Add stlport source module to the NDK.
See README file to see how to use it, or build+run the unit-test program.
Change-Id: Ifd09580b2ffbc3bfa268282712dbd0d9330fdb9b
diff --git a/docs/CHANGES.TXT b/docs/CHANGES.TXT
index 127782e..c65dd1a 100644
--- a/docs/CHANGES.TXT
+++ b/docs/CHANGES.TXT
@@ -130,6 +130,10 @@
The binaries for the already-deprecated gcc-4.2.1 have been removed.
+- This NDK comes with a port of the STLport library, provided as an import
+ module. See sources/android/stlport/README for usage instructions.
+
+ Warning: C++ exceptions and RTTI are still not supported.
- The 'cpufeatures' library has been updated to provide better architecture
and features detection (including a work-around for buggy ARMv6 kernels
diff --git a/sources/android/stlport/Android.mk b/sources/android/stlport/Android.mk
new file mode 100644
index 0000000..0f9b38e
--- /dev/null
+++ b/sources/android/stlport/Android.mk
@@ -0,0 +1,59 @@
+LOCAL_PATH := $(call my-dir)
+
+libstlport_path := $(call my-dir)
+
+libstlport_src_files := \
+ src/dll_main.cpp \
+ src/fstream.cpp \
+ src/strstream.cpp \
+ src/sstream.cpp \
+ src/ios.cpp \
+ src/stdio_streambuf.cpp \
+ src/istream.cpp \
+ src/ostream.cpp \
+ src/iostream.cpp \
+ src/codecvt.cpp \
+ src/collate.cpp \
+ src/ctype.cpp \
+ src/monetary.cpp \
+ src/num_get.cpp \
+ src/num_put.cpp \
+ src/num_get_float.cpp \
+ src/num_put_float.cpp \
+ src/numpunct.cpp \
+ src/time_facets.cpp \
+ src/messages.cpp \
+ src/locale.cpp \
+ src/locale_impl.cpp \
+ src/locale_catalog.cpp \
+ src/facets_byname.cpp \
+ src/complex.cpp \
+ src/complex_io.cpp \
+ src/complex_trig.cpp \
+ src/string.cpp \
+ src/bitset.cpp \
+ src/allocators.cpp \
+ src/c_locale.c \
+ src/cxa.c \
+
+libstlport_cflags := -D_GNU_SOURCE
+libstlport_cppflags := -fuse-cxa-atexit
+libstlport_c_includes := $(libstlport_path)/stlport
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := stlport_static
+LOCAL_SRC_FILES := $(libstlport_src_files)
+LOCAL_CFLAGS := $(libstlport_cflags)
+LOCAL_CPPFLAGS := $(libstlport_cppflags)
+LOCAL_C_INCLUDES := $(libstlport_c_includes)
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_C_INCLUDES)
+include $(BUILD_STATIC_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := stlport_shared
+LOCAL_SRC_FILES := $(libstlport_src_files)
+LOCAL_CFLAGS := $(libstlport_cflags)
+LOCAL_CPPFLAGS := $(libstlport_cppflags)
+LOCAL_C_INCLUDES := $(libstlport_c_includes)
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_C_INCLUDES)
+include $(BUILD_SHARED_LIBRARY)
diff --git a/sources/android/stlport/LICENSE b/sources/android/stlport/LICENSE
new file mode 100644
index 0000000..6846270
--- /dev/null
+++ b/sources/android/stlport/LICENSE
@@ -0,0 +1,27 @@
+Boris Fomitchev grants Licensee a non-exclusive, non-transferable, royalty-free license to use STLport and its documentation without fee.
+
+By downloading, using, or copying STLport or any portion thereof, Licensee agrees to abide by the intellectual property laws and all other applicable laws of the United States of America, and to all of the terms and conditions of this Agreement.
+
+Licensee shall maintain the following copyright and permission notices on STLport sources and its documentation unchanged :
+
+Copyright 1999,2000 Boris Fomitchev
+
+This material is provided "as is", with absolutely no warranty expressed or implied. Any use is at your own risk.
+Permission to use or copy this software for any purpose is hereby granted without fee, provided the above notices are retained on all copies. Permission to modify the code and to distribute modified code is granted, provided the above notices are retained, and a notice that the code was modified is included with the above copyright notice.
+The Licensee may distribute binaries compiled with STLport (whether original or modified) without any royalties or restrictions.
+
+The Licensee may distribute original or modified STLport sources, provided that:
+
+The conditions indicated in the above permission notice are met;
+The following copyright notices are retained when present, and conditions provided in accompanying permission notices are met :
+Copyright 1994 Hewlett-Packard Company
+
+Copyright 1996,97 Silicon Graphics Computer Systems, Inc.
+
+Copyright 1997 Moscow Center for SPARC Technology.
+
+Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. Hewlett-Packard Company makes no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty.
+
+Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. Silicon Graphics makes no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty.
+
+Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. Moscow Center for SPARC Technology makes no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty.
diff --git a/sources/android/stlport/MODULE_LICENSE_BSD_LIKE b/sources/android/stlport/MODULE_LICENSE_BSD_LIKE
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/sources/android/stlport/MODULE_LICENSE_BSD_LIKE
diff --git a/sources/android/stlport/README b/sources/android/stlport/README
new file mode 100644
index 0000000..0a6dbb4
--- /dev/null
+++ b/sources/android/stlport/README
@@ -0,0 +1,77 @@
+STLport for Android
+
+WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+
+ This feature is currently in beta. In case of issue
+ please contact the android-ndk support forum or
+ file bugs at http://b.android.com
+
+WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+
+This directory contains a port of STLport for Android, which provides
+a simple STL implementation. Note that it currently does not support
+C++ exceptions and RTTI. Support for wchar_t and locales is probably buggy.
+
+You can either use it as a static or shared library.
+
+1/ The static library is recommended if you will only produce
+ one shared library for your project. All necessary STLport functions
+ will be added to it. This option should also generate smaller
+ overall binaries.
+
+2/ The shared library, is recommended if you want to produce
+ several shared libraries in your project, because it avoids copying the
+ same STLport functions to each one of them, and having different instances
+ of the same global variables (which can easily conflict or result in
+ undefined behaviour).
+
+To use the *static* library, do the following:
+
+ a. Add 'stlport_static' to your module's LOCAL_STATIC_LIBRARIES
+ variable.
+
+ b. At the end of your Android.mk, import the module with:
+
+ $(call import-module,android/stlport)
+
+
+To use the *shared* library, do the following:
+
+ a. Add 'stlport_shared' to your module's LOCAL_SHARED_LIBRARIES
+ variable.
+
+ b. At the end of your Android.mk, import them module with
+ the same line described above for the static case.
+
+Note that you will need, in your application, to explicitely load
+the 'stlport_shared' library before any library that depends on it.
+For example:
+
+ static {
+ System.loadLibrary("stlport_shared");
+ System.loadLibrary("foo");
+ System.loadLibrary("bar");
+ }
+
+If both libfoo.so and libbar.so depend on STLport.
+
+You can build the STLport unit test program by doing the following:
+
+ cd $NDK/sources/android/stlport/test
+ $NDK/ndk-build
+
+This generates a standalone executable under libs/armeabi/test_stlport.
+Note that it must be run in a writable directory (it needs to write then
+read a few files). Here's an example on how to run it:
+
+ adb push libs/armeabi/test_stlport /data/local/
+ adb shell chmod 755 /data/local/test_stlport
+ adb shell 'cd /data/local; test_stlport'
+
+Note that a few unit tests fail at the moment, they should hopefully
+fixed in a later release of this library.
+
+VERSION INFORMATION: This module is based on STLport version 5.x.y (TODO)
+
diff --git a/sources/android/stlport/README.android b/sources/android/stlport/README.android
new file mode 100644
index 0000000..a35c955
--- /dev/null
+++ b/sources/android/stlport/README.android
@@ -0,0 +1,9 @@
+Version: 5.2.1
+
+Changes:
+ * Added _android.h included by _system.h
+ * Do not use linux float functions in num_get_float.cpp as Android does not
+ have them.
+ * _mbstate_t.h cannot define its own mbstate_t as bionic already defines
+ it.
+ * _pair.h needs to define bionic's (sgi's) internal pair header guard.
diff --git a/sources/android/stlport/README.original b/sources/android/stlport/README.original
new file mode 100644
index 0000000..a759495
--- /dev/null
+++ b/sources/android/stlport/README.original
@@ -0,0 +1,64 @@
+**********************************************************************
+* README file for STLport 5.0 *
+* *
+**********************************************************************
+
+This directory contains the STLport-5.0 release.
+
+What's inside :
+
+README - this file
+INSTALL - installation instructions
+
+bin - installation directory for STLport unit tests;
+ it may contain more subdirs, if you use
+ crosscompilation
+build/lib - build directory for STLport library (if you use
+ STLport iostreams and/or locale only)
+build/test/unit - build directory for regression (unit) tests
+build/test/eh - build directory for exception handling tests
+stlport - main STLport include directory
+src - source for iostreams implementation and other parts
+ that aren't pure template code
+lib - installation directory for STLport library (if you
+ use STLport iostreams and/or locale only);
+ it may contain more subdirs, if you use
+ crosscompilation
+test/unit - unit (regression) tests
+test/eh - exception handling test using STLport iostreams
+etc - miscellanous files (ChangeLog, TODO, scripts, etc.)
+
+GETTING STLPORT
+
+To download the latest version of STLport, please be sure to visit
+https://sourceforge.net/project/showfiles.php?group_id=146814
+
+LEGALESE
+
+This software is being distributed under the following terms:
+
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999-2003
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+
+**********************************************************************
diff --git a/sources/android/stlport/src/_stdio_file.h b/sources/android/stlport/src/_stdio_file.h
new file mode 100644
index 0000000..d913fc4
--- /dev/null
+++ b/sources/android/stlport/src/_stdio_file.h
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STDIO_FILE_H
+#define _STLP_STDIO_FILE_H
+
+/* This file provides a low-level interface between the internal
+ * representation of struct FILE, from the C stdio library, and
+ * the C++ I/O library. */
+
+#ifndef _STLP_CSTDIO
+# include <cstdio>
+#endif
+#ifndef _STLP_CSTDDEF
+# include <cstddef>
+#endif
+
+#if defined (__MSL__)
+# include <unix.h> /* get the definition of fileno */
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_WCE)
+
+inline int _FILE_fd(const FILE *__f) {
+ /* Check if FILE is one of the three standard streams
+ We do this check first, because invoking _fileno() on one of them
+ causes a terminal window to be created. This also happens if you do
+ any IO on them, but merely retrieving the filedescriptor shouldn't
+ already do that.
+
+ Obviously this is pretty implementation-specific because it requires
+ that indeed the first three FDs are always the same, but that is not
+ only common but almost guaranteed. */
+ for (int __fd = 0; __fd != 3; ++__fd) {
+ if (__f == _getstdfilex(__fd))
+ return __fd;
+ }
+
+ /* Normal files. */
+ return (int)::_fileno((FILE*)__f);
+}
+
+# elif defined (_STLP_SCO_OPENSERVER) || defined (__NCR_SVR)
+
+inline int _FILE_fd(const FILE *__f) { return __f->__file; }
+
+# elif defined (__sun) && defined (_LP64)
+
+inline int _FILE_fd(const FILE *__f) { return (int) __f->__pad[2]; }
+
+#elif defined (__hpux) /* && defined(__hppa) && defined(__HP_aCC)) */ || \
+ defined (__MVS__) || \
+ defined (_STLP_USE_UCLIBC) /* should be before _STLP_USE_GLIBC */
+
+inline int _FILE_fd(const FILE *__f) { return fileno(__CONST_CAST(FILE*, __f)); }
+
+#elif defined (_STLP_USE_GLIBC)
+
+inline int _FILE_fd(const FILE *__f) { return __f->_fileno; }
+
+#elif defined (__BORLANDC__)
+
+inline int _FILE_fd(const FILE *__f) { return __f->fd; }
+
+#elif defined (__MWERKS__)
+
+/* using MWERKS-specific defines here to detect other OS targets
+ * dwa: I'm not sure they provide fileno for all OS's, but this should
+ * work for Win32 and WinCE
+
+ * Hmm, at least for Novell NetWare __dest_os == __mac_os true too..
+ * May be both __dest_os and __mac_os defined and empty? - ptr */
+# if __dest_os == __mac_os
+inline int _FILE_fd(const FILE *__f) { return ::fileno(__CONST_CAST(FILE*, __f)); }
+# else
+inline int _FILE_fd(const FILE *__f) { return ::_fileno(__CONST_CAST(FILE*, __f)); }
+# endif
+
+#elif defined (__QNXNTO__) || defined (__WATCOMC__) || defined (__EMX__)
+
+inline int _FILE_fd(const FILE *__f) { return __f->_handle; }
+
+#elif defined (__Lynx__)
+
+/* the prototypes are taken from LynxOS patch for STLport 4.0 */
+inline int _FILE_fd(const FILE *__f) { return __f->_fd; }
+
+#else /* The most common access to file descriptor. */
+
+inline int _FILE_fd(const FILE *__f) { return __f->_file; }
+
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_STDIO_FILE_H */
+
+/* Local Variables:
+ * mode:C++
+ * End: */
diff --git a/sources/android/stlport/src/acquire_release.h b/sources/android/stlport/src/acquire_release.h
new file mode 100644
index 0000000..5ea73da
--- /dev/null
+++ b/sources/android/stlport/src/acquire_release.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef ACQUIRE_RELEASE_H
+#define ACQUIRE_RELEASE_H
+
+#include "c_locale.h"
+
+_STLP_BEGIN_NAMESPACE
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+_Locale_ctype* _STLP_CALL __acquire_ctype(const char* &name, char *buf, _Locale_name_hint* hint, int *__err_code);
+_Locale_codecvt* _STLP_CALL __acquire_codecvt(const char* &name, char *buf, _Locale_name_hint* hint, int *__err_code);
+_Locale_numeric* _STLP_CALL __acquire_numeric(const char* &name, char *buf, _Locale_name_hint* hint, int *__err_code);
+_Locale_collate* _STLP_CALL __acquire_collate(const char* &name, char *buf, _Locale_name_hint* hint, int *__err_code);
+_Locale_monetary* _STLP_CALL __acquire_monetary(const char* &name, char *buf, _Locale_name_hint* hint, int *__err_code);
+_Locale_time* _STLP_CALL __acquire_time(const char* &name, char *buf, _Locale_name_hint*, int *__err_code);
+_Locale_messages* _STLP_CALL __acquire_messages(const char* &name, char *buf, _Locale_name_hint* hint, int *__err_code);
+
+void _STLP_CALL __release_ctype(_Locale_ctype* cat);
+void _STLP_CALL __release_codecvt(_Locale_codecvt* cat);
+void _STLP_CALL __release_numeric(_Locale_numeric* cat);
+void _STLP_CALL __release_collate(_Locale_collate* cat);
+void _STLP_CALL __release_monetary(_Locale_monetary* cat);
+void _STLP_CALL __release_time(_Locale_time* __time);
+void _STLP_CALL __release_messages(_Locale_messages* cat);
+
+_STLP_MOVE_TO_STD_NAMESPACE
+_STLP_END_NAMESPACE
+
+#endif /* ACQUIRE_RELEASE_H */
diff --git a/sources/android/stlport/src/aligned_buffer.h b/sources/android/stlport/src/aligned_buffer.h
new file mode 100644
index 0000000..6ff6ca6
--- /dev/null
+++ b/sources/android/stlport/src/aligned_buffer.h
@@ -0,0 +1,21 @@
+#ifndef ALIGNED_BUFFER_H
+#define ALIGNED_BUFFER_H
+
+_STLP_BEGIN_NAMESPACE
+// this is for fake initialization
+template<class T>
+union _Stl_aligned_buffer {
+ char buf[sizeof(T)];
+ struct { double a; double b; } padding;
+
+ T* operator&() {
+ return __REINTERPRET_CAST(T*, this);
+ }
+
+ T const* operator&() const {
+ return __REINTERPRET_CAST(T const*, this);
+ }
+};
+_STLP_END_NAMESPACE
+
+#endif
diff --git a/sources/android/stlport/src/allocators.cpp b/sources/android/stlport/src/allocators.cpp
new file mode 100644
index 0000000..8bbcca8
--- /dev/null
+++ b/sources/android/stlport/src/allocators.cpp
@@ -0,0 +1,1121 @@
+/*
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#include "stlport_prefix.h"
+
+#include <memory>
+
+#if defined (__GNUC__) && (defined (__CYGWIN__) || defined (__MINGW32__))
+# include <malloc.h>
+#endif
+
+#if defined (_STLP_PTHREADS) && !defined (_STLP_NO_THREADS)
+# include <pthread_alloc>
+# include <cerrno>
+#endif
+
+#include <stl/_threads.h>
+
+#include "lock_free_slist.h"
+
+#if defined (__WATCOMC__)
+# pragma warning 13 9
+# pragma warning 367 9
+# pragma warning 368 9
+#endif
+
+#if defined (_STLP_SGI_THREADS)
+ // We test whether threads are in use before locking.
+ // Perhaps this should be moved into stl_threads.h, but that
+ // probably makes it harder to avoid the procedure call when
+ // it isn't needed.
+extern "C" {
+ extern int __us_rsthread_malloc;
+}
+#endif
+
+// Specialised debug form of new operator which does not provide "false"
+// memory leaks when run with debug CRT libraries.
+#if defined (_STLP_MSVC) && (_STLP_MSVC >= 1020 && defined (_STLP_DEBUG_ALLOC)) && !defined (_STLP_WCE)
+# include <crtdbg.h>
+inline char* __stlp_new_chunk(size_t __bytes) {
+ void *__chunk = _STLP_CHECK_NULL_ALLOC(::operator new(__bytes, __FILE__, __LINE__));
+ return __STATIC_CAST(char*, __chunk);
+}
+inline void __stlp_delete_chunck(void* __p) { ::operator delete(__p, __FILE__, __LINE__); }
+#else
+# ifdef _STLP_NODE_ALLOC_USE_MALLOC
+# include <cstdlib>
+inline char* __stlp_new_chunk(size_t __bytes) {
+ // do not use _STLP_CHECK_NULL_ALLOC, this macro is dedicated to new operator.
+ void *__chunk = _STLP_VENDOR_CSTD::malloc(__bytes);
+ if (__chunk == 0) {
+ _STLP_THROW_BAD_ALLOC;
+ }
+ return __STATIC_CAST(char*, __chunk);
+}
+inline void __stlp_delete_chunck(void* __p) { _STLP_VENDOR_CSTD::free(__p); }
+# else
+inline char* __stlp_new_chunk(size_t __bytes)
+{ return __STATIC_CAST(char*, _STLP_STD::__stl_new(__bytes)); }
+inline void __stlp_delete_chunck(void* __p) { _STLP_STD::__stl_delete(__p); }
+# endif
+#endif
+
+/* This is an additional atomic operations to the ones already defined in
+ * stl/_threads.h, platform should try to support it to improve performance.
+ * __add_atomic_t _STLP_ATOMIC_ADD(volatile __add_atomic_t* __target, __add_atomic_t __val) :
+ * does *__target = *__target + __val and returns the old *__target value */
+typedef long __add_atomic_t;
+typedef unsigned long __uadd_atomic_t;
+
+#if defined (__GNUC__) && defined (__i386__)
+inline long _STLP_atomic_add_gcc_x86(long volatile* p, long addend) {
+ long result;
+ __asm__ __volatile__
+ ("lock; xaddl %1, %0;"
+ :"=m" (*p), "=r" (result)
+ :"m" (*p), "1" (addend)
+ :"cc");
+ return result + addend;
+}
+# define _STLP_ATOMIC_ADD(__dst, __val) _STLP_atomic_add_gcc_x86(__dst, __val)
+#elif defined (_STLP_WIN32THREADS)
+// The Win32 API function InterlockedExchangeAdd is not available on Windows 95.
+# if !defined (_STLP_WIN95_LIKE)
+# if defined (_STLP_NEW_PLATFORM_SDK)
+# define _STLP_ATOMIC_ADD(__dst, __val) InterlockedExchangeAdd(__dst, __val)
+# else
+# define _STLP_ATOMIC_ADD(__dst, __val) InterlockedExchangeAdd(__CONST_CAST(__add_atomic_t*, __dst), __val)
+# endif
+# endif
+#endif
+
+#if defined (__OS400__)
+// dums 02/05/2007: is it really necessary ?
+enum { _ALIGN = 16, _ALIGN_SHIFT = 4 };
+#else
+enum { _ALIGN = 2 * sizeof(void*), _ALIGN_SHIFT = 2 + sizeof(void*) / 4 };
+#endif
+
+#define _S_FREELIST_INDEX(__bytes) ((__bytes - size_t(1)) >> (int)_ALIGN_SHIFT)
+
+_STLP_BEGIN_NAMESPACE
+
+// malloc_alloc out-of-memory handling
+static __oom_handler_type __oom_handler = __STATIC_CAST(__oom_handler_type, 0);
+
+#ifdef _STLP_THREADS
+_STLP_mutex __oom_handler_lock;
+#endif
+
+void* _STLP_CALL __malloc_alloc::allocate(size_t __n)
+{
+ void *__result = malloc(__n);
+ if ( 0 == __result ) {
+ __oom_handler_type __my_malloc_handler;
+
+ for (;;) {
+ {
+#ifdef _STLP_THREADS
+ _STLP_auto_lock _l( __oom_handler_lock );
+#endif
+ __my_malloc_handler = __oom_handler;
+ }
+ if ( 0 == __my_malloc_handler) {
+ _STLP_THROW_BAD_ALLOC;
+ }
+ (*__my_malloc_handler)();
+ __result = malloc(__n);
+ if ( __result )
+ return __result;
+ }
+ }
+ return __result;
+}
+
+__oom_handler_type _STLP_CALL __malloc_alloc::set_malloc_handler(__oom_handler_type __f)
+{
+#ifdef _STLP_THREADS
+ _STLP_auto_lock _l( __oom_handler_lock );
+#endif
+ __oom_handler_type __old = __oom_handler;
+ __oom_handler = __f;
+ return __old;
+}
+
+// *******************************************************
+// Default node allocator.
+// With a reasonable compiler, this should be roughly as fast as the
+// original STL class-specific allocators, but with less fragmentation.
+//
+// Important implementation properties:
+// 1. If the client request an object of size > _MAX_BYTES, the resulting
+// object will be obtained directly from malloc.
+// 2. In all other cases, we allocate an object of size exactly
+// _S_round_up(requested_size). Thus the client has enough size
+// information that we can return the object to the proper free list
+// without permanently losing part of the object.
+//
+
+#define _STLP_NFREELISTS 16
+
+#if defined (_STLP_LEAKS_PEDANTIC) && defined (_STLP_USE_DYNAMIC_LIB)
+/*
+ * We can only do cleanup of the node allocator memory pool if we are
+ * sure that the STLport library is used as a shared one as it guaranties
+ * the unicity of the node allocator instance. Without that guaranty node
+ * allocator instances might exchange memory blocks making the implementation
+ * of a cleaning process much more complicated.
+ */
+# define _STLP_DO_CLEAN_NODE_ALLOC
+#endif
+
+/* When STLport is used without multi threaded safety we use the node allocator
+ * implementation with locks as locks becomes no-op. The lock free implementation
+ * always use system specific atomic operations which are slower than 'normal'
+ * ones.
+ */
+#if defined (_STLP_THREADS) && \
+ defined (_STLP_HAS_ATOMIC_FREELIST) && defined (_STLP_ATOMIC_ADD)
+/*
+ * We have an implementation of the atomic freelist (_STLP_atomic_freelist)
+ * for this architecture and compiler. That means we can use the non-blocking
+ * implementation of the node-allocation engine.*/
+# define _STLP_USE_LOCK_FREE_IMPLEMENTATION
+#endif
+
+#if !defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
+# if defined (_STLP_THREADS)
+
+class _Node_Alloc_Lock {
+ static _STLP_STATIC_MUTEX& _S_Mutex() {
+ static _STLP_STATIC_MUTEX mutex _STLP_MUTEX_INITIALIZER;
+ return mutex;
+ }
+public:
+ _Node_Alloc_Lock() {
+# if defined (_STLP_SGI_THREADS)
+ if (__us_rsthread_malloc)
+# endif
+ _S_Mutex()._M_acquire_lock();
+ }
+
+ ~_Node_Alloc_Lock() {
+# if defined (_STLP_SGI_THREADS)
+ if (__us_rsthread_malloc)
+# endif
+ _S_Mutex()._M_release_lock();
+ }
+};
+
+# else
+
+class _Node_Alloc_Lock {
+public:
+ _Node_Alloc_Lock() { }
+ ~_Node_Alloc_Lock() { }
+};
+
+# endif
+
+struct _Node_alloc_obj {
+ _Node_alloc_obj * _M_next;
+};
+#endif
+
+class __node_alloc_impl {
+ static inline size_t _STLP_CALL _S_round_up(size_t __bytes)
+ { return (((__bytes) + (size_t)_ALIGN-1) & ~((size_t)_ALIGN - 1)); }
+
+#if defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
+ typedef _STLP_atomic_freelist::item _Obj;
+ typedef _STLP_atomic_freelist _Freelist;
+ typedef _STLP_atomic_freelist _ChunkList;
+
+ // Header of blocks of memory that have been allocated as part of
+ // a larger chunk but have not yet been chopped up into nodes.
+ struct _FreeBlockHeader : public _STLP_atomic_freelist::item {
+ char* _M_end; // pointer to end of free memory
+ };
+#else
+ typedef _Node_alloc_obj _Obj;
+ typedef _Obj* _STLP_VOLATILE _Freelist;
+ typedef _Obj* _ChunkList;
+#endif
+
+private:
+ // Returns an object of size __n, and optionally adds to size __n free list.
+ static _Obj* _S_refill(size_t __n);
+ // Allocates a chunk for nobjs of size __p_size. nobjs may be reduced
+ // if it is inconvenient to allocate the requested number.
+ static char* _S_chunk_alloc(size_t __p_size, int& __nobjs);
+ // Chunk allocation state.
+ static _Freelist _S_free_list[_STLP_NFREELISTS];
+ // Amount of total allocated memory
+#if defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
+ static _STLP_VOLATILE __add_atomic_t _S_heap_size;
+#else
+ static size_t _S_heap_size;
+#endif
+
+#if defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
+ // List of blocks of free memory
+ static _STLP_atomic_freelist _S_free_mem_blocks;
+#else
+ // Start of the current free memory buffer
+ static char* _S_start_free;
+ // End of the current free memory buffer
+ static char* _S_end_free;
+#endif
+
+#if defined (_STLP_DO_CLEAN_NODE_ALLOC)
+public:
+ // Methods to report alloc/dealloc calls to the counter system.
+# if defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
+ typedef _STLP_VOLATILE __stl_atomic_t _AllocCounter;
+# else
+ typedef __stl_atomic_t _AllocCounter;
+# endif
+ static _AllocCounter& _STLP_CALL _S_alloc_counter();
+ static void _S_alloc_call();
+ static void _S_dealloc_call();
+
+private:
+ // Free all the allocated chuncks of memory
+ static void _S_chunk_dealloc();
+ // Beginning of the linked list of allocated chunks of memory
+ static _ChunkList _S_chunks;
+#endif /* _STLP_DO_CLEAN_NODE_ALLOC */
+
+public:
+ /* __n must be > 0 */
+ static void* _M_allocate(size_t& __n);
+ /* __p may not be 0 */
+ static void _M_deallocate(void *__p, size_t __n);
+};
+
+#if !defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
+void* __node_alloc_impl::_M_allocate(size_t& __n) {
+ __n = _S_round_up(__n);
+ _Obj * _STLP_VOLATILE * __my_free_list = _S_free_list + _S_FREELIST_INDEX(__n);
+ _Obj *__r;
+
+ // Acquire the lock here with a constructor call.
+ // This ensures that it is released in exit or during stack
+ // unwinding.
+ _Node_Alloc_Lock __lock_instance;
+
+ if ( (__r = *__my_free_list) != 0 ) {
+ *__my_free_list = __r->_M_next;
+ } else {
+ __r = _S_refill(__n);
+ }
+# if defined (_STLP_DO_CLEAN_NODE_ALLOC)
+ _S_alloc_call();
+# endif
+ // lock is released here
+ return __r;
+}
+
+void __node_alloc_impl::_M_deallocate(void *__p, size_t __n) {
+ _Obj * _STLP_VOLATILE * __my_free_list = _S_free_list + _S_FREELIST_INDEX(__n);
+ _Obj * __pobj = __STATIC_CAST(_Obj*, __p);
+
+ // acquire lock
+ _Node_Alloc_Lock __lock_instance;
+ __pobj->_M_next = *__my_free_list;
+ *__my_free_list = __pobj;
+
+# if defined (_STLP_DO_CLEAN_NODE_ALLOC)
+ _S_dealloc_call();
+# endif
+ // lock is released here
+}
+
+# if defined (_STLP_DO_CLEAN_NODE_ALLOC)
+# define _STLP_OFFSET sizeof(_Obj)
+# else
+# define _STLP_OFFSET 0
+# endif
+
+/* We allocate memory in large chunks in order to avoid fragmenting */
+/* the malloc heap too much. */
+/* We assume that size is properly aligned. */
+/* We hold the allocation lock. */
+char* __node_alloc_impl::_S_chunk_alloc(size_t _p_size, int& __nobjs) {
+ char* __result;
+ size_t __total_bytes = _p_size * __nobjs;
+ size_t __bytes_left = _S_end_free - _S_start_free;
+
+ if (__bytes_left > 0) {
+ if (__bytes_left >= __total_bytes) {
+ __result = _S_start_free;
+ _S_start_free += __total_bytes;
+ return __result;
+ }
+
+ if (__bytes_left >= _p_size) {
+ __nobjs = (int)(__bytes_left / _p_size);
+ __total_bytes = _p_size * __nobjs;
+ __result = _S_start_free;
+ _S_start_free += __total_bytes;
+ return __result;
+ }
+
+ // Try to make use of the left-over piece.
+ _Obj* _STLP_VOLATILE* __my_free_list = _S_free_list + _S_FREELIST_INDEX(__bytes_left);
+ __REINTERPRET_CAST(_Obj*, _S_start_free)->_M_next = *__my_free_list;
+ *__my_free_list = __REINTERPRET_CAST(_Obj*, _S_start_free);
+ _S_start_free = _S_end_free = 0;
+ }
+
+ size_t __bytes_to_get = 2 * __total_bytes + _S_round_up(_S_heap_size) + _STLP_OFFSET;
+
+ _STLP_TRY {
+ _S_start_free = __stlp_new_chunk(__bytes_to_get);
+ }
+#if defined (_STLP_USE_EXCEPTIONS)
+ catch (const _STLP_STD::bad_alloc&) {
+ _Obj* _STLP_VOLATILE* __my_free_list;
+ _Obj* __p;
+ // Try to do with what we have. That can't hurt.
+ // We do not try smaller requests, since that tends
+ // to result in disaster on multi-process machines.
+ for (size_t __i = _p_size; __i <= (size_t)_MAX_BYTES; __i += (size_t)_ALIGN) {
+ __my_free_list = _S_free_list + _S_FREELIST_INDEX(__i);
+ __p = *__my_free_list;
+ if (0 != __p) {
+ *__my_free_list = __p -> _M_next;
+ _S_start_free = __REINTERPRET_CAST(char*, __p);
+ _S_end_free = _S_start_free + __i;
+ return _S_chunk_alloc(_p_size, __nobjs);
+ // Any leftover piece will eventually make it to the
+ // right free list.
+ }
+ }
+ __bytes_to_get = __total_bytes + _STLP_OFFSET;
+ _S_start_free = __stlp_new_chunk(__bytes_to_get);
+ }
+#endif
+
+ _S_heap_size += __bytes_to_get >> 4;
+# if defined (_STLP_DO_CLEAN_NODE_ALLOC)
+ __REINTERPRET_CAST(_Obj*, _S_start_free)->_M_next = _S_chunks;
+ _S_chunks = __REINTERPRET_CAST(_Obj*, _S_start_free);
+# endif
+ _S_end_free = _S_start_free + __bytes_to_get;
+ _S_start_free += _STLP_OFFSET;
+ return _S_chunk_alloc(_p_size, __nobjs);
+}
+
+/* Returns an object of size __n, and optionally adds to size __n free list.*/
+/* We assume that __n is properly aligned. */
+/* We hold the allocation lock. */
+_Node_alloc_obj* __node_alloc_impl::_S_refill(size_t __n) {
+ int __nobjs = 20;
+ char* __chunk = _S_chunk_alloc(__n, __nobjs);
+
+ if (1 == __nobjs) return __REINTERPRET_CAST(_Obj*, __chunk);
+
+ _Obj* _STLP_VOLATILE* __my_free_list = _S_free_list + _S_FREELIST_INDEX(__n);
+ _Obj* __result;
+ _Obj* __current_obj;
+ _Obj* __next_obj;
+
+ /* Build free list in chunk */
+ __result = __REINTERPRET_CAST(_Obj*, __chunk);
+ *__my_free_list = __next_obj = __REINTERPRET_CAST(_Obj*, __chunk + __n);
+ for (--__nobjs; --__nobjs; ) {
+ __current_obj = __next_obj;
+ __next_obj = __REINTERPRET_CAST(_Obj*, __REINTERPRET_CAST(char*, __next_obj) + __n);
+ __current_obj->_M_next = __next_obj;
+ }
+ __next_obj->_M_next = 0;
+ return __result;
+}
+
+# if defined (_STLP_DO_CLEAN_NODE_ALLOC)
+void __node_alloc_impl::_S_alloc_call()
+{ ++_S_alloc_counter(); }
+
+void __node_alloc_impl::_S_dealloc_call() {
+ __stl_atomic_t &counter = _S_alloc_counter();
+ if (--counter == 0)
+ { _S_chunk_dealloc(); }
+}
+
+/* We deallocate all the memory chunks */
+void __node_alloc_impl::_S_chunk_dealloc() {
+ _Obj *__pcur = _S_chunks, *__pnext;
+ while (__pcur != 0) {
+ __pnext = __pcur->_M_next;
+ __stlp_delete_chunck(__pcur);
+ __pcur = __pnext;
+ }
+ _S_chunks = 0;
+ _S_start_free = _S_end_free = 0;
+ _S_heap_size = 0;
+ memset(__REINTERPRET_CAST(char*, __CONST_CAST(_Obj**, &_S_free_list[0])), 0, _STLP_NFREELISTS * sizeof(_Obj*));
+}
+# endif
+
+#else
+
+void* __node_alloc_impl::_M_allocate(size_t& __n) {
+ __n = _S_round_up(__n);
+ _Obj* __r = _S_free_list[_S_FREELIST_INDEX(__n)].pop();
+ if (__r == 0)
+ { __r = _S_refill(__n); }
+
+# if defined (_STLP_DO_CLEAN_NODE_ALLOC)
+ _S_alloc_call();
+# endif
+ return __r;
+}
+
+void __node_alloc_impl::_M_deallocate(void *__p, size_t __n) {
+ _S_free_list[_S_FREELIST_INDEX(__n)].push(__STATIC_CAST(_Obj*, __p));
+
+# if defined (_STLP_DO_CLEAN_NODE_ALLOC)
+ _S_dealloc_call();
+# endif
+}
+
+/* Returns an object of size __n, and optionally adds additional ones to */
+/* freelist of objects of size __n. */
+/* We assume that __n is properly aligned. */
+__node_alloc_impl::_Obj* __node_alloc_impl::_S_refill(size_t __n) {
+ int __nobjs = 20;
+ char* __chunk = _S_chunk_alloc(__n, __nobjs);
+
+ if (__nobjs <= 1)
+ return __REINTERPRET_CAST(_Obj*, __chunk);
+
+ // Push all new nodes (minus first one) onto freelist
+ _Obj* __result = __REINTERPRET_CAST(_Obj*, __chunk);
+ _Obj* __cur_item = __result;
+ _Freelist* __my_freelist = _S_free_list + _S_FREELIST_INDEX(__n);
+ for (--__nobjs; __nobjs != 0; --__nobjs) {
+ __cur_item = __REINTERPRET_CAST(_Obj*, __REINTERPRET_CAST(char*, __cur_item) + __n);
+ __my_freelist->push(__cur_item);
+ }
+ return __result;
+}
+
+# if defined (_STLP_DO_CLEAN_NODE_ALLOC)
+# define _STLP_OFFSET _ALIGN
+# else
+# define _STLP_OFFSET 0
+# endif
+
+/* We allocate memory in large chunks in order to avoid fragmenting */
+/* the malloc heap too much. */
+/* We assume that size is properly aligned. */
+char* __node_alloc_impl::_S_chunk_alloc(size_t _p_size, int& __nobjs) {
+# if defined (_STLP_DO_CLEAN_NODE_ALLOC)
+ //We are going to add a small memory block to keep all the allocated blocks
+ //address, we need to do so respecting the memory alignment. The following
+ //static assert checks that the reserved block is big enough to store a pointer.
+ _STLP_STATIC_ASSERT(sizeof(_Obj) <= _ALIGN)
+# endif
+ char* __result = 0;
+ __add_atomic_t __total_bytes = __STATIC_CAST(__add_atomic_t, _p_size) * __nobjs;
+
+ _FreeBlockHeader* __block = __STATIC_CAST(_FreeBlockHeader*, _S_free_mem_blocks.pop());
+ if (__block != 0) {
+ // We checked a block out and can now mess with it with impugnity.
+ // We'll put the remainder back into the list if we're done with it below.
+ char* __buf_start = __REINTERPRET_CAST(char*, __block);
+ __add_atomic_t __bytes_left = __block->_M_end - __buf_start;
+
+ if ((__bytes_left < __total_bytes) && (__bytes_left >= __STATIC_CAST(__add_atomic_t, _p_size))) {
+ // There's enough left for at least one object, but not as much as we wanted
+ __result = __buf_start;
+ __nobjs = (int)(__bytes_left/_p_size);
+ __total_bytes = __STATIC_CAST(__add_atomic_t, _p_size) * __nobjs;
+ __bytes_left -= __total_bytes;
+ __buf_start += __total_bytes;
+ }
+ else if (__bytes_left >= __total_bytes) {
+ // The block has enough left to satisfy all that was asked for
+ __result = __buf_start;
+ __bytes_left -= __total_bytes;
+ __buf_start += __total_bytes;
+ }
+
+ if (__bytes_left != 0) {
+ // There is still some memory left over in block after we satisfied our request.
+ if ((__result != 0) && (__bytes_left >= (__add_atomic_t)sizeof(_FreeBlockHeader))) {
+ // We were able to allocate at least one object and there is still enough
+ // left to put remainder back into list.
+ _FreeBlockHeader* __newblock = __REINTERPRET_CAST(_FreeBlockHeader*, __buf_start);
+ __newblock->_M_end = __block->_M_end;
+ _S_free_mem_blocks.push(__newblock);
+ }
+ else {
+ // We were not able to allocate enough for at least one object.
+ // Shove into freelist of nearest (rounded-down!) size.
+ size_t __rounded_down = _S_round_up(__bytes_left + 1) - (size_t)_ALIGN;
+ if (__rounded_down > 0)
+ _S_free_list[_S_FREELIST_INDEX(__rounded_down)].push((_Obj*)__buf_start);
+ }
+ }
+ if (__result != 0)
+ return __result;
+ }
+
+ // We couldn't satisfy it from the list of free blocks, get new memory.
+ __add_atomic_t __bytes_to_get = 2 * __total_bytes +
+ __STATIC_CAST(__add_atomic_t,
+ _S_round_up(__STATIC_CAST(__uadd_atomic_t, _STLP_ATOMIC_ADD(&_S_heap_size, 0)))) +
+ _STLP_OFFSET;
+ _STLP_TRY {
+ __result = __stlp_new_chunk(__bytes_to_get);
+ }
+#if defined (_STLP_USE_EXCEPTIONS)
+ catch (const bad_alloc&) {
+ // Allocation failed; try to canibalize from freelist of a larger object size.
+ for (size_t __i = _p_size; __i <= (size_t)_MAX_BYTES; __i += (size_t)_ALIGN) {
+ _Obj* __p = _S_free_list[_S_FREELIST_INDEX(__i)].pop();
+ if (0 != __p) {
+ if (__i < sizeof(_FreeBlockHeader)) {
+ // Not enough to put into list of free blocks, divvy it up here.
+ // Use as much as possible for this request and shove remainder into freelist.
+ __nobjs = (int)(__i/_p_size);
+ __total_bytes = __nobjs * __STATIC_CAST(__add_atomic_t, _p_size);
+ size_t __bytes_left = __i - __total_bytes;
+ size_t __rounded_down = _S_round_up(__bytes_left+1) - (size_t)_ALIGN;
+ if (__rounded_down > 0) {
+ _S_free_list[_S_FREELIST_INDEX(__rounded_down)].push(__REINTERPRET_CAST(_Obj*, __REINTERPRET_CAST(char*, __p) + __total_bytes));
+ }
+ return __REINTERPRET_CAST(char*, __p);
+ }
+ else {
+ // Add node to list of available blocks and recursively allocate from it.
+ _FreeBlockHeader* __newblock = (_FreeBlockHeader*)__p;
+ __newblock->_M_end = __REINTERPRET_CAST(char*, __p) + __i;
+ _S_free_mem_blocks.push(__newblock);
+ return _S_chunk_alloc(_p_size, __nobjs);
+ }
+ }
+ }
+
+ // We were not able to find something in a freelist, try to allocate a smaller amount.
+ __bytes_to_get = __total_bytes + _STLP_OFFSET;
+ __result = __stlp_new_chunk(__bytes_to_get);
+
+ // This should either throw an exception or remedy the situation.
+ // Thus we assume it succeeded.
+ }
+#endif
+ // Alignment check
+ _STLP_VERBOSE_ASSERT(((__REINTERPRET_CAST(size_t, __result) & __STATIC_CAST(size_t, _ALIGN - 1)) == 0),
+ _StlMsg_DBA_DELETED_TWICE)
+ _STLP_ATOMIC_ADD(&_S_heap_size, __bytes_to_get >> 4);
+
+# if defined (_STLP_DO_CLEAN_NODE_ALLOC)
+ // We have to track the allocated memory chunks for release on exit.
+ _S_chunks.push(__REINTERPRET_CAST(_Obj*, __result));
+ __result += _ALIGN;
+ __bytes_to_get -= _ALIGN;
+# endif
+
+ if (__bytes_to_get > __total_bytes) {
+ // Push excess memory allocated in this chunk into list of free memory blocks
+ _FreeBlockHeader* __freeblock = __REINTERPRET_CAST(_FreeBlockHeader*, __result + __total_bytes);
+ __freeblock->_M_end = __result + __bytes_to_get;
+ _S_free_mem_blocks.push(__freeblock);
+ }
+ return __result;
+}
+
+# if defined (_STLP_DO_CLEAN_NODE_ALLOC)
+void __node_alloc_impl::_S_alloc_call()
+{ _STLP_ATOMIC_INCREMENT(&_S_alloc_counter()); }
+
+void __node_alloc_impl::_S_dealloc_call() {
+ _STLP_VOLATILE __stl_atomic_t *pcounter = &_S_alloc_counter();
+ if (_STLP_ATOMIC_DECREMENT(pcounter) == 0)
+ _S_chunk_dealloc();
+}
+
+/* We deallocate all the memory chunks */
+void __node_alloc_impl::_S_chunk_dealloc() {
+ // Note: The _Node_alloc_helper class ensures that this function
+ // will only be called when the (shared) library is unloaded or the
+ // process is shutdown. It's thus not possible that another thread
+ // is currently trying to allocate a node (we're not thread-safe here).
+ //
+
+ // Clear the free blocks and all freelistst. This makes sure that if
+ // for some reason more memory is allocated again during shutdown
+ // (it'd also be really nasty to leave references to deallocated memory).
+ _S_free_mem_blocks.clear();
+ _S_heap_size = 0;
+
+ for (size_t __i = 0; __i < _STLP_NFREELISTS; ++__i) {
+ _S_free_list[__i].clear();
+ }
+
+ // Detach list of chunks and free them all
+ _Obj* __chunk = _S_chunks.clear();
+ while (__chunk != 0) {
+ _Obj* __next = __chunk->_M_next;
+ __stlp_delete_chunck(__chunk);
+ __chunk = __next;
+ }
+}
+# endif
+
+#endif
+
+#if defined (_STLP_DO_CLEAN_NODE_ALLOC)
+struct __node_alloc_cleaner {
+ ~__node_alloc_cleaner()
+ { __node_alloc_impl::_S_dealloc_call(); }
+};
+
+# if defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
+_STLP_VOLATILE __stl_atomic_t& _STLP_CALL
+# else
+__stl_atomic_t& _STLP_CALL
+# endif
+__node_alloc_impl::_S_alloc_counter() {
+ static _AllocCounter _S_counter = 1;
+ static __node_alloc_cleaner _S_node_alloc_cleaner;
+ return _S_counter;
+}
+#endif
+
+#if !defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
+_Node_alloc_obj * _STLP_VOLATILE
+__node_alloc_impl::_S_free_list[_STLP_NFREELISTS]
+= {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+// The 16 zeros are necessary to make version 4.1 of the SunPro
+// compiler happy. Otherwise it appears to allocate too little
+// space for the array.
+#else
+_STLP_atomic_freelist __node_alloc_impl::_S_free_list[_STLP_NFREELISTS];
+_STLP_atomic_freelist __node_alloc_impl::_S_free_mem_blocks;
+#endif
+
+#if !defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
+char *__node_alloc_impl::_S_start_free = 0;
+char *__node_alloc_impl::_S_end_free = 0;
+#endif
+
+#if defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
+_STLP_VOLATILE __add_atomic_t
+#else
+size_t
+#endif
+__node_alloc_impl::_S_heap_size = 0;
+
+#if defined (_STLP_DO_CLEAN_NODE_ALLOC)
+# if defined (_STLP_USE_LOCK_FREE_IMPLEMENTATION)
+_STLP_atomic_freelist __node_alloc_impl::_S_chunks;
+# else
+_Node_alloc_obj* __node_alloc_impl::_S_chunks = 0;
+# endif
+#endif
+
+void * _STLP_CALL __node_alloc::_M_allocate(size_t& __n)
+{ return __node_alloc_impl::_M_allocate(__n); }
+
+void _STLP_CALL __node_alloc::_M_deallocate(void *__p, size_t __n)
+{ __node_alloc_impl::_M_deallocate(__p, __n); }
+
+#if defined (_STLP_PTHREADS) && !defined (_STLP_NO_THREADS)
+
+# define _STLP_DATA_ALIGNMENT 8
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// *******************************************************
+// __perthread_alloc implementation
+union _Pthread_alloc_obj {
+ union _Pthread_alloc_obj * __free_list_link;
+ char __client_data[_STLP_DATA_ALIGNMENT]; /* The client sees this. */
+};
+
+// Pthread allocators don't appear to the client to have meaningful
+// instances. We do in fact need to associate some state with each
+// thread. That state is represented by _Pthread_alloc_per_thread_state.
+
+struct _Pthread_alloc_per_thread_state {
+ typedef _Pthread_alloc_obj __obj;
+ enum { _S_NFREELISTS = _MAX_BYTES / _STLP_DATA_ALIGNMENT };
+
+ // Free list link for list of available per thread structures.
+ // When one of these becomes available for reuse due to thread
+ // termination, any objects in its free list remain associated
+ // with it. The whole structure may then be used by a newly
+ // created thread.
+ _Pthread_alloc_per_thread_state() : __next(0)
+ { memset((void *)__CONST_CAST(_Pthread_alloc_obj**, __free_list), 0, (size_t)_S_NFREELISTS * sizeof(__obj *)); }
+ // Returns an object of size __n, and possibly adds to size n free list.
+ void *_M_refill(size_t __n);
+
+ _Pthread_alloc_obj* volatile __free_list[_S_NFREELISTS];
+ _Pthread_alloc_per_thread_state *__next;
+ // this data member is only to be used by per_thread_allocator, which returns memory to the originating thread.
+ _STLP_mutex _M_lock;
+};
+
+// Pthread-specific allocator.
+class _Pthread_alloc_impl {
+public: // but only for internal use:
+ typedef _Pthread_alloc_per_thread_state __state_type;
+ typedef char value_type;
+
+ // Allocates a chunk for nobjs of size size. nobjs may be reduced
+ // if it is inconvenient to allocate the requested number.
+ static char *_S_chunk_alloc(size_t __size, size_t &__nobjs, __state_type*);
+
+ enum {_S_ALIGN = _STLP_DATA_ALIGNMENT};
+
+ static size_t _S_round_up(size_t __bytes)
+ { return (((__bytes) + (int)_S_ALIGN - 1) & ~((int)_S_ALIGN - 1)); }
+ static size_t _S_freelist_index(size_t __bytes)
+ { return (((__bytes) + (int)_S_ALIGN - 1) / (int)_S_ALIGN - 1); }
+
+private:
+ // Chunk allocation state. And other shared state.
+ // Protected by _S_chunk_allocator_lock.
+ static _STLP_STATIC_MUTEX _S_chunk_allocator_lock;
+ static char *_S_start_free;
+ static char *_S_end_free;
+ static size_t _S_heap_size;
+ static __state_type *_S_free_per_thread_states;
+ static pthread_key_t _S_key;
+ static bool _S_key_initialized;
+ // Pthread key under which per thread state is stored.
+ // Allocator instances that are currently unclaimed by any thread.
+ static void _S_destructor(void *instance);
+ // Function to be called on thread exit to reclaim per thread
+ // state.
+ static __state_type *_S_new_per_thread_state();
+public:
+ // Return a recycled or new per thread state.
+ static __state_type *_S_get_per_thread_state();
+private:
+ // ensure that the current thread has an associated
+ // per thread state.
+ class _M_lock;
+ friend class _M_lock;
+ class _M_lock {
+ public:
+ _M_lock () { _S_chunk_allocator_lock._M_acquire_lock(); }
+ ~_M_lock () { _S_chunk_allocator_lock._M_release_lock(); }
+ };
+
+public:
+
+ /* n must be > 0 */
+ static void * allocate(size_t& __n);
+
+ /* p may not be 0 */
+ static void deallocate(void *__p, size_t __n);
+
+ // boris : versions for per_thread_allocator
+ /* n must be > 0 */
+ static void * allocate(size_t& __n, __state_type* __a);
+
+ /* p may not be 0 */
+ static void deallocate(void *__p, size_t __n, __state_type* __a);
+
+ static void * reallocate(void *__p, size_t __old_sz, size_t& __new_sz);
+};
+
+/* Returns an object of size n, and optionally adds to size n free list.*/
+/* We assume that n is properly aligned. */
+/* We hold the allocation lock. */
+void *_Pthread_alloc_per_thread_state::_M_refill(size_t __n) {
+ typedef _Pthread_alloc_obj __obj;
+ size_t __nobjs = 128;
+ char * __chunk = _Pthread_alloc_impl::_S_chunk_alloc(__n, __nobjs, this);
+ __obj * volatile * __my_free_list;
+ __obj * __result;
+ __obj * __current_obj, * __next_obj;
+ size_t __i;
+
+ if (1 == __nobjs) {
+ return __chunk;
+ }
+
+ __my_free_list = __free_list + _Pthread_alloc_impl::_S_freelist_index(__n);
+
+ /* Build free list in chunk */
+ __result = (__obj *)__chunk;
+ *__my_free_list = __next_obj = (__obj *)(__chunk + __n);
+ for (__i = 1; ; ++__i) {
+ __current_obj = __next_obj;
+ __next_obj = (__obj *)((char *)__next_obj + __n);
+ if (__nobjs - 1 == __i) {
+ __current_obj -> __free_list_link = 0;
+ break;
+ } else {
+ __current_obj -> __free_list_link = __next_obj;
+ }
+ }
+ return __result;
+}
+
+void _Pthread_alloc_impl::_S_destructor(void *__instance) {
+ _M_lock __lock_instance; // Need to acquire lock here.
+ _Pthread_alloc_per_thread_state* __s = (_Pthread_alloc_per_thread_state*)__instance;
+ __s -> __next = _S_free_per_thread_states;
+ _S_free_per_thread_states = __s;
+}
+
+_Pthread_alloc_per_thread_state* _Pthread_alloc_impl::_S_new_per_thread_state() {
+ /* lock already held here. */
+ if (0 != _S_free_per_thread_states) {
+ _Pthread_alloc_per_thread_state *__result = _S_free_per_thread_states;
+ _S_free_per_thread_states = _S_free_per_thread_states -> __next;
+ return __result;
+ }
+ else {
+ return new _Pthread_alloc_per_thread_state;
+ }
+}
+
+_Pthread_alloc_per_thread_state* _Pthread_alloc_impl::_S_get_per_thread_state() {
+ int __ret_code;
+ __state_type* __result;
+
+ if (_S_key_initialized && (__result = (__state_type*) pthread_getspecific(_S_key)))
+ return __result;
+
+ /*REFERENCED*/
+ _M_lock __lock_instance; // Need to acquire lock here.
+ if (!_S_key_initialized) {
+ if (pthread_key_create(&_S_key, _S_destructor)) {
+ _STLP_THROW_BAD_ALLOC; // failed
+ }
+ _S_key_initialized = true;
+ }
+
+ __result = _S_new_per_thread_state();
+ __ret_code = pthread_setspecific(_S_key, __result);
+ if (__ret_code) {
+ if (__ret_code == ENOMEM) {
+ _STLP_THROW_BAD_ALLOC;
+ } else {
+ // EINVAL
+ _STLP_ABORT();
+ }
+ }
+ return __result;
+}
+
+/* We allocate memory in large chunks in order to avoid fragmenting */
+/* the malloc heap too much. */
+/* We assume that size is properly aligned. */
+char *_Pthread_alloc_impl::_S_chunk_alloc(size_t __p_size, size_t &__nobjs, _Pthread_alloc_per_thread_state *__a) {
+ typedef _Pthread_alloc_obj __obj;
+ {
+ char * __result;
+ size_t __total_bytes;
+ size_t __bytes_left;
+ /*REFERENCED*/
+ _M_lock __lock_instance; // Acquire lock for this routine
+
+ __total_bytes = __p_size * __nobjs;
+ __bytes_left = _S_end_free - _S_start_free;
+ if (__bytes_left >= __total_bytes) {
+ __result = _S_start_free;
+ _S_start_free += __total_bytes;
+ return __result;
+ } else if (__bytes_left >= __p_size) {
+ __nobjs = __bytes_left/__p_size;
+ __total_bytes = __p_size * __nobjs;
+ __result = _S_start_free;
+ _S_start_free += __total_bytes;
+ return __result;
+ } else {
+ size_t __bytes_to_get = 2 * __total_bytes + _S_round_up(_S_heap_size);
+ // Try to make use of the left-over piece.
+ if (__bytes_left > 0) {
+ __obj * volatile * __my_free_list = __a->__free_list + _S_freelist_index(__bytes_left);
+ ((__obj *)_S_start_free) -> __free_list_link = *__my_free_list;
+ *__my_free_list = (__obj *)_S_start_free;
+ }
+# ifdef _SGI_SOURCE
+ // Try to get memory that's aligned on something like a
+ // cache line boundary, so as to avoid parceling out
+ // parts of the same line to different threads and thus
+ // possibly different processors.
+ {
+ const int __cache_line_size = 128; // probable upper bound
+ __bytes_to_get &= ~(__cache_line_size-1);
+ _S_start_free = (char *)memalign(__cache_line_size, __bytes_to_get);
+ if (0 == _S_start_free) {
+ _S_start_free = (char *)__malloc_alloc::allocate(__bytes_to_get);
+ }
+ }
+# else /* !SGI_SOURCE */
+ _S_start_free = (char *)__malloc_alloc::allocate(__bytes_to_get);
+# endif
+ _S_heap_size += __bytes_to_get >> 4;
+ _S_end_free = _S_start_free + __bytes_to_get;
+ }
+ }
+ // lock is released here
+ return _S_chunk_alloc(__p_size, __nobjs, __a);
+}
+
+
+/* n must be > 0 */
+void *_Pthread_alloc_impl::allocate(size_t& __n) {
+ typedef _Pthread_alloc_obj __obj;
+ __obj * volatile * __my_free_list;
+ __obj * __result;
+ __state_type* __a;
+
+ if (__n > _MAX_BYTES) {
+ return __malloc_alloc::allocate(__n);
+ }
+
+ __n = _S_round_up(__n);
+ __a = _S_get_per_thread_state();
+
+ __my_free_list = __a->__free_list + _S_freelist_index(__n);
+ __result = *__my_free_list;
+ if (__result == 0) {
+ void *__r = __a->_M_refill(__n);
+ return __r;
+ }
+ *__my_free_list = __result->__free_list_link;
+ return __result;
+};
+
+/* p may not be 0 */
+void _Pthread_alloc_impl::deallocate(void *__p, size_t __n) {
+ typedef _Pthread_alloc_obj __obj;
+ __obj *__q = (__obj *)__p;
+ __obj * volatile * __my_free_list;
+ __state_type* __a;
+
+ if (__n > _MAX_BYTES) {
+ __malloc_alloc::deallocate(__p, __n);
+ return;
+ }
+
+ __a = _S_get_per_thread_state();
+
+ __my_free_list = __a->__free_list + _S_freelist_index(__n);
+ __q -> __free_list_link = *__my_free_list;
+ *__my_free_list = __q;
+}
+
+// boris : versions for per_thread_allocator
+/* n must be > 0 */
+void *_Pthread_alloc_impl::allocate(size_t& __n, __state_type* __a) {
+ typedef _Pthread_alloc_obj __obj;
+ __obj * volatile * __my_free_list;
+ __obj * __result;
+
+ if (__n > _MAX_BYTES) {
+ return __malloc_alloc::allocate(__n);
+ }
+ __n = _S_round_up(__n);
+
+ // boris : here, we have to lock per thread state, as we may be getting memory from
+ // different thread pool.
+ _STLP_auto_lock __lock(__a->_M_lock);
+
+ __my_free_list = __a->__free_list + _S_freelist_index(__n);
+ __result = *__my_free_list;
+ if (__result == 0) {
+ void *__r = __a->_M_refill(__n);
+ return __r;
+ }
+ *__my_free_list = __result->__free_list_link;
+ return __result;
+};
+
+/* p may not be 0 */
+void _Pthread_alloc_impl::deallocate(void *__p, size_t __n, __state_type* __a) {
+ typedef _Pthread_alloc_obj __obj;
+ __obj *__q = (__obj *)__p;
+ __obj * volatile * __my_free_list;
+
+ if (__n > _MAX_BYTES) {
+ __malloc_alloc::deallocate(__p, __n);
+ return;
+ }
+
+ // boris : here, we have to lock per thread state, as we may be returning memory from
+ // different thread.
+ _STLP_auto_lock __lock(__a->_M_lock);
+
+ __my_free_list = __a->__free_list + _S_freelist_index(__n);
+ __q -> __free_list_link = *__my_free_list;
+ *__my_free_list = __q;
+}
+
+void *_Pthread_alloc_impl::reallocate(void *__p, size_t __old_sz, size_t& __new_sz) {
+ void * __result;
+ size_t __copy_sz;
+
+ if (__old_sz > _MAX_BYTES && __new_sz > _MAX_BYTES) {
+ return realloc(__p, __new_sz);
+ }
+
+ if (_S_round_up(__old_sz) == _S_round_up(__new_sz)) return __p;
+ __result = allocate(__new_sz);
+ __copy_sz = __new_sz > __old_sz? __old_sz : __new_sz;
+ memcpy(__result, __p, __copy_sz);
+ deallocate(__p, __old_sz);
+ return __result;
+}
+
+_Pthread_alloc_per_thread_state* _Pthread_alloc_impl::_S_free_per_thread_states = 0;
+pthread_key_t _Pthread_alloc_impl::_S_key = 0;
+_STLP_STATIC_MUTEX _Pthread_alloc_impl::_S_chunk_allocator_lock _STLP_MUTEX_INITIALIZER;
+bool _Pthread_alloc_impl::_S_key_initialized = false;
+char *_Pthread_alloc_impl::_S_start_free = 0;
+char *_Pthread_alloc_impl::_S_end_free = 0;
+size_t _Pthread_alloc_impl::_S_heap_size = 0;
+
+void * _STLP_CALL _Pthread_alloc::allocate(size_t& __n)
+{ return _Pthread_alloc_impl::allocate(__n); }
+void _STLP_CALL _Pthread_alloc::deallocate(void *__p, size_t __n)
+{ _Pthread_alloc_impl::deallocate(__p, __n); }
+void * _STLP_CALL _Pthread_alloc::allocate(size_t& __n, __state_type* __a)
+{ return _Pthread_alloc_impl::allocate(__n, __a); }
+void _STLP_CALL _Pthread_alloc::deallocate(void *__p, size_t __n, __state_type* __a)
+{ _Pthread_alloc_impl::deallocate(__p, __n, __a); }
+void * _STLP_CALL _Pthread_alloc::reallocate(void *__p, size_t __old_sz, size_t& __new_sz)
+{ return _Pthread_alloc_impl::reallocate(__p, __old_sz, __new_sz); }
+_Pthread_alloc_per_thread_state* _STLP_CALL _Pthread_alloc::_S_get_per_thread_state()
+{ return _Pthread_alloc_impl::_S_get_per_thread_state(); }
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#endif
+
+_STLP_END_NAMESPACE
+
+#undef _S_FREELIST_INDEX
diff --git a/sources/android/stlport/src/bitset.cpp b/sources/android/stlport/src/bitset.cpp
new file mode 100644
index 0000000..90f1799
--- /dev/null
+++ b/sources/android/stlport/src/bitset.cpp
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#include "stlport_prefix.h"
+
+#include <bitset>
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// ------------------------------------------------------------
+// Lookup tables for find and count operations.
+
+size_t _Bs_G::_S_count(const unsigned char *__first,
+ const unsigned char *__last)
+{
+ static const unsigned char _bit_count[256] = {
+ 0, /* 0 */ 1, /* 1 */ 1, /* 2 */ 2, /* 3 */ 1, /* 4 */
+ 2, /* 5 */ 2, /* 6 */ 3, /* 7 */ 1, /* 8 */ 2, /* 9 */
+ 2, /* 10 */ 3, /* 11 */ 2, /* 12 */ 3, /* 13 */ 3, /* 14 */
+ 4, /* 15 */ 1, /* 16 */ 2, /* 17 */ 2, /* 18 */ 3, /* 19 */
+ 2, /* 20 */ 3, /* 21 */ 3, /* 22 */ 4, /* 23 */ 2, /* 24 */
+ 3, /* 25 */ 3, /* 26 */ 4, /* 27 */ 3, /* 28 */ 4, /* 29 */
+ 4, /* 30 */ 5, /* 31 */ 1, /* 32 */ 2, /* 33 */ 2, /* 34 */
+ 3, /* 35 */ 2, /* 36 */ 3, /* 37 */ 3, /* 38 */ 4, /* 39 */
+ 2, /* 40 */ 3, /* 41 */ 3, /* 42 */ 4, /* 43 */ 3, /* 44 */
+ 4, /* 45 */ 4, /* 46 */ 5, /* 47 */ 2, /* 48 */ 3, /* 49 */
+ 3, /* 50 */ 4, /* 51 */ 3, /* 52 */ 4, /* 53 */ 4, /* 54 */
+ 5, /* 55 */ 3, /* 56 */ 4, /* 57 */ 4, /* 58 */ 5, /* 59 */
+ 4, /* 60 */ 5, /* 61 */ 5, /* 62 */ 6, /* 63 */ 1, /* 64 */
+ 2, /* 65 */ 2, /* 66 */ 3, /* 67 */ 2, /* 68 */ 3, /* 69 */
+ 3, /* 70 */ 4, /* 71 */ 2, /* 72 */ 3, /* 73 */ 3, /* 74 */
+ 4, /* 75 */ 3, /* 76 */ 4, /* 77 */ 4, /* 78 */ 5, /* 79 */
+ 2, /* 80 */ 3, /* 81 */ 3, /* 82 */ 4, /* 83 */ 3, /* 84 */
+ 4, /* 85 */ 4, /* 86 */ 5, /* 87 */ 3, /* 88 */ 4, /* 89 */
+ 4, /* 90 */ 5, /* 91 */ 4, /* 92 */ 5, /* 93 */ 5, /* 94 */
+ 6, /* 95 */ 2, /* 96 */ 3, /* 97 */ 3, /* 98 */ 4, /* 99 */
+ 3, /* 100 */ 4, /* 101 */ 4, /* 102 */ 5, /* 103 */ 3, /* 104 */
+ 4, /* 105 */ 4, /* 106 */ 5, /* 107 */ 4, /* 108 */ 5, /* 109 */
+ 5, /* 110 */ 6, /* 111 */ 3, /* 112 */ 4, /* 113 */ 4, /* 114 */
+ 5, /* 115 */ 4, /* 116 */ 5, /* 117 */ 5, /* 118 */ 6, /* 119 */
+ 4, /* 120 */ 5, /* 121 */ 5, /* 122 */ 6, /* 123 */ 5, /* 124 */
+ 6, /* 125 */ 6, /* 126 */ 7, /* 127 */ 1, /* 128 */ 2, /* 129 */
+ 2, /* 130 */ 3, /* 131 */ 2, /* 132 */ 3, /* 133 */ 3, /* 134 */
+ 4, /* 135 */ 2, /* 136 */ 3, /* 137 */ 3, /* 138 */ 4, /* 139 */
+ 3, /* 140 */ 4, /* 141 */ 4, /* 142 */ 5, /* 143 */ 2, /* 144 */
+ 3, /* 145 */ 3, /* 146 */ 4, /* 147 */ 3, /* 148 */ 4, /* 149 */
+ 4, /* 150 */ 5, /* 151 */ 3, /* 152 */ 4, /* 153 */ 4, /* 154 */
+ 5, /* 155 */ 4, /* 156 */ 5, /* 157 */ 5, /* 158 */ 6, /* 159 */
+ 2, /* 160 */ 3, /* 161 */ 3, /* 162 */ 4, /* 163 */ 3, /* 164 */
+ 4, /* 165 */ 4, /* 166 */ 5, /* 167 */ 3, /* 168 */ 4, /* 169 */
+ 4, /* 170 */ 5, /* 171 */ 4, /* 172 */ 5, /* 173 */ 5, /* 174 */
+ 6, /* 175 */ 3, /* 176 */ 4, /* 177 */ 4, /* 178 */ 5, /* 179 */
+ 4, /* 180 */ 5, /* 181 */ 5, /* 182 */ 6, /* 183 */ 4, /* 184 */
+ 5, /* 185 */ 5, /* 186 */ 6, /* 187 */ 5, /* 188 */ 6, /* 189 */
+ 6, /* 190 */ 7, /* 191 */ 2, /* 192 */ 3, /* 193 */ 3, /* 194 */
+ 4, /* 195 */ 3, /* 196 */ 4, /* 197 */ 4, /* 198 */ 5, /* 199 */
+ 3, /* 200 */ 4, /* 201 */ 4, /* 202 */ 5, /* 203 */ 4, /* 204 */
+ 5, /* 205 */ 5, /* 206 */ 6, /* 207 */ 3, /* 208 */ 4, /* 209 */
+ 4, /* 210 */ 5, /* 211 */ 4, /* 212 */ 5, /* 213 */ 5, /* 214 */
+ 6, /* 215 */ 4, /* 216 */ 5, /* 217 */ 5, /* 218 */ 6, /* 219 */
+ 5, /* 220 */ 6, /* 221 */ 6, /* 222 */ 7, /* 223 */ 3, /* 224 */
+ 4, /* 225 */ 4, /* 226 */ 5, /* 227 */ 4, /* 228 */ 5, /* 229 */
+ 5, /* 230 */ 6, /* 231 */ 4, /* 232 */ 5, /* 233 */ 5, /* 234 */
+ 6, /* 235 */ 5, /* 236 */ 6, /* 237 */ 6, /* 238 */ 7, /* 239 */
+ 4, /* 240 */ 5, /* 241 */ 5, /* 242 */ 6, /* 243 */ 5, /* 244 */
+ 6, /* 245 */ 6, /* 246 */ 7, /* 247 */ 5, /* 248 */ 6, /* 249 */
+ 6, /* 250 */ 7, /* 251 */ 6, /* 252 */ 7, /* 253 */ 7, /* 254 */
+ 8 /* 255 */
+ };
+
+ size_t __result(0);
+ while ( __first < __last ) {
+ __result += _bit_count[*(__first++)];
+ }
+ return __result;
+}
+
+unsigned char _Bs_G::_S_first_one(unsigned char __byte)
+{
+ static const unsigned char _first_one[256] = {
+ 0, /* 0 */ 0, /* 1 */ 1, /* 2 */ 0, /* 3 */ 2, /* 4 */
+ 0, /* 5 */ 1, /* 6 */ 0, /* 7 */ 3, /* 8 */ 0, /* 9 */
+ 1, /* 10 */ 0, /* 11 */ 2, /* 12 */ 0, /* 13 */ 1, /* 14 */
+ 0, /* 15 */ 4, /* 16 */ 0, /* 17 */ 1, /* 18 */ 0, /* 19 */
+ 2, /* 20 */ 0, /* 21 */ 1, /* 22 */ 0, /* 23 */ 3, /* 24 */
+ 0, /* 25 */ 1, /* 26 */ 0, /* 27 */ 2, /* 28 */ 0, /* 29 */
+ 1, /* 30 */ 0, /* 31 */ 5, /* 32 */ 0, /* 33 */ 1, /* 34 */
+ 0, /* 35 */ 2, /* 36 */ 0, /* 37 */ 1, /* 38 */ 0, /* 39 */
+ 3, /* 40 */ 0, /* 41 */ 1, /* 42 */ 0, /* 43 */ 2, /* 44 */
+ 0, /* 45 */ 1, /* 46 */ 0, /* 47 */ 4, /* 48 */ 0, /* 49 */
+ 1, /* 50 */ 0, /* 51 */ 2, /* 52 */ 0, /* 53 */ 1, /* 54 */
+ 0, /* 55 */ 3, /* 56 */ 0, /* 57 */ 1, /* 58 */ 0, /* 59 */
+ 2, /* 60 */ 0, /* 61 */ 1, /* 62 */ 0, /* 63 */ 6, /* 64 */
+ 0, /* 65 */ 1, /* 66 */ 0, /* 67 */ 2, /* 68 */ 0, /* 69 */
+ 1, /* 70 */ 0, /* 71 */ 3, /* 72 */ 0, /* 73 */ 1, /* 74 */
+ 0, /* 75 */ 2, /* 76 */ 0, /* 77 */ 1, /* 78 */ 0, /* 79 */
+ 4, /* 80 */ 0, /* 81 */ 1, /* 82 */ 0, /* 83 */ 2, /* 84 */
+ 0, /* 85 */ 1, /* 86 */ 0, /* 87 */ 3, /* 88 */ 0, /* 89 */
+ 1, /* 90 */ 0, /* 91 */ 2, /* 92 */ 0, /* 93 */ 1, /* 94 */
+ 0, /* 95 */ 5, /* 96 */ 0, /* 97 */ 1, /* 98 */ 0, /* 99 */
+ 2, /* 100 */ 0, /* 101 */ 1, /* 102 */ 0, /* 103 */ 3, /* 104 */
+ 0, /* 105 */ 1, /* 106 */ 0, /* 107 */ 2, /* 108 */ 0, /* 109 */
+ 1, /* 110 */ 0, /* 111 */ 4, /* 112 */ 0, /* 113 */ 1, /* 114 */
+ 0, /* 115 */ 2, /* 116 */ 0, /* 117 */ 1, /* 118 */ 0, /* 119 */
+ 3, /* 120 */ 0, /* 121 */ 1, /* 122 */ 0, /* 123 */ 2, /* 124 */
+ 0, /* 125 */ 1, /* 126 */ 0, /* 127 */ 7, /* 128 */ 0, /* 129 */
+ 1, /* 130 */ 0, /* 131 */ 2, /* 132 */ 0, /* 133 */ 1, /* 134 */
+ 0, /* 135 */ 3, /* 136 */ 0, /* 137 */ 1, /* 138 */ 0, /* 139 */
+ 2, /* 140 */ 0, /* 141 */ 1, /* 142 */ 0, /* 143 */ 4, /* 144 */
+ 0, /* 145 */ 1, /* 146 */ 0, /* 147 */ 2, /* 148 */ 0, /* 149 */
+ 1, /* 150 */ 0, /* 151 */ 3, /* 152 */ 0, /* 153 */ 1, /* 154 */
+ 0, /* 155 */ 2, /* 156 */ 0, /* 157 */ 1, /* 158 */ 0, /* 159 */
+ 5, /* 160 */ 0, /* 161 */ 1, /* 162 */ 0, /* 163 */ 2, /* 164 */
+ 0, /* 165 */ 1, /* 166 */ 0, /* 167 */ 3, /* 168 */ 0, /* 169 */
+ 1, /* 170 */ 0, /* 171 */ 2, /* 172 */ 0, /* 173 */ 1, /* 174 */
+ 0, /* 175 */ 4, /* 176 */ 0, /* 177 */ 1, /* 178 */ 0, /* 179 */
+ 2, /* 180 */ 0, /* 181 */ 1, /* 182 */ 0, /* 183 */ 3, /* 184 */
+ 0, /* 185 */ 1, /* 186 */ 0, /* 187 */ 2, /* 188 */ 0, /* 189 */
+ 1, /* 190 */ 0, /* 191 */ 6, /* 192 */ 0, /* 193 */ 1, /* 194 */
+ 0, /* 195 */ 2, /* 196 */ 0, /* 197 */ 1, /* 198 */ 0, /* 199 */
+ 3, /* 200 */ 0, /* 201 */ 1, /* 202 */ 0, /* 203 */ 2, /* 204 */
+ 0, /* 205 */ 1, /* 206 */ 0, /* 207 */ 4, /* 208 */ 0, /* 209 */
+ 1, /* 210 */ 0, /* 211 */ 2, /* 212 */ 0, /* 213 */ 1, /* 214 */
+ 0, /* 215 */ 3, /* 216 */ 0, /* 217 */ 1, /* 218 */ 0, /* 219 */
+ 2, /* 220 */ 0, /* 221 */ 1, /* 222 */ 0, /* 223 */ 5, /* 224 */
+ 0, /* 225 */ 1, /* 226 */ 0, /* 227 */ 2, /* 228 */ 0, /* 229 */
+ 1, /* 230 */ 0, /* 231 */ 3, /* 232 */ 0, /* 233 */ 1, /* 234 */
+ 0, /* 235 */ 2, /* 236 */ 0, /* 237 */ 1, /* 238 */ 0, /* 239 */
+ 4, /* 240 */ 0, /* 241 */ 1, /* 242 */ 0, /* 243 */ 2, /* 244 */
+ 0, /* 245 */ 1, /* 246 */ 0, /* 247 */ 3, /* 248 */ 0, /* 249 */
+ 1, /* 250 */ 0, /* 251 */ 2, /* 252 */ 0, /* 253 */ 1, /* 254 */
+ 0, /* 255 */
+ };
+ return _first_one[__byte];
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
diff --git a/sources/android/stlport/src/c_locale.c b/sources/android/stlport/src/c_locale.c
new file mode 100644
index 0000000..376e22e
--- /dev/null
+++ b/sources/android/stlport/src/c_locale.c
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#include "stlport_prefix.h"
+
+#include "c_locale.h"
+
+#if defined (_STLP_WIN32) && !defined (_STLP_WCE)
+# include "c_locale_win32/c_locale_win32.c"
+#elif defined (_STLP_USE_GLIBC2_LOCALIZATION)
+# include "c_locale_glibc/c_locale_glibc2.c" /* glibc 2.2 and newer */
+#else
+# include "c_locale_dummy/c_locale_dummy.c"
+#endif
diff --git a/sources/android/stlport/src/c_locale.h b/sources/android/stlport/src/c_locale.h
new file mode 100644
index 0000000..36d9961
--- /dev/null
+++ b/sources/android/stlport/src/c_locale.h
@@ -0,0 +1,450 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/*
+ * It is impossible to write the C++ locale library in terms of locales
+ * as defined in the C standard. Instead, we write the C++ locale and I/O
+ * library in terms of a low level C-like interface. This file defines
+ * that interface.
+ *
+ * The low-level locale interface can't be written portably; there
+ * must be a version of it for each platform that the C++ library
+ * is ported to. On many systems this interface may be a thin wrapper
+ * for existing functionality.
+ */
+
+#ifndef _STLP_C_LOCALE_IMPL_H
+#define _STLP_C_LOCALE_IMPL_H
+
+#include "stlport_prefix.h"
+
+#include <wchar.h> /* for mbstate_t */
+#include <stl/c_locale.h>
+
+struct _Locale_name_hint;
+
+#if defined (_GNU_SOURCE) && defined (__GLIBC__) && \
+ ((__GLIBC__ > 2) || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2))
+# define _STLP_USE_GLIBC2_LOCALIZATION
+# include <nl_types.h>
+typedef nl_catd nl_catd_type;
+#else
+typedef int nl_catd_type;
+#endif
+
+/*
+ * A number: the maximum length of a simple locale name.
+ * (i.e. a name like like en_US, as opposed to a name like
+ * en_US/de_AT/de_AT/es_MX/en_US/en_US) */
+#define _Locale_MAX_SIMPLE_NAME 256
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Typedefs:
+ */
+typedef unsigned short int _Locale_mask_t;
+
+/* Function called during STLport library load phase. Might contain any
+ * code necessary to the platform localization layer.
+ */
+void _Locale_init(void);
+
+/* Function called during STLport library unload. Might contain any
+ * code necessary to the platform localization layer.
+ */
+void _Locale_final(void);
+
+/* Create a category of the locale with the given name.
+ *
+ * The char* argument is a simple (not a composite) locale name, which may
+ * neither be an empty string nor a null pointer.
+ *
+ * These functions return NULL to indicate failure. Failure reason should be reported
+ * using the __err_code pointer.
+ */
+struct _Locale_ctype* _Locale_ctype_create(const char *, struct _Locale_name_hint*, int * /* __err_code */);
+struct _Locale_codecvt* _Locale_codecvt_create(const char *, struct _Locale_name_hint*, int * /* __err_code */);
+struct _Locale_numeric* _Locale_numeric_create(const char *, struct _Locale_name_hint*, int * /* __err_code */);
+struct _Locale_time* _Locale_time_create(const char *, struct _Locale_name_hint*, int * /* __err_code */);
+struct _Locale_collate* _Locale_collate_create(const char *, struct _Locale_name_hint*, int * /* __err_code */);
+struct _Locale_monetary* _Locale_monetary_create(const char *, struct _Locale_name_hint*, int * /* __err_code */);
+struct _Locale_messages* _Locale_messages_create(const char *, struct _Locale_name_hint*, int * /* __err_code */);
+
+/* Give error reason on failure of one of the _Locale_*_create functions. Available
+ * reasons are:
+ * 0: No specific error reason has been reported.
+ * 1: No platform support for the given facet.
+ * 2: Unknown locale name
+ * 3: No platform API for localization support.
+ * 4: No more memory
+ */
+#define _STLP_LOC_UNDEFINED 0
+#define _STLP_LOC_UNSUPPORTED_FACET_CATEGORY 1
+#define _STLP_LOC_UNKNOWN_NAME 2
+#define _STLP_LOC_NO_PLATFORM_SUPPORT 3
+#define _STLP_LOC_NO_MEMORY 4
+
+/* Release a category of a locale
+ *
+ * These functions are used to release a category acquired with the
+ * according _Locale_*_create() functions.
+ */
+void _Locale_ctype_destroy(struct _Locale_ctype *);
+void _Locale_codecvt_destroy(struct _Locale_codecvt *);
+void _Locale_numeric_destroy(struct _Locale_numeric *);
+void _Locale_time_destroy(struct _Locale_time *);
+void _Locale_collate_destroy(struct _Locale_collate *);
+void _Locale_monetary_destroy(struct _Locale_monetary *);
+void _Locale_messages_destroy(struct _Locale_messages *);
+
+/*
+ * Returns the name of the user's default locale in each
+ * category, as a null-terminated string. A NULL value
+ * means the default "C" locale.
+ */
+const char * _Locale_ctype_default(char * __buf);
+const char * _Locale_numeric_default(char * __buf);
+const char * _Locale_time_default(char * __buf);
+const char * _Locale_collate_default(char * __buf);
+const char * _Locale_monetary_default(char * __buf);
+const char * _Locale_messages_default(char * __buf);
+
+/* Retrieve the name of the given category
+ *
+ * __buf points to a buffer that can hold at least _Locale_MAX_SIMPLE_NAME
+ * characters. These functions store the name, as a null-terminated
+ * string, in __buf. This function can't fail, at worst name is truncated.
+ */
+char const* _Locale_ctype_name(const struct _Locale_ctype *, char* __buf);
+char const* _Locale_codecvt_name(const struct _Locale_codecvt *, char* __buf);
+char const* _Locale_numeric_name(const struct _Locale_numeric *, char* __buf);
+char const* _Locale_time_name(const struct _Locale_time *, char* __buf);
+char const* _Locale_collate_name(const struct _Locale_collate *, char* __buf);
+char const* _Locale_monetary_name(const struct _Locale_monetary *, char* __buf);
+char const* _Locale_messages_name(const struct _Locale_messages *, char* __buf);
+
+/*
+ * cname is a (possibly composite) locale name---i.e. a name that can
+ * be passed to setlocale. __buf points to an array large enough to
+ * store at least _Locale_MAX_SIMPLE_NAME characters, and each of these
+ * functions extracts the name of a single category, stores it in buf
+ * as a null-terminated string, and returns buf.
+ */
+char const* _Locale_extract_ctype_name(const char *cname, char *__buf,
+ struct _Locale_name_hint* __hint, int *__err_code);
+char const* _Locale_extract_numeric_name(const char *cname, char *__buf,
+ struct _Locale_name_hint* __hint, int *__err_code);
+char const* _Locale_extract_time_name(const char *cname, char *__buf,
+ struct _Locale_name_hint* __hint, int *__err_code);
+char const* _Locale_extract_collate_name(const char *cname, char *__buf,
+ struct _Locale_name_hint* __hint, int *__err_code);
+char const* _Locale_extract_monetary_name(const char *cname, char *__buf,
+ struct _Locale_name_hint* __hint, int *__err_code);
+char const* _Locale_extract_messages_name(const char *cname, char *__buf,
+ struct _Locale_name_hint* __hint, int *__err_code);
+
+/* Functions to improve locale creation process. For some locale API (Win32)
+ * you need to find a locale identification from the name which can be a
+ * rather expensive operation especially if you do so for all facets of a
+ * locale. Those functions can be used to extract from a API dependent facet
+ * struct the information necessary to skip this lookup process for other
+ * facets creation. If not supported those function should return NULL.
+ */
+struct _Locale_name_hint* _Locale_get_ctype_hint(struct _Locale_ctype*);
+struct _Locale_name_hint* _Locale_get_numeric_hint(struct _Locale_numeric*);
+struct _Locale_name_hint* _Locale_get_time_hint(struct _Locale_time*);
+struct _Locale_name_hint* _Locale_get_collate_hint(struct _Locale_collate*);
+struct _Locale_name_hint* _Locale_get_monetary_hint(struct _Locale_monetary*);
+struct _Locale_name_hint* _Locale_get_messages_hint(struct _Locale_messages*);
+
+/*
+ * FUNCTIONS THAT USE CTYPE
+ */
+
+/*
+ * Narrow character functions:
+ */
+
+/*
+ * Returns a pointer to the beginning of the ctype table. The table is
+ * at least 257 bytes long; if p is the pointer returned by this
+ * function, then p[c] is valid if c is EOF or if p is any value of
+ * type unsigned char.
+ */
+const _Locale_mask_t * _Locale_ctype_table(struct _Locale_ctype *);
+
+/*
+ * c is either EOF, or an unsigned char value.
+ */
+int _Locale_toupper(struct _Locale_ctype *, int /* c */);
+int _Locale_tolower(struct _Locale_ctype *, int /* c */);
+
+
+#ifndef _STLP_NO_WCHAR_T
+/*
+ * Wide character functions:
+ */
+_Locale_mask_t _WLocale_ctype(struct _Locale_ctype *, wint_t, _Locale_mask_t);
+wint_t _WLocale_tolower(struct _Locale_ctype *, wint_t);
+wint_t _WLocale_toupper(struct _Locale_ctype *, wint_t);
+
+/*
+ * Multibyte functions:
+ */
+
+/*
+ * Returns the number of bytes of the longest allowed multibyte
+ * character in the current encoding.
+ */
+int _WLocale_mb_cur_max(struct _Locale_codecvt *);
+
+/*
+ * Returns the number of bytes of the shortest allowed multibyte
+ * character in the current encoding.
+ */
+int _WLocale_mb_cur_min(struct _Locale_codecvt *);
+
+/*
+ * Returns 1 if the current multibyte encoding is stateless
+ * and does not require the use of an mbstate_t value.
+ */
+int _WLocale_is_stateless(struct _Locale_codecvt *);
+
+/*
+ * Almost identical to mbrtowc, from 4.6.5.3.2 of NA1. The only
+ * important difference is that mbrtowc treats null wide characters
+ * as special, and we don't. Specifically: examines the characters
+ * in [from, from + n), extracts a single wide character, and stores
+ * it in *to. Modifies shift_state if appropriate. The return value,
+ * which is always positive, is the number of characters extracted from
+ * the input sequence. Return value is (size_t) -1 if there was an
+ * encoding error in the input sequence, and (size_t) -2 if
+ * [from, from + n) is correct but not complete. None of the pointer
+ * arguments may be null pointers.
+ */
+size_t _WLocale_mbtowc(struct _Locale_codecvt *,
+ wchar_t * /* to */,
+ const char * /* from */, size_t /* n */,
+ mbstate_t *);
+
+/*
+ * Again, very similar to wcrtomb. The differences are that (1) it
+ * doesn't treat null characters as special; and (2) it stores at most
+ * n characters. Converts c to a multibyte sequence, stores that
+ * sequence in the array 'to', and returns the length of the sequence.
+ * Modifies shift_state if appropriate. The return value is (size_t) -1
+ * if c is not a valid wide character, and (size_t) -2 if the length of
+ * the multibyte character sequence is greater than n.
+ */
+size_t _WLocale_wctomb(struct _Locale_codecvt *,
+ char *, size_t,
+ const wchar_t,
+ mbstate_t *);
+
+/*
+ * Inserts whatever characters are necessary to restore st to an
+ * initial shift state. Sets *next to buf + m, where m is the number
+ * of characters inserted. (0 <= m <= n.) Returns m to indicate
+ * success, (size_t) -1 to indicate error, (size_t) -2 to indicate
+ * partial success (more than n characters needed). For success or partial
+ * success, sets *next to buf + m.
+ */
+size_t _WLocale_unshift(struct _Locale_codecvt *,
+ mbstate_t *,
+ char *, size_t, char **);
+#endif
+
+/*
+ * FUNCTIONS THAT USE COLLATE
+ */
+
+/*
+ * Compares the two sequences [s1, s1 + n1) and [s2, s2 + n2). Neither
+ * sequence is assumed to be null-terminated, and null characters
+ * aren't special. If the two sequences are the same up through
+ * min(n1, n2), then the sequence that compares less is whichever one
+ * is shorter.
+ */
+int _Locale_strcmp(struct _Locale_collate *,
+ const char * /* s1 */, size_t /* n1 */,
+ const char * /* s2 */, size_t /* n2 */);
+#ifndef _STLP_NO_WCHAR_T
+int _WLocale_strcmp(struct _Locale_collate *,
+ const wchar_t * /* s1 */, size_t /* n1 */,
+ const wchar_t * /* s2 */, size_t /* n2 */);
+#endif
+
+/*
+ * Creates a transformed version of the string [s2, s2 + n2). The
+ * string may contain embedded null characters; nulls aren't special.
+ * The transformed string begins at s1, and contains at most n1
+ * characters. The return value is the length of the transformed
+ * string. If the return value is greater than n1 then this is an
+ * error condition: it indicates that there wasn't enough space. In
+ * that case, the contents of [s1, s1 + n1) is unspecified.
+*/
+size_t _Locale_strxfrm(struct _Locale_collate *,
+ char * /* s1 */, size_t /* n1 */,
+ const char * /* s2 */, size_t /* n2 */);
+
+#ifndef _STLP_NO_WCHAR_T
+size_t _WLocale_strxfrm(struct _Locale_collate *,
+ wchar_t * /* s1 */, size_t /* n1 */,
+ const wchar_t * /* s2 */, size_t /* n2 */);
+#endif
+
+
+/*
+ * FUNCTIONS THAT USE NUMERIC
+ */
+
+/*
+ * Equivalent to the first three fields in struct lconv. (C standard,
+ * section 7.4.)
+ */
+char _Locale_decimal_point(struct _Locale_numeric *);
+char _Locale_thousands_sep(struct _Locale_numeric *);
+const char * _Locale_grouping(struct _Locale_numeric *);
+
+#ifndef _STLP_NO_WCHAR_T
+wchar_t _WLocale_decimal_point(struct _Locale_numeric *);
+wchar_t _WLocale_thousands_sep(struct _Locale_numeric *);
+#endif
+
+/*
+ * Return "true" and "false" in English locales, and something
+ * appropriate in non-English locales.
+ */
+const char * _Locale_true(struct _Locale_numeric *);
+const char * _Locale_false(struct _Locale_numeric *);
+
+#ifndef _STLP_NO_WCHAR_T
+const wchar_t * _WLocale_true(struct _Locale_numeric *, wchar_t* /* buf */, size_t /* bufSize */);
+const wchar_t * _WLocale_false(struct _Locale_numeric *, wchar_t* /* buf */, size_t /* bufSize */);
+#endif
+
+/*
+ * FUNCTIONS THAT USE MONETARY
+ */
+
+/*
+ * Return the obvious fields of struct lconv.
+ */
+const char * _Locale_int_curr_symbol(struct _Locale_monetary *);
+const char * _Locale_currency_symbol(struct _Locale_monetary *);
+char _Locale_mon_decimal_point(struct _Locale_monetary *);
+char _Locale_mon_thousands_sep(struct _Locale_monetary *);
+const char * _Locale_mon_grouping(struct _Locale_monetary *);
+const char * _Locale_positive_sign(struct _Locale_monetary *);
+const char * _Locale_negative_sign(struct _Locale_monetary *);
+char _Locale_int_frac_digits(struct _Locale_monetary *);
+char _Locale_frac_digits(struct _Locale_monetary *);
+int _Locale_p_cs_precedes(struct _Locale_monetary *);
+int _Locale_p_sep_by_space(struct _Locale_monetary *);
+int _Locale_p_sign_posn(struct _Locale_monetary *);
+int _Locale_n_cs_precedes(struct _Locale_monetary *);
+int _Locale_n_sep_by_space(struct _Locale_monetary *);
+int _Locale_n_sign_posn(struct _Locale_monetary *);
+
+#ifndef _STLP_NO_WCHAR_T
+const wchar_t * _WLocale_int_curr_symbol(struct _Locale_monetary *, wchar_t* /* buf */, size_t /* bufSize */);
+const wchar_t * _WLocale_currency_symbol(struct _Locale_monetary *, wchar_t* /* buf */, size_t /* bufSize */);
+wchar_t _WLocale_mon_decimal_point(struct _Locale_monetary *);
+wchar_t _WLocale_mon_thousands_sep(struct _Locale_monetary *);
+const wchar_t * _WLocale_positive_sign(struct _Locale_monetary *, wchar_t* /* buf */, size_t /* bufSize */);
+const wchar_t * _WLocale_negative_sign(struct _Locale_monetary *, wchar_t* /* buf */, size_t /* bufSize */);
+#endif
+
+/*
+ * FUNCTIONS THAT USE TIME
+ */
+
+/*
+ * month is in the range [0, 12).
+ */
+const char * _Locale_full_monthname(struct _Locale_time *, int /* month */);
+const char * _Locale_abbrev_monthname(struct _Locale_time *, int /* month */);
+
+#ifndef _STLP_NO_WCHAR_T
+const wchar_t * _WLocale_full_monthname(struct _Locale_time *, int /* month */,
+ wchar_t* /* buf */, size_t /* bufSize */);
+const wchar_t * _WLocale_abbrev_monthname(struct _Locale_time *, int /* month */,
+ wchar_t* /* buf */, size_t /* bufSize */);
+#endif
+
+/*
+ * day is in the range [0, 7). Sunday is 0.
+ */
+const char * _Locale_full_dayofweek(struct _Locale_time *, int /* day */);
+const char * _Locale_abbrev_dayofweek(struct _Locale_time *, int /* day */);
+
+#ifndef _STLP_NO_WCHAR_T
+const wchar_t * _WLocale_full_dayofweek(struct _Locale_time *, int /* day */,
+ wchar_t* /* buf */, size_t /* bufSize */);
+const wchar_t * _WLocale_abbrev_dayofweek(struct _Locale_time *, int /* day */,
+ wchar_t* /* buf */, size_t /* bufSize */);
+#endif
+
+const char * _Locale_d_t_fmt(struct _Locale_time *);
+const char * _Locale_d_fmt(struct _Locale_time *);
+const char * _Locale_t_fmt(struct _Locale_time *);
+const char * _Locale_long_d_t_fmt(struct _Locale_time*);
+const char * _Locale_long_d_fmt(struct _Locale_time*);
+
+const char * _Locale_am_str(struct _Locale_time *);
+const char * _Locale_pm_str(struct _Locale_time *);
+
+#ifndef _STLP_NO_WCHAR_T
+const wchar_t * _WLocale_am_str(struct _Locale_time *,
+ wchar_t* /* buf */, size_t /* bufSize */);
+const wchar_t * _WLocale_pm_str(struct _Locale_time *,
+ wchar_t* /* buf */, size_t /* bufSize */);
+#endif
+
+/*
+ * FUNCTIONS THAT USE MESSAGES
+ */
+
+/*
+ * Very similar to catopen, except that it uses the given message
+ * category to determine which catalog to open.
+ */
+nl_catd_type _Locale_catopen(struct _Locale_messages*, const char*);
+
+/* Complementary to _Locale_catopen.
+ * The catalog must be a value that was returned by a previous call
+ * to _Locale_catopen.
+ */
+void _Locale_catclose(struct _Locale_messages*, nl_catd_type);
+
+/*
+ * Returns a string, identified by a set index and a message index,
+ * from an opened message catalog. Returns the supplied default if
+ * no such string exists.
+ */
+const char * _Locale_catgets(struct _Locale_messages *, nl_catd_type,
+ int, int,const char *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _STLP_C_LOCALE_IMPL_H */
diff --git a/sources/android/stlport/src/c_locale_dummy/c_locale_dummy.c b/sources/android/stlport/src/c_locale_dummy/c_locale_dummy.c
new file mode 100644
index 0000000..be48f23
--- /dev/null
+++ b/sources/android/stlport/src/c_locale_dummy/c_locale_dummy.c
@@ -0,0 +1,485 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* This is a "stub" implementation of the "c_locale.h" interface,
+ intended for operating systems where we have not yet written
+ a real implementation. A C++ library using this stub implementation
+ is still standard-conforming, since the C++ standard does not require
+ that any locales other than "C" be supported.
+*/
+
+#include <string.h>
+#include <wchar.h>
+#include <ctype.h>
+#include <wctype.h>
+#include <limits.h>
+
+#if defined (_STLP_USE_SAFE_STRING_FUNCTIONS)
+# define _STLP_STRNCPY(D, DS, S, C) strncpy_s(D, DS, S, C)
+# if !defined (_STLP_NO_WCHAR_T)
+# define _STLP_WCSNCPY(D, DS, S, C) wcsncpy_s(D, DS, S, C)
+# endif
+#else
+# define _STLP_STRNCPY(D, DS, S, C) strncpy(D, S, C)
+# if !defined (_STLP_NO_WCHAR_T)
+# define _STLP_WCSNCPY(D, DS, S, C) wcsncpy(D, S, C)
+# endif
+#endif
+
+static const char *_C_name = "C";
+static const char *_empty_str = "";
+#ifndef _STLP_NO_WCHAR_T
+static const wchar_t *_empty_wstr = L"";
+#endif
+
+static _Locale_mask_t ctable[256];
+
+/* Framework functions */
+
+void _Locale_init(void) {
+ /* Ctype table for the ASCII character set. */
+ char c;
+ /* We might never reach 128 when char is signed. */
+ for (c = 0; /* c != 128 */; ++c) {
+ if (isalpha(c)) ctable[(unsigned char)c] |= _Locale_ALPHA;
+ if (iscntrl(c)) ctable[(unsigned char)c] |= _Locale_CNTRL;
+ if (isdigit(c)) ctable[(unsigned char)c] |= _Locale_DIGIT;
+ if (isprint(c)) ctable[(unsigned char)c] |= _Locale_PRINT;
+ if (ispunct(c)) ctable[(unsigned char)c] |= _Locale_PUNCT;
+ if (isspace(c)) ctable[(unsigned char)c] |= _Locale_SPACE;
+ if (isxdigit(c)) ctable[(unsigned char)c] |= _Locale_XDIGIT;
+ if (isupper(c)) ctable[(unsigned char)c] |= _Locale_UPPER;
+ if (islower(c)) ctable[(unsigned char)c] |= _Locale_LOWER;
+ if (c == 127) break;
+ }
+
+ /* ASCII is a 7-bit code, so everything else is non-ASCII. */
+ memset(&(ctable[128]), 0, 128 * sizeof(_Locale_mask_t));
+}
+
+void _Locale_final(void)
+{}
+
+void* _Locale_create(const char* name, int *__err_code) {
+ if (name[0] == 'C' && name[1] == 0)
+ { return (void*)0x1; }
+ *__err_code = _STLP_LOC_NO_PLATFORM_SUPPORT; return 0;
+}
+
+struct _Locale_ctype* _Locale_ctype_create(const char *name,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return (struct _Locale_ctype*)_Locale_create(name, __err_code); }
+
+struct _Locale_codecvt* _Locale_codecvt_create(const char *name,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return (struct _Locale_codecvt*)_Locale_create(name, __err_code); }
+
+struct _Locale_numeric* _Locale_numeric_create(const char *name,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return (struct _Locale_numeric*)_Locale_create(name, __err_code); }
+
+struct _Locale_time* _Locale_time_create(const char *name,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return (struct _Locale_time*)_Locale_create(name, __err_code); }
+
+struct _Locale_collate* _Locale_collate_create(const char *name,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return (struct _Locale_collate*)_Locale_create(name, __err_code); }
+
+struct _Locale_monetary* _Locale_monetary_create(const char *name,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return (struct _Locale_monetary*)_Locale_create(name, __err_code); }
+
+struct _Locale_messages* _Locale_messages_create(const char *name,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return (struct _Locale_messages*)_Locale_create(name, __err_code); }
+
+const char *_Locale_ctype_default(char* buf) { return _C_name; }
+const char *_Locale_numeric_default(char * buf) { return _C_name; }
+const char *_Locale_time_default(char* buf) { return _C_name; }
+const char *_Locale_collate_default(char* buf) { return _C_name; }
+const char *_Locale_monetary_default(char* buf) { return _C_name; }
+const char *_Locale_messages_default(char* buf) { return _C_name; }
+
+char const* _Locale_ctype_name(const struct _Locale_ctype *lctype, char* buf)
+{ return _C_name; }
+
+char const* _Locale_codecvt_name(const struct _Locale_codecvt *lcodecvt, char* buf)
+{ return _C_name; }
+
+char const* _Locale_numeric_name(const struct _Locale_numeric *lnum, char* buf)
+{ return _C_name; }
+
+char const* _Locale_time_name(const struct _Locale_time *ltime, char* buf)
+{ return _C_name; }
+
+char const* _Locale_collate_name(const struct _Locale_collate *lcol, char* buf)
+{ return _C_name; }
+
+char const* _Locale_monetary_name(const struct _Locale_monetary *lmon, char* buf)
+{ return _C_name; }
+
+char const* _Locale_messages_name(const struct _Locale_messages *lmes, char* buf)
+{ return _C_name; }
+
+void _Locale_ctype_destroy(struct _Locale_ctype *lctype) {}
+void _Locale_codecvt_destroy(struct _Locale_codecvt *lcodecvt) {}
+void _Locale_numeric_destroy(struct _Locale_numeric *lnum) {}
+void _Locale_time_destroy(struct _Locale_time *ltime) {}
+void _Locale_collate_destroy(struct _Locale_collate *lcol) {}
+void _Locale_monetary_destroy(struct _Locale_monetary *lmon) {}
+void _Locale_messages_destroy(struct _Locale_messages *lmes) {}
+
+static char const* _Locale_extract_name(const char* name, int *__err_code) {
+ // When the request is the default locale or the "C" locale we answer "C".
+ if (name[0] == 0 ||
+ (name[0] == 'C' && name[1] == 0))
+ { return _C_name; }
+ *__err_code = _STLP_LOC_NO_PLATFORM_SUPPORT; return 0;
+}
+
+char const* _Locale_extract_ctype_name(const char *name, char *buf,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return _Locale_extract_name(name, __err_code); }
+
+char const* _Locale_extract_numeric_name(const char *name, char *buf,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return _Locale_extract_name(name, __err_code); }
+
+char const* _Locale_extract_time_name(const char*name, char *buf,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return _Locale_extract_name(name, __err_code); }
+
+char const* _Locale_extract_collate_name(const char *name, char *buf,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return _Locale_extract_name(name, __err_code); }
+
+char const* _Locale_extract_monetary_name(const char *name, char *buf,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return _Locale_extract_name(name, __err_code); }
+
+char const* _Locale_extract_messages_name(const char *name, char *buf,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return _Locale_extract_name(name, __err_code); }
+
+struct _Locale_name_hint* _Locale_get_ctype_hint(struct _Locale_ctype* ctype)
+{ return 0; }
+struct _Locale_name_hint* _Locale_get_numeric_hint(struct _Locale_numeric* numeric)
+{ return 0; }
+struct _Locale_name_hint* _Locale_get_time_hint(struct _Locale_time* time)
+{ return 0; }
+struct _Locale_name_hint* _Locale_get_collate_hint(struct _Locale_collate* collate)
+{ return 0; }
+struct _Locale_name_hint* _Locale_get_monetary_hint(struct _Locale_monetary* monetary)
+{ return 0; }
+struct _Locale_name_hint* _Locale_get_messages_hint(struct _Locale_messages* messages)
+{ return 0; }
+
+/* ctype */
+const _Locale_mask_t* _Locale_ctype_table(struct _Locale_ctype* lctype) {
+ _STLP_MARK_PARAMETER_AS_UNUSED(lctype)
+ return ctable;
+}
+
+int _Locale_toupper(struct _Locale_ctype*lctype, int c)
+{ return toupper(c); }
+
+int _Locale_tolower(struct _Locale_ctype*lctype, int c)
+{ return tolower(c); }
+
+#ifndef _STLP_NO_WCHAR_T
+_Locale_mask_t _WLocale_ctype(struct _Locale_ctype *lctype, wint_t wc, _Locale_mask_t mask) {
+ _Locale_mask_t ret = 0;
+ if ((mask & _Locale_ALPHA) != 0 && iswalpha(wc))
+ ret |= _Locale_ALPHA;
+
+ if ((mask & _Locale_CNTRL) != 0 && iswcntrl(wc))
+ ret |= _Locale_CNTRL;
+
+ if ((mask & _Locale_DIGIT) != 0 && iswdigit(wc))
+ ret |= _Locale_DIGIT;
+
+ if ((mask & _Locale_PRINT) != 0 && iswprint(wc))
+ ret |= _Locale_PRINT;
+
+ if ((mask & _Locale_PUNCT) != 0 && iswpunct(wc))
+ ret |= _Locale_PUNCT;
+
+ if ((mask & _Locale_SPACE) != 0 && iswspace(wc))
+ ret |= _Locale_SPACE;
+
+ if ((mask & _Locale_XDIGIT) != 0 && iswxdigit(wc))
+ ret |= _Locale_XDIGIT;
+
+ if ((mask & _Locale_UPPER) != 0 && iswupper(wc))
+ ret |= _Locale_UPPER;
+
+ if ((mask & _Locale_LOWER) != 0 && iswlower(wc))
+ ret |= _Locale_LOWER;
+
+ return ret;
+}
+
+wint_t _WLocale_tolower(struct _Locale_ctype *lctype, wint_t wc)
+{ return towlower(wc); }
+
+wint_t _WLocale_toupper(struct _Locale_ctype *lctype, wint_t wc)
+{ return towupper(wc); }
+
+int _WLocale_mb_cur_max (struct _Locale_codecvt *lcodecvt) { return 1; }
+int _WLocale_mb_cur_min (struct _Locale_codecvt *lcodecvt) { return 1; }
+int _WLocale_is_stateless (struct _Locale_codecvt *lcodecvt) { return 1; }
+
+size_t _WLocale_mbtowc(struct _Locale_codecvt *lcodecvt,
+ wchar_t *to,
+ const char *from, size_t n,
+ mbstate_t *st)
+{ *to = *from; return 1; }
+
+size_t _WLocale_wctomb(struct _Locale_codecvt *lcodecvt,
+ char *to, size_t n,
+ const wchar_t c,
+ mbstate_t *st)
+{ *to = (char)c; return 1; }
+
+size_t _WLocale_unshift(struct _Locale_codecvt *lcodecvt,
+ mbstate_t *st,
+ char *buf, size_t n, char ** next)
+{ *next = buf; return 0; }
+#endif
+
+/* Collate */
+ int _Locale_strcmp(struct _Locale_collate* lcol,
+ const char* s1, size_t n1, const char* s2, size_t n2) {
+ int ret = 0;
+ char buf1[64], buf2[64];
+ while (n1 > 0 || n2 > 0) {
+ size_t bufsize1 = n1 < 63 ? n1 : 63;
+ size_t bufsize2 = n2 < 63 ? n2 : 63;
+ _STLP_STRNCPY(buf1, 64, s1, bufsize1); buf1[bufsize1] = 0;
+ _STLP_STRNCPY(buf2, 64, s2, bufsize2); buf2[bufsize2] = 0;
+
+ ret = strcmp(buf1, buf2);
+ if (ret != 0) return ret < 0 ? -1 : 1;
+ s1 += bufsize1; n1 -= bufsize1;
+ s2 += bufsize2; n2 -= bufsize2;
+ }
+ return ret == 0 ? 0 : (ret < 0 ? -1 : 1);
+}
+
+#ifndef _STLP_NO_WCHAR_T
+
+int _WLocale_strcmp(struct _Locale_collate* lcol,
+ const wchar_t* s1, size_t n1, const wchar_t* s2, size_t n2) {
+ int ret = 0;
+ wchar_t buf1[64], buf2[64];
+ while (n1 > 0 || n2 > 0) {
+ size_t bufsize1 = n1 < 63 ? n1 : 63;
+ size_t bufsize2 = n2 < 63 ? n2 : 63;
+ _STLP_WCSNCPY(buf1, 64, s1, bufsize1); buf1[bufsize1] = 0;
+ _STLP_WCSNCPY(buf2, 64, s2, bufsize2); buf2[bufsize2] = 0;
+
+ ret = wcscmp(buf1, buf2);
+ if (ret != 0) return ret < 0 ? -1 : 1;
+ s1 += bufsize1; n1 -= bufsize1;
+ s2 += bufsize2; n2 -= bufsize2;
+ }
+ return ret == 0 ? 0 : (ret < 0 ? -1 : 1);
+}
+
+#endif
+
+size_t _Locale_strxfrm(struct _Locale_collate* lcol,
+ char* dest, size_t dest_n,
+ const char* src, size_t src_n) {
+ if (dest != 0) {
+ _STLP_STRNCPY(dest, dest_n, src, dest_n - 1); dest[dest_n - 1] = 0;
+ }
+ return src_n;
+}
+
+#ifndef _STLP_NO_WCHAR_T
+
+size_t _WLocale_strxfrm(struct _Locale_collate* lcol,
+ wchar_t* dest, size_t dest_n,
+ const wchar_t* src, size_t src_n) {
+ if (dest != 0) {
+ _STLP_WCSNCPY(dest, dest_n, src, dest_n - 1); dest[dest_n - 1] = 0;
+ }
+ return src_n;
+}
+
+#endif
+
+/* Numeric */
+
+char _Locale_decimal_point(struct _Locale_numeric* lnum)
+{ return '.'; }
+char _Locale_thousands_sep(struct _Locale_numeric* lnum)
+{ return ','; }
+const char* _Locale_grouping(struct _Locale_numeric * lnum)
+{ return _empty_str; }
+const char * _Locale_true(struct _Locale_numeric * lnum)
+{ return "true"; }
+const char * _Locale_false(struct _Locale_numeric * lnum)
+{ return "false"; }
+
+#ifndef _STLP_NO_WCHAR_T
+wchar_t _WLocale_decimal_point(struct _Locale_numeric* lnum)
+{ return L'.'; }
+wchar_t _WLocale_thousands_sep(struct _Locale_numeric* lnum)
+{ return L','; }
+const wchar_t * _WLocale_true(struct _Locale_numeric* lnum, wchar_t* buf, size_t bufSize)
+{ return L"true"; }
+const wchar_t * _WLocale_false(struct _Locale_numeric* lnum, wchar_t* buf, size_t bufSize)
+{ return L"false"; }
+#endif
+
+/* Monetary */
+
+const char* _Locale_int_curr_symbol(struct _Locale_monetary * lmon)
+{ return _empty_str; }
+const char* _Locale_currency_symbol(struct _Locale_monetary * lmon)
+{ return _empty_str; }
+char _Locale_mon_decimal_point(struct _Locale_monetary * lmon)
+{ return '.'; }
+char _Locale_mon_thousands_sep(struct _Locale_monetary * lmon)
+{ return ','; }
+const char* _Locale_mon_grouping(struct _Locale_monetary * lmon)
+{ return _empty_str; }
+const char* _Locale_positive_sign(struct _Locale_monetary * lmon)
+{ return _empty_str; }
+const char* _Locale_negative_sign(struct _Locale_monetary * lmon)
+{ return _empty_str; }
+char _Locale_int_frac_digits(struct _Locale_monetary * lmon)
+{ return 0; }
+char _Locale_frac_digits(struct _Locale_monetary * lmon)
+{ return 0; }
+int _Locale_p_cs_precedes(struct _Locale_monetary * lmon)
+{ return CHAR_MAX; }
+int _Locale_p_sep_by_space(struct _Locale_monetary * lmon)
+{ return CHAR_MAX; }
+int _Locale_p_sign_posn(struct _Locale_monetary * lmon)
+{ return CHAR_MAX; }
+int _Locale_n_cs_precedes(struct _Locale_monetary * lmon)
+{ return CHAR_MAX; }
+int _Locale_n_sep_by_space(struct _Locale_monetary * lmon)
+{ return CHAR_MAX; }
+int _Locale_n_sign_posn(struct _Locale_monetary * lmon)
+{ return CHAR_MAX; }
+
+#ifndef _STLP_NO_WCHAR_T
+const wchar_t* _WLocale_int_curr_symbol(struct _Locale_monetary * lmon,
+ wchar_t* buf, size_t bufSize)
+{ return _empty_wstr; }
+const wchar_t* _WLocale_currency_symbol(struct _Locale_monetary * lmon,
+ wchar_t* buf, size_t bufSize)
+{ return _empty_wstr; }
+wchar_t _WLocale_mon_decimal_point(struct _Locale_monetary * lmon)
+{ return L'.'; }
+wchar_t _WLocale_mon_thousands_sep(struct _Locale_monetary * lmon)
+{ return L','; }
+const wchar_t* _WLocale_positive_sign(struct _Locale_monetary * lmon,
+ wchar_t* buf, size_t bufSize)
+{ return _empty_wstr; }
+const wchar_t* _WLocale_negative_sign(struct _Locale_monetary * lmon,
+ wchar_t* buf, size_t bufSize)
+{ return _empty_wstr; }
+#endif
+
+/* Time */
+static const char* full_monthname[] =
+{ "January", "February", "March", "April", "May", "June",
+ "July", "August", "September", "October", "November", "December" };
+const char * _Locale_full_monthname(struct _Locale_time * ltime, int n)
+{ return full_monthname[n]; }
+
+static const char* abbrev_monthname[] =
+{ "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
+const char * _Locale_abbrev_monthname(struct _Locale_time * ltime, int n)
+{ return abbrev_monthname[n]; }
+
+static const char* full_dayname[] =
+{ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
+const char * _Locale_full_dayofweek(struct _Locale_time * ltime, int n)
+{ return full_dayname[n]; }
+
+static const char* abbrev_dayname[] =
+{ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
+const char * _Locale_abbrev_dayofweek(struct _Locale_time * ltime, int n)
+{ return abbrev_dayname[n]; }
+
+const char* _Locale_d_t_fmt(struct _Locale_time* ltime)
+{ return "%m/%d/%y"; }
+const char* _Locale_d_fmt(struct _Locale_time* ltime)
+{ return "%m/%d/%y"; }
+const char* _Locale_t_fmt(struct _Locale_time* ltime)
+{ return "%H:%M:%S"; }
+const char* _Locale_long_d_t_fmt(struct _Locale_time* ltime)
+{ return _empty_str; }
+const char* _Locale_long_d_fmt(struct _Locale_time* ltime)
+{ return _empty_str; }
+const char* _Locale_am_str(struct _Locale_time* ltime)
+{ return "AM"; }
+const char* _Locale_pm_str(struct _Locale_time* ltime)
+{ return "PM"; }
+
+#ifndef _STLP_NO_WCHAR_T
+static const wchar_t* full_wmonthname[] =
+{ L"January", L"February", L"March", L"April", L"May", L"June",
+ L"July", L"August", L"September", L"October", L"November", L"December" };
+const wchar_t * _WLocale_full_monthname(struct _Locale_time * ltime, int n,
+ wchar_t* buf, size_t bufSize)
+{ return full_wmonthname[n]; }
+
+static const wchar_t* abbrev_wmonthname[] =
+{ L"Jan", L"Feb", L"Mar", L"Apr", L"May", L"Jun",
+ L"Jul", L"Aug", L"Sep", L"Oct", L"Nov", L"Dec" };
+const wchar_t * _WLocale_abbrev_monthname(struct _Locale_time * ltime, int n,
+ wchar_t* buf, size_t bufSize)
+{ return abbrev_wmonthname[n]; }
+
+static const wchar_t* full_wdayname[] =
+{ L"Sunday", L"Monday", L"Tuesday", L"Wednesday", L"Thursday", L"Friday", L"Saturday" };
+const wchar_t * _WLocale_full_dayofweek(struct _Locale_time * ltime, int n,
+ wchar_t* buf, size_t bufSize)
+{ return full_wdayname[n]; }
+
+static const wchar_t* abbrev_wdayname[] =
+{ L"Sun", L"Mon", L"Tue", L"Wed", L"Thu", L"Fri", L"Sat" };
+const wchar_t * _WLocale_abbrev_dayofweek(struct _Locale_time * ltime, int n,
+ wchar_t* buf, size_t bufSize)
+{ return abbrev_wdayname[n]; }
+
+const wchar_t* _WLocale_am_str(struct _Locale_time* ltime,
+ wchar_t* buf, size_t bufSize)
+{ return L"AM"; }
+const wchar_t* _WLocale_pm_str(struct _Locale_time* ltime,
+ wchar_t* buf, size_t bufSize)
+{ return L"PM"; }
+#endif
+
+/* Messages */
+
+nl_catd_type _Locale_catopen(struct _Locale_messages* lmes, const char* name)
+{ return -1; }
+void _Locale_catclose(struct _Locale_messages* lmes, nl_catd_type cat) {}
+const char* _Locale_catgets(struct _Locale_messages* lmes, nl_catd_type cat,
+ int setid, int msgid, const char *dfault)
+{ return dfault; }
diff --git a/sources/android/stlport/src/c_locale_glibc/c_locale_glibc2.c b/sources/android/stlport/src/c_locale_glibc/c_locale_glibc2.c
new file mode 100644
index 0000000..0cf8279
--- /dev/null
+++ b/sources/android/stlport/src/c_locale_glibc/c_locale_glibc2.c
@@ -0,0 +1,705 @@
+#include <locale.h>
+#include <langinfo.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <wctype.h>
+#include <string.h>
+#include <stdint.h>
+
+static const char *_empty_str = "";
+static const char *_C_name = "C";
+
+static wchar_t* _ToWChar(const char* buf, wchar_t *wbuf, size_t wbufSize) {
+ wchar_t *wcur = wbuf;
+ wchar_t *wend = wbuf + wbufSize - 1;
+ for (; wcur != wend && *buf != 0; ++buf, ++wcur)
+ *wcur = *buf;
+ *wcur = 0;
+ return wbuf;
+}
+
+#if 0
+struct _Locale_ctype
+{
+ locale_t __cloc;
+};
+
+struct _Locale_numeric
+{
+ locale_t __cloc;
+};
+
+struct _Locale_time
+{
+ locale_t __cloc;
+};
+
+struct _Locale_collate
+{
+ locale_t __cloc;
+};
+
+struct _Locale_monetary
+{
+ locale_t __cloc;
+};
+
+struct _Locale_messages
+{
+ locale_t __cloc;
+};
+#endif
+
+void _Locale_init()
+{}
+
+void _Locale_final()
+{}
+
+struct _Locale_ctype *_Locale_ctype_create(const char *nm, struct _Locale_name_hint* hint,
+ int *__err_code) {
+ *__err_code = _STLP_LOC_UNKNOWN_NAME;
+ return (struct _Locale_ctype*)newlocale(LC_CTYPE_MASK, nm, NULL);
+}
+
+struct _Locale_codecvt *_Locale_codecvt_create(const char *nm, struct _Locale_name_hint* hint,
+ int *__err_code) {
+ // Glibc do not support multibyte manipulation for the moment, it simply implements "C".
+ if (nm[0] == 'C' && nm[1] == 0)
+ { return (struct _Locale_codecvt*)0x01; }
+ *__err_code = _STLP_LOC_NO_PLATFORM_SUPPORT; return 0;
+}
+
+struct _Locale_numeric *_Locale_numeric_create(const char *nm, struct _Locale_name_hint* hint,
+ int *__err_code) {
+ *__err_code = _STLP_LOC_UNKNOWN_NAME;
+ return (struct _Locale_numeric*)newlocale(LC_NUMERIC_MASK, nm, NULL);
+}
+
+struct _Locale_time *_Locale_time_create(const char *nm, struct _Locale_name_hint* hint,
+ int *__err_code) {
+ *__err_code = _STLP_LOC_UNKNOWN_NAME;
+ return (struct _Locale_time*)newlocale(LC_TIME_MASK, nm, NULL);
+}
+
+struct _Locale_collate *_Locale_collate_create(const char *nm, struct _Locale_name_hint* hint,
+ int *__err_code) {
+ *__err_code = _STLP_LOC_UNKNOWN_NAME;
+ return (struct _Locale_collate*)newlocale(LC_COLLATE_MASK, nm, NULL);
+}
+
+struct _Locale_monetary *_Locale_monetary_create(const char *nm, struct _Locale_name_hint* hint,
+ int *__err_code) {
+ *__err_code = _STLP_LOC_UNKNOWN_NAME;
+ return (struct _Locale_monetary*)newlocale(LC_MONETARY_MASK, nm, NULL);
+}
+
+struct _Locale_messages *_Locale_messages_create(const char *nm, struct _Locale_name_hint* hint,
+ int *__err_code) {
+ *__err_code = _STLP_LOC_UNKNOWN_NAME;
+ return (struct _Locale_messages*)newlocale(LC_MESSAGES_MASK, nm, NULL);
+}
+
+/*
+ try to see locale category LC should be used from environment;
+ according POSIX, the order is
+ 1. LC_ALL
+ 2. category (LC_CTYPE, LC_NUMERIC, ... )
+ 3. LANG
+ If set nothing, return "C" (this really implementation-specific).
+*/
+static const char *_Locale_aux_default( const char *LC, char *nm )
+{
+ char *name = getenv( "LC_ALL" );
+
+ if ( name != NULL && *name != 0 ) {
+ return name;
+ }
+ name = getenv( LC );
+ if ( name != NULL && *name != 0 ) {
+ return name;
+ }
+ name = getenv( "LANG" );
+ if ( name != NULL && *name != 0 ) {
+ return name;
+ }
+
+ return _C_name;
+}
+
+const char *_Locale_ctype_default( char *nm )
+{
+ return _Locale_aux_default( "LC_CTYPE", nm );
+}
+
+const char *_Locale_numeric_default( char *nm )
+{
+ return _Locale_aux_default( "LC_NUMERIC", nm );
+}
+
+const char *_Locale_time_default( char *nm )
+{
+ return _Locale_aux_default( "LC_TIME", nm );
+}
+
+const char *_Locale_collate_default( char *nm )
+{
+ return _Locale_aux_default( "LC_COLLATE", nm );
+}
+
+const char *_Locale_monetary_default( char *nm )
+{
+ return _Locale_aux_default( "LC_MONETARY", nm );
+}
+
+const char *_Locale_messages_default( char *nm )
+{
+ return _Locale_aux_default( "LC_MESSAGES", nm );
+}
+
+char const*_Locale_ctype_name( const struct _Locale_ctype *__loc, char *buf )
+{
+ return ((locale_t)__loc)->__names[LC_CTYPE];
+}
+
+char const*_Locale_codecvt_name( const struct _Locale_codecvt *__loc, char *buf )
+{
+ return _C_name;
+}
+
+char const*_Locale_numeric_name( const struct _Locale_numeric *__loc, char *buf )
+{
+ return ((locale_t)__loc)->__names[LC_NUMERIC];
+}
+
+char const*_Locale_time_name( const struct _Locale_time *__loc, char *buf )
+{
+ return ((locale_t)__loc)->__names[LC_TIME];
+}
+
+char const*_Locale_collate_name( const struct _Locale_collate *__loc, char *buf )
+{
+ return ((locale_t)__loc)->__names[LC_COLLATE];
+}
+
+char const*_Locale_monetary_name( const struct _Locale_monetary *__loc, char *buf )
+{
+ return ((locale_t)__loc)->__names[LC_MONETARY];
+}
+
+char const*_Locale_messages_name( const struct _Locale_messages *__loc, char *buf )
+{
+ return ((locale_t)__loc)->__names[LC_MESSAGES];
+}
+
+void _Locale_ctype_destroy( struct _Locale_ctype *__loc )
+{ freelocale((locale_t)__loc); }
+
+void _Locale_codecvt_destroy( struct _Locale_codecvt *__loc )
+{}
+
+void _Locale_numeric_destroy( struct _Locale_numeric *__loc )
+{ freelocale((locale_t)__loc); }
+
+void _Locale_time_destroy( struct _Locale_time *__loc )
+{ freelocale((locale_t)__loc); }
+
+void _Locale_collate_destroy( struct _Locale_collate *__loc )
+{ freelocale((locale_t)__loc); }
+
+void _Locale_monetary_destroy( struct _Locale_monetary *__loc )
+{ freelocale((locale_t)__loc); }
+
+void _Locale_messages_destroy( struct _Locale_messages* __loc )
+{ freelocale((locale_t)__loc); }
+
+/*
+ * locale loc expected either locale name indeed (platform-specific)
+ * or string like "LC_CTYPE=LocaleNameForCType;LC_NUMERIC=LocaleNameForNum;"
+ *
+ */
+
+static char const*__Extract_locale_name( const char *loc, const char *category, char *buf )
+{
+ char *expr;
+ size_t len_name;
+
+ if( loc[0]=='L' && loc[1]=='C' && loc[2]=='_') {
+ expr = strstr( (char*)loc, category );
+ if ( expr == NULL )
+ return NULL; /* Category not found. */
+ ++expr;
+ len_name = strcspn( expr, ";" );
+ len_name = len_name >= _Locale_MAX_SIMPLE_NAME ? _Locale_MAX_SIMPLE_NAME - 1 : len_name;
+ strncpy( buf, expr, len_name );
+ buf[len_name] = 0;
+ return buf;
+ }
+ return loc;
+}
+
+char const*_Locale_extract_ctype_name(const char *loc, char *buf,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return __Extract_locale_name( loc, "LC_CTYPE=", buf ); }
+
+char const*_Locale_extract_numeric_name(const char *loc, char *buf,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return __Extract_locale_name( loc, "LC_NUMERIC=", buf ); }
+
+char const*_Locale_extract_time_name(const char *loc, char *buf,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return __Extract_locale_name( loc, "LC_TIME=", buf ); }
+
+char const*_Locale_extract_collate_name(const char *loc, char *buf,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return __Extract_locale_name( loc, "LC_COLLATE=", buf ); }
+
+char const*_Locale_extract_monetary_name(const char *loc, char *buf,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return __Extract_locale_name( loc, "LC_MONETARY=", buf ); }
+
+char const*_Locale_extract_messages_name(const char *loc, char *buf,
+ struct _Locale_name_hint* hint, int *__err_code)
+{ return __Extract_locale_name( loc, "LC_MESSAGES=", buf ); }
+
+struct _Locale_name_hint* _Locale_get_ctype_hint(struct _Locale_ctype* ctype)
+{ return 0; }
+struct _Locale_name_hint* _Locale_get_numeric_hint(struct _Locale_numeric* numeric)
+{ return 0; }
+struct _Locale_name_hint* _Locale_get_time_hint(struct _Locale_time* time)
+{ return 0; }
+struct _Locale_name_hint* _Locale_get_collate_hint(struct _Locale_collate* collate)
+{ return 0; }
+struct _Locale_name_hint* _Locale_get_monetary_hint(struct _Locale_monetary* monetary)
+{ return 0; }
+struct _Locale_name_hint* _Locale_get_messages_hint(struct _Locale_messages* messages)
+{ return 0; }
+
+/* ctype */
+
+const _Locale_mask_t *_Locale_ctype_table( struct _Locale_ctype *__loc )
+{
+ /* return table with masks (upper, lower, alpha, etc.) */
+ _STLP_STATIC_ASSERT( sizeof(_Locale_mask_t) == sizeof(((locale_t)__loc)->__ctype_b[0]) )
+ return ((locale_t)__loc)->__ctype_b;
+}
+
+int _Locale_toupper( struct _Locale_ctype *__loc, int c )
+{ return ((locale_t)__loc)->__ctype_toupper[c]; }
+
+int _Locale_tolower( struct _Locale_ctype *__loc, int c )
+{ return ((locale_t)__loc)->__ctype_tolower[c]; }
+
+#if !defined (_STLP_NO_WCHAR_T)
+_Locale_mask_t _WLocale_ctype( struct _Locale_ctype *__loc, wint_t wc, _Locale_mask_t __mask )
+{
+ _Locale_mask_t ret = 0;
+ if ((__mask & _Locale_ALPHA) != 0 && iswalpha_l(wc, (locale_t)__loc))
+ ret |= _Locale_ALPHA;
+
+ if ((__mask & _Locale_CNTRL) != 0 && iswcntrl_l(wc, (locale_t)__loc))
+ ret |= _Locale_CNTRL;
+
+ if ((__mask & _Locale_DIGIT) != 0 && iswdigit_l(wc, (locale_t)__loc))
+ ret |= _Locale_DIGIT;
+
+ if ((__mask & _Locale_PRINT) != 0 && iswprint_l(wc, (locale_t)__loc))
+ ret |= _Locale_PRINT;
+
+ if ((__mask & _Locale_PUNCT) != 0 && iswpunct_l(wc, (locale_t)__loc))
+ ret |= _Locale_PUNCT;
+
+ if ((__mask & _Locale_SPACE) != 0 && iswspace_l(wc, (locale_t)__loc))
+ ret |= _Locale_SPACE;
+
+ if ((__mask & _Locale_XDIGIT) != 0 && iswxdigit_l(wc, (locale_t)__loc))
+ ret |= _Locale_XDIGIT;
+
+ if ((__mask & _Locale_UPPER) != 0 && iswupper_l(wc, (locale_t)__loc))
+ ret |= _Locale_UPPER;
+
+ if ((__mask & _Locale_LOWER) != 0 && iswlower_l(wc, (locale_t)__loc))
+ ret |= _Locale_LOWER;
+
+ return ret;
+}
+
+wint_t _WLocale_tolower( struct _Locale_ctype *__loc, wint_t c )
+{
+ return towlower_l( c, ((locale_t)__loc) );
+}
+
+wint_t _WLocale_toupper( struct _Locale_ctype *__loc, wint_t c )
+{
+ return towupper_l( c, ((locale_t)__loc) );
+}
+#endif
+
+int _WLocale_mb_cur_max( struct _Locale_codecvt * lcodecvt) { return 1; }
+int _WLocale_mb_cur_min( struct _Locale_codecvt * lcodecvt) { return 1; }
+int _WLocale_is_stateless( struct _Locale_codecvt * lcodecvt) { return 1; }
+
+#if !defined (_STLP_NO_WCHAR_T)
+size_t _WLocale_mbtowc(struct _Locale_codecvt *lcodecvt,
+ wchar_t *to,
+ const char *from, size_t n,
+ mbstate_t *st)
+{ *to = *from; return 1; }
+
+size_t _WLocale_wctomb(struct _Locale_codecvt *lcodecvt,
+ char *to, size_t n,
+ const wchar_t c,
+ mbstate_t *st)
+{ *to = (char)c; return 1; }
+#endif
+
+size_t _WLocale_unshift(struct _Locale_codecvt *lcodecvt,
+ mbstate_t *st,
+ char *buf, size_t n, char ** next)
+{ *next = buf; return 0; }
+
+/* Collate */
+int _Locale_strcmp(struct _Locale_collate * __loc,
+ const char *s1, size_t n1,
+ const char *s2, size_t n2) {
+ int ret = 0;
+ char buf1[64], buf2[64];
+ while (n1 > 0 || n2 > 0) {
+ size_t bufsize1 = n1 < 63 ? n1 : 63;
+ size_t bufsize2 = n2 < 63 ? n2 : 63;
+ strncpy(buf1, s1, bufsize1); buf1[bufsize1] = 0;
+ strncpy(buf2, s2, bufsize2); buf2[bufsize2] = 0;
+
+ ret = strcoll_l(buf1, buf2, (locale_t)__loc);
+ if (ret != 0) return ret;
+ s1 += bufsize1; n1 -= bufsize1;
+ s2 += bufsize2; n2 -= bufsize2;
+ }
+ return ret;
+}
+
+#if !defined (_STLP_NO_WCHAR_T)
+int _WLocale_strcmp(struct _Locale_collate *__loc,
+ const wchar_t *s1, size_t n1,
+ const wchar_t *s2, size_t n2) {
+ int ret = 0;
+ wchar_t buf1[64], buf2[64];
+ while (n1 > 0 || n2 > 0) {
+ size_t bufsize1 = n1 < 63 ? n1 : 63;
+ size_t bufsize2 = n2 < 63 ? n2 : 63;
+ wcsncpy(buf1, s1, bufsize1); buf1[bufsize1] = 0;
+ wcsncpy(buf2, s2, bufsize2); buf2[bufsize2] = 0;
+
+ ret = wcscoll_l(buf1, buf2, (locale_t)__loc);
+ if (ret != 0) return ret;
+ s1 += bufsize1; n1 -= bufsize1;
+ s2 += bufsize2; n2 -= bufsize2;
+ }
+ return ret;
+}
+
+#endif
+
+size_t _Locale_strxfrm(struct _Locale_collate *__loc,
+ char *dest, size_t dest_n,
+ const char *src, size_t src_n )
+{
+ const char *real_src;
+ char *buf = NULL;
+ size_t result;
+
+ if (src_n == 0)
+ {
+ if (dest != NULL) dest[0] = 0;
+ return 0;
+ }
+ if (src[src_n] != 0) {
+ buf = malloc(src_n + 1);
+ strncpy(buf, src, src_n);
+ buf[src_n] = 0;
+ real_src = buf;
+ }
+ else
+ real_src = src;
+ result = strxfrm_l(dest, real_src, dest_n, (locale_t)__loc);
+ if (buf != NULL) free(buf);
+ return result;
+}
+
+# ifndef _STLP_NO_WCHAR_T
+
+size_t _WLocale_strxfrm( struct _Locale_collate *__loc,
+ wchar_t *dest, size_t dest_n,
+ const wchar_t *src, size_t src_n )
+{
+ const wchar_t *real_src;
+ wchar_t *buf = NULL;
+ size_t result;
+
+ if (src_n == 0)
+ {
+ if (dest != NULL) dest[0] = 0;
+ return 0;
+ }
+ if (src[src_n] != 0) {
+ buf = malloc((src_n + 1) * sizeof(wchar_t));
+ wcsncpy(buf, src, src_n);
+ buf[src_n] = 0;
+ real_src = buf;
+ }
+ else
+ real_src = src;
+ result = wcsxfrm_l(dest, real_src, dest_n, (locale_t)__loc);
+ if (buf != NULL) free(buf);
+ return result;
+}
+
+# endif
+
+/* Numeric */
+
+char _Locale_decimal_point(struct _Locale_numeric *__loc)
+{
+ return *(nl_langinfo_l(RADIXCHAR, (locale_t)__loc));
+}
+
+char _Locale_thousands_sep(struct _Locale_numeric *__loc)
+{
+ return *(nl_langinfo_l(THOUSEP, (locale_t)__loc));
+}
+
+const char* _Locale_grouping(struct _Locale_numeric *__loc)
+{
+ return (_Locale_thousands_sep(__loc) != 0 ) ? (nl_langinfo_l(GROUPING, (locale_t)__loc)) : _empty_str;
+}
+
+const char *_Locale_true(struct _Locale_numeric *__loc)
+{
+ return nl_langinfo_l(YESSTR, (locale_t)__loc);
+}
+
+const char *_Locale_false(struct _Locale_numeric *__loc)
+{
+ return nl_langinfo_l(NOSTR, (locale_t)__loc);
+}
+
+#ifndef _STLP_NO_WCHAR_T
+wchar_t _WLocale_decimal_point(struct _Locale_numeric *__loc)
+{ return (wchar_t)_Locale_decimal_point(__loc); }
+wchar_t _WLocale_thousands_sep(struct _Locale_numeric *__loc)
+{ return (wchar_t)_Locale_thousands_sep(__loc); }
+const wchar_t *_WLocale_true(struct _Locale_numeric *__loc, wchar_t *buf, size_t bufSize)
+{ return _ToWChar(_Locale_true(__loc), buf, bufSize); }
+const wchar_t *_WLocale_false(struct _Locale_numeric *__loc, wchar_t *buf, size_t bufSize)
+{ return _ToWChar(_Locale_false(__loc), buf, bufSize); }
+#endif
+
+/* Monetary */
+
+const char *_Locale_int_curr_symbol(struct _Locale_monetary *__loc)
+{
+ return nl_langinfo_l(INT_CURR_SYMBOL, (locale_t)__loc);
+}
+
+const char *_Locale_currency_symbol(struct _Locale_monetary *__loc)
+{
+ return nl_langinfo_l(CURRENCY_SYMBOL, (locale_t)__loc);
+}
+
+char _Locale_mon_decimal_point(struct _Locale_monetary * __loc)
+{
+ return *(nl_langinfo_l(MON_DECIMAL_POINT,(locale_t)__loc));
+}
+
+char _Locale_mon_thousands_sep(struct _Locale_monetary *__loc)
+{
+ return *(nl_langinfo_l(MON_THOUSANDS_SEP, (locale_t)__loc));
+}
+
+#ifndef _STLP_NO_WCHAR_T
+const wchar_t *_WLocale_int_curr_symbol(struct _Locale_monetary *__loc, wchar_t *buf, size_t bufSize)
+{ return _ToWChar(_Locale_int_curr_symbol(__loc), buf, bufSize); }
+const wchar_t *_WLocale_currency_symbol(struct _Locale_monetary *__loc, wchar_t *buf, size_t bufSize)
+{ return _ToWChar(_Locale_currency_symbol(__loc), buf, bufSize); }
+wchar_t _WLocale_mon_decimal_point(struct _Locale_monetary * __loc)
+{ return (wchar_t)_Locale_mon_decimal_point(__loc); }
+wchar_t _WLocale_mon_thousands_sep(struct _Locale_monetary * __loc)
+{ return (wchar_t)_Locale_mon_thousands_sep(__loc); }
+const wchar_t *_WLocale_positive_sign(struct _Locale_monetary *__loc, wchar_t *buf, size_t bufSize)
+{ return _ToWChar(_Locale_positive_sign(__loc), buf, bufSize); }
+const wchar_t *_WLocale_negative_sign(struct _Locale_monetary *__loc, wchar_t *buf, size_t bufSize)
+{ return _ToWChar(_Locale_negative_sign(__loc), buf, bufSize); }
+#endif
+
+const char *_Locale_mon_grouping(struct _Locale_monetary *__loc)
+{
+ return (_Locale_mon_thousands_sep( __loc ) != 0 ) ? nl_langinfo_l(MON_GROUPING, (locale_t)__loc) : _empty_str;
+}
+
+const char *_Locale_positive_sign(struct _Locale_monetary *__loc)
+{
+ return nl_langinfo_l(POSITIVE_SIGN, (locale_t)__loc);
+}
+
+const char *_Locale_negative_sign(struct _Locale_monetary *__loc)
+{
+ return nl_langinfo_l(NEGATIVE_SIGN, (locale_t)__loc);
+}
+
+char _Locale_int_frac_digits(struct _Locale_monetary *__loc)
+{
+ /* We are forced to manually handled the "C" locale for consistency with
+ * the default implementation in STLport. */
+ const char* lname = ((locale_t)__loc)->__names[LC_MONETARY];
+ if (lname[0] == 'C' && lname[1] == 0)
+ return 0;
+ return *(nl_langinfo_l(INT_FRAC_DIGITS, (locale_t)__loc));
+}
+
+char _Locale_frac_digits(struct _Locale_monetary *__loc)
+{
+ /* We are forced to manually handled the "C" locale for consistency with
+ * the default implementation in STLport. */
+ const char* lname = ((locale_t)__loc)->__names[LC_MONETARY];
+ if (lname[0] == 'C' && lname[1] == 0)
+ return 0;
+ return *(nl_langinfo_l(FRAC_DIGITS, (locale_t)__loc));
+}
+
+/* 1 if currency_symbol precedes a positive value, 0 if succeeds */
+int _Locale_p_cs_precedes(struct _Locale_monetary *__loc)
+{
+ return *(nl_langinfo_l(P_CS_PRECEDES, (locale_t)__loc));
+}
+
+/* 1 if a space separates currency_symbol from a positive value. */
+int _Locale_p_sep_by_space(struct _Locale_monetary *__loc)
+{
+ return *(nl_langinfo_l(P_SEP_BY_SPACE, (locale_t)__loc));
+}
+
+/*
+ * 0 Parentheses surround the quantity and currency_symbol
+ * 1 The sign string precedes the quantity and currency_symbol
+ * 2 The sign string succeeds the quantity and currency_symbol.
+ * 3 The sign string immediately precedes the currency_symbol.
+ * 4 The sign string immediately succeeds the currency_symbol.
+ */
+int _Locale_p_sign_posn(struct _Locale_monetary *__loc)
+{
+ return *(nl_langinfo_l(P_SIGN_POSN, (locale_t)__loc));
+}
+
+/* 1 if currency_symbol precedes a negative value, 0 if succeeds */
+int _Locale_n_cs_precedes(struct _Locale_monetary *__loc)
+{
+ return *(nl_langinfo_l(N_CS_PRECEDES, (locale_t)__loc));
+}
+
+/* 1 if a space separates currency_symbol from a negative value. */
+int _Locale_n_sep_by_space(struct _Locale_monetary *__loc)
+{
+ return *(nl_langinfo_l(N_SEP_BY_SPACE, (locale_t)__loc));
+}
+
+/*
+ * 0 Parentheses surround the quantity and currency_symbol
+ * 1 The sign string precedes the quantity and currency_symbol
+ * 2 The sign string succeeds the quantity and currency_symbol.
+ * 3 The sign string immediately precedes the currency_symbol.
+ * 4 The sign string immediately succeeds the currency_symbol.
+ */
+int _Locale_n_sign_posn(struct _Locale_monetary *__loc)
+{
+ return *(nl_langinfo_l(N_SIGN_POSN, (locale_t)__loc));
+}
+
+
+/* Time */
+const char *_Locale_full_monthname(struct _Locale_time *__loc, int _m )
+{
+ return nl_langinfo_l(MON_1 + _m, (locale_t)__loc);
+}
+
+const char *_Locale_abbrev_monthname(struct _Locale_time *__loc, int _m )
+{
+ return nl_langinfo_l(ABMON_1 + _m, (locale_t)__loc);
+}
+
+const char *_Locale_full_dayofweek(struct _Locale_time *__loc, int _d )
+{
+ return nl_langinfo_l(DAY_1 + _d, (locale_t)__loc);
+}
+
+const char *_Locale_abbrev_dayofweek(struct _Locale_time *__loc, int _d )
+{
+ return nl_langinfo_l(ABDAY_1 + _d, (locale_t)__loc);
+}
+
+const char *_Locale_d_t_fmt(struct _Locale_time *__loc)
+{
+ return nl_langinfo_l(D_T_FMT, (locale_t)__loc);
+}
+
+const char *_Locale_d_fmt(struct _Locale_time *__loc )
+{
+ return nl_langinfo_l(D_FMT, (locale_t)__loc);
+}
+
+const char *_Locale_t_fmt(struct _Locale_time *__loc )
+{
+ return nl_langinfo_l(T_FMT, (locale_t)__loc);
+}
+
+const char *_Locale_long_d_t_fmt(struct _Locale_time *__loc )
+{
+ return nl_langinfo_l(ERA_D_T_FMT, (locale_t)__loc);
+}
+
+const char *_Locale_long_d_fmt(struct _Locale_time *__loc )
+{
+ return nl_langinfo_l(ERA_D_FMT, (locale_t)__loc);
+}
+
+const char *_Locale_am_str(struct _Locale_time *__loc )
+{
+ return nl_langinfo_l(AM_STR, (locale_t)__loc);
+}
+
+const char *_Locale_pm_str(struct _Locale_time* __loc )
+{
+ return nl_langinfo_l(PM_STR, (locale_t)__loc);
+}
+
+#ifndef _STLP_NO_WCHAR_T
+const wchar_t *_WLocale_full_monthname(struct _Locale_time *__loc, int _m, wchar_t *buf, size_t bufSize)
+{ return _ToWChar(_Locale_full_monthname(__loc, _m), buf, bufSize); }
+const wchar_t *_WLocale_abbrev_monthname(struct _Locale_time *__loc, int _m, wchar_t *buf, size_t bufSize)
+{ return _ToWChar(_Locale_abbrev_monthname(__loc, _m), buf, bufSize); }
+const wchar_t *_WLocale_full_dayofweek(struct _Locale_time *__loc, int _d, wchar_t *buf, size_t bufSize)
+{ return _ToWChar(_Locale_full_dayofweek(__loc, _d), buf, bufSize); }
+const wchar_t *_WLocale_abbrev_dayofweek(struct _Locale_time *__loc, int _d, wchar_t *buf, size_t bufSize)
+{ return _ToWChar(_Locale_abbrev_dayofweek(__loc, _d), buf, bufSize); }
+const wchar_t *_WLocale_am_str(struct _Locale_time *__loc, wchar_t *buf, size_t bufSize)
+{ return _ToWChar(_Locale_am_str(__loc), buf, bufSize); }
+const wchar_t *_WLocale_pm_str(struct _Locale_time* __loc, wchar_t *buf, size_t bufSize)
+{ return _ToWChar(_Locale_pm_str(__loc), buf, bufSize); }
+#endif
+
+/* Messages */
+
+nl_catd_type _Locale_catopen(struct _Locale_messages *__loc, const char *__cat_name )
+{
+ return catopen( __cat_name, NL_CAT_LOCALE );
+}
+
+void _Locale_catclose(struct _Locale_messages *__loc, nl_catd_type __cat )
+{
+ catclose( __cat );
+}
+
+const char *_Locale_catgets(struct _Locale_messages *__loc, nl_catd_type __cat,
+ int __setid, int __msgid, const char *dfault)
+{
+ return catgets( __cat, __setid, __msgid, dfault );
+}
diff --git a/sources/android/stlport/src/c_locale_win32/c_locale_win32.c b/sources/android/stlport/src/c_locale_win32/c_locale_win32.c
new file mode 100644
index 0000000..dab958d
--- /dev/null
+++ b/sources/android/stlport/src/c_locale_win32/c_locale_win32.c
@@ -0,0 +1,1786 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * Written 2000
+ * Anton Lapach
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#include <limits.h>
+#if defined (_STLP_MSVC) || defined (__ICL)
+# include <memory.h>
+#endif
+#include <string.h>
+#include <locale.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#if defined (_STLP_USE_SAFE_STRING_FUNCTIONS)
+# define _STLP_STRCPY(D, DS, S) strcpy_s(D, DS, S)
+# define _STLP_STRNCPY(D, DS, S, C) strncpy_s(D, DS, S, C)
+# define _STLP_STRCAT(D, DS, S) strcat_s(D, DS, S)
+#else
+# define _STLP_STRCPY(D, DS, S) strcpy(D, S)
+# define _STLP_STRNCPY(D, DS, S, C) strncpy(D, S, C)
+# define _STLP_STRCAT(D, DS, S) strcat(D, S)
+#endif
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* Framework functions */
+/*
+ locale :: "lang[_country[.code_page]]"
+ | ".code_page"
+ | ""
+ | NULL
+
+*/
+
+typedef struct _LOCALECONV {
+ const char* name;
+ const char* abbrev;
+} LOCALECONV;
+
+#define MAX_LANG_LEN 64 /* max language name length */
+#define MAX_CTRY_LEN 64 /* max country name length */
+#define MAX_MODIFIER_LEN 0 /* max modifier name length - n/a */
+#define MAX_LC_LEN (MAX_LANG_LEN+MAX_CTRY_LEN+MAX_MODIFIER_LEN+3)
+ /* max entire locale string length */
+#define MAX_CP_LEN 5 /* max code page name length */
+
+#if !defined (LANG_INVARIANT)
+# define LANG_INVARIANT 0x7f
+# define _STLP_LANG_INVARIANT_DEFINED
+#endif
+
+#ifndef CP_UTF7
+# define CP_UTF7 65000
+#endif
+
+#ifndef CP_UTF8
+# define CP_UTF8 65001
+#endif
+
+#define INVARIANT_LCID MAKELCID(MAKELANGID(LANG_INVARIANT, SUBLANG_NEUTRAL), SORT_DEFAULT)
+
+static const char *_C_name = "C";
+
+/* non-NLS language string table */
+static LOCALECONV __rg_language[] = {
+ {"american", "ENU"},
+ {"american english", "ENU"},
+ {"american-english", "ENU"},
+ {"australian", "ENA"},
+ {"belgian", "NLB"},
+ {"canadian", "ENC"},
+ {"chh", "ZHH"},
+ {"chi", "ZHI"},
+ {"chinese", "CHS"},
+ {"chinese-hongkong", "ZHH"},
+ {"chinese-simplified", "CHS"},
+ {"chinese-singapore", "ZHI"},
+ {"chinese-traditional", "CHT"},
+ {"dutch-belgian", "NLB"},
+ {"english-american", "ENU"},
+ {"english-aus", "ENA"},
+ {"english-belize", "ENL"},
+ {"english-can", "ENC"},
+ {"english-caribbean", "ENB"},
+ {"english-ire", "ENI"},
+ {"english-jamaica", "ENJ"},
+ {"english-nz", "ENZ"},
+ {"english-south africa", "ENS"},
+ {"english-trinidad y tobago", "ENT"},
+ {"english-uk", "ENG"},
+ {"english-us", "ENU"},
+ {"english-usa", "ENU"},
+ {"french-belgian", "FRB"},
+ {"french-canadian", "FRC"},
+ {"french-luxembourg", "FRL"},
+ {"french-swiss", "FRS"},
+ {"german-austrian", "DEA"},
+ {"german-lichtenstein", "DEC"},
+ {"german-luxembourg", "DEL"},
+ {"german-swiss", "DES"},
+ {"irish-english", "ENI"},
+ {"italian-swiss", "ITS"},
+ {"norwegian", "NOR"},
+ {"norwegian-bokmal", "NOR"},
+ {"norwegian-nynorsk", "NON"},
+ {"portuguese-brazilian", "PTB"},
+ {"spanish-argentina", "ESS"},
+ {"spanish-bolivia", "ESB"},
+ {"spanish-chile", "ESL"},
+ {"spanish-colombia", "ESO"},
+ {"spanish-costa rica", "ESC"},
+ {"spanish-dominican republic", "ESD"},
+ {"spanish-ecuador", "ESF"},
+ {"spanish-el salvador", "ESE"},
+ {"spanish-guatemala", "ESG"},
+ {"spanish-honduras", "ESH"},
+ {"spanish-mexican", "ESM"},
+ {"spanish-modern", "ESN"},
+ {"spanish-nicaragua", "ESI"},
+ {"spanish-panama", "ESA"},
+ {"spanish-paraguay", "ESZ"},
+ {"spanish-peru", "ESR"},
+ {"spanish-puerto rico", "ESU"},
+ {"spanish-uruguay", "ESY"},
+ {"spanish-venezuela", "ESV"},
+ {"swedish-finland", "SVF"},
+ {"swiss", "DES"},
+ {"uk", "ENG"},
+ {"us", "ENU"},
+ {"usa", "ENU"}
+};
+
+/* non-NLS country string table */
+static LOCALECONV __rg_country[] = {
+ {"america", "USA"},
+ {"britain", "GBR"},
+ {"china", "CHN"},
+ {"czech", "CZE"},
+ {"england", "GBR"},
+ {"great britain", "GBR"},
+ {"holland", "NLD"},
+ {"hong-kong", "HKG"},
+ {"new-zealand", "NZL"},
+ {"nz", "NZL"},
+ {"pr china", "CHN"},
+ {"pr-china", "CHN"},
+ {"puerto-rico", "PRI"},
+ {"slovak", "SVK"},
+ {"south africa", "ZAF"},
+ {"south korea", "KOR"},
+ {"south-africa", "ZAF"},
+ {"south-korea", "KOR"},
+ {"trinidad & tobago", "TTO"},
+ {"uk", "GBR"},
+ {"united-kingdom", "GBR"},
+ {"united-states", "USA"},
+ {"us", "USA"},
+};
+
+typedef struct _Locale_name_hint {
+ LCID id;
+} _Locale_lcid_t;
+
+typedef struct _Locale_ctype {
+ _Locale_lcid_t lc;
+ UINT cp;
+ unsigned short ctable[256];
+} _Locale_ctype_t;
+
+typedef struct _Locale_numeric {
+ _Locale_lcid_t lc;
+ char cp[MAX_CP_LEN + 1];
+ char decimal_point[4];
+ char thousands_sep[4];
+ char *grouping;
+} _Locale_numeric_t;
+
+typedef struct _Locale_time {
+ _Locale_lcid_t lc;
+ char cp[MAX_CP_LEN + 1];
+ char *month[12];
+ char *abbrev_month[12];
+ char *dayofweek[7];
+ char *abbrev_dayofweek[7];
+ char *date_time_format;
+ char *long_date_time_format;
+ char *date_format;
+ char *long_date_format;
+ char *time_format;
+ char am[9];
+ char pm[9];
+} _Locale_time_t;
+
+typedef struct _Locale_collate {
+ _Locale_lcid_t lc;
+ char cp[MAX_CP_LEN + 1];
+} _Locale_collate_t;
+
+typedef struct _Locale_monetary {
+ _Locale_lcid_t lc;
+ char cp[MAX_CP_LEN + 1];
+ char decimal_point[4];
+ char thousands_sep[4];
+ char *grouping;
+ char int_curr_symbol[5]; /* 3 + 1 + 1 */
+ char curr_symbol[6];
+ char negative_sign[5];
+ char positive_sign[5];
+ int frac_digits;
+ int int_frac_digits;
+} _Locale_monetary_t;
+
+/* Internal function */
+static void __FixGrouping(char *grouping);
+static const char* __ConvertName(const char* lname, LOCALECONV* ConvTable, int TableSize);
+static int __ParseLocaleString(const char* lname, char* lang, char* ctry, char* page);
+static int __GetLCID(const char* lang, const char* ctry, LCID* lcid);
+static int __GetLCIDFromName(const char* lname, LCID* lcid, char *cp, _Locale_lcid_t *hint);
+static char const* __GetLocaleName(LCID lcid, const char* cp, char* buf);
+static char const* __Extract_locale_name(const char* loc, const char* category, char* buf);
+static char const* __TranslateToSystem(const char* lname, char* buf, _Locale_lcid_t* hint, int *__err_code);
+static void __GetLocaleInfoUsingACP(LCID lcid, const char* cp, LCTYPE lctype, char* buf, int buf_size, wchar_t* wbuf, int wbuf_size);
+static int __intGetACP(LCID lcid);
+static int __intGetOCP(LCID lcid);
+static int __GetDefaultCP(LCID lcid);
+static char* __ConvertToCP(int from_cp, int to_cp, const char *from, size_t size, size_t *ret_buf_size);
+static void my_ltoa(long __x, char* buf);
+
+void my_ltoa(long __x, char* buf) {
+ char rbuf[64];
+ char* ptr = rbuf;
+
+ if (__x == 0)
+ *ptr++ = '0';
+ else {
+ for (; __x != 0; __x /= 10)
+ *ptr++ = (char)(__x % 10) + '0';
+ }
+ while(ptr > rbuf) *buf++ = *--ptr;
+ /* psw */
+ *buf = '\0';
+}
+
+#if defined (__cplusplus)
+_STLP_BEGIN_NAMESPACE
+extern "C" {
+#endif
+
+_Locale_lcid_t* _Locale_get_ctype_hint(_Locale_ctype_t* ltype)
+{ return (ltype != 0) ? <ype->lc : 0; }
+_Locale_lcid_t* _Locale_get_numeric_hint(_Locale_numeric_t* lnumeric)
+{ return (lnumeric != 0) ? &lnumeric->lc : 0; }
+_Locale_lcid_t* _Locale_get_time_hint(_Locale_time_t* ltime)
+{ return (ltime != 0) ? <ime->lc : 0; }
+_Locale_lcid_t* _Locale_get_collate_hint(_Locale_collate_t* lcollate)
+{ return (lcollate != 0) ? &lcollate->lc : 0; }
+_Locale_lcid_t* _Locale_get_monetary_hint(_Locale_monetary_t* lmonetary)
+{ return (lmonetary != 0) ? &lmonetary->lc : 0; }
+_Locale_lcid_t* _Locale_get_messages_hint(struct _Locale_messages* lmessages) {
+ _STLP_MARK_PARAMETER_AS_UNUSED(lmessages)
+ return 0;
+}
+
+#define MAP(x, y) if ((mask & x) != 0) ret |= (y)
+unsigned short MapCtypeMask(unsigned short mask) {
+ unsigned short ret = 0;
+ MAP(C1_UPPER, _Locale_UPPER | _Locale_PRINT);
+ MAP(C1_LOWER, _Locale_LOWER | _Locale_PRINT);
+ MAP(C1_DIGIT, _Locale_DIGIT | _Locale_PRINT);
+ MAP(C1_SPACE, _Locale_SPACE | _Locale_PRINT);
+ MAP(C1_PUNCT, _Locale_PUNCT | _Locale_PRINT);
+ /* MAP(C1_BLANK, ?); */
+ MAP(C1_XDIGIT, _Locale_XDIGIT | _Locale_PRINT);
+ MAP(C1_ALPHA, _Locale_ALPHA | _Locale_PRINT);
+ if ((mask & C1_CNTRL) != 0) { ret |= _Locale_CNTRL; ret &= ~_Locale_PRINT; }
+ return ret;
+}
+
+static void MapCtypeMasks(unsigned short *cur, unsigned short *end) {
+ for (; cur != end; ++cur) {
+ *cur = MapCtypeMask(*cur);
+ }
+}
+
+_Locale_ctype_t* _Locale_ctype_create(const char * name, _Locale_lcid_t* lc_hint, int *__err_code) {
+ char cp_name[MAX_CP_LEN + 1];
+ int NativeCP;
+ unsigned char Buffer[256];
+ unsigned char *ptr;
+ CPINFO CPInfo;
+ int i;
+ wchar_t *wbuffer;
+ int BufferSize;
+
+ _Locale_ctype_t *ltype = (_Locale_ctype_t*)malloc(sizeof(_Locale_ctype_t));
+
+ if (!ltype) { *__err_code = _STLP_LOC_NO_MEMORY; return ltype; }
+ memset(ltype, 0, sizeof(_Locale_ctype_t));
+
+ if (__GetLCIDFromName(name, <ype->lc.id, cp_name, lc_hint) == -1)
+ { free(ltype); *__err_code = _STLP_LOC_UNKNOWN_NAME; return NULL; }
+
+#if defined (__BORLANDC__)
+ if ( ltype->lc.id == INVARIANT_LCID && name[0] == 'C' && name[1] == 0 )
+ { ltype->lc.id = 0x409; }
+#endif
+
+ ltype->cp = atoi(cp_name);
+
+ NativeCP = __GetDefaultCP(ltype->lc.id);
+
+ /* Make table with all characters. */
+ for (i = 0; i < 256; ++i) Buffer[i] = (unsigned char)i;
+
+ if (!GetCPInfo(NativeCP, &CPInfo)) { free(ltype); return NULL; }
+
+ if (CPInfo.MaxCharSize > 1) {
+ for (ptr = (unsigned char*)CPInfo.LeadByte; *ptr && *(ptr + 1); ptr+=2)
+ for (i = *ptr; i <= *(ptr + 1); ++i) Buffer[i] = 0;
+ }
+
+ if ((UINT)NativeCP != ltype->cp) {
+ OSVERSIONINFO ver_info;
+ ver_info.dwOSVersionInfoSize = sizeof(ver_info);
+ GetVersionEx(&ver_info);
+ if (ver_info.dwPlatformId == VER_PLATFORM_WIN32_NT) {
+ /* Convert character sequence to Unicode. */
+ BufferSize = MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, (const char*)Buffer, 256, NULL, 0);
+ if (!BufferSize) { free(ltype); *__err_code = _STLP_LOC_UNKNOWN_NAME; return NULL; }
+ wbuffer = (wchar_t*)malloc(BufferSize * sizeof(wchar_t));
+ if (!wbuffer) { free(ltype); *__err_code = _STLP_LOC_NO_MEMORY; return NULL; }
+ MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, (const char*)Buffer, 256, wbuffer, BufferSize);
+
+ GetStringTypeW(CT_CTYPE1, wbuffer, 256, ltype->ctable);
+ MapCtypeMasks(ltype->ctable, ltype->ctable + 256);
+ free(wbuffer);
+ }
+ else {
+ unsigned short ctable[256];
+ unsigned char TargetBuffer[256];
+ GetStringTypeA(ltype->lc.id, CT_CTYPE1, (const char*)Buffer, 256, ctable);
+
+ /* Convert character sequence to target code page. */
+ BufferSize = MultiByteToWideChar(NativeCP, MB_PRECOMPOSED, (const char*)Buffer, 256, NULL, 0);
+ if (!BufferSize) { free(ltype); *__err_code = _STLP_LOC_UNKNOWN_NAME; return NULL; }
+ wbuffer = (wchar_t*)malloc(BufferSize * sizeof(wchar_t));
+ if (!wbuffer) { free(ltype); *__err_code = _STLP_LOC_NO_MEMORY; return NULL; }
+ MultiByteToWideChar(NativeCP, MB_PRECOMPOSED, (const char*)Buffer, 256, wbuffer, BufferSize);
+ if (!WideCharToMultiByte(ltype->cp, WC_COMPOSITECHECK | WC_SEPCHARS, wbuffer, BufferSize, (char*)TargetBuffer, 256, NULL, FALSE))
+ { free(wbuffer); free(ltype); *__err_code = _STLP_LOC_UNKNOWN_NAME; return NULL; }
+
+ free(wbuffer);
+
+ /* Translate ctype table. */
+ for (i = 0; i < 256; ++i) {
+ if (!TargetBuffer[i]) continue;
+ ltype->ctable[TargetBuffer[i]] = MapCtypeMask(ctable[i]);
+ }
+ }
+ }
+ else {
+ GetStringTypeA(ltype->lc.id, CT_CTYPE1, (const char*)Buffer, 256, ltype->ctable);
+ MapCtypeMasks(ltype->ctable, ltype->ctable + 256);
+ }
+ return ltype;
+}
+
+_Locale_numeric_t* _Locale_numeric_create(const char * name, _Locale_lcid_t* lc_hint, int *__err_code) {
+ wchar_t wbuf[4];
+ char *GroupingBuffer;
+ int BufferSize;
+
+ _Locale_numeric_t *lnum = (_Locale_numeric_t*)malloc(sizeof(_Locale_numeric_t));
+ if (!lnum) { *__err_code = _STLP_LOC_NO_MEMORY; return lnum; }
+ memset(lnum, 0, sizeof(_Locale_numeric_t));
+
+ if (__GetLCIDFromName(name, &lnum->lc.id, lnum->cp, lc_hint) == -1)
+ { free(lnum); *__err_code = _STLP_LOC_UNKNOWN_NAME; return NULL; }
+
+#if defined (__BORLANDC__)
+ if (lnum->lc.id != INVARIANT_LCID) {
+#endif
+ __GetLocaleInfoUsingACP(lnum->lc.id, lnum->cp, LOCALE_SDECIMAL, lnum->decimal_point, 4, wbuf, 4);
+ __GetLocaleInfoUsingACP(lnum->lc.id, lnum->cp, LOCALE_STHOUSAND, lnum->thousands_sep, 4, wbuf, 4);
+#if defined (__BORLANDC__)
+ }
+ else
+ lnum->decimal_point[0] = '.';
+#endif
+
+ if (lnum->lc.id != INVARIANT_LCID) {
+ BufferSize = GetLocaleInfoA(lnum->lc.id, LOCALE_SGROUPING, NULL, 0);
+ GroupingBuffer = (char*)malloc(BufferSize);
+ if (!GroupingBuffer) { free(lnum); *__err_code = _STLP_LOC_NO_MEMORY; return NULL; }
+ GetLocaleInfoA(lnum->lc.id, LOCALE_SGROUPING, GroupingBuffer, BufferSize);
+ __FixGrouping(GroupingBuffer);
+ lnum->grouping = GroupingBuffer;
+ }
+ else {
+ lnum->grouping = (char*)malloc(1);
+ if (!lnum->grouping) { free(lnum); *__err_code = _STLP_LOC_NO_MEMORY; return NULL; }
+ lnum->grouping[0] = 0;
+ }
+
+ return lnum;
+}
+
+static int __ConvertDate(const char *NTDate, char *buffer, int buf_size) {
+ /* This function will return an incomplete buffer if buffer is not long enough */
+ const char *cur_char;
+ char *cur_output, *end_output;
+
+ /* Correct time format. */
+ cur_char = NTDate;
+ cur_output = buffer;
+ end_output = cur_output + buf_size;
+ buf_size = 0;
+ while (*cur_char) {
+ if (cur_output && (cur_output == end_output)) break;
+ switch (*cur_char) {
+ case 'd':
+ {
+ if (*(cur_char + 1) == 'd') {
+ if (cur_output && (cur_output + 2 > end_output)) {
+ *cur_output = 0;
+ return ++buf_size;
+ }
+ if (*(cur_char + 2) == 'd') {
+ if (*(cur_char + 3) == 'd') {
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'A'; }
+ buf_size += 2;
+ cur_char += 3;
+ }
+ else {
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'a'; }
+ buf_size += 2;
+ cur_char += 2;
+ }
+ }
+ else {
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'd'; }
+ buf_size += 2;
+ cur_char++;
+ }
+ }
+ else {
+ if (cur_output && (cur_output + 3 > end_output)) {
+ *cur_output = 0;
+ return ++buf_size;
+ }
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = '#'; *(cur_output++) = 'd'; }
+ buf_size += 3;
+ }
+ }
+ break;
+ case 'M':
+ {
+ if (*(cur_char + 1) == 'M') {
+ if (cur_output && (cur_output + 2 > end_output)) {
+ *cur_output = 0;
+ return ++buf_size;
+ }
+ if (*(cur_char + 2) == 'M') {
+ if (*(cur_char + 3) == 'M') {
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'B'; }
+ buf_size += 2;
+ cur_char += 3;
+ }
+ else {
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'b'; }
+ buf_size += 2;
+ cur_char += 2;
+ }
+ }
+ else {
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'm'; }
+ buf_size += 2;
+ cur_char++;
+ }
+ }
+ else {
+ if (cur_output && (cur_output + 3 > end_output)) {
+ *cur_output = 0;
+ return ++buf_size;
+ }
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = '#'; *(cur_output++) = 'm'; }
+ buf_size += 3;
+ }
+ }
+ break;
+ case 'y':
+ {
+ if (*(cur_char + 1) == 'y') {
+ if (cur_output && (cur_output + 2 > end_output)) {
+ *cur_output = 0;
+ return ++buf_size;
+ }
+ if (*(cur_char + 2) == 'y' && *(cur_char + 3) == 'y') {
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'Y'; }
+ buf_size += 2;
+ cur_char += 3;
+ }
+ else {
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'y'; }
+ buf_size += 2;
+ cur_char++;
+ }
+ }
+ else {
+ if (cur_output && (cur_output + 3 > end_output)) {
+ *cur_output = 0;
+ return ++buf_size;
+ }
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = '#'; *(cur_output++) = 'y'; }
+ buf_size += 3;
+ }
+ }
+ break;
+ case '%':
+ {
+ if (cur_output && (cur_output + 2 > end_output)) {
+ *cur_output = 0;
+ return ++buf_size;
+ }
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = '%'; }
+ buf_size += 2;
+ }
+ break;
+ case '\'':
+ {
+ ++cur_char;
+ while (*cur_char != '\'' && *cur_char != 0 && (cur_output == NULL || cur_output != end_output)) {
+ if (cur_output) { *cur_output++ = *cur_char; }
+ ++cur_char;
+ buf_size += 1;
+ }
+ }
+ break;
+ default:
+ {
+ if (cur_output) { *(cur_output++) = *cur_char; }
+ buf_size += 1;
+ }
+ break;
+ }
+ if (*cur_char == 0) break;
+ ++cur_char;
+ }
+
+ if (!cur_output || cur_output != end_output) {
+ if (cur_output) *cur_output = 0;
+ buf_size += 1;
+ }
+ else {
+ /* We trunc result */
+ *(--cur_output) = 0;
+ }
+
+ return buf_size;
+}
+
+static int __ConvertTime(const char *NTTime, char *buffer, int buf_size) {
+ const char *cur_char;
+ char *cur_output, *end_output;
+ cur_char = NTTime;
+ cur_output = buffer;
+ end_output = cur_output + buf_size;
+ buf_size = 0;
+ while (*cur_char) {
+ switch(*cur_char) {
+ case 'h':
+ if (*(cur_char + 1) == 'h') {
+ if (cur_output && (cur_output + 2 > end_output)) {
+ *cur_output = 0;
+ return ++buf_size;
+ }
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'I'; }
+ buf_size += 2;
+ ++cur_char;
+ }
+ else {
+ if (cur_output && (cur_output + 3 > end_output)) {
+ *cur_output = 0;
+ return ++buf_size;
+ }
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = '#'; *(cur_output++) = 'I'; }
+ buf_size += 3;
+ }
+ break;
+ case 'H':
+ if (*(cur_char + 1) == 'H') {
+ if (cur_output && (cur_output + 2 > end_output)) {
+ *cur_output = 0;
+ return ++buf_size;
+ }
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'H'; }
+ buf_size += 2;
+ ++cur_char;
+ }
+ else {
+ if (cur_output && (cur_output + 3 > end_output)) {
+ *cur_output = 0;
+ return ++buf_size;
+ }
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = '#'; *(cur_output++) = 'H'; }
+ buf_size += 3;
+ }
+ break;
+ case 'm':
+ if (*(cur_char + 1) == 'm') {
+ if (cur_output && (cur_output + 2 > end_output)) {
+ *cur_output = 0;
+ return ++buf_size;
+ }
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'M'; }
+ buf_size += 2;
+ cur_char++;
+ }
+ else {
+ if (cur_output && (cur_output + 3 > end_output)) {
+ *cur_output = 0;
+ return ++buf_size;
+ }
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = '#'; *(cur_output++) = 'M'; }
+ buf_size += 3;
+ }
+ break;
+ case 's':
+ if (*(cur_char + 1) == 's') {
+ if (cur_output && (cur_output + 2 > end_output)) {
+ *cur_output = 0;
+ return ++buf_size;
+ }
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'S'; }
+ buf_size += 2;
+ ++cur_char;
+ }
+ else {
+ if (cur_output && (cur_output + 3 > end_output)) {
+ *cur_output = 0;
+ return ++buf_size;
+ }
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = '#'; *(cur_output++) = 'S'; }
+ buf_size += 3;
+ }
+ break;
+ case 't':
+ if (*(cur_char + 1) == 't')
+ ++cur_char;
+ if (cur_output && (cur_output + 2 > end_output)) {
+ *cur_output = 0;
+ return ++buf_size;
+ }
+ if (cur_output) { *(cur_output++) = '%'; *(cur_output++) = 'p'; }
+ buf_size += 2;
+ break;
+ case '%':
+ if (cur_output && (cur_output + 2 > end_output)) {
+ *cur_output = 0;
+ return ++buf_size;
+ }
+ if (cur_output) { *(cur_output++)='%'; *(cur_output++)='%'; }
+ buf_size += 2;
+ break;
+ case '\'':
+ ++cur_char;
+ while (*cur_char != '\'' && *cur_char != 0 && (!cur_output || (cur_output != end_output))) {
+ if (cur_output) *cur_output++ = *cur_char;
+ ++cur_char;
+ buf_size += 1;
+ }
+ break;
+ default:
+ if (cur_output) { *(cur_output++) = *cur_char; }
+ buf_size += 1;
+ break;
+ }
+ if (*cur_char == 0) break;
+ ++cur_char;
+ }
+
+ if (!cur_output || cur_output != end_output) {
+ if (cur_output) *cur_output = 0;
+ buf_size += 1;
+ }
+ else {
+ /* We trunc result */
+ *(--cur_output) = 0;
+ }
+
+ return buf_size;
+}
+
+_Locale_time_t* _Locale_time_create(const char * name, _Locale_lcid_t* lc_hint, int *__err_code) {
+ int size, month, dayofweek;
+ size_t length;
+ char fmt80[80];
+ wchar_t wbuf80[80];
+
+ _Locale_time_t *ltime = (_Locale_time_t*)malloc(sizeof(_Locale_time_t));
+
+ if (!ltime) { *__err_code = _STLP_LOC_NO_MEMORY; return ltime; }
+ memset(ltime, 0, sizeof(_Locale_time_t));
+
+ if (__GetLCIDFromName(name, <ime->lc.id, ltime->cp, lc_hint) == -1)
+ { free(ltime); *__err_code = _STLP_LOC_UNKNOWN_NAME; return NULL; }
+
+#if defined (__BORLANDC__)
+ if ( ltime->lc.id == INVARIANT_LCID && name[0] == 'C' && name[1] == 0 )
+ { ltime->lc.id = 0x409; }
+#endif
+
+ for (month = LOCALE_SMONTHNAME1; month <= LOCALE_SMONTHNAME12; ++month) { /* Small hack :-) */
+ size = GetLocaleInfoA(ltime->lc.id, month, NULL, 0);
+ ltime->month[month - LOCALE_SMONTHNAME1] = (char*)malloc(size);
+ if (!ltime->month[month - LOCALE_SMONTHNAME1])
+ { _Locale_time_destroy(ltime); *__err_code = _STLP_LOC_NO_MEMORY; return NULL; }
+ __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, month, ltime->month[month - LOCALE_SMONTHNAME1], size, wbuf80, 80);
+ }
+
+ for (month = LOCALE_SABBREVMONTHNAME1; month <= LOCALE_SABBREVMONTHNAME12; ++month) {
+ size = GetLocaleInfoA(ltime->lc.id, month, NULL, 0);
+ ltime->abbrev_month[month - LOCALE_SABBREVMONTHNAME1] = (char*)malloc(size);
+ if (!ltime->abbrev_month[month - LOCALE_SABBREVMONTHNAME1])
+ { _Locale_time_destroy(ltime); *__err_code = _STLP_LOC_NO_MEMORY; return NULL; }
+ __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, month, ltime->abbrev_month[month - LOCALE_SABBREVMONTHNAME1], size, wbuf80, 80);
+ }
+
+ for (dayofweek = LOCALE_SDAYNAME1; dayofweek <= LOCALE_SDAYNAME7; ++dayofweek) {
+ int dayindex = ( dayofweek != LOCALE_SDAYNAME7 ) ? dayofweek - LOCALE_SDAYNAME1 + 1 : 0;
+ size = GetLocaleInfoA(ltime->lc.id, dayofweek, NULL, 0);
+ ltime->dayofweek[dayindex] = (char*)malloc(size);
+ if (!ltime->dayofweek[dayindex])
+ { _Locale_time_destroy(ltime); *__err_code = _STLP_LOC_NO_MEMORY; return NULL; }
+ __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, dayofweek, ltime->dayofweek[dayindex], size, wbuf80, 80);
+ }
+
+ for (dayofweek = LOCALE_SABBREVDAYNAME1; dayofweek <= LOCALE_SABBREVDAYNAME7; ++dayofweek) {
+ int dayindex = ( dayofweek != LOCALE_SABBREVDAYNAME7 ) ? dayofweek - LOCALE_SABBREVDAYNAME1 + 1 : 0;
+ size = GetLocaleInfoA(ltime->lc.id, dayofweek, NULL, 0);
+ ltime->abbrev_dayofweek[dayindex] = (char*)malloc(size);
+ if (!ltime->abbrev_dayofweek[dayindex])
+ { _Locale_time_destroy(ltime); *__err_code = _STLP_LOC_NO_MEMORY; return NULL; }
+ __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, dayofweek, ltime->abbrev_dayofweek[dayindex], size, wbuf80, 80);
+ }
+
+ __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, LOCALE_SSHORTDATE, fmt80, 80, wbuf80, 80);
+ size = __ConvertDate(fmt80, NULL, 0);
+ ltime->date_format = (char*)malloc(size);
+ if (!ltime->date_format)
+ { _Locale_time_destroy(ltime); *__err_code = _STLP_LOC_NO_MEMORY; return NULL; }
+ __ConvertDate(fmt80, ltime->date_format, size);
+
+ __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, LOCALE_SLONGDATE, fmt80, 80, wbuf80, 80);
+ size = __ConvertDate(fmt80, NULL, 0);
+ ltime->long_date_format = (char*)malloc(size);
+ if (!ltime->long_date_format)
+ { _Locale_time_destroy(ltime);*__err_code = _STLP_LOC_NO_MEMORY; return NULL; }
+ __ConvertDate(fmt80, ltime->long_date_format, size);
+
+ __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, LOCALE_STIMEFORMAT, fmt80, 80, wbuf80, 80);
+ size = __ConvertTime(fmt80, NULL, 0);
+ ltime->time_format = (char*)malloc(size);
+ if (!ltime->time_format)
+ { _Locale_time_destroy(ltime); *__err_code = _STLP_LOC_NO_MEMORY; return NULL; }
+ __ConvertTime(fmt80, ltime->time_format, size);
+
+ /* NT doesn't provide this information, we must simulate. */
+ length = strlen(ltime->date_format) + strlen(ltime->time_format) + 1 /* space */ + 1 /* trailing 0 */;
+ ltime->date_time_format = (char*)malloc(length);
+ if (!ltime->date_time_format)
+ { _Locale_time_destroy(ltime); *__err_code = _STLP_LOC_NO_MEMORY; return NULL; }
+ _STLP_STRCPY(ltime->date_time_format, length, ltime->date_format);
+ _STLP_STRCAT(ltime->date_time_format, length, " ");
+ _STLP_STRCAT(ltime->date_time_format, length, ltime->time_format);
+
+ /* NT doesn't provide this information, we must simulate. */
+ length = strlen(ltime->long_date_format) + strlen(ltime->time_format) + 1 /* space */ + 1 /* trailing 0 */;
+ ltime->long_date_time_format = (char*)malloc(length);
+ if (!ltime->long_date_time_format)
+ { _Locale_time_destroy(ltime); *__err_code = _STLP_LOC_NO_MEMORY; return NULL; }
+ _STLP_STRCPY(ltime->long_date_time_format, length, ltime->long_date_format);
+ _STLP_STRCAT(ltime->long_date_time_format, length, " ");
+ _STLP_STRCAT(ltime->long_date_time_format, length, ltime->time_format);
+
+ __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, LOCALE_S1159, ltime->am, 9, wbuf80, 80);
+ __GetLocaleInfoUsingACP(ltime->lc.id, ltime->cp, LOCALE_S2359, ltime->pm, 9, wbuf80, 80);
+
+ return ltime;
+}
+
+_Locale_collate_t* _Locale_collate_create(const char * name, _Locale_lcid_t* lc_hint, int *__err_code) {
+ _Locale_collate_t *lcol = (_Locale_collate_t*)malloc(sizeof(_Locale_collate_t));
+ if (!lcol) { *__err_code = _STLP_LOC_NO_MEMORY; return lcol; }
+ memset(lcol, 0, sizeof(_Locale_collate_t));
+
+ if (__GetLCIDFromName(name, &lcol->lc.id, lcol->cp, lc_hint) == -1)
+ { free(lcol); *__err_code = _STLP_LOC_UNKNOWN_NAME; return NULL; }
+
+#if defined (__BORLANDC__)
+ if ( lcol->lc.id == INVARIANT_LCID && name[0] == 'C' && name[1] == 0 )
+ { lcol->lc.id = 0x409; }
+#endif
+
+ return lcol;
+}
+
+_Locale_monetary_t* _Locale_monetary_create(const char * name, _Locale_lcid_t* lc_hint, int *__err_code) {
+ char *GroupingBuffer;
+ int BufferSize;
+ char FracDigits[3];
+ wchar_t wbuf[6];
+
+ _Locale_monetary_t *lmon = (_Locale_monetary_t*)malloc(sizeof(_Locale_monetary_t));
+ if (!lmon) { *__err_code = _STLP_LOC_NO_MEMORY; return lmon; }
+ memset(lmon, 0, sizeof(_Locale_monetary_t));
+
+ if (__GetLCIDFromName(name, &lmon->lc.id, lmon->cp, lc_hint) == -1)
+ { free(lmon); *__err_code = _STLP_LOC_UNKNOWN_NAME; return NULL; }
+
+ if (lmon->lc.id != INVARIANT_LCID) {
+ /* Extract information about monetary system */
+ __GetLocaleInfoUsingACP(lmon->lc.id, lmon->cp, LOCALE_SDECIMAL, lmon->decimal_point, 4, wbuf, 6);
+ __GetLocaleInfoUsingACP(lmon->lc.id, lmon->cp, LOCALE_STHOUSAND, lmon->thousands_sep, 4, wbuf, 6);
+
+ BufferSize = GetLocaleInfoA(lmon->lc.id, LOCALE_SGROUPING, NULL, 0);
+ GroupingBuffer = (char*)malloc(BufferSize);
+ if (!GroupingBuffer)
+ { lmon->grouping = NULL; *__err_code = _STLP_LOC_NO_MEMORY; return lmon; }
+ GetLocaleInfoA(lmon->lc.id, LOCALE_SGROUPING, GroupingBuffer, BufferSize);
+ __FixGrouping(GroupingBuffer);
+ lmon->grouping = GroupingBuffer;
+
+ __GetLocaleInfoUsingACP(lmon->lc.id, lmon->cp, LOCALE_SCURRENCY, lmon->curr_symbol, 6, wbuf, 6);
+ __GetLocaleInfoUsingACP(lmon->lc.id, lmon->cp, LOCALE_SNEGATIVESIGN, lmon->negative_sign, 5, wbuf, 6);
+ __GetLocaleInfoUsingACP(lmon->lc.id, lmon->cp, LOCALE_SPOSITIVESIGN, lmon->positive_sign, 5, wbuf, 6);
+
+ GetLocaleInfoA(lmon->lc.id, LOCALE_ICURRDIGITS, FracDigits, 3);
+ lmon->frac_digits = atoi(FracDigits);
+
+ GetLocaleInfoA(lmon->lc.id, LOCALE_IINTLCURRDIGITS, FracDigits, 3);
+ lmon->int_frac_digits = atoi(FracDigits);
+
+ __GetLocaleInfoUsingACP(lmon->lc.id, lmon->cp, LOCALE_SINTLSYMBOL, lmon->int_curr_symbol, 5, wbuf, 6);
+ /* Even if Platform SDK documentation says that the returned symbol should
+ * be a 3 letters symbol followed by a seperation character, experimentation
+ * has shown that no seperation character is ever appended. We are adding it
+ * ourself to conform to the POSIX specification.
+ */
+ if (lmon->int_curr_symbol[3] == 0) {
+ lmon->int_curr_symbol[3] = ' ';
+ lmon->int_curr_symbol[4] = 0;
+ }
+ }
+ /* else it is already ok */
+
+ return lmon;
+}
+
+struct _Locale_messages* _Locale_messages_create(const char *name, _Locale_lcid_t* lc_hint, int *__err_code) {
+ /* The Win32 API has no support for messages facet */
+ _STLP_MARK_PARAMETER_AS_UNUSED(name)
+ _STLP_MARK_PARAMETER_AS_UNUSED(lc_hint)
+ *__err_code = _STLP_LOC_UNSUPPORTED_FACET_CATEGORY;
+ return NULL;
+}
+
+static const char* _Locale_common_default(char* buf) {
+ char cp[MAX_CP_LEN + 1];
+ int CodePage = __GetDefaultCP(LOCALE_USER_DEFAULT);
+ my_ltoa(CodePage, cp);
+ return __GetLocaleName(LOCALE_USER_DEFAULT, cp, buf);
+}
+
+const char* _Locale_ctype_default(char* buf)
+{ return _Locale_common_default(buf); }
+
+const char* _Locale_numeric_default(char * buf)
+{ return _Locale_common_default(buf); }
+
+const char* _Locale_time_default(char* buf)
+{ return _Locale_common_default(buf); }
+
+const char* _Locale_collate_default(char* buf)
+{ return _Locale_common_default(buf); }
+
+const char* _Locale_monetary_default(char* buf)
+{ return _Locale_common_default(buf); }
+
+const char* _Locale_messages_default(char* buf)
+{ return _Locale_common_default(buf); }
+
+char const* _Locale_ctype_name(const _Locale_ctype_t* ltype, char* buf) {
+ char cp_buf[MAX_CP_LEN + 1];
+ my_ltoa(ltype->cp, cp_buf);
+ return __GetLocaleName(ltype->lc.id, cp_buf, buf);
+}
+
+char const* _Locale_numeric_name(const _Locale_numeric_t* lnum, char* buf)
+{ return __GetLocaleName(lnum->lc.id, lnum->cp, buf); }
+
+char const* _Locale_time_name(const _Locale_time_t* ltime, char* buf)
+{ return __GetLocaleName(ltime->lc.id, ltime->cp, buf); }
+
+char const* _Locale_collate_name(const _Locale_collate_t* lcol, char* buf)
+{ return __GetLocaleName(lcol->lc.id, lcol->cp, buf); }
+
+char const* _Locale_monetary_name(const _Locale_monetary_t* lmon, char* buf)
+{ return __GetLocaleName(lmon->lc.id, lmon->cp, buf); }
+
+char const* _Locale_messages_name(const struct _Locale_messages* lmes, char* buf) {
+ _STLP_MARK_PARAMETER_AS_UNUSED(lmes)
+ _STLP_MARK_PARAMETER_AS_UNUSED(buf)
+ return NULL;
+}
+
+void _Locale_ctype_destroy(_Locale_ctype_t* ltype) {
+ if (!ltype) return;
+
+ free(ltype);
+}
+
+void _Locale_numeric_destroy(_Locale_numeric_t* lnum) {
+ if (!lnum) return;
+
+ if (lnum->grouping) free(lnum->grouping);
+ free(lnum);
+}
+
+void _Locale_time_destroy(_Locale_time_t* ltime) {
+ int i;
+ if (!ltime) return;
+
+ for (i = 0; i < 12; ++i) {
+ if (ltime->month[i]) free(ltime->month[i]);
+ if (ltime->abbrev_month[i]) free(ltime->abbrev_month[i]);
+ }
+
+ for (i = 0; i < 7; ++i) {
+ if (ltime->dayofweek[i]) free(ltime->dayofweek[i]);
+ if (ltime->abbrev_dayofweek[i]) free(ltime->abbrev_dayofweek[i]);
+ }
+
+ if (ltime->date_format) free(ltime->date_format);
+ if (ltime->long_date_format) free(ltime->long_date_format);
+ if (ltime->time_format) free(ltime->time_format);
+ if (ltime->date_time_format) free(ltime->date_time_format);
+ if (ltime->long_date_time_format) free(ltime->long_date_time_format);
+
+ free(ltime);
+}
+
+void _Locale_collate_destroy(_Locale_collate_t* lcol) {
+ if (!lcol) return;
+
+ free(lcol);
+}
+
+void _Locale_monetary_destroy(_Locale_monetary_t* lmon) {
+ if (!lmon) return;
+
+ if (lmon->grouping) free(lmon->grouping);
+ free(lmon);
+}
+
+void _Locale_messages_destroy(struct _Locale_messages* lmes)
+{ _STLP_MARK_PARAMETER_AS_UNUSED(lmes) }
+
+static char const* _Locale_extract_category_name(const char* name, const char* category, char* buf,
+ _Locale_lcid_t* hint, int *__err_code) {
+ const char* cname = __Extract_locale_name(name, category, buf);
+ if (cname == 0 || (cname[0] == 'C' && cname[1] == 0)) {
+ return cname;
+ }
+ return __TranslateToSystem(cname, buf, hint, __err_code);
+}
+
+char const* _Locale_extract_ctype_name(const char* cname, char* buf,
+ _Locale_lcid_t* hint, int *__err_code)
+{ return _Locale_extract_category_name(cname, "LC_CTYPE", buf, hint, __err_code); }
+
+char const* _Locale_extract_numeric_name(const char* cname, char* buf,
+ _Locale_lcid_t* hint, int *__err_code)
+{ return _Locale_extract_category_name(cname, "LC_NUMERIC", buf, hint, __err_code); }
+
+char const* _Locale_extract_time_name(const char* cname, char* buf,
+ _Locale_lcid_t* hint, int *__err_code)
+{ return _Locale_extract_category_name(cname, "LC_TIME", buf, hint, __err_code); }
+
+char const* _Locale_extract_collate_name(const char* cname, char* buf,
+ _Locale_lcid_t* hint, int *__err_code)
+{ return _Locale_extract_category_name(cname, "LC_COLLATE", buf, hint, __err_code); }
+
+char const* _Locale_extract_monetary_name(const char* cname, char* buf,
+ _Locale_lcid_t* hint, int *__err_code)
+{ return _Locale_extract_category_name(cname, "LC_MONETARY", buf, hint, __err_code); }
+
+char const* _Locale_extract_messages_name(const char* cname, char* buf,
+ _Locale_lcid_t* hint, int *__err_code) {
+ if (cname[0] == 'L' && cname[1] == 'C' && cname[2] == '_') {
+ return _C_name;
+ }
+ if (cname[0] == 'C' && cname[1] == 0) {
+ return _C_name;
+ }
+ return __TranslateToSystem(cname, buf, hint, __err_code);
+}
+
+/* ctype */
+
+const _Locale_mask_t* _Locale_ctype_table(_Locale_ctype_t* ltype) {
+ _STLP_STATIC_ASSERT(sizeof(_Locale_mask_t) == sizeof(ltype->ctable[0]))
+ return (const _Locale_mask_t*)ltype->ctable;
+}
+
+int _Locale_toupper(_Locale_ctype_t* ltype, int c) {
+ char buf[2], out_buf[2];
+ buf[0] = (char)c; buf[1] = 0;
+ if ((UINT)__GetDefaultCP(ltype->lc.id) == ltype->cp) {
+ LCMapStringA(ltype->lc.id, LCMAP_LINGUISTIC_CASING | LCMAP_UPPERCASE, buf, 2, out_buf, 2);
+ return out_buf[0];
+ }
+ else {
+ wchar_t wbuf[2];
+ MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, buf, 2, wbuf, 2);
+ WideCharToMultiByte(__GetDefaultCP(ltype->lc.id), WC_COMPOSITECHECK | WC_SEPCHARS, wbuf, 2, buf, 2, NULL, FALSE);
+
+ LCMapStringA(ltype->lc.id, LCMAP_LINGUISTIC_CASING | LCMAP_UPPERCASE, buf, 2, out_buf, 2);
+
+ MultiByteToWideChar(__GetDefaultCP(ltype->lc.id), MB_PRECOMPOSED, out_buf, 2, wbuf, 2);
+ WideCharToMultiByte(ltype->cp, WC_COMPOSITECHECK | WC_SEPCHARS, wbuf, 2, out_buf, 2, NULL, FALSE);
+ return out_buf[0];
+ }
+}
+
+int _Locale_tolower(_Locale_ctype_t* ltype, int c) {
+ char buf[2], out_buf[2];
+ buf[0] = (char)c; buf[1] = 0;
+ if ((UINT)__GetDefaultCP(ltype->lc.id) == ltype->cp) {
+ LCMapStringA(ltype->lc.id, LCMAP_LINGUISTIC_CASING | LCMAP_LOWERCASE, buf, 2, out_buf, 2);
+ return out_buf[0];
+ }
+ else {
+ wchar_t wbuf[2];
+ MultiByteToWideChar(ltype->cp, MB_PRECOMPOSED, buf, 2, wbuf, 2);
+ WideCharToMultiByte(__GetDefaultCP(ltype->lc.id), WC_COMPOSITECHECK | WC_SEPCHARS, wbuf, 2, buf, 2, NULL, FALSE);
+
+ LCMapStringA(ltype->lc.id, LCMAP_LINGUISTIC_CASING | LCMAP_LOWERCASE, buf, 2, out_buf, 2);
+
+ MultiByteToWideChar(__GetDefaultCP(ltype->lc.id), MB_PRECOMPOSED, out_buf, 2, wbuf, 2);
+ WideCharToMultiByte(ltype->cp, WC_COMPOSITECHECK | WC_SEPCHARS, wbuf, 2, out_buf, 2, NULL, FALSE);
+ return out_buf[0];
+ }
+}
+
+#ifndef CSTR_EQUAL /* VC5SP3*/
+# define CSTR_EQUAL 2
+#endif
+#ifndef CSTR_LESS_THAN /* VC5SP3 */
+# define CSTR_LESS_THAN 1
+#endif
+
+static DWORD max_DWORD = 0xffffffff;
+static DWORD trim_size_t_to_DWORD(size_t n) { return n < (size_t)max_DWORD ? (DWORD)n : max_DWORD; }
+
+/* Collate */
+/* This function takes care of the potential size_t DWORD different size. */
+static int _Locale_strcmp_auxA(_Locale_collate_t* lcol,
+ const char* s1, size_t n1,
+ const char* s2, size_t n2) {
+ int result = CSTR_EQUAL;
+ while (n1 > 0 || n2 > 0) {
+ DWORD size1 = trim_size_t_to_DWORD(n1);
+ DWORD size2 = trim_size_t_to_DWORD(n2);
+ result = CompareStringA(lcol->lc.id, 0, s1, size1, s2, size2);
+ if (result != CSTR_EQUAL)
+ break;
+ n1 -= size1;
+ n2 -= size2;
+ }
+ return result;
+}
+
+int _Locale_strcmp(_Locale_collate_t* lcol,
+ const char* s1, size_t n1,
+ const char* s2, size_t n2) {
+ int result;
+ if (__GetDefaultCP(lcol->lc.id) == atoi(lcol->cp)) {
+ result = _Locale_strcmp_auxA(lcol, s1, n1, s2, n2);
+ }
+ else {
+ char *buf1, *buf2;
+ size_t size1, size2;
+ buf1 = __ConvertToCP(atoi(lcol->cp), __GetDefaultCP(lcol->lc.id), s1, n1, &size1);
+ buf2 = __ConvertToCP(atoi(lcol->cp), __GetDefaultCP(lcol->lc.id), s2, n2, &size2);
+
+ result = _Locale_strcmp_auxA(lcol, buf1, size1, buf2, size2);
+ free(buf1); free(buf2);
+ }
+ return (result == CSTR_EQUAL) ? 0 : (result == CSTR_LESS_THAN) ? -1 : 1;
+}
+
+size_t _Locale_strxfrm(_Locale_collate_t* lcol,
+ char* dst, size_t dst_size,
+ const char* src, size_t src_size) {
+ int result;
+
+ /* The Windows API do not support transformation of very long strings (src_size > INT_MAX)
+ * In this case the result will just be the input string:
+ */
+ if (src_size > INT_MAX) {
+ if (dst != 0) {
+ _STLP_STRNCPY(dst, dst_size, src, src_size);
+ }
+ return src_size;
+ }
+ if (dst_size > INT_MAX) {
+ /* now that we know that src_size <= INT_MAX we can safely decrease dst_size to INT_MAX. */
+ dst_size = INT_MAX;
+ }
+
+ if (__GetDefaultCP(lcol->lc.id) == atoi(lcol->cp))
+ result = LCMapStringA(lcol->lc.id, LCMAP_SORTKEY, src, (int)src_size, dst, (int)dst_size);
+ else {
+ char *buf;
+ size_t size;
+ buf = __ConvertToCP(atoi(lcol->cp), __GetDefaultCP(lcol->lc.id), src, src_size, &size);
+
+ result = LCMapStringA(lcol->lc.id, LCMAP_SORTKEY, buf, (int)size, dst, (int)dst_size);
+ free(buf);
+ }
+ return result != 0 ? result - 1 : 0;
+}
+
+/* Numeric */
+static const char* __true_name = "true";
+static const char* __false_name = "false";
+
+char _Locale_decimal_point(_Locale_numeric_t* lnum)
+{ return lnum->decimal_point[0]; }
+
+char _Locale_thousands_sep(_Locale_numeric_t* lnum)
+{ return lnum->thousands_sep[0]; }
+
+const char* _Locale_grouping(_Locale_numeric_t * lnum) {
+ if (!lnum->grouping) return "";
+ else return lnum->grouping;
+}
+
+const char * _Locale_true(_Locale_numeric_t * lnum) {
+ _STLP_MARK_PARAMETER_AS_UNUSED(lnum)
+ return __true_name; /* NT does't provide information about this */
+}
+
+const char * _Locale_false(_Locale_numeric_t * lnum) {
+ _STLP_MARK_PARAMETER_AS_UNUSED(lnum)
+ return __false_name; /* NT does't provide information about this */
+}
+
+/* Monetary */
+const char* _Locale_int_curr_symbol(_Locale_monetary_t * lmon)
+{ return lmon->int_curr_symbol; }
+
+const char* _Locale_currency_symbol(_Locale_monetary_t * lmon)
+{ return lmon->curr_symbol; }
+
+char _Locale_mon_decimal_point(_Locale_monetary_t * lmon)
+{ return lmon->decimal_point[0]; }
+
+char _Locale_mon_thousands_sep(_Locale_monetary_t * lmon)
+{ return lmon->thousands_sep[0]; }
+
+const char* _Locale_mon_grouping(_Locale_monetary_t * lmon) {
+ if (!lmon->grouping) return "";
+ else return lmon->grouping;
+}
+
+const char* _Locale_positive_sign(_Locale_monetary_t * lmon)
+{ return lmon->positive_sign; }
+
+const char* _Locale_negative_sign(_Locale_monetary_t * lmon)
+{ return lmon->negative_sign; }
+
+char _Locale_int_frac_digits(_Locale_monetary_t * lmon)
+{ return (char)lmon->int_frac_digits; }
+
+char _Locale_frac_digits(_Locale_monetary_t * lmon)
+{ return (char)lmon->frac_digits; }
+
+int _Locale_p_cs_precedes(_Locale_monetary_t * lmon) {
+ char loc_data[2];
+ GetLocaleInfoA(lmon->lc.id, LOCALE_IPOSSYMPRECEDES, loc_data, 2);
+ if (loc_data[0] == '0') return 0;
+ else if (loc_data[0] == '1') return 1;
+ else return -1;
+}
+
+int _Locale_p_sep_by_space(_Locale_monetary_t * lmon) {
+ char loc_data[2];
+ GetLocaleInfoA(lmon->lc.id, LOCALE_IPOSSEPBYSPACE, loc_data, 2);
+ if (loc_data[0] == '0') return 0;
+ else if (loc_data[0] == '1') return 1;
+ else return -1;
+}
+
+int _Locale_p_sign_posn(_Locale_monetary_t * lmon) {
+ char loc_data[2];
+ if (lmon->lc.id != INVARIANT_LCID) {
+ GetLocaleInfoA(lmon->lc.id, LOCALE_IPOSSIGNPOSN, loc_data, 2);
+ return atoi(loc_data);
+ }
+ else {
+ return CHAR_MAX;
+ }
+}
+
+int _Locale_n_cs_precedes(_Locale_monetary_t * lmon) {
+ char loc_data[2];
+ GetLocaleInfoA(lmon->lc.id, LOCALE_INEGSYMPRECEDES, loc_data, 2);
+ if (loc_data[0] == '0') return 0;
+ else if (loc_data[0] == '1') return 1;
+ else return -1;
+}
+
+int _Locale_n_sep_by_space(_Locale_monetary_t * lmon) {
+ char loc_data[2];
+ GetLocaleInfoA(lmon->lc.id, LOCALE_INEGSEPBYSPACE, loc_data, 2);
+ if (loc_data[0] == '0') return 0;
+ else if (loc_data[0] == '1') return 1;
+ else return -1;
+}
+
+int _Locale_n_sign_posn(_Locale_monetary_t * lmon) {
+ char loc_data[2];
+ if (lmon->lc.id != INVARIANT_LCID) {
+ GetLocaleInfoA(lmon->lc.id, LOCALE_INEGSIGNPOSN, loc_data, 2);
+ return atoi(loc_data);
+ }
+ else {
+ return CHAR_MAX;
+ }
+}
+
+/* Time */
+const char * _Locale_full_monthname(_Locale_time_t * ltime, int month) {
+ const char **names = (const char**)ltime->month;
+ return names[month];
+}
+
+const char * _Locale_abbrev_monthname(_Locale_time_t * ltime, int month) {
+ const char **names = (const char**)ltime->abbrev_month;
+ return names[month];
+}
+
+const char * _Locale_full_dayofweek(_Locale_time_t * ltime, int day) {
+ const char **names = (const char**)ltime->dayofweek;
+ return names[day];
+}
+
+const char * _Locale_abbrev_dayofweek(_Locale_time_t * ltime, int day) {
+ const char **names = (const char**)ltime->abbrev_dayofweek;
+ return names[day];
+}
+
+const char* _Locale_d_t_fmt(_Locale_time_t* ltime)
+{ return ltime->date_time_format; }
+
+const char* _Locale_long_d_t_fmt(_Locale_time_t* ltime)
+{ return ltime->long_date_time_format; }
+
+const char* _Locale_d_fmt(_Locale_time_t* ltime)
+{ return ltime->date_format; }
+
+const char* _Locale_long_d_fmt(_Locale_time_t* ltime)
+{ return ltime->long_date_format; }
+
+const char* _Locale_t_fmt(_Locale_time_t* ltime)
+{ return ltime->time_format; }
+
+const char* _Locale_am_str(_Locale_time_t* ltime)
+{ return ltime->am; }
+
+const char* _Locale_pm_str(_Locale_time_t* ltime)
+{ return ltime->pm; }
+
+/* Messages */
+nl_catd_type _Locale_catopen(struct _Locale_messages* lmes, const char* cat_name) {
+ _STLP_MARK_PARAMETER_AS_UNUSED(lmes)
+ _STLP_MARK_PARAMETER_AS_UNUSED(cat_name)
+ return -1;
+}
+void _Locale_catclose(struct _Locale_messages* lmes, nl_catd_type cat) {
+ _STLP_MARK_PARAMETER_AS_UNUSED(lmes)
+ _STLP_MARK_PARAMETER_AS_UNUSED(&cat)
+}
+const char* _Locale_catgets(struct _Locale_messages* lmes, nl_catd_type cat,
+ int setid, int msgid, const char *dfault) {
+ _STLP_MARK_PARAMETER_AS_UNUSED(lmes)
+ _STLP_MARK_PARAMETER_AS_UNUSED(&cat)
+ _STLP_MARK_PARAMETER_AS_UNUSED(&setid)
+ _STLP_MARK_PARAMETER_AS_UNUSED(&msgid)
+ return dfault;
+}
+
+#ifdef __cplusplus
+} /* extern C */
+_STLP_END_NAMESPACE
+#endif
+
+void __FixGrouping(char *grouping) {
+ /* This converts NT version which uses '0' instead of 0, etc ; to ANSI */
+ char *g = grouping;
+ char building_group = 0;
+ char repeat_last = 0;
+ /* Check there is a grouping info otherwise we would add a useless CHAR_MAX */
+ if (*g) {
+ for (; *g; ++g) {
+ if (*g > '0' && *g <= '9') {
+ if (!building_group) {
+ *grouping = *g - '0';
+ building_group = 1;
+ }
+ else {
+ /* Known issue: grouping might roll. */
+ *grouping = *grouping * 10 + *g - '0';
+ }
+ }
+ else if (*g == '0') {
+ if (!building_group) {
+ repeat_last = 1;
+ }
+ else
+ /* Known issue: grouping might roll. */
+ *grouping *= 10;
+ }
+ else if (*g == ';') {
+ /* Stop adding to the current group */
+ building_group = 0;
+ ++grouping;
+ }
+ /* else we ignore the character */
+ }
+
+ if (!repeat_last)
+ *grouping++ = CHAR_MAX;
+ *grouping = 0;
+ }
+}
+
+const char* __ConvertName(const char* lname, LOCALECONV* ConvTable, int TableSize) {
+ int i;
+ int cmp;
+ int low = 0;
+ int high = TableSize - 1;
+
+ /* typical binary search - do until no more to search or match */
+ while (low <= high) {
+ i = (low + high) / 2;
+
+ if ((cmp = lstrcmpiA(lname, (*(ConvTable + i)).name)) == 0)
+ return (*(ConvTable + i)).abbrev;
+ else if (cmp < 0)
+ high = i - 1;
+ else
+ low = i + 1;
+ }
+ return lname;
+}
+
+int __ParseLocaleString(const char* lname,
+ char* lang, char* ctry, char* page) {
+ int param = 0;
+ size_t len;
+ size_t tmpLen;
+
+ if (lname[0] == 0)
+ return 0;
+
+ /* We look for the first country separator '_' */
+ len = strcspn(lname, "_");
+ if (lname[len] == '_') {
+ if (len == 0 || len > MAX_LANG_LEN) return -1; /* empty lang is invalid*/
+ _STLP_STRNCPY(lang, MAX_LANG_LEN + 1, lname, len);
+ lname += len + 1;
+ ++param;
+ }
+
+ /* We look for the last code page separator '.' */
+ len = -1;
+ tmpLen = strcspn(lname, ".");
+ while (lname[tmpLen] == '.') {
+ len = tmpLen; ++tmpLen;
+ tmpLen += strcspn(lname + tmpLen, ".");
+ }
+ if (len != -1) { /* Means that we found a '.' */
+ if (param == 0) {
+ /* We have no lang yet so we have to fill it first, no country */
+ if (len > MAX_LANG_LEN) return -1;
+ if (len == 0) {
+ /* No language nor country, only code page */
+ ++param;
+ }
+ else
+ { _STLP_STRNCPY(lang, MAX_LANG_LEN + 1, lname, len); }
+ ++param;
+ }
+ else {
+ /* We already have a lang so we are now looking for the country: */
+ if (len == 0) return -1; /* We forbid locale name with the "_." motif in it */
+ if (len > MAX_CTRY_LEN) return -1;
+ _STLP_STRNCPY(ctry, MAX_CTRY_LEN + 1, lname, len);
+ }
+ ++param;
+ lname += len + 1;
+ }
+
+ /* We look for ',' for compatibility with POSIX */
+ len = strcspn(lname, ",");
+ switch (param) {
+ case 0:
+ if (len > MAX_LANG_LEN) return -1;
+ _STLP_STRNCPY(lang, MAX_LANG_LEN + 1, lname, len);
+ break;
+ case 1:
+ if (len > MAX_CTRY_LEN) return -1;
+ _STLP_STRNCPY(ctry, MAX_CTRY_LEN + 1, lname, len);
+ break;
+ default:
+ if (len > MAX_CP_LEN) return -1;
+ _STLP_STRNCPY(page, MAX_CP_LEN + 1, lname, len);
+ break;
+ }
+
+ /* ',' POSIX modifier is not used in NT */
+ return 0;
+}
+
+/* Data necessary for find LCID*/
+static CRITICAL_SECTION __criticalSection;
+static int __FindFlag;
+static LCID __FndLCID;
+static const char* __FndLang;
+static const char* __FndCtry;
+
+void _Locale_init()
+{ InitializeCriticalSection(&__criticalSection); }
+
+void _Locale_final()
+{ DeleteCriticalSection(&__criticalSection); }
+
+static LCID LocaleFromHex(const char* locale) {
+ unsigned long result = 0;
+ int digit;
+ while (*locale) {
+ result <<= 4;
+ digit = (*locale >= '0' && *locale <= '9') ? *locale - '0':
+ (*locale >= 'A' && *locale <= 'F') ? (*locale - 'A') + 10
+ : (*locale - 'a') + 10;
+ result += digit;
+ ++locale;
+ }
+ return (LCID)result;
+}
+
+static BOOL CALLBACK EnumLocalesProcA(LPSTR locale) {
+ LCID lcid = LocaleFromHex(locale);
+ int LangFlag = 0, CtryFlag = !__FndCtry;
+ static char Lang[MAX_LANG_LEN], Ctry[MAX_CTRY_LEN];
+
+ GetLocaleInfoA(lcid, LOCALE_SENGLANGUAGE, Lang, MAX_LANG_LEN);
+ if (lstrcmpiA(Lang, __FndLang) != 0) {
+ GetLocaleInfoA(lcid, LOCALE_SABBREVLANGNAME, Lang, MAX_LANG_LEN);
+ if (lstrcmpiA(Lang, __FndLang) != 0) {
+ GetLocaleInfoA(lcid, LOCALE_SISO639LANGNAME, Lang, MAX_LANG_LEN);
+ if (lstrcmpiA(Lang, __FndLang) == 0) LangFlag = 1;
+ }
+ else LangFlag = 1;
+ }
+ else LangFlag = 1;
+
+ if (__FndCtry) {
+ GetLocaleInfoA(lcid, LOCALE_SENGCOUNTRY, Ctry, MAX_CTRY_LEN);
+ if (lstrcmpiA(Ctry, __FndCtry) != 0) {
+ GetLocaleInfoA(lcid, LOCALE_SABBREVCTRYNAME, Ctry, MAX_CTRY_LEN);
+ if (lstrcmpiA(Ctry, __FndCtry) != 0) {
+ GetLocaleInfoA(lcid, LOCALE_SISO3166CTRYNAME, Ctry, MAX_CTRY_LEN);
+ if (lstrcmpiA(Ctry, __FndCtry) == 0) CtryFlag = 1;
+ }
+ else CtryFlag = 1;
+ }
+ else
+ CtryFlag = 1;
+ }
+
+ if (LangFlag && CtryFlag) {
+ __FindFlag = 1;
+ __FndLCID = lcid;
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+int __GetLCID(const char* lang, const char* ctry, LCID* lcid) {
+ int ret;
+ EnterCriticalSection(&__criticalSection);
+
+ __FindFlag = 0;
+ __FndLang = lang;
+ __FndCtry = ctry;
+ EnumSystemLocalesA(EnumLocalesProcA, LCID_INSTALLED);
+
+ if (__FindFlag != 0) *lcid = __FndLCID;
+ ret = __FindFlag != 0 ? 0 : -1;
+
+ LeaveCriticalSection(&__criticalSection);
+ return ret;
+}
+
+int __GetLCIDFromName(const char* lname, LCID* lcid, char* cp, _Locale_lcid_t *hint) {
+ char lang[MAX_LANG_LEN + 1], ctry[MAX_CTRY_LEN + 1], page[MAX_CP_LEN + 1];
+ int result = 0;
+ if (lname == NULL || lname[0] == 0) {
+ *lcid = LOCALE_USER_DEFAULT;
+ return 0;
+ }
+
+ memset(lang, 0, MAX_LANG_LEN + 1);
+ memset(ctry, 0, MAX_CTRY_LEN + 1);
+ memset(page, 0, MAX_CP_LEN + 1);
+ if (__ParseLocaleString(lname, lang, ctry, page) == -1) return -1;
+
+ if (hint != 0) {
+ *lcid = hint->id;
+ }
+ else {
+ if (lang[0] == 0 && ctry[0] == 0)
+ *lcid = LOCALE_USER_DEFAULT; /* Only code page given. */
+ else {
+ if (ctry[0] == 0) {
+ result = __GetLCID(__ConvertName(lang, __rg_language, sizeof(__rg_language) / sizeof(LOCALECONV)), NULL, lcid);
+ if (result != 0) {
+ /* Check 'C' special case. Check is done after call to __GetLCID because normal programs do not
+ * generate facet from 'C' name, they use the locale::classic() facets. */
+ if (lang[0] == 'C' && lang[1] == 0) {
+ *lcid = INVARIANT_LCID;
+ result = 0;
+ }
+ }
+ }
+ else {
+ result = __GetLCID(__ConvertName(lang, __rg_language, sizeof(__rg_language) / sizeof(LOCALECONV)),
+ __ConvertName(ctry, __rg_country, sizeof(__rg_country) / sizeof(LOCALECONV)),
+ lcid);
+ if (result != 0) {
+ /* Non NLS mapping might introduce problem with some locales when only one entry is mapped,
+ * the lang or the country (example: chinese locales like 'chinese_taiwan' gives 'CHS_taiwan'
+ * that do not exists in system). This is why we are giving this locale an other chance by
+ * calling __GetLCID without the mapping. */
+ result = __GetLCID(lang, ctry, lcid);
+ }
+ }
+ }
+ }
+
+ if (result == 0) {
+ /* Handling code page */
+ if (lstrcmpiA(page, "ACP") == 0 || page[0] == 0)
+ my_ltoa(__intGetACP(*lcid), cp);
+ else if (lstrcmpiA(page, "OCP") == 0)
+ my_ltoa(__intGetOCP(*lcid), cp);
+ else if (lstrcmpiA(page, "UTF7") == 0)
+ my_ltoa(CP_UTF7, cp);
+ else if (lstrcmpiA(page, "UTF8") == 0)
+ my_ltoa(CP_UTF8, cp);
+ else
+ _STLP_STRNCPY(cp, MAX_CP_LEN + 1, page, 5);
+
+ /* Code page must be an integer value,
+ * 0 returned by __intGetACP and 1 returned by __intGetOCP are invalid
+ * values.
+ */
+ if (cp[1] == 0 && (cp[0] == '0' || cp[1] == '1'))
+ return -1;
+ else if (atoi(cp) == 0)
+ return -1;
+ }
+
+ return result;
+}
+
+char const* __GetLocaleName(LCID lcid, const char* cp, char* buf) {
+ if (lcid == INVARIANT_LCID) {
+ return _C_name;
+ }
+ else {
+ char lang[MAX_LANG_LEN + 1], ctry[MAX_CTRY_LEN + 1];
+ GetLocaleInfoA(lcid, LOCALE_SENGLANGUAGE, lang, MAX_LANG_LEN);
+ GetLocaleInfoA(lcid, LOCALE_SENGCOUNTRY, ctry, MAX_CTRY_LEN);
+ _STLP_STRCPY(buf, _Locale_MAX_SIMPLE_NAME, lang);
+ _STLP_STRCAT(buf, _Locale_MAX_SIMPLE_NAME, "_");
+ _STLP_STRCAT(buf, _Locale_MAX_SIMPLE_NAME, ctry);
+ _STLP_STRCAT(buf, _Locale_MAX_SIMPLE_NAME, ".");
+ _STLP_STRCAT(buf, _Locale_MAX_SIMPLE_NAME, cp);
+ return buf;
+ }
+}
+
+char const* __Extract_locale_name(const char* loc, const char* category, char* buf) {
+ char *expr;
+ size_t len_name;
+
+ if (loc[0] == 'L' && loc[1] == 'C' && loc[2] == '_') {
+ expr = strstr((char*)loc, category);
+ if (expr == NULL) return NULL; /* Category not found. */
+ expr = strchr(expr, '=');
+ if (expr == NULL) return NULL;
+ ++expr;
+ len_name = strcspn(expr, ";");
+ len_name = len_name >= _Locale_MAX_SIMPLE_NAME ? _Locale_MAX_SIMPLE_NAME - 1
+ : len_name;
+ _STLP_STRNCPY(buf, _Locale_MAX_SIMPLE_NAME, expr, len_name); buf[len_name] = 0;
+ return buf;
+ }
+ else {
+ return loc;
+ }
+}
+
+char const* __TranslateToSystem(const char* lname, char* buf, _Locale_lcid_t* hint,
+ int *__err_code) {
+ LCID lcid;
+ char cp[MAX_CP_LEN + 1];
+ if (__GetLCIDFromName(lname, &lcid, cp, hint) != 0)
+ { *__err_code = _STLP_LOC_UNKNOWN_NAME; return NULL; }
+
+ return __GetLocaleName(lcid, cp, buf);
+}
+
+void __GetLocaleInfoUsingACP(LCID lcid, const char* cp, LCTYPE lctype, char* buf, int buf_size, wchar_t* wbuf, int wbuf_size) {
+ wchar_t *Buffer;
+ int BufferSize;
+ int icp;
+
+ GetLocaleInfoA(lcid, lctype, buf, buf_size);
+
+ icp = atoi(cp);
+ if (icp != CP_ACP && buf[0] != 0) {
+ BufferSize = MultiByteToWideChar(CP_ACP, 0, buf, -1, NULL, 0);
+ if (BufferSize > wbuf_size)
+ {
+ Buffer = (wchar_t*)malloc(sizeof(wchar_t) * BufferSize);
+ }
+ else
+ {
+ Buffer = wbuf;
+ }
+ MultiByteToWideChar(CP_ACP, 0, buf, -1, Buffer, BufferSize);
+ WideCharToMultiByte(icp, 0, Buffer, -1, buf, buf_size, NULL, NULL);
+ if (Buffer != wbuf)
+ {
+ free(Buffer);
+ }
+ }
+}
+
+/* Return 0 if ANSI code page not used */
+int __intGetACP(LCID lcid) {
+ char cp[6];
+ if (!GetLocaleInfoA(lcid, LOCALE_IDEFAULTANSICODEPAGE, cp, 6)) {
+#if defined (_STLP_LANG_INVARIANT_DEFINED)
+ if (lcid == INVARIANT_LCID) {
+ /* We are using a limited PSDK, we rely on the most common code page */
+ return 1252;
+ }
+#endif
+ return 0;
+ }
+ return atoi(cp);
+}
+
+/* Return 1 if OEM code page not used */
+int __intGetOCP(LCID lcid) {
+ char cp[6];
+ if (!GetLocaleInfoA(lcid, LOCALE_IDEFAULTCODEPAGE, cp, 6))
+ return 0;
+ return atoi(cp);
+}
+
+int __GetDefaultCP(LCID lcid) {
+ int cp = __intGetACP(lcid);
+ if (cp == 0) return __intGetOCP(lcid);
+ else return cp;
+}
+
+static int trim_size_t_to_int(size_t n) { return n < (size_t)INT_MAX ? (int)n : INT_MAX; }
+
+char* __ConvertToCP(int from_cp, int to_cp, const char *from, size_t size, size_t *ret_buf_size) {
+ size_t wbuffer_size, buffer_size, from_offset, wbuf_offset;
+ int from_size, to_size, wbuf_size;
+ wchar_t *wbuffer;
+ char* buffer;
+
+ size_t orig_size = size;
+
+ wbuffer_size = 0;
+ from_offset = 0;
+ while (size > 0) {
+ from_size = trim_size_t_to_int(size);
+ wbuffer_size += MultiByteToWideChar(from_cp, MB_PRECOMPOSED,
+ from + from_offset, from_size, NULL, 0);
+ from_offset += from_size;
+ size -= from_size;
+ }
+
+ wbuffer = (wchar_t*)malloc(sizeof(wchar_t)*wbuffer_size);
+
+ size = orig_size;
+ wbuf_offset = 0;
+ from_offset = 0;
+ while (size > 0) {
+ from_size = trim_size_t_to_int(size);
+ wbuf_size = trim_size_t_to_int(wbuffer_size - wbuf_offset);
+ wbuf_offset += MultiByteToWideChar(from_cp, MB_PRECOMPOSED,
+ from + from_offset, from_size, wbuffer + wbuf_offset, wbuf_size);
+ from_offset += from_size;
+ size -= from_size;
+ }
+
+ buffer_size = 0;
+ wbuf_offset = 0;
+ size = wbuffer_size;
+ while (size > 0) {
+ wbuf_size = trim_size_t_to_int(size);
+ buffer_size += WideCharToMultiByte(to_cp, WC_COMPOSITECHECK | WC_SEPCHARS,
+ wbuffer + wbuf_offset, wbuf_size,
+ NULL, 0, NULL, FALSE);
+ wbuf_offset += wbuf_size;
+ size -= wbuf_size;
+ }
+
+ buffer = (char*)malloc(buffer_size);
+ *ret_buf_size = buffer_size;
+
+ size = wbuffer_size;
+ wbuf_offset = 0;
+ while (size > 0) {
+ wbuf_size = trim_size_t_to_int(size);
+ to_size = trim_size_t_to_int(buffer_size);
+ buffer_size -= WideCharToMultiByte(to_cp, WC_COMPOSITECHECK | WC_SEPCHARS,
+ wbuffer + wbuf_offset, wbuf_size,
+ buffer, to_size, NULL, FALSE);
+ wbuf_offset += wbuf_size;
+ size -= wbuf_size;
+ }
+
+ free(wbuffer);
+ return buffer;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef _STLP_NO_WCHAR_T
+# include "c_wlocale_win32.c"
+#endif
diff --git a/sources/android/stlport/src/c_locale_win32/c_wlocale_win32.c b/sources/android/stlport/src/c_locale_win32/c_wlocale_win32.c
new file mode 100644
index 0000000..a12659b
--- /dev/null
+++ b/sources/android/stlport/src/c_locale_win32/c_wlocale_win32.c
@@ -0,0 +1,314 @@
+/*
+ * Copyright (c) 2007 2008
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if defined (_STLP_USE_SAFE_STRING_FUNCTIONS)
+# define _STLP_WCSNCPY(D, DS, S, C) wcsncpy_s(D, DS, S, C)
+#else
+# define _STLP_WCSNCPY(D, DS, S, C) wcsncpy(D, S, C)
+#endif
+
+static const wchar_t* __wtrue_name = L"true";
+static const wchar_t* __wfalse_name = L"false";
+
+typedef struct _Locale_codecvt {
+ _Locale_lcid_t lc;
+ UINT cp;
+ unsigned char cleads[256 / CHAR_BIT];
+ unsigned char max_char_size;
+ DWORD mbtowc_flags;
+ DWORD wctomb_flags;
+} _Locale_codecvt_t;
+
+/* Ctype */
+_Locale_mask_t _WLocale_ctype(_Locale_ctype_t* ltype, wint_t c,
+ _Locale_mask_t which_bits) {
+ wchar_t buf[2];
+ WORD out[2];
+ buf[0] = c; buf[1] = 0;
+ GetStringTypeW(CT_CTYPE1, buf, -1, out);
+ _STLP_MARK_PARAMETER_AS_UNUSED(ltype)
+ return (_Locale_mask_t)(MapCtypeMask(out[0]) & which_bits);
+}
+
+wint_t _WLocale_tolower(_Locale_ctype_t* ltype, wint_t c) {
+ wchar_t in_c = c;
+ wchar_t res;
+
+ LCMapStringW(ltype->lc.id, LCMAP_LOWERCASE, &in_c, 1, &res, 1);
+ return res;
+}
+
+wint_t _WLocale_toupper(_Locale_ctype_t* ltype, wint_t c) {
+ wchar_t in_c = c;
+ wchar_t res;
+
+ LCMapStringW(ltype->lc.id, LCMAP_UPPERCASE, &in_c, 1, &res, 1);
+ return res;
+}
+
+_Locale_codecvt_t* _Locale_codecvt_create(const char * name, _Locale_lcid_t* lc_hint, int *__err_code) {
+ char cp_name[MAX_CP_LEN + 1];
+ unsigned char *ptr;
+ CPINFO CPInfo;
+ int i;
+
+ _Locale_codecvt_t *lcodecvt = (_Locale_codecvt_t*)malloc(sizeof(_Locale_codecvt_t));
+
+ if (!lcodecvt) { *__err_code = _STLP_LOC_NO_MEMORY; return lcodecvt; }
+ memset(lcodecvt, 0, sizeof(_Locale_codecvt_t));
+
+ if (__GetLCIDFromName(name, &lcodecvt->lc.id, cp_name, lc_hint) == -1)
+ { free(lcodecvt); *__err_code = _STLP_LOC_UNKNOWN_NAME; return NULL; }
+
+ lcodecvt->cp = atoi(cp_name);
+ if (!GetCPInfo(lcodecvt->cp, &CPInfo)) { free(lcodecvt); return NULL; }
+
+ if (lcodecvt->cp != CP_UTF7 && lcodecvt->cp != CP_UTF8) {
+ lcodecvt->mbtowc_flags = MB_PRECOMPOSED;
+ lcodecvt->wctomb_flags = WC_COMPOSITECHECK | WC_SEPCHARS;
+ }
+ lcodecvt->max_char_size = CPInfo.MaxCharSize;
+
+ if (CPInfo.MaxCharSize > 1) {
+ for (ptr = (unsigned char*)CPInfo.LeadByte; *ptr && *(ptr + 1); ptr += 2)
+ for (i = *ptr; i <= *(ptr + 1); ++i) lcodecvt->cleads[i / CHAR_BIT] |= (0x01 << i % CHAR_BIT);
+ }
+
+ return lcodecvt;
+}
+
+char const* _Locale_codecvt_name(const _Locale_codecvt_t* lcodecvt, char* buf) {
+ char cp_buf[MAX_CP_LEN + 1];
+ my_ltoa(lcodecvt->cp, cp_buf);
+ return __GetLocaleName(lcodecvt->lc.id, cp_buf, buf);
+}
+
+void _Locale_codecvt_destroy(_Locale_codecvt_t* lcodecvt) {
+ if (!lcodecvt) return;
+
+ free(lcodecvt);
+}
+
+int _WLocale_mb_cur_max (_Locale_codecvt_t * lcodecvt)
+{ return lcodecvt->max_char_size; }
+
+int _WLocale_mb_cur_min (_Locale_codecvt_t *lcodecvt) {
+ _STLP_MARK_PARAMETER_AS_UNUSED(lcodecvt)
+ return 1;
+}
+
+int _WLocale_is_stateless (_Locale_codecvt_t * lcodecvt)
+{ return (lcodecvt->max_char_size == 1) ? 1 : 0; }
+
+static int __isleadbyte(int i, unsigned char *ctable) {
+ unsigned char c = (unsigned char)i;
+ return (ctable[c / CHAR_BIT] & (0x01 << c % CHAR_BIT));
+}
+
+static int __mbtowc(_Locale_codecvt_t *l, wchar_t *dst, const char *from, unsigned int count) {
+ int result;
+
+ if (l->cp == CP_UTF7 || l->cp == CP_UTF8) {
+ result = MultiByteToWideChar(l->cp, l->mbtowc_flags, from, count, dst, 1);
+ if (result == 0) {
+ switch (GetLastError()) {
+ case ERROR_NO_UNICODE_TRANSLATION:
+ return -2;
+ default:
+ return -1;
+ }
+ }
+ }
+ else {
+ if (count == 1 && __isleadbyte(*from, l->cleads)) return (size_t)-2;
+ result = MultiByteToWideChar(l->cp, l->mbtowc_flags, from, count, dst, 1);
+ if (result == 0) return -1;
+ }
+
+ return result;
+}
+
+size_t _WLocale_mbtowc(_Locale_codecvt_t *lcodecvt, wchar_t *to,
+ const char *from, size_t n, mbstate_t *shift_state) {
+ int result;
+ _STLP_MARK_PARAMETER_AS_UNUSED(shift_state)
+ if (lcodecvt->max_char_size == 1) { /* Single byte encoding. */
+ result = MultiByteToWideChar(lcodecvt->cp, lcodecvt->mbtowc_flags, from, 1, to, 1);
+ if (result == 0) return (size_t)-1;
+ return result;
+ }
+ else { /* Multi byte encoding. */
+ int retval;
+ unsigned int count = 1;
+ while (n--) {
+ retval = __mbtowc(lcodecvt, to, from, count);
+ if (retval == -2)
+ { if (++count > ((unsigned int)lcodecvt->max_char_size)) return (size_t)-1; }
+ else if (retval == -1)
+ { return (size_t)-1; }
+ else
+ { return count; }
+ }
+ return (size_t)-2;
+ }
+}
+
+size_t _WLocale_wctomb(_Locale_codecvt_t *lcodecvt, char *to, size_t n,
+ const wchar_t c, mbstate_t *shift_state) {
+ int size = WideCharToMultiByte(lcodecvt->cp, lcodecvt->wctomb_flags, &c, 1, NULL, 0, NULL, NULL);
+
+ if (!size) return (size_t)-1;
+ if ((size_t)size > n) return (size_t)-2;
+
+ if (n > INT_MAX)
+ /* Limiting the output buf size to INT_MAX seems like reasonable to transform a single wchar_t. */
+ n = INT_MAX;
+
+ WideCharToMultiByte(lcodecvt->cp, lcodecvt->wctomb_flags, &c, 1, to, (int)n, NULL, NULL);
+
+ _STLP_MARK_PARAMETER_AS_UNUSED(shift_state)
+ return (size_t)size;
+}
+
+size_t _WLocale_unshift(_Locale_codecvt_t *lcodecvt, mbstate_t *st,
+ char *buf, size_t n, char **next) {
+ /* _WLocale_wctomb do not even touch to st, there is nothing to unshift in this localization implementation. */
+ _STLP_MARK_PARAMETER_AS_UNUSED(lcodecvt)
+ _STLP_MARK_PARAMETER_AS_UNUSED(st)
+ _STLP_MARK_PARAMETER_AS_UNUSED(&n)
+ *next = buf;
+ return 0;
+}
+
+/* Collate */
+/* This function takes care of the potential size_t DWORD different size. */
+static int _WLocale_strcmp_aux(_Locale_collate_t* lcol,
+ const wchar_t* s1, size_t n1,
+ const wchar_t* s2, size_t n2) {
+ int result = CSTR_EQUAL;
+ while (n1 > 0 || n2 > 0) {
+ DWORD size1 = trim_size_t_to_DWORD(n1);
+ DWORD size2 = trim_size_t_to_DWORD(n2);
+ result = CompareStringW(lcol->lc.id, 0, s1, size1, s2, size2);
+ if (result != CSTR_EQUAL)
+ break;
+ n1 -= size1;
+ n2 -= size2;
+ }
+ return result;
+}
+
+int _WLocale_strcmp(_Locale_collate_t* lcol,
+ const wchar_t* s1, size_t n1,
+ const wchar_t* s2, size_t n2) {
+ int result;
+ result = _WLocale_strcmp_aux(lcol, s1, n1, s2, n2);
+ return (result == CSTR_EQUAL) ? 0 : (result == CSTR_LESS_THAN) ? -1 : 1;
+}
+
+size_t _WLocale_strxfrm(_Locale_collate_t* lcol,
+ wchar_t* dst, size_t dst_size,
+ const wchar_t* src, size_t src_size) {
+ int result, i;
+
+ /* see _Locale_strxfrm: */
+ if (src_size > INT_MAX) {
+ if (dst != 0) {
+ _STLP_WCSNCPY(dst, dst_size, src, src_size);
+ }
+ return src_size;
+ }
+ if (dst_size > INT_MAX) {
+ dst_size = INT_MAX;
+ }
+ result = LCMapStringW(lcol->lc.id, LCMAP_SORTKEY, src, (int)src_size, dst, (int)dst_size);
+ if (result != 0 && dst != 0) {
+ for (i = result - 1; i >= 0; --i) {
+ dst[i] = ((unsigned char*)dst)[i];
+ }
+ }
+ return result != 0 ? result - 1 : 0;
+}
+
+/* Numeric */
+wchar_t _WLocale_decimal_point(_Locale_numeric_t* lnum) {
+ wchar_t buf[4];
+ GetLocaleInfoW(lnum->lc.id, LOCALE_SDECIMAL, buf, 4);
+ return buf[0];
+}
+
+wchar_t _WLocale_thousands_sep(_Locale_numeric_t* lnum) {
+ wchar_t buf[4];
+ GetLocaleInfoW(lnum->lc.id, LOCALE_STHOUSAND, buf, 4);
+ return buf[0];
+}
+
+const wchar_t * _WLocale_true(_Locale_numeric_t* lnum, wchar_t* buf, size_t bufSize) {
+ _STLP_MARK_PARAMETER_AS_UNUSED(lnum)
+ _STLP_MARK_PARAMETER_AS_UNUSED(buf)
+ _STLP_MARK_PARAMETER_AS_UNUSED(&bufSize)
+ return __wtrue_name;
+}
+
+const wchar_t * _WLocale_false(_Locale_numeric_t* lnum, wchar_t* buf, size_t bufSize) {
+ _STLP_MARK_PARAMETER_AS_UNUSED(lnum)
+ _STLP_MARK_PARAMETER_AS_UNUSED(buf)
+ _STLP_MARK_PARAMETER_AS_UNUSED(&bufSize)
+ return __wfalse_name;
+}
+
+/* Monetary */
+const wchar_t* _WLocale_int_curr_symbol(_Locale_monetary_t * lmon, wchar_t* buf, size_t bufSize)
+{ GetLocaleInfoW(lmon->lc.id, LOCALE_SINTLSYMBOL, buf, (int)bufSize); return buf; }
+
+const wchar_t* _WLocale_currency_symbol(_Locale_monetary_t * lmon, wchar_t* buf, size_t bufSize)
+{ GetLocaleInfoW(lmon->lc.id, LOCALE_SCURRENCY, buf, (int)bufSize); return buf; }
+
+wchar_t _WLocale_mon_decimal_point(_Locale_monetary_t * lmon)
+{ return lmon->decimal_point[0]; }
+
+wchar_t _WLocale_mon_thousands_sep(_Locale_monetary_t * lmon)
+{ return lmon->thousands_sep[0]; }
+
+const wchar_t* _WLocale_positive_sign(_Locale_monetary_t * lmon, wchar_t* buf, size_t bufSize)
+{ GetLocaleInfoW(lmon->lc.id, LOCALE_SPOSITIVESIGN, buf, (int)bufSize); return buf; }
+
+const wchar_t* _WLocale_negative_sign(_Locale_monetary_t * lmon, wchar_t* buf, size_t bufSize)
+{ GetLocaleInfoW(lmon->lc.id, LOCALE_SNEGATIVESIGN, buf, (int)bufSize); return buf; }
+
+/* Time */
+const wchar_t * _WLocale_full_monthname(_Locale_time_t * ltime, int month,
+ wchar_t* buf, size_t bufSize)
+{ GetLocaleInfoW(ltime->lc.id, LOCALE_SMONTHNAME1 + month, buf, (int)bufSize); return buf; }
+
+const wchar_t * _WLocale_abbrev_monthname(_Locale_time_t * ltime, int month,
+ wchar_t* buf, size_t bufSize)
+{ GetLocaleInfoW(ltime->lc.id, LOCALE_SABBREVMONTHNAME1 + month, buf, (int)bufSize); return buf; }
+
+const wchar_t * _WLocale_full_dayofweek(_Locale_time_t * ltime, int day,
+ wchar_t* buf, size_t bufSize)
+{ GetLocaleInfoW(ltime->lc.id, LOCALE_SDAYNAME1 + day, buf, (int)bufSize); return buf; }
+
+const wchar_t * _WLocale_abbrev_dayofweek(_Locale_time_t * ltime, int day,
+ wchar_t* buf, size_t bufSize)
+{ GetLocaleInfoW(ltime->lc.id, LOCALE_SABBREVDAYNAME1 + day, buf, (int)bufSize); return buf; }
+
+const wchar_t* _WLocale_am_str(_Locale_time_t* ltime,
+ wchar_t* buf, size_t bufSize)
+{ GetLocaleInfoW(ltime->lc.id, LOCALE_S1159, buf, (int)bufSize); return buf; }
+
+const wchar_t* _WLocale_pm_str(_Locale_time_t* ltime,
+ wchar_t* buf, size_t bufSize)
+{ GetLocaleInfoW(ltime->lc.id, LOCALE_S2359, buf, (int)bufSize); return buf; }
diff --git a/sources/android/stlport/src/codecvt.cpp b/sources/android/stlport/src/codecvt.cpp
new file mode 100644
index 0000000..113a262
--- /dev/null
+++ b/sources/android/stlport/src/codecvt.cpp
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#include "stlport_prefix.h"
+
+#include <locale>
+#include <algorithm>
+
+_STLP_BEGIN_NAMESPACE
+
+//----------------------------------------------------------------------
+// codecvt<char, char, mbstate_t>
+
+codecvt<char, char, mbstate_t>::~codecvt() {}
+
+int codecvt<char, char, mbstate_t>::do_length(state_type&,
+ const char* from,
+ const char* end,
+ size_t mx) const
+{ return (int)(min) ( __STATIC_CAST(size_t, (end - from)), mx); }
+
+int codecvt<char, char, mbstate_t>::do_max_length() const _STLP_NOTHROW
+{ return 1; }
+
+bool
+codecvt<char, char, mbstate_t>::do_always_noconv() const _STLP_NOTHROW
+{ return true; }
+
+int
+codecvt<char, char, mbstate_t>::do_encoding() const _STLP_NOTHROW
+{ return 1; }
+
+codecvt_base::result
+codecvt<char, char, mbstate_t>::do_unshift(state_type& /* __state */,
+ char* __to,
+ char* /* __to_limit */,
+ char*& __to_next) const
+{ __to_next = __to; return noconv; }
+
+codecvt_base::result
+codecvt<char, char, mbstate_t>::do_in (state_type& /* __state */ ,
+ const char* __from,
+ const char* /* __from_end */,
+ const char*& __from_next,
+ char* __to,
+ char* /* __to_end */,
+ char*& __to_next) const
+{ __from_next = __from; __to_next = __to; return noconv; }
+
+codecvt_base::result
+codecvt<char, char, mbstate_t>::do_out(state_type& /* __state */,
+ const char* __from,
+ const char* /* __from_end */,
+ const char*& __from_next,
+ char* __to,
+ char* /* __to_limit */,
+ char*& __to_next) const
+{ __from_next = __from; __to_next = __to; return noconv; }
+
+
+#if !defined (_STLP_NO_WCHAR_T)
+//----------------------------------------------------------------------
+// codecvt<wchar_t, char, mbstate_t>
+
+codecvt<wchar_t, char, mbstate_t>::~codecvt() {}
+
+
+codecvt<wchar_t, char, mbstate_t>::result
+codecvt<wchar_t, char, mbstate_t>::do_out(state_type& /* state */,
+ const intern_type* from,
+ const intern_type* from_end,
+ const intern_type*& from_next,
+ extern_type* to,
+ extern_type* to_limit,
+ extern_type*& to_next) const {
+ ptrdiff_t len = (min) (from_end - from, to_limit - to);
+ copy(from, from + len, to);
+ from_next = from + len;
+ to_next = to + len;
+ return ok;
+}
+
+codecvt<wchar_t, char, mbstate_t>::result
+codecvt<wchar_t, char, mbstate_t>::do_in (state_type& /* state */,
+ const extern_type* from,
+ const extern_type* from_end,
+ const extern_type*& from_next,
+ intern_type* to,
+ intern_type* to_limit,
+ intern_type*& to_next) const {
+ ptrdiff_t len = (min) (from_end - from, to_limit - to);
+ copy(__REINTERPRET_CAST(const unsigned char*, from),
+ __REINTERPRET_CAST(const unsigned char*, from) + len, to);
+ from_next = from + len;
+ to_next = to + len;
+ return ok;
+}
+
+codecvt<wchar_t, char, mbstate_t>::result
+codecvt<wchar_t, char, mbstate_t>::do_unshift(state_type& /* state */,
+ extern_type* to,
+ extern_type* ,
+ extern_type*& to_next) const {
+ to_next = to;
+ return noconv;
+}
+
+int codecvt<wchar_t, char, mbstate_t>::do_encoding() const _STLP_NOTHROW
+{ return 1; }
+
+bool codecvt<wchar_t, char, mbstate_t>::do_always_noconv() const _STLP_NOTHROW
+{ return true; }
+
+int codecvt<wchar_t, char, mbstate_t>::do_length(state_type&,
+ const extern_type* from,
+ const extern_type* end,
+ size_t mx) const
+{ return (int)(min) ((size_t) (end - from), mx); }
+
+int codecvt<wchar_t, char, mbstate_t>::do_max_length() const _STLP_NOTHROW
+{ return 1; }
+#endif /* wchar_t */
+
+_STLP_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/src/collate.cpp b/sources/android/stlport/src/collate.cpp
new file mode 100644
index 0000000..ee5540d
--- /dev/null
+++ b/sources/android/stlport/src/collate.cpp
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#include "stlport_prefix.h"
+
+#include <locale>
+
+_STLP_BEGIN_NAMESPACE
+
+// collate<char>
+
+collate<char>::~collate() {}
+
+int collate<char>::do_compare(const char* low1, const char* high1,
+ const char* low2, const char* high2) const
+{ return _STLP_PRIV __lexicographical_compare_3way(low1, high1, low2, high2); }
+
+string collate<char>::do_transform(const char* low, const char* high) const
+{ return string(low, high); }
+
+long collate<char>::do_hash(const char* low, const char* high) const {
+ unsigned long result = 0;
+ for ( ; low < high; ++low)
+ result = 5 * result + *low;
+ return result;
+}
+
+#if !defined (_STLP_NO_WCHAR_T)
+// collate<wchar_t>
+
+collate<wchar_t>::~collate() {}
+
+int
+collate<wchar_t>::do_compare(const wchar_t* low1, const wchar_t* high1,
+ const wchar_t* low2, const wchar_t* high2) const
+{ return _STLP_PRIV __lexicographical_compare_3way(low1, high1, low2, high2); }
+
+wstring collate<wchar_t>::do_transform(const wchar_t* low, const wchar_t* high) const
+{ return wstring(low, high); }
+
+long collate<wchar_t>::do_hash(const wchar_t* low, const wchar_t* high) const {
+ unsigned long result = 0;
+ for ( ; low < high; ++low)
+ result = 5 * result + *low;
+ return result;
+}
+#endif
+
+_STLP_END_NAMESPACE
+
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/src/complex.cpp b/sources/android/stlport/src/complex.cpp
new file mode 100644
index 0000000..50f310c
--- /dev/null
+++ b/sources/android/stlport/src/complex.cpp
@@ -0,0 +1,347 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#include "stlport_prefix.h"
+
+#include <numeric>
+#include <cmath>
+#include <complex>
+
+#if defined (_STLP_MSVC_LIB) && (_STLP_MSVC_LIB >= 1400)
+// hypot is deprecated.
+# if defined (_STLP_MSVC)
+# pragma warning (disable : 4996)
+# elif defined (__ICL)
+# pragma warning (disable : 1478)
+# endif
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+// Complex division and square roots.
+
+// Absolute value
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC float _STLP_CALL abs(const complex<float>& __z)
+{ return ::hypot(__z._M_re, __z._M_im); }
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC double _STLP_CALL abs(const complex<double>& __z)
+{ return ::hypot(__z._M_re, __z._M_im); }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC long double _STLP_CALL abs(const complex<long double>& __z)
+{ return ::hypot(__z._M_re, __z._M_im); }
+#endif
+
+// Phase
+
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC float _STLP_CALL arg(const complex<float>& __z)
+{ return ::atan2(__z._M_im, __z._M_re); }
+
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC double _STLP_CALL arg(const complex<double>& __z)
+{ return ::atan2(__z._M_im, __z._M_re); }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC long double _STLP_CALL arg(const complex<long double>& __z)
+{ return ::atan2(__z._M_im, __z._M_re); }
+#endif
+
+// Construct a complex number from polar representation
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC complex<float> _STLP_CALL polar(const float& __rho, const float& __phi)
+{ return complex<float>(__rho * ::cos(__phi), __rho * ::sin(__phi)); }
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC complex<double> _STLP_CALL polar(const double& __rho, const double& __phi)
+{ return complex<double>(__rho * ::cos(__phi), __rho * ::sin(__phi)); }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC complex<long double> _STLP_CALL polar(const long double& __rho, const long double& __phi)
+{ return complex<long double>(__rho * ::cos(__phi), __rho * ::sin(__phi)); }
+#endif
+
+// Division
+template <class _Tp>
+static void _divT(const _Tp& __z1_r, const _Tp& __z1_i,
+ const _Tp& __z2_r, const _Tp& __z2_i,
+ _Tp& __res_r, _Tp& __res_i) {
+ _Tp __ar = __z2_r >= 0 ? __z2_r : -__z2_r;
+ _Tp __ai = __z2_i >= 0 ? __z2_i : -__z2_i;
+
+ if (__ar <= __ai) {
+ _Tp __ratio = __z2_r / __z2_i;
+ _Tp __denom = __z2_i * (1 + __ratio * __ratio);
+ __res_r = (__z1_r * __ratio + __z1_i) / __denom;
+ __res_i = (__z1_i * __ratio - __z1_r) / __denom;
+ }
+ else {
+ _Tp __ratio = __z2_i / __z2_r;
+ _Tp __denom = __z2_r * (1 + __ratio * __ratio);
+ __res_r = (__z1_r + __z1_i * __ratio) / __denom;
+ __res_i = (__z1_i - __z1_r * __ratio) / __denom;
+ }
+}
+
+template <class _Tp>
+static void _divT(const _Tp& __z1_r,
+ const _Tp& __z2_r, const _Tp& __z2_i,
+ _Tp& __res_r, _Tp& __res_i) {
+ _Tp __ar = __z2_r >= 0 ? __z2_r : -__z2_r;
+ _Tp __ai = __z2_i >= 0 ? __z2_i : -__z2_i;
+
+ if (__ar <= __ai) {
+ _Tp __ratio = __z2_r / __z2_i;
+ _Tp __denom = __z2_i * (1 + __ratio * __ratio);
+ __res_r = (__z1_r * __ratio) / __denom;
+ __res_i = - __z1_r / __denom;
+ }
+ else {
+ _Tp __ratio = __z2_i / __z2_r;
+ _Tp __denom = __z2_r * (1 + __ratio * __ratio);
+ __res_r = __z1_r / __denom;
+ __res_i = - (__z1_r * __ratio) / __denom;
+ }
+}
+
+void _STLP_CALL
+complex<float>::_div(const float& __z1_r, const float& __z1_i,
+ const float& __z2_r, const float& __z2_i,
+ float& __res_r, float& __res_i)
+{ _divT(__z1_r, __z1_i, __z2_r, __z2_i, __res_r, __res_i); }
+
+void _STLP_CALL
+complex<float>::_div(const float& __z1_r,
+ const float& __z2_r, const float& __z2_i,
+ float& __res_r, float& __res_i)
+{ _divT(__z1_r, __z2_r, __z2_i, __res_r, __res_i); }
+
+
+void _STLP_CALL
+complex<double>::_div(const double& __z1_r, const double& __z1_i,
+ const double& __z2_r, const double& __z2_i,
+ double& __res_r, double& __res_i)
+{ _divT(__z1_r, __z1_i, __z2_r, __z2_i, __res_r, __res_i); }
+
+void _STLP_CALL
+complex<double>::_div(const double& __z1_r,
+ const double& __z2_r, const double& __z2_i,
+ double& __res_r, double& __res_i)
+{ _divT(__z1_r, __z2_r, __z2_i, __res_r, __res_i); }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+void _STLP_CALL
+complex<long double>::_div(const long double& __z1_r, const long double& __z1_i,
+ const long double& __z2_r, const long double& __z2_i,
+ long double& __res_r, long double& __res_i)
+{ _divT(__z1_r, __z1_i, __z2_r, __z2_i, __res_r, __res_i); }
+
+void _STLP_CALL
+complex<long double>::_div(const long double& __z1_r,
+ const long double& __z2_r, const long double& __z2_i,
+ long double& __res_r, long double& __res_i)
+{ _divT(__z1_r, __z2_r, __z2_i, __res_r, __res_i); }
+#endif
+
+//----------------------------------------------------------------------
+// Square root
+template <class _Tp>
+static complex<_Tp> sqrtT(const complex<_Tp>& z) {
+ _Tp re = z._M_re;
+ _Tp im = z._M_im;
+ _Tp mag = ::hypot(re, im);
+ complex<_Tp> result;
+
+ if (mag == 0.f) {
+ result._M_re = result._M_im = 0.f;
+ } else if (re > 0.f) {
+ result._M_re = ::sqrt(0.5f * (mag + re));
+ result._M_im = im/result._M_re/2.f;
+ } else {
+ result._M_im = ::sqrt(0.5f * (mag - re));
+ if (im < 0.f)
+ result._M_im = - result._M_im;
+ result._M_re = im/result._M_im/2.f;
+ }
+ return result;
+}
+
+complex<float> _STLP_CALL
+sqrt(const complex<float>& z) { return sqrtT(z); }
+
+complex<double> _STLP_CALL
+sqrt(const complex<double>& z) { return sqrtT(z); }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+complex<long double> _STLP_CALL
+sqrt(const complex<long double>& z) { return sqrtT(z); }
+#endif
+
+// exp, log, pow for complex<float>, complex<double>, and complex<long double>
+//----------------------------------------------------------------------
+// exp
+template <class _Tp>
+static complex<_Tp> expT(const complex<_Tp>& z) {
+ _Tp expx = ::exp(z._M_re);
+ return complex<_Tp>(expx * ::cos(z._M_im),
+ expx * ::sin(z._M_im));
+}
+_STLP_DECLSPEC complex<float> _STLP_CALL exp(const complex<float>& z)
+{ return expT(z); }
+
+_STLP_DECLSPEC complex<double> _STLP_CALL exp(const complex<double>& z)
+{ return expT(z); }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_DECLSPEC complex<long double> _STLP_CALL exp(const complex<long double>& z)
+{ return expT(z); }
+#endif
+
+//----------------------------------------------------------------------
+// log10
+template <class _Tp>
+static complex<_Tp> log10T(const complex<_Tp>& z, const _Tp& ln10_inv) {
+ complex<_Tp> r;
+
+ r._M_im = ::atan2(z._M_im, z._M_re) * ln10_inv;
+ r._M_re = ::log10(::hypot(z._M_re, z._M_im));
+ return r;
+}
+
+static const float LN10_INVF = 1.f / ::log(10.f);
+_STLP_DECLSPEC complex<float> _STLP_CALL log10(const complex<float>& z)
+{ return log10T(z, LN10_INVF); }
+
+static const double LN10_INV = 1. / ::log10(10.);
+_STLP_DECLSPEC complex<double> _STLP_CALL log10(const complex<double>& z)
+{ return log10T(z, LN10_INV); }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+static const long double LN10_INVL = 1.l / ::log(10.l);
+_STLP_DECLSPEC complex<long double> _STLP_CALL log10(const complex<long double>& z)
+{ return log10T(z, LN10_INVL); }
+#endif
+
+//----------------------------------------------------------------------
+// log
+template <class _Tp>
+static complex<_Tp> logT(const complex<_Tp>& z) {
+ complex<_Tp> r;
+
+ r._M_im = ::atan2(z._M_im, z._M_re);
+ r._M_re = ::log(::hypot(z._M_re, z._M_im));
+ return r;
+}
+_STLP_DECLSPEC complex<float> _STLP_CALL log(const complex<float>& z)
+{ return logT(z); }
+
+_STLP_DECLSPEC complex<double> _STLP_CALL log(const complex<double>& z)
+{ return logT(z); }
+
+#ifndef _STLP_NO_LONG_DOUBLE
+_STLP_DECLSPEC complex<long double> _STLP_CALL log(const complex<long double>& z)
+{ return logT(z); }
+# endif
+
+//----------------------------------------------------------------------
+// pow
+template <class _Tp>
+static complex<_Tp> powT(const _Tp& a, const complex<_Tp>& b) {
+ _Tp logr = ::log(a);
+ _Tp x = ::exp(logr * b._M_re);
+ _Tp y = logr * b._M_im;
+
+ return complex<_Tp>(x * ::cos(y), x * ::sin(y));
+}
+
+template <class _Tp>
+static complex<_Tp> powT(const complex<_Tp>& z_in, int n) {
+ complex<_Tp> z = z_in;
+ z = _STLP_PRIV __power(z, (n < 0 ? -n : n), multiplies< complex<_Tp> >());
+ if (n < 0)
+ return _Tp(1.0) / z;
+ else
+ return z;
+}
+
+template <class _Tp>
+static complex<_Tp> powT(const complex<_Tp>& a, const _Tp& b) {
+ _Tp logr = ::log(::hypot(a._M_re,a._M_im));
+ _Tp logi = ::atan2(a._M_im, a._M_re);
+ _Tp x = ::exp(logr * b);
+ _Tp y = logi * b;
+
+ return complex<_Tp>(x * ::cos(y), x * ::sin(y));
+}
+
+template <class _Tp>
+static complex<_Tp> powT(const complex<_Tp>& a, const complex<_Tp>& b) {
+ _Tp logr = ::log(::hypot(a._M_re,a._M_im));
+ _Tp logi = ::atan2(a._M_im, a._M_re);
+ _Tp x = ::exp(logr * b._M_re - logi * b._M_im);
+ _Tp y = logr * b._M_im + logi * b._M_re;
+
+ return complex<_Tp>(x * ::cos(y), x * ::sin(y));
+}
+
+_STLP_DECLSPEC complex<float> _STLP_CALL pow(const float& a, const complex<float>& b)
+{ return powT(a, b); }
+
+_STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>& z_in, int n)
+{ return powT(z_in, n); }
+
+_STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>& a, const float& b)
+{ return powT(a, b); }
+
+_STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>& a, const complex<float>& b)
+{ return powT(a, b); }
+
+_STLP_DECLSPEC complex<double> _STLP_CALL pow(const double& a, const complex<double>& b)
+{ return powT(a, b); }
+
+_STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>& z_in, int n)
+{ return powT(z_in, n); }
+
+_STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>& a, const double& b)
+{ return powT(a, b); }
+
+_STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>& a, const complex<double>& b)
+{ return powT(a, b); }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_DECLSPEC complex<long double> _STLP_CALL pow(const long double& a,
+ const complex<long double>& b)
+{ return powT(a, b); }
+
+
+_STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>& z_in, int n)
+{ return powT(z_in, n); }
+
+_STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>& a,
+ const long double& b)
+{ return powT(a, b); }
+
+_STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>& a,
+ const complex<long double>& b)
+{ return powT(a, b); }
+#endif
+
+_STLP_END_NAMESPACE
diff --git a/sources/android/stlport/src/complex_io.cpp b/sources/android/stlport/src/complex_io.cpp
new file mode 100644
index 0000000..4cb6636
--- /dev/null
+++ b/sources/android/stlport/src/complex_io.cpp
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#include "stlport_prefix.h"
+
+#include <complex>
+#include <istream>
+
+_STLP_BEGIN_NAMESPACE
+
+// Specializations for narrow characters; lets us avoid the nuisance of
+// widening.
+_STLP_OPERATOR_SPEC
+basic_ostream<char, char_traits<char> >& _STLP_CALL
+operator<< (basic_ostream<char, char_traits<char> >& __os, const complex<float>& __z)
+{ return __os << '(' << (double)__z.real() << ',' << (double)__z.imag() << ')'; }
+
+_STLP_OPERATOR_SPEC
+basic_ostream<char, char_traits<char> >& _STLP_CALL
+operator<< (basic_ostream<char, char_traits<char> >& __os, const complex<double>& __z)
+{ return __os << '(' << __z.real() << ',' << __z.imag() << ')'; }
+
+#ifndef _STLP_NO_LONG_DOUBLE
+_STLP_OPERATOR_SPEC
+basic_ostream<char, char_traits<char> >& _STLP_CALL
+operator<< (basic_ostream<char, char_traits<char> >& __os, const complex<long double>& __z)
+{ return __os << '(' << __z.real() << ',' << __z.imag() << ')'; }
+#endif
+
+// Specialization for narrow characters; lets us avoid widen.
+_STLP_OPERATOR_SPEC
+basic_istream<char, char_traits<char> >& _STLP_CALL
+operator>>(basic_istream<char, char_traits<char> >& __is, complex<float>& __z) {
+ float __re = 0;
+ float __im = 0;
+
+ char __c;
+
+ __is >> __c;
+ if (__c == '(') {
+ __is >> __re >> __c;
+ if (__c == ',')
+ __is >> __im >> __c;
+ if (__c != ')')
+ __is.setstate(ios_base::failbit);
+ }
+ else {
+ __is.putback(__c);
+ __is >> __re;
+ }
+
+ if (__is)
+ __z = complex<float>(__re, __im);
+ return __is;
+}
+
+_STLP_OPERATOR_SPEC
+basic_istream<char, char_traits<char> >& _STLP_CALL
+operator>>(basic_istream<char, char_traits<char> >& __is, complex<double>& __z) {
+ double __re = 0;
+ double __im = 0;
+
+ char __c;
+
+ __is >> __c;
+ if (__c == '(') {
+ __is >> __re >> __c;
+ if (__c == ',')
+ __is >> __im >> __c;
+ if (__c != ')')
+ __is.setstate(ios_base::failbit);
+ }
+ else {
+ __is.putback(__c);
+ __is >> __re;
+ }
+
+ if (__is)
+ __z = complex<double>(__re, __im);
+ return __is;
+}
+
+#ifndef _STLP_NO_LONG_DOUBLE
+_STLP_OPERATOR_SPEC
+basic_istream<char, char_traits<char> >& _STLP_CALL
+operator>>(basic_istream<char, char_traits<char> >& __is, complex<long double>& __z) {
+ long double __re = 0;
+ long double __im = 0;
+
+ char __c;
+
+ __is >> __c;
+ if (__c == '(') {
+ __is >> __re >> __c;
+ if (__c == ',')
+ __is >> __im >> __c;
+ if (__c != ')')
+ __is.setstate(ios_base::failbit);
+ }
+ else {
+ __is.putback(__c);
+ __is >> __re;
+ }
+
+ if (__is)
+ __z = complex<long double>(__re, __im);
+ return __is;
+}
+#endif
+
+// Force instantiation of complex I/O functions
+#if !(defined (_STLP_NO_FORCE_INSTANTIATE) || defined (_STLP_NO_WCHAR_T))
+
+_STLP_OPERATOR_SPEC basic_istream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
+operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&, complex<float>&);
+
+_STLP_OPERATOR_SPEC basic_istream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
+operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&, complex<double>&);
+
+#ifndef _STLP_NO_LONG_DOUBLE
+_STLP_OPERATOR_SPEC basic_istream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
+operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&, complex<long double>&);
+
+_STLP_OPERATOR_SPEC basic_ostream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
+operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&, const complex<long double>&);
+#endif
+
+_STLP_OPERATOR_SPEC basic_ostream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
+operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&, const complex<float>&);
+
+_STLP_OPERATOR_SPEC basic_ostream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
+operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&, const complex<double>&);
+
+#endif /* _STLP_NO_WCHAR_T */
+
+_STLP_END_NAMESPACE
+
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/src/complex_trig.cpp b/sources/android/stlport/src/complex_trig.cpp
new file mode 100644
index 0000000..f566fe9
--- /dev/null
+++ b/sources/android/stlport/src/complex_trig.cpp
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#include "stlport_prefix.h"
+
+
+// Trigonometric and hyperbolic functions for complex<float>,
+// complex<double>, and complex<long double>
+#include <complex>
+#include <cfloat>
+#include <cmath>
+
+_STLP_BEGIN_NAMESPACE
+
+
+//----------------------------------------------------------------------
+// helpers
+#if defined (__sgi)
+ static const union { unsigned int i; float f; } float_ulimit = { 0x42b2d4fc };
+ static const float float_limit = float_ulimit.f;
+ static union {
+ struct { unsigned int h; unsigned int l; } w;
+ double d;
+ } double_ulimit = { 0x408633ce, 0x8fb9f87d };
+ static const double double_limit = double_ulimit.d;
+ static union {
+ struct { unsigned int h[2]; unsigned int l[2]; } w;
+ long double ld;
+ } ldouble_ulimit = {0x408633ce, 0x8fb9f87e, 0xbd23b659, 0x4e9bd8b1};
+# if !defined (_STLP_NO_LONG_DOUBLE)
+ static const long double ldouble_limit = ldouble_ulimit.ld;
+# endif
+#else
+# if defined (M_LN2) && defined (FLT_MAX_EXP)
+ static const float float_limit = float(M_LN2 * FLT_MAX_EXP);
+ static const double double_limit = M_LN2 * DBL_MAX_EXP;
+# else
+ static const float float_limit = ::log(FLT_MAX);
+ static const double double_limit = ::log(DBL_MAX);
+# endif
+# if !defined (_STLP_NO_LONG_DOUBLE)
+# if defined (M_LN2l)
+ static const long double ldouble_limit = M_LN2l * LDBL_MAX_EXP;
+# else
+ static const long double ldouble_limit = ::log(LDBL_MAX);
+# endif
+# endif
+#endif
+
+
+//----------------------------------------------------------------------
+// sin
+template <class _Tp>
+static complex<_Tp> sinT(const complex<_Tp>& z) {
+ return complex<_Tp>(::sin(z._M_re) * ::cosh(z._M_im),
+ ::cos(z._M_re) * ::sinh(z._M_im));
+}
+
+_STLP_DECLSPEC complex<float> _STLP_CALL sin(const complex<float>& z)
+{ return sinT(z); }
+
+_STLP_DECLSPEC complex<double> _STLP_CALL sin(const complex<double>& z)
+{ return sinT(z); }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_DECLSPEC complex<long double> _STLP_CALL sin(const complex<long double>& z)
+{ return sinT(z); }
+#endif
+
+//----------------------------------------------------------------------
+// cos
+template <class _Tp>
+static complex<_Tp> cosT(const complex<_Tp>& z) {
+ return complex<_Tp>(::cos(z._M_re) * ::cosh(z._M_im),
+ -::sin(z._M_re) * ::sinh(z._M_im));
+}
+
+_STLP_DECLSPEC complex<float> _STLP_CALL cos(const complex<float>& z)
+{ return cosT(z); }
+
+_STLP_DECLSPEC complex<double> _STLP_CALL cos(const complex<double>& z)
+{ return cosT(z); }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_DECLSPEC complex<long double> _STLP_CALL cos(const complex<long double>& z)
+{ return cosT(z); }
+#endif
+
+//----------------------------------------------------------------------
+// tan
+template <class _Tp>
+static complex<_Tp> tanT(const complex<_Tp>& z, const _Tp& Tp_limit) {
+ _Tp re2 = 2.f * z._M_re;
+ _Tp im2 = 2.f * z._M_im;
+
+ if (::abs(im2) > Tp_limit)
+ return complex<_Tp>(0.f, (im2 > 0 ? 1.f : -1.f));
+ else {
+ _Tp den = ::cos(re2) + ::cosh(im2);
+ return complex<_Tp>(::sin(re2) / den, ::sinh(im2) / den);
+ }
+}
+
+_STLP_DECLSPEC complex<float> _STLP_CALL tan(const complex<float>& z)
+{ return tanT(z, float_limit); }
+
+_STLP_DECLSPEC complex<double> _STLP_CALL tan(const complex<double>& z)
+{ return tanT(z, double_limit); }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_DECLSPEC complex<long double> _STLP_CALL tan(const complex<long double>& z)
+{ return tanT(z, ldouble_limit); }
+#endif
+
+//----------------------------------------------------------------------
+// sinh
+template <class _Tp>
+static complex<_Tp> sinhT(const complex<_Tp>& z) {
+ return complex<_Tp>(::sinh(z._M_re) * ::cos(z._M_im),
+ ::cosh(z._M_re) * ::sin(z._M_im));
+}
+
+_STLP_DECLSPEC complex<float> _STLP_CALL sinh(const complex<float>& z)
+{ return sinhT(z); }
+
+_STLP_DECLSPEC complex<double> _STLP_CALL sinh(const complex<double>& z)
+{ return sinhT(z); }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_DECLSPEC complex<long double> _STLP_CALL sinh(const complex<long double>& z)
+{ return sinhT(z); }
+#endif
+
+//----------------------------------------------------------------------
+// cosh
+template <class _Tp>
+static complex<_Tp> coshT(const complex<_Tp>& z) {
+ return complex<_Tp>(::cosh(z._M_re) * ::cos(z._M_im),
+ ::sinh(z._M_re) * ::sin(z._M_im));
+}
+
+_STLP_DECLSPEC complex<float> _STLP_CALL cosh(const complex<float>& z)
+{ return coshT(z); }
+
+_STLP_DECLSPEC complex<double> _STLP_CALL cosh(const complex<double>& z)
+{ return coshT(z); }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_DECLSPEC complex<long double> _STLP_CALL cosh(const complex<long double>& z)
+{ return coshT(z); }
+#endif
+
+//----------------------------------------------------------------------
+// tanh
+template <class _Tp>
+static complex<_Tp> tanhT(const complex<_Tp>& z, const _Tp& Tp_limit) {
+ _Tp re2 = 2.f * z._M_re;
+ _Tp im2 = 2.f * z._M_im;
+ if (::abs(re2) > Tp_limit)
+ return complex<_Tp>((re2 > 0 ? 1.f : -1.f), 0.f);
+ else {
+ _Tp den = ::cosh(re2) + ::cos(im2);
+ return complex<_Tp>(::sinh(re2) / den, ::sin(im2) / den);
+ }
+}
+
+_STLP_DECLSPEC complex<float> _STLP_CALL tanh(const complex<float>& z)
+{ return tanhT(z, float_limit); }
+
+_STLP_DECLSPEC complex<double> _STLP_CALL tanh(const complex<double>& z)
+{ return tanhT(z, double_limit); }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_DECLSPEC complex<long double> _STLP_CALL tanh(const complex<long double>& z)
+{ return tanhT(z, ldouble_limit); }
+#endif
+
+_STLP_END_NAMESPACE
diff --git a/sources/android/stlport/src/ctype.cpp b/sources/android/stlport/src/ctype.cpp
new file mode 100644
index 0000000..b1e84b1
--- /dev/null
+++ b/sources/android/stlport/src/ctype.cpp
@@ -0,0 +1,486 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#include "stlport_prefix.h"
+
+#include <algorithm>
+#include <locale>
+#include <functional>
+
+#include "c_locale.h"
+
+_STLP_BEGIN_NAMESPACE
+
+//----------------------------------------------------------------------
+// ctype<char>
+
+// The classic table: static data members.
+
+#if !defined (_STLP_STATIC_CONST_INIT_BUG) && !defined (_STLP_NO_STATIC_CONST_DEFINITION)
+//*TY 02/25/2000 - added workaround for MPW compilers; they confuse on in-class static const
+const size_t ctype<char>::table_size;
+#endif
+
+// This macro is specifically for platforms where isprint() relies
+// on separate flag
+
+const ctype_base::mask*
+ctype<char>::classic_table() _STLP_NOTHROW {
+ /* Ctype table for the ASCII character set. */
+ static const ctype_base::mask _S_classic_table[table_size] = {
+ cntrl /* null */,
+ cntrl /* ^A */,
+ cntrl /* ^B */,
+ cntrl /* ^C */,
+ cntrl /* ^D */,
+ cntrl /* ^E */,
+ cntrl /* ^F */,
+ cntrl /* ^G */,
+ cntrl /* ^H */,
+ ctype_base::mask(space | cntrl) /* tab */,
+ ctype_base::mask(space | cntrl) /* LF */,
+ ctype_base::mask(space | cntrl) /* ^K */,
+ ctype_base::mask(space | cntrl) /* FF */,
+ ctype_base::mask(space | cntrl) /* ^M */,
+ cntrl /* ^N */,
+ cntrl /* ^O */,
+ cntrl /* ^P */,
+ cntrl /* ^Q */,
+ cntrl /* ^R */,
+ cntrl /* ^S */,
+ cntrl /* ^T */,
+ cntrl /* ^U */,
+ cntrl /* ^V */,
+ cntrl /* ^W */,
+ cntrl /* ^X */,
+ cntrl /* ^Y */,
+ cntrl /* ^Z */,
+ cntrl /* esc */,
+ cntrl /* ^\ */,
+ cntrl /* ^] */,
+ cntrl /* ^^ */,
+ cntrl /* ^_ */,
+ ctype_base::mask(space | print) /* */,
+ ctype_base::mask(punct | print) /* ! */,
+ ctype_base::mask(punct | print) /* " */,
+ ctype_base::mask(punct | print) /* # */,
+ ctype_base::mask(punct | print) /* $ */,
+ ctype_base::mask(punct | print) /* % */,
+ ctype_base::mask(punct | print) /* & */,
+ ctype_base::mask(punct | print) /* ' */,
+ ctype_base::mask(punct | print) /* ( */,
+ ctype_base::mask(punct | print) /* ) */,
+ ctype_base::mask(punct | print) /* * */,
+ ctype_base::mask(punct | print) /* + */,
+ ctype_base::mask(punct | print) /* , */,
+ ctype_base::mask(punct | print) /* - */,
+ ctype_base::mask(punct | print) /* . */,
+ ctype_base::mask(punct | print) /* / */,
+ ctype_base::mask(digit | print | xdigit) /* 0 */,
+ ctype_base::mask(digit | print | xdigit) /* 1 */,
+ ctype_base::mask(digit | print | xdigit) /* 2 */,
+ ctype_base::mask(digit | print | xdigit) /* 3 */,
+ ctype_base::mask(digit | print | xdigit) /* 4 */,
+ ctype_base::mask(digit | print | xdigit) /* 5 */,
+ ctype_base::mask(digit | print | xdigit) /* 6 */,
+ ctype_base::mask(digit | print | xdigit) /* 7 */,
+ ctype_base::mask(digit | print | xdigit) /* 8 */,
+ ctype_base::mask(digit | print | xdigit) /* 9 */,
+ ctype_base::mask(punct | print) /* : */,
+ ctype_base::mask(punct | print) /* ; */,
+ ctype_base::mask(punct | print) /* < */,
+ ctype_base::mask(punct | print) /* = */,
+ ctype_base::mask(punct | print) /* > */,
+ ctype_base::mask(punct | print) /* ? */,
+ ctype_base::mask(punct | print) /* ! */,
+ ctype_base::mask(alpha | print | upper | xdigit) /* A */,
+ ctype_base::mask(alpha | print | upper | xdigit) /* B */,
+ ctype_base::mask(alpha | print | upper | xdigit) /* C */,
+ ctype_base::mask(alpha | print | upper | xdigit) /* D */,
+ ctype_base::mask(alpha | print | upper | xdigit) /* E */,
+ ctype_base::mask(alpha | print | upper | xdigit) /* F */,
+ ctype_base::mask(alpha | print | upper) /* G */,
+ ctype_base::mask(alpha | print | upper) /* H */,
+ ctype_base::mask(alpha | print | upper) /* I */,
+ ctype_base::mask(alpha | print | upper) /* J */,
+ ctype_base::mask(alpha | print | upper) /* K */,
+ ctype_base::mask(alpha | print | upper) /* L */,
+ ctype_base::mask(alpha | print | upper) /* M */,
+ ctype_base::mask(alpha | print | upper) /* N */,
+ ctype_base::mask(alpha | print | upper) /* O */,
+ ctype_base::mask(alpha | print | upper) /* P */,
+ ctype_base::mask(alpha | print | upper) /* Q */,
+ ctype_base::mask(alpha | print | upper) /* R */,
+ ctype_base::mask(alpha | print | upper) /* S */,
+ ctype_base::mask(alpha | print | upper) /* T */,
+ ctype_base::mask(alpha | print | upper) /* U */,
+ ctype_base::mask(alpha | print | upper) /* V */,
+ ctype_base::mask(alpha | print | upper) /* W */,
+ ctype_base::mask(alpha | print | upper) /* X */,
+ ctype_base::mask(alpha | print | upper) /* Y */,
+ ctype_base::mask(alpha | print | upper) /* Z */,
+ ctype_base::mask(punct | print) /* [ */,
+ ctype_base::mask(punct | print) /* \ */,
+ ctype_base::mask(punct | print) /* ] */,
+ ctype_base::mask(punct | print) /* ^ */,
+ ctype_base::mask(punct | print) /* _ */,
+ ctype_base::mask(punct | print) /* ` */,
+ ctype_base::mask(alpha | print | lower | xdigit) /* a */,
+ ctype_base::mask(alpha | print | lower | xdigit) /* b */,
+ ctype_base::mask(alpha | print | lower | xdigit) /* c */,
+ ctype_base::mask(alpha | print | lower | xdigit) /* d */,
+ ctype_base::mask(alpha | print | lower | xdigit) /* e */,
+ ctype_base::mask(alpha | print | lower | xdigit) /* f */,
+ ctype_base::mask(alpha | print | lower) /* g */,
+ ctype_base::mask(alpha | print | lower) /* h */,
+ ctype_base::mask(alpha | print | lower) /* i */,
+ ctype_base::mask(alpha | print | lower) /* j */,
+ ctype_base::mask(alpha | print | lower) /* k */,
+ ctype_base::mask(alpha | print | lower) /* l */,
+ ctype_base::mask(alpha | print | lower) /* m */,
+ ctype_base::mask(alpha | print | lower) /* n */,
+ ctype_base::mask(alpha | print | lower) /* o */,
+ ctype_base::mask(alpha | print | lower) /* p */,
+ ctype_base::mask(alpha | print | lower) /* q */,
+ ctype_base::mask(alpha | print | lower) /* r */,
+ ctype_base::mask(alpha | print | lower) /* s */,
+ ctype_base::mask(alpha | print | lower) /* t */,
+ ctype_base::mask(alpha | print | lower) /* u */,
+ ctype_base::mask(alpha | print | lower) /* v */,
+ ctype_base::mask(alpha | print | lower) /* w */,
+ ctype_base::mask(alpha | print | lower) /* x */,
+ ctype_base::mask(alpha | print | lower) /* y */,
+ ctype_base::mask(alpha | print | lower) /* z */,
+ ctype_base::mask(punct | print) /* { */,
+ ctype_base::mask(punct | print) /* | */,
+ ctype_base::mask(punct | print) /* } */,
+ ctype_base::mask(punct | print) /* ~ */,
+ cntrl /* del (0x7f)*/,
+ /* ASCII is a 7-bit code, so everything else is non-ASCII */
+ ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0),
+ ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0),
+ ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0),
+ ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0),
+ ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0),
+ ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0),
+ ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0),
+ ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0),
+ ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0),
+ ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0),
+ ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0),
+ ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0),
+ ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0),
+ ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0),
+ ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0),
+ ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0), ctype_base::mask(0)
+ };
+ return _S_classic_table;
+}
+
+// For every c in the range 0 <= c < 256, _S_upper[c] is the
+// uppercased version of c and _S_lower[c] is the lowercased
+// version. As before, these two tables assume the ASCII character
+// set.
+
+const unsigned char _S_upper[ctype<char>::table_size] =
+{
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+ 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+ 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
+ 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
+ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+ 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+ 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+ 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+ 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+ 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
+ 0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+ 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+ 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+ 0x58, 0x59, 0x5a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+ 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+ 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+ 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+ 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+ 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+ 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+ 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+ 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+ 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+ 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+ 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+ 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+ 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+ 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
+ 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
+};
+
+const unsigned char _S_lower[ctype<char>::table_size] =
+{
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+ 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+ 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
+ 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
+ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+ 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+ 0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
+ 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
+ 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
+ 0x78, 0x79, 0x7a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
+ 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
+ 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
+ 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
+ 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+ 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+ 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+ 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+ 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+ 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+ 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+ 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+ 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+ 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+ 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+ 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+ 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+ 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+ 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
+ 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
+};
+
+//An helper struct to check wchar_t index without generating warnings
+//under some compilers (gcc) because of a limited range of value
+//(when wchar_t is unsigned)
+template <bool _IsSigned>
+struct _WCharIndexT;
+
+#if !(defined (__BORLANDC__) && !defined(__linux__)) && \
+ !(defined (__GNUC__) && (defined (__MINGW32__) || defined (__CYGWIN__))) && \
+ !defined (__ICL)
+_STLP_TEMPLATE_NULL
+struct _WCharIndexT<true> {
+ static bool in_range(wchar_t c, size_t upperBound) {
+ return c >= 0 && size_t(c) < upperBound;
+ }
+};
+#endif
+
+_STLP_TEMPLATE_NULL
+struct _WCharIndexT<false> {
+ static bool in_range(wchar_t c, size_t upperBound) {
+ return size_t(c) < upperBound;
+ }
+};
+
+typedef _WCharIndexT<wchar_t(-1) < 0> _WCharIndex;
+
+// Some helper functions used in ctype<>::scan_is and scan_is_not.
+
+struct _Ctype_is_mask : public unary_function<char, bool> {
+ ctype_base::mask _Mask;
+ const ctype_base::mask* _M_table;
+
+ _Ctype_is_mask(ctype_base::mask __m, const ctype_base::mask* __t) : _Mask(__m), _M_table(__t) {}
+ bool operator()(char __c) const { return (_M_table[(unsigned char) __c] & _Mask) != 0; }
+};
+
+struct _Ctype_not_mask : public unary_function<char, bool> {
+ ctype_base::mask _Mask;
+ const ctype_base::mask* _M_table;
+
+ _Ctype_not_mask(ctype_base::mask __m, const ctype_base::mask* __t) : _Mask(__m), _M_table(__t) {}
+ bool operator()(char __c) const { return (_M_table[(unsigned char) __c] & _Mask) == 0; }
+};
+
+ctype<char>::ctype(const ctype_base::mask * __tab, bool __del, size_t __refs) :
+ locale::facet(__refs),
+ _M_ctype_table(__tab ? __tab : classic_table()),
+ _M_delete(__tab && __del)
+{}
+
+ctype<char>::~ctype() {
+ if (_M_delete)
+ delete[] __CONST_CAST(ctype_base::mask *, _M_ctype_table);
+}
+
+const char*
+#if defined (__DMC__)
+_STLP_DECLSPEC
+#endif
+ctype<char>::scan_is(ctype_base::mask __m, const char* __low, const char* __high) const
+{ return _STLP_STD::find_if(__low, __high, _Ctype_is_mask(__m, _M_ctype_table)); }
+
+const char*
+#if defined (__DMC__)
+_STLP_DECLSPEC
+#endif
+ctype<char>::scan_not(ctype_base::mask __m, const char* __low, const char* __high) const
+{ return _STLP_STD::find_if(__low, __high, _Ctype_not_mask(__m, _M_ctype_table)); }
+
+char ctype<char>::do_toupper(char __c) const
+{ return (char) _S_upper[(unsigned char) __c]; }
+char ctype<char>::do_tolower(char __c) const
+{ return (char) _S_lower[(unsigned char) __c]; }
+
+const char* ctype<char>::do_toupper(char* __low, const char* __high) const {
+ for ( ; __low < __high; ++__low)
+ *__low = (char) _S_upper[(unsigned char) *__low];
+ return __high;
+}
+const char* ctype<char>::do_tolower(char* __low, const char* __high) const {
+ for ( ; __low < __high; ++__low)
+ *__low = (char) _S_lower[(unsigned char) *__low];
+ return __high;
+}
+
+char
+ctype<char>::do_widen(char __c) const { return __c; }
+
+const char*
+ctype<char>::do_widen(const char* __low, const char* __high,
+ char* __to) const {
+ _STLP_PRIV __copy_trivial(__low, __high, __to);
+ return __high;
+}
+char
+ctype<char>::do_narrow(char __c, char /* dfault */ ) const { return __c; }
+const char*
+ctype<char>::do_narrow(const char* __low, const char* __high,
+ char /* dfault */, char* __to) const {
+ _STLP_PRIV __copy_trivial(__low, __high, __to);
+ return __high;
+}
+
+
+#if !defined (_STLP_NO_WCHAR_T)
+
+struct _Ctype_w_is_mask : public unary_function<wchar_t, bool> {
+ ctype_base::mask M;
+ const ctype_base::mask* table;
+
+ _Ctype_w_is_mask(ctype_base::mask m, const ctype_base::mask* t)
+ : M(m), table(t) {}
+ bool operator()(wchar_t c) const
+ { return _WCharIndex::in_range(c, ctype<char>::table_size) && (table[c] & M); }
+};
+
+//----------------------------------------------------------------------
+// ctype<wchar_t>
+
+ctype<wchar_t>::~ctype() {}
+
+
+bool ctype<wchar_t>::do_is(ctype_base::mask m, wchar_t c) const {
+ const ctype_base::mask * table = ctype<char>::classic_table();
+ return _WCharIndex::in_range(c, ctype<char>::table_size) && (m & table[c]);
+}
+
+const wchar_t* ctype<wchar_t>::do_is(const wchar_t* low, const wchar_t* high,
+ ctype_base::mask * vec) const {
+ // boris : not clear if this is the right thing to do...
+ const ctype_base::mask * table = ctype<char>::classic_table();
+ wchar_t c;
+ for ( ; low < high; ++low, ++vec) {
+ c = *low;
+ *vec = _WCharIndex::in_range(c, ctype<char>::table_size) ? table[c] : ctype_base::mask(0);
+ }
+ return high;
+}
+
+const wchar_t*
+ctype<wchar_t>::do_scan_is(ctype_base::mask m,
+ const wchar_t* low, const wchar_t* high) const {
+ return find_if(low, high, _Ctype_w_is_mask(m, ctype<char>::classic_table()));
+}
+
+
+const wchar_t*
+ctype<wchar_t>::do_scan_not(ctype_base::mask m,
+ const wchar_t* low, const wchar_t* high) const {
+ return find_if(low, high, not1(_Ctype_w_is_mask(m, ctype<char>::classic_table())));
+}
+
+wchar_t ctype<wchar_t>::do_toupper(wchar_t c) const {
+ return _WCharIndex::in_range(c, ctype<char>::table_size) ? (wchar_t)_S_upper[c]
+ : c;
+}
+
+const wchar_t*
+ctype<wchar_t>::do_toupper(wchar_t* low, const wchar_t* high) const {
+ for ( ; low < high; ++low) {
+ wchar_t c = *low;
+ *low = _WCharIndex::in_range(c, ctype<char>::table_size) ? (wchar_t)_S_upper[c]
+ : c;
+ }
+ return high;
+}
+
+wchar_t ctype<wchar_t>::do_tolower(wchar_t c) const {
+ return _WCharIndex::in_range(c, ctype<char>::table_size) ? (wchar_t)_S_lower[c]
+ : c;
+}
+
+const wchar_t*
+ctype<wchar_t>::do_tolower(wchar_t* low, const wchar_t* high) const {
+ for ( ; low < high; ++low) {
+ wchar_t c = *low;
+ *low = _WCharIndex::in_range(c, ctype<char>::table_size) ? (wchar_t)_S_lower[c]
+ : c;
+ }
+ return high;
+}
+
+wchar_t ctype<wchar_t>::do_widen(char c) const {
+ return (wchar_t)(unsigned char)c;
+}
+
+const char*
+ctype<wchar_t>::do_widen(const char* low, const char* high,
+ wchar_t* dest) const {
+ while (low != high)
+ *dest++ = (wchar_t)(unsigned char)*low++;
+ return high;
+}
+
+char ctype<wchar_t>::do_narrow(wchar_t c, char dfault) const
+{ return (unsigned char)c == c ? (char)c : dfault; }
+
+const wchar_t* ctype<wchar_t>::do_narrow(const wchar_t* low,
+ const wchar_t* high,
+ char dfault, char* dest) const {
+ while (low != high) {
+ wchar_t c = *low++;
+ *dest++ = (unsigned char)c == c ? (char)c : dfault;
+ }
+
+ return high;
+}
+
+# endif
+_STLP_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/src/cxa.c b/sources/android/stlport/src/cxa.c
new file mode 100644
index 0000000..998170e
--- /dev/null
+++ b/sources/android/stlport/src/cxa.c
@@ -0,0 +1,198 @@
+#include "stlport_prefix.h"
+
+#if defined(__unix) && defined(__GNUC__)
+
+#ifdef __FreeBSD__
+# include <osreldate.h>
+#endif
+
+#if (defined(__FreeBSD__) && (__FreeBSD_version < 503001)) || defined(__sun) || defined (__hpux)
+/* Note: __cxa_finalize and __cxa_atexit present in libc in FreeBSD 5.3 */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <pthread.h>
+
+/* __asm__ (".symver " "__cxa_finalize" "," "__cxa_finalize" "@" "STLPORT_5_0_0"); */
+/* __asm__ (".symver " "__cxa_finalize" "," "__cxa_finalize" "@@" "STLPORT_5_0_0"); */
+
+/* Not atomic! */
+/* But we can use static mutexes here: I hope that performance issue isn't very
+ significant on unloading (for only few calls, ~10) - ptr */
+
+/*
+#define atomic_compare_and_exchange_bool_acq(mem, newval, oldval) \
+ ({ __typeof (mem) __gmemp = (mem); \
+ __typeof (*mem) __gnewval = (newval); \
+ \
+ *__gmemp == (oldval) ? (*__gmemp = __gnewval, 0) : 1; })
+*/
+
+enum {
+ ef_free, /* `ef_free' MUST be zero! */
+ ef_us,
+ ef_on,
+ ef_at,
+ ef_cxa
+};
+
+struct exit_function
+{
+ /* `flavour' should be of type of the `enum' above but since we need
+ this element in an atomic operation we have to use `long int'. */
+ long int flavor;
+ union {
+ void (*at)(void);
+ struct {
+ void (*fn)(int status, void *arg);
+ void *arg;
+ } on;
+ struct {
+ void (*fn)(void *arg, int status);
+ void *arg;
+ void *dso_handle;
+ } cxa;
+ } func;
+};
+
+struct exit_function_list
+{
+ struct exit_function_list *next;
+ size_t idx;
+ struct exit_function fns[32];
+};
+
+struct exit_function *__new_exitfn (void);
+
+/* Register a function to be called by exit or when a shared library
+ is unloaded. This function is only called from code generated by
+ the C++ compiler. */
+int __cxa_atexit(void (*func)(void *), void *arg, void *d)
+{
+ struct exit_function *new = __new_exitfn ();
+
+ if ( new == NULL )
+ return -1;
+
+ new->flavor = ef_cxa;
+ new->func.cxa.fn = (void (*) (void *, int)) func;
+ new->func.cxa.arg = arg;
+ new->func.cxa.dso_handle = d;
+ return 0;
+}
+
+
+/* We change global data, so we need locking. */
+#ifdef __linux__
+static pthread_mutex_t lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
+#endif
+/* #ifdef __FreeBSD__ */
+#if 0
+static pthread_mutex_t lock =
+ { PTHREAD_MUTEX_RECURSIVE /* PTHREAD_MUTEX_DEFAULT */, PTHREAD_PRIO_NONE, {NULL,NULL},
+ NULL, { NULL }, /* MUTEX_FLAGS_PRIVATE */ 0x1, 0, 0, 0, {NULL, NULL},
+ { 0, 0, 0, 0 } };
+#endif
+#ifdef __sun
+static pthread_mutex_t lock =
+ {{0, 0, 0, PTHREAD_MUTEX_RECURSIVE, _MUTEX_MAGIC}, {{{0}}}, 0};
+#endif
+#ifdef __hpux
+static pthread_mutex_t lock = PTHREAD_MUTEX_RECURSIVE_INITIALIZER_NP;
+# ifdef __ia64
+void *__dso_handle = (void *) &__dso_handle;
+# endif
+#endif
+
+
+static struct exit_function_list initial;
+struct exit_function_list *__exit_funcs = &initial;
+
+struct exit_function *__new_exitfn(void)
+{
+ struct exit_function_list *l;
+ size_t i = 0;
+
+#ifndef __FreeBSD__
+ pthread_mutex_lock( &lock );
+#endif
+
+ for (l = __exit_funcs; l != NULL; l = l->next) {
+ for (i = 0; i < l->idx; ++i)
+ if (l->fns[i].flavor == ef_free)
+ break;
+ if ( i < l->idx )
+ break;
+
+ if (l->idx < sizeof (l->fns) / sizeof (l->fns[0])) {
+ i = l->idx++;
+ break;
+ }
+ }
+
+ if (l == NULL) {
+ l = (struct exit_function_list *)malloc( sizeof(struct exit_function_list) );
+ if (l != NULL) {
+ l->next = __exit_funcs;
+ __exit_funcs = l;
+
+ l->idx = 1;
+ i = 0;
+ }
+ }
+
+ /* Mark entry as used, but we don't know the flavor now. */
+ if ( l != NULL )
+ l->fns[i].flavor = ef_us;
+
+#ifndef __FreeBSD__
+ pthread_mutex_unlock( &lock );
+#endif
+
+ return l == NULL ? NULL : &l->fns[i];
+}
+
+/* If D is non-NULL, call all functions registered with `__cxa_atexit'
+ with the same dso handle. Otherwise, if D is NULL, call all of the
+ registered handlers. */
+
+/*
+ * Note, that original __cxa_finalize don't use lock, but use __exit_funcs
+ * i.e. global data.
+ */
+void __cxa_finalize(void *d)
+{
+ struct exit_function_list *funcs;
+
+#ifndef __FreeBSD__
+ pthread_mutex_lock( &lock );
+#endif
+
+ for (funcs = __exit_funcs; funcs; funcs = funcs->next) {
+ struct exit_function *f;
+
+ for (f = &funcs->fns[funcs->idx - 1]; f >= &funcs->fns[0]; --f) {
+ if ( (d == NULL || d == f->func.cxa.dso_handle) && (f->flavor == ef_cxa) ) {
+ f->flavor = ef_free;
+ (*f->func.cxa.fn) (f->func.cxa.arg, 0);
+ }
+ }
+ }
+
+ /* Remove the registered fork handlers. We do not have to
+ unregister anything if the program is going to terminate anyway. */
+#ifdef UNREGISTER_ATFORK
+ if (d != NULL)
+ UNREGISTER_ATFORK (d);
+#endif
+#ifndef __FreeBSD__
+ pthread_mutex_unlock( &lock );
+#endif
+}
+
+/* __asm__ (".symver " "__cxa_finalize" "," "__cxa_finalize" "@@" "STLPORT_5_0_0"); */
+/* void __cxa_finalize(void *d) __attribute__ ((weak)); */
+
+#endif /* OS name */
+#endif /* __unix */
+
diff --git a/sources/android/stlport/src/details/fstream_stdio.cpp b/sources/android/stlport/src/details/fstream_stdio.cpp
new file mode 100644
index 0000000..8392ffd
--- /dev/null
+++ b/sources/android/stlport/src/details/fstream_stdio.cpp
@@ -0,0 +1,387 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if defined (__SUNPPRO_CC) && !defined (_STLP_NO_NEW_C_HEADERS)
+# include <time.h>
+// For sunpro, it chokes if time.h is included through stat.h
+#endif
+
+#include <fstream>
+
+#ifdef __CYGWIN__
+# define __int64 long long
+#endif
+
+#include <cstdio>
+#if !defined(__ISCPP__)
+extern "C" {
+# include <sys/stat.h>
+}
+#endif
+
+#if defined( __MSL__ )
+# include <unix.h>
+#endif
+
+#if defined(__ISCPP__)
+# include <c_locale_is/filestat.h>
+#endif
+
+#if defined(__BEOS__) && defined(__INTEL__)
+# include <fcntl.h>
+# include <sys/stat.h> // For _fstat
+#endif
+
+#if defined (_STLP_MSVC) || defined (__MINGW32__)
+# include <fcntl.h>
+# define S_IREAD _S_IREAD
+# define S_IWRITE _S_IWRITE
+# define S_IFREG _S_IFREG
+ // map permission masks
+# ifndef S_IRUSR
+# define S_IRUSR _S_IREAD
+# define S_IWUSR _S_IWRITE
+# endif
+# ifndef S_IRGRP
+# define S_IRGRP _S_IREAD
+# define S_IWGRP _S_IWRITE
+# endif
+# ifndef S_IROTH
+# define S_IROTH _S_IREAD
+# define S_IWOTH _S_IWRITE
+# endif
+
+# ifndef O_RDONLY
+# define O_RDONLY _O_RDONLY
+# define O_WRONLY _O_WRONLY
+# define O_RDWR _O_RDWR
+# define O_APPEND _O_APPEND
+# define O_CREAT _O_CREAT
+# define O_TRUNC _O_TRUNC
+# define O_TEXT _O_TEXT
+# define O_BINARY _O_BINARY
+# endif
+
+# ifndef O_ACCMODE
+# define O_ACCMODE (O_RDONLY|O_WRONLY|O_RDWR)
+# endif
+#endif
+
+const _STLP_fd INVALID_STLP_FD = -1;
+
+
+# ifdef __MSL__
+# define _O_TEXT 0x0
+# if !defined( O_TEXT )
+# define O_TEXT _O_TEXT
+# endif
+# define _S_IFREG S_IFREG
+# define S_IREAD S_IRUSR
+# define S_IWRITE S_IWUSR
+# define S_IEXEC S_IXUSR
+# define _S_IWRITE S_IWRITE
+# define _S_IREAD S_IREAD
+# define _open open
+# define _close close
+# define _read read
+# define _write write
+# endif
+
+_STLP_BEGIN_NAMESPACE
+
+// Compare with streamoff definition in stl/char_traits.h!
+
+#if defined (_STLP_USE_DEFAULT_FILE_OFFSET) || \
+ (!defined(_LARGEFILE_SOURCE) && !defined(_LARGEFILE64_SOURCE))
+# define FOPEN fopen
+# define FSEEK fseek
+# define FSTAT fstat
+# define STAT stat
+# define FTELL ftell
+#else
+# define FOPEN fopen64
+# define FSEEK fseeko64
+# define FSTAT fstat64
+# define STAT stat64
+# define FTELL ftello64
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Helper functions for _Filebuf_base.
+
+static bool __is_regular_file(_STLP_fd fd) {
+ struct STAT buf;
+ return FSTAT(fd, &buf) == 0 && (buf.st_mode & S_IFREG) != 0 ;
+}
+
+// Number of characters in the file.
+static streamoff __file_size(_STLP_fd fd) {
+ streamoff ret = 0;
+
+ struct STAT buf;
+ if (FSTAT(fd, &buf) == 0 && (buf.st_mode & S_IFREG) != 0)
+ ret = buf.st_size > 0 ? buf.st_size : 0;
+
+ return ret;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+// All version of Unix have mmap and lseek system calls. Some also have
+// longer versions of those system calls to accommodate 64-bit offsets.
+// If we're on a Unix system, define some macros to encapsulate those
+// differences.
+
+size_t _Filebuf_base::_M_page_size = 4096;
+
+_Filebuf_base::_Filebuf_base()
+ : _M_file_id(INVALID_STLP_FD),
+ _M_openmode(0),
+ _M_is_open(false),
+ _M_should_close(false)
+{}
+
+void _Filebuf_base::_S_initialize()
+{
+
+}
+
+// Return the size of the file. This is a wrapper for stat.
+// Returns zero if the size cannot be determined or is ill-defined.
+streamoff _Filebuf_base::_M_file_size()
+{
+ return _STLP_PRIV __file_size(_M_file_id);
+}
+
+bool _Filebuf_base::_M_open(const char* name, ios_base::openmode openmode,
+ long permission)
+{
+ _STLP_fd file_no;
+
+ if (_M_is_open)
+ return false;
+
+ // use FILE-based i/o
+ const char* flags;
+
+ switch (openmode & (~ios_base::ate)) {
+ case ios_base::out:
+ case ios_base::out | ios_base::trunc:
+ flags = "w";
+ break;
+
+ case ios_base::out | ios_base::binary:
+ case ios_base::out | ios_base::trunc | ios_base::binary:
+ flags = "wb";
+ break;
+
+ case ios_base::out | ios_base::app:
+ flags = "a";
+ break;
+
+ case ios_base::out | ios_base::app | ios_base::binary:
+ flags = "ab";
+ break;
+
+ case ios_base::in:
+ flags = "r";
+ break;
+
+ case ios_base::in | ios_base::binary:
+ flags = "rb";
+ break;
+
+ case ios_base::in | ios_base::out:
+ flags = "r+";
+ break;
+
+ case ios_base::in | ios_base::out | ios_base::binary:
+ flags = "r+b";
+ break;
+
+ case ios_base::in | ios_base::out | ios_base::trunc:
+ flags = "w+";
+ break;
+
+ case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary:
+ flags = "w+b";
+ break;
+
+ default: // The above are the only combinations of
+ return false; // flags allowed by the C++ standard.
+ }
+
+ // fbp : TODO : set permissions !
+ (void)permission; // currently unused //*TY 02/26/2000 - added to suppress warning message
+ _M_file = FOPEN(name, flags);
+
+ if (_M_file) {
+ file_no = fileno(_M_file);
+ } else {
+ return false;
+ }
+
+ // unset buffering immediately
+ setbuf(_M_file, 0);
+
+ _M_is_open = true;
+
+ if (openmode & ios_base::ate) {
+ if (FSEEK(_M_file, 0, SEEK_END) != 0)
+ _M_is_open = false;
+ }
+
+ _M_file_id = file_no;
+ _M_should_close = _M_is_open;
+ _M_openmode = openmode;
+
+ if (_M_is_open)
+ _M_regular_file = _STLP_PRIV __is_regular_file(_M_file_id);
+
+ return (_M_is_open != 0);
+}
+
+
+bool _Filebuf_base::_M_open(const char* name, ios_base::openmode openmode)
+{
+ // This doesn't really grant everyone in the world read/write
+ // access. On Unix, file-creation system calls always clear
+ // bits that are set in the umask from the permissions flag.
+ return this->_M_open(name, openmode, S_IRUSR | S_IWUSR | S_IRGRP |
+ S_IWGRP | S_IROTH | S_IWOTH);
+}
+
+// Associated the filebuf with a file descriptor pointing to an already-
+// open file. Mode is set to be consistent with the way that the file
+// was opened.
+bool _Filebuf_base::_M_open( int file_no, ios_base::openmode )
+{
+ if (_M_is_open || file_no < 0)
+ return false;
+
+ struct STAT buf;
+ if (FSTAT(file_no, &buf) != 0)
+ return false;
+ int mode = buf.st_mode;
+
+ switch ( mode & (S_IWRITE | S_IREAD) ) {
+ case S_IREAD:
+ _M_openmode = ios_base::in;
+ break;
+ case S_IWRITE:
+ _M_openmode = ios_base::out;
+ break;
+ case (S_IWRITE | S_IREAD):
+ _M_openmode = ios_base::in | ios_base::out;
+ break;
+ default:
+ return false;
+ }
+ _M_file_id = file_no;
+ _M_is_open = true;
+ _M_should_close = false;
+ _M_regular_file = _STLP_PRIV __is_regular_file(_M_file_id);
+ return true;
+}
+
+bool _Filebuf_base::_M_close()
+{
+ if (!_M_is_open)
+ return false;
+
+ bool ok = _M_should_close ? (fclose(_M_file) == 0) : true;
+
+ _M_is_open = _M_should_close = false;
+ _M_openmode = 0;
+ return ok;
+}
+
+// Read up to n characters into a buffer. Return value is number of
+// characters read.
+ptrdiff_t _Filebuf_base::_M_read(char* buf, ptrdiff_t n) {
+ return fread(buf, 1, n, _M_file);
+}
+
+// Write n characters from a buffer. Return value: true if we managed
+// to write the entire buffer, false if we didn't.
+bool _Filebuf_base::_M_write(char* buf, ptrdiff_t n)
+{
+ for (;;) {
+ ptrdiff_t written = fwrite(buf, 1, n, _M_file);
+
+ if (n == written) {
+ return true;
+ }
+
+ if (written > 0 && written < n) {
+ n -= written;
+ buf += written;
+ } else {
+ return false;
+ }
+ }
+}
+
+// Wrapper for lseek or the like.
+streamoff _Filebuf_base::_M_seek(streamoff offset, ios_base::seekdir dir)
+{
+ int whence;
+
+ switch ( dir ) {
+ case ios_base::beg:
+ if (offset < 0 /* || offset > _M_file_size() */ )
+ return streamoff(-1);
+ whence = SEEK_SET;
+ break;
+ case ios_base::cur:
+ whence = SEEK_CUR;
+ break;
+ case ios_base::end:
+ if (/* offset > 0 || */ -offset > _M_file_size() )
+ return streamoff(-1);
+ whence = SEEK_END;
+ break;
+ default:
+ return streamoff(-1);
+ }
+
+ if ( FSEEK(_M_file, offset, whence) == 0 ) {
+ return FTELL(_M_file);
+ }
+
+ return streamoff(-1);
+}
+
+
+// Attempts to memory-map len bytes of the current file, starting
+// at position offset. Precondition: offset is a multiple of the
+// page size. Postcondition: return value is a null pointer if the
+// memory mapping failed. Otherwise the return value is a pointer to
+// the memory-mapped file and the file position is set to offset.
+void *_Filebuf_base::_M_mmap(streamoff, streamoff )
+{
+ return 0;
+}
+
+void _Filebuf_base::_M_unmap(void*, streamoff)
+{
+ // precondition : there is a valid mapping at the moment
+}
+
+_STLP_END_NAMESPACE
diff --git a/sources/android/stlport/src/details/fstream_unistd.cpp b/sources/android/stlport/src/details/fstream_unistd.cpp
new file mode 100644
index 0000000..7440883
--- /dev/null
+++ b/sources/android/stlport/src/details/fstream_unistd.cpp
@@ -0,0 +1,347 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if defined (__SUNPPRO_CC) && !defined (_STLP_NO_NEW_C_HEADERS)
+# include <time.h>
+// For sunpro, it chokes if time.h is included through stat.h
+#endif
+
+#include <fstream>
+
+#ifdef __CYGWIN__
+# define __int64 long long
+#endif
+
+extern "C" {
+// open/close/read/write
+#include <sys/stat.h> // For stat
+#if !defined (_CRAY) && ! defined (__EMX__)
+# include <sys/mman.h> // For mmap
+#endif
+
+// on HP-UX 11, this one contradicts with pthread.h on pthread_atfork, unless we unset this
+#if defined (__hpux) && defined (__GNUC__)
+# undef _INCLUDE_POSIX1C_SOURCE
+#endif
+
+#include <unistd.h>
+#include <fcntl.h>
+}
+
+#ifdef __APPLE__
+# include <sys/sysctl.h>
+#endif
+
+const _STLP_fd INVALID_STLP_FD = -1;
+
+#ifndef O_ACCMODE
+# define O_ACCMODE (O_RDONLY|O_WRONLY|O_RDWR)
+#endif
+
+// Compare with streamoff definition in stl/char_traits.h!
+#if defined (_STLP_USE_DEFAULT_FILE_OFFSET) || \
+ (!defined(_LARGEFILE_SOURCE) && !defined (_LARGEFILE64_SOURCE))
+# define FSTAT fstat
+# define STAT stat
+# define LSEEK lseek
+# define MMAP mmap
+# define OPEN open
+#else
+# define FSTAT fstat64
+# define STAT stat64
+# define LSEEK lseek64
+# define MMAP mmap64
+# define OPEN open64
+#endif
+
+#ifndef MAP_FAILED /* MMAP failure return code */
+# define MAP_FAILED -1
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+static ios_base::openmode flag_to_openmode(int mode)
+{
+ ios_base::openmode ret = ios_base::__default_mode;
+
+ switch ( mode & O_ACCMODE ) {
+ case O_RDONLY:
+ ret = ios_base::in;
+ break;
+ case O_WRONLY:
+ ret = ios_base::out;
+ break;
+ case O_RDWR:
+ ret = ios_base::in | ios_base::out;
+ break;
+ }
+
+ if ( mode & O_APPEND )
+ ret |= ios_base::app;
+
+ return ret;
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Helper functions for _Filebuf_base.
+
+static bool __is_regular_file(_STLP_fd fd) {
+ struct STAT buf;
+ return FSTAT(fd, &buf) == 0 && S_ISREG(buf.st_mode);
+}
+
+// Number of characters in the file.
+static streamoff __file_size(_STLP_fd fd) {
+ streamoff ret = 0;
+
+ struct STAT buf;
+ if (FSTAT(fd, &buf) == 0 && S_ISREG(buf.st_mode))
+ ret = buf.st_size > 0 ? buf.st_size : 0;
+
+ return ret;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+size_t _Filebuf_base::_M_page_size = 4096;
+
+_Filebuf_base::_Filebuf_base()
+ : _M_file_id(INVALID_STLP_FD),
+ _M_openmode(0),
+ _M_is_open(false),
+ _M_should_close(false)
+{}
+
+void _Filebuf_base::_S_initialize()
+{
+#if defined (__APPLE__)
+ int mib[2];
+ size_t pagesize, len;
+ mib[0] = CTL_HW;
+ mib[1] = HW_PAGESIZE;
+ len = sizeof(pagesize);
+ sysctl(mib, 2, &pagesize, &len, NULL, 0);
+ _M_page_size = pagesize;
+#elif defined (__DJGPP) && defined (_CRAY)
+ _M_page_size = BUFSIZ;
+#else
+ _M_page_size = sysconf(_SC_PAGESIZE);
+#endif
+}
+
+// Return the size of the file. This is a wrapper for stat.
+// Returns zero if the size cannot be determined or is ill-defined.
+streamoff _Filebuf_base::_M_file_size()
+{
+ return _STLP_PRIV __file_size(_M_file_id);
+}
+
+bool _Filebuf_base::_M_open(const char* name, ios_base::openmode openmode,
+ long permission)
+{
+ _STLP_fd file_no;
+
+ if (_M_is_open)
+ return false;
+
+ int flags = 0;
+
+ // Unix makes no distinction between text and binary files.
+ switch ( openmode & (~ios_base::ate & ~ios_base::binary) ) {
+ case ios_base::out:
+ case ios_base::out | ios_base::trunc:
+ flags = O_WRONLY | O_CREAT | O_TRUNC;
+ break;
+ case ios_base::app:
+ case ios_base::out | ios_base::app:
+ flags = O_WRONLY | O_CREAT | O_APPEND;
+ break;
+ case ios_base::in:
+ flags = O_RDONLY;
+ permission = 0; // Irrelevant unless we're writing.
+ break;
+ case ios_base::in | ios_base::out:
+ flags = O_RDWR;
+ break;
+ case ios_base::in | ios_base::out | ios_base::trunc:
+ flags = O_RDWR | O_CREAT | O_TRUNC;
+ break;
+ case ios_base::in | ios_base::app:
+ case ios_base::in | ios_base::out | ios_base::app:
+ flags = O_RDWR | O_CREAT | O_APPEND;
+ break;
+ default: // The above are the only combinations of
+ return false; // flags allowed by the C++ standard.
+ }
+
+ file_no = OPEN(name, flags, permission);
+
+ if (file_no < 0)
+ return false;
+
+ _M_is_open = true;
+
+ if ((openmode & (ios_base::ate | ios_base::app)) && (LSEEK(file_no, 0, SEEK_END) == -1)) {
+ _M_is_open = false;
+ }
+
+ _M_file_id = file_no;
+ _M_should_close = _M_is_open;
+ _M_openmode = openmode;
+
+ if (_M_is_open)
+ _M_regular_file = _STLP_PRIV __is_regular_file(_M_file_id);
+
+ return (_M_is_open != 0);
+}
+
+
+bool _Filebuf_base::_M_open(const char* name, ios_base::openmode openmode)
+{
+ // This doesn't really grant everyone in the world read/write
+ // access. On Unix, file-creation system calls always clear
+ // bits that are set in the umask from the permissions flag.
+ return this->_M_open(name, openmode, S_IRUSR | S_IWUSR | S_IRGRP |
+ S_IWGRP | S_IROTH | S_IWOTH);
+}
+
+// Associated the filebuf with a file descriptor pointing to an already-
+// open file. Mode is set to be consistent with the way that the file
+// was opened.
+bool _Filebuf_base::_M_open(int file_no, ios_base::openmode)
+{
+ if (_M_is_open || file_no < 0)
+ return false;
+
+ int mode = fcntl(file_no, F_GETFL);
+
+ if (mode == -1)
+ return false;
+
+ _M_openmode = flag_to_openmode(mode);
+ _M_file_id = file_no;
+
+ _M_is_open = true;
+ _M_should_close = false;
+ _M_regular_file = _STLP_PRIV __is_regular_file(_M_file_id);
+ return true;
+}
+
+bool _Filebuf_base::_M_close()
+{
+ if (!_M_is_open)
+ return false;
+
+ bool ok = _M_should_close ? (close(_M_file_id) == 0) : true;
+
+ _M_is_open = _M_should_close = false;
+ _M_openmode = 0;
+ return ok;
+}
+
+// Read up to n characters into a buffer. Return value is number of
+// characters read.
+ptrdiff_t _Filebuf_base::_M_read(char* buf, ptrdiff_t n)
+{
+ return read(_M_file_id, buf, n);
+}
+
+// Write n characters from a buffer. Return value: true if we managed
+// to write the entire buffer, false if we didn't.
+bool _Filebuf_base::_M_write(char* buf, ptrdiff_t n)
+{
+ for (;;) {
+ ptrdiff_t written = write(_M_file_id, buf, n);
+
+ if (n == written) {
+ return true;
+ }
+
+ if (written > 0 && written < n) {
+ n -= written;
+ buf += written;
+ } else {
+ return false;
+ }
+ }
+}
+
+// Wrapper for lseek or the like.
+streamoff _Filebuf_base::_M_seek(streamoff offset, ios_base::seekdir dir)
+{
+ int whence;
+
+ switch ( dir ) {
+ case ios_base::beg:
+ if (offset < 0 /* || offset > _M_file_size() */ )
+ return streamoff(-1);
+ whence = SEEK_SET;
+ break;
+ case ios_base::cur:
+ whence = SEEK_CUR;
+ break;
+ case ios_base::end:
+ if (/* offset > 0 || */ -offset > _M_file_size() )
+ return streamoff(-1);
+ whence = SEEK_END;
+ break;
+ default:
+ return streamoff(-1);
+ }
+
+ return LSEEK(_M_file_id, offset, whence);
+}
+
+// Attempts to memory-map len bytes of the current file, starting
+// at position offset. Precondition: offset is a multiple of the
+// page size. Postcondition: return value is a null pointer if the
+// memory mapping failed. Otherwise the return value is a pointer to
+// the memory-mapped file and the file position is set to offset.
+void* _Filebuf_base::_M_mmap(streamoff offset, streamoff len)
+{
+ void* base;
+#if !defined (__DJGPP) && !defined (_CRAY)
+ base = MMAP(0, len, PROT_READ, MAP_PRIVATE, _M_file_id, offset);
+ if (base != (void*)MAP_FAILED) {
+ if (LSEEK(_M_file_id, offset + len, SEEK_SET) < 0) {
+ this->_M_unmap(base, len);
+ base = 0;
+ }
+ } else
+ base =0;
+#else
+ _STLP_MARK_PARAMETER_AS_UNUSED(&offset)
+ _STLP_MARK_PARAMETER_AS_UNUSED(&len)
+ base = 0;
+#endif
+ return base;
+}
+
+void _Filebuf_base::_M_unmap(void* base, streamoff len)
+{
+ // precondition : there is a valid mapping at the moment
+#if !defined (__DJGPP) && !defined (_CRAY)
+ munmap((char*)base, len);
+#else
+ _STLP_MARK_PARAMETER_AS_UNUSED(&len)
+ _STLP_MARK_PARAMETER_AS_UNUSED(base)
+#endif
+}
+
+_STLP_END_NAMESPACE
diff --git a/sources/android/stlport/src/details/fstream_win32io.cpp b/sources/android/stlport/src/details/fstream_win32io.cpp
new file mode 100644
index 0000000..673f367
--- /dev/null
+++ b/sources/android/stlport/src/details/fstream_win32io.cpp
@@ -0,0 +1,629 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#include <fstream>
+
+#if !defined (_STLP_WCE)
+# ifdef __BORLANDC__
+# include <cfcntl.h> // For _O_RDONLY, etc
+# else
+# include <io.h> // For _get_osfhandle
+# include <fcntl.h> // For _O_RDONLY, etc
+# endif
+# include <sys/stat.h> // For _fstat
+#endif
+
+#define _TEXTBUF_SIZE 0x1000
+
+const _STLP_fd INVALID_STLP_FD = INVALID_HANDLE_VALUE;
+
+#if !defined (INVALID_SET_FILE_POINTER)
+# define INVALID_SET_FILE_POINTER 0xffffffff
+#endif
+
+#ifndef O_ACCMODE
+# define O_ACCMODE (O_RDONLY|O_WRONLY|O_RDWR)
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if !defined(__MSL__) && !defined(_STLP_WCE)
+static ios_base::openmode flag_to_openmode(int mode) {
+ ios_base::openmode ret = ios_base::__default_mode;
+
+ switch (mode & O_ACCMODE) {
+ case O_RDONLY:
+ ret = ios_base::in; break;
+ case O_WRONLY:
+ ret = ios_base::out; break;
+ case O_RDWR:
+ ret = ios_base::in | ios_base::out; break;
+ }
+
+ if (mode & O_APPEND)
+ ret |= ios_base::app;
+
+ if (mode & O_BINARY)
+ ret |= ios_base::binary;
+
+ return ret;
+}
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Helper functions for _Filebuf_base.
+
+static bool __is_regular_file(_STLP_fd fd) {
+ BY_HANDLE_FILE_INFORMATION info;
+
+ // Return true if the file handle isn't a directory.
+ return GetFileInformationByHandle(fd, &info) &&
+ ((info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0);
+}
+
+// Number of characters in the file.
+static streamoff __file_size(_STLP_fd fd) {
+ streamoff ret = 0;
+
+ LARGE_INTEGER li;
+ li.LowPart = GetFileSize(fd, (unsigned long*) &li.HighPart);
+ if (li.LowPart != INVALID_FILE_SIZE || GetLastError() == NO_ERROR)
+ ret = li.QuadPart;
+
+ return ret;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+// Visual C++ and Intel use this, but not Metrowerks
+// Also MinGW, msvcrt.dll (but not crtdll.dll) dependent version
+#if (defined (_STLP_MSVC_LIB) && !defined (_STLP_WCE)) || \
+ (defined (__MINGW32__) && defined (__MSVCRT__))
+
+// fcntl(fileno, F_GETFL) for Microsoft library
+// 'semi-documented' defines:
+# define IOINFO_L2E 5
+# define IOINFO_ARRAY_ELTS (1 << IOINFO_L2E)
+# define _pioinfo(i) ( __pioinfo[(i) >> IOINFO_L2E] + \
+ ((i) & (IOINFO_ARRAY_ELTS - 1)) )
+# define FAPPEND 0x20 // O_APPEND flag
+# define FTEXT 0x80 // O_TEXT flag
+// end of 'semi-documented' defines
+
+// 'semi-documented' internal structure
+extern "C" {
+ struct ioinfo {
+ long osfhnd; // the real os HANDLE
+ char osfile; // file handle flags
+ char pipech; // pipe buffer
+# if defined (_MT)
+ // multi-threaded locking
+ int lockinitflag;
+ CRITICAL_SECTION lock;
+# endif
+ };
+# if defined (__MINGW32__)
+ __MINGW_IMPORT ioinfo * __pioinfo[];
+# else
+ extern _CRTIMP ioinfo * __pioinfo[];
+# endif
+} // extern "C"
+// end of 'semi-documented' declarations
+
+static ios_base::openmode _get_osfflags(int fd, HANDLE oshandle) {
+ char dosflags = 0;
+ if (fd >= 0)
+ dosflags = _pioinfo(fd)->osfile;
+ //else
+ //the file will be considered as open in binary mode with no append attribute
+ // end of 'semi-documented' stuff
+
+ int mode = 0;
+ if (dosflags & FAPPEND)
+ mode |= O_APPEND;
+
+ if (dosflags & FTEXT)
+ mode |= O_TEXT;
+ else
+ mode |= O_BINARY;
+
+ // For Read/Write access we have to guess
+ DWORD dummy, dummy2;
+ BOOL writeOk = WriteFile(oshandle, &dummy2, 0, &dummy, 0);
+ BOOL readOk = ReadFile(oshandle, &dummy2, 0, &dummy, NULL);
+ if (writeOk && readOk)
+ mode |= O_RDWR;
+ else if (readOk)
+ mode |= O_RDONLY;
+ else
+ mode |= O_WRONLY;
+
+ return flag_to_openmode(mode);
+}
+
+#elif defined (__DMC__)
+
+# define FHND_APPEND 0x04
+# define FHND_DEVICE 0x08
+# define FHND_TEXT 0x10
+
+extern "C" unsigned char __fhnd_info[_NFILE];
+
+static ios_base::openmode _get_osfflags(int fd, HANDLE oshandle) {
+ int mode = 0;
+
+ if (__fhnd_info[fd] & FHND_APPEND)
+ mode |= O_APPEND;
+
+ if (__fhnd_info[fd] & FHND_TEXT == 0)
+ mode |= O_BINARY;
+
+ for (FILE *fp = &_iob[0]; fp < &_iob[_NFILE]; fp++) {
+ if ((fileno(fp) == fd) && (fp->_flag & (_IOREAD | _IOWRT | _IORW))) {
+ const int osflags = fp->_flag;
+
+ if ((osflags & _IOREAD) && !(osflags & _IOWRT) && !(osflags & _IORW))
+ mode |= O_RDONLY;
+ else if ((osflags & _IOWRT) && !(osflags & _IOREAD) && !(osflags & _IORW))
+ mode |= O_WRONLY;
+ else
+ mode |= O_RDWR;
+ break;
+ }
+ }
+
+ return flag_to_openmode(mode);
+}
+#endif
+
+size_t _Filebuf_base::_M_page_size = 4096;
+
+_Filebuf_base::_Filebuf_base()
+ : _M_file_id(INVALID_STLP_FD),
+ _M_openmode(0),
+ _M_is_open(false),
+ _M_should_close(false),
+ _M_view_id(0)
+{}
+
+void _Filebuf_base::_S_initialize() {
+ SYSTEM_INFO SystemInfo;
+ GetSystemInfo(&SystemInfo);
+ _M_page_size = SystemInfo.dwPageSize;
+ // might be .dwAllocationGranularity
+}
+
+// Return the size of the file. This is a wrapper for stat.
+// Returns zero if the size cannot be determined or is ill-defined.
+streamoff _Filebuf_base::_M_file_size() {
+ return _STLP_PRIV __file_size(_M_file_id);
+}
+
+bool _Filebuf_base::_M_open(const char* name, ios_base::openmode openmode,
+ long permission) {
+ _STLP_fd file_no;
+
+ if (_M_is_open)
+ return false;
+
+ DWORD dwDesiredAccess, dwCreationDisposition;
+ bool doTruncate = false;
+
+ switch (openmode & (~ios_base::ate & ~ios_base::binary)) {
+ case ios_base::out:
+ case ios_base::out | ios_base::trunc:
+ dwDesiredAccess = GENERIC_WRITE;
+ dwCreationDisposition = OPEN_ALWAYS;
+ // boris : even though it is very non-intuitive, standard
+ // requires them both to behave same.
+ doTruncate = true;
+ break;
+ case ios_base::out | ios_base::app:
+ dwDesiredAccess = GENERIC_WRITE;
+ dwCreationDisposition = OPEN_ALWAYS;
+ break;
+ case ios_base::in:
+ dwDesiredAccess = GENERIC_READ;
+ dwCreationDisposition = OPEN_EXISTING;
+ permission = 0; // Irrelevant unless we're writing.
+ break;
+ case ios_base::in | ios_base::out:
+ dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
+ dwCreationDisposition = OPEN_EXISTING;
+ break;
+ case ios_base::in | ios_base::out | ios_base::trunc:
+ dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
+ dwCreationDisposition = OPEN_ALWAYS;
+ doTruncate = true;
+ break;
+ default: // The above are the only combinations of
+ return false; // flags allowed by the C++ standard.
+ }
+
+ DWORD dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
+
+#if defined(_STLP_USE_WIDE_INTERFACE)
+ file_no = CreateFile (_STLP_PRIV __ASCIIToWide(name).c_str(),
+#else
+ file_no = CreateFileA(name,
+#endif
+ dwDesiredAccess, dwShareMode, 0,
+ dwCreationDisposition, permission, 0);
+
+ if (file_no == INVALID_STLP_FD)
+ return false;
+
+ if (
+#if !defined (_STLP_WCE)
+ GetFileType(file_no) == FILE_TYPE_DISK &&
+#endif
+ ((doTruncate && SetEndOfFile(file_no) == 0) ||
+ (((openmode & ios_base::ate) != 0) &&
+ (SetFilePointer(file_no, 0, NULL, FILE_END) == INVALID_SET_FILE_POINTER)))) {
+ CloseHandle(file_no);
+ return false;
+ }
+
+ _M_is_open = true;
+ _M_file_id = file_no;
+ _M_should_close = _M_is_open;
+ _M_openmode = openmode;
+
+ if (_M_is_open)
+ _M_regular_file = _STLP_PRIV __is_regular_file(_M_file_id);
+
+ return (_M_is_open != 0);
+}
+
+bool _Filebuf_base::_M_open(const char* name, ios_base::openmode openmode) {
+ // This doesn't really grant everyone in the world read/write
+ // access. On Unix, file-creation system calls always clear
+ // bits that are set in the umask from the permissions flag.
+ return this->_M_open(name, openmode, FILE_ATTRIBUTE_NORMAL);
+}
+
+bool _Filebuf_base::_M_open(_STLP_fd __id, ios_base::openmode init_mode) {
+#if (defined (_STLP_MSVC_LIB) && !defined (_STLP_WCE)) || \
+ (defined (__MINGW32__) && defined (__MSVCRT__)) || defined (__DMC__)
+
+ if (_M_is_open || __id == INVALID_STLP_FD)
+ return false;
+
+ if (init_mode != ios_base::__default_mode)
+ _M_openmode = init_mode;
+ else
+ _M_openmode = _get_osfflags(-1, __id);
+
+ _M_is_open = true;
+ _M_file_id = __id;
+ _M_should_close = false;
+ _M_regular_file = _STLP_PRIV __is_regular_file(_M_file_id);
+
+ return true;
+#else
+ (void)__id;
+ (void)init_mode; // dwa 4/27/00 - suppress unused parameter warning
+
+ // not available for the API
+ return false;
+
+#endif
+}
+
+// Associated the filebuf with a file descriptor pointing to an already-
+// open file. Mode is set to be consistent with the way that the file
+// was opened.
+bool _Filebuf_base::_M_open(int file_no, ios_base::openmode init_mode) {
+ if (_M_is_open || file_no < 0)
+ return false;
+
+#if (defined (_STLP_MSVC_LIB) && !defined (_STLP_WCE)) || \
+ (defined (__MINGW32__) && defined (__MSVCRT__)) || defined (__DMC__)
+
+ HANDLE oshandle = (HANDLE)_get_osfhandle(file_no);
+ if (oshandle == INVALID_STLP_FD)
+ return false;
+
+ if (init_mode != ios_base::__default_mode)
+ _M_openmode = init_mode;
+ else
+ _M_openmode = _get_osfflags(file_no, oshandle);
+
+ _M_file_id = oshandle;
+ _M_is_open = true;
+ _M_should_close = false;
+ _M_regular_file = _STLP_PRIV __is_regular_file(_M_file_id);
+ return true;
+#else
+ _STLP_MARK_PARAMETER_AS_UNUSED(&init_mode)
+ // not available for the API
+ return false;
+#endif
+}
+
+bool _Filebuf_base::_M_close() {
+ if (!_M_is_open)
+ return false;
+
+ bool ok;
+
+ if (!_M_should_close)
+ ok = true;
+ else {
+ if (_M_file_id != INVALID_STLP_FD) {
+ ok = (CloseHandle(_M_file_id) != 0);
+ }
+ else {
+ ok = false;
+ }
+ }
+
+ _M_is_open = _M_should_close = false;
+ _M_openmode = 0;
+ return ok;
+}
+
+
+#define _STLP_LF 10
+#define _STLP_CR 13
+#define _STLP_CTRLZ 26
+
+// Read up to n characters into a buffer. Return value is number of
+// characters read.
+ptrdiff_t _Filebuf_base::_M_read(char* buf, ptrdiff_t n) {
+ ptrdiff_t readen = 0;
+ //Here cast to size_t is safe as n cannot be negative.
+ size_t chunkSize = (min)(size_t(0xffffffff), __STATIC_CAST(size_t, n));
+ // The following, while validating that we are still able to extract chunkSize
+ // charaters to the buffer, avoids extraction of too small chunk of datas
+ // which would be counter performant.
+ while (__STATIC_CAST(size_t, (n - readen)) >= chunkSize) {
+ DWORD numberOfBytesRead;
+ ReadFile(_M_file_id, buf + readen, __STATIC_CAST(DWORD, chunkSize), &numberOfBytesRead, 0);
+
+ if (numberOfBytesRead == 0)
+ break;
+
+ if (!(_M_openmode & ios_base::binary)) {
+ // translate CR-LFs to LFs in the buffer
+ char *to = buf + readen;
+ char *from = to;
+ char *last = from + numberOfBytesRead - 1;
+ for (; from <= last && *from != _STLP_CTRLZ; ++from) {
+ if (*from != _STLP_CR)
+ *to++ = *from;
+ else { // found CR
+ if (from < last) { // not at buffer end
+ if (*(from + 1) != _STLP_LF)
+ *to++ = _STLP_CR;
+ }
+ else { // last char is CR, peek for LF
+ char peek = ' ';
+ DWORD NumberOfBytesPeeked;
+ ReadFile(_M_file_id, (LPVOID)&peek, 1, &NumberOfBytesPeeked, 0);
+ if (NumberOfBytesPeeked != 0) {
+ if (peek != _STLP_LF) { //not a <CR><LF> combination
+ *to++ = _STLP_CR;
+ if ((to < buf + n) && (peek != _STLP_CR))
+ //We have enough place to store peek and it is no a special
+ //_STLP_CR character, we can store it.
+ *to++ = peek;
+ else
+ SetFilePointer(_M_file_id, (LONG)-1, 0, FILE_CURRENT);
+ }
+ else {
+ // A <CR><LF> combination, we keep the <LF>:
+ *to++ = _STLP_LF;
+ }
+ }
+ else {
+ /* This case is tedious, we could
+ * - put peek back in the file but this would then generate an infinite loop
+ * - report an error as we don't know if in a future call to ReadFile we won't then
+ * get a <LF>. Doing so would make all files with a <CR> last an invalid file
+ * for STLport, a hard solution for STLport clients.
+ * - store the <CR> in the returned buffer, the chosen solution, even if in this
+ * case we could miss a <CR><LF> combination.
+ */
+ *to++ = _STLP_CR;
+ }
+ }
+ } // found CR
+ } // for
+ readen = to - buf;
+ // seek back to TEXT end of file if hit CTRL-Z
+ if (from <= last) { // terminated due to CTRLZ
+ SetFilePointer(_M_file_id, -(LONG)((last + 1) - from), 0, FILE_CURRENT);
+ break;
+ }
+ }
+ else
+ readen += numberOfBytesRead;
+ }
+ return readen;
+}
+
+// Write n characters from a buffer. Return value: true if we managed
+// to write the entire buffer, false if we didn't.
+bool _Filebuf_base::_M_write(char* buf, ptrdiff_t n) {
+ for (;;) {
+ ptrdiff_t written;
+
+ //In the following implementation we are going to cast most of the ptrdiff_t
+ //values in size_t to work with coherent unsigned values. Doing so make code
+ //more simple especially in the min function call.
+
+ // In append mode, every write does an implicit seek to the end
+ // of the file.
+ if (_M_openmode & ios_base::app)
+ _M_seek(0, ios_base::end);
+
+ if (_M_openmode & ios_base::binary) {
+ // binary mode
+ size_t bytes_to_write = (size_t)n;
+ DWORD NumberOfBytesWritten;
+ written = 0;
+ for (; bytes_to_write != 0;) {
+ WriteFile(_M_file_id, buf + written,
+ __STATIC_CAST(DWORD, (min)(size_t(0xffffffff), bytes_to_write)),
+ &NumberOfBytesWritten, 0);
+ if (NumberOfBytesWritten == 0)
+ return false;
+ bytes_to_write -= NumberOfBytesWritten;
+ written += NumberOfBytesWritten;
+ }
+ }
+ else {
+ char textbuf[_TEXTBUF_SIZE + 1]; // extra 1 in case LF at end
+ char * nextblock = buf, * ptrtextbuf = textbuf;
+ char * endtextbuf = textbuf + _TEXTBUF_SIZE;
+ char * endblock = buf + n;
+ ptrdiff_t nextblocksize = (min) (n, (ptrdiff_t)_TEXTBUF_SIZE);
+ char * nextlf;
+
+ while ( (nextblocksize > 0) &&
+ (nextlf = (char *)memchr(nextblock, _STLP_LF, nextblocksize)) != 0) {
+ ptrdiff_t linelength = nextlf - nextblock;
+ memcpy(ptrtextbuf, nextblock, linelength);
+ ptrtextbuf += linelength;
+ nextblock += (linelength + 1);
+ * ptrtextbuf ++ = _STLP_CR;
+ * ptrtextbuf ++ = _STLP_LF;
+ nextblocksize = (min) (ptrdiff_t(endblock - nextblock),
+ (max) (ptrdiff_t(0), ptrdiff_t(endtextbuf - ptrtextbuf)));
+ }
+ // write out what's left, > condition is here since for LF at the end ,
+ // endtextbuf may get < ptrtextbuf ...
+ if (nextblocksize > 0) {
+ memcpy(ptrtextbuf, nextblock, nextblocksize);
+ ptrtextbuf += nextblocksize;
+ nextblock += nextblocksize;
+ }
+ // now write out the translated buffer
+ char * writetextbuf = textbuf;
+ for (size_t NumberOfBytesToWrite = (size_t)(ptrtextbuf - textbuf);
+ NumberOfBytesToWrite;) {
+ DWORD NumberOfBytesWritten;
+ WriteFile((HANDLE)_M_file_id, writetextbuf,
+ __STATIC_CAST(DWORD, (min)(size_t(0xffffffff), NumberOfBytesToWrite)),
+ &NumberOfBytesWritten, 0);
+ if (!NumberOfBytesWritten) // write shortfall
+ return false;
+ writetextbuf += NumberOfBytesWritten;
+ NumberOfBytesToWrite -= NumberOfBytesWritten;
+ }
+ // count non-translated characters
+ written = (nextblock - buf);
+ }
+
+ if (n == written)
+ return true;
+ else if (written > 0 && written < n) {
+ n -= written;
+ buf += written;
+ }
+ else
+ return false;
+ }
+}
+
+// Wrapper for lseek or the like.
+streamoff _Filebuf_base::_M_seek(streamoff offset, ios_base::seekdir dir) {
+ streamoff result = -1;
+ int whence;
+
+ switch(dir) {
+ case ios_base::beg:
+ if (offset < 0 /* || offset > _M_file_size() */ )
+ return streamoff(-1);
+ whence = FILE_BEGIN;
+ break;
+ case ios_base::cur:
+ whence = FILE_CURRENT;
+ break;
+ case ios_base::end:
+ if (/* offset > 0 || */ -offset > _M_file_size() )
+ return streamoff(-1);
+ whence = FILE_END;
+ break;
+ default:
+ return streamoff(-1);
+ }
+
+ LARGE_INTEGER li;
+ li.QuadPart = offset;
+ li.LowPart = SetFilePointer(_M_file_id, li.LowPart, &li.HighPart, whence);
+ if (li.LowPart != INVALID_SET_FILE_POINTER || GetLastError() == NO_ERROR)
+ result = li.QuadPart;
+
+ return result;
+}
+
+
+// Attempts to memory-map len bytes of the current file, starting
+// at position offset. Precondition: offset is a multiple of the
+// page size. Postcondition: return value is a null pointer if the
+// memory mapping failed. Otherwise the return value is a pointer to
+// the memory-mapped file and the file position is set to offset.
+void* _Filebuf_base::_M_mmap(streamoff offset, streamoff len) {
+ void* base;
+ _M_view_id = CreateFileMapping(_M_file_id, (PSECURITY_ATTRIBUTES)0 ,
+ PAGE_READONLY, 0 /* len >> 32 */ ,
+ 0 /* len & 0xFFFFFFFF */ , // low-order DWORD of size
+ 0);
+
+ if (_M_view_id) {
+#if 0
+/*
+ printf("view %x created from file %x, error = %d, size = %d, map_offset = %d map_len = %d\n",
+ _M_view_id, _M_file_id, GetLastError(),
+ (int)cur_filesize, ULL(offset) & 0xffffffff, len);
+*/
+#endif
+ LARGE_INTEGER li;
+ li.QuadPart = offset;
+ base = MapViewOfFile(_M_view_id, FILE_MAP_READ, li.HighPart, li.LowPart,
+#if !defined (__DMC__)
+ __STATIC_CAST(SIZE_T, len));
+#else
+ __STATIC_CAST(DWORD, len));
+#endif
+ // check if mapping succeded and is usable
+ if (base == 0 || _M_seek(offset + len, ios_base::beg) < 0) {
+ this->_M_unmap(base, len);
+ base = 0;
+ }
+ } else
+ base = 0;
+
+ return base;
+}
+
+void _Filebuf_base::_M_unmap(void* base, streamoff len) {
+ // precondition : there is a valid mapping at the moment
+ if (base != NULL)
+ UnmapViewOfFile(base);
+ // destroy view handle as well
+ if (_M_view_id != NULL)
+ CloseHandle(_M_view_id);
+ _M_view_id = NULL;
+ (void)len; //unused variable
+}
+
+_STLP_END_NAMESPACE
diff --git a/sources/android/stlport/src/dll_main.cpp b/sources/android/stlport/src/dll_main.cpp
new file mode 100644
index 0000000..faaa721
--- /dev/null
+++ b/sources/android/stlport/src/dll_main.cpp
@@ -0,0 +1,262 @@
+ /*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#define _STLP_EXPOSE_GLOBALS_IMPLEMENTATION
+
+#include "stlport_prefix.h"
+
+#if !defined (_STLP_DEBUG) && ! defined (_STLP_ASSERTIONS)
+# if !defined (__APPLE__) || !defined (__GNUC__) || (__GNUC__ < 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ < 3))
+/* dums: Please if the following code was being uncommented please explain why
+ * as for the moment it only looks like a source of inconsistency in the way
+ * STLport different translation units are compiled.
+ */
+//# define _STLP_ASSERTIONS 1
+# endif
+#endif
+
+#include <utility>
+#include <memory>
+#include <vector>
+#include <set>
+#include <list>
+#include <slist>
+#include <deque>
+#include <hash_map>
+#include <limits>
+#include <string>
+#include <stdexcept>
+#include <bitset>
+#include <locale>
+
+#if defined (__DMC__)
+// for rope static members
+# include <rope>
+#endif
+
+#include <stl/_range_errors.c>
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_NO_EXCEPTION_HEADER) || defined (_STLP_BROKEN_EXCEPTION_CLASS)
+exception::exception() _STLP_NOTHROW {}
+exception::~exception() _STLP_NOTHROW {}
+bad_exception::bad_exception() _STLP_NOTHROW {}
+bad_exception::~bad_exception() _STLP_NOTHROW {}
+const char* exception::what() const _STLP_NOTHROW { return "class exception"; }
+const char* bad_exception::what() const _STLP_NOTHROW { return "class bad_exception"; }
+#endif
+
+#if defined (_STLP_OWN_STDEXCEPT)
+# include <stl/_stdexcept_base.c>
+
+// boris : those are needed to force typeinfo nodes to be created in here only
+logic_error::~logic_error() _STLP_NOTHROW_INHERENTLY {}
+runtime_error::~runtime_error() _STLP_NOTHROW_INHERENTLY {}
+domain_error::~domain_error() _STLP_NOTHROW_INHERENTLY {}
+invalid_argument::~invalid_argument() _STLP_NOTHROW_INHERENTLY {}
+length_error::~length_error() _STLP_NOTHROW_INHERENTLY {}
+out_of_range::~out_of_range() _STLP_NOTHROW_INHERENTLY {}
+range_error::~range_error() _STLP_NOTHROW_INHERENTLY {}
+overflow_error::~overflow_error() _STLP_NOTHROW_INHERENTLY {}
+underflow_error::~underflow_error() _STLP_NOTHROW_INHERENTLY {}
+
+#endif
+
+#if !defined(_STLP_WCE_EVC3)
+# if defined (_STLP_NO_BAD_ALLOC)
+const nothrow_t nothrow /* = {} */;
+# endif
+#endif
+
+#if !defined (_STLP_NO_FORCE_INSTANTIATE)
+
+# if defined (_STLP_DEBUG) || defined (_STLP_ASSERTIONS)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+template class _STLP_CLASS_DECLSPEC __stl_debug_engine<bool>;
+_STLP_MOVE_TO_STD_NAMESPACE
+# endif
+
+template class _STLP_CLASS_DECLSPEC __debug_alloc<__node_alloc>;
+template class _STLP_CLASS_DECLSPEC __debug_alloc<__new_alloc>;
+
+//Export of the types used to represent buckets in the hashtable implementation.
+/*
+ * For the vector class we do not use any MSVC6 workaround even if we export it from
+ * the STLport dynamic libraries because we know what methods are called and none is
+ * a template method. Moreover the exported class is an instanciation of vector with
+ * _Slist_node_base struct that is an internal STLport class that no user should ever
+ * use.
+ */
+# if !defined (_STLP_USE_PTR_SPECIALIZATIONS)
+template class _STLP_CLASS_DECLSPEC allocator<_STLP_PRIV _Slist_node_base*>;
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+template class _STLP_CLASS_DECLSPEC _STLP_alloc_proxy<_Slist_node_base**, _Slist_node_base*,
+ allocator<_Slist_node_base*> >;
+template class _STLP_CLASS_DECLSPEC _Vector_base<_Slist_node_base*,
+ allocator<_Slist_node_base*> >;
+_STLP_MOVE_TO_STD_NAMESPACE
+# endif
+
+# if defined (_STLP_DEBUG)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+template class _STLP_CLASS_DECLSPEC _STLP_NON_DBG_NAME(vector)<_Slist_node_base*,
+ allocator<_Slist_node_base*> >;
+_STLP_MOVE_TO_STD_NAMESPACE
+# endif
+
+template class _STLP_CLASS_DECLSPEC vector<_STLP_PRIV _Slist_node_base*,
+ allocator<_STLP_PRIV _Slist_node_base*> >;
+//End of hashtable bucket types export.
+
+//Export of _Locale_impl facets container:
+# if !defined (_STLP_USE_PTR_SPECIALIZATIONS)
+template class _STLP_CLASS_DECLSPEC allocator<locale::facet*>;
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+template class _STLP_CLASS_DECLSPEC _STLP_alloc_proxy<locale::facet**, locale::facet*, allocator<locale::facet*> >;
+template class _STLP_CLASS_DECLSPEC _Vector_base<locale::facet*, allocator<locale::facet*> >;
+_STLP_MOVE_TO_STD_NAMESPACE
+
+# endif
+# if defined (_STLP_DEBUG)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+# define _STLP_NON_DBG_VECTOR _STLP_NON_DBG_NAME(vector)
+template class _STLP_CLASS_DECLSPEC __construct_checker<_STLP_PRIV _STLP_NON_DBG_VECTOR<locale::facet*, allocator<locale::facet*> > >;
+template class _STLP_CLASS_DECLSPEC _STLP_NON_DBG_VECTOR<locale::facet*, allocator<locale::facet*> >;
+# undef _STLP_NON_DBG_VECTOR
+_STLP_MOVE_TO_STD_NAMESPACE
+# endif
+
+template class _STLP_CLASS_DECLSPEC vector<locale::facet*, allocator<locale::facet*> >;
+//End of export of _Locale_impl facets container.
+
+# if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+template class _STLP_CLASS_DECLSPEC allocator<void*>;
+
+typedef _STLP_PRIV _List_node<void*> _VoidPtr_Node;
+template class _STLP_CLASS_DECLSPEC allocator<_VoidPtr_Node>;
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template class _STLP_CLASS_DECLSPEC _STLP_alloc_proxy<void**, void*, allocator<void*> >;
+template class _STLP_CLASS_DECLSPEC _Vector_base<void*, allocator<void*> >;
+template class _STLP_CLASS_DECLSPEC _STLP_PTR_IMPL_NAME(vector)<void*, allocator<void*> >;
+
+template class _STLP_CLASS_DECLSPEC _List_node<void*>;
+template class _STLP_CLASS_DECLSPEC _STLP_alloc_proxy<_List_node_base, _VoidPtr_Node, allocator<_VoidPtr_Node> >;
+template class _STLP_CLASS_DECLSPEC _List_base<void*, allocator<void*> >;
+template class _STLP_CLASS_DECLSPEC _STLP_PTR_IMPL_NAME(list)<void*, allocator<void*> >;
+
+template class _STLP_CLASS_DECLSPEC _Slist_node<void*>;
+template class _STLP_CLASS_DECLSPEC _STLP_alloc_proxy<_Slist_node_base, _Slist_node<void*>, allocator<_Slist_node<void*> > >;
+template class _STLP_CLASS_DECLSPEC _Slist_base<void*, allocator<void*> >;
+template class _STLP_CLASS_DECLSPEC _STLP_PTR_IMPL_NAME(slist)<void*, allocator<void*> >;
+
+template class _STLP_CLASS_DECLSPEC _STLP_alloc_proxy<size_t, void*, allocator<void*> >;
+template class _STLP_CLASS_DECLSPEC _STLP_alloc_proxy<void***, void**, allocator<void**> >;
+template struct _STLP_CLASS_DECLSPEC _Deque_iterator<void*, _Nonconst_traits<void*> >;
+template class _STLP_CLASS_DECLSPEC _Deque_base<void*, allocator<void*> >;
+template class _STLP_CLASS_DECLSPEC _STLP_PTR_IMPL_NAME(deque)<void*, allocator<void*> >;
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+# endif /* _STLP_USE_PTR_SPECIALIZATIONS */
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template class _STLP_CLASS_DECLSPEC _Rb_global<bool>;
+template class _STLP_CLASS_DECLSPEC _List_global<bool>;
+
+template class _STLP_CLASS_DECLSPEC _Sl_global<bool>;
+template class _STLP_CLASS_DECLSPEC _Stl_prime<bool>;
+
+template class _STLP_CLASS_DECLSPEC _LimG<bool>;
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#endif /* _STLP_NO_FORCE_INSTANTIATE */
+
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_SIGNAL_RUNTIME_COMPATIBILITY)
+extern "C" void _STLP_DECLSPEC _STLP_CALL _STLP_SIGNAL_RUNTIME_COMPATIBILITY() {}
+#endif
+
+#define FORCE_SYMBOL extern
+
+#if defined (_WIN32) && defined (_STLP_USE_DECLSPEC) && !defined (_STLP_USE_STATIC_LIB)
+// stlportmt.cpp : Defines the entry point for the DLL application.
+//
+# undef FORCE_SYMBOL
+# define FORCE_SYMBOL APIENTRY
+
+extern "C" {
+
+BOOL APIENTRY DllMain( HANDLE hModule,
+ DWORD ul_reason_for_call,
+ LPVOID) {
+ switch (ul_reason_for_call) {
+ case DLL_PROCESS_ATTACH:
+ DisableThreadLibraryCalls((HINSTANCE)hModule);
+ case DLL_THREAD_ATTACH:
+ case DLL_THREAD_DETACH:
+ case DLL_PROCESS_DETACH:
+ break;
+ }
+ return TRUE;
+}
+
+} /* extern "C" */
+
+#if !defined (_STLP_MSVC) && !defined (__MINGW32__)
+_STLP_BEGIN_NAMESPACE
+
+static void FORCE_SYMBOL
+force_link() {
+ set<int>::iterator iter;
+ // _M_increment; _M_decrement instantiation
+ ++iter;
+ --iter;
+}
+
+_STLP_END_NAMESPACE
+#endif
+
+#endif /* _WIN32 */
+
+#if defined (__ICL) && (__ICL >= 900) && (_STLP_MSVC_LIB < 1300)
+# undef std
+
+namespace std
+{
+ void _STLP_CALL unexpected() {
+ unexpected_handler hdl;
+ set_unexpected(hdl = set_unexpected((unexpected_handler)0));
+ hdl();
+ }
+}
+#endif
diff --git a/sources/android/stlport/src/facets_byname.cpp b/sources/android/stlport/src/facets_byname.cpp
new file mode 100644
index 0000000..07d1a3d
--- /dev/null
+++ b/sources/android/stlport/src/facets_byname.cpp
@@ -0,0 +1,1057 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#include "stlport_prefix.h"
+
+#include <hash_map>
+#include <vector>
+
+#include <locale>
+#include <istream>
+
+#include <algorithm>
+#include <functional>
+
+#include "c_locale.h"
+#include "locale_impl.h"
+#include "acquire_release.h"
+
+_STLP_BEGIN_NAMESPACE
+
+//----------------------------------------------------------------------
+// ctype_byname<char>
+
+#if defined (__DMC__)
+_STLP_DECLSPEC
+#endif
+ctype_byname<char>::ctype_byname(const char* name, size_t refs)
+ : ctype<char>( 0, false, refs) {
+ if (!name)
+ locale::_M_throw_on_null_name();
+
+ int __err_code;
+ char buf[_Locale_MAX_SIMPLE_NAME];
+ _M_ctype = _STLP_PRIV __acquire_ctype(name, buf, 0, &__err_code);
+ if (!_M_ctype)
+ locale::_M_throw_on_creation_failure(__err_code, name, "ctype");
+
+ _M_init();
+}
+
+void ctype_byname<char>::_M_init() {
+ _M_ctype_table = _M_byname_table;
+
+ // We have to do this, instead of just pointer twiddling, because
+ // ctype_base::mask isn't the same type as _Locale_mask_t.
+ const _Locale_mask_t* p = _Locale_ctype_table(_M_ctype);
+ for (size_t i = 0; i != table_size; ++i) {
+ _M_byname_table[i] = ctype_base::mask(p[i]);
+ }
+}
+
+ctype_byname<char>::~ctype_byname()
+{ _STLP_PRIV __release_ctype(_M_ctype); }
+
+char ctype_byname<char>::do_toupper(char c) const
+{ return (char)_Locale_toupper(_M_ctype, c); }
+
+char ctype_byname<char>::do_tolower(char c) const
+{ return (char)_Locale_tolower(_M_ctype, c); }
+
+const char*
+ctype_byname<char>::do_toupper(char* first, const char* last) const {
+ for ( ; first != last ; ++first)
+ *first = (char)_Locale_toupper(_M_ctype, *first);
+ return last;
+}
+
+const char*
+ctype_byname<char>::do_tolower(char* first, const char* last) const {
+ for ( ; first != last ; ++first)
+ *first = (char)_Locale_tolower(_M_ctype, *first);
+ return last;
+}
+
+
+// Some helper functions used in ctype<>::scan_is and scan_is_not.
+#if !defined (_STLP_NO_WCHAR_T)
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// ctype_byname<wchar_t>
+
+struct _Ctype_byname_w_is_mask : public unary_function<wchar_t, bool> {
+ _Locale_mask_t M;
+ _Locale_ctype* M_ctp;
+
+ _Ctype_byname_w_is_mask(_Locale_mask_t m, _Locale_ctype* c)
+ : M(m), M_ctp(c) {}
+ bool operator()(wchar_t c) const
+ { return _WLocale_ctype(M_ctp, c, M) != 0; }
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#if defined (__DMC__)
+_STLP_DECLSPEC
+#endif
+ctype_byname<wchar_t>::ctype_byname(const char* name, size_t refs)
+ : ctype<wchar_t>(refs) {
+ if (!name)
+ locale::_M_throw_on_null_name();
+
+ int __err_code;
+ char buf[_Locale_MAX_SIMPLE_NAME];
+ _M_ctype = _STLP_PRIV __acquire_ctype(name, buf, 0, &__err_code);
+ if (!_M_ctype)
+ locale::_M_throw_on_creation_failure(__err_code, name, "ctype");
+}
+
+ctype_byname<wchar_t>::~ctype_byname()
+{ _STLP_PRIV __release_ctype(_M_ctype); }
+
+bool ctype_byname<wchar_t>::do_is(ctype_base::mask m, wchar_t c) const
+{ return _WLocale_ctype(_M_ctype, c, (_Locale_mask_t)m) != 0; }
+
+const wchar_t*
+ctype_byname<wchar_t>::do_is(const wchar_t* low, const wchar_t* high,
+ ctype_base::mask * m) const {
+ _Locale_mask_t all_bits = _Locale_mask_t(ctype_base::space |
+ ctype_base::print |
+ ctype_base::cntrl |
+ ctype_base::upper |
+ ctype_base::lower |
+ ctype_base::alpha |
+ ctype_base::digit |
+ ctype_base::punct |
+ ctype_base::xdigit);
+
+ for ( ; low < high; ++low, ++m)
+ *m = ctype_base::mask (_WLocale_ctype(_M_ctype, *low, all_bits));
+ return high;
+}
+
+const wchar_t*
+ctype_byname<wchar_t>
+ ::do_scan_is(ctype_base::mask m, const wchar_t* low, const wchar_t* high) const
+{ return find_if(low, high, _STLP_PRIV _Ctype_byname_w_is_mask(m, _M_ctype)); }
+
+const wchar_t*
+ctype_byname<wchar_t>
+ ::do_scan_not(ctype_base::mask m, const wchar_t* low, const wchar_t* high) const
+{ return find_if(low, high, not1(_STLP_PRIV _Ctype_byname_w_is_mask(m, _M_ctype))); }
+
+wchar_t ctype_byname<wchar_t>::do_toupper(wchar_t c) const
+{ return _WLocale_toupper(_M_ctype, c); }
+
+const wchar_t*
+ctype_byname<wchar_t>::do_toupper(wchar_t* low, const wchar_t* high) const {
+ for ( ; low < high; ++low)
+ *low = _WLocale_toupper(_M_ctype, *low);
+ return high;
+}
+
+wchar_t ctype_byname<wchar_t>::do_tolower(wchar_t c) const
+{ return _WLocale_tolower(_M_ctype, c); }
+
+const wchar_t*
+ctype_byname<wchar_t>::do_tolower(wchar_t* low, const wchar_t* high) const {
+ for ( ; low < high; ++low)
+ *low = _WLocale_tolower(_M_ctype, *low);
+ return high;
+}
+
+#endif /* WCHAR_T */
+
+// collate_byname<char>
+#if defined (__DMC__)
+_STLP_DECLSPEC
+#endif
+collate_byname<char>::collate_byname(const char* name, size_t refs)
+ : collate<char>(refs) {
+ if (!name)
+ locale::_M_throw_on_null_name();
+
+ int __err_code;
+ char buf[_Locale_MAX_SIMPLE_NAME];
+ _M_collate = _STLP_PRIV __acquire_collate(name, buf, 0, &__err_code);
+ if (!_M_collate)
+ locale::_M_throw_on_creation_failure(__err_code, name, "collate");
+}
+
+collate_byname<char>::~collate_byname()
+{ _STLP_PRIV __release_collate(_M_collate); }
+
+int collate_byname<char>::do_compare(const char* __low1,
+ const char* __high1,
+ const char* __low2,
+ const char* __high2) const {
+ return _Locale_strcmp(_M_collate,
+ __low1, __high1 - __low1,
+ __low2, __high2 - __low2);
+}
+
+collate_byname<char>::string_type
+collate_byname<char>::do_transform(const char* low, const char* high) const {
+ if (low == high)
+ return string_type();
+
+ size_t n = _Locale_strxfrm(_M_collate, NULL, 0, low, high - low);
+
+ // NOT PORTABLE. What we're doing relies on internal details of the
+ // string implementation. (Contiguity of string elements and presence
+ // of trailing zero.)
+ string_type buf(n, 0);
+ _Locale_strxfrm(_M_collate, &(*buf.begin()), n + 1, low, high - low);
+ return buf;
+}
+
+
+#if !defined (_STLP_NO_WCHAR_T)
+
+// collate_byname<wchar_t>
+
+#if defined (__DMC__)
+_STLP_DECLSPEC
+#endif
+collate_byname<wchar_t>::collate_byname(const char* name, size_t refs)
+ : collate<wchar_t>(refs) {
+ if (!name)
+ locale::_M_throw_on_null_name();
+
+ int __err_code;
+ char buf[_Locale_MAX_SIMPLE_NAME];
+ _M_collate = _STLP_PRIV __acquire_collate(name, buf, 0, &__err_code);
+ if (!_M_collate)
+ locale::_M_throw_on_creation_failure(__err_code, name, "collate");
+}
+
+collate_byname<wchar_t>::~collate_byname()
+{ _STLP_PRIV __release_collate(_M_collate); }
+
+int collate_byname<wchar_t>::do_compare(const wchar_t* low1,
+ const wchar_t* high1,
+ const wchar_t* low2,
+ const wchar_t* high2) const {
+ return _WLocale_strcmp(_M_collate,
+ low1, high1 - low1,
+ low2, high2 - low2);
+}
+
+collate_byname<wchar_t>::string_type
+collate_byname<wchar_t>::do_transform(const wchar_t* low,
+ const wchar_t* high) const {
+ if (low == high)
+ return string_type();
+
+ size_t n = _WLocale_strxfrm(_M_collate, NULL, 0, low, high - low);
+
+ // NOT PORTABLE. What we're doing relies on internal details of the
+ // string implementation. (Contiguity of string elements and presence
+ // of trailing zero.)
+ string_type buf(n, 0);
+ _WLocale_strxfrm(_M_collate, &(*buf.begin()), n + 1, low, high - low);
+ return buf;
+}
+
+#endif /* _STLP_NO_WCHAR_T */
+
+//----------------------------------------------------------------------
+// codecvt_byname<char>
+
+codecvt_byname<char, char, mbstate_t>
+ ::codecvt_byname(const char* name, size_t refs)
+ : codecvt<char, char, mbstate_t>(refs) {
+ if (!name)
+ locale::_M_throw_on_null_name();
+}
+
+codecvt_byname<char, char, mbstate_t>::~codecvt_byname() {}
+
+
+#if !defined (_STLP_NO_WCHAR_T)
+
+//----------------------------------------------------------------------
+// codecvt_byname<wchar_t>
+codecvt_byname<wchar_t, char, mbstate_t>::codecvt_byname(const char* name, size_t refs)
+ : codecvt<wchar_t, char, mbstate_t>(refs) {
+ if (!name)
+ locale::_M_throw_on_null_name();
+
+ int __err_code;
+ char buf[_Locale_MAX_SIMPLE_NAME];
+ _M_codecvt = _STLP_PRIV __acquire_codecvt(name, buf, 0, &__err_code);
+ if (!_M_codecvt)
+ locale::_M_throw_on_creation_failure(__err_code, name, "ctype");
+}
+
+codecvt_byname<wchar_t, char, mbstate_t>::~codecvt_byname()
+{ _STLP_PRIV __release_codecvt(_M_codecvt); }
+
+codecvt<wchar_t, char, mbstate_t>::result
+codecvt_byname<wchar_t, char, mbstate_t>::do_out(state_type& state,
+ const intern_type* from,
+ const intern_type* from_end,
+ const intern_type*& from_next,
+ extern_type* to,
+ extern_type* to_limit,
+ extern_type*& to_next) const {
+ while (from != from_end && to != to_limit) {
+ size_t chars_stored = _WLocale_wctomb(_M_codecvt,
+ to, to_limit - to, *from,
+ &state);
+ if (chars_stored == (size_t) -1) {
+ from_next = from;
+ to_next = to;
+ return error;
+ }
+ else if (chars_stored == (size_t) -2) {
+ from_next = from;
+ to_next = to;
+ return partial;
+ }
+
+ ++from;
+ to += chars_stored;
+ }
+
+ from_next = from;
+ to_next = to;
+ return ok;
+}
+
+codecvt<wchar_t, char, mbstate_t>::result
+codecvt_byname<wchar_t, char, mbstate_t>::do_in(state_type& state,
+ const extern_type* from,
+ const extern_type* from_end,
+ const extern_type*& from_next,
+ intern_type* to,
+ intern_type* to_end,
+ intern_type*& to_next) const {
+ while (from != from_end && to != to_end) {
+ size_t chars_read = _WLocale_mbtowc(_M_codecvt,
+ to, from, from_end - from,
+ &state);
+ if (chars_read == (size_t) -1) {
+ from_next = from;
+ to_next = to;
+ return error;
+ }
+
+ if (chars_read == (size_t) -2) {
+ from_next = from;
+ to_next = to;
+ return partial;
+ }
+
+ from += chars_read;
+ to++;
+ }
+
+ from_next = from;
+ to_next = to;
+ return ok;
+}
+
+codecvt<wchar_t, char, mbstate_t>::result
+codecvt_byname<wchar_t, char, mbstate_t>::do_unshift(state_type& state,
+ extern_type* to,
+ extern_type* to_limit,
+ extern_type*& to_next) const {
+ to_next = to;
+ size_t result = _WLocale_unshift(_M_codecvt, &state,
+ to, to_limit - to, &to_next);
+ if (result == (size_t) -1)
+ return error;
+ else if (result == (size_t) -2)
+ return partial;
+ else
+# if defined (__ISCPP__)
+ return /*to_next == to ? noconv :*/ ok;
+# else
+ return to_next == to ? noconv : ok;
+# endif
+}
+
+int
+codecvt_byname<wchar_t, char, mbstate_t>::do_encoding() const _STLP_NOTHROW {
+ if (_WLocale_is_stateless(_M_codecvt)) {
+ int max_width = _WLocale_mb_cur_max(_M_codecvt);
+ int min_width = _WLocale_mb_cur_min(_M_codecvt);
+ return min_width == max_width ? min_width : 0;
+ }
+ else
+ return -1;
+}
+
+bool
+codecvt_byname<wchar_t, char, mbstate_t>::do_always_noconv() const _STLP_NOTHROW
+{ return false; }
+
+int
+codecvt_byname<wchar_t, char, mbstate_t>::do_length(state_type& state,
+ const extern_type* from,
+ const extern_type* end,
+ size_t mx) const {
+ size_t __count = 0;
+ while (from != end && mx--) {
+ intern_type __dummy;
+ size_t chars_read = _WLocale_mbtowc(_M_codecvt,
+ &__dummy, from, end - from,
+ &state);
+ if ((chars_read == (size_t) -1) || (chars_read == (size_t) -2)) // error or partial
+ break;
+ __count += chars_read;
+ from += chars_read;
+ }
+ return int(__count);
+}
+
+int
+codecvt_byname<wchar_t, char, mbstate_t>::do_max_length() const _STLP_NOTHROW
+{ return _WLocale_mb_cur_max(_M_codecvt); }
+#endif
+
+// numpunct_byname<char>
+numpunct_byname<char>::numpunct_byname(const char* name, size_t refs)
+: numpunct<char>(refs) {
+ if (!name)
+ locale::_M_throw_on_null_name();
+
+ int __err_code;
+ char buf[_Locale_MAX_SIMPLE_NAME];
+ _M_numeric = _STLP_PRIV __acquire_numeric(name, buf, 0, &__err_code);
+ if (!_M_numeric)
+ locale::_M_throw_on_creation_failure(__err_code, name, "numpunct");
+}
+
+numpunct_byname<char>::~numpunct_byname()
+{ _STLP_PRIV __release_numeric(_M_numeric); }
+
+char numpunct_byname<char>::do_decimal_point() const
+{ return _Locale_decimal_point(_M_numeric); }
+
+char numpunct_byname<char>::do_thousands_sep() const
+{ return _Locale_thousands_sep(_M_numeric); }
+
+string numpunct_byname<char>::do_grouping() const {
+ const char * __grouping = _Locale_grouping(_M_numeric);
+ if (__grouping != NULL && __grouping[0] == CHAR_MAX)
+ __grouping = "";
+ return __grouping;
+}
+
+string numpunct_byname<char>::do_truename() const
+{ return _Locale_true(_M_numeric); }
+
+string numpunct_byname<char>::do_falsename() const
+{ return _Locale_false(_M_numeric); }
+
+//----------------------------------------------------------------------
+// numpunct<wchar_t>
+
+#if !defined (_STLP_NO_WCHAR_T)
+
+// numpunct_byname<wchar_t>
+
+numpunct_byname<wchar_t>::numpunct_byname(const char* name, size_t refs)
+: numpunct<wchar_t>(refs) {
+ if (!name)
+ locale::_M_throw_on_null_name();
+
+ int __err_code;
+ char buf[_Locale_MAX_SIMPLE_NAME];
+ _M_numeric = _STLP_PRIV __acquire_numeric(name, buf, 0, &__err_code);
+ if (!_M_numeric)
+ locale::_M_throw_on_creation_failure(__err_code, name, "numpunct");
+}
+
+numpunct_byname<wchar_t>::~numpunct_byname()
+{ _STLP_PRIV __release_numeric(_M_numeric); }
+
+wchar_t numpunct_byname<wchar_t>::do_decimal_point() const
+{ return _WLocale_decimal_point(_M_numeric); }
+
+wchar_t numpunct_byname<wchar_t>::do_thousands_sep() const
+{ return _WLocale_thousands_sep(_M_numeric); }
+
+string numpunct_byname<wchar_t>::do_grouping() const {
+ const char * __grouping = _Locale_grouping(_M_numeric);
+ if (__grouping != NULL && __grouping[0] == CHAR_MAX)
+ __grouping = "";
+ return __grouping;
+}
+
+wstring numpunct_byname<wchar_t>::do_truename() const {
+ wchar_t buf[16];
+ return _WLocale_true(_M_numeric, _STLP_ARRAY_AND_SIZE(buf));
+}
+
+wstring numpunct_byname<wchar_t>::do_falsename() const {
+ wchar_t buf[16];
+ return _WLocale_false(_M_numeric, _STLP_ARRAY_AND_SIZE(buf));
+}
+
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+static void _Init_monetary_formats(money_base::pattern& pos_format,
+ money_base::pattern& neg_format,
+ _Locale_monetary * monetary) {
+ switch (_Locale_p_sign_posn(monetary)) {
+ case 0: // Parentheses surround the quantity and currency symbol
+ case 1: // The sign string precedes the quantity and currency symbol
+ pos_format.field[0] = (char) money_base::sign;
+ if (_Locale_p_cs_precedes(monetary)) {
+ // 1 if currency symbol precedes a positive value
+ pos_format.field[1] = (char) money_base::symbol;
+ if (_Locale_p_sep_by_space(monetary)) {
+ // a space separates currency symbol from a positive value.
+ pos_format.field[2] = (char) money_base::space;
+ pos_format.field[3] = (char) money_base::value;
+ } else {
+ // a space not separates currency symbol from a positive value.
+ pos_format.field[2] = (char) money_base::value;
+ pos_format.field[3] = (char) money_base::none;
+ }
+ } else {
+ // 0 if currency symbol succeeds a positive value
+ pos_format.field[1] = (char) money_base::value;
+ if (_Locale_p_sep_by_space(monetary)) {
+ // a space separates currency symbol from a positive value.
+ pos_format.field[2] = (char) money_base::space;
+ pos_format.field[3] = (char) money_base::symbol;
+ } else {
+ // a space not separates currency symbol from a positive value.
+ pos_format.field[2] = (char) money_base::symbol;
+ pos_format.field[3] = (char) money_base::none;
+ }
+ }
+ break;
+ case 2: // The sign string succeeds the quantity and currency symbol.
+ if (_Locale_p_cs_precedes(monetary)) {
+ // 1 if currency symbol precedes a positive value
+ pos_format.field[0] = (char) money_base::symbol;
+ if (_Locale_p_sep_by_space(monetary)) {
+ // a space separates currency symbol from a positive value.
+ pos_format.field[1] = (char) money_base::space;
+ pos_format.field[2] = (char) money_base::value;
+ pos_format.field[3] = (char) money_base::sign;
+ } else {
+ // a space not separates currency symbol from a positive value.
+ pos_format.field[1] = (char) money_base::value;
+ pos_format.field[2] = (char) money_base::sign;
+ pos_format.field[3] = (char) money_base::none;
+ }
+ } else {
+ // 0 if currency symbol succeeds a positive value
+ pos_format.field[0] = (char) money_base::value;
+ if (_Locale_p_sep_by_space(monetary)) {
+ // a space separates currency symbol from a positive value.
+ pos_format.field[1] = (char) money_base::space;
+ pos_format.field[2] = (char) money_base::symbol;
+ pos_format.field[3] = (char) money_base::sign;
+ } else {
+ // a space not separates currency symbol from a positive value.
+ pos_format.field[1] = (char) money_base::symbol;
+ pos_format.field[2] = (char) money_base::sign;
+ pos_format.field[3] = (char) money_base::none;
+ }
+ }
+ break;
+ case 3: // The sign string immediately precedes the currency symbol.
+ if (_Locale_p_cs_precedes(monetary)) {
+ // 1 if currency symbol precedes a positive value
+ pos_format.field[0] = (char) money_base::sign;
+ pos_format.field[1] = (char) money_base::symbol;
+ if (_Locale_p_sep_by_space(monetary)) {
+ // a space separates currency symbol from a positive value.
+ pos_format.field[2] = (char) money_base::space;
+ pos_format.field[3] = (char) money_base::value;
+ } else {
+ // a space not separates currency symbol from a positive value.
+ pos_format.field[2] = (char) money_base::value;
+ pos_format.field[3] = (char) money_base::none;
+ }
+ } else {
+ // 0 if currency symbol succeeds a positive value
+ pos_format.field[0] = (char) money_base::value;
+ pos_format.field[1] = (char) money_base::sign;
+ pos_format.field[2] = (char) money_base::symbol;
+ pos_format.field[3] = (char) money_base::none;
+ }
+ break;
+ case 4: // The sign string immediately succeeds the currency symbol.
+ if (_Locale_p_cs_precedes(monetary)) {
+ // 1 if currency symbol precedes a positive value
+ pos_format.field[0] = (char) money_base::symbol;
+ pos_format.field[1] = (char) money_base::sign;
+ pos_format.field[2] = (char) money_base::value;
+ pos_format.field[3] = (char) money_base::none;
+ } else {
+ // 0 if currency symbol succeeds a positive value
+ pos_format.field[0] = (char) money_base::value;
+ if (_Locale_p_sep_by_space(monetary)) {
+ // a space separates currency symbol from a positive value.
+ pos_format.field[1] = (char) money_base::space;
+ pos_format.field[2] = (char) money_base::symbol;
+ pos_format.field[3] = (char) money_base::sign;
+ } else {
+ // a space not separates currency symbol from a positive value.
+ pos_format.field[1] = (char) money_base::symbol;
+ pos_format.field[2] = (char) money_base::sign;
+ pos_format.field[3] = (char) money_base::none;
+ }
+ }
+ break;
+ default: // Default C++ Standard format
+ pos_format.field[0] = (char) money_base::symbol;
+ pos_format.field[1] = (char) money_base::sign;
+ pos_format.field[2] = (char) money_base::none;
+ pos_format.field[3] = (char) money_base::value;
+ break;
+ }
+
+ switch (_Locale_n_sign_posn(monetary)) {
+ case 0: // Parentheses surround the quantity and currency symbol
+ case 1: // The sign string precedes the quantity and currency symbol
+ neg_format.field[0] = (char) money_base::sign;
+ if (_Locale_n_cs_precedes(monetary)) {
+ // 1 if currency symbol precedes a negative value
+ neg_format.field[1] = (char) money_base::symbol;
+ if (_Locale_n_sep_by_space(monetary)) {
+ // a space separates currency symbol from a negative value.
+ neg_format.field[2] = (char) money_base::space;
+ neg_format.field[3] = (char) money_base::value;
+ } else {
+ // a space not separates currency symbol from a negative value.
+ neg_format.field[2] = (char) money_base::value;
+ neg_format.field[3] = (char) money_base::none;
+ }
+ } else {
+ // 0 if currency symbol succeeds a negative value
+ neg_format.field[1] = (char) money_base::value;
+ if (_Locale_n_sep_by_space(monetary)) {
+ // a space separates currency symbol from a negative value.
+ neg_format.field[2] = (char) money_base::space;
+ neg_format.field[3] = (char) money_base::symbol;
+ } else {
+ // a space not separates currency symbol from a negative value.
+ neg_format.field[2] = (char) money_base::symbol;
+ neg_format.field[3] = (char) money_base::none;
+ }
+ }
+ break;
+ case 2: // The sign string succeeds the quantity and currency symbol.
+ if (_Locale_n_cs_precedes(monetary)) {
+ // 1 if currency symbol precedes a negative value
+ neg_format.field[0] = (char) money_base::symbol;
+ if (_Locale_n_sep_by_space(monetary)) {
+ // a space separates currency symbol from a negative value.
+ neg_format.field[1] = (char) money_base::space;
+ neg_format.field[2] = (char) money_base::value;
+ neg_format.field[3] = (char) money_base::sign;
+ } else {
+ // a space not separates currency symbol from a negative value.
+ neg_format.field[1] = (char) money_base::value;
+ neg_format.field[2] = (char) money_base::sign;
+ neg_format.field[3] = (char) money_base::none;
+ }
+ } else {
+ // 0 if currency symbol succeeds a negative value
+ neg_format.field[0] = (char) money_base::value;
+ if (_Locale_n_sep_by_space(monetary)) {
+ // a space separates currency symbol from a negative value.
+ neg_format.field[1] = (char) money_base::space;
+ neg_format.field[2] = (char) money_base::symbol;
+ neg_format.field[3] = (char) money_base::sign;
+ } else {
+ // a space not separates currency symbol from a negative value.
+ neg_format.field[1] = (char) money_base::symbol;
+ neg_format.field[2] = (char) money_base::sign;
+ neg_format.field[3] = (char) money_base::none;
+ }
+ }
+ break;
+ case 3: // The sign string immediately precedes the currency symbol.
+ if (_Locale_n_cs_precedes(monetary)) {
+ // 1 if currency symbol precedes a negative value
+ neg_format.field[0] = (char) money_base::sign;
+ neg_format.field[1] = (char) money_base::symbol;
+ if (_Locale_n_sep_by_space(monetary)) {
+ // a space separates currency symbol from a negative value.
+ neg_format.field[2] = (char) money_base::space;
+ neg_format.field[3] = (char) money_base::value;
+ } else {
+ // a space not separates currency symbol from a negative value.
+ neg_format.field[2] = (char) money_base::value;
+ neg_format.field[3] = (char) money_base::none;
+ }
+ } else {
+ // 0 if currency symbol succeeds a negative value
+ neg_format.field[0] = (char) money_base::value;
+ neg_format.field[1] = (char) money_base::sign;
+ neg_format.field[2] = (char) money_base::symbol;
+ neg_format.field[3] = (char) money_base::none;
+ }
+ break;
+ case 4: // The sign string immediately succeeds the currency symbol.
+ if (_Locale_n_cs_precedes(monetary)) {
+ // 1 if currency symbol precedes a negative value
+ neg_format.field[0] = (char) money_base::symbol;
+ neg_format.field[1] = (char) money_base::sign;
+ neg_format.field[2] = (char) money_base::none;
+ neg_format.field[3] = (char) money_base::value;
+ } else {
+ // 0 if currency symbol succeeds a negative value
+ neg_format.field[0] = (char) money_base::value;
+ if (_Locale_n_sep_by_space(monetary)) {
+ // a space separates currency symbol from a negative value.
+ neg_format.field[1] = (char) money_base::space;
+ neg_format.field[2] = (char) money_base::symbol;
+ neg_format.field[3] = (char) money_base::sign;
+ } else {
+ // a space not separates currency symbol from a negative value.
+ neg_format.field[1] = (char) money_base::symbol;
+ neg_format.field[2] = (char) money_base::sign;
+ neg_format.field[3] = (char) money_base::none;
+ }
+ }
+ break;
+ default: // Default C++ Standard format
+ neg_format.field[0] = (char) money_base::symbol;
+ neg_format.field[1] = (char) money_base::sign;
+ neg_format.field[2] = (char) money_base::none;
+ neg_format.field[3] = (char) money_base::value;
+ break;
+ }
+}
+
+// international variant of monetary
+
+/*
+ * int_curr_symbol
+ *
+ * The international currency symbol. The operand is a four-character
+ * string, with the first three characters containing the alphabetic
+ * international currency symbol in accordance with those specified
+ * in the ISO 4217 specification. The fourth character is the character used
+ * to separate the international currency symbol from the monetary quantity.
+ *
+ * (http://www.opengroup.org/onlinepubs/7990989775/xbd/locale.html)
+ */
+
+/*
+ * Standards are unclear in the usage of international currency
+ * and monetary formats.
+ * But I am expect that international currency symbol should be the first
+ * (not depends upon where currency symbol situated in the national
+ * format).
+ *
+ * If this isn't so, let's see:
+ * 1 234.56 RUR
+ * GBP 1,234.56
+ * USD 1,234.56
+ * The situation really is worse than you see above:
+ * RUR typed wrong here---it prints '1 234.56 RUR ' (see space after RUR).
+ * This is due to intl_fmp.curr_symbol() == "RUR ". (see reference in comments
+ * above).
+ *
+ */
+
+static void _Init_monetary_formats_int(money_base::pattern& pos_format,
+ money_base::pattern& neg_format,
+ _Locale_monetary * monetary)
+{
+
+ switch (_Locale_p_sign_posn(monetary)) {
+ case 0: // Parentheses surround the quantity and currency symbol
+ case 1: // The sign string precedes the quantity and currency symbol
+ pos_format.field[0] = (char) money_base::symbol;
+ pos_format.field[1] = (char) money_base::sign;
+ pos_format.field[2] = (char) money_base::value;
+ pos_format.field[3] = (char) money_base::none;
+ break;
+ case 2: // The sign string succeeds the quantity and currency symbol.
+ pos_format.field[0] = (char) money_base::symbol;
+ pos_format.field[1] = (char) money_base::value;
+ pos_format.field[2] = (char) money_base::sign;
+ pos_format.field[3] = (char) money_base::none;
+ break;
+ case 3: // The sign string immediately precedes the currency symbol.
+ case 4: // The sign string immediately succeeds the currency symbol.
+ pos_format.field[0] = (char) money_base::symbol;
+ if (_Locale_p_cs_precedes(monetary)) {
+ // 1 if currency symbol precedes a positive value
+ pos_format.field[1] = (char) money_base::sign;
+ pos_format.field[2] = (char) money_base::value;
+ } else {
+ // 0 if currency symbol succeeds a positive value
+ pos_format.field[1] = (char) money_base::value;
+ pos_format.field[2] = (char) money_base::sign;
+ }
+ pos_format.field[3] = (char) money_base::none;
+ break;
+ default: // Default C++ Standard format
+ pos_format.field[0] = (char) money_base::symbol;
+ pos_format.field[1] = (char) money_base::sign;
+ pos_format.field[2] = (char) money_base::none;
+ pos_format.field[3] = (char) money_base::value;
+ break;
+ }
+
+
+ switch (_Locale_n_sign_posn(monetary)) {
+ case 0: // Parentheses surround the quantity and currency symbol
+ case 1: // The sign string precedes the quantity and currency symbol
+ neg_format.field[0] = (char) money_base::symbol;
+ neg_format.field[1] = (char) money_base::sign;
+ neg_format.field[2] = (char) money_base::value;
+ neg_format.field[3] = (char) money_base::none;
+ break;
+ case 2: // The sign string succeeds the quantity and currency symbol.
+ neg_format.field[0] = (char) money_base::symbol;
+ neg_format.field[1] = (char) money_base::value;
+ neg_format.field[2] = (char) money_base::sign;
+ neg_format.field[3] = (char) money_base::none;
+ break;
+ case 3: // The sign string immediately precedes the currency symbol.
+ case 4: // The sign string immediately succeeds the currency symbol.
+ neg_format.field[0] = (char) money_base::symbol;
+ if (_Locale_n_cs_precedes(monetary)) {
+ // 1 if currency symbol precedes a negative value
+ neg_format.field[1] = (char) money_base::sign;
+ neg_format.field[2] = (char) money_base::value;
+ } else {
+ // 0 if currency symbol succeeds a negative value
+ neg_format.field[1] = (char) money_base::value;
+ neg_format.field[2] = (char) money_base::sign;
+ }
+ neg_format.field[3] = (char) money_base::none;
+ break;
+ default: // Default C++ Standard format
+ neg_format.field[0] = (char) money_base::symbol;
+ neg_format.field[1] = (char) money_base::sign;
+ neg_format.field[2] = (char) money_base::none;
+ neg_format.field[3] = (char) money_base::value;
+ break;
+ }
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+//
+// moneypunct_byname<>
+//
+moneypunct_byname<char, true>::moneypunct_byname(const char * name,
+ size_t refs)
+ : moneypunct<char, true>(refs) {
+ if (!name)
+ locale::_M_throw_on_null_name();
+
+ int __err_code;
+ char buf[_Locale_MAX_SIMPLE_NAME];
+ _M_monetary = _STLP_PRIV __acquire_monetary(name, buf, 0, &__err_code);
+ if (!_M_monetary)
+ locale::_M_throw_on_creation_failure(__err_code, name, "moneypunct");
+
+ _STLP_PRIV _Init_monetary_formats_int(_M_pos_format, _M_neg_format, _M_monetary);
+}
+
+moneypunct_byname<char, true>::moneypunct_byname(_Locale_monetary *__mon)
+ : _M_monetary(__mon) {
+ _STLP_PRIV _Init_monetary_formats_int(_M_pos_format, _M_neg_format, _M_monetary);
+}
+
+moneypunct_byname<char, true>::~moneypunct_byname()
+{ _STLP_PRIV __release_monetary(_M_monetary); }
+
+char moneypunct_byname<char, true>::do_decimal_point() const
+{ return _Locale_mon_decimal_point(_M_monetary); }
+
+char moneypunct_byname<char, true>::do_thousands_sep() const
+{ return _Locale_mon_thousands_sep(_M_monetary); }
+
+string moneypunct_byname<char, true>::do_grouping() const
+{ return _Locale_mon_grouping(_M_monetary); }
+
+string moneypunct_byname<char, true>::do_curr_symbol() const
+{ return _Locale_int_curr_symbol(_M_monetary); }
+
+string moneypunct_byname<char, true>::do_positive_sign() const
+{ return _Locale_positive_sign(_M_monetary); }
+
+string moneypunct_byname<char, true>::do_negative_sign() const
+{ return _Locale_negative_sign(_M_monetary); }
+
+int moneypunct_byname<char, true>::do_frac_digits() const
+{ return _Locale_int_frac_digits(_M_monetary); }
+
+moneypunct_byname<char, false>::moneypunct_byname(const char * name,
+ size_t refs)
+ : moneypunct<char, false>(refs) {
+ if (!name)
+ locale::_M_throw_on_null_name();
+
+ int __err_code;
+ char buf[_Locale_MAX_SIMPLE_NAME];
+ _M_monetary = _STLP_PRIV __acquire_monetary(name, buf, 0, &__err_code);
+ if (!_M_monetary)
+ locale::_M_throw_on_creation_failure(__err_code, name, "moneypunct");
+
+ _STLP_PRIV _Init_monetary_formats(_M_pos_format, _M_neg_format, _M_monetary);
+}
+
+moneypunct_byname<char, false>::moneypunct_byname(_Locale_monetary *__mon)
+ : _M_monetary(__mon) {
+ _STLP_PRIV _Init_monetary_formats(_M_pos_format, _M_neg_format, _M_monetary);
+}
+
+moneypunct_byname<char, false>::~moneypunct_byname()
+{ _STLP_PRIV __release_monetary(_M_monetary); }
+
+char moneypunct_byname<char, false>::do_decimal_point() const
+{ return _Locale_mon_decimal_point(_M_monetary); }
+
+char moneypunct_byname<char, false>::do_thousands_sep() const
+{ return _Locale_mon_thousands_sep(_M_monetary); }
+
+string moneypunct_byname<char, false>::do_grouping() const
+{ return _Locale_mon_grouping(_M_monetary); }
+
+string moneypunct_byname<char, false>::do_curr_symbol() const
+{ return _Locale_currency_symbol(_M_monetary); }
+
+string moneypunct_byname<char, false>::do_positive_sign() const
+{ return _Locale_positive_sign(_M_monetary); }
+
+string moneypunct_byname<char, false>::do_negative_sign() const
+{ return _Locale_negative_sign(_M_monetary); }
+
+int moneypunct_byname<char, false>::do_frac_digits() const
+{ return _Locale_frac_digits(_M_monetary); }
+
+//
+// moneypunct_byname<wchar_t>
+//
+#if !defined (_STLP_NO_WCHAR_T)
+
+moneypunct_byname<wchar_t, true>::moneypunct_byname(const char * name,
+ size_t refs)
+ : moneypunct<wchar_t, true>(refs) {
+ if (!name)
+ locale::_M_throw_on_null_name();
+
+ int __err_code;
+ char buf[_Locale_MAX_SIMPLE_NAME];
+ _M_monetary = _STLP_PRIV __acquire_monetary(name, buf, 0, &__err_code);
+ if (!_M_monetary)
+ locale::_M_throw_on_creation_failure(__err_code, name, "moneypunct");
+
+ _STLP_PRIV _Init_monetary_formats_int(_M_pos_format, _M_neg_format, _M_monetary);
+}
+
+moneypunct_byname<wchar_t, true>::moneypunct_byname(_Locale_monetary *__mon)
+ : _M_monetary(__mon) {
+ _STLP_PRIV _Init_monetary_formats_int(_M_pos_format, _M_neg_format, _M_monetary);
+}
+
+moneypunct_byname<wchar_t, true>::~moneypunct_byname()
+{ _STLP_PRIV __release_monetary(_M_monetary); }
+
+wchar_t moneypunct_byname<wchar_t, true>::do_decimal_point() const
+{ return _Locale_mon_decimal_point(_M_monetary); }
+
+wchar_t moneypunct_byname<wchar_t, true>::do_thousands_sep() const
+{ return _Locale_mon_thousands_sep(_M_monetary); }
+
+string moneypunct_byname<wchar_t, true>::do_grouping() const
+{ return _Locale_mon_grouping(_M_monetary); }
+
+inline wstring __do_widen (string const& str) {
+#if defined (_STLP_NO_MEMBER_TEMPLATES) || defined (_STLP_MSVC)
+ wstring::_Reserve_t __Reserve;
+ size_t __size = str.size();
+ wstring result(__Reserve, __size);
+ copy(str.begin(), str.end(), result.begin());
+#else
+ wstring result(str.begin(), str.end());
+#endif
+ return result;
+}
+
+wstring moneypunct_byname<wchar_t, true>::do_curr_symbol() const
+{ wchar_t buf[16]; return _WLocale_int_curr_symbol(_M_monetary, _STLP_ARRAY_AND_SIZE(buf)); }
+
+wstring moneypunct_byname<wchar_t, true>::do_positive_sign() const
+{ wchar_t buf[16]; return _WLocale_positive_sign(_M_monetary, _STLP_ARRAY_AND_SIZE(buf)); }
+
+wstring moneypunct_byname<wchar_t, true>::do_negative_sign() const
+{ wchar_t buf[16]; return _WLocale_negative_sign(_M_monetary, _STLP_ARRAY_AND_SIZE(buf)); }
+
+int moneypunct_byname<wchar_t, true>::do_frac_digits() const
+{ return _Locale_int_frac_digits(_M_monetary); }
+
+moneypunct_byname<wchar_t, false>::moneypunct_byname(const char * name,
+ size_t refs)
+ : moneypunct<wchar_t, false>(refs) {
+ if (!name)
+ locale::_M_throw_on_null_name() ;
+
+ int __err_code;
+ char buf[_Locale_MAX_SIMPLE_NAME];
+ _M_monetary = _STLP_PRIV __acquire_monetary(name, buf, 0, &__err_code);
+ if (!_M_monetary)
+ locale::_M_throw_on_creation_failure(__err_code, name, "moneypunct");
+
+ _STLP_PRIV _Init_monetary_formats(_M_pos_format, _M_neg_format, _M_monetary);
+}
+
+moneypunct_byname<wchar_t, false>::moneypunct_byname(_Locale_monetary *__mon)
+ : _M_monetary(__mon) {
+ _STLP_PRIV _Init_monetary_formats(_M_pos_format, _M_neg_format, _M_monetary);
+}
+
+moneypunct_byname<wchar_t, false>::~moneypunct_byname()
+{ _STLP_PRIV __release_monetary(_M_monetary); }
+
+wchar_t moneypunct_byname<wchar_t, false>::do_decimal_point() const
+{ return _Locale_mon_decimal_point(_M_monetary); }
+
+wchar_t moneypunct_byname<wchar_t, false>::do_thousands_sep() const
+{ return _Locale_mon_thousands_sep(_M_monetary); }
+
+string moneypunct_byname<wchar_t, false>::do_grouping() const
+{ return _Locale_mon_grouping(_M_monetary); }
+
+wstring moneypunct_byname<wchar_t, false>::do_curr_symbol() const
+{ wchar_t buf[16]; return _WLocale_currency_symbol(_M_monetary, _STLP_ARRAY_AND_SIZE(buf)); }
+
+wstring moneypunct_byname<wchar_t, false>::do_positive_sign() const
+{ wchar_t buf[16]; return _WLocale_positive_sign(_M_monetary, _STLP_ARRAY_AND_SIZE(buf)); }
+
+wstring moneypunct_byname<wchar_t, false>::do_negative_sign() const
+{ wchar_t buf[16]; return _WLocale_negative_sign(_M_monetary, _STLP_ARRAY_AND_SIZE(buf)); }
+
+int moneypunct_byname<wchar_t, false>::do_frac_digits() const
+{ return _Locale_frac_digits(_M_monetary); }
+
+#endif
+
+_STLP_END_NAMESPACE
+
diff --git a/sources/android/stlport/src/fstream.cpp b/sources/android/stlport/src/fstream.cpp
new file mode 100644
index 0000000..81543bb
--- /dev/null
+++ b/sources/android/stlport/src/fstream.cpp
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#include "stlport_prefix.h"
+
+#ifdef _STLP_USE_UNIX_IO
+# include "details/fstream_unistd.cpp"
+#elif defined(_STLP_USE_STDIO_IO)
+# include "details/fstream_stdio.cpp"
+#elif defined(_STLP_USE_WIN32_IO)
+# include "details/fstream_win32io.cpp"
+#else
+# error "Can't recognize IO scheme to use"
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+// fbp : let us map 1 MB maximum, just be sure not to trash VM
+#define MMAP_CHUNK 0x100000L
+
+_Underflow< char, char_traits<char> >::int_type _STLP_CALL
+_Underflow< char, char_traits<char> >::_M_doit(basic_filebuf<char, char_traits<char> >* __this)
+{
+ typedef char_traits<char> traits_type;
+ typedef traits_type::int_type int_type;
+
+ if (!__this->_M_in_input_mode) {
+ if (!__this->_M_switch_to_input_mode())
+ return traits_type::eof();
+ }
+ else if (__this->_M_in_putback_mode) {
+ __this->_M_exit_putback_mode();
+ if (__this->gptr() != __this->egptr()) {
+ int_type __c = traits_type::to_int_type(*__this->gptr());
+ return __c;
+ }
+ }
+
+ // If it's a disk file, and if the internal and external character
+ // sequences are guaranteed to be identical, then try to use memory
+ // mapped I/O. Otherwise, revert to ordinary read.
+ if (__this->_M_base.__regular_file()
+ && __this->_M_always_noconv
+ && __this->_M_base._M_in_binary_mode()) {
+ // If we've mmapped part of the file already, then unmap it.
+ if (__this->_M_mmap_base)
+ __this->_M_base._M_unmap(__this->_M_mmap_base, __this->_M_mmap_len);
+
+ // Determine the position where we start mapping. It has to be
+ // a multiple of the page size.
+ streamoff __cur = __this->_M_base._M_seek(0, ios_base::cur);
+ streamoff __size = __this->_M_base._M_file_size();
+ if (__size > 0 && __cur >= 0 && __cur < __size) {
+ streamoff __offset = (__cur / __this->_M_base.__page_size()) * __this->_M_base.__page_size();
+ streamoff __remainder = __cur - __offset;
+
+ __this->_M_mmap_len = __size - __offset;
+
+ if (__this->_M_mmap_len > MMAP_CHUNK)
+ __this->_M_mmap_len = MMAP_CHUNK;
+
+ if ((__this->_M_mmap_base = __this->_M_base._M_mmap(__offset, __this->_M_mmap_len)) != 0) {
+ __this->setg(__STATIC_CAST(char*, __this->_M_mmap_base),
+ __STATIC_CAST(char*, __this->_M_mmap_base) + __STATIC_CAST(ptrdiff_t, __remainder),
+ __STATIC_CAST(char*, __this->_M_mmap_base) + __STATIC_CAST(ptrdiff_t, __this->_M_mmap_len));
+ return traits_type::to_int_type(*__this->gptr());
+ }
+ else
+ __this->_M_mmap_len = 0;
+ }
+ else {
+ __this->_M_mmap_base = 0;
+ __this->_M_mmap_len = 0;
+ }
+ }
+
+ return __this->_M_underflow_aux();
+}
+
+//----------------------------------------------------------------------
+// Force instantiation of filebuf and fstream classes.
+#if !defined(_STLP_NO_FORCE_INSTANTIATE)
+
+template class basic_filebuf<char, char_traits<char> >;
+template class basic_ifstream<char, char_traits<char> >;
+template class basic_ofstream<char, char_traits<char> >;
+template class basic_fstream<char, char_traits<char> >;
+
+# if !defined (_STLP_NO_WCHAR_T)
+template class _Underflow<wchar_t, char_traits<wchar_t> >;
+template class basic_filebuf<wchar_t, char_traits<wchar_t> >;
+template class basic_ifstream<wchar_t, char_traits<wchar_t> >;
+template class basic_ofstream<wchar_t, char_traits<wchar_t> >;
+template class basic_fstream<wchar_t, char_traits<wchar_t> >;
+# endif /* _STLP_NO_WCHAR_T */
+
+#endif
+
+_STLP_END_NAMESPACE
diff --git a/sources/android/stlport/src/ios.cpp b/sources/android/stlport/src/ios.cpp
new file mode 100644
index 0000000..cb35e0b
--- /dev/null
+++ b/sources/android/stlport/src/ios.cpp
@@ -0,0 +1,318 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#include "stlport_prefix.h"
+
+#include <algorithm>
+#include <ios>
+#include <locale>
+#include <ostream> // for __get_ostreambuf definition
+
+#include "aligned_buffer.h"
+
+_STLP_BEGIN_NAMESPACE
+
+//----------------------------------------------------------------------
+// ios_base members
+
+// class ios_base::failure, a subclass of exception. It's used solely
+// for reporting errors.
+
+ios_base::failure::failure(const string& s)
+ : __Named_exception(s)
+{}
+
+ios_base::failure::~failure() _STLP_NOTHROW_INHERENTLY {}
+
+#if !defined (_STLP_STATIC_CONST_INIT_BUG) && !defined (_STLP_NO_STATIC_CONST_DEFINITION)
+// Definitions of ios_base's formatting flags.
+const ios_base::fmtflags ios_base::left;
+const ios_base::fmtflags ios_base::right;
+const ios_base::fmtflags ios_base::internal;
+const ios_base::fmtflags ios_base::dec;
+const ios_base::fmtflags ios_base::hex;
+const ios_base::fmtflags ios_base::oct;
+const ios_base::fmtflags ios_base::fixed;
+const ios_base::fmtflags ios_base::scientific;
+const ios_base::fmtflags ios_base::boolalpha;
+const ios_base::fmtflags ios_base::showbase;
+const ios_base::fmtflags ios_base::showpoint;
+const ios_base::fmtflags ios_base::showpos;
+const ios_base::fmtflags ios_base::skipws;
+const ios_base::fmtflags ios_base::unitbuf;
+const ios_base::fmtflags ios_base::uppercase;
+const ios_base::fmtflags ios_base::adjustfield;
+const ios_base::fmtflags ios_base::basefield;
+const ios_base::fmtflags ios_base::floatfield;
+
+// Definitions of ios_base's state flags.
+const ios_base::iostate ios_base::goodbit;
+const ios_base::iostate ios_base::badbit;
+const ios_base::iostate ios_base::eofbit;
+const ios_base::iostate ios_base::failbit;
+
+// Definitions of ios_base's openmode flags.
+const ios_base::openmode ios_base::app;
+const ios_base::openmode ios_base::ate;
+const ios_base::openmode ios_base::binary;
+const ios_base::openmode ios_base::in;
+const ios_base::openmode ios_base::out;
+const ios_base::openmode ios_base::trunc;
+
+// Definitions of ios_base's seekdir flags.
+const ios_base::seekdir ios_base::beg;
+const ios_base::seekdir ios_base::cur;
+const ios_base::seekdir ios_base::end;
+
+#endif
+
+// Internal functions used for managing exponentially-growing arrays of
+// POD types.
+
+// array is a pointer to N elements of type PODType. Expands the array,
+// if necessary, so that array[index] is meaningful. All new elements are
+// initialized to zero. Returns a pointer to the new array, and the new
+// size.
+
+template <class PODType>
+static pair<PODType*, size_t>
+_Stl_expand_array(PODType* __array, size_t N, int index) {
+ if ((int)N < index + 1) {
+ size_t new_N = (max)(2 * N, size_t(index + 1));
+ PODType* new_array
+ = __STATIC_CAST(PODType*,realloc(__array, new_N * sizeof(PODType)));
+ if (new_array) {
+ fill(new_array + N, new_array + new_N, PODType());
+ return pair<PODType*, size_t>(new_array, new_N);
+ }
+ else
+ return pair<PODType*, size_t>(__STATIC_CAST(PODType*,0), 0);
+ }
+ else
+ return pair<PODType*, size_t>(__array, N);
+}
+
+// array is a pointer to N elements of type PODType. Allocate a new
+// array of N elements, copying the values from the old array to the new.
+// Return a pointer to the new array. It is assumed that array is non-null
+// and N is nonzero.
+template <class PODType>
+static PODType* _Stl_copy_array(const PODType* __array, size_t N) {
+ PODType* result = __STATIC_CAST(PODType*,malloc(N * sizeof(PODType)));
+ if (result)
+ copy(__array, __array + N, result);
+ return result;
+}
+
+locale ios_base::imbue(const locale& loc) {
+ if (loc != _M_locale) {
+ locale previous = _M_locale;
+ _M_locale = loc;
+ _M_invoke_callbacks(imbue_event);
+ return previous;
+ }
+ else {
+ _M_invoke_callbacks(imbue_event);
+ return _M_locale;
+ }
+}
+
+int _STLP_CALL ios_base::xalloc() {
+#if defined (_STLP_THREADS) && \
+ defined (_STLP_WIN32THREADS) && defined (_STLP_NEW_PLATFORM_SDK)
+ static volatile __stl_atomic_t _S_index = 0;
+ return _STLP_ATOMIC_INCREMENT(&_S_index);
+#else
+ static int _S_index = 0;
+ static _STLP_STATIC_MUTEX __lock _STLP_MUTEX_INITIALIZER;
+ _STLP_auto_lock sentry(__lock);
+ return _S_index++;
+#endif
+}
+
+long& ios_base::iword(int index) {
+ static long dummy = 0;
+
+ pair<long*, size_t> tmp = _Stl_expand_array(_M_iwords, _M_num_iwords, index);
+ if (tmp.first) { // The allocation, if any, succeeded.
+ _M_iwords = tmp.first;
+ _M_num_iwords = tmp.second;
+ return _M_iwords[index];
+ }
+ else {
+ _M_setstate_nothrow(badbit);
+ _M_check_exception_mask();
+ return dummy;
+ }
+}
+
+
+void*& ios_base::pword(int index) {
+ static void* dummy = 0;
+
+ pair<void**, size_t> tmp = _Stl_expand_array(_M_pwords, _M_num_pwords, index);
+ if (tmp.first) { // The allocation, if any, succeeded.
+ _M_pwords = tmp.first;
+ _M_num_pwords = tmp.second;
+ return _M_pwords[index];
+ }
+ else {
+ _M_setstate_nothrow(badbit);
+ _M_check_exception_mask();
+ return dummy;
+ }
+}
+
+void ios_base::register_callback(event_callback __fn, int index) {
+ pair<pair<event_callback, int>*, size_t> tmp
+ = _Stl_expand_array(_M_callbacks, _M_num_callbacks, (int)_M_callback_index /* fbp: index ??? */ );
+ if (tmp.first) {
+ _M_callbacks = tmp.first;
+ _M_num_callbacks = tmp.second;
+ _M_callbacks[_M_callback_index++] = make_pair(__fn, index);
+ }
+ else {
+ _M_setstate_nothrow(badbit);
+ _M_check_exception_mask();
+ }
+}
+
+// Invokes all currently registered callbacks for a particular event.
+// Behaves correctly even if one of the callbacks adds a new callback.
+void ios_base::_M_invoke_callbacks(event E) {
+ for (size_t i = _M_callback_index; i > 0; --i) {
+ event_callback f = _M_callbacks[i-1].first;
+ int n = _M_callbacks[i-1].second;
+ f(E, *this, n);
+ }
+}
+
+// This function is called if the state, rdstate(), has a bit set
+// that is also set in the exception mask exceptions().
+void ios_base::_M_throw_failure() {
+ const char* arg ;
+# if 0
+ char buffer[256];
+ char* ptr;
+ strcpy(buffer, "ios failure: rdstate = 0x");
+ ptr = __write_integer(buffer+strlen(buffer), ios_base::hex, __STATIC_CAST(unsigned long,_M_iostate));
+ strcpy(ptr, " mask = 0x");
+ ptr = __write_integer(buffer+strlen(buffer), ios_base::hex, __STATIC_CAST(unsigned long,_M_exception_mask));
+ *ptr = 0;
+ arg = buffer;
+# else
+ arg = "ios failure";
+# endif
+
+# ifndef _STLP_USE_EXCEPTIONS
+ fputs(arg, stderr);
+# else
+ throw failure(arg);
+# endif
+}
+
+// Copy x's state to *this. This member function is used in the
+// implementation of basic_ios::copyfmt. Does not copy _M_exception_mask
+// or _M_iostate.
+void ios_base::_M_copy_state(const ios_base& x) {
+ _M_fmtflags = x._M_fmtflags; // Copy the flags, except for _M_iostate
+ _M_openmode = x._M_openmode; // and _M_exception_mask.
+ _M_seekdir = x._M_seekdir;
+ _M_precision = x._M_precision;
+ _M_width = x._M_width;
+ _M_locale = x._M_locale;
+
+ if (x._M_callbacks) {
+ pair<event_callback, int>* tmp = _Stl_copy_array(x._M_callbacks, x._M_callback_index);
+ if (tmp) {
+ free(_M_callbacks);
+ _M_callbacks = tmp;
+ _M_num_callbacks = _M_callback_index = x._M_callback_index;
+ }
+ else {
+ _M_setstate_nothrow(badbit);
+ _M_check_exception_mask();
+ }
+ }
+
+ if (x._M_iwords) {
+ long* tmp = _Stl_copy_array(x._M_iwords, x._M_num_iwords);
+ if (tmp) {
+ free(_M_iwords);
+ _M_iwords = tmp;
+ _M_num_iwords = x._M_num_iwords;
+ }
+ else {
+ _M_setstate_nothrow(badbit);
+ _M_check_exception_mask();
+ }
+ }
+
+ if (x._M_pwords) {
+ void** tmp = _Stl_copy_array(x._M_pwords, x._M_num_pwords);
+ if (tmp) {
+ free(_M_pwords);
+ _M_pwords = tmp;
+ _M_num_pwords = x._M_num_pwords;
+ }
+ else {
+ _M_setstate_nothrow(badbit);
+ _M_check_exception_mask();
+ }
+ }
+}
+
+// ios's (protected) default constructor. The standard says that all
+// fields have indeterminate values; we initialize them to zero for
+// simplicity. The only thing that really matters is that the arrays
+// are all initially null pointers, and the array element counts are all
+// initially zero.
+ios_base::ios_base()
+ : _M_fmtflags(0), _M_iostate(0), _M_openmode(0), _M_seekdir(0),
+ _M_exception_mask(0),
+ _M_precision(0), _M_width(0),
+ _M_locale(),
+ _M_callbacks(0), _M_num_callbacks(0), _M_callback_index(0),
+ _M_iwords(0), _M_num_iwords(0),
+ _M_pwords(0),
+ _M_num_pwords(0)
+{}
+
+// ios's destructor.
+ios_base::~ios_base() {
+ _M_invoke_callbacks(erase_event);
+ free(_M_callbacks);
+ free(_M_iwords);
+ free(_M_pwords);
+}
+
+//----------------------------------------------------------------------
+// Force instantiation of basic_ios
+// For DLL exports, they are already instantiated.
+#if !defined(_STLP_NO_FORCE_INSTANTIATE)
+template class _STLP_CLASS_DECLSPEC basic_ios<char, char_traits<char> >;
+# if !defined (_STLP_NO_WCHAR_T)
+template class _STLP_CLASS_DECLSPEC basic_ios<wchar_t, char_traits<wchar_t> >;
+# endif /* _STLP_NO_WCHAR_T */
+#endif
+
+_STLP_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/src/iostream.cpp b/sources/android/stlport/src/iostream.cpp
new file mode 100644
index 0000000..0d3329b
--- /dev/null
+++ b/sources/android/stlport/src/iostream.cpp
@@ -0,0 +1,354 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#include "stlport_prefix.h"
+
+#include <memory>
+#include <istream>
+#include <fstream>
+#if defined (_STLP_MSVC) || defined (__MWERKS__) || defined (__ICL) || defined (__ISCPP__)
+# define _STLP_USE_NOT_INIT_SEGMENT
+# include <iostream>
+#endif
+
+#include "stdio_streambuf.h"
+#include "aligned_buffer.h"
+#include "_stdio_file.h"
+#include "c_locale.h"
+
+// boris : note this is repeated in <iostream>
+#ifndef _STLP_USE_NAMESPACES
+// in case of SGI iostreams, we have to rename our streams not to clash with those
+// provided in native lib
+# define cin _STLP_cin
+# define cout _STLP_cout
+# define cerr _STLP_cerr
+# define clog _STLP_clog
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+// This file handles iostream initialization. It is inherently
+// nonportable, since the C++ language definition provides no mechanism
+// for controlling order of initialization of nonlocal objects.
+// Initialization has three parts, which must be performed in the following
+// order:
+// (1) Initialize the locale system
+// (2) Call the constructors for the eight global stream objects.
+// (3) Create streambufs for the global stream objects, and initialize
+// the stream objects by calling the init() member function.
+
+
+#if defined (_STLP_USE_NOT_INIT_SEGMENT)
+
+// Definitions of the eight global I/O objects that are declared in
+// <iostream>. For some compilers we use pragmas to put the global I/O
+// objects into an initialization segment that will not
+// be executed. We then explicitly invoke the constructors
+// with placement new in ios_base::_S_initialize()
+
+# if defined (__MWERKS__)
+# pragma suppress_init_code on
+# else
+# pragma init_seg("STLPORT_NO_INIT")
+# endif
+
+_STLP_DECLSPEC istream cin(0);
+_STLP_DECLSPEC ostream cout(0);
+_STLP_DECLSPEC ostream cerr(0);
+_STLP_DECLSPEC ostream clog(0);
+
+# ifndef _STLP_NO_WCHAR_T
+_STLP_DECLSPEC wistream wcin(0);
+_STLP_DECLSPEC wostream wcout(0);
+_STLP_DECLSPEC wostream wcerr(0);
+_STLP_DECLSPEC wostream wclog(0);
+# endif
+
+# if defined (__MWERKS__)
+# pragma suppress_init_code off
+# endif
+
+#else
+
+// Definitions of the eight global I/O objects that are declared in
+// <iostream>. Disgusting hack: we deliberately define them with the
+// wrong types so that the constructors don't get run automatically.
+// We need special tricks to make sure that these objects are struct-
+// aligned rather than byte-aligned.
+
+// This is not portable. Declaring a variable with different types in
+// two translations units is "undefined", according to the C++ standard.
+// Most compilers, however, silently accept this instead of diagnosing
+// it as an error.
+
+# ifndef __DMC__
+_STLP_DECLSPEC _Stl_aligned_buffer<istream> cin;
+_STLP_DECLSPEC _Stl_aligned_buffer<ostream> cout;
+_STLP_DECLSPEC _Stl_aligned_buffer<ostream> cerr;
+_STLP_DECLSPEC _Stl_aligned_buffer<ostream> clog;
+# else
+_Stl_aligned_buffer<istream> cin;
+_Stl_aligned_buffer<ostream> cout;
+_Stl_aligned_buffer<ostream> cerr;
+_Stl_aligned_buffer<ostream> clog;
+
+# pragma alias("?cin@std@@3V?$basic_istream@std@DV?$char_traits@std@D@1@@1@A", "?cin@std@@3T?$_Stl_aligned_buffer@std@V?$basic_istream@std@DV?$char_traits@std@D@1@@1@@1@A")
+# pragma alias("?cout@std@@3V?$basic_ostream@std@DV?$char_traits@std@D@1@@1@A", "?cout@std@@3T?$_Stl_aligned_buffer@std@V?$basic_ostream@std@DV?$char_traits@std@D@1@@1@@1@A")
+# pragma alias("?cerr@std@@3V?$basic_ostream@std@DV?$char_traits@std@D@1@@1@A", "?cerr@std@@3T?$_Stl_aligned_buffer@std@V?$basic_ostream@std@DV?$char_traits@std@D@1@@1@@1@A")
+# pragma alias("?clog@std@@3V?$basic_ostream@std@DV?$char_traits@std@D@1@@1@A", "?clog@std@@3T?$_Stl_aligned_buffer@std@V?$basic_ostream@std@DV?$char_traits@std@D@1@@1@@1@A")
+# endif
+
+# ifndef _STLP_NO_WCHAR_T
+
+# ifndef __DMC__
+_STLP_DECLSPEC _Stl_aligned_buffer<wistream> wcin;
+_STLP_DECLSPEC _Stl_aligned_buffer<wostream> wcout;
+_STLP_DECLSPEC _Stl_aligned_buffer<wostream> wcerr;
+_STLP_DECLSPEC _Stl_aligned_buffer<wostream> wclog;
+# else
+_Stl_aligned_buffer<wistream> wcin;
+_Stl_aligned_buffer<wostream> wcout;
+_Stl_aligned_buffer<wostream> wcerr;
+_Stl_aligned_buffer<wostream> wclog;
+
+# pragma alias("?wcin@std@@3V?$basic_istream@std@_YV?$char_traits@std@_Y@1@@1@A", "?wcin@std@@3T?$_Stl_aligned_buffer@std@V?$basic_istream@std@_YV?$char_traits@std@_Y@1@@1@@1@A")
+# pragma alias("?wcout@std@@3V?$basic_ostream@std@_YV?$char_traits@std@_Y@1@@1@A", "?wcout@std@@3T?$_Stl_aligned_buffer@std@V?$basic_ostream@std@_YV?$char_traits@std@_Y@1@@1@@1@A")
+# pragma alias("?wcerr@std@@3V?$basic_ostream@std@_YV?$char_traits@std@_Y@1@@1@A", "?wcerr@std@@3T?$_Stl_aligned_buffer@std@V?$basic_ostream@std@_YV?$char_traits@std@_Y@1@@1@@1@A")
+# pragma alias("?wclog@std@@3V?$basic_ostream@std@_YV?$char_traits@std@_Y@1@@1@A", "?wclog@std@@3T?$_Stl_aligned_buffer@std@V?$basic_ostream@std@_YV?$char_traits@std@_Y@1@@1@@1@A")
+# endif
+# endif
+#endif /* STL_MSVC || __MWERKS__ */
+
+// Member functions from class ios_base and ios_base::Init
+
+long ios_base::Init::_S_count = 0;
+// by default, those are synced
+bool ios_base::_S_is_synced = true;
+
+ios_base::Init::Init() {
+ if (_S_count++ == 0) {
+ _Locale_init();
+ ios_base::_S_initialize();
+ _Filebuf_base::_S_initialize();
+ }
+}
+
+ios_base::Init::~Init() {
+ if (--_S_count == 0) {
+ ios_base::_S_uninitialize();
+ _Locale_final();
+ }
+}
+
+static int _Stl_extract_open_param(FILE* f)
+{ return _FILE_fd(f); }
+
+#ifdef _STLP_REDIRECT_STDSTREAMS
+static const char* _Stl_extract_open_param(const char* name)
+{ return name; }
+#endif
+
+template <class _Tp>
+static filebuf*
+_Stl_create_filebuf(_Tp x, ios_base::openmode mode ) {
+ auto_ptr<filebuf> result(new basic_filebuf<char, char_traits<char> >());
+ result->open(_Stl_extract_open_param(x), mode);
+
+ if (result->is_open())
+ return result.release();
+
+ return 0;
+}
+
+#if !defined (_STLP_NO_WCHAR_T)
+static wfilebuf*
+_Stl_create_wfilebuf(FILE* f, ios_base::openmode mode) {
+ auto_ptr<wfilebuf> result(new basic_filebuf<wchar_t, char_traits<wchar_t> >());
+ result->_M_open(_FILE_fd(f), mode);
+
+ if (result->is_open())
+ return result.release();
+
+ return 0;
+}
+#endif
+
+void _STLP_CALL ios_base::_S_initialize() {
+#if !defined (_STLP_HAS_NO_NAMESPACES) && !defined (_STLP_DONT_USE_PRIV_NAMESPACE)
+ using _STLP_PRIV stdio_istreambuf;
+ using _STLP_PRIV stdio_ostreambuf;
+#endif
+
+ auto_ptr<streambuf> cin_buf;
+ auto_ptr<streambuf> cout_buf;
+ auto_ptr<streambuf> cerr_buf;
+ auto_ptr<streambuf> clog_buf;
+
+ if (_S_is_synced)
+ cin_buf.reset(new stdio_istreambuf(stdin));
+ else
+ cin_buf.reset(_Stl_create_filebuf(stdin, ios_base::in));
+
+ if (_S_is_synced) {
+#ifdef _STLP_REDIRECT_STDSTREAMS
+ cout_buf.reset(_Stl_create_filebuf("/stdout.txt", ios::out));
+ cerr_buf.reset(_Stl_create_filebuf("/stderr.txt", ios::out));
+ clog_buf.reset(_Stl_create_filebuf("/stdlog.txt", ios::out));
+#else
+ cout_buf.reset(new stdio_ostreambuf(stdout));
+ cerr_buf.reset(new stdio_ostreambuf(stderr));
+ clog_buf.reset(new stdio_ostreambuf(stderr));
+#endif
+ }
+ else {
+ cout_buf.reset(_Stl_create_filebuf(stdout, ios_base::out));
+ cerr_buf.reset(_Stl_create_filebuf(stderr, ios_base::out));
+ clog_buf.reset(_Stl_create_filebuf(stderr, ios_base::out));
+ }
+
+ istream* ptr_cin = new(&cin) istream(cin_buf.get()); cin_buf.release();
+ ostream* ptr_cout = new(&cout) ostream(cout_buf.get()); cout_buf.release();
+ ostream* ptr_cerr = new(&cerr) ostream(cerr_buf.get()); cerr_buf.release();
+ /*ostream* ptr_clog = */ new(&clog) ostream(clog_buf.get()); clog_buf.release();
+ ptr_cin->tie(ptr_cout);
+ ptr_cerr->setf(ios_base::unitbuf);
+
+#ifndef _STLP_NO_WCHAR_T
+ auto_ptr<wfilebuf> win(_Stl_create_wfilebuf(stdin, ios_base::in));
+ auto_ptr<wfilebuf> wout(_Stl_create_wfilebuf(stdout, ios_base::out));
+ auto_ptr<wfilebuf> werr(_Stl_create_wfilebuf(stderr, ios_base::out));
+ auto_ptr<wfilebuf> wlog(_Stl_create_wfilebuf(stderr, ios_base::out));
+
+ // Run constructors for the four wide stream objects.
+ wistream* ptr_wcin = new(&wcin) wistream(win.get()); win.release();
+ wostream* ptr_wcout = new(&wcout) wostream(wout.get()); wout.release();
+ wostream* ptr_wcerr = new(&wcerr) wostream(werr.get()); werr.release();
+ /*wostream* ptr_wclog = */ new(&wclog) wostream(wlog.get()); wlog.release();
+
+ ptr_wcin->tie(ptr_wcout);
+ ptr_wcerr->setf(ios_base::unitbuf);
+#endif
+}
+
+void _STLP_CALL ios_base::_S_uninitialize() {
+ // Note that destroying output streambufs flushes the buffers.
+ istream* ptr_cin = &cin;
+ ostream* ptr_cout = &cout;
+ ostream* ptr_cerr = &cerr;
+ ostream* ptr_clog = &clog;
+
+ // We don't want any exceptions being thrown here
+ ptr_cin->exceptions(0);
+ ptr_cout->exceptions(0);
+ ptr_cerr->exceptions(0);
+ ptr_clog->exceptions(0);
+
+ delete ptr_cin->rdbuf(0);
+ delete ptr_cout->rdbuf(0);
+ delete ptr_cerr->rdbuf(0);
+ delete ptr_clog->rdbuf(0);
+
+ _Destroy(ptr_cin);
+ _Destroy(ptr_cout);
+ _Destroy(ptr_cerr);
+ _Destroy(ptr_clog);
+
+#ifndef _STLP_NO_WCHAR_T
+ wistream* ptr_wcin = &wcin;
+ wostream* ptr_wcout = &wcout;
+ wostream* ptr_wcerr = &wcerr;
+ wostream* ptr_wclog = &wclog;
+
+ // We don't want any exceptions being thrown here
+ ptr_wcin->exceptions(0);
+ ptr_wcout->exceptions(0);
+ ptr_wcerr->exceptions(0);
+ ptr_wclog->exceptions(0);
+
+ delete ptr_wcin->rdbuf(0);
+ delete ptr_wcout->rdbuf(0);
+ delete ptr_wcerr->rdbuf(0);
+ delete ptr_wclog->rdbuf(0);
+
+ _Destroy(ptr_wcin);
+ _Destroy(ptr_wcout);
+ _Destroy(ptr_wcerr);
+ _Destroy(ptr_wclog);
+#endif
+}
+
+
+bool _STLP_CALL ios_base::sync_with_stdio(bool sync) {
+# if !defined (_STLP_HAS_NO_NAMESPACES) && !defined (_STLP_DONT_USE_PRIV_NAMESPACE)
+ using _STLP_PRIV stdio_istreambuf;
+ using _STLP_PRIV stdio_ostreambuf;
+# endif
+
+ if (sync == _S_is_synced) return sync;
+
+ // if by any chance we got there before std streams initialization,
+ // just set the sync flag and exit
+ if (Init::_S_count == 0) {
+ _S_is_synced = sync;
+ return sync;
+ }
+
+ auto_ptr<streambuf> cin_buf;
+ auto_ptr<streambuf> cout_buf;
+ auto_ptr<streambuf> cerr_buf;
+ auto_ptr<streambuf> clog_buf;
+
+ if (sync)
+ cin_buf.reset(new stdio_istreambuf(stdin));
+ else
+ cin_buf.reset(_Stl_create_filebuf(stdin, ios_base::in));
+
+ if (sync) {
+#ifdef _STLP_REDIRECT_STDSTREAMS
+ cout_buf.reset(_Stl_create_filebuf("/stdout.txt", ios::out));
+ cerr_buf.reset(_Stl_create_filebuf("/stderr.txt", ios::out));
+ clog_buf.reset(_Stl_create_filebuf("/stdlog.txt", ios::out));
+#else
+ cout_buf.reset(new stdio_ostreambuf(stdout));
+ cerr_buf.reset(new stdio_ostreambuf(stderr));
+ clog_buf.reset(new stdio_ostreambuf(stderr));
+#endif
+ }
+ else {
+ cout_buf.reset(_Stl_create_filebuf(stdout, ios_base::out));
+ cerr_buf.reset(_Stl_create_filebuf(stderr, ios_base::out));
+ clog_buf.reset(_Stl_create_filebuf(stderr, ios_base::out));
+ }
+
+ if (cin_buf.get() != 0 && cout_buf.get() != 0 && cerr_buf.get() != 0 && clog_buf.get() != 0) {
+ // When streambuf passed to rdbuf is not null, rdbuf is exception safe:
+ delete (&cin)->rdbuf(cin_buf.release());
+ delete (&cout)->rdbuf(cout_buf.release());
+ delete (&cerr)->rdbuf(cerr_buf.release());
+ delete (&clog)->rdbuf(clog_buf.release());
+ _S_is_synced = sync;
+ }
+
+ return _S_is_synced;
+}
+
+_STLP_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/src/istream.cpp b/sources/android/stlport/src/istream.cpp
new file mode 100644
index 0000000..715364c
--- /dev/null
+++ b/sources/android/stlport/src/istream.cpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+# include "stlport_prefix.h"
+
+#include <istream>
+
+_STLP_BEGIN_NAMESPACE
+
+#if !defined(_STLP_NO_FORCE_INSTANTIATE)
+
+// instantiations
+# if defined (_STLP_USE_TEMPLATE_EXPORT)
+template class _STLP_CLASS_DECLSPEC _Isentry<char, char_traits<char> >;
+# endif
+
+template class _STLP_CLASS_DECLSPEC basic_iostream<char, char_traits<char> >;
+template class _STLP_CLASS_DECLSPEC basic_istream<char, char_traits<char> >;
+
+# if !defined (_STLP_NO_WCHAR_T)
+# if defined (_STLP_USE_TEMPLATE_EXPORT)
+template class _STLP_CLASS_DECLSPEC _Isentry<wchar_t, char_traits<wchar_t> >;
+# endif
+template class _STLP_CLASS_DECLSPEC basic_istream<wchar_t, char_traits<wchar_t> >;
+template class _STLP_CLASS_DECLSPEC basic_iostream<wchar_t, char_traits<wchar_t> >;
+# endif /* !_STLP_NO_WCHAR_T */
+
+#endif /* _STLP_NO_FORCE_INSTANTIATE */
+
+_STLP_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/src/locale.cpp b/sources/android/stlport/src/locale.cpp
new file mode 100644
index 0000000..8df976b
--- /dev/null
+++ b/sources/android/stlport/src/locale.cpp
@@ -0,0 +1,445 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#include "stlport_prefix.h"
+
+#include <locale>
+#include <stdexcept>
+
+#include "c_locale.h"
+#include "locale_impl.h"
+
+_STLP_BEGIN_NAMESPACE
+
+static const string _Nameless("*");
+
+static inline bool is_C_locale_name (const char* name)
+{ return ((name[0] == 'C') && (name[1] == 0)); }
+
+locale* _Stl_get_classic_locale();
+locale* _Stl_get_global_locale();
+
+#if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) || \
+ defined (_STLP_SIGNAL_RUNTIME_COMPATIBILITY) || defined (_STLP_CHECK_RUNTIME_COMPATIBILITY)
+# define locale _STLP_NO_MEM_T_NAME(loc)
+#endif
+
+locale::facet::~facet() {}
+
+#if !defined (_STLP_MEMBER_TEMPLATES) || defined (_STLP_INLINE_MEMBER_TEMPLATES)
+// members that fail to be templates
+bool locale::operator()(const string& __x,
+ const string& __y) const
+{ return __locale_do_operator_call(*this, __x, __y); }
+
+# if !defined (_STLP_NO_WCHAR_T)
+bool locale::operator()(const wstring& __x,
+ const wstring& __y) const
+{ return __locale_do_operator_call(*this, __x, __y); }
+# endif
+#endif
+
+void _STLP_CALL locale::_M_throw_on_null_name()
+{ _STLP_THROW(runtime_error("Invalid null locale name")); }
+
+void _STLP_CALL locale::_M_throw_on_combine_error(const string& name) {
+ string what = "Unable to find facet";
+ what += " in ";
+ what += name.empty() ? "system" : name.c_str();
+ what += " locale";
+ _STLP_THROW(runtime_error(what.c_str()));
+}
+
+void _STLP_CALL locale::_M_throw_on_creation_failure(int __err_code,
+ const char* name, const char* facet) {
+ string what;
+ switch (__err_code) {
+ case _STLP_LOC_UNSUPPORTED_FACET_CATEGORY:
+ what = "No platform localization support for ";
+ what += facet;
+ what += " facet category, unable to create facet for ";
+ what += name[0] == 0 ? "system" : name;
+ what += " locale";
+ break;
+ case _STLP_LOC_NO_PLATFORM_SUPPORT:
+ what = "No platform localization support, unable to create ";
+ what += name[0] == 0 ? "system" : name;
+ what += " locale";
+ break;
+ default:
+ case _STLP_LOC_UNKNOWN_NAME:
+ what = "Unable to create facet ";
+ what += facet;
+ what += " from name '";
+ what += name;
+ what += "'";
+ break;
+ case _STLP_LOC_NO_MEMORY:
+ _STLP_THROW_BAD_ALLOC;
+ break;
+ }
+
+ _STLP_THROW(runtime_error(what.c_str()));
+}
+
+// Takes a reference to a locale::id, assign a numeric index if not already
+// affected and returns it. The returned index is always positive.
+static const locale::id& _Stl_loc_get_index(locale::id& id) {
+ if (id._M_index == 0) {
+#if defined (_STLP_ATOMIC_INCREMENT) && !defined (_STLP_WIN95_LIKE)
+ static _STLP_VOLATILE __stl_atomic_t _S_index = __STATIC_CAST(__stl_atomic_t, locale::id::_S_max);
+ id._M_index = _STLP_ATOMIC_INCREMENT(&_S_index);
+#else
+ static _STLP_STATIC_MUTEX _Index_lock _STLP_MUTEX_INITIALIZER;
+ _STLP_auto_lock sentry(_Index_lock);
+ size_t new_index = locale::id::_S_max++;
+ id._M_index = new_index;
+#endif
+ }
+ return id;
+}
+
+// Default constructor: create a copy of the global locale.
+locale::locale() _STLP_NOTHROW
+ : _M_impl(_get_Locale_impl(_Stl_get_global_locale()->_M_impl))
+{}
+
+// Copy constructor
+locale::locale(const locale& L) _STLP_NOTHROW
+ : _M_impl( _get_Locale_impl( L._M_impl ) )
+{}
+
+void locale::_M_insert(facet* f, locale::id& n) {
+ if (f)
+ _M_impl->insert(f, _Stl_loc_get_index(n));
+}
+
+locale::locale( _Locale_impl* impl ) :
+ _M_impl( _get_Locale_impl( impl ) )
+{}
+
+// Create a locale from a name.
+locale::locale(const char* name)
+ : _M_impl(0) {
+ if (!name)
+ _M_throw_on_null_name();
+
+ if (is_C_locale_name(name)) {
+ _M_impl = _get_Locale_impl( locale::classic()._M_impl );
+ return;
+ }
+
+ _Locale_impl* impl = 0;
+ _STLP_TRY {
+ impl = new _Locale_impl(locale::id::_S_max, name);
+
+ // Insert categories one at a time.
+ _Locale_name_hint *hint = 0;
+ const char* ctype_name = name;
+ char ctype_buf[_Locale_MAX_SIMPLE_NAME];
+ const char* numeric_name = name;
+ char numeric_buf[_Locale_MAX_SIMPLE_NAME];
+ const char* time_name = name;
+ char time_buf[_Locale_MAX_SIMPLE_NAME];
+ const char* collate_name = name;
+ char collate_buf[_Locale_MAX_SIMPLE_NAME];
+ const char* monetary_name = name;
+ char monetary_buf[_Locale_MAX_SIMPLE_NAME];
+ const char* messages_name = name;
+ char messages_buf[_Locale_MAX_SIMPLE_NAME];
+ hint = impl->insert_ctype_facets(ctype_name, ctype_buf, hint);
+ hint = impl->insert_numeric_facets(numeric_name, numeric_buf, hint);
+ hint = impl->insert_time_facets(time_name, time_buf, hint);
+ hint = impl->insert_collate_facets(collate_name, collate_buf, hint);
+ hint = impl->insert_monetary_facets(monetary_name, monetary_buf, hint);
+ impl->insert_messages_facets(messages_name, messages_buf, hint);
+
+ // Try to use a normalize locale name in order to have the == operator
+ // to behave correctly:
+ if (strcmp(ctype_name, numeric_name) == 0 &&
+ strcmp(ctype_name, time_name) == 0 &&
+ strcmp(ctype_name, collate_name) == 0 &&
+ strcmp(ctype_name, monetary_name) == 0 &&
+ strcmp(ctype_name, messages_name) == 0) {
+ impl->name = ctype_name;
+ }
+ // else we keep current name.
+
+ // reassign impl
+ _M_impl = _get_Locale_impl( impl );
+ }
+ _STLP_UNWIND(delete impl);
+}
+
+static void _Stl_loc_combine_names_aux(_Locale_impl* L,
+ const char* name,
+ const char* ctype_name, const char* time_name, const char* numeric_name,
+ const char* collate_name, const char* monetary_name, const char* messages_name,
+ locale::category c) {
+ // This function is only called when names has been validated so using _Locale_extract_*_name
+ // can't fail.
+ int __err_code;
+ char buf[_Locale_MAX_SIMPLE_NAME];
+ L->name = string("LC_CTYPE=") + _Locale_extract_ctype_name((c & locale::ctype) ? ctype_name : name, buf, 0, &__err_code) + ";";
+ L->name += string("LC_TIME=") + _Locale_extract_time_name((c & locale::time) ? time_name : name, buf, 0, &__err_code) + ";";
+ L->name += string("LC_NUMERIC=") + _Locale_extract_numeric_name((c & locale::numeric) ? numeric_name : name, buf, 0, &__err_code) + ";";
+ L->name += string("LC_COLLATE=") + _Locale_extract_collate_name((c & locale::collate) ? collate_name : name, buf, 0, &__err_code) + ";";
+ L->name += string("LC_MONETARY=") + _Locale_extract_monetary_name((c & locale::monetary) ? monetary_name : name, buf, 0, &__err_code) + ";";
+ L->name += string("LC_MESSAGES=") + _Locale_extract_messages_name((c & locale::messages) ? messages_name : name, buf, 0, &__err_code);
+}
+
+// Give L a name where all facets except those in category c
+// are taken from name1, and those in category c are taken from name2.
+static void _Stl_loc_combine_names(_Locale_impl* L,
+ const char* name1, const char* name2,
+ locale::category c) {
+ if ((c & locale::all) == 0 || strcmp(name1, name1) == 0)
+ L->name = name1;
+ else if ((c & locale::all) == locale::all)
+ L->name = name2;
+ else {
+ _Stl_loc_combine_names_aux(L, name1, name2, name2, name2, name2, name2, name2, c);
+ }
+}
+
+static void _Stl_loc_combine_names(_Locale_impl* L,
+ const char* name,
+ const char* ctype_name, const char* time_name, const char* numeric_name,
+ const char* collate_name, const char* monetary_name, const char* messages_name,
+ locale::category c) {
+ if ((c & locale::all) == 0 || (strcmp(name, ctype_name) == 0 &&
+ strcmp(name, time_name) == 0 &&
+ strcmp(name, numeric_name) == 0 &&
+ strcmp(name, collate_name) == 0 &&
+ strcmp(name, monetary_name) == 0 &&
+ strcmp(name, messages_name) == 0))
+ L->name = name;
+ else if ((c & locale::all) == locale::all && strcmp(ctype_name, time_name) == 0 &&
+ strcmp(ctype_name, numeric_name) == 0 &&
+ strcmp(ctype_name, collate_name) == 0 &&
+ strcmp(ctype_name, monetary_name) == 0 &&
+ strcmp(ctype_name, messages_name) == 0)
+ L->name = ctype_name;
+ else {
+ _Stl_loc_combine_names_aux(L, name, ctype_name, time_name, numeric_name, collate_name, monetary_name, messages_name, c);
+ }
+}
+
+
+// Create a locale that's a copy of L, except that all of the facets
+// in category c are instead constructed by name.
+locale::locale(const locale& L, const char* name, locale::category c)
+ : _M_impl(0) {
+ if (!name)
+ _M_throw_on_null_name();
+
+ if (_Nameless == name)
+ _STLP_THROW(runtime_error((string("Invalid locale name '") + _Nameless + "'").c_str()));
+
+ _Locale_impl* impl = 0;
+
+ _STLP_TRY {
+ impl = new _Locale_impl(*L._M_impl);
+
+ _Locale_name_hint *hint = 0;
+ const char* ctype_name = name;
+ char ctype_buf[_Locale_MAX_SIMPLE_NAME];
+ const char* numeric_name = name;
+ char numeric_buf[_Locale_MAX_SIMPLE_NAME];
+ const char* time_name = name;
+ char time_buf[_Locale_MAX_SIMPLE_NAME];
+ const char* collate_name = name;
+ char collate_buf[_Locale_MAX_SIMPLE_NAME];
+ const char* monetary_name = name;
+ char monetary_buf[_Locale_MAX_SIMPLE_NAME];
+ const char* messages_name = name;
+ char messages_buf[_Locale_MAX_SIMPLE_NAME];
+ if (c & locale::ctype)
+ hint = impl->insert_ctype_facets(ctype_name, ctype_buf, hint);
+ if (c & locale::numeric)
+ hint = impl->insert_numeric_facets(numeric_name, numeric_buf, hint);
+ if (c & locale::time)
+ hint = impl->insert_time_facets(time_name, time_buf, hint);
+ if (c & locale::collate)
+ hint = impl->insert_collate_facets(collate_name, collate_buf, hint);
+ if (c & locale::monetary)
+ hint = impl->insert_monetary_facets(monetary_name, monetary_buf,hint);
+ if (c & locale::messages)
+ impl->insert_messages_facets(messages_name, messages_buf, hint);
+
+ _Stl_loc_combine_names(impl, L._M_impl->name.c_str(),
+ ctype_name, time_name, numeric_name,
+ collate_name, monetary_name, messages_name, c);
+ _M_impl = _get_Locale_impl( impl );
+ }
+ _STLP_UNWIND(delete impl)
+}
+
+// Contruct a new locale where all facets that aren't in category c
+// come from L1, and all those that are in category c come from L2.
+locale::locale(const locale& L1, const locale& L2, category c)
+ : _M_impl(0) {
+ _Locale_impl* impl = new _Locale_impl(*L1._M_impl);
+
+ _Locale_impl* i2 = L2._M_impl;
+
+ if (L1.name() != _Nameless && L2.name() != _Nameless)
+ _Stl_loc_combine_names(impl, L1._M_impl->name.c_str(), L2._M_impl->name.c_str(), c);
+ else {
+ impl->name = _Nameless;
+ }
+
+ if (c & collate) {
+ impl->insert( i2, _STLP_STD::collate<char>::id);
+# ifndef _STLP_NO_WCHAR_T
+ impl->insert( i2, _STLP_STD::collate<wchar_t>::id);
+# endif
+ }
+ if (c & ctype) {
+ impl->insert( i2, _STLP_STD::ctype<char>::id);
+ impl->insert( i2, _STLP_STD::codecvt<char, char, mbstate_t>::id);
+# ifndef _STLP_NO_WCHAR_T
+ impl->insert( i2, _STLP_STD::ctype<wchar_t>::id);
+ impl->insert( i2, _STLP_STD::codecvt<wchar_t, char, mbstate_t>::id);
+# endif
+ }
+ if (c & monetary) {
+ impl->insert( i2, _STLP_STD::moneypunct<char, true>::id);
+ impl->insert( i2, _STLP_STD::moneypunct<char, false>::id);
+ impl->insert( i2, _STLP_STD::money_get<char, istreambuf_iterator<char, char_traits<char> > >::id);
+ impl->insert( i2, _STLP_STD::money_put<char, ostreambuf_iterator<char, char_traits<char> > >::id);
+# ifndef _STLP_NO_WCHAR_T
+ impl->insert( i2, _STLP_STD::moneypunct<wchar_t, true>::id);
+ impl->insert( i2, _STLP_STD::moneypunct<wchar_t, false>::id);
+ impl->insert( i2, _STLP_STD::money_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
+ impl->insert( i2, _STLP_STD::money_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
+# endif
+ }
+ if (c & numeric) {
+ impl->insert( i2, _STLP_STD::numpunct<char>::id);
+ impl->insert( i2, _STLP_STD::num_get<char, istreambuf_iterator<char, char_traits<char> > >::id);
+ impl->insert( i2, _STLP_STD::num_put<char, ostreambuf_iterator<char, char_traits<char> > >::id);
+# ifndef _STLP_NO_WCHAR_T
+ impl->insert( i2, _STLP_STD::numpunct<wchar_t>::id);
+ impl->insert( i2, _STLP_STD::num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
+ impl->insert( i2, _STLP_STD::num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
+# endif
+ }
+ if (c & time) {
+ impl->insert( i2, _STLP_STD::time_get<char, istreambuf_iterator<char, char_traits<char> > >::id);
+ impl->insert( i2, _STLP_STD::time_put<char, ostreambuf_iterator<char, char_traits<char> > >::id);
+# ifndef _STLP_NO_WCHAR_T
+ impl->insert( i2, _STLP_STD::time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
+ impl->insert( i2, _STLP_STD::time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
+# endif
+ }
+ if (c & messages) {
+ impl->insert( i2, _STLP_STD::messages<char>::id);
+# ifndef _STLP_NO_WCHAR_T
+ impl->insert( i2, _STLP_STD::messages<wchar_t>::id);
+# endif
+ }
+ _M_impl = _get_Locale_impl( impl );
+}
+
+// Destructor.
+locale::~locale() _STLP_NOTHROW {
+ if (_M_impl)
+ _release_Locale_impl(_M_impl);
+}
+
+// Assignment operator. Much like the copy constructor: just a bit of
+// pointer twiddling.
+const locale& locale::operator=(const locale& L) _STLP_NOTHROW {
+ if (this->_M_impl != L._M_impl) {
+ if (this->_M_impl)
+ _release_Locale_impl(this->_M_impl);
+ this->_M_impl = _get_Locale_impl(L._M_impl);
+ }
+ return *this;
+}
+
+locale::facet* locale::_M_get_facet(const locale::id& n) const {
+ return n._M_index < _M_impl->size() ? _M_impl->facets_vec[n._M_index] : 0;
+}
+
+locale::facet* locale::_M_use_facet(const locale::id& n) const {
+ locale::facet* f = (n._M_index < _M_impl->size() ? _M_impl->facets_vec[n._M_index] : 0);
+ if (!f)
+ _M_impl->_M_throw_bad_cast();
+ return f;
+}
+
+string locale::name() const {
+ return _M_impl->name;
+}
+
+// Compare two locales for equality.
+bool locale::operator==(const locale& L) const {
+ return this->_M_impl == L._M_impl ||
+ (this->name() == L.name() && this->name() != _Nameless);
+}
+
+bool locale::operator!=(const locale& L) const {
+ return !(*this == L);
+}
+
+// static data members.
+
+const locale& _STLP_CALL locale::classic() {
+ return *_Stl_get_classic_locale();
+}
+
+#if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+locale _STLP_CALL locale::global(const locale& L) {
+#else
+_Locale_impl* _STLP_CALL locale::global(const locale& L) {
+#endif
+ locale old(_Stl_get_global_locale()->_M_impl);
+ if (_Stl_get_global_locale()->_M_impl != L._M_impl) {
+ _release_Locale_impl(_Stl_get_global_locale()->_M_impl);
+ // this assign should be atomic, should be fixed here:
+ _Stl_get_global_locale()->_M_impl = _get_Locale_impl(L._M_impl);
+
+ // Set the global C locale, if appropriate.
+#if !defined(_STLP_NO_LOCALE_SUPPORT)
+ if (L.name() != _Nameless)
+ setlocale(LC_ALL, L.name().c_str());
+#endif
+ }
+
+#if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+ return old;
+#else
+ return old._M_impl;
+#endif
+}
+
+#if !defined (_STLP_STATIC_CONST_INIT_BUG) && !defined (_STLP_NO_STATIC_CONST_DEFINITION)
+const locale::category locale::none;
+const locale::category locale::collate;
+const locale::category locale::ctype;
+const locale::category locale::monetary;
+const locale::category locale::numeric;
+const locale::category locale::time;
+const locale::category locale::messages;
+const locale::category locale::all;
+#endif
+
+_STLP_END_NAMESPACE
+
diff --git a/sources/android/stlport/src/locale_catalog.cpp b/sources/android/stlport/src/locale_catalog.cpp
new file mode 100644
index 0000000..31e672e
--- /dev/null
+++ b/sources/android/stlport/src/locale_catalog.cpp
@@ -0,0 +1,288 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#include "stlport_prefix.h"
+
+#include <hash_map>
+#include <string>
+
+#include <locale>
+#include <istream>
+
+#include "c_locale.h"
+#include "locale_impl.h"
+#include "acquire_release.h"
+
+_STLP_BEGIN_NAMESPACE
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Those wrappers are needed to use locale functions in __acquire_category,
+// all functions have to present the same prototype.
+
+static void* _Loc_ctype_create(const char * s, _Locale_name_hint* hint, int *__err_code)
+{ return _Locale_ctype_create(s, hint, __err_code); }
+static void* _Loc_codecvt_create(const char * s, _Locale_name_hint* hint, int *__err_code)
+{ return _Locale_codecvt_create(s, hint, __err_code); }
+static void* _Loc_numeric_create(const char * s, _Locale_name_hint* hint, int *__err_code)
+{ return _Locale_numeric_create(s, hint, __err_code); }
+static void* _Loc_time_create(const char * s, _Locale_name_hint* hint, int *__err_code)
+{ return _Locale_time_create(s, hint, __err_code); }
+static void* _Loc_collate_create(const char * s, _Locale_name_hint* hint, int *__err_code)
+{ return _Locale_collate_create(s, hint, __err_code); }
+static void* _Loc_monetary_create(const char * s, _Locale_name_hint* hint, int *__err_code)
+{ return _Locale_monetary_create(s, hint, __err_code); }
+static void* _Loc_messages_create(const char * s, _Locale_name_hint* hint, int *__err_code)
+{ return _Locale_messages_create(s, hint, __err_code); }
+
+static char const* _Loc_ctype_name(void* l, char* s)
+{ return _Locale_ctype_name((_Locale_ctype*)l, s); }
+static char const* _Loc_codecvt_name(void* l, char* s)
+{ return _Locale_codecvt_name((_Locale_codecvt*)l, s); }
+static char const* _Loc_numeric_name(void* l, char* s)
+{ return _Locale_numeric_name((_Locale_numeric*)l, s); }
+static char const* _Loc_time_name(void* l, char* s)
+{ return _Locale_time_name((_Locale_time*)l, s); }
+static char const* _Loc_collate_name(void* l, char* s)
+{ return _Locale_collate_name((_Locale_collate*)l, s); }
+static char const* _Loc_monetary_name(void* l, char* s)
+{ return _Locale_monetary_name((_Locale_monetary*)l, s); }
+static char const* _Loc_messages_name(void* l, char* s)
+{ return _Locale_messages_name((_Locale_messages*)l, s); }
+
+static const char* _Loc_ctype_default(char* p)
+{ return _Locale_ctype_default(p); }
+static const char* _Loc_numeric_default(char * p)
+{ return _Locale_numeric_default(p); }
+static const char* _Loc_time_default(char* p)
+{ return _Locale_time_default(p); }
+static const char* _Loc_collate_default(char* p)
+{ return _Locale_collate_default(p); }
+static const char* _Loc_monetary_default(char* p)
+{ return _Locale_monetary_default(p); }
+static const char* _Loc_messages_default(char* p)
+{ return _Locale_messages_default(p); }
+
+static void _Loc_ctype_destroy(void* p) {_Locale_ctype_destroy((_Locale_ctype*)p); }
+static void _Loc_codecvt_destroy(void* p) {_Locale_codecvt_destroy((_Locale_codecvt*)p); }
+static void _Loc_numeric_destroy(void* p) {_Locale_numeric_destroy((_Locale_numeric*)p); }
+static void _Loc_time_destroy(void* p) {_Locale_time_destroy((_Locale_time*)p);}
+static void _Loc_collate_destroy(void* p) {_Locale_collate_destroy((_Locale_collate*)p);}
+static void _Loc_monetary_destroy(void* p) {_Locale_monetary_destroy((_Locale_monetary*)p);}
+static void _Loc_messages_destroy(void* p) {_Locale_messages_destroy((_Locale_messages*)p);}
+
+typedef void* (*loc_create_func_t)(const char *, _Locale_name_hint*, int *__err_code);
+typedef char const* (*loc_name_func_t)(void* l, char* s);
+typedef void (*loc_destroy_func_t)(void* l);
+typedef const char* (*loc_default_name_func_t)(char* s);
+typedef char const* (*loc_extract_name_func_t)(const char*, char*, _Locale_name_hint*, int *__err_code);
+
+//----------------------------------------------------------------------
+// Acquire and release low-level category objects. The whole point of
+// this is so that we don't allocate (say) four different _Locale_ctype
+// objects for a single locale.
+
+// Global hash tables for category objects.
+typedef hash_map<string, pair<void*, size_t>, hash<string>, equal_to<string> > Category_Map;
+
+// Look up a category by name
+static Category_Map** ctype_hash() {
+ static Category_Map *_S_ctype_hash = 0;
+ return &_S_ctype_hash;
+}
+static Category_Map** codecvt_hash() {
+ static Category_Map *_S_codecvt_hash = 0;
+ return &_S_codecvt_hash;
+}
+static Category_Map** numeric_hash() {
+ static Category_Map *_S_numeric_hash = 0;
+ return &_S_numeric_hash;
+}
+static Category_Map** time_hash() {
+ static Category_Map *_S_time_hash = 0;
+ return &_S_time_hash;
+}
+static Category_Map** collate_hash() {
+ static Category_Map *_S_collate_hash = 0;
+ return &_S_collate_hash;
+}
+static Category_Map** monetary_hash() {
+ static Category_Map *_S_monetary_hash = 0;
+ return &_S_monetary_hash;
+}
+static Category_Map** messages_hash() {
+ static Category_Map *_S_messages_hash;
+ return &_S_messages_hash;
+}
+
+// We have a single lock for all of the hash tables. We may wish to
+// replace it with six different locks.
+/* REFERENCED */
+static _STLP_STATIC_MUTEX& category_hash_mutex() {
+ static _STLP_STATIC_MUTEX lock _STLP_MUTEX_INITIALIZER;
+ return lock;
+}
+
+static void*
+__acquire_category(const char* &name, char *buf, _Locale_name_hint* hint,
+ loc_extract_name_func_t extract_name,
+ loc_create_func_t create_obj, loc_default_name_func_t default_name,
+ Category_Map ** M, int *__err_code) {
+#if !defined (__BORLANDC__) || (__BORLANDC__ >= 0x564)
+ typedef Category_Map::iterator Category_iterator;
+ pair<Category_iterator, bool> result;
+#else
+# if !defined(_STLP_DEBUG)
+ pair<_Ht_iterator<_Slist_iterator<pair<const string,pair<void *,unsigned int> >,_Nonconst_traits<pair<const string,pair<void *,unsigned int> > > >,_NonLocalHashMapTraitsT<pair<const string,pair<void *,unsigned int> > > >, bool> result;
+# else
+ pair<_DBG_iter<_NonDbg_hashtable<pair<const string,pair<void *,unsigned int> >,string,hash<string>,_HashMapTraitsT<pair<const string,pair<void *,unsigned int> > >,_Select1st<pair<const string,pair<void *,unsigned int> > >,_DbgEqual<string,equal_to<string> >,allocator<pair<const string,pair<void *,unsigned int> > > >,_DbgTraits<_NonLocalHashMapTraitsT<pair<const string,pair<void *,unsigned int> > > > >, bool> result;
+# endif
+#endif
+
+ *__err_code = _STLP_LOC_UNDEFINED;
+
+ // Find what name to look for. Be careful if user requests the default.
+ if (name[0] == 0) {
+ name = default_name(buf);
+ if (name == 0 || name[0] == 0)
+ name = "C";
+ }
+ else {
+ const char* cname = extract_name(name, buf, hint, __err_code);
+ if (cname == 0) {
+ return 0;
+ }
+ name = cname;
+ }
+
+ Category_Map::value_type __e(name, pair<void*,size_t>((void*)0,size_t(0)));
+
+ _STLP_auto_lock sentry(category_hash_mutex());
+
+ if (!*M)
+ *M = new Category_Map();
+
+ // Look for an existing entry with that name.
+ result = (*M)->insert_noresize(__e);
+
+ if (result.second) {
+ // There was no entry in the map already. Create the category.
+ (*result.first).second.first = create_obj(name, hint, __err_code);
+ if (!(*result.first).second.first) {
+ (*M)->erase(result.first);
+#if defined (_STLP_LEAKS_PEDANTIC)
+ if ((*M)->empty()) {
+ delete *M;
+ *M = 0;
+ }
+#endif
+ return 0;
+ }
+ }
+
+ // Increment the reference count.
+ ++((*result.first).second.second);
+
+ return (*result.first).second.first;
+}
+
+static void
+__release_category(void* cat,
+ loc_destroy_func_t destroy_fun,
+ loc_name_func_t get_name,
+ Category_Map** M) {
+ Category_Map *pM = *M;
+
+ if (cat && pM) {
+ // Find the name of the category object.
+ char buf[_Locale_MAX_SIMPLE_NAME + 1];
+ char const* name = get_name(cat, buf);
+
+ if (name != 0) {
+ _STLP_auto_lock sentry(category_hash_mutex());
+ Category_Map::iterator it = pM->find(name);
+ if (it != pM->end()) {
+ // Decrement the ref count. If it goes to zero, delete this category
+ // from the map.
+ if (--((*it).second.second) == 0) {
+ void* cat1 = (*it).second.first;
+ destroy_fun(cat1);
+ pM->erase(it);
+#if defined (_STLP_LEAKS_PEDANTIC)
+ if (pM->empty()) {
+ delete pM;
+ *M = 0;
+ }
+#endif
+ }
+ }
+ }
+ }
+}
+
+_Locale_ctype* _STLP_CALL __acquire_ctype(const char* &name, char *buf, _Locale_name_hint* hint, int *__err_code) {
+ return __REINTERPRET_CAST(_Locale_ctype*, __acquire_category(name, buf, hint,
+ _Locale_extract_ctype_name, _Loc_ctype_create, _Loc_ctype_default,
+ ctype_hash(), __err_code));
+}
+_Locale_codecvt* _STLP_CALL __acquire_codecvt(const char* &name, char *buf, _Locale_name_hint* hint, int *__err_code) {
+ return __REINTERPRET_CAST(_Locale_codecvt*, __acquire_category(name, buf, hint,
+ _Locale_extract_ctype_name, _Loc_codecvt_create, _Loc_ctype_default,
+ codecvt_hash(), __err_code));
+}
+_Locale_numeric* _STLP_CALL __acquire_numeric(const char* &name, char *buf, _Locale_name_hint* hint, int *__err_code) {
+ return __REINTERPRET_CAST(_Locale_numeric*, __acquire_category(name, buf, hint,
+ _Locale_extract_numeric_name, _Loc_numeric_create, _Loc_numeric_default,
+ numeric_hash(), __err_code));
+}
+_Locale_time* _STLP_CALL __acquire_time(const char* &name, char *buf, _Locale_name_hint* hint, int *__err_code) {
+ return __REINTERPRET_CAST(_Locale_time*, __acquire_category(name, buf, hint,
+ _Locale_extract_time_name, _Loc_time_create, _Loc_time_default,
+ time_hash(), __err_code));
+}
+_Locale_collate* _STLP_CALL __acquire_collate(const char* &name, char *buf, _Locale_name_hint* hint, int *__err_code) {
+ return __REINTERPRET_CAST(_Locale_collate*, __acquire_category(name, buf, hint,
+ _Locale_extract_collate_name, _Loc_collate_create, _Loc_collate_default,
+ collate_hash(), __err_code));
+}
+_Locale_monetary* _STLP_CALL __acquire_monetary(const char* &name, char *buf, _Locale_name_hint* hint, int *__err_code) {
+ return __REINTERPRET_CAST(_Locale_monetary*, __acquire_category(name, buf, hint,
+ _Locale_extract_monetary_name, _Loc_monetary_create, _Loc_monetary_default,
+ monetary_hash(), __err_code));
+}
+_Locale_messages* _STLP_CALL __acquire_messages(const char* &name, char *buf, _Locale_name_hint* hint, int *__err_code) {
+ return __REINTERPRET_CAST(_Locale_messages*, __acquire_category(name, buf, hint,
+ _Locale_extract_messages_name, _Loc_messages_create, _Loc_messages_default,
+ messages_hash(), __err_code));
+}
+
+void _STLP_CALL __release_ctype(_Locale_ctype* cat)
+{ __release_category(cat, _Loc_ctype_destroy, _Loc_ctype_name, ctype_hash()); }
+void _STLP_CALL __release_codecvt(_Locale_codecvt* cat)
+{ __release_category(cat, _Loc_codecvt_destroy, _Loc_codecvt_name, codecvt_hash()); }
+void _STLP_CALL __release_numeric(_Locale_numeric* cat)
+{ __release_category(cat, _Loc_numeric_destroy, _Loc_numeric_name, numeric_hash()); }
+void _STLP_CALL __release_time(_Locale_time* cat)
+{ __release_category(cat, _Loc_time_destroy, _Loc_time_name, time_hash()); }
+void _STLP_CALL __release_collate(_Locale_collate* cat)
+{ __release_category(cat, _Loc_collate_destroy, _Loc_collate_name, collate_hash()); }
+void _STLP_CALL __release_monetary(_Locale_monetary* cat)
+{ __release_category(cat, _Loc_monetary_destroy, _Loc_monetary_name, monetary_hash()); }
+void _STLP_CALL __release_messages(_Locale_messages* cat)
+{ __release_category(cat, _Loc_messages_destroy, _Loc_messages_name, messages_hash()); }
+
+_STLP_MOVE_TO_STD_NAMESPACE
+_STLP_END_NAMESPACE
diff --git a/sources/android/stlport/src/locale_impl.cpp b/sources/android/stlport/src/locale_impl.cpp
new file mode 100644
index 0000000..103b603
--- /dev/null
+++ b/sources/android/stlport/src/locale_impl.cpp
@@ -0,0 +1,765 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#include "stlport_prefix.h"
+
+#include <locale>
+#include <algorithm>
+#include <typeinfo>
+
+#include "c_locale.h"
+#include "aligned_buffer.h"
+#include "acquire_release.h"
+#include "locale_impl.h"
+
+_STLP_BEGIN_NAMESPACE
+
+static const string _Nameless("*");
+
+static inline bool is_C_locale_name (const char* name)
+{ return ((name[0] == 'C') && (name[1] == 0)); }
+
+locale::facet * _STLP_CALL _get_facet(locale::facet *f)
+{
+ if (f != 0)
+ f->_M_incr();
+ return f;
+}
+
+void _STLP_CALL _release_facet(locale::facet *&f)
+{
+ if ((f != 0) && (f->_M_decr() == 0)) {
+ delete f;
+ f = 0;
+ }
+}
+
+size_t locale::id::_S_max = 27;
+
+static void _Stl_loc_assign_ids();
+
+static _Stl_aligned_buffer<_Locale_impl::Init> __Loc_init_buf;
+
+_Locale_impl::Init::Init() {
+ if (_M_count()._M_incr() == 1) {
+ _Locale_impl::_S_initialize();
+ }
+}
+
+_Locale_impl::Init::~Init() {
+ if (_M_count()._M_decr() == 0) {
+ _Locale_impl::_S_uninitialize();
+ }
+}
+
+_Refcount_Base& _Locale_impl::Init::_M_count() const {
+ static _Refcount_Base _S_count(0);
+ return _S_count;
+}
+
+_Locale_impl::_Locale_impl(const char* s)
+ : _Refcount_Base(0), name(s), facets_vec() {
+ facets_vec.reserve( locale::id::_S_max );
+ new (&__Loc_init_buf) Init();
+}
+
+_Locale_impl::_Locale_impl( _Locale_impl const& locimpl )
+ : _Refcount_Base(0), name(locimpl.name), facets_vec() {
+ for_each( locimpl.facets_vec.begin(), locimpl.facets_vec.end(), _get_facet);
+ facets_vec = locimpl.facets_vec;
+ new (&__Loc_init_buf) Init();
+}
+
+_Locale_impl::_Locale_impl( size_t n, const char* s)
+ : _Refcount_Base(0), name(s), facets_vec(n, 0) {
+ new (&__Loc_init_buf) Init();
+}
+
+_Locale_impl::~_Locale_impl() {
+ (&__Loc_init_buf)->~Init();
+ for_each( facets_vec.begin(), facets_vec.end(), _release_facet);
+}
+
+// Initialization of the locale system. This must be called before
+// any locales are constructed. (Meaning that it must be called when
+// the I/O library itself is initialized.)
+void _STLP_CALL _Locale_impl::_S_initialize() {
+ _Stl_loc_assign_ids();
+ make_classic_locale();
+}
+
+// Release of the classic locale ressources. Has to be called after the last
+// locale destruction and not only after the classic locale destruction as
+// the facets can be shared between different facets.
+void _STLP_CALL _Locale_impl::_S_uninitialize() {
+ //Not necessary anymore as classic facets are now 'normal' dynamically allocated
+ //facets with a reference counter telling to _release_facet when the facet can be
+ //deleted.
+ //free_classic_locale();
+}
+
+// _Locale_impl non-inline member functions.
+void _STLP_CALL _Locale_impl::_M_throw_bad_cast() {
+ _STLP_THROW(bad_cast());
+}
+
+void _Locale_impl::insert(_Locale_impl *from, const locale::id& n) {
+ if (n._M_index > 0 && n._M_index < from->size()) {
+ this->insert(from->facets_vec[n._M_index], n);
+ }
+}
+
+locale::facet* _Locale_impl::insert(locale::facet *f, const locale::id& n) {
+ if (f == 0 || n._M_index == 0)
+ return 0;
+
+ if (n._M_index >= facets_vec.size()) {
+ facets_vec.resize(n._M_index + 1);
+ }
+
+ if (f != facets_vec[n._M_index])
+ {
+ _release_facet(facets_vec[n._M_index]);
+ facets_vec[n._M_index] = _get_facet(f);
+ }
+
+ return f;
+}
+
+//
+// <locale> content which is dependent on the name
+//
+
+/* Six functions, one for each category. Each of them takes a
+ * a name, constructs that appropriate category facets by name,
+ * and inserts them into the locale. */
+_Locale_name_hint* _Locale_impl::insert_ctype_facets(const char* &name, char *buf, _Locale_name_hint* hint) {
+ if (name[0] == 0)
+ name = _Locale_ctype_default(buf);
+
+ if (name == 0 || name[0] == 0 || is_C_locale_name(name)) {
+ _Locale_impl* i2 = locale::classic()._M_impl;
+ this->insert(i2, ctype<char>::id);
+ this->insert(i2, codecvt<char, char, mbstate_t>::id);
+#ifndef _STLP_NO_WCHAR_T
+ this->insert(i2, ctype<wchar_t>::id);
+ this->insert(i2, codecvt<wchar_t, char, mbstate_t>::id);
+#endif
+ } else {
+ locale::facet* ct = 0;
+ locale::facet* cvt = 0;
+#ifndef _STLP_NO_WCHAR_T
+ locale::facet* wct = 0;
+ locale::facet* wcvt = 0;
+#endif
+ int __err_code;
+ _Locale_ctype *__lct = _STLP_PRIV __acquire_ctype(name, buf, hint, &__err_code);
+ if (!__lct) {
+ locale::_M_throw_on_creation_failure(__err_code, name, "ctype");
+ return hint;
+ }
+
+ if (hint == 0) hint = _Locale_get_ctype_hint(__lct);
+
+ _STLP_TRY {
+ ct = new ctype_byname<char>(__lct);
+ }
+ _STLP_UNWIND(_STLP_PRIV __release_ctype(__lct));
+
+ _STLP_TRY {
+ cvt = new codecvt_byname<char, char, mbstate_t>(name);
+ }
+ _STLP_UNWIND(delete ct);
+
+#ifndef _STLP_NO_WCHAR_T
+ _STLP_TRY {
+ _Locale_ctype *__lwct = _STLP_PRIV __acquire_ctype(name, buf, hint, &__err_code);
+ if (!__lwct) {
+ locale::_M_throw_on_creation_failure(__err_code, name, "ctype");
+ return hint;
+ }
+
+ _STLP_TRY {
+ wct = new ctype_byname<wchar_t>(__lwct);
+ }
+ _STLP_UNWIND(_STLP_PRIV __release_ctype(__lwct));
+
+ _Locale_codecvt *__lwcvt = _STLP_PRIV __acquire_codecvt(name, buf, hint, &__err_code);
+ if (__lwcvt) {
+ _STLP_TRY {
+ wcvt = new codecvt_byname<wchar_t, char, mbstate_t>(__lwcvt);
+ }
+ _STLP_UNWIND(_STLP_PRIV __release_codecvt(__lwcvt); delete wct);
+ }
+ }
+ _STLP_UNWIND(delete cvt; delete ct);
+#endif
+
+ this->insert(ct, ctype<char>::id);
+ this->insert(cvt, codecvt<char, char, mbstate_t>::id);
+#ifndef _STLP_NO_WCHAR_T
+ this->insert(wct, ctype<wchar_t>::id);
+ if (wcvt) this->insert(wcvt, codecvt<wchar_t, char, mbstate_t>::id);
+#endif
+ }
+ return hint;
+}
+
+_Locale_name_hint* _Locale_impl::insert_numeric_facets(const char* &name, char *buf, _Locale_name_hint* hint) {
+ if (name[0] == 0)
+ name = _Locale_numeric_default(buf);
+
+ _Locale_impl* i2 = locale::classic()._M_impl;
+
+ // We first insert name independant facets taken from the classic locale instance:
+ this->insert(i2,
+ num_put<char, ostreambuf_iterator<char, char_traits<char> > >::id);
+ this->insert(i2,
+ num_get<char, istreambuf_iterator<char, char_traits<char> > >::id);
+#ifndef _STLP_NO_WCHAR_T
+ this->insert(i2,
+ num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
+ this->insert(i2,
+ num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
+#endif
+
+ if (name == 0 || name[0] == 0 || is_C_locale_name(name)) {
+ this->insert(i2, numpunct<char>::id);
+#ifndef _STLP_NO_WCHAR_T
+ this->insert(i2, numpunct<wchar_t>::id);
+#endif
+ }
+ else {
+ locale::facet* punct = 0;
+#ifndef _STLP_NO_WCHAR_T
+ locale::facet* wpunct = 0;
+#endif
+
+ int __err_code;
+ _Locale_numeric *__lpunct = _STLP_PRIV __acquire_numeric(name, buf, hint, &__err_code);
+ if (!__lpunct) {
+ locale::_M_throw_on_creation_failure(__err_code, name, "numpunct");
+ return hint;
+ }
+
+ if (hint == 0) hint = _Locale_get_numeric_hint(__lpunct);
+ _STLP_TRY {
+ punct = new numpunct_byname<char>(__lpunct);
+ }
+ _STLP_UNWIND(_STLP_PRIV __release_numeric(__lpunct));
+
+#ifndef _STLP_NO_WCHAR_T
+ _Locale_numeric *__lwpunct = _STLP_PRIV __acquire_numeric(name, buf, hint, &__err_code);
+ if (!__lwpunct) {
+ delete punct;
+ locale::_M_throw_on_creation_failure(__err_code, name, "numpunct");
+ return hint;
+ }
+ if (__lwpunct) {
+ _STLP_TRY {
+ wpunct = new numpunct_byname<wchar_t>(__lwpunct);
+ }
+ _STLP_UNWIND(_STLP_PRIV __release_numeric(__lwpunct); delete punct);
+ }
+#endif
+
+ this->insert(punct, numpunct<char>::id);
+#ifndef _STLP_NO_WCHAR_T
+ this->insert(wpunct, numpunct<wchar_t>::id);
+#endif
+ }
+ return hint;
+}
+
+_Locale_name_hint* _Locale_impl::insert_time_facets(const char* &name, char *buf, _Locale_name_hint* hint) {
+ if (name[0] == 0)
+ name = _Locale_time_default(buf);
+
+ if (name == 0 || name[0] == 0 || is_C_locale_name(name)) {
+ _Locale_impl* i2 = locale::classic()._M_impl;
+ this->insert(i2,
+ time_get<char, istreambuf_iterator<char, char_traits<char> > >::id);
+ this->insert(i2,
+ time_put<char, ostreambuf_iterator<char, char_traits<char> > >::id);
+#ifndef _STLP_NO_WCHAR_T
+ this->insert(i2,
+ time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
+ this->insert(i2,
+ time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
+#endif
+ } else {
+ locale::facet *get = 0;
+ locale::facet *put = 0;
+#ifndef _STLP_NO_WCHAR_T
+ locale::facet *wget = 0;
+ locale::facet *wput = 0;
+#endif
+
+ int __err_code;
+ _Locale_time *__time = _STLP_PRIV __acquire_time(name, buf, hint, &__err_code);
+ if (!__time) {
+ // time facets category is not mandatory for correct stream behavior so if platform
+ // do not support it we do not generate a runtime_error exception.
+ if (__err_code == _STLP_LOC_NO_MEMORY) {
+ _STLP_THROW_BAD_ALLOC;
+ }
+ return hint;
+ }
+
+ if (!hint) hint = _Locale_get_time_hint(__time);
+ _STLP_TRY {
+ get = new time_get_byname<char, istreambuf_iterator<char, char_traits<char> > >(__time);
+ put = new time_put_byname<char, ostreambuf_iterator<char, char_traits<char> > >(__time);
+#ifndef _STLP_NO_WCHAR_T
+ wget = new time_get_byname<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >(__time);
+ wput = new time_put_byname<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >(__time);
+#endif
+ }
+#ifndef _STLP_NO_WCHAR_T
+ _STLP_UNWIND(delete wget; delete put; delete get; _STLP_PRIV __release_time(__time));
+#else
+ _STLP_UNWIND(delete get; _STLP_PRIV __release_time(__time));
+#endif
+
+ _STLP_PRIV __release_time(__time);
+
+ this->insert(get, time_get<char, istreambuf_iterator<char, char_traits<char> > >::id);
+ this->insert(put, time_put<char, ostreambuf_iterator<char, char_traits<char> > >::id);
+#ifndef _STLP_NO_WCHAR_T
+ this->insert(wget, time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
+ this->insert(wput, time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
+#endif
+ }
+ return hint;
+}
+
+_Locale_name_hint* _Locale_impl::insert_collate_facets(const char* &name, char *buf, _Locale_name_hint* hint) {
+ if (name[0] == 0)
+ name = _Locale_collate_default(buf);
+
+ if (name == 0 || name[0] == 0 || is_C_locale_name(name)) {
+ _Locale_impl* i2 = locale::classic()._M_impl;
+ this->insert(i2, collate<char>::id);
+#ifndef _STLP_NO_WCHAR_T
+ this->insert(i2, collate<wchar_t>::id);
+#endif
+ }
+ else {
+ locale::facet *col = 0;
+#ifndef _STLP_NO_WCHAR_T
+ locale::facet *wcol = 0;
+#endif
+
+ int __err_code;
+ _Locale_collate *__coll = _STLP_PRIV __acquire_collate(name, buf, hint, &__err_code);
+ if (!__coll) {
+ if (__err_code == _STLP_LOC_NO_MEMORY) {
+ _STLP_THROW_BAD_ALLOC;
+ }
+ return hint;
+ }
+
+ if (hint == 0) hint = _Locale_get_collate_hint(__coll);
+ _STLP_TRY {
+ col = new collate_byname<char>(__coll);
+ }
+ _STLP_UNWIND(_STLP_PRIV __release_collate(__coll));
+
+#ifndef _STLP_NO_WCHAR_T
+ _Locale_collate *__wcoll = _STLP_PRIV __acquire_collate(name, buf, hint, &__err_code);
+ if (!__wcoll) {
+ if (__err_code == _STLP_LOC_NO_MEMORY) {
+ delete col;
+ _STLP_THROW_BAD_ALLOC;
+ }
+ }
+ if (__wcoll) {
+ _STLP_TRY {
+ wcol = new collate_byname<wchar_t>(__wcoll);
+ }
+ _STLP_UNWIND(_STLP_PRIV __release_collate(__wcoll); delete col);
+ }
+#endif
+
+ this->insert(col, collate<char>::id);
+#ifndef _STLP_NO_WCHAR_T
+ if (wcol) this->insert(wcol, collate<wchar_t>::id);
+#endif
+ }
+ return hint;
+}
+
+_Locale_name_hint* _Locale_impl::insert_monetary_facets(const char* &name, char *buf, _Locale_name_hint* hint) {
+ if (name[0] == 0)
+ name = _Locale_monetary_default(buf);
+
+ _Locale_impl* i2 = locale::classic()._M_impl;
+
+ // We first insert name independant facets taken from the classic locale instance:
+ this->insert(i2, money_get<char, istreambuf_iterator<char, char_traits<char> > >::id);
+ this->insert(i2, money_put<char, ostreambuf_iterator<char, char_traits<char> > >::id);
+#ifndef _STLP_NO_WCHAR_T
+ this->insert(i2, money_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
+ this->insert(i2, money_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id);
+#endif
+
+ if (name == 0 || name[0] == 0 || is_C_locale_name(name)) {
+ this->insert(i2, moneypunct<char, false>::id);
+ this->insert(i2, moneypunct<char, true>::id);
+#ifndef _STLP_NO_WCHAR_T
+ this->insert(i2, moneypunct<wchar_t, false>::id);
+ this->insert(i2, moneypunct<wchar_t, true>::id);
+#endif
+ }
+ else {
+ locale::facet *punct = 0;
+ locale::facet *ipunct = 0;
+
+#ifndef _STLP_NO_WCHAR_T
+ locale::facet* wpunct = 0;
+ locale::facet* wipunct = 0;
+#endif
+
+ int __err_code;
+ _Locale_monetary *__mon = _STLP_PRIV __acquire_monetary(name, buf, hint, &__err_code);
+ if (!__mon) {
+ if (__err_code == _STLP_LOC_NO_MEMORY) {
+ _STLP_THROW_BAD_ALLOC;
+ }
+ return hint;
+ }
+
+ if (hint == 0) hint = _Locale_get_monetary_hint(__mon);
+
+ _STLP_TRY {
+ punct = new moneypunct_byname<char, false>(__mon);
+ }
+ _STLP_UNWIND(_STLP_PRIV __release_monetary(__mon));
+
+ _Locale_monetary *__imon = _STLP_PRIV __acquire_monetary(name, buf, hint, &__err_code);
+ if (!__imon) {
+ delete punct;
+ if (__err_code == _STLP_LOC_NO_MEMORY) {
+ _STLP_THROW_BAD_ALLOC;
+ }
+ return hint;
+ }
+
+ _STLP_TRY {
+ ipunct = new moneypunct_byname<char, true>(__imon);
+ }
+ _STLP_UNWIND(_STLP_PRIV __release_monetary(__imon); delete punct);
+
+#ifndef _STLP_NO_WCHAR_T
+ _STLP_TRY {
+ _Locale_monetary *__wmon = _STLP_PRIV __acquire_monetary(name, buf, hint, &__err_code);
+ if (!__wmon) {
+ if (__err_code == _STLP_LOC_NO_MEMORY) {
+ _STLP_THROW_BAD_ALLOC;
+ }
+ }
+
+ if (__wmon) {
+ _STLP_TRY {
+ wpunct = new moneypunct_byname<wchar_t, false>(__wmon);
+ }
+ _STLP_UNWIND(_STLP_PRIV __release_monetary(__wmon));
+
+ _Locale_monetary *__wimon = _STLP_PRIV __acquire_monetary(name, buf, hint, &__err_code);
+ if (!__wimon) {
+ delete wpunct;
+ if (__err_code == _STLP_LOC_NO_MEMORY) {
+ _STLP_THROW_BAD_ALLOC;
+ }
+ wpunct = 0;
+ }
+ else {
+ _STLP_TRY {
+ wipunct = new moneypunct_byname<wchar_t, true>(__wimon);
+ }
+ _STLP_UNWIND(_STLP_PRIV __release_monetary(__wimon); delete wpunct);
+ }
+ }
+ }
+ _STLP_UNWIND(delete ipunct; delete punct);
+#endif
+
+ this->insert(punct, moneypunct<char, false>::id);
+ this->insert(ipunct, moneypunct<char, true>::id);
+#ifndef _STLP_NO_WCHAR_T
+ if (wpunct) this->insert(wpunct, moneypunct<wchar_t, false>::id);
+ if (wipunct) this->insert(wipunct, moneypunct<wchar_t, true>::id);
+#endif
+ }
+ return hint;
+}
+
+_Locale_name_hint* _Locale_impl::insert_messages_facets(const char* &name, char *buf, _Locale_name_hint* hint) {
+ if (name[0] == 0)
+ name = _Locale_messages_default(buf);
+
+ if (name == 0 || name[0] == 0 || is_C_locale_name(name)) {
+ _Locale_impl* i2 = locale::classic()._M_impl;
+ this->insert(i2, messages<char>::id);
+#ifndef _STLP_NO_WCHAR_T
+ this->insert(i2, messages<wchar_t>::id);
+#endif
+ }
+ else {
+ locale::facet *msg = 0;
+#ifndef _STLP_NO_WCHAR_T
+ locale::facet *wmsg = 0;
+#endif
+
+ int __err_code;
+ _Locale_messages *__msg = _STLP_PRIV __acquire_messages(name, buf, hint, &__err_code);
+ if (!__msg) {
+ if (__err_code == _STLP_LOC_NO_MEMORY) {
+ _STLP_THROW_BAD_ALLOC;
+ }
+ return hint;
+ }
+
+ _STLP_TRY {
+ msg = new messages_byname<char>(__msg);
+ }
+ _STLP_UNWIND(_STLP_PRIV __release_messages(__msg));
+
+#ifndef _STLP_NO_WCHAR_T
+ _STLP_TRY {
+ _Locale_messages *__wmsg = _STLP_PRIV __acquire_messages(name, buf, hint, &__err_code);
+ if (!__wmsg) {
+ if (__err_code == _STLP_LOC_NO_MEMORY) {
+ _STLP_THROW_BAD_ALLOC;
+ }
+ }
+
+ if (__wmsg) {
+ _STLP_TRY {
+ wmsg = new messages_byname<wchar_t>(__wmsg);
+ }
+ _STLP_UNWIND(_STLP_PRIV __release_messages(__wmsg));
+ }
+ }
+ _STLP_UNWIND(delete msg);
+#endif
+
+ this->insert(msg, messages<char>::id);
+#ifndef _STLP_NO_WCHAR_T
+ if (wmsg) this->insert(wmsg, messages<wchar_t>::id);
+#endif
+ }
+ return hint;
+}
+
+static void _Stl_loc_assign_ids() {
+ // This assigns ids to every facet that is a member of a category,
+ // and also to money_get/put, num_get/put, and time_get/put
+ // instantiated using ordinary pointers as the input/output
+ // iterators. (The default is [io]streambuf_iterator.)
+
+ money_get<char, istreambuf_iterator<char, char_traits<char> > >::id._M_index = 8;
+ money_put<char, ostreambuf_iterator<char, char_traits<char> > >::id._M_index = 9;
+ num_get<char, istreambuf_iterator<char, char_traits<char> > >::id._M_index = 10;
+ num_put<char, ostreambuf_iterator<char, char_traits<char> > >::id._M_index = 11;
+ time_get<char, istreambuf_iterator<char, char_traits<char> > >::id._M_index = 12;
+ time_put<char, ostreambuf_iterator<char, char_traits<char> > >::id._M_index = 13;
+
+#ifndef _STLP_NO_WCHAR_T
+ money_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id._M_index = 21;
+ money_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id._M_index = 22;
+ num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id._M_index = 23;
+ num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > > ::id._M_index = 24;
+ time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id._M_index = 25;
+ time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id._M_index = 26;
+#endif
+ // locale::id::_S_max = 27;
+}
+
+// To access those static instance use the getter below, they guaranty
+// a correct initialization.
+static locale *_Stl_classic_locale = 0;
+static locale *_Stl_global_locale = 0;
+
+locale* _Stl_get_classic_locale() {
+ static _Locale_impl::Init init;
+ return _Stl_classic_locale;
+}
+
+locale* _Stl_get_global_locale() {
+ static _Locale_impl::Init init;
+ return _Stl_global_locale;
+}
+
+#if defined (_STLP_MSVC) || defined (__ICL) || defined (__ISCPP__) || defined (__DMC__)
+/*
+ * The following static variable needs to be initialized before STLport
+ * users static variable in order for him to be able to use Standard
+ * streams in its variable initialization.
+ * This variable is here because MSVC do not allow to change the initialization
+ * segment in a given translation unit, iostream.cpp already contains an
+ * initialization segment specification.
+ */
+# pragma warning (disable : 4073)
+# pragma init_seg(lib)
+#endif
+
+static ios_base::Init _IosInit;
+
+void _Locale_impl::make_classic_locale() {
+ // This funcion will be called once: during build classic _Locale_impl
+
+ // The classic locale contains every facet that belongs to a category.
+ static _Stl_aligned_buffer<_Locale_impl> _Locale_classic_impl_buf;
+ _Locale_impl *classic = new(&_Locale_classic_impl_buf) _Locale_impl("C");
+
+ locale::facet* classic_facets[] = {
+ 0,
+ new collate<char>(1),
+ new ctype<char>(0, false, 1),
+ new codecvt<char, char, mbstate_t>(1),
+ new moneypunct<char, true>(1),
+ new moneypunct<char, false>(1),
+ new numpunct<char>(1),
+ new messages<char>(1),
+ new money_get<char, istreambuf_iterator<char, char_traits<char> > >(1),
+ new money_put<char, ostreambuf_iterator<char, char_traits<char> > >(1),
+ new num_get<char, istreambuf_iterator<char, char_traits<char> > >(1),
+ new num_put<char, ostreambuf_iterator<char, char_traits<char> > >(1),
+ new time_get<char, istreambuf_iterator<char, char_traits<char> > >(1),
+ new time_put<char, ostreambuf_iterator<char, char_traits<char> > >(1),
+#ifndef _STLP_NO_WCHAR_T
+ new collate<wchar_t>(1),
+ new ctype<wchar_t>(1),
+ new codecvt<wchar_t, char, mbstate_t>(1),
+ new moneypunct<wchar_t, true>(1),
+ new moneypunct<wchar_t, false>(1),
+ new numpunct<wchar_t>(1),
+ new messages<wchar_t>(1),
+ new money_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >(1),
+ new money_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >(1),
+ new num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >(1),
+ new num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >(1),
+ new time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >(1),
+ new time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >(1),
+#endif
+ 0
+ };
+
+ const size_t nb_classic_facets = sizeof(classic_facets) / sizeof(locale::facet *);
+ classic->facets_vec.reserve(nb_classic_facets);
+ classic->facets_vec.assign(&classic_facets[0], &classic_facets[0] + nb_classic_facets);
+
+ static locale _Locale_classic(classic);
+ _Stl_classic_locale = &_Locale_classic;
+
+ static locale _Locale_global(classic);
+ _Stl_global_locale = &_Locale_global;
+}
+
+// Declarations of (non-template) facets' static data members
+// size_t locale::id::_S_max = 27; // made before
+
+locale::id collate<char>::id = { 1 };
+locale::id ctype<char>::id = { 2 };
+locale::id codecvt<char, char, mbstate_t>::id = { 3 };
+locale::id moneypunct<char, true>::id = { 4 };
+locale::id moneypunct<char, false>::id = { 5 };
+locale::id numpunct<char>::id = { 6 } ;
+locale::id messages<char>::id = { 7 };
+
+#ifndef _STLP_NO_WCHAR_T
+locale::id collate<wchar_t>::id = { 14 };
+locale::id ctype<wchar_t>::id = { 15 };
+locale::id codecvt<wchar_t, char, mbstate_t>::id = { 16 };
+locale::id moneypunct<wchar_t, true>::id = { 17 } ;
+locale::id moneypunct<wchar_t, false>::id = { 18 } ;
+locale::id numpunct<wchar_t>::id = { 19 };
+locale::id messages<wchar_t>::id = { 20 };
+#endif
+
+_STLP_DECLSPEC _Locale_impl* _STLP_CALL _get_Locale_impl(_Locale_impl *loc)
+{
+ _STLP_ASSERT( loc != 0 );
+ loc->_M_incr();
+ return loc;
+}
+
+void _STLP_CALL _release_Locale_impl(_Locale_impl *& loc)
+{
+ _STLP_ASSERT( loc != 0 );
+ if (loc->_M_decr() == 0) {
+ if (*loc != *_Stl_classic_locale)
+ delete loc;
+ else
+ loc->~_Locale_impl();
+ loc = 0;
+ }
+}
+
+_STLP_DECLSPEC _Locale_impl* _STLP_CALL _copy_Nameless_Locale_impl(_Locale_impl *loc)
+{
+ _STLP_ASSERT( loc != 0 );
+ _Locale_impl *loc_new = new _Locale_impl(*loc);
+ loc_new->name = _Nameless;
+ return loc_new;
+}
+
+/* _GetFacetId implementation have to be here in order to be in the same translation unit
+ * as where id are initialize (in _Stl_loc_assign_ids) */
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const money_get<char, istreambuf_iterator<char, char_traits<char> > >*)
+{ return money_get<char, istreambuf_iterator<char, char_traits<char> > >::id; }
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const money_put<char, ostreambuf_iterator<char, char_traits<char> > >*)
+{ return money_put<char, ostreambuf_iterator<char, char_traits<char> > >::id; }
+#ifndef _STLP_NO_WCHAR_T
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const money_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >*)
+{ return money_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id; }
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const money_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >*)
+{ return money_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id; }
+#endif
+
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const num_get<char, istreambuf_iterator<char, char_traits<char> > >*)
+{ return num_get<char, istreambuf_iterator<char, char_traits<char> > >::id; }
+#ifndef _STLP_NO_WCHAR_T
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >*)
+{ return num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id; }
+#endif
+
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const num_put<char, ostreambuf_iterator<char, char_traits<char> > >*)
+{ return num_put<char, ostreambuf_iterator<char, char_traits<char> > >::id; }
+#ifndef _STLP_NO_WCHAR_T
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >*)
+{ return num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id; }
+#endif
+
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const time_get<char, istreambuf_iterator<char, char_traits<char> > >*)
+{ return time_get<char, istreambuf_iterator<char, char_traits<char> > >::id; }
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const time_put<char, ostreambuf_iterator<char, char_traits<char> > >*)
+{ return time_put<char, ostreambuf_iterator<char, char_traits<char> > >::id; }
+#ifndef _STLP_NO_WCHAR_T
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >*)
+{ return time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id; }
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >*)
+{ return time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >::id; }
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
diff --git a/sources/android/stlport/src/locale_impl.h b/sources/android/stlport/src/locale_impl.h
new file mode 100644
index 0000000..2aa694c
--- /dev/null
+++ b/sources/android/stlport/src/locale_impl.h
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef LOCALE_IMPL_H
+#define LOCALE_IMPL_H
+
+#include <clocale> // C locale header file.
+#include <vector>
+#include <string>
+#include <locale>
+#include "c_locale.h"
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+//Export of _Locale_impl facets container:
+# if !defined (_STLP_USE_PTR_SPECIALIZATIONS)
+//If we are using pointer specialization, vector<locale::facet*> will use
+//the already exported vector<void*> implementation.
+_STLP_EXPORT_TEMPLATE_CLASS allocator<locale::facet*>;
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<locale::facet**, locale::facet*, allocator<locale::facet*> >;
+_STLP_EXPORT_TEMPLATE_CLASS _Vector_base<locale::facet*, allocator<locale::facet*> >;
+
+_STLP_MOVE_TO_STD_NAMESPACE
+# endif
+# if defined (_STLP_DEBUG)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+# define _STLP_NON_DBG_VECTOR _STLP_NON_DBG_NAME(vector)
+_STLP_EXPORT_TEMPLATE_CLASS __construct_checker<_STLP_NON_DBG_VECTOR<locale::facet*, allocator<locale::facet*> > >;
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_NON_DBG_VECTOR<locale::facet*, allocator<locale::facet*> >;
+# undef _STLP_NON_DBG_VECTOR
+_STLP_MOVE_TO_STD_NAMESPACE
+# endif
+
+_STLP_EXPORT_TEMPLATE_CLASS vector<locale::facet*, allocator<locale::facet*> >;
+#endif
+
+//----------------------------------------------------------------------
+// Class _Locale_impl
+// This is the base class which implements access only and is supposed to
+// be used for classic locale only
+class _STLP_CLASS_DECLSPEC _Locale_impl : public _Refcount_Base {
+ public:
+ _Locale_impl(const char* s);
+ _Locale_impl(const _Locale_impl&);
+ _Locale_impl(size_t n, const char* s);
+
+ private:
+ ~_Locale_impl();
+
+ public:
+ size_t size() const { return facets_vec.size(); }
+
+ basic_string<char, char_traits<char>, allocator<char> > name;
+
+ static void _STLP_FUNCTION_THROWS _STLP_CALL _M_throw_bad_cast();
+
+ private:
+ void operator=(const _Locale_impl&);
+
+ public:
+ class _STLP_CLASS_DECLSPEC Init {
+ public:
+ Init();
+ ~Init();
+ private:
+ _Refcount_Base& _M_count() const;
+ };
+
+ static void _STLP_CALL _S_initialize();
+ static void _STLP_CALL _S_uninitialize();
+
+ static void make_classic_locale();
+ static void free_classic_locale();
+
+ friend class Init;
+
+ public:
+ // void remove(size_t index);
+ locale::facet* insert(locale::facet*, const locale::id& n);
+ void insert(_Locale_impl* from, const locale::id& n);
+
+ // Helper functions for byname construction of locales.
+ _Locale_name_hint* insert_ctype_facets(const char* &name, char *buf, _Locale_name_hint* hint);
+ _Locale_name_hint* insert_numeric_facets(const char* &name, char *buf, _Locale_name_hint* hint);
+ _Locale_name_hint* insert_time_facets(const char* &name, char *buf, _Locale_name_hint* hint);
+ _Locale_name_hint* insert_collate_facets(const char* &name, char *buf, _Locale_name_hint* hint);
+ _Locale_name_hint* insert_monetary_facets(const char* &name, char *buf, _Locale_name_hint* hint);
+ _Locale_name_hint* insert_messages_facets(const char* &name, char *buf, _Locale_name_hint* hint);
+
+ bool operator != (const locale& __loc) const { return __loc._M_impl != this; }
+
+ private:
+ vector<locale::facet*> facets_vec;
+
+ private:
+ friend _Locale_impl * _STLP_CALL _copy_Nameless_Locale_impl( _Locale_impl * );
+ friend void _STLP_CALL _release_Locale_impl( _Locale_impl *& loc );
+#if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) || \
+ defined (_STLP_SIGNAL_RUNTIME_COMPATIBILITY) || defined (_STLP_CHECK_RUNTIME_COMPATIBILITY)
+ friend class _STLP_NO_MEM_T_NAME(loc);
+#else
+ friend class locale;
+#endif
+};
+
+void _STLP_CALL _release_Locale_impl( _Locale_impl *& loc );
+
+_STLP_END_NAMESPACE
+
+#endif
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/src/lock_free_slist.h b/sources/android/stlport/src/lock_free_slist.h
new file mode 100644
index 0000000..7c753d1
--- /dev/null
+++ b/sources/android/stlport/src/lock_free_slist.h
@@ -0,0 +1,307 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_LOCK_FREE_SLIST_H
+#define _STLP_LOCK_FREE_SLIST_H
+
+#if defined(_STLP_PTHREADS)
+# include <pthread.h>
+
+# if defined (__GNUC__) && defined (__i386__)
+
+# define _STLP_HAS_ATOMIC_FREELIST
+/**
+ * Class that implements a non-blocking and thread-safe freelist.
+ * It is used for the lock-free node allocation engine.
+ *
+ * @author felixw@inin.com
+ */
+class _STLP_atomic_freelist {
+public:
+ /**
+ * Type representing items of the freelist
+ */
+ struct item {
+ item* _M_next;
+ };
+
+ _STLP_atomic_freelist() {
+ // Statically assert layout of member is as expected by assembly code
+ _STLP_STATIC_ASSERT(sizeof(_M) == 8)
+ _M._M_data._M_top = 0;
+ _M._M_data._M_sequence = 0;
+ }
+
+ /**
+ * Atomically pushes the specified item onto the freelist.
+ *
+ * @param __item [in] Item to add to the front of the list
+ */
+ void push(item* __item) {
+ // NOTE: GCC uses ebx as the PIC register for globals in shared libraries.
+ // The GCC version I'm using (3.4.1) won't temporarily spill it if it's
+ // used as input, output, or clobber. Instead, it complains with a
+ // "can't find a register in class `BREG' while reloading `asm'" error.
+ // This is probably a compiler bug, but as the cmpxchg8b instruction
+ // requires ebx, I work around this here by using ecx for the '__item'
+ // input and spilling ebx into edi. This also precludes us from using
+ // a "m" operand for the cmpxchg8b argument (GCC might think it can make
+ // it relative to ebx). Instead, we're using esi for the address of _M_data.
+ //
+ int __tmp1; // These dummy variables are used to tell GCC that the eax, ecx,
+ int __tmp2; // and edx registers will not have the same value as their input.
+ int __tmp3; // The optimizer will remove them as their values are not used.
+ __asm__ __volatile__
+ (" movl %%ebx, %%edi\n\t"
+ " movl %%ecx, %%ebx\n\t"
+ "L1_%=: movl %%eax, (%%ebx)\n\t" // __item._M_next = _M._M_data._M_top
+ " leal 1(%%edx),%%ecx\n\t" // new sequence = _M._M_data._M_sequence + 1
+ "lock; cmpxchg8b (%%esi)\n\t"
+ " jne L1_%=\n\t" // Failed, retry! (edx:eax now contain most recent _M_sequence:_M_top)
+ " movl %%edi, %%ebx"
+ :"=a" (__tmp1), "=d" (__tmp2), "=c" (__tmp3)
+ :"a" (_M._M_data._M_top), "d" (_M._M_data._M_sequence), "c" (__item), "S" (&_M._M_data)
+ :"edi", "memory", "cc");
+ }
+
+ /**
+ * Atomically removes the topmost item from the freelist and returns a
+ * pointer to it. Returns NULL if the list is empty.
+ *
+ * @return Item that was removed from front of list; NULL if list empty
+ */
+ item* pop() {
+ item* __result;
+ int __tmp;
+ __asm__ __volatile__
+ (" movl %%ebx, %%edi\n\t"
+ "L1_%=: testl %%eax, %%eax\n\t" // _M_top == NULL?
+ " je L2_%=\n\t" // If yes, we're done
+ " movl (%%eax), %%ebx\n\t" // new top = _M._M_data._M_top->_M_next
+ " leal 1(%%edx),%%ecx\n\t" // new sequence = _M._M_data._M_sequence + 1
+ "lock; cmpxchg8b (%%esi)\n\t"
+ " jne L1_%=\n\t" // We failed, retry! (edx:eax now contain most recent _M_sequence:_M_top)
+ "L2_%=: movl %%edi, %%ebx"
+ :"=a" (__result), "=d" (__tmp)
+ :"a" (_M._M_data._M_top), "d" (_M._M_data._M_sequence), "S" (&_M._M_data)
+ :"edi", "ecx", "memory", "cc");
+ return __result;
+ }
+
+ /**
+ * Atomically detaches all items from the list and returns a pointer to the
+ * topmost item. The items are still chained and may be traversed safely as
+ * they're now "owned" by the calling thread.
+ *
+ * @return Pointer to topmost item in the list; NULL if list empty
+ */
+ item* clear() {
+ item* __result;
+ int __tmp;
+ __asm__ __volatile__
+ (" movl %%ebx, %%edi\n\t"
+ "L1_%=: testl %%eax, %%eax\n\t" // _M_top == NULL?
+ " je L2_%=\n\t" // If yes, we're done
+ " xorl %%ebx, %%ebx\n\t" // We're attempting to set _M_top to NULL
+ " leal 1(%%edx),%%ecx\n\t" // new sequence = _M._M_data._M_sequence + 1
+ "lock; cmpxchg8b (%%esi)\n\t"
+ " jne L1_%=\n\t" // Failed, retry! (edx:eax now contain most recent _M_sequence:_M_top)
+ "L2_%=: movl %%edi, %%ebx"
+ :"=a" (__result), "=d" (__tmp)
+ :"a" (_M._M_data._M_top), "d" (_M._M_data._M_sequence), "S" (&_M._M_data)
+ :"edi", "ecx", "memory", "cc");
+ return __result;
+ }
+
+private:
+ union {
+ long long _M_align;
+ struct {
+ item* _M_top; // Topmost element in the freelist
+ unsigned int _M_sequence; // Sequence counter to prevent "ABA problem"
+ } _M_data;
+ } _M;
+
+ _STLP_atomic_freelist(const _STLP_atomic_freelist&);
+ _STLP_atomic_freelist& operator=(const _STLP_atomic_freelist&);
+};
+
+# endif /* if defined(__GNUC__) && defined(__i386__) */
+
+#elif defined (_STLP_WIN32THREADS)
+
+# if !defined (_WIN64)
+# define _STLP_USE_ASM_IMPLEMENTATION
+# endif
+
+// Here are the compiler/platform requirements for the thread safe and
+// lock free singly linked list implementation:
+# if defined (_STLP_USE_ASM_IMPLEMENTATION)
+// For the asm version:
+# if defined (_STLP_MSVC) && defined (_M_IX86) && (_M_IX86 >= 500)
+# define _STLP_HAS_ATOMIC_FREELIST
+# endif
+# else
+// For the API based version:
+# if defined (_STLP_NEW_PLATFORM_SDK) && (!defined (WINVER) || (WINVER >= 0x0501)) && \
+ (!defined (_WIN32_WINNT) || (_WIN32_WINNT >= 0x0501))
+# define _STLP_HAS_ATOMIC_FREELIST
+# endif
+# endif
+
+# if defined (_STLP_HAS_ATOMIC_FREELIST)
+# if defined (_STLP_USE_ASM_IMPLEMENTATION)
+# if defined (_STLP_MSVC) && (_STLP_MSVC < 1300) || defined (__ICL)
+# pragma warning (push)
+# pragma warning (disable : 4035) //function has no return value
+# endif
+# endif
+/**
+ * Class that implements a non-blocking and thread-safe freelist.
+ * It is used for the lock-free node allocation engine.
+ *
+ * @author felixw@inin.com
+ */
+class _STLP_atomic_freelist {
+public:
+ /**
+ * Type representing items of the freelist
+ */
+# if defined (_STLP_USE_ASM_IMPLEMENTATION)
+ struct item {
+ item* _M_next;
+ };
+# else
+ typedef SLIST_ENTRY item;
+# endif
+
+ _STLP_atomic_freelist() {
+ // Statically assert layout of member is as expected by assembly code
+# if defined (_STLP_USE_ASM_IMPLEMENTATION)
+ _STLP_STATIC_ASSERT((sizeof(item) == sizeof(item*)) && (sizeof(_M) == 8))
+ _M._M_data._M_top = 0;
+ _M._M_data._M_sequence = 0;
+# else
+ InitializeSListHead(&_M_head);
+# endif
+ }
+
+ /**
+ * Atomically pushes the specified item onto the freelist.
+ *
+ * @param __item [in] Item to add to the front of the list
+ */
+ void push(item* __item) {
+# if defined (_STLP_USE_ASM_IMPLEMENTATION)
+ __asm
+ {
+ mov esi, this
+ mov ebx, __item
+ mov eax, [esi] // _M._M_data._M_top
+ mov edx, [esi+4] // _M._M_data._M_sequence
+ L1: mov [ebx], eax // __item._M_next = _M._M_data._M_top
+ lea ecx, [edx+1] // new sequence = _M._M_data._M_sequence + 1
+ lock cmpxchg8b qword ptr [esi]
+ jne L1 // Failed, retry! (edx:eax now contain most recent _M_sequence:_M_top)
+ }
+# else
+ InterlockedPushEntrySList(&_M_head, __item);
+# endif
+ }
+
+ /**
+ * Atomically removes the topmost item from the freelist and returns a
+ * pointer to it. Returns NULL if the list is empty.
+ *
+ * @return Item that was removed from front of list; NULL if list empty
+ */
+ item* pop() {
+# if defined (_STLP_USE_ASM_IMPLEMENTATION)
+ __asm
+ {
+ mov esi, this
+ mov eax, [esi] // _M._M_data._M_top
+ mov edx, [esi+4] // _M._M_data._M_sequence
+ L1: test eax, eax // _M_top == NULL?
+ je L2 // Yes, we're done
+ mov ebx, [eax] // new top = _M._M_data._M_top->_M_next
+ lea ecx, [edx+1] // new sequence = _M._M_data._M_sequence + 1
+ lock cmpxchg8b qword ptr [esi]
+ jne L1 // Failed, retry! (edx:eax now contain most recent _M_sequence:_M_top)
+ L2:
+ }
+# else
+ return InterlockedPopEntrySList(&_M_head);
+# endif
+ }
+
+ /**
+ * Atomically detaches all items from the list and returns pointer to the
+ * topmost. The items are still chained and may be traversed safely as
+ * they're now "owned" by the calling thread.
+ *
+ * @return Pointer to topmost item in the list; NULL if list empty
+ */
+ item* clear() {
+# if defined (_STLP_USE_ASM_IMPLEMENTATION)
+ __asm
+ {
+ mov esi, this
+ mov eax, [esi] // _M._M_data._M_top
+ mov edx, [esi+4] // _M._M_data._M_sequence
+ L1: test eax, eax // _M_top == NULL?
+ je L2 // Yes, we're done
+ xor ebx,ebx // We're attempting to set _M._M_data._M_top to NULL
+ lea ecx, [edx+1] // new sequence = _M._M_data._M_sequence + 1
+ lock cmpxchg8b qword ptr [esi]
+ jne L1 // Failed, retry! (edx:eax now contain most recent _M_sequence:_M_top)
+ L2:
+ }
+# else
+ return InterlockedFlushSList(&_M_head);
+# endif
+ }
+
+private:
+# if defined (_STLP_USE_ASM_IMPLEMENTATION)
+ union {
+ __int64 _M_align;
+ struct {
+ item* _M_top; // Topmost element in the freelist
+ unsigned int _M_sequence; // Sequence counter to prevent "ABA problem"
+ } _M_data;
+ } _M;
+# else
+ SLIST_HEADER _M_head;
+# endif
+
+ _STLP_atomic_freelist(const _STLP_atomic_freelist&);
+ _STLP_atomic_freelist& operator = (const _STLP_atomic_freelist&);
+};
+
+# if defined (_STLP_USE_ASM_IMPLEMENTATION)
+# if defined (_STLP_MSVC) && (_STLP_MSVC < 1300) || defined (__ICL)
+# pragma warning (pop)
+# endif
+# endif
+
+# endif /* _STLP_HAS_ATOMIC_FREELIST */
+
+#endif
+
+#endif /* _STLP_LOCK_FREE_SLIST_H */
diff --git a/sources/android/stlport/src/message_facets.h b/sources/android/stlport/src/message_facets.h
new file mode 100644
index 0000000..946b529
--- /dev/null
+++ b/sources/android/stlport/src/message_facets.h
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef MESSAGE_FACETS_H
+#define MESSAGE_FACETS_H
+
+#include <string>
+#include <locale>
+#include <hash_map>
+
+#include "c_locale.h"
+
+_STLP_BEGIN_NAMESPACE
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Class _Catalog_locale_map. The reason for this is that, internally,
+// a message string is always a char*. We need a ctype facet to convert
+// a string to and from wchar_t, and the user is permitted to provide such
+// a facet when calling open().
+
+struct _Catalog_locale_map {
+ _Catalog_locale_map() : M(0) {}
+ ~_Catalog_locale_map() { if (M) delete M; }
+
+ void insert(nl_catd_type key, const locale& L);
+ locale lookup(nl_catd_type key) const;
+ void erase(nl_catd_type key);
+
+ typedef hash_map<nl_catd_type, locale, hash<nl_catd_type>, equal_to<nl_catd_type>,
+ allocator<pair<_STLP_CONST nl_catd_type, locale> > > map_type;
+ map_type *M;
+
+private: // Invalidate copy constructor and assignment
+ _Catalog_locale_map(const _Catalog_locale_map&);
+ void operator=(const _Catalog_locale_map&);
+};
+
+/*
+ * In glibc nl_catd type is void *, but messages_base::catalog is defined as int
+ * by ISO/IEC 14882; The int may be too short to store pointer on 64-bit platforms;
+ * Another problem, is that do_open() may return negative value to indicate that no
+ * catalog open---this case can't be represented with pointers.
+ * The class _Catalog_nl_catd_map intended to make relation between
+ * messages_base::catalog and nl_catd handler.
+ *
+ */
+
+#if defined (_STLP_USE_GLIBC2_LOCALIZATION)
+# define _STLP_USE_NL_CATD_MAPPING
+#else
+/* If no mapping a message_base::catalog entry, int typedef according C++ Standard 22.2.7.1,
+ * has to be large enough to contain a nl_catd_type value.
+ */
+_STLP_STATIC_ASSERT(sizeof(nl_catd_type) <= sizeof(int))
+#endif
+
+class _STLP_CLASS_DECLSPEC _Catalog_nl_catd_map {
+public:
+ _Catalog_nl_catd_map()
+ {}
+ ~_Catalog_nl_catd_map()
+ {}
+
+ typedef hash_map<messages_base::catalog, nl_catd_type, hash<messages_base::catalog>, equal_to<messages_base::catalog>,
+ allocator<pair<_STLP_CONST messages_base::catalog, nl_catd_type> > > map_type;
+ typedef hash_map<nl_catd_type, messages_base::catalog, hash<nl_catd_type>, equal_to<nl_catd_type>,
+ allocator<pair<_STLP_CONST nl_catd_type, messages_base::catalog> > > rmap_type;
+ // typedef map<messages_base::catalog,nl_catd_type> map_type;
+ // typedef map<nl_catd_type,messages_base::catalog> rmap_type;
+
+ messages_base::catalog insert(nl_catd_type cat)
+#if !defined (_STLP_USE_NL_CATD_MAPPING)
+ { return (messages_base::catalog)cat; }
+#else
+ ;
+#endif
+
+ void erase(messages_base::catalog)
+#if !defined (_STLP_USE_NL_CATD_MAPPING)
+ {}
+#else
+ ;
+#endif
+
+ nl_catd_type operator [] ( messages_base::catalog cat )
+#if !defined (_STLP_USE_NL_CATD_MAPPING)
+ { return cat; }
+#else
+ { return cat < 0 ? 0 : M[cat]; }
+#endif
+
+private:
+ _Catalog_nl_catd_map(const _Catalog_nl_catd_map&);
+ _Catalog_nl_catd_map& operator =(const _Catalog_nl_catd_map&);
+
+#if defined (_STLP_USE_NL_CATD_MAPPING)
+ map_type M;
+ rmap_type Mr;
+ static _STLP_VOLATILE __stl_atomic_t _count;
+#endif
+};
+
+class _Messages {
+public:
+ typedef messages_base::catalog catalog;
+
+ _Messages(bool, const char *name);
+ _Messages(bool, _Locale_messages*);
+
+ catalog do_open(const string& __fn, const locale& __loc) const;
+ string do_get(catalog __c, int __set, int __msgid,
+ const string& __dfault) const;
+#if !defined (_STLP_NO_WCHAR_T)
+ wstring do_get(catalog __c, int __set, int __msgid,
+ const wstring& __dfault) const;
+#endif
+ void do_close(catalog __c) const;
+ ~_Messages();
+
+private:
+ _Locale_messages* _M_message_obj;
+ _Catalog_locale_map* _M_map;
+ mutable _Catalog_nl_catd_map _M_cat;
+
+ //private definition to avoid warning (with ICL)
+ _Messages(const _Messages&);
+ _Messages& operator=(const _Messages&);
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/src/messages.cpp b/sources/android/stlport/src/messages.cpp
new file mode 100644
index 0000000..ae4669e
--- /dev/null
+++ b/sources/android/stlport/src/messages.cpp
@@ -0,0 +1,247 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#include "stlport_prefix.h"
+
+#include <typeinfo>
+
+#include "message_facets.h"
+#include "acquire_release.h"
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+void _Catalog_locale_map::insert(nl_catd_type key, const locale& L) {
+ _STLP_TRY {
+#if !defined (_STLP_NO_TYPEINFO) && !defined (_STLP_NO_RTTI)
+ // Don't bother to do anything unless we're using a non-default ctype facet
+# ifdef _STLP_NO_WCHAR_T
+ typedef char _Char;
+# else
+ typedef wchar_t _Char;
+# endif
+
+ typedef ctype<_Char> wctype;
+ wctype const& wct = use_facet<wctype>(L);
+ if (typeid(wct) != typeid(wctype)) {
+#endif
+ if (!M)
+ M = new map_type;
+
+ M->insert(map_type::value_type(key, L));
+#if !defined (_STLP_NO_TYPEINFO) && !defined (_STLP_NO_RTTI)
+ }
+#endif
+ }
+ _STLP_CATCH_ALL {}
+}
+
+void _Catalog_locale_map::erase(nl_catd_type key) {
+ if (M)
+ M->erase(key);
+}
+
+locale _Catalog_locale_map::lookup(nl_catd_type key) const {
+ if (M) {
+ map_type::const_iterator i = M->find(key);
+ return i != M->end() ? (*i).second : locale::classic();
+ }
+ else
+ return locale::classic();
+}
+
+
+#if defined (_STLP_USE_NL_CATD_MAPPING)
+_STLP_VOLATILE __stl_atomic_t _Catalog_nl_catd_map::_count = 0;
+
+messages_base::catalog _Catalog_nl_catd_map::insert(nl_catd_type cat) {
+ messages_base::catalog &res = Mr[cat];
+ if ( res == 0 ) {
+#if defined (_STLP_ATOMIC_INCREMENT)
+ res = __STATIC_CAST(int, _STLP_ATOMIC_INCREMENT(&_count));
+#else
+ static _STLP_STATIC_MUTEX _Count_lock _STLP_MUTEX_INITIALIZER;
+ {
+ _STLP_auto_lock sentry(_Count_lock);
+ res = __STATIC_CAST(int, ++_count);
+ }
+#endif
+ M[res] = cat;
+ }
+ return res;
+}
+
+void _Catalog_nl_catd_map::erase(messages_base::catalog cat) {
+ map_type::iterator mit(M.find(cat));
+ if (mit != M.end()) {
+ Mr.erase((*mit).second);
+ M.erase(mit);
+ }
+}
+#endif
+
+//----------------------------------------------------------------------
+//
+_Messages::_Messages(bool is_wide, const char *name) :
+ _M_message_obj(0), _M_map(0) {
+ if (!name)
+ locale::_M_throw_on_null_name();
+
+ int __err_code;
+ char buf[_Locale_MAX_SIMPLE_NAME];
+ _M_message_obj = _STLP_PRIV __acquire_messages(name, buf, 0, &__err_code);
+ if (!_M_message_obj)
+ locale::_M_throw_on_creation_failure(__err_code, name, "messages");
+
+ if (is_wide)
+ _M_map = new _Catalog_locale_map;
+}
+
+_Messages::_Messages(bool is_wide, _Locale_messages* msg) :
+ _M_message_obj(msg), _M_map(is_wide ? new _Catalog_locale_map() : 0)
+{}
+
+_Messages::~_Messages() {
+ __release_messages(_M_message_obj);
+ delete _M_map;
+}
+
+_Messages::catalog _Messages::do_open(const string& filename, const locale& L) const {
+ nl_catd_type result = _M_message_obj ? _Locale_catopen(_M_message_obj, filename.c_str())
+ : (nl_catd_type)(-1);
+
+ if ( result != (nl_catd_type)(-1) ) {
+ if ( _M_map != 0 ) {
+ _M_map->insert(result, L);
+ }
+ return _STLP_MUTABLE(_Messages_impl, _M_cat).insert( result );
+ }
+
+ return -1;
+}
+
+string _Messages::do_get(catalog cat,
+ int set, int p_id, const string& dfault) const {
+ return _M_message_obj != 0 && cat >= 0
+ ? string(_Locale_catgets(_M_message_obj, _STLP_MUTABLE(_Messages_impl, _M_cat)[cat],
+ set, p_id, dfault.c_str()))
+ : dfault;
+}
+
+#if !defined (_STLP_NO_WCHAR_T)
+
+wstring
+_Messages::do_get(catalog thecat,
+ int set, int p_id, const wstring& dfault) const {
+ typedef ctype<wchar_t> wctype;
+ const wctype& ct = use_facet<wctype>(_M_map->lookup(_STLP_MUTABLE(_Messages_impl, _M_cat)[thecat]));
+
+ const char* str = _Locale_catgets(_M_message_obj, _STLP_MUTABLE(_Messages_impl, _M_cat)[thecat], set, p_id, "");
+
+ // Verify that the lookup failed; an empty string might represent success.
+ if (!str)
+ return dfault;
+ else if (str[0] == '\0') {
+ const char* str2 = _Locale_catgets(_M_message_obj, _STLP_MUTABLE(_Messages_impl, _M_cat)[thecat], set, p_id, "*");
+ if (!str2 || ((str2[0] == '*') && (str2[1] == '\0')))
+ return dfault;
+ }
+
+ // str is correct. Now we must widen it to get a wstring.
+ size_t n = strlen(str);
+
+ // NOT PORTABLE. What we're doing relies on internal details of the
+ // string implementation. (Contiguity of string elements.)
+ wstring result(n, wchar_t(0));
+ ct.widen(str, str + n, &*result.begin());
+ return result;
+}
+
+#endif
+
+void _Messages::do_close(catalog thecat) const {
+ if (_M_message_obj)
+ _Locale_catclose(_M_message_obj, _STLP_MUTABLE(_Messages_impl, _M_cat)[thecat]);
+ if (_M_map) _M_map->erase(_STLP_MUTABLE(_Messages_impl, _M_cat)[thecat]);
+ _STLP_MUTABLE(_Messages_impl, _M_cat).erase( thecat );
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+//----------------------------------------------------------------------
+// messages<char>
+messages<char>::messages(size_t refs)
+ : locale::facet(refs) {}
+
+messages_byname<char>::messages_byname(const char *name, size_t refs)
+ : messages<char>(refs), _M_impl(new _STLP_PRIV _Messages(false, name)) {}
+
+messages_byname<char>::messages_byname(_Locale_messages* msg)
+ : messages<char>(0), _M_impl(new _STLP_PRIV _Messages(false, msg)) {}
+
+messages_byname<char>::~messages_byname()
+{ delete _M_impl; }
+
+messages_byname<char>::catalog
+messages_byname<char>::do_open(const string& filename, const locale& l) const
+{ return _M_impl->do_open(filename, l); }
+
+string
+messages_byname<char>::do_get(catalog cat, int set, int p_id,
+ const string& dfault) const
+{ return _M_impl->do_get(cat, set, p_id, dfault); }
+
+void messages_byname<char>::do_close(catalog cat) const
+{ _M_impl->do_close(cat); }
+
+#if !defined (_STLP_NO_WCHAR_T)
+
+//----------------------------------------------------------------------
+// messages<wchar_t>
+
+messages<wchar_t>::messages(size_t refs)
+ : locale::facet(refs) {}
+
+messages_byname<wchar_t>::messages_byname(const char *name, size_t refs)
+ : messages<wchar_t>(refs), _M_impl(new _STLP_PRIV _Messages(true, name)) {}
+
+messages_byname<wchar_t>::messages_byname(_Locale_messages* msg)
+ : messages<wchar_t>(0), _M_impl(new _STLP_PRIV _Messages(true, msg)) {}
+
+messages_byname<wchar_t>::~messages_byname()
+{ delete _M_impl; }
+
+messages_byname<wchar_t>::catalog
+messages_byname<wchar_t>::do_open(const string& filename, const locale& L) const
+{ return _M_impl->do_open(filename, L); }
+
+wstring
+messages_byname<wchar_t>::do_get(catalog thecat,
+ int set, int p_id, const wstring& dfault) const
+{ return _M_impl->do_get(thecat, set, p_id, dfault); }
+
+void messages_byname<wchar_t>::do_close(catalog cat) const
+{ _M_impl->do_close(cat); }
+
+#endif
+
+_STLP_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/src/monetary.cpp b/sources/android/stlport/src/monetary.cpp
new file mode 100644
index 0000000..d9b213a
--- /dev/null
+++ b/sources/android/stlport/src/monetary.cpp
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#include "stlport_prefix.h"
+
+#include <locale>
+#include <istream>
+
+_STLP_BEGIN_NAMESPACE
+
+static void _Init_monetary_formats(money_base::pattern& pos_format,
+ money_base::pattern& neg_format) {
+ pos_format.field[0] = (char) money_base::symbol;
+ pos_format.field[1] = (char) money_base::sign;
+ pos_format.field[2] = (char) money_base::none;
+ pos_format.field[3] = (char) money_base::value;
+
+ neg_format.field[0] = (char) money_base::symbol;
+ neg_format.field[1] = (char) money_base::sign;
+ neg_format.field[2] = (char) money_base::none;
+ neg_format.field[3] = (char) money_base::value;
+}
+
+// This is being used throughout the library
+static const string _S_empty_string;
+#ifndef _STLP_NO_WCHAR_T
+static const wstring _S_empty_wstring;
+#endif
+
+//
+// moneypunct<>
+//
+
+moneypunct<char, true>::moneypunct(size_t __refs) : locale::facet(__refs)
+{ _Init_monetary_formats(_M_pos_format, _M_neg_format); }
+moneypunct<char, true>::~moneypunct() {}
+
+char moneypunct<char, true>::do_decimal_point() const {return ' ';}
+char moneypunct<char, true>::do_thousands_sep() const {return ' ';}
+string moneypunct<char, true>::do_grouping() const { return _S_empty_string; }
+string moneypunct<char, true>::do_curr_symbol() const { return _S_empty_string; }
+string moneypunct<char, true>::do_positive_sign() const { return _S_empty_string; }
+string moneypunct<char, true>::do_negative_sign() const { return _S_empty_string; }
+money_base::pattern moneypunct<char, true>::do_pos_format() const {return _M_pos_format;}
+money_base::pattern moneypunct<char, true>::do_neg_format() const {return _M_neg_format;}
+int moneypunct<char, true>::do_frac_digits() const {return 0;}
+
+moneypunct<char, false>::moneypunct(size_t __refs) : locale::facet(__refs)
+{ _Init_monetary_formats(_M_pos_format, _M_neg_format); }
+moneypunct<char, false>::~moneypunct() {}
+
+char moneypunct<char, false>::do_decimal_point() const {return ' ';}
+char moneypunct<char, false>::do_thousands_sep() const {return ' ';}
+
+string moneypunct<char, false>::do_grouping() const { return _S_empty_string; }
+string moneypunct<char, false>::do_curr_symbol() const { return _S_empty_string; }
+string moneypunct<char, false>::do_positive_sign() const { return _S_empty_string; }
+string moneypunct<char, false>::do_negative_sign() const { return _S_empty_string; }
+money_base::pattern moneypunct<char, false>::do_pos_format() const {return _M_pos_format;}
+money_base::pattern moneypunct<char, false>::do_neg_format() const {return _M_neg_format;}
+int moneypunct<char, false>::do_frac_digits() const {return 0;}
+
+#ifndef _STLP_NO_WCHAR_T
+moneypunct<wchar_t, true>::moneypunct(size_t __refs) : locale::facet(__refs)
+{ _Init_monetary_formats(_M_pos_format, _M_neg_format); }
+moneypunct<wchar_t, true>::~moneypunct() {}
+
+wchar_t moneypunct<wchar_t, true>::do_decimal_point() const {return L' ';}
+wchar_t moneypunct<wchar_t, true>::do_thousands_sep() const {return L' ';}
+string moneypunct<wchar_t, true>::do_grouping() const {return _S_empty_string;}
+
+wstring moneypunct<wchar_t, true>::do_curr_symbol() const
+{return _S_empty_wstring;}
+wstring moneypunct<wchar_t, true>::do_positive_sign() const
+{return _S_empty_wstring;}
+wstring moneypunct<wchar_t, true>::do_negative_sign() const
+{return _S_empty_wstring;}
+int moneypunct<wchar_t, true>::do_frac_digits() const {return 0;}
+money_base::pattern moneypunct<wchar_t, true>::do_pos_format() const
+{return _M_pos_format;}
+money_base::pattern moneypunct<wchar_t, true>::do_neg_format() const
+{return _M_neg_format;}
+
+moneypunct<wchar_t, false>::moneypunct(size_t __refs) : locale::facet(__refs)
+{ _Init_monetary_formats(_M_pos_format, _M_neg_format); }
+moneypunct<wchar_t, false>::~moneypunct() {}
+
+wchar_t moneypunct<wchar_t, false>::do_decimal_point() const {return L' ';}
+wchar_t moneypunct<wchar_t, false>::do_thousands_sep() const {return L' ';}
+string moneypunct<wchar_t, false>::do_grouping() const { return _S_empty_string;}
+wstring moneypunct<wchar_t, false>::do_curr_symbol() const
+{return _S_empty_wstring;}
+wstring moneypunct<wchar_t, false>::do_positive_sign() const
+{return _S_empty_wstring;}
+wstring moneypunct<wchar_t, false>::do_negative_sign() const
+{return _S_empty_wstring;}
+int moneypunct<wchar_t, false>::do_frac_digits() const {return 0;}
+
+money_base::pattern moneypunct<wchar_t, false>::do_pos_format() const
+{return _M_pos_format;}
+money_base::pattern moneypunct<wchar_t, false>::do_neg_format() const
+{return _M_neg_format;}
+
+#endif /* WCHAR_T */
+
+//
+// Instantiations
+//
+
+#if !defined (_STLP_NO_FORCE_INSTANTIATE)
+
+template class _STLP_CLASS_DECLSPEC money_get<char, istreambuf_iterator<char, char_traits<char> > >;
+template class _STLP_CLASS_DECLSPEC money_put<char, ostreambuf_iterator<char, char_traits<char> > >;
+// template class money_put<char, char*>;
+
+# ifndef _STLP_NO_WCHAR_T
+template class _STLP_CLASS_DECLSPEC money_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
+template class _STLP_CLASS_DECLSPEC money_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
+// template class money_put<wchar_t, wchar_t*>;
+// template class money_get<wchar_t, const wchar_t*>;
+# endif
+
+#endif
+
+#if !defined (_STLP_STATIC_CONST_INIT_BUG) && !defined (_STLP_NO_STATIC_CONST_DEFINITION)
+const bool moneypunct<char, true>::intl;
+const bool moneypunct<char, false>::intl;
+# ifndef _STLP_NO_WCHAR_T
+const bool moneypunct<wchar_t, true>::intl;
+const bool moneypunct<wchar_t, false>::intl;
+# endif
+#endif
+
+_STLP_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/src/num_get.cpp b/sources/android/stlport/src/num_get.cpp
new file mode 100644
index 0000000..45901ac
--- /dev/null
+++ b/sources/android/stlport/src/num_get.cpp
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#include "stlport_prefix.h"
+
+#include <locale>
+#include <istream>
+#include <algorithm>
+
+_STLP_BEGIN_NAMESPACE
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// __valid_grouping compares two strings, one representing the
+// group sizes encountered when reading an integer, and the other
+// representing the valid group sizes as returned by the numpunct
+// grouping() member function. Both are interpreted right-to-left.
+// The grouping string is treated as if it were extended indefinitely
+// with its last value. For a grouping to be valid, each term in
+// the first string must be equal to the corresponding term in the
+// second, except for the last, which must be less than or equal.
+
+// boris : this takes reversed first string !
+bool _STLP_CALL
+__valid_grouping(const char * first1, const char * last1,
+ const char * first2, const char * last2) {
+ if (first1 == last1 || first2 == last2) return true;
+
+ --last1; --last2;
+
+ while (first1 != last1) {
+ if (*last1 != *first2)
+ return false;
+ --last1;
+ if (first2 != last2) ++first2;
+ }
+
+ return *last1 <= *first2;
+}
+
+_STLP_DECLSPEC unsigned char _STLP_CALL __digit_val_table(unsigned __index) {
+ static const unsigned char __val_table[128] = {
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,10,11,12,13,14,15,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,10,11,12,13,14,15,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
+ };
+
+ return __val_table[__index];
+}
+
+_STLP_DECLSPEC const char* _STLP_CALL __narrow_atoms()
+{ return "+-0xX"; }
+
+// index is actually a char
+
+#if !defined (_STLP_NO_WCHAR_T)
+
+// Similar, except return the character itself instead of the numeric
+// value. Used for floating-point input.
+bool _STLP_CALL __get_fdigit(wchar_t& c, const wchar_t* digits) {
+ const wchar_t* p = find(digits, digits + 10, c);
+ if (p != digits + 10) {
+ c = (char)('0' + (p - digits));
+ return true;
+ }
+ else
+ return false;
+}
+
+bool _STLP_CALL __get_fdigit_or_sep(wchar_t& c, wchar_t sep,
+ const wchar_t * digits) {
+ if (c == sep) {
+ c = (char)',';
+ return true;
+ }
+ else
+ return __get_fdigit(c, digits);
+}
+
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#if !defined(_STLP_NO_FORCE_INSTANTIATE)
+//----------------------------------------------------------------------
+// Force instantiation of num_get<>
+template class _STLP_CLASS_DECLSPEC istreambuf_iterator<char, char_traits<char> >;
+// template class num_get<char, const char*>;
+template class num_get<char, istreambuf_iterator<char, char_traits<char> > >;
+
+# if !defined (_STLP_NO_WCHAR_T)
+template class _STLP_CLASS_DECLSPEC istreambuf_iterator<wchar_t, char_traits<wchar_t> >;
+template class num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
+// template class num_get<wchar_t, const wchar_t*>;
+# endif
+#endif
+
+_STLP_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/src/num_get_float.cpp b/sources/android/stlport/src/num_get_float.cpp
new file mode 100644
index 0000000..63e9fed
--- /dev/null
+++ b/sources/android/stlport/src/num_get_float.cpp
@@ -0,0 +1,884 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#include "stlport_prefix.h"
+
+#include <limits>
+#include <locale>
+#include <istream>
+
+#if (defined (__GNUC__) && !defined (__sun) && !defined (__hpux)) || \
+ defined (__DMC__)
+# include <stdint.h>
+#endif
+
+#if defined (__linux__) || defined (__MINGW32__) || defined (__CYGWIN__) || \
+ defined (__BORLANDC__) || defined (__DMC__) || defined (__HP_aCC)
+
+# if defined (__BORLANDC__)
+typedef unsigned int uint32_t;
+typedef unsigned __int64 uint64_t;
+# endif
+
+union _ll {
+ uint64_t i64;
+ struct {
+# if defined (_STLP_BIG_ENDIAN)
+ uint32_t hi;
+ uint32_t lo;
+# elif defined (_STLP_LITTLE_ENDIAN)
+ uint32_t lo;
+ uint32_t hi;
+# else
+# error Unknown endianess
+# endif
+ } i32;
+};
+
+# if defined (__linux__) && !defined (ANDROID)
+# include <ieee754.h>
+# else
+union ieee854_long_double {
+ long double d;
+
+ /* This is the IEEE 854 double-extended-precision format. */
+ struct {
+ unsigned int mantissa1:32;
+ unsigned int mantissa0:32;
+ unsigned int exponent:15;
+ unsigned int negative:1;
+ unsigned int empty:16;
+ } ieee;
+};
+
+# define IEEE854_LONG_DOUBLE_BIAS 0x3fff
+# endif
+#endif
+
+_STLP_BEGIN_NAMESPACE
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+//----------------------------------------------------------------------
+// num_get
+
+// Helper functions for _M_do_get_float.
+
+#if !defined (_STLP_NO_WCHAR_T)
+void _STLP_CALL
+_Initialize_get_float( const ctype<wchar_t>& ct,
+ wchar_t& Plus, wchar_t& Minus,
+ wchar_t& pow_e, wchar_t& pow_E,
+ wchar_t* digits) {
+ char ndigits[11] = "0123456789";
+ Plus = ct.widen('+');
+ Minus = ct.widen('-');
+ pow_e = ct.widen('e');
+ pow_E = ct.widen('E');
+ ct.widen(ndigits + 0, ndigits + 10, digits);
+}
+#endif /* WCHAR_T */
+
+/*
+ * __string_to_double is just lifted from atof, the difference being
+ * that we just use '.' for the decimal point, rather than let it
+ * be taken from the current C locale, which of course is not accessible
+ * to us.
+ */
+#if defined (_STLP_MSVC) || defined (__BORLANDC__) || defined (__ICL)
+typedef unsigned long uint32;
+typedef unsigned __int64 uint64;
+# define ULL(x) x##Ui64
+#elif defined (__unix) || defined (__MINGW32__) || \
+ (defined (__DMC__) && (__LONGLONG)) || defined (__WATCOMC__) || \
+ defined (ANDROID)
+typedef uint32_t uint32;
+typedef uint64_t uint64;
+# define ULL(x) x##ULL
+#else
+# error There should be some unsigned 64-bit integer on the system!
+#endif
+
+// Multiplication of two 64-bit integers, giving a 128-bit result.
+// Taken from Algorithm M in Knuth section 4.3.1, with the loop
+// hand-unrolled.
+static void _Stl_mult64(const uint64 u, const uint64 v,
+ uint64& high, uint64& low) {
+ const uint64 low_mask = ULL(0xffffffff);
+ const uint64 u0 = u & low_mask;
+ const uint64 u1 = u >> 32;
+ const uint64 v0 = v & low_mask;
+ const uint64 v1 = v >> 32;
+
+ uint64 t = u0 * v0;
+ low = t & low_mask;
+
+ t = u1 * v0 + (t >> 32);
+ uint64 w1 = t & low_mask;
+ uint64 w2 = t >> 32;
+
+ uint64 x = u0 * v1 + w1;
+ low += (x & low_mask) << 32;
+ high = u1 * v1 + w2 + (x >> 32);
+}
+
+#if !defined (__linux__) || defined (ANDROID)
+
+# define bit11 ULL(0x7ff)
+# define exponent_mask (bit11 << 52)
+
+# if !defined (__GNUC__) || (__GNUC__ != 3) || (__GNUC_MINOR__ != 4) || \
+ (!defined (__CYGWIN__) && !defined (__MINGW32__))
+//Generate bad code when compiled with -O2 option.
+inline
+# endif
+void _Stl_set_exponent(uint64 &val, uint64 exp)
+{ val = (val & ~exponent_mask) | ((exp & bit11) << 52); }
+
+#endif // __linux__
+
+/* Power of ten fractions for tenscale*/
+/* The constants are factored so that at most two constants
+ * and two multiplies are needed. Furthermore, one of the constants
+ * is represented exactly - 10**n where 1<= n <= 27.
+ */
+
+static const uint64 _Stl_tenpow[80] = {
+ULL(0xa000000000000000), /* _Stl_tenpow[0]=(10**1)/(2**4) */
+ULL(0xc800000000000000), /* _Stl_tenpow[1]=(10**2)/(2**7) */
+ULL(0xfa00000000000000), /* _Stl_tenpow[2]=(10**3)/(2**10) */
+ULL(0x9c40000000000000), /* _Stl_tenpow[3]=(10**4)/(2**14) */
+ULL(0xc350000000000000), /* _Stl_tenpow[4]=(10**5)/(2**17) */
+ULL(0xf424000000000000), /* _Stl_tenpow[5]=(10**6)/(2**20) */
+ULL(0x9896800000000000), /* _Stl_tenpow[6]=(10**7)/(2**24) */
+ULL(0xbebc200000000000), /* _Stl_tenpow[7]=(10**8)/(2**27) */
+ULL(0xee6b280000000000), /* _Stl_tenpow[8]=(10**9)/(2**30) */
+ULL(0x9502f90000000000), /* _Stl_tenpow[9]=(10**10)/(2**34) */
+ULL(0xba43b74000000000), /* _Stl_tenpow[10]=(10**11)/(2**37) */
+ULL(0xe8d4a51000000000), /* _Stl_tenpow[11]=(10**12)/(2**40) */
+ULL(0x9184e72a00000000), /* _Stl_tenpow[12]=(10**13)/(2**44) */
+ULL(0xb5e620f480000000), /* _Stl_tenpow[13]=(10**14)/(2**47) */
+ULL(0xe35fa931a0000000), /* _Stl_tenpow[14]=(10**15)/(2**50) */
+ULL(0x8e1bc9bf04000000), /* _Stl_tenpow[15]=(10**16)/(2**54) */
+ULL(0xb1a2bc2ec5000000), /* _Stl_tenpow[16]=(10**17)/(2**57) */
+ULL(0xde0b6b3a76400000), /* _Stl_tenpow[17]=(10**18)/(2**60) */
+ULL(0x8ac7230489e80000), /* _Stl_tenpow[18]=(10**19)/(2**64) */
+ULL(0xad78ebc5ac620000), /* _Stl_tenpow[19]=(10**20)/(2**67) */
+ULL(0xd8d726b7177a8000), /* _Stl_tenpow[20]=(10**21)/(2**70) */
+ULL(0x878678326eac9000), /* _Stl_tenpow[21]=(10**22)/(2**74) */
+ULL(0xa968163f0a57b400), /* _Stl_tenpow[22]=(10**23)/(2**77) */
+ULL(0xd3c21bcecceda100), /* _Stl_tenpow[23]=(10**24)/(2**80) */
+ULL(0x84595161401484a0), /* _Stl_tenpow[24]=(10**25)/(2**84) */
+ULL(0xa56fa5b99019a5c8), /* _Stl_tenpow[25]=(10**26)/(2**87) */
+ULL(0xcecb8f27f4200f3a), /* _Stl_tenpow[26]=(10**27)/(2**90) */
+
+ULL(0xd0cf4b50cfe20766), /* _Stl_tenpow[27]=(10**55)/(2**183) */
+ULL(0xd2d80db02aabd62c), /* _Stl_tenpow[28]=(10**83)/(2**276) */
+ULL(0xd4e5e2cdc1d1ea96), /* _Stl_tenpow[29]=(10**111)/(2**369) */
+ULL(0xd6f8d7509292d603), /* _Stl_tenpow[30]=(10**139)/(2**462) */
+ULL(0xd910f7ff28069da4), /* _Stl_tenpow[31]=(10**167)/(2**555) */
+ULL(0xdb2e51bfe9d0696a), /* _Stl_tenpow[32]=(10**195)/(2**648) */
+ULL(0xdd50f1996b947519), /* _Stl_tenpow[33]=(10**223)/(2**741) */
+ULL(0xdf78e4b2bd342cf7), /* _Stl_tenpow[34]=(10**251)/(2**834) */
+ULL(0xe1a63853bbd26451), /* _Stl_tenpow[35]=(10**279)/(2**927) */
+ULL(0xe3d8f9e563a198e5), /* _Stl_tenpow[36]=(10**307)/(2**1020) */
+
+// /* _Stl_tenpow[36]=(10**335)/(2**) */
+// /* _Stl_tenpow[36]=(10**335)/(2**) */
+
+ULL(0xfd87b5f28300ca0e), /* _Stl_tenpow[37]=(10**-28)/(2**-93) */
+ULL(0xfb158592be068d2f), /* _Stl_tenpow[38]=(10**-56)/(2**-186) */
+ULL(0xf8a95fcf88747d94), /* _Stl_tenpow[39]=(10**-84)/(2**-279) */
+ULL(0xf64335bcf065d37d), /* _Stl_tenpow[40]=(10**-112)/(2**-372) */
+ULL(0xf3e2f893dec3f126), /* _Stl_tenpow[41]=(10**-140)/(2**-465) */
+ULL(0xf18899b1bc3f8ca2), /* _Stl_tenpow[42]=(10**-168)/(2**-558) */
+ULL(0xef340a98172aace5), /* _Stl_tenpow[43]=(10**-196)/(2**-651) */
+ULL(0xece53cec4a314ebe), /* _Stl_tenpow[44]=(10**-224)/(2**-744) */
+ULL(0xea9c227723ee8bcb), /* _Stl_tenpow[45]=(10**-252)/(2**-837) */
+ULL(0xe858ad248f5c22ca), /* _Stl_tenpow[46]=(10**-280)/(2**-930) */
+ULL(0xe61acf033d1a45df), /* _Stl_tenpow[47]=(10**-308)/(2**-1023) */
+ULL(0xe3e27a444d8d98b8), /* _Stl_tenpow[48]=(10**-336)/(2**-1116) */
+ULL(0xe1afa13afbd14d6e) /* _Stl_tenpow[49]=(10**-364)/(2**-1209) */
+};
+
+static const short _Stl_twoexp[80] = {
+4,7,10,14,17,20,24,27,30,34,37,40,44,47,50,54,57,60,64,67,70,74,77,80,84,87,90,
+183,276,369,462,555,648,741,834,927,1020,
+-93,-186,-279,-372,-465,-558,-651,-744,-837,-930,-1023,-1116,-1209
+};
+
+#define TEN_1 0 /* offset to 10 ** 1 */
+#define TEN_27 26 /* offset to 10 ** 27 */
+#define TEN_M28 37 /* offset to 10 ** -28 */
+#define NUM_HI_P 11
+#define NUM_HI_N 13
+
+#define _Stl_HIBITULL (ULL(1) << 63)
+
+static void _Stl_norm_and_round(uint64& p, int& norm, uint64 prodhi, uint64 prodlo) {
+ norm = 0;
+ if ((prodhi & _Stl_HIBITULL) == 0) {
+ /* leading bit is a zero
+ * may have to normalize
+ */
+ if ((prodhi == ~_Stl_HIBITULL) &&
+ ((prodlo >> 62) == 0x3)) { /* normalization followed by round
+ * would cause carry to create
+ * extra bit, so don't normalize
+ */
+ p = _Stl_HIBITULL;
+ return;
+ }
+ p = (prodhi << 1) | (prodlo >> 63); /* normalize */
+ norm = 1;
+ prodlo <<= 1;
+ }
+ else {
+ p = prodhi;
+ }
+
+ if ((prodlo & _Stl_HIBITULL) != 0) { /* first guard bit a one */
+ if (((p & 0x1) != 0) ||
+ prodlo != _Stl_HIBITULL ) { /* not borderline for round to even */
+ /* round */
+ ++p;
+ if (p == 0)
+ ++p;
+ }
+ }
+}
+
+// Convert a 64-bitb fraction * 10^exp to a 64-bit fraction * 2^bexp.
+// p: 64-bit fraction
+// exp: base-10 exponent
+// bexp: base-2 exponent (output parameter)
+static void _Stl_tenscale(uint64& p, int exp, int& bexp) {
+ bexp = 0;
+
+ if ( exp == 0 ) { /* no scaling needed */
+ return;
+ }
+
+ int exp_hi = 0, exp_lo = exp; /* exp = exp_hi*32 + exp_lo */
+ int tlo = TEN_1, thi; /* offsets in power of ten table */
+ int num_hi; /* number of high exponent powers */
+
+ if (exp > 0) { /* split exponent */
+ if (exp_lo > 27) {
+ exp_lo++;
+ while (exp_lo > 27) {
+ exp_hi++;
+ exp_lo -= 28;
+ }
+ }
+ thi = TEN_27;
+ num_hi = NUM_HI_P;
+ } else { // exp < 0
+ while (exp_lo < 0) {
+ exp_hi++;
+ exp_lo += 28;
+ }
+ thi = TEN_M28;
+ num_hi = NUM_HI_N;
+ }
+
+ uint64 prodhi, prodlo; /* 128b product */
+ int norm; /* number of bits of normalization */
+
+ int hi, lo; /* offsets in power of ten table */
+ while (exp_hi) { /* scale */
+ hi = (min) (exp_hi, num_hi); /* only a few large powers of 10 */
+ exp_hi -= hi; /* could iterate in extreme case */
+ hi += thi-1;
+ _Stl_mult64(p, _Stl_tenpow[hi], prodhi, prodlo);
+ _Stl_norm_and_round(p, norm, prodhi, prodlo);
+ bexp += _Stl_twoexp[hi] - norm;
+ }
+
+ if (exp_lo) {
+ lo = tlo + exp_lo -1;
+ _Stl_mult64(p, _Stl_tenpow[lo], prodhi, prodlo);
+ _Stl_norm_and_round(p, norm, prodhi, prodlo);
+ bexp += _Stl_twoexp[lo] - norm;
+ }
+
+ return;
+}
+
+// First argument is a buffer of values from 0 to 9, NOT ascii.
+// Second argument is number of digits in buffer, 1 <= digits <= 17.
+// Third argument is base-10 exponent.
+
+/* IEEE representation */
+#if !defined (__linux__) || defined (ANDROID)
+
+union _Double_rep {
+ uint64 ival;
+ double val;
+};
+
+static double _Stl_atod(char *buffer, ptrdiff_t ndigit, int dexp) {
+ typedef numeric_limits<double> limits;
+ _Double_rep drep;
+ uint64 &value = drep.ival; /* Value develops as follows:
+ * 1) decimal digits as an integer
+ * 2) left adjusted fraction
+ * 3) right adjusted fraction
+ * 4) exponent and fraction
+ */
+
+ uint32 guard; /* First guard bit */
+ uint64 rest; /* Remaining guard bits */
+
+ int bexp; /* binary exponent */
+ int nzero; /* number of non-zero bits */
+ int sexp; /* scaling exponent */
+
+ char *bufferend; /* pointer to char after last digit */
+
+ /* Convert the decimal digits to a binary integer. */
+ bufferend = buffer + ndigit;
+ value = 0;
+
+ while (buffer < bufferend) {
+ value *= 10;
+ value += *buffer++;
+ }
+
+ /* Check for zero and treat it as a special case */
+ if (value == 0) {
+ return 0.0;
+ }
+
+ /* Normalize value */
+ bexp = 64; /* convert from 64b int to fraction */
+
+ /* Count number of non-zeroes in value */
+ nzero = 0;
+ if ((value >> 32) != 0) { nzero = 32; } //*TY 03/25/2000 - added explicit comparison to zero to avoid uint64 to bool conversion operator
+ if ((value >> (16 + nzero)) != 0) { nzero += 16; }
+ if ((value >> ( 8 + nzero)) != 0) { nzero += 8; }
+ if ((value >> ( 4 + nzero)) != 0) { nzero += 4; }
+ if ((value >> ( 2 + nzero)) != 0) { nzero += 2; }
+ if ((value >> ( 1 + nzero)) != 0) { nzero += 1; }
+ if ((value >> ( nzero)) != 0) { nzero += 1; }
+
+ /* Normalize */
+ value <<= /*(uint64)*/ (64 - nzero); //*TY 03/25/2000 - removed extraneous cast to uint64
+ bexp -= 64 - nzero;
+
+ /* At this point we have a 64b fraction and a binary exponent
+ * but have yet to incorporate the decimal exponent.
+ */
+
+ /* multiply by 10^dexp */
+ _Stl_tenscale(value, dexp, sexp);
+ bexp += sexp;
+
+ if (bexp <= -1022) { /* HI denorm or underflow */
+ bexp += 1022;
+ if (bexp < -53) { /* guaranteed underflow */
+ value = 0;
+ }
+ else { /* denorm or possible underflow */
+ int lead0 = 12 - bexp; /* 12 sign and exponent bits */
+
+ /* we must special case right shifts of more than 63 */
+ if (lead0 > 64) {
+ rest = value;
+ guard = 0;
+ value = 0;
+ }
+ else if (lead0 == 64) {
+ rest = value & ((ULL(1)<< 63)-1);
+ guard = (uint32) ((value>> 63) & 1 );
+ value = 0;
+ }
+ else {
+ rest = value & (((ULL(1) << lead0)-1)-1);
+ guard = (uint32) (((value>> lead0)-1) & 1);
+ value >>= /*(uint64)*/ lead0; /* exponent is zero */
+ }
+
+ /* Round */
+ if (guard && ((value & 1) || rest) ) {
+ ++value;
+ if (value == (ULL(1) << (limits::digits - 1))) { /* carry created normal number */
+ value = 0;
+ _Stl_set_exponent(value, 1);
+ }
+ }
+ }
+ }
+ else { /* not zero or denorm */
+ /* Round to 53 bits */
+ rest = value & ((1 << 10) - 1);
+ value >>= 10;
+ guard = (uint32) value & 1;
+ value >>= 1;
+
+ /* value&1 guard rest Action
+ *
+ * dc 0 dc none
+ * 1 1 dc round
+ * 0 1 0 none
+ * 0 1 !=0 round
+ */
+ if (guard) {
+ if (((value&1)!=0) || (rest!=0)) {
+ ++value; /* round */
+ if ((value >> 53) != 0) { /* carry all the way across */
+ value >>= 1; /* renormalize */
+ ++bexp;
+ }
+ }
+ }
+ /*
+ * Check for overflow
+ * IEEE Double Precision Format
+ * (From Table 7-8 of Kane and Heinrich)
+ *
+ * Fraction bits 52
+ * Emax +1023
+ * Emin -1022
+ * Exponent bias +1023
+ * Exponent bits 11
+ * Integer bit hidden
+ * Total width in bits 64
+ */
+
+ if (bexp > limits::max_exponent) { /* overflow */
+ return limits::infinity();
+ }
+ else { /* value is normal */
+ value &= ~(ULL(1) << (limits::digits - 1)); /* hide hidden bit */
+ _Stl_set_exponent(value, bexp + 1022); /* add bias */
+ }
+ }
+
+ _STLP_STATIC_ASSERT(sizeof(uint64) >= sizeof(double))
+ return drep.val;
+}
+
+#endif
+
+#if defined (__linux__) || defined (__MINGW32__) || defined (__CYGWIN__) || \
+ defined (__BORLANDC__) || defined (__DMC__) || defined (__HP_aCC)
+
+template <class D, class IEEE, int M, int BIAS>
+D _Stl_atodT(char *buffer, ptrdiff_t ndigit, int dexp)
+{
+ typedef numeric_limits<D> limits;
+
+ /* Convert the decimal digits to a binary integer. */
+ char *bufferend = buffer + ndigit; /* pointer to char after last digit */
+ _ll vv;
+ vv.i64 = 0L;
+
+ while ( buffer < bufferend ) {
+ vv.i64 *= 10;
+ vv.i64 += *buffer++;
+ }
+
+ if ( vv.i64 == ULL(0) ) { /* Check for zero and treat it as a special case */
+ return D(0.0);
+ }
+
+ /* Normalize value */
+
+ int bexp = 64; /* convert from 64b int to fraction */
+
+ /* Count number of non-zeroes in value */
+ int nzero = 0;
+ if ((vv.i64 >> 32) != 0) { nzero = 32; }
+ if ((vv.i64 >> (16 + nzero)) != 0) { nzero += 16; }
+ if ((vv.i64 >> ( 8 + nzero)) != 0) { nzero += 8; }
+ if ((vv.i64 >> ( 4 + nzero)) != 0) { nzero += 4; }
+ if ((vv.i64 >> ( 2 + nzero)) != 0) { nzero += 2; }
+ if ((vv.i64 >> ( 1 + nzero)) != 0) { nzero += 1; }
+ if ((vv.i64 >> ( nzero)) != 0) { nzero += 1; }
+
+ /* Normalize */
+ nzero = 64 - nzero;
+ vv.i64 <<= nzero; // * TY 03/25/2000 - removed extraneous cast to uint64
+ bexp -= nzero;
+
+ /* At this point we have a 64b fraction and a binary exponent
+ * but have yet to incorporate the decimal exponent.
+ */
+
+ /* multiply by 10^dexp */
+ int sexp;
+ _Stl_tenscale(vv.i64, dexp, sexp);
+ bexp += sexp;
+
+ if ( bexp >= limits::min_exponent ) { /* not zero or denorm */
+ if ( limits::digits < 64 ) {
+ /* Round to (64 - M + 1) bits */
+ uint64_t rest = vv.i64 & ((~ULL(0) / ULL(2)) >> (limits::digits - 1));
+ vv.i64 >>= M - 2;
+ uint32_t guard = (uint32) vv.i64 & 1;
+ vv.i64 >>= 1;
+
+ /* value&1 guard rest Action
+ *
+ * dc 0 dc none
+ * 1 1 dc round
+ * 0 1 0 none
+ * 0 1 !=0 round
+ */
+
+ if (guard) {
+ if ( ((vv.i64 & 1) != 0) || (rest != 0) ) {
+ vv.i64++; /* round */
+ if ( (vv.i64 >> (limits::digits < 64 ? limits::digits : 0)) != 0 ) { /* carry all the way across */
+ vv.i64 >>= 1; /* renormalize */
+ ++bexp;
+ }
+ }
+ }
+
+ vv.i64 &= ~(ULL(1) << (limits::digits - 1)); /* hide hidden bit */
+ }
+ /*
+ * Check for overflow
+ * IEEE Double Precision Format
+ * (From Table 7-8 of Kane and Heinrich)
+ *
+ * Fraction bits 52
+ * Emax +1023
+ * Emin -1022
+ * Exponent bias +1023
+ * Exponent bits 11
+ * Integer bit hidden
+ * Total width in bits 64
+ */
+
+ if (bexp > limits::max_exponent) { /* overflow */
+ return limits::infinity();
+ }
+
+ /* value is normal */
+
+ IEEE v;
+
+ v.ieee.mantissa0 = vv.i32.hi;
+ v.ieee.mantissa1 = vv.i32.lo;
+ v.ieee.negative = 0;
+ v.ieee.exponent = bexp + BIAS - 1;
+
+ return v.d;
+ }
+
+ /* HI denorm or underflow */
+ bexp += BIAS - 1;
+ if (bexp < -limits::digits) { /* guaranteed underflow */
+ vv.i64 = 0;
+ } else { /* denorm or possible underflow */
+
+ /*
+ * Problem point for long double: looks like this code reflect shareing of mantissa
+ * and exponent in 64b int; not so for long double
+ */
+
+ int lead0 = M - bexp; /* M = 12 sign and exponent bits */
+ uint64_t rest;
+ uint32_t guard;
+
+ /* we must special case right shifts of more than 63 */
+
+ if (lead0 > 64) {
+ rest = vv.i64;
+ guard = 0;
+ vv.i64 = 0;
+ } else if (lead0 == 64) {
+ rest = vv.i64 & ((ULL(1) << 63)-1);
+ guard = (uint32) ((vv.i64 >> 63) & 1 );
+ vv.i64 = 0;
+ } else {
+ rest = vv.i64 & (((ULL(1) << lead0)-1)-1);
+ guard = (uint32) (((vv.i64 >> lead0)-1) & 1);
+ vv.i64 >>= /*(uint64)*/ lead0; /* exponent is zero */
+ }
+
+ /* Round */
+ if (guard && ( (vv.i64 & 1) || rest)) {
+ vv.i64++;
+ if (vv.i64 == (ULL(1) << (limits::digits - 1))) { /* carry created normal number */
+ IEEE v;
+
+ v.ieee.mantissa0 = 0;
+ v.ieee.mantissa1 = 0;
+ v.ieee.negative = 0;
+ v.ieee.exponent = 1;
+ return v.d;
+ }
+ }
+ }
+
+ IEEE v;
+
+ v.ieee.mantissa0 = vv.i32.hi;
+ v.ieee.mantissa1 = vv.i32.lo;
+ v.ieee.negative = 0;
+ v.ieee.exponent = 0;
+
+ return v.d;
+}
+#endif // __linux__
+
+#if !defined (__linux__) || defined (ANDROID)
+static double _Stl_string_to_double(const char *s) {
+ typedef numeric_limits<double> limits;
+ const int max_digits = limits::digits10 + 2;
+ unsigned c;
+ unsigned Negate, decimal_point;
+ char *d;
+ int exp;
+ int dpchar;
+ char digits[max_digits];
+
+ c = *s++;
+
+ /* process sign */
+ Negate = 0;
+ if (c == '+') {
+ c = *s++;
+ } else if (c == '-') {
+ Negate = 1;
+ c = *s++;
+ }
+
+ d = digits;
+ dpchar = '.' - '0';
+ decimal_point = 0;
+ exp = 0;
+
+ for (;;) {
+ c -= '0';
+ if (c < 10) {
+ if (d == digits + max_digits) {
+ /* ignore more than max_digits digits, but adjust exponent */
+ exp += (decimal_point ^ 1);
+ } else {
+ if (c == 0 && d == digits) {
+ /* ignore leading zeros */
+ } else {
+ *d++ = (char) c;
+ }
+ exp -= decimal_point;
+ }
+ } else if (c == (unsigned int) dpchar && !decimal_point) { /* INTERNATIONAL */
+ decimal_point = 1;
+ } else {
+ break;
+ }
+ c = *s++;
+ }
+
+ /* strtod cant return until it finds the end of the exponent */
+ if (d == digits) {
+ return 0.0;
+ }
+
+ if (c == 'e' - '0' || c == 'E' - '0') {
+ register unsigned negate_exp = 0;
+ register int e = 0;
+ c = *s++;
+ if (c == '+' || c == ' ') {
+ c = *s++;
+ } else if (c == '-') {
+ negate_exp = 1;
+ c = *s++;
+ }
+ if (c -= '0', c < 10) {
+ do {
+ e = e * 10 + (int)c;
+ c = *s++;
+ } while (c -= '0', c < 10);
+
+ if (negate_exp) {
+ e = -e;
+ }
+ exp += e;
+ }
+ }
+
+ double x;
+ ptrdiff_t n = d - digits;
+ if ((exp + n - 1) < limits::min_exponent10) {
+ x = 0;
+ }
+ else if ((exp + n - 1) > limits::max_exponent10) {
+ x = limits::infinity();
+ }
+ else {
+ /* Let _Stl_atod diagnose under- and over-flows.
+ * If the input was == 0.0, we have already returned,
+ * so retval of +-Inf signals OVERFLOW, 0.0 UNDERFLOW */
+ x = _Stl_atod(digits, n, exp);
+ }
+
+ if (Negate) {
+ x = -x;
+ }
+
+ return x;
+}
+
+#endif
+
+#if defined (__linux__) || defined (__MINGW32__) || defined (__CYGWIN__) || \
+ defined (__BORLANDC__) || defined (__DMC__) || defined (__HP_aCC)
+
+template <class D, class IEEE, int M, int BIAS>
+D _Stl_string_to_doubleT(const char *s)
+{
+ typedef numeric_limits<D> limits;
+ const int max_digits = limits::digits10; /* + 2 17 */;
+ unsigned c;
+ unsigned decimal_point;
+ char *d;
+ int exp;
+ D x;
+ int dpchar;
+ char digits[max_digits];
+
+ c = *s++;
+
+ /* process sign */
+ bool Negate = false;
+ if (c == '+') {
+ c = *s++;
+ } else if (c == '-') {
+ Negate = true;
+ c = *s++;
+ }
+
+ d = digits;
+ dpchar = '.' - '0';
+ decimal_point = 0;
+ exp = 0;
+
+ for (;;) {
+ c -= '0';
+ if (c < 10) {
+ if (d == digits + max_digits) {
+ /* ignore more than max_digits digits, but adjust exponent */
+ exp += (decimal_point ^ 1);
+ } else {
+ if (c == 0 && d == digits) {
+ /* ignore leading zeros */
+ } else {
+ *d++ = (char) c;
+ }
+ exp -= decimal_point;
+ }
+ } else if (c == (unsigned int) dpchar && !decimal_point) { /* INTERNATIONAL */
+ decimal_point = 1;
+ } else {
+ break;
+ }
+ c = *s++;
+ }
+ /* strtod cant return until it finds the end of the exponent */
+ if (d == digits) {
+ return D(0.0);
+ }
+
+ if (c == 'e'-'0' || c == 'E'-'0') {
+ bool negate_exp = false;
+ register int e = 0;
+ c = *s++;
+ if (c == '+' || c == ' ') {
+ c = *s++;
+ } else if (c == '-') {
+ negate_exp = true;
+ c = *s++;
+ }
+ if (c -= '0', c < 10) {
+ do {
+ e = e * 10 + (int)c;
+ c = *s++;
+ } while (c -= '0', c < 10);
+
+ if (negate_exp) {
+ e = -e;
+ }
+ exp += e;
+ }
+ }
+
+ ptrdiff_t n = d - digits;
+ if ((exp + n - 1) < limits::min_exponent10) {
+ return D(0.0); // +0.0 is the same as -0.0
+ } else if ((exp + n - 1) > limits::max_exponent10 ) {
+ // not good, because of x = -x below; this may lead to portability problems
+ x = limits::infinity();
+ } else {
+ /* let _Stl_atod diagnose under- and over-flows */
+ /* if the input was == 0.0, we have already returned,
+ so retval of +-Inf signals OVERFLOW, 0.0 UNDERFLOW
+ */
+ x = _Stl_atodT<D,IEEE,M,BIAS>(digits, n, exp);
+ }
+
+ return Negate ? -x : x;
+}
+
+#endif // __linux__
+
+void _STLP_CALL
+__string_to_float(const __iostring& v, float& val)
+{
+#if !defined (__linux__) || defined (ANDROID)
+ val = (float)_Stl_string_to_double(v.c_str());
+#else
+ val = (float)_Stl_string_to_doubleT<double,ieee754_double,12,IEEE754_DOUBLE_BIAS>(v.c_str());
+#endif
+}
+
+void _STLP_CALL
+__string_to_float(const __iostring& v, double& val)
+{
+#if !defined (__linux__) || defined (ANDROID)
+ val = _Stl_string_to_double(v.c_str());
+#else
+ val = _Stl_string_to_doubleT<double,ieee754_double,12,IEEE754_DOUBLE_BIAS>(v.c_str());
+#endif
+}
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+void _STLP_CALL
+__string_to_float(const __iostring& v, long double& val) {
+#if !defined (__linux__) && !defined (__MINGW32__) && !defined (__CYGWIN__) && \
+ !defined (__BORLANDC__) && !defined (__DMC__) && !defined (__HP_aCC)
+ //The following function is valid only if long double is an alias for double.
+ _STLP_STATIC_ASSERT( sizeof(long double) <= sizeof(double) )
+ val = _Stl_string_to_double(v.c_str());
+#else
+ val = _Stl_string_to_doubleT<long double,ieee854_long_double,16,IEEE854_LONG_DOUBLE_BIAS>(v.c_str());
+#endif
+}
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+_STLP_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/src/num_put.cpp b/sources/android/stlport/src/num_put.cpp
new file mode 100644
index 0000000..e123561
--- /dev/null
+++ b/sources/android/stlport/src/num_put.cpp
@@ -0,0 +1,183 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#include "stlport_prefix.h"
+
+#include <locale>
+#include <ostream>
+
+_STLP_BEGIN_NAMESPACE
+
+// Note that grouping[0] is the number of digits in the *rightmost* group.
+// We assume, without checking, that *last is null and that there is enough
+// space in the buffer to extend the number past [first, last).
+template <class Char>
+static ptrdiff_t
+__insert_grouping_aux(Char* first, Char* last, const string& grouping,
+ Char separator, Char Plus, Char Minus,
+ int basechars) {
+ typedef string::size_type str_size;
+
+ if (first == last)
+ return 0;
+
+ int sign = 0;
+
+ if (*first == Plus || *first == Minus) {
+ sign = 1;
+ ++first;
+ }
+
+ first += basechars;
+ Char* cur_group = last; // Points immediately beyond the rightmost
+ // digit of the current group.
+ int groupsize = 0; // Size of the current group (if grouping.size() == 0, size
+ // of group unlimited: we force condition (groupsize <= 0))
+
+ for ( str_size n = 0; ; ) { // Index of the current group
+ if ( n < grouping.size() ) {
+ groupsize = __STATIC_CAST(int, grouping[n++] );
+ }
+
+ if ((groupsize <= 0) || (groupsize >= cur_group - first) || (groupsize == CHAR_MAX)) {
+ break;
+ }
+
+ // Insert a separator character just before position cur_group - groupsize
+ cur_group -= groupsize;
+ ++last;
+ copy_backward(cur_group, last, last + 1);
+ *cur_group = separator;
+ }
+
+ return (last - first) + sign + basechars;
+}
+
+//Dynamic output buffer version.
+template <class Char, class Str>
+static void
+__insert_grouping_aux( /* __basic_iostring<Char> */ Str& iostr, size_t __group_pos,
+ const string& grouping,
+ Char separator, Char Plus, Char Minus,
+ int basechars) {
+ typedef string::size_type str_size;
+
+ if (iostr.size() < __group_pos)
+ return;
+
+ int __first_pos = 0;
+ Char __first = *iostr.begin();
+
+ if (__first == Plus || __first == Minus) {
+ ++__first_pos;
+ }
+
+ __first_pos += basechars;
+
+ typename Str::iterator cur_group(iostr.begin() + __group_pos); // Points immediately beyond the rightmost
+ // digit of the current group.
+ int groupsize = 0; // Size of the current group (if grouping.size() == 0, size
+ // of group unlimited: we force condition (groupsize <= 0))
+
+ for ( str_size n = 0; ; ) { // Index of the current group
+ if ( n < grouping.size() ) {
+ groupsize = __STATIC_CAST( int, grouping[n++] );
+ }
+
+ if ( (groupsize <= 0) || (groupsize >= ((cur_group - iostr.begin()) - __first_pos)) ||
+ (groupsize == CHAR_MAX)) {
+ break;
+ }
+
+ // Insert a separator character just before position cur_group - groupsize
+ cur_group -= groupsize;
+ cur_group = iostr.insert(cur_group, separator);
+ }
+}
+
+//----------------------------------------------------------------------
+// num_put
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+_STLP_DECLSPEC const char* _STLP_CALL __hex_char_table_lo()
+{ return "0123456789abcdefx"; }
+
+_STLP_DECLSPEC const char* _STLP_CALL __hex_char_table_hi()
+{ return "0123456789ABCDEFX"; }
+
+char* _STLP_CALL
+__write_integer(char* buf, ios_base::fmtflags flags, long x) {
+ char tmp[64];
+ char* bufend = tmp+64;
+ char* beg = __write_integer_backward(bufend, flags, x);
+ return copy(beg, bufend, buf);
+}
+
+///-------------------------------------
+
+ptrdiff_t _STLP_CALL
+__insert_grouping(char * first, char * last, const string& grouping,
+ char separator, char Plus, char Minus, int basechars) {
+ return __insert_grouping_aux(first, last, grouping,
+ separator, Plus, Minus, basechars);
+}
+
+void _STLP_CALL
+__insert_grouping(__iostring &str, size_t group_pos, const string& grouping,
+ char separator, char Plus, char Minus, int basechars) {
+ __insert_grouping_aux(str, group_pos, grouping, separator, Plus, Minus, basechars);
+}
+
+#if !defined (_STLP_NO_WCHAR_T)
+ptrdiff_t _STLP_CALL
+__insert_grouping(wchar_t* first, wchar_t* last, const string& grouping,
+ wchar_t separator, wchar_t Plus, wchar_t Minus,
+ int basechars) {
+ return __insert_grouping_aux(first, last, grouping, separator,
+ Plus, Minus, basechars);
+}
+
+void _STLP_CALL
+__insert_grouping(__iowstring &str, size_t group_pos, const string& grouping,
+ wchar_t separator, wchar_t Plus, wchar_t Minus,
+ int basechars) {
+ __insert_grouping_aux(str, group_pos, grouping, separator, Plus, Minus, basechars);
+}
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+//----------------------------------------------------------------------
+// Force instantiation of num_put<>
+#if !defined(_STLP_NO_FORCE_INSTANTIATE)
+template class _STLP_CLASS_DECLSPEC ostreambuf_iterator<char, char_traits<char> >;
+// template class num_put<char, char*>;
+template class num_put<char, ostreambuf_iterator<char, char_traits<char> > >;
+# ifndef _STLP_NO_WCHAR_T
+template class ostreambuf_iterator<wchar_t, char_traits<wchar_t> >;
+template class num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
+// template class num_put<wchar_t, wchar_t*>;
+# endif /* INSTANTIATE_WIDE_STREAMS */
+#endif
+
+_STLP_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/src/num_put_float.cpp b/sources/android/stlport/src/num_put_float.cpp
new file mode 100644
index 0000000..7ebd165
--- /dev/null
+++ b/sources/android/stlport/src/num_put_float.cpp
@@ -0,0 +1,918 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#include "stlport_prefix.h"
+
+#include <cmath>
+#include <ios>
+#include <locale>
+
+#if defined (__DECCXX)
+# define NDIG 400
+#else
+# define NDIG 82
+#endif
+
+#define todigit(x) ((x)+'0')
+
+#if defined (_STLP_UNIX)
+
+# if defined (__sun)
+# include <floatingpoint.h>
+# endif
+
+# if defined (__sun) || defined (__digital__) || defined (__sgi) || defined (_STLP_SCO_OPENSERVER) || defined (__NCR_SVR)
+// DEC, SGI & Solaris need this
+# include <values.h>
+# include <nan.h>
+# endif
+
+# if defined (__QNXNTO__) || ( defined(__GNUC__) && defined(__APPLE__) ) || defined(_STLP_USE_UCLIBC) /* 0.9.26 */ || \
+ defined(__FreeBSD__)
+# define USE_SPRINTF_INSTEAD
+# endif
+
+# if defined (_AIX) // JFA 3-Aug-2000
+# include <math.h>
+# include <float.h>
+# endif
+
+# include <math.h>
+#endif
+
+#include <cstdio>
+#include <cstdlib>
+
+#if defined (_STLP_MSVC_LIB) || defined (__MINGW32__) || defined (__BORLANDC__) || defined (__DJGPP) || \
+ defined (_STLP_SCO_OPENSERVER) || defined (__NCR_SVR)
+# include <float.h>
+#endif
+
+#if defined (__MRC__) || defined (__SC__) || defined (_CRAY) //*TY 02/24/2000 - added support for MPW
+# include <fp.h>
+#endif
+
+#if defined (__CYGWIN__)
+# include <ieeefp.h>
+#endif
+
+#if defined (__MSL__)
+# include <cstdlib> // for atoi
+# include <cstdio> // for snprintf
+# include <algorithm>
+# include <cassert>
+#endif
+
+#if defined (__ISCPP__)
+# include <cfloat>
+#endif
+
+#include <algorithm>
+
+#if defined (__DMC__)
+# define snprintf _snprintf
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+#if defined (__MWERKS__) || defined(__BEOS__)
+# define USE_SPRINTF_INSTEAD
+#endif
+
+template <int N>
+struct _Dig
+{
+ enum { dig = _Dig<N/10>::dig + 1 };
+};
+
+_STLP_TEMPLATE_NULL
+struct _Dig<0>
+{
+ enum { dig = 0 };
+};
+
+#ifdef _STLP_NO_LONG_DOUBLE
+# define MAXEDIGITS int(_Dig<DBL_MAX_10_EXP>::dig)
+# define MAXFSIG DBL_DIG
+# define MAXFCVT (DBL_DIG + 1)
+#else
+# define MAXEDIGITS int(_Dig<LDBL_MAX_10_EXP>::dig)
+# define MAXFSIG LDBL_DIG
+# define MAXFCVT (LDBL_DIG + 1)
+#endif
+
+// Tests for infinity and NaN differ on different OSs. We encapsulate
+// these differences here.
+#if !defined (USE_SPRINTF_INSTEAD)
+# if defined (__hpux) && defined (__GNUC__)
+# define _STLP_USE_SIGN_HELPER
+# elif defined (__DJGPP) || (defined (_STLP_USE_GLIBC) && ! defined (__MSL__)) || \
+ defined (__CYGWIN__) || \
+ defined (__FreeBSD__) || defined (__NetBSD__) || defined (__OpenBSD__) || \
+ defined (__HP_aCC)
+static inline bool _Stl_is_nan_or_inf(double x)
+# if defined (isfinite)
+{ return !isfinite(x); }
+# else
+{ return !finite(x); }
+# endif
+static inline bool _Stl_is_neg_nan(double x) { return isnan(x) && ( copysign(1., x) < 0 ); }
+static inline bool _Stl_is_inf(double x) { return isinf(x); }
+// inline bool _Stl_is_neg_inf(double x) { return isinf(x) < 0; }
+static inline bool _Stl_is_neg_inf(double x) { return isinf(x) && x < 0; }
+# elif (defined (__unix) || defined (__unix__)) && \
+ !defined (__APPLE__) && !defined (__DJGPP) && !defined(__osf__) && \
+ !defined (_CRAY) && !defined(__ANDROID__)
+static inline bool _Stl_is_nan_or_inf(double x) { return IsNANorINF(x); }
+static inline bool _Stl_is_inf(double x) { return IsNANorINF(x) && IsINF(x); }
+static inline bool _Stl_is_neg_inf(double x) { return (IsINF(x)) && (x < 0.0); }
+static inline bool _Stl_is_neg_nan(double x) { return IsNegNAN(x); }
+# elif defined (_STLP_MSVC_LIB) || defined (__MINGW32__) || defined (__BORLANDC__)
+static inline bool _Stl_is_nan_or_inf(double x) { return !_finite(x); }
+# if !defined (__BORLANDC__)
+static inline bool _Stl_is_inf(double x) {
+ int fclass = _fpclass(x);
+ return fclass == _FPCLASS_NINF || fclass == _FPCLASS_PINF;
+}
+static inline bool _Stl_is_neg_inf(double x) { return _fpclass(x) == _FPCLASS_NINF; }
+# else
+static inline bool _Stl_is_inf(double x) { return _Stl_is_nan_or_inf(x) && !_isnan(x);}
+static inline bool _Stl_is_neg_inf(double x) { return _Stl_is_inf(x) && x < 0 ; }
+# endif
+static inline bool _Stl_is_neg_nan(double x) { return _isnan(x) && _copysign(1., x) < 0 ; }
+# if defined (__BORLANDC__)
+static inline bool _Stl_is_nan_or_inf(long double x) { return !_finitel(x); }
+static inline bool _Stl_is_inf(long double x) { return _Stl_is_nan_or_inf(x) && !_isnanl(x);}
+static inline bool _Stl_is_neg_inf(long double x) { return _Stl_is_inf(x) && x < 0 ; }
+static inline bool _Stl_is_neg_nan(long double x) { return _isnanl(x) && _copysignl(1.l, x) < 0 ; }
+# elif !defined (_STLP_NO_LONG_DOUBLE)
+// Simply there to avoid warning long double -> double implicit conversion:
+static inline bool _Stl_is_nan_or_inf(long double x) { return _Stl_is_nan_or_inf(__STATIC_CAST(double, x)); }
+static inline bool _Stl_is_inf(long double x) { return _Stl_is_inf(__STATIC_CAST(double, x));}
+static inline bool _Stl_is_neg_inf(long double x) { return _Stl_is_neg_inf(__STATIC_CAST(double, x)); }
+static inline bool _Stl_is_neg_nan(long double x) { return _Stl_is_neg_nan(__STATIC_CAST(double, x)); }
+# endif
+# elif defined (__MRC__) || defined (__SC__) || defined (__DMC__)
+static bool _Stl_is_nan_or_inf(double x) { return isnan(x) || !isfinite(x); }
+static bool _Stl_is_inf(double x) { return !isfinite(x); }
+static bool _Stl_is_neg_inf(double x) { return !isfinite(x) && signbit(x); }
+static bool _Stl_is_neg_nan(double x) { return isnan(x) && signbit(x); }
+# elif /* defined(__FreeBSD__) || defined(__OpenBSD__) || */ (defined(__GNUC__) && defined(__APPLE__))
+static inline bool _Stl_is_nan_or_inf(double x) { return !finite(x); }
+static inline bool _Stl_is_inf(double x) { return _Stl_is_nan_or_inf(x) && ! isnan(x); }
+static inline bool _Stl_is_neg_inf(double x) { return _Stl_is_inf(x) && x < 0 ; }
+static inline bool _Stl_is_neg_nan(double x) { return isnan(x) && copysign(1., x) < 0 ; }
+# elif defined( _AIX ) // JFA 11-Aug-2000
+static bool _Stl_is_nan_or_inf(double x) { return isnan(x) || !finite(x); }
+static bool _Stl_is_inf(double x) { return !finite(x); }
+// bool _Stl_is_neg_inf(double x) { return _class(x) == FP_MINUS_INF; }
+static bool _Stl_is_neg_inf(double x) { return _Stl_is_inf(x) && ( copysign(1., x) < 0 ); }
+static bool _Stl_is_neg_nan(double x) { return isnan(x) && ( copysign(1., x) < 0 ); }
+# elif defined (__ISCPP__)
+static inline bool _Stl_is_nan_or_inf (double x) { return _fp_isINF(x) || _fp_isNAN(x); }
+static inline bool _Stl_is_inf (double x) { return _fp_isINF(x); }
+static inline bool _Stl_is_neg_inf (double x) { return _fp_isINF(x) && x < 0; }
+static inline bool _Stl_is_neg_nan (double x) { return _fp_isNAN(x) && x < 0; }
+# elif defined (_CRAY)
+# if defined (_CRAYIEEE)
+static inline bool _Stl_is_nan_or_inf(double x) { return isnan(x) || isinf(x); }
+static inline bool _Stl_is_inf(double x) { return isinf(x); }
+static inline bool _Stl_is_neg_inf(double x) { return isinf(x) && signbit(x); }
+static inline bool _Stl_is_neg_nan(double x) { return isnan(x) && signbit(x); }
+# else
+static inline bool _Stl_is_nan_or_inf(double x) { return false; }
+static inline bool _Stl_is_inf(double x) { return false; }
+static inline bool _Stl_is_neg_inf(double x) { return false; }
+static inline bool _Stl_is_neg_nan(double x) { return false; }
+# endif
+# else // nothing from above
+# define USE_SPRINTF_INSTEAD
+# endif
+#endif // !USE_SPRINTF_INSTEAD
+
+#if !defined (USE_SPRINTF_INSTEAD)
+// Reentrant versions of floating-point conversion functions. The argument
+// lists look slightly different on different operating systems, so we're
+// encapsulating the differences here.
+
+# if defined (__CYGWIN__) || defined(__DJGPP)
+static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf)
+{ return ecvtbuf(x, n, pt, sign, buf); }
+static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf)
+{ return fcvtbuf(x, n, pt, sign, buf); }
+# if !defined (_STLP_NO_LONG_DOUBLE)
+# if defined (__CYGWIN__)
+# define _STLP_EMULATE_LONG_DOUBLE_CVT
+# else
+static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf)
+{ return ecvtbuf(x, n, pt, sign, buf); }
+static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf)
+{ return fcvtbuf(x, n, pt, sign, buf); }
+# endif
+# endif
+# elif defined (_STLP_USE_GLIBC)
+static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf, size_t bsize)
+{ return ecvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0; }
+static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf, size_t bsize)
+{ return fcvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0; }
+# ifndef _STLP_NO_LONG_DOUBLE
+static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf, size_t bsize)
+{ return qecvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0; }
+static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf, size_t bsize)
+{ return qfcvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0; }
+# endif
+# define _STLP_NEED_CVT_BUFFER_SIZE
+# elif defined (__sun)
+static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf)
+{ return econvert(x, n, pt, sign, buf); }
+static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf)
+{ return fconvert(x, n, pt, sign, buf); }
+# ifndef _STLP_NO_LONG_DOUBLE
+static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf)
+{ return qeconvert(&x, n, pt, sign, buf); }
+static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf)
+{ return qfconvert(&x, n, pt, sign, buf); }
+# endif
+# elif defined (__DECCXX)
+static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf, size_t bsize)
+{ return (ecvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0); }
+static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf, size_t bsize)
+{ return (fcvt_r(x, n, pt, sign, buf, bsize) == 0 ? buf : 0); }
+# ifndef _STLP_NO_LONG_DOUBLE
+// fbp : no "long double" conversions !
+static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf, size_t bsize)
+{ return (ecvt_r((double)x, n, pt, sign, buf, bsize) == 0 ? buf : 0) ; }
+static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf, size_t bsize)
+{ return (fcvt_r((double)x, n, pt, sign, buf, bsize) == 0 ? buf : 0); }
+# endif
+# define _STLP_NEED_CVT_BUFFER_SIZE
+# elif defined (__hpux)
+static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign)
+{ return ecvt(x, n, pt, sign); }
+static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign)
+{ return fcvt(x, n, pt, sign); }
+# if !defined (_STLP_NO_LONG_DOUBLE)
+static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign)
+{ return _ldecvt(*(long_double*)&x, n, pt, sign); }
+static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign)
+{ return _ldfcvt(*(long_double*)&x, n, pt, sign); }
+# endif
+# define _STLP_CVT_NEED_SYNCHRONIZATION
+# elif defined (__unix) && !defined (__APPLE__) && !defined (_CRAY)
+static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf)
+{ return ecvt_r(x, n, pt, sign, buf); }
+static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf)
+{ return fcvt_r(x, n, pt, sign, buf); }
+# if !defined (_STLP_NO_LONG_DOUBLE)
+static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf)
+{ return qecvt_r(x, n, pt, sign, buf); }
+static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf)
+{ return qfcvt_r(x, n, pt, sign, buf); }
+# endif
+# elif defined (_STLP_MSVC_LIB) || defined (__MINGW32__) || defined (__BORLANDC__)
+# if defined (_STLP_USE_SAFE_STRING_FUNCTIONS)
+# define _STLP_APPEND(a, b) a##b
+# define _STLP_BUF_PARAMS , char* buf, size_t bsize
+# define _STLP_SECURE_FUN(F, X, N, PT, SIGN) _STLP_APPEND(F, _s)(buf, bsize, X, N, PT, SIGN); return buf
+# else
+# define _STLP_BUF_PARAMS
+# define _STLP_SECURE_FUN(F, X, N, PT, SIGN) return F(X, N, PT, SIGN)
+# define _STLP_CVT_NEED_SYNCHRONIZATION
+# endif
+static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign _STLP_BUF_PARAMS)
+{ _STLP_SECURE_FUN(_ecvt, x, n, pt, sign); }
+static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign _STLP_BUF_PARAMS)
+{ _STLP_SECURE_FUN(_fcvt, x, n, pt, sign); }
+# if !defined (_STLP_NO_LONG_DOUBLE)
+# if defined (_STLP_USE_SAFE_STRING_FUNCTIONS)
+# define _STLP_PARAMS , buf, bsize
+# else
+# define _STLP_PARAMS
+# endif
+static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign _STLP_BUF_PARAMS)
+{ return _Stl_ecvtR(__STATIC_CAST(double, x), n, pt, sign _STLP_PARAMS); }
+static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign _STLP_BUF_PARAMS)
+{ return _Stl_fcvtR(__STATIC_CAST(double, x), n, pt, sign _STLP_PARAMS); }
+# undef _STLP_PARAMS
+# endif
+# undef _STLP_SECURE_FUN
+# undef _STLP_BUF_PARAMS
+# undef _STLP_APPEND
+# if defined (__BORLANDC__) /* || defined (__GNUC__) MinGW do not support 'L' modifier so emulation do not work */
+# define _STLP_EMULATE_LONG_DOUBLE_CVT
+# endif
+# elif defined (__ISCPP__)
+static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf)
+{ return _fp_ecvt( x, n, pt, sign, buf); }
+static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf)
+{ return _fp_fcvt(x, n, pt, sign, buf); }
+# if !defined (_STLP_NO_LONG_DOUBLE)
+static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf)
+{ return _fp_ecvt( x, n, pt, sign, buf); }
+static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf)
+{ return _fp_fcvt(x, n, pt, sign, buf); }
+# endif
+# elif defined (_AIX) || defined (__FreeBSD__) || defined (__NetBSD__) || defined (__OpenBSD__) || \
+ defined (__MRC__) || defined (__SC__) || defined (_CRAY) || \
+ defined (_STLP_SCO_OPENSERVER) || defined (__NCR_SVR) || \
+ defined (__DMC__)
+static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign)
+{ return ecvt(x, n, pt, sign ); }
+static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign)
+{ return fcvt(x, n, pt, sign); }
+# if !defined (_STLP_NO_LONG_DOUBLE)
+static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign)
+{ return ecvt(x, n, pt, sign ); }
+static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign)
+{ return fcvt(x, n, pt, sign); }
+# endif
+# define _STLP_CVT_NEED_SYNCHRONIZATION
+# else
+# error Missing _Stl_ecvtR and _Stl_fcvtR implementations.
+# endif
+
+#if defined (_STLP_CVT_NEED_SYNCHRONIZATION)
+/* STLport synchronize access to *cvt functions but those methods might
+ * be called from outside, in this case we will still have a race condition. */
+# if defined (_STLP_THREADS)
+static _STLP_STATIC_MUTEX& put_float_mutex() {
+ static _STLP_STATIC_MUTEX __put_float_mutex _STLP_MUTEX_INITIALIZER;
+ return __put_float_mutex;
+}
+static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char* buf) {
+ _STLP_auto_lock lock(put_float_mutex());
+ strcpy(buf, _Stl_ecvtR(x, n, pt, sign)); return buf;
+}
+static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char* buf) {
+ _STLP_auto_lock lock(put_float_mutex());
+ strcpy(buf, _Stl_fcvtR(x, n, pt, sign)); return buf;
+}
+# if !defined (_STLP_NO_LONG_DOUBLE) && !defined (_STLP_EMULATE_LONG_DOUBLE_CVT)
+static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf) {
+ _STLP_auto_lock lock(put_float_mutex());
+ strcpy(buf, _Stl_ecvtR(x, n, pt, sign)); return buf;
+}
+static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf) {
+ _STLP_auto_lock lock(put_float_mutex());
+ strcpy(buf, _Stl_fcvtR(x, n, pt, sign)); return buf;
+}
+# endif
+# else
+static inline char* _Stl_ecvtR(double x, int n, int* pt, int* sign, char*)
+{ return _Stl_ecvtR(x, n, pt, sign); }
+static inline char* _Stl_fcvtR(double x, int n, int* pt, int* sign, char*)
+{ return _Stl_fcvtR(x, n, pt, sign); }
+# if !defined (_STLP_NO_LONG_DOUBLE) && !defined (_STLP_EMULATE_LONG_DOUBLE_CVT)
+static inline char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char*)
+{ return _Stl_ecvtR(x, n, pt, sign); }
+static inline char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char*)
+{ return _Stl_fcvtR(x, n, pt, sign); }
+# endif
+# endif
+#endif
+
+# if !defined (_STLP_USE_SAFE_STRING_FUNCTIONS) && !defined (_STLP_NEED_CVT_BUFFER_SIZE)
+# define _STLP_CVT_BUFFER(B) B
+# else
+# define _STLP_CVT_BUFFER(B) _STLP_ARRAY_AND_SIZE(B)
+# endif
+
+# if defined (_STLP_EMULATE_LONG_DOUBLE_CVT)
+static void __fill_fmtbuf(char* fmtbuf, ios_base::fmtflags flags, char long_modifier);
+
+// Emulation of ecvt/fcvt functions using sprintf:
+static char* _Stl_ecvtR(long double x, int n, int* pt, int* sign, char* buf) {
+ // If long double value can be safely converted to double without losing precision
+ // we use the ecvt function for double:
+ double y = __STATIC_CAST(double, x);
+ if (x == y)
+ return _Stl_ecvtR(y, n, pt, sign, buf);
+
+ char fmtbuf[32];
+ __fill_fmtbuf(fmtbuf, 0, 'L');
+ sprintf(buf, fmtbuf, n, x < 0.0l ? -x : x);
+ /* We are waiting for something having the form x.xxxe+yyyy */
+ *pt = 0;
+ *sign = 0;
+ int i = -1;
+ int offset = 0;
+ while (buf[++i] != 0 && n != 0) {
+ if (buf[i] >= '0' && buf[i] <= '9') {
+ --n;
+ if (offset != 0)
+ buf[i - offset] = buf[i];
+ }
+ else {
+ if (offset != 0) break;
+ ++offset;
+ *pt = i;
+ }
+ }
+ if (offset != 0)
+ buf[i - offset] = 0;
+ // Extract exponent part in point position:
+ int e = 0;
+ while (buf[++i] != 0) {
+ if (buf[i] >= '0' && buf[i] <= '9') {
+ e = e * 10 + (buf[i] - '0');
+ }
+ }
+ *pt += e;
+ return buf;
+}
+
+static char* _Stl_fcvtR(long double x, int n, int* pt, int* sign, char* buf) {
+ // If long double value can be safely converted to double without losing precision
+ // we use the fcvt function for double:
+ double y = __STATIC_CAST(double, x);
+ if (x == y)
+ return _Stl_fcvtR(y, n, pt, sign, buf);
+
+ char fmtbuf[32];
+ __fill_fmtbuf(fmtbuf, ios_base::fixed, 'L');
+ sprintf(buf, fmtbuf, n, x < 0.0l ? -x : x);
+ *pt = 0;
+ *sign = 0;
+ int i = -1;
+ int offset = 0;
+ while (buf[++i] != 0 && (offset == 0 || n != 0)) {
+ if (buf[i] >= '0' && buf[i] <= '9') {
+ if (offset != 0) {
+ --n;
+ buf[i - offset] = buf[i];
+ }
+ }
+ else {
+ ++offset;
+ *pt = i;
+ }
+ }
+ if (offset != 0)
+ buf[i - offset] = 0;
+ else
+ *pt = i;
+ return buf;
+}
+#endif
+
+//----------------------------------------------------------------------
+// num_put
+
+// __format_float formats a mantissa and exponent as returned by
+// one of the conversion functions (ecvt_r, fcvt_r, qecvt_r, qfcvt_r)
+// according to the specified precision and format flags. This is
+// based on doprnt but is much simpler since it is concerned only
+// with floating point input and does not consider all formats. It
+// also does not deal with blank padding, which is handled by
+// __copy_float_and_fill.
+
+static size_t __format_float_scientific( __iostring& buf, const char *bp,
+ int decpt, int sign, bool is_zero,
+ ios_base::fmtflags flags,
+ int precision) {
+ // sign if required
+ if (sign)
+ buf += '-';
+ else if (flags & ios_base::showpos)
+ buf += '+';
+
+ // first digit of mantissa
+ buf += *bp++;
+
+ // start of grouping position, grouping won't occur in scientific notation
+ // as it is impossible to have something like 1234.0e04 but we return a correct
+ // group position for coherency with __format_float_fixed.
+ size_t __group_pos = buf.size();
+
+ // decimal point if required
+ if (precision != 0 || flags & ios_base::showpoint) {
+ buf += '.';
+ }
+
+ // rest of mantissa
+ while (*bp != 0 && precision--)
+ buf += *bp++;
+
+ // trailing 0 if needed
+ if (precision > 0)
+ buf.append(precision, '0');
+
+ // exponent size = number of digits + exponent sign + exponent symbol + trailing zero
+ char expbuf[MAXEDIGITS + 3];
+ //We start filling at the buffer end
+ char *suffix = expbuf + MAXEDIGITS + 2;
+ *suffix = 0;
+ if (!is_zero) {
+ int nn = decpt - 1;
+ if (nn < 0)
+ nn = -nn;
+ for (; nn > 9; nn /= 10)
+ *--suffix = (char) todigit(nn % 10);
+ *--suffix = (char) todigit(nn);
+ }
+
+ // prepend leading zeros to exponent
+ // C89 Standard says that it should be at least 2 digits, C99 Standard says that
+ // we stop prepend zeros if more than 3 digits. To repect both STLport prepend zeros
+ // until it is 2 digits.
+ while (suffix > &expbuf[MAXEDIGITS])
+ *--suffix = '0';
+
+ // put in the exponent sign
+ *--suffix = (char) ((decpt > 0 || is_zero ) ? '+' : '-');
+
+ // put in the e
+ *--suffix = flags & ios_base::uppercase ? 'E' : 'e';
+
+ // copy the suffix
+ buf += suffix;
+ return __group_pos;
+}
+
+static size_t __format_float_fixed( __iostring &buf, const char *bp,
+ int decpt, int sign,
+ ios_base::fmtflags flags,
+ int precision) {
+ if ( sign && (decpt > -precision) && (*bp != 0) )
+ buf += '-';
+ else if ( flags & ios_base::showpos )
+ buf += '+';
+
+ // digits before decimal point
+ int nnn = decpt;
+ do {
+ buf += (nnn <= 0 || *bp == 0) ? '0' : *bp++;
+ } while ( --nnn > 0 );
+
+ // start of grouping position
+ size_t __group_pos = buf.size();
+
+ // decimal point if needed
+ if ( flags & ios_base::showpoint || precision > 0 ) {
+ buf += '.';
+ }
+
+ // digits after decimal point if any
+ while ( *bp != 0 && --precision >= 0 ) {
+ buf += (++decpt <= 0) ? '0' : *bp++;
+ }
+
+ // trailing zeros if needed
+ if (precision > 0)
+ buf.append(precision, '0');
+
+ return __group_pos;
+}
+
+#if defined (_STLP_USE_SIGN_HELPER)
+template<class _FloatT>
+struct float_sign_helper {
+ float_sign_helper(_FloatT __x)
+ { _M_number._num = __x; }
+
+ bool is_negative() const {
+ const unsigned short sign_mask(1 << (sizeof(unsigned short) * CHAR_BIT - 1));
+ return (get_sign_word() & sign_mask) != 0;
+ }
+private:
+ union {
+ unsigned short _Words[8];
+ _FloatT _num;
+ } _M_number;
+
+ unsigned short get_word_higher() const _STLP_NOTHROW
+ { return _M_number._Words[0]; }
+ unsigned short get_word_lower() const _STLP_NOTHROW
+ { return _M_number._Words[(sizeof(_FloatT) >= 12 ? 10 : sizeof(_FloatT)) / sizeof(unsigned short) - 1]; }
+ unsigned short get_sign_word() const _STLP_NOTHROW
+# if defined (_STLP_BIG_ENDIAN)
+ { return get_word_higher(); }
+# else /* _STLP_LITTLE_ENDIAN */
+ { return get_word_lower(); }
+# endif
+};
+#endif
+
+template <class _FloatT>
+static size_t __format_nan_or_inf(__iostring& buf, _FloatT x, ios_base::fmtflags flags) {
+ static const char* inf[2] = { "inf", "Inf" };
+ static const char* nan[2] = { "nan", "NaN" };
+ const char** inf_or_nan;
+#if !defined (_STLP_USE_SIGN_HELPER)
+ if (_Stl_is_inf(x)) { // Infinity
+ inf_or_nan = inf;
+ if (_Stl_is_neg_inf(x))
+ buf += '-';
+ else if (flags & ios_base::showpos)
+ buf += '+';
+ } else { // NaN
+ inf_or_nan = nan;
+ if (_Stl_is_neg_nan(x))
+ buf += '-';
+ else if (flags & ios_base::showpos)
+ buf += '+';
+ }
+#else
+ typedef numeric_limits<_FloatT> limits;
+ if (x == limits::infinity() || x == -limits::infinity()) {
+ inf_or_nan = inf;
+ } else { // NaN
+ inf_or_nan = nan;
+ }
+ float_sign_helper<_FloatT> helper(x);
+ if (helper.is_negative())
+ buf += '-';
+ else if (flags & ios_base::showpos)
+ buf += '+';
+#endif
+ size_t ret = buf.size();
+ buf += inf_or_nan[flags & ios_base::uppercase ? 1 : 0];
+ return ret;
+}
+
+static inline size_t __format_float(__iostring &buf, const char * bp,
+ int decpt, int sign, bool is_zero,
+ ios_base::fmtflags flags,
+ int precision) {
+ size_t __group_pos = 0;
+ switch (flags & ios_base::floatfield) {
+ case ios_base::scientific:
+ __group_pos = __format_float_scientific( buf, bp, decpt, sign, is_zero,
+ flags, precision);
+ break;
+ case ios_base::fixed:
+ __group_pos = __format_float_fixed( buf, bp, decpt, sign,
+ flags, precision);
+ break;
+ default: // g format
+ // establish default precision
+ if (flags & ios_base::showpoint || precision > 0) {
+ if (precision == 0) precision = 1;
+ } else
+ precision = 6;
+
+ // reset exponent if value is zero
+ if (is_zero)
+ decpt = 1;
+
+ int kk = precision;
+ if (!(flags & ios_base::showpoint)) {
+ size_t n = strlen(bp);
+ if (n < (size_t)kk)
+ kk = (int)n;
+ while (kk >= 1 && bp[kk-1] == '0')
+ --kk;
+ }
+
+ if (decpt < -3 || decpt > precision) {
+ precision = kk - 1;
+ __group_pos = __format_float_scientific( buf, bp, decpt, sign, is_zero,
+ flags, precision);
+ } else {
+ precision = kk - decpt;
+ __group_pos = __format_float_fixed( buf, bp, decpt, sign,
+ flags, precision);
+ }
+ break;
+ } /* switch */
+ return __group_pos;
+}
+
+#endif
+
+#if defined (USE_SPRINTF_INSTEAD) || defined (_STLP_EMULATE_LONG_DOUBLE_CVT)
+struct GroupPos {
+ bool operator () (char __c) const {
+ return __c == '.' ||
+ __c == 'e' || __c == 'E';
+ }
+};
+
+// Creates a format string for sprintf()
+static void __fill_fmtbuf(char* fmtbuf, ios_base::fmtflags flags, char long_modifier) {
+ fmtbuf[0] = '%';
+ int i = 1;
+
+ if (flags & ios_base::showpos)
+ fmtbuf[i++] = '+';
+
+ if (flags & ios_base::showpoint)
+ fmtbuf[i++] = '#';
+
+ fmtbuf[i++] = '.';
+ fmtbuf[i++] = '*';
+
+ if (long_modifier)
+ fmtbuf[i++] = long_modifier;
+
+ switch (flags & ios_base::floatfield)
+ {
+ case ios_base::scientific:
+ fmtbuf[i++] = (flags & ios_base::uppercase) ? 'E' : 'e';
+ break;
+ case ios_base::fixed:
+# if defined (__FreeBSD__)
+ fmtbuf[i++] = 'f';
+# else
+ fmtbuf[i++] = (flags & ios_base::uppercase) ? 'F' : 'f';
+# endif
+ break;
+ default:
+ fmtbuf[i++] = (flags & ios_base::uppercase) ? 'G' : 'g';
+ break;
+ }
+
+ fmtbuf[i] = 0;
+}
+
+#endif /* USE_SPRINTF_INSTEAD */
+
+template <class _FloatT>
+static size_t __write_floatT(__iostring &buf, ios_base::fmtflags flags, int precision,
+ _FloatT x
+#if defined (USE_SPRINTF_INSTEAD)
+ , char modifier) {
+ /* In theory, if we want 'arbitrary' precision, we should use 'arbitrary'
+ * buffer size below, but really we limited by exponent part in double.
+ * - ptr
+ */
+ typedef numeric_limits<_FloatT> limits;
+ char static_buf[limits::max_exponent10 + 6]; // 6: -xxx.yyyE-zzz (sign, dot, E, exp sign, \0)
+ char fmtbuf[32];
+ __fill_fmtbuf(fmtbuf, flags, modifier);
+ snprintf(_STLP_ARRAY_AND_SIZE(static_buf), fmtbuf, precision, x);
+ buf = static_buf;
+ return find_if(buf.begin(), buf.end(), GroupPos()) - buf.begin();
+#else
+ ) {
+ typedef numeric_limits<_FloatT> limits;
+ //If numeric_limits support is correct we use the exposed values to detect NaN and infinity:
+ if (limits::has_infinity && limits::has_quiet_NaN) {
+ if (!(x == x) || // NaN check
+ (x == limits::infinity() || x == -limits::infinity())) {
+ return __format_nan_or_inf(buf, x, flags);
+ }
+ }
+ // numeric_limits support is not good enough, we rely on platform dependent function
+ // _Stl_is_nan_or_inf that do not support long double.
+ else if (_Stl_is_nan_or_inf(x)) {
+ return __format_nan_or_inf(buf, x, flags);
+ }
+# if defined (__MINGW32__)
+ //For the moment MinGW is limited to display at most numeric_limits<double>::max()
+ if (x > numeric_limits<double>::max() ||
+ x < -numeric_limits<double>::max()) {
+ return __format_nan_or_inf(buf, x, flags);
+ }
+# endif
+
+ /* Buffer size is max number of digits which is the addition of:
+ * - max_exponent10: max number of digits in fixed mode
+ * - digits10 + 2: max number of significant digits
+ * - trailing '\0'
+ */
+ char cvtbuf[limits::max_exponent10 + limits::digits10 + 2 + 1];
+ char *bp;
+ int decpt, sign;
+
+ switch (flags & ios_base::floatfield) {
+ case ios_base::fixed:
+ {
+ /* Here, number of digits represents digits _after_ decimal point.
+ * In order to limit static buffer size we have to give 2 different values depending on x value.
+ * For small values (abs(x) < 1) we need as many digits as requested by precision limited by the maximum number of digits
+ * which is min_exponent10 + digits10 + 2
+ * For bigger values we won't have more than limits::digits10 + 2 digits after decimal point. */
+ int digits10 = (x > -1.0 && x < 1.0 ? -limits::min_exponent10 + limits::digits10 + 2
+ : limits::digits10 + 2);
+ bp = _Stl_fcvtR(x, (min) (precision, digits10), &decpt, &sign, _STLP_CVT_BUFFER(cvtbuf) );
+ }
+ break;
+ case ios_base::scientific:
+ default:
+ /* Here, number of digits is total number of digits which is limited to digits10 + 2. */
+ {
+ int digits10 = limits::digits10 + 2;
+ bp = _Stl_ecvtR(x, (min) (precision, digits10), &decpt, &sign, _STLP_CVT_BUFFER(cvtbuf) );
+ }
+ break;
+ }
+ return __format_float(buf, bp, decpt, sign, x == 0.0, flags, precision);
+#endif
+}
+
+size_t _STLP_CALL
+__write_float(__iostring &buf, ios_base::fmtflags flags, int precision,
+ double x) {
+ return __write_floatT(buf, flags, precision, x
+#if defined (USE_SPRINTF_INSTEAD)
+ , 0
+#endif
+ );
+}
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+size_t _STLP_CALL
+__write_float(__iostring &buf, ios_base::fmtflags flags, int precision,
+ long double x) {
+ return __write_floatT(buf, flags, precision, x
+#if defined (USE_SPRINTF_INSTEAD)
+ , 'L'
+#endif
+ );
+}
+#endif
+
+void _STLP_CALL __get_floor_digits(__iostring &out, _STLP_LONGEST_FLOAT_TYPE __x) {
+ typedef numeric_limits<_STLP_LONGEST_FLOAT_TYPE> limits;
+#if defined (USE_SPRINTF_INSTEAD)
+ char cvtbuf[limits::max_exponent10 + 6];
+# if !defined (_STLP_NO_LONG_DOUBLE)
+ snprintf(_STLP_ARRAY_AND_SIZE(cvtbuf), "%Lf", __x); // check for 1234.56!
+# else
+ snprintf(_STLP_ARRAY_AND_SIZE(cvtbuf), "%f", __x); // check for 1234.56!
+# endif
+ char *p = strchr( cvtbuf, '.' );
+ if ( p == 0 ) {
+ out.append( cvtbuf );
+ } else {
+ out.append( cvtbuf, p );
+ }
+#else
+ char cvtbuf[limits::max_exponent10 + 1];
+ char * bp;
+ int decpt, sign;
+ bp = _Stl_fcvtR(__x, 0, &decpt, &sign, _STLP_CVT_BUFFER(cvtbuf));
+
+ if (sign) {
+ out += '-';
+ }
+ out.append(bp, bp + decpt);
+#endif
+}
+
+
+#if !defined (_STLP_NO_WCHAR_T)
+void _STLP_CALL __convert_float_buffer( __iostring const& str, __iowstring &out,
+ const ctype<wchar_t>& ct, wchar_t dot, bool __check_dot) {
+ string::const_iterator str_ite(str.begin()), str_end(str.end());
+
+ //First loop, check the dot char
+ if (__check_dot) {
+ while (str_ite != str_end) {
+ if (*str_ite != '.') {
+ out += ct.widen(*str_ite++);
+ } else {
+ out += dot;
+ break;
+ }
+ }
+ } else {
+ if (str_ite != str_end) {
+ out += ct.widen(*str_ite);
+ }
+ }
+
+ if (str_ite != str_end) {
+ //Second loop, dot has been found, no check anymore
+ while (++str_ite != str_end) {
+ out += ct.widen(*str_ite);
+ }
+ }
+}
+
+#endif
+
+void _STLP_CALL
+__adjust_float_buffer(__iostring &str, char dot) {
+ if ('.' != dot) {
+ size_t __dot_pos = str.find('.');
+ if (__dot_pos != string::npos) {
+ str[__dot_pos] = dot;
+ }
+ }
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+_STLP_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/src/numpunct.cpp b/sources/android/stlport/src/numpunct.cpp
new file mode 100644
index 0000000..cbadc7a
--- /dev/null
+++ b/sources/android/stlport/src/numpunct.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#include "stlport_prefix.h"
+
+#include <locale>
+
+_STLP_BEGIN_NAMESPACE
+
+//----------------------------------------------------------------------
+// numpunct<char>
+char numpunct<char>::do_decimal_point() const {return '.';}
+char numpunct<char>::do_thousands_sep() const { return ','; }
+string numpunct<char>::do_grouping() const { return string();}
+string numpunct<char>::do_truename() const { return "true";}
+string numpunct<char>::do_falsename() const { return "false"; }
+numpunct<char>::~numpunct() {}
+
+#if !defined (_STLP_NO_WCHAR_T)
+wchar_t numpunct<wchar_t>::do_decimal_point() const { return L'.'; }
+wchar_t numpunct<wchar_t>::do_thousands_sep() const { return L','; }
+string numpunct<wchar_t>::do_grouping() const { return string(); }
+wstring numpunct<wchar_t>::do_truename() const { return L"true"; }
+wstring numpunct<wchar_t>::do_falsename() const { return L"false"; }
+numpunct<wchar_t>::~numpunct() {}
+#endif
+
+_STLP_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/src/ostream.cpp b/sources/android/stlport/src/ostream.cpp
new file mode 100644
index 0000000..96d4737
--- /dev/null
+++ b/sources/android/stlport/src/ostream.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#include "stlport_prefix.h"
+
+#include <ostream>
+
+_STLP_BEGIN_NAMESPACE
+
+#if !defined(_STLP_NO_FORCE_INSTANTIATE)
+
+// instantiations
+template class _STLP_CLASS_DECLSPEC basic_ostream<char, char_traits<char> >;
+
+# if defined (_STLP_USE_TEMPLATE_EXPORT)
+template class _STLP_CLASS_DECLSPEC _Osentry<char, char_traits<char> >;
+# endif
+
+#ifndef _STLP_NO_WCHAR_T
+
+# if defined (_STLP_USE_TEMPLATE_EXPORT)
+template class _STLP_CLASS_DECLSPEC _Osentry<wchar_t, char_traits<wchar_t> >;
+# endif
+template class _STLP_CLASS_DECLSPEC basic_ostream<wchar_t, char_traits<wchar_t> >;
+#endif
+
+#endif
+
+_STLP_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/src/sparc_atomic.s b/sources/android/stlport/src/sparc_atomic.s
new file mode 100644
index 0000000..67e41d6
--- /dev/null
+++ b/sources/android/stlport/src/sparc_atomic.s
@@ -0,0 +1,68 @@
+ .section ".text",#alloc,#execinstr
+ .align 8
+ .skip 16
+
+
+ /*
+ ** int _STLP_atomic_exchange (void *pvalue, int value)
+ */
+
+ .type _STLP_atomic_exchange,#function
+ .global _STLP_atomic_exchange
+ .align 8
+
+_STLP_atomic_exchange:
+0:
+ ld [%o0], %o2 ! Set the current value
+ mov %o1, %o3 ! Set the new value
+! swap [%o0], %o3 ! Do the compare and swap
+ cas [%o0], %o2, %o3
+ cmp %o2, %o3 ! Check whether successful
+ bne 0b ! Retry upon failure
+ stbar
+ mov %o2, %o0 ! Set the new value
+ retl ! return
+ nop
+ .size _STLP_atomic_exchange,(.-_STLP_atomic_exchange)
+
+ /* int _STLP_atomic_increment (void *pvalue) */
+
+ .type _STLP_atomic_increment,#function
+ .global _STLP_atomic_increment
+ .align 8
+_STLP_atomic_increment:
+1:
+ ld [%o0], %o2 ! set the current
+ add %o2, 0x1, %o3 ! Increment and store current
+! swap [%o0], %o3 ! Do the compare and swap
+ cas [%o0], %o2, %o3
+ cmp %o3, %o2 ! Check whether successful
+ bne 1b ! Retry if we failed.
+ membar #LoadLoad | #LoadStore ! Ensure the cas finishes before
+ ! returning
+ nop
+ retl ! return
+ nop
+
+ .size _STLP_atomic_increment,(.-_STLP_atomic_increment)
+
+
+ /* int _STLP_atomic_decrement (void *pvalue) */
+ .type _STLP_atomic_decrement,#function
+ .global _STLP_atomic_decrement
+ .align 8
+
+_STLP_atomic_decrement:
+2:
+ ld [%o0], %o2 ! set the current
+ sub %o2, 0x1, %o3 ! decrement and store current
+! swap [%o0], %o3 ! Do the compare and swap
+ cas [%o0], %o2, %o3
+ cmp %o3, %o2 ! Check whether successful
+ bne 2b ! Retry if we failed.
+ membar #LoadLoad | #LoadStore ! Ensure the cas finishes before
+ nop
+ ! returning
+ retl ! return
+ nop
+ .size _STLP_atomic_decrement,(.-_STLP_atomic_decrement)
diff --git a/sources/android/stlport/src/sparc_atomic64.s b/sources/android/stlport/src/sparc_atomic64.s
new file mode 100644
index 0000000..ff2c42a
--- /dev/null
+++ b/sources/android/stlport/src/sparc_atomic64.s
@@ -0,0 +1,65 @@
+ .section ".text",#alloc,#execinstr
+ .align 8
+ .skip 16
+
+! int _STLP_atomic_exchange (void *pvalue, int value)
+!
+
+ .type _STLP_atomic_exchange,#function
+ .global _STLP_atomic_exchange
+ .align 8
+
+_STLP_atomic_exchange:
+1:
+ ldx [%o0], %o2 ! Set the current value
+ mov %o1, %o3 ! Set the new value
+ casx [%o0], %o2, %o3 ! Do the compare and swap
+ cmp %o2, %o3 ! Check whether successful
+ bne 1b ! Retry upon failure
+ membar #LoadLoad | #LoadStore ! Ensure the cas finishes before
+ ! returning
+ retl ! return
+ mov %o2, %o0 ! Set the new value
+ .size _STLP_atomic_exchange,(.-_STLP_atomic_exchange)
+
+
+! int _STLP_atomic_increment (void *pvalue)
+
+ .type _STLP_atomic_increment,#function
+ .global _STLP_atomic_increment
+ .align 8
+_STLP_atomic_increment:
+0:
+ ldx [%o0], %o2 ! set the current
+ addx %o2, 0x1, %o3 ! Increment and store current
+ casx [%o0], %o2, %o3 ! Do the compare and swap
+ cmp %o3, %o2 ! Check whether successful
+ bne 0b
+ membar #LoadLoad | #LoadStore ! Ensure the cas finishes before
+ ! returning
+ retl ! return
+ mov %o1, %o0 ! Set the return value
+
+ .size _STLP_atomic_increment,(.-_STLP_atomic_increment)
+
+
+! /* int _STLP_atomic_decrement (void *pvalue) */
+ .type _STLP_atomic_decrement,#function
+ .global _STLP_atomic_decrement
+ .align 8
+
+_STLP_atomic_decrement:
+0:
+ ldx [%o0], %o2 ! set the current
+ subx %o2, 0x1, %o3 ! decrement and store current
+ casx [%o0], %o2, %o3 ! Do the compare and swap
+ cmp %o3, %o2 ! Check whether successful
+ bne 0b
+ membar #LoadLoad | #LoadStore ! Ensure the cas finishes before
+ ! returning
+ retl ! return
+ nop
+ .size _STLP_atomic_decrement,(.-_STLP_atomic_decrement)
+
+
+
diff --git a/sources/android/stlport/src/sstream.cpp b/sources/android/stlport/src/sstream.cpp
new file mode 100644
index 0000000..2d1d652
--- /dev/null
+++ b/sources/android/stlport/src/sstream.cpp
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#include "stlport_prefix.h"
+
+#include <sstream>
+
+_STLP_BEGIN_NAMESPACE
+
+#if !defined (_STLP_NO_FORCE_INSTANTIATE)
+
+// Force instantiation of stringstream classes.
+template class _STLP_CLASS_DECLSPEC basic_stringbuf<char, char_traits<char>, allocator<char> >;
+template class _STLP_CLASS_DECLSPEC basic_ostringstream<char, char_traits<char>, allocator<char> >;
+template class _STLP_CLASS_DECLSPEC basic_istringstream<char, char_traits<char>, allocator<char> >;
+template class _STLP_CLASS_DECLSPEC basic_stringstream<char, char_traits<char>, allocator<char> >;
+
+# if !defined (_STLP_NO_WCHAR_T)
+template class _STLP_CLASS_DECLSPEC basic_stringbuf<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >;
+template class _STLP_CLASS_DECLSPEC basic_ostringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >;
+template class _STLP_CLASS_DECLSPEC basic_istringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >;
+template class _STLP_CLASS_DECLSPEC basic_stringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >;
+# endif
+
+#endif
+
+_STLP_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/src/stdio_streambuf.cpp b/sources/android/stlport/src/stdio_streambuf.cpp
new file mode 100644
index 0000000..45aad79
--- /dev/null
+++ b/sources/android/stlport/src/stdio_streambuf.cpp
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#include "stlport_prefix.h"
+#include "stdio_streambuf.h"
+
+#ifdef _STLP_UNIX
+# include <sys/types.h>
+# include <sys/stat.h>
+#endif
+
+#include <fstream>
+#include <limits>
+
+_STLP_BEGIN_NAMESPACE
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Compare with streamoff definition in stl/char_traits.h!
+
+#if defined (_STLP_USE_DEFAULT_FILE_OFFSET) || \
+ (!defined(_LARGEFILE_SOURCE) && !defined(_LARGEFILE64_SOURCE))
+# if !defined (_STLP_MSVC) || (_STLP_MSVC < 1400) || defined(_STLP_WCE)
+# define FSEEK fseek
+# else
+# define FSEEK _fseeki64
+# endif
+# define FSETPOS fsetpos
+# define FGETPOS fgetpos
+# define FPOS_T fpos_t
+#else
+# define FSEEK fseeko64
+# define FSETPOS fsetpos64
+# define FGETPOS fgetpos64
+# define FPOS_T fpos64_t
+#endif
+
+//----------------------------------------------------------------------
+// Class stdio_streambuf_base
+
+stdio_streambuf_base::stdio_streambuf_base(FILE* file)
+ : /* _STLP_STD::FILE_basic_streambuf(file, 0), */
+ _M_file(file)
+{}
+
+stdio_streambuf_base::~stdio_streambuf_base() {
+ _STLP_VENDOR_CSTD::fflush(_M_file);
+}
+
+_STLP_STD::streambuf* stdio_streambuf_base::setbuf(char* s, streamsize n) {
+#ifdef _STLP_WCE
+ // no buffering in windows ce .NET
+#else
+ size_t __n_size_t = (sizeof(streamsize) > sizeof(size_t)) ? __STATIC_CAST(size_t, (min)(__STATIC_CAST(streamsize, (numeric_limits<size_t>::max)()), n))
+ : __STATIC_CAST(size_t, n);
+ _STLP_VENDOR_CSTD::setvbuf(_M_file, s, (s == 0 && n == 0) ? _IONBF : _IOFBF, __n_size_t);
+#endif
+ return this;
+}
+
+stdio_streambuf_base::pos_type
+stdio_streambuf_base::seekoff(off_type off, ios_base::seekdir dir,
+ ios_base::openmode /* mode */) {
+ int whence;
+ switch (dir) {
+ case ios_base::beg:
+ whence = SEEK_SET;
+ break;
+ case ios_base::cur:
+ whence = SEEK_CUR;
+ break;
+ case ios_base::end:
+ whence = SEEK_END;
+ break;
+ default:
+ return pos_type(-1);
+ }
+
+ if (off <= numeric_limits<off_type>::max() && FSEEK(_M_file, off, whence) == 0) {
+ FPOS_T pos;
+ FGETPOS(_M_file, &pos);
+ // added 21 june 00 mdb,rjf,wjs: glibc 2.2 changed fpos_t to be a struct instead
+ // of a primitive type
+#if (defined (__GLIBC__) && ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 2))))
+ return pos_type((streamoff)pos.__pos);
+#elif defined (__ISCPP__) || defined (__MVS__) || defined (__OS400__)
+ return pos_type(pos.__fpos_elem[ 0 ]);
+#elif defined (__EMX__)
+ return pos_type((streamoff)pos._pos);
+#else
+ return pos_type(pos);
+#endif
+ }
+ else
+ return pos_type(-1);
+}
+
+
+stdio_streambuf_base::pos_type
+stdio_streambuf_base::seekpos(pos_type pos, ios_base::openmode /* mode */) {
+ // added 21 june 00 mdb,rjf,wjs: glibc 2.2 changed fpos_t to be a struct instead
+ // of a primitive type
+#if (defined(__GLIBC__) && ( (__GLIBC__ > 2) || ( (__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 2) ) ) )
+ FPOS_T p;
+ p.__pos = pos;
+# ifdef _STLP_USE_UCLIBC
+# ifdef __STDIO_MBSTATE
+ memset( &(p.__mbstate), 0, sizeof(p.__mbstate) );
+# endif
+# ifdef __STDIO_WIDE
+ p.mblen_pending = 0;
+# endif
+# else
+ memset( &(p.__state), 0, sizeof(p.__state) );
+# endif
+#elif defined (__MVS__) || defined (__OS400__)
+ FPOS_T p;
+ p.__fpos_elem[0] = pos;
+#elif defined (__EMX__)
+ FPOS_T p;
+ p._pos = pos;
+ memset( &(p._mbstate), 0, sizeof(p._mbstate) );
+#else
+ FPOS_T p(pos);
+#endif
+
+ return FSETPOS(_M_file, &p) == 0 ? pos : pos_type(-1);
+}
+
+int stdio_streambuf_base::sync() {
+ return _STLP_VENDOR_CSTD::fflush(_M_file) == 0 ? 0 : -1;
+}
+
+//----------------------------------------------------------------------
+// Class stdio_istreambuf
+
+stdio_istreambuf::~stdio_istreambuf() {}
+
+streamsize stdio_istreambuf::showmanyc()
+{ return 0; }
+
+stdio_istreambuf::int_type stdio_istreambuf::underflow()
+{
+#ifdef _STLP_WCE
+ int c = fgetc(_M_file);
+#else
+ int c = getc(_M_file);
+#endif
+ if (c != EOF) {
+ _STLP_VENDOR_CSTD::ungetc(c, _M_file);
+ return c;
+ }
+ else
+ return traits_type::eof();
+}
+
+stdio_istreambuf::int_type stdio_istreambuf::uflow() {
+#ifdef _STLP_WCE
+ int c = fgetc(_M_file);
+#else
+ int c = getc(_M_file);
+#endif
+ return c != EOF ? c : traits_type::eof();
+}
+
+stdio_istreambuf::int_type stdio_istreambuf::pbackfail(int_type c) {
+ if (c != traits_type::eof()) {
+ int result = _STLP_VENDOR_CSTD::ungetc(c, _M_file);
+ return result != EOF ? result : traits_type::eof();
+ }
+ else{
+ if (this->eback() < this->gptr()) {
+ this->gbump(-1);
+ return traits_type::not_eof(c);
+ }
+ else
+ return traits_type::eof();
+ }
+}
+
+//----------------------------------------------------------------------
+// Class stdio_ostreambuf
+
+stdio_ostreambuf::~stdio_ostreambuf() {}
+
+streamsize stdio_ostreambuf::showmanyc()
+{ return -1; }
+
+stdio_ostreambuf::int_type stdio_ostreambuf::overflow(int_type c) {
+ // Write the existing buffer, without writing any additional character.
+ if (c == traits_type::eof()) {
+ // Do we have a buffer to write?
+ ptrdiff_t unwritten = this->pptr() - this->pbase();
+ if (unwritten != 0) {
+ _STLP_VENDOR_CSTD::fflush(_M_file);
+ // Test if the write succeeded.
+ if (this->pptr() - this->pbase() < unwritten)
+ return traits_type::not_eof(c);
+ else
+ return traits_type::eof();
+ }
+
+ // We always succeed if we don't have to do anything.
+ else
+ return traits_type::not_eof(c);
+ }
+
+ // Write the character c, and whatever else might be in the buffer.
+ else {
+#ifdef _STLP_WCE
+ int result = fputc(c, _M_file);
+#else
+ int result = putc(c, _M_file);
+#endif
+ return result != EOF ? result : traits_type::eof();
+ }
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+_STLP_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/src/stdio_streambuf.h b/sources/android/stlport/src/stdio_streambuf.h
new file mode 100644
index 0000000..33747b5
--- /dev/null
+++ b/sources/android/stlport/src/stdio_streambuf.h
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+// This header defines two streambufs:
+// stdio_istreambuf, a read-only streambuf synchronized with a C stdio
+// FILE object
+// stdio_ostreambuf, a write-only streambuf synchronized with a C stdio
+// FILE object.
+// Note that neither stdio_istreambuf nor stdio_ostreambuf is a template;
+// both classes are derived from basic_streambuf<char, char_traits<char> >.
+
+// Note: the imbue() member function is a no-op. In particular, these
+// classes assume that codecvt<char, char, mbstate_t> is always an identity
+// transformation. This is true of the default locale, and of all locales
+// defined for the C I/O library. If you need to use a locale where
+// the codecvt<char, char, mbstate_t> facet performs a nontrivial
+// conversion, then you should use basic_filebuf<> instead of stdio_istreambuf
+// or stdio_ostreambuf. (If you don't understand what any of this means,
+// then it's not a feature you need to worry about. Locales where
+// codecvt<char, char, mbstate_t> does something nontrivial are a rare
+// corner case.)
+
+
+#ifndef _STLP_STDIO_STREAMBUF
+#define _STLP_STDIO_STREAMBUF
+
+#include <streambuf>
+#include <cstdio> // For FILE.
+
+_STLP_BEGIN_NAMESPACE
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Base class for features common to stdio_istreambuf and stdio_ostreambuf
+class stdio_streambuf_base :
+ public basic_streambuf<char, char_traits<char> > /* FILE_basic_streambuf */ {
+public: // Constructor, destructor.
+ // The argument may not be null. It must be an open file pointer.
+ stdio_streambuf_base(FILE*);
+
+ // The destructor flushes the stream, but does not close it.
+ ~stdio_streambuf_base();
+
+protected: // Virtual functions from basic_streambuf.
+ streambuf* setbuf(char*, streamsize);
+
+ pos_type seekoff(off_type, ios_base::seekdir,
+ ios_base::openmode
+ = ios_base::in | ios_base::out);
+ pos_type seekpos(pos_type,
+ ios_base::openmode
+ = ios_base::in | ios_base::out);
+ int sync();
+
+protected:
+ FILE* _M_file;
+};
+
+class stdio_istreambuf : public stdio_streambuf_base {
+public: // Constructor, destructor.
+ stdio_istreambuf(FILE* __f) : stdio_streambuf_base(__f) {}
+ ~stdio_istreambuf();
+
+protected: // Virtual functions from basic_streambuf.
+ streamsize showmanyc();
+ int_type underflow();
+ int_type uflow();
+ virtual int_type pbackfail(int_type c = traits_type::eof());
+};
+
+class stdio_ostreambuf : public stdio_streambuf_base {
+public: // Constructor, destructor.
+ stdio_ostreambuf(FILE* __f) : stdio_streambuf_base(__f) {}
+ ~stdio_ostreambuf();
+
+protected: // Virtual functions from basic_streambuf.
+ streamsize showmanyc();
+ int_type overflow(int_type c = traits_type::eof());
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_STDIO_STREAMBUF */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/src/stlport.rc b/sources/android/stlport/src/stlport.rc
new file mode 100644
index 0000000..3fdb4a7
--- /dev/null
+++ b/sources/android/stlport/src/stlport.rc
@@ -0,0 +1,96 @@
+///////////////////////////
+//
+// Version
+//
+#include <windows.h>
+
+#include <stl/_stlport_version.h>
+
+/* On some evc3/evc4 targets the windows.h doesn't include winver.h or doesn't
+ * define needed file version flags, so we redefine them here.
+ */
+#ifndef VS_FF_DEBUG
+# define VS_FF_DEBUG 0x00000001L
+#endif
+
+#ifndef VOS__WINDOWS32
+# define VOS__WINDOWS32 0x00000004L
+#endif
+
+#ifndef VFT_DLL
+# define VFT_DLL 0x00000002L
+#endif
+
+#ifndef VFT2_UNKNOWN
+# define VFT2_UNKNOWN 0x00000000L
+#endif
+
+#define STRINGIZE(X) STRINGIZE_AUX(X)
+#define STRINGIZE_AUX(X) #X
+
+#define VERSION_ID _STLPORT_MAJOR, _STLPORT_MINOR, _STLPORT_PATCHLEVEL, 0
+#if !defined (__BORLANDC__)
+# define VERSION_STR STRINGIZE(_STLPORT_MAJOR._STLPORT_MINOR._STLPORT_PATCHLEVEL)
+#else
+/* Borland precompiler happen weird character when trying to transform a
+ * macro containing 0 in a character string so we use a workaround for this
+ * value. We do not check the major version that will never be 0 again.
+ */
+# if (_STLPORT_MINOR == 0)
+# define _STLP_MINOR "0"
+# else
+# define _STLP_MINOR STRINGIZE(_STLPORT_MINOR)
+# endif
+# if (_STLPORT_PATCHLEVEL == 0)
+# define _STLP_PATCH "0"
+# else
+# define _STLP_PATCH STRINGIZE(_STLPORT_PATCHLEVEL)
+# endif
+# define VERSION_STR STRINGIZE(_STLPORT_MAJOR) "." _STLP_MINOR "." _STLP_PATCH "\0"
+#endif
+
+#if defined (__GNUC__)
+# define LIB_MOTIF "libstlport"
+#else
+# define LIB_MOTIF "stlport"
+#endif
+#define DLLNAME LIB_MOTIF "." STRINGIZE(_STLPORT_MAJOR) "." STRINGIZE(_STLPORT_MINOR) ".dll\0"
+#define DLLNAME2(buildstr) LIB_MOTIF "" STRINGIZE(buildstr) "." STRINGIZE(_STLPORT_MAJOR) "." STRINGIZE(_STLPORT_MINOR) ".dll\0"
+
+VS_VERSION_INFO VERSIONINFO
+FILEVERSION VERSION_ID
+PRODUCTVERSION VERSION_ID
+FILEFLAGSMASK 0x3fL
+
+FILEFLAGS VS_FF_DEBUG
+
+FILEOS VOS__WINDOWS32
+FILETYPE VFT_DLL
+FILESUBTYPE VFT2_UNKNOWN
+BEGIN
+ BLOCK "StringFileInfo"
+ BEGIN
+ BLOCK "040904B0"
+ BEGIN
+ VALUE "CompanyName", "STLport Consulting, Inc.\0"
+ VALUE "FileDescription", "STLport\0"
+ VALUE "FileVersion", VERSION_STR
+ VALUE "InternalName", "STLPORT.DLL\0"
+ VALUE "LegalCopyright", "Copyright (C) Boris Fomitchev\0"
+#if !defined (BUILD)
+ VALUE "OriginalFilename", DLLNAME
+#else
+ VALUE "OriginalFilename", DLLNAME2(BUILD)
+#endif
+ VALUE "ProductName", "STLport Standard ANSI C++ Library\0"
+ VALUE "ProductVersion", VERSION_STR
+#if defined (BUILD_INFOS)
+ VALUE "SpecialBuild", STRINGIZE(COMP) " " STRINGIZE(BUILD_INFOS) "\0"
+#endif
+ END
+ END
+ BLOCK "VarFileInfo"
+ BEGIN
+ VALUE "Translation", 0x409, 1200
+ END
+END
diff --git a/sources/android/stlport/src/stlport_prefix.h b/sources/android/stlport/src/stlport_prefix.h
new file mode 100644
index 0000000..4e06b76
--- /dev/null
+++ b/sources/android/stlport/src/stlport_prefix.h
@@ -0,0 +1,43 @@
+#ifndef STLPORT_PREFIX_H
+#define STLPORT_PREFIX_H
+
+#define __BUILDING_STLPORT 1
+
+#if defined (_WIN32) || defined (WIN32)
+# ifdef __cplusplus
+# define WIN32_LEAN_AND_MEAN
+# define NOSERVICE
+# endif
+#endif
+
+#undef _STLP_NO_FORCE_INSTANTIATE
+
+/* Please add extra compilation switches for particular compilers here */
+
+#if defined (_MSC_VER) && !defined (__COMO__) && !defined (__MWERKS__)
+# include "warning_disable.h"
+#endif
+
+#include <stl/config/features.h>
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT) && defined (_STLP_USE_DECLSPEC) && !defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)
+# define _STLP_EXPOSE_GLOBALS_IMPLEMENTATION
+#endif
+
+#ifdef __cplusplus
+
+# include <ctime>
+# if defined (_STLP_USE_NAMESPACES) && !defined (_STLP_VENDOR_GLOBAL_CSTD)
+using _STLP_VENDOR_CSTD::time_t;
+# endif
+
+# if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+# define _STLP_OPERATOR_SPEC _STLP_DECLSPEC
+# else
+# define _STLP_OPERATOR_SPEC _STLP_TEMPLATE_NULL _STLP_DECLSPEC
+# endif
+
+#endif /* __cplusplus */
+
+#endif /* PREFIX */
+
diff --git a/sources/android/stlport/src/string.cpp b/sources/android/stlport/src/string.cpp
new file mode 100644
index 0000000..77e2187
--- /dev/null
+++ b/sources/android/stlport/src/string.cpp
@@ -0,0 +1,93 @@
+#include "stlport_prefix.h"
+
+#include <string>
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined(_STLP_USE_WIDE_INTERFACE)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+wstring __ASCIIToWide(const char *ascii) {
+ size_t size = strlen(ascii);
+ wchar_t* buff = new wchar_t[size+1];
+ mbstowcs(buff, ascii, size);
+ buff[size] = 0x00;
+ wstring ret(buff);
+ delete[] buff;
+ return ret;
+}
+string __WideToASCII(const wchar_t *wide) {
+ size_t size = wcslen(wide);
+ char* buff = new char[size+1];
+ wcstombs(buff, wide, size);
+ buff[size] = 0;
+ string ret(buff);
+ delete[] buff;
+ return ret;
+}
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#if !defined (_STLP_NO_FORCE_INSTANTIATE)
+
+template class _STLP_CLASS_DECLSPEC allocator<char>;
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template class _STLP_CLASS_DECLSPEC _STLP_alloc_proxy<char*, char, allocator<char> >;
+template class _STLP_CLASS_DECLSPEC _String_base<char, allocator<char> >;
+
+# if defined (_STLP_DEBUG) && !defined (__SUNPRO_CC) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+# define basic_string _STLP_NON_DBG_NAME(str)
+
+template class _STLP_CLASS_DECLSPEC basic_string<char, char_traits<char>, allocator<char> >;
+template class _STLP_CLASS_DECLSPEC __construct_checker<basic_string<char, char_traits<char>, allocator<char> > >;
+
+# undef basic_string
+# endif
+
+# if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+# define basic_string _STLP_NO_MEM_T_NAME(str)
+# else
+_STLP_MOVE_TO_STD_NAMESPACE
+# endif
+
+template class _STLP_CLASS_DECLSPEC basic_string<char, char_traits<char>, allocator<char> >;
+
+# if defined (basic_string)
+_STLP_MOVE_TO_STD_NAMESPACE
+# undef basic_string
+# endif
+
+# if !defined (_STLP_NO_WCHAR_T)
+template class _STLP_CLASS_DECLSPEC allocator<wchar_t>;
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template class _STLP_CLASS_DECLSPEC _String_base<wchar_t, allocator<wchar_t> >;
+
+# if defined (_STLP_DEBUG) && !defined (__SUNPRO_CC) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+# define basic_string _STLP_NON_DBG_NAME(str)
+
+template class _STLP_CLASS_DECLSPEC basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >;
+template class _STLP_CLASS_DECLSPEC __construct_checker<basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > >;
+
+# undef basic_string
+# endif
+
+# if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+# define basic_string _STLP_NO_MEM_T_NAME(str)
+# else
+_STLP_MOVE_TO_STD_NAMESPACE
+# endif
+
+template class _STLP_CLASS_DECLSPEC basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >;
+
+# if defined (basic_string)
+_STLP_MOVE_TO_STD_NAMESPACE
+# undef basic_string
+# endif
+# endif
+#endif
+
+_STLP_END_NAMESPACE
diff --git a/sources/android/stlport/src/strstream.cpp b/sources/android/stlport/src/strstream.cpp
new file mode 100644
index 0000000..740e01e
--- /dev/null
+++ b/sources/android/stlport/src/strstream.cpp
@@ -0,0 +1,391 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+// Implementation of the classes in header <strstream>.
+// WARNING: The classes defined in <strstream> are DEPRECATED. This
+// header is defined in section D.7.1 of the C++ standard, and it
+// MAY BE REMOVED in a future standard revision. You should use the
+// header <sstream> instead.
+
+#include "stlport_prefix.h"
+
+#include <strstream>
+#include <algorithm>
+#include <limits>
+
+_STLP_BEGIN_NAMESPACE
+
+// strstreambuf constructor, destructor.
+strstreambuf::strstreambuf(streamsize initial_capacity)
+ : _M_alloc_fun(0), _M_free_fun(0),
+ _M_dynamic(true), _M_frozen(false), _M_constant(false) {
+ size_t n = (sizeof(streamsize) > sizeof(size_t)) ? __STATIC_CAST(size_t, (min)(__STATIC_CAST(streamsize, (numeric_limits<size_t>::max)()),
+ (max)(initial_capacity, streamsize(16))))
+ : __STATIC_CAST(size_t, (max)(initial_capacity, streamsize(16)));
+
+ char* buf = _M_alloc(n);
+ if (buf) {
+ setp(buf, buf + n);
+ setg(buf, buf, buf);
+ }
+}
+
+strstreambuf::strstreambuf(__alloc_fn alloc_f, __free_fn free_f)
+ : _M_alloc_fun(alloc_f), _M_free_fun(free_f),
+ _M_dynamic(true), _M_frozen(false), _M_constant(false) {
+ size_t n = 16;
+
+ char* buf = _M_alloc(n);
+ if (buf) {
+ setp(buf, buf + n);
+ setg(buf, buf, buf);
+ }
+}
+
+strstreambuf::strstreambuf(char* get, streamsize n, char* put)
+ : _M_alloc_fun(0), _M_free_fun(0),
+ _M_dynamic(false), _M_frozen(false), _M_constant(false) {
+ _M_setup(get, put, n);
+}
+
+strstreambuf::strstreambuf(signed char* get, streamsize n, signed char* put)
+ : _M_alloc_fun(0), _M_free_fun(0),
+ _M_dynamic(false), _M_frozen(false), _M_constant(false) {
+ _M_setup(__REINTERPRET_CAST(char*,get), __REINTERPRET_CAST(char*,put), n);
+}
+
+strstreambuf::strstreambuf(unsigned char* get, streamsize n,
+ unsigned char* put)
+ : _M_alloc_fun(0), _M_free_fun(0),
+ _M_dynamic(false), _M_frozen(false), _M_constant(false) {
+ _M_setup(__REINTERPRET_CAST(char*,get), __REINTERPRET_CAST(char*,put), n);
+}
+
+strstreambuf::strstreambuf(const char* get, streamsize n)
+ : _M_alloc_fun(0), _M_free_fun(0),
+ _M_dynamic(false), _M_frozen(false), _M_constant(true) {
+ _M_setup(__CONST_CAST(char*,get), 0, n);
+}
+
+strstreambuf::strstreambuf(const signed char* get, streamsize n)
+ : _M_alloc_fun(0), _M_free_fun(0),
+ _M_dynamic(false), _M_frozen(false), _M_constant(true) {
+ _M_setup(__REINTERPRET_CAST(char*, __CONST_CAST(signed char*,get)), 0, n);
+}
+
+strstreambuf::strstreambuf(const unsigned char* get, streamsize n)
+ : _M_alloc_fun(0), _M_free_fun(0),
+ _M_dynamic(false), _M_frozen(false), _M_constant(true) {
+ _M_setup(__REINTERPRET_CAST(char*, __CONST_CAST(unsigned char*,get)), 0, n);
+}
+
+strstreambuf::~strstreambuf() {
+ if (_M_dynamic && !_M_frozen)
+ _M_free(eback());
+}
+
+void strstreambuf::freeze(bool frozenflag) {
+ if (_M_dynamic)
+ _M_frozen = frozenflag;
+}
+
+char* strstreambuf::str() {
+ freeze(true);
+ return eback();
+}
+
+int strstreambuf::pcount() const {
+ return int(pptr() ? pptr() - pbase() : 0);
+}
+
+strstreambuf::int_type strstreambuf::overflow(int_type c) {
+ if (c == traits_type::eof())
+ return traits_type::not_eof(c);
+
+ // Try to expand the buffer.
+ if (pptr() == epptr() && _M_dynamic && !_M_frozen && !_M_constant) {
+ ptrdiff_t old_size = epptr() - pbase();
+ ptrdiff_t new_size = (max)(2 * old_size, ptrdiff_t(1));
+
+ char* buf = _M_alloc(new_size);
+ if (buf) {
+ memcpy(buf, pbase(), old_size);
+
+ char* old_buffer = pbase();
+ bool reposition_get = false;
+ ptrdiff_t old_get_offset;
+ if (gptr() != 0) {
+ reposition_get = true;
+ old_get_offset = gptr() - eback();
+ }
+
+ setp(buf, buf + new_size);
+ pbump((int)old_size);
+
+ if (reposition_get)
+ setg(buf, buf + old_get_offset, buf + (max)(old_get_offset, old_size));
+
+ _M_free(old_buffer);
+ }
+ }
+
+ if (pptr() != epptr()) {
+ *pptr() = traits_type::to_char_type(c);
+ pbump(1);
+ return c;
+ }
+ else
+ return traits_type::eof();
+}
+
+strstreambuf::int_type strstreambuf::pbackfail(int_type c) {
+ if (gptr() != eback()) {
+ if (c == traits_type::eof()) {
+ gbump(-1);
+ return traits_type::not_eof(c);
+ }
+ else if (c == gptr()[-1]) {
+ gbump(-1);
+ return c;
+ }
+ else if (!_M_constant) {
+ gbump(-1);
+ *gptr() = traits_type::to_char_type(c);
+ return c;
+ }
+ }
+
+ return traits_type::eof();
+}
+
+strstreambuf::int_type strstreambuf::underflow() {
+ if (gptr() == egptr() && pptr() && pptr() > egptr())
+ setg(eback(), gptr(), pptr());
+
+ if (gptr() != egptr())
+ return (unsigned char) *gptr();
+ else
+ return _Traits::eof();
+}
+
+basic_streambuf<char, char_traits<char> >*
+strstreambuf::setbuf(char*, streamsize) {
+ return this;
+}
+
+strstreambuf::pos_type
+strstreambuf::seekoff(off_type off,
+ ios_base::seekdir dir, ios_base::openmode mode) {
+ bool do_get = false;
+ bool do_put = false;
+
+ if ((mode & (ios_base::in | ios_base::out)) ==
+ (ios_base::in | ios_base::out) &&
+ (dir == ios_base::beg || dir == ios_base::end))
+ do_get = do_put = true;
+ else if (mode & ios_base::in)
+ do_get = true;
+ else if (mode & ios_base::out)
+ do_put = true;
+
+ // !gptr() is here because, according to D.7.1 paragraph 4, the seekable
+ // area is undefined if there is no get area.
+ if ((!do_get && !do_put) || (do_put && !pptr()) || !gptr())
+ return pos_type(off_type(-1));
+
+ char* seeklow = eback();
+ char* seekhigh = epptr() ? epptr() : egptr();
+
+ off_type newoff;
+ switch(dir) {
+ case ios_base::beg:
+ newoff = 0;
+ break;
+ case ios_base::end:
+ newoff = seekhigh - seeklow;
+ break;
+ case ios_base::cur:
+ newoff = do_put ? pptr() - seeklow : gptr() - seeklow;
+ break;
+ default:
+ return pos_type(off_type(-1));
+ }
+
+ off += newoff;
+ if (off < 0 || off > seekhigh - seeklow)
+ return pos_type(off_type(-1));
+
+ if (do_put) {
+ if (seeklow + __STATIC_CAST(ptrdiff_t, off) < pbase()) {
+ setp(seeklow, epptr());
+ pbump((int)off);
+ }
+ else {
+ setp(pbase(), epptr());
+ pbump((int)(off - (pbase() - seeklow)));
+ }
+ }
+ if (do_get) {
+ if (off <= egptr() - seeklow)
+ setg(seeklow, seeklow + __STATIC_CAST(ptrdiff_t, off), egptr());
+ else if (off <= pptr() - seeklow)
+ setg(seeklow, seeklow + __STATIC_CAST(ptrdiff_t, off), pptr());
+ else
+ setg(seeklow, seeklow + __STATIC_CAST(ptrdiff_t, off), epptr());
+ }
+
+ return pos_type(newoff);
+}
+
+strstreambuf::pos_type
+strstreambuf::seekpos(pos_type pos, ios_base::openmode mode) {
+ return seekoff(pos - pos_type(off_type(0)), ios_base::beg, mode);
+}
+
+
+char* strstreambuf::_M_alloc(size_t n) {
+ if (_M_alloc_fun)
+ return __STATIC_CAST(char*,_M_alloc_fun(n));
+ else
+ return new char[n];
+}
+
+void strstreambuf::_M_free(char* p) {
+ if (p) {
+ if (_M_free_fun)
+ _M_free_fun(p);
+ else
+ delete[] p;
+ }
+}
+
+void strstreambuf::_M_setup(char* get, char* put, streamsize n) {
+ if (get) {
+ size_t N = n > 0 ? size_t(n) : n == 0 ? strlen(get) : size_t(INT_MAX);
+
+ if (put) {
+ setg(get, get, get + N);
+ setp(put, put + N);
+ }
+ else {
+ setg(get, get, get + N);
+ }
+ }
+}
+
+//----------------------------------------------------------------------
+// Class istrstream
+
+istrstream::istrstream(char* s)
+ : basic_istream<char, char_traits<char> >(0), _M_buf(s, 0) {
+ this->init(&_M_buf);
+}
+
+istrstream::istrstream(const char* s)
+ : basic_istream<char, char_traits<char> >(0), _M_buf(s, 0) {
+ this->init(&_M_buf);
+}
+
+istrstream::istrstream(char* s, streamsize n)
+ : basic_istream<char, char_traits<char> >(0), _M_buf(s, n) {
+ this->init(&_M_buf);
+}
+
+istrstream::istrstream(const char* s, streamsize n)
+ : basic_istream<char, char_traits<char> >(0), _M_buf(s, n) {
+ this->init(&_M_buf);
+}
+
+istrstream::~istrstream() {}
+
+strstreambuf* istrstream::rdbuf() const {
+ return __CONST_CAST(strstreambuf*,&_M_buf);
+}
+
+char* istrstream::str() { return _M_buf.str(); }
+
+//----------------------------------------------------------------------
+// Class ostrstream
+
+ostrstream::ostrstream()
+ : basic_ostream<char, char_traits<char> >(0), _M_buf() {
+ basic_ios<char, char_traits<char> >::init(&_M_buf);
+}
+
+ostrstream::ostrstream(char* s, int n, ios_base::openmode mode)
+ : basic_ostream<char, char_traits<char> >(0),
+ _M_buf(s, n, mode & ios_base::app ? s + strlen(s) : s) {
+ basic_ios<char, char_traits<char> >::init(&_M_buf);
+}
+
+ostrstream::~ostrstream() {}
+
+strstreambuf* ostrstream::rdbuf() const {
+ return __CONST_CAST(strstreambuf*,&_M_buf);
+}
+
+void ostrstream::freeze(bool freezeflag) {
+ _M_buf.freeze(freezeflag);
+}
+
+char* ostrstream::str() {
+ return _M_buf.str();
+}
+
+int ostrstream::pcount() const {
+ return _M_buf.pcount();
+}
+
+
+//----------------------------------------------------------------------
+// Class strstream
+
+strstream::strstream()
+ : basic_iostream<char, char_traits<char> >(0), _M_buf() {
+ basic_ios<char, char_traits<char> >::init(&_M_buf);
+}
+
+strstream::strstream(char* s, int n, ios_base::openmode mode)
+ : basic_iostream<char, char_traits<char> >(0),
+ _M_buf(s, n, mode & ios_base::app ? s + strlen(s) : s) {
+ basic_ios<char, char_traits<char> >::init(&_M_buf);
+}
+
+strstream::~strstream() {}
+
+strstreambuf* strstream::rdbuf() const {
+ return __CONST_CAST(strstreambuf*,&_M_buf);
+}
+
+void strstream::freeze(bool freezeflag) {
+ _M_buf.freeze(freezeflag);
+}
+
+int strstream::pcount() const {
+ return _M_buf.pcount();
+}
+
+char* strstream::str() {
+ return _M_buf.str();
+}
+
+_STLP_END_NAMESPACE
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/src/time_facets.cpp b/sources/android/stlport/src/time_facets.cpp
new file mode 100644
index 0000000..3e98c70
--- /dev/null
+++ b/sources/android/stlport/src/time_facets.cpp
@@ -0,0 +1,565 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#include "stlport_prefix.h"
+
+#include <cstdio>
+#include <locale>
+#include <istream>
+
+#include "c_locale.h"
+#include "acquire_release.h"
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// default "C" values for month and day names
+
+const char default_dayname[][14] = {
+ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat",
+ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
+ "Friday", "Saturday"};
+
+const char default_monthname[][24] = {
+ "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+ "January", "February", "March", "April", "May", "June",
+ "July", "August", "September", "October", "November", "December"};
+
+#ifndef _STLP_NO_WCHAR_T
+const wchar_t default_wdayname[][14] = {
+ L"Sun", L"Mon", L"Tue", L"Wed", L"Thu", L"Fri", L"Sat",
+ L"Sunday", L"Monday", L"Tuesday", L"Wednesday", L"Thursday",
+ L"Friday", L"Saturday"};
+
+const wchar_t default_wmonthname[][24] = {
+ L"Jan", L"Feb", L"Mar", L"Apr", L"May", L"Jun",
+ L"Jul", L"Aug", L"Sep", L"Oct", L"Nov", L"Dec",
+ L"January", L"February", L"March", L"April", L"May", L"June",
+ L"July", L"August", L"September", L"October", L"November", L"December"};
+#endif
+
+#if defined (__BORLANDC__)
+_Time_Info time_init<char>::_M_timeinfo;
+# ifndef _STLP_NO_WCHAR_T
+_WTime_Info time_init<wchar_t>::_M_timeinfo;
+# endif
+#endif
+
+// _Init_time_info: initialize table with
+// "C" values (note these are not defined in the C standard, so this
+// is somewhat arbitrary).
+
+static void _Init_timeinfo_base(_Time_Info_Base& table) {
+ table._M_time_format = "%H:%M:%S";
+ table._M_date_format = "%m/%d/%y";
+ table._M_date_time_format = "%m/%d/%y";
+}
+
+static void _Init_timeinfo(_Time_Info& table) {
+ int i;
+ for (i = 0; i < 14; ++i)
+ table._M_dayname[i] = default_dayname[i];
+ for (i = 0; i < 24; ++i)
+ table._M_monthname[i] = default_monthname[i];
+ table._M_am_pm[0] = "AM";
+ table._M_am_pm[1] = "PM";
+ _Init_timeinfo_base(table);
+}
+
+#ifndef _STLP_NO_WCHAR_T
+static void _Init_timeinfo(_WTime_Info& table) {
+ int i;
+ for (i = 0; i < 14; ++i)
+ table._M_dayname[i] = default_wdayname[i];
+ for (i = 0; i < 24; ++i)
+ table._M_monthname[i] = default_wmonthname[i];
+ table._M_am_pm[0] = L"AM";
+ table._M_am_pm[1] = L"PM";
+ _Init_timeinfo_base(table);
+}
+#endif
+
+static void _Init_timeinfo_base(_Time_Info_Base& table, _Locale_time * time) {
+ table._M_time_format = _Locale_t_fmt(time);
+ if ( table._M_time_format == "%T" ) {
+ table._M_time_format = "%H:%M:%S";
+ } else if ( table._M_time_format == "%r" ) {
+ table._M_time_format = "%I:%M:%S %p";
+ } else if ( table._M_time_format == "%R" ) {
+ table._M_time_format = "%H:%M";
+ }
+ table._M_date_format = _Locale_d_fmt(time);
+ table._M_date_time_format = _Locale_d_t_fmt(time);
+ table._M_long_date_format = _Locale_long_d_fmt(time);
+ table._M_long_date_time_format = _Locale_long_d_t_fmt(time);
+}
+
+static void _Init_timeinfo(_Time_Info& table, _Locale_time * time) {
+ int i;
+ for (i = 0; i < 7; ++i)
+ table._M_dayname[i] = _Locale_abbrev_dayofweek(time, i);
+ for (i = 0; i < 7; ++i)
+ table._M_dayname[i+7] = _Locale_full_dayofweek(time, i);
+ for (i = 0; i < 12; ++i)
+ table._M_monthname[i] = _Locale_abbrev_monthname(time, i);
+ for (i = 0; i < 12; ++i)
+ table._M_monthname[i+12] = _Locale_full_monthname(time, i);
+ table._M_am_pm[0] = _Locale_am_str(time);
+ table._M_am_pm[1] = _Locale_pm_str(time);
+ _Init_timeinfo_base(table, time);
+}
+
+#ifndef _STLP_NO_WCHAR_T
+static void _Init_timeinfo(_WTime_Info& table, _Locale_time * time) {
+ wchar_t buf[128];
+ int i;
+ for (i = 0; i < 7; ++i)
+ table._M_dayname[i] = _WLocale_abbrev_dayofweek(time, i, _STLP_ARRAY_AND_SIZE(buf));
+ for (i = 0; i < 7; ++i)
+ table._M_dayname[i+7] = _WLocale_full_dayofweek(time, i, _STLP_ARRAY_AND_SIZE(buf));
+ for (i = 0; i < 12; ++i)
+ table._M_monthname[i] = _WLocale_abbrev_monthname(time, i, _STLP_ARRAY_AND_SIZE(buf));
+ for (i = 0; i < 12; ++i)
+ table._M_monthname[i+12] = _WLocale_full_monthname(time, i, _STLP_ARRAY_AND_SIZE(buf));
+ table._M_am_pm[0] = _WLocale_am_str(time, _STLP_ARRAY_AND_SIZE(buf));
+ table._M_am_pm[1] = _WLocale_pm_str(time, _STLP_ARRAY_AND_SIZE(buf));
+ _Init_timeinfo_base(table, time);
+}
+#endif
+
+template <class _Ch, class _TimeInfo>
+void __subformat(_STLP_BASIC_IOSTRING(_Ch) &buf, const ctype<_Ch>& ct,
+ const string& format, const _TimeInfo& table, const tm* t) {
+ const char * cp = format.data();
+ const char * cp_end = cp + format.size();
+ while (cp != cp_end) {
+ if (*cp == '%') {
+ char mod = 0;
+ ++cp;
+ if (*cp == '#') {
+ mod = *cp; ++cp;
+ }
+ __write_formatted_timeT(buf, ct, *cp++, mod, table, t);
+ } else
+ buf.append(1, *cp++);
+ }
+}
+
+static void __append(__iostring &buf, const string& name)
+{ buf.append(name.data(), name.data() + name.size()); }
+
+static void __append(__iowstring &buf, const wstring& name)
+{ buf.append(name.data(), name.data() + name.size()); }
+
+static void __append(__iostring &buf, char *first, char *last, const ctype<char>& /* ct */)
+{ buf.append(first, last); }
+
+static void __append(__iowstring &buf, char *first, char *last, const ctype<wchar_t>& ct) {
+ wchar_t _wbuf[64];
+ ct.widen(first, last, _wbuf);
+ buf.append(_wbuf, _wbuf + (last - first));
+}
+
+#if defined (__GNUC__)
+/* The number of days from the first day of the first ISO week of this
+ year to the year day YDAY with week day WDAY. ISO weeks start on
+ Monday; the first ISO week has the year's first Thursday. YDAY may
+ be as small as YDAY_MINIMUM. */
+# define __ISO_WEEK_START_WDAY 1 /* Monday */
+# define __ISO_WEEK1_WDAY 4 /* Thursday */
+# define __YDAY_MINIMUM (-366)
+# define __TM_YEAR_BASE 1900
+static int
+__iso_week_days(int yday, int wday) {
+ /* Add enough to the first operand of % to make it nonnegative. */
+ int big_enough_multiple_of_7 = (-__YDAY_MINIMUM / 7 + 2) * 7;
+ return (yday
+ - (yday - wday + __ISO_WEEK1_WDAY + big_enough_multiple_of_7) % 7
+ + __ISO_WEEK1_WDAY - __ISO_WEEK_START_WDAY);
+}
+
+# define __is_leap(year)\
+ ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
+
+#endif
+
+#define __hour12(hour) \
+ (((hour) % 12 == 0) ? (12) : (hour) % 12)
+
+#if !defined (_STLP_USE_SAFE_STRING_FUNCTIONS)
+# define _STLP_SPRINTF sprintf
+#else
+# define _STLP_SPRINTF sprintf_s
+#endif
+
+template <class _Ch, class _TimeInfo>
+void _STLP_CALL __write_formatted_timeT(_STLP_BASIC_IOSTRING(_Ch) &buf,
+ const ctype<_Ch>& ct,
+ char format, char modifier,
+ const _TimeInfo& table, const tm* t) {
+ char _buf[64];
+ char *_bend;
+
+ switch (format) {
+ case 'a':
+ __append(buf, table._M_dayname[t->tm_wday]);
+ break;
+
+ case 'A':
+ __append(buf, table._M_dayname[t->tm_wday + 7]);
+ break;
+
+ case 'b':
+ __append(buf, table._M_monthname[t->tm_mon]);
+ break;
+
+ case 'B':
+ __append(buf, table._M_monthname[t->tm_mon + 12]);
+ break;
+
+ case 'c':
+ __subformat(buf, ct, (modifier != '#') ? table._M_date_time_format
+ : table._M_long_date_time_format, table, t);
+ break;
+
+ case 'd':
+ _STLP_SPRINTF(_buf, (modifier != '#') ? "%.2ld" : "%ld", (long)t->tm_mday);
+ __append(buf, _buf, ((long)t->tm_mday < 10L && modifier == '#') ? _buf + 1 : _buf + 2, ct);
+ break;
+
+ case 'e':
+ _STLP_SPRINTF(_buf, "%2ld", (long)t->tm_mday);
+ __append(buf, _buf, _buf + 2, ct);
+ break;
+
+ case 'H':
+ _STLP_SPRINTF(_buf, (modifier != '#') ? "%.2ld" : "%ld", (long)t->tm_hour);
+ __append(buf, _buf, ((long)t->tm_hour < 10L && modifier == '#') ? _buf + 1 : _buf + 2, ct);
+ break;
+
+ case 'I':
+ _STLP_SPRINTF(_buf, (modifier != '#') ? "%.2ld" : "%ld", (long)__hour12(t->tm_hour));
+ __append(buf, _buf, ((long)__hour12(t->tm_hour) < 10L && modifier == '#') ? _buf + 1 : _buf + 2, ct);
+ break;
+
+ case 'j':
+ _bend = __write_integer(_buf, 0, (long)((long)t->tm_yday + 1));
+ __append(buf, _buf, _bend, ct);
+ break;
+
+ case 'm':
+ _STLP_SPRINTF(_buf, (modifier != '#') ? "%.2ld" : "%ld", (long)t->tm_mon + 1);
+ __append(buf, _buf, ((long)(t->tm_mon + 1) < 10L && modifier == '#') ? _buf + 1 : _buf + 2, ct);
+ break;
+
+ case 'M':
+ _STLP_SPRINTF(_buf, (modifier != '#') ? "%.2ld" : "%ld", (long)t->tm_min);
+ __append(buf, _buf, ((long)t->tm_min < 10L && modifier == '#') ? _buf + 1 : _buf + 2, ct);
+ break;
+
+ case 'p':
+ __append(buf, table._M_am_pm[t->tm_hour / 12]);
+ break;
+
+ case 'S': // pad with zeros
+ _STLP_SPRINTF(_buf, (modifier != '#') ? "%.2ld" : "%ld", (long)t->tm_sec);
+ __append(buf, _buf, ((long)t->tm_sec < 10L && modifier == '#') ? _buf + 1 : _buf + 2, ct);
+ break;
+
+ case 'U':
+ _bend = __write_integer(_buf, 0, long((t->tm_yday - t->tm_wday + 7) / 7));
+ __append(buf, _buf, _bend, ct);
+ break;
+
+ case 'w':
+ _bend = __write_integer(_buf, 0, (long)t->tm_wday);
+ __append(buf, _buf, _bend, ct);
+ break;
+
+ case 'W':
+ _bend = __write_integer(_buf, 0,
+ (long)(t->tm_wday == 0 ? (t->tm_yday + 1) / 7 :
+ (t->tm_yday + 8 - t->tm_wday) / 7));
+ __append(buf, _buf, _bend, ct);
+ break;
+
+ case'x':
+ __subformat(buf, ct, (modifier != '#') ? table._M_date_format
+ : table._M_long_date_format, table, t);
+ break;
+
+ case 'X':
+ __subformat(buf, ct, table._M_time_format, table, t);
+ break;
+
+ case 'y':
+ _bend = __write_integer(_buf, 0, (long)((long)(t->tm_year + 1900) % 100));
+ __append(buf, _buf, _bend, ct);
+ break;
+
+ case 'Y':
+ _bend = __write_integer(_buf, 0, (long)((long)t->tm_year + 1900));
+ __append(buf, _buf, _bend, ct);
+ break;
+
+ case '%':
+ buf.append(1, ct.widen('%'));
+ break;
+
+#if defined (__GNUC__)
+ // fbp : at least on SUN
+# if defined (_STLP_UNIX) && !defined (__linux__)
+# define __USE_BSD 1
+# endif
+
+ /*********************************************
+ * JGS, handle various extensions *
+ *********************************************/
+
+ case 'h': /* POSIX.2 extension */
+ // same as 'b', abbrev month name
+ __append(buf, table._M_monthname[t->tm_mon]);
+ break;
+ case 'C': /* POSIX.2 extension */
+ // same as 'd', the day
+ _STLP_SPRINTF(_buf, "%2ld", (long)t->tm_mday);
+ __append(buf, _buf, _buf + 2, ct);
+ break;
+
+ case 'D': /* POSIX.2 extension */
+ // same as 'x'
+ __subformat(buf, ct, table._M_date_format, table, t);
+ break;
+
+ case 'k': /* GNU extension */
+ _STLP_SPRINTF(_buf, "%2ld", (long)t->tm_hour);
+ __append(buf, _buf, _buf + 2, ct);
+ break;
+
+ case 'l': /* GNU extension */
+ _STLP_SPRINTF(_buf, "%2ld", (long)t->tm_hour % 12);
+ __append(buf, _buf, _buf + 2, ct);
+ break;
+
+ case 'n': /* POSIX.2 extension */
+ buf.append(1, ct.widen('\n'));
+ break;
+
+ case 'R': /* GNU extension */
+ __subformat(buf, ct, "%H:%M", table, t);
+ break;
+
+ case 'r': /* POSIX.2 extension */
+ __subformat(buf, ct, "%I:%M:%S %p", table, t);
+ break;
+
+ case 'T': /* POSIX.2 extension. */
+ __subformat(buf, ct, "%H:%M:%S", table, t);
+ break;
+
+ case 't': /* POSIX.2 extension. */
+ buf.append(1, ct.widen('\t'));
+
+ case 'u': /* POSIX.2 extension. */
+ _bend = __write_integer(_buf, 0, long((t->tm_wday - 1 + 7)) % 7 + 1);
+ __append(buf, _buf, _bend, ct);
+ break;
+
+ case 's': {
+ time_t __t = mktime(__CONST_CAST(tm*, t));
+ _bend = __write_integer(_buf, 0, (long)__t );
+ __append(buf, _buf, _bend, ct);
+ break;
+ }
+ case 'g': /* GNU extension */
+ case 'G': {
+ int year = t->tm_year + __TM_YEAR_BASE;
+ int days = __iso_week_days (t->tm_yday, t->tm_wday);
+ if (days < 0) {
+ /* This ISO week belongs to the previous year. */
+ year--;
+ days = __iso_week_days (t->tm_yday + (365 + __is_leap (year)), t->tm_wday);
+ }
+ else {
+ int d = __iso_week_days (t->tm_yday - (365 + __is_leap (year)), t->tm_wday);
+ if (0 <= d) {
+ /* This ISO week belongs to the next year. */
+ ++year;
+ days = d;
+ }
+ }
+ long val;
+ switch (format) {
+ case 'g':
+ val = (long)(year % 100 + 100) % 100;
+ break;
+ case 'G':
+ val = (long)year;
+ break;
+ default:
+ val = (long)days / 7 + 1;
+ break;
+ }
+ _bend = __write_integer(_buf, 0, val);
+ __append(buf, _buf, _bend, ct);
+ break;
+ }
+
+# if defined (_STLP_USE_GLIBC)
+ case 'z': /* GNU extension. */
+ if (t->tm_isdst < 0)
+ break;
+ {
+ int diff;
+# if defined (__USE_BSD) || defined (__BEOS__)
+ diff = t->tm_gmtoff;
+# else
+ diff = t->__tm_gmtoff;
+# endif
+ if (diff < 0) {
+ buf.append(1, ct.widen('-'));
+ diff = -diff;
+ } else
+ buf.append(1, ct.widen('+'));
+ diff /= 60;
+ _STLP_SPRINTF(_buf, "%.4d", (diff / 60) * 100 + diff % 60);
+ __append(buf, _buf, _buf + 4, ct);
+ break;
+ }
+# endif /* __GLIBC__ */
+#endif /* __GNUC__ */
+
+ default:
+ break;
+ }
+}
+
+void _STLP_CALL __write_formatted_time(__iostring &buf, const ctype<char>& ct,
+ char format, char modifier,
+ const _Time_Info& table, const tm* t)
+{ __write_formatted_timeT(buf, ct, format, modifier, table, t); }
+
+void _STLP_CALL __write_formatted_time(__iowstring &buf, const ctype<wchar_t>& ct,
+ char format, char modifier,
+ const _WTime_Info& table, const tm* t)
+{ __write_formatted_timeT(buf, ct, format, modifier, table, t); }
+
+static time_base::dateorder __get_date_order(_Locale_time* time) {
+ const char * fmt = _Locale_d_fmt(time);
+ char first, second, third;
+
+ while (*fmt != 0 && *fmt != '%') ++fmt;
+ if (*fmt == 0)
+ return time_base::no_order;
+ first = *++fmt;
+ while (*fmt != 0 && *fmt != '%') ++fmt;
+ if (*fmt == 0)
+ return time_base::no_order;
+ second = *++fmt;
+ while (*fmt != 0 && *fmt != '%') ++fmt;
+ if (*fmt == 0)
+ return time_base::no_order;
+ third = *++fmt;
+
+ switch (first) {
+ case 'd':
+ return (second == 'm' && third == 'y') ? time_base::dmy
+ : time_base::no_order;
+ case 'm':
+ return (second == 'd' && third == 'y') ? time_base::mdy
+ : time_base::no_order;
+ case 'y':
+ switch (second) {
+ case 'd':
+ return third == 'm' ? time_base::ydm : time_base::no_order;
+ case 'm':
+ return third == 'd' ? time_base::ymd : time_base::no_order;
+ default:
+ return time_base::no_order;
+ }
+ default:
+ return time_base::no_order;
+ }
+}
+
+time_init<char>::time_init()
+ : _M_dateorder(time_base::no_order)
+{ _Init_timeinfo(_M_timeinfo); }
+
+time_init<char>::time_init(const char* __name) {
+ if (!__name)
+ locale::_M_throw_on_null_name();
+
+ int __err_code;
+ char buf[_Locale_MAX_SIMPLE_NAME];
+ _Locale_time *__time = __acquire_time(__name, buf, 0, &__err_code);
+ if (!__time)
+ locale::_M_throw_on_creation_failure(__err_code, __name, "time");
+
+ _Init_timeinfo(this->_M_timeinfo, __time);
+ _M_dateorder = __get_date_order(__time);
+ __release_time(__time);
+}
+
+time_init<char>::time_init(_Locale_time *__time) {
+ _Init_timeinfo(this->_M_timeinfo, __time);
+ _M_dateorder = __get_date_order(__time);
+}
+
+#ifndef _STLP_NO_WCHAR_T
+time_init<wchar_t>::time_init()
+ : _M_dateorder(time_base::no_order)
+{ _Init_timeinfo(_M_timeinfo); }
+
+time_init<wchar_t>::time_init(const char* __name) {
+ if (!__name)
+ locale::_M_throw_on_null_name();
+
+ int __err_code;
+ char buf[_Locale_MAX_SIMPLE_NAME];
+ _Locale_time *__time = __acquire_time(__name, buf, 0, &__err_code);
+ if (!__time)
+ locale::_M_throw_on_creation_failure(__err_code, __name, "time");
+
+ _Init_timeinfo(this->_M_timeinfo, __time);
+ _M_dateorder = __get_date_order(__time);
+ __release_time(__time);
+}
+
+time_init<wchar_t>::time_init(_Locale_time *__time) {
+ _Init_timeinfo(this->_M_timeinfo, __time);
+ _M_dateorder = __get_date_order(__time);
+}
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#if !defined (_STLP_NO_FORCE_INSTANTIATE)
+template class time_get<char, istreambuf_iterator<char, char_traits<char> > >;
+template class time_put<char, ostreambuf_iterator<char, char_traits<char> > >;
+
+# ifndef _STLP_NO_WCHAR_T
+template class time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
+template class time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
+# endif
+
+#endif
+
+_STLP_END_NAMESPACE
diff --git a/sources/android/stlport/src/warning_disable.h b/sources/android/stlport/src/warning_disable.h
new file mode 100644
index 0000000..7f0c1c8
--- /dev/null
+++ b/sources/android/stlport/src/warning_disable.h
@@ -0,0 +1,61 @@
+#if !defined (__ICL)
+/* This header is used to turn off warnings of Microsoft compilers generated.
+ * while building STLport.
+ * For compiling user code, see stlport/config/_msvc_warnings_off.h.
+ */
+
+# if (_MSC_VER < 1300) /* VC6/eVC4 */
+# pragma warning( disable : 4097 ) /* typedef-name used as based class of (...) */
+# pragma warning( disable : 4251 ) /* DLL interface needed */
+# pragma warning( disable : 4284 ) /* for -> operator */
+# pragma warning( disable : 4503 ) /* decorated name length exceeded, name was truncated */
+# pragma warning( disable : 4514 ) /* unreferenced inline function has been removed */
+# pragma warning( disable : 4660 ) /* template-class specialization '...' is already instantiated */
+# pragma warning( disable : 4701 ) /* local variable 'base' may be used without having been initialized */
+# pragma warning( disable : 4710 ) /* function (...) not inlined */
+# pragma warning( disable : 4786 ) /* identifier truncated to 255 characters */
+# endif
+
+# if (_MSC_VER <= 1310)
+# pragma warning( disable : 4511 ) /* copy constructor cannot be generated */
+# endif
+
+# if (_MSC_VER < 1300) && defined (UNDER_CE)
+# pragma warning( disable : 4201 ) /* nonstandard extension used : nameless struct/union */
+# pragma warning( disable : 4214 ) /* nonstandard extension used : bit field types other than int */
+# endif
+
+/* Suppress warnings emitted from Windows CE SDK headers. */
+# if (_MSC_VER >= 1400) && defined (UNDER_CE)
+# pragma warning( disable : 4115 ) /* Named type definition in parentheses. */
+# pragma warning( disable : 4201 ) /* Nameless struct/union. */
+# pragma warning( disable : 4214 ) /* Bit field types other than int. */
+# pragma warning( disable : 4290 ) /* C++ exception specification ignored. */
+# pragma warning( disable : 4430 ) /* Missing type specifier, int assumed. */
+# pragma warning( disable : 4431 ) /* Missing type specifier, int assumed. */
+# endif
+
+# pragma warning( disable : 4075 ) /* initializers put in unrecognized initialization area */
+/* This warning is disable only for the c_locale_win32.c file compilation: */
+# pragma warning( disable : 4100 ) /* unreferenced formal parameter */
+# pragma warning( disable : 4127 ) /* conditional expression is constant */
+# pragma warning( disable : 4146 ) /* unary minus applied to unsigned type */
+# pragma warning( disable : 4245 ) /* conversion from 'enum ' to 'unsigned int', signed/unsigned mismatch */
+# pragma warning( disable : 4244 ) /* implicit conversion: possible loss of data */
+# pragma warning( disable : 4512 ) /* assignment operator could not be generated */
+# pragma warning( disable : 4571 ) /* catch(...) blocks compiled with /EHs do not catch or re-throw Structured Exceptions */
+# pragma warning( disable : 4702 ) /* unreachable code (appears in release with warning level4) */
+#else
+# pragma warning( disable : 69 ) /* integer conversion resulted in truncation */
+# pragma warning( disable : 174 ) /* expression has no effect */
+# pragma warning( disable : 279 ) /* controling expression is constant */
+# pragma warning( disable : 383 ) /* reference to temporary used */
+# pragma warning( disable : 444 ) /* destructor for base class "..." is not virtual*/
+# pragma warning( disable : 810 ) /* conversion from "int" to "char" may lose significant bits */
+# pragma warning( disable : 981 ) /* operands are evaluated in unspecified order */
+# pragma warning( disable : 1418 ) /* external definition with no prior declaration */
+# pragma warning( disable : 1419 ) /* external declaration in primary source file */
+# pragma warning( disable : 1572 ) /* floating-point equality and inequality comparisons are unreliable */
+# pragma warning( disable : 1682 ) /* implicit conversion of a 64-bit integral type to a smaller integral type */
+# pragma warning( disable : 1683 ) /* explicit conversion of a 64-bit integral type to a smaller integral type */
+#endif
diff --git a/sources/android/stlport/stlport/algorithm b/sources/android/stlport/stlport/algorithm
new file mode 100644
index 0000000..c653d8c
--- /dev/null
+++ b/sources/android/stlport/stlport/algorithm
@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_ALGORITHM
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x1
+# include <stl/_prolog.h>
+# define _STLP_ALGORITHM
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1)
+# ifndef _STLP_INTERNAL_CSTDIO
+// remove() conflicts, <cstdio> should always go first
+# include <stl/_cstdio.h>
+# endif
+
+# ifndef _STLP_INTERNAL_ALGO_H
+# include <stl/_algo.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x1) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <algorithm>
+# else
+# include _STLP_NATIVE_HEADER(algorithm)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1 )
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_ALGORITHM */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/assert.h b/sources/android/stlport/stlport/assert.h
new file mode 100644
index 0000000..112dd26
--- /dev/null
+++ b/sources/android/stlport/stlport/assert.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x202
+# include <stl/_cprolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x202) && ! defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+#endif
+
+/* evc3 doesn't have assert.h; macro assert() is defined in stl_evc.h */
+#ifndef _STLP_WCE_EVC3
+# if !defined (assert)
+# define _STLP_NATIVE_ASSERT_H_INCLUDED
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <assert.h>
+# else
+# include _STLP_NATIVE_C_HEADER(assert.h)
+# endif
+# endif
+# if !defined (_STLP_NATIVE_ASSERT_H_INCLUDED)
+/* See errno.h for additional information about this #error */
+# error assert has been defined before inclusion of assert.h header.
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x202)
+# if ! defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# endif
+# undef _STLP_DONT_POP_HEADER_ID
+#endif
+
+/* Local Variables:
+ * mode:C++
+ * End:
+ */
diff --git a/sources/android/stlport/stlport/bitset b/sources/android/stlport/stlport/bitset
new file mode 100644
index 0000000..1d7fcf3
--- /dev/null
+++ b/sources/android/stlport/stlport/bitset
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_BITSET
+
+// This implementation of bitset<> has a second template parameter,
+// _WordT, which defaults to unsigned long. *YOU SHOULD NOT USE
+// THIS FEATURE*. It is experimental, and it may be removed in
+// future releases.
+
+// A bitset of size N, using words of type _WordT, will have
+// N % (sizeof(_WordT) * CHAR_BIT) unused bits. (They are the high-
+// order bits in the highest word.) It is a class invariant
+// of class bitset<> that those unused bits are always zero.
+
+// Most of the actual code isn't contained in bitset<> itself, but in the
+// base class _Base_bitset. The base class works with whole words, not with
+// individual bits. This allows us to specialize _Base_bitset for the
+// important special case where the bitset is only a single word.
+
+// The C++ standard does not define the precise semantics of operator[].
+// In this implementation the const version of operator[] is equivalent
+// to test(), except that it does no range checking. The non-const version
+// returns a reference to a bit, again without doing any range checking.
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x2
+# include <stl/_prolog.h>
+# define _STLP_BITSET
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x2)
+# ifndef _STLP_INTERNAL_BITSET
+# include <stl/_bitset.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x2) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <bitset>
+# else
+# include _STLP_NATIVE_HEADER(bitset)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x2 )
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_BITSET */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/cassert b/sources/android/stlport/stlport/cassert
new file mode 100644
index 0000000..aabd0b4
--- /dev/null
+++ b/sources/android/stlport/stlport/cassert
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x103
+# include <stl/_prolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x103) && ! defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+#endif
+
+#if !defined (_STLP_WCE_EVC3)
+# if defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cassert>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cassert)
+# endif
+# else
+# include <assert.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x103 )
+# if !defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+#endif
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/cctype b/sources/android/stlport/stlport/cctype
new file mode 100644
index 0000000..513512e
--- /dev/null
+++ b/sources/android/stlport/stlport/cctype
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CCTYPE
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x104
+# define _STLP_CCTYPE
+# include <stl/_prolog.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x104 )
+# ifndef _STLP_INTERNAL_CCTYPE
+# include <stl/_cctype.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x104) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cctype>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cctype)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x104 )
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_CCTYPE */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/cerrno b/sources/android/stlport/stlport/cerrno
new file mode 100644
index 0000000..0d17faf
--- /dev/null
+++ b/sources/android/stlport/stlport/cerrno
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CERRNO
+#define _STLP_CERRNO
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x105
+# include <stl/_prolog.h>
+#endif
+
+#ifndef _STLP_WCE
+# if defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cerrno>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cerrno)
+# endif
+# else
+# include <errno.h>
+# endif
+#endif
+
+#ifndef errno /* errno is not a macro */
+# if defined (_STLP_IMPORT_VENDOR_CSTD)
+# if !defined (__IBMCPP__) && !defined (__hpux) && !defined (__MWERKS__) && !defined (_STLP_WCE)
+_STLP_BEGIN_NAMESPACE
+using _STLP_VENDOR_CSTD::errno;
+_STLP_END_NAMESPACE
+# endif
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x105 )
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_CERRNO */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/cfloat b/sources/android/stlport/stlport/cfloat
new file mode 100644
index 0000000..cb2e0cd
--- /dev/null
+++ b/sources/android/stlport/stlport/cfloat
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CFLOAT
+#define _STLP_CFLOAT
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x106
+# include <stl/_prolog.h>
+#endif
+
+// Borland defines some implementation constants in std:: namespace,
+// we do not want to import them.
+#if defined (_STLP_USE_NEW_C_HEADERS) && !defined (__BORLANDC__)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cfloat>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cfloat)
+# endif
+#else
+# include <float.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x106 )
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_CFLOAT */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/ciso646 b/sources/android/stlport/stlport/ciso646
new file mode 100644
index 0000000..443449d
--- /dev/null
+++ b/sources/android/stlport/stlport/ciso646
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CISO646
+#define _STLP_CISO646
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x107
+# include <stl/_prolog.h>
+#endif
+
+#if !defined(_STLP_WCE_EVC3) && !defined (__BORLANDC__)
+# if defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <ciso646>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(ciso646)
+# endif
+# else
+# include <iso646.h>
+# endif /* _STLP_USE_NEW_C_HEADERS */
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x107 )
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_CISO646 */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/climits b/sources/android/stlport/stlport/climits
new file mode 100644
index 0000000..86bc413
--- /dev/null
+++ b/sources/android/stlport/stlport/climits
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CLIMITS
+# define _STLP_CLIMITS
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x108
+# include <stl/_prolog.h>
+#endif
+
+#if defined (__SUNPRO_CC) && ((__SUNPRO_CC == 0x500) && (__SUNPRO_CC_COMPAT > 4))
+# include </usr/include/limits.h>
+#elif defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <climits>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(climits)
+# endif
+#else
+# if defined (__BORLANDC__)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <limits.h>
+# else
+# include _STLP_NATIVE_C_HEADER(limits.h)
+# endif
+# else
+# include <limits.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x108 )
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_CLIMITS */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/clocale b/sources/android/stlport/stlport/clocale
new file mode 100644
index 0000000..28996ce
--- /dev/null
+++ b/sources/android/stlport/stlport/clocale
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CLOCALE
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x109
+# define _STLP_CLOCALE
+# include <stl/_prolog.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x109)
+# ifndef _STLP_INTERNAL_CLOCALE
+# include <stl/_clocale.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x109) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <clocale>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(clocale)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x109)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_CLOCALE */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/cmath b/sources/android/stlport/stlport/cmath
new file mode 100644
index 0000000..46a8f52
--- /dev/null
+++ b/sources/android/stlport/stlport/cmath
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CMATH
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x110
+# include <stl/_prolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x110) && !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+# define _STLP_CMATH
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x110) && !defined (_STLP_DONT_POP_HEADER_ID)
+# ifndef _STLP_INTERNAL_CMATH
+# include <stl/_cmath.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x110) || defined (_STLP_DONT_POP_HEADER_ID) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cmath>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cmath)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x110)
+# if !defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+#endif
+
+#endif /* _STLP_CMATH */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/complex b/sources/android/stlport/stlport/complex
new file mode 100644
index 0000000..6cfe605
--- /dev/null
+++ b/sources/android/stlport/stlport/complex
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_COMPLEX
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x10
+# define _STLP_COMPLEX
+# include <stl/_prolog.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x10)
+// This header declares the template class complex, as described in
+// in the C++ Standard. Single-precision complex numbers
+// are complex<float>, double-precision are complex<double>, and
+// quad precision are complex<long double>.
+
+// Note that the template class complex is declared within namespace
+// std, as called for by the draft C++ standard
+# ifndef _STLP_INTERNAL_COMPLEX
+# include <stl/_complex.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x10) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <complex>
+# else
+# include _STLP_NATIVE_HEADER(complex)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x10 )
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_COMPLEX */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/csetjmp b/sources/android/stlport/stlport/csetjmp
new file mode 100644
index 0000000..eef2bd8
--- /dev/null
+++ b/sources/android/stlport/stlport/csetjmp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CSETJMP
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x111
+# define _STLP_CSETJMP
+# include <stl/_prolog.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x111)
+# ifndef _STLP_INTERNAL_CSETJMP
+# include <stl/_csetjmp.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x111) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <csetjmp>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(csetjmp)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x111 )
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_CSETJMP */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/csignal b/sources/android/stlport/stlport/csignal
new file mode 100644
index 0000000..7b1a30d
--- /dev/null
+++ b/sources/android/stlport/stlport/csignal
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CSIGNAL
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x112
+# define _STLP_CSIGNAL
+# include <stl/_prolog.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x112)
+# ifndef _STLP_INTERNAL_CSIGNAL
+# include <stl/_csignal.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x112) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <csignal>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(csignal)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x112 )
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_CSIGNAL */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/cstdarg b/sources/android/stlport/stlport/cstdarg
new file mode 100644
index 0000000..6882bbd
--- /dev/null
+++ b/sources/android/stlport/stlport/cstdarg
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CSTDARG
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x113
+# define _STLP_CSTDARG
+# include <stl/_prolog.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x113)
+# ifndef _STLP_INTERNAL_CSTDARG
+# include <stl/_cstdarg.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x113) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cstdarg>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cstdarg)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x113 )
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_CSTDARG */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/cstddef b/sources/android/stlport/stlport/cstddef
new file mode 100644
index 0000000..0a66f0e
--- /dev/null
+++ b/sources/android/stlport/stlport/cstddef
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CSTDDEF
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x114
+# define _STLP_CSTDDEF
+# include <stl/_prolog.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x114)
+# ifndef _STLP_INTERNAL_CSTDDEF
+# include <stl/_cstddef.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x114) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cstddef>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cstddef)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x114 )
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_CSTDDEF */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/cstdio b/sources/android/stlport/stlport/cstdio
new file mode 100644
index 0000000..e20c8ff
--- /dev/null
+++ b/sources/android/stlport/stlport/cstdio
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CSTDIO
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x15
+# include <stl/_prolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x15) && !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+# define _STLP_CSTDIO
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x15) && !defined (_STLP_DONT_POP_HEADER_ID)
+# ifndef _STLP_INTERNAL_CSTDIO
+# include <stl/_cstdio.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x15) || defined (_STLP_DONT_POP_HEADER_ID) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cstdio>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cstdio)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x15)
+# if !defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+#endif
+
+#endif
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/cstdlib b/sources/android/stlport/stlport/cstdlib
new file mode 100644
index 0000000..20afa35
--- /dev/null
+++ b/sources/android/stlport/stlport/cstdlib
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CSTDLIB
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x116
+# define _STLP_CSTDLIB
+# include <stl/_prolog.h>
+#endif
+
+# if defined (__GNUC__) && defined (__MINGW32__)
+/* Native cstdlib includes stdlib.h using an include_next so STLport stdlib.h
+ * is not used and the workaround in this file must be duplicated here
+ * (see stdlib.h). */
+# include "errno.h"
+# endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x116)
+# ifndef _STLP_INTERNAL_CSTDLIB
+# include <stl/_cstdlib.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x116) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cstdlib>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cstdlib)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x116)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_CSTDLIB */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/cstring b/sources/android/stlport/stlport/cstring
new file mode 100644
index 0000000..d5cf58d
--- /dev/null
+++ b/sources/android/stlport/stlport/cstring
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CSTRING
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x117
+# define _STLP_CSTRING
+# include <stl/_prolog.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x117)
+# ifndef _STLP_INTERNAL_CSTRING
+# include <stl/_cstring.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x117) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cstring>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cstring)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x117)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_CSTRING */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/ctime b/sources/android/stlport/stlport/ctime
new file mode 100644
index 0000000..bafb7dd
--- /dev/null
+++ b/sources/android/stlport/stlport/ctime
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CTIME
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x118
+# include <stl/_prolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x118) && ! defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+# define _STLP_CTIME
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x118) && !defined (_STLP_DONT_POP_HEADER_ID)
+# ifndef _STLP_INTERNAL_CTIME
+# include <stl/_ctime.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x118) || defined (_STLP_DONT_POP_HEADER_ID) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <ctime>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(ctime)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x118)
+# if !defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+#endif
+
+#endif /* _STLP_CTIME */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/ctype.h b/sources/android/stlport/stlport/ctype.h
new file mode 100644
index 0000000..f9d1000
--- /dev/null
+++ b/sources/android/stlport/stlport/ctype.h
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CTYPE_H
+
+/* Workaround for a "misbehaviour" when compiling resource scripts using
+ * eMbedded Visual C++. The standard .rc file includes windows header files,
+ * which in turn include ctype.h, which results in warnings and errors
+ */
+#if !defined(RC_INVOKED)
+
+# if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x219
+# include <stl/_prolog.h>
+# elif (_STLP_OUTERMOST_HEADER_ID == 0x219)
+# define _STLP_DONT_POP_HEADER_ID
+# define _STLP_CTYPE_H
+# endif
+
+# if defined(_STLP_WCE_EVC3)
+struct _exception;
+# endif
+
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <ctype.h>
+# else
+# include _STLP_NATIVE_C_HEADER(ctype.h)
+# endif
+
+/* on evc4 including ctype.h also defines setjmp macro */
+# if defined (_STLP_WCE)
+# define _STLP_NATIVE_SETJMP_H_INCLUDED
+# endif
+
+# ifndef _STLP_CTYPE_H_SEEN
+# define _STLP_CTYPE_H_SEEN
+
+/* Undef convenience interfaces */
+# undef isspace
+# undef isprint
+# undef iscntrl
+# undef isupper
+# undef islower
+# undef isalpha
+# undef isdigit
+# undef ispunct
+# undef isxdigit
+# undef isalnum
+# undef isgraph
+# undef toupper
+# undef tolower
+
+# if defined (UNDER_CE)
+
+# if (_WIN32_WCE < 300) /* Only wide chars for older versions */
+# define _isctype iswctype
+# endif
+
+__inline int (isalpha)(int c) { return _isctype(c, _ALPHA); }
+__inline int (isupper)(int c) { return _isctype(c, _UPPER); }
+__inline int (islower)(int c) { return _isctype(c, _LOWER); }
+__inline int (isdigit)(int c) { return _isctype(c, _DIGIT); }
+__inline int (isxdigit)(int c) { return _isctype(c, _HEX); }
+__inline int (isspace)(int c) { return _isctype(c, _SPACE); }
+__inline int (ispunct)(int c) { return _isctype(c, _PUNCT); }
+__inline int (isalnum)(int c) { return _isctype(c, _ALPHA|_DIGIT); }
+__inline int (isprint)(int c) { return _isctype(c, _BLANK|_PUNCT|_ALPHA|_DIGIT); }
+__inline int (isgraph)(int c) { return _isctype(c, _PUNCT|_ALPHA|_DIGIT); }
+__inline int (iscntrl)(int c) { return _isctype(c, _CONTROL); }
+__inline int (isascii)(int c) { return ((unsigned)(c) < 0x80); }
+
+# undef _isctype
+
+__inline int (iswalpha)(int c) { return iswctype((unsigned short)(c), _ALPHA); }
+__inline int (iswupper)(int c) { return iswctype((unsigned short)(c), _UPPER); }
+__inline int (iswlower)(int c) { return iswctype((unsigned short)(c), _LOWER); }
+__inline int (iswdigit)(int c) { return iswctype((unsigned short)(c), _DIGIT); }
+__inline int (iswxdigit)(int c) { return iswctype((unsigned short)(c), _HEX); }
+__inline int (iswspace)(int c) { return iswctype((unsigned short)(c), _SPACE); }
+__inline int (iswpunct)(int c) { return iswctype((unsigned short)(c), _PUNCT); }
+__inline int (iswalnum)(int c) { return iswctype((unsigned short)(c), _ALPHA|_DIGIT); }
+__inline int (iswprint)(int c) { return iswctype((unsigned short)(c), _BLANK|_PUNCT|_ALPHA|_DIGIT); }
+__inline int (iswgraph)(int c) { return iswctype((unsigned short)(c), _PUNCT|_ALPHA|_DIGIT); }
+__inline int (iswcntrl)(int c) { return iswctype((unsigned short)(c), _CONTROL); }
+__inline int (iswascii)(int c) { return ((unsigned)(c) < 0x80); }
+
+# endif /* UNDER_CE */
+
+# endif /* _STLP_CTYPE_H_SEEN */
+
+# if (_STLP_OUTERMOST_HEADER_ID == 0x219)
+# if ! defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+# endif
+
+#endif /* RC_INVOKED */
+
+#endif /* _STLP_CTYPE_H */
diff --git a/sources/android/stlport/stlport/cwchar b/sources/android/stlport/stlport/cwchar
new file mode 100644
index 0000000..0b32054
--- /dev/null
+++ b/sources/android/stlport/stlport/cwchar
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CWCHAR
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x120
+# define _STLP_CWCHAR
+# include <stl/_prolog.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x120)
+# ifndef _STLP_INTERNAL_CWCHAR
+# include <stl/_cwchar.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x120) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cwchar>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cwchar)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x120)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_CWCHAR */
+
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/cwctype b/sources/android/stlport/stlport/cwctype
new file mode 100644
index 0000000..0e86218
--- /dev/null
+++ b/sources/android/stlport/stlport/cwctype
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CWCTYPE
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x121
+# define _STLP_CWCTYPE
+# include <stl/_prolog.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x121)
+# ifndef _STLP_INTERNAL_CWCTYPE
+# include <stl/_cwctype.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x121) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cwctype>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cwctype)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x121)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_CWCTYPE */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/deque b/sources/android/stlport/stlport/deque
new file mode 100644
index 0000000..448f159
--- /dev/null
+++ b/sources/android/stlport/stlport/deque
@@ -0,0 +1,57 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_DEQUE
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x22
+# include <stl/_prolog.h>
+# define _STLP_DEQUE
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x22)
+# ifndef _STLP_INTERNAL_DEQUE_H
+# include <stl/_deque.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x22) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <deque>
+# else
+# include _STLP_NATIVE_HEADER(deque)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x22)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_DEQUE */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/errno.h b/sources/android/stlport/stlport/errno.h
new file mode 100644
index 0000000..bb7999b
--- /dev/null
+++ b/sources/android/stlport/stlport/errno.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x205
+# include <stl/_cprolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x205) && !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+#endif
+
+#ifdef _STLP_WCE
+/* only show message when directly including this file in a non-library build */
+# if !defined(__BUILDING_STLPORT) && (_STLP_OUTERMOST_HEADER_ID == 0x205)
+# pragma message("eMbedded Visual C++ 3 and .NET don't have a errno.h header; STLport won't include native errno.h here")
+# endif
+#else
+# ifndef errno
+/* We define the following macro first to guaranty the header reentrancy: */
+# define _STLP_NATIVE_ERRNO_H_INCLUDED
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <errno.h>
+# else
+# include _STLP_NATIVE_C_HEADER(errno.h)
+# endif
+# if defined (__BORLANDC__) && (__BORLANDC__ >= 0x590) && defined (__cplusplus)
+_STLP_BEGIN_NAMESPACE
+using _STLP_VENDOR_CSTD::__errno;
+_STLP_END_NAMESPACE
+# endif
+# endif /* errno */
+
+# if !defined (_STLP_NATIVE_ERRNO_H_INCLUDED)
+/* If errno has been defined before inclusion of native errno.h including it from STLport errno.h
+ * becomes impossible because if:
+ * #define errno foo
+ * then
+ * #include _STLP_NATIVE_C_HEADER(errno.h)
+ * becomes:
+ * #include _STLP_NATIVE_C_HEADER(foo.h)
+ *
+ * To fix this problem you have to find where this definition comes from and include errno.h before it.
+ */
+# error errno has been defined before inclusion of errno.h header.
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x205)
+# if ! defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# endif
+# undef _STLP_DONT_POP_HEADER_ID
+#endif
+
+/* Local Variables:
+ * mode: C
+ * End:
+ */
diff --git a/sources/android/stlport/stlport/exception b/sources/android/stlport/stlport/exception
new file mode 100644
index 0000000..47822e9
--- /dev/null
+++ b/sources/android/stlport/stlport/exception
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+// This header exists solely for portability. Normally it just includes
+// the native header <exception>.
+
+#ifndef _STLP_EXCEPTION
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x423
+# include <stl/_prolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x423)
+# define _STLP_DONT_POP_HEADER_ID
+# define _STLP_EXCEPTION
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x423) && !defined (_STLP_DONT_POP_HEADER_ID)
+# ifndef _STLP_INTERNAL_EXCEPTION
+# include <stl/_exception.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x423) || defined (_STLP_DONT_POP_HEADER_ID) || defined (_STLP_IMPORT_VENDOR_STD)
+/* If we are here it means that we are in an include called
+ * from the native lib which means that we can simply forward this
+ * call to the native exception header:
+ */
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <exception>
+# else
+# if defined (__DMC__) && (_STLP_OUTERMOST_HEADER_ID == 0x874)
+// Workaround to DMC harcoded typeinfo.h inclusion.
+# include <../include/exception>
+# else
+# include _STLP_NATIVE_CPP_RUNTIME_HEADER(exception)
+# endif
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x423)
+# if !defined(_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+#endif
+
+#endif /* _STLP_EXCEPTION */
+
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/exception.h b/sources/android/stlport/stlport/exception.h
new file mode 100644
index 0000000..f4be9af
--- /dev/null
+++ b/sources/android/stlport/stlport/exception.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_OLDSTD_exception
+#define _STLP_OLDSTD_exception
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x824
+# include <stl/_prolog.h>
+#endif
+
+#if defined (__BORLANDC__) || defined (_MSC_VER)
+# include <exception>
+#else
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <exception.h>
+# else
+# include _STLP_NATIVE_CPP_RUNTIME_HEADER(exception.h)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x824)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_OLDSTD_exception */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/float.h b/sources/android/stlport/stlport/float.h
new file mode 100644
index 0000000..70fe3ad
--- /dev/null
+++ b/sources/android/stlport/stlport/float.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x203
+# include <stl/_cprolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x203) && !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x203)
+# error This header is only reentrant once, it should be modified if it has to be included more.
+#endif
+
+#if defined (_STLP_WCE_EVC3)
+struct _exception;
+#endif
+
+#if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <float.h>
+#else
+# include _STLP_NATIVE_C_HEADER(float.h)
+#endif
+
+#if !defined (__linux__)
+# if defined(__BORLANDC__) && defined (__cplusplus) && (__BORLANDC__ >= 0x560)
+_STLP_BEGIN_NAMESPACE
+using ::_max_dble;
+using ::_max_flt;
+using ::_max_ldble;
+using ::_tiny_ldble;
+_STLP_END_NAMESPACE
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x203)
+# if ! defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# endif
+# undef _STLP_DONT_POP_HEADER_ID
+#endif
diff --git a/sources/android/stlport/stlport/fstream b/sources/android/stlport/stlport/fstream
new file mode 100644
index 0000000..fc4cd1e
--- /dev/null
+++ b/sources/android/stlport/stlport/fstream
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+
+// This header defines classes basic_filebuf, basic_ifstream,
+// basic_ofstream, and basic_fstream. These classes represent
+// streambufs and streams whose sources or destinations are files.
+
+#ifndef _STLP_FSTREAM
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x1025
+# include <stl/_prolog.h>
+# define _STLP_FSTREAM
+# if defined (__DMC__) && defined (_DLL)
+# define _STLP_CLASS_IMPORT_DECLSPEC __declspec(dllimport)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1025) && \
+ !(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
+# include <stl/_ioserr.h>
+
+# ifndef _STLP_INTERNAL_FSTREAM_H
+# include <stl/_fstream.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x1025) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <fstream>
+# else
+# include _STLP_NATIVE_HEADER(fstream)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1025)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# if defined (__DMC__) && defined (_DLL)
+# undef _STLP_CLASS_IMPORT_DECLSPEC
+# define _STLP_CLASS_IMPORT_DECLSPEC
+# endif
+#endif
+
+#endif /* _STLP_FSTREAM */
+
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/fstream.h b/sources/android/stlport/stlport/fstream.h
new file mode 100644
index 0000000..4640033
--- /dev/null
+++ b/sources/android/stlport/stlport/fstream.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_FSTREAM_H
+#define _STLP_FSTREAM_H
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x2026
+# include <stl/_prolog.h>
+#endif
+
+#include <fstream>
+
+// get desired pollution
+#include <iostream.h>
+
+#ifndef _STLP_HAS_NO_NAMESPACES
+# include <using/fstream>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x2026)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_FSTREAM_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/functional b/sources/android/stlport/stlport/functional
new file mode 100644
index 0000000..27e37ab
--- /dev/null
+++ b/sources/android/stlport/stlport/functional
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_FUNCTIONAL
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x27
+# include <stl/_prolog.h>
+# define _STLP_FUNCTIONAL
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x27)
+# ifndef _STLP_INTERNAL_FUNCTION_H
+# include <stl/_function.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x27) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <functional>
+# else
+# include _STLP_NATIVE_HEADER(functional)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x27)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#if !defined(_STLP_NO_EXTENSIONS) && defined(_STLP_USE_BOOST_SUPPORT)
+
+#include <boost/ref.hpp>
+#include <boost/utility/result_of.hpp>
+#include <boost/bind/placeholders.hpp>
+#include <boost/mem_fn.hpp>
+#include <boost/bind.hpp>
+
+namespace boost {
+
+template<class T> class reference_wrapper;
+template<class T> reference_wrapper<T> const ref(T &);
+template<class T> inline reference_wrapper<T const> const cref(T const &);
+
+template<typename F> struct result_of;
+
+namespace _mfi {
+template<class R, class T> class dm;
+}
+
+template<class R, class T> _mfi::dm<R, T> mem_fn(R T::*f);
+
+} // namespace boost
+
+_STLP_BEGIN_NAMESPACE
+
+namespace tr1 {
+
+using ::boost::reference_wrapper;
+using ::boost::ref;
+using ::boost::cref;
+
+using ::boost::result_of;
+
+using ::boost::mem_fn;
+
+using ::boost::bind;
+
+namespace placeholders {
+ using ::_1;
+ using ::_2;
+ using ::_3;
+ using ::_4;
+ using ::_5;
+ using ::_6;
+ using ::_7;
+ using ::_8;
+ using ::_9;
+} // placeholders
+
+} // namespace tr1
+
+_STLP_END_NAMESPACE
+
+#endif // !_STLP_NO_EXTENSIONS && _STLP_USE_BOOST_SUPPORT
+
+#endif /* _STLP_FUNCTIONAL */
+
+#if !defined(_STLP_FUNCTIONAL_FUN) && !defined(_STLP_NO_EXTENSIONS) && defined(_STLP_USE_BOOST_SUPPORT)
+
+#ifndef BOOST_FUNCTION_NUM_ARGS // avoid recursive includes
+
+// #ifdef BOOST_FUNCTION_BASE_HEADER
+// #undef BOOST_FUNCTION_BASE_HEADER
+// #endif
+
+// #ifdef BOOST_FUNCTION_PROLOGUE_HPP
+// #undef BOOST_FUNCTION_PROLOGUE_HPP
+// #endif
+
+#define _STLP_FUNCTIONAL_FUN
+
+#ifndef BOOST_FUNCTION_BASE_HEADER // avoid recursive includes
+# include <boost/function.hpp>
+#else
+namespace boost {
+class bad_function_call;
+template<typename Signature, typename Allocator >
+class function;
+template<typename Signature, typename Allocator>
+void swap(function<Signature, Allocator>& f1, function<Signature, Allocator>& f2);
+}
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+namespace tr1 {
+
+using ::boost::bad_function_call;
+using ::boost::function;
+using ::boost::swap;
+
+} // namespace tr1
+
+_STLP_END_NAMESPACE
+
+#endif // !BOOST_FUNCTION_NUM_ARGS
+
+#endif // !_STLP_FUNCTIONAL_REF && !_STLP_NO_EXTENSIONS && _STLP_USE_BOOST_SUPPORT
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/hash_map b/sources/android/stlport/stlport/hash_map
new file mode 100644
index 0000000..0e2422d
--- /dev/null
+++ b/sources/android/stlport/stlport/hash_map
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_HASH_MAP
+#define _STLP_HASH_MAP
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x4028
+# include <stl/_prolog.h>
+#endif
+
+#ifdef _STLP_PRAGMA_ONCE
+# pragma once
+#endif
+
+#if defined (_STLP_NO_EXTENSIONS)
+/* Comment following if you want to use hash constainers even if you ask for
+ * no extension.
+ */
+# error The hash_map and hash_multimap class are STLport extensions.
+#endif
+
+#include <stl/_hash_map.h>
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x4028)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_HASH_MAP */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/hash_set b/sources/android/stlport/stlport/hash_set
new file mode 100644
index 0000000..0fc89ec
--- /dev/null
+++ b/sources/android/stlport/stlport/hash_set
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_HASH_SET
+#define _STLP_HASH_SET
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x4029
+# include <stl/_prolog.h>
+#endif
+
+#ifdef _STLP_PRAGMA_ONCE
+# pragma once
+#endif
+
+#if defined (_STLP_NO_EXTENSIONS)
+/* Comment following if you want to use hash constainers even if you ask for
+ * no extension.
+ */
+# error The hash_set and hash_multiset class are STLport extensions.
+#endif
+
+#include <stl/_hash_set.h>
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x4029)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_HASH_SET */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/iomanip b/sources/android/stlport/stlport/iomanip
new file mode 100644
index 0000000..085564f
--- /dev/null
+++ b/sources/android/stlport/stlport/iomanip
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_IOMANIP
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x1030
+# include <stl/_prolog.h>
+# define _STLP_IOMANIP
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1030) && \
+ !(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
+# include <stl/_ioserr.h>
+
+# ifndef _STLP_INTERNAL_IOMANIP
+# include <stl/_iomanip.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x1030) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <iomanip>
+# else
+# include _STLP_NATIVE_HEADER(iomanip)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1030)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_IOMANIP */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/iomanip.h b/sources/android/stlport/stlport/iomanip.h
new file mode 100644
index 0000000..1bfb0d2
--- /dev/null
+++ b/sources/android/stlport/stlport/iomanip.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_IOMANIP_H
+#define _STLP_IOMANIP_H
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x2031
+# include <stl/_prolog.h>
+#endif
+
+#include <stl/_ioserr.h>
+
+#include <iomanip>
+
+#ifndef _STLP_HAS_NO_NAMESPACES
+# ifdef _STLP_BROKEN_USING_DIRECTIVE
+_STLP_USING_NAMESPACE(stlport)
+# else
+using _STLP_STD::setiosflags;
+using _STLP_STD::resetiosflags;
+using _STLP_STD::setbase;
+using _STLP_STD::setfill;
+using _STLP_STD::setprecision;
+using _STLP_STD::setw;
+# endif
+#endif /* _STLP_HAS_NO_NAMESPACES */
+
+// get all the pollution we want
+#include <iostream.h>
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x2031)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_IOMANIP_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/ios b/sources/android/stlport/stlport/ios
new file mode 100644
index 0000000..12492bb
--- /dev/null
+++ b/sources/android/stlport/stlport/ios
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_IOS
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x1032
+# include <stl/_prolog.h>
+# define _STLP_IOS
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1032) && \
+ !(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
+# include <stl/_ioserr.h>
+
+# ifndef _STLP_INTERNAL_IOS_H
+# include <stl/_ios.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x1032) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <ios>
+# else
+# include _STLP_NATIVE_HEADER(ios)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1032)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_IOS */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/ios.h b/sources/android/stlport/stlport/ios.h
new file mode 100644
index 0000000..90ccfbb
--- /dev/null
+++ b/sources/android/stlport/stlport/ios.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_IOS_H
+#define _STLP_IOS_H
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x1033
+# include <stl/_prolog.h>
+#endif
+
+#include <ios>
+
+#if defined (_STLP_USE_NAMESPACES)
+# include <using/ios>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1033)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_IOS_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/iosfwd b/sources/android/stlport/stlport/iosfwd
new file mode 100644
index 0000000..1401046
--- /dev/null
+++ b/sources/android/stlport/stlport/iosfwd
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_IOSFWD
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x1034
+# include <stl/_prolog.h>
+# define _STLP_IOSFWD
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1034) && \
+ !(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
+# include <stl/_ioserr.h>
+
+# ifndef _STLP_INTERNAL_IOSFWD
+# include <stl/_iosfwd.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x1034) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <iosfwd>
+# else
+# include _STLP_NATIVE_HEADER(iosfwd)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1034)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_IOSFWD */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/iostream b/sources/android/stlport/stlport/iostream
new file mode 100644
index 0000000..1241f10
--- /dev/null
+++ b/sources/android/stlport/stlport/iostream
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_IOSTREAM
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x1037
+# include <stl/_prolog.h>
+# define _STLP_IOSTREAM
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1037) && \
+ !(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
+# include <stl/_ioserr.h>
+
+# ifdef _STLP_REDIRECT_STDSTREAMS
+// for ofstream redirection
+# ifndef _STLP_INTERNAL_FSTREAM_H
+# include <stl/_fstream.h>
+# endif
+# endif
+
+# ifndef _STLP_INTERNAL_IOSFWD
+# include <stl/_iosfwd.h>
+# endif
+
+# ifndef _STLP_INTERNAL_ISTREAM
+# include <stl/_istream.h>
+# endif
+
+_STLP_BEGIN_NAMESPACE
+
+# ifndef _STLP_USE_NAMESPACES
+// in case of SGI iostreams, we have to rename our streams not to clash with those
+// provided in native lib
+# define cin _STLP_cin
+# define cout _STLP_cout
+# define cerr _STLP_cerr
+# define clog _STLP_clog
+# endif
+
+// Note: cin and wcin are both associated with stdio. The C standard
+// (Amendment 1, section 4.6.2.1) says that it is an error to mix
+// wide- and narrow-oriented I/O on the same stream. This implies
+// that it is an error to use both cin and wcin in the same C++
+// program; the same applies to cout and wcout, and cerr/clog and
+// wcerr/wclog.
+
+extern _STLP_DECLSPEC istream cin;
+
+# ifdef _STLP_REDIRECT_STDSTREAMS
+extern _STLP_DECLSPEC ofstream cout;
+extern _STLP_DECLSPEC ofstream cerr;
+extern _STLP_DECLSPEC ofstream clog;
+# else
+extern _STLP_DECLSPEC ostream cout;
+extern _STLP_DECLSPEC ostream cerr;
+extern _STLP_DECLSPEC ostream clog;
+# endif
+
+# ifndef _STLP_NO_WCHAR_T
+extern _STLP_DECLSPEC wistream wcin;
+extern _STLP_DECLSPEC wostream wcout;
+extern _STLP_DECLSPEC wostream wcerr;
+extern _STLP_DECLSPEC wostream wclog;
+# endif
+
+_STLP_END_NAMESPACE
+
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x1037) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <iostream>
+# else
+# include _STLP_NATIVE_HEADER(iostream)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1037)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_IOSTREAM */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/iostream.h b/sources/android/stlport/stlport/iostream.h
new file mode 100644
index 0000000..2e7a7a9
--- /dev/null
+++ b/sources/android/stlport/stlport/iostream.h
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_IOSTREAM_H
+#define _STLP_IOSTREAM_H
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x2035
+# include <stl/_prolog.h>
+#endif
+
+#include <iostream>
+
+// Those should be included all separately, as they do contain using declarations
+#include <streambuf.h>
+#include <ostream.h>
+#include <istream.h>
+
+#ifndef _STLP_HAS_NO_NAMESPACES
+
+# ifdef _STLP_BROKEN_USING_DIRECTIVE
+_STLP_USING_NAMESPACE(stlport)
+# else
+using _STLP_STD::cin;
+using _STLP_STD::cout;
+using _STLP_STD::clog;
+using _STLP_STD::cerr;
+using _STLP_STD::iostream;
+# ifndef _STLP_NO_WCHAR_T
+using _STLP_STD::wcin;
+using _STLP_STD::wcout;
+using _STLP_STD::wclog;
+using _STLP_STD::wcerr;
+# endif
+# endif
+#endif /* _STLP_HAS_NO_NAMESPACES */
+
+// Obsolete classes for old-style backwards compatibility
+
+
+class istream_withassign : public istream {
+ public:
+ istream_withassign() : istream((streambuf*)0) {}
+ ~istream_withassign() {}
+
+ istream_withassign& operator=(istream& __s) {
+ ios::init(__s.rdbuf());
+ return *this;
+ }
+ istream_withassign& operator=(streambuf* __s) {
+ ios::init(__s);
+ return *this;
+ }
+};
+
+class ostream_withassign : public ostream {
+ public:
+ ostream_withassign() : ostream((streambuf*)0) {}
+ ~ostream_withassign() {}
+
+ ostream_withassign& operator=(ostream& __s) {
+ ios::init(__s.rdbuf());
+ return *this;
+ }
+ ostream_withassign& operator=(streambuf* __s) {
+ ios::init(__s);
+ return *this;
+ }
+};
+
+class iostream_withassign : public iostream {
+ public:
+ iostream_withassign() : iostream((streambuf*)0) {}
+ ~iostream_withassign() {}
+ iostream_withassign & operator=(ios& __i) {
+ ios::init(__i.rdbuf());
+ return *this;
+ }
+ iostream_withassign & operator=(streambuf* __s) {
+ ios::init(__s);
+ return *this;
+ }
+} ;
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x2035)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_IOSTREAM_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/iso646.h b/sources/android/stlport/stlport/iso646.h
new file mode 100644
index 0000000..858863a
--- /dev/null
+++ b/sources/android/stlport/stlport/iso646.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x204
+# include <stl/_cprolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x204) && !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+#endif
+
+/* evc3 doesn't have iso646.h */
+#if !defined (_STLP_WCE_EVC3) && !defined (__BORLANDC__)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <iso646.h>
+# else
+# include _STLP_NATIVE_C_HEADER(iso646.h)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x204)
+# if ! defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# endif
+# undef _STLP_DONT_POP_HEADER_ID
+#endif
+
diff --git a/sources/android/stlport/stlport/istream b/sources/android/stlport/stlport/istream
new file mode 100644
index 0000000..d4ca903
--- /dev/null
+++ b/sources/android/stlport/stlport/istream
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_ISTREAM
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x1036
+# include <stl/_prolog.h>
+# define _STLP_ISTREAM
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1036) && \
+ !(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
+# include <stl/_ioserr.h>
+
+# ifndef _STLP_INTERNAL_ISTREAM
+# include <stl/_istream.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x1036) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <istream>
+# else
+# include _STLP_NATIVE_HEADER(istream)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1036)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_ISTREAM */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/istream.h b/sources/android/stlport/stlport/istream.h
new file mode 100644
index 0000000..d382d96
--- /dev/null
+++ b/sources/android/stlport/stlport/istream.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_ISTREAM_H
+#define _STLP_ISTREAM_H
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x2037
+# include <stl/_prolog.h>
+#endif
+
+#include <stl/_ioserr.h>
+
+#include <istream>
+
+#ifndef _STLP_HAS_NO_NAMESPACES
+# ifdef _STLP_BROKEN_USING_DIRECTIVE
+_STLP_USING_NAMESPACE(stlport)
+# else
+using _STLP_STD::basic_istream;
+using _STLP_STD::basic_iostream;
+using _STLP_STD::istream;
+using _STLP_STD::iostream;
+using _STLP_STD::ios;
+# ifndef _STLP_NO_WCHAR_T
+using _STLP_STD::wistream;
+using _STLP_STD::wiostream;
+# endif
+using _STLP_STD::ws;
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x2037)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_ISTREAM_H */
diff --git a/sources/android/stlport/stlport/iterator b/sources/android/stlport/stlport/iterator
new file mode 100644
index 0000000..f8d3dee
--- /dev/null
+++ b/sources/android/stlport/stlport/iterator
@@ -0,0 +1,61 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_ITERATOR
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x38
+# include <stl/_prolog.h>
+# define _STLP_ITERATOR
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x38)
+# ifndef _STLP_INTERNAL_ITERATOR_H
+# include <stl/_iterator.h>
+# endif
+
+# ifndef _STLP_INTERNAL_STREAM_ITERATOR_H
+# include <stl/_stream_iterator.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x38) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <iterator>
+# else
+# include _STLP_NATIVE_HEADER(iterator)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x38)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_ITERATOR */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/limits b/sources/android/stlport/stlport/limits
new file mode 100644
index 0000000..5333b14
--- /dev/null
+++ b/sources/android/stlport/stlport/limits
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_LIMITS
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x39
+# include <stl/_prolog.h>
+# define _STLP_LIMITS
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x39)
+# ifndef _STLP_INTERNAL_LIMITS
+# include <stl/_limits.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x39) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <limits>
+# else
+# include _STLP_NATIVE_HEADER(limits)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x39)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_LIMITS */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/limits.h b/sources/android/stlport/stlport/limits.h
new file mode 100644
index 0000000..aab553b
--- /dev/null
+++ b/sources/android/stlport/stlport/limits.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x201
+# include <stl/_cprolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x201) && ! defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+#endif
+
+#if defined(_STLP_WCE_EVC3)
+struct _exception;
+#endif
+
+#if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <limits.h>
+#else
+# include _STLP_NATIVE_C_HEADER(limits.h)
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x201)
+# if ! defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# endif
+# undef _STLP_DONT_POP_HEADER_ID
+#endif
diff --git a/sources/android/stlport/stlport/list b/sources/android/stlport/stlport/list
new file mode 100644
index 0000000..647a8be
--- /dev/null
+++ b/sources/android/stlport/stlport/list
@@ -0,0 +1,57 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_LIST
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x40
+# include <stl/_prolog.h>
+# define _STLP_LIST
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x40)
+# ifndef _STLP_INTERNAL_LIST_H
+# include <stl/_list.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x40) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <list>
+# else
+# include _STLP_NATIVE_HEADER(list)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x40)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_LIST */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/locale b/sources/android/stlport/stlport/locale
new file mode 100644
index 0000000..22cd01f
--- /dev/null
+++ b/sources/android/stlport/stlport/locale
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_LOCALE
+
+// Basic framework: class locale and class locale::facet
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x1041
+# include <stl/_prolog.h>
+# define _STLP_LOCALE
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1041) && \
+ !(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
+# include <stl/_ioserr.h>
+
+// Individual facets
+# ifndef _STLP_INTERNAL_CTYPE_H
+# include <stl/_ctype.h>
+# endif
+
+# ifndef _STLP_INTERNAL_CODECVT_H
+# include <stl/_codecvt.h>
+# endif
+
+# ifndef _STLP_INTERNAL_COLLATE_H
+# include <stl/_collate.h>
+# endif
+
+# ifndef _STLP_INTERNAL_NUM_PUT_H
+# include <stl/_num_put.h>
+# endif
+
+# ifndef _STLP_INTERNAL_NUM_GET_H
+# include <stl/_num_get.h>
+# endif
+
+// those never included separately anyway
+# include <stl/_monetary.h>
+# include <stl/_time_facets.h>
+# include <stl/_messages_facets.h>
+
+// some stuff for streambuf iterators ended up defined there
+// Strictly speaking, _istream.h portion is only required for <iterator>, but it may break too many
+// programs if we omit it
+# ifndef _STLP_ISTREAM_H
+# include <stl/_istream.h>
+# endif
+
+// Convenience interfaces
+#undef isspace
+#undef isprint
+#undef iscntrl
+#undef isupper
+#undef islower
+#undef isalpha
+#undef isdigit
+#undef ispunct
+#undef isxdigit
+#undef isalnum
+#undef isgraph
+#undef toupper
+#undef tolower
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _CharT>
+inline bool isspace (_CharT c, const locale& loc)
+{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::space, c); }
+
+template <class _CharT>
+inline bool isprint (_CharT c, const locale& loc)
+{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::print, c); }
+
+template <class _CharT>
+inline bool iscntrl (_CharT c, const locale& loc)
+{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::cntrl, c); }
+
+template <class _CharT>
+inline bool isupper (_CharT c, const locale& loc)
+{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::upper, c); }
+
+template <class _CharT>
+inline bool islower (_CharT c, const locale& loc)
+{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::lower, c); }
+
+template <class _CharT>
+inline bool isalpha (_CharT c, const locale& loc)
+{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::alpha, c); }
+
+template <class _CharT>
+inline bool isdigit (_CharT c, const locale& loc)
+{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::digit, c); }
+
+template <class _CharT>
+inline bool ispunct (_CharT c, const locale& loc)
+{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::punct, c); }
+
+template <class _CharT>
+inline bool isxdigit (_CharT c, const locale& loc)
+{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::xdigit, c); }
+
+template <class _CharT>
+inline bool isalnum (_CharT c, const locale& loc)
+{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::alnum, c); }
+
+template <class _CharT>
+inline bool isgraph (_CharT c, const locale& loc)
+{ return (use_facet<ctype<_CharT> >(loc)).is(ctype_base::graph, c); }
+
+template <class _CharT>
+inline _CharT toupper(_CharT c, const locale& loc)
+{ return (use_facet<ctype<_CharT> >(loc)).toupper(c); }
+
+template <class _CharT>
+inline _CharT tolower(_CharT c, const locale& loc)
+{ return (use_facet<ctype<_CharT> >(loc)).tolower(c); }
+
+_STLP_END_NAMESPACE
+
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x1041) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <locale>
+# else
+# include _STLP_NATIVE_HEADER(locale)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1041)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_LOCALE */
+
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/locale.h b/sources/android/stlport/stlport/locale.h
new file mode 100644
index 0000000..81b56b4
--- /dev/null
+++ b/sources/android/stlport/stlport/locale.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x242
+# include <stl/_cprolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x242)
+# if !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+# else
+# error STLport include schema violation
+# endif
+#endif
+
+/* evc3 doesn't have locale.h */
+#ifndef _STLP_WCE_EVC3
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <locale.h>
+# else
+# include _STLP_NATIVE_C_HEADER(locale.h)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x242)
+# if !defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+#endif
diff --git a/sources/android/stlport/stlport/map b/sources/android/stlport/stlport/map
new file mode 100644
index 0000000..f30c400
--- /dev/null
+++ b/sources/android/stlport/stlport/map
@@ -0,0 +1,57 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_MAP
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x43
+# include <stl/_prolog.h>
+# define _STLP_MAP
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x43)
+# ifndef _STLP_INTERNAL_MAP_H
+# include <stl/_map.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x43) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <map>
+# else
+# include _STLP_NATIVE_HEADER(map)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x43)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_MAP */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/math.h b/sources/android/stlport/stlport/math.h
new file mode 100644
index 0000000..32b666f
--- /dev/null
+++ b/sources/android/stlport/stlport/math.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x244
+# include <stl/_cprolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x244) && !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+#endif
+
+#if !defined (exception) && (!defined (__KCC) || (__KCC_VERSION < 4000)) && \
+ !(defined(__IBMCPP__) && (500 <= __IBMCPP__)) && !defined(_STLP_WCE_EVC3)
+# define _STLP_EXCEPTION_WAS_REDEFINED 1
+# define exception __math_exception
+#endif
+
+#if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <math.h>
+#else
+# include _STLP_NATIVE_C_HEADER(math.h)
+#endif
+
+#if defined (_STLP_EXCEPTION_WAS_REDEFINED)
+# undef exception
+# undef _STLP_EXCEPTION_WAS_REDEFINED
+#endif
+
+#ifdef _STLP_WCE_EVC3
+# undef _exception
+# define _exception exception
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x244)
+# if ! defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+#endif
+
diff --git a/sources/android/stlport/stlport/mem.h b/sources/android/stlport/stlport/mem.h
new file mode 100644
index 0000000..2ebecea
--- /dev/null
+++ b/sources/android/stlport/stlport/mem.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_mem_h
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x245
+# include <stl/_cprolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x245) && !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x245) || defined (_STLP_DONT_POP_HEADER_ID)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <mem.h>
+# else
+# include _STLP_NATIVE_C_HEADER(mem.h)
+# endif
+#else
+# if defined (__BORLANDC__) && defined (__USING_CNAME__)
+# define _USING_CNAME_WAS_UNDEFINED
+# undef __USING_CNAME__
+# endif
+
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <mem.h>
+# else
+# include _STLP_NATIVE_C_HEADER(mem.h)
+# endif
+
+# if defined (__BORLANDC__) && defined (_USING_CNAME_WAS_UNDEFINED)
+# define __USING_CNAME__
+# define _STLP_mem_h 1
+# undef _USING_CNAME_WAS_UNDEFINED
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x245)
+# if !defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# endif
+# undef _STLP_DONT_POP_HEADER_ID
+#endif
+
+#endif /* _STLP_mem_h */
diff --git a/sources/android/stlport/stlport/memory b/sources/android/stlport/stlport/memory
new file mode 100644
index 0000000..3c0ceb3
--- /dev/null
+++ b/sources/android/stlport/stlport/memory
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_MEMORY
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x46
+# include <stl/_prolog.h>
+# define _STLP_MEMORY
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x46)
+# ifndef _STLP_INTERNAL_ALLOC_H
+# include <stl/_alloc.h>
+# endif
+
+# ifndef _STLP_INTERNAL_TEMPBUF_H
+# include <stl/_tempbuf.h>
+# endif
+
+# ifndef _STLP_INTERNAL_RAW_STORAGE_ITER_H
+# include <stl/_raw_storage_iter.h>
+# endif
+
+# include <stl/_auto_ptr.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x46) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (__MSL__)
+# include _STLP_NATIVE_HEADER(limits)
+# endif
+
+# if !defined(_STLP_NO_EXTENSIONS) && defined(_STLP_USE_BOOST_SUPPORT)
+# define BOOST_TR1_MEMORY_INCLUDED
+# define BOOST_TR1_FULL_MEMORY_INCLUDED
+# endif
+
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <memory>
+# else
+# include _STLP_NATIVE_HEADER(memory)
+# endif
+
+# if defined (__MSL__) && (__MSL__ >= 0x2405 && __MSL__ < 0x5201)
+/* 980401 vss MSL 2.4 Pro 3 Release */
+# include <new_mem.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x46)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#if !defined(_STLP_NO_EXTENSIONS) && defined(_STLP_USE_BOOST_SUPPORT)
+
+namespace boost {
+
+class bad_weak_ptr;
+template<class T> class shared_ptr;
+template<class T> class weak_ptr;
+template<class T> class enable_shared_from_this;
+template<class D, class T> D * get_deleter(shared_ptr<T> const & p);
+template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r);
+template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r);
+template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r);
+template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b);
+template<class T> void swap(shared_ptr<T> & a, shared_ptr<T> & b);
+
+namespace detail{
+class shared_count;
+class weak_count;
+}
+
+} // namespace boost
+
+# ifndef BOOST_SHARED_PTR_HPP_INCLUDED
+# include <boost/shared_ptr.hpp>
+# endif
+# ifndef BOOST_WEAK_PTR_HPP_INCLUDED
+# include <boost/weak_ptr.hpp>
+# endif
+# ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED
+# include <boost/enable_shared_from_this.hpp>
+# endif
+
+_STLP_BEGIN_NAMESPACE
+
+namespace tr1 {
+
+using ::boost::bad_weak_ptr;
+using ::boost::shared_ptr;
+using ::boost::swap;
+using ::boost::static_pointer_cast;
+using ::boost::dynamic_pointer_cast;
+using ::boost::const_pointer_cast;
+using ::boost::get_deleter;
+using ::boost::weak_ptr;
+using ::boost::enable_shared_from_this;
+
+// shared_ptr IO
+// weak_ptr IO
+
+} // namespace tr1
+
+_STLP_END_NAMESPACE
+
+#endif /* !_STLP_NO_EXTENSIONS && _STLP_USE_BOOST_SUPPORT */
+
+#endif /* _STLP_MEMORY */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/new b/sources/android/stlport/stlport/new
new file mode 100644
index 0000000..974ca44
--- /dev/null
+++ b/sources/android/stlport/stlport/new
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_NEW_HEADER
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x447
+# define _STLP_NEW_HEADER
+# include <stl/_prolog.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x447)
+# ifndef _STLP_NEW_H_HEADER
+# include <stl/_new.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x447) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <new>
+# else
+# include _STLP_NATIVE_CPP_RUNTIME_HEADER(new)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x447)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_NEW */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/new.h b/sources/android/stlport/stlport/new.h
new file mode 100644
index 0000000..0a9bf33
--- /dev/null
+++ b/sources/android/stlport/stlport/new.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x848
+# include <stl/_prolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x848) && ! defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+#endif
+
+#if !defined(_STLP_NO_NEW_HEADER)
+# if defined (__BORLANDC__)
+# include <new>
+# elif defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <new.h>
+# elif defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800 && !defined(_MSC_VER))
+# include _STLP_NATIVE_OLD_STREAMS_HEADER(new.h)
+# else
+# if defined (__GNUC__) && (__GNUC__ >= 3)
+# include _STLP_NATIVE_OLD_STREAMS_HEADER(new.h)
+# else
+# include _STLP_NATIVE_CPP_RUNTIME_HEADER(new.h)
+# endif
+# endif
+#endif /* !defined(_STLP_NO_NEW_HEADER) */
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x848)
+# if ! defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+#endif
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/numeric b/sources/android/stlport/stlport/numeric
new file mode 100644
index 0000000..79e4647
--- /dev/null
+++ b/sources/android/stlport/stlport/numeric
@@ -0,0 +1,54 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_NUMERIC
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x49
+# include <stl/_prolog.h>
+# define _STLP_NUMERIC
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x49)
+# ifndef _STLP_INTERNAL_NUMERIC_H
+# include <stl/_numeric.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x49) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <numeric>
+# else
+# include _STLP_NATIVE_HEADER(numeric)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x49)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_NUMERIC */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/ostream b/sources/android/stlport/stlport/ostream
new file mode 100644
index 0000000..5134d9c
--- /dev/null
+++ b/sources/android/stlport/stlport/ostream
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_OSTREAM
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x1050
+# include <stl/_prolog.h>
+# define _STLP_OSTREAM
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1050) && \
+ !(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
+# include <stl/_ioserr.h>
+
+# ifndef _STLP_INTERNAL_OSTREAM
+# include <stl/_ostream.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x1050) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <ostream>
+# else
+# include _STLP_NATIVE_HEADER(ostream)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1050)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_OSTREAM */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/ostream.h b/sources/android/stlport/stlport/ostream.h
new file mode 100644
index 0000000..b6a7664
--- /dev/null
+++ b/sources/android/stlport/stlport/ostream.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_OSTREAM_H
+#define _STLP_OSTREAM_H
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x2051
+# include <stl/_prolog.h>
+#endif
+
+#include <stl/_ioserr.h>
+
+#include <ostream>
+
+#ifdef _STLP_USE_NAMESPACES
+# include <using/ostream>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x2051)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_OSTREAM_H */
diff --git a/sources/android/stlport/stlport/pthread.h b/sources/android/stlport/stlport/pthread.h
new file mode 100644
index 0000000..4f0d90c
--- /dev/null
+++ b/sources/android/stlport/stlport/pthread.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x280
+# include <stl/_prolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x280) && ! defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+#endif
+
+#if defined (__SUNPRO_CC) || defined (__HP_aCC)
+# include "/usr/include/pthread.h"
+#else
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <pthread.h>
+# else
+# include _STLP_NATIVE_C_HEADER(pthread.h)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x280)
+# if !defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+#endif
+
+/*
+ Local Variables:
+ mode:C++
+ End:
+*/
diff --git a/sources/android/stlport/stlport/pthread_alloc b/sources/android/stlport/stlport/pthread_alloc
new file mode 100644
index 0000000..c5ccbcb
--- /dev/null
+++ b/sources/android/stlport/stlport/pthread_alloc
@@ -0,0 +1,49 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_PTHREAD_ALLOC
+#define _STLP_PTHREAD_ALLOC
+
+# ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x52
+# include <stl/_prolog.h>
+# endif
+
+# ifdef _STLP_PRAGMA_ONCE
+# pragma once
+# endif
+
+# include <stl/_pthread_alloc.h>
+
+# if (_STLP_OUTERMOST_HEADER_ID == 0x52)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# endif
+
+#endif /* _STLP_PTHREAD_ALLOC */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/queue b/sources/android/stlport/stlport/queue
new file mode 100644
index 0000000..6acd63f
--- /dev/null
+++ b/sources/android/stlport/stlport/queue
@@ -0,0 +1,57 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_QUEUE
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x53
+# include <stl/_prolog.h>
+# define _STLP_QUEUE
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x53)
+# ifndef _STLP_INTERNAL_QUEUE_H
+# include <stl/_queue.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x53) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <queue>
+# else
+# include _STLP_NATIVE_HEADER(queue)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x53)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_QUEUE */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/rlocks.h b/sources/android/stlport/stlport/rlocks.h
new file mode 100644
index 0000000..84db1f4
--- /dev/null
+++ b/sources/android/stlport/stlport/rlocks.h
@@ -0,0 +1,11 @@
+#ifndef _STLP_misc_rlocks_h
+# define _STLP_misc_rlocks_h
+# if (__SUNPRO_CC >= 0x500 )
+# include <../CCios/rlocks.h>
+# elif defined (__SUNPRO_CC)
+# include <../CC/rlocks.h>
+# else
+# error "This file is for SUN CC only. Please remove it if it causes any harm for other compilers."
+# endif
+#endif
+
diff --git a/sources/android/stlport/stlport/rope b/sources/android/stlport/stlport/rope
new file mode 100644
index 0000000..4faa36b
--- /dev/null
+++ b/sources/android/stlport/stlport/rope
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef _STLP_ROPE
+#define _STLP_ROPE
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x54
+# include <stl/_prolog.h>
+#endif
+
+#ifdef _STLP_PRAGMA_ONCE
+# pragma once
+#endif
+
+#if defined (_STLP_NO_EXTENSIONS)
+/* Comment following if you want to use rope class even if you ask for
+ * no extension.
+ */
+# error The rope class is a STLport extension.
+#endif
+
+#include <stl/_rope.h>
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x54)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_ROPE */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/set b/sources/android/stlport/stlport/set
new file mode 100644
index 0000000..ed79d89
--- /dev/null
+++ b/sources/android/stlport/stlport/set
@@ -0,0 +1,57 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_SET
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x55
+# include <stl/_prolog.h>
+# define _STLP_SET
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x55)
+# ifndef _STLP_INTERNAL_SET_H
+# include <stl/_set.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x55) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <set>
+# else
+# include _STLP_NATIVE_HEADER(set)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x55)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_SET */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/setjmp.h b/sources/android/stlport/stlport/setjmp.h
new file mode 100644
index 0000000..3d3f5ef
--- /dev/null
+++ b/sources/android/stlport/stlport/setjmp.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_SETJMP_H
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x256
+# include <stl/_cprolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x256) && !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+# define _STLP_SETJMP_H
+#endif
+
+#if defined(_STLP_WCE_EVC3)
+struct _exception;
+#endif
+
+#if !defined (setjmp)
+# define _STLP_NATIVE_SETJMP_H_INCLUDED
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <setjmp.h>
+# else
+# include _STLP_NATIVE_C_HEADER(setjmp.h)
+# endif
+#endif
+
+#if !defined (_STLP_NATIVE_SETJMP_H_INCLUDED)
+/* See errno.h file for a description of this problem. */
+# error setjmp has been defined before inclusion of setjmp.h header.
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x256)
+# if ! defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+#endif
+#endif /* _STLP_SETJMP_H */
diff --git a/sources/android/stlport/stlport/signal.h b/sources/android/stlport/stlport/signal.h
new file mode 100644
index 0000000..27f91be
--- /dev/null
+++ b/sources/android/stlport/stlport/signal.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x257
+# include <stl/_cprolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x257) && ! defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+#endif
+
+/* evc3 and evc4 don't have signal.h */
+#ifndef _STLP_WCE
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <signal.h>
+# else
+# include _STLP_NATIVE_C_HEADER(signal.h)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x257)
+# if ! defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# endif
+# undef _STLP_DONT_POP_HEADER_ID
+#endif
+
diff --git a/sources/android/stlport/stlport/slist b/sources/android/stlport/stlport/slist
new file mode 100644
index 0000000..c1930e4
--- /dev/null
+++ b/sources/android/stlport/stlport/slist
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef _STLP_SLIST
+#define _STLP_SLIST
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x58
+# include <stl/_prolog.h>
+#endif
+
+#ifdef _STLP_PRAGMA_ONCE
+# pragma once
+#endif
+
+#if defined (_STLP_NO_EXTENSIONS)
+/* Comment following if you want to use the slist constainer even if you ask for
+ * no extension.
+ */
+# error The slist class is an STLport extension.
+#endif
+
+#ifndef _STLP_INTERNAL_SLIST_H
+# include <stl/_slist.h>
+#endif
+
+#if defined (_STLP_IMPORT_VENDOR_STD)
+//This is not a Standard header, it might failed for most of
+//the compilers so we comment it for the moment. Should be uncommented
+//on a compiler basis.
+//# include _STLP_NATIVE_HEADER(slist)
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x58)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_SLIST */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/sstream b/sources/android/stlport/stlport/sstream
new file mode 100644
index 0000000..336bdde
--- /dev/null
+++ b/sources/android/stlport/stlport/sstream
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+// This header defines classes basic_stringbuf, basic_istringstream,
+// basic_ostringstream, and basic_stringstream. These classes
+// represent streamsbufs and streams whose sources or destinations are
+// C++ strings.
+
+#ifndef _STLP_SSTREAM
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x1059
+# include <stl/_prolog.h>
+# define _STLP_SSTREAM
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1059) && \
+ !(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
+# include <stl/_ioserr.h>
+
+# ifndef _STLP_INTERNAL_SSTREAM
+# include <stl/_sstream.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x1059) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <sstream>
+# else
+# include _STLP_NATIVE_HEADER(sstream)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1059)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_SSTREAM */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stack b/sources/android/stlport/stlport/stack
new file mode 100644
index 0000000..253b31d
--- /dev/null
+++ b/sources/android/stlport/stlport/stack
@@ -0,0 +1,57 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STACK
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x60
+# include <stl/_prolog.h>
+# define _STLP_STACK
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x60)
+# ifndef _STLP_INTERNAL_STACK_H
+# include <stl/_stack.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x60) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <stack>
+# else
+# include _STLP_NATIVE_HEADER(stack)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x60)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_STACK */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stdarg.h b/sources/android/stlport/stlport/stdarg.h
new file mode 100644
index 0000000..368e672
--- /dev/null
+++ b/sources/android/stlport/stlport/stdarg.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* Workaround for a "misbehaviour" when compiling resource scripts using
+ * eMbedded Visual C++. The standard .rc file includes windows header files,
+ * which in turn include stdarg.h, which results in warnings and errors
+ */
+#if !defined (RC_INVOKED)
+
+# if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x261
+# include <stl/_cprolog.h>
+# elif (_STLP_OUTERMOST_HEADER_ID == 0x261) && !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+# endif
+
+# if defined(_STLP_WCE_EVC3)
+struct _exception;
+# endif
+
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <stdarg.h>
+# else
+# include _STLP_NATIVE_C_HEADER(stdarg.h)
+# endif
+
+# if (_STLP_OUTERMOST_HEADER_ID == 0x261)
+# if !defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+# endif
+#endif /* RC_INVOKED */
diff --git a/sources/android/stlport/stlport/stddef.h b/sources/android/stlport/stlport/stddef.h
new file mode 100644
index 0000000..f959c23
--- /dev/null
+++ b/sources/android/stlport/stlport/stddef.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x262
+# include <stl/_cprolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x262) && ! defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+#endif
+
+#if defined (_MSC_VER) || defined (__DMC__)
+/* Native stddef.h contains errno macro definition making inclusion of native
+ * errno.h in STLport errno.h impossible. We are then forced to include errno.h
+ * first.
+ */
+# include "errno.h"
+#endif
+
+#if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <stddef.h>
+#else
+# include _STLP_NATIVE_C_HEADER(stddef.h)
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x262)
+# if ! defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+#endif
diff --git a/sources/android/stlport/stlport/stdexcept b/sources/android/stlport/stlport/stdexcept
new file mode 100644
index 0000000..dbb96b9
--- /dev/null
+++ b/sources/android/stlport/stlport/stdexcept
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STDEXCEPT
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x63
+# include <stl/_prolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x63) && !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+# define _STLP_STDEXCEPT
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x63)
+# ifndef _STLP_INTERNAL_STDEXCEPT
+# include <stl/_stdexcept.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x63) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <stdexcept>
+# else
+# include _STLP_NATIVE_HEADER(stdexcept)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x63)
+# if !defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+#endif
+
+#endif /* _STLP_STDEXCEPT */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stdio.h b/sources/android/stlport/stlport/stdio.h
new file mode 100644
index 0000000..e2dbdea
--- /dev/null
+++ b/sources/android/stlport/stlport/stdio.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* Workaround for a "misbehaviour" when compiling resource scripts using
+ * eMbedded Visual C++. The standard .rc file includes windows header files,
+ * which in turn include stdarg.h, which results in warnings and errors
+ */
+#if !defined(RC_INVOKED)
+
+# ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x264
+# include <stl/_cprolog.h>
+# elif (_STLP_OUTERMOST_HEADER_ID == 0x264) && !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+# endif
+
+# if defined(_STLP_WCE_EVC3)
+struct _exception;
+# endif
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <stdio.h>
+# else
+# include _STLP_NATIVE_C_HEADER(stdio.h)
+# endif
+
+# if defined (__SUNPRO_CC) && !defined (_STRUCT_FILE)
+# define _STRUCT_FILE
+# endif
+
+# if defined (__BORLANDC__) && defined (__cplusplus) && !defined (__linux__)
+_STLP_BEGIN_NAMESPACE
+using __std_alias::_streams;
+_STLP_END_NAMESPACE
+# endif
+
+# if (_STLP_OUTERMOST_HEADER_ID == 0x264)
+# if !defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+# endif
+
+#endif /* RC_INVOKED */
diff --git a/sources/android/stlport/stlport/stdiostream.h b/sources/android/stlport/stlport/stdiostream.h
new file mode 100644
index 0000000..80a5c67
--- /dev/null
+++ b/sources/android/stlport/stlport/stdiostream.h
@@ -0,0 +1,10 @@
+#ifndef _STLP_misc_stdiostream_h
+# define _STLP_misc_stdiostream_h
+# if (__SUNPRO_CC >= 0x500 )
+# include <../CCios/stdiostream.h>
+# else if defined (__SUNPRO_CC)
+# include <../CC/stdiostream.h>
+# else
+# error "This file is for SUN CC only. Please remove it if it causes any harm for other compilers."
+# endif
+#endif
diff --git a/sources/android/stlport/stlport/stdlib.h b/sources/android/stlport/stlport/stdlib.h
new file mode 100644
index 0000000..fd55f8a
--- /dev/null
+++ b/sources/android/stlport/stlport/stdlib.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* Workaround for a "misbehaviour" when compiling resource scripts using
+ * eMbedded Visual C++. The standard .rc file includes windows header files,
+ * which in turn include stdlib.h, which results in warnings and errors
+ */
+#if !defined (RC_INVOKED)
+
+# if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x265
+# include <stl/_cprolog.h>
+# elif (_STLP_OUTERMOST_HEADER_ID == 0x265) && !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+# endif
+
+# if defined (_STLP_MSVC_LIB) || (defined (__GNUC__) && defined (__MINGW32__)) || \
+ defined (__BORLANDC__) || defined (__DMC__) || \
+ (defined (__HP_aCC) && defined (_REENTRANT))
+/* Native stdlib.h contains errno macro definition making inclusion of native
+ * errno.h in STLport errno.h impossible. We are then forced to include errno.h
+ * first.
+ */
+# include "errno.h"
+# endif
+
+/*
+ forward-declaration for _exception struct; prevents warning message
+ ../include/stdlib.h(817) : warning C4115: '_exception' : named type definition in parentheses
+*/
+# if defined(_STLP_WCE_EVC3)
+struct _exception;
+# endif
+
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <stdlib.h>
+# else
+# include _STLP_NATIVE_C_HEADER(stdlib.h)
+# endif
+
+/* on evc3/evc4 including stdlib.h also defines setjmp macro */
+# if defined (_STLP_WCE)
+# define _STLP_NATIVE_SETJMP_H_INCLUDED
+# endif
+
+# if (_STLP_OUTERMOST_HEADER_ID == 0x265)
+# if ! defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+# endif
+
+#endif /* RC_INVOKED */
diff --git a/sources/android/stlport/stlport/stl/_abbrevs.h b/sources/android/stlport/stlport/stl/_abbrevs.h
new file mode 100644
index 0000000..c4acac8
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_abbrevs.h
@@ -0,0 +1,77 @@
+/*
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_ABBREVS_H
+# define _STLP_INTERNAL_ABBREVS_H
+
+// ugliness is intentional - to reduce conflicts
+# define input_iterator_tag _In__ItT
+# define output_iterator_tag _Ou__ItT
+# define bidirectional_iterator_tag _Bd__ItT
+# define random_access_iterator_tag _Ra__ItT
+# define input_iterator _In__It
+# define output_iterator _Ou__It
+# define bidirectional_iterator _Bd__It
+# define random_access_iterator _Ra__It
+# define reverse_bidirectional_iterator _rBd__It
+# define reverse_iterator _r__It
+# define back_insert_iterator _bI__It
+# define front_insert_iterator _fI__It
+# define raw_storage_iterator _rS__It
+# define _Const_traits _C_Tr
+# define _Const_Const_traits _CC_Tr
+# define _Nonconst_traits _N_Tr
+# define _Nonconst_Const_traits _NC_Tr
+
+// ugliness is intentional - to reduce conflicts probability
+# define __malloc_alloc M__A
+# define __node_alloc D__A
+# define __new_alloc N__A
+# define __debug_alloc G__A
+# define _STLP_alloc_proxy P__A
+
+# define _Deque_iterator_base _Dq__ItB
+# define _Deque_iterator _Dq__It
+
+# define _Select1st _S1st
+# define _Select2nd _S2nd
+# define __move_source __m_s
+# define _Vector_nonconst_traits _V_nct
+
+# define _Ht_iterator _Ht_It
+
+# define _List_node_base _L__NB
+# define _List_iterator_base _L__ItB
+# define _List_iterator _L__It
+
+# define _Slist_iterator_base _SL__ItB
+# define _Slist_iterator _SL__It
+
+# define _Rb_tree_node_base _rbT__NB
+# define _Rb_tree_node _rbT__N
+# define _Rb_tree_base_iterator _rbT__It
+# define _Rb_tree_base _rbT__B
+
+# if defined (__DMC__) && defined (_STLP_DEBUG)
+# define _NonDbg_hashtable _Nd_Ht
+# define _DBG_iter _d__It
+# endif
+#endif
+
diff --git a/sources/android/stlport/stlport/stl/_algo.c b/sources/android/stlport/stlport/stl/_algo.c
new file mode 100644
index 0000000..b58b92d
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_algo.c
@@ -0,0 +1,2028 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_ALGO_C
+#define _STLP_ALGO_C
+
+#if !defined (_STLP_INTERNAL_ALGO_H)
+# include <stl/_algo.h>
+#endif
+
+#ifndef _STLP_INTERNAL_TEMPBUF_H
+# include <stl/_tempbuf.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _BidirectionalIter, class _Distance, class _Compare>
+void __merge_without_buffer(_BidirectionalIter __first,
+ _BidirectionalIter __middle,
+ _BidirectionalIter __last,
+ _Distance __len1, _Distance __len2,
+ _Compare __comp);
+
+
+template <class _BidirectionalIter1, class _BidirectionalIter2,
+ class _BidirectionalIter3, class _Compare>
+_BidirectionalIter3 __merge_backward(_BidirectionalIter1 __first1,
+ _BidirectionalIter1 __last1,
+ _BidirectionalIter2 __first2,
+ _BidirectionalIter2 __last2,
+ _BidirectionalIter3 __result,
+ _Compare __comp);
+
+template <class _Tp>
+#if !(defined (__SUNPRO_CC) && (__SUNPRO_CC < 0x420 ))
+inline
+#endif
+const _Tp& __median(const _Tp& __a, const _Tp& __b, const _Tp& __c) {
+ if (__a < __b)
+ if (__b < __c)
+ return __b;
+ else if (__a < __c)
+ return __c;
+ else
+ return __a;
+ else if (__a < __c)
+ return __a;
+ else if (__b < __c)
+ return __c;
+ else
+ return __b;
+}
+
+template <class _Tp, class _Compare>
+#if !(defined (__SUNPRO_CC) && (__SUNPRO_CC < 0x420 ))
+inline
+#endif
+const _Tp&
+__median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp) {
+ if (__comp(__a, __b)) {
+ _STLP_VERBOSE_ASSERT(!__comp(__b, __a), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ if (__comp(__b, __c)) {
+ _STLP_VERBOSE_ASSERT(!__comp(__c, __b), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ return __b;
+ }
+ else if (__comp(__a, __c)) {
+ _STLP_VERBOSE_ASSERT(!__comp(__c, __a), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ return __c;
+ }
+ else
+ return __a;
+ }
+ else if (__comp(__a, __c)) {
+ _STLP_VERBOSE_ASSERT(!__comp(__c, __a), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ return __a;
+ }
+ else if (__comp(__b, __c)) {
+ _STLP_VERBOSE_ASSERT(!__comp(__c, __b), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ return __c;
+ }
+ else
+ return __b;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _ForwardIter1, class _ForwardIter2>
+_ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
+ _ForwardIter2 __first2, _ForwardIter2 __last2) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+ // Test for empty ranges
+ if (__first1 == __last1 || __first2 == __last2)
+ return __first1;
+
+ // Test for a pattern of length 1.
+ _ForwardIter2 __p1(__first2);
+
+ if ( ++__p1 == __last2 )
+ return find(__first1, __last1, *__first2);
+
+ // General case.
+
+ for ( ; ; ) { // __first1 != __last1 will be checked in find below
+ __first1 = find(__first1, __last1, *__first2);
+ if (__first1 == __last1)
+ return __last1;
+
+ _ForwardIter2 __p = __p1;
+ _ForwardIter1 __current = __first1;
+ if (++__current == __last1)
+ return __last1;
+
+ while (*__current == *__p) {
+ if (++__p == __last2)
+ return __first1;
+ if (++__current == __last1)
+ return __last1;
+ }
+
+ ++__first1;
+ }
+ return __first1;
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _RandomAccessIter, class _Integer, class _Tp,
+ class _BinaryPred, class _Distance>
+_RandomAccessIter __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
+ _Integer __count, const _Tp& __val, _BinaryPred __pred,
+ _Distance*, const random_access_iterator_tag &)
+{
+ _Distance __tailSize = __last - __first;
+ const _Distance __pattSize = __count;
+ const _Distance __skipOffset = __pattSize - 1;
+ _RandomAccessIter __backTrack;
+ _Distance __remainder, __prevRemainder;
+
+ for ( _RandomAccessIter __lookAhead = __first + __skipOffset; __tailSize >= __pattSize; __lookAhead += __pattSize ) { // the main loop...
+ //__lookAhead here is always pointing to the last element of next possible match.
+ __tailSize -= __pattSize;
+
+ while ( !__pred(*__lookAhead, __val) ) { // the skip loop...
+ if (__tailSize < __pattSize)
+ return __last;
+
+ __lookAhead += __pattSize;
+ __tailSize -= __pattSize;
+ }
+
+ if ( __skipOffset == 0 ) {
+ return (__lookAhead - __skipOffset); //Success
+ }
+
+ __remainder = __skipOffset;
+
+ for (__backTrack = __lookAhead; __pred(*--__backTrack, __val); ) {
+ if (--__remainder == 0)
+ return (__lookAhead - __skipOffset); //Success
+ }
+
+ if (__remainder > __tailSize)
+ return __last; //failure
+
+ __lookAhead += __remainder;
+ __tailSize -= __remainder;
+
+ while ( __pred(*__lookAhead, __val) ) {
+ __prevRemainder = __remainder;
+ __backTrack = __lookAhead;
+
+ do {
+ if (--__remainder == 0)
+ return (__lookAhead - __skipOffset); //Success
+ } while (__pred(*--__backTrack, __val));
+
+ //adjust remainder for next comparison
+ __remainder += __pattSize - __prevRemainder;
+
+ if (__remainder > __tailSize)
+ return __last; //failure
+
+ __lookAhead += __remainder;
+ __tailSize -= __remainder;
+ }
+
+ //__lookAhead here is always pointing to the element of the last mismatch.
+ }
+
+ return __last; //failure
+}
+
+template <class _ForwardIter, class _Integer, class _Tp,
+ class _Distance, class _BinaryPred>
+_ForwardIter __search_n(_ForwardIter __first, _ForwardIter __last,
+ _Integer __count, const _Tp& __val, _BinaryPred __pred,
+ _Distance*, const forward_iterator_tag &) {
+ for (; (__first != __last) && !__pred(*__first, __val); ++__first) {}
+ while (__first != __last) {
+ _Integer __n = __count - 1;
+ _ForwardIter __i = __first;
+ ++__i;
+ while (__i != __last && __n != 0 && __pred(*__i, __val)) {
+ ++__i;
+ --__n;
+ }
+ if (__n == 0)
+ return __first;
+ else if (__i != __last)
+ for (__first = ++__i; (__first != __last) && !__pred(*__first, __val); ++__first) {}
+ else
+ break;
+ }
+ return __last;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+// search_n. Search for __count consecutive copies of __val.
+template <class _ForwardIter, class _Integer, class _Tp>
+_ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,
+ _Integer __count, const _Tp& __val) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ if (__count <= 0)
+ return __first;
+ if (__count == 1)
+ //We use find when __count == 1 to use potential find overload.
+ return find(__first, __last, __val);
+ return _STLP_PRIV __search_n(__first, __last, __count, __val, equal_to<_Tp>(),
+ _STLP_DISTANCE_TYPE(__first, _ForwardIter),
+ _STLP_ITERATOR_CATEGORY(__first, _ForwardIter));
+}
+
+template <class _ForwardIter, class _Integer, class _Tp, class _BinaryPred>
+_ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,
+ _Integer __count, const _Tp& __val,
+ _BinaryPred __binary_pred) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ if (__count <= 0)
+ return __first;
+ return _STLP_PRIV __search_n(__first, __last, __count, __val, __binary_pred,
+ _STLP_DISTANCE_TYPE(__first, _ForwardIter),
+ _STLP_ITERATOR_CATEGORY(__first, _ForwardIter));
+}
+
+template <class _ForwardIter1, class _ForwardIter2>
+_ForwardIter1
+find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
+ _ForwardIter2 __first2, _ForwardIter2 __last2) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+ return _STLP_PRIV __find_end(__first1, __last1, __first2, __last2,
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ _STLP_ITERATOR_CATEGORY(__first1, _ForwardIter1),
+ _STLP_ITERATOR_CATEGORY(__first2, _ForwardIter2),
+#else
+ forward_iterator_tag(),
+ forward_iterator_tag(),
+#endif
+ _STLP_PRIV __equal_to(_STLP_VALUE_TYPE(__first1, _ForwardIter1))
+ );
+}
+
+// unique and unique_copy
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIterator, class _OutputIterator, class _BinaryPredicate,
+ class _Tp>
+_STLP_INLINE_LOOP _OutputIterator
+__unique_copy(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result,
+ _BinaryPredicate __binary_pred, _Tp*) {
+ _Tp __val = *__first;
+ *__result = __val;
+ while (++__first != __last)
+ if (!__binary_pred(__val, *__first)) {
+ __val = *__first;
+ *++__result = __val;
+ }
+ return ++__result;
+}
+
+template <class _InputIter, class _OutputIter, class _BinaryPredicate>
+inline _OutputIter
+__unique_copy(_InputIter __first, _InputIter __last,_OutputIter __result,
+ _BinaryPredicate __binary_pred, const output_iterator_tag &) {
+ return _STLP_PRIV __unique_copy(__first, __last, __result, __binary_pred,
+ _STLP_VALUE_TYPE(__first, _InputIter));
+}
+
+template <class _InputIter, class _ForwardIter, class _BinaryPredicate>
+_STLP_INLINE_LOOP _ForwardIter
+__unique_copy(_InputIter __first, _InputIter __last, _ForwardIter __result,
+ _BinaryPredicate __binary_pred, const forward_iterator_tag &) {
+ *__result = *__first;
+ while (++__first != __last)
+ if (!__binary_pred(*__result, *__first)) *++__result = *__first;
+ return ++__result;
+}
+
+#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
+template <class _InputIterator, class _BidirectionalIterator, class _BinaryPredicate>
+inline _BidirectionalIterator
+__unique_copy(_InputIterator __first, _InputIterator __last,
+ _BidirectionalIterator __result, _BinaryPredicate __binary_pred,
+ const bidirectional_iterator_tag &) {
+ return _STLP_PRIV __unique_copy(__first, __last, __result, __binary_pred, forward_iterator_tag());
+}
+
+template <class _InputIterator, class _RandomAccessIterator, class _BinaryPredicate>
+inline _RandomAccessIterator
+__unique_copy(_InputIterator __first, _InputIterator __last,
+ _RandomAccessIterator __result, _BinaryPredicate __binary_pred,
+ const random_access_iterator_tag &) {
+ return _STLP_PRIV __unique_copy(__first, __last, __result, __binary_pred, forward_iterator_tag());
+}
+#endif /* _STLP_NONTEMPL_BASE_MATCH_BUG */
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter, class _OutputIter>
+_OutputIter
+unique_copy(_InputIter __first, _InputIter __last, _OutputIter __result) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ if (__first == __last) return __result;
+ return _STLP_PRIV __unique_copy(__first, __last, __result,
+ _STLP_PRIV __equal_to(_STLP_VALUE_TYPE(__first, _InputIter)),
+ _STLP_ITERATOR_CATEGORY(__result, _OutputIter));
+}
+
+template <class _InputIter, class _OutputIter, class _BinaryPredicate>
+_OutputIter
+unique_copy(_InputIter __first, _InputIter __last,_OutputIter __result,
+ _BinaryPredicate __binary_pred) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ if (__first == __last) return __result;
+ return _STLP_PRIV __unique_copy(__first, __last, __result, __binary_pred,
+ _STLP_ITERATOR_CATEGORY(__result, _OutputIter));
+}
+
+// rotate and rotate_copy, and their auxiliary functions
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _Distance>
+_ForwardIter __rotate_aux(_ForwardIter __first,
+ _ForwardIter __middle,
+ _ForwardIter __last,
+ _Distance*,
+ const forward_iterator_tag &) {
+ if (__first == __middle)
+ return __last;
+ if (__last == __middle)
+ return __first;
+
+ _ForwardIter __first2 = __middle;
+ do {
+ _STLP_STD::swap(*__first++, *__first2++);
+ if (__first == __middle)
+ __middle = __first2;
+ } while (__first2 != __last);
+
+ _ForwardIter __new_middle = __first;
+
+ __first2 = __middle;
+
+ while (__first2 != __last) {
+ _STLP_STD::swap (*__first++, *__first2++);
+ if (__first == __middle)
+ __middle = __first2;
+ else if (__first2 == __last)
+ __first2 = __middle;
+ }
+
+ return __new_middle;
+}
+
+template <class _BidirectionalIter, class _Distance>
+_BidirectionalIter __rotate_aux(_BidirectionalIter __first,
+ _BidirectionalIter __middle,
+ _BidirectionalIter __last,
+ _Distance*,
+ const bidirectional_iterator_tag &) {
+ if (__first == __middle)
+ return __last;
+ if (__last == __middle)
+ return __first;
+
+ _STLP_PRIV __reverse(__first, __middle, bidirectional_iterator_tag());
+ _STLP_PRIV __reverse(__middle, __last, bidirectional_iterator_tag());
+
+ while (__first != __middle && __middle != __last)
+ _STLP_STD::swap(*__first++, *--__last);
+
+ if (__first == __middle) {
+ _STLP_PRIV __reverse(__middle, __last, bidirectional_iterator_tag());
+ return __last;
+ }
+ else {
+ _STLP_PRIV __reverse(__first, __middle, bidirectional_iterator_tag());
+ return __first;
+ }
+}
+
+// rotate and rotate_copy, and their auxiliary functions
+template <class _EuclideanRingElement>
+_STLP_INLINE_LOOP
+_EuclideanRingElement __gcd(_EuclideanRingElement __m,
+ _EuclideanRingElement __n) {
+ while (__n != 0) {
+ _EuclideanRingElement __t = __m % __n;
+ __m = __n;
+ __n = __t;
+ }
+ return __m;
+}
+
+template <class _RandomAccessIter, class _Distance, class _Tp>
+_RandomAccessIter __rotate_aux(_RandomAccessIter __first,
+ _RandomAccessIter __middle,
+ _RandomAccessIter __last,
+ _Distance *, _Tp *) {
+
+ _Distance __n = __last - __first;
+ _Distance __k = __middle - __first;
+ _Distance __l = __n - __k;
+ _RandomAccessIter __result = __first + (__last - __middle);
+
+ if (__k == 0) /* __first == middle */
+ return __last;
+
+ if (__k == __l) {
+ _STLP_STD::swap_ranges(__first, __middle, __middle);
+ return __result;
+ }
+
+ _Distance __d = _STLP_PRIV __gcd(__n, __k);
+
+ for (_Distance __i = 0; __i < __d; __i++) {
+ _Tp __tmp = *__first;
+ _RandomAccessIter __p = __first;
+
+ if (__k < __l) {
+ for (_Distance __j = 0; __j < __l/__d; __j++) {
+ if (__p > __first + __l) {
+ *__p = *(__p - __l);
+ __p -= __l;
+ }
+
+ *__p = *(__p + __k);
+ __p += __k;
+ }
+ }
+
+ else {
+ for (_Distance __j = 0; __j < __k/__d - 1; __j ++) {
+ if (__p < __last - __k) {
+ *__p = *(__p + __k);
+ __p += __k;
+ }
+
+ *__p = * (__p - __l);
+ __p -= __l;
+ }
+ }
+
+ *__p = __tmp;
+ ++__first;
+ }
+
+ return __result;
+}
+
+template <class _RandomAccessIter, class _Distance>
+inline _RandomAccessIter
+__rotate_aux(_RandomAccessIter __first, _RandomAccessIter __middle, _RandomAccessIter __last,
+ _Distance * __dis, const random_access_iterator_tag &) {
+ return _STLP_PRIV __rotate_aux(__first, __middle, __last,
+ __dis, _STLP_VALUE_TYPE(__first, _RandomAccessIter));
+}
+
+template <class _ForwardIter>
+_ForwardIter
+__rotate(_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last) {
+ _STLP_DEBUG_CHECK(__check_range(__first, __middle))
+ _STLP_DEBUG_CHECK(__check_range(__middle, __last))
+ return __rotate_aux(__first, __middle, __last,
+ _STLP_DISTANCE_TYPE(__first, _ForwardIter),
+ _STLP_ITERATOR_CATEGORY(__first, _ForwardIter));
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _ForwardIter>
+void rotate(_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last) {
+ _STLP_PRIV __rotate(__first, __middle, __last);
+}
+
+// Return a random number in the range [0, __n). This function encapsulates
+// whether we're using rand (part of the standard C library) or lrand48
+// (not standard, but a much better choice whenever it's available).
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Distance>
+inline _Distance __random_number(_Distance __n) {
+#ifdef _STLP_NO_DRAND48
+ return rand() % __n;
+#else
+ return lrand48() % __n;
+#endif
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _RandomAccessIter>
+void random_shuffle(_RandomAccessIter __first,
+ _RandomAccessIter __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ if (__first == __last) return;
+ for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+ iter_swap(__i, __first + _STLP_PRIV __random_number((__i - __first) + 1));
+}
+
+template <class _RandomAccessIter, class _RandomNumberGenerator>
+void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last,
+ _RandomNumberGenerator &__rand) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ if (__first == __last) return;
+ for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+ iter_swap(__i, __first + __rand((__i - __first) + 1));
+}
+
+#if !defined (_STLP_NO_EXTENSIONS)
+// random_sample and random_sample_n (extensions, not part of the standard).
+template <class _ForwardIter, class _OutputIter, class _Distance>
+_OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,
+ _OutputIter __out_ite, const _Distance __n) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _Distance __remaining = _STLP_STD::distance(__first, __last);
+ _Distance __m = (min) (__n, __remaining);
+
+ while (__m > 0) {
+ if (_STLP_PRIV __random_number(__remaining) < __m) {
+ *__out_ite = *__first;
+ ++__out_ite;
+ --__m;
+ }
+
+ --__remaining;
+ ++__first;
+ }
+ return __out_ite;
+}
+
+
+template <class _ForwardIter, class _OutputIter, class _Distance,
+ class _RandomNumberGenerator>
+_OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,
+ _OutputIter __out_ite, const _Distance __n,
+ _RandomNumberGenerator& __rand) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _Distance __remaining = _STLP_STD::distance(__first, __last);
+ _Distance __m = (min) (__n, __remaining);
+
+ while (__m > 0) {
+ if (__rand(__remaining) < __m) {
+ *__out_ite = *__first;
+ ++__out_ite;
+ --__m;
+ }
+
+ --__remaining;
+ ++__first;
+ }
+ return __out_ite;
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter, class _RandomAccessIter, class _Distance>
+_RandomAccessIter __random_sample(_InputIter __first, _InputIter __last,
+ _RandomAccessIter __out_ite,
+ const _Distance __n) {
+ _Distance __m = 0;
+ _Distance __t = __n;
+ for ( ; __first != __last && __m < __n; ++__m, ++__first)
+ __out_ite[__m] = *__first;
+
+ while (__first != __last) {
+ ++__t;
+ _Distance __M = __random_number(__t);
+ if (__M < __n)
+ __out_ite[__M] = *__first;
+ ++__first;
+ }
+
+ return __out_ite + __m;
+}
+
+template <class _InputIter, class _RandomAccessIter,
+ class _RandomNumberGenerator, class _Distance>
+_RandomAccessIter __random_sample(_InputIter __first, _InputIter __last,
+ _RandomAccessIter __out_ite,
+ _RandomNumberGenerator& __rand,
+ const _Distance __n) {
+ _Distance __m = 0;
+ _Distance __t = __n;
+ for ( ; __first != __last && __m < __n; ++__m, ++__first)
+ __out_ite[__m] = *__first;
+
+ while (__first != __last) {
+ ++__t;
+ _Distance __M = __rand(__t);
+ if (__M < __n)
+ __out_ite[__M] = *__first;
+ ++__first;
+ }
+
+ return __out_ite + __m;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter, class _RandomAccessIter>
+_RandomAccessIter
+random_sample(_InputIter __first, _InputIter __last,
+ _RandomAccessIter __out_first, _RandomAccessIter __out_last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__out_first, __out_last))
+ return _STLP_PRIV __random_sample(__first, __last,
+ __out_first, __out_last - __out_first);
+}
+
+template <class _InputIter, class _RandomAccessIter, class _RandomNumberGenerator>
+_RandomAccessIter
+random_sample(_InputIter __first, _InputIter __last,
+ _RandomAccessIter __out_first, _RandomAccessIter __out_last,
+ _RandomNumberGenerator& __rand) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__out_first, __out_last))
+ return _STLP_PRIV __random_sample(__first, __last,
+ __out_first, __rand,
+ __out_last - __out_first);
+}
+
+#endif /* _STLP_NO_EXTENSIONS */
+
+// partition, stable_partition, and their auxiliary functions
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _Predicate>
+_STLP_INLINE_LOOP _ForwardIter __partition(_ForwardIter __first,
+ _ForwardIter __last,
+ _Predicate __pred,
+ const forward_iterator_tag &) {
+ if (__first == __last) return __first;
+
+ while (__pred(*__first))
+ if (++__first == __last) return __first;
+
+ _ForwardIter __next = __first;
+
+ while (++__next != __last) {
+ if (__pred(*__next)) {
+ _STLP_STD::swap(*__first, *__next);
+ ++__first;
+ }
+ }
+ return __first;
+}
+
+template <class _BidirectionalIter, class _Predicate>
+_STLP_INLINE_LOOP _BidirectionalIter __partition(_BidirectionalIter __first,
+ _BidirectionalIter __last,
+ _Predicate __pred,
+ const bidirectional_iterator_tag &) {
+ for (;;) {
+ for (;;) {
+ if (__first == __last)
+ return __first;
+ else if (__pred(*__first))
+ ++__first;
+ else
+ break;
+ }
+ --__last;
+ for (;;) {
+ if (__first == __last)
+ return __first;
+ else if (!__pred(*__last))
+ --__last;
+ else
+ break;
+ }
+ iter_swap(__first, __last);
+ ++__first;
+ }
+}
+
+#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
+template <class _BidirectionalIter, class _Predicate>
+inline
+_BidirectionalIter __partition(_BidirectionalIter __first,
+ _BidirectionalIter __last,
+ _Predicate __pred,
+ const random_access_iterator_tag &) {
+ return __partition(__first, __last, __pred, bidirectional_iterator_tag());
+}
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _ForwardIter, class _Predicate>
+_ForwardIter partition(_ForwardIter __first, _ForwardIter __last, _Predicate __pred) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ return _STLP_PRIV __partition(__first, __last, __pred, _STLP_ITERATOR_CATEGORY(__first, _ForwardIter));
+}
+
+
+/* __pred_of_first: false if we know that __pred(*__first) is false,
+ * true when we don't know the result of __pred(*__first).
+ * __not_pred_of_before_last: true if we know that __pred(*--__last) is true,
+ * false when we don't know the result of __pred(*--__last).
+ */
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _Predicate, class _Distance>
+_ForwardIter __inplace_stable_partition(_ForwardIter __first,
+ _ForwardIter __last,
+ _Predicate __pred, _Distance __len,
+ bool __pred_of_first, bool __pred_of_before_last) {
+ if (__len == 1)
+ return (__pred_of_first && (__pred_of_before_last || __pred(*__first))) ? __last : __first;
+ _ForwardIter __middle = __first;
+ _Distance __half_len = __len / 2;
+ _STLP_STD::advance(__middle, __half_len);
+ return _STLP_PRIV __rotate(_STLP_PRIV __inplace_stable_partition(__first, __middle, __pred, __half_len, __pred_of_first, false),
+ __middle,
+ _STLP_PRIV __inplace_stable_partition(__middle, __last, __pred, __len - __half_len, true, __pred_of_before_last));
+}
+
+template <class _ForwardIter, class _Pointer, class _Predicate,
+ class _Distance>
+_ForwardIter __stable_partition_adaptive(_ForwardIter __first,
+ _ForwardIter __last,
+ _Predicate __pred, _Distance __len,
+ _Pointer __buffer, _Distance __buffer_size,
+ bool __pred_of_first, bool __pred_of_before_last) {
+ if (__len <= __buffer_size) {
+ _ForwardIter __result1 = __first;
+ _Pointer __result2 = __buffer;
+ if ((__first != __last) && (!__pred_of_first || __pred(*__first))) {
+ *__result2 = *__first;
+ ++__result2; ++__first; --__len;
+ }
+ for (; __first != __last ; ++__first, --__len) {
+ if (((__len == 1) && (__pred_of_before_last || __pred(*__first))) ||
+ ((__len != 1) && __pred(*__first))){
+ *__result1 = *__first;
+ ++__result1;
+ }
+ else {
+ *__result2 = *__first;
+ ++__result2;
+ }
+ }
+ _STLP_STD::copy(__buffer, __result2, __result1);
+ return __result1;
+ }
+ else {
+ _ForwardIter __middle = __first;
+ _Distance __half_len = __len / 2;
+ _STLP_STD::advance(__middle, __half_len);
+ return _STLP_PRIV __rotate(_STLP_PRIV __stable_partition_adaptive(__first, __middle, __pred,
+ __half_len, __buffer, __buffer_size,
+ __pred_of_first, false),
+ __middle,
+ _STLP_PRIV __stable_partition_adaptive(__middle, __last, __pred,
+ __len - __half_len, __buffer, __buffer_size,
+ true, __pred_of_before_last));
+ }
+}
+
+template <class _ForwardIter, class _Predicate, class _Tp, class _Distance>
+inline _ForwardIter
+__stable_partition_aux_aux(_ForwardIter __first, _ForwardIter __last,
+ _Predicate __pred, _Tp*, _Distance*, bool __pred_of_before_last) {
+ _Temporary_buffer<_ForwardIter, _Tp> __buf(__first, __last);
+ _STLP_MPWFIX_TRY //*TY 06/01/2000 - they forget to call dtor for _Temporary_buffer if no try/catch block is present
+ return (__buf.size() > 0) ?
+ __stable_partition_adaptive(__first, __last, __pred,
+ _Distance(__buf.requested_size()),
+ __buf.begin(), __buf.size(),
+ false, __pred_of_before_last) :
+ __inplace_stable_partition(__first, __last, __pred,
+ _Distance(__buf.requested_size()),
+ false, __pred_of_before_last);
+ _STLP_MPWFIX_CATCH //*TY 06/01/2000 - they forget to call dtor for _Temporary_buffer if no try/catch block is present
+}
+
+template <class _ForwardIter, class _Predicate>
+_ForwardIter
+__stable_partition_aux(_ForwardIter __first, _ForwardIter __last, _Predicate __pred,
+ const forward_iterator_tag &) {
+ return __stable_partition_aux_aux(__first, __last, __pred,
+ _STLP_VALUE_TYPE(__first, _ForwardIter),
+ _STLP_DISTANCE_TYPE(__first, _ForwardIter), false);
+}
+
+template <class _BidirectIter, class _Predicate>
+_BidirectIter
+__stable_partition_aux(_BidirectIter __first, _BidirectIter __last, _Predicate __pred,
+ const bidirectional_iterator_tag &) {
+ for (--__last;;) {
+ if (__first == __last)
+ return __first;
+ else if (!__pred(*__last))
+ --__last;
+ else
+ break;
+ }
+ ++__last;
+ //Here we know that __pred(*--__last) is true
+ return __stable_partition_aux_aux(__first, __last, __pred,
+ _STLP_VALUE_TYPE(__first, _BidirectIter),
+ _STLP_DISTANCE_TYPE(__first, _BidirectIter), true);
+}
+
+#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
+template <class _BidirectIter, class _Predicate>
+_BidirectIter
+__stable_partition_aux(_BidirectIter __first, _BidirectIter __last, _Predicate __pred,
+ const random_access_iterator_tag &) {
+ return __stable_partition_aux(__first, __last, __pred, bidirectional_iterator_tag());
+}
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _ForwardIter, class _Predicate>
+_ForwardIter
+stable_partition(_ForwardIter __first, _ForwardIter __last, _Predicate __pred) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ for (;;) {
+ if (__first == __last)
+ return __first;
+ else if (__pred(*__first))
+ ++__first;
+ else
+ break;
+ }
+ return _STLP_PRIV __stable_partition_aux(__first, __last, __pred,
+ _STLP_ITERATOR_CATEGORY(__first, _ForwardIter));
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _RandomAccessIter, class _Tp, class _Compare>
+_RandomAccessIter __unguarded_partition(_RandomAccessIter __first,
+ _RandomAccessIter __last,
+ _Tp __pivot, _Compare __comp) {
+ for (;;) {
+ while (__comp(*__first, __pivot)) {
+ _STLP_VERBOSE_ASSERT(!__comp(__pivot, *__first), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ ++__first;
+ }
+ --__last;
+ while (__comp(__pivot, *__last)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__last, __pivot), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ --__last;
+ }
+ if (!(__first < __last))
+ return __first;
+ iter_swap(__first, __last);
+ ++__first;
+ }
+}
+
+// sort() and its auxiliary functions.
+#define __stl_threshold 16
+
+template <class _RandomAccessIter, class _Tp, class _Compare>
+void __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val,
+ _Compare __comp) {
+ _RandomAccessIter __next = __last;
+ --__next;
+ while (__comp(__val, *__next)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__next, __val), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ *__last = *__next;
+ __last = __next;
+ --__next;
+ }
+ *__last = __val;
+}
+
+template <class _RandomAccessIter, class _Tp, class _Compare>
+inline void __linear_insert(_RandomAccessIter __first,
+ _RandomAccessIter __last, _Tp __val, _Compare __comp) {
+ //*TY 12/26/1998 - added __val as a paramter
+ // _Tp __val = *__last; //*TY 12/26/1998 - __val supplied by caller
+ if (__comp(__val, *__first)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__first, __val), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ copy_backward(__first, __last, __last + 1);
+ *__first = __val;
+ }
+ else
+ __unguarded_linear_insert(__last, __val, __comp);
+}
+
+template <class _RandomAccessIter, class _Tp, class _Compare>
+void __insertion_sort(_RandomAccessIter __first,
+ _RandomAccessIter __last,
+ _Tp *, _Compare __comp) {
+ if (__first == __last) return;
+ for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
+ __linear_insert<_RandomAccessIter, _Tp, _Compare>(__first, __i, *__i, __comp); //*TY 12/26/1998 - supply *__i as __val
+}
+
+template <class _RandomAccessIter, class _Tp, class _Compare>
+void __unguarded_insertion_sort_aux(_RandomAccessIter __first,
+ _RandomAccessIter __last,
+ _Tp*, _Compare __comp) {
+ for (_RandomAccessIter __i = __first; __i != __last; ++__i)
+ __unguarded_linear_insert<_RandomAccessIter, _Tp, _Compare>(__i, *__i, __comp);
+}
+
+template <class _RandomAccessIter, class _Compare>
+inline void __unguarded_insertion_sort(_RandomAccessIter __first,
+ _RandomAccessIter __last,
+ _Compare __comp) {
+ __unguarded_insertion_sort_aux(__first, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIter), __comp);
+}
+
+template <class _RandomAccessIter, class _Compare>
+void __final_insertion_sort(_RandomAccessIter __first,
+ _RandomAccessIter __last, _Compare __comp) {
+ if (__last - __first > __stl_threshold) {
+ __insertion_sort(__first, __first + __stl_threshold, _STLP_VALUE_TYPE(__first,_RandomAccessIter), __comp);
+ __unguarded_insertion_sort(__first + __stl_threshold, __last, __comp);
+ }
+ else
+ __insertion_sort(__first, __last, _STLP_VALUE_TYPE(__first,_RandomAccessIter), __comp);
+}
+
+template <class _RandomAccessIter, class _Tp, class _Size, class _Compare>
+void __introsort_loop(_RandomAccessIter __first,
+ _RandomAccessIter __last, _Tp*,
+ _Size __depth_limit, _Compare __comp) {
+ while (__last - __first > __stl_threshold) {
+ if (__depth_limit == 0) {
+ partial_sort(__first, __last, __last, __comp);
+ return;
+ }
+ --__depth_limit;
+ _RandomAccessIter __cut =
+ __unguarded_partition(__first, __last,
+ _Tp(__median(*__first,
+ *(__first + (__last - __first)/2),
+ *(__last - 1), __comp)),
+ __comp);
+ __introsort_loop(__cut, __last, (_Tp*) 0, __depth_limit, __comp);
+ __last = __cut;
+ }
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _RandomAccessIter>
+void sort(_RandomAccessIter __first, _RandomAccessIter __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ if (__first != __last) {
+ _STLP_PRIV __introsort_loop(__first, __last,
+ _STLP_VALUE_TYPE(__first, _RandomAccessIter),
+ _STLP_PRIV __lg(__last - __first) * 2,
+ _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)));
+ _STLP_PRIV __final_insertion_sort(__first, __last,
+ _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)));
+ }
+}
+
+template <class _RandomAccessIter, class _Compare>
+void sort(_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ if (__first != __last) {
+ _STLP_PRIV __introsort_loop(__first, __last,
+ _STLP_VALUE_TYPE(__first, _RandomAccessIter),
+ _STLP_PRIV __lg(__last - __first) * 2, __comp);
+ _STLP_PRIV __final_insertion_sort(__first, __last, __comp);
+ }
+}
+
+// stable_sort() and its auxiliary functions.
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _RandomAccessIter, class _Compare>
+void __inplace_stable_sort(_RandomAccessIter __first,
+ _RandomAccessIter __last, _Compare __comp) {
+ if (__last - __first < 15) {
+ __insertion_sort(__first, __last, _STLP_VALUE_TYPE(__first,_RandomAccessIter), __comp);
+ return;
+ }
+ _RandomAccessIter __middle = __first + (__last - __first) / 2;
+ __inplace_stable_sort(__first, __middle, __comp);
+ __inplace_stable_sort(__middle, __last, __comp);
+ __merge_without_buffer(__first, __middle, __last,
+ __middle - __first,
+ __last - __middle,
+ __comp);
+}
+
+template <class _RandomAccessIter1, class _RandomAccessIter2,
+ class _Distance, class _Compare>
+void __merge_sort_loop(_RandomAccessIter1 __first,
+ _RandomAccessIter1 __last,
+ _RandomAccessIter2 __result, _Distance __step_size,
+ _Compare __comp) {
+ _Distance __two_step = 2 * __step_size;
+
+ while (__last - __first >= __two_step) {
+ __result = merge(__first, __first + __step_size,
+ __first + __step_size, __first + __two_step,
+ __result,
+ __comp);
+ __first += __two_step;
+ }
+ __step_size = (min) (_Distance(__last - __first), __step_size);
+
+ merge(__first, __first + __step_size,
+ __first + __step_size, __last,
+ __result,
+ __comp);
+}
+
+const int __stl_chunk_size = 7;
+
+template <class _RandomAccessIter, class _Distance, class _Compare>
+void __chunk_insertion_sort(_RandomAccessIter __first,
+ _RandomAccessIter __last,
+ _Distance __chunk_size, _Compare __comp) {
+ while (__last - __first >= __chunk_size) {
+ __insertion_sort(__first, __first + __chunk_size,
+ _STLP_VALUE_TYPE(__first,_RandomAccessIter), __comp);
+ __first += __chunk_size;
+ }
+ __insertion_sort(__first, __last, _STLP_VALUE_TYPE(__first,_RandomAccessIter), __comp);
+}
+
+template <class _RandomAccessIter, class _Pointer, class _Distance,
+ class _Compare>
+void __merge_sort_with_buffer(_RandomAccessIter __first,
+ _RandomAccessIter __last, _Pointer __buffer,
+ _Distance*, _Compare __comp) {
+ _Distance __len = __last - __first;
+ _Pointer __buffer_last = __buffer + __len;
+
+ _Distance __step_size = __stl_chunk_size;
+ __chunk_insertion_sort(__first, __last, __step_size, __comp);
+
+ while (__step_size < __len) {
+ __merge_sort_loop(__first, __last, __buffer, __step_size, __comp);
+ __step_size *= 2;
+ __merge_sort_loop(__buffer, __buffer_last, __first, __step_size, __comp);
+ __step_size *= 2;
+ }
+}
+
+template <class _BidirectionalIter1, class _BidirectionalIter2,
+ class _Distance>
+_BidirectionalIter1 __rotate_adaptive(_BidirectionalIter1 __first,
+ _BidirectionalIter1 __middle,
+ _BidirectionalIter1 __last,
+ _Distance __len1, _Distance __len2,
+ _BidirectionalIter2 __buffer,
+ _Distance __buffer_size) {
+ if (__len1 > __len2 && __len2 <= __buffer_size) {
+ _BidirectionalIter2 __buffer_end = _STLP_STD::copy(__middle, __last, __buffer);
+ _STLP_STD::copy_backward(__first, __middle, __last);
+ return _STLP_STD::copy(__buffer, __buffer_end, __first);
+ }
+ else if (__len1 <= __buffer_size) {
+ _BidirectionalIter2 __buffer_end = _STLP_STD::copy(__first, __middle, __buffer);
+ _STLP_STD::copy(__middle, __last, __first);
+ return _STLP_STD::copy_backward(__buffer, __buffer_end, __last);
+ }
+ else
+ return _STLP_PRIV __rotate(__first, __middle, __last);
+}
+
+template <class _BidirectionalIter, class _Distance, class _Pointer,
+ class _Compare>
+void __merge_adaptive(_BidirectionalIter __first,
+ _BidirectionalIter __middle,
+ _BidirectionalIter __last,
+ _Distance __len1, _Distance __len2,
+ _Pointer __buffer, _Distance __buffer_size,
+ _Compare __comp) {
+ if (__len1 <= __len2 && __len1 <= __buffer_size) {
+ _Pointer __buffer_end = _STLP_STD::copy(__first, __middle, __buffer);
+ _STLP_STD::merge(__buffer, __buffer_end, __middle, __last, __first, __comp);
+ }
+ else if (__len2 <= __buffer_size) {
+ _Pointer __buffer_end = _STLP_STD::copy(__middle, __last, __buffer);
+ _STLP_PRIV __merge_backward(__first, __middle, __buffer, __buffer_end, __last,
+ __comp);
+ }
+ else {
+ _BidirectionalIter __first_cut = __first;
+ _BidirectionalIter __second_cut = __middle;
+ _Distance __len11 = 0;
+ _Distance __len22 = 0;
+ if (__len1 > __len2) {
+ __len11 = __len1 / 2;
+ _STLP_STD::advance(__first_cut, __len11);
+ __second_cut = _STLP_STD::lower_bound(__middle, __last, *__first_cut, __comp);
+ __len22 += _STLP_STD::distance(__middle, __second_cut);
+ }
+ else {
+ __len22 = __len2 / 2;
+ _STLP_STD::advance(__second_cut, __len22);
+ __first_cut = _STLP_STD::upper_bound(__first, __middle, *__second_cut, __comp);
+ __len11 += _STLP_STD::distance(__first, __first_cut);
+ }
+ _BidirectionalIter __new_middle =
+ __rotate_adaptive(__first_cut, __middle, __second_cut, __len1 - __len11,
+ __len22, __buffer, __buffer_size);
+ __merge_adaptive(__first, __first_cut, __new_middle, __len11,
+ __len22, __buffer, __buffer_size, __comp);
+ __merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11,
+ __len2 - __len22, __buffer, __buffer_size, __comp);
+ }
+}
+
+template <class _RandomAccessIter, class _Pointer, class _Distance,
+ class _Compare>
+void __stable_sort_adaptive(_RandomAccessIter __first,
+ _RandomAccessIter __last, _Pointer __buffer,
+ _Distance __buffer_size, _Compare __comp) {
+ _Distance __len = (__last - __first + 1) / 2;
+ _RandomAccessIter __middle = __first + __len;
+ if (__len > __buffer_size) {
+ __stable_sort_adaptive(__first, __middle, __buffer, __buffer_size,
+ __comp);
+ __stable_sort_adaptive(__middle, __last, __buffer, __buffer_size,
+ __comp);
+ }
+ else {
+ __merge_sort_with_buffer(__first, __middle, __buffer, (_Distance*)0,
+ __comp);
+ __merge_sort_with_buffer(__middle, __last, __buffer, (_Distance*)0,
+ __comp);
+ }
+ __merge_adaptive(__first, __middle, __last, _Distance(__middle - __first),
+ _Distance(__last - __middle), __buffer, __buffer_size,
+ __comp);
+}
+
+template <class _RandomAccessIter, class _Tp, class _Distance, class _Compare>
+void __stable_sort_aux(_RandomAccessIter __first,
+ _RandomAccessIter __last, _Tp*, _Distance*,
+ _Compare __comp) {
+ _Temporary_buffer<_RandomAccessIter, _Tp> buf(__first, __last);
+ if (buf.begin() == 0)
+ __inplace_stable_sort(__first, __last, __comp);
+ else
+ __stable_sort_adaptive(__first, __last, buf.begin(),
+ _Distance(buf.size()),
+ __comp);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _RandomAccessIter>
+void stable_sort(_RandomAccessIter __first,
+ _RandomAccessIter __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _STLP_PRIV __stable_sort_aux(__first, __last,
+ _STLP_VALUE_TYPE(__first, _RandomAccessIter),
+ _STLP_DISTANCE_TYPE(__first, _RandomAccessIter),
+ _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)));
+}
+
+template <class _RandomAccessIter, class _Compare>
+void stable_sort(_RandomAccessIter __first,
+ _RandomAccessIter __last, _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _STLP_PRIV __stable_sort_aux(__first, __last,
+ _STLP_VALUE_TYPE(__first, _RandomAccessIter),
+ _STLP_DISTANCE_TYPE(__first, _RandomAccessIter),
+ __comp);
+}
+
+// partial_sort, partial_sort_copy, and auxiliary functions.
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _RandomAccessIter, class _Tp, class _Compare>
+void __partial_sort(_RandomAccessIter __first, _RandomAccessIter __middle,
+ _RandomAccessIter __last, _Tp*, _Compare __comp) {
+ make_heap(__first, __middle, __comp);
+ for (_RandomAccessIter __i = __middle; __i < __last; ++__i) {
+ if (__comp(*__i, *__first)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__first, *__i), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ __pop_heap(__first, __middle, __i, _Tp(*__i), __comp,
+ _STLP_DISTANCE_TYPE(__first, _RandomAccessIter));
+ }
+ }
+ sort_heap(__first, __middle, __comp);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _RandomAccessIter>
+void partial_sort(_RandomAccessIter __first,_RandomAccessIter __middle,
+ _RandomAccessIter __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __middle))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__middle, __last))
+ _STLP_PRIV __partial_sort(__first, __middle, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIter),
+ _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)));
+}
+
+template <class _RandomAccessIter, class _Compare>
+void partial_sort(_RandomAccessIter __first,_RandomAccessIter __middle,
+ _RandomAccessIter __last, _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __middle))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__middle, __last))
+ _STLP_PRIV __partial_sort(__first, __middle, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIter), __comp);
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter, class _RandomAccessIter, class _Compare,
+ class _Distance, class _Tp>
+_RandomAccessIter __partial_sort_copy(_InputIter __first,
+ _InputIter __last,
+ _RandomAccessIter __result_first,
+ _RandomAccessIter __result_last,
+ _Compare __comp, _Distance*, _Tp*) {
+ if (__result_first == __result_last) return __result_last;
+ _RandomAccessIter __result_real_last = __result_first;
+ while(__first != __last && __result_real_last != __result_last) {
+ *__result_real_last = *__first;
+ ++__result_real_last;
+ ++__first;
+ }
+ make_heap(__result_first, __result_real_last, __comp);
+ while (__first != __last) {
+ if (__comp(*__first, *__result_first)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__result_first, *__first), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ __adjust_heap(__result_first, _Distance(0),
+ _Distance(__result_real_last - __result_first),
+ _Tp(*__first),
+ __comp);
+ }
+ ++__first;
+ }
+ sort_heap(__result_first, __result_real_last, __comp);
+ return __result_real_last;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter, class _RandomAccessIter>
+_RandomAccessIter
+partial_sort_copy(_InputIter __first, _InputIter __last,
+ _RandomAccessIter __result_first, _RandomAccessIter __result_last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__result_first, __result_last))
+ return _STLP_PRIV __partial_sort_copy(__first, __last, __result_first, __result_last,
+ _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _InputIter)),
+ _STLP_DISTANCE_TYPE(__result_first, _RandomAccessIter),
+ _STLP_VALUE_TYPE(__first, _InputIter));
+}
+
+template <class _InputIter, class _RandomAccessIter, class _Compare>
+_RandomAccessIter
+partial_sort_copy(_InputIter __first, _InputIter __last,
+ _RandomAccessIter __result_first,
+ _RandomAccessIter __result_last, _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__result_first, __result_last))
+ return _STLP_PRIV __partial_sort_copy(__first, __last, __result_first, __result_last,
+ __comp,
+ _STLP_DISTANCE_TYPE(__result_first, _RandomAccessIter),
+ _STLP_VALUE_TYPE(__first, _InputIter));
+}
+
+// nth_element() and its auxiliary functions.
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _RandomAccessIter, class _Tp, class _Compare>
+void __nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
+ _RandomAccessIter __last, _Tp*, _Compare __comp) {
+ while (__last - __first > 3) {
+ _RandomAccessIter __cut =
+ __unguarded_partition(__first, __last,
+ _Tp(__median(*__first,
+ *(__first + (__last - __first)/2),
+ *(__last - 1),
+ __comp)),
+ __comp);
+ if (__cut <= __nth)
+ __first = __cut;
+ else
+ __last = __cut;
+ }
+ __insertion_sort(__first, __last, _STLP_VALUE_TYPE(__first,_RandomAccessIter), __comp);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _RandomAccessIter>
+void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
+ _RandomAccessIter __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __nth))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__nth, __last))
+ _STLP_PRIV __nth_element(__first, __nth, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIter),
+ _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)));
+}
+
+template <class _RandomAccessIter, class _Compare>
+void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
+ _RandomAccessIter __last, _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __nth))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__nth, __last))
+ _STLP_PRIV __nth_element(__first, __nth, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIter), __comp);
+}
+
+// Binary search (lower_bound, upper_bound, equal_range, binary_search).
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _Tp,
+ class _Compare1, class _Compare2, class _Distance>
+_ForwardIter __upper_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+ _Compare1 __comp1, _Compare2 __comp2, _Distance*) {
+ _Distance __len = _STLP_STD::distance(__first, __last);
+ _Distance __half;
+
+ while (__len > 0) {
+ __half = __len >> 1;
+ _ForwardIter __middle = __first;
+ _STLP_STD::advance(__middle, __half);
+ if (__comp2(__val, *__middle)) {
+ _STLP_VERBOSE_ASSERT(!__comp1(*__middle, __val), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ __len = __half;
+ }
+ else {
+ __first = __middle;
+ ++__first;
+ __len = __len - __half - 1;
+ }
+ }
+ return __first;
+}
+
+template <class _ForwardIter, class _Tp,
+ class _Compare1, class _Compare2, class _Distance>
+pair<_ForwardIter, _ForwardIter>
+__equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+ _Compare1 __comp1, _Compare2 __comp2, _Distance* __dist) {
+ _Distance __len = _STLP_STD::distance(__first, __last);
+ _Distance __half;
+
+ while (__len > 0) {
+ __half = __len >> 1;
+ _ForwardIter __middle = __first;
+ _STLP_STD::advance(__middle, __half);
+ if (__comp1(*__middle, __val)) {
+ _STLP_VERBOSE_ASSERT(!__comp2(__val, *__middle), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ __first = __middle;
+ ++__first;
+ __len = __len - __half - 1;
+ }
+ else if (__comp2(__val, *__middle)) {
+ _STLP_VERBOSE_ASSERT(!__comp1(*__middle, __val), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ __len = __half;
+ }
+ else {
+ _ForwardIter __left = _STLP_PRIV __lower_bound(__first, __middle, __val, __comp1, __comp2, __dist);
+ //Small optim: If lower_bound haven't found an equivalent value
+ //there is no need to call upper_bound.
+ if (__comp1(*__left, __val)) {
+ _STLP_VERBOSE_ASSERT(!__comp2(__val, *__left), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ return pair<_ForwardIter, _ForwardIter>(__left, __left);
+ }
+ _STLP_STD::advance(__first, __len);
+ _ForwardIter __right = _STLP_PRIV __upper_bound(++__middle, __first, __val, __comp1, __comp2, __dist);
+ return pair<_ForwardIter, _ForwardIter>(__left, __right);
+ }
+ }
+ return pair<_ForwardIter, _ForwardIter>(__first, __first);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+ while (__first1 != __last1 && __first2 != __last2) {
+ if (*__first2 < *__first1) {
+ *__result = *__first2;
+ ++__first2;
+ }
+ else {
+ *__result = *__first1;
+ ++__first1;
+ }
+ ++__result;
+ }
+ return _STLP_STD::copy(__first2, __last2, _STLP_STD::copy(__first1, __last1, __result));
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+ class _Compare>
+_OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result, _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+ while (__first1 != __last1 && __first2 != __last2) {
+ if (__comp(*__first2, *__first1)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__first1, *__first2), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ *__result = *__first2;
+ ++__first2;
+ }
+ else {
+ *__result = *__first1;
+ ++__first1;
+ }
+ ++__result;
+ }
+ return _STLP_STD::copy(__first2, __last2, _STLP_STD::copy(__first1, __last1, __result));
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _BidirectionalIter, class _Distance, class _Compare>
+void __merge_without_buffer(_BidirectionalIter __first,
+ _BidirectionalIter __middle,
+ _BidirectionalIter __last,
+ _Distance __len1, _Distance __len2,
+ _Compare __comp) {
+ if (__len1 == 0 || __len2 == 0)
+ return;
+ if (__len1 + __len2 == 2) {
+ if (__comp(*__middle, *__first)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__first, *__middle), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ iter_swap(__first, __middle);
+ }
+ return;
+ }
+ _BidirectionalIter __first_cut = __first;
+ _BidirectionalIter __second_cut = __middle;
+ _Distance __len11 = 0;
+ _Distance __len22 = 0;
+ if (__len1 > __len2) {
+ __len11 = __len1 / 2;
+ _STLP_STD::advance(__first_cut, __len11);
+ __second_cut = _STLP_STD::lower_bound(__middle, __last, *__first_cut, __comp);
+ __len22 += _STLP_STD::distance(__middle, __second_cut);
+ }
+ else {
+ __len22 = __len2 / 2;
+ _STLP_STD::advance(__second_cut, __len22);
+ __first_cut = _STLP_STD::upper_bound(__first, __middle, *__second_cut, __comp);
+ __len11 += _STLP_STD::distance(__first, __first_cut);
+ }
+ _BidirectionalIter __new_middle
+ = _STLP_PRIV __rotate(__first_cut, __middle, __second_cut);
+ __merge_without_buffer(__first, __first_cut, __new_middle, __len11, __len22,
+ __comp);
+ __merge_without_buffer(__new_middle, __second_cut, __last, __len1 - __len11,
+ __len2 - __len22, __comp);
+}
+
+template <class _BidirectionalIter1, class _BidirectionalIter2,
+ class _BidirectionalIter3, class _Compare>
+_BidirectionalIter3 __merge_backward(_BidirectionalIter1 __first1,
+ _BidirectionalIter1 __last1,
+ _BidirectionalIter2 __first2,
+ _BidirectionalIter2 __last2,
+ _BidirectionalIter3 __result,
+ _Compare __comp) {
+ if (__first1 == __last1)
+ return copy_backward(__first2, __last2, __result);
+ if (__first2 == __last2)
+ return copy_backward(__first1, __last1, __result);
+ --__last1;
+ --__last2;
+ for (;;) {
+ if (__comp(*__last2, *__last1)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__last1, *__last2), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ *--__result = *__last1;
+ if (__first1 == __last1)
+ return copy_backward(__first2, ++__last2, __result);
+ --__last1;
+ }
+ else {
+ *--__result = *__last2;
+ if (__first2 == __last2)
+ return copy_backward(__first1, ++__last1, __result);
+ --__last2;
+ }
+ }
+}
+
+template <class _BidirectionalIter, class _Tp,
+ class _Distance, class _Compare>
+inline void __inplace_merge_aux(_BidirectionalIter __first,
+ _BidirectionalIter __middle,
+ _BidirectionalIter __last, _Tp*, _Distance*,
+ _Compare __comp) {
+ _Distance __len1 = _STLP_STD::distance(__first, __middle);
+ _Distance __len2 = _STLP_STD::distance(__middle, __last);
+
+ _Temporary_buffer<_BidirectionalIter, _Tp> __buf(__first, __last);
+ if (__buf.begin() == 0)
+ __merge_without_buffer(__first, __middle, __last, __len1, __len2, __comp);
+ else
+ __merge_adaptive(__first, __middle, __last, __len1, __len2,
+ __buf.begin(), _Distance(__buf.size()),
+ __comp);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _BidirectionalIter>
+void inplace_merge(_BidirectionalIter __first,
+ _BidirectionalIter __middle,
+ _BidirectionalIter __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __middle))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__middle, __last))
+ if (__first == __middle || __middle == __last)
+ return;
+ _STLP_PRIV __inplace_merge_aux(__first, __middle, __last,
+ _STLP_VALUE_TYPE(__first, _BidirectionalIter), _STLP_DISTANCE_TYPE(__first, _BidirectionalIter),
+ _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _BidirectionalIter)));
+}
+
+template <class _BidirectionalIter, class _Compare>
+void inplace_merge(_BidirectionalIter __first,
+ _BidirectionalIter __middle,
+ _BidirectionalIter __last, _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __middle))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__middle, __last))
+ if (__first == __middle || __middle == __last)
+ return;
+ _STLP_PRIV __inplace_merge_aux(__first, __middle, __last,
+ _STLP_VALUE_TYPE(__first, _BidirectionalIter), _STLP_DISTANCE_TYPE(__first, _BidirectionalIter),
+ __comp);
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _Compare>
+bool __includes(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2, _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+ while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(*__first2, *__first1)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__first1, *__first2), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ return false;
+ }
+ else if (__comp(*__first1, *__first2))
+ ++__first1;
+ else
+ ++__first1, ++__first2;
+
+ return __first2 == __last2;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _Compare>
+bool includes(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2, _Compare __comp) {
+ return _STLP_PRIV __includes(__first1, __last1, __first2, __last2, __comp);
+}
+
+template <class _InputIter1, class _InputIter2>
+bool includes(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2) {
+ return _STLP_PRIV __includes(__first1, __last1, __first2, __last2,
+ _STLP_PRIV __less(_STLP_VALUE_TYPE(__first1, _InputIter1)));
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+ class _Compare>
+_OutputIter __set_union(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result, _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+ while (__first1 != __last1 && __first2 != __last2) {
+ if (__comp(*__first1, *__first2)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__first2, *__first1), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ *__result = *__first1;
+ ++__first1;
+ }
+ else if (__comp(*__first2, *__first1)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__first1, *__first2), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ *__result = *__first2;
+ ++__first2;
+ }
+ else {
+ *__result = *__first1;
+ ++__first1;
+ ++__first2;
+ }
+ ++__result;
+ }
+ return _STLP_STD::copy(__first2, __last2, _STLP_STD::copy(__first1, __last1, __result));
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result) {
+ return _STLP_PRIV __set_union(__first1, __last1, __first2, __last2, __result,
+ _STLP_PRIV __less(_STLP_VALUE_TYPE(__first1, _InputIter1)));
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+ class _Compare>
+_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result, _Compare __comp) {
+ return _STLP_PRIV __set_union(__first1, __last1, __first2, __last2, __result, __comp);
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+ class _Compare>
+_OutputIter __set_intersection(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result, _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+ while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(*__first1, *__first2)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__first2, *__first1), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ ++__first1;
+ }
+ else if (__comp(*__first2, *__first1))
+ ++__first2;
+ else {
+ *__result = *__first1;
+ ++__first1;
+ ++__first2;
+ ++__result;
+ }
+ return __result;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result) {
+ return _STLP_PRIV __set_intersection(__first1, __last1, __first2, __last2, __result,
+ _STLP_PRIV __less(_STLP_VALUE_TYPE(__first1, _InputIter1)));
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+ class _Compare>
+_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result, _Compare __comp) {
+ return _STLP_PRIV __set_intersection(__first1, __last1, __first2, __last2, __result, __comp);
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+ class _Compare>
+_OutputIter __set_difference(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result, _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+ while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(*__first1, *__first2)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__first2, *__first1), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ *__result = *__first1;
+ ++__first1;
+ ++__result;
+ }
+ else if (__comp(*__first2, *__first1))
+ ++__first2;
+ else {
+ ++__first1;
+ ++__first2;
+ }
+ return _STLP_STD::copy(__first1, __last1, __result);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result) {
+ return _STLP_PRIV __set_difference(__first1, __last1, __first2, __last2, __result,
+ _STLP_PRIV __less(_STLP_VALUE_TYPE(__first1, _InputIter1)));
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+ class _Compare>
+_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result, _Compare __comp) {
+ return _STLP_PRIV __set_difference(__first1, __last1, __first2, __last2, __result, __comp);
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _OutputIter, class _Compare>
+_OutputIter
+__set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result, _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+ while (__first1 != __last1 && __first2 != __last2) {
+ if (__comp(*__first1, *__first2)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__first2, *__first1), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ *__result = *__first1;
+ ++__first1;
+ ++__result;
+ }
+ else if (__comp(*__first2, *__first1)) {
+ *__result = *__first2;
+ ++__first2;
+ ++__result;
+ }
+ else {
+ ++__first1;
+ ++__first2;
+ }
+ }
+ return _STLP_STD::copy(__first2, __last2, _STLP_STD::copy(__first1, __last1, __result));
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter
+set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result) {
+ return _STLP_PRIV __set_symmetric_difference(__first1, __last1, __first2, __last2, __result,
+ _STLP_PRIV __less(_STLP_VALUE_TYPE(__first1, _InputIter1)));
+}
+
+template <class _InputIter1, class _InputIter2, class _OutputIter, class _Compare>
+_OutputIter
+set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result,
+ _Compare __comp) {
+ return _STLP_PRIV __set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp);
+}
+
+// min_element and max_element, with and without an explicitly supplied
+// comparison function.
+
+template <class _ForwardIter>
+_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ if (__first == __last) return __first;
+ _ForwardIter __result = __first;
+ while (++__first != __last)
+ if (*__result < *__first) {
+ _STLP_VERBOSE_ASSERT(!(*__first < *__result), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ __result = __first;
+ }
+ return __result;
+}
+
+template <class _ForwardIter, class _Compare>
+_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last,
+ _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ if (__first == __last) return __first;
+ _ForwardIter __result = __first;
+ while (++__first != __last) {
+ if (__comp(*__result, *__first)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__first, *__result), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ __result = __first;
+ }
+ }
+ return __result;
+}
+
+template <class _ForwardIter>
+_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ if (__first == __last) return __first;
+ _ForwardIter __result = __first;
+ while (++__first != __last)
+ if (*__first < *__result) {
+ _STLP_VERBOSE_ASSERT(!(*__result < *__first), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ __result = __first;
+ }
+ return __result;
+}
+
+template <class _ForwardIter, class _Compare>
+_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last,
+ _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ if (__first == __last) return __first;
+ _ForwardIter __result = __first;
+ while (++__first != __last) {
+ if (__comp(*__first, *__result)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__result, *__first), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ __result = __first;
+ }
+ }
+ return __result;
+}
+
+// next_permutation and prev_permutation, with and without an explicitly
+// supplied comparison function.
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _BidirectionalIter, class _Compare>
+bool __next_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
+ _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ if (__first == __last)
+ return false;
+ _BidirectionalIter __i = __first;
+ ++__i;
+ if (__i == __last)
+ return false;
+ __i = __last;
+ --__i;
+
+ for(;;) {
+ _BidirectionalIter __ii = __i;
+ --__i;
+ if (__comp(*__i, *__ii)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__ii, *__i), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ _BidirectionalIter __j = __last;
+ while (!__comp(*__i, *--__j)) {}
+ iter_swap(__i, __j);
+ reverse(__ii, __last);
+ return true;
+ }
+ if (__i == __first) {
+ reverse(__first, __last);
+ return false;
+ }
+ }
+#if defined (_STLP_NEED_UNREACHABLE_RETURN)
+ return false;
+#endif
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _BidirectionalIter>
+bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ return _STLP_PRIV __next_permutation(__first, __last,
+ _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _BidirectionalIter)));
+}
+
+template <class _BidirectionalIter, class _Compare>
+bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
+ _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ return _STLP_PRIV __next_permutation(__first, __last, __comp);
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _BidirectionalIter, class _Compare>
+bool __prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
+ _Compare __comp) {
+ if (__first == __last)
+ return false;
+ _BidirectionalIter __i = __first;
+ ++__i;
+ if (__i == __last)
+ return false;
+ __i = __last;
+ --__i;
+
+ for(;;) {
+ _BidirectionalIter __ii = __i;
+ --__i;
+ if (__comp(*__ii, *__i)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__i, *__ii), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ _BidirectionalIter __j = __last;
+ while (!__comp(*--__j, *__i)) {}
+ iter_swap(__i, __j);
+ reverse(__ii, __last);
+ return true;
+ }
+ if (__i == __first) {
+ reverse(__first, __last);
+ return false;
+ }
+ }
+#if defined (_STLP_NEED_UNREACHABLE_RETURN)
+ return false;
+#endif
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _BidirectionalIter>
+bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ return _STLP_PRIV __prev_permutation(__first, __last,
+ _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _BidirectionalIter)));
+}
+
+template <class _BidirectionalIter, class _Compare>
+bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
+ _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ return _STLP_PRIV __prev_permutation(__first, __last, __comp);
+}
+
+#if !defined (_STLP_NO_EXTENSIONS)
+
+// is_heap, a predicate testing whether or not a range is
+// a heap. This function is an extension, not part of the C++
+// standard.
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _RandomAccessIter, class _Distance, class _StrictWeakOrdering>
+bool __is_heap(_RandomAccessIter __first, _StrictWeakOrdering __comp,
+ _Distance __n) {
+ _Distance __parent = 0;
+ for (_Distance __child = 1; __child < __n; ++__child) {
+ if (__comp(__first[__parent], __first[__child])) {
+ _STLP_VERBOSE_ASSERT(!__comp(__first[__child], __first[__parent]), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ return false;
+ }
+ if ((__child & 1) == 0)
+ ++__parent;
+ }
+ return true;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _RandomAccessIter>
+bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ return _STLP_PRIV __is_heap(__first, _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _RandomAccessIter)), __last - __first);
+}
+
+template <class _RandomAccessIter, class _StrictWeakOrdering>
+bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last,
+ _StrictWeakOrdering __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ return _STLP_PRIV __is_heap(__first, __comp, __last - __first);
+}
+
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _StrictWeakOrdering>
+bool __is_sorted(_ForwardIter __first, _ForwardIter __last,
+ _StrictWeakOrdering __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ if (__first == __last)
+ return true;
+
+ _ForwardIter __next = __first;
+ for (++__next; __next != __last; __first = __next, ++__next) {
+ if (__comp(*__next, *__first)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__first, *__next), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ return false;
+ }
+ }
+
+ return true;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif /* _STLP_NO_EXTENSIONS */
+
+_STLP_END_NAMESPACE
+
+#undef __stl_threshold
+
+#endif /* _STLP_ALGO_C */
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_algo.h b/sources/android/stlport/stlport/stl/_algo.h
new file mode 100644
index 0000000..01e5f93
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_algo.h
@@ -0,0 +1,745 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_ALGO_H
+#define _STLP_INTERNAL_ALGO_H
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+# include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_HEAP_H
+# include <stl/_heap.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+# include <stl/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+# include <stl/_function_base.h>
+#endif
+
+#if defined (__SUNPRO_CC) && !defined (_STLP_INTERNAL_CSTDIO)
+// remove() conflict
+# include <stl/_cstdio.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+// for_each. Apply a function to every element of a range.
+template <class _InputIter, class _Function>
+_STLP_INLINE_LOOP _Function
+for_each(_InputIter __first, _InputIter __last, _Function __f) {
+ for ( ; __first != __last; ++__first)
+ __f(*__first);
+ return __f;
+}
+
+// count_if
+template <class _InputIter, class _Predicate>
+_STLP_INLINE_LOOP _STLP_DIFFERENCE_TYPE(_InputIter)
+count_if(_InputIter __first, _InputIter __last, _Predicate __pred) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _STLP_DIFFERENCE_TYPE(_InputIter) __n = 0;
+ for ( ; __first != __last; ++__first) {
+ if (__pred(*__first))
+ ++__n;
+ }
+ return __n;
+}
+
+// adjacent_find.
+
+template <class _ForwardIter, class _BinaryPredicate>
+_STLP_INLINE_LOOP _ForwardIter
+adjacent_find(_ForwardIter __first, _ForwardIter __last,
+ _BinaryPredicate __binary_pred) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ if (__first == __last)
+ return __last;
+ _ForwardIter __next = __first;
+ while(++__next != __last) {
+ if (__binary_pred(*__first, *__next))
+ return __first;
+ __first = __next;
+ }
+ return __last;
+}
+
+template <class _ForwardIter>
+_STLP_INLINE_LOOP _ForwardIter
+adjacent_find(_ForwardIter __first, _ForwardIter __last) {
+ return adjacent_find(__first, __last,
+ _STLP_PRIV __equal_to(_STLP_VALUE_TYPE(__first, _ForwardIter)));
+}
+
+#if !defined (_STLP_NO_ANACHRONISMS)
+template <class _InputIter, class _Tp, class _Size>
+_STLP_INLINE_LOOP void
+count(_InputIter __first, _InputIter __last, const _Tp& __val, _Size& __n) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ for ( ; __first != __last; ++__first)
+ if (*__first == __val)
+ ++__n;
+}
+
+template <class _InputIter, class _Predicate, class _Size>
+_STLP_INLINE_LOOP void
+count_if(_InputIter __first, _InputIter __last, _Predicate __pred, _Size& __n) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ for ( ; __first != __last; ++__first)
+ if (__pred(*__first))
+ ++__n;
+}
+#endif
+
+template <class _ForwardIter1, class _ForwardIter2>
+_ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
+ _ForwardIter2 __first2, _ForwardIter2 __last2);
+
+// search_n. Search for __count consecutive copies of __val.
+template <class _ForwardIter, class _Integer, class _Tp>
+_ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,
+ _Integer __count, const _Tp& __val);
+template <class _ForwardIter, class _Integer, class _Tp, class _BinaryPred>
+_ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,
+ _Integer __count, const _Tp& __val, _BinaryPred __binary_pred);
+
+template <class _InputIter, class _ForwardIter>
+inline _InputIter find_first_of(_InputIter __first1, _InputIter __last1,
+ _ForwardIter __first2, _ForwardIter __last2) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+ return _STLP_PRIV __find_first_of(__first1, __last1, __first2, __last2);
+}
+
+template <class _InputIter, class _ForwardIter, class _BinaryPredicate>
+inline _InputIter
+find_first_of(_InputIter __first1, _InputIter __last1,
+ _ForwardIter __first2, _ForwardIter __last2, _BinaryPredicate __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+ return _STLP_PRIV __find_first_of(__first1, __last1, __first2, __last2, __comp);
+}
+
+template <class _ForwardIter1, class _ForwardIter2>
+_ForwardIter1
+find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
+ _ForwardIter2 __first2, _ForwardIter2 __last2);
+
+// swap_ranges
+template <class _ForwardIter1, class _ForwardIter2>
+_STLP_INLINE_LOOP _ForwardIter2
+swap_ranges(_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ for ( ; __first1 != __last1; ++__first1, ++__first2)
+ iter_swap(__first1, __first2);
+ return __first2;
+}
+
+// transform
+template <class _InputIter, class _OutputIter, class _UnaryOperation>
+_STLP_INLINE_LOOP _OutputIter
+transform(_InputIter __first, _InputIter __last, _OutputIter __result, _UnaryOperation __opr) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ for ( ; __first != __last; ++__first, ++__result)
+ *__result = __opr(*__first);
+ return __result;
+}
+template <class _InputIter1, class _InputIter2, class _OutputIter, class _BinaryOperation>
+_STLP_INLINE_LOOP _OutputIter
+transform(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _OutputIter __result,_BinaryOperation __binary_op) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result)
+ *__result = __binary_op(*__first1, *__first2);
+ return __result;
+}
+
+// replace_if, replace_copy, replace_copy_if
+
+template <class _ForwardIter, class _Predicate, class _Tp>
+_STLP_INLINE_LOOP void
+replace_if(_ForwardIter __first, _ForwardIter __last, _Predicate __pred, const _Tp& __new_value) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ for ( ; __first != __last; ++__first)
+ if (__pred(*__first))
+ *__first = __new_value;
+}
+
+template <class _InputIter, class _OutputIter, class _Tp>
+_STLP_INLINE_LOOP _OutputIter
+replace_copy(_InputIter __first, _InputIter __last,_OutputIter __result,
+ const _Tp& __old_value, const _Tp& __new_value) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ for ( ; __first != __last; ++__first, ++__result)
+ *__result = *__first == __old_value ? __new_value : *__first;
+ return __result;
+}
+
+template <class _Iterator, class _OutputIter, class _Predicate, class _Tp>
+_STLP_INLINE_LOOP _OutputIter
+replace_copy_if(_Iterator __first, _Iterator __last,
+ _OutputIter __result,
+ _Predicate __pred, const _Tp& __new_value) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ for ( ; __first != __last; ++__first, ++__result)
+ *__result = __pred(*__first) ? __new_value : *__first;
+ return __result;
+}
+
+// generate and generate_n
+
+template <class _ForwardIter, class _Generator>
+_STLP_INLINE_LOOP void
+generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ for ( ; __first != __last; ++__first)
+ *__first = __gen();
+}
+
+template <class _OutputIter, class _Size, class _Generator>
+_STLP_INLINE_LOOP void
+generate_n(_OutputIter __first, _Size __n, _Generator __gen) {
+ for ( ; __n > 0; --__n, ++__first)
+ *__first = __gen();
+}
+
+// remove, remove_if, remove_copy, remove_copy_if
+
+template <class _InputIter, class _OutputIter, class _Tp>
+_STLP_INLINE_LOOP _OutputIter
+remove_copy(_InputIter __first, _InputIter __last,_OutputIter __result, const _Tp& __val) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ for ( ; __first != __last; ++__first) {
+ if (!(*__first == __val)) {
+ *__result = *__first;
+ ++__result;
+ }
+ }
+ return __result;
+}
+
+template <class _InputIter, class _OutputIter, class _Predicate>
+_STLP_INLINE_LOOP _OutputIter
+remove_copy_if(_InputIter __first, _InputIter __last, _OutputIter __result, _Predicate __pred) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ for ( ; __first != __last; ++__first) {
+ if (!__pred(*__first)) {
+ *__result = *__first;
+ ++__result;
+ }
+ }
+ return __result;
+}
+
+template <class _ForwardIter, class _Tp>
+_STLP_INLINE_LOOP _ForwardIter
+remove(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ __first = find(__first, __last, __val);
+ if (__first == __last)
+ return __first;
+ else {
+ _ForwardIter __next = __first;
+ return remove_copy(++__next, __last, __first, __val);
+ }
+}
+
+template <class _ForwardIter, class _Predicate>
+_STLP_INLINE_LOOP _ForwardIter
+remove_if(_ForwardIter __first, _ForwardIter __last, _Predicate __pred) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ __first = find_if(__first, __last, __pred);
+ if ( __first == __last )
+ return __first;
+ else {
+ _ForwardIter __next = __first;
+ return remove_copy_if(++__next, __last, __first, __pred);
+ }
+}
+
+// unique and unique_copy
+template <class _InputIter, class _OutputIter>
+_OutputIter unique_copy(_InputIter __first, _InputIter __last, _OutputIter __result);
+
+template <class _InputIter, class _OutputIter, class _BinaryPredicate>
+_OutputIter unique_copy(_InputIter __first, _InputIter __last,_OutputIter __result,
+ _BinaryPredicate __binary_pred);
+
+template <class _ForwardIter>
+inline _ForwardIter unique(_ForwardIter __first, _ForwardIter __last) {
+ __first = adjacent_find(__first, __last);
+ return unique_copy(__first, __last, __first);
+}
+
+template <class _ForwardIter, class _BinaryPredicate>
+inline _ForwardIter unique(_ForwardIter __first, _ForwardIter __last,
+ _BinaryPredicate __binary_pred) {
+ __first = adjacent_find(__first, __last, __binary_pred);
+ return unique_copy(__first, __last, __first, __binary_pred);
+}
+
+// reverse and reverse_copy, and their auxiliary functions
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _BidirectionalIter>
+_STLP_INLINE_LOOP void
+__reverse(_BidirectionalIter __first, _BidirectionalIter __last, const bidirectional_iterator_tag &) {
+ for (; __first != __last && __first != --__last; ++__first)
+ _STLP_STD::iter_swap(__first,__last);
+}
+
+template <class _RandomAccessIter>
+_STLP_INLINE_LOOP void
+__reverse(_RandomAccessIter __first, _RandomAccessIter __last, const random_access_iterator_tag &) {
+ for (; __first < __last; ++__first)
+ _STLP_STD::iter_swap(__first, --__last);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _BidirectionalIter>
+inline void
+reverse(_BidirectionalIter __first, _BidirectionalIter __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _STLP_PRIV __reverse(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _BidirectionalIter));
+}
+
+template <class _BidirectionalIter, class _OutputIter>
+_STLP_INLINE_LOOP
+_OutputIter reverse_copy(_BidirectionalIter __first,
+ _BidirectionalIter __last,
+ _OutputIter __result) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ while (__first != __last) {
+ --__last;
+ *__result = *__last;
+ ++__result;
+ }
+ return __result;
+}
+
+template <class _ForwardIter>
+void rotate(_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last);
+
+template <class _ForwardIter, class _OutputIter>
+inline _OutputIter rotate_copy(_ForwardIter __first, _ForwardIter __middle,
+ _ForwardIter __last, _OutputIter __result) {
+ return _STLP_STD::copy(__first, __middle, copy(__middle, __last, __result));
+}
+
+// random_shuffle
+
+template <class _RandomAccessIter>
+void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last);
+
+template <class _RandomAccessIter, class _RandomNumberGenerator>
+void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last,
+ _RandomNumberGenerator& __rand);
+
+#if !defined (_STLP_NO_EXTENSIONS)
+// random_sample and random_sample_n (extensions, not part of the standard).
+
+template <class _ForwardIter, class _OutputIter, class _Distance>
+_OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,
+ _OutputIter __out_ite, const _Distance __n);
+
+template <class _ForwardIter, class _OutputIter, class _Distance,
+ class _RandomNumberGenerator>
+_OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,
+ _OutputIter __out_ite, const _Distance __n,
+ _RandomNumberGenerator& __rand);
+
+template <class _InputIter, class _RandomAccessIter>
+_RandomAccessIter
+random_sample(_InputIter __first, _InputIter __last,
+ _RandomAccessIter __out_first, _RandomAccessIter __out_last);
+
+template <class _InputIter, class _RandomAccessIter,
+ class _RandomNumberGenerator>
+_RandomAccessIter
+random_sample(_InputIter __first, _InputIter __last,
+ _RandomAccessIter __out_first, _RandomAccessIter __out_last,
+ _RandomNumberGenerator& __rand);
+
+#endif /* _STLP_NO_EXTENSIONS */
+
+// partition, stable_partition, and their auxiliary functions
+
+template <class _ForwardIter, class _Predicate>
+_ForwardIter partition(_ForwardIter __first, _ForwardIter __last, _Predicate __pred);
+
+template <class _ForwardIter, class _Predicate>
+_ForwardIter
+stable_partition(_ForwardIter __first, _ForwardIter __last, _Predicate __pred);
+
+// sort() and its auxiliary functions.
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Size>
+inline _Size __lg(_Size __n) {
+ _Size __k;
+ for (__k = 0; __n != 1; __n >>= 1) ++__k;
+ return __k;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _RandomAccessIter>
+void sort(_RandomAccessIter __first, _RandomAccessIter __last);
+template <class _RandomAccessIter, class _Compare>
+void sort(_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp);
+
+// stable_sort() and its auxiliary functions.
+template <class _RandomAccessIter>
+void stable_sort(_RandomAccessIter __first,
+ _RandomAccessIter __last);
+
+template <class _RandomAccessIter, class _Compare>
+void stable_sort(_RandomAccessIter __first,
+ _RandomAccessIter __last, _Compare __comp);
+
+// partial_sort, partial_sort_copy, and auxiliary functions.
+
+template <class _RandomAccessIter>
+void partial_sort(_RandomAccessIter __first, _RandomAccessIter __middle,
+ _RandomAccessIter __last);
+
+template <class _RandomAccessIter, class _Compare>
+void partial_sort(_RandomAccessIter __first,_RandomAccessIter __middle,
+ _RandomAccessIter __last, _Compare __comp);
+
+template <class _InputIter, class _RandomAccessIter>
+_RandomAccessIter
+partial_sort_copy(_InputIter __first, _InputIter __last,
+ _RandomAccessIter __result_first, _RandomAccessIter __result_last);
+
+template <class _InputIter, class _RandomAccessIter, class _Compare>
+_RandomAccessIter
+partial_sort_copy(_InputIter __first, _InputIter __last,
+ _RandomAccessIter __result_first,
+ _RandomAccessIter __result_last, _Compare __comp);
+
+// nth_element() and its auxiliary functions.
+template <class _RandomAccessIter>
+void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
+ _RandomAccessIter __last);
+
+template <class _RandomAccessIter, class _Compare>
+void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
+ _RandomAccessIter __last, _Compare __comp);
+
+// auxiliary class for lower_bound, etc.
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _T1, class _T2>
+struct __less_2 {
+ bool operator() (const _T1& __x, const _T2& __y) const { return __x < __y ; }
+};
+
+template <class _T1, class _T2>
+__less_2<_T1,_T2> __less2(_T1*, _T2* ) { return __less_2<_T1, _T2>(); }
+
+#if defined (_STLP_FUNCTION_PARTIAL_ORDER)
+template <class _Tp>
+less<_Tp> __less2(_Tp*, _Tp* ) { return less<_Tp>(); }
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+// Binary search (lower_bound, upper_bound, equal_range, binary_search).
+template <class _ForwardIter, class _Tp>
+inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,
+ const _Tp& __val) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ return _STLP_PRIV __lower_bound(__first, __last, __val,
+ _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),
+ _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),
+ _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+}
+
+template <class _ForwardIter, class _Tp, class _Compare>
+inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,
+ const _Tp& __val, _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ return _STLP_PRIV __lower_bound(__first, __last, __val, __comp, __comp,
+ _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _Tp, class _Compare1, class _Compare2, class _Distance>
+_ForwardIter __upper_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+ _Compare1 __comp1, _Compare2 __comp2, _Distance*);
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _ForwardIter, class _Tp>
+inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,
+ const _Tp& __val) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ return _STLP_PRIV __upper_bound(__first, __last, __val,
+ _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),
+ _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),
+ _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+}
+
+template <class _ForwardIter, class _Tp, class _Compare>
+inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,
+ const _Tp& __val, _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ return _STLP_PRIV __upper_bound(__first, __last, __val, __comp, __comp,
+ _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _Tp, class _Compare1, class _Compare2, class _Distance>
+pair<_ForwardIter, _ForwardIter>
+__equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+ _Compare1 __comp1, _Compare2 __comp2, _Distance*);
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _ForwardIter, class _Tp>
+inline pair<_ForwardIter, _ForwardIter>
+equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ return _STLP_PRIV __equal_range(__first, __last, __val,
+ _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),
+ _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),
+ _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+}
+
+template <class _ForwardIter, class _Tp, class _Compare>
+inline pair<_ForwardIter, _ForwardIter>
+equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+ _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ return _STLP_PRIV __equal_range(__first, __last, __val, __comp, __comp,
+ _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+}
+
+template <class _ForwardIter, class _Tp>
+inline bool binary_search(_ForwardIter __first, _ForwardIter __last,
+ const _Tp& __val) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _ForwardIter __i = _STLP_PRIV __lower_bound(__first, __last, __val,
+ _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),
+ _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),
+ _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+ return __i != __last && !(__val < *__i);
+}
+
+template <class _ForwardIter, class _Tp, class _Compare>
+inline bool binary_search(_ForwardIter __first, _ForwardIter __last,
+ const _Tp& __val,
+ _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _ForwardIter __i = _STLP_PRIV __lower_bound(__first, __last, __val, __comp, __comp,
+ _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+ return __i != __last && !__comp(__val, *__i);
+}
+
+// merge, with and without an explicitly supplied comparison function.
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result);
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+ class _Compare>
+_OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result, _Compare __comp);
+
+
+// inplace_merge and its auxiliary functions.
+
+
+template <class _BidirectionalIter>
+void inplace_merge(_BidirectionalIter __first,
+ _BidirectionalIter __middle,
+ _BidirectionalIter __last) ;
+
+template <class _BidirectionalIter, class _Compare>
+void inplace_merge(_BidirectionalIter __first,
+ _BidirectionalIter __middle,
+ _BidirectionalIter __last, _Compare __comp);
+
+// Set algorithms: includes, set_union, set_intersection, set_difference,
+// set_symmetric_difference. All of these algorithms have the precondition
+// that their input ranges are sorted and the postcondition that their output
+// ranges are sorted.
+
+template <class _InputIter1, class _InputIter2>
+bool includes(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2);
+
+template <class _InputIter1, class _InputIter2, class _Compare>
+bool includes(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2, _Compare __comp);
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result);
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+ class _Compare>
+_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result, _Compare __comp);
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result);
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+ class _Compare>
+_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result, _Compare __comp);
+
+
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result);
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+ class _Compare>
+_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result, _Compare __comp);
+
+template <class _InputIter1, class _InputIter2, class _OutputIter>
+_OutputIter
+set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result);
+
+
+template <class _InputIter1, class _InputIter2, class _OutputIter,
+ class _Compare>
+_OutputIter
+set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _OutputIter __result,
+ _Compare __comp);
+
+
+// min_element and max_element, with and without an explicitly supplied
+// comparison function.
+
+template <class _ForwardIter>
+_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last);
+template <class _ForwardIter, class _Compare>
+_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last,
+ _Compare __comp);
+
+template <class _ForwardIter>
+_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last);
+
+template <class _ForwardIter, class _Compare>
+_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last,
+ _Compare __comp);
+
+// next_permutation and prev_permutation, with and without an explicitly
+// supplied comparison function.
+
+template <class _BidirectionalIter>
+bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last);
+
+template <class _BidirectionalIter, class _Compare>
+bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
+ _Compare __comp);
+
+
+template <class _BidirectionalIter>
+bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last);
+
+
+template <class _BidirectionalIter, class _Compare>
+bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
+ _Compare __comp);
+
+#if !defined (_STLP_NO_EXTENSIONS)
+// is_heap, a predicate testing whether or not a range is
+// a heap. This function is an extension, not part of the C++
+// standard.
+
+template <class _RandomAccessIter>
+bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last);
+
+template <class _RandomAccessIter, class _StrictWeakOrdering>
+bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last,
+ _StrictWeakOrdering __comp);
+
+// is_sorted, a predicated testing whether a range is sorted in
+// nondescending order. This is an extension, not part of the C++
+// standard.
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _StrictWeakOrdering>
+bool __is_sorted(_ForwardIter __first, _ForwardIter __last,
+ _StrictWeakOrdering __comp);
+
+_STLP_MOVE_TO_STD_NAMESPACE
+template <class _ForwardIter>
+inline bool is_sorted(_ForwardIter __first, _ForwardIter __last) {
+ return _STLP_PRIV __is_sorted(__first, __last,
+ _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _ForwardIter)));
+}
+
+template <class _ForwardIter, class _StrictWeakOrdering>
+inline bool is_sorted(_ForwardIter __first, _ForwardIter __last,
+ _StrictWeakOrdering __comp) {
+ return _STLP_PRIV __is_sorted(__first, __last, __comp);
+}
+#endif
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_algo.c>
+#endif
+
+#endif /* _STLP_INTERNAL_ALGO_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/stl/_algobase.c b/sources/android/stlport/stlport/stl/_algobase.c
new file mode 100644
index 0000000..157e25c
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_algobase.c
@@ -0,0 +1,483 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_ALGOBASE_C
+#define _STLP_ALGOBASE_C
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+# include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+# include <stl/_function_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _InputIter1, class _InputIter2>
+bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+ for ( ; __first1 != __last1 && __first2 != __last2
+ ; ++__first1, ++__first2) {
+ if (*__first1 < *__first2) {
+ _STLP_VERBOSE_ASSERT(!(*__first2 < *__first1), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ return true;
+ }
+ if (*__first2 < *__first1)
+ return false;
+ }
+ return __first1 == __last1 && __first2 != __last2;
+}
+
+template <class _InputIter1, class _InputIter2, class _Compare>
+bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _Compare __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+ for ( ; __first1 != __last1 && __first2 != __last2
+ ; ++__first1, ++__first2) {
+ if (__comp(*__first1, *__first2)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__first2, *__first1),
+ _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ return true;
+ }
+ if (__comp(*__first2, *__first1))
+ return false;
+ }
+ return __first1 == __last1 && __first2 != __last2;
+}
+
+#if !defined (_STLP_NO_EXTENSIONS)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter1, class _InputIter2>
+int __lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2) {
+ while (__first1 != __last1 && __first2 != __last2) {
+ if (*__first1 < *__first2) {
+ _STLP_VERBOSE_ASSERT(!(*__first2 < *__first1), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ return -1;
+ }
+ if (*__first2 < *__first1)
+ return 1;
+ ++__first1;
+ ++__first2;
+ }
+ if (__first2 == __last2) {
+ return !(__first1 == __last1);
+ }
+ else {
+ return -1;
+ }
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter1, class _InputIter2>
+int lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+ return _STLP_PRIV __lexicographical_compare_3way(__first1, __last1, __first2, __last2);
+}
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _RandomAccessIter, class _Tp>
+_STLP_INLINE_LOOP _RandomAccessIter __find(_RandomAccessIter __first, _RandomAccessIter __last,
+ const _Tp& __val,
+ const random_access_iterator_tag &) {
+ _STLP_DIFFERENCE_TYPE(_RandomAccessIter) __trip_count = (__last - __first) >> 2;
+
+ for ( ; __trip_count > 0 ; --__trip_count) {
+ if (*__first == __val) return __first;
+ ++__first;
+
+ if (*__first == __val) return __first;
+ ++__first;
+
+ if (*__first == __val) return __first;
+ ++__first;
+
+ if (*__first == __val) return __first;
+ ++__first;
+ }
+
+ switch (__last - __first) {
+ case 3:
+ if (*__first == __val) return __first;
+ ++__first;
+ case 2:
+ if (*__first == __val) return __first;
+ ++__first;
+ case 1:
+ if (*__first == __val) return __first;
+ //++__first;
+ case 0:
+ default:
+ return __last;
+ }
+}
+
+inline char*
+__find(char* __first, char* __last, char __val, const random_access_iterator_tag &) {
+ void *res = memchr(__first, __val, __last - __first);
+ return res != 0 ? __STATIC_CAST(char*, res) : __last;
+}
+inline const char*
+__find(const char* __first, const char* __last, char __val, const random_access_iterator_tag &) {
+ const void *res = memchr(__first, __val, __last - __first);
+ return res != 0 ? __STATIC_CAST(const char*, res) : __last;
+}
+
+template <class _RandomAccessIter, class _Predicate>
+_STLP_INLINE_LOOP _RandomAccessIter __find_if(_RandomAccessIter __first, _RandomAccessIter __last,
+ _Predicate __pred,
+ const random_access_iterator_tag &) {
+ _STLP_DIFFERENCE_TYPE(_RandomAccessIter) __trip_count = (__last - __first) >> 2;
+
+ for ( ; __trip_count > 0 ; --__trip_count) {
+ if (__pred(*__first)) return __first;
+ ++__first;
+
+ if (__pred(*__first)) return __first;
+ ++__first;
+
+ if (__pred(*__first)) return __first;
+ ++__first;
+
+ if (__pred(*__first)) return __first;
+ ++__first;
+ }
+
+ switch(__last - __first) {
+ case 3:
+ if (__pred(*__first)) return __first;
+ ++__first;
+ case 2:
+ if (__pred(*__first)) return __first;
+ ++__first;
+ case 1:
+ if (__pred(*__first)) return __first;
+ //++__first;
+ case 0:
+ default:
+ return __last;
+ }
+}
+
+template <class _InputIter, class _Tp>
+_STLP_INLINE_LOOP _InputIter __find(_InputIter __first, _InputIter __last,
+ const _Tp& __val,
+ const input_iterator_tag &) {
+ while (__first != __last && !(*__first == __val)) ++__first;
+ return __first;
+}
+
+template <class _InputIter, class _Predicate>
+_STLP_INLINE_LOOP _InputIter __find_if(_InputIter __first, _InputIter __last,
+ _Predicate __pred,
+ const input_iterator_tag &) {
+ while (__first != __last && !__pred(*__first))
+ ++__first;
+ return __first;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter, class _Predicate>
+_InputIter find_if(_InputIter __first, _InputIter __last,
+ _Predicate __pred) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ return _STLP_PRIV __find_if(__first, __last, __pred, _STLP_ITERATOR_CATEGORY(__first, _InputIter));
+}
+
+template <class _InputIter, class _Tp>
+_InputIter find(_InputIter __first, _InputIter __last, const _Tp& __val) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ return _STLP_PRIV __find(__first, __last, __val, _STLP_ITERATOR_CATEGORY(__first, _InputIter));
+}
+
+template <class _ForwardIter1, class _ForwardIter2, class _BinaryPred>
+_ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
+ _ForwardIter2 __first2, _ForwardIter2 __last2,
+ _BinaryPred __pred) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+ // Test for empty ranges
+ if (__first1 == __last1 || __first2 == __last2)
+ return __first1;
+
+ // Test for a pattern of length 1.
+ _ForwardIter2 __p1(__first2);
+
+ if ( ++__p1 == __last2 ) {
+ while (__first1 != __last1 && !__pred(*__first1, *__first2)) {
+ ++__first1;
+ }
+ return __first1;
+ }
+
+ // General case.
+
+ for ( ; ; ) { // __first1 != __last1 will be checked below
+ while (__first1 != __last1 && !__pred(*__first1, *__first2)) {
+ ++__first1;
+ }
+ if (__first1 == __last1) {
+ return __last1;
+ }
+ _ForwardIter2 __p = __p1;
+ _ForwardIter1 __current = __first1;
+ if (++__current == __last1) return __last1;
+
+ while (__pred(*__current, *__p)) {
+ if (++__p == __last2)
+ return __first1;
+ if (++__current == __last1)
+ return __last1;
+ }
+ ++__first1;
+ }
+ return __first1;
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+template <class _Tp>
+struct _IsCharLikeType
+{ typedef __false_type _Ret; };
+
+_STLP_TEMPLATE_NULL struct _IsCharLikeType<char>
+{ typedef __true_type _Ret; };
+
+_STLP_TEMPLATE_NULL struct _IsCharLikeType<unsigned char>
+{ typedef __true_type _Ret; };
+
+# ifndef _STLP_NO_SIGNED_BUILTINS
+_STLP_TEMPLATE_NULL struct _IsCharLikeType<signed char>
+{ typedef __true_type _Ret; };
+# endif
+
+template <class _Tp1, class _Tp2>
+inline bool __stlp_eq(_Tp1 __val1, _Tp2 __val2)
+{ return __val1 == __val2; }
+
+#if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+template <class _Tp>
+inline bool __stlp_eq(_Tp, _Tp)
+{ return true; }
+#endif
+
+template <class _InputIter, class _ForwardIter, class _Tp2, class _Predicate>
+inline _InputIter __find_first_of_aux2(_InputIter __first1, _InputIter __last1,
+ _ForwardIter __first2, _ForwardIter __last2,
+ _Tp2*, _Predicate __pred,
+ const __true_type& /* _UseStrcspnLikeAlgo */) {
+ unsigned char __hints[(UCHAR_MAX + 1) / CHAR_BIT];
+ memset(__hints, 0, sizeof(__hints) / sizeof(unsigned char));
+ for (; __first2 != __last2; ++__first2) {
+ unsigned char __tmp = (unsigned char)*__first2;
+ __hints[__tmp / CHAR_BIT] |= (1 << (__tmp % CHAR_BIT));
+ }
+
+ for (; __first1 != __last1; ++__first1) {
+ _Tp2 __tmp = (_Tp2)*__first1;
+ if (__stlp_eq(*__first1, __tmp) &&
+ __pred((__hints[(unsigned char)__tmp / CHAR_BIT] & (1 << ((unsigned char)__tmp % CHAR_BIT))) != 0))
+ break;
+ }
+ return __first1;
+}
+
+template <class _InputIter, class _ForwardIter, class _Tp2, class _Predicate>
+inline _InputIter __find_first_of_aux2(_InputIter __first1, _InputIter __last1,
+ _ForwardIter __first2, _ForwardIter __last2,
+ _Tp2* /* __dummy */, _Predicate /* __pred */,
+ const __false_type& /* _UseStrcspnLikeAlgo */) {
+ return _STLP_PRIV __find_first_of(__first1, __last1, __first2, __last2,
+ _STLP_PRIV __equal_to(_STLP_VALUE_TYPE(__first1, _InputIter)));
+}
+
+template <class _InputIter, class _ForwardIter, class _Tp1, class _Tp2>
+inline _InputIter __find_first_of_aux1(_InputIter __first1, _InputIter __last1,
+ _ForwardIter __first2, _ForwardIter __last2,
+ _Tp1* __pt1, _Tp2* __pt2) {
+ typedef _STLP_TYPENAME _STLP_STD::_IsIntegral<_Tp1>::_Ret _IsIntegral;
+ typedef _STLP_TYPENAME _STLP_PRIV _IsCharLikeType<_Tp2>::_Ret _IsCharLike;
+ typedef _STLP_TYPENAME _STLP_STD::_Land2<_IsIntegral, _IsCharLike>::_Ret _UseStrcspnLikeAlgo;
+ return _STLP_PRIV __find_first_of_aux2(__first1, __last1,
+ __first2, __last2,
+ __pt2, _Identity<bool>(), _UseStrcspnLikeAlgo());
+}
+
+template <class _InputIter, class _ForwardIter>
+inline _InputIter __find_first_of(_InputIter __first1, _InputIter __last1,
+ _ForwardIter __first2, _ForwardIter __last2) {
+ return _STLP_PRIV __find_first_of_aux1(__first1, __last1, __first2, __last2,
+ _STLP_VALUE_TYPE(__first1, _InputIter),
+ _STLP_VALUE_TYPE(__first2, _ForwardIter));
+}
+
+// find_first_of, with and without an explicitly supplied comparison function.
+template <class _InputIter, class _ForwardIter, class _BinaryPredicate>
+_InputIter __find_first_of(_InputIter __first1, _InputIter __last1,
+ _ForwardIter __first2, _ForwardIter __last2,
+ _BinaryPredicate __comp) {
+ for ( ; __first1 != __last1; ++__first1) {
+ for (_ForwardIter __iter = __first2; __iter != __last2; ++__iter) {
+ if (__comp(*__first1, *__iter)) {
+ return __first1;
+ }
+ }
+ }
+ return __last1;
+}
+
+// find_end, with and without an explicitly supplied comparison function.
+// Search [first2, last2) as a subsequence in [first1, last1), and return
+// the *last* possible match. Note that find_end for bidirectional iterators
+// is much faster than for forward iterators.
+
+// find_end for forward iterators.
+template <class _ForwardIter1, class _ForwardIter2,
+ class _BinaryPredicate>
+_ForwardIter1 __find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
+ _ForwardIter2 __first2, _ForwardIter2 __last2,
+ const forward_iterator_tag &, const forward_iterator_tag &,
+ _BinaryPredicate __comp) {
+ if (__first2 == __last2)
+ return __last1;
+ else {
+ _ForwardIter1 __result = __last1;
+ for (;;) {
+ _ForwardIter1 __new_result = _STLP_STD::search(__first1, __last1, __first2, __last2, __comp);
+ if (__new_result == __last1)
+ return __result;
+ else {
+ __result = __new_result;
+ __first1 = __new_result;
+ ++__first1;
+ }
+ }
+ }
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+// find_end for bidirectional iterators. Requires partial specialization.
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+
+# ifndef _STLP_INTERNAL_ITERATOR_H
+_STLP_END_NAMESPACE
+# include <stl/_iterator.h>
+_STLP_BEGIN_NAMESPACE
+# endif /*_STLP_INTERNAL_ITERATOR_H*/
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _BidirectionalIter1, class _BidirectionalIter2,
+ class _BinaryPredicate>
+_BidirectionalIter1
+__find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
+ _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
+ const bidirectional_iterator_tag &, const bidirectional_iterator_tag &,
+ _BinaryPredicate __comp) {
+ typedef _STLP_STD::reverse_iterator<_BidirectionalIter1> _RevIter1;
+ typedef _STLP_STD::reverse_iterator<_BidirectionalIter2> _RevIter2;
+
+ _RevIter1 __rlast1(__first1);
+ _RevIter2 __rlast2(__first2);
+ _RevIter1 __rresult = _STLP_STD::search(_RevIter1(__last1), __rlast1,
+ _RevIter2(__last2), __rlast2,
+ __comp);
+
+ if (__rresult == __rlast1)
+ return __last1;
+ else {
+ _BidirectionalIter1 __result = __rresult.base();
+ _STLP_STD::advance(__result, -_STLP_STD::distance(__first2, __last2));
+ return __result;
+ }
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+template <class _ForwardIter1, class _ForwardIter2,
+ class _BinaryPredicate>
+_ForwardIter1
+find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
+ _ForwardIter2 __first2, _ForwardIter2 __last2,
+ _BinaryPredicate __comp) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+ return _STLP_PRIV __find_end(__first1, __last1, __first2, __last2,
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ _STLP_ITERATOR_CATEGORY(__first1, _ForwardIter1),
+ _STLP_ITERATOR_CATEGORY(__first2, _ForwardIter2),
+#else
+ forward_iterator_tag(),
+ forward_iterator_tag(),
+#endif
+ __comp);
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _Tp, class _Compare1, class _Compare2, class _Distance>
+_ForwardIter __lower_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+ _Compare1 __comp1, _Compare2 __comp2, _Distance*) {
+ _Distance __len = _STLP_STD::distance(__first, __last);
+ _Distance __half;
+ _ForwardIter __middle;
+
+ while (__len > 0) {
+ __half = __len >> 1;
+ __middle = __first;
+ _STLP_STD::advance(__middle, __half);
+ if (__comp1(*__middle, __val)) {
+ _STLP_VERBOSE_ASSERT(!__comp2(__val, *__middle), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ __first = __middle;
+ ++__first;
+ __len = __len - __half - 1;
+ }
+ else
+ __len = __half;
+ }
+ return __first;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_ALGOBASE_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_algobase.h b/sources/android/stlport/stlport/stl/_algobase.h
new file mode 100644
index 0000000..597dcbe
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_algobase.h
@@ -0,0 +1,728 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+#define _STLP_INTERNAL_ALGOBASE_H
+
+#ifndef _STLP_INTERNAL_CSTDDEF
+# include <stl/_cstddef.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CSTRING
+# include <stl/_cstring.h>
+#endif
+
+#ifndef _STLP_CLIMITS
+# include <climits>
+#endif
+
+#ifndef _STLP_INTERNAL_CSTDLIB
+# include <stl/_cstdlib.h>
+#endif
+
+#ifndef _STLP_INTERNAL_PAIR_H
+# include <stl/_pair.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
+# include <stl/_iterator_base.h>
+#endif
+
+#ifndef _STLP_TYPE_TRAITS_H
+# include <stl/type_traits.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+template <class _Tp>
+inline void __swap_aux(_Tp& __a, _Tp& __b, const __true_type& /*SwapImplemented*/) {
+ __a._M_swap_workaround(__b);
+}
+
+template <class _Tp>
+inline void __swap_aux(_Tp& __a, _Tp& __b, const __false_type& /*SwapImplemented*/) {
+ _Tp __tmp = __a;
+ __a = __b;
+ __b = __tmp;
+}
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+// swap and iter_swap
+template <class _Tp>
+inline void swap(_Tp& __a, _Tp& __b) {
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+# if !defined(__BORLANDC__)
+ typedef typename _SwapImplemented<_Tp>::_Ret _Implemented;
+# else
+ enum { _Is = _SwapImplemented<_Tp>::_Is };
+ typedef typename __bool2type<_Is>::_Ret _Implemented;
+# endif
+ _STLP_PRIV __swap_aux(__a, __b, _Implemented());
+#else
+ _Tp __tmp = __a;
+ __a = __b;
+ __b = __tmp;
+#endif
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter1, class _ForwardIter2, class _Value>
+inline void __iter_swap_aux_aux(_ForwardIter1& __i1, _ForwardIter2& __i2, _Value *) {
+ _Value tmp = *__i1;
+ *__i1 = *__i2;
+ *__i2 = tmp;
+}
+
+template <class _ForwardIter1, class _ForwardIter2>
+inline void __iter_swap_aux(_ForwardIter1& __i1, _ForwardIter2& __i2, const __true_type& /*OKToSwap*/) {
+ /* namespace specification breaks access to the right swap template overload (at least for gcc) */
+ /*_STLP_STD::*/ swap(*__i1, *__i2);
+}
+
+template <class _ForwardIter1, class _ForwardIter2>
+inline void __iter_swap_aux(_ForwardIter1& __i1, _ForwardIter2& __i2, const __false_type& /*OKToSwap*/) {
+ _STLP_PRIV __iter_swap_aux_aux( __i1, __i2, _STLP_VALUE_TYPE(__i1,_ForwardIter1) );
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _ForwardIter1, class _ForwardIter2>
+inline void iter_swap(_ForwardIter1 __i1, _ForwardIter2 __i2) {
+ _STLP_PRIV __iter_swap_aux( __i1, __i2, _IsOKToSwap(_STLP_VALUE_TYPE(__i1, _ForwardIter1), _STLP_VALUE_TYPE(__i2, _ForwardIter2),
+ _STLP_IS_REF_TYPE_REAL_REF(__i1, _ForwardIter1),
+ _STLP_IS_REF_TYPE_REAL_REF(__i2, _ForwardIter2))._Answer());
+}
+
+//--------------------------------------------------
+// min and max
+
+#if !defined (__BORLANDC__) || defined (_STLP_USE_OWN_NAMESPACE)
+# if (defined (__BORLANDC__) && (__BORLANDC__ < 0x580)) && !defined (__STDC__)
+//In not ANSI mode Borland import min/max in global namespace which conflict
+//with STLport min/max when user does a 'using namespace std' in its code
+//(see test/unit/alg_test.cpp). To avoid this clash we simply import Borland min/max
+//in STLport namespace.
+using _STLP_VENDOR_STD::min;
+using _STLP_VENDOR_STD::max;
+# else
+template <class _Tp>
+inline const _Tp& (min)(const _Tp& __a, const _Tp& __b) { return __b < __a ? __b : __a; }
+template <class _Tp>
+inline const _Tp& (max)(const _Tp& __a, const _Tp& __b) { return __a < __b ? __b : __a; }
+# endif
+#endif
+
+# if defined (__BORLANDC__) && defined (_STLP_USE_OWN_NAMESPACE)
+inline unsigned long (min) (unsigned long __a, unsigned long __b) { return __b < __a ? __b : __a; }
+inline unsigned long (max) (unsigned long __a, unsigned long __b) { return __a < __b ? __b : __a; }
+# endif
+
+# if !defined (__BORLANDC__) || (__BORLANDC__ < 0x590)
+template <class _Tp, class _Compare>
+inline const _Tp& (min)(const _Tp& __a, const _Tp& __b, _Compare __comp) {
+ return __comp(__b, __a) ? __b : __a;
+}
+
+template <class _Tp, class _Compare>
+inline const _Tp& (max)(const _Tp& __a, const _Tp& __b, _Compare __comp) {
+ return __comp(__a, __b) ? __b : __a;
+}
+# else
+template <class _Tp, class _Compare>
+inline const _Tp (min)(const _Tp __a, const _Tp __b, _Compare __comp) {
+ return __comp(__b, __a) ? __b : __a;
+}
+
+template <class _Tp, class _Compare>
+inline const _Tp (max)(const _Tp __a, const _Tp __b, _Compare __comp) {
+ return __comp(__a, __b) ? __b : __a;
+}
+# endif
+
+//--------------------------------------------------
+// copy
+
+// All of these auxiliary functions serve two purposes. (1) Replace
+// calls to copy with memmove whenever possible. (Memmove, not memcpy,
+// because the input and output ranges are permitted to overlap.)
+// (2) If we're using random access iterators, then write the loop as
+// a for loop with an explicit count.
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter, class _OutputIter, class _Distance>
+inline _OutputIter __copy(_InputIter __first, _InputIter __last,
+ _OutputIter __result, const input_iterator_tag &, _Distance*) {
+ for ( ; __first != __last; ++__result, ++__first)
+ *__result = *__first;
+ return __result;
+}
+
+#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
+template <class _InputIter, class _OutputIter, class _Distance>
+inline _OutputIter __copy(_InputIter __first, _InputIter __last,
+ _OutputIter __result, const forward_iterator_tag &, _Distance* ) {
+ for ( ; __first != __last; ++__result, ++__first)
+ *__result = *__first;
+ return __result;
+}
+
+template <class _InputIter, class _OutputIter, class _Distance>
+inline _OutputIter __copy(_InputIter __first, _InputIter __last,
+ _OutputIter __result, const bidirectional_iterator_tag &, _Distance* ) {
+ for ( ; __first != __last; ++__result, ++__first)
+ *__result = *__first;
+ return __result;
+}
+#endif
+
+template <class _RandomAccessIter, class _OutputIter, class _Distance>
+inline _OutputIter
+__copy(_RandomAccessIter __first, _RandomAccessIter __last,
+ _OutputIter __result, const random_access_iterator_tag &, _Distance*) {
+ for (_Distance __n = __last - __first; __n > 0; --__n) {
+ *__result = *__first;
+ ++__first;
+ ++__result;
+ }
+ return __result;
+}
+
+inline void*
+__copy_trivial(const void* __first, const void* __last, void* __result) {
+ size_t __n = (const char*)__last - (const char*)__first;
+ return __n ? (void *)((char*)memmove(__result, __first, __n) + __n) : __result;
+}
+
+//--------------------------------------------------
+// copy_backward auxiliary functions
+
+template <class _BidirectionalIter1, class _BidirectionalIter2,
+ class _Distance>
+inline _BidirectionalIter2 __copy_backward(_BidirectionalIter1 __first,
+ _BidirectionalIter1 __last,
+ _BidirectionalIter2 __result,
+ const bidirectional_iterator_tag &,
+ _Distance*) {
+ while (__first != __last)
+ *--__result = *--__last;
+ return __result;
+}
+
+template <class _RandomAccessIter, class _BidirectionalIter, class _Distance>
+inline _BidirectionalIter __copy_backward(_RandomAccessIter __first,
+ _RandomAccessIter __last,
+ _BidirectionalIter __result,
+ const random_access_iterator_tag &,
+ _Distance*) {
+ for (_Distance __n = __last - __first; __n > 0; --__n)
+ *--__result = *--__last;
+ return __result;
+}
+
+inline void*
+__copy_trivial_backward(const void* __first, const void* __last, void* __result) {
+ const ptrdiff_t _Num = (const char*)__last - (const char*)__first;
+ return (_Num > 0) ? memmove((char*)__result - _Num, __first, _Num) : __result ;
+}
+
+template <class _InputIter, class _OutputIter>
+inline _OutputIter __copy_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result,
+ const __false_type& /*IsOKToMemCpy*/) {
+ return _STLP_PRIV __copy(__first, __last, __result, random_access_iterator_tag(), (ptrdiff_t*)0);
+}
+template <class _InputIter, class _OutputIter>
+inline _OutputIter __copy_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result,
+ const __true_type& /*IsOKToMemCpy*/) {
+ // we know they all pointers, so this cast is OK
+ // return (_OutputIter)__copy_trivial(&(*__first), &(*__last), &(*__result));
+ return (_OutputIter)_STLP_PRIV __copy_trivial(__first, __last, __result);
+}
+
+template <class _InputIter, class _OutputIter>
+inline _OutputIter __copy_aux(_InputIter __first, _InputIter __last, _OutputIter __result,
+ const __true_type& /*BothPtrType*/) {
+ return _STLP_PRIV __copy_ptrs(__first, __last, __result,
+ _UseTrivialCopy(_STLP_VALUE_TYPE(__first, _InputIter),
+ _STLP_VALUE_TYPE(__result, _OutputIter))._Answer());
+}
+
+template <class _InputIter, class _OutputIter>
+inline _OutputIter __copy_aux(_InputIter __first, _InputIter __last, _OutputIter __result,
+ const __false_type& /*BothPtrType*/) {
+ return _STLP_PRIV __copy(__first, __last, __result,
+ _STLP_ITERATOR_CATEGORY(__first, _InputIter),
+ _STLP_DISTANCE_TYPE(__first, _InputIter));
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter, class _OutputIter>
+inline _OutputIter copy(_InputIter __first, _InputIter __last, _OutputIter __result) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ return _STLP_PRIV __copy_aux(__first, __last, __result, _BothPtrType< _InputIter, _OutputIter>::_Answer());
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter, class _OutputIter>
+inline _OutputIter __copy_backward_ptrs(_InputIter __first, _InputIter __last,
+ _OutputIter __result, const __false_type& /*TrivialAssignment*/) {
+ return _STLP_PRIV __copy_backward(__first, __last, __result,
+ _STLP_ITERATOR_CATEGORY(__first, _InputIter),
+ _STLP_DISTANCE_TYPE(__first, _InputIter));
+}
+template <class _InputIter, class _OutputIter>
+inline _OutputIter __copy_backward_ptrs(_InputIter __first, _InputIter __last,
+ _OutputIter __result, const __true_type& /*TrivialAssignment*/) {
+ return (_OutputIter)_STLP_PRIV __copy_trivial_backward(__first, __last, __result);
+}
+
+template <class _InputIter, class _OutputIter>
+inline _OutputIter __copy_backward_aux(_InputIter __first, _InputIter __last, _OutputIter __result, const __false_type&) {
+ return _STLP_PRIV __copy_backward(__first, __last, __result,
+ _STLP_ITERATOR_CATEGORY(__first,_InputIter),
+ _STLP_DISTANCE_TYPE(__first, _InputIter));
+}
+
+template <class _InputIter, class _OutputIter>
+inline _OutputIter __copy_backward_aux(_InputIter __first, _InputIter __last, _OutputIter __result, const __true_type&) {
+ return _STLP_PRIV __copy_backward_ptrs(__first, __last, __result,
+ _UseTrivialCopy(_STLP_VALUE_TYPE(__first, _InputIter),
+ _STLP_VALUE_TYPE(__result, _OutputIter))._Answer());
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter, class _OutputIter>
+inline _OutputIter copy_backward(_InputIter __first, _InputIter __last, _OutputIter __result) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ return _STLP_PRIV __copy_backward_aux(__first, __last, __result, _BothPtrType< _InputIter, _OutputIter>::_Answer() );
+}
+
+#if !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS)
+# define _STLP_DECLARE_COPY_TRIVIAL(_Tp) \
+inline _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) \
+{ return (_Tp*)_STLP_PRIV __copy_trivial(__first, __last, __result); } \
+inline _Tp* copy_backward(const _Tp* __first, const _Tp* __last, _Tp* __result) \
+{ return (_Tp*)_STLP_PRIV __copy_trivial_backward(__first, __last, __result); }
+
+# if !defined (_STLP_NO_BOOL)
+_STLP_DECLARE_COPY_TRIVIAL(bool)
+# endif
+_STLP_DECLARE_COPY_TRIVIAL(char)
+# if !defined (_STLP_NO_SIGNED_BUILTINS)
+_STLP_DECLARE_COPY_TRIVIAL(signed char)
+# endif
+_STLP_DECLARE_COPY_TRIVIAL(unsigned char)
+_STLP_DECLARE_COPY_TRIVIAL(short)
+_STLP_DECLARE_COPY_TRIVIAL(unsigned short)
+_STLP_DECLARE_COPY_TRIVIAL(int)
+_STLP_DECLARE_COPY_TRIVIAL(unsigned int)
+_STLP_DECLARE_COPY_TRIVIAL(long)
+_STLP_DECLARE_COPY_TRIVIAL(unsigned long)
+# if !defined(_STLP_NO_WCHAR_T) && !defined (_STLP_WCHAR_T_IS_USHORT)
+_STLP_DECLARE_COPY_TRIVIAL(wchar_t)
+# endif
+# if defined (_STLP_LONG_LONG)
+_STLP_DECLARE_COPY_TRIVIAL(_STLP_LONG_LONG)
+_STLP_DECLARE_COPY_TRIVIAL(unsigned _STLP_LONG_LONG)
+# endif
+_STLP_DECLARE_COPY_TRIVIAL(float)
+_STLP_DECLARE_COPY_TRIVIAL(double)
+# if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_DECLARE_COPY_TRIVIAL(long double)
+# endif
+# undef _STLP_DECLARE_COPY_TRIVIAL
+#endif
+
+//--------------------------------------------------
+// copy_n (not part of the C++ standard)
+
+#if !defined (_STLP_NO_EXTENSIONS)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter, class _Size, class _OutputIter>
+_STLP_INLINE_LOOP _STLP_STD::pair<_InputIter, _OutputIter>
+__copy_n(_InputIter __first, _Size __count, _OutputIter __result,
+ const input_iterator_tag &) {
+ for ( ; __count > 0; --__count) {
+ *__result = *__first;
+ ++__first;
+ ++__result;
+ }
+ return _STLP_STD::pair<_InputIter, _OutputIter>(__first, __result);
+}
+
+template <class _RAIter, class _Size, class _OutputIter>
+inline _STLP_STD::pair<_RAIter, _OutputIter>
+__copy_n(_RAIter __first, _Size __count, _OutputIter __result,
+ const random_access_iterator_tag &) {
+ _RAIter __last = __first + __count;
+ return _STLP_STD::pair<_RAIter, _OutputIter>(__last, _STLP_STD::copy(__first, __last, __result));
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter, class _Size, class _OutputIter>
+inline pair<_InputIter, _OutputIter>
+copy_n(_InputIter __first, _Size __count, _OutputIter __result) {
+ _STLP_FIX_LITERAL_BUG(__first)
+ return _STLP_PRIV __copy_n(__first, __count, __result, _STLP_ITERATOR_CATEGORY(__first, _InputIter));
+}
+#endif
+
+//--------------------------------------------------
+// fill and fill_n
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _Tp>
+_STLP_INLINE_LOOP
+void __fill_fwd(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) {
+ for ( ; __first != __last; ++__first)
+ *__first = __val;
+}
+
+template <class _ForwardIter, class _Tp, class _Distance>
+inline void __fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+ const input_iterator_tag &, _Distance*) {
+ _STLP_PRIV __fill_fwd(__first, __last, __val);
+}
+
+#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
+template <class _ForwardIter, class _Tp, class _Distance>
+_STLP_INLINE_LOOP
+void __fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+ const forward_iterator_tag &, _Distance*) {
+ _STLP_PRIV __fill_fwd(__first, __last, __val);
+}
+
+template <class _ForwardIter, class _Tp, class _Distance>
+_STLP_INLINE_LOOP
+void __fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
+ const bidirectional_iterator_tag &, _Distance*) {
+ _STLP_PRIV __fill_fwd(__first, __last, __val);
+}
+#endif
+
+template <class _RandomAccessIter, class _Tp, class _Distance>
+_STLP_INLINE_LOOP
+void __fill(_RandomAccessIter __first, _RandomAccessIter __last, const _Tp& __val,
+ const random_access_iterator_tag &, _Distance*) {
+ for (_Distance __n = __last - __first ; __n > 0; ++__first, --__n)
+ *__first = __val;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _ForwardIter, class _Tp>
+inline void fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _STLP_PRIV __fill(__first, __last, __val,
+ _STLP_ITERATOR_CATEGORY(__first, _ForwardIter),
+ _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+}
+
+// Specialization: for one-byte types we can use memset.
+inline void fill(unsigned char* __first, unsigned char* __last,
+ const unsigned char& __val) {
+ unsigned char __tmp = __val;
+ memset(__first, __tmp, __last - __first);
+}
+#if !defined (_STLP_NO_SIGNED_BUILTINS)
+inline void fill(signed char* __first, signed char* __last,
+ const signed char& __val) {
+ signed char __tmp = __val;
+ memset(__first, __STATIC_CAST(unsigned char,__tmp), __last - __first);
+}
+#endif
+inline void fill(char* __first, char* __last, const char& __val) {
+ char __tmp = __val;
+ memset(__first, __STATIC_CAST(unsigned char,__tmp), __last - __first);
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _OutputIter, class _Size, class _Tp>
+_STLP_INLINE_LOOP
+_OutputIter __fill_n(_OutputIter __first, _Size __n, const _Tp& __val) {
+ _STLP_FIX_LITERAL_BUG(__first)
+ for ( ; __n > 0; --__n, ++__first)
+ *__first = __val;
+ return __first;
+}
+
+#if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+template <class _Size>
+inline unsigned char* __fill_n(unsigned char* __first, _Size __n,
+ const unsigned char& __val) {
+ _STLP_STD::fill(__first, __first + __n, __val);
+ return __first + __n;
+}
+#if !defined (_STLP_NO_SIGNED_BUILTINS)
+template <class _Size>
+inline signed char* __fill_n(signed char* __first, _Size __n,
+ const signed char& __val) {
+ _STLP_STD::fill(__first, __first + __n, __val);
+ return __first + __n;
+}
+#endif
+template <class _Size>
+inline char* __fill_n(char* __first, _Size __n,
+ const char& __val) {
+ _STLP_STD::fill(__first, __first + __n, __val);
+ return __first + __n;
+}
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _OutputIter, class _Size, class _Tp>
+inline void fill_n(_OutputIter __first, _Size __n, const _Tp& __val) {
+ _STLP_FIX_LITERAL_BUG(__first)
+ _STLP_PRIV __fill_n(__first, __n, __val);
+}
+
+
+//--------------------------------------------------
+// equal and mismatch
+
+template <class _InputIter1, class _InputIter2>
+_STLP_INLINE_LOOP
+_STLP_STD::pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1,
+ _InputIter1 __last1,
+ _InputIter2 __first2) {
+ _STLP_FIX_LITERAL_BUG(__first2)
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ while (__first1 != __last1 && *__first1 == *__first2) {
+ ++__first1;
+ ++__first2;
+ }
+ return _STLP_STD::pair<_InputIter1, _InputIter2>(__first1, __first2);
+}
+
+template <class _InputIter1, class _InputIter2, class _BinaryPredicate>
+_STLP_INLINE_LOOP
+_STLP_STD::pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1,
+ _InputIter1 __last1,
+ _InputIter2 __first2,
+ _BinaryPredicate __binary_pred) {
+ _STLP_FIX_LITERAL_BUG(__first2)
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ while (__first1 != __last1 && __binary_pred(*__first1, *__first2)) {
+ ++__first1;
+ ++__first2;
+ }
+ return _STLP_STD::pair<_InputIter1, _InputIter2>(__first1, __first2);
+}
+
+template <class _InputIter1, class _InputIter2>
+_STLP_INLINE_LOOP
+bool equal(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2) {
+ _STLP_FIX_LITERAL_BUG(__first1) _STLP_FIX_LITERAL_BUG(__last1) _STLP_FIX_LITERAL_BUG(__first2)
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ for ( ; __first1 != __last1; ++__first1, ++__first2)
+ if (!(*__first1 == *__first2))
+ return false;
+ return true;
+}
+
+template <class _InputIter1, class _InputIter2, class _BinaryPredicate>
+_STLP_INLINE_LOOP
+bool equal(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _BinaryPredicate __binary_pred) {
+ _STLP_FIX_LITERAL_BUG(__first2)
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ for ( ; __first1 != __last1; ++__first1, ++__first2)
+ if (!__binary_pred(*__first1, *__first2))
+ return false;
+ return true;
+}
+
+//--------------------------------------------------
+// lexicographical_compare and lexicographical_compare_3way.
+// (the latter is not part of the C++ standard.)
+
+template <class _InputIter1, class _InputIter2>
+bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2);
+
+template <class _InputIter1, class _InputIter2, class _Compare>
+bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _Compare __comp);
+
+inline bool
+lexicographical_compare(const unsigned char* __first1,
+ const unsigned char* __last1,
+ const unsigned char* __first2,
+ const unsigned char* __last2) {
+ const size_t __len1 = __last1 - __first1;
+ const size_t __len2 = __last2 - __first2;
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+
+ const int __result = memcmp(__first1, __first2, (min) (__len1, __len2));
+ return __result != 0 ? (__result < 0) : (__len1 < __len2);
+}
+
+
+#if !(CHAR_MAX == SCHAR_MAX)
+inline bool lexicographical_compare(const char* __first1, const char* __last1,
+ const char* __first2, const char* __last2) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))
+
+ return lexicographical_compare((const unsigned char*) __first1,
+ (const unsigned char*) __last1,
+ (const unsigned char*) __first2,
+ (const unsigned char*) __last2);
+}
+#endif /* CHAR_MAX == SCHAR_MAX */
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter1, class _InputIter2>
+int __lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2);
+
+inline int
+__lexicographical_compare_3way(const unsigned char* __first1,
+ const unsigned char* __last1,
+ const unsigned char* __first2,
+ const unsigned char* __last2) {
+ const ptrdiff_t __len1 = __last1 - __first1;
+ const ptrdiff_t __len2 = __last2 - __first2;
+ const int __result = memcmp(__first1, __first2, (min) (__len1, __len2));
+ return __result != 0 ? __result
+ : (__len1 == __len2 ? 0 : (__len1 < __len2 ? -1 : 1));
+}
+
+
+#if !(CHAR_MAX == SCHAR_MAX)
+inline int
+__lexicographical_compare_3way(const char* __first1, const char* __last1,
+ const char* __first2, const char* __last2) {
+ return __lexicographical_compare_3way((const unsigned char*) __first1,
+ (const unsigned char*) __last1,
+ (const unsigned char*) __first2,
+ (const unsigned char*) __last2);
+}
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#if !defined (_STLP_NO_EXTENSIONS)
+template <class _InputIter1, class _InputIter2>
+int lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2);
+
+#endif
+
+// count
+template <class _InputIter, class _Tp>
+_STLP_INLINE_LOOP _STLP_DIFFERENCE_TYPE(_InputIter)
+count(_InputIter __first, _InputIter __last, const _Tp& __val) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _STLP_DIFFERENCE_TYPE(_InputIter) __n = 0;
+ for ( ; __first != __last; ++__first)
+ if (*__first == __val)
+ ++__n;
+ return __n;
+}
+
+// find and find_if. Note find may be expressed in terms of find_if if appropriate binder was available.
+template <class _InputIter, class _Tp>
+_InputIter find(_InputIter __first, _InputIter __last, const _Tp& __val);
+
+template <class _InputIter, class _Predicate>
+_InputIter find_if(_InputIter __first, _InputIter __last, _Predicate __pred);
+
+// search.
+template <class _ForwardIter1, class _ForwardIter2, class _BinaryPred>
+_ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
+ _ForwardIter2 __first2, _ForwardIter2 __last2, _BinaryPred __predicate);
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// find_first_of
+template <class _InputIter, class _ForwardIter>
+_InputIter __find_first_of(_InputIter __first1, _InputIter __last1,
+ _ForwardIter __first2, _ForwardIter __last2);
+
+template <class _InputIter, class _ForwardIter, class _BinaryPredicate>
+_InputIter __find_first_of(_InputIter __first1, _InputIter __last1,
+ _ForwardIter __first2, _ForwardIter __last2,
+ _BinaryPredicate __comp);
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _ForwardIter1, class _ForwardIter2,
+ class _BinaryPredicate>
+_ForwardIter1
+find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
+ _ForwardIter2 __first2, _ForwardIter2 __last2,
+ _BinaryPredicate __comp);
+
+// replace
+template <class _ForwardIter, class _Tp>
+_STLP_INLINE_LOOP void
+replace(_ForwardIter __first, _ForwardIter __last,
+ const _Tp& __old_value, const _Tp& __new_value) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ for ( ; __first != __last; ++__first)
+ if (*__first == __old_value)
+ *__first = __new_value;
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _Tp, class _Compare1, class _Compare2, class _Distance>
+_ForwardIter __lower_bound(_ForwardIter __first, _ForwardIter __last,
+ const _Tp& __val, _Compare1 __comp1, _Compare2 __comp2, _Distance*);
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_algobase.c>
+#endif
+
+#endif /* _STLP_INTERNAL_ALGOBASE_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/stl/_alloc.c b/sources/android/stlport/stlport/stl/_alloc.c
new file mode 100644
index 0000000..467405b
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_alloc.c
@@ -0,0 +1,87 @@
+/*
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_ALLOC_C
+#define _STLP_ALLOC_C
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+# include <stl/_alloc.h>
+#endif
+
+#if defined (__WATCOMC__)
+# pragma warning 13 9
+# pragma warning 367 9
+# pragma warning 368 9
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Alloc>
+void * _STLP_CALL __debug_alloc<_Alloc>::allocate(size_t __n) {
+ size_t __total_extra = __extra_before_chunk() + __extra_after_chunk();
+ size_t __real_n = __n + __total_extra;
+ if (__real_n < __n) {
+ //It means that we rolled on size_t, __n must be very large:
+ _STLP_THROW_BAD_ALLOC;
+ }
+ __alloc_header *__result = (__alloc_header *)__allocator_type::allocate(__real_n);
+ memset((char*)__result, __shred_byte, __real_n * sizeof(value_type));
+ __result->__magic = __magic;
+ __result->__type_size = sizeof(value_type);
+ __result->_M_size = (_STLP_UINT32_T)__n;
+ return ((char*)__result) + (long)__extra_before;
+}
+
+template <class _Alloc>
+void _STLP_CALL
+__debug_alloc<_Alloc>::deallocate(void *__p, size_t __n) {
+ __alloc_header * __real_p = (__alloc_header*)((char *)__p -(long)__extra_before);
+ // check integrity
+ _STLP_VERBOSE_ASSERT(__real_p->__magic != __deleted_magic, _StlMsg_DBA_DELETED_TWICE)
+ _STLP_VERBOSE_ASSERT(__real_p->__magic == __magic, _StlMsg_DBA_NEVER_ALLOCATED)
+ _STLP_VERBOSE_ASSERT(__real_p->__type_size == 1,_StlMsg_DBA_TYPE_MISMATCH)
+ _STLP_VERBOSE_ASSERT(__real_p->_M_size == __n, _StlMsg_DBA_SIZE_MISMATCH)
+ // check pads on both sides
+ unsigned char* __tmp;
+ for (__tmp = (unsigned char*)(__real_p + 1); __tmp < (unsigned char*)__p; ++__tmp) {
+ _STLP_VERBOSE_ASSERT(*__tmp == __shred_byte, _StlMsg_DBA_UNDERRUN)
+ }
+
+ size_t __real_n = __n + __extra_before_chunk() + __extra_after_chunk();
+
+ for (__tmp= ((unsigned char*)__p) + __n * sizeof(value_type);
+ __tmp < ((unsigned char*)__real_p) + __real_n ; ++__tmp) {
+ _STLP_VERBOSE_ASSERT(*__tmp == __shred_byte, _StlMsg_DBA_OVERRUN)
+ }
+
+ // that may be unfortunate, just in case
+ __real_p->__magic = __deleted_magic;
+ memset((char*)__p, __shred_byte, __n * sizeof(value_type));
+ __allocator_type::deallocate(__real_p, __real_n);
+}
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_ALLOC_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_alloc.h b/sources/android/stlport/stlport/stl/_alloc.h
new file mode 100644
index 0000000..09b8af5
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_alloc.h
@@ -0,0 +1,580 @@
+/*
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+#define _STLP_INTERNAL_ALLOC_H
+
+#ifndef _STLP_INTERNAL_CSTDDEF
+# include <stl/_cstddef.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CSTDLIB
+# include <stl/_cstdlib.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CSTRING
+# include <stl/_cstring.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+# include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_NEW_HEADER
+# include <stl/_new.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CONSTRUCT_H
+# include <stl/_construct.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+// Malloc-based allocator. Typically slower than default alloc below.
+// Typically thread-safe and more storage efficient.
+
+#if !defined (_STLP_USE_NO_IOSTREAMS)
+typedef void (* __oom_handler_type)();
+#endif
+
+class _STLP_CLASS_DECLSPEC __malloc_alloc {
+public:
+ // this one is needed for proper simple_alloc wrapping
+ typedef char value_type;
+ static void* _STLP_CALL allocate(size_t __n)
+#if !defined (_STLP_USE_NO_IOSTREAMS)
+ ;
+#else
+ {
+ void *__result = malloc(__n);
+ if (__result == 0) {
+ _STLP_THROW_BAD_ALLOC;
+ }
+ return __result;
+ }
+#endif
+
+ static void _STLP_CALL deallocate(void* __p, size_t /* __n */) { free((char*)__p); }
+#if !defined (_STLP_USE_NO_IOSTREAMS)
+ static __oom_handler_type _STLP_CALL set_malloc_handler(__oom_handler_type __f);
+#endif
+};
+
+// New-based allocator. Typically slower than default alloc below.
+// Typically thread-safe and more storage efficient.
+class _STLP_CLASS_DECLSPEC __new_alloc {
+public:
+ // this one is needed for proper simple_alloc wrapping
+ typedef char value_type;
+ static void* _STLP_CALL allocate(size_t __n) { return __stl_new(__n); }
+ static void _STLP_CALL deallocate(void* __p, size_t) { __stl_delete(__p); }
+};
+
+// Allocator adaptor to check size arguments for debugging.
+// Reports errors using assert. Checking can be disabled with
+// NDEBUG, but it's far better to just use the underlying allocator
+// instead when no checking is desired.
+// There is some evidence that this can confuse Purify.
+// This adaptor can only be applied to raw allocators
+
+template <class _Alloc>
+class __debug_alloc : public _Alloc {
+public:
+ typedef _Alloc __allocator_type;
+ typedef typename _Alloc::value_type value_type;
+private:
+ struct __alloc_header {
+ size_t __magic: 16;
+ size_t __type_size:16;
+ _STLP_UINT32_T _M_size;
+ }; // that is 8 bytes for sure
+ // Sunpro CC has bug on enums, so extra_before/after set explicitly
+ enum { __pad = 8, __magic = 0xdeba, __deleted_magic = 0xdebd,
+ __shred_byte = _STLP_SHRED_BYTE };
+
+ enum { __extra_before = 16, __extra_after = 8 };
+ // Size of space used to store size. Note
+ // that this must be large enough to preserve
+ // alignment.
+ static size_t _STLP_CALL __extra_before_chunk() {
+ return (long)__extra_before / sizeof(value_type) +
+ (size_t)((long)__extra_before % sizeof(value_type) > 0);
+ }
+ static size_t _STLP_CALL __extra_after_chunk() {
+ return (long)__extra_after / sizeof(value_type) +
+ (size_t)((long)__extra_after % sizeof(value_type) > 0);
+ }
+public:
+ __debug_alloc() {}
+ ~__debug_alloc() {}
+ static void* _STLP_CALL allocate(size_t);
+ static void _STLP_CALL deallocate(void *, size_t);
+};
+
+# if defined (__OS400__)
+// dums 02/05/2007: is it really necessary ?
+enum { _MAX_BYTES = 256 };
+# else
+enum { _MAX_BYTES = 32 * sizeof(void*) };
+# endif
+
+#if !defined (_STLP_USE_NO_IOSTREAMS)
+// Default node allocator.
+// With a reasonable compiler, this should be roughly as fast as the
+// original STL class-specific allocators, but with less fragmentation.
+class _STLP_CLASS_DECLSPEC __node_alloc {
+ static void * _STLP_CALL _M_allocate(size_t& __n);
+ /* __p may not be 0 */
+ static void _STLP_CALL _M_deallocate(void *__p, size_t __n);
+
+public:
+ // this one is needed for proper simple_alloc wrapping
+ typedef char value_type;
+ /* __n must be > 0 */
+ static void* _STLP_CALL allocate(size_t& __n)
+ { return (__n > (size_t)_MAX_BYTES) ? __stl_new(__n) : _M_allocate(__n); }
+ /* __p may not be 0 */
+ static void _STLP_CALL deallocate(void *__p, size_t __n)
+ { if (__n > (size_t)_MAX_BYTES) __stl_delete(__p); else _M_deallocate(__p, __n); }
+};
+
+# if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS __debug_alloc<__node_alloc>;
+# endif
+
+#endif
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS __debug_alloc<__new_alloc>;
+_STLP_EXPORT_TEMPLATE_CLASS __debug_alloc<__malloc_alloc>;
+#endif
+
+/* macro to convert the allocator for initialization
+ * not using MEMBER_TEMPLATE_CLASSES as it should work given template constructor */
+#if defined (_STLP_MEMBER_TEMPLATES) || ! defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+/* if _STLP_NO_TEMPLATE_CONVERSIONS is set, the member template constructor is
+ * not used implicitly to convert allocator parameter, so let us do it explicitly */
+# if defined (_STLP_MEMBER_TEMPLATE_CLASSES) && defined (_STLP_NO_TEMPLATE_CONVERSIONS)
+# define _STLP_CONVERT_ALLOCATOR(__a, _Tp) __stl_alloc_create(__a,(_Tp*)0)
+# else
+# define _STLP_CONVERT_ALLOCATOR(__a, _Tp) __a
+# endif
+/* else convert, but only if partial specialization works, since else
+ * Container::allocator_type won't be different */
+#else
+# define _STLP_CONVERT_ALLOCATOR(__a, _Tp) __stl_alloc_create(__a,(_Tp*)0)
+#endif
+
+// Another allocator adaptor: _Alloc_traits. This serves two
+// purposes. First, make it possible to write containers that can use
+// either SGI-style allocators or standard-conforming allocator.
+
+// The fully general version.
+template <class _Tp, class _Allocator>
+struct _Alloc_traits {
+ typedef _Allocator _Orig;
+#if !defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)
+ typedef typename _Allocator::_STLP_TEMPLATE rebind<_Tp> _Rebind_type;
+ typedef typename _Rebind_type::other allocator_type;
+ static allocator_type create_allocator(const _Orig& __a)
+ { return allocator_type(_STLP_CONVERT_ALLOCATOR(__a, _Tp)); }
+#else
+ // this is not actually true, used only to pass this type through
+ // to dynamic overload selection in _STLP_alloc_proxy methods
+ typedef _Allocator allocator_type;
+#endif
+};
+
+#if defined (_STLP_USE_PERTHREAD_ALLOC)
+
+_STLP_END_NAMESPACE
+// include additional header here
+# include <stl/_pthread_alloc.h>
+_STLP_BEGIN_NAMESPACE
+
+typedef __pthread_alloc __alloc_type;
+#elif defined (_STLP_USE_NEWALLOC)
+typedef __new_alloc __alloc_type;
+#elif defined (_STLP_USE_MALLOC)
+typedef __malloc_alloc __alloc_type;
+#else
+typedef __node_alloc __alloc_type;
+#endif
+
+#if defined (_STLP_DEBUG_ALLOC)
+typedef __debug_alloc<__alloc_type> __sgi_alloc;
+#else
+typedef __alloc_type __sgi_alloc;
+#endif
+
+#if !defined (_STLP_NO_ANACHRONISMS)
+typedef __sgi_alloc __single_client_alloc;
+typedef __sgi_alloc __multithreaded_alloc;
+#endif
+
+// This implements allocators as specified in the C++ standard.
+//
+// Note that standard-conforming allocators use many language features
+// that are not yet widely implemented. In particular, they rely on
+// member templates, partial specialization, partial ordering of function
+// templates, the typename keyword, and the use of the template keyword
+// to refer to a template member of a dependent type.
+
+/*
+template <class _Tp>
+struct _AllocatorAux {
+ typedef _Tp* pointer;
+ typedef const _Tp* const_pointer;
+ typedef _Tp& reference;
+ typedef const _Tp& const_reference;
+
+ pointer address(reference __x) const {return &__x;}
+ const_pointer address(const_reference __x) const { return &__x; }
+};
+
+template <class _Tp>
+struct _AllocatorAux<const _Tp> {
+ typedef _Tp* pointer;
+ typedef const _Tp* const_pointer;
+ typedef _Tp& reference;
+ typedef const _Tp& const_reference;
+
+ const_pointer address(const_reference __x) const { return &__x; }
+};
+*/
+
+template <class _Tp>
+class allocator //: public _AllocatorAux<_Tp>
+/* A small helper struct to recognize STLport allocator implementation
+ * from any user specialization one.
+ */
+ : public __stlport_class<allocator<_Tp> >
+{
+public:
+ typedef _Tp value_type;
+ typedef _Tp* pointer;
+ typedef const _Tp* const_pointer;
+ typedef _Tp& reference;
+ typedef const _Tp& const_reference;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+#if defined (_STLP_MEMBER_TEMPLATE_CLASSES)
+ template <class _Tp1> struct rebind {
+ typedef allocator<_Tp1> other;
+ };
+#endif
+ allocator() _STLP_NOTHROW {}
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _Tp1> allocator(const allocator<_Tp1>&) _STLP_NOTHROW {}
+#endif
+ allocator(const allocator<_Tp>&) _STLP_NOTHROW {}
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ allocator(__move_source<allocator<_Tp> > src) _STLP_NOTHROW {}
+#endif
+ ~allocator() _STLP_NOTHROW {}
+ pointer address(reference __x) const {return &__x;}
+ const_pointer address(const_reference __x) const { return &__x; }
+ // __n is permitted to be 0. The C++ standard says nothing about what the return value is when __n == 0.
+ _Tp* allocate(size_type __n, const void* = 0) {
+ if (__n > max_size()) {
+ _STLP_THROW_BAD_ALLOC;
+ }
+ if (__n != 0) {
+ size_type __buf_size = __n * sizeof(value_type);
+ _Tp* __ret = __REINTERPRET_CAST(_Tp*, __sgi_alloc::allocate(__buf_size));
+#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)
+ memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);
+#endif
+ return __ret;
+ }
+
+ return 0;
+ }
+ // __p is permitted to be a null pointer, only if n==0.
+ void deallocate(pointer __p, size_type __n) {
+ _STLP_ASSERT( (__p == 0) == (__n == 0) )
+ if (__p != 0) {
+#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)
+ memset((char*)__p, _STLP_SHRED_BYTE, __n * sizeof(value_type));
+#endif
+ __sgi_alloc::deallocate((void*)__p, __n * sizeof(value_type));
+ }
+ }
+#if !defined (_STLP_NO_ANACHRONISMS)
+ // backwards compatibility
+ void deallocate(pointer __p) const { if (__p != 0) __sgi_alloc::deallocate((void*)__p, sizeof(value_type)); }
+#endif
+ size_type max_size() const _STLP_NOTHROW { return size_t(-1) / sizeof(value_type); }
+ void construct(pointer __p, const_reference __val) { _STLP_STD::_Copy_Construct(__p, __val); }
+ void destroy(pointer __p) { _STLP_STD::_Destroy(__p); }
+
+#if defined (_STLP_NO_EXTENSIONS)
+ /* STLport extension giving rounded size of an allocated memory buffer
+ * This method do not have to be part of a user defined allocator implementation
+ * and won't even be called if such a function was granted.
+ */
+protected:
+#endif
+ _Tp* _M_allocate(size_type __n, size_type& __allocated_n) {
+ if (__n > max_size()) {
+ _STLP_THROW_BAD_ALLOC;
+ }
+
+ if (__n != 0) {
+ size_type __buf_size = __n * sizeof(value_type);
+ _Tp* __ret = __REINTERPRET_CAST(_Tp*, __sgi_alloc::allocate(__buf_size));
+#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)
+ memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);
+#endif
+ __allocated_n = __buf_size / sizeof(value_type);
+ return __ret;
+ }
+
+ return 0;
+ }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(allocator<_Tp>& __other) {}
+#endif
+};
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC allocator<void> {
+public:
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef void* pointer;
+ typedef const void* const_pointer;
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ typedef void value_type;
+#endif
+#if defined (_STLP_MEMBER_TEMPLATE_CLASSES)
+ template <class _Tp1> struct rebind {
+ typedef allocator<_Tp1> other;
+ };
+#endif
+};
+
+template <class _T1, class _T2>
+inline bool _STLP_CALL operator==(const allocator<_T1>&, const allocator<_T2>&) _STLP_NOTHROW
+{ return true; }
+template <class _T1, class _T2>
+inline bool _STLP_CALL operator!=(const allocator<_T1>&, const allocator<_T2>&) _STLP_NOTHROW
+{ return false; }
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS allocator<char>;
+# if defined (_STLP_HAS_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS allocator<wchar_t>;
+# endif
+# if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+_STLP_EXPORT_TEMPLATE_CLASS allocator<void*>;
+# endif
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp>
+struct __alloc_type_traits {
+#if !defined (__BORLANDC__)
+ typedef typename _IsSTLportClass<allocator<_Tp> >::_Ret _STLportAlloc;
+#else
+ enum { _Is = _IsSTLportClass<allocator<_Tp> >::_Is };
+ typedef typename __bool2type<_Is>::_Ret _STLportAlloc;
+#endif
+ //The default allocator implementation which is recognize thanks to the
+ //__stlport_class inheritance is a stateless object so:
+ typedef _STLportAlloc has_trivial_default_constructor;
+ typedef _STLportAlloc has_trivial_copy_constructor;
+ typedef _STLportAlloc has_trivial_assignment_operator;
+ typedef _STLportAlloc has_trivial_destructor;
+ typedef _STLportAlloc is_POD_type;
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+template <class _Tp>
+struct __type_traits<allocator<_Tp> > : _STLP_PRIV __alloc_type_traits<_Tp> {};
+#else
+_STLP_TEMPLATE_NULL
+struct __type_traits<allocator<char> > : _STLP_PRIV __alloc_type_traits<char> {};
+# if defined (_STLP_HAS_WCHAR_T)
+_STLP_TEMPLATE_NULL
+struct __type_traits<allocator<wchar_t> > : _STLP_PRIV __alloc_type_traits<wchar_t> {};
+# endif
+# if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+_STLP_TEMPLATE_NULL
+struct __type_traits<allocator<void*> > : _STLP_PRIV __alloc_type_traits<void*> {};
+# endif
+#endif
+
+
+#if !defined (_STLP_FORCE_ALLOCATORS)
+# define _STLP_FORCE_ALLOCATORS(a,y)
+#endif
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_MEMBER_TEMPLATE_CLASSES)
+// The version for the default allocator, for rare occasion when we have partial spec w/o member template classes
+template <class _Tp, class _Tp1>
+struct _Alloc_traits<_Tp, allocator<_Tp1> > {
+ typedef allocator<_Tp1> _Orig;
+ typedef allocator<_Tp> allocator_type;
+ static allocator_type create_allocator(const allocator<_Tp1 >& __a)
+ { return allocator_type(_STLP_CONVERT_ALLOCATOR(__a, _Tp)); }
+};
+#endif
+
+#if !defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE) && defined (_STLP_MEMBER_TEMPLATES)
+template <class _Tp, class _Alloc>
+inline _STLP_TYPENAME_ON_RETURN_TYPE _Alloc_traits<_Tp, _Alloc>::allocator_type _STLP_CALL
+__stl_alloc_create(const _Alloc& __a, const _Tp*) {
+ typedef typename _Alloc::_STLP_TEMPLATE rebind<_Tp>::other _Rebound_type;
+ return _Rebound_type(__a);
+}
+#else
+// If custom allocators are being used without member template classes support :
+// user (on purpose) is forced to define rebind/get operations !!!
+template <class _Tp1, class _Tp2>
+inline allocator<_Tp2>& _STLP_CALL
+__stl_alloc_rebind(allocator<_Tp1>& __a, const _Tp2*) { return (allocator<_Tp2>&)(__a); }
+template <class _Tp1, class _Tp2>
+inline allocator<_Tp2> _STLP_CALL
+__stl_alloc_create(const allocator<_Tp1>&, const _Tp2*) { return allocator<_Tp2>(); }
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// inheritance is being used for EBO optimization
+template <class _Value, class _Tp, class _MaybeReboundAlloc>
+class _STLP_alloc_proxy : public _MaybeReboundAlloc {
+private:
+ typedef _MaybeReboundAlloc _Base;
+ typedef typename _Base::size_type size_type;
+ typedef _STLP_alloc_proxy<_Value, _Tp, _MaybeReboundAlloc> _Self;
+public:
+ _Value _M_data;
+
+ _STLP_alloc_proxy (const _MaybeReboundAlloc& __a, _Value __p) :
+ _MaybeReboundAlloc(__a), _M_data(__p) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ _STLP_alloc_proxy (__move_source<_Self> src) :
+ _Base(_STLP_PRIV _AsMoveSource(src.get()._M_base())),
+ _M_data(_STLP_PRIV _AsMoveSource(src.get()._M_data)) {}
+
+ _Base& _M_base()
+ { return *this; }
+#endif
+
+private:
+ /* Following are helper methods to detect stateless allocators and avoid
+ * swap in this case. For some compilers (VC6) it is a workaround for a
+ * compiler bug in the Empty Base class Optimization feature, for others
+ * it is a small optimization or nothing if no EBO. */
+ void _M_swap_alloc(_Self&, const __true_type& /*_IsStateless*/)
+ {}
+
+ void _M_swap_alloc(_Self& __x, const __false_type& /*_IsStateless*/) {
+ _MaybeReboundAlloc &__base_this = *this;
+ _MaybeReboundAlloc &__base_x = __x;
+ _STLP_STD::swap(__base_this, __base_x);
+ }
+
+public:
+ void _M_swap_alloc(_Self& __x) {
+#if !defined (__BORLANDC__)
+ typedef typename _IsStateless<_MaybeReboundAlloc>::_Ret _StatelessAlloc;
+#else
+ typedef typename __bool2type<_IsStateless<_MaybeReboundAlloc>::_Is>::_Ret _StatelessAlloc;
+#endif
+ _M_swap_alloc(__x, _StatelessAlloc());
+ }
+
+ /* We need to define the following swap implementation for allocator with state
+ * as those allocators might have implement a special swap function to correctly
+ * move datas from an instance to the oher, _STLP_alloc_proxy should not break
+ * this mecanism. */
+ void swap(_Self& __x) {
+ _M_swap_alloc(__x);
+ _STLP_STD::swap(_M_data, __x._M_data);
+ }
+
+ _Tp* allocate(size_type __n, size_type& __allocated_n) {
+#if !defined (__BORLANDC__)
+ typedef typename _IsSTLportClass<_MaybeReboundAlloc>::_Ret _STLportAlloc;
+#else
+ typedef typename __bool2type<_IsSTLportClass<_MaybeReboundAlloc>::_Is>::_Ret _STLportAlloc;
+#endif
+ return allocate(__n, __allocated_n, _STLportAlloc());
+ }
+
+ // Unified interface to perform allocate()/deallocate() with limited
+ // language support
+#if defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)
+ // else it is rebound already, and allocate() member is accessible
+ _Tp* allocate(size_type __n)
+ { return __stl_alloc_rebind(__STATIC_CAST(_Base&, *this), __STATIC_CAST(_Tp*, 0)).allocate(__n, 0); }
+ void deallocate(_Tp* __p, size_type __n)
+ { __stl_alloc_rebind(__STATIC_CAST(_Base&, *this), __STATIC_CAST(_Tp*, 0)).deallocate(__p, __n); }
+private:
+ _Tp* allocate(size_type __n, size_type& __allocated_n, const __true_type& /*STLport allocator*/)
+ { return __stl_alloc_rebind(__STATIC_CAST(_Base&, *this), __STATIC_CAST(_Tp*, 0))._M_allocate(__n, __allocated_n); }
+#else
+ //Expose Standard allocate overload (using expression do not work for some compilers (Borland))
+ _Tp* allocate(size_type __n)
+ { return _Base::allocate(__n); }
+private:
+ _Tp* allocate(size_type __n, size_type& __allocated_n, const __true_type& /*STLport allocator*/)
+ { return _Base::_M_allocate(__n, __allocated_n); }
+#endif
+
+ _Tp* allocate(size_type __n, size_type& __allocated_n, const __false_type& /*STLport allocator*/)
+ { __allocated_n = __n; return allocate(__n); }
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<char*, char, allocator<char> >;
+# if defined (_STLP_HAS_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<wchar_t*, wchar_t, allocator<wchar_t> >;
+# endif
+# if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<void**, void*, allocator<void*> >;
+# endif
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_alloc.c>
+#endif
+
+#endif /* _STLP_INTERNAL_ALLOC_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/stl/_auto_ptr.h b/sources/android/stlport/stlport/stl/_auto_ptr.h
new file mode 100644
index 0000000..c750534
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_auto_ptr.h
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_AUTO_PTR_H
+#define _STLP_AUTO_PTR_H
+
+_STLP_BEGIN_NAMESPACE
+// implementation primitive
+class __ptr_base {
+public:
+ void* _M_p;
+ void __set(const volatile void* p) { _M_p = __CONST_CAST(void*,p); }
+ void __set(void* p) { _M_p = p; }
+};
+
+template <class _Tp>
+class auto_ptr_ref {
+public:
+ __ptr_base& _M_r;
+ _Tp* const _M_p;
+
+ auto_ptr_ref(__ptr_base& __r, _Tp* __p) : _M_r(__r), _M_p(__p) { }
+
+ _Tp* release() const { _M_r.__set(__STATIC_CAST(void*, 0)); return _M_p; }
+
+private:
+ //explicitely defined as private to avoid warnings:
+ typedef auto_ptr_ref<_Tp> _Self;
+ _Self& operator = (_Self const&);
+};
+
+template<class _Tp>
+class auto_ptr : public __ptr_base {
+public:
+ typedef _Tp element_type;
+ typedef auto_ptr<_Tp> _Self;
+
+ _Tp* release() _STLP_NOTHROW {
+ _Tp* __px = this->get();
+ this->_M_p = 0;
+ return __px;
+ }
+
+ void reset(_Tp* __px = 0) _STLP_NOTHROW {
+ _Tp* __pt = this->get();
+ if (__px != __pt)
+ delete __pt;
+ this->__set(__px);
+ }
+
+ _Tp* get() const _STLP_NOTHROW
+#if !defined (__GNUC__) || (__GNUC__ > 2)
+ { return __STATIC_CAST(_Tp*, _M_p); }
+#else
+ { return __REINTERPRET_CAST(_Tp*, _M_p); }
+#endif
+
+#if !defined (_STLP_NO_ARROW_OPERATOR)
+ _Tp* operator->() const _STLP_NOTHROW {
+ _STLP_VERBOSE_ASSERT(get() != 0, _StlMsg_AUTO_PTR_NULL)
+ return get();
+ }
+#endif
+ _Tp& operator*() const _STLP_NOTHROW {
+ _STLP_VERBOSE_ASSERT(get() != 0, _StlMsg_AUTO_PTR_NULL)
+ return *get();
+ }
+
+ explicit auto_ptr(_Tp* __px = 0) _STLP_NOTHROW { this->__set(__px); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+# if !defined (_STLP_NO_TEMPLATE_CONVERSIONS)
+ template<class _Tp1> auto_ptr(auto_ptr<_Tp1>& __r) _STLP_NOTHROW {
+ _Tp* __conversionCheck = __r.release();
+ this->__set(__conversionCheck);
+ }
+# endif
+ template<class _Tp1> auto_ptr<_Tp>& operator=(auto_ptr<_Tp1>& __r) _STLP_NOTHROW {
+ _Tp* __conversionCheck = __r.release();
+ reset(__conversionCheck);
+ return *this;
+ }
+#endif
+
+ auto_ptr(_Self& __r) _STLP_NOTHROW { this->__set(__r.release()); }
+
+ _Self& operator=(_Self& __r) _STLP_NOTHROW {
+ reset(__r.release());
+ return *this;
+ }
+
+ ~auto_ptr() _STLP_NOTHROW { /* boris : reset(0) might be better */ delete this->get(); }
+
+ auto_ptr(auto_ptr_ref<_Tp> __r) _STLP_NOTHROW
+ { this->__set(__r.release()); }
+
+ _Self& operator=(auto_ptr_ref<_Tp> __r) _STLP_NOTHROW {
+ reset(__r.release());
+ return *this;
+ }
+
+#if defined(_STLP_MEMBER_TEMPLATES) && !defined(_STLP_NO_TEMPLATE_CONVERSIONS)
+ template<class _Tp1> operator auto_ptr_ref<_Tp1>() _STLP_NOTHROW
+ { return auto_ptr_ref<_Tp1>(*this, this->get()); }
+ template<class _Tp1> operator auto_ptr<_Tp1>() _STLP_NOTHROW
+ { return auto_ptr<_Tp1>(release()); }
+#else
+ operator auto_ptr_ref<_Tp>() _STLP_NOTHROW
+ { return auto_ptr_ref<_Tp>(*this, this->get()); }
+#endif
+};
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_AUTO_PTR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_bitset.c b/sources/android/stlport/stlport/stl/_bitset.c
new file mode 100644
index 0000000..82b9312
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_bitset.c
@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) 1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_BITSET_C
+#define _STLP_BITSET_C
+
+#ifndef _STLP_BITSET_H
+# include <stl/_bitset.h>
+#endif
+
+#define __BITS_PER_WORD (CHAR_BIT * sizeof(unsigned long))
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+//
+// Definitions of non-inline functions from _Base_bitset.
+//
+template<size_t _Nw>
+void _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift) {
+ if (__shift != 0) {
+ const size_t __wshift = __shift / __BITS_PER_WORD;
+ const size_t __offset = __shift % __BITS_PER_WORD;
+
+ if (__offset == 0)
+ for (size_t __n = _Nw - 1; __n >= __wshift; --__n)
+ _M_w[__n] = _M_w[__n - __wshift];
+
+ else {
+ const size_t __sub_offset = __BITS_PER_WORD - __offset;
+ for (size_t __n = _Nw - 1; __n > __wshift; --__n)
+ _M_w[__n] = (_M_w[__n - __wshift] << __offset) |
+ (_M_w[__n - __wshift - 1] >> __sub_offset);
+ _M_w[__wshift] = _M_w[0] << __offset;
+ }
+
+ fill(_M_w + 0, _M_w + __wshift, __STATIC_CAST(_WordT,0));
+ }
+}
+
+template<size_t _Nw>
+void _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) {
+ if (__shift != 0) {
+ const size_t __wshift = __shift / __BITS_PER_WORD;
+ const size_t __offset = __shift % __BITS_PER_WORD;
+ const size_t __limit = _Nw - __wshift - 1;
+
+ if (__offset == 0)
+ for (size_t __n = 0; __n <= __limit; ++__n)
+ _M_w[__n] = _M_w[__n + __wshift];
+
+ else {
+ const size_t __sub_offset = __BITS_PER_WORD - __offset;
+ for (size_t __n = 0; __n < __limit; ++__n)
+ _M_w[__n] = (_M_w[__n + __wshift] >> __offset) |
+ (_M_w[__n + __wshift + 1] << __sub_offset);
+ _M_w[__limit] = _M_w[_Nw-1] >> __offset;
+ }
+
+ fill(_M_w + __limit + 1, _M_w + _Nw, __STATIC_CAST(_WordT,0));
+ }
+}
+
+template<size_t _Nw>
+unsigned long _Base_bitset<_Nw>::_M_do_to_ulong() const {
+ for (size_t __i = 1; __i < _Nw; ++__i)
+ if (_M_w[__i])
+ __stl_throw_overflow_error("bitset");
+ return _M_w[0];
+} // End _M_do_to_ulong
+
+template<size_t _Nw>
+size_t _Base_bitset<_Nw>::_M_do_find_first(size_t __not_found) const {
+ for ( size_t __i = 0; __i < _Nw; __i++ ) {
+ _WordT __thisword = _M_w[__i];
+ if ( __thisword != __STATIC_CAST(_WordT,0) ) {
+ // find byte within word
+ for ( size_t __j = 0; __j < sizeof(_WordT); __j++ ) {
+ unsigned char __this_byte
+ = __STATIC_CAST(unsigned char,(__thisword & (~(unsigned char)0)));
+ if ( __this_byte )
+ return __i*__BITS_PER_WORD + __j*CHAR_BIT +
+ _Bs_G::_S_first_one(__this_byte);
+
+ __thisword >>= CHAR_BIT;
+ }
+ }
+ }
+ // not found, so return an indication of failure.
+ return __not_found;
+}
+
+template<size_t _Nw>
+size_t
+_Base_bitset<_Nw>::_M_do_find_next(size_t __prev,
+ size_t __not_found) const {
+ // make bound inclusive
+ ++__prev;
+
+ // check out of bounds
+ if ( __prev >= _Nw * __BITS_PER_WORD )
+ return __not_found;
+
+ // search first word
+ size_t __i = _S_whichword(__prev);
+ _WordT __thisword = _M_w[__i];
+
+ // mask off bits below bound
+ __thisword &= (~__STATIC_CAST(_WordT,0)) << _S_whichbit(__prev);
+
+ if ( __thisword != __STATIC_CAST(_WordT,0) ) {
+ // find byte within word
+ // get first byte into place
+ __thisword >>= _S_whichbyte(__prev) * CHAR_BIT;
+ for ( size_t __j = _S_whichbyte(__prev); __j < sizeof(_WordT); ++__j ) {
+ unsigned char __this_byte
+ = __STATIC_CAST(unsigned char,(__thisword & (~(unsigned char)0)));
+ if ( __this_byte )
+ return __i*__BITS_PER_WORD + __j*CHAR_BIT +
+ _Bs_G::_S_first_one(__this_byte);
+
+ __thisword >>= CHAR_BIT;
+ }
+ }
+
+ // check subsequent words
+ ++__i;
+ for ( ; __i < _Nw; ++__i ) {
+ /* _WordT */ __thisword = _M_w[__i];
+ if ( __thisword != __STATIC_CAST(_WordT,0) ) {
+ // find byte within word
+ for ( size_t __j = 0; __j < sizeof(_WordT); ++__j ) {
+ unsigned char __this_byte
+ = __STATIC_CAST(unsigned char,(__thisword & (~(unsigned char)0)));
+ if ( __this_byte )
+ return __i*__BITS_PER_WORD + __j*CHAR_BIT +
+ _Bs_G::_S_first_one(__this_byte);
+
+ __thisword >>= CHAR_BIT;
+ }
+ }
+ }
+
+ // not found, so return an indication of failure.
+ return __not_found;
+} // end _M_do_find_next
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#if !defined (_STLP_NON_TYPE_TMPL_PARAM_BUG)
+
+# if !defined (_STLP_USE_NO_IOSTREAMS)
+
+_STLP_END_NAMESPACE
+
+#ifndef _STLP_STRING_IO_H
+# include <stl/_string_io.h> //includes _istream.h and _ostream.h
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _CharT, class _Traits, size_t _Nb>
+basic_istream<_CharT, _Traits>& _STLP_CALL
+operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x) {
+ basic_string<_CharT, _Traits> __tmp;
+ __tmp.reserve(_Nb);
+
+ // Skip whitespace
+ typename basic_istream<_CharT, _Traits>::sentry __sentry(__is);
+ if (__sentry) {
+ basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf();
+ for (size_t __i = 0; __i < _Nb; ++__i) {
+ static typename _Traits::int_type __eof = _Traits::eof();
+
+ typename _Traits::int_type __c1 = __buf->sbumpc();
+ if (_Traits::eq_int_type(__c1, __eof)) {
+ __is.setstate(ios_base::eofbit);
+ break;
+ }
+ else {
+ typename _Traits::char_type __c2 = _Traits::to_char_type(__c1);
+ char __c = __is.narrow(__c2, '*');
+
+ if (__c == '0' || __c == '1')
+ __tmp.push_back(__c);
+ else if (_Traits::eq_int_type(__buf->sputbackc(__c2), __eof)) {
+ __is.setstate(ios_base::failbit);
+ break;
+ }
+ }
+ }
+
+ if (__tmp.empty())
+ __is.setstate(ios_base::failbit);
+ else
+ __x._M_copy_from_string(__tmp, __STATIC_CAST(size_t,0), _Nb);
+ }
+
+ return __is;
+}
+
+template <class _CharT, class _Traits, size_t _Nb>
+basic_ostream<_CharT, _Traits>& _STLP_CALL
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const bitset<_Nb>& __x) {
+ basic_string<_CharT, _Traits> __tmp;
+ __x._M_copy_to_string(__tmp);
+ return __os << __tmp;
+}
+
+# endif /* !_STLP_USE_NO_IOSTREAMS */
+
+#endif /* _STLP_NON_TYPE_TMPL_PARAM_BUG */
+
+_STLP_END_NAMESPACE
+
+#undef __BITS_PER_WORD
+#undef bitset
+
+#endif /* _STLP_BITSET_C */
diff --git a/sources/android/stlport/stlport/stl/_bitset.h b/sources/android/stlport/stlport/stl/_bitset.h
new file mode 100644
index 0000000..f894346
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_bitset.h
@@ -0,0 +1,880 @@
+/*
+ * Copyright (c) 1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_BITSET_H
+#define _STLP_BITSET_H
+
+// A bitset of size N has N % (sizeof(unsigned long) * CHAR_BIT) unused
+// bits. (They are the high- order bits in the highest word.) It is
+// a class invariant of class bitset<> that those unused bits are
+// always zero.
+
+// Most of the actual code isn't contained in bitset<> itself, but in the
+// base class _Base_bitset. The base class works with whole words, not with
+// individual bits. This allows us to specialize _Base_bitset for the
+// important special case where the bitset is only a single word.
+
+// The C++ standard does not define the precise semantics of operator[].
+// In this implementation the const version of operator[] is equivalent
+// to test(), except that it does no range checking. The non-const version
+// returns a reference to a bit, again without doing any range checking.
+
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+# include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+# include <stl/_alloc.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+# include <stl/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_UNINITIALIZED_H
+# include <stl/_uninitialized.h>
+#endif
+
+#ifndef _STLP_RANGE_ERRORS_H
+# include <stl/_range_errors.h>
+#endif
+
+#ifndef _STLP_INTERNAL_STRING_H
+# include <stl/_string.h>
+#endif
+
+#define __BITS_PER_WORD (CHAR_BIT*sizeof(unsigned long))
+#define __BITSET_WORDS(__n) ((__n + __BITS_PER_WORD - 1)/__BITS_PER_WORD)
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// structure to aid in counting bits
+class _STLP_CLASS_DECLSPEC _Bs_G
+{
+ public:
+ //returns the number of bit set within the buffer between __beg and __end.
+ static size_t _S_count(const unsigned char *__beg, const unsigned char *__end)
+#if defined (_STLP_USE_NO_IOSTREAMS)
+ {
+ size_t __result = 0;
+ for (; __beg != __end; ++__beg) {
+ for (size_t i = 0; i < (sizeof(unsigned char) * 8); ++i) {
+ if ((*__beg & (1 << i)) != 0) { ++__result; }
+ }
+ }
+ return __result;
+ }
+#else
+ ;
+#endif
+ // Mapping from 8 bit unsigned integers to the index of the first one bit set:
+ static unsigned char _S_first_one(unsigned char __x)
+#if defined (_STLP_USE_NO_IOSTREAMS)
+ {
+ for (unsigned char i = 0; i < (sizeof(unsigned char) * 8); ++i) {
+ if ((__x & (1 << i)) != 0) { return i; }
+ }
+ return 0;
+ }
+#else
+ ;
+#endif
+};
+
+//
+// Base class: general case.
+//
+
+template<size_t _Nw>
+struct _Base_bitset {
+ typedef unsigned long _WordT;
+
+ _WordT _M_w[_Nw]; // 0 is the least significant word.
+
+ _Base_bitset() { _M_do_reset(); }
+
+ _Base_bitset(unsigned long __val) {
+ _M_do_reset();
+ _M_w[0] = __val;
+ }
+
+ static size_t _STLP_CALL _S_whichword( size_t __pos ) {
+ return __pos / __BITS_PER_WORD;
+ }
+ static size_t _STLP_CALL _S_whichbyte( size_t __pos ) {
+ return (__pos % __BITS_PER_WORD) / CHAR_BIT;
+ }
+ static size_t _STLP_CALL _S_whichbit( size_t __pos ) {
+ return __pos % __BITS_PER_WORD;
+ }
+ static _WordT _STLP_CALL _S_maskbit( size_t __pos ) {
+ return __STATIC_CAST(_WordT,1) << _S_whichbit(__pos);
+ }
+
+ _WordT& _M_getword(size_t __pos) { return _M_w[_S_whichword(__pos)]; }
+ _WordT _M_getword(size_t __pos) const { return _M_w[_S_whichword(__pos)]; }
+
+ _WordT& _M_hiword() { return _M_w[_Nw - 1]; }
+ _WordT _M_hiword() const { return _M_w[_Nw - 1]; }
+
+ void _M_do_and(const _Base_bitset<_Nw>& __x) {
+ for ( size_t __i = 0; __i < _Nw; __i++ ) {
+ _M_w[__i] &= __x._M_w[__i];
+ }
+ }
+
+ void _M_do_or(const _Base_bitset<_Nw>& __x) {
+ for ( size_t __i = 0; __i < _Nw; __i++ ) {
+ _M_w[__i] |= __x._M_w[__i];
+ }
+ }
+
+ void _M_do_xor(const _Base_bitset<_Nw>& __x) {
+ for ( size_t __i = 0; __i < _Nw; __i++ ) {
+ _M_w[__i] ^= __x._M_w[__i];
+ }
+ }
+
+ void _M_do_left_shift(size_t __shift);
+
+ void _M_do_right_shift(size_t __shift);
+
+ void _M_do_flip() {
+ for ( size_t __i = 0; __i < _Nw; __i++ ) {
+ _M_w[__i] = ~_M_w[__i];
+ }
+ }
+
+ void _M_do_set() {
+ for ( size_t __i = 0; __i < _Nw; __i++ ) {
+ _M_w[__i] = ~__STATIC_CAST(_WordT,0);
+ }
+ }
+
+ void _M_do_reset() { memset(_M_w, 0, _Nw * sizeof(_WordT)); }
+
+ bool _M_is_equal(const _Base_bitset<_Nw>& __x) const {
+ for (size_t __i = 0; __i < _Nw; ++__i) {
+ if (_M_w[__i] != __x._M_w[__i])
+ return false;
+ }
+ return true;
+ }
+
+ bool _M_is_any() const {
+ for ( size_t __i = 0; __i < _Nw ; __i++ ) {
+ if ( _M_w[__i] != __STATIC_CAST(_WordT,0) )
+ return true;
+ }
+ return false;
+ }
+
+ size_t _M_do_count() const {
+ const unsigned char* __byte_ptr = (const unsigned char*)_M_w;
+ const unsigned char* __end_ptr = (const unsigned char*)(_M_w+_Nw);
+
+ return _Bs_G::_S_count(__byte_ptr, __end_ptr);
+ }
+
+ unsigned long _M_do_to_ulong() const;
+
+ // find first "on" bit
+ size_t _M_do_find_first(size_t __not_found) const;
+
+ // find the next "on" bit that follows "prev"
+ size_t _M_do_find_next(size_t __prev, size_t __not_found) const;
+};
+
+//
+// Base class: specialization for a single word.
+//
+_STLP_TEMPLATE_NULL
+struct _Base_bitset<1UL> {
+ typedef unsigned long _WordT;
+ typedef _Base_bitset<1UL> _Self;
+
+ _WordT _M_w;
+
+ _Base_bitset( void ) : _M_w(0) {}
+ _Base_bitset(unsigned long __val) : _M_w(__val) {}
+
+ static size_t _STLP_CALL _S_whichword( size_t __pos ) {
+ return __pos / __BITS_PER_WORD ;
+ }
+ static size_t _STLP_CALL _S_whichbyte( size_t __pos ) {
+ return (__pos % __BITS_PER_WORD) / CHAR_BIT;
+ }
+ static size_t _STLP_CALL _S_whichbit( size_t __pos ) {
+ return __pos % __BITS_PER_WORD;
+ }
+ static _WordT _STLP_CALL _S_maskbit( size_t __pos ) {
+ return (__STATIC_CAST(_WordT,1)) << _S_whichbit(__pos);
+ }
+
+ _WordT& _M_getword(size_t) { return _M_w; }
+ _WordT _M_getword(size_t) const { return _M_w; }
+
+ _WordT& _M_hiword() { return _M_w; }
+ _WordT _M_hiword() const { return _M_w; }
+
+ void _M_do_and(const _Self& __x) { _M_w &= __x._M_w; }
+ void _M_do_or(const _Self& __x) { _M_w |= __x._M_w; }
+ void _M_do_xor(const _Self& __x) { _M_w ^= __x._M_w; }
+ void _M_do_left_shift(size_t __shift) { _M_w <<= __shift; }
+ void _M_do_right_shift(size_t __shift) { _M_w >>= __shift; }
+ void _M_do_flip() { _M_w = ~_M_w; }
+ void _M_do_set() { _M_w = ~__STATIC_CAST(_WordT,0); }
+ void _M_do_reset() { _M_w = 0; }
+
+ bool _M_is_equal(const _Self& __x) const {
+ return _M_w == __x._M_w;
+ }
+ bool _M_is_any() const {
+ return _M_w != 0;
+ }
+
+ size_t _M_do_count() const {
+ const unsigned char* __byte_ptr = (const unsigned char*)&_M_w;
+ const unsigned char* __end_ptr = ((const unsigned char*)&_M_w)+sizeof(_M_w);
+ return _Bs_G::_S_count(__byte_ptr, __end_ptr);
+ }
+
+ unsigned long _M_do_to_ulong() const { return _M_w; }
+
+ inline size_t _M_do_find_first(size_t __not_found) const;
+
+ // find the next "on" bit that follows "prev"
+ inline size_t _M_do_find_next(size_t __prev, size_t __not_found) const;
+};
+
+
+// ------------------------------------------------------------
+//
+// Definitions of should-be-non-inline functions from the single-word version of
+// _Base_bitset.
+//
+inline size_t
+_Base_bitset<1UL>::_M_do_find_first(size_t __not_found) const {
+ // typedef unsigned long _WordT;
+ _WordT __thisword = _M_w;
+
+ if ( __thisword != __STATIC_CAST(_WordT,0) ) {
+ // find byte within word
+ for ( size_t __j = 0; __j < sizeof(_WordT); __j++ ) {
+ unsigned char __this_byte
+ = __STATIC_CAST(unsigned char,(__thisword & (~(unsigned char)0)));
+ if ( __this_byte )
+ return __j*CHAR_BIT + _Bs_G::_S_first_one(__this_byte);
+
+ __thisword >>= CHAR_BIT;
+ }
+ }
+ // not found, so return a value that indicates failure.
+ return __not_found;
+}
+
+inline size_t
+_Base_bitset<1UL>::_M_do_find_next(size_t __prev,
+ size_t __not_found ) const {
+ // make bound inclusive
+ ++__prev;
+
+ // check out of bounds
+ if ( __prev >= __BITS_PER_WORD )
+ return __not_found;
+
+ // search first (and only) word
+ _WordT __thisword = _M_w;
+
+ // mask off bits below bound
+ __thisword &= (~__STATIC_CAST(_WordT,0)) << _S_whichbit(__prev);
+
+ if ( __thisword != __STATIC_CAST(_WordT,0) ) {
+ // find byte within word
+ // get first byte into place
+ __thisword >>= _S_whichbyte(__prev) * CHAR_BIT;
+ for ( size_t __j = _S_whichbyte(__prev); __j < sizeof(_WordT); __j++ ) {
+ unsigned char __this_byte
+ = __STATIC_CAST(unsigned char,(__thisword & (~(unsigned char)0)));
+ if ( __this_byte )
+ return __j*CHAR_BIT + _Bs_G::_S_first_one(__this_byte);
+
+ __thisword >>= CHAR_BIT;
+ }
+ }
+
+ // not found, so return a value that indicates failure.
+ return __not_found;
+} // end _M_do_find_next
+
+
+// ------------------------------------------------------------
+// Helper class to zero out the unused high-order bits in the highest word.
+
+template <size_t _Extrabits> struct _Sanitize {
+ static void _STLP_CALL _M_do_sanitize(unsigned long& __val)
+ { __val &= ~((~__STATIC_CAST(unsigned long,0)) << _Extrabits); }
+};
+
+_STLP_TEMPLATE_NULL struct _Sanitize<0UL> {
+ static void _STLP_CALL _M_do_sanitize(unsigned long) {}
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+// ------------------------------------------------------------
+// Class bitset.
+// _Nb may be any nonzero number of type size_t.
+template<size_t _Nb>
+class bitset : public _STLP_PRIV _Base_bitset<__BITSET_WORDS(_Nb) > {
+public:
+ enum { _Words = __BITSET_WORDS(_Nb) } ;
+
+private:
+ typedef _STLP_PRIV _Base_bitset< _Words > _Base;
+
+ void _M_do_sanitize() {
+ _STLP_PRIV _Sanitize<_Nb%__BITS_PER_WORD >::_M_do_sanitize(this->_M_hiword());
+ }
+public:
+ typedef unsigned long _WordT;
+ struct reference;
+ friend struct reference;
+
+ // bit reference:
+ struct reference {
+ typedef _STLP_PRIV _Base_bitset<_Words > _Bitset_base;
+ typedef bitset<_Nb> _Bitset;
+ // friend _Bitset;
+ _WordT *_M_wp;
+ size_t _M_bpos;
+
+ // should be left undefined
+ reference() {}
+
+ reference( _Bitset& __b, size_t __pos ) {
+ _M_wp = &__b._M_getword(__pos);
+ _M_bpos = _Bitset_base::_S_whichbit(__pos);
+ }
+
+ public:
+ ~reference() {}
+
+ // for b[i] = __x;
+ reference& operator=(bool __x) {
+ if ( __x )
+ *_M_wp |= _Bitset_base::_S_maskbit(_M_bpos);
+ else
+ *_M_wp &= ~_Bitset_base::_S_maskbit(_M_bpos);
+
+ return *this;
+ }
+
+ // for b[i] = b[__j];
+ reference& operator=(const reference& __j) {
+ if ( (*(__j._M_wp) & _Bitset_base::_S_maskbit(__j._M_bpos)) )
+ *_M_wp |= _Bitset_base::_S_maskbit(_M_bpos);
+ else
+ *_M_wp &= ~_Bitset_base::_S_maskbit(_M_bpos);
+
+ return *this;
+ }
+
+ // flips the bit
+ bool operator~() const { return (*(_M_wp) & _Bitset_base::_S_maskbit(_M_bpos)) == 0; }
+
+ // for __x = b[i];
+ operator bool() const { return (*(_M_wp) & _Bitset_base::_S_maskbit(_M_bpos)) != 0; }
+
+ // for b[i].flip();
+ reference& flip() {
+ *_M_wp ^= _Bitset_base::_S_maskbit(_M_bpos);
+ return *this;
+ }
+ };
+
+ // 23.3.5.1 constructors:
+ bitset() {}
+
+ bitset(unsigned long __val) : _STLP_PRIV _Base_bitset<_Words>(__val) { _M_do_sanitize(); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template<class _CharT, class _Traits, class _Alloc>
+ explicit bitset(const basic_string<_CharT,_Traits,_Alloc>& __s,
+ size_t __pos = 0)
+ : _STLP_PRIV _Base_bitset<_Words >() {
+ if (__pos > __s.size())
+ __stl_throw_out_of_range("bitset");
+ _M_copy_from_string(__s, __pos,
+ basic_string<_CharT, _Traits, _Alloc>::npos);
+ }
+ template<class _CharT, class _Traits, class _Alloc>
+ bitset(const basic_string<_CharT, _Traits, _Alloc>& __s,
+ size_t __pos,
+ size_t __n)
+ : _STLP_PRIV _Base_bitset<_Words >() {
+ if (__pos > __s.size())
+ __stl_throw_out_of_range("bitset");
+ _M_copy_from_string(__s, __pos, __n);
+ }
+#else /* _STLP_MEMBER_TEMPLATES */
+ explicit bitset(const string& __s,
+ size_t __pos = 0,
+ size_t __n = (size_t)-1)
+ : _STLP_PRIV _Base_bitset<_Words >() {
+ if (__pos > __s.size())
+ __stl_throw_out_of_range("bitset");
+ _M_copy_from_string(__s, __pos, __n);
+ }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ // 23.3.5.2 bitset operations:
+ bitset<_Nb>& operator&=(const bitset<_Nb>& __rhs) {
+ this->_M_do_and(__rhs);
+ return *this;
+ }
+
+ bitset<_Nb>& operator|=(const bitset<_Nb>& __rhs) {
+ this->_M_do_or(__rhs);
+ return *this;
+ }
+
+ bitset<_Nb>& operator^=(const bitset<_Nb>& __rhs) {
+ this->_M_do_xor(__rhs);
+ return *this;
+ }
+
+ bitset<_Nb>& operator<<=(size_t __pos) {
+ this->_M_do_left_shift(__pos);
+ this->_M_do_sanitize();
+ return *this;
+ }
+
+ bitset<_Nb>& operator>>=(size_t __pos) {
+ this->_M_do_right_shift(__pos);
+ this->_M_do_sanitize();
+ return *this;
+ }
+
+ //
+ // Extension:
+ // Versions of single-bit set, reset, flip, test with no range checking.
+ //
+
+ bitset<_Nb>& _Unchecked_set(size_t __pos) {
+ this->_M_getword(__pos) |= _STLP_PRIV _Base_bitset<_Words > ::_S_maskbit(__pos);
+ return *this;
+ }
+
+ bitset<_Nb>& _Unchecked_set(size_t __pos, int __val) {
+ if (__val)
+ this->_M_getword(__pos) |= this->_S_maskbit(__pos);
+ else
+ this->_M_getword(__pos) &= ~ this->_S_maskbit(__pos);
+
+ return *this;
+ }
+
+ bitset<_Nb>& _Unchecked_reset(size_t __pos) {
+ this->_M_getword(__pos) &= ~ this->_S_maskbit(__pos);
+ return *this;
+ }
+
+ bitset<_Nb>& _Unchecked_flip(size_t __pos) {
+ this->_M_getword(__pos) ^= this->_S_maskbit(__pos);
+ return *this;
+ }
+
+ bool _Unchecked_test(size_t __pos) const {
+ return (this->_M_getword(__pos) & this->_S_maskbit(__pos)) != __STATIC_CAST(_WordT,0);
+ }
+
+ // Set, reset, and flip.
+
+ bitset<_Nb>& set() {
+ this->_M_do_set();
+ this->_M_do_sanitize();
+ return *this;
+ }
+
+ bitset<_Nb>& set(size_t __pos) {
+ if (__pos >= _Nb)
+ __stl_throw_out_of_range("bitset");
+ return _Unchecked_set(__pos);
+ }
+
+ bitset<_Nb>& set(size_t __pos, int __val) {
+ if (__pos >= _Nb)
+ __stl_throw_out_of_range("bitset");
+ return _Unchecked_set(__pos, __val);
+ }
+
+ bitset<_Nb>& reset() {
+ this->_M_do_reset();
+ return *this;
+ }
+
+ bitset<_Nb>& reset(size_t __pos) {
+ if (__pos >= _Nb)
+ __stl_throw_out_of_range("bitset");
+
+ return _Unchecked_reset(__pos);
+ }
+
+ bitset<_Nb>& flip() {
+ this->_M_do_flip();
+ this->_M_do_sanitize();
+ return *this;
+ }
+
+ bitset<_Nb>& flip(size_t __pos) {
+ if (__pos >= _Nb)
+ __stl_throw_out_of_range("bitset");
+
+ return _Unchecked_flip(__pos);
+ }
+
+ bitset<_Nb> operator~() const {
+ return bitset<_Nb>(*this).flip();
+ }
+
+ // element access:
+ //for b[i];
+ reference operator[](size_t __pos) { return reference(*this,__pos); }
+ bool operator[](size_t __pos) const { return _Unchecked_test(__pos); }
+
+ unsigned long to_ulong() const { return this->_M_do_to_ulong(); }
+
+#if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS)
+ template <class _CharT, class _Traits, class _Alloc>
+ basic_string<_CharT, _Traits, _Alloc> to_string() const {
+ basic_string<_CharT, _Traits, _Alloc> __result;
+ _M_copy_to_string(__result);
+ return __result;
+ }
+#else
+ string to_string() const {
+ string __result;
+ _M_copy_to_string(__result);
+ return __result;
+ }
+#endif /* _STLP_EXPLICIT_FUNCTION_TMPL_ARGS */
+
+ size_t count() const { return this->_M_do_count(); }
+
+ size_t size() const { return _Nb; }
+
+ bool operator==(const bitset<_Nb>& __rhs) const {
+ return this->_M_is_equal(__rhs);
+ }
+ bool operator!=(const bitset<_Nb>& __rhs) const {
+ return !this->_M_is_equal(__rhs);
+ }
+
+ bool test(size_t __pos) const {
+ if (__pos >= _Nb)
+ __stl_throw_out_of_range("bitset");
+
+ return _Unchecked_test(__pos);
+ }
+
+ bool any() const { return this->_M_is_any(); }
+ bool none() const { return !this->_M_is_any(); }
+
+ bitset<_Nb> operator<<(size_t __pos) const {
+ bitset<_Nb> __result(*this);
+ __result <<= __pos ; return __result;
+ }
+ bitset<_Nb> operator>>(size_t __pos) const {
+ bitset<_Nb> __result(*this);
+ __result >>= __pos ; return __result;
+ }
+
+#if !defined (_STLP_NO_EXTENSIONS)
+ //
+ // EXTENSIONS: bit-find operations. These operations are
+ // experimental, and are subject to change or removal in future
+ // versions.
+ //
+
+ // find the index of the first "on" bit
+ size_t _Find_first() const
+ { return this->_M_do_find_first(_Nb); }
+
+ // find the index of the next "on" bit after prev
+ size_t _Find_next( size_t __prev ) const
+ { return this->_M_do_find_next(__prev, _Nb); }
+#endif
+
+//
+// Definitions of should-be non-inline member functions.
+//
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template<class _CharT, class _Traits, class _Alloc>
+ void _M_copy_from_string(const basic_string<_CharT,_Traits,_Alloc>& __s,
+ size_t __pos, size_t __n) {
+#else
+ void _M_copy_from_string(const string& __s,
+ size_t __pos, size_t __n) {
+ typedef typename string::traits_type _Traits;
+#endif
+ reset();
+ size_t __tmp = _Nb;
+ const size_t __Nbits = (min) (__tmp, (min) (__n, __s.size() - __pos));
+ for ( size_t __i= 0; __i < __Nbits; ++__i) {
+ typename _Traits::int_type __k = _Traits::to_int_type(__s[__pos + __Nbits - __i - 1]);
+ // boris : widen() ?
+ if (__k == '1')
+ set(__i);
+ else if (__k != '0')
+ __stl_throw_invalid_argument("bitset");
+ }
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _CharT, class _Traits, class _Alloc>
+ void _M_copy_to_string(basic_string<_CharT, _Traits, _Alloc>& __s) const
+#else
+ void _M_copy_to_string(string& __s) const
+#endif
+ {
+ __s.assign(_Nb, '0');
+
+ for (size_t __i = 0; __i < _Nb; ++__i) {
+ if (_Unchecked_test(__i))
+ __s[_Nb - 1 - __i] = '1';
+ }
+ }
+
+#if !defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_NO_WCHAR_T)
+ void _M_copy_to_string(wstring& __s) const {
+ __s.assign(_Nb, '0');
+
+ for (size_t __i = 0; __i < _Nb; ++__i) {
+ if (_Unchecked_test(__i))
+ __s[_Nb - 1 - __i] = '1';
+ }
+ }
+#endif
+
+#if defined (_STLP_NON_TYPE_TMPL_PARAM_BUG)
+ bitset<_Nb> operator&(const bitset<_Nb>& __y) const {
+ bitset<_Nb> __result(*this);
+ __result &= __y;
+ return __result;
+ }
+ bitset<_Nb> operator|(const bitset<_Nb>& __y) const {
+ bitset<_Nb> __result(*this);
+ __result |= __y;
+ return __result;
+ }
+ bitset<_Nb> operator^(const bitset<_Nb>& __y) const {
+ bitset<_Nb> __result(*this);
+ __result ^= __y;
+ return __result;
+ }
+#endif
+};
+
+// ------------------------------------------------------------
+//
+// 23.3.5.3 bitset operations:
+//
+#if ! defined (_STLP_NON_TYPE_TMPL_PARAM_BUG)
+template <size_t _Nb>
+inline bitset<_Nb> _STLP_CALL
+operator&(const bitset<_Nb>& __x,
+ const bitset<_Nb>& __y) {
+ bitset<_Nb> __result(__x);
+ __result &= __y;
+ return __result;
+}
+
+
+template <size_t _Nb>
+inline bitset<_Nb> _STLP_CALL
+operator|(const bitset<_Nb>& __x,
+ const bitset<_Nb>& __y) {
+ bitset<_Nb> __result(__x);
+ __result |= __y;
+ return __result;
+}
+
+template <size_t _Nb>
+inline bitset<_Nb> _STLP_CALL
+operator^(const bitset<_Nb>& __x,
+ const bitset<_Nb>& __y) {
+ bitset<_Nb> __result(__x);
+ __result ^= __y;
+ return __result;
+}
+
+#if !defined (_STLP_USE_NO_IOSTREAMS)
+
+_STLP_END_NAMESPACE
+
+# if !(defined (_STLP_MSVC) && (_STLP_MSVC < 1300)) && \
+ !(defined(__SUNPRO_CC) && (__SUNPRO_CC < 0x500))
+
+#ifndef _STLP_INTERNAL_IOSFWD
+# include <stl/_iosfwd.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _CharT, class _Traits, size_t _Nb>
+basic_istream<_CharT, _Traits>& _STLP_CALL
+operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x);
+
+template <class _CharT, class _Traits, size_t _Nb>
+basic_ostream<_CharT, _Traits>& _STLP_CALL
+operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Nb>& __x);
+
+# else
+
+#ifndef _STLP_STRING_IO_H
+# include <stl/_string_io.h> //includes _istream.h and _ostream.h
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <size_t _Nb>
+istream& _STLP_CALL
+operator>>(istream& __is, bitset<_Nb>& __x) {
+ typedef typename string::traits_type _Traits;
+ string __tmp;
+ __tmp.reserve(_Nb);
+
+ // Skip whitespace
+ typename istream::sentry __sentry(__is);
+ if (__sentry) {
+ streambuf* __buf = __is.rdbuf();
+ for (size_t __i = 0; __i < _Nb; ++__i) {
+ static typename _Traits::int_type __eof = _Traits::eof();
+
+ typename _Traits::int_type __c1 = __buf->sbumpc();
+ if (_Traits::eq_int_type(__c1, __eof)) {
+ __is.setstate(ios_base::eofbit);
+ break;
+ }
+ else {
+ typename _Traits::char_type __c2 = _Traits::to_char_type(__c1);
+ char __c = __is.narrow(__c2, '*');
+
+ if (__c == '0' || __c == '1')
+ __tmp.push_back(__c);
+ else if (_Traits::eq_int_type(__buf->sputbackc(__c2), __eof)) {
+ __is.setstate(ios_base::failbit);
+ break;
+ }
+ }
+ }
+
+ if (__tmp.empty())
+ __is.setstate(ios_base::failbit);
+ else
+ __x._M_copy_from_string(__tmp, __STATIC_CAST(size_t,0), _Nb);
+ }
+
+ return __is;
+}
+
+template <size_t _Nb>
+ostream& _STLP_CALL
+operator<<(ostream& __os, const bitset<_Nb>& __x) {
+ string __tmp;
+ __x._M_copy_to_string(__tmp);
+ return __os << __tmp;
+}
+
+# if !defined (_STLP_NO_WCHAR_T)
+
+template <size_t _Nb>
+wistream& _STLP_CALL
+operator>>(wistream& __is, bitset<_Nb>& __x) {
+ typedef typename wstring::traits_type _Traits;
+ wstring __tmp;
+ __tmp.reserve(_Nb);
+
+ // Skip whitespace
+ typename wistream::sentry __sentry(__is);
+ if (__sentry) {
+ wstreambuf* __buf = __is.rdbuf();
+ for (size_t __i = 0; __i < _Nb; ++__i) {
+ static typename _Traits::int_type __eof = _Traits::eof();
+
+ typename _Traits::int_type __c1 = __buf->sbumpc();
+ if (_Traits::eq_int_type(__c1, __eof)) {
+ __is.setstate(ios_base::eofbit);
+ break;
+ }
+ else {
+ typename _Traits::char_type __c2 = _Traits::to_char_type(__c1);
+ char __c = __is.narrow(__c2, '*');
+
+ if (__c == '0' || __c == '1')
+ __tmp.push_back(__c);
+ else if (_Traits::eq_int_type(__buf->sputbackc(__c2), __eof)) {
+ __is.setstate(ios_base::failbit);
+ break;
+ }
+ }
+ }
+
+ if (__tmp.empty())
+ __is.setstate(ios_base::failbit);
+ else
+ __x._M_copy_from_string(__tmp, __STATIC_CAST(size_t,0), _Nb);
+ }
+
+ return __is;
+}
+
+template <size_t _Nb>
+wostream& _STLP_CALL
+operator<<(wostream& __os, const bitset<_Nb>& __x) {
+ wstring __tmp;
+ __x._M_copy_to_string(__tmp);
+ return __os << __tmp;
+}
+
+# endif /* _STLP_NO_WCHAR_T */
+# endif
+#endif
+
+#endif /* _STLP_NON_TYPE_TMPL_PARAM_BUG */
+
+#undef bitset
+
+_STLP_END_NAMESPACE
+
+#undef __BITS_PER_WORD
+#undef __BITSET_WORDS
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_bitset.c>
+#endif
+
+#endif /* _STLP_BITSET_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_bvector.h b/sources/android/stlport/stlport/stl/_bvector.h
new file mode 100644
index 0000000..bf417f1
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_bvector.h
@@ -0,0 +1,841 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_BVECTOR_H
+#define _STLP_INTERNAL_BVECTOR_H
+
+#ifndef _STLP_INTERNAL_VECTOR_H
+# include <stl/_vector.h>
+#endif
+
+#define _STLP_WORD_BIT (int(CHAR_BIT * sizeof(unsigned int)))
+
+_STLP_BEGIN_NAMESPACE
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+struct _Bit_reference {
+ unsigned int* _M_p;
+ unsigned int _M_mask;
+ _Bit_reference(unsigned int* __x, unsigned int __y)
+ : _M_p(__x), _M_mask(__y) {}
+
+public:
+ _Bit_reference() : _M_p(0), _M_mask(0) {}
+
+ operator bool() const {
+ return !(!(*_M_p & _M_mask));
+ }
+ _Bit_reference& operator = (bool __x) {
+ if (__x) *_M_p |= _M_mask;
+ else *_M_p &= ~_M_mask;
+ return *this;
+ }
+ _Bit_reference& operator = (const _Bit_reference& __x) {
+ return *this = bool(__x);
+ }
+ bool operator == (const _Bit_reference& __x) const {
+ return bool(*this) == bool(__x);
+ }
+ bool operator < (const _Bit_reference& __x) const {
+ return !bool(*this) && bool(__x);
+ }
+
+ _Bit_reference& operator |= (bool __x) {
+ if (__x)
+ *_M_p |= _M_mask;
+ return *this;
+ }
+ _Bit_reference& operator &= (bool __x) {
+ if (!__x)
+ *_M_p &= ~_M_mask;
+ return *this;
+ }
+ void flip() { *_M_p ^= _M_mask; }
+};
+
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+inline void swap(_STLP_PRIV _Bit_reference& __x, _STLP_PRIV _Bit_reference& __y) {
+ bool __tmp = (bool)__x;
+ __x = __y;
+ __y = __tmp;
+}
+
+// Might not be very useful but costs nothing!
+_STLP_TEMPLATE_NULL
+struct __type_traits<_STLP_PRIV _Bit_reference> {
+ typedef __false_type has_trivial_default_constructor;
+ typedef __true_type has_trivial_copy_constructor;
+ typedef __false_type has_trivial_assignment_operator;
+ typedef __true_type has_trivial_destructor;
+ typedef __false_type is_POD_type;
+};
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+struct _Bit_iterator_base {
+ typedef ptrdiff_t difference_type;
+
+ unsigned int* _M_p;
+ unsigned int _M_offset;
+
+ void _M_bump_up() {
+ if (_M_offset++ == _STLP_WORD_BIT - 1) {
+ _M_offset = 0;
+ ++_M_p;
+ }
+ }
+
+ void _M_bump_down() {
+ if (_M_offset-- == 0) {
+ _M_offset = _STLP_WORD_BIT - 1;
+ --_M_p;
+ }
+ }
+
+ _Bit_iterator_base() : _M_p(0), _M_offset(0) {}
+ _Bit_iterator_base(unsigned int* __x, unsigned int __y) : _M_p(__x), _M_offset(__y) {}
+// see comment in doc/README.evc4 and doc/README.evc8
+#if defined(_MSC_VER) && _MSC_VER<=1401 && defined(MIPS) && defined(NDEBUG)
+ _Bit_iterator_base( const _Bit_iterator_base& __x) : _M_p(__x._M_p), _M_offset(__x._M_offset) {}
+#endif
+ // _Bit_iterator_base& operator = ( const _Bit_iterator_base& __x) { _M_p = __x._M_p ; _M_offset = __x._M_offset ; return *this; }
+
+ void _M_advance (difference_type __i) {
+ difference_type __n = __i + _M_offset;
+ _M_p += __n / _STLP_WORD_BIT;
+ __n = __n % _STLP_WORD_BIT;
+ if (__n < 0) {
+ _M_offset = (unsigned int) __n + _STLP_WORD_BIT;
+ --_M_p;
+ } else
+ _M_offset = (unsigned int) __n;
+ }
+
+ difference_type _M_subtract(const _Bit_iterator_base& __x) const {
+ return _STLP_WORD_BIT * (_M_p - __x._M_p) + _M_offset - __x._M_offset;
+ }
+};
+
+inline bool _STLP_CALL operator==(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) {
+ return __y._M_p == __x._M_p && __y._M_offset == __x._M_offset;
+}
+inline bool _STLP_CALL operator!=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) {
+ return __y._M_p != __x._M_p || __y._M_offset != __x._M_offset;
+}
+
+inline bool _STLP_CALL operator<(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) {
+ return __x._M_p < __y._M_p || (__x._M_p == __y._M_p && __x._M_offset < __y._M_offset);
+}
+
+inline bool _STLP_CALL operator>(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) {
+ return operator <(__y , __x);
+}
+inline bool _STLP_CALL operator<=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) {
+ return !(__y < __x);
+}
+inline bool _STLP_CALL operator>=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) {
+ return !(__x < __y);
+}
+
+template <class _Ref, class _Ptr>
+struct _Bit_iter : public _Bit_iterator_base {
+ typedef _Ref reference;
+ typedef _Ptr pointer;
+ typedef _Bit_iter<_Ref, _Ptr> _Self;
+ typedef random_access_iterator_tag iterator_category;
+ typedef bool value_type;
+ typedef ptrdiff_t difference_type;
+ typedef size_t size_type;
+
+ _Bit_iter(unsigned int* __x, unsigned int __y) : _Bit_iterator_base(__x, __y) {}
+ _Bit_iter() {}
+
+ _Bit_iter(const _Bit_iter<_Bit_reference, _Bit_reference*>& __x):
+ _Bit_iterator_base((const _Bit_iterator_base&)__x) {}
+
+ // _Self& operator = (const _Bit_iter<_Bit_reference, _Bit_reference*>& __x)
+ // { (_Bit_iterator_base&)*this = (const _Bit_iterator_base&)__x; return *this; }
+
+ reference operator*() const {
+ return _Bit_reference(_M_p, 1UL << _M_offset);
+ }
+ _Self& operator++() {
+ _M_bump_up();
+ return *this;
+ }
+ _Self operator++(int) {
+ _Self __tmp = *this;
+ _M_bump_up();
+ return __tmp;
+ }
+ _Self& operator--() {
+ _M_bump_down();
+ return *this;
+ }
+ _Self operator--(int) {
+ _Self __tmp = *this;
+ _M_bump_down();
+ return __tmp;
+ }
+ _Self& operator+=(difference_type __i) {
+ _M_advance(__i);
+ return *this;
+ }
+ _Self& operator-=(difference_type __i) {
+ *this += -__i;
+ return *this;
+ }
+ _Self operator+(difference_type __i) const {
+ _Self __tmp = *this;
+ return __tmp += __i;
+ }
+ _Self operator-(difference_type __i) const {
+ _Self __tmp = *this;
+ return __tmp -= __i;
+ }
+ difference_type operator-(const _Self& __x) const {
+ return _M_subtract(__x);
+ }
+ reference operator[](difference_type __i) { return *(*this + __i); }
+};
+
+template <class _Ref, class _Ptr>
+inline _Bit_iter<_Ref,_Ptr> _STLP_CALL
+operator+(ptrdiff_t __n, const _Bit_iter<_Ref, _Ptr>& __x) {
+ return __x + __n;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+template <class _Ref, class _Ptr>
+struct __type_traits< _STLP_PRIV _Bit_iter<_Ref, _Ptr> > {
+ typedef __false_type has_trivial_default_constructor;
+ typedef __true_type has_trivial_copy_constructor;
+ typedef __true_type has_trivial_assignment_operator;
+ typedef __true_type has_trivial_destructor;
+ typedef __false_type is_POD_type;
+};
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+#if defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
+inline random_access_iterator_tag iterator_category(const _STLP_PRIV _Bit_iterator_base&)
+{ return random_access_iterator_tag(); }
+inline ptrdiff_t* distance_type(const _STLP_PRIV _Bit_iterator_base&)
+{ return (ptrdiff_t*)0; }
+inline bool* value_type(const _STLP_PRIV _Bit_iter<_STLP_PRIV _Bit_reference, _STLP_PRIV _Bit_reference*>&)
+{ return (bool*)0; }
+inline bool* value_type(const _STLP_PRIV _Bit_iter<bool, const bool*>&)
+{ return (bool*)0; }
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+typedef _Bit_iter<bool, const bool*> _Bit_const_iterator;
+typedef _Bit_iter<_Bit_reference, _Bit_reference*> _Bit_iterator;
+
+// Bit-vector base class, which encapsulates the difference between
+// old SGI-style allocators and standard-conforming allocators.
+template <class _Alloc>
+class _Bvector_base {
+ typedef _Bvector_base<_Alloc> _Self;
+public:
+ _STLP_FORCE_ALLOCATORS(bool, _Alloc)
+ typedef _Alloc allocator_type;
+ typedef unsigned int __chunk_type;
+ typedef typename _Alloc_traits<__chunk_type, _Alloc>::allocator_type __chunk_allocator_type;
+ allocator_type get_allocator() const
+ { return _STLP_CONVERT_ALLOCATOR(__STATIC_CAST(const __chunk_allocator_type&, _M_end_of_storage), bool); }
+
+ _Bvector_base(const allocator_type& __a)
+ : _M_start(), _M_finish(), _M_end_of_storage(_STLP_CONVERT_ALLOCATOR(__a, __chunk_type),
+ (__chunk_type*)0)
+ {}
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ _Bvector_base(__move_source<_Self> src)
+ : _M_start(src.get()._M_start), _M_finish(src.get()._M_finish),
+ _M_end_of_storage(src.get()._M_end_of_storage) {
+ //Make the source destroyable
+ src.get()._M_start._M_p = 0;
+ }
+#endif
+
+ ~_Bvector_base() {
+ _M_deallocate();
+ }
+
+protected:
+
+ static size_t _M_bits_to_chunks(size_t __n_bits)
+ { return (__n_bits + _STLP_WORD_BIT - 1) / _STLP_WORD_BIT; }
+
+ __chunk_type* _M_bit_alloc(size_t __n)
+ { return _M_end_of_storage.allocate(_M_bits_to_chunks(__n)); }
+
+ void _M_deallocate() {
+ if (_M_start._M_p)
+ _M_end_of_storage.deallocate(_M_start._M_p,
+ _M_end_of_storage._M_data - _M_start._M_p);
+ }
+
+ _Bit_iterator _M_start;
+ _Bit_iterator _M_finish;
+ _STLP_alloc_proxy<__chunk_type*, __chunk_type, __chunk_allocator_type> _M_end_of_storage;
+};
+
+
+// The next few lines are confusing. What we're doing is declaring a
+// partial specialization of vector<T, Alloc> if we have the necessary
+// compiler support. Otherwise, we define a class bit_vector which uses
+// the default allocator.
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_BOOL) && !defined (__SUNPRO_CC)
+# define _STLP_VECBOOL_TEMPLATE
+# define __BVEC_TMPL_HEADER template <class _Alloc>
+#else
+# undef _STLP_VECBOOL_TEMPLATE
+# ifdef _STLP_NO_BOOL
+# define __BVEC_TMPL_HEADER
+# else
+# define __BVEC_TMPL_HEADER _STLP_TEMPLATE_NULL
+# endif
+# define _Alloc allocator<bool>
+#endif
+
+#if defined (_STLP_DEBUG)
+# define vector _STLP_NON_DBG_NAME(vector)
+#endif
+
+#ifdef _STLP_NO_BOOL
+# define __BVECTOR_QUALIFIED bit_vector
+# define __BVECTOR bit_vector
+#else
+# ifdef _STLP_VECBOOL_TEMPLATE
+# define __BVECTOR_QUALIFIED vector<bool, _Alloc>
+# else
+# define __BVECTOR_QUALIFIED vector<bool, allocator<bool> >
+# endif
+# if defined (_STLP_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS)
+# define __BVECTOR __BVECTOR_QUALIFIED
+# else
+# define __BVECTOR vector
+# endif
+#endif
+
+#if !defined (_STLP_DEBUG) || defined (_STLP_NO_BOOL)
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+__BVEC_TMPL_HEADER
+class __BVECTOR_QUALIFIED : public _STLP_PRIV _Bvector_base<_Alloc >
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_DEBUG)
+ , public __stlport_class< __BVECTOR_QUALIFIED >
+#endif
+{
+ typedef _STLP_PRIV _Bvector_base<_Alloc > _Base;
+ typedef __BVECTOR_QUALIFIED _Self;
+public:
+ typedef bool value_type;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef _STLP_PRIV _Bit_reference reference;
+ typedef bool const_reference;
+ typedef _STLP_PRIV _Bit_reference* pointer;
+ typedef const bool* const_pointer;
+ typedef random_access_iterator_tag _Iterator_category;
+
+ typedef _STLP_PRIV _Bit_iterator iterator;
+ typedef _STLP_PRIV _Bit_const_iterator const_iterator;
+
+ _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS;
+
+#ifdef _STLP_VECBOOL_TEMPLATE
+ typedef _STLP_TYPENAME _STLP_PRIV _Bvector_base<_Alloc >::allocator_type allocator_type;
+ typedef _STLP_TYPENAME _STLP_PRIV _Bvector_base<_Alloc >::__chunk_type __chunk_type;
+#else
+ typedef _STLP_PRIV _Bvector_base<_Alloc >::allocator_type allocator_type;
+ typedef _STLP_PRIV _Bvector_base<_Alloc >::__chunk_type __chunk_type;
+#endif
+
+protected:
+
+ void _M_initialize(size_type __n) {
+ __chunk_type* __q = this->_M_bit_alloc(__n);
+ this->_M_end_of_storage._M_data = __q + _Base::_M_bits_to_chunks(__n);
+ this->_M_start = iterator(__q, 0);
+ this->_M_finish = this->_M_start + difference_type(__n);
+ }
+ void _M_insert_aux(iterator __position, bool __x) {
+ if (this->_M_finish._M_p != this->_M_end_of_storage._M_data) {
+ _STLP_PRIV __copy_backward(__position, this->_M_finish, this->_M_finish + 1,
+ random_access_iterator_tag(), (difference_type*)0 );
+ *__position = __x;
+ ++this->_M_finish;
+ }
+ else {
+ size_type __len = size() ? 2 * size() : _STLP_WORD_BIT;
+ __chunk_type* __q = this->_M_bit_alloc(__len);
+ iterator __i = _STLP_STD::copy(begin(), __position, iterator(__q, 0));
+ *__i++ = __x;
+ this->_M_finish = _STLP_STD::copy(__position, end(), __i);
+ this->_M_deallocate();
+ this->_M_end_of_storage._M_data = __q + _Base::_M_bits_to_chunks(__len);
+ this->_M_start = iterator(__q, 0);
+ }
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void _M_initialize_range(_InputIterator __first, _InputIterator __last,
+ const input_iterator_tag &) {
+ this->_M_start = iterator();
+ this->_M_finish = iterator();
+ this->_M_end_of_storage._M_data = 0;
+ for ( ; __first != __last; ++__first)
+ push_back(*__first);
+ }
+
+ template <class _ForwardIterator>
+ void _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
+ const forward_iterator_tag &) {
+ size_type __n = _STLP_STD::distance(__first, __last);
+ _M_initialize(__n);
+ _STLP_STD::copy(__first, __last, this->_M_start);
+ }
+
+ template <class _InputIterator>
+ void _M_insert_range(iterator __pos,
+ _InputIterator __first, _InputIterator __last,
+ const input_iterator_tag &) {
+ for ( ; __first != __last; ++__first) {
+ __pos = insert(__pos, *__first);
+ ++__pos;
+ }
+ }
+
+ template <class _ForwardIterator>
+ void _M_insert_range(iterator __position,
+ _ForwardIterator __first, _ForwardIterator __last,
+ const forward_iterator_tag &) {
+ if (__first != __last) {
+ size_type __n = _STLP_STD::distance(__first, __last);
+ if (capacity() - size() >= __n) {
+ _STLP_PRIV __copy_backward(__position, end(), this->_M_finish + difference_type(__n),
+ random_access_iterator_tag(), (difference_type*)0 );
+ _STLP_STD::copy(__first, __last, __position);
+ this->_M_finish += difference_type(__n);
+ }
+ else {
+ size_type __len = size() + (max)(size(), __n);
+ __chunk_type* __q = this->_M_bit_alloc(__len);
+ iterator __i = _STLP_STD::copy(begin(), __position, iterator(__q, 0));
+ __i = _STLP_STD::copy(__first, __last, __i);
+ this->_M_finish = _STLP_STD::copy(__position, end(), __i);
+ this->_M_deallocate();
+ this->_M_end_of_storage._M_data = __q + _Base::_M_bits_to_chunks(__len);
+ this->_M_start = iterator(__q, 0);
+ }
+ }
+ }
+
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+public:
+ iterator begin() { return this->_M_start; }
+ const_iterator begin() const { return this->_M_start; }
+ iterator end() { return this->_M_finish; }
+ const_iterator end() const { return this->_M_finish; }
+
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ const_reverse_iterator rbegin() const {
+ return const_reverse_iterator(end());
+ }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+ const_reverse_iterator rend() const {
+ return const_reverse_iterator(begin());
+ }
+
+ size_type size() const { return size_type(end() - begin()); }
+ size_type max_size() const { return size_type(-1); }
+ size_type capacity() const {
+ return size_type(const_iterator(this->_M_end_of_storage._M_data, 0) - begin());
+ }
+ bool empty() const { return begin() == end(); }
+ reference operator[](size_type __n)
+ { return *(begin() + difference_type(__n)); }
+ const_reference operator[](size_type __n) const
+ { return *(begin() + difference_type(__n)); }
+
+ void _M_range_check(size_type __n) const {
+ if (__n >= this->size())
+ __stl_throw_range_error("vector<bool>");
+ }
+
+ reference at(size_type __n)
+ { _M_range_check(__n); return (*this)[__n]; }
+ const_reference at(size_type __n) const
+ { _M_range_check(__n); return (*this)[__n]; }
+
+ explicit __BVECTOR(const allocator_type& __a = allocator_type())
+ : _STLP_PRIV _Bvector_base<_Alloc >(__a) {}
+
+ __BVECTOR(size_type __n, bool __val,
+ const allocator_type& __a = allocator_type())
+ : _STLP_PRIV _Bvector_base<_Alloc >(__a) {
+ _M_initialize(__n);
+ fill(this->_M_start._M_p, (__chunk_type*)(this->_M_end_of_storage._M_data), __val ? ~0 : 0);
+ }
+
+ explicit __BVECTOR(size_type __n)
+ : _STLP_PRIV _Bvector_base<_Alloc >(allocator_type()) {
+ _M_initialize(__n);
+ fill(this->_M_start._M_p, (__chunk_type*)(this->_M_end_of_storage._M_data), 0);
+ }
+
+ __BVECTOR(const _Self& __x)
+ : _STLP_PRIV _Bvector_base<_Alloc >(__x.get_allocator()) {
+ _M_initialize(__x.size());
+ _STLP_STD::copy(__x.begin(), __x.end(), this->_M_start);
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _Integer>
+ void _M_initialize_dispatch(_Integer __n, _Integer __x, const __true_type&) {
+ _M_initialize(__n);
+ fill(this->_M_start._M_p, this->_M_end_of_storage._M_data, __x ? ~0 : 0);
+ }
+
+ template <class _InputIterator>
+ void _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+ const __false_type&) {
+ _M_initialize_range(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIterator));
+ }
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ // Check whether it's an integral type. If so, it's not an iterator.
+ template <class _InputIterator>
+ __BVECTOR(_InputIterator __first, _InputIterator __last)
+ : _STLP_PRIV _Bvector_base<_Alloc >(allocator_type()) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_initialize_dispatch(__first, __last, _Integral());
+ }
+# endif
+ template <class _InputIterator>
+ __BVECTOR(_InputIterator __first, _InputIterator __last,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _STLP_PRIV _Bvector_base<_Alloc >(__a) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_initialize_dispatch(__first, __last, _Integral());
+ }
+#else /* _STLP_MEMBER_TEMPLATES */
+ __BVECTOR(const_iterator __first, const_iterator __last,
+ const allocator_type& __a = allocator_type())
+ : _STLP_PRIV _Bvector_base<_Alloc >(__a) {
+ size_type __n = _STLP_STD::distance(__first, __last);
+ _M_initialize(__n);
+ _STLP_STD::copy(__first, __last, this->_M_start);
+ }
+ __BVECTOR(const bool* __first, const bool* __last,
+ const allocator_type& __a = allocator_type())
+ : _STLP_PRIV _Bvector_base<_Alloc >(__a) {
+ size_type __n = _STLP_STD::distance(__first, __last);
+ _M_initialize(__n);
+ _STLP_STD::copy(__first, __last, this->_M_start);
+ }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ __BVECTOR(__move_source<_Self> src)
+ : _STLP_PRIV _Bvector_base<_Alloc >(__move_source<_Base>(src.get())) {}
+#endif
+
+ ~__BVECTOR() {}
+
+ __BVECTOR_QUALIFIED& operator=(const __BVECTOR_QUALIFIED& __x) {
+ if (&__x == this) return *this;
+ if (__x.size() > capacity()) {
+ this->_M_deallocate();
+ _M_initialize(__x.size());
+ }
+ _STLP_STD::copy(__x.begin(), __x.end(), begin());
+ this->_M_finish = begin() + difference_type(__x.size());
+ return *this;
+ }
+
+ // assign(), a generalized assignment member function. Two
+ // versions: one that takes a count, and one that takes a range.
+ // The range version is a member template, so we dispatch on whether
+ // or not the type is an integer.
+
+ void _M_fill_assign(size_t __n, bool __x) {
+ if (__n > size()) {
+ fill(this->_M_start._M_p, (__chunk_type*)(this->_M_end_of_storage._M_data), __x ? ~0 : 0);
+ insert(end(), __n - size(), __x);
+ }
+ else {
+ erase(begin() + __n, end());
+ fill(this->_M_start._M_p, (__chunk_type*)(this->_M_end_of_storage._M_data), __x ? ~0 : 0);
+ }
+ }
+ void assign(size_t __n, bool __x) { _M_fill_assign(__n, __x); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void assign(_InputIterator __first, _InputIterator __last) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_assign_dispatch(__first, __last, _Integral());
+ }
+
+ template <class _Integer>
+ void _M_assign_dispatch(_Integer __n, _Integer __val, const __true_type&)
+ { _M_fill_assign((size_t) __n, (bool) __val); }
+
+ template <class _InputIter>
+ void _M_assign_dispatch(_InputIter __first, _InputIter __last, const __false_type&)
+ { _M_assign_aux(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIter)); }
+
+ template <class _InputIterator>
+ void _M_assign_aux(_InputIterator __first, _InputIterator __last,
+ const input_iterator_tag &) {
+ iterator __cur = begin();
+ for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
+ *__cur = *__first;
+ if (__first == __last)
+ erase(__cur, end());
+ else
+ insert(end(), __first, __last);
+ }
+
+ template <class _ForwardIterator>
+ void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+ const forward_iterator_tag &) {
+ size_type __len = _STLP_STD::distance(__first, __last);
+ if (__len < size())
+ erase(_STLP_STD::copy(__first, __last, begin()), end());
+ else {
+ _ForwardIterator __mid = __first;
+ _STLP_STD::advance(__mid, size());
+ _STLP_STD::copy(__first, __mid, begin());
+ insert(end(), __mid, __last);
+ }
+ }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ void reserve(size_type __n) {
+ if (capacity() < __n) {
+ if (max_size() < __n)
+ __stl_throw_length_error("vector<bool>");
+ __chunk_type* __q = this->_M_bit_alloc(__n);
+ _STLP_PRIV _Bit_iterator __z(__q, 0);
+ this->_M_finish = _STLP_STD::copy(begin(), end(), __z);
+ this->_M_deallocate();
+ this->_M_start = iterator(__q, 0);
+ this->_M_end_of_storage._M_data = __q + _Base::_M_bits_to_chunks(__n);
+ }
+ }
+
+ reference front() { return *begin(); }
+ const_reference front() const { return *begin(); }
+ reference back() { return *(end() - 1); }
+ const_reference back() const { return *(end() - 1); }
+ void push_back(bool __x) {
+ if (this->_M_finish._M_p != this->_M_end_of_storage._M_data) {
+ *(this->_M_finish) = __x;
+ ++this->_M_finish;
+ }
+ else
+ _M_insert_aux(end(), __x);
+ }
+ void swap(__BVECTOR_QUALIFIED& __x) {
+ _STLP_STD::swap(this->_M_start, __x._M_start);
+ _STLP_STD::swap(this->_M_finish, __x._M_finish);
+ this->_M_end_of_storage.swap(__x._M_end_of_storage);
+ }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(__BVECTOR_QUALIFIED& __x) { swap(__x); }
+#endif
+
+ iterator insert(iterator __position, bool __x = bool()) {
+ difference_type __n = __position - begin();
+ if (this->_M_finish._M_p != this->_M_end_of_storage._M_data && __position == end()) {
+ *(this->_M_finish) = __x;
+ ++this->_M_finish;
+ }
+ else
+ _M_insert_aux(__position, __x);
+ return begin() + __n;
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+
+ template <class _Integer>
+ void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
+ const __true_type&) {
+ _M_fill_insert(__pos, (size_type) __n, (bool) __x);
+ }
+
+ template <class _InputIterator>
+ void _M_insert_dispatch(iterator __pos,
+ _InputIterator __first, _InputIterator __last,
+ const __false_type&) {
+ _M_insert_range(__pos, __first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIterator));
+ }
+
+ // Check whether it's an integral type. If so, it's not an iterator.
+ template <class _InputIterator>
+ void insert(iterator __position,
+ _InputIterator __first, _InputIterator __last) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_insert_dispatch(__position, __first, __last, _Integral());
+ }
+#else /* _STLP_MEMBER_TEMPLATES */
+ void insert(iterator __position,
+ const_iterator __first, const_iterator __last) {
+ if (__first == __last) return;
+ size_type __n = _STLP_STD::distance(__first, __last);
+ if (capacity() - size() >= __n) {
+ _STLP_PRIV __copy_backward(__position, end(), this->_M_finish + __n,
+ random_access_iterator_tag(), (difference_type*)0 );
+ _STLP_STD::copy(__first, __last, __position);
+ this->_M_finish += __n;
+ }
+ else {
+ size_type __len = size() + (max)(size(), __n);
+ __chunk_type* __q = this->_M_bit_alloc(__len);
+ iterator __i = _STLP_STD::copy(begin(), __position, iterator(__q, 0));
+ __i = _STLP_STD::copy(__first, __last, __i);
+ this->_M_finish = _STLP_STD::copy(__position, end(), __i);
+ this->_M_deallocate();
+ this->_M_end_of_storage._M_data = __q + _Base::_M_bits_to_chunks(__len);
+ this->_M_start = iterator(__q, 0);
+ }
+ }
+
+ void insert(iterator __position, const bool* __first, const bool* __last) {
+ if (__first == __last) return;
+ size_type __n = _STLP_STD::distance(__first, __last);
+ if (capacity() - size() >= __n) {
+ _STLP_PRIV __copy_backward(__position, end(), this->_M_finish + __n,
+ random_access_iterator_tag(), (difference_type*)0 );
+ _STLP_STD::copy(__first, __last, __position);
+ this->_M_finish += __n;
+ }
+ else {
+ size_type __len = size() + (max)(size(), __n);
+ __chunk_type* __q = this->_M_bit_alloc(__len);
+ iterator __i = _STLP_STD::copy(begin(), __position, iterator(__q, 0));
+ __i = _STLP_STD::copy(__first, __last, __i);
+ this->_M_finish = _STLP_STD::copy(__position, end(), __i);
+ this->_M_deallocate();
+ this->_M_end_of_storage._M_data = __q + _Base::_M_bits_to_chunks(__len);
+ this->_M_start = iterator(__q, 0);
+ }
+ }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ void _M_fill_insert(iterator __position, size_type __n, bool __x) {
+ if (__n == 0) return;
+ if (capacity() - size() >= __n) {
+ _STLP_PRIV __copy_backward(__position, end(), this->_M_finish + difference_type(__n),
+ random_access_iterator_tag(), (difference_type*)0 );
+ fill(__position, __position + difference_type(__n), __x);
+ this->_M_finish += difference_type(__n);
+ }
+ else {
+ size_type __len = size() + (max)(size(), __n);
+ __chunk_type* __q = this->_M_bit_alloc(__len);
+ iterator __i = _STLP_STD::copy(begin(), __position, iterator(__q, 0));
+ fill_n(__i, __n, __x);
+ this->_M_finish = _STLP_STD::copy(__position, end(), __i + difference_type(__n));
+ this->_M_deallocate();
+ this->_M_end_of_storage._M_data = __q + _Base::_M_bits_to_chunks(__len);
+ this->_M_start = iterator(__q, 0);
+ }
+ }
+
+ void insert(iterator __position, size_type __n, bool __x) {
+ _M_fill_insert(__position, __n, __x);
+ }
+
+ void pop_back() {
+ --this->_M_finish;
+ }
+ iterator erase(iterator __position) {
+ if (__position + 1 != end())
+ _STLP_STD::copy(__position + 1, end(), __position);
+ --this->_M_finish;
+ return __position;
+ }
+ iterator erase(iterator __first, iterator __last) {
+ this->_M_finish = _STLP_STD::copy(__last, end(), __first);
+ return __first;
+ }
+ void resize(size_type __new_size, bool __x = bool()) {
+ if (__new_size < size())
+ erase(begin() + difference_type(__new_size), end());
+ else
+ insert(end(), __new_size - size(), __x);
+ }
+ void flip() {
+ for (__chunk_type* __p = this->_M_start._M_p; __p != this->_M_end_of_storage._M_data; ++__p)
+ *__p = ~*__p;
+ }
+
+ void clear() { erase(begin(), end()); }
+};
+
+#if defined (_STLP_NO_BOOL) || defined (__HP_aCC) // fixed soon (03/17/2000)
+# define _STLP_TEMPLATE_HEADER __BVEC_TMPL_HEADER
+# define _STLP_TEMPLATE_CONTAINER __BVECTOR_QUALIFIED
+# include <stl/_relops_cont.h>
+# undef _STLP_TEMPLATE_CONTAINER
+# undef _STLP_TEMPLATE_HEADER
+#endif /* NO_BOOL */
+
+#if defined (_STLP_DEBUG) && !defined (_STLP_NO_BOOL)
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+_STLP_END_NAMESPACE
+
+#undef vector
+#undef _Alloc
+#undef _STLP_VECBOOL_TEMPLATE
+#undef __BVECTOR
+#undef __BVECTOR_QUALIFIED
+#undef __BVEC_TMPL_HEADER
+
+#undef _STLP_WORD_BIT
+
+#endif /* _STLP_INTERNAL_BVECTOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_carray.h b/sources/android/stlport/stlport/stl/_carray.h
new file mode 100644
index 0000000..560bab2
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_carray.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2005
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_CARRAY_H
+#define _STLP_CARRAY_H
+
+/* Purpose: Mimic a pur C array with the additionnal feature of
+ * being able to be used with type not default constructible.
+ */
+
+#ifndef _STLP_INTERNAL_CONSTRUCT_H
+# include <stl/_construct.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp, size_t _Nb>
+struct _CArray {
+ _CArray (const _Tp& __val) {
+ for (size_t __i = 0; __i < _Nb; ++__i) {
+ _Copy_Construct(__REINTERPRET_CAST(_Tp*, _M_data + __i * sizeof(_Tp)), __val);
+ }
+ }
+
+ ~_CArray() {
+ _Destroy_Range(__REINTERPRET_CAST(_Tp*, _M_data + 0),
+ __REINTERPRET_CAST(_Tp*, _M_data + _Nb * sizeof(_Tp)));
+ }
+
+ _Tp& operator [] (size_t __i) {
+ _STLP_ASSERT(__i < _Nb)
+ return *__REINTERPRET_CAST(_Tp*, _M_data + __i * sizeof(_Tp));
+ }
+
+private:
+ char _M_data[sizeof(_Tp) * _Nb];
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif //_STLP_CARRAY_H
diff --git a/sources/android/stlport/stlport/stl/_cctype.h b/sources/android/stlport/stlport/stl/_cctype.h
new file mode 100644
index 0000000..cf82524
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_cctype.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_CCTYPE
+#define _STLP_INTERNAL_CCTYPE
+
+#if defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cctype>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cctype)
+# endif
+#else
+# include <ctype.h>
+#endif /* _STLP_USE_NEW_C_HEADERS */
+
+#if ! defined (_STLP_NO_CSTD_FUNCTION_IMPORTS)
+# if defined ( _STLP_IMPORT_VENDOR_CSTD )
+_STLP_BEGIN_NAMESPACE
+using _STLP_VENDOR_CSTD::isalnum;
+using _STLP_VENDOR_CSTD::isalpha;
+using _STLP_VENDOR_CSTD::iscntrl;
+using _STLP_VENDOR_CSTD::isdigit;
+using _STLP_VENDOR_CSTD::isgraph;
+using _STLP_VENDOR_CSTD::islower;
+using _STLP_VENDOR_CSTD::isprint;
+using _STLP_VENDOR_CSTD::ispunct;
+using _STLP_VENDOR_CSTD::isspace;
+using _STLP_VENDOR_CSTD::isupper;
+using _STLP_VENDOR_CSTD::isxdigit;
+using _STLP_VENDOR_CSTD::tolower;
+using _STLP_VENDOR_CSTD::toupper;
+_STLP_END_NAMESPACE
+# endif /* _STLP_IMPORT_VENDOR_CSTD*/
+#endif /* _STLP_NO_CSTD_FUNCTION_IMPORTS */
+
+#endif
diff --git a/sources/android/stlport/stlport/stl/_clocale.h b/sources/android/stlport/stlport/stl/_clocale.h
new file mode 100644
index 0000000..2dcf39a
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_clocale.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_CLOCALE
+#define _STLP_INTERNAL_CLOCALE
+
+#if !defined (_STLP_WCE_EVC3)
+
+# if defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <clocale>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(clocale)
+# endif
+# else
+# include <locale.h>
+# endif
+
+# if defined (_STLP_IMPORT_VENDOR_CSTD)
+_STLP_BEGIN_NAMESPACE
+using _STLP_VENDOR_CSTD::lconv;
+# if !defined (_STLP_NO_CSTD_FUNCTION_IMPORTS) && !defined(__ANDROID__)
+using _STLP_VENDOR_CSTD::localeconv;
+using _STLP_VENDOR_CSTD::setlocale;
+# endif
+_STLP_END_NAMESPACE
+# endif
+
+#endif /* !_STLP_WCE_EVC3 */
+
+#endif
diff --git a/sources/android/stlport/stlport/stl/_cmath.h b/sources/android/stlport/stlport/stl/_cmath.h
new file mode 100644
index 0000000..2867c23
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_cmath.h
@@ -0,0 +1,605 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_CMATH
+#define _STLP_INTERNAL_CMATH
+
+/* gcc do not like when a using directive appear after a function
+ * declaration. cmath have abs overloads and cstdlib a using directive
+ * so cstdlib has to be included first.
+ */
+#if defined (__GNUC__) && defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cstdlib>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cstdlib)
+# endif
+#endif
+
+#if defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_NO_NAMESPACES) && !defined (exception)
+# define exception __math_exception
+# endif
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cmath>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cmath)
+# endif
+# if defined (_STLP_HAS_NO_NAMESPACES)
+# undef exception
+# endif
+#else
+# include <math.h>
+#endif
+
+#if (defined (__SUNPRO_CC) && (__SUNPRO_CC > 0x500)) || \
+ !(defined (__IBMCPP__) && (__IBMCPP__ >= 500) || !(defined(__HP_aCC) && (__HP_aCC >= 30000) ))
+# if !defined(_STLP_HAS_NO_NAMESPACES) && !defined(__SUNPRO_CC)
+// All the other hypot stuff is going to be at file scope, so follow along here.
+namespace std {
+# endif
+extern "C" double hypot(double x, double y);
+# if !defined(_STLP_HAS_NO_NAMESPACES) && !defined(__SUNPRO_CC)
+}
+# endif
+
+#endif
+
+#if defined (__sun) && defined (__GNUC__)
+extern "C" {
+ float __cosf(float v);
+ float __sinf(float v);
+ float __atan2f(float, float);
+ float __coshf(float v);
+ float __sinhf(float v);
+ float __sqrtf(float v);
+ float __expf(float v);
+ float __logf(float v);
+ float __log10f(float v);
+
+ long double __cosl(long double v);
+ long double __sinl(long double v);
+ long double __atan2l(long double, long double);
+ long double __coshl(long double v);
+ long double __sinhl(long double v);
+ long double __sqrtl(long double v);
+ long double __expl(long double v);
+ long double __logl(long double v);
+ long double __log10l(long double v);
+}
+
+extern "C" {
+ inline float cosf(float v) { return __cosf(v); }
+ inline float sinf(float v) { return __sinf(v); }
+ inline float atan2f(float v1, float v2) { return __atan2f(v1,v2); }
+ inline float coshf(float v) { return __coshf(v); }
+ inline float sinhf(float v) { return __sinhf(v); }
+ inline float sqrtf(float v) { return __sqrtf(v); }
+ inline float expf(float v) { return __expf(v); }
+ inline float logf(float v) { return __logf(v); }
+ inline float log10f(float v) { return __log10f(v); }
+
+ inline long double cosl(long double v) { return __cosl(v); }
+ inline long double sinl(long double v) { return __sinl(v); }
+ inline long double atan2l(long double v1, long double v2) { return __atan2l(v1,v2); }
+ inline long double coshl(long double v) { return __coshl(v); }
+ inline long double sinhl(long double v) { return __sinhl(v); }
+ inline long double sqrtl(long double v) { return __sqrtl(v); }
+ inline long double expl(long double v) { return __expl(v); }
+ inline long double logl(long double v) { return __logl(v); }
+ inline long double log10l(long double v) { return __log10l(v); }
+}
+#endif // __sun && __GNUC__
+
+#if defined (__sun)
+extern "C" {
+extern float __acosf(float);
+extern float __asinf(float);
+extern float __atanf(float);
+extern float __atan2f(float, float);
+extern float __ceilf(float);
+extern float __cosf(float);
+extern float __coshf(float);
+extern float __expf(float);
+extern float __fabsf(float);
+extern float __floorf(float);
+extern float __fmodf(float, float);
+extern float __frexpf(float, int *);
+extern float __ldexpf(float, int);
+extern float __logf(float);
+extern float __log10f(float);
+extern float __modff(float, float *);
+extern float __powf(float, float);
+extern float __sinf(float);
+extern float __sinhf(float);
+extern float __sqrtf(float);
+extern float __tanf(float);
+extern float __tanhf(float);
+
+extern long double __acosl(long double);
+extern long double __asinl(long double);
+extern long double __atanl(long double);
+extern long double __atan2l(long double, long double);
+extern long double __ceill(long double);
+extern long double __cosl(long double);
+extern long double __coshl(long double);
+extern long double __expl(long double);
+extern long double __fabsl(long double);
+extern long double __floorl(long double);
+extern long double __fmodl(long double, long double);
+extern long double __frexpl(long double, int *);
+extern long double __ldexpl(long double, int);
+extern long double __logl(long double);
+extern long double __log10l(long double);
+extern long double __modfl(long double, long double *);
+extern long double __powl(long double, long double);
+extern long double __sinl(long double);
+extern long double __sinhl(long double);
+extern long double __sqrtl(long double);
+extern long double __tanl(long double);
+extern long double __tanhl(long double);
+}
+#endif
+
+#if defined (__BORLANDC__)
+# define _STLP_CMATH_FUNC_NAMESPACE _STLP_VENDOR_CSTD
+#else
+# define _STLP_CMATH_FUNC_NAMESPACE
+#endif
+
+#if !defined (__sun) || defined (__GNUC__)
+# define _STLP_MATH_INLINE(float_type, func, cfunc) \
+ inline float_type func (float_type x) { return _STLP_CMATH_FUNC_NAMESPACE::cfunc(x); }
+# define _STLP_MATH_INLINE2(float_type, type, func, cfunc) \
+ inline float_type func (float_type x, type y) { return _STLP_CMATH_FUNC_NAMESPACE::cfunc(x, y); }
+# define _STLP_MATH_INLINE_D(float_type, func, cfunc)
+# define _STLP_MATH_INLINE2_D(float_type, type, func, cfunc)
+#else
+# ifdef __SUNPRO_CC
+# define _STLP_MATH_INLINE(float_type, func, cfunc) \
+ inline float_type func (float_type x) { return _STLP_VENDOR_CSTD::__##cfunc(x); }
+# define _STLP_MATH_INLINE_D(float_type, func, cfunc) \
+ inline float_type func (float_type x) { return _STLP_VENDOR_CSTD::cfunc(x); }
+# define _STLP_MATH_INLINE2(float_type, type, func, cfunc) \
+ inline float_type func (float_type x, type y) { return _STLP_VENDOR_CSTD::__##cfunc(x,y); }
+# define _STLP_MATH_INLINE2_D(float_type, type, func, cfunc) \
+ inline float_type func (float_type x, type y) { return _STLP_VENDOR_CSTD::cfunc(x,y); }
+# else
+# error Unknown compiler for the Sun platform
+# endif
+#endif
+
+/** macros to define math functions
+These macros (having an X somewhere in the name) forward to the C library's
+double functions but cast the arguments and return values to the given type. */
+
+#define _STLP_MATH_INLINEX(__type,func,cfunc) \
+ inline __type func (__type x) \
+ { return __STATIC_CAST(__type, _STLP_CMATH_FUNC_NAMESPACE::cfunc((double)x)); }
+#define _STLP_MATH_INLINE2X(__type1,__type2,func,cfunc) \
+ inline __type1 func (__type1 x, __type2 y) \
+ { return __STATIC_CAST(__type1, _STLP_CMATH_FUNC_NAMESPACE::cfunc((double)x, y)); }
+#define _STLP_MATH_INLINE2PX(__type,func,cfunc) \
+ inline __type func (__type x, __type *y) { \
+ double tmp1, tmp2; \
+ tmp1 = _STLP_CMATH_FUNC_NAMESPACE::cfunc(__STATIC_CAST(double, x), &tmp2); \
+ *y = __STATIC_CAST(__type, tmp2); \
+ return __STATIC_CAST(__type, tmp1); \
+ }
+#define _STLP_MATH_INLINE2XX(__type,func,cfunc) \
+ inline __type func (__type x, __type y) \
+ { return __STATIC_CAST(__type, _STLP_CMATH_FUNC_NAMESPACE::cfunc((double)x, (double)y)); }
+
+
+/** rough characterization of compiler and native C library
+For the compiler, it can either support long double or not. If it doesn't, the
+macro _STLP_NO_LONG_DOUBLE is not defined and we don't define any long double
+overloads.
+For the native C library the question is whether it has variants with an 'f'
+suffix (for float as opposed to double) or an 'l' suffix (for long double). If
+the float variants are missing, _STLP_NO_VENDOR_MATH_F is defined, when the
+long double variants are missing, _STLP_NO_VENDOR_MATH_L is defined. Of course
+the latter doesn't make sense anyway when the compiler already has no long
+double support.
+
+Those two traits determine a) which overloads get defined and b) how they are
+defined.
+
+Meaning of suffixes:
+"" : function returning and taking a float_type
+"2" : function returning a float_type and taking to float_types
+"2P" : function returning a float_type and taking a float_type and a float_type*
+"2PI": function returning a float_type and taking a float_type and an int*
+"2I" : function returning a float_type and taking a float_Type and an int
+*/
+
+#if !defined (_STLP_NO_LONG_DOUBLE) && !defined (_STLP_NO_VENDOR_MATH_L) && !defined (_STLP_NO_VENDOR_MATH_F)
+ // long double support and both e.g. sinl(long double) and sinf(float)
+ // This is the default for a correct and complete native library.
+# define _STLP_DEF_MATH_INLINE(func,cf) \
+ _STLP_MATH_INLINE(float,func,cf##f) \
+ _STLP_MATH_INLINE_D(double,func,cf) \
+ _STLP_MATH_INLINE(long double,func,cf##l)
+# define _STLP_DEF_MATH_INLINE2(func,cf) \
+ _STLP_MATH_INLINE2(float,float,func,cf##f) \
+ _STLP_MATH_INLINE2_D(double,double,func,cf) \
+ _STLP_MATH_INLINE2(long double,long double,func,cf##l)
+# define _STLP_DEF_MATH_INLINE2P(func,cf) \
+ _STLP_MATH_INLINE2(float,float *,func,cf##f) \
+ _STLP_MATH_INLINE2_D(double,double *,func,cf) \
+ _STLP_MATH_INLINE2(long double,long double *,func,cf##l)
+# define _STLP_DEF_MATH_INLINE2PI(func,cf) \
+ _STLP_MATH_INLINE2(float,int *,func,cf##f) \
+ _STLP_MATH_INLINE2_D(double,int *,func,cf) \
+ _STLP_MATH_INLINE2(long double,int *,func,cf##l)
+# define _STLP_DEF_MATH_INLINE2I(func,cf) \
+ _STLP_MATH_INLINE2(float,int,func,cf##f) \
+ _STLP_MATH_INLINE2_D(double,int,func,cf) \
+ _STLP_MATH_INLINE2(long double,int,func,cf##l)
+#else
+# if !defined (_STLP_NO_LONG_DOUBLE)
+# if !defined (_STLP_NO_VENDOR_MATH_F)
+ // long double support and e.g. sinf(float) but not e.g. sinl(long double)
+# define _STLP_DEF_MATH_INLINE(func,cf) \
+ _STLP_MATH_INLINE(float,func,cf##f) \
+ _STLP_MATH_INLINEX(long double,func,cf)
+# define _STLP_DEF_MATH_INLINE2(func,cf) \
+ _STLP_MATH_INLINE2(float,float,func,cf##f) \
+ _STLP_MATH_INLINE2XX(long double,func,cf)
+# define _STLP_DEF_MATH_INLINE2P(func,cf) \
+ _STLP_MATH_INLINE2(float,float *,func,cf##f) \
+ _STLP_MATH_INLINE2PX(long double,func,cf)
+# define _STLP_DEF_MATH_INLINE2PI(func,cf) \
+ _STLP_MATH_INLINE2(float,int *,func,cf##f) \
+ _STLP_MATH_INLINE2X(long double,int *,func,cf)
+# define _STLP_DEF_MATH_INLINE2I(func,cf) \
+ _STLP_MATH_INLINE2(float,int,func,cf##f) \
+ _STLP_MATH_INLINE2X(long double,int,func,cf)
+# elif !defined (_STLP_NO_VENDOR_MATH_L)
+ // long double support and e.g. sinl(long double) but not e.g. sinf(float)
+# define _STLP_DEF_MATH_INLINE(func,cf) \
+ _STLP_MATH_INLINEX(float,func,cf) \
+ _STLP_MATH_INLINE(long double,func,cf##l)
+# define _STLP_DEF_MATH_INLINE2(func,cf) \
+ _STLP_MATH_INLINE2XX(float,func,cf) \
+ _STLP_MATH_INLINE2(long double,long double,func,cf##l)
+# define _STLP_DEF_MATH_INLINE2P(func,cf) \
+ _STLP_MATH_INLINE2PX(float,func,cf) \
+ _STLP_MATH_INLINE2(long double,long double *,func,cf##l)
+# define _STLP_DEF_MATH_INLINE2PI(func,cf) \
+ _STLP_MATH_INLINE2X(float,int *,func,cf) \
+ _STLP_MATH_INLINE2(long double,int *,func,cf##l)
+# define _STLP_DEF_MATH_INLINE2I(func,cf) \
+ _STLP_MATH_INLINE2X(float,int,func,cf) \
+ _STLP_MATH_INLINE2(long double,int,func,cf##l)
+# else
+# define _STLP_DEF_MATH_INLINE(func,cf) \
+ _STLP_MATH_INLINEX(float,func,cf) \
+ _STLP_MATH_INLINEX(long double,func,cf)
+# define _STLP_DEF_MATH_INLINE2(func,cf) \
+ _STLP_MATH_INLINE2XX(float,func,cf) \
+ _STLP_MATH_INLINE2XX(long double,func,cf)
+# define _STLP_DEF_MATH_INLINE2P(func,cf) \
+ _STLP_MATH_INLINE2PX(float,func,cf) \
+ _STLP_MATH_INLINE2PX(long double,func,cf)
+# define _STLP_DEF_MATH_INLINE2PI(func,cf) \
+ _STLP_MATH_INLINE2X(float,int *,func,cf) \
+ _STLP_MATH_INLINE2X(long double,int *,func,cf)
+# define _STLP_DEF_MATH_INLINE2I(func,cf) \
+ _STLP_MATH_INLINE2X(float,int,func,cf) \
+ _STLP_MATH_INLINE2X(long double,int,func,cf)
+# endif
+# else
+# if !defined (_STLP_NO_VENDOR_MATH_F)
+# define _STLP_DEF_MATH_INLINE(func,cf) \
+ _STLP_MATH_INLINE(float,func,cf##f)
+# define _STLP_DEF_MATH_INLINE2(func,cf) \
+ _STLP_MATH_INLINE2(float,float,func,cf##f)
+# define _STLP_DEF_MATH_INLINE2P(func,cf) \
+ _STLP_MATH_INLINE2(float,float *,func,cf##f)
+# define _STLP_DEF_MATH_INLINE2PI(func,cf) \
+ _STLP_MATH_INLINE2(float,int *,func,cf##f)
+# define _STLP_DEF_MATH_INLINE2I(func,cf) \
+ _STLP_MATH_INLINE2(float,int,func,cf##f)
+# else // _STLP_NO_VENDOR_MATH_F
+ // neither long double support nor e.g. sinf(float) functions
+# define _STLP_DEF_MATH_INLINE(func,cf) \
+ _STLP_MATH_INLINEX(float,func,cf)
+# define _STLP_DEF_MATH_INLINE2(func,cf) \
+ _STLP_MATH_INLINE2XX(float,func,cf)
+# define _STLP_DEF_MATH_INLINE2P(func,cf) \
+ _STLP_MATH_INLINE2PX(float,func,cf)
+# define _STLP_DEF_MATH_INLINE2PI(func,cf) \
+ _STLP_MATH_INLINE2X(float,int *,func,cf)
+# define _STLP_DEF_MATH_INLINE2I(func,cf) \
+ _STLP_MATH_INLINE2X(float,int,func,cf)
+# endif // _STLP_NO_VENDOR_MATH_F
+# endif
+#endif
+
+#if defined (_STLP_WCE) || \
+ (defined(_STLP_MSVC) && (_STLP_MSVC <= 1300) && defined (_MSC_EXTENSIONS) /* && !defined(_STLP_WCE_NET) */)
+/*
+ * dums: VC6 has all the required C++ functions but only define them if
+ * _MSC_EXTENSIONS is not defined (a bug?). STLport just do the same
+ * thing also when _MSC_EXTENSIONS is defined.
+ * TODO: above check (_STLP_MSVC <= 1300) also catches VC7.0, is that intended?
+ */
+//We have to tell the compilers that abs, acos ... math functions are not intrinsic
+//otherwise we have Internal Compiler Error in release mode...
+# pragma warning(push)
+# pragma warning(disable: 4162) // no function with C linkage found
+# pragma warning(disable: 4163) // not available as an intrinsic function
+# pragma function (abs, acos, asin, atan, atan2, cos, cosh, exp, fabs, fmod, log, log10, sin, sinh, sqrt, tan, tanh)
+# if defined (_STLP_WCE)
+# pragma function (ceil, floor)
+# endif
+# define _STLP_RESTORE_FUNCTION_INTRINSIC
+#endif // _STLP_MSVC && _STLP_MSVC <= 1300 && !_STLP_WCE && _MSC_EXTENSIONS
+
+#if (defined (__BORLANDC__) || defined (__WATCOMC__)) && defined (_STLP_USE_NEW_C_HEADERS)
+/* In this config Borland native lib only define functions in std namespace.
+ * In order to have all overloads in STLport namespace we need to add the
+ * double overload in global namespace. We do not use a using statement to avoid
+ * import of invalid overload.
+ */
+# define _STLP_DMATH_INLINE(func) _STLP_MATH_INLINE(double, func, func)
+# define _STLP_DMATH_INLINE2(func) _STLP_MATH_INLINE2(double, double, func, func)
+
+_STLP_DMATH_INLINE(acos)
+_STLP_DMATH_INLINE(asin)
+_STLP_DMATH_INLINE(atan)
+_STLP_DMATH_INLINE2(atan2)
+_STLP_DMATH_INLINE(ceil)
+_STLP_DMATH_INLINE(cos)
+_STLP_DMATH_INLINE(cosh)
+_STLP_DMATH_INLINE(exp)
+_STLP_DMATH_INLINE(fabs)
+_STLP_DMATH_INLINE(floor)
+_STLP_DMATH_INLINE2(fmod)
+_STLP_MATH_INLINE2X(double, int*, frexp, frexp)
+_STLP_MATH_INLINE2X(double, int, ldexp, ldexp)
+_STLP_DMATH_INLINE(log)
+_STLP_DMATH_INLINE(log10)
+_STLP_MATH_INLINE2PX(double, modf, modf)
+_STLP_DMATH_INLINE(sin)
+_STLP_DMATH_INLINE(sinh)
+_STLP_DMATH_INLINE(sqrt)
+_STLP_DMATH_INLINE(tan)
+_STLP_DMATH_INLINE(tanh)
+_STLP_DMATH_INLINE2(pow)
+_STLP_DMATH_INLINE2(hypot)
+
+# undef _STLP_DMATH_INLINE
+# undef _STLP_DMATH_INLINE2
+#endif
+
+#if defined (__DMC__)
+# if defined (fabs)
+inline double __stlp_fabs(double __x) { return fabs(__x); }
+# undef fabs
+inline double fabs(double __x) { return __stlp_fabs(__x); }
+# endif
+# if defined (cos)
+inline double __stlp_cos(double __x) { return cos(__x); }
+# undef cos
+inline double cos(double __x) { return __stlp_cos(__x); }
+# endif
+# if defined (sin)
+inline double __stlp_sin(double __x) { return sin(__x); }
+# undef sin
+inline double sin(double __x) { return __stlp_sin(__x); }
+# endif
+# if defined (sqrt)
+inline double __stlp_sqrt(double __x) { return sqrt(__x); }
+# undef sqrt
+inline double sqrt(double __x) { return __stlp_sqrt(__x); }
+# endif
+# if defined (ldexp)
+inline double __stlp_ldexp(double __x, int __y) { return ldexp(__x, __y); }
+# undef ldexp
+inline double ldexp(double __x, int __y) { return __stlp_ldexp(__x, __y); }
+# endif
+#endif
+
+/* MSVC native lib starting with .Net 2003 has already all math functions
+ * in global namespace.
+ * HP-UX native lib has math functions in the global namespace.
+ */
+#if (!defined (_STLP_MSVC_LIB) || (_STLP_MSVC_LIB < 1310) || defined(UNDER_CE)) && \
+ (!defined (__HP_aCC) || (__HP_aCC < 30000)) && \
+ !defined (__WATCOMC__)
+inline double abs(double __x)
+{ return ::fabs(__x); }
+# if !defined (__MVS__)
+_STLP_DEF_MATH_INLINE(abs, fabs)
+# else // __MVS__ has native long double abs?
+inline float abs(float __x) { return ::fabsf(__x); }
+# endif
+
+_STLP_DEF_MATH_INLINE(acos, acos)
+_STLP_DEF_MATH_INLINE(asin, asin)
+_STLP_DEF_MATH_INLINE(atan, atan)
+_STLP_DEF_MATH_INLINE2(atan2, atan2)
+_STLP_DEF_MATH_INLINE(ceil, ceil)
+_STLP_DEF_MATH_INLINE(cos, cos)
+_STLP_DEF_MATH_INLINE(cosh, cosh)
+_STLP_DEF_MATH_INLINE(exp, exp)
+_STLP_DEF_MATH_INLINE(fabs, fabs)
+_STLP_DEF_MATH_INLINE(floor, floor)
+_STLP_DEF_MATH_INLINE2(fmod, fmod)
+_STLP_DEF_MATH_INLINE2PI(frexp, frexp)
+_STLP_DEF_MATH_INLINE2I(ldexp, ldexp)
+_STLP_DEF_MATH_INLINE(log, log)
+_STLP_DEF_MATH_INLINE(log10, log10)
+_STLP_DEF_MATH_INLINE2P(modf, modf)
+_STLP_DEF_MATH_INLINE(sin, sin)
+_STLP_DEF_MATH_INLINE(sinh, sinh)
+_STLP_DEF_MATH_INLINE(sqrt, sqrt)
+_STLP_DEF_MATH_INLINE(tan, tan)
+_STLP_DEF_MATH_INLINE(tanh, tanh)
+_STLP_DEF_MATH_INLINE2(pow, pow)
+
+# if !defined(_STLP_MSVC) /* || (_STLP_MSVC > 1300) */ || defined(_STLP_WCE) || !defined (_MSC_EXTENSIONS) /* && !defined(_STLP_WCE_NET) */
+# ifndef _STLP_NO_VENDOR_MATH_F
+# ifndef __sun
+inline float pow(float __x, int __y) { return _STLP_CMATH_FUNC_NAMESPACE::powf(__x, __STATIC_CAST(float,__y)); }
+# else
+inline float pow(float __x, int __y) { return ::__powf(__x, __STATIC_CAST(float,__y)); }
+# endif
+# else
+inline float pow(float __x, int __y) { return __STATIC_CAST(float, _STLP_CMATH_FUNC_NAMESPACE::pow(__x, __STATIC_CAST(float,__y))); }
+# endif
+inline double pow(double __x, int __y) { return _STLP_CMATH_FUNC_NAMESPACE::pow(__x, __STATIC_CAST(double,__y)); }
+# if !defined (_STLP_NO_LONG_DOUBLE)
+# if !defined(_STLP_NO_VENDOR_MATH_L)
+# ifndef __sun
+inline long double pow(long double __x, int __y) { return _STLP_CMATH_FUNC_NAMESPACE::powl(__x, __STATIC_CAST(long double,__y)); }
+# else
+# ifndef __SUNPRO_CC
+inline long double pow(long double __x, int __y) { return ::__powl(__x, __STATIC_CAST(long double,__y)); }
+# else
+inline long double pow(long double __x, int __y) { return _STLP_VENDOR_CSTD::__powl(__x, __STATIC_CAST(long double,__y)); }
+# endif
+# endif
+# else
+inline long double pow(long double __x, int __y) { return __STATIC_CAST(long double, _STLP_CMATH_FUNC_NAMESPACE::pow(__x, __STATIC_CAST(long double,__y))); }
+# endif
+# endif
+# else
+//The MS native pow version has a bugged overload so it is not imported
+//in the STLport namespace.
+//Here is the bugged version:
+//inline double pow(int __x, int __y) { return (_Pow_int(__x, __y)); }
+inline double pow(double __x, int __y) { return (_Pow_int(__x, __y)); }
+inline float pow(float __x, int __y) { return (_Pow_int(__x, __y)); }
+inline long double pow(long double __x, int __y) { return (_Pow_int(__x, __y)); }
+# endif
+#endif
+
+#if (defined (_STLP_MSVC) && !defined (_STLP_WCE)) || defined (__ICL) || defined (__sun)
+# if defined (_STLP_MSVC) && (_STLP_MSVC >= 1400)
+# pragma warning (push)
+# pragma warning (disable : 4996) // hypot is deprecated.
+# endif
+_STLP_MATH_INLINE2XX(float, hypot, hypot)
+inline long double hypot(long double x, long double y) { return sqrt(x * x + y * y); }
+# if defined (_STLP_MSVC) && (_STLP_MSVC >= 1400)
+# pragma warning (pop)
+# endif
+#else
+# if defined (_STLP_USE_UCLIBC)
+inline double hypot(double x, double y) { return sqrt(x * x + y * y); }
+_STLP_DEF_MATH_INLINE2(hypot, hypot)
+# elif defined (_STLP_WCE)
+ /* CE has a double _hypot(double,double) which we use */
+inline double hypot(double __x, double __y) { return _hypot(__x,__y); }
+_STLP_DEF_MATH_INLINE2(hypot, _hypot)
+# endif
+#endif
+
+#if defined (_STLP_RESTORE_FUNCTION_INTRINSIC)
+//restoration of the default intrinsic status of those functions:
+# pragma intrinsic (abs, acos, asin, atan, atan2, cos, cosh, exp, fabs, fmod, log, log10, sin, sinh, sqrt, tan, tanh)
+# if defined (_STLP_WCE)
+# pragma intrinsic (ceil, floor)
+# endif
+# pragma warning(pop)
+# undef _STLP_RESTORE_FUNCTION_INTRINSIC
+#endif // _STLP_MSVC && _STLP_MSVC <= 1300 && !_STLP_WCE && _MSC_EXTENSIONS
+
+/* C++ Standard is unclear about several call to 'using ::func' if new overloads
+ * of ::func appears between 2 successive 'using' calls. To avoid this potential
+ * problem we provide all abs overload before the 'using' call.
+ * Beware: This header inclusion has to be after all abs overload of this file.
+ * The first 'using ::abs' call is going to be in the other header.
+ */
+#ifndef _STLP_INTERNAL_CSTDLIB
+# include <stl/_cstdlib.h>
+#endif
+
+#if defined (_STLP_IMPORT_VENDOR_CSTD) && !defined (_STLP_NO_CSTD_FUNCTION_IMPORTS)
+#if defined (ANDROID)
+namespace __captured {
+template<typename _Tp> inline int __capture_isfinite(_Tp __f) { return isfinite(__f); }
+template<typename _Tp> inline int __capture_isinf(_Tp __f) { return isinf(__f); }
+template<typename _Tp> inline int __capture_isnan(_Tp __f) { return isnan(__f); }
+template<typename _Tp> inline int __capture_signbit(_Tp __f) { return signbit(__f); }
+}
+#undef isfinite
+#undef isinf
+#undef isnan
+#undef signbit
+namespace __captured {
+template<typename _Tp> inline int isfinite(_Tp __f) { return __capture_isfinite(__f); }
+template<typename _Tp> inline int isinf(_Tp __f) { return __capture_isinf(__f); }
+template<typename _Tp> inline int isnan(_Tp __f) { return __capture_isnan(__f); }
+template<typename _Tp> inline int signbit(_Tp __f) { return __capture_signbit(__f); }
+}
+#endif
+_STLP_BEGIN_NAMESPACE
+using ::abs;
+using ::acos;
+using ::asin;
+using ::atan;
+using ::atan2;
+using ::ceil;
+using ::cos;
+using ::cosh;
+using ::exp;
+using ::fabs;
+using ::floor;
+using ::fmod;
+using ::frexp;
+/*
+ Because of some weird interaction between STLport headers
+ and native HP-UX headers, when compiled with _STLP_DEBUG
+ macro defined with aC++, hypot() is not declared.
+ At some point we'll need to get to the bottom line of
+ this problem.
+*/
+#if !(defined(__HP_aCC) && defined(_STLP_DEBUG))
+using ::hypot;
+#endif
+#if defined (ANDROID)
+using __captured::isfinite;
+using __captured::isinf;
+using __captured::isnan;
+#endif
+using ::ldexp;
+using ::log;
+using ::log10;
+using ::modf;
+using ::pow;
+#if defined (ANDROID)
+using __captured::signbit;
+#endif
+using ::sin;
+using ::sinh;
+using ::sqrt;
+using ::tan;
+using ::tanh;
+_STLP_END_NAMESPACE
+# if defined (__BORLANDC__) && (__BORLANDC__ >= 0x560) && !defined (__linux__)
+using _STLP_VENDOR_CSTD::_ecvt;
+using _STLP_VENDOR_CSTD::_fcvt;
+# endif
+#endif
+
+#endif /* _STLP_INTERNAL_CMATH */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_codecvt.h b/sources/android/stlport/stlport/stl/_codecvt.h
new file mode 100644
index 0000000..29b408b
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_codecvt.h
@@ -0,0 +1,442 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+// WARNING: This is an internal header file, included by other C++
+// standard library headers. You should not attempt to use this header
+// file directly.
+
+
+#ifndef _STLP_INTERNAL_CODECVT_H
+#define _STLP_INTERNAL_CODECVT_H
+
+#ifndef _STLP_C_LOCALE_H
+# include <stl/c_locale.h>
+#endif
+
+#ifndef _STLP_INTERNAL_LOCALE_H
+# include <stl/_locale.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+# include <stl/_algobase.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+class _STLP_CLASS_DECLSPEC codecvt_base {
+public:
+ enum result {ok, partial, error, noconv};
+};
+
+template <class _InternT, class _ExternT, class _StateT>
+class codecvt : public locale::facet, public codecvt_base {
+public:
+ typedef _InternT intern_type;
+ typedef _ExternT extern_type;
+ typedef _StateT state_type;
+
+#if defined (_STLP_MSVC) && (_STLP_MSVC < 1300)
+ /* For the moment VC6 do not support this facet default implementation
+ * because of the static locale::id instance. When VC6 see this definition
+ * it goes crasy with locale::id static instances and all the has_facet tests
+ * unit tests are failing.
+ */
+};
+#else
+ explicit codecvt(size_t __refs = 0) : locale::facet(__refs) {}
+
+ result out(state_type& __state,
+ const intern_type* __from,
+ const intern_type* __from_end,
+ const intern_type*& __from_next,
+ extern_type* __to,
+ extern_type* __to_limit,
+ extern_type*& __to_next) const {
+ _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
+ _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
+ return do_out(__state,
+ __from, __from_end, __from_next,
+ __to, __to_limit, __to_next);
+ }
+
+ result unshift(state_type& __state,
+ extern_type* __to,
+ extern_type* __to_limit,
+ extern_type*& __to_next) const {
+ _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
+ return do_unshift(__state, __to, __to_limit, __to_next);
+ }
+
+ result in(state_type& __state,
+ const extern_type* __from,
+ const extern_type* __from_end,
+ const extern_type*& __from_next,
+ intern_type* __to,
+ intern_type* __to_limit,
+ intern_type*& __to_next) const {
+ _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
+ _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
+ return do_in(__state,
+ __from, __from_end, __from_next,
+ __to, __to_limit, __to_next);
+ }
+
+ int encoding() const _STLP_NOTHROW { return do_encoding(); }
+
+ bool always_noconv() const _STLP_NOTHROW { return do_always_noconv(); }
+
+ int length(state_type& __state,
+ const extern_type* __from,
+ const extern_type* __from_end,
+ size_t __max) const {
+ _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
+ return do_length(__state, __from, __from_end, __max);
+ }
+
+ int max_length() const _STLP_NOTHROW { return do_max_length(); }
+
+ static locale::id id;
+
+protected:
+ ~codecvt() {}
+
+ virtual result do_out(state_type&,
+ const intern_type* __from,
+ const intern_type*,
+ const intern_type*& __from_next,
+ extern_type* __to,
+ extern_type*,
+ extern_type*& __to_next) const
+ { __from_next = __from; __to_next = __to; return noconv; }
+
+ virtual result do_in (state_type&,
+ const extern_type* __from,
+ const extern_type*,
+ const extern_type*& __from_next,
+ intern_type* __to,
+ intern_type*,
+ intern_type*& __to_next) const
+ { __from_next = __from; __to_next = __to; return noconv; }
+
+ virtual result do_unshift(state_type&,
+ extern_type* __to,
+ extern_type*,
+ extern_type*& __to_next) const
+ { __to_next = __to; return noconv; }
+
+ virtual int do_encoding() const _STLP_NOTHROW
+ { return 1; }
+
+ virtual bool do_always_noconv() const _STLP_NOTHROW
+ { return true; }
+
+ virtual int do_length(state_type&,
+ const extern_type* __from,
+ const extern_type* __end,
+ size_t __max) const
+ { return (int)(min) ( __STATIC_CAST(size_t, (__end - __from)), __max); }
+
+ virtual int do_max_length() const _STLP_NOTHROW
+ { return 1; }
+
+private:
+ codecvt(const codecvt<intern_type, extern_type, state_type>&);
+ codecvt<intern_type, extern_type, state_type>& operator = (const codecvt<intern_type, extern_type, state_type>&);
+};
+
+# if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
+# if !defined (__BORLANDC__) || (__BORLANDC__ >= 0x590)
+template <class _InternT, class _ExternT, class _StateT>
+locale::id codecvt<_InternT, _ExternT, _StateT>::id;
+# endif
+# endif
+#endif
+
+template <class _InternT, class _ExternT, class _StateT>
+class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT> {};
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC codecvt<char, char, mbstate_t>
+ : public locale::facet, public codecvt_base {
+public:
+ typedef char intern_type;
+ typedef char extern_type;
+ typedef mbstate_t state_type;
+
+ explicit codecvt(size_t __refs = 0) : locale::facet(__refs) {}
+
+ result out(state_type& __state,
+ const char* __from,
+ const char* __from_end,
+ const char*& __from_next,
+ char* __to,
+ char* __to_limit,
+ char*& __to_next) const {
+ _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
+ _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
+ return do_out(__state,
+ __from, __from_end, __from_next,
+ __to, __to_limit, __to_next);
+ }
+
+ result unshift(state_type& __state,
+ char* __to, char* __to_limit, char*& __to_next) const {
+ _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
+ return do_unshift(__state, __to, __to_limit, __to_next);
+ }
+
+ result in(state_type& __state,
+ const char* __from,
+ const char* __from_end,
+ const char*& __from_next,
+ char* __to,
+ char* __to_limit,
+ char*& __to_next) const {
+ _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
+ _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
+ return do_in(__state,
+ __from, __from_end, __from_next,
+ __to, __to_limit, __to_next);
+ }
+
+ int encoding() const _STLP_NOTHROW { return do_encoding(); }
+
+ bool always_noconv() const _STLP_NOTHROW { return do_always_noconv(); }
+
+ int length(state_type& __state,
+ const char* __from, const char* __from_end,
+ size_t __max) const {
+ _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
+ return do_length(__state, __from, __from_end, __max);
+ }
+
+ int max_length() const _STLP_NOTHROW { return do_max_length(); }
+
+ static _STLP_STATIC_DECLSPEC locale::id id;
+
+protected:
+ ~codecvt();
+
+ virtual result do_out(state_type& /* __state */,
+ const char* __from,
+ const char* /* __from_end */,
+ const char*& __from_next,
+ char* __to,
+ char* /* __to_limit */,
+ char*& __to_next) const;
+
+ virtual result do_in (state_type& /* __state */ ,
+ const char* __from,
+ const char* /* __from_end */,
+ const char*& __from_next,
+ char* __to,
+ char* /* __to_end */,
+ char*& __to_next) const;
+
+ virtual result do_unshift(state_type& /* __state */,
+ char* __to,
+ char* /* __to_limit */,
+ char*& __to_next) const;
+
+ virtual int do_encoding() const _STLP_NOTHROW;
+ virtual bool do_always_noconv() const _STLP_NOTHROW;
+ virtual int do_length(state_type& __state,
+ const char* __from,
+ const char* __end,
+ size_t __max) const;
+ virtual int do_max_length() const _STLP_NOTHROW;
+private:
+ codecvt(const codecvt<char, char, mbstate_t>&);
+ codecvt<char, char, mbstate_t>& operator =(const codecvt<char, char, mbstate_t>&);
+};
+
+# ifndef _STLP_NO_WCHAR_T
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC codecvt<wchar_t, char, mbstate_t>
+ : public locale::facet, public codecvt_base {
+public:
+ typedef wchar_t intern_type;
+ typedef char extern_type;
+ typedef mbstate_t state_type;
+
+ explicit codecvt(size_t __refs = 0) : locale::facet(__refs) {}
+
+ result out(state_type& __state,
+ const wchar_t* __from,
+ const wchar_t* __from_end,
+ const wchar_t*& __from_next,
+ char* __to,
+ char* __to_limit,
+ char*& __to_next) const {
+ _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
+ _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
+ return do_out(__state,
+ __from, __from_end, __from_next,
+ __to, __to_limit, __to_next);
+ }
+
+ result unshift(state_type& __state,
+ char* __to, char* __to_limit, char*& __to_next) const {
+ _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
+ return do_unshift(__state, __to, __to_limit, __to_next);
+ }
+
+ result in(state_type& __state,
+ const char* __from,
+ const char* __from_end,
+ const char*& __from_next,
+ wchar_t* __to,
+ wchar_t* __to_limit,
+ wchar_t*& __to_next) const {
+ _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
+ _STLP_VERBOSE_ASSERT(__to <= __to_limit, _StlMsg_INVALID_ARGUMENT)
+ return do_in(__state,
+ __from, __from_end, __from_next,
+ __to, __to_limit, __to_next);
+ }
+
+ int encoding() const _STLP_NOTHROW { return do_encoding(); }
+
+ bool always_noconv() const _STLP_NOTHROW { return do_always_noconv(); }
+
+ int length(state_type& __state,
+ const char* __from, const char* __from_end,
+ size_t __max) const {
+ _STLP_VERBOSE_ASSERT(__from <= __from_end, _StlMsg_INVALID_ARGUMENT)
+ return do_length(__state, __from, __from_end, __max);
+ }
+
+ int max_length() const _STLP_NOTHROW { return do_max_length(); }
+
+ static _STLP_STATIC_DECLSPEC locale::id id;
+
+protected:
+ ~codecvt();
+
+ virtual result do_out(state_type& __state,
+ const wchar_t* __from,
+ const wchar_t* __from_end,
+ const wchar_t*& __from_next,
+ char* __to,
+ char* __to_limit,
+ char*& __to_next) const;
+
+ virtual result do_in (state_type& __state,
+ const char* __from,
+ const char* __from_end,
+ const char*& __from_next,
+ wchar_t* __to,
+ wchar_t* __to_limit,
+ wchar_t*& __to_next) const;
+
+ virtual result do_unshift(state_type& __state,
+ char* __to,
+ char* __to_limit,
+ char*& __to_next) const;
+
+ virtual int do_encoding() const _STLP_NOTHROW;
+
+ virtual bool do_always_noconv() const _STLP_NOTHROW;
+
+ virtual int do_length(state_type& __state,
+ const char* __from,
+ const char* __end,
+ size_t __max) const;
+
+ virtual int do_max_length() const _STLP_NOTHROW;
+
+private:
+ codecvt(const codecvt<wchar_t, char, mbstate_t>&);
+ codecvt<wchar_t, char, mbstate_t>& operator = (const codecvt<wchar_t, char, mbstate_t>&);
+};
+
+# endif
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC codecvt_byname<char, char, mbstate_t>
+ : public codecvt<char, char, mbstate_t> {
+public:
+ explicit codecvt_byname(const char* __name, size_t __refs = 0);
+ ~codecvt_byname();
+private:
+ codecvt_byname(const codecvt_byname<char, char, mbstate_t>&);
+ codecvt_byname<char, char, mbstate_t>& operator =(const codecvt_byname<char, char, mbstate_t>&);
+};
+
+# ifndef _STLP_NO_WCHAR_T
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC codecvt_byname<wchar_t, char, mbstate_t>
+ : public codecvt<wchar_t, char, mbstate_t> {
+ friend class _Locale_impl;
+public:
+ explicit codecvt_byname(const char * __name, size_t __refs = 0);
+
+protected:
+ ~codecvt_byname();
+
+ virtual result do_out(state_type& __state,
+ const wchar_t* __from,
+ const wchar_t* __from_end,
+ const wchar_t*& __from_next,
+ char* __to,
+ char* __to_limit,
+ char*& __to_next) const;
+
+ virtual result do_in (state_type& __state,
+ const char* __from,
+ const char* __from_end,
+ const char*& __from_next,
+ wchar_t* __to,
+ wchar_t* __to_limit,
+ wchar_t*& __to_next) const;
+
+ virtual result do_unshift(state_type& __state,
+ char* __to,
+ char* __to_limit,
+ char*& __to_next) const;
+
+ virtual int do_encoding() const _STLP_NOTHROW;
+
+ virtual bool do_always_noconv() const _STLP_NOTHROW;
+
+ virtual int do_length(state_type& __state,
+ const char* __from,
+ const char* __end,
+ size_t __max) const;
+
+ virtual int do_max_length() const _STLP_NOTHROW;
+
+private:
+ codecvt_byname(_Locale_codecvt* __cvt)
+ : _M_codecvt(__cvt) {}
+
+ codecvt_byname(const codecvt_byname<wchar_t, char, mbstate_t>&);
+ codecvt_byname<wchar_t, char, mbstate_t>& operator =(const codecvt_byname<wchar_t, char, mbstate_t>&);
+ _Locale_codecvt* _M_codecvt;
+};
+
+# endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_CODECVT_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/stl/_collate.h b/sources/android/stlport/stlport/stl/_collate.h
new file mode 100644
index 0000000..4384f2e
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_collate.h
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+// WARNING: This is an internal header file, included by other C++
+// standard library headers. You should not attempt to use this header
+// file directly.
+
+#ifndef _STLP_INTERNAL_COLLATE_H
+#define _STLP_INTERNAL_COLLATE_H
+
+#ifndef _STLP_C_LOCALE_H
+# include <stl/c_locale.h>
+#endif
+
+#ifndef _STLP_INTERNAL_LOCALE_H
+# include <stl/_locale.h>
+#endif
+
+#ifndef _STLP_INTERNAL_STRING_H
+# include <stl/_string.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _CharT> class collate {};
+template <class _CharT> class collate_byname {};
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC collate<char> : public locale::facet {
+public:
+ typedef char char_type;
+ typedef string string_type;
+
+ explicit collate(size_t __refs = 0) : locale::facet(__refs) {}
+
+ int compare(const char* __low1, const char* __high1,
+ const char* __low2, const char* __high2) const {
+ return do_compare( __low1, __high1, __low2, __high2);
+ }
+
+ string_type transform(const char* __low, const char* __high) const {
+ return do_transform(__low, __high);
+ }
+
+ long hash(const char* __low, const char* __high) const
+ { return do_hash(__low, __high); }
+
+ static _STLP_STATIC_DECLSPEC locale::id id;
+
+protected:
+ ~collate();
+
+ virtual int do_compare(const char*, const char*,
+ const char*, const char*) const;
+ virtual string_type do_transform(const char*, const char*) const;
+ virtual long do_hash(const char*, const char*) const;
+private:
+ collate(const collate<char>&);
+ collate<char>& operator =(const collate<char>&);
+};
+
+# ifndef _STLP_NO_WCHAR_T
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC collate<wchar_t> : public locale::facet {
+public:
+ typedef wchar_t char_type;
+ typedef wstring string_type;
+
+ explicit collate(size_t __refs = 0) : locale::facet(__refs) {}
+
+ int compare(const wchar_t* __low1, const wchar_t* __high1,
+ const wchar_t* __low2, const wchar_t* __high2) const {
+ return do_compare( __low1, __high1, __low2, __high2);
+ }
+
+ string_type transform(const wchar_t* __low, const wchar_t* __high) const {
+ return do_transform(__low, __high);
+ }
+
+ long hash(const wchar_t* __low, const wchar_t* __high) const
+ { return do_hash(__low, __high); }
+
+ static _STLP_STATIC_DECLSPEC locale::id id;
+
+protected:
+ ~collate();
+
+ virtual int do_compare(const wchar_t*, const wchar_t*,
+ const wchar_t*, const wchar_t*) const;
+ virtual string_type do_transform(const wchar_t*, const wchar_t*) const;
+ virtual long do_hash(const wchar_t* __low, const wchar_t* __high) const;
+private:
+ collate(const collate<wchar_t>&);
+ collate<wchar_t>& operator = (const collate<wchar_t>&);
+};
+
+# endif /* NO_WCHAR_T */
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC collate_byname<char>: public collate<char> {
+ friend class _Locale_impl;
+public:
+ explicit collate_byname(const char* __name, size_t __refs = 0);
+
+protected:
+ ~collate_byname();
+
+ virtual int do_compare(const char*, const char*,
+ const char*, const char*) const;
+ virtual string_type do_transform(const char*, const char*) const;
+
+private:
+ collate_byname(_Locale_collate *__coll)
+ : _M_collate(__coll) {}
+ _Locale_collate* _M_collate;
+ collate_byname(const collate_byname<char>&);
+ collate_byname<char>& operator =(const collate_byname<char>&);
+};
+
+# ifndef _STLP_NO_WCHAR_T
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC collate_byname<wchar_t>: public collate<wchar_t> {
+ friend class _Locale_impl;
+public:
+ explicit collate_byname(const char * __name, size_t __refs = 0);
+
+protected:
+ ~collate_byname();
+
+ virtual int do_compare(const wchar_t*, const wchar_t*,
+ const wchar_t*, const wchar_t*) const;
+ virtual string_type do_transform(const wchar_t*, const wchar_t*) const;
+
+private:
+ collate_byname(_Locale_collate *__coll)
+ : _M_collate(__coll) {}
+ _Locale_collate* _M_collate;
+ collate_byname(const collate_byname<wchar_t>&);
+ collate_byname<wchar_t>& operator =(const collate_byname<wchar_t>&);
+};
+
+# endif /* NO_WCHAR_T */
+
+template <class _CharT, class _Traits, class _Alloc>
+bool
+__locale_do_operator_call (const locale& __loc,
+ const basic_string<_CharT, _Traits, _Alloc>& __x,
+ const basic_string<_CharT, _Traits, _Alloc>& __y) {
+ collate<_CharT> const& __coll = use_facet<collate<_CharT> >(__loc);
+ return __coll.compare(__x.data(), __x.data() + __x.size(),
+ __y.data(), __y.data() + __y.size()) < 0;
+}
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_COLLATE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_complex.c b/sources/android/stlport/stlport/stl/_complex.c
new file mode 100644
index 0000000..204fa1e
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_complex.c
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_COMPLEX_C
+#define _STLP_COMPLEX_C
+
+#ifndef _STLP_INTERNAL_COMPLEX
+# include <stl/_complex.h>
+#endif
+
+#if !defined (_STLP_USE_NO_IOSTREAMS)
+# ifndef _STLP_INTERNAL_ISTREAM
+# include <stl/_istream.h>
+# endif
+
+# ifndef _STLP_INTERNAL_SSTREAM
+# include <stl/_sstream.h>
+# endif
+
+# ifndef _STLP_STRING_IO_H
+# include <stl/_string_io.h>
+# endif
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+// Non-inline member functions.
+
+template <class _Tp>
+void complex<_Tp>::_div(const _Tp& __z1_r, const _Tp& __z1_i,
+ const _Tp& __z2_r, const _Tp& __z2_i,
+ _Tp& __res_r, _Tp& __res_i) {
+ _Tp __ar = __z2_r >= 0 ? __z2_r : -__z2_r;
+ _Tp __ai = __z2_i >= 0 ? __z2_i : -__z2_i;
+
+ if (__ar <= __ai) {
+ _Tp __ratio = __z2_r / __z2_i;
+ _Tp __denom = __z2_i * (1 + __ratio * __ratio);
+ __res_r = (__z1_r * __ratio + __z1_i) / __denom;
+ __res_i = (__z1_i * __ratio - __z1_r) / __denom;
+ }
+ else {
+ _Tp __ratio = __z2_i / __z2_r;
+ _Tp __denom = __z2_r * (1 + __ratio * __ratio);
+ __res_r = (__z1_r + __z1_i * __ratio) / __denom;
+ __res_i = (__z1_i - __z1_r * __ratio) / __denom;
+ }
+}
+
+template <class _Tp>
+void complex<_Tp>::_div(const _Tp& __z1_r,
+ const _Tp& __z2_r, const _Tp& __z2_i,
+ _Tp& __res_r, _Tp& __res_i) {
+ _Tp __ar = __z2_r >= 0 ? __z2_r : -__z2_r;
+ _Tp __ai = __z2_i >= 0 ? __z2_i : -__z2_i;
+
+ if (__ar <= __ai) {
+ _Tp __ratio = __z2_r / __z2_i;
+ _Tp __denom = __z2_i * (1 + __ratio * __ratio);
+ __res_r = (__z1_r * __ratio) / __denom;
+ __res_i = - __z1_r / __denom;
+ }
+ else {
+ _Tp __ratio = __z2_i / __z2_r;
+ _Tp __denom = __z2_r * (1 + __ratio * __ratio);
+ __res_r = __z1_r / __denom;
+ __res_i = - (__z1_r * __ratio) / __denom;
+ }
+}
+
+// I/O.
+#if !defined (_STLP_USE_NO_IOSTREAMS)
+
+// Complex output, in the form (re,im). We use a two-step process
+// involving stringstream so that we get the padding right.
+template <class _Tp, class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& _STLP_CALL
+operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __z) {
+ basic_ostringstream<_CharT, _Traits, allocator<_CharT> > __tmp;
+ __tmp.flags(__os.flags());
+ __tmp.imbue(__os.getloc());
+ __tmp.precision(__os.precision());
+ __tmp << '(' << __z.real() << ',' << __z.imag() << ')';
+ return __os << __tmp.str();
+}
+
+// Complex input from arbitrary streams. Note that results in some
+// locales may be confusing, since the decimal character varies with
+// locale and the separator between real and imaginary parts does not.
+
+template <class _Tp, class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& _STLP_CALL
+operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __z) {
+ _Tp __re = 0;
+ _Tp __im = 0;
+
+ const ctype<_CharT>& __c_type = *__is._M_ctype_facet();
+
+ const char __punct[4] = "(,)";
+ _CharT __wpunct[3];
+ __c_type.widen(__punct, __punct + 3, __wpunct);
+
+ _CharT __c;
+
+ __is >> __c;
+ if (_Traits::eq(__c, __wpunct[0])) { // Left paren
+ __is >> __re >> __c;
+ if (_Traits::eq(__c, __wpunct[1])) // Comma
+ __is >> __im >> __c;
+ if (!_Traits::eq(__c, __wpunct[2])) // Right paren
+ __is.setstate(ios_base::failbit);
+ }
+ else {
+ __is.putback(__c);
+ __is >> __re;
+ }
+
+ if (__is)
+ __z = complex<_Tp>(__re, __im);
+ return __is;
+}
+
+#endif /* _STLP_USE_NO_IOSTREAMS */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_COMPLEX_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_complex.h b/sources/android/stlport/stlport/stl/_complex.h
new file mode 100644
index 0000000..5dba0ad
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_complex.h
@@ -0,0 +1,935 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_INTERNAL_COMPLEX
+#define _STLP_INTERNAL_COMPLEX
+
+// This header declares the template class complex, as described in
+// in the draft C++ standard. Single-precision complex numbers
+// are complex<float>, double-precision are complex<double>, and
+// quad precision are complex<long double>.
+
+// Note that the template class complex is declared within namespace
+// std, as called for by the draft C++ standard.
+
+#ifndef _STLP_INTERNAL_CMATH
+# include <stl/_cmath.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Tp>
+struct complex {
+ typedef _Tp value_type;
+ typedef complex<_Tp> _Self;
+
+ // Constructors, destructor, assignment operator.
+ complex() : _M_re(0), _M_im(0) {}
+ complex(const value_type& __x)
+ : _M_re(__x), _M_im(0) {}
+ complex(const value_type& __x, const value_type& __y)
+ : _M_re(__x), _M_im(__y) {}
+ complex(const _Self& __z)
+ : _M_re(__z._M_re), _M_im(__z._M_im) {}
+
+ _Self& operator=(const _Self& __z) {
+ _M_re = __z._M_re;
+ _M_im = __z._M_im;
+ return *this;
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES) && defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ template <class _Tp2>
+ explicit complex(const complex<_Tp2>& __z)
+ : _M_re(__z._M_re), _M_im(__z._M_im) {}
+
+ template <class _Tp2>
+ _Self& operator=(const complex<_Tp2>& __z) {
+ _M_re = __z._M_re;
+ _M_im = __z._M_im;
+ return *this;
+ }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ // Element access.
+ value_type real() const { return _M_re; }
+ value_type imag() const { return _M_im; }
+
+ // Arithmetic op= operations involving one real argument.
+
+ _Self& operator= (const value_type& __x) {
+ _M_re = __x;
+ _M_im = 0;
+ return *this;
+ }
+ _Self& operator+= (const value_type& __x) {
+ _M_re += __x;
+ return *this;
+ }
+ _Self& operator-= (const value_type& __x) {
+ _M_re -= __x;
+ return *this;
+ }
+ _Self& operator*= (const value_type& __x) {
+ _M_re *= __x;
+ _M_im *= __x;
+ return *this;
+ }
+ _Self& operator/= (const value_type& __x) {
+ _M_re /= __x;
+ _M_im /= __x;
+ return *this;
+ }
+
+ // Arithmetic op= operations involving two complex arguments.
+
+ static void _STLP_CALL _div(const value_type& __z1_r, const value_type& __z1_i,
+ const value_type& __z2_r, const value_type& __z2_i,
+ value_type& __res_r, value_type& __res_i);
+
+ static void _STLP_CALL _div(const value_type& __z1_r,
+ const value_type& __z2_r, const value_type& __z2_i,
+ value_type& __res_r, value_type& __res_i);
+
+#if defined (_STLP_MEMBER_TEMPLATES) // && defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+
+ template <class _Tp2> _Self& operator+= (const complex<_Tp2>& __z) {
+ _M_re += __z._M_re;
+ _M_im += __z._M_im;
+ return *this;
+ }
+
+ template <class _Tp2> _Self& operator-= (const complex<_Tp2>& __z) {
+ _M_re -= __z._M_re;
+ _M_im -= __z._M_im;
+ return *this;
+ }
+
+ template <class _Tp2> _Self& operator*= (const complex<_Tp2>& __z) {
+ value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;
+ value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;
+ _M_re = __r;
+ _M_im = __i;
+ return *this;
+ }
+
+ template <class _Tp2> _Self& operator/= (const complex<_Tp2>& __z) {
+ value_type __r;
+ value_type __i;
+ _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
+ _M_re = __r;
+ _M_im = __i;
+ return *this;
+ }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ _Self& operator+= (const _Self& __z) {
+ _M_re += __z._M_re;
+ _M_im += __z._M_im;
+ return *this;
+ }
+
+ _Self& operator-= (const _Self& __z) {
+ _M_re -= __z._M_re;
+ _M_im -= __z._M_im;
+ return *this;
+ }
+
+ _Self& operator*= (const _Self& __z) {
+ value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;
+ value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;
+ _M_re = __r;
+ _M_im = __i;
+ return *this;
+ }
+
+ _Self& operator/= (const _Self& __z) {
+ value_type __r;
+ value_type __i;
+ _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
+ _M_re = __r;
+ _M_im = __i;
+ return *this;
+ }
+
+ // Data members.
+ value_type _M_re;
+ value_type _M_im;
+};
+
+// Explicit specializations for float, double, long double. The only
+// reason for these specializations is to enable automatic conversions
+// from complex<float> to complex<double>, and complex<double> to
+// complex<long double>.
+
+_STLP_TEMPLATE_NULL
+struct _STLP_CLASS_DECLSPEC complex<float> {
+ typedef float value_type;
+ typedef complex<float> _Self;
+ // Constructors, destructor, assignment operator.
+
+ complex(value_type __x = 0.0f, value_type __y = 0.0f)
+ : _M_re(__x), _M_im(__y) {}
+
+ complex(const complex<float>& __z) : _M_re(__z._M_re), _M_im(__z._M_im) {}
+
+ inline explicit complex(const complex<double>& __z);
+#ifndef _STLP_NO_LONG_DOUBLE
+ inline explicit complex(const complex<long double>& __z);
+#endif
+ // Element access.
+ value_type real() const { return _M_re; }
+ value_type imag() const { return _M_im; }
+
+ // Arithmetic op= operations involving one real argument.
+
+ _Self& operator= (value_type __x) {
+ _M_re = __x;
+ _M_im = 0.0f;
+ return *this;
+ }
+ _Self& operator+= (value_type __x) {
+ _M_re += __x;
+ return *this;
+ }
+ _Self& operator-= (value_type __x) {
+ _M_re -= __x;
+ return *this;
+ }
+ _Self& operator*= (value_type __x) {
+ _M_re *= __x;
+ _M_im *= __x;
+ return *this;
+ }
+ _Self& operator/= (value_type __x) {
+ _M_re /= __x;
+ _M_im /= __x;
+ return *this;
+ }
+
+ // Arithmetic op= operations involving two complex arguments.
+
+ static void _STLP_CALL _div(const float& __z1_r, const float& __z1_i,
+ const float& __z2_r, const float& __z2_i,
+ float& __res_r, float& __res_i);
+
+ static void _STLP_CALL _div(const float& __z1_r,
+ const float& __z2_r, const float& __z2_i,
+ float& __res_r, float& __res_i);
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _Tp2>
+ complex<float>& operator=(const complex<_Tp2>& __z) {
+ _M_re = __z._M_re;
+ _M_im = __z._M_im;
+ return *this;
+ }
+
+ template <class _Tp2>
+ complex<float>& operator+= (const complex<_Tp2>& __z) {
+ _M_re += __z._M_re;
+ _M_im += __z._M_im;
+ return *this;
+ }
+
+ template <class _Tp2>
+ complex<float>& operator-= (const complex<_Tp2>& __z) {
+ _M_re -= __z._M_re;
+ _M_im -= __z._M_im;
+ return *this;
+ }
+
+ template <class _Tp2>
+ complex<float>& operator*= (const complex<_Tp2>& __z) {
+ float __r = _M_re * __z._M_re - _M_im * __z._M_im;
+ float __i = _M_re * __z._M_im + _M_im * __z._M_re;
+ _M_re = __r;
+ _M_im = __i;
+ return *this;
+ }
+
+ template <class _Tp2>
+ complex<float>& operator/= (const complex<_Tp2>& __z) {
+ float __r;
+ float __i;
+ _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
+ _M_re = __r;
+ _M_im = __i;
+ return *this;
+ }
+
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ _Self& operator=(const _Self& __z) {
+ _M_re = __z._M_re;
+ _M_im = __z._M_im;
+ return *this;
+ }
+
+ _Self& operator+= (const _Self& __z) {
+ _M_re += __z._M_re;
+ _M_im += __z._M_im;
+ return *this;
+ }
+
+ _Self& operator-= (const _Self& __z) {
+ _M_re -= __z._M_re;
+ _M_im -= __z._M_im;
+ return *this;
+ }
+
+ _Self& operator*= (const _Self& __z) {
+ value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;
+ value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;
+ _M_re = __r;
+ _M_im = __i;
+ return *this;
+ }
+
+ _Self& operator/= (const _Self& __z) {
+ value_type __r;
+ value_type __i;
+ _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
+ _M_re = __r;
+ _M_im = __i;
+ return *this;
+ }
+
+ // Data members.
+ value_type _M_re;
+ value_type _M_im;
+};
+
+_STLP_TEMPLATE_NULL
+struct _STLP_CLASS_DECLSPEC complex<double> {
+ typedef double value_type;
+ typedef complex<double> _Self;
+
+ // Constructors, destructor, assignment operator.
+
+ complex(value_type __x = 0.0, value_type __y = 0.0)
+ : _M_re(__x), _M_im(__y) {}
+
+ complex(const complex<double>& __z)
+ : _M_re(__z._M_re), _M_im(__z._M_im) {}
+ inline complex(const complex<float>& __z);
+#if !defined (_STLP_NO_LONG_DOUBLE)
+ explicit inline complex(const complex<long double>& __z);
+#endif
+ // Element access.
+ value_type real() const { return _M_re; }
+ value_type imag() const { return _M_im; }
+
+ // Arithmetic op= operations involving one real argument.
+
+ _Self& operator= (value_type __x) {
+ _M_re = __x;
+ _M_im = 0.0;
+ return *this;
+ }
+ _Self& operator+= (value_type __x) {
+ _M_re += __x;
+ return *this;
+ }
+ _Self& operator-= (value_type __x) {
+ _M_re -= __x;
+ return *this;
+ }
+ _Self& operator*= (value_type __x) {
+ _M_re *= __x;
+ _M_im *= __x;
+ return *this;
+ }
+ _Self& operator/= (value_type __x) {
+ _M_re /= __x;
+ _M_im /= __x;
+ return *this;
+ }
+
+ // Arithmetic op= operations involving two complex arguments.
+
+ static void _STLP_CALL _div(const double& __z1_r, const double& __z1_i,
+ const double& __z2_r, const double& __z2_i,
+ double& __res_r, double& __res_i);
+ static void _STLP_CALL _div(const double& __z1_r,
+ const double& __z2_r, const double& __z2_i,
+ double& __res_r, double& __res_i);
+
+#if defined (_STLP_MEMBER_TEMPLATES) && defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ template <class _Tp2>
+ complex<double>& operator=(const complex<_Tp2>& __z) {
+ _M_re = __z._M_re;
+ _M_im = __z._M_im;
+ return *this;
+ }
+
+ template <class _Tp2>
+ complex<double>& operator+= (const complex<_Tp2>& __z) {
+ _M_re += __z._M_re;
+ _M_im += __z._M_im;
+ return *this;
+ }
+
+ template <class _Tp2>
+ complex<double>& operator-= (const complex<_Tp2>& __z) {
+ _M_re -= __z._M_re;
+ _M_im -= __z._M_im;
+ return *this;
+ }
+
+ template <class _Tp2>
+ complex<double>& operator*= (const complex<_Tp2>& __z) {
+ double __r = _M_re * __z._M_re - _M_im * __z._M_im;
+ double __i = _M_re * __z._M_im + _M_im * __z._M_re;
+ _M_re = __r;
+ _M_im = __i;
+ return *this;
+ }
+
+ template <class _Tp2>
+ complex<double>& operator/= (const complex<_Tp2>& __z) {
+ double __r;
+ double __i;
+ _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
+ _M_re = __r;
+ _M_im = __i;
+ return *this;
+ }
+
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ _Self& operator=(const _Self& __z) {
+ _M_re = __z._M_re;
+ _M_im = __z._M_im;
+ return *this;
+ }
+
+ _Self& operator+= (const _Self& __z) {
+ _M_re += __z._M_re;
+ _M_im += __z._M_im;
+ return *this;
+ }
+
+ _Self& operator-= (const _Self& __z) {
+ _M_re -= __z._M_re;
+ _M_im -= __z._M_im;
+ return *this;
+ }
+
+ _Self& operator*= (const _Self& __z) {
+ value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;
+ value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;
+ _M_re = __r;
+ _M_im = __i;
+ return *this;
+ }
+
+ _Self& operator/= (const _Self& __z) {
+ value_type __r;
+ value_type __i;
+ _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
+ _M_re = __r;
+ _M_im = __i;
+ return *this;
+ }
+
+ // Data members.
+ value_type _M_re;
+ value_type _M_im;
+};
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+
+_STLP_TEMPLATE_NULL
+struct _STLP_CLASS_DECLSPEC complex<long double> {
+ typedef long double value_type;
+ typedef complex<long double> _Self;
+
+ // Constructors, destructor, assignment operator.
+ complex(value_type __x = 0.0l, value_type __y = 0.0l)
+ : _M_re(__x), _M_im(__y) {}
+
+ complex(const complex<long double>& __z)
+ : _M_re(__z._M_re), _M_im(__z._M_im) {}
+ inline complex(const complex<float>& __z);
+ inline complex(const complex<double>& __z);
+
+ // Element access.
+ value_type real() const { return _M_re; }
+ value_type imag() const { return _M_im; }
+
+ // Arithmetic op= operations involving one real argument.
+
+ _Self& operator= (value_type __x) {
+ _M_re = __x;
+ _M_im = 0.0l;
+ return *this;
+ }
+ _Self& operator+= (value_type __x) {
+ _M_re += __x;
+ return *this;
+ }
+ _Self& operator-= (value_type __x) {
+ _M_re -= __x;
+ return *this;
+ }
+ _Self& operator*= (value_type __x) {
+ _M_re *= __x;
+ _M_im *= __x;
+ return *this;
+ }
+ _Self& operator/= (value_type __x) {
+ _M_re /= __x;
+ _M_im /= __x;
+ return *this;
+ }
+
+ // Arithmetic op= operations involving two complex arguments.
+
+ static void _STLP_CALL _div(const long double& __z1_r, const long double& __z1_i,
+ const long double& __z2_r, const long double& __z2_i,
+ long double& __res_r, long double& __res_i);
+
+ static void _STLP_CALL _div(const long double& __z1_r,
+ const long double& __z2_r, const long double& __z2_i,
+ long double& __res_r, long double& __res_i);
+
+# if defined (_STLP_MEMBER_TEMPLATES) && defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+
+ template <class _Tp2>
+ complex<long double>& operator=(const complex<_Tp2>& __z) {
+ _M_re = __z._M_re;
+ _M_im = __z._M_im;
+ return *this;
+ }
+
+ template <class _Tp2>
+ complex<long double>& operator+= (const complex<_Tp2>& __z) {
+ _M_re += __z._M_re;
+ _M_im += __z._M_im;
+ return *this;
+ }
+
+ template <class _Tp2>
+ complex<long double>& operator-= (const complex<_Tp2>& __z) {
+ _M_re -= __z._M_re;
+ _M_im -= __z._M_im;
+ return *this;
+ }
+
+ template <class _Tp2>
+ complex<long double>& operator*= (const complex<_Tp2>& __z) {
+ long double __r = _M_re * __z._M_re - _M_im * __z._M_im;
+ long double __i = _M_re * __z._M_im + _M_im * __z._M_re;
+ _M_re = __r;
+ _M_im = __i;
+ return *this;
+ }
+
+ template <class _Tp2>
+ complex<long double>& operator/= (const complex<_Tp2>& __z) {
+ long double __r;
+ long double __i;
+ _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
+ _M_re = __r;
+ _M_im = __i;
+ return *this;
+ }
+
+# endif /* _STLP_MEMBER_TEMPLATES */
+
+ _Self& operator=(const _Self& __z) {
+ _M_re = __z._M_re;
+ _M_im = __z._M_im;
+ return *this;
+ }
+
+ _Self& operator+= (const _Self& __z) {
+ _M_re += __z._M_re;
+ _M_im += __z._M_im;
+ return *this;
+ }
+
+ _Self& operator-= (const _Self& __z) {
+ _M_re -= __z._M_re;
+ _M_im -= __z._M_im;
+ return *this;
+ }
+
+ _Self& operator*= (const _Self& __z) {
+ value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;
+ value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;
+ _M_re = __r;
+ _M_im = __i;
+ return *this;
+ }
+
+ _Self& operator/= (const _Self& __z) {
+ value_type __r;
+ value_type __i;
+ _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
+ _M_re = __r;
+ _M_im = __i;
+ return *this;
+ }
+
+ // Data members.
+ value_type _M_re;
+ value_type _M_im;
+};
+
+#endif /* _STLP_NO_LONG_DOUBLE */
+
+// Converting constructors from one of these three specialized types
+// to another.
+
+inline complex<float>::complex(const complex<double>& __z)
+ : _M_re((float)__z._M_re), _M_im((float)__z._M_im) {}
+inline complex<double>::complex(const complex<float>& __z)
+ : _M_re(__z._M_re), _M_im(__z._M_im) {}
+#ifndef _STLP_NO_LONG_DOUBLE
+inline complex<float>::complex(const complex<long double>& __z)
+ : _M_re((float)__z._M_re), _M_im((float)__z._M_im) {}
+inline complex<double>::complex(const complex<long double>& __z)
+ : _M_re((double)__z._M_re), _M_im((double)__z._M_im) {}
+inline complex<long double>::complex(const complex<float>& __z)
+ : _M_re(__z._M_re), _M_im(__z._M_im) {}
+inline complex<long double>::complex(const complex<double>& __z)
+ : _M_re(__z._M_re), _M_im(__z._M_im) {}
+#endif
+
+// Unary non-member arithmetic operators.
+
+template <class _Tp>
+inline complex<_Tp> _STLP_CALL operator+(const complex<_Tp>& __z)
+{ return __z; }
+
+template <class _Tp>
+inline complex<_Tp> _STLP_CALL operator-(const complex<_Tp>& __z)
+{ return complex<_Tp>(-__z._M_re, -__z._M_im); }
+
+// Non-member arithmetic operations involving one real argument.
+
+template <class _Tp>
+inline complex<_Tp> _STLP_CALL operator+(const _Tp& __x, const complex<_Tp>& __z)
+{ return complex<_Tp>(__x + __z._M_re, __z._M_im); }
+
+template <class _Tp>
+inline complex<_Tp> _STLP_CALL operator+(const complex<_Tp>& __z, const _Tp& __x)
+{ return complex<_Tp>(__z._M_re + __x, __z._M_im); }
+
+template <class _Tp>
+inline complex<_Tp> _STLP_CALL operator-(const _Tp& __x, const complex<_Tp>& __z)
+{ return complex<_Tp>(__x - __z._M_re, -__z._M_im); }
+
+template <class _Tp>
+inline complex<_Tp> _STLP_CALL operator-(const complex<_Tp>& __z, const _Tp& __x)
+{ return complex<_Tp>(__z._M_re - __x, __z._M_im); }
+
+template <class _Tp>
+inline complex<_Tp> _STLP_CALL operator*(const _Tp& __x, const complex<_Tp>& __z)
+{ return complex<_Tp>(__x * __z._M_re, __x * __z._M_im); }
+
+template <class _Tp>
+inline complex<_Tp> _STLP_CALL operator*(const complex<_Tp>& __z, const _Tp& __x)
+{ return complex<_Tp>(__z._M_re * __x, __z._M_im * __x); }
+
+template <class _Tp>
+inline complex<_Tp> _STLP_CALL operator/(const _Tp& __x, const complex<_Tp>& __z) {
+ complex<_Tp> __result;
+ complex<_Tp>::_div(__x,
+ __z._M_re, __z._M_im,
+ __result._M_re, __result._M_im);
+ return __result;
+}
+
+template <class _Tp>
+inline complex<_Tp> _STLP_CALL operator/(const complex<_Tp>& __z, const _Tp& __x)
+{ return complex<_Tp>(__z._M_re / __x, __z._M_im / __x); }
+
+// Non-member arithmetic operations involving two complex arguments
+
+template <class _Tp>
+inline complex<_Tp> _STLP_CALL
+operator+(const complex<_Tp>& __z1, const complex<_Tp>& __z2)
+{ return complex<_Tp>(__z1._M_re + __z2._M_re, __z1._M_im + __z2._M_im); }
+
+template <class _Tp>
+inline complex<_Tp> _STLP_CALL
+operator-(const complex<_Tp>& __z1, const complex<_Tp>& __z2)
+{ return complex<_Tp>(__z1._M_re - __z2._M_re, __z1._M_im - __z2._M_im); }
+
+template <class _Tp>
+inline complex<_Tp> _STLP_CALL
+operator*(const complex<_Tp>& __z1, const complex<_Tp>& __z2) {
+ return complex<_Tp>(__z1._M_re * __z2._M_re - __z1._M_im * __z2._M_im,
+ __z1._M_re * __z2._M_im + __z1._M_im * __z2._M_re);
+}
+
+template <class _Tp>
+inline complex<_Tp> _STLP_CALL
+operator/(const complex<_Tp>& __z1, const complex<_Tp>& __z2) {
+ complex<_Tp> __result;
+ complex<_Tp>::_div(__z1._M_re, __z1._M_im,
+ __z2._M_re, __z2._M_im,
+ __result._M_re, __result._M_im);
+ return __result;
+}
+
+// Comparison operators.
+
+template <class _Tp>
+inline bool _STLP_CALL operator==(const complex<_Tp>& __z1, const complex<_Tp>& __z2)
+{ return __z1._M_re == __z2._M_re && __z1._M_im == __z2._M_im; }
+
+template <class _Tp>
+inline bool _STLP_CALL operator==(const complex<_Tp>& __z, const _Tp& __x)
+{ return __z._M_re == __x && __z._M_im == 0; }
+
+template <class _Tp>
+inline bool _STLP_CALL operator==(const _Tp& __x, const complex<_Tp>& __z)
+{ return __x == __z._M_re && 0 == __z._M_im; }
+
+//04/27/04 dums: removal of this check, if it is restablish
+//please explain why the other operators are not macro guarded
+//#ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER
+
+template <class _Tp>
+inline bool _STLP_CALL operator!=(const complex<_Tp>& __z1, const complex<_Tp>& __z2)
+{ return __z1._M_re != __z2._M_re || __z1._M_im != __z2._M_im; }
+
+//#endif /* _STLP_FUNCTION_TMPL_PARTIAL_ORDER */
+
+template <class _Tp>
+inline bool _STLP_CALL operator!=(const complex<_Tp>& __z, const _Tp& __x)
+{ return __z._M_re != __x || __z._M_im != 0; }
+
+template <class _Tp>
+inline bool _STLP_CALL operator!=(const _Tp& __x, const complex<_Tp>& __z)
+{ return __x != __z._M_re || 0 != __z._M_im; }
+
+// Other basic arithmetic operations
+template <class _Tp>
+inline _Tp _STLP_CALL real(const complex<_Tp>& __z)
+{ return __z._M_re; }
+
+template <class _Tp>
+inline _Tp _STLP_CALL imag(const complex<_Tp>& __z)
+{ return __z._M_im; }
+
+template <class _Tp>
+_Tp _STLP_CALL abs(const complex<_Tp>& __z);
+
+template <class _Tp>
+_Tp _STLP_CALL arg(const complex<_Tp>& __z);
+
+template <class _Tp>
+inline _Tp _STLP_CALL norm(const complex<_Tp>& __z)
+{ return __z._M_re * __z._M_re + __z._M_im * __z._M_im; }
+
+template <class _Tp>
+inline complex<_Tp> _STLP_CALL conj(const complex<_Tp>& __z)
+{ return complex<_Tp>(__z._M_re, -__z._M_im); }
+
+template <class _Tp>
+complex<_Tp> _STLP_CALL polar(const _Tp& __rho)
+{ return complex<_Tp>(__rho, 0); }
+
+template <class _Tp>
+complex<_Tp> _STLP_CALL polar(const _Tp& __rho, const _Tp& __phi);
+
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC float _STLP_CALL abs(const complex<float>&);
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC double _STLP_CALL abs(const complex<double>&);
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC float _STLP_CALL arg(const complex<float>&);
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC double _STLP_CALL arg(const complex<double>&);
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC complex<float> _STLP_CALL polar(const float& __rho, const float& __phi);
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC complex<double> _STLP_CALL polar(const double& __rho, const double& __phi);
+
+template <class _Tp>
+_Tp _STLP_CALL abs(const complex<_Tp>& __z)
+{ return _Tp(abs(complex<double>(double(__z.real()), double(__z.imag())))); }
+
+template <class _Tp>
+_Tp _STLP_CALL arg(const complex<_Tp>& __z)
+{ return _Tp(arg(complex<double>(double(__z.real()), double(__z.imag())))); }
+
+template <class _Tp>
+complex<_Tp> _STLP_CALL polar(const _Tp& __rho, const _Tp& __phi) {
+ complex<double> __tmp = polar(double(__rho), double(__phi));
+ return complex<_Tp>(_Tp(__tmp.real()), _Tp(__tmp.imag()));
+}
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC long double _STLP_CALL arg(const complex<long double>&);
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC long double _STLP_CALL abs(const complex<long double>&);
+_STLP_TEMPLATE_NULL
+_STLP_DECLSPEC complex<long double> _STLP_CALL polar(const long double&, const long double&);
+#endif
+
+
+#if !defined (_STLP_USE_NO_IOSTREAMS)
+
+_STLP_END_NAMESPACE
+
+# ifndef _STLP_INTERNAL_IOSFWD
+# include <stl/_iosfwd.h>
+# endif
+
+_STLP_BEGIN_NAMESPACE
+
+// Complex output, in the form (re,im). We use a two-step process
+// involving stringstream so that we get the padding right.
+template <class _Tp, class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& _STLP_CALL
+operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __z);
+
+template <class _Tp, class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& _STLP_CALL
+operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __z);
+
+// Specializations for narrow characters; lets us avoid widen.
+
+_STLP_OPERATOR_TEMPLATE
+_STLP_DECLSPEC basic_istream<char, char_traits<char> >& _STLP_CALL
+operator>>(basic_istream<char, char_traits<char> >& __is, complex<float>& __z);
+
+_STLP_OPERATOR_TEMPLATE
+_STLP_DECLSPEC basic_istream<char, char_traits<char> >& _STLP_CALL
+operator>>(basic_istream<char, char_traits<char> >& __is, complex<double>& __z);
+
+_STLP_OPERATOR_TEMPLATE
+_STLP_DECLSPEC basic_ostream<char, char_traits<char> >& _STLP_CALL
+operator<<(basic_ostream<char, char_traits<char> >& __is, const complex<float>& __z);
+
+_STLP_OPERATOR_TEMPLATE
+_STLP_DECLSPEC basic_ostream<char, char_traits<char> >& _STLP_CALL
+operator<<(basic_ostream<char, char_traits<char> >& __is, const complex<double>& __z);
+
+# if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_OPERATOR_TEMPLATE
+_STLP_DECLSPEC basic_istream<char, char_traits<char> >& _STLP_CALL
+operator>>(basic_istream<char, char_traits<char> >& __is, complex<long double>& __z);
+
+_STLP_OPERATOR_TEMPLATE
+_STLP_DECLSPEC basic_ostream<char, char_traits<char> >& _STLP_CALL
+operator<<(basic_ostream<char, char_traits<char> >& __is, const complex<long double>& __z);
+
+# endif
+
+# if defined (_STLP_USE_TEMPLATE_EXPORT) && ! defined (_STLP_NO_WCHAR_T)
+
+_STLP_EXPORT_TEMPLATE basic_istream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
+operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&, complex<double>&);
+_STLP_EXPORT_TEMPLATE basic_ostream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
+operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&, const complex<double>&);
+_STLP_EXPORT_TEMPLATE basic_istream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
+operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&, complex<float>&);
+_STLP_EXPORT_TEMPLATE basic_ostream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
+operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&, const complex<float>&);
+
+# if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_EXPORT_TEMPLATE basic_istream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
+operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&, complex<long double>&);
+_STLP_EXPORT_TEMPLATE basic_ostream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
+operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&, const complex<long double>&);
+# endif
+# endif
+#endif
+
+
+// Transcendental functions. These are defined only for float,
+// double, and long double. (Sqrt isn't transcendental, of course,
+// but it's included in this section anyway.)
+
+_STLP_DECLSPEC complex<float> _STLP_CALL sqrt(const complex<float>&);
+
+_STLP_DECLSPEC complex<float> _STLP_CALL exp(const complex<float>&);
+_STLP_DECLSPEC complex<float> _STLP_CALL log(const complex<float>&);
+_STLP_DECLSPEC complex<float> _STLP_CALL log10(const complex<float>&);
+
+_STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>&, int);
+_STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>&, const float&);
+_STLP_DECLSPEC complex<float> _STLP_CALL pow(const float&, const complex<float>&);
+_STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>&, const complex<float>&);
+
+_STLP_DECLSPEC complex<float> _STLP_CALL sin(const complex<float>&);
+_STLP_DECLSPEC complex<float> _STLP_CALL cos(const complex<float>&);
+_STLP_DECLSPEC complex<float> _STLP_CALL tan(const complex<float>&);
+
+_STLP_DECLSPEC complex<float> _STLP_CALL sinh(const complex<float>&);
+_STLP_DECLSPEC complex<float> _STLP_CALL cosh(const complex<float>&);
+_STLP_DECLSPEC complex<float> _STLP_CALL tanh(const complex<float>&);
+
+_STLP_DECLSPEC complex<double> _STLP_CALL sqrt(const complex<double>&);
+
+_STLP_DECLSPEC complex<double> _STLP_CALL exp(const complex<double>&);
+_STLP_DECLSPEC complex<double> _STLP_CALL log(const complex<double>&);
+_STLP_DECLSPEC complex<double> _STLP_CALL log10(const complex<double>&);
+
+_STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>&, int);
+_STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>&, const double&);
+_STLP_DECLSPEC complex<double> _STLP_CALL pow(const double&, const complex<double>&);
+_STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>&, const complex<double>&);
+
+_STLP_DECLSPEC complex<double> _STLP_CALL sin(const complex<double>&);
+_STLP_DECLSPEC complex<double> _STLP_CALL cos(const complex<double>&);
+_STLP_DECLSPEC complex<double> _STLP_CALL tan(const complex<double>&);
+
+_STLP_DECLSPEC complex<double> _STLP_CALL sinh(const complex<double>&);
+_STLP_DECLSPEC complex<double> _STLP_CALL cosh(const complex<double>&);
+_STLP_DECLSPEC complex<double> _STLP_CALL tanh(const complex<double>&);
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_DECLSPEC complex<long double> _STLP_CALL sqrt(const complex<long double>&);
+_STLP_DECLSPEC complex<long double> _STLP_CALL exp(const complex<long double>&);
+_STLP_DECLSPEC complex<long double> _STLP_CALL log(const complex<long double>&);
+_STLP_DECLSPEC complex<long double> _STLP_CALL log10(const complex<long double>&);
+
+_STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>&, int);
+_STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>&, const long double&);
+_STLP_DECLSPEC complex<long double> _STLP_CALL pow(const long double&, const complex<long double>&);
+_STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>&,
+ const complex<long double>&);
+
+_STLP_DECLSPEC complex<long double> _STLP_CALL sin(const complex<long double>&);
+_STLP_DECLSPEC complex<long double> _STLP_CALL cos(const complex<long double>&);
+_STLP_DECLSPEC complex<long double> _STLP_CALL tan(const complex<long double>&);
+
+_STLP_DECLSPEC complex<long double> _STLP_CALL sinh(const complex<long double>&);
+_STLP_DECLSPEC complex<long double> _STLP_CALL cosh(const complex<long double>&);
+_STLP_DECLSPEC complex<long double> _STLP_CALL tanh(const complex<long double>&);
+#endif
+
+_STLP_END_NAMESPACE
+
+#ifndef _STLP_LINK_TIME_INSTANTIATION
+# include <stl/_complex.c>
+#endif
+
+#endif
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_config_compat_post.h b/sources/android/stlport/stlport/stl/_config_compat_post.h
new file mode 100644
index 0000000..e3b4111
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_config_compat_post.h
@@ -0,0 +1,51 @@
+/*========================================== */
+#if 1 /* def _STLP_3_COMPATIBILITY */
+
+# define __SGI_STL_PORT _STLPORT_VERSION
+
+# if defined (_STLP_DEBUG) && ! defined ( __STL_DEBUG )
+# define __STL_DEBUG _STLP_DEBUG
+# endif
+
+# if defined (_STLP_USE_NAMESPACES)
+# undef __STL_USE_NAMESPACES
+# define __STL_USE_NAMESPACES _STLP_USE_NAMESPACES
+# endif
+
+# if defined (_STLP_USE_EXCEPTIONS)
+# undef __STL_USE_EXCEPTIONS
+# define __STL_USE_EXCEPTIONS _STLP_USE_EXCEPTIONS
+# endif
+
+# if defined (_STLP_BEGIN_NAMESPACE) && ! defined ( __STL_BEGIN_NAMESPACE )
+# define __STL_BEGIN_NAMESPACE _STLP_BEGIN_NAMESPACE
+# define __STL_END_NAMESPACE _STLP_END_NAMESPACE
+# define __STL_VENDOR_STD _STLP_VENDOR_STD
+# define __STL_VENDOR_CSTD _STLP_VENDOR_CSTD
+# endif
+# endif
+
+/*
+# if defined (_STLP_XXX) && ! defined ( __STL_XXX )
+# define __STL_XXX _STLP_XXX
+# endif
+*/
+
+/* 5.0 -> 4.6 compatibility section */
+#if 1 /* def _STLP_46_COMPATIBILITY */
+
+/* provide a uniform way to access full functionality */
+# define __slist__ slist
+# define __map__ map
+# define __multimap__ multimap
+# define __set__ set
+# define __multiset__ multiset
+# define __list__ list
+# define __hash_map__ hash_map
+# define __hash_multimap__ hash_multimap
+# define __hash_set__ hash_set
+# define __hash_multiset__ hash_multiset
+# define __vector__ vector
+
+#endif
+
diff --git a/sources/android/stlport/stlport/stl/_construct.h b/sources/android/stlport/stlport/stl/_construct.h
new file mode 100644
index 0000000..9361878
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_construct.h
@@ -0,0 +1,289 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_CONSTRUCT_H
+#define _STLP_INTERNAL_CONSTRUCT_H
+
+#if !defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_INTERNAL_CSTRING)
+# include <stl/_cstring.h>
+#endif
+
+#ifndef _STLP_INTERNAL_NEW
+# include <stl/_new.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
+# include <stl/_iterator_base.h>
+#endif
+
+#ifndef _STLP_TYPE_TRAITS_H
+# include <stl/type_traits.h>
+#endif
+
+#if !defined (_STLP_MOVE_CONSTRUCT_FWK_H) && !defined (_STLP_NO_MOVE_SEMANTIC)
+# include <stl/_move_construct_fwk.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Tp>
+inline void __destroy_aux(_Tp* __pointer, const __false_type& /*_Trivial_destructor*/)
+{ __pointer->~_Tp(); }
+
+template <class _Tp>
+inline void __destroy_aux(_Tp*, const __true_type& /*_Trivial_destructor*/) {}
+
+template <class _Tp>
+inline void _Destroy(_Tp* __pointer) {
+ typedef typename __type_traits<_Tp>::has_trivial_destructor _Trivial_destructor;
+ __destroy_aux(__pointer, _Trivial_destructor());
+#if defined (_STLP_DEBUG_UNINITIALIZED)
+ memset(__REINTERPRET_CAST(char*, __pointer), _STLP_SHRED_BYTE, sizeof(_Tp));
+#endif
+}
+
+template <class _Tp>
+inline void _Destroy_Moved(_Tp* __pointer) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef typename __move_traits<_Tp>::complete _Trivial_destructor;
+ __destroy_aux(__pointer, _Trivial_destructor());
+# if defined (_STLP_DEBUG_UNINITIALIZED)
+ memset((char*)__pointer, _STLP_SHRED_BYTE, sizeof(_Tp));
+# endif
+#else
+ _Destroy(__pointer);
+#endif
+}
+
+#if defined (new)
+# define _STLP_NEW_REDEFINE new
+# undef new
+#endif
+
+template <class _T1>
+inline void _Construct_aux (_T1* __p, const __false_type&) {
+ new(__p) _T1();
+}
+
+template <class _T1>
+inline void _Construct_aux (_T1* __p, const __true_type&) {
+#if defined (_STLP_DEF_CONST_PLCT_NEW_BUG)
+ *__p = _T1(0);
+#else
+ // We use binary copying for POD types since it results
+ // in a considerably better code at least on MSVC.
+ *__p = _T1();
+#endif /* _STLP_DEF_CONST_PLCT_NEW_BUG */
+}
+
+template <class _T1>
+inline void _Construct(_T1* __p) {
+#if defined (_STLP_DEBUG_UNINITIALIZED)
+ memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_T1));
+#endif
+#if defined (_STLP_DEF_CONST_PLCT_NEW_BUG)
+ _Construct_aux (__p, _HasDefaultZeroValue(__p)._Answer());
+#else
+ _Construct_aux (__p, _Is_POD(__p)._Answer());
+#endif /* _STLP_DEF_CONST_PLCT_NEW_BUG */
+}
+
+template <class _Tp>
+inline void _Copy_Construct_aux(_Tp* __p, const _Tp& __val, const __false_type&) {
+ new(__p) _Tp(__val);
+}
+
+template <class _Tp>
+inline void _Copy_Construct_aux(_Tp* __p, const _Tp& __val, const __true_type&) {
+ // We use binary copying for POD types since it results
+ // in a considerably better code at least on MSVC.
+ *__p = __val;
+}
+
+template <class _Tp>
+inline void _Copy_Construct(_Tp* __p, const _Tp& __val) {
+#if defined (_STLP_DEBUG_UNINITIALIZED)
+ memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_Tp));
+#endif
+ _Copy_Construct_aux(__p, __val, _Is_POD(__p)._Answer());
+}
+
+template <class _T1, class _T2>
+inline void _Param_Construct_aux(_T1* __p, const _T2& __val, const __false_type&) {
+ new(__p) _T1(__val);
+}
+
+template <class _T1, class _T2>
+inline void _Param_Construct_aux(_T1* __p, const _T2& __val, const __true_type&) {
+ // We use binary copying for POD types since it results
+ // in a considerably better code at least on MSVC.
+ *__p = _T1(__val);
+}
+
+template <class _T1, class _T2>
+inline void _Param_Construct(_T1* __p, const _T2& __val) {
+#if defined (_STLP_DEBUG_UNINITIALIZED)
+ memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_T1));
+#endif
+ _Param_Construct_aux(__p, __val, _Is_POD(__p)._Answer());
+}
+
+template <class _T1, class _T2>
+inline void _Move_Construct_Aux(_T1* __p, _T2& __val, const __false_type& /*_IsPOD*/) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ new(__p) _T1(_STLP_PRIV _AsMoveSource(__val));
+#else
+ _Param_Construct(__p, __val);
+#endif
+}
+
+template <class _T1, class _T2>
+inline void _Move_Construct_Aux(_T1* __p, _T2& __val, const __true_type& /*_IsPOD*/) {
+ // We use binary copying for POD types since it results
+ // in a considerably better code at least on MSVC.
+ *__p = _T1(__val);
+}
+
+template <class _T1, class _T2>
+inline void _Move_Construct(_T1* __p, _T2& __val) {
+#if defined (_STLP_DEBUG_UNINITIALIZED)
+ memset((char*)__p, _STLP_SHRED_BYTE, sizeof(_T1));
+#endif
+ _Move_Construct_Aux(__p, __val, _Is_POD(__p)._Answer());
+}
+
+#if defined(_STLP_NEW_REDEFINE)
+# if defined (DEBUG_NEW)
+# define new DEBUG_NEW
+# endif
+# undef _STLP_NEW_REDEFINE
+#endif
+
+template <class _ForwardIterator, class _Tp>
+_STLP_INLINE_LOOP void
+__destroy_range_aux(_ForwardIterator __first, _ForwardIterator __last, _Tp*, const __false_type& /*_Trivial_destructor*/) {
+ for ( ; __first != __last; ++__first) {
+ __destroy_aux(&(*__first), __false_type());
+#if defined (_STLP_DEBUG_UNINITIALIZED)
+ memset((char*)&(*__first), _STLP_SHRED_BYTE, sizeof(_Tp));
+#endif
+ }
+}
+
+template <class _ForwardIterator, class _Tp>
+#if defined (_STLP_DEBUG_UNINITIALIZED)
+_STLP_INLINE_LOOP void
+__destroy_range_aux(_ForwardIterator __first, _ForwardIterator __last, _Tp*, const __true_type& /*_Trivial_destructor*/) {
+ for ( ; __first != __last; ++__first)
+ memset((char*)&(*__first), _STLP_SHRED_BYTE, sizeof(_Tp));
+}
+#else
+inline void
+__destroy_range_aux(_ForwardIterator, _ForwardIterator, _Tp*, const __true_type& /*_Trivial_destructor*/) {}
+#endif
+
+template <class _ForwardIterator, class _Tp>
+inline void
+__destroy_range(_ForwardIterator __first, _ForwardIterator __last, _Tp *__ptr) {
+ typedef typename __type_traits<_Tp>::has_trivial_destructor _Trivial_destructor;
+ __destroy_range_aux(__first, __last, __ptr, _Trivial_destructor());
+}
+
+template <class _ForwardIterator>
+inline void _Destroy_Range(_ForwardIterator __first, _ForwardIterator __last) {
+ __destroy_range(__first, __last, _STLP_VALUE_TYPE(__first, _ForwardIterator));
+}
+
+inline void _Destroy_Range(char*, char*) {}
+#if defined (_STLP_HAS_WCHAR_T) // dwa 8/15/97
+inline void _Destroy_Range(wchar_t*, wchar_t*) {}
+inline void _Destroy_Range(const wchar_t*, const wchar_t*) {}
+#endif
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _ForwardIterator, class _Tp>
+inline void
+__destroy_mv_srcs(_ForwardIterator __first, _ForwardIterator __last, _Tp *__ptr) {
+ typedef typename __move_traits<_Tp>::complete _CompleteMove;
+ __destroy_range_aux(__first, __last, __ptr, _CompleteMove());
+}
+#endif
+
+template <class _ForwardIterator>
+inline void _Destroy_Moved_Range(_ForwardIterator __first, _ForwardIterator __last)
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+{ __destroy_mv_srcs(__first, __last, _STLP_VALUE_TYPE(__first, _ForwardIterator)); }
+#else
+{ _Destroy_Range(__first, __last); }
+#endif
+
+#if defined (_STLP_DEF_CONST_DEF_PARAM_BUG)
+// Those adaptors are here to fix common compiler bug regarding builtins:
+// expressions like int k = int() should initialize k to 0
+template <class _Tp>
+inline _Tp __default_constructed_aux(_Tp*, const __false_type&) {
+ return _Tp();
+}
+template <class _Tp>
+inline _Tp __default_constructed_aux(_Tp*, const __true_type&) {
+ return _Tp(0);
+}
+
+template <class _Tp>
+inline _Tp __default_constructed(_Tp* __p) {
+ return __default_constructed_aux(__p, _HasDefaultZeroValue(__p)._Answer());
+}
+
+# define _STLP_DEFAULT_CONSTRUCTED(_TTp) __default_constructed((_TTp*)0)
+#else
+# define _STLP_DEFAULT_CONSTRUCTED(_TTp) _TTp()
+#endif /* _STLP_DEF_CONST_DEF_PARAM_BUG */
+
+
+#if !defined (_STLP_NO_ANACHRONISMS)
+// --------------------------------------------------
+// Old names from the HP STL.
+
+template <class _T1, class _T2>
+inline void construct(_T1* __p, const _T2& __val) {_Param_Construct(__p, __val); }
+template <class _T1>
+inline void construct(_T1* __p) { _STLP_STD::_Construct(__p); }
+template <class _Tp>
+inline void destroy(_Tp* __pointer) { _STLP_STD::_Destroy(__pointer); }
+template <class _ForwardIterator>
+inline void destroy(_ForwardIterator __first, _ForwardIterator __last) { _STLP_STD::_Destroy_Range(__first, __last); }
+#endif /* _STLP_NO_ANACHRONISMS */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_CONSTRUCT_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_cprolog.h b/sources/android/stlport/stlport/stl/_cprolog.h
new file mode 100644
index 0000000..1d27656
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_cprolog.h
@@ -0,0 +1,25 @@
+/* NOTE : this header has no guards and is MEANT for multiple inclusion!
+ * If you are using "header protection" option with your compiler,
+ * please also find #pragma which disables it and put it here, to
+ * allow reentrancy of this header.
+ */
+
+#ifdef std
+# undef std /* We undef "std" on entry , as STLport headers may include native ones. */
+#endif
+
+#ifdef _STLP_PROLOG_HEADER_INCLUDED
+# error STlport prolog header can not be reincluded as long as epilog has not be included.
+#endif
+
+#define _STLP_PROLOG_HEADER_INCLUDED
+
+#ifndef _STLP_FEATURES_H
+# include <stl/config/features.h>
+#endif
+
+/* If the platform provides any specific prolog actions,
+ * like #pragmas, do include platform-specific prolog file */
+#if defined (_STLP_HAS_SPECIFIC_PROLOG_EPILOG)
+# include <stl/config/_prolog.h>
+#endif
diff --git a/sources/android/stlport/stlport/stl/_csetjmp.h b/sources/android/stlport/stlport/stl/_csetjmp.h
new file mode 100644
index 0000000..ca132c1
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_csetjmp.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_CSETJMP
+#define _STLP_INTERNAL_CSETJMP
+
+// if the macro is on, the header is already there
+#if !defined (setjmp)
+# if defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <csetjmp>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(csetjmp)
+# endif
+# else
+# include <setjmp.h>
+# endif
+#endif
+
+#if defined (_STLP_IMPORT_VENDOR_CSTD)
+
+# if defined (__BORLANDC__) && defined (_STLP_USE_NEW_C_HEADERS)
+/* For Borland, even if stdjmp.h is included symbols won't be in global namespace
+ * so we need to reach them in vendor namespace:
+ */
+# undef _STLP_NATIVE_SETJMP_H_INCLUDED
+# endif
+
+_STLP_BEGIN_NAMESPACE
+# if !defined (_STLP_NATIVE_SETJMP_H_INCLUDED)
+using _STLP_VENDOR_CSTD::jmp_buf;
+# else
+// if setjmp.h was included first, this is in global namespace, not in
+// vendor's std. - 2005-08-04, ptr
+using ::jmp_buf;
+# endif
+# if !defined (_STLP_NO_CSTD_FUNCTION_IMPORTS)
+# if !defined (setjmp)
+# if !defined (__MSL__) || ((__MSL__ > 0x7001) && (__MSL__ < 0x8000))
+# ifndef _STLP_NATIVE_SETJMP_H_INCLUDED
+using _STLP_VENDOR_CSTD::setjmp;
+# else
+using ::setjmp;
+# endif
+# endif
+# endif
+# if !defined (_STLP_NATIVE_SETJMP_H_INCLUDED)
+using _STLP_VENDOR_CSTD::longjmp;
+# else
+using ::longjmp;
+# endif
+# endif
+_STLP_END_NAMESPACE
+#endif /* _STLP_IMPORT_VENDOR_CSTD */
+
+#endif
diff --git a/sources/android/stlport/stlport/stl/_csignal.h b/sources/android/stlport/stlport/stl/_csignal.h
new file mode 100644
index 0000000..551846b
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_csignal.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_CSIGNAL
+#define _STLP_INTERNAL_CSIGNAL
+
+#if !defined (_STLP_WCE)
+# if defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <csignal>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(csignal)
+# endif
+# else
+# include <signal.h>
+# endif
+
+# if defined (_STLP_IMPORT_VENDOR_CSTD)
+_STLP_BEGIN_NAMESPACE
+# if !defined (_STLP_NO_CSTD_FUNCTION_IMPORTS)
+using _STLP_VENDOR_CSTD::signal;
+using _STLP_VENDOR_CSTD::raise;
+# endif /* _STLP_NO_CSTD_FUNCTION_IMPORTS */
+using _STLP_VENDOR_CSTD::sig_atomic_t;
+_STLP_END_NAMESPACE
+# endif /* _STLP_IMPORT_VENDOR_CSTD */
+#endif
+
+#endif /* _STLP_INTERNAL_CSIGNAL */
diff --git a/sources/android/stlport/stlport/stl/_cstdarg.h b/sources/android/stlport/stlport/stl/_cstdarg.h
new file mode 100644
index 0000000..e98f31c
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_cstdarg.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+#ifndef _STLP_INTERNAL_CSTDARG
+#define _STLP_INTERNAL_CSTDARG
+
+#if defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cstdarg>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cstdarg)
+# endif
+#else
+# include <stdarg.h>
+#endif
+
+#ifdef _STLP_IMPORT_VENDOR_CSTD
+_STLP_BEGIN_NAMESPACE
+using _STLP_VENDOR_CSTD::va_list;
+_STLP_END_NAMESPACE
+#endif /* _STLP_IMPORT_VENDOR_CSTD */
+
+#endif
diff --git a/sources/android/stlport/stlport/stl/_cstddef.h b/sources/android/stlport/stlport/stl/_cstddef.h
new file mode 100644
index 0000000..35a585c
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_cstddef.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_CSTDDEF
+#define _STLP_INTERNAL_CSTDDEF
+
+# if (__GNUC__ >= 3) && defined (__CYGWIN__) // this total HACK is the only expedient way I could cygwin to work with GCC 3.0
+# define __need_wint_t // mostly because wint_t didn't seem to get defined otherwise :(
+# define __need_wchar_t
+# define __need_size_t
+# define __need_ptrdiff_t
+# define __need_NULL
+# endif
+
+# if defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cstddef>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cstddef)
+# endif
+# else
+# include <stddef.h>
+# endif
+
+# ifdef _STLP_IMPORT_VENDOR_CSTD
+_STLP_BEGIN_NAMESPACE
+using _STLP_VENDOR_CSTD::ptrdiff_t;
+using _STLP_VENDOR_CSTD::size_t;
+_STLP_END_NAMESPACE
+# endif /* _STLP_IMPORT_VENDOR_CSTD */
+
+#endif /* _STLP_INTERNAL_CSTDDEF */
diff --git a/sources/android/stlport/stlport/stl/_cstdio.h b/sources/android/stlport/stlport/stl/_cstdio.h
new file mode 100644
index 0000000..67236f2
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_cstdio.h
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_CSTDIO
+#define _STLP_INTERNAL_CSTDIO
+
+#if defined (__Lynx__)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <stdarg.h>
+# else
+# include _STLP_NATIVE_C_HEADER(stdarg.h)
+# endif
+#endif
+
+#if defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cstdio>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cstdio)
+# endif
+#else
+# include <stdio.h>
+#endif
+
+#if defined (__MWERKS__)
+# undef stdin
+# undef stdout
+# undef stderr
+# define stdin (&_STLP_VENDOR_CSTD::__files[0])
+# define stdout (&_STLP_VENDOR_CSTD::__files[1])
+# define stderr (&_STLP_VENDOR_CSTD::__files[2])
+#endif
+
+#if defined (_STLP_MSVC_LIB) && (_STLP_MSVC_LIB < 1400) || defined (_STLP_USING_PLATFORM_SDK_COMPILER)
+inline int vsnprintf(char *s1, size_t n, const char *s2, va_list v)
+{ return _STLP_VENDOR_CSTD::_vsnprintf(s1, n, s2, v); }
+#endif
+
+#if defined (_STLP_IMPORT_VENDOR_CSTD )
+_STLP_BEGIN_NAMESPACE
+using _STLP_VENDOR_CSTD::FILE;
+using _STLP_VENDOR_CSTD::fpos_t;
+using _STLP_VENDOR_CSTD::size_t;
+
+// undef obsolete macros
+# undef putc
+# undef getc
+# undef getchar
+# undef putchar
+# undef feof
+# undef ferror
+
+# if !defined (_STLP_NO_CSTD_FUNCTION_IMPORTS)
+using _STLP_VENDOR_CSTD::clearerr;
+using _STLP_VENDOR_CSTD::fclose;
+using _STLP_VENDOR_CSTD::feof;
+using _STLP_VENDOR_CSTD::ferror;
+using _STLP_VENDOR_CSTD::fflush;
+using _STLP_VENDOR_CSTD::fgetc;
+using _STLP_VENDOR_CSTD::fgetpos;
+using _STLP_VENDOR_CSTD::fgets;
+using _STLP_VENDOR_CSTD::fopen;
+using _STLP_VENDOR_CSTD::fprintf;
+using _STLP_VENDOR_CSTD::fputc;
+using _STLP_VENDOR_CSTD::fputs;
+using _STLP_VENDOR_CSTD::fread;
+# if !defined (_WIN32_WCE) || (_WIN32_WCE < 400)
+using _STLP_VENDOR_CSTD::freopen;
+# endif
+using _STLP_VENDOR_CSTD::fscanf;
+using _STLP_VENDOR_CSTD::fseek;
+using _STLP_VENDOR_CSTD::fsetpos;
+using _STLP_VENDOR_CSTD::ftell;
+using _STLP_VENDOR_CSTD::fwrite;
+
+# if !(defined (__IBMCPP__) && (__IBMCPP__ >= 500))
+# if !defined (_WIN32_WCE) || (_WIN32_WCE < 400) // Supplied as macros, TODO: use inline function to redirect to the macros?
+ using _STLP_VENDOR_CSTD::getc;
+ using _STLP_VENDOR_CSTD::putc;
+# endif
+ using _STLP_VENDOR_CSTD::getchar;
+ using _STLP_VENDOR_CSTD::putchar;
+# endif
+
+using _STLP_VENDOR_CSTD::gets;
+# if !defined (_WIN32_WCE) || (_WIN32_WCE < 400)
+using _STLP_VENDOR_CSTD::perror;
+# endif
+using _STLP_VENDOR_CSTD::printf;
+using _STLP_VENDOR_CSTD::puts;
+# if !defined (_WIN32_WCE) || (_WIN32_WCE < 400)
+using _STLP_VENDOR_CSTD::remove;
+using _STLP_VENDOR_CSTD::rename;
+using _STLP_VENDOR_CSTD::rewind;
+using _STLP_VENDOR_CSTD::setbuf;
+using _STLP_VENDOR_CSTD::tmpfile;
+using _STLP_VENDOR_CSTD::tmpnam;
+# endif
+using _STLP_VENDOR_CSTD::scanf;
+using _STLP_VENDOR_CSTD::setvbuf;
+using _STLP_VENDOR_CSTD::sprintf;
+using _STLP_VENDOR_CSTD::sscanf;
+using _STLP_VENDOR_CSTD::ungetc;
+using _STLP_VENDOR_CSTD::vfprintf;
+using _STLP_VENDOR_CSTD::vprintf;
+using _STLP_VENDOR_CSTD::vsprintf;
+# if (defined (__MWERKS__) || (defined (_STLP_MSVC_LIB) && (_STLP_MSVC_LIB < 1400)) || \
+ (defined (__BORLANDC__)))
+using _STLP_VENDOR_CSTD::vsnprintf;
+# endif
+# endif /* _STLP_NO_CSTD_FUNCTION_IMPORTS */
+_STLP_END_NAMESPACE
+#endif /* _STLP_IMPORT_VENDOR_CSTD */
+
+#endif /* _STLP_INTERNAL_CSTDIO */
diff --git a/sources/android/stlport/stlport/stl/_cstdlib.h b/sources/android/stlport/stlport/stl/_cstdlib.h
new file mode 100644
index 0000000..4d1dd35
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_cstdlib.h
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_CSTDLIB
+#define _STLP_INTERNAL_CSTDLIB
+
+#if defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cstdlib>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cstdlib)
+# endif
+#else
+# include <stdlib.h>
+#endif
+
+#if defined (__BORLANDC__) && !defined (__linux__)
+/* Borland process.h header do not bring anything here and is just included
+ * in order to avoid inclusion later. This header cannot be included later
+ * because Borland compiler consider that for instance the abort function
+ * defined as extern "C" cannot be overloaded and it finds 2 "overloads",
+ * once in native std namespace and the other in STLport namespace...
+ */
+# include <process.h>
+#endif
+
+/* on evc3/evc4 including stdlib.h also defines setjmp macro */
+#if defined (_STLP_WCE)
+# define _STLP_NATIVE_SETJMP_H_INCLUDED
+#endif
+
+#if defined (__MSL__) && (__MSL__ <= 0x5003)
+namespace std {
+ typedef ::div_t div_t;
+ typedef ::ldiv_t ldiv_t;
+# ifdef __MSL_LONGLONG_SUPPORT__
+ typedef ::lldiv_t lldiv_t;
+# endif
+}
+#endif
+
+#ifdef _STLP_IMPORT_VENDOR_CSTD
+_STLP_BEGIN_NAMESPACE
+using _STLP_VENDOR_CSTD::div_t;
+using _STLP_VENDOR_CSTD::ldiv_t;
+using _STLP_VENDOR_CSTD::size_t;
+
+# ifndef _STLP_NO_CSTD_FUNCTION_IMPORTS
+# ifndef _STLP_WCE
+// these functions just don't exist on Windows CE
+using _STLP_VENDOR_CSTD::abort;
+using _STLP_VENDOR_CSTD::getenv;
+using _STLP_VENDOR_CSTD::mblen;
+using _STLP_VENDOR_CSTD::mbtowc;
+using _STLP_VENDOR_CSTD::system;
+using _STLP_VENDOR_CSTD::bsearch;
+# endif
+using _STLP_VENDOR_CSTD::atexit;
+using _STLP_VENDOR_CSTD::exit;
+using _STLP_VENDOR_CSTD::calloc;
+using _STLP_VENDOR_CSTD::free;
+using _STLP_VENDOR_CSTD::malloc;
+using _STLP_VENDOR_CSTD::realloc;
+using _STLP_VENDOR_CSTD::atof;
+using _STLP_VENDOR_CSTD::atoi;
+using _STLP_VENDOR_CSTD::atol;
+using _STLP_VENDOR_CSTD::mbstowcs;
+using _STLP_VENDOR_CSTD::strtod;
+using _STLP_VENDOR_CSTD::strtol;
+using _STLP_VENDOR_CSTD::strtoul;
+
+# if !(defined (_STLP_NO_NATIVE_WIDE_STREAMS) || defined (_STLP_NO_NATIVE_MBSTATE_T))
+using _STLP_VENDOR_CSTD::wcstombs;
+# ifndef _STLP_WCE
+using _STLP_VENDOR_CSTD::wctomb;
+# endif
+# endif
+using _STLP_VENDOR_CSTD::qsort;
+using _STLP_VENDOR_CSTD::labs;
+using _STLP_VENDOR_CSTD::ldiv;
+# if defined (_STLP_LONG_LONG) && !defined (_STLP_NO_VENDOR_STDLIB_L)
+# if !defined(__sun)
+using _STLP_VENDOR_CSTD::llabs;
+using _STLP_VENDOR_CSTD::lldiv_t;
+using _STLP_VENDOR_CSTD::lldiv;
+# else
+using ::llabs;
+using ::lldiv_t;
+using ::lldiv;
+# endif
+# endif
+using _STLP_VENDOR_CSTD::rand;
+using _STLP_VENDOR_CSTD::srand;
+# endif /* _STLP_NO_CSTD_FUNCTION_IMPORTS */
+_STLP_END_NAMESPACE
+#endif /* _STLP_IMPORT_VENDOR_CSTD */
+
+#if (defined (__BORLANDC__) || defined (__WATCOMC__)) && defined (_STLP_USE_NEW_C_HEADERS)
+//In this config bcc define everything in std namespace and not in
+//the global one.
+inline int abs(int __x) { return _STLP_VENDOR_CSTD::abs(__x); }
+inline _STLP_VENDOR_CSTD::div_t div(int __x, int __y) { return _STLP_VENDOR_CSTD::div(__x, __y); }
+#endif
+
+#if defined(_MSC_EXTENSIONS) && defined(_STLP_MSVC) && (_STLP_MSVC <= 1300)
+# define _STLP_RESTORE_FUNCTION_INTRINSIC
+# pragma warning (push)
+# pragma warning (disable: 4162)
+# pragma function (abs)
+#endif
+
+//HP-UX native lib has abs() and div() functions in global namespace
+#if !defined (__SUNPRO_CC) && \
+ (!defined (__HP_aCC) || (__HP_aCC < 30000))
+
+//MSVC starting with .Net 2003 already define all math functions in global namespace:
+# if !defined (__WATCOMC__) && \
+ (!defined (_STLP_MSVC_LIB) || (_STLP_MSVC_LIB < 1310) || defined (UNDER_CE))
+inline long abs(long __x) { return _STLP_VENDOR_CSTD::labs(__x); }
+# endif
+
+/** VC since version 8 has this, the platform SDK and CE SDKs hanging behind. */
+# if !defined (__WATCOMC__) && \
+ (!defined (_STLP_MSVC_LIB) || (_STLP_MSVC_LIB < 1400) || defined (_STLP_USING_PLATFORM_SDK_COMPILER) || defined (UNDER_CE))
+inline _STLP_VENDOR_CSTD::ldiv_t div(long __x, long __y) { return _STLP_VENDOR_CSTD::ldiv(__x, __y); }
+# endif
+
+#endif
+
+#if defined (_STLP_RESTORE_FUNCTION_INTRINSIC)
+# pragma intrinsic (abs)
+# pragma warning (pop)
+# undef _STLP_RESTORE_FUNCTION_INTRINSIC
+#endif
+
+#if defined (_STLP_LONG_LONG)
+# if !defined (_STLP_NO_VENDOR_STDLIB_L)
+# if !defined (__sun)
+inline _STLP_LONG_LONG abs(_STLP_LONG_LONG __x) { return _STLP_VENDOR_CSTD::llabs(__x); }
+inline lldiv_t div(_STLP_LONG_LONG __x, _STLP_LONG_LONG __y) { return _STLP_VENDOR_CSTD::lldiv(__x, __y); }
+# else
+inline _STLP_LONG_LONG abs(_STLP_LONG_LONG __x) { return ::llabs(__x); }
+inline lldiv_t div(_STLP_LONG_LONG __x, _STLP_LONG_LONG __y) { return ::lldiv(__x, __y); }
+# endif
+# else
+inline _STLP_LONG_LONG abs(_STLP_LONG_LONG __x) { return __x < 0 ? -__x : __x; }
+# endif
+#endif
+
+/* C++ Standard is unclear about several call to 'using ::func' if new overloads
+ * of ::func appears between 2 successive 'using' calls. To avoid this potential
+ * problem we provide all abs overload before the 'using' call.
+ * Beware: This header inclusion has to be after all abs overload of this file.
+ * The first 'using ::abs' call is going to be in the other header.
+ */
+#ifndef _STLP_INTERNAL_CMATH
+# include <stl/_cmath.h>
+#endif
+
+#if defined (_STLP_IMPORT_VENDOR_CSTD) && !defined (_STLP_NO_CSTD_FUNCTION_IMPORTS)
+// ad hoc, don't replace with _STLP_VENDOR_CSTD::abs here! - ptr 2005-03-05
+_STLP_BEGIN_NAMESPACE
+using ::abs;
+using ::div;
+_STLP_END_NAMESPACE
+#endif
+
+#endif /* _STLP_INTERNAL_CSTDLIB */
diff --git a/sources/android/stlport/stlport/stl/_cstring.h b/sources/android/stlport/stlport/stl/_cstring.h
new file mode 100644
index 0000000..fe0fd5f
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_cstring.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_CSTRING
+#define _STLP_INTERNAL_CSTRING
+
+#if defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cstring>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cstring)
+# endif
+#else
+# include <string.h>
+#endif
+
+#ifdef _STLP_IMPORT_VENDOR_CSTD
+_STLP_BEGIN_NAMESPACE
+# include <using/cstring>
+_STLP_END_NAMESPACE
+#endif /* _STLP_IMPORT_VENDOR_CSTD */
+
+#endif /* _STLP_INTERNAL_CSTRING */
diff --git a/sources/android/stlport/stlport/stl/_ctime.h b/sources/android/stlport/stlport/stl/_ctime.h
new file mode 100644
index 0000000..56e433b
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_ctime.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_CTIME
+#define _STLP_INTERNAL_CTIME
+
+#if !defined (_STLP_WCE_EVC3)
+
+# if defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <ctime>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(ctime)
+# endif
+# else
+# include <time.h>
+# endif
+
+# if defined (_STLP_IMPORT_VENDOR_CSTD)
+_STLP_BEGIN_NAMESPACE
+using _STLP_VENDOR_CSTD::size_t;
+using _STLP_VENDOR_CSTD::clock_t;
+using _STLP_VENDOR_CSTD::time_t;
+using _STLP_VENDOR_CSTD::tm;
+# if !defined (_STLP_NO_CSTD_FUNCTION_IMPORTS)
+using _STLP_VENDOR_CSTD::clock;
+using _STLP_VENDOR_CSTD::asctime;
+using _STLP_VENDOR_CSTD::ctime;
+using _STLP_VENDOR_CSTD::gmtime;
+
+# if !defined (_WIN32_WCE) || (_WIN32_WCE < 0x500) // CE5 stopped supplying this
+using _STLP_VENDOR_CSTD::difftime;
+# endif
+using _STLP_VENDOR_CSTD::mktime;
+using _STLP_VENDOR_CSTD::localtime;
+using _STLP_VENDOR_CSTD::strftime;
+using _STLP_VENDOR_CSTD::time;
+# endif /* _STLP_NO_CSTD_FUNCTION_IMPORTS */
+_STLP_END_NAMESPACE
+# endif /* _STLP_IMPORT_VENDOR_CSTD */
+
+#endif
+
+#endif /* _STLP_INTERNAL_CTIME */
diff --git a/sources/android/stlport/stlport/stl/_ctraits_fns.h b/sources/android/stlport/stlport/stl/_ctraits_fns.h
new file mode 100644
index 0000000..e4a4af1
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_ctraits_fns.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ */
+
+// WARNING: This is an internal header file, included by other C++
+// standard library headers. You should not attempt to use this header
+// file directly.
+
+#ifndef _STLP_INTERNAL_CTRAITS_FUNCTIONS_H
+#define _STLP_INTERNAL_CTRAITS_FUNCTIONS_H
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+# include <stl/_function_base.h>
+#endif
+
+// This file contains a few small adapters that allow a character
+// traits class to be used as a function object.
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Traits>
+struct _Eq_traits
+ : public binary_function<typename _Traits::char_type,
+ typename _Traits::char_type,
+ bool> {
+ bool operator()(const typename _Traits::char_type& __x,
+ const typename _Traits::char_type& __y) const
+ { return _Traits::eq(__x, __y); }
+};
+
+template <class _Traits>
+struct _Eq_char_bound
+ : public unary_function<typename _Traits::char_type, bool> {
+ typename _Traits::char_type __val;
+ _Eq_char_bound(typename _Traits::char_type __c) : __val(__c) {}
+ bool operator()(const typename _Traits::char_type& __x) const
+ { return _Traits::eq(__x, __val); }
+};
+
+template <class _Traits>
+struct _Neq_char_bound
+ : public unary_function<typename _Traits::char_type, bool>
+{
+ typename _Traits::char_type __val;
+ _Neq_char_bound(typename _Traits::char_type __c) : __val(__c) {}
+ bool operator()(const typename _Traits::char_type& __x) const
+ { return !_Traits::eq(__x, __val); }
+};
+
+template <class _Traits>
+struct _Eq_int_bound
+ : public unary_function<typename _Traits::char_type, bool> {
+ typename _Traits::int_type __val;
+
+ _Eq_int_bound(typename _Traits::int_type __c) : __val(__c) {}
+ bool operator()(const typename _Traits::char_type& __x) const
+ { return _Traits::eq_int_type(_Traits::to_int_type(__x), __val); }
+};
+
+#if 0
+template <class _Traits>
+struct _Lt_traits
+ : public binary_function<typename _Traits::char_type,
+ typename _Traits::char_type,
+ bool> {
+ bool operator()(const typename _Traits::char_type& __x,
+ const typename _Traits::char_type& __y) const
+ { return _Traits::lt(__x, __y); }
+};
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_CTRAITS_FUNCTIONS_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_ctype.h b/sources/android/stlport/stlport/stl/_ctype.h
new file mode 100644
index 0000000..33a5d3c
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_ctype.h
@@ -0,0 +1,280 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+// WARNING: This is an internal header file, included by other C++
+// standard library headers. You should not attempt to use this header
+// file directly.
+
+#ifndef _STLP_INTERNAL_CTYPE_H
+#define _STLP_INTERNAL_CTYPE_H
+
+#ifndef _STLP_C_LOCALE_H
+# include <stl/c_locale.h>
+#endif
+
+#ifndef _STLP_INTERNAL_LOCALE_H
+# include <stl/_locale.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+# include <stl/_algobase.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+class _STLP_CLASS_DECLSPEC ctype_base {
+public:
+ enum mask {
+ space = _Locale_SPACE,
+ print = _Locale_PRINT,
+ cntrl = _Locale_CNTRL,
+ upper = _Locale_UPPER,
+ lower = _Locale_LOWER,
+ alpha = _Locale_ALPHA,
+ digit = _Locale_DIGIT,
+ punct = _Locale_PUNCT,
+ xdigit = _Locale_XDIGIT,
+ alnum = alpha | digit,
+ graph = alnum | punct
+ };
+};
+
+// ctype<> template
+
+template <class charT> class ctype {};
+template <class charT> class ctype_byname {};
+
+//ctype specializations
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC ctype<char> : public locale::facet, public ctype_base {
+#ifndef _STLP_NO_WCHAR_T
+# ifdef _STLP_MSVC
+ typedef ctype<wchar_t> _Wctype;
+ friend _Wctype;
+# else
+ friend class ctype<wchar_t>;
+# endif
+#endif
+public:
+
+ typedef char char_type;
+
+ explicit ctype(const mask* __tab = 0, bool __del = false, size_t __refs = 0);
+ bool is(mask __m, char __c) const
+ { return ((*(_M_ctype_table+(unsigned char)__c)) & __m) != 0; }
+
+ const char* is(const char* __low, const char* __high, mask* __vec) const {
+ for (const char* __p = __low;__p != __high; ++__p, ++__vec) {
+ *__vec = _M_ctype_table[(unsigned char)*__p];
+ }
+ return __high;
+ }
+
+ const char* scan_is(mask __m, const char* __low, const char* __high) const;
+ const char* scan_not(mask __m, const char* __low, const char* __high) const;
+
+ char (toupper)(char __c) const { return do_toupper(__c); }
+ const char* (toupper)(char* __low, const char* __high) const {
+ return do_toupper(__low, __high);
+ }
+
+ char (tolower)(char __c) const { return do_tolower(__c); }
+ const char* (tolower)(char* __low, const char* __high) const {
+ return do_tolower(__low, __high);
+ }
+
+ char widen(char __c) const { return do_widen(__c); }
+ const char* widen(const char* __low, const char* __high, char* __to) const {
+ return do_widen(__low, __high, __to);
+ }
+
+ char narrow(char __c, char __dfault) const {
+ return do_narrow(__c, __dfault);
+ }
+ const char* narrow(const char* __low, const char* __high,
+ char __dfault, char* __to) const {
+ return do_narrow(__low, __high, __dfault, __to);
+ }
+
+ static _STLP_STATIC_DECLSPEC locale::id id;
+ _STLP_STATIC_CONSTANT(size_t, table_size = 256);
+
+protected:
+ const mask* table() const _STLP_NOTHROW { return _M_ctype_table; }
+ static const mask* _STLP_CALL classic_table() _STLP_NOTHROW;
+
+ ~ctype();
+
+ virtual char do_toupper(char __c) const;
+ virtual char do_tolower(char __c) const;
+ virtual const char* do_toupper(char* __low, const char* __high) const;
+ virtual const char* do_tolower(char* __low, const char* __high) const;
+ virtual char do_widen(char __c) const;
+ virtual const char* do_widen(const char* __low, const char* __high,
+ char* __to) const;
+ virtual char do_narrow(char __c, char /* dfault */ ) const;
+ virtual const char* do_narrow(const char* __low, const char* __high,
+ char /* dfault */, char* __to) const;
+private:
+ struct _Is_mask {
+ mask __m;
+ _Is_mask(mask __x): __m(__x) {}
+ bool operator()(char __c) {return (__m & (unsigned char) __c) != 0;}
+ };
+
+protected:
+ const mask* _M_ctype_table;
+private:
+ bool _M_delete;
+};
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC ctype_byname<char>: public ctype<char> {
+ friend class _Locale_impl;
+public:
+ explicit ctype_byname(const char*, size_t = 0);
+ ~ctype_byname();
+
+ virtual char do_toupper(char __c) const;
+ virtual char do_tolower(char __c) const;
+
+ virtual const char* do_toupper(char*, const char*) const;
+ virtual const char* do_tolower(char*, const char*) const;
+
+private:
+ ctype_byname(_Locale_ctype* __ctype)
+ : _M_ctype(__ctype)
+ { _M_init(); }
+
+ void _M_init();
+
+ //explicitely defined as private to avoid warnings:
+ typedef ctype_byname<char> _Self;
+ ctype_byname(_Self const&);
+ _Self& operator = (_Self const&);
+
+ mask _M_byname_table[table_size];
+ _Locale_ctype* _M_ctype;
+};
+
+# ifndef _STLP_NO_WCHAR_T
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC ctype<wchar_t> : public locale::facet, public ctype_base {
+public:
+ typedef wchar_t char_type;
+
+ explicit ctype(size_t __refs = 0) : locale::facet(__refs) {}
+
+ bool is(mask __m, wchar_t __c) const
+ { return do_is(__m, __c); }
+
+ const wchar_t* is(const wchar_t* __low, const wchar_t* __high,
+ mask* __vec) const
+ { return do_is(__low, __high, __vec); }
+
+ const wchar_t* scan_is(mask __m,
+ const wchar_t* __low, const wchar_t* __high) const
+ { return do_scan_is(__m, __low, __high); }
+
+ const wchar_t* scan_not (mask __m,
+ const wchar_t* __low, const wchar_t* __high) const
+ { return do_scan_not(__m, __low, __high); }
+
+ wchar_t (toupper)(wchar_t __c) const { return do_toupper(__c); }
+ const wchar_t* (toupper)(wchar_t* __low, const wchar_t* __high) const
+ { return do_toupper(__low, __high); }
+
+ wchar_t (tolower)(wchar_t __c) const { return do_tolower(__c); }
+ const wchar_t* (tolower)(wchar_t* __low, const wchar_t* __high) const
+ { return do_tolower(__low, __high); }
+
+ wchar_t widen(char __c) const { return do_widen(__c); }
+ const char* widen(const char* __low, const char* __high,
+ wchar_t* __to) const
+ { return do_widen(__low, __high, __to); }
+
+ char narrow(wchar_t __c, char __dfault) const
+ { return do_narrow(__c, __dfault); }
+ const wchar_t* narrow(const wchar_t* __low, const wchar_t* __high,
+ char __dfault, char* __to) const
+ { return do_narrow(__low, __high, __dfault, __to); }
+
+ static _STLP_STATIC_DECLSPEC locale::id id;
+
+protected:
+ ~ctype();
+
+ virtual bool do_is(mask __m, wchar_t __c) const;
+ virtual const wchar_t* do_is(const wchar_t*, const wchar_t*, mask*) const;
+ virtual const wchar_t* do_scan_is(mask,
+ const wchar_t*, const wchar_t*) const;
+ virtual const wchar_t* do_scan_not(mask,
+ const wchar_t*, const wchar_t*) const;
+ virtual wchar_t do_toupper(wchar_t __c) const;
+ virtual const wchar_t* do_toupper(wchar_t*, const wchar_t*) const;
+ virtual wchar_t do_tolower(wchar_t c) const;
+ virtual const wchar_t* do_tolower(wchar_t*, const wchar_t*) const;
+ virtual wchar_t do_widen(char c) const;
+ virtual const char* do_widen(const char*, const char*, wchar_t*) const;
+ virtual char do_narrow(wchar_t __c, char __dfault) const;
+ virtual const wchar_t* do_narrow(const wchar_t*, const wchar_t*,
+ char, char*) const;
+};
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC ctype_byname<wchar_t>: public ctype<wchar_t> {
+ friend class _Locale_impl;
+public:
+ explicit ctype_byname(const char* __name, size_t __refs = 0);
+
+protected:
+ ~ctype_byname();
+
+ virtual bool do_is(mask __m, wchar_t __c) const;
+ virtual const wchar_t* do_is(const wchar_t*, const wchar_t*, mask*) const;
+ virtual const wchar_t* do_scan_is(mask,
+ const wchar_t*, const wchar_t*) const;
+ virtual const wchar_t* do_scan_not(mask,
+ const wchar_t*, const wchar_t*) const;
+ virtual wchar_t do_toupper(wchar_t __c) const;
+ virtual const wchar_t* do_toupper(wchar_t*, const wchar_t*) const;
+ virtual wchar_t do_tolower(wchar_t c) const;
+ virtual const wchar_t* do_tolower(wchar_t*, const wchar_t*) const;
+
+private:
+ ctype_byname(_Locale_ctype* __ctype)
+ : _M_ctype(__ctype) {}
+
+ //explicitely defined as private to avoid warnings:
+ typedef ctype_byname<wchar_t> _Self;
+ ctype_byname(_Self const&);
+ _Self& operator = (_Self const&);
+
+ _Locale_ctype* _M_ctype;
+};
+
+# endif /* WCHAR_T */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_CTYPE_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/stl/_cwchar.h b/sources/android/stlport/stlport/stl/_cwchar.h
new file mode 100644
index 0000000..87cb82b
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_cwchar.h
@@ -0,0 +1,342 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_CWCHAR
+#define _STLP_INTERNAL_CWCHAR
+
+#if defined (_STLP_WCE_EVC3)
+# ifndef _STLP_INTERNAL_MBSTATE_T
+# include <stl/_mbstate_t.h>
+# endif
+#else
+# if defined (__GNUC__)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cstddef>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cstddef)
+# endif
+# endif
+
+# if !defined (_STLP_NO_CWCHAR) && defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cwchar>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cwchar)
+# endif
+# if defined (__OpenBSD__)
+typedef _BSD_WINT_T_ wint_t;
+# endif /* __OpenBSD__ */
+
+# if defined (__DMC__)
+# define __STDC_LIMIT_MACROS
+# include <stdint.h> // WCHAR_MIN, WCHAR_MAX
+# endif
+# elif defined (_STLP_NO_WCHAR_T) || \
+ (defined (__BORLANDC__) && (__BORLANDC__ < 0x570)) || \
+ defined (__OpenBSD__) || defined (__FreeBSD__) || \
+ (defined (__GNUC__) && (defined (__APPLE__) || defined ( __Lynx__ )))
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <stddef.h>
+# else
+# include _STLP_NATIVE_C_HEADER(stddef.h)
+# endif
+# if defined (__Lynx__)
+# ifndef _WINT_T
+typedef long int wint_t;
+# define _WINT_T
+# endif /* _WINT_T */
+# endif
+# if defined(__OpenBSD__)
+typedef _BSD_WINT_T_ wint_t;
+# endif /* __OpenBSD__ */
+# else
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <wchar.h>
+# else
+# include _STLP_NATIVE_C_HEADER(wchar.h)
+# endif
+
+# if defined (__sun) && (defined (_XOPEN_SOURCE) || (_XOPEN_VERSION - 0 == 4))
+extern wint_t btowc();
+extern int fwprintf();
+extern int fwscanf();
+extern int fwide();
+extern int mbsinit();
+extern size_t mbrlen();
+extern size_t mbrtowc();
+extern size_t mbsrtowcs();
+extern int swprintf();
+extern int swscanf();
+extern int vfwprintf();
+extern int vwprintf();
+extern int vswprintf();
+extern size_t wcrtomb();
+extern size_t wcsrtombs();
+extern wchar_t *wcsstr();
+extern int wctob();
+extern wchar_t *wmemchr();
+extern int wmemcmp();
+extern wchar_t *wmemcpy();
+extern wchar_t *wmemmove();
+extern wchar_t *wmemset();
+extern int wprintf();
+extern int wscanf();
+# endif
+# endif
+
+# if defined (__MSL__) && (__MSL__ <= 0x51FF) /* dwa 2/28/99 - not yet implemented by MSL */
+# define _STLP_WCHAR_MSL_EXCLUDE 1
+namespace std {
+ extern "C" size_t wcsftime(wchar_t * str, size_t max_size, const wchar_t * format_str, const struct tm * timeptr);
+}
+# define _STLP_NO_NATIVE_MBSTATE_T 1
+# elif defined (__BORLANDC__)
+# if !defined (_STLP_USE_NO_IOSTREAMS)
+# define _STLP_NO_NATIVE_MBSTATE_T
+# endif
+# define _STLP_WCHAR_BORLAND_EXCLUDE 1
+# endif
+
+# ifndef _STLP_INTERNAL_MBSTATE_T
+# include <stl/_mbstate_t.h>
+# endif
+
+# if !defined (_STLP_NO_WCHAR_T)
+# ifndef WCHAR_MIN
+# define WCHAR_MIN 0
+/* SUNpro has some bugs with casts. wchar_t is size of int there anyway. */
+# if defined (__SUNPRO_CC) || defined (__DJGPP)
+# define WCHAR_MAX (~0)
+# else
+# define WCHAR_MAX ((wchar_t)~0)
+# endif
+# endif
+# if defined (__DMC__) || (defined (_STLP_MSVC_LIB) && (_STLP_MSVC_LIB < 1400)) || defined(_WIN32_WCE)
+/* Compilers that do not define WCHAR_MIN and WCHAR_MAX to be testable at
+ * preprocessing time. */
+# undef WCHAR_MIN
+# define WCHAR_MIN 0
+# undef WCHAR_MAX
+# define WCHAR_MAX 0xffff
+# endif
+# if defined (__GNUC__) && defined (__alpha__)
+/* Definition of WCHAR_MIN and MAX are wrong for alpha platform
+ * as gcc consider wchar_t as an unsigned type but WCHAR_MIN is defined as
+ * a negative value. Static assertion is here to check that a future alpha
+ * SDK or a future gcc won't change the situation making this workaround
+ * useless.
+ */
+/* Check that gcc still consider wchar_t as unsigned */
+_STLP_STATIC_ASSERT(((wchar_t)-1 > 0))
+/* Check that WCHAR_MIN value hasn't been fixed */
+_STLP_STATIC_ASSERT((WCHAR_MIN < 0))
+# undef WCHAR_MIN
+# define WCHAR_MIN 0
+# undef WCHAR_MAX
+# define WCHAR_MAX 0xffffffff
+# endif
+# if defined(__HP_aCC) && (__HP_aCC >= 60000)
+/* Starting with B.11.31, HP-UX/ia64 provides C99-compliant definitions
+ * of WCHAR_MIN/MAX macros without having to define
+ * _INCLUDE_STDC__SOURCE_199901 macro (which aCC compiler does not
+ * predefine). Let STLport provide B.11.31 definitions on any version of
+ * HP-UX/ia64.
+ */
+# undef WCHAR_MIN
+# define WCHAR_MIN 0
+# undef WCHAR_MAX
+# define WCHAR_MAX UINT_MAX
+# endif
+# endif
+
+# if defined (_STLP_IMPORT_VENDOR_CSTD)
+
+# if defined (__SUNPRO_CC) && !defined (_STLP_HAS_NO_NEW_C_HEADERS)
+using _STLP_VENDOR_CSTD::wint_t;
+# endif
+
+_STLP_BEGIN_NAMESPACE
+# if defined (_STLP_NO_WCHAR_T)
+typedef int wint_t;
+# else
+// gcc 3.0 has a glitch : wint_t only sucked into the global namespace if _GLIBCPP_USE_WCHAR_T is defined
+// __MWERKS__ has definition in wchar_t.h (MSL C++), but ones differ from definition
+// in stdio.h; I prefer settings from last file.
+# if (defined (__GNUC__) && ! defined (_GLIBCPP_USE_WCHAR_T))
+using ::wint_t;
+# else
+using _STLP_VENDOR_CSTD::wint_t;
+# endif
+# endif
+
+using _STLP_VENDOR_CSTD::size_t;
+
+# if !defined (_STLP_NO_NATIVE_MBSTATE_T) && !defined (_STLP_USE_OWN_MBSTATE_T)
+using _STLP_VENDOR_MB_NAMESPACE::mbstate_t;
+
+# if !defined (_STLP_NO_CSTD_FUNCTION_IMPORTS) && !defined(_STLP_WCHAR_BORLAND_EXCLUDE) && \
+ (!defined(__MSL__) || __MSL__ > 0x6001)
+# if defined (__MINGW32__) && ((__MINGW32_MAJOR_VERSION > 3) || ((__MINGW32_MAJOR_VERSION == 3) && (__MINGW32_MINOR_VERSION >= 8))) || \
+ !(defined (__KCC) || defined (__GNUC__)) && !defined(_STLP_WCE_NET)
+using _STLP_VENDOR_MB_NAMESPACE::btowc;
+# if (!defined(__MSL__) || __MSL__ > 0x7001)
+using _STLP_VENDOR_MB_NAMESPACE::mbsinit;
+# endif
+# endif
+# if defined (__MINGW32__) && ((__MINGW32_MAJOR_VERSION > 3) || ((__MINGW32_MAJOR_VERSION == 3) && (__MINGW32_MINOR_VERSION >= 8))) || \
+ !defined (__GNUC__) && !defined(_STLP_WCE_NET)
+using _STLP_VENDOR_MB_NAMESPACE::mbrlen;
+using _STLP_VENDOR_MB_NAMESPACE::mbrtowc;
+using _STLP_VENDOR_MB_NAMESPACE::mbsrtowcs;
+using _STLP_VENDOR_MB_NAMESPACE::wcrtomb;
+using _STLP_VENDOR_MB_NAMESPACE::wcsrtombs;
+# endif
+# endif /* BORLAND && !__MSL__ || __MSL__ > 0x6001 */
+
+# endif /* _STLP_NO_NATIVE_MBSTATE_T */
+
+# if !defined (_STLP_NO_NATIVE_WIDE_FUNCTIONS) && ! defined (_STLP_NO_CSTD_FUNCTION_IMPORTS)
+
+# if !defined (_STLP_WCHAR_BORLAND_EXCLUDE) && ! defined (_STLP_NO_CSTD_FUNCTION_IMPORTS)
+using _STLP_VENDOR_CSTD::fgetwc;
+using _STLP_VENDOR_CSTD::fgetws;
+using _STLP_VENDOR_CSTD::fputwc;
+using _STLP_VENDOR_CSTD::fputws;
+# endif
+
+# if !(defined (_STLP_WCHAR_SUNPRO_EXCLUDE) || defined (_STLP_WCHAR_BORLAND_EXCLUDE) || \
+ defined(_STLP_WCHAR_HPACC_EXCLUDE) )
+# if !defined (__DECCXX)
+using _STLP_VENDOR_CSTD::fwide;
+# endif
+using _STLP_VENDOR_CSTD::fwprintf;
+using _STLP_VENDOR_CSTD::fwscanf;
+using _STLP_VENDOR_CSTD::getwchar;
+# endif
+
+# if !defined(_STLP_WCHAR_BORLAND_EXCLUDE)
+# ifndef _STLP_WCE_NET
+using _STLP_VENDOR_CSTD::getwc;
+# endif
+using _STLP_VENDOR_CSTD::ungetwc;
+# ifndef _STLP_WCE_NET
+using _STLP_VENDOR_CSTD::putwc;
+# endif
+using _STLP_VENDOR_CSTD::putwchar;
+# endif
+
+# if !(defined (_STLP_WCHAR_SUNPRO_EXCLUDE) || defined (_STLP_WCHAR_BORLAND_EXCLUDE) || \
+ defined (_STLP_WCHAR_HPACC_EXCLUDE) )
+# if defined (_STLP_MSVC_LIB) && (_STLP_MSVC_LIB <= 1300) || \
+ defined (__MINGW32__)
+# undef swprintf
+# define swprintf _snwprintf
+# undef vswprintf
+# define vswprintf _vsnwprintf
+using ::swprintf;
+using ::vswprintf;
+# else
+using _STLP_VENDOR_CSTD::swprintf;
+using _STLP_VENDOR_CSTD::vswprintf;
+# endif
+using _STLP_VENDOR_CSTD::swscanf;
+using _STLP_VENDOR_CSTD::vfwprintf;
+using _STLP_VENDOR_CSTD::vwprintf;
+
+# if (!defined(__MSL__) || __MSL__ > 0x7001 ) && !defined(_STLP_WCE_NET) && \
+ !defined(_STLP_USE_UCLIBC) /* at least in uClibc 0.9.26 */
+
+using _STLP_VENDOR_CSTD::wcsftime;
+# endif
+using _STLP_VENDOR_CSTD::wcstok;
+
+# endif
+
+# if !defined (_STLP_WCE_NET)
+using _STLP_VENDOR_CSTD::wcscoll;
+using _STLP_VENDOR_CSTD::wcsxfrm;
+# endif
+using _STLP_VENDOR_CSTD::wcscat;
+using _STLP_VENDOR_CSTD::wcsrchr;
+using _STLP_VENDOR_CSTD::wcscmp;
+
+using _STLP_VENDOR_CSTD::wcscpy;
+using _STLP_VENDOR_CSTD::wcscspn;
+
+using _STLP_VENDOR_CSTD::wcslen;
+using _STLP_VENDOR_CSTD::wcsncat;
+using _STLP_VENDOR_CSTD::wcsncmp;
+using _STLP_VENDOR_CSTD::wcsncpy;
+using _STLP_VENDOR_CSTD::wcspbrk;
+using _STLP_VENDOR_CSTD::wcschr;
+
+using _STLP_VENDOR_CSTD::wcsspn;
+
+# if !defined (_STLP_WCHAR_BORLAND_EXCLUDE)
+using _STLP_VENDOR_CSTD::wcstod;
+using _STLP_VENDOR_CSTD::wcstol;
+# endif
+
+# if !(defined (_STLP_WCHAR_SUNPRO_EXCLUDE) || defined (_STLP_WCHAR_HPACC_EXCLUDE) )
+using _STLP_VENDOR_CSTD::wcsstr;
+using _STLP_VENDOR_CSTD::wmemchr;
+
+# if !defined (_STLP_WCHAR_BORLAND_EXCLUDE)
+# if !defined (_STLP_WCE_NET)
+using _STLP_VENDOR_CSTD::wctob;
+# endif
+# if !defined (__DMC__)
+using _STLP_VENDOR_CSTD::wmemcmp;
+using _STLP_VENDOR_CSTD::wmemmove;
+# endif
+using _STLP_VENDOR_CSTD::wprintf;
+using _STLP_VENDOR_CSTD::wscanf;
+# endif
+
+# if defined (__BORLANDC__) && !defined (__linux__)
+inline wchar_t* _STLP_wmemcpy(wchar_t* __wdst, const wchar_t* __wsrc, size_t __n)
+{ return __STATIC_CAST(wchar_t*, _STLP_VENDOR_CSTD::wmemcpy(__wdst, __wsrc, __n)); }
+inline wchar_t* _STLP_wmemset(wchar_t* __wdst, wchar_t __wc, size_t __n)
+{ return __STATIC_CAST(wchar_t*, _STLP_VENDOR_CSTD::memset(__wdst, __wc, __n)); }
+# undef wmemcpy
+# undef wmemset
+inline wchar_t* wmemcpy(wchar_t* __wdst, const wchar_t* __wsrc, size_t __n)
+{ return _STLP_wmemcpy(__wdst, __wsrc, __n); }
+inline wchar_t* wmemset(wchar_t* __wdst, wchar_t __wc, size_t __n)
+{ return _STLP_wmemset(__wdst, __wc, __n); }
+# elif defined (__DMC__)
+inline wchar_t* wmemcpy(wchar_t* __RESTRICT __wdst, const wchar_t* __RESTRICT __wsrc, size_t __n)
+{ return __STATIC_CAST(wchar_t*, memcpy(__wdst, __wsrc, __n * sizeof(wchar_t))); }
+inline wchar_t* wmemmove(wchar_t* __RESTRICT __wdst, const wchar_t * __RESTRICT __wc, size_t __n)
+{ return __STATIC_CAST(wchar_t*, memmove(__wdst, __wc, __n * sizeof(wchar_t))); }
+inline wchar_t* wmemset(wchar_t* __wdst, wchar_t __wc, size_t __n)
+{ for (size_t i = 0; i < __n; i++) __wdst[i] = __wc; return __wdst; }
+# else
+using _STLP_VENDOR_CSTD::wmemcpy;
+using _STLP_VENDOR_CSTD::wmemset;
+# endif
+# endif
+
+# endif /* _STLP_NO_NATIVE_WIDE_FUNCTIONS */
+_STLP_END_NAMESPACE
+
+# endif /* _STLP_IMPORT_VENDOR_CSTD */
+
+# undef _STLP_WCHAR_SUNPRO_EXCLUDE
+# undef _STLP_WCHAR_MSL_EXCLUDE
+
+# endif /* !defined(_STLP_WCE_EVC3) */
+
+#endif /* _STLP_INTERNAL_CWCHAR */
diff --git a/sources/android/stlport/stlport/stl/_cwctype.h b/sources/android/stlport/stlport/stl/_cwctype.h
new file mode 100644
index 0000000..83b551f
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_cwctype.h
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_CWCTYPE
+#define _STLP_INTERNAL_CWCTYPE
+
+#if defined (__BORLANDC__) && !defined (_STLP_INTERNAL_CCTYPE)
+# include <stl/_cctype.h>
+#endif
+
+#if !defined (_STLP_WCE_EVC3)
+# if defined (_STLP_USE_NEW_C_HEADERS)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <cwctype>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(cwctype)
+# endif
+# if defined (__MSL__)
+namespace std {
+ typedef wchar_t wctrans_t;
+ wint_t towctrans(wint_t c, wctrans_t value);
+ wctrans_t wctrans(const char *name);
+}
+using std::wctrans_t;
+using std::towctrans;
+using std::wctrans;
+# endif
+# else
+# include <wctype.h>
+# endif
+
+# if defined (_STLP_IMPORT_VENDOR_CSTD) && !defined (__hpux)
+
+# if defined (_STLP_USE_GLIBC) && !(defined (_GLIBCPP_USE_WCHAR_T) || defined (_GLIBCXX_USE_WCHAR_T)) || \
+ defined (__sun) || defined (__FreeBSD__) || \
+ defined (__CYGWIN__) || \
+ defined (__MINGW32__) && ((__MINGW32_MAJOR_VERSION < 3) || (__MINGW32_MAJOR_VERSION == 3) && (__MINGW32_MINOR_VERSION <= 0))
+//We take wide functions from global namespace:
+# define _STLP_VENDOR_CSTD_WFUNC
+# else
+# define _STLP_VENDOR_CSTD_WFUNC _STLP_VENDOR_CSTD
+# endif
+
+_STLP_BEGIN_NAMESPACE
+using _STLP_VENDOR_CSTD_WFUNC::wctype_t;
+using _STLP_VENDOR_CSTD_WFUNC::wint_t;
+# if !defined (_STLP_NO_CSTD_FUNCTION_IMPORTS)
+# if !defined (__BORLANDC__) && !defined (__MSL__)
+using _STLP_VENDOR_CSTD_WFUNC::wctrans_t;
+# if !defined (__DMC__) && (!defined(_WIN32_WCE) || (_WIN32_WCE < 400))
+using _STLP_VENDOR_CSTD_WFUNC::towctrans;
+using _STLP_VENDOR_CSTD_WFUNC::wctrans;
+using _STLP_VENDOR_CSTD_WFUNC::wctype;
+# endif
+using _STLP_VENDOR_CSTD_WFUNC::iswctype;
+# endif
+using _STLP_VENDOR_CSTD_WFUNC::iswalnum;
+using _STLP_VENDOR_CSTD_WFUNC::iswalpha;
+using _STLP_VENDOR_CSTD_WFUNC::iswcntrl;
+
+using _STLP_VENDOR_CSTD_WFUNC::iswdigit;
+using _STLP_VENDOR_CSTD_WFUNC::iswgraph;
+using _STLP_VENDOR_CSTD_WFUNC::iswlower;
+using _STLP_VENDOR_CSTD_WFUNC::iswprint;
+using _STLP_VENDOR_CSTD_WFUNC::iswpunct;
+using _STLP_VENDOR_CSTD_WFUNC::iswspace;
+using _STLP_VENDOR_CSTD_WFUNC::iswupper;
+using _STLP_VENDOR_CSTD_WFUNC::iswxdigit;
+
+using _STLP_VENDOR_CSTD_WFUNC::towlower;
+using _STLP_VENDOR_CSTD_WFUNC::towupper;
+# endif /* _STLP_NO_CSTD_FUNCTION_IMPORTS */
+_STLP_END_NAMESPACE
+# endif /* _STLP_IMPORT_VENDOR_CSTD */
+#endif /* _STLP_WCE_EVC3 */
+
+#endif /* _STLP_INTERNAL_CWCTYPE */
diff --git a/sources/android/stlport/stlport/stl/_deque.c b/sources/android/stlport/stlport/stl/_deque.c
new file mode 100644
index 0000000..74e9ef6
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_deque.c
@@ -0,0 +1,823 @@
+/*
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_DEQUE_C
+#define _STLP_DEQUE_C
+
+#ifndef _STLP_INTERNAL_DEQUE_H
+# include <stl/_deque.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Non-inline member functions from _Deque_base.
+
+template <class _Tp, class _Alloc >
+_Deque_base<_Tp,_Alloc >::~_Deque_base() {
+ if (_M_map._M_data) {
+ _M_destroy_nodes(_M_start._M_node, this->_M_finish._M_node + 1);
+ _M_map.deallocate(_M_map._M_data, _M_map_size._M_data);
+ }
+}
+
+template <class _Tp, class _Alloc >
+void _Deque_base<_Tp,_Alloc>::_M_initialize_map(size_t __num_elements) {
+ size_t __num_nodes = __num_elements / this->buffer_size() + 1 ;
+
+ _M_map_size._M_data = (max)((size_t) _S_initial_map_size, __num_nodes + 2);
+ _M_map._M_data = _M_map.allocate(_M_map_size._M_data);
+
+ _Tp** __nstart = _M_map._M_data + (_M_map_size._M_data - __num_nodes) / 2;
+ _Tp** __nfinish = __nstart + __num_nodes;
+
+ _STLP_TRY {
+ _M_create_nodes(__nstart, __nfinish);
+ }
+ _STLP_UNWIND((_M_map.deallocate(_M_map._M_data, _M_map_size._M_data),
+ _M_map._M_data = 0, _M_map_size._M_data = 0))
+ _M_start._M_set_node(__nstart);
+ this->_M_finish._M_set_node(__nfinish - 1);
+ _M_start._M_cur = _M_start._M_first;
+ this->_M_finish._M_cur = this->_M_finish._M_first + __num_elements % this->buffer_size();
+}
+
+template <class _Tp, class _Alloc >
+void _Deque_base<_Tp,_Alloc>::_M_create_nodes(_Tp** __nstart,
+ _Tp** __nfinish) {
+ _Tp** __cur = __nstart;
+ _STLP_TRY {
+ for (; __cur < __nfinish; ++__cur)
+ *__cur = _M_map_size.allocate(this->buffer_size());
+ }
+ _STLP_UNWIND(_M_destroy_nodes(__nstart, __cur))
+}
+
+template <class _Tp, class _Alloc >
+void _Deque_base<_Tp,_Alloc>::_M_destroy_nodes(_Tp** __nstart,
+ _Tp** __nfinish) {
+ for (_Tp** __n = __nstart; __n < __nfinish; ++__n)
+ _M_map_size.deallocate(*__n, this->buffer_size());
+}
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+# define deque _STLP_PTR_IMPL_NAME(deque)
+#elif defined (_STLP_DEBUG)
+# define deque _STLP_NON_DBG_NAME(deque)
+#else
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+// qualified references
+# define __iterator__ _Deque_iterator<_Tp, _Nonconst_traits<_Tp> >
+# define const_iterator _Deque_iterator<_Tp, _Const_traits<_Tp> >
+# define iterator __iterator__
+# define size_type size_t
+# define value_type _Tp
+#else
+# define __iterator__ _STLP_TYPENAME_ON_RETURN_TYPE deque<_Tp, _Alloc>::iterator
+#endif
+
+template <class _Tp, class _Alloc >
+deque<_Tp, _Alloc >&
+deque<_Tp, _Alloc >::operator= (const deque<_Tp, _Alloc >& __x) {
+ const size_type __len = size();
+ if (&__x != this) {
+ if (__len >= __x.size())
+ erase(_STLP_STD::copy(__x.begin(), __x.end(), this->_M_start), this->_M_finish);
+ else {
+ const_iterator __mid = __x.begin() + difference_type(__len);
+ _STLP_STD::copy(__x.begin(), __mid, this->_M_start);
+ insert(this->_M_finish, __mid, __x.end());
+ }
+ }
+ return *this;
+}
+
+template <class _Tp, class _Alloc >
+void deque<_Tp, _Alloc >::_M_fill_insert(iterator __pos,
+ size_type __n, const value_type& __x) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+ if (__pos._M_cur == this->_M_start._M_cur) {
+ iterator __new_start = _M_reserve_elements_at_front(__n);
+ _STLP_TRY {
+ uninitialized_fill(__new_start, this->_M_start, __x);
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+ this->_M_start = __new_start;
+ }
+ else if (__pos._M_cur == this->_M_finish._M_cur) {
+ iterator __new_finish = _M_reserve_elements_at_back(__n);
+ _STLP_TRY {
+ uninitialized_fill(this->_M_finish, __new_finish, __x);
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node+1, __new_finish._M_node+1))
+ this->_M_finish = __new_finish;
+ }
+ else
+ _M_fill_insert_aux(__pos, __n, __x, _Movable());
+}
+
+#if !defined (_STLP_MEMBER_TEMPLATES)
+
+template <class _Tp, class _Alloc >
+void deque<_Tp, _Alloc>::insert(iterator __pos,
+ const value_type* __first, const value_type* __last) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+ size_type __n = __last - __first;
+ if (__pos._M_cur == this->_M_start._M_cur) {
+ iterator __new_start = _M_reserve_elements_at_front(__n);
+ _STLP_TRY {
+ _STLP_PRIV __ucopy(__first, __last, __new_start);
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+ this->_M_start = __new_start;
+ }
+ else if (__pos._M_cur == this->_M_finish._M_cur) {
+ iterator __new_finish = _M_reserve_elements_at_back(__n);
+ _STLP_TRY {
+ _STLP_PRIV __ucopy(__first, __last, this->_M_finish);
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1,
+ __new_finish._M_node + 1))
+ this->_M_finish = __new_finish;
+ }
+ else
+ _M_insert_range_aux(__pos, __first, __last, __n, _Movable());
+}
+
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::insert(iterator __pos,
+ const_iterator __first, const_iterator __last) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+ size_type __n = __last - __first;
+ if (__pos._M_cur == this->_M_start._M_cur) {
+ iterator __new_start = _M_reserve_elements_at_front(__n);
+ _STLP_TRY {
+ _STLP_PRIV __ucopy(__first, __last, __new_start);
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+ this->_M_start = __new_start;
+ }
+ else if (__pos._M_cur == this->_M_finish._M_cur) {
+ iterator __new_finish = _M_reserve_elements_at_back(__n);
+ _STLP_TRY {
+ _STLP_PRIV __ucopy(__first, __last, this->_M_finish);
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1,
+ __new_finish._M_node + 1))
+ this->_M_finish = __new_finish;
+ }
+ else
+ _M_insert_range_aux(__pos, __first, __last, __n, _Movable());
+}
+
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+template <class _Tp, class _Alloc >
+__iterator__ deque<_Tp,_Alloc>::_M_erase(iterator __pos,
+ const __true_type& /*_Movable*/) {
+ difference_type __index = __pos - this->_M_start;
+ if (size_type(__index) < this->size() >> 1) {
+ //We move the start of the deque one position to the right
+ //starting from the rightmost element to move.
+ iterator __src = __pos, __dst = __pos;
+ _STLP_STD::_Destroy(&(*__dst));
+ if (__src != this->_M_start) {
+ for (--__src; __dst != this->_M_start; --__src, --__dst) {
+ _STLP_STD::_Move_Construct(&(*__dst), *__src);
+ _STLP_STD::_Destroy_Moved(&(*__src));
+ }
+ }
+ _M_pop_front_aux();
+ }
+ else {
+ iterator __src = __pos, __dst = __pos;
+ _STLP_STD::_Destroy(&(*__dst));
+ for (++__src; __src != this->_M_finish; ++__src, ++__dst) {
+ _STLP_STD::_Move_Construct(&(*__dst), *__src);
+ _STLP_STD::_Destroy_Moved(&(*__src));
+ }
+ //Duplication of the pop_back code without the destroy which has already been done:
+ if (this->_M_finish._M_cur != this->_M_finish._M_first) {
+ --this->_M_finish._M_cur;
+ }
+ else {
+ _M_pop_back_aux();
+ }
+ }
+ return this->_M_start + __index;
+}
+
+template <class _Tp, class _Alloc >
+__iterator__ deque<_Tp,_Alloc>::_M_erase(iterator __pos,
+ const __false_type& /*_Movable*/) {
+ iterator __next = __pos;
+ ++__next;
+ difference_type __index = __pos - this->_M_start;
+ if (size_type(__index) < this->size() >> 1) {
+ copy_backward(this->_M_start, __pos, __next);
+ pop_front();
+ }
+ else {
+ _STLP_STD::copy(__next, this->_M_finish, __pos);
+ pop_back();
+ }
+ return this->_M_start + __index;
+}
+
+template <class _Tp, class _Alloc >
+__iterator__ deque<_Tp,_Alloc>::_M_erase(iterator __first, iterator __last,
+ const __true_type& /*_Movable*/) {
+ difference_type __n = __last - __first;
+ difference_type __elems_before = __first - this->_M_start;
+ if (__elems_before <= difference_type(this->size() - __n) / 2) {
+ iterator __src = __first, __dst = __last;
+ if (__src != this->_M_start) {
+ for (--__src, --__dst; (__src >= this->_M_start) && (__dst >= __first); --__src, --__dst) {
+ _STLP_STD::_Destroy(&(*__dst));
+ _STLP_STD::_Move_Construct(&(*__dst), *__src);
+ }
+ if (__dst >= __first) {
+ //There are more elements to erase than elements to move
+ _STLP_STD::_Destroy_Range(__first, ++__dst);
+ _STLP_STD::_Destroy_Moved_Range(this->_M_start, __first);
+ }
+ else {
+ //There are more elements to move than elements to erase
+ for (; __src >= this->_M_start; --__src, --__dst) {
+ _STLP_STD::_Destroy_Moved(&(*__dst));
+ _STLP_STD::_Move_Construct(&(*__dst), *__src);
+ }
+ _STLP_STD::_Destroy_Moved_Range(this->_M_start, ++__dst);
+ }
+ }
+ else {
+ _STLP_STD::_Destroy_Range(this->_M_start, __last);
+ }
+ iterator __new_start = this->_M_start + __n;
+ this->_M_destroy_nodes(this->_M_start._M_node, __new_start._M_node);
+ this->_M_start = __new_start;
+ }
+ else {
+ if (__last != this->_M_finish) {
+ iterator __src = __last, __dst = __first;
+ for (; (__src != this->_M_finish) && (__dst != __last); ++__src, ++__dst) {
+ _STLP_STD::_Destroy(&(*__dst));
+ _STLP_STD::_Move_Construct(&(*__dst), *__src);
+ }
+ if (__dst != __last) {
+ //There are more elements to erase than elements to move
+ _STLP_STD::_Destroy_Range(__dst, __last);
+ _STLP_STD::_Destroy_Moved_Range(__last, this->_M_finish);
+ }
+ else {
+ //There are more elements to move than elements to erase
+ for (; __src != this->_M_finish; ++__src, ++__dst) {
+ _STLP_STD::_Destroy_Moved(&(*__dst));
+ _STLP_STD::_Move_Construct(&(*__dst), *__src);
+ }
+ _STLP_STD::_Destroy_Moved_Range(__dst, this->_M_finish);
+ }
+ }
+ else {
+ _STLP_STD::_Destroy_Range(__first, this->_M_finish);
+ }
+ iterator __new_finish = this->_M_finish - __n;
+ this->_M_destroy_nodes(__new_finish._M_node + 1, this->_M_finish._M_node + 1);
+ this->_M_finish = __new_finish;
+ }
+ return this->_M_start + __elems_before;
+}
+
+template <class _Tp, class _Alloc >
+__iterator__ deque<_Tp,_Alloc>::_M_erase(iterator __first, iterator __last,
+ const __false_type& /*_Movable*/) {
+ difference_type __n = __last - __first;
+ difference_type __elems_before = __first - this->_M_start;
+ if (__elems_before <= difference_type(this->size() - __n) / 2) {
+ copy_backward(this->_M_start, __first, __last);
+ iterator __new_start = this->_M_start + __n;
+ _STLP_STD::_Destroy_Range(this->_M_start, __new_start);
+ this->_M_destroy_nodes(this->_M_start._M_node, __new_start._M_node);
+ this->_M_start = __new_start;
+ }
+ else {
+ _STLP_STD::copy(__last, this->_M_finish, __first);
+ iterator __new_finish = this->_M_finish - __n;
+ _STLP_STD::_Destroy_Range(__new_finish, this->_M_finish);
+ this->_M_destroy_nodes(__new_finish._M_node + 1, this->_M_finish._M_node + 1);
+ this->_M_finish = __new_finish;
+ }
+ return this->_M_start + __elems_before;
+}
+
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::clear() {
+ for (_Map_pointer __node = this->_M_start._M_node + 1;
+ __node < this->_M_finish._M_node;
+ ++__node) {
+ _STLP_STD::_Destroy_Range(*__node, *__node + this->buffer_size());
+ this->_M_map_size.deallocate(*__node, this->buffer_size());
+ }
+
+ if (this->_M_start._M_node != this->_M_finish._M_node) {
+ _STLP_STD::_Destroy_Range(this->_M_start._M_cur, this->_M_start._M_last);
+ _STLP_STD::_Destroy_Range(this->_M_finish._M_first, this->_M_finish._M_cur);
+ this->_M_map_size.deallocate(this->_M_finish._M_first, this->buffer_size());
+ }
+ else
+ _STLP_STD::_Destroy_Range(this->_M_start._M_cur, this->_M_finish._M_cur);
+
+ this->_M_finish = this->_M_start;
+}
+
+// Precondition: this->_M_start and this->_M_finish have already been initialized,
+// but none of the deque's elements have yet been constructed.
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_fill_initialize(const value_type& __val,
+ const __false_type& /*_TrivialInit*/) {
+ _Map_pointer __cur = this->_M_start._M_node;
+ _STLP_TRY {
+ for (; __cur < this->_M_finish._M_node; ++__cur)
+ uninitialized_fill(*__cur, *__cur + this->buffer_size(), __val);
+ uninitialized_fill(this->_M_finish._M_first, this->_M_finish._M_cur, __val);
+ }
+ _STLP_UNWIND(_STLP_STD::_Destroy_Range(this->_M_start, iterator(*__cur, __cur)))
+}
+
+
+// Called only if this->_M_finish._M_cur == this->_M_finish._M_last - 1.
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_push_back_aux_v(const value_type& __t) {
+ _M_reserve_map_at_back();
+ *(this->_M_finish._M_node + 1) = this->_M_map_size.allocate(this->buffer_size());
+ _STLP_TRY {
+ _Copy_Construct(this->_M_finish._M_cur, __t);
+ this->_M_finish._M_set_node(this->_M_finish._M_node + 1);
+ this->_M_finish._M_cur = this->_M_finish._M_first;
+ }
+ _STLP_UNWIND(this->_M_map_size.deallocate(*(this->_M_finish._M_node + 1),
+ this->buffer_size()))
+}
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+// Called only if this->_M_finish._M_cur == this->_M_finish._M_last - 1.
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_push_back_aux() {
+ _M_reserve_map_at_back();
+ *(this->_M_finish._M_node + 1) = this->_M_map_size.allocate(this->buffer_size());
+ _STLP_TRY {
+ _STLP_STD::_Construct(this->_M_finish._M_cur);
+ this->_M_finish._M_set_node(this->_M_finish._M_node + 1);
+ this->_M_finish._M_cur = this->_M_finish._M_first;
+ }
+ _STLP_UNWIND(this->_M_map_size.deallocate(*(this->_M_finish._M_node + 1),
+ this->buffer_size()))
+}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+// Called only if this->_M_start._M_cur == this->_M_start._M_first.
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_push_front_aux_v(const value_type& __t) {
+ _M_reserve_map_at_front();
+ *(this->_M_start._M_node - 1) = this->_M_map_size.allocate(this->buffer_size());
+ _STLP_TRY {
+ this->_M_start._M_set_node(this->_M_start._M_node - 1);
+ this->_M_start._M_cur = this->_M_start._M_last - 1;
+ _Copy_Construct(this->_M_start._M_cur, __t);
+ }
+ _STLP_UNWIND((++this->_M_start,
+ this->_M_map_size.deallocate(*(this->_M_start._M_node - 1), this->buffer_size())))
+}
+
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+// Called only if this->_M_start._M_cur == this->_M_start._M_first.
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_push_front_aux() {
+ _M_reserve_map_at_front();
+ *(this->_M_start._M_node - 1) = this->_M_map_size.allocate(this->buffer_size());
+ _STLP_TRY {
+ this->_M_start._M_set_node(this->_M_start._M_node - 1);
+ this->_M_start._M_cur = this->_M_start._M_last - 1;
+ _STLP_STD::_Construct(this->_M_start._M_cur);
+ }
+ _STLP_UNWIND((++this->_M_start, this->_M_map_size.deallocate(*(this->_M_start._M_node - 1),
+ this->buffer_size())))
+}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+// Called only if this->_M_finish._M_cur == this->_M_finish._M_first.
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_pop_back_aux() {
+ this->_M_map_size.deallocate(this->_M_finish._M_first, this->buffer_size());
+ this->_M_finish._M_set_node(this->_M_finish._M_node - 1);
+ this->_M_finish._M_cur = this->_M_finish._M_last - 1;
+}
+
+// Note that if the deque has at least one element (a precondition for this member
+// function), and if this->_M_start._M_cur == this->_M_start._M_last, then the deque
+// must have at least two nodes.
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_pop_front_aux() {
+ if (this->_M_start._M_cur != this->_M_start._M_last - 1)
+ ++this->_M_start._M_cur;
+ else {
+ this->_M_map_size.deallocate(this->_M_start._M_first, this->buffer_size());
+ this->_M_start._M_set_node(this->_M_start._M_node + 1);
+ this->_M_start._M_cur = this->_M_start._M_first;
+ }
+}
+
+template <class _Tp, class _Alloc >
+__iterator__ deque<_Tp,_Alloc>::_M_fill_insert_aux(iterator __pos, size_type __n,
+ const value_type& __x,
+ const __true_type& /*_Movable*/) {
+ const difference_type __elems_before = __pos - this->_M_start;
+ size_type __length = this->size();
+ value_type __x_copy = __x;
+ if (__elems_before <= difference_type(__length / 2)) {
+ iterator __new_start = _M_reserve_elements_at_front(__n);
+ __pos = this->_M_start + __elems_before;
+ _STLP_TRY {
+ iterator __dst = __new_start;
+ iterator __src = this->_M_start;
+ for (; __src != __pos; ++__dst, ++__src) {
+ _STLP_STD::_Move_Construct(&(*__dst), *__src);
+ _STLP_STD::_Destroy_Moved(&(*__src));
+ }
+ this->_M_start = __new_start;
+ uninitialized_fill(__dst, __src, __x_copy);
+ __pos = __dst;
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+ }
+ else {
+ iterator __new_finish = _M_reserve_elements_at_back(__n);
+ const difference_type __elems_after = difference_type(__length) - __elems_before;
+ __pos = this->_M_finish - __elems_after;
+ _STLP_TRY {
+ iterator __dst = __new_finish;
+ iterator __src = this->_M_finish;
+ for (--__src, --__dst; __src >= __pos; --__src, --__dst) {
+ _STLP_STD::_Move_Construct(&(*__dst), *__src);
+ _STLP_STD::_Destroy_Moved(&(*__src));
+ }
+ this->_M_finish = __new_finish;
+ uninitialized_fill(__pos, __pos + __n, __x_copy);
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+ }
+ return __pos;
+}
+
+template <class _Tp, class _Alloc >
+__iterator__ deque<_Tp,_Alloc>::_M_fill_insert_aux(iterator __pos, size_type __n,
+ const value_type& __x,
+ const __false_type& /*_Movable*/) {
+ const difference_type __elems_before = __pos - this->_M_start;
+ size_type __length = this->size();
+ value_type __x_copy = __x;
+ if (__elems_before <= difference_type(__length / 2)) {
+ iterator __new_start = _M_reserve_elements_at_front(__n);
+ iterator __old_start = this->_M_start;
+ __pos = this->_M_start + __elems_before;
+ _STLP_TRY {
+ if (__elems_before >= difference_type(__n)) {
+ iterator __start_n = this->_M_start + difference_type(__n);
+ _STLP_PRIV __ucopy(this->_M_start, __start_n, __new_start);
+ this->_M_start = __new_start;
+ _STLP_STD::copy(__start_n, __pos, __old_start);
+ _STLP_STD::fill(__pos - difference_type(__n), __pos, __x_copy);
+ __pos -= difference_type(__n);
+ }
+ else {
+ _STLP_PRIV __uninitialized_copy_fill(this->_M_start, __pos, __new_start,
+ this->_M_start, __x_copy);
+ this->_M_start = __new_start;
+ fill(__old_start, __pos, __x_copy);
+ }
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+ }
+ else {
+ iterator __new_finish = _M_reserve_elements_at_back(__n);
+ iterator __old_finish = this->_M_finish;
+ const difference_type __elems_after =
+ difference_type(__length) - __elems_before;
+ __pos = this->_M_finish - __elems_after;
+ _STLP_TRY {
+ if (__elems_after > difference_type(__n)) {
+ iterator __finish_n = this->_M_finish - difference_type(__n);
+ _STLP_PRIV __ucopy(__finish_n, this->_M_finish, this->_M_finish);
+ this->_M_finish = __new_finish;
+ copy_backward(__pos, __finish_n, __old_finish);
+ fill(__pos, __pos + difference_type(__n), __x_copy);
+ }
+ else {
+ _STLP_PRIV __uninitialized_fill_copy(this->_M_finish, __pos + difference_type(__n),
+ __x_copy, __pos, this->_M_finish);
+ this->_M_finish = __new_finish;
+ fill(__pos, __old_finish, __x_copy);
+ }
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+ }
+ return __pos;
+}
+
+#if !defined (_STLP_MEMBER_TEMPLATES)
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_insert_range_aux(iterator __pos,
+ const value_type* __first, const value_type* __last,
+ size_type __n, const __true_type& /*_Movable*/) {
+ const difference_type __elems_before = __pos - this->_M_start;
+ size_type __length = size();
+ if (__elems_before <= difference_type(__length / 2)) {
+ iterator __new_start = _M_reserve_elements_at_front(__n);
+ __pos = this->_M_start + __elems_before;
+ _STLP_TRY {
+ iterator __dst = __new_start;
+ iterator __src = this->_M_start;
+ for (; __src != __pos; ++__dst, ++__src) {
+ _STLP_STD::_Move_Construct(&(*__dst), *__src);
+ _STLP_STD::_Destroy_Moved(&(*__src));
+ }
+ this->_M_start = __new_start;
+ _STLP_PRIV __ucopy(__first, __last, __dst);
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+ }
+ else {
+ iterator __new_finish = _M_reserve_elements_at_back(__n);
+ const difference_type __elems_after = difference_type(__length) - __elems_before;
+ __pos = this->_M_finish - __elems_after;
+ _STLP_TRY {
+ iterator __dst = __new_finish;
+ iterator __src = this->_M_finish;
+ for (--__src, --__dst; __src >= __pos; --__src, --__dst) {
+ _STLP_STD::_Move_Construct(&(*__dst), *__src);
+ _STLP_STD::_Destroy_Moved(&(*__src));
+ }
+ this->_M_finish = __new_finish;
+ _STLP_PRIV __ucopy(__first, __last, __pos);
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+ }
+}
+
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_insert_range_aux(iterator __pos,
+ const value_type* __first, const value_type* __last,
+ size_type __n, const __false_type& /*_Movable*/) {
+ const difference_type __elems_before = __pos - this->_M_start;
+ size_type __length = size();
+ if (__elems_before <= difference_type(__length / 2)) {
+ iterator __new_start = _M_reserve_elements_at_front(__n);
+ iterator __old_start = this->_M_start;
+ __pos = this->_M_start + __elems_before;
+ _STLP_TRY {
+ if (__elems_before >= difference_type(__n)) {
+ iterator __start_n = this->_M_start + difference_type(__n);
+ _STLP_PRIV __ucopy(this->_M_start, __start_n, __new_start);
+ this->_M_start = __new_start;
+ _STLP_STD::copy(__start_n, __pos, __old_start);
+ _STLP_STD::copy(__first, __last, __pos - difference_type(__n));
+ }
+ else {
+ const value_type* __mid = __first + (difference_type(__n) - __elems_before);
+ _STLP_PRIV __uninitialized_copy_copy(this->_M_start, __pos, __first, __mid, __new_start);
+ this->_M_start = __new_start;
+ _STLP_STD::copy(__mid, __last, __old_start);
+ }
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+ }
+ else {
+ iterator __new_finish = _M_reserve_elements_at_back(__n);
+ iterator __old_finish = this->_M_finish;
+ const difference_type __elems_after =
+ difference_type(__length) - __elems_before;
+ __pos = this->_M_finish - __elems_after;
+ _STLP_TRY {
+
+ if (__elems_after > difference_type(__n)) {
+ iterator __finish_n = this->_M_finish - difference_type(__n);
+ _STLP_PRIV __ucopy(__finish_n, this->_M_finish, this->_M_finish);
+ this->_M_finish = __new_finish;
+ _STLP_STD::copy_backward(__pos, __finish_n, __old_finish);
+ _STLP_STD::copy(__first, __last, __pos);
+ }
+ else {
+ const value_type* __mid = __first + __elems_after;
+ _STLP_PRIV __uninitialized_copy_copy(__mid, __last, __pos, this->_M_finish, this->_M_finish);
+ this->_M_finish = __new_finish;
+ _STLP_STD::copy(__first, __mid, __pos);
+ }
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+ }
+}
+
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_insert_range_aux(iterator __pos,
+ const_iterator __first, const_iterator __last,
+ size_type __n, const __true_type& /*_Movable*/) {
+ const difference_type __elems_before = __pos - this->_M_start;
+ size_type __length = size();
+ if (__elems_before <= difference_type(__length / 2)) {
+ iterator __new_start = _M_reserve_elements_at_front(__n);
+ __pos = this->_M_start + __elems_before;
+ _STLP_TRY {
+ iterator __dst = __new_start;
+ iterator __src = this->_M_start;
+ for (; __src != __pos; ++__dst, ++__src) {
+ _STLP_STD::_Move_Construct(&(*__dst), *__src);
+ _STLP_STD::_Destroy_Moved(&(*__src));
+ }
+ this->_M_start = __new_start;
+ _STLP_PRIV __ucopy(__first, __last, __dst);
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+ }
+ else {
+ iterator __new_finish = _M_reserve_elements_at_back(__n);
+ const difference_type __elems_after = difference_type(__length) - __elems_before;
+ __pos = this->_M_finish - __elems_after;
+ _STLP_TRY {
+ iterator __dst = __new_finish;
+ iterator __src = this->_M_finish;
+ for (--__src, --__dst; __src >= __pos; --__src, --__dst) {
+ _STLP_STD::_Move_Construct(&(*__dst), *__src);
+ _STLP_STD::_Destroy_Moved(&(*__src));
+ }
+ this->_M_finish = __new_finish;
+ _STLP_PRIV __ucopy(__first, __last, __pos);
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+ }
+}
+
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_insert_range_aux(iterator __pos,
+ const_iterator __first, const_iterator __last,
+ size_type __n, const __false_type& /*_Movable*/) {
+ const difference_type __elems_before = __pos - this->_M_start;
+ size_type __length = size();
+ if (__elems_before < difference_type(__length / 2)) {
+ iterator __new_start = _M_reserve_elements_at_front(__n);
+ iterator __old_start = this->_M_start;
+ __pos = this->_M_start + __elems_before;
+ _STLP_TRY {
+ if (__elems_before >= difference_type(__n)) {
+ iterator __start_n = this->_M_start + __n;
+ _STLP_PRIV __ucopy(this->_M_start, __start_n, __new_start);
+ this->_M_start = __new_start;
+ _STLP_STD::copy(__start_n, __pos, __old_start);
+ _STLP_STD::copy(__first, __last, __pos - difference_type(__n));
+ }
+ else {
+ const_iterator __mid = __first + (__n - __elems_before);
+ _STLP_PRIV __uninitialized_copy_copy(this->_M_start, __pos, __first, __mid, __new_start);
+ this->_M_start = __new_start;
+ _STLP_STD::copy(__mid, __last, __old_start);
+ }
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+ }
+ else {
+ iterator __new_finish = _M_reserve_elements_at_back(__n);
+ iterator __old_finish = this->_M_finish;
+ const difference_type __elems_after = __length - __elems_before;
+ __pos = this->_M_finish - __elems_after;
+ _STLP_TRY {
+ if (__elems_after > difference_type(__n)) {
+ iterator __finish_n = this->_M_finish - difference_type(__n);
+ _STLP_PRIV __ucopy(__finish_n, this->_M_finish, this->_M_finish);
+ this->_M_finish = __new_finish;
+ _STLP_STD::copy_backward(__pos, __finish_n, __old_finish);
+ _STLP_STD::copy(__first, __last, __pos);
+ }
+ else {
+ const_iterator __mid = __first + __elems_after;
+ _STLP_PRIV __uninitialized_copy_copy(__mid, __last, __pos, this->_M_finish, this->_M_finish);
+ this->_M_finish = __new_finish;
+ _STLP_STD::copy(__first, __mid, __pos);
+ }
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+ }
+}
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_new_elements_at_front(size_type __new_elems) {
+ size_type __new_nodes
+ = (__new_elems + this->buffer_size() - 1) / this->buffer_size();
+ _M_reserve_map_at_front(__new_nodes);
+ size_type __i = 1;
+ _STLP_TRY {
+ for (; __i <= __new_nodes; ++__i)
+ *(this->_M_start._M_node - __i) = this->_M_map_size.allocate(this->buffer_size());
+ }
+ _STLP_UNWIND(for (size_type __j = 1; __j < __i; ++__j)
+ this->_M_map_size.deallocate(*(this->_M_start._M_node - __j), this->buffer_size()))
+}
+
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_new_elements_at_back(size_type __new_elems) {
+ size_type __new_nodes
+ = (__new_elems + this->buffer_size() - 1) / this->buffer_size();
+ _M_reserve_map_at_back(__new_nodes);
+ size_type __i = 1;
+ _STLP_TRY {
+ for (; __i <= __new_nodes; ++__i)
+ *(this->_M_finish._M_node + __i) = this->_M_map_size.allocate(this->buffer_size());
+ }
+ _STLP_UNWIND(for (size_type __j = 1; __j < __i; ++__j)
+ this->_M_map_size.deallocate(*(this->_M_finish._M_node + __j), this->buffer_size()))
+}
+
+template <class _Tp, class _Alloc >
+void deque<_Tp,_Alloc>::_M_reallocate_map(size_type __nodes_to_add,
+ bool __add_at_front) {
+ size_type __old_num_nodes = this->_M_finish._M_node - this->_M_start._M_node + 1;
+ size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
+
+ _Map_pointer __new_nstart;
+ if (this->_M_map_size._M_data > 2 * __new_num_nodes) {
+ __new_nstart = this->_M_map._M_data + (this->_M_map_size._M_data - __new_num_nodes) / 2
+ + (__add_at_front ? __nodes_to_add : 0);
+ if (__new_nstart < this->_M_start._M_node)
+ _STLP_STD::copy(this->_M_start._M_node, this->_M_finish._M_node + 1, __new_nstart);
+ else
+ _STLP_STD::copy_backward(this->_M_start._M_node, this->_M_finish._M_node + 1,
+ __new_nstart + __old_num_nodes);
+ }
+ else {
+ size_type __new_map_size =
+ this->_M_map_size._M_data + (max)((size_t)this->_M_map_size._M_data, __nodes_to_add) + 2;
+
+ _Map_pointer __new_map = this->_M_map.allocate(__new_map_size);
+ __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
+ + (__add_at_front ? __nodes_to_add : 0);
+ _STLP_STD::copy(this->_M_start._M_node, this->_M_finish._M_node + 1, __new_nstart);
+ this->_M_map.deallocate(this->_M_map._M_data, this->_M_map_size._M_data);
+
+ this->_M_map._M_data = __new_map;
+ this->_M_map_size._M_data = __new_map_size;
+ }
+
+ this->_M_start._M_set_node(__new_nstart);
+ this->_M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
+}
+
+#if defined (deque)
+# undef deque
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+_STLP_END_NAMESPACE
+
+#undef __iterator__
+#undef iterator
+#undef const_iterator
+#undef size_type
+#undef value_type
+
+#endif /* _STLP_DEQUE_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_deque.h b/sources/android/stlport/stlport/stl/_deque.h
new file mode 100644
index 0000000..a8faeef
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_deque.h
@@ -0,0 +1,1115 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_DEQUE_H
+#define _STLP_INTERNAL_DEQUE_H
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+# include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+# include <stl/_alloc.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+# include <stl/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_UNINITIALIZED_H
+# include <stl/_uninitialized.h>
+#endif
+
+#ifndef _STLP_RANGE_ERRORS_H
+# include <stl/_range_errors.h>
+#endif
+
+/* Class invariants:
+ * For any nonsingular iterator i:
+ * i.node is the address of an element in the map array. The
+ * contents of i.node is a pointer to the beginning of a node.
+ * i.first == *(i.node)
+ * i.last == i.first + node_size
+ * i.cur is a pointer in the range [i.first, i.last). NOTE:
+ * the implication of this is that i.cur is always a dereferenceable
+ * pointer, even if i is a past-the-end iterator.
+ * Start and Finish are always nonsingular iterators. NOTE: this means
+ * that an empty deque must have one node, and that a deque
+ * with N elements, where N is the buffer size, must have two nodes.
+ * For every node other than start.node and finish.node, every element
+ * in the node is an initialized object. If start.node == finish.node,
+ * then [start.cur, finish.cur) are initialized objects, and
+ * the elements outside that range are uninitialized storage. Otherwise,
+ * [start.cur, start.last) and [finish.first, finish.cur) are initialized
+ * objects, and [start.first, start.cur) and [finish.cur, finish.last)
+ * are uninitialized storage.
+ * [map, map + map_size) is a valid, non-empty range.
+ * [start.node, finish.node] is a valid range contained within
+ * [map, map + map_size).
+ * A pointer in the range [map, map + map_size) points to an allocated node
+ * if and only if the pointer is in the range [start.node, finish.node].
+ */
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp>
+struct _Deque_iterator_base {
+
+ static size_t _S_buffer_size() {
+ const size_t blocksize = _MAX_BYTES;
+ return (sizeof(_Tp) < blocksize ? (blocksize / sizeof(_Tp)) : 1);
+ }
+
+ typedef random_access_iterator_tag iterator_category;
+
+ typedef _Tp value_type;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+
+ typedef value_type** _Map_pointer;
+
+ typedef _Deque_iterator_base< _Tp > _Self;
+
+ value_type* _M_cur;
+ value_type* _M_first;
+ value_type* _M_last;
+ _Map_pointer _M_node;
+
+ _Deque_iterator_base(value_type* __x, _Map_pointer __y)
+ : _M_cur(__x), _M_first(*__y),
+ _M_last(*__y + _S_buffer_size()), _M_node(__y) {}
+
+ _Deque_iterator_base() : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) {}
+
+// see comment in doc/README.evc4 and doc/README.evc8
+#if defined (_STLP_MSVC) && (_STLP_MSVC <= 1401) && defined (MIPS) && defined (NDEBUG)
+ _Deque_iterator_base(_Deque_iterator_base const& __other)
+ : _M_cur(__other._M_cur), _M_first(__other._M_first),
+ _M_last(__other._M_last), _M_node(__other._M_node) {}
+#endif
+
+ difference_type _M_subtract(const _Self& __x) const {
+ return difference_type(_S_buffer_size()) * (_M_node - __x._M_node - 1) +
+ (_M_cur - _M_first) + (__x._M_last - __x._M_cur);
+ }
+
+ void _M_increment() {
+ if (++_M_cur == _M_last) {
+ _M_set_node(_M_node + 1);
+ _M_cur = _M_first;
+ }
+ }
+
+ void _M_decrement() {
+ if (_M_cur == _M_first) {
+ _M_set_node(_M_node - 1);
+ _M_cur = _M_last;
+ }
+ --_M_cur;
+ }
+
+ void _M_advance(difference_type __n) {
+ const size_t buffersize = _S_buffer_size();
+ difference_type __offset = __n + (_M_cur - _M_first);
+ if (__offset >= 0 && __offset < difference_type(buffersize))
+ _M_cur += __n;
+ else {
+ difference_type __node_offset =
+ __offset > 0 ? __offset / buffersize
+ : -difference_type((-__offset - 1) / buffersize) - 1;
+ _M_set_node(_M_node + __node_offset);
+ _M_cur = _M_first +
+
+ (__offset - __node_offset * difference_type(buffersize));
+ }
+ }
+
+ void _M_set_node(_Map_pointer __new_node) {
+ _M_last = (_M_first = *(_M_node = __new_node)) + difference_type(_S_buffer_size());
+ }
+};
+
+
+template <class _Tp, class _Traits>
+struct _Deque_iterator : public _Deque_iterator_base< _Tp> {
+ typedef random_access_iterator_tag iterator_category;
+ typedef _Tp value_type;
+ typedef typename _Traits::reference reference;
+ typedef typename _Traits::pointer pointer;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef value_type** _Map_pointer;
+
+ typedef _Deque_iterator_base< _Tp > _Base;
+ typedef _Deque_iterator<_Tp, _Traits> _Self;
+ typedef typename _Traits::_NonConstTraits _NonConstTraits;
+ typedef _Deque_iterator<_Tp, _NonConstTraits> iterator;
+ typedef typename _Traits::_ConstTraits _ConstTraits;
+ typedef _Deque_iterator<_Tp, _ConstTraits> const_iterator;
+
+ _Deque_iterator(value_type* __x, _Map_pointer __y) :
+ _Deque_iterator_base<value_type>(__x,__y) {}
+
+ _Deque_iterator() {}
+ //copy constructor for iterator and constructor from iterator for const_iterator
+ _Deque_iterator(const iterator& __x) :
+ _Deque_iterator_base<value_type>(__x) {}
+
+ reference operator*() const {
+ return *this->_M_cur;
+ }
+
+ _STLP_DEFINE_ARROW_OPERATOR
+
+ difference_type operator-(const const_iterator& __x) const { return this->_M_subtract(__x); }
+
+ _Self& operator++() { this->_M_increment(); return *this; }
+ _Self operator++(int) {
+ _Self __tmp = *this;
+ ++*this;
+ return __tmp;
+ }
+
+ _Self& operator--() { this->_M_decrement(); return *this; }
+ _Self operator--(int) {
+ _Self __tmp = *this;
+ --*this;
+ return __tmp;
+ }
+
+ _Self& operator+=(difference_type __n) { this->_M_advance(__n); return *this; }
+ _Self operator+(difference_type __n) const {
+ _Self __tmp = *this;
+ return __tmp += __n;
+ }
+
+ _Self& operator-=(difference_type __n) { return *this += -__n; }
+ _Self operator-(difference_type __n) const {
+ _Self __tmp = *this;
+ return __tmp -= __n;
+ }
+
+ reference operator[](difference_type __n) const { return *(*this + __n); }
+};
+
+
+template <class _Tp, class _Traits>
+inline _Deque_iterator<_Tp, _Traits> _STLP_CALL
+operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Traits>& __x)
+{ return __x + __n; }
+
+
+#if defined (_STLP_USE_SEPARATE_RELOPS_NAMESPACE)
+template <class _Tp>
+inline bool _STLP_CALL
+operator==(const _Deque_iterator_base<_Tp >& __x,
+ const _Deque_iterator_base<_Tp >& __y)
+{ return __x._M_cur == __y._M_cur; }
+
+template <class _Tp>
+inline bool _STLP_CALL
+operator < (const _Deque_iterator_base<_Tp >& __x,
+ const _Deque_iterator_base<_Tp >& __y) {
+ return (__x._M_node == __y._M_node) ?
+ (__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node);
+}
+
+template <class _Tp>
+inline bool _STLP_CALL
+operator!=(const _Deque_iterator_base<_Tp >& __x,
+ const _Deque_iterator_base<_Tp >& __y)
+{ return __x._M_cur != __y._M_cur; }
+
+template <class _Tp>
+inline bool _STLP_CALL
+operator>(const _Deque_iterator_base<_Tp >& __x,
+ const _Deque_iterator_base<_Tp >& __y)
+{ return __y < __x; }
+
+template <class _Tp>
+inline bool _STLP_CALL operator>=(const _Deque_iterator_base<_Tp >& __x,
+ const _Deque_iterator_base<_Tp >& __y)
+{ return !(__x < __y); }
+
+template <class _Tp>
+inline bool _STLP_CALL operator<=(const _Deque_iterator_base<_Tp >& __x,
+ const _Deque_iterator_base<_Tp >& __y)
+{ return !(__y < __x); }
+
+#else /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
+
+template <class _Tp, class _Traits1, class _Traits2>
+inline bool _STLP_CALL
+operator==(const _Deque_iterator<_Tp, _Traits1 >& __x,
+ const _Deque_iterator<_Tp, _Traits2 >& __y)
+{ return __x._M_cur == __y._M_cur; }
+
+template <class _Tp, class _Traits1, class _Traits2>
+inline bool _STLP_CALL
+operator < (const _Deque_iterator<_Tp, _Traits1 >& __x,
+ const _Deque_iterator<_Tp, _Traits2 >& __y) {
+ return (__x._M_node == __y._M_node) ?
+ (__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node);
+}
+
+template <class _Tp>
+inline bool _STLP_CALL
+operator!=(const _Deque_iterator<_Tp, _Nonconst_traits<_Tp> >& __x,
+ const _Deque_iterator<_Tp, _Const_traits<_Tp> >& __y)
+{ return __x._M_cur != __y._M_cur; }
+
+template <class _Tp>
+inline bool _STLP_CALL
+operator>(const _Deque_iterator<_Tp, _Nonconst_traits<_Tp> >& __x,
+ const _Deque_iterator<_Tp, _Const_traits<_Tp> >& __y)
+{ return __y < __x; }
+
+template <class _Tp>
+inline bool _STLP_CALL
+operator>=(const _Deque_iterator<_Tp, _Nonconst_traits<_Tp> >& __x,
+ const _Deque_iterator<_Tp, _Const_traits<_Tp> >& __y)
+{ return !(__x < __y); }
+
+template <class _Tp>
+inline bool _STLP_CALL
+operator<=(const _Deque_iterator<_Tp, _Nonconst_traits<_Tp> >& __x,
+ const _Deque_iterator<_Tp, _Const_traits<_Tp> >& __y)
+{ return !(__y < __x); }
+#endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+_STLP_MOVE_TO_STD_NAMESPACE
+template <class _Tp, class _Traits>
+struct __type_traits<_STLP_PRIV _Deque_iterator<_Tp, _Traits> > {
+ typedef __false_type has_trivial_default_constructor;
+ typedef __true_type has_trivial_copy_constructor;
+ typedef __true_type has_trivial_assignment_operator;
+ typedef __true_type has_trivial_destructor;
+ typedef __false_type is_POD_type;
+};
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+#if defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
+_STLP_MOVE_TO_STD_NAMESPACE
+template <class _Tp, class _Traits> inline _Tp* _STLP_CALL
+value_type(const _STLP_PRIV _Deque_iterator<_Tp, _Traits >&) { return (_Tp*)0; }
+template <class _Tp, class _Traits> inline random_access_iterator_tag _STLP_CALL
+iterator_category(const _STLP_PRIV _Deque_iterator<_Tp, _Traits >&) { return random_access_iterator_tag(); }
+template <class _Tp, class _Traits> inline ptrdiff_t* _STLP_CALL
+distance_type(const _STLP_PRIV _Deque_iterator<_Tp, _Traits >&) { return 0; }
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+/* Deque base class. It has two purposes. First, its constructor
+ * and destructor allocate (but don't initialize) storage. This makes
+ * exception safety easier. Second, the base class encapsulates all of
+ * the differences between SGI-style allocators and standard-conforming
+ * allocators.
+ */
+
+template <class _Tp, class _Alloc>
+class _Deque_base {
+ typedef _Deque_base<_Tp, _Alloc> _Self;
+public:
+ typedef _Tp value_type;
+ _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
+ typedef _Alloc allocator_type;
+ typedef _STLP_alloc_proxy<size_t, value_type, allocator_type> _Alloc_proxy;
+
+ typedef typename _Alloc_traits<_Tp*, _Alloc>::allocator_type _Map_alloc_type;
+ typedef _STLP_alloc_proxy<value_type**, value_type*, _Map_alloc_type> _Map_alloc_proxy;
+
+ typedef _Deque_iterator<_Tp, _Nonconst_traits<_Tp> > iterator;
+ typedef _Deque_iterator<_Tp, _Const_traits<_Tp> > const_iterator;
+
+ static size_t _STLP_CALL buffer_size() { return _Deque_iterator_base<_Tp>::_S_buffer_size(); }
+
+ _Deque_base(const allocator_type& __a, size_t __num_elements)
+ : _M_start(), _M_finish(), _M_map(_STLP_CONVERT_ALLOCATOR(__a, _Tp*), 0),
+ _M_map_size(__a, (size_t)0)
+ { _M_initialize_map(__num_elements); }
+
+ _Deque_base(const allocator_type& __a)
+ : _M_start(), _M_finish(), _M_map(_STLP_CONVERT_ALLOCATOR(__a, _Tp*), 0),
+ _M_map_size(__a, (size_t)0) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ _Deque_base(__move_source<_Self> src)
+ : _M_start(src.get()._M_start), _M_finish(src.get()._M_finish),
+ _M_map(__move_source<_Map_alloc_proxy>(src.get()._M_map)),
+ _M_map_size(__move_source<_Alloc_proxy>(src.get()._M_map_size)) {
+ src.get()._M_map._M_data = 0;
+ src.get()._M_map_size._M_data = 0;
+ src.get()._M_finish = src.get()._M_start;
+ }
+#endif
+
+ ~_Deque_base();
+
+protected:
+ void _M_initialize_map(size_t);
+ void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish);
+ void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish);
+ enum { _S_initial_map_size = 8 };
+
+protected:
+ iterator _M_start;
+ iterator _M_finish;
+ _Map_alloc_proxy _M_map;
+ _Alloc_proxy _M_map_size;
+};
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+# define deque _STLP_PTR_IMPL_NAME(deque)
+#elif defined (_STLP_DEBUG)
+# define deque _STLP_NON_DBG_NAME(deque)
+#else
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) >
+class deque : protected _STLP_PRIV _Deque_base<_Tp, _Alloc>
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (deque)
+ , public __stlport_class<deque<_Tp, _Alloc> >
+#endif
+{
+ typedef _STLP_PRIV _Deque_base<_Tp, _Alloc> _Base;
+ typedef deque<_Tp, _Alloc> _Self;
+public: // Basic types
+ typedef _Tp value_type;
+ typedef value_type* pointer;
+ typedef const value_type* const_pointer;
+ typedef value_type& reference;
+ typedef const value_type& const_reference;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef random_access_iterator_tag _Iterator_category;
+ _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
+ typedef typename _Base::allocator_type allocator_type;
+
+public: // Iterators
+ typedef typename _Base::iterator iterator;
+ typedef typename _Base::const_iterator const_iterator;
+
+ _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS;
+
+protected: // Internal typedefs
+ typedef pointer* _Map_pointer;
+#if defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef __false_type _Movable;
+#endif
+
+public: // Basic accessors
+ iterator begin() { return this->_M_start; }
+ iterator end() { return this->_M_finish; }
+ const_iterator begin() const { return const_iterator(this->_M_start); }
+ const_iterator end() const { return const_iterator(this->_M_finish); }
+
+ reverse_iterator rbegin() { return reverse_iterator(this->_M_finish); }
+ reverse_iterator rend() { return reverse_iterator(this->_M_start); }
+ const_reverse_iterator rbegin() const
+ { return const_reverse_iterator(this->_M_finish); }
+ const_reverse_iterator rend() const
+ { return const_reverse_iterator(this->_M_start); }
+
+ reference operator[](size_type __n)
+ { return this->_M_start[difference_type(__n)]; }
+ const_reference operator[](size_type __n) const
+ { return this->_M_start[difference_type(__n)]; }
+
+ void _M_range_check(size_type __n) const {
+ if (__n >= this->size())
+ __stl_throw_out_of_range("deque");
+ }
+ reference at(size_type __n)
+ { _M_range_check(__n); return (*this)[__n]; }
+ const_reference at(size_type __n) const
+ { _M_range_check(__n); return (*this)[__n]; }
+
+ reference front() { return *this->_M_start; }
+ reference back() {
+ iterator __tmp = this->_M_finish;
+ --__tmp;
+ return *__tmp;
+ }
+ const_reference front() const { return *this->_M_start; }
+ const_reference back() const {
+ const_iterator __tmp = this->_M_finish;
+ --__tmp;
+ return *__tmp;
+ }
+
+ size_type size() const { return this->_M_finish - this->_M_start; }
+ size_type max_size() const { return size_type(-1); }
+ bool empty() const { return this->_M_finish == this->_M_start; }
+ allocator_type get_allocator() const { return this->_M_map_size; }
+
+public: // Constructor, destructor.
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ explicit deque(const allocator_type& __a = allocator_type())
+#else
+ deque()
+ : _STLP_PRIV _Deque_base<_Tp, _Alloc>(allocator_type(), 0) {}
+ deque(const allocator_type& __a)
+#endif
+ : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__a, 0) {}
+
+ deque(const _Self& __x)
+ : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__x.get_allocator(), __x.size())
+ { _STLP_PRIV __ucopy(__x.begin(), __x.end(), this->_M_start); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+private:
+ void _M_initialize(size_type __n, const value_type& __val = _STLP_DEFAULT_CONSTRUCTED(_Tp)) {
+ typedef typename _TrivialInit<_Tp>::_Ret _TrivialInit;
+ _M_fill_initialize(__val, _TrivialInit());
+ }
+public:
+ explicit deque(size_type __n)
+ : _STLP_PRIV _Deque_base<_Tp, _Alloc>(allocator_type(), __n)
+ { _M_initialize(__n); }
+ deque(size_type __n, const value_type& __val, const allocator_type& __a = allocator_type())
+#else
+ explicit deque(size_type __n)
+ : _STLP_PRIV _Deque_base<_Tp, _Alloc>(allocator_type(), __n) {
+ typedef typename _TrivialInit<_Tp>::_Ret _TrivialInit;
+ _M_fill_initialize(_STLP_DEFAULT_CONSTRUCTED(_Tp), _TrivialInit());
+ }
+ deque(size_type __n, const value_type& __val)
+ : _STLP_PRIV _Deque_base<_Tp, _Alloc>(allocator_type(), __n)
+ { _M_fill_initialize(__val, __false_type()); }
+ deque(size_type __n, const value_type& __val, const allocator_type& __a)
+#endif
+ : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__a, __n)
+ { _M_fill_initialize(__val, __false_type()); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+protected:
+ template <class _Integer>
+ void _M_initialize_dispatch(_Integer __n, _Integer __x, const __true_type&) {
+ this->_M_initialize_map(__n);
+ _M_fill_initialize(__x, __false_type());
+ }
+
+ template <class _InputIter>
+ void _M_initialize_dispatch(_InputIter __first, _InputIter __last,
+ const __false_type&) {
+ _M_range_initialize(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIter));
+ }
+
+public:
+ // Check whether it's an integral type. If so, it's not an iterator.
+ template <class _InputIterator>
+ deque(_InputIterator __first, _InputIterator __last,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__a) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_initialize_dispatch(__first, __last, _Integral());
+ }
+
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ deque(_InputIterator __first, _InputIterator __last)
+ : _STLP_PRIV _Deque_base<_Tp, _Alloc>(allocator_type()) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_initialize_dispatch(__first, __last, _Integral());
+ }
+# endif
+
+#else
+ deque(const value_type* __first, const value_type* __last,
+ const allocator_type& __a = allocator_type() )
+ : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__a, __last - __first)
+ { _STLP_PRIV __ucopy(__first, __last, this->_M_start); }
+
+ deque(const_iterator __first, const_iterator __last,
+ const allocator_type& __a = allocator_type() )
+ : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__a, __last - __first)
+ { _STLP_PRIV __ucopy(__first, __last, this->_M_start); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ deque(__move_source<_Self> src)
+ : _STLP_PRIV _Deque_base<_Tp, _Alloc>(__move_source<_Base>(src.get()))
+ {}
+#endif
+
+ ~deque()
+ { _STLP_STD::_Destroy_Range(this->_M_start, this->_M_finish); }
+
+ _Self& operator= (const _Self& __x);
+
+ void swap(_Self& __x) {
+ _STLP_STD::swap(this->_M_start, __x._M_start);
+ _STLP_STD::swap(this->_M_finish, __x._M_finish);
+ this->_M_map.swap(__x._M_map);
+ this->_M_map_size.swap(__x._M_map_size);
+ }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+public:
+ // assign(), a generalized assignment member function. Two
+ // versions: one that takes a count, and one that takes a range.
+ // The range version is a member template, so we dispatch on whether
+ // or not the type is an integer.
+
+ void _M_fill_assign(size_type __n, const _Tp& __val) {
+ if (__n > size()) {
+ _STLP_STD::fill(begin(), end(), __val);
+ insert(end(), __n - size(), __val);
+ }
+ else {
+ erase(begin() + __n, end());
+ _STLP_STD::fill(begin(), end(), __val);
+ }
+ }
+
+ void assign(size_type __n, const _Tp& __val) {
+ _M_fill_assign(__n, __val);
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void assign(_InputIterator __first, _InputIterator __last) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_assign_dispatch(__first, __last, _Integral());
+ }
+
+private: // helper functions for assign()
+
+ template <class _Integer>
+ void _M_assign_dispatch(_Integer __n, _Integer __val,
+ const __true_type& /*_IsIntegral*/)
+ { _M_fill_assign((size_type) __n, (_Tp) __val); }
+
+ template <class _InputIterator>
+ void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+ const __false_type& /*_IsIntegral*/) {
+ _M_assign_aux(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIterator));
+ }
+
+ template <class _InputIter>
+ void _M_assign_aux(_InputIter __first, _InputIter __last, const input_iterator_tag &) {
+ iterator __cur = begin();
+ for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
+ *__cur = *__first;
+ if (__first == __last)
+ erase(__cur, end());
+ else
+ insert(end(), __first, __last);
+ }
+
+ template <class _ForwardIterator>
+ void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+ const forward_iterator_tag &) {
+#else
+ void assign(const value_type *__first, const value_type *__last) {
+ size_type __size = size();
+ size_type __len = __last - __first;
+ if (__len > __size) {
+ const value_type *__mid = __first + __size;
+ _STLP_STD::copy(__first, __mid, begin());
+ insert(end(), __mid, __last);
+ }
+ else {
+ erase(_STLP_STD::copy(__first, __last, begin()), end());
+ }
+ }
+ void assign(const_iterator __first, const_iterator __last) {
+ typedef const_iterator _ForwardIterator;
+#endif /* _STLP_MEMBER_TEMPLATES */
+ size_type __len = _STLP_STD::distance(__first, __last);
+ if (__len > size()) {
+ _ForwardIterator __mid = __first;
+ _STLP_STD::advance(__mid, size());
+ _STLP_STD::copy(__first, __mid, begin());
+ insert(end(), __mid, __last);
+ }
+ else {
+ erase(_STLP_STD::copy(__first, __last, begin()), end());
+ }
+ }
+
+
+public: // push_* and pop_*
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ void push_back(const value_type& __t = _STLP_DEFAULT_CONSTRUCTED(_Tp)) {
+#else
+ void push_back(const value_type& __t) {
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+ if (this->_M_finish._M_cur != this->_M_finish._M_last - 1) {
+ _Copy_Construct(this->_M_finish._M_cur, __t);
+ ++this->_M_finish._M_cur;
+ }
+ else
+ _M_push_back_aux_v(__t);
+ }
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ void push_front(const value_type& __t = _STLP_DEFAULT_CONSTRUCTED(_Tp)) {
+#else
+ void push_front(const value_type& __t) {
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+ if (this->_M_start._M_cur != this->_M_start._M_first) {
+ _Copy_Construct(this->_M_start._M_cur - 1, __t);
+ --this->_M_start._M_cur;
+ }
+ else
+ _M_push_front_aux_v(__t);
+ }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ void push_back() {
+ if (this->_M_finish._M_cur != this->_M_finish._M_last - 1) {
+ _STLP_STD::_Construct(this->_M_finish._M_cur);
+ ++this->_M_finish._M_cur;
+ }
+ else
+ _M_push_back_aux();
+ }
+ void push_front() {
+ if (this->_M_start._M_cur != this->_M_start._M_first) {
+ _STLP_STD::_Construct(this->_M_start._M_cur - 1);
+ --this->_M_start._M_cur;
+ }
+ else
+ _M_push_front_aux();
+ }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+ void pop_back() {
+ if (this->_M_finish._M_cur != this->_M_finish._M_first) {
+ --this->_M_finish._M_cur;
+ _STLP_STD::_Destroy(this->_M_finish._M_cur);
+ }
+ else {
+ _M_pop_back_aux();
+ _STLP_STD::_Destroy(this->_M_finish._M_cur);
+ }
+ }
+
+ void pop_front() {
+ _STLP_STD::_Destroy(this->_M_start._M_cur);
+ _M_pop_front_aux();
+ }
+
+public: // Insert
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ iterator insert(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(_Tp)) {
+#else
+ iterator insert(iterator __pos, const value_type& __x) {
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+ if (__pos._M_cur == this->_M_start._M_cur) {
+ push_front(__x);
+ return this->_M_start;
+ }
+ else if (__pos._M_cur == this->_M_finish._M_cur) {
+ push_back(__x);
+ iterator __tmp = this->_M_finish;
+ --__tmp;
+ return __tmp;
+ }
+ else {
+ return _M_fill_insert_aux(__pos, 1, __x, _Movable());
+ }
+ }
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+ iterator insert(iterator __pos)
+ { return insert(__pos, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+ void insert(iterator __pos, size_type __n, const value_type& __x)
+ { _M_fill_insert(__pos, __n, __x); }
+
+protected:
+ iterator _M_fill_insert_aux(iterator __pos, size_type __n, const value_type& __x, const __true_type& /*_Movable*/);
+ iterator _M_fill_insert_aux(iterator __pos, size_type __n, const value_type& __x, const __false_type& /*_Movable*/);
+
+ void _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _Integer>
+ void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
+ const __true_type& /*_IsIntegral*/) {
+ _M_fill_insert(__pos, (size_type) __n, (value_type) __x);
+ }
+
+ template <class _InputIterator>
+ void _M_insert_dispatch(iterator __pos,
+ _InputIterator __first, _InputIterator __last,
+ const __false_type& /*_IsIntegral*/) {
+ _M_insert(__pos, __first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIterator));
+ }
+
+public:
+ // Check whether it's an integral type. If so, it's not an iterator.
+ template <class _InputIterator>
+ void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_insert_dispatch(__pos, __first, __last, _Integral());
+ }
+
+#else /* _STLP_MEMBER_TEMPLATES */
+ void _M_insert_range_aux(iterator __pos,
+ const value_type* __first, const value_type* __last,
+ size_type __n, const __true_type& /*_Movable*/);
+ void _M_insert_range_aux(iterator __pos,
+ const value_type* __first, const value_type* __last,
+ size_type __n, const __false_type& /*_Movable*/);
+ void _M_insert_range_aux(iterator __pos,
+ const_iterator __first, const_iterator __last,
+ size_type __n, const __true_type& /*_Movable*/);
+ void _M_insert_range_aux(iterator __pos,
+ const_iterator __first, const_iterator __last,
+ size_type __n, const __false_type& /*_Movable*/);
+public:
+ void insert(iterator __pos,
+ const value_type* __first, const value_type* __last);
+ void insert(iterator __pos,
+ const_iterator __first, const_iterator __last);
+
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+public:
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size,
+ const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(_Tp)) {
+#else
+ void resize(size_type __new_size, const value_type& __x) {
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ const size_type __len = size();
+ if (__new_size < __len)
+ erase(this->_M_start + __new_size, this->_M_finish);
+ else
+ insert(this->_M_finish, __new_size - __len, __x);
+ }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size)
+ { resize(__new_size, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+protected:
+ iterator _M_erase(iterator __pos, const __true_type& /*_Movable*/);
+ iterator _M_erase(iterator __pos, const __false_type& /*_Movable*/);
+
+ iterator _M_erase(iterator __first, iterator __last, const __true_type& /*_Movable*/);
+ iterator _M_erase(iterator __first, iterator __last, const __false_type& /*_Movable*/);
+public: // Erase
+ iterator erase(iterator __pos) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+ return _M_erase(__pos, _Movable());
+ }
+ iterator erase(iterator __first, iterator __last) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+ if (__first == this->_M_start && __last == this->_M_finish) {
+ clear();
+ return this->_M_finish;
+ }
+ else {
+ if (__first == __last)
+ return __first;
+ return _M_erase(__first, __last, _Movable());
+ }
+ }
+ void clear();
+
+protected: // Internal construction/destruction
+
+ void _M_fill_initialize(const value_type& __val, const __true_type& /*_TrivialInit*/)
+ {}
+ void _M_fill_initialize(const value_type& __val, const __false_type& /*_TrivialInit*/);
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void _M_range_initialize(_InputIterator __first, _InputIterator __last,
+ const input_iterator_tag &) {
+ this->_M_initialize_map(0);
+ _STLP_TRY {
+ for ( ; __first != __last; ++__first)
+ push_back(*__first);
+ }
+ _STLP_UNWIND(clear())
+ }
+ template <class _ForwardIterator>
+ void _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
+ const forward_iterator_tag &) {
+ size_type __n = _STLP_STD::distance(__first, __last);
+ this->_M_initialize_map(__n);
+ _Map_pointer __cur_node = this->_M_start._M_node;
+ _STLP_TRY {
+ for (; __cur_node < this->_M_finish._M_node; ++__cur_node) {
+ _ForwardIterator __mid = __first;
+ _STLP_STD::advance(__mid, this->buffer_size());
+ _STLP_STD::uninitialized_copy(__first, __mid, *__cur_node);
+ __first = __mid;
+ }
+ _STLP_STD::uninitialized_copy(__first, __last, this->_M_finish._M_first);
+ }
+ _STLP_UNWIND(_STLP_STD::_Destroy_Range(this->_M_start, iterator(*__cur_node, __cur_node)))
+ }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+protected: // Internal push_* and pop_*
+
+ void _M_push_back_aux_v(const value_type&);
+ void _M_push_front_aux_v(const value_type&);
+#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ void _M_push_back_aux();
+ void _M_push_front_aux();
+#endif /*_STLP_DONT_SUP_DFLT_PARAM !_STLP_NO_ANACHRONISMS*/
+ void _M_pop_back_aux();
+ void _M_pop_front_aux();
+
+protected: // Internal insert functions
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+
+ template <class _InputIterator>
+ void _M_insert(iterator __pos,
+ _InputIterator __first,
+ _InputIterator __last,
+ const input_iterator_tag &) {
+ _STLP_STD::copy(__first, __last, inserter(*this, __pos));
+ }
+
+ template <class _ForwardIterator>
+ void _M_insert(iterator __pos,
+ _ForwardIterator __first, _ForwardIterator __last,
+ const forward_iterator_tag &) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+ size_type __n = _STLP_STD::distance(__first, __last);
+ if (__pos._M_cur == this->_M_start._M_cur) {
+ iterator __new_start = _M_reserve_elements_at_front(__n);
+ _STLP_TRY {
+ uninitialized_copy(__first, __last, __new_start);
+ this->_M_start = __new_start;
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+ }
+ else if (__pos._M_cur == this->_M_finish._M_cur) {
+ iterator __new_finish = _M_reserve_elements_at_back(__n);
+ _STLP_TRY {
+ uninitialized_copy(__first, __last, this->_M_finish);
+ this->_M_finish = __new_finish;
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+ }
+ else
+ _M_insert_range_aux(__pos, __first, __last, __n, _Movable());
+ }
+
+ template <class _ForwardIterator>
+ void _M_insert_range_aux(iterator __pos,
+ _ForwardIterator __first, _ForwardIterator __last,
+ size_type __n, const __true_type& /*_Movable*/) {
+ const difference_type __elemsbefore = __pos - this->_M_start;
+ size_type __length = size();
+ if (__elemsbefore <= difference_type(__length / 2)) {
+ iterator __new_start = _M_reserve_elements_at_front(__n);
+ __pos = this->_M_start + __elemsbefore;
+ _STLP_TRY {
+ iterator __dst = __new_start;
+ iterator __src = this->_M_start;
+ for (; __src != __pos; ++__dst, ++__src) {
+ _STLP_STD::_Move_Construct(&(*__dst), *__src);
+ _STLP_STD::_Destroy_Moved(&(*__src));
+ }
+ this->_M_start = __new_start;
+ uninitialized_copy(__first, __last, __dst);
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+ }
+ else {
+ iterator __new_finish = _M_reserve_elements_at_back(__n);
+ const difference_type __elemsafter = difference_type(__length) - __elemsbefore;
+ __pos = this->_M_finish - __elemsafter;
+ _STLP_TRY {
+ iterator __dst = __new_finish;
+ iterator __src = this->_M_finish;
+ for (--__src, --__dst; __src >= __pos; --__src, --__dst) {
+ _STLP_STD::_Move_Construct(&(*__dst), *__src);
+ _STLP_STD::_Destroy_Moved(&(*__src));
+ }
+ this->_M_finish = __new_finish;
+ uninitialized_copy(__first, __last, __pos);
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+ }
+ }
+
+ template <class _ForwardIterator>
+ void _M_insert_range_aux(iterator __pos,
+ _ForwardIterator __first, _ForwardIterator __last,
+ size_type __n, const __false_type& /*_Movable*/) {
+ const difference_type __elemsbefore = __pos - this->_M_start;
+ size_type __length = size();
+ if (__elemsbefore <= difference_type(__length / 2)) {
+ iterator __new_start = _M_reserve_elements_at_front(__n);
+ iterator __old_start = this->_M_start;
+ __pos = this->_M_start + __elemsbefore;
+ _STLP_TRY {
+ if (__elemsbefore >= difference_type(__n)) {
+ iterator __start_n = this->_M_start + difference_type(__n);
+ _STLP_STD::uninitialized_copy(this->_M_start, __start_n, __new_start);
+ this->_M_start = __new_start;
+ _STLP_STD::copy(__start_n, __pos, __old_start);
+ _STLP_STD::copy(__first, __last, __pos - difference_type(__n));
+ }
+ else {
+ _ForwardIterator __mid = __first;
+ _STLP_STD::advance(__mid, difference_type(__n) - __elemsbefore);
+ _STLP_PRIV __uninitialized_copy_copy(this->_M_start, __pos, __first, __mid, __new_start);
+ this->_M_start = __new_start;
+ _STLP_STD::copy(__mid, __last, __old_start);
+ }
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(__new_start._M_node, this->_M_start._M_node))
+ }
+ else {
+ iterator __new_finish = _M_reserve_elements_at_back(__n);
+ iterator __old_finish = this->_M_finish;
+ const difference_type __elemsafter = difference_type(__length) - __elemsbefore;
+ __pos = this->_M_finish - __elemsafter;
+ _STLP_TRY {
+ if (__elemsafter > difference_type(__n)) {
+ iterator __finish_n = this->_M_finish - difference_type(__n);
+ _STLP_STD::uninitialized_copy(__finish_n, this->_M_finish, this->_M_finish);
+ this->_M_finish = __new_finish;
+ _STLP_STD::copy_backward(__pos, __finish_n, __old_finish);
+ _STLP_STD::copy(__first, __last, __pos);
+ }
+ else {
+ _ForwardIterator __mid = __first;
+ _STLP_STD::advance(__mid, __elemsafter);
+ _STLP_PRIV __uninitialized_copy_copy(__mid, __last, __pos, this->_M_finish, this->_M_finish);
+ this->_M_finish = __new_finish;
+ _STLP_STD::copy(__first, __mid, __pos);
+ }
+ }
+ _STLP_UNWIND(this->_M_destroy_nodes(this->_M_finish._M_node + 1, __new_finish._M_node + 1))
+ }
+ }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ iterator _M_reserve_elements_at_front(size_type __n) {
+ size_type __vacancies = this->_M_start._M_cur - this->_M_start._M_first;
+ if (__n > __vacancies)
+ _M_new_elements_at_front(__n - __vacancies);
+ return this->_M_start - difference_type(__n);
+ }
+
+ iterator _M_reserve_elements_at_back(size_type __n) {
+ size_type __vacancies = (this->_M_finish._M_last - this->_M_finish._M_cur) - 1;
+ if (__n > __vacancies)
+ _M_new_elements_at_back(__n - __vacancies);
+ return this->_M_finish + difference_type(__n);
+ }
+
+ void _M_new_elements_at_front(size_type __new_elements);
+ void _M_new_elements_at_back(size_type __new_elements);
+
+protected: // Allocation of _M_map and nodes
+
+ // Makes sure the _M_map has space for new nodes. Does not actually
+ // add the nodes. Can invalidate _M_map pointers. (And consequently,
+ // deque iterators.)
+
+ void _M_reserve_map_at_back (size_type __nodes_to_add = 1) {
+ if (__nodes_to_add + 1 > this->_M_map_size._M_data - (this->_M_finish._M_node - this->_M_map._M_data))
+ _M_reallocate_map(__nodes_to_add, false);
+ }
+
+ void _M_reserve_map_at_front (size_type __nodes_to_add = 1) {
+ if (__nodes_to_add > size_type(this->_M_start._M_node - this->_M_map._M_data))
+ _M_reallocate_map(__nodes_to_add, true);
+ }
+
+ void _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front);
+};
+
+#if defined (deque)
+# undef deque
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_deque.c>
+#endif
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+# include <stl/pointers/_deque.h>
+#endif
+
+#if defined (_STLP_DEBUG)
+# include <stl/debug/_deque.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#define _STLP_TEMPLATE_CONTAINER deque<_Tp, _Alloc>
+#define _STLP_TEMPLATE_HEADER template <class _Tp, class _Alloc>
+#include <stl/_relops_cont.h>
+#undef _STLP_TEMPLATE_CONTAINER
+#undef _STLP_TEMPLATE_HEADER
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Tp, class _Alloc>
+struct __move_traits<deque<_Tp, _Alloc> > {
+ typedef __true_type implemented;
+ typedef typename __move_traits<_Alloc>::complete complete;
+};
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_DEQUE_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/stl/_epilog.h b/sources/android/stlport/stlport/stl/_epilog.h
new file mode 100644
index 0000000..0747ae3
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_epilog.h
@@ -0,0 +1,42 @@
+/* NOTE : this header has no guards and is MEANT for multiple inclusion!
+ * If you are using "header protection" option with your compiler,
+ * please also find #pragma which disables it and put it here, to
+ * allow reentrancy of this header.
+ */
+
+#ifndef _STLP_PROLOG_HEADER_INCLUDED
+# error STLport epilog header can not be included as long as prolog has not be included.
+#endif
+
+/* If the platform provides any specific epilog actions,
+ * like #pragmas, do include platform-specific prolog file
+ */
+#if defined (_STLP_HAS_SPECIFIC_PROLOG_EPILOG)
+# include <stl/config/_epilog.h>
+#endif
+
+#if !defined (_STLP_NO_POST_COMPATIBLE_SECTION)
+# include <stl/_config_compat_post.h>
+#endif
+
+#if defined (_STLP_USE_OWN_NAMESPACE)
+
+# if !defined (_STLP_DONT_REDEFINE_STD)
+/* We redefine "std" to STLPORT, so that user code may use std:: transparently
+ * The STLPORT macro contains the STLport namespace name containing all the std
+ * stuff.
+ */
+# if defined (std)
+/*
+ * Looks like the compiler native library on which STLport rely defined the std macro.
+ * This might introduce major incompatibility so report the problem to the STLport
+ * forum or comment the following #error at your own risk.
+ */
+# error Incompatible native Std library.
+# endif /* std */
+# define std STLPORT
+# endif /* _STLP_DONT_REDEFINE_STD */
+
+#endif
+
+#undef _STLP_PROLOG_HEADER_INCLUDED /* defined in _prolog.h */
diff --git a/sources/android/stlport/stlport/stl/_exception.h b/sources/android/stlport/stlport/stl/_exception.h
new file mode 100644
index 0000000..a0bf4ad
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_exception.h
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+// The header <exception> contains low-level functions that interact
+// with a compiler's exception-handling mechanism. It is assumed to
+// be supplied with the compiler, rather than with the library, because
+// it is inherently tied very closely to the compiler itself.
+
+// On platforms where <exception> does not exist, this header defines
+// an exception base class. This is *not* a substitute for everything
+// in <exception>, but it suffices to support a bare minimum of STL
+// functionality.
+
+#ifndef _STLP_INTERNAL_EXCEPTION
+#define _STLP_INTERNAL_EXCEPTION
+
+#if !defined (_STLP_NO_EXCEPTION_HEADER)
+
+# if defined ( _UNCAUGHT_EXCEPTION )
+# undef _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT
+# endif
+
+# if defined (_STLP_BROKEN_EXCEPTION_CLASS)
+# define exception _STLP_NULLIFIED_BROKEN_EXCEPTION_CLASS
+# define bad_exception _STLP_NULLIFIED_BROKEN_BAD_EXCEPTION_CLASS
+# if defined (_STLP_NO_NEW_NEW_HEADER)
+# include _STLP_NATIVE_CPP_RUNTIME_HEADER(Exception.h)
+# else
+# include _STLP_NATIVE_CPP_RUNTIME_HEADER(Exception)
+# endif
+# undef exception
+# undef bad_exception
+# else
+# if defined (_STLP_NO_NEW_NEW_HEADER)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <exception.h>
+# else
+# include _STLP_NATIVE_CPP_RUNTIME_HEADER(exception.h)
+# endif
+# else
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <exception>
+# else
+# include _STLP_NATIVE_CPP_RUNTIME_HEADER(exception)
+# endif
+# endif
+# endif
+
+# if defined (_STLP_HAS_SPECIFIC_PROLOG_EPILOG) && defined (_STLP_MSVC_LIB) && (_STLP_MSVC_LIB < 1300)
+// dwa 02/04/00
+// The header <yvals.h> which ships with vc6 and is included by its native <exception>
+// actually turns on warnings, so we have to turn them back off.
+# include <stl/config/_warnings_off.h>
+# endif
+
+# if defined (_STLP_USE_OWN_NAMESPACE)
+
+_STLP_BEGIN_NAMESPACE
+# if !defined (_STLP_BROKEN_EXCEPTION_CLASS)
+# if !defined (_STLP_USING_PLATFORM_SDK_COMPILER) || !defined (_WIN64)
+using _STLP_VENDOR_EXCEPT_STD::exception;
+# else
+using ::exception;
+# endif
+using _STLP_VENDOR_EXCEPT_STD::bad_exception;
+# endif
+
+# if !defined (_STLP_NO_USING_FOR_GLOBAL_FUNCTIONS)
+// fbp : many platforms present strange mix of
+// those in various namespaces
+# if !defined (_STLP_VENDOR_UNEXPECTED_STD)
+# define _STLP_VENDOR_UNEXPECTED_STD _STLP_VENDOR_EXCEPT_STD
+# else
+/* The following definitions are for backward compatibility as _STLP_VENDOR_TERMINATE_STD
+ * and _STLP_VENDOR_UNCAUGHT_EXCEPTION_STD has been introduce after _STLP_VENDOR_UNEXPECTED_STD
+ * and _STLP_VENDOR_UNEXPECTED_STD was the macro used in their place before that introduction.
+ */
+# if !defined (_STLP_VENDOR_TERMINATE_STD)
+# define _STLP_VENDOR_TERMINATE_STD _STLP_VENDOR_UNEXPECTED_STD
+# endif
+# if !defined (_STLP_VENDOR_UNCAUGHT_EXCEPTION_STD)
+# define _STLP_VENDOR_UNCAUGHT_EXCEPTION_STD _STLP_VENDOR_UNEXPECTED_STD
+# endif
+# endif
+# if !defined (_STLP_VENDOR_TERMINATE_STD)
+# define _STLP_VENDOR_TERMINATE_STD _STLP_VENDOR_EXCEPT_STD
+# endif
+# if !defined (_STLP_VENDOR_UNCAUGHT_EXCEPTION_STD)
+# define _STLP_VENDOR_UNCAUGHT_EXCEPTION_STD _STLP_VENDOR_EXCEPT_STD
+# endif
+# if !defined (_STLP_VENDOR_TERMINATE_STD)
+# define _STLP_VENDOR_TERMINATE_STD _STLP_VENDOR_EXCEPT_STD
+# endif
+# if !defined (_STLP_VENDOR_UNCAUGHT_EXCEPTION_STD)
+# define _STLP_VENDOR_UNCAUGHT_EXCEPTION_STD _STLP_VENDOR_EXCEPT_STD
+# endif
+// weird errors
+# if !defined (_STLP_NO_UNEXPECTED_EXCEPT_SUPPORT)
+# if defined (__ICL) && (__ICL >= 900) && (_STLP_MSVC_LIB < 1300)
+//See config/_intel.h for reason about this workaround
+using std::unexpected;
+# else
+using _STLP_VENDOR_UNEXPECTED_STD::unexpected;
+# endif
+using _STLP_VENDOR_UNEXPECTED_STD::unexpected_handler;
+using _STLP_VENDOR_UNEXPECTED_STD::set_unexpected;
+# endif
+using _STLP_VENDOR_TERMINATE_STD::terminate;
+using _STLP_VENDOR_TERMINATE_STD::terminate_handler;
+using _STLP_VENDOR_TERMINATE_STD::set_terminate;
+
+# if !defined (_STLP_NO_UNCAUGHT_EXCEPT_SUPPORT)
+using _STLP_VENDOR_UNCAUGHT_EXCEPTION_STD::uncaught_exception;
+# endif
+# endif /* !_STLP_NO_USING_FOR_GLOBAL_FUNCTIONS */
+_STLP_END_NAMESPACE
+# endif /* _STLP_OWN_NAMESPACE */
+#else /* _STLP_NO_EXCEPTION_HEADER */
+
+/* fbp : absence of <exception> usually means that those
+ * functions are not going to be called by compiler.
+ * Still, define them for the user.
+ * dums: Policy modification, if the function do not behave like the Standard
+ * defined it we do not grant it in the STLport namespace. We will have
+ * compile time error rather than runtime error.
+ */
+#if 0
+/*
+typedef void (*unexpected_handler)();
+unexpected_handler set_unexpected(unexpected_handler f) _STLP_NOTHROW_INHERENTLY;
+void unexpected();
+
+typedef void (*terminate_handler)();
+terminate_handler set_terminate(terminate_handler f) _STLP_NOTHROW_INHERENTLY;
+void terminate();
+
+bool uncaught_exception(); // not implemented under mpw as of Jan/1999
+*/
+#endif
+
+#endif /* _STLP_NO_EXCEPTION_HEADER */
+
+#if defined (_STLP_NO_EXCEPTION_HEADER) || defined (_STLP_BROKEN_EXCEPTION_CLASS)
+_STLP_BEGIN_NAMESPACE
+
+// section 18.6.1
+class _STLP_CLASS_DECLSPEC exception {
+public:
+# ifndef _STLP_USE_NO_IOSTREAMS
+ exception() _STLP_NOTHROW;
+ virtual ~exception() _STLP_NOTHROW;
+ virtual const char* what() const _STLP_NOTHROW;
+# else
+ exception() _STLP_NOTHROW {}
+ virtual ~exception() _STLP_NOTHROW {}
+ virtual const char* what() const _STLP_NOTHROW {return "class exception";}
+# endif
+};
+
+// section 18.6.2.1
+class _STLP_CLASS_DECLSPEC bad_exception : public exception {
+public:
+# ifndef _STLP_USE_NO_IOSTREAMS
+ bad_exception() _STLP_NOTHROW;
+ ~bad_exception() _STLP_NOTHROW;
+ const char* what() const _STLP_NOTHROW;
+# else
+ bad_exception() _STLP_NOTHROW {}
+ ~bad_exception() _STLP_NOTHROW {}
+ const char* what() const _STLP_NOTHROW {return "class bad_exception";}
+# endif
+};
+
+// forward declaration
+class __Named_exception;
+_STLP_END_NAMESPACE
+#endif
+
+#endif /* _STLP_INTERNAL_EXCEPTION */
diff --git a/sources/android/stlport/stlport/stl/_facets_fwd.h b/sources/android/stlport/stlport/stl/_facets_fwd.h
new file mode 100644
index 0000000..d4c8451
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_facets_fwd.h
@@ -0,0 +1,53 @@
+#ifndef _STLP_FACETS_FWD_H
+#define _STLP_FACETS_FWD_H
+
+
+#include <stl/_iosfwd.h>
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+template <class _CharT, class _InputIter>
+#else
+template <class _CharT, class _InputIter = istreambuf_iterator<_CharT, char_traits<_CharT> > >
+#endif
+class money_get;
+
+#if defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+template <class _CharT, class _OutputIter>
+#else
+template <class _CharT, class _OutputIter = ostreambuf_iterator<_CharT, char_traits<_CharT> > >
+#endif
+class money_put;
+
+#if defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+template <class _CharT, class _InputIter>
+#else
+template <class _CharT, class _InputIter = istreambuf_iterator<_CharT, char_traits<_CharT> > >
+#endif
+class num_get;
+
+#if defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+template <class _CharT, class _OutputIter>
+#else
+template <class _CharT, class _OutputIter = ostreambuf_iterator<_CharT, char_traits<_CharT> > >
+#endif
+class num_put;
+
+#if defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+template <class _Ch, class _InIt>
+#else
+template <class _Ch, class _InIt = istreambuf_iterator<_Ch, char_traits<_Ch> > >
+#endif
+class time_get;
+
+#if defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+template <class _Ch, class _OutIt>
+#else
+template <class _Ch, class _OutIt = ostreambuf_iterator<_Ch, char_traits<_Ch> > >
+#endif
+class time_put;
+
+_STLP_END_NAMESPACE
+
+#endif
diff --git a/sources/android/stlport/stlport/stl/_fstream.c b/sources/android/stlport/stlport/stl/_fstream.c
new file mode 100644
index 0000000..f1548ae
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_fstream.c
@@ -0,0 +1,766 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_FSTREAM_C
+#define _STLP_FSTREAM_C
+
+#ifndef _STLP_INTERNAL_FSTREAM_H
+# include <stl/_fstream.h>
+#endif
+
+#ifndef _STLP_INTERNAL_LIMITS
+# include <stl/_limits.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+# if defined ( _STLP_NESTED_TYPE_PARAM_BUG )
+// no wchar_t is supported for this mode
+# define __BF_int_type__ int
+# define __BF_pos_type__ streampos
+# define __BF_off_type__ streamoff
+# else
+# define __BF_int_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_filebuf<_CharT, _Traits>::int_type
+# define __BF_pos_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_filebuf<_CharT, _Traits>::pos_type
+# define __BF_off_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_filebuf<_CharT, _Traits>::off_type
+# endif
+
+
+//----------------------------------------------------------------------
+// Public basic_filebuf<> member functions
+
+template <class _CharT, class _Traits>
+basic_filebuf<_CharT, _Traits>::basic_filebuf()
+ : basic_streambuf<_CharT, _Traits>(), _M_base(),
+ _M_constant_width(false), _M_always_noconv(false),
+ _M_int_buf_dynamic(false),
+ _M_in_input_mode(false), _M_in_output_mode(false),
+ _M_in_error_mode(false), _M_in_putback_mode(false),
+ _M_int_buf(0), _M_int_buf_EOS(0),
+ _M_ext_buf(0), _M_ext_buf_EOS(0),
+ _M_ext_buf_converted(0), _M_ext_buf_end(0),
+ _M_state(_STLP_DEFAULT_CONSTRUCTED(_State_type)),
+ _M_end_state(_STLP_DEFAULT_CONSTRUCTED(_State_type)),
+ _M_mmap_base(0), _M_mmap_len(0),
+ _M_saved_eback(0), _M_saved_gptr(0), _M_saved_egptr(0),
+ _M_codecvt(0),
+ _M_width(1), _M_max_width(1)
+{
+ this->_M_setup_codecvt(locale(), false);
+}
+
+template <class _CharT, class _Traits>
+basic_filebuf<_CharT, _Traits>::~basic_filebuf() {
+ this->close();
+ _M_deallocate_buffers();
+}
+
+
+template <class _CharT, class _Traits>
+_STLP_TYPENAME_ON_RETURN_TYPE basic_filebuf<_CharT, _Traits>::int_type
+basic_filebuf<_CharT, _Traits>::underflow() {
+ return _Underflow<_CharT, _Traits>::_M_doit(this);
+}
+
+template <class _CharT, class _Traits>
+basic_filebuf<_CharT, _Traits>*
+basic_filebuf<_CharT, _Traits>::close() {
+ bool __ok = this->is_open();
+
+ if (_M_in_output_mode) {
+ __ok = __ok && !_Traits::eq_int_type(this->overflow(traits_type::eof()),
+ traits_type::eof());
+ __ok == __ok && this->_M_unshift();
+ }
+ else if (_M_in_input_mode)
+ this->_M_exit_input_mode();
+
+ // Note order of arguments. We close the file even if __ok is false.
+ __ok = _M_base._M_close() && __ok;
+
+ // Restore the initial state, except that we don't deallocate the buffer
+ // or mess with the cached codecvt information.
+ _M_state = _M_end_state = _State_type();
+ _M_ext_buf_converted = _M_ext_buf_end = 0;
+
+ _M_mmap_base = 0;
+ _M_mmap_len = 0;
+
+ this->setg(0, 0, 0);
+ this->setp(0, 0);
+
+ _M_saved_eback = _M_saved_gptr = _M_saved_egptr = 0;
+
+ _M_in_input_mode = _M_in_output_mode = _M_in_error_mode = _M_in_putback_mode
+ = false;
+
+ return __ok ? this : 0;
+}
+
+// This member function is called whenever we exit input mode.
+// It unmaps the memory-mapped file, if any, and sets
+// _M_in_input_mode to false.
+template <class _CharT, class _Traits>
+void basic_filebuf<_CharT, _Traits>::_M_exit_input_mode() {
+ if (_M_mmap_base != 0) {
+ _M_base._M_unmap(_M_mmap_base, _M_mmap_len);
+ _M_mmap_base = 0;
+ _M_mmap_len = 0;
+ }
+ _M_in_input_mode = false;
+}
+
+
+//----------------------------------------------------------------------
+// basic_filebuf<> overridden protected virtual member functions
+
+template <class _CharT, class _Traits>
+streamsize basic_filebuf<_CharT, _Traits>::showmanyc() {
+ // Is there any possibility that reads can succeed?
+ if (!this->is_open() || _M_in_output_mode || _M_in_error_mode)
+ return -1;
+ else if (_M_in_putback_mode)
+ return this->egptr() - this->gptr();
+ else if (_M_constant_width) {
+ streamoff __pos = _M_base._M_seek(0, ios_base::cur);
+ streamoff __size = _M_base._M_file_size();
+ return __pos >= 0 && __size > __pos ? __size - __pos : 0;
+ }
+ else
+ return 0;
+}
+
+
+// Make a putback position available, if necessary, by switching to a
+// special internal buffer used only for putback. The buffer is
+// [_M_pback_buf, _M_pback_buf + _S_pback_buf_size), but the base
+// class only sees a piece of it at a time. (We want to make sure
+// that we don't try to read a character that hasn't been initialized.)
+// The end of the putback buffer is always _M_pback_buf + _S_pback_buf_size,
+// but the beginning is usually not _M_pback_buf.
+template <class _CharT, class _Traits>
+__BF_int_type__
+basic_filebuf<_CharT, _Traits>::pbackfail(int_type __c) {
+ const int_type __eof = traits_type::eof();
+
+ // If we aren't already in input mode, pushback is impossible.
+ if (!_M_in_input_mode)
+ return __eof;
+
+ // We can use the ordinary get buffer if there's enough space, and
+ // if it's a buffer that we're allowed to write to.
+ if (this->gptr() != this->eback() &&
+ (traits_type::eq_int_type(__c, __eof) ||
+ traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1]) ||
+ !_M_mmap_base)) {
+ this->gbump(-1);
+ if (traits_type::eq_int_type(__c, __eof) ||
+ traits_type::eq(traits_type::to_char_type(__c), *this->gptr()))
+ return traits_type::to_int_type(*this->gptr());
+ }
+ else if (!traits_type::eq_int_type(__c, __eof)) {
+ // Are we in the putback buffer already?
+ _CharT* __pback_end = _M_pback_buf + __STATIC_CAST(int,_S_pback_buf_size);
+ if (_M_in_putback_mode) {
+ // Do we have more room in the putback buffer?
+ if (this->eback() != _M_pback_buf)
+ this->setg(this->egptr() - 1, this->egptr() - 1, __pback_end);
+ else
+ return __eof; // No more room in the buffer, so fail.
+ }
+ else { // We're not yet in the putback buffer.
+ _M_saved_eback = this->eback();
+ _M_saved_gptr = this->gptr();
+ _M_saved_egptr = this->egptr();
+ this->setg(__pback_end - 1, __pback_end - 1, __pback_end);
+ _M_in_putback_mode = true;
+ }
+ }
+ else
+ return __eof;
+
+ // We have made a putback position available. Assign to it, and return.
+ *this->gptr() = traits_type::to_char_type(__c);
+ return __c;
+}
+
+// This member function flushes the put area, and also outputs the
+// character __c (unless __c is eof). Invariant: we always leave room
+// in the internal buffer for one character more than the base class knows
+// about. We see the internal buffer as [_M_int_buf, _M_int_buf_EOS), but
+// the base class only sees [_M_int_buf, _M_int_buf_EOS - 1).
+template <class _CharT, class _Traits>
+__BF_int_type__
+basic_filebuf<_CharT, _Traits>::overflow(int_type __c) {
+ // Switch to output mode, if necessary.
+ if (!_M_in_output_mode)
+ if (!_M_switch_to_output_mode())
+ return traits_type::eof();
+
+ _CharT* __ibegin = this->_M_int_buf;
+ _CharT* __iend = this->pptr();
+ this->setp(_M_int_buf, _M_int_buf_EOS - 1);
+
+ // Put __c at the end of the internal buffer.
+ if (!traits_type::eq_int_type(__c, traits_type::eof()))
+ *__iend++ = _Traits::to_char_type(__c);
+
+ // For variable-width encodings, output may take more than one pass.
+ while (__ibegin != __iend) {
+ const _CharT* __inext = __ibegin;
+ char* __enext = _M_ext_buf;
+ typename _Codecvt::result __status
+ = _M_codecvt->out(_M_state, __ibegin, __iend, __inext,
+ _M_ext_buf, _M_ext_buf_EOS, __enext);
+ if (__status == _Codecvt::noconv) {
+ return _Noconv_output<_Traits>::_M_doit(this, __ibegin, __iend)
+ ? traits_type::not_eof(__c)
+ : _M_output_error();
+ }
+
+ // For a constant-width encoding we know that the external buffer
+ // is large enough, so failure to consume the entire internal buffer
+ // or to produce the correct number of external characters, is an error.
+ // For a variable-width encoding, however, we require only that we
+ // consume at least one internal character
+ else if (__status != _Codecvt::error &&
+ (((__inext == __iend) &&
+ (__enext - _M_ext_buf == _M_width * (__iend - __ibegin))) ||
+ (!_M_constant_width && __inext != __ibegin))) {
+ // We successfully converted part or all of the internal buffer.
+ ptrdiff_t __n = __enext - _M_ext_buf;
+ if (_M_write(_M_ext_buf, __n))
+ __ibegin += __inext - __ibegin;
+ else
+ return _M_output_error();
+ }
+ else
+ return _M_output_error();
+ }
+
+ return traits_type::not_eof(__c);
+}
+
+// This member function must be called before any I/O has been
+// performed on the stream, otherwise it has no effect.
+//
+// __buf == 0 && __n == 0 means to make this stream unbuffered.
+// __buf != 0 && __n > 0 means to use __buf as the stream's internal
+// buffer, rather than the buffer that would otherwise be allocated
+// automatically. __buf must be a pointer to an array of _CharT whose
+// size is at least __n.
+template <class _CharT, class _Traits>
+basic_streambuf<_CharT, _Traits>*
+basic_filebuf<_CharT, _Traits>::setbuf(_CharT* __buf, streamsize __n) {
+ if (!_M_in_input_mode &&! _M_in_output_mode && !_M_in_error_mode &&
+ _M_int_buf == 0) {
+ if (__buf == 0 && __n == 0)
+ _M_allocate_buffers(0, 1);
+ else if (__buf != 0 && __n > 0)
+ _M_allocate_buffers(__buf, __n);
+ }
+ return this;
+}
+
+#if defined (_STLP_ASSERTIONS)
+// helper class.
+template <class _CharT>
+struct _Filebuf_Tmp_Buf {
+ _CharT* _M_ptr;
+ _Filebuf_Tmp_Buf(ptrdiff_t __n) : _M_ptr(0) { _M_ptr = new _CharT[__n]; }
+ ~_Filebuf_Tmp_Buf() { delete[] _M_ptr; }
+};
+#endif
+
+template <class _CharT, class _Traits>
+__BF_pos_type__
+basic_filebuf<_CharT, _Traits>::seekoff(off_type __off,
+ ios_base::seekdir __whence,
+ ios_base::openmode /* dummy */) {
+ if (!this->is_open())
+ return pos_type(-1);
+
+ if (!_M_constant_width && __off != 0)
+ return pos_type(-1);
+
+ if (!_M_seek_init(__off != 0 || __whence != ios_base::cur))
+ return pos_type(-1);
+
+ // Seek to beginning or end, regardless of whether we're in input mode.
+ if (__whence == ios_base::beg || __whence == ios_base::end)
+ return _M_seek_return(_M_base._M_seek(_M_width * __off, __whence),
+ _State_type());
+
+ // Seek relative to current position. Complicated if we're in input mode.
+ _STLP_ASSERT(__whence == ios_base::cur)
+ if (!_M_in_input_mode)
+ return _M_seek_return(_M_base._M_seek(_M_width * __off, __whence),
+ _State_type());
+
+ if (_M_mmap_base != 0) {
+ // __off is relative to gptr(). We need to do a bit of arithmetic
+ // to get an offset relative to the external file pointer.
+ streamoff __adjust = _M_mmap_len - (this->gptr() - (_CharT*) _M_mmap_base);
+
+ // if __off == 0, we do not need to exit input mode and to shift file pointer
+ return __off == 0 ? pos_type(_M_base._M_seek(0, ios_base::cur) - __adjust)
+ : _M_seek_return(_M_base._M_seek(__off - __adjust, ios_base::cur), _State_type());
+ }
+
+ if (_M_constant_width) { // Get or set the position.
+ streamoff __iadj = _M_width * (this->gptr() - this->eback());
+
+ // Compensate for offset relative to gptr versus offset relative
+ // to external pointer. For a text-oriented stream, where the
+ // compensation is more than just pointer arithmetic, we may get
+ // but not set the current position.
+
+ if (__iadj <= _M_ext_buf_end - _M_ext_buf) {
+ streamoff __eadj = _M_base._M_get_offset(_M_ext_buf + __STATIC_CAST(ptrdiff_t, __iadj), _M_ext_buf_end);
+
+ return __off == 0 ? pos_type(_M_base._M_seek(0, ios_base::cur) - __eadj)
+ : _M_seek_return(_M_base._M_seek(__off - __eadj, ios_base::cur), _State_type());
+ }
+ }
+ else { // Get the position. Encoding is var width.
+ // Get position in internal buffer.
+ ptrdiff_t __ipos = this->gptr() - this->eback();
+
+ // Get corresponding position in external buffer.
+ _State_type __state = _M_state;
+ int __epos = _M_codecvt->length(__state, _M_ext_buf, _M_ext_buf_converted,
+ __ipos);
+#if defined (_STLP_ASSERTIONS)
+ // Sanity check (expensive): make sure __epos is the right answer.
+ _STLP_ASSERT(__epos >= 0)
+ _State_type __tmp_state = _M_state;
+ _Filebuf_Tmp_Buf<_CharT> __buf(__ipos);
+ _CharT* __ibegin = __buf._M_ptr;
+ _CharT* __inext = __ibegin;
+ const char* __dummy;
+ typename _Codecvt::result __status
+ = _M_codecvt->in(__tmp_state,
+ _M_ext_buf, _M_ext_buf + __epos, __dummy,
+ __ibegin, __ibegin + __ipos, __inext);
+ // The result code is necessarily ok because:
+ // - noconv: impossible for a variable encoding
+ // - error: length method is supposed to count until it reach max value or find an error so we cannot have
+ // an error again when decoding an external buffer up to length return value.
+ // - partial: idem error, it is also a reason for length to stop counting.
+ _STLP_ASSERT(__status == _Codecvt::ok)
+ _STLP_ASSERT(__inext == __ibegin + __ipos)
+ _STLP_ASSERT(equal(this->eback(), this->gptr(), __ibegin, _STLP_PRIV _Eq_traits<traits_type>()))
+#endif
+ // Get the current position (at the end of the external buffer),
+ // then adjust it. Again, it might be a text-oriented stream.
+ streamoff __cur = _M_base._M_seek(0, ios_base::cur);
+ streamoff __adj = _M_base._M_get_offset(_M_ext_buf, _M_ext_buf + __epos) -
+ _M_base._M_get_offset(_M_ext_buf, _M_ext_buf_end);
+ if (__cur != -1 && __cur + __adj >= 0)
+ return __off == 0 ? pos_type(__cur + __adj)
+ : _M_seek_return(__cur + __adj, __state);
+ }
+
+ return pos_type(-1);
+}
+
+
+template <class _CharT, class _Traits>
+__BF_pos_type__
+basic_filebuf<_CharT, _Traits>::seekpos(pos_type __pos,
+ ios_base::openmode /* dummy */) {
+ if (this->is_open()) {
+ if (!_M_seek_init(true))
+ return pos_type(-1);
+
+ streamoff __off = off_type(__pos);
+ if (__off != -1 && _M_base._M_seek(__off, ios_base::beg) != -1) {
+ _M_state = __pos.state();
+ return _M_seek_return(__off, __pos.state());
+ }
+ }
+
+ return pos_type(-1);
+}
+
+
+template <class _CharT, class _Traits>
+int basic_filebuf<_CharT, _Traits>::sync() {
+ if (_M_in_output_mode)
+ return traits_type::eq_int_type(this->overflow(traits_type::eof()),
+ traits_type::eof()) ? -1 : 0;
+ return 0;
+}
+
+
+// Change the filebuf's locale. This member function has no effect
+// unless it is called before any I/O is performed on the stream.
+template <class _CharT, class _Traits>
+void basic_filebuf<_CharT, _Traits>::imbue(const locale& __loc) {
+ if (!_M_in_input_mode && !_M_in_output_mode && !_M_in_error_mode) {
+ this->_M_setup_codecvt(__loc);
+ }
+}
+
+//----------------------------------------------------------------------
+// basic_filebuf<> helper functions.
+
+//----------------------------------------
+// Helper functions for switching between modes.
+
+// This member function is called if we're performing the first I/O
+// operation on a filebuf, or if we're performing an input operation
+// immediately after a seek.
+template <class _CharT, class _Traits>
+bool basic_filebuf<_CharT, _Traits>::_M_switch_to_input_mode() {
+ if (this->is_open() && (((int)_M_base.__o_mode() & (int)ios_base::in) !=0)
+ && (_M_in_output_mode == 0) && (_M_in_error_mode == 0)) {
+ if (!_M_int_buf && !_M_allocate_buffers())
+ return false;
+
+ _M_ext_buf_converted = _M_ext_buf;
+ _M_ext_buf_end = _M_ext_buf;
+
+ _M_end_state = _M_state;
+
+ _M_in_input_mode = true;
+ return true;
+ }
+
+ return false;
+}
+
+
+// This member function is called if we're performing the first I/O
+// operation on a filebuf, or if we're performing an output operation
+// immediately after a seek.
+template <class _CharT, class _Traits>
+bool basic_filebuf<_CharT, _Traits>::_M_switch_to_output_mode() {
+ if (this->is_open() && (_M_base.__o_mode() & (int)ios_base::out) &&
+ _M_in_input_mode == 0 && _M_in_error_mode == 0) {
+
+ if (!_M_int_buf && !_M_allocate_buffers())
+ return false;
+
+ // In append mode, every write does an implicit seek to the end
+ // of the file. Whenever leaving output mode, the end of file
+ // get put in the initial shift state.
+ if (_M_base.__o_mode() & ios_base::app)
+ _M_state = _State_type();
+
+ this->setp(_M_int_buf, _M_int_buf_EOS - 1);
+ _M_in_output_mode = true;
+ return true;
+ }
+
+ return false;
+}
+
+
+//----------------------------------------
+// Helper functions for input
+
+// This member function is called if there is an error during input.
+// It puts the filebuf in error mode, clear the get area buffer, and
+// returns eof.
+// returns eof. Error mode is sticky; it is cleared only by close or
+// seek.
+
+template <class _CharT, class _Traits>
+__BF_int_type__
+basic_filebuf<_CharT, _Traits>::_M_input_error() {
+ this->_M_exit_input_mode();
+ _M_in_output_mode = false;
+ _M_in_error_mode = true;
+ this->setg(0, 0, 0);
+ return traits_type::eof();
+}
+
+template <class _CharT, class _Traits>
+__BF_int_type__
+basic_filebuf<_CharT, _Traits>::_M_underflow_aux() {
+ // We have the state and file position from the end of the internal
+ // buffer. This round, they become the beginning of the internal buffer.
+ _M_state = _M_end_state;
+
+ // Fill the external buffer. Start with any leftover characters that
+ // didn't get converted last time.
+ if (_M_ext_buf_end > _M_ext_buf_converted)
+
+ _M_ext_buf_end = _STLP_STD::copy(_M_ext_buf_converted, _M_ext_buf_end, _M_ext_buf);
+ // boris : copy_backward did not work
+ //_M_ext_buf_end = copy_backward(_M_ext_buf_converted, _M_ext_buf_end,
+ //_M_ext_buf+ (_M_ext_buf_end - _M_ext_buf_converted));
+ else
+ _M_ext_buf_end = _M_ext_buf;
+
+ // Now fill the external buffer with characters from the file. This is
+ // a loop because occasionally we don't get enough external characters
+ // to make progress.
+ for (;;) {
+ ptrdiff_t __n = _M_base._M_read(_M_ext_buf_end, _M_ext_buf_EOS - _M_ext_buf_end);
+ if (__n < 0) {
+ // Read failed, maybe we should set err bit on associated stream...
+ this->setg(0, 0, 0);
+ return traits_type::eof();
+ }
+
+ _M_ext_buf_end += __n;
+
+ // If external buffer is empty there is nothing to do.
+ if (_M_ext_buf == _M_ext_buf_end) {
+ this->setg(0, 0, 0);
+ return traits_type::eof();
+ }
+
+ // Convert the external buffer to internal characters.
+ const char* __enext;
+ _CharT* __inext;
+
+ typename _Codecvt::result __status
+ = _M_codecvt->in(_M_end_state,
+ _M_ext_buf, _M_ext_buf_end, __enext,
+ _M_int_buf, _M_int_buf_EOS, __inext);
+
+ /* Error conditions:
+ * (1) Return value of error.
+ * (2) Producing internal characters without consuming external characters.
+ * (3) In fixed-width encodings, producing an internal sequence whose length
+ * is inconsistent with that of the internal sequence.
+ * (4) Failure to produce any characters if we have enough characters in
+ * the external buffer, where "enough" means the largest possible width
+ * of a single character. */
+ if (__status == _Codecvt::noconv)
+ return _Noconv_input<_Traits>::_M_doit(this);
+ else if (__status == _Codecvt::error ||
+ (__inext != _M_int_buf && __enext == _M_ext_buf) ||
+ (_M_constant_width && (__inext - _M_int_buf) * _M_width != (__enext - _M_ext_buf)) ||
+ (__inext == _M_int_buf && __enext - _M_ext_buf >= _M_max_width))
+ return _M_input_error();
+ else if (__inext != _M_int_buf) {
+ _M_ext_buf_converted = _M_ext_buf + (__enext - _M_ext_buf);
+ this->setg(_M_int_buf, _M_int_buf, __inext);
+ return traits_type::to_int_type(*_M_int_buf);
+ }
+ /* We need to go around the loop again to get more external characters.
+ * But if the previous read failed then don't try again for now.
+ * Don't enter error mode for a failed read. Error mode is sticky,
+ * and we might succeed if we try again. */
+ if (__n <= 0) {
+ this->setg(0, 0, 0);
+ return traits_type::eof();
+ }
+ }
+}
+
+//----------------------------------------
+// Helper functions for output
+
+// This member function is called if there is an error during output.
+// It puts the filebuf in error mode, clear the put area buffer, and
+// returns eof. Error mode is sticky; it is cleared only by close or
+// seek.
+template <class _CharT, class _Traits>
+__BF_int_type__
+basic_filebuf<_CharT, _Traits>::_M_output_error() {
+ _M_in_output_mode = false;
+ _M_in_input_mode = false;
+ _M_in_error_mode = true;
+ this->setp(0, 0);
+ return traits_type::eof();
+}
+
+
+// Write whatever sequence of characters is necessary to get back to
+// the initial shift state. This function overwrites the external
+// buffer, changes the external file position, and changes the state.
+// Precondition: the internal buffer is empty.
+template <class _CharT, class _Traits>
+bool basic_filebuf<_CharT, _Traits>::_M_unshift() {
+ if (_M_in_output_mode && !_M_constant_width) {
+ typename _Codecvt::result __status;
+ do {
+ char* __enext = _M_ext_buf;
+ __status = _M_codecvt->unshift(_M_state,
+ _M_ext_buf, _M_ext_buf_EOS, __enext);
+ if (__status == _Codecvt::noconv ||
+ (__enext == _M_ext_buf && __status == _Codecvt::ok))
+ return true;
+ else if (__status == _Codecvt::error)
+ return false;
+ else if (!_M_write(_M_ext_buf, __enext - _M_ext_buf))
+ return false;
+ } while (__status == _Codecvt::partial);
+ }
+
+ return true;
+}
+
+
+//----------------------------------------
+// Helper functions for buffer allocation and deallocation
+
+// This member function is called when we're initializing a filebuf's
+// internal and external buffers. The argument is the size of the
+// internal buffer; the external buffer is sized using the character
+// width in the current encoding. Preconditions: the buffers are currently
+// null. __n >= 1. __buf is either a null pointer or a pointer to an
+// array show size is at least __n.
+
+// We need __n >= 1 for two different reasons. For input, the base
+// class always needs a buffer because of the semantics of underflow().
+// For output, we want to have an internal buffer that's larger by one
+// element than the buffer that the base class knows about. (See
+// basic_filebuf<>::overflow() for the reason.)
+template <class _CharT, class _Traits>
+bool basic_filebuf<_CharT, _Traits>::_M_allocate_buffers(_CharT* __buf, streamsize __n) {
+ //The major hypothesis in the following implementation is that size_t is unsigned.
+ //We also need streamsize byte representation to be larger or equal to the int
+ //representation to correctly store the encoding information.
+ _STLP_STATIC_ASSERT(!numeric_limits<size_t>::is_signed &&
+ sizeof(streamsize) >= sizeof(int))
+
+ if (__buf == 0) {
+ streamsize __bufsize = __n * sizeof(_CharT);
+ //We first check that the streamsize representation can't overflow a size_t one.
+ //If it can, we check that __bufsize is not higher than the size_t max value.
+ if ((sizeof(streamsize) > sizeof(size_t)) &&
+ (__bufsize > __STATIC_CAST(streamsize, (numeric_limits<size_t>::max)())))
+ return false;
+ _M_int_buf = __STATIC_CAST(_CharT*, malloc(__STATIC_CAST(size_t, __bufsize)));
+ if (!_M_int_buf)
+ return false;
+ _M_int_buf_dynamic = true;
+ }
+ else {
+ _M_int_buf = __buf;
+ _M_int_buf_dynamic = false;
+ }
+
+ streamsize __ebufsiz = (max)(__n * __STATIC_CAST(streamsize, _M_width),
+ __STATIC_CAST(streamsize, _M_codecvt->max_length()));
+
+ _M_ext_buf = 0;
+ if ((sizeof(streamsize) < sizeof(size_t)) ||
+ ((sizeof(streamsize) == sizeof(size_t)) && numeric_limits<streamsize>::is_signed) ||
+ (__ebufsiz <= __STATIC_CAST(streamsize, (numeric_limits<size_t>::max)()))) {
+ _M_ext_buf = __STATIC_CAST(char*, malloc(__STATIC_CAST(size_t, __ebufsiz)));
+ }
+
+ if (!_M_ext_buf) {
+ _M_deallocate_buffers();
+ return false;
+ }
+
+ _M_int_buf_EOS = _M_int_buf + __STATIC_CAST(ptrdiff_t, __n);
+ _M_ext_buf_EOS = _M_ext_buf + __STATIC_CAST(ptrdiff_t, __ebufsiz);
+ return true;
+}
+
+// Abbreviation for the most common case.
+template <class _CharT, class _Traits>
+bool basic_filebuf<_CharT, _Traits>::_M_allocate_buffers() {
+ // Choose a buffer that's at least 4096 characters long and that's a
+ // multiple of the page size.
+ streamsize __default_bufsiz =
+ ((_M_base.__page_size() + 4095UL) / _M_base.__page_size()) * _M_base.__page_size();
+ return _M_allocate_buffers(0, __default_bufsiz);
+}
+
+template <class _CharT, class _Traits>
+void basic_filebuf<_CharT, _Traits>::_M_deallocate_buffers() {
+ if (_M_int_buf_dynamic)
+ free(_M_int_buf);
+ free(_M_ext_buf);
+ _M_int_buf = 0;
+ _M_int_buf_EOS = 0;
+ _M_ext_buf = 0;
+ _M_ext_buf_EOS = 0;
+}
+
+
+//----------------------------------------
+// Helper functiosn for seek and imbue
+
+template <class _CharT, class _Traits>
+bool basic_filebuf<_CharT, _Traits>::_M_seek_init(bool __do_unshift) {
+ // If we're in error mode, leave it.
+ _M_in_error_mode = false;
+
+ // Flush the output buffer if we're in output mode, and (conditionally)
+ // emit an unshift sequence.
+ if (_M_in_output_mode) {
+ bool __ok = !traits_type::eq_int_type(this->overflow(traits_type::eof()),
+ traits_type::eof());
+ if (__do_unshift)
+ __ok = __ok && this->_M_unshift();
+ if (!__ok) {
+ _M_in_output_mode = false;
+ _M_in_error_mode = true;
+ this->setp(0, 0);
+ return false;
+ }
+ }
+
+ // Discard putback characters, if any.
+ if (_M_in_input_mode && _M_in_putback_mode)
+ _M_exit_putback_mode();
+
+ return true;
+}
+
+
+/* Change the filebuf's locale. This member function has no effect
+ * unless it is called before any I/O is performed on the stream.
+ * This function is called on construction and on an imbue call. In the
+ * case of the construction the codecvt facet might be a custom one if
+ * the basic_filebuf user has instanciate it with a custom char_traits.
+ * The user will have to call imbue before any I/O operation.
+ */
+template <class _CharT, class _Traits>
+void basic_filebuf<_CharT, _Traits>::_M_setup_codecvt(const locale& __loc, bool __on_imbue) {
+ if (has_facet<_Codecvt>(__loc)) {
+ _M_codecvt = &use_facet<_Codecvt>(__loc) ;
+ int __encoding = _M_codecvt->encoding();
+
+ _M_width = (max)(__encoding, 1);
+ _M_max_width = _M_codecvt->max_length();
+ _M_constant_width = __encoding > 0;
+ _M_always_noconv = _M_codecvt->always_noconv();
+ }
+ else {
+ _M_codecvt = 0;
+ _M_width = _M_max_width = 1;
+ _M_constant_width = _M_always_noconv = false;
+ if (__on_imbue) {
+ //This call will generate an exception reporting the problem.
+ use_facet<_Codecvt>(__loc);
+ }
+ }
+}
+
+_STLP_END_NAMESPACE
+
+# undef __BF_int_type__
+# undef __BF_pos_type__
+# undef __BF_off_type__
+
+#endif /* _STLP_FSTREAM_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_fstream.h b/sources/android/stlport/stlport/stl/_fstream.h
new file mode 100644
index 0000000..1945e41
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_fstream.h
@@ -0,0 +1,714 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+// This header defines classes basic_filebuf, basic_ifstream,
+// basic_ofstream, and basic_fstream. These classes represent
+// streambufs and streams whose sources or destinations are files.
+
+#ifndef _STLP_INTERNAL_FSTREAM_H
+#define _STLP_INTERNAL_FSTREAM_H
+
+#if defined(__sgi) && !defined(__GNUC__) && !defined(_STANDARD_C_PLUS_PLUS)
+# error This header file requires the -LANG:std option
+#endif
+
+#ifndef _STLP_INTERNAL_STREAMBUF
+# include <stl/_streambuf.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ISTREAM
+# include <stl/_istream.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CODECVT_H
+# include <stl/_codecvt.h>
+#endif
+
+#if defined (_STLP_USE_WIN32_IO)
+typedef void* _STLP_fd;
+#elif defined (_STLP_USE_UNIX_EMULATION_IO) || defined (_STLP_USE_STDIO_IO) || defined (_STLP_USE_UNIX_IO)
+typedef int _STLP_fd;
+#else
+# error "Configure i/o !"
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//----------------------------------------------------------------------
+// Class _Filebuf_base, a private base class to factor out the system-
+// dependent code from basic_filebuf<>.
+
+class _STLP_CLASS_DECLSPEC _Filebuf_base {
+public: // Opening and closing files.
+ _Filebuf_base();
+
+ bool _M_open(const char*, ios_base::openmode, long __protection);
+ bool _M_open(const char*, ios_base::openmode);
+ bool _M_open(int __id, ios_base::openmode = ios_base::__default_mode);
+#if defined (_STLP_USE_WIN32_IO)
+ bool _M_open(_STLP_fd __id, ios_base::openmode = ios_base::__default_mode);
+#endif /* _STLP_USE_WIN32_IO */
+ bool _M_close();
+
+public: // Low-level I/O, like Unix read/write
+ ptrdiff_t _M_read(char* __buf, ptrdiff_t __n);
+ streamoff _M_seek(streamoff __offset, ios_base::seekdir __dir);
+ streamoff _M_file_size();
+ bool _M_write(char* __buf, ptrdiff_t __n);
+
+public: // Memory-mapped I/O.
+ void* _M_mmap(streamoff __offset, streamoff __len);
+ void _M_unmap(void* __mmap_base, streamoff __len);
+
+public:
+ // Returns a value n such that, if pos is the file pointer at the
+ // beginning of the range [first, last), pos + n is the file pointer at
+ // the end. On many operating systems n == __last - __first.
+ // In Unix, writing n characters always bumps the file position by n.
+ // In Windows text mode, however, it bumps the file position by n + m,
+ // where m is the number of newlines in the range. That's because an
+ // internal \n corresponds to an external two-character sequence.
+ streamoff _M_get_offset(char* __first, char* __last) {
+#if defined (_STLP_UNIX) || defined (_STLP_MAC)
+ return __last - __first;
+#else // defined (_STLP_WIN32)
+ return ( (_M_openmode & ios_base::binary) != 0 )
+ ? (__last - __first)
+ : count(__first, __last, '\n') + (__last - __first);
+#endif
+ }
+
+ // Returns true if we're in binary mode or if we're using an OS or file
+ // system where there is no distinction between text and binary mode.
+ bool _M_in_binary_mode() const {
+#if defined (_STLP_UNIX) || defined (_STLP_MAC) || defined(__BEOS__) || defined (__amigaos__)
+ return true;
+#elif defined (_STLP_WIN32) || defined (_STLP_VM)
+ return (_M_openmode & ios_base::binary) != 0;
+#else
+# error "Port!"
+#endif
+ }
+
+ static void _S_initialize();
+
+protected: // Static data members.
+ static size_t _M_page_size;
+
+protected: // Data members.
+ _STLP_fd _M_file_id;
+#if defined (_STLP_USE_STDIO_IO)
+ // for stdio, the whole FILE* is being kept here
+ FILE* _M_file;
+#endif
+ ios_base::openmode _M_openmode ;
+ unsigned char _M_is_open ;
+ unsigned char _M_should_close ;
+ unsigned char _M_regular_file ;
+
+#if defined (_STLP_USE_WIN32_IO)
+ _STLP_fd _M_view_id;
+#endif
+
+public :
+ static size_t _STLP_CALL __page_size() { return _M_page_size; }
+ int __o_mode() const { return (int)_M_openmode; }
+ bool __is_open() const { return (_M_is_open !=0 ); }
+ bool __should_close() const { return (_M_should_close != 0); }
+ bool __regular_file() const { return (_M_regular_file != 0); }
+ _STLP_fd __get_fd() const { return _M_file_id; }
+};
+
+//----------------------------------------------------------------------
+// Class basic_filebuf<>.
+
+// Forward declaration of two helper classes.
+template <class _Traits> class _Noconv_input;
+template <class _Traits> class _Noconv_output;
+
+// There is a specialized version of underflow, for basic_filebuf<char>,
+// in fstream.cpp.
+template <class _CharT, class _Traits>
+class _Underflow;
+
+template <class _CharT, class _Traits>
+class basic_filebuf : public basic_streambuf<_CharT, _Traits> {
+public: // Types.
+ typedef _CharT char_type;
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+ typedef _Traits traits_type;
+
+ typedef typename _Traits::state_type _State_type;
+ typedef basic_streambuf<_CharT, _Traits> _Base;
+ typedef basic_filebuf<_CharT, _Traits> _Self;
+
+public: // Constructors, destructor.
+ basic_filebuf();
+ ~basic_filebuf();
+
+public: // Opening and closing files.
+ bool is_open() const { return _M_base.__is_open(); }
+
+ _Self* open(const char* __s, ios_base::openmode __m) {
+ return _M_base._M_open(__s, __m) ? this : 0;
+ }
+
+#if !defined (_STLP_NO_EXTENSIONS)
+ // These two version of open() and file descriptor getter are extensions.
+ _Self* open(const char* __s, ios_base::openmode __m,
+ long __protection) {
+ return _M_base._M_open(__s, __m, __protection) ? this : 0;
+ }
+
+ _STLP_fd fd() const { return _M_base.__get_fd(); }
+
+ _Self* open(int __id, ios_base::openmode _Init_mode = ios_base::__default_mode) {
+ return this->_M_open(__id, _Init_mode);
+ }
+
+# if defined (_STLP_USE_WIN32_IO)
+ _Self* open(_STLP_fd __id, ios_base::openmode _Init_mode = ios_base::__default_mode) {
+ return _M_base._M_open(__id, _Init_mode) ? this : 0;
+ }
+# endif /* _STLP_USE_WIN32_IO */
+
+#endif
+
+ _Self* _M_open(int __id, ios_base::openmode _Init_mode = ios_base::__default_mode) {
+ return _M_base._M_open(__id, _Init_mode) ? this : 0;
+ }
+
+ _Self* close();
+
+protected: // Virtual functions from basic_streambuf.
+ virtual streamsize showmanyc();
+ virtual int_type underflow();
+
+ virtual int_type pbackfail(int_type = traits_type::eof());
+ virtual int_type overflow(int_type = traits_type::eof());
+
+ virtual basic_streambuf<_CharT, _Traits>* setbuf(char_type*, streamsize);
+ virtual pos_type seekoff(off_type, ios_base::seekdir,
+ ios_base::openmode = ios_base::in | ios_base::out);
+ virtual pos_type seekpos(pos_type,
+ ios_base::openmode = ios_base::in | ios_base::out);
+
+ virtual int sync();
+ virtual void imbue(const locale&);
+
+private: // Helper functions.
+
+ // Precondition: we are currently in putback input mode. Effect:
+ // switches back to ordinary input mode.
+ void _M_exit_putback_mode() {
+ this->setg(_M_saved_eback, _M_saved_gptr, _M_saved_egptr);
+ _M_in_putback_mode = false;
+ }
+ bool _M_switch_to_input_mode();
+ void _M_exit_input_mode();
+ bool _M_switch_to_output_mode();
+
+ int_type _M_input_error();
+ int_type _M_underflow_aux();
+ friend class _Underflow<_CharT, _Traits>;
+
+ int_type _M_output_error();
+ bool _M_unshift();
+
+ bool _M_allocate_buffers(_CharT* __buf, streamsize __n);
+ bool _M_allocate_buffers();
+ void _M_deallocate_buffers();
+
+ pos_type _M_seek_return(off_type __off, _State_type __state) {
+ if (__off != -1) {
+ if (_M_in_input_mode)
+ _M_exit_input_mode();
+ _M_in_input_mode = false;
+ _M_in_output_mode = false;
+ _M_in_putback_mode = false;
+ _M_in_error_mode = false;
+ this->setg(0, 0, 0);
+ this->setp(0, 0);
+ }
+
+ pos_type __result(__off);
+ __result.state(__state);
+ return __result;
+ }
+
+ bool _M_seek_init(bool __do_unshift);
+
+ void _M_setup_codecvt(const locale&, bool __on_imbue = true);
+
+private: // Data members used in all modes.
+
+ _Filebuf_base _M_base;
+
+private: // Locale-related information.
+
+ unsigned char _M_constant_width;
+ unsigned char _M_always_noconv;
+
+ // private: // Mode flags.
+ unsigned char _M_int_buf_dynamic; // True if internal buffer is heap allocated,
+ // false if it was supplied by the user.
+ unsigned char _M_in_input_mode;
+ unsigned char _M_in_output_mode;
+ unsigned char _M_in_error_mode;
+ unsigned char _M_in_putback_mode;
+
+ // Internal buffer: characters seen by the filebuf's clients.
+ _CharT* _M_int_buf;
+ _CharT* _M_int_buf_EOS;
+
+ // External buffer: characters corresponding to the external file.
+ char* _M_ext_buf;
+ char* _M_ext_buf_EOS;
+
+ // The range [_M_ext_buf, _M_ext_buf_converted) contains the external
+ // characters corresponding to the sequence in the internal buffer. The
+ // range [_M_ext_buf_converted, _M_ext_buf_end) contains characters that
+ // have been read into the external buffer but have not been converted
+ // to an internal sequence.
+ char* _M_ext_buf_converted;
+ char* _M_ext_buf_end;
+
+ // State corresponding to beginning of internal buffer.
+ _State_type _M_state;
+
+private: // Data members used only in input mode.
+
+ // Similar to _M_state except that it corresponds to
+ // the end of the internal buffer instead of the beginning.
+ _State_type _M_end_state;
+
+ // This is a null pointer unless we are in mmap input mode.
+ void* _M_mmap_base;
+ streamoff _M_mmap_len;
+
+private: // Data members used only in putback mode.
+ _CharT* _M_saved_eback;
+ _CharT* _M_saved_gptr;
+ _CharT* _M_saved_egptr;
+
+ typedef codecvt<_CharT, char, _State_type> _Codecvt;
+ const _Codecvt* _M_codecvt;
+
+ int _M_width; // Width of the encoding (if constant), else 1
+ int _M_max_width; // Largest possible width of single character.
+
+
+ enum { _S_pback_buf_size = 8 };
+ _CharT _M_pback_buf[_S_pback_buf_size];
+
+ // for _Noconv_output
+public:
+ bool _M_write(char* __buf, ptrdiff_t __n) {return _M_base._M_write(__buf, __n); }
+
+public:
+ int_type
+ _M_do_noconv_input() {
+ _M_ext_buf_converted = _M_ext_buf_end;
+ /* this-> */ _Base::setg((char_type*)_M_ext_buf, (char_type*)_M_ext_buf, (char_type*)_M_ext_buf_end);
+ return traits_type::to_int_type(*_M_ext_buf);
+ }
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS basic_filebuf<char, char_traits<char> >;
+# if ! defined (_STLP_NO_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS basic_filebuf<wchar_t, char_traits<wchar_t> >;
+# endif
+#endif /* _STLP_USE_TEMPLATE_EXPORT */
+
+//
+// This class had to be designed very carefully to work
+// with Visual C++.
+//
+template <class _Traits>
+class _Noconv_output {
+public:
+ typedef typename _Traits::char_type char_type;
+ static bool _STLP_CALL _M_doit(basic_filebuf<char_type, _Traits >*,
+ char_type*, char_type*)
+ { return false; }
+};
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC _Noconv_output< char_traits<char> > {
+public:
+ static bool _STLP_CALL
+ _M_doit(basic_filebuf<char, char_traits<char> >* __buf,
+ char* __first, char* __last) {
+ ptrdiff_t __n = __last - __first;
+ return (__buf->_M_write(__first, __n));
+ }
+};
+
+//----------------------------------------------------------------------
+// basic_filebuf<> helper functions.
+
+
+//----------------------------------------
+// Helper functions for switching between modes.
+
+//
+// This class had to be designed very carefully to work
+// with Visual C++.
+//
+template <class _Traits>
+class _Noconv_input {
+public:
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::char_type char_type;
+
+ static inline int_type _STLP_CALL
+ _M_doit(basic_filebuf<char_type, _Traits>*)
+ { return _Traits::eof(); }
+};
+
+_STLP_TEMPLATE_NULL
+class _Noconv_input<char_traits<char> > {
+public:
+ static inline int _STLP_CALL
+ _M_doit(basic_filebuf<char, char_traits<char> >* __buf) {
+ return __buf->_M_do_noconv_input();
+ }
+};
+
+// underflow() may be called for one of two reasons. (1) We've
+// been going through the special putback buffer, and we need to move back
+// to the regular internal buffer. (2) We've exhausted the internal buffer,
+// and we need to replentish it.
+template <class _CharT, class _Traits>
+class _Underflow {
+public:
+ typedef typename _Traits::int_type int_type;
+ typedef _Traits traits_type;
+
+ // There is a specialized version of underflow, for basic_filebuf<char>,
+ // in fstream.cpp.
+ static int_type _STLP_CALL _M_doit(basic_filebuf<_CharT, _Traits>* __this) {
+ if (!__this->_M_in_input_mode) {
+ if (!__this->_M_switch_to_input_mode())
+ return traits_type::eof();
+ }
+ else if (__this->_M_in_putback_mode) {
+ __this->_M_exit_putback_mode();
+ if (__this->gptr() != __this->egptr()) {
+ int_type __c = traits_type::to_int_type(*__this->gptr());
+ return __c;
+ }
+ }
+
+ return __this->_M_underflow_aux();
+ }
+};
+
+// Specialization of underflow: if the character type is char, maybe
+// we can use mmap instead of read.
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC _Underflow< char, char_traits<char> >
+{
+ public:
+ typedef char_traits<char>::int_type int_type;
+ typedef char_traits<char> traits_type;
+ static int_type _STLP_CALL _M_doit(basic_filebuf<char, traits_type >* __this);
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_NO_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS _Underflow<wchar_t, char_traits<wchar_t> >;
+#endif
+
+//----------------------------------------------------------------------
+// Class basic_ifstream<>
+
+template <class _CharT, class _Traits>
+class basic_ifstream : public basic_istream<_CharT, _Traits> {
+public: // Types
+ typedef _CharT char_type;
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+ typedef _Traits traits_type;
+
+ typedef basic_ios<_CharT, _Traits> _Basic_ios;
+ typedef basic_istream<_CharT, _Traits> _Base;
+ typedef basic_filebuf<_CharT, _Traits> _Buf;
+
+public: // Constructors, destructor.
+
+ basic_ifstream() :
+ basic_ios<_CharT, _Traits>(), basic_istream<_CharT, _Traits>(0), _M_buf() {
+ this->init(&_M_buf);
+ }
+
+ explicit basic_ifstream(const char* __s, ios_base::openmode __mod = ios_base::in) :
+ basic_ios<_CharT, _Traits>(), basic_istream<_CharT, _Traits>(0),
+ _M_buf() {
+ this->init(&_M_buf);
+ if (!_M_buf.open(__s, __mod | ios_base::in))
+ this->setstate(ios_base::failbit);
+ }
+
+#if !defined (_STLP_NO_EXTENSIONS)
+ explicit basic_ifstream(int __id, ios_base::openmode __mod = ios_base::in) :
+ basic_ios<_CharT, _Traits>(), basic_istream<_CharT, _Traits>(0), _M_buf() {
+ this->init(&_M_buf);
+ if (!_M_buf.open(__id, __mod | ios_base::in))
+ this->setstate(ios_base::failbit);
+ }
+ basic_ifstream(const char* __s, ios_base::openmode __m,
+ long __protection) :
+ basic_ios<_CharT, _Traits>(), basic_istream<_CharT, _Traits>(0), _M_buf() {
+ this->init(&_M_buf);
+ if (!_M_buf.open(__s, __m | ios_base::in, __protection))
+ this->setstate(ios_base::failbit);
+ }
+
+# if defined (_STLP_USE_WIN32_IO)
+ explicit basic_ifstream(_STLP_fd __id, ios_base::openmode __mod = ios_base::in) :
+ basic_ios<_CharT, _Traits>(), basic_istream<_CharT, _Traits>(0), _M_buf() {
+ this->init(&_M_buf);
+ if (!_M_buf.open(__id, __mod | ios_base::in))
+ this->setstate(ios_base::failbit);
+ }
+# endif /* _STLP_USE_WIN32_IO */
+#endif
+
+ ~basic_ifstream() {}
+
+public: // File and buffer operations.
+ basic_filebuf<_CharT, _Traits>* rdbuf() const
+ { return __CONST_CAST(_Buf*,&_M_buf); }
+
+ bool is_open() {
+ return this->rdbuf()->is_open();
+ }
+
+ void open(const char* __s, ios_base::openmode __mod = ios_base::in) {
+ if (!this->rdbuf()->open(__s, __mod | ios_base::in))
+ this->setstate(ios_base::failbit);
+ }
+
+ void close() {
+ if (!this->rdbuf()->close())
+ this->setstate(ios_base::failbit);
+ }
+
+private:
+ basic_filebuf<_CharT, _Traits> _M_buf;
+};
+
+
+//----------------------------------------------------------------------
+// Class basic_ofstream<>
+
+template <class _CharT, class _Traits>
+class basic_ofstream : public basic_ostream<_CharT, _Traits> {
+public: // Types
+ typedef _CharT char_type;
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+ typedef _Traits traits_type;
+
+ typedef basic_ios<_CharT, _Traits> _Basic_ios;
+ typedef basic_ostream<_CharT, _Traits> _Base;
+ typedef basic_filebuf<_CharT, _Traits> _Buf;
+
+public: // Constructors, destructor.
+ basic_ofstream() :
+ basic_ios<_CharT, _Traits>(),
+ basic_ostream<_CharT, _Traits>(0), _M_buf() {
+ this->init(&_M_buf);
+ }
+ explicit basic_ofstream(const char* __s, ios_base::openmode __mod = ios_base::out)
+ : basic_ios<_CharT, _Traits>(), basic_ostream<_CharT, _Traits>(0), _M_buf() {
+ this->init(&_M_buf);
+ if (!_M_buf.open(__s, __mod | ios_base::out))
+ this->setstate(ios_base::failbit);
+ }
+
+#if !defined (_STLP_NO_EXTENSIONS)
+ explicit basic_ofstream(int __id, ios_base::openmode __mod = ios_base::out)
+ : basic_ios<_CharT, _Traits>(), basic_ostream<_CharT, _Traits>(0),
+ _M_buf() {
+ this->init(&_M_buf);
+ if (!_M_buf.open(__id, __mod | ios_base::out))
+ this->setstate(ios_base::failbit);
+ }
+ basic_ofstream(const char* __s, ios_base::openmode __m, long __protection) :
+ basic_ios<_CharT, _Traits>(), basic_ostream<_CharT, _Traits>(0), _M_buf() {
+ this->init(&_M_buf);
+ if (!_M_buf.open(__s, __m | ios_base::out, __protection))
+ this->setstate(ios_base::failbit);
+ }
+# if defined (_STLP_USE_WIN32_IO)
+ explicit basic_ofstream(_STLP_fd __id, ios_base::openmode __mod = ios_base::out)
+ : basic_ios<_CharT, _Traits>(), basic_ostream<_CharT, _Traits>(0),
+ _M_buf() {
+ this->init(&_M_buf);
+ if (!_M_buf.open(__id, __mod | ios_base::out))
+ this->setstate(ios_base::failbit);
+ }
+# endif /* _STLP_USE_WIN32_IO */
+#endif
+
+ ~basic_ofstream() {}
+
+public: // File and buffer operations.
+ basic_filebuf<_CharT, _Traits>* rdbuf() const
+ { return __CONST_CAST(_Buf*,&_M_buf); }
+
+ bool is_open() {
+ return this->rdbuf()->is_open();
+ }
+
+ void open(const char* __s, ios_base::openmode __mod= ios_base::out) {
+ if (!this->rdbuf()->open(__s, __mod | ios_base::out))
+ this->setstate(ios_base::failbit);
+ }
+
+ void close() {
+ if (!this->rdbuf()->close())
+ this->setstate(ios_base::failbit);
+ }
+
+private:
+ basic_filebuf<_CharT, _Traits> _M_buf;
+};
+
+
+//----------------------------------------------------------------------
+// Class basic_fstream<>
+
+template <class _CharT, class _Traits>
+class basic_fstream : public basic_iostream<_CharT, _Traits> {
+public: // Types
+ typedef _CharT char_type;
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+ typedef _Traits traits_type;
+
+ typedef basic_ios<_CharT, _Traits> _Basic_ios;
+ typedef basic_iostream<_CharT, _Traits> _Base;
+ typedef basic_filebuf<_CharT, _Traits> _Buf;
+
+public: // Constructors, destructor.
+
+ basic_fstream()
+ : basic_ios<_CharT, _Traits>(), basic_iostream<_CharT, _Traits>(0), _M_buf() {
+ this->init(&_M_buf);
+ }
+
+ explicit basic_fstream(const char* __s,
+ ios_base::openmode __mod = ios_base::in | ios_base::out) :
+ basic_ios<_CharT, _Traits>(), basic_iostream<_CharT, _Traits>(0), _M_buf() {
+ this->init(&_M_buf);
+ if (!_M_buf.open(__s, __mod))
+ this->setstate(ios_base::failbit);
+ }
+
+#if !defined (_STLP_NO_EXTENSIONS)
+ explicit basic_fstream(int __id,
+ ios_base::openmode __mod = ios_base::in | ios_base::out) :
+ basic_ios<_CharT, _Traits>(), basic_iostream<_CharT, _Traits>(0), _M_buf() {
+ this->init(&_M_buf);
+ if (!_M_buf.open(__id, __mod))
+ this->setstate(ios_base::failbit);
+ }
+ basic_fstream(const char* __s, ios_base::openmode __m, long __protection) :
+ basic_ios<_CharT, _Traits>(), basic_iostream<_CharT, _Traits>(0), _M_buf() {
+ this->init(&_M_buf);
+ if (!_M_buf.open(__s, __m, __protection))
+ this->setstate(ios_base::failbit);
+ }
+# if defined (_STLP_USE_WIN32_IO)
+ explicit basic_fstream(_STLP_fd __id,
+ ios_base::openmode __mod = ios_base::in | ios_base::out) :
+ basic_ios<_CharT, _Traits>(), basic_iostream<_CharT, _Traits>(0), _M_buf() {
+ this->init(&_M_buf);
+ if (!_M_buf.open(__id, __mod))
+ this->setstate(ios_base::failbit);
+ }
+# endif /* _STLP_USE_WIN32_IO */
+#endif
+ ~basic_fstream() {}
+
+public: // File and buffer operations.
+
+ basic_filebuf<_CharT, _Traits>* rdbuf() const
+ { return __CONST_CAST(_Buf*,&_M_buf); }
+
+ bool is_open() {
+ return this->rdbuf()->is_open();
+ }
+
+ void open(const char* __s,
+ ios_base::openmode __mod =
+ ios_base::in | ios_base::out) {
+ if (!this->rdbuf()->open(__s, __mod))
+ this->setstate(ios_base::failbit);
+ }
+
+ void close() {
+ if (!this->rdbuf()->close())
+ this->setstate(ios_base::failbit);
+ }
+
+private:
+ basic_filebuf<_CharT, _Traits> _M_buf;
+
+#if defined (_STLP_MSVC) && (_STLP_MSVC >= 1300 && _STLP_MSVC <= 1310)
+ typedef basic_fstream<_CharT, _Traits> _Self;
+ //explicitely defined as private to avoid warnings:
+ basic_fstream(_Self const&);
+ _Self& operator = (_Self const&);
+#endif
+};
+
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_fstream.c>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS basic_ifstream<char, char_traits<char> >;
+_STLP_EXPORT_TEMPLATE_CLASS basic_ofstream<char, char_traits<char> >;
+_STLP_EXPORT_TEMPLATE_CLASS basic_fstream<char, char_traits<char> >;
+# if ! defined (_STLP_NO_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS basic_ifstream<wchar_t, char_traits<wchar_t> >;
+_STLP_EXPORT_TEMPLATE_CLASS basic_ofstream<wchar_t, char_traits<wchar_t> >;
+_STLP_EXPORT_TEMPLATE_CLASS basic_fstream<wchar_t, char_traits<wchar_t> >;
+# endif
+#endif /* _STLP_USE_TEMPLATE_EXPORT */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_FSTREAM */
+
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_function.h b/sources/android/stlport/stlport/stl/_function.h
new file mode 100644
index 0000000..bf4ad3e
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_function.h
@@ -0,0 +1,433 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_FUNCTION_H
+#define _STLP_INTERNAL_FUNCTION_H
+
+#ifndef _STLP_TYPE_TRAITS_H
+# include <stl/type_traits.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+# include <stl/_function_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Tp>
+struct not_equal_to : public binary_function<_Tp, _Tp, bool> {
+ bool operator()(const _Tp& __x, const _Tp& __y) const { return __x != __y; }
+};
+
+template <class _Tp>
+struct greater : public binary_function<_Tp, _Tp, bool> {
+ bool operator()(const _Tp& __x, const _Tp& __y) const { return __x > __y; }
+};
+
+template <class _Tp>
+struct greater_equal : public binary_function<_Tp, _Tp, bool> {
+ bool operator()(const _Tp& __x, const _Tp& __y) const { return __x >= __y; }
+};
+
+template <class _Tp>
+struct less_equal : public binary_function<_Tp, _Tp, bool> {
+ bool operator()(const _Tp& __x, const _Tp& __y) const { return __x <= __y; }
+};
+
+template <class _Tp>
+struct divides : public binary_function<_Tp, _Tp, _Tp> {
+ _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x / __y; }
+};
+
+template <class _Tp>
+struct modulus : public binary_function<_Tp, _Tp, _Tp> {
+ _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x % __y; }
+};
+
+template <class _Tp>
+struct negate : public unary_function<_Tp, _Tp> {
+ _Tp operator()(const _Tp& __x) const { return -__x; }
+};
+
+template <class _Tp>
+struct logical_and : public binary_function<_Tp, _Tp, bool> {
+ bool operator()(const _Tp& __x, const _Tp& __y) const { return __x && __y; }
+};
+
+template <class _Tp>
+struct logical_or : public binary_function<_Tp, _Tp,bool> {
+ bool operator()(const _Tp& __x, const _Tp& __y) const { return __x || __y; }
+};
+
+template <class _Tp>
+struct logical_not : public unary_function<_Tp, bool> {
+ bool operator()(const _Tp& __x) const { return !__x; }
+};
+
+#if !defined (_STLP_NO_EXTENSIONS)
+// identity_element (not part of the C++ standard).
+template <class _Tp> inline _Tp identity_element(plus<_Tp>) { return _Tp(0); }
+template <class _Tp> inline _Tp identity_element(multiplies<_Tp>) { return _Tp(1); }
+#endif
+
+#if defined (_STLP_BASE_TYPEDEF_BUG)
+// this workaround is needed for SunPro 4.0.1
+// suggested by "Martin Abernethy" <gma@paston.co.uk>:
+
+// We have to introduce the XXary_predicate_aux structures in order to
+// access the argument and return types of predicate functions supplied
+// as type parameters. SUN C++ 4.0.1 compiler gives errors for template type parameters
+// of the form 'name1::name2', where name1 is itself a type parameter.
+template <class _Pair>
+struct __pair_aux : private _Pair {
+ typedef typename _Pair::first_type first_type;
+ typedef typename _Pair::second_type second_type;
+};
+
+template <class _Operation>
+struct __unary_fun_aux : private _Operation {
+ typedef typename _Operation::argument_type argument_type;
+ typedef typename _Operation::result_type result_type;
+};
+
+template <class _Operation>
+struct __binary_fun_aux : private _Operation {
+ typedef typename _Operation::first_argument_type first_argument_type;
+ typedef typename _Operation::second_argument_type second_argument_type;
+ typedef typename _Operation::result_type result_type;
+};
+
+# define __UNARY_ARG(__Operation,__type) __unary_fun_aux<__Operation>::__type
+# define __BINARY_ARG(__Operation,__type) __binary_fun_aux<__Operation>::__type
+# define __PAIR_ARG(__Pair,__type) __pair_aux<__Pair>::__type
+#else
+# define __UNARY_ARG(__Operation,__type) __Operation::__type
+# define __BINARY_ARG(__Operation,__type) __Operation::__type
+# define __PAIR_ARG(__Pair,__type) __Pair::__type
+#endif
+
+template <class _Predicate>
+class unary_negate
+ : public unary_function<typename __UNARY_ARG(_Predicate, argument_type), bool> {
+ typedef unary_function<typename __UNARY_ARG(_Predicate, argument_type), bool> _Base;
+public:
+ typedef typename _Base::argument_type argument_type;
+private:
+ typedef typename __call_traits<argument_type>::const_param_type _ArgParamType;
+protected:
+ _Predicate _M_pred;
+public:
+ explicit unary_negate(const _Predicate& __x) : _M_pred(__x) {}
+ bool operator()(_ArgParamType __x) const {
+ return !_M_pred(__x);
+ }
+};
+
+template <class _Predicate>
+inline unary_negate<_Predicate>
+not1(const _Predicate& __pred) {
+ return unary_negate<_Predicate>(__pred);
+}
+
+template <class _Predicate>
+class binary_negate
+ : public binary_function<typename __BINARY_ARG(_Predicate, first_argument_type),
+ typename __BINARY_ARG(_Predicate, second_argument_type),
+ bool> {
+ typedef binary_function<typename __BINARY_ARG(_Predicate, first_argument_type),
+ typename __BINARY_ARG(_Predicate, second_argument_type),
+ bool> _Base;
+public:
+ typedef typename _Base::first_argument_type first_argument_type;
+ typedef typename _Base::second_argument_type second_argument_type;
+private:
+ typedef typename __call_traits<first_argument_type>::const_param_type _FstArgParamType;
+ typedef typename __call_traits<second_argument_type>::const_param_type _SndArgParamType;
+protected:
+ _Predicate _M_pred;
+public:
+ explicit binary_negate(const _Predicate& __x) : _M_pred(__x) {}
+ bool operator()(_FstArgParamType __x, _SndArgParamType __y) const {
+ return !_M_pred(__x, __y);
+ }
+};
+
+template <class _Predicate>
+inline binary_negate<_Predicate>
+not2(const _Predicate& __pred) {
+ return binary_negate<_Predicate>(__pred);
+}
+
+template <class _Operation>
+class binder1st :
+ public unary_function<typename __BINARY_ARG(_Operation, second_argument_type),
+ typename __BINARY_ARG(_Operation, result_type) > {
+ typedef unary_function<typename __BINARY_ARG(_Operation, second_argument_type),
+ typename __BINARY_ARG(_Operation, result_type) > _Base;
+public:
+ typedef typename _Base::argument_type argument_type;
+ typedef typename _Base::result_type result_type;
+private:
+ typedef typename __call_traits<argument_type>::param_type _ArgParamType;
+ typedef typename __call_traits<argument_type>::const_param_type _ConstArgParamType;
+ typedef typename __call_traits<typename _Operation::first_argument_type>::const_param_type _ValueParamType;
+protected:
+ //op is a Standard name (20.3.6.1), do no make it STLport naming convention compliant.
+ _Operation op;
+ typename _Operation::first_argument_type _M_value;
+public:
+ binder1st(const _Operation& __x, _ValueParamType __y)
+ : op(__x), _M_value(__y) {}
+
+ result_type operator()(_ConstArgParamType __x) const
+ { return op(_M_value, __x); }
+ // DR 109 Missing binders for non-const sequence elements
+ result_type operator()(_ArgParamType __x) const
+ { return op(_M_value, __x); }
+};
+
+template <class _Operation, class _Tp>
+inline binder1st<_Operation>
+bind1st(const _Operation& __fn, const _Tp& __x) {
+ typedef typename _Operation::first_argument_type _Arg1_type;
+ return binder1st<_Operation>(__fn, _Arg1_type(__x));
+}
+
+template <class _Operation>
+class binder2nd
+ : public unary_function<typename __BINARY_ARG(_Operation, first_argument_type),
+ typename __BINARY_ARG(_Operation, result_type)> {
+ typedef unary_function<typename __BINARY_ARG(_Operation, first_argument_type),
+ typename __BINARY_ARG(_Operation, result_type)> _Base;
+public:
+ typedef typename _Base::argument_type argument_type;
+ typedef typename _Base::result_type result_type;
+private:
+ typedef typename __call_traits<argument_type>::param_type _ArgParamType;
+ typedef typename __call_traits<argument_type>::const_param_type _ConstArgParamType;
+ typedef typename __call_traits<typename _Operation::second_argument_type>::const_param_type _ValueParamType;
+protected:
+ //op is a Standard name (20.3.6.3), do no make it STLport naming convention compliant.
+ _Operation op;
+ typename _Operation::second_argument_type value;
+public:
+ binder2nd(const _Operation& __x, _ValueParamType __y)
+ : op(__x), value(__y) {}
+
+ result_type operator()(_ConstArgParamType __x) const
+ { return op(__x, value); }
+ // DR 109 Missing binders for non-const sequence elements
+ result_type operator()(_ArgParamType __x) const
+ { return op(__x, value); }
+};
+
+template <class _Operation, class _Tp>
+inline binder2nd<_Operation>
+bind2nd(const _Operation& __fn, const _Tp& __x) {
+ typedef typename _Operation::second_argument_type _Arg2_type;
+ return binder2nd<_Operation>(__fn, _Arg2_type(__x));
+}
+
+#if !defined (_STLP_NO_EXTENSIONS)
+// unary_compose and binary_compose (extensions, not part of the standard).
+
+template <class _Operation1, class _Operation2>
+class unary_compose :
+ public unary_function<typename __UNARY_ARG(_Operation2, argument_type),
+ typename __UNARY_ARG(_Operation1, result_type)> {
+ typedef unary_function<typename __UNARY_ARG(_Operation2, argument_type),
+ typename __UNARY_ARG(_Operation1, result_type)> _Base;
+public:
+ typedef typename _Base::argument_type argument_type;
+ typedef typename _Base::result_type result_type;
+private:
+ typedef typename __call_traits<argument_type>::const_param_type _ArgParamType;
+protected:
+ _Operation1 _M_fn1;
+ _Operation2 _M_fn2;
+public:
+ unary_compose(const _Operation1& __x, const _Operation2& __y)
+ : _M_fn1(__x), _M_fn2(__y) {}
+
+ result_type operator()(_ArgParamType __x) const {
+ return _M_fn1(_M_fn2(__x));
+ }
+};
+
+template <class _Operation1, class _Operation2>
+inline unary_compose<_Operation1,_Operation2>
+compose1(const _Operation1& __fn1, const _Operation2& __fn2) {
+ return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
+}
+
+template <class _Operation1, class _Operation2, class _Operation3>
+class binary_compose :
+ public unary_function<typename __UNARY_ARG(_Operation2, argument_type),
+ typename __BINARY_ARG(_Operation1, result_type)> {
+ typedef unary_function<typename __UNARY_ARG(_Operation2, argument_type),
+ typename __BINARY_ARG(_Operation1, result_type)> _Base;
+public:
+ typedef typename _Base::argument_type argument_type;
+ typedef typename _Base::result_type result_type;
+private:
+ typedef typename __call_traits<argument_type>::const_param_type _ArgParamType;
+protected:
+ _Operation1 _M_fn1;
+ _Operation2 _M_fn2;
+ _Operation3 _M_fn3;
+public:
+ binary_compose(const _Operation1& __x, const _Operation2& __y,
+ const _Operation3& __z)
+ : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }
+
+ result_type operator()(_ArgParamType __x) const {
+ return _M_fn1(_M_fn2(__x), _M_fn3(__x));
+ }
+};
+
+template <class _Operation1, class _Operation2, class _Operation3>
+inline binary_compose<_Operation1, _Operation2, _Operation3>
+compose2(const _Operation1& __fn1, const _Operation2& __fn2,
+ const _Operation3& __fn3) {
+ return binary_compose<_Operation1,_Operation2,_Operation3>(__fn1, __fn2, __fn3);
+}
+
+// identity is an extension: it is not part of the standard.
+template <class _Tp> struct identity : public _STLP_PRIV _Identity<_Tp> {};
+// select1st and select2nd are extensions: they are not part of the standard.
+template <class _Pair> struct select1st : public _STLP_PRIV _Select1st<_Pair> {};
+template <class _Pair> struct select2nd : public _STLP_PRIV _Select2nd<_Pair> {};
+
+template <class _Arg1, class _Arg2>
+struct project1st : public _STLP_PRIV _Project1st<_Arg1, _Arg2> {};
+
+template <class _Arg1, class _Arg2>
+struct project2nd : public _STLP_PRIV _Project2nd<_Arg1, _Arg2> {};
+
+
+// constant_void_fun, constant_unary_fun, and constant_binary_fun are
+// extensions: they are not part of the standard. (The same, of course,
+// is true of the helper functions constant0, constant1, and constant2.)
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Result>
+struct _Constant_void_fun {
+ typedef _Result result_type;
+ result_type _M_val;
+
+ _Constant_void_fun(const result_type& __v) : _M_val(__v) {}
+ const result_type& operator()() const { return _M_val; }
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _Result>
+struct constant_void_fun : public _STLP_PRIV _Constant_void_fun<_Result> {
+ constant_void_fun(const _Result& __v)
+ : _STLP_PRIV _Constant_void_fun<_Result>(__v) {}
+};
+
+template <class _Result, _STLP_DFL_TMPL_PARAM( _Argument , _Result) >
+struct constant_unary_fun : public _STLP_PRIV _Constant_unary_fun<_Result, _Argument> {
+ constant_unary_fun(const _Result& __v)
+ : _STLP_PRIV _Constant_unary_fun<_Result, _Argument>(__v) {}
+};
+
+template <class _Result, _STLP_DFL_TMPL_PARAM( _Arg1 , _Result), _STLP_DFL_TMPL_PARAM( _Arg2 , _Arg1) >
+struct constant_binary_fun
+ : public _STLP_PRIV _Constant_binary_fun<_Result, _Arg1, _Arg2> {
+ constant_binary_fun(const _Result& __v)
+ : _STLP_PRIV _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {}
+};
+
+template <class _Result>
+inline constant_void_fun<_Result> constant0(const _Result& __val) {
+ return constant_void_fun<_Result>(__val);
+}
+
+template <class _Result>
+inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val) {
+ return constant_unary_fun<_Result,_Result>(__val);
+}
+
+template <class _Result>
+inline constant_binary_fun<_Result,_Result,_Result>
+constant2(const _Result& __val) {
+ return constant_binary_fun<_Result,_Result,_Result>(__val);
+}
+
+// subtractive_rng is an extension: it is not part of the standard.
+// Note: this code assumes that int is 32 bits.
+class subtractive_rng : public unary_function<_STLP_UINT32_T, _STLP_UINT32_T> {
+private:
+ _STLP_UINT32_T _M_table[55];
+ _STLP_UINT32_T _M_index1;
+ _STLP_UINT32_T _M_index2;
+public:
+ _STLP_UINT32_T operator()(_STLP_UINT32_T __limit) {
+ _M_index1 = (_M_index1 + 1) % 55;
+ _M_index2 = (_M_index2 + 1) % 55;
+ _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2];
+ return _M_table[_M_index1] % __limit;
+ }
+
+ void _M_initialize(_STLP_UINT32_T __seed) {
+ _STLP_UINT32_T __k = 1;
+ _M_table[54] = __seed;
+ _STLP_UINT32_T __i;
+ for (__i = 0; __i < 54; __i++) {
+ _STLP_UINT32_T __ii = (21 * (__i + 1) % 55) - 1;
+ _M_table[__ii] = __k;
+ __k = __seed - __k;
+ __seed = _M_table[__ii];
+ }
+ for (int __loop = 0; __loop < 4; __loop++) {
+ for (__i = 0; __i < 55; __i++)
+ _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55];
+ }
+ _M_index1 = 0;
+ _M_index2 = 31;
+ }
+
+ subtractive_rng(unsigned int __seed) { _M_initialize(__seed); }
+ subtractive_rng() { _M_initialize(161803398ul); }
+};
+
+#endif /* _STLP_NO_EXTENSIONS */
+
+_STLP_END_NAMESPACE
+
+#include <stl/_function_adaptors.h>
+
+#endif /* _STLP_INTERNAL_FUNCTION_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_function_adaptors.h b/sources/android/stlport/stlport/stl/_function_adaptors.h
new file mode 100644
index 0000000..0da419b
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_function_adaptors.h
@@ -0,0 +1,783 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * Copyright (c) 2000
+ * Pavel Kuznetsov
+ *
+ * Copyright (c) 2001
+ * Meridian'93
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+// This file has noo macro protection as it is meant to be included several times
+// from other header.
+// Adaptor function objects: pointers to member functions.
+
+// There are a total of 16 = 2^4 function objects in this family.
+// (1) Member functions taking no arguments vs member functions taking
+// one argument.
+// (2) Call through pointer vs call through reference.
+// (3) Member function with void return type vs member function with
+// non-void return type.
+// (4) Const vs non-const member function.
+
+// Note that choice (3) is nothing more than a workaround: according
+// to the draft, compilers should handle void and non-void the same way.
+// This feature is not yet widely implemented, though. You can only use
+// member functions returning void if your compiler supports partial
+// specialization.
+
+// All of this complexity is in the function objects themselves. You can
+// ignore it by using the helper function mem_fun and mem_fun_ref,
+// which create whichever type of adaptor is appropriate.
+
+_STLP_BEGIN_NAMESPACE
+
+//This implementation will only be used if needed, that is to say when there is the return void bug
+//and when there is no partial template specialization
+#if defined (_STLP_DONT_RETURN_VOID) && defined (_STLP_NO_CLASS_PARTIAL_SPECIALIZATION) && defined (_STLP_MEMBER_TEMPLATE_CLASSES)
+
+template<class _Result, class _Tp>
+class _Mem_fun0_ptr : public unary_function<_Tp*, _Result> {
+protected:
+ typedef _Result (_Tp::*__fun_type) ();
+ explicit _Mem_fun0_ptr(__fun_type __f) : _M_f(__f) {}
+
+public:
+ _Result operator ()(_Tp* __p) const { return (__p->*_M_f)(); }
+
+private:
+ __fun_type _M_f;
+};
+
+template<class _Result, class _Tp, class _Arg>
+class _Mem_fun1_ptr : public binary_function<_Tp*,_Arg,_Result> {
+protected:
+ typedef _Result (_Tp::*__fun_type) (_Arg);
+ explicit _Mem_fun1_ptr(__fun_type __f) : _M_f(__f) {}
+
+public:
+ _Result operator ()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); }
+
+private:
+ __fun_type _M_f;
+};
+
+template<class _Result, class _Tp>
+class _Const_mem_fun0_ptr : public unary_function<const _Tp*,_Result> {
+protected:
+ typedef _Result (_Tp::*__fun_type) () const;
+ explicit _Const_mem_fun0_ptr(__fun_type __f) : _M_f(__f) {}
+
+public:
+ _Result operator ()(const _Tp* __p) const { return (__p->*_M_f)(); }
+
+private:
+ __fun_type _M_f;
+};
+
+template<class _Result, class _Tp, class _Arg>
+class _Const_mem_fun1_ptr : public binary_function<const _Tp*,_Arg,_Result> {
+protected:
+ typedef _Result (_Tp::*__fun_type) (_Arg) const;
+ explicit _Const_mem_fun1_ptr(__fun_type __f) : _M_f(__f) {}
+
+public:
+ _Result operator ()(const _Tp* __p, _Arg __x) const {
+ return (__p->*_M_f)(__x); }
+
+private:
+ __fun_type _M_f;
+};
+
+template<class _Result, class _Tp>
+class _Mem_fun0_ref : public unary_function<_Tp,_Result> {
+protected:
+ typedef _Result (_Tp::*__fun_type) ();
+ explicit _Mem_fun0_ref(__fun_type __f) : _M_f(__f) {}
+
+public:
+ _Result operator ()(_Tp& __p) const { return (__p.*_M_f)(); }
+
+private:
+ __fun_type _M_f;
+};
+
+template<class _Result, class _Tp, class _Arg>
+class _Mem_fun1_ref : public binary_function<_Tp,_Arg,_Result> {
+protected:
+ typedef _Result (_Tp::*__fun_type) (_Arg);
+ explicit _Mem_fun1_ref(__fun_type __f) : _M_f(__f) {}
+
+public:
+ _Result operator ()(_Tp& __p, _Arg __x) const { return (__p.*_M_f)(__x); }
+
+private:
+ __fun_type _M_f;
+};
+
+template<class _Result, class _Tp>
+class _Const_mem_fun0_ref : public unary_function<_Tp,_Result> {
+protected:
+ typedef _Result (_Tp::*__fun_type) () const;
+ explicit _Const_mem_fun0_ref(__fun_type __f) : _M_f(__f) {}
+
+public:
+ _Result operator ()(const _Tp& __p) const { return (__p.*_M_f)(); }
+
+private:
+ __fun_type _M_f;
+};
+
+template<class _Result, class _Tp, class _Arg>
+class _Const_mem_fun1_ref : public binary_function<_Tp,_Arg,_Result> {
+protected:
+ typedef _Result (_Tp::*__fun_type) (_Arg) const;
+ explicit _Const_mem_fun1_ref(__fun_type __f) : _M_f(__f) {}
+
+public:
+ _Result operator ()(const _Tp& __p, _Arg __x) const { return (__p.*_M_f)(__x); }
+
+private:
+ __fun_type _M_f;
+};
+
+template<class _Result>
+struct _Mem_fun_traits {
+ template<class _Tp>
+ struct _Args0 {
+ typedef _Mem_fun0_ptr<_Result,_Tp> _Ptr;
+ typedef _Const_mem_fun0_ptr<_Result,_Tp> _Ptr_const;
+ typedef _Mem_fun0_ref<_Result,_Tp> _Ref;
+ typedef _Const_mem_fun0_ref<_Result,_Tp> _Ref_const;
+ };
+
+ template<class _Tp, class _Arg>
+ struct _Args1 {
+ typedef _Mem_fun1_ptr<_Result,_Tp,_Arg> _Ptr;
+ typedef _Const_mem_fun1_ptr<_Result,_Tp,_Arg> _Ptr_const;
+ typedef _Mem_fun1_ref<_Result,_Tp,_Arg> _Ref;
+ typedef _Const_mem_fun1_ref<_Result,_Tp,_Arg> _Ref_const;
+ };
+};
+
+template<class _Arg, class _Result>
+class _Ptr_fun1_base : public unary_function<_Arg, _Result> {
+protected:
+ typedef _Result (*__fun_type) (_Arg);
+ explicit _Ptr_fun1_base(__fun_type __f) : _M_f(__f) {}
+
+public:
+ _Result operator()(_Arg __x) const { return _M_f(__x); }
+
+private:
+ __fun_type _M_f;
+};
+
+template <class _Arg1, class _Arg2, class _Result>
+class _Ptr_fun2_base : public binary_function<_Arg1,_Arg2,_Result> {
+protected:
+ typedef _Result (*__fun_type) (_Arg1, _Arg2);
+ explicit _Ptr_fun2_base(__fun_type __f) : _M_f(__f) {}
+
+public:
+ _Result operator()(_Arg1 __x, _Arg2 __y) const { return _M_f(__x, __y); }
+
+private:
+ __fun_type _M_f;
+};
+
+template<class _Result>
+struct _Ptr_fun_traits {
+ template<class _Arg> struct _Args1 {
+ typedef _Ptr_fun1_base<_Arg,_Result> _Fun;
+ };
+
+ template<class _Arg1, class _Arg2> struct _Args2 {
+ typedef _Ptr_fun2_base<_Arg1,_Arg2,_Result> _Fun;
+ };
+};
+
+/* Specializations for void return type */
+template<class _Tp>
+class _Void_mem_fun0_ptr : public unary_function<_Tp*,void> {
+protected:
+ typedef void (_Tp::*__fun_type) ();
+ explicit _Void_mem_fun0_ptr(__fun_type __f) : _M_f(__f) {}
+
+public:
+ void operator ()(_Tp* __p) const { (__p->*_M_f)(); }
+
+private:
+ __fun_type _M_f;
+};
+
+template<class _Tp, class _Arg>
+class _Void_mem_fun1_ptr : public binary_function<_Tp*,_Arg,void> {
+protected:
+ typedef void (_Tp::*__fun_type) (_Arg);
+ explicit _Void_mem_fun1_ptr(__fun_type __f) : _M_f(__f) {}
+
+public:
+ void operator ()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
+
+private:
+ __fun_type _M_f;
+};
+
+template<class _Tp>
+class _Void_const_mem_fun0_ptr : public unary_function<const _Tp*,void> {
+protected:
+ typedef void (_Tp::*__fun_type) () const;
+ explicit _Void_const_mem_fun0_ptr(__fun_type __f) : _M_f(__f) {}
+
+public:
+ void operator ()(const _Tp* __p) const { (__p->*_M_f)(); }
+
+private:
+ __fun_type _M_f;
+};
+
+template<class _Tp, class _Arg>
+class _Void_const_mem_fun1_ptr : public binary_function<const _Tp*,_Arg,void> {
+protected:
+ typedef void (_Tp::*__fun_type) (_Arg) const;
+ explicit _Void_const_mem_fun1_ptr(__fun_type __f) : _M_f(__f) {}
+
+public:
+ void operator ()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
+
+private:
+ __fun_type _M_f;
+};
+
+template<class _Tp>
+class _Void_mem_fun0_ref : public unary_function<_Tp,void> {
+protected:
+ typedef void (_Tp::*__fun_type) ();
+ explicit _Void_mem_fun0_ref(__fun_type __f) : _M_f(__f) {}
+
+public:
+ void operator ()(_Tp& __p) const { (__p.*_M_f)(); }
+
+private:
+ __fun_type _M_f;
+};
+
+template<class _Tp, class _Arg>
+class _Void_mem_fun1_ref : public binary_function<_Tp,_Arg,void> {
+protected:
+ typedef void (_Tp::*__fun_type) (_Arg);
+ explicit _Void_mem_fun1_ref(__fun_type __f) : _M_f(__f) {}
+
+public:
+ void operator ()(_Tp& __p, _Arg __x) const { (__p.*_M_f)(__x); }
+
+private:
+ __fun_type _M_f;
+};
+
+template<class _Tp>
+class _Void_const_mem_fun0_ref : public unary_function<_Tp,void> {
+protected:
+ typedef void (_Tp::*__fun_type) () const;
+ explicit _Void_const_mem_fun0_ref(__fun_type __f) : _M_f(__f) {}
+
+public:
+ void operator ()(const _Tp& __p) const { (__p.*_M_f)(); }
+
+private:
+ __fun_type _M_f;
+};
+
+template<class _Tp, class _Arg>
+class _Void_const_mem_fun1_ref : public binary_function<_Tp,_Arg,void> {
+protected:
+ typedef void (_Tp::*__fun_type) (_Arg) const;
+ explicit _Void_const_mem_fun1_ref(__fun_type __f) : _M_f(__f) {}
+
+public:
+ void operator ()(const _Tp& __p, _Arg __x) const { (__p.*_M_f)(__x); }
+
+private:
+ __fun_type _M_f;
+};
+
+_STLP_TEMPLATE_NULL
+struct _Mem_fun_traits<void> {
+ template<class _Tp> struct _Args0 {
+ typedef _Void_mem_fun0_ptr<_Tp> _Ptr;
+ typedef _Void_const_mem_fun0_ptr<_Tp> _Ptr_const;
+ typedef _Void_mem_fun0_ref<_Tp> _Ref;
+ typedef _Void_const_mem_fun0_ref<_Tp> _Ref_const;
+ };
+
+ template<class _Tp, class _Arg> struct _Args1 {
+ typedef _Void_mem_fun1_ptr<_Tp,_Arg> _Ptr;
+ typedef _Void_const_mem_fun1_ptr<_Tp,_Arg> _Ptr_const;
+ typedef _Void_mem_fun1_ref<_Tp,_Arg> _Ref;
+ typedef _Void_const_mem_fun1_ref<_Tp,_Arg> _Ref_const;
+ };
+};
+
+template<class _Arg>
+class _Ptr_void_fun1_base : public unary_function<_Arg, void> {
+protected:
+ typedef void (*__fun_type) (_Arg);
+ explicit _Ptr_void_fun1_base(__fun_type __f) : _M_f(__f) {}
+
+public:
+ void operator()(_Arg __x) const { _M_f(__x); }
+
+private:
+ __fun_type _M_f;
+};
+
+template <class _Arg1, class _Arg2>
+class _Ptr_void_fun2_base : public binary_function<_Arg1,_Arg2,void> {
+protected:
+ typedef void (*__fun_type) (_Arg1, _Arg2);
+ explicit _Ptr_void_fun2_base(__fun_type __f) : _M_f(__f) {}
+
+public:
+ void operator()(_Arg1 __x, _Arg2 __y) const { _M_f(__x, __y); }
+
+private:
+ __fun_type _M_f;
+};
+
+_STLP_TEMPLATE_NULL
+struct _Ptr_fun_traits<void> {
+ template<class _Arg> struct _Args1 {
+ typedef _Ptr_void_fun1_base<_Arg> _Fun;
+ };
+
+ template<class _Arg1, class _Arg2> struct _Args2 {
+ typedef _Ptr_void_fun2_base<_Arg1,_Arg2> _Fun;
+ };
+};
+
+// pavel: need extra level of inheritance here since MSVC++ does not
+// accept traits-based fake partial specialization for template
+// arguments other than first
+
+template<class _Result, class _Arg>
+class _Ptr_fun1 :
+ public _Ptr_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Arg>::_Fun {
+protected:
+ typedef typename _Ptr_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Arg>::_Fun _Base;
+ explicit _Ptr_fun1(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template<class _Result, class _Arg1, class _Arg2>
+class _Ptr_fun2 :
+ public _Ptr_fun_traits<_Result>::_STLP_TEMPLATE _Args2<_Arg1,_Arg2>::_Fun {
+protected:
+ typedef typename _Ptr_fun_traits<_Result>::_STLP_TEMPLATE _Args2<_Arg1,_Arg2>::_Fun _Base;
+ explicit _Ptr_fun2(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Result, class _Tp>
+class mem_fun_t :
+ public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ptr {
+ typedef typename
+ _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ptr _Base;
+public:
+ explicit mem_fun_t(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Result, class _Tp>
+class const_mem_fun_t :
+ public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ptr_const {
+ typedef typename
+ _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ptr_const _Base;
+public:
+ explicit const_mem_fun_t(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Result, class _Tp>
+class mem_fun_ref_t :
+ public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ref {
+ typedef typename
+ _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ref _Base;
+public:
+ explicit mem_fun_ref_t(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Result, class _Tp>
+class const_mem_fun_ref_t :
+ public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ref_const {
+ typedef typename
+ _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ref_const _Base;
+public:
+ explicit const_mem_fun_ref_t(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Result, class _Tp, class _Arg>
+class mem_fun1_t :
+ public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ptr {
+ typedef typename
+ _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ptr _Base;
+public:
+ explicit mem_fun1_t(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Result, class _Tp, class _Arg>
+class const_mem_fun1_t :
+ public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ptr_const {
+ typedef typename
+ _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ptr_const _Base;
+public:
+ explicit const_mem_fun1_t(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Result, class _Tp, class _Arg>
+class mem_fun1_ref_t :
+ public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ref {
+ typedef typename
+ _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ref _Base;
+public:
+ explicit mem_fun1_ref_t(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Result, class _Tp, class _Arg>
+class const_mem_fun1_ref_t :
+ public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ref_const {
+ typedef typename
+ _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ref_const _Base;
+public:
+ explicit const_mem_fun1_ref_t(typename _Base::__fun_type __f) : _Base(__f) {}
+};
+
+template <class _Arg, class _Result>
+class pointer_to_unary_function :
+ public _Ptr_fun1<_Result,_Arg> {
+ typedef typename
+ _Ptr_fun1<_Result,_Arg>::__fun_type __fun_type;
+public:
+ explicit pointer_to_unary_function(__fun_type __f)
+ : _Ptr_fun1<_Result,_Arg>(__f) {}
+};
+
+template <class _Arg1, class _Arg2, class _Result>
+class pointer_to_binary_function :
+ public _Ptr_fun2<_Result,_Arg1,_Arg2> {
+ typedef typename
+ _Ptr_fun2<_Result,_Arg1,_Arg2>::__fun_type __fun_type;
+public:
+ explicit pointer_to_binary_function(__fun_type __f)
+ : _Ptr_fun2<_Result,_Arg1,_Arg2>(__f) {}
+};
+
+#else
+
+template <class _Ret, class _Tp>
+class mem_fun_t : public unary_function<_Tp*,_Ret> {
+ typedef _Ret (_Tp::*__fun_type)(void);
+public:
+ explicit mem_fun_t(__fun_type __pf) : _M_f(__pf) {}
+ _Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); }
+private:
+ __fun_type _M_f;
+};
+
+template <class _Ret, class _Tp>
+class const_mem_fun_t : public unary_function<const _Tp*,_Ret> {
+ typedef _Ret (_Tp::*__fun_type)(void) const;
+public:
+ explicit const_mem_fun_t(__fun_type __pf) : _M_f(__pf) {}
+ _Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); }
+private:
+ __fun_type _M_f;
+};
+
+template <class _Ret, class _Tp>
+class mem_fun_ref_t : public unary_function<_Tp,_Ret> {
+ typedef _Ret (_Tp::*__fun_type)(void);
+public:
+ explicit mem_fun_ref_t(__fun_type __pf) : _M_f(__pf) {}
+ _Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); }
+private:
+ __fun_type _M_f;
+};
+
+template <class _Ret, class _Tp>
+class const_mem_fun_ref_t : public unary_function<_Tp,_Ret> {
+ typedef _Ret (_Tp::*__fun_type)(void) const;
+public:
+ explicit const_mem_fun_ref_t(__fun_type __pf) : _M_f(__pf) {}
+ _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); }
+private:
+ __fun_type _M_f;
+};
+
+template <class _Ret, class _Tp, class _Arg>
+class mem_fun1_t : public binary_function<_Tp*,_Arg,_Ret> {
+ typedef _Ret (_Tp::*__fun_type)(_Arg);
+public:
+ explicit mem_fun1_t(__fun_type __pf) : _M_f(__pf) {}
+ _Ret operator()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); }
+private:
+ __fun_type _M_f;
+};
+
+template <class _Ret, class _Tp, class _Arg>
+class const_mem_fun1_t : public binary_function<const _Tp*,_Arg,_Ret> {
+ typedef _Ret (_Tp::*__fun_type)(_Arg) const;
+public:
+ explicit const_mem_fun1_t(__fun_type __pf) : _M_f(__pf) {}
+ _Ret operator()(const _Tp* __p, _Arg __x) const
+ { return (__p->*_M_f)(__x); }
+private:
+ __fun_type _M_f;
+};
+
+template <class _Ret, class _Tp, class _Arg>
+class mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
+ typedef _Ret (_Tp::*__fun_type)(_Arg);
+public:
+ explicit mem_fun1_ref_t(__fun_type __pf) : _M_f(__pf) {}
+ _Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
+private:
+ __fun_type _M_f;
+};
+
+template <class _Ret, class _Tp, class _Arg>
+class const_mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
+ typedef _Ret (_Tp::*__fun_type)(_Arg) const;
+public:
+ explicit const_mem_fun1_ref_t(__fun_type __pf) : _M_f(__pf) {}
+ _Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
+private:
+ __fun_type _M_f;
+};
+
+template <class _Arg, class _Result>
+class pointer_to_unary_function : public unary_function<_Arg, _Result> {
+protected:
+ _Result (*_M_ptr)(_Arg);
+public:
+ pointer_to_unary_function() {}
+ explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) {}
+ _Result operator()(_Arg __x) const { return _M_ptr(__x); }
+};
+
+template <class _Arg1, class _Arg2, class _Result>
+class pointer_to_binary_function :
+ public binary_function<_Arg1,_Arg2,_Result> {
+protected:
+ _Result (*_M_ptr)(_Arg1, _Arg2);
+public:
+ pointer_to_binary_function() {}
+ explicit pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
+ : _M_ptr(__x) {}
+ _Result operator()(_Arg1 __x, _Arg2 __y) const {
+ return _M_ptr(__x, __y);
+ }
+};
+
+# if defined (_STLP_DONT_RETURN_VOID) && !defined (_STLP_NO_CLASS_PARTIAL_SPECIALIZATION)
+//Partial specializations for the void type
+template <class _Tp>
+class mem_fun_t<void, _Tp> : public unary_function<_Tp*,void> {
+ typedef void (_Tp::*__fun_type)(void);
+public:
+ explicit mem_fun_t _STLP_PSPEC2(void,_Tp) (__fun_type __pf) : _M_f(__pf) {}
+ void operator()(_Tp* __p) const { (__p->*_M_f)(); }
+private:
+ __fun_type _M_f;
+};
+
+template <class _Tp>
+class const_mem_fun_t<void, _Tp> : public unary_function<const _Tp*,void> {
+ typedef void (_Tp::*__fun_type)(void) const;
+public:
+ explicit const_mem_fun_t _STLP_PSPEC2(void,_Tp) (__fun_type __pf) : _M_f(__pf) {}
+ void operator()(const _Tp* __p) const { (__p->*_M_f)(); }
+private:
+ __fun_type _M_f;
+};
+
+template <class _Tp>
+class mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
+ typedef void (_Tp::*__fun_type)(void);
+public:
+ explicit mem_fun_ref_t _STLP_PSPEC2(void,_Tp) (__fun_type __pf) : _M_f(__pf) {}
+ void operator()(_Tp& __r) const { (__r.*_M_f)(); }
+private:
+ __fun_type _M_f;
+};
+
+template <class _Tp>
+class const_mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
+ typedef void (_Tp::*__fun_type)(void) const;
+public:
+ explicit const_mem_fun_ref_t _STLP_PSPEC2(void,_Tp) (__fun_type __pf) : _M_f(__pf) {}
+ void operator()(const _Tp& __r) const { (__r.*_M_f)(); }
+private:
+ __fun_type _M_f;
+};
+
+template <class _Tp, class _Arg>
+class mem_fun1_t<void, _Tp, _Arg> : public binary_function<_Tp*,_Arg,void> {
+ typedef void (_Tp::*__fun_type)(_Arg);
+public:
+ explicit mem_fun1_t _STLP_PSPEC3(void,_Tp,_Arg) (__fun_type __pf) : _M_f(__pf) {}
+ void operator()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
+private:
+ __fun_type _M_f;
+};
+
+template <class _Tp, class _Arg>
+class const_mem_fun1_t<void, _Tp, _Arg>
+ : public binary_function<const _Tp*,_Arg,void> {
+ typedef void (_Tp::*__fun_type)(_Arg) const;
+public:
+ explicit const_mem_fun1_t _STLP_PSPEC3(void,_Tp,_Arg) (__fun_type __pf) : _M_f(__pf) {}
+ void operator()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
+private:
+ __fun_type _M_f;
+};
+
+template <class _Tp, class _Arg>
+class mem_fun1_ref_t<void, _Tp, _Arg>
+ : public binary_function<_Tp,_Arg,void> {
+ typedef void (_Tp::*__fun_type)(_Arg);
+public:
+ explicit mem_fun1_ref_t _STLP_PSPEC3(void,_Tp,_Arg) (__fun_type __pf) : _M_f(__pf) {}
+ void operator()(_Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
+private:
+ __fun_type _M_f;
+};
+
+template <class _Tp, class _Arg>
+class const_mem_fun1_ref_t<void, _Tp, _Arg>
+ : public binary_function<_Tp,_Arg,void> {
+ typedef void (_Tp::*__fun_type)(_Arg) const;
+public:
+ explicit const_mem_fun1_ref_t _STLP_PSPEC3(void,_Tp,_Arg) (__fun_type __pf) : _M_f(__pf) {}
+ void operator()(const _Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
+private:
+ __fun_type _M_f;
+};
+
+template <class _Arg>
+class pointer_to_unary_function<_Arg, void> : public unary_function<_Arg, void> {
+ typedef void (*__fun_type)(_Arg);
+ __fun_type _M_ptr;
+public:
+ pointer_to_unary_function() {}
+ explicit pointer_to_unary_function(__fun_type __x) : _M_ptr(__x) {}
+ void operator()(_Arg __x) const { _M_ptr(__x); }
+};
+
+template <class _Arg1, class _Arg2>
+class pointer_to_binary_function<_Arg1, _Arg2, void> : public binary_function<_Arg1,_Arg2,void> {
+ typedef void (*__fun_type)(_Arg1, _Arg2);
+ __fun_type _M_ptr;
+public:
+ pointer_to_binary_function() {}
+ explicit pointer_to_binary_function(__fun_type __x) : _M_ptr(__x) {}
+ void operator()(_Arg1 __x, _Arg2 __y) const { _M_ptr(__x, __y); }
+};
+
+# endif
+
+#endif
+
+#if !defined (_STLP_MEMBER_POINTER_PARAM_BUG)
+// Mem_fun adaptor helper functions. There are only two:
+// mem_fun and mem_fun_ref. (mem_fun1 and mem_fun1_ref
+// are provided for backward compatibility, but they are no longer
+// part of the C++ standard.)
+
+template <class _Result, class _Tp>
+inline mem_fun_t<_Result,_Tp>
+mem_fun(_Result (_Tp::*__f)()) { return mem_fun_t<_Result,_Tp>(__f); }
+
+template <class _Result, class _Tp>
+inline const_mem_fun_t<_Result,_Tp>
+mem_fun(_Result (_Tp::*__f)() const) { return const_mem_fun_t<_Result,_Tp>(__f); }
+
+template <class _Result, class _Tp>
+inline mem_fun_ref_t<_Result,_Tp>
+mem_fun_ref(_Result (_Tp::*__f)()) { return mem_fun_ref_t<_Result,_Tp>(__f); }
+
+template <class _Result, class _Tp>
+inline const_mem_fun_ref_t<_Result,_Tp>
+mem_fun_ref(_Result (_Tp::*__f)() const) { return const_mem_fun_ref_t<_Result,_Tp>(__f); }
+
+template <class _Result, class _Tp, class _Arg>
+inline mem_fun1_t<_Result,_Tp,_Arg>
+mem_fun(_Result (_Tp::*__f)(_Arg)) { return mem_fun1_t<_Result,_Tp,_Arg>(__f); }
+
+template <class _Result, class _Tp, class _Arg>
+inline const_mem_fun1_t<_Result,_Tp,_Arg>
+mem_fun(_Result (_Tp::*__f)(_Arg) const) { return const_mem_fun1_t<_Result,_Tp,_Arg>(__f); }
+
+template <class _Result, class _Tp, class _Arg>
+inline mem_fun1_ref_t<_Result,_Tp,_Arg>
+mem_fun_ref(_Result (_Tp::*__f)(_Arg)) { return mem_fun1_ref_t<_Result,_Tp,_Arg>(__f); }
+
+template <class _Result, class _Tp, class _Arg>
+inline const_mem_fun1_ref_t<_Result,_Tp,_Arg>
+mem_fun_ref(_Result (_Tp::*__f)(_Arg) const) { return const_mem_fun1_ref_t<_Result,_Tp,_Arg>(__f); }
+
+# if !(defined (_STLP_NO_EXTENSIONS) || defined (_STLP_NO_ANACHRONISMS))
+// mem_fun1 and mem_fun1_ref are no longer part of the C++ standard,
+// but they are provided for backward compatibility.
+template <class _Result, class _Tp, class _Arg>
+inline mem_fun1_t<_Result,_Tp,_Arg>
+mem_fun1(_Result (_Tp::*__f)(_Arg)) { return mem_fun1_t<_Result,_Tp,_Arg>(__f); }
+
+template <class _Result, class _Tp, class _Arg>
+inline const_mem_fun1_t<_Result,_Tp,_Arg>
+mem_fun1(_Result (_Tp::*__f)(_Arg) const) { return const_mem_fun1_t<_Result,_Tp,_Arg>(__f); }
+
+template <class _Result, class _Tp, class _Arg>
+inline mem_fun1_ref_t<_Result,_Tp,_Arg>
+mem_fun1_ref(_Result (_Tp::*__f)(_Arg)) { return mem_fun1_ref_t<_Result,_Tp,_Arg>(__f); }
+
+template <class _Result, class _Tp, class _Arg>
+inline const_mem_fun1_ref_t<_Result,_Tp,_Arg>
+mem_fun1_ref(_Result (_Tp::*__f)(_Arg) const) { return const_mem_fun1_ref_t<_Result,_Tp,_Arg>(__f); }
+
+# endif
+
+#endif
+
+template <class _Arg, class _Result>
+inline pointer_to_unary_function<_Arg, _Result>
+ptr_fun(_Result (*__f)(_Arg))
+{ return pointer_to_unary_function<_Arg, _Result>(__f); }
+
+template <class _Arg1, class _Arg2, class _Result>
+inline pointer_to_binary_function<_Arg1,_Arg2,_Result>
+ptr_fun(_Result (*__f)(_Arg1, _Arg2))
+{ return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f); }
+
+_STLP_END_NAMESPACE
diff --git a/sources/android/stlport/stlport/stl/_function_base.h b/sources/android/stlport/stlport/stl/_function_base.h
new file mode 100644
index 0000000..1e7f4f5
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_function_base.h
@@ -0,0 +1,217 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+#define _STLP_INTERNAL_FUNCTION_BASE_H
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_TYPE_TRAITS_H)
+# include <stl/type_traits.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Arg, class _Result>
+struct unary_function {
+ typedef _Arg argument_type;
+ typedef _Result result_type;
+#if !defined (__BORLANDC__) || (__BORLANDC__ < 0x580)
+protected:
+ /* This class purpose is to be derived but it is not polymorphic so users should never try
+ * to destroy an instance of it directly. The protected non-virtual destructor make this
+ * fact obvious at compilation time. */
+ ~unary_function() {}
+#endif
+};
+
+template <class _Arg1, class _Arg2, class _Result>
+struct binary_function {
+ typedef _Arg1 first_argument_type;
+ typedef _Arg2 second_argument_type;
+ typedef _Result result_type;
+#if !defined (__BORLANDC__) || (__BORLANDC__ < 0x580)
+protected:
+ /* See unary_function comment. */
+ ~binary_function() {}
+#endif
+};
+
+template <class _Tp>
+struct equal_to : public binary_function<_Tp, _Tp, bool> {
+ bool operator()(const _Tp& __x, const _Tp& __y) const { return __x == __y; }
+};
+
+template <class _Tp>
+struct less : public binary_function<_Tp,_Tp,bool>
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+/* less is the default template parameter for many STL containers, to fully use
+ * the move constructor feature we need to know that the default less is just a
+ * functor.
+ */
+ , public __stlport_class<less<_Tp> >
+#endif
+{
+ bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; }
+
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(less<_Tp>& __x) {}
+#endif
+};
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+template <class _Tp>
+struct __type_traits<less<_Tp> > {
+#if !defined (__BORLANDC__)
+ typedef typename _IsSTLportClass<less<_Tp> >::_Ret _STLportLess;
+#else
+ enum { _Is = _IsSTLportClass<less<_Tp> >::_Is };
+ typedef typename __bool2type<_Is>::_Ret _STLportLess;
+#endif
+ typedef _STLportLess has_trivial_default_constructor;
+ typedef _STLportLess has_trivial_copy_constructor;
+ typedef _STLportLess has_trivial_assignment_operator;
+ typedef _STLportLess has_trivial_destructor;
+ typedef _STLportLess is_POD_type;
+};
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp>
+less<_Tp> __less(_Tp* ) { return less<_Tp>(); }
+
+template <class _Tp>
+equal_to<_Tp> __equal_to(_Tp* ) { return equal_to<_Tp>(); }
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _Tp>
+struct plus : public binary_function<_Tp, _Tp, _Tp> {
+ _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x + __y; }
+};
+
+template <class _Tp>
+struct minus : public binary_function<_Tp, _Tp, _Tp> {
+ _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x - __y; }
+};
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp>
+plus<_Tp> __plus(_Tp* ) { return plus<_Tp>(); }
+
+template <class _Tp>
+minus<_Tp> __minus(_Tp* ) { return minus<_Tp>(); }
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _Tp>
+struct multiplies : public binary_function<_Tp, _Tp, _Tp> {
+ _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x * __y; }
+};
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Pair>
+struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> {
+ const typename _Pair::first_type& operator()(const _Pair& __x) const {
+ return __x.first;
+ }
+};
+
+template <class _Pair>
+struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type> {
+ const typename _Pair::second_type& operator()(const _Pair& __x) const {
+ return __x.second;
+ }
+};
+
+// project1st and project2nd are extensions: they are not part of the standard
+template <class _Arg1, class _Arg2>
+struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> {
+ _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; }
+};
+
+template <class _Arg1, class _Arg2>
+struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> {
+ _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; }
+};
+
+#if defined (_STLP_MULTI_CONST_TEMPLATE_ARG_BUG)
+// fbp : sort of select1st just for maps
+template <class _Pair, class _Whatever>
+// JDJ (CW Pro1 doesn't like const when first_type is also const)
+struct __Select1st_hint : public unary_function<_Pair, _Whatever> {
+ const _Whatever& operator () (const _Pair& __x) const { return __x.first; }
+};
+# define _STLP_SELECT1ST(__x,__y) _STLP_PRIV __Select1st_hint< __x, __y >
+#else
+# define _STLP_SELECT1ST(__x, __y) _STLP_PRIV _Select1st< __x >
+#endif
+
+template <class _Tp>
+struct _Identity : public unary_function<_Tp,_Tp> {
+ const _Tp& operator()(const _Tp& __x) const { return __x; }
+};
+
+template <class _Result, class _Argument>
+struct _Constant_unary_fun {
+ typedef _Argument argument_type;
+ typedef _Result result_type;
+ result_type _M_val;
+
+ _Constant_unary_fun(const result_type& __v) : _M_val(__v) {}
+ const result_type& operator()(const _Argument&) const { return _M_val; }
+};
+
+template <class _Result, class _Arg1, class _Arg2>
+struct _Constant_binary_fun {
+ typedef _Arg1 first_argument_type;
+ typedef _Arg2 second_argument_type;
+ typedef _Result result_type;
+ _Result _M_val;
+
+ _Constant_binary_fun(const _Result& __v) : _M_val(__v) {}
+ const result_type& operator()(const _Arg1&, const _Arg2&) const {
+ return _M_val;
+ }
+};
+
+// identity_element (not part of the C++ standard).
+template <class _Tp> inline _Tp __identity_element(plus<_Tp>) { return _Tp(0); }
+template <class _Tp> inline _Tp __identity_element(multiplies<_Tp>) { return _Tp(1); }
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_FUNCTION_BASE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_hash_fun.h b/sources/android/stlport/stlport/stl/_hash_fun.h
new file mode 100644
index 0000000..6197d7b
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_hash_fun.h
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_HASH_FUN_H
+#define _STLP_HASH_FUN_H
+
+#ifndef _STLP_INTERNAL_CSTDDEF
+# include <stl/_cstddef.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Key> struct hash { };
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+inline size_t __stl_hash_string(const char* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ unsigned long __h = 0;
+ for ( ; *__s; ++__s)
+ __h = 5*__h + *__s;
+
+ return size_t(__h);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_TEMPLATE_NULL
+struct hash<char*> {
+ size_t operator()(const char* __s) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return _STLP_PRIV __stl_hash_string(__s);
+ }
+};
+
+_STLP_TEMPLATE_NULL
+struct hash<const char*> {
+ size_t operator()(const char* __s) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return _STLP_PRIV __stl_hash_string(__s);
+ }
+};
+
+_STLP_TEMPLATE_NULL struct hash<char> {
+ size_t operator()(char __x) const { return __x; }
+};
+_STLP_TEMPLATE_NULL struct hash<unsigned char> {
+ size_t operator()(unsigned char __x) const { return __x; }
+};
+#if !defined (_STLP_NO_SIGNED_BUILTINS)
+_STLP_TEMPLATE_NULL struct hash<signed char> {
+ size_t operator()(unsigned char __x) const { return __x; }
+};
+#endif
+_STLP_TEMPLATE_NULL struct hash<short> {
+ size_t operator()(short __x) const { return __x; }
+};
+_STLP_TEMPLATE_NULL struct hash<unsigned short> {
+ size_t operator()(unsigned short __x) const { return __x; }
+};
+_STLP_TEMPLATE_NULL struct hash<int> {
+ size_t operator()(int __x) const { return __x; }
+};
+
+#if !defined (_STLP_MSVC) || (_STLP_MSVC < 1300) || defined (_WIN64)
+_STLP_TEMPLATE_NULL struct hash<unsigned int> {
+ size_t operator()(unsigned int __x) const { return __x; }
+};
+#else
+/* MSVC .Net since 2002 has a 64 bits portability warning feature. typedef
+ * like size_t are tagged as potential 64 bits variables making them different from
+ * unsigned int. To avoid the warning when a hash container is instanciated with
+ * the size_t key we prefer to grant the size_t specialization rather than the
+ * unsigned int one.
+ */
+_STLP_TEMPLATE_NULL struct hash<size_t> {
+ size_t operator()(size_t __x) const { return __x; }
+};
+#endif
+
+_STLP_TEMPLATE_NULL struct hash<long> {
+ size_t operator()(long __x) const { return __x; }
+};
+_STLP_TEMPLATE_NULL struct hash<unsigned long> {
+ size_t operator()(unsigned long __x) const { return __x; }
+};
+
+#if defined (_STLP_LONG_LONG)
+_STLP_TEMPLATE_NULL struct hash<_STLP_LONG_LONG> {
+ size_t operator()(_STLP_LONG_LONG x) const { return (size_t)x; }
+};
+_STLP_TEMPLATE_NULL struct hash<unsigned _STLP_LONG_LONG> {
+ size_t operator()(unsigned _STLP_LONG_LONG x) const { return (size_t)x; }
+};
+#endif
+
+_STLP_TEMPLATE_NULL
+struct hash<void *>
+{
+ union __vp {
+ size_t s;
+ void *p;
+ };
+
+ size_t operator()(void *__x) const
+ {
+ __vp vp;
+ vp.p = __x;
+ return vp.s;
+ }
+};
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_HASH_FUN_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_hash_map.h b/sources/android/stlport/stlport/stl/_hash_map.h
new file mode 100644
index 0000000..cd46603
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_hash_map.h
@@ -0,0 +1,500 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_HASH_MAP_H
+#define _STLP_INTERNAL_HASH_MAP_H
+
+#ifndef _STLP_INTERNAL_HASHTABLE_H
+# include <stl/_hashtable.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//Specific iterator traits creation
+_STLP_CREATE_HASH_ITERATOR_TRAITS(HashMapTraitsT, traits)
+
+template <class _Key, class _Tp, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Key>),
+ _STLP_DFL_TMPL_PARAM(_EqualKey,equal_to<_Key>),
+ _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_STLP_CONST _Key, _Tp) >
+class hash_map
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ : public __stlport_class<hash_map<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> >
+#endif
+{
+private:
+ typedef hash_map<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> _Self;
+public:
+ typedef _Key key_type;
+ typedef _Tp data_type;
+ typedef _Tp mapped_type;
+ typedef pair<_STLP_CONST key_type, data_type> value_type;
+private:
+ //Specific iterator traits creation
+ typedef _STLP_PRIV _HashMapTraitsT<value_type> _HashMapTraits;
+
+public:
+ typedef hashtable<value_type, key_type, _HashFcn, _HashMapTraits,
+ _STLP_SELECT1ST(value_type, _Key), _EqualKey, _Alloc > _Ht;
+
+ typedef typename _Ht::hasher hasher;
+ typedef typename _Ht::key_equal key_equal;
+
+ typedef typename _Ht::size_type size_type;
+ typedef typename _Ht::difference_type difference_type;
+ typedef typename _Ht::pointer pointer;
+ typedef typename _Ht::const_pointer const_pointer;
+ typedef typename _Ht::reference reference;
+ typedef typename _Ht::const_reference const_reference;
+
+ typedef typename _Ht::iterator iterator;
+ typedef typename _Ht::const_iterator const_iterator;
+
+ typedef typename _Ht::allocator_type allocator_type;
+
+ hasher hash_funct() const { return _M_ht.hash_funct(); }
+ key_equal key_eq() const { return _M_ht.key_eq(); }
+ allocator_type get_allocator() const { return _M_ht.get_allocator(); }
+
+private:
+ _Ht _M_ht;
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+public:
+ hash_map() : _M_ht(0, hasher(), key_equal(), allocator_type()) {}
+ explicit hash_map(size_type __n)
+ : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
+ hash_map(size_type __n, const hasher& __hf)
+ : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
+ hash_map(size_type __n, const hasher& __hf, const key_equal& __eql,
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ hash_map(__move_source<_Self> src)
+ : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {
+ }
+#endif
+
+#ifdef _STLP_MEMBER_TEMPLATES
+ template <class _InputIterator>
+ hash_map(_InputIterator __f, _InputIterator __l)
+ : _M_ht(0, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+ template <class _InputIterator>
+ hash_map(_InputIterator __f, _InputIterator __l, size_type __n)
+ : _M_ht(__n, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+ template <class _InputIterator>
+ hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
+ const hasher& __hf)
+ : _M_ht(__n, __hf, key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+# ifdef _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS
+ template <class _InputIterator>
+ hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
+ const hasher& __hf, const key_equal& __eql)
+ : _M_ht(__n, __hf, __eql, allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+# endif
+ template <class _InputIterator>
+ hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
+ const hasher& __hf, const key_equal& __eql,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_unique(__f, __l); }
+
+#else
+ hash_map(const value_type* __f, const value_type* __l)
+ : _M_ht(0, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+ hash_map(const value_type* __f, const value_type* __l, size_type __n)
+ : _M_ht(__n, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+ hash_map(const value_type* __f, const value_type* __l, size_type __n,
+ const hasher& __hf)
+ : _M_ht(__n, __hf, key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+ hash_map(const value_type* __f, const value_type* __l, size_type __n,
+ const hasher& __hf, const key_equal& __eql,
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_unique(__f, __l); }
+
+ hash_map(const_iterator __f, const_iterator __l)
+ : _M_ht(0, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+ hash_map(const_iterator __f, const_iterator __l, size_type __n)
+ : _M_ht(__n, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+ hash_map(const_iterator __f, const_iterator __l, size_type __n,
+ const hasher& __hf)
+ : _M_ht(__n, __hf, key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+ hash_map(const_iterator __f, const_iterator __l, size_type __n,
+ const hasher& __hf, const key_equal& __eql,
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_unique(__f, __l); }
+#endif /*_STLP_MEMBER_TEMPLATES */
+
+public:
+ size_type size() const { return _M_ht.size(); }
+ size_type max_size() const { return _M_ht.max_size(); }
+ bool empty() const { return _M_ht.empty(); }
+ void swap(_Self& __hs) { _M_ht.swap(__hs._M_ht); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+ iterator begin() { return _M_ht.begin(); }
+ iterator end() { return _M_ht.end(); }
+ const_iterator begin() const { return _M_ht.begin(); }
+ const_iterator end() const { return _M_ht.end(); }
+
+public:
+ pair<iterator,bool> insert(const value_type& __obj)
+ { return _M_ht.insert_unique(__obj); }
+#ifdef _STLP_MEMBER_TEMPLATES
+ template <class _InputIterator>
+ void insert(_InputIterator __f, _InputIterator __l)
+ { _M_ht.insert_unique(__f,__l); }
+#else
+ void insert(const value_type* __f, const value_type* __l)
+ { _M_ht.insert_unique(__f,__l); }
+ void insert(const_iterator __f, const_iterator __l)
+ { _M_ht.insert_unique(__f, __l); }
+#endif /*_STLP_MEMBER_TEMPLATES */
+ pair<iterator,bool> insert_noresize(const value_type& __obj)
+ { return _M_ht.insert_unique_noresize(__obj); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __key) { return _M_ht.find(__key); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ _Tp& operator[](const _KT& __key) {
+ iterator __it = _M_ht.find(__key);
+ return (__it == _M_ht.end() ?
+ _M_ht._M_insert(value_type(__key, _STLP_DEFAULT_CONSTRUCTED(_Tp))).second :
+ (*__it).second );
+ }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __key) const { return _M_ht.count(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator, iterator> equal_range(const _KT& __key)
+ { return _M_ht.equal_range(__key); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator> equal_range(const _KT& __key) const
+ { return _M_ht.equal_range(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type erase(const _KT& __key) {return _M_ht.erase(__key); }
+ void erase(iterator __it) { _M_ht.erase(__it); }
+ void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
+ void clear() { _M_ht.clear(); }
+
+ void resize(size_type __hint) { _M_ht.resize(__hint); }
+ size_type bucket_count() const { return _M_ht.bucket_count(); }
+ size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
+ size_type elems_in_bucket(size_type __n) const
+ { return _M_ht.elems_in_bucket(__n); }
+};
+
+//Specific iterator traits creation
+_STLP_CREATE_HASH_ITERATOR_TRAITS(HashMultimapTraitsT, traits)
+
+template <class _Key, class _Tp, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Key>),
+ _STLP_DFL_TMPL_PARAM(_EqualKey,equal_to<_Key>),
+ _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_STLP_CONST _Key, _Tp) >
+class hash_multimap
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ : public __stlport_class<hash_multimap<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> >
+#endif
+{
+private:
+ typedef hash_multimap<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> _Self;
+public:
+ typedef _Key key_type;
+ typedef _Tp data_type;
+ typedef _Tp mapped_type;
+ typedef pair<_STLP_CONST key_type, data_type> value_type;
+private:
+ //Specific iterator traits creation
+ typedef _STLP_PRIV _HashMultimapTraitsT<value_type> _HashMultimapTraits;
+
+public:
+ typedef hashtable<value_type, key_type, _HashFcn, _HashMultimapTraits,
+ _STLP_SELECT1ST(value_type, _Key), _EqualKey, _Alloc > _Ht;
+
+ typedef typename _Ht::hasher hasher;
+ typedef typename _Ht::key_equal key_equal;
+
+ typedef typename _Ht::size_type size_type;
+ typedef typename _Ht::difference_type difference_type;
+ typedef typename _Ht::pointer pointer;
+ typedef typename _Ht::const_pointer const_pointer;
+ typedef typename _Ht::reference reference;
+ typedef typename _Ht::const_reference const_reference;
+
+ typedef typename _Ht::iterator iterator;
+ typedef typename _Ht::const_iterator const_iterator;
+
+ typedef typename _Ht::allocator_type allocator_type;
+
+ hasher hash_funct() const { return _M_ht.hash_funct(); }
+ key_equal key_eq() const { return _M_ht.key_eq(); }
+ allocator_type get_allocator() const { return _M_ht.get_allocator(); }
+
+private:
+ _Ht _M_ht;
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+public:
+ hash_multimap() : _M_ht(0, hasher(), key_equal(), allocator_type()) {}
+ explicit hash_multimap(size_type __n)
+ : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
+ hash_multimap(size_type __n, const hasher& __hf)
+ : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
+ hash_multimap(size_type __n, const hasher& __hf, const key_equal& __eql,
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ hash_multimap(__move_source<_Self> src)
+ : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {
+ }
+#endif
+
+#ifdef _STLP_MEMBER_TEMPLATES
+ template <class _InputIterator>
+ hash_multimap(_InputIterator __f, _InputIterator __l)
+ : _M_ht(0, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+ template <class _InputIterator>
+ hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n)
+ : _M_ht(__n, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+ template <class _InputIterator>
+ hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
+ const hasher& __hf)
+ : _M_ht(__n, __hf, key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+# ifdef _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS
+ template <class _InputIterator>
+ hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
+ const hasher& __hf, const key_equal& __eql)
+ : _M_ht(__n, __hf, __eql, allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+# endif
+ template <class _InputIterator>
+ hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
+ const hasher& __hf, const key_equal& __eql,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_equal(__f, __l); }
+
+#else
+ hash_multimap(const value_type* __f, const value_type* __l)
+ : _M_ht(0, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+ hash_multimap(const value_type* __f, const value_type* __l, size_type __n)
+ : _M_ht(__n, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+ hash_multimap(const value_type* __f, const value_type* __l, size_type __n,
+ const hasher& __hf)
+ : _M_ht(__n, __hf, key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+ hash_multimap(const value_type* __f, const value_type* __l, size_type __n,
+ const hasher& __hf, const key_equal& __eql,
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_equal(__f, __l); }
+
+ hash_multimap(const_iterator __f, const_iterator __l)
+ : _M_ht(0, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+ hash_multimap(const_iterator __f, const_iterator __l, size_type __n)
+ : _M_ht(__n, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+ hash_multimap(const_iterator __f, const_iterator __l, size_type __n,
+ const hasher& __hf)
+ : _M_ht(__n, __hf, key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+ hash_multimap(const_iterator __f, const_iterator __l, size_type __n,
+ const hasher& __hf, const key_equal& __eql,
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_equal(__f, __l); }
+#endif /*_STLP_MEMBER_TEMPLATES */
+
+public:
+ size_type size() const { return _M_ht.size(); }
+ size_type max_size() const { return _M_ht.max_size(); }
+ bool empty() const { return _M_ht.empty(); }
+ void swap(_Self& __hs) { _M_ht.swap(__hs._M_ht); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+ iterator begin() { return _M_ht.begin(); }
+ iterator end() { return _M_ht.end(); }
+ const_iterator begin() const { return _M_ht.begin(); }
+ const_iterator end() const { return _M_ht.end(); }
+
+public:
+ iterator insert(const value_type& __obj)
+ { return _M_ht.insert_equal(__obj); }
+#ifdef _STLP_MEMBER_TEMPLATES
+ template <class _InputIterator>
+ void insert(_InputIterator __f, _InputIterator __l)
+ { _M_ht.insert_equal(__f,__l); }
+#else
+ void insert(const value_type* __f, const value_type* __l) {
+ _M_ht.insert_equal(__f,__l);
+ }
+ void insert(const_iterator __f, const_iterator __l)
+ { _M_ht.insert_equal(__f, __l); }
+#endif /*_STLP_MEMBER_TEMPLATES */
+ iterator insert_noresize(const value_type& __obj)
+ { return _M_ht.insert_equal_noresize(__obj); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __key) { return _M_ht.find(__key); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __key) const { return _M_ht.count(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator, iterator>
+ equal_range(const _KT& __key) { return _M_ht.equal_range(__key); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator>
+ equal_range(const _KT& __key) const { return _M_ht.equal_range(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type erase(const _KT& __key) {return _M_ht.erase(__key); }
+ void erase(iterator __it) { _M_ht.erase(__it); }
+ void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
+ void clear() { _M_ht.clear(); }
+
+public:
+ void resize(size_type __hint) { _M_ht.resize(__hint); }
+ size_type bucket_count() const { return _M_ht.bucket_count(); }
+ size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
+ size_type elems_in_bucket(size_type __n) const
+ { return _M_ht.elems_in_bucket(__n); }
+};
+
+#define _STLP_TEMPLATE_HEADER template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
+#define _STLP_TEMPLATE_CONTAINER hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>
+#include <stl/_relops_hash_cont.h>
+#undef _STLP_TEMPLATE_CONTAINER
+#define _STLP_TEMPLATE_CONTAINER hash_multimap<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>
+#include <stl/_relops_hash_cont.h>
+#undef _STLP_TEMPLATE_CONTAINER
+#undef _STLP_TEMPLATE_HEADER
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+# if !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
+struct __move_traits<hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> > :
+ _STLP_PRIV __move_traits_help<typename hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>::_Ht>
+{};
+
+template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
+struct __move_traits<hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> > :
+ _STLP_PRIV __move_traits_help<typename hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc>::_Ht>
+{};
+# endif
+
+// Specialization of insert_iterator so that it will work for hash_map
+// and hash_multimap.
+template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
+class insert_iterator<hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
+protected:
+ typedef hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container;
+ _Container* container;
+public:
+ typedef _Container container_type;
+ typedef output_iterator_tag iterator_category;
+ typedef void value_type;
+ typedef void difference_type;
+ typedef void pointer;
+ typedef void reference;
+
+ insert_iterator(_Container& __x) : container(&__x) {}
+ insert_iterator(_Container& __x, typename _Container::iterator)
+ : container(&__x) {}
+ insert_iterator<_Container>&
+ operator=(const typename _Container::value_type& __val) {
+ container->insert(__val);
+ return *this;
+ }
+ insert_iterator<_Container>& operator*() { return *this; }
+ insert_iterator<_Container>& operator++() { return *this; }
+ insert_iterator<_Container>& operator++(int) { return *this; }
+};
+
+template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
+class insert_iterator<hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
+protected:
+ typedef hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container;
+ _Container* container;
+ typename _Container::iterator iter;
+public:
+ typedef _Container container_type;
+ typedef output_iterator_tag iterator_category;
+ typedef void value_type;
+ typedef void difference_type;
+ typedef void pointer;
+ typedef void reference;
+
+ insert_iterator(_Container& __x) : container(&__x) {}
+ insert_iterator(_Container& __x, typename _Container::iterator)
+ : container(&__x) {}
+ insert_iterator<_Container>&
+ operator=(const typename _Container::value_type& __val) {
+ container->insert(__val);
+ return *this;
+ }
+ insert_iterator<_Container>& operator*() { return *this; }
+ insert_iterator<_Container>& operator++() { return *this; }
+ insert_iterator<_Container>& operator++(int) { return *this; }
+};
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_HASH_MAP_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_hash_set.h b/sources/android/stlport/stlport/stl/_hash_set.h
new file mode 100644
index 0000000..29b168b
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_hash_set.h
@@ -0,0 +1,495 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_HASH_SET_H
+#define _STLP_INTERNAL_HASH_SET_H
+
+#ifndef _STLP_INTERNAL_HASHTABLE_H
+# include <stl/_hashtable.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//Specific iterator traits creation
+_STLP_CREATE_HASH_ITERATOR_TRAITS(HashSetTraitsT, Const_traits)
+
+template <class _Value, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Value>),
+ _STLP_DFL_TMPL_PARAM(_EqualKey, equal_to<_Value>),
+ _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Value>) >
+class hash_set
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ : public __stlport_class<hash_set<_Value, _HashFcn, _EqualKey, _Alloc> >
+#endif
+{
+ typedef hash_set<_Value, _HashFcn, _EqualKey, _Alloc> _Self;
+ //Specific iterator traits creation
+ typedef _STLP_PRIV _HashSetTraitsT<_Value> _HashSetTraits;
+public:
+ typedef hashtable<_Value, _Value, _HashFcn,
+ _HashSetTraits, _STLP_PRIV _Identity<_Value>, _EqualKey, _Alloc> _Ht;
+public:
+ typedef typename _Ht::key_type key_type;
+ typedef typename _Ht::value_type value_type;
+ typedef typename _Ht::hasher hasher;
+ typedef typename _Ht::key_equal key_equal;
+
+ typedef typename _Ht::size_type size_type;
+ typedef typename _Ht::difference_type difference_type;
+ typedef typename _Ht::pointer pointer;
+ typedef typename _Ht::const_pointer const_pointer;
+ typedef typename _Ht::reference reference;
+ typedef typename _Ht::const_reference const_reference;
+
+ typedef typename _Ht::iterator iterator;
+ typedef typename _Ht::const_iterator const_iterator;
+
+ typedef typename _Ht::allocator_type allocator_type;
+
+ hasher hash_funct() const { return _M_ht.hash_funct(); }
+ key_equal key_eq() const { return _M_ht.key_eq(); }
+ allocator_type get_allocator() const { return _M_ht.get_allocator(); }
+
+private:
+ _Ht _M_ht;
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+public:
+ hash_set()
+ : _M_ht(0, hasher(), key_equal(), allocator_type()) {}
+ explicit hash_set(size_type __n)
+ : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
+ hash_set(size_type __n, const hasher& __hf)
+ : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
+ const allocator_type& __a = allocator_type())
+#else
+ hash_set(size_type __n, const hasher& __hf, const key_equal& __eql)
+ : _M_ht(__n, __hf, __eql, allocator_type()) {}
+ hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
+ const allocator_type& __a)
+#endif
+ : _M_ht(__n, __hf, __eql, __a) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ hash_set(__move_source<_Self> src)
+ : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {}
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ hash_set(_InputIterator __f, _InputIterator __l)
+ : _M_ht(0, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+ template <class _InputIterator>
+ hash_set(_InputIterator __f, _InputIterator __l, size_type __n)
+ : _M_ht(__n, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+ template <class _InputIterator>
+ hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
+ const hasher& __hf)
+ : _M_ht(__n, __hf, key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+ template <class _InputIterator>
+ hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
+ const hasher& __hf, const key_equal& __eql,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_unique(__f, __l); }
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
+ const hasher& __hf, const key_equal& __eql)
+ : _M_ht(__n, __hf, __eql, allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+# endif
+#else
+ hash_set(const value_type* __f, const value_type* __l)
+ : _M_ht(0, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+ hash_set(const value_type* __f, const value_type* __l, size_type __n)
+ : _M_ht(__n, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+ hash_set(const value_type* __f, const value_type* __l, size_type __n,
+ const hasher& __hf)
+ : _M_ht(__n, __hf, key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+ hash_set(const value_type* __f, const value_type* __l, size_type __n,
+ const hasher& __hf, const key_equal& __eql,
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_unique(__f, __l); }
+
+ hash_set(const_iterator __f, const_iterator __l)
+ : _M_ht(0, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+ hash_set(const_iterator __f, const_iterator __l, size_type __n)
+ : _M_ht(__n, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+ hash_set(const_iterator __f, const_iterator __l, size_type __n,
+ const hasher& __hf)
+ : _M_ht(__n, __hf, key_equal(), allocator_type())
+ { _M_ht.insert_unique(__f, __l); }
+ hash_set(const_iterator __f, const_iterator __l, size_type __n,
+ const hasher& __hf, const key_equal& __eql,
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_unique(__f, __l); }
+#endif /*_STLP_MEMBER_TEMPLATES */
+
+public:
+ size_type size() const { return _M_ht.size(); }
+ size_type max_size() const { return _M_ht.max_size(); }
+ bool empty() const { return _M_ht.empty(); }
+ void swap(_Self& __hs) { _M_ht.swap(__hs._M_ht); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+ iterator begin() { return _M_ht.begin(); }
+ iterator end() { return _M_ht.end(); }
+ const_iterator begin() const { return _M_ht.begin(); }
+ const_iterator end() const { return _M_ht.end(); }
+
+public:
+ pair<iterator, bool> insert(const value_type& __obj)
+ { return _M_ht.insert_unique(__obj); }
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void insert(_InputIterator __f, _InputIterator __l)
+#else
+ void insert(const_iterator __f, const_iterator __l)
+ {_M_ht.insert_unique(__f, __l); }
+ void insert(const value_type* __f, const value_type* __l)
+#endif
+ { _M_ht.insert_unique(__f,__l); }
+
+ pair<iterator, bool> insert_noresize(const value_type& __obj)
+ { return _M_ht.insert_unique_noresize(__obj); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __key) { return _M_ht.find(__key); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __key) const { return _M_ht.count(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator, iterator> equal_range(const _KT& __key)
+ { return _M_ht.equal_range(__key); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator> equal_range(const _KT& __key) const
+ { return _M_ht.equal_range(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type erase(const _KT& __key) {return _M_ht.erase(__key); }
+ void erase(iterator __it) { _M_ht.erase(__it); }
+ void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
+ void clear() { _M_ht.clear(); }
+
+public:
+ void resize(size_type __hint) { _M_ht.resize(__hint); }
+ size_type bucket_count() const { return _M_ht.bucket_count(); }
+ size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
+ size_type elems_in_bucket(size_type __n) const
+ { return _M_ht.elems_in_bucket(__n); }
+};
+
+//Specific iterator traits creation
+_STLP_CREATE_HASH_ITERATOR_TRAITS(HashMultisetTraitsT, Const_traits)
+
+template <class _Value, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Value>),
+ _STLP_DFL_TMPL_PARAM(_EqualKey, equal_to<_Value>),
+ _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Value>) >
+class hash_multiset
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ : public __stlport_class<hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> >
+#endif
+{
+ typedef hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> _Self;
+ //Specific iterator traits creation
+ typedef _STLP_PRIV _HashMultisetTraitsT<_Value> _HashMultisetTraits;
+public:
+ typedef hashtable<_Value, _Value, _HashFcn,
+ _HashMultisetTraits, _STLP_PRIV _Identity<_Value>, _EqualKey, _Alloc> _Ht;
+
+ typedef typename _Ht::key_type key_type;
+ typedef typename _Ht::value_type value_type;
+ typedef typename _Ht::hasher hasher;
+ typedef typename _Ht::key_equal key_equal;
+
+ typedef typename _Ht::size_type size_type;
+ typedef typename _Ht::difference_type difference_type;
+ typedef typename _Ht::pointer pointer;
+ typedef typename _Ht::const_pointer const_pointer;
+ typedef typename _Ht::reference reference;
+ typedef typename _Ht::const_reference const_reference;
+
+ typedef typename _Ht::iterator iterator;
+ typedef typename _Ht::const_iterator const_iterator;
+
+ typedef typename _Ht::allocator_type allocator_type;
+
+ hasher hash_funct() const { return _M_ht.hash_funct(); }
+ key_equal key_eq() const { return _M_ht.key_eq(); }
+ allocator_type get_allocator() const { return _M_ht.get_allocator(); }
+
+private:
+ _Ht _M_ht;
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+public:
+ hash_multiset()
+ : _M_ht(0, hasher(), key_equal(), allocator_type()) {}
+ explicit hash_multiset(size_type __n)
+ : _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
+ hash_multiset(size_type __n, const hasher& __hf)
+ : _M_ht(__n, __hf, key_equal(), allocator_type()) {}
+ hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql)
+ : _M_ht(__n, __hf, __eql, allocator_type()) {}
+ hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql,
+ const allocator_type& __a)
+ : _M_ht(__n, __hf, __eql, __a) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ hash_multiset(__move_source<_Self> src)
+ : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {}
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ hash_multiset(_InputIterator __f, _InputIterator __l)
+ : _M_ht(0, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+ template <class _InputIterator>
+ hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n)
+ : _M_ht(__n, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+ template <class _InputIterator>
+ hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
+ const hasher& __hf)
+ : _M_ht(__n, __hf, key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+
+ template <class _InputIterator>
+ hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
+ const hasher& __hf, const key_equal& __eql,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_equal(__f, __l); }
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
+ const hasher& __hf, const key_equal& __eql)
+ : _M_ht(__n, __hf, __eql, allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+# endif
+#else
+ hash_multiset(const value_type* __f, const value_type* __l)
+ : _M_ht(0, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+ hash_multiset(const value_type* __f, const value_type* __l, size_type __n)
+ : _M_ht(__n, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+ hash_multiset(const value_type* __f, const value_type* __l, size_type __n,
+ const hasher& __hf)
+ : _M_ht(__n, __hf, key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+ hash_multiset(const value_type* __f, const value_type* __l, size_type __n,
+ const hasher& __hf, const key_equal& __eql,
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_equal(__f, __l); }
+
+ hash_multiset(const_iterator __f, const_iterator __l)
+ : _M_ht(0, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+ hash_multiset(const_iterator __f, const_iterator __l, size_type __n)
+ : _M_ht(__n, hasher(), key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+ hash_multiset(const_iterator __f, const_iterator __l, size_type __n,
+ const hasher& __hf)
+ : _M_ht(__n, __hf, key_equal(), allocator_type())
+ { _M_ht.insert_equal(__f, __l); }
+ hash_multiset(const_iterator __f, const_iterator __l, size_type __n,
+ const hasher& __hf, const key_equal& __eql,
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_equal(__f, __l); }
+#endif /*_STLP_MEMBER_TEMPLATES */
+
+public:
+ size_type size() const { return _M_ht.size(); }
+ size_type max_size() const { return _M_ht.max_size(); }
+ bool empty() const { return _M_ht.empty(); }
+ void swap(_Self& hs) { _M_ht.swap(hs._M_ht); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+ iterator begin() { return _M_ht.begin(); }
+ iterator end() { return _M_ht.end(); }
+ const_iterator begin() const { return _M_ht.begin(); }
+ const_iterator end() const { return _M_ht.end(); }
+
+public:
+ iterator insert(const value_type& __obj) { return _M_ht.insert_equal(__obj); }
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void insert(_InputIterator __f, _InputIterator __l)
+ { _M_ht.insert_equal(__f,__l); }
+#else
+ void insert(const value_type* __f, const value_type* __l)
+ { _M_ht.insert_equal(__f,__l); }
+ void insert(const_iterator __f, const_iterator __l)
+ { _M_ht.insert_equal(__f, __l); }
+#endif /*_STLP_MEMBER_TEMPLATES */
+ iterator insert_noresize(const value_type& __obj)
+ { return _M_ht.insert_equal_noresize(__obj); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __key) { return _M_ht.find(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __key) const { return _M_ht.count(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator, iterator> equal_range(const _KT& __key)
+ { return _M_ht.equal_range(__key); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator> equal_range(const _KT& __key) const
+ { return _M_ht.equal_range(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type erase(const _KT& __key) {return _M_ht.erase(__key); }
+ void erase(iterator __it) { _M_ht.erase(__it); }
+ void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
+ void clear() { _M_ht.clear(); }
+
+public:
+ void resize(size_type __hint) { _M_ht.resize(__hint); }
+ size_type bucket_count() const { return _M_ht.bucket_count(); }
+ size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
+ size_type elems_in_bucket(size_type __n) const
+ { return _M_ht.elems_in_bucket(__n); }
+};
+
+#define _STLP_TEMPLATE_HEADER template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+#define _STLP_TEMPLATE_CONTAINER hash_set<_Value,_HashFcn,_EqualKey,_Alloc>
+
+#include <stl/_relops_hash_cont.h>
+
+#undef _STLP_TEMPLATE_CONTAINER
+#define _STLP_TEMPLATE_CONTAINER hash_multiset<_Value,_HashFcn,_EqualKey,_Alloc>
+#include <stl/_relops_hash_cont.h>
+
+#undef _STLP_TEMPLATE_CONTAINER
+#undef _STLP_TEMPLATE_HEADER
+
+// Specialization of insert_iterator so that it will work for hash_set
+// and hash_multiset.
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+# if !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+struct __move_traits<hash_set<_Value, _HashFcn, _EqualKey, _Alloc> > :
+ _STLP_PRIV __move_traits_aux<typename hash_set<_Value, _HashFcn, _EqualKey, _Alloc>::_Ht>
+{};
+
+template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+struct __move_traits<hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> > :
+ _STLP_PRIV __move_traits_aux<typename hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>::_Ht>
+{};
+# endif
+
+template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+class insert_iterator<hash_set<_Value, _HashFcn, _EqualKey, _Alloc> > {
+protected:
+ typedef hash_set<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
+ _Container* container;
+public:
+ typedef _Container container_type;
+ typedef output_iterator_tag iterator_category;
+ typedef void value_type;
+ typedef void difference_type;
+ typedef void pointer;
+ typedef void reference;
+
+ insert_iterator(_Container& __x) : container(&__x) {}
+ insert_iterator(_Container& __x, typename _Container::iterator)
+ : container(&__x) {}
+ insert_iterator<_Container>&
+ operator=(const typename _Container::value_type& __val) {
+ container->insert(__val);
+ return *this;
+ }
+ insert_iterator<_Container>& operator*() { return *this; }
+ insert_iterator<_Container>& operator++() { return *this; }
+ insert_iterator<_Container>& operator++(int) { return *this; }
+};
+
+template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+class insert_iterator<hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> > {
+protected:
+ typedef hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
+ _Container* container;
+ typename _Container::iterator iter;
+public:
+ typedef _Container container_type;
+ typedef output_iterator_tag iterator_category;
+ typedef void value_type;
+ typedef void difference_type;
+ typedef void pointer;
+ typedef void reference;
+
+ insert_iterator(_Container& __x) : container(&__x) {}
+ insert_iterator(_Container& __x, typename _Container::iterator)
+ : container(&__x) {}
+ insert_iterator<_Container>&
+ operator=(const typename _Container::value_type& __val) {
+ container->insert(__val);
+ return *this;
+ }
+ insert_iterator<_Container>& operator*() { return *this; }
+ insert_iterator<_Container>& operator++() { return *this; }
+ insert_iterator<_Container>& operator++(int) { return *this; }
+};
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_HASH_SET_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_hashtable.c b/sources/android/stlport/stlport/stl/_hashtable.c
new file mode 100644
index 0000000..b743156
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_hashtable.c
@@ -0,0 +1,553 @@
+/*
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_HASHTABLE_C
+#define _STLP_HASHTABLE_C
+
+#ifndef _STLP_INTERNAL_HASHTABLE_H
+# include <stl/_hashtable.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+# define __PRIME_LIST_BODY { \
+ 7ul, 23ul, \
+ 53ul, 97ul, 193ul, 389ul, 769ul, \
+ 1543ul, 3079ul, 6151ul, 12289ul, 24593ul, \
+ 49157ul, 98317ul, 196613ul, 393241ul, 786433ul, \
+ 1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul, \
+ 50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,\
+ 1610612741ul, 3221225473ul, 4294967291ul \
+}
+
+template <class _Dummy>
+const size_t* _STLP_CALL
+_Stl_prime<_Dummy>::_S_primes(size_t &__size) {
+ static const size_t _list[] = __PRIME_LIST_BODY;
+# ifndef __MWERKS__
+ __size = sizeof(_list) / sizeof(_list[0]);
+# else
+ __size = 30;
+# endif
+ return _list;
+}
+
+template <class _Dummy>
+size_t _STLP_CALL
+_Stl_prime<_Dummy>::_S_max_nb_buckets() {
+ size_t __size;
+ const size_t* __first = _S_primes(__size);
+ return *(__first + __size - 1);
+}
+
+template <class _Dummy>
+size_t _STLP_CALL
+_Stl_prime<_Dummy>::_S_next_size(size_t __n) {
+ size_t __size;
+ const size_t* __first = _S_primes(__size);
+ const size_t* __last = __first + __size;
+ const size_t* pos = __lower_bound(__first, __last, __n,
+ __less((size_t*)0), __less((size_t*)0), (ptrdiff_t*)0);
+ return (pos == __last ? *(__last - 1) : *pos);
+}
+
+template <class _Dummy>
+void _STLP_CALL
+_Stl_prime<_Dummy>::_S_prev_sizes(size_t __n, size_t const*&__begin, size_t const*&__pos) {
+ size_t __size;
+ __begin = _S_primes(__size);
+ const size_t* __last = __begin + __size;
+ __pos = __lower_bound(__begin, __last, __n,
+ __less((size_t*)0), __less((size_t*)0), (ptrdiff_t*)0);
+
+ if (__pos== __last)
+ --__pos;
+ else if (*__pos == __n) {
+ if (__pos != __begin)
+ --__pos;
+ }
+}
+
+# undef __PRIME_LIST_BODY
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#endif
+
+#if defined (_STLP_DEBUG)
+# define hashtable _STLP_NON_DBG_NAME(hashtable)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+// fbp: these defines are for outline methods definitions.
+// needed to definitions to be portable. Should not be used in method bodies.
+
+#if defined ( _STLP_NESTED_TYPE_PARAM_BUG )
+# define __size_type__ size_t
+# define size_type size_t
+# define value_type _Val
+# define key_type _Key
+# define __reference__ _Val&
+
+# define __iterator__ _Ht_iterator<_Val, _STLP_HEADER_TYPENAME _Traits::_NonConstTraits, \
+ _Key, _HF, _ExK, _EqK, _All>
+# define __const_iterator__ _Ht_iterator<_Val, _STLP_HEADER_TYPENAME _Traits::_ConstTraits, \
+ _Key, _HF, _ExK, _EqK, _All>
+#else
+# define __size_type__ _STLP_TYPENAME_ON_RETURN_TYPE hashtable<_Val, _Key, _HF, _Traits, _ExK, _EqK, _All>::size_type
+# define __reference__ _STLP_TYPENAME_ON_RETURN_TYPE hashtable<_Val, _Key, _HF, _Traits, _ExK, _EqK, _All>::reference
+# define __iterator__ _STLP_TYPENAME_ON_RETURN_TYPE hashtable<_Val, _Key, _HF, _Traits, _ExK, _EqK, _All>::iterator
+# define __const_iterator__ _STLP_TYPENAME_ON_RETURN_TYPE hashtable<_Val, _Key, _HF, _Traits, _ExK, _EqK, _All>::const_iterator
+#endif
+
+/*
+ * This method is too difficult to implement for hashtable that do not
+ * require a sorted operation on the stored type.
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+bool hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>::_M_equal(
+ const hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>& __ht1,
+ const hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>& __ht2) {
+ return __ht1._M_buckets == __ht2._M_buckets &&
+ __ht1._M_elems == __ht2._M_elems;
+}
+*/
+
+/* Returns the iterator before the first iterator of the bucket __n and set
+ * __n to the first previous bucket having the same first iterator as bucket
+ * __n.
+ */
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+__iterator__
+hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+ ::_M_before_begin(size_type &__n) const {
+ return _S_before_begin(_M_elems, _M_buckets, __n);
+}
+
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+__iterator__
+hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+ ::_S_before_begin(const _ElemsCont& __elems, const _BucketVector& __buckets,
+ size_type &__n) {
+ _ElemsCont &__mutable_elems = __CONST_CAST(_ElemsCont&, __elems);
+ typename _BucketVector::const_iterator __bpos(__buckets.begin() + __n);
+
+ _ElemsIte __pos(*__bpos);
+ if (__pos == __mutable_elems.begin()) {
+ __n = 0;
+ return __mutable_elems.before_begin();
+ }
+
+ typename _BucketVector::const_iterator __bcur(__bpos);
+ _BucketType *__pos_node = __pos._M_node;
+ for (--__bcur; __pos_node == *__bcur; --__bcur);
+
+ __n = __bcur - __buckets.begin() + 1;
+ _ElemsIte __cur(*__bcur);
+ _ElemsIte __prev = __cur++;
+ for (; __cur != __pos; ++__prev, ++__cur);
+ return __prev;
+}
+
+
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+__iterator__
+hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+ ::_M_insert_noresize(size_type __n, const value_type& __obj) {
+ //We always insert this element as 1st in the bucket to not break
+ //the elements order as equal elements must be kept next to each other.
+ size_type __prev = __n;
+ _ElemsIte __pos = _M_before_begin(__prev)._M_ite;
+
+ fill(_M_buckets.begin() + __prev, _M_buckets.begin() + __n + 1,
+ _M_elems.insert_after(__pos, __obj)._M_node);
+ ++_M_num_elements;
+ return iterator(_ElemsIte(_M_buckets[__n]));
+}
+
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+pair<__iterator__, bool>
+hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+ ::insert_unique_noresize(const value_type& __obj) {
+ const size_type __n = _M_bkt_num(__obj);
+ _ElemsIte __cur(_M_buckets[__n]);
+ _ElemsIte __last(_M_buckets[__n + 1]);
+
+ if (__cur != __last) {
+ for (; __cur != __last; ++__cur) {
+ if (_M_equals(_M_get_key(*__cur), _M_get_key(__obj))) {
+ //We check that equivalent keys have equals hash code as otherwise, on resize,
+ //equivalent value might not be in the same bucket
+ _STLP_ASSERT(_M_hash(_M_get_key(*__cur)) == _M_hash(_M_get_key(__obj)))
+ return pair<iterator, bool>(iterator(__cur), false);
+ }
+ }
+ /* Here we do not rely on the _M_insert_noresize method as we know
+ * that we cannot break element orders, elements are unique, and
+ * insertion after the first bucket element is faster than what is
+ * done in _M_insert_noresize.
+ */
+ __cur = _M_elems.insert_after(_ElemsIte(_M_buckets[__n]), __obj);
+ ++_M_num_elements;
+ return pair<iterator, bool>(iterator(__cur), true);
+ }
+
+ return pair<iterator, bool>(_M_insert_noresize(__n, __obj), true);
+}
+
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+__iterator__
+hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+ ::insert_equal_noresize(const value_type& __obj) {
+ const size_type __n = _M_bkt_num(__obj);
+ {
+ _ElemsIte __cur(_M_buckets[__n]);
+ _ElemsIte __last(_M_buckets[__n + 1]);
+
+ for (; __cur != __last; ++__cur) {
+ if (_M_equals(_M_get_key(*__cur), _M_get_key(__obj))) {
+ //We check that equivalent keys have equals hash code as otherwise, on resize,
+ //equivalent value might not be in the same bucket
+ _STLP_ASSERT(_M_hash(_M_get_key(*__cur)) == _M_hash(_M_get_key(__obj)))
+ ++_M_num_elements;
+ return _M_elems.insert_after(__cur, __obj);
+ }
+ }
+ }
+
+ return _M_insert_noresize(__n, __obj);
+}
+
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+__reference__
+hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+ ::_M_insert(const value_type& __obj) {
+ _M_enlarge(_M_num_elements + 1);
+ return *insert_unique_noresize(__obj).first;
+}
+
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+__size_type__
+hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+ ::erase(const key_type& __key) {
+ const size_type __n = _M_bkt_num_key(__key);
+
+ _ElemsIte __cur(_M_buckets[__n]);
+ _ElemsIte __last(_M_buckets[__n + 1]);
+ if (__cur == __last)
+ return 0;
+
+ size_type __erased = 0;
+ if (_M_equals(_M_get_key(*__cur), __key)) {
+ //We look for the pos before __cur:
+ size_type __prev_b = __n;
+ _ElemsIte __prev = _M_before_begin(__prev_b)._M_ite;
+ do {
+ __cur = _M_elems.erase_after(__prev);
+ ++__erased;
+ } while ((__cur != __last) && _M_equals(_M_get_key(*__cur), __key));
+ fill(_M_buckets.begin() + __prev_b, _M_buckets.begin() + __n + 1, __cur._M_node);
+ }
+ else {
+ _ElemsIte __prev = __cur++;
+ for (; __cur != __last; ++__prev, ++__cur) {
+ if (_M_equals(_M_get_key(*__cur), __key)) {
+ do {
+ __cur = _M_elems.erase_after(__prev);
+ ++__erased;
+ } while ((__cur != __last) && _M_equals(_M_get_key(*__cur), __key));
+ break;
+ }
+ }
+ }
+
+ _M_num_elements -= __erased;
+ _M_reduce();
+ return __erased;
+}
+
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+ ::erase(const_iterator __it) {
+ const size_type __n = _M_bkt_num(*__it);
+ _ElemsIte __cur(_M_buckets[__n]);
+
+ size_type __erased = 0;
+ if (__cur == __it._M_ite) {
+ size_type __prev_b = __n;
+ _ElemsIte __prev = _M_before_begin(__prev_b)._M_ite;
+ fill(_M_buckets.begin() + __prev_b, _M_buckets.begin() + __n + 1,
+ _M_elems.erase_after(__prev)._M_node);
+ ++__erased;
+ }
+ else {
+ _ElemsIte __prev = __cur++;
+ _ElemsIte __last(_M_buckets[__n + 1]);
+ for (; __cur != __last; ++__prev, ++__cur) {
+ if (__cur == __it._M_ite) {
+ _M_elems.erase_after(__prev);
+ ++__erased;
+ break;
+ }
+ }
+ }
+
+ _M_num_elements -= __erased;
+ _M_reduce();
+}
+
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+ ::erase(const_iterator __first, const_iterator __last) {
+ if (__first == __last)
+ return;
+ size_type __f_bucket = _M_bkt_num(*__first);
+ size_type __l_bucket = __last != end() ? _M_bkt_num(*__last) : (_M_buckets.size() - 1);
+
+ _ElemsIte __cur(_M_buckets[__f_bucket]);
+ _ElemsIte __prev;
+ if (__cur == __first._M_ite) {
+ __prev = _M_before_begin(__f_bucket)._M_ite;
+ }
+ else {
+ _ElemsIte __last(_M_buckets[++__f_bucket]);
+ __prev = __cur++;
+ for (; (__cur != __last) && (__cur != __first._M_ite); ++__prev, ++__cur);
+ }
+ size_type __erased = 0;
+ //We do not use the slist::erase_after method taking a range to count the
+ //number of erased elements:
+ while (__cur != __last._M_ite) {
+ __cur = _M_elems.erase_after(__prev);
+ ++__erased;
+ }
+ fill(_M_buckets.begin() + __f_bucket, _M_buckets.begin() + __l_bucket + 1, __cur._M_node);
+ _M_num_elements -= __erased;
+ _M_reduce();
+}
+
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+ ::rehash(size_type __num_buckets_hint) {
+ if (bucket_count() >= __num_buckets_hint) {
+ // We are trying to reduce number of buckets, we have to validate it:
+ size_type __limit_num_buckets = (size_type)((float)size() / max_load_factor());
+ if (__num_buckets_hint < __limit_num_buckets) {
+ // Targetted number of buckets __num_buckets_hint would break
+ // load_factor() <= max_load_factor() rule.
+ return;
+ }
+ }
+
+ _M_rehash(__num_buckets_hint);
+}
+
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+ ::_M_enlarge(size_type __to_size) {
+ size_type __num_buckets = bucket_count();
+ size_type __num_buckets_hint = (size_type)((float)__to_size / max_load_factor());
+ if (__num_buckets_hint <= __num_buckets) {
+ return;
+ }
+ __num_buckets = _STLP_PRIV _Stl_prime_type::_S_next_size(__num_buckets_hint);
+
+ _M_rehash(__num_buckets);
+}
+
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+ ::_M_reduce() {
+ size_type __num_buckets = bucket_count();
+ // We only try to reduce the hashtable if the theorical load factor
+ // is lower than a fraction of the max load factor:
+ // 4 factor is coming from the fact that prime number list is almost a
+ // geometrical suite with reason 2, as we try to jump 2 levels is means
+ // a 4 factor.
+ if ((float)size() / (float)__num_buckets > max_load_factor() / 4.0f)
+ return;
+
+ const size_type *__first;
+ const size_type *__prev;
+ _STLP_PRIV _Stl_prime_type::_S_prev_sizes(__num_buckets, __first, __prev);
+
+ /* We are only going to reduce number of buckets if moving to yet the previous number
+ * of buckets in the prime numbers would respect the load rule. Otherwise algorithm
+ * successively removing and adding an element would each time perform an expensive
+ * rehash operation. */
+ const size_type *__prev_prev = __prev;
+ if (__prev_prev != __first) {
+ --__prev_prev;
+ if ((float)size() / (float)*__prev_prev > max_load_factor())
+ return;
+ }
+ else {
+ if (*__prev >= __num_buckets)
+ return;
+ }
+
+ // Can we reduce further:
+ while (__prev_prev != __first) {
+ --__prev_prev;
+ if ((float)size() / (float)*__prev_prev > max_load_factor())
+ // We cannot reduce further.
+ break;
+ --__prev;
+ }
+
+ _M_rehash(*__prev);
+}
+
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+ ::_M_resize() {
+ if (load_factor() > max_load_factor()) {
+ // We have to enlarge
+ _M_enlarge(size());
+ }
+ else {
+ // We can try to reduce size:
+ _M_reduce();
+ }
+}
+
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+ ::_M_rehash(size_type __num_buckets) {
+#if defined (_STLP_DEBUG)
+ _M_check();
+#endif
+ _ElemsCont __tmp_elems(_M_elems.get_allocator());
+ _BucketVector __tmp(__num_buckets + 1, __STATIC_CAST(_BucketType*, 0), _M_buckets.get_allocator());
+ _ElemsIte __cur, __last(_M_elems.end());
+ while (!_M_elems.empty()) {
+ __cur = _M_elems.begin();
+ size_type __new_bucket = _M_bkt_num(*__cur, __num_buckets);
+ _ElemsIte __ite(__cur), __before_ite(__cur);
+ for (++__ite;
+ __ite != __last && _M_equals(_M_get_key(*__cur), _M_get_key(*__ite));
+ ++__ite, ++__before_ite);
+ size_type __prev_bucket = __new_bucket;
+ _ElemsIte __prev = _S_before_begin(__tmp_elems, __tmp, __prev_bucket)._M_ite;
+ __tmp_elems.splice_after(__prev, _M_elems, _M_elems.before_begin(), __before_ite);
+ fill(__tmp.begin() + __prev_bucket, __tmp.begin() + __new_bucket + 1, __cur._M_node);
+ }
+ _M_elems.swap(__tmp_elems);
+ _M_buckets.swap(__tmp);
+}
+
+#if defined (_STLP_DEBUG)
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>::_M_check() const {
+ //We check that hash code of stored keys haven't change and also that equivalent
+ //relation hasn't been modified
+ size_t __num_buckets = bucket_count();
+ for (size_t __b = 0; __b < __num_buckets; ++__b) {
+ _ElemsIte __cur(_M_buckets[__b]), __last(_M_buckets[__b + 1]);
+ _ElemsIte __fst(__cur), __snd(__cur);
+ for (; __cur != __last; ++__cur) {
+ _STLP_ASSERT( _M_bkt_num(*__cur, __num_buckets) == __b )
+ _STLP_ASSERT( !_M_equals(_M_get_key(*__fst), _M_get_key(*__cur)) || _M_equals(_M_get_key(*__snd), _M_get_key(*__cur)) )
+ if (__fst != __snd)
+ ++__fst;
+ if (__snd != __cur)
+ ++__snd;
+ }
+ }
+}
+#endif
+
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>::clear() {
+ _M_elems.clear();
+ _M_buckets.assign(_M_buckets.size(), __STATIC_CAST(_BucketType*, 0));
+ _M_num_elements = 0;
+}
+
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+void hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+ ::_M_copy_from(const hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>& __ht) {
+ _M_elems.clear();
+ _M_elems.insert(_M_elems.end(), __ht._M_elems.begin(), __ht._M_elems.end());
+ _M_buckets.resize(__ht._M_buckets.size());
+ _ElemsConstIte __src(__ht._M_elems.begin()), __src_end(__ht._M_elems.end());
+ _ElemsIte __dst(_M_elems.begin());
+ typename _BucketVector::const_iterator __src_b(__ht._M_buckets.begin()),
+ __src_end_b(__ht._M_buckets.end());
+ typename _BucketVector::iterator __dst_b(_M_buckets.begin()), __dst_end_b(_M_buckets.end());
+ for (; __src != __src_end; ++__src, ++__dst) {
+ for (; __src_b != __src_end_b; ++__src_b, ++__dst_b) {
+ if (*__src_b == __src._M_node) {
+ *__dst_b = __dst._M_node;
+ }
+ else
+ break;
+ }
+ }
+ fill(__dst_b, __dst_end_b, __STATIC_CAST(_BucketType*, 0));
+ _M_num_elements = __ht._M_num_elements;
+ _M_max_load_factor = __ht._M_max_load_factor;
+}
+
+#undef __iterator__
+#undef const_iterator
+#undef __size_type__
+#undef __reference__
+#undef size_type
+#undef value_type
+#undef key_type
+#undef __stl_num_primes
+
+#if defined (_STLP_DEBUG)
+# undef hashtable
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_HASHTABLE_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_hashtable.h b/sources/android/stlport/stlport/stl/_hashtable.h
new file mode 100644
index 0000000..1c8e2f5
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_hashtable.h
@@ -0,0 +1,658 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_HASHTABLE_H
+#define _STLP_INTERNAL_HASHTABLE_H
+
+#ifndef _STLP_INTERNAL_VECTOR_H
+# include <stl/_vector.h>
+#endif
+
+#ifndef _STLP_INTERNAL_SLIST_H
+# include <stl/_slist.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+# include <stl/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+# include <stl/_function_base.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+# include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_HASH_FUN_H
+# include <stl/_hash_fun.h>
+#endif
+
+/*
+ * Hashtable class, used to implement the hashed associative containers
+ * hash_set, hash_map, hash_multiset, hash_multimap,
+ * unordered_set, unordered_map, unordered_multiset, unordered_multimap.
+ */
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+//Export of the classes used to represent buckets in the hashtable implementation.
+# if !defined (_STLP_USE_PTR_SPECIALIZATIONS)
+//If pointer specialization is enabled vector<_Slist_node_base*> will use the void*
+//storage type for which internal classes have already been exported.
+_STLP_EXPORT_TEMPLATE_CLASS allocator<_STLP_PRIV _Slist_node_base*>;
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<_Slist_node_base**, _Slist_node_base*,
+ allocator<_Slist_node_base*> >;
+_STLP_EXPORT_TEMPLATE_CLASS _Vector_base<_Slist_node_base*,
+ allocator<_Slist_node_base*> >;
+_STLP_MOVE_TO_STD_NAMESPACE
+# endif
+
+# if defined (_STLP_DEBUG)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+# define _STLP_NON_DBG_VECTOR _STLP_NON_DBG_NAME(vector)
+_STLP_EXPORT_TEMPLATE_CLASS __construct_checker<_STLP_NON_DBG_VECTOR<_Slist_node_base*, allocator<_Slist_node_base*> > >;
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_NON_DBG_VECTOR<_Slist_node_base*, allocator<_Slist_node_base*> >;
+# undef _STLP_NON_DBG_VECTOR
+_STLP_MOVE_TO_STD_NAMESPACE
+# endif
+
+_STLP_EXPORT_TEMPLATE_CLASS vector<_STLP_PRIV _Slist_node_base*,
+ allocator<_STLP_PRIV _Slist_node_base*> >;
+#endif
+
+#if defined (_STLP_DEBUG)
+# define hashtable _STLP_NON_DBG_NAME(hashtable)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+// some compilers require the names of template parameters to be the same
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+class hashtable;
+
+#if !defined (_STLP_DEBUG)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+template <class _BaseIte, class _Traits>
+struct _Ht_iterator {
+ typedef typename _Traits::_ConstTraits _ConstTraits;
+ typedef typename _Traits::_NonConstTraits _NonConstTraits;
+
+ typedef _Ht_iterator<_BaseIte,_Traits> _Self;
+
+ typedef typename _Traits::value_type value_type;
+ typedef typename _Traits::pointer pointer;
+ typedef typename _Traits::reference reference;
+ typedef forward_iterator_tag iterator_category;
+ typedef ptrdiff_t difference_type;
+ typedef size_t size_type;
+
+ typedef _Ht_iterator<_BaseIte, _NonConstTraits> iterator;
+ typedef _Ht_iterator<_BaseIte, _ConstTraits> const_iterator;
+
+ _Ht_iterator() {}
+ //copy constructor for iterator and constructor from iterator for const_iterator
+ _Ht_iterator(const iterator& __it) : _M_ite(__it._M_ite) {}
+ _Ht_iterator(_BaseIte __it) : _M_ite(__it) {}
+
+ reference operator*() const {
+ return *_M_ite;
+ }
+ _STLP_DEFINE_ARROW_OPERATOR
+
+ _Self& operator++() {
+ ++_M_ite;
+ return *this;
+ }
+ _Self operator++(int) {
+ _Self __tmp = *this;
+ ++*this;
+ return __tmp;
+ }
+
+ bool operator == (const_iterator __rhs) const {
+ return _M_ite == __rhs._M_ite;
+ }
+ bool operator != (const_iterator __rhs) const {
+ return _M_ite != __rhs._M_ite;
+ }
+
+ _BaseIte _M_ite;
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+template <class _BaseIte, class _Traits>
+struct __type_traits<_STLP_PRIV _Ht_iterator<_BaseIte, _Traits> > {
+ typedef __false_type has_trivial_default_constructor;
+ typedef __true_type has_trivial_copy_constructor;
+ typedef __true_type has_trivial_assignment_operator;
+ typedef __true_type has_trivial_destructor;
+ typedef __false_type is_POD_type;
+};
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+#if defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
+template <class _BaseIte, class _Traits>
+inline
+# if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+_STLP_TYPENAME_ON_RETURN_TYPE _Traits::value_type *
+# else
+_STLP_TYPENAME_ON_RETURN_TYPE _STLP_PRIV _Ht_iterator<_BaseIte,_Traits>::value_type *
+# endif
+value_type(const _STLP_PRIV _Ht_iterator<_BaseIte,_Traits>&) {
+ typedef _STLP_TYPENAME _STLP_PRIV _Ht_iterator<_BaseIte,_Traits>::value_type _Val;
+ return (_Val*) 0;
+}
+template <class _BaseIte, class _Traits>
+inline forward_iterator_tag iterator_category(const _STLP_PRIV _Ht_iterator<_BaseIte,_Traits>&)
+{ return forward_iterator_tag(); }
+template <class _BaseIte, class _Traits>
+inline ptrdiff_t* distance_type(const _STLP_PRIV _Ht_iterator<_BaseIte,_Traits>&)
+{ return (ptrdiff_t*) 0; }
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Dummy>
+class _Stl_prime {
+ // Returns begining of primes list and size by reference.
+ static const size_t* _S_primes(size_t&);
+public:
+ //Returns the maximum number of buckets handled by the hashtable implementation
+ static size_t _STLP_CALL _S_max_nb_buckets();
+
+ //Returns the bucket size next to a required size
+ static size_t _STLP_CALL _S_next_size(size_t);
+
+ // Returns the bucket range containing sorted list of prime numbers <= __hint.
+ static void _STLP_CALL _S_prev_sizes(size_t __hint, const size_t *&__begin, const size_t *&__end);
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS _Stl_prime<bool>;
+#endif
+
+typedef _Stl_prime<bool> _Stl_prime_type;
+
+#if !defined (_STLP_DEBUG)
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+/*
+ * Hashtables handle allocators a bit differently than other containers
+ * do. If we're using standard-conforming allocators, then a hashtable
+ * unconditionally has a member variable to hold its allocator, even if
+ * it so happens that all instances of the allocator type are identical.
+ * This is because, for hashtables, this extra storage is negligible.
+ * Additionally, a base class wouldn't serve any other purposes; it
+ * wouldn't, for example, simplify the exception-handling code.
+ */
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+class hashtable {
+ typedef hashtable<_Val, _Key, _HF, _Traits, _ExK, _EqK, _All> _Self;
+ typedef typename _Traits::_NonConstTraits _NonConstTraits;
+ typedef typename _Traits::_ConstTraits _ConstTraits;
+ typedef typename _Traits::_NonConstLocalTraits _NonConstLocalTraits;
+ typedef typename _Traits::_ConstLocalTraits _ConstLocalTraits;
+
+public:
+ typedef _Key key_type;
+ typedef _Val value_type;
+ typedef _HF hasher;
+ typedef _EqK key_equal;
+
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef typename _NonConstTraits::pointer pointer;
+ typedef const value_type* const_pointer;
+ typedef typename _NonConstTraits::reference reference;
+ typedef const value_type& const_reference;
+ typedef forward_iterator_tag _Iterator_category;
+
+ hasher hash_funct() const { return _M_hash; }
+ key_equal key_eq() const { return _M_equals; }
+
+private:
+ _STLP_FORCE_ALLOCATORS(_Val, _All)
+#if defined (_STLP_DEBUG)
+ typedef _STLP_PRIV _STLP_NON_DBG_NAME(slist)<value_type, _All> _ElemsCont;
+#else
+ typedef slist<value_type, _All> _ElemsCont;
+#endif
+ typedef typename _ElemsCont::iterator _ElemsIte;
+ typedef typename _ElemsCont::const_iterator _ElemsConstIte;
+ typedef _STLP_PRIV _Slist_node_base _BucketType;
+ typedef typename _Alloc_traits<_BucketType*, _All>::allocator_type _BucketAllocType;
+ /*
+ * We are going to use vector of _Slist_node_base pointers for 2 reasons:
+ * - limit code bloat, all hashtable instanciation use the same buckets representation.
+ * - avoid _STLP_DEBUG performance trouble: with a vector of iterator on slist the resize
+ * method would be too slow because the slist::splice_after method become linear on
+ * the number of iterators in the buckets rather than constant in time as the iterator
+ * has to be move from a slist to the other.
+ */
+#if defined (_STLP_DEBUG)
+ typedef _STLP_PRIV _STLP_NON_DBG_NAME(vector)<_BucketType*, _BucketAllocType> _BucketVector;
+#else
+ typedef vector<_BucketType*, _BucketAllocType> _BucketVector;
+#endif
+
+ hasher _M_hash;
+ key_equal _M_equals;
+ _ElemsCont _M_elems;
+ _BucketVector _M_buckets;
+ size_type _M_num_elements;
+ float _M_max_load_factor;
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+ static const key_type& _M_get_key(const value_type& __val) {
+ _ExK k;
+ return k(__val);
+ }
+public:
+ typedef _STLP_PRIV _Ht_iterator<_ElemsIte, _NonConstTraits> iterator;
+ typedef _STLP_PRIV _Ht_iterator<_ElemsIte, _ConstTraits> const_iterator;
+ //TODO: Avoids this debug check and make the local_iterator different from
+ //iterator in debug mode too.
+#if !defined (_STLP_DEBUG)
+ typedef _STLP_PRIV _Ht_iterator<_ElemsIte, _NonConstLocalTraits> local_iterator;
+ typedef _STLP_PRIV _Ht_iterator<_ElemsIte, _ConstLocalTraits> const_local_iterator;
+#else
+ typedef iterator local_iterator;
+ typedef const_iterator const_local_iterator;
+#endif
+
+ typedef _All allocator_type;
+ allocator_type get_allocator() const { return _M_elems.get_allocator(); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ hashtable(size_type __n,
+ const _HF& __hf,
+ const _EqK& __eql,
+ const allocator_type& __a = allocator_type())
+#else
+ hashtable(size_type __n,
+ const _HF& __hf,
+ const _EqK& __eql)
+ : _M_hash(__hf),
+ _M_equals(__eql),
+ _M_elems(allocator_type()),
+ _M_buckets(_STLP_CONVERT_ALLOCATOR(__a, _BucketType*)),
+ _M_num_elements(0),
+ _M_max_load_factor(1.0f)
+ { _M_initialize_buckets(__n); }
+
+ hashtable(size_type __n,
+ const _HF& __hf,
+ const _EqK& __eql,
+ const allocator_type& __a)
+#endif
+ : _M_hash(__hf),
+ _M_equals(__eql),
+ _M_elems(__a),
+ _M_buckets(_STLP_CONVERT_ALLOCATOR(__a, _BucketType*)),
+ _M_num_elements(0),
+ _M_max_load_factor(1.0f)
+ { _M_initialize_buckets(__n); }
+
+ hashtable(const _Self& __ht)
+ : _M_hash(__ht._M_hash),
+ _M_equals(__ht._M_equals),
+ _M_elems(__ht.get_allocator()),
+ _M_buckets(_STLP_CONVERT_ALLOCATOR(__ht.get_allocator(), _BucketType*)),
+ _M_num_elements(0),
+ _M_max_load_factor(1.0f)
+ { _M_copy_from(__ht); }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ hashtable(__move_source<_Self> src)
+ : _M_hash(_STLP_PRIV _AsMoveSource(src.get()._M_hash)),
+ _M_equals(_STLP_PRIV _AsMoveSource(src.get()._M_equals)),
+ _M_elems(__move_source<_ElemsCont>(src.get()._M_elems)),
+ _M_buckets(__move_source<_BucketVector>(src.get()._M_buckets)),
+ _M_num_elements(src.get()._M_num_elements),
+ _M_max_load_factor(src.get()._M_max_load_factor) {}
+#endif
+
+ _Self& operator= (const _Self& __ht) {
+ if (&__ht != this) {
+ clear();
+ _M_hash = __ht._M_hash;
+ _M_equals = __ht._M_equals;
+ _M_copy_from(__ht);
+ }
+ return *this;
+ }
+
+ ~hashtable() { clear(); }
+
+ size_type size() const { return _M_num_elements; }
+ size_type max_size() const { return size_type(-1); }
+ bool empty() const { return size() == 0; }
+
+ void swap(_Self& __ht) {
+ _STLP_STD::swap(_M_hash, __ht._M_hash);
+ _STLP_STD::swap(_M_equals, __ht._M_equals);
+ _M_elems.swap(__ht._M_elems);
+ _M_buckets.swap(__ht._M_buckets);
+ _STLP_STD::swap(_M_num_elements, __ht._M_num_elements);
+ _STLP_STD::swap(_M_max_load_factor, __ht._M_max_load_factor);
+ }
+
+ iterator begin() { return _M_elems.begin(); }
+ iterator end() { return _M_elems.end(); }
+ local_iterator begin(size_type __n) { return _ElemsIte(_M_buckets[__n]); }
+ local_iterator end(size_type __n) { return _ElemsIte(_M_buckets[__n + 1]); }
+
+ const_iterator begin() const { return __CONST_CAST(_ElemsCont&, _M_elems).begin(); }
+ const_iterator end() const { return __CONST_CAST(_ElemsCont&, _M_elems).end(); }
+ const_local_iterator begin(size_type __n) const { return _ElemsIte(_M_buckets[__n]); }
+ const_local_iterator end(size_type __n) const { return _ElemsIte(_M_buckets[__n + 1]); }
+
+ //static bool _STLP_CALL _M_equal (const _Self&, const _Self&);
+
+public:
+ //The number of buckets is size() - 1 because the last bucket always contains
+ //_M_elems.end() to make algo easier to implement.
+ size_type bucket_count() const { return _M_buckets.size() - 1; }
+ size_type max_bucket_count() const { return _STLP_PRIV _Stl_prime_type::_S_max_nb_buckets(); }
+ size_type elems_in_bucket(size_type __bucket) const
+ { return _STLP_STD::distance(_ElemsIte(_M_buckets[__bucket]), _ElemsIte(_M_buckets[__bucket + 1])); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type bucket(const _KT& __k) const { return _M_bkt_num_key(__k); }
+
+ // hash policy
+ float load_factor() const { return (float)size() / (float)bucket_count(); }
+ float max_load_factor() const { return _M_max_load_factor; }
+ void max_load_factor(float __z) {
+ _M_max_load_factor = __z;
+ _M_resize();
+ }
+
+ pair<iterator, bool> insert_unique(const value_type& __obj) {
+ _M_enlarge(_M_num_elements + 1);
+ return insert_unique_noresize(__obj);
+ }
+
+ iterator insert_equal(const value_type& __obj) {
+ _M_enlarge(_M_num_elements + 1);
+ return insert_equal_noresize(__obj);
+ }
+
+protected:
+ iterator _M_insert_noresize(size_type __n, const value_type& __obj);
+public:
+ pair<iterator, bool> insert_unique_noresize(const value_type& __obj);
+ iterator insert_equal_noresize(const value_type& __obj);
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void insert_unique(_InputIterator __f, _InputIterator __l)
+ { insert_unique(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIterator)); }
+
+ template <class _InputIterator>
+ void insert_equal(_InputIterator __f, _InputIterator __l)
+ { insert_equal(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIterator)); }
+
+ template <class _InputIterator>
+ void insert_unique(_InputIterator __f, _InputIterator __l,
+ const input_iterator_tag &) {
+ for ( ; __f != __l; ++__f)
+ insert_unique(*__f);
+ }
+
+ template <class _InputIterator>
+ void insert_equal(_InputIterator __f, _InputIterator __l,
+ const input_iterator_tag &) {
+ for ( ; __f != __l; ++__f)
+ insert_equal(*__f);
+ }
+
+ template <class _ForwardIterator>
+ void insert_unique(_ForwardIterator __f, _ForwardIterator __l,
+ const forward_iterator_tag &) {
+ size_type __n = _STLP_STD::distance(__f, __l);
+ _M_enlarge(_M_num_elements + __n);
+ for ( ; __n > 0; --__n, ++__f)
+ insert_unique_noresize(*__f);
+ }
+
+ template <class _ForwardIterator>
+ void insert_equal(_ForwardIterator __f, _ForwardIterator __l,
+ const forward_iterator_tag &) {
+ size_type __n = _STLP_STD::distance(__f, __l);
+ _M_enlarge(_M_num_elements + __n);
+ for ( ; __n > 0; --__n, ++__f)
+ insert_equal_noresize(*__f);
+ }
+
+#else /* _STLP_MEMBER_TEMPLATES */
+ void insert_unique(const value_type* __f, const value_type* __l) {
+ size_type __n = __l - __f;
+ _M_enlarge(_M_num_elements + __n);
+ for ( ; __n > 0; --__n, ++__f)
+ insert_unique_noresize(*__f);
+ }
+
+ void insert_equal(const value_type* __f, const value_type* __l) {
+ size_type __n = __l - __f;
+ _M_enlarge(_M_num_elements + __n);
+ for ( ; __n > 0; --__n, ++__f)
+ insert_equal_noresize(*__f);
+ }
+
+ void insert_unique(const_iterator __f, const_iterator __l) {
+ size_type __n = _STLP_STD::distance(__f, __l);
+ _M_enlarge(_M_num_elements + __n);
+ for ( ; __n > 0; --__n, ++__f)
+ insert_unique_noresize(*__f);
+ }
+
+ void insert_equal(const_iterator __f, const_iterator __l) {
+ size_type __n = _STLP_STD::distance(__f, __l);
+ _M_enlarge(_M_num_elements + __n);
+ for ( ; __n > 0; --__n, ++__f)
+ insert_equal_noresize(*__f);
+ }
+#endif /*_STLP_MEMBER_TEMPLATES */
+
+ //reference find_or_insert(const value_type& __obj);
+
+private:
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ _ElemsIte _M_find(const _KT& __key) const {
+ size_type __n = _M_bkt_num_key(__key);
+ _ElemsIte __first(_M_buckets[__n]);
+ _ElemsIte __last(_M_buckets[__n + 1]);
+ for ( ; (__first != __last) && !_M_equals(_M_get_key(*__first), __key); ++__first);
+ if (__first != __last)
+ return __first;
+ else
+ return __CONST_CAST(_ElemsCont&, _M_elems).end();
+ }
+
+public:
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __key) { return _M_find(__key); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __key) const { return _M_find(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __key) const {
+ const size_type __n = _M_bkt_num_key(__key);
+
+ _ElemsIte __cur(_M_buckets[__n]);
+ _ElemsIte __last(_M_buckets[__n + 1]);
+ for (; __cur != __last; ++__cur) {
+ if (_M_equals(_M_get_key(*__cur), __key)) {
+ size_type __result = 1;
+ for (++__cur;
+ __cur != __last && _M_equals(_M_get_key(*__cur), __key);
+ ++__result, ++__cur);
+ return __result;
+ }
+ }
+ return 0;
+ }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator, iterator> equal_range(const _KT& __key) {
+ typedef pair<iterator, iterator> _Pii;
+ const size_type __n = _M_bkt_num_key(__key);
+
+ for (_ElemsIte __first(_M_buckets[__n]), __last(_M_buckets[__n + 1]);
+ __first != __last; ++__first) {
+ if (_M_equals(_M_get_key(*__first), __key)) {
+ _ElemsIte __cur(__first);
+ for (++__cur; (__cur != __last) && _M_equals(_M_get_key(*__cur), __key); ++__cur);
+ return _Pii(__first, __cur);
+ }
+ }
+ return _Pii(end(), end());
+ }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator> equal_range(const _KT& __key) const {
+ typedef pair<const_iterator, const_iterator> _Pii;
+ const size_type __n = _M_bkt_num_key(__key);
+
+ for (_ElemsIte __first(_M_buckets[__n]), __last(_M_buckets[__n + 1]);
+ __first != __last; ++__first) {
+ if (_M_equals(_M_get_key(*__first), __key)) {
+ _ElemsIte __cur(__first);
+ for (++__cur; (__cur != __last) && _M_equals(_M_get_key(*__cur), __key); ++__cur);
+ return _Pii(__first, __cur);
+ }
+ }
+ return _Pii(end(), end());
+ }
+
+ size_type erase(const key_type& __key);
+ void erase(const_iterator __it);
+ void erase(const_iterator __first, const_iterator __last);
+
+private:
+ void _M_enlarge(size_type __n);
+ void _M_reduce();
+ void _M_resize();
+ void _M_rehash(size_type __num_buckets);
+#if defined (_STLP_DEBUG)
+ void _M_check() const;
+#endif
+
+public:
+ void rehash(size_type __num_buckets_hint);
+ void resize(size_type __num_buckets_hint)
+ { rehash(__num_buckets_hint); }
+ void clear();
+
+ // this is for hash_map::operator[]
+ reference _M_insert(const value_type& __obj);
+
+private:
+ //__n is set to the first bucket that has to be modified if any
+ //erase/insert operation is done after the returned iterator.
+ iterator _M_before_begin(size_type &__n) const;
+
+ static iterator _S_before_begin(const _ElemsCont& __elems, const _BucketVector& __buckets,
+ size_type &__n);
+
+ void _M_initialize_buckets(size_type __n) {
+ const size_type __n_buckets = _STLP_PRIV _Stl_prime_type::_S_next_size(__n) + 1;
+ _M_buckets.reserve(__n_buckets);
+ _M_buckets.assign(__n_buckets, __STATIC_CAST(_BucketType*, 0));
+ }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type _M_bkt_num_key(const _KT& __key) const
+ { return _M_bkt_num_key(__key, bucket_count()); }
+
+ size_type _M_bkt_num(const value_type& __obj) const
+ { return _M_bkt_num_key(_M_get_key(__obj)); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type _M_bkt_num_key(const _KT& __key, size_type __n) const
+ { return _M_hash(__key) % __n; }
+
+ size_type _M_bkt_num(const value_type& __obj, size_t __n) const
+ { return _M_bkt_num_key(_M_get_key(__obj), __n); }
+
+ void _M_copy_from(const _Self& __ht);
+};
+
+#if defined (_STLP_DEBUG)
+# undef hashtable
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_hashtable.c>
+#endif
+
+#if defined (_STLP_DEBUG)
+# include <stl/debug/_hashtable.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#define _STLP_TEMPLATE_HEADER template <class _Val, class _Key, class _HF, class _Traits, class _ExK, class _EqK, class _All>
+#define _STLP_TEMPLATE_CONTAINER hashtable<_Val,_Key,_HF,_Traits,_ExK,_EqK,_All>
+#include <stl/_relops_hash_cont.h>
+#undef _STLP_TEMPLATE_CONTAINER
+#undef _STLP_TEMPLATE_HEADER
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Val, class _Key, class _HF, class _Traits, class _ExK, class _EqK, class _All>
+struct __move_traits<hashtable<_Val, _Key, _HF, _Traits, _ExK, _EqK, _All> > {
+ //Hashtables are movable:
+ typedef __true_type implemented;
+
+ //Completeness depends on many template parameters, for the moment we consider it not complete:
+ typedef __false_type complete;
+};
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_HASHTABLE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_heap.c b/sources/android/stlport/stlport/stl/_heap.c
new file mode 100644
index 0000000..a4ab049
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_heap.c
@@ -0,0 +1,246 @@
+/*
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_HEAP_C
+#define _STLP_HEAP_C
+
+#ifndef _STLP_INTERNAL_HEAP_H
+# include <stl/_heap.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
+# include <stl/_iterator_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _RandomAccessIterator, class _Distance, class _Tp>
+_STLP_INLINE_LOOP
+void
+__push_heap(_RandomAccessIterator __first,
+ _Distance __holeIndex, _Distance __topIndex, _Tp __val)
+{
+ _Distance __parent = (__holeIndex - 1) / 2;
+ while (__holeIndex > __topIndex && *(__first + __parent) < __val) {
+ *(__first + __holeIndex) = *(__first + __parent);
+ __holeIndex = __parent;
+ __parent = (__holeIndex - 1) / 2;
+ }
+ *(__first + __holeIndex) = __val;
+}
+
+template <class _RandomAccessIterator, class _Distance, class _Tp>
+inline void
+__push_heap_aux(_RandomAccessIterator __first,
+ _RandomAccessIterator __last, _Distance*, _Tp*)
+{
+ __push_heap(__first, _Distance((__last - __first) - 1), _Distance(0),
+ _Tp(*(__last - 1)));
+}
+
+template <class _RandomAccessIterator>
+void
+push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+{
+ __push_heap_aux(__first, __last,
+ _STLP_DISTANCE_TYPE(__first, _RandomAccessIterator), _STLP_VALUE_TYPE(__first, _RandomAccessIterator));
+}
+
+
+template <class _RandomAccessIterator, class _Distance, class _Tp,
+ class _Compare>
+_STLP_INLINE_LOOP
+void
+__push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+ _Distance __topIndex, _Tp __val, _Compare __comp)
+{
+ _Distance __parent = (__holeIndex - 1) / 2;
+ while (__holeIndex > __topIndex && __comp(*(__first + __parent), __val)) {
+ _STLP_VERBOSE_ASSERT(!__comp(__val, *(__first + __parent)), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ *(__first + __holeIndex) = *(__first + __parent);
+ __holeIndex = __parent;
+ __parent = (__holeIndex - 1) / 2;
+ }
+ *(__first + __holeIndex) = __val;
+}
+
+template <class _RandomAccessIterator, class _Compare,
+ class _Distance, class _Tp>
+inline void
+__push_heap_aux(_RandomAccessIterator __first,
+ _RandomAccessIterator __last, _Compare __comp,
+ _Distance*, _Tp*)
+{
+ __push_heap(__first, _Distance((__last - __first) - 1), _Distance(0),
+ _Tp(*(__last - 1)), __comp);
+}
+
+template <class _RandomAccessIterator, class _Compare>
+void
+push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+ _Compare __comp)
+{
+ __push_heap_aux(__first, __last, __comp,
+ _STLP_DISTANCE_TYPE(__first, _RandomAccessIterator), _STLP_VALUE_TYPE(__first, _RandomAccessIterator));
+}
+
+template <class _RandomAccessIterator, class _Distance, class _Tp>
+void
+__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+ _Distance __len, _Tp __val) {
+ _Distance __topIndex = __holeIndex;
+ _Distance __secondChild = 2 * __holeIndex + 2;
+ while (__secondChild < __len) {
+ if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
+ __secondChild--;
+ *(__first + __holeIndex) = *(__first + __secondChild);
+ __holeIndex = __secondChild;
+ __secondChild = 2 * (__secondChild + 1);
+ }
+ if (__secondChild == __len) {
+ *(__first + __holeIndex) = *(__first + (__secondChild - 1));
+ __holeIndex = __secondChild - 1;
+ }
+ __push_heap(__first, __holeIndex, __topIndex, __val);
+}
+
+
+template <class _RandomAccessIterator, class _Tp>
+inline void
+__pop_heap_aux(_RandomAccessIterator __first, _RandomAccessIterator __last, _Tp*) {
+ __pop_heap(__first, __last - 1, __last - 1,
+ _Tp(*(__last - 1)), _STLP_DISTANCE_TYPE(__first, _RandomAccessIterator));
+}
+
+template <class _RandomAccessIterator>
+void pop_heap(_RandomAccessIterator __first,
+ _RandomAccessIterator __last) {
+ __pop_heap_aux(__first, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIterator));
+}
+
+template <class _RandomAccessIterator, class _Distance,
+ class _Tp, class _Compare>
+void
+__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+ _Distance __len, _Tp __val, _Compare __comp)
+{
+ _Distance __topIndex = __holeIndex;
+ _Distance __secondChild = 2 * __holeIndex + 2;
+ while (__secondChild < __len) {
+ if (__comp(*(__first + __secondChild), *(__first + (__secondChild - 1)))) {
+ _STLP_VERBOSE_ASSERT(!__comp(*(__first + (__secondChild - 1)), *(__first + __secondChild)),
+ _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ __secondChild--;
+ }
+ *(__first + __holeIndex) = *(__first + __secondChild);
+ __holeIndex = __secondChild;
+ __secondChild = 2 * (__secondChild + 1);
+ }
+ if (__secondChild == __len) {
+ *(__first + __holeIndex) = *(__first + (__secondChild - 1));
+ __holeIndex = __secondChild - 1;
+ }
+ __push_heap(__first, __holeIndex, __topIndex, __val, __comp);
+}
+
+
+template <class _RandomAccessIterator, class _Tp, class _Compare>
+inline void
+__pop_heap_aux(_RandomAccessIterator __first,
+ _RandomAccessIterator __last, _Tp*, _Compare __comp)
+{
+ __pop_heap(__first, __last - 1, __last - 1, _Tp(*(__last - 1)), __comp,
+ _STLP_DISTANCE_TYPE(__first, _RandomAccessIterator));
+}
+
+
+template <class _RandomAccessIterator, class _Compare>
+void
+pop_heap(_RandomAccessIterator __first,
+ _RandomAccessIterator __last, _Compare __comp)
+{
+ __pop_heap_aux(__first, __last, _STLP_VALUE_TYPE(__first, _RandomAccessIterator), __comp);
+}
+
+template <class _RandomAccessIterator, class _Tp, class _Distance>
+_STLP_INLINE_LOOP
+void
+__make_heap(_RandomAccessIterator __first,
+ _RandomAccessIterator __last, _Tp*, _Distance*)
+{
+ if (__last - __first < 2) return;
+ _Distance __len = __last - __first;
+ _Distance __parent = (__len - 2)/2;
+
+ for (;;) {
+ __adjust_heap(__first, __parent, __len, _Tp(*(__first + __parent)));
+ if (__parent == 0) return;
+ __parent--;
+ }
+}
+
+template <class _RandomAccessIterator>
+void
+make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+{
+ __make_heap(__first, __last,
+ _STLP_VALUE_TYPE(__first, _RandomAccessIterator), _STLP_DISTANCE_TYPE(__first, _RandomAccessIterator));
+}
+
+template <class _RandomAccessIterator, class _Compare,
+ class _Tp, class _Distance>
+_STLP_INLINE_LOOP
+void
+__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+ _Compare __comp, _Tp*, _Distance*)
+{
+ if (__last - __first < 2) return;
+ _Distance __len = __last - __first;
+ _Distance __parent = (__len - 2)/2;
+
+ for (;;) {
+ __adjust_heap(__first, __parent, __len, _Tp(*(__first + __parent)),
+ __comp);
+ if (__parent == 0) return;
+ __parent--;
+ }
+}
+
+template <class _RandomAccessIterator, class _Compare>
+void
+make_heap(_RandomAccessIterator __first,
+ _RandomAccessIterator __last, _Compare __comp)
+{
+ __make_heap(__first, __last, __comp,
+ _STLP_VALUE_TYPE(__first, _RandomAccessIterator), _STLP_DISTANCE_TYPE(__first, _RandomAccessIterator));
+}
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_HEAP_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_heap.h b/sources/android/stlport/stlport/stl/_heap.h
new file mode 100644
index 0000000..016dc49
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_heap.h
@@ -0,0 +1,125 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Hewlett-Packard Company makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ *
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_HEAP_H
+#define _STLP_INTERNAL_HEAP_H
+
+_STLP_BEGIN_NAMESPACE
+
+// Heap-manipulation functions: push_heap, pop_heap, make_heap, sort_heap.
+
+template <class _RandomAccessIterator>
+void
+push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last);
+
+
+template <class _RandomAccessIterator, class _Compare>
+void
+push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+ _Compare __comp);
+
+template <class _RandomAccessIterator, class _Distance, class _Tp>
+void
+__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+ _Distance __len, _Tp __val);
+
+template <class _RandomAccessIterator, class _Tp, class _Distance>
+inline void
+__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+ _RandomAccessIterator __result, _Tp __val, _Distance*)
+{
+ *__result = *__first;
+ __adjust_heap(__first, _Distance(0), _Distance(__last - __first), __val);
+}
+
+template <class _RandomAccessIterator>
+void pop_heap(_RandomAccessIterator __first,
+ _RandomAccessIterator __last);
+
+template <class _RandomAccessIterator, class _Distance,
+ class _Tp, class _Compare>
+void
+__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+ _Distance __len, _Tp __val, _Compare __comp);
+
+template <class _RandomAccessIterator, class _Tp, class _Compare,
+ class _Distance>
+inline void
+__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+ _RandomAccessIterator __result, _Tp __val, _Compare __comp,
+ _Distance*)
+{
+ *__result = *__first;
+ __adjust_heap(__first, _Distance(0), _Distance(__last - __first),
+ __val, __comp);
+}
+
+template <class _RandomAccessIterator, class _Compare>
+void
+pop_heap(_RandomAccessIterator __first,
+ _RandomAccessIterator __last, _Compare __comp);
+
+template <class _RandomAccessIterator>
+void
+make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last);
+
+template <class _RandomAccessIterator, class _Compare>
+void
+make_heap(_RandomAccessIterator __first,
+ _RandomAccessIterator __last, _Compare __comp);
+
+template <class _RandomAccessIterator>
+_STLP_INLINE_LOOP
+void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+{
+ while (__last - __first > 1)
+ pop_heap(__first, __last--);
+}
+
+template <class _RandomAccessIterator, class _Compare>
+_STLP_INLINE_LOOP
+void
+sort_heap(_RandomAccessIterator __first,
+ _RandomAccessIterator __last, _Compare __comp)
+{
+ while (__last - __first > 1)
+ pop_heap(__first, __last--, __comp);
+}
+
+_STLP_END_NAMESPACE
+
+# if !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_heap.c>
+# endif
+
+#endif /* _STLP_INTERNAL_HEAP_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_iomanip.h b/sources/android/stlport/stlport/stl/_iomanip.h
new file mode 100644
index 0000000..a27d951
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_iomanip.h
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_IOMANIP
+#define _STLP_INTERNAL_IOMANIP
+
+#ifndef _STLP_INTERNAL_ISTREAM
+# include <stl/_istream.h> // Includes <ostream> and <ios>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+//----------------------------------------------------------------------
+// Machinery for defining manipulators.
+
+// Class that calls one of ios_base's single-argument member functions.
+template <class _Arg>
+struct _Ios_Manip_1 {
+ typedef _Arg (ios_base::*__f_ptr_type)(_Arg);
+
+ _Ios_Manip_1(__f_ptr_type __f, const _Arg& __arg)
+ : _M_f(__f), _M_arg(__arg) {}
+
+ void operator()(ios_base& __ios) const
+ { (__ios.*_M_f)(_M_arg); }
+
+ __f_ptr_type _M_f;
+ _Arg _M_arg;
+};
+
+// Class that calls one of ios_base's two-argument member functions.
+struct _Ios_Setf_Manip {
+ ios_base::fmtflags _M_flag;
+ ios_base::fmtflags _M_mask;
+ bool _M_two_args;
+
+ _Ios_Setf_Manip(ios_base::fmtflags __f)
+ : _M_flag(__f), _M_mask(0), _M_two_args(false) {}
+
+ _Ios_Setf_Manip(ios_base::fmtflags __f, ios_base::fmtflags __m)
+ : _M_flag(__f), _M_mask(__m), _M_two_args(true) {}
+
+ void operator()(ios_base& __ios) const {
+ if (_M_two_args)
+ __ios.setf(_M_flag, _M_mask);
+ else
+ __ios.setf(_M_flag);
+ }
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _CharT, class _Traits, class _Arg>
+inline basic_istream<_CharT, _Traits>& _STLP_CALL
+operator>>(basic_istream<_CharT, _Traits>& __istr,
+ const _STLP_PRIV _Ios_Manip_1<_Arg>& __f) {
+ __f(__istr);
+ return __istr;
+}
+
+template <class _CharT, class _Traits, class _Arg>
+inline basic_ostream<_CharT, _Traits>& _STLP_CALL
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const _STLP_PRIV _Ios_Manip_1<_Arg>& __f) {
+ __f(__os);
+ return __os;
+}
+
+template <class _CharT, class _Traits>
+inline basic_istream<_CharT, _Traits>& _STLP_CALL
+operator>>(basic_istream<_CharT, _Traits>& __istr,
+ const _STLP_PRIV _Ios_Setf_Manip& __f) {
+ __f(__istr);
+ return __istr;
+}
+
+template <class _CharT, class _Traits>
+inline basic_ostream<_CharT, _Traits>& _STLP_CALL
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const _STLP_PRIV _Ios_Setf_Manip& __f) {
+ __f(__os);
+ return __os;
+}
+
+//----------------------------------------------------------------------
+// The ios_base manipulators.
+inline _STLP_PRIV _Ios_Setf_Manip _STLP_CALL resetiosflags(ios_base::fmtflags __mask)
+{ return _STLP_PRIV _Ios_Setf_Manip(0, __mask); }
+
+inline _STLP_PRIV _Ios_Setf_Manip _STLP_CALL setiosflags(ios_base::fmtflags __flag)
+{ return _STLP_PRIV _Ios_Setf_Manip(__flag); }
+
+inline _STLP_PRIV _Ios_Setf_Manip _STLP_CALL setbase(int __n) {
+ ios_base::fmtflags __base = __n == 8 ? ios_base::oct :
+ __n == 10 ? ios_base::dec :
+ __n == 16 ? ios_base::hex :
+ ios_base::fmtflags(0);
+ return _STLP_PRIV _Ios_Setf_Manip(__base, ios_base::basefield);
+}
+
+inline _STLP_PRIV _Ios_Manip_1<streamsize> _STLP_CALL
+setprecision(int __n) {
+ _STLP_PRIV _Ios_Manip_1<streamsize>::__f_ptr_type __f = &ios_base::precision;
+ return _STLP_PRIV _Ios_Manip_1<streamsize>(__f, __n);
+}
+
+inline _STLP_PRIV _Ios_Manip_1<streamsize> _STLP_CALL
+setw(int __n) {
+ _STLP_PRIV _Ios_Manip_1<streamsize>::__f_ptr_type __f = &ios_base::width;
+ return _STLP_PRIV _Ios_Manip_1<streamsize>(__f, __n);
+}
+
+//----------------------------------------------------------------------
+// setfill, a manipulator that operates on basic_ios<> instead of ios_base.
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _CharT>
+struct _Setfill_Manip {
+ _Setfill_Manip(_CharT __c) : _M_c(__c) {}
+ _CharT _M_c;
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _CharT, class _CharT2, class _Traits>
+inline basic_ostream<_CharT, _Traits>& _STLP_CALL
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const _STLP_PRIV _Setfill_Manip<_CharT2>& __m) {
+ __os.fill(__m._M_c);
+ return __os;
+}
+
+template <class _CharT, class _CharT2, class _Traits>
+inline basic_istream<_CharT, _Traits>& _STLP_CALL
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ const _STLP_PRIV _Setfill_Manip<_CharT2>& __m) {
+ __is.fill(__m._M_c);
+ return __is;
+}
+
+template <class _CharT>
+inline _STLP_PRIV _Setfill_Manip<_CharT> _STLP_CALL setfill(_CharT __c)
+{ return _STLP_PRIV _Setfill_Manip<_CharT>(__c); }
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_IOMANIP */
diff --git a/sources/android/stlport/stlport/stl/_ios.c b/sources/android/stlport/stlport/stl/_ios.c
new file mode 100644
index 0000000..7dec77f
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_ios.c
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_IOS_C
+#define _STLP_IOS_C
+
+#ifndef _STLP_INTERNAL_IOS_H
+# include <stl/_ios.h>
+#endif
+
+#ifndef _STLP_INTERNAL_STREAMBUF
+# include <stl/_streambuf.h>
+#endif
+
+#ifndef _STLP_INTERNAL_NUMPUNCT_H
+# include <stl/_numpunct.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+// basic_ios<>'s non-inline member functions
+
+// Public constructor, taking a streambuf.
+template <class _CharT, class _Traits>
+basic_ios<_CharT, _Traits>
+ ::basic_ios(basic_streambuf<_CharT, _Traits>* __streambuf)
+ : ios_base(), _M_cached_ctype(0),
+ _M_fill(_STLP_NULL_CHAR_INIT(_CharT)), _M_streambuf(0), _M_tied_ostream(0) {
+ basic_ios<_CharT, _Traits>::init(__streambuf);
+}
+
+template <class _CharT, class _Traits>
+basic_streambuf<_CharT, _Traits>*
+basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __buf) {
+ basic_streambuf<_CharT, _Traits>* __tmp = _M_streambuf;
+ _M_streambuf = __buf;
+ this->clear();
+ return __tmp;
+}
+
+template <class _CharT, class _Traits>
+basic_ios<_CharT, _Traits>&
+basic_ios<_CharT, _Traits>::copyfmt(const basic_ios<_CharT, _Traits>& __x) {
+ _M_invoke_callbacks(erase_event);
+ _M_copy_state(__x); // Inherited from ios_base.
+ _M_cached_ctype = __x._M_cached_ctype;
+ _M_fill = __x._M_fill;
+ _M_tied_ostream = __x._M_tied_ostream;
+ _M_invoke_callbacks(copyfmt_event);
+ this->_M_set_exception_mask(__x.exceptions());
+ return *this;
+}
+
+template <class _CharT, class _Traits>
+locale basic_ios<_CharT, _Traits>::imbue(const locale& __loc) {
+ locale __tmp = ios_base::imbue(__loc);
+ _STLP_TRY {
+ if (_M_streambuf)
+ _M_streambuf->pubimbue(__loc);
+
+ // no throwing here
+ _M_cached_ctype = &use_facet<ctype<char_type> >(__loc);
+ }
+ _STLP_CATCH_ALL {
+ __tmp = ios_base::imbue(__tmp);
+ _M_handle_exception(ios_base::failbit);
+ }
+ return __tmp;
+}
+
+// Protected constructor and initialization functions. The default
+// constructor creates an uninitialized basic_ios, and init() initializes
+// all of the members to the values in Table 89 of the C++ standard.
+
+template <class _CharT, class _Traits>
+basic_ios<_CharT, _Traits>::basic_ios()
+ : ios_base(),
+ _M_fill(_STLP_NULL_CHAR_INIT(_CharT)), _M_streambuf(0), _M_tied_ostream(0)
+{}
+
+template <class _CharT, class _Traits>
+void
+basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
+{
+ this->rdbuf(__sb);
+ this->imbue(locale());
+ this->tie(0);
+ this->_M_set_exception_mask(ios_base::goodbit);
+ this->_M_clear_nothrow(__sb != 0 ? ios_base::goodbit : ios_base::badbit);
+ ios_base::flags(ios_base::skipws | ios_base::dec);
+ ios_base::width(0);
+ ios_base::precision(6);
+ this->fill(widen(' '));
+ // We don't need to worry about any of the three arrays: they are
+ // initialized correctly in ios_base's constructor.
+}
+
+// This is never called except from within a catch clause.
+template <class _CharT, class _Traits>
+void basic_ios<_CharT, _Traits>::_M_handle_exception(ios_base::iostate __flag)
+{
+ this->_M_setstate_nothrow(__flag);
+ if (this->_M_get_exception_mask() & __flag)
+ _STLP_RETHROW;
+}
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_IOS_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_ios.h b/sources/android/stlport/stlport/stl/_ios.h
new file mode 100644
index 0000000..20422f0
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_ios.h
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_INTERNAL_IOS_H
+#define _STLP_INTERNAL_IOS_H
+
+
+#ifndef _STLP_IOS_BASE_H
+# include <stl/_ios_base.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CTYPE_H
+# include <stl/_ctype.h>
+#endif
+
+#ifndef _STLP_INTERNAL_NUMPUNCT_H
+# include <stl/_numpunct.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+// ----------------------------------------------------------------------
+
+// Class basic_ios, a subclass of ios_base. The only important difference
+// between the two is that basic_ios is a class template, parameterized
+// by the character type. ios_base exists to factor out all of the
+// common properties that don't depend on the character type.
+
+// The second template parameter, _Traits, defaults to char_traits<_CharT>.
+// The default is declared in header <iosfwd>, and it isn't declared here
+// because C++ language rules do not allow it to be declared twice.
+
+template <class _CharT, class _Traits>
+class basic_ios : public ios_base {
+ friend class ios_base;
+public: // Synonyms for types.
+ typedef _CharT char_type;
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+ typedef _Traits traits_type;
+
+public: // Constructor, destructor.
+ explicit basic_ios(basic_streambuf<_CharT, _Traits>* __streambuf);
+ virtual ~basic_ios() {}
+
+public: // Members from clause 27.4.4.2
+ basic_ostream<_CharT, _Traits>* tie() const {
+ return _M_tied_ostream;
+ }
+ basic_ostream<_CharT, _Traits>*
+ tie(basic_ostream<char_type, traits_type>* __new_tied_ostream) {
+ basic_ostream<char_type, traits_type>* __tmp = _M_tied_ostream;
+ _M_tied_ostream = __new_tied_ostream;
+ return __tmp;
+ }
+
+ basic_streambuf<_CharT, _Traits>* rdbuf() const
+ { return _M_streambuf; }
+
+ basic_streambuf<_CharT, _Traits>*
+ rdbuf(basic_streambuf<char_type, traits_type>*);
+
+ // Copies __x's state to *this.
+ basic_ios<_CharT, _Traits>& copyfmt(const basic_ios<_CharT, _Traits>& __x);
+
+ char_type fill() const { return _M_fill; }
+ char_type fill(char_type __fill) {
+ char_type __tmp(_M_fill);
+ _M_fill = __fill;
+ return __tmp;
+ }
+
+public: // Members from 27.4.4.3. These four functions
+ // can almost be defined in ios_base.
+
+ void clear(iostate __state = goodbit) {
+ _M_clear_nothrow(this->rdbuf() ? __state : iostate(__state|ios_base::badbit));
+ _M_check_exception_mask();
+ }
+ void setstate(iostate __state) { this->clear(rdstate() | __state); }
+
+ iostate exceptions() const { return this->_M_get_exception_mask(); }
+ void exceptions(iostate __mask) {
+ this->_M_set_exception_mask(__mask);
+ this->clear(this->rdstate());
+ }
+
+public: // Locale-related member functions.
+ locale imbue(const locale&);
+
+ inline char narrow(_CharT, char) const ;
+ inline _CharT widen(char) const;
+
+ // Helper function that makes testing for EOF more convenient.
+ static bool _STLP_CALL _S_eof(int_type __c) {
+ const int_type __eof = _Traits::eof();
+ return _Traits::eq_int_type(__c, __eof);
+ }
+
+protected:
+ // Cached copy of the curent locale's ctype facet. Set by init() and imbue().
+ const ctype<char_type>* _M_cached_ctype;
+
+public:
+ // Equivalent to &use_facet< Facet >(getloc()), but faster.
+ const ctype<char_type>* _M_ctype_facet() const { return _M_cached_ctype; }
+
+protected:
+ basic_ios();
+
+ void init(basic_streambuf<_CharT, _Traits>* __streambuf);
+
+public:
+
+ // Helper function used in istream and ostream. It is called only from
+ // a catch clause.
+ void _M_handle_exception(ios_base::iostate __flag);
+
+private: // Data members
+ char_type _M_fill; // The fill character, used for padding.
+
+ basic_streambuf<_CharT, _Traits>* _M_streambuf;
+ basic_ostream<_CharT, _Traits>* _M_tied_ostream;
+
+};
+
+
+template <class _CharT, class _Traits>
+inline char
+basic_ios<_CharT, _Traits>::narrow(_CharT __c, char __default) const
+{ return _M_ctype_facet()->narrow(__c, __default); }
+
+template <class _CharT, class _Traits>
+inline _CharT
+basic_ios<_CharT, _Traits>::widen(char __c) const
+{ return _M_ctype_facet()->widen(__c); }
+
+# if !defined (_STLP_NO_METHOD_SPECIALIZATION)
+_STLP_TEMPLATE_NULL
+inline char
+basic_ios<char, char_traits<char> >::narrow(char __c, char) const
+{
+ return __c;
+}
+
+_STLP_TEMPLATE_NULL
+inline char
+basic_ios<char, char_traits<char> >::widen(char __c) const
+{
+ return __c;
+}
+# endif /* _STLP_NO_METHOD_SPECIALIZATION */
+
+# if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS basic_ios<char, char_traits<char> >;
+# if ! defined (_STLP_NO_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS basic_ios<wchar_t, char_traits<wchar_t> >;
+# endif
+# endif /* _STLP_USE_TEMPLATE_EXPORT */
+
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_ios.c>
+#endif
+
+#endif /* _STLP_IOS */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/stl/_ios_base.h b/sources/android/stlport/stlport/stl/_ios_base.h
new file mode 100644
index 0000000..c9e10ad
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_ios_base.h
@@ -0,0 +1,345 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_IOS_BASE_H
+#define _STLP_IOS_BASE_H
+
+#ifndef _STLP_INTERNAL_STDEXCEPT_BASE
+# include <stl/_stdexcept_base.h>
+#endif
+
+#ifndef _STLP_INTERNAL_PAIR_H
+# include <stl/_pair.h>
+#endif
+
+#ifndef _STLP_INTERNAL_LOCALE_H
+# include <stl/_locale.h>
+#endif
+
+#ifndef _STLP_INTERNAL_STRING_H
+# include <stl/_string.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+// ----------------------------------------------------------------------
+
+// Class ios_base. This is the base class of the ios hierarchy, which
+// includes basic_istream and basic_ostream. Classes in the ios
+// hierarchy are actually quite simple: they are just glorified
+// wrapper classes. They delegate buffering and physical character
+// manipulation to the streambuf classes, and they delegate most
+// formatting tasks to a locale.
+
+class _STLP_CLASS_DECLSPEC ios_base {
+public:
+
+ class _STLP_CLASS_DECLSPEC failure : public __Named_exception {
+ public:
+ explicit failure(const string&);
+ virtual ~failure() _STLP_NOTHROW_INHERENTLY;
+ };
+
+ typedef int fmtflags;
+ typedef int iostate;
+ typedef int openmode;
+ typedef int seekdir;
+
+# ifndef _STLP_NO_ANACHRONISMS
+ typedef fmtflags fmt_flags;
+# endif
+
+ // Formatting flags.
+ _STLP_STATIC_CONSTANT(int, left = 0x0001);
+ _STLP_STATIC_CONSTANT(int, right = 0x0002);
+ _STLP_STATIC_CONSTANT(int, internal = 0x0004);
+ _STLP_STATIC_CONSTANT(int, dec = 0x0008);
+ _STLP_STATIC_CONSTANT(int, hex = 0x0010);
+ _STLP_STATIC_CONSTANT(int, oct = 0x0020);
+ _STLP_STATIC_CONSTANT(int, fixed = 0x0040);
+ _STLP_STATIC_CONSTANT(int, scientific = 0x0080);
+ _STLP_STATIC_CONSTANT(int, boolalpha = 0x0100);
+ _STLP_STATIC_CONSTANT(int, showbase = 0x0200);
+ _STLP_STATIC_CONSTANT(int, showpoint = 0x0400);
+ _STLP_STATIC_CONSTANT(int, showpos = 0x0800);
+ _STLP_STATIC_CONSTANT(int, skipws = 0x1000);
+ _STLP_STATIC_CONSTANT(int, unitbuf = 0x2000);
+ _STLP_STATIC_CONSTANT(int, uppercase = 0x4000);
+ _STLP_STATIC_CONSTANT(int, adjustfield = left | right | internal);
+ _STLP_STATIC_CONSTANT(int, basefield = dec | hex | oct);
+ _STLP_STATIC_CONSTANT(int, floatfield = scientific | fixed);
+
+ // State flags.
+ _STLP_STATIC_CONSTANT(int, goodbit = 0x00);
+ _STLP_STATIC_CONSTANT(int, badbit = 0x01);
+ _STLP_STATIC_CONSTANT(int, eofbit = 0x02);
+ _STLP_STATIC_CONSTANT(int, failbit = 0x04);
+
+ // Openmode flags.
+ _STLP_STATIC_CONSTANT(int, __default_mode = 0x0); /* implementation detail */
+ _STLP_STATIC_CONSTANT(int, app = 0x01);
+ _STLP_STATIC_CONSTANT(int, ate = 0x02);
+ _STLP_STATIC_CONSTANT(int, binary = 0x04);
+ _STLP_STATIC_CONSTANT(int, in = 0x08);
+ _STLP_STATIC_CONSTANT(int, out = 0x10);
+ _STLP_STATIC_CONSTANT(int, trunc = 0x20);
+
+ // Seekdir flags
+ _STLP_STATIC_CONSTANT(int, beg = 0x01);
+ _STLP_STATIC_CONSTANT(int, cur = 0x02);
+ _STLP_STATIC_CONSTANT(int, end = 0x04);
+
+public: // Flag-manipulation functions.
+ fmtflags flags() const { return _M_fmtflags; }
+ fmtflags flags(fmtflags __flags) {
+ fmtflags __tmp = _M_fmtflags;
+ _M_fmtflags = __flags;
+ return __tmp;
+ }
+
+ fmtflags setf(fmtflags __flag) {
+ fmtflags __tmp = _M_fmtflags;
+ _M_fmtflags |= __flag;
+ return __tmp;
+ }
+ fmtflags setf(fmtflags __flag, fmtflags __mask) {
+ fmtflags __tmp = _M_fmtflags;
+ _M_fmtflags &= ~__mask;
+ _M_fmtflags |= __flag & __mask;
+ return __tmp;
+ }
+ void unsetf(fmtflags __mask) { _M_fmtflags &= ~__mask; }
+
+ streamsize precision() const { return _M_precision; }
+ streamsize precision(streamsize __newprecision) {
+ streamsize __tmp = _M_precision;
+ _M_precision = __newprecision;
+ return __tmp;
+ }
+
+ streamsize width() const { return _M_width; }
+ streamsize width(streamsize __newwidth) {
+ streamsize __tmp = _M_width;
+ _M_width = __newwidth;
+ return __tmp;
+ }
+
+public: // Locales
+ locale imbue(const locale&);
+ locale getloc() const { return _M_locale; }
+
+public: // Auxiliary storage.
+ static int _STLP_CALL xalloc();
+ long& iword(int __index);
+ void*& pword(int __index);
+
+public: // Destructor.
+ virtual ~ios_base();
+
+public: // Callbacks.
+ enum event { erase_event, imbue_event, copyfmt_event };
+ typedef void (*event_callback)(event, ios_base&, int __index);
+ void register_callback(event_callback __fn, int __index);
+
+public: // This member function affects only
+ // the eight predefined ios objects:
+ // cin, cout, etc.
+ static bool _STLP_CALL sync_with_stdio(bool __sync = true);
+
+public: // The C++ standard requires only that these
+ // member functions be defined in basic_ios.
+ // We define them in the non-template
+ // base class to avoid code duplication.
+ operator void*() const { return !fail() ? (void*) __CONST_CAST(ios_base*,this) : (void*) 0; }
+ bool operator!() const { return fail(); }
+
+ iostate rdstate() const { return _M_iostate; }
+
+ bool good() const { return _M_iostate == 0; }
+ bool eof() const { return (_M_iostate & eofbit) != 0; }
+ bool fail() const { return (_M_iostate & (failbit | badbit)) != 0; }
+ bool bad() const { return (_M_iostate & badbit) != 0; }
+
+protected: // The functional protected interface.
+
+ // Copies the state of __x to *this. This member function makes it
+ // possible to implement basic_ios::copyfmt without having to expose
+ // ios_base's private data members. Does not copy _M_exception_mask
+ // or _M_iostate.
+ void _M_copy_state(const ios_base& __x);
+
+ void _M_setstate_nothrow(iostate __state) { _M_iostate |= __state; }
+ void _M_clear_nothrow(iostate __state) { _M_iostate = __state; }
+ iostate _M_get_exception_mask() const { return _M_exception_mask; }
+ void _M_set_exception_mask(iostate __mask) { _M_exception_mask = __mask; }
+ void _M_check_exception_mask() {
+ if (_M_iostate & _M_exception_mask)
+ _M_throw_failure();
+ }
+
+ void _M_invoke_callbacks(event);
+ void _STLP_FUNCTION_THROWS _M_throw_failure();
+
+ ios_base(); // Default constructor.
+
+protected: // Initialization of the I/O system
+ static void _STLP_CALL _S_initialize();
+ static void _STLP_CALL _S_uninitialize();
+ static bool _S_is_synced;
+
+private: // Invalidate the copy constructor and
+ // assignment operator.
+ ios_base(const ios_base&);
+ void operator=(const ios_base&);
+
+private: // Data members.
+
+ fmtflags _M_fmtflags; // Flags
+ iostate _M_iostate;
+ openmode _M_openmode;
+ seekdir _M_seekdir;
+ iostate _M_exception_mask;
+
+ streamsize _M_precision;
+ streamsize _M_width;
+
+ locale _M_locale;
+
+ pair<event_callback, int>* _M_callbacks;
+ size_t _M_num_callbacks; // Size of the callback array.
+ size_t _M_callback_index; // Index of the next available callback;
+ // initially zero.
+
+ long* _M_iwords; // Auxiliary storage. The count is zero
+ size_t _M_num_iwords; // if and only if the pointer is null.
+
+ void** _M_pwords;
+ size_t _M_num_pwords;
+
+public:
+ // ----------------------------------------------------------------------
+ // Nested initializer class. This is an implementation detail, but it's
+ // prescribed by the standard. The static initializer object (on
+ // implementations where such a thing is required) is declared in
+ // <iostream>
+ class _STLP_CLASS_DECLSPEC Init
+ {
+ public:
+ Init();
+ ~Init();
+ private:
+ static long _S_count;
+ friend class ios_base;
+ };
+
+ friend class Init;
+
+public:
+# ifndef _STLP_NO_ANACHRONISMS
+ // 31.6 Old iostreams members [depr.ios.members]
+ typedef iostate io_state;
+ typedef openmode open_mode;
+ typedef seekdir seek_dir;
+ typedef _STLP_STD::streamoff streamoff;
+ typedef _STLP_STD::streampos streampos;
+# endif
+};
+
+// ----------------------------------------------------------------------
+// ios_base manipulator functions, from section 27.4.5 of the C++ standard.
+// All of them are trivial one-line wrapper functions.
+
+// fmtflag manipulators, section 27.4.5.1
+inline ios_base& _STLP_CALL boolalpha(ios_base& __s)
+ { __s.setf(ios_base::boolalpha); return __s;}
+
+inline ios_base& _STLP_CALL noboolalpha(ios_base& __s)
+ { __s.unsetf(ios_base::boolalpha); return __s;}
+
+inline ios_base& _STLP_CALL showbase(ios_base& __s)
+ { __s.setf(ios_base::showbase); return __s;}
+
+inline ios_base& _STLP_CALL noshowbase(ios_base& __s)
+ { __s.unsetf(ios_base::showbase); return __s;}
+
+inline ios_base& _STLP_CALL showpoint(ios_base& __s)
+ { __s.setf(ios_base::showpoint); return __s;}
+
+inline ios_base& _STLP_CALL noshowpoint(ios_base& __s)
+ { __s.unsetf(ios_base::showpoint); return __s;}
+
+inline ios_base& _STLP_CALL showpos(ios_base& __s)
+ { __s.setf(ios_base::showpos); return __s;}
+
+inline ios_base& _STLP_CALL noshowpos(ios_base& __s)
+ { __s.unsetf(ios_base::showpos); return __s;}
+
+inline ios_base& _STLP_CALL skipws(ios_base& __s)
+ { __s.setf(ios_base::skipws); return __s;}
+
+inline ios_base& _STLP_CALL noskipws(ios_base& __s)
+ { __s.unsetf(ios_base::skipws); return __s;}
+
+inline ios_base& _STLP_CALL uppercase(ios_base& __s)
+ { __s.setf(ios_base::uppercase); return __s;}
+
+inline ios_base& _STLP_CALL nouppercase(ios_base& __s)
+ { __s.unsetf(ios_base::uppercase); return __s;}
+
+inline ios_base& _STLP_CALL unitbuf(ios_base& __s)
+ { __s.setf(ios_base::unitbuf); return __s;}
+
+inline ios_base& _STLP_CALL nounitbuf(ios_base& __s)
+ { __s.unsetf(ios_base::unitbuf); return __s;}
+
+
+// adjustfield manipulators, section 27.4.5.2
+inline ios_base& _STLP_CALL internal(ios_base& __s)
+ { __s.setf(ios_base::internal, ios_base::adjustfield); return __s; }
+
+inline ios_base& _STLP_CALL left(ios_base& __s)
+ { __s.setf(ios_base::left, ios_base::adjustfield); return __s; }
+
+inline ios_base& _STLP_CALL right(ios_base& __s)
+ { __s.setf(ios_base::right, ios_base::adjustfield); return __s; }
+
+// basefield manipulators, section 27.4.5.3
+inline ios_base& _STLP_CALL dec(ios_base& __s)
+ { __s.setf(ios_base::dec, ios_base::basefield); return __s; }
+
+inline ios_base& _STLP_CALL hex(ios_base& __s)
+ { __s.setf(ios_base::hex, ios_base::basefield); return __s; }
+
+inline ios_base& _STLP_CALL oct(ios_base& __s)
+ { __s.setf(ios_base::oct, ios_base::basefield); return __s; }
+
+
+// floatfield manipulators, section 27.4.5.3
+inline ios_base& _STLP_CALL fixed(ios_base& __s)
+ { __s.setf(ios_base::fixed, ios_base::floatfield); return __s; }
+
+inline ios_base& _STLP_CALL scientific(ios_base& __s)
+ { __s.setf(ios_base::scientific, ios_base::floatfield); return __s; }
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_IOS_BASE */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/stl/_ioserr.h b/sources/android/stlport/stlport/stl/_ioserr.h
new file mode 100644
index 0000000..83ba877
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_ioserr.h
@@ -0,0 +1,12 @@
+/*
+ * This file is included in every header that needs the STLport library to be
+ * built; the header files mostly are the iostreams-headers. The file checks for
+ * _STLP_USE_NO_IOSTREAMS or _STLP_NO_IOSTREAMS being not defined, so that the
+ * iostreams part of STLport cannot be used when the symbols were defined
+ * accidentally.
+ */
+#if defined (_STLP_NO_IOSTREAMS)
+# error STLport iostreams header cannot be used; you chose not to use iostreams in the STLport configuration file (stlport/stl/config/user_config.h).
+#elif defined (_STLP_USE_NO_IOSTREAMS )
+# error STLport iostreams header cannot be used; your compiler do not support it.
+#endif
diff --git a/sources/android/stlport/stlport/stl/_iosfwd.h b/sources/android/stlport/stlport/stl/_iosfwd.h
new file mode 100644
index 0000000..e31db31
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_iosfwd.h
@@ -0,0 +1,159 @@
+#ifndef _STLP_INTERNAL_IOSFWD
+#define _STLP_INTERNAL_IOSFWD
+
+#if defined (__sgi) && !defined (__GNUC__) && !defined (_STANDARD_C_PLUS_PLUS)
+# error This header file requires the -LANG:std option
+#endif
+
+// This file provides forward declarations of the most important I/O
+// classes. Note that almost all of those classes are class templates,
+// with default template arguments. According to the C++ standard,
+// if a class template is declared more than once in the same scope
+// then only one of those declarations may have default arguments.
+
+// <iosfwd> contains the same declarations as other headers, and including
+// both <iosfwd> and (say) <iostream> is permitted. This means that only
+// one header may contain those default template arguments.
+
+// In this implementation, the declarations in <iosfwd> contain default
+// template arguments. All of the other I/O headers include <iosfwd>.
+
+#ifndef _STLP_CHAR_TRAITS_H
+# include <stl/char_traits.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+class ios_base;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_ios;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_streambuf;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_istream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_ostream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_iostream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM( _Traits , char_traits<_CharT>),
+ _STLP_DFL_TMPL_PARAM(_Allocator , allocator<_CharT>) >
+class basic_stringbuf;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>),
+ _STLP_DFL_TMPL_PARAM(_Allocator , allocator<_CharT>) >
+class basic_istringstream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>),
+ _STLP_DFL_TMPL_PARAM(_Allocator , allocator<_CharT>) >
+class basic_ostringstream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>),
+ _STLP_DFL_TMPL_PARAM(_Allocator , allocator<_CharT>) >
+class basic_stringstream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_filebuf;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_ifstream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_ofstream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class basic_fstream;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class istreambuf_iterator;
+
+template <class _CharT, _STLP_DFL_TMPL_PARAM(_Traits , char_traits<_CharT>) >
+class ostreambuf_iterator;
+
+typedef basic_ios<char, char_traits<char> > ios;
+
+#if !defined (_STLP_NO_WCHAR_T)
+typedef basic_ios<wchar_t, char_traits<wchar_t> > wios;
+#endif
+
+// Forward declaration of class locale, and of the most important facets.
+class locale;
+template <class _Facet>
+#if defined (_STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS)
+struct _Use_facet {
+ const locale& __loc;
+ _Use_facet(const locale& __p_loc) : __loc(__p_loc) {}
+ inline const _Facet& operator *() const;
+};
+# define use_facet *_Use_facet
+#else
+inline const _Facet& use_facet(const locale&);
+#endif
+
+template <class _CharT> class ctype;
+template <class _CharT> class ctype_byname;
+template <class _CharT> class collate;
+template <class _CharT> class collate_byname;
+
+_STLP_TEMPLATE_NULL class ctype<char>;
+_STLP_TEMPLATE_NULL class ctype_byname<char>;
+_STLP_TEMPLATE_NULL class collate<char>;
+_STLP_TEMPLATE_NULL class collate_byname<char>;
+
+#if !defined (_STLP_NO_WCHAR_T)
+_STLP_TEMPLATE_NULL class ctype<wchar_t>;
+_STLP_TEMPLATE_NULL class ctype_byname<wchar_t>;
+_STLP_TEMPLATE_NULL class collate<wchar_t>;
+_STLP_TEMPLATE_NULL class collate_byname<wchar_t>;
+#endif
+
+#if !(defined (__SUNPRO_CC) && __SUNPRO_CC < 0x500 )
+// Typedefs for ordinary (narrow-character) streams.
+//_STLP_TEMPLATE_NULL class basic_streambuf<char, char_traits<char> >;
+#endif
+
+typedef basic_istream<char, char_traits<char> > istream;
+typedef basic_ostream<char, char_traits<char> > ostream;
+typedef basic_iostream<char, char_traits<char> > iostream;
+typedef basic_streambuf<char,char_traits<char> > streambuf;
+
+typedef basic_stringbuf<char, char_traits<char>, allocator<char> > stringbuf;
+typedef basic_istringstream<char, char_traits<char>, allocator<char> > istringstream;
+typedef basic_ostringstream<char, char_traits<char>, allocator<char> > ostringstream;
+typedef basic_stringstream<char, char_traits<char>, allocator<char> > stringstream;
+
+typedef basic_filebuf<char, char_traits<char> > filebuf;
+typedef basic_ifstream<char, char_traits<char> > ifstream;
+typedef basic_ofstream<char, char_traits<char> > ofstream;
+typedef basic_fstream<char, char_traits<char> > fstream;
+
+#if !defined (_STLP_NO_WCHAR_T)
+// Typedefs for wide-character streams.
+typedef basic_streambuf<wchar_t, char_traits<wchar_t> > wstreambuf;
+typedef basic_istream<wchar_t, char_traits<wchar_t> > wistream;
+typedef basic_ostream<wchar_t, char_traits<wchar_t> > wostream;
+typedef basic_iostream<wchar_t, char_traits<wchar_t> > wiostream;
+
+typedef basic_stringbuf<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wstringbuf;
+typedef basic_istringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wistringstream;
+typedef basic_ostringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wostringstream;
+typedef basic_stringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wstringstream;
+
+typedef basic_filebuf<wchar_t, char_traits<wchar_t> > wfilebuf;
+typedef basic_ifstream<wchar_t, char_traits<wchar_t> > wifstream;
+typedef basic_ofstream<wchar_t, char_traits<wchar_t> > wofstream;
+typedef basic_fstream<wchar_t, char_traits<wchar_t> > wfstream;
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_iostream_string.h b/sources/android/stlport/stlport/stl/_iostream_string.h
new file mode 100644
index 0000000..87656a4
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_iostream_string.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2004
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+ /*
+ * This is an internal string for the STLport own iostream implementation.
+ * The only diference rely on the allocator used to instanciate the basic_string.
+ * Its goals is to improve performance limitating the number of dynamic allocation
+ * that could occur when requesting a big float ouput for instance. This allocator
+ * is not standard conformant as it has an internal state (the static buffer)
+ */
+
+
+#ifndef _STLP_INTERNAL_IOSTREAM_STRING_H
+#define _STLP_INTERNAL_IOSTREAM_STRING_H
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+# include <stl/_alloc.h>
+#endif /* _STLP_INTERNAL_ALLOC_H */
+
+#ifndef _STLP_INTERNAL_STRING_H
+# include <stl/_string.h>
+#endif /* _STLP_INTERNAL_STRING_H */
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _CharT>
+class __iostring_allocator : public allocator<_CharT> {
+public:
+ enum { _STR_SIZE = 256 };
+
+private:
+ enum { _BUF_SIZE = _STR_SIZE + 1 };
+ typedef allocator<_CharT> _Base;
+ _CharT _M_static_buf[_BUF_SIZE];
+
+public:
+ typedef typename _Base::size_type size_type;
+ typedef typename _Base::pointer pointer;
+#if defined (_STLP_MEMBER_TEMPLATE_CLASSES)
+ template <class _Tp1> struct rebind {
+# if !defined (_STLP_MSVC) || (_STLP_MSVC >= 1300)
+ typedef __iostring_allocator<_Tp1> other;
+# else
+ typedef _STLP_PRIV __iostring_allocator<_Tp1> other;
+# endif
+ };
+#endif
+
+ _CharT* allocate(size_type __n, const void* __ptr = 0) {
+ if (__n > _BUF_SIZE) {
+ return _Base::allocate(__n, __ptr);
+ }
+ return _M_static_buf;
+ }
+ void deallocate(pointer __p, size_type __n) {
+ if (__p != _M_static_buf) _Base::deallocate(__p, __n);
+ }
+};
+
+#if defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE) || !defined (_STLP_MEMBER_TEMPLATES)
+/*
+ * As the __iostring_allocator allocator will only be used in the basic_string implementation
+ * we known that it is never going to be bound to another type that the one used to instantiate
+ * the basic_string. This is why the associated __stl_alloc_rebind has only one template
+ * parameter.
+ */
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _Tp>
+inline _STLP_PRIV __iostring_allocator<_Tp>& _STLP_CALL
+__stl_alloc_rebind(_STLP_PRIV __iostring_allocator<_Tp>& __a, const _Tp*)
+{ return __a; }
+template <class _Tp>
+inline _STLP_PRIV __iostring_allocator<_Tp> _STLP_CALL
+__stl_alloc_create(const _STLP_PRIV __iostring_allocator<_Tp>&, const _Tp*)
+{ return _STLP_PRIV __iostring_allocator<_Tp>(); }
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif /* _STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE */
+
+#if !defined (_STLP_DEBUG)
+template <class _CharT>
+struct __basic_iostring : public basic_string<_CharT, char_traits<_CharT>, __iostring_allocator<_CharT> > {
+ /*
+ * A consequence of the non standard conformant allocator is that a string using it
+ * must always be presized to the allocator static buffer size because the basic_string implementation
+ * do not manage an allocator returning always the same memory adress as long as the
+ * requested memory block size is under a certain value.
+ */
+ typedef __basic_iostring<_CharT> _Self;
+ typedef basic_string<_CharT, char_traits<_CharT>, __iostring_allocator<_CharT> > _Base;
+ typedef typename _Base::_Reserve_t _Reserve_t;
+
+ __basic_iostring() : _Base(_Reserve_t(), __iostring_allocator<_CharT>::_STR_SIZE)
+ {}
+
+ _Self& operator=(const _CharT* __s) {
+ _Base::operator=(__s);
+ return *this;
+ }
+};
+
+typedef __basic_iostring<char> __iostring;
+
+# if !defined (_STLP_NO_WCHAR_T)
+typedef __basic_iostring<wchar_t> __iowstring;
+# endif
+
+# define _STLP_BASIC_IOSTRING(_CharT) _STLP_PRIV __basic_iostring<_CharT>
+
+#else
+
+typedef string __iostring;
+# if !defined (_STLP_NO_WCHAR_T)
+typedef wstring __iowstring;
+# endif
+
+# define _STLP_BASIC_IOSTRING(_CharT) basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> >
+
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_IOSTREAM_STRING_H */
diff --git a/sources/android/stlport/stlport/stl/_istream.c b/sources/android/stlport/stlport/stl/_istream.c
new file mode 100644
index 0000000..ab327b2
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_istream.c
@@ -0,0 +1,1429 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_ISTREAM_C
+#define _STLP_ISTREAM_C
+
+#ifndef _STLP_INTERNAL_ISTREAM
+# include <stl/_istream.h>
+#endif
+
+#ifndef _STLP_INTERNAL_LIMITS
+# include <stl/_limits.h>
+#endif
+
+#ifndef _STLP_INTERNAL_NUM_GET_H
+# include <stl/_num_get.h>
+#endif
+
+#if defined ( _STLP_NESTED_TYPE_PARAM_BUG )
+// no wchar_t is supported for this mode
+# define __BIS_int_type__ int
+# define __BIS_pos_type__ streampos
+# define __BIS_off_type__ streamoff
+#else
+# define __BIS_int_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::int_type
+# define __BIS_pos_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::pos_type
+# define __BIS_off_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::off_type
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//----------------------------------------------------------------------
+// Function object structs used by some member functions.
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Traits>
+struct _Is_not_wspace {
+ typedef typename _Traits::char_type argument_type;
+ typedef bool result_type;
+
+ const ctype<argument_type>* _M_ctype;
+
+ _Is_not_wspace(const ctype<argument_type>* __c_type) : _M_ctype(__c_type) {}
+ bool operator()(argument_type __c) const
+ { return !_M_ctype->is(ctype_base::space, __c); }
+};
+
+template <class _Traits>
+struct _Is_wspace_null {
+ typedef typename _Traits::char_type argument_type;
+ typedef bool result_type;
+
+ const ctype<argument_type>* _M_ctype;
+
+ _Is_wspace_null(const ctype<argument_type>* __c_type) : _M_ctype(__c_type) {}
+ bool operator()(argument_type __c) const {
+ return _Traits::eq(__c, argument_type()) ||
+ _M_ctype->is(ctype_base::space, __c);
+ }
+};
+
+template <class _Traits>
+struct _Scan_for_wspace {
+ typedef typename _Traits::char_type char_type;
+ typedef char_type* first_argument_type;
+ typedef char_type* second_argument_type;
+ typedef char_type* result_type;
+
+ const ctype<char_type>* _M_ctype;
+
+ _Scan_for_wspace(const ctype<char_type>* __ctype) : _M_ctype(__ctype) {}
+ const char_type*
+ operator()(const char_type* __first, const char_type* __last) const {
+ return _M_ctype->scan_is(ctype_base::space, __first, __last);
+ }
+};
+
+template <class _Traits>
+struct _Scan_wspace_null {
+ typedef typename _Traits::char_type char_type;
+ typedef char_type* first_argument_type;
+ typedef char_type* second_argument_type;
+ typedef char_type* result_type;
+
+ const ctype<char_type>* _M_ctype;
+
+ _Scan_wspace_null(const ctype<char_type>* __c_type) : _M_ctype(__c_type) {}
+ const char_type*
+ operator()(const char_type* __first, const char_type* __last) const {
+ __last = find_if(__first, __last,
+ _Eq_char_bound<_Traits>(char_type()));
+ return _M_ctype->scan_is(ctype_base::space, __first, __last);
+ }
+};
+
+template <class _Traits>
+struct _Scan_for_not_wspace {
+ typedef typename _Traits::char_type char_type;
+ typedef char_type* first_argument_type;
+ typedef char_type* second_argument_type;
+ typedef char_type* result_type;
+
+ const ctype<char_type>* _M_ctype;
+
+ _Scan_for_not_wspace(const ctype<char_type>* __c_type) : _M_ctype(__c_type) {}
+ const char_type*
+ operator()(const char_type* __first, const char_type* __last) const {
+ return _M_ctype->scan_not(ctype_base::space, __first, __last);
+ }
+};
+
+template <class _Traits>
+struct _Scan_for_char_val {
+ typedef typename _Traits::char_type char_type;
+ typedef char_type* first_argument_type;
+ typedef char_type* second_argument_type;
+ typedef char_type* result_type;
+
+ char_type _M_val;
+
+ _Scan_for_char_val(char_type __val) : _M_val(__val) {}
+
+ const char_type*
+ operator()(const char_type* __first, const char_type* __last) const {
+ return find_if(__first, __last, _Eq_char_bound<_Traits>(_M_val));
+ }
+};
+
+template <class _Traits>
+struct _Scan_for_int_val {
+ typedef typename _Traits::char_type char_type;
+ typedef typename _Traits::int_type int_type;
+ typedef char_type* first_argument_type;
+ typedef char_type* second_argument_type;
+ typedef char_type* result_type;
+
+ int_type _M_val;
+
+ _Scan_for_int_val(int_type __val) : _M_val(__val) {}
+
+ const char_type*
+ operator()(const char_type* __first, const char_type* __last) const {
+ return find_if(__first, __last,
+ _Eq_int_bound<_Traits>(_M_val));
+ }
+};
+
+// Helper function: try to push back a character to a streambuf,
+// return true if the pushback succeeded. Does not throw.
+
+template <class _CharT, class _Traits>
+bool _STLP_CALL
+__pushback(basic_streambuf<_CharT, _Traits>* __buf, _CharT __c) {
+ bool ret;
+ _STLP_TRY {
+ const typename _Traits::int_type __eof = _Traits::eof();
+ ret = !_Traits::eq_int_type(__buf->sputbackc(__c), __eof);
+ }
+ _STLP_CATCH_ALL {
+ ret = false;
+ }
+ return ret;
+}
+
+//----------------------------------------------------------------------
+// Definitions of basic_istream<>'s noninline member functions.
+
+// Helper function for formatted input of numbers.
+template <class _CharT, class _Traits, class _Number>
+ios_base::iostate _STLP_CALL
+__get_num(basic_istream<_CharT, _Traits>& __that, _Number& __val) {
+ typedef typename basic_istream<_CharT, _Traits>::sentry _Sentry;
+ ios_base::iostate __err = 0;
+ _Sentry __sentry( __that ); // Skip whitespace.
+ if (__sentry) {
+ typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > _Num_get;
+ _STLP_TRY {
+ // Do not remove additional parenthesis around use_facet instanciation, some compilers (VC6)
+ // require it when building the library.
+ (use_facet<_Num_get>(__that.getloc())).get(istreambuf_iterator<_CharT, _Traits>(__that.rdbuf()),
+ 0, __that, __err, __val);
+ }
+ _STLP_CATCH_ALL {
+ __that._M_handle_exception(ios_base::badbit);
+ }
+ if (__err) __that.setstate(__err);
+ }
+ return __err;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (short& __val) {
+ long __lval;
+ _STLP_PRIV __get_num(*this, __lval);
+ if ( this->fail() ) {
+ return *this;
+ }
+ short __tmp = __STATIC_CAST(short, __lval);
+ unsigned short __uval = __STATIC_CAST(unsigned short, __lval);
+ // check if we lose digits
+ // if ((__val != __lval) && ((unsigned short)__val != __lval))
+ if ((__tmp != __lval) && ((long)__uval != __lval))
+ this->setstate(ios_base::failbit);
+ else
+ __val = __tmp;
+ return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (int& __val) {
+ long __lval;
+ _STLP_PRIV __get_num(*this, __lval);
+ if ( this->fail() ) {
+ return *this;
+ }
+ int __tmp = __lval;
+ unsigned int __uval = __lval;
+ // check if we lose digits
+ // if ((__val != __lval) && ((unsigned int)__val != __lval))
+ if ((__tmp != __lval) && ((long)__uval != __lval))
+ this->setstate(ios_base::failbit);
+ else
+ __val = __tmp;
+ return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned short& __val) {
+ _STLP_PRIV __get_num(*this, __val);
+ return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned int& __val) {
+ _STLP_PRIV __get_num(*this, __val);
+ return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (long& __val) {
+ _STLP_PRIV __get_num(*this, __val);
+ return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned long& __val) {
+ _STLP_PRIV __get_num(*this, __val);
+ return *this;
+}
+
+#if defined (_STLP_LONG_LONG)
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (_STLP_LONG_LONG& __val) {
+ _STLP_PRIV __get_num(*this, __val);
+ return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned _STLP_LONG_LONG& __val) {
+ _STLP_PRIV __get_num(*this, __val);
+ return *this;
+}
+#endif
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (float& __val) {
+ _STLP_PRIV __get_num(*this, __val);
+ return *this;
+}
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (double& __val) {
+ _STLP_PRIV __get_num(*this, __val);
+ return *this;
+}
+#if !defined (_STLP_NO_LONG_DOUBLE)
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (long double& __val) {
+ _STLP_PRIV __get_num(*this, __val);
+ return *this;
+}
+#endif
+#if !defined (_STLP_NO_BOOL)
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (bool& __val) {
+ _STLP_PRIV __get_num(*this, __val);
+ return *this;
+}
+#endif
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (void*& __val) {
+ _STLP_PRIV __get_num(*this, __val);
+ return *this;
+}
+
+// Unformatted input
+
+template <class _CharT, class _Traits>
+__BIS_int_type__
+basic_istream<_CharT, _Traits>::peek() {
+ typename _Traits::int_type __tmp = _Traits::eof();
+
+ this->_M_gcount = 0;
+ sentry __sentry(*this, _No_Skip_WS());
+
+ if (__sentry) {
+ _STLP_TRY {
+ __tmp = this->rdbuf()->sgetc();
+ }
+ _STLP_CATCH_ALL {
+ this->_M_handle_exception(ios_base::badbit);
+ }
+ if (this->_S_eof(__tmp))
+ this->setstate(ios_base::eofbit);
+ }
+
+ return __tmp;
+}
+
+
+template <class _CharT, class _Traits>
+__BIS_int_type__
+basic_istream<_CharT, _Traits>::get() {
+ typename _Traits::int_type __tmp = _Traits::eof();
+ sentry __sentry(*this, _No_Skip_WS());
+ this->_M_gcount = 0;
+
+ if (__sentry) {
+ _STLP_TRY {
+ __tmp = this->rdbuf()->sbumpc();
+ }
+ _STLP_CATCH_ALL {
+ this->_M_handle_exception(ios_base::badbit);
+ }
+
+ if (!this->_S_eof(__tmp))
+ this->_M_gcount = 1;
+ }
+
+ if (_M_gcount == 0)
+ this->setstate(ios_base::eofbit | ios_base::failbit);
+
+ return __tmp;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::get(_CharT& __c) {
+ sentry __sentry(*this, _No_Skip_WS());
+ this->_M_gcount = 0;
+
+ if (__sentry) {
+ typename _Traits::int_type __tmp = _Traits::eof();
+ _STLP_TRY {
+ __tmp = this->rdbuf()->sbumpc();
+ }
+ _STLP_CATCH_ALL {
+ this->_M_handle_exception(ios_base::badbit);
+ }
+
+ if (!this->_S_eof(__tmp)) {
+ this->_M_gcount = 1;
+ __c = _Traits::to_char_type(__tmp);
+ }
+ }
+
+ if (this->_M_gcount == 0)
+ this->setstate(ios_base::eofbit | ios_base::failbit);
+
+ return *this;
+}
+
+
+// Read characters and discard them. The standard specifies a single
+// function with two arguments, each with a default. We instead use
+// three overloded functions, because it's possible to implement the
+// first two more efficiently than the fully general third version.
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::ignore() {
+ sentry __sentry(*this, _No_Skip_WS());
+ this->_M_gcount = 0;
+
+ if (__sentry) {
+ int_type __c;
+ _STLP_TRY {
+ __c = this->rdbuf()->sbumpc();
+ }
+ _STLP_CATCH_ALL {
+ this->_M_handle_exception(ios_base::badbit);
+ return *this;
+ }
+
+ if (!this->_S_eof(__c))
+ this->_M_gcount = 1;
+ else
+ this->setstate(ios_base::eofbit);
+ }
+
+ return *this;
+}
+
+// Putback
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::putback(_CharT __c) {
+ this->_M_gcount = 0;
+ sentry __sentry(*this, _No_Skip_WS());
+
+ if (__sentry) {
+ typename _Traits::int_type __tmp = _Traits::eof();
+ basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+// if (!__buf || this->_S_eof(__buf->sputbackc(__c)))
+ if (__buf) {
+ _STLP_TRY {
+ __tmp = __buf->sputbackc(__c);
+ }
+ _STLP_CATCH_ALL {
+ this->_M_handle_exception(ios_base::badbit);
+ }
+ }
+ if (this->_S_eof(__tmp))
+ this->setstate(ios_base::badbit);
+ }
+ else
+ this->setstate(ios_base::failbit);
+
+ return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::unget() {
+ this->_M_gcount = 0;
+
+ sentry __sentry(*this, _No_Skip_WS());
+
+ if (__sentry) {
+ basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+ // if (!__buf || _Traits::eq_int_type(__buf->sungetc(), _Traits::eof()))
+ if (__buf) {
+ _STLP_TRY {
+ if (this->_S_eof(__buf->sungetc()))
+ this->setstate(ios_base::badbit);
+ }
+ _STLP_CATCH_ALL {
+ this->_M_handle_exception(ios_base::badbit);
+ }
+ } else
+ this->setstate(ios_base::badbit);
+ }
+ else
+ this->setstate(ios_base::failbit);
+
+ return *this;
+}
+
+// Positioning and buffer control.
+
+template <class _CharT, class _Traits>
+int basic_istream<_CharT, _Traits>::sync() {
+ sentry __sentry(*this, _No_Skip_WS());
+
+ basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+ if (__buf) {
+ if (__buf->pubsync() == -1) {
+ this->setstate(ios_base::badbit);
+ return -1;
+ }
+ else
+ return 0;
+ }
+ else
+ return -1;
+}
+
+template <class _CharT, class _Traits>
+__BIS_pos_type__
+basic_istream<_CharT, _Traits>::tellg() {
+ sentry __sentry(*this, _No_Skip_WS());
+
+ basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+ return (__buf && !this->fail()) ? __buf->pubseekoff(0, ios_base::cur, ios_base::in)
+ : pos_type(-1);
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::seekg(pos_type __pos) {
+ sentry __sentry(*this, _No_Skip_WS());
+
+ basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+ if (!this->fail() && __buf) {
+ if (__buf->pubseekpos(__pos, ios_base::in) == pos_type(-1)) {
+ this->setstate(ios_base::failbit);
+ }
+ }
+ return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir) {
+ sentry __sentry(*this, _No_Skip_WS());
+
+ basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+ if (!this->fail() && __buf)
+ __buf->pubseekoff(__off, __dir, ios_base::in);
+ return *this;
+}
+
+// Formatted input of characters and character arrays.
+
+template <class _CharT, class _Traits>
+void basic_istream<_CharT, _Traits>::_M_formatted_get(_CharT& __c) {
+// typename _Traits::int_type __tmp = _Traits::eof();
+
+ sentry __sentry(*this); // Skip whitespace.
+
+ if (__sentry) {
+ typename _Traits::int_type __tmp;// = _Traits::eof();
+
+ _STLP_TRY {
+ __tmp = this->rdbuf()->sbumpc();
+ }
+ _STLP_CATCH_ALL {
+ this->_M_handle_exception(ios_base::badbit);
+ return;
+ }
+
+ if (!this->_S_eof(__tmp))
+ __c = _Traits::to_char_type(__tmp);
+ else
+ this->setstate(ios_base::eofbit | ios_base::failbit);
+ }
+}
+
+
+//---------------------------------------------------------------------------
+// istream's helper functions.
+
+// A generic function for unbuffered input. We stop when we reach EOF,
+// or when we have extracted _Num characters, or when the function object
+// __is_delim return true. In the last case, it extracts the character
+// for which __is_delim is true, if and only if __extract_delim is true.
+// It appends a null character to the end of the string; this means that
+// it may store up to _Num + 1 characters.
+//
+// __is_getline governs two corner cases: reading _Num characters without
+// encountering delim or eof (in which case failbit is set if __is_getline
+// is true); and reading _Num characters where the _Num+1'st character is
+// eof (in which case eofbit is set if __is_getline is true).
+//
+// It is assumed that __is_delim never throws.
+//
+// Return value is the number of characters extracted, including the
+// delimiter if it is extracted. Note that the number of characaters
+// extracted isn't necessarily the same as the number stored.
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template < class _CharT, class _Traits, class _Is_Delim>
+streamsize _STLP_CALL
+__read_unbuffered(basic_istream<_CharT, _Traits>* __that, basic_streambuf<_CharT, _Traits>* __buf,
+ streamsize _Num, _CharT* __s,
+ _Is_Delim __is_delim,
+ bool __extract_delim, bool __append_null,
+ bool __is_getline)
+{
+ streamsize __n = 0;
+ ios_base::iostate __status = 0;
+
+ typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
+ // The operations that can potentially throw are sbumpc, snextc, and sgetc.
+ _STLP_TRY {
+ for (;;) {
+ if (__n == _Num) {
+ if (__is_getline) // didn't find delimiter as one of the _Num chars
+ __status |= ios_base::failbit;
+ break;
+ }
+ int_type __c = __buf->sbumpc(); // sschwarz
+
+ if (__that->_S_eof(__c)) {
+ if (__n < _Num || __is_getline)
+ __status |= ios_base::eofbit;
+ break;
+ } else if (__is_delim(_Traits::to_char_type(__c))) {
+ if (__extract_delim) { // Extract and discard current character.
+ ++__n;
+ } else if ( !__pushback(__buf, _Traits::to_char_type(__c)) ) { // leave delimiter
+ __status |= ios_base::failbit;
+ }
+ break;
+ }
+ // regular character
+ *__s++ = _Traits::to_char_type(__c);
+ ++__n;
+ }
+ }
+ _STLP_CATCH_ALL {
+ __that->_M_handle_exception(ios_base::badbit);
+ *__s = _STLP_DEFAULT_CONSTRUCTED(_CharT);
+ return __n;
+ }
+
+ if (__append_null)
+ *__s = _STLP_DEFAULT_CONSTRUCTED(_CharT);
+ if (__status)
+ __that->setstate(__status); // This might throw.
+ return __n;
+}
+
+// Much like __read_unbuffered, but with one additional function object:
+// __scan_delim(first, last) returns the first pointer p in [first, last)
+// such that __is_delim(p) is true.
+
+template < class _CharT, class _Traits, class _Is_Delim, class _Scan_Delim>
+streamsize _STLP_CALL
+__read_buffered(basic_istream<_CharT, _Traits>* __that, basic_streambuf<_CharT, _Traits>* __buf,
+ streamsize _Num, _CharT* __s,
+ _Is_Delim __is_delim, _Scan_Delim __scan_delim,
+ bool __extract_delim, bool __append_null,
+ bool __is_getline) {
+ streamsize __n = 0;
+ ios_base::iostate __status = 0;
+ bool __done = false;
+
+ _STLP_TRY {
+ while (__buf->_M_egptr() != __buf->_M_gptr() && !__done) {
+ const _CharT* __first = __buf->_M_gptr();
+ const _CharT* __last = __buf->_M_egptr();
+ //casting numeric_limits<ptrdiff_t>::max to streamsize only works is ptrdiff_t is signed or streamsize representation
+ //is larger than ptrdiff_t one.
+ _STLP_STATIC_ASSERT((sizeof(streamsize) > sizeof(ptrdiff_t)) ||
+ ((sizeof(streamsize) == sizeof(ptrdiff_t)) && numeric_limits<ptrdiff_t>::is_signed))
+ ptrdiff_t __request = __STATIC_CAST(ptrdiff_t, (min) (__STATIC_CAST(streamsize, (numeric_limits<ptrdiff_t>::max)()), _Num - __n));
+
+ const _CharT* __p = __scan_delim(__first, __last);
+ ptrdiff_t __chunk = (min) (ptrdiff_t(__p - __first), __request);
+ _Traits::copy(__s, __first, __chunk);
+ __s += __chunk;
+ __n += __chunk;
+ __buf->_M_gbump((int)__chunk);
+
+ // We terminated by finding delim.
+ if (__p != __last && __p - __first <= __request) {
+ if (__extract_delim) {
+ __n += 1;
+ __buf->_M_gbump(1);
+ }
+ __done = true;
+ }
+
+ // We terminated by reading all the characters we were asked for.
+ else if (__n == _Num) {
+
+ // Find out if we have reached eof. This matters for getline.
+ if (__is_getline) {
+ if (__chunk == __last - __first) {
+ if (__that->_S_eof(__buf->sgetc()))
+ __status |= ios_base::eofbit;
+ }
+ else
+ __status |= ios_base::failbit;
+ }
+ __done = true;
+ }
+
+ // The buffer contained fewer than _Num - __n characters. Either we're
+ // at eof, or we should refill the buffer and try again.
+ else {
+ if (__that->_S_eof(__buf->sgetc())) {
+ __status |= ios_base::eofbit;
+ __done = true;
+ }
+ }
+ } // Close the while loop.
+ }
+ _STLP_CATCH_ALL {
+ __that->_M_handle_exception(ios_base::badbit);
+ __done = true;
+ }
+
+ if (__done) {
+ if (__append_null)
+ *__s = _STLP_DEFAULT_CONSTRUCTED(_CharT);
+ if (__status != 0)
+ __that->setstate(__status); // This might throw.
+ return __n;
+ }
+
+ // If execution has reached this point, then we have an empty buffer but
+ // we have not reached eof. What that means is that the streambuf has
+ // decided to switch from buffered to unbuffered input. We switch to
+ // to __read_unbuffered.
+
+ return __n + __read_unbuffered(__that, __buf, _Num - __n, __s, __is_delim,
+ __extract_delim,__append_null,__is_getline);
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::get(_CharT* __s, streamsize __n,
+ _CharT __delim) {
+ sentry __sentry(*this, _No_Skip_WS());
+ this->_M_gcount = 0;
+
+ if (__sentry) {
+ if (__n > 0) {
+ basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+
+ if (__buf->egptr() != __buf->gptr())
+ this->_M_gcount =
+ _STLP_PRIV __read_buffered(this, __buf, __n - 1, __s,
+ _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
+ _STLP_PRIV _Scan_for_char_val<_Traits>(__delim),
+ false, true, false);
+ else
+ this->_M_gcount =
+ _STLP_PRIV __read_unbuffered(this, __buf, __n - 1, __s,
+ _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
+ false, true, false);
+ }
+ }
+
+ if (this->_M_gcount == 0)
+ this->setstate(ios_base::failbit);
+
+ return *this;
+}
+
+// Getline is essentially identical to get, except that it extracts
+// the delimiter.
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::getline(_CharT* __s, streamsize __n,
+ _CharT __delim) {
+ sentry __sentry(*this, _No_Skip_WS());
+ this->_M_gcount = 0;
+
+ if (__sentry) {
+ if (__n > 0) {
+ basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+ this->_M_gcount = __buf->egptr() != __buf->gptr()
+ ? _STLP_PRIV __read_buffered(this, __buf, __n - 1, __s,
+ _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
+ _STLP_PRIV _Scan_for_char_val<_Traits>(__delim),
+ true, true, true)
+ : _STLP_PRIV __read_unbuffered(this, __buf, __n - 1, __s,
+ _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
+ true, true, true);
+ }
+ }
+
+ if (this->_M_gcount == 0)
+ this->setstate(ios_base::failbit);
+
+ return *this;
+}
+
+// Read n characters. We don't look for any delimiter, and we don't
+// put in a terminating null character.
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n) {
+ sentry __sentry(*this, _No_Skip_WS());
+ this->_M_gcount = 0;
+
+ if (__sentry && !this->eof()) {
+ basic_streambuf<_CharT, _Traits>*__buf = this->rdbuf();
+ if (__buf->gptr() != __buf->egptr())
+ _M_gcount
+ = _STLP_PRIV __read_buffered(this, __buf, __n, __s,
+ _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
+ _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
+ false, false, false);
+ else
+ _M_gcount
+ = _STLP_PRIV __read_unbuffered(this, __buf, __n, __s,
+ _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
+ false, false, false);
+ }
+ else
+ this->setstate(ios_base::failbit);
+
+ if (this->eof())
+ this->setstate(ios_base::eofbit | ios_base::failbit);
+
+ return *this;
+}
+
+
+// Read n or fewer characters. We don't look for any delimiter, and
+// we don't put in a terminating null character.
+template <class _CharT, class _Traits>
+streamsize
+basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __nmax) {
+ sentry __sentry(*this, _No_Skip_WS());
+ this->_M_gcount = 0;
+
+ if (__sentry && !this->eof() && __nmax >= 0) {
+
+ basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+ streamsize __avail = __buf->in_avail();
+
+ // fbp : isn't full-blown setstate required here ?
+ if (__avail == -1)
+ this->_M_setstate_nothrow(ios_base::eofbit);
+
+ else if (__avail != 0) {
+
+ if (__buf->gptr() != __buf->egptr())
+ _M_gcount
+ = _STLP_PRIV __read_buffered(this, __buf, (min) (__avail, __nmax), __s,
+ _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
+ _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
+ false, false, false);
+ else
+ _M_gcount
+ = _STLP_PRIV __read_unbuffered(this, __buf, (min) (__avail, __nmax), __s,
+ _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
+ false, false, false);
+ }
+ }
+ else {
+ // fbp : changed so that failbit is set only there, to pass Dietmar's test
+ if (this->eof())
+ this->setstate(ios_base::eofbit | ios_base::failbit);
+ else
+ this->setstate(ios_base::failbit);
+ }
+
+ // if (this->eof())
+ // this->setstate(ios_base::eofbit | ios_base::failbit);
+
+ return _M_gcount;
+}
+
+template <class _CharT, class _Traits>
+void basic_istream<_CharT, _Traits>::_M_formatted_get(_CharT* __s) {
+ sentry __sentry(*this); // Skip whitespace.
+
+ if (__sentry) {
+ basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+ streamsize __nmax = this->width() > 0
+ ? this->width() - 1
+ : ((numeric_limits<streamsize>::max)() / sizeof(_CharT)) - 1;
+
+ streamsize __n = __buf->gptr() != __buf->egptr()
+ ? _STLP_PRIV __read_buffered(this, __buf, __nmax, __s,
+ _STLP_PRIV _Is_wspace_null<_Traits>(this->_M_ctype_facet()),
+ _STLP_PRIV _Scan_wspace_null<_Traits>(this->_M_ctype_facet()),
+ false, true, false)
+ : _STLP_PRIV __read_unbuffered(this, __buf, __nmax, __s,
+ _STLP_PRIV _Is_wspace_null<_Traits>(this->_M_ctype_facet()),
+ false, true, false);
+ if (__n == 0)
+ this->setstate(ios_base::failbit);
+ }
+ this->width(0);
+}
+
+// A generic unbuffered function for ignoring characters. We stop
+// when we reach EOF, or when the function object __is_delim returns
+// true. In the last case, it extracts the character for which
+// __is_delim is true, if and only if __extract_delim is true.
+
+template < class _CharT, class _Traits, class _Is_Delim>
+void _STLP_CALL
+_M_ignore_unbuffered(basic_istream<_CharT, _Traits>* __that,
+ basic_streambuf<_CharT, _Traits>* __buf,
+ _Is_Delim __is_delim,
+ bool __extract_delim, bool __set_failbit) {
+ bool __done = false;
+ ios_base::iostate __status = 0;
+ typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
+
+ _STLP_TRY {
+ while (!__done) {
+ int_type __c = __buf->sbumpc();
+
+ if (__that->_S_eof(__c)) {
+ __done = true;
+ __status |= __set_failbit ? ios_base::eofbit | ios_base::failbit
+ : ios_base::eofbit;
+ }
+
+ else if (__is_delim(_Traits::to_char_type(__c))) {
+ __done = true;
+ if (!__extract_delim)
+ if (__that->_S_eof(__buf->sputbackc(_Traits::to_char_type(__c))))
+ __status |= ios_base::failbit;
+ }
+ }
+ }
+ _STLP_CATCH_ALL {
+ __that->_M_handle_exception(ios_base::badbit);
+ }
+
+ __that->setstate(__status);
+}
+
+// A generic buffered function for ignoring characters. Much like
+// _M_ignore_unbuffered, but with one additional function object:
+// __scan_delim(first, last) returns the first pointer p in [first,
+// last) such that __is_delim(p) is true.
+
+template < class _CharT, class _Traits, class _Is_Delim, class _Scan_Delim>
+void _STLP_CALL
+_M_ignore_buffered(basic_istream<_CharT, _Traits>* __that,
+ basic_streambuf<_CharT, _Traits>* __buf,
+ _Is_Delim __is_delim, _Scan_Delim __scan_delim,
+ bool __extract_delim, bool __set_failbit) {
+ bool __at_eof = false;
+ bool __found_delim = false;
+
+ _STLP_TRY {
+ while (__buf->_M_egptr() != __buf->_M_gptr() && !__at_eof && !__found_delim) {
+ const _CharT* __p = __scan_delim(__buf->_M_gptr(), __buf->_M_egptr());
+ __buf->_M_gbump((int)(__p - __buf->_M_gptr()));
+
+ if (__p != __buf->_M_egptr()) { // We found delim, so we're done.
+ if (__extract_delim)
+ __buf->_M_gbump(1);
+ __found_delim = true;
+ }
+
+ else // No delim. Try to refil the buffer.
+ __at_eof = __that->_S_eof(__buf->sgetc());
+ } // Close the while loop.
+ }
+ _STLP_CATCH_ALL {
+ __that->_M_handle_exception(ios_base::badbit);
+ return;
+ }
+
+ if (__at_eof) {
+ __that->setstate(__set_failbit ? ios_base::eofbit | ios_base::failbit
+ : ios_base::eofbit);
+ return;
+ }
+ if (__found_delim)
+ return;
+
+ // If execution has reached this point, then we have an empty buffer but
+ // we have not reached eof. What that means is that the streambuf has
+ // decided to switch from a buffered to an unbuffered mode. We switch
+ // to _M_ignore_unbuffered.
+ _M_ignore_unbuffered(__that, __buf, __is_delim, __extract_delim, __set_failbit);
+}
+
+// Overloaded versions of _M_ignore_unbuffered and _M_ignore_unbuffered
+// with an explicit count _Num. Return value is the number of
+// characters extracted.
+//
+// The function object __max_chars takes two arguments, _Num and __n
+// (the latter being the number of characters we have already read),
+// and returns the maximum number of characters to read from the buffer.
+// We parameterize _M_ignore_buffered so that we can use it for both
+// bounded and unbounded input; for the former the function object should
+// be minus<>, and for the latter it should return a constant maximum value.
+
+template < class _CharT, class _Traits, class _Max_Chars, class _Is_Delim>
+streamsize _STLP_CALL
+_M_ignore_unbuffered(basic_istream<_CharT, _Traits>* __that,
+ basic_streambuf<_CharT, _Traits>* __buf,
+ streamsize _Num, _Max_Chars __max_chars,
+ _Is_Delim __is_delim,
+ bool __extract_delim, bool __set_failbit) {
+ streamsize __n = 0;
+ ios_base::iostate __status = 0;
+ typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
+
+ _STLP_TRY {
+ while (__max_chars(_Num, __n) > 0) {
+ int_type __c = __buf->sbumpc();
+
+ if (__that->_S_eof(__c)) {
+ __status |= __set_failbit ? ios_base::eofbit | ios_base::failbit
+ : ios_base::eofbit;
+ break;
+ }
+
+ else if (__is_delim(_Traits::to_char_type(__c))) {
+ if (__extract_delim)
+ ++__n;
+ else if (__that->_S_eof(__buf->sputbackc(_Traits::to_char_type(__c))))
+ __status |= ios_base::failbit;
+
+ break;
+ }
+ // fbp : added counter increment to pass Dietmar's test
+ ++__n;
+ }
+ }
+ _STLP_CATCH_ALL {
+ __that->_M_handle_exception(ios_base::badbit);
+ }
+
+ if (__status)
+ __that->setstate(__status); // This might throw.
+ return __n;
+}
+
+template < class _CharT, class _Traits, class _Max_Chars, class _Is_Delim, class _Scan_Delim>
+streamsize _STLP_CALL
+_M_ignore_buffered(basic_istream<_CharT, _Traits>* __that,
+ basic_streambuf<_CharT, _Traits>* __buf,
+ streamsize _Num,
+ _Max_Chars __max_chars,
+ _Is_Delim __is_delim, _Scan_Delim __scan_delim,
+ bool __extract_delim, bool __set_failbit) {
+ streamsize __n = 0;
+ bool __at_eof = false;
+ bool __done = false;
+
+ _STLP_TRY {
+ while (__buf->_M_egptr() != __buf->_M_gptr() && !__done) {
+ ptrdiff_t __avail = __buf->_M_egptr() - __buf->_M_gptr();
+ streamsize __m = __max_chars(_Num, __n);
+
+ if (__avail >= __m) { // We have more characters than we need.
+ const _CharT* __last = __buf->_M_gptr() + __STATIC_CAST(ptrdiff_t, __m);
+ const _CharT* __p = __scan_delim(__buf->_M_gptr(), __last);
+ ptrdiff_t __chunk = __p - __buf->_M_gptr();
+ __n += __chunk;
+ __buf->_M_gbump((int)__chunk);
+
+ if (__extract_delim && __p != __last) {
+ __n += 1;
+ __buf->_M_gbump(1);
+ }
+
+ __done = true;
+ }
+
+ else {
+ const _CharT* __p = __scan_delim(__buf->_M_gptr(), __buf->_M_egptr());
+ ptrdiff_t __chunk = __p - __buf->_M_gptr();
+ __n += __chunk;
+ __buf->_M_gbump((int)__chunk);
+
+ if (__p != __buf->_M_egptr()) { // We found delim.
+ if (__extract_delim) {
+ __n += 1;
+ __buf->_M_gbump(1);
+ }
+
+ __done = true;
+ }
+
+ // We didn't find delim. Try to refill the buffer.
+ else if (__that->_S_eof(__buf->sgetc())) {
+ __done = true;
+ __at_eof = true;
+ }
+ }
+ } // Close the while loop.
+ }
+ _STLP_CATCH_ALL {
+ __that->_M_handle_exception(ios_base::badbit);
+ return __n;
+ }
+
+ if (__at_eof)
+ __that->setstate(__set_failbit ? ios_base::eofbit | ios_base::failbit
+ : ios_base::eofbit);
+
+ if (__done)
+ return __n;
+
+ // If execution has reached this point, then we have an empty buffer but
+ // we have not reached eof. What that means is that the streambuf has
+ // decided to switch from buffered to unbuffered input. We switch to
+ // to _M_ignore_unbuffered.
+
+ return __n + _M_ignore_unbuffered(__that, __buf, _Num, __max_chars,
+ __is_delim, __extract_delim, __set_failbit);
+}
+
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::ignore(streamsize __n) {
+ sentry __sentry(*this, _No_Skip_WS());
+ this->_M_gcount = 0;
+
+ if (__sentry) {
+ basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+ typedef _STLP_PRIV _Constant_unary_fun<bool, int_type> _Const_bool;
+ typedef _STLP_PRIV _Constant_binary_fun<streamsize, streamsize, streamsize> _Const_streamsize;
+ const streamsize __maxss = (numeric_limits<streamsize>::max)();
+
+ if (__n == (numeric_limits<int>::max)()) {
+ if (__buf->gptr() != __buf->egptr())
+ _M_gcount = _M_ignore_buffered(this, __buf,
+ __maxss, _Const_streamsize(__maxss),
+ _Const_bool(false),
+ _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
+ false, false);
+ else
+ _M_gcount = _M_ignore_unbuffered(this, __buf,
+ __maxss, _Const_streamsize(__maxss),
+ _Const_bool(false), false, false);
+ }
+ else {
+ if (__buf->gptr() != __buf->egptr())
+ _M_gcount = _M_ignore_buffered(this, __buf,
+ __n, minus<streamsize>(),
+ _Const_bool(false),
+ _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
+ false, false);
+ else
+ _M_gcount = _M_ignore_unbuffered(this, __buf, __n, minus<streamsize>(),
+ _Const_bool(false), false, false);
+ }
+ }
+
+ return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __delim) {
+ sentry __sentry(*this, _No_Skip_WS());
+ this->_M_gcount = 0;
+
+ if (__sentry) {
+ basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+ typedef _STLP_PRIV _Constant_unary_fun<bool, int_type> _Const_bool;
+ typedef _STLP_PRIV _Constant_binary_fun<streamsize, streamsize, streamsize>
+ _Const_streamsize;
+ const streamsize __maxss = (numeric_limits<streamsize>::max)();
+
+ if (__n == (numeric_limits<int>::max)()) {
+ if (__buf->gptr() != __buf->egptr())
+ _M_gcount = _M_ignore_buffered(this, __buf,
+ __maxss, _Const_streamsize(__maxss),
+ _STLP_PRIV _Eq_int_bound<_Traits>(__delim),
+ _STLP_PRIV _Scan_for_int_val<_Traits>(__delim),
+ true, false);
+ else
+ _M_gcount = _M_ignore_unbuffered(this, __buf,
+ __maxss, _Const_streamsize(__maxss),
+ _STLP_PRIV _Eq_int_bound<_Traits>(__delim),
+ true, false);
+ }
+ else {
+ if (__buf->gptr() != __buf->egptr())
+ _M_gcount = _M_ignore_buffered(this, __buf,
+ __n, minus<streamsize>(),
+ _STLP_PRIV _Eq_int_bound<_Traits>(__delim),
+ _STLP_PRIV _Scan_for_int_val<_Traits>(__delim),
+ true, false);
+ else
+ _M_gcount = _M_ignore_unbuffered(this, __buf, __n, minus<streamsize>(),
+ _STLP_PRIV _Eq_int_bound<_Traits>(__delim),
+ true, false);
+ }
+ }
+
+ return *this;
+}
+
+// This member function does not construct a sentry object, because
+// it is called from sentry's constructor.
+template <class _CharT, class _Traits>
+void basic_istream<_CharT, _Traits>::_M_skip_whitespace(bool __set_failbit) {
+ basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+ if (!__buf)
+ this->setstate(ios_base::badbit);
+ else if (__buf->gptr() != __buf->egptr())
+ _M_ignore_buffered(this, __buf,
+ _STLP_PRIV _Is_not_wspace<_Traits>(this->_M_ctype_facet()),
+ _STLP_PRIV _Scan_for_not_wspace<_Traits>(this->_M_ctype_facet()),
+ false, __set_failbit);
+ else
+ _M_ignore_unbuffered(this, __buf,
+ _STLP_PRIV _Is_not_wspace<_Traits>(this->_M_ctype_facet()),
+ false, __set_failbit);
+}
+
+
+// This is a very simple loop that reads characters from __src and puts
+// them into __dest. It looks complicated because of the (standard-
+// mandated) exception handling policy.
+//
+// We stop when we get an exception, when we fail to insert into the
+// output streambuf, or when __is_delim is true.
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template < class _CharT, class _Traits, class _Is_Delim>
+streamsize _STLP_CALL
+__copy_unbuffered(basic_istream<_CharT, _Traits>* __that, basic_streambuf<_CharT, _Traits>* __src,
+ basic_streambuf<_CharT, _Traits>* __dest,
+ _Is_Delim __is_delim,
+ bool __extract_delim, bool __rethrow) {
+ streamsize __extracted = 0;
+ ios_base::iostate __status = 0;
+ typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
+ int_type __c;
+
+ _STLP_TRY {
+ for (;;) {
+ // Get a character. If there's an exception, catch and (maybe) rethrow it.
+ __c = __src->sbumpc();
+
+ // If we failed to get a character, then quit.
+ if (__that->_S_eof(__c)) {
+ __status |= ios_base::eofbit;
+ break;
+ }
+ // If it's the delimiter, then quit.
+ else if (__is_delim(_Traits::to_char_type(__c))) {
+ if (!__extract_delim && !__pushback(__src, _Traits::to_char_type(__c)))
+ __status |= ios_base::failbit;
+ break;
+ }
+ else {
+ // Try to put the character in the output streambuf.
+ bool __failed = false;
+ _STLP_TRY {
+ if (!__that->_S_eof(__dest->sputc(_Traits::to_char_type(__c))))
+ ++__extracted;
+ else
+ __failed = true;
+ }
+ _STLP_CATCH_ALL {
+ __failed = true;
+ }
+
+ // If we failed to put the character in the output streambuf, then
+ // try to push it back to the input streambuf.
+ if (__failed && !__pushback(__src, _Traits::to_char_type(__c)))
+ __status |= ios_base::failbit;
+
+ // fbp : avoiding infinite loop in io-27-6-1-2-3.exp
+ if (__failed)
+ break;
+ }
+
+ } /* for (;;) */
+
+ }
+ // fbp : this try/catch moved here in reasonable assumption
+ // __is_delim never throw (__pushback is guaranteed not to)
+ _STLP_CATCH_ALL {
+ // See 27.6.1.2.3, paragraph 13.
+ if (__rethrow && __extracted == 0)
+ __that->_M_handle_exception(ios_base::failbit);
+ }
+ __that->setstate(__status);
+ return __extracted;
+}
+
+// Buffered copying from one streambuf to another. We copy the characters
+// in chunks, rather than one at a time. We still have to worry about all
+// of the error conditions we checked in __copy_unbuffered, plus one more:
+// the streambuf might decide to switch from a buffered to an unbuffered mode.
+
+template < class _CharT, class _Traits, class _Is_Delim, class _Scan_Delim>
+streamsize _STLP_CALL
+__copy_buffered(basic_istream<_CharT, _Traits>* __that, basic_streambuf<_CharT, _Traits>* __src,
+ basic_streambuf<_CharT, _Traits>* __dest,
+ _Scan_Delim __scan_delim, _Is_Delim __is_delim,
+ bool __extract_delim, bool __rethrow) {
+ streamsize __extracted = 0;
+ ios_base::iostate __status = 0;
+ typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
+ //Borland compiler generates a warning if assignment because value is never used:
+ int_type __c /*= _Traits::eof()*/;
+ _CharT* __first = __src->_M_gptr();
+ ptrdiff_t __avail = __src->_M_egptr() - __first;
+ // fbp : introduced to move catch/try blocks out of the loop
+ bool __do_handle_exceptions = false;
+
+ _STLP_TRY {
+ for (;;) {
+ const _CharT* __last = __scan_delim(__first, __src->_M_egptr());
+
+ // Try to copy the entire input buffer to the output buffer.
+ streamsize __n = __dest->sputn(__first, __extract_delim && __last != __src->_M_egptr()
+ ? (__last - __first) + 1
+ : (__last - __first));
+ __src->_M_gbump((int)__n);
+ __extracted += __n;
+
+ // from this on, catch() will call _M_handle_exceptions()
+ __do_handle_exceptions = true;
+
+ if (__n < __avail) // We found the delimiter, or else failed to
+ break; // copy some characters.
+
+ __c = __src->sgetc();
+
+ // Three possibilities: we succeeded in refilling the buffer, or
+ // we got EOF, or the streambuf has switched to unbuffered mode.
+ __first = __src->_M_gptr();
+ __avail = __src->_M_egptr() - __first;
+
+ if (__avail > 0)
+ {} // dwa 1/16/00 -- suppress a Metrowerks warning
+ else if (__that->_S_eof(__c)) {
+ __status |= ios_base::eofbit;
+ break;
+ }
+ else {
+ return __extracted + __copy_unbuffered(__that, __src, __dest, __is_delim,
+ __extract_delim, __rethrow);
+ }
+
+ __do_handle_exceptions = false;
+ }
+ }
+
+ _STLP_CATCH_ALL {
+ // See 27.6.1.2.3, paragraph 13.
+ if (__rethrow && __do_handle_exceptions && __extracted == 0)
+ __that->_M_handle_exception(ios_base::failbit);
+ }
+
+ if (__status)
+ __that->setstate(__status); // This might throw.
+ return __extracted;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>
+ ::get(basic_streambuf<_CharT, _Traits>& __dest, _CharT __delim) {
+ sentry __sentry(*this, _No_Skip_WS());
+ this->_M_gcount = 0;
+
+ if (__sentry) {
+ basic_streambuf<_CharT, _Traits>* __src = this->rdbuf();
+
+ if (__src)
+ this->_M_gcount = __src->egptr() != __src->gptr()
+ ? _STLP_PRIV __copy_buffered(this, __src, &__dest,
+ _STLP_PRIV _Scan_for_char_val<_Traits>(__delim),
+ _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
+ false, false)
+ : _STLP_PRIV __copy_unbuffered(this, __src, &__dest,
+ _STLP_PRIV _Eq_char_bound<_Traits>(__delim),
+ false, false);
+ }
+
+ if (this->_M_gcount == 0)
+ this->setstate(ios_base::failbit);
+
+ return *this;
+}
+
+// Copying characters into a streambuf.
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>
+ ::operator>>(basic_streambuf<_CharT, _Traits>* __dest) {
+ streamsize __n = 0;
+ typedef typename basic_istream<_CharT, _Traits>::sentry _Sentry;
+ _Sentry __sentry(*this);
+ if (__sentry) {
+ basic_streambuf<_CharT, _Traits>* __src = this->rdbuf();
+ if (__src && __dest)
+ __n = __src->egptr() != __src->gptr()
+ ? _STLP_PRIV __copy_buffered(this, __src, __dest,
+ _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
+ _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
+ false, true)
+ : _STLP_PRIV __copy_unbuffered(this, __src, __dest,
+ _STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
+ false, true);
+ }
+
+ if (__n == 0)
+ this->setstate(ios_base::failbit);
+
+ return *this;
+}
+
+// ----------------------------------------------------------------
+// basic_iostream<> class
+// ----------------------------------------------------------------
+
+template <class _CharT, class _Traits>
+basic_iostream<_CharT, _Traits>
+ ::basic_iostream(basic_streambuf<_CharT, _Traits>* __buf)
+ : basic_ios<_CharT, _Traits>(),
+ basic_istream<_CharT, _Traits>(__buf),
+ basic_ostream<_CharT, _Traits>(__buf) {
+ this->init(__buf);
+}
+
+template <class _CharT, class _Traits>
+basic_iostream<_CharT, _Traits>::~basic_iostream()
+{}
+
+_STLP_END_NAMESPACE
+
+#undef __BIS_int_type__
+#undef __BIS_pos_type__
+#undef __BIS_off_type__
+
+#endif /* _STLP_ISTREAM_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_istream.h b/sources/android/stlport/stlport/stl/_istream.h
new file mode 100644
index 0000000..6b38d03
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_istream.h
@@ -0,0 +1,359 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_INTERNAL_ISTREAM
+#define _STLP_INTERNAL_ISTREAM
+
+// this block is included by _ostream.h, we include it here to lower #include level
+#if defined (_STLP_HAS_WCHAR_T) && !defined (_STLP_INTERNAL_CWCHAR)
+# include <stl/_cwchar.h>
+#endif
+
+#ifndef _STLP_INTERNAL_IOS_H
+# include <stl/_ios.h> // For basic_ios<>. Includes <iosfwd>.
+#endif
+
+#ifndef _STLP_INTERNAL_OSTREAM_H
+# include <stl/_ostream.h> // Needed as a base class of basic_iostream.
+#endif
+
+#ifndef _STLP_INTERNAL_ISTREAMBUF_ITERATOR_H
+# include <stl/_istreambuf_iterator.h>
+#endif
+
+#include <stl/_ctraits_fns.h> // Helper functions that allow char traits
+ // to be used as function objects.
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+template <class _CharT, class _Traits>
+class _Isentry;
+#endif
+
+struct _No_Skip_WS {}; // Dummy class used by sentry.
+
+template <class _CharT, class _Traits>
+bool _M_init_skip(basic_istream<_CharT, _Traits>& __istr);
+template <class _CharT, class _Traits>
+bool _M_init_noskip(basic_istream<_CharT, _Traits>& __istr);
+
+//----------------------------------------------------------------------
+// Class basic_istream, a class that performs formatted input through
+// a stream buffer.
+
+// The second template parameter, _Traits, defaults to char_traits<_CharT>.
+// The default is declared in header <iosfwd>, and it isn't declared here
+// because C++ language rules do not allow it to be declared twice.
+
+template <class _CharT, class _Traits>
+class basic_istream : virtual public basic_ios<_CharT, _Traits> {
+ typedef basic_istream<_CharT, _Traits> _Self;
+
+#if defined (_STLP_MSVC) && (_STLP_MSVC >= 1300 && _STLP_MSVC <= 1310)
+ //explicitely defined as private to avoid warnings:
+ basic_istream(_Self const&);
+ _Self& operator = (_Self const&);
+#endif
+
+public:
+ // Types
+ typedef _CharT char_type;
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+ typedef _Traits traits_type;
+ typedef basic_ios<_CharT, _Traits> _Basic_ios;
+
+ typedef basic_ios<_CharT, _Traits>& (_STLP_CALL *__ios_fn)(basic_ios<_CharT, _Traits>&);
+ typedef ios_base& (_STLP_CALL *__ios_base_fn)(ios_base&);
+ typedef _Self& (_STLP_CALL *__istream_fn)(_Self&);
+
+public: // Constructor and destructor.
+ explicit basic_istream(basic_streambuf<_CharT, _Traits>* __buf) :
+ basic_ios<_CharT, _Traits>(), _M_gcount(0) {
+ this->init(__buf);
+ }
+ ~basic_istream() {};
+
+public: // Nested sentry class.
+
+public: // Hooks for manipulators. The arguments are
+ // function pointers.
+ _Self& operator>> (__istream_fn __f) { return __f(*this); }
+ _Self& operator>> (__ios_fn __f) { __f(*this); return *this; }
+ _Self& operator>> (__ios_base_fn __f) { __f(*this); return *this; }
+
+public: // Formatted input of numbers.
+ _Self& operator>> (short& __val);
+ _Self& operator>> (int& __val);
+ _Self& operator>> (unsigned short& __val);
+ _Self& operator>> (unsigned int& __val);
+ _Self& operator>> (long& __val);
+ _Self& operator>> (unsigned long& __val);
+#ifdef _STLP_LONG_LONG
+ _Self& operator>> (_STLP_LONG_LONG& __val);
+ _Self& operator>> (unsigned _STLP_LONG_LONG& __val);
+#endif
+ _Self& operator>> (float& __val);
+ _Self& operator>> (double& __val);
+# ifndef _STLP_NO_LONG_DOUBLE
+ _Self& operator>> (long double& __val);
+# endif
+# ifndef _STLP_NO_BOOL
+ _Self& operator>> (bool& __val);
+# endif
+ _Self& operator>> (void*& __val);
+
+public: // Copying characters into a streambuf.
+ _Self& operator>>(basic_streambuf<_CharT, _Traits>*);
+
+public: // Unformatted input.
+ streamsize gcount() const { return _M_gcount; }
+ int_type peek();
+
+public: // get() for single characters
+ int_type get();
+ _Self& get(char_type& __c);
+
+public: // get() for character arrays.
+ _Self& get(char_type* __s, streamsize __n, char_type __delim);
+ _Self& get(char_type* __s, streamsize __n)
+ { return get(__s, __n, this->widen('\n')); }
+
+public: // get() for streambufs
+ _Self& get(basic_streambuf<_CharT, _Traits>& __buf,
+ char_type __delim);
+ _Self& get(basic_streambuf<_CharT, _Traits>& __buf)
+ { return get(__buf, this->widen('\n')); }
+
+public: // getline()
+ _Self& getline(char_type* __s, streamsize __n, char_type delim);
+ _Self& getline(char_type* __s, streamsize __n)
+ { return getline(__s, __n, this->widen('\n')); }
+
+public: // read(), readsome(), ignore()
+ _Self& ignore();
+ _Self& ignore(streamsize __n);
+ _Self& ignore(streamsize __n, int_type __delim);
+
+ _Self& read(char_type* __s, streamsize __n);
+ streamsize readsome(char_type* __s, streamsize __n);
+
+public: // putback
+ _Self& putback(char_type __c);
+ _Self& unget();
+
+public: // Positioning and buffer control.
+ int sync();
+
+ pos_type tellg();
+ _Self& seekg(pos_type __pos);
+ _Self& seekg(off_type, ios_base::seekdir);
+
+public: // Helper functions for non-member extractors.
+ void _M_formatted_get(_CharT& __c);
+ void _M_formatted_get(_CharT* __s);
+ void _M_skip_whitespace(bool __set_failbit);
+
+private: // Number of characters extracted by the
+ streamsize _M_gcount; // most recent unformatted input function.
+
+public:
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+ // If we are using DLL specs, we have not to use inner classes
+ // end class declaration here
+ typedef _Isentry<_CharT, _Traits> sentry;
+};
+# define sentry _Isentry
+template <class _CharT, class _Traits>
+class _Isentry {
+ typedef _Isentry<_CharT, _Traits> _Self;
+# else
+ class sentry {
+ typedef sentry _Self;
+#endif
+
+ private:
+ const bool _M_ok;
+ // basic_streambuf<_CharT, _Traits>* _M_buf;
+
+ public:
+ typedef _Traits traits_type;
+
+ explicit sentry(basic_istream<_CharT, _Traits>& __istr,
+ bool __noskipws = false) :
+ _M_ok((__noskipws || !(__istr.flags() & ios_base::skipws)) ? _M_init_noskip(__istr) : _M_init_skip(__istr) )
+ /* , _M_buf(__istr.rdbuf()) */
+ {}
+
+ // Calling this constructor is the same as calling the previous one with
+ // __noskipws = true, except that it doesn't require a runtime test.
+ sentry(basic_istream<_CharT, _Traits>& __istr, _No_Skip_WS) : /* _M_buf(__istr.rdbuf()), */
+ _M_ok(_M_init_noskip(__istr)) {}
+
+ ~sentry() {}
+
+ operator bool() const { return _M_ok; }
+
+ private: // Disable assignment and copy constructor.
+ //Implementation is here only to avoid warning with some compilers.
+ sentry(const _Self&) : _M_ok(false) {}
+ _Self& operator=(const _Self&) { return *this; }
+ };
+
+# if defined (_STLP_USE_TEMPLATE_EXPORT)
+# undef sentry
+# else
+ // close basic_istream class definition here
+};
+# endif
+
+# if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS _Isentry<char, char_traits<char> >;
+_STLP_EXPORT_TEMPLATE_CLASS basic_istream<char, char_traits<char> >;
+# if ! defined (_STLP_NO_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS _Isentry<wchar_t, char_traits<wchar_t> >;
+_STLP_EXPORT_TEMPLATE_CLASS basic_istream<wchar_t, char_traits<wchar_t> >;
+# endif
+# endif /* _STLP_USE_TEMPLATE_EXPORT */
+
+// Non-member character and string extractor functions.
+template <class _CharT, class _Traits>
+inline basic_istream<_CharT, _Traits>& _STLP_CALL
+operator>>(basic_istream<_CharT, _Traits>& __in_str, _CharT& __c) {
+ __in_str._M_formatted_get(__c);
+ return __in_str;
+}
+
+template <class _Traits>
+inline basic_istream<char, _Traits>& _STLP_CALL
+operator>>(basic_istream<char, _Traits>& __in_str, unsigned char& __c) {
+ __in_str._M_formatted_get(__REINTERPRET_CAST(char&,__c));
+ return __in_str;
+}
+
+template <class _Traits>
+inline basic_istream<char, _Traits>& _STLP_CALL
+operator>>(basic_istream<char, _Traits>& __in_str, signed char& __c) {
+ __in_str._M_formatted_get(__REINTERPRET_CAST(char&,__c));
+ return __in_str;
+}
+
+template <class _CharT, class _Traits>
+inline basic_istream<_CharT, _Traits>& _STLP_CALL
+operator>>(basic_istream<_CharT, _Traits>& __in_str, _CharT* __s) {
+ __in_str._M_formatted_get(__s);
+ return __in_str;
+}
+
+template <class _Traits>
+inline basic_istream<char, _Traits>& _STLP_CALL
+operator>>(basic_istream<char, _Traits>& __in_str, unsigned char* __s) {
+ __in_str._M_formatted_get(__REINTERPRET_CAST(char*,__s));
+ return __in_str;
+}
+
+template <class _Traits>
+inline basic_istream<char, _Traits>& _STLP_CALL
+operator>>(basic_istream<char, _Traits>& __in_str, signed char* __s) {
+ __in_str._M_formatted_get(__REINTERPRET_CAST(char*,__s));
+ return __in_str;
+}
+
+//----------------------------------------------------------------------
+// istream manipulator.
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& _STLP_CALL
+ws(basic_istream<_CharT, _Traits>& __istr) {
+ if (!__istr.eof()) {
+ typedef typename basic_istream<_CharT, _Traits>::sentry _Sentry;
+ _Sentry __sentry(__istr, _No_Skip_WS()); // Don't skip whitespace.
+ if (__sentry)
+ __istr._M_skip_whitespace(false);
+ }
+ return __istr;
+}
+
+// Helper functions for istream<>::sentry constructor.
+template <class _CharT, class _Traits>
+inline bool _M_init_skip(basic_istream<_CharT, _Traits>& __istr) {
+ if (__istr.good()) {
+ if (__istr.tie())
+ __istr.tie()->flush();
+
+ __istr._M_skip_whitespace(true);
+ }
+
+ if (!__istr.good()) {
+ __istr.setstate(ios_base::failbit);
+ return false;
+ } else
+ return true;
+}
+
+template <class _CharT, class _Traits>
+inline bool _M_init_noskip(basic_istream<_CharT, _Traits>& __istr) {
+ if (__istr.good()) {
+ if (__istr.tie())
+ __istr.tie()->flush();
+
+ if (!__istr.rdbuf())
+ __istr.setstate(ios_base::badbit);
+ }
+ else
+ __istr.setstate(ios_base::failbit);
+ return __istr.good();
+}
+
+//----------------------------------------------------------------------
+// Class iostream.
+template <class _CharT, class _Traits>
+class basic_iostream
+ : public basic_istream<_CharT, _Traits>,
+ public basic_ostream<_CharT, _Traits>
+{
+public:
+ typedef basic_ios<_CharT, _Traits> _Basic_ios;
+
+ explicit basic_iostream(basic_streambuf<_CharT, _Traits>* __buf);
+ virtual ~basic_iostream();
+};
+
+# if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS basic_iostream<char, char_traits<char> >;
+
+# if ! defined (_STLP_NO_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS basic_iostream<wchar_t, char_traits<wchar_t> >;
+# endif
+# endif /* _STLP_USE_TEMPLATE_EXPORT */
+
+template <class _CharT, class _Traits>
+basic_streambuf<_CharT, _Traits>* _STLP_CALL _M_get_istreambuf(basic_istream<_CharT, _Traits>& __istr)
+{ return __istr.rdbuf(); }
+
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_istream.c>
+#endif
+
+#endif /* _STLP_INTERNAL_ISTREAM */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_istreambuf_iterator.h b/sources/android/stlport/stlport/stl/_istreambuf_iterator.h
new file mode 100644
index 0000000..9f340cb
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_istreambuf_iterator.h
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+// WARNING: This is an internal header file, included by other C++
+// standard library headers. You should not attempt to use this header
+// file directly.
+
+
+#ifndef _STLP_INTERNAL_ISTREAMBUF_ITERATOR_H
+#define _STLP_INTERNAL_ISTREAMBUF_ITERATOR_H
+
+#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
+# include <stl/_iterator_base.h>
+#endif
+
+#ifndef _STLP_INTERNAL_STREAMBUF
+# include <stl/_streambuf.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+// defined in _istream.h
+template <class _CharT, class _Traits>
+extern basic_streambuf<_CharT, _Traits>* _STLP_CALL _M_get_istreambuf(basic_istream<_CharT, _Traits>& ) ;
+
+// We do not read any characters until operator* is called. operator* calls sgetc
+// unless the iterator is unchanged from the last call in which case a cached value is
+// used. Calls to operator++ use sbumpc.
+
+template<class _CharT, class _Traits>
+class istreambuf_iterator :
+ public iterator<input_iterator_tag, _CharT, typename _Traits::off_type, _CharT*, _CharT&>
+{
+public:
+ typedef _CharT char_type;
+ typedef _Traits traits_type;
+ typedef typename _Traits::int_type int_type;
+ typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+ typedef basic_istream<_CharT, _Traits> istream_type;
+
+ typedef input_iterator_tag iterator_category;
+ typedef _CharT value_type;
+ typedef typename _Traits::off_type difference_type;
+ typedef const _CharT* pointer;
+ typedef const _CharT& reference;
+
+public:
+ istreambuf_iterator(streambuf_type* __p = 0) { this->_M_init(__p); }
+ // istreambuf_iterator(basic_istream<_CharT, _Traits>& __is) { this->_M_init(_M_get_istreambuf(__is)); }
+ inline istreambuf_iterator(basic_istream<_CharT, _Traits>& __is);
+
+ char_type operator*() const { this->_M_getc(); return _M_c; }
+ istreambuf_iterator<_CharT, _Traits>& operator++() {
+ _M_buf->sbumpc();
+ _M_have_c = false;
+ return *this;
+ }
+ istreambuf_iterator<_CharT, _Traits> operator++(int);
+
+ bool equal(const istreambuf_iterator<_CharT, _Traits>& __i) const {
+ if (this->_M_buf)
+ this->_M_getc();
+ if (__i._M_buf)
+ __i._M_getc();
+ return this->_M_eof == __i._M_eof;
+ }
+
+private:
+ void _M_init(streambuf_type* __p) {
+ _M_buf = __p;
+ _M_eof = (__p == 0);
+ _M_have_c = false;
+ }
+
+ void _M_getc() const {
+ if (_M_have_c)
+ return;
+ int_type __c = _M_buf->sgetc();
+ _STLP_MUTABLE(_Self, _M_c) = traits_type::to_char_type(__c);
+ _STLP_MUTABLE(_Self, _M_eof) = traits_type::eq_int_type(__c, traits_type::eof());
+ _STLP_MUTABLE(_Self, _M_have_c) = true;
+ }
+
+private:
+ streambuf_type* _M_buf;
+ mutable _CharT _M_c;
+ mutable bool _M_eof;
+ mutable bool _M_have_c;
+};
+
+template<class _CharT, class _Traits>
+inline istreambuf_iterator<_CharT, _Traits>::istreambuf_iterator(basic_istream<_CharT, _Traits>& __is)
+{ this->_M_init(_M_get_istreambuf(__is)); }
+
+template<class _CharT, class _Traits>
+inline bool _STLP_CALL operator==(const istreambuf_iterator<_CharT, _Traits>& __x,
+ const istreambuf_iterator<_CharT, _Traits>& __y) {
+ return __x.equal(__y);
+}
+
+#ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
+
+template<class _CharT, class _Traits>
+inline bool _STLP_CALL operator!=(const istreambuf_iterator<_CharT, _Traits>& __x,
+ const istreambuf_iterator<_CharT, _Traits>& __y) {
+ return !__x.equal(__y);
+}
+
+#endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
+
+# if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS istreambuf_iterator<char, char_traits<char> >;
+# if defined (INSTANTIATE_WIDE_STREAMS)
+_STLP_EXPORT_TEMPLATE_CLASS istreambuf_iterator<wchar_t, char_traits<wchar_t> >;
+# endif
+# endif /* _STLP_USE_TEMPLATE_EXPORT */
+
+# ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
+template <class _CharT, class _Traits>
+inline input_iterator_tag _STLP_CALL iterator_category(const istreambuf_iterator<_CharT, _Traits>&) { return input_iterator_tag(); }
+template <class _CharT, class _Traits>
+inline streamoff* _STLP_CALL
+distance_type(const istreambuf_iterator<_CharT, _Traits>&) { return (streamoff*)0; }
+template <class _CharT, class _Traits>
+inline _CharT* _STLP_CALL value_type(const istreambuf_iterator<_CharT, _Traits>&) { return (_CharT*)0; }
+# endif
+
+template <class _CharT, class _Traits>
+istreambuf_iterator<_CharT, _Traits>
+istreambuf_iterator<_CharT, _Traits>::operator++(int) {
+ _M_getc(); // __tmp should avoid any future actions under
+ // underlined buffer---during call of operator *()
+ // (due to buffer for *this and __tmp are the same).
+ istreambuf_iterator<_CharT, _Traits> __tmp = *this;
+ _M_buf->sbumpc();
+ _M_have_c = false;
+ return __tmp;
+}
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_ISTREAMBUF_ITERATOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/stl/_iterator.h b/sources/android/stlport/stlport/stl/_iterator.h
new file mode 100644
index 0000000..8e3b7b0
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_iterator.h
@@ -0,0 +1,265 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+#define _STLP_INTERNAL_ITERATOR_H
+
+#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
+# include <stl/_iterator_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+// This is the new version of reverse_iterator, as defined in the
+// draft C++ standard. It relies on the iterator_traits template,
+// which in turn relies on partial specialization. The class
+// reverse_bidirectional_iterator is no longer part of the draft
+// standard, but it is retained for backward compatibility.
+
+template <class _Iterator>
+class reverse_iterator :
+ public iterator<typename iterator_traits<_Iterator>::iterator_category,
+ typename iterator_traits<_Iterator>::value_type,
+ typename iterator_traits<_Iterator>::difference_type,
+ typename iterator_traits<_Iterator>::pointer,
+ typename iterator_traits<_Iterator>::reference> {
+protected:
+ _Iterator current;
+ typedef reverse_iterator<_Iterator> _Self;
+public:
+ typedef typename iterator_traits<_Iterator>::difference_type difference_type;
+ // pointer type required for arrow operator hidden behind _STLP_DEFINE_ARROW_OPERATOR:
+ typedef typename iterator_traits<_Iterator>::pointer pointer;
+ typedef typename iterator_traits<_Iterator>::reference reference;
+ typedef _Iterator iterator_type;
+public:
+ reverse_iterator() {}
+ explicit reverse_iterator(iterator_type __x) : current(__x) {}
+ reverse_iterator(const _Self& __x) : current(__x.current) {}
+ _Self& operator = (const _Self& __x) { current = __x.base(); return *this; }
+# if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _Iter>
+ reverse_iterator(const reverse_iterator<_Iter>& __x) : current(__x.base()) {}
+ template <class _Iter>
+ _Self& operator = (const reverse_iterator<_Iter>& __x) { current = __x.base(); return *this; }
+# endif /* _STLP_MEMBER_TEMPLATES */
+
+ iterator_type base() const { return current; }
+ reference operator*() const {
+ _Iterator __tmp = current;
+ return *--__tmp;
+ }
+ _STLP_DEFINE_ARROW_OPERATOR
+ _Self& operator++() {
+ --current;
+ return *this;
+ }
+ _Self operator++(int) {
+ _Self __tmp = *this;
+ --current;
+ return __tmp;
+ }
+ _Self& operator--() {
+ ++current;
+ return *this;
+ }
+ _Self operator--(int) {
+ _Self __tmp = *this;
+ ++current;
+ return __tmp;
+ }
+
+ _Self operator+(difference_type __n) const { return _Self(current - __n); }
+ _Self& operator+=(difference_type __n) {
+ current -= __n;
+ return *this;
+ }
+ _Self operator-(difference_type __n) const { return _Self(current + __n); }
+ _Self& operator-=(difference_type __n) {
+ current += __n;
+ return *this;
+ }
+ reference operator[](difference_type __n) const { return *(*this + __n); }
+};
+
+template <class _Iterator>
+inline bool _STLP_CALL operator==(const reverse_iterator<_Iterator>& __x,
+ const reverse_iterator<_Iterator>& __y)
+{ return __x.base() == __y.base(); }
+
+template <class _Iterator>
+inline bool _STLP_CALL operator<(const reverse_iterator<_Iterator>& __x,
+ const reverse_iterator<_Iterator>& __y)
+{ return __y.base() < __x.base(); }
+
+# if defined (_STLP_USE_SEPARATE_RELOPS_NAMESPACE)
+template <class _Iterator>
+inline bool _STLP_CALL operator!=(const reverse_iterator<_Iterator>& __x,
+ const reverse_iterator<_Iterator>& __y)
+{ return !(__x == __y); }
+
+template <class _Iterator>
+inline bool _STLP_CALL operator>(const reverse_iterator<_Iterator>& __x,
+ const reverse_iterator<_Iterator>& __y)
+{ return __y < __x; }
+
+template <class _Iterator>
+inline bool _STLP_CALL operator<=(const reverse_iterator<_Iterator>& __x,
+ const reverse_iterator<_Iterator>& __y)
+{ return !(__y < __x); }
+
+template <class _Iterator>
+inline bool _STLP_CALL operator>=(const reverse_iterator<_Iterator>& __x,
+ const reverse_iterator<_Iterator>& __y)
+{ return !(__x < __y); }
+# endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
+
+template <class _Iterator>
+# if defined (__SUNPRO_CC)
+inline ptrdiff_t _STLP_CALL
+# else
+inline typename reverse_iterator<_Iterator>::difference_type _STLP_CALL
+# endif
+operator-(const reverse_iterator<_Iterator>& __x,
+ const reverse_iterator<_Iterator>& __y)
+{ return __y.base() - __x.base(); }
+
+template <class _Iterator, class _DifferenceType>
+inline reverse_iterator<_Iterator> _STLP_CALL
+operator+(_DifferenceType n,const reverse_iterator<_Iterator>& x)
+{ return x.operator+(n); }
+#endif
+
+template <class _Container>
+class back_insert_iterator
+ : public iterator<output_iterator_tag, void, void, void, void> {
+ typedef back_insert_iterator<_Container> _Self;
+protected:
+ //c is a Standard name (24.4.2.1), do no make it STLport naming convention compliant.
+ _Container *container;
+public:
+ typedef _Container container_type;
+ typedef output_iterator_tag iterator_category;
+
+ explicit back_insert_iterator(_Container& __x) : container(&__x) {}
+
+ _Self& operator=(const _Self& __other) {
+ container = __other.container;
+ return *this;
+ }
+ _Self& operator=(const typename _Container::value_type& __val) {
+ container->push_back(__val);
+ return *this;
+ }
+ _Self& operator*() { return *this; }
+ _Self& operator++() { return *this; }
+ _Self operator++(int) { return *this; }
+};
+
+template <class _Container>
+inline back_insert_iterator<_Container> _STLP_CALL back_inserter(_Container& __x)
+{ return back_insert_iterator<_Container>(__x); }
+
+template <class _Container>
+class front_insert_iterator
+ : public iterator<output_iterator_tag, void, void, void, void> {
+ typedef front_insert_iterator<_Container> _Self;
+protected:
+ //c is a Standard name (24.4.2.3), do no make it STLport naming convention compliant.
+ _Container *container;
+public:
+ typedef _Container container_type;
+ typedef output_iterator_tag iterator_category;
+ explicit front_insert_iterator(_Container& __x) : container(&__x) {}
+
+ _Self& operator=(const _Self& __other) {
+ container = __other.container;
+ return *this;
+ }
+ _Self& operator=(const typename _Container::value_type& __val) {
+ container->push_front(__val);
+ return *this;
+ }
+ _Self& operator*() { return *this; }
+ _Self& operator++() { return *this; }
+ _Self operator++(int) { return *this; }
+};
+
+template <class _Container>
+inline front_insert_iterator<_Container> _STLP_CALL front_inserter(_Container& __x)
+{ return front_insert_iterator<_Container>(__x); }
+
+template <class _Container>
+class insert_iterator
+ : public iterator<output_iterator_tag, void, void, void, void> {
+ typedef insert_iterator<_Container> _Self;
+protected:
+ //container is a Standard name (24.4.2.5), do no make it STLport naming convention compliant.
+ _Container *container;
+ typename _Container::iterator _M_iter;
+public:
+ typedef _Container container_type;
+ typedef output_iterator_tag iterator_category;
+ insert_iterator(_Container& __x, typename _Container::iterator __i)
+ : container(&__x), _M_iter(__i) {}
+
+ _Self& operator=(_Self const& __other) {
+ container = __other.container;
+ _M_iter = __other._M_iter;
+ return *this;
+ }
+ _Self& operator=(const typename _Container::value_type& __val) {
+ _M_iter = container->insert(_M_iter, __val);
+ ++_M_iter;
+ return *this;
+ }
+ _Self& operator*() { return *this; }
+ _Self& operator++() { return *this; }
+ _Self& operator++(int) { return *this; }
+};
+
+template <class _Container, class _Iterator>
+inline insert_iterator<_Container> _STLP_CALL
+inserter(_Container& __x, _Iterator __i) {
+ typedef typename _Container::iterator __iter;
+ return insert_iterator<_Container>(__x, __iter(__i));
+}
+
+_STLP_END_NAMESPACE
+
+#if ! defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) || defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
+# include <stl/_iterator_old.h>
+#endif
+
+#endif /* _STLP_INTERNAL_ITERATOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_iterator_base.h b/sources/android/stlport/stlport/stl/_iterator_base.h
new file mode 100644
index 0000000..ef59048
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_iterator_base.h
@@ -0,0 +1,525 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
+#define _STLP_INTERNAL_ITERATOR_BASE_H
+
+#ifndef _STLP_INTERNAL_CSTDDEF
+# include <stl/_cstddef.h>
+#endif
+
+//# if defined (_STLP_IMPORT_VENDOR_CSTD) && ! defined (_STLP_VENDOR_GLOBAL_CSTD)
+//_STLP_BEGIN_NAMESPACE
+//using namespace _STLP_VENDOR_CSTD;
+//_STLP_END_NAMESPACE
+//#endif /* _STLP_IMPORT_VENDOR_CSTD */
+
+#if !defined(_STLP_USE_OLD_HP_ITERATOR_QUERIES) && !defined(_STLP_CLASS_PARTIAL_SPECIALIZATION)
+# ifndef _STLP_TYPE_TRAITS_H
+# include <stl/type_traits.h>
+# endif
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+struct input_iterator_tag {};
+struct output_iterator_tag {};
+struct forward_iterator_tag : public input_iterator_tag {};
+struct bidirectional_iterator_tag : public forward_iterator_tag {};
+struct random_access_iterator_tag : public bidirectional_iterator_tag {};
+
+template <class _Category, class _Tp, _STLP_DFL_TMPL_PARAM(_Distance,ptrdiff_t),
+ _STLP_DFL_TMPL_PARAM(_Pointer,_Tp*), _STLP_DFL_TMPL_PARAM(_Reference,_Tp&) >
+struct iterator {
+ typedef _Category iterator_category;
+ typedef _Tp value_type;
+ typedef _Distance difference_type;
+ typedef _Pointer pointer;
+ typedef _Reference reference;
+};
+_STLP_TEMPLATE_NULL
+struct iterator<output_iterator_tag, void, void, void, void> {
+ typedef output_iterator_tag iterator_category;
+#ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
+ typedef void value_type;
+ typedef void difference_type;
+ typedef void pointer;
+ typedef void reference;
+#endif
+};
+
+#if defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
+# define _STLP_ITERATOR_CATEGORY(_It, _Tp) _STLP_STD::iterator_category(_It)
+# define _STLP_DISTANCE_TYPE(_It, _Tp) _STLP_STD::distance_type(_It)
+# define _STLP_VALUE_TYPE(_It, _Tp) _STLP_STD::value_type(_It)
+//Old HP iterator queries do not give information about the iterator
+//associated reference type so we consider that it is not a real reference.
+# define _STLP_IS_REF_TYPE_REAL_REF(_It, _Tp) __false_type()
+#else
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+# define _STLP_VALUE_TYPE(_It, _Tp) (_STLP_TYPENAME _STLP_STD::iterator_traits< _Tp >::value_type*)0
+# define _STLP_DISTANCE_TYPE(_It, _Tp) (_STLP_TYPENAME _STLP_STD::iterator_traits< _Tp >::difference_type*)0
+# if defined (__BORLANDC__) || defined (__SUNPRO_CC) || ( defined (__MWERKS__) && (__MWERKS__ <= 0x2303)) || \
+ (defined (__sgi) && defined (_COMPILER_VERSION)) || defined (__DMC__)
+# define _STLP_ITERATOR_CATEGORY(_It, _Tp) _STLP_STD::iterator_traits< _Tp >::iterator_category()
+# else
+# define _STLP_ITERATOR_CATEGORY(_It, _Tp) _STLP_TYPENAME _STLP_STD::iterator_traits< _Tp >::iterator_category()
+# endif
+# define _STLP_IS_REF_TYPE_REAL_REF(_It, _Tp) _STLP_STD::_IsRefType< _STLP_TYPENAME _STLP_STD::iterator_traits< _Tp >::reference >::_Ret()
+# else
+# define _STLP_ITERATOR_CATEGORY(_It, _Tp) _STLP_STD::__iterator_category(_It, _STLP_STD::_IsPtrType<_Tp>::_Ret())
+# define _STLP_DISTANCE_TYPE(_It, _Tp) _STLP_STD::__distance_type(_It, _STLP_STD::_IsPtrType<_Tp>::_Ret())
+# define _STLP_VALUE_TYPE(_It, _Tp) _STLP_STD::__value_type(_It, _STLP_STD::_IsPtrType<_Tp>::_Ret())
+# define _STLP_IS_REF_TYPE_REAL_REF(_It, _Tp) __false_type()
+# endif
+#endif
+
+#if defined (_STLP_DONT_REDEFINE_STD) && defined (_STLP_WHOLE_NATIVE_STD)
+/* In this mode we will see both STLport implementation and native
+ * one. To allow some interaction between both implementations through
+ * iterators we have to map std iterator categories to stlport ones. This
+ * way we will be able to initialize STLport containers with native
+ * iterators, the other side won't work except when STLport iterators are
+ * simple pointers. */
+
+_STLP_END_NAMESPACE
+
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <iterator>
+# else
+# include _STLP_NATIVE_HEADER(iterator)
+# endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _IteCat>
+struct _CategoryMapping
+{ typedef _IteCat _Tag; };
+
+_STLP_TEMPLATE_NULL
+struct _CategoryMapping<::std::input_iterator_tag>
+{ typedef input_iterator_tag _Tag; };
+_STLP_TEMPLATE_NULL
+struct _CategoryMapping<::std::output_iterator_tag>
+{ typedef output_iterator_tag _Tag; };
+_STLP_TEMPLATE_NULL
+struct _CategoryMapping<::std::forward_iterator_tag>
+{ typedef forward_iterator_tag _Tag; };
+_STLP_TEMPLATE_NULL
+struct _CategoryMapping<::std::bidirectional_iterator_tag>
+{ typedef bidirectional_iterator_tag _Tag; };
+_STLP_TEMPLATE_NULL
+struct _CategoryMapping<::std::random_access_iterator_tag>
+{ typedef random_access_iterator_tag _Tag; };
+
+template <class _Iterator>
+struct iterator_traits {
+ typedef typename _Iterator::iterator_category _OriginalTag;
+ typedef typename _CategoryMapping<_OriginalTag>::_Tag iterator_category;
+#else
+template <class _Iterator>
+struct iterator_traits {
+ typedef typename _Iterator::iterator_category iterator_category;
+#endif
+ typedef typename _Iterator::value_type value_type;
+ typedef typename _Iterator::difference_type difference_type;
+ typedef typename _Iterator::pointer pointer;
+ typedef typename _Iterator::reference reference;
+};
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (__SUNPRO_CC)
+# define _STLP_DIFFERENCE_TYPE(_Iterator) typename iterator_traits<_Iterator>::difference_type
+#else
+# define _STLP_DIFFERENCE_TYPE(_Iterator) ptrdiff_t
+#endif
+
+#ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
+
+// fbp : this order keeps gcc happy
+template <class _Tp>
+struct iterator_traits<const _Tp*> {
+ typedef random_access_iterator_tag iterator_category;
+ typedef _Tp value_type;
+ typedef ptrdiff_t difference_type;
+ typedef const _Tp* pointer;
+ typedef const _Tp& reference;
+};
+
+template <class _Tp>
+struct iterator_traits<_Tp*> {
+ typedef random_access_iterator_tag iterator_category;
+ typedef _Tp value_type;
+ typedef ptrdiff_t difference_type;
+ typedef _Tp* pointer;
+ typedef _Tp& reference;
+};
+
+# if defined (__BORLANDC__)
+template <class _Tp>
+struct iterator_traits<_Tp* const> {
+ typedef random_access_iterator_tag iterator_category;
+ typedef _Tp value_type;
+ typedef ptrdiff_t difference_type;
+ typedef const _Tp* pointer;
+ typedef const _Tp& reference;
+};
+# endif
+
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+_STLP_END_NAMESPACE
+#include <stl/_ptrs_specialize.h>
+_STLP_BEGIN_NAMESPACE
+
+#ifndef _STLP_USE_OLD_HP_ITERATOR_QUERIES
+// The overloaded functions iterator_category, distance_type, and
+// value_type are not part of the C++ standard. (They have been
+// replaced by struct iterator_traits.) They are included for
+// backward compatibility with the HP STL.
+// We introduce internal names for these functions.
+
+# ifndef _STLP_CLASS_PARTIAL_SPECIALIZATION
+
+template <class _Tp>
+inline _STLP_STD::random_access_iterator_tag
+__iterator_category(const _Tp*, const __true_type&)
+{ return _STLP_STD::random_access_iterator_tag(); }
+
+template <class _Iter>
+inline _STLP_TYPENAME_ON_RETURN_TYPE _STLP_STD::iterator_traits<_Iter>::iterator_category
+__iterator_category(const _Iter&, const __false_type&) {
+ typedef _STLP_TYPENAME _STLP_STD::iterator_traits<_Iter>::iterator_category _Category;
+ return _Category();
+}
+
+template <class _Tp>
+inline ptrdiff_t*
+__distance_type(const _Tp*, const __true_type&)
+{ return __STATIC_CAST(ptrdiff_t*, 0); }
+
+template <class _Iter>
+inline _STLP_TYPENAME_ON_RETURN_TYPE _STLP_STD::iterator_traits<_Iter>::difference_type*
+__distance_type(const _Iter&, const __false_type&) {
+ typedef _STLP_TYPENAME _STLP_STD::iterator_traits<_Iter>::difference_type _diff_type;
+ return __STATIC_CAST(_diff_type*,0);
+}
+
+template <class _Tp>
+inline _Tp*
+__value_type(const _Tp*, const __true_type&)
+{ return __STATIC_CAST(_Tp*, 0); }
+
+template <class _Iter>
+inline _STLP_TYPENAME_ON_RETURN_TYPE _STLP_STD::iterator_traits<_Iter>::value_type*
+__value_type(const _Iter&, const __false_type&) {
+ typedef _STLP_TYPENAME _STLP_STD::iterator_traits<_Iter>::value_type _value_type;
+ return __STATIC_CAST(_value_type*,0);
+}
+
+# endif
+
+#else /* _STLP_USE_OLD_HP_ITERATOR_QUERIES */
+template <class _Category, class _Tp, class _Distance, class _Pointer, class _Reference>
+inline _Category _STLP_CALL iterator_category(const iterator<_Category,_Tp,_Distance,_Pointer,_Reference>&) { return _Category(); }
+template <class _Category, class _Tp, class _Distance, class _Pointer, class _Reference>
+inline _Tp* _STLP_CALL value_type(const iterator<_Category,_Tp,_Distance,_Pointer,_Reference>&) { return __STATIC_CAST(_Tp*, 0); }
+template <class _Category, class _Tp, class _Distance, class _Pointer, class _Reference>
+inline _Distance* _STLP_CALL distance_type(const iterator<_Category,_Tp,_Distance,_Pointer,_Reference>&) { return __STATIC_CAST(_Distance*, 0); }
+template <class _Tp>
+inline random_access_iterator_tag _STLP_CALL iterator_category(const _Tp*) { return random_access_iterator_tag(); }
+template <class _Tp>
+inline _Tp* _STLP_CALL value_type(const _Tp*) { return __STATIC_CAST(_Tp*, 0); }
+template <class _Tp>
+inline ptrdiff_t* _STLP_CALL distance_type(const _Tp*) { return __STATIC_CAST(ptrdiff_t*, 0); }
+#endif /* _STLP_USE_OLD_HP_ITERATOR_QUERIES */
+
+#if !defined (_STLP_NO_ANACHRONISMS)
+// The base classes input_iterator, output_iterator, forward_iterator,
+// bidirectional_iterator, and random_access_iterator are not part of
+// the C++ standard. (They have been replaced by struct iterator.)
+// They are included for backward compatibility with the HP STL.
+template <class _Tp, class _Distance> struct input_iterator :
+ public iterator <input_iterator_tag, _Tp, _Distance, _Tp*, _Tp&> {};
+struct output_iterator : public iterator <output_iterator_tag, void, void, void, void> {};
+template <class _Tp, class _Distance> struct forward_iterator :
+ public iterator<forward_iterator_tag, _Tp, _Distance, _Tp*, _Tp&> {};
+template <class _Tp, class _Distance> struct bidirectional_iterator :
+ public iterator<bidirectional_iterator_tag, _Tp, _Distance, _Tp*, _Tp&> {};
+template <class _Tp, class _Distance> struct random_access_iterator :
+ public iterator<random_access_iterator_tag, _Tp, _Distance, _Tp*, _Tp&> {};
+
+# if defined (_STLP_BASE_MATCH_BUG) && defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
+template <class _Tp, class _Distance>
+inline input_iterator_tag _STLP_CALL
+iterator_category(const input_iterator<_Tp, _Distance>&) { return input_iterator_tag(); }
+inline output_iterator_tag _STLP_CALL
+iterator_category(const output_iterator&) { return output_iterator_tag(); }
+template <class _Tp, class _Distance>
+inline forward_iterator_tag _STLP_CALL
+iterator_category(const forward_iterator<_Tp, _Distance>&) { return forward_iterator_tag(); }
+template <class _Tp, class _Distance>
+inline bidirectional_iterator_tag _STLP_CALL
+iterator_category(const bidirectional_iterator<_Tp, _Distance>&) { return bidirectional_iterator_tag(); }
+template <class _Tp, class _Distance>
+inline random_access_iterator_tag _STLP_CALL
+iterator_category(const random_access_iterator<_Tp, _Distance>&) { return random_access_iterator_tag(); }
+template <class _Tp, class _Distance>
+inline _Tp* _STLP_CALL value_type(const input_iterator<_Tp, _Distance>&) { return __STATIC_CAST(_Tp*, 0); }
+template <class _Tp, class _Distance>
+inline _Tp* _STLP_CALL value_type(const forward_iterator<_Tp, _Distance>&) { return __STATIC_CAST(_Tp*, 0); }
+template <class _Tp, class _Distance>
+inline _Tp* _STLP_CALL value_type(const bidirectional_iterator<_Tp, _Distance>&) { return __STATIC_CAST(_Tp*, 0); }
+template <class _Tp, class _Distance>
+inline _Tp* _STLP_CALL value_type(const random_access_iterator<_Tp, _Distance>&) { return __STATIC_CAST(_Tp*, 0); }
+template <class _Tp, class _Distance>
+inline _Distance* _STLP_CALL distance_type(const input_iterator<_Tp, _Distance>&) { return __STATIC_CAST(_Distance*, 0); }
+template <class _Tp, class _Distance>
+inline _Distance* _STLP_CALL distance_type(const forward_iterator<_Tp, _Distance>&) { return __STATIC_CAST(_Distance*, 0); }
+template <class _Tp, class _Distance>
+inline _Distance* _STLP_CALL distance_type(const bidirectional_iterator<_Tp, _Distance>&) { return __STATIC_CAST(_Distance*, 0);}
+template <class _Tp, class _Distance>
+inline _Distance* _STLP_CALL distance_type(const random_access_iterator<_Tp, _Distance>&) { return __STATIC_CAST(_Distance*, 0); }
+# endif
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIterator>
+inline _STLP_DIFFERENCE_TYPE(_InputIterator) _STLP_CALL
+__distance(const _InputIterator& __first, const _InputIterator& __last,
+ const input_iterator_tag &) {
+ _STLP_DIFFERENCE_TYPE(_InputIterator) __n = 0;
+ _InputIterator __it(__first);
+ while (__it != __last) {
+ ++__it; ++__n;
+ }
+ return __n;
+}
+
+#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
+template <class _ForwardIterator>
+inline _STLP_DIFFERENCE_TYPE(_ForwardIterator) _STLP_CALL
+__distance(const _ForwardIterator& __first, const _ForwardIterator& __last,
+ const forward_iterator_tag &) {
+ _STLP_DIFFERENCE_TYPE(_ForwardIterator) __n = 0;
+ _ForwardIterator __it(__first);
+ while (__it != __last) {
+ ++__it; ++__n;
+ }
+ return __n;
+}
+
+template <class _BidirectionalIterator>
+_STLP_INLINE_LOOP _STLP_DIFFERENCE_TYPE(_BidirectionalIterator) _STLP_CALL
+__distance(const _BidirectionalIterator& __first, const _BidirectionalIterator& __last,
+ const bidirectional_iterator_tag &) {
+ _STLP_DIFFERENCE_TYPE(_BidirectionalIterator) __n = 0;
+ _BidirectionalIterator __it(__first);
+ while (__it != __last) {
+ ++__it; ++__n;
+ }
+ return __n;
+}
+#endif
+
+template <class _RandomAccessIterator>
+inline _STLP_DIFFERENCE_TYPE(_RandomAccessIterator) _STLP_CALL
+__distance(const _RandomAccessIterator& __first, const _RandomAccessIterator& __last,
+ const random_access_iterator_tag &)
+{ return __last - __first; }
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIterator>
+inline _STLP_DIFFERENCE_TYPE(_InputIterator) _STLP_CALL
+distance(_InputIterator __first, _InputIterator __last)
+{ return _STLP_PRIV __distance(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIterator)); }
+
+#if !defined (_STLP_NO_ANACHRONISMS)
+template <class _InputIterator, class _Distance>
+inline void _STLP_CALL distance(const _InputIterator& __first,
+ const _InputIterator& __last, _Distance& __n)
+{ __n += _STLP_STD::distance(__first, __last); }
+
+# if defined (_STLP_MSVC)
+// MSVC specific
+template <class _InputIterator, class _Dist>
+inline void _STLP_CALL _Distance(_InputIterator __first,
+ _InputIterator __last, _Dist& __n)
+{ __n += _STLP_STD::distance(__first, __last); }
+# endif
+#endif
+
+// fbp: those are being used for iterator/const_iterator definitions everywhere
+template <class _Tp>
+struct _Nonconst_traits;
+
+template <class _Tp>
+struct _Const_traits {
+ typedef _Tp value_type;
+ typedef const _Tp& reference;
+ typedef const _Tp* pointer;
+ typedef _Const_traits<_Tp> _ConstTraits;
+ typedef _Nonconst_traits<_Tp> _NonConstTraits;
+};
+
+template <class _Tp>
+struct _Nonconst_traits {
+ typedef _Tp value_type;
+ typedef _Tp& reference;
+ typedef _Tp* pointer;
+ typedef _Const_traits<_Tp> _ConstTraits;
+ typedef _Nonconst_traits<_Tp> _NonConstTraits;
+};
+
+/*
+ * dums: A special iterator/const_iterator traits for set and multiset for which even
+ * the iterator is not mutable
+ */
+template <class _Tp>
+struct _Nonconst_Const_traits;
+
+template <class _Tp>
+struct _Const_Const_traits {
+ typedef _Tp value_type;
+ typedef const _Tp& reference;
+ typedef const _Tp* pointer;
+ typedef _Const_Const_traits<_Tp> _ConstTraits;
+ typedef _Nonconst_Const_traits<_Tp> _NonConstTraits;
+};
+
+template <class _Tp>
+struct _Nonconst_Const_traits {
+ typedef _Tp value_type;
+ typedef const _Tp& reference;
+ typedef const _Tp* pointer;
+ typedef _Const_Const_traits<_Tp> _ConstTraits;
+ typedef _Nonconst_Const_traits<_Tp> _NonConstTraits;
+};
+
+/*
+ * A macro to generate a new iterator traits from one of the
+ * previous one. Changing the iterator traits type make iterators
+ * from different containers not comparable.
+ */
+#define _STLP_CREATE_ITERATOR_TRAITS_BASE(Motif, Traits) \
+template <class _Tp> \
+struct _##Motif; \
+template <class _Tp> \
+struct _Const##Motif : public _STLP_STD::_Const_##Traits<_Tp> { \
+ typedef _Const##Motif<_Tp> _ConstTraits; \
+ typedef _##Motif<_Tp> _NonConstTraits; \
+}; \
+template <class _Tp> \
+struct _##Motif : public _STLP_STD::_Nonconst_##Traits<_Tp> { \
+ typedef _Const##Motif<_Tp> _ConstTraits; \
+ typedef _##Motif<_Tp> _NonConstTraits; \
+};
+
+#define _STLP_CREATE_ITERATOR_TRAITS(Motif, Traits) \
+_STLP_MOVE_TO_PRIV_NAMESPACE \
+_STLP_CREATE_ITERATOR_TRAITS_BASE(Motif, Traits) \
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#define _STLP_CREATE_HASH_ITERATOR_TRAITS(Motif, Traits) \
+_STLP_MOVE_TO_PRIV_NAMESPACE \
+_STLP_CREATE_ITERATOR_TRAITS_BASE(NonLocal##Motif, Traits) \
+_STLP_CREATE_ITERATOR_TRAITS_BASE(Local##Motif, Traits) \
+template <class _Tp> \
+struct _##Motif { \
+ typedef _ConstNonLocal##Motif<_Tp> _ConstTraits; \
+ typedef _NonLocal##Motif<_Tp> _NonConstTraits; \
+ typedef _ConstLocal##Motif<_Tp> _ConstLocalTraits; \
+ typedef _Local##Motif<_Tp> _NonConstLocalTraits; \
+}; \
+_STLP_MOVE_TO_STD_NAMESPACE
+
+/*
+# if defined (_STLP_BASE_TYPEDEF_BUG)
+// this workaround is needed for SunPro 4.0.1
+template <class _Traits>
+struct __cnst_traits_aux : private _Traits {
+ typedef typename _Traits::value_type value_type;
+};
+# define __TRAITS_VALUE_TYPE(_Traits) __cnst_traits_aux<_Traits>::value_type
+# else
+# define __TRAITS_VALUE_TYPE(_Traits) _Traits::value_type
+# endif
+*/
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter, class _Distance>
+_STLP_INLINE_LOOP void _STLP_CALL
+__advance(_InputIter& __i, _Distance __n, const input_iterator_tag &)
+{ while (__n--) ++__i; }
+
+// fbp : added output iterator tag variant
+template <class _InputIter, class _Distance>
+_STLP_INLINE_LOOP void _STLP_CALL
+__advance(_InputIter& __i, _Distance __n, const output_iterator_tag &)
+{ while (__n--) ++__i; }
+
+#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
+template <class _ForwardIterator, class _Distance>
+_STLP_INLINE_LOOP void _STLP_CALL
+__advance(_ForwardIterator& i, _Distance n, const forward_iterator_tag &)
+{ while (n--) ++i; }
+#endif
+
+template <class _BidirectionalIterator, class _Distance>
+_STLP_INLINE_LOOP void _STLP_CALL
+__advance(_BidirectionalIterator& __i, _Distance __n,
+ const bidirectional_iterator_tag &) {
+ if (__n > 0)
+ while (__n--) ++__i;
+ else
+ while (__n++) --__i;
+}
+
+template <class _RandomAccessIterator, class _Distance>
+inline void _STLP_CALL
+__advance(_RandomAccessIterator& __i, _Distance __n,
+ const random_access_iterator_tag &)
+{ __i += __n; }
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIterator, class _Distance>
+inline void _STLP_CALL advance(_InputIterator& __i, _Distance __n)
+{ _STLP_PRIV __advance(__i, __n, _STLP_ITERATOR_CATEGORY(__i, _InputIterator)); }
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_ITERATOR_BASE_H */
+
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_iterator_old.h b/sources/android/stlport/stlport/stl/_iterator_old.h
new file mode 100644
index 0000000..144b9ab
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_iterator_old.h
@@ -0,0 +1,334 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_ITERATOR_OLD_H
+#define _STLP_INTERNAL_ITERATOR_OLD_H
+
+#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
+# include <stl/_iterator_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
+
+template <class _Container>
+inline output_iterator_tag _STLP_CALL
+iterator_category(const back_insert_iterator<_Container>&) { return output_iterator_tag(); }
+template <class _Container>
+inline output_iterator_tag _STLP_CALL
+iterator_category(const front_insert_iterator<_Container>&) { return output_iterator_tag(); }
+template <class _Container>
+inline output_iterator_tag _STLP_CALL
+iterator_category(const insert_iterator<_Container>&) { return output_iterator_tag(); }
+
+#endif
+
+template <class _BidirectionalIterator, class _Tp,
+ _STLP_DFL_TMPL_PARAM(_Reference, _Tp& ),
+#if defined (_STLP_MSVC50_COMPATIBILITY)
+# define __Reference _Reference, class _Pointer
+# define Reference__ _Reference, _Pointer
+ _STLP_DFL_TMPL_PARAM(_Pointer, _Tp*),
+#else
+# define __Reference _Reference
+# define Reference__ _Reference
+#endif
+ _STLP_DFL_TYPE_PARAM(_Distance, ptrdiff_t)>
+class reverse_bidirectional_iterator {
+ typedef reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
+ Reference__, _Distance> _Self;
+ // friend inline bool operator== _STLP_NULL_TMPL_ARGS (const _Self& x, const _Self& y);
+protected:
+ _BidirectionalIterator current;
+public:
+ typedef bidirectional_iterator_tag iterator_category;
+ typedef _Tp value_type;
+ typedef _Distance difference_type;
+# if defined (_STLP_MSVC50_COMPATIBILITY)
+ typedef _Pointer pointer;
+# else
+ typedef _Tp* pointer;
+# endif
+ typedef _Reference reference;
+
+ reverse_bidirectional_iterator() {}
+ explicit reverse_bidirectional_iterator(_BidirectionalIterator __x)
+ : current(__x) {}
+ _BidirectionalIterator base() const { return current; }
+ _Reference operator*() const {
+ _BidirectionalIterator __tmp = current;
+ return *(--__tmp);
+ }
+
+ _STLP_DEFINE_ARROW_OPERATOR
+
+ _Self& operator++() {
+ --current;
+ return *this;
+ }
+ _Self operator++(int) {
+ _Self __tmp = *this;
+ --current;
+ return __tmp;
+ }
+ _Self& operator--() {
+ ++current;
+ return *this;
+ }
+ _Self operator--(int) {
+ _Self __tmp = *this;
+ ++current;
+ return __tmp;
+ }
+};
+
+#ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
+template <class _BidirectionalIterator, class _Tp, class __Reference,
+ class _Distance>
+inline bidirectional_iterator_tag _STLP_CALL
+iterator_category(const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp, Reference__, _Distance>&)
+{ return bidirectional_iterator_tag(); }
+template <class _BidirectionalIterator, class _Tp, class __Reference,
+ class _Distance>
+inline _Tp* _STLP_CALL
+value_type(const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp, Reference__, _Distance>&)
+{ return (_Tp*) 0; }
+template <class _BidirectionalIterator, class _Tp, class __Reference,
+ class _Distance>
+inline _Distance* _STLP_CALL
+distance_type(const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp, Reference__, _Distance>&)
+{ return (_Distance*) 0; }
+#endif
+
+template <class _BidirectionalIterator, class _Tp, class __Reference,
+ class _Distance>
+inline bool _STLP_CALL operator==(
+ const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
+ Reference__, _Distance>& __x,
+ const reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
+ Reference__, _Distance>& __y)
+{ return __x.base() == __y.base(); }
+
+#ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
+
+template <class _BiIter, class _Tp, class __Reference, class _Distance>
+inline bool _STLP_CALL operator!=(
+ const reverse_bidirectional_iterator<_BiIter, _Tp, Reference__, _Distance>& __x,
+ const reverse_bidirectional_iterator<_BiIter, _Tp, Reference__, _Distance>& __y)
+{ return !(__x == __y); }
+
+#endif
+
+#if !defined ( _STLP_CLASS_PARTIAL_SPECIALIZATION )
+
+// This is the old version of reverse_iterator, as found in the original
+// HP STL. It does not use partial specialization.
+
+template <class _RandomAccessIterator, class _Tp,
+ _STLP_DFL_TMPL_PARAM(_Reference,_Tp&),
+# if defined (_STLP_MSVC50_COMPATIBILITY)
+ _STLP_DFL_TMPL_PARAM(_Pointer, _Tp*),
+# endif
+ _STLP_DFL_TYPE_PARAM(_Distance,ptrdiff_t)>
+class reverse_iterator {
+ typedef reverse_iterator<_RandomAccessIterator, _Tp, Reference__, _Distance> _Self;
+protected:
+ _RandomAccessIterator __current;
+public:
+ typedef random_access_iterator_tag iterator_category;
+ typedef _Tp value_type;
+ typedef _Distance difference_type;
+# if defined (_STLP_MSVC50_COMPATIBILITY)
+ typedef _Pointer pointer;
+# else
+ typedef _Tp* pointer;
+# endif
+ typedef _Reference reference;
+
+ reverse_iterator() {}
+ reverse_iterator(const _Self& __x) : __current(__x.base()) {}
+ explicit reverse_iterator(_RandomAccessIterator __x) : __current(__x) {}
+ _Self& operator=(const _Self& __x) {__current = __x.base(); return *this; }
+
+ _RandomAccessIterator base() const { return __current; }
+ _Reference operator*() const { return *(__current - (difference_type)1); }
+
+ _STLP_DEFINE_ARROW_OPERATOR
+
+ _Self& operator++() {
+ --__current;
+ return *this;
+ }
+ _Self operator++(int) {
+ _Self __tmp = *this;
+ --__current;
+ return __tmp;
+ }
+ _Self& operator--() {
+ ++__current;
+ return *this;
+ }
+ _Self operator--(int) {
+ _Self __tmp = *this;
+ ++__current;
+ return __tmp;
+ }
+ _Self operator+(_Distance __n) const {
+ return _Self(__current - __n);
+ }
+ _Self& operator+=(_Distance __n) {
+ __current -= __n;
+ return *this;
+ }
+ _Self operator-(_Distance __n) const {
+ return _Self(__current + __n);
+ }
+ _Self& operator-=(_Distance __n) {
+ __current += __n;
+ return *this;
+ }
+ _Reference operator[](_Distance __n) const { return *(*this + __n); }
+};
+
+# ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
+template <class _RandomAccessIterator, class _Tp,
+ class __Reference, class _Distance>
+inline random_access_iterator_tag _STLP_CALL
+iterator_category(const reverse_iterator<_RandomAccessIterator, _Tp, Reference__, _Distance>&)
+{ return random_access_iterator_tag(); }
+template <class _RandomAccessIterator, class _Tp,
+ class __Reference, class _Distance>
+inline _Tp* _STLP_CALL value_type(const reverse_iterator<_RandomAccessIterator, _Tp, Reference__, _Distance>&)
+{ return (_Tp*) 0; }
+template <class _RandomAccessIterator, class _Tp,
+ class __Reference, class _Distance>
+inline _Distance* _STLP_CALL
+distance_type(const reverse_iterator<_RandomAccessIterator, _Tp, Reference__, _Distance>&)
+{ return (_Distance*) 0; }
+# endif
+
+template <class _RandomAccessIterator, class _Tp,
+ class __Reference, class _Distance>
+inline bool _STLP_CALL
+operator==(const reverse_iterator<_RandomAccessIterator, _Tp,
+ Reference__, _Distance>& __x,
+ const reverse_iterator<_RandomAccessIterator, _Tp,
+ Reference__, _Distance>& __y)
+{
+ return __x.base() == __y.base();
+}
+
+template <class _RandomAccessIterator, class _Tp,
+ class __Reference, class _Distance>
+inline bool _STLP_CALL
+operator<(const reverse_iterator<_RandomAccessIterator, _Tp,
+ Reference__, _Distance>& __x,
+ const reverse_iterator<_RandomAccessIterator, _Tp,
+ Reference__, _Distance>& __y)
+{
+ return __y.base() < __x.base();
+}
+
+# ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
+
+template <class _RandomAccessIterator, class _Tp,
+ class __Reference, class _Distance>
+inline bool _STLP_CALL
+operator!=(const reverse_iterator<_RandomAccessIterator, _Tp,
+ Reference__, _Distance>& __x,
+ const reverse_iterator<_RandomAccessIterator, _Tp,
+ Reference__, _Distance>& __y) {
+ return !(__x == __y);
+}
+
+template <class _RandomAccessIterator, class _Tp,
+ class __Reference, class _Distance>
+inline bool _STLP_CALL
+operator>(const reverse_iterator<_RandomAccessIterator, _Tp,
+ Reference__, _Distance>& __x,
+ const reverse_iterator<_RandomAccessIterator, _Tp,
+ Reference__, _Distance>& __y) {
+ return __y < __x;
+}
+
+template <class _RandomAccessIterator, class _Tp,
+ class __Reference, class _Distance>
+inline bool _STLP_CALL
+operator<=(const reverse_iterator<_RandomAccessIterator, _Tp,
+ Reference__, _Distance>& __x,
+ const reverse_iterator<_RandomAccessIterator, _Tp,
+ Reference__, _Distance>& __y) {
+ return !(__y < __x);
+}
+
+template <class _RandomAccessIterator, class _Tp,
+ class __Reference, class _Distance>
+inline bool _STLP_CALL
+operator>=(const reverse_iterator<_RandomAccessIterator, _Tp,
+ Reference__, _Distance>& __x,
+ const reverse_iterator<_RandomAccessIterator, _Tp,
+ Reference__, _Distance>& __y) {
+ return !(__x < __y);
+}
+
+# endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
+
+template <class _RandomAccessIterator, class _Tp,
+ class __Reference, class _Distance>
+inline _Distance _STLP_CALL
+operator-(const reverse_iterator<_RandomAccessIterator, _Tp,
+ Reference__, _Distance>& __x,
+ const reverse_iterator<_RandomAccessIterator, _Tp,
+ Reference__, _Distance>& __y)
+{
+ return __y.base() - __x.base();
+}
+
+template <class _RandomAccessIterator, class _Tp,
+ class __Reference, class _Distance>
+inline reverse_iterator<_RandomAccessIterator, _Tp,
+ Reference__, _Distance> _STLP_CALL
+operator+(_Distance __n,
+ const reverse_iterator<_RandomAccessIterator, _Tp,
+ Reference__, _Distance>& __x)
+{
+ return reverse_iterator<_RandomAccessIterator, _Tp,
+ Reference__, _Distance>(__x.base() - __n);
+}
+
+#endif /* ! defined ( _STLP_CLASS_PARTIAL_SPECIALIZATION ) */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_ITERATOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_limits.c b/sources/android/stlport/stlport/stl/_limits.c
new file mode 100644
index 0000000..3938024
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_limits.c
@@ -0,0 +1,405 @@
+/*
+ * Copyright (c) 1998,1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_LIMITS_C
+#define _STLP_LIMITS_C
+
+#ifndef _STLP_INTERNAL_LIMITS
+# include <stl/_limits.h>
+#endif
+
+//==========================================================
+// numeric_limits static members
+//==========================================================
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+#if !defined (_STLP_STATIC_CONST_INIT_BUG) && !defined (_STLP_NO_STATIC_CONST_DEFINITION)
+
+# define __declare_numeric_base_member(__type, __mem) \
+template <class __number> \
+ const __type _Numeric_limits_base<__number>:: __mem
+
+__declare_numeric_base_member(bool, is_specialized);
+__declare_numeric_base_member(int, digits);
+__declare_numeric_base_member(int, digits10);
+__declare_numeric_base_member(bool, is_signed);
+__declare_numeric_base_member(bool, is_integer);
+__declare_numeric_base_member(bool, is_exact);
+__declare_numeric_base_member(int, radix);
+__declare_numeric_base_member(int, min_exponent);
+__declare_numeric_base_member(int, max_exponent);
+__declare_numeric_base_member(int, min_exponent10);
+__declare_numeric_base_member(int, max_exponent10);
+__declare_numeric_base_member(bool, has_infinity);
+__declare_numeric_base_member(bool, has_quiet_NaN);
+__declare_numeric_base_member(bool, has_signaling_NaN);
+__declare_numeric_base_member(float_denorm_style, has_denorm);
+__declare_numeric_base_member(bool, has_denorm_loss);
+__declare_numeric_base_member(bool, is_iec559);
+__declare_numeric_base_member(bool, is_bounded);
+__declare_numeric_base_member(bool, is_modulo);
+__declare_numeric_base_member(bool, traps);
+__declare_numeric_base_member(bool, tinyness_before);
+__declare_numeric_base_member(float_round_style, round_style);
+
+# undef __declare_numeric_base_member
+
+# define __declare_integer_limits_member(__type, __mem) \
+template <class _Int, _STLP_LIMITS_MIN_TYPE __imin, _STLP_LIMITS_MAX_TYPE __imax, int __idigits, bool __ismod> \
+ const __type _Integer_limits<_Int, __imin, __imax, __idigits, __ismod>:: __mem
+
+__declare_integer_limits_member(bool, is_specialized);
+__declare_integer_limits_member(int, digits);
+__declare_integer_limits_member(int, digits10);
+__declare_integer_limits_member(bool, is_signed);
+__declare_integer_limits_member(bool, is_integer);
+__declare_integer_limits_member(bool, is_exact);
+__declare_integer_limits_member(int, radix);
+__declare_integer_limits_member(bool, is_bounded);
+__declare_integer_limits_member(bool, is_modulo);
+# undef __declare_integer_limits_member
+
+# if defined (__GNUC__) && (__GNUC__ != 2 || __GNUC_MINOR__ > 96) && (__GNUC__ != 3 || __GNUC_MINOR__ == 0) && (__GNUC__ <= 3)
+_STLP_MOVE_TO_STD_NAMESPACE
+
+# define __declare_numeric_limits_member(__integer) \
+ _STLP_TEMPLATE_NULL const int numeric_limits<__integer>::digits; \
+ _STLP_TEMPLATE_NULL const int numeric_limits<__integer>::digits10; \
+ _STLP_TEMPLATE_NULL const int numeric_limits<__integer>::radix; \
+ _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_specialized; \
+ _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_signed; \
+ _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_integer; \
+ _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_exact; \
+ _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_bounded; \
+ _STLP_TEMPLATE_NULL const bool numeric_limits<__integer>::is_modulo
+
+__declare_numeric_limits_member(_STLP_LONG_LONG);
+__declare_numeric_limits_member(unsigned _STLP_LONG_LONG);
+
+# undef __declare_numeric_limits_member
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+# endif
+
+# define __declare_float_limits_member(__type, __mem) \
+template <class __number, \
+ int __Digits, int __Digits10, \
+ int __MinExp, int __MaxExp, \
+ int __MinExp10, int __MaxExp10, \
+ bool __IsIEC559, \
+ float_denorm_style __DenormStyle, \
+ float_round_style __RoundStyle> \
+const __type _Floating_limits< __number, __Digits, __Digits10, \
+ __MinExp, __MaxExp, __MinExp10, __MaxExp10, \
+ __IsIEC559, __DenormStyle, __RoundStyle>::\
+ __mem
+
+__declare_float_limits_member(bool, is_specialized);
+__declare_float_limits_member(int, digits);
+__declare_float_limits_member(int, digits10);
+__declare_float_limits_member(bool, is_signed);
+__declare_float_limits_member(int, radix);
+__declare_float_limits_member(int, min_exponent);
+__declare_float_limits_member(int, max_exponent);
+__declare_float_limits_member(int, min_exponent10);
+__declare_float_limits_member(int, max_exponent10);
+__declare_float_limits_member(bool, has_infinity);
+__declare_float_limits_member(bool, has_quiet_NaN);
+__declare_float_limits_member(bool, has_signaling_NaN);
+__declare_float_limits_member(float_denorm_style, has_denorm);
+__declare_float_limits_member(bool, has_denorm_loss);
+__declare_float_limits_member(bool, is_iec559);
+__declare_float_limits_member(bool, is_bounded);
+__declare_float_limits_member(bool, traps);
+__declare_float_limits_member(bool, tinyness_before);
+__declare_float_limits_member(float_round_style, round_style);
+# undef __declare_float_limits_member
+
+#endif
+
+
+#if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)
+
+# if defined (__GNUC__) || defined (__BORLANDC__)
+# define _STLP_ADDITIONAL_OPEN_BRACKET {
+# define _STLP_ADDITIONAL_CLOSE_BRACKET }
+# else
+# define _STLP_ADDITIONAL_OPEN_BRACKET
+# define _STLP_ADDITIONAL_CLOSE_BRACKET
+# endif
+
+/* The following code has been extracted from the boost libraries (www.boost.org) and
+ * adapted with the STLport portability macros. Advantage on previous technique is that
+ * computation of infinity and NaN values is only based on big/little endianess, compiler
+ * float, double or long double representation is taken into account thanks to the sizeof
+ * operator. */
+template<class _Number, unsigned short _Word>
+struct float_helper {
+ union _WordsNumber {
+ unsigned short _Words[8];
+ _Number _num;
+ };
+ static _Number get_word_higher() _STLP_NOTHROW {
+ _WordsNumber __tmp = { _STLP_ADDITIONAL_OPEN_BRACKET _Word, 0, 0, 0, 0, 0, 0, 0 _STLP_ADDITIONAL_CLOSE_BRACKET };
+ return __tmp._num;
+ }
+ static _Number get_word_lower() _STLP_NOTHROW {
+ _WordsNumber __tmp = { _STLP_ADDITIONAL_OPEN_BRACKET 0, 0, 0, 0, 0, 0, 0, 0 _STLP_ADDITIONAL_CLOSE_BRACKET };
+ __tmp._Words[(sizeof(_Number) >= 12 ? 10 : sizeof(_Number)) / sizeof(unsigned short) - 1] = _Word;
+ return __tmp._num;
+ }
+ static _Number get_from_last_word() _STLP_NOTHROW {
+# if defined (_STLP_BIG_ENDIAN)
+ return get_word_higher();
+# else /* _STLP_LITTLE_ENDIAN */
+ return get_word_lower();
+# endif
+ }
+ static _Number get_from_first_word() _STLP_NOTHROW {
+# if defined (_STLP_BIG_ENDIAN)
+ return get_word_lower();
+# else /* _STLP_LITTLE_ENDIAN */
+ return get_word_higher();
+# endif
+ }
+};
+
+# if !defined (_STLP_NO_LONG_DOUBLE) && !defined (_STLP_BIG_ENDIAN)
+template<class _Number, unsigned short _Word1, unsigned short _Word2>
+struct float_helper2 {
+ union _WordsNumber {
+ unsigned short _Words[8];
+ _Number _num;
+ };
+ //static _Number get_word_higher() _STLP_NOTHROW {
+ // _WordsNumber __tmp = { _STLP_ADDITIONAL_OPEN_BRACKET _Word1, _Word2, 0, 0, 0, 0, 0, 0 _STLP_ADDITIONAL_CLOSE_BRACKET };
+ // return __tmp._num;
+ //}
+ static _Number get_word_lower() _STLP_NOTHROW {
+ _WordsNumber __tmp = { _STLP_ADDITIONAL_OPEN_BRACKET 0, 0, 0, 0, 0, 0, 0, 0 _STLP_ADDITIONAL_CLOSE_BRACKET };
+ __tmp._Words[(sizeof(_Number) >= 12 ? 10 : sizeof(_Number)) / sizeof(unsigned short) - 2] = _Word1;
+ __tmp._Words[(sizeof(_Number) >= 12 ? 10 : sizeof(_Number)) / sizeof(unsigned short) - 1] = _Word2;
+ return __tmp._num;
+ }
+ static _Number get_from_last_word() _STLP_NOTHROW {
+//# if defined (_STLP_BIG_ENDIAN)
+// return get_word_higher();
+//# else /* _STLP_LITTLE_ENDIAN */
+ return get_word_lower();
+//# endif
+ }
+};
+# endif
+
+/* Former values kept in case moving to boost code has introduce a regression on
+ * some platform. */
+#if 0
+# if defined (_STLP_BIG_ENDIAN)
+# if defined (__OS400__)
+# define _STLP_FLOAT_INF_REP { 0x7f80, 0 }
+# define _STLP_FLOAT_QNAN_REP { 0xffc0, 0 }
+# define _STLP_FLOAT_SNAN_REP { 0xff80, 0 }
+# define _STLP_DOUBLE_INF_REP { 0x7ff0, 0, 0, 0 }
+# define _STLP_DOUBLE_QNAN_REP { 0xfff8, 0, 0, 0 }
+# define _STLP_DOUBLE_SNAN_REP { 0xfff0, 0, 0, 0 }
+# define _STLP_LDOUBLE_INF_REP { 0x7ff0, 0, 0, 0, 0, 0, 0, 0 }
+# define _STLP_LDOUBLE_QNAN_REP { 0xfff8, 0, 0, 0, 0, 0, 0, 0 }
+# define _STLP_LDOUBLE_SNAN_REP { 0xfff0, 0, 0, 0, 0, 0, 0, 0 }
+# else /* __OS400__ */
+# define _STLP_FLOAT_INF_REP { 0x7f80, 0 }
+# define _STLP_FLOAT_QNAN_REP { 0x7fc1, 0 }
+# define _STLP_FLOAT_SNAN_REP { 0x7f81, 0 }
+# define _STLP_DOUBLE_INF_REP { 0x7ff0, 0, 0, 0 }
+# define _STLP_DOUBLE_QNAN_REP { 0x7ff9, 0, 0, 0 }
+# define _STLP_DOUBLE_SNAN_REP { 0x7ff1, 0, 0, 0 }
+# define _STLP_LDOUBLE_INF_REP { 0x7ff0, 0, 0, 0, 0, 0, 0, 0 }
+# define _STLP_LDOUBLE_QNAN_REP { 0x7ff1, 0, 0, 0, 0, 0, 0, 0 }
+# define _STLP_LDOUBLE_SNAN_REP { 0x7ff9, 0, 0, 0, 0, 0, 0, 0 }
+# endif /* __OS400__ */
+# else /* _STLP_LITTLE_ENDIAN */
+# if defined(__DECCXX)
+# define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
+# define _STLP_FLOAT_QNAN_REP { 0, 0xffc0 }
+# define _STLP_FLOAT_SNAN_REP { 0x5555, 0x7f85 }
+# define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
+# define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0xfff8 }
+# define _STLP_DOUBLE_SNAN_REP { 0x5555, 0x5555, 0x5555, 0x7ff5 }
+# define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0, 0, 0, 0, 0x7fff }
+# define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0, 0, 0, 0x8000, 0xffff }
+# define _STLP_LDOUBLE_SNAN_REP { 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x7fff}
+# else
+# define _STLP_FLOAT_INF_REP { 0, 0x7f80 }
+# define _STLP_FLOAT_QNAN_REP { 0, 0x7fc0 }
+# define _STLP_FLOAT_SNAN_REP { 0, 0x7fa0 }
+# define _STLP_DOUBLE_INF_REP { 0, 0, 0, 0x7ff0 }
+# define _STLP_DOUBLE_QNAN_REP { 0, 0, 0, 0x7ff8 }
+# define _STLP_DOUBLE_SNAN_REP { 0, 0, 0, 0x7ff4 }
+# if defined (_STLP_MSVC) || defined (__ICL)
+# define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x7FF0, 0 }
+# define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xFFF8, 0 }
+# define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xFFF8, 0 }
+# elif defined (__BORLANDC__)
+# define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x8000, 0x7fff }
+# define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xc000, 0x7fff }
+# define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xa000, 0x7fff }
+# else
+# define _STLP_LDOUBLE_INF_REP { 0, 0, 0, 0x8000, 0x7fff, 0 }
+# define _STLP_LDOUBLE_QNAN_REP { 0, 0, 0, 0xa000, 0x7fff, 0 }
+# define _STLP_LDOUBLE_SNAN_REP { 0, 0, 0, 0xc000, 0x7fff, 0 }
+# endif
+# endif
+# endif
+
+union _F_rep {
+ unsigned short rep[2];
+ float val;
+};
+union _D_rep {
+ unsigned short rep[4];
+ double val;
+};
+
+# ifndef _STLP_NO_LONG_DOUBLE
+union _LD_rep {
+ unsigned short rep[8];
+ long double val;
+};
+# endif
+#endif
+
+template <class __dummy>
+float _STLP_CALL _LimG<__dummy>::get_F_inf() {
+ typedef float_helper<float, 0x7f80u> _FloatHelper;
+ return _FloatHelper::get_from_last_word();
+}
+template <class __dummy>
+float _STLP_CALL _LimG<__dummy>::get_F_qNaN() {
+ typedef float_helper<float, 0x7f81u> _FloatHelper;
+ return _FloatHelper::get_from_last_word();
+}
+template <class __dummy>
+float _STLP_CALL _LimG<__dummy>::get_F_sNaN() {
+ typedef float_helper<float, 0x7fc1u> _FloatHelper;
+ return _FloatHelper::get_from_last_word();
+}
+template <class __dummy>
+float _STLP_CALL _LimG<__dummy>::get_F_denormMin() {
+ typedef float_helper<float, 0x0001u> _FloatHelper;
+ return _FloatHelper::get_from_first_word();
+}
+
+template <int __use_double_limits>
+class _NumericLimitsAccess;
+
+_STLP_TEMPLATE_NULL
+class _NumericLimitsAccess<1> {
+public:
+ static double get_inf() {
+ typedef float_helper<double, 0x7ff0u> _FloatHelper;
+ return _FloatHelper::get_from_last_word();
+ }
+ static double get_qNaN() {
+ typedef float_helper<double, 0x7ff1u> _FloatHelper;
+ return _FloatHelper::get_from_last_word();
+ }
+ static double get_sNaN() {
+ typedef float_helper<double, 0x7ff9u> _FloatHelper;
+ return _FloatHelper::get_from_last_word();
+ }
+};
+
+template <class __dummy>
+double _STLP_CALL _LimG<__dummy>::get_D_inf()
+{ return _NumericLimitsAccess<1>::get_inf(); }
+template <class __dummy>
+double _STLP_CALL _LimG<__dummy>::get_D_qNaN()
+{ return _NumericLimitsAccess<1>::get_qNaN(); }
+template <class __dummy>
+double _STLP_CALL _LimG<__dummy>::get_D_sNaN()
+{ return _NumericLimitsAccess<1>::get_sNaN(); }
+template <class __dummy>
+double _STLP_CALL _LimG<__dummy>::get_D_denormMin() {
+ typedef float_helper<double, 0x0001u> _FloatHelper;
+ return _FloatHelper::get_from_first_word();
+}
+
+# if !defined (_STLP_NO_LONG_DOUBLE)
+_STLP_TEMPLATE_NULL
+class _NumericLimitsAccess<0> {
+public:
+ static long double get_inf() {
+# if defined (_STLP_BIG_ENDIAN)
+ typedef float_helper<long double, 0x7ff0u> _FloatHelper;
+# else
+ typedef float_helper2<long double, 0x8000u, 0x7fffu> _FloatHelper;
+# endif
+ return _FloatHelper::get_from_last_word();
+ }
+ static long double get_qNaN() {
+# if defined (_STLP_BIG_ENDIAN)
+ typedef float_helper<long double, 0x7ff1u> _FloatHelper;
+# else
+ typedef float_helper2<long double, 0xc000u, 0x7fffu> _FloatHelper;
+# endif
+ return _FloatHelper::get_from_last_word();
+ }
+ static long double get_sNaN() {
+# if defined (_STLP_BIG_ENDIAN)
+ typedef float_helper<long double, 0x7ff9u> _FloatHelper;
+# else
+ typedef float_helper2<long double, 0x9000u, 0x7fffu> _FloatHelper;
+# endif
+ return _FloatHelper::get_from_last_word();
+ }
+};
+
+template <class __dummy>
+long double _STLP_CALL _LimG<__dummy>::get_LD_inf() {
+ const int __use_double_limits = sizeof(double) == sizeof(long double) ? 1 : 0;
+ return _NumericLimitsAccess<__use_double_limits>::get_inf();
+}
+template <class __dummy>
+long double _STLP_CALL _LimG<__dummy>::get_LD_qNaN() {
+ const int __use_double_limits = sizeof(double) == sizeof(long double) ? 1 : 0;
+ return _NumericLimitsAccess<__use_double_limits>::get_qNaN();
+}
+template <class __dummy>
+long double _STLP_CALL _LimG<__dummy>::get_LD_sNaN() {
+ const int __use_double_limits = sizeof(double) == sizeof(long double) ? 1 : 0;
+ return _NumericLimitsAccess<__use_double_limits>::get_sNaN();
+}
+template <class __dummy>
+long double _STLP_CALL _LimG<__dummy>::get_LD_denormMin() {
+ typedef float_helper<long double, 0x0001u> _FloatHelper;
+ return _FloatHelper::get_from_first_word();
+}
+# endif
+
+#endif /* _STLP_EXPOSE_GLOBALS_IMPLEMENTATION */
+
+#undef _STLP_LIMITS_MIN_TYPE
+#undef _STLP_LIMITS_MAX_TYPE
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_LIMITS_C_INCLUDED */
diff --git a/sources/android/stlport/stlport/stl/_limits.h b/sources/android/stlport/stlport/stl/_limits.h
new file mode 100644
index 0000000..c0091f6
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_limits.h
@@ -0,0 +1,519 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This may be not portable code. Parts of numeric_limits<> are
+ * inherently machine-dependent. At present this file is suitable
+ * for the MIPS, SPARC, Alpha and ia32 architectures.
+ */
+
+#ifndef _STLP_INTERNAL_LIMITS
+#define _STLP_INTERNAL_LIMITS
+
+#ifndef _STLP_CLIMITS
+# include <climits>
+#endif
+
+#ifndef _STLP_CFLOAT
+# include <cfloat>
+#endif
+
+#if defined (_STLP_HAS_WCHAR_T) && !defined (_STLP_INTERNAL_CWCHAR)
+# include <stl/_cwchar.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+enum float_round_style {
+ round_indeterminate = -1,
+ round_toward_zero = 0,
+ round_to_nearest = 1,
+ round_toward_infinity = 2,
+ round_toward_neg_infinity = 3
+};
+
+enum float_denorm_style {
+ denorm_indeterminate = -1,
+ denorm_absent = 0,
+ denorm_present = 1
+};
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Base class for all specializations of numeric_limits.
+template <class __number>
+class _Numeric_limits_base {
+public:
+
+ static __number (_STLP_CALL min)() _STLP_NOTHROW { return __number(); }
+ static __number (_STLP_CALL max)() _STLP_NOTHROW { return __number(); }
+
+ _STLP_STATIC_CONSTANT(int, digits = 0);
+ _STLP_STATIC_CONSTANT(int, digits10 = 0);
+ _STLP_STATIC_CONSTANT(int, radix = 0);
+ _STLP_STATIC_CONSTANT(int, min_exponent = 0);
+ _STLP_STATIC_CONSTANT(int, min_exponent10 = 0);
+ _STLP_STATIC_CONSTANT(int, max_exponent = 0);
+ _STLP_STATIC_CONSTANT(int, max_exponent10 = 0);
+
+ _STLP_STATIC_CONSTANT(float_denorm_style, has_denorm = denorm_absent);
+ _STLP_STATIC_CONSTANT(float_round_style, round_style = round_toward_zero);
+
+ _STLP_STATIC_CONSTANT(bool, is_specialized = false);
+ _STLP_STATIC_CONSTANT(bool, is_signed = false);
+ _STLP_STATIC_CONSTANT(bool, is_integer = false);
+ _STLP_STATIC_CONSTANT(bool, is_exact = false);
+ _STLP_STATIC_CONSTANT(bool, has_infinity = false);
+ _STLP_STATIC_CONSTANT(bool, has_quiet_NaN = false);
+ _STLP_STATIC_CONSTANT(bool, has_signaling_NaN = false);
+ _STLP_STATIC_CONSTANT(bool, has_denorm_loss = false);
+ _STLP_STATIC_CONSTANT(bool, is_iec559 = false);
+ _STLP_STATIC_CONSTANT(bool, is_bounded = false);
+ _STLP_STATIC_CONSTANT(bool, is_modulo = false);
+ _STLP_STATIC_CONSTANT(bool, traps = false);
+ _STLP_STATIC_CONSTANT(bool, tinyness_before = false);
+
+ static __number _STLP_CALL epsilon() _STLP_NOTHROW { return __number(); }
+ static __number _STLP_CALL round_error() _STLP_NOTHROW { return __number(); }
+
+ static __number _STLP_CALL infinity() _STLP_NOTHROW { return __number(); }
+ static __number _STLP_CALL quiet_NaN() _STLP_NOTHROW { return __number(); }
+ static __number _STLP_CALL signaling_NaN() _STLP_NOTHROW { return __number(); }
+ static __number _STLP_CALL denorm_min() _STLP_NOTHROW { return __number(); }
+};
+
+// Base class for integers.
+
+#ifdef _STLP_LIMITED_DEFAULT_TEMPLATES
+# ifdef _STLP_LONG_LONG
+# define _STLP_LIMITS_MIN_TYPE _STLP_LONG_LONG
+# define _STLP_LIMITS_MAX_TYPE unsigned _STLP_LONG_LONG
+# else
+# define _STLP_LIMITS_MIN_TYPE long
+# define _STLP_LIMITS_MAX_TYPE unsigned long
+# endif
+#else
+# define _STLP_LIMITS_MIN_TYPE _Int
+# define _STLP_LIMITS_MAX_TYPE _Int
+#endif /* _STLP_LIMITED_DEFAULT_TEMPLATES */
+
+template <class _Int,
+ _STLP_LIMITS_MIN_TYPE __imin,
+ _STLP_LIMITS_MAX_TYPE __imax,
+ int __idigits, bool __ismod>
+class _Integer_limits : public _Numeric_limits_base<_Int> {
+public:
+
+ static _Int (_STLP_CALL min) () _STLP_NOTHROW { return (_Int)__imin; }
+ static _Int (_STLP_CALL max) () _STLP_NOTHROW { return (_Int)__imax; }
+
+ _STLP_STATIC_CONSTANT(int, digits = (__idigits < 0) ? ((int)((sizeof(_Int) * (CHAR_BIT))) - ((__imin == 0) ? 0 : 1)) : (__idigits));
+ _STLP_STATIC_CONSTANT(int, digits10 = (digits * 301UL) / 1000);
+ _STLP_STATIC_CONSTANT(int, radix = 2);
+ _STLP_STATIC_CONSTANT(bool, is_specialized = true);
+ _STLP_STATIC_CONSTANT(bool, is_signed = (__imin != 0));
+ _STLP_STATIC_CONSTANT(bool, is_integer = true);
+ _STLP_STATIC_CONSTANT(bool, is_exact = true);
+ _STLP_STATIC_CONSTANT(bool, is_bounded = true);
+ _STLP_STATIC_CONSTANT(bool, is_modulo = __ismod);
+};
+
+// Base class for floating-point numbers.
+template <class __number,
+ int __Digits, int __Digits10,
+ int __MinExp, int __MaxExp,
+ int __MinExp10, int __MaxExp10,
+ bool __IsIEC559,
+ float_denorm_style __DenormStyle,
+ float_round_style __RoundStyle>
+class _Floating_limits : public _Numeric_limits_base<__number> {
+public:
+
+ _STLP_STATIC_CONSTANT(int, digits = __Digits);
+ _STLP_STATIC_CONSTANT(int, digits10 = __Digits10);
+ _STLP_STATIC_CONSTANT(int, radix = FLT_RADIX);
+ _STLP_STATIC_CONSTANT(int, min_exponent = __MinExp);
+ _STLP_STATIC_CONSTANT(int, max_exponent = __MaxExp);
+ _STLP_STATIC_CONSTANT(int, min_exponent10 = __MinExp10);
+ _STLP_STATIC_CONSTANT(int, max_exponent10 = __MaxExp10);
+
+ _STLP_STATIC_CONSTANT(float_denorm_style, has_denorm = __DenormStyle);
+ _STLP_STATIC_CONSTANT(float_round_style, round_style = __RoundStyle);
+
+ _STLP_STATIC_CONSTANT(bool, is_specialized = true);
+ _STLP_STATIC_CONSTANT(bool, is_signed = true);
+
+ _STLP_STATIC_CONSTANT(bool, has_infinity = true);
+#if (!defined (_STLP_MSVC) || (_STLP_MSVC > 1300)) && \
+ (!defined (__BORLANDC__) || (__BORLANDC__ >= 0x590)) && \
+ (!defined (_CRAY) || defined (_CRAYIEEE))
+ _STLP_STATIC_CONSTANT(bool, has_quiet_NaN = true);
+ _STLP_STATIC_CONSTANT(bool, has_signaling_NaN = true);
+#else
+ _STLP_STATIC_CONSTANT(bool, has_quiet_NaN = false);
+ _STLP_STATIC_CONSTANT(bool, has_signaling_NaN = false);
+#endif
+
+ _STLP_STATIC_CONSTANT(bool, is_iec559 = __IsIEC559 && has_infinity && has_quiet_NaN && has_signaling_NaN && (has_denorm == denorm_present));
+ _STLP_STATIC_CONSTANT(bool, has_denorm_loss = false);
+ _STLP_STATIC_CONSTANT(bool, is_bounded = true);
+ _STLP_STATIC_CONSTANT(bool, traps = true);
+ _STLP_STATIC_CONSTANT(bool, tinyness_before = false);
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+// Class numeric_limits
+
+// The unspecialized class.
+
+template<class _Tp>
+class numeric_limits : public _STLP_PRIV _Numeric_limits_base<_Tp> {};
+
+// Specializations for all built-in integral types.
+
+#if !defined (_STLP_NO_BOOL)
+_STLP_TEMPLATE_NULL
+class numeric_limits<bool>
+ : public _STLP_PRIV _Integer_limits<bool, false, true, 1, false>
+{};
+#endif /* _STLP_NO_BOOL */
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<char>
+ : public _STLP_PRIV _Integer_limits<char, CHAR_MIN, CHAR_MAX, -1, true>
+{};
+
+#if !defined (_STLP_NO_SIGNED_BUILTINS)
+_STLP_TEMPLATE_NULL
+class numeric_limits<signed char>
+ : public _STLP_PRIV _Integer_limits<signed char, SCHAR_MIN, SCHAR_MAX, -1, true>
+{};
+#endif
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned char>
+ : public _STLP_PRIV _Integer_limits<unsigned char, 0, UCHAR_MAX, -1, true>
+{};
+
+#if !(defined (_STLP_NO_WCHAR_T) || defined (_STLP_WCHAR_T_IS_USHORT))
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<wchar_t>
+ : public _STLP_PRIV _Integer_limits<wchar_t, WCHAR_MIN, WCHAR_MAX, -1, true>
+{};
+
+#endif
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<short>
+ : public _STLP_PRIV _Integer_limits<short, SHRT_MIN, SHRT_MAX, -1, true>
+{};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned short>
+ : public _STLP_PRIV _Integer_limits<unsigned short, 0, USHRT_MAX, -1, true>
+{};
+
+#if defined (__xlC__) && (__xlC__ == 0x500)
+# undef INT_MIN
+# define INT_MIN -2147483648
+#endif
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<int>
+ : public _STLP_PRIV _Integer_limits<int, INT_MIN, INT_MAX, -1, true>
+{};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned int>
+ : public _STLP_PRIV _Integer_limits<unsigned int, 0, UINT_MAX, -1, true>
+{};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<long>
+ : public _STLP_PRIV _Integer_limits<long, LONG_MIN, LONG_MAX, -1, true>
+{};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned long>
+ : public _STLP_PRIV _Integer_limits<unsigned long, 0, ULONG_MAX, -1, true>
+{};
+
+#if defined (_STLP_LONG_LONG)
+
+# if defined (_STLP_MSVC) || defined (__BORLANDC__)
+# define LONGLONG_MAX 0x7fffffffffffffffi64
+# define LONGLONG_MIN (-LONGLONG_MAX-1i64)
+# define ULONGLONG_MAX 0xffffffffffffffffUi64
+# else
+# ifndef LONGLONG_MAX
+# define LONGLONG_MAX 0x7fffffffffffffffLL
+# endif
+# ifndef LONGLONG_MIN
+# define LONGLONG_MIN (-LONGLONG_MAX-1LL)
+# endif
+# ifndef ULONGLONG_MAX
+# define ULONGLONG_MAX 0xffffffffffffffffULL
+# endif
+# endif
+
+# if !defined (__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ <= 96) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1) || (__GNUC__ > 3)
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<_STLP_LONG_LONG>
+ : public _STLP_PRIV _Integer_limits<_STLP_LONG_LONG, LONGLONG_MIN, LONGLONG_MAX, -1, true>
+{};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned _STLP_LONG_LONG>
+ : public _STLP_PRIV _Integer_limits<unsigned _STLP_LONG_LONG, 0, ULONGLONG_MAX, -1, true>
+{};
+# else /* gcc 2.97 (after 2000-11-01), 2.98, 3.0 */
+/*
+ newest gcc has new mangling scheme, that has problem
+ with generating name [instantiated] of template specialization like
+ _Integer_limits<_STLP_LONG_LONG, LONGLONG_MIN, LONGLONG_MAX, -1, true>
+ ~~~~~~~~~~~~ ~~~~~~~~~~~~
+ Below is code that solve this problem.
+ - ptr
+ */
+_STLP_TEMPLATE_NULL
+class numeric_limits<_STLP_LONG_LONG>
+ : public _STLP_PRIV _Numeric_limits_base<_STLP_LONG_LONG> {
+public:
+
+ static _STLP_LONG_LONG (_STLP_CALL min) () _STLP_NOTHROW { return LONGLONG_MIN; }
+ static _STLP_LONG_LONG (_STLP_CALL max) () _STLP_NOTHROW { return LONGLONG_MAX; }
+
+ _STLP_STATIC_CONSTANT(int, digits = ((int)((sizeof(_STLP_LONG_LONG) * (CHAR_BIT))) - 1));
+ _STLP_STATIC_CONSTANT(int, digits10 = (digits * 301UL) / 1000);
+ _STLP_STATIC_CONSTANT(int, radix = 2);
+ _STLP_STATIC_CONSTANT(bool, is_specialized = true);
+ _STLP_STATIC_CONSTANT(bool, is_signed = true);
+ _STLP_STATIC_CONSTANT(bool, is_integer = true);
+ _STLP_STATIC_CONSTANT(bool, is_exact = true);
+ _STLP_STATIC_CONSTANT(bool, is_bounded = true);
+ _STLP_STATIC_CONSTANT(bool, is_modulo = true);
+};
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<unsigned _STLP_LONG_LONG>
+ : public _STLP_PRIV _Numeric_limits_base<unsigned _STLP_LONG_LONG> {
+public:
+
+ static unsigned _STLP_LONG_LONG (_STLP_CALL min) () _STLP_NOTHROW { return 0ULL; }
+ static unsigned _STLP_LONG_LONG (_STLP_CALL max) () _STLP_NOTHROW { return ULONGLONG_MAX; }
+
+ _STLP_STATIC_CONSTANT(int, digits = ((int)((sizeof(unsigned _STLP_LONG_LONG) * (CHAR_BIT)))));
+ _STLP_STATIC_CONSTANT(int, digits10 = (digits * 301UL) / 1000);
+ _STLP_STATIC_CONSTANT(int, radix = 2);
+ _STLP_STATIC_CONSTANT(bool, is_specialized = true);
+ _STLP_STATIC_CONSTANT(bool, is_signed = false);
+ _STLP_STATIC_CONSTANT(bool, is_integer = true);
+ _STLP_STATIC_CONSTANT(bool, is_exact = true);
+ _STLP_STATIC_CONSTANT(bool, is_bounded = true);
+ _STLP_STATIC_CONSTANT(bool, is_modulo = true);
+};
+
+# endif /* __GNUC__ > 2000-11-01 */
+
+#endif /* _STLP_LONG_LONG */
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Specializations for all built-in floating-point types.
+template <class __dummy>
+class _LimG {
+public:
+ static float _STLP_CALL get_F_inf();
+ static float _STLP_CALL get_F_qNaN();
+ static float _STLP_CALL get_F_sNaN();
+ static float _STLP_CALL get_F_denormMin();
+ static double _STLP_CALL get_D_inf();
+ static double _STLP_CALL get_D_qNaN();
+ static double _STLP_CALL get_D_sNaN();
+ static double _STLP_CALL get_D_denormMin();
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+ static long double _STLP_CALL get_LD_inf();
+ static long double _STLP_CALL get_LD_qNaN();
+ static long double _STLP_CALL get_LD_sNaN();
+ static long double _STLP_CALL get_LD_denormMin();
+#endif
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS _LimG<bool>;
+#endif
+
+#if defined (__GNUC__)
+# if defined (__FLT_DENORM_MIN__)
+# define _STLP_FLT_DENORM_MIN __FLT_DENORM_MIN__
+# else
+# define _STLP_FLT_DENORM_STYLE denorm_absent
+# endif
+# if defined (__DBL_DENORM_MIN__)
+# define _STLP_DBL_DENORM_MIN __DBL_DENORM_MIN__
+# else
+# define _STLP_DBL_DENORM_STYLE denorm_absent
+# endif
+# if defined (__LDBL_DENORM_MIN__)
+# define _STLP_LDBL_DENORM_MIN __LDBL_DENORM_MIN__
+# else
+# define _STLP_LDBL_DENORM_STYLE denorm_absent
+# endif
+#endif
+
+/* If compiler do not expose thanks to some macro its status regarding
+ * denormalized floating point numbers, we consider that denormalization
+ * is present. Unit tests will tell us if compiler do not support them. */
+#if !defined (_STLP_FLT_DENORM_STYLE)
+# define _STLP_FLT_DENORM_STYLE denorm_present
+#endif
+
+#if !defined (_STLP_DBL_DENORM_STYLE)
+# define _STLP_DBL_DENORM_STYLE denorm_present
+#endif
+
+#if !defined (_STLP_LDBL_DENORM_STYLE)
+# define _STLP_LDBL_DENORM_STYLE denorm_present
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<float>
+ : public _STLP_PRIV _Floating_limits<float,
+ FLT_MANT_DIG, // Binary digits of precision
+ FLT_DIG, // Decimal digits of precision
+ FLT_MIN_EXP, // Minimum exponent
+ FLT_MAX_EXP, // Maximum exponent
+ FLT_MIN_10_EXP, // Minimum base 10 exponent
+ FLT_MAX_10_EXP, // Maximum base 10 exponent
+ true,
+ _STLP_FLT_DENORM_STYLE,
+ round_to_nearest> {
+public:
+ static float (_STLP_CALL min) () _STLP_NOTHROW { return FLT_MIN; }
+ static float _STLP_CALL denorm_min() _STLP_NOTHROW
+#if defined (_STLP_FLT_DENORM_MIN)
+ { return _STLP_FLT_DENORM_MIN; }
+#else
+ { return _STLP_FLT_DENORM_STYLE ? _STLP_PRIV _LimG<bool>::get_F_denormMin() : FLT_MIN; }
+#endif
+ static float (_STLP_CALL max) () _STLP_NOTHROW { return FLT_MAX; }
+ static float _STLP_CALL epsilon() _STLP_NOTHROW { return FLT_EPSILON; }
+ static float _STLP_CALL round_error() _STLP_NOTHROW { return 0.5f; } // Units: ulps.
+ static float _STLP_CALL infinity() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_F_inf(); }
+ static float _STLP_CALL quiet_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_F_qNaN(); }
+ static float _STLP_CALL signaling_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_F_sNaN(); }
+};
+
+#undef _STLP_FLT_DENORM_MIN
+#undef _STLP_FLT_DNORM_STYLE
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<double>
+ : public _STLP_PRIV _Floating_limits<double,
+ DBL_MANT_DIG, // Binary digits of precision
+ DBL_DIG, // Decimal digits of precision
+ DBL_MIN_EXP, // Minimum exponent
+ DBL_MAX_EXP, // Maximum exponent
+ DBL_MIN_10_EXP, // Minimum base 10 exponent
+ DBL_MAX_10_EXP, // Maximum base 10 exponent
+ true,
+ _STLP_DBL_DENORM_STYLE,
+ round_to_nearest> {
+public:
+ static double (_STLP_CALL min)() _STLP_NOTHROW { return DBL_MIN; }
+ static double _STLP_CALL denorm_min() _STLP_NOTHROW
+#if defined (_STLP_DBL_DENORM_MIN)
+ { return _STLP_DBL_DENORM_MIN; }
+#else
+ { return _STLP_DBL_DENORM_STYLE ? _STLP_PRIV _LimG<bool>::get_D_denormMin() : DBL_MIN; }
+#endif
+ static double (_STLP_CALL max)() _STLP_NOTHROW { return DBL_MAX; }
+ static double _STLP_CALL epsilon() _STLP_NOTHROW { return DBL_EPSILON; }
+ static double _STLP_CALL round_error() _STLP_NOTHROW { return 0.5; } // Units: ulps.
+ static double _STLP_CALL infinity() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_D_inf(); }
+ static double _STLP_CALL quiet_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_D_qNaN(); }
+ static double _STLP_CALL signaling_NaN() _STLP_NOTHROW { return _STLP_PRIV _LimG<bool>::get_D_sNaN(); }
+};
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+
+_STLP_TEMPLATE_NULL
+class numeric_limits<long double>
+ : public _STLP_PRIV _Floating_limits<long double,
+ LDBL_MANT_DIG, // Binary digits of precision
+ LDBL_DIG, // Decimal digits of precision
+ LDBL_MIN_EXP, // Minimum exponent
+ LDBL_MAX_EXP, // Maximum exponent
+ LDBL_MIN_10_EXP,// Minimum base 10 exponent
+ LDBL_MAX_10_EXP,// Maximum base 10 exponent
+ false, // do not conform to iec559
+ _STLP_LDBL_DENORM_STYLE,
+ round_to_nearest> {
+public:
+ static long double (_STLP_CALL min) () _STLP_NOTHROW { return LDBL_MIN; }
+ static long double _STLP_CALL denorm_min() _STLP_NOTHROW
+#if defined (_STLP_LDBL_DENORM_MIN)
+ { return _STLP_LDBL_DENORM_MIN; }
+#else
+ { return _STLP_LDBL_DENORM_STYLE ? _STLP_PRIV _LimG<bool>::get_LD_denormMin() : LDBL_MIN; }
+#endif
+ _STLP_STATIC_CONSTANT(bool, is_iec559 = false);
+ static long double (_STLP_CALL max) () _STLP_NOTHROW { return LDBL_MAX; }
+ static long double _STLP_CALL epsilon() _STLP_NOTHROW { return LDBL_EPSILON; }
+ static long double _STLP_CALL round_error() _STLP_NOTHROW { return 0.5l; }
+ static long double _STLP_CALL infinity() _STLP_NOTHROW
+ //For MSVC, long double is nothing more than an alias for double.
+#if !defined (_STLP_MSVC)
+ { return _STLP_PRIV _LimG<bool>::get_LD_inf(); }
+#else
+ { return _STLP_PRIV _LimG<bool>::get_D_inf(); }
+#endif
+ static long double _STLP_CALL quiet_NaN() _STLP_NOTHROW
+#if !defined (_STLP_MSVC)
+ { return _STLP_PRIV _LimG<bool>::get_LD_qNaN(); }
+#else
+ { return _STLP_PRIV _LimG<bool>::get_D_qNaN(); }
+#endif
+ static long double _STLP_CALL signaling_NaN() _STLP_NOTHROW
+#if !defined (_STLP_MSVC)
+ { return _STLP_PRIV _LimG<bool>::get_LD_sNaN(); }
+#else
+ { return _STLP_PRIV _LimG<bool>::get_D_sNaN(); }
+#endif
+};
+
+#endif
+
+// We write special values (Inf and NaN) as bit patterns and
+// cast the the appropriate floating-point types.
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_limits.c>
+#endif
+
+#endif
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_list.c b/sources/android/stlport/stlport/stl/_list.c
new file mode 100644
index 0000000..86e420b
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_list.c
@@ -0,0 +1,250 @@
+/*
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_LIST_C
+#define _STLP_LIST_C
+
+#ifndef _STLP_INTERNAL_LIST_H
+# include <stl/_list.h>
+#endif
+
+#ifndef _STLP_CARRAY_H
+# include <stl/_carray.h>
+#endif
+
+#ifndef _STLP_RANGE_ERRORS_H
+# include <stl/_range_errors.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+#if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)
+template <class _Dummy>
+void _STLP_CALL
+_List_global<_Dummy>::_Transfer(_List_node_base* __position,
+ _List_node_base* __first, _List_node_base* __last) {
+ if (__position != __last) {
+ // Remove [first, last) from its old position.
+ __last->_M_prev->_M_next = __position;
+ __first->_M_prev->_M_next = __last;
+ __position->_M_prev->_M_next = __first;
+
+ // Splice [first, last) into its new position.
+ _Node_base* __tmp = __position->_M_prev;
+ __position->_M_prev = __last->_M_prev;
+ __last->_M_prev = __first->_M_prev;
+ __first->_M_prev = __tmp;
+ }
+}
+#endif /* _STLP_EXPOSE_GLOBALS_IMPLEMENTATION */
+
+template <class _Tp, class _Alloc>
+void _List_base<_Tp,_Alloc>::clear() {
+ _Node* __cur = __STATIC_CAST(_Node*, _M_node._M_data._M_next);
+ while (
+#if defined (__BORLANDC__) // runtime error
+ __cur &&
+#endif
+ __cur != &(_M_node._M_data)) {
+ _Node* __tmp = __cur;
+ __cur = __STATIC_CAST(_Node*, __cur->_M_next);
+ _STLP_STD::_Destroy(&__tmp->_M_data);
+ this->_M_node.deallocate(__tmp, 1);
+ }
+ _M_node._M_data._M_next = &_M_node._M_data;
+ _M_node._M_data._M_prev = &_M_node._M_data;
+}
+
+#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+# define size_type size_t
+#endif
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+# define list _STLP_PTR_IMPL_NAME(list)
+#elif defined (_STLP_DEBUG)
+# define list _STLP_NON_DBG_NAME(list)
+#else
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+template <class _Tp, class _Alloc>
+void list<_Tp, _Alloc>::resize(size_type __new_size, const _Tp& __x) {
+ iterator __i = begin();
+ size_type __len = 0;
+ for ( ; __i != end() && __len < __new_size; ++__i, ++__len);
+
+ if (__len == __new_size)
+ erase(__i, end());
+ else // __i == end()
+ insert(end(), __new_size - __len, __x);
+}
+
+template <class _Tp, class _Alloc>
+list<_Tp, _Alloc>& list<_Tp, _Alloc>::operator=(const list<_Tp, _Alloc>& __x) {
+ if (this != &__x) {
+ iterator __first1 = begin();
+ iterator __last1 = end();
+ const_iterator __first2 = __x.begin();
+ const_iterator __last2 = __x.end();
+ while (__first1 != __last1 && __first2 != __last2)
+ *__first1++ = *__first2++;
+ if (__first2 == __last2)
+ erase(__first1, __last1);
+ else
+ insert(__last1, __first2, __last2);
+ }
+ return *this;
+}
+
+template <class _Tp, class _Alloc>
+void list<_Tp, _Alloc>::_M_fill_assign(size_type __n, const _Tp& __val) {
+ iterator __i = begin();
+ for ( ; __i != end() && __n > 0; ++__i, --__n)
+ *__i = __val;
+ if (__n > 0)
+ insert(end(), __n, __val);
+ else
+ erase(__i, end());
+}
+
+#if !defined (list)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+template <class _Tp, class _Alloc, class _Predicate>
+void _S_remove_if(list<_Tp, _Alloc>& __that, _Predicate __pred) {
+ typedef typename list<_Tp, _Alloc>::iterator _Literator;
+ _Literator __first = __that.begin();
+ _Literator __last = __that.end();
+ while (__first != __last) {
+ _Literator __next = __first;
+ ++__next;
+ if (__pred(*__first)) __that.erase(__first);
+ __first = __next;
+ }
+}
+
+template <class _Tp, class _Alloc, class _BinaryPredicate>
+void _S_unique(list<_Tp, _Alloc>& __that, _BinaryPredicate __binary_pred) {
+ typedef typename list<_Tp, _Alloc>::iterator _Literator;
+ _Literator __first = __that.begin();
+ _Literator __last = __that.end();
+ if (__first == __last) return;
+ _Literator __next = __first;
+ while (++__next != __last) {
+ if (__binary_pred(*__first, *__next))
+ __that.erase(__next);
+ else
+ __first = __next;
+ __next = __first;
+ }
+}
+
+template <class _Tp, class _Alloc, class _StrictWeakOrdering>
+void _S_merge(list<_Tp, _Alloc>& __that, list<_Tp, _Alloc>& __x,
+ _StrictWeakOrdering __comp) {
+ typedef typename list<_Tp, _Alloc>::iterator _Literator;
+ _Literator __first1 = __that.begin();
+ _Literator __last1 = __that.end();
+ _Literator __first2 = __x.begin();
+ _Literator __last2 = __x.end();
+ if (__that.get_allocator() == __x.get_allocator()) {
+ while (__first1 != __last1 && __first2 != __last2) {
+ if (__comp(*__first2, *__first1)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__first1, *__first2), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ _Literator __next = __first2;
+ _List_global_inst::_Transfer(__first1._M_node, __first2._M_node, (++__next)._M_node);
+ __first2 = __next;
+ }
+ else
+ ++__first1;
+ }
+ if (__first2 != __last2)
+ _List_global_inst::_Transfer(__last1._M_node, __first2._M_node, __last2._M_node);
+ }
+ else {
+ while (__first1 != __last1 && __first2 != __last2) {
+ if (__comp(*__first2, *__first1)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__first1, *__first2), _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ __first1 = __that.insert(__first1, *__first2);
+ }
+ else
+ ++__first1;
+ }
+ if (__first2 != __last2) {
+ __that.insert(__first1, __first2, __last2);
+ }
+ __x.clear();
+ }
+}
+
+template <class _Tp, class _Alloc, class _StrictWeakOrdering>
+void _S_sort(list<_Tp, _Alloc>& __that, _StrictWeakOrdering __comp) {
+ // Do nothing if the list has length 0 or 1.
+ if (__that._M_node._M_data._M_next == &__that._M_node._M_data ||
+ __that._M_node._M_data._M_next->_M_next == &__that._M_node._M_data)
+ return;
+
+ list<_Tp, _Alloc> __carry(__that.get_allocator());
+ const int NB = 64;
+ _STLP_PRIV _CArray<list<_Tp, _Alloc>, NB> __counter(__carry);
+ int __fill = 0;
+ while (!__that.empty()) {
+ __carry.splice(__carry.begin(), __that, __that.begin());
+ int __i = 0;
+ while (__i < __fill && !__counter[__i].empty()) {
+ _S_merge(__counter[__i], __carry, __comp);
+ __carry.swap(__counter[__i++]);
+ }
+ __carry.swap(__counter[__i]);
+ if (__i == __fill) {
+ ++__fill;
+ if (__fill >= NB) {
+ //Looks like the list has too many elements to be sorted with this algorithm:
+ __stl_throw_overflow_error("list::sort");
+ }
+ }
+ }
+
+ for (int __i = 1; __i < __fill; ++__i)
+ _S_merge(__counter[__i], __counter[__i - 1], __comp);
+ __that.swap(__counter[__fill - 1]);
+}
+
+#if defined (list)
+# undef list
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_LIST_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_list.h b/sources/android/stlport/stlport/stl/_list.h
new file mode 100644
index 0000000..6cd3f2b
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_list.h
@@ -0,0 +1,742 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_LIST_IMPL_H
+#define _STLP_INTERNAL_LIST_IMPL_H
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+# include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+# include <stl/_alloc.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+# include <stl/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CONSTRUCT_H
+# include <stl/_construct.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+# include <stl/_function_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+struct _List_node_base {
+ _List_node_base* _M_next;
+ _List_node_base* _M_prev;
+};
+
+template <class _Dummy>
+class _List_global {
+public:
+ typedef _List_node_base _Node_base;
+ static void _STLP_CALL _Transfer(_Node_base* __pos,
+ _Node_base* __first, _Node_base* __last);
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS _List_global<bool>;
+#endif
+typedef _List_global<bool> _List_global_inst;
+
+template <class _Tp>
+class _List_node : public _List_node_base {
+public:
+ _Tp _M_data;
+ __TRIVIAL_STUFF(_List_node)
+};
+
+struct _List_iterator_base {
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef bidirectional_iterator_tag iterator_category;
+
+ _List_node_base* _M_node;
+
+ _List_iterator_base(_List_node_base* __x) : _M_node(__x) {}
+
+ void _M_incr() { _M_node = _M_node->_M_next; }
+ void _M_decr() { _M_node = _M_node->_M_prev; }
+};
+
+
+template<class _Tp, class _Traits>
+struct _List_iterator : public _List_iterator_base {
+ typedef _Tp value_type;
+ typedef typename _Traits::pointer pointer;
+ typedef typename _Traits::reference reference;
+
+ typedef _List_iterator<_Tp, _Traits> _Self;
+ typedef typename _Traits::_NonConstTraits _NonConstTraits;
+ typedef _List_iterator<_Tp, _NonConstTraits> iterator;
+ typedef typename _Traits::_ConstTraits _ConstTraits;
+ typedef _List_iterator<_Tp, _ConstTraits> const_iterator;
+
+ typedef bidirectional_iterator_tag iterator_category;
+ typedef _List_node<_Tp> _Node;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+
+ explicit _List_iterator(_List_node_base* __x) : _List_iterator_base(__x) {}
+ _List_iterator() : _List_iterator_base(0) {}
+ //copy constructor for iterator and constructor from iterator for const_iterator
+ _List_iterator(const iterator& __x) : _List_iterator_base(__x._M_node) {}
+
+ reference operator*() const { return __STATIC_CAST(_Node*, this->_M_node)->_M_data; }
+
+ _STLP_DEFINE_ARROW_OPERATOR
+
+ _Self& operator++() {
+ this->_M_incr();
+ return *this;
+ }
+ _Self operator++(int) {
+ _Self __tmp = *this;
+ this->_M_incr();
+ return __tmp;
+ }
+ _Self& operator--() {
+ this->_M_decr();
+ return *this;
+ }
+ _Self operator--(int) {
+ _Self __tmp = *this;
+ this->_M_decr();
+ return __tmp;
+ }
+ bool operator==(const_iterator __y ) const {
+ return this->_M_node == __y._M_node;
+ }
+ bool operator!=(const_iterator __y ) const {
+ return this->_M_node != __y._M_node;
+ }
+};
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+_STLP_MOVE_TO_STD_NAMESPACE
+template <class _Tp, class _Traits>
+struct __type_traits<_STLP_PRIV _List_iterator<_Tp, _Traits> > {
+ typedef __false_type has_trivial_default_constructor;
+ typedef __true_type has_trivial_copy_constructor;
+ typedef __true_type has_trivial_assignment_operator;
+ typedef __true_type has_trivial_destructor;
+ typedef __false_type is_POD_type;
+};
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+#if defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
+_STLP_MOVE_TO_STD_NAMESPACE
+template <class _Tp, class _Traits>
+inline _Tp* value_type(const _STLP_PRIV _List_iterator<_Tp, _Traits>&) { return 0; }
+inline bidirectional_iterator_tag iterator_category(const _STLP_PRIV _List_iterator_base&) { return bidirectional_iterator_tag();}
+inline ptrdiff_t* distance_type(const _STLP_PRIV _List_iterator_base&) { return 0; }
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+// Base class that encapsulates details of allocators and helps
+// to simplify EH
+
+template <class _Tp, class _Alloc>
+class _List_base {
+protected:
+ _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
+ typedef _List_node_base _Node_base;
+ typedef _List_node<_Tp> _Node;
+ typedef _List_base<_Tp, _Alloc> _Self;
+ typedef typename _Alloc_traits<_Node, _Alloc>::allocator_type _Node_allocator_type;
+public:
+ typedef _STLP_alloc_proxy<_Node_base, _Node, _Node_allocator_type> _AllocProxy;
+ typedef _Alloc allocator_type;
+
+ allocator_type get_allocator() const
+ { return _STLP_CONVERT_ALLOCATOR((const _Node_allocator_type&)_M_node, _Tp); }
+
+ _List_base(const allocator_type& __a) : _M_node(_STLP_CONVERT_ALLOCATOR(__a, _Node), _Node_base())
+ { _M_empty_initialize(); }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ _List_base(__move_source<_Self> src) :
+ _M_node(__move_source<_AllocProxy>(src.get()._M_node)) {
+ if (src.get().empty())
+ //We force this to empty.
+ _M_empty_initialize();
+ else {
+ src.get()._M_empty_initialize();
+ _M_node._M_data._M_prev->_M_next = _M_node._M_data._M_next->_M_prev = &_M_node._M_data;
+ }
+ }
+#endif
+
+ ~_List_base()
+ { clear(); }
+
+ void clear();
+ bool empty() const { return _M_node._M_data._M_next == &_M_node._M_data; }
+
+ void _M_empty_initialize() {
+ _M_node._M_data._M_next = &_M_node._M_data;
+ _M_node._M_data._M_prev = _M_node._M_data._M_next;
+ }
+
+public:
+ _AllocProxy _M_node;
+};
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+# define list _STLP_PTR_IMPL_NAME(list)
+#elif defined (_STLP_DEBUG)
+# define list _STLP_NON_DBG_NAME(list)
+#else
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) >
+class list;
+
+#if !defined (list)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+// helper functions to reduce code duplication
+template <class _Tp, class _Alloc, class _Predicate>
+void _S_remove_if(list<_Tp, _Alloc>& __that, _Predicate __pred);
+
+template <class _Tp, class _Alloc, class _BinaryPredicate>
+void _S_unique(list<_Tp, _Alloc>& __that, _BinaryPredicate __binary_pred);
+
+template <class _Tp, class _Alloc, class _StrictWeakOrdering>
+void _S_merge(list<_Tp, _Alloc>& __that, list<_Tp, _Alloc>& __x,
+ _StrictWeakOrdering __comp);
+
+template <class _Tp, class _Alloc, class _StrictWeakOrdering>
+void _S_sort(list<_Tp, _Alloc>& __that, _StrictWeakOrdering __comp);
+
+#if !defined (list)
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+template <class _Tp, class _Alloc>
+class list : public _STLP_PRIV _List_base<_Tp, _Alloc>
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (list)
+ , public __stlport_class<list<_Tp, _Alloc> >
+#endif
+{
+ typedef _STLP_PRIV _List_base<_Tp, _Alloc> _Base;
+ typedef list<_Tp, _Alloc> _Self;
+ typedef _STLP_PRIV _List_node<_Tp> _Node;
+ typedef _STLP_PRIV _List_node_base _Node_base;
+public:
+ typedef _Tp value_type;
+ typedef value_type* pointer;
+ typedef const value_type* const_pointer;
+ typedef value_type& reference;
+ typedef const value_type& const_reference;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
+ typedef typename _Base::allocator_type allocator_type;
+ typedef bidirectional_iterator_tag _Iterator_category;
+
+public:
+ typedef _STLP_PRIV _List_iterator<_Tp, _Nonconst_traits<_Tp> > iterator;
+ typedef _STLP_PRIV _List_iterator<_Tp, _Const_traits<_Tp> > const_iterator;
+ _STLP_DECLARE_BIDIRECTIONAL_REVERSE_ITERATORS;
+
+protected:
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ _Node_base* _M_create_node(const_reference __x = value_type()) {
+#else
+ _Node_base* _M_create_node(const_reference __x) {
+#endif
+ _Node* __p = this->_M_node.allocate(1);
+ _STLP_TRY {
+ _Copy_Construct(&__p->_M_data, __x);
+ }
+ _STLP_UNWIND(this->_M_node.deallocate(__p, 1))
+ return __p;
+ }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+ _Node_base* _M_create_node() {
+ _Node* __p = this->_M_node.allocate(1);
+ _STLP_TRY {
+ _STLP_STD::_Construct(&__p->_M_data);
+ }
+ _STLP_UNWIND(this->_M_node.deallocate(__p, 1))
+ return __p;
+ }
+#endif
+
+public:
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ explicit list(size_type __n, const_reference __val = _STLP_DEFAULT_CONSTRUCTED(value_type),
+ const allocator_type& __a = allocator_type())
+#else
+ explicit list(size_type __n)
+ : _STLP_PRIV _List_base<_Tp, _Alloc>(allocator_type())
+ { this->insert(begin(), __n, _STLP_DEFAULT_CONSTRUCTED(value_type)); }
+ list(size_type __n, const_reference __val)
+ : _STLP_PRIV _List_base<_Tp, _Alloc>(allocator_type())
+ { this->insert(begin(), __n, __val); }
+ list(size_type __n, const_reference __val, const allocator_type& __a)
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ : _STLP_PRIV _List_base<_Tp, _Alloc>(__a)
+ { this->insert(begin(), __n, __val); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ // We don't need any dispatching tricks here, because insert does all of
+ // that anyway.
+ template <class _InputIterator>
+ list(_InputIterator __first, _InputIterator __last,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _STLP_PRIV _List_base<_Tp, _Alloc>(__a)
+ { _M_insert(begin(), __first, __last); }
+
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ list(_InputIterator __first, _InputIterator __last)
+ : _STLP_PRIV _List_base<_Tp, _Alloc>(allocator_type())
+ { _M_insert(begin(), __first, __last); }
+# endif
+#else /* _STLP_MEMBER_TEMPLATES */
+ list(const value_type* __first, const value_type* __last,
+ const allocator_type& __a = allocator_type())
+ : _STLP_PRIV _List_base<_Tp, _Alloc>(__a)
+ { _M_insert(begin(), __first, __last); }
+ list(const_iterator __first, const_iterator __last,
+ const allocator_type& __a = allocator_type())
+ : _STLP_PRIV _List_base<_Tp, _Alloc>(__a)
+ { _M_insert(begin(), __first, __last); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ explicit list(const allocator_type& __a = allocator_type())
+#else
+ list()
+ : _STLP_PRIV _List_base<_Tp, _Alloc>(allocator_type()) {}
+ list(const allocator_type& __a)
+#endif
+ : _STLP_PRIV _List_base<_Tp, _Alloc>(__a) {}
+
+ list(const _Self& __x) : _STLP_PRIV _List_base<_Tp, _Alloc>(__x.get_allocator())
+ { _M_insert(begin(), __x.begin(), __x.end()); }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ list(__move_source<_Self> src)
+ : _STLP_PRIV _List_base<_Tp, _Alloc>(__move_source<_Base>(src.get())) {}
+#endif
+
+ ~list() {}
+
+ _Self& operator = (const _Self& __x);
+
+ iterator begin() { return iterator(this->_M_node._M_data._M_next); }
+ const_iterator begin() const { return const_iterator(this->_M_node._M_data._M_next); }
+
+ iterator end() { return iterator(&this->_M_node._M_data); }
+ const_iterator end() const { return const_iterator(__CONST_CAST(_Node_base*, &this->_M_node._M_data)); }
+
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+ const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+
+ size_type size() const {
+ size_type __result = _STLP_STD::distance(begin(), end());
+ return __result;
+ }
+ size_type max_size() const { return size_type(-1); }
+
+ reference front() { return *begin(); }
+ const_reference front() const { return *begin(); }
+ reference back() { return *(--end()); }
+ const_reference back() const { return *(--end()); }
+
+private:
+ void _M_swap_aux(_Self& __x) {
+ __x._M_node._M_swap_alloc(this->_M_node);
+ __x._M_node._M_data._M_next = this->_M_node._M_data._M_next;
+ __x._M_node._M_data._M_next->_M_prev = &__x._M_node._M_data;
+ __x._M_node._M_data._M_prev = this->_M_node._M_data._M_prev;
+ __x._M_node._M_data._M_prev->_M_next = &__x._M_node._M_data;
+ this->_M_empty_initialize();
+ }
+
+public:
+ void swap(_Self& __x) {
+ if (__x.empty()) {
+ if (this->empty()) {
+ return;
+ }
+ this->_M_swap_aux(__x);
+ } else if (this->empty()) {
+ __x._M_swap_aux(*this);
+ } else {
+ this->_M_node.swap(__x._M_node);
+ _STLP_STD::swap(this->_M_node._M_data._M_prev->_M_next, __x._M_node._M_data._M_prev->_M_next);
+ _STLP_STD::swap(this->_M_node._M_data._M_next->_M_prev, __x._M_node._M_data._M_next->_M_prev);
+ }
+ }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+ iterator insert(iterator __pos, const_reference __x = value_type())
+#else
+ iterator insert(iterator __pos, const_reference __x)
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+ {
+ _Node_base* __tmp = _M_create_node(__x);
+ _Node_base* __n = __pos._M_node;
+ _Node_base* __p = __n->_M_prev;
+ __tmp->_M_next = __n;
+ __tmp->_M_prev = __p;
+ __p->_M_next = __tmp;
+ __n->_M_prev = __tmp;
+ return iterator(__tmp);
+ }
+
+private:
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void _M_insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_insert_dispatch(__pos, __first, __last, _Integral());
+ }
+
+ // Check whether it's an integral type. If so, it's not an iterator.
+ template<class _Integer>
+ void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
+ const __true_type& /*_IsIntegral*/) {
+ _M_fill_insert(__pos, __n, __x);
+ }
+ template <class _InputIter>
+ void _M_insert_dispatch(iterator __pos,
+ _InputIter __first, _InputIter __last,
+ const __false_type& /*_IsIntegral*/) {
+#else /* _STLP_MEMBER_TEMPLATES */
+ void _M_insert(iterator __pos, const value_type* __first, const value_type* __last) {
+ for (; __first != __last; ++__first)
+ insert(__pos, *__first);
+ }
+ void _M_insert(iterator __pos, const_iterator __first, const_iterator __last) {
+#endif /* _STLP_MEMBER_TEMPLATES */
+ //We use a temporary list to avoid the auto reference troubles (infinite loop)
+ for (; __first != __last; ++__first)
+ insert(__pos, *__first);
+ }
+
+public:
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_splice_insert_dispatch(__pos, __first, __last, _Integral());
+ }
+
+private:
+ // Check whether it's an integral type. If so, it's not an iterator.
+ template<class _Integer>
+ void _M_splice_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
+ const __true_type& /*_IsIntegral*/) {
+ _M_fill_insert(__pos, __n, __x);
+ }
+ template <class _InputIter>
+ void _M_splice_insert_dispatch(iterator __pos,
+ _InputIter __first, _InputIter __last,
+ const __false_type& /*_IsIntegral*/) {
+#else /* _STLP_MEMBER_TEMPLATES */
+ void insert(iterator __pos, const value_type* __first, const value_type* __last) {
+ _Self __tmp(__first, __last, this->get_allocator());
+ _STLP_ASSERT(__tmp.get_allocator() == this->get_allocator())
+ splice(__pos, __tmp);
+ }
+ void insert(iterator __pos, const_iterator __first, const_iterator __last) {
+#endif /* _STLP_MEMBER_TEMPLATES */
+ //We use a temporary list to avoid the auto reference troubles (infinite loop)
+ _Self __tmp(__first, __last, this->get_allocator());
+ splice(__pos, __tmp);
+ }
+
+public:
+ void insert(iterator __pos, size_type __n, const_reference __x)
+ { _M_fill_insert(__pos, __n, __x); }
+
+private:
+ void _M_fill_insert(iterator __pos, size_type __n, const_reference __x) {
+ for ( ; __n > 0; --__n)
+ insert(__pos, __x);
+ }
+
+public:
+ void push_front(const_reference __x) { insert(begin(), __x); }
+ void push_back (const_reference __x) { insert(end(), __x); }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ iterator insert(iterator __pos)
+ { return insert(__pos, _STLP_DEFAULT_CONSTRUCTED(value_type)); }
+ void push_front() {insert(begin());}
+ void push_back() {insert(end());}
+# endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+ iterator erase(iterator __pos) {
+ _Node_base* __next_node = __pos._M_node->_M_next;
+ _Node_base* __prev_node = __pos._M_node->_M_prev;
+ _Node* __n = __STATIC_CAST(_Node*, __pos._M_node);
+ __prev_node->_M_next = __next_node;
+ __next_node->_M_prev = __prev_node;
+ _STLP_STD::_Destroy(&__n->_M_data);
+ this->_M_node.deallocate(__n, 1);
+ return iterator(__next_node);
+ }
+
+ iterator erase(iterator __first, iterator __last) {
+ while (__first != __last)
+ erase(__first++);
+ return __last;
+ }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size, const_reference __x = value_type());
+#else
+ void resize(size_type __new_size, const_reference __x);
+ void resize(size_type __new_size)
+ { this->resize(__new_size, _STLP_DEFAULT_CONSTRUCTED(value_type)); }
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM*/
+
+ void pop_front() { erase(begin()); }
+ void pop_back() {
+ iterator __tmp = end();
+ erase(--__tmp);
+ }
+
+public:
+ // assign(), a generalized assignment member function. Two
+ // versions: one that takes a count, and one that takes a range.
+ // The range version is a member template, so we dispatch on whether
+ // or not the type is an integer.
+
+ void assign(size_type __n, const_reference __val) { _M_fill_assign(__n, __val); }
+
+ void _M_fill_assign(size_type __n, const_reference __val);
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void assign(_InputIterator __first, _InputIterator __last) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_assign_dispatch(__first, __last, _Integral());
+ }
+
+ template <class _Integer>
+ void _M_assign_dispatch(_Integer __n, _Integer __val,
+ const __true_type& /*_IsIntegral*/) {
+ _M_fill_assign(__n, __val);
+ }
+
+ template <class _InputIterator>
+ void _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2,
+ const __false_type& /*_IsIntegral*/) {
+#else
+ void assign(const value_type *__first2, const value_type *__last2) {
+ iterator __first1 = begin();
+ iterator __last1 = end();
+ for ( ; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)
+ *__first1 = *__first2;
+ if (__first2 == __last2)
+ erase(__first1, __last1);
+ else
+ insert(__last1, __first2, __last2);
+ }
+ void assign(const_iterator __first2, const_iterator __last2) {
+#endif /* _STLP_MEMBER_TEMPLATES */
+ iterator __first1 = begin();
+ iterator __last1 = end();
+ for ( ; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)
+ *__first1 = *__first2;
+ if (__first2 == __last2)
+ erase(__first1, __last1);
+ else
+ insert(__last1, __first2, __last2);
+ }
+
+public:
+ void splice(iterator __pos, _Self& __x) {
+ if (!__x.empty()) {
+ if (this->get_allocator() == __x.get_allocator()) {
+ _STLP_PRIV _List_global_inst::_Transfer(__pos._M_node, __x.begin()._M_node, __x.end()._M_node);
+ }
+ else {
+ insert(__pos, __x.begin(), __x.end());
+ __x.clear();
+ }
+ }
+ }
+ void splice(iterator __pos, _Self& __x, iterator __i) {
+ iterator __j = __i;
+ ++__j;
+ if (__pos == __i || __pos == __j) return;
+ if (this->get_allocator() == __x.get_allocator()) {
+ _STLP_PRIV _List_global_inst::_Transfer(__pos._M_node, __i._M_node, __j._M_node);
+ }
+ else {
+ insert(__pos, *__i);
+ __x.erase(__i);
+ }
+ }
+ void splice(iterator __pos, _Self& __x, iterator __first, iterator __last) {
+ if (__first != __last) {
+ if (this->get_allocator() == __x.get_allocator()) {
+ _STLP_PRIV _List_global_inst::_Transfer(__pos._M_node, __first._M_node, __last._M_node);
+ }
+ else {
+ insert(__pos, __first, __last);
+ __x.erase(__first, __last);
+ }
+ }
+ }
+
+ void remove(const_reference __val) {
+ iterator __first = begin();
+ iterator __last = end();
+ while (__first != __last) {
+ iterator __next = __first;
+ ++__next;
+ if (__val == *__first) erase(__first);
+ __first = __next;
+ }
+ }
+
+ void unique()
+ { _STLP_PRIV _S_unique(*this, equal_to<value_type>()); }
+
+ void merge(_Self& __x)
+ { _STLP_PRIV _S_merge(*this, __x, less<value_type>()); }
+
+ void reverse() {
+ _Node_base* __p = &this->_M_node._M_data;
+ _Node_base* __tmp = __p;
+ do {
+ _STLP_STD::swap(__tmp->_M_next, __tmp->_M_prev);
+ __tmp = __tmp->_M_prev; // Old next node is now prev.
+ } while (__tmp != __p);
+ }
+
+ void sort()
+ { _STLP_PRIV _S_sort(*this, less<value_type>()); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _Predicate>
+ void remove_if(_Predicate __pred)
+ { _STLP_PRIV _S_remove_if(*this, __pred); }
+ template <class _BinaryPredicate>
+ void unique(_BinaryPredicate __binary_pred)
+ { _STLP_PRIV _S_unique(*this, __binary_pred); }
+
+ template <class _StrictWeakOrdering>
+ void merge(_Self& __x,
+ _StrictWeakOrdering __comp) {
+ _STLP_PRIV _S_merge(*this, __x, __comp);
+ }
+
+ template <class _StrictWeakOrdering>
+ void sort(_StrictWeakOrdering __comp)
+ { _STLP_PRIV _S_sort(*this, __comp); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+};
+
+#if defined (list)
+# undef list
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_list.c>
+#endif
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+# include <stl/pointers/_list.h>
+#endif
+
+#if defined (_STLP_DEBUG)
+# include <stl/debug/_list.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Tp, class _Alloc>
+_STLP_INLINE_LOOP bool _STLP_CALL
+operator==(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y) {
+ typedef typename list<_Tp,_Alloc>::const_iterator const_iterator;
+ const_iterator __end1 = __x.end();
+ const_iterator __end2 = __y.end();
+
+ const_iterator __i1 = __x.begin();
+ const_iterator __i2 = __y.begin();
+ while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2) {
+ ++__i1;
+ ++__i2;
+ }
+ return __i1 == __end1 && __i2 == __end2;
+}
+
+#define _STLP_EQUAL_OPERATOR_SPECIALIZED
+#define _STLP_TEMPLATE_HEADER template <class _Tp, class _Alloc>
+#define _STLP_TEMPLATE_CONTAINER list<_Tp, _Alloc>
+#include <stl/_relops_cont.h>
+#undef _STLP_TEMPLATE_CONTAINER
+#undef _STLP_TEMPLATE_HEADER
+#undef _STLP_EQUAL_OPERATOR_SPECIALIZED
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Tp, class _Alloc>
+struct __move_traits<list<_Tp, _Alloc> > {
+ typedef __true_type implemented;
+ typedef typename __move_traits<_Alloc>::complete complete;
+};
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_LIST_IMPL_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_locale.h b/sources/android/stlport/stlport/stl/_locale.h
new file mode 100644
index 0000000..fd6d537
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_locale.h
@@ -0,0 +1,364 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+// WARNING: This is an internal header file, included by other C++
+// standard library headers. You should not attempt to use this header
+// file directly.
+
+
+#ifndef _STLP_INTERNAL_LOCALE_H
+#define _STLP_INTERNAL_LOCALE_H
+
+#ifndef _STLP_INTERNAL_CSTDLIB
+# include <stl/_cstdlib.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CWCHAR
+# include <stl/_cwchar.h>
+#endif
+
+#ifndef _STLP_INTERNAL_THREADS_H
+# include <stl/_threads.h>
+#endif
+
+#ifndef _STLP_STRING_FWD_H
+# include <stl/_string_fwd.h>
+#endif
+
+#include <stl/_facets_fwd.h>
+
+_STLP_BEGIN_NAMESPACE
+
+class _Locale_impl; // Forward declaration of opaque type.
+class locale;
+
+template <class _CharT, class _Traits, class _Alloc>
+bool __locale_do_operator_call(const locale& __loc,
+ const basic_string<_CharT, _Traits, _Alloc>& __x,
+ const basic_string<_CharT, _Traits, _Alloc>& __y);
+
+_STLP_DECLSPEC _Locale_impl * _STLP_CALL _get_Locale_impl( _Locale_impl *locimpl );
+_STLP_DECLSPEC _Locale_impl * _STLP_CALL _copy_Nameless_Locale_impl( _Locale_impl *locimpl );
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Facet>
+bool _HasFacet(const locale& __loc, const _Facet* __facet) _STLP_NOTHROW;
+
+template <class _Facet>
+_Facet* _UseFacet(const locale& __loc, const _Facet* __facet);
+
+template <class _Facet>
+void _InsertFacet(locale& __loc, _Facet* __facet);
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) || \
+ defined (_STLP_SIGNAL_RUNTIME_COMPATIBILITY) || defined (_STLP_CHECK_RUNTIME_COMPATIBILITY)
+# define locale _STLP_NO_MEM_T_NAME(loc)
+#endif
+
+class _STLP_CLASS_DECLSPEC locale {
+public:
+ // types:
+ class _STLP_CLASS_DECLSPEC facet : protected _Refcount_Base {
+ protected:
+ /* Here we filter __init_count user value to 0 or 1 because __init_count is a
+ * size_t instance and _Refcount_Base use __stl_atomic_t instances that might
+ * have lower sizeof and generate roll issues. 1 is enough to keep the facet
+ * alive when required. */
+ explicit facet(size_t __init_count = 0) : _Refcount_Base( __init_count == 0 ? 0 : 1 ) {}
+ virtual ~facet();
+ friend class locale;
+ friend class _Locale_impl;
+ friend facet * _STLP_CALL _get_facet( facet * );
+ friend void _STLP_CALL _release_facet( facet *& );
+
+ private: // Invalidate assignment and copying.
+ facet(const facet& ) /* : _Refcount_Base(1) {} */;
+ void operator=(const facet&);
+ };
+
+#if defined (__MVS__) || defined (__OS400__)
+ struct
+#else
+ class
+#endif
+ _STLP_CLASS_DECLSPEC id {
+ public:
+ size_t _M_index;
+ static size_t _S_max;
+ };
+
+ typedef int category;
+ _STLP_STATIC_CONSTANT(category, none = 0x000);
+ _STLP_STATIC_CONSTANT(category, collate = 0x010);
+ _STLP_STATIC_CONSTANT(category, ctype = 0x020);
+ _STLP_STATIC_CONSTANT(category, monetary = 0x040);
+ _STLP_STATIC_CONSTANT(category, numeric = 0x100);
+ _STLP_STATIC_CONSTANT(category, time = 0x200);
+ _STLP_STATIC_CONSTANT(category, messages = 0x400);
+ _STLP_STATIC_CONSTANT(category, all = collate | ctype | monetary | numeric | time | messages);
+
+ // construct/copy/destroy:
+ locale() _STLP_NOTHROW;
+ locale(const locale&) _STLP_NOTHROW;
+ explicit locale(const char *);
+ locale(const locale&, const char*, category);
+
+#if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+ template <class _Facet>
+ locale(const locale& __loc, _Facet* __f) {
+ if ( __f != 0 ) {
+ this->_M_impl = _get_Locale_impl( _copy_Nameless_Locale_impl( __loc._M_impl ) );
+ _STLP_PRIV _InsertFacet(*this, __f);
+ } else {
+ this->_M_impl = _get_Locale_impl( __loc._M_impl );
+ }
+ }
+#endif
+
+protected:
+ // those are for internal use
+ locale(_Locale_impl*);
+
+public:
+ locale(const locale&, const locale&, category);
+ const locale& operator=(const locale&) _STLP_NOTHROW;
+
+#if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+protected:
+#endif
+ ~locale() _STLP_NOTHROW;
+
+public:
+#if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS) && \
+ !defined(_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+ template <class _Facet>
+ locale combine(const locale& __loc) const {
+ _Facet *__facet = 0;
+ if (!_STLP_PRIV _HasFacet(__loc, __facet))
+ _M_throw_on_combine_error(__loc.name());
+
+ return locale(*this, _STLP_PRIV _UseFacet(__loc, __facet));
+ }
+#endif
+
+ // locale operations:
+ string name() const;
+
+ bool operator==(const locale&) const;
+ bool operator!=(const locale&) const;
+
+#if !defined (_STLP_MEMBER_TEMPLATES) || defined (_STLP_INLINE_MEMBER_TEMPLATES) || (defined(__MWERKS__) && __MWERKS__ <= 0x2301)
+ bool operator()(const string& __x, const string& __y) const;
+# ifndef _STLP_NO_WCHAR_T
+ bool operator()(const wstring& __x, const wstring& __y) const;
+# endif
+#elif !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+ template <class _CharT, class _Traits, class _Alloc>
+ bool operator()(const basic_string<_CharT, _Traits, _Alloc>& __x,
+ const basic_string<_CharT, _Traits, _Alloc>& __y) const
+ { return __locale_do_operator_call(*this, __x, __y); }
+#endif
+
+ // global locale objects:
+#if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+ static locale _STLP_CALL global(const locale&);
+#else
+ static _Locale_impl* _STLP_CALL global(const locale&);
+#endif
+ static const locale& _STLP_CALL classic();
+
+//protected: // Helper functions for locale globals.
+ facet* _M_get_facet(const id&) const;
+ // same, but throws
+ facet* _M_use_facet(const id&) const;
+ static void _STLP_FUNCTION_THROWS _STLP_CALL _M_throw_on_combine_error(const string& name);
+ static void _STLP_FUNCTION_THROWS _STLP_CALL _M_throw_on_null_name();
+ static void _STLP_FUNCTION_THROWS _STLP_CALL _M_throw_on_creation_failure(int __err_code,
+ const char* name, const char* facet);
+
+//protected: // More helper functions.
+ void _M_insert(facet* __f, id& __id);
+
+ // friends:
+ friend class _Locale_impl;
+
+protected: // Data members
+ _Locale_impl* _M_impl;
+ _Locale_impl* _M_get_impl() const { return _M_impl; }
+};
+
+#if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) || \
+ defined (_STLP_SIGNAL_RUNTIME_COMPATIBILITY) || defined (_STLP_CHECK_RUNTIME_COMPATIBILITY)
+# undef locale
+# define _Locale _STLP_NO_MEM_T_NAME(loc)
+
+class locale : public _Locale {
+public:
+
+ // construct/copy/destroy:
+ locale() _STLP_NOTHROW {
+#if defined (_STLP_CHECK_RUNTIME_COMPATIBILITY)
+ _STLP_CHECK_RUNTIME_COMPATIBILITY();
+#endif
+ }
+ locale(const locale& __loc) _STLP_NOTHROW : _Locale(__loc) {}
+ explicit locale(const char *__str) : _Locale(__str) {}
+ locale(const locale& __loc, const char* __str, category __cat)
+ : _Locale(__loc, __str, __cat) {}
+
+ template <class _Facet>
+ locale(const locale& __loc, _Facet* __f)
+ : _Locale(__f != 0 ? _copy_Nameless_Locale_impl(__loc._M_impl) : __loc._M_impl) {
+ if ( __f != 0 ) {
+ _STLP_PRIV _InsertFacet(*this, __f);
+ }
+ }
+
+private:
+ // those are for internal use
+ locale(_Locale_impl* __impl) : _Locale(__impl) {}
+ locale(const _Locale& __loc) : _Locale(__loc) {}
+
+public:
+
+ locale(const locale& __loc1, const locale& __loc2, category __cat)
+ : _Locale(__loc1, __loc2, __cat) {}
+
+ const locale& operator=(const locale& __loc) _STLP_NOTHROW {
+ _Locale::operator=(__loc);
+ return *this;
+ }
+
+ template <class _Facet>
+ locale combine(const locale& __loc) const {
+ _Facet *__facet = 0;
+ if (!_STLP_PRIV _HasFacet(__loc, __facet))
+ _M_throw_on_combine_error(__loc.name());
+
+ return locale(*this, _STLP_PRIV _UseFacet(__loc, __facet));
+ }
+
+ // locale operations:
+ bool operator==(const locale& __loc) const { return _Locale::operator==(__loc); }
+ bool operator!=(const locale& __loc) const { return _Locale::operator!=(__loc); }
+
+ template <class _CharT, class _Traits, class _Alloc>
+ bool operator()(const basic_string<_CharT, _Traits, _Alloc>& __x,
+ const basic_string<_CharT, _Traits, _Alloc>& __y) const
+ { return __locale_do_operator_call(*this, __x, __y); }
+
+ // global locale objects:
+ static locale _STLP_CALL global(const locale& __loc) {
+ return _Locale::global(__loc);
+ }
+ static const locale& _STLP_CALL classic() {
+ return __STATIC_CAST(const locale&, _Locale::classic());
+ }
+
+ // friends:
+ friend class _Locale_impl;
+};
+
+# undef _Locale
+#endif
+
+//----------------------------------------------------------------------
+// locale globals
+
+template <class _Facet>
+inline const _Facet&
+#ifdef _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS
+_Use_facet<_Facet>::operator *() const
+#else
+use_facet(const locale& __loc)
+#endif
+{
+ _Facet *__facet = 0;
+ return *(_STLP_PRIV _UseFacet(__loc, __facet));
+}
+
+template <class _Facet>
+#ifdef _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS
+struct has_facet {
+ const locale& __loc;
+ has_facet(const locale& __p_loc) : __loc(__p_loc) {}
+ operator bool() const _STLP_NOTHROW
+#else
+inline bool has_facet(const locale& __loc) _STLP_NOTHROW
+#endif
+{
+ _Facet *__facet = 0;
+ return _STLP_PRIV _HasFacet(__loc, __facet);
+}
+
+#ifdef _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS
+}; // close class definition
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+/* _GetFacetId is a helper function that allow delaying access to
+ * facet id static instance in the library source code to avoid
+ * the other static instances that many compilers are generating
+ * in all dynamic library or executable when instanciating facet
+ * template class.
+ */
+template <class _Facet>
+inline locale::id& _GetFacetId(const _Facet*)
+{ return _Facet::id; }
+
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const money_get<char, istreambuf_iterator<char, char_traits<char> > >*);
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const money_put<char, ostreambuf_iterator<char, char_traits<char> > >*);
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const num_get<char, istreambuf_iterator<char, char_traits<char> > >*);
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const num_put<char, ostreambuf_iterator<char, char_traits<char> > >*);
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const time_get<char, istreambuf_iterator<char, char_traits<char> > >*);
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const time_put<char, ostreambuf_iterator<char, char_traits<char> > >*);
+
+#ifndef _STLP_NO_WCHAR_T
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const money_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >*);
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const money_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >*);
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >*);
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >*);
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >*);
+_STLP_DECLSPEC locale::id& _STLP_CALL _GetFacetId(const time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >*);
+#endif
+
+template <class _Facet>
+inline bool _HasFacet(const locale& __loc, const _Facet* __facet) _STLP_NOTHROW
+{ return (__loc._M_get_facet(_GetFacetId(__facet)) != 0); }
+
+template <class _Facet>
+inline _Facet* _UseFacet(const locale& __loc, const _Facet* __facet)
+{ return __STATIC_CAST(_Facet*, __loc._M_use_facet(_GetFacetId(__facet))); }
+
+template <class _Facet>
+inline void _InsertFacet(locale& __loc, _Facet* __facet)
+{ __loc._M_insert(__facet, _GetFacetId(__facet)); }
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_LOCALE_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/stl/_map.h b/sources/android/stlport/stlport/stl/_map.h
new file mode 100644
index 0000000..bf46a5d
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_map.h
@@ -0,0 +1,435 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_MAP_H
+#define _STLP_INTERNAL_MAP_H
+
+#ifndef _STLP_INTERNAL_TREE_H
+# include <stl/_tree.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//Specific iterator traits creation
+_STLP_CREATE_ITERATOR_TRAITS(MapTraitsT, traits)
+
+template <class _Key, class _Tp, _STLP_DFL_TMPL_PARAM(_Compare, less<_Key> ),
+ _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_STLP_CONST _Key, _Tp) >
+class map
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ : public __stlport_class<map<_Key, _Tp, _Compare, _Alloc> >
+#endif
+{
+ typedef map<_Key, _Tp, _Compare, _Alloc> _Self;
+public:
+
+// typedefs:
+
+ typedef _Key key_type;
+ typedef _Tp data_type;
+ typedef _Tp mapped_type;
+ typedef pair<_STLP_CONST _Key, _Tp> value_type;
+ typedef _Compare key_compare;
+
+ class value_compare
+ : public binary_function<value_type, value_type, bool> {
+ friend class map<_Key,_Tp,_Compare,_Alloc>;
+ protected :
+ //c is a Standard name (23.3.1), do no make it STLport naming convention compliant.
+ _Compare comp;
+ value_compare(_Compare __c) : comp(__c) {}
+ public:
+ bool operator()(const value_type& __x, const value_type& __y) const
+ { return comp(__x.first, __y.first); }
+ };
+
+protected:
+ typedef _STLP_PRIV _MapTraitsT<value_type> _MapTraits;
+
+public:
+ //Following typedef have to be public for __move_traits specialization.
+ typedef _STLP_PRIV _Rb_tree<key_type, key_compare,
+ value_type, _STLP_SELECT1ST(value_type, _Key),
+ _MapTraits, _Alloc> _Rep_type;
+
+ typedef typename _Rep_type::pointer pointer;
+ typedef typename _Rep_type::const_pointer const_pointer;
+ typedef typename _Rep_type::reference reference;
+ typedef typename _Rep_type::const_reference const_reference;
+ typedef typename _Rep_type::iterator iterator;
+ typedef typename _Rep_type::const_iterator const_iterator;
+ typedef typename _Rep_type::reverse_iterator reverse_iterator;
+ typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+ typedef typename _Rep_type::size_type size_type;
+ typedef typename _Rep_type::difference_type difference_type;
+ typedef typename _Rep_type::allocator_type allocator_type;
+
+private:
+ _Rep_type _M_t; // red-black tree representing map
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+public:
+ // allocation/deallocation
+ map() : _M_t(_Compare(), allocator_type()) {}
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ explicit map(const _Compare& __comp,
+ const allocator_type& __a = allocator_type())
+#else
+ explicit map(const _Compare& __comp)
+ : _M_t(__comp, allocator_type()) {}
+ explicit map(const _Compare& __comp, const allocator_type& __a)
+#endif
+ : _M_t(__comp, __a) {}
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ map(_InputIterator __first, _InputIterator __last)
+ : _M_t(_Compare(), allocator_type())
+ { _M_t.insert_unique(__first, __last); }
+
+ template <class _InputIterator>
+ map(_InputIterator __first, _InputIterator __last, const _Compare& __comp,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); }
+
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ map(_InputIterator __first, _InputIterator __last, const _Compare& __comp)
+ : _M_t(__comp, allocator_type()) { _M_t.insert_unique(__first, __last); }
+# endif
+
+#else
+ map(const value_type* __first, const value_type* __last)
+ : _M_t(_Compare(), allocator_type())
+ { _M_t.insert_unique(__first, __last); }
+
+ map(const value_type* __first,
+ const value_type* __last, const _Compare& __comp,
+ const allocator_type& __a = allocator_type())
+ : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); }
+
+ map(const_iterator __first, const_iterator __last)
+ : _M_t(_Compare(), allocator_type())
+ { _M_t.insert_unique(__first, __last); }
+
+ map(const_iterator __first, const_iterator __last, const _Compare& __comp,
+ const allocator_type& __a = allocator_type())
+ : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ map(const _Self& __x) : _M_t(__x._M_t) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ map(__move_source<_Self> src)
+ : _M_t(__move_source<_Rep_type>(src.get()._M_t)) {}
+#endif
+
+ _Self& operator=(const _Self& __x) {
+ _M_t = __x._M_t;
+ return *this;
+ }
+
+ // accessors:
+ key_compare key_comp() const { return _M_t.key_comp(); }
+ value_compare value_comp() const { return value_compare(_M_t.key_comp()); }
+ allocator_type get_allocator() const { return _M_t.get_allocator(); }
+
+ iterator begin() { return _M_t.begin(); }
+ const_iterator begin() const { return _M_t.begin(); }
+ iterator end() { return _M_t.end(); }
+ const_iterator end() const { return _M_t.end(); }
+ reverse_iterator rbegin() { return _M_t.rbegin(); }
+ const_reverse_iterator rbegin() const { return _M_t.rbegin(); }
+ reverse_iterator rend() { return _M_t.rend(); }
+ const_reverse_iterator rend() const { return _M_t.rend(); }
+ bool empty() const { return _M_t.empty(); }
+ size_type size() const { return _M_t.size(); }
+ size_type max_size() const { return _M_t.max_size(); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ _Tp& operator[](const _KT& __k) {
+ iterator __i = lower_bound(__k);
+ // __i->first is greater than or equivalent to __k.
+ if (__i == end() || key_comp()(__k, (*__i).first))
+ __i = insert(__i, value_type(__k, _STLP_DEFAULT_CONSTRUCTED(_Tp)));
+ return (*__i).second;
+ }
+ void swap(_Self& __x) { _M_t.swap(__x._M_t); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+ // insert/erase
+ pair<iterator,bool> insert(const value_type& __x)
+ { return _M_t.insert_unique(__x); }
+ iterator insert(iterator __pos, const value_type& __x)
+ { return _M_t.insert_unique(__pos, __x); }
+#ifdef _STLP_MEMBER_TEMPLATES
+ template <class _InputIterator>
+ void insert(_InputIterator __first, _InputIterator __last)
+ { _M_t.insert_unique(__first, __last); }
+#else
+ void insert(const value_type* __first, const value_type* __last)
+ { _M_t.insert_unique(__first, __last); }
+ void insert(const_iterator __first, const_iterator __last)
+ { _M_t.insert_unique(__first, __last); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ void erase(iterator __pos) { _M_t.erase(__pos); }
+ size_type erase(const key_type& __x) { return _M_t.erase_unique(__x); }
+ void erase(iterator __first, iterator __last) { _M_t.erase(__first, __last); }
+ void clear() { _M_t.clear(); }
+
+ // map operations:
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __x) { return _M_t.find(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __x) const { return _M_t.find(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __x) const { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator lower_bound(const _KT& __x) { return _M_t.lower_bound(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator lower_bound(const _KT& __x) const { return _M_t.lower_bound(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator upper_bound(const _KT& __x) { return _M_t.upper_bound(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator upper_bound(const _KT& __x) const { return _M_t.upper_bound(__x); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator,iterator> equal_range(const _KT& __x)
+ { return _M_t.equal_range_unique(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator,const_iterator> equal_range(const _KT& __x) const
+ { return _M_t.equal_range_unique(__x); }
+};
+
+//Specific iterator traits creation
+_STLP_CREATE_ITERATOR_TRAITS(MultimapTraitsT, traits)
+
+template <class _Key, class _Tp, _STLP_DFL_TMPL_PARAM(_Compare, less<_Key> ),
+ _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_STLP_CONST _Key, _Tp) >
+class multimap
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ : public __stlport_class<multimap<_Key, _Tp, _Compare, _Alloc> >
+#endif
+{
+ typedef multimap<_Key, _Tp, _Compare, _Alloc> _Self;
+public:
+
+// typedefs:
+
+ typedef _Key key_type;
+ typedef _Tp data_type;
+ typedef _Tp mapped_type;
+ typedef pair<_STLP_CONST _Key, _Tp> value_type;
+ typedef _Compare key_compare;
+
+ class value_compare : public binary_function<value_type, value_type, bool> {
+ friend class multimap<_Key,_Tp,_Compare,_Alloc>;
+ protected:
+ //comp is a Standard name (23.3.2), do no make it STLport naming convention compliant.
+ _Compare comp;
+ value_compare(_Compare __c) : comp(__c) {}
+ public:
+ bool operator()(const value_type& __x, const value_type& __y) const
+ { return comp(__x.first, __y.first); }
+ };
+
+protected:
+ //Specific iterator traits creation
+ typedef _STLP_PRIV _MultimapTraitsT<value_type> _MultimapTraits;
+
+public:
+ //Following typedef have to be public for __move_traits specialization.
+ typedef _STLP_PRIV _Rb_tree<key_type, key_compare,
+ value_type, _STLP_SELECT1ST(value_type, _Key),
+ _MultimapTraits, _Alloc> _Rep_type;
+
+ typedef typename _Rep_type::pointer pointer;
+ typedef typename _Rep_type::const_pointer const_pointer;
+ typedef typename _Rep_type::reference reference;
+ typedef typename _Rep_type::const_reference const_reference;
+ typedef typename _Rep_type::iterator iterator;
+ typedef typename _Rep_type::const_iterator const_iterator;
+ typedef typename _Rep_type::reverse_iterator reverse_iterator;
+ typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+ typedef typename _Rep_type::size_type size_type;
+ typedef typename _Rep_type::difference_type difference_type;
+ typedef typename _Rep_type::allocator_type allocator_type;
+
+private:
+ _Rep_type _M_t; // red-black tree representing multimap
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+public:
+ // allocation/deallocation
+ multimap() : _M_t(_Compare(), allocator_type()) { }
+ explicit multimap(const _Compare& __comp,
+ const allocator_type& __a = allocator_type())
+ : _M_t(__comp, __a) { }
+
+#ifdef _STLP_MEMBER_TEMPLATES
+ template <class _InputIterator>
+ multimap(_InputIterator __first, _InputIterator __last)
+ : _M_t(_Compare(), allocator_type())
+ { _M_t.insert_equal(__first, __last); }
+# ifdef _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS
+ template <class _InputIterator>
+ multimap(_InputIterator __first, _InputIterator __last,
+ const _Compare& __comp)
+ : _M_t(__comp, allocator_type()) { _M_t.insert_equal(__first, __last); }
+# endif
+ template <class _InputIterator>
+ multimap(_InputIterator __first, _InputIterator __last,
+ const _Compare& __comp,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
+#else
+ multimap(const value_type* __first, const value_type* __last)
+ : _M_t(_Compare(), allocator_type())
+ { _M_t.insert_equal(__first, __last); }
+ multimap(const value_type* __first, const value_type* __last,
+ const _Compare& __comp,
+ const allocator_type& __a = allocator_type())
+ : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
+
+ multimap(const_iterator __first, const_iterator __last)
+ : _M_t(_Compare(), allocator_type())
+ { _M_t.insert_equal(__first, __last); }
+ multimap(const_iterator __first, const_iterator __last,
+ const _Compare& __comp,
+ const allocator_type& __a = allocator_type())
+ : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ multimap(const _Self& __x) : _M_t(__x._M_t) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ multimap(__move_source<_Self> src)
+ : _M_t(__move_source<_Rep_type>(src.get()._M_t)) {}
+#endif
+
+ _Self& operator=(const _Self& __x) {
+ _M_t = __x._M_t;
+ return *this;
+ }
+
+ // accessors:
+
+ key_compare key_comp() const { return _M_t.key_comp(); }
+ value_compare value_comp() const { return value_compare(_M_t.key_comp()); }
+ allocator_type get_allocator() const { return _M_t.get_allocator(); }
+
+ iterator begin() { return _M_t.begin(); }
+ const_iterator begin() const { return _M_t.begin(); }
+ iterator end() { return _M_t.end(); }
+ const_iterator end() const { return _M_t.end(); }
+ reverse_iterator rbegin() { return _M_t.rbegin(); }
+ const_reverse_iterator rbegin() const { return _M_t.rbegin(); }
+ reverse_iterator rend() { return _M_t.rend(); }
+ const_reverse_iterator rend() const { return _M_t.rend(); }
+ bool empty() const { return _M_t.empty(); }
+ size_type size() const { return _M_t.size(); }
+ size_type max_size() const { return _M_t.max_size(); }
+ void swap(_Self& __x) { _M_t.swap(__x._M_t); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+ // insert/erase
+ iterator insert(const value_type& __x) { return _M_t.insert_equal(__x); }
+ iterator insert(iterator __pos, const value_type& __x) { return _M_t.insert_equal(__pos, __x); }
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void insert(_InputIterator __first, _InputIterator __last)
+ { _M_t.insert_equal(__first, __last); }
+#else
+ void insert(const value_type* __first, const value_type* __last)
+ { _M_t.insert_equal(__first, __last); }
+ void insert(const_iterator __first, const_iterator __last)
+ { _M_t.insert_equal(__first, __last); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+ void erase(iterator __pos) { _M_t.erase(__pos); }
+ size_type erase(const key_type& __x) { return _M_t.erase(__x); }
+ void erase(iterator __first, iterator __last) { _M_t.erase(__first, __last); }
+ void clear() { _M_t.clear(); }
+
+ // multimap operations:
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __x) { return _M_t.find(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __x) const { return _M_t.find(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __x) const { return _M_t.count(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator lower_bound(const _KT& __x) { return _M_t.lower_bound(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator lower_bound(const _KT& __x) const { return _M_t.lower_bound(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator upper_bound(const _KT& __x) { return _M_t.upper_bound(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator upper_bound(const _KT& __x) const { return _M_t.upper_bound(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator,iterator> equal_range(const _KT& __x)
+ { return _M_t.equal_range(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator,const_iterator> equal_range(const _KT& __x) const
+ { return _M_t.equal_range(__x); }
+};
+
+#define _STLP_TEMPLATE_HEADER template <class _Key, class _Tp, class _Compare, class _Alloc>
+#define _STLP_TEMPLATE_CONTAINER map<_Key,_Tp,_Compare,_Alloc>
+#include <stl/_relops_cont.h>
+#undef _STLP_TEMPLATE_CONTAINER
+#define _STLP_TEMPLATE_CONTAINER multimap<_Key,_Tp,_Compare,_Alloc>
+#include <stl/_relops_cont.h>
+#undef _STLP_TEMPLATE_CONTAINER
+#undef _STLP_TEMPLATE_HEADER
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Key, class _Tp, class _Compare, class _Alloc>
+struct __move_traits<map<_Key,_Tp,_Compare,_Alloc> > :
+ _STLP_PRIV __move_traits_aux<typename map<_Key,_Tp,_Compare,_Alloc>::_Rep_type>
+{};
+
+template <class _Key, class _Tp, class _Compare, class _Alloc>
+struct __move_traits<multimap<_Key,_Tp,_Compare,_Alloc> > :
+ _STLP_PRIV __move_traits_aux<typename multimap<_Key,_Tp,_Compare,_Alloc>::_Rep_type>
+{};
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_MAP_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/stl/_mbstate_t.h b/sources/android/stlport/stlport/stl/_mbstate_t.h
new file mode 100644
index 0000000..53566a7
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_mbstate_t.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_MBSTATE_T
+#define _STLP_INTERNAL_MBSTATE_T
+
+#if (defined (__OpenBSD__) || defined (__FreeBSD__) || defined (__hpux)) && defined (__GNUC__) && !defined (_GLIBCPP_HAVE_MBSTATE_T)
+# define _STLP_CPP_MBSTATE_T /* mbstate_t defined in native <cwchar>, so not defined in C! */
+#endif
+
+#if defined (_STLP_NO_NATIVE_MBSTATE_T) || defined (_STLP_CPP_MBSTATE_T) && !defined (_MBSTATE_T)
+# define _STLP_USE_OWN_MBSTATE_T
+# define _MBSTATE_T
+#endif
+
+#if defined (_STLP_USE_OWN_MBSTATE_T)
+# if !defined (_STLP_CPP_MBSTATE_T) || !defined (__cplusplus) || !defined (_STLP_USE_NEW_C_HEADERS)
+# if !defined (ANDROID) /* mbstate_t conflicts with Android's definition */
+typedef int mbstate_t;
+# endif
+# endif
+
+# if !defined (_STLP_CPP_MBSTATE_T) && defined (__cplusplus) && defined (_STLP_USE_NAMESPACES)
+_STLP_BEGIN_NAMESPACE
+using ::mbstate_t;
+_STLP_END_NAMESPACE
+# endif
+
+#endif /* _STLP_USE_OWN_MBSTATE_T */
+
+#endif /* _STLP_INTERNAL_MBSTATE_T */
diff --git a/sources/android/stlport/stlport/stl/_messages_facets.h b/sources/android/stlport/stlport/stl/_messages_facets.h
new file mode 100644
index 0000000..aca5596
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_messages_facets.h
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+// WARNING: This is an internal header file, included by other C++
+// standard library headers. You should not attempt to use this header
+// file directly.
+
+
+#ifndef _STLP_INTERNAL_MESSAGES_H
+#define _STLP_INTERNAL_MESSAGES_H
+
+#ifndef _STLP_IOS_BASE_H
+# include <stl/_ios_base.h>
+#endif
+
+#ifndef _STLP_C_LOCALE_H
+# include <stl/c_locale.h>
+#endif
+
+#ifndef _STLP_INTERNAL_STRING_H
+# include <stl/_string.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+// messages facets
+
+class messages_base {
+ public:
+ typedef int catalog;
+};
+
+template <class _CharT> class messages {};
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+class _Messages;
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC messages<char> : public locale::facet, public messages_base {
+public:
+ typedef messages_base::catalog catalog;
+ typedef char char_type;
+ typedef string string_type;
+
+ explicit messages(size_t __refs = 0);
+
+ catalog open(const string& __fn, const locale& __loc) const
+ { return do_open(__fn, __loc); }
+ string_type get(catalog __c, int __set, int __msgid,
+ const string_type& __dfault) const
+ { return do_get(__c, __set, __msgid, __dfault); }
+ inline void close(catalog __c) const
+ { do_close(__c); }
+
+ static _STLP_STATIC_DECLSPEC locale::id id;
+
+protected:
+ ~messages() {}
+
+ virtual catalog do_open(const string& __fn, const locale& __loc) const
+ { return -1; }
+ virtual string_type do_get(catalog __c, int __set, int __msgid,
+ const string_type& __dfault) const
+ { return __dfault; }
+ virtual void do_close(catalog __c) const
+ {}
+};
+
+#if !defined (_STLP_NO_WCHAR_T)
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC messages<wchar_t> : public locale::facet, public messages_base {
+public:
+ typedef messages_base::catalog catalog;
+ typedef wchar_t char_type;
+ typedef wstring string_type;
+
+ explicit messages(size_t __refs = 0);
+
+ inline catalog open(const string& __fn, const locale& __loc) const
+ { return do_open(__fn, __loc); }
+ inline string_type get(catalog __c, int __set, int __msgid,
+ const string_type& __dfault) const
+ { return do_get(__c, __set, __msgid, __dfault); }
+ inline void close(catalog __c) const
+ { do_close(__c); }
+
+ static _STLP_STATIC_DECLSPEC locale::id id;
+
+protected:
+ ~messages() {}
+
+ virtual catalog do_open(const string& __fn, const locale& __loc) const
+ { return -1; }
+ virtual string_type do_get(catalog __c, int __set, int __msgid,
+ const string_type& __dfault) const
+ { return __dfault; }
+ virtual void do_close(catalog __c) const
+ {}
+};
+
+#endif
+
+template <class _CharT> class messages_byname {};
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC messages_byname<char> : public messages<char> {
+ friend class _Locale_impl;
+public:
+ typedef messages_base::catalog catalog;
+ typedef string string_type;
+
+ explicit messages_byname(const char* __name, size_t __refs = 0);
+
+protected:
+ ~messages_byname();
+
+ virtual catalog do_open(const string& __fn, const locale& __loc) const;
+ virtual string_type do_get(catalog __c, int __set, int __msgid,
+ const string_type& __dfault) const;
+ virtual void do_close(catalog __c) const;
+
+private:
+ messages_byname(_Locale_messages*);
+ typedef messages_byname<char> _Self;
+ //explicitely defined as private to avoid warnings:
+ messages_byname(_Self const&);
+ _Self& operator = (_Self const&);
+
+ _STLP_PRIV _Messages* _M_impl;
+};
+
+#if !defined (_STLP_NO_WCHAR_T)
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC messages_byname<wchar_t> : public messages<wchar_t> {
+ friend class _Locale_impl;
+public:
+ typedef messages_base::catalog catalog;
+ typedef wstring string_type;
+
+ explicit messages_byname(const char* __name, size_t __refs = 0);
+
+protected:
+ ~messages_byname();
+
+ virtual catalog do_open(const string& __fn, const locale& __loc) const;
+ virtual string_type do_get(catalog __c, int __set, int __msgid,
+ const string_type& __dfault) const;
+ virtual void do_close(catalog __c) const;
+
+private:
+ messages_byname(_Locale_messages*);
+ typedef messages_byname<wchar_t> _Self;
+ //explicitely defined as private to avoid warnings:
+ messages_byname(_Self const&);
+ _Self& operator = (_Self const&);
+
+ _STLP_PRIV _Messages* _M_impl;
+};
+#endif /* WCHAR_T */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_MESSAGES_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/stl/_monetary.c b/sources/android/stlport/stlport/stl/_monetary.c
new file mode 100644
index 0000000..3de937c
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_monetary.c
@@ -0,0 +1,527 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_MONETARY_C
+#define _STLP_MONETARY_C
+
+# ifndef _STLP_INTERNAL_MONETARY_H
+# include <stl/_monetary.h>
+# endif
+
+#ifndef _STLP_INTERNAL_IOS_H
+# include <stl/_ios.h>
+#endif
+
+#ifndef _STLP_INTERNAL_NUM_PUT_H
+# include <stl/_num_put.h>
+#endif
+
+#ifndef _STLP_INTERNAL_NUM_GET_H
+# include <stl/_num_get.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _CharT, class _InputIterator>
+locale::id money_get<_CharT, _InputIterator>::id;
+
+template <class _CharT, class _OutputIterator>
+locale::id money_put<_CharT, _OutputIterator>::id;
+
+// money_get facets
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// helper functions for do_get
+template <class _InIt1, class _InIt2>
+pair<_InIt1, bool> __get_string( _InIt1 __first, _InIt1 __last,
+ _InIt2 __str_first, _InIt2 __str_last) {
+ while ( __first != __last && __str_first != __str_last && *__first == *__str_first ) {
+ ++__first;
+ ++__str_first;
+ }
+ return make_pair(__first, __str_first == __str_last);
+}
+
+template <class _InIt, class _OuIt, class _CharT>
+bool
+__get_monetary_value(_InIt& __first, _InIt __last, _OuIt __out_ite,
+ const ctype<_CharT>& _c_type,
+ _CharT __point, int __frac_digits, _CharT __sep,
+ const string& __grouping, bool &__syntax_ok) {
+ if (__first == __last || !_c_type.is(ctype_base::digit, *__first))
+ return false;
+
+ char __group_sizes[128];
+ char* __group_sizes_end = __grouping.empty()? 0 : __group_sizes;
+ char __current_group_size = 0;
+
+ while (__first != __last) {
+ if (_c_type.is(ctype_base::digit, *__first)) {
+ ++__current_group_size;
+ *__out_ite++ = *__first++;
+ }
+ else if (__group_sizes_end) {
+ if (*__first == __sep) {
+ *__group_sizes_end++ = __current_group_size;
+ __current_group_size = 0;
+ ++__first;
+ }
+ else break;
+ }
+ else
+ break;
+ }
+
+ if (__grouping.empty())
+ __syntax_ok = true;
+ else {
+ if (__group_sizes_end != __group_sizes)
+ *__group_sizes_end++ = __current_group_size;
+
+ __syntax_ok = __valid_grouping(__group_sizes, __group_sizes_end,
+ __grouping.data(), __grouping.data()+ __grouping.size());
+
+ if (__first == __last || *__first != __point) {
+ for (int __digits = 0; __digits != __frac_digits; ++__digits)
+ *__out_ite++ = _CharT('0');
+ return true; // OK not to have decimal point
+ }
+ }
+
+ ++__first;
+
+ int __digits = 0;
+
+ while (__first != __last && _c_type.is(ctype_base::digit, *__first)) {
+ *__out_ite++ = *__first++;
+ ++__digits;
+ }
+
+ __syntax_ok = __syntax_ok && (__digits == __frac_digits);
+
+ return true;
+}
+
+
+template <class _CharT, class _InputIter, class _StrType>
+_InputIter __money_do_get(_InputIter __s, _InputIter __end, bool __intl,
+ ios_base& __str, ios_base::iostate& __err,
+ _StrType& __digits, bool &__is_positive, _CharT* /*__dummy*/) {
+ if (__s == __end) {
+ __err |= ios_base::eofbit;
+ return __s;
+ }
+
+ typedef _CharT char_type;
+ typedef _StrType string_type;
+ typedef _InputIter iter_type;
+ typedef moneypunct<char_type, false> _Punct;
+ typedef moneypunct<char_type, true> _Punct_intl;
+ typedef ctype<char_type> _Ctype;
+
+ locale __loc = __str.getloc();
+ const _Punct& __punct = use_facet<_Punct>(__loc) ;
+ const _Punct_intl& __punct_intl = use_facet<_Punct_intl>(__loc) ;
+ const _Ctype& __c_type = use_facet<_Ctype>(__loc) ;
+
+ money_base::pattern __format = __intl ? __punct_intl.neg_format()
+ : __punct.neg_format();
+ string_type __ns = __intl ? __punct_intl.negative_sign()
+ : __punct.negative_sign();
+ string_type __ps = __intl ? __punct_intl.positive_sign()
+ : __punct.positive_sign();
+ int __i;
+ bool __symbol_required = (__str.flags() & ios_base::showbase) != 0;
+ string_type __buf;
+ back_insert_iterator<string_type> __out_ite(__buf);
+
+ for (__i = 0; __i < 4; ++__i) {
+ switch (__format.field[__i]) {
+ case money_base::space:
+ if (!__c_type.is(ctype_base::space, *__s)) {
+ __err = ios_base::failbit;
+ return __s;
+ }
+ ++__s;
+ case money_base::none:
+ while (__s != __end && __c_type.is(ctype_base::space, *__s))
+ ++__s;
+ break;
+ case money_base::symbol: {
+ string_type __curs = __intl ? __punct_intl.curr_symbol()
+ : __punct.curr_symbol();
+ pair<iter_type, bool>
+ __result = __get_string(__s, __end, __curs.begin(), __curs.end());
+ if (!__result.second && __symbol_required)
+ __err = ios_base::failbit;
+ __s = __result.first;
+ break;
+ }
+ case money_base::sign: {
+ if (__s == __end) {
+ if (__ps.empty())
+ break;
+ if (__ns.empty()) {
+ __is_positive = false;
+ break;
+ }
+ __err = ios_base::failbit;
+ return __s;
+ }
+ else {
+ if (__ps.empty()) {
+ if (__ns.empty())
+ break;
+ if (*__s == __ns[0]) {
+ ++__s;
+ __is_positive = false;
+ }
+ break;
+ }
+ else {
+ if (*__s == __ps[0]) {
+ ++__s;
+ break;
+ }
+ if (__ns.empty())
+ break;
+ if (*__s == __ns[0]) {
+ ++__s;
+ __is_positive = false;
+ break;
+ }
+ __err = ios_base::failbit;
+ }
+ }
+ return __s;
+ }
+ case money_base::value: {
+ char_type __point = __intl ? __punct_intl.decimal_point()
+ : __punct.decimal_point();
+ int __frac_digits = __intl ? __punct_intl.frac_digits()
+ : __punct.frac_digits();
+ string __grouping = __intl ? __punct_intl.grouping()
+ : __punct.grouping();
+ bool __syntax_ok = true;
+
+ bool __result;
+
+ char_type __sep = __grouping.empty() ? char_type() :
+ __intl ? __punct_intl.thousands_sep() : __punct.thousands_sep();
+
+ __result = __get_monetary_value(__s, __end, __out_ite, __c_type,
+ __point, __frac_digits,
+ __sep,
+ __grouping, __syntax_ok);
+
+ if (!__syntax_ok)
+ __err |= ios_base::failbit;
+ if (!__result) {
+ __err = ios_base::failbit;
+ return __s;
+ }
+ break;
+
+ } // Close money_base::value case
+ } // Close switch statement
+ } // Close for loop
+
+ if (__is_positive) {
+ if (__ps.size() > 1) {
+ pair<_InputIter, bool>
+ __result = __get_string(__s, __end, __ps.begin() + 1, __ps.end());
+ __s = __result.first;
+ if (!__result.second)
+ __err |= ios::failbit;
+ }
+ if (!(__err & ios_base::failbit))
+ __digits = __buf;
+ }
+ else {
+ if (__ns.size() > 1) {
+ pair<_InputIter, bool>
+ __result = __get_string(__s, __end, __ns.begin() + 1, __ns.end());
+ __s = __result.first;
+ if (!__result.second)
+ __err |= ios::failbit;
+ }
+ if (!(__err & ios::failbit)) {
+ __digits = __c_type.widen('-');
+ __digits += __buf;
+ }
+ }
+ if (__s == __end)
+ __err |= ios::eofbit;
+
+ return __s;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+//===== methods ======
+template <class _CharT, class _InputIter>
+_InputIter
+money_get<_CharT, _InputIter>::do_get(_InputIter __s, _InputIter __end, bool __intl,
+ ios_base& __str, ios_base::iostate& __err,
+ _STLP_LONGEST_FLOAT_TYPE& __units) const {
+ string_type __buf;
+ bool __is_positive = true;
+ __s = _STLP_PRIV __money_do_get(__s, __end, __intl, __str, __err, __buf, __is_positive, (_CharT*)0);
+
+ if (__err == ios_base::goodbit || __err == ios_base::eofbit) {
+ typename string_type::iterator __b = __buf.begin(), __e = __buf.end();
+
+ if (!__is_positive) ++__b;
+ // Can't use atold, since it might be wchar_t. Don't get confused by name below :
+ // it's perfectly capable of reading long double.
+ _STLP_PRIV __get_decimal_integer(__b, __e, __units, (_CharT*)0);
+
+ if (!__is_positive) {
+ __units = -__units;
+ }
+ }
+
+ return __s;
+}
+
+template <class _CharT, class _InputIter>
+_InputIter
+money_get<_CharT, _InputIter>::do_get(iter_type __s, iter_type __end, bool __intl,
+ ios_base& __str, ios_base::iostate& __err,
+ string_type& __digits) const {
+ bool __is_positive = true;
+ return _STLP_PRIV __money_do_get(__s, __end, __intl, __str, __err, __digits, __is_positive, (_CharT*)0);
+}
+
+// money_put facets
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _CharT, class _OutputIter, class _Str_Type, class _Str>
+_OutputIter __money_do_put(_OutputIter __s, bool __intl, ios_base& __str,
+ _CharT __fill, const _Str& __digits, bool __check_digits,
+ _Str_Type * /*__dummy*/) {
+ typedef _CharT char_type;
+ typedef _Str_Type string_type;
+ typedef ctype<char_type> _Ctype;
+ typedef moneypunct<char_type, false> _Punct;
+ typedef moneypunct<char_type, true> _Punct_intl;
+
+ locale __loc = __str.getloc();
+ const _Ctype& __c_type = use_facet<_Ctype>(__loc) ;
+ const _Punct& __punct = use_facet<_Punct>(__loc) ;
+ const _Punct_intl& __punct_intl = use_facet<_Punct_intl>(__loc) ;
+
+ // some special characters
+ char_type __minus = __c_type.widen('-');
+ char_type __plus = __c_type.widen('+');
+ char_type __space = __c_type.widen(' ');
+ char_type __zero = __c_type.widen('0');
+ char_type __point = __intl ? __punct_intl.decimal_point()
+ : __punct.decimal_point();
+
+ char_type __sep = __intl ? __punct_intl.thousands_sep()
+ : __punct.thousands_sep();
+
+ string __grouping = __intl ? __punct_intl.grouping()
+ : __punct.grouping();
+
+ int __frac_digits = __intl ? __punct_intl.frac_digits()
+ : __punct.frac_digits();
+
+ string_type __curr_sym = __intl ? __punct_intl.curr_symbol()
+ : __punct.curr_symbol();
+
+ // if there are no digits we are going to return __s. If there
+ // are digits, but not enough to fill the frac_digits, we are
+ // going to add zeros. I don't know whether this is right or
+ // not.
+ if (__digits.empty())
+ return __s;
+
+ typename string_type::const_iterator __digits_first = __digits.begin();
+ typename string_type::const_iterator __digits_last = __digits.end();
+
+ bool __is_negative = *__digits_first == __minus;
+ if (__is_negative)
+ ++__digits_first;
+
+#if !defined (__BORLANDC__)
+ string_type __sign = __intl ? __is_negative ? __punct_intl.negative_sign()
+ : __punct_intl.positive_sign()
+ : __is_negative ? __punct.negative_sign()
+ : __punct.positive_sign();
+#else
+ string_type __sign;
+ if (__intl) {
+ if (__is_negative)
+ __sign = __punct_intl.negative_sign();
+ else
+ __sign = __punct_intl.positive_sign();
+ }
+ else {
+ if (__is_negative)
+ __sign = __punct.negative_sign();
+ else
+ __sign = __punct.positive_sign();
+ }
+#endif
+
+ if (__check_digits) {
+ typename string_type::const_iterator __cp = __digits_first;
+ while (__cp != __digits_last && __c_type.is(ctype_base::digit, *__cp))
+ ++__cp;
+ if (__cp == __digits_first)
+ return __s;
+ __digits_last = __cp;
+ }
+
+ // If grouping is required, we make a copy of __digits and
+ // insert the grouping.
+ _STLP_BASIC_IOSTRING(char_type) __new_digits;
+ if (!__grouping.empty()) {
+ __new_digits.assign(__digits_first, __digits_last);
+ __insert_grouping(__new_digits,
+ __new_digits.size() - __frac_digits,
+ __grouping,
+ __sep, __plus, __minus, 0);
+ __digits_first = __new_digits.begin(); // <<--
+ __digits_last = __new_digits.end(); // <<--
+ }
+
+ // Determine the amount of padding required, if any.
+ streamsize __width = __str.width();
+
+#if defined (_STLP_DEBUG) && (defined(__HP_aCC) && (__HP_aCC <= 1))
+ size_t __value_length = operator -(__digits_last, __digits_first);
+#else
+ size_t __value_length = __digits_last - __digits_first;
+#endif
+
+ size_t __length = __value_length + __sign.size();
+
+ if (__frac_digits != 0)
+ ++__length;
+
+ bool __generate_curr = (__str.flags() & ios_base::showbase) !=0;
+ if (__generate_curr)
+ __length += __curr_sym.size();
+ money_base::pattern __format = __intl ? (__is_negative ? __punct_intl.neg_format()
+ : __punct_intl.pos_format())
+ : (__is_negative ? __punct.neg_format()
+ : __punct.pos_format());
+ {
+ //For the moment the following is commented for decoding reason.
+ //No reason to add a space last if the money symbol do not have to be display
+ //if (__format.field[3] == (char) money_base::symbol && !__generate_curr) {
+ // if (__format.field[2] == (char) money_base::space) {
+ // __format.field[2] = (char) money_base::none;
+ // }
+ //}
+ //space can only be second or third and only once (22.2.6.3-1):
+ if ((__format.field[1] == (char) money_base::space) ||
+ (__format.field[2] == (char) money_base::space))
+ ++__length;
+ }
+
+ const bool __need_fill = (((sizeof(streamsize) > sizeof(size_t)) && (__STATIC_CAST(streamsize, __length) < __width)) ||
+ ((sizeof(streamsize) <= sizeof(size_t)) && (__length < __STATIC_CAST(size_t, __width))));
+ streamsize __fill_amt = __need_fill ? __width - __length : 0;
+
+ ios_base::fmtflags __fill_pos = __str.flags() & ios_base::adjustfield;
+
+ if (__fill_amt != 0 &&
+ !(__fill_pos & (ios_base::left | ios_base::internal)))
+ __s = _STLP_PRIV __fill_n(__s, __fill_amt, __fill);
+
+ for (int __i = 0; __i < 4; ++__i) {
+ char __ffield = __format.field[__i];
+ switch (__ffield) {
+ case money_base::space:
+ *__s++ = __space;
+ case money_base::none:
+ if (__fill_amt != 0 && __fill_pos == ios_base::internal)
+ __s = _STLP_PRIV __fill_n(__s, __fill_amt, __fill);
+ break;
+ case money_base::symbol:
+ if (__generate_curr)
+ __s = _STLP_STD::copy(__curr_sym.begin(), __curr_sym.end(), __s);
+ break;
+ case money_base::sign:
+ if (!__sign.empty())
+ *__s++ = __sign[0];
+ break;
+ case money_base::value:
+ if (__frac_digits == 0) {
+ __s = _STLP_STD::copy(__digits_first, __digits_last, __s);
+ } else {
+ if ((int)__value_length <= __frac_digits) {
+ // if we see '9' here, we should out 0.09
+ *__s++ = __zero; // integer part is zero
+ *__s++ = __point; // decimal point
+ __s = _STLP_PRIV __fill_n(__s, __frac_digits - __value_length, __zero); // zeros
+ __s = _STLP_STD::copy(__digits_first, __digits_last, __s); // digits
+ } else {
+ __s = _STLP_STD::copy(__digits_first, __digits_last - __frac_digits, __s);
+ if (__frac_digits != 0) {
+ *__s++ = __point;
+ __s = _STLP_STD::copy(__digits_last - __frac_digits, __digits_last, __s);
+ }
+ }
+ }
+ break;
+ } //Close for switch
+ } // Close for loop
+
+ // Ouput rest of sign if necessary.
+ if (__sign.size() > 1)
+ __s = _STLP_STD::copy(__sign.begin() + 1, __sign.end(), __s);
+ if (__fill_amt != 0 &&
+ !(__fill_pos & (ios_base::right | ios_base::internal)))
+ __s = _STLP_PRIV __fill_n(__s, __fill_amt, __fill);
+
+ return __s;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _CharT, class _OutputIter>
+_OutputIter
+money_put<_CharT, _OutputIter>
+ ::do_put(_OutputIter __s, bool __intl, ios_base& __str,
+ char_type __fill, _STLP_LONGEST_FLOAT_TYPE __units) const {
+ _STLP_BASIC_IOSTRING(char_type) __digits;
+ _STLP_PRIV __get_money_digits(__digits, __str, __units);
+ return _STLP_PRIV __money_do_put(__s, __intl, __str, __fill, __digits, false, __STATIC_CAST(string_type*, 0));
+}
+
+template <class _CharT, class _OutputIter>
+_OutputIter
+money_put<_CharT, _OutputIter>
+ ::do_put(_OutputIter __s, bool __intl, ios_base& __str,
+ char_type __fill, const string_type& __digits) const {
+ return _STLP_PRIV __money_do_put(__s, __intl, __str, __fill, __digits, true, __STATIC_CAST(string_type*, 0));
+}
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_MONETARY_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_monetary.h b/sources/android/stlport/stlport/stl/_monetary.h
new file mode 100644
index 0000000..7b93010
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_monetary.h
@@ -0,0 +1,435 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+// WARNING: This is an internal header file, included by other C++
+// standard library headers. You should not attempt to use this header
+// file directly.
+
+
+#ifndef _STLP_INTERNAL_MONETARY_H
+#define _STLP_INTERNAL_MONETARY_H
+
+#ifndef _STLP_INTERNAL_OSTREAMBUF_ITERATOR_H
+# include <stl/_ostreambuf_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ISTREAMBUF_ITERATOR_H
+# include <stl/_istreambuf_iterator.h>
+#endif
+
+#ifndef _STLP_FACETS_FWD_H
+# include <stl/_facets_fwd.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+class money_base {
+public:
+ enum part {none, space, symbol, sign, value};
+ struct pattern {
+ char field[4];
+ };
+};
+
+// moneypunct facets: forward declaration
+template <class _charT, _STLP_DFL_NON_TYPE_PARAM(bool, _International, false) > class moneypunct {};
+
+// money_get facets
+
+template <class _CharT, class _InputIter>
+class money_get : public locale::facet {
+public:
+ typedef _CharT char_type;
+ typedef _InputIter iter_type;
+ typedef basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> > string_type;
+
+ explicit money_get(size_t __refs = 0) : locale::facet(__refs) {}
+ iter_type get(iter_type __s, iter_type __end, bool __intl,
+ ios_base& __str, ios_base::iostate& __err,
+ _STLP_LONGEST_FLOAT_TYPE& __units) const
+ { return do_get(__s, __end, __intl, __str, __err, __units); }
+ iter_type get(iter_type __s, iter_type __end, bool __intl,
+ ios_base& __str, ios_base::iostate& __err,
+ string_type& __digits) const
+ { return do_get(__s, __end, __intl, __str, __err, __digits); }
+
+ static locale::id id;
+
+protected:
+ ~money_get() {}
+ virtual iter_type do_get(iter_type __s, iter_type __end, bool __intl,
+ ios_base& __str, ios_base::iostate& __err,
+ _STLP_LONGEST_FLOAT_TYPE& __units) const;
+ virtual iter_type do_get(iter_type __s, iter_type __end, bool __intl,
+ ios_base& __str, ios_base::iostate& __err,
+ string_type& __digits) const;
+};
+
+
+// moneypunct facets: definition of specializations
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC moneypunct<char, true> : public locale::facet, public money_base {
+public:
+ typedef char char_type;
+ typedef string string_type;
+ explicit moneypunct _STLP_PSPEC2(char, true) (size_t __refs = 0);
+
+ char decimal_point() const { return do_decimal_point(); }
+ char thousands_sep() const { return do_thousands_sep(); }
+ string grouping() const { return do_grouping(); }
+ string_type curr_symbol() const { return do_curr_symbol(); }
+ string_type positive_sign() const { return do_positive_sign(); }
+ string_type negative_sign() const { return do_negative_sign(); }
+ int frac_digits() const { return do_frac_digits(); }
+ pattern pos_format() const { return do_pos_format(); }
+ pattern neg_format() const { return do_neg_format(); }
+
+ static _STLP_STATIC_DECLSPEC locale::id id;
+ _STLP_STATIC_CONSTANT(bool, intl = true);
+
+protected:
+ pattern _M_pos_format;
+ pattern _M_neg_format;
+
+ ~moneypunct _STLP_PSPEC2(char, true) ();
+
+ virtual char do_decimal_point() const;
+ virtual char do_thousands_sep() const;
+ virtual string do_grouping() const;
+
+ virtual string do_curr_symbol() const;
+
+ virtual string do_positive_sign() const;
+ virtual string do_negative_sign() const;
+ virtual int do_frac_digits() const;
+ virtual pattern do_pos_format() const;
+ virtual pattern do_neg_format() const;
+};
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC moneypunct<char, false> : public locale::facet, public money_base {
+public:
+ typedef char char_type;
+ typedef string string_type;
+
+ explicit moneypunct _STLP_PSPEC2(char, false) (size_t __refs = 0);
+
+ char decimal_point() const { return do_decimal_point(); }
+ char thousands_sep() const { return do_thousands_sep(); }
+ string grouping() const { return do_grouping(); }
+ string_type curr_symbol() const { return do_curr_symbol(); }
+ string_type positive_sign() const { return do_positive_sign(); }
+ string_type negative_sign() const { return do_negative_sign(); }
+ int frac_digits() const { return do_frac_digits(); }
+ pattern pos_format() const { return do_pos_format(); }
+ pattern neg_format() const { return do_neg_format(); }
+
+ static _STLP_STATIC_DECLSPEC locale::id id;
+ _STLP_STATIC_CONSTANT(bool, intl = false);
+
+protected:
+ pattern _M_pos_format;
+ pattern _M_neg_format;
+
+ ~moneypunct _STLP_PSPEC2(char, false) ();
+
+ virtual char do_decimal_point() const;
+ virtual char do_thousands_sep() const;
+ virtual string do_grouping() const;
+
+ virtual string do_curr_symbol() const;
+
+ virtual string do_positive_sign() const;
+ virtual string do_negative_sign() const;
+ virtual int do_frac_digits() const;
+ virtual pattern do_pos_format() const;
+ virtual pattern do_neg_format() const;
+};
+
+
+#ifndef _STLP_NO_WCHAR_T
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC moneypunct<wchar_t, true> : public locale::facet, public money_base {
+public:
+ typedef wchar_t char_type;
+ typedef wstring string_type;
+ explicit moneypunct _STLP_PSPEC2(wchar_t, true) (size_t __refs = 0);
+ wchar_t decimal_point() const { return do_decimal_point(); }
+ wchar_t thousands_sep() const { return do_thousands_sep(); }
+ string grouping() const { return do_grouping(); }
+ string_type curr_symbol() const { return do_curr_symbol(); }
+ string_type positive_sign() const { return do_positive_sign(); }
+ string_type negative_sign() const { return do_negative_sign(); }
+ int frac_digits() const { return do_frac_digits(); }
+ pattern pos_format() const { return do_pos_format(); }
+ pattern neg_format() const { return do_neg_format(); }
+
+ static _STLP_STATIC_DECLSPEC locale::id id;
+ _STLP_STATIC_CONSTANT(bool, intl = true);
+
+protected:
+ pattern _M_pos_format;
+ pattern _M_neg_format;
+
+ ~moneypunct _STLP_PSPEC2(wchar_t, true) ();
+
+ virtual wchar_t do_decimal_point() const;
+ virtual wchar_t do_thousands_sep() const;
+ virtual string do_grouping() const;
+
+ virtual string_type do_curr_symbol() const;
+
+ virtual string_type do_positive_sign() const;
+ virtual string_type do_negative_sign() const;
+ virtual int do_frac_digits() const;
+ virtual pattern do_pos_format() const;
+ virtual pattern do_neg_format() const;
+};
+
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC moneypunct<wchar_t, false> : public locale::facet, public money_base {
+public:
+ typedef wchar_t char_type;
+ typedef wstring string_type;
+ explicit moneypunct _STLP_PSPEC2(wchar_t, false) (size_t __refs = 0);
+ wchar_t decimal_point() const { return do_decimal_point(); }
+ wchar_t thousands_sep() const { return do_thousands_sep(); }
+ string grouping() const { return do_grouping(); }
+ string_type curr_symbol() const { return do_curr_symbol(); }
+ string_type positive_sign() const { return do_positive_sign(); }
+ string_type negative_sign() const { return do_negative_sign(); }
+ int frac_digits() const { return do_frac_digits(); }
+ pattern pos_format() const { return do_pos_format(); }
+ pattern neg_format() const { return do_neg_format(); }
+
+ static _STLP_STATIC_DECLSPEC locale::id id;
+ _STLP_STATIC_CONSTANT(bool, intl = false);
+
+protected:
+ pattern _M_pos_format;
+ pattern _M_neg_format;
+
+ ~moneypunct _STLP_PSPEC2(wchar_t, false) ();
+
+ virtual wchar_t do_decimal_point() const;
+ virtual wchar_t do_thousands_sep() const;
+ virtual string do_grouping() const;
+
+ virtual string_type do_curr_symbol() const;
+
+ virtual string_type do_positive_sign() const;
+ virtual string_type do_negative_sign() const;
+ virtual int do_frac_digits() const;
+ virtual pattern do_pos_format() const;
+ virtual pattern do_neg_format() const;
+};
+
+# endif
+
+template <class _charT, _STLP_DFL_NON_TYPE_PARAM(bool , _International , false) > class moneypunct_byname {};
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC moneypunct_byname<char, true> : public moneypunct<char, true> {
+ friend class _Locale_impl;
+public:
+ typedef money_base::pattern pattern;
+ typedef char char_type;
+ typedef string string_type;
+
+ explicit moneypunct_byname _STLP_PSPEC2(char, true) (const char * __name, size_t __refs = 0);
+
+protected:
+ ~moneypunct_byname _STLP_PSPEC2(char, true) ();
+ virtual char do_decimal_point() const;
+ virtual char do_thousands_sep() const;
+ virtual string do_grouping() const;
+
+ virtual string_type do_curr_symbol() const;
+
+ virtual string_type do_positive_sign() const;
+ virtual string_type do_negative_sign() const;
+ virtual int do_frac_digits() const;
+
+private:
+ moneypunct_byname _STLP_PSPEC2(char, true) (_Locale_monetary *__monetary);
+
+ typedef moneypunct_byname<char, true> _Self;
+ //explicitely defined as private to avoid warnings:
+ moneypunct_byname(_Self const&);
+ _Self& operator = (_Self const&);
+
+ _Locale_monetary* _M_monetary;
+};
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC moneypunct_byname<char, false> : public moneypunct<char, false> {
+ friend class _Locale_impl;
+public:
+ typedef money_base::pattern pattern;
+ typedef char char_type;
+ typedef string string_type;
+
+ explicit moneypunct_byname _STLP_PSPEC2(char, false) (const char * __name, size_t __refs = 0);
+
+protected:
+ ~moneypunct_byname _STLP_PSPEC2(char, false) ();
+ virtual char do_decimal_point() const;
+ virtual char do_thousands_sep() const;
+ virtual string do_grouping() const;
+
+ virtual string_type do_curr_symbol() const;
+
+ virtual string_type do_positive_sign() const;
+ virtual string_type do_negative_sign() const;
+ virtual int do_frac_digits() const;
+
+private:
+ moneypunct_byname _STLP_PSPEC2(char, false) (_Locale_monetary *__monetary);
+
+ typedef moneypunct_byname<char, false> _Self;
+ //explicitely defined as private to avoid warnings:
+ moneypunct_byname(_Self const&);
+ _Self& operator = (_Self const&);
+
+ _Locale_monetary* _M_monetary;
+};
+
+#if !defined (_STLP_NO_WCHAR_T)
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC moneypunct_byname<wchar_t, true> : public moneypunct<wchar_t, true> {
+ friend class _Locale_impl;
+public:
+ typedef money_base::pattern pattern;
+ typedef wchar_t char_type;
+ typedef wstring string_type;
+
+ explicit moneypunct_byname _STLP_PSPEC2(wchar_t, true) (const char * __name, size_t __refs = 0);
+
+protected:
+ ~moneypunct_byname _STLP_PSPEC2(wchar_t, true) ();
+ virtual wchar_t do_decimal_point() const;
+ virtual wchar_t do_thousands_sep() const;
+ virtual string do_grouping() const;
+
+ virtual string_type do_curr_symbol() const;
+
+ virtual string_type do_positive_sign() const;
+ virtual string_type do_negative_sign() const;
+ virtual int do_frac_digits() const;
+
+private:
+ moneypunct_byname _STLP_PSPEC2(wchar_t, true) (_Locale_monetary *__monetary);
+
+ typedef moneypunct_byname<wchar_t, true> _Self;
+ //explicitely defined as private to avoid warnings:
+ moneypunct_byname(_Self const&);
+ _Self& operator = (_Self const&);
+
+ _Locale_monetary* _M_monetary;
+};
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC moneypunct_byname<wchar_t, false> : public moneypunct<wchar_t, false> {
+ friend class _Locale_impl;
+public:
+ typedef money_base::pattern pattern;
+ typedef wchar_t char_type;
+ typedef wstring string_type;
+
+ explicit moneypunct_byname _STLP_PSPEC2(wchar_t, false) (const char * __name, size_t __refs = 0);
+
+protected:
+ ~moneypunct_byname _STLP_PSPEC2(wchar_t, false) ();
+ virtual wchar_t do_decimal_point() const;
+ virtual wchar_t do_thousands_sep() const;
+ virtual string do_grouping() const;
+
+ virtual string_type do_curr_symbol() const;
+
+ virtual string_type do_positive_sign() const;
+ virtual string_type do_negative_sign() const;
+ virtual int do_frac_digits() const;
+
+private:
+ moneypunct_byname _STLP_PSPEC2(wchar_t, false) (_Locale_monetary *__monetary);
+
+ typedef moneypunct_byname<wchar_t, false> _Self;
+ //explicitely defined as private to avoid warnings:
+ moneypunct_byname(_Self const&);
+ _Self& operator = (_Self const&);
+
+ _Locale_monetary* _M_monetary;
+};
+#endif
+
+//===== methods ======
+
+
+// money_put facets
+
+template <class _CharT, class _OutputIter>
+class money_put : public locale::facet {
+public:
+ typedef _CharT char_type;
+ typedef _OutputIter iter_type;
+ typedef basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> > string_type;
+
+ explicit money_put(size_t __refs = 0) : locale::facet(__refs) {}
+ iter_type put(iter_type __s, bool __intl, ios_base& __str,
+ char_type __fill, _STLP_LONGEST_FLOAT_TYPE __units) const
+ { return do_put(__s, __intl, __str, __fill, __units); }
+ iter_type put(iter_type __s, bool __intl, ios_base& __str,
+ char_type __fill,
+ const string_type& __digits) const
+ { return do_put(__s, __intl, __str, __fill, __digits); }
+
+ static locale::id id;
+
+protected:
+ ~money_put() {}
+ virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __str,
+ char_type __fill, _STLP_LONGEST_FLOAT_TYPE __units) const;
+ virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __str,
+ char_type __fill,
+ const string_type& __digits) const;
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS money_get<char, istreambuf_iterator<char, char_traits<char> > >;
+_STLP_EXPORT_TEMPLATE_CLASS money_put<char, ostreambuf_iterator<char, char_traits<char> > >;
+# if ! defined (_STLP_NO_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS money_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
+_STLP_EXPORT_TEMPLATE_CLASS money_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
+# endif
+#endif
+
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_monetary.c>
+#endif
+
+#endif /* _STLP_INTERNAL_MONETARY_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
+
diff --git a/sources/android/stlport/stlport/stl/_move_construct_fwk.h b/sources/android/stlport/stlport/stl/_move_construct_fwk.h
new file mode 100644
index 0000000..4a85fe3
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_move_construct_fwk.h
@@ -0,0 +1,159 @@
+/*
+ *
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_MOVE_CONSTRUCT_FWK_H
+#define _STLP_MOVE_CONSTRUCT_FWK_H
+
+#ifndef _STLP_TYPE_TRAITS_H
+# include <stl/type_traits.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+/*************************************************************
+ * Move constructor framework
+ *************************************************************/
+
+/*************************************************************
+ *Partial move:
+ *The source HAS to be a valid instance after the move!
+ *************************************************************/
+template <class _Tp>
+class __move_source {
+public:
+ explicit __move_source (_Tp &_src) : _M_data(_src)
+ {}
+
+ _Tp& get() const
+ { return _M_data; }
+private:
+ _Tp &_M_data;
+
+ //We explicitely forbid assignment to avoid warning:
+ typedef __move_source<_Tp> _Self;
+ _Self& operator = (_Self const&);
+};
+
+//Class used to signal move constructor support, implementation and type.
+template <class _Tp>
+struct __move_traits {
+ /*
+ * implemented tells if a the special move constructor has to be called or the classic
+ * copy constructor is just fine. Most of the time the copy constructor is fine only
+ * if the following info is true.
+ */
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && \
+ !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && \
+ !defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef typename _IsSTLportClass<_Tp>::_Ret implemented;
+#else
+ typedef __false_type implemented;
+#endif
+ /*
+ * complete tells if the move is complete or partial, that is to say, does the source
+ * needs to be destroyed once it has been moved.
+ */
+# if defined (__BORLANDC__) && (__BORLANDC__ >= 0x564)
+ typedef __type_traits<_Tp>::has_trivial_destructor _TpMoveComplete;
+ typedef typename __bool2type<__type2bool<_TpMoveComplete>::_Ret>::_Ret complete;
+# else
+ typedef typename __type_traits<_Tp>::has_trivial_destructor complete;
+# endif
+};
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+/*
+ * This struct should never be used if the user has not explicitely stipulated
+ * that its class support the full move concept. To check that the return type
+ * in such a case will be __invalid_source<_Tp> to generate a compile error
+ * revealing the configuration problem.
+ */
+template <class _Tp>
+struct _MoveSourceTraits {
+ typedef typename __move_traits<_Tp>::implemented _MvImpRet;
+#if defined (__BORLANDC__)
+ typedef typename __selectT<_MvImpRet,
+#else
+ enum {_MvImp = __type2bool<_MvImpRet>::_Ret};
+ typedef typename __select<_MvImp,
+#endif
+ __move_source<_Tp>,
+ _Tp const&>::_Ret _Type;
+};
+
+//The helper function
+template <class _Tp>
+inline _STLP_TYPENAME_ON_RETURN_TYPE _MoveSourceTraits<_Tp>::_Type
+_AsMoveSource (_Tp &src) {
+ typedef typename _MoveSourceTraits<_Tp>::_Type _SrcType;
+ return _SrcType(src);
+}
+
+//Helper structs used for many class.
+template <class _Tp>
+struct __move_traits_aux {
+ typedef typename __move_traits<_Tp>::implemented implemented;
+ typedef typename __move_traits<_Tp>::complete complete;
+};
+
+template <class _Tp1, class _Tp2>
+struct __move_traits_aux2 {
+ typedef __move_traits<_Tp1> _MoveTraits1;
+ typedef __move_traits<_Tp2> _MoveTraits2;
+
+ typedef typename _Lor2<typename _MoveTraits1::implemented,
+ typename _MoveTraits2::implemented>::_Ret implemented;
+ typedef typename _Land2<typename _MoveTraits1::complete,
+ typename _MoveTraits2::complete>::_Ret complete;
+};
+
+/*
+ * Most of the time a class implement a move constructor but its use depends
+ * on a third party, this is what the following struct are for.
+ */
+template <class _Tp>
+struct __move_traits_help {
+ typedef __true_type implemented;
+ typedef typename __move_traits<_Tp>::complete complete;
+};
+
+template <class _Tp1, class _Tp2>
+struct __move_traits_help1 {
+ typedef __move_traits<_Tp1> _MoveTraits1;
+ typedef __move_traits<_Tp2> _MoveTraits2;
+
+ typedef typename _Lor2<typename _MoveTraits1::implemented,
+ typename _MoveTraits2::implemented>::_Ret implemented;
+ typedef typename _Land2<typename _MoveTraits1::complete,
+ typename _MoveTraits2::complete>::_Ret complete;
+};
+
+template <class _Tp1, class _Tp2>
+struct __move_traits_help2 {
+ typedef __move_traits<_Tp1> _MoveTraits1;
+ typedef __move_traits<_Tp2> _MoveTraits2;
+
+ typedef __true_type implemented;
+ typedef typename _Land2<typename _MoveTraits1::complete,
+ typename _MoveTraits2::complete>::_Ret complete;
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_MOVE_CONSTRUCT_FWK_H */
diff --git a/sources/android/stlport/stlport/stl/_new.h b/sources/android/stlport/stlport/stl/_new.h
new file mode 100644
index 0000000..94094cf
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_new.h
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_NEW
+#define _STLP_INTERNAL_NEW
+
+#ifndef _STLP_INTERNAL_CSTDDEF
+// size_t
+# include <stl/_cstddef.h>
+#endif
+
+#if defined (__BORLANDC__) && (__BORLANDC__ < 0x570)
+// new.h uses ::malloc ;(
+# include _STLP_NATIVE_CPP_C_HEADER(cstdlib)
+using _STLP_VENDOR_CSTD::malloc;
+#endif
+
+#if !defined (_STLP_NO_NEW_NEW_HEADER)
+// eMbedded Visual C++ .NET unfortunately uses _INC_NEW for both <new.h> and <new>
+// we undefine the symbol to get the stuff in the SDK's <new>
+# if defined (_STLP_WCE_NET) && defined (_INC_NEW)
+# undef _INC_NEW
+# endif
+
+# if defined (new)
+/* STLport cannot replace native Std library new header if new is a macro,
+ * please define new macro after <new> header inclusion.
+ */
+# error Cannot include native new header as new is a macro.
+# endif
+
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <new>
+# else
+# include _STLP_NATIVE_CPP_RUNTIME_HEADER(new)
+# endif
+#else
+# include <new.h>
+#endif
+
+#if defined (_STLP_NO_BAD_ALLOC) && !defined (_STLP_NEW_DONT_THROW_BAD_ALLOC)
+# define _STLP_NEW_DONT_THROW_BAD_ALLOC 1
+#endif
+
+#if defined (_STLP_USE_EXCEPTIONS) && defined (_STLP_NEW_DONT_THROW_BAD_ALLOC)
+
+# ifndef _STLP_INTERNAL_EXCEPTION
+# include <stl/_exception.h>
+# endif
+
+_STLP_BEGIN_NAMESPACE
+
+# if defined (_STLP_NO_BAD_ALLOC)
+struct nothrow_t {};
+# define nothrow nothrow_t()
+# endif
+
+/*
+ * STLport own bad_alloc exception to be used if the native C++ library
+ * do not define it or when the new operator do not throw it to avoid
+ * a useless library dependency.
+ */
+class bad_alloc : public exception {
+public:
+ bad_alloc () _STLP_NOTHROW_INHERENTLY { }
+ bad_alloc(const bad_alloc&) _STLP_NOTHROW_INHERENTLY { }
+ bad_alloc& operator=(const bad_alloc&) _STLP_NOTHROW_INHERENTLY {return *this;}
+ ~bad_alloc () _STLP_NOTHROW_INHERENTLY { }
+ const char* what() const _STLP_NOTHROW_INHERENTLY { return "bad alloc"; }
+};
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_USE_EXCEPTIONS && (_STLP_NO_BAD_ALLOC || _STLP_NEW_DONT_THROW_BAD_ALLOC) */
+
+#if defined (_STLP_USE_OWN_NAMESPACE)
+
+_STLP_BEGIN_NAMESPACE
+
+# if !defined (_STLP_NEW_DONT_THROW_BAD_ALLOC)
+using _STLP_VENDOR_EXCEPT_STD::bad_alloc;
+# endif
+
+# if !defined (_STLP_NO_BAD_ALLOC)
+using _STLP_VENDOR_EXCEPT_STD::nothrow_t;
+using _STLP_VENDOR_EXCEPT_STD::nothrow;
+# if defined (_STLP_GLOBAL_NEW_HANDLER)
+using ::new_handler;
+using ::set_new_handler;
+# else
+using _STLP_VENDOR_EXCEPT_STD::new_handler;
+using _STLP_VENDOR_EXCEPT_STD::set_new_handler;
+# endif
+# endif /* !_STLP_NO_BAD_ALLOC */
+
+_STLP_END_NAMESPACE
+#endif /* _STLP_USE_OWN_NAMESPACE */
+
+#ifndef _STLP_THROW_BAD_ALLOC
+# if !defined (_STLP_USE_EXCEPTIONS)
+# ifndef _STLP_INTERNAL_CSTDIO
+# include <stl/_cstdio.h>
+# endif
+# define _STLP_THROW_BAD_ALLOC puts("out of memory\n"); exit(1)
+# else
+# define _STLP_THROW_BAD_ALLOC _STLP_THROW(_STLP_STD::bad_alloc())
+# endif
+#endif
+
+#if defined (_STLP_NO_NEW_NEW_HEADER) || defined (_STLP_NEW_DONT_THROW_BAD_ALLOC)
+# define _STLP_CHECK_NULL_ALLOC(__x) void* __y = __x; if (__y == 0) { _STLP_THROW_BAD_ALLOC; } return __y
+#else
+# define _STLP_CHECK_NULL_ALLOC(__x) return __x
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if ((defined (__IBMCPP__) || defined (__OS400__) || defined (__xlC__) || defined (qTidyHeap)) && defined (_STLP_DEBUG_ALLOC))
+inline void* _STLP_CALL __stl_new(size_t __n) { _STLP_CHECK_NULL_ALLOC(::operator new(__n, __FILE__, __LINE__)); }
+inline void _STLP_CALL __stl_delete(void* __p) { ::operator delete(__p, __FILE__, __LINE__); }
+#else
+inline void* _STLP_CALL __stl_new(size_t __n) { _STLP_CHECK_NULL_ALLOC(::operator new(__n)); }
+inline void _STLP_CALL __stl_delete(void* __p) { ::operator delete(__p); }
+#endif
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_NEW */
+
+/*
+ * Local Variables:
+ * mode:C++
+ * End:
+ */
diff --git a/sources/android/stlport/stlport/stl/_num_get.c b/sources/android/stlport/stlport/stl/_num_get.c
new file mode 100644
index 0000000..1e7d234
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_num_get.c
@@ -0,0 +1,623 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_NUM_GET_C
+#define _STLP_NUM_GET_C
+
+#ifndef _STLP_INTERNAL_NUM_GET_H
+# include <stl/_num_get.h>
+#endif
+
+#ifndef _STLP_INTERNAL_LIMITS
+# include <stl/_limits.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+_STLP_DECLSPEC unsigned char _STLP_CALL __digit_val_table(unsigned);
+_STLP_DECLSPEC const char* _STLP_CALL __narrow_atoms();
+
+// __do_get_integer, __do_get_float and its helper functions.
+
+inline bool _STLP_CALL __get_fdigit(char __c, const char*)
+{ return __c >= '0' && __c <= '9'; }
+
+inline bool _STLP_CALL __get_fdigit_or_sep(char& __c, char __sep, const char *__digits) {
+ if (__c == __sep) {
+ __c = ',' ;
+ return true ;
+ }
+ else
+ return __get_fdigit(__c, __digits);
+}
+
+inline int _STLP_CALL
+__get_digit_from_table(unsigned __index)
+{ return (__index > 127 ? 0xFF : __digit_val_table(__index)); }
+
+template <class _InputIter, class _CharT>
+int
+__get_base_or_zero(_InputIter& __in_ite, _InputIter& __end,
+ ios_base::fmtflags __flags, const ctype<_CharT>& __c_type) {
+ _CharT __atoms[5];
+ __c_type.widen(__narrow_atoms(), __narrow_atoms() + 5, __atoms);
+
+ bool __negative = false;
+ _CharT __c = *__in_ite;
+
+ if (__c == __atoms[1] /* __xminus_char */ ) {
+ __negative = true;
+ ++__in_ite;
+ }
+ else if (__c == __atoms[0] /* __xplus_char */ )
+ ++__in_ite;
+
+ int __base;
+ int __valid_zero = 0;
+
+ ios_base::fmtflags __basefield = __flags & ios_base::basefield;
+
+ switch (__basefield) {
+ case ios_base::oct:
+ __base = 8;
+ break;
+ case ios_base::dec:
+ __base = 10;
+ break;
+ case ios_base::hex:
+ __base = 16;
+ if (__in_ite != __end && *__in_ite == __atoms[2] /* __zero_char */ ) {
+ ++__in_ite;
+ if (__in_ite != __end &&
+ (*__in_ite == __atoms[3] /* __x_char */ || *__in_ite == __atoms[4] /* __X_char */ ))
+ ++__in_ite;
+ else
+ __valid_zero = 1; // That zero is valid by itself.
+ }
+ break;
+ default:
+ if (__in_ite != __end && *__in_ite == __atoms[2] /* __zero_char */ ) {
+ ++__in_ite;
+ if (__in_ite != __end &&
+ (*__in_ite == __atoms[3] /* __x_char */ || *__in_ite == __atoms[4] /* __X_char */ )) {
+ ++__in_ite;
+ __base = 16;
+ }
+ else
+ {
+ __base = 8;
+ __valid_zero = 1; // That zero is still valid by itself.
+ }
+ }
+ else
+ __base = 10;
+ break;
+ }
+ return (__base << 2) | ((int)__negative << 1) | __valid_zero;
+}
+
+
+template <class _InputIter, class _Integer, class _CharT>
+bool _STLP_CALL
+__get_integer(_InputIter& __first, _InputIter& __last,
+ int __base, _Integer& __val,
+ int __got, bool __is_negative, _CharT __separator, const string& __grouping, const __true_type& /*_IsSigned*/) {
+ bool __ovflow = false;
+ _Integer __result = 0;
+ bool __is_group = !__grouping.empty();
+ char __group_sizes[64];
+ char __current_group_size = 0;
+ char* __group_sizes_end = __group_sizes;
+
+ _Integer __over_base = (numeric_limits<_Integer>::min)() / __STATIC_CAST(_Integer, __base);
+
+ for ( ; __first != __last ; ++__first) {
+
+ const _CharT __c = *__first;
+
+ if (__is_group && __c == __separator) {
+ *__group_sizes_end++ = __current_group_size;
+ __current_group_size = 0;
+ continue;
+ }
+
+ int __n = __get_digit_from_table(__c);
+
+ if (__n >= __base)
+ break;
+
+ ++__got;
+ ++__current_group_size;
+
+ if (__result < __over_base)
+ __ovflow = true; // don't need to keep accumulating
+ else {
+ _Integer __next = __STATIC_CAST(_Integer, __base * __result - __n);
+ if (__result != 0)
+ __ovflow = __ovflow || __next >= __result;
+ __result = __next;
+ }
+ }
+
+ if (__is_group && __group_sizes_end != __group_sizes) {
+ *__group_sizes_end++ = __current_group_size;
+ }
+
+ // fbp : added to not modify value if nothing was read
+ if (__got > 0) {
+ __val = __ovflow ? __is_negative ? (numeric_limits<_Integer>::min)()
+ : (numeric_limits<_Integer>::max)()
+ : __is_negative ? __result
+ : __STATIC_CAST(_Integer, -__result);
+ }
+ // overflow is being treated as failure
+ return ((__got > 0) && !__ovflow) &&
+ (__is_group == 0 ||
+ __valid_grouping(__group_sizes, __group_sizes_end,
+ __grouping.data(), __grouping.data()+ __grouping.size()));
+}
+
+template <class _InputIter, class _Integer, class _CharT>
+bool _STLP_CALL
+__get_integer(_InputIter& __first, _InputIter& __last,
+ int __base, _Integer& __val,
+ int __got, bool __is_negative, _CharT __separator, const string& __grouping, const __false_type& /*_IsSigned*/) {
+ bool __ovflow = false;
+ _Integer __result = 0;
+ bool __is_group = !__grouping.empty();
+ char __group_sizes[64];
+ char __current_group_size = 0;
+ char* __group_sizes_end = __group_sizes;
+
+ _Integer __over_base = (numeric_limits<_Integer>::max)() / __STATIC_CAST(_Integer, __base);
+
+ for ( ; __first != __last ; ++__first) {
+
+ const _CharT __c = *__first;
+
+ if (__is_group && __c == __separator) {
+ *__group_sizes_end++ = __current_group_size;
+ __current_group_size = 0;
+ continue;
+ }
+
+ int __n = __get_digit_from_table(__c);
+
+ if (__n >= __base)
+ break;
+
+ ++__got;
+ ++__current_group_size;
+
+ if (__result > __over_base)
+ __ovflow = true; //don't need to keep accumulating
+ else {
+ _Integer __next = __STATIC_CAST(_Integer, __base * __result + __n);
+ if (__result != 0)
+ __ovflow = __ovflow || __next <= __result;
+ __result = __next;
+ }
+ }
+
+ if (__is_group && __group_sizes_end != __group_sizes) {
+ *__group_sizes_end++ = __current_group_size;
+ }
+
+ // fbp : added to not modify value if nothing was read
+ if (__got > 0) {
+ __val = __ovflow ? (numeric_limits<_Integer>::max)()
+ : (__is_negative ? __STATIC_CAST(_Integer, -__result)
+ : __result);
+ }
+
+ // overflow is being treated as failure
+ return ((__got > 0) && !__ovflow) &&
+ (__is_group == 0 ||
+ __valid_grouping(__group_sizes, __group_sizes_end,
+ __grouping.data(), __grouping.data()+ __grouping.size()));
+}
+
+
+template <class _InputIter, class _Integer, class _CharT>
+bool _STLP_CALL
+__get_decimal_integer(_InputIter& __first, _InputIter& __last, _Integer& __val, _CharT* /*dummy*/) {
+ string __grp;
+ //Here there is no grouping so separator is not important, we just pass the default character.
+ return __get_integer(__first, __last, 10, __val, 0, false, _CharT() /*separator*/, __grp, __false_type());
+}
+
+template <class _InputIter, class _Integer, class _CharT>
+_InputIter _STLP_CALL
+__do_get_integer(_InputIter& __in_ite, _InputIter& __end, ios_base& __str,
+ ios_base::iostate& __err, _Integer& __val, _CharT* /*__pc*/) {
+ locale __loc = __str.getloc();
+ const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+#if defined (__HP_aCC) && (__HP_aCC == 1)
+ bool _IsSigned = !((_Integer)(-1) > 0);
+#else
+ typedef typename __bool2type<numeric_limits<_Integer>::is_signed>::_Ret _IsSigned;
+#endif
+
+ const int __base_or_zero = __get_base_or_zero(__in_ite, __end, __str.flags(), __ctype);
+ int __got = __base_or_zero & 1;
+
+ bool __result;
+
+ if (__in_ite == __end) { // We may have already read a 0. If so,
+
+ if (__got > 0) { // the result is 0 even if we're at eof.
+ __val = 0;
+ __result = true;
+ }
+ else
+ __result = false;
+ }
+ else {
+ const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
+ const bool __negative = (__base_or_zero & 2) != 0;
+ const int __base = __base_or_zero >> 2;
+
+#if defined (__HP_aCC) && (__HP_aCC == 1)
+ if (_IsSigned)
+ __result = __get_integer(__in_ite, __end, __base, __val, __got, __negative, __np.thousands_sep(), __np.grouping(), __true_type() );
+ else
+ __result = __get_integer(__in_ite, __end, __base, __val, __got, __negative, __np.thousands_sep(), __np.grouping(), __false_type() );
+#else
+ __result = __get_integer(__in_ite, __end, __base, __val, __got, __negative, __np.thousands_sep(), __np.grouping(), _IsSigned());
+# endif
+ }
+
+ __err = __STATIC_CAST(ios_base::iostate, __result ? ios_base::goodbit : ios_base::failbit);
+
+ if (__in_ite == __end)
+ __err |= ios_base::eofbit;
+ return __in_ite;
+}
+
+// __read_float and its helper functions.
+template <class _InputIter, class _CharT>
+_InputIter _STLP_CALL
+__copy_sign(_InputIter __first, _InputIter __last, __iostring& __v,
+ _CharT __xplus, _CharT __xminus) {
+ if (__first != __last) {
+ _CharT __c = *__first;
+ if (__c == __xplus)
+ ++__first;
+ else if (__c == __xminus) {
+ __v.push_back('-');
+ ++__first;
+ }
+ }
+ return __first;
+}
+
+
+template <class _InputIter, class _CharT>
+bool _STLP_CALL
+__copy_digits(_InputIter& __first, _InputIter __last,
+ __iostring& __v, const _CharT* __digits) {
+ bool __ok = false;
+
+ for ( ; __first != __last; ++__first) {
+ _CharT __c = *__first;
+ if (__get_fdigit(__c, __digits)) {
+ __v.push_back((char)__c);
+ __ok = true;
+ }
+ else
+ break;
+ }
+ return __ok;
+}
+
+template <class _InputIter, class _CharT>
+bool _STLP_CALL
+__copy_grouped_digits(_InputIter& __first, _InputIter __last,
+ __iostring& __v, const _CharT * __digits,
+ _CharT __sep, const string& __grouping,
+ bool& __grouping_ok) {
+ bool __ok = false;
+ char __group_sizes[64];
+ char*__group_sizes_end = __group_sizes;
+ char __current_group_size = 0;
+
+ for ( ; __first != __last; ++__first) {
+ _CharT __c = *__first;
+ bool __tmp = __get_fdigit_or_sep(__c, __sep, __digits);
+ if (__tmp) {
+ if (__c == ',') {
+ *__group_sizes_end++ = __current_group_size;
+ __current_group_size = 0;
+ }
+ else {
+ __ok = true;
+ __v.push_back((char)__c);
+ ++__current_group_size;
+ }
+ }
+ else
+ break;
+ }
+
+ if (__group_sizes_end != __group_sizes)
+ *__group_sizes_end++ = __current_group_size;
+ __grouping_ok = __valid_grouping(__group_sizes, __group_sizes_end, __grouping.data(), __grouping.data() + __grouping.size());
+ return __ok;
+}
+
+
+template <class _InputIter, class _CharT>
+bool _STLP_CALL
+__read_float(__iostring& __buf, _InputIter& __in_ite, _InputIter& __end,
+ const ctype<_CharT> &__ct, const numpunct<_CharT> &__numpunct) {
+ // Create a string, copying characters of the form
+ // [+-]? [0-9]* .? [0-9]* ([eE] [+-]? [0-9]+)?
+
+ string __grouping = __numpunct.grouping();
+ bool __digits_before_dot /* = false */;
+ bool __digits_after_dot = false;
+ bool __ok;
+
+ bool __grouping_ok = true;
+
+ _CharT __dot = __numpunct.decimal_point();
+ _CharT __sep = __numpunct.thousands_sep();
+
+ _CharT __digits[10];
+ _CharT __xplus;
+ _CharT __xminus;
+
+ _CharT __pow_e;
+ _CharT __pow_E;
+
+ _Initialize_get_float(__ct, __xplus, __xminus, __pow_e, __pow_E, __digits);
+
+ // Get an optional sign
+ __in_ite = __copy_sign(__in_ite, __end, __buf, __xplus, __xminus);
+
+ // Get an optional string of digits.
+ if (!__grouping.empty())
+ __digits_before_dot = __copy_grouped_digits(__in_ite, __end, __buf, __digits,
+ __sep, __grouping, __grouping_ok);
+ else
+ __digits_before_dot = __copy_digits(__in_ite, __end, __buf, __digits);
+
+ // Get an optional decimal point, and an optional string of digits.
+ if (__in_ite != __end && *__in_ite == __dot) {
+ __buf.push_back('.');
+ ++__in_ite;
+ __digits_after_dot = __copy_digits(__in_ite, __end, __buf, __digits);
+ }
+
+ // There have to be some digits, somewhere.
+ __ok = __digits_before_dot || __digits_after_dot;
+
+ // Get an optional exponent.
+ if (__ok && __in_ite != __end && (*__in_ite == __pow_e || *__in_ite == __pow_E)) {
+ __buf.push_back('e');
+ ++__in_ite;
+ __in_ite = __copy_sign(__in_ite, __end, __buf, __xplus, __xminus);
+ __ok = __copy_digits(__in_ite, __end, __buf, __digits);
+ // If we have an exponent then the sign
+ // is optional but the digits aren't.
+ }
+
+ return __ok;
+}
+
+template <class _InputIter, class _Float, class _CharT>
+_InputIter _STLP_CALL
+__do_get_float(_InputIter& __in_ite, _InputIter& __end, ios_base& __str,
+ ios_base::iostate& __err, _Float& __val, _CharT* /*__pc*/) {
+ locale __loc = __str.getloc();
+ const ctype<_CharT> &__ctype = use_facet<ctype<_CharT> >(__loc);
+ const numpunct<_CharT> &__numpunct = use_facet<numpunct<_CharT> >(__loc);
+
+ __iostring __buf ;
+ bool __ok = __read_float(__buf, __in_ite, __end, __ctype, __numpunct);
+ if (__ok) {
+ __string_to_float(__buf, __val);
+ __err = ios_base::goodbit;
+ }
+ else {
+ __err = ios_base::failbit;
+ }
+ if (__in_ite == __end)
+ __err |= ios_base::eofbit;
+ return __in_ite;
+}
+
+template <class _InputIter, class _CharT>
+_InputIter _STLP_CALL
+__do_get_alphabool(_InputIter& __in_ite, _InputIter& __end, ios_base& __str,
+ ios_base::iostate& __err, bool& __x, _CharT* /*__pc*/) {
+ const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__str.getloc());
+ const basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> > __truename = __np.truename();
+ const basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> > __falsename = __np.falsename();
+ bool __true_ok = true;
+ bool __false_ok = true;
+
+ size_t __n = 0;
+ for ( ; __in_ite != __end; ++__in_ite) {
+ _CharT __c = *__in_ite;
+ __true_ok = __true_ok && (__c == __truename[__n]);
+ __false_ok = __false_ok && (__c == __falsename[__n]);
+ ++__n;
+
+ if ((!__true_ok && !__false_ok) ||
+ (__true_ok && __n >= __truename.size()) ||
+ (__false_ok && __n >= __falsename.size())) {
+ ++__in_ite;
+ break;
+ }
+ }
+ if (__true_ok && __n < __truename.size()) __true_ok = false;
+ if (__false_ok && __n < __falsename.size()) __false_ok = false;
+
+ if (__true_ok || __false_ok) {
+ __err = ios_base::goodbit;
+ __x = __true_ok;
+ }
+ else
+ __err = ios_base::failbit;
+
+ if (__in_ite == __end)
+ __err |= ios_base::eofbit;
+
+ return __in_ite;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+//
+// num_get<>, num_put<>
+//
+
+template <class _CharT, class _InputIterator>
+locale::id num_get<_CharT, _InputIterator>::id;
+
+#if !defined (_STLP_NO_BOOL)
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end,
+ ios_base& __s, ios_base::iostate& __err, bool& __x) const {
+ if (__s.flags() & ios_base::boolalpha) {
+ return _STLP_PRIV __do_get_alphabool(__in_ite, __end, __s, __err, __x, (_CharT*)0);
+ }
+ else {
+ long __lx;
+ _InputIter __tmp = _STLP_PRIV __do_get_integer(__in_ite, __end, __s, __err, __lx, (_CharT*)0 );
+ if (!(__err & ios_base::failbit)) {
+ if (__lx == 0)
+ __x = false;
+ else if (__lx == 1)
+ __x = true;
+ else
+ __err |= ios_base::failbit;
+ }
+ return __tmp;
+ }
+}
+#endif
+
+#if defined (_STLP_FIX_LIBRARY_ISSUES)
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, short& __val) const
+{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, int& __val) const
+{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }
+
+#endif
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, long& __val) const
+{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err,
+ unsigned short& __val) const
+{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err,
+ unsigned int& __val) const
+{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err,
+ unsigned long& __val) const
+{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err,
+ float& __val) const
+{ return _STLP_PRIV __do_get_float(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err,
+ double& __val) const
+{ return _STLP_PRIV __do_get_float(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err,
+ long double& __val) const
+{ return _STLP_PRIV __do_get_float(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }
+#endif
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err,
+ void*& __p) const {
+#if defined (_STLP_LONG_LONG) && !defined (__MRC__) //*ty 12/07/2001 - MrCpp can not cast from long long to void*
+ unsigned _STLP_LONG_LONG __val;
+#else
+ unsigned long __val;
+#endif
+ iter_type __tmp = _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 );
+ if (!(__err & ios_base::failbit))
+ __p = __REINTERPRET_CAST(void*, __val);
+ return __tmp;
+}
+
+#if defined (_STLP_LONG_LONG)
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err,
+ _STLP_LONG_LONG& __val) const
+{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }
+
+template <class _CharT, class _InputIter>
+_InputIter
+num_get<_CharT, _InputIter>::do_get(_InputIter __in_ite, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err,
+ unsigned _STLP_LONG_LONG& __val) const
+{ return _STLP_PRIV __do_get_integer(__in_ite, __end, __str, __err, __val, (_CharT*)0 ); }
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_NUMERIC_FACETS_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_num_get.h b/sources/android/stlport/stlport/stl/_num_get.h
new file mode 100644
index 0000000..95f7935
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_num_get.h
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+// WARNING: This is an internal header file, included by other C++
+// standard library headers. You should not attempt to use this header
+// file directly.
+
+
+#ifndef _STLP_INTERNAL_NUM_GET_H
+#define _STLP_INTERNAL_NUM_GET_H
+
+#ifndef _STLP_INTERNAL_ISTREAMBUF_ITERATOR_H
+# include <stl/_istreambuf_iterator.h>
+#endif
+
+#ifndef _STLP_C_LOCALE_H
+# include <stl/c_locale.h>
+#endif
+
+#ifndef _STLP_INTERNAL_NUMPUNCT_H
+# include <stl/_numpunct.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CTYPE_H
+# include <stl/_ctype.h>
+#endif
+
+#ifndef _STLP_INTERNAL_IOSTREAM_STRING_H
+# include <stl/_iostream_string.h>
+#endif
+
+#ifndef _STLP_FACETS_FWD_H
+# include <stl/_facets_fwd.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//----------------------------------------------------------------------
+// num_get facets
+
+template <class _CharT, class _InputIter>
+class num_get: public locale::facet {
+public:
+ typedef _CharT char_type;
+ typedef _InputIter iter_type;
+
+ explicit num_get(size_t __refs = 0): locale::facet(__refs) {}
+
+#if !defined (_STLP_NO_BOOL)
+ _InputIter get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, bool& __val) const
+ { return do_get(__ii, __end, __str, __err, __val); }
+#endif
+
+#if defined (_STLP_FIX_LIBRARY_ISSUES)
+ _InputIter get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, short& __val) const
+ { return do_get(__ii, __end, __str, __err, __val); }
+
+ _InputIter get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, int& __val) const
+ { return do_get(__ii, __end, __str, __err, __val); }
+#endif
+
+ _InputIter get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, long& __val) const
+ { return do_get(__ii, __end, __str, __err, __val); }
+
+ _InputIter get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, unsigned short& __val) const
+ { return do_get(__ii, __end, __str, __err, __val); }
+
+ _InputIter get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, unsigned int& __val) const
+ { return do_get(__ii, __end, __str, __err, __val); }
+
+ _InputIter get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, unsigned long& __val) const
+ { return do_get(__ii, __end, __str, __err, __val); }
+
+#if defined (_STLP_LONG_LONG)
+ _InputIter get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, _STLP_LONG_LONG& __val) const
+ { return do_get(__ii, __end, __str, __err, __val); }
+
+ _InputIter get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, unsigned _STLP_LONG_LONG& __val) const
+ { return do_get(__ii, __end, __str, __err, __val); }
+#endif /* _STLP_LONG_LONG */
+
+ _InputIter get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, float& __val) const
+ { return do_get(__ii, __end, __str, __err, __val); }
+
+ _InputIter get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, double& __val) const
+ { return do_get(__ii, __end, __str, __err, __val); }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+ _InputIter get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, long double& __val) const
+ { return do_get(__ii, __end, __str, __err, __val); }
+# endif
+
+ _InputIter get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, void*& __val) const
+ { return do_get(__ii, __end, __str, __err, __val); }
+
+ static locale::id id;
+
+protected:
+ ~num_get() {}
+
+ typedef string string_type;
+ typedef ctype<_CharT> _Ctype;
+ typedef numpunct<_CharT> _Numpunct;
+
+#if !defined (_STLP_NO_BOOL)
+ virtual _InputIter do_get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, bool& __val) const;
+#endif
+
+ virtual _InputIter do_get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, long& __val) const;
+ virtual _InputIter do_get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, unsigned short& __val) const;
+ virtual _InputIter do_get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, unsigned int& __val) const;
+ virtual _InputIter do_get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, unsigned long& __val) const;
+
+#if defined (_STLP_FIX_LIBRARY_ISSUES)
+ // issue 118 : those are actually not supposed to be here
+ virtual _InputIter do_get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, short& __val) const;
+ virtual _InputIter do_get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, int& __val) const;
+#endif
+
+ virtual _InputIter do_get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, float& __val) const;
+ virtual _InputIter do_get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, double& __val) const;
+ virtual _InputIter do_get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, void*& __p) const;
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+ virtual _InputIter do_get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, long double& __val) const;
+#endif
+
+#if defined (_STLP_LONG_LONG)
+ virtual _InputIter do_get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, _STLP_LONG_LONG& __val) const;
+ virtual _InputIter do_get(_InputIter __ii, _InputIter __end, ios_base& __str,
+ ios_base::iostate& __err, unsigned _STLP_LONG_LONG& __val) const;
+#endif
+
+};
+
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS num_get<char, istreambuf_iterator<char, char_traits<char> > >;
+// _STLP_EXPORT_TEMPLATE_CLASS num_get<char, const char*>;
+# if !defined (_STLP_NO_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
+// _STLP_EXPORT_TEMPLATE_CLASS num_get<wchar_t, const wchar_t*>;
+# endif
+#endif
+
+#if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION)
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+_STLP_DECLSPEC bool _STLP_CALL __valid_grouping(const char*, const char*, const char*, const char*);
+
+template <class _InputIter, class _Integer, class _CharT>
+bool _STLP_CALL
+__get_decimal_integer(_InputIter& __first, _InputIter& __last, _Integer& __val, _CharT*);
+
+# if !defined (_STLP_NO_WCHAR_T)
+bool _STLP_DECLSPEC _STLP_CALL __get_fdigit(wchar_t&, const wchar_t*);
+bool _STLP_DECLSPEC _STLP_CALL __get_fdigit_or_sep(wchar_t&, wchar_t, const wchar_t*);
+# endif
+
+inline void _STLP_CALL
+_Initialize_get_float(const ctype<char>&,
+ char& Plus, char& Minus,
+ char& pow_e, char& pow_E,
+ char*) {
+ Plus = '+';
+ Minus = '-';
+ pow_e = 'e';
+ pow_E = 'E';
+}
+
+# if !defined (_STLP_NO_WCHAR_T)
+void _STLP_DECLSPEC _STLP_CALL _Initialize_get_float(const ctype<wchar_t>&,
+ wchar_t&, wchar_t&, wchar_t&, wchar_t&, wchar_t*);
+# endif
+void _STLP_DECLSPEC _STLP_CALL __string_to_float(const __iostring&, float&);
+void _STLP_DECLSPEC _STLP_CALL __string_to_float(const __iostring&, double&);
+# if !defined (_STLP_NO_LONG_DOUBLE)
+void _STLP_DECLSPEC _STLP_CALL __string_to_float(const __iostring&, long double&);
+# endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#endif /* _STLP_EXPOSE_STREAM_IMPLEMENTATION */
+
+
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_num_get.c>
+#endif
+
+#endif /* _STLP_INTERNAL_NUM_GET_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/stl/_num_put.c b/sources/android/stlport/stlport/stl/_num_put.c
new file mode 100644
index 0000000..0c07838
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_num_put.c
@@ -0,0 +1,522 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_NUM_PUT_C
+#define _STLP_NUM_PUT_C
+
+#ifndef _STLP_INTERNAL_NUM_PUT_H
+# include <stl/_num_put.h>
+#endif
+
+#ifndef _STLP_INTERNAL_LIMITS
+# include <stl/_limits.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// __do_put_float and its helper functions. Strategy: write the output
+// to a buffer of char, transform the buffer to _CharT, and then copy
+// it to the output.
+
+//----------------------------------------------------------------------
+// num_put facet
+
+template <class _CharT, class _OutputIter>
+_OutputIter _STLP_CALL
+__copy_float_and_fill(const _CharT* __first, const _CharT* __last,
+ _OutputIter __oi,
+ ios_base::fmtflags __flags,
+ streamsize __width, _CharT __fill,
+ _CharT __xplus, _CharT __xminus) {
+ if (__width <= __last - __first)
+ return _STLP_STD::copy(__first, __last, __oi);
+ else {
+ streamsize __pad = __width - (__last - __first);
+ ios_base::fmtflags __dir = __flags & ios_base::adjustfield;
+
+ if (__dir == ios_base::left) {
+ __oi = _STLP_STD::copy(__first, __last, __oi);
+ return _STLP_PRIV __fill_n(__oi, __pad, __fill);
+ }
+ else if (__dir == ios_base::internal && __first != __last &&
+ (*__first == __xplus || *__first == __xminus)) {
+ *__oi++ = *__first++;
+ __oi = _STLP_PRIV __fill_n(__oi, __pad, __fill);
+ return _STLP_STD::copy(__first, __last, __oi);
+ }
+ else {
+ __oi = _STLP_PRIV __fill_n(__oi, __pad, __fill);
+ return _STLP_STD::copy(__first, __last, __oi);
+ }
+ }
+}
+
+#if !defined (_STLP_NO_WCHAR_T)
+// Helper routine for wchar_t
+template <class _OutputIter>
+_OutputIter _STLP_CALL
+__put_float(__iostring &__str, _OutputIter __oi,
+ ios_base& __f, wchar_t __fill,
+ wchar_t __decimal_point, wchar_t __sep,
+ size_t __group_pos, const string& __grouping) {
+ const ctype<wchar_t>& __ct = use_facet<ctype<wchar_t> >(__f.getloc());
+
+ __iowstring __wbuf;
+ __convert_float_buffer(__str, __wbuf, __ct, __decimal_point);
+
+ if (!__grouping.empty()) {
+ __insert_grouping(__wbuf, __group_pos, __grouping,
+ __sep, __ct.widen('+'), __ct.widen('-'), 0);
+ }
+
+ return __copy_float_and_fill(__wbuf.data(), __wbuf.data() + __wbuf.size(), __oi,
+ __f.flags(), __f.width(0), __fill, __ct.widen('+'), __ct.widen('-'));
+}
+#endif /* WCHAR_T */
+
+// Helper routine for char
+template <class _OutputIter>
+_OutputIter _STLP_CALL
+__put_float(__iostring &__str, _OutputIter __oi,
+ ios_base& __f, char __fill,
+ char __decimal_point, char __sep,
+ size_t __group_pos, const string& __grouping) {
+ if ((__group_pos < __str.size()) && (__str[__group_pos] == '.')) {
+ __str[__group_pos] = __decimal_point;
+ }
+
+ if (!__grouping.empty()) {
+ __insert_grouping(__str, __group_pos,
+ __grouping, __sep, '+', '-', 0);
+ }
+
+ return __copy_float_and_fill(__str.data(), __str.data() + __str.size(), __oi,
+ __f.flags(), __f.width(0), __fill, '+', '-');
+}
+
+template <class _CharT, class _OutputIter, class _Float>
+_OutputIter _STLP_CALL
+__do_put_float(_OutputIter __s, ios_base& __f,
+ _CharT __fill, _Float __x) {
+ __iostring __buf;
+
+ size_t __group_pos = __write_float(__buf, __f.flags(), (int)__f.precision(), __x);
+
+ const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__f.getloc());
+ return __put_float(__buf, __s, __f, __fill,
+ __np.decimal_point(), __np.thousands_sep(),
+ __group_pos, __np.grouping());
+}
+
+inline void __get_money_digits_aux (__iostring &__buf, ios_base &, _STLP_LONGEST_FLOAT_TYPE __x)
+{ __get_floor_digits(__buf, __x); }
+
+#if !defined (_STLP_NO_WCHAR_T)
+inline void __get_money_digits_aux (__iowstring &__wbuf, ios_base &__f, _STLP_LONGEST_FLOAT_TYPE __x) {
+ __iostring __buf;
+ __get_floor_digits(__buf, __x);
+
+ const ctype<wchar_t>& __ct = use_facet<ctype<wchar_t> >(__f.getloc());
+ __convert_float_buffer(__buf, __wbuf, __ct, wchar_t(0), false);
+}
+#endif
+
+template <class _CharT>
+void _STLP_CALL __get_money_digits(_STLP_BASIC_IOSTRING(_CharT) &__buf, ios_base& __f, _STLP_LONGEST_FLOAT_TYPE __x)
+{ __get_money_digits_aux(__buf, __f, __x); }
+
+// _M_do_put_integer and its helper functions.
+
+template <class _CharT, class _OutputIter>
+_OutputIter _STLP_CALL
+__copy_integer_and_fill(const _CharT* __buf, ptrdiff_t __len,
+ _OutputIter __oi,
+ ios_base::fmtflags __flg, streamsize __wid, _CharT __fill,
+ _CharT __xplus, _CharT __xminus) {
+ if (__len >= __wid)
+ return _STLP_STD::copy(__buf, __buf + __len, __oi);
+ else {
+ //casting numeric_limits<ptrdiff_t>::max to streamsize only works is ptrdiff_t is signed or streamsize representation
+ //is larger than ptrdiff_t one.
+ _STLP_STATIC_ASSERT((sizeof(streamsize) > sizeof(ptrdiff_t)) ||
+ ((sizeof(streamsize) == sizeof(ptrdiff_t)) && numeric_limits<ptrdiff_t>::is_signed))
+ ptrdiff_t __pad = __STATIC_CAST(ptrdiff_t, (min) (__STATIC_CAST(streamsize, (numeric_limits<ptrdiff_t>::max)()),
+ __STATIC_CAST(streamsize, __wid - __len)));
+ ios_base::fmtflags __dir = __flg & ios_base::adjustfield;
+
+ if (__dir == ios_base::left) {
+ __oi = _STLP_STD::copy(__buf, __buf + __len, __oi);
+ return _STLP_PRIV __fill_n(__oi, __pad, __fill);
+ }
+ else if (__dir == ios_base::internal && __len != 0 &&
+ (__buf[0] == __xplus || __buf[0] == __xminus)) {
+ *__oi++ = __buf[0];
+ __oi = __fill_n(__oi, __pad, __fill);
+ return _STLP_STD::copy(__buf + 1, __buf + __len, __oi);
+ }
+ else if (__dir == ios_base::internal && __len >= 2 &&
+ (__flg & ios_base::showbase) &&
+ (__flg & ios_base::basefield) == ios_base::hex) {
+ *__oi++ = __buf[0];
+ *__oi++ = __buf[1];
+ __oi = __fill_n(__oi, __pad, __fill);
+ return _STLP_STD::copy(__buf + 2, __buf + __len, __oi);
+ }
+ else {
+ __oi = __fill_n(__oi, __pad, __fill);
+ return _STLP_STD::copy(__buf, __buf + __len, __oi);
+ }
+ }
+}
+
+#if !defined (_STLP_NO_WCHAR_T)
+// Helper function for wchar_t
+template <class _OutputIter>
+_OutputIter _STLP_CALL
+__put_integer(char* __buf, char* __iend, _OutputIter __s,
+ ios_base& __f,
+ ios_base::fmtflags __flags, wchar_t __fill) {
+ locale __loc = __f.getloc();
+ const ctype<wchar_t>& __ct = use_facet<ctype<wchar_t> >(__loc);
+
+ wchar_t __xplus = __ct.widen('+');
+ wchar_t __xminus = __ct.widen('-');
+
+ wchar_t __wbuf[64];
+ __ct.widen(__buf, __iend, __wbuf);
+ ptrdiff_t __len = __iend - __buf;
+ wchar_t* __eend = __wbuf + __len;
+
+ const numpunct<wchar_t>& __np = use_facet<numpunct<wchar_t> >(__loc);
+ const string& __grouping = __np.grouping();
+
+ if (!__grouping.empty()) {
+ int __basechars;
+ if (__flags & ios_base::showbase)
+ switch (__flags & ios_base::basefield) {
+ case ios_base::hex: __basechars = 2; break;
+ case ios_base::oct: __basechars = 1; break;
+ default: __basechars = 0;
+ }
+ else
+ __basechars = 0;
+
+ __len = __insert_grouping(__wbuf, __eend, __grouping, __np.thousands_sep(),
+ __xplus, __xminus, __basechars);
+ }
+
+ return __copy_integer_and_fill((wchar_t*)__wbuf, __len, __s,
+ __flags, __f.width(0), __fill, __xplus, __xminus);
+}
+#endif
+
+// Helper function for char
+template <class _OutputIter>
+_OutputIter _STLP_CALL
+__put_integer(char* __buf, char* __iend, _OutputIter __s,
+ ios_base& __f, ios_base::fmtflags __flags, char __fill) {
+ char __grpbuf[64];
+ ptrdiff_t __len = __iend - __buf;
+
+ const numpunct<char>& __np = use_facet<numpunct<char> >(__f.getloc());
+ const string& __grouping = __np.grouping();
+
+ if (!__grouping.empty()) {
+ int __basechars;
+ if (__flags & ios_base::showbase)
+ switch (__flags & ios_base::basefield) {
+ case ios_base::hex: __basechars = 2; break;
+ case ios_base::oct: __basechars = 1; break;
+ default: __basechars = 0;
+ }
+ else
+ __basechars = 0;
+
+ // make sure there is room at the end of the buffer
+ // we pass to __insert_grouping
+ _STLP_STD::copy(__buf, __iend, (char *) __grpbuf);
+ __buf = __grpbuf;
+ __iend = __grpbuf + __len;
+ __len = __insert_grouping(__buf, __iend, __grouping, __np.thousands_sep(),
+ '+', '-', __basechars);
+ }
+
+ return __copy_integer_and_fill(__buf, __len, __s, __flags, __f.width(0), __fill, '+', '-');
+}
+
+#if defined (_STLP_LONG_LONG)
+typedef _STLP_LONG_LONG __max_int_t;
+typedef unsigned _STLP_LONG_LONG __umax_int_t;
+#else
+typedef long __max_int_t;
+typedef unsigned long __umax_int_t;
+#endif
+
+_STLP_DECLSPEC const char* _STLP_CALL __hex_char_table_lo();
+_STLP_DECLSPEC const char* _STLP_CALL __hex_char_table_hi();
+
+template <class _Integer>
+inline char* _STLP_CALL
+__write_decimal_backward(char* __ptr, _Integer __x, ios_base::fmtflags __flags, const __true_type& /* is_signed */) {
+ const bool __negative = __x < 0 ;
+ __max_int_t __temp = __x;
+ __umax_int_t __utemp = __negative?-__temp:__temp;
+
+ for (; __utemp != 0; __utemp /= 10)
+ *--__ptr = (char)((int)(__utemp % 10) + '0');
+ // put sign if needed or requested
+ if (__negative)
+ *--__ptr = '-';
+ else if (__flags & ios_base::showpos)
+ *--__ptr = '+';
+ return __ptr;
+}
+
+template <class _Integer>
+inline char* _STLP_CALL
+__write_decimal_backward(char* __ptr, _Integer __x, ios_base::fmtflags __flags, const __false_type& /* is_signed */) {
+ for (; __x != 0; __x /= 10)
+ *--__ptr = (char)((int)(__x % 10) + '0');
+ // put sign if requested
+ if (__flags & ios_base::showpos)
+ *--__ptr = '+';
+ return __ptr;
+}
+
+template <class _Integer>
+char* _STLP_CALL
+__write_integer_backward(char* __buf, ios_base::fmtflags __flags, _Integer __x) {
+ char* __ptr = __buf;
+
+ if (__x == 0) {
+ *--__ptr = '0';
+ if ((__flags & ios_base::showpos) && ((__flags & (ios_base::oct | ios_base::hex)) == 0))
+ *--__ptr = '+';
+ // oct or hex base shall not be added to the 0 value (see '#' flag in C formating strings)
+ }
+ else {
+ switch (__flags & ios_base::basefield) {
+ case ios_base::oct:
+ {
+ __umax_int_t __temp = __x;
+ // if the size of integer is less than 8, clear upper part
+ if ( sizeof(__x) < 8 && sizeof(__umax_int_t) >= 8 )
+ __temp &= 0xFFFFFFFF;
+
+ for (; __temp != 0; __temp >>=3)
+ *--__ptr = (char)((((unsigned)__temp)& 0x7) + '0');
+
+ // put leading '0' if showbase is set
+ if (__flags & ios_base::showbase)
+ *--__ptr = '0';
+ }
+ break;
+ case ios_base::hex:
+ {
+ const char* __table_ptr = (__flags & ios_base::uppercase) ?
+ __hex_char_table_hi() : __hex_char_table_lo();
+ __umax_int_t __temp = __x;
+ // if the size of integer is less than 8, clear upper part
+ if ( sizeof(__x) < 8 && sizeof(__umax_int_t) >= 8 )
+ __temp &= 0xFFFFFFFF;
+
+ for (; __temp != 0; __temp >>=4)
+ *--__ptr = __table_ptr[((unsigned)__temp & 0xF)];
+
+ if (__flags & ios_base::showbase) {
+ *--__ptr = __table_ptr[16];
+ *--__ptr = '0';
+ }
+ }
+ break;
+ //case ios_base::dec:
+ default:
+ {
+#if defined(__HP_aCC) && (__HP_aCC == 1)
+ bool _IsSigned = !((_Integer)-1 > 0);
+ if (_IsSigned)
+ __ptr = __write_decimal_backward(__ptr, __x, __flags, __true_type() );
+ else
+ __ptr = __write_decimal_backward(__ptr, __x, __flags, __false_type() );
+#else
+ typedef typename __bool2type<numeric_limits<_Integer>::is_signed>::_Ret _IsSigned;
+ __ptr = __write_decimal_backward(__ptr, __x, __flags, _IsSigned());
+#endif
+ }
+ break;
+ }
+ }
+
+ // return pointer to beginning of the string
+ return __ptr;
+}
+
+template <class _CharT, class _OutputIter, class _Integer>
+_OutputIter _STLP_CALL
+__do_put_integer(_OutputIter __s, ios_base& __f, _CharT __fill, _Integer __x) {
+ // buffer size = number of bytes * number of digit necessary in the smallest Standard base (base 8, 3 digits/byte)
+ // plus the longest base representation '0x'
+ // Do not use __buf_size to define __buf static buffer, some compilers (HP aCC) do not accept const variable as
+ // the specification of a static buffer size.
+ char __buf[sizeof(_Integer) * 3 + 2];
+ const ptrdiff_t __buf_size = sizeof(__buf) / sizeof(char);
+ ios_base::fmtflags __flags = __f.flags();
+ char* __ibeg = __write_integer_backward((char*)__buf + __buf_size, __flags, __x);
+ return __put_integer(__ibeg, (char*)__buf + __buf_size, __s, __f, __flags, __fill);
+}
+
+template <class _CharT, class _OutputIter>
+_OutputIter _STLP_CALL
+__do_put_bool(_OutputIter __s, ios_base& __f, _CharT __fill, bool __x) {
+ const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__f.getloc());
+
+ basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> > __str = __x ? __np.truename() : __np.falsename();
+
+ streamsize __wid = __f.width(0);
+ if (__str.size() >= __STATIC_CAST(size_t, __wid))
+ return _STLP_STD::copy(__str.begin(), __str.end(), __s);
+ else {
+ streamsize __pad = __wid - __str.size();
+ ios_base::fmtflags __dir = __f.flags() & ios_base::adjustfield;
+
+ if (__dir == ios_base::left) {
+ __s = _STLP_STD::copy(__str.begin(), __str.end(), __s);
+ return __fill_n(__s, __pad, __fill);
+ }
+ else /* covers right and internal padding */ {
+ __s = __fill_n(__s, __pad, __fill);
+ return _STLP_STD::copy(__str.begin(), __str.end(), __s);
+ }
+ }
+}
+_STLP_MOVE_TO_STD_NAMESPACE
+
+//
+// num_put<>
+//
+
+template <class _CharT, class _OutputIterator>
+locale::id num_put<_CharT, _OutputIterator>::id;
+
+#if !defined (_STLP_NO_BOOL)
+template <class _CharT, class _OutputIter>
+_OutputIter
+num_put<_CharT, _OutputIter>::do_put(_OutputIter __s, ios_base& __f, _CharT __fill,
+ bool __val) const {
+ if (!(__f.flags() & ios_base::boolalpha))
+ // 22.2.2.2.2.23: shall return do_put for int and not directly __do_put_integer.
+ return do_put(__s, __f, __fill, __STATIC_CAST(long, __val));
+
+ return _STLP_PRIV __do_put_bool(__s, __f, __fill, __val);
+}
+#endif
+
+template <class _CharT, class _OutputIter>
+_OutputIter
+num_put<_CharT, _OutputIter>::do_put(_OutputIter __s, ios_base& __f, _CharT __fill,
+ long __val) const
+{ return _STLP_PRIV __do_put_integer(__s, __f, __fill, __val); }
+
+template <class _CharT, class _OutputIter>
+_OutputIter
+num_put<_CharT, _OutputIter>::do_put(_OutputIter __s, ios_base& __f, _CharT __fill,
+ unsigned long __val) const
+{ return _STLP_PRIV __do_put_integer(__s, __f, __fill, __val); }
+
+template <class _CharT, class _OutputIter>
+_OutputIter
+num_put<_CharT, _OutputIter>::do_put(_OutputIter __s, ios_base& __f, _CharT __fill,
+ double __val) const
+{ return _STLP_PRIV __do_put_float(__s, __f, __fill, __val); }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+template <class _CharT, class _OutputIter>
+_OutputIter
+num_put<_CharT, _OutputIter>::do_put(_OutputIter __s, ios_base& __f, _CharT __fill,
+ long double __val) const
+{ return _STLP_PRIV __do_put_float(__s, __f, __fill, __val); }
+#endif
+
+#if defined (_STLP_LONG_LONG)
+template <class _CharT, class _OutputIter>
+_OutputIter
+num_put<_CharT, _OutputIter>::do_put(_OutputIter __s, ios_base& __f, _CharT __fill,
+ _STLP_LONG_LONG __val) const
+{ return _STLP_PRIV __do_put_integer(__s, __f, __fill, __val); }
+
+template <class _CharT, class _OutputIter>
+_OutputIter
+num_put<_CharT, _OutputIter>::do_put(_OutputIter __s, ios_base& __f, _CharT __fill,
+ unsigned _STLP_LONG_LONG __val) const
+{ return _STLP_PRIV __do_put_integer(__s, __f, __fill, __val); }
+#endif /* _STLP_LONG_LONG */
+
+
+// 22.2.2.2.2 Stage 1: "For conversion from void* the specifier is %p."
+// This is not clear and I'm really don't follow this (below).
+template <class _CharT, class _OutputIter>
+_OutputIter
+num_put<_CharT, _OutputIter>::do_put(_OutputIter __s, ios_base& __f, _CharT /*__fill*/,
+ const void* __val) const {
+ const ctype<_CharT>& __c_type = use_facet<ctype<_CharT> >(__f.getloc());
+ ios_base::fmtflags __save_flags = __f.flags();
+
+ __f.setf(ios_base::hex, ios_base::basefield);
+ __f.setf(ios_base::showbase);
+ __f.setf(ios_base::internal, ios_base::adjustfield);
+ __f.width((sizeof(void*) * 2) + 2); // digits in pointer type plus '0x' prefix
+ if ( __val == 0 ) {
+ // base ('0x') not shown for null, but I really want to type it
+ // for pointer. Print it first in this case.
+ const char* __table_ptr = (__save_flags & ios_base::uppercase) ?
+ _STLP_PRIV __hex_char_table_hi() : _STLP_PRIV __hex_char_table_lo();
+ __s++ = __c_type.widen( '0' );
+ __s++ = __c_type.widen( __table_ptr[16] );
+ __f.width((sizeof(void*) * 2)); // digits in pointer type
+ } else {
+ __f.width((sizeof(void*) * 2) + 2); // digits in pointer type plus '0x' prefix
+ }
+#if defined (_STLP_MSVC)
+# pragma warning (push)
+# pragma warning (disable : 4311) //pointer truncation from 'const void*' to 'unsigned long'
+#endif
+ _OutputIter result =
+#ifdef _STLP_LONG_LONG
+ ( sizeof(void*) == sizeof(unsigned long) ) ?
+#endif
+ _STLP_PRIV __do_put_integer(__s, __f, __c_type.widen('0'), __REINTERPRET_CAST(unsigned long,__val))
+#ifdef _STLP_LONG_LONG
+ : /* ( sizeof(void*) == sizeof(unsigned _STLP_LONG_LONG) ) ? */
+ _STLP_PRIV __do_put_integer(__s, __f, __c_type.widen('0'), __REINTERPRET_CAST(unsigned _STLP_LONG_LONG,__val))
+#endif
+ ;
+#if defined (_STLP_MSVC)
+# pragma warning (pop)
+#endif
+ __f.flags(__save_flags);
+ return result;
+}
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_NUM_PUT_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_num_put.h b/sources/android/stlport/stlport/stl/_num_put.h
new file mode 100644
index 0000000..29bfc01
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_num_put.h
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+// WARNING: This is an internal header file, included by other C++
+// standard library headers. You should not attempt to use this header
+// file directly.
+
+
+#ifndef _STLP_INTERNAL_NUM_PUT_H
+#define _STLP_INTERNAL_NUM_PUT_H
+
+#ifndef _STLP_INTERNAL_NUMPUNCT_H
+# include <stl/_numpunct.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CTYPE_H
+# include <stl/_ctype.h>
+#endif
+
+#ifndef _STLP_INTERNAL_OSTREAMBUF_ITERATOR_H
+# include <stl/_ostreambuf_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_IOSTREAM_STRING_H
+# include <stl/_iostream_string.h>
+#endif
+
+#ifndef _STLP_FACETS_FWD_H
+# include <stl/_facets_fwd.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//----------------------------------------------------------------------
+// num_put facet
+
+template <class _CharT, class _OutputIter>
+class num_put: public locale::facet {
+public:
+ typedef _CharT char_type;
+ typedef _OutputIter iter_type;
+
+ explicit num_put(size_t __refs = 0) : locale::facet(__refs) {}
+
+#if !defined (_STLP_NO_BOOL)
+ iter_type put(iter_type __s, ios_base& __f, char_type __fill,
+ bool __val) const {
+ return do_put(__s, __f, __fill, __val);
+ }
+#endif
+ iter_type put(iter_type __s, ios_base& __f, char_type __fill,
+ long __val) const {
+ return do_put(__s, __f, __fill, __val);
+ }
+
+ iter_type put(iter_type __s, ios_base& __f, char_type __fill,
+ unsigned long __val) const {
+ return do_put(__s, __f, __fill, __val);
+ }
+
+#if defined (_STLP_LONG_LONG)
+ iter_type put(iter_type __s, ios_base& __f, char_type __fill,
+ _STLP_LONG_LONG __val) const {
+ return do_put(__s, __f, __fill, __val);
+ }
+
+ iter_type put(iter_type __s, ios_base& __f, char_type __fill,
+ unsigned _STLP_LONG_LONG __val) const {
+ return do_put(__s, __f, __fill, __val);
+ }
+#endif
+
+ iter_type put(iter_type __s, ios_base& __f, char_type __fill,
+ double __val) const {
+ return do_put(__s, __f, __fill, (double)__val);
+ }
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+ iter_type put(iter_type __s, ios_base& __f, char_type __fill,
+ long double __val) const {
+ return do_put(__s, __f, __fill, __val);
+ }
+#endif
+
+ iter_type put(iter_type __s, ios_base& __f, char_type __fill,
+ const void * __val) const {
+ return do_put(__s, __f, __fill, __val);
+ }
+
+ static locale::id id;
+
+protected:
+ ~num_put() {}
+#if !defined (_STLP_NO_BOOL)
+ virtual _OutputIter do_put(_OutputIter __s, ios_base& __f, _CharT __fill, bool __val) const;
+#endif
+ virtual _OutputIter do_put(_OutputIter __s, ios_base& __f, _CharT __fill, long __val) const;
+ virtual _OutputIter do_put(_OutputIter __s, ios_base& __f, _CharT __fill, unsigned long __val) const;
+ virtual _OutputIter do_put(_OutputIter __s, ios_base& __f, _CharT __fill, double __val) const;
+#if !defined (_STLP_NO_LONG_DOUBLE)
+ virtual _OutputIter do_put(_OutputIter __s, ios_base& __f, _CharT __fill, long double __val) const;
+#endif
+
+#if defined (_STLP_LONG_LONG)
+ virtual _OutputIter do_put(_OutputIter __s, ios_base& __f, _CharT __fill, _STLP_LONG_LONG __val) const;
+ virtual _OutputIter do_put(_OutputIter __s, ios_base& __f, _CharT __fill,
+ unsigned _STLP_LONG_LONG __val) const ;
+#endif
+ virtual _OutputIter do_put(_OutputIter __s, ios_base& __f, _CharT __fill, const void* __val) const;
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS num_put<char, ostreambuf_iterator<char, char_traits<char> > >;
+# if !defined (_STLP_NO_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
+# endif
+#endif
+
+#if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION)
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Integer>
+char* _STLP_CALL
+__write_integer_backward(char* __buf, ios_base::fmtflags __flags, _Integer __x);
+
+/*
+ * Returns the position on the right of the digits that has to be considered
+ * for the application of the grouping policy.
+ */
+extern size_t _STLP_CALL __write_float(__iostring&, ios_base::fmtflags, int, double);
+# if !defined (_STLP_NO_LONG_DOUBLE)
+extern size_t _STLP_CALL __write_float(__iostring&, ios_base::fmtflags, int, long double);
+# endif
+
+/*
+ * Gets the digits of the integer part.
+ */
+void _STLP_CALL __get_floor_digits(__iostring&, _STLP_LONGEST_FLOAT_TYPE);
+
+template <class _CharT>
+void _STLP_CALL __get_money_digits(_STLP_BASIC_IOSTRING(_CharT)&, ios_base&, _STLP_LONGEST_FLOAT_TYPE);
+
+# if !defined (_STLP_NO_WCHAR_T)
+extern void _STLP_CALL __convert_float_buffer(__iostring const&, __iowstring&, const ctype<wchar_t>&, wchar_t, bool = true);
+# endif
+extern void _STLP_CALL __adjust_float_buffer(__iostring&, char);
+
+extern char* _STLP_CALL
+__write_integer(char* buf, ios_base::fmtflags flags, long x);
+
+extern ptrdiff_t _STLP_CALL __insert_grouping(char* first, char* last, const string&, char, char, char, int);
+extern void _STLP_CALL __insert_grouping(__iostring&, size_t, const string&, char, char, char, int);
+# if !defined (_STLP_NO_WCHAR_T)
+extern ptrdiff_t _STLP_CALL __insert_grouping(wchar_t*, wchar_t*, const string&, wchar_t, wchar_t, wchar_t, int);
+extern void _STLP_CALL __insert_grouping(__iowstring&, size_t, const string&, wchar_t, wchar_t, wchar_t, int);
+# endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#endif /* _STLP_EXPOSE_STREAM_IMPLEMENTATION */
+
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_num_put.c>
+#endif
+
+#endif /* _STLP_INTERNAL_NUMERIC_FACETS_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_numeric.c b/sources/android/stlport/stlport/stl/_numeric.c
new file mode 100644
index 0000000..6bd07ff
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_numeric.c
@@ -0,0 +1,106 @@
+/*
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_NUMERIC_C
+#define _STLP_NUMERIC_C
+
+#ifndef _STLP_INTERNAL_NUMERIC_H
+# include <stl/_numeric.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIterator, class _OutputIterator, class _Tp,
+ class _BinaryOperation>
+_OutputIterator
+__partial_sum(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result, _Tp*, _BinaryOperation __binary_op) {
+ _STLP_DEBUG_CHECK(__check_range(__first, __last))
+ if (__first == __last) return __result;
+ *__result = *__first;
+
+ _Tp __val = *__first;
+ while (++__first != __last) {
+ __val = __binary_op(__val, *__first);
+ *++__result = __val;
+ }
+ return ++__result;
+}
+
+template <class _InputIterator, class _OutputIterator, class _Tp,
+ class _BinaryOperation>
+_OutputIterator
+__adjacent_difference(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result, _Tp*,
+ _BinaryOperation __binary_op) {
+ _STLP_DEBUG_CHECK(__check_range(__first, __last))
+ if (__first == __last) return __result;
+ *__result = *__first;
+ _Tp __val = *__first;
+ while (++__first != __last) {
+ _Tp __tmp = *__first;
+ *++__result = __binary_op(__tmp, __val);
+ __val = __tmp;
+ }
+ return ++__result;
+}
+
+
+template <class _Tp, class _Integer, class _MonoidOperation>
+_Tp __power(_Tp __x, _Integer __n, _MonoidOperation __opr) {
+ _STLP_MPWFIX_TRY
+ if (__n == 0)
+ return __identity_element(__opr);
+ else {
+ while ((__n & 1) == 0) {
+ __n >>= 1;
+ __x = __opr(__x, __x);
+ }
+ _Tp __result = __x;
+ _STLP_MPWFIX_TRY
+ __n >>= 1;
+ while (__n != 0) {
+ __x = __opr(__x, __x);
+ if ((__n & 1) != 0)
+ __result = __opr(__result, __x);
+ __n >>= 1;
+ }
+ return __result;
+ _STLP_MPWFIX_CATCH
+ }
+ _STLP_MPWFIX_CATCH_ACTION(__x = _Tp())
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_NUMERIC_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_numeric.h b/sources/android/stlport/stlport/stl/_numeric.h
new file mode 100644
index 0000000..4844da1
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_numeric.h
@@ -0,0 +1,191 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_NUMERIC_H
+#define _STLP_INTERNAL_NUMERIC_H
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+# include <stl/_function_base.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
+# include <stl/_iterator_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _InputIterator, class _Tp>
+_STLP_INLINE_LOOP
+_Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp _Init) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ for ( ; __first != __last; ++__first)
+ _Init = _Init + *__first;
+ return _Init;
+}
+
+template <class _InputIterator, class _Tp, class _BinaryOperation>
+_STLP_INLINE_LOOP
+_Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp _Init,
+ _BinaryOperation __binary_op) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ for ( ; __first != __last; ++__first)
+ _Init = __binary_op(_Init, *__first);
+ return _Init;
+}
+
+template <class _InputIterator1, class _InputIterator2, class _Tp>
+_STLP_INLINE_LOOP
+_Tp inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
+ _InputIterator2 __first2, _Tp _Init) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ for ( ; __first1 != __last1; ++__first1, ++__first2)
+ _Init = _Init + (*__first1 * *__first2);
+ return _Init;
+}
+
+template <class _InputIterator1, class _InputIterator2, class _Tp,
+ class _BinaryOperation1, class _BinaryOperation2>
+_STLP_INLINE_LOOP
+_Tp inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
+ _InputIterator2 __first2, _Tp _Init,
+ _BinaryOperation1 __binary_op1,
+ _BinaryOperation2 __binary_op2) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))
+ for ( ; __first1 != __last1; ++__first1, ++__first2)
+ _Init = __binary_op1(_Init, __binary_op2(*__first1, *__first2));
+ return _Init;
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIterator, class _OutputIterator, class _Tp,
+ class _BinaryOperation>
+_OutputIterator
+__partial_sum(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result, _Tp*, _BinaryOperation __binary_op);
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIterator, class _OutputIterator>
+inline _OutputIterator
+partial_sum(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result) {
+ return _STLP_PRIV __partial_sum(__first, __last, __result, _STLP_VALUE_TYPE(__first, _InputIterator),
+ _STLP_PRIV __plus(_STLP_VALUE_TYPE(__first, _InputIterator)));
+}
+
+template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
+inline _OutputIterator
+partial_sum(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result, _BinaryOperation __binary_op) {
+ return _STLP_PRIV __partial_sum(__first, __last, __result, _STLP_VALUE_TYPE(__first, _InputIterator),
+ __binary_op);
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIterator, class _OutputIterator, class _Tp,
+ class _BinaryOperation>
+_OutputIterator
+__adjacent_difference(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result, _Tp*,
+ _BinaryOperation __binary_op);
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIterator, class _OutputIterator>
+inline _OutputIterator
+adjacent_difference(_InputIterator __first,
+ _InputIterator __last, _OutputIterator __result) {
+ return _STLP_PRIV __adjacent_difference(__first, __last, __result,
+ _STLP_VALUE_TYPE(__first, _InputIterator),
+ _STLP_PRIV __minus(_STLP_VALUE_TYPE(__first, _InputIterator)));
+}
+
+template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
+_OutputIterator
+adjacent_difference(_InputIterator __first, _InputIterator __last,
+ _OutputIterator __result, _BinaryOperation __binary_op) {
+ return _STLP_PRIV __adjacent_difference(__first, __last, __result,
+ _STLP_VALUE_TYPE(__first, _InputIterator),
+ __binary_op);
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp, class _Integer, class _MonoidOperation>
+_Tp __power(_Tp __x, _Integer __n, _MonoidOperation __opr);
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#if !defined (_STLP_NO_EXTENSIONS)
+
+// Returns __x ** __n, where __n >= 0. _Note that "multiplication"
+// is required to be associative, but not necessarily commutative.
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp, class _Integer>
+inline _Tp __power(_Tp __x, _Integer __n) {
+ return __power(__x, __n, multiplies<_Tp>());
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+// Alias for the internal name __power. Note that power is an extension,
+// not part of the C++ standard.
+template <class _Tp, class _Integer, class _MonoidOperation>
+inline _Tp power(_Tp __x, _Integer __n, _MonoidOperation __opr) {
+ return _STLP_PRIV __power(__x, __n, __opr);
+}
+
+template <class _Tp, class _Integer>
+inline _Tp power(_Tp __x, _Integer __n) {
+ return _STLP_PRIV __power(__x, __n, multiplies<_Tp>());
+}
+
+// iota is not part of the C++ standard. It is an extension.
+
+template <class _ForwardIterator, class _Tp>
+_STLP_INLINE_LOOP
+void iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __val) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ while (__first != __last)
+ *__first++ = __val++;
+}
+#endif
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_numeric.c>
+#endif
+
+#endif /* _STLP_INTERNAL_NUMERIC_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_numpunct.h b/sources/android/stlport/stlport/stl/_numpunct.h
new file mode 100644
index 0000000..c0d0ff4
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_numpunct.h
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+// WARNING: This is an internal header file, included by other C++
+// standard library headers. You should not attempt to use this header
+// file directly.
+
+
+#ifndef _STLP_INTERNAL_NUMPUNCT_H
+#define _STLP_INTERNAL_NUMPUNCT_H
+
+#ifndef _STLP_IOS_BASE_H
+# include <stl/_ios_base.h>
+#endif
+
+# ifndef _STLP_C_LOCALE_H
+# include <stl/c_locale.h>
+# endif
+
+#ifndef _STLP_INTERNAL_STRING_H
+# include <stl/_string.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//----------------------------------------------------------------------
+// numpunct facets
+
+template <class _CharT> class numpunct {};
+template <class _CharT> class numpunct_byname {};
+template <class _Ch, class _InIt> class num_get;
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC numpunct<char> : public locale::facet {
+public:
+ typedef char char_type;
+ typedef string string_type;
+
+ explicit numpunct(size_t __refs = 0)
+ : locale::facet(__refs) {}
+
+ char decimal_point() const { return do_decimal_point(); }
+ char thousands_sep() const { return do_thousands_sep(); }
+ string grouping() const { return do_grouping(); }
+ string truename() const { return do_truename(); }
+ string falsename() const { return do_falsename(); }
+
+ static _STLP_STATIC_DECLSPEC locale::id id;
+
+protected:
+ ~numpunct();
+
+ virtual char do_decimal_point() const;
+ virtual char do_thousands_sep() const;
+ virtual string do_grouping() const;
+ virtual string do_truename() const;
+ virtual string do_falsename() const;
+};
+
+# if ! defined (_STLP_NO_WCHAR_T)
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC numpunct<wchar_t> : public locale::facet {
+public:
+ typedef wchar_t char_type;
+ typedef wstring string_type;
+
+ explicit numpunct(size_t __refs = 0)
+ : locale::facet(__refs) {}
+
+ wchar_t decimal_point() const { return do_decimal_point(); }
+ wchar_t thousands_sep() const { return do_thousands_sep(); }
+ string grouping() const { return do_grouping(); }
+ wstring truename() const { return do_truename(); }
+ wstring falsename() const { return do_falsename(); }
+
+ static _STLP_STATIC_DECLSPEC locale::id id;
+
+protected:
+ ~numpunct();
+
+ virtual wchar_t do_decimal_point() const;
+ virtual wchar_t do_thousands_sep() const;
+ virtual string do_grouping() const;
+ virtual wstring do_truename() const;
+ virtual wstring do_falsename() const;
+};
+
+# endif /* WCHAR_T */
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC numpunct_byname<char> : public numpunct<char> {
+ friend class _Locale_impl;
+public:
+ typedef char char_type;
+ typedef string string_type;
+
+ explicit numpunct_byname(const char* __name, size_t __refs = 0);
+
+protected:
+
+ ~numpunct_byname();
+
+ virtual char do_decimal_point() const;
+ virtual char do_thousands_sep() const;
+ virtual string do_grouping() const;
+ virtual string do_truename() const;
+ virtual string do_falsename() const;
+
+private:
+ numpunct_byname(_Locale_numeric *__numeric)
+ : _M_numeric(__numeric) {}
+
+ //explicitely defined as private to avoid warnings:
+ typedef numpunct_byname<char> _Self;
+ numpunct_byname(_Self const&);
+ _Self& operator = (_Self const&);
+
+ _Locale_numeric* _M_numeric;
+};
+
+# ifndef _STLP_NO_WCHAR_T
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC numpunct_byname<wchar_t>: public numpunct<wchar_t> {
+ friend class _Locale_impl;
+public:
+ typedef wchar_t char_type;
+ typedef wstring string_type;
+
+ explicit numpunct_byname(const char* __name, size_t __refs = 0);
+
+protected:
+ ~numpunct_byname();
+
+ virtual wchar_t do_decimal_point() const;
+ virtual wchar_t do_thousands_sep() const;
+ virtual string do_grouping() const;
+ virtual wstring do_truename() const;
+ virtual wstring do_falsename() const;
+
+private:
+ numpunct_byname(_Locale_numeric *__numeric)
+ : _M_numeric(__numeric) {}
+
+ //explicitely defined as private to avoid warnings:
+ typedef numpunct_byname<wchar_t> _Self;
+ numpunct_byname(_Self const&);
+ _Self& operator = (_Self const&);
+
+ _Locale_numeric* _M_numeric;
+};
+
+# endif /* WCHAR_T */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_NUMPUNCT_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/stl/_ostream.c b/sources/android/stlport/stlport/stl/_ostream.c
new file mode 100644
index 0000000..faba6c2
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_ostream.c
@@ -0,0 +1,455 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_OSTREAM_C
+#define _STLP_OSTREAM_C
+
+#ifndef _STLP_INTERNAL_OSTREAM_H
+# include <stl/_ostream.h>
+#endif
+
+#if !defined (_STLP_INTERNAL_NUM_PUT_H)
+# include <stl/_num_put.h> // For basic_streambuf and iterators
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//----------------------------------------------------------------------
+// Definitions of non-inline member functions.
+
+// Constructor, destructor
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>::basic_ostream(basic_streambuf<_CharT, _Traits>* __buf)
+ : basic_ios<_CharT, _Traits>() {
+ this->init(__buf);
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>::~basic_ostream()
+{}
+
+// Output directly from a streambuf.
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>&
+basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<_CharT, _Traits>* __from) {
+ sentry __sentry(*this);
+ if (__sentry) {
+ if (__from) {
+ bool __any_inserted = __from->gptr() != __from->egptr()
+ ? this->_M_copy_buffered(__from, this->rdbuf())
+ : this->_M_copy_unbuffered(__from, this->rdbuf());
+ if (!__any_inserted)
+ this->setstate(ios_base::failbit);
+ }
+ else
+ this->setstate(ios_base::badbit);
+ }
+
+ return *this;
+}
+
+// Helper functions for the streambuf version of operator<<. The
+// exception-handling code is complicated because exceptions thrown
+// while extracting characters are treated differently than exceptions
+// thrown while inserting characters.
+
+template <class _CharT, class _Traits>
+bool basic_ostream<_CharT, _Traits>
+ ::_M_copy_buffered(basic_streambuf<_CharT, _Traits>* __from,
+ basic_streambuf<_CharT, _Traits>* __to) {
+ bool __any_inserted = false;
+
+ while (__from->egptr() != __from->gptr()) {
+ const ptrdiff_t __avail = __from->egptr() - __from->gptr();
+
+ streamsize __nwritten;
+ _STLP_TRY {
+ __nwritten = __to->sputn(__from->gptr(), __avail);
+ __from->gbump((int)__nwritten);
+ }
+ _STLP_CATCH_ALL {
+ this->_M_handle_exception(ios_base::badbit);
+ return __any_inserted;
+ }
+
+ if (__nwritten == __avail) {
+ _STLP_TRY {
+ if (this->_S_eof(__from->sgetc()))
+ return true;
+ else
+ __any_inserted = true;
+ }
+ _STLP_CATCH_ALL {
+ this->_M_handle_exception(ios_base::failbit);
+ return false;
+ }
+ }
+ else if (__nwritten != 0)
+ return true;
+ else
+ return __any_inserted;
+ }
+
+ // No characters are in the buffer, but we aren't at EOF. Switch to
+ // unbuffered mode.
+ return __any_inserted || this->_M_copy_unbuffered(__from, __to);
+}
+
+/*
+ * Helper struct (guard) to put back a character in a streambuf
+ * whenever an exception or an eof occur.
+ */
+template <class _CharT, class _Traits>
+struct _SPutBackC {
+ typedef basic_streambuf<_CharT, _Traits> _StreamBuf;
+ typedef typename _StreamBuf::int_type int_type;
+ _SPutBackC(_StreamBuf *pfrom)
+ : __pfrom(pfrom), __c(0), __do_guard(false) {}
+ ~_SPutBackC() {
+ if (__do_guard) {
+ __pfrom->sputbackc(_Traits::to_char_type(__c));
+ }
+ }
+
+ void guard(int_type c) {
+ __c = c;
+ __do_guard = true;
+ }
+ void release() {
+ __do_guard = false;
+ }
+
+private:
+ _StreamBuf *__pfrom;
+ int_type __c;
+ bool __do_guard;
+};
+
+template <class _CharT, class _Traits>
+bool basic_ostream<_CharT, _Traits>
+ ::_M_copy_unbuffered(basic_streambuf<_CharT, _Traits>* __from,
+ basic_streambuf<_CharT, _Traits>* __to) {
+ typedef _SPutBackC<_CharT, _Traits> _SPutBackCGuard;
+ bool __any_inserted = false;
+ int_type __c;
+
+ _STLP_TRY {
+ _SPutBackCGuard __cguard(__from);
+ for (;;) {
+ _STLP_TRY {
+ __c = __from->sbumpc();
+ }
+ _STLP_CATCH_ALL {
+ this->_M_handle_exception(ios_base::failbit);
+ break;
+ }
+
+ if (this->_S_eof(__c))
+ break;
+
+ __cguard.guard(__c);
+#if defined (__DMC__)
+ _STLP_TRY {
+#endif
+ if (this->_S_eof(__to->sputc(_Traits::to_char_type(__c))))
+ break;
+
+#if defined (__DMC__)
+ }
+ _STLP_CATCH_ALL {
+ this->_M_handle_exception(ios_base::badbit);
+ break;
+ }
+#endif
+ __cguard.release();
+ __any_inserted = true;
+ }
+ }
+ _STLP_CATCH_ALL {
+ this->_M_handle_exception(ios_base::badbit);
+ }
+ return __any_inserted;
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Helper function for numeric output.
+template <class _CharT, class _Traits, class _Number>
+basic_ostream<_CharT, _Traits>& _STLP_CALL
+__put_num(basic_ostream<_CharT, _Traits>& __os, _Number __x) {
+ typedef typename basic_ostream<_CharT, _Traits>::sentry _Sentry;
+ _Sentry __sentry(__os);
+ bool __failed = true;
+
+ if (__sentry) {
+ _STLP_TRY {
+ typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > _NumPut;
+ __failed = (use_facet<_NumPut>(__os.getloc())).put(ostreambuf_iterator<_CharT, _Traits>(__os.rdbuf()),
+ __os, __os.fill(),
+ __x).failed();
+ }
+ _STLP_CATCH_ALL {
+ __os._M_handle_exception(ios_base::badbit);
+ }
+ }
+ if (__failed)
+ __os.setstate(ios_base::badbit);
+ return __os;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+/*
+ * In the following operators we try to limit code bloat by limiting the
+ * number of __put_num instanciations.
+ */
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(short __x) {
+ _STLP_STATIC_ASSERT( sizeof(short) <= sizeof(long) )
+ long __tmp = ((this->flags() & _Basic_ios::basefield) != ios_base::dec) ?
+ __STATIC_CAST(long, __STATIC_CAST(unsigned short, __x)): __x;
+ return _STLP_PRIV __put_num(*this, __tmp);
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned short __x) {
+ _STLP_STATIC_ASSERT( sizeof(unsigned short) <= sizeof(unsigned long) )
+ return _STLP_PRIV __put_num(*this, __STATIC_CAST(unsigned long,__x));
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(int __x) {
+ _STLP_STATIC_ASSERT( sizeof(int) <= sizeof(long) )
+ long __tmp = ((this->flags() & _Basic_ios::basefield) != ios_base::dec) ?
+ __STATIC_CAST(long, __STATIC_CAST(unsigned int, __x)): __x;
+ return _STLP_PRIV __put_num(*this, __tmp);
+}
+
+template <class _CharT, class _Traits>
+#if defined (_WIN64) || !defined (_STLP_MSVC) || (_STLP_MSVC < 1300)
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned int __x) {
+ _STLP_STATIC_ASSERT( sizeof(unsigned int) <= sizeof(unsigned long) )
+#else
+/* We define this operator with size_t rather than unsigned int to avoid
+ * 64 bits warning.
+ */
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(size_t __x) {
+ _STLP_STATIC_ASSERT( sizeof(size_t) <= sizeof(unsigned long) )
+#endif
+ return _STLP_PRIV __put_num(*this, __STATIC_CAST(unsigned long,__x));
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long __x)
+{ return _STLP_PRIV __put_num(*this, __x); }
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned long __x)
+{ return _STLP_PRIV __put_num(*this, __x); }
+
+#ifdef _STLP_LONG_LONG
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<< (_STLP_LONG_LONG __x)
+{ return _STLP_PRIV __put_num(*this, __x); }
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<< (unsigned _STLP_LONG_LONG __x)
+{ return _STLP_PRIV __put_num(*this, __x); }
+#endif
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(float __x)
+{ return _STLP_PRIV __put_num(*this, __STATIC_CAST(double,__x)); }
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(double __x)
+{ return _STLP_PRIV __put_num(*this, __x); }
+
+#ifndef _STLP_NO_LONG_DOUBLE
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long double __x)
+{ return _STLP_PRIV __put_num(*this, __x); }
+#endif
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(const void* __x)
+{ return _STLP_PRIV __put_num(*this, __x); }
+
+#ifndef _STLP_NO_BOOL
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(bool __x)
+{ return _STLP_PRIV __put_num(*this, __x); }
+#endif
+
+template <class _CharT, class _Traits>
+void basic_ostream<_CharT, _Traits>::_M_put_char(_CharT __c) {
+ sentry __sentry(*this);
+ if (__sentry) {
+ bool __failed = true;
+ _STLP_TRY {
+ streamsize __npad = this->width() > 0 ? this->width() - 1 : 0;
+ // if (__npad <= 1)
+ if (__npad == 0)
+ __failed = this->_S_eof(this->rdbuf()->sputc(__c));
+ else if ((this->flags() & ios_base::adjustfield) == ios_base::left) {
+ __failed = this->_S_eof(this->rdbuf()->sputc(__c));
+ __failed = __failed ||
+ this->rdbuf()->_M_sputnc(this->fill(), __npad) != __npad;
+ }
+ else {
+ __failed = this->rdbuf()->_M_sputnc(this->fill(), __npad) != __npad;
+ __failed = __failed || this->_S_eof(this->rdbuf()->sputc(__c));
+ }
+
+ this->width(0);
+ }
+ _STLP_CATCH_ALL {
+ this->_M_handle_exception(ios_base::badbit);
+ }
+
+ if (__failed)
+ this->setstate(ios_base::badbit);
+ }
+}
+
+template <class _CharT, class _Traits>
+void basic_ostream<_CharT, _Traits>::_M_put_nowiden(const _CharT* __s) {
+ sentry __sentry(*this);
+ if (__sentry) {
+ bool __failed = true;
+ streamsize __n = _Traits::length(__s);
+ streamsize __npad = this->width() > __n ? this->width() - __n : 0;
+
+ _STLP_TRY {
+ if (__npad == 0)
+ __failed = this->rdbuf()->sputn(__s, __n) != __n;
+ else if ((this->flags() & ios_base::adjustfield) == ios_base::left) {
+ __failed = this->rdbuf()->sputn(__s, __n) != __n;
+ __failed = __failed ||
+ this->rdbuf()->_M_sputnc(this->fill(), __npad) != __npad;
+ }
+ else {
+ __failed = this->rdbuf()->_M_sputnc(this->fill(), __npad) != __npad;
+ __failed = __failed || this->rdbuf()->sputn(__s, __n) != __n;
+ }
+
+ this->width(0);
+ }
+ _STLP_CATCH_ALL {
+ this->_M_handle_exception(ios_base::badbit);
+ }
+
+ if (__failed)
+ this->setstate(ios_base::failbit);
+ }
+}
+
+template <class _CharT, class _Traits>
+void basic_ostream<_CharT, _Traits>::_M_put_widen(const char* __s) {
+ sentry __sentry(*this);
+ if (__sentry) {
+ bool __failed = true;
+ streamsize __n = char_traits<char>::length(__s);
+ streamsize __npad = this->width() > __n ? this->width() - __n : 0;
+
+ _STLP_TRY {
+ if (__npad == 0)
+ __failed = !this->_M_put_widen_aux(__s, __n);
+ else if ((this->flags() & ios_base::adjustfield) == ios_base::left) {
+ __failed = !this->_M_put_widen_aux(__s, __n);
+ __failed = __failed ||
+ this->rdbuf()->_M_sputnc(this->fill(), __npad) != __npad;
+ }
+ else {
+ __failed = this->rdbuf()->_M_sputnc(this->fill(), __npad) != __npad;
+ __failed = __failed || !this->_M_put_widen_aux(__s, __n);
+ }
+
+ this->width(0);
+ }
+ _STLP_CATCH_ALL {
+ this->_M_handle_exception(ios_base::badbit);
+ }
+
+ if (__failed)
+ this->setstate(ios_base::failbit);
+ }
+}
+
+template <class _CharT, class _Traits>
+bool basic_ostream<_CharT, _Traits>::_M_put_widen_aux(const char* __s,
+ streamsize __n) {
+ basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
+
+ for ( ; __n > 0 ; --__n)
+ if (this->_S_eof(__buf->sputc(this->widen(*__s++))))
+ return false;
+ return true;
+}
+
+// Unformatted output of a single character.
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>&
+basic_ostream<_CharT, _Traits>::put(char_type __c) {
+ sentry __sentry(*this);
+ bool __failed = true;
+
+ if (__sentry) {
+ _STLP_TRY {
+ __failed = this->_S_eof(this->rdbuf()->sputc(__c));
+ }
+ _STLP_CATCH_ALL {
+ this->_M_handle_exception(ios_base::badbit);
+ }
+ }
+
+ if (__failed)
+ this->setstate(ios_base::badbit);
+
+ return *this;
+}
+
+// Unformatted output of a single character.
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>&
+basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n) {
+ sentry __sentry(*this);
+ bool __failed = true;
+
+ if (__sentry) {
+ _STLP_TRY {
+ __failed = this->rdbuf()->sputn(__s, __n) != __n;
+ }
+ _STLP_CATCH_ALL {
+ this->_M_handle_exception(ios_base::badbit);
+ }
+ }
+
+ if (__failed)
+ this->setstate(ios_base::badbit);
+
+ return *this;
+}
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_OSTREAM_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_ostream.h b/sources/android/stlport/stlport/stl/_ostream.h
new file mode 100644
index 0000000..3335b66
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_ostream.h
@@ -0,0 +1,387 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+
+#ifndef _STLP_INTERNAL_OSTREAM_H
+#define _STLP_INTERNAL_OSTREAM_H
+
+#ifndef _STLP_INTERNAL_IOS_H
+# include <stl/_ios.h> // For basic_ios<>. Includes <iosfwd>.
+#endif
+
+#ifndef _STLP_INTERNAL_OSTREAMBUF_ITERATOR_H
+# include <stl/_ostreambuf_iterator.h>
+#endif
+
+#if !defined (_STLP_NO_UNCAUGHT_EXCEPT_SUPPORT) && !defined (_STLP_INTERNAL_EXCEPTION)
+# include <stl/_exception.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+template <class _CharT, class _Traits>
+class _Osentry;
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _CharT, class _Traits>
+bool __init_bostr(basic_ostream<_CharT, _Traits>& __str);
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+//----------------------------------------------------------------------
+// class basic_ostream<>
+
+template <class _CharT, class _Traits>
+class basic_ostream : virtual public basic_ios<_CharT, _Traits> {
+ typedef basic_ostream<_CharT, _Traits> _Self;
+
+#if defined (_STLP_MSVC) && (_STLP_MSVC >= 1300 && _STLP_MSVC <= 1310)
+ //explicitely defined as private to avoid warnings:
+ basic_ostream(_Self const&);
+ _Self& operator = (_Self const&);
+#endif
+
+public: // Types
+ typedef _CharT char_type;
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+ typedef _Traits traits_type;
+ typedef basic_ios<_CharT, _Traits> _Basic_ios;
+
+public: // Constructor and destructor.
+ explicit basic_ostream(basic_streambuf<_CharT, _Traits>* __buf);
+ ~basic_ostream();
+
+public: // Hooks for manipulators.
+ typedef basic_ios<_CharT, _Traits>& (_STLP_CALL *__ios_fn)(basic_ios<_CharT, _Traits>&);
+ typedef ios_base& (_STLP_CALL *__ios_base_fn)(ios_base&);
+ typedef _Self& (_STLP_CALL *__ostream_fn)(_Self&);
+ _Self& operator<< (__ostream_fn __f) { return __f(*this); }
+ _Self & operator<< (__ios_base_fn __f) { __f(*this); return *this; }
+ _Self& operator<< (__ios_fn __ff) { __ff(*this); return *this; }
+
+private:
+ bool _M_copy_buffered(basic_streambuf<_CharT, _Traits>* __from,
+ basic_streambuf<_CharT, _Traits>* __to);
+ bool _M_copy_unbuffered(basic_streambuf<_CharT, _Traits>* __from,
+ basic_streambuf<_CharT, _Traits>* __to);
+
+public:
+ void _M_put_char(_CharT __c);
+
+ void _M_put_nowiden(const _CharT* __s);
+ void _M_put_widen(const char* __s);
+ bool _M_put_widen_aux(const char* __s, streamsize __n);
+
+public: // Unformatted output.
+ _Self& put(char_type __c);
+ _Self& write(const char_type* __s, streamsize __n);
+
+public: // Formatted output.
+ // Formatted output from a streambuf.
+ _Self& operator<<(basic_streambuf<_CharT, _Traits>* __buf);
+# ifndef _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER
+ // this is needed for compiling with option char = unsigned
+ _Self& operator<<(unsigned char __x) { _M_put_char(__x); return *this; }
+# endif
+ _Self& operator<<(short __x);
+ _Self& operator<<(unsigned short __x);
+ _Self& operator<<(int __x);
+#if defined (_WIN64) || !defined (_STLP_MSVC) || (_STLP_MSVC < 1300)
+ _Self& operator<<(unsigned int __x);
+#else
+/* We define this operator with size_t rather than unsigned int to avoid
+ * 64 bits warning.
+ */
+ _Self& operator<<(size_t __x);
+#endif
+ _Self& operator<<(long __x);
+ _Self& operator<<(unsigned long __x);
+#ifdef _STLP_LONG_LONG
+ _Self& operator<< (_STLP_LONG_LONG __x);
+ _Self& operator<< (unsigned _STLP_LONG_LONG __x);
+#endif
+ _Self& operator<<(float __x);
+ _Self& operator<<(double __x);
+# ifndef _STLP_NO_LONG_DOUBLE
+ _Self& operator<<(long double __x);
+# endif
+ _Self& operator<<(const void* __x);
+# ifndef _STLP_NO_BOOL
+ _Self& operator<<(bool __x);
+# endif
+
+public: // Buffer positioning and manipulation.
+ _Self& flush() {
+ if (this->rdbuf())
+ if (this->rdbuf()->pubsync() == -1)
+ this->setstate(ios_base::badbit);
+ return *this;
+ }
+
+ pos_type tellp() {
+ return this->rdbuf() && !this->fail()
+ ? this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out)
+ : pos_type(-1);
+ }
+
+ _Self& seekp(pos_type __pos) {
+ if (this->rdbuf() && !this->fail()) {
+ if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1)) {
+ this->setstate(ios_base::failbit);
+ }
+ }
+ return *this;
+ }
+
+ _Self& seekp(off_type __off, ios_base::seekdir __dir) {
+ if (this->rdbuf() && !this->fail())
+ this->rdbuf()->pubseekoff(__off, __dir, ios_base::out);
+ return *this;
+ }
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+ // If we are using DLL specs, we have not to use inner classes
+ // end class declaration here
+ typedef _Osentry<_CharT, _Traits> sentry;
+};
+# define sentry _Osentry
+ template <class _CharT, class _Traits>
+ class _Osentry {
+ typedef _Osentry<_CharT, _Traits> _Self;
+#else
+ class sentry {
+ typedef sentry _Self;
+#endif
+ private:
+ basic_ostream<_CharT, _Traits>& _M_str;
+ // basic_streambuf<_CharT, _Traits>* _M_buf;
+ bool _M_ok;
+ public:
+ explicit sentry(basic_ostream<_CharT, _Traits>& __str)
+ : _M_str(__str), /* _M_buf(__str.rdbuf()), */ _M_ok(_STLP_PRIV __init_bostr(__str))
+ {}
+
+ ~sentry() {
+ if (_M_str.flags() & ios_base::unitbuf)
+#if !defined (_STLP_NO_UNCAUGHT_EXCEPT_SUPPORT)
+ if (!uncaught_exception())
+#endif
+ _M_str.flush();
+ }
+
+ operator bool() const { return _M_ok; }
+ private: // Disable assignment and copy constructor.
+ //Implementation is here only to avoid warning with some compilers.
+ sentry(const _Self& __s) : _M_str(__s._M_str) {}
+ _Self& operator=(const _Self&) { return *this; }
+ };
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+# undef sentry
+#else
+ // close basic_ostream class definition here
+};
+#endif
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS basic_ostream<char, char_traits<char> >;
+_STLP_EXPORT_TEMPLATE_CLASS _Osentry<char, char_traits<char> >;
+# if !defined (_STLP_NO_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS basic_ostream<wchar_t, char_traits<wchar_t> >;
+_STLP_EXPORT_TEMPLATE_CLASS _Osentry<wchar_t, char_traits<wchar_t> >;
+# endif
+#endif /* _STLP_USE_TEMPLATE_EXPORT */
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Helper functions for istream<>::sentry constructor.
+template <class _CharT, class _Traits>
+bool __init_bostr(basic_ostream<_CharT, _Traits>& __str) {
+ if (__str.good()) {
+ // boris : check if this is needed !
+ if (!__str.rdbuf())
+ __str.setstate(ios_base::badbit);
+ if (__str.tie())
+ __str.tie()->flush();
+ return __str.good();
+ }
+ else
+ return false;
+}
+
+template <class _CharT, class _Traits>
+inline basic_streambuf<_CharT, _Traits>* _STLP_CALL
+__get_ostreambuf(basic_ostream<_CharT, _Traits>& __St)
+{ return __St.rdbuf(); }
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+// Non-member functions.
+template <class _CharT, class _Traits>
+inline basic_ostream<_CharT, _Traits>& _STLP_CALL
+operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c){
+ __os._M_put_char(__c);
+ return __os;
+}
+
+template <class _CharT, class _Traits>
+inline basic_ostream<_CharT, _Traits>& _STLP_CALL
+operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __s) {
+ __os._M_put_nowiden(__s);
+ return __os;
+}
+
+#if defined (_STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER)
+// some specializations
+
+inline basic_ostream<char, char_traits<char> >& _STLP_CALL
+operator<<(basic_ostream<char, char_traits<char> >& __os, char __c) {
+ __os._M_put_char(__c);
+ return __os;
+}
+
+inline basic_ostream<char, char_traits<char> >& _STLP_CALL
+operator<<(basic_ostream<char, char_traits<char> >& __os, signed char __c) {
+ __os._M_put_char(__c);
+ return __os;
+}
+
+inline basic_ostream<char, char_traits<char> >& _STLP_CALL
+operator<<(basic_ostream<char, char_traits<char> >& __os, unsigned char __c) {
+ __os._M_put_char(__c);
+ return __os;
+}
+
+inline basic_ostream<char, char_traits<char> >& _STLP_CALL
+operator<<(basic_ostream<char, char_traits<char> >& __os, const char* __s) {
+ __os._M_put_nowiden(__s);
+ return __os;
+}
+
+inline basic_ostream<char, char_traits<char> >& _STLP_CALL
+operator<<(basic_ostream<char, char_traits<char> >& __os, const signed char* __s) {
+ __os._M_put_nowiden(__REINTERPRET_CAST(const char*,__s));
+ return __os;
+}
+
+inline basic_ostream<char, char_traits<char> >&
+operator<<(basic_ostream<char, char_traits<char> >& __os, const unsigned char* __s) {
+ __os._M_put_nowiden(__REINTERPRET_CAST(const char*,__s));
+ return __os;
+}
+
+#else
+
+// also for compilers who might use that
+template <class _CharT, class _Traits>
+inline basic_ostream<_CharT, _Traits>& _STLP_CALL
+operator<<(basic_ostream<_CharT, _Traits>& __os, char __c) {
+ __os._M_put_char(__os.widen(__c));
+ return __os;
+}
+
+template <class _Traits>
+inline basic_ostream<char, _Traits>& _STLP_CALL
+operator<<(basic_ostream<char, _Traits>& __os, char __c) {
+ __os._M_put_char(__c);
+ return __os;
+}
+
+template <class _Traits>
+inline basic_ostream<char, _Traits>& _STLP_CALL
+operator<<(basic_ostream<char, _Traits>& __os, signed char __c) {
+ __os._M_put_char(__c);
+ return __os;
+}
+
+template <class _Traits>
+inline basic_ostream<char, _Traits>& _STLP_CALL
+operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c) {
+ __os._M_put_char(__c);
+ return __os;
+}
+
+template <class _CharT, class _Traits>
+inline basic_ostream<_CharT, _Traits>& _STLP_CALL
+operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __s) {
+ __os._M_put_widen(__s);
+ return __os;
+}
+
+template <class _Traits>
+inline basic_ostream<char, _Traits>& _STLP_CALL
+operator<<(basic_ostream<char, _Traits>& __os, const char* __s) {
+ __os._M_put_nowiden(__s);
+ return __os;
+}
+
+template <class _Traits>
+inline basic_ostream<char, _Traits>& _STLP_CALL
+operator<<(basic_ostream<char, _Traits>& __os, const signed char* __s) {
+ __os._M_put_nowiden(__REINTERPRET_CAST(const char*,__s));
+ return __os;
+}
+
+template <class _Traits>
+inline basic_ostream<char, _Traits>&
+operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __s) {
+ __os._M_put_nowiden(__REINTERPRET_CAST(const char*,__s));
+ return __os;
+}
+#endif /* _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER */
+
+//----------------------------------------------------------------------
+// basic_ostream manipulators.
+
+template <class _CharT, class _Traits>
+inline basic_ostream<_CharT, _Traits>& _STLP_CALL
+endl(basic_ostream<_CharT, _Traits>& __os) {
+ __os.put(__os.widen('\n'));
+ __os.flush();
+ return __os;
+}
+
+template <class _CharT, class _Traits>
+inline basic_ostream<_CharT, _Traits>& _STLP_CALL
+ends(basic_ostream<_CharT, _Traits>& __os) {
+ __os.put(_STLP_DEFAULT_CONSTRUCTED(_CharT));
+ return __os;
+}
+
+template <class _CharT, class _Traits>
+inline basic_ostream<_CharT, _Traits>& _STLP_CALL
+flush(basic_ostream<_CharT, _Traits>& __os) {
+ __os.flush();
+ return __os;
+}
+
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_ostream.c>
+#endif
+
+#endif /* _STLP_INTERNAL_OSTREAM_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_ostreambuf_iterator.h b/sources/android/stlport/stlport/stl/_ostreambuf_iterator.h
new file mode 100644
index 0000000..d886549
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_ostreambuf_iterator.h
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+// WARNING: This is an internal header file, included by other C++
+// standard library headers. You should not attempt to use this header
+// file directly.
+
+
+#ifndef _STLP_INTERNAL_OSTREAMBUF_ITERATOR_H
+#define _STLP_INTERNAL_OSTREAMBUF_ITERATOR_H
+
+#ifndef _STLP_INTERNAL_STREAMBUF
+# include <stl/_streambuf.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template<class _CharT, class _Traits>
+extern basic_streambuf<_CharT, _Traits>* _STLP_CALL __get_ostreambuf(basic_ostream<_CharT, _Traits>&);
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+// The default template argument is declared in iosfwd
+template <class _CharT, class _Traits>
+class ostreambuf_iterator :
+ public iterator<output_iterator_tag, void, void, void, void> {
+public:
+ typedef _CharT char_type;
+ typedef _Traits traits_type;
+ typedef typename _Traits::int_type int_type;
+ typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+ typedef basic_ostream<_CharT, _Traits> ostream_type;
+
+ typedef output_iterator_tag iterator_category;
+ typedef void value_type;
+ typedef void difference_type;
+ typedef void pointer;
+ typedef void reference;
+
+public:
+ ostreambuf_iterator(streambuf_type* __buf) _STLP_NOTHROW : _M_buf(__buf), _M_ok(__buf!=0) {}
+ // ostreambuf_iterator(ostream_type& __o) _STLP_NOTHROW : _M_buf(__get_ostreambuf(__o)), _M_ok(_M_buf != 0) {}
+ inline ostreambuf_iterator(ostream_type& __o) _STLP_NOTHROW;
+
+ ostreambuf_iterator<_CharT, _Traits>& operator=(char_type __c) {
+ _M_ok = _M_ok && !traits_type::eq_int_type(_M_buf->sputc(__c),
+ traits_type::eof());
+ return *this;
+ }
+
+ ostreambuf_iterator<_CharT, _Traits>& operator*() { return *this; }
+ ostreambuf_iterator<_CharT, _Traits>& operator++() { return *this; }
+ ostreambuf_iterator<_CharT, _Traits>& operator++(int) { return *this; }
+
+ bool failed() const { return !_M_ok; }
+
+private:
+ streambuf_type* _M_buf;
+ bool _M_ok;
+};
+
+template <class _CharT, class _Traits>
+inline ostreambuf_iterator<_CharT, _Traits>::ostreambuf_iterator(basic_ostream<_CharT, _Traits>& __o) _STLP_NOTHROW
+ : _M_buf(_STLP_PRIV __get_ostreambuf(__o)), _M_ok(_M_buf != 0) {}
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS ostreambuf_iterator<char, char_traits<char> >;
+# if defined (INSTANTIATE_WIDE_STREAMS)
+_STLP_EXPORT_TEMPLATE_CLASS ostreambuf_iterator<wchar_t, char_traits<wchar_t> >;
+# endif
+#endif /* _STLP_USE_TEMPLATE_EXPORT */
+
+#if defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
+template <class _CharT, class _Traits>
+inline output_iterator_tag _STLP_CALL
+iterator_category(const ostreambuf_iterator<_CharT, _Traits>&) { return output_iterator_tag(); }
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_OSTREAMBUF_ITERATOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/stl/_pair.h b/sources/android/stlport/stlport/stl/_pair.h
new file mode 100644
index 0000000..de0b08e
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_pair.h
@@ -0,0 +1,186 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_PAIR_H
+#define _STLP_INTERNAL_PAIR_H
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+# ifndef _STLP_TYPE_TRAITS_H
+# include <stl/type_traits.h>
+# endif
+
+# if !defined (_STLP_MOVE_CONSTRUCT_FWK_H) && !defined (_STLP_NO_MOVE_SEMANTIC)
+# include <stl/_move_construct_fwk.h>
+# endif
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (ANDROID)
+/* Android has stl_pair.h, prevent using it by defining the header guard. */
+# define __SGI_STL_INTERNAL_PAIR_H
+#endif
+template <class _T1, class _T2>
+struct pair {
+ typedef _T1 first_type;
+ typedef _T2 second_type;
+
+ _T1 first;
+ _T2 second;
+#if defined (_STLP_CONST_CONSTRUCTOR_BUG)
+ pair() {}
+#else
+ pair() : first(_T1()), second(_T2()) {}
+#endif
+ pair(const _T1& __a, const _T2& __b) : first(__a), second(__b) {}
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _U1, class _U2>
+ pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {}
+
+ pair(const pair<_T1,_T2>& __o) : first(__o.first), second(__o.second) {}
+#endif
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ pair(__move_source<pair<_T1, _T2> > src) : first(_STLP_PRIV _AsMoveSource(src.get().first)),
+ second(_STLP_PRIV _AsMoveSource(src.get().second))
+ {}
+#endif
+
+ __TRIVIAL_DESTRUCTOR(pair)
+};
+
+template <class _T1, class _T2>
+inline bool _STLP_CALL operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+{ return __x.first == __y.first && __x.second == __y.second; }
+
+template <class _T1, class _T2>
+inline bool _STLP_CALL operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) {
+ return __x.first < __y.first ||
+ (!(__y.first < __x.first) && __x.second < __y.second);
+}
+
+#if defined (_STLP_USE_SEPARATE_RELOPS_NAMESPACE)
+template <class _T1, class _T2>
+inline bool _STLP_CALL operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+{ return !(__x == __y); }
+
+template <class _T1, class _T2>
+inline bool _STLP_CALL operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+{ return __y < __x; }
+
+template <class _T1, class _T2>
+inline bool _STLP_CALL operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+{ return !(__y < __x); }
+
+template <class _T1, class _T2>
+inline bool _STLP_CALL operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+{ return !(__x < __y); }
+#endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
+
+#if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) && !defined (_STLP_NO_EXTENSIONS)
+template <class _T1, class _T2, int _Sz>
+inline pair<_T1, _T2 const*> make_pair(_T1 const& __x,
+ _T2 const (&__y)[_Sz])
+{ return pair<_T1, _T2 const*>(__x, static_cast<_T2 const*>(__y)); }
+
+template <class _T1, class _T2, int _Sz>
+inline pair<_T1 const*, _T2> make_pair(_T1 const (&__x)[_Sz],
+ _T2 const& __y)
+{ return pair<_T1 const*, _T2>(static_cast<_T1 const*>(__x), __y); }
+
+template <class _T1, class _T2, int _Sz1, int _Sz2>
+inline pair<_T1 const*, _T2 const*> make_pair(_T1 const (&__x)[_Sz1],
+ _T2 const (&__y)[_Sz2]) {
+ return pair<_T1 const*, _T2 const*>(static_cast<_T1 const*>(__x),
+ static_cast<_T2 const*>(__y));
+}
+#endif
+
+template <class _T1, class _T2>
+inline pair<_T1, _T2> _STLP_CALL make_pair(_T1 __x, _T2 __y)
+{ return pair<_T1, _T2>(__x, __y); }
+
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_USE_NAMESPACES) || !defined (_STLP_USE_SEPARATE_RELOPS_NAMESPACE)
+_STLP_BEGIN_RELOPS_NAMESPACE
+
+template <class _Tp>
+inline bool _STLP_CALL operator!=(const _Tp& __x, const _Tp& __y)
+{ return !(__x == __y); }
+
+template <class _Tp>
+inline bool _STLP_CALL operator>(const _Tp& __x, const _Tp& __y)
+{ return __y < __x; }
+
+template <class _Tp>
+inline bool _STLP_CALL operator<=(const _Tp& __x, const _Tp& __y)
+{ return !(__y < __x); }
+
+template <class _Tp>
+inline bool _STLP_CALL operator>=(const _Tp& __x, const _Tp& __y)
+{ return !(__x < __y); }
+
+_STLP_END_RELOPS_NAMESPACE
+#endif
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+_STLP_BEGIN_NAMESPACE
+
+template <class _T1, class _T2>
+struct __type_traits<pair<_T1, _T2> > {
+ typedef __type_traits<_T1> _T1Traits;
+ typedef __type_traits<_T2> _T2Traits;
+ typedef typename _Land2<typename _T1Traits::has_trivial_default_constructor,
+ typename _T2Traits::has_trivial_default_constructor>::_Ret has_trivial_default_constructor;
+ typedef typename _Land2<typename _T1Traits::has_trivial_copy_constructor,
+ typename _T2Traits::has_trivial_copy_constructor>::_Ret has_trivial_copy_constructor;
+ typedef typename _Land2<typename _T1Traits::has_trivial_assignment_operator,
+ typename _T2Traits::has_trivial_assignment_operator>::_Ret has_trivial_assignment_operator;
+ typedef typename _Land2<typename _T1Traits::has_trivial_destructor,
+ typename _T2Traits::has_trivial_destructor>::_Ret has_trivial_destructor;
+ typedef __false_type is_POD_type;
+};
+
+# if !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _T1, class _T2>
+struct __move_traits<pair<_T1, _T2> >
+ : _STLP_PRIV __move_traits_help1<_T1, _T2> {};
+# endif
+
+_STLP_END_NAMESPACE
+#endif
+
+#endif /* _STLP_INTERNAL_PAIR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_prolog.h b/sources/android/stlport/stlport/stl/_prolog.h
new file mode 100644
index 0000000..9705c2c
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_prolog.h
@@ -0,0 +1,18 @@
+/* NOTE : this header has no guards and is MEANT for multiple inclusion!
+ * If you are using "header protection" option with your compiler,
+ * please also find #pragma which disables it and put it here, to
+ * allow reentrancy of this header.
+ */
+
+#include <stl/_cprolog.h>
+
+/* Get all debug things, potentially only empty macros if none of
+ * the debug features available in user config file is activated. */
+ /* Thanks to _STLP_OUTERMOST_HEADER_ID we hide _debug.h when C standard
+ * headers are included as some platforms (Win32) include C standard headers
+ * in an 'extern "C"' scope which do not accept the templates exposed
+ * in _debug.h. */
+#if defined (__cplusplus) && !defined (_STLP_DEBUG_H) && \
+ !((_STLP_OUTERMOST_HEADER_ID >= 0x200) && (_STLP_OUTERMOST_HEADER_ID <= 0x300))
+# include <stl/debug/_debug.h>
+#endif
diff --git a/sources/android/stlport/stlport/stl/_pthread_alloc.h b/sources/android/stlport/stlport/stl/_pthread_alloc.h
new file mode 100644
index 0000000..f45d949
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_pthread_alloc.h
@@ -0,0 +1,461 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_PTHREAD_ALLOC_H
+#define _STLP_PTHREAD_ALLOC_H
+
+/*
+ * Pthread-specific node allocator.
+ * This is similar to the default allocator, except that free-list
+ * information is kept separately for each thread, avoiding locking.
+ * This should be reasonably fast even in the presence of threads.
+ * The down side is that storage may not be well-utilized.
+ * It is not an error to allocate memory in thread A and deallocate
+ * it in thread B. But this effectively transfers ownership of the memory,
+ * so that it can only be reallocated by thread B. Thus this can effectively
+ * result in a storage leak if it's done on a regular basis.
+ * It can also result in frequent sharing of
+ * cache lines among processors, with potentially serious performance
+ * consequences.
+ */
+
+#if !defined (_STLP_PTHREADS)
+# error POSIX specific allocator implementation. Your system do not seems to \
+have this interface so please comment the _STLP_USE_PERTHREAD_ALLOC macro \
+or report to the STLport forum.
+#endif
+
+#if defined (_STLP_USE_NO_IOSTREAMS)
+# error You cannot use per thread allocator implementation without building \
+STLport libraries.
+#endif
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+# include <stl/_alloc.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+struct _Pthread_alloc_per_thread_state;
+
+// Pthread-specific allocator.
+class _STLP_CLASS_DECLSPEC _Pthread_alloc {
+public: // but only for internal use:
+ typedef _Pthread_alloc_per_thread_state __state_type;
+ typedef char value_type;
+
+public:
+ // Return a recycled or new per thread state.
+ static __state_type * _STLP_CALL _S_get_per_thread_state();
+
+ /* n must be > 0 */
+ static void * _STLP_CALL allocate(size_t& __n);
+
+ /* p may not be 0 */
+ static void _STLP_CALL deallocate(void *__p, size_t __n);
+
+ // boris : versions for per_thread_allocator
+ /* n must be > 0 */
+ static void * _STLP_CALL allocate(size_t& __n, __state_type* __a);
+
+ /* p may not be 0 */
+ static void _STLP_CALL deallocate(void *__p, size_t __n, __state_type* __a);
+
+ static void * _STLP_CALL reallocate(void *__p, size_t __old_sz, size_t& __new_sz);
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+typedef _STLP_PRIV _Pthread_alloc __pthread_alloc;
+typedef __pthread_alloc pthread_alloc;
+
+template <class _Tp>
+class pthread_allocator : public __stlport_class<pthread_allocator<_Tp> > {
+ typedef pthread_alloc _S_Alloc; // The underlying allocator.
+public:
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef _Tp* pointer;
+ typedef const _Tp* const_pointer;
+ typedef _Tp& reference;
+ typedef const _Tp& const_reference;
+ typedef _Tp value_type;
+
+#ifdef _STLP_MEMBER_TEMPLATE_CLASSES
+ template <class _NewType> struct rebind {
+ typedef pthread_allocator<_NewType> other;
+ };
+#endif
+
+ pthread_allocator() _STLP_NOTHROW {}
+ pthread_allocator(const pthread_allocator<_Tp>& a) _STLP_NOTHROW {}
+
+#if defined (_STLP_MEMBER_TEMPLATES) /* && defined (_STLP_FUNCTION_PARTIAL_ORDER) */
+ template <class _OtherType> pthread_allocator(const pthread_allocator<_OtherType>&)
+ _STLP_NOTHROW {}
+#endif
+
+ ~pthread_allocator() _STLP_NOTHROW {}
+
+ pointer address(reference __x) const { return &__x; }
+ const_pointer address(const_reference __x) const { return &__x; }
+
+ // __n is permitted to be 0. The C++ standard says nothing about what
+ // the return value is when __n == 0.
+ _Tp* allocate(size_type __n, const void* = 0) {
+ if (__n > max_size()) {
+ _STLP_THROW_BAD_ALLOC;
+ }
+ if (__n != 0) {
+ size_type __buf_size = __n * sizeof(value_type);
+ _Tp* __ret = __REINTERPRET_CAST(value_type*, _S_Alloc::allocate(__buf_size));
+#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)
+ memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);
+#endif
+ return __ret;
+ }
+ else
+ return 0;
+ }
+
+ void deallocate(pointer __p, size_type __n) {
+ _STLP_ASSERT( (__p == 0) == (__n == 0) )
+ if (__p != 0) {
+#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)
+ memset((char*)__p, _STLP_SHRED_BYTE, __n * sizeof(value_type));
+#endif
+ _S_Alloc::deallocate(__p, __n * sizeof(value_type));
+ }
+ }
+
+ size_type max_size() const _STLP_NOTHROW
+ { return size_t(-1) / sizeof(_Tp); }
+
+ void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }
+ void destroy(pointer _p) { _p->~_Tp(); }
+
+#if defined (_STLP_NO_EXTENSIONS)
+ /* STLport extension giving rounded size of an allocated memory buffer
+ * This method do not have to be part of a user defined allocator implementation
+ * and won't even be called if such a function was granted.
+ */
+protected:
+#endif
+ _Tp* allocate(size_type __n, size_type& __allocated_n) {
+ if (__n > max_size()) {
+ _STLP_THROW_BAD_ALLOC;
+ }
+ if (__n != 0) {
+ size_type __buf_size = __n * sizeof(value_type);
+ _Tp* __ret = __REINTERPRET_CAST(value_type*, _S_Alloc::allocate(__buf_size));
+#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)
+ memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);
+#endif
+ __allocated_n = __buf_size / sizeof(value_type);
+ return __ret;
+ }
+ else
+ return 0;
+ }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(pthread_allocator<_Tp>& __x) {}
+#endif
+};
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC pthread_allocator<void> {
+public:
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef void* pointer;
+ typedef const void* const_pointer;
+ typedef void value_type;
+#ifdef _STLP_MEMBER_TEMPLATE_CLASSES
+ template <class _NewType> struct rebind {
+ typedef pthread_allocator<_NewType> other;
+ };
+#endif
+};
+
+template <class _T1, class _T2>
+inline bool operator==(const pthread_allocator<_T1>&,
+ const pthread_allocator<_T2>& a2)
+{ return true; }
+
+#ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER
+template <class _T1, class _T2>
+inline bool operator!=(const pthread_allocator<_T1>&,
+ const pthread_allocator<_T2>&)
+{ return false; }
+#endif
+
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+
+template <class _Tp, class _Atype>
+struct _Alloc_traits<_Tp, pthread_allocator<_Atype> >
+{ typedef pthread_allocator<_Tp> allocator_type; };
+
+#endif
+
+#if defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)
+
+template <class _Tp1, class _Tp2>
+inline pthread_allocator<_Tp2>&
+__stl_alloc_rebind(pthread_allocator<_Tp1>& __x, const _Tp2*)
+{ return (pthread_allocator<_Tp2>&)__x; }
+
+template <class _Tp1, class _Tp2>
+inline pthread_allocator<_Tp2>
+__stl_alloc_create(pthread_allocator<_Tp1>&, const _Tp2*)
+{ return pthread_allocator<_Tp2>(); }
+
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp>
+struct __pthread_alloc_type_traits {
+ typedef typename _IsSTLportClass<pthread_allocator<_Tp> >::_Ret _STLportAlloc;
+ //The default allocator implementation which is recognize thanks to the
+ //__stlport_class inheritance is a stateless object so:
+ typedef _STLportAlloc has_trivial_default_constructor;
+ typedef _STLportAlloc has_trivial_copy_constructor;
+ typedef _STLportAlloc has_trivial_assignment_operator;
+ typedef _STLportAlloc has_trivial_destructor;
+ typedef _STLportAlloc is_POD_type;
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+template <class _Tp>
+struct __type_traits<pthread_allocator<_Tp> > : _STLP_PRIV __pthread_alloc_type_traits<_Tp> {};
+#else
+_STLP_TEMPLATE_NULL
+struct __type_traits<pthread_allocator<char> > : _STLP_PRIV __pthread_alloc_type_traits<char> {};
+# if defined (_STLP_HAS_WCHAR_T)
+_STLP_TEMPLATE_NULL
+struct __type_traits<pthread_allocator<wchar_t> > : _STLP_PRIV __pthread_alloc_type_traits<wchar_t> {};
+# endif
+# if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+_STLP_TEMPLATE_NULL
+struct __type_traits<pthread_allocator<void*> > : _STLP_PRIV __pthread_alloc_type_traits<void*> {};
+# endif
+#endif
+
+//
+// per_thread_allocator<> : this allocator always return memory to the same thread
+// it was allocated from.
+//
+
+template <class _Tp>
+class per_thread_allocator {
+ typedef pthread_alloc _S_Alloc; // The underlying allocator.
+ typedef pthread_alloc::__state_type __state_type;
+public:
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef _Tp* pointer;
+ typedef const _Tp* const_pointer;
+ typedef _Tp& reference;
+ typedef const _Tp& const_reference;
+ typedef _Tp value_type;
+
+#ifdef _STLP_MEMBER_TEMPLATE_CLASSES
+ template <class _NewType> struct rebind {
+ typedef per_thread_allocator<_NewType> other;
+ };
+#endif
+
+ per_thread_allocator() _STLP_NOTHROW {
+ _M_state = _S_Alloc::_S_get_per_thread_state();
+ }
+ per_thread_allocator(const per_thread_allocator<_Tp>& __a) _STLP_NOTHROW : _M_state(__a._M_state){}
+
+#if defined (_STLP_MEMBER_TEMPLATES) /* && defined (_STLP_FUNCTION_PARTIAL_ORDER) */
+ template <class _OtherType> per_thread_allocator(const per_thread_allocator<_OtherType>& __a)
+ _STLP_NOTHROW : _M_state(__a._M_state) {}
+#endif
+
+ ~per_thread_allocator() _STLP_NOTHROW {}
+
+ pointer address(reference __x) const { return &__x; }
+ const_pointer address(const_reference __x) const { return &__x; }
+
+ // __n is permitted to be 0. The C++ standard says nothing about what
+ // the return value is when __n == 0.
+ _Tp* allocate(size_type __n, const void* = 0) {
+ if (__n > max_size()) {
+ _STLP_THROW_BAD_ALLOC;
+ }
+ if (__n != 0) {
+ size_type __buf_size = __n * sizeof(value_type);
+ _Tp* __ret = __REINTERPRET_CAST(_Tp*, _S_Alloc::allocate(__buf_size, _M_state));
+#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)
+ memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);
+#endif
+ return __ret;
+ }
+ else
+ return 0;
+ }
+
+ void deallocate(pointer __p, size_type __n) {
+ _STLP_ASSERT( (__p == 0) == (__n == 0) )
+ if (__p != 0) {
+#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)
+ memset((char*)__p, _STLP_SHRED_BYTE, __n * sizeof(value_type));
+#endif
+ _S_Alloc::deallocate(__p, __n * sizeof(value_type), _M_state);
+ }
+ }
+
+ size_type max_size() const _STLP_NOTHROW
+ { return size_t(-1) / sizeof(_Tp); }
+
+ void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }
+ void destroy(pointer _p) { _p->~_Tp(); }
+
+ // state is being kept here
+ __state_type* _M_state;
+
+#if defined (_STLP_NO_EXTENSIONS)
+ /* STLport extension giving rounded size of an allocated memory buffer
+ * This method do not have to be part of a user defined allocator implementation
+ * and won't even be called if such a function was granted.
+ */
+protected:
+#endif
+ _Tp* allocate(size_type __n, size_type& __allocated_n) {
+ if (__n > max_size()) {
+ _STLP_THROW_BAD_ALLOC;
+ }
+ if (__n != 0) {
+ size_type __buf_size = __n * sizeof(value_type);
+ _Tp* __ret = __REINTERPRET_CAST(value_type*, _S_Alloc::allocate(__buf_size, _M_state));
+#if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)
+ memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);
+#endif
+ __allocated_n = __buf_size / sizeof(value_type);
+ return __ret;
+ }
+ else
+ return 0;
+ }
+};
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC per_thread_allocator<void> {
+public:
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef void* pointer;
+ typedef const void* const_pointer;
+ typedef void value_type;
+#ifdef _STLP_MEMBER_TEMPLATE_CLASSES
+ template <class _NewType> struct rebind {
+ typedef per_thread_allocator<_NewType> other;
+ };
+#endif
+};
+
+template <class _T1, class _T2>
+inline bool operator==(const per_thread_allocator<_T1>& __a1,
+ const per_thread_allocator<_T2>& __a2)
+{ return __a1._M_state == __a2._M_state; }
+
+#ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER
+template <class _T1, class _T2>
+inline bool operator!=(const per_thread_allocator<_T1>& __a1,
+ const per_thread_allocator<_T2>& __a2)
+{ return __a1._M_state != __a2._M_state; }
+#endif
+
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+
+template <class _Tp, class _Atype>
+struct _Alloc_traits<_Tp, per_thread_allocator<_Atype> >
+{ typedef per_thread_allocator<_Tp> allocator_type; };
+
+#endif
+
+#if defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)
+
+template <class _Tp1, class _Tp2>
+inline per_thread_allocator<_Tp2>&
+__stl_alloc_rebind(per_thread_allocator<_Tp1>& __x, const _Tp2*)
+{ return (per_thread_allocator<_Tp2>&)__x; }
+
+template <class _Tp1, class _Tp2>
+inline per_thread_allocator<_Tp2>
+__stl_alloc_create(per_thread_allocator<_Tp1>&, const _Tp2*)
+{ return per_thread_allocator<_Tp2>(); }
+
+#endif /* _STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE */
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp>
+struct __perthread_alloc_type_traits {
+ typedef typename _IsSTLportClass<per_thread_allocator<_Tp> >::_Ret _STLportAlloc;
+ //The default allocator implementation which is recognize thanks to the
+ //__stlport_class inheritance is a stateless object so:
+ typedef __false_type has_trivial_default_constructor;
+ typedef _STLportAlloc has_trivial_copy_constructor;
+ typedef _STLportAlloc has_trivial_assignment_operator;
+ typedef _STLportAlloc has_trivial_destructor;
+ typedef __false_type is_POD_type;
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+template <class _Tp>
+struct __type_traits<per_thread_allocator<_Tp> > : _STLP_PRIV __perthread_alloc_type_traits<_Tp> {};
+#else
+_STLP_TEMPLATE_NULL
+struct __type_traits<per_thread_allocator<char> > : _STLP_PRIV __perthread_alloc_type_traits<char> {};
+# if defined (_STLP_HAS_WCHAR_T)
+_STLP_TEMPLATE_NULL
+struct __type_traits<per_thread_allocator<wchar_t> > : _STLP_PRIV __perthread_alloc_type_traits<wchar_t> {};
+# endif
+# if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+_STLP_TEMPLATE_NULL
+struct __type_traits<per_thread_allocator<void*> > : _STLP_PRIV __perthread_alloc_type_traits<void*> {};
+# endif
+#endif
+
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_PTHREAD_ALLOC */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_ptrs_specialize.h b/sources/android/stlport/stlport/stl/_ptrs_specialize.h
new file mode 100644
index 0000000..b9cb5d8
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_ptrs_specialize.h
@@ -0,0 +1,83 @@
+#ifndef _STLP_PTRS_SPECIALIZE_H
+#define _STLP_PTRS_SPECIALIZE_H
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) || \
+ (defined (_STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS) && !defined (_STLP_NO_ARROW_OPERATOR))
+# define _STLP_POINTERS_SPECIALIZE( _TpP )
+# define _STLP_DEFINE_ARROW_OPERATOR pointer operator->() const { return &(operator*()); }
+#else
+# ifndef _STLP_TYPE_TRAITS_H
+# include <stl/type_traits.h>
+# endif
+
+// the following is a workaround for arrow operator problems
+# if defined ( _STLP_NO_ARROW_OPERATOR )
+// User wants to disable proxy -> operators
+# define _STLP_DEFINE_ARROW_OPERATOR
+# else
+// Compiler can handle generic -> operator.
+# if defined (__BORLANDC__)
+# define _STLP_DEFINE_ARROW_OPERATOR pointer operator->() const { return &(*(*this)); }
+# elif defined(__WATCOMC__)
+# define _STLP_DEFINE_ARROW_OPERATOR pointer operator->() const { reference x = operator*(); return &x; }
+# else
+# define _STLP_DEFINE_ARROW_OPERATOR pointer operator->() const { return &(operator*()); }
+# endif
+# endif /* _STLP_NO_ARROW_OPERATOR */
+
+// Important pointers specializations
+
+# ifdef _STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS
+# define _STLP_TYPE_TRAITS_POD_SPECIALIZE_V(_Type)
+# define _STLP_TYPE_TRAITS_POD_SPECIALIZE(_Type)
+# else
+# define _STLP_TYPE_TRAITS_POD_SPECIALIZE(_Type) _STLP_TEMPLATE_NULL struct __type_traits<_Type> : __type_traits_aux<__true_type> {};
+# define _STLP_TYPE_TRAITS_POD_SPECIALIZE_V(_Type) \
+_STLP_TYPE_TRAITS_POD_SPECIALIZE(_Type*) \
+_STLP_TYPE_TRAITS_POD_SPECIALIZE(const _Type*) \
+_STLP_TYPE_TRAITS_POD_SPECIALIZE(_Type**) \
+_STLP_TYPE_TRAITS_POD_SPECIALIZE(_Type* const *) \
+_STLP_TYPE_TRAITS_POD_SPECIALIZE(const _Type**) \
+_STLP_TYPE_TRAITS_POD_SPECIALIZE(_Type***) \
+_STLP_TYPE_TRAITS_POD_SPECIALIZE(const _Type***)
+# endif
+
+# define _STLP_POINTERS_SPECIALIZE(_Type) _STLP_TYPE_TRAITS_POD_SPECIALIZE_V(_Type)
+
+_STLP_BEGIN_NAMESPACE
+
+# if !defined ( _STLP_NO_BOOL )
+_STLP_POINTERS_SPECIALIZE( bool )
+# endif
+_STLP_TYPE_TRAITS_POD_SPECIALIZE_V(void)
+# ifndef _STLP_NO_SIGNED_BUILTINS
+ _STLP_POINTERS_SPECIALIZE( signed char )
+# endif
+ _STLP_POINTERS_SPECIALIZE( char )
+ _STLP_POINTERS_SPECIALIZE( unsigned char )
+ _STLP_POINTERS_SPECIALIZE( short )
+ _STLP_POINTERS_SPECIALIZE( unsigned short )
+ _STLP_POINTERS_SPECIALIZE( int )
+ _STLP_POINTERS_SPECIALIZE( unsigned int )
+ _STLP_POINTERS_SPECIALIZE( long )
+ _STLP_POINTERS_SPECIALIZE( unsigned long )
+ _STLP_POINTERS_SPECIALIZE( float )
+ _STLP_POINTERS_SPECIALIZE( double )
+# if !defined ( _STLP_NO_LONG_DOUBLE )
+ _STLP_POINTERS_SPECIALIZE( long double )
+# endif
+# if defined ( _STLP_LONG_LONG)
+ _STLP_POINTERS_SPECIALIZE( _STLP_LONG_LONG )
+ _STLP_POINTERS_SPECIALIZE( unsigned _STLP_LONG_LONG )
+# endif
+# if defined ( _STLP_HAS_WCHAR_T ) && ! defined (_STLP_WCHAR_T_IS_USHORT)
+ _STLP_POINTERS_SPECIALIZE( wchar_t )
+# endif
+
+_STLP_END_NAMESPACE
+
+# undef _STLP_ARROW_SPECIALIZE
+# undef _STLP_TYPE_TRAITS_POD_SPECIALIZE_V
+
+#endif
+#endif
diff --git a/sources/android/stlport/stlport/stl/_queue.h b/sources/android/stlport/stlport/stl/_queue.h
new file mode 100644
index 0000000..5f3763c
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_queue.h
@@ -0,0 +1,268 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_QUEUE_H
+#define _STLP_INTERNAL_QUEUE_H
+
+#ifndef _STLP_INTERNAL_DEQUE_H
+# include <stl/_deque.h>
+#endif
+
+#ifndef _STLP_INTERNAL_VECTOR_H
+# include <stl/_vector.h>
+#endif
+
+#ifndef _STLP_INTERNAL_HEAP_H
+# include <stl/_heap.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+# include <stl/_function_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+# if ! defined ( _STLP_LIMITED_DEFAULT_TEMPLATES )
+template <class _Tp, class _Sequence = deque<_Tp> >
+# elif defined ( _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS )
+# define _STLP_QUEUE_ARGS _Tp
+template <class _Tp>
+# else
+template <class _Tp, class _Sequence>
+# endif
+class queue
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+# if defined (_STLP_QUEUE_ARGS)
+ : public __stlport_class<queue<_Tp> >
+# else
+ : public __stlport_class<queue<_Tp, _Sequence> >
+# endif
+#endif
+{
+# if defined ( _STLP_QUEUE_ARGS )
+ typedef deque<_Tp> _Sequence;
+ typedef queue<_Tp> _Self;
+# else
+ typedef queue<_Tp, _Sequence> _Self;
+# endif
+public:
+ typedef typename _Sequence::value_type value_type;
+ typedef typename _Sequence::size_type size_type;
+ typedef _Sequence container_type;
+
+ typedef typename _Sequence::reference reference;
+ typedef typename _Sequence::const_reference const_reference;
+
+protected:
+ //c is a Standard name (23.2.3.1), do no make it STLport naming convention compliant.
+ _Sequence c;
+public:
+ queue() : c() {}
+ explicit queue(const _Sequence& __c) : c(__c) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ queue(__move_source<_Self> src)
+ : c(_STLP_PRIV _AsMoveSource(src.get().c)) {}
+#endif
+
+ bool empty() const { return c.empty(); }
+ size_type size() const { return c.size(); }
+ reference front() { return c.front(); }
+ const_reference front() const { return c.front(); }
+ reference back() { return c.back(); }
+ const_reference back() const { return c.back(); }
+ void push(const value_type& __x) { c.push_back(__x); }
+ void pop() { c.pop_front(); }
+ const _Sequence& _Get_s() const { return c; }
+
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) {
+ _Sequence __tmp = c;
+ c = __x.c;
+ __x.c = __tmp;
+ }
+#endif
+};
+
+#ifndef _STLP_QUEUE_ARGS
+# define _STLP_QUEUE_ARGS _Tp, _Sequence
+# define _STLP_QUEUE_HEADER_ARGS class _Tp, class _Sequence
+#else
+# define _STLP_QUEUE_HEADER_ARGS class _Tp
+#endif
+
+template < _STLP_QUEUE_HEADER_ARGS >
+inline bool _STLP_CALL
+operator==(const queue<_STLP_QUEUE_ARGS >& __x, const queue<_STLP_QUEUE_ARGS >& __y) {
+ return __x._Get_s() == __y._Get_s();
+}
+
+template < _STLP_QUEUE_HEADER_ARGS >
+inline bool _STLP_CALL
+operator<(const queue<_STLP_QUEUE_ARGS >& __x, const queue<_STLP_QUEUE_ARGS >& __y) {
+ return __x._Get_s() < __y._Get_s();
+}
+
+_STLP_RELOPS_OPERATORS( template < _STLP_QUEUE_HEADER_ARGS >, queue<_STLP_QUEUE_ARGS > )
+
+# if !(defined ( _STLP_LIMITED_DEFAULT_TEMPLATES ) || defined ( _STLP_TEMPLATE_PARAM_SUBTYPE_BUG ))
+template <class _Tp, class _Sequence = vector<_Tp>,
+ class _Compare = less<_STLP_HEADER_TYPENAME _Sequence::value_type> >
+# elif defined ( _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS )
+template <class _Tp>
+# else
+template <class _Tp, class _Sequence, class _Compare>
+# endif
+class priority_queue
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+# if defined (_STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS)
+ : public __stlport_class<priority_queue<_Tp> >
+# else
+ : public __stlport_class<priority_queue<_Tp, _Sequence> >
+# endif
+#endif
+{
+# ifdef _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS
+ typedef vector<_Tp> _Sequence;
+ typedef less< typename vector<_Tp>::value_type> _Compare;
+ typedef priority_queue<_Tp> _Self;
+# else
+ typedef priority_queue<_Tp, _Sequence, _Compare> _Self;
+# endif
+public:
+ typedef typename _Sequence::value_type value_type;
+ typedef typename _Sequence::size_type size_type;
+ typedef _Sequence container_type;
+
+ typedef typename _Sequence::reference reference;
+ typedef typename _Sequence::const_reference const_reference;
+protected:
+ //c is a Standard name (23.2.3.2), do no make it STLport naming convention compliant.
+ _Sequence c;
+ _Compare comp;
+public:
+ priority_queue() : c() {}
+ explicit priority_queue(const _Compare& __x) : c(), comp(__x) {}
+ priority_queue(const _Compare& __x, const _Sequence& __s)
+ : c(__s), comp(__x)
+ { make_heap(c.begin(), c.end(), comp); }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ priority_queue(__move_source<_Self> src)
+ : c(_STLP_PRIV _AsMoveSource(src.get().c)),
+ comp(_STLP_PRIV _AsMoveSource(src.get().comp)) {}
+#endif
+
+#ifdef _STLP_MEMBER_TEMPLATES
+ template <class _InputIterator>
+ priority_queue(_InputIterator __first, _InputIterator __last)
+ : c(__first, __last) { make_heap(c.begin(), c.end(), comp); }
+
+ template <class _InputIterator>
+ priority_queue(_InputIterator __first,
+ _InputIterator __last, const _Compare& __x)
+ : c(__first, __last), comp(__x)
+ { make_heap(c.begin(), c.end(), comp); }
+
+ template <class _InputIterator>
+ priority_queue(_InputIterator __first, _InputIterator __last,
+ const _Compare& __x, const _Sequence& __s)
+ : c(__s), comp(__x)
+ {
+ c.insert(c.end(), __first, __last);
+ make_heap(c.begin(), c.end(), comp);
+ }
+
+#else /* _STLP_MEMBER_TEMPLATES */
+ priority_queue(const value_type* __first, const value_type* __last)
+ : c(__first, __last) { make_heap(c.begin(), c.end(), comp); }
+
+ priority_queue(const value_type* __first, const value_type* __last,
+ const _Compare& __x)
+ : c(__first, __last), comp(__x)
+ { make_heap(c.begin(), c.end(), comp); }
+
+ priority_queue(const value_type* __first, const value_type* __last,
+ const _Compare& __x, const _Sequence& __c)
+ : c(__c), comp(__x)
+ {
+ c.insert(c.end(), __first, __last);
+ make_heap(c.begin(), c.end(), comp);
+ }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ bool empty() const { return c.empty(); }
+ size_type size() const { return c.size(); }
+ const_reference top() const { return c.front(); }
+ void push(const value_type& __x) {
+ _STLP_TRY {
+ c.push_back(__x);
+ push_heap(c.begin(), c.end(), comp);
+ }
+ _STLP_UNWIND(c.clear())
+ }
+ void pop() {
+ _STLP_TRY {
+ pop_heap(c.begin(), c.end(), comp);
+ c.pop_back();
+ }
+ _STLP_UNWIND(c.clear())
+ }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) {
+ _Sequence __tmp = c;
+ c = __x.c;
+ __x.c = __tmp;
+ }
+#endif
+};
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Tp, class _Sequence>
+struct __move_traits<queue<_Tp, _Sequence> > :
+ _STLP_PRIV __move_traits_aux<_Sequence>
+{};
+
+template <class _Tp, class _Sequence, class _Compare>
+struct __move_traits<priority_queue<_Tp, _Sequence, _Compare> > :
+ _STLP_PRIV __move_traits_aux2<_Sequence, _Compare>
+{};
+#endif
+
+_STLP_END_NAMESPACE
+
+#undef _STLP_QUEUE_ARGS
+#undef _STLP_QUEUE_HEADER_ARGS
+#undef comp
+
+#endif /* _STLP_INTERNAL_QUEUE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_range_errors.c b/sources/android/stlport/stlport/stl/_range_errors.c
new file mode 100644
index 0000000..87293be
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_range_errors.c
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#if defined(_STLP_THROW_RANGE_ERRORS)
+# if defined (_STLP_WHOLE_NATIVE_STD) && defined (_STLP_DONT_REDEFINE_STD)
+// In this mode we are going to throw native exception so that catch of
+// exception like std::runtime_error for instance will also catch exception
+// thrown by STLport containers like stlport::vector or stlport::string.
+# include <stdexcept>
+# include <string>
+# define _STLP_THROW_MSG(ex,msg) throw std::ex(msg)
+# else
+# if defined (__BUILDING_STLPORT)
+# include <stdexcept>
+# include <string>
+# else
+# ifndef _STLP_INTERNAL_STDEXCEPT
+# include <stl/_stdexcept.h>
+# endif
+# ifndef _STLP_INTERNAL_STRING_H
+# include <stl/_string.h>
+# endif
+# endif
+# define _STLP_THROW_MSG(ex,msg) throw ex(msg)
+# endif
+#else
+# if defined (__BUILDING_STLPORT)
+# include <cstdlib>
+# include <cstdio>
+# else
+# ifndef _STLP_INTERNAL_CSTDLIB
+# include <stl/_cstdlib.h>
+# endif
+# ifndef _STLP_INTERNAL_CSTDIO
+# include <stl/_cstdio.h>
+# endif
+# endif
+# define _STLP_THROW_MSG(ex,msg) puts(msg),_STLP_ABORT()
+#endif
+
+// For mode without library and throwing range errors, include the
+// stdexcept header and throw the appropriate exceptions directly.
+
+#if defined (_STLP_EXTERN_RANGE_ERRORS)
+# define _STLP_THROW_FUNCT_SPEC void _STLP_DECLSPEC
+#else
+# define _STLP_THROW_FUNCT_SPEC inline void
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_THROW_FUNCT_SPEC _STLP_CALL __stl_throw_runtime_error(const char* __msg)
+{ _STLP_THROW_MSG(runtime_error, __msg); }
+
+_STLP_THROW_FUNCT_SPEC _STLP_CALL __stl_throw_range_error(const char* __msg)
+{ _STLP_THROW_MSG(range_error, __msg); }
+
+_STLP_THROW_FUNCT_SPEC _STLP_CALL __stl_throw_out_of_range(const char* __msg)
+{ _STLP_THROW_MSG(out_of_range, __msg); }
+
+_STLP_THROW_FUNCT_SPEC _STLP_CALL __stl_throw_length_error(const char* __msg)
+{ _STLP_THROW_MSG(length_error, __msg); }
+
+_STLP_THROW_FUNCT_SPEC _STLP_CALL __stl_throw_invalid_argument(const char* __msg)
+{ _STLP_THROW_MSG(invalid_argument, __msg); }
+
+_STLP_THROW_FUNCT_SPEC _STLP_CALL __stl_throw_overflow_error(const char* __msg)
+{ _STLP_THROW_MSG(overflow_error, __msg); }
+
+_STLP_END_NAMESPACE
+
+#undef _STLP_THROW_FUNCT_SPEC
+#undef _STLP_THROW_MSG
diff --git a/sources/android/stlport/stlport/stl/_range_errors.h b/sources/android/stlport/stlport/stl/_range_errors.h
new file mode 100644
index 0000000..80df26a
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_range_errors.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ *
+ */
+
+#ifndef _STLP_RANGE_ERRORS_H
+#define _STLP_RANGE_ERRORS_H
+
+// A few places in the STL throw range errors, using standard exception
+// classes defined in <stdexcept>. This header file provides functions
+// to throw those exception objects.
+
+// _STLP_DONT_THROW_RANGE_ERRORS is a hook so that users can disable
+// this exception throwing.
+#if defined (_STLP_CAN_THROW_RANGE_ERRORS) && defined (_STLP_USE_EXCEPTIONS) && \
+ !defined (_STLP_DONT_THROW_RANGE_ERRORS)
+# define _STLP_THROW_RANGE_ERRORS
+#endif
+
+// For the STLport iostreams, only declaration here, definition is in the lib
+#if !defined (_STLP_USE_NO_IOSTREAMS) && !defined (_STLP_EXTERN_RANGE_ERRORS)
+# define _STLP_EXTERN_RANGE_ERRORS
+#endif
+
+_STLP_BEGIN_NAMESPACE
+void _STLP_FUNCTION_THROWS _STLP_DECLSPEC _STLP_CALL __stl_throw_runtime_error(const char* __msg);
+void _STLP_FUNCTION_THROWS _STLP_DECLSPEC _STLP_CALL __stl_throw_range_error(const char* __msg);
+void _STLP_FUNCTION_THROWS _STLP_DECLSPEC _STLP_CALL __stl_throw_out_of_range(const char* __msg);
+void _STLP_FUNCTION_THROWS _STLP_DECLSPEC _STLP_CALL __stl_throw_length_error(const char* __msg);
+void _STLP_FUNCTION_THROWS _STLP_DECLSPEC _STLP_CALL __stl_throw_invalid_argument(const char* __msg);
+void _STLP_FUNCTION_THROWS _STLP_DECLSPEC _STLP_CALL __stl_throw_overflow_error(const char* __msg);
+
+#if defined (__DMC__) && !defined (_STLP_NO_EXCEPTIONS)
+# pragma noreturn(__stl_throw_runtime_error)
+# pragma noreturn(__stl_throw_range_error)
+# pragma noreturn(__stl_throw_out_of_range)
+# pragma noreturn(__stl_throw_length_error)
+# pragma noreturn(__stl_throw_invalid_argument)
+# pragma noreturn(__stl_throw_overflow_error)
+#endif
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_EXTERN_RANGE_ERRORS)
+# include <stl/_range_errors.c>
+#endif
+
+#endif /* _STLP_RANGE_ERRORS_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_raw_storage_iter.h b/sources/android/stlport/stlport/stl/_raw_storage_iter.h
new file mode 100644
index 0000000..6e4bc2e
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_raw_storage_iter.h
@@ -0,0 +1,80 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_RAW_STORAGE_ITERATOR_H
+#define _STLP_INTERNAL_RAW_STORAGE_ITERATOR_H
+
+#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
+# include <stl/_iterator_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _ForwardIterator, class _Tp>
+class raw_storage_iterator
+ : public iterator<output_iterator_tag,void,void,void,void>
+{
+protected:
+ _ForwardIterator _M_iter;
+public:
+ typedef output_iterator_tag iterator_category;
+# ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
+ typedef void value_type;
+ typedef void difference_type;
+ typedef void pointer;
+ typedef void reference;
+# endif
+ explicit raw_storage_iterator(_ForwardIterator __x) : _M_iter(__x) {}
+ raw_storage_iterator<_ForwardIterator, _Tp>& operator*() { return *this; }
+ raw_storage_iterator<_ForwardIterator, _Tp>& operator=(const _Tp& __element) {
+ _Param_Construct(&*_M_iter, __element);
+ return *this;
+ }
+ raw_storage_iterator<_ForwardIterator, _Tp>& operator++() {
+ ++_M_iter;
+ return *this;
+ }
+ raw_storage_iterator<_ForwardIterator, _Tp> operator++(int) {
+ raw_storage_iterator<_ForwardIterator, _Tp> __tmp = *this;
+ ++_M_iter;
+ return __tmp;
+ }
+};
+
+# ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
+template <class _ForwardIterator, class _Tp>
+inline output_iterator_tag iterator_category(const raw_storage_iterator<_ForwardIterator, _Tp>&) { return output_iterator_tag(); }
+#endif
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_RAW_STORAGE_ITERATOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_relops_cont.h b/sources/android/stlport/stlport/stl/_relops_cont.h
new file mode 100644
index 0000000..cd8ec05
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_relops_cont.h
@@ -0,0 +1,29 @@
+// This is an implementation file which
+// is intended to be included multiple times with different _STLP_ASSOCIATIVE_CONTAINER
+// setting
+
+#if !defined (_STLP_EQUAL_OPERATOR_SPECIALIZED)
+_STLP_TEMPLATE_HEADER
+inline bool _STLP_CALL operator==(const _STLP_TEMPLATE_CONTAINER& __x,
+ const _STLP_TEMPLATE_CONTAINER& __y) {
+ return __x.size() == __y.size() &&
+ equal(__x.begin(), __x.end(), __y.begin());
+}
+#endif /* _STLP_EQUAL_OPERATOR_SPECIALIZED */
+
+_STLP_TEMPLATE_HEADER
+inline bool _STLP_CALL operator<(const _STLP_TEMPLATE_CONTAINER& __x,
+ const _STLP_TEMPLATE_CONTAINER& __y) {
+ return lexicographical_compare(__x.begin(), __x.end(),
+ __y.begin(), __y.end());
+}
+
+_STLP_RELOPS_OPERATORS( _STLP_TEMPLATE_HEADER , _STLP_TEMPLATE_CONTAINER )
+
+#if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+_STLP_TEMPLATE_HEADER
+inline void _STLP_CALL swap(_STLP_TEMPLATE_CONTAINER& __x,
+ _STLP_TEMPLATE_CONTAINER& __y) {
+ __x.swap(__y);
+}
+#endif /* _STLP_FUNCTION_TMPL_PARTIAL_ORDER */
diff --git a/sources/android/stlport/stlport/stl/_relops_hash_cont.h b/sources/android/stlport/stlport/stl/_relops_hash_cont.h
new file mode 100644
index 0000000..421c805
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_relops_hash_cont.h
@@ -0,0 +1,13 @@
+/* This is an implementation file which is intended to be included
+ * multiple times with different _STLP_TEMPLATE_CONTAINER settings.
+ */
+
+#if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+
+_STLP_TEMPLATE_HEADER
+inline void _STLP_CALL
+swap(_STLP_TEMPLATE_CONTAINER& __hm1, _STLP_TEMPLATE_CONTAINER& __hm2) {
+ __hm1.swap(__hm2);
+}
+
+#endif /* _STLP_FUNCTION_TMPL_PARTIAL_ORDER */
diff --git a/sources/android/stlport/stlport/stl/_rope.c b/sources/android/stlport/stlport/stl/_rope.c
new file mode 100644
index 0000000..196ee22
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_rope.c
@@ -0,0 +1,1407 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+// Set buf_start, buf_end, and buf_ptr appropriately, filling tmp_buf
+// if necessary. Assumes path_end[leaf_index] and leaf_pos are correct.
+// Results in a valid buf_ptr if the iterator can be legitimately
+// dereferenced.
+#ifndef _STLP_ROPEIMPL_H
+#define _STLP_ROPEIMPL_H
+
+#ifndef _STLP_INTERNAL_ROPE_H
+# include <stl/_rope.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CSTDIO
+# include <stl/_cstdio.h>
+#endif
+
+#if !defined (_STLP_USE_NO_IOSTREAMS)
+# ifndef _STLP_INTERNAL_OSTREAM_H
+# include <stl/_ostream.h>
+# endif
+
+# ifndef _STLP_INTERNAL_ISTREAM
+# include <stl/_istream.h>
+# endif
+#endif
+
+#include <stl/_range_errors.h>
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined ( _STLP_NESTED_TYPE_PARAM_BUG )
+# define __allocator__ _Alloc
+#else
+# define __allocator__ allocator_type
+#endif
+
+template<class _CharT, class _Alloc>
+_Rope_iterator<_CharT, _Alloc>::_Rope_iterator(rope<_CharT,_Alloc>* __r, size_t __pos)
+ : _Rope_iterator_base<_CharT,_Alloc>(__r->_M_tree_ptr._M_data, __pos),
+ _M_root_rope(__r) { _RopeRep::_S_ref(this->_M_root); }
+
+template<class _CharT, class _Alloc>
+_Rope_iterator<_CharT, _Alloc>::_Rope_iterator(rope<_CharT,_Alloc>& __r, size_t __pos):
+ _Rope_iterator_base<_CharT,_Alloc>(__r._M_tree_ptr._M_data, __pos),
+ _M_root_rope(&__r) {
+#if !defined (__DMC__)
+ _RopeRep::_S_ref(this->_M_root); if (!(__r.empty()))_S_setcache(*this);
+#else
+ _Rope_iterator_base<_CharT, _Alloc>* __x = this;
+ _RopeRep::_S_ref(this->_M_root); if (!(__r.empty()))_S_setcache(*__x);
+#endif
+}
+
+template<class _CharT, class _Alloc>
+void _Rope_RopeRep<_CharT, _Alloc>::_M_free_c_string() {
+ _CharT* __cstr = _M_c_string;
+ if (0 != __cstr) {
+ size_t _p_size = _M_size._M_data + 1;
+ _STLP_STD::_Destroy_Range(__cstr, __cstr + _p_size);
+ _M_size.deallocate(__cstr, _p_size);
+ }
+}
+
+// Set buf_start, buf_end, and buf_ptr appropriately, filling tmp_buf
+// if necessary. Assumes _M_path_end[leaf_index] and leaf_pos are correct.
+// Results in a valid buf_ptr if the iterator can be legitimately
+// dereferenced.
+template <class _CharT, class _Alloc>
+void _Rope_iterator_base<_CharT,_Alloc>::_S_setbuf(
+ _Rope_iterator_base<_CharT,_Alloc>& __x) {
+ const _RopeRep* __leaf = __x._M_path_end._M_data[__x._M_leaf_index];
+ size_t __leaf_pos = __x._M_leaf_pos;
+ size_t __pos = __x._M_current_pos;
+
+ switch(__leaf->_M_tag) {
+ case _RopeRep::_S_leaf:
+ typedef _Rope_RopeLeaf<_CharT, _Alloc> _RopeLeaf;
+ __x._M_buf_start = __STATIC_CAST(const _RopeLeaf*, __leaf)->_M_data;
+ __x._M_buf_ptr = __x._M_buf_start + (__pos - __leaf_pos);
+ __x._M_buf_end = __x._M_buf_start + __leaf->_M_size._M_data;
+ break;
+ case _RopeRep::_S_function:
+ case _RopeRep::_S_substringfn:
+ {
+ size_t __len = _S_iterator_buf_len;
+ size_t __buf_start_pos = __leaf_pos;
+ size_t __leaf_end = __leaf_pos + __leaf->_M_size._M_data;
+ typedef _Rope_RopeFunction<_CharT, _Alloc> _RopeFunction;
+ char_producer<_CharT>* __fn = __STATIC_CAST(const _RopeFunction*, __leaf)->_M_fn;
+
+ if (__buf_start_pos + __len <= __pos) {
+ __buf_start_pos = __pos - __len/4;
+ if (__buf_start_pos + __len > __leaf_end) {
+ __buf_start_pos = __leaf_end - __len;
+ }
+ }
+ if (__buf_start_pos + __len > __leaf_end) {
+ __len = __leaf_end - __buf_start_pos;
+ }
+ (*__fn)(__buf_start_pos - __leaf_pos, __len, __x._M_tmp_buf._M_data);
+ __x._M_buf_ptr = __x._M_tmp_buf._M_data + (__pos - __buf_start_pos);
+ __x._M_buf_start = __x._M_tmp_buf._M_data;
+ __x._M_buf_end = __x._M_tmp_buf._M_data + __len;
+ }
+ break;
+ default:
+ _STLP_ASSERT(0)
+ ;
+ }
+}
+
+// Set path and buffer inside a rope iterator. We assume that
+// pos and root are already set.
+template <class _CharT, class _Alloc>
+void _Rope_iterator_base<_CharT,_Alloc>::_S_setcache(
+ _Rope_iterator_base<_CharT,_Alloc>& __x) {
+ const _RopeRep* __path[_RopeRep::_S_max_rope_depth+1];
+ const _RopeRep* __curr_rope;
+ int __curr_depth = -1; /* index into path */
+ size_t __curr_start_pos = 0;
+ size_t __pos = __x._M_current_pos;
+ unsigned char __dirns = 0; // Bit vector marking right turns in the path
+
+ _STLP_ASSERT(__pos <= __x._M_root->_M_size._M_data)
+ if (__pos >= __x._M_root->_M_size._M_data) {
+ __x._M_buf_ptr = 0;
+ return;
+ }
+ __curr_rope = __x._M_root;
+ if (0 != __curr_rope->_M_c_string) {
+ /* Treat the root as a leaf. */
+ __x._M_buf_start = __curr_rope->_M_c_string;
+ __x._M_buf_end = __curr_rope->_M_c_string + __curr_rope->_M_size._M_data;
+ __x._M_buf_ptr = __curr_rope->_M_c_string + __pos;
+ __x._M_path_end._M_data[0] = __curr_rope;
+ __x._M_leaf_index = 0;
+ __x._M_leaf_pos = 0;
+ return;
+ }
+ for(;;) {
+ ++__curr_depth;
+ _STLP_ASSERT(__curr_depth <= _RopeRep::_S_max_rope_depth)
+ __path[__curr_depth] = __curr_rope;
+ switch(__curr_rope->_M_tag) {
+ case _RopeRep::_S_leaf:
+ case _RopeRep::_S_function:
+ case _RopeRep::_S_substringfn:
+ __x._M_leaf_pos = __curr_start_pos;
+ goto done;
+ case _RopeRep::_S_concat:
+ {
+ const _RopeConcat* __c = __STATIC_CAST(const _RopeConcat*, __curr_rope);
+ _RopeRep* __left = __c->_M_left;
+ size_t __left_len = __left->_M_size._M_data;
+
+ __dirns <<= 1;
+ if (__pos >= __curr_start_pos + __left_len) {
+ __dirns |= 1;
+ __curr_rope = __c->_M_right;
+ __curr_start_pos += __left_len;
+ } else {
+ __curr_rope = __left;
+ }
+ }
+ break;
+ }
+ }
+done:
+ // Copy last section of path into _M_path_end.
+ {
+ int __i = -1;
+ int __j = __curr_depth + 1 - _S_path_cache_len;
+
+ if (__j < 0) __j = 0;
+ while (__j <= __curr_depth) {
+ __x._M_path_end._M_data[++__i] = __path[__j++];
+ }
+ __x._M_leaf_index = __i;
+ }
+ __x._M_path_directions = __dirns;
+ _S_setbuf(__x);
+}
+
+// Specialized version of the above. Assumes that
+// the path cache is valid for the previous position.
+template <class _CharT, class _Alloc>
+void _Rope_iterator_base<_CharT,_Alloc>::_S_setcache_for_incr(
+_Rope_iterator_base<_CharT,_Alloc>& __x) {
+ int __current_index = __x._M_leaf_index;
+ const _RopeRep* __current_node = __x._M_path_end._M_data[__current_index];
+ size_t __len = __current_node->_M_size._M_data;
+ size_t __node_start_pos = __x._M_leaf_pos;
+ unsigned char __dirns = __x._M_path_directions;
+ const _RopeConcat* __c;
+
+ _STLP_ASSERT(__x._M_current_pos <= __x._M_root->_M_size._M_data)
+ if (__x._M_current_pos - __node_start_pos < __len) {
+ /* More stuff in this leaf, we just didn't cache it. */
+ _S_setbuf(__x);
+ return;
+ }
+ _STLP_ASSERT(__node_start_pos + __len == __x._M_current_pos)
+ // node_start_pos is starting position of last_node.
+ while (--__current_index >= 0) {
+ if (!(__dirns & 1) /* Path turned left */)
+ break;
+ __current_node = __x._M_path_end._M_data[__current_index];
+ __c = __STATIC_CAST(const _RopeConcat*, __current_node);
+ // Otherwise we were in the right child. Thus we should pop
+ // the concatenation node.
+ __node_start_pos -= __c->_M_left->_M_size._M_data;
+ __dirns >>= 1;
+ }
+ if (__current_index < 0) {
+ // We underflowed the cache. Punt.
+ _S_setcache(__x);
+ return;
+ }
+ __current_node = __x._M_path_end._M_data[__current_index];
+ __c = __STATIC_CAST(const _RopeConcat*, __current_node);
+ // current_node is a concatenation node. We are positioned on the first
+ // character in its right child.
+ // node_start_pos is starting position of current_node.
+ __node_start_pos += __c->_M_left->_M_size._M_data;
+ __current_node = __c->_M_right;
+ __x._M_path_end._M_data[++__current_index] = __current_node;
+ __dirns |= 1;
+ while (_RopeRep::_S_concat == __current_node->_M_tag) {
+ ++__current_index;
+ if (_S_path_cache_len == __current_index) {
+ int __i;
+ for (__i = 0; __i < _S_path_cache_len-1; ++__i) {
+ __x._M_path_end._M_data[__i] = __x._M_path_end._M_data[__i+1];
+ }
+ --__current_index;
+ }
+ __current_node = __STATIC_CAST(const _RopeConcat*, __current_node)->_M_left;
+ __x._M_path_end._M_data[__current_index] = __current_node;
+ __dirns <<= 1;
+ // node_start_pos is unchanged.
+ }
+ __x._M_leaf_index = __current_index;
+ __x._M_leaf_pos = __node_start_pos;
+ __x._M_path_directions = __dirns;
+ _S_setbuf(__x);
+}
+
+template <class _CharT, class _Alloc>
+void _Rope_iterator_base<_CharT,_Alloc>::_M_incr(size_t __n) {
+ _M_current_pos += __n;
+ if (0 != _M_buf_ptr) {
+ size_t __chars_left = _M_buf_end - _M_buf_ptr;
+ if (__chars_left > __n) {
+ _M_buf_ptr += __n;
+ } else if (__chars_left == __n) {
+ _M_buf_ptr += __n;
+ _S_setcache_for_incr(*this);
+ } else {
+ _M_buf_ptr = 0;
+ }
+ }
+}
+
+template <class _CharT, class _Alloc>
+void _Rope_iterator_base<_CharT,_Alloc>::_M_decr(size_t __n) {
+ if (0 != _M_buf_ptr) {
+ size_t __chars_left = _M_buf_ptr - _M_buf_start;
+ if (__chars_left >= __n) {
+ _M_buf_ptr -= __n;
+ } else {
+ _M_buf_ptr = 0;
+ }
+ }
+ _M_current_pos -= __n;
+}
+
+template <class _CharT, class _Alloc>
+void _Rope_iterator<_CharT,_Alloc>::_M_check() {
+ if (_M_root_rope->_M_tree_ptr._M_data != this->_M_root) {
+ // _Rope was modified. Get things fixed up.
+ _RopeRep::_S_unref(this->_M_root);
+ this->_M_root = _M_root_rope->_M_tree_ptr._M_data;
+ _RopeRep::_S_ref(this->_M_root);
+ this->_M_buf_ptr = 0;
+ }
+}
+
+// There are several reasons for not doing this with virtual destructors
+// and a class specific delete operator:
+// - A class specific delete operator can't easily get access to
+// allocator instances if we need them.
+// - Any virtual function would need a 4 or byte vtable pointer;
+// this only requires a one byte tag per object.
+template <class _CharT, class _Alloc>
+void _Rope_RopeRep<_CharT,_Alloc>::_M_free_tree() {
+ switch (_M_tag) {
+ case _S_leaf:
+ {
+ typedef _Rope_RopeLeaf<_CharT, _Alloc> _RopeLeaf;
+ _RopeLeaf* __l = __STATIC_CAST(_RopeLeaf*, this);
+ _STLP_STD::_Destroy(__l); // ->_Rope_RopeLeaf<_CharT,_Alloc>::~_Rope_RopeLeaf();
+ _STLP_CREATE_ALLOCATOR(allocator_type,(const allocator_type&)_M_size,
+ _RopeLeaf).deallocate(__l, 1);
+ break;
+ }
+ case _S_concat:
+ {
+ typedef _Rope_RopeConcatenation<_CharT, _Alloc> _RopeConcatenation;
+ _RopeConcatenation* __c = __STATIC_CAST(_RopeConcatenation*, this);
+ _STLP_STD::_Destroy(__c);
+ _STLP_CREATE_ALLOCATOR(allocator_type,(const allocator_type&)_M_size,
+ _RopeConcatenation).deallocate(__c, 1);
+ break;
+ }
+ case _S_function:
+ {
+ typedef _Rope_RopeFunction<_CharT, _Alloc> _RopeFunction;
+ _RopeFunction* __f = __STATIC_CAST(_RopeFunction*, this);
+ _STLP_STD::_Destroy(__f);
+ _STLP_CREATE_ALLOCATOR(allocator_type, (const allocator_type&)_M_size,
+ _RopeFunction).deallocate(__f, 1);
+ break;
+ }
+ case _S_substringfn:
+ {
+ typedef _Rope_RopeSubstring<_CharT, _Alloc> _RopeSubstring;
+ _RopeSubstring* __rss = __STATIC_CAST(_RopeSubstring*, this);
+ _STLP_STD::_Destroy(__rss);
+ _STLP_CREATE_ALLOCATOR(allocator_type, (const allocator_type&)_M_size,
+ _RopeSubstring).deallocate(__rss, 1);
+ break;
+ }
+ }
+}
+
+# if defined ( _STLP_NESTED_TYPE_PARAM_BUG )
+# define __RopeLeaf__ _Rope_RopeLeaf<_CharT,_Alloc>
+# define __RopeRep__ _Rope_RopeRep<_CharT,_Alloc>
+# define _RopeLeaf _Rope_RopeLeaf<_CharT,_Alloc>
+# define _RopeRep _Rope_RopeRep<_CharT,_Alloc>
+# define size_type size_t
+# else
+# define __RopeLeaf__ _STLP_TYPENAME_ON_RETURN_TYPE rope<_CharT,_Alloc>::_RopeLeaf
+# define __RopeRep__ _STLP_TYPENAME_ON_RETURN_TYPE rope<_CharT,_Alloc>::_RopeRep
+# endif
+
+template <class _CharT, class _Alloc>
+void rope<_CharT, _Alloc>::_M_throw_out_of_range() const {
+ __stl_throw_out_of_range("rope");
+}
+
+// Concatenate a C string onto a leaf rope by copying the rope data.
+// Used for short ropes.
+template <class _CharT, class _Alloc>
+__RopeLeaf__*
+rope<_CharT,_Alloc>::_S_leaf_concat_char_iter (
+ _RopeLeaf* __r, const _CharT* __iter, size_t __len) {
+ size_t __old_len = __r->_M_size._M_data;
+ _CharT* __new_data = __r->_M_size.allocate(_S_rounded_up_size(__old_len + __len));
+ _RopeLeaf* __result;
+
+ _STLP_PRIV __ucopy_n(__r->_M_data, __old_len, __new_data);
+ _STLP_PRIV __ucopy_n(__iter, __len, __new_data + __old_len);
+ _S_construct_null(__new_data + __old_len + __len);
+ _STLP_TRY {
+ __result = _S_new_RopeLeaf(__new_data, __old_len + __len, __r->get_allocator());
+ }
+ _STLP_UNWIND(_RopeRep::_S_free_string(__new_data, __old_len + __len,
+ __r->get_allocator()))
+ return __result;
+}
+
+template <class _CharT, class _Alloc>
+void _Terminate_RopeLeaf(_Rope_RopeLeaf<_CharT,_Alloc> *__r,
+ size_t __size, const __true_type& /*basic char type*/) {
+ _S_construct_null(__r->_M_data + __size);
+ _STLP_ASSERT(__r->_M_c_string == __r->_M_data)
+}
+
+template <class _CharT, class _Alloc>
+void _Terminate_RopeLeaf(_Rope_RopeLeaf<_CharT,_Alloc> *__r,
+ size_t, const __false_type& /*basic char type*/) {
+ if (__r->_M_c_string != __r->_M_data && 0 != __r->_M_c_string) {
+ __r->_M_free_c_string();
+ __r->_M_c_string = 0;
+ }
+}
+
+// As above, but it's OK to clobber original if refcount is 1
+template <class _CharT, class _Alloc>
+__RopeLeaf__*
+rope<_CharT,_Alloc>::_S_destr_leaf_concat_char_iter (_RopeLeaf* __r, const _CharT* __iter, size_t __len) {
+ //_STLP_ASSERT(__r->_M_ref_count >= 1)
+ if ( /* __r->_M_ref_count > 1 */ __r->_M_incr() > 2 ) { // - ptr
+ __r->_M_decr(); // - ptr
+ return _S_leaf_concat_char_iter(__r, __iter, __len);
+ }
+ __r->_M_decr(); // - ptr, __r->_M_ref_count == 1 or 0
+ size_t __old_len = __r->_M_size._M_data;
+ if (_S_rounded_up_size(__old_len) == _S_rounded_up_size(__old_len + __len)) {
+ // The space has been partially initialized for the standard
+ // character types. But that doesn't matter for those types.
+ _STLP_PRIV __ucopy_n(__iter, __len, __r->_M_data + __old_len);
+ _Terminate_RopeLeaf(__r, __old_len + __len, _IsBasicCharType());
+ __r->_M_size._M_data = __old_len + __len;
+ // _STLP_ASSERT(__r->_M_ref_count == 1)
+ // __r->_M_ref_count = 2;
+ __r->_M_incr(); // i.e. __r->_M_ref_count = 2
+ return __r;
+ } else {
+ _RopeLeaf* __result = _S_leaf_concat_char_iter(__r, __iter, __len);
+ //_STLP_ASSERT(__result->_M_ref_count == 1)
+ return __result;
+ }
+}
+
+// Assumes left and right are not 0.
+// Does not increment (nor decrement on exception) child reference counts.
+// Result has ref count 1.
+template <class _CharT, class _Alloc>
+__RopeRep__*
+rope<_CharT,_Alloc>::_S_tree_concat (_RopeRep* __left, _RopeRep* __right) {
+ _RopeConcatenation* __result =
+ _S_new_RopeConcatenation(__left, __right, __left->get_allocator());
+ size_t __depth = __result->_M_depth;
+
+ _STLP_ASSERT(__left->get_allocator() == __right->get_allocator())
+ if (__depth > 20 && (__result->_M_size._M_data < 1000 ||
+ __depth > _RopeRep::_S_max_rope_depth)) {
+ _RopeRep* __balanced;
+
+ _STLP_TRY {
+ __balanced = _S_balance(__result);
+ // _STLP_ASSERT(__result == __balanced ||
+ // 1 == __result->_M_ref_count &&
+ // 1 == __balanced->_M_ref_count)
+ __result->_M_unref_nonnil();
+ }
+ _STLP_UNWIND((_STLP_CREATE_ALLOCATOR(allocator_type,(allocator_type&)__left->_M_size,
+ _RopeConcatenation).deallocate(__result,1)))
+ // In case of exception, we need to deallocate
+ // otherwise dangling result node. But caller
+ // still owns its children. Thus unref is
+ // inappropriate.
+ return __balanced;
+ } else {
+ return __result;
+ }
+}
+
+template <class _CharT, class _Alloc>
+__RopeRep__*
+rope<_CharT,_Alloc>::_S_concat_char_iter (_RopeRep* __r,
+ const _CharT*__s, size_t __slen) {
+ _RopeRep* __result;
+ if (0 == __slen) {
+ _S_ref(__r);
+ return __r;
+ }
+ if (0 == __r)
+ return _S_RopeLeaf_from_unowned_char_ptr(__s, __slen, __r->get_allocator());
+ if (_RopeRep::_S_leaf == __r->_M_tag &&
+ __r->_M_size._M_data + __slen <= _S_copy_max) {
+ __result = _S_leaf_concat_char_iter((_RopeLeaf*)__r, __s, __slen);
+ // _STLP_ASSERT(1 == __result->_M_ref_count)
+ return __result;
+ }
+ if (_RopeRep::_S_concat == __r->_M_tag &&
+ _RopeRep::_S_leaf == ((_RopeConcatenation*)__r)->_M_right->_M_tag) {
+ _RopeLeaf* __right = (_RopeLeaf* )(((_RopeConcatenation* )__r)->_M_right);
+ if (__right->_M_size._M_data + __slen <= _S_copy_max) {
+ _RopeRep* __left = ((_RopeConcatenation*)__r)->_M_left;
+ _RopeRep* __nright = _S_leaf_concat_char_iter((_RopeLeaf*)__right, __s, __slen);
+ __left->_M_ref_nonnil();
+ _STLP_TRY {
+ __result = _S_tree_concat(__left, __nright);
+ }
+ _STLP_UNWIND(_S_unref(__left); _S_unref(__nright))
+ // _STLP_ASSERT(1 == __result->_M_ref_count)
+ return __result;
+ }
+ }
+ _RopeRep* __nright =
+ _S_RopeLeaf_from_unowned_char_ptr(__s, __slen, __r->get_allocator());
+ _STLP_TRY {
+ __r->_M_ref_nonnil();
+ __result = _S_tree_concat(__r, __nright);
+ }
+ _STLP_UNWIND(_S_unref(__r); _S_unref(__nright))
+ // _STLP_ASSERT(1 == __result->_M_ref_count)
+ return __result;
+}
+
+template <class _CharT, class _Alloc>
+__RopeRep__*
+rope<_CharT,_Alloc>::_S_destr_concat_char_iter(
+ _RopeRep* __r, const _CharT* __s, size_t __slen) {
+ _RopeRep* __result;
+ if (0 == __r)
+ return _S_RopeLeaf_from_unowned_char_ptr(__s, __slen,
+ __r->get_allocator());
+ // size_t __count = __r->_M_ref_count;
+ size_t __orig_size = __r->_M_size._M_data;
+ // _STLP_ASSERT(__count >= 1)
+ if ( /* __count > 1 */ __r->_M_incr() > 2 ) {
+ __r->_M_decr();
+ return _S_concat_char_iter(__r, __s, __slen);
+ }
+ if (0 == __slen) {
+ return __r;
+ }
+ __r->_M_decr();
+ if (__orig_size + __slen <= _S_copy_max && _RopeRep::_S_leaf == __r->_M_tag) {
+ return _S_destr_leaf_concat_char_iter((_RopeLeaf*)__r, __s, __slen);
+ }
+ if (_RopeRep::_S_concat == __r->_M_tag) {
+ _RopeLeaf* __right = __STATIC_CAST(_RopeLeaf*, __STATIC_CAST(_RopeConcatenation*, __r)->_M_right);
+ if (_RopeRep::_S_leaf == __right->_M_tag &&
+ __right->_M_size._M_data + __slen <= _S_copy_max) {
+ _RopeRep* __new_right = _S_destr_leaf_concat_char_iter(__right, __s, __slen);
+ if (__right == __new_right) {
+ // _STLP_ASSERT(__new_right->_M_ref_count == 2)
+ // __new_right->_M_ref_count = 1;
+ __new_right->_M_decr();
+ } else {
+ // _STLP_ASSERT(__new_right->_M_ref_count >= 1)
+ __right->_M_unref_nonnil();
+ }
+ // _STLP_ASSERT(__r->_M_ref_count == 1)
+ // __r->_M_ref_count = 2; // One more than before.
+ __r->_M_incr();
+ __STATIC_CAST(_RopeConcatenation*, __r)->_M_right = __new_right;
+ // E.Musser : moved below
+ // __r->_M_size._M_data = __orig_size + __slen;
+ if (0 != __r->_M_c_string) {
+ __r->_M_free_c_string();
+ __r->_M_c_string = 0;
+ }
+ __r->_M_size._M_data = __orig_size + __slen;
+ return __r;
+ }
+ }
+ _RopeRep* __right =
+ _S_RopeLeaf_from_unowned_char_ptr(__s, __slen, __r->get_allocator());
+ __r->_M_ref_nonnil();
+ _STLP_TRY {
+ __result = _S_tree_concat(__r, __right);
+ }
+ _STLP_UNWIND(_S_unref(__r); _S_unref(__right))
+ // _STLP_ASSERT(1 == __result->_M_ref_count)
+ return __result;
+}
+
+template <class _CharT, class _Alloc>
+__RopeRep__*
+rope<_CharT,_Alloc>::_S_concat_rep(_RopeRep* __left, _RopeRep* __right) {
+ if (0 == __left) {
+ _S_ref(__right);
+ return __right;
+ }
+ if (0 == __right) {
+ __left->_M_ref_nonnil();
+ return __left;
+ }
+ if (_RopeRep::_S_leaf == __right->_M_tag) {
+ if (_RopeRep::_S_leaf == __left->_M_tag) {
+ if (__right->_M_size._M_data + __left->_M_size._M_data <= _S_copy_max) {
+ return _S_leaf_concat_char_iter(__STATIC_CAST(_RopeLeaf*, __left),
+ __STATIC_CAST(_RopeLeaf*, __right)->_M_data,
+ __right->_M_size._M_data);
+ }
+ } else if (_RopeRep::_S_concat == __left->_M_tag &&
+ _RopeRep::_S_leaf == __STATIC_CAST(_RopeConcatenation*, __left)->_M_right->_M_tag) {
+ _RopeLeaf* __leftright =
+ __STATIC_CAST(_RopeLeaf*, __STATIC_CAST(_RopeConcatenation*, __left)->_M_right);
+ if (__leftright->_M_size._M_data + __right->_M_size._M_data <= _S_copy_max) {
+ _RopeRep* __leftleft = __STATIC_CAST(_RopeConcatenation*, __left)->_M_left;
+ _RopeRep* __rest = _S_leaf_concat_char_iter(__leftright,
+ __STATIC_CAST(_RopeLeaf*, __right)->_M_data,
+ __right->_M_size._M_data);
+ __leftleft->_M_ref_nonnil();
+ _STLP_TRY {
+ return _S_tree_concat(__leftleft, __rest);
+ }
+ _STLP_UNWIND(_S_unref(__leftleft); _S_unref(__rest))
+ }
+ }
+ }
+ __left->_M_ref_nonnil();
+ __right->_M_ref_nonnil();
+ _STLP_TRY {
+ return _S_tree_concat(__left, __right);
+ }
+ _STLP_UNWIND(_S_unref(__left); _S_unref(__right))
+ _STLP_RET_AFTER_THROW(0)
+}
+
+template <class _CharT, class _Alloc>
+__RopeRep__*
+rope<_CharT,_Alloc>::_S_substring(_RopeRep* __base,
+ size_t __start, size_t __endp1) {
+ if (0 == __base) return 0;
+ size_t __len = __base->_M_size._M_data;
+ size_t __adj_endp1;
+ const size_t __lazy_threshold = 128;
+
+ if (__endp1 >= __len) {
+ if (0 == __start) {
+ __base->_M_ref_nonnil();
+ return __base;
+ } else {
+ __adj_endp1 = __len;
+ }
+ } else {
+ __adj_endp1 = __endp1;
+ }
+ switch(__base->_M_tag) {
+ case _RopeRep::_S_concat:
+ {
+ _RopeConcatenation* __c = __STATIC_CAST(_RopeConcatenation*, __base);
+ _RopeRep* __left = __c->_M_left;
+ _RopeRep* __right = __c->_M_right;
+ size_t __left_len = __left->_M_size._M_data;
+ _RopeRep* __result;
+
+ if (__adj_endp1 <= __left_len) {
+ return _S_substring(__left, __start, __endp1);
+ } else if (__start >= __left_len) {
+ return _S_substring(__right, __start - __left_len,
+ __adj_endp1 - __left_len);
+ }
+ _Self_destruct_ptr __left_result(_S_substring(__left, __start, __left_len));
+ _Self_destruct_ptr __right_result(_S_substring(__right, 0, __endp1 - __left_len));
+ _STLP_MPWFIX_TRY //*TY 06/01/2000 - mpw forgets to call dtor on __left_result and __right_result without this try block
+ __result = _S_concat_rep(__left_result, __right_result);
+ // _STLP_ASSERT(1 == __result->_M_ref_count)
+ return __result;
+ _STLP_MPWFIX_CATCH //*TY 06/01/2000 -
+ }
+ case _RopeRep::_S_leaf:
+ {
+ _RopeLeaf* __l = __STATIC_CAST(_RopeLeaf*, __base);
+ _RopeLeaf* __result;
+ size_t __result_len;
+ if (__start >= __adj_endp1) return 0;
+ __result_len = __adj_endp1 - __start;
+ if (__result_len > __lazy_threshold) goto lazy;
+ const _CharT* __section = __l->_M_data + __start;
+ // We should sometimes create substring node instead.
+ __result = _S_RopeLeaf_from_unowned_char_ptr(__section, __result_len,
+ __base->get_allocator());
+ return __result;
+ }
+ case _RopeRep::_S_substringfn:
+ // Avoid introducing multiple layers of substring nodes.
+ {
+ _RopeSubstring* __old = __STATIC_CAST(_RopeSubstring*, __base);
+ size_t __result_len;
+ if (__start >= __adj_endp1) return 0;
+ __result_len = __adj_endp1 - __start;
+ if (__result_len > __lazy_threshold) {
+ _RopeSubstring* __result = _S_new_RopeSubstring(__old->_M_base,
+ __start + __old->_M_start,
+ __adj_endp1 - __start,
+ __base->get_allocator());
+ return __result;
+ } // *** else fall through: ***
+ }
+ case _RopeRep::_S_function:
+ {
+ _RopeFunction* __f = __STATIC_CAST(_RopeFunction*, __base);
+ if (__start >= __adj_endp1) return 0;
+ size_t __result_len = __adj_endp1 - __start;
+
+ if (__result_len > __lazy_threshold) goto lazy;
+ _CharT* __section = __base->_M_size.allocate(_S_rounded_up_size(__result_len));
+ _STLP_TRY {
+ (*(__f->_M_fn))(__start, __result_len, __section);
+ }
+ _STLP_UNWIND(_RopeRep::_S_free_string(__section,
+ __result_len, __base->get_allocator()))
+ _S_construct_null(__section + __result_len);
+ return _S_new_RopeLeaf(__section, __result_len,
+ __base->get_allocator());
+ }
+ }
+ /*NOTREACHED*/
+ _STLP_ASSERT(false)
+ lazy:
+ {
+ // Create substring node.
+ return _S_new_RopeSubstring(__base, __start, __adj_endp1 - __start,
+ __base->get_allocator());
+ }
+}
+
+template<class _CharT>
+class _Rope_flatten_char_consumer : public _Rope_char_consumer<_CharT> {
+private:
+ _CharT* _M_buf_ptr;
+public:
+ _Rope_flatten_char_consumer(_CharT* __buffer) {
+ _M_buf_ptr = __buffer;
+ }
+ ~_Rope_flatten_char_consumer() {}
+ bool operator() (const _CharT* __leaf, size_t __n) {
+ _STLP_PRIV __ucopy_n(__leaf, __n, _M_buf_ptr);
+ _M_buf_ptr += __n;
+ return true;
+ }
+};
+
+template<class _CharT>
+class _Rope_find_char_char_consumer : public _Rope_char_consumer<_CharT> {
+private:
+ _CharT _M_pattern;
+public:
+ size_t _M_count; // Number of nonmatching characters
+ _Rope_find_char_char_consumer(_CharT __p)
+ : _M_pattern(__p), _M_count(0) {}
+ ~_Rope_find_char_char_consumer() {}
+ bool operator() (const _CharT* __leaf, size_t __n) {
+ size_t __i;
+ for (__i = 0; __i < __n; ++__i) {
+ if (__leaf[__i] == _M_pattern) {
+ _M_count += __i; return false;
+ }
+ }
+ _M_count += __n; return true;
+ }
+};
+
+#if !defined (_STLP_USE_NO_IOSTREAMS)
+template<class _CharT, class _Traits>
+// Here _CharT is both the stream and rope character type.
+class _Rope_insert_char_consumer : public _Rope_char_consumer<_CharT> {
+private:
+ typedef basic_ostream<_CharT,_Traits> _Insert_ostream;
+ typedef _Rope_insert_char_consumer<_CharT,_Traits> _Self;
+ _Insert_ostream& _M_o;
+
+ //explicitely defined as private to avoid warnings:
+ _Self& operator = (_Self const&);
+public:
+ _Rope_insert_char_consumer(_Insert_ostream& __writer)
+ : _M_o(__writer) {}
+ ~_Rope_insert_char_consumer() {}
+ // Caller is presumed to own the ostream
+ bool operator() (const _CharT* __leaf, size_t __n);
+ // Returns true to continue traversal.
+};
+
+template<class _CharT, class _Traits>
+bool _Rope_insert_char_consumer<_CharT, _Traits>::operator()
+ (const _CharT* __leaf, size_t __n) {
+ size_t __i;
+ // We assume that formatting is set up correctly for each element.
+ for (__i = 0; __i < __n; ++__i) _M_o.put(__leaf[__i]);
+ return true;
+}
+#endif /* !_STLP_USE_NO_IOSTREAMS */
+
+template <class _CharT, class _Alloc, class _CharConsumer>
+bool _S_apply_to_pieces(_CharConsumer& __c,
+ _Rope_RopeRep<_CharT, _Alloc> * __r,
+ size_t __begin, size_t __end) {
+ typedef _Rope_RopeRep<_CharT, _Alloc> _RopeRep;
+ typedef _Rope_RopeConcatenation<_CharT,_Alloc> _RopeConcatenation;
+ typedef _Rope_RopeLeaf<_CharT,_Alloc> _RopeLeaf;
+ typedef _Rope_RopeFunction<_CharT,_Alloc> _RopeFunction;
+
+ if (0 == __r) return true;
+ switch(__r->_M_tag) {
+ case _RopeRep::_S_concat:
+ {
+ _RopeConcatenation* __conc = __STATIC_CAST(_RopeConcatenation*, __r);
+ _RopeRep* __left = __conc->_M_left;
+ size_t __left_len = __left->_M_size._M_data;
+ if (__begin < __left_len) {
+ size_t __left_end = (min) (__left_len, __end);
+ if (!_S_apply_to_pieces(__c, __left, __begin, __left_end))
+ return false;
+ }
+ if (__end > __left_len) {
+ _RopeRep* __right = __conc->_M_right;
+ size_t __right_start = (max)(__left_len, __begin);
+ if (!_S_apply_to_pieces(__c, __right,
+ __right_start - __left_len,
+ __end - __left_len)) {
+ return false;
+ }
+ }
+ }
+ return true;
+ case _RopeRep::_S_leaf:
+ {
+ _RopeLeaf* __l = __STATIC_CAST(_RopeLeaf*, __r);
+ return __c(__l->_M_data + __begin, __end - __begin);
+ }
+ case _RopeRep::_S_function:
+ case _RopeRep::_S_substringfn:
+ {
+ _RopeFunction* __f = __STATIC_CAST(_RopeFunction*, __r);
+ size_t __len = __end - __begin;
+ bool __result;
+ _CharT* __buffer = __r->get_allocator().allocate(__len);
+ _STLP_TRY {
+ (*(__f->_M_fn))(__begin, __len, __buffer);
+ __result = __c(__buffer, __len);
+ __r->get_allocator().deallocate(__buffer, __len);
+ }
+ _STLP_UNWIND((__r->get_allocator().deallocate(__buffer, __len)))
+ return __result;
+ }
+ default:
+ _STLP_ASSERT(false)
+ /*NOTREACHED*/
+ return false;
+ }
+}
+
+#if !defined (_STLP_USE_NO_IOSTREAMS)
+template<class _CharT, class _Traits>
+inline void _Rope_fill(basic_ostream<_CharT, _Traits>& __o, streamsize __n) {
+ char __f = __o.fill();
+ for (streamsize __i = 0; __i < __n; ++__i) __o.put(__f);
+}
+
+template<class _CharT, class _Traits, class _Alloc>
+basic_ostream<_CharT, _Traits>& _S_io_get(basic_ostream<_CharT, _Traits>& __o,
+ const rope<_CharT, _Alloc>& __r, const __true_type& /*_IsBasicCharType*/) {
+ streamsize __w = __o.width();
+ const bool __left = (__o.flags() & ios::left) != 0;
+ size_t __rope_len = __r.size();
+ _Rope_insert_char_consumer<_CharT, _Traits> __c(__o);
+
+ const bool __need_pad = (((sizeof(streamsize) > sizeof(size_t)) && (__STATIC_CAST(streamsize, __rope_len) < __w)) ||
+ ((sizeof(streamsize) <= sizeof(size_t)) && (__rope_len < __STATIC_CAST(size_t, __w))));
+ streamsize __pad_len = __need_pad ? __w - __rope_len : 0;
+
+ if (!__left && __pad_len > 0) {
+ _Rope_fill(__o, __pad_len);
+ }
+ __r.apply_to_pieces(0, __rope_len, __c);
+ if (__left && __pad_len > 0) {
+ _Rope_fill(__o, __pad_len);
+ }
+ return __o;
+}
+
+template<class _CharT, class _Traits, class _Alloc>
+basic_ostream<_CharT, _Traits>& _S_io_get(basic_ostream<_CharT, _Traits>& __o,
+ const rope<_CharT, _Alloc>& __r, const __false_type& /*_IsBasicCharType*/) {
+ streamsize __w = __o.width();
+ size_t __rope_len = __r.size();
+ _Rope_insert_char_consumer<_CharT, _Traits> __c(__o);
+
+ __o.width(__w /__rope_len);
+ _STLP_TRY {
+ __r.apply_to_pieces(0, __rope_len, __c);
+ __o.width(__w);
+ }
+ _STLP_UNWIND(__o.width(__w))
+ return __o;
+}
+
+template<class _CharT, class _Traits, class _Alloc>
+basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __o,
+ const rope<_CharT, _Alloc>& __r) {
+ typedef typename _IsIntegral<_CharT>::_Ret _Char_Is_Integral;
+ return _S_io_get(__o, __r, _Char_Is_Integral());
+}
+#endif /* NO_IOSTREAMS */
+
+template <class _CharT, class _Alloc>
+_CharT* rope<_CharT,_Alloc>::_S_flatten(_RopeRep* __r,
+ size_t __start, size_t __len,
+ _CharT* __buffer) {
+ _Rope_flatten_char_consumer<_CharT> __c(__buffer);
+ _S_apply_to_pieces(__c, __r, __start, __start + __len);
+ return(__buffer + __len);
+}
+
+template <class _CharT, class _Alloc>
+size_t rope<_CharT,_Alloc>::find(_CharT __pattern, size_t __start) const {
+ _Rope_find_char_char_consumer<_CharT> __c(__pattern);
+ _S_apply_to_pieces(__c, _M_tree_ptr._M_data, __start, size());
+ size_type __result_pos = __start + __c._M_count;
+#ifndef _STLP_OLD_ROPE_SEMANTICS
+ if (__result_pos == size()) __result_pos = npos;
+#endif
+ return __result_pos;
+}
+
+template <class _CharT, class _Alloc>
+_CharT*
+rope<_CharT,_Alloc>::_S_flatten(_Rope_RopeRep<_CharT, _Alloc>* __r, _CharT* __buffer) {
+ if (0 == __r) return __buffer;
+ switch(__r->_M_tag) {
+ case _RopeRep::_S_concat:
+ {
+ _RopeConcatenation* __c = __STATIC_CAST(_RopeConcatenation*, __r);
+ _RopeRep* __left = __c->_M_left;
+ _RopeRep* __right = __c->_M_right;
+ _CharT* __rest = _S_flatten(__left, __buffer);
+ return _S_flatten(__right, __rest);
+ }
+ case _RopeRep::_S_leaf:
+ {
+ _RopeLeaf* __l = __STATIC_CAST(_RopeLeaf*, __r);
+ return _STLP_PRIV __ucopy_n(__l->_M_data, __l->_M_size._M_data, __buffer).second;
+ }
+ case _RopeRep::_S_function:
+ case _RopeRep::_S_substringfn:
+ // We dont yet do anything with substring nodes.
+ // This needs to be fixed before ropefiles will work well.
+ {
+ _RopeFunction* __f = __STATIC_CAST(_RopeFunction*, __r);
+ (*(__f->_M_fn))(0, __f->_M_size._M_data, __buffer);
+ return __buffer + __f->_M_size._M_data;
+ }
+ default:
+ _STLP_ASSERT(false)
+ /*NOTREACHED*/
+ return 0;
+ }
+}
+
+#ifdef _STLP_DEBUG
+// This needs work for _CharT != char
+template <class _CharT, class _Alloc>
+void rope<_CharT,_Alloc>::_S_dump(_RopeRep* __r, int __indent) {
+ for (int __i = 0; __i < __indent; ++__i) putchar(' ');
+ if (0 == __r) {
+ printf("NULL\n"); return;
+ }
+ if (_RopeRep::_S_concat == __r->_M_tag) {
+ _RopeConcatenation* __c = __STATIC_CAST(_RopeConcatenation*, __r);
+ _RopeRep* __left = __c->_M_left;
+ _RopeRep* __right = __c->_M_right;
+ printf("Concatenation %p (rc = %ld, depth = %d, len = %ld, %s balanced)\n",
+ __r, __r->_M_ref_count, __r->_M_depth, __r->_M_size._M_data,
+ __r->_M_is_balanced? "" : "not");
+ _S_dump(__left, __indent + 2);
+ _S_dump(__right, __indent + 2);
+ return;
+ }
+ else {
+ const char* __kind;
+
+ switch (__r->_M_tag) {
+ case _RopeRep::_S_leaf:
+ __kind = "Leaf";
+ break;
+ case _RopeRep::_S_function:
+ __kind = "Function";
+ break;
+ case _RopeRep::_S_substringfn:
+ __kind = "Function representing substring";
+ break;
+ default:
+ __kind = "(corrupted kind field!)";
+ }
+ printf("%s %p (rc = %ld, depth = %d, len = %ld) ",
+ __kind, __r, __r->_M_ref_count, __r->_M_depth, __r->_M_size._M_data);
+ if (sizeof(_CharT) == 1) {
+ const int __max_len = 40;
+ _Self_destruct_ptr __prefix(_S_substring(__r, 0, __max_len));
+ _CharT __buffer[__max_len + 1];
+ bool __too_big = __r->_M_size._M_data > __prefix->_M_size._M_data;
+
+ _S_flatten(__prefix, __buffer);
+ __buffer[__prefix->_M_size._M_data] = _STLP_DEFAULT_CONSTRUCTED(_CharT);
+ printf("%s%s\n", (char*)__buffer, __too_big? "...\n" : "\n");
+ } else {
+ printf("\n");
+ }
+ }
+}
+#endif /* _STLP_DEBUG */
+
+# define __ROPE_TABLE_BODY = { \
+/* 0 */1, /* 1 */2, /* 2 */3, /* 3 */5, /* 4 */8, /* 5 */13, /* 6 */21, \
+/* 7 */34, /* 8 */55, /* 9 */89, /* 10 */144, /* 11 */233, /* 12 */377, \
+/* 13 */610, /* 14 */987, /* 15 */1597, /* 16 */2584, /* 17 */4181, \
+/* 18 */6765ul, /* 19 */10946ul, /* 20 */17711ul, /* 21 */28657ul, /* 22 */46368ul, \
+/* 23 */75025ul, /* 24 */121393ul, /* 25 */196418ul, /* 26 */317811ul, \
+/* 27 */514229ul, /* 28 */832040ul, /* 29 */1346269ul, /* 30 */2178309ul, \
+/* 31 */3524578ul, /* 32 */5702887ul, /* 33 */9227465ul, /* 34 */14930352ul, \
+/* 35 */24157817ul, /* 36 */39088169ul, /* 37 */63245986ul, /* 38 */102334155ul, \
+/* 39 */165580141ul, /* 40 */267914296ul, /* 41 */433494437ul, \
+/* 42 */701408733ul, /* 43 */1134903170ul, /* 44 */1836311903ul, \
+/* 45 */2971215073ul }
+
+template <class _CharT, class _Alloc>
+const unsigned long
+rope<_CharT,_Alloc>::_S_min_len[__ROPE_DEPTH_SIZE] __ROPE_TABLE_BODY;
+# undef __ROPE_DEPTH_SIZE
+# undef __ROPE_MAX_DEPTH
+# undef __ROPE_TABLE_BODY
+
+// These are Fibonacci numbers < 2**32.
+
+template <class _CharT, class _Alloc>
+__RopeRep__* rope<_CharT,_Alloc>::_S_balance(_RopeRep* __r) {
+ _RopeRep* __forest[_RopeRep::_S_max_rope_depth + 1] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0};
+ _RopeRep* __result = 0;
+ int __i;
+ // Invariant:
+ // The concatenation of forest in descending order is equal to __r.
+ // __forest[__i]._M_size._M_data >= _S_min_len[__i]
+ // __forest[__i]._M_depth = __i
+ // References from forest are included in refcount.
+
+ _STLP_TRY {
+ _S_add_to_forest(__r, __forest);
+ for (__i = 0; __i <= _RopeRep::_S_max_rope_depth; ++__i)
+ if (0 != __forest[__i]) {
+ _Self_destruct_ptr __old(__result);
+ __result = _S_concat_rep(__forest[__i], __result);
+ __forest[__i]->_M_unref_nonnil();
+# ifdef _STLP_USE_EXCEPTIONS
+ __forest[__i] = 0;
+# endif
+ }
+ }
+ _STLP_UNWIND(for(__i = 0; __i <= _RopeRep::_S_max_rope_depth; ++__i)
+ _S_unref(__forest[__i]))
+ if (__result->_M_depth > _RopeRep::_S_max_rope_depth) {
+ __stl_throw_range_error("rope too long");
+ }
+ return(__result);
+}
+
+
+template <class _CharT, class _Alloc>
+void
+rope<_CharT,_Alloc>::_S_add_to_forest(_RopeRep* __r, _RopeRep** __forest)
+{
+ if (__r -> _M_is_balanced) {
+ _S_add_leaf_to_forest(__r, __forest);
+ return;
+ }
+ _STLP_ASSERT(__r->_M_tag == _RopeRep::_S_concat)
+ {
+ _RopeConcatenation* __c = (_RopeConcatenation*)__r;
+
+ _S_add_to_forest(__c->_M_left, __forest);
+ _S_add_to_forest(__c->_M_right, __forest);
+ }
+}
+
+
+template <class _CharT, class _Alloc>
+void
+rope<_CharT,_Alloc>::_S_add_leaf_to_forest(_RopeRep* __r, _RopeRep** __forest)
+{
+ _RopeRep* __insertee; // included in refcount
+ _RopeRep* __too_tiny = 0; // included in refcount
+ int __i; // forest[0..__i-1] is empty
+ size_t __s = __r->_M_size._M_data;
+
+ for (__i = 0; __s >= _S_min_len[__i+1]/* not this bucket */; ++__i) {
+ if (0 != __forest[__i]) {
+ _Self_destruct_ptr __old(__too_tiny);
+ __too_tiny = _S_concat_and_set_balanced(__forest[__i], __too_tiny);
+ __forest[__i]->_M_unref_nonnil();
+ __forest[__i] = 0;
+ }
+ }
+ {
+ _Self_destruct_ptr __old(__too_tiny);
+ __insertee = _S_concat_and_set_balanced(__too_tiny, __r);
+ }
+ // Too_tiny dead, and no longer included in refcount.
+ // Insertee is live and included.
+ _STLP_ASSERT(_S_is_almost_balanced(__insertee))
+ _STLP_ASSERT(__insertee->_M_depth <= __r->_M_depth + 1)
+ for (;; ++__i) {
+ if (0 != __forest[__i]) {
+ _Self_destruct_ptr __old(__insertee);
+ __insertee = _S_concat_and_set_balanced(__forest[__i], __insertee);
+ __forest[__i]->_M_unref_nonnil();
+ __forest[__i] = 0;
+ _STLP_ASSERT(_S_is_almost_balanced(__insertee))
+ }
+ _STLP_ASSERT(_S_min_len[__i] <= __insertee->_M_size._M_data)
+ _STLP_ASSERT(__forest[__i] == 0)
+ if (__i == _RopeRep::_S_max_rope_depth ||
+ __insertee->_M_size._M_data < _S_min_len[__i+1]) {
+ __forest[__i] = __insertee;
+ // refcount is OK since __insertee is now dead.
+ return;
+ }
+ }
+}
+
+template <class _CharT, class _Alloc>
+_CharT
+rope<_CharT,_Alloc>::_S_fetch(_RopeRep* __r, size_type __i)
+{
+ _CharT* __cstr = __r->_M_c_string;
+
+ _STLP_ASSERT(__i < __r->_M_size._M_data)
+ if (0 != __cstr) return __cstr[__i];
+ for(;;) {
+ switch(__r->_M_tag) {
+ case _RopeRep::_S_concat:
+ {
+ _RopeConcatenation* __c = (_RopeConcatenation*)__r;
+ _RopeRep* __left = __c->_M_left;
+ size_t __left_len = __left->_M_size._M_data;
+
+ if (__i >= __left_len) {
+ __i -= __left_len;
+ __r = __c->_M_right;
+ } else {
+ __r = __left;
+ }
+ }
+ break;
+ case _RopeRep::_S_leaf:
+ {
+ _RopeLeaf* __l = (_RopeLeaf*)__r;
+ return __l->_M_data[__i];
+ }
+ case _RopeRep::_S_function:
+ case _RopeRep::_S_substringfn:
+ {
+ _RopeFunction* __f = (_RopeFunction*)__r;
+ _CharT __result;
+
+ (*(__f->_M_fn))(__i, 1, &__result);
+ return __result;
+ }
+ }
+ }
+#if defined(_STLP_NEED_UNREACHABLE_RETURN)
+ return 0;
+#endif
+}
+
+// Return a uniquely referenced character slot for the given
+// position, or 0 if that's not possible.
+template <class _CharT, class _Alloc>
+_CharT*
+rope<_CharT,_Alloc>::_S_fetch_ptr(_RopeRep* __r, size_type __i)
+{
+ _RopeRep* __clrstack[_RopeRep::_S_max_rope_depth];
+ size_t __csptr = 0;
+
+ for(;;) {
+ // if (__r->_M_ref_count > 1) return 0;
+ if ( __r->_M_incr() > 2 ) {
+ __r->_M_decr();
+ return 0;
+ }
+ switch(__r->_M_tag) {
+ case _RopeRep::_S_concat:
+ {
+ _RopeConcatenation* __c = (_RopeConcatenation*)__r;
+ _RopeRep* __left = __c->_M_left;
+ size_t __left_len = __left->_M_size._M_data;
+
+ if (__c->_M_c_string != 0) __clrstack[__csptr++] = __c;
+ if (__i >= __left_len) {
+ __i -= __left_len;
+ __r = __c->_M_right;
+ } else {
+ __r = __left;
+ }
+ }
+ break;
+ case _RopeRep::_S_leaf:
+ {
+ _RopeLeaf* __l = (_RopeLeaf*)__r;
+ if (__l->_M_c_string != __l->_M_data && __l->_M_c_string != 0)
+ __clrstack[__csptr++] = __l;
+ while (__csptr > 0) {
+ -- __csptr;
+ _RopeRep* __d = __clrstack[__csptr];
+ __d->_M_free_c_string();
+ __d->_M_c_string = 0;
+ }
+ return __l->_M_data + __i;
+ }
+ case _RopeRep::_S_function:
+ case _RopeRep::_S_substringfn:
+ return 0;
+ }
+ }
+#if defined(_STLP_NEED_UNREACHABLE_RETURN)
+ return 0;
+#endif
+
+}
+
+// The following could be implemented trivially using
+// lexicographical_compare_3way.
+// We do a little more work to avoid dealing with rope iterators for
+// flat strings.
+template <class _CharT, class _Alloc>
+int
+rope<_CharT,_Alloc>::_S_compare (const _RopeRep* __left,
+ const _RopeRep* __right) {
+ size_t __left_len;
+ size_t __right_len;
+
+ if (0 == __right) return 0 != __left;
+ if (0 == __left) return -1;
+ __left_len = __left->_M_size._M_data;
+ __right_len = __right->_M_size._M_data;
+ if (_RopeRep::_S_leaf == __left->_M_tag) {
+ const _RopeLeaf* __l = __STATIC_CAST(const _RopeLeaf*, __left);
+ if (_RopeRep::_S_leaf == __right->_M_tag) {
+ const _RopeLeaf* __r = __STATIC_CAST(const _RopeLeaf*, __right);
+ return _STLP_PRIV __lexicographical_compare_3way(__l->_M_data, __l->_M_data + __left_len,
+ __r->_M_data, __r->_M_data + __right_len);
+ }
+ else {
+ const_iterator __rstart(__right, 0);
+ const_iterator __rend(__right, __right_len);
+ return _STLP_PRIV __lexicographical_compare_3way(__l->_M_data, __l->_M_data + __left_len,
+ __rstart, __rend);
+ }
+ }
+ else {
+ const_iterator __lstart(__left, 0);
+ const_iterator __lend(__left, __left_len);
+ if (_RopeRep::_S_leaf == __right->_M_tag) {
+ const _RopeLeaf* __r = __STATIC_CAST(const _RopeLeaf*, __right);
+ return _STLP_PRIV __lexicographical_compare_3way(__lstart, __lend,
+ __r->_M_data, __r->_M_data + __right_len);
+ }
+ else {
+ const_iterator __rstart(__right, 0);
+ const_iterator __rend(__right, __right_len);
+ return _STLP_PRIV __lexicographical_compare_3way(__lstart, __lend, __rstart, __rend);
+ }
+ }
+}
+
+// Assignment to reference proxies.
+template <class _CharT, class _Alloc>
+_Rope_char_ref_proxy<_CharT, _Alloc>&
+_Rope_char_ref_proxy<_CharT, _Alloc>::operator= (_CharT __c) {
+ _RopeRep* __old = _M_root->_M_tree_ptr._M_data;
+ // First check for the case in which everything is uniquely
+ // referenced. In that case we can do this destructively.
+ _CharT* __ptr = _My_rope::_S_fetch_ptr(__old, _M_pos);
+ if (0 != __ptr) {
+ *__ptr = __c;
+ return *this;
+ }
+ _Self_destruct_ptr __left(
+ _My_rope::_S_substring(__old, 0, _M_pos));
+ _Self_destruct_ptr __right(
+ _My_rope::_S_substring(__old, _M_pos+1, __old->_M_size._M_data));
+ _Self_destruct_ptr __result_left(
+ _My_rope::_S_destr_concat_char_iter(__left, &__c, 1));
+
+ // _STLP_ASSERT(__left == __result_left || 1 == __result_left->_M_ref_count)
+ _RopeRep* __result =
+ _My_rope::_S_concat_rep(__result_left, __right);
+ // _STLP_ASSERT(1 <= __result->_M_ref_count)
+ _RopeRep::_S_unref(__old);
+ _M_root->_M_tree_ptr._M_data = __result;
+ return *this;
+}
+
+template <class _CharT, class _Alloc>
+_Rope_char_ptr_proxy<_CharT, _Alloc>
+_Rope_char_ref_proxy<_CharT, _Alloc>::operator& () const {
+ return _Rope_char_ptr_proxy<_CharT, _Alloc>(*this);
+}
+
+template<class _CharT, class _Alloc>
+_CharT rope<_CharT,_Alloc>::_S_empty_c_str[1] = { _CharT() };
+// # endif
+
+#if !defined (_STLP_STATIC_CONST_INIT_BUG) && !defined (_STLP_NO_STATIC_CONST_DEFINITION)
+template <class _CharT, class _Alloc>
+const size_t rope<_CharT, _Alloc>::npos;
+#endif
+
+template<class _CharT, class _Alloc>
+const _CharT* rope<_CharT,_Alloc>::c_str() const {
+ if (0 == _M_tree_ptr._M_data) {
+ // Possibly redundant, but probably fast.
+ _S_empty_c_str[0] = _STLP_DEFAULT_CONSTRUCTED(_CharT);
+ return _S_empty_c_str;
+ }
+ _CharT* __old_c_string = _M_tree_ptr._M_data->_M_c_string;
+ if (0 != __old_c_string) return __old_c_string;
+ size_t __s = size();
+ _CharT* __result = _STLP_CREATE_ALLOCATOR(allocator_type,(const allocator_type&)_M_tree_ptr, _CharT).allocate(__s + 1);
+ _S_flatten(_M_tree_ptr._M_data, __result);
+ _S_construct_null(__result + __s);
+ __old_c_string = __STATIC_CAST(_CharT*, _Atomic_swap_ptr(__REINTERPRET_CAST(void* _STLP_VOLATILE*, &(_M_tree_ptr._M_data->_M_c_string)),
+ __result));
+ if (0 != __old_c_string) {
+ // It must have been added in the interim. Hence it had to have been
+ // separately allocated. Deallocate the old copy, since we just
+ // replaced it.
+ _STLP_STD::_Destroy_Range(__old_c_string, __old_c_string + __s + 1);
+ _STLP_CREATE_ALLOCATOR(allocator_type,(const allocator_type&)_M_tree_ptr, _CharT).deallocate(__old_c_string, __s + 1);
+ }
+ return __result;
+}
+
+template<class _CharT, class _Alloc>
+const _CharT* rope<_CharT,_Alloc>::replace_with_c_str() {
+ if (0 == _M_tree_ptr._M_data) {
+ _S_empty_c_str[0] = _STLP_DEFAULT_CONSTRUCTED(_CharT);
+ return _S_empty_c_str;
+ }
+ _CharT* __old_c_string = _M_tree_ptr._M_data->_M_c_string;
+ if (_RopeRep::_S_leaf == _M_tree_ptr._M_data->_M_tag && 0 != __old_c_string) {
+ return __old_c_string;
+ }
+ size_t __s = size();
+ _CharT* __result = _M_tree_ptr.allocate(_S_rounded_up_size(__s));
+ _S_flatten(_M_tree_ptr._M_data, __result);
+ _S_construct_null(__result + __s);
+ _M_tree_ptr._M_data->_M_unref_nonnil();
+ _M_tree_ptr._M_data = _S_new_RopeLeaf(__result, __s, _M_tree_ptr);
+ return __result;
+}
+
+// Algorithm specializations. More should be added.
+
+#if (!defined (_STLP_MSVC) || (_STLP_MSVC >= 1310)) && !defined (__DMC__)
+// I couldn't get this to work with VC++
+template<class _CharT,class _Alloc>
+void _Rope_rotate(_Rope_iterator<_CharT,_Alloc> __first,
+ _Rope_iterator<_CharT,_Alloc> __middle,
+ _Rope_iterator<_CharT,_Alloc> __last) {
+ _STLP_ASSERT(__first.container() == __middle.container() &&
+ __middle.container() == __last.container())
+ rope<_CharT,_Alloc>& __r(__first.container());
+ rope<_CharT,_Alloc> __prefix = __r.substr(0, __first.index());
+ rope<_CharT,_Alloc> __suffix =
+ __r.substr(__last.index(), __r.size() - __last.index());
+ rope<_CharT,_Alloc> __part1 =
+ __r.substr(__middle.index(), __last.index() - __middle.index());
+ rope<_CharT,_Alloc> __part2 =
+ __r.substr(__first.index(), __middle.index() - __first.index());
+ __r = __prefix;
+ __r += __part1;
+ __r += __part2;
+ __r += __suffix;
+}
+
+
+# if 0
+// Probably not useful for several reasons:
+// - for SGIs 7.1 compiler and probably some others,
+// this forces lots of rope<wchar_t, ...> instantiations, creating a
+// code bloat and compile time problem. (Fixed in 7.2.)
+// - wchar_t is 4 bytes wide on most UNIX platforms, making it unattractive
+// for unicode strings. Unsigned short may be a better character
+// type.
+inline void rotate(
+ _Rope_iterator<wchar_t, allocator<char> > __first,
+ _Rope_iterator<wchar_t, allocator<char> > __middle,
+ _Rope_iterator<wchar_t, allocator<char> > __last) {
+ _Rope_rotate(__first, __middle, __last);
+}
+# endif
+#endif /* _STLP_MSVC */
+
+# undef __RopeLeaf__
+# undef __RopeRep__
+# undef __RopeLeaf
+# undef __RopeRep
+# undef size_type
+
+_STLP_END_NAMESPACE
+
+# endif /* ROPEIMPL_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_rope.h b/sources/android/stlport/stlport/stl/_rope.h
new file mode 100644
index 0000000..f100f67
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_rope.h
@@ -0,0 +1,2389 @@
+/*
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+// rope<_CharT,_Alloc> is a sequence of _CharT.
+// Ropes appear to be mutable, but update operations
+// really copy enough of the data structure to leave the original
+// valid. Thus ropes can be logically copied by just copying
+// a pointer value.
+
+#ifndef _STLP_INTERNAL_ROPE_H
+#define _STLP_INTERNAL_ROPE_H
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+# include <stl/_algobase.h>
+#endif
+
+#if !defined (_STLP_USE_NO_IOSTREAMS) && !defined (_STLP_INTERNAL_IOSFWD)
+# include <stl/_iosfwd.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+# include <stl/_alloc.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+# include <stl/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALGO_H
+# include <stl/_algo.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+# include <stl/_function_base.h>
+#endif
+
+#ifndef _STLP_INTERNAL_NUMERIC_H
+# include <stl/_numeric.h>
+#endif
+
+#ifndef _STLP_INTERNAL_HASH_FUN_H
+# include <stl/_hash_fun.h>
+#endif
+
+#ifndef _STLP_CHAR_TRAITS_H
+# include <stl/char_traits.h>
+#endif
+
+#ifndef _STLP_INTERNAL_THREADS_H
+# include <stl/_threads.h>
+#endif
+
+#ifdef _STLP_SGI_THREADS
+# include <mutex.h>
+#endif
+
+#ifndef _STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE
+# define _STLP_CREATE_ALLOCATOR(__atype,__a, _Tp) (_Alloc_traits<_Tp,__atype>::create_allocator(__a))
+#else
+# define _STLP_CREATE_ALLOCATOR(__atype,__a, _Tp) __stl_alloc_create(__a,(_Tp*)0)
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+// First a lot of forward declarations. The standard seems to require
+// much stricter "declaration before use" than many of the implementations
+// that preceded it.
+template<class _CharT, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_CharT>) > class rope;
+template<class _CharT, class _Alloc> struct _Rope_RopeConcatenation;
+template<class _CharT, class _Alloc> struct _Rope_RopeRep;
+template<class _CharT, class _Alloc> struct _Rope_RopeLeaf;
+template<class _CharT, class _Alloc> struct _Rope_RopeFunction;
+template<class _CharT, class _Alloc> struct _Rope_RopeSubstring;
+template<class _CharT, class _Alloc> class _Rope_iterator;
+template<class _CharT, class _Alloc> class _Rope_const_iterator;
+template<class _CharT, class _Alloc> class _Rope_char_ref_proxy;
+template<class _CharT, class _Alloc> class _Rope_char_ptr_proxy;
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _CharT>
+struct _BasicCharType { typedef __false_type _Ret; };
+
+_STLP_TEMPLATE_NULL
+struct _BasicCharType<char> { typedef __true_type _Ret; };
+
+#ifdef _STLP_HAS_WCHAR_T
+_STLP_TEMPLATE_NULL
+struct _BasicCharType<wchar_t> { typedef __true_type _Ret; };
+#endif
+
+// Some helpers, so we can use the power algorithm on ropes.
+// See below for why this isn't local to the implementation.
+
+// This uses a nonstandard refcount convention.
+// The result has refcount 0.
+template<class _CharT, class _Alloc>
+struct _Rope_Concat_fn
+ : public binary_function<rope<_CharT,_Alloc>, rope<_CharT,_Alloc>,
+ rope<_CharT,_Alloc> > {
+ rope<_CharT,_Alloc> operator() (const rope<_CharT,_Alloc>& __x,
+ const rope<_CharT,_Alloc>& __y) {
+ return __x + __y;
+ }
+};
+
+template <class _CharT, class _Alloc>
+inline
+rope<_CharT,_Alloc>
+__identity_element(_Rope_Concat_fn<_CharT, _Alloc>)
+{ return rope<_CharT,_Alloc>(); }
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+// Store an eos
+template <class _CharT>
+inline void _S_construct_null_aux(_CharT *__p, const __true_type&)
+{ *__p = 0; }
+
+template <class _CharT>
+inline void _S_construct_null_aux(_CharT *__p, const __false_type&)
+{ _STLP_STD::_Construct(__p); }
+
+template <class _CharT>
+inline void _S_construct_null(_CharT *__p) {
+ typedef typename _IsIntegral<_CharT>::_Ret _Char_Is_Integral;
+ _S_construct_null_aux(__p, _Char_Is_Integral());
+}
+
+// char_producers are logically functions that generate a section of
+// a string. These can be converted to ropes. The resulting rope
+// invokes the char_producer on demand. This allows, for example,
+// files to be viewed as ropes without reading the entire file.
+template <class _CharT>
+class char_producer {
+public:
+ virtual ~char_producer() {}
+ virtual void operator()(size_t __start_pos, size_t __len,
+ _CharT* __buffer) = 0;
+ // Buffer should really be an arbitrary output iterator.
+ // That way we could flatten directly into an ostream, etc.
+ // This is thoroughly impossible, since iterator types don't
+ // have runtime descriptions.
+};
+
+// Sequence buffers:
+//
+// Sequence must provide an append operation that appends an
+// array to the sequence. Sequence buffers are useful only if
+// appending an entire array is cheaper than appending element by element.
+// This is true for many string representations.
+// This should perhaps inherit from ostream<sequence::value_type>
+// and be implemented correspondingly, so that they can be used
+// for formatted. For the sake of portability, we don't do this yet.
+//
+// For now, sequence buffers behave as output iterators. But they also
+// behave a little like basic_ostringstream<sequence::value_type> and a
+// little like containers.
+
+template<class _Sequence
+# if !(defined (_STLP_NON_TYPE_TMPL_PARAM_BUG) || \
+ defined ( _STLP_NO_DEFAULT_NON_TYPE_PARAM ))
+ , size_t _Buf_sz = 100
+# if defined(__sgi) && !defined(__GNUC__)
+# define __TYPEDEF_WORKAROUND
+ ,class _V = typename _Sequence::value_type
+# endif /* __sgi */
+# endif /* _STLP_NON_TYPE_TMPL_PARAM_BUG */
+ >
+// The 3rd parameter works around a common compiler bug.
+class sequence_buffer : public iterator <output_iterator_tag, void, void, void, void> {
+public:
+# ifndef __TYPEDEF_WORKAROUND
+ typedef typename _Sequence::value_type value_type;
+ typedef sequence_buffer<_Sequence
+# if !(defined (_STLP_NON_TYPE_TMPL_PARAM_BUG) || \
+ defined ( _STLP_NO_DEFAULT_NON_TYPE_PARAM ))
+ , _Buf_sz
+ > _Self;
+# else /* _STLP_NON_TYPE_TMPL_PARAM_BUG */
+ > _Self;
+ enum { _Buf_sz = 100};
+# endif /* _STLP_NON_TYPE_TMPL_PARAM_BUG */
+ // # endif
+# else /* __TYPEDEF_WORKAROUND */
+ typedef _V value_type;
+ typedef sequence_buffer<_Sequence, _Buf_sz, _V> _Self;
+# endif /* __TYPEDEF_WORKAROUND */
+protected:
+ _Sequence* _M_prefix;
+ value_type _M_buffer[_Buf_sz];
+ size_t _M_buf_count;
+public:
+ void flush() {
+ _M_prefix->append(_M_buffer, _M_buffer + _M_buf_count);
+ _M_buf_count = 0;
+ }
+ ~sequence_buffer() { flush(); }
+ sequence_buffer() : _M_prefix(0), _M_buf_count(0) {}
+ sequence_buffer(const _Self& __x) {
+ _M_prefix = __x._M_prefix;
+ _M_buf_count = __x._M_buf_count;
+ _STLP_STD::copy(__x._M_buffer, __x._M_buffer + __x._M_buf_count, _M_buffer);
+ }
+ sequence_buffer(_Self& __x) {
+ __x.flush();
+ _M_prefix = __x._M_prefix;
+ _M_buf_count = 0;
+ }
+ sequence_buffer(_Sequence& __s) : _M_prefix(&__s), _M_buf_count(0) {}
+ _Self& operator= (_Self& __x) {
+ __x.flush();
+ _M_prefix = __x._M_prefix;
+ _M_buf_count = 0;
+ return *this;
+ }
+ _Self& operator= (const _Self& __x) {
+ _M_prefix = __x._M_prefix;
+ _M_buf_count = __x._M_buf_count;
+ _STLP_STD::copy(__x._M_buffer, __x._M_buffer + __x._M_buf_count, _M_buffer);
+ return *this;
+ }
+ void push_back(value_type __x) {
+ if (_M_buf_count < _Buf_sz) {
+ _M_buffer[_M_buf_count] = __x;
+ ++_M_buf_count;
+ } else {
+ flush();
+ _M_buffer[0] = __x;
+ _M_buf_count = 1;
+ }
+ }
+ void append(const value_type *__s, size_t __len) {
+ if (__len + _M_buf_count <= _Buf_sz) {
+ size_t __i = _M_buf_count;
+ size_t __j = 0;
+ for (; __j < __len; __i++, __j++) {
+ _M_buffer[__i] = __s[__j];
+ }
+ _M_buf_count += __len;
+ } else if (0 == _M_buf_count) {
+ _M_prefix->append(__s, __s + __len);
+ } else {
+ flush();
+ append(__s, __len);
+ }
+ }
+ _Self& write(const value_type *__s, size_t __len) {
+ append(__s, __len);
+ return *this;
+ }
+ _Self& put(value_type __x) {
+ push_back(__x);
+ return *this;
+ }
+ _Self& operator=(const value_type& __rhs) {
+ push_back(__rhs);
+ return *this;
+ }
+ _Self& operator*() { return *this; }
+ _Self& operator++() { return *this; }
+ _Self& operator++(int) { return *this; }
+};
+
+// The following should be treated as private, at least for now.
+template<class _CharT>
+class _Rope_char_consumer {
+#if !defined (_STLP_MEMBER_TEMPLATES)
+public:
+ //Without member templates we have to use run-time parameterization.
+ // The symmetry with char_producer is accidental and temporary.
+ virtual ~_Rope_char_consumer() {}
+ virtual bool operator()(const _CharT* __buffer, size_t __len) = 0;
+#endif
+};
+
+//
+// What follows should really be local to rope. Unfortunately,
+// that doesn't work, since it makes it impossible to define generic
+// equality on rope iterators. According to the draft standard, the
+// template parameters for such an equality operator cannot be inferred
+// from the occurence of a member class as a parameter.
+// (SGI compilers in fact allow this, but the __result wouldn't be
+// portable.)
+// Similarly, some of the static member functions are member functions
+// only to avoid polluting the global namespace, and to circumvent
+// restrictions on type inference for template functions.
+//
+
+//
+// The internal data structure for representing a rope. This is
+// private to the implementation. A rope is really just a pointer
+// to one of these.
+//
+// A few basic functions for manipulating this data structure
+// are members of _RopeRep. Most of the more complex algorithms
+// are implemented as rope members.
+//
+// Some of the static member functions of _RopeRep have identically
+// named functions in rope that simply invoke the _RopeRep versions.
+//
+
+template<class _CharT, class _Alloc>
+struct _Rope_RopeRep
+ : public _Refcount_Base
+{
+ typedef _Rope_RopeRep<_CharT, _Alloc> _Self;
+public:
+ //
+ // GAB: 11/09/05
+ //
+ // "__ROPE_DEPTH_SIZE" is set to one more then the "__ROPE_MAX_DEPTH".
+ // This was originally just an addition of "__ROPE_MAX_DEPTH + 1"
+ // but this addition causes the sunpro compiler to complain about
+ // multiple declarations during the initialization of "_S_min_len".
+ // Changed to be a fixed value and the sunpro compiler appears to
+ // be happy???
+ //
+# define __ROPE_MAX_DEPTH 45
+# define __ROPE_DEPTH_SIZE 46 // __ROPE_MAX_DEPTH + 1
+ enum { _S_max_rope_depth = __ROPE_MAX_DEPTH };
+ enum _Tag {_S_leaf, _S_concat, _S_substringfn, _S_function};
+ // Apparently needed by VC++
+ // The data fields of leaves are allocated with some
+ // extra space, to accomodate future growth and for basic
+ // character types, to hold a trailing eos character.
+ enum { _S_alloc_granularity = 8 };
+
+ _Tag _M_tag:8;
+ bool _M_is_balanced:8;
+
+ _STLP_FORCE_ALLOCATORS(_CharT, _Alloc)
+ typedef _Alloc allocator_type;
+
+ allocator_type get_allocator() const { return allocator_type(_M_size); }
+
+ unsigned char _M_depth;
+ _CharT* _STLP_VOLATILE _M_c_string;
+ _STLP_PRIV _STLP_alloc_proxy<size_t, _CharT, allocator_type> _M_size;
+
+#ifdef _STLP_NO_ARROW_OPERATOR
+ _Rope_RopeRep() : _Refcount_Base(1), _M_size(allocator_type(), 0) {
+# if defined (_STLP_CHECK_RUNTIME_COMPATIBILITY)
+ _STLP_CHECK_RUNTIME_COMPATIBILITY();
+# endif
+ }
+#endif
+
+ /* Flattened version of string, if needed. */
+ /* typically 0. */
+ /* If it's not 0, then the memory is owned */
+ /* by this node. */
+ /* In the case of a leaf, this may point to */
+ /* the same memory as the data field. */
+ _Rope_RopeRep(_Tag __t, unsigned char __d, bool __b, size_t _p_size,
+ allocator_type __a) :
+ _Refcount_Base(1),
+ _M_tag(__t), _M_is_balanced(__b), _M_depth(__d), _M_c_string(0), _M_size(__a, _p_size) {
+#if defined (_STLP_CHECK_RUNTIME_COMPATIBILITY)
+ _STLP_CHECK_RUNTIME_COMPATIBILITY();
+#endif
+ }
+
+ typedef _STLP_TYPENAME _STLP_PRIV _BasicCharType<_CharT>::_Ret _IsBasicCharType;
+
+#if 0
+ /* Please tell why this code is necessary if you uncomment it.
+ * Problem with it is that rope implementation expect that _S_rounded_up_size(n)
+ * returns a size > n in order to store the terminating null charater. When
+ * instanciation type is not a char or wchar_t this is not guaranty resulting in
+ * memory overrun.
+ */
+ static size_t _S_rounded_up_size_aux(size_t __n, __true_type const& /*_IsBasicCharType*/) {
+ // Allow slop for in-place expansion.
+ return (__n + _S_alloc_granularity) & ~(_S_alloc_granularity - 1);
+ }
+
+ static size_t _S_rounded_up_size_aux(size_t __n, __false_type const& /*_IsBasicCharType*/) {
+ // Allow slop for in-place expansion.
+ return (__n + _S_alloc_granularity - 1) & ~(_S_alloc_granularity - 1);
+ }
+#endif
+ // fbp : moved from RopeLeaf
+ static size_t _S_rounded_up_size(size_t __n)
+ //{ return _S_rounded_up_size_aux(__n, _IsBasicCharType()); }
+ { return (__n + _S_alloc_granularity) & ~(_S_alloc_granularity - 1); }
+
+ static void _S_free_string( _CharT* __s, size_t __len,
+ allocator_type __a) {
+ _STLP_STD::_Destroy_Range(__s, __s + __len);
+ // This has to be a static member, so this gets a bit messy
+# ifndef _STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE
+ __a.deallocate(__s, _S_rounded_up_size(__len)); //*ty 03/24/2001 - restored not to use __stl_alloc_rebind() since it is not defined under _STLP_MEMBER_TEMPLATE_CLASSES
+# else
+ __stl_alloc_rebind (__a, (_CharT*)0).deallocate(__s, _S_rounded_up_size(__len));
+# endif
+ }
+
+ // Deallocate data section of a leaf.
+ // This shouldn't be a member function.
+ // But its hard to do anything else at the
+ // moment, because it's templatized w.r.t.
+ // an allocator.
+ // Does nothing if __GC is defined.
+ void _M_free_c_string();
+ void _M_free_tree();
+ // Deallocate t. Assumes t is not 0.
+ void _M_unref_nonnil() {
+ if (_M_decr() == 0) _M_free_tree();
+ }
+ void _M_ref_nonnil() {
+ _M_incr();
+ }
+ static void _S_unref(_Self* __t) {
+ if (0 != __t) {
+ __t->_M_unref_nonnil();
+ }
+ }
+ static void _S_ref(_Self* __t) {
+ if (0 != __t) __t->_M_incr();
+ }
+ //static void _S_free_if_unref(_Self* __t) {
+ // if (0 != __t && 0 == __t->_M_ref_count) __t->_M_free_tree();
+ //}
+};
+
+template<class _CharT, class _Alloc>
+struct _Rope_RopeLeaf : public _Rope_RopeRep<_CharT,_Alloc> {
+public:
+ _CharT* _M_data; /* Not necessarily 0 terminated. */
+ /* The allocated size is */
+ /* _S_rounded_up_size(size), except */
+ /* in the GC case, in which it */
+ /* doesn't matter. */
+private:
+ typedef _Rope_RopeRep<_CharT,_Alloc> _RopeRep;
+ typedef typename _RopeRep::_IsBasicCharType _IsBasicCharType;
+ void _M_init(__true_type const& /*_IsBasicCharType*/) {
+ this->_M_c_string = _M_data;
+ }
+ void _M_init(__false_type const& /*_IsBasicCharType*/) {}
+
+public:
+ _STLP_FORCE_ALLOCATORS(_CharT, _Alloc)
+ typedef typename _RopeRep::allocator_type allocator_type;
+
+ _Rope_RopeLeaf( _CharT* __d, size_t _p_size, allocator_type __a)
+ : _Rope_RopeRep<_CharT,_Alloc>(_RopeRep::_S_leaf, 0, true, _p_size, __a),
+ _M_data(__d) {
+ _STLP_ASSERT(_p_size > 0)
+ _M_init(_IsBasicCharType());
+ }
+
+# ifdef _STLP_NO_ARROW_OPERATOR
+ _Rope_RopeLeaf() {}
+ _Rope_RopeLeaf(const _Rope_RopeLeaf<_CharT, _Alloc>& ) {}
+# endif
+
+// The constructor assumes that d has been allocated with
+ // the proper allocator and the properly padded size.
+ // In contrast, the destructor deallocates the data:
+ ~_Rope_RopeLeaf() {
+ if (_M_data != this->_M_c_string) {
+ this->_M_free_c_string();
+ }
+ _RopeRep::_S_free_string(_M_data, this->_M_size._M_data, this->get_allocator());
+ }
+};
+
+template<class _CharT, class _Alloc>
+struct _Rope_RopeConcatenation : public _Rope_RopeRep<_CharT, _Alloc> {
+private:
+ typedef _Rope_RopeRep<_CharT,_Alloc> _RopeRep;
+
+public:
+ _RopeRep* _M_left;
+ _RopeRep* _M_right;
+ _STLP_FORCE_ALLOCATORS(_CharT, _Alloc)
+ typedef typename _RopeRep::allocator_type allocator_type;
+ _Rope_RopeConcatenation(_RopeRep* __l, _RopeRep* __r, allocator_type __a)
+ : _Rope_RopeRep<_CharT,_Alloc>(_RopeRep::_S_concat,
+ (max)(__l->_M_depth, __r->_M_depth) + 1, false,
+ __l->_M_size._M_data + __r->_M_size._M_data, __a), _M_left(__l), _M_right(__r)
+ {}
+# ifdef _STLP_NO_ARROW_OPERATOR
+ _Rope_RopeConcatenation() {}
+ _Rope_RopeConcatenation(const _Rope_RopeConcatenation<_CharT, _Alloc>&) {}
+# endif
+
+ ~_Rope_RopeConcatenation() {
+ this->_M_free_c_string();
+ _M_left->_M_unref_nonnil();
+ _M_right->_M_unref_nonnil();
+ }
+};
+
+template <class _CharT, class _Alloc>
+struct _Rope_RopeFunction : public _Rope_RopeRep<_CharT, _Alloc> {
+private:
+ typedef _Rope_RopeRep<_CharT,_Alloc> _RopeRep;
+public:
+ char_producer<_CharT>* _M_fn;
+ /*
+ * Char_producer is owned by the
+ * rope and should be explicitly
+ * deleted when the rope becomes
+ * inaccessible.
+ */
+ bool _M_delete_when_done;
+ _STLP_FORCE_ALLOCATORS(_CharT, _Alloc)
+ typedef typename _Rope_RopeRep<_CharT,_Alloc>::allocator_type allocator_type;
+# ifdef _STLP_NO_ARROW_OPERATOR
+ _Rope_RopeFunction() {}
+ _Rope_RopeFunction(const _Rope_RopeFunction<_CharT, _Alloc>& ) {}
+# endif
+
+ _Rope_RopeFunction(char_producer<_CharT>* __f, size_t _p_size,
+ bool __d, allocator_type __a)
+ : _Rope_RopeRep<_CharT,_Alloc>(_RopeRep::_S_function, 0, true, _p_size, __a), _M_fn(__f)
+ , _M_delete_when_done(__d)
+ { _STLP_ASSERT(_p_size > 0) }
+
+ ~_Rope_RopeFunction() {
+ this->_M_free_c_string();
+ if (_M_delete_when_done) {
+ delete _M_fn;
+ }
+ }
+};
+
+/*
+ * Substring results are usually represented using just
+ * concatenation nodes. But in the case of very long flat ropes
+ * or ropes with a functional representation that isn't practical.
+ * In that case, we represent the __result as a special case of
+ * RopeFunction, whose char_producer points back to the rope itself.
+ * In all cases except repeated substring operations and
+ * deallocation, we treat the __result as a RopeFunction.
+ */
+template<class _CharT, class _Alloc>
+struct _Rope_RopeSubstring : public char_producer<_CharT>, public _Rope_RopeFunction<_CharT,_Alloc> {
+public:
+ // XXX this whole class should be rewritten.
+ typedef _Rope_RopeRep<_CharT,_Alloc> _RopeRep;
+ _RopeRep *_M_base; // not 0
+ size_t _M_start;
+ /* virtual */ void operator()(size_t __start_pos, size_t __req_len,
+ _CharT* __buffer) {
+ typedef _Rope_RopeFunction<_CharT,_Alloc> _RopeFunction;
+ typedef _Rope_RopeLeaf<_CharT,_Alloc> _RopeLeaf;
+ switch (_M_base->_M_tag) {
+ case _RopeRep::_S_function:
+ case _RopeRep::_S_substringfn:
+ {
+ char_producer<_CharT>* __fn =
+ __STATIC_CAST(_RopeFunction*, _M_base)->_M_fn;
+ _STLP_ASSERT(__start_pos + __req_len <= this->_M_size._M_data)
+ _STLP_ASSERT(_M_start + this->_M_size._M_data <= _M_base->_M_size._M_data)
+ (*__fn)(__start_pos + _M_start, __req_len, __buffer);
+ }
+ break;
+ case _RopeRep::_S_leaf:
+ {
+ _CharT* __s =
+ __STATIC_CAST(_RopeLeaf*, _M_base)->_M_data;
+ _STLP_PRIV __ucopy_n(__s + __start_pos + _M_start, __req_len, __buffer);
+ }
+ break;
+ default:
+ _STLP_ASSERT(false)
+ ;
+ }
+ }
+
+ _STLP_FORCE_ALLOCATORS(_CharT, _Alloc)
+ typedef typename _RopeRep::allocator_type allocator_type;
+
+ _Rope_RopeSubstring(_RopeRep* __b, size_t __s, size_t __l, allocator_type __a)
+ : _Rope_RopeFunction<_CharT,_Alloc>(this, __l, false, __a),
+ _M_base(__b), _M_start(__s) {
+ _STLP_ASSERT(__l > 0)
+ _STLP_ASSERT(__s + __l <= __b->_M_size._M_data)
+ _M_base->_M_ref_nonnil();
+ this->_M_tag = _RopeRep::_S_substringfn;
+ }
+ virtual ~_Rope_RopeSubstring()
+ { _M_base->_M_unref_nonnil(); }
+};
+
+/*
+ * Self-destructing pointers to Rope_rep.
+ * These are not conventional smart pointers. Their
+ * only purpose in life is to ensure that unref is called
+ * on the pointer either at normal exit or if an exception
+ * is raised. It is the caller's responsibility to
+ * adjust reference counts when these pointers are initialized
+ * or assigned to. (This convention significantly reduces
+ * the number of potentially expensive reference count
+ * updates.)
+ */
+template<class _CharT, class _Alloc>
+struct _Rope_self_destruct_ptr {
+ _Rope_RopeRep<_CharT,_Alloc>* _M_ptr;
+ ~_Rope_self_destruct_ptr()
+ { _Rope_RopeRep<_CharT,_Alloc>::_S_unref(_M_ptr); }
+# ifdef _STLP_USE_EXCEPTIONS
+ _Rope_self_destruct_ptr() : _M_ptr(0) {}
+# else
+ _Rope_self_destruct_ptr() {}
+# endif
+ _Rope_self_destruct_ptr(_Rope_RopeRep<_CharT,_Alloc>* __p) : _M_ptr(__p) {}
+ _Rope_RopeRep<_CharT,_Alloc>& operator*() { return *_M_ptr; }
+ _Rope_RopeRep<_CharT,_Alloc>* operator->() { return _M_ptr; }
+ operator _Rope_RopeRep<_CharT,_Alloc>*() { return _M_ptr; }
+ _Rope_self_destruct_ptr<_CharT, _Alloc>&
+ operator= (_Rope_RopeRep<_CharT,_Alloc>* __x)
+ { _M_ptr = __x; return *this; }
+};
+
+/*
+ * Dereferencing a nonconst iterator has to return something
+ * that behaves almost like a reference. It's not possible to
+ * return an actual reference since assignment requires extra
+ * work. And we would get into the same problems as with the
+ * CD2 version of basic_string.
+ */
+template<class _CharT, class _Alloc>
+class _Rope_char_ref_proxy {
+ typedef _Rope_char_ref_proxy<_CharT, _Alloc> _Self;
+ friend class rope<_CharT,_Alloc>;
+ friend class _Rope_iterator<_CharT,_Alloc>;
+ friend class _Rope_char_ptr_proxy<_CharT,_Alloc>;
+ typedef _Rope_self_destruct_ptr<_CharT,_Alloc> _Self_destruct_ptr;
+ typedef _Rope_RopeRep<_CharT,_Alloc> _RopeRep;
+ typedef rope<_CharT,_Alloc> _My_rope;
+ size_t _M_pos;
+ _CharT _M_current;
+ bool _M_current_valid;
+ _My_rope* _M_root; // The whole rope.
+public:
+ _Rope_char_ref_proxy(_My_rope* __r, size_t __p) :
+ _M_pos(__p), _M_current_valid(false), _M_root(__r) {}
+ _Rope_char_ref_proxy(const _Self& __x) :
+ _M_pos(__x._M_pos), _M_current_valid(false), _M_root(__x._M_root) {}
+ // Don't preserve cache if the reference can outlive the
+ // expression. We claim that's not possible without calling
+ // a copy constructor or generating reference to a proxy
+ // reference. We declare the latter to have undefined semantics.
+ _Rope_char_ref_proxy(_My_rope* __r, size_t __p, _CharT __c)
+ : _M_pos(__p), _M_current(__c), _M_current_valid(true), _M_root(__r) {}
+ inline operator _CharT () const;
+ _Self& operator= (_CharT __c);
+ _Rope_char_ptr_proxy<_CharT, _Alloc> operator& () const;
+ _Self& operator= (const _Self& __c) {
+ return operator=((_CharT)__c);
+ }
+};
+
+#ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER
+template<class _CharT, class __Alloc>
+inline void swap(_Rope_char_ref_proxy <_CharT, __Alloc > __a,
+ _Rope_char_ref_proxy <_CharT, __Alloc > __b) {
+ _CharT __tmp = __a;
+ __a = __b;
+ __b = __tmp;
+}
+#else
+// There is no really acceptable way to handle this. The default
+// definition of swap doesn't work for proxy references.
+// It can't really be made to work, even with ugly hacks, since
+// the only unusual operation it uses is the copy constructor, which
+// is needed for other purposes. We provide a macro for
+// full specializations, and instantiate the most common case.
+# define _ROPE_SWAP_SPECIALIZATION(_CharT, __Alloc) \
+ inline void swap(_Rope_char_ref_proxy <_CharT, __Alloc > __a, \
+ _Rope_char_ref_proxy <_CharT, __Alloc > __b) { \
+ _CharT __tmp = __a; \
+ __a = __b; \
+ __b = __tmp; \
+ }
+
+_ROPE_SWAP_SPECIALIZATION(char, allocator<char>)
+
+# ifndef _STLP_NO_WCHAR_T
+_ROPE_SWAP_SPECIALIZATION(wchar_t, allocator<wchar_t>)
+# endif
+
+#endif /* !_STLP_FUNCTION_TMPL_PARTIAL_ORDER */
+
+template<class _CharT, class _Alloc>
+class _Rope_char_ptr_proxy {
+ // XXX this class should be rewritten.
+public:
+ typedef _Rope_char_ptr_proxy<_CharT, _Alloc> _Self;
+ friend class _Rope_char_ref_proxy<_CharT,_Alloc>;
+ size_t _M_pos;
+ rope<_CharT,_Alloc>* _M_root; // The whole rope.
+
+ _Rope_char_ptr_proxy(const _Rope_char_ref_proxy<_CharT,_Alloc>& __x)
+ : _M_pos(__x._M_pos), _M_root(__x._M_root) {}
+ _Rope_char_ptr_proxy(const _Self& __x)
+ : _M_pos(__x._M_pos), _M_root(__x._M_root) {}
+ _Rope_char_ptr_proxy() {}
+ _Rope_char_ptr_proxy(_CharT* __x) : _M_pos(0), _M_root(0) {
+ _STLP_ASSERT(0 == __x)
+ }
+ _Self& operator= (const _Self& __x) {
+ _M_pos = __x._M_pos;
+ _M_root = __x._M_root;
+ return *this;
+ }
+
+ _Rope_char_ref_proxy<_CharT,_Alloc> operator*() const {
+ return _Rope_char_ref_proxy<_CharT,_Alloc>(_M_root, _M_pos);
+ }
+};
+
+
+/*
+ * Rope iterators:
+ * Unlike in the C version, we cache only part of the stack
+ * for rope iterators, since they must be efficiently copyable.
+ * When we run out of cache, we have to reconstruct the iterator
+ * value.
+ * Pointers from iterators are not included in reference counts.
+ * Iterators are assumed to be thread private. Ropes can
+ * be shared.
+ */
+template<class _CharT, class _Alloc>
+class _Rope_iterator_base
+/* : public random_access_iterator<_CharT, ptrdiff_t> */
+{
+ friend class rope<_CharT,_Alloc>;
+ typedef _Rope_iterator_base<_CharT, _Alloc> _Self;
+ typedef _Rope_RopeConcatenation<_CharT,_Alloc> _RopeConcat;
+public:
+ typedef _Rope_RopeRep<_CharT,_Alloc> _RopeRep;
+
+ enum { _S_path_cache_len = 4 }; // Must be <= 9 because of _M_path_direction.
+ enum { _S_iterator_buf_len = 15 };
+ size_t _M_current_pos;
+ // The whole rope.
+ _RopeRep* _M_root;
+ // Starting position for current leaf
+ size_t _M_leaf_pos;
+ // Buffer possibly containing current char.
+ _CharT* _M_buf_start;
+ // Pointer to current char in buffer, != 0 ==> buffer valid.
+ _CharT* _M_buf_ptr;
+ // One past __last valid char in buffer.
+ _CharT* _M_buf_end;
+
+ // What follows is the path cache. We go out of our
+ // way to make this compact.
+ // Path_end contains the bottom section of the path from
+ // the root to the current leaf.
+ struct {
+# if defined (__BORLANDC__) && (__BORLANDC__ < 0x560)
+ _RopeRep const*_M_data[4];
+# else
+ _RopeRep const*_M_data[_S_path_cache_len];
+# endif
+ } _M_path_end;
+ // Last valid __pos in path_end;
+ // _M_path_end[0] ... _M_path_end[_M_leaf_index-1]
+ // point to concatenation nodes.
+ int _M_leaf_index;
+ // (_M_path_directions >> __i) & 1 is 1
+ // if we got from _M_path_end[leaf_index - __i - 1]
+ // to _M_path_end[leaf_index - __i] by going to the
+ // __right. Assumes path_cache_len <= 9.
+ unsigned char _M_path_directions;
+ // Short buffer for surrounding chars.
+ // This is useful primarily for
+ // RopeFunctions. We put the buffer
+ // here to avoid locking in the
+ // multithreaded case.
+ // The cached path is generally assumed to be valid
+ // only if the buffer is valid.
+ struct {
+# if defined (__BORLANDC__) && (__BORLANDC__ < 0x560)
+ _CharT _M_data[15];
+# else
+ _CharT _M_data[_S_iterator_buf_len];
+# endif
+ } _M_tmp_buf;
+
+ // Set buffer contents given path cache.
+ static void _S_setbuf(_Rope_iterator_base<_CharT, _Alloc>& __x);
+ // Set buffer contents and path cache.
+ static void _S_setcache(_Rope_iterator_base<_CharT, _Alloc>& __x);
+ // As above, but assumes path cache is valid for previous posn.
+ static void _S_setcache_for_incr(_Rope_iterator_base<_CharT, _Alloc>& __x);
+ _Rope_iterator_base() {}
+ _Rope_iterator_base(_RopeRep* __root, size_t __pos)
+ : _M_current_pos(__pos),_M_root(__root), _M_buf_ptr(0) {}
+ void _M_incr(size_t __n);
+ void _M_decr(size_t __n);
+public:
+ size_t index() const { return _M_current_pos; }
+private:
+ void _M_copy_buf(const _Self& __x) {
+ _M_tmp_buf = __x._M_tmp_buf;
+ if (__x._M_buf_start == __x._M_tmp_buf._M_data) {
+ _M_buf_start = _M_tmp_buf._M_data;
+ _M_buf_end = _M_buf_start + (__x._M_buf_end - __x._M_buf_start);
+ _M_buf_ptr = _M_buf_start + (__x._M_buf_ptr - __x._M_buf_start);
+ } else {
+ _M_buf_end = __x._M_buf_end;
+ }
+ }
+
+public:
+ _Rope_iterator_base(const _Self& __x) :
+ _M_current_pos(__x._M_current_pos),
+ _M_root(__x._M_root),
+ _M_leaf_pos( __x._M_leaf_pos ),
+ _M_buf_start(__x._M_buf_start),
+ _M_buf_ptr(__x._M_buf_ptr),
+ _M_path_end(__x._M_path_end),
+ _M_leaf_index(__x._M_leaf_index),
+ _M_path_directions(__x._M_path_directions)
+ {
+ if (0 != __x._M_buf_ptr) {
+ _M_copy_buf(__x);
+ }
+ }
+ _Self& operator = (const _Self& __x)
+ {
+ _M_current_pos = __x._M_current_pos;
+ _M_root = __x._M_root;
+ _M_buf_start = __x._M_buf_start;
+ _M_buf_ptr = __x._M_buf_ptr;
+ _M_path_end = __x._M_path_end;
+ _M_leaf_index = __x._M_leaf_index;
+ _M_path_directions = __x._M_path_directions;
+ _M_leaf_pos = __x._M_leaf_pos;
+ if (0 != __x._M_buf_ptr) {
+ _M_copy_buf(__x);
+ }
+ return *this;
+ }
+};
+
+template<class _CharT, class _Alloc> class _Rope_iterator;
+
+template<class _CharT, class _Alloc>
+class _Rope_const_iterator : public _Rope_iterator_base<_CharT,_Alloc> {
+ friend class rope<_CharT,_Alloc>;
+ typedef _Rope_const_iterator<_CharT, _Alloc> _Self;
+ typedef _Rope_iterator_base<_CharT,_Alloc> _Base;
+ // protected:
+public:
+# ifndef _STLP_HAS_NO_NAMESPACES
+ typedef _Rope_RopeRep<_CharT,_Alloc> _RopeRep;
+ // The one from the base class may not be directly visible.
+# endif
+ _Rope_const_iterator(const _RopeRep* __root, size_t __pos):
+ _Rope_iterator_base<_CharT,_Alloc>(__CONST_CAST(_RopeRep*,__root), __pos)
+ // Only nonconst iterators modify root ref count
+ {}
+public:
+ typedef _CharT reference; // Really a value. Returning a reference
+ // Would be a mess, since it would have
+ // to be included in refcount.
+ typedef const _CharT* pointer;
+ typedef _CharT value_type;
+ typedef ptrdiff_t difference_type;
+ typedef random_access_iterator_tag iterator_category;
+
+public:
+ _Rope_const_iterator() {}
+ _Rope_const_iterator(const _Self& __x) :
+ _Rope_iterator_base<_CharT,_Alloc>(__x) { }
+ _Rope_const_iterator(const _Rope_iterator<_CharT,_Alloc>& __x):
+ _Rope_iterator_base<_CharT,_Alloc>(__x) {}
+ _Rope_const_iterator(const rope<_CharT,_Alloc>& __r, size_t __pos) :
+ _Rope_iterator_base<_CharT,_Alloc>(__r._M_tree_ptr._M_data, __pos) {}
+ _Self& operator= (const _Self& __x) {
+ _Base::operator=(__x);
+ return *this;
+ }
+ reference operator*() {
+ if (0 == this->_M_buf_ptr)
+#if !defined (__DMC__)
+ _S_setcache(*this);
+#else
+ { _Rope_iterator_base<_CharT, _Alloc>* __x = this; _S_setcache(*__x); }
+#endif
+ return *(this->_M_buf_ptr);
+ }
+ _Self& operator++()
+ {
+ if ( this->_M_buf_ptr != 0 ) {
+ _CharT *__next = this->_M_buf_ptr + 1;
+ if ( __next < this->_M_buf_end ) {
+ this->_M_buf_ptr = __next;
+ ++this->_M_current_pos;
+ return *this;
+ }
+ }
+ this->_M_incr(1);
+ return *this;
+ }
+ _Self& operator+=(ptrdiff_t __n) {
+ if (__n >= 0) {
+ this->_M_incr(__n);
+ } else {
+ this->_M_decr(-__n);
+ }
+ return *this;
+ }
+ _Self& operator--() {
+ this->_M_decr(1);
+ return *this;
+ }
+ _Self& operator-=(ptrdiff_t __n) {
+ if (__n >= 0) {
+ this->_M_decr(__n);
+ } else {
+ this->_M_incr(-__n);
+ }
+ return *this;
+ }
+ _Self operator++(int) {
+ size_t __old_pos = this->_M_current_pos;
+ this->_M_incr(1);
+ return _Rope_const_iterator<_CharT,_Alloc>(this->_M_root, __old_pos);
+ // This makes a subsequent dereference expensive.
+ // Perhaps we should instead copy the iterator
+ // if it has a valid cache?
+ }
+ _Self operator--(int) {
+ size_t __old_pos = this->_M_current_pos;
+ this->_M_decr(1);
+ return _Rope_const_iterator<_CharT,_Alloc>(this->_M_root, __old_pos);
+ }
+ inline reference operator[](size_t __n);
+};
+
+template<class _CharT, class _Alloc>
+class _Rope_iterator : public _Rope_iterator_base<_CharT,_Alloc> {
+ friend class rope<_CharT,_Alloc>;
+ typedef _Rope_iterator<_CharT, _Alloc> _Self;
+ typedef _Rope_iterator_base<_CharT,_Alloc> _Base;
+ typedef _Rope_RopeRep<_CharT,_Alloc> _RopeRep;
+
+public:
+ rope<_CharT,_Alloc>* _M_root_rope;
+ // root is treated as a cached version of this,
+ // and is used to detect changes to the underlying
+ // rope.
+ // Root is included in the reference count.
+ // This is necessary so that we can detect changes reliably.
+ // Unfortunately, it requires careful bookkeeping for the
+ // nonGC case.
+ _Rope_iterator(rope<_CharT,_Alloc>* __r, size_t __pos);
+
+ void _M_check();
+public:
+ typedef _Rope_char_ref_proxy<_CharT,_Alloc> reference;
+ typedef _Rope_char_ref_proxy<_CharT,_Alloc>* pointer;
+ typedef _CharT value_type;
+ typedef ptrdiff_t difference_type;
+ typedef random_access_iterator_tag iterator_category;
+public:
+ ~_Rope_iterator() { //*TY 5/6/00 - added dtor to balance reference count
+ _RopeRep::_S_unref(this->_M_root);
+ }
+
+ rope<_CharT,_Alloc>& container() { return *_M_root_rope; }
+ _Rope_iterator() {
+ this->_M_root = 0; // Needed for reference counting.
+ }
+ _Rope_iterator(const _Self& __x) :
+ _Rope_iterator_base<_CharT,_Alloc>(__x) {
+ _M_root_rope = __x._M_root_rope;
+ _RopeRep::_S_ref(this->_M_root);
+ }
+ _Rope_iterator(rope<_CharT,_Alloc>& __r, size_t __pos);
+ _Self& operator= (const _Self& __x) {
+ _RopeRep* __old = this->_M_root;
+ _RopeRep::_S_ref(__x._M_root);
+ _Base::operator=(__x);
+ _M_root_rope = __x._M_root_rope;
+ _RopeRep::_S_unref(__old);
+ return *this;
+ }
+ reference operator*() {
+ _M_check();
+ if (0 == this->_M_buf_ptr) {
+ return reference(_M_root_rope, this->_M_current_pos);
+ } else {
+ return reference(_M_root_rope, this->_M_current_pos, *(this->_M_buf_ptr));
+ }
+ }
+ _Self& operator++() {
+ this->_M_incr(1);
+ return *this;
+ }
+ _Self& operator+=(ptrdiff_t __n) {
+ if (__n >= 0) {
+ this->_M_incr(__n);
+ } else {
+ this->_M_decr(-__n);
+ }
+ return *this;
+ }
+ _Self& operator--() {
+ this->_M_decr(1);
+ return *this;
+ }
+ _Self& operator-=(ptrdiff_t __n) {
+ if (__n >= 0) {
+ this->_M_decr(__n);
+ } else {
+ this->_M_incr(-__n);
+ }
+ return *this;
+ }
+ _Self operator++(int) {
+ size_t __old_pos = this->_M_current_pos;
+ this->_M_incr(1);
+ return _Self(_M_root_rope, __old_pos);
+ }
+ _Self operator--(int) {
+ size_t __old_pos = this->_M_current_pos;
+ this->_M_decr(1);
+ return _Self(_M_root_rope, __old_pos);
+ }
+ reference operator[](ptrdiff_t __n) {
+ return reference(_M_root_rope, this->_M_current_pos + __n);
+ }
+};
+
+# ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
+template <class _CharT, class _Alloc>
+inline random_access_iterator_tag
+iterator_category(const _Rope_iterator<_CharT,_Alloc>&) { return random_access_iterator_tag();}
+template <class _CharT, class _Alloc>
+inline _CharT* value_type(const _Rope_iterator<_CharT,_Alloc>&) { return 0; }
+template <class _CharT, class _Alloc>
+inline ptrdiff_t* distance_type(const _Rope_iterator<_CharT,_Alloc>&) { return 0; }
+template <class _CharT, class _Alloc>
+inline random_access_iterator_tag
+iterator_category(const _Rope_const_iterator<_CharT,_Alloc>&) { return random_access_iterator_tag(); }
+template <class _CharT, class _Alloc>
+inline _CharT* value_type(const _Rope_const_iterator<_CharT,_Alloc>&) { return 0; }
+template <class _CharT, class _Alloc>
+inline ptrdiff_t* distance_type(const _Rope_const_iterator<_CharT,_Alloc>&) { return 0; }
+#endif /* _STLP_USE_OLD_HP_ITERATOR_QUERIES */
+
+template <class _CharT, class _Alloc, class _CharConsumer>
+bool _S_apply_to_pieces(_CharConsumer& __c,
+ _Rope_RopeRep<_CharT, _Alloc> *__r,
+ size_t __begin, size_t __end);
+ // begin and end are assumed to be in range.
+
+template <class _CharT, class _Alloc>
+class rope
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ : public __stlport_class<rope<_CharT, _Alloc> >
+#endif
+{
+ typedef rope<_CharT,_Alloc> _Self;
+public:
+ typedef _CharT value_type;
+ typedef ptrdiff_t difference_type;
+ typedef size_t size_type;
+ typedef _CharT const_reference;
+ typedef const _CharT* const_pointer;
+ typedef _Rope_iterator<_CharT,_Alloc> iterator;
+ typedef _Rope_const_iterator<_CharT,_Alloc> const_iterator;
+ typedef _Rope_char_ref_proxy<_CharT,_Alloc> reference;
+ typedef _Rope_char_ptr_proxy<_CharT,_Alloc> pointer;
+
+ friend class _Rope_iterator<_CharT,_Alloc>;
+ friend class _Rope_const_iterator<_CharT,_Alloc>;
+ friend struct _Rope_RopeRep<_CharT,_Alloc>;
+ friend class _Rope_iterator_base<_CharT,_Alloc>;
+ friend class _Rope_char_ptr_proxy<_CharT,_Alloc>;
+ friend class _Rope_char_ref_proxy<_CharT,_Alloc>;
+ friend struct _Rope_RopeSubstring<_CharT,_Alloc>;
+
+ _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS;
+
+protected:
+ typedef _CharT* _Cstrptr;
+
+ static _CharT _S_empty_c_str[1];
+
+ enum { _S_copy_max = 23 };
+ // For strings shorter than _S_copy_max, we copy to
+ // concatenate.
+
+ typedef _Rope_RopeRep<_CharT, _Alloc> _RopeRep;
+ typedef typename _RopeRep::_IsBasicCharType _IsBasicCharType;
+
+public:
+ _STLP_FORCE_ALLOCATORS(_CharT, _Alloc)
+ typedef _Alloc allocator_type;
+
+public:
+ // The only data member of a rope:
+ _STLP_PRIV _STLP_alloc_proxy<_RopeRep*, _CharT, allocator_type> _M_tree_ptr;
+
+public:
+ allocator_type get_allocator() const { return allocator_type(_M_tree_ptr); }
+
+public:
+ typedef _Rope_RopeConcatenation<_CharT,_Alloc> _RopeConcatenation;
+ typedef _Rope_RopeLeaf<_CharT,_Alloc> _RopeLeaf;
+ typedef _Rope_RopeFunction<_CharT,_Alloc> _RopeFunction;
+ typedef _Rope_RopeSubstring<_CharT,_Alloc> _RopeSubstring;
+
+ // Retrieve a character at the indicated position.
+ static _CharT _S_fetch(_RopeRep* __r, size_type __pos);
+
+ // Obtain a pointer to the character at the indicated position.
+ // The pointer can be used to change the character.
+ // If such a pointer cannot be produced, as is frequently the
+ // case, 0 is returned instead.
+ // (Returns nonzero only if all nodes in the path have a refcount
+ // of 1.)
+ static _CharT* _S_fetch_ptr(_RopeRep* __r, size_type __pos);
+
+ static void _S_unref(_RopeRep* __t) {
+ _RopeRep::_S_unref(__t);
+ }
+ static void _S_ref(_RopeRep* __t) {
+ _RopeRep::_S_ref(__t);
+ }
+
+ typedef _Rope_self_destruct_ptr<_CharT,_Alloc> _Self_destruct_ptr;
+
+ // _Result is counted in refcount.
+ static _RopeRep* _S_substring(_RopeRep* __base,
+ size_t __start, size_t __endp1);
+
+ static _RopeRep* _S_concat_char_iter(_RopeRep* __r,
+ const _CharT* __iter, size_t __slen);
+ // Concatenate rope and char ptr, copying __s.
+ // Should really take an arbitrary iterator.
+ // Result is counted in refcount.
+ static _RopeRep* _S_destr_concat_char_iter(_RopeRep* __r,
+ const _CharT* __iter, size_t __slen);
+ // As above, but one reference to __r is about to be
+ // destroyed. Thus the pieces may be recycled if all
+ // relevent reference counts are 1.
+
+ // General concatenation on _RopeRep. _Result
+ // has refcount of 1. Adjusts argument refcounts.
+ static _RopeRep* _S_concat_rep(_RopeRep* __left, _RopeRep* __right);
+
+public:
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _CharConsumer>
+#else
+ typedef _Rope_char_consumer<_CharT> _CharConsumer;
+#endif
+ void apply_to_pieces(size_t __begin, size_t __end,
+ _CharConsumer& __c) const
+ { _S_apply_to_pieces(__c, _M_tree_ptr._M_data, __begin, __end); }
+
+protected:
+
+ static size_t _S_rounded_up_size(size_t __n)
+ { return _RopeRep::_S_rounded_up_size(__n); }
+
+ // Allocate and construct a RopeLeaf using the supplied allocator
+ // Takes ownership of s instead of copying.
+ static _RopeLeaf* _S_new_RopeLeaf(_CharT *__s,
+ size_t _p_size, allocator_type __a) {
+ _RopeLeaf* __space = _STLP_CREATE_ALLOCATOR(allocator_type, __a,
+ _RopeLeaf).allocate(1);
+ _STLP_TRY {
+ new(__space) _RopeLeaf(__s, _p_size, __a);
+ }
+ _STLP_UNWIND(_STLP_CREATE_ALLOCATOR(allocator_type,__a,
+ _RopeLeaf).deallocate(__space, 1))
+ return __space;
+ }
+
+ static _RopeConcatenation* _S_new_RopeConcatenation(_RopeRep* __left, _RopeRep* __right,
+ allocator_type __a) {
+ _RopeConcatenation* __space = _STLP_CREATE_ALLOCATOR(allocator_type, __a,
+ _RopeConcatenation).allocate(1);
+ return new(__space) _RopeConcatenation(__left, __right, __a);
+ }
+
+ static _RopeFunction* _S_new_RopeFunction(char_producer<_CharT>* __f,
+ size_t _p_size, bool __d, allocator_type __a) {
+ _RopeFunction* __space = _STLP_CREATE_ALLOCATOR(allocator_type, __a,
+ _RopeFunction).allocate(1);
+ return new(__space) _RopeFunction(__f, _p_size, __d, __a);
+ }
+
+ static _RopeSubstring* _S_new_RopeSubstring(_Rope_RopeRep<_CharT,_Alloc>* __b, size_t __s,
+ size_t __l, allocator_type __a) {
+ _RopeSubstring* __space = _STLP_CREATE_ALLOCATOR(allocator_type, __a,
+ _RopeSubstring).allocate(1);
+ return new(__space) _RopeSubstring(__b, __s, __l, __a);
+ }
+
+ static
+ _RopeLeaf* _S_RopeLeaf_from_unowned_char_ptr(const _CharT *__s,
+ size_t _p_size, allocator_type __a) {
+ if (0 == _p_size) return 0;
+
+ _CharT* __buf = _STLP_CREATE_ALLOCATOR(allocator_type,__a, _CharT).allocate(_S_rounded_up_size(_p_size));
+
+ _STLP_PRIV __ucopy_n(__s, _p_size, __buf);
+ _S_construct_null(__buf + _p_size);
+
+ _STLP_TRY {
+ return _S_new_RopeLeaf(__buf, _p_size, __a);
+ }
+ _STLP_UNWIND(_RopeRep::_S_free_string(__buf, _p_size, __a))
+ _STLP_RET_AFTER_THROW(0)
+ }
+
+
+ // Concatenation of nonempty strings.
+ // Always builds a concatenation node.
+ // Rebalances if the result is too deep.
+ // Result has refcount 1.
+ // Does not increment left and right ref counts even though
+ // they are referenced.
+ static _RopeRep*
+ _S_tree_concat(_RopeRep* __left, _RopeRep* __right);
+
+ // Concatenation helper functions
+ static _RopeLeaf*
+ _S_leaf_concat_char_iter(_RopeLeaf* __r,
+ const _CharT* __iter, size_t __slen);
+ // Concatenate by copying leaf.
+ // should take an arbitrary iterator
+ // result has refcount 1.
+ static _RopeLeaf* _S_destr_leaf_concat_char_iter
+ (_RopeLeaf* __r, const _CharT* __iter, size_t __slen);
+ // A version that potentially clobbers __r if __r->_M_ref_count == 1.
+
+
+ // A helper function for exponentiating strings.
+ // This uses a nonstandard refcount convention.
+ // The result has refcount 0.
+ typedef _STLP_PRIV _Rope_Concat_fn<_CharT,_Alloc> _Concat_fn;
+#if !defined (__GNUC__) || (__GNUC__ < 3)
+ friend _Concat_fn;
+#else
+ friend struct _STLP_PRIV _Rope_Concat_fn<_CharT,_Alloc>;
+#endif
+
+public:
+ static size_t _S_char_ptr_len(const _CharT* __s) {
+ return char_traits<_CharT>::length(__s);
+ }
+
+public: /* for operators */
+ rope(_RopeRep* __t, const allocator_type& __a = allocator_type())
+ : _M_tree_ptr(__a, __t) { }
+private:
+ // Copy __r to the _CharT buffer.
+ // Returns __buffer + __r->_M_size._M_data.
+ // Assumes that buffer is uninitialized.
+ static _CharT* _S_flatten(_RopeRep* __r, _CharT* __buffer);
+
+ // Again, with explicit starting position and length.
+ // Assumes that buffer is uninitialized.
+ static _CharT* _S_flatten(_RopeRep* __r,
+ size_t __start, size_t __len,
+ _CharT* __buffer);
+
+ // fbp : HP aCC prohibits access to protected min_len from within static methods ( ?? )
+public:
+ static const unsigned long _S_min_len[__ROPE_DEPTH_SIZE];
+protected:
+ static bool _S_is_balanced(_RopeRep* __r)
+ { return (__r->_M_size._M_data >= _S_min_len[__r->_M_depth]); }
+
+ static bool _S_is_almost_balanced(_RopeRep* __r) {
+ return (__r->_M_depth == 0 ||
+ __r->_M_size._M_data >= _S_min_len[__r->_M_depth - 1]);
+ }
+
+ static bool _S_is_roughly_balanced(_RopeRep* __r) {
+ return (__r->_M_depth <= 1 ||
+ __r->_M_size._M_data >= _S_min_len[__r->_M_depth - 2]);
+ }
+
+ // Assumes the result is not empty.
+ static _RopeRep* _S_concat_and_set_balanced(_RopeRep* __left,
+ _RopeRep* __right) {
+ _RopeRep* __result = _S_concat_rep(__left, __right);
+ if (_S_is_balanced(__result)) __result->_M_is_balanced = true;
+ return __result;
+ }
+
+ // The basic rebalancing operation. Logically copies the
+ // rope. The result has refcount of 1. The client will
+ // usually decrement the reference count of __r.
+ // The result is within height 2 of balanced by the above
+ // definition.
+ static _RopeRep* _S_balance(_RopeRep* __r);
+
+ // Add all unbalanced subtrees to the forest of balanceed trees.
+ // Used only by balance.
+ static void _S_add_to_forest(_RopeRep*__r, _RopeRep** __forest);
+
+ // Add __r to forest, assuming __r is already balanced.
+ static void _S_add_leaf_to_forest(_RopeRep* __r, _RopeRep** __forest);
+
+#ifdef _STLP_DEBUG
+ // Print to stdout, exposing structure
+ static void _S_dump(_RopeRep* __r, int __indent = 0);
+#endif
+
+ // Return -1, 0, or 1 if __x < __y, __x == __y, or __x > __y resp.
+ static int _S_compare(const _RopeRep* __x, const _RopeRep* __y);
+
+ void _STLP_FUNCTION_THROWS _M_throw_out_of_range() const;
+
+ void _M_reset(_RopeRep* __r) {
+ //if (__r != _M_tree_ptr._M_data) {
+ _S_unref(_M_tree_ptr._M_data);
+ _M_tree_ptr._M_data = __r;
+ //}
+ }
+
+public:
+ bool empty() const { return 0 == _M_tree_ptr._M_data; }
+
+ // Comparison member function. This is public only for those
+ // clients that need a ternary comparison. Others
+ // should use the comparison operators below.
+ int compare(const _Self& __y) const {
+ return _S_compare(_M_tree_ptr._M_data, __y._M_tree_ptr._M_data);
+ }
+
+ rope(const _CharT* __s, const allocator_type& __a = allocator_type())
+ : _M_tree_ptr(__a, _S_RopeLeaf_from_unowned_char_ptr(__s, _S_char_ptr_len(__s),__a))
+ {}
+
+ rope(const _CharT* __s, size_t __len,
+ const allocator_type& __a = allocator_type())
+ : _M_tree_ptr(__a, (_S_RopeLeaf_from_unowned_char_ptr(__s, __len, __a)))
+ {}
+
+ // Should perhaps be templatized with respect to the iterator type
+ // and use Sequence_buffer. (It should perhaps use sequence_buffer
+ // even now.)
+ rope(const _CharT *__s, const _CharT *__e,
+ const allocator_type& __a = allocator_type())
+ : _M_tree_ptr(__a, _S_RopeLeaf_from_unowned_char_ptr(__s, __e - __s, __a))
+ {}
+
+ rope(const const_iterator& __s, const const_iterator& __e,
+ const allocator_type& __a = allocator_type())
+ : _M_tree_ptr(__a, _S_substring(__s._M_root, __s._M_current_pos,
+ __e._M_current_pos))
+ {}
+
+ rope(const iterator& __s, const iterator& __e,
+ const allocator_type& __a = allocator_type())
+ : _M_tree_ptr(__a, _S_substring(__s._M_root, __s._M_current_pos,
+ __e._M_current_pos))
+ {}
+
+ rope(_CharT __c, const allocator_type& __a = allocator_type())
+ : _M_tree_ptr(__a, (_RopeRep*)0) {
+ _CharT* __buf = _M_tree_ptr.allocate(_S_rounded_up_size(1));
+
+ _Copy_Construct(__buf, __c);
+ _S_construct_null(__buf + 1);
+
+ _STLP_TRY {
+ _M_tree_ptr._M_data = _S_new_RopeLeaf(__buf, 1, __a);
+ }
+ _STLP_UNWIND(_RopeRep::_S_free_string(__buf, 1, __a))
+ }
+
+ rope(size_t __n, _CharT __c,
+ const allocator_type& __a = allocator_type()):
+ _M_tree_ptr(__a, (_RopeRep*)0) {
+ if (0 == __n)
+ return;
+
+ rope<_CharT,_Alloc> __result;
+# define __exponentiate_threshold size_t(32)
+ _RopeRep* __remainder;
+ rope<_CharT,_Alloc> __remainder_rope;
+
+ // gcc-2.7.2 bugs
+ typedef _STLP_PRIV _Rope_Concat_fn<_CharT,_Alloc> _Concat_fn;
+
+ size_t __exponent = __n / __exponentiate_threshold;
+ size_t __rest = __n % __exponentiate_threshold;
+ if (0 == __rest) {
+ __remainder = 0;
+ } else {
+ _CharT* __rest_buffer = _M_tree_ptr.allocate(_S_rounded_up_size(__rest));
+ uninitialized_fill_n(__rest_buffer, __rest, __c);
+ _S_construct_null(__rest_buffer + __rest);
+ _STLP_TRY {
+ __remainder = _S_new_RopeLeaf(__rest_buffer, __rest, __a);
+ }
+ _STLP_UNWIND(_RopeRep::_S_free_string(__rest_buffer, __rest, __a))
+ }
+ __remainder_rope._M_tree_ptr._M_data = __remainder;
+ if (__exponent != 0) {
+ _CharT* __base_buffer = _M_tree_ptr.allocate(_S_rounded_up_size(__exponentiate_threshold));
+ _RopeLeaf* __base_leaf;
+ rope<_CharT,_Alloc> __base_rope;
+ uninitialized_fill_n(__base_buffer, __exponentiate_threshold, __c);
+ _S_construct_null(__base_buffer + __exponentiate_threshold);
+ _STLP_TRY {
+ __base_leaf = _S_new_RopeLeaf(__base_buffer,
+ __exponentiate_threshold, __a);
+ }
+ _STLP_UNWIND(_RopeRep::_S_free_string(__base_buffer,
+ __exponentiate_threshold, __a))
+ __base_rope._M_tree_ptr._M_data = __base_leaf;
+ if (1 == __exponent) {
+ __result = __base_rope;
+ // One each for base_rope and __result
+ //_STLP_ASSERT(2 == __result._M_tree_ptr._M_data->_M_ref_count)
+ } else {
+ __result = _STLP_PRIV __power(__base_rope, __exponent, _Concat_fn());
+ }
+ if (0 != __remainder) {
+ __result += __remainder_rope;
+ }
+ } else {
+ __result = __remainder_rope;
+ }
+ _M_tree_ptr._M_data = __result._M_tree_ptr._M_data;
+ _M_tree_ptr._M_data->_M_ref_nonnil();
+# undef __exponentiate_threshold
+ }
+
+ rope(const allocator_type& __a = allocator_type())
+ : _M_tree_ptr(__a, (_RopeRep*)0) {}
+
+ // Construct a rope from a function that can compute its members
+ rope(char_producer<_CharT> *__fn, size_t __len, bool __delete_fn,
+ const allocator_type& __a = allocator_type())
+ : _M_tree_ptr(__a, (_RopeRep*)0) {
+ _M_tree_ptr._M_data = (0 == __len) ?
+ 0 : _S_new_RopeFunction(__fn, __len, __delete_fn, __a);
+ }
+
+ rope(const _Self& __x)
+ : _M_tree_ptr(__x._M_tree_ptr, __x._M_tree_ptr._M_data) {
+ _S_ref(_M_tree_ptr._M_data);
+ }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ rope(__move_source<_Self> __src)
+ : _M_tree_ptr(__src.get()._M_tree_ptr, __src.get()._M_tree_ptr._M_data) {
+ __src.get()._M_tree_ptr._M_data = 0;
+ }
+#endif
+
+ ~rope() {
+ _S_unref(_M_tree_ptr._M_data);
+ }
+
+ _Self& operator=(const _Self& __x) {
+ _STLP_ASSERT(get_allocator() == __x.get_allocator())
+ _S_ref(__x._M_tree_ptr._M_data);
+ _M_reset(__x._M_tree_ptr._M_data);
+ return *this;
+ }
+
+ void clear() {
+ _S_unref(_M_tree_ptr._M_data);
+ _M_tree_ptr._M_data = 0;
+ }
+ void push_back(_CharT __x) {
+ _M_reset(_S_destr_concat_char_iter(_M_tree_ptr._M_data, &__x, 1));
+ }
+
+ void pop_back() {
+ _RopeRep* __old = _M_tree_ptr._M_data;
+ _M_tree_ptr._M_data =
+ _S_substring(_M_tree_ptr._M_data, 0, _M_tree_ptr._M_data->_M_size._M_data - 1);
+ _S_unref(__old);
+ }
+
+ _CharT back() const {
+ return _S_fetch(_M_tree_ptr._M_data, _M_tree_ptr._M_data->_M_size._M_data - 1);
+ }
+
+ void push_front(_CharT __x) {
+ _RopeRep* __old = _M_tree_ptr._M_data;
+ _RopeRep* __left =
+ _S_RopeLeaf_from_unowned_char_ptr(&__x, 1, _M_tree_ptr);
+ _STLP_TRY {
+ _M_tree_ptr._M_data = _S_concat_rep(__left, _M_tree_ptr._M_data);
+ _S_unref(__old);
+ _S_unref(__left);
+ }
+ _STLP_UNWIND(_S_unref(__left))
+ }
+
+ void pop_front() {
+ _RopeRep* __old = _M_tree_ptr._M_data;
+ _M_tree_ptr._M_data = _S_substring(_M_tree_ptr._M_data, 1, _M_tree_ptr._M_data->_M_size._M_data);
+ _S_unref(__old);
+ }
+
+ _CharT front() const {
+ return _S_fetch(_M_tree_ptr._M_data, 0);
+ }
+
+ void balance() {
+ _RopeRep* __old = _M_tree_ptr._M_data;
+ _M_tree_ptr._M_data = _S_balance(_M_tree_ptr._M_data);
+ _S_unref(__old);
+ }
+
+ void copy(_CharT* __buffer) const {
+ _STLP_STD::_Destroy_Range(__buffer, __buffer + size());
+ _S_flatten(_M_tree_ptr._M_data, __buffer);
+ }
+
+ /*
+ * This is the copy function from the standard, but
+ * with the arguments reordered to make it consistent with the
+ * rest of the interface.
+ * Note that this guaranteed not to compile if the draft standard
+ * order is assumed.
+ */
+ size_type copy(size_type __pos, size_type __n, _CharT* __buffer) const {
+ size_t _p_size = size();
+ size_t __len = (__pos + __n > _p_size? _p_size - __pos : __n);
+
+ _STLP_STD::_Destroy_Range(__buffer, __buffer + __len);
+ _S_flatten(_M_tree_ptr._M_data, __pos, __len, __buffer);
+ return __len;
+ }
+
+# ifdef _STLP_DEBUG
+ // Print to stdout, exposing structure. May be useful for
+ // performance debugging.
+ void dump() {
+ _S_dump(_M_tree_ptr._M_data);
+ }
+# endif
+
+ // Convert to 0 terminated string in new allocated memory.
+ // Embedded 0s in the input do not terminate the copy.
+ const _CharT* c_str() const;
+
+ // As above, but also use the flattened representation as the
+ // the new rope representation.
+ const _CharT* replace_with_c_str();
+
+ // Reclaim memory for the c_str generated flattened string.
+ // Intentionally undocumented, since it's hard to say when this
+ // is safe for multiple threads.
+ void delete_c_str () {
+ if (0 == _M_tree_ptr._M_data) return;
+ if (_RopeRep::_S_leaf == _M_tree_ptr._M_data->_M_tag &&
+ ((_RopeLeaf*)_M_tree_ptr._M_data)->_M_data ==
+ _M_tree_ptr._M_data->_M_c_string) {
+ // Representation shared
+ return;
+ }
+ _M_tree_ptr._M_data->_M_free_c_string();
+ _M_tree_ptr._M_data->_M_c_string = 0;
+ }
+
+ _CharT operator[] (size_type __pos) const {
+ return _S_fetch(_M_tree_ptr._M_data, __pos);
+ }
+
+ _CharT at(size_type __pos) const {
+ if (__pos >= size()) _M_throw_out_of_range();
+ return (*this)[__pos];
+ }
+
+ const_iterator begin() const {
+ return(const_iterator(_M_tree_ptr._M_data, 0));
+ }
+
+ // An easy way to get a const iterator from a non-const container.
+ const_iterator const_begin() const {
+ return(const_iterator(_M_tree_ptr._M_data, 0));
+ }
+
+ const_iterator end() const {
+ return(const_iterator(_M_tree_ptr._M_data, size()));
+ }
+
+ const_iterator const_end() const {
+ return(const_iterator(_M_tree_ptr._M_data, size()));
+ }
+
+ size_type size() const {
+ return(0 == _M_tree_ptr._M_data? 0 : _M_tree_ptr._M_data->_M_size._M_data);
+ }
+
+ size_type length() const {
+ return size();
+ }
+
+ size_type max_size() const {
+ return _S_min_len[__ROPE_MAX_DEPTH-1] - 1;
+ // Guarantees that the result can be sufficiently
+ // balanced. Longer ropes will probably still work,
+ // but it's harder to make guarantees.
+ }
+
+ const_reverse_iterator rbegin() const {
+ return const_reverse_iterator(end());
+ }
+
+ const_reverse_iterator const_rbegin() const {
+ return const_reverse_iterator(end());
+ }
+
+ const_reverse_iterator rend() const {
+ return const_reverse_iterator(begin());
+ }
+
+ const_reverse_iterator const_rend() const {
+ return const_reverse_iterator(begin());
+ }
+ // The symmetric cases are intentionally omitted, since they're presumed
+ // to be less common, and we don't handle them as well.
+
+ // The following should really be templatized.
+ // The first argument should be an input iterator or
+ // forward iterator with value_type _CharT.
+ _Self& append(const _CharT* __iter, size_t __n) {
+ _M_reset(_S_destr_concat_char_iter(_M_tree_ptr._M_data, __iter, __n));
+ return *this;
+ }
+
+ _Self& append(const _CharT* __c_string) {
+ size_t __len = _S_char_ptr_len(__c_string);
+ append(__c_string, __len);
+ return *this;
+ }
+
+ _Self& append(const _CharT* __s, const _CharT* __e) {
+ _M_reset(_S_destr_concat_char_iter(_M_tree_ptr._M_data, __s, __e - __s));
+ return *this;
+ }
+
+ _Self& append(const_iterator __s, const_iterator __e) {
+ _STLP_ASSERT(__s._M_root == __e._M_root)
+ _STLP_ASSERT(get_allocator() == __s._M_root->get_allocator())
+ _Self_destruct_ptr __appendee(_S_substring(__s._M_root, __s._M_current_pos, __e._M_current_pos));
+ _M_reset(_S_concat_rep(_M_tree_ptr._M_data, (_RopeRep*)__appendee));
+ return *this;
+ }
+
+ _Self& append(_CharT __c) {
+ _M_reset(_S_destr_concat_char_iter(_M_tree_ptr._M_data, &__c, 1));
+ return *this;
+ }
+
+ _Self& append() { return append(_CharT()); } // XXX why?
+
+ _Self& append(const _Self& __y) {
+ _STLP_ASSERT(__y.get_allocator() == get_allocator())
+ _M_reset(_S_concat_rep(_M_tree_ptr._M_data, __y._M_tree_ptr._M_data));
+ return *this;
+ }
+
+ _Self& append(size_t __n, _CharT __c) {
+ rope<_CharT,_Alloc> __last(__n, __c);
+ return append(__last);
+ }
+
+ void swap(_Self& __b) {
+ _M_tree_ptr.swap(__b._M_tree_ptr);
+ }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+protected:
+ // Result is included in refcount.
+ static _RopeRep* replace(_RopeRep* __old, size_t __pos1,
+ size_t __pos2, _RopeRep* __r) {
+ if (0 == __old) { _S_ref(__r); return __r; }
+ _Self_destruct_ptr __left(_S_substring(__old, 0, __pos1));
+ _Self_destruct_ptr __right(_S_substring(__old, __pos2, __old->_M_size._M_data));
+ _STLP_MPWFIX_TRY //*TY 06/01/2000 -
+ _RopeRep* __result;
+
+ if (0 == __r) {
+ __result = _S_concat_rep(__left, __right);
+ } else {
+ _STLP_ASSERT(__old->get_allocator() == __r->get_allocator())
+ _Self_destruct_ptr __left_result(_S_concat_rep(__left, __r));
+ __result = _S_concat_rep(__left_result, __right);
+ }
+ return __result;
+ _STLP_MPWFIX_CATCH //*TY 06/01/2000 -
+ }
+
+public:
+ void insert(size_t __p, const _Self& __r) {
+ if (__p > size()) _M_throw_out_of_range();
+ _STLP_ASSERT(get_allocator() == __r.get_allocator())
+ _M_reset(replace(_M_tree_ptr._M_data, __p, __p, __r._M_tree_ptr._M_data));
+ }
+
+ void insert(size_t __p, size_t __n, _CharT __c) {
+ rope<_CharT,_Alloc> __r(__n,__c);
+ insert(__p, __r);
+ }
+
+ void insert(size_t __p, const _CharT* __i, size_t __n) {
+ if (__p > size()) _M_throw_out_of_range();
+ _Self_destruct_ptr __left(_S_substring(_M_tree_ptr._M_data, 0, __p));
+ _Self_destruct_ptr __right(_S_substring(_M_tree_ptr._M_data, __p, size()));
+ _Self_destruct_ptr __left_result(
+ _S_concat_char_iter(__left, __i, __n));
+ // _S_ destr_concat_char_iter should be safe here.
+ // But as it stands it's probably not a win, since __left
+ // is likely to have additional references.
+ _M_reset(_S_concat_rep(__left_result, __right));
+ }
+
+ void insert(size_t __p, const _CharT* __c_string) {
+ insert(__p, __c_string, _S_char_ptr_len(__c_string));
+ }
+
+ void insert(size_t __p, _CharT __c) {
+ insert(__p, &__c, 1);
+ }
+
+ void insert(size_t __p) {
+ _CharT __c = _CharT();
+ insert(__p, &__c, 1);
+ }
+
+ void insert(size_t __p, const _CharT* __i, const _CharT* __j) {
+ _Self __r(__i, __j);
+ insert(__p, __r);
+ }
+
+ void insert(size_t __p, const const_iterator& __i,
+ const const_iterator& __j) {
+ _Self __r(__i, __j);
+ insert(__p, __r);
+ }
+
+ void insert(size_t __p, const iterator& __i,
+ const iterator& __j) {
+ _Self __r(__i, __j);
+ insert(__p, __r);
+ }
+
+ // (position, length) versions of replace operations:
+ void replace(size_t __p, size_t __n, const _Self& __r) {
+ if (__p > size()) _M_throw_out_of_range();
+ _M_reset(replace(_M_tree_ptr._M_data, __p, __p + __n, __r._M_tree_ptr._M_data));
+ }
+
+ void replace(size_t __p, size_t __n,
+ const _CharT* __i, size_t __i_len) {
+ _Self __r(__i, __i_len);
+ replace(__p, __n, __r);
+ }
+
+ void replace(size_t __p, size_t __n, _CharT __c) {
+ _Self __r(__c);
+ replace(__p, __n, __r);
+ }
+
+ void replace(size_t __p, size_t __n, const _CharT* __c_string) {
+ _Self __r(__c_string);
+ replace(__p, __n, __r);
+ }
+
+ void replace(size_t __p, size_t __n,
+ const _CharT* __i, const _CharT* __j) {
+ _Self __r(__i, __j);
+ replace(__p, __n, __r);
+ }
+
+ void replace(size_t __p, size_t __n,
+ const const_iterator& __i, const const_iterator& __j) {
+ _Self __r(__i, __j);
+ replace(__p, __n, __r);
+ }
+
+ void replace(size_t __p, size_t __n,
+ const iterator& __i, const iterator& __j) {
+ _Self __r(__i, __j);
+ replace(__p, __n, __r);
+ }
+
+ // Single character variants:
+ void replace(size_t __p, _CharT __c) {
+ if (__p > size()) _M_throw_out_of_range();
+ iterator __i(this, __p);
+ *__i = __c;
+ }
+
+ void replace(size_t __p, const _Self& __r) {
+ replace(__p, 1, __r);
+ }
+
+ void replace(size_t __p, const _CharT* __i, size_t __i_len) {
+ replace(__p, 1, __i, __i_len);
+ }
+
+ void replace(size_t __p, const _CharT* __c_string) {
+ replace(__p, 1, __c_string);
+ }
+
+ void replace(size_t __p, const _CharT* __i, const _CharT* __j) {
+ replace(__p, 1, __i, __j);
+ }
+
+ void replace(size_t __p, const const_iterator& __i,
+ const const_iterator& __j) {
+ replace(__p, 1, __i, __j);
+ }
+
+ void replace(size_t __p, const iterator& __i,
+ const iterator& __j) {
+ replace(__p, 1, __i, __j);
+ }
+
+ // Erase, (position, size) variant.
+ void erase(size_t __p, size_t __n) {
+ if (__p > size()) _M_throw_out_of_range();
+ _M_reset(replace(_M_tree_ptr._M_data, __p, __p + __n, 0));
+ }
+
+ // Erase, single character
+ void erase(size_t __p) {
+ erase(__p, __p + 1);
+ }
+
+ // Insert, iterator variants.
+ iterator insert(const iterator& __p, const _Self& __r)
+ { insert(__p.index(), __r); return __p; }
+ iterator insert(const iterator& __p, size_t __n, _CharT __c)
+ { insert(__p.index(), __n, __c); return __p; }
+ iterator insert(const iterator& __p, _CharT __c)
+ { insert(__p.index(), __c); return __p; }
+ iterator insert(const iterator& __p )
+ { insert(__p.index()); return __p; }
+ iterator insert(const iterator& __p, const _CharT* c_string)
+ { insert(__p.index(), c_string); return __p; }
+ iterator insert(const iterator& __p, const _CharT* __i, size_t __n)
+ { insert(__p.index(), __i, __n); return __p; }
+ iterator insert(const iterator& __p, const _CharT* __i,
+ const _CharT* __j)
+ { insert(__p.index(), __i, __j); return __p; }
+ iterator insert(const iterator& __p,
+ const const_iterator& __i, const const_iterator& __j)
+ { insert(__p.index(), __i, __j); return __p; }
+ iterator insert(const iterator& __p,
+ const iterator& __i, const iterator& __j)
+ { insert(__p.index(), __i, __j); return __p; }
+
+ // Replace, range variants.
+ void replace(const iterator& __p, const iterator& __q,
+ const _Self& __r)
+ { replace(__p.index(), __q.index() - __p.index(), __r); }
+ void replace(const iterator& __p, const iterator& __q, _CharT __c)
+ { replace(__p.index(), __q.index() - __p.index(), __c); }
+ void replace(const iterator& __p, const iterator& __q,
+ const _CharT* __c_string)
+ { replace(__p.index(), __q.index() - __p.index(), __c_string); }
+ void replace(const iterator& __p, const iterator& __q,
+ const _CharT* __i, size_t __n)
+ { replace(__p.index(), __q.index() - __p.index(), __i, __n); }
+ void replace(const iterator& __p, const iterator& __q,
+ const _CharT* __i, const _CharT* __j)
+ { replace(__p.index(), __q.index() - __p.index(), __i, __j); }
+ void replace(const iterator& __p, const iterator& __q,
+ const const_iterator& __i, const const_iterator& __j)
+ { replace(__p.index(), __q.index() - __p.index(), __i, __j); }
+ void replace(const iterator& __p, const iterator& __q,
+ const iterator& __i, const iterator& __j)
+ { replace(__p.index(), __q.index() - __p.index(), __i, __j); }
+
+ // Replace, iterator variants.
+ void replace(const iterator& __p, const _Self& __r)
+ { replace(__p.index(), __r); }
+ void replace(const iterator& __p, _CharT __c)
+ { replace(__p.index(), __c); }
+ void replace(const iterator& __p, const _CharT* __c_string)
+ { replace(__p.index(), __c_string); }
+ void replace(const iterator& __p, const _CharT* __i, size_t __n)
+ { replace(__p.index(), __i, __n); }
+ void replace(const iterator& __p, const _CharT* __i, const _CharT* __j)
+ { replace(__p.index(), __i, __j); }
+ void replace(const iterator& __p, const_iterator __i,
+ const_iterator __j)
+ { replace(__p.index(), __i, __j); }
+ void replace(const iterator& __p, iterator __i, iterator __j)
+ { replace(__p.index(), __i, __j); }
+
+ // Iterator and range variants of erase
+ iterator erase(const iterator& __p, const iterator& __q) {
+ size_t __p_index = __p.index();
+ erase(__p_index, __q.index() - __p_index);
+ return iterator(this, __p_index);
+ }
+ iterator erase(const iterator& __p) {
+ size_t __p_index = __p.index();
+ erase(__p_index, 1);
+ return iterator(this, __p_index);
+ }
+
+ _Self substr(size_t __start, size_t __len = 1) const {
+ if (__start > size()) _M_throw_out_of_range();
+ return rope<_CharT,_Alloc>(_S_substring(_M_tree_ptr._M_data, __start, __start + __len));
+ }
+
+ _Self substr(iterator __start, iterator __end) const {
+ return rope<_CharT,_Alloc>(_S_substring(_M_tree_ptr._M_data, __start.index(), __end.index()));
+ }
+
+ _Self substr(iterator __start) const {
+ size_t __pos = __start.index();
+ return rope<_CharT,_Alloc>(_S_substring(_M_tree_ptr._M_data, __pos, __pos + 1));
+ }
+
+ _Self substr(const_iterator __start, const_iterator __end) const {
+ // This might eventually take advantage of the cache in the
+ // iterator.
+ return rope<_CharT,_Alloc>(_S_substring(_M_tree_ptr._M_data, __start.index(), __end.index()));
+ }
+
+ rope<_CharT,_Alloc> substr(const_iterator __start) {
+ size_t __pos = __start.index();
+ return rope<_CharT,_Alloc>(_S_substring(_M_tree_ptr._M_data, __pos, __pos + 1));
+ }
+
+#include <stl/_string_npos.h>
+
+ size_type find(const _Self& __s, size_type __pos = 0) const {
+ if (__pos >= size())
+# ifndef _STLP_OLD_ROPE_SEMANTICS
+ return npos;
+# else
+ return size();
+# endif
+
+ size_type __result_pos;
+ const_iterator __result = _STLP_STD::search(const_begin() + (ptrdiff_t)__pos, const_end(), __s.begin(), __s.end() );
+ __result_pos = __result.index();
+# ifndef _STLP_OLD_ROPE_SEMANTICS
+ if (__result_pos == size()) __result_pos = npos;
+# endif
+ return __result_pos;
+ }
+ size_type find(_CharT __c, size_type __pos = 0) const;
+ size_type find(const _CharT* __s, size_type __pos = 0) const {
+ size_type __result_pos;
+ const_iterator __result = _STLP_STD::search(const_begin() + (ptrdiff_t)__pos, const_end(),
+ __s, __s + _S_char_ptr_len(__s));
+ __result_pos = __result.index();
+# ifndef _STLP_OLD_ROPE_SEMANTICS
+ if (__result_pos == size()) __result_pos = npos;
+# endif
+ return __result_pos;
+ }
+
+ iterator mutable_begin() {
+ return(iterator(this, 0));
+ }
+
+ iterator mutable_end() {
+ return(iterator(this, size()));
+ }
+
+ reverse_iterator mutable_rbegin() {
+ return reverse_iterator(mutable_end());
+ }
+
+ reverse_iterator mutable_rend() {
+ return reverse_iterator(mutable_begin());
+ }
+
+ reference mutable_reference_at(size_type __pos) {
+ return reference(this, __pos);
+ }
+
+# ifdef __STD_STUFF
+ reference operator[] (size_type __pos) {
+ return reference(this, __pos);
+ }
+
+ reference at(size_type __pos) {
+ if (__pos >= size()) _M_throw_out_of_range();
+ return (*this)[__pos];
+ }
+
+ void resize(size_type, _CharT) {}
+ void resize(size_type) {}
+ void reserve(size_type = 0) {}
+ size_type capacity() const {
+ return max_size();
+ }
+
+ // Stuff below this line is dangerous because it's error prone.
+ // I would really like to get rid of it.
+ // copy function with funny arg ordering.
+ size_type copy(_CharT* __buffer, size_type __n,
+ size_type __pos = 0) const {
+ return copy(__pos, __n, __buffer);
+ }
+
+ iterator end() { return mutable_end(); }
+
+ iterator begin() { return mutable_begin(); }
+
+ reverse_iterator rend() { return mutable_rend(); }
+
+ reverse_iterator rbegin() { return mutable_rbegin(); }
+
+# else
+
+ const_iterator end() { return const_end(); }
+
+ const_iterator begin() { return const_begin(); }
+
+ const_reverse_iterator rend() { return const_rend(); }
+
+ const_reverse_iterator rbegin() { return const_rbegin(); }
+
+# endif
+}; //class rope
+
+#if defined (__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 96)
+template <class _CharT, class _Alloc>
+const size_t rope<_CharT, _Alloc>::npos = ~(size_t) 0;
+#endif
+
+template <class _CharT, class _Alloc>
+inline _CharT
+_Rope_const_iterator< _CharT, _Alloc>::operator[](size_t __n)
+{ return rope<_CharT,_Alloc>::_S_fetch(this->_M_root, this->_M_current_pos + __n); }
+
+template <class _CharT, class _Alloc>
+inline bool operator== (const _Rope_const_iterator<_CharT,_Alloc>& __x,
+ const _Rope_const_iterator<_CharT,_Alloc>& __y) {
+ return (__x._M_current_pos == __y._M_current_pos &&
+ __x._M_root == __y._M_root);
+}
+
+template <class _CharT, class _Alloc>
+inline bool operator< (const _Rope_const_iterator<_CharT,_Alloc>& __x,
+ const _Rope_const_iterator<_CharT,_Alloc>& __y)
+{ return (__x._M_current_pos < __y._M_current_pos); }
+
+#ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
+
+template <class _CharT, class _Alloc>
+inline bool operator!= (const _Rope_const_iterator<_CharT,_Alloc>& __x,
+ const _Rope_const_iterator<_CharT,_Alloc>& __y)
+{ return !(__x == __y); }
+
+template <class _CharT, class _Alloc>
+inline bool operator> (const _Rope_const_iterator<_CharT,_Alloc>& __x,
+ const _Rope_const_iterator<_CharT,_Alloc>& __y)
+{ return __y < __x; }
+
+template <class _CharT, class _Alloc>
+inline bool operator<= (const _Rope_const_iterator<_CharT,_Alloc>& __x,
+ const _Rope_const_iterator<_CharT,_Alloc>& __y)
+{ return !(__y < __x); }
+
+template <class _CharT, class _Alloc>
+inline bool operator>= (const _Rope_const_iterator<_CharT,_Alloc>& __x,
+ const _Rope_const_iterator<_CharT,_Alloc>& __y)
+{ return !(__x < __y); }
+
+#endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
+
+template <class _CharT, class _Alloc>
+inline ptrdiff_t operator-(const _Rope_const_iterator<_CharT,_Alloc>& __x,
+ const _Rope_const_iterator<_CharT,_Alloc>& __y)
+{ return (ptrdiff_t)__x._M_current_pos - (ptrdiff_t)__y._M_current_pos; }
+
+#if !defined( __MWERKS__ ) || __MWERKS__ >= 0x2000 // dwa 8/21/97 - "ambiguous access to overloaded function" bug.
+template <class _CharT, class _Alloc>
+inline _Rope_const_iterator<_CharT,_Alloc>
+operator-(const _Rope_const_iterator<_CharT,_Alloc>& __x, ptrdiff_t __n)
+{ return _Rope_const_iterator<_CharT,_Alloc>(__x._M_root, __x._M_current_pos - __n); }
+# endif
+
+template <class _CharT, class _Alloc>
+inline _Rope_const_iterator<_CharT,_Alloc>
+operator+(const _Rope_const_iterator<_CharT,_Alloc>& __x, ptrdiff_t __n)
+{ return _Rope_const_iterator<_CharT,_Alloc>(__x._M_root, __x._M_current_pos + __n); }
+
+template <class _CharT, class _Alloc>
+inline _Rope_const_iterator<_CharT,_Alloc>
+operator+(ptrdiff_t __n, const _Rope_const_iterator<_CharT,_Alloc>& __x)
+{ return _Rope_const_iterator<_CharT,_Alloc>(__x._M_root, __x._M_current_pos + __n); }
+
+template <class _CharT, class _Alloc>
+inline bool operator== (const _Rope_iterator<_CharT,_Alloc>& __x,
+ const _Rope_iterator<_CharT,_Alloc>& __y) {
+ return (__x._M_current_pos == __y._M_current_pos &&
+ __x._M_root_rope == __y._M_root_rope);
+}
+
+template <class _CharT, class _Alloc>
+inline bool operator< (const _Rope_iterator<_CharT,_Alloc>& __x,
+ const _Rope_iterator<_CharT,_Alloc>& __y)
+{ return (__x._M_current_pos < __y._M_current_pos); }
+
+#if defined (_STLP_USE_SEPARATE_RELOPS_NAMESPACE)
+template <class _CharT, class _Alloc>
+inline bool operator!= (const _Rope_iterator<_CharT,_Alloc>& __x,
+ const _Rope_iterator<_CharT,_Alloc>& __y)
+{ return !(__x == __y); }
+
+template <class _CharT, class _Alloc>
+inline bool operator> (const _Rope_iterator<_CharT,_Alloc>& __x,
+ const _Rope_iterator<_CharT,_Alloc>& __y)
+{ return __y < __x; }
+
+template <class _CharT, class _Alloc>
+inline bool operator<= (const _Rope_iterator<_CharT,_Alloc>& __x,
+ const _Rope_iterator<_CharT,_Alloc>& __y)
+{ return !(__y < __x); }
+
+template <class _CharT, class _Alloc>
+inline bool operator>= (const _Rope_iterator<_CharT,_Alloc>& __x,
+ const _Rope_iterator<_CharT,_Alloc>& __y)
+{ return !(__x < __y); }
+#endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
+
+template <class _CharT, class _Alloc>
+inline ptrdiff_t operator-(const _Rope_iterator<_CharT,_Alloc>& __x,
+ const _Rope_iterator<_CharT,_Alloc>& __y)
+{ return (ptrdiff_t)__x._M_current_pos - (ptrdiff_t)__y._M_current_pos; }
+
+#if !defined( __MWERKS__ ) || __MWERKS__ >= 0x2000 // dwa 8/21/97 - "ambiguous access to overloaded function" bug.
+template <class _CharT, class _Alloc>
+inline _Rope_iterator<_CharT,_Alloc>
+operator-(const _Rope_iterator<_CharT,_Alloc>& __x,
+ ptrdiff_t __n) {
+ return _Rope_iterator<_CharT,_Alloc>(__x._M_root_rope, __x._M_current_pos - __n);
+}
+# endif
+
+template <class _CharT, class _Alloc>
+inline _Rope_iterator<_CharT,_Alloc>
+operator+(const _Rope_iterator<_CharT,_Alloc>& __x,
+ ptrdiff_t __n) {
+ return _Rope_iterator<_CharT,_Alloc>(__x._M_root_rope, __x._M_current_pos + __n);
+}
+
+template <class _CharT, class _Alloc>
+inline _Rope_iterator<_CharT,_Alloc>
+operator+(ptrdiff_t __n, const _Rope_iterator<_CharT,_Alloc>& __x) {
+ return _Rope_iterator<_CharT,_Alloc>(__x._M_root_rope, __x._M_current_pos + __n);
+}
+
+template <class _CharT, class _Alloc>
+inline rope<_CharT,_Alloc>
+operator+ (const rope<_CharT,_Alloc>& __left,
+ const rope<_CharT,_Alloc>& __right) {
+ _STLP_ASSERT(__left.get_allocator() == __right.get_allocator())
+ return rope<_CharT,_Alloc>(rope<_CharT,_Alloc>::_S_concat_rep(__left._M_tree_ptr._M_data, __right._M_tree_ptr._M_data));
+ // Inlining this should make it possible to keep __left and __right in registers.
+}
+
+template <class _CharT, class _Alloc>
+inline rope<_CharT,_Alloc>&
+operator+= (rope<_CharT,_Alloc>& __left,
+ const rope<_CharT,_Alloc>& __right) {
+ __left.append(__right);
+ return __left;
+}
+
+template <class _CharT, class _Alloc>
+inline rope<_CharT,_Alloc>
+operator+ (const rope<_CharT,_Alloc>& __left,
+ const _CharT* __right) {
+ size_t __rlen = rope<_CharT,_Alloc>::_S_char_ptr_len(__right);
+ return rope<_CharT,_Alloc>(rope<_CharT,_Alloc>::_S_concat_char_iter(__left._M_tree_ptr._M_data, __right, __rlen));
+}
+
+template <class _CharT, class _Alloc>
+inline rope<_CharT,_Alloc>&
+operator+= (rope<_CharT,_Alloc>& __left,
+ const _CharT* __right) {
+ __left.append(__right);
+ return __left;
+}
+
+template <class _CharT, class _Alloc>
+inline rope<_CharT,_Alloc>
+operator+ (const rope<_CharT,_Alloc>& __left, _CharT __right) {
+ return rope<_CharT,_Alloc>(rope<_CharT,_Alloc>::_S_concat_char_iter(__left._M_tree_ptr._M_data, &__right, 1));
+}
+
+template <class _CharT, class _Alloc>
+inline rope<_CharT,_Alloc>&
+operator+= (rope<_CharT,_Alloc>& __left, _CharT __right) {
+ __left.append(__right);
+ return __left;
+}
+
+template <class _CharT, class _Alloc>
+inline bool
+operator< (const rope<_CharT,_Alloc>& __left,
+ const rope<_CharT,_Alloc>& __right) {
+ return __left.compare(__right) < 0;
+}
+
+template <class _CharT, class _Alloc>
+inline bool
+operator== (const rope<_CharT,_Alloc>& __left,
+ const rope<_CharT,_Alloc>& __right) {
+ return __left.compare(__right) == 0;
+}
+
+#ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
+
+template <class _CharT, class _Alloc>
+inline bool
+operator!= (const rope<_CharT,_Alloc>& __x, const rope<_CharT,_Alloc>& __y) {
+ return !(__x == __y);
+}
+
+template <class _CharT, class _Alloc>
+inline bool
+operator> (const rope<_CharT,_Alloc>& __x, const rope<_CharT,_Alloc>& __y) {
+ return __y < __x;
+}
+
+template <class _CharT, class _Alloc>
+inline bool
+operator<= (const rope<_CharT,_Alloc>& __x, const rope<_CharT,_Alloc>& __y) {
+ return !(__y < __x);
+}
+
+template <class _CharT, class _Alloc>
+inline bool
+operator>= (const rope<_CharT,_Alloc>& __x, const rope<_CharT,_Alloc>& __y) {
+ return !(__x < __y);
+}
+
+template <class _CharT, class _Alloc>
+inline bool operator!= (const _Rope_char_ptr_proxy<_CharT,_Alloc>& __x,
+ const _Rope_char_ptr_proxy<_CharT,_Alloc>& __y) {
+ return !(__x == __y);
+}
+
+#endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
+
+template <class _CharT, class _Alloc>
+inline bool operator== (const _Rope_char_ptr_proxy<_CharT,_Alloc>& __x,
+ const _Rope_char_ptr_proxy<_CharT,_Alloc>& __y) {
+ return (__x._M_pos == __y._M_pos && __x._M_root == __y._M_root);
+}
+
+#if !defined (_STLP_USE_NO_IOSTREAMS)
+template<class _CharT, class _Traits, class _Alloc>
+basic_ostream<_CharT, _Traits>& operator<< (basic_ostream<_CharT, _Traits>& __o,
+ const rope<_CharT, _Alloc>& __r);
+#endif
+
+typedef rope<char, allocator<char> > crope;
+#if defined (_STLP_HAS_WCHAR_T)
+typedef rope<wchar_t, allocator<wchar_t> > wrope;
+#endif
+
+inline crope::reference __mutable_reference_at(crope& __c, size_t __i)
+{ return __c.mutable_reference_at(__i); }
+
+#if defined (_STLP_HAS_WCHAR_T)
+inline wrope::reference __mutable_reference_at(wrope& __c, size_t __i)
+{ return __c.mutable_reference_at(__i); }
+#endif
+
+#if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+template <class _CharT, class _Alloc>
+inline void swap(rope<_CharT,_Alloc>& __x, rope<_CharT,_Alloc>& __y)
+{ __x.swap(__y); }
+#else
+
+inline void swap(crope& __x, crope& __y) { __x.swap(__y); }
+# ifdef _STLP_HAS_WCHAR_T // dwa 8/21/97
+inline void swap(wrope& __x, wrope& __y) { __x.swap(__y); }
+# endif
+
+#endif /* _STLP_FUNCTION_TMPL_PARTIAL_ORDER */
+
+
+// Hash functions should probably be revisited later:
+_STLP_TEMPLATE_NULL struct hash<crope> {
+ size_t operator()(const crope& __str) const {
+ size_t _p_size = __str.size();
+
+ if (0 == _p_size) return 0;
+ return 13*__str[0] + 5*__str[_p_size - 1] + _p_size;
+ }
+};
+
+#if defined (_STLP_HAS_WCHAR_T) // dwa 8/21/97
+_STLP_TEMPLATE_NULL struct hash<wrope> {
+ size_t operator()(const wrope& __str) const {
+ size_t _p_size = __str.size();
+
+ if (0 == _p_size) return 0;
+ return 13*__str[0] + 5*__str[_p_size - 1] + _p_size;
+ }
+};
+#endif
+
+#if (!defined (_STLP_MSVC) || (_STLP_MSVC >= 1310))
+// I couldn't get this to work with VC++
+template<class _CharT,class _Alloc>
+# if defined (__DMC__)
+extern
+# endif
+void _Rope_rotate(_Rope_iterator<_CharT, _Alloc> __first,
+ _Rope_iterator<_CharT, _Alloc> __middle,
+ _Rope_iterator<_CharT, _Alloc> __last);
+
+inline void rotate(_Rope_iterator<char, allocator<char> > __first,
+ _Rope_iterator<char, allocator<char> > __middle,
+ _Rope_iterator<char, allocator<char> > __last)
+{ _Rope_rotate(__first, __middle, __last); }
+#endif
+
+template <class _CharT, class _Alloc>
+inline _Rope_char_ref_proxy<_CharT, _Alloc>::operator _CharT () const {
+ if (_M_current_valid) {
+ return _M_current;
+ } else {
+ return _My_rope::_S_fetch(_M_root->_M_tree_ptr._M_data, _M_pos);
+ }
+}
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _CharT, class _Alloc>
+struct __move_traits<rope<_CharT, _Alloc> > {
+ typedef __true_type implemented;
+ //Completness depends on the allocator:
+ typedef typename __move_traits<_Alloc>::complete complete;
+};
+#endif
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_rope.c>
+#endif
+
+#endif /* _STLP_INTERNAL_ROPE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_set.h b/sources/android/stlport/stlport/stl/_set.h
new file mode 100644
index 0000000..a8f6862
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_set.h
@@ -0,0 +1,412 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_SET_H
+#define _STLP_INTERNAL_SET_H
+
+#ifndef _STLP_INTERNAL_TREE_H
+# include <stl/_tree.h>
+#endif
+
+#if !defined (_STLP_USE_PTR_SPECIALIZATIONS)
+
+_STLP_BEGIN_NAMESPACE
+
+//Specific iterator traits creation
+_STLP_CREATE_ITERATOR_TRAITS(SetTraitsT, Const_traits)
+
+template <class _Key, _STLP_DFL_TMPL_PARAM(_Compare, less<_Key>),
+ _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Key>) >
+class set
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ : public __stlport_class<set<_Key, _Compare, _Alloc> >
+#endif
+{
+ typedef set<_Key, _Compare, _Alloc> _Self;
+public:
+// typedefs:
+ typedef _Key key_type;
+ typedef _Key value_type;
+ typedef _Compare key_compare;
+ typedef _Compare value_compare;
+
+private:
+ //Specific iterator traits creation
+ typedef _STLP_PRIV _SetTraitsT<value_type> _SetTraits;
+
+public:
+ //Following typedef have to be public for __move_traits specialization.
+ typedef _STLP_PRIV _Rb_tree<key_type, key_compare,
+ value_type, _STLP_PRIV _Identity<value_type>,
+ _SetTraits, _Alloc> _Rep_type;
+
+ typedef typename _Rep_type::pointer pointer;
+ typedef typename _Rep_type::const_pointer const_pointer;
+ typedef typename _Rep_type::reference reference;
+ typedef typename _Rep_type::const_reference const_reference;
+ typedef typename _Rep_type::iterator iterator;
+ typedef typename _Rep_type::const_iterator const_iterator;
+ typedef typename _Rep_type::reverse_iterator reverse_iterator;
+ typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+ typedef typename _Rep_type::size_type size_type;
+ typedef typename _Rep_type::difference_type difference_type;
+ typedef typename _Rep_type::allocator_type allocator_type;
+
+private:
+ _Rep_type _M_t; // red-black tree representing set
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+public:
+
+ // allocation/deallocation
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ explicit set(const _Compare& __comp = _Compare(),
+ const allocator_type& __a = allocator_type())
+#else
+ set()
+ : _M_t(_Compare(), allocator_type()) {}
+ explicit set(const _Compare& __comp)
+ : _M_t(__comp, allocator_type()) {}
+ set(const _Compare& __comp, const allocator_type& __a)
+#endif
+ : _M_t(__comp, __a) {}
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ set(_InputIterator __first, _InputIterator __last)
+ : _M_t(_Compare(), allocator_type())
+ { _M_t.insert_unique(__first, __last); }
+
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ set(_InputIterator __first, _InputIterator __last, const _Compare& __comp)
+ : _M_t(__comp, allocator_type()) { _M_t.insert_unique(__first, __last); }
+# endif
+ template <class _InputIterator>
+ set(_InputIterator __first, _InputIterator __last, const _Compare& __comp,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); }
+#else
+ set(const value_type* __first, const value_type* __last)
+ : _M_t(_Compare(), allocator_type())
+ { _M_t.insert_unique(__first, __last); }
+
+ set(const value_type* __first,
+ const value_type* __last, const _Compare& __comp,
+ const allocator_type& __a = allocator_type())
+ : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); }
+
+ set(const_iterator __first, const_iterator __last)
+ : _M_t(_Compare(), allocator_type())
+ { _M_t.insert_unique(__first, __last); }
+
+ set(const_iterator __first, const_iterator __last, const _Compare& __comp,
+ const allocator_type& __a = allocator_type())
+ : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ set(const _Self& __x) : _M_t(__x._M_t) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ set(__move_source<_Self> src)
+ : _M_t(__move_source<_Rep_type>(src.get()._M_t)) {}
+#endif
+
+ _Self& operator=(const _Self& __x) {
+ _M_t = __x._M_t;
+ return *this;
+ }
+
+ // accessors:
+ key_compare key_comp() const { return _M_t.key_comp(); }
+ value_compare value_comp() const { return _M_t.key_comp(); }
+ allocator_type get_allocator() const { return _M_t.get_allocator(); }
+
+ iterator begin() { return _M_t.begin(); }
+ iterator end() { return _M_t.end(); }
+ const_iterator begin() const { return _M_t.begin(); }
+ const_iterator end() const { return _M_t.end(); }
+ reverse_iterator rbegin() { return _M_t.rbegin(); }
+ reverse_iterator rend() { return _M_t.rend(); }
+ const_reverse_iterator rbegin() const { return _M_t.rbegin(); }
+ const_reverse_iterator rend() const { return _M_t.rend(); }
+ bool empty() const { return _M_t.empty(); }
+ size_type size() const { return _M_t.size(); }
+ size_type max_size() const { return _M_t.max_size(); }
+ void swap(_Self& __x) { _M_t.swap(__x._M_t); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+ // insert/erase
+ pair<iterator,bool> insert(const value_type& __x)
+ { return _M_t.insert_unique(__x); }
+ iterator insert(iterator __pos, const value_type& __x)
+ { return _M_t.insert_unique( __pos , __x); }
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void insert(_InputIterator __first, _InputIterator __last)
+ { _M_t.insert_unique(__first, __last); }
+#else
+ void insert(const_iterator __first, const_iterator __last)
+ { _M_t.insert_unique(__first, __last); }
+ void insert(const value_type* __first, const value_type* __last)
+ { _M_t.insert_unique(__first, __last); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+ void erase(iterator __pos) { _M_t.erase( __pos ); }
+ size_type erase(const key_type& __x) { return _M_t.erase_unique(__x); }
+ void erase(iterator __first, iterator __last) { _M_t.erase(__first, __last ); }
+ void clear() { _M_t.clear(); }
+
+ // set operations:
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __x) const { return _M_t.find(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __x) { return _M_t.find(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __x) const
+ { return _M_t.find(__x) == _M_t.end() ? 0 : 1 ; }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator lower_bound(const _KT& __x) { return _M_t.lower_bound(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator lower_bound(const _KT& __x) const { return _M_t.lower_bound(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator upper_bound(const _KT& __x) { return _M_t.upper_bound(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator upper_bound(const _KT& __x) const { return _M_t.upper_bound(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator, iterator> equal_range(const _KT& __x)
+ { return _M_t.equal_range_unique(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator> equal_range(const _KT& __x) const
+ { return _M_t.equal_range_unique(__x); }
+};
+
+//Specific iterator traits creation
+_STLP_CREATE_ITERATOR_TRAITS(MultisetTraitsT, Const_traits)
+
+template <class _Key, _STLP_DFL_TMPL_PARAM(_Compare, less<_Key>),
+ _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Key>) >
+class multiset
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ : public __stlport_class<multiset<_Key, _Compare, _Alloc> >
+#endif
+{
+ typedef multiset<_Key, _Compare, _Alloc> _Self;
+public:
+ // typedefs:
+
+ typedef _Key key_type;
+ typedef _Key value_type;
+ typedef _Compare key_compare;
+ typedef _Compare value_compare;
+
+private:
+ //Specific iterator traits creation
+ typedef _STLP_PRIV _MultisetTraitsT<value_type> _MultisetTraits;
+
+public:
+ //Following typedef have to be public for __move_traits specialization.
+ typedef _STLP_PRIV _Rb_tree<key_type, key_compare,
+ value_type, _STLP_PRIV _Identity<value_type>,
+ _MultisetTraits, _Alloc> _Rep_type;
+
+ typedef typename _Rep_type::pointer pointer;
+ typedef typename _Rep_type::const_pointer const_pointer;
+ typedef typename _Rep_type::reference reference;
+ typedef typename _Rep_type::const_reference const_reference;
+ typedef typename _Rep_type::iterator iterator;
+ typedef typename _Rep_type::const_iterator const_iterator;
+ typedef typename _Rep_type::reverse_iterator reverse_iterator;
+ typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+ typedef typename _Rep_type::size_type size_type;
+ typedef typename _Rep_type::difference_type difference_type;
+ typedef typename _Rep_type::allocator_type allocator_type;
+
+private:
+ _Rep_type _M_t; // red-black tree representing multiset
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+public:
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ explicit multiset(const _Compare& __comp = _Compare(),
+ const allocator_type& __a = allocator_type())
+#else
+ multiset()
+ : _M_t(_Compare(), allocator_type()) {}
+ explicit multiset(const _Compare& __comp)
+ : _M_t(__comp, allocator_type()) {}
+ multiset(const _Compare& __comp, const allocator_type& __a)
+#endif
+ : _M_t(__comp, __a) {}
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ multiset(_InputIterator __first, _InputIterator __last)
+ : _M_t(_Compare(), allocator_type())
+ { _M_t.insert_equal(__first, __last); }
+
+ template <class _InputIterator>
+ multiset(_InputIterator __first, _InputIterator __last,
+ const _Compare& __comp,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ multiset(_InputIterator __first, _InputIterator __last,
+ const _Compare& __comp)
+ : _M_t(__comp, allocator_type()) { _M_t.insert_equal(__first, __last); }
+# endif
+#else
+ multiset(const value_type* __first, const value_type* __last)
+ : _M_t(_Compare(), allocator_type())
+ { _M_t.insert_equal(__first, __last); }
+
+ multiset(const value_type* __first, const value_type* __last,
+ const _Compare& __comp,
+ const allocator_type& __a = allocator_type())
+ : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
+
+ multiset(const_iterator __first, const_iterator __last)
+ : _M_t(_Compare(), allocator_type())
+ { _M_t.insert_equal(__first, __last); }
+
+ multiset(const_iterator __first, const_iterator __last,
+ const _Compare& __comp,
+ const allocator_type& __a = allocator_type())
+ : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ multiset(const _Self& __x) : _M_t(__x._M_t) {}
+ _Self& operator=(const _Self& __x) {
+ _M_t = __x._M_t;
+ return *this;
+ }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ multiset(__move_source<_Self> src)
+ : _M_t(__move_source<_Rep_type>(src.get()._M_t)) {}
+#endif
+
+ // accessors:
+ key_compare key_comp() const { return _M_t.key_comp(); }
+ value_compare value_comp() const { return _M_t.key_comp(); }
+ allocator_type get_allocator() const { return _M_t.get_allocator(); }
+
+ iterator begin() { return _M_t.begin(); }
+ iterator end() { return _M_t.end(); }
+ const_iterator begin() const { return _M_t.begin(); }
+ const_iterator end() const { return _M_t.end(); }
+ reverse_iterator rbegin() { return _M_t.rbegin(); }
+ reverse_iterator rend() { return _M_t.rend(); }
+ const_reverse_iterator rbegin() const { return _M_t.rbegin(); }
+ const_reverse_iterator rend() const { return _M_t.rend(); }
+ bool empty() const { return _M_t.empty(); }
+ size_type size() const { return _M_t.size(); }
+ size_type max_size() const { return _M_t.max_size(); }
+ void swap(_Self& __x) { _M_t.swap(__x._M_t); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+ // insert/erase
+ iterator insert(const value_type& __x)
+ { return _M_t.insert_equal(__x); }
+ iterator insert(iterator __pos, const value_type& __x)
+ { return _M_t.insert_equal(__pos, __x); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void insert(_InputIterator __first, _InputIterator __last)
+ { _M_t.insert_equal(__first, __last); }
+#else
+ void insert(const value_type* __first, const value_type* __last)
+ { _M_t.insert_equal(__first, __last); }
+ void insert(const_iterator __first, const_iterator __last)
+ { _M_t.insert_equal(__first, __last); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+ void erase(iterator __pos) { _M_t.erase( __pos ); }
+ size_type erase(const key_type& __x) { return _M_t.erase(__x); }
+ void erase(iterator __first, iterator __last) { _M_t.erase( __first, __last ); }
+ void clear() { _M_t.clear(); }
+
+ // multiset operations:
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __x) { return _M_t.find(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __x) const { return _M_t.find(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __x) const { return _M_t.count(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator lower_bound(const _KT& __x) { return _M_t.lower_bound(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator lower_bound(const _KT& __x) const { return _M_t.lower_bound(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator upper_bound(const _KT& __x) { return _M_t.upper_bound(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator upper_bound(const _KT& __x) const { return _M_t.upper_bound(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator, iterator> equal_range(const _KT& __x) { return _M_t.equal_range(__x); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator> equal_range(const _KT& __x) const { return _M_t.equal_range(__x); }
+};
+
+#else
+# include <stl/pointers/_set.h>
+_STLP_BEGIN_NAMESPACE
+#endif /* _STLP_USE_PTR_SPECIALIZATIONS */
+
+#define _STLP_TEMPLATE_HEADER template <class _Key, class _Compare, class _Alloc>
+#define _STLP_TEMPLATE_CONTAINER set<_Key,_Compare,_Alloc>
+#include <stl/_relops_cont.h>
+#undef _STLP_TEMPLATE_CONTAINER
+#define _STLP_TEMPLATE_CONTAINER multiset<_Key,_Compare,_Alloc>
+#include <stl/_relops_cont.h>
+#undef _STLP_TEMPLATE_CONTAINER
+#undef _STLP_TEMPLATE_HEADER
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Key, class _Compare, class _Alloc>
+struct __move_traits<set<_Key,_Compare,_Alloc> > :
+ _STLP_PRIV __move_traits_aux<typename set<_Key,_Compare,_Alloc>::_Rep_type>
+{};
+
+template <class _Key, class _Compare, class _Alloc>
+struct __move_traits<multiset<_Key,_Compare,_Alloc> > :
+ _STLP_PRIV __move_traits_aux<typename multiset<_Key,_Compare,_Alloc>::_Rep_type>
+{};
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_SET_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_slist.c b/sources/android/stlport/stlport/stl/_slist.c
new file mode 100644
index 0000000..ba158d0
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_slist.c
@@ -0,0 +1,231 @@
+/*
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_SLIST_C
+#define _STLP_SLIST_C
+
+#ifndef _STLP_INTERNAL_SLIST_H
+# include <stl/_slist.h>
+#endif
+
+#ifndef _STLP_CARRAY_H
+# include <stl/_carray.h>
+#endif
+
+#ifndef _STLP_RANGE_ERRORS_H
+# include <stl/_range_errors.h>
+#endif
+
+#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+# define size_type size_t
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp, class _Alloc>
+_Slist_node_base*
+_Slist_base<_Tp,_Alloc>::_M_erase_after(_Slist_node_base* __before_first,
+ _Slist_node_base* __last_node) {
+ _Slist_node_base* __cur = __before_first->_M_next;
+ while (__cur != __last_node) {
+ _Node* __tmp = __STATIC_CAST(_Node*, __cur);
+ __cur = __cur->_M_next;
+ _STLP_STD::_Destroy(&__tmp->_M_data);
+ _M_head.deallocate(__tmp,1);
+ }
+ __before_first->_M_next = __last_node;
+ return __last_node;
+}
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+# define slist _STLP_PTR_IMPL_NAME(slist)
+#elif defined (_STLP_DEBUG)
+# define slist _STLP_NON_DBG_NAME(slist)
+#else
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+/* When building STLport lib Digital Mars Compiler complains on the _M_data assignment
+ * problem which would be perfertly right if we were using it. Hiding it during build
+ * fix this issue.
+ */
+template <class _Tp, class _Alloc>
+slist<_Tp,_Alloc>& slist<_Tp,_Alloc>::operator=(const slist<_Tp,_Alloc>& __x) {
+ if (&__x != this) {
+ _Node_base* __p1 = &this->_M_head._M_data;
+ _Node_base* __n1 = this->_M_head._M_data._M_next;
+ const _Node_base* __n2 = __x._M_head._M_data._M_next;
+ while (__n1 && __n2) {
+ __STATIC_CAST(_Node*, __n1)->_M_data = __STATIC_CAST(const _Node*, __n2)->_M_data;
+ __p1 = __n1;
+ __n1 = __n1->_M_next;
+ __n2 = __n2->_M_next;
+ }
+ if (__n2 == 0)
+ this->_M_erase_after(__p1, 0);
+ else
+ _M_insert_after_range(__p1, const_iterator(__CONST_CAST(_Node_base*, __n2)),
+ const_iterator(0));
+ }
+ return *this;
+}
+
+template <class _Tp, class _Alloc>
+void slist<_Tp, _Alloc>::_M_fill_assign(size_type __n, const _Tp& __val) {
+ _Node_base* __prev = &this->_M_head._M_data;
+ _Node_base* __node = this->_M_head._M_data._M_next;
+ for ( ; __node != 0 && __n > 0 ; --__n) {
+ __STATIC_CAST(_Node*, __node)->_M_data = __val;
+ __prev = __node;
+ __node = __node->_M_next;
+ }
+ if (__n > 0)
+ _M_insert_after_fill(__prev, __n, __val);
+ else
+ this->_M_erase_after(__prev, 0);
+}
+
+template <class _Tp, class _Alloc>
+void slist<_Tp,_Alloc>::resize(size_type __len, const _Tp& __x) {
+ _Node_base* __cur = &this->_M_head._M_data;
+ while (__cur->_M_next != 0 && __len > 0) {
+ --__len;
+ __cur = __cur->_M_next;
+ }
+ if (__cur->_M_next)
+ this->_M_erase_after(__cur, 0);
+ else
+ _M_insert_after_fill(__cur, __len, __x);
+}
+
+template <class _Tp, class _Alloc>
+void slist<_Tp,_Alloc>::remove(const _Tp& __val) {
+ _Node_base* __cur = &this->_M_head._M_data;
+ while (__cur && __cur->_M_next) {
+ if (__STATIC_CAST(_Node*, __cur->_M_next)->_M_data == __val)
+ this->_M_erase_after(__cur);
+ else
+ __cur = __cur->_M_next;
+ }
+}
+
+#if !defined (slist)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+template <class _Tp, class _Alloc, class _BinaryPredicate>
+void _Slist_unique(slist<_Tp, _Alloc>& __that, _BinaryPredicate __pred) {
+ typedef _Slist_node<_Tp> _Node;
+ typename slist<_Tp, _Alloc>::iterator __ite(__that.begin());
+ if (__ite != __that.end()) {
+ while (__ite._M_node->_M_next) {
+ if (__pred(*__ite, __STATIC_CAST(_Node*, __ite._M_node->_M_next)->_M_data))
+ __that.erase_after(__ite);
+ else
+ ++__ite;
+ }
+ }
+}
+
+template <class _Tp, class _Alloc, class _StrictWeakOrdering>
+void _Slist_merge(slist<_Tp, _Alloc>& __that, slist<_Tp, _Alloc>& __x,
+ _StrictWeakOrdering __comp) {
+ typedef _Slist_node<_Tp> _Node;
+ typedef _STLP_PRIV _Slist_node_base _Node_base;
+ if (__that.get_allocator() == __x.get_allocator()) {
+ typename slist<_Tp, _Alloc>::iterator __ite(__that.before_begin());
+ while (__ite._M_node->_M_next && !__x.empty()) {
+ if (__comp(__x.front(), __STATIC_CAST(_Node*, __ite._M_node->_M_next)->_M_data)) {
+ _STLP_VERBOSE_ASSERT(!__comp(__STATIC_CAST(_Node*, __ite._M_node->_M_next)->_M_data, __x.front()),
+ _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ __that.splice_after(__ite, __x, __x.before_begin());
+ }
+ ++__ite;
+ }
+ if (!__x.empty()) {
+ __that.splice_after(__ite, __x);
+ }
+ }
+ else {
+ typename slist<_Tp, _Alloc>::iterator __i1(__that.before_begin()), __i2(__x.begin());
+ while (__i1._M_node->_M_next && __i2._M_node) {
+ if (__comp(__STATIC_CAST(_Node*, __i1._M_node->_M_next)->_M_data, *__i2)) {
+ _STLP_VERBOSE_ASSERT(!__comp(*__i2, __STATIC_CAST(_Node*, __i1._M_node->_M_next)->_M_data),
+ _StlMsg_INVALID_STRICT_WEAK_PREDICATE)
+ ++__i1;
+ }
+ else {
+ __i1 = __that.insert_after(__i1, *(__i2++));
+ }
+ }
+ __that.insert_after(__i1, __i2, __x.end());
+ __x.clear();
+ }
+}
+
+template <class _Tp, class _Alloc, class _StrictWeakOrdering>
+void _Slist_sort(slist<_Tp, _Alloc>& __that, _StrictWeakOrdering __comp) {
+ if (!__that.begin()._M_node || !__that.begin()._M_node->_M_next)
+ return;
+
+ slist<_Tp, _Alloc> __carry(__that.get_allocator());
+ const int NB = 64;
+ _STLP_PRIV _CArray<slist<_Tp, _Alloc>, NB> __counter(__carry);
+ int __fill = 0;
+ while (!__that.empty()) {
+ __carry.splice_after(__carry.before_begin(), __that, __that.before_begin());
+ int __i = 0;
+ while (__i < __fill && !__counter[__i].empty()) {
+ _STLP_PRIV _Slist_merge(__counter[__i], __carry, __comp);
+ __carry.swap(__counter[__i]);
+ ++__i;
+ }
+ __carry.swap(__counter[__i]);
+ if (__i == __fill) {
+ ++__fill;
+ if (__fill >= NB) {
+ //Looks like the slist has too many elements to be sorted with this algorithm:
+ __stl_throw_overflow_error("slist::sort");
+ }
+ }
+ }
+
+ for (int __i = 1; __i < __fill; ++__i)
+ _STLP_PRIV _Slist_merge(__counter[__i], __counter[__i - 1], __comp);
+ __that.swap(__counter[__fill-1]);
+}
+
+#if defined (slist)
+# undef slist
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+# undef size_type
+#endif
+
+#endif /* _STLP_SLIST_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_slist.h b/sources/android/stlport/stlport/stl/_slist.h
new file mode 100644
index 0000000..924daa4
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_slist.h
@@ -0,0 +1,914 @@
+/*
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_SLIST_H
+#define _STLP_INTERNAL_SLIST_H
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+# include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+# include <stl/_alloc.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+# include <stl/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CONSTRUCT_H
+# include <stl/_construct.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+# include <stl/_function_base.h>
+#endif
+
+#ifndef _STLP_INTERNAL_SLIST_BASE_H
+# include <stl/_slist_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp>
+class _Slist_node : public _Slist_node_base {
+public:
+ _Tp _M_data;
+ __TRIVIAL_STUFF(_Slist_node)
+};
+
+struct _Slist_iterator_base {
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef forward_iterator_tag iterator_category;
+
+ _Slist_node_base *_M_node;
+
+ _Slist_iterator_base(_Slist_node_base *__x) : _M_node(__x) {}
+
+ void _M_incr() {
+ _M_node = _M_node->_M_next;
+ }
+};
+
+template <class _Tp, class _Traits>
+class _Slist_iterator : public _Slist_iterator_base {
+public:
+ typedef typename _Traits::value_type value_type;
+ typedef typename _Traits::pointer pointer;
+ typedef typename _Traits::reference reference;
+ typedef forward_iterator_tag iterator_category;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+
+ typedef _Slist_iterator<_Tp, _Traits> _Self;
+ typedef typename _Traits::_NonConstTraits _NonConstTraits;
+ typedef _Slist_iterator<_Tp, _NonConstTraits> iterator;
+ typedef typename _Traits::_ConstTraits _ConstTraits;
+ typedef _Slist_iterator<_Tp, _ConstTraits> const_iterator;
+
+ typedef _Slist_node<value_type> _Node;
+
+ explicit _Slist_iterator(_Slist_node_base *__x) : _Slist_iterator_base(__x) {}
+ _Slist_iterator() : _Slist_iterator_base(0) {}
+ //copy constructor for iterator and constructor from iterator for const_iterator
+ _Slist_iterator(const iterator& __x) : _Slist_iterator_base(__x._M_node) {}
+
+ reference operator*() const { return __STATIC_CAST(_Node*, this->_M_node)->_M_data; }
+
+ _STLP_DEFINE_ARROW_OPERATOR
+
+ _Self& operator++() {
+ _M_incr();
+ return *this;
+ }
+ _Self operator++(int) {
+ _Self __tmp = *this;
+ _M_incr();
+ return __tmp;
+ }
+
+ bool operator==(const_iterator __y ) const {
+ return this->_M_node == __y._M_node;
+ }
+ bool operator!=(const_iterator __y ) const {
+ return this->_M_node != __y._M_node;
+ }
+};
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+_STLP_MOVE_TO_STD_NAMESPACE
+template <class _Tp, class _Traits>
+struct __type_traits<_STLP_PRIV _Slist_iterator<_Tp, _Traits> > {
+ typedef __false_type has_trivial_default_constructor;
+ typedef __true_type has_trivial_copy_constructor;
+ typedef __true_type has_trivial_assignment_operator;
+ typedef __true_type has_trivial_destructor;
+ typedef __false_type is_POD_type;
+};
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+#if defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
+_STLP_MOVE_TO_STD_NAMESPACE
+template <class _Tp, class _Traits>
+inline _Tp* _STLP_CALL value_type(const _STLP_PRIV _Slist_iterator<_Tp, _Traits>&) { return __STATIC_CAST(_Tp*, 0); }
+inline ptrdiff_t* _STLP_CALL distance_type(const _STLP_PRIV _Slist_iterator_base&) { return 0; }
+inline forward_iterator_tag _STLP_CALL iterator_category(const _STLP_PRIV _Slist_iterator_base&) { return forward_iterator_tag(); }
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif /* OLD_QUERIES */
+
+// Base class that encapsulates details of allocators and simplifies EH
+template <class _Tp, class _Alloc>
+class _Slist_base {
+protected:
+ typedef _Slist_node<_Tp> _Node;
+ typedef typename _Alloc_traits<_Node,_Alloc>::allocator_type _M_node_allocator_type;
+ typedef _Slist_base<_Tp, _Alloc> _Self;
+
+public:
+ typedef _STLP_alloc_proxy<_Slist_node_base, _Node, _M_node_allocator_type> _AllocProxy;
+
+ _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
+ typedef _Alloc allocator_type;
+
+ _Slist_base(const allocator_type& __a) :
+ _M_head(_STLP_CONVERT_ALLOCATOR(__a, _Node), _Slist_node_base() )
+ { _M_head._M_data._M_next = 0; }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ _Slist_base(__move_source<_Self> src) :
+ _M_head(__move_source<_AllocProxy>(src.get()._M_head))
+ { src.get()._M_head._M_data._M_next = 0; }
+#endif
+
+ ~_Slist_base() { _M_erase_after(&_M_head._M_data, 0); }
+
+protected:
+ _Slist_node_base* _M_erase_after(_Slist_node_base* __pos) {
+ _Node* __next = __STATIC_CAST(_Node*, __pos->_M_next);
+ _Slist_node_base* __next_next = __next->_M_next;
+ __pos->_M_next = __next_next;
+ _STLP_STD::_Destroy(&__next->_M_data);
+ _M_head.deallocate(__next,1);
+ return __next_next;
+ }
+ _Slist_node_base* _M_erase_after(_Slist_node_base*, _Slist_node_base*);
+
+public:
+ allocator_type get_allocator() const
+ { return _STLP_CONVERT_ALLOCATOR((const _M_node_allocator_type&)_M_head, _Tp); }
+ _AllocProxy _M_head;
+};
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+# define slist _STLP_PTR_IMPL_NAME(slist)
+#elif defined (_STLP_DEBUG)
+# define slist _STLP_NON_DBG_NAME(slist)
+#else
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) >
+class slist;
+
+#if !defined (slist)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+// helper functions to reduce code duplication
+template <class _Tp, class _Alloc, class _BinaryPredicate>
+void _Slist_unique(slist<_Tp, _Alloc>& __that, _BinaryPredicate __binary_pred);
+
+template <class _Tp, class _Alloc, class _StrictWeakOrdering>
+void _Slist_merge(slist<_Tp, _Alloc>& __that, slist<_Tp, _Alloc>& __x,
+ _StrictWeakOrdering __comp);
+
+template <class _Tp, class _Alloc, class _StrictWeakOrdering>
+void _Slist_sort(slist<_Tp, _Alloc>& __that, _StrictWeakOrdering __comp);
+
+#if !defined (slist)
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+template <class _Tp, class _Alloc>
+class slist : protected _STLP_PRIV _Slist_base<_Tp,_Alloc>
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (slist)
+ , public __stlport_class<slist<_Tp, _Alloc> >
+#endif
+{
+private:
+ typedef _STLP_PRIV _Slist_base<_Tp,_Alloc> _Base;
+ typedef slist<_Tp,_Alloc> _Self;
+public:
+ typedef _Tp value_type;
+
+ typedef value_type* pointer;
+ typedef const value_type* const_pointer;
+ typedef value_type& reference;
+ typedef const value_type& const_reference;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef forward_iterator_tag _Iterator_category;
+
+ typedef _STLP_PRIV _Slist_iterator<_Tp, _Nonconst_traits<_Tp> > iterator;
+ typedef _STLP_PRIV _Slist_iterator<_Tp, _Const_traits<_Tp> > const_iterator;
+
+ _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
+ typedef typename _Base::allocator_type allocator_type;
+
+private:
+ typedef _STLP_PRIV _Slist_node<_Tp> _Node;
+ typedef _STLP_PRIV _Slist_node_base _Node_base;
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+ _Node* _M_create_node(const value_type& __x = _Tp()) {
+#else
+ _Node* _M_create_node(const value_type& __x) {
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ _Node* __node = this->_M_head.allocate(1);
+ _STLP_TRY {
+ _Copy_Construct(&__node->_M_data, __x);
+ __node->_M_next = 0;
+ }
+ _STLP_UNWIND(this->_M_head.deallocate(__node, 1))
+ return __node;
+ }
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+ _Node* _M_create_node() {
+ _Node* __node = this->_M_head.allocate(1);
+ _STLP_TRY {
+ _STLP_STD::_Construct(&__node->_M_data);
+ __node->_M_next = 0;
+ }
+ _STLP_UNWIND(this->_M_head.deallocate(__node, 1))
+ return __node;
+ }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+public:
+
+ allocator_type get_allocator() const { return _Base::get_allocator(); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ explicit slist(const allocator_type& __a = allocator_type())
+#else
+ slist()
+ : _STLP_PRIV _Slist_base<_Tp,_Alloc>(allocator_type()) {}
+ slist(const allocator_type& __a)
+#endif
+ : _STLP_PRIV _Slist_base<_Tp,_Alloc>(__a) {}
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ explicit slist(size_type __n, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(_Tp),
+ const allocator_type& __a = allocator_type())
+#else
+ explicit slist(size_type __n)
+ : _STLP_PRIV _Slist_base<_Tp,_Alloc>(allocator_type())
+ { _M_insert_after_fill(&this->_M_head._M_data, __n, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+ slist(size_type __n, const value_type& __x)
+ : _STLP_PRIV _Slist_base<_Tp,_Alloc>(allocator_type())
+ { _M_insert_after_fill(&this->_M_head._M_data, __n, __x); }
+ slist(size_type __n, const value_type& __x, const allocator_type& __a)
+#endif
+ : _STLP_PRIV _Slist_base<_Tp,_Alloc>(__a)
+ { _M_insert_after_fill(&this->_M_head._M_data, __n, __x); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ // We don't need any dispatching tricks here, because _M_insert_after_range
+ // already does them.
+ template <class _InputIterator>
+ slist(_InputIterator __first, _InputIterator __last,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _STLP_PRIV _Slist_base<_Tp,_Alloc>(__a)
+ { _M_insert_after_range(&this->_M_head._M_data, __first, __last); }
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ // VC++ needs this crazyness
+ template <class _InputIterator>
+ slist(_InputIterator __first, _InputIterator __last)
+ : _STLP_PRIV _Slist_base<_Tp,_Alloc>(allocator_type())
+ { _M_insert_after_range(&this->_M_head._M_data, __first, __last); }
+# endif
+#else /* _STLP_MEMBER_TEMPLATES */
+ slist(const_iterator __first, const_iterator __last,
+ const allocator_type& __a = allocator_type() )
+ : _STLP_PRIV _Slist_base<_Tp,_Alloc>(__a)
+ { _M_insert_after_range(&this->_M_head._M_data, __first, __last); }
+ slist(const value_type* __first, const value_type* __last,
+ const allocator_type& __a = allocator_type())
+ : _STLP_PRIV _Slist_base<_Tp,_Alloc>(__a)
+ { _M_insert_after_range(&this->_M_head._M_data, __first, __last); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ slist(const _Self& __x)
+ : _STLP_PRIV _Slist_base<_Tp,_Alloc>(__x.get_allocator())
+ { _M_insert_after_range(&this->_M_head._M_data, __x.begin(), __x.end()); }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ slist(__move_source<_Self> src)
+ : _STLP_PRIV _Slist_base<_Tp, _Alloc>(__move_source<_Base>(src.get())) {}
+#endif
+
+ _Self& operator= (const _Self& __x);
+
+ ~slist() {}
+
+public:
+ // assign(), a generalized assignment member function. Two
+ // versions: one that takes a count, and one that takes a range.
+ // The range version is a member template, so we dispatch on whether
+ // or not the type is an integer.
+
+ void assign(size_type __n, const _Tp& __val) { _M_fill_assign(__n, __val); }
+
+private:
+ void _M_fill_assign(size_type __n, const _Tp& __val);
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+public:
+ template <class _InputIterator>
+ void assign(_InputIterator __first, _InputIterator __last) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_assign_dispatch(__first, __last, _Integral());
+ }
+
+private:
+ template <class _Integer>
+ void _M_assign_dispatch(_Integer __n, _Integer __val,
+ const __true_type& /*_IsIntegral*/) {
+ _M_fill_assign((size_type) __n, (_Tp) __val);
+ }
+
+ template <class _InputIter>
+ void _M_assign_dispatch(_InputIter __first, _InputIter __last,
+ const __false_type& /*_IsIntegral*/) {
+#else
+public:
+ void assign(const_pointer __first, const_pointer __last) {
+ _Node_base* __prev = &this->_M_head._M_data;
+ _Node_base* __node = this->_M_head._M_data._M_next;
+ while (__node != 0 && __first != __last) {
+ __STATIC_CAST(_Node*, __node)->_M_data = *__first;
+ __prev = __node;
+ __node = __node->_M_next;
+ ++__first;
+ }
+ if (__first != __last)
+ _M_insert_after_range(__prev, __first, __last);
+ else
+ this->_M_erase_after(__prev, 0);
+ }
+ void assign(const_iterator __first, const_iterator __last) {
+#endif /* _STLP_MEMBER_TEMPLATES */
+ _Node_base* __prev = &this->_M_head._M_data;
+ _Node_base* __node = this->_M_head._M_data._M_next;
+ while (__node != 0 && __first != __last) {
+ __STATIC_CAST(_Node*, __node)->_M_data = *__first;
+ __prev = __node;
+ __node = __node->_M_next;
+ ++__first;
+ }
+ if (__first != __last)
+ _M_insert_after_range(__prev, __first, __last);
+ else
+ this->_M_erase_after(__prev, 0);
+ }
+
+public:
+
+ // Experimental new feature: before_begin() returns a
+ // non-dereferenceable iterator that, when incremented, yields
+ // begin(). This iterator may be used as the argument to
+ // insert_after, erase_after, etc. Note that even for an empty
+ // slist, before_begin() is not the same iterator as end(). It
+ // is always necessary to increment before_begin() at least once to
+ // obtain end().
+ iterator before_begin() { return iterator(&this->_M_head._M_data); }
+ const_iterator before_begin() const
+ { return const_iterator(__CONST_CAST(_Node_base*, &this->_M_head._M_data)); }
+
+ iterator begin() { return iterator(this->_M_head._M_data._M_next); }
+ const_iterator begin() const
+ { return const_iterator(this->_M_head._M_data._M_next);}
+
+ iterator end() { return iterator(); }
+ const_iterator end() const { return const_iterator(); }
+
+ size_type size() const
+ { return _STLP_PRIV _Sl_global_inst::size(this->_M_head._M_data._M_next); }
+
+ size_type max_size() const { return size_type(-1); }
+
+ bool empty() const { return this->_M_head._M_data._M_next == 0; }
+
+ void swap(_Self& __x)
+ { this->_M_head.swap(__x._M_head); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+public:
+ reference front() { return *begin(); }
+ const_reference front() const { return *begin(); }
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ void push_front(const value_type& __x = _Tp()) {
+#else
+ void push_front(const value_type& __x) {
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+ _STLP_PRIV __slist_make_link(&this->_M_head._M_data, _M_create_node(__x));
+ }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ void push_front() { _STLP_PRIV __slist_make_link(&this->_M_head._M_data, _M_create_node());}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+ void pop_front() {
+ _Node* __node = __STATIC_CAST(_Node*, this->_M_head._M_data._M_next);
+ this->_M_head._M_data._M_next = __node->_M_next;
+ _STLP_STD::_Destroy(&__node->_M_data);
+ this->_M_head.deallocate(__node, 1);
+ }
+
+ iterator previous(const_iterator __pos) {
+ return iterator(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node));
+ }
+ const_iterator previous(const_iterator __pos) const {
+ return const_iterator(__CONST_CAST(_Node_base*,
+ _STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data,
+ __pos._M_node)));
+ }
+
+private:
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ _Node* _M_insert_after(_Node_base* __pos, const value_type& __x = _Tp()) {
+#else
+ _Node* _M_insert_after(_Node_base* __pos, const value_type& __x) {
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ return __STATIC_CAST(_Node*, _STLP_PRIV __slist_make_link(__pos, _M_create_node(__x)));
+ }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+ _Node* _M_insert_after(_Node_base* __pos) {
+ return __STATIC_CAST(_Node*, _STLP_PRIV __slist_make_link(__pos, _M_create_node()));
+ }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+ void _M_insert_after_fill(_Node_base* __pos,
+ size_type __n, const value_type& __x) {
+ for (size_type __i = 0; __i < __n; ++__i)
+ __pos = _STLP_PRIV __slist_make_link(__pos, _M_create_node(__x));
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ // Check whether it's an integral type. If so, it's not an iterator.
+ template <class _InIter>
+ void _M_insert_after_range(_Node_base* __pos,
+ _InIter __first, _InIter __last) {
+ typedef typename _IsIntegral<_InIter>::_Ret _Integral;
+ _M_insert_after_range(__pos, __first, __last, _Integral());
+ }
+
+ template <class _Integer>
+ void _M_insert_after_range(_Node_base* __pos, _Integer __n, _Integer __x,
+ const __true_type&) {
+ _M_insert_after_fill(__pos, __n, __x);
+ }
+
+ template <class _InIter>
+ void _M_insert_after_range(_Node_base* __pos,
+ _InIter __first, _InIter __last,
+ const __false_type&) {
+#else /* _STLP_MEMBER_TEMPLATES */
+ void _M_insert_after_range(_Node_base* __pos,
+ const value_type* __first,
+ const value_type* __last) {
+ while (__first != __last) {
+ __pos = _STLP_PRIV __slist_make_link(__pos, _M_create_node(*__first));
+ ++__first;
+ }
+ }
+ void _M_insert_after_range(_Node_base* __pos,
+ const_iterator __first, const_iterator __last) {
+#endif /* _STLP_MEMBER_TEMPLATES */
+ while (__first != __last) {
+ __pos = _STLP_PRIV __slist_make_link(__pos, _M_create_node(*__first));
+ ++__first;
+ }
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ // Check whether it's an integral type. If so, it's not an iterator.
+ template <class _InIter>
+ void _M_splice_after_range(_Node_base* __pos,
+ _InIter __first, _InIter __last) {
+ typedef typename _IsIntegral<_InIter>::_Ret _Integral;
+ _M_splice_after_range(__pos, __first, __last, _Integral());
+ }
+
+ template <class _Integer>
+ void _M_splice_after_range(_Node_base* __pos, _Integer __n, _Integer __x,
+ const __true_type&) {
+ _M_insert_after_fill(__pos, __n, __x);
+ }
+
+ template <class _InIter>
+ void _M_splice_after_range(_Node_base* __pos,
+ _InIter __first, _InIter __last,
+ const __false_type&) {
+#else /* _STLP_MEMBER_TEMPLATES */
+ void _M_splice_after_range(_Node_base* __pos,
+ const value_type* __first,
+ const value_type* __last) {
+ while (__first != __last) {
+ __pos = _STLP_PRIV __slist_make_link(__pos, _M_create_node(*__first));
+ ++__first;
+ }
+ }
+ void _M_splice_after_range(_Node_base* __pos,
+ const_iterator __first, const_iterator __last) {
+#endif /* _STLP_MEMBER_TEMPLATES */
+ //We use a temporary slist to avoid the auto reference troubles (infinite loop)
+ _Self __tmp(__first, __last, this->get_allocator());
+ splice_after(iterator(__pos), __tmp);
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ // Check whether it's an integral type. If so, it's not an iterator.
+ template <class _InIter>
+ void _M_splice_range(_Node_base* __pos,
+ _InIter __first, _InIter __last) {
+ typedef typename _IsIntegral<_InIter>::_Ret _Integral;
+ _M_splice_range(__pos, __first, __last, _Integral());
+ }
+
+ template <class _Integer>
+ void _M_splice_range(_Node_base* __pos, _Integer __n, _Integer __x,
+ const __true_type&) {
+ _M_insert_after_fill(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos),
+ __n, __x);
+ }
+
+ template <class _InIter>
+ void _M_splice_range(_Node_base* __pos,
+ _InIter __first, _InIter __last,
+ const __false_type&) {
+#else /* _STLP_MEMBER_TEMPLATES */
+ void _M_splice_range(_Node_base* __pos,
+ const value_type* __first,
+ const value_type* __last) {
+ while (__first != __last) {
+ __pos = _STLP_PRIV __slist_make_link(__pos, _M_create_node(*__first));
+ ++__first;
+ }
+ }
+ void _M_splice_range(_Node_base* __pos,
+ const_iterator __first, const_iterator __last) {
+#endif /* _STLP_MEMBER_TEMPLATES */
+ //We use a temporary slist to avoid the auto reference troubles (infinite loop)
+ _Self __tmp(__first, __last, this->get_allocator());
+ splice(iterator(__pos), __tmp);
+ }
+
+public:
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ iterator insert_after(iterator __pos, const value_type& __x = _Tp()) {
+#else
+ iterator insert_after(iterator __pos, const value_type& __x) {
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ return iterator(_M_insert_after(__pos._M_node, __x));
+ }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+ iterator insert_after(iterator __pos) {
+ return insert_after(__pos, _STLP_DEFAULT_CONSTRUCTED(_Tp));
+ }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+ void insert_after(iterator __pos, size_type __n, const value_type& __x) {
+ _M_insert_after_fill(__pos._M_node, __n, __x);
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ // We don't need any dispatching tricks here, because _M_insert_after_range
+ // already does them.
+ template <class _InIter>
+ void insert_after(iterator __pos, _InIter __first, _InIter __last) {
+#else /* _STLP_MEMBER_TEMPLATES */
+ void insert_after(iterator __pos,
+ const value_type* __first, const value_type* __last) {
+ _M_insert_after_range(__pos._M_node, __first, __last);
+ }
+ void insert_after(iterator __pos,
+ const_iterator __first, const_iterator __last) {
+#endif /* _STLP_MEMBER_TEMPLATES */
+ _M_splice_after_range(__pos._M_node, __first, __last);
+ }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ iterator insert(iterator __pos, const value_type& __x = _Tp()) {
+#else
+ iterator insert(iterator __pos, const value_type& __x) {
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ return iterator(_M_insert_after(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node),
+ __x));
+ }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+ iterator insert(iterator __pos) {
+ return iterator(_M_insert_after(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node),
+ _STLP_DEFAULT_CONSTRUCTED(_Tp)));
+ }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+ void insert(iterator __pos, size_type __n, const value_type& __x) {
+ _M_insert_after_fill(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node), __n, __x);
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ // We don't need any dispatching tricks here, because _M_insert_after_range
+ // already does them.
+ template <class _InIter>
+ void insert(iterator __pos, _InIter __first, _InIter __last) {
+#else /* _STLP_MEMBER_TEMPLATES */
+ void insert(iterator __pos, const value_type* __first,
+ const value_type* __last) {
+ _M_insert_after_range(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node),
+ __first, __last);
+ }
+ void insert(iterator __pos, const_iterator __first, const_iterator __last) {
+#endif /* _STLP_MEMBER_TEMPLATES */
+ _M_splice_range(__pos._M_node, __first, __last);
+ }
+
+public:
+ iterator erase_after(iterator __pos)
+ { return iterator(this->_M_erase_after(__pos._M_node)); }
+ iterator erase_after(iterator __before_first, iterator __last)
+ { return iterator(this->_M_erase_after(__before_first._M_node, __last._M_node)); }
+
+ iterator erase(iterator __pos)
+ { return iterator(this->_M_erase_after(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node))); }
+ iterator erase(iterator __first, iterator __last)
+ { return iterator(this->_M_erase_after(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __first._M_node), __last._M_node)); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type new_size, const value_type& __x = _Tp());
+#else
+ void resize(size_type new_size, const value_type& __x);
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type new_size) { resize(new_size, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+ void clear()
+ { this->_M_erase_after(&this->_M_head._M_data, 0); }
+
+public:
+ // Moves the range [__before_first + 1, __before_last + 1) to *this,
+ // inserting it immediately after __pos. This is constant time.
+ void splice_after(iterator __pos, _Self& __x,
+ iterator __before_first, iterator __before_last) {
+ if (__before_first != __before_last) {
+ if (this->get_allocator() == __x.get_allocator()) {
+ _STLP_PRIV _Sl_global_inst::__splice_after(__pos._M_node,
+ __before_first._M_node, __before_last._M_node);
+ }
+ else {
+ this->insert_after(__pos, iterator(__before_first._M_node->_M_next), iterator(__before_last._M_node->_M_next));
+ __x.erase_after(__before_first, ++__before_last);
+ }
+ }
+ }
+
+ // Moves the element that follows __prev to *this, inserting it immediately
+ // after __pos. This is constant time.
+ void splice_after(iterator __pos, _Self& __x, iterator __prev) {
+ if (this->get_allocator() == __x.get_allocator()) {
+ _STLP_PRIV _Sl_global_inst::__splice_after(__pos._M_node,
+ __prev._M_node, __prev._M_node->_M_next);
+ }
+ else {
+ this->insert_after(__pos, __STATIC_CAST(_Node*, __prev._M_node->_M_next)->_M_data);
+ __x.erase_after(__prev);
+ }
+ }
+
+ // Removes all of the elements from the list __x to *this, inserting
+ // them immediately after __pos. __x must not be *this. Complexity:
+ // linear in __x.size().
+ void splice_after(iterator __pos, _Self& __x) {
+ if (this->get_allocator() == __x.get_allocator())
+ _STLP_PRIV _Sl_global_inst::__splice_after(__pos._M_node, &__x._M_head._M_data);
+ else {
+ this->insert_after(__pos, __x.begin(), __x.end());
+ __x.clear();
+ }
+ }
+
+ // Linear in distance(begin(), __pos), and linear in __x.size().
+ void splice(iterator __pos, _Self& __x) {
+ if (__x._M_head._M_data._M_next) {
+ if (this->get_allocator() == __x.get_allocator()) {
+ _STLP_PRIV _Sl_global_inst::__splice_after(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node),
+ &__x._M_head._M_data,
+ _STLP_PRIV _Sl_global_inst::__previous(&__x._M_head._M_data, 0));
+ }
+ else {
+ insert(__pos, __x.begin(), __x.end());
+ __x.clear();
+ }
+ }
+ }
+
+ // Linear in distance(begin(), __pos), and in distance(__x.begin(), __i).
+ void splice(iterator __pos, _Self& __x, iterator __i) {
+ if (this->get_allocator() == __x.get_allocator()) {
+ _STLP_PRIV _Sl_global_inst::__splice_after(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node),
+ _STLP_PRIV _Sl_global_inst::__previous(&__x._M_head._M_data, __i._M_node),
+ __i._M_node);
+ }
+ else {
+ insert(__pos, *__i);
+ __x.erase(__i);
+ }
+ }
+
+ // Linear in distance(begin(), __pos), in distance(__x.begin(), __first),
+ // and in distance(__first, __last).
+ void splice(iterator __pos, _Self& __x, iterator __first, iterator __last) {
+ if (__first != __last) {
+ if (this->get_allocator() == __x.get_allocator()) {
+ _STLP_PRIV _Sl_global_inst::__splice_after(_STLP_PRIV _Sl_global_inst::__previous(&this->_M_head._M_data, __pos._M_node),
+ _STLP_PRIV _Sl_global_inst::__previous(&__x._M_head._M_data, __first._M_node),
+ _STLP_PRIV _Sl_global_inst::__previous(__first._M_node, __last._M_node));
+ }
+ else {
+ insert(__pos, __first, __last);
+ __x.erase(__first, __last);
+ }
+ }
+ }
+
+public:
+ void reverse() {
+ if (this->_M_head._M_data._M_next)
+ this->_M_head._M_data._M_next = _STLP_PRIV _Sl_global_inst::__reverse(this->_M_head._M_data._M_next);
+ }
+
+ void remove(const _Tp& __val);
+
+ void unique() { _STLP_PRIV _Slist_unique(*this, equal_to<value_type>()); }
+ void merge(_Self& __x) { _STLP_PRIV _Slist_merge(*this, __x, less<value_type>()); }
+ void sort() { _STLP_PRIV _Slist_sort(*this, less<value_type>()); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _Predicate>
+ void remove_if(_Predicate __pred) {
+ _Node_base* __cur = &this->_M_head._M_data;
+ while (__cur->_M_next) {
+ if (__pred(__STATIC_CAST(_Node*, __cur->_M_next)->_M_data))
+ this->_M_erase_after(__cur);
+ else
+ __cur = __cur->_M_next;
+ }
+ }
+
+ template <class _BinaryPredicate>
+ void unique(_BinaryPredicate __pred)
+ { _STLP_PRIV _Slist_unique(*this, __pred); }
+
+ template <class _StrictWeakOrdering>
+ void merge(_Self& __x, _StrictWeakOrdering __comp)
+ { _STLP_PRIV _Slist_merge(*this, __x, __comp); }
+
+ template <class _StrictWeakOrdering>
+ void sort(_StrictWeakOrdering __comp)
+ { _STLP_PRIV _Slist_sort(*this, __comp); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+};
+
+#if defined (slist)
+# undef slist
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_slist.c>
+#endif
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+# include <stl/pointers/_slist.h>
+#endif
+
+#if defined (_STLP_DEBUG)
+# include <stl/debug/_slist.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Tp, class _Alloc>
+inline bool _STLP_CALL
+operator == (const slist<_Tp,_Alloc>& _SL1, const slist<_Tp,_Alloc>& _SL2) {
+ typedef typename slist<_Tp,_Alloc>::const_iterator const_iterator;
+ const_iterator __end1 = _SL1.end();
+ const_iterator __end2 = _SL2.end();
+
+ const_iterator __i1 = _SL1.begin();
+ const_iterator __i2 = _SL2.begin();
+ while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2) {
+ ++__i1;
+ ++__i2;
+ }
+ return __i1 == __end1 && __i2 == __end2;
+}
+
+#define _STLP_EQUAL_OPERATOR_SPECIALIZED
+#define _STLP_TEMPLATE_HEADER template <class _Tp, class _Alloc>
+#define _STLP_TEMPLATE_CONTAINER slist<_Tp, _Alloc>
+#include <stl/_relops_cont.h>
+#undef _STLP_TEMPLATE_CONTAINER
+#undef _STLP_TEMPLATE_HEADER
+#undef _STLP_EQUAL_OPERATOR_SPECIALIZED
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+# if !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Tp, class _Alloc>
+struct __move_traits<slist<_Tp, _Alloc> > {
+ typedef __true_type implemented;
+ typedef typename __move_traits<_Alloc>::complete complete;
+};
+# endif
+
+// Specialization of insert_iterator so that insertions will be constant
+// time rather than linear time.
+template <class _Tp, class _Alloc>
+class insert_iterator<slist<_Tp, _Alloc> > {
+protected:
+ typedef slist<_Tp, _Alloc> _Container;
+ _Container* _M_container;
+ typename _Container::iterator _M_iter;
+public:
+ typedef _Container container_type;
+ typedef output_iterator_tag iterator_category;
+ typedef void value_type;
+ typedef void difference_type;
+ typedef void pointer;
+ typedef void reference;
+
+ insert_iterator(_Container& __x, typename _Container::iterator __i)
+ : _M_container(&__x) {
+ if (__i == __x.begin())
+ _M_iter = __x.before_begin();
+ else
+ _M_iter = __x.previous(__i);
+ }
+
+ insert_iterator<_Container>&
+ operator = (const typename _Container::value_type& __val) {
+ _M_iter = _M_container->insert_after(_M_iter, __val);
+ return *this;
+ }
+
+ insert_iterator<_Container>& operator*() { return *this; }
+ insert_iterator<_Container>& operator++() { return *this; }
+ insert_iterator<_Container>& operator++(int) { return *this; }
+};
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_SLIST_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_slist_base.c b/sources/android/stlport/stlport/stl/_slist_base.c
new file mode 100644
index 0000000..e0e68c9
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_slist_base.c
@@ -0,0 +1,104 @@
+/*
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_SLIST_BASE_C
+#define _STLP_SLIST_BASE_C
+
+#ifndef _STLP_INTERNAL_SLIST_BASE_H
+# include <stl/_slist_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Dummy>
+_Slist_node_base* _STLP_CALL
+_Sl_global<_Dummy>::__previous(_Slist_node_base* __head,
+ const _Slist_node_base* __node) {
+ while (__head && __head->_M_next != __node)
+ __head = __head->_M_next;
+ return __head;
+}
+
+template <class _Dummy>
+void _STLP_CALL
+_Sl_global<_Dummy>::__splice_after(_Slist_node_base* __pos, _Slist_node_base* __head) {
+ _Slist_node_base* __before_last = __previous(__head, 0);
+ if (__before_last != __head) {
+ _Slist_node_base* __after = __pos->_M_next;
+ __pos->_M_next = __head->_M_next;
+ __head->_M_next = 0;
+ __before_last->_M_next = __after;
+ }
+}
+
+template <class _Dummy>
+void _STLP_CALL
+_Sl_global<_Dummy>::__splice_after(_Slist_node_base* __pos,
+ _Slist_node_base* __before_first,
+ _Slist_node_base* __before_last) {
+ if (__pos != __before_first && __pos != __before_last) {
+ _Slist_node_base* __first = __before_first->_M_next;
+ _Slist_node_base* __after = __pos->_M_next;
+ __before_first->_M_next = __before_last->_M_next;
+ __pos->_M_next = __first;
+ __before_last->_M_next = __after;
+ }
+}
+
+template <class _Dummy>
+_Slist_node_base* _STLP_CALL
+_Sl_global<_Dummy>::__reverse(_Slist_node_base* __node) {
+ _Slist_node_base* __result = __node;
+ __node = __node->_M_next;
+ __result->_M_next = 0;
+ while(__node) {
+ _Slist_node_base* __next = __node->_M_next;
+ __node->_M_next = __result;
+ __result = __node;
+ __node = __next;
+ }
+ return __result;
+}
+
+template <class _Dummy>
+size_t _STLP_CALL
+_Sl_global<_Dummy>::size(_Slist_node_base* __node) {
+ size_t __result = 0;
+ for ( ; __node != 0; __node = __node->_M_next)
+ ++__result;
+ return __result;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_SLIST_BASE_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_slist_base.h b/sources/android/stlport/stlport/stl/_slist_base.h
new file mode 100644
index 0000000..3afa18a
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_slist_base.h
@@ -0,0 +1,90 @@
+/*
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_SLIST_BASE_H
+#define _STLP_INTERNAL_SLIST_BASE_H
+
+#ifndef _STLP_INTERNAL_CSTDDEF
+# include <stl/_cstddef.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+struct _Slist_node_base {
+ _Slist_node_base* _M_next;
+};
+
+inline _Slist_node_base*
+__slist_make_link(_Slist_node_base* __prev_node,
+ _Slist_node_base* __new_node) {
+ __new_node->_M_next = __prev_node->_M_next;
+ __prev_node->_M_next = __new_node;
+ return __new_node;
+}
+
+
+template <class _Dummy>
+class _Sl_global {
+public:
+ // those used to be global functions
+ // moved here to reduce code bloat without templatizing _Slist_iterator_base
+ static size_t _STLP_CALL size(_Slist_node_base* __node);
+ static _Slist_node_base* _STLP_CALL __reverse(_Slist_node_base* __node);
+ static void _STLP_CALL __splice_after(_Slist_node_base* __pos,
+ _Slist_node_base* __before_first,
+ _Slist_node_base* __before_last);
+
+ static void _STLP_CALL __splice_after(_Slist_node_base* __pos, _Slist_node_base* __head);
+
+ static _Slist_node_base* _STLP_CALL __previous(_Slist_node_base* __head,
+ const _Slist_node_base* __node);
+ static const _Slist_node_base* _STLP_CALL __previous(const _Slist_node_base* __head,
+ const _Slist_node_base* __node) {
+ return _Sl_global<_Dummy>::__previous(__CONST_CAST(_Slist_node_base*, __head), __node);
+ }
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS _Sl_global<bool>;
+#endif
+
+typedef _Sl_global<bool> _Sl_global_inst;
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION) && defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)
+# include <stl/_slist_base.c>
+#endif
+
+#endif /* _STLP_INTERNAL_SLIST_BASE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_sparc_atomic.h b/sources/android/stlport/stlport/stl/_sparc_atomic.h
new file mode 100644
index 0000000..21cc0ad
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_sparc_atomic.h
@@ -0,0 +1,61 @@
+
+// Currently, SUN CC requires object file
+
+#if defined (__GNUC__)
+
+/*
+** int _STLP_atomic_exchange (__stl_atomic_t *pvalue, __stl_atomic_t value)
+*/
+
+# if defined(__sparc_v9__) || defined (__sparcv9)
+
+# ifdef __arch64__
+
+# define _STLP_EXCH_ASM asm volatile ("casx [%3], %4, %0 ; membar #LoadLoad | #LoadStore " : \
+ "=r" (_L_value2), "=m" (*_L_pvalue1) : \
+ "m" (*_L_pvalue1), "r" (_L_pvalue1), "r" (_L_value1), "0" (_L_value2) )
+
+# else /* __arch64__ */
+
+# define _STLP_EXCH_ASM asm volatile ("cas [%3], %4, %0" : \
+ "=r" (_L_value2), "=m" (*_L_pvalue1) : \
+ "m" (*_L_pvalue1), "r" (_L_pvalue1), "r" (_L_value1), "0" (_L_value2) )
+# endif
+
+# else /* __sparc_v9__ */
+
+# define _STLP_EXCH_ASM asm volatile ("swap [%3], %0 " : \
+ "=r" (_L_value2), "=m" (*_L_pvalue1) : \
+ "m" (*_L_pvalue1), "r" (_L_pvalue1), "0" (_L_value2) )
+# endif
+
+
+# define _STLP_ATOMIC_EXCHANGE(__pvalue1, __value2) \
+ ({ register volatile __stl_atomic_t *_L_pvalue1 = __pvalue1; \
+ register __stl_atomic_t _L_value1, _L_value2 = __value2 ; \
+ do { _L_value1 = *_L_pvalue1; _STLP_EXCH_ASM; } while ( _L_value1 != _L_value2 ) ; \
+ _L_value1; })
+
+# define _STLP_ATOMIC_INCREMENT(__pvalue1) \
+ ({ register volatile __stl_atomic_t *_L_pvalue1 = __pvalue1; \
+ register __stl_atomic_t _L_value1, _L_value2; \
+ do { _L_value1 = *_L_pvalue1; _L_value2 = _L_value1+1; _STLP_EXCH_ASM; } while ( _L_value1 != _L_value2 ) ; \
+ (_L_value2 + 1); })
+
+# define _STLP_ATOMIC_DECREMENT(__pvalue1) \
+ ({ register volatile __stl_atomic_t *_L_pvalue1 = __pvalue1; \
+ register __stl_atomic_t _L_value1, _L_value2; \
+ do { _L_value1 = *_L_pvalue1; _L_value2 = _L_value1-1; _STLP_EXCH_ASM; } while ( _L_value1 != _L_value2 ) ; \
+ (_L_value2 - 1); })
+
+# elif ! defined (_STLP_NO_EXTERN_INLINE)
+
+extern "C" __stl_atomic_t _STLP_atomic_exchange(__stl_atomic_t * __x, __stl_atomic_t __v);
+extern "C" void _STLP_atomic_decrement(__stl_atomic_t* i);
+extern "C" void _STLP_atomic_increment(__stl_atomic_t* i);
+
+# define _STLP_ATOMIC_INCREMENT(__x) _STLP_atomic_increment((__stl_atomic_t*)__x)
+# define _STLP_ATOMIC_DECREMENT(__x) _STLP_atomic_decrement((__stl_atomic_t*)__x)
+# define _STLP_ATOMIC_EXCHANGE(__x, __y) _STLP_atomic_exchange((__stl_atomic_t*)__x, (__stl_atomic_t)__y)
+
+#endif
diff --git a/sources/android/stlport/stlport/stl/_sstream.c b/sources/android/stlport/stlport/stl/_sstream.c
new file mode 100644
index 0000000..9f58535
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_sstream.c
@@ -0,0 +1,465 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_SSTREAM_C
+#define _STLP_SSTREAM_C
+
+#ifndef _STLP_INTERNAL_SSTREAM
+# include <stl/_sstream.h>
+#endif
+
+#if defined ( _STLP_NESTED_TYPE_PARAM_BUG )
+// no wint_t is supported for this mode
+# define __BSB_int_type__ int
+# define __BSB_pos_type__ streampos
+#else
+# define __BSB_int_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+# define __BSB_pos_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//----------------------------------------------------------------------
+// Non-inline stringbuf member functions.
+
+// Constructors. Note that the base class constructor sets all of the
+// get and area pointers to null.
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_stringbuf<_CharT, _Traits, _Alloc>
+ ::basic_stringbuf(ios_base::openmode __mode)
+ : basic_streambuf<_CharT, _Traits>(), _M_mode(__mode), _M_str()
+{}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_stringbuf<_CharT, _Traits, _Alloc>
+ ::basic_stringbuf(const basic_string<_CharT, _Traits, _Alloc>& __s, ios_base::openmode __mode)
+ : basic_streambuf<_CharT, _Traits>(), _M_mode(__mode), _M_str(__s)
+{
+ _M_set_ptrs();
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_stringbuf<_CharT, _Traits, _Alloc>::~basic_stringbuf()
+{}
+
+// Set the underlying string to a new value.
+template <class _CharT, class _Traits, class _Alloc>
+void
+basic_stringbuf<_CharT, _Traits, _Alloc>::str(const basic_string<_CharT, _Traits, _Alloc>& __s)
+{
+ _M_str = __s;
+ _M_set_ptrs();
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+void
+basic_stringbuf<_CharT, _Traits, _Alloc>::_M_set_ptrs()
+{
+ _CharT* __data_ptr = _S_start(_M_str);
+ _CharT* __data_end = _S_finish(_M_str);
+ // The initial read position is the beginning of the string.
+ if (_M_mode & ios_base::in) {
+ this->setg(__data_ptr, (_M_mode & ios_base::ate) ? __data_end : __data_ptr, __data_end);
+ }
+
+ // The initial write position is the beginning of the string.
+ if (_M_mode & ios_base::out) {
+ if ( _M_mode & (ios_base::app | ios_base::ate) ) {
+ this->setp( __data_end, __data_end );
+ } else {
+ this->setp( __data_ptr, __data_end );
+ this->pbump((int)_M_str.size()); // initial write position, if we initialized with string
+ }
+ // this->setp((_M_mode & (ios_base::app | ios_base::ate))? __data_end : __data_ptr, __data_end);
+ }
+}
+
+// Precondition: gptr() >= egptr(). Returns a character, if one is available.
+template <class _CharT, class _Traits, class _Alloc>
+__BSB_int_type__
+basic_stringbuf<_CharT, _Traits, _Alloc>::underflow() {
+ return this->gptr() != this->egptr()
+ ? _Traits::to_int_type(*this->gptr())
+ : _Traits::eof();
+}
+
+// Precondition: gptr() >= egptr().
+template <class _CharT, class _Traits, class _Alloc>
+__BSB_int_type__
+basic_stringbuf<_CharT, _Traits, _Alloc>::uflow() {
+ if (this->gptr() != this->egptr()) {
+ int_type __c = _Traits::to_int_type(*this->gptr());
+ this->gbump(1);
+ return __c;
+ }
+ else
+ return _Traits::eof();
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+__BSB_int_type__
+basic_stringbuf<_CharT, _Traits, _Alloc>::pbackfail(int_type __c) {
+ if (this->gptr() != this->eback()) {
+ if (!_Traits::eq_int_type(__c, _Traits::eof())) {
+ if (_Traits::eq(_Traits::to_char_type(__c), this->gptr()[-1])) {
+ this->gbump(-1);
+ return __c;
+ }
+ else if (_M_mode & ios_base::out) {
+ this->gbump(-1);
+ *this->gptr() = _Traits::to_char_type(__c);
+ return __c;
+ }
+ else
+ return _Traits::eof();
+ }
+ else {
+ this->gbump(-1);
+ return _Traits::not_eof(__c);
+ }
+ }
+ else
+ return _Traits::eof();
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+__BSB_int_type__ basic_stringbuf<_CharT, _Traits, _Alloc>::overflow(int_type __c)
+{
+ if (!_Traits::eq_int_type(__c, _Traits::eof())) {
+ if (_M_mode & ios_base::out) {
+ if ( this->pptr() < this->epptr() ) { // just put back in any case
+ _M_str.push_back( _Traits::to_char_type(__c) );
+ this->pbump(1);
+ } else if ( _M_mode & ios_base::in ) {
+ ptrdiff_t __offset = this->gptr() - this->eback();
+ _M_str.push_back(_Traits::to_char_type(__c));
+ _CharT* __data_ptr = _S_start(_M_str);
+ this->setg(__data_ptr, __data_ptr + __offset, _S_finish(_M_str));
+ this->setp(__data_ptr, _S_finish(_M_str));
+ this->pbump((int)_M_str.size());
+ } else {
+ _M_str.push_back( _Traits::to_char_type(__c) );
+ this->setp(_S_start(_M_str), _S_finish(_M_str));
+ this->pbump((int)_M_str.size());
+ }
+ return __c;
+ }
+ return _Traits::eof(); // Overflow always fails if it's read-only
+ }
+ return _Traits::not_eof(__c); // __c is EOF, so we don't have to do anything
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+streamsize
+basic_stringbuf<_CharT, _Traits, _Alloc>::xsputn(const char_type* __s,
+ streamsize __n) {
+ streamsize __nwritten = 0;
+
+ if ((_M_mode & ios_base::out) && __n > 0) {
+ // If the put pointer is somewhere in the middle of the string,
+ // then overwrite instead of append.
+ if ( !_M_str.empty() && this->pbase() == _S_start(_M_str)) {
+ ptrdiff_t __avail = _S_finish(_M_str) - this->pptr();
+ if (__avail > __n) {
+ _Traits::copy(this->pptr(), __s, __STATIC_CAST(size_t, __n));
+ this->pbump((int)__n);
+ return __n;
+ } else {
+ _Traits::copy(this->pptr(), __s, __avail);
+ __nwritten += __avail;
+ __n -= __avail;
+ __s += __avail;
+ }
+ }
+
+ // At this point we know we're appending.
+ _CharT* __data_ptr;
+ if (_M_mode & ios_base::in) {
+ ptrdiff_t __get_offset = this->gptr() - this->eback();
+ _M_str.append(__s, __s + __STATIC_CAST(ptrdiff_t, __n));
+ __data_ptr = _S_start(_M_str);
+ this->setg(__data_ptr, __data_ptr + __get_offset, _S_finish(_M_str));
+ } else {
+ _M_str.append(__s, __s + __STATIC_CAST(ptrdiff_t, __n));
+ __data_ptr = _S_start(_M_str);
+ }
+
+ this->setp(__data_ptr, _S_finish(_M_str));
+ this->pbump((int)_M_str.size());
+ __nwritten += __n;
+ }
+
+ return __nwritten;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+streamsize
+basic_stringbuf<_CharT, _Traits, _Alloc>::_M_xsputnc(char_type __c,
+ streamsize __n) {
+ streamsize __nwritten = 0;
+
+ if ((_M_mode & ios_base::out) && __n > 0) {
+ // If the put pointer is somewhere in the middle of the string,
+ // then overwrite instead of append.
+ if (this->pbase() == _S_start(_M_str)) {
+ ptrdiff_t __avail = _S_finish(_M_str) - this->pptr();
+ if (__avail > __n) {
+ _Traits::assign(this->pptr(), __STATIC_CAST(size_t, __n), __c);
+ this->pbump(__STATIC_CAST(int, __n));
+ return __n;
+ }
+ else {
+ _Traits::assign(this->pptr(), __avail, __c);
+ __nwritten += __avail;
+ __n -= __avail;
+ }
+ }
+
+ // At this point we know we're appending.
+ size_t __app_size = sizeof(streamsize) > sizeof(size_t) ? __STATIC_CAST(size_t, (min)(__n, __STATIC_CAST(streamsize, _M_str.max_size())))
+ : __STATIC_CAST(size_t, __n);
+ _CharT* __data_ptr;
+ if (this->_M_mode & ios_base::in) {
+ ptrdiff_t __get_offset = this->gptr() - this->eback();
+ _M_str.append(__app_size, __c);
+ __data_ptr = _S_start(_M_str);
+ this->setg(__data_ptr, __data_ptr + __get_offset, _S_finish(_M_str));
+ } else {
+ _M_str.append(__app_size, __c);
+ __data_ptr = _S_start(_M_str);
+ }
+
+ this->setp(__data_ptr, _S_finish(_M_str));
+ this->pbump((int)_M_str.size());
+ __nwritten += __app_size;
+ }
+
+ return __nwritten;
+}
+
+// According to the C++ standard the effects of setbuf are implementation
+// defined, except that setbuf(0, 0) has no effect. In this implementation,
+// setbuf(<anything>, n), for n > 0, calls reserve(n) on the underlying
+// string.
+template <class _CharT, class _Traits, class _Alloc>
+basic_streambuf<_CharT, _Traits>*
+basic_stringbuf<_CharT, _Traits, _Alloc>::setbuf(_CharT*, streamsize __n) {
+ if (__n > 0) {
+ bool __do_get_area = false;
+ bool __do_put_area = false;
+ ptrdiff_t __offg = 0;
+ ptrdiff_t __offp = 0;
+
+ if (this->pbase() == _S_start(_M_str)) {
+ __do_put_area = true;
+ __offp = this->pptr() - this->pbase();
+ }
+
+ if (this->eback() == _S_start(_M_str)) {
+ __do_get_area = true;
+ __offg = this->gptr() - this->eback();
+ }
+
+ _M_str.reserve(sizeof(streamsize) > sizeof(size_t) ? __STATIC_CAST(size_t, (min)(__n, __STATIC_CAST(streamsize, _M_str.max_size())))
+ : __STATIC_CAST(size_t, __n));
+
+ _CharT* __data_ptr = _S_start(_M_str);
+
+ if (__do_get_area) {
+ this->setg(__data_ptr, __data_ptr + __offg, _S_finish(_M_str));
+ }
+
+ if (__do_put_area) {
+ this->setp(__data_ptr, _S_finish(_M_str));
+ this->pbump((int)__offp);
+ }
+ }
+
+ return this;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+__BSB_pos_type__
+basic_stringbuf<_CharT, _Traits, _Alloc>
+ ::seekoff(off_type __off,
+ ios_base::seekdir __dir,
+ ios_base::openmode __mode) {
+ __mode &= _M_mode;
+
+ bool __imode = (__mode & ios_base::in) != 0;
+ bool __omode = (__mode & ios_base::out) != 0;
+
+ if ( !(__imode || __omode) )
+ return pos_type(off_type(-1));
+
+ if ( (__imode && (this->gptr() == 0)) || (__omode && (this->pptr() == 0)) )
+ return pos_type(off_type(-1));
+
+ streamoff __newoff;
+ switch(__dir) {
+ case ios_base::beg:
+ __newoff = 0;
+ break;
+ case ios_base::end:
+ __newoff = _M_str.size();
+ break;
+ case ios_base::cur:
+ __newoff = __imode ? this->gptr() - this->eback() : this->pptr() - this->pbase();
+ if ( __off == 0 ) {
+ return pos_type(__newoff);
+ }
+ break;
+ default:
+ return pos_type(off_type(-1));
+ }
+
+ __off += __newoff;
+
+ if (__imode) {
+ ptrdiff_t __n = this->egptr() - this->eback();
+
+ if (__off < 0 || __off > __n)
+ return pos_type(off_type(-1));
+ this->setg(this->eback(), this->eback() + __STATIC_CAST(ptrdiff_t, __off),
+ this->eback() + __STATIC_CAST(ptrdiff_t, __n));
+ }
+
+ if (__omode) {
+ ptrdiff_t __n = this->epptr() - this->pbase();
+
+ if (__off < 0 || __off > __n)
+ return pos_type(off_type(-1));
+ this->setp(this->pbase(), this->pbase() + __n);
+ this->pbump((int)__off);
+ }
+
+ return pos_type(__off);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+__BSB_pos_type__
+basic_stringbuf<_CharT, _Traits, _Alloc>
+ ::seekpos(pos_type __pos, ios_base::openmode __mode) {
+ __mode &= _M_mode;
+
+ bool __imode = (__mode & ios_base::in) != 0;
+ bool __omode = (__mode & ios_base::out) != 0;
+
+ if ( !(__imode || __omode) )
+ return pos_type(off_type(-1));
+
+ if ( (__imode && (this->gptr() == 0)) || (__omode && (this->pptr() == 0)) )
+ return pos_type(off_type(-1));
+
+ const off_type __n = __pos - pos_type(off_type(0));
+
+ if (__imode) {
+ if (__n < 0 || __n > this->egptr() - this->eback())
+ return pos_type(off_type(-1));
+ this->setg(this->eback(), this->eback() + __STATIC_CAST(ptrdiff_t, __n), this->egptr());
+ }
+
+ if (__omode) {
+ if (__n < 0 || size_t(__n) > _M_str.size())
+ return pos_type(off_type(-1));
+
+ this->setp(_S_start(_M_str), _S_finish(_M_str));
+ this->pbump((int)__n);
+ }
+
+ return __pos;
+}
+
+//----------------------------------------------------------------------
+// Non-inline istringstream member functions.
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_istringstream<_CharT, _Traits, _Alloc>
+ ::basic_istringstream(ios_base::openmode __mode)
+ : basic_istream<_CharT, _Traits>(0),
+ _M_buf(__mode | ios_base::in) {
+ this->init(&_M_buf);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_istringstream<_CharT, _Traits, _Alloc>
+ ::basic_istringstream(const _String& __str,ios_base::openmode __mode)
+ : basic_istream<_CharT, _Traits>(0),
+ _M_buf(__str, __mode | ios_base::in) {
+ this->init(&_M_buf);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_istringstream<_CharT, _Traits, _Alloc>::~basic_istringstream()
+{}
+
+//----------------------------------------------------------------------
+// Non-inline ostringstream member functions.
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_ostringstream<_CharT, _Traits, _Alloc>
+ ::basic_ostringstream(ios_base::openmode __mode)
+ : basic_ostream<_CharT, _Traits>(0),
+ _M_buf(__mode | ios_base::out) {
+ this->init(&_M_buf);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_ostringstream<_CharT, _Traits, _Alloc>
+ ::basic_ostringstream(const _String& __str, ios_base::openmode __mode)
+ : basic_ostream<_CharT, _Traits>(0),
+ _M_buf(__str, __mode | ios_base::out) {
+ this->init(&_M_buf);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_ostringstream<_CharT, _Traits, _Alloc>::~basic_ostringstream()
+{}
+
+//----------------------------------------------------------------------
+// Non-inline stringstream member functions.
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_stringstream<_CharT, _Traits, _Alloc>
+ ::basic_stringstream(ios_base::openmode __mode)
+ : basic_iostream<_CharT, _Traits>(0), _M_buf(__mode) {
+ this->init(&_M_buf);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_stringstream<_CharT, _Traits, _Alloc>
+ ::basic_stringstream(const _String& __str, ios_base::openmode __mode)
+ : basic_iostream<_CharT, _Traits>(0), _M_buf(__str, __mode) {
+ this->init(&_M_buf);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_stringstream<_CharT, _Traits, _Alloc>::~basic_stringstream()
+{}
+
+_STLP_END_NAMESPACE
+
+# undef __BSB_int_type__
+# undef __BSB_pos_type__
+
+#endif /* _STLP_SSTREAM_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_sstream.h b/sources/android/stlport/stlport/stl/_sstream.h
new file mode 100644
index 0000000..9e8d02a
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_sstream.h
@@ -0,0 +1,266 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+
+// This header defines classes basic_stringbuf, basic_istringstream,
+// basic_ostringstream, and basic_stringstream. These classes
+// represent streamsbufs and streams whose sources or destinations are
+// C++ strings.
+
+#ifndef _STLP_INTERNAL_SSTREAM
+#define _STLP_INTERNAL_SSTREAM
+
+#ifndef _STLP_INTERNAL_STREAMBUF
+# include <stl/_streambuf.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ISTREAM
+# include <stl/_istream.h> // Includes <ostream>, <ios>, <iosfwd>
+#endif
+
+#ifndef _STLP_INTERNAL_STRING_H
+# include <stl/_string.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//----------------------------------------------------------------------
+// This version of basic_stringbuf relies on the internal details of
+// basic_string. It relies on the fact that, in this implementation,
+// basic_string's iterators are pointers. It also assumes (as allowed
+// by the standard) that _CharT is a POD type.
+
+// We have a very small buffer for the put area, just so that we don't
+// have to use append() for every sputc. Conceptually, the buffer
+// immediately follows the end of the underlying string. We use this
+// buffer when appending to write-only streambufs, but we don't use it
+// for read-write streambufs.
+
+template <class _CharT, class _Traits, class _Alloc>
+class basic_stringbuf : public basic_streambuf<_CharT, _Traits> {
+public: // Typedefs.
+ typedef _CharT char_type;
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+ typedef _Traits traits_type;
+
+ typedef basic_streambuf<_CharT, _Traits> _Base;
+ typedef basic_stringbuf<_CharT, _Traits, _Alloc> _Self;
+ typedef basic_string<_CharT, _Traits, _Alloc> _String;
+
+public: // Constructors, destructor.
+ explicit basic_stringbuf(ios_base::openmode __mode
+ = ios_base::in | ios_base::out);
+ explicit basic_stringbuf(const _String& __s, ios_base::openmode __mode
+ = ios_base::in | ios_base::out);
+ virtual ~basic_stringbuf();
+
+public: // Get or set the string.
+ _String str() const { return _M_str; }
+ void str(const _String& __s);
+
+protected: // Overridden virtual member functions.
+ virtual int_type underflow();
+ virtual int_type uflow();
+ virtual int_type pbackfail(int_type __c);
+ virtual int_type overflow(int_type __c);
+ int_type pbackfail() {return pbackfail(_Traits::eof());}
+ int_type overflow() {return overflow(_Traits::eof());}
+
+ virtual streamsize xsputn(const char_type* __s, streamsize __n);
+ virtual streamsize _M_xsputnc(char_type __c, streamsize __n);
+
+ virtual _Base* setbuf(_CharT* __buf, streamsize __n);
+ virtual pos_type seekoff(off_type __off, ios_base::seekdir __dir,
+ ios_base::openmode __mode
+ = ios_base::in | ios_base::out);
+ virtual pos_type seekpos(pos_type __pos, ios_base::openmode __mode
+ = ios_base::in | ios_base::out);
+
+private: // Helper functions.
+ void _M_set_ptrs();
+ static _CharT* _S_start(const _String& __str) { return __CONST_CAST(_CharT*, __str.data()); }
+ static _CharT* _S_finish(const _String& __str) { return __CONST_CAST(_CharT*, __str.data()) + __str.size(); }
+
+private:
+ ios_base::openmode _M_mode;
+ _String _M_str;
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS basic_stringbuf<char, char_traits<char>, allocator<char> >;
+# if !defined (_STLP_NO_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS basic_stringbuf<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >;
+# endif
+#endif /* _STLP_USE_TEMPLATE_EXPORT */
+
+//----------------------------------------------------------------------
+// Class basic_istringstream, an input stream that uses a stringbuf.
+
+template <class _CharT, class _Traits, class _Alloc>
+class basic_istringstream : public basic_istream<_CharT, _Traits> {
+public: // Typedefs
+ typedef typename _Traits::char_type char_type;
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+ typedef _Traits traits_type;
+
+ typedef basic_ios<_CharT, _Traits> _Basic_ios;
+ typedef basic_istream<_CharT, _Traits> _Base;
+ typedef basic_string<_CharT, _Traits, _Alloc> _String;
+ typedef basic_stringbuf<_CharT, _Traits, _Alloc> _Buf;
+
+public: // Constructors, destructor.
+ basic_istringstream(ios_base::openmode __mode = ios_base::in);
+ basic_istringstream(const _String& __str,
+ ios_base::openmode __mode = ios_base::in);
+ ~basic_istringstream();
+
+public: // Member functions
+
+ basic_stringbuf<_CharT, _Traits, _Alloc>* rdbuf() const
+ { return __CONST_CAST(_Buf*,&_M_buf); }
+
+ _String str() const { return _M_buf.str(); }
+ void str(const _String& __s) { _M_buf.str(__s); }
+
+private:
+ basic_stringbuf<_CharT, _Traits, _Alloc> _M_buf;
+
+#if defined (_STLP_MSVC) && (_STLP_MSVC >= 1300 && _STLP_MSVC <= 1310)
+ typedef basic_istringstream<_CharT, _Traits> _Self;
+ //explicitely defined as private to avoid warnings:
+ basic_istringstream(_Self const&);
+ _Self& operator = (_Self const&);
+#endif
+};
+
+
+//----------------------------------------------------------------------
+// Class basic_ostringstream, an output stream that uses a stringbuf.
+
+template <class _CharT, class _Traits, class _Alloc>
+class basic_ostringstream : public basic_ostream<_CharT, _Traits> {
+public: // Typedefs
+ typedef typename _Traits::char_type char_type;
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+ typedef _Traits traits_type;
+
+ typedef basic_ios<_CharT, _Traits> _Basic_ios;
+ typedef basic_ostream<_CharT, _Traits> _Base;
+ typedef basic_string<_CharT, _Traits, _Alloc> _String;
+ typedef basic_stringbuf<_CharT, _Traits, _Alloc> _Buf;
+
+public: // Constructors, destructor.
+ basic_ostringstream(ios_base::openmode __mode = ios_base::out);
+ basic_ostringstream(const _String& __str,
+ ios_base::openmode __mode = ios_base::out);
+ ~basic_ostringstream();
+
+public: // Member functions.
+
+ basic_stringbuf<_CharT, _Traits, _Alloc>* rdbuf() const
+ { return __CONST_CAST(_Buf*,&_M_buf); }
+
+ _String str() const { return _M_buf.str(); }
+ void str(const _String& __s) { _M_buf.str(__s); } // dwa 02/07/00 - BUG STOMPER DAVE
+
+
+private:
+ basic_stringbuf<_CharT, _Traits, _Alloc> _M_buf;
+
+#if defined (_STLP_MSVC) && (_STLP_MSVC >= 1300 && _STLP_MSVC <= 1310)
+ typedef basic_ostringstream<_CharT, _Traits> _Self;
+ //explicitely defined as private to avoid warnings:
+ basic_ostringstream(_Self const&);
+ _Self& operator = (_Self const&);
+#endif
+};
+
+
+//----------------------------------------------------------------------
+// Class basic_stringstream, a bidirectional stream that uses a stringbuf.
+
+template <class _CharT, class _Traits, class _Alloc>
+class basic_stringstream : public basic_iostream<_CharT, _Traits> {
+public: // Typedefs
+ typedef typename _Traits::char_type char_type;
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+ typedef _Traits traits_type;
+
+ typedef basic_ios<_CharT, _Traits> _Basic_ios;
+ typedef basic_iostream<_CharT, _Traits> _Base;
+ typedef basic_string<_CharT, _Traits, _Alloc> _String;
+ typedef basic_stringbuf<_CharT, _Traits, _Alloc> _Buf;
+
+ typedef ios_base::openmode openmode;
+
+public: // Constructors, destructor.
+ basic_stringstream(openmode __mod = ios_base::in | ios_base::out);
+ basic_stringstream(const _String& __str,
+ openmode __mod = ios_base::in | ios_base::out);
+ ~basic_stringstream();
+
+public: // Member functions.
+
+ basic_stringbuf<_CharT, _Traits, _Alloc>* rdbuf() const
+ { return __CONST_CAST(_Buf*,&_M_buf); }
+
+ _String str() const { return _M_buf.str(); }
+ void str(const _String& __s) { _M_buf.str(__s); }
+
+private:
+ basic_stringbuf<_CharT, _Traits, _Alloc> _M_buf;
+
+#if defined (_STLP_MSVC) && (_STLP_MSVC >= 1300 && _STLP_MSVC <= 1310)
+ typedef basic_stringstream<_CharT, _Traits> _Self;
+ //explicitely defined as private to avoid warnings:
+ basic_stringstream(_Self const&);
+ _Self& operator = (_Self const&);
+#endif
+};
+
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS basic_istringstream<char, char_traits<char>, allocator<char> >;
+_STLP_EXPORT_TEMPLATE_CLASS basic_ostringstream<char, char_traits<char>, allocator<char> >;
+_STLP_EXPORT_TEMPLATE_CLASS basic_stringstream<char, char_traits<char>, allocator<char> >;
+# if !defined (_STLP_NO_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS basic_istringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >;
+_STLP_EXPORT_TEMPLATE_CLASS basic_ostringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >;
+_STLP_EXPORT_TEMPLATE_CLASS basic_stringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >;
+# endif
+#endif /* _STLP_USE_TEMPLATE_EXPORT */
+
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_sstream.c>
+#endif
+
+#endif /* _STLP_INTERNAL_SSTREAM */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_stack.h b/sources/android/stlport/stlport/stl/_stack.h
new file mode 100644
index 0000000..7ea9d59
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_stack.h
@@ -0,0 +1,133 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_STACK_H
+#define _STLP_INTERNAL_STACK_H
+
+#ifndef _STLP_INTERNAL_DEQUE_H
+# include <stl/_deque.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if !defined ( _STLP_LIMITED_DEFAULT_TEMPLATES )
+template <class _Tp, class _Sequence = deque<_Tp> >
+#elif defined ( _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS )
+# define _STLP_STACK_ARGS _Tp
+template <class _Tp>
+#else
+template <class _Tp, class _Sequence>
+#endif
+class stack
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+# if defined (_STLP_STACK_ARGS)
+ : public __stlport_class<stack<_Tp> >
+# else
+ : public __stlport_class<stack<_Tp, _Sequence> >
+# endif
+#endif
+{
+#ifdef _STLP_STACK_ARGS
+ typedef deque<_Tp> _Sequence;
+ typedef stack<_Tp> _Self;
+#else
+ typedef stack<_Tp, _Sequence> _Self;
+#endif
+
+public:
+ typedef typename _Sequence::value_type value_type;
+ typedef typename _Sequence::size_type size_type;
+ typedef _Sequence container_type;
+
+ typedef typename _Sequence::reference reference;
+ typedef typename _Sequence::const_reference const_reference;
+protected:
+ //c is a Standard name (23.2.3.3), do no make it STLport naming convention compliant.
+ _Sequence c;
+public:
+ stack() : c() {}
+ explicit stack(const _Sequence& __s) : c(__s) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ stack(__move_source<_Self> src)
+ : c(_STLP_PRIV _AsMoveSource(src.get().c)) {}
+#endif
+
+ bool empty() const { return c.empty(); }
+ size_type size() const { return c.size(); }
+ reference top() { return c.back(); }
+ const_reference top() const { return c.back(); }
+ void push(const value_type& __x) { c.push_back(__x); }
+ void pop() { c.pop_back(); }
+ const _Sequence& _Get_s() const { return c; }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) {
+ _Sequence __tmp = c;
+ c = __x.c;
+ __x.c = __tmp;
+ }
+#endif
+};
+
+#ifndef _STLP_STACK_ARGS
+# define _STLP_STACK_ARGS _Tp, _Sequence
+# define _STLP_STACK_HEADER_ARGS class _Tp, class _Sequence
+#else
+# define _STLP_STACK_HEADER_ARGS class _Tp
+#endif
+
+template < _STLP_STACK_HEADER_ARGS >
+inline bool _STLP_CALL operator==(const stack< _STLP_STACK_ARGS >& __x,
+ const stack< _STLP_STACK_ARGS >& __y)
+{ return __x._Get_s() == __y._Get_s(); }
+
+template < _STLP_STACK_HEADER_ARGS >
+inline bool _STLP_CALL operator<(const stack< _STLP_STACK_ARGS >& __x,
+ const stack< _STLP_STACK_ARGS >& __y)
+{ return __x._Get_s() < __y._Get_s(); }
+
+_STLP_RELOPS_OPERATORS(template < _STLP_STACK_HEADER_ARGS >, stack< _STLP_STACK_ARGS >)
+
+#undef _STLP_STACK_ARGS
+#undef _STLP_STACK_HEADER_ARGS
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Tp, class _Sequence>
+struct __move_traits<stack<_Tp, _Sequence> > :
+ _STLP_PRIV __move_traits_aux<_Sequence>
+{};
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_STACK_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_stdexcept.h b/sources/android/stlport/stlport/stl/_stdexcept.h
new file mode 100644
index 0000000..8c784bb
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_stdexcept.h
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_STDEXCEPT
+#define _STLP_INTERNAL_STDEXCEPT
+
+#ifndef _STLP_INTERNAL_STDEXCEPT_BASE
+# include <stl/_stdexcept_base.h>
+#endif
+
+#if !defined (_STLP_USE_NATIVE_STDEXCEPT) || defined (_STLP_USE_OWN_NAMESPACE)
+
+# if defined(_STLP_USE_EXCEPTIONS) || \
+ !(defined(_MIPS_SIM) && defined(_ABIO32) && (_MIPS_SIM == _ABIO32))
+
+_STLP_BEGIN_NAMESPACE
+
+class _STLP_CLASS_DECLSPEC logic_error : public __Named_exception {
+public:
+ logic_error(const string& __s) : __Named_exception(__s) {}
+# ifndef _STLP_USE_NO_IOSTREAMS
+ ~logic_error() _STLP_NOTHROW_INHERENTLY;
+# endif
+};
+
+class _STLP_CLASS_DECLSPEC runtime_error : public __Named_exception {
+public:
+ runtime_error(const string& __s) : __Named_exception(__s) {}
+# ifndef _STLP_USE_NO_IOSTREAMS
+ ~runtime_error() _STLP_NOTHROW_INHERENTLY;
+# endif
+};
+
+class _STLP_CLASS_DECLSPEC domain_error : public logic_error {
+public:
+ domain_error(const string& __arg) : logic_error(__arg) {}
+# ifndef _STLP_USE_NO_IOSTREAMS
+ ~domain_error() _STLP_NOTHROW_INHERENTLY;
+# endif
+};
+
+class _STLP_CLASS_DECLSPEC invalid_argument : public logic_error {
+public:
+ invalid_argument(const string& __arg) : logic_error(__arg) {}
+# ifndef _STLP_USE_NO_IOSTREAMS
+ ~invalid_argument() _STLP_NOTHROW_INHERENTLY;
+# endif
+};
+
+class _STLP_CLASS_DECLSPEC length_error : public logic_error {
+public:
+ length_error(const string& __arg) : logic_error(__arg) {}
+# ifndef _STLP_USE_NO_IOSTREAMS
+ ~length_error() _STLP_NOTHROW_INHERENTLY;
+# endif
+};
+
+class _STLP_CLASS_DECLSPEC out_of_range : public logic_error {
+public:
+ out_of_range(const string& __arg) : logic_error(__arg) {}
+# ifndef _STLP_USE_NO_IOSTREAMS
+ ~out_of_range() _STLP_NOTHROW_INHERENTLY;
+# endif
+};
+
+class _STLP_CLASS_DECLSPEC range_error : public runtime_error {
+public:
+ range_error(const string& __arg) : runtime_error(__arg) {}
+# ifndef _STLP_USE_NO_IOSTREAMS
+ ~range_error() _STLP_NOTHROW_INHERENTLY;
+# endif
+};
+
+class _STLP_CLASS_DECLSPEC overflow_error : public runtime_error {
+public:
+ overflow_error(const string& __arg) : runtime_error(__arg) {}
+# ifndef _STLP_USE_NO_IOSTREAMS
+ ~overflow_error() _STLP_NOTHROW_INHERENTLY;
+# endif
+};
+
+class _STLP_CLASS_DECLSPEC underflow_error : public runtime_error {
+public:
+ underflow_error(const string& __arg) : runtime_error(__arg) {}
+# ifndef _STLP_USE_NO_IOSTREAMS
+ ~underflow_error() _STLP_NOTHROW_INHERENTLY;
+# endif
+};
+
+_STLP_END_NAMESPACE
+
+# endif
+#endif
+
+#endif /* _STLP_INTERNAL_STDEXCEPT */
diff --git a/sources/android/stlport/stlport/stl/_stdexcept_base.c b/sources/android/stlport/stlport/stl/_stdexcept_base.c
new file mode 100644
index 0000000..deb7056
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_stdexcept_base.c
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+__Named_exception::__Named_exception(const string& __str) {
+ size_t __size = strlen(_STLP_PRIV __get_c_string(__str)) + 1;
+ if (__size > _S_bufsize) {
+ _M_name = __STATIC_CAST(char*, malloc(__size * sizeof(char)));
+ if (!_M_name) {
+ __size = _S_bufsize;
+ _M_name = _M_static_name;
+ }
+ else {
+ *(__REINTERPRET_CAST(size_t*, &_M_static_name[0])) = __size * sizeof(char);
+ }
+ }
+ else {
+ _M_name = _M_static_name;
+ }
+#if !defined (_STLP_USE_SAFE_STRING_FUNCTIONS)
+ strncpy(_M_name, _STLP_PRIV __get_c_string(__str), __size - 1);
+ _M_name[__size - 1] = '\0';
+#else
+ strncpy_s(_M_name, __size, _STLP_PRIV __get_c_string(__str), __size - 1);
+#endif
+}
+
+__Named_exception::__Named_exception(const __Named_exception& __x) {
+ size_t __size = strlen(__x._M_name) + 1;
+ if (__size > _S_bufsize) {
+ _M_name = __STATIC_CAST(char*, malloc(__size * sizeof(char)));
+ if (!_M_name) {
+ __size = _S_bufsize;
+ _M_name = _M_static_name;
+ }
+ else {
+ *(__REINTERPRET_CAST(size_t*, &_M_static_name[0])) = __size * sizeof(char);
+ }
+ }
+ else {
+ _M_name = _M_static_name;
+ }
+#if !defined (_STLP_USE_SAFE_STRING_FUNCTIONS)
+ strncpy(_M_name, __x._M_name, __size - 1);
+ _M_name[__size - 1] = '\0';
+#else
+ strncpy_s(_M_name, __size, __x._M_name, __size - 1);
+#endif
+}
+
+__Named_exception& __Named_exception::operator = (const __Named_exception& __x) {
+ size_t __size = strlen(__x._M_name) + 1;
+ size_t __buf_size = _M_name != _M_static_name ? *(__REINTERPRET_CAST(size_t*, &_M_static_name[0])) : _S_bufsize;
+ if (__size > __buf_size) {
+ // Being here necessarily mean that we need to allocate a buffer:
+ if (_M_name != _M_static_name) free(_M_name);
+ _M_name = __STATIC_CAST(char*, malloc(__size * sizeof(char)));
+ if (!_M_name) {
+ __size = _S_bufsize;
+ _M_name = _M_static_name;
+ }
+ else {
+ *(__REINTERPRET_CAST(size_t*, &_M_static_name[0])) = __size * sizeof(char);
+ }
+ }
+#if !defined (_STLP_USE_SAFE_STRING_FUNCTIONS)
+ strncpy(_M_name, __x._M_name, __size - 1);
+ _M_name[__size - 1] = '\0';
+#else
+ strncpy_s(_M_name, __size, __x._M_name, __size - 1);
+#endif
+ return *this;
+}
+
+__Named_exception::~__Named_exception() _STLP_NOTHROW_INHERENTLY {
+ if (_M_name != _M_static_name)
+ free(_M_name);
+}
+
+const char* __Named_exception::what() const _STLP_NOTHROW_INHERENTLY
+{ return _M_name; }
diff --git a/sources/android/stlport/stlport/stl/_stdexcept_base.h b/sources/android/stlport/stlport/stl/_stdexcept_base.h
new file mode 100644
index 0000000..69dc077
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_stdexcept_base.h
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_STDEXCEPT_BASE
+#define _STLP_INTERNAL_STDEXCEPT_BASE
+
+#if !defined (_STLP_USE_NATIVE_STDEXCEPT) || defined (_STLP_USE_OWN_NAMESPACE)
+
+# ifndef _STLP_INTERNAL_EXCEPTION
+# include <stl/_exception.h>
+# endif
+
+# if defined(_STLP_USE_EXCEPTIONS) || \
+ !(defined(_MIPS_SIM) && defined(_ABIO32) && (_MIPS_SIM == _ABIO32))
+
+# ifndef _STLP_INTERNAL_CSTRING
+# include <stl/_cstring.h>
+# endif
+
+# ifndef _STLP_STRING_FWD_H
+# include <stl/_string_fwd.h>
+# endif
+
+# ifndef _STLP_USE_NO_IOSTREAMS
+# define _STLP_OWN_STDEXCEPT 1
+# endif
+
+_STLP_BEGIN_NAMESPACE
+
+/* We disable the 4275 warning for
+ * - WinCE where there are only static version of the native C++ runtime.
+ * - The MSVC compilers when the STLport user wants to make an STLport dll linked to
+ * the static C++ native runtime. In this case the std::exception base class is no more
+ * exported from native dll but is used as a base class for the exported __Named_exception
+ * class.
+ */
+# if defined (_STLP_WCE_NET) || \
+ defined (_STLP_USE_DYNAMIC_LIB) && defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB)
+# define _STLP_DO_WARNING_POP
+# pragma warning (push)
+# pragma warning (disable: 4275) // Non dll interface class 'exception' used as base
+ // for dll-interface class '__Named_exception'
+# endif
+
+# if !defined (_STLP_NO_EXCEPTION_HEADER)
+# if !defined (_STLP_EXCEPTION_BASE) && !defined (_STLP_BROKEN_EXCEPTION_CLASS) && \
+ defined (_STLP_USE_NAMESPACES) && defined (_STLP_USE_OWN_NAMESPACE)
+using _STLP_VENDOR_EXCEPT_STD::exception;
+# endif
+# endif
+# define _STLP_EXCEPTION_BASE exception
+
+class _STLP_CLASS_DECLSPEC __Named_exception : public _STLP_EXCEPTION_BASE {
+public:
+ __Named_exception(const string& __str);
+ __Named_exception(const __Named_exception&);
+ __Named_exception& operator = (const __Named_exception&);
+
+ const char* what() const _STLP_NOTHROW_INHERENTLY;
+ ~__Named_exception() _STLP_NOTHROW_INHERENTLY;
+
+private:
+ enum { _S_bufsize = 256 };
+ char _M_static_name[_S_bufsize];
+ char *_M_name;
+};
+
+# if defined (_STLP_USE_NO_IOSTREAMS) && !defined (__BUILDING_STLPORT)
+ // if not linking to the lib, expose implementation of members here
+# include <stl/_stdexcept_base.c>
+# endif
+
+# if defined (_STLP_DO_WARNING_POP)
+# pragma warning (pop)
+# undef _STLP_DO_WARNING_POP
+# endif
+
+_STLP_END_NAMESPACE
+
+# endif /* Not o32, and no exceptions */
+#endif /* _STLP_STDEXCEPT_SEEN */
+
+#endif /* _STLP_INTERNAL_STDEXCEPT_BASE */
diff --git a/sources/android/stlport/stlport/stl/_stlport_version.h b/sources/android/stlport/stlport/stl/_stlport_version.h
new file mode 100644
index 0000000..587651d
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_stlport_version.h
@@ -0,0 +1,30 @@
+ /*
+ *
+ * Copyright (c) 2005
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STLPORT_VERSION_H
+#define _STLP_STLPORT_VERSION_H
+
+/* The last SGI STL release we merged with */
+#define __SGI_STL 0x330
+
+/* STLport version */
+#define _STLPORT_MAJOR 5
+#define _STLPORT_MINOR 2
+#define _STLPORT_PATCHLEVEL 1
+
+#define _STLPORT_VERSION 0x521
+
+#endif /* _STLP_STLPORT_VERSION_H */
diff --git a/sources/android/stlport/stlport/stl/_stream_iterator.h b/sources/android/stlport/stlport/stl/_stream_iterator.h
new file mode 100644
index 0000000..aa26ae3
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_stream_iterator.h
@@ -0,0 +1,253 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996-1998
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#if !defined (_STLP_INTERNAL_STREAM_ITERATOR_H) && !defined (_STLP_USE_NO_IOSTREAMS)
+#define _STLP_INTERNAL_STREAM_ITERATOR_H
+
+#ifndef _STLP_INTERNAL_ITERATOR_BASE_H
+# include <stl/_iterator_base.h>
+#endif
+
+// streambuf_iterators predeclarations must appear first
+#ifndef _STLP_INTERNAL_IOSFWD
+# include <stl/_iosfwd.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+# include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_OSTREAMBUF_ITERATOR_H
+# include <stl/_ostreambuf_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ISTREAMBUF_ITERATOR_H
+# include <stl/_istreambuf_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ISTREAM
+# include <stl/_istream.h>
+#endif
+
+// istream_iterator and ostream_iterator look very different if we're
+// using new, templatized iostreams than if we're using the old cfront
+// version.
+
+_STLP_BEGIN_NAMESPACE
+
+#if !defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+# define __ISI_TMPL_HEADER_ARGUMENTS class _Tp, class _CharT, class _Traits, class _Dist
+# define __ISI_TMPL_ARGUMENTS _Tp, _CharT, _Traits, _Dist
+template <class _Tp,
+ class _CharT = char, class _Traits = char_traits<_CharT>,
+ class _Dist = ptrdiff_t>
+class istream_iterator : public iterator<input_iterator_tag, _Tp , _Dist,
+ const _Tp*, const _Tp& > {
+#else
+# if defined (_STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS) && !defined (_STLP_DEFAULT_TYPE_PARAM)
+# define __ISI_TMPL_HEADER_ARGUMENTS class _Tp
+# define __ISI_TMPL_ARGUMENTS _Tp
+template <class _Tp>
+class istream_iterator : public iterator<input_iterator_tag, _Tp , ptrdiff_t,
+ const _Tp*, const _Tp& > {
+# else
+# define __ISI_TMPL_HEADER_ARGUMENTS class _Tp, class _Dist
+# define __ISI_TMPL_ARGUMENTS _Tp, _Dist
+template <class _Tp, _STLP_DFL_TYPE_PARAM(_Dist, ptrdiff_t)>
+class istream_iterator : public iterator<input_iterator_tag, _Tp, _Dist ,
+ const _Tp*, const _Tp& > {
+# endif /* _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS */
+#endif /* _STLP_LIMITED_DEFAULT_TEMPLATES */
+
+#if defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+ typedef char _CharT;
+ typedef char_traits<char> _Traits;
+# if defined (_STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS) && !defined (_STLP_DEFAULT_TYPE_PARAM)
+ typedef ptrdiff_t _Dist;
+# endif
+#endif
+
+ typedef istream_iterator< __ISI_TMPL_ARGUMENTS > _Self;
+public:
+ typedef _CharT char_type;
+ typedef _Traits traits_type;
+ typedef basic_istream<_CharT, _Traits> istream_type;
+
+ typedef input_iterator_tag iterator_category;
+ typedef _Tp value_type;
+ typedef _Dist difference_type;
+ typedef const _Tp* pointer;
+ typedef const _Tp& reference;
+
+ istream_iterator() : _M_stream(0), _M_ok(false), _M_read_done(true) {}
+ istream_iterator(istream_type& __s) : _M_stream(&__s), _M_ok(false), _M_read_done(false) {}
+
+ reference operator*() const {
+ if (!_M_read_done) {
+ _M_read();
+ }
+ return _M_value;
+ }
+
+ _STLP_DEFINE_ARROW_OPERATOR
+
+ _Self& operator++() {
+ _M_read();
+ return *this;
+ }
+ _Self operator++(int) {
+ _Self __tmp = *this;
+ _M_read();
+ return __tmp;
+ }
+
+ bool _M_equal(const _Self& __x) const {
+ if (!_M_read_done) {
+ _M_read();
+ }
+ if (!__x._M_read_done) {
+ __x._M_read();
+ }
+ return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream);
+ }
+
+private:
+ istream_type* _M_stream;
+ mutable _Tp _M_value;
+ mutable bool _M_ok;
+ mutable bool _M_read_done;
+
+ void _M_read() const {
+ _STLP_MUTABLE(_Self, _M_ok) = ((_M_stream != 0) && !_M_stream->fail());
+ if (_M_ok) {
+ *_M_stream >> _STLP_MUTABLE(_Self, _M_value);
+ _STLP_MUTABLE(_Self, _M_ok) = !_M_stream->fail();
+ }
+ _STLP_MUTABLE(_Self, _M_read_done) = true;
+ }
+};
+
+#if !defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+template <class _TpP,
+ class _CharT = char, class _Traits = char_traits<_CharT> >
+#else
+template <class _TpP>
+#endif
+class ostream_iterator: public iterator<output_iterator_tag, void, void, void, void> {
+#if defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+ typedef char _CharT;
+ typedef char_traits<char> _Traits;
+ typedef ostream_iterator<_TpP> _Self;
+#else
+ typedef ostream_iterator<_TpP, _CharT, _Traits> _Self;
+#endif
+public:
+ typedef _CharT char_type;
+ typedef _Traits traits_type;
+ typedef basic_ostream<_CharT, _Traits> ostream_type;
+
+ typedef output_iterator_tag iterator_category;
+
+ ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {}
+ ostream_iterator(ostream_type& __s, const _CharT* __c)
+ : _M_stream(&__s), _M_string(__c) {}
+ _Self& operator=(const _TpP& __val) {
+ *_M_stream << __val;
+ if (_M_string) *_M_stream << _M_string;
+ return *this;
+ }
+ _Self& operator*() { return *this; }
+ _Self& operator++() { return *this; }
+ _Self& operator++(int) { return *this; }
+private:
+ ostream_type* _M_stream;
+ const _CharT* _M_string;
+};
+
+#if defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
+# if defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+template <class _TpP>
+inline output_iterator_tag _STLP_CALL
+iterator_category(const ostream_iterator<_TpP>&) { return output_iterator_tag(); }
+# else
+template <class _TpP, class _CharT, class _Traits>
+inline output_iterator_tag _STLP_CALL
+iterator_category(const ostream_iterator<_TpP, _CharT, _Traits>&) { return output_iterator_tag(); }
+# endif
+#endif
+
+_STLP_END_NAMESPACE
+
+// form-independent definiotion of stream iterators
+_STLP_BEGIN_NAMESPACE
+
+template < __ISI_TMPL_HEADER_ARGUMENTS >
+inline bool _STLP_CALL
+operator==(const istream_iterator< __ISI_TMPL_ARGUMENTS >& __x,
+ const istream_iterator< __ISI_TMPL_ARGUMENTS >& __y)
+{ return __x._M_equal(__y); }
+
+#if defined (_STLP_USE_SEPARATE_RELOPS_NAMESPACE)
+template < __ISI_TMPL_HEADER_ARGUMENTS >
+inline bool _STLP_CALL
+operator!=(const istream_iterator< __ISI_TMPL_ARGUMENTS >& __x,
+ const istream_iterator< __ISI_TMPL_ARGUMENTS >& __y)
+{ return !__x._M_equal(__y); }
+#endif
+
+#if defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
+template < __ISI_TMPL_HEADER_ARGUMENTS >
+inline input_iterator_tag _STLP_CALL
+iterator_category(const istream_iterator< __ISI_TMPL_ARGUMENTS >&)
+{ return input_iterator_tag(); }
+template < __ISI_TMPL_HEADER_ARGUMENTS >
+inline _Tp* _STLP_CALL
+value_type(const istream_iterator< __ISI_TMPL_ARGUMENTS >&) { return (_Tp*) 0; }
+
+# if defined (_STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS) && !defined (_STLP_DEFAULT_TYPE_PARAM)
+template < __ISI_TMPL_HEADER_ARGUMENTS >
+inline ptrdiff_t* _STLP_CALL
+distance_type(const istream_iterator< __ISI_TMPL_ARGUMENTS >&) { return (ptrdiff_t*)0; }
+# else
+template < __ISI_TMPL_HEADER_ARGUMENTS >
+inline _Dist* _STLP_CALL
+distance_type(const istream_iterator< __ISI_TMPL_ARGUMENTS >&) { return (_Dist*)0; }
+# endif /* _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS */
+#endif
+
+_STLP_END_NAMESPACE
+
+#undef __ISI_TMPL_HEADER_ARGUMENTS
+#undef __ISI_TMPL_ARGUMENTS
+
+#endif /* _STLP_INTERNAL_STREAM_ITERATOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_streambuf.c b/sources/android/stlport/stlport/stl/_streambuf.c
new file mode 100644
index 0000000..bd61a20
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_streambuf.c
@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_STREAMBUF_C
+#define _STLP_STREAMBUF_C
+
+#ifndef _STLP_INTERNAL_STREAMBUF
+# include <stl/_streambuf.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+//----------------------------------------------------------------------
+// Non-inline basic_streambuf<> member functions.
+
+#if !defined (_STLP_MSVC) || (_STLP_MSVC >= 1300) || !defined (_STLP_USE_STATIC_LIB)
+template <class _CharT, class _Traits>
+basic_streambuf<_CharT, _Traits>::basic_streambuf()
+ : _M_gbegin(0), _M_gnext(0), _M_gend(0),
+ _M_pbegin(0), _M_pnext(0), _M_pend(0),
+ _M_locale() {
+ // _M_lock._M_initialize();
+}
+#endif
+
+template <class _CharT, class _Traits>
+basic_streambuf<_CharT, _Traits>::~basic_streambuf()
+{}
+
+template <class _CharT, class _Traits>
+locale
+basic_streambuf<_CharT, _Traits>::pubimbue(const locale& __loc) {
+ this->imbue(__loc);
+ locale __tmp = _M_locale;
+ _M_locale = __loc;
+ return __tmp;
+}
+
+template <class _CharT, class _Traits>
+streamsize
+basic_streambuf<_CharT, _Traits>::xsgetn(_CharT* __s, streamsize __n) {
+ streamsize __result = 0;
+ const int_type __eof = _Traits::eof();
+
+ while (__result < __n) {
+ if (_M_gnext < _M_gend) {
+ size_t __chunk = (min) (__STATIC_CAST(size_t,_M_gend - _M_gnext),
+ __STATIC_CAST(size_t,__n - __result));
+ _Traits::copy(__s, _M_gnext, __chunk);
+ __result += __chunk;
+ __s += __chunk;
+ _M_gnext += __chunk;
+ }
+ else {
+ int_type __c = this->sbumpc();
+ if (!_Traits::eq_int_type(__c, __eof)) {
+ *__s = _Traits::to_char_type(__c);
+ ++__result;
+ ++__s;
+ }
+ else
+ break;
+ }
+ }
+
+ return __result;
+}
+
+template <class _CharT, class _Traits>
+streamsize
+basic_streambuf<_CharT, _Traits>::xsputn(const _CharT* __s, streamsize __n)
+{
+ streamsize __result = 0;
+ const int_type __eof = _Traits::eof();
+
+ while (__result < __n) {
+ if (_M_pnext < _M_pend) {
+ size_t __chunk = (min) (__STATIC_CAST(size_t,_M_pend - _M_pnext),
+ __STATIC_CAST(size_t,__n - __result));
+ _Traits::copy(_M_pnext, __s, __chunk);
+ __result += __chunk;
+ __s += __chunk;
+ _M_pnext += __chunk;
+ }
+
+ else if (!_Traits::eq_int_type(this->overflow(_Traits::to_int_type(*__s)),
+ __eof)) {
+ ++__result;
+ ++__s;
+ }
+ else
+ break;
+ }
+ return __result;
+}
+
+template <class _CharT, class _Traits>
+streamsize
+basic_streambuf<_CharT, _Traits>::_M_xsputnc(_CharT __c, streamsize __n)
+{
+ streamsize __result = 0;
+ const int_type __eof = _Traits::eof();
+
+ while (__result < __n) {
+ if (_M_pnext < _M_pend) {
+ size_t __chunk = (min) (__STATIC_CAST(size_t,_M_pend - _M_pnext),
+ __STATIC_CAST(size_t,__n - __result));
+ _Traits::assign(_M_pnext, __chunk, __c);
+ __result += __chunk;
+ _M_pnext += __chunk;
+ }
+
+ else if (!_Traits::eq_int_type(this->overflow(_Traits::to_int_type(__c)),
+ __eof))
+ ++__result;
+ else
+ break;
+ }
+ return __result;
+}
+
+template <class _CharT, class _Traits>
+_STLP_TYPENAME_ON_RETURN_TYPE basic_streambuf<_CharT, _Traits>::int_type
+basic_streambuf<_CharT, _Traits>::_M_snextc_aux()
+{
+ int_type __eof = _Traits::eof();
+ if (_M_gend == _M_gnext)
+ return _Traits::eq_int_type(this->uflow(), __eof) ? __eof : this->sgetc();
+ else {
+ _M_gnext = _M_gend;
+ return this->underflow();
+ }
+}
+
+template <class _CharT, class _Traits>
+_STLP_TYPENAME_ON_RETURN_TYPE basic_streambuf<_CharT, _Traits>::int_type
+basic_streambuf<_CharT, _Traits>::pbackfail(int_type) {
+ return _Traits::eof();
+}
+
+template <class _CharT, class _Traits>
+_STLP_TYPENAME_ON_RETURN_TYPE basic_streambuf<_CharT, _Traits>::int_type
+basic_streambuf<_CharT, _Traits>::overflow(int_type) {
+ return _Traits::eof();
+}
+
+template <class _CharT, class _Traits>
+_STLP_TYPENAME_ON_RETURN_TYPE basic_streambuf<_CharT, _Traits>::int_type
+basic_streambuf<_CharT, _Traits>::uflow() {
+ return ( _Traits::eq_int_type(this->underflow(),_Traits::eof()) ?
+ _Traits::eof() :
+ _Traits::to_int_type(*_M_gnext++));
+}
+
+template <class _CharT, class _Traits>
+_STLP_TYPENAME_ON_RETURN_TYPE basic_streambuf<_CharT, _Traits>::int_type
+basic_streambuf<_CharT, _Traits>::underflow()
+{ return _Traits::eof(); }
+
+template <class _CharT, class _Traits>
+streamsize
+basic_streambuf<_CharT, _Traits>::showmanyc()
+{ return 0; }
+
+template <class _CharT, class _Traits>
+void
+basic_streambuf<_CharT, _Traits>::imbue(const locale&) {}
+
+template <class _CharT, class _Traits>
+int
+basic_streambuf<_CharT, _Traits>::sync() { return 0; }
+
+template <class _CharT, class _Traits>
+_STLP_TYPENAME_ON_RETURN_TYPE basic_streambuf<_CharT, _Traits>::pos_type
+basic_streambuf<_CharT, _Traits>::seekpos(pos_type, ios_base::openmode)
+{ return pos_type(-1); }
+
+template <class _CharT, class _Traits>
+_STLP_TYPENAME_ON_RETURN_TYPE basic_streambuf<_CharT, _Traits>::pos_type
+basic_streambuf<_CharT, _Traits>::seekoff(off_type, ios_base::seekdir,
+ ios_base::openmode)
+{ return pos_type(-1); }
+
+template <class _CharT, class _Traits>
+basic_streambuf<_CharT, _Traits>*
+basic_streambuf<_CharT, _Traits>:: setbuf(char_type*, streamsize)
+{ return this; }
+
+_STLP_END_NAMESPACE
+
+#endif
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_streambuf.h b/sources/android/stlport/stlport/stl/_streambuf.h
new file mode 100644
index 0000000..e336b0f
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_streambuf.h
@@ -0,0 +1,287 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_INTERNAL_STREAMBUF
+#define _STLP_INTERNAL_STREAMBUF
+
+#ifndef _STLP_IOS_BASE_H
+# include <stl/_ios_base.h> // Needed for ios_base bitfield members.
+#endif // <ios_base> includes <iosfwd>.
+
+_STLP_BEGIN_NAMESPACE
+
+//----------------------------------------------------------------------
+// Class basic_streambuf<>, the base class of the streambuf hierarchy.
+
+// A basic_streambuf<> manages an input (get) area and an output (put)
+// area. Each is described by three pointers: a beginning, an end, and a
+// current position. basic_streambuf<> contains some very simple member
+// functions that manipulate those six pointers, but almost all of the real
+// functionality gets delegated to protected virtual member functions.
+// All of the public member functions are inline, and most of the protected
+// member functions are virtual.
+
+// Although basic_streambuf<> is not abstract, it is useful only as a base
+// class. Its virtual member functions have default definitions such that
+// reading from a basic_streambuf<> will always yield EOF, and writing to a
+// basic_streambuf<> will always fail.
+
+// The second template parameter, _Traits, defaults to char_traits<_CharT>.
+// The default is declared in header <iosfwd>, and it isn't declared here
+// because C++ language rules do not allow it to be declared twice.
+
+template <class _CharT, class _Traits>
+class basic_streambuf {
+ friend class basic_istream<_CharT, _Traits>;
+ friend class basic_ostream<_CharT, _Traits>;
+
+public: // Typedefs.
+ typedef _CharT char_type;
+ typedef typename _Traits::int_type int_type;
+ typedef typename _Traits::pos_type pos_type;
+ typedef typename _Traits::off_type off_type;
+ typedef _Traits traits_type;
+
+private: // Data members.
+
+ char_type* _M_gbegin; // Beginning of get area
+ char_type* _M_gnext; // Current position within the get area
+ char_type* _M_gend; // End of get area
+
+ char_type* _M_pbegin; // Beginning of put area
+ char_type* _M_pnext; // Current position within the put area
+ char_type* _M_pend; // End of put area
+
+ locale _M_locale; // The streambuf's locale object
+
+public: // Destructor.
+ virtual ~basic_streambuf();
+
+protected: // The default constructor.
+ basic_streambuf()
+#if defined (_STLP_MSVC) && (_STLP_MSVC < 1300) && defined (_STLP_USE_STATIC_LIB)
+ //We make it inline to avoid unresolved symbol.
+ : _M_gbegin(0), _M_gnext(0), _M_gend(0),
+ _M_pbegin(0), _M_pnext(0), _M_pend(0),
+ _M_locale()
+ {}
+#else
+ ;
+#endif
+
+protected: // Protected interface to the get area.
+ char_type* eback() const { return _M_gbegin; } // Beginning
+ char_type* gptr() const { return _M_gnext; } // Current position
+ char_type* egptr() const { return _M_gend; } // End
+
+ void gbump(int __n) { _M_gnext += __n; }
+ void setg(char_type* __gbegin, char_type* __gnext, char_type* __gend) {
+ _M_gbegin = __gbegin;
+ _M_gnext = __gnext;
+ _M_gend = __gend;
+ }
+
+public:
+ // An alternate public interface to the above functions
+ // which allows us to avoid using templated friends which
+ // are not supported on some compilers.
+ char_type* _M_eback() const { return eback(); }
+ char_type* _M_gptr() const { return gptr(); }
+ char_type* _M_egptr() const { return egptr(); }
+ void _M_gbump(int __n) { gbump(__n); }
+ void _M_setg(char_type* __gbegin, char_type* __gnext, char_type* __gend)
+ { this->setg(__gbegin, __gnext, __gend); }
+
+protected: // Protected interface to the put area
+
+ char_type* pbase() const { return _M_pbegin; } // Beginning
+ char_type* pptr() const { return _M_pnext; } // Current position
+ char_type* epptr() const { return _M_pend; } // End
+
+ void pbump(int __n) { _M_pnext += __n; }
+ void setp(char_type* __pbegin, char_type* __pend) {
+ _M_pbegin = __pbegin;
+ _M_pnext = __pbegin;
+ _M_pend = __pend;
+ }
+
+protected: // Virtual buffer management functions.
+
+ virtual basic_streambuf<_CharT, _Traits>* setbuf(char_type*, streamsize);
+
+ // Alters the stream position, using an integer offset. In this
+ // class seekoff does nothing; subclasses are expected to override it.
+ virtual pos_type seekoff(off_type, ios_base::seekdir,
+ ios_base::openmode = ios_base::in | ios_base::out);
+
+ // Alters the stream position, using a previously obtained streampos. In
+ // this class seekpos does nothing; subclasses are expected to override it.
+ virtual pos_type
+ seekpos(pos_type, ios_base::openmode = ios_base::in | ios_base::out);
+
+ // Synchronizes (i.e. flushes) the buffer. All subclasses are expected to
+ // override this virtual member function.
+ virtual int sync();
+
+
+public: // Buffer management.
+ basic_streambuf<_CharT, _Traits>* pubsetbuf(char_type* __s, streamsize __n)
+ { return this->setbuf(__s, __n); }
+
+ pos_type pubseekoff(off_type __offset, ios_base::seekdir __way,
+ ios_base::openmode __mod = ios_base::in | ios_base::out)
+ { return this->seekoff(__offset, __way, __mod); }
+
+ pos_type pubseekpos(pos_type __sp,
+ ios_base::openmode __mod = ios_base::in | ios_base::out)
+ { return this->seekpos(__sp, __mod); }
+
+ int pubsync() { return this->sync(); }
+
+protected: // Virtual get area functions, as defined in
+ // 17.5.2.4.3 and 17.5.2.4.4 of the standard.
+ // Returns a lower bound on the number of characters that we can read,
+ // with underflow, before reaching end of file. (-1 is a special value:
+ // it means that underflow will fail.) Most subclasses should probably
+ // override this virtual member function.
+ virtual streamsize showmanyc();
+
+ // Reads up to __n characters. Return value is the number of
+ // characters read.
+ virtual streamsize xsgetn(char_type* __s, streamsize __n);
+
+ // Called when there is no read position, i.e. when gptr() is null
+ // or when gptr() >= egptr(). Subclasses are expected to override
+ // this virtual member function.
+ virtual int_type underflow();
+
+ // Similar to underflow(), but used for unbuffered input. Most
+ // subclasses should probably override this virtual member function.
+ virtual int_type uflow();
+
+ // Called when there is no putback position, i.e. when gptr() is null
+ // or when gptr() == eback(). All subclasses are expected to override
+ // this virtual member function.
+ virtual int_type pbackfail(int_type = traits_type::eof());
+
+protected: // Virtual put area functions, as defined in
+ // 27.5.2.4.5 of the standard.
+
+ // Writes up to __n characters. Return value is the number of characters
+ // written.
+ virtual streamsize xsputn(const char_type* __s, streamsize __n);
+
+ // Extension: writes up to __n copies of __c. Return value is the number
+ // of characters written.
+ virtual streamsize _M_xsputnc(char_type __c, streamsize __n);
+
+ // Called when there is no write position. All subclasses are expected to
+ // override this virtual member function.
+ virtual int_type overflow(int_type = traits_type::eof());
+
+public: // Public members for writing characters.
+ // Write a single character.
+ int_type sputc(char_type __c) {
+ return ((_M_pnext < _M_pend) ? _Traits::to_int_type(*_M_pnext++ = __c)
+ : this->overflow(_Traits::to_int_type(__c)));
+ }
+
+ // Write __n characters.
+ streamsize sputn(const char_type* __s, streamsize __n)
+ { return this->xsputn(__s, __n); }
+
+ // Extension: write __n copies of __c.
+ streamsize _M_sputnc(char_type __c, streamsize __n)
+ { return this->_M_xsputnc(__c, __n); }
+
+private: // Helper functions.
+ int_type _M_snextc_aux();
+
+public: // Public members for reading characters.
+ streamsize in_avail() {
+ return (_M_gnext < _M_gend) ? (_M_gend - _M_gnext) : this->showmanyc();
+ }
+
+ // Advance to the next character and return it.
+ int_type snextc() {
+ return ( _M_gend - _M_gnext > 1 ?
+ _Traits::to_int_type(*++_M_gnext) :
+ this->_M_snextc_aux());
+ }
+
+ // Return the current character and advance to the next.
+ int_type sbumpc() {
+ return _M_gnext < _M_gend ? _Traits::to_int_type(*_M_gnext++)
+ : this->uflow();
+ }
+
+ // Return the current character without advancing to the next.
+ int_type sgetc() {
+ return _M_gnext < _M_gend ? _Traits::to_int_type(*_M_gnext)
+ : this->underflow();
+ }
+
+ streamsize sgetn(char_type* __s, streamsize __n)
+ { return this->xsgetn(__s, __n); }
+
+ int_type sputbackc(char_type __c) {
+ return ((_M_gbegin < _M_gnext) && _Traits::eq(__c, *(_M_gnext - 1)))
+ ? _Traits::to_int_type(*--_M_gnext)
+ : this->pbackfail(_Traits::to_int_type(__c));
+ }
+
+ int_type sungetc() {
+ return (_M_gbegin < _M_gnext)
+ ? _Traits::to_int_type(*--_M_gnext)
+ : this->pbackfail();
+ }
+
+protected: // Virtual locale functions.
+
+ // This is a hook, called by pubimbue() just before pubimbue()
+ // sets the streambuf's locale to __loc. Note that imbue should
+ // not (and cannot, since it has no access to streambuf's private
+ // members) set the streambuf's locale itself.
+ virtual void imbue(const locale&);
+
+public: // Locale-related functions.
+ locale pubimbue(const locale&);
+ locale getloc() const { return _M_locale; }
+
+#if !defined (_STLP_NO_ANACHRONISMS)
+ void stossc() { this->sbumpc(); }
+#endif
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS basic_streambuf<char, char_traits<char> >;
+# if !defined (_STLP_NO_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS basic_streambuf<wchar_t, char_traits<wchar_t> >;
+# endif // _STLP_NO_WCHAR_T
+#endif // _STLP_USE_TEMPLATE_EXPORT
+
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_streambuf.c>
+#endif
+
+#endif
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_string.c b/sources/android/stlport/stlport/stl/_string.c
new file mode 100644
index 0000000..4fa5ece
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_string.c
@@ -0,0 +1,673 @@
+/*
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+#ifndef _STLP_STRING_C
+#define _STLP_STRING_C
+
+#ifndef _STLP_INTERNAL_STRING_H
+# include <stl/_string.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CTRAITS_FUNCTIONS_H
+# include <stl/_ctraits_fns.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_H
+# include <stl/_function.h>
+#endif
+
+#if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+# define basic_string _STLP_NO_MEM_T_NAME(str)
+#elif defined (_STLP_DEBUG)
+# define basic_string _STLP_NON_DBG_NAME(str)
+#endif
+
+#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+# define __size_type__ size_t
+# define size_type size_t
+# define iterator _CharT*
+#else
+# define __size_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_string<_CharT,_Traits,_Alloc>::size_type
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// A helper class to use a char_traits as a function object.
+template <class _Traits>
+struct _Not_within_traits : public unary_function<typename _Traits::char_type, bool> {
+ typedef typename _Traits::char_type _CharT;
+ const _CharT* _M_first;
+ const _CharT* _M_last;
+
+ _Not_within_traits(const _CharT* __f, const _CharT* __l)
+ : _M_first(__f), _M_last(__l) {}
+
+ bool operator()(const _CharT& __x) const {
+ return find_if(_M_first, _M_last,
+ _STLP_PRIV _Eq_char_bound<_Traits>(__x)) == _M_last;
+ }
+};
+
+template <class _InputIter, class _CharT, class _Traits>
+inline _InputIter __str_find_first_of_aux(_InputIter __first1, _InputIter __last1,
+ const _CharT* __first2, const _CharT* __last2,
+ _Traits*, const __true_type& /* _STLportTraits */)
+{ return __find_first_of(__first1, __last1, __first2, __last2); }
+
+template <class _InputIter, class _CharT, class _Traits>
+inline _InputIter __str_find_first_of_aux(_InputIter __first1, _InputIter __last1,
+ const _CharT* __first2, const _CharT* __last2,
+ _Traits*, const __false_type& /* _STLportTraits */)
+{ return __find_first_of(__first1, __last1, __first2, __last2, _STLP_PRIV _Eq_traits<_Traits>()); }
+
+template <class _InputIter, class _CharT, class _Traits>
+inline _InputIter __str_find_first_of(_InputIter __first1, _InputIter __last1,
+ const _CharT* __first2, const _CharT* __last2,
+ _Traits* __traits) {
+#if !defined (__BORLANDC__)
+ typedef typename _IsSTLportClass<_Traits>::_Ret _STLportTraits;
+#else
+ enum { _Is = _IsSTLportClass<_Traits>::_Is };
+ typedef typename __bool2type<_Is>::_Ret _STLportTraits;
+#endif
+ return __str_find_first_of_aux(__first1, __last1, __first2, __last2, __traits, _STLportTraits());
+}
+
+template <class _InputIter, class _CharT, class _Traits>
+inline _InputIter __str_find_first_not_of_aux3(_InputIter __first1, _InputIter __last1,
+ const _CharT* __first2, const _CharT* __last2,
+ _Traits* /* __traits */, const __true_type& __useStrcspnLikeAlgo)
+{ return __find_first_of_aux2(__first1, __last1, __first2, __last2, __first2, not1(_Identity<bool>()), __useStrcspnLikeAlgo); }
+
+template <class _InputIter, class _CharT, class _Traits>
+inline _InputIter __str_find_first_not_of_aux3(_InputIter __first1, _InputIter __last1,
+ const _CharT* __first2, const _CharT* __last2,
+ _Traits* /* __traits */, const __false_type& /* _UseStrcspnLikeAlgo */)
+{ return _STLP_STD::find_if(__first1, __last1, _STLP_PRIV _Not_within_traits<_Traits>(__first2, __last2)); }
+
+template <class _InputIter, class _CharT, class _Tp, class _Traits>
+inline _InputIter __str_find_first_not_of_aux2(_InputIter __first1, _InputIter __last1,
+ const _CharT* __first2, const _CharT* __last2,
+ _Tp* __pt, _Traits* __traits) {
+ typedef typename _IsIntegral<_Tp>::_Ret _IsIntegral;
+ typedef typename _IsCharLikeType<_CharT>::_Ret _IsCharLike;
+ typedef typename _Land2<_IsIntegral, _IsCharLike>::_Ret _UseStrcspnLikeAlgo;
+ return __str_find_first_not_of_aux3(__first1, __last1, __first2, __last2, __traits, _UseStrcspnLikeAlgo());
+}
+
+template <class _InputIter, class _CharT, class _Traits>
+inline _InputIter __str_find_first_not_of_aux1(_InputIter __first1, _InputIter __last1,
+ const _CharT* __first2, const _CharT* __last2,
+ _Traits* __traits, const __true_type& /* _STLportTraits */)
+{ return __str_find_first_not_of_aux2(__first1, __last1, __first2, __last2,
+ _STLP_VALUE_TYPE(__first1, _InputIter), __traits); }
+
+template <class _InputIter, class _CharT, class _Traits>
+inline _InputIter __str_find_first_not_of_aux1(_InputIter __first1, _InputIter __last1,
+ const _CharT* __first2, const _CharT* __last2,
+ _Traits*, const __false_type& /* _STLportTraits */)
+{ return _STLP_STD::find_if(__first1, __last1, _STLP_PRIV _Not_within_traits<_Traits>(__first2, __last2)); }
+
+template <class _InputIter, class _CharT, class _Traits>
+inline _InputIter __str_find_first_not_of(_InputIter __first1, _InputIter __last1,
+ const _CharT* __first2, const _CharT* __last2,
+ _Traits* __traits) {
+#if !defined (__BORLANDC__)
+ typedef typename _IsSTLportClass<_Traits>::_Ret _STLportTraits;
+#else
+ enum { _Is = _IsSTLportClass<_Traits>::_Is };
+ typedef typename __bool2type<_Is>::_Ret _STLportTraits;
+#endif
+ return __str_find_first_not_of_aux1(__first1, __last1, __first2, __last2, __traits, _STLportTraits());
+}
+
+// ------------------------------------------------------------
+// Non-inline declarations.
+
+#if !defined (basic_string)
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+// Change the string's capacity so that it is large enough to hold
+// at least __res_arg elements, plus the terminating _CharT(). Note that,
+// if __res_arg < capacity(), this member function may actually decrease
+// the string's capacity.
+template <class _CharT, class _Traits, class _Alloc>
+void basic_string<_CharT,_Traits,_Alloc>::reserve(size_type __res_arg) {
+ if (__res_arg > max_size())
+ this->_M_throw_length_error();
+
+ size_type __n = (max)(__res_arg, size()) + 1;
+ if (__n < this->_M_capacity())
+ return;
+
+ _M_reserve(__n);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+void basic_string<_CharT,_Traits,_Alloc>::_M_reserve(size_type __n) {
+ pointer __new_start = this->_M_start_of_storage.allocate(__n, __n);
+ pointer __new_finish = _STLP_PRIV __ucopy(this->_M_Start(), this->_M_Finish(), __new_start);
+ _M_construct_null(__new_finish);
+ this->_M_deallocate_block();
+ this->_M_reset(__new_start, __new_finish, __new_start + __n);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT,_Traits,_Alloc>&
+basic_string<_CharT,_Traits,_Alloc>::append(size_type __n, _CharT __c) {
+ if (__n > 0) {
+ if (__n > max_size() - size())
+ this->_M_throw_length_error();
+ if (__n >= this->_M_rest())
+ _M_reserve(_M_compute_next_size(__n));
+ _STLP_PRIV __uninitialized_fill_n(this->_M_finish + 1, __n - 1, __c);
+ _M_construct_null(this->_M_finish + __n);
+ _Traits::assign(*end(), __c);
+ this->_M_finish += __n;
+ }
+ return *this;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT, _Traits, _Alloc>&
+basic_string<_CharT, _Traits, _Alloc>::_M_append(const _CharT* __first, const _CharT* __last) {
+ if (__first != __last) {
+ size_type __n = __STATIC_CAST(size_type, __last - __first);
+ if (__n >= this->_M_rest()) {
+ size_type __len = _M_compute_next_size(__n);
+ pointer __new_start = this->_M_start_of_storage.allocate(__len, __len);
+ pointer __new_finish = _STLP_PRIV __ucopy(this->_M_Start(), this->_M_Finish(), __new_start);
+ __new_finish = _STLP_PRIV __ucopy(__first, __last, __new_finish);
+ _M_construct_null(__new_finish);
+ this->_M_deallocate_block();
+ this->_M_reset(__new_start, __new_finish, __new_start + __len);
+ }
+ else {
+ const _CharT* __f1 = __first;
+ ++__f1;
+ _STLP_PRIV __ucopy(__f1, __last, this->_M_finish + 1);
+ _M_construct_null(this->_M_finish + __n);
+ _Traits::assign(*end(), *__first);
+ this->_M_finish += __n;
+ }
+ }
+ return *this;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT,_Traits,_Alloc>&
+basic_string<_CharT,_Traits,_Alloc>::assign(size_type __n, _CharT __c) {
+ if (__n <= size()) {
+ _Traits::assign(this->_M_Start(), __n, __c);
+ erase(begin() + __n, end());
+ }
+ else {
+ if (__n < capacity()) {
+ _Traits::assign(this->_M_Start(), size(), __c);
+ append(__n - size(), __c);
+ }
+ else {
+ _Self __str(__n, __c);
+ this->swap(__str);
+ }
+ }
+ return *this;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT,_Traits,_Alloc>&
+basic_string<_CharT,_Traits,_Alloc>::_M_assign(const _CharT* __f, const _CharT* __l) {
+ ptrdiff_t __n = __l - __f;
+ if (__STATIC_CAST(size_type, __n) <= size()) {
+ _Traits::copy(this->_M_Start(), __f, __n);
+ erase(begin() + __n, end());
+ }
+ else {
+ _Traits::copy(this->_M_Start(), __f, size());
+ _M_append(__f + size(), __l);
+ }
+ return *this;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+_CharT* basic_string<_CharT,_Traits,_Alloc> ::_M_insert_aux(_CharT* __p,
+ _CharT __c) {
+ pointer __new_pos = __p;
+ if (this->_M_rest() > 1 ) {
+ _M_construct_null(this->_M_finish + 1);
+ _Traits::move(__p + 1, __p, this->_M_finish - __p);
+ _Traits::assign(*__p, __c);
+ ++this->_M_finish;
+ }
+ else {
+ size_type __len = _M_compute_next_size(1);
+ pointer __new_start = this->_M_start_of_storage.allocate(__len, __len);
+ __new_pos = _STLP_PRIV __ucopy(this->_M_Start(), __p, __new_start);
+ _Traits::assign(*__new_pos, __c);
+ pointer __new_finish = __new_pos + 1;
+ __new_finish = _STLP_PRIV __ucopy(__p, this->_M_finish, __new_finish);
+ _M_construct_null(__new_finish);
+ this->_M_deallocate_block();
+ this->_M_reset(__new_start, __new_finish, __new_start + __len);
+ }
+ return __new_pos;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+void basic_string<_CharT,_Traits,_Alloc>::insert(iterator __pos,
+ size_t __n, _CharT __c) {
+ if (__n != 0) {
+ if (this->_M_rest() > __n) {
+ const size_type __elems_after = this->_M_finish - __pos;
+ pointer __old_finish = this->_M_finish;
+ if (__elems_after >= __n) {
+ _STLP_PRIV __ucopy((this->_M_finish - __n) + 1, this->_M_finish + 1, this->_M_finish + 1);
+ this->_M_finish += __n;
+ _Traits::move(__pos + __n, __pos, (__elems_after - __n) + 1);
+ _Traits::assign(__pos, __n, __c);
+ }
+ else {
+ _STLP_PRIV __uninitialized_fill_n(this->_M_finish + 1, __n - __elems_after - 1, __c);
+ this->_M_finish += __n - __elems_after;
+ _STLP_PRIV __ucopy(__pos, __old_finish + 1, this->_M_finish);
+ this->_M_finish += __elems_after;
+ _Traits::assign(__pos, __elems_after + 1, __c);
+ }
+ }
+ else {
+ size_type __len = _M_compute_next_size(__n);
+ pointer __new_start = this->_M_start_of_storage.allocate(__len, __len);
+ pointer __new_finish = _STLP_PRIV __ucopy(this->_M_Start(), __pos, __new_start);
+ __new_finish = _STLP_PRIV __uninitialized_fill_n(__new_finish, __n, __c);
+ __new_finish = _STLP_PRIV __ucopy(__pos, this->_M_finish, __new_finish);
+ _M_construct_null(__new_finish);
+ this->_M_deallocate_block();
+ this->_M_reset(__new_start, __new_finish, __new_start + __len);
+ }
+ }
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+void basic_string<_CharT,_Traits,_Alloc>::_M_insert(iterator __pos,
+ const _CharT* __first, const _CharT* __last,
+ bool __self_ref) {
+ //this version has to take care about the auto referencing
+ if (__first != __last) {
+ const size_t __n = __last - __first;
+ if (this->_M_rest() > __n) {
+ const size_t __elems_after = this->_M_finish - __pos;
+ pointer __old_finish = this->_M_finish;
+ if (__elems_after >= __n) {
+ _STLP_PRIV __ucopy((this->_M_finish - __n) + 1, this->_M_finish + 1, this->_M_finish + 1);
+ this->_M_finish += __n;
+ _Traits::move(__pos + __n, __pos, (__elems_after - __n) + 1);
+ if (!__self_ref || __last < __pos) {
+ _M_copy(__first, __last, __pos);
+ }
+ else {
+ //We have to check that the source buffer hasn't move
+ if (__first >= __pos) {
+ //The source buffer has move
+ __first += __n;
+ __last += __n;
+ _M_copy(__first, __last, __pos);
+ }
+ else {
+ //The source buffer hasn't move, it has been duplicated
+ _M_move(__first, __last, __pos);
+ }
+ }
+ }
+ else {
+ const_iterator __mid = __first;
+ __mid += __elems_after + 1;
+ _STLP_PRIV __ucopy(__mid, __last, this->_M_finish + 1);
+ this->_M_finish += __n - __elems_after;
+ _STLP_PRIV __ucopy(__pos, __old_finish + 1, this->_M_finish);
+ this->_M_finish += __elems_after;
+ if (!__self_ref)
+ _M_copy(__first, __mid, __pos);
+ else
+ _M_move(__first, __mid, __pos);
+ }
+ }
+ else {
+ size_type __len = _M_compute_next_size(__n);
+ pointer __new_start = this->_M_start_of_storage.allocate(__len, __len);
+ pointer __new_finish = _STLP_PRIV __ucopy(this->_M_Start(), __pos, __new_start);
+ __new_finish = _STLP_PRIV __ucopy(__first, __last, __new_finish);
+ __new_finish = _STLP_PRIV __ucopy(__pos, this->_M_finish, __new_finish);
+ _M_construct_null(__new_finish);
+ this->_M_deallocate_block();
+ this->_M_reset(__new_start, __new_finish, __new_start + __len);
+ }
+ }
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT,_Traits,_Alloc>&
+basic_string<_CharT,_Traits,_Alloc> ::replace(iterator __first, iterator __last,
+ size_type __n, _CharT __c) {
+ size_type __len = (size_type)(__last - __first);
+
+ if (__len >= __n) {
+ _Traits::assign(__first, __n, __c);
+ erase(__first + __n, __last);
+ }
+ else {
+ _Traits::assign(__first, __len, __c);
+ insert(__last, __n - __len, __c);
+ }
+ return *this;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT,_Traits,_Alloc>&
+basic_string<_CharT,_Traits,_Alloc> ::_M_replace(iterator __first, iterator __last,
+ const _CharT* __f, const _CharT* __l,
+ bool __self_ref) {
+ const ptrdiff_t __n = __l - __f;
+ const difference_type __len = __last - __first;
+ if (__len >= __n) {
+ if (!__self_ref || __l < __first || __f >= __last)
+ _M_copy(__f, __l, __first);
+ else
+ _M_move(__f, __l, __first);
+ erase(__first + __n, __last);
+ } else if (!__self_ref || (__f >= __last) || (__l <= __first)) { // no overlap
+ const_iterator __m = __f + __len;
+ _M_copy(__f, __m, __first);
+ _M_insert(__last, __m, __l, __self_ref );
+ } else if (__f < __first) { // we have to take care of overlaping
+ const_iterator __m = __f + __len;
+ // We have to deal with possible reallocation because we do insert first.
+ const difference_type __off_dest = __first - this->begin();
+ const difference_type __off_src = __f - this->begin();
+ _M_insert(__last, __m, __l, true);
+ _Traits::move(begin() + __off_dest, begin() + __off_src, __len);
+ } else {
+ const_iterator __m = __f + __len;
+ _Traits::move(__first, __f, __len);
+ _M_insert(__last, __m, __l, true);
+ }
+ return *this;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+__size_type__ basic_string<_CharT,_Traits,_Alloc>::find( const _CharT* __s, size_type __pos,
+ size_type __n) const
+{
+ const size_t __len = size();
+ if (__pos >= __len || __pos + __n > __len) {
+ if ( __n == 0 && __pos <= __len ) { // marginal case
+ return __pos;
+ }
+ return npos;
+ }
+
+ const_pointer __result =
+ _STLP_STD::search(this->_M_Start() + __pos, this->_M_Finish(),
+ __s, __s + __n, _STLP_PRIV _Eq_traits<_Traits>());
+ return __result != this->_M_Finish() ? __result - this->_M_Start() : npos;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+__size_type__ basic_string<_CharT,_Traits,_Alloc>::find(_CharT __c, size_type __pos) const
+{
+ if (__pos >= size()) { /*__pos + 1 > size()*/
+ return npos;
+ }
+
+ const_pointer __result =
+ _STLP_STD::find_if(this->_M_Start() + __pos, this->_M_Finish(),
+ _STLP_PRIV _Eq_char_bound<_Traits>(__c));
+ return __result != this->_M_Finish() ? __result - this->_M_Start() : npos;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+__size_type__ basic_string<_CharT,_Traits,_Alloc>::rfind(const _CharT* __s, size_type __pos,
+ size_type __n) const
+{
+ const size_type __len = size();
+ if ( __len < __n ) {
+ return npos;
+ }
+ const_pointer __last = this->_M_Start() + (min)( __len - __n, __pos) + __n;
+ if ( __n == 0 ) { // marginal case
+ return __last - this->_M_Start();
+ }
+ const_pointer __result = _STLP_STD::find_end(this->_M_Start(), __last,
+ __s, __s + __n, _STLP_PRIV _Eq_traits<_Traits>());
+ return __result != __last ? __result - this->_M_Start() : npos;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+__size_type__ basic_string<_CharT,_Traits,_Alloc>::rfind(_CharT __c, size_type __pos) const
+{
+ const size_type __len = size();
+ if ( __len < 1 ) {
+ return npos;
+ }
+ const_iterator __last = begin() + (min)(__len - 1, __pos) + 1;
+ const_reverse_iterator __rresult =
+ _STLP_STD::find_if(const_reverse_iterator(__last), rend(),
+ _STLP_PRIV _Eq_char_bound<_Traits>(__c));
+ return __rresult != rend() ? (__rresult.base() - 1) - begin() : npos;
+}
+
+template <class _CharT, class _Traits, class _Alloc> __size_type__
+basic_string<_CharT,_Traits,_Alloc> ::find_first_of(const _CharT* __s, size_type __pos,
+ size_type __n) const {
+ if (__pos >= size()) /*__pos + 1 > size()*/
+ return npos;
+ else {
+ const_iterator __result = _STLP_PRIV __str_find_first_of(begin() + __pos, end(),
+ __s, __s + __n,
+ __STATIC_CAST(_Traits*, 0));
+ return __result != end() ? __result - begin() : npos;
+ }
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+ __size_type__
+basic_string<_CharT,_Traits,_Alloc> ::find_last_of(const _CharT* __s, size_type __pos,
+ size_type __n) const
+{
+ const size_type __len = size();
+ if ( __len < 1 ) {
+ return npos;
+ }
+ const const_iterator __last = begin() + (min)(__len - 1, __pos) + 1;
+ const const_reverse_iterator __rresult =
+ _STLP_PRIV __str_find_first_of(const_reverse_iterator(__last), rend(),
+ __s, __s + __n,
+ __STATIC_CAST(_Traits*, 0));
+ return __rresult != rend() ? (__rresult.base() - 1) - begin() : npos;
+}
+
+
+template <class _CharT, class _Traits, class _Alloc> __size_type__
+basic_string<_CharT,_Traits,_Alloc> ::find_first_not_of(const _CharT* __s, size_type __pos,
+ size_type __n) const {
+ typedef typename _Traits::char_type _CharType;
+ if (__pos >= size()) /*__pos + 1 >= size()*/
+ return npos;
+ else {
+ const_pointer __result = _STLP_PRIV __str_find_first_not_of(this->_M_Start() + __pos, this->_M_Finish(),
+ __STATIC_CAST(const _CharType*, __s),
+ __STATIC_CAST(const _CharType*, __s) + __n,
+ __STATIC_CAST(_Traits*, 0));
+ return __result != this->_M_finish ? __result - this->_M_Start() : npos;
+ }
+}
+
+template <class _CharT, class _Traits, class _Alloc> __size_type__
+basic_string<_CharT,_Traits,_Alloc> ::find_first_not_of(_CharT __c, size_type __pos) const {
+ if (1 > size())
+ return npos;
+ else {
+ const_pointer __result = _STLP_STD::find_if(this->_M_Start() + __pos, this->_M_Finish(),
+ _STLP_PRIV _Neq_char_bound<_Traits>(__c));
+ return __result != this->_M_finish ? __result - this->_M_Start() : npos;
+ }
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+__size_type__
+basic_string<_CharT,_Traits,_Alloc>::find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+{
+ typedef typename _Traits::char_type _CharType;
+ const size_type __len = size();
+ if ( __len < 1 ) {
+ return npos;
+ }
+ const_iterator __last = begin() + (min)(__len - 1, __pos) + 1;
+ const_reverse_iterator __rlast = const_reverse_iterator(__last);
+ const_reverse_iterator __rresult =
+ _STLP_PRIV __str_find_first_not_of(__rlast, rend(),
+ __STATIC_CAST(const _CharType*, __s),
+ __STATIC_CAST(const _CharType*, __s) + __n,
+ __STATIC_CAST(_Traits*, 0));
+ return __rresult != rend() ? (__rresult.base() - 1) - begin() : npos;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+__size_type__
+basic_string<_CharT, _Traits, _Alloc>::find_last_not_of(_CharT __c, size_type __pos) const
+{
+ const size_type __len = size();
+ if ( __len < 1 ) {
+ return npos;
+ }
+ const_iterator __last = begin() + (min)(__len - 1, __pos) + 1;
+ const_reverse_iterator __rlast = const_reverse_iterator(__last);
+ const_reverse_iterator __rresult =
+ _STLP_STD::find_if(__rlast, rend(),
+ _STLP_PRIV _Neq_char_bound<_Traits>(__c));
+ return __rresult != rend() ? (__rresult.base() - 1) - begin() : npos;
+}
+
+#if !defined (basic_string)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+template <class _CharT, class _Traits, class _Alloc>
+void _STLP_CALL _S_string_copy(const basic_string<_CharT,_Traits,_Alloc>& __s,
+ _CharT* __buf, size_t __n) {
+ if (__n > 0) {
+ __n = (min) (__n - 1, __s.size());
+ _STLP_STD::copy(__s.begin(), __s.begin() + __n, __buf);
+ __buf[__n] = _CharT();
+ }
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#include <stl/_range_errors.h>
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// _String_base methods
+template <class _Tp, class _Alloc>
+void _String_base<_Tp,_Alloc>::_M_throw_length_error() const
+{ __stl_throw_length_error("basic_string"); }
+
+template <class _Tp, class _Alloc>
+void _String_base<_Tp, _Alloc>::_M_throw_out_of_range() const
+{ __stl_throw_out_of_range("basic_string"); }
+
+template <class _Tp, class _Alloc>
+void _String_base<_Tp, _Alloc>::_M_allocate_block(size_t __n) {
+ if ((__n <= (max_size() + 1)) && (__n > 0)) {
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+ if (__n > _DEFAULT_SIZE) {
+ this->_M_start_of_storage._M_data = _M_start_of_storage.allocate(__n, __n);
+ this->_M_finish = this->_M_start_of_storage._M_data;
+ this->_M_buffers._M_end_of_storage = this->_M_start_of_storage._M_data + __n;
+ }
+#else
+ this->_M_start_of_storage._M_data = _M_start_of_storage.allocate(__n, __n);
+ this->_M_finish = this->_M_start_of_storage._M_data;
+ this->_M_end_of_storage = this->_M_start_of_storage._M_data + __n;
+#endif
+ } else {
+ this->_M_throw_length_error();
+ }
+}
+
+#if !defined (basic_string)
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT, _Traits, _Alloc>::basic_string(const _CharT* __s)
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _M_range_initialize(__s, __s + traits_type::length(__s));
+}
+#endif
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT, _Traits, _Alloc>::basic_string(const _CharT* __s,
+ const allocator_type& __a)
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _M_range_initialize(__s, __s + traits_type::length(__s));
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_string<_CharT, _Traits, _Alloc>::basic_string(const basic_string<_CharT, _Traits, _Alloc> & __s)
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(__s.get_allocator())
+{ _M_range_initialize(__s._M_Start(), __s._M_Finish()); }
+
+#if defined (basic_string)
+_STLP_MOVE_TO_STD_NAMESPACE
+# undef basic_string
+#endif
+
+#if !defined (_STLP_STATIC_CONST_INIT_BUG) && !defined (_STLP_NO_STATIC_CONST_DEFINITION)
+template <class _CharT, class _Traits, class _Alloc>
+const size_t basic_string<_CharT, _Traits, _Alloc>::npos;
+#endif
+
+_STLP_END_NAMESPACE
+
+#undef __size_type__
+#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+# undef size_type
+# undef iterator
+#endif
+
+#endif /* _STLP_STRING_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_string.h b/sources/android/stlport/stlport/stl/_string.h
new file mode 100644
index 0000000..540822b
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_string.h
@@ -0,0 +1,1182 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_STRING_H
+#define _STLP_INTERNAL_STRING_H
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+# include <stl/_alloc.h>
+#endif
+
+#ifndef _STLP_STRING_FWD_H
+# include <stl/_string_fwd.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+# include <stl/_function_base.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+# include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+# include <stl/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_UNINITIALIZED_H
+# include <stl/_uninitialized.h>
+#endif
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+# include <stl/_string_sum.h>
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+#if defined (__MWERKS__) && ! defined (_STLP_USE_OWN_NAMESPACE)
+
+// MSL implementation classes expect to see the definition of streampos
+// when this header is included. We expect this to be fixed in later MSL
+// implementations
+# if !defined( __MSL_CPP__ ) || __MSL_CPP__ < 0x4105
+# include <stl/msl_string.h>
+# endif
+#endif // __MWERKS__
+
+/*
+ * Standard C++ string class. This class has performance
+ * characteristics very much like vector<>, meaning, for example, that
+ * it does not perform reference-count or copy-on-write, and that
+ * concatenation of two strings is an O(N) operation.
+
+ * There are three reasons why basic_string is not identical to
+ * vector.
+ * First, basic_string always stores a null character at the end;
+ * this makes it possible for c_str to be a fast operation.
+ * Second, the C++ standard requires basic_string to copy elements
+ * using char_traits<>::assign, char_traits<>::copy, and
+ * char_traits<>::move. This means that all of vector<>'s low-level
+ * operations must be rewritten. Third, basic_string<> has a lot of
+ * extra functions in its interface that are convenient but, strictly
+ * speaking, redundant.
+ */
+
+#include <stl/_string_base.h>
+
+_STLP_BEGIN_NAMESPACE
+
+// ------------------------------------------------------------
+// Class basic_string.
+
+// Class invariants:
+// (1) [start, finish) is a valid range.
+// (2) Each iterator in [start, finish) points to a valid object
+// of type value_type.
+// (3) *finish is a valid object of type value_type; when
+// value_type is not a POD it is value_type().
+// (4) [finish + 1, end_of_storage) is a valid range.
+// (5) Each iterator in [finish + 1, end_of_storage) points to
+// unininitialized memory.
+
+// Note one important consequence: a string of length n must manage
+// a block of memory whose size is at least n + 1.
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+struct _String_reserve_t {};
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+# define basic_string _STLP_NO_MEM_T_NAME(str)
+#elif defined (_STLP_DEBUG)
+# define basic_string _STLP_NON_DBG_NAME(str)
+#endif
+
+#if defined (basic_string)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+#if defined (__DMC__)
+# define _STLP_PRIVATE public
+#elif defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+# define _STLP_PRIVATE protected
+#else
+# define _STLP_PRIVATE private
+#endif
+
+template <class _CharT, class _Traits, class _Alloc>
+class basic_string : _STLP_PRIVATE _STLP_PRIV _String_base<_CharT,_Alloc>
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (basic_string)
+ , public __stlport_class<basic_string<_CharT, _Traits, _Alloc> >
+#endif
+{
+_STLP_PRIVATE: // Private members inherited from base.
+ typedef _STLP_PRIV _String_base<_CharT,_Alloc> _Base;
+ typedef basic_string<_CharT, _Traits, _Alloc> _Self;
+
+public:
+ typedef _CharT value_type;
+ typedef _Traits traits_type;
+
+ typedef value_type* pointer;
+ typedef const value_type* const_pointer;
+ typedef value_type& reference;
+ typedef const value_type& const_reference;
+ typedef typename _Base::size_type size_type;
+ typedef ptrdiff_t difference_type;
+ typedef random_access_iterator_tag _Iterator_category;
+
+ typedef const value_type* const_iterator;
+ typedef value_type* iterator;
+
+ _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS;
+
+#include <stl/_string_npos.h>
+
+ typedef _STLP_PRIV _String_reserve_t _Reserve_t;
+
+public: // Constructor, destructor, assignment.
+ typedef typename _Base::allocator_type allocator_type;
+
+ allocator_type get_allocator() const
+ { return _STLP_CONVERT_ALLOCATOR((const allocator_type&)this->_M_start_of_storage, _CharT); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ explicit basic_string(const allocator_type& __a = allocator_type())
+#else
+ basic_string()
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type(), _Base::_DEFAULT_SIZE)
+ { _M_terminate_string(); }
+ explicit basic_string(const allocator_type& __a)
+#endif
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(__a, _Base::_DEFAULT_SIZE)
+ { _M_terminate_string(); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ basic_string(_Reserve_t, size_t __n,
+ const allocator_type& __a = allocator_type())
+#else
+ basic_string(_Reserve_t, size_t __n)
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type(), __n + 1)
+ { _M_terminate_string(); }
+ basic_string(_Reserve_t, size_t __n, const allocator_type& __a)
+#endif
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(__a, __n + 1)
+ { _M_terminate_string(); }
+
+ basic_string(const _Self&);
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ basic_string(const _Self& __s, size_type __pos, size_type __n = npos,
+ const allocator_type& __a = allocator_type())
+#else
+ basic_string(const _Self& __s, size_type __pos)
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) {
+ if (__pos > __s.size())
+ this->_M_throw_out_of_range();
+ else
+ _M_range_initialize(__s._M_Start() + __pos, __s._M_Finish());
+ }
+ basic_string(const _Self& __s, size_type __pos, size_type __n)
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) {
+ if (__pos > __s.size())
+ this->_M_throw_out_of_range();
+ else
+ _M_range_initialize(__s._M_Start() + __pos,
+ __s._M_Start() + __pos + (min) (__n, __s.size() - __pos));
+ }
+ basic_string(const _Self& __s, size_type __pos, size_type __n,
+ const allocator_type& __a)
+#endif
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) {
+ if (__pos > __s.size())
+ this->_M_throw_out_of_range();
+ else
+ _M_range_initialize(__s._M_Start() + __pos,
+ __s._M_Start() + __pos + (min) (__n, __s.size() - __pos));
+ }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ basic_string(const _CharT* __s, size_type __n,
+ const allocator_type& __a = allocator_type())
+#else
+ basic_string(const _CharT* __s, size_type __n)
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _M_range_initialize(__s, __s + __n);
+ }
+ basic_string(const _CharT* __s, size_type __n, const allocator_type& __a)
+#endif
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _M_range_initialize(__s, __s + __n);
+ }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ basic_string(const _CharT* __s,
+ const allocator_type& __a = allocator_type());
+#else
+ basic_string(const _CharT* __s);
+ basic_string(const _CharT* __s, const allocator_type& __a);
+#endif
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ basic_string(size_type __n, _CharT __c,
+ const allocator_type& __a = allocator_type())
+#else
+ basic_string(size_type __n, _CharT __c)
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type(), __n + 1) {
+ this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_Start(), __n, __c);
+ _M_terminate_string();
+ }
+ basic_string(size_type __n, _CharT __c, const allocator_type& __a)
+#endif
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(__a, __n + 1) {
+ this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_Start(), __n, __c);
+ _M_terminate_string();
+ }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ basic_string(__move_source<_Self> src)
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(__move_source<_Base>(src.get())) {}
+#endif
+
+ // Check to see if _InputIterator is an integer type. If so, then
+ // it can't be an iterator.
+#if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+ template <class _InputIterator>
+ basic_string(_InputIterator __f, _InputIterator __l,
+ const allocator_type & __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_initialize_dispatch(__f, __l, _Integral());
+ }
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ basic_string(_InputIterator __f, _InputIterator __l)
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_initialize_dispatch(__f, __l, _Integral());
+ }
+# endif
+#else
+# if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+ basic_string(const _CharT* __f, const _CharT* __l,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(__a) {
+ _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+ _M_range_initialize(__f, __l);
+ }
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ basic_string(const _CharT* __f, const _CharT* __l)
+ : _STLP_PRIV _String_base<_CharT,_Alloc>(allocator_type()) {
+ _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+ _M_range_initialize(__f, __l);
+ }
+# endif
+# endif
+# if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+ /* We need an additionnal constructor to build an empty string without
+ * any allocation or termination char*/
+protected:
+ struct _CalledFromWorkaround_t {};
+ basic_string(_CalledFromWorkaround_t, const allocator_type &__a)
+ : _String_base<_CharT,_Alloc>(__a) {}
+# endif
+#endif
+
+_STLP_PRIVATE:
+ size_type _M_compute_next_size(size_type __n) {
+ const size_type __size = size();
+ if (__n > max_size() - __size)
+ this->_M_throw_length_error();
+ size_type __len = __size + (max)(__n, __size) + 1;
+ if (__len > max_size() || __len < __size)
+ __len = max_size(); // overflow
+ return __len;
+ }
+
+ template <class _InputIter>
+ void _M_range_initialize(_InputIter __f, _InputIter __l,
+ const input_iterator_tag &__tag) {
+ this->_M_allocate_block();
+ _M_construct_null(this->_M_Finish());
+ _M_appendT(__f, __l, __tag);
+ }
+
+ template <class _ForwardIter>
+ void _M_range_initialize(_ForwardIter __f, _ForwardIter __l,
+ const forward_iterator_tag &) {
+ difference_type __n = _STLP_STD::distance(__f, __l);
+ this->_M_allocate_block(__n + 1);
+ this->_M_finish = uninitialized_copy(__f, __l, this->_M_Start());
+ this->_M_terminate_string();
+ }
+
+ template <class _InputIter>
+ void _M_range_initializeT(_InputIter __f, _InputIter __l) {
+ _M_range_initialize(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter));
+ }
+
+ template <class _Integer>
+ void _M_initialize_dispatch(_Integer __n, _Integer __x, const __true_type& /*_Integral*/) {
+ this->_M_allocate_block(__n + 1);
+ this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_Start(), __n, __x);
+ this->_M_terminate_string();
+ }
+
+ template <class _InputIter>
+ void _M_initialize_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*_Integral*/) {
+ _M_range_initializeT(__f, __l);
+ }
+
+public:
+ _Self& operator=(const _Self& __s) {
+ if (&__s != this)
+ _M_assign(__s._M_Start(), __s._M_Finish());
+ return *this;
+ }
+
+ _Self& operator=(const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return _M_assign(__s, __s + traits_type::length(__s));
+ }
+
+ _Self& operator=(_CharT __c)
+ { return assign(__STATIC_CAST(size_type,1), __c); }
+
+private:
+ static _CharT _STLP_CALL _M_null()
+ { return _STLP_DEFAULT_CONSTRUCTED(_CharT); }
+
+_STLP_PRIVATE: // Helper functions used by constructors
+ // and elsewhere.
+ void _M_construct_null(_CharT* __p) const
+ { _STLP_STD::_Construct(__p); }
+ void _M_terminate_string()
+ { _M_construct_null(this->_M_Finish()); }
+ bool _M_inside(const _CharT* __s) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return (__s >= this->_M_Start()) && (__s < this->_M_Finish());
+ }
+
+ void _M_range_initialize(const _CharT* __f, const _CharT* __l) {
+ _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+ ptrdiff_t __n = __l - __f;
+ this->_M_allocate_block(__n + 1);
+ this->_M_finish = uninitialized_copy(__f, __l, this->_M_Start());
+ _M_terminate_string();
+ }
+
+public: // Iterators.
+ iterator begin() { return this->_M_Start(); }
+ iterator end() { return this->_M_Finish(); }
+ const_iterator begin() const { return this->_M_Start(); }
+ const_iterator end() const { return this->_M_Finish(); }
+
+ reverse_iterator rbegin()
+ { return reverse_iterator(this->_M_Finish()); }
+ reverse_iterator rend()
+ { return reverse_iterator(this->_M_Start()); }
+ const_reverse_iterator rbegin() const
+ { return const_reverse_iterator(this->_M_Finish()); }
+ const_reverse_iterator rend() const
+ { return const_reverse_iterator(this->_M_Start()); }
+
+public: // Size, capacity, etc.
+ size_type size() const { return this->_M_Finish() - this->_M_Start(); }
+ size_type length() const { return size(); }
+ size_type max_size() const { return _Base::max_size(); }
+
+ void resize(size_type __n, _CharT __c) {
+ if (__n <= size())
+ erase(begin() + __n, end());
+ else
+ append(__n - size(), __c);
+ }
+
+ void resize(size_type __n) { resize(__n, _M_null()); }
+
+private:
+ void _M_reserve(size_type);
+public:
+ void reserve(size_type = 0);
+
+ size_type capacity() const
+ { return this->_M_capacity() - 1; }
+
+ void clear() {
+ if (!empty()) {
+ _Traits::assign(*(this->_M_Start()), _M_null());
+ this->_M_finish = this->_M_Start();
+ }
+ }
+
+ bool empty() const { return this->_M_Start() == this->_M_Finish(); }
+
+public: // Element access.
+
+ const_reference operator[](size_type __n) const
+ { return *(this->_M_Start() + __n); }
+ reference operator[](size_type __n)
+ { return *(this->_M_Start() + __n); }
+
+ const_reference at(size_type __n) const {
+ if (__n >= size())
+ this->_M_throw_out_of_range();
+ return *(this->_M_Start() + __n);
+ }
+
+ reference at(size_type __n) {
+ if (__n >= size())
+ this->_M_throw_out_of_range();
+ return *(this->_M_Start() + __n);
+ }
+
+public: // Append, operator+=, push_back.
+
+ _Self& operator+=(const _Self& __s) { return append(__s); }
+ _Self& operator+=(const _CharT* __s) { _STLP_FIX_LITERAL_BUG(__s) return append(__s); }
+ _Self& operator+=(_CharT __c) { push_back(__c); return *this; }
+
+private:
+ _Self& _M_append(const _CharT* __first, const _CharT* __last);
+
+#if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+ template <class _InputIter>
+ _Self& _M_appendT(_InputIter __first, _InputIter __last,
+ const input_iterator_tag &) {
+ for ( ; __first != __last ; ++__first)
+ push_back(*__first);
+ return *this;
+ }
+
+ template <class _ForwardIter>
+ _Self& _M_appendT(_ForwardIter __first, _ForwardIter __last,
+ const forward_iterator_tag &) {
+ if (__first != __last) {
+ size_type __n = __STATIC_CAST(size_type, _STLP_STD::distance(__first, __last));
+ if (__n >= this->_M_rest()) {
+ size_type __len = _M_compute_next_size(__n);
+ pointer __new_start = this->_M_start_of_storage.allocate(__len, __len);
+ pointer __new_finish = uninitialized_copy(this->_M_Start(), this->_M_Finish(), __new_start);
+ __new_finish = uninitialized_copy(__first, __last, __new_finish);
+ _M_construct_null(__new_finish);
+ this->_M_deallocate_block();
+ this->_M_reset(__new_start, __new_finish, __new_start + __len);
+ }
+ else {
+ _Traits::assign(*this->_M_finish, *__first++);
+ uninitialized_copy(__first, __last, this->_M_Finish() + 1);
+ _M_construct_null(this->_M_Finish() + __n);
+ this->_M_finish += __n;
+ }
+ }
+ return *this;
+ }
+
+ template <class _Integer>
+ _Self& _M_append_dispatch(_Integer __n, _Integer __x, const __true_type& /*Integral*/)
+ { return append((size_type) __n, (_CharT) __x); }
+
+ template <class _InputIter>
+ _Self& _M_append_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*Integral*/)
+ { return _M_appendT(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter)); }
+
+public:
+ // Check to see if _InputIterator is an integer type. If so, then
+ // it can't be an iterator.
+ template <class _InputIter>
+ _Self& append(_InputIter __first, _InputIter __last) {
+ typedef typename _IsIntegral<_InputIter>::_Ret _Integral;
+ return _M_append_dispatch(__first, __last, _Integral());
+ }
+#else
+public:
+ _Self& append(const _CharT* __first, const _CharT* __last) {
+ _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+ return _M_append(__first, __last);
+ }
+#endif
+
+public:
+ _Self& append(const _Self& __s)
+ { return _M_append(__s._M_Start(), __s._M_Finish()); }
+
+ _Self& append(const _Self& __s,
+ size_type __pos, size_type __n) {
+ if (__pos > __s.size())
+ this->_M_throw_out_of_range();
+ return _M_append(__s._M_Start() + __pos,
+ __s._M_Start() + __pos + (min) (__n, __s.size() - __pos));
+ }
+
+ _Self& append(const _CharT* __s, size_type __n)
+ { _STLP_FIX_LITERAL_BUG(__s) return _M_append(__s, __s+__n); }
+ _Self& append(const _CharT* __s)
+ { _STLP_FIX_LITERAL_BUG(__s) return _M_append(__s, __s + traits_type::length(__s)); }
+ _Self& append(size_type __n, _CharT __c);
+
+public:
+ void push_back(_CharT __c) {
+ if (this->_M_rest() == 1 )
+ _M_reserve(_M_compute_next_size(1));
+ _M_construct_null(this->_M_Finish() + 1);
+ _Traits::assign(*(this->_M_Finish()), __c);
+ ++this->_M_finish;
+ }
+
+ void pop_back() {
+ _Traits::assign(*(this->_M_Finish() - 1), _M_null());
+ --this->_M_finish;
+ }
+
+public: // Assign
+ _Self& assign(const _Self& __s)
+ { return _M_assign(__s._M_Start(), __s._M_Finish()); }
+
+ _Self& assign(const _Self& __s,
+ size_type __pos, size_type __n) {
+ if (__pos > __s.size())
+ this->_M_throw_out_of_range();
+ return _M_assign(__s._M_Start() + __pos,
+ __s._M_Start() + __pos + (min) (__n, __s.size() - __pos));
+ }
+
+ _Self& assign(const _CharT* __s, size_type __n)
+ { _STLP_FIX_LITERAL_BUG(__s) return _M_assign(__s, __s + __n); }
+
+ _Self& assign(const _CharT* __s)
+ { _STLP_FIX_LITERAL_BUG(__s) return _M_assign(__s, __s + _Traits::length(__s)); }
+
+ _Self& assign(size_type __n, _CharT __c);
+
+private:
+ _Self& _M_assign(const _CharT* __f, const _CharT* __l);
+
+#if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+ // Helper functions for assign.
+ template <class _Integer>
+ _Self& _M_assign_dispatch(_Integer __n, _Integer __x, const __true_type& /*_Integral*/)
+ { return assign((size_type) __n, (_CharT) __x); }
+
+ template <class _InputIter>
+ _Self& _M_assign_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*_Integral*/) {
+ pointer __cur = this->_M_Start();
+ while (__f != __l && __cur != this->_M_Finish()) {
+ _Traits::assign(*__cur, *__f);
+ ++__f;
+ ++__cur;
+ }
+ if (__f == __l)
+ erase(__cur, this->end());
+ else
+ _M_appendT(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter));
+ return *this;
+ }
+
+public:
+ // Check to see if _InputIterator is an integer type. If so, then
+ // it can't be an iterator.
+ template <class _InputIter>
+ _Self& assign(_InputIter __first, _InputIter __last) {
+ typedef typename _IsIntegral<_InputIter>::_Ret _Integral;
+ return _M_assign_dispatch(__first, __last, _Integral());
+ }
+#else
+public:
+ _Self& assign(const _CharT* __f, const _CharT* __l) {
+ _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+ return _M_assign(__f, __l);
+ }
+#endif
+
+public: // Insert
+ _Self& insert(size_type __pos, const _Self& __s) {
+ if (__pos > size())
+ this->_M_throw_out_of_range();
+ if (__s.size() > max_size() - size())
+ this->_M_throw_length_error();
+ _M_insert(begin() + __pos, __s._M_Start(), __s._M_Finish(), &__s == this);
+ return *this;
+ }
+
+ _Self& insert(size_type __pos, const _Self& __s,
+ size_type __beg, size_type __n) {
+ if (__pos > size() || __beg > __s.size())
+ this->_M_throw_out_of_range();
+ size_type __len = (min) (__n, __s.size() - __beg);
+ if (__len > max_size() - size())
+ this->_M_throw_length_error();
+ _M_insert(begin() + __pos,
+ __s._M_Start() + __beg, __s._M_Start() + __beg + __len, &__s == this);
+ return *this;
+ }
+ _Self& insert(size_type __pos, const _CharT* __s, size_type __n) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ if (__pos > size())
+ this->_M_throw_out_of_range();
+ if (__n > max_size() - size())
+ this->_M_throw_length_error();
+ _M_insert(begin() + __pos, __s, __s + __n, _M_inside(__s));
+ return *this;
+ }
+
+ _Self& insert(size_type __pos, const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ if (__pos > size())
+ this->_M_throw_out_of_range();
+ size_type __len = _Traits::length(__s);
+ if (__len > max_size() - size())
+ this->_M_throw_length_error();
+ _M_insert(this->_M_Start() + __pos, __s, __s + __len, _M_inside(__s));
+ return *this;
+ }
+
+ _Self& insert(size_type __pos, size_type __n, _CharT __c) {
+ if (__pos > size())
+ this->_M_throw_out_of_range();
+ if (__n > max_size() - size())
+ this->_M_throw_length_error();
+ insert(begin() + __pos, __n, __c);
+ return *this;
+ }
+
+ iterator insert(iterator __p, _CharT __c) {
+ _STLP_FIX_LITERAL_BUG(__p)
+ if (__p == end()) {
+ push_back(__c);
+ return this->_M_Finish() - 1;
+ }
+ else
+ return _M_insert_aux(__p, __c);
+ }
+
+ void insert(iterator __p, size_t __n, _CharT __c);
+
+_STLP_PRIVATE: // Helper functions for insert.
+ void _M_insert(iterator __p, const _CharT* __first, const _CharT* __last, bool __self_ref);
+
+ pointer _M_insert_aux(pointer, _CharT);
+
+ void _M_copy(const _CharT* __f, const _CharT* __l, _CharT* __res) {
+ _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+ _STLP_FIX_LITERAL_BUG(__res)
+ _Traits::copy(__res, __f, __l - __f);
+ }
+
+ void _M_move(const _CharT* __f, const _CharT* __l, _CharT* __res) {
+ _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+ _Traits::move(__res, __f, __l - __f);
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+# if !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+ template <class _ForwardIter>
+ void _M_insert_overflow(iterator __pos, _ForwardIter __first, _ForwardIter __last,
+ size_type __n) {
+ size_type __len = _M_compute_next_size(__n);
+ pointer __new_start = this->_M_start_of_storage.allocate(__len, __len);
+ pointer __new_finish = uninitialized_copy(this->_M_Start(), __pos, __new_start);
+ __new_finish = uninitialized_copy(__first, __last, __new_finish);
+ __new_finish = uninitialized_copy(__pos, this->_M_Finish(), __new_finish);
+ _M_construct_null(__new_finish);
+ this->_M_deallocate_block();
+ this->_M_reset(__new_start, __new_finish, __new_start + __len);
+ }
+
+ template <class _InputIter>
+ void _M_insertT(iterator __p, _InputIter __first, _InputIter __last,
+ const input_iterator_tag &) {
+ for ( ; __first != __last; ++__first) {
+ __p = insert(__p, *__first);
+ ++__p;
+ }
+ }
+
+ template <class _ForwardIter>
+ void _M_insertT(iterator __pos, _ForwardIter __first, _ForwardIter __last,
+ const forward_iterator_tag &) {
+ if (__first != __last) {
+ size_type __n = _STLP_STD::distance(__first, __last);
+ if (__n < this->_M_rest()) {
+ const size_type __elems_after = this->_M_finish - __pos;
+ if (__elems_after >= __n) {
+ uninitialized_copy((this->_M_Finish() - __n) + 1, this->_M_Finish() + 1, this->_M_Finish() + 1);
+ this->_M_finish += __n;
+ _Traits::move(__pos + __n, __pos, (__elems_after - __n) + 1);
+ _M_copyT(__first, __last, __pos);
+ }
+ else {
+ pointer __old_finish = this->_M_Finish();
+ _ForwardIter __mid = __first;
+ _STLP_STD::advance(__mid, __elems_after + 1);
+ _STLP_STD::uninitialized_copy(__mid, __last, this->_M_Finish() + 1);
+ this->_M_finish += __n - __elems_after;
+ uninitialized_copy(__pos, __old_finish + 1, this->_M_Finish());
+ this->_M_finish += __elems_after;
+ _M_copyT(__first, __mid, __pos);
+ }
+ }
+ else {
+ _M_insert_overflow(__pos, __first, __last, __n);
+ }
+ }
+ }
+
+ template <class _Integer>
+ void _M_insert_dispatch(iterator __p, _Integer __n, _Integer __x,
+ const __true_type& /*Integral*/)
+ { insert(__p, (size_type) __n, (_CharT) __x); }
+
+ template <class _InputIter>
+ void _M_insert_dispatch(iterator __p, _InputIter __first, _InputIter __last,
+ const __false_type& /*Integral*/) {
+ _STLP_FIX_LITERAL_BUG(__p)
+ /* We are forced to do a temporary string to avoid the self referencing issue. */
+ const _Self __self(__first, __last, get_allocator());
+ _M_insertT(__p, __self.begin(), __self.end(), forward_iterator_tag());
+ }
+
+ template <class _InputIterator>
+ void _M_copyT(_InputIterator __first, _InputIterator __last, pointer __result) {
+ _STLP_FIX_LITERAL_BUG(__result)
+ for ( ; __first != __last; ++__first, ++__result)
+ _Traits::assign(*__result, *__first);
+ }
+
+# if !defined (_STLP_NO_METHOD_SPECIALIZATION)
+ void _M_copyT(const _CharT* __f, const _CharT* __l, _CharT* __res) {
+ _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+ _STLP_FIX_LITERAL_BUG(__res)
+ _Traits::copy(__res, __f, __l - __f);
+ }
+# endif
+public:
+ // Check to see if _InputIterator is an integer type. If so, then
+ // it can't be an iterator.
+ template <class _InputIter>
+ void insert(iterator __p, _InputIter __first, _InputIter __last) {
+ typedef typename _IsIntegral<_InputIter>::_Ret _Integral;
+ _M_insert_dispatch(__p, __first, __last, _Integral());
+ }
+# endif
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION)
+public:
+ void insert(iterator __p, const _CharT* __f, const _CharT* __l) {
+ _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+ _M_insert(__p, __f, __l, _M_inside(__f));
+ }
+#endif
+
+public: // Erase.
+ _Self& erase(size_type __pos = 0, size_type __n = npos) {
+ if (__pos > size())
+ this->_M_throw_out_of_range();
+ erase(begin() + __pos, begin() + __pos + (min) (__n, size() - __pos));
+ return *this;
+ }
+
+ iterator erase(iterator __pos) {
+ // The move includes the terminating _CharT().
+ _Traits::move(__pos, __pos + 1, this->_M_Finish() - __pos);
+ --this->_M_finish;
+ return __pos;
+ }
+
+ iterator erase(iterator __first, iterator __last) {
+ if (__first != __last) {
+ // The move includes the terminating _CharT().
+ traits_type::move(__first, __last, (this->_M_Finish() - __last) + 1);
+ this->_M_finish = this->_M_Finish() - (__last - __first);
+ }
+ return __first;
+ }
+
+public: // Replace. (Conceptually equivalent
+ // to erase followed by insert.)
+ _Self& replace(size_type __pos, size_type __n, const _Self& __s) {
+ const size_type __size = size();
+ if (__pos > __size)
+ this->_M_throw_out_of_range();
+ const size_type __len = (min) (__n, __size - __pos);
+ if (__s.size() > max_size() - (__size - __len))
+ this->_M_throw_length_error();
+ return _M_replace(begin() + __pos, begin() + __pos + __len,
+ __s._M_Start(), __s._M_Finish(), &__s == this);
+ }
+
+ _Self& replace(size_type __pos1, size_type __n1, const _Self& __s,
+ size_type __pos2, size_type __n2) {
+ const size_type __size1 = size();
+ const size_type __size2 = __s.size();
+ if (__pos1 > __size1 || __pos2 > __size2)
+ this->_M_throw_out_of_range();
+ const size_type __len1 = (min) (__n1, __size1 - __pos1);
+ const size_type __len2 = (min) (__n2, __size2 - __pos2);
+ if (__len2 > max_size() - (__size1 - __len1))
+ this->_M_throw_length_error();
+ return _M_replace(begin() + __pos1, begin() + __pos1 + __len1,
+ __s._M_Start() + __pos2, __s._M_Start() + __pos2 + __len2, &__s == this);
+ }
+
+ _Self& replace(size_type __pos, size_type __n1,
+ const _CharT* __s, size_type __n2) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ const size_type __size = size();
+ if (__pos > __size)
+ this->_M_throw_out_of_range();
+ const size_type __len = (min) (__n1, __size - __pos);
+ if (__n2 > max_size() - (__size - __len))
+ this->_M_throw_length_error();
+ return _M_replace(begin() + __pos, begin() + __pos + __len,
+ __s, __s + __n2, _M_inside(__s));
+ }
+
+ _Self& replace(size_type __pos, size_type __n1, const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return replace(__pos, __n1, __s, _Traits::length(__s));
+ }
+
+ _Self& replace(size_type __pos, size_type __n1,
+ size_type __n2, _CharT __c) {
+ const size_type __size = size();
+ if (__pos > __size)
+ this->_M_throw_out_of_range();
+ const size_type __len = (min) (__n1, __size - __pos);
+ if (__n2 > max_size() - (__size - __len))
+ this->_M_throw_length_error();
+ return replace(begin() + __pos, begin() + __pos + __len, __n2, __c);
+ }
+
+ _Self& replace(iterator __first, iterator __last, const _Self& __s) {
+ _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+ return _M_replace(__first, __last, __s._M_Start(), __s._M_Finish(), &__s == this);
+ }
+
+ _Self& replace(iterator __first, iterator __last,
+ const _CharT* __s, size_type __n) {
+ _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+ _STLP_FIX_LITERAL_BUG(__s)
+ return _M_replace(__first, __last, __s, __s + __n, _M_inside(__s));
+ }
+
+ _Self& replace(iterator __first, iterator __last,
+ const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+ _STLP_FIX_LITERAL_BUG(__s)
+ return _M_replace(__first, __last, __s, __s + _Traits::length(__s), _M_inside(__s));
+ }
+
+ _Self& replace(iterator __first, iterator __last, size_type __n, _CharT __c);
+
+_STLP_PRIVATE: // Helper functions for replace.
+ _Self& _M_replace(iterator __first, iterator __last,
+ const _CharT* __f, const _CharT* __l, bool __self_ref);
+
+#if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+ template <class _Integer>
+ _Self& _M_replace_dispatch(iterator __first, iterator __last,
+ _Integer __n, _Integer __x, const __true_type& /*IsIntegral*/) {
+ _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+ return replace(__first, __last, (size_type) __n, (_CharT) __x);
+ }
+
+ template <class _InputIter>
+ _Self& _M_replace_dispatch(iterator __first, iterator __last,
+ _InputIter __f, _InputIter __l, const __false_type& /*IsIntegral*/) {
+ _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+ /* We are forced to do a temporary string to avoid the self referencing issue. */
+ const _Self __self(__f, __l, get_allocator());
+ return _M_replace(__first, __last, __self._M_Start(), __self._M_Finish(), false);
+ }
+
+public:
+ // Check to see if _InputIter is an integer type. If so, then
+ // it can't be an iterator.
+ template <class _InputIter>
+ _Self& replace(iterator __first, iterator __last,
+ _InputIter __f, _InputIter __l) {
+ _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+ typedef typename _IsIntegral<_InputIter>::_Ret _Integral;
+ return _M_replace_dispatch(__first, __last, __f, __l, _Integral());
+ }
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION)
+public:
+ _Self& replace(iterator __first, iterator __last,
+ const _CharT* __f, const _CharT* __l) {
+ _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+ _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+ return _M_replace(__first, __last, __f, __l, _M_inside(__f));
+ }
+#endif
+
+public: // Other modifier member functions.
+
+ size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ if (__pos > size())
+ this->_M_throw_out_of_range();
+ const size_type __len = (min) (__n, size() - __pos);
+ _Traits::copy(__s, this->_M_Start() + __pos, __len);
+ return __len;
+ }
+
+ void swap(_Self& __s) { this->_M_swap(__s); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+public: // Conversion to C string.
+
+ const _CharT* c_str() const { return this->_M_Start(); }
+ const _CharT* data() const { return this->_M_Start(); }
+
+public: // find.
+ size_type find(const _Self& __s, size_type __pos = 0) const
+ { return find(__s._M_Start(), __pos, __s.size()); }
+
+ size_type find(const _CharT* __s, size_type __pos = 0) const
+ { _STLP_FIX_LITERAL_BUG(__s) return find(__s, __pos, _Traits::length(__s)); }
+
+ size_type find(const _CharT* __s, size_type __pos, size_type __n) const;
+
+ // WIE: Versant schema compiler 5.2.2 ICE workaround
+ size_type find(_CharT __c) const { return find(__c, 0); }
+ size_type find(_CharT __c, size_type __pos /* = 0 */) const;
+
+public: // rfind.
+ size_type rfind(const _Self& __s, size_type __pos = npos) const
+ { return rfind(__s._M_Start(), __pos, __s.size()); }
+
+ size_type rfind(const _CharT* __s, size_type __pos = npos) const
+ { _STLP_FIX_LITERAL_BUG(__s) return rfind(__s, __pos, _Traits::length(__s)); }
+
+ size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const;
+ size_type rfind(_CharT __c, size_type __pos = npos) const;
+
+public: // find_first_of
+ size_type find_first_of(const _Self& __s, size_type __pos = 0) const
+ { return find_first_of(__s._M_Start(), __pos, __s.size()); }
+
+ size_type find_first_of(const _CharT* __s, size_type __pos = 0) const
+ { _STLP_FIX_LITERAL_BUG(__s) return find_first_of(__s, __pos, _Traits::length(__s)); }
+
+ size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
+
+ size_type find_first_of(_CharT __c, size_type __pos = 0) const
+ { return find(__c, __pos); }
+
+public: // find_last_of
+ size_type find_last_of(const _Self& __s, size_type __pos = npos) const
+ { return find_last_of(__s._M_Start(), __pos, __s.size()); }
+
+ size_type find_last_of(const _CharT* __s, size_type __pos = npos) const
+ { _STLP_FIX_LITERAL_BUG(__s) return find_last_of(__s, __pos, _Traits::length(__s)); }
+
+ size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
+
+ size_type find_last_of(_CharT __c, size_type __pos = npos) const
+ { return rfind(__c, __pos); }
+
+public: // find_first_not_of
+ size_type find_first_not_of(const _Self& __s, size_type __pos = 0) const
+ { return find_first_not_of(__s._M_Start(), __pos, __s.size()); }
+
+ size_type find_first_not_of(const _CharT* __s, size_type __pos = 0) const
+ { _STLP_FIX_LITERAL_BUG(__s) return find_first_not_of(__s, __pos, _Traits::length(__s)); }
+
+ size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const;
+
+ size_type find_first_not_of(_CharT __c, size_type __pos = 0) const;
+
+public: // find_last_not_of
+ size_type find_last_not_of(const _Self& __s, size_type __pos = npos) const
+ { return find_last_not_of(__s._M_Start(), __pos, __s.size()); }
+
+ size_type find_last_not_of(const _CharT* __s, size_type __pos = npos) const
+ { _STLP_FIX_LITERAL_BUG(__s) return find_last_not_of(__s, __pos, _Traits::length(__s)); }
+
+ size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const;
+
+ size_type find_last_not_of(_CharT __c, size_type __pos = npos) const;
+
+public: // Substring.
+ _Self substr(size_type __pos = 0, size_type __n = npos) const
+ { return _Self(*this, __pos, __n, get_allocator()); }
+
+public: // Compare
+ int compare(const _Self& __s) const
+ { return _M_compare(this->_M_Start(), this->_M_Finish(), __s._M_Start(), __s._M_Finish()); }
+
+ int compare(size_type __pos1, size_type __n1, const _Self& __s) const {
+ if (__pos1 > size())
+ this->_M_throw_out_of_range();
+ return _M_compare(this->_M_Start() + __pos1,
+ this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1),
+ __s._M_Start(), __s._M_Finish());
+ }
+
+ int compare(size_type __pos1, size_type __n1, const _Self& __s,
+ size_type __pos2, size_type __n2) const {
+ if (__pos1 > size() || __pos2 > __s.size())
+ this->_M_throw_out_of_range();
+ return _M_compare(this->_M_Start() + __pos1,
+ this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1),
+ __s._M_Start() + __pos2,
+ __s._M_Start() + __pos2 + (min) (__n2, __s.size() - __pos2));
+ }
+
+ int compare(const _CharT* __s) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return _M_compare(this->_M_Start(), this->_M_Finish(), __s, __s + _Traits::length(__s));
+ }
+
+ int compare(size_type __pos1, size_type __n1, const _CharT* __s) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ if (__pos1 > size())
+ this->_M_throw_out_of_range();
+ return _M_compare(this->_M_Start() + __pos1,
+ this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1),
+ __s, __s + _Traits::length(__s));
+ }
+
+ int compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ if (__pos1 > size())
+ this->_M_throw_out_of_range();
+ return _M_compare(this->_M_Start() + __pos1,
+ this->_M_Start() + __pos1 + (min) (__n1, size() - __pos1),
+ __s, __s + __n2);
+ }
+
+public: // Helper functions for compare.
+ static int _STLP_CALL _M_compare(const _CharT* __f1, const _CharT* __l1,
+ const _CharT* __f2, const _CharT* __l2) {
+ const ptrdiff_t __n1 = __l1 - __f1;
+ const ptrdiff_t __n2 = __l2 - __f2;
+ const int cmp = _Traits::compare(__f1, __f2, (min) (__n1, __n2));
+ return cmp != 0 ? cmp : (__n1 < __n2 ? -1 : (__n1 > __n2 ? 1 : 0));
+ }
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION) && !defined (_STLP_DEBUG) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+# define _STLP_STRING_SUM_BASE(__reserve, __size, __alloc) _STLP_PRIV _String_base<_CharT,_Alloc>(__alloc, __size + 1)
+# include <stl/_string_sum_methods.h>
+# undef _STLP_STRING_SUM_BASE
+#endif
+};
+
+#undef _STLP_PRIVATE
+
+#if defined (__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 96)
+template <class _CharT, class _Traits, class _Alloc>
+const size_t basic_string<_CharT, _Traits, _Alloc>::npos = ~(size_t) 0;
+#endif
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS basic_string<char, char_traits<char>, allocator<char> >;
+# if defined (_STLP_HAS_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >;
+# endif
+#endif /* _STLP_USE_TEMPLATE_EXPORT */
+
+#if defined (basic_string)
+_STLP_MOVE_TO_STD_NAMESPACE
+# undef basic_string
+#endif
+
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+# include <stl/_string_workaround.h>
+#endif
+
+#if defined (_STLP_DEBUG)
+# include <stl/debug/_string.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+// ------------------------------------------------------------
+// Non-member functions.
+// Swap.
+#if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+template <class _CharT, class _Traits, class _Alloc>
+inline void _STLP_CALL
+swap(basic_string<_CharT,_Traits,_Alloc>& __x,
+ basic_string<_CharT,_Traits,_Alloc>& __y)
+{ __x.swap(__y); }
+#else
+inline void _STLP_CALL swap(string& __x, string& __y)
+{ __x.swap(__y); }
+# if defined (_STLP_HAS_WCHAR_T)
+inline void _STLP_CALL swap(wstring& __x, wstring& __y)
+{ __x.swap(__y); }
+# endif
+#endif
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _CharT, class _Traits, class _Alloc>
+struct __move_traits<basic_string<_CharT, _Traits, _Alloc> > {
+ typedef __true_type implemented;
+ //Completness depends on the allocator:
+ typedef typename __move_traits<_Alloc>::complete complete;
+};
+/*#else
+ * There is no need to specialize for string and wstring in this case
+ * as the default __move_traits will already tell that string is movable
+ * but not complete. We cannot define it as complete as nothing guaranty
+ * that the STLport user hasn't specialized std::allocator for char or
+ * wchar_t.
+ */
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _CharT, class _Traits, class _Alloc>
+void _STLP_CALL _S_string_copy(const basic_string<_CharT,_Traits,_Alloc>& __s,
+ _CharT* __buf, size_t __n);
+
+#if defined(_STLP_USE_WIDE_INTERFACE)
+// A couple of functions to transfer between ASCII/Unicode
+wstring __ASCIIToWide(const char *ascii);
+string __WideToASCII(const wchar_t *wide);
+#endif
+
+inline const char* _STLP_CALL
+__get_c_string(const string& __str) { return __str.c_str(); }
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#include <stl/_string_operators.h>
+
+#if defined(_STLP_USE_NO_IOSTREAMS) || \
+ (defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION))
+# include <stl/_string.c>
+#endif
+
+#endif /* _STLP_INTERNAL_STRING_H */
+
+/*
+ * Local Variables:
+ * mode:C++
+ * End:
+ */
diff --git a/sources/android/stlport/stlport/stl/_string_base.h b/sources/android/stlport/stlport/stl/_string_base.h
new file mode 100644
index 0000000..7c6d7fe
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_string_base.h
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STRING_BASE_H
+#define _STLP_STRING_BASE_H
+
+// ------------------------------------------------------------
+// Class _String_base.
+
+// _String_base is a helper class that makes it it easier to write an
+// exception-safe version of basic_string. The constructor allocates,
+// but does not initialize, a block of memory. The destructor
+// deallocates, but does not destroy elements within, a block of
+// memory. The destructor assumes that _M_start either is null, or else
+// points to a block of memory that was allocated using _String_base's
+// allocator and whose size is _M_end_of_storage - _M_start_of_storage._M_data.
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp, class _Alloc>
+class _String_base {
+ typedef _String_base<_Tp, _Alloc> _Self;
+protected:
+ _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
+public:
+ //dums: Some compiler(MSVC6) require it to be public not simply protected!
+ enum {_DEFAULT_SIZE = 4 * sizeof( void * )};
+ //This is needed by the full move framework
+ typedef _Alloc allocator_type;
+ typedef _STLP_alloc_proxy<_Tp*, _Tp, allocator_type> _AllocProxy;
+ typedef size_t size_type;
+private:
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+ union _Buffers {
+ _Tp* _M_end_of_storage;
+ _Tp _M_static_buf[_DEFAULT_SIZE];
+ } _M_buffers;
+#else
+ _Tp* _M_end_of_storage;
+#endif /* _STLP_USE_SHORT_STRING_OPTIM */
+protected:
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+ bool _M_using_static_buf() const
+ { return (_M_start_of_storage._M_data == _M_buffers._M_static_buf); }
+ _Tp const* _M_Start() const { return _M_start_of_storage._M_data; }
+ _Tp* _M_Start() { return _M_start_of_storage._M_data; }
+ _Tp const* _M_End() const
+ { return _M_using_static_buf() ? _M_buffers._M_static_buf + _DEFAULT_SIZE : _M_buffers._M_end_of_storage; }
+ _Tp* _M_End()
+ { return _M_using_static_buf() ? _M_buffers._M_static_buf + _DEFAULT_SIZE : _M_buffers._M_end_of_storage; }
+ size_type _M_capacity() const
+ { return _M_using_static_buf() ? _DEFAULT_SIZE : _M_buffers._M_end_of_storage - _M_start_of_storage._M_data; }
+ size_type _M_rest() const
+ { return _M_using_static_buf() ? _DEFAULT_SIZE - (_M_finish - _M_buffers._M_static_buf) : _M_buffers._M_end_of_storage - _M_finish; }
+#else
+ _Tp const* _M_Start() const { return _M_start_of_storage._M_data; }
+ _Tp* _M_Start() { return _M_start_of_storage._M_data; }
+ _Tp const* _M_End() const { return _M_end_of_storage; }
+ _Tp* _M_End() { return _M_end_of_storage; }
+ size_type _M_capacity() const
+ { return _M_end_of_storage - _M_start_of_storage._M_data; }
+ size_type _M_rest() const
+ { return _M_end_of_storage - _M_finish; }
+#endif /* _STLP_USE_SHORT_STRING_OPTIM */
+
+ _Tp* _M_finish;
+ _AllocProxy _M_start_of_storage;
+
+ _Tp const* _M_Finish() const {return _M_finish;}
+ _Tp* _M_Finish() {return _M_finish;}
+
+ // Precondition: 0 < __n <= max_size().
+ void _M_allocate_block(size_t __n = _DEFAULT_SIZE);
+ void _M_deallocate_block() {
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+ if (!_M_using_static_buf() && (_M_start_of_storage._M_data != 0))
+ _M_start_of_storage.deallocate(_M_start_of_storage._M_data, _M_buffers._M_end_of_storage - _M_start_of_storage._M_data);
+#else
+ if (_M_start_of_storage._M_data != 0)
+ _M_start_of_storage.deallocate(_M_start_of_storage._M_data, _M_end_of_storage - _M_start_of_storage._M_data);
+#endif /* _STLP_USE_SHORT_STRING_OPTIM */
+ }
+
+ size_t max_size() const {
+ const size_type __string_max_size = size_type(-1) / sizeof(_Tp);
+ typename allocator_type::size_type __alloc_max_size = _M_start_of_storage.max_size();
+ return (min)(__alloc_max_size, __string_max_size) - 1;
+ }
+
+ _String_base(const allocator_type& __a)
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+ : _M_finish(_M_buffers._M_static_buf), _M_start_of_storage(__a, _M_buffers._M_static_buf)
+#else
+ : _M_end_of_storage(0), _M_finish(0), _M_start_of_storage(__a, (_Tp*)0)
+#endif
+ {}
+
+ _String_base(const allocator_type& __a, size_t __n)
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+ : _M_finish(_M_buffers._M_static_buf), _M_start_of_storage(__a, _M_buffers._M_static_buf) {
+#else
+ : _M_end_of_storage(0), _M_finish(0), _M_start_of_storage(__a, (_Tp*)0) {
+#endif
+ _M_allocate_block(__n);
+ }
+
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+ void _M_move_src (_Self &src) {
+ if (src._M_using_static_buf()) {
+ _M_buffers = src._M_buffers;
+ _M_finish = _M_buffers._M_static_buf + (src._M_finish - src._M_start_of_storage._M_data);
+ _M_start_of_storage._M_data = _M_buffers._M_static_buf;
+ }
+ else {
+ _M_start_of_storage._M_data = src._M_start_of_storage._M_data;
+ _M_finish = src._M_finish;
+ _M_buffers._M_end_of_storage = src._M_buffers._M_end_of_storage;
+ src._M_start_of_storage._M_data = 0;
+ }
+ }
+#endif
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ _String_base(__move_source<_Self> src)
+# if defined (_STLP_USE_SHORT_STRING_OPTIM)
+ : _M_start_of_storage(__move_source<_AllocProxy>(src.get()._M_start_of_storage)) {
+ _M_move_src(src.get());
+# else
+ : _M_end_of_storage(src.get()._M_end_of_storage), _M_finish(src.get()._M_finish),
+ _M_start_of_storage(__move_source<_AllocProxy>(src.get()._M_start_of_storage)) {
+ src.get()._M_start_of_storage._M_data = 0;
+# endif
+ }
+#endif
+
+ ~_String_base() { _M_deallocate_block(); }
+
+ void _M_reset(_Tp *__start, _Tp *__finish, _Tp *__end_of_storage) {
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+ _M_buffers._M_end_of_storage = __end_of_storage;
+#else
+ _M_end_of_storage = __end_of_storage;
+#endif
+ _M_finish = __finish;
+ _M_start_of_storage._M_data = __start;
+ }
+
+ void _M_swap(_Self &__s) {
+#if defined (_STLP_USE_SHORT_STRING_OPTIM)
+ if (_M_using_static_buf()) {
+ if (__s._M_using_static_buf()) {
+ _STLP_STD::swap(_M_buffers, __s._M_buffers);
+ _Tp *__tmp = _M_finish;
+ _M_finish = _M_start_of_storage._M_data + (__s._M_finish - __s._M_start_of_storage._M_data);
+ __s._M_finish = __s._M_buffers._M_static_buf + (__tmp - _M_start_of_storage._M_data);
+ //We need to swap _M_start_of_storage for allocators with state:
+ _M_start_of_storage.swap(__s._M_start_of_storage);
+ _M_start_of_storage._M_data = _M_buffers._M_static_buf;
+ __s._M_start_of_storage._M_data = __s._M_buffers._M_static_buf;
+ } else {
+ __s._M_swap(*this);
+ return;
+ }
+ }
+ else if (__s._M_using_static_buf()) {
+ _Tp *__tmp = _M_start_of_storage._M_data;
+ _Tp *__tmp_finish = _M_finish;
+ _Tp *__tmp_end_data = _M_buffers._M_end_of_storage;
+ _M_buffers = __s._M_buffers;
+ //We need to swap _M_start_of_storage for allocators with state:
+ _M_start_of_storage.swap(__s._M_start_of_storage);
+ _M_start_of_storage._M_data = _M_buffers._M_static_buf;
+ _M_finish = _M_buffers._M_static_buf + (__s._M_finish - __s._M_buffers._M_static_buf);
+ __s._M_buffers._M_end_of_storage = __tmp_end_data;
+ __s._M_start_of_storage._M_data = __tmp;
+ __s._M_finish = __tmp_finish;
+ }
+ else {
+ _STLP_STD::swap(_M_buffers._M_end_of_storage, __s._M_buffers._M_end_of_storage);
+ _M_start_of_storage.swap(__s._M_start_of_storage);
+ _STLP_STD::swap(_M_finish, __s._M_finish);
+ }
+#else
+ _STLP_STD::swap(_M_end_of_storage, __s._M_end_of_storage);
+ _M_start_of_storage.swap(__s._M_start_of_storage);
+ _STLP_STD::swap(_M_finish, __s._M_finish);
+#endif
+ }
+
+ void _STLP_FUNCTION_THROWS _M_throw_length_error() const;
+ void _STLP_FUNCTION_THROWS _M_throw_out_of_range() const;
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS _String_base<char, allocator<char> >;
+# if defined (_STLP_HAS_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS _String_base<wchar_t, allocator<wchar_t> >;
+# endif
+#endif /* _STLP_USE_TEMPLATE_EXPORT */
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_STRING_BASE_H */
+
+/*
+ * Local Variables:
+ * mode:C++
+ * End:
+ */
diff --git a/sources/android/stlport/stlport/stl/_string_fwd.h b/sources/android/stlport/stlport/stl/_string_fwd.h
new file mode 100644
index 0000000..fe65385
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_string_fwd.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STRING_FWD_H
+#define _STLP_STRING_FWD_H
+
+#ifndef _STLP_INTERNAL_IOSFWD
+# include <stl/_iosfwd.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if !defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+template <class _CharT,
+ class _Traits = char_traits<_CharT>,
+ class _Alloc = allocator<_CharT> >
+class basic_string;
+#else
+template <class _CharT,
+ class _Traits,
+ class _Alloc>
+class basic_string;
+#endif /* _STLP_LIMITED_DEFAULT_TEMPLATES */
+
+typedef basic_string<char, char_traits<char>, allocator<char> > string;
+
+#if defined (_STLP_HAS_WCHAR_T)
+typedef basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wstring;
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+//This function limits header dependency between exception and string
+//implementation. It is implemented in _string.h
+const char* _STLP_CALL __get_c_string(const string& __str);
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_STRING_FWD_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_string_hash.h b/sources/android/stlport/stlport/stl/_string_hash.h
new file mode 100644
index 0000000..87f2d9f
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_string_hash.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STRING_HASH_H
+#define _STLP_STRING_HASH_H
+
+#ifndef _STLP_HASH_FUN_H
+# include <stl/_hash_fun.h>
+#endif
+
+#ifndef _STLP_INTERNAL_STRING_H
+# include <stl/_string.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _CharT, class _Traits, class _Alloc>
+_STLP_INLINE_LOOP size_t
+__stl_string_hash(const basic_string<_CharT,_Traits,_Alloc>& __s) {
+ unsigned long __h = 0;
+ size_t __len = __s.size();
+ const _CharT* __data = __s.data();
+ for ( size_t __i = 0; __i < __len; ++__i)
+ __h = /* 5 *__h */(__h << 2) + __h + __data[__i];
+ return size_t(__h);
+}
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && \
+ (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x560))
+template <class _CharT, class _Traits, class _Alloc>
+struct hash<basic_string<_CharT,_Traits,_Alloc> > {
+ size_t operator()(const basic_string<_CharT,_Traits,_Alloc>& __s) const
+ { return __stl_string_hash(__s); }
+};
+
+#else
+
+_STLP_TEMPLATE_NULL
+struct _STLP_CLASS_DECLSPEC hash<string> {
+ size_t operator()(const string& __s) const
+ { return __stl_string_hash(__s); }
+};
+
+# if defined (_STLP_HAS_WCHAR_T)
+_STLP_TEMPLATE_NULL
+struct _STLP_CLASS_DECLSPEC hash<wstring> {
+ size_t operator()(const wstring& __s) const
+ { return __stl_string_hash(__s); }
+};
+# endif
+
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+_STLP_END_NAMESPACE
+
+#endif
diff --git a/sources/android/stlport/stlport/stl/_string_io.c b/sources/android/stlport/stlport/stl/_string_io.c
new file mode 100644
index 0000000..84b1873
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_string_io.c
@@ -0,0 +1,172 @@
+#ifndef _STLP_STRING_IO_C
+#define _STLP_STRING_IO_C
+
+#ifndef _STLP_STRING_IO_H
+# include <stl/_string_io.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CTYPE_H
+# include <stl/_ctype.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _CharT, class _Traits>
+bool _STLP_CALL
+__stlp_string_fill(basic_ostream<_CharT, _Traits>& __os,
+ basic_streambuf<_CharT, _Traits>* __buf,
+ streamsize __n) {
+ _CharT __f = __os.fill();
+ for (streamsize __i = 0; __i < __n; ++__i) {
+ if (_Traits::eq_int_type(__buf->sputc(__f), _Traits::eof()))
+ return false;
+ }
+ return true;
+}
+
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_ostream<_CharT, _Traits>& _STLP_CALL
+operator << (basic_ostream<_CharT, _Traits>& __os,
+ const basic_string<_CharT,_Traits,_Alloc>& __s) {
+ typedef basic_ostream<_CharT, _Traits> __ostream;
+ typedef typename basic_string<_CharT, _Traits, _Alloc>::size_type size_type;
+
+ // The hypothesis of this implementation is that size_type is unsigned:
+ _STLP_STATIC_ASSERT(__STATIC_CAST(size_type, -1) > 0)
+
+ typename __ostream::sentry __sentry(__os);
+ bool __ok = false;
+
+ if (__sentry) {
+ __ok = true;
+ size_type __n = __s.size();
+ const bool __left = (__os.flags() & __ostream::left) != 0;
+ const streamsize __w = __os.width(0);
+ basic_streambuf<_CharT, _Traits>* __buf = __os.rdbuf();
+
+ const bool __need_pad = (((sizeof(streamsize) > sizeof(size_t)) && (__STATIC_CAST(streamsize, __n) < __w)) ||
+ ((sizeof(streamsize) <= sizeof(size_t)) && (__n < __STATIC_CAST(size_t, __w))));
+ streamsize __pad_len = __need_pad ? __w - __n : 0;
+
+ if (!__left)
+ __ok = __stlp_string_fill(__os, __buf, __pad_len);
+
+ __ok = __ok && (__buf->sputn(__s.data(), streamsize(__n)) == streamsize(__n));
+
+ if (__left)
+ __ok = __ok && __stlp_string_fill(__os, __buf, __pad_len);
+ }
+
+ if (!__ok)
+ __os.setstate(__ostream::failbit);
+
+ return __os;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_istream<_CharT, _Traits>& _STLP_CALL
+operator >> (basic_istream<_CharT, _Traits>& __is,
+ basic_string<_CharT,_Traits, _Alloc>& __s) {
+ typedef basic_istream<_CharT, _Traits> __istream;
+ typedef typename basic_string<_CharT, _Traits, _Alloc>::size_type size_type;
+
+ // The hypothesis of this implementation is that size_type is unsigned:
+ _STLP_STATIC_ASSERT(__STATIC_CAST(size_type, -1) > 0)
+
+ typename __istream::sentry __sentry(__is);
+
+ if (__sentry) {
+ basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf();
+ typedef ctype<_CharT> _C_type;
+
+ const locale& __loc = __is.getloc();
+ const _C_type& _Ctype = use_facet<_C_type>(__loc);
+ __s.clear();
+ streamsize __width = __is.width(0);
+ size_type __n;
+ if (__width <= 0)
+ __n = __s.max_size();
+ /* __width can only overflow size_type if sizeof(streamsize) > sizeof(size_type)
+ * because here we know that __width is positive and the stattic assertion check
+ * that size_type is unsigned.
+ */
+ else if (sizeof(streamsize) > sizeof(size_type) &&
+ (__width > __STATIC_CAST(streamsize, __s.max_size())))
+ __n = 0;
+ else {
+ __n = __STATIC_CAST(size_type, __width);
+ __s.reserve(__n);
+ }
+
+ while (__n-- > 0) {
+ typename _Traits::int_type __c1 = __buf->sbumpc();
+ if (_Traits::eq_int_type(__c1, _Traits::eof())) {
+ __is.setstate(__istream::eofbit);
+ break;
+ }
+ else {
+ _CharT __c = _Traits::to_char_type(__c1);
+
+ if (_Ctype.is(_C_type::space, __c)) {
+ if (_Traits::eq_int_type(__buf->sputbackc(__c), _Traits::eof()))
+ __is.setstate(__istream::failbit);
+ break;
+ }
+ else
+ __s.push_back(__c);
+ }
+ }
+
+ // If we have read no characters, then set failbit.
+ if (__s.empty())
+ __is.setstate(__istream::failbit);
+ }
+ else
+ __is.setstate(__istream::failbit);
+
+ return __is;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_istream<_CharT, _Traits>& _STLP_CALL
+getline(basic_istream<_CharT, _Traits>& __is,
+ basic_string<_CharT,_Traits,_Alloc>& __s,
+ _CharT __delim) {
+ typedef basic_istream<_CharT, _Traits> __istream;
+ typedef typename basic_string<_CharT, _Traits, _Alloc>::size_type size_type;
+ size_type __nread = 0;
+ typename basic_istream<_CharT, _Traits>::sentry __sentry(__is, true);
+ if (__sentry) {
+ basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf();
+ __s.clear();
+
+ while (__nread < __s.max_size()) {
+ int __c1 = __buf->sbumpc();
+ if (_Traits::eq_int_type(__c1, _Traits::eof())) {
+ __is.setstate(__istream::eofbit);
+ break;
+ }
+ else {
+ ++__nread;
+ _CharT __c = _Traits::to_char_type(__c1);
+ if (!_Traits::eq(__c, __delim))
+ __s.push_back(__c);
+ else
+ break; // Character is extracted but not appended.
+ }
+ }
+ }
+ if (__nread == 0 || __nread >= __s.max_size())
+ __is.setstate(__istream::failbit);
+
+ return __is;
+}
+
+_STLP_END_NAMESPACE
+
+#endif
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_string_io.h b/sources/android/stlport/stlport/stl/_string_io.h
new file mode 100644
index 0000000..fe549fe
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_string_io.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STRING_IO_H
+#define _STLP_STRING_IO_H
+
+#ifndef _STLP_INTERNAL_OSTREAM_H
+# include <stl/_ostream.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ISTREAM
+# include <stl/_istream.h>
+#endif
+
+// I/O.
+_STLP_BEGIN_NAMESPACE
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_ostream<_CharT, _Traits>& _STLP_CALL
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const basic_string<_CharT,_Traits,_Alloc>& __s);
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+
+template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
+basic_ostream<_CharT, _Traits>& _STLP_CALL
+operator<<(basic_ostream<_CharT, _Traits>& __os,
+ const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __sum) {
+ basic_string<_CharT, _Traits, _Alloc> __tmp(__sum);
+ return __os << __tmp;
+}
+
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_istream<_CharT, _Traits>& _STLP_CALL
+operator>>(basic_istream<_CharT, _Traits>& __is,
+ basic_string<_CharT,_Traits,_Alloc>& __s);
+
+template <class _CharT, class _Traits, class _Alloc>
+basic_istream<_CharT, _Traits>& _STLP_CALL
+getline(basic_istream<_CharT, _Traits>& __is,
+ basic_string<_CharT,_Traits,_Alloc>& __s,
+ _CharT __delim);
+
+#if !(defined (__BORLANDC__) && !defined (_STLP_USE_OWN_NAMESPACE))
+
+template <class _CharT, class _Traits, class _Alloc>
+inline basic_istream<_CharT, _Traits>& _STLP_CALL
+getline(basic_istream<_CharT, _Traits>& __is,
+ basic_string<_CharT,_Traits,_Alloc>& __s) {
+ return getline(__is, __s, __is.widen('\n'));
+}
+#endif
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_string_io.c>
+#endif
+
+#endif /* _STLP_STRING_IO_H */
diff --git a/sources/android/stlport/stlport/stl/_string_npos.h b/sources/android/stlport/stlport/stl/_string_npos.h
new file mode 100644
index 0000000..faa9c62
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_string_npos.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2005
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+/* This header contains npos definition used in basic_string and rope
+ * implementation. It do not have to be guarded as files including it
+ * are already guarded and it has sometimes to be included several times.
+ */
+
+#if defined (_STLP_STATIC_CONST_INIT_BUG)
+ enum { npos = -1 };
+#elif defined (__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 96)
+ // inline initializer conflicts with 'extern template'
+ static const size_t npos;
+#else
+ static const size_t npos = ~(size_t)0;
+#endif
diff --git a/sources/android/stlport/stlport/stl/_string_operators.h b/sources/android/stlport/stlport/stl/_string_operators.h
new file mode 100644
index 0000000..cff13af
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_string_operators.h
@@ -0,0 +1,602 @@
+/*
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STRING_OPERATORS_H
+#define _STLP_STRING_OPERATORS_H
+
+_STLP_BEGIN_NAMESPACE
+
+#if !defined (_STLP_USE_TEMPLATE_EXPRESSION)
+
+# if defined (__GNUC__) || defined (__MLCCPP__)
+# define _STLP_INIT_AMBIGUITY 1
+# endif
+
+template <class _CharT, class _Traits, class _Alloc>
+inline basic_string<_CharT,_Traits,_Alloc> _STLP_CALL
+operator+(const basic_string<_CharT,_Traits,_Alloc>& __s,
+ const basic_string<_CharT,_Traits,_Alloc>& __y) {
+ typedef basic_string<_CharT,_Traits,_Alloc> _Str;
+ typedef typename _Str::_Reserve_t _Reserve_t;
+# if defined (_STLP_INIT_AMBIGUITY)
+ // gcc counts this as a function
+ _Str __result = _Str(_Reserve_t(), __s.size() + __y.size(), __s.get_allocator());
+# else
+ _Str __result(_Reserve_t(), __s.size() + __y.size(), __s.get_allocator());
+# endif
+ __result.append(__s);
+ __result.append(__y);
+ return __result;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline basic_string<_CharT,_Traits,_Alloc> _STLP_CALL
+operator+(const _CharT* __s,
+ const basic_string<_CharT,_Traits,_Alloc>& __y) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ typedef basic_string<_CharT,_Traits,_Alloc> _Str;
+ typedef typename _Str::_Reserve_t _Reserve_t;
+ const size_t __n = _Traits::length(__s);
+# if defined (_STLP_INIT_AMBIGUITY)
+ _Str __result = _Str(_Reserve_t(), __n + __y.size(), __y.get_allocator());
+# else
+ _Str __result(_Reserve_t(), __n + __y.size(), __y.get_allocator());
+# endif
+ __result.append(__s, __s + __n);
+ __result.append(__y);
+ return __result;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline basic_string<_CharT,_Traits,_Alloc> _STLP_CALL
+operator+(_CharT __c,
+ const basic_string<_CharT,_Traits,_Alloc>& __y) {
+ typedef basic_string<_CharT,_Traits,_Alloc> _Str;
+ typedef typename _Str::_Reserve_t _Reserve_t;
+# if defined (_STLP_INIT_AMBIGUITY)
+ _Str __result = _Str(_Reserve_t(), 1 + __y.size(), __y.get_allocator());
+# else
+ _Str __result(_Reserve_t(), 1 + __y.size(), __y.get_allocator());
+# endif
+ __result.push_back(__c);
+ __result.append(__y);
+ return __result;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline basic_string<_CharT,_Traits,_Alloc> _STLP_CALL
+operator+(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ typedef basic_string<_CharT,_Traits,_Alloc> _Str;
+ typedef typename _Str::_Reserve_t _Reserve_t;
+ const size_t __n = _Traits::length(__s);
+# if defined (_STLP_INIT_AMBIGUITY)
+ _Str __result = _Str(_Reserve_t(), __x.size() + __n, __x.get_allocator());
+# else
+ _Str __result(_Reserve_t(), __x.size() + __n, __x.get_allocator());
+# endif
+ __result.append(__x);
+ __result.append(__s, __s + __n);
+ return __result;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline basic_string<_CharT,_Traits,_Alloc> _STLP_CALL
+operator+(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const _CharT __c) {
+ typedef basic_string<_CharT,_Traits,_Alloc> _Str;
+ typedef typename _Str::_Reserve_t _Reserve_t;
+# if defined (_STLP_INIT_AMBIGUITY)
+ _Str __result = _Str(_Reserve_t(), __x.size() + 1, __x.get_allocator());
+# else
+ _Str __result(_Reserve_t(), __x.size() + 1, __x.get_allocator());
+# endif
+ __result.append(__x);
+ __result.push_back(__c);
+ return __result;
+}
+
+# undef _STLP_INIT_AMBIGUITY
+
+#else /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+// addition with basic_string
+template <class _CharT, class _Traits, class _Alloc>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+ _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+ _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+ _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+ _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+ _STLP_PRIV __on_right>,
+ _STLP_PRIV __on_right> _STLP_CALL
+operator+(const basic_string<_CharT,_Traits,_Alloc>& __lhs,
+ const basic_string<_CharT,_Traits,_Alloc>& __rhs) {
+ typedef _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+ _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+ _STLP_PRIV __on_right> __root_type;
+ __root_type __root(__rhs, _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>(__lhs.get_allocator()));
+ return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+ __root_type,
+ _STLP_PRIV __on_right>(__lhs, __root);
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+ _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+ _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+ _STLP_PRIV __on_right> _STLP_CALL
+operator+(const basic_string<_CharT,_Traits,_Alloc>& __lhs,
+ const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __rhs) {
+ return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+ _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+ _STLP_PRIV __on_right>(__lhs, __rhs);
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+ _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+ _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+ _STLP_PRIV __on_left> _STLP_CALL
+operator+(const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __lhs,
+ const basic_string<_CharT,_Traits,_Alloc>& __rhs) {
+ return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+ _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+ _STLP_PRIV __on_left>(__lhs, __rhs);
+}
+
+// addition with C string
+template <class _CharT, class _Traits, class _Alloc>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+ _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+ _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+ _STLP_PRIV __cstr_wrapper<_CharT>,
+ _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+ _STLP_PRIV __on_right>,
+ _STLP_PRIV __on_right> _STLP_CALL
+operator+(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const _CharT* __s) {
+ const size_t __n = _Traits::length(__s);
+ typedef _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __cstr_wrapper<_CharT>,
+ _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+ _STLP_PRIV __on_right> __root_type;
+ __root_type __root(_STLP_PRIV __cstr_wrapper<_CharT>(__s, __n), _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>(__x.get_allocator()));
+ return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+ __root_type, _STLP_PRIV __on_right>(__x, __root);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+ _STLP_PRIV __cstr_wrapper<_CharT>,
+ _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+ _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+ _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+ _STLP_PRIV __on_right>,
+ _STLP_PRIV __on_right> _STLP_CALL
+operator+(const _CharT* __s,
+ const basic_string<_CharT,_Traits,_Alloc>& __y) {
+ const size_t __n = _Traits::length(__s);
+ typedef _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+ _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+ _STLP_PRIV __on_right> __root_type;
+ __root_type __root(__y, _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>(__y.get_allocator()));
+ return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __cstr_wrapper<_CharT>,
+ __root_type,
+ _STLP_PRIV __on_right>(_STLP_PRIV __cstr_wrapper<_CharT>(__s, __n), __root);
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+ _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+ _STLP_PRIV __cstr_wrapper<_CharT>,
+ _STLP_PRIV __on_left> _STLP_CALL
+operator+(const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __x,
+ const _CharT* __s) {
+ const size_t __n = _Traits::length(__s);
+ return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+ _STLP_PRIV __cstr_wrapper<_CharT>,
+ _STLP_PRIV __on_left>(__x, _STLP_PRIV __cstr_wrapper<_CharT>(__s, __n));
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+ _STLP_PRIV __cstr_wrapper<_CharT>,
+ _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+ _STLP_PRIV __on_right> _STLP_CALL
+operator+(const _CharT* __s,
+ const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __y) {
+ const size_t __n = _Traits::length(__s);
+ return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __cstr_wrapper<_CharT>,
+ _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+ _STLP_PRIV __on_right>(_STLP_PRIV __cstr_wrapper<_CharT>(__s, __n), __y);
+}
+
+// addition with char
+template <class _CharT, class _Traits, class _Alloc>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+ _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+ _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+ _STLP_PRIV __char_wrapper<_CharT>,
+ _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+ _STLP_PRIV __on_right>,
+ _STLP_PRIV __on_right> _STLP_CALL
+operator+(const basic_string<_CharT,_Traits,_Alloc>& __x, const _CharT __c) {
+ typedef _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __char_wrapper<_CharT>,
+ _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+ _STLP_PRIV __on_right> __root_type;
+ __root_type __root(__c, _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>(__x.get_allocator()));
+ return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+ __root_type, _STLP_PRIV __on_right>(__x, __root);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+ _STLP_PRIV __char_wrapper<_CharT>,
+ _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+ _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+ _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+ _STLP_PRIV __on_right>,
+ _STLP_PRIV __on_right> _STLP_CALL
+operator+(const _CharT __c, const basic_string<_CharT,_Traits,_Alloc>& __x) {
+ typedef _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_wrapper<_CharT,_Traits,_Alloc>,
+ _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>,
+ _STLP_PRIV __on_right> __root_type;
+ __root_type __root(__x, _STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc>(__x.get_allocator()));
+ return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __char_wrapper<_CharT>,
+ __root_type, _STLP_PRIV __on_right>(__c, __root);
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc,
+ _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+ _STLP_PRIV __char_wrapper<_CharT>,
+ _STLP_PRIV __on_left> _STLP_CALL
+operator+(const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __x, const _CharT __c) {
+ return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+ _STLP_PRIV __char_wrapper<_CharT>, _STLP_PRIV __on_left>(__x, __c);
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Left, class _Right, class _StorageDir>
+inline _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __char_wrapper<_CharT>,
+ _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+ _STLP_PRIV __on_right> _STLP_CALL
+operator+(const _CharT __c, const _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>& __x) {
+ return _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _STLP_PRIV __char_wrapper<_CharT>,
+ _STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir>,
+ _STLP_PRIV __on_right>(__c, __x);
+}
+
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+// Operator== and operator!=
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator==(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const basic_string<_CharT,_Traits,_Alloc>& __y) {
+ return __x.size() == __y.size() && _Traits::compare(__x.data(), __y.data(), __x.size()) == 0;
+}
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator==(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+ const basic_string<_CharT,_Traits,_Alloc>& __y) {
+ return __x.size() == __y.size() && _Traits::compare(__x.data(), __y.data(), __x.size()) == 0;
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator==(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
+ return __x.size() == __y.size() && _Traits::compare(__x.data(), __y.data(), __x.size()) == 0;
+}
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator==(const _CharT* __s,
+ const basic_string<_CharT,_Traits,_Alloc>& __y) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ size_t __n = _Traits::length(__s);
+ return __n == __y.size() && _Traits::compare(__s, __y.data(), __n) == 0;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator==(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ size_t __n = _Traits::length(__s);
+ return __x.size() == __n && _Traits::compare(__x.data(), __s, __n) == 0;
+}
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator==(const _CharT* __s,
+ const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ size_t __n = _Traits::length(__s);
+ return __n == __y.size() && _Traits::compare(__s, __y.data(), __n) == 0;
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator==(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+ const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ size_t __n = _Traits::length(__s);
+ return __x.size() == __n && _Traits::compare(__x.data(), __s, __n) == 0;
+}
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+// Operator< (and also >, <=, and >=).
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator<(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const basic_string<_CharT,_Traits,_Alloc>& __y) {
+ return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__x.begin(), __x.end(),
+ __y.begin(), __y.end()) < 0;
+}
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator<(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+ const basic_string<_CharT,_Traits,_Alloc>& __y) {
+ return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__x.begin(), __x.end(),
+ __y.begin(), __y.end()) < 0;
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator<(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
+ return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__x.begin(), __x.end(),
+ __y.begin(), __y.end()) < 0;
+}
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator<(const _CharT* __s,
+ const basic_string<_CharT,_Traits,_Alloc>& __y) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ size_t __n = _Traits::length(__s);
+ return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__s, __s + __n,
+ __y.begin(), __y.end()) < 0;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator<(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ size_t __n = _Traits::length(__s);
+ return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__x.begin(), __x.end(),
+ __s, __s + __n) < 0;
+}
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator<(const _CharT* __s,
+ const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ size_t __n = _Traits::length(__s);
+ return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__s, __s + __n,
+ __y.begin(), __y.end()) < 0;
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator<(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+ const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ size_t __n = _Traits::length(__s);
+ return basic_string<_CharT,_Traits,_Alloc> ::_M_compare(__x.begin(), __x.end(),
+ __s, __s + __n) < 0;
+}
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+#if defined (_STLP_USE_SEPARATE_RELOPS_NAMESPACE)
+
+/* Only defined if _STLP_USE_SEPARATE_RELOPS_NAMESPACE is defined otherwise
+ * it might introduce ambiguity with pure template relational operators
+ * from rel_ops namespace.
+ */
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator!=(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const basic_string<_CharT,_Traits,_Alloc>& __y)
+{ return !(__x == __y); }
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator>(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const basic_string<_CharT,_Traits,_Alloc>& __y)
+{ return __y < __x; }
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator<=(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const basic_string<_CharT,_Traits,_Alloc>& __y)
+{ return !(__y < __x); }
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator>=(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const basic_string<_CharT,_Traits,_Alloc>& __y)
+{ return !(__x < __y); }
+
+# if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator!=(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+ const basic_string<_CharT,_Traits,_Alloc>& __y)
+{ return !(__x==__y); }
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator!=(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y)
+{ return !(__x==__y); }
+# endif
+
+#endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator!=(const _CharT* __s,
+ const basic_string<_CharT,_Traits,_Alloc>& __y) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return !(__s == __y);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator!=(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return !(__x == __s);
+}
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator!=(const _CharT* __s,
+ const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return !(__s == __y);
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator!=(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+ const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return !(__x == __s);
+}
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator>(const _CharT* __s,
+ const basic_string<_CharT,_Traits,_Alloc>& __y) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return __y < __s;
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator>(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return __s < __x;
+}
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator>(const _CharT* __s,
+ const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return __y < __s;
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator>(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+ const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return __s < __x;
+}
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator<=(const _CharT* __s,
+ const basic_string<_CharT,_Traits,_Alloc>& __y) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return !(__y < __s);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator<=(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return !(__s < __x);
+}
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator<=(const _CharT* __s,
+ const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return !(__y < __s);
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator<=(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+ const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return !(__s < __x);
+}
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator>=(const _CharT* __s,
+ const basic_string<_CharT,_Traits,_Alloc>& __y) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return !(__s < __y);
+}
+
+template <class _CharT, class _Traits, class _Alloc>
+inline bool _STLP_CALL
+operator>=(const basic_string<_CharT,_Traits,_Alloc>& __x,
+ const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return !(__x < __s);
+}
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator>=(const _CharT* __s,
+ const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __y) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return !(__s < __y);
+}
+
+template <class _CharT, class _Traits, class _Alloc, class _Lhs, class _Rhs, class _StoreDir>
+inline bool _STLP_CALL
+operator>=(const _STLP_PRIV __bstr_sum<_CharT,_Traits,_Alloc,_Lhs,_Rhs,_StoreDir>& __x,
+ const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return !(__x < __s);
+}
+#endif /* _STLP_USE_TEMPLATE_EXPRESSION */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_STRING_OPERATORS_H */
+
diff --git a/sources/android/stlport/stlport/stl/_string_sum.h b/sources/android/stlport/stlport/stl/_string_sum.h
new file mode 100644
index 0000000..739d288
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_string_sum.h
@@ -0,0 +1,414 @@
+/*
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STRING_SUM_H
+#define _STLP_STRING_SUM_H
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+/*char wrapper to simulate basic_string*/
+template <class _CharT>
+struct __char_wrapper {
+ typedef const _CharT& const_reference;
+
+ __char_wrapper(_CharT __val) : _Val(__val) {}
+
+ _CharT getValue() const { return _Val; }
+ size_t size() const { return 1; }
+
+ const_reference operator[] (size_t __n) const {
+ //To avoid a check on __n we use this strange implementation
+ return (&_Val)[__n];
+ }
+
+private:
+ _CharT _Val;
+};
+
+/*C string wrapper to simulate basic_string*/
+template <class _CharT>
+struct __cstr_wrapper {
+ typedef const _CharT& const_reference;
+
+ __cstr_wrapper(const _CharT *__cstr, size_t __size) :
+ _CStr(__cstr), _Size(__size) {}
+
+ const _CharT* c_str() const { return _CStr; }
+
+ size_t size() const { return _Size; }
+
+ const_reference operator[] (size_t __n) const { return _CStr[__n]; }
+
+private:
+ const _CharT *_CStr;
+ size_t _Size;
+};
+
+/*basic_string wrapper to ensure that we only store a reference to the original string and not copy it*/
+template <class _CharT, class _Traits, class _Alloc>
+struct __bstr_wrapper {
+ typedef const _CharT& const_reference;
+ typedef basic_string<_CharT, _Traits, _Alloc> _BString;
+
+ __bstr_wrapper (_BString const& __s) :
+ _BStr(__s) {}
+
+ size_t size() const { return _BStr.size(); }
+
+ const_reference operator[] (size_t __n) const { return _BStr[__n]; }
+
+ _BString const& b_str() const { return _BStr; }
+
+private:
+ _BString const& _BStr;
+};
+
+struct __on_left {};
+struct __on_right {};
+
+template <class _CharT, class _Traits, class _Alloc,
+ class _Left, class _Right,
+ class _StorageDirection>
+class __bstr_sum {
+public:
+ typedef basic_string<_CharT, _Traits, _Alloc> _BString;
+ typedef typename _BString::const_reference const_reference;
+ typedef typename _BString::const_iterator const_iterator;
+ typedef typename _BString::const_reverse_iterator const_reverse_iterator;
+ typedef typename _BString::size_type size_type;
+ typedef typename _BString::allocator_type allocator_type;
+ typedef __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDirection> _Self;
+
+ __bstr_sum (_Left const& lhs, _Right const& rhs) :
+ _lhs(lhs), _rhs(rhs) {}
+
+ _Left const& getLhs() const { return _lhs; }
+ _Right const& getRhs() const { return _rhs; }
+
+ allocator_type get_allocator() const { return _M_get_storage(false).get_allocator(); }
+
+ const_iterator begin() const { return _M_get_storage().begin(); }
+ const_iterator end() const { return _M_get_storage().end(); }
+ const_reverse_iterator rbegin() const { return _M_get_storage().rbegin(); }
+ const_reverse_iterator rend() const { return _M_get_storage().rend(); }
+
+ size_type size() const { return _lhs.size() + _rhs.size(); }
+ size_type length() const { return size(); }
+
+ size_t max_size() const { return _M_get_storage().max_size(); }
+ size_type capacity() const { return size(); }
+ bool empty() const { return size() == 0; }
+
+ const_reference operator[](size_t __n) const
+ { return (__n < _lhs.size())?_lhs[__n]:_rhs[__n - _lhs.size()]; }
+
+ const_reference at(size_type __n) const
+ { return _M_get_storage().at(__n); }
+
+ //operator +=
+ typedef __bstr_sum<_CharT, _Traits, _Alloc, _Self, __bstr_wrapper<_CharT, _Traits, _Alloc>, __on_left> _BStrOnLeft;
+ _BStrOnLeft operator += (const _BString& __s) { return append(__s); }
+
+ typedef __bstr_sum<_CharT, _Traits, _Alloc, _Self, __cstr_wrapper<_CharT>, __on_left> _CStrOnLeft;
+ _CStrOnLeft operator += (const _CharT* __s) { return append(__s); }
+
+ typedef __bstr_sum<_CharT, _Traits, _Alloc, _Self, __char_wrapper<_CharT>, __on_left> _CharOnLeft;
+ _CharOnLeft operator += (_CharT __c) { return _CharOnLeft(*this, __c); }
+
+ //append
+ _BStrOnLeft append (const _BString& __s)
+ { return _BStrOnLeft(*this, __s); }
+ _BString& append(const _BString& __s, size_type __pos, size_type __n)
+ { return _M_get_storage().append(__s, __pos, __n); }
+ _CStrOnLeft append(const _CharT* __s) {
+ const size_type __n = _Traits::length(__s);
+ return _CStrOnLeft(*this, __cstr_wrapper<_CharT>(__s, __n));
+ }
+ _CStrOnLeft append(const _CharT* __s, size_type __n)
+ { return _CStrOnLeft(*this, __cstr_wrapper<_CharT>(__s, __n)); }
+ _BString& append(size_type __n, _CharT __c)
+ {return _M_get_storage().append(__n, __c);}
+ template <class _InputIter>
+ _BString& append(_InputIter __first, _InputIter __last)
+ {return _M_get_storage().append(__first, __last);}
+
+ //assign
+ _BString& assign(const _BString& __s) {return _M_get_storage().assign(__s);}
+ _BString& assign(const _BString& __s, size_type __pos, size_type __n) {return _M_get_storage().assign(__s, __pos, __n);}
+ _BString& assign(const _CharT* __s, size_type __n) {return _M_get_storage().assign(__s, __n);}
+ _BString& assign(const _CharT* __s) {return _M_get_storage().assign(__s); }
+ _BString& assign(size_type __n, _CharT __c) {return _M_get_storage().assign(__n, __c);}
+
+ //insert
+ _BString& insert(size_type __pos, const _BString& __s) {return _M_get_storage().insert(__pos, __s);}
+ _BString& insert(size_type __pos, const _BString& __s, size_type __beg, size_type __n)
+ {return _M_get_storage().insert(__pos, __s, __beg, __n);}
+ _BString& insert(size_type __pos, const _CharT* __s, size_type __n) {return _M_get_storage().insert(__pos, __s, __n);}
+ _BString& insert(size_type __pos, const _CharT* __s) {return _M_get_storage().insert(__pos, __s);}
+ _BString& insert(size_type __pos, size_type __n, _CharT __c) {return _M_get_storage().insert(__pos, __n, __c);}
+
+ //erase
+ _BString& erase(size_type __pos = 0, size_type __n =_BString::npos) {return _M_get_storage().erase(__pos, __n);}
+
+ //replace
+ _BString& replace(size_type __pos, size_type __n, const _BString& __s)
+ {return _M_get_storage().replace(__pos, __n, __s);}
+ _BString& replace(size_type __pos1, size_type __n1, const _BString& __s, size_type __pos2, size_type __n2)
+ {return _M_get_storage().replace(__pos1, __n1, __s, __pos2, __n2);}
+ _BString& replace(size_type __pos, size_type __n1, const _CharT* __s, size_type __n2)
+ {return _M_get_storage().replace(__pos, __n1, __s, __n2);}
+ _BString& replace(size_type __pos, size_type __n1, const _CharT* __s)
+ {return _M_get_storage().replace(__pos, __n1, __s);}
+ _BString& replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
+ {return _M_get_storage().replace(__pos, __n1, __n2, __c);}
+
+ size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const
+ {return _M_get_storage().copy(__s, __n, __pos);}
+
+ void swap(_BString& __s)
+ {_M_get_storage().swap(__s);}
+
+ const _CharT* c_str() const { return _M_get_storage().c_str(); }
+ const _CharT* data() const { return _M_get_storage().data(); }
+
+ //find family
+ size_type find(const _BString& __s, size_type __pos = 0) const { return _M_get_storage().find(__s, __pos); }
+ size_type find(const _CharT* __s, size_type __pos = 0) const { return _M_get_storage().find(__s, __pos); }
+ size_type find(const _CharT* __s, size_type __pos, size_type __n) const { return _M_get_storage().find(__s, __pos, __n); }
+ size_type find(_CharT __c, size_type __pos = 0) const { return _M_get_storage().find(__c, __pos); }
+
+ size_type rfind(const _BString& __s, size_type __pos = _BString::npos) const { return _M_get_storage().rfind(__s, __pos); }
+ size_type rfind(const _CharT* __s, size_type __pos = _BString::npos) const { return _M_get_storage().rfind(__s, __pos); }
+ size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const { return _M_get_storage().rfind(__s, __pos, __n); }
+ size_type rfind(_CharT __c, size_type __pos = _BString::npos) const { return _M_get_storage().rfind(__c, __pos); }
+
+ size_type find_first_of(const _BString& __s, size_type __pos = 0) const
+ { return _M_get_storage().find_first_of(__s, __pos); }
+ size_type find_first_of(const _CharT* __s, size_type __pos = 0) const
+ { return _M_get_storage().find_first_of(__s, __pos); }
+ size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
+ { return _M_get_storage().find_first_of(__s, __pos, __n); }
+ size_type find_first_of(_CharT __c, size_type __pos = 0) const
+ { return _M_get_storage().find(__c, __pos); }
+
+ size_type find_last_of(const _BString& __s, size_type __pos = _BString::npos) const
+ { return _M_get_storage().find_last_of(__s, __pos); }
+ size_type find_last_of(const _CharT* __s, size_type __pos = _BString::npos) const
+ { return _M_get_storage().find_last_of(__s, __pos); }
+ size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
+ { return _M_get_storage().find_last_of(__s, __pos, __n); }
+ size_type find_last_of(_CharT __c, size_type __pos = _BString::npos) const
+ { return _M_get_storage().rfind(__c, __pos); }
+
+ size_type find_first_not_of(const _BString& __s, size_type __pos = 0) const
+ { return _M_get_storage().find_first_not_of(__s, __pos); }
+ size_type find_first_not_of(const _CharT* __s, size_type __pos = 0) const
+ { return _M_get_storage().find_first_not_of(__s, __pos); }
+ size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+ { return _M_get_storage().find_first_not_of(__s, __pos, __n); }
+ size_type find_first_not_of(_CharT __c, size_type __pos = 0) const
+ { return _M_get_storage().find_first_not_of(__c, __pos); }
+
+ size_type find_last_not_of(const _BString& __s, size_type __pos = _BString::npos) const
+ { return _M_get_storage().find_last_not_of(__s, __pos); }
+ size_type find_last_not_of(const _CharT* __s, size_type __pos =_BString:: npos) const
+ { return _M_get_storage().find_last_not_of(__s, __pos); }
+ size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+ { return _M_get_storage().find_last_not_of(__s, __pos, __n); }
+ size_type find_last_not_of(_CharT __c, size_type __pos = _BString::npos) const
+ { return _M_get_storage().find_last_not_of(__c, __pos); }
+
+ _BString substr(size_type __pos = 0, size_type __n = _BString::npos) const
+ { return _M_get_storage().substr(__pos, __n); }
+
+ //compare
+ int compare(const _BString& __s) const
+ { return _M_get_storage().compare(__s); }
+ int compare(size_type __pos1, size_type __n1, const _Self& __s) const
+ { return _M_get_storage().compare(__pos1, __n1, __s); }
+ int compare(size_type __pos1, size_type __n1, const _Self& __s, size_type __pos2, size_type __n2) const
+ { return _M_get_storage().compare(__pos1, __n1, __s, __pos2, __n2); }
+ int compare(const _CharT* __s) const
+ { return _M_get_storage().compare(__s); }
+ int compare(size_type __pos1, size_type __n1, const _CharT* __s) const
+ { return _M_get_storage().compare(__pos1, __n1, __s); }
+ int compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const
+ { return _M_get_storage().compare(__pos1, __n1, __s, __n2); }
+
+ //Returns the underlying basic_string representation of the template expression
+ //The non const method will always initialise it.
+ _BString& _M_get_storage()
+ { return _rhs._M_get_storage(*this, _StorageDirection()); }
+
+ template <class _Lhs, class _Rhs, class _StorageDir>
+ _BString& _M_get_storage(__bstr_sum<_CharT, _Traits, _Alloc, _Lhs, _Rhs, _StorageDir> const& __ref,
+ __on_left const& /*StorageDir*/)
+ { return _lhs._M_get_storage(__ref); }
+
+ template <class _Lhs, class _Rhs, class _StorageDir>
+ _BString& _M_get_storage(__bstr_sum<_CharT, _Traits, _Alloc, _Lhs, _Rhs, _StorageDir> const& __ref,
+ __on_right const& /*StorageDir*/)
+ { return _rhs._M_get_storage(__ref); }
+
+ template <class _Lhs, class _Rhs, class _StorageDir>
+ _BString& _M_get_storage(__bstr_sum<_CharT, _Traits, _Alloc, _Lhs, _Rhs, _StorageDir> const& __ref)
+ { return _M_get_storage(__ref, _StorageDirection()); }
+
+ //The const method can be invoked without initialising the basic_string so avoiding dynamic allocation.
+ _BString const& _M_get_storage(bool __do_init = true) const
+ { return _M_get_storage(*this, __do_init, _StorageDirection()); }
+
+ template <class _Lhs, class _Rhs, class _StorageDir>
+ _BString const& _M_get_storage(__bstr_sum<_CharT, _Traits, _Alloc, _Lhs, _Rhs, _StorageDir> const& __ref,
+ bool __do_init, __on_left const& /*StorageDir*/) const
+ { return _lhs._M_get_storage(__ref, __do_init); }
+
+ template <class _Lhs, class _Rhs, class _StorageDir>
+ _BString const& _M_get_storage(__bstr_sum<_CharT, _Traits, _Alloc, _Lhs, _Rhs, _StorageDir> const& __ref,
+ bool __do_init, __on_right const& /*StorageDir*/) const
+ { return _rhs._M_get_storage(__ref, __do_init); }
+
+ template <class _Lhs, class _Rhs, class _StorageDir>
+ _BString const& _M_get_storage(__bstr_sum<_CharT, _Traits, _Alloc, _Lhs, _Rhs, _StorageDir> const& __ref,
+ bool __do_init) const
+ { return _M_get_storage(__ref, __do_init, _StorageDirection()); }
+
+private:
+ _Left _lhs;
+ _Right _rhs;
+};
+
+/*
+ * For this operator we choose to use the right part as the storage part
+ */
+template <class _CharT, class _Traits, class _Alloc,
+ class _Lh1, class _Rh1, class _StoreDir1,
+ class _Lh2, class _Rh2, class _StoreDir2>
+inline __bstr_sum<_CharT, _Traits, _Alloc,
+ __bstr_sum<_CharT, _Traits, _Alloc, _Lh1, _Rh1, _StoreDir1>,
+ __bstr_sum<_CharT, _Traits, _Alloc, _Lh2, _Rh2, _StoreDir2>,
+ __on_right> _STLP_CALL
+operator + (const __bstr_sum<_CharT, _Traits, _Alloc, _Lh1, _Rh1, _StoreDir1> &__lhs,
+ const __bstr_sum<_CharT, _Traits, _Alloc, _Lh2, _Rh2, _StoreDir2> &__rhs) {
+ return __bstr_sum<_CharT, _Traits, _Alloc,
+ __bstr_sum<_CharT, _Traits, _Alloc, _Lh1, _Rh1, _StoreDir1>,
+ __bstr_sum<_CharT, _Traits, _Alloc, _Lh2, _Rh2, _StoreDir2>,
+ __on_right>(__lhs, __rhs);
+}
+
+template <class _CharT, class _Traits, class _Alloc,
+ class _Lh1, class _Rh1, class _StoreDir1,
+ class _Lh2, class _Rh2, class _StoreDir2>
+inline bool _STLP_CALL
+operator == (const __bstr_sum<_CharT, _Traits, _Alloc, _Lh1, _Rh1, _StoreDir1> &__lhs,
+ const __bstr_sum<_CharT, _Traits, _Alloc, _Lh2, _Rh2, _StoreDir2> &__rhs)
+{ return (__lhs.size() == __rhs.size()) && (__lhs._M_get_storage() == __rhs._M_get_storage()); }
+
+template <class _CharT, class _Traits, class _Alloc,
+ class _Lh1, class _Rh1, class _StoreDir1,
+ class _Lh2, class _Rh2, class _StoreDir2>
+inline bool _STLP_CALL
+operator < (const __bstr_sum<_CharT, _Traits, _Alloc, _Lh1, _Rh1, _StoreDir1> &__lhs,
+ const __bstr_sum<_CharT, _Traits, _Alloc, _Lh2, _Rh2, _StoreDir2> &__rhs)
+{ return __lhs._M_get_storage() < __rhs._M_get_storage(); }
+
+#ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
+
+template <class _CharT, class _Traits, class _Alloc,
+ class _Lh1, class _Rh1, class _StoreDir1,
+ class _Lh2, class _Rh2, class _StoreDir2>
+inline bool _STLP_CALL
+operator != (const __bstr_sum<_CharT, _Traits, _Alloc, _Lh1, _Rh1, _StoreDir1> &__lhs,
+ const __bstr_sum<_CharT, _Traits, _Alloc, _Lh2, _Rh2, _StoreDir2> &__rhs)
+{ return !(__lhs == __rhs); }
+
+template <class _CharT, class _Traits, class _Alloc,
+ class _Lh1, class _Rh1, class _StoreDir1,
+ class _Lh2, class _Rh2, class _StoreDir2>
+inline bool _STLP_CALL
+operator > (const __bstr_sum<_CharT, _Traits, _Alloc, _Lh1, _Rh1, _StoreDir1> &__lhs,
+ const __bstr_sum<_CharT, _Traits, _Alloc, _Lh2, _Rh2, _StoreDir2> &__rhs)
+{ return __rhs < __lhs; }
+
+template <class _CharT, class _Traits, class _Alloc,
+ class _Lh1, class _Rh1, class _StoreDir1,
+ class _Lh2, class _Rh2, class _StoreDir2>
+inline bool _STLP_CALL
+operator <= (const __bstr_sum<_CharT, _Traits, _Alloc, _Lh1, _Rh1, _StoreDir1> &__lhs,
+ const __bstr_sum<_CharT, _Traits, _Alloc, _Lh2, _Rh2, _StoreDir2> &__rhs)
+{ return !(__rhs < __lhs); }
+
+template <class _CharT, class _Traits, class _Alloc,
+ class _Lh1, class _Rh1, class _StoreDir1,
+ class _Lh2, class _Rh2, class _StoreDir2>
+inline bool _STLP_CALL
+operator >= (const __bstr_sum<_CharT, _Traits, _Alloc, _Lh1, _Rh1, _StoreDir1> &__lhs,
+ const __bstr_sum<_CharT, _Traits, _Alloc, _Lh2, _Rh2, _StoreDir2> &__rhs)
+{ return !(__lhs < __rhs); }
+
+#endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
+
+
+/*
+ * This class will be used to simulate a temporary string that is required for
+ * a call to the c_str method on the __bstr_sum class.
+ */
+
+template <class _CharT, class _Traits, class _Alloc>
+struct __sum_storage_elem {
+ typedef __sum_storage_elem<_CharT, _Traits, _Alloc> _Self;
+ typedef basic_string<_CharT, _Traits, _Alloc> _BString;
+
+ __sum_storage_elem(_Alloc __alloc) : _M_init(false), _M_storage(__alloc)
+ {}
+
+ template <class _Left, class _Right, class _StorageDir>
+ void _M_Init(__bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir> const& __ref) const {
+ if (!_M_init) {
+ _STLP_MUTABLE(_Self, _M_storage) = __ref;
+ _STLP_MUTABLE(_Self, _M_init) = true;
+ }
+ }
+
+ template <class _Left, class _Right, class _StorageDir>
+ _BString const& _M_get_storage(__bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir> const& __ref,
+ bool __do_init) const {
+ if (__do_init) {
+ _M_Init(__ref);
+ }
+ return _M_storage;
+ }
+ template <class _Left, class _Right, class _StorageDir>
+ _BString& _M_get_storage(__bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir> const& __ref) {
+ _M_Init(__ref);
+ return _M_storage;
+ }
+
+ size_t size() const { return 0; }
+ _CharT const& operator[](size_t __n) const
+ { return __STATIC_CAST(_CharT*, 0)[__n]; }
+
+private:
+ mutable bool _M_init;
+ mutable basic_string<_CharT, _Traits, _Alloc> _M_storage;
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /*_STLP_STRING_SUM_H*/
diff --git a/sources/android/stlport/stlport/stl/_string_sum_methods.h b/sources/android/stlport/stlport/stl/_string_sum_methods.h
new file mode 100644
index 0000000..305608e
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_string_sum_methods.h
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/*
+ * All the necessary methods used for template expressions with basic_string
+ * This file do not have to be macro guarded as it is only used in the _string.h
+ * file and it is a part of the basic_string definition.
+ */
+
+public:
+ template <class _Left, class _Right, class _StorageDir>
+ basic_string(_STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir> const& __s)
+ : _STLP_STRING_SUM_BASE(_Reserve_t(), __s.size(), __s.get_allocator())
+ { _M_append_sum(__s); }
+
+ template <class _Left, class _Right, class _StorageDir>
+ basic_string(_STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir> const& __s,
+ size_type __pos, size_type __n = npos,
+ const allocator_type& __a = allocator_type())
+ : _STLP_STRING_SUM_BASE(_Reserve_t(), (__pos <= __s.size()) ? ((min) (__n, __s.size() - __pos)) : 0, __a) {
+ size_type __size = __s.size();
+ if (__pos > __size)
+ this->_M_throw_out_of_range();
+ else
+ _M_append_sum_pos(__s, __pos, (min) (__n, __size - __pos));
+ }
+
+private:
+ _CharT* _M_append_fast(_STLP_PRIV __char_wrapper<_CharT> __c, _CharT *__buf) {
+ _STLP_STD::_Copy_Construct(__buf, __c.getValue());
+ return __buf + 1;
+ }
+ _CharT* _M_append_fast(_CharT const* __s, size_type __s_size, _CharT *__buf)
+ { return uninitialized_copy(__s, __s + __s_size, __buf); }
+ _CharT* _M_append_fast(_STLP_PRIV __cstr_wrapper<_CharT> const& __s, _CharT *__buf)
+ { return _M_append_fast(__s.c_str(), __s.size(), __buf); }
+ _CharT* _M_append_fast(_STLP_PRIV __bstr_wrapper<_CharT, _Traits, _Alloc> __s, _CharT *__buf)
+ { return _M_append_fast(__s.b_str(), __buf); }
+ _CharT* _M_append_fast(_Self const& __s, _CharT *__buf)
+ { return _M_append_fast(__s.data(), __s.size(), __buf); }
+ _CharT* _M_append_fast(_STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc> const&, _CharT *__buf)
+ { return __buf; }
+ template <class _Left, class _Right, class _StorageDir>
+ _CharT* _M_append_fast(_STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir> const& __s, _CharT *__buf)
+ { return _M_append_fast(__s.getRhs(), _M_append_fast(__s.getLhs(), __buf)); }
+
+ _CharT* _M_append_fast_pos(_STLP_PRIV __char_wrapper<_CharT> __c, _CharT *__buf, size_type /*__pos*/, size_type __n) {
+ if (__n == 0)
+ return __buf;
+ _STLP_STD::_Copy_Construct(__buf, __c.getValue());
+ return __buf + 1;
+ }
+ _CharT* _M_append_fast_pos(_CharT const* __s, size_type __s_size, _CharT *__buf,
+ size_type __pos, size_type __n)
+ { return uninitialized_copy(__s + __pos, __s + __pos + (min)(__n, __s_size - __pos), __buf); }
+ _CharT* _M_append_fast_pos(_STLP_PRIV __cstr_wrapper<_CharT> const& __s, _CharT *__buf,
+ size_type __pos, size_type __n)
+ { return _M_append_fast_pos(__s.c_str(), __s.size(), __buf, __pos, __n); }
+ _CharT* _M_append_fast_pos(_STLP_PRIV __bstr_wrapper<_CharT, _Traits, _Alloc> __s, _CharT *__buf,
+ size_type __pos, size_type __n)
+ { return _M_append_fast_pos(__s.b_str(), __buf, __pos, __n); }
+ _CharT* _M_append_fast_pos(_Self const& __s, _CharT *__buf,
+ size_type __pos, size_type __n)
+ { return _M_append_fast_pos(__s.data(), __s.size(), __buf, __pos, __n); }
+ _CharT* _M_append_fast_pos(_STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc> const&, _CharT *__buf,
+ size_type, size_type)
+ { return __buf; }
+
+ template <class _Left, class _Right, class _StorageDir>
+ _CharT* _M_append_fast_pos(_STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir> const& __s,
+ _CharT *__buf, size_type __pos, size_type __n) {
+ if (__n == 0) {
+ return __buf;
+ }
+ size_type __lhs_size = __s.getLhs().size();
+ if (__pos < __lhs_size) {
+ if (__n < (__lhs_size - __pos)) {
+ return _M_append_fast_pos(__s.getLhs(), __buf, __pos, __n);
+ } else {
+ return _M_append_fast_pos(__s.getRhs(), _M_append_fast_pos(__s.getLhs(), __buf, __pos, __n),
+ 0, __n - (__lhs_size - __pos));
+ }
+ } else {
+ return _M_append_fast_pos(__s.getRhs(), __buf, __pos - __lhs_size, __n);
+ }
+ }
+
+ template <class _Left, class _Right, class _StorageDir>
+ _Self& _M_append_sum (_STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir> const& __s) {
+ size_type __s_size = __s.size();
+ if (__s_size == 0)
+ return *this;
+ const size_type __old_size = this->size();
+ if (__s_size > this->max_size() || __old_size > (this->max_size() - __s_size))
+ this->_M_throw_length_error();
+ if (__old_size + __s_size > this->capacity()) {
+ const size_type __len = __old_size + (max)(__old_size, __s_size) + 1;
+ pointer __new_start = this->_M_start_of_storage.allocate(__len);
+ pointer __new_finish = uninitialized_copy(this->_M_Start(), this->_M_Finish(), __new_start);
+ __new_finish = this->_M_append_fast(__s, __new_finish);
+ this->_M_construct_null(__new_finish);
+ this->_M_deallocate_block();
+ this->_M_reset(__new_start, __new_finish, __new_start + __len);
+ }
+ else {
+ _M_append_sum_no_overflow(__s, 0, __s_size);
+ }
+ return *this;
+ }
+
+ template <class _Left, class _Right, class _StorageDir>
+ _Self& _M_append_sum_pos(_STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir> const& __s,
+ size_type __pos, size_type __n) {
+ size_type __s_size = (min)(__s.size() - __pos, __n);
+ if (__s_size == 0)
+ return *this;
+ const size_type __old_size = this->size();
+ if (__s_size > this->max_size() || __old_size > (this->max_size() - __s_size))
+ this->_M_throw_length_error();
+ if (__old_size + __s_size > this->capacity()) {
+ const size_type __len = __old_size + (max)(__old_size, __s_size) + 1;
+ pointer __new_start = this->_M_start_of_storage.allocate(__len);
+ pointer __new_finish = uninitialized_copy(this->_M_Start(), this->_M_Finish(), __new_start);
+ __new_finish = _M_append_fast_pos(__s, __new_finish, __pos, __s_size);
+ this->_M_construct_null(__new_finish);
+ this->_M_deallocate_block();
+ this->_M_reset(__new_start, __new_finish, __new_start + __len);
+ }
+ else {
+ _M_append_sum_no_overflow(__s, __pos, __s_size);
+ }
+ return *this;
+ }
+
+ template <class _Left, class _Right, class _StorageDir>
+ void _M_append_sum_no_overflow(_STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir> const& __s,
+ size_type __pos, size_type __n) {
+ pointer __finish = this->_M_Finish();
+ _M_append_fast_pos(__s, __finish + 1, __pos + 1, __n - 1);
+ this->_M_construct_null(__finish + __n);
+ _Traits::assign(*this->_M_finish, __s[__pos]);
+ this->_M_finish += __n;
+ }
diff --git a/sources/android/stlport/stlport/stl/_string_workaround.h b/sources/android/stlport/stlport/stl/_string_workaround.h
new file mode 100644
index 0000000..d77e320
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_string_workaround.h
@@ -0,0 +1,599 @@
+/*
+ * Copyright (c) 2004
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+//Included from _string.h, no need for macro guarding.
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_DEBUG)
+# define basic_string _STLP_NON_DBG_NAME(str)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+#define _STLP_NO_MEM_T_STRING_BASE _STLP_PRIV _STLP_NO_MEM_T_NAME(str)<_CharT, _Traits, _Alloc>
+
+template <class _CharT, class _Traits, class _Alloc>
+class basic_string : public _STLP_NO_MEM_T_STRING_BASE
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (basic_string)
+ , public __stlport_class<basic_string<_CharT, _Traits, _Alloc> >
+#endif
+{
+private: // Protected members inherited from base.
+ typedef basic_string<_CharT, _Traits, _Alloc> _Self;
+ typedef _STLP_NO_MEM_T_STRING_BASE _Base;
+ typedef typename _Base::_CalledFromWorkaround_t _CalledFromWorkaround_t;
+public:
+
+ __IMPORT_WITH_REVERSE_ITERATORS(_Base)
+
+ typedef typename _Base::_Iterator_category _Iterator_category;
+ typedef typename _Base::traits_type traits_type;
+ typedef typename _Base::_Reserve_t _Reserve_t;
+
+#include <stl/_string_npos.h>
+
+public: // Constructor, destructor, assignment.
+ explicit basic_string(const allocator_type& __a = allocator_type())
+ : _STLP_NO_MEM_T_STRING_BASE(__a) {}
+
+ basic_string(_Reserve_t __r, size_t __n,
+ const allocator_type& __a = allocator_type())
+ : _STLP_NO_MEM_T_STRING_BASE(__r, __n, __a) {}
+
+ basic_string(const _Self& __s)
+ : _STLP_NO_MEM_T_STRING_BASE(__s) {}
+
+ basic_string(const _Self& __s, size_type __pos, size_type __n = npos,
+ const allocator_type& __a = allocator_type())
+ : _STLP_NO_MEM_T_STRING_BASE(__s, __pos, __n, __a) {}
+
+ basic_string(const _CharT* __s, size_type __n,
+ const allocator_type& __a = allocator_type())
+ : _STLP_NO_MEM_T_STRING_BASE(__s, __n, __a) {}
+
+ basic_string(const _CharT* __s,
+ const allocator_type& __a = allocator_type())
+ : _STLP_NO_MEM_T_STRING_BASE(__s, __a) {}
+
+ basic_string(size_type __n, _CharT __c,
+ const allocator_type& __a = allocator_type())
+ : _STLP_NO_MEM_T_STRING_BASE(__n, __c, __a) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ basic_string(__move_source<_Self> src)
+ : _STLP_NO_MEM_T_STRING_BASE(__move_source<_Base>(src.get())) {}
+#endif
+
+ // Check to see if _InputIterator is an integer type. If so, then
+ // it can't be an iterator.
+ template <class _InputIterator>
+ basic_string(_InputIterator __f, _InputIterator __l,
+ const allocator_type & __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _STLP_NO_MEM_T_STRING_BASE(_CalledFromWorkaround_t(), __a) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_initialize_dispatch(__f, __l, _Integral());
+ }
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ basic_string(_InputIterator __f, _InputIterator __l)
+ : _STLP_NO_MEM_T_STRING_BASE(_CalledFromWorkaround_t(), allocator_type()) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_initialize_dispatch(__f, __l, _Integral());
+ }
+# endif
+
+ _Self& operator=(const _Self& __s) {
+ _Base::operator=(__s);
+ return *this;
+ }
+
+ _Self& operator=(const _CharT* __s) {
+ _Base::operator=(__s);
+ return *this;
+ }
+
+ _Self& operator=(_CharT __c) {
+ _Base::operator=(__c);
+ return *this;
+ }
+
+private:
+ template <class _InputIter>
+ void _M_range_initialize(_InputIter __f, _InputIter __l,
+ const input_iterator_tag &__tag) {
+ this->_M_allocate_block();
+ this->_M_construct_null(this->_M_Finish());
+ _M_appendT(__f, __l, __tag);
+ }
+
+ template <class _ForwardIter>
+ void _M_range_initialize(_ForwardIter __f, _ForwardIter __l,
+ const forward_iterator_tag &) {
+ difference_type __n = _STLP_STD::distance(__f, __l);
+ this->_M_allocate_block(__n + 1);
+ this->_M_finish = uninitialized_copy(__f, __l, this->_M_Start());
+ this->_M_terminate_string();
+ }
+
+ template <class _InputIter>
+ void _M_range_initializeT(_InputIter __f, _InputIter __l) {
+ _M_range_initialize(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter));
+ }
+
+ template <class _Integer>
+ void _M_initialize_dispatch(_Integer __n, _Integer __x, const __true_type& /*_Integral*/) {
+ this->_M_allocate_block(__n + 1);
+ this->_M_finish = uninitialized_fill_n(this->_M_Start(), __n, __x);
+ this->_M_terminate_string();
+ }
+
+ template <class _InputIter>
+ void _M_initialize_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*_Integral*/) {
+ _M_range_initializeT(__f, __l);
+ }
+
+public: // Append, operator+=, push_back.
+ _Self& operator+=(const _Self& __s) {
+ _Base::operator+=(__s);
+ return *this;
+ }
+ _Self& operator+=(const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _Base::operator+=(__s);
+ return *this;
+ }
+ _Self& operator+=(_CharT __c) {
+ _Base::operator+=(__c);
+ return *this;
+ }
+
+ _Self& append(const _Self& __s) {
+ _Base::append(__s);
+ return *this;
+ }
+
+ _Self& append(const _Self& __s,
+ size_type __pos, size_type __n) {
+ _Base::append(__s, __pos, __n);
+ return *this;
+ }
+
+ _Self& append(const _CharT* __s, size_type __n) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _Base::append(__s, __n);
+ return *this;
+ }
+ _Self& append(const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _Base::append(__s);
+ return *this;
+ }
+ _Self& append(size_type __n, _CharT __c) {
+ _Base::append(__n, __c);
+ return *this;
+ }
+
+ // Check to see if _InputIterator is an integer type. If so, then
+ // it can't be an iterator.
+ template <class _InputIter>
+ _Self& append(_InputIter __first, _InputIter __last) {
+ typedef typename _IsIntegral<_InputIter>::_Ret _Integral;
+ return _M_append_dispatch(__first, __last, _Integral());
+ }
+
+#if !defined (_STLP_NO_METHOD_SPECIALIZATION) && !defined (_STLP_NO_EXTENSIONS)
+ //See equivalent assign method remark.
+ _Self& append(const _CharT* __f, const _CharT* __l) {
+ _STLP_FIX_LITERAL_BUG(__f)_STLP_FIX_LITERAL_BUG(__l)
+ _Base::append(__f, __l);
+ return *this;
+ }
+#endif
+
+private: // Helper functions for append.
+
+ template <class _InputIter>
+ _Self& _M_appendT(_InputIter __first, _InputIter __last,
+ const input_iterator_tag &) {
+ for ( ; __first != __last ; ++__first)
+ _Base::push_back(*__first);
+ return *this;
+ }
+
+ template <class _ForwardIter>
+ _Self& _M_appendT(_ForwardIter __first, _ForwardIter __last,
+ const forward_iterator_tag &) {
+ if (__first != __last) {
+ const size_type __n = __STATIC_CAST(size_type, _STLP_STD::distance(__first, __last));
+ if (__n >= this->_M_rest()) {
+ size_type __len = this->_M_compute_next_size(__n);
+ pointer __new_start = this->_M_start_of_storage.allocate(__len, __len);
+ pointer __new_finish = uninitialized_copy(this->_M_Start(), this->_M_Finish(), __new_start);
+ __new_finish = uninitialized_copy(__first, __last, __new_finish);
+ this->_M_construct_null(__new_finish);
+ this->_M_deallocate_block();
+ this->_M_reset(__new_start, __new_finish, __new_start + __len);
+ }
+ else {
+ _Traits::assign(*this->_M_finish, *__first++);
+ uninitialized_copy(__first, __last, this->_M_Finish() + 1);
+ this->_M_construct_null(this->_M_Finish() + __n);
+ this->_M_finish += __n;
+ }
+ }
+ return *this;
+ }
+
+ template <class _Integer>
+ _Self& _M_append_dispatch(_Integer __n, _Integer __x, const __true_type& /*Integral*/)
+ { return append((size_type) __n, (_CharT) __x); }
+
+ template <class _InputIter>
+ _Self& _M_append_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*Integral*/)
+ { return _M_appendT(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter)); }
+
+public: // Assign
+ _Self& assign(const _Self& __s) {
+ _Base::assign(__s);
+ return *this;
+ }
+
+ _Self& assign(const _Self& __s,
+ size_type __pos, size_type __n) {
+ _Base::assign(__s, __pos, __n);
+ return *this;
+ }
+
+ _Self& assign(const _CharT* __s, size_type __n) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _Base::assign(__s, __n);
+ return *this;
+ }
+
+ _Self& assign(const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _Base::assign(__s);
+ return *this;
+ }
+
+ _Self& assign(size_type __n, _CharT __c) {
+ _Base::assign(__n, __c);
+ return *this;
+ }
+
+private: // Helper functions for assign.
+
+ template <class _Integer>
+ _Self& _M_assign_dispatch(_Integer __n, _Integer __x, const __true_type& /*_Integral*/)
+ { return assign((size_type) __n, (_CharT) __x); }
+
+ template <class _InputIter>
+ _Self& _M_assign_dispatch(_InputIter __f, _InputIter __l, const __false_type& /*_Integral*/) {
+ pointer __cur = this->_M_Start();
+ while (__f != __l && __cur != this->_M_Finish()) {
+ _Traits::assign(*__cur, *__f);
+ ++__f;
+ ++__cur;
+ }
+ if (__f == __l)
+ _Base::erase(__cur, this->_M_Finish());
+ else
+ _M_appendT(__f, __l, _STLP_ITERATOR_CATEGORY(__f, _InputIter));
+ return *this;
+ }
+
+public:
+ // Check to see if _InputIterator is an integer type. If so, then
+ // it can't be an iterator.
+ template <class _InputIter>
+ _Self& assign(_InputIter __first, _InputIter __last) {
+ typedef typename _IsIntegral<_InputIter>::_Ret _Integral;
+ return _M_assign_dispatch(__first, __last, _Integral());
+ }
+
+#if !defined (_STLP_NO_METHOD_SPECIALIZATION) && !defined (_STLP_NO_EXTENSIONS)
+ /* This method is not part of the standard and is a specialization of the
+ * template method assign. It is only granted for convenience to call assign
+ * with mixed parameters iterator and const_iterator.
+ */
+ _Self& assign(const _CharT* __f, const _CharT* __l) {
+ _STLP_FIX_LITERAL_BUG(__f)_STLP_FIX_LITERAL_BUG(__l)
+ _Base::assign(__f, __l);
+ return *this;
+ }
+#endif
+
+public: // Insert
+ _Self& insert(size_type __pos, const _Self& __s) {
+ _Base::insert(__pos, __s);
+ return *this;
+ }
+
+ _Self& insert(size_type __pos, const _Self& __s,
+ size_type __beg, size_type __n) {
+ _Base::insert(__pos, __s, __beg, __n);
+ return *this;
+ }
+ _Self& insert(size_type __pos, const _CharT* __s, size_type __n) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _Base::insert(__pos, __s, __n);
+ return *this;
+ }
+
+ _Self& insert(size_type __pos, const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _Base::insert(__pos, __s);
+ return *this;
+ }
+
+ _Self& insert(size_type __pos, size_type __n, _CharT __c) {
+ _Base::insert(__pos, __n, __c);
+ return *this;
+ }
+
+ iterator insert(iterator __p, _CharT __c)
+ { return _Base::insert(__p, __c); }
+
+ void insert(iterator __p, size_t __n, _CharT __c)
+ { _Base::insert(__p, __n, __c); }
+
+ // Check to see if _InputIterator is an integer type. If so, then
+ // it can't be an iterator.
+ template <class _InputIter>
+ void insert(iterator __p, _InputIter __first, _InputIter __last) {
+ typedef typename _IsIntegral<_InputIter>::_Ret _Integral;
+ _M_insert_dispatch(__p, __first, __last, _Integral());
+ }
+
+#if !defined (_STLP_NO_METHOD_SPECIALIZATION)
+public:
+ void insert(iterator __p, const _CharT* __f, const _CharT* __l) {
+ _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+ _M_insert(__p, __f, __l, this->_M_inside(__f));
+ }
+#endif
+
+private: // Helper functions for insert.
+ void _M_insert(iterator __p, const _CharT* __f, const _CharT* __l, bool __self_ref) {
+ _STLP_FIX_LITERAL_BUG(__f)_STLP_FIX_LITERAL_BUG(__l)
+ _Base::_M_insert(__p, __f, __l, __self_ref);
+ }
+
+ template <class _ForwardIter>
+ void _M_insert_overflow(iterator __pos, _ForwardIter __first, _ForwardIter __last,
+ size_type __n) {
+ size_type __len = this->_M_compute_next_size(__n);
+ pointer __new_start = this->_M_start_of_storage.allocate(__len, __len);
+ pointer __new_finish = uninitialized_copy(this->_M_Start(), __pos, __new_start);
+ __new_finish = uninitialized_copy(__first, __last, __new_finish);
+ __new_finish = uninitialized_copy(__pos, this->_M_Finish(), __new_finish);
+ this->_M_construct_null(__new_finish);
+ this->_M_deallocate_block();
+ this->_M_reset(__new_start, __new_finish, __new_start + __len);
+ }
+
+ template <class _InputIter>
+ void _M_insertT(iterator __p, _InputIter __first, _InputIter __last,
+ const input_iterator_tag &) {
+ for ( ; __first != __last; ++__first) {
+ __p = insert(__p, *__first);
+ ++__p;
+ }
+ }
+
+ template <class _ForwardIter>
+ void _M_insertT(iterator __pos, _ForwardIter __first, _ForwardIter __last,
+ const forward_iterator_tag &) {
+ if (__first != __last) {
+ size_type __n = __STATIC_CAST(size_type, _STLP_STD::distance(__first, __last));
+ if (__n < this->_M_rest()) {
+ const size_type __elems_after = this->_M_finish - __pos;
+ if (__elems_after >= __n) {
+ uninitialized_copy((this->_M_Finish() - __n) + 1, this->_M_Finish() + 1, this->_M_Finish() + 1);
+ this->_M_finish += __n;
+ _Traits::move(__pos + __n, __pos, (__elems_after - __n) + 1);
+ _M_copyT(__first, __last, __pos);
+ }
+ else {
+ pointer __old_finish = this->_M_Finish();
+ _ForwardIter __mid = __first;
+ _STLP_STD::advance(__mid, __elems_after + 1);
+ _STLP_STD::uninitialized_copy(__mid, __last, this->_M_Finish() + 1);
+ this->_M_finish += __n - __elems_after;
+ uninitialized_copy(__pos, __old_finish + 1, this->_M_Finish());
+ this->_M_finish += __elems_after;
+ _M_copyT(__first, __mid, __pos);
+ }
+ }
+ else {
+ _M_insert_overflow(__pos, __first, __last, __n);
+ }
+ }
+ }
+
+ template <class _Integer>
+ void _M_insert_dispatch(iterator __p, _Integer __n, _Integer __x,
+ const __true_type& /*Integral*/)
+ { insert(__p, (size_type) __n, (_CharT) __x); }
+
+ template <class _InputIter>
+ void _M_insert_dispatch(iterator __p, _InputIter __first, _InputIter __last,
+ const __false_type& /*Integral*/) {
+ _STLP_FIX_LITERAL_BUG(__p)
+ /* We are forced to do a temporary string to avoid the self referencing issue. */
+ const _Self __self(__first, __last, this->get_allocator());
+ _M_insertT(__p, __self.begin(), __self.end(), _STLP_ITERATOR_CATEGORY(__first, _InputIter));
+ }
+
+ template <class _InputIterator>
+ void _M_copyT(_InputIterator __first, _InputIterator __last, pointer __result) {
+ _STLP_FIX_LITERAL_BUG(__p)
+ for ( ; __first != __last; ++__first, ++__result)
+ _Traits::assign(*__result, *__first);
+ }
+
+#if !defined (_STLP_NO_METHOD_SPECIALIZATION)
+ void _M_copyT(const _CharT* __f, const _CharT* __l, _CharT* __res) {
+ _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l) _STLP_FIX_LITERAL_BUG(__res)
+ _Base::_M_copy(__f, __l, __res);
+ }
+#endif
+
+public: // Erase.
+ _Self& erase(size_type __pos = 0, size_type __n = npos) {
+ _Base::erase(__pos, __n);
+ return *this;
+ }
+
+ iterator erase(iterator __pos) {
+ _STLP_FIX_LITERAL_BUG(__pos)
+ return _Base::erase(__pos);
+ }
+
+ iterator erase(iterator __first, iterator __last) {
+ _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+ return _Base::erase(__first, __last);
+ }
+
+public: // Replace. (Conceptually equivalent
+ // to erase followed by insert.)
+ _Self& replace(size_type __pos, size_type __n, const _Self& __s) {
+ _Base::replace(__pos, __n, __s);
+ return *this;
+ }
+
+ _Self& replace(size_type __pos1, size_type __n1, const _Self& __s,
+ size_type __pos2, size_type __n2) {
+ _Base::replace(__pos1, __n1, __s, __pos2, __n2);
+ return *this;
+ }
+
+ _Self& replace(size_type __pos, size_type __n1,
+ const _CharT* __s, size_type __n2) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _Base::replace(__pos, __n1, __s, __n2);
+ return *this;
+ }
+
+ _Self& replace(size_type __pos, size_type __n1, const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _Base::replace(__pos, __n1, __s);
+ return *this;
+ }
+
+ _Self& replace(size_type __pos, size_type __n1,
+ size_type __n2, _CharT __c) {
+ _Base::replace(__pos, __n1, __n2, __c);
+ return *this;
+ }
+
+ _Self& replace(iterator __first, iterator __last, const _Self& __s) {
+ _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+ _Base::replace(__first, __last, __s);
+ return *this;
+ }
+
+ _Self& replace(iterator __first, iterator __last,
+ const _CharT* __s, size_type __n) {
+ _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+ _STLP_FIX_LITERAL_BUG(__s)
+ _Base::replace(__first, __last, __s, __n);
+ return *this;
+ }
+
+ _Self& replace(iterator __first, iterator __last,
+ const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+ _STLP_FIX_LITERAL_BUG(__s)
+ _Base::replace(__first, __last, __s);
+ return *this;
+ }
+
+ _Self& replace(iterator __first, iterator __last,
+ size_type __n, _CharT __c) {
+ _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+ _Base::replace(__first, __last, __n, __c);
+ return *this;
+ }
+
+ // Check to see if _InputIter is an integer type. If so, then
+ // it can't be an iterator.
+ template <class _InputIter>
+ _Self& replace(iterator __first, iterator __last,
+ _InputIter __f, _InputIter __l) {
+ _STLP_FIX_LITERAL_BUG(__first)_STLP_FIX_LITERAL_BUG(__last)
+ typedef typename _IsIntegral<_InputIter>::_Ret _Integral;
+ return _M_replace_dispatch(__first, __last, __f, __l, _Integral());
+ }
+
+#if !defined (_STLP_NO_METHOD_SPECIALIZATION)
+ _Self& replace(iterator __first, iterator __last,
+ const _CharT* __f, const _CharT* __l) {
+ _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+ _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+ return _M_replace(__first, __last, __f, __l, this->_M_inside(__f));
+ }
+#endif
+
+private: // Helper functions for replace.
+ _Self& _M_replace(iterator __first, iterator __last,
+ const _CharT* __f, const _CharT* __l, bool __self_ref) {
+ _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+ _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+ _Base::_M_replace(__first, __last, __f, __l, __self_ref);
+ return *this;
+ }
+
+ template <class _Integer>
+ _Self& _M_replace_dispatch(iterator __first, iterator __last,
+ _Integer __n, _Integer __x, const __true_type& /*IsIntegral*/) {
+ _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+ return replace(__first, __last, (size_type) __n, (_CharT) __x);
+ }
+
+ template <class _InputIter>
+ _Self& _M_replace_dispatch(iterator __first, iterator __last,
+ _InputIter __f, _InputIter __l, const __false_type& /*IsIntegral*/) {
+ _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+ /* We are forced to do a temporary string to avoid the self referencing issue. */
+ const _Self __self(__f, __l, this->get_allocator());
+ return _M_replace(__first, __last, __self._M_Start(), __self._M_Finish(), false);
+ }
+
+public: // Other modifier member functions.
+ void swap(_Self& __s) { _Base::swap(__s); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+public: // Substring.
+ _Self substr(size_type __pos = 0, size_type __n = npos) const
+ { return _Self(*this, __pos, __n, this->get_allocator()); }
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION) && !defined (_STLP_DEBUG)
+# define _STLP_STRING_SUM_BASE _STLP_NO_MEM_T_STRING_BASE
+# include <stl/_string_sum_methods.h>
+# undef _STLP_STRING_SUM_BASE
+#endif
+};
+
+#undef _STLP_NO_MEM_T_STRING_BASE
+
+#if defined (basic_string)
+_STLP_MOVE_TO_STD_NAMESPACE
+# undef basic_string
+#endif
+
+_STLP_END_NAMESPACE
diff --git a/sources/android/stlport/stlport/stl/_strstream.h b/sources/android/stlport/stlport/stl/_strstream.h
new file mode 100644
index 0000000..5e3d4c3
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_strstream.h
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_INTERNAL_STRSTREAM
+#define _STLP_INTERNAL_STRSTREAM
+
+#ifndef _STLP_INTERNAL_STREAMBUF
+# include <stl/_streambuf.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ISTREAM
+# include <stl/_istream.h> // Includes <ostream>, <ios>, <iosfwd>
+#endif
+
+#ifndef _STLP_INTERNAL_STRING_H
+# include <stl/_string.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#ifndef _STLP_USE_NAMESPACES
+# define strstream _STLP_strstream
+# define ostrstream _STLP_ostrstream
+# define istrstream _STLP_istrstream
+# define strstreambuf _STLP_strstreambuf
+#endif
+
+//----------------------------------------------------------------------
+// Class strstreambuf, a streambuf class that manages an array of char.
+// Note that this class is not a template.
+
+class _STLP_CLASS_DECLSPEC strstreambuf : public basic_streambuf<char, char_traits<char> > {
+public: // Types.
+ typedef char_traits<char> _Traits;
+ typedef basic_streambuf<char, char_traits<char> > _Base;
+ typedef void* (*__alloc_fn)(size_t);
+ typedef void (*__free_fn)(void*);
+public: // Constructor, destructor
+
+ explicit strstreambuf(streamsize _Initial_capacity = 0);
+
+ strstreambuf(__alloc_fn, __free_fn);
+
+ strstreambuf(char* __get, streamsize __n, char* __put = 0);
+ strstreambuf(signed char* __get, streamsize __n, signed char* __put = 0);
+ strstreambuf(unsigned char* __get, streamsize __n, unsigned char* __put=0);
+
+ strstreambuf(const char* __get, streamsize __n);
+ strstreambuf(const signed char* __get, streamsize __n);
+ strstreambuf(const unsigned char* __get, streamsize __n);
+
+ virtual ~strstreambuf();
+
+public: // strstreambuf operations.
+ void freeze(bool = true);
+ char* str();
+ int pcount() const;
+
+protected: // Overridden virtual member functions.
+ virtual int_type overflow(int_type __c = _Traits::eof());
+ virtual int_type pbackfail(int_type __c = _Traits::eof());
+ virtual int_type underflow();
+ virtual _Base* setbuf(char* __buf, streamsize __n);
+ virtual pos_type seekoff(off_type __off, ios_base::seekdir __dir,
+ ios_base::openmode __mode
+ = ios_base::in | ios_base::out);
+ virtual pos_type seekpos(pos_type __pos, ios_base::openmode __mode
+ = ios_base::in | ios_base::out);
+
+private: // Helper functions.
+ // Dynamic allocation, possibly using _M_alloc_fun and _M_free_fun.
+ char* _M_alloc(size_t);
+ void _M_free(char*);
+
+ // Helper function used in constructors.
+ void _M_setup(char* __get, char* __put, streamsize __n);
+private: // Data members.
+ __alloc_fn _M_alloc_fun;
+ __free_fn _M_free_fun;
+ bool _M_dynamic : 1;
+ bool _M_frozen : 1;
+ bool _M_constant : 1;
+};
+
+//----------------------------------------------------------------------
+// Class istrstream, an istream that manages a strstreambuf.
+
+class _STLP_CLASS_DECLSPEC istrstream : public basic_istream<char, char_traits<char> > {
+public:
+ explicit istrstream(char*);
+ explicit istrstream(const char*);
+ istrstream(char* , streamsize);
+ istrstream(const char*, streamsize);
+ virtual ~istrstream();
+
+ strstreambuf* rdbuf() const;
+ char* str();
+
+private:
+ strstreambuf _M_buf;
+};
+
+//----------------------------------------------------------------------
+// Class ostrstream
+
+class _STLP_CLASS_DECLSPEC ostrstream : public basic_ostream<char, char_traits<char> >
+{
+public:
+ ostrstream();
+ ostrstream(char*, int, ios_base::openmode = ios_base::out);
+ virtual ~ostrstream();
+
+ strstreambuf* rdbuf() const;
+ void freeze(bool = true);
+ char* str();
+ int pcount() const;
+
+private:
+ strstreambuf _M_buf;
+};
+
+//----------------------------------------------------------------------
+// Class strstream
+
+class _STLP_CLASS_DECLSPEC strstream : public basic_iostream<char, char_traits<char> > {
+public:
+ typedef char char_type;
+ typedef char_traits<char>::int_type int_type;
+ typedef char_traits<char>::pos_type pos_type;
+ typedef char_traits<char>::off_type off_type;
+
+ strstream();
+ strstream(char*, int, ios_base::openmode = ios_base::in | ios_base::out);
+ virtual ~strstream();
+
+ strstreambuf* rdbuf() const;
+ void freeze(bool = true);
+ int pcount() const;
+ char* str();
+
+private:
+ strstreambuf _M_buf;
+
+ //explicitely defined as private to avoid warnings:
+ strstream(strstream const&);
+ strstream& operator = (strstream const&);
+};
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_STRSTREAM */
diff --git a/sources/android/stlport/stlport/stl/_tempbuf.c b/sources/android/stlport/stlport/stl/_tempbuf.c
new file mode 100644
index 0000000..179b472
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_tempbuf.c
@@ -0,0 +1,57 @@
+/*
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_TEMPBUF_C
+#define _STLP_TEMPBUF_C
+
+#ifndef _STLP_INTERNAL_TEMPBUF_H
+# include <stl/_tempbuf.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Tp>
+pair<_Tp*, ptrdiff_t> _STLP_CALL
+__get_temporary_buffer(ptrdiff_t __len, _Tp*)
+{
+ if (__len > ptrdiff_t(INT_MAX / sizeof(_Tp)))
+ __len = INT_MAX / sizeof(_Tp);
+
+ while (__len > 0) {
+ _Tp* __tmp = (_Tp*) malloc((size_t)__len * sizeof(_Tp));
+ if (__tmp != 0)
+ return pair<_Tp*, ptrdiff_t>(__tmp, __len);
+ __len /= 2;
+ }
+
+ return pair<_Tp*, ptrdiff_t>((_Tp*)0, 0);
+}
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_TEMPBUF_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_tempbuf.h b/sources/android/stlport/stlport/stl/_tempbuf.h
new file mode 100644
index 0000000..0e0a747
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_tempbuf.h
@@ -0,0 +1,167 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_TEMPBUF_H
+#define _STLP_INTERNAL_TEMPBUF_H
+
+#ifndef _STLP_CLIMITS
+# include <climits>
+#endif
+
+#ifndef _STLP_INTERNAL_CSTDLIB
+# include <stl/_cstdlib.h>
+#endif
+
+#ifndef _STLP_INTERNAL_UNINITIALIZED_H
+# include <stl/_uninitialized.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Tp>
+pair<_Tp*, ptrdiff_t> _STLP_CALL
+__get_temporary_buffer(ptrdiff_t __len, _Tp*);
+
+#ifndef _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS
+
+template <class _Tp>
+inline pair<_Tp*, ptrdiff_t> _STLP_CALL get_temporary_buffer(ptrdiff_t __len) {
+ return __get_temporary_buffer(__len, (_Tp*) 0);
+}
+
+# if ! defined(_STLP_NO_EXTENSIONS)
+// This overload is not required by the standard; it is an extension.
+// It is supported for backward compatibility with the HP STL, and
+// because not all compilers support the language feature (explicit
+// function template arguments) that is required for the standard
+// version of get_temporary_buffer.
+template <class _Tp>
+inline pair<_Tp*, ptrdiff_t> _STLP_CALL
+get_temporary_buffer(ptrdiff_t __len, _Tp*) {
+ return __get_temporary_buffer(__len, (_Tp*) 0);
+}
+# endif
+#endif
+
+template <class _Tp>
+inline void _STLP_CALL return_temporary_buffer(_Tp* __p) {
+// SunPro brain damage
+ free((char*)__p);
+}
+
+template <class _ForwardIterator, class _Tp>
+class _Temporary_buffer {
+private:
+ ptrdiff_t _M_original_len;
+ ptrdiff_t _M_len;
+ _Tp* _M_buffer;
+
+ void _M_allocate_buffer() {
+ _M_original_len = _M_len;
+ _M_buffer = 0;
+
+ if (_M_len > (ptrdiff_t)(INT_MAX / sizeof(_Tp)))
+ _M_len = INT_MAX / sizeof(_Tp);
+
+ while (_M_len > 0) {
+ _M_buffer = (_Tp*) malloc(_M_len * sizeof(_Tp));
+ if (_M_buffer)
+ break;
+ _M_len /= 2;
+ }
+ }
+
+ void _M_initialize_buffer(const _Tp&, const __true_type&) {}
+ void _M_initialize_buffer(const _Tp& val, const __false_type&) {
+ uninitialized_fill_n(_M_buffer, _M_len, val);
+ }
+
+public:
+ ptrdiff_t size() const { return _M_len; }
+ ptrdiff_t requested_size() const { return _M_original_len; }
+ _Tp* begin() { return _M_buffer; }
+ _Tp* end() { return _M_buffer + _M_len; }
+
+ _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last) {
+ // Workaround for a __type_traits bug in the pre-7.3 compiler.
+# if defined(__sgi) && !defined(__GNUC__) && _COMPILER_VERSION < 730
+ typedef typename __type_traits<_Tp>::is_POD_type _Trivial;
+# else
+ typedef typename __type_traits<_Tp>::has_trivial_default_constructor _Trivial;
+# endif
+ _STLP_TRY {
+ _M_len = _STLP_STD::distance(__first, __last);
+ _M_allocate_buffer();
+ if (_M_len > 0)
+ _M_initialize_buffer(*__first, _Trivial());
+ }
+ _STLP_UNWIND(free(_M_buffer); _M_buffer = 0; _M_len = 0)
+ }
+
+ ~_Temporary_buffer() {
+ _STLP_STD::_Destroy_Range(_M_buffer, _M_buffer + _M_len);
+ free(_M_buffer);
+ }
+
+private:
+ // Disable copy constructor and assignment operator.
+ _Temporary_buffer(const _Temporary_buffer<_ForwardIterator, _Tp>&) {}
+ void operator=(const _Temporary_buffer<_ForwardIterator, _Tp>&) {}
+};
+
+# ifndef _STLP_NO_EXTENSIONS
+
+// Class temporary_buffer is not part of the standard. It is an extension.
+
+template <class _ForwardIterator,
+ class _Tp
+#ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
+ = typename iterator_traits<_ForwardIterator>::value_type
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+ >
+struct temporary_buffer : public _Temporary_buffer<_ForwardIterator, _Tp>
+{
+ temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
+ : _Temporary_buffer<_ForwardIterator, _Tp>(__first, __last) {}
+ ~temporary_buffer() {}
+};
+
+# endif /* _STLP_NO_EXTENSIONS */
+
+_STLP_END_NAMESPACE
+
+# ifndef _STLP_LINK_TIME_INSTANTIATION
+# include <stl/_tempbuf.c>
+# endif
+
+#endif /* _STLP_INTERNAL_TEMPBUF_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_threads.c b/sources/android/stlport/stlport/stl/_threads.c
new file mode 100644
index 0000000..ea3c0b9
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_threads.c
@@ -0,0 +1,167 @@
+/*
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_THREADS_C
+#define _STLP_THREADS_C
+
+#ifndef _STLP_INTERNAL_THREADS_H
+# include <stl/_threads.h>
+#endif
+
+#if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)
+
+#if defined (_STLP_SGI_THREADS)
+# include <time.h>
+#elif defined (_STLP_UNIX)
+# ifndef _STLP_INTERNAL_CTIME
+# include <stl/_ctime.h>
+# endif
+# if defined (_STLP_USE_NAMESPACES) && !defined (_STLP_VENDOR_GLOBAL_CSTD)
+using _STLP_VENDOR_CSTD::time_t;
+# endif
+# include <sys/time.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_USE_ATOMIC_SWAP_MUTEX)
+template<int __32bits>
+_STLP_STATIC_MUTEX
+_Atomic_swap_struct<__32bits>::_S_swap_lock _STLP_MUTEX_INITIALIZER;
+# undef _STLP_USE_ATOMIC_SWAP_MUTEX
+#endif
+
+#if defined (_STLP_THREADS) && !defined (_STLP_USE_PTHREAD_SPINLOCK)
+template <int __inst>
+unsigned _STLP_mutex_spin<__inst>::__max = _STLP_mutex_spin<__inst>::__low_max;
+
+template <int __inst>
+unsigned _STLP_mutex_spin<__inst>::__last = 0;
+#endif // _STLP_USE_PTHREAD_SPINLOCK
+
+#if defined (_STLP_THREADS) && !defined (_STLP_USE_PTHREAD_SPINLOCK)
+
+# if defined (_STLP_SPARC_SOLARIS_THREADS)
+// underground function in libc.so; we do not want dependance on librt
+extern "C" int __nanosleep(const struct timespec*, struct timespec*);
+# define _STLP_NANOSLEEP __nanosleep
+# else
+# define _STLP_NANOSLEEP nanosleep
+# endif
+
+template <int __inst>
+void _STLP_CALL
+_STLP_mutex_spin<__inst>::_S_nsec_sleep(int __log_nsec, unsigned int& __iteration) {
+# if defined (_STLP_WIN32THREADS)
+# if defined (_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)
+ if (__iteration <= 4000) {
+ // Use SwitchToThread because
+ // 1) Sleep(1) often takes ~15 ms
+ // 2) SwitchToThread yields to lower-priority threads
+ // 4000 is enough to avoid Sleep and is used just to prevent infinite looping
+ // This number is advised spin count for Heap management by Microsoft
+ SwitchToThread();
+ } else {
+# endif
+ if (__log_nsec <= 21) {
+ /* Note from boost (www.boost.org):
+ * Changed from Sleep(0) to Sleep(1).
+ * According to MSDN, Sleep(0) will never yield to a lower-priority thread,
+ * whereas Sleep(1) will. Performance seems not to be affected. */
+ Sleep(1);
+ } else {
+ Sleep(1 << (__log_nsec - 20));
+ }
+# if defined (_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400)
+ __iteration = 0; //reset to avoid sleeps sequence
+ }
+# endif
+# elif defined(_STLP_OS2THREADS)
+ if (__log_nsec <= 20) {
+ DosSleep(0);
+ } else {
+ DosSleep(1 << (__log_nsec - 20));
+ }
+# elif defined (_STLP_UNIX)
+ timespec __ts;
+ /* Max sleep is 2**27nsec ~ 60msec */
+ __ts.tv_sec = 0;
+ __ts.tv_nsec = 1 << __log_nsec;
+ _STLP_NANOSLEEP(&__ts, 0);
+# endif
+}
+
+template <int __inst>
+void _STLP_CALL
+_STLP_mutex_spin<__inst>::_M_do_lock(volatile __stl_atomic_t* __lock) {
+# if defined(_STLP_ATOMIC_EXCHANGE)
+ if (_Atomic_swap(__lock, 1)) {
+ unsigned __my_spin_max = _STLP_mutex_spin<0>::__max;
+ unsigned __my_last_spins = _STLP_mutex_spin<0>::__last;
+ volatile unsigned __junk = 17; // Value doesn't matter.
+ unsigned __i;
+
+ for (__i = 0; __i < __my_spin_max; ++__i) {
+ if (__i < __my_last_spins/2 || *__lock) {
+ __junk *= __junk; __junk *= __junk;
+ __junk *= __junk; __junk *= __junk;
+ } else {
+ if (!_Atomic_swap(__lock, 1)) {
+ // got it!
+ // Spinning worked. Thus we're probably not being scheduled
+ // against the other process with which we were contending.
+ // Thus it makes sense to spin longer the next time.
+ _STLP_mutex_spin<0>::__last = __i;
+ _STLP_mutex_spin<0>::__max = _STLP_mutex_spin<0>::__high_max;
+ return;
+ }
+ }
+ }
+
+ // We are probably being scheduled against the other process. Sleep.
+ _STLP_mutex_spin<0>::__max = _STLP_mutex_spin<0>::__low_max;
+
+ for (__i = 0 ;; ++__i) {
+ int __log_nsec = __i + 6;
+
+ if (__log_nsec > 27) __log_nsec = 27;
+ if (!_Atomic_swap(__lock, 1)) {
+ break;
+ }
+ _S_nsec_sleep(__log_nsec, __i);
+ }
+ } /* first _Atomic_swap */
+# endif
+}
+#endif // _STLP_USE_PTHREAD_SPINLOCK
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_EXPOSE_GLOBALS_IMPLEMENTATION */
+#endif /* _STLP_THREADS_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_threads.h b/sources/android/stlport/stlport/stl/_threads.h
new file mode 100644
index 0000000..fe381d8
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_threads.h
@@ -0,0 +1,687 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+// WARNING: This is an internal header file, included by other C++
+// standard library headers. You should not attempt to use this header
+// file directly.
+
+
+#ifndef _STLP_INTERNAL_THREADS_H
+#define _STLP_INTERNAL_THREADS_H
+
+// Supported threading models are native SGI, pthreads, uithreads
+// (similar to pthreads, but based on an earlier draft of the Posix
+// threads standard), and Win32 threads. Uithread support by Jochen
+// Schlick, 1999, and Solaris threads generalized to them.
+
+#ifndef _STLP_INTERNAL_CSTDDEF
+# include <stl/_cstddef.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CSTDLIB
+# include <stl/_cstdlib.h>
+#endif
+
+// On SUN and Mac OS X gcc, zero-initialization works just fine...
+#if defined (__sun) || (defined (__GNUC__) && defined(__APPLE__))
+# define _STLP_MUTEX_INITIALIZER
+#endif
+
+/* This header defines the following atomic operation that platform should
+ * try to support as much as possible. Atomic operation are exposed as macro
+ * in order to easily test for their existance. They are:
+ * __stl_atomic_t _STLP_ATOMIC_INCREMENT(volatile __stl_atomic_t* __ptr) :
+ * increment *__ptr by 1 and returns the new value
+ * __stl_atomic_t _STLP_ATOMIC_DECREMENT(volatile __stl_atomic_t* __ptr) :
+ * decrement *__ptr by 1 and returns the new value
+ * __stl_atomic_t _STLP_ATOMIC_EXCHANGE(volatile __stl_atomic_t* __target, __stl_atomic_t __val) :
+ * assign __val to *__target and returns former *__target value
+ * void* _STLP_ATOMIC_EXCHANGE_PTR(void* volatile* __target, void* __ptr) :
+ * assign __ptr to *__target and returns former *__target value
+ */
+
+#if defined (_STLP_THREADS)
+
+# if defined (_STLP_SGI_THREADS)
+
+# include <mutex.h>
+// Hack for SGI o32 compilers.
+# if !defined(__add_and_fetch) && \
+ (__mips < 3 || !(defined (_ABIN32) || defined(_ABI64)))
+# define __add_and_fetch(__l,__v) add_then_test((unsigned long*)__l,__v)
+# define __test_and_set(__l,__v) test_and_set(__l,__v)
+# endif /* o32 */
+
+# if __mips < 3 || !(defined (_ABIN32) || defined(_ABI64))
+# define _STLP_ATOMIC_EXCHANGE(__p, __q) test_and_set(__p, __q)
+# else
+# define _STLP_ATOMIC_EXCHANGE(__p, __q) __test_and_set((unsigned long*)__p, (unsigned long)__q)
+# endif
+
+# define _STLP_ATOMIC_INCREMENT(__x) __add_and_fetch(__x, 1)
+# define _STLP_ATOMIC_DECREMENT(__x) __add_and_fetch(__x, (size_t) -1)
+typedef long __stl_atomic_t;
+
+# elif defined (_STLP_PTHREADS)
+
+# include <pthread.h>
+# if !defined (_STLP_USE_PTHREAD_SPINLOCK)
+# if defined (PTHREAD_MUTEX_INITIALIZER) && !defined (_STLP_MUTEX_INITIALIZER) && defined (_REENTRANT)
+# define _STLP_MUTEX_INITIALIZER = { PTHREAD_MUTEX_INITIALIZER }
+# endif
+//HPUX variants have (on some platforms optional) non-standard "DCE" pthreads impl
+# if defined (_DECTHREADS_) && (defined (_PTHREAD_USE_D4) || defined (__hpux)) && !defined (_CMA_SUPPRESS_EXTERNALS_)
+# define _STLP_PTHREAD_ATTR_DEFAULT pthread_mutexattr_default
+# else
+# define _STLP_PTHREAD_ATTR_DEFAULT 0
+# endif
+# else
+# if defined (__OpenBSD__)
+# include <spinlock.h>
+# endif
+# endif
+
+# if defined (__GNUC__) && defined (__i386__)
+# if !defined (_STLP_ATOMIC_INCREMENT)
+inline long _STLP_atomic_increment_gcc_x86(long volatile* p) {
+ long result;
+ __asm__ __volatile__
+ ("lock; xaddl %1, %0;"
+ :"=m" (*p), "=r" (result)
+ :"m" (*p), "1" (1)
+ :"cc");
+ return result + 1;
+}
+# define _STLP_ATOMIC_INCREMENT(__x) (_STLP_atomic_increment_gcc_x86((long volatile*)__x))
+# endif
+
+# if !defined (_STLP_ATOMIC_DECREMENT)
+inline long _STLP_atomic_decrement_gcc_x86(long volatile* p) {
+ long result;
+ __asm__ __volatile__
+ ("lock; xaddl %1, %0;"
+ :"=m" (*p), "=r" (result)
+ :"m" (*p), "1" (-1)
+ :"cc");
+ return result - 1;
+}
+# define _STLP_ATOMIC_DECREMENT(__x) (_STLP_atomic_decrement_gcc_x86((long volatile*)__x))
+# endif
+typedef long __stl_atomic_t;
+# else
+typedef size_t __stl_atomic_t;
+# endif /* if defined(__GNUC__) && defined(__i386__) */
+
+# elif defined (_STLP_WIN32THREADS)
+
+# if !defined (_STLP_ATOMIC_INCREMENT)
+# if !defined (_STLP_NEW_PLATFORM_SDK)
+# define _STLP_ATOMIC_INCREMENT(__x) InterlockedIncrement(__CONST_CAST(long*, __x))
+# define _STLP_ATOMIC_DECREMENT(__x) InterlockedDecrement(__CONST_CAST(long*, __x))
+# define _STLP_ATOMIC_EXCHANGE(__x, __y) InterlockedExchange(__CONST_CAST(long*, __x), __y)
+# else
+# define _STLP_ATOMIC_INCREMENT(__x) InterlockedIncrement(__x)
+# define _STLP_ATOMIC_DECREMENT(__x) InterlockedDecrement(__x)
+# define _STLP_ATOMIC_EXCHANGE(__x, __y) InterlockedExchange(__x, __y)
+# endif
+# define _STLP_ATOMIC_EXCHANGE_PTR(__x, __y) STLPInterlockedExchangePointer(__x, __y)
+# endif
+typedef long __stl_atomic_t;
+
+# elif defined (__DECC) || defined (__DECCXX)
+
+# include <machine/builtins.h>
+# define _STLP_ATOMIC_EXCHANGE __ATOMIC_EXCH_LONG
+# define _STLP_ATOMIC_INCREMENT(__x) __ATOMIC_ADD_LONG(__x, 1)
+# define _STLP_ATOMIC_DECREMENT(__x) __ATOMIC_ADD_LONG(__x, -1)
+typedef long __stl_atomic_t;
+
+# elif defined (_STLP_SPARC_SOLARIS_THREADS)
+
+typedef long __stl_atomic_t;
+# include <stl/_sparc_atomic.h>
+
+# elif defined (_STLP_UITHREADS)
+
+// this inclusion is potential hazard to bring up all sorts
+// of old-style headers. Let's assume vendor already know how
+// to deal with that.
+# ifndef _STLP_INTERNAL_CTIME
+# include <stl/_ctime.h>
+# endif
+# if defined (_STLP_USE_NAMESPACES) && ! defined (_STLP_VENDOR_GLOBAL_CSTD)
+using _STLP_VENDOR_CSTD::time_t;
+# endif
+# include <synch.h>
+# ifndef _STLP_INTERNAL_CSTDIO
+# include <stl/_cstdio.h>
+# endif
+# ifndef _STLP_INTERNAL_CWCHAR
+# include <stl/_cwchar.h>
+# endif
+typedef size_t __stl_atomic_t;
+
+# elif defined (_STLP_BETHREADS)
+
+# include <OS.h>
+# include <cassert>
+# include <stdio.h>
+# define _STLP_MUTEX_INITIALIZER = { 0 }
+typedef size_t __stl_atomic_t;
+
+# elif defined (_STLP_NWTHREADS)
+
+# include <nwthread.h>
+# include <nwsemaph.h>
+typedef size_t __stl_atomic_t;
+
+# elif defined(_STLP_OS2THREADS)
+
+# if defined (__GNUC__)
+# define INCL_DOSSEMAPHORES
+# include <os2.h>
+# else
+// This section serves to replace os2.h for VisualAge C++
+ typedef unsigned long ULONG;
+# if !defined (__HEV__) /* INCL_SEMAPHORE may also define HEV */
+# define __HEV__
+ typedef ULONG HEV;
+ typedef HEV* PHEV;
+# endif
+ typedef ULONG APIRET;
+ typedef ULONG HMTX;
+ typedef HMTX* PHMTX;
+ typedef const char* PCSZ;
+ typedef ULONG BOOL32;
+ APIRET _System DosCreateMutexSem(PCSZ pszName, PHEV phev, ULONG flAttr, BOOL32 fState);
+ APIRET _System DosRequestMutexSem(HMTX hmtx, ULONG ulTimeout);
+ APIRET _System DosReleaseMutexSem(HMTX hmtx);
+ APIRET _System DosCloseMutexSem(HMTX hmtx);
+# define _STLP_MUTEX_INITIALIZER = { 0 }
+# endif /* GNUC */
+typedef size_t __stl_atomic_t;
+
+# else
+
+typedef size_t __stl_atomic_t;
+
+# endif
+
+#else
+/* no threads */
+# define _STLP_ATOMIC_INCREMENT(__x) ++(*__x)
+# define _STLP_ATOMIC_DECREMENT(__x) --(*__x)
+/* We do not grant other atomic operations as they are useless if STLport do not have
+ * to be thread safe
+ */
+typedef size_t __stl_atomic_t;
+#endif
+
+#if !defined (_STLP_MUTEX_INITIALIZER)
+# if defined(_STLP_ATOMIC_EXCHANGE)
+# define _STLP_MUTEX_INITIALIZER = { 0 }
+# elif defined(_STLP_UITHREADS)
+# define _STLP_MUTEX_INITIALIZER = { DEFAULTMUTEX }
+# else
+# define _STLP_MUTEX_INITIALIZER
+# endif
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_THREADS) && !defined (_STLP_USE_PTHREAD_SPINLOCK)
+// Helper struct. This is a workaround for various compilers that don't
+// handle static variables in inline functions properly.
+template <int __inst>
+struct _STLP_mutex_spin {
+ enum { __low_max = 30, __high_max = 1000 };
+ // Low if we suspect uniprocessor, high for multiprocessor.
+ static unsigned __max;
+ static unsigned __last;
+ static void _STLP_CALL _M_do_lock(volatile __stl_atomic_t* __lock);
+ static void _STLP_CALL _S_nsec_sleep(int __log_nsec, unsigned int& __iteration);
+};
+#endif // !_STLP_USE_PTHREAD_SPINLOCK
+
+// Locking class. Note that this class *does not have a constructor*.
+// It must be initialized either statically, with _STLP_MUTEX_INITIALIZER,
+// or dynamically, by explicitly calling the _M_initialize member function.
+// (This is similar to the ways that a pthreads mutex can be initialized.)
+// There are explicit member functions for acquiring and releasing the lock.
+
+// There is no constructor because static initialization is essential for
+// some uses, and only a class aggregate (see section 8.5.1 of the C++
+// standard) can be initialized that way. That means we must have no
+// constructors, no base classes, no virtual functions, and no private or
+// protected members.
+
+// For non-static cases, clients should use _STLP_mutex.
+
+struct _STLP_CLASS_DECLSPEC _STLP_mutex_base {
+#if defined (_STLP_ATOMIC_EXCHANGE) || defined (_STLP_SGI_THREADS)
+ // It should be relatively easy to get this to work on any modern Unix.
+ volatile __stl_atomic_t _M_lock;
+#endif
+
+#if defined (_STLP_THREADS)
+# if defined (_STLP_ATOMIC_EXCHANGE)
+ inline void _M_initialize() { _M_lock = 0; }
+ inline void _M_destroy() {}
+
+ void _M_acquire_lock() {
+ _STLP_mutex_spin<0>::_M_do_lock(&_M_lock);
+ }
+
+ inline void _M_release_lock() {
+ volatile __stl_atomic_t* __lock = &_M_lock;
+# if defined(_STLP_SGI_THREADS) && defined(__GNUC__) && __mips >= 3
+ asm("sync");
+ *__lock = 0;
+# elif defined(_STLP_SGI_THREADS) && __mips >= 3 && \
+ (defined (_ABIN32) || defined(_ABI64))
+ __lock_release(__lock);
+# elif defined (_STLP_SPARC_SOLARIS_THREADS)
+# if defined (__WORD64) || defined (__arch64__) || defined (__sparcv9) || defined (__sparcv8plus)
+ asm("membar #StoreStore ; membar #LoadStore");
+# else
+ asm(" stbar ");
+# endif
+ *__lock = 0;
+# else
+ *__lock = 0;
+ // This is not sufficient on many multiprocessors, since
+ // writes to protected variables and the lock may be reordered.
+# endif
+ }
+# elif defined (_STLP_PTHREADS)
+# if defined (_STLP_USE_PTHREAD_SPINLOCK)
+# if !defined (__OpenBSD__)
+ pthread_spinlock_t _M_lock;
+ inline void _M_initialize() { pthread_spin_init( &_M_lock, 0 ); }
+ inline void _M_destroy() { pthread_spin_destroy( &_M_lock ); }
+
+ // sorry, but no static initializer for pthread_spinlock_t;
+ // this will not work for compilers that has problems with call
+ // constructor of static object...
+
+ // _STLP_mutex_base()
+ // { pthread_spin_init( &_M_lock, 0 ); }
+
+ // ~_STLP_mutex_base()
+ // { pthread_spin_destroy( &_M_lock ); }
+
+ inline void _M_acquire_lock() { pthread_spin_lock( &_M_lock ); }
+ inline void _M_release_lock() { pthread_spin_unlock( &_M_lock ); }
+# else // __OpenBSD__
+ spinlock_t _M_lock;
+ inline void _M_initialize() { _SPINLOCK_INIT( &_M_lock ); }
+ inline void _M_destroy() { }
+ inline void _M_acquire_lock() { _SPINLOCK( &_M_lock ); }
+ inline void _M_release_lock() { _SPINUNLOCK( &_M_lock ); }
+# endif // __OpenBSD__
+# else // !_STLP_USE_PTHREAD_SPINLOCK
+ pthread_mutex_t _M_lock;
+ inline void _M_initialize()
+ { pthread_mutex_init(&_M_lock,_STLP_PTHREAD_ATTR_DEFAULT); }
+ inline void _M_destroy()
+ { pthread_mutex_destroy(&_M_lock); }
+ inline void _M_acquire_lock() {
+# if defined ( __hpux ) && ! defined (PTHREAD_MUTEX_INITIALIZER)
+ if (!_M_lock.field1) _M_initialize();
+# endif
+ pthread_mutex_lock(&_M_lock);
+ }
+ inline void _M_release_lock() { pthread_mutex_unlock(&_M_lock); }
+# endif // !_STLP_USE_PTHREAD_SPINLOCK
+
+# elif defined (_STLP_UITHREADS)
+ mutex_t _M_lock;
+ inline void _M_initialize()
+ { mutex_init(&_M_lock, 0, NULL); }
+ inline void _M_destroy()
+ { mutex_destroy(&_M_lock); }
+ inline void _M_acquire_lock() { mutex_lock(&_M_lock); }
+ inline void _M_release_lock() { mutex_unlock(&_M_lock); }
+
+# elif defined (_STLP_OS2THREADS)
+ HMTX _M_lock;
+ inline void _M_initialize() { DosCreateMutexSem(NULL, &_M_lock, 0, false); }
+ inline void _M_destroy() { DosCloseMutexSem(_M_lock); }
+ inline void _M_acquire_lock() {
+ if (!_M_lock) _M_initialize();
+ DosRequestMutexSem(_M_lock, SEM_INDEFINITE_WAIT);
+ }
+ inline void _M_release_lock() { DosReleaseMutexSem(_M_lock); }
+# elif defined (_STLP_BETHREADS)
+ sem_id sem;
+ inline void _M_initialize() {
+ sem = create_sem(1, "STLPort");
+ assert(sem > 0);
+ }
+ inline void _M_destroy() {
+ int t = delete_sem(sem);
+ assert(t == B_NO_ERROR);
+ }
+ inline void _M_acquire_lock();
+ inline void _M_release_lock() {
+ status_t t = release_sem(sem);
+ assert(t == B_NO_ERROR);
+ }
+# elif defined (_STLP_NWTHREADS)
+ LONG _M_lock;
+ inline void _M_initialize()
+ { _M_lock = OpenLocalSemaphore(1); }
+ inline void _M_destroy()
+ { CloseLocalSemaphore(_M_lock); }
+ inline void _M_acquire_lock()
+ { WaitOnLocalSemaphore(_M_lock); }
+ inline void _M_release_lock() { SignalLocalSemaphore(_M_lock); }
+# else //*ty 11/24/2001 - added configuration check
+# error "Unknown thread facility configuration"
+# endif
+#else /* No threads */
+ inline void _M_initialize() {}
+ inline void _M_destroy() {}
+ inline void _M_acquire_lock() {}
+ inline void _M_release_lock() {}
+#endif // _STLP_PTHREADS
+};
+
+// Locking class. The constructor initializes the lock, the destructor destroys it.
+// Well - behaving class, does not need static initializer
+
+class _STLP_CLASS_DECLSPEC _STLP_mutex : public _STLP_mutex_base {
+ public:
+ inline _STLP_mutex () { _M_initialize(); }
+ inline ~_STLP_mutex () { _M_destroy(); }
+ private:
+ _STLP_mutex(const _STLP_mutex&);
+ void operator=(const _STLP_mutex&);
+};
+
+// A locking class that uses _STLP_STATIC_MUTEX. The constructor takes
+// a reference to an _STLP_STATIC_MUTEX, and acquires a lock. The destructor
+// releases the lock.
+// It's not clear that this is exactly the right functionality.
+// It will probably change in the future.
+
+struct _STLP_CLASS_DECLSPEC _STLP_auto_lock {
+ _STLP_auto_lock(_STLP_STATIC_MUTEX& __lock) : _M_lock(__lock)
+ { _M_lock._M_acquire_lock(); }
+ ~_STLP_auto_lock()
+ { _M_lock._M_release_lock(); }
+
+private:
+ _STLP_STATIC_MUTEX& _M_lock;
+ void operator=(const _STLP_auto_lock&);
+ _STLP_auto_lock(const _STLP_auto_lock&);
+};
+
+/*
+ * Class _Refcount_Base provides a type, __stl_atomic_t, a data member,
+ * _M_ref_count, and member functions _M_incr and _M_decr, which perform
+ * atomic preincrement/predecrement. The constructor initializes
+ * _M_ref_count.
+ */
+class _STLP_CLASS_DECLSPEC _Refcount_Base {
+ // The data member _M_ref_count
+#if defined (__DMC__)
+public:
+#endif
+ _STLP_VOLATILE __stl_atomic_t _M_ref_count;
+
+#if defined (_STLP_THREADS) && \
+ (!defined (_STLP_ATOMIC_INCREMENT) || !defined (_STLP_ATOMIC_DECREMENT) || \
+ defined (_STLP_WIN95_LIKE))
+# define _STLP_USE_MUTEX
+ _STLP_mutex _M_mutex;
+#endif
+
+ public:
+ // Constructor
+ _Refcount_Base(__stl_atomic_t __n) : _M_ref_count(__n) {}
+#if defined (__BORLANDC__)
+ ~_Refcount_Base(){};
+#endif
+
+ // _M_incr and _M_decr
+#if defined (_STLP_THREADS)
+# if !defined (_STLP_USE_MUTEX)
+ __stl_atomic_t _M_incr() { return _STLP_ATOMIC_INCREMENT(&_M_ref_count); }
+ __stl_atomic_t _M_decr() { return _STLP_ATOMIC_DECREMENT(&_M_ref_count); }
+# else
+# undef _STLP_USE_MUTEX
+ __stl_atomic_t _M_incr() {
+ _STLP_auto_lock l(_M_mutex);
+ return ++_M_ref_count;
+ }
+ __stl_atomic_t _M_decr() {
+ _STLP_auto_lock l(_M_mutex);
+ return --_M_ref_count;
+ }
+# endif
+#else /* No threads */
+ __stl_atomic_t _M_incr() { return ++_M_ref_count; }
+ __stl_atomic_t _M_decr() { return --_M_ref_count; }
+#endif
+};
+
+/* Atomic swap on __stl_atomic_t
+ * This is guaranteed to behave as though it were atomic only if all
+ * possibly concurrent updates use _Atomic_swap.
+ * In some cases the operation is emulated with a lock.
+ * Idem for _Atomic_swap_ptr
+ */
+/* Helper struct to handle following cases:
+ * - on platforms where sizeof(__stl_atomic_t) == sizeof(void*) atomic
+ * exchange can be done on pointers
+ * - on platform without atomic operation swap is done in a critical section,
+ * portable but inefficient.
+ */
+template <int __use_ptr_atomic_swap>
+class _Atomic_swap_struct {
+public:
+#if defined (_STLP_THREADS) && \
+ !defined (_STLP_ATOMIC_EXCHANGE) && \
+ (defined (_STLP_PTHREADS) || defined (_STLP_UITHREADS) || defined (_STLP_OS2THREADS) || \
+ defined (_STLP_USE_PTHREAD_SPINLOCK) || defined (_STLP_NWTHREADS))
+# define _STLP_USE_ATOMIC_SWAP_MUTEX
+ static _STLP_STATIC_MUTEX _S_swap_lock;
+#endif
+
+ static __stl_atomic_t _S_swap(_STLP_VOLATILE __stl_atomic_t* __p, __stl_atomic_t __q) {
+#if defined (_STLP_THREADS)
+# if defined (_STLP_ATOMIC_EXCHANGE)
+ return _STLP_ATOMIC_EXCHANGE(__p, __q);
+# elif defined (_STLP_USE_ATOMIC_SWAP_MUTEX)
+ _S_swap_lock._M_acquire_lock();
+ __stl_atomic_t __result = *__p;
+ *__p = __q;
+ _S_swap_lock._M_release_lock();
+ return __result;
+# else
+# error Missing atomic swap implementation
+# endif
+#else
+ /* no threads */
+ __stl_atomic_t __result = *__p;
+ *__p = __q;
+ return __result;
+#endif // _STLP_THREADS
+ }
+
+ static void* _S_swap_ptr(void* _STLP_VOLATILE* __p, void* __q) {
+#if defined (_STLP_THREADS)
+# if defined (_STLP_ATOMIC_EXCHANGE_PTR)
+ return _STLP_ATOMIC_EXCHANGE_PTR(__p, __q);
+# elif defined (_STLP_ATOMIC_EXCHANGE)
+ _STLP_STATIC_ASSERT(sizeof(__stl_atomic_t) == sizeof(void*))
+ return __REINTERPRET_CAST(void*, _STLP_ATOMIC_EXCHANGE(__REINTERPRET_CAST(volatile __stl_atomic_t*, __p),
+ __REINTERPRET_CAST(__stl_atomic_t, __q))
+ );
+# elif defined (_STLP_USE_ATOMIC_SWAP_MUTEX)
+ _S_swap_lock._M_acquire_lock();
+ void *__result = *__p;
+ *__p = __q;
+ _S_swap_lock._M_release_lock();
+ return __result;
+# else
+# error Missing pointer atomic swap implementation
+# endif
+#else
+ /* no thread */
+ void *__result = *__p;
+ *__p = __q;
+ return __result;
+#endif
+ }
+};
+
+_STLP_TEMPLATE_NULL
+class _Atomic_swap_struct<0> {
+public:
+#if defined (_STLP_THREADS) && \
+ (!defined (_STLP_ATOMIC_EXCHANGE) || !defined (_STLP_ATOMIC_EXCHANGE_PTR)) && \
+ (defined (_STLP_PTHREADS) || defined (_STLP_UITHREADS) || defined (_STLP_OS2THREADS) || \
+ defined (_STLP_USE_PTHREAD_SPINLOCK) || defined (_STLP_NWTHREADS))
+# define _STLP_USE_ATOMIC_SWAP_MUTEX
+ static _STLP_STATIC_MUTEX _S_swap_lock;
+#endif
+
+ static __stl_atomic_t _S_swap(_STLP_VOLATILE __stl_atomic_t* __p, __stl_atomic_t __q) {
+#if defined (_STLP_THREADS)
+# if defined (_STLP_ATOMIC_EXCHANGE)
+ return _STLP_ATOMIC_EXCHANGE(__p, __q);
+# elif defined (_STLP_USE_ATOMIC_SWAP_MUTEX)
+ /* This should be portable, but performance is expected
+ * to be quite awful. This really needs platform specific
+ * code.
+ */
+ _S_swap_lock._M_acquire_lock();
+ __stl_atomic_t __result = *__p;
+ *__p = __q;
+ _S_swap_lock._M_release_lock();
+ return __result;
+# else
+# error Missing atomic swap implementation
+# endif
+#else
+ /* no threads */
+ __stl_atomic_t __result = *__p;
+ *__p = __q;
+ return __result;
+#endif // _STLP_THREADS
+ }
+
+ static void* _S_swap_ptr(void* _STLP_VOLATILE* __p, void* __q) {
+#if defined (_STLP_THREADS)
+# if defined (_STLP_ATOMIC_EXCHANGE_PTR)
+ return _STLP_ATOMIC_EXCHANGE_PTR(__p, __q);
+# elif defined (_STLP_ATOMIC_EXCHANGE)
+ _STLP_STATIC_ASSERT(sizeof(__stl_atomic_t) == sizeof(void*))
+ return __REINTERPRET_CAST(void*, _STLP_ATOMIC_EXCHANGE(__REINTERPRET_CAST(volatile __stl_atomic_t*, __p),
+ __REINTERPRET_CAST(__stl_atomic_t, __q))
+ );
+# elif defined (_STLP_USE_ATOMIC_SWAP_MUTEX)
+ _S_swap_lock._M_acquire_lock();
+ void *__result = *__p;
+ *__p = __q;
+ _S_swap_lock._M_release_lock();
+ return __result;
+# else
+# error Missing pointer atomic swap implementation
+# endif
+#else
+ /* no thread */
+ void *__result = *__p;
+ *__p = __q;
+ return __result;
+#endif
+ }
+};
+
+#if defined (_STLP_MSVC) && (_STLP_MSVC == 1300)
+# pragma warning (push)
+# pragma warning (disable : 4189) //__use_ptr_atomic_swap initialized but not used
+#endif
+
+inline __stl_atomic_t _STLP_CALL _Atomic_swap(_STLP_VOLATILE __stl_atomic_t * __p, __stl_atomic_t __q) {
+ const int __use_ptr_atomic_swap = sizeof(__stl_atomic_t) == sizeof(void*);
+ return _Atomic_swap_struct<__use_ptr_atomic_swap>::_S_swap(__p, __q);
+}
+
+inline void* _STLP_CALL _Atomic_swap_ptr(void* _STLP_VOLATILE* __p, void* __q) {
+ const int __use_ptr_atomic_swap = sizeof(__stl_atomic_t) == sizeof(void*);
+ return _Atomic_swap_struct<__use_ptr_atomic_swap>::_S_swap_ptr(__p, __q);
+}
+
+#if defined (_STLP_MSVC) && (_STLP_MSVC == 1300)
+# pragma warning (pop)
+#endif
+
+#if defined (_STLP_BETHREADS)
+template <int __inst>
+struct _STLP_beos_static_lock_data {
+ static bool is_init;
+ struct mutex_t : public _STLP_mutex {
+ mutex_t()
+ { _STLP_beos_static_lock_data<0>::is_init = true; }
+ ~mutex_t()
+ { _STLP_beos_static_lock_data<0>::is_init = false; }
+ };
+ static mutex_t mut;
+};
+
+template <int __inst>
+bool _STLP_beos_static_lock_data<__inst>::is_init = false;
+template <int __inst>
+typename _STLP_beos_static_lock_data<__inst>::mutex_t _STLP_beos_static_lock_data<__inst>::mut;
+
+inline void _STLP_mutex_base::_M_acquire_lock() {
+ if (sem == 0) {
+ // we need to initialise on demand here
+ // to prevent race conditions use our global
+ // mutex if it's available:
+ if (_STLP_beos_static_lock_data<0>::is_init) {
+ _STLP_auto_lock al(_STLP_beos_static_lock_data<0>::mut);
+ if (sem == 0) _M_initialize();
+ }
+ else {
+ // no lock available, we must still be
+ // in startup code, THERE MUST BE ONE THREAD
+ // ONLY active at this point.
+ _M_initialize();
+ }
+ }
+ status_t t;
+ t = acquire_sem(sem);
+ assert(t == B_NO_ERROR);
+}
+#endif
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_threads.c>
+#endif
+
+#endif /* _STLP_INTERNAL_THREADS_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_time_facets.c b/sources/android/stlport/stlport/stl/_time_facets.c
new file mode 100644
index 0000000..f403817
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_time_facets.c
@@ -0,0 +1,441 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_TIME_FACETS_C
+#define _STLP_TIME_FACETS_C
+
+#ifndef _STLP_INTERNAL_TIME_FACETS_H
+# include <stl/_time_facets.h>
+#endif
+
+#ifndef _STLP_INTERNAL_NUM_PUT_H
+# include <stl/_num_put.h>
+#endif
+
+#ifndef _STLP_INTERNAL_NUM_GET_H
+# include <stl/_num_get.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//----------------------------------------------------------------------
+// Declarations of static template members.
+
+template <class _CharT, class _InputIterator>
+locale::id time_get<_CharT, _InputIterator>::id;
+
+template <class _CharT, class _OutputIterator>
+locale::id time_put<_CharT, _OutputIterator>::id;
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+/* Matching input against a list of names
+
+ * Alphabetic input of the names of months and the names
+ * of weekdays requires matching input against a list of names.
+ * We use a simple generic algorithm to accomplish this. This
+ * algorithm is not very efficient, especially for longer lists
+ * of names, but it probably does not matter for the initial
+ * implementation and it may never matter, since we do not expect
+ * this kind of input to be used very often. The algorithm
+ * could be improved fairly simply by creating a new list of
+ * names still in the running at each iteration. A more sophisticated
+ * approach would be to build a tree to do the matching.
+ *
+ * We compare each character of the input to the corresponding
+ * character of each name on the list that has not been eliminated,
+ * either because every character in the name has already been
+ * matched, or because some character has not been matched. We
+ * continue only as long as there are some names that have not been
+ * eliminated.
+
+ * We do not really need a random access iterator (a forward iterator
+ * would do), but the extra generality makes the notation clumsier,
+ * and we don't really need it.
+
+ * We can recognize a failed match by the fact that the return value
+ * will be __name_end.
+ */
+
+#define _MAXNAMES 24
+
+template <class _InIt, class _NameIt>
+size_t _STLP_CALL
+__match(_InIt& __first, _InIt& __last, _NameIt __name, _NameIt __name_end) {
+ typedef ptrdiff_t difference_type;
+ difference_type __n = __name_end - __name;
+ difference_type __i, __start = 0;
+ size_t __pos = 0;
+ difference_type __check_count = __n;
+ bool __do_not_check[_MAXNAMES];
+ size_t __matching_name_index = __n;
+
+ memset(__do_not_check, 0, sizeof(__do_not_check));
+
+ while (__first != __last) {
+ difference_type __new_n = __n;
+ for (__i = __start; __i < __n; ++__i) {
+ if (!__do_not_check[__i]) {
+ if (*__first == __name[__i][__pos]) {
+ if (__pos == (__name[__i].size() - 1)) {
+ __matching_name_index = __i;
+ __do_not_check[__i] = true;
+ if (__i == __start) ++__start;
+ --__check_count;
+ if (__check_count == 0) {
+ ++__first;
+ return __matching_name_index;
+ }
+ }
+ __new_n = __i + 1;
+ }
+ else {
+ __do_not_check[__i] = true;
+ if (__i == __start) ++__start;
+ --__check_count;
+ if (__check_count == 0)
+ return __matching_name_index;
+ }
+ }
+ else {
+ if (__i == __start) ++ __start;
+ }
+ }
+
+ __n = __new_n;
+ ++__first; ++__pos;
+ }
+
+ return __matching_name_index;
+}
+
+// __get_formatted_time reads input that is assumed to be formatted
+// according to the rules for the C strftime function (C standard,
+// 7.12.3.5). This function is used to implement the do_get_time
+// and do_get_date virtual functions, which depend on the locale
+// specifications for the time and day formats respectively.
+// Note the catchall default case, intended mainly for the '%Z'
+// format designator, which does not make sense here since the
+// representation of timezones is not part of the locale.
+//
+// The case branches are implemented either by doing a match using
+// the appopriate name table or by doing a __get_integer_nogroup.
+//
+// 'y' format is assumed to mean that the input represents years
+// since 1900. That is, 2002 should be represented as 102. There
+// is no century-guessing.
+//
+// The match is successful if and only if the second component of the
+// return value is format_end.
+
+// Note that the antepenultimate parameter is being used only to determine
+// the correct overloading for the calls to __get_integer_nogroup.
+template <class _InIt1, class _Ch, class _TimeInfo>
+string::const_iterator _STLP_CALL
+__get_formatted_time _STLP_WEAK (_InIt1 __first, _InIt1 __last,
+ string::const_iterator __format, string::const_iterator __format_end,
+ _Ch*, const _TimeInfo& __table,
+ const ios_base& __s, ios_base::iostate& __err, tm* __t) {
+ const ctype<_Ch>& __ct = use_facet<ctype<_Ch> >(__s.getloc());
+ typedef basic_string<_Ch, char_traits<_Ch>, allocator<_Ch> > string_type;
+ size_t offset;
+
+ while (__first != __last && __format != __format_end) {
+ offset = 0;
+ if (*__format == '%') {
+ ++__format;
+ char __c = *__format;
+ if (__c == '#') { //MS extension
+ ++__format;
+ __c = *__format;
+ }
+
+ switch (__c) {
+ case 'A':
+ offset = 7;
+ case 'a': {
+ size_t __index = __match(__first, __last,
+ __table._M_dayname + offset, __table._M_dayname + offset + 7);
+ if (__index == 7)
+ return __format;
+ __t->tm_wday = __STATIC_CAST(int, __index);
+ break;
+ }
+
+ case 'B':
+ offset = 12;
+ case 'b': {
+ size_t __index = __match(__first, __last,
+ __table._M_monthname + offset, __table._M_monthname + offset + 12);
+ if (__index == 12)
+ return __format;
+ __t->tm_mon = __STATIC_CAST(int, __index);
+ break;
+ }
+
+ case 'd': {
+ bool __pr = __get_decimal_integer(__first, __last, __t->tm_mday, __STATIC_CAST(_Ch*, 0));
+ if (!__pr || __t->tm_mday < 1 || __t->tm_mday > 31) {
+ __err |= ios_base::failbit;
+ return __format;
+ }
+ break;
+ }
+
+ case 'H': case 'I': {
+ bool __pr = __get_decimal_integer(__first, __last, __t->tm_hour, __STATIC_CAST(_Ch*, 0));
+ if (!__pr)
+ return __format;
+ break;
+ }
+
+ case 'j': {
+ bool __pr = __get_decimal_integer(__first, __last, __t->tm_yday, __STATIC_CAST(_Ch*, 0));
+ if (!__pr)
+ return __format;
+ break;
+ }
+
+ case 'm': {
+ bool __pr = __get_decimal_integer(__first, __last, __t->tm_mon, __STATIC_CAST(_Ch*, 0));
+ --__t->tm_mon;
+ if (!__pr || __t->tm_mon < 0 || __t->tm_mon > 11) {
+ __err |= ios_base::failbit;
+ return __format;
+ }
+ break;
+ }
+
+ case 'M': {
+ bool __pr = __get_decimal_integer(__first, __last, __t->tm_min, __STATIC_CAST(_Ch*, 0));
+ if (!__pr)
+ return __format;
+ break;
+ }
+
+ case 'p': {
+ size_t __index = __match(__first, __last,
+ __table._M_am_pm + 0, __table._M_am_pm + 2);
+ if (__index == 2)
+ return __format;
+ // 12:00 PM <=> 12:00, 12:00 AM <=> 00:00
+ if (__index == 1 && __t->tm_hour != 12 )
+ __t->tm_hour += 12;
+ if (__index == 0 && __t->tm_hour == 12 )
+ __t->tm_hour = 0;
+ break;
+ }
+
+ case 'S': {
+ bool __pr = __get_decimal_integer(__first, __last, __t->tm_sec, __STATIC_CAST(_Ch*, 0));
+ if (!__pr)
+ return __format;
+ break;
+ }
+
+ case 'y': {
+ bool __pr = __get_decimal_integer(__first, __last, __t->tm_year, __STATIC_CAST(_Ch*, 0));
+ if (!__pr)
+ return __format;
+ break;
+ }
+
+ case 'Y': {
+ bool __pr = __get_decimal_integer(__first, __last, __t->tm_year, __STATIC_CAST(_Ch*, 0));
+ __t->tm_year -= 1900;
+ if (!__pr)
+ return __format;
+ break;
+ }
+
+ default:
+ break;
+ }
+ }
+ else {
+ if (*__first++ != __ct.widen(*__format)) break;
+ }
+
+ ++__format;
+ }
+
+ return __format;
+}
+
+template <class _InIt, class _TimeInfo>
+bool _STLP_CALL
+__get_short_or_long_dayname(_InIt& __first, _InIt& __last, const _TimeInfo& __table, tm* __t) {
+ size_t __index = __match(__first, __last, __table._M_dayname + 0, __table._M_dayname + 14);
+ if (__index != 14) {
+ __t->tm_wday = __STATIC_CAST(int, __index % 7);
+ return true;
+ }
+ return false;
+}
+
+template <class _InIt, class _TimeInfo>
+bool _STLP_CALL
+__get_short_or_long_monthname(_InIt& __first, _InIt& __last, const _TimeInfo& __table, tm* __t) {
+ size_t __index = __match(__first, __last, __table._M_monthname + 0, __table._M_monthname + 24);
+ if (__index != 24) {
+ __t->tm_mon = __STATIC_CAST(int, __index % 12);
+ return true;
+ }
+ return false;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _Ch, class _InIt>
+_InIt
+time_get<_Ch, _InIt>::do_get_date(_InIt __s, _InIt __end,
+ ios_base& __str, ios_base::iostate& __err,
+ tm* __t) const {
+ typedef string::const_iterator string_iterator;
+
+ string_iterator __format = this->_M_timeinfo._M_date_format.begin();
+ string_iterator __format_end = this->_M_timeinfo._M_date_format.end();
+
+ string_iterator __result
+ = _STLP_PRIV __get_formatted_time(__s, __end, __format, __format_end,
+ __STATIC_CAST(_Ch*, 0), this->_M_timeinfo,
+ __str, __err, __t);
+ if (__result == __format_end)
+ __err = ios_base::goodbit;
+ else {
+ __err = ios_base::failbit;
+ if (__s == __end)
+ __err |= ios_base::eofbit;
+ }
+ return __s;
+}
+
+template <class _Ch, class _InIt>
+_InIt
+time_get<_Ch, _InIt>::do_get_time(_InIt __s, _InIt __end,
+ ios_base& __str, ios_base::iostate& __err,
+ tm* __t) const {
+ typedef string::const_iterator string_iterator;
+ string_iterator __format = this->_M_timeinfo._M_time_format.begin();
+ string_iterator __format_end = this->_M_timeinfo._M_time_format.end();
+
+ string_iterator __result
+ = _STLP_PRIV __get_formatted_time(__s, __end, __format, __format_end,
+ __STATIC_CAST(_Ch*, 0), this->_M_timeinfo,
+ __str, __err, __t);
+ __err = __result == __format_end ? ios_base::goodbit
+ : ios_base::failbit;
+ if (__s == __end)
+ __err |= ios_base::eofbit;
+ return __s;
+}
+
+template <class _Ch, class _InIt>
+_InIt
+time_get<_Ch, _InIt>::do_get_year(_InIt __s, _InIt __end,
+ ios_base&, ios_base::iostate& __err,
+ tm* __t) const {
+ if (__s == __end) {
+ __err = ios_base::failbit | ios_base::eofbit;
+ return __s;
+ }
+
+ bool __pr = _STLP_PRIV __get_decimal_integer(__s, __end, __t->tm_year, __STATIC_CAST(_Ch*, 0));
+ __t->tm_year -= 1900;
+ __err = __pr ? ios_base::goodbit : ios_base::failbit;
+ if (__s == __end)
+ __err |= ios_base::eofbit;
+
+ return __s;
+}
+
+template <class _Ch, class _InIt>
+_InIt
+time_get<_Ch, _InIt>::do_get_weekday(_InIt __s, _InIt __end,
+ ios_base &__str, ios_base::iostate &__err,
+ tm *__t) const {
+ bool __result =
+ _STLP_PRIV __get_short_or_long_dayname(__s, __end, this->_M_timeinfo, __t);
+ if (__result)
+ __err = ios_base::goodbit;
+ else {
+ __err = ios_base::failbit;
+ if (__s == __end)
+ __err |= ios_base::eofbit;
+ }
+ return __s;
+}
+
+template <class _Ch, class _InIt>
+_InIt
+time_get<_Ch, _InIt>::do_get_monthname(_InIt __s, _InIt __end,
+ ios_base &__str, ios_base::iostate &__err,
+ tm *__t) const {
+ bool __result =
+ _STLP_PRIV __get_short_or_long_monthname(__s, __end, this->_M_timeinfo, __t);
+ if (__result)
+ __err = ios_base::goodbit;
+ else {
+ __err = ios_base::failbit;
+ if (__s == __end)
+ __err |= ios_base::eofbit;
+ }
+ return __s;
+}
+
+template<class _Ch, class _OutputIter>
+_OutputIter
+time_put<_Ch,_OutputIter>::put(_OutputIter __s, ios_base& __f, _Ch __fill,
+ const tm* __tmb, const _Ch* __pat,
+ const _Ch* __pat_end) const {
+ const ctype<_Ch>& _Ct = use_facet<ctype<_Ch> >(__f.getloc());
+ while (__pat != __pat_end) {
+ char __c = _Ct.narrow(*__pat, 0);
+ if (__c == '%') {
+ char __mod = 0;
+ ++__pat;
+ __c = _Ct.narrow(*__pat++, 0);
+ if (__c == '#') { // MS extension
+ __mod = __c;
+ __c = _Ct.narrow(*__pat++, 0);
+ }
+ __s = do_put(__s, __f, __fill, __tmb, __c, __mod);
+ }
+ else
+ *__s++ = *__pat++;
+ }
+ return __s;
+}
+
+template<class _Ch, class _OutputIter>
+_OutputIter
+time_put<_Ch,_OutputIter>::do_put(_OutputIter __s, ios_base& __f, _Ch /* __fill */,
+ const tm* __tmb, char __format,
+ char __modifier ) const {
+ const ctype<_Ch>& __ct = use_facet<ctype<_Ch> >(__f.getloc());
+ _STLP_BASIC_IOSTRING(_Ch) __buf;
+ _STLP_PRIV __write_formatted_time(__buf, __ct, __format, __modifier, this->_M_timeinfo, __tmb);
+ return copy(__buf.begin(), __buf.end(), __s);
+}
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_TIME_FACETS_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_time_facets.h b/sources/android/stlport/stlport/stl/_time_facets.h
new file mode 100644
index 0000000..e67c2f4
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_time_facets.h
@@ -0,0 +1,329 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+// WARNING: This is an internal header file, included by other C++
+// standard library headers. You should not attempt to use this header
+// file directly.
+
+
+#ifndef _STLP_INTERNAL_TIME_FACETS_H
+#define _STLP_INTERNAL_TIME_FACETS_H
+
+#ifndef _STLP_INTERNAL_CTIME
+# include <stl/_ctime.h> // Needed (for struct tm) by time facets
+#endif
+
+#ifndef _STLP_C_LOCALE_H
+# include <stl/c_locale.h>
+#endif
+
+#ifndef _STLP_IOS_BASE_H
+# include <stl/_ios_base.h>
+#endif
+
+#ifndef _STLP_INTERNAL_IOSTREAM_STRING_H
+# include <stl/_iostream_string.h>
+#endif
+
+#ifndef _STLP_FACETS_FWD_H
+# include <stl/_facets_fwd.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// Template functions used by time_get
+
+/* Both time_get and time_put need a structure of type _Time_Info
+ * to provide names and abbreviated names for months and days,
+ * as well as the am/pm designator. The month and weekday tables
+ * have the all the abbreviated names before all the full names.
+ * The _Time_Info tables are initialized using the non-template
+ * time_base class, which has a default constructor and two protected.
+ * The default one initialize _Time_Info with "C" time info. The
+ * protected initialize _time_Info using a _Locale_time instance
+ * or using a name( in fact the name is used to build a _Locale_time
+ * instance that is then used for initialization). */
+
+class _STLP_CLASS_DECLSPEC _Time_Info_Base {
+public:
+ string _M_time_format;
+ string _M_date_format;
+ string _M_date_time_format;
+ string _M_long_date_format;
+ string _M_long_date_time_format;
+};
+
+class _STLP_CLASS_DECLSPEC _Time_Info : public _Time_Info_Base {
+public:
+ string _M_dayname[14];
+ string _M_monthname[24];
+ string _M_am_pm[2];
+};
+
+#ifndef _STLP_NO_WCHAR_T
+class _STLP_CLASS_DECLSPEC _WTime_Info : public _Time_Info_Base {
+public:
+ wstring _M_dayname[14];
+ wstring _M_monthname[24];
+ wstring _M_am_pm[2];
+};
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+class _STLP_CLASS_DECLSPEC time_base {
+public:
+ enum dateorder {no_order, dmy, mdy, ymd, ydm};
+};
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Ch>
+class time_init;
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC time_init<char> {
+protected:
+ time_init();
+ time_init(const char *name);
+ time_init(_Locale_time*);
+#if defined (__BORLANDC__)
+ static
+#endif
+ _Time_Info _M_timeinfo;
+ time_base::dateorder _M_dateorder;
+};
+
+#ifndef _STLP_NO_WCHAR_T
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC time_init<wchar_t> {
+protected:
+ time_init();
+ time_init(const char *name);
+ time_init(_Locale_time*);
+#if defined (__BORLANDC__)
+ static
+#endif
+ _WTime_Info _M_timeinfo;
+ time_base::dateorder _M_dateorder;
+};
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _Ch, class _InIt>
+class time_get : public locale::facet, public time_base, public _STLP_PRIV time_init<_Ch> {
+public:
+ typedef _Ch char_type;
+ typedef _InIt iter_type;
+
+ explicit time_get(size_t __refs = 0) : locale::facet(__refs)
+ {}
+
+ dateorder date_order() const { return do_date_order(); }
+ iter_type get_time(iter_type __s, iter_type __end, ios_base& __str,
+ ios_base::iostate& __err, tm* __t) const
+ { return do_get_time(__s, __end, __str, __err, __t); }
+ iter_type get_date(iter_type __s, iter_type __end, ios_base& __str,
+ ios_base::iostate& __err, tm* __t) const
+ { return do_get_date(__s, __end, __str, __err, __t); }
+ iter_type get_weekday(iter_type __s, iter_type __end, ios_base& __str,
+ ios_base::iostate& __err, tm* __t) const
+ { return do_get_weekday(__s, __end, __str, __err, __t); }
+ iter_type get_monthname(iter_type __s, iter_type __end, ios_base& __str,
+ ios_base::iostate& __err, tm* __t) const
+ { return do_get_monthname(__s, __end, __str, __err, __t); }
+ iter_type get_year(iter_type __s, iter_type __end, ios_base& __str,
+ ios_base::iostate& __err, tm* __t) const
+ { return do_get_year(__s, __end, __str, __err, __t); }
+
+ static locale::id id;
+
+protected:
+ time_get(const char* __name, size_t __refs)
+ : locale::facet(__refs), _STLP_PRIV time_init<_Ch>(__name)
+ {}
+ time_get(_Locale_time *__time)
+ : _STLP_PRIV time_init<_Ch>(__time)
+ {}
+
+ ~time_get() {}
+
+ virtual dateorder do_date_order() const { return this->_M_dateorder; }
+
+ virtual iter_type do_get_time(iter_type __s, iter_type __end,
+ ios_base&, ios_base::iostate& __err,
+ tm* __t) const;
+
+ virtual iter_type do_get_date(iter_type __s, iter_type __end,
+ ios_base&, ios_base::iostate& __err,
+ tm* __t) const;
+
+ virtual iter_type do_get_weekday(iter_type __s, iter_type __end,
+ ios_base&,
+ ios_base::iostate& __err,
+ tm* __t) const;
+ virtual iter_type do_get_monthname(iter_type __s, iter_type __end,
+ ios_base&,
+ ios_base::iostate& __err,
+ tm* __t) const;
+
+ virtual iter_type do_get_year(iter_type __s, iter_type __end,
+ ios_base&, ios_base::iostate& __err,
+ tm* __t) const;
+};
+
+#if defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+template <class _Ch, class _InIt>
+#else
+template <class _Ch, class _InIt = istreambuf_iterator<_Ch, char_traits<_Ch> > >
+#endif
+class time_get_byname : public time_get<_Ch, _InIt> {
+ friend class _Locale_impl;
+public:
+ typedef time_base::dateorder dateorder;
+ typedef _InIt iter_type;
+
+ explicit time_get_byname(const char* __name, size_t __refs = 0)
+ : time_get<_Ch, _InIt>(__name, __refs) {}
+
+protected:
+ ~time_get_byname() {}
+ dateorder do_date_order() const { return this->_M_dateorder; }
+
+private:
+ time_get_byname(_Locale_time *__time)
+ : time_get<_Ch, _InIt>(__time)
+ {}
+
+ typedef time_get_byname<_Ch, _InIt> _Self;
+ //explicitely defined as private to avoid warnings:
+ time_get_byname(_Self const&);
+ _Self& operator = (_Self const&);
+};
+
+// time_put facet
+
+// For the formats 'x, 'X', and 'c', do_put calls the first form of
+// put with the pattern obtained from _M_timeinfo._M_date_format or
+// _M_timeinfo._M_time_format.
+
+// Helper function: __ takes a single-character
+// format. As indicated by the foregoing remark, this will never be
+// 'x', 'X', or 'c'.
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+_STLP_DECLSPEC void _STLP_CALL
+__write_formatted_time(__iostring&, const ctype<char>& __ct,
+ char __format, char __modifier,
+ const _Time_Info& __table, const tm* __t);
+
+#ifndef _STLP_NO_WCHAR_T
+_STLP_DECLSPEC void _STLP_CALL
+__write_formatted_time(__iowstring&, const ctype<wchar_t>& __ct,
+ char __format, char __modifier,
+ const _WTime_Info& __table, const tm* __t);
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _Ch, class _OutIt>
+class time_put : public locale::facet, public time_base, public _STLP_PRIV time_init<_Ch> {
+public:
+ typedef _Ch char_type;
+ typedef _OutIt iter_type;
+
+ explicit time_put(size_t __refs = 0) : locale::facet(__refs)
+ {}
+
+ _OutIt put(iter_type __s, ios_base& __f, _Ch __fill,
+ const tm* __tmb,
+ const _Ch* __pat, const _Ch* __pat_end) const;
+
+ _OutIt put(iter_type __s, ios_base& __f, _Ch __fill,
+ const tm* __tmb, char __format, char __modifier = 0) const
+ { return do_put(__s, __f, __fill, __tmb, __format, __modifier); }
+
+ static locale::id id;
+
+protected:
+ time_put(const char* __name, size_t __refs)
+ : locale::facet(__refs), _STLP_PRIV time_init<_Ch>(__name)
+ {}
+ time_put(_Locale_time *__time)
+ : _STLP_PRIV time_init<_Ch>(__time)
+ {}
+ ~time_put() {}
+ virtual iter_type do_put(iter_type __s, ios_base& __f,
+ char_type /* __fill */, const tm* __tmb,
+ char __format, char /* __modifier */) const;
+};
+
+#if defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+template <class _Ch, class _OutIt>
+#else
+template <class _Ch, class _OutIt = ostreambuf_iterator<_Ch, char_traits<_Ch> > >
+#endif
+class time_put_byname : public time_put<_Ch, _OutIt> {
+ friend class _Locale_impl;
+public:
+ typedef time_base::dateorder dateorder;
+ typedef _OutIt iter_type;
+ typedef _Ch char_type;
+
+ explicit time_put_byname(const char * __name, size_t __refs = 0)
+ : time_put<_Ch, _OutIt>(__name, __refs)
+ {}
+
+protected:
+ ~time_put_byname() {}
+
+private:
+ time_put_byname(_Locale_time *__time)
+ : time_put<_Ch, _OutIt>(__time)
+ {}
+
+ typedef time_put_byname<_Ch, _OutIt> _Self;
+ //explicitely defined as private to avoid warnings:
+ time_put_byname(_Self const&);
+ _Self& operator = (_Self const&);
+};
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS time_get<char, istreambuf_iterator<char, char_traits<char> > >;
+_STLP_EXPORT_TEMPLATE_CLASS time_put<char, ostreambuf_iterator<char, char_traits<char> > >;
+# if !defined (_STLP_NO_WCHAR_T)
+_STLP_EXPORT_TEMPLATE_CLASS time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
+_STLP_EXPORT_TEMPLATE_CLASS time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >;
+# endif
+
+#endif
+
+_STLP_END_NAMESPACE
+
+#if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_time_facets.c>
+#endif
+
+#endif /* _STLP_INTERNAL_TIME_FACETS_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_tree.c b/sources/android/stlport/stlport/stl/_tree.c
new file mode 100644
index 0000000..818fcc4
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_tree.c
@@ -0,0 +1,730 @@
+/*
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ * Modified CRP 7/10/00 for improved conformance / efficiency on insert_unique /
+ * insert_equal with valid hint -- efficiency is improved all around, and it is
+ * should now be standard conforming for complexity on insert point immediately
+ * after hint (amortized constant time).
+ *
+ */
+#ifndef _STLP_TREE_C
+#define _STLP_TREE_C
+
+#ifndef _STLP_INTERNAL_TREE_H
+# include <stl/_tree.h>
+#endif
+
+#if defined (_STLP_DEBUG)
+# define _Rb_tree _STLP_NON_DBG_NAME(Rb_tree)
+#endif
+
+// fbp: these defines are for outline methods definitions.
+// needed for definitions to be portable. Should not be used in method bodies.
+#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+# define __iterator__ _Rb_tree_iterator<_Value, _STLP_HEADER_TYPENAME _Traits::_NonConstTraits>
+# define __size_type__ size_t
+# define iterator __iterator__
+#else
+# define __iterator__ _STLP_TYPENAME_ON_RETURN_TYPE _Rb_tree<_Key, _Compare, _Value, _KeyOfValue, _Traits, _Alloc>::iterator
+# define __size_type__ _STLP_TYPENAME_ON_RETURN_TYPE _Rb_tree<_Key, _Compare, _Value, _KeyOfValue, _Traits, _Alloc>::size_type
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+#if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)
+
+template <class _Dummy> void _STLP_CALL
+_Rb_global<_Dummy>::_Rotate_left(_Rb_tree_node_base* __x,
+ _Rb_tree_node_base*& __root) {
+ _Rb_tree_node_base* __y = __x->_M_right;
+ __x->_M_right = __y->_M_left;
+ if (__y->_M_left != 0)
+ __y->_M_left->_M_parent = __x;
+ __y->_M_parent = __x->_M_parent;
+
+ if (__x == __root)
+ __root = __y;
+ else if (__x == __x->_M_parent->_M_left)
+ __x->_M_parent->_M_left = __y;
+ else
+ __x->_M_parent->_M_right = __y;
+ __y->_M_left = __x;
+ __x->_M_parent = __y;
+}
+
+template <class _Dummy> void _STLP_CALL
+_Rb_global<_Dummy>::_Rotate_right(_Rb_tree_node_base* __x,
+ _Rb_tree_node_base*& __root) {
+ _Rb_tree_node_base* __y = __x->_M_left;
+ __x->_M_left = __y->_M_right;
+ if (__y->_M_right != 0)
+ __y->_M_right->_M_parent = __x;
+ __y->_M_parent = __x->_M_parent;
+
+ if (__x == __root)
+ __root = __y;
+ else if (__x == __x->_M_parent->_M_right)
+ __x->_M_parent->_M_right = __y;
+ else
+ __x->_M_parent->_M_left = __y;
+ __y->_M_right = __x;
+ __x->_M_parent = __y;
+}
+
+template <class _Dummy> void _STLP_CALL
+_Rb_global<_Dummy>::_Rebalance(_Rb_tree_node_base* __x,
+ _Rb_tree_node_base*& __root) {
+ __x->_M_color = _S_rb_tree_red;
+ while (__x != __root && __x->_M_parent->_M_color == _S_rb_tree_red) {
+ if (__x->_M_parent == __x->_M_parent->_M_parent->_M_left) {
+ _Rb_tree_node_base* __y = __x->_M_parent->_M_parent->_M_right;
+ if (__y && __y->_M_color == _S_rb_tree_red) {
+ __x->_M_parent->_M_color = _S_rb_tree_black;
+ __y->_M_color = _S_rb_tree_black;
+ __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
+ __x = __x->_M_parent->_M_parent;
+ }
+ else {
+ if (__x == __x->_M_parent->_M_right) {
+ __x = __x->_M_parent;
+ _Rotate_left(__x, __root);
+ }
+ __x->_M_parent->_M_color = _S_rb_tree_black;
+ __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
+ _Rotate_right(__x->_M_parent->_M_parent, __root);
+ }
+ }
+ else {
+ _Rb_tree_node_base* __y = __x->_M_parent->_M_parent->_M_left;
+ if (__y && __y->_M_color == _S_rb_tree_red) {
+ __x->_M_parent->_M_color = _S_rb_tree_black;
+ __y->_M_color = _S_rb_tree_black;
+ __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
+ __x = __x->_M_parent->_M_parent;
+ }
+ else {
+ if (__x == __x->_M_parent->_M_left) {
+ __x = __x->_M_parent;
+ _Rotate_right(__x, __root);
+ }
+ __x->_M_parent->_M_color = _S_rb_tree_black;
+ __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
+ _Rotate_left(__x->_M_parent->_M_parent, __root);
+ }
+ }
+ }
+ __root->_M_color = _S_rb_tree_black;
+}
+
+template <class _Dummy> _Rb_tree_node_base* _STLP_CALL
+_Rb_global<_Dummy>::_Rebalance_for_erase(_Rb_tree_node_base* __z,
+ _Rb_tree_node_base*& __root,
+ _Rb_tree_node_base*& __leftmost,
+ _Rb_tree_node_base*& __rightmost) {
+ _Rb_tree_node_base* __y = __z;
+ _Rb_tree_node_base* __x;
+ _Rb_tree_node_base* __x_parent;
+
+ if (__y->_M_left == 0) // __z has at most one non-null child. y == z.
+ __x = __y->_M_right; // __x might be null.
+ else {
+ if (__y->_M_right == 0) // __z has exactly one non-null child. y == z.
+ __x = __y->_M_left; // __x is not null.
+ else { // __z has two non-null children. Set __y to
+ __y = _Rb_tree_node_base::_S_minimum(__y->_M_right); // __z's successor. __x might be null.
+ __x = __y->_M_right;
+ }
+ }
+
+ if (__y != __z) { // relink y in place of z. y is z's successor
+ __z->_M_left->_M_parent = __y;
+ __y->_M_left = __z->_M_left;
+ if (__y != __z->_M_right) {
+ __x_parent = __y->_M_parent;
+ if (__x) __x->_M_parent = __y->_M_parent;
+ __y->_M_parent->_M_left = __x; // __y must be a child of _M_left
+ __y->_M_right = __z->_M_right;
+ __z->_M_right->_M_parent = __y;
+ }
+ else
+ __x_parent = __y;
+ if (__root == __z)
+ __root = __y;
+ else if (__z->_M_parent->_M_left == __z)
+ __z->_M_parent->_M_left = __y;
+ else
+ __z->_M_parent->_M_right = __y;
+ __y->_M_parent = __z->_M_parent;
+ _STLP_STD::swap(__y->_M_color, __z->_M_color);
+ __y = __z;
+ // __y now points to node to be actually deleted
+ }
+ else { // __y == __z
+ __x_parent = __y->_M_parent;
+ if (__x) __x->_M_parent = __y->_M_parent;
+ if (__root == __z)
+ __root = __x;
+ else {
+ if (__z->_M_parent->_M_left == __z)
+ __z->_M_parent->_M_left = __x;
+ else
+ __z->_M_parent->_M_right = __x;
+ }
+
+ if (__leftmost == __z) {
+ if (__z->_M_right == 0) // __z->_M_left must be null also
+ __leftmost = __z->_M_parent;
+ // makes __leftmost == _M_header if __z == __root
+ else
+ __leftmost = _Rb_tree_node_base::_S_minimum(__x);
+ }
+ if (__rightmost == __z) {
+ if (__z->_M_left == 0) // __z->_M_right must be null also
+ __rightmost = __z->_M_parent;
+ // makes __rightmost == _M_header if __z == __root
+ else // __x == __z->_M_left
+ __rightmost = _Rb_tree_node_base::_S_maximum(__x);
+ }
+ }
+
+ if (__y->_M_color != _S_rb_tree_red) {
+ while (__x != __root && (__x == 0 || __x->_M_color == _S_rb_tree_black))
+ if (__x == __x_parent->_M_left) {
+ _Rb_tree_node_base* __w = __x_parent->_M_right;
+ if (__w->_M_color == _S_rb_tree_red) {
+ __w->_M_color = _S_rb_tree_black;
+ __x_parent->_M_color = _S_rb_tree_red;
+ _Rotate_left(__x_parent, __root);
+ __w = __x_parent->_M_right;
+ }
+ if ((__w->_M_left == 0 ||
+ __w->_M_left->_M_color == _S_rb_tree_black) && (__w->_M_right == 0 ||
+ __w->_M_right->_M_color == _S_rb_tree_black)) {
+ __w->_M_color = _S_rb_tree_red;
+ __x = __x_parent;
+ __x_parent = __x_parent->_M_parent;
+ } else {
+ if (__w->_M_right == 0 ||
+ __w->_M_right->_M_color == _S_rb_tree_black) {
+ if (__w->_M_left) __w->_M_left->_M_color = _S_rb_tree_black;
+ __w->_M_color = _S_rb_tree_red;
+ _Rotate_right(__w, __root);
+ __w = __x_parent->_M_right;
+ }
+ __w->_M_color = __x_parent->_M_color;
+ __x_parent->_M_color = _S_rb_tree_black;
+ if (__w->_M_right) __w->_M_right->_M_color = _S_rb_tree_black;
+ _Rotate_left(__x_parent, __root);
+ break;
+ }
+ } else { // same as above, with _M_right <-> _M_left.
+ _Rb_tree_node_base* __w = __x_parent->_M_left;
+ if (__w->_M_color == _S_rb_tree_red) {
+ __w->_M_color = _S_rb_tree_black;
+ __x_parent->_M_color = _S_rb_tree_red;
+ _Rotate_right(__x_parent, __root);
+ __w = __x_parent->_M_left;
+ }
+ if ((__w->_M_right == 0 ||
+ __w->_M_right->_M_color == _S_rb_tree_black) && (__w->_M_left == 0 ||
+ __w->_M_left->_M_color == _S_rb_tree_black)) {
+ __w->_M_color = _S_rb_tree_red;
+ __x = __x_parent;
+ __x_parent = __x_parent->_M_parent;
+ } else {
+ if (__w->_M_left == 0 ||
+ __w->_M_left->_M_color == _S_rb_tree_black) {
+ if (__w->_M_right) __w->_M_right->_M_color = _S_rb_tree_black;
+ __w->_M_color = _S_rb_tree_red;
+ _Rotate_left(__w, __root);
+ __w = __x_parent->_M_left;
+ }
+ __w->_M_color = __x_parent->_M_color;
+ __x_parent->_M_color = _S_rb_tree_black;
+ if (__w->_M_left) __w->_M_left->_M_color = _S_rb_tree_black;
+ _Rotate_right(__x_parent, __root);
+ break;
+ }
+ }
+ if (__x) __x->_M_color = _S_rb_tree_black;
+ }
+ return __y;
+}
+
+template <class _Dummy> _Rb_tree_node_base* _STLP_CALL
+_Rb_global<_Dummy>::_M_decrement(_Rb_tree_node_base* _M_node) {
+ if (_M_node->_M_color == _S_rb_tree_red && _M_node->_M_parent->_M_parent == _M_node)
+ _M_node = _M_node->_M_right;
+ else if (_M_node->_M_left != 0) {
+ _M_node = _Rb_tree_node_base::_S_maximum(_M_node->_M_left);
+ }
+ else {
+ _Base_ptr __y = _M_node->_M_parent;
+ while (_M_node == __y->_M_left) {
+ _M_node = __y;
+ __y = __y->_M_parent;
+ }
+ _M_node = __y;
+ }
+ return _M_node;
+}
+
+template <class _Dummy> _Rb_tree_node_base* _STLP_CALL
+_Rb_global<_Dummy>::_M_increment(_Rb_tree_node_base* _M_node) {
+ if (_M_node->_M_right != 0) {
+ _M_node = _Rb_tree_node_base::_S_minimum(_M_node->_M_right);
+ }
+ else {
+ _Base_ptr __y = _M_node->_M_parent;
+ while (_M_node == __y->_M_right) {
+ _M_node = __y;
+ __y = __y->_M_parent;
+ }
+ // check special case: This is necessary if _M_node is the
+ // _M_head and the tree contains only a single node __y. In
+ // that case parent, left and right all point to __y!
+ if (_M_node->_M_right != __y)
+ _M_node = __y;
+ }
+ return _M_node;
+}
+
+#endif /* _STLP_EXPOSE_GLOBALS_IMPLEMENTATION */
+
+
+template <class _Key, class _Compare,
+ class _Value, class _KeyOfValue, class _Traits, class _Alloc>
+_Rb_tree<_Key,_Compare,_Value,_KeyOfValue,_Traits,_Alloc>&
+_Rb_tree<_Key,_Compare,_Value,_KeyOfValue,_Traits,_Alloc> ::operator=(
+ const _Rb_tree<_Key,_Compare,_Value,_KeyOfValue,_Traits,_Alloc>& __x) {
+ if (this != &__x) {
+ // Note that _Key may be a constant type.
+ clear();
+ _M_node_count = 0;
+ _M_key_compare = __x._M_key_compare;
+ if (__x._M_root() == 0) {
+ _M_root() = 0;
+ _M_leftmost() = &this->_M_header._M_data;
+ _M_rightmost() = &this->_M_header._M_data;
+ }
+ else {
+ _M_root() = _M_copy(__x._M_root(), &this->_M_header._M_data);
+ _M_leftmost() = _S_minimum(_M_root());
+ _M_rightmost() = _S_maximum(_M_root());
+ _M_node_count = __x._M_node_count;
+ }
+ }
+ return *this;
+}
+
+// CRP 7/10/00 inserted argument __on_right, which is another hint (meant to
+// act like __on_left and ignore a portion of the if conditions -- specify
+// __on_right != 0 to bypass comparison as false or __on_left != 0 to bypass
+// comparison as true)
+template <class _Key, class _Compare,
+ class _Value, class _KeyOfValue, class _Traits, class _Alloc>
+__iterator__
+_Rb_tree<_Key,_Compare,_Value,_KeyOfValue,_Traits,_Alloc> ::_M_insert(_Rb_tree_node_base * __parent,
+ const _Value& __val,
+ _Rb_tree_node_base * __on_left,
+ _Rb_tree_node_base * __on_right) {
+ // We do not create the node here as, depending on tests, we might call
+ // _M_key_compare that can throw an exception.
+ _Base_ptr __new_node;
+
+ if ( __parent == &this->_M_header._M_data ) {
+ __new_node = _M_create_node(__val);
+ _S_left(__parent) = __new_node; // also makes _M_leftmost() = __new_node
+ _M_root() = __new_node;
+ _M_rightmost() = __new_node;
+ }
+ else if ( __on_right == 0 && // If __on_right != 0, the remainder fails to false
+ ( __on_left != 0 || // If __on_left != 0, the remainder succeeds to true
+ _M_key_compare( _KeyOfValue()(__val), _S_key(__parent) ) ) ) {
+ __new_node = _M_create_node(__val);
+ _S_left(__parent) = __new_node;
+ if (__parent == _M_leftmost())
+ _M_leftmost() = __new_node; // maintain _M_leftmost() pointing to min node
+ }
+ else {
+ __new_node = _M_create_node(__val);
+ _S_right(__parent) = __new_node;
+ if (__parent == _M_rightmost())
+ _M_rightmost() = __new_node; // maintain _M_rightmost() pointing to max node
+ }
+ _S_parent(__new_node) = __parent;
+ _Rb_global_inst::_Rebalance(__new_node, this->_M_header._M_data._M_parent);
+ ++_M_node_count;
+ return iterator(__new_node);
+}
+
+template <class _Key, class _Compare,
+ class _Value, class _KeyOfValue, class _Traits, class _Alloc>
+__iterator__
+_Rb_tree<_Key,_Compare,_Value,_KeyOfValue,_Traits,_Alloc> ::insert_equal(const _Value& __val) {
+ _Base_ptr __y = &this->_M_header._M_data;
+ _Base_ptr __x = _M_root();
+ while (__x != 0) {
+ __y = __x;
+ if (_M_key_compare(_KeyOfValue()(__val), _S_key(__x))) {
+ __x = _S_left(__x);
+ }
+ else
+ __x = _S_right(__x);
+ }
+ return _M_insert(__y, __val, __x);
+}
+
+
+template <class _Key, class _Compare,
+ class _Value, class _KeyOfValue, class _Traits, class _Alloc>
+pair<__iterator__, bool>
+_Rb_tree<_Key,_Compare,_Value,_KeyOfValue,_Traits,_Alloc> ::insert_unique(const _Value& __val) {
+ _Base_ptr __y = &this->_M_header._M_data;
+ _Base_ptr __x = _M_root();
+ bool __comp = true;
+ while (__x != 0) {
+ __y = __x;
+ __comp = _M_key_compare(_KeyOfValue()(__val), _S_key(__x));
+ __x = __comp ? _S_left(__x) : _S_right(__x);
+ }
+ iterator __j = iterator(__y);
+ if (__comp) {
+ if (__j == begin())
+ return pair<iterator,bool>(_M_insert(__y, __val, /* __x*/ __y), true);
+ else
+ --__j;
+ }
+ if (_M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__val))) {
+ return pair<iterator,bool>(_M_insert(__y, __val, __x), true);
+ }
+ return pair<iterator,bool>(__j, false);
+}
+
+// Modifications CRP 7/10/00 as noted to improve conformance and
+// efficiency.
+template <class _Key, class _Compare,
+ class _Value, class _KeyOfValue, class _Traits, class _Alloc>
+__iterator__
+_Rb_tree<_Key,_Compare,_Value,_KeyOfValue,_Traits,_Alloc> ::insert_unique(iterator __position,
+ const _Value& __val) {
+ if (__position._M_node == this->_M_header._M_data._M_left) { // begin()
+
+ // if the container is empty, fall back on insert_unique.
+ if (empty())
+ return insert_unique(__val).first;
+
+ if (_M_key_compare(_KeyOfValue()(__val), _S_key(__position._M_node))) {
+ return _M_insert(__position._M_node, __val, __position._M_node);
+ }
+ // first argument just needs to be non-null
+ else {
+ bool __comp_pos_v = _M_key_compare( _S_key(__position._M_node), _KeyOfValue()(__val) );
+
+ if (__comp_pos_v == false) // compare > and compare < both false so compare equal
+ return __position;
+ //Below __comp_pos_v == true
+
+ // Standard-conformance - does the insertion point fall immediately AFTER
+ // the hint?
+ iterator __after = __position;
+ ++__after;
+
+ // Check for only one member -- in that case, __position points to itself,
+ // and attempting to increment will cause an infinite loop.
+ if (__after._M_node == &this->_M_header._M_data)
+ // Check guarantees exactly one member, so comparison was already
+ // performed and we know the result; skip repeating it in _M_insert
+ // by specifying a non-zero fourth argument.
+ return _M_insert(__position._M_node, __val, 0, __position._M_node);
+
+ // All other cases:
+
+ // Optimization to catch insert-equivalent -- save comparison results,
+ // and we get this for free.
+ if (_M_key_compare( _KeyOfValue()(__val), _S_key(__after._M_node) )) {
+ if (_S_right(__position._M_node) == 0)
+ return _M_insert(__position._M_node, __val, 0, __position._M_node);
+ else
+ return _M_insert(__after._M_node, __val, __after._M_node);
+ }
+ else {
+ return insert_unique(__val).first;
+ }
+ }
+ }
+ else if (__position._M_node == &this->_M_header._M_data) { // end()
+ if (_M_key_compare(_S_key(_M_rightmost()), _KeyOfValue()(__val))) {
+ // pass along to _M_insert that it can skip comparing
+ // v, Key ; since compare Key, v was true, compare v, Key must be false.
+ return _M_insert(_M_rightmost(), __val, 0, __position._M_node); // Last argument only needs to be non-null
+ }
+ else
+ return insert_unique(__val).first;
+ }
+ else {
+ iterator __before = __position;
+ --__before;
+
+ bool __comp_v_pos = _M_key_compare(_KeyOfValue()(__val), _S_key(__position._M_node));
+
+ if (__comp_v_pos
+ && _M_key_compare( _S_key(__before._M_node), _KeyOfValue()(__val) )) {
+
+ if (_S_right(__before._M_node) == 0)
+ return _M_insert(__before._M_node, __val, 0, __before._M_node); // Last argument only needs to be non-null
+ else
+ return _M_insert(__position._M_node, __val, __position._M_node);
+ // first argument just needs to be non-null
+ }
+ else {
+ // Does the insertion point fall immediately AFTER the hint?
+ iterator __after = __position;
+ ++__after;
+ // Optimization to catch equivalent cases and avoid unnecessary comparisons
+ bool __comp_pos_v = !__comp_v_pos; // Stored this result earlier
+ // If the earlier comparison was true, this comparison doesn't need to be
+ // performed because it must be false. However, if the earlier comparison
+ // was false, we need to perform this one because in the equal case, both will
+ // be false.
+ if (!__comp_v_pos) {
+ __comp_pos_v = _M_key_compare(_S_key(__position._M_node), _KeyOfValue()(__val));
+ }
+
+ if ( (!__comp_v_pos) // comp_v_pos true implies comp_v_pos false
+ && __comp_pos_v
+ && (__after._M_node == &this->_M_header._M_data ||
+ _M_key_compare( _KeyOfValue()(__val), _S_key(__after._M_node) ))) {
+ if (_S_right(__position._M_node) == 0)
+ return _M_insert(__position._M_node, __val, 0, __position._M_node);
+ else
+ return _M_insert(__after._M_node, __val, __after._M_node);
+ } else {
+ // Test for equivalent case
+ if (__comp_v_pos == __comp_pos_v)
+ return __position;
+ else
+ return insert_unique(__val).first;
+ }
+ }
+ }
+}
+
+template <class _Key, class _Compare,
+ class _Value, class _KeyOfValue, class _Traits, class _Alloc>
+__iterator__
+_Rb_tree<_Key,_Compare,_Value,_KeyOfValue,_Traits,_Alloc> ::insert_equal(iterator __position,
+ const _Value& __val) {
+ if (__position._M_node == this->_M_header._M_data._M_left) { // begin()
+
+ // Check for zero members
+ if (size() <= 0)
+ return insert_equal(__val);
+
+ if (!_M_key_compare(_S_key(__position._M_node), _KeyOfValue()(__val)))
+ return _M_insert(__position._M_node, __val, __position._M_node);
+ else {
+ // Check for only one member
+ if (__position._M_node->_M_left == __position._M_node)
+ // Unlike insert_unique, can't avoid doing a comparison here.
+ return _M_insert(__position._M_node, __val);
+
+ // All other cases:
+ // Standard-conformance - does the insertion point fall immediately AFTER
+ // the hint?
+ iterator __after = __position;
+ ++__after;
+
+ // Already know that compare(pos, v) must be true!
+ // Therefore, we want to know if compare(after, v) is false.
+ // (i.e., we now pos < v, now we want to know if v <= after)
+ // If not, invalid hint.
+ if ( __after._M_node == &this->_M_header._M_data ||
+ !_M_key_compare( _S_key(__after._M_node), _KeyOfValue()(__val) ) ) {
+ if (_S_right(__position._M_node) == 0)
+ return _M_insert(__position._M_node, __val, 0, __position._M_node);
+ else
+ return _M_insert(__after._M_node, __val, __after._M_node);
+ }
+ else { // Invalid hint
+ return insert_equal(__val);
+ }
+ }
+ }
+ else if (__position._M_node == &this->_M_header._M_data) { // end()
+ if (!_M_key_compare(_KeyOfValue()(__val), _S_key(_M_rightmost())))
+ return _M_insert(_M_rightmost(), __val, 0, __position._M_node); // Last argument only needs to be non-null
+ else {
+ return insert_equal(__val);
+ }
+ }
+ else {
+ iterator __before = __position;
+ --__before;
+ // store the result of the comparison between pos and v so
+ // that we don't have to do it again later. Note that this reverses the shortcut
+ // on the if, possibly harming efficiency in comparisons; I think the harm will
+ // be negligible, and to do what I want to do (save the result of a comparison so
+ // that it can be re-used) there is no alternative. Test here is for before <= v <= pos.
+ bool __comp_pos_v = _M_key_compare(_S_key(__position._M_node), _KeyOfValue()(__val));
+ if (!__comp_pos_v &&
+ !_M_key_compare(_KeyOfValue()(__val), _S_key(__before._M_node))) {
+ if (_S_right(__before._M_node) == 0)
+ return _M_insert(__before._M_node, __val, 0, __before._M_node); // Last argument only needs to be non-null
+ else
+ return _M_insert(__position._M_node, __val, __position._M_node);
+ }
+ else {
+ // Does the insertion point fall immediately AFTER the hint?
+ // Test for pos < v <= after
+ iterator __after = __position;
+ ++__after;
+
+ if (__comp_pos_v &&
+ ( __after._M_node == &this->_M_header._M_data ||
+ !_M_key_compare( _S_key(__after._M_node), _KeyOfValue()(__val) ) ) ) {
+ if (_S_right(__position._M_node) == 0)
+ return _M_insert(__position._M_node, __val, 0, __position._M_node);
+ else
+ return _M_insert(__after._M_node, __val, __after._M_node);
+ }
+ else { // Invalid hint
+ return insert_equal(__val);
+ }
+ }
+ }
+}
+
+template <class _Key, class _Compare,
+ class _Value, class _KeyOfValue, class _Traits, class _Alloc>
+_Rb_tree_node_base*
+_Rb_tree<_Key,_Compare,_Value,_KeyOfValue,_Traits,_Alloc> ::_M_copy(_Rb_tree_node_base* __x,
+ _Rb_tree_node_base* __p) {
+ // structural copy. __x and __p must be non-null.
+ _Base_ptr __top = _M_clone_node(__x);
+ _S_parent(__top) = __p;
+
+ _STLP_TRY {
+ if (_S_right(__x))
+ _S_right(__top) = _M_copy(_S_right(__x), __top);
+ __p = __top;
+ __x = _S_left(__x);
+
+ while (__x != 0) {
+ _Base_ptr __y = _M_clone_node(__x);
+ _S_left(__p) = __y;
+ _S_parent(__y) = __p;
+ if (_S_right(__x))
+ _S_right(__y) = _M_copy(_S_right(__x), __y);
+ __p = __y;
+ __x = _S_left(__x);
+ }
+ }
+ _STLP_UNWIND(_M_erase(__top))
+
+ return __top;
+}
+
+// this has to stay out-of-line : it's recursive
+template <class _Key, class _Compare,
+ class _Value, class _KeyOfValue, class _Traits, class _Alloc>
+void
+_Rb_tree<_Key,_Compare,_Value,_KeyOfValue,_Traits,_Alloc>::_M_erase(_Rb_tree_node_base *__x) {
+ // erase without rebalancing
+ while (__x != 0) {
+ _M_erase(_S_right(__x));
+ _Base_ptr __y = _S_left(__x);
+ _STLP_STD::_Destroy(&_S_value(__x));
+ this->_M_header.deallocate(__STATIC_CAST(_Link_type, __x),1);
+ __x = __y;
+ }
+}
+
+#if defined (_STLP_DEBUG)
+inline int
+__black_count(_Rb_tree_node_base* __node, _Rb_tree_node_base* __root) {
+ if (__node == 0)
+ return 0;
+ else {
+ int __bc = __node->_M_color == _S_rb_tree_black ? 1 : 0;
+ if (__node == __root)
+ return __bc;
+ else
+ return __bc + __black_count(__node->_M_parent, __root);
+ }
+}
+
+template <class _Key, class _Compare,
+ class _Value, class _KeyOfValue, class _Traits, class _Alloc>
+bool _Rb_tree<_Key,_Compare,_Value,_KeyOfValue,_Traits,_Alloc>::__rb_verify() const {
+ if (_M_node_count == 0 || begin() == end())
+ return ((_M_node_count == 0) &&
+ (begin() == end()) &&
+ (this->_M_header._M_data._M_left == &this->_M_header._M_data) &&
+ (this->_M_header._M_data._M_right == &this->_M_header._M_data));
+
+ int __len = __black_count(_M_leftmost(), _M_root());
+ for (const_iterator __it = begin(); __it != end(); ++__it) {
+ _Base_ptr __x = __it._M_node;
+ _Base_ptr __L = _S_left(__x);
+ _Base_ptr __R = _S_right(__x);
+
+ if (__x->_M_color == _S_rb_tree_red)
+ if ((__L && __L->_M_color == _S_rb_tree_red) ||
+ (__R && __R->_M_color == _S_rb_tree_red))
+ return false;
+
+ if (__L && _M_key_compare(_S_key(__x), _S_key(__L)))
+ return false;
+ if (__R && _M_key_compare(_S_key(__R), _S_key(__x)))
+ return false;
+
+ if (!__L && !__R && __black_count(__x, _M_root()) != __len)
+ return false;
+ }
+
+ if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
+ return false;
+ if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
+ return false;
+
+ return true;
+}
+#endif /* _STLP_DEBUG */
+
+_STLP_MOVE_TO_STD_NAMESPACE
+_STLP_END_NAMESPACE
+
+#undef _Rb_tree
+#undef __iterator__
+#undef iterator
+#undef __size_type__
+
+#endif /* _STLP_TREE_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_tree.h b/sources/android/stlport/stlport/stl/_tree.h
new file mode 100644
index 0000000..bf05901
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_tree.h
@@ -0,0 +1,684 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_TREE_H
+#define _STLP_INTERNAL_TREE_H
+
+/*
+
+Red-black tree class, designed for use in implementing STL
+associative containers (set, multiset, map, and multimap). The
+insertion and deletion algorithms are based on those in Cormen,
+Leiserson, and Rivest, Introduction to Algorithms (MIT Press, 1990),
+except that
+
+(1) the header cell is maintained with links not only to the root
+but also to the leftmost node of the tree, to enable constant time
+begin(), and to the rightmost node of the tree, to enable linear time
+performance when used with the generic set algorithms (set_union,
+etc.);
+
+(2) when a node being deleted has two children its successor node is
+relinked into its place, rather than copied, so that the only
+iterators invalidated are those referring to the deleted node.
+
+*/
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+# include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+# include <stl/_alloc.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+# include <stl/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CONSTRUCT_H
+# include <stl/_construct.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+# include <stl/_function_base.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+typedef bool _Rb_tree_Color_type;
+//const _Rb_tree_Color_type _S_rb_tree_red = false;
+//const _Rb_tree_Color_type _S_rb_tree_black = true;
+
+#define _S_rb_tree_red false
+#define _S_rb_tree_black true
+
+struct _Rb_tree_node_base {
+ typedef _Rb_tree_Color_type _Color_type;
+ typedef _Rb_tree_node_base* _Base_ptr;
+
+ _Color_type _M_color;
+ _Base_ptr _M_parent;
+ _Base_ptr _M_left;
+ _Base_ptr _M_right;
+
+ static _Base_ptr _STLP_CALL _S_minimum(_Base_ptr __x) {
+ while (__x->_M_left != 0) __x = __x->_M_left;
+ return __x;
+ }
+
+ static _Base_ptr _STLP_CALL _S_maximum(_Base_ptr __x) {
+ while (__x->_M_right != 0) __x = __x->_M_right;
+ return __x;
+ }
+};
+
+template <class _Value>
+struct _Rb_tree_node : public _Rb_tree_node_base {
+ _Value _M_value_field;
+ __TRIVIAL_STUFF(_Rb_tree_node)
+};
+
+struct _Rb_tree_base_iterator;
+
+template <class _Dummy>
+class _Rb_global {
+public:
+ typedef _Rb_tree_node_base* _Base_ptr;
+ // those used to be global functions
+ static void _STLP_CALL _Rebalance(_Base_ptr __x, _Base_ptr& __root);
+ static _Base_ptr _STLP_CALL _Rebalance_for_erase(_Base_ptr __z,
+ _Base_ptr& __root,
+ _Base_ptr& __leftmost,
+ _Base_ptr& __rightmost);
+ // those are from _Rb_tree_base_iterator - moved here to reduce code bloat
+ // moved here to reduce code bloat without templatizing _Rb_tree_base_iterator
+ static _Base_ptr _STLP_CALL _M_increment (_Base_ptr);
+ static _Base_ptr _STLP_CALL _M_decrement (_Base_ptr);
+ static void _STLP_CALL _Rotate_left (_Base_ptr __x, _Base_ptr& __root);
+ static void _STLP_CALL _Rotate_right(_Base_ptr __x, _Base_ptr& __root);
+};
+
+# if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS _Rb_global<bool>;
+# endif
+
+typedef _Rb_global<bool> _Rb_global_inst;
+
+struct _Rb_tree_base_iterator {
+ typedef _Rb_tree_node_base* _Base_ptr;
+ typedef bidirectional_iterator_tag iterator_category;
+ typedef ptrdiff_t difference_type;
+ _Base_ptr _M_node;
+ _Rb_tree_base_iterator() : _M_node(0) {}
+ _Rb_tree_base_iterator(_Base_ptr __x) : _M_node(__x) {}
+};
+
+template <class _Value, class _Traits>
+struct _Rb_tree_iterator : public _Rb_tree_base_iterator {
+ typedef _Value value_type;
+ typedef typename _Traits::reference reference;
+ typedef typename _Traits::pointer pointer;
+ typedef _Rb_tree_iterator<_Value, _Traits> _Self;
+ typedef _Rb_tree_node_base* _Base_ptr;
+ typedef _Rb_tree_node<_Value>* _Link_type;
+
+ typedef typename _Traits::_NonConstTraits _NonConstTraits;
+ typedef _Rb_tree_iterator<_Value, _NonConstTraits> iterator;
+ typedef typename _Traits::_ConstTraits _ConstTraits;
+ typedef _Rb_tree_iterator<_Value, _ConstTraits> const_iterator;
+
+ _Rb_tree_iterator() {}
+#if !defined (_STLP_DEBUG)
+ /* In STL debug mode we need this constructor implicit for the pointer
+ * specialization implementation.
+ */
+ explicit
+#endif
+ _Rb_tree_iterator(_Base_ptr __x) : _Rb_tree_base_iterator(__x) {}
+ //copy constructor for iterator and constructor from iterator for const_iterator
+ _Rb_tree_iterator(const iterator& __it) : _Rb_tree_base_iterator(__it._M_node) {}
+
+ reference operator*() const {
+ return __STATIC_CAST(_Link_type, _M_node)->_M_value_field;
+ }
+
+ _STLP_DEFINE_ARROW_OPERATOR
+
+ _Self& operator++() {
+ _M_node = _Rb_global_inst::_M_increment(_M_node);
+ return *this;
+ }
+ _Self operator++(int) {
+ _Self __tmp = *this;
+ ++(*this);
+ return __tmp;
+ }
+
+ _Self& operator--() {
+ _M_node = _Rb_global_inst::_M_decrement(_M_node);
+ return *this;
+ }
+ _Self operator--(int) {
+ _Self __tmp = *this;
+ --(*this);
+ return __tmp;
+ }
+
+ bool operator == (const_iterator __rhs) const {
+ return _M_node == __rhs._M_node;
+ }
+ bool operator != (const_iterator __rhs) const {
+ return _M_node != __rhs._M_node;
+ }
+};
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+_STLP_MOVE_TO_STD_NAMESPACE
+template <class _Value, class _Traits>
+struct __type_traits<_STLP_PRIV _Rb_tree_iterator<_Value, _Traits> > {
+ typedef __false_type has_trivial_default_constructor;
+ typedef __true_type has_trivial_copy_constructor;
+ typedef __true_type has_trivial_assignment_operator;
+ typedef __true_type has_trivial_destructor;
+ typedef __false_type is_POD_type;
+};
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+#if defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
+_STLP_MOVE_TO_STD_NAMESPACE
+template <class _Value, class _Traits>
+inline _Value* value_type(const _STLP_PRIV _Rb_tree_iterator<_Value, _Traits>&)
+{ return (_Value*)0; }
+inline bidirectional_iterator_tag iterator_category(const _STLP_PRIV _Rb_tree_base_iterator&)
+{ return bidirectional_iterator_tag(); }
+inline ptrdiff_t* distance_type(const _STLP_PRIV _Rb_tree_base_iterator&)
+{ return (ptrdiff_t*) 0; }
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+// Base class to help EH
+
+template <class _Tp, class _Alloc>
+class _Rb_tree_base {
+public:
+ typedef _Rb_tree_node_base _Node_base;
+ typedef _Rb_tree_node<_Tp> _Node;
+ _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
+ typedef _Alloc allocator_type;
+private:
+ typedef _Rb_tree_base<_Tp, _Alloc> _Self;
+ typedef typename _Alloc_traits<_Node, _Alloc>::allocator_type _M_node_allocator_type;
+ typedef _STLP_alloc_proxy<_Node_base, _Node, _M_node_allocator_type> _AllocProxy;
+
+public:
+ allocator_type get_allocator() const {
+ return _STLP_CONVERT_ALLOCATOR(_M_header, _Tp);
+ }
+
+protected:
+ _Rb_tree_base(const allocator_type& __a) :
+ _M_header(_STLP_CONVERT_ALLOCATOR(__a, _Node), _Node_base() ) {
+ _M_empty_initialize();
+ }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ _Rb_tree_base(__move_source<_Self> src) :
+ _M_header(__move_source<_AllocProxy>(src.get()._M_header)) {
+ _M_rebind(&src.get()._M_header._M_data);
+ src.get()._M_empty_initialize();
+ }
+#endif
+
+ void _M_empty_initialize() {
+ _M_header._M_data._M_color = _S_rb_tree_red; // used to distinguish header from
+ // __root, in iterator.operator++
+ _M_header._M_data._M_parent = 0;
+ _M_header._M_data._M_left = &_M_header._M_data;
+ _M_header._M_data._M_right = &_M_header._M_data;
+ }
+
+ void _M_rebind(_Node_base *__static_node) {
+ if (_M_header._M_data._M_parent != 0) {
+ _M_header._M_data._M_parent->_M_parent = &_M_header._M_data;
+ }
+ if (_M_header._M_data._M_right == __static_node) {
+ _M_header._M_data._M_right = &_M_header._M_data;
+ }
+ if (_M_header._M_data._M_left == __static_node) {
+ _M_header._M_data._M_left = &_M_header._M_data;
+ }
+ }
+
+ _AllocProxy _M_header;
+};
+
+#if defined (_STLP_DEBUG)
+# define _Rb_tree _STLP_NON_DBG_NAME(Rb_tree)
+#endif
+
+template <class _Key, class _Compare,
+ class _Value, class _KeyOfValue, class _Traits,
+ _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Value>) >
+class _Rb_tree : public _Rb_tree_base<_Value, _Alloc> {
+ typedef _Rb_tree_base<_Value, _Alloc> _Base;
+ typedef _Rb_tree<_Key, _Compare, _Value, _KeyOfValue, _Traits, _Alloc> _Self;
+protected:
+ typedef _Rb_tree_node_base * _Base_ptr;
+ typedef _Rb_tree_node<_Value> _Node;
+ typedef _Node* _Link_type;
+ typedef _Rb_tree_Color_type _Color_type;
+public:
+ typedef _Key key_type;
+ typedef _Value value_type;
+ typedef typename _Traits::pointer pointer;
+ typedef const value_type* const_pointer;
+ typedef typename _Traits::reference reference;
+ typedef const value_type& const_reference;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef bidirectional_iterator_tag _Iterator_category;
+ typedef typename _Base::allocator_type allocator_type;
+
+protected:
+
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+ _Base_ptr _M_create_node(const value_type& __x) {
+ _Link_type __tmp = this->_M_header.allocate(1);
+ _STLP_TRY {
+ _Copy_Construct(&__tmp->_M_value_field, __x);
+ }
+ _STLP_UNWIND(this->_M_header.deallocate(__tmp,1))
+ _S_left(__tmp) = 0;
+ _S_right(__tmp) = 0;
+ return __tmp;
+ }
+
+ _Base_ptr _M_clone_node(_Base_ptr __x) {
+ _Base_ptr __tmp = _M_create_node(_S_value(__x));
+ _S_color(__tmp) = _S_color(__x);
+ return __tmp;
+ }
+
+ size_type _M_node_count; // keeps track of size of tree
+ _Compare _M_key_compare;
+
+ _Base_ptr _M_root() const
+ { return this->_M_header._M_data._M_parent; }
+ _Base_ptr _M_leftmost() const
+ { return this->_M_header._M_data._M_left; }
+ _Base_ptr _M_rightmost() const
+ { return this->_M_header._M_data._M_right; }
+
+ _Base_ptr& _M_root()
+ { return this->_M_header._M_data._M_parent; }
+ _Base_ptr& _M_leftmost()
+ { return this->_M_header._M_data._M_left; }
+ _Base_ptr& _M_rightmost()
+ { return this->_M_header._M_data._M_right; }
+
+ static _Base_ptr& _STLP_CALL _S_left(_Base_ptr __x)
+ { return __x->_M_left; }
+ static _Base_ptr& _STLP_CALL _S_right(_Base_ptr __x)
+ { return __x->_M_right; }
+ static _Base_ptr& _STLP_CALL _S_parent(_Base_ptr __x)
+ { return __x->_M_parent; }
+ static value_type& _STLP_CALL _S_value(_Base_ptr __x)
+ { return __STATIC_CAST(_Link_type, __x)->_M_value_field; }
+ static const _Key& _STLP_CALL _S_key(_Base_ptr __x)
+ { return _KeyOfValue()(_S_value(__x));}
+ static _Color_type& _STLP_CALL _S_color(_Base_ptr __x)
+ { return (_Color_type&)(__x->_M_color); }
+
+ static _Base_ptr _STLP_CALL _S_minimum(_Base_ptr __x)
+ { return _Rb_tree_node_base::_S_minimum(__x); }
+
+ static _Base_ptr _STLP_CALL _S_maximum(_Base_ptr __x)
+ { return _Rb_tree_node_base::_S_maximum(__x); }
+
+public:
+ typedef typename _Traits::_NonConstTraits _NonConstTraits;
+ typedef typename _Traits::_ConstTraits _ConstTraits;
+ typedef _Rb_tree_iterator<value_type, _NonConstTraits> iterator;
+ typedef _Rb_tree_iterator<value_type, _ConstTraits> const_iterator;
+ _STLP_DECLARE_BIDIRECTIONAL_REVERSE_ITERATORS;
+
+private:
+ iterator _M_insert(_Base_ptr __parent, const value_type& __val, _Base_ptr __on_left = 0, _Base_ptr __on_right = 0);
+ _Base_ptr _M_copy(_Base_ptr __x, _Base_ptr __p);
+ void _M_erase(_Base_ptr __x);
+
+public:
+ // allocation/deallocation
+ _Rb_tree()
+ : _Rb_tree_base<_Value, _Alloc>(allocator_type()), _M_node_count(0), _M_key_compare(_Compare())
+ {}
+
+ _Rb_tree(const _Compare& __comp)
+ : _Rb_tree_base<_Value, _Alloc>(allocator_type()), _M_node_count(0), _M_key_compare(__comp)
+ {}
+
+ _Rb_tree(const _Compare& __comp, const allocator_type& __a)
+ : _Rb_tree_base<_Value, _Alloc>(__a), _M_node_count(0), _M_key_compare(__comp)
+ {}
+
+ _Rb_tree(const _Self& __x)
+ : _Rb_tree_base<_Value, _Alloc>(__x.get_allocator()),
+ _M_node_count(0), _M_key_compare(__x._M_key_compare) {
+ if (__x._M_root() != 0) {
+ _S_color(&this->_M_header._M_data) = _S_rb_tree_red;
+ _M_root() = _M_copy(__x._M_root(), &this->_M_header._M_data);
+ _M_leftmost() = _S_minimum(_M_root());
+ _M_rightmost() = _S_maximum(_M_root());
+ }
+ _M_node_count = __x._M_node_count;
+ }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ _Rb_tree(__move_source<_Self> src)
+ : _Rb_tree_base<_Value, _Alloc>(__move_source<_Base>(src.get())),
+ _M_node_count(src.get()._M_node_count),
+ _M_key_compare(_AsMoveSource(src.get()._M_key_compare))
+ { src.get()._M_node_count = 0; }
+#endif
+
+ ~_Rb_tree() { clear(); }
+ _Self& operator=(const _Self& __x);
+
+public:
+ // accessors:
+ _Compare key_comp() const { return _M_key_compare; }
+
+ iterator begin() { return iterator(_M_leftmost()); }
+ const_iterator begin() const { return const_iterator(_M_leftmost()); }
+ iterator end() { return iterator(&this->_M_header._M_data); }
+ const_iterator end() const { return const_iterator(__CONST_CAST(_Base_ptr, &this->_M_header._M_data)); }
+
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ const_reverse_iterator rbegin() const
+ { return const_reverse_iterator(end()); }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+ const_reverse_iterator rend() const
+ { return const_reverse_iterator(begin()); }
+ bool empty() const { return _M_node_count == 0; }
+ size_type size() const { return _M_node_count; }
+ size_type max_size() const { return size_type(-1); }
+
+ void swap(_Self& __t) {
+ if (__t.empty()) {
+ if (this->empty()) return;
+ __t._M_header.swap(this->_M_header);
+ __t._M_rebind(&this->_M_header._M_data);
+ this->_M_empty_initialize();
+ }
+ else if (this->empty()) {
+ __t.swap(*this);
+ return;
+ }
+ else {
+ this->_M_header.swap(__t._M_header);
+ this->_M_rebind(&__t._M_header._M_data);
+ __t._M_rebind(&this->_M_header._M_data);
+ }
+ _STLP_STD::swap(_M_node_count, __t._M_node_count);
+ _STLP_STD::swap(_M_key_compare, __t._M_key_compare);
+ }
+
+public:
+ // insert/erase
+ pair<iterator,bool> insert_unique(const value_type& __x);
+ iterator insert_equal(const value_type& __x);
+
+ iterator insert_unique(iterator __pos, const value_type& __x);
+ iterator insert_equal(iterator __pos, const value_type& __x);
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template<class _II> void insert_equal(_II __first, _II __last) {
+ for ( ; __first != __last; ++__first)
+ insert_equal(*__first);
+ }
+ template<class _II> void insert_unique(_II __first, _II __last) {
+ for ( ; __first != __last; ++__first)
+ insert_unique(*__first);
+ }
+#else
+ void insert_unique(const_iterator __first, const_iterator __last) {
+ for ( ; __first != __last; ++__first)
+ insert_unique(*__first);
+ }
+ void insert_unique(const value_type* __first, const value_type* __last) {
+ for ( ; __first != __last; ++__first)
+ insert_unique(*__first);
+ }
+ void insert_equal(const_iterator __first, const_iterator __last) {
+ for ( ; __first != __last; ++__first)
+ insert_equal(*__first);
+ }
+ void insert_equal(const value_type* __first, const value_type* __last) {
+ for ( ; __first != __last; ++__first)
+ insert_equal(*__first);
+ }
+#endif
+
+ void erase(iterator __pos) {
+ _Base_ptr __x = _Rb_global_inst::_Rebalance_for_erase(__pos._M_node,
+ this->_M_header._M_data._M_parent,
+ this->_M_header._M_data._M_left,
+ this->_M_header._M_data._M_right);
+ _STLP_STD::_Destroy(&_S_value(__x));
+ this->_M_header.deallocate(__STATIC_CAST(_Link_type, __x), 1);
+ --_M_node_count;
+ }
+
+ size_type erase(const key_type& __x) {
+ pair<iterator,iterator> __p = equal_range(__x);
+ size_type __n = _STLP_STD::distance(__p.first, __p.second);
+ erase(__p.first, __p.second);
+ return __n;
+ }
+
+ size_type erase_unique(const key_type& __x) {
+ iterator __i = find(__x);
+ if (__i._M_node != &this->_M_header._M_data) {
+ erase(__i);
+ return 1;
+ }
+ return 0;
+ }
+
+ void erase(iterator __first, iterator __last) {
+ if (__first._M_node == this->_M_header._M_data._M_left && // begin()
+ __last._M_node == &this->_M_header._M_data) // end()
+ clear();
+ else
+ while (__first != __last) erase(__first++);
+ }
+
+ void erase(const key_type* __first, const key_type* __last) {
+ while (__first != __last) erase(*__first++);
+ }
+
+ void clear() {
+ if (_M_node_count != 0) {
+ _M_erase(_M_root());
+ _M_leftmost() = &this->_M_header._M_data;
+ _M_root() = 0;
+ _M_rightmost() = &this->_M_header._M_data;
+ _M_node_count = 0;
+ }
+ }
+
+public:
+ // set operations:
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __k) { return iterator(_M_find(__k)); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __k) const { return const_iterator(_M_find(__k)); }
+private:
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ _Base_ptr _M_find(const _KT& __k) const {
+ _Base_ptr __y = __CONST_CAST(_Base_ptr, &this->_M_header._M_data); // Last node which is not less than __k.
+ _Base_ptr __x = _M_root(); // Current node.
+
+ while (__x != 0)
+ if (!_M_key_compare(_S_key(__x), __k))
+ __y = __x, __x = _S_left(__x);
+ else
+ __x = _S_right(__x);
+
+ if (__y != &this->_M_header._M_data) {
+ if (_M_key_compare(__k, _S_key(__y))) {
+ __y = __CONST_CAST(_Base_ptr, &this->_M_header._M_data);
+ }
+ }
+ return __y;
+ }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ _Base_ptr _M_lower_bound(const _KT& __k) const {
+ _Base_ptr __y = __CONST_CAST(_Base_ptr, &this->_M_header._M_data); /* Last node which is not less than __k. */
+ _Base_ptr __x = _M_root(); /* Current node. */
+
+ while (__x != 0)
+ if (!_M_key_compare(_S_key(__x), __k))
+ __y = __x, __x = _S_left(__x);
+ else
+ __x = _S_right(__x);
+
+ return __y;
+ }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ _Base_ptr _M_upper_bound(const _KT& __k) const {
+ _Base_ptr __y = __CONST_CAST(_Base_ptr, &this->_M_header._M_data); /* Last node which is greater than __k. */
+ _Base_ptr __x = _M_root(); /* Current node. */
+
+ while (__x != 0)
+ if (_M_key_compare(__k, _S_key(__x)))
+ __y = __x, __x = _S_left(__x);
+ else
+ __x = _S_right(__x);
+
+ return __y;
+ }
+
+public:
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __x) const {
+ pair<const_iterator, const_iterator> __p = equal_range(__x);
+ return _STLP_STD::distance(__p.first, __p.second);
+ }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator lower_bound(const _KT& __x) { return iterator(_M_lower_bound(__x)); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator lower_bound(const _KT& __x) const { return const_iterator(_M_lower_bound(__x)); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator upper_bound(const _KT& __x) { return iterator(_M_upper_bound(__x)); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator upper_bound(const _KT& __x) const { return const_iterator(_M_upper_bound(__x)); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator,iterator> equal_range(const _KT& __x)
+ { return pair<iterator, iterator>(lower_bound(__x), upper_bound(__x)); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator> equal_range(const _KT& __x) const
+ { return pair<const_iterator, const_iterator>(lower_bound(__x), upper_bound(__x)); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator,iterator> equal_range_unique(const _KT& __x) {
+ pair<iterator, iterator> __p;
+ __p.second = lower_bound(__x);
+ if (__p.second._M_node != &this->_M_header._M_data &&
+ !_M_key_compare(__x, _S_key(__p.second._M_node))) {
+ __p.first = __p.second++;
+ }
+ else {
+ __p.first = __p.second;
+ }
+ return __p;
+ }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator> equal_range_unique(const _KT& __x) const {
+ pair<const_iterator, const_iterator> __p;
+ __p.second = lower_bound(__x);
+ if (__p.second._M_node != &this->_M_header._M_data &&
+ !_M_key_compare(__x, _S_key(__p.second._M_node))) {
+ __p.first = __p.second++;
+ }
+ else {
+ __p.first = __p.second;
+ }
+ return __p;
+ }
+
+#if defined (_STLP_DEBUG)
+public:
+ // Debugging.
+ bool __rb_verify() const;
+#endif //_STLP_DEBUG
+};
+
+#if defined (_STLP_DEBUG)
+# undef _Rb_tree
+#endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_tree.c>
+#endif
+
+#if defined (_STLP_DEBUG)
+# include <stl/debug/_tree.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#define _STLP_TEMPLATE_HEADER template <class _Key, class _Compare, class _Value, class _KeyOfValue, class _Traits, class _Alloc>
+#define _STLP_TEMPLATE_CONTAINER _STLP_PRIV _Rb_tree<_Key,_Compare,_Value,_KeyOfValue,_Traits,_Alloc>
+#include <stl/_relops_cont.h>
+#undef _STLP_TEMPLATE_CONTAINER
+#undef _STLP_TEMPLATE_HEADER
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Key, class _Compare, class _Value, class _KeyOfValue, class _Traits, class _Alloc>
+struct __move_traits<_STLP_PRIV _Rb_tree<_Key, _Compare, _Value, _KeyOfValue, _Traits, _Alloc> >
+ : _STLP_PRIV __move_traits_help2<_Compare, _Alloc> {};
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_TREE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_typeinfo.h b/sources/android/stlport/stlport/stl/_typeinfo.h
new file mode 100644
index 0000000..843ba56
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_typeinfo.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_INTERNAL_TYPEINFO
+#define _STLP_INTERNAL_TYPEINFO
+
+#if !defined (_STLP_NO_TYPEINFO)
+
+# if defined (_STLP_NO_NEW_NEW_HEADER)
+# include <typeinfo.h>
+# else
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <typeinfo>
+# else
+# include _STLP_NATIVE_CPP_RUNTIME_HEADER(typeinfo)
+# endif
+# endif
+
+# if (defined(_STLP_MSVC) && (_STLP_MSVC >= 1300)) || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800))
+// In .NET, <typeinfo> actually includes <typeinfo.h>
+# undef _STLP_OLDSTD_typeinfo
+# endif
+
+// if <typeinfo.h> already included, do not import anything
+# if defined(_STLP_USE_NAMESPACES) && !defined(_STLP_OLDSTD_typeinfo) && \
+ (defined(_STLP_VENDOR_GLOBAL_EXCEPT_STD) || \
+ defined(_STLP_USE_OWN_NAMESPACE) || defined (_STLP_DEBUG))
+# if defined(_STLP_MSVC) && (_STLP_MSVC < 1300) && !defined(_STLP_WCE_NET)
+class bad_cast : public exception {};
+# endif
+
+_STLP_BEGIN_NAMESPACE
+// VC 6 and eVC 4 have type_info in the global namespace
+# if (defined(_STLP_MSVC) && (_STLP_MSVC < 1300)) || defined(_STLP_WCE_NET)
+using ::type_info;
+# else
+using _STLP_VENDOR_EXCEPT_STD::type_info;
+# endif
+
+# if !defined (__DMC__)
+using _STLP_VENDOR_EXCEPT_STD::bad_typeid;
+# endif
+
+# if defined (_STLP_MSVC) && (_STLP_MSVC < 1300) && !defined (_STLP_WCE_NET)
+using ::bad_cast;
+# else
+using _STLP_VENDOR_EXCEPT_STD::bad_cast;
+# endif
+
+_STLP_END_NAMESPACE
+
+# endif
+
+#else
+
+# ifndef _STLP_INTERNAL_EXCEPTION
+# include <stl/_exception.h>
+# endif
+
+_STLP_BEGIN_NAMESPACE
+# if !defined (__DMC__)
+struct bad_cast : exception {};
+# endif
+_STLP_END_NAMESPACE
+#endif
+
+#endif
diff --git a/sources/android/stlport/stlport/stl/_uninitialized.h b/sources/android/stlport/stlport/stl/_uninitialized.h
new file mode 100644
index 0000000..5489a94
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_uninitialized.h
@@ -0,0 +1,443 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_UNINITIALIZED_H
+#define _STLP_INTERNAL_UNINITIALIZED_H
+
+#ifndef _STLP_INTERNAL_CSTRING
+# include <stl/_cstring.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+# include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CONSTRUCT_H
+# include <stl/_construct.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+// uninitialized_copy
+
+template <class _InputIter, class _OutputIter, class _Distance>
+inline _OutputIter __ucopy(_InputIter __first, _InputIter __last,
+ _OutputIter __result, _Distance*) {
+ _OutputIter __cur = __result;
+ _STLP_TRY {
+ for ( ; __first != __last; ++__first, ++__cur)
+ _Param_Construct(&*__cur, *__first);
+ return __cur;
+ }
+ _STLP_UNWIND(_STLP_STD::_Destroy_Range(__result, __cur))
+ _STLP_RET_AFTER_THROW(__cur)
+}
+
+template <class _InputIter, class _OutputIter, class _Distance>
+inline _OutputIter __ucopy(_InputIter __first, _InputIter __last,
+ _OutputIter __result, const input_iterator_tag &, _Distance* __d)
+{ return __ucopy(__first, __last, __result, __d); }
+
+#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
+template <class _InputIter, class _OutputIter, class _Distance>
+inline _OutputIter __ucopy(_InputIter __first, _InputIter __last,
+ _OutputIter __result, const forward_iterator_tag &, _Distance* __d)
+{ return __ucopy(__first, __last, __result, __d); }
+
+template <class _InputIter, class _OutputIter, class _Distance>
+inline _OutputIter __ucopy(_InputIter __first, _InputIter __last,
+ _OutputIter __result, const bidirectional_iterator_tag &, _Distance* __d)
+{ return __ucopy(__first, __last, __result, __d); }
+#endif
+
+template <class _RandomAccessIter, class _OutputIter, class _Distance>
+inline _OutputIter __ucopy(_RandomAccessIter __first, _RandomAccessIter __last,
+ _OutputIter __result, const random_access_iterator_tag &, _Distance*) {
+ _OutputIter __cur = __result;
+ _STLP_TRY {
+ for (_Distance __n = __last - __first; __n > 0; --__n) {
+ _Param_Construct(&*__cur, *__first);
+ ++__first;
+ ++__cur;
+ }
+ return __cur;
+ }
+ _STLP_UNWIND(_STLP_STD::_Destroy_Range(__result, __cur))
+ _STLP_RET_AFTER_THROW(__cur)
+}
+
+//Used internaly
+template <class _RandomAccessIter, class _OutputIter>
+inline _OutputIter __ucopy(_RandomAccessIter __first, _RandomAccessIter __last, _OutputIter __result)
+{ return __ucopy(__first, __last, __result, random_access_iterator_tag(), (ptrdiff_t*)0); }
+
+inline void*
+__ucopy_trivial(const void* __first, const void* __last, void* __result) {
+ //dums: this version can use memcpy (__copy_trivial can't)
+ return (__last == __first) ? __result :
+ ((char*)memcpy(__result, __first, ((const char*)__last - (const char*)__first))) +
+ ((const char*)__last - (const char*)__first);
+}
+
+template <class _InputIter, class _OutputIter>
+inline _OutputIter __ucopy_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result,
+ const __false_type& /*TrivialUCopy*/)
+{ return __ucopy(__first, __last, __result, random_access_iterator_tag(), (ptrdiff_t*)0); }
+
+template <class _InputIter, class _OutputIter>
+inline _OutputIter __ucopy_ptrs(_InputIter __first, _InputIter __last, _OutputIter __result,
+ const __true_type& /*TrivialUCopy*/) {
+ // we know they all pointers, so this cast is OK
+ // return (_OutputIter)__copy_trivial(&(*__first), &(*__last), &(*__result));
+ return (_OutputIter)__ucopy_trivial(__first, __last, __result);
+}
+
+template <class _InputIter, class _OutputIter>
+inline _OutputIter __ucopy_aux(_InputIter __first, _InputIter __last, _OutputIter __result,
+ const __true_type& /*BothPtrType*/) {
+ return __ucopy_ptrs(__first, __last, __result,
+ _UseTrivialUCopy(_STLP_VALUE_TYPE(__first, _InputIter),
+ _STLP_VALUE_TYPE(__result, _OutputIter))._Answer());
+}
+
+template <class _InputIter, class _OutputIter>
+inline _OutputIter __ucopy_aux(_InputIter __first, _InputIter __last, _OutputIter __result,
+ const __false_type& /*BothPtrType*/) {
+ return __ucopy(__first, __last, __result,
+ _STLP_ITERATOR_CATEGORY(__first, _InputIter),
+ _STLP_DISTANCE_TYPE(__first, _InputIter));
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter, class _ForwardIter>
+inline _ForwardIter
+uninitialized_copy(_InputIter __first, _InputIter __last, _ForwardIter __result)
+{ return _STLP_PRIV __ucopy_aux(__first, __last, __result, _BothPtrType< _InputIter, _ForwardIter>::_Answer()); }
+
+inline char*
+uninitialized_copy(const char* __first, const char* __last, char* __result)
+{ return (char*)_STLP_PRIV __ucopy_trivial(__first, __last, __result); }
+
+# if defined (_STLP_HAS_WCHAR_T) // dwa 8/15/97
+inline wchar_t*
+uninitialized_copy(const wchar_t* __first, const wchar_t* __last, wchar_t* __result)
+{ return (wchar_t*)_STLP_PRIV __ucopy_trivial (__first, __last, __result); }
+# endif
+
+// uninitialized_copy_n (not part of the C++ standard)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter, class _Size, class _ForwardIter>
+_STLP_INLINE_LOOP
+pair<_InputIter, _ForwardIter>
+__ucopy_n(_InputIter __first, _Size __count, _ForwardIter __result,
+ const input_iterator_tag &) {
+ _ForwardIter __cur = __result;
+ _STLP_TRY {
+ for ( ; __count > 0 ; --__count, ++__first, ++__cur)
+ _Param_Construct(&*__cur, *__first);
+ return pair<_InputIter, _ForwardIter>(__first, __cur);
+ }
+ _STLP_UNWIND(_STLP_STD::_Destroy_Range(__result, __cur))
+ _STLP_RET_AFTER_THROW((pair<_InputIter, _ForwardIter>(__first, __cur)))
+}
+
+# if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
+template <class _InputIter, class _Size, class _ForwardIterator>
+inline pair<_InputIter, _ForwardIterator>
+__ucopy_n(_InputIter __first, _Size __count,
+ _ForwardIterator __result,
+ const forward_iterator_tag &)
+{ return __ucopy_n(__first, __count, __result, input_iterator_tag()); }
+
+template <class _InputIter, class _Size, class _ForwardIterator>
+inline pair<_InputIter, _ForwardIterator>
+__ucopy_n(_InputIter __first, _Size __count,
+ _ForwardIterator __result,
+ const bidirectional_iterator_tag &)
+{ return __ucopy_n(__first, __count, __result, input_iterator_tag()); }
+# endif
+
+template <class _RandomAccessIter, class _Size, class _ForwardIter>
+inline pair<_RandomAccessIter, _ForwardIter>
+__ucopy_n(_RandomAccessIter __first, _Size __count, _ForwardIter __result,
+ const random_access_iterator_tag &) {
+ _RandomAccessIter __last = __first + __count;
+ return pair<_RandomAccessIter, _ForwardIter>(__last, uninitialized_copy(__first, __last, __result));
+}
+
+// This is used internally in <rope> , which is extension itself.
+template <class _InputIter, class _Size, class _ForwardIter>
+inline pair<_InputIter, _ForwardIter>
+__ucopy_n(_InputIter __first, _Size __count, _ForwardIter __result)
+{ return _STLP_PRIV __ucopy_n(__first, __count, __result, _STLP_ITERATOR_CATEGORY(__first, _InputIter)); }
+
+#if !defined (_STLP_NO_EXTENSIONS)
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _InputIter, class _Size, class _ForwardIter>
+inline pair<_InputIter, _ForwardIter>
+uninitialized_copy_n(_InputIter __first, _Size __count, _ForwardIter __result)
+{ return _STLP_PRIV __ucopy_n(__first, __count, __result); }
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+#endif
+
+template <class _ForwardIter, class _Tp, class _Distance>
+inline void __ufill(_ForwardIter __first, _ForwardIter __last, const _Tp& __x, _Distance*) {
+ _ForwardIter __cur = __first;
+ _STLP_TRY {
+ for ( ; __cur != __last; ++__cur)
+ _Param_Construct(&*__cur, __x);
+ }
+ _STLP_UNWIND(_STLP_STD::_Destroy_Range(__first, __cur))
+}
+
+template <class _ForwardIter, class _Tp, class _Distance>
+inline void __ufill(_ForwardIter __first, _ForwardIter __last,
+ const _Tp& __x, const input_iterator_tag &, _Distance* __d)
+{ __ufill(__first, __last, __x, __d); }
+
+#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
+template <class _ForwardIter, class _Tp, class _Distance>
+inline void __ufill(_ForwardIter __first, _ForwardIter __last,
+ const _Tp& __x, const forward_iterator_tag &, _Distance* __d)
+{ __ufill(__first, __last, __x, __d); }
+
+template <class _ForwardIter, class _Tp, class _Distance>
+inline void __ufill(_ForwardIter __first, _ForwardIter __last,
+ const _Tp& __x, const bidirectional_iterator_tag &, _Distance* __d)
+{ __ufill(__first, __last, __x, __d); }
+#endif
+
+template <class _ForwardIter, class _Tp, class _Distance>
+inline void __ufill(_ForwardIter __first, _ForwardIter __last,
+ const _Tp& __x, const random_access_iterator_tag &, _Distance*) {
+ _ForwardIter __cur = __first;
+ _STLP_TRY {
+ for (_Distance __n = __last - __first; __n > 0; --__n, ++__cur)
+ _Param_Construct(&*__cur, __x);
+ }
+ _STLP_UNWIND(_STLP_STD::_Destroy_Range(__first, __cur))
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _ForwardIter, class _Tp>
+inline void uninitialized_fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __x) {
+ _STLP_PRIV __ufill(__first, __last, __x,
+ _STLP_ITERATOR_CATEGORY(__first, _ForwardIter),
+ _STLP_DISTANCE_TYPE(__first, _ForwardIter));
+}
+
+// Specialization: for one-byte types we can use memset.
+inline void uninitialized_fill(unsigned char* __first, unsigned char* __last,
+ const unsigned char& __val) {
+ unsigned char __tmp = __val;
+ memset(__first, __tmp, __last - __first);
+}
+#if !defined (_STLP_NO_SIGNED_BUILTINS)
+inline void uninitialized_fill(signed char* __first, signed char* __last,
+ const signed char& __val) {
+ signed char __tmp = __val;
+ memset(__first, __STATIC_CAST(unsigned char,__tmp), __last - __first);
+}
+#endif
+inline void uninitialized_fill(char* __first, char* __last, const char& __val) {
+ char __tmp = __val;
+ memset(__first, __STATIC_CAST(unsigned char,__tmp), __last - __first);
+}
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _ForwardIter, class _Size, class _Tp>
+inline _ForwardIter __ufill_n(_ForwardIter __first, _Size __n, const _Tp& __x) {
+ _ForwardIter __cur = __first;
+ _STLP_TRY {
+ for ( ; __n > 0; --__n, ++__cur)
+ _Param_Construct(&*__cur, __x);
+ }
+ _STLP_UNWIND(_STLP_STD::_Destroy_Range(__first, __cur))
+ return __cur;
+}
+
+template <class _ForwardIter, class _Size, class _Tp>
+inline _ForwardIter __ufill_n(_ForwardIter __first, _Size __n, const _Tp& __x,
+ const input_iterator_tag &)
+{ return __ufill_n(__first, __n, __x); }
+
+#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
+template <class _ForwardIter, class _Size, class _Tp>
+inline _ForwardIter __ufill_n(_ForwardIter __first, _Size __n, const _Tp& __x,
+ const forward_iterator_tag &)
+{ return __ufill_n(__first, __n, __x); }
+
+template <class _ForwardIter, class _Size, class _Tp>
+inline _ForwardIter __ufill_n(_ForwardIter __first, _Size __n, const _Tp& __x,
+ const bidirectional_iterator_tag &)
+{ return __ufill_n(__first, __n, __x); }
+#endif
+
+template <class _ForwardIter, class _Size, class _Tp>
+inline _ForwardIter __uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x) {
+ _ForwardIter __last = __first + __n;
+ __ufill(__first, __last, __x, random_access_iterator_tag(), (ptrdiff_t*)0);
+ return __last;
+}
+
+template <class _ForwardIter, class _Size, class _Tp>
+inline _ForwardIter __ufill_n(_ForwardIter __first, _Size __n, const _Tp& __x,
+ const random_access_iterator_tag &)
+{ return __uninitialized_fill_n(__first, __n, __x); }
+
+/* __uninitialized_init is an internal algo to init a range with a value
+ * built using default constructor. It is only called with pointer as
+ * iterator.
+ */
+template <class _ForwardIter, class _Size, class _Tp>
+inline _ForwardIter __uinit_aux_aux(_ForwardIter __first, _Size __n, const _Tp& __val,
+ const __false_type& /*_HasDefaultZero*/)
+{ return __uninitialized_fill_n(__first, __n, __val); }
+
+template <class _ForwardIter, class _Size, class _Tp>
+inline _ForwardIter __uinit_aux_aux(_ForwardIter __first, _Size __n, const _Tp& /* __val */,
+ const __true_type& /*_HasDefaultZero*/) {
+ memset((unsigned char*)__first, 0, __n * sizeof(_Tp));
+ return __first + __n;
+}
+
+template <class _ForwardIter, class _Size, class _Tp>
+inline _ForwardIter __uinit_aux(_ForwardIter __first, _Size __n, const _Tp&,
+ const __true_type& /*_TrivialInit*/)
+{ return __first + __n; }
+
+template <class _ForwardIter, class _Size, class _Tp>
+inline _ForwardIter __uinit_aux(_ForwardIter __first, _Size __n, const _Tp& __val,
+ const __false_type& /*_TrivialInit*/)
+{ return __uinit_aux_aux(__first, __n, __val, _HasDefaultZeroValue(__first)._Answer()); }
+
+template <class _ForwardIter, class _Size, class _Tp>
+inline _ForwardIter __uninitialized_init(_ForwardIter __first, _Size __n, const _Tp& __val)
+{ return __uinit_aux(__first, __n, __val, _UseTrivialInit(__first)._Answer()); }
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _ForwardIter, class _Size, class _Tp>
+inline void
+uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x)
+{ _STLP_PRIV __ufill_n(__first, __n, __x, _STLP_ITERATOR_CATEGORY(__first, _ForwardIter)); }
+
+// Extensions: __uninitialized_copy_copy, __uninitialized_copy_fill,
+// __uninitialized_fill_copy.
+
+// __uninitialized_copy_copy
+// Copies [first1, last1) into [result, result + (last1 - first1)), and
+// copies [first2, last2) into
+// [result + (last1 - first1), result + (last1 - first1) + (last2 - first2)).
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _InputIter1, class _InputIter2, class _ForwardIter>
+inline _ForwardIter
+__uninitialized_copy_copy(_InputIter1 __first1, _InputIter1 __last1,
+ _InputIter2 __first2, _InputIter2 __last2,
+ _ForwardIter __result) {
+ _ForwardIter __new_result = uninitialized_copy(__first1, __last1, __result);
+ _STLP_TRY {
+ return uninitialized_copy(__first2, __last2, __new_result);
+ }
+ _STLP_UNWIND(_STLP_STD::_Destroy_Range(__result, __new_result))
+ _STLP_RET_AFTER_THROW(__result)
+}
+
+// __uninitialized_fill_copy
+// Fills [result, mid) with x, and copies [first, last) into
+// [mid, mid + (last - first)).
+template <class _ForwardIter, class _Tp, class _InputIter>
+inline _ForwardIter
+__uninitialized_fill_copy(_ForwardIter __result, _ForwardIter __mid, const _Tp& __x,
+ _InputIter __first, _InputIter __last) {
+ uninitialized_fill(__result, __mid, __x);
+ _STLP_TRY {
+ return uninitialized_copy(__first, __last, __mid);
+ }
+ _STLP_UNWIND(_STLP_STD::_Destroy_Range(__result, __mid))
+ _STLP_RET_AFTER_THROW(__result)
+}
+
+// __uninitialized_copy_fill
+// Copies [first1, last1) into [first2, first2 + (last1 - first1)), and
+// fills [first2 + (last1 - first1), last2) with x.
+template <class _Iter, class _Tp>
+inline void
+__uninitialized_copy_fill(_Iter __first1, _Iter __last1, _Iter __first2, _Iter __last2,
+ const _Tp& __x) {
+ _Iter __mid2 = uninitialized_copy(__first1, __last1, __first2);
+ _STLP_TRY {
+ uninitialized_fill(__mid2, __last2, __x);
+ }
+ _STLP_UNWIND(_STLP_STD::_Destroy_Range(__first2, __mid2))
+}
+
+/* __uninitialized_move:
+ * This function is used internaly and only with pointers as iterators.
+ */
+template <class _InputIter, class _ForwardIter, class _TrivialUCpy>
+inline _ForwardIter
+__uninitialized_move(_InputIter __first, _InputIter __last, _ForwardIter __result,
+ _TrivialUCpy __trivial_ucpy, const __false_type& /*_Movable*/)
+{ return __ucopy_ptrs(__first, __last, __result, __trivial_ucpy); }
+
+template <class _InputIter, class _ForwardIter, class _TrivialUCpy>
+_STLP_INLINE_LOOP
+_ForwardIter
+__uninitialized_move(_InputIter __first, _InputIter __last, _ForwardIter __result,
+ _TrivialUCpy , const __true_type& /*_Movable*/) {
+ //Move constructor should not throw so we do not need to take care of exceptions here.
+ for (ptrdiff_t __n = __last - __first ; __n > 0; --__n) {
+ _Move_Construct(&*__result, *__first);
+ ++__first; ++__result;
+ }
+ return __result;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_UNINITIALIZED_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_unordered_map.h b/sources/android/stlport/stlport/stl/_unordered_map.h
new file mode 100644
index 0000000..f2b017d
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_unordered_map.h
@@ -0,0 +1,443 @@
+/*
+ * Copyright (c) 2004
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_UNORDERED_MAP_H
+#define _STLP_INTERNAL_UNORDERED_MAP_H
+
+#ifndef _STLP_INTERNAL_HASHTABLE_H
+# include <stl/_hashtable.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//Specific iterator traits creation
+_STLP_CREATE_HASH_ITERATOR_TRAITS(UnorderedMapTraitsT, traits)
+
+_STLP_BEGIN_TR1_NAMESPACE
+
+template <class _Key, class _Tp, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Key>),
+ _STLP_DFL_TMPL_PARAM(_EqualKey, equal_to<_Key>),
+ _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_STLP_CONST _Key, _Tp) >
+class unordered_map
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ : public __stlport_class<unordered_map<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> >
+#endif
+{
+private:
+ typedef unordered_map<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> _Self;
+public:
+ typedef _Key key_type;
+ typedef _Tp data_type;
+ typedef _Tp mapped_type;
+ typedef pair<_STLP_CONST key_type, data_type> value_type;
+private:
+ //Specific iterator traits creation
+ typedef _STLP_PRIV _UnorderedMapTraitsT<value_type> _UnorderedMapTraits;
+
+public:
+ typedef hashtable<value_type, key_type, _HashFcn, _UnorderedMapTraits,
+ _STLP_SELECT1ST(value_type, _Key), _EqualKey, _Alloc > _Ht;
+
+ typedef typename _Ht::hasher hasher;
+ typedef typename _Ht::key_equal key_equal;
+
+ typedef typename _Ht::size_type size_type;
+ typedef typename _Ht::difference_type difference_type;
+ typedef typename _Ht::pointer pointer;
+ typedef typename _Ht::const_pointer const_pointer;
+ typedef typename _Ht::reference reference;
+ typedef typename _Ht::const_reference const_reference;
+
+ typedef typename _Ht::iterator iterator;
+ typedef typename _Ht::const_iterator const_iterator;
+ typedef typename _Ht::local_iterator local_iterator;
+ typedef typename _Ht::const_local_iterator const_local_iterator;
+
+ typedef typename _Ht::allocator_type allocator_type;
+
+ hasher hash_function() const { return _M_ht.hash_funct(); }
+ key_equal key_eq() const { return _M_ht.key_eq(); }
+ allocator_type get_allocator() const { return _M_ht.get_allocator(); }
+
+private:
+ _Ht _M_ht;
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+public:
+ explicit unordered_map(size_type __n = 0, const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ unordered_map(__move_source<_Self> src)
+ : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {}
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ unordered_map(_InputIterator __f, _InputIterator __l,
+ size_type __n = 0, const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_unique(__f, __l); }
+#else
+ unordered_map(const value_type* __f, const value_type* __l,
+ size_type __n = 0, const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_unique(__f, __l); }
+
+ unordered_map(const_iterator __f, const_iterator __l,
+ size_type __n = 0, const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_unique(__f, __l); }
+#endif /*_STLP_MEMBER_TEMPLATES */
+
+ _Self& operator = (const _Self& __other)
+ { _M_ht = __other._M_ht; return *this; }
+
+ size_type size() const { return _M_ht.size(); }
+ size_type max_size() const { return _M_ht.max_size(); }
+ bool empty() const { return _M_ht.empty(); }
+ void swap(_Self& __hs) { _M_ht.swap(__hs._M_ht); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+ iterator begin() { return _M_ht.begin(); }
+ iterator end() { return _M_ht.end(); }
+ const_iterator begin() const { return _M_ht.begin(); }
+ const_iterator end() const { return _M_ht.end(); }
+
+ pair<iterator,bool> insert(const value_type& __obj)
+ { return _M_ht.insert_unique(__obj); }
+ iterator insert(const_iterator /*__hint*/, const value_type& __obj)
+ { return _M_ht.insert_unique(__obj); }
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void insert(_InputIterator __f, _InputIterator __l)
+#else
+ void insert(const value_type* __f, const value_type* __l)
+ { _M_ht.insert_unique(__f,__l); }
+ void insert(const_iterator __f, const_iterator __l)
+#endif /*_STLP_MEMBER_TEMPLATES */
+ { _M_ht.insert_unique(__f, __l); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __key) { return _M_ht.find(__key); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ _Tp& operator[](const _KT& __key) {
+ iterator __it = _M_ht.find(__key);
+ return (__it == _M_ht.end() ?
+ _M_ht._M_insert(value_type(__key, _STLP_DEFAULT_CONSTRUCTED(_Tp))).second :
+ (*__it).second );
+ }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __key) const { return _M_ht.count(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator, iterator> equal_range(const _KT& __key)
+ { return _M_ht.equal_range(__key); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator> equal_range(const _KT& __key) const
+ { return _M_ht.equal_range(__key); }
+
+ size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
+ void erase(const_iterator __it) { _M_ht.erase(__it); }
+ void erase(const_iterator __f, const_iterator __l) { _M_ht.erase(__f, __l); }
+ void clear() { _M_ht.clear(); }
+
+ size_type bucket_count() const { return _M_ht.bucket_count(); }
+ size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
+ size_type bucket_size(size_type __n) const { return _M_ht.elems_in_bucket(__n); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type bucket(const _KT& __k) const { return _M_ht.bucket(__k); }
+ local_iterator begin(size_type __n) { return _M_ht.begin(__n); }
+ local_iterator end(size_type __n) { return _M_ht.end(__n); }
+ const_local_iterator begin(size_type __n) const { return _M_ht.begin(__n); }
+ const_local_iterator end(size_type __n) const { return _M_ht.end(__n); }
+
+ float load_factor() const { return _M_ht.load_factor(); }
+ float max_load_factor() const { return _M_ht.max_load_factor(); }
+ void max_load_factor(float __val) { _M_ht.max_load_factor(__val); }
+ void rehash(size_type __hint) { _M_ht.rehash(__hint); }
+
+#if defined (__DMC__) // disable operator==(pair<x,unordered_map>, pair<x,unordered_map>)
+ bool operator==(const _Self&) const;
+#endif
+};
+
+_STLP_END_NAMESPACE
+
+//Specific iterator traits creation
+_STLP_CREATE_HASH_ITERATOR_TRAITS(UnorderedMultimapTraitsT, traits)
+
+_STLP_BEGIN_TR1_NAMESPACE
+
+template <class _Key, class _Tp, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Key>),
+ _STLP_DFL_TMPL_PARAM(_EqualKey, equal_to<_Key>),
+ _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_STLP_CONST _Key, _Tp) >
+class unordered_multimap
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ : public __stlport_class<unordered_multimap<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> >
+#endif
+{
+private:
+ typedef unordered_multimap<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> _Self;
+public:
+ typedef _Key key_type;
+ typedef _Tp data_type;
+ typedef _Tp mapped_type;
+ typedef pair<_STLP_CONST key_type, data_type> value_type;
+private:
+ //Specific iterator traits creation
+ typedef _STLP_PRIV _UnorderedMultimapTraitsT<value_type> _UnorderedMultimapTraits;
+
+public:
+ typedef hashtable<value_type, key_type, _HashFcn, _UnorderedMultimapTraits,
+ _STLP_SELECT1ST(value_type, _Key), _EqualKey, _Alloc > _Ht;
+
+ typedef typename _Ht::hasher hasher;
+ typedef typename _Ht::key_equal key_equal;
+
+ typedef typename _Ht::size_type size_type;
+ typedef typename _Ht::difference_type difference_type;
+ typedef typename _Ht::pointer pointer;
+ typedef typename _Ht::const_pointer const_pointer;
+ typedef typename _Ht::reference reference;
+ typedef typename _Ht::const_reference const_reference;
+
+ typedef typename _Ht::iterator iterator;
+ typedef typename _Ht::const_iterator const_iterator;
+ typedef typename _Ht::local_iterator local_iterator;
+ typedef typename _Ht::const_local_iterator const_local_iterator;
+
+ typedef typename _Ht::allocator_type allocator_type;
+
+ hasher hash_function() const { return _M_ht.hash_funct(); }
+ key_equal key_eq() const { return _M_ht.key_eq(); }
+ allocator_type get_allocator() const { return _M_ht.get_allocator(); }
+
+private:
+ _Ht _M_ht;
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+public:
+ explicit unordered_multimap(size_type __n = 0, const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ unordered_multimap(__move_source<_Self> src)
+ : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {}
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ unordered_multimap(_InputIterator __f, _InputIterator __l,
+ size_type __n = 0, const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_equal(__f, __l); }
+#else
+ unordered_multimap(const value_type* __f, const value_type* __l,
+ size_type __n = 0, const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_equal(__f, __l); }
+
+ unordered_multimap(const_iterator __f, const_iterator __l,
+ size_type __n = 0, const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_equal(__f, __l); }
+#endif /*_STLP_MEMBER_TEMPLATES */
+
+ _Self& operator = (const _Self& __other)
+ { _M_ht = __other._M_ht; return *this; }
+
+ size_type size() const { return _M_ht.size(); }
+ size_type max_size() const { return _M_ht.max_size(); }
+ bool empty() const { return _M_ht.empty(); }
+ void swap(_Self& __hs) { _M_ht.swap(__hs._M_ht); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+ iterator begin() { return _M_ht.begin(); }
+ iterator end() { return _M_ht.end(); }
+ const_iterator begin() const { return _M_ht.begin(); }
+ const_iterator end() const { return _M_ht.end(); }
+
+ iterator insert(const value_type& __obj)
+ { return _M_ht.insert_equal(__obj); }
+ iterator insert(const_iterator /*__hint*/, const value_type& __obj)
+ { return _M_ht.insert_equal(__obj); }
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void insert(_InputIterator __f, _InputIterator __l)
+#else
+ void insert(const value_type* __f, const value_type* __l)
+ { _M_ht.insert_equal(__f,__l); }
+ void insert(const_iterator __f, const_iterator __l)
+#endif /*_STLP_MEMBER_TEMPLATES */
+ { _M_ht.insert_equal(__f, __l); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __key) { return _M_ht.find(__key); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __key) const { return _M_ht.count(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator, iterator> equal_range(const _KT& __key)
+ { return _M_ht.equal_range(__key); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator> equal_range(const _KT& __key) const
+ { return _M_ht.equal_range(__key); }
+
+ size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
+ void erase(const_iterator __it) { _M_ht.erase(__it); }
+ void erase(const_iterator __f, const_iterator __l) { _M_ht.erase(__f, __l); }
+ void clear() { _M_ht.clear(); }
+
+ size_type bucket_count() const { return _M_ht.bucket_count(); }
+ size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
+ size_type bucket_size(size_type __n) const { return _M_ht.elems_in_bucket(__n); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type bucket(const _KT& __k) const { return _M_ht.bucket(__k); }
+ local_iterator begin(size_type __n) { return _M_ht.begin(__n); }
+ local_iterator end(size_type __n) { return _M_ht.end(__n); }
+ const_local_iterator begin(size_type __n) const { return _M_ht.begin(__n); }
+ const_local_iterator end(size_type __n) const { return _M_ht.end(__n); }
+
+ float load_factor() const { return _M_ht.load_factor(); }
+ float max_load_factor() const { return _M_ht.max_load_factor(); }
+ void max_load_factor(float __val) { _M_ht.max_load_factor(__val); }
+ void rehash(size_type __hint) { _M_ht.rehash(__hint); }
+};
+
+#define _STLP_TEMPLATE_HEADER template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
+#define _STLP_TEMPLATE_CONTAINER unordered_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>
+
+#include <stl/_relops_hash_cont.h>
+
+#undef _STLP_TEMPLATE_CONTAINER
+#define _STLP_TEMPLATE_CONTAINER unordered_multimap<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>
+
+#include <stl/_relops_hash_cont.h>
+
+#undef _STLP_TEMPLATE_CONTAINER
+#undef _STLP_TEMPLATE_HEADER
+
+_STLP_END_NAMESPACE
+
+// Specialization of insert_iterator so that it will work for unordered_map
+// and unordered_multimap.
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+# if !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
+struct __move_traits<_STLP_TR1 unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> > :
+ _STLP_PRIV __move_traits_help<typename _STLP_TR1 unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>::_Ht>
+{};
+
+template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
+struct __move_traits<_STLP_TR1 unordered_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> > :
+ _STLP_PRIV __move_traits_help<typename _STLP_TR1 unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>::_Ht>
+{};
+# endif
+
+template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
+class insert_iterator<_STLP_TR1 unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
+protected:
+ typedef _STLP_TR1 unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container;
+ _Container* container;
+public:
+ typedef _Container container_type;
+ typedef output_iterator_tag iterator_category;
+ typedef void value_type;
+ typedef void difference_type;
+ typedef void pointer;
+ typedef void reference;
+
+ insert_iterator(_Container& __x) : container(&__x) {}
+ insert_iterator(_Container& __x, typename _Container::iterator)
+ : container(&__x) {}
+ insert_iterator<_Container>&
+ operator=(const typename _Container::value_type& __val) {
+ container->insert(__val);
+ return *this;
+ }
+ insert_iterator<_Container>& operator*() { return *this; }
+ insert_iterator<_Container>& operator++() { return *this; }
+ insert_iterator<_Container>& operator++(int) { return *this; }
+};
+
+template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
+class insert_iterator<_STLP_TR1 unordered_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
+protected:
+ typedef _STLP_TR1 unordered_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container;
+ _Container* container;
+ typename _Container::iterator iter;
+public:
+ typedef _Container container_type;
+ typedef output_iterator_tag iterator_category;
+ typedef void value_type;
+ typedef void difference_type;
+ typedef void pointer;
+ typedef void reference;
+
+ insert_iterator(_Container& __x) : container(&__x) {}
+ insert_iterator(_Container& __x, typename _Container::iterator)
+ : container(&__x) {}
+ insert_iterator<_Container>&
+ operator=(const typename _Container::value_type& __val) {
+ container->insert(__val);
+ return *this;
+ }
+ insert_iterator<_Container>& operator*() { return *this; }
+ insert_iterator<_Container>& operator++() { return *this; }
+ insert_iterator<_Container>& operator++(int) { return *this; }
+};
+
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_UNORDERED_MAP_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_unordered_set.h b/sources/android/stlport/stlport/stl/_unordered_set.h
new file mode 100644
index 0000000..ef5f5fe
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_unordered_set.h
@@ -0,0 +1,418 @@
+/*
+ * Copyright (c) 2004
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_UNORDERED_SET_H
+#define _STLP_INTERNAL_UNORDERED_SET_H
+
+#ifndef _STLP_INTERNAL_HASHTABLE_H
+# include <stl/_hashtable.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//Specific iterator traits creation
+_STLP_CREATE_HASH_ITERATOR_TRAITS(UnorderedSetTraitsT, Const_traits)
+
+_STLP_BEGIN_TR1_NAMESPACE
+
+template <class _Value, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Value>),
+ _STLP_DFL_TMPL_PARAM(_EqualKey, equal_to<_Value>),
+ _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Value>) >
+class unordered_set
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ : public __stlport_class<unordered_set<_Value, _HashFcn, _EqualKey, _Alloc> >
+#endif
+{
+ typedef unordered_set<_Value, _HashFcn, _EqualKey, _Alloc> _Self;
+ //Specific iterator traits creation
+ typedef _STLP_PRIV _UnorderedSetTraitsT<_Value> _UnorderedSetTraits;
+public:
+ typedef hashtable<_Value, _Value, _HashFcn,
+ _UnorderedSetTraits, _STLP_PRIV _Identity<_Value>, _EqualKey, _Alloc> _Ht;
+public:
+ typedef typename _Ht::key_type key_type;
+ typedef typename _Ht::value_type value_type;
+ typedef typename _Ht::hasher hasher;
+ typedef typename _Ht::key_equal key_equal;
+
+ typedef typename _Ht::size_type size_type;
+ typedef typename _Ht::difference_type difference_type;
+ typedef typename _Ht::pointer pointer;
+ typedef typename _Ht::const_pointer const_pointer;
+ typedef typename _Ht::reference reference;
+ typedef typename _Ht::const_reference const_reference;
+
+ typedef typename _Ht::iterator iterator;
+ typedef typename _Ht::const_iterator const_iterator;
+ typedef typename _Ht::local_iterator local_iterator;
+ typedef typename _Ht::const_local_iterator const_local_iterator;
+
+ typedef typename _Ht::allocator_type allocator_type;
+
+ hasher hash_function() const { return _M_ht.hash_funct(); }
+ key_equal key_eq() const { return _M_ht.key_eq(); }
+ allocator_type get_allocator() const { return _M_ht.get_allocator(); }
+
+private:
+ _Ht _M_ht;
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+public:
+ explicit unordered_set(size_type __n = 0, const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ unordered_set(__move_source<_Self> src)
+ : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {}
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ unordered_set(_InputIterator __f, _InputIterator __l,
+ size_type __n = 0, const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_unique(__f, __l); }
+#else
+ unordered_set(const value_type* __f, const value_type* __l,
+ size_type __n = 0, const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_unique(__f, __l); }
+
+ unordered_set(const_iterator __f, const_iterator __l,
+ size_type __n = 0, const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_unique(__f, __l); }
+#endif /*_STLP_MEMBER_TEMPLATES */
+
+ _Self& operator = (const _Self& __other)
+ { _M_ht = __other._M_ht; return *this; }
+
+ size_type size() const { return _M_ht.size(); }
+ size_type max_size() const { return _M_ht.max_size(); }
+ bool empty() const { return _M_ht.empty(); }
+ void swap(_Self& __hs) { _M_ht.swap(__hs._M_ht); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+ iterator begin() { return _M_ht.begin(); }
+ iterator end() { return _M_ht.end(); }
+ const_iterator begin() const { return _M_ht.begin(); }
+ const_iterator end() const { return _M_ht.end(); }
+
+ pair<iterator, bool> insert(const value_type& __obj)
+ { return _M_ht.insert_unique(__obj); }
+ iterator insert(const_iterator /*__hint*/, const value_type& __obj)
+ { return _M_ht.insert_unique(__obj); }
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void insert(_InputIterator __f, _InputIterator __l)
+#else
+ void insert(const_iterator __f, const_iterator __l)
+ {_M_ht.insert_unique(__f, __l); }
+ void insert(const value_type* __f, const value_type* __l)
+#endif
+ { _M_ht.insert_unique(__f,__l); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __key) { return _M_ht.find(__key); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __key) const { return _M_ht.count(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator, iterator> equal_range(const _KT& __key)
+ { return _M_ht.equal_range(__key); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator> equal_range(const _KT& __key) const
+ { return _M_ht.equal_range(__key); }
+
+ size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
+ void erase(const_iterator __it) { _M_ht.erase(__it); }
+ void erase(const_iterator __f, const_iterator __l) { _M_ht.erase(__f, __l); }
+ void clear() { _M_ht.clear(); }
+
+ size_type bucket_count() const { return _M_ht.bucket_count(); }
+ size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
+ size_type bucket_size(size_type __n) const { return _M_ht.elems_in_bucket(__n); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type bucket(const _KT& __k) const { return _M_ht.bucket(__k); }
+ local_iterator begin(size_type __n) { return _M_ht.begin(__n); }
+ local_iterator end(size_type __n) { return _M_ht.end(__n); }
+ const_local_iterator begin(size_type __n) const { return _M_ht.begin(__n); }
+ const_local_iterator end(size_type __n) const { return _M_ht.end(__n); }
+
+ float load_factor() const { return _M_ht.load_factor(); }
+ float max_load_factor() const { return _M_ht.max_load_factor(); }
+ void max_load_factor(float __val) { _M_ht.max_load_factor(__val); }
+ void rehash(size_type __hint) { _M_ht.rehash(__hint); }
+};
+
+_STLP_END_NAMESPACE
+
+//Specific iterator traits creation
+_STLP_CREATE_HASH_ITERATOR_TRAITS(UnorderedMultisetTraitsT, Const_traits)
+
+_STLP_BEGIN_TR1_NAMESPACE
+
+template <class _Value, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Value>),
+ _STLP_DFL_TMPL_PARAM(_EqualKey, equal_to<_Value>),
+ _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Value>) >
+class unordered_multiset
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ : public __stlport_class<unordered_multiset<_Value, _HashFcn, _EqualKey, _Alloc> >
+#endif
+{
+ typedef unordered_multiset<_Value, _HashFcn, _EqualKey, _Alloc> _Self;
+ //Specific iterator traits creation
+ typedef _STLP_PRIV _UnorderedMultisetTraitsT<_Value> _UnorderedMultisetTraits;
+public:
+ typedef hashtable<_Value, _Value, _HashFcn,
+ _UnorderedMultisetTraits, _STLP_PRIV _Identity<_Value>, _EqualKey, _Alloc> _Ht;
+
+ typedef typename _Ht::key_type key_type;
+ typedef typename _Ht::value_type value_type;
+ typedef typename _Ht::hasher hasher;
+ typedef typename _Ht::key_equal key_equal;
+
+ typedef typename _Ht::size_type size_type;
+ typedef typename _Ht::difference_type difference_type;
+ typedef typename _Ht::pointer pointer;
+ typedef typename _Ht::const_pointer const_pointer;
+ typedef typename _Ht::reference reference;
+ typedef typename _Ht::const_reference const_reference;
+
+ typedef typename _Ht::iterator iterator;
+ typedef typename _Ht::const_iterator const_iterator;
+ typedef typename _Ht::local_iterator local_iterator;
+ typedef typename _Ht::const_local_iterator const_local_iterator;
+
+ typedef typename _Ht::allocator_type allocator_type;
+
+ hasher hash_function() const { return _M_ht.hash_funct(); }
+ key_equal key_eq() const { return _M_ht.key_eq(); }
+ allocator_type get_allocator() const { return _M_ht.get_allocator(); }
+
+private:
+ _Ht _M_ht;
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+public:
+ explicit unordered_multiset(size_type __n = 0, const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ unordered_multiset(__move_source<_Self> src)
+ : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {}
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ unordered_multiset(_InputIterator __f, _InputIterator __l,
+ size_type __n = 0, const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_equal(__f, __l); }
+#else
+ unordered_multiset(const value_type* __f, const value_type* __l,
+ size_type __n = 0, const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_equal(__f, __l); }
+
+ unordered_multiset(const_iterator __f, const_iterator __l,
+ size_type __n = 0, const hasher& __hf = hasher(),
+ const key_equal& __eql = key_equal(),
+ const allocator_type& __a = allocator_type())
+ : _M_ht(__n, __hf, __eql, __a)
+ { _M_ht.insert_equal(__f, __l); }
+#endif /*_STLP_MEMBER_TEMPLATES */
+
+ _Self& operator = (const _Self& __other)
+ { _M_ht = __other._M_ht; return *this; }
+
+ size_type size() const { return _M_ht.size(); }
+ size_type max_size() const { return _M_ht.max_size(); }
+ bool empty() const { return _M_ht.empty(); }
+ void swap(_Self& hs) { _M_ht.swap(hs._M_ht); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+ iterator begin() { return _M_ht.begin(); }
+ iterator end() { return _M_ht.end(); }
+ const_iterator begin() const { return _M_ht.begin(); }
+ const_iterator end() const { return _M_ht.end(); }
+
+ iterator insert(const value_type& __obj)
+ { return _M_ht.insert_equal(__obj); }
+ iterator insert(const_iterator /*__hint*/, const value_type& __obj)
+ { return _M_ht.insert_equal(__obj); }
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void insert(_InputIterator __f, _InputIterator __l)
+#else
+ void insert(const value_type* __f, const value_type* __l)
+ { _M_ht.insert_equal(__f,__l); }
+ void insert(const_iterator __f, const_iterator __l)
+#endif /*_STLP_MEMBER_TEMPLATES */
+ { _M_ht.insert_equal(__f, __l); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __key) { return _M_ht.find(__key); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __key) const { return _M_ht.count(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator, iterator> equal_range(const _KT& __key)
+ { return _M_ht.equal_range(__key); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator> equal_range(const _KT& __key) const
+ { return _M_ht.equal_range(__key); }
+
+ size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
+ void erase(const_iterator __it) { _M_ht.erase(__it); }
+ void erase(const_iterator __f, const_iterator __l) { _M_ht.erase(__f, __l); }
+ void clear() { _M_ht.clear(); }
+
+ size_type bucket_count() const { return _M_ht.bucket_count(); }
+ size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
+ size_type bucket_size(size_type __n) const { return _M_ht.elems_in_bucket(__n); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type bucket(const _KT& __k) const { return _M_ht.bucket(__k); }
+ local_iterator begin(size_type __n) { return _M_ht.begin(__n); }
+ local_iterator end(size_type __n) { return _M_ht.end(__n); }
+ const_local_iterator begin(size_type __n) const { return _M_ht.begin(__n); }
+ const_local_iterator end(size_type __n) const { return _M_ht.end(__n); }
+
+ float load_factor() const { return _M_ht.load_factor(); }
+ float max_load_factor() const { return _M_ht.max_load_factor(); }
+ void max_load_factor(float __val) { _M_ht.max_load_factor(__val); }
+ void rehash(size_type __hint) { _M_ht.rehash(__hint); }
+};
+
+#define _STLP_TEMPLATE_HEADER template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+#define _STLP_TEMPLATE_CONTAINER unordered_set<_Value,_HashFcn,_EqualKey,_Alloc>
+
+#include <stl/_relops_hash_cont.h>
+
+#undef _STLP_TEMPLATE_CONTAINER
+#define _STLP_TEMPLATE_CONTAINER unordered_multiset<_Value,_HashFcn,_EqualKey,_Alloc>
+#include <stl/_relops_hash_cont.h>
+
+#undef _STLP_TEMPLATE_CONTAINER
+#undef _STLP_TEMPLATE_HEADER
+
+_STLP_END_NAMESPACE
+
+// Specialization of insert_iterator so that it will work for unordered_set
+// and unordered_multiset.
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+# if !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+struct __move_traits<_STLP_TR1 unordered_set<_Value, _HashFcn, _EqualKey, _Alloc> > :
+ _STLP_PRIV __move_traits_aux<typename _STLP_TR1 unordered_set<_Value, _HashFcn, _EqualKey, _Alloc>::_Ht>
+{};
+
+template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+struct __move_traits<_STLP_TR1 unordered_multiset<_Value, _HashFcn, _EqualKey, _Alloc> > :
+ _STLP_PRIV __move_traits_aux<typename _STLP_TR1 unordered_multiset<_Value, _HashFcn, _EqualKey, _Alloc>::_Ht>
+{};
+# endif
+
+template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+class insert_iterator<_STLP_TR1 unordered_set<_Value, _HashFcn, _EqualKey, _Alloc> > {
+protected:
+ typedef _STLP_TR1 unordered_set<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
+ _Container* container;
+public:
+ typedef _Container container_type;
+ typedef output_iterator_tag iterator_category;
+ typedef void value_type;
+ typedef void difference_type;
+ typedef void pointer;
+ typedef void reference;
+
+ insert_iterator(_Container& __x) : container(&__x) {}
+ insert_iterator(_Container& __x, typename _Container::iterator)
+ : container(&__x) {}
+ insert_iterator<_Container>&
+ operator=(const typename _Container::value_type& __val) {
+ container->insert(__val);
+ return *this;
+ }
+ insert_iterator<_Container>& operator*() { return *this; }
+ insert_iterator<_Container>& operator++() { return *this; }
+ insert_iterator<_Container>& operator++(int) { return *this; }
+};
+
+template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
+class insert_iterator<_STLP_TR1 unordered_multiset<_Value, _HashFcn, _EqualKey, _Alloc> > {
+protected:
+ typedef _STLP_TR1 unordered_multiset<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
+ _Container* container;
+ typename _Container::iterator iter;
+public:
+ typedef _Container container_type;
+ typedef output_iterator_tag iterator_category;
+ typedef void value_type;
+ typedef void difference_type;
+ typedef void pointer;
+ typedef void reference;
+
+ insert_iterator(_Container& __x) : container(&__x) {}
+ insert_iterator(_Container& __x, typename _Container::iterator)
+ : container(&__x) {}
+ insert_iterator<_Container>&
+ operator=(const typename _Container::value_type& __val) {
+ container->insert(__val);
+ return *this;
+ }
+ insert_iterator<_Container>& operator*() { return *this; }
+ insert_iterator<_Container>& operator++() { return *this; }
+ insert_iterator<_Container>& operator++(int) { return *this; }
+};
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_INTERNAL_UNORDERED_SET_H */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/stl/_valarray.c b/sources/android/stlport/stlport/stl/_valarray.c
new file mode 100644
index 0000000..ee534a9
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_valarray.c
@@ -0,0 +1,191 @@
+/*
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_VALARRAY_C
+#define _STLP_VALARRAY_C
+
+#ifndef _STLP_VALARRAY_H
+# include <stl/_valarray.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Tp>
+_Valarray_bool valarray<_Tp>:: operator!() const {
+ _Valarray_bool __tmp(this->size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ __tmp[__i] = !(*this)[__i];
+ return __tmp;
+}
+
+// Behavior is undefined if __x and *this have different sizes
+template <class _Tp>
+valarray<_Tp>& valarray<_Tp>::operator=(const slice_array<_Tp>& __x) {
+ _STLP_ASSERT(__x._M_slice.size() == this->size())
+ size_t __index = __x._M_slice.start();
+ for (size_t __i = 0;
+ __i < __x._M_slice.size();
+ ++__i, __index += __x._M_slice.stride())
+ (*this)[__i] = __x._M_array[__index];
+ return *this;
+}
+
+template <class _Tp>
+valarray<_Tp> valarray<_Tp>::operator[](slice __slice) const {
+ valarray<_Tp> __tmp(__slice.size(), _NoInit());
+ size_t __index = __slice.start();
+ for (size_t __i = 0;
+ __i < __slice.size();
+ ++__i, __index += __slice.stride())
+ __tmp[__i] = (*this)[__index];
+ return __tmp;
+}
+
+template <class _Size>
+bool _Gslice_Iter_tmpl<_Size>::_M_incr() {
+ size_t __dim = _M_indices.size() - 1;
+ ++_M_step;
+ for (;;) {
+ _M_1d_idx += _M_gslice._M_strides[__dim];
+ if (++_M_indices[__dim] != _M_gslice._M_lengths[__dim])
+ return true;
+ else if (__dim != 0) {
+ _M_1d_idx -= _M_gslice._M_strides[__dim] * _M_gslice._M_lengths[__dim];
+ _M_indices[__dim] = 0;
+ --__dim;
+ }
+ else
+ return false;
+ }
+}
+
+// Behavior is undefined if __x and *this have different sizes, or if
+// __x was constructed from a degenerate gslice.
+template <class _Tp>
+valarray<_Tp>& valarray<_Tp>::operator=(const gslice_array<_Tp>& __x) {
+ if (this->size() != 0) {
+ _Gslice_Iter __i(__x._M_gslice);
+ do
+ (*this)[__i._M_step] = __x._M_array[__i._M_1d_idx];
+ while(__i._M_incr());
+ }
+ return *this;
+}
+
+template <class _Tp>
+valarray<_Tp> valarray<_Tp>::operator[](const gslice& __slice) const {
+ valarray<_Tp> __tmp(__slice._M_size(), _NoInit());
+ if (__tmp.size() != 0) {
+ _Gslice_Iter __i(__slice);
+ do __tmp[__i._M_step] = (*this)[__i._M_1d_idx]; while(__i._M_incr());
+ }
+ return __tmp;
+}
+
+template <class _Tp>
+valarray<_Tp> valarray<_Tp>::operator[](const _Valarray_bool& __mask) const {
+ size_t _p_size = 0;
+ {
+ for (size_t __i = 0; __i < __mask.size(); ++__i)
+ if (__mask[__i]) ++_p_size;
+ }
+
+ valarray<_Tp> __tmp(_p_size, _NoInit());
+ size_t __idx = 0;
+ {
+ for (size_t __i = 0; __i < __mask.size(); ++__i)
+ if (__mask[__i]) __tmp[__idx++] = (*this)[__i];
+ }
+
+ return __tmp;
+}
+
+template <class _Tp>
+valarray<_Tp>& valarray<_Tp>::operator=(const indirect_array<_Tp>& __x) {
+ _STLP_ASSERT(__x._M_addr.size() == this->size())
+ for (size_t __i = 0; __i < __x._M_addr.size(); ++__i)
+ (*this)[__i] = __x._M_array[__x._M_addr[__i]];
+ return *this;
+}
+
+template <class _Tp>
+valarray<_Tp>
+valarray<_Tp>::operator[](const _Valarray_size_t& __addr) const {
+ valarray<_Tp> __tmp(__addr.size(), _NoInit());
+ for (size_t __i = 0; __i < __addr.size(); ++__i)
+ __tmp[__i] = (*this)[__addr[__i]];
+ return __tmp;
+}
+
+//----------------------------------------------------------------------
+// Other valarray noninline member functions
+
+// Shift and cshift
+
+template <class _Tp>
+valarray<_Tp> valarray<_Tp>::shift(int __n) const {
+ valarray<_Tp> __tmp(this->size());
+
+ if (__n >= 0) {
+ if (__n < this->size())
+ copy(this->_M_first + __n, this->_M_first + this->size(),
+ __tmp._M_first);
+ }
+ else {
+ if (-__n < this->size())
+ copy(this->_M_first, this->_M_first + this->size() + __n,
+ __tmp._M_first - __n);
+ }
+ return __tmp;
+}
+
+template <class _Tp>
+valarray<_Tp> valarray<_Tp>::cshift(int __m) const {
+ valarray<_Tp> __tmp(this->size());
+
+ // Reduce __m to an equivalent number in the range [0, size()). We
+ // have to be careful with negative numbers, since the sign of a % b
+ // is unspecified when a < 0.
+ long __n = __m;
+ if (this->size() < (numeric_limits<long>::max)())
+ __n %= long(this->size());
+ if (__n < 0)
+ __n += this->size();
+
+ copy(this->_M_first, this->_M_first + __n,
+ __tmp._M_first + (this->size() - __n));
+ copy(this->_M_first + __n, this->_M_first + this->size(),
+ __tmp._M_first);
+
+ return __tmp;
+}
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_VALARRAY_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_valarray.h b/sources/android/stlport/stlport/stl/_valarray.h
new file mode 100644
index 0000000..cd9641a
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_valarray.h
@@ -0,0 +1,1684 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_VALARRAY_H
+#define _STLP_VALARRAY_H
+
+#ifndef _STLP_INTERNAL_CMATH
+# include <stl/_cmath.h>
+#endif
+
+#ifndef _STLP_INTERNAL_NEW
+# include <stl/_new.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALGO_H
+# include <stl/_algo.h>
+#endif
+
+#ifndef _STLP_INTERNAL_NUMERIC_H
+# include <stl/_numeric.h>
+#endif
+
+#ifndef _STLP_INTERNAL_LIMITS
+# include <stl/_limits.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+class slice;
+class gslice;
+
+template <class _Tp> class valarray;
+typedef valarray<bool> _Valarray_bool;
+typedef valarray<size_t> _Valarray_size_t;
+
+template <class _Tp> class slice_array;
+template <class _Tp> class gslice_array;
+template <class _Tp> class mask_array;
+template <class _Tp> class indirect_array;
+
+//----------------------------------------------------------------------
+// class valarray
+
+// Base class to handle memory allocation and deallocation. We can't just
+// use vector<>, because vector<bool> would be unsuitable as an internal
+// representation for valarray<bool>.
+
+template <class _Tp>
+struct _Valarray_base {
+ _Tp* _M_first;
+ size_t _M_size;
+
+ _Valarray_base() : _M_first(0), _M_size(0) {}
+ _Valarray_base(size_t __n) : _M_first(0), _M_size(0) { _M_allocate(__n); }
+ ~_Valarray_base() { _M_deallocate(); }
+
+ void _M_allocate(size_t __n) {
+ if (__n != 0) {
+ _M_first = __STATIC_CAST(_Tp*, __stl_new(__n * sizeof(_Tp)));
+ _M_size = __n;
+ }
+ else {
+ _M_first = 0;
+ _M_size = 0;
+ }
+ }
+
+ void _M_deallocate() {
+ __stl_delete(_M_first);
+ _M_first = 0;
+ _M_size = 0;
+ }
+};
+
+template <class _Tp>
+class valarray : private _Valarray_base<_Tp>
+{
+ friend class gslice;
+
+public:
+ typedef _Tp value_type;
+
+ // Basic constructors
+ valarray() : _Valarray_base<_Tp>() {}
+ explicit valarray(size_t __n) : _Valarray_base<_Tp>(__n)
+ { uninitialized_fill_n(this->_M_first, this->_M_size, _STLP_DEFAULT_CONSTRUCTED(value_type)); }
+ valarray(const value_type& __x, size_t __n) : _Valarray_base<_Tp>(__n)
+ { uninitialized_fill_n(this->_M_first, this->_M_size, __x); }
+ valarray(const value_type* __p, size_t __n) : _Valarray_base<_Tp>(__n)
+ { uninitialized_copy(__p, __p + __n, this->_M_first); }
+ valarray(const valarray<_Tp>& __x) : _Valarray_base<_Tp>(__x._M_size) {
+ uninitialized_copy(__x._M_first, __x._M_first + __x._M_size,
+ this->_M_first);
+ }
+
+ // Constructors from auxiliary array types
+ valarray(const slice_array<_Tp>&);
+ valarray(const gslice_array<_Tp>&);
+ valarray(const mask_array<_Tp>&);
+ valarray(const indirect_array<_Tp>&);
+
+ // Destructor
+ ~valarray() { _STLP_STD::_Destroy_Range(this->_M_first, this->_M_first + this->_M_size); }
+
+ // Extension: constructor that doesn't initialize valarray elements to a
+ // specific value. This is faster for types such as int and double.
+private:
+ void _M_initialize(const __true_type&) {}
+ void _M_initialize(const __false_type&)
+ { uninitialized_fill_n(this->_M_first, this->_M_size, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+
+public:
+ struct _NoInit {};
+ valarray(size_t __n, _NoInit) : _Valarray_base<_Tp>(__n) {
+ typedef typename __type_traits<_Tp>::has_trivial_default_constructor _Is_Trivial;
+ _M_initialize(_Is_Trivial());
+ }
+
+public: // Assignment
+ // Basic assignment. Note that 'x = y' is undefined if x.size() != y.size()
+ valarray<_Tp>& operator=(const valarray<_Tp>& __x) {
+ _STLP_ASSERT(__x.size() == this->size())
+ if (this != &__x)
+ copy(__x._M_first, __x._M_first + __x._M_size, this->_M_first);
+ return *this;
+ }
+
+ // Scalar assignment
+ valarray<_Tp>& operator=(const value_type& __x) {
+ fill_n(this->_M_first, this->_M_size, __x);
+ return *this;
+ }
+
+ // Assignment of auxiliary array types
+ valarray<_Tp>& operator=(const slice_array<_Tp>&);
+ valarray<_Tp>& operator=(const gslice_array<_Tp>&);
+ valarray<_Tp>& operator=(const mask_array<_Tp>&);
+ valarray<_Tp>& operator=(const indirect_array<_Tp>&);
+
+public: // Element access
+ value_type operator[](size_t __n) const {
+ _STLP_ASSERT(__n < this->size())
+ return this->_M_first[__n];
+ }
+ value_type& operator[](size_t __n) {
+ _STLP_ASSERT(__n < this->size())
+ return this->_M_first[__n];
+ }
+ size_t size() const { return this->_M_size; }
+
+public: // Subsetting operations with auxiliary type
+ valarray<_Tp> operator[](slice) const;
+ slice_array<_Tp> operator[](slice);
+ valarray<_Tp> operator[](const gslice&) const;
+ gslice_array<_Tp> operator[](const gslice&);
+ valarray<_Tp> operator[](const _Valarray_bool&) const;
+ mask_array<_Tp> operator[](const _Valarray_bool&);
+ valarray<_Tp> operator[](const _Valarray_size_t&) const;
+ indirect_array<_Tp> operator[](const _Valarray_size_t&);
+
+public: // Unary operators.
+ valarray<_Tp> operator+() const { return *this; }
+
+ valarray<_Tp> operator-() const {
+ valarray<_Tp> __tmp(this->size(), _NoInit());
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ __tmp[__i] = -(*this)[__i];
+ return __tmp;
+ }
+
+ valarray<_Tp> operator~() const {
+ valarray<_Tp> __tmp(this->size(), _NoInit());
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ __tmp[__i] = ~(*this)[__i];
+ return __tmp;
+ }
+
+ _Valarray_bool operator!() const;
+
+public: // Scalar computed assignment.
+ valarray<_Tp>& operator*= (const value_type& __x) {
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] *= __x;
+ return *this;
+ }
+
+ valarray<_Tp>& operator/= (const value_type& __x) {
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] /= __x;
+ return *this;
+ }
+
+ valarray<_Tp>& operator%= (const value_type& __x) {
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] %= __x;
+ return *this;
+ }
+
+ valarray<_Tp>& operator+= (const value_type& __x) {
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] += __x;
+ return *this;
+ }
+
+ valarray<_Tp>& operator-= (const value_type& __x) {
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] -= __x;
+ return *this;
+ }
+
+ valarray<_Tp>& operator^= (const value_type& __x) {
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] ^= __x;
+ return *this;
+ }
+
+ valarray<_Tp>& operator&= (const value_type& __x) {
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] &= __x;
+ return *this;
+ }
+
+ valarray<_Tp>& operator|= (const value_type& __x) {
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] |= __x;
+ return *this;
+ }
+
+ valarray<_Tp>& operator<<= (const value_type& __x) {
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] <<= __x;
+ return *this;
+ }
+
+ valarray<_Tp>& operator>>= (const value_type& __x) {
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] >>= __x;
+ return *this;
+ }
+
+public: // Array computed assignment.
+ valarray<_Tp>& operator*= (const valarray<_Tp>& __x) {
+ _STLP_ASSERT(__x.size() == this->size())
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] *= __x[__i];
+ return *this;
+ }
+
+ valarray<_Tp>& operator/= (const valarray<_Tp>& __x) {
+ _STLP_ASSERT(__x.size() == this->size())
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] /= __x[__i];
+ return *this;
+ }
+
+ valarray<_Tp>& operator%= (const valarray<_Tp>& __x) {
+ _STLP_ASSERT(__x.size() == this->size())
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] %= __x[__i];
+ return *this;
+ }
+
+ valarray<_Tp>& operator+= (const valarray<_Tp>& __x) {
+ _STLP_ASSERT(__x.size() == this->size())
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] += __x[__i];
+ return *this;
+ }
+
+ valarray<_Tp>& operator-= (const valarray<_Tp>& __x) {
+ _STLP_ASSERT(__x.size() == this->size())
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] -= __x[__i];
+ return *this;
+ }
+
+ valarray<_Tp>& operator^= (const valarray<_Tp>& __x) {
+ _STLP_ASSERT(__x.size() == this->size())
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] ^= __x[__i];
+ return *this;
+ }
+
+ valarray<_Tp>& operator&= (const valarray<_Tp>& __x) {
+ _STLP_ASSERT(__x.size() == this->size())
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] &= __x[__i];
+ return *this;
+ }
+
+ valarray<_Tp>& operator|= (const valarray<_Tp>& __x) {
+ _STLP_ASSERT(__x.size() == this->size())
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] |= __x[__i];
+ return *this;
+ }
+
+ valarray<_Tp>& operator<<= (const valarray<_Tp>& __x) {
+ _STLP_ASSERT(__x.size() == this->size())
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] <<= __x[__i];
+ return *this;
+ }
+
+ valarray<_Tp>& operator>>= (const valarray<_Tp>& __x) {
+ _STLP_ASSERT(__x.size() == this->size())
+ for (size_t __i = 0; __i < this->size(); ++__i)
+ (*this)[__i] >>= __x[__i];
+ return *this;
+ }
+
+public: // Other member functions.
+
+ // The result is undefined for zero-length arrays
+ value_type sum() const {
+ _STLP_ASSERT(this->size() != 0)
+ return accumulate(this->_M_first + 1, this->_M_first + this->_M_size,
+ (*this)[0]);
+ }
+
+ // The result is undefined for zero-length arrays
+ value_type (min) () const {
+ _STLP_ASSERT(this->size() != 0)
+ return *min_element(this->_M_first + 0, this->_M_first + this->_M_size);
+ }
+
+ value_type (max) () const {
+ _STLP_ASSERT(this->size() != 0)
+ return *max_element(this->_M_first + 0, this->_M_first + this->_M_size);
+ }
+
+ valarray<_Tp> shift(int __n) const;
+ valarray<_Tp> cshift(int __n) const;
+
+ valarray<_Tp> apply(value_type __f(value_type)) const {
+ valarray<_Tp> __tmp(this->size());
+ transform(this->_M_first + 0, this->_M_first + this->_M_size, __tmp._M_first,
+ __f);
+ return __tmp;
+ }
+ valarray<_Tp> apply(value_type __f(const value_type&)) const {
+ valarray<_Tp> __tmp(this->size());
+ transform(this->_M_first + 0, this->_M_first + this->_M_size, __tmp._M_first,
+ __f);
+ return __tmp;
+ }
+
+ void resize(size_t __n, value_type __x = value_type()) {
+ _STLP_STD::_Destroy_Range(this->_M_first, this->_M_first + this->_M_size);
+ _Valarray_base<_Tp>::_M_deallocate();
+ _Valarray_base<_Tp>::_M_allocate(__n);
+ uninitialized_fill_n(this->_M_first, this->_M_size, __x);
+ }
+};
+
+//----------------------------------------------------------------------
+// valarray non-member functions.
+
+// Binary arithmetic operations between two arrays. Behavior is
+// undefined if the two arrays do not have the same length.
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator*(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] * __y[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator/(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] / __y[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator%(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] % __y[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator+(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] + __y[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator-(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] - __y[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator^(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] ^ __y[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator&(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] & __y[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator|(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] | __y[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator<<(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] << __y[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator>>(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] >> __y[__i];
+ return __tmp;
+}
+
+// Binary arithmetic operations between an array and a scalar.
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator*(const valarray<_Tp>& __x, const _Tp& __c) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] * __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator*(const _Tp& __c, const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c * __x[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator/(const valarray<_Tp>& __x, const _Tp& __c) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] / __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator/(const _Tp& __c, const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c / __x[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator%(const valarray<_Tp>& __x, const _Tp& __c) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] % __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator%(const _Tp& __c, const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c % __x[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator+(const valarray<_Tp>& __x, const _Tp& __c) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] + __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator+(const _Tp& __c, const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c + __x[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator-(const valarray<_Tp>& __x, const _Tp& __c) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] - __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator-(const _Tp& __c, const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c - __x[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator^(const valarray<_Tp>& __x, const _Tp& __c) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] ^ __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator^(const _Tp& __c, const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c ^ __x[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator&(const valarray<_Tp>& __x, const _Tp& __c) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] & __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator&(const _Tp& __c, const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c & __x[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator|(const valarray<_Tp>& __x, const _Tp& __c) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] | __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator|(const _Tp& __c, const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c | __x[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator<<(const valarray<_Tp>& __x, const _Tp& __c) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] << __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator<<(const _Tp& __c, const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c << __x[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator>>(const valarray<_Tp>& __x, const _Tp& __c) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] >> __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> _STLP_CALL operator>>(const _Tp& __c, const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c >> __x[__i];
+ return __tmp;
+}
+
+// Binary logical operations between two arrays. Behavior is undefined
+// if the two arrays have different lengths. Note that operator== does
+// not do what you might at first expect.
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator==(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] == __y[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator<(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] < __y[__i];
+ return __tmp;
+}
+
+#ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator!=(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] != __y[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator>(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] > __y[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator<=(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] <= __y[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator>=(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] >= __y[__i];
+ return __tmp;
+}
+
+#endif /* _STLP_USE_SEPARATE_RELOPS_NAMESPACE */
+// fbp : swap ?
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator&&(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] && __y[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator||(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ _STLP_ASSERT(__x.size() == __y.size())
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] || __y[__i];
+ return __tmp;
+}
+
+// Logical operations between an array and a scalar.
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator==(const valarray<_Tp>& __x, const _Tp& __c) {
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] == __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator==(const _Tp& __c, const valarray<_Tp>& __x) {
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c == __x[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator!=(const valarray<_Tp>& __x, const _Tp& __c) {
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] != __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator!=(const _Tp& __c, const valarray<_Tp>& __x) {
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c != __x[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator<(const valarray<_Tp>& __x, const _Tp& __c) {
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] < __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator<(const _Tp& __c, const valarray<_Tp>& __x) {
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c < __x[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator>(const valarray<_Tp>& __x, const _Tp& __c) {
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] > __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator>(const _Tp& __c, const valarray<_Tp>& __x) {
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c > __x[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator<=(const valarray<_Tp>& __x, const _Tp& __c) {
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] <= __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator<=(const _Tp& __c, const valarray<_Tp>& __x) {
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c <= __x[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator>=(const valarray<_Tp>& __x, const _Tp& __c) {
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] >= __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator>=(const _Tp& __c, const valarray<_Tp>& __x) {
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c >= __x[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator&&(const valarray<_Tp>& __x, const _Tp& __c) {
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] && __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator&&(const _Tp& __c, const valarray<_Tp>& __x) {
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c && __x[__i];
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator||(const valarray<_Tp>& __x, const _Tp& __c) {
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __x[__i] || __c;
+ return __tmp;
+}
+
+template <class _Tp>
+inline _Valarray_bool _STLP_CALL operator||(const _Tp& __c, const valarray<_Tp>& __x) {
+ _Valarray_bool __tmp(__x.size(), _Valarray_bool::_NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = __c || __x[__i];
+ return __tmp;
+}
+
+// valarray "transcendentals" (the list includes abs and sqrt, which,
+// of course, are not transcendental).
+
+template <class _Tp>
+inline valarray<_Tp> abs(const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::abs(__x[__i]);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> acos(const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::acos(__x[__i]);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> asin(const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::asin(__x[__i]);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> atan(const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::atan(__x[__i]);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> atan2(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::atan2(__x[__i], __y[__i]);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> atan2(const valarray<_Tp>& __x, const _Tp& __c) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::atan2(__x[__i], __c);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> atan2(const _Tp& __c, const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::atan2(__c, __x[__i]);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> cos(const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::cos(__x[__i]);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> cosh(const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::cosh(__x[__i]);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> exp(const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::exp(__x[__i]);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> log(const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::log(__x[__i]);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> log10(const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::log10(__x[__i]);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> pow(const valarray<_Tp>& __x,
+ const valarray<_Tp>& __y) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::pow(__x[__i], __y[__i]);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> pow(const valarray<_Tp>& __x, const _Tp& __c) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::pow(__x[__i], __c);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> pow(const _Tp& __c, const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::pow(__c, __x[__i]);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> sin(const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::sin(__x[__i]);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> sinh(const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::sinh(__x[__i]);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> sqrt(const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::sqrt(__x[__i]);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> tan(const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::tan(__x[__i]);
+ return __tmp;
+}
+
+template <class _Tp>
+inline valarray<_Tp> tanh(const valarray<_Tp>& __x) {
+ typedef typename valarray<_Tp>::_NoInit _NoInit;
+ valarray<_Tp> __tmp(__x.size(), _NoInit());
+ for (size_t __i = 0; __i < __x.size(); ++__i)
+ __tmp[__i] = ::tanh(__x[__i]);
+ return __tmp;
+}
+
+//----------------------------------------------------------------------
+// slice and slice_array
+
+class slice {
+public:
+ slice() : _M_start(0), _M_length(0), _M_stride(0) {}
+ slice(size_t __start, size_t __length, size_t __stride)
+ : _M_start(__start), _M_length(__length), _M_stride(__stride)
+ {}
+ __TRIVIAL_DESTRUCTOR(slice)
+
+ size_t start() const { return _M_start; }
+ size_t size() const { return _M_length; }
+ size_t stride() const { return _M_stride; }
+
+private:
+ size_t _M_start;
+ size_t _M_length;
+ size_t _M_stride;
+};
+
+template <class _Tp>
+class slice_array {
+ friend class valarray<_Tp>;
+public:
+ typedef _Tp value_type;
+
+ void operator=(const valarray<value_type>& __x) const {
+ size_t __index = _M_slice.start();
+ for (size_t __i = 0;
+ __i < _M_slice.size();
+ ++__i, __index += _M_slice.stride())
+ _M_array[__index] = __x[__i];
+ }
+
+ void operator*=(const valarray<value_type>& __x) const {
+ size_t __index = _M_slice.start();
+ for (size_t __i = 0;
+ __i < _M_slice.size();
+ ++__i, __index += _M_slice.stride())
+ _M_array[__index] *= __x[__i];
+ }
+
+ void operator/=(const valarray<value_type>& __x) const {
+ size_t __index = _M_slice.start();
+ for (size_t __i = 0;
+ __i < _M_slice.size();
+ ++__i, __index += _M_slice.stride())
+ _M_array[__index] /= __x[__i];
+ }
+
+ void operator%=(const valarray<value_type>& __x) const {
+ size_t __index = _M_slice.start();
+ for (size_t __i = 0;
+ __i < _M_slice.size();
+ ++__i, __index += _M_slice.stride())
+ _M_array[__index] %= __x[__i];
+ }
+
+ void operator+=(const valarray<value_type>& __x) const {
+ size_t __index = _M_slice.start();
+ for (size_t __i = 0;
+ __i < _M_slice.size();
+ ++__i, __index += _M_slice.stride())
+ _M_array[__index] += __x[__i];
+ }
+
+ void operator-=(const valarray<value_type>& __x) const {
+ size_t __index = _M_slice.start();
+ for (size_t __i = 0;
+ __i < _M_slice.size();
+ ++__i, __index += _M_slice.stride())
+ _M_array[__index] -= __x[__i];
+ }
+
+ void operator^=(const valarray<value_type>& __x) const {
+ size_t __index = _M_slice.start();
+ for (size_t __i = 0;
+ __i < _M_slice.size();
+ ++__i, __index += _M_slice.stride())
+ _M_array[__index] ^= __x[__i];
+ }
+
+ void operator&=(const valarray<value_type>& __x) const {
+ size_t __index = _M_slice.start();
+ for (size_t __i = 0;
+ __i < _M_slice.size();
+ ++__i, __index += _M_slice.stride())
+ _M_array[__index] &= __x[__i];
+ }
+
+ void operator|=(const valarray<value_type>& __x) const {
+ size_t __index = _M_slice.start();
+ for (size_t __i = 0;
+ __i < _M_slice.size();
+ ++__i, __index += _M_slice.stride())
+ _M_array[__index] |= __x[__i];
+ }
+
+ void operator<<=(const valarray<value_type>& __x) const {
+ size_t __index = _M_slice.start();
+ for (size_t __i = 0;
+ __i < _M_slice.size();
+ ++__i, __index += _M_slice.stride())
+ _M_array[__index] <<= __x[__i];
+ }
+
+ void operator>>=(const valarray<value_type>& __x) const {
+ size_t __index = _M_slice.start();
+ for (size_t __i = 0;
+ __i < _M_slice.size();
+ ++__i, __index += _M_slice.stride())
+ _M_array[__index] >>= __x[__i];
+ }
+
+ void operator=(const value_type& __c) /*const could be const but standard says NO (26.3.5.4-1)*/ {
+ size_t __index = _M_slice.start();
+ for (size_t __i = 0;
+ __i < _M_slice.size();
+ ++__i, __index += _M_slice.stride())
+ _M_array[__index] = __c;
+ }
+
+ // C++ Standard defect 253, copy constructor must be public.
+ slice_array(const slice_array &__x)
+ : _M_slice(__x._M_slice), _M_array(__x._M_array)
+ {}
+
+ ~slice_array() {}
+
+private:
+ slice_array(const slice& __slice, valarray<_Tp> &__array)
+ : _M_slice(__slice), _M_array(__array)
+ {}
+
+ slice _M_slice;
+ valarray<_Tp>& _M_array;
+
+private:
+ // Disable default constructor and assignment
+ slice_array();
+ slice_array& operator=(const slice_array&);
+};
+
+// valarray member functions dealing with slice and slice_array
+
+template <class _Tp>
+inline valarray<_Tp>::valarray(const slice_array<_Tp>& __x)
+ : _Valarray_base<_Tp>(__x._M_slice.size()) {
+ typedef typename __type_traits<_Tp>::has_trivial_default_constructor
+ _Is_Trivial;
+ _M_initialize(_Is_Trivial());
+ *this = __x;
+}
+
+
+template <class _Tp>
+inline slice_array<_Tp> valarray<_Tp>::operator[](slice __slice)
+{ return slice_array<_Tp>(__slice, *this); }
+
+//----------------------------------------------------------------------
+// gslice and gslice_array
+
+template <class _Size>
+struct _Gslice_Iter_tmpl;
+
+class gslice {
+ friend struct _Gslice_Iter_tmpl<size_t>;
+public:
+ gslice() : _M_start(0), _M_lengths(), _M_strides() {}
+ gslice(size_t __start,
+ const _Valarray_size_t& __lengths, const _Valarray_size_t& __strides)
+ : _M_start(__start), _M_lengths(__lengths), _M_strides(__strides)
+ {}
+ __TRIVIAL_DESTRUCTOR(gslice)
+
+ size_t start() const { return _M_start; }
+ _Valarray_size_t size() const { return _M_lengths; }
+ _Valarray_size_t stride() const { return _M_strides; }
+
+ // Extension: check for an empty gslice.
+ bool _M_empty() const { return _M_lengths.size() == 0; }
+
+ // Extension: number of indices this gslice represents. (For a degenerate
+ // gslice, they're not necessarily all distinct.)
+ size_t _M_size() const {
+ return !this->_M_empty()
+ ? accumulate(_M_lengths._M_first + 1,
+ _M_lengths._M_first + _M_lengths._M_size,
+ _M_lengths[0],
+ multiplies<size_t>())
+ : 0;
+ }
+
+# ifndef __HP_aCC
+private:
+# endif
+
+ size_t _M_start;
+ _Valarray_size_t _M_lengths;
+ _Valarray_size_t _M_strides;
+};
+
+// This is not an STL iterator. It is constructed from a gslice, and it
+// steps through the gslice indices in sequence. See 23.3.6 of the C++
+// standard, paragraphs 2-3, for an explanation of the sequence. At
+// each step we get two things: the ordinal (i.e. number of steps taken),
+// and the one-dimensional index.
+
+template <class _Size>
+struct _Gslice_Iter_tmpl {
+ _Gslice_Iter_tmpl(const gslice& __gslice)
+ : _M_step(0), _M_1d_idx(__gslice.start()),
+ _M_indices(size_t(0), __gslice._M_lengths.size()),
+ _M_gslice(__gslice)
+ {}
+
+ bool _M_done() const { return _M_indices[0] == _M_gslice._M_lengths[0]; }
+
+ bool _M_incr();
+
+ _Size _M_step;
+ _Size _M_1d_idx;
+
+ valarray<_Size> _M_indices;
+ const gslice& _M_gslice;
+};
+
+typedef _Gslice_Iter_tmpl<size_t> _Gslice_Iter;
+
+template <class _Tp>
+class gslice_array {
+ friend class valarray<_Tp>;
+public:
+ typedef _Tp value_type;
+
+ void operator= (const valarray<value_type>& __x) const {
+ if (!_M_gslice._M_empty()) {
+ _Gslice_Iter __i(_M_gslice);
+ do _M_array[__i._M_1d_idx] = __x[__i._M_step]; while(__i._M_incr());
+ }
+ }
+
+ void operator*= (const valarray<value_type>& __x) const {
+ if (!_M_gslice._M_empty()) {
+ _Gslice_Iter __i(_M_gslice);
+ do _M_array[__i._M_1d_idx] *= __x[__i._M_step]; while(__i._M_incr());
+ }
+ }
+
+ void operator/= (const valarray<value_type>& __x) const {
+ if (!_M_gslice._M_empty()) {
+ _Gslice_Iter __i(_M_gslice);
+ do _M_array[__i._M_1d_idx] /= __x[__i._M_step]; while(__i._M_incr());
+ }
+ }
+
+ void operator%= (const valarray<value_type>& __x) const {
+ if (!_M_gslice._M_empty()) {
+ _Gslice_Iter __i(_M_gslice);
+ do _M_array[__i._M_1d_idx] %= __x[__i._M_step]; while(__i._M_incr());
+ }
+ }
+
+ void operator+= (const valarray<value_type>& __x) const {
+ if (!_M_gslice._M_empty()) {
+ _Gslice_Iter __i(_M_gslice);
+ do _M_array[__i._M_1d_idx] += __x[__i._M_step]; while(__i._M_incr());
+ }
+ }
+
+ void operator-= (const valarray<value_type>& __x) const {
+ if (!_M_gslice._M_empty()) {
+ _Gslice_Iter __i(_M_gslice);
+ do _M_array[__i._M_1d_idx] -= __x[__i._M_step]; while(__i._M_incr());
+ }
+ }
+
+ void operator^= (const valarray<value_type>& __x) const {
+ if (!_M_gslice._M_empty()) {
+ _Gslice_Iter __i(_M_gslice);
+ do _M_array[__i._M_1d_idx] ^= __x[__i._M_step]; while(__i._M_incr());
+ }
+ }
+
+ void operator&= (const valarray<value_type>& __x) const {
+ if (!_M_gslice._M_empty()) {
+ _Gslice_Iter __i(_M_gslice);
+ do _M_array[__i._M_1d_idx] &= __x[__i._M_step]; while(__i._M_incr());
+ }
+ }
+
+ void operator|= (const valarray<value_type>& __x) const {
+ if (!_M_gslice._M_empty()) {
+ _Gslice_Iter __i(_M_gslice);
+ do _M_array[__i._M_1d_idx] |= __x[__i._M_step]; while(__i._M_incr());
+ }
+ }
+
+ void operator<<= (const valarray<value_type>& __x) const {
+ if (!_M_gslice._M_empty()) {
+ _Gslice_Iter __i(_M_gslice);
+ do _M_array[__i._M_1d_idx] <<= __x[__i._M_step]; while(__i._M_incr());
+ }
+ }
+
+ void operator>>= (const valarray<value_type>& __x) const {
+ if (!_M_gslice._M_empty()) {
+ _Gslice_Iter __i(_M_gslice);
+ do _M_array[__i._M_1d_idx] >>= __x[__i._M_step]; while(__i._M_incr());
+ }
+ }
+
+ void operator= (const value_type& __c) /*const could be const but standard says NO (26.3.7.4-1)*/ {
+ if (!_M_gslice._M_empty()) {
+ _Gslice_Iter __i(_M_gslice);
+ do _M_array[__i._M_1d_idx] = __c; while(__i._M_incr());
+ }
+ }
+
+ // C++ Standard defect 253, copy constructor must be public.
+ gslice_array(const gslice_array& __x)
+ : _M_gslice(__x._M_gslice), _M_array(__x._M_array)
+ {}
+
+ ~gslice_array() {}
+
+private:
+ gslice_array(const gslice &__gslice, valarray<_Tp> &__array)
+ : _M_gslice(__gslice), _M_array(__array)
+ {}
+
+ gslice _M_gslice;
+ valarray<value_type>& _M_array;
+
+private:
+ // Disable default constructor and assignment
+ gslice_array();
+ void operator=(const gslice_array<_Tp>&);
+};
+
+// valarray member functions dealing with gslice and gslice_array. Note
+// that it is illegal (behavior is undefined) to construct a gslice_array
+// from a degenerate gslice.
+
+template <class _Tp>
+inline valarray<_Tp>::valarray(const gslice_array<_Tp>& __x)
+ : _Valarray_base<_Tp>(__x._M_gslice._M_size()) {
+ typedef typename __type_traits<_Tp>::has_trivial_default_constructor
+ _Is_Trivial;
+ _M_initialize(_Is_Trivial());
+ *this = __x;
+}
+
+template <class _Tp>
+inline gslice_array<_Tp> valarray<_Tp>::operator[](const gslice& __slice)
+{ return gslice_array<_Tp>(__slice, *this); }
+
+
+//----------------------------------------------------------------------
+// mask_array
+
+template <class _Tp>
+class mask_array {
+ friend class valarray<_Tp>;
+public:
+ typedef _Tp value_type;
+
+ void operator=(const valarray<value_type>& __x) const {
+ size_t __idx = 0;
+ for (size_t __i = 0; __i < _M_array.size(); ++__i)
+ if (_M_mask[__i]) _M_array[__i] = __x[__idx++];
+ }
+
+ void operator*=(const valarray<value_type>& __x) const {
+ size_t __idx = 0;
+ for (size_t __i = 0; __i < _M_array.size(); ++__i)
+ if (_M_mask[__i]) _M_array[__i] *= __x[__idx++];
+ }
+
+ void operator/=(const valarray<value_type>& __x) const {
+ size_t __idx = 0;
+ for (size_t __i = 0; __i < _M_array.size(); ++__i)
+ if (_M_mask[__i]) _M_array[__i] /= __x[__idx++];
+ }
+
+ void operator%=(const valarray<value_type>& __x) const {
+ size_t __idx = 0;
+ for (size_t __i = 0; __i < _M_array.size(); ++__i)
+ if (_M_mask[__i]) _M_array[__i] %= __x[__idx++];
+ }
+
+ void operator+=(const valarray<value_type>& __x) const {
+ size_t __idx = 0;
+ for (size_t __i = 0; __i < _M_array.size(); ++__i)
+ if (_M_mask[__i]) _M_array[__i] += __x[__idx++];
+ }
+
+ void operator-=(const valarray<value_type>& __x) const {
+ size_t __idx = 0;
+ for (size_t __i = 0; __i < _M_array.size(); ++__i)
+ if (_M_mask[__i]) _M_array[__i] -= __x[__idx++];
+ }
+
+ void operator^=(const valarray<value_type>& __x) const {
+ size_t __idx = 0;
+ for (size_t __i = 0; __i < _M_array.size(); ++__i)
+ if (_M_mask[__i]) _M_array[__i] ^= __x[__idx++];
+ }
+
+ void operator&=(const valarray<value_type>& __x) const {
+ size_t __idx = 0;
+ for (size_t __i = 0; __i < _M_array.size(); ++__i)
+ if (_M_mask[__i]) _M_array[__i] &= __x[__idx++];
+ }
+
+ void operator|=(const valarray<value_type>& __x) const {
+ size_t __idx = 0;
+ for (size_t __i = 0; __i < _M_array.size(); ++__i)
+ if (_M_mask[__i]) _M_array[__i] |= __x[__idx++];
+ }
+
+ void operator<<=(const valarray<value_type>& __x) const {
+ size_t __idx = 0;
+ for (size_t __i = 0; __i < _M_array.size(); ++__i)
+ if (_M_mask[__i]) _M_array[__i] <<= __x[__idx++];
+ }
+
+ void operator>>=(const valarray<value_type>& __x) const {
+ size_t __idx = 0;
+ for (size_t __i = 0; __i < _M_array.size(); ++__i)
+ if (_M_mask[__i]) _M_array[__i] >>= __x[__idx++];
+ }
+
+ void operator=(const value_type& __c) const {
+ for (size_t __i = 0; __i < _M_array.size(); ++__i)
+ if (_M_mask[__i]) _M_array[__i] = __c;
+ }
+
+ // Extension: number of true values in the mask
+ size_t _M_num_true() const {
+ size_t __result = 0;
+ for (size_t __i = 0; __i < _M_mask.size(); ++__i)
+ if (_M_mask[__i]) ++__result;
+ return __result;
+ }
+
+ // C++ Standard defect 253, copy constructor must be public.
+ mask_array(const mask_array& __x)
+ : _M_mask(__x._M_mask), _M_array(__x._M_array)
+ {}
+
+ ~mask_array() {}
+
+private:
+ mask_array(const _Valarray_bool& __mask, valarray<_Tp>& __array)
+ : _M_mask(__mask), _M_array(__array)
+ {}
+ _Valarray_bool _M_mask;
+ valarray<_Tp>& _M_array;
+
+private:
+ // Disable default constructor and assignment
+ mask_array();
+ void operator=(const mask_array<_Tp>&);
+};
+
+// valarray member functions dealing with mask_array
+
+template <class _Tp>
+inline valarray<_Tp>::valarray(const mask_array<_Tp>& __x)
+ : _Valarray_base<_Tp>(__x._M_num_true()) {
+ typedef typename __type_traits<_Tp>::has_trivial_default_constructor
+ _Is_Trivial;
+ _M_initialize(_Is_Trivial());
+ *this = __x;
+}
+
+// Behavior is undefined if __x._M_num_true() != this->size()
+template <class _Tp>
+inline valarray<_Tp>& valarray<_Tp>::operator=(const mask_array<_Tp>& __x) {
+ size_t __idx = 0;
+ for (size_t __i = 0; __i < __x._M_array.size(); ++__i)
+ if (__x._M_mask[__i]) (*this)[__idx++] = __x._M_array[__i];
+ return *this;
+}
+
+template <class _Tp>
+inline mask_array<_Tp> valarray<_Tp>::operator[](const _Valarray_bool& __mask) {
+ _STLP_ASSERT(__mask.size() == this->size())
+ return mask_array<_Tp>(__mask, *this);
+}
+
+//----------------------------------------------------------------------
+// indirect_array
+
+template <class _Tp>
+class indirect_array {
+ friend class valarray<_Tp>;
+public:
+ typedef _Tp value_type;
+
+ void operator=(const valarray<value_type>& __x) const {
+ for (size_t __i = 0; __i < _M_addr.size(); ++__i)
+ _M_array[_M_addr[__i]] = __x[__i];
+ }
+
+ void operator*=(const valarray<value_type>& __x) const {
+ for (size_t __i = 0; __i < _M_addr.size(); ++__i)
+ _M_array[_M_addr[__i]] *= __x[__i];
+ }
+
+ void operator/=(const valarray<value_type>& __x) const {
+ for (size_t __i = 0; __i < _M_addr.size(); ++__i)
+ _M_array[_M_addr[__i]] /= __x[__i];
+ }
+
+ void operator%=(const valarray<value_type>& __x) const {
+ for (size_t __i = 0; __i < _M_addr.size(); ++__i)
+ _M_array[_M_addr[__i]] %= __x[__i];
+ }
+
+ void operator+=(const valarray<value_type>& __x) const {
+ for (size_t __i = 0; __i < _M_addr.size(); ++__i)
+ _M_array[_M_addr[__i]] += __x[__i];
+ }
+
+ void operator-=(const valarray<value_type>& __x) const {
+ for (size_t __i = 0; __i < _M_addr.size(); ++__i)
+ _M_array[_M_addr[__i]] -= __x[__i];
+ }
+
+ void operator^=(const valarray<value_type>& __x) const {
+ for (size_t __i = 0; __i < _M_addr.size(); ++__i)
+ _M_array[_M_addr[__i]] ^= __x[__i];
+ }
+
+ void operator&=(const valarray<value_type>& __x) const {
+ for (size_t __i = 0; __i < _M_addr.size(); ++__i)
+ _M_array[_M_addr[__i]] &= __x[__i];
+ }
+
+ void operator|=(const valarray<value_type>& __x) const {
+ for (size_t __i = 0; __i < _M_addr.size(); ++__i)
+ _M_array[_M_addr[__i]] |= __x[__i];
+ }
+
+ void operator<<=(const valarray<value_type>& __x) const {
+ for (size_t __i = 0; __i < _M_addr.size(); ++__i)
+ _M_array[_M_addr[__i]] <<= __x[__i];
+ }
+
+ void operator>>=(const valarray<value_type>& __x) const {
+ for (size_t __i = 0; __i < _M_addr.size(); ++__i)
+ _M_array[_M_addr[__i]] >>= __x[__i];
+ }
+
+ void operator=(const value_type& __c) const {
+ for (size_t __i = 0; __i < _M_addr.size(); ++__i)
+ _M_array[_M_addr[__i]] = __c;
+ }
+
+ // C++ Standard defect 253, copy constructor must be public.
+ indirect_array(const indirect_array& __x)
+ : _M_addr(__x._M_addr), _M_array(__x._M_array)
+ {}
+
+ ~indirect_array() {}
+
+private:
+ indirect_array(const _Valarray_size_t& __addr, valarray<_Tp>& __array)
+ : _M_addr(__addr), _M_array(__array)
+ {}
+
+ _Valarray_size_t _M_addr;
+ valarray<_Tp>& _M_array;
+
+private:
+ // Disable default constructor and assignment
+ indirect_array();
+ void operator=(const indirect_array<_Tp>&);
+};
+
+// valarray member functions dealing with indirect_array
+
+template <class _Tp>
+inline valarray<_Tp>::valarray(const indirect_array<_Tp>& __x)
+ : _Valarray_base<_Tp>(__x._M_addr.size()) {
+ typedef typename __type_traits<_Tp>::has_trivial_default_constructor
+ _Is_Trivial;
+ _M_initialize(_Is_Trivial());
+ *this = __x;
+}
+
+
+template <class _Tp>
+inline indirect_array<_Tp>
+valarray<_Tp>::operator[](const _Valarray_size_t& __addr)
+{ return indirect_array<_Tp>(__addr, *this); }
+
+_STLP_END_NAMESPACE
+
+# if !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_valarray.c>
+# endif
+
+#endif /* _STLP_VALARRAY */
+
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_vector.c b/sources/android/stlport/stlport/stl/_vector.c
new file mode 100644
index 0000000..705f786
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_vector.c
@@ -0,0 +1,242 @@
+/*
+ *
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_VECTOR_C
+#define _STLP_VECTOR_C
+
+#if !defined (_STLP_INTERNAL_VECTOR_H)
+# include <stl/_vector.h>
+#endif
+
+#include <stl/_range_errors.h>
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp, class _Alloc>
+void _Vector_base<_Tp,_Alloc>::_M_throw_length_error() const
+{ __stl_throw_length_error("vector"); }
+
+template <class _Tp, class _Alloc>
+void _Vector_base<_Tp, _Alloc>::_M_throw_out_of_range() const
+{ __stl_throw_out_of_range("vector"); }
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+# define vector _STLP_PTR_IMPL_NAME(vector)
+#elif defined (_STLP_DEBUG)
+# define vector _STLP_NON_DBG_NAME(vector)
+#else
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+# define __iterator__ _Tp*
+#else
+# define __iterator__ _STLP_TYPENAME_ON_RETURN_TYPE vector<_Tp, _Alloc>::iterator
+#endif
+
+template <class _Tp, class _Alloc>
+void vector<_Tp, _Alloc>::reserve(size_type __n) {
+ if (capacity() < __n) {
+ if (max_size() < __n) {
+ this->_M_throw_length_error();
+ }
+
+ const size_type __old_size = size();
+ pointer __tmp;
+ if (this->_M_start) {
+ __tmp = _M_allocate_and_copy(__n, this->_M_start, this->_M_finish);
+ _M_clear();
+ } else {
+ __tmp = this->_M_end_of_storage.allocate(__n, __n);
+ }
+ _M_set(__tmp, __tmp + __old_size, __tmp + __n);
+ }
+}
+
+template <class _Tp, class _Alloc>
+void vector<_Tp, _Alloc>::_M_insert_overflow_aux(pointer __pos, const _Tp& __x, const __false_type& /*DO NOT USE!!*/,
+ size_type __fill_len, bool __atend ) {
+ typedef typename __type_traits<_Tp>::has_trivial_copy_constructor _TrivialUCopy;
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+ size_type __len = _M_compute_next_size(__fill_len);
+ pointer __new_start = this->_M_end_of_storage.allocate(__len, __len);
+ pointer __new_finish = __new_start;
+ _STLP_TRY {
+ __new_finish = _STLP_PRIV __uninitialized_move(this->_M_start, __pos, __new_start, _TrivialUCopy(), _Movable());
+ // handle insertion
+ if (__fill_len == 1) {
+ _Copy_Construct(__new_finish, __x);
+ ++__new_finish;
+ } else
+ __new_finish = _STLP_PRIV __uninitialized_fill_n(__new_finish, __fill_len, __x);
+ if (!__atend)
+ __new_finish = _STLP_PRIV __uninitialized_move(__pos, this->_M_finish, __new_finish, _TrivialUCopy(), _Movable()); // copy remainder
+ }
+ _STLP_UNWIND((_STLP_STD::_Destroy_Range(__new_start,__new_finish),
+ this->_M_end_of_storage.deallocate(__new_start,__len)))
+ _M_clear_after_move();
+ _M_set(__new_start, __new_finish, __new_start + __len);
+}
+
+template <class _Tp, class _Alloc>
+void vector<_Tp, _Alloc>::_M_insert_overflow(pointer __pos, const _Tp& __x, const __true_type& /*_TrivialCopy*/,
+ size_type __fill_len, bool __atend ) {
+ size_type __len = _M_compute_next_size(__fill_len);
+ pointer __new_start = this->_M_end_of_storage.allocate(__len, __len);
+ pointer __new_finish = __STATIC_CAST(pointer, _STLP_PRIV __copy_trivial(this->_M_start, __pos, __new_start));
+ // handle insertion
+ __new_finish = _STLP_PRIV __fill_n(__new_finish, __fill_len, __x);
+ if (!__atend)
+ __new_finish = __STATIC_CAST(pointer, _STLP_PRIV __copy_trivial(__pos, this->_M_finish, __new_finish)); // copy remainder
+ _M_clear();
+ _M_set(__new_start, __new_finish, __new_start + __len);
+}
+
+template <class _Tp, class _Alloc>
+void vector<_Tp, _Alloc>::_M_fill_insert_aux(iterator __pos, size_type __n,
+ const _Tp& __x, const __true_type& /*_Movable*/) {
+ if (_M_is_inside(__x)) {
+ _Tp __x_copy = __x;
+ _M_fill_insert_aux(__pos, __n, __x_copy, __true_type());
+ return;
+ }
+ iterator __src = this->_M_finish - 1;
+ iterator __dst = __src + __n;
+ for (; __src >= __pos; --__dst, --__src) {
+ _STLP_STD::_Move_Construct(__dst, *__src);
+ _STLP_STD::_Destroy_Moved(__src);
+ }
+ _STLP_PRIV __uninitialized_fill_n(__pos, __n, __x);
+ this->_M_finish += __n;
+}
+
+template <class _Tp, class _Alloc>
+void vector<_Tp, _Alloc>::_M_fill_insert_aux (iterator __pos, size_type __n,
+ const _Tp& __x, const __false_type& /*_Movable*/) {
+ typedef typename __type_traits<_Tp>::has_trivial_copy_constructor _TrivialUCopy;
+ typedef typename __type_traits<_Tp>::has_trivial_assignment_operator _TrivialCopy;
+ //Here self referencing needs to be checked even for non movable types.
+ if (_M_is_inside(__x)) {
+ _Tp __x_copy = __x;
+ _M_fill_insert_aux(__pos, __n, __x_copy, __false_type());
+ return;
+ }
+ const size_type __elems_after = this->_M_finish - __pos;
+ pointer __old_finish = this->_M_finish;
+ if (__elems_after > __n) {
+ _STLP_PRIV __ucopy_ptrs(this->_M_finish - __n, this->_M_finish, this->_M_finish, _TrivialUCopy());
+ this->_M_finish += __n;
+ _STLP_PRIV __copy_backward_ptrs(__pos, __old_finish - __n, __old_finish, _TrivialCopy());
+ _STLP_STD::fill(__pos, __pos + __n, __x);
+ } else {
+ this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_finish, __n - __elems_after, __x);
+ _STLP_PRIV __ucopy_ptrs(__pos, __old_finish, this->_M_finish, _TrivialUCopy());
+ this->_M_finish += __elems_after;
+ _STLP_STD::fill(__pos, __old_finish, __x);
+ }
+}
+
+template <class _Tp, class _Alloc>
+void vector<_Tp, _Alloc>::_M_fill_insert(iterator __pos,
+ size_type __n, const _Tp& __x) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+ if (__n != 0) {
+ if (size_type(this->_M_end_of_storage._M_data - this->_M_finish) >= __n) {
+ _M_fill_insert_aux(__pos, __n, __x, _Movable());
+ } else {
+ typedef typename __type_traits<_Tp>::has_trivial_assignment_operator _TrivialCopy;
+ _M_insert_overflow(__pos, __x, _TrivialCopy(), __n);
+ }
+ }
+}
+
+template <class _Tp, class _Alloc>
+vector<_Tp, _Alloc>& vector<_Tp, _Alloc>::operator = (const vector<_Tp, _Alloc>& __x) {
+ typedef typename __type_traits<_Tp>::has_trivial_assignment_operator _TrivialCopy;
+ typedef typename __type_traits<_Tp>::has_trivial_copy_constructor _TrivialUCopy;
+ if (&__x != this) {
+ const size_type __xlen = __x.size();
+ if (__xlen > capacity()) {
+ size_type __len = __xlen;
+ pointer __tmp = _M_allocate_and_copy(__len, __CONST_CAST(const_pointer, __x._M_start) + 0,
+ __CONST_CAST(const_pointer, __x._M_finish) + 0);
+ _M_clear();
+ this->_M_start = __tmp;
+ this->_M_end_of_storage._M_data = this->_M_start + __len;
+ } else if (size() >= __xlen) {
+ pointer __i = _STLP_PRIV __copy_ptrs(__CONST_CAST(const_pointer, __x._M_start) + 0,
+ __CONST_CAST(const_pointer, __x._M_finish) + 0, this->_M_start, _TrivialCopy());
+ _STLP_STD::_Destroy_Range(__i, this->_M_finish);
+ } else {
+ _STLP_PRIV __copy_ptrs(__CONST_CAST(const_pointer, __x._M_start),
+ __CONST_CAST(const_pointer, __x._M_start) + size(), this->_M_start, _TrivialCopy());
+ _STLP_PRIV __ucopy_ptrs(__CONST_CAST(const_pointer, __x._M_start) + size(),
+ __CONST_CAST(const_pointer, __x._M_finish) + 0, this->_M_finish, _TrivialUCopy());
+ }
+ this->_M_finish = this->_M_start + __xlen;
+ }
+ return *this;
+}
+
+template <class _Tp, class _Alloc>
+void vector<_Tp, _Alloc>::_M_fill_assign(size_t __n, const _Tp& __val) {
+ if (__n > capacity()) {
+ vector<_Tp, _Alloc> __tmp(__n, __val, get_allocator());
+ __tmp.swap(*this);
+ } else if (__n > size()) {
+ fill(begin(), end(), __val);
+ this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_finish, __n - size(), __val);
+ } else
+ erase(_STLP_PRIV __fill_n(begin(), __n, __val), end());
+}
+
+template <class _Tp, class _Alloc>
+__iterator__
+vector<_Tp, _Alloc>::insert(iterator __pos, const _Tp& __x) {
+ size_type __n = __pos - begin();
+ _M_fill_insert(__pos, 1, __x);
+ return begin() + __n;
+}
+
+#undef __iterator__
+
+#if defined (vector)
+# undef vector
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_VECTOR_C */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/_vector.h b/sources/android/stlport/stlport/stl/_vector.h
new file mode 100644
index 0000000..ed243ef
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/_vector.h
@@ -0,0 +1,773 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_VECTOR_H
+#define _STLP_INTERNAL_VECTOR_H
+
+#ifndef _STLP_INTERNAL_ALGOBASE_H
+# include <stl/_algobase.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+# include <stl/_alloc.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ITERATOR_H
+# include <stl/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_UNINITIALIZED_H
+# include <stl/_uninitialized.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+// The vector base class serves one purpose, its constructor and
+// destructor allocate (but don't initialize) storage. This makes
+// exception safety easier.
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp, class _Alloc>
+class _Vector_base {
+public:
+ typedef _Vector_base<_Tp, _Alloc> _Self;
+ _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
+ typedef _Alloc allocator_type;
+ typedef _Tp* pointer;
+ typedef _STLP_alloc_proxy<pointer, _Tp, allocator_type> _AllocProxy;
+
+ _Vector_base(const _Alloc& __a)
+ : _M_start(0), _M_finish(0), _M_end_of_storage(__a, 0) {}
+
+ _Vector_base(size_t __n, const _Alloc& __a)
+ : _M_start(0), _M_finish(0), _M_end_of_storage(__a, 0) {
+ _M_start = _M_end_of_storage.allocate(__n, __n);
+ _M_finish = _M_start;
+ _M_end_of_storage._M_data = _M_start + __n;
+ _STLP_MPWFIX_TRY _STLP_MPWFIX_CATCH
+ }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ _Vector_base(__move_source<_Self> src)
+ : _M_start(src.get()._M_start), _M_finish(src.get()._M_finish),
+ _M_end_of_storage(__move_source<_AllocProxy>(src.get()._M_end_of_storage)) {
+ //Set the source as empty:
+ src.get()._M_finish = src.get()._M_end_of_storage._M_data = src.get()._M_start = 0;
+ }
+#endif
+
+ ~_Vector_base() {
+ if (_M_start != _STLP_DEFAULT_CONSTRUCTED(pointer))
+ _M_end_of_storage.deallocate(_M_start, _M_end_of_storage._M_data - _M_start);
+ }
+
+protected:
+ void _STLP_FUNCTION_THROWS _M_throw_length_error() const;
+ void _STLP_FUNCTION_THROWS _M_throw_out_of_range() const;
+
+ pointer _M_start;
+ pointer _M_finish;
+ _AllocProxy _M_end_of_storage;
+};
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+# define vector _STLP_PTR_IMPL_NAME(vector)
+#elif defined (_STLP_DEBUG)
+# define vector _STLP_NON_DBG_NAME(vector)
+#else
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) >
+class vector : protected _STLP_PRIV _Vector_base<_Tp, _Alloc>
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (vector)
+ , public __stlport_class<vector<_Tp, _Alloc> >
+#endif
+{
+private:
+ typedef _STLP_PRIV _Vector_base<_Tp, _Alloc> _Base;
+ typedef vector<_Tp, _Alloc> _Self;
+public:
+ _STLP_FORCE_ALLOCATORS(_Tp, _Alloc)
+ typedef typename _Base::allocator_type allocator_type;
+
+ typedef _Tp value_type;
+ typedef value_type* pointer;
+ typedef const value_type* const_pointer;
+ typedef value_type* iterator;
+ typedef const value_type* const_iterator;
+
+ typedef value_type& reference;
+ typedef const value_type& const_reference;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef random_access_iterator_tag _Iterator_category;
+
+ _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS;
+
+ allocator_type get_allocator() const
+ { return _STLP_CONVERT_ALLOCATOR((const allocator_type&)this->_M_end_of_storage, _Tp); }
+
+private:
+#if defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef __false_type _Movable;
+#endif
+
+ // handles insertions on overflow
+ void _M_insert_overflow_aux(pointer __pos, const _Tp& __x, const __false_type& /*_Movable*/,
+ size_type __fill_len, bool __atend);
+ void _M_insert_overflow_aux(pointer __pos, const _Tp& __x, const __true_type& /*_Movable*/,
+ size_type __fill_len, bool __atend) {
+ //We need to take care of self referencing here:
+ if (_M_is_inside(__x)) {
+ value_type __x_copy = __x;
+ _M_insert_overflow_aux(__pos, __x_copy, __false_type(), __fill_len, __atend);
+ return;
+ }
+ _M_insert_overflow_aux(__pos, __x, __false_type(), __fill_len, __atend);
+ }
+
+ void _M_insert_overflow(pointer __pos, const _Tp& __x, const __false_type& /*_TrivialCopy*/,
+ size_type __fill_len, bool __atend = false) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+ _M_insert_overflow_aux(__pos, __x, _Movable(), __fill_len, __atend);
+ }
+ void _M_insert_overflow(pointer __pos, const _Tp& __x, const __true_type& /*_TrivialCopy*/,
+ size_type __fill_len, bool __atend = false);
+ void _M_range_check(size_type __n) const {
+ if (__n >= size_type(this->_M_finish - this->_M_start))
+ this->_M_throw_out_of_range();
+ }
+
+ size_type _M_compute_next_size(size_type __n) {
+ const size_type __size = size();
+ if (__n > max_size() - __size)
+ this->_M_throw_length_error();
+ size_type __len = __size + (max)(__n, __size);
+ if (__len > max_size() || __len < __size)
+ __len = max_size(); // overflow
+ return __len;
+ }
+
+public:
+ iterator begin() { return this->_M_start; }
+ const_iterator begin() const { return this->_M_start; }
+ iterator end() { return this->_M_finish; }
+ const_iterator end() const { return this->_M_finish; }
+
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+ const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+
+ size_type size() const { return size_type(this->_M_finish - this->_M_start); }
+ size_type max_size() const {
+ size_type __vector_max_size = size_type(-1) / sizeof(_Tp);
+ typename allocator_type::size_type __alloc_max_size = this->_M_end_of_storage.max_size();
+ return (__alloc_max_size < __vector_max_size)?__alloc_max_size:__vector_max_size;
+ }
+
+ size_type capacity() const { return size_type(this->_M_end_of_storage._M_data - this->_M_start); }
+ bool empty() const { return this->_M_start == this->_M_finish; }
+
+ reference operator[](size_type __n) { return *(begin() + __n); }
+ const_reference operator[](size_type __n) const { return *(begin() + __n); }
+
+ reference front() { return *begin(); }
+ const_reference front() const { return *begin(); }
+ reference back() { return *(end() - 1); }
+ const_reference back() const { return *(end() - 1); }
+
+ reference at(size_type __n) { _M_range_check(__n); return (*this)[__n]; }
+ const_reference at(size_type __n) const { _M_range_check(__n); return (*this)[__n]; }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ explicit vector(const allocator_type& __a = allocator_type())
+#else
+ vector()
+ : _STLP_PRIV _Vector_base<_Tp, _Alloc>(allocator_type()) {}
+ vector(const allocator_type& __a)
+#endif
+ : _STLP_PRIV _Vector_base<_Tp, _Alloc>(__a) {}
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+private:
+ //We always call _M_initialize with only 1 parameter. Default parameter
+ //is used to allow explicit instanciation of vector with types with no
+ //default constructor.
+ void _M_initialize(size_type __n, const _Tp& __val = _STLP_DEFAULT_CONSTRUCTED(_Tp))
+ { this->_M_finish = _STLP_PRIV __uninitialized_init(this->_M_start, __n, __val); }
+public:
+ explicit vector(size_type __n)
+ : _STLP_PRIV _Vector_base<_Tp, _Alloc>(__n, allocator_type())
+ { _M_initialize(__n); }
+ vector(size_type __n, const _Tp& __val, const allocator_type& __a = allocator_type())
+#else
+ explicit vector(size_type __n)
+ : _STLP_PRIV _Vector_base<_Tp, _Alloc>(__n, allocator_type())
+ { this->_M_finish = _STLP_PRIV __uninitialized_init(this->_M_start, __n, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+ vector(size_type __n, const _Tp& __val)
+ : _STLP_PRIV _Vector_base<_Tp, _Alloc>(__n, allocator_type())
+ { this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_start, __n, __val); }
+ vector(size_type __n, const _Tp& __val, const allocator_type& __a)
+#endif
+ : _STLP_PRIV _Vector_base<_Tp, _Alloc>(__n, __a)
+ { this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_start, __n, __val); }
+
+ vector(const _Self& __x)
+ : _STLP_PRIV _Vector_base<_Tp, _Alloc>(__x.size(), __x.get_allocator()) {
+ typedef typename __type_traits<_Tp>::has_trivial_copy_constructor _TrivialUCopy;
+ this->_M_finish = _STLP_PRIV __ucopy_ptrs(__x.begin(), __x.end(), this->_M_start, _TrivialUCopy());
+ }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ vector(__move_source<_Self> src)
+ : _STLP_PRIV _Vector_base<_Tp, _Alloc>(__move_source<_Base>(src.get()))
+ {}
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+private:
+ template <class _Integer>
+ void _M_initialize_aux(_Integer __n, _Integer __val,
+ const __true_type& /*_IsIntegral*/) {
+ size_type __real_n = __n;
+ this->_M_start = this->_M_end_of_storage.allocate(__n, __real_n);
+ this->_M_end_of_storage._M_data = this->_M_start + __real_n;
+ this->_M_finish = _STLP_PRIV __uninitialized_fill_n(this->_M_start, __n, __val);
+ }
+
+ template <class _InputIterator>
+ void _M_initialize_aux(_InputIterator __first, _InputIterator __last,
+ const __false_type& /*_IsIntegral*/)
+ { _M_range_initialize(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIterator)); }
+
+public:
+ // Check whether it's an integral type. If so, it's not an iterator.
+ template <class _InputIterator>
+ vector(_InputIterator __first, _InputIterator __last,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL )
+ : _STLP_PRIV _Vector_base<_Tp, _Alloc>(__a) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_initialize_aux(__first, __last, _Integral());
+ }
+
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ vector(_InputIterator __first, _InputIterator __last)
+ : _STLP_PRIV _Vector_base<_Tp, _Alloc>(allocator_type()) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_initialize_aux(__first, __last, _Integral());
+ }
+# endif /* _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS */
+
+#else /* _STLP_MEMBER_TEMPLATES */
+ vector(const _Tp* __first, const _Tp* __last,
+ const allocator_type& __a = allocator_type())
+ : _STLP_PRIV _Vector_base<_Tp, _Alloc>(__last - __first, __a) {
+ typedef typename __type_traits<_Tp>::has_trivial_copy_constructor _TrivialUCopy;
+ this->_M_finish = _STLP_PRIV __ucopy_ptrs(__first, __last, this->_M_start, _TrivialUCopy());
+ }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ //As the vector container is a back insert oriented container it
+ //seems rather logical to destroy elements in reverse order.
+ ~vector() { _STLP_STD::_Destroy_Range(rbegin(), rend()); }
+
+ _Self& operator=(const _Self& __x);
+
+ void reserve(size_type __n);
+
+ // assign(), a generalized assignment member function. Two
+ // versions: one that takes a count, and one that takes a range.
+ // The range version is a member template, so we dispatch on whether
+ // or not the type is an integer.
+
+ void assign(size_type __n, const _Tp& __val) { _M_fill_assign(__n, __val); }
+ void _M_fill_assign(size_type __n, const _Tp& __val);
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _ForwardIter>
+ void _M_assign_aux(_ForwardIter __first, _ForwardIter __last, const forward_iterator_tag &) {
+#else
+ void assign(const_iterator __first, const_iterator __last) {
+ typedef const_iterator _ForwardIter;
+#endif
+ const size_type __len = _STLP_STD::distance(__first, __last);
+ if (__len > capacity()) {
+ size_type __n = __len;
+ iterator __tmp = _M_allocate_and_copy(__n, __first, __last);
+ _M_clear();
+ _M_set(__tmp, __tmp + __len, __tmp + __n);
+ }
+ else if (size() >= __len) {
+ iterator __new_finish = copy(__first, __last, this->_M_start);
+ _STLP_STD::_Destroy_Range(__new_finish, this->_M_finish);
+ this->_M_finish = __new_finish;
+ }
+ else {
+ _ForwardIter __mid = __first;
+ _STLP_STD::advance(__mid, size());
+ _STLP_STD::copy(__first, __mid, this->_M_start);
+ this->_M_finish = _STLP_STD::uninitialized_copy(__mid, __last, this->_M_finish);
+ }
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIter>
+ void _M_assign_aux(_InputIter __first, _InputIter __last,
+ const input_iterator_tag &) {
+ iterator __cur = begin();
+ for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
+ *__cur = *__first;
+ if (__first == __last)
+ erase(__cur, end());
+ else
+ insert(end(), __first, __last);
+ }
+
+ template <class _Integer>
+ void _M_assign_dispatch(_Integer __n, _Integer __val,
+ const __true_type& /*_IsIntegral*/)
+ { _M_fill_assign(__n, __val); }
+
+ template <class _InputIter>
+ void _M_assign_dispatch(_InputIter __first, _InputIter __last,
+ const __false_type& /*_IsIntegral*/)
+ { _M_assign_aux(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIter)); }
+
+ template <class _InputIterator>
+ void assign(_InputIterator __first, _InputIterator __last) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_assign_dispatch(__first, __last, _Integral());
+ }
+#endif
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ void push_back(const _Tp& __x = _STLP_DEFAULT_CONSTRUCTED(_Tp)) {
+#else
+ void push_back(const _Tp& __x) {
+#endif
+ if (this->_M_finish != this->_M_end_of_storage._M_data) {
+ _Copy_Construct(this->_M_finish, __x);
+ ++this->_M_finish;
+ }
+ else {
+ typedef typename __type_traits<_Tp>::has_trivial_assignment_operator _TrivialCopy;
+ _M_insert_overflow(this->_M_finish, __x, _TrivialCopy(), 1, true);
+ }
+ }
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+ iterator insert(iterator __pos, const _Tp& __x = _STLP_DEFAULT_CONSTRUCTED(_Tp));
+#else
+ iterator insert(iterator __pos, const _Tp& __x);
+#endif
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+ void push_back() { push_back(_STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+ iterator insert(iterator __pos) { return insert(__pos, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+#endif
+
+ void swap(_Self& __x) {
+ _STLP_STD::swap(this->_M_start, __x._M_start);
+ _STLP_STD::swap(this->_M_finish, __x._M_finish);
+ this->_M_end_of_storage.swap(__x._M_end_of_storage);
+ }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+private:
+ void _M_fill_insert_aux (iterator __pos, size_type __n, const _Tp& __x, const __true_type& /*_Movable*/);
+ void _M_fill_insert_aux (iterator __pos, size_type __n, const _Tp& __x, const __false_type& /*_Movable*/);
+ void _M_fill_insert (iterator __pos, size_type __n, const _Tp& __x);
+
+ bool _M_is_inside(const value_type& __x) const {
+ return (&__x >= this->_M_start && &__x < this->_M_finish);
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _ForwardIterator>
+ void _M_range_insert_realloc(iterator __pos,
+ _ForwardIterator __first, _ForwardIterator __last,
+#else
+ void _M_range_insert_realloc(iterator __pos,
+ const_iterator __first, const_iterator __last,
+#endif
+ size_type __n) {
+ typedef typename __type_traits<_Tp>::has_trivial_copy_constructor _TrivialUCopy;
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+ size_type __len = _M_compute_next_size(__n);
+ pointer __new_start = this->_M_end_of_storage.allocate(__len, __len);
+ pointer __new_finish = __new_start;
+ _STLP_TRY {
+ __new_finish = _STLP_PRIV __uninitialized_move(this->_M_start, __pos, __new_start, _TrivialUCopy(), _Movable());
+ __new_finish = uninitialized_copy(__first, __last, __new_finish);
+ __new_finish = _STLP_PRIV __uninitialized_move(__pos, this->_M_finish, __new_finish, _TrivialUCopy(), _Movable());
+ }
+ _STLP_UNWIND((_STLP_STD::_Destroy_Range(__new_start,__new_finish),
+ this->_M_end_of_storage.deallocate(__new_start,__len)))
+ _M_clear_after_move();
+ _M_set(__new_start, __new_finish, __new_start + __len);
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _ForwardIterator>
+ void _M_range_insert_aux(iterator __pos,
+ _ForwardIterator __first, _ForwardIterator __last,
+#else
+ void _M_range_insert_aux(iterator __pos,
+ const_iterator __first, const_iterator __last,
+#endif
+ size_type __n, const __true_type& /*_Movable*/) {
+ iterator __src = this->_M_finish - 1;
+ iterator __dst = __src + __n;
+ for (; __src >= __pos; --__dst, --__src) {
+ _STLP_STD::_Move_Construct(__dst, *__src);
+ _STLP_STD::_Destroy_Moved(__src);
+ }
+ uninitialized_copy(__first, __last, __pos);
+ this->_M_finish += __n;
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _ForwardIterator>
+ void _M_range_insert_aux(iterator __pos,
+ _ForwardIterator __first, _ForwardIterator __last,
+#else
+ void _M_range_insert_aux(iterator __pos,
+ const_iterator __first, const_iterator __last,
+#endif
+ size_type __n, const __false_type& /*_Movable*/) {
+ typedef typename __type_traits<_Tp>::has_trivial_copy_constructor _TrivialUCopy;
+ typedef typename __type_traits<_Tp>::has_trivial_assignment_operator _TrivialCopy;
+ const size_type __elems_after = this->_M_finish - __pos;
+ pointer __old_finish = this->_M_finish;
+ if (__elems_after > __n) {
+ _STLP_PRIV __ucopy_ptrs(this->_M_finish - __n, this->_M_finish, this->_M_finish, _TrivialUCopy());
+ this->_M_finish += __n;
+ _STLP_PRIV __copy_backward_ptrs(__pos, __old_finish - __n, __old_finish, _TrivialCopy());
+ copy(__first, __last, __pos);
+ }
+ else {
+#if defined ( _STLP_MEMBER_TEMPLATES )
+ _ForwardIterator __mid = __first;
+ _STLP_STD::advance(__mid, __elems_after);
+#else
+ const_pointer __mid = __first + __elems_after;
+#endif
+ uninitialized_copy(__mid, __last, this->_M_finish);
+ this->_M_finish += __n - __elems_after;
+ _STLP_PRIV __ucopy_ptrs(__pos, __old_finish, this->_M_finish, _TrivialUCopy());
+ this->_M_finish += __elems_after;
+ copy(__first, __mid, __pos);
+ } /* elems_after */
+ }
+
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _Integer>
+ void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
+ const __true_type&)
+ { _M_fill_insert(__pos, (size_type) __n, (_Tp) __val); }
+
+ template <class _InputIterator>
+ void _M_insert_dispatch(iterator __pos,
+ _InputIterator __first, _InputIterator __last,
+ const __false_type&)
+ { _M_range_insert(__pos, __first, __last, _STLP_ITERATOR_CATEGORY(__first, _InputIterator)); }
+
+public:
+ // Check whether it's an integral type. If so, it's not an iterator.
+ template <class _InputIterator>
+ void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_insert_dispatch(__pos, __first, __last, _Integral());
+ }
+
+private:
+ template <class _InputIterator>
+ void _M_range_insert(iterator __pos,
+ _InputIterator __first, _InputIterator __last,
+ const input_iterator_tag &) {
+ for ( ; __first != __last; ++__first) {
+ __pos = insert(__pos, *__first);
+ ++__pos;
+ }
+ }
+
+ template <class _ForwardIterator>
+ void _M_range_insert(iterator __pos,
+ _ForwardIterator __first, _ForwardIterator __last,
+ const forward_iterator_tag &) {
+#else
+public:
+ void insert(iterator __pos,
+ const_iterator __first, const_iterator __last) {
+#endif
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+ /* This method do not check self referencing.
+ * Standard forbids it, checked by the debug mode.
+ */
+ if (__first != __last) {
+ size_type __n = _STLP_STD::distance(__first, __last);
+
+ if (size_type(this->_M_end_of_storage._M_data - this->_M_finish) >= __n) {
+ _M_range_insert_aux(__pos, __first, __last, __n, _Movable());
+ }
+ else {
+ _M_range_insert_realloc(__pos, __first, __last, __n);
+ }
+ }
+ }
+
+public:
+ void insert (iterator __pos, size_type __n, const _Tp& __x)
+ { _M_fill_insert(__pos, __n, __x); }
+
+ void pop_back() {
+ --this->_M_finish;
+ _STLP_STD::_Destroy(this->_M_finish);
+ }
+
+private:
+ iterator _M_erase(iterator __pos, const __true_type& /*_Movable*/) {
+ _STLP_STD::_Destroy(__pos);
+ iterator __dst = __pos, __src = __dst + 1;
+ iterator __end = end();
+ for (; __src != __end; ++__dst, ++__src) {
+ _STLP_STD::_Move_Construct(__dst, *__src);
+ _STLP_STD::_Destroy_Moved(__src);
+ }
+ this->_M_finish = __dst;
+ return __pos;
+ }
+ iterator _M_erase(iterator __pos, const __false_type& /*_Movable*/) {
+ if (__pos + 1 != end()) {
+ typedef typename __type_traits<_Tp>::has_trivial_assignment_operator _TrivialCopy;
+ _STLP_PRIV __copy_ptrs(__pos + 1, this->_M_finish, __pos, _TrivialCopy());
+ }
+ --this->_M_finish;
+ _STLP_STD::_Destroy(this->_M_finish);
+ return __pos;
+ }
+ iterator _M_erase(iterator __first, iterator __last, const __true_type& /*_Movable*/) {
+ iterator __dst = __first, __src = __last;
+ iterator __end = end();
+ for (; __dst != __last && __src != __end; ++__dst, ++__src) {
+ _STLP_STD::_Destroy(__dst);
+ _STLP_STD::_Move_Construct(__dst, *__src);
+ }
+ if (__dst != __last) {
+ //There is more elements to erase than element to move:
+ _STLP_STD::_Destroy_Range(__dst, __last);
+ _STLP_STD::_Destroy_Moved_Range(__last, __end);
+ }
+ else {
+ //There is more element to move than element to erase:
+ for (; __src != __end; ++__dst, ++__src) {
+ _STLP_STD::_Destroy_Moved(__dst);
+ _STLP_STD::_Move_Construct(__dst, *__src);
+ }
+ _STLP_STD::_Destroy_Moved_Range(__dst, __end);
+ }
+ this->_M_finish = __dst;
+ return __first;
+ }
+ iterator _M_erase(iterator __first, iterator __last, const __false_type& /*_Movable*/) {
+ typedef typename __type_traits<_Tp>::has_trivial_assignment_operator _TrivialCopy;
+ pointer __i = _STLP_PRIV __copy_ptrs(__last, this->_M_finish, __first, _TrivialCopy());
+ _STLP_STD::_Destroy_Range(__i, this->_M_finish);
+ this->_M_finish = __i;
+ return __first;
+ }
+
+public:
+ iterator erase(iterator __pos) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+ return _M_erase(__pos, _Movable());
+ }
+ iterator erase(iterator __first, iterator __last) {
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ typedef typename __move_traits<_Tp>::implemented _Movable;
+#endif
+ if (__first == __last)
+ return __first;
+ return _M_erase(__first, __last, _Movable());
+ }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size, const _Tp& __x = _STLP_DEFAULT_CONSTRUCTED(_Tp)) {
+#else
+ void resize(size_type __new_size, const _Tp& __x) {
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ if (__new_size < size())
+ erase(begin() + __new_size, end());
+ else
+ insert(end(), __new_size - size(), __x);
+ }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size) { resize(__new_size, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+ void clear() {
+ erase(begin(), end());
+ }
+
+private:
+ void _M_clear() {
+ _STLP_STD::_Destroy_Range(rbegin(), rend());
+ this->_M_end_of_storage.deallocate(this->_M_start, this->_M_end_of_storage._M_data - this->_M_start);
+ }
+
+ void _M_clear_after_move() {
+ _STLP_STD::_Destroy_Moved_Range(rbegin(), rend());
+ this->_M_end_of_storage.deallocate(this->_M_start, this->_M_end_of_storage._M_data - this->_M_start);
+ }
+
+ void _M_set(pointer __s, pointer __f, pointer __e) {
+ this->_M_start = __s;
+ this->_M_finish = __f;
+ this->_M_end_of_storage._M_data = __e;
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _ForwardIterator>
+ pointer _M_allocate_and_copy(size_type& __n,
+ _ForwardIterator __first, _ForwardIterator __last)
+#else /* _STLP_MEMBER_TEMPLATES */
+ pointer _M_allocate_and_copy(size_type& __n,
+ const_pointer __first, const_pointer __last)
+#endif /* _STLP_MEMBER_TEMPLATES */
+ {
+ pointer __result = this->_M_end_of_storage.allocate(__n, __n);
+ _STLP_TRY {
+ uninitialized_copy(__first, __last, __result);
+ return __result;
+ }
+ _STLP_UNWIND(this->_M_end_of_storage.deallocate(__result, __n))
+ _STLP_RET_AFTER_THROW(__result)
+ }
+
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void _M_range_initialize(_InputIterator __first, _InputIterator __last,
+ const input_iterator_tag &) {
+ for ( ; __first != __last; ++__first)
+ push_back(*__first);
+ }
+ // This function is only called by the constructor.
+ template <class _ForwardIterator>
+ void _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
+ const forward_iterator_tag &) {
+ size_type __n = _STLP_STD::distance(__first, __last);
+ this->_M_start = this->_M_end_of_storage.allocate(__n, __n);
+ this->_M_end_of_storage._M_data = this->_M_start + __n;
+ this->_M_finish = uninitialized_copy(__first, __last, this->_M_start);
+ }
+#endif /* _STLP_MEMBER_TEMPLATES */
+};
+
+#if defined (vector)
+# undef vector
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+_STLP_END_NAMESPACE
+
+#if !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/_vector.c>
+#endif
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+# include <stl/pointers/_vector.h>
+#endif
+
+//We define the bool specialization before the debug interfave
+//to benefit of the debug version of vector even for the bool
+//specialization.
+#if !defined (_STLP_NO_BOOL) || !defined (_STLP_NO_EXTENSIONS)
+# if !defined (_STLP_INTERNAL_BVECTOR_H)
+# include <stl/_bvector.h>
+# endif
+#endif
+
+#if defined (_STLP_DEBUG)
+# include <stl/debug/_vector.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if !defined (_STLP_NO_BOOL) && !defined (_STLP_NO_EXTENSIONS)
+// This typedef is non-standard. It is provided for backward compatibility.
+typedef vector<bool, allocator<bool> > bit_vector;
+#endif
+
+#define _STLP_TEMPLATE_HEADER template <class _Tp, class _Alloc>
+#define _STLP_TEMPLATE_CONTAINER vector<_Tp, _Alloc>
+#include <stl/_relops_cont.h>
+#undef _STLP_TEMPLATE_CONTAINER
+#undef _STLP_TEMPLATE_HEADER
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+# if !defined (_STLP_NO_MOVE_SEMANTIC)
+template <class _Tp, class _Alloc>
+struct __move_traits<vector<_Tp, _Alloc> > {
+ typedef __true_type implemented;
+ typedef typename __move_traits<_Alloc>::complete complete;
+};
+# endif
+
+# if !defined (_STLP_DEBUG)
+template <class _Tp, class _Alloc>
+struct _DefaultZeroValue<vector<_Tp, _Alloc> >
+{ typedef typename __type_traits<_Alloc>::has_trivial_default_constructor _Ret; };
+# endif
+
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_VECTOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/boost_type_traits.h b/sources/android/stlport/stlport/stl/boost_type_traits.h
new file mode 100644
index 0000000..ae3a3f6
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/boost_type_traits.h
@@ -0,0 +1,150 @@
+/*
+ *
+ * Copyright (c) 2004
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_BOOST_TYPE_TRAITS_H
+#define _STLP_BOOST_TYPE_TRAITS_H
+
+#ifndef BOOST_CONFIG_SUFFIX_HPP
+# ifdef BOOST_CONFIG_HPP
+# undef BOOST_CONFIG_HPP
+# endif
+# include <boost/config.hpp>
+#endif
+
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_float.hpp>
+#include <boost/type_traits/has_trivial_constructor.hpp>
+#include <boost/type_traits/has_trivial_copy.hpp>
+#include <boost/type_traits/has_trivial_assign.hpp>
+#include <boost/type_traits/has_trivial_destructor.hpp>
+#include <boost/type_traits/is_pod.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+/*
+ * This file mostly wraps boost type_traits in the STLport type_traits.
+ * When checking a type traits like trivial assign operator for instance
+ * both the boost value and STLport values has to be taken into account
+ * as we don't know what the user might have prefer, specializing the boost
+ * type traits or the STLport one.
+ */
+_STLP_BEGIN_NAMESPACE
+
+template <class _Tp> struct _IsRef {
+ enum { _Is = ::boost::is_reference<_Tp>::value };
+ typedef typename __bool2type<_Is>::_Ret _Ret;
+};
+
+template <class _Tp> struct _IsPtr {
+ enum { is_pointer = ::boost::is_pointer<_Tp>::value };
+ typedef typename __bool2type<is_pointer>::_Ret _Ret;
+};
+
+template <class _Tp> struct _IsIntegral {
+ enum { is_integral = ::boost::is_integral<_Tp>::value };
+ typedef typename __bool2type<is_integral>::_Ret _Ret;
+};
+
+template <class _Tp> struct _IsRational {
+ enum { is_float = ::boost::is_float<_Tp>::value };
+ typedef typename __bool2type<is_float>::_Ret _Ret;
+};
+
+template <class _Tp>
+struct __type_traits {
+ enum { trivial_constructor = ::boost::has_trivial_constructor<_Tp>::value };
+ typedef typename __bool2type<trivial_constructor>::_Ret has_trivial_default_constructor;
+
+ enum { trivial_copy = ::boost::has_trivial_copy<_Tp>::value };
+ typedef typename __bool2type<trivial_copy>::_Ret has_trivial_copy_constructor;
+
+ enum { trivial_assign = ::boost::has_trivial_assign<_Tp>::value };
+ typedef typename __bool2type<trivial_assign>::_Ret has_trivial_assignment_operator;
+
+ enum { trivial_destructor = ::boost::has_trivial_destructor<_Tp>::value };
+ typedef typename __bool2type<trivial_destructor>::_Ret has_trivial_destructor;
+
+ enum { pod = ::boost::is_pod<_Tp>::value };
+ typedef typename __bool2type<pod>::_Ret is_POD_type;
+};
+
+template <class _Tp1, class _Tp2>
+struct _TrivialCopy {
+ typedef typename ::boost::remove_cv<_Tp1>::type uncv1;
+ typedef typename ::boost::remove_cv<_Tp2>::type uncv2;
+
+ enum { same = ::boost::is_same<uncv1, uncv2>::value };
+ typedef typename __bool2type<same>::_Ret _Same;
+
+ enum { boost_trivial_assign = ::boost::has_trivial_assign<uncv1>::value };
+ typedef typename __bool2type<boost_trivial_assign>::_Ret _BoostTrivialAssign;
+ typedef typename __type_traits<uncv1>::has_trivial_assignment_operator _STLPTrivialAssign;
+ typedef typename _Lor2<_BoostTrivialAssign, _STLPTrivialAssign>::_Ret _TrivialAssign;
+
+ typedef typename _Land2<_Same, _TrivialAssign>::_Ret _Type;
+ static _Type _Answer() { return _Type(); }
+};
+
+template <class _Tp1, class _Tp2>
+struct _TrivialUCopy {
+ typedef typename ::boost::remove_cv<_Tp1>::type uncv1;
+ typedef typename ::boost::remove_cv<_Tp2>::type uncv2;
+
+ enum { same = ::boost::is_same<uncv1, uncv2>::value };
+ typedef typename __bool2type<same>::_Ret _Same;
+
+ enum { boost_trivial_copy = ::boost::has_trivial_copy<uncv1>::value };
+ typedef typename __bool2type<boost_trivial_copy>::_Ret _BoostTrivialCopy;
+ typedef typename __type_traits<uncv1>::has_trivial_copy_constructor _STLPTrivialCopy;
+ typedef typename _Lor2<_BoostTrivialCopy, _STLPTrivialCopy>::_Ret _TrivialCopy;
+
+ typedef typename _Land2<_Same, _TrivialCopy>::_Ret _Type;
+ static _Type _Answer() { return _Type(); }
+};
+
+template <class _Tp>
+struct _DefaultZeroValue {
+ enum { is_integral = ::boost::is_integral<_Tp>::value };
+ typedef typename __bool2type<is_integral>::_Ret _IsIntegral;
+ enum { is_float = ::boost::is_float<_Tp>::value };
+ typedef typename __bool2type<is_float>::_Ret _IsFloat;
+ enum { is_pointer = ::boost::is_pointer<_Tp>::value };
+ typedef typename __bool2type<is_pointer>::_Ret _IsPointer;
+
+ typedef typename _Lor3<_IsIntegral, _IsFloat, _IsPointer>::_Ret _Ret;
+};
+
+template <class _Tp>
+struct _TrivialInit {
+ typedef typename ::boost::remove_cv<_Tp>::type uncv;
+
+ enum { boost_trivial_constructor = ::boost::has_trivial_constructor<uncv>::value };
+ typedef typename __bool2type<boost_trivial_constructor>::_Ret _BoostTrivialInit;
+ typedef typename __type_traits<uncv>::has_trivial_default_constructor _STLPTrivialInit;
+ typedef typename _Lor2<_BoostTrivialInit, _STLPTrivialInit>::_Ret _Tr1;
+
+ typedef typename _DefaultZeroValue<_Tp>::_Ret _Tr2;
+ typedef typename _Not<_Tr2>::_Ret _Tr3;
+
+ typedef typename _Land2<_Tr1, _Tr3>::_Ret _Ret;
+ static _Ret _Answer() { return _Ret(); }
+};
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_BOOST_TYPE_TRAITS_H */
diff --git a/sources/android/stlport/stlport/stl/c_locale.h b/sources/android/stlport/stlport/stl/c_locale.h
new file mode 100644
index 0000000..cadd2bc
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/c_locale.h
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_C_LOCALE_H
+#define _STLP_C_LOCALE_H
+
+/*
+ * Implementation dependent definitions.
+ * Beware: This header is not a purely internal header, it is also included
+ * from the outside world when building the STLport library. So this header
+ * should not reference internal headers (stlport/stl/_*.h) directly.
+ */
+#if defined (__sgi)
+# if defined (ROOT_65) /* IRIX 6.5.x */
+# include <sgidefs.h>
+# include <standards.h>
+# include <wchar.h>
+# include <ctype.h>
+# else /* IRIX pre-6.5 */
+# include <sgidefs.h>
+# include <standards.h>
+# if !defined(_SIZE_T) && !defined(_SIZE_T_)
+# define _SIZE_T
+# if (_MIPS_SZLONG == 32)
+typedef unsigned int size_t;
+# endif
+# if (_MIPS_SZLONG == 64)
+typedef unsigned long size_t;
+# endif
+# endif
+# if !defined (_WCHAR_T)
+# define _WCHAR_T
+# if (_MIPS_SZLONG == 32)
+typedef long wchar_t;
+# endif
+# if (_MIPS_SZLONG == 64)
+typedef __int32_t wchar_t;
+# endif
+# endif /* _WCHAR_T */
+# if !defined (_WINT_T)
+# define _WINT_T
+# if (_MIPS_SZLONG == 32)
+typedef long wint_t;
+# endif
+# if (_MIPS_SZLONG == 64)
+typedef __int32_t wint_t;
+# endif
+# endif /* _WINT_T */
+# if !defined (_MBSTATE_T)
+# define _MBSTATE_T
+/* _MSC_VER check is here for historical reason and seems wrong as it is the macro defined
+ * by Microsoft compilers to give their version. But we are in a SGI platform section so it
+ * is weird. However _MSC_VER might also be a SGI compiler macro so we keep it this way.*/
+# if defined (_MSC_VER)
+typedef int mbstate_t;
+# else
+typedef char mbstate_t;
+# endif
+# endif /* _MBSTATE_T */
+# endif /* ROOT65 */
+#elif defined (_STLP_USE_GLIBC)
+# include <ctype.h>
+#endif
+
+/*
+ * GENERAL FRAMEWORK
+ */
+
+/*
+ * Opaque types, implementation (if there is one) depends
+ * on platform localisation API.
+ */
+struct _Locale_ctype;
+struct _Locale_codecvt;
+struct _Locale_numeric;
+struct _Locale_time;
+struct _Locale_collate;
+struct _Locale_monetary;
+struct _Locale_messages;
+
+/*
+ Bitmask macros.
+*/
+
+/*
+ * For narrow characters, we expose the lookup table interface.
+ */
+
+#if defined (_STLP_USE_GLIBC)
+/* This section uses macros defined in the gnu libc ctype.h header */
+# define _Locale_CNTRL _IScntrl
+# define _Locale_UPPER _ISupper
+# define _Locale_LOWER _ISlower
+# define _Locale_DIGIT _ISdigit
+# define _Locale_XDIGIT _ISxdigit
+# define _Locale_PUNCT _ISpunct
+# define _Locale_SPACE _ISspace
+# define _Locale_PRINT _ISprint
+# define _Locale_ALPHA _ISalpha
+#else
+/* Default values based on C++ Standard 22.2.1.
+ * Under Windows the localisation implementation take care of mapping its
+ * mask values to those internal values. For other platforms without real
+ * localization support we are free to use the most suitable values.*/
+# define _Locale_SPACE 0x0001
+# define _Locale_PRINT 0x0002
+# define _Locale_CNTRL 0x0004
+# define _Locale_UPPER 0x0008
+# define _Locale_LOWER 0x0010
+# define _Locale_ALPHA 0x0020
+# define _Locale_DIGIT 0x0040
+# define _Locale_PUNCT 0x0080
+# define _Locale_XDIGIT 0x0100
+#endif
+
+#endif /* _STLP_C_LOCALE_H */
diff --git a/sources/android/stlport/stlport/stl/char_traits.h b/sources/android/stlport/stlport/stl/char_traits.h
new file mode 100644
index 0000000..f004a70
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/char_traits.h
@@ -0,0 +1,278 @@
+/*
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_CHAR_TRAITS_H
+#define _STLP_CHAR_TRAITS_H
+
+// Define char_traits
+
+#ifndef _STLP_INTERNAL_CSTDDEF
+# include <stl/_cstddef.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CSTRING
+# include <stl/_cstring.h>
+#endif
+
+#if defined (__unix)
+# include <sys/types.h> // For off_t
+#endif /* __unix */
+
+#if defined (__BORLANDC__)
+# include <mem.h>
+# include <string.h>
+# include <_stddef.h>
+# include <sys/types.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CONSTRUCT_H
+# include <stl/_construct.h>
+#endif
+
+#ifndef _STLP_INTERNAL_CWCHAR
+# include <stl/_cwchar.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+template <class _Tp> class allocator;
+
+#define _STLP_NULL_CHAR_INIT(_ChT) _STLP_DEFAULT_CONSTRUCTED(_ChT)
+
+#if defined(_STLP_WCE)
+typedef long streamoff;
+#elif defined (_STLP_WIN32)
+# if defined (_STLP_LONG_LONG) && !defined (__CYGWIN__)
+//The Win32 file io API support 64 bits access so streamoff and streamsize
+//has to reflect that. Do not change the stringbuf behavior.
+typedef _STLP_LONG_LONG streamoff;
+# else
+typedef ptrdiff_t streamoff;
+# endif
+#else // __unix
+# ifdef _STLP_USE_DEFAULT_FILE_OFFSET
+typedef off_t streamoff;
+# elif defined(_LARGEFILE_SOURCE) || defined(_LARGEFILE64_SOURCE) /* || defined(__USE_FILE_OFFSET64) */ \
+ /* || (defined(_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64)) */ /* || defined (__sgi) && defined (_STLP_HAS_NO_NEW_C_HEADERS) */
+typedef off64_t streamoff;
+# else
+typedef off_t streamoff;
+# endif
+#endif /* __unix */
+
+#if defined (_STLP_WIN32)
+typedef streamoff streamsize;
+#else
+typedef ptrdiff_t streamsize;
+#endif
+
+// Class fpos, which represents a position within a file. (The C++
+// standard calls for it to be defined in <ios>. This implementation
+// moves it to <iosfwd>, which is included by <ios>.)
+template <class _StateT> class fpos {
+public: // From table 88 of the C++ standard.
+ fpos(streamoff __pos) : _M_pos(__pos), _M_st(_STLP_NULL_CHAR_INIT(_StateT)) {}
+ fpos() : _M_pos(0), _M_st(_STLP_NULL_CHAR_INIT(_StateT)) {}
+
+ operator streamoff() const { return _M_pos; }
+
+ bool operator==(const fpos& __y) const
+ { return _M_pos == __y._M_pos; }
+ bool operator!=(const fpos& __y) const
+ { return _M_pos != __y._M_pos; }
+
+ fpos& operator+=(streamoff __off) {
+ _M_pos += __off;
+ return *this;
+ }
+ fpos& operator-=(streamoff __off) {
+ _M_pos -= __off;
+ return *this;
+ }
+
+ fpos operator+(streamoff __off) {
+ fpos __tmp(*this);
+ __tmp += __off;
+ return __tmp;
+ }
+ fpos operator-(streamoff __off) {
+ fpos __tmp(*this);
+ __tmp -= __off;
+ return __tmp;
+ }
+
+public: // Manipulation of the state member.
+ _StateT state() const { return _M_st; }
+ void state(_StateT __st) { _M_st = __st; }
+private:
+ streamoff _M_pos;
+ _StateT _M_st;
+};
+
+typedef fpos<mbstate_t> streampos;
+typedef fpos<mbstate_t> wstreampos;
+
+// Class __char_traits_base.
+template <class _CharT, class _IntT>
+class __char_traits_base {
+public:
+ typedef _CharT char_type;
+ typedef _IntT int_type;
+ typedef streamoff off_type;
+ typedef streampos pos_type;
+ typedef mbstate_t state_type;
+
+ static void _STLP_CALL assign(char_type& __c1, const char_type& __c2) { __c1 = __c2; }
+ static bool _STLP_CALL eq(const char_type& __c1, const char_type& __c2)
+ { return __c1 == __c2; }
+ static bool _STLP_CALL lt(const char_type& __c1, const char_type& __c2)
+ { return __c1 < __c2; }
+
+ static int _STLP_CALL compare(const char_type* __s1, const char_type* __s2, size_t __n) {
+ for (size_t __i = 0; __i < __n; ++__i)
+ if (!eq(__s1[__i], __s2[__i]))
+ return __s1[__i] < __s2[__i] ? -1 : 1;
+ return 0;
+ }
+
+ static size_t _STLP_CALL length(const char_type* __s) {
+ const char_type _NullChar = _STLP_DEFAULT_CONSTRUCTED(char_type);
+ size_t __i(0);
+ for (; !eq(__s[__i], _NullChar); ++__i) {}
+ return __i;
+ }
+
+ static const char_type* _STLP_CALL find(const char_type* __s, size_t __n, const char_type& __c) {
+ for ( ; __n > 0 ; ++__s, --__n)
+ if (eq(*__s, __c))
+ return __s;
+ return 0;
+ }
+
+ static char_type* _STLP_CALL move(char_type* __s1, const char_type* __s2, size_t _Sz)
+ { return (_Sz == 0 ? __s1 : (char_type*)memmove(__s1, __s2, _Sz * sizeof(char_type))); }
+
+ static char_type* _STLP_CALL copy(char_type* __s1, const char_type* __s2, size_t __n) {
+ return (__n == 0 ? __s1 :
+ (char_type*)memcpy(__s1, __s2, __n * sizeof(char_type)));
+ }
+
+ static char_type* _STLP_CALL assign(char_type* __s, size_t __n, char_type __c) {
+ for (size_t __i = 0; __i < __n; ++__i)
+ __s[__i] = __c;
+ return __s;
+ }
+
+ static int_type _STLP_CALL not_eof(const int_type& __c)
+ { return !eq_int_type(__c, eof()) ? __c : __STATIC_CAST(int_type, 0); }
+
+ static char_type _STLP_CALL to_char_type(const int_type& __c)
+ { return (char_type)__c; }
+
+ static int_type _STLP_CALL to_int_type(const char_type& __c)
+ { return (int_type)__c; }
+
+ static bool _STLP_CALL eq_int_type(const int_type& __c1, const int_type& __c2)
+ { return __c1 == __c2; }
+
+ static int_type _STLP_CALL eof()
+ { return (int_type)-1; }
+};
+
+// Generic char_traits class. Note that this class is provided only
+// as a base for explicit specialization; it is unlikely to be useful
+// as is for any particular user-defined type. In particular, it
+// *will not work* for a non-POD type.
+
+template <class _CharT>
+class char_traits
+ : public __char_traits_base<_CharT, _CharT> {};
+
+// Specialization for char.
+
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC char_traits<char>
+ : public __char_traits_base<char, int>,
+ public __stlport_class<char_traits<char> > {
+public:
+ typedef char char_type;
+ typedef int int_type;
+ typedef streamoff off_type;
+ typedef streampos pos_type;
+ typedef mbstate_t state_type;
+
+ static char _STLP_CALL to_char_type(const int& __c)
+ { return (char)(unsigned char)__c; }
+
+ static int _STLP_CALL to_int_type(const char& __c)
+ { return (unsigned char)__c; }
+
+ static int _STLP_CALL compare(const char* __s1, const char* __s2, size_t __n)
+ { return memcmp(__s1, __s2, __n); }
+
+ static size_t _STLP_CALL length(const char* __s)
+ { return strlen(__s); }
+
+ static void _STLP_CALL assign(char& __c1, const char& __c2)
+ { __c1 = __c2; }
+
+ static char* _STLP_CALL assign(char* __s, size_t __n, char __c) {
+ memset(__s, __c, __n);
+ return __s;
+ }
+};
+
+#if defined (_STLP_HAS_WCHAR_T)
+// Specialization for wchar_t.
+_STLP_TEMPLATE_NULL
+class _STLP_CLASS_DECLSPEC char_traits<wchar_t>
+ : public __char_traits_base<wchar_t, wint_t> {
+# if !defined (_STLP_NO_NATIVE_WIDE_FUNCTIONS) && !defined (_STLP_WCHAR_HPACC_EXCLUDE)
+public:
+# if !defined (__BORLANDC__)
+ static wchar_t* _STLP_CALL move(wchar_t* __dest, const wchar_t* __src, size_t __n)
+ { return wmemmove(__dest, __src, __n); }
+# endif
+
+ static wchar_t* _STLP_CALL copy(wchar_t* __dest, const wchar_t* __src, size_t __n)
+ { return wmemcpy(__dest, __src, __n); }
+
+# if !defined (__DMC__) && !defined (__BORLANDC__)
+ static int _STLP_CALL compare(const wchar_t* __s1, const wchar_t* __s2, size_t __n)
+ { return wmemcmp(__s1, __s2, __n); }
+# endif
+
+ static wchar_t* _STLP_CALL assign(wchar_t* __s, size_t __n, wchar_t __c)
+ { return wmemset(__s, __c, __n); }
+
+ static size_t _STLP_CALL length(const wchar_t* __s)
+ { return wcslen(__s); }
+
+ static void _STLP_CALL assign(wchar_t& __c1, const wchar_t& __c2)
+ { __c1 = __c2; }
+# endif
+};
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_CHAR_TRAITS_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/concept_checks.h b/sources/android/stlport/stlport/stl/concept_checks.h
new file mode 100644
index 0000000..5fe02c2
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/concept_checks.h
@@ -0,0 +1,810 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Silicon Graphics makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ */
+
+#ifndef __CONCEPT_CHECKS_H
+#define __CONCEPT_CHECKS_H
+
+/*
+ Use these macro like assertions, but they assert properties
+ on types (usually template arguments). In technical terms they
+ verify whether a type "models" a "concept".
+
+ This set of requirements and the terminology used here is derived
+ from the book "Generic Programming and the STL" by Matt Austern
+ (Addison Wesley). For further information please consult that
+ book. The requirements also are intended to match the ANSI/ISO C++
+ standard.
+
+ This file covers the basic concepts and the iterator concepts.
+ There are several other files that provide the requirements
+ for the STL containers:
+ container_concepts.h
+ sequence_concepts.h
+ assoc_container_concepts.h
+
+ Jeremy Siek, 1999
+
+ TO DO:
+ - some issues with regards to concept classification and mutability
+ including AssociativeContianer -> ForwardContainer
+ and SortedAssociativeContainer -> ReversibleContainer
+ - HashedAssociativeContainer
+ - Allocator
+ - Function Object Concepts
+
+ */
+
+#ifndef _STLP_USE_CONCEPT_CHECKS
+
+// Some compilers lack the features that are necessary for concept checks.
+// On those compilers we define the concept check macros to do nothing.
+#define _STLP_REQUIRES(__type_var, __concept) do {} while(0)
+#define _STLP_CLASS_REQUIRES(__type_var, __concept) \
+ static int __##__type_var##_##__concept
+#define _STLP_CONVERTIBLE(__type_x, __type_y) do {} while(0)
+#define _STLP_REQUIRES_SAME_TYPE(__type_x, __type_y) do {} while(0)
+#define _STLP_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y) \
+ static int __##__type_x##__type_y##_require_same_type
+#define _STLP_GENERATOR_CHECK(__func, __ret) do {} while(0)
+#define _STLP_CLASS_GENERATOR_CHECK(__func, __ret) \
+ static int __##__func##__ret##_generator_check
+#define _STLP_UNARY_FUNCTION_CHECK(__func, __ret, __arg) do {} while(0)
+#define _STLP_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
+ static int __##__func##__ret##__arg##_unary_function_check
+#define _STLP_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
+ do {} while(0)
+#define _STLP_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
+ static int __##__func##__ret##__first##__second##_binary_function_check
+#define _STLP_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
+ do {} while(0)
+#define _STLP_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
+ static int __##__opname##__ret##__first##__second##_require_binary_op
+
+#else /* _STLP_USE_CONCEPT_CHECKS */
+
+// This macro tests whether the template argument "__type_var"
+// satisfies the requirements of "__concept". Here is a list of concepts
+// that we know how to check:
+// _Allocator
+// _Assignable
+// _DefaultConstructible
+// _EqualityComparable
+// _LessThanComparable
+// _TrivialIterator
+// _InputIterator
+// _OutputIterator
+// _ForwardIterator
+// _BidirectionalIterator
+// _RandomAccessIterator
+// _Mutable_TrivialIterator
+// _Mutable_ForwardIterator
+// _Mutable_BidirectionalIterator
+// _Mutable_RandomAccessIterator
+
+#define _STLP_REQUIRES(__type_var, __concept) \
+do { \
+ void (*__x)( __type_var ) = __concept##_concept_specification< __type_var >\
+ ::##__concept##_requirement_violation; __x = __x; } while (0)
+
+// Use this to check whether type X is convertible to type Y
+#define _STLP_CONVERTIBLE(__type_x, __type_y) \
+do { \
+ void (*__x)( __type_x , __type_y ) = _STL_CONVERT_ERROR< __type_x , \
+ __type_y >::__type_X_is_not_convertible_to_type_Y; \
+ __x = __x; } while (0)
+
+// Use this to test whether two template arguments are the same type
+#define _STLP_REQUIRES_SAME_TYPE(__type_x, __type_y) \
+do { \
+ void (*__x)( __type_x , __type_y ) = _STL_SAME_TYPE_ERROR< __type_x, \
+ __type_y >::__type_X_not_same_as_type_Y; \
+ __x = __x; } while (0)
+
+
+// function object checks
+#define _STLP_GENERATOR_CHECK(__func, __ret) \
+do { \
+ __ret (*__x)( __func&) = \
+ _STL_GENERATOR_ERROR< \
+ __func, __ret>::__generator_requirement_violation; \
+ __x = __x; } while (0)
+
+
+#define _STLP_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
+do { \
+ __ret (*__x)( __func&, const __arg& ) = \
+ _STL_UNARY_FUNCTION_ERROR< \
+ __func, __ret, __arg>::__unary_function_requirement_violation; \
+ __x = __x; } while (0)
+
+
+#define _STLP_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
+do { \
+ __ret (*__x)( __func&, const __first&, const __second& ) = \
+ _STL_BINARY_FUNCTION_ERROR< \
+ __func, __ret, __first, __second>::__binary_function_requirement_violation; \
+ __x = __x; } while (0)
+
+
+#define _STLP_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
+ do { \
+ __ret (*__x)( __first&, __second& ) = _STL_BINARY##__opname##_ERROR< \
+ __ret, __first, __second>::__binary_operator_requirement_violation; \
+ __ret (*__y)( const __first&, const __second& ) = \
+ _STL_BINARY##__opname##_ERROR< __ret, __first, __second>:: \
+ __const_binary_operator_requirement_violation; \
+ __y = __y; __x = __x; } while (0)
+
+
+#ifdef _STLP_NO_FUNCTION_PTR_IN_CLASS_TEMPLATE
+
+#define _STLP_CLASS_REQUIRES(__type_var, __concept)
+#define _STLP_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y)
+#define _STLP_CLASS_GENERATOR_CHECK(__func, __ret)
+#define _STLP_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg)
+#define _STLP_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second)
+#define _STLP_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second)
+
+#else
+
+// Use this macro inside of template classes, where you would
+// like to place requirements on the template arguments to the class
+// Warning: do not pass pointers and such (e.g. T*) in as the __type_var,
+// since the type_var is used to construct identifiers. Instead typedef
+// the pointer type, then use the typedef name for the __type_var.
+#define _STLP_CLASS_REQUIRES(__type_var, __concept) \
+ typedef void (* __func##__type_var##__concept)( __type_var ); \
+ template <__func##__type_var##__concept _Tp1> \
+ struct __dummy_struct_##__type_var##__concept { }; \
+ static __dummy_struct_##__type_var##__concept< \
+ __concept##_concept_specification< \
+ __type_var>::__concept##_requirement_violation> \
+ __dummy_ptr_##__type_var##__concept
+
+
+#define _STLP_CLASS_REQUIRES_SAME_TYPE(__type_x, __type_y) \
+ typedef void (* __func_##__type_x##__type_y##same_type)( __type_x, \
+ __type_y ); \
+ template < __func_##__type_x##__type_y##same_type _Tp1> \
+ struct __dummy_struct_##__type_x##__type_y##_same_type { }; \
+ static __dummy_struct_##__type_x##__type_y##_same_type< \
+ _STL_SAME_TYPE_ERROR<__type_x, __type_y>::__type_X_not_same_as_type_Y> \
+ __dummy_ptr_##__type_x##__type_y##_same_type
+
+
+#define _STLP_CLASS_GENERATOR_CHECK(__func, __ret) \
+ typedef __ret (* __f_##__func##__ret##_generator)( __func& ); \
+ template <__f_##__func##__ret##_generator _Tp1> \
+ struct __dummy_struct_##__func##__ret##_generator { }; \
+ static __dummy_struct_##__func##__ret##_generator< \
+ _STL_GENERATOR_ERROR< \
+ __func, __ret>::__generator_requirement_violation> \
+ __dummy_ptr_##__func##__ret##_generator
+
+
+#define _STLP_CLASS_UNARY_FUNCTION_CHECK(__func, __ret, __arg) \
+ typedef __ret (* __f_##__func##__ret##__arg##_unary_check)( __func&, \
+ const __arg& ); \
+ template <__f_##__func##__ret##__arg##_unary_check _Tp1> \
+ struct __dummy_struct_##__func##__ret##__arg##_unary_check { }; \
+ static __dummy_struct_##__func##__ret##__arg##_unary_check< \
+ _STL_UNARY_FUNCTION_ERROR< \
+ __func, __ret, __arg>::__unary_function_requirement_violation> \
+ __dummy_ptr_##__func##__ret##__arg##_unary_check
+
+
+#define _STLP_CLASS_BINARY_FUNCTION_CHECK(__func, __ret, __first, __second) \
+ typedef __ret (* __f_##__func##__ret##__first##__second##_binary_check)( __func&, const __first&,\
+ const __second& ); \
+ template <__f_##__func##__ret##__first##__second##_binary_check _Tp1> \
+ struct __dummy_struct_##__func##__ret##__first##__second##_binary_check { }; \
+ static __dummy_struct_##__func##__ret##__first##__second##_binary_check< \
+ _STL_BINARY_FUNCTION_ERROR<__func, __ret, __first, __second>:: \
+ __binary_function_requirement_violation> \
+ __dummy_ptr_##__func##__ret##__first##__second##_binary_check
+
+
+#define _STLP_CLASS_REQUIRES_BINARY_OP(__opname, __ret, __first, __second) \
+ typedef __ret (* __f_##__func##__ret##__first##__second##_binary_op)(const __first&, \
+ const __second& ); \
+ template <__f_##__func##__ret##__first##__second##_binary_op _Tp1> \
+ struct __dummy_struct_##__func##__ret##__first##__second##_binary_op { }; \
+ static __dummy_struct_##__func##__ret##__first##__second##_binary_op< \
+ _STL_BINARY##__opname##_ERROR<__ret, __first, __second>:: \
+ __binary_operator_requirement_violation> \
+ __dummy_ptr_##__func##__ret##__first##__second##_binary_op
+
+#endif
+
+/* helper class for finding non-const version of a type. Need to have
+ something to assign to etc. when testing constant iterators. */
+
+template <class _Tp>
+struct _Mutable_trait {
+ typedef _Tp _Type;
+};
+template <class _Tp>
+struct _Mutable_trait<const _Tp> {
+ typedef _Tp _Type;
+};
+
+
+/* helper function for avoiding compiler warnings about unused variables */
+template <class _Type>
+void __sink_unused_warning(_Type) { }
+
+template <class _TypeX, class _TypeY>
+struct _STL_CONVERT_ERROR {
+ static void
+ __type_X_is_not_convertible_to_type_Y(_TypeX __x, _TypeY) {
+ _TypeY __y = __x;
+ __sink_unused_warning(__y);
+ }
+};
+
+
+template <class _Type> struct __check_equal { };
+
+template <class _TypeX, class _TypeY>
+struct _STL_SAME_TYPE_ERROR {
+ static void
+ __type_X_not_same_as_type_Y(_TypeX , _TypeY ) {
+ __check_equal<_TypeX> t1 = __check_equal<_TypeY>();
+ }
+};
+
+
+// Some Functon Object Checks
+
+template <class _Func, class _Ret>
+struct _STL_GENERATOR_ERROR {
+ static _Ret __generator_requirement_violation(_Func& __f) {
+ return __f();
+ }
+};
+
+template <class _Func>
+struct _STL_GENERATOR_ERROR<_Func, void> {
+ static void __generator_requirement_violation(_Func& __f) {
+ __f();
+ }
+};
+
+
+template <class _Func, class _Ret, class _Arg>
+struct _STL_UNARY_FUNCTION_ERROR {
+ static _Ret
+ __unary_function_requirement_violation(_Func& __f,
+ const _Arg& __arg) {
+ return __f(__arg);
+ }
+};
+
+template <class _Func, class _Arg>
+struct _STL_UNARY_FUNCTION_ERROR<_Func, void, _Arg> {
+ static void
+ __unary_function_requirement_violation(_Func& __f,
+ const _Arg& __arg) {
+ __f(__arg);
+ }
+};
+
+template <class _Func, class _Ret, class _First, class _Second>
+struct _STL_BINARY_FUNCTION_ERROR {
+ static _Ret
+ __binary_function_requirement_violation(_Func& __f,
+ const _First& __first,
+ const _Second& __second) {
+ return __f(__first, __second);
+ }
+};
+
+template <class _Func, class _First, class _Second>
+struct _STL_BINARY_FUNCTION_ERROR<_Func, void, _First, _Second> {
+ static void
+ __binary_function_requirement_violation(_Func& __f,
+ const _First& __first,
+ const _Second& __second) {
+ __f(__first, __second);
+ }
+};
+
+
+#define _STLP_DEFINE_BINARY_OP_CHECK(_OP, _NAME) \
+template <class _Ret, class _First, class _Second> \
+struct _STL_BINARY##_NAME##_ERROR { \
+ static _Ret \
+ __const_binary_operator_requirement_violation(const _First& __first, \
+ const _Second& __second) { \
+ return __first _OP __second; \
+ } \
+ static _Ret \
+ __binary_operator_requirement_violation(_First& __first, \
+ _Second& __second) { \
+ return __first _OP __second; \
+ } \
+}
+
+_STLP_DEFINE_BINARY_OP_CHECK(==, _OP_EQUAL);
+_STLP_DEFINE_BINARY_OP_CHECK(!=, _OP_NOT_EQUAL);
+_STLP_DEFINE_BINARY_OP_CHECK(<, _OP_LESS_THAN);
+_STLP_DEFINE_BINARY_OP_CHECK(<=, _OP_LESS_EQUAL);
+_STLP_DEFINE_BINARY_OP_CHECK(>, _OP_GREATER_THAN);
+_STLP_DEFINE_BINARY_OP_CHECK(>=, _OP_GREATER_EQUAL);
+_STLP_DEFINE_BINARY_OP_CHECK(+, _OP_PLUS);
+_STLP_DEFINE_BINARY_OP_CHECK(*, _OP_TIMES);
+_STLP_DEFINE_BINARY_OP_CHECK(/, _OP_DIVIDE);
+_STLP_DEFINE_BINARY_OP_CHECK(-, _OP_SUBTRACT);
+_STLP_DEFINE_BINARY_OP_CHECK(%, _OP_MOD);
+// ...
+
+// TODO, add unary operators (prefix and postfix)
+
+/*
+ The presence of this class is just to trick EDG into displaying
+ these error messages before any other errors. Without the
+ classes, the errors in the functions get reported after
+ other class errors deep inside the library. The name
+ choice just makes for an eye catching error message :)
+ */
+struct _STL_ERROR {
+
+ template <class _Type>
+ static _Type
+ __default_constructor_requirement_violation(_Type) {
+ return _Type();
+ }
+ template <class _Type>
+ static _Type
+ __assignment_operator_requirement_violation(_Type __a) {
+ __a = __a;
+ return __a;
+ }
+ template <class _Type>
+ static _Type
+ __copy_constructor_requirement_violation(_Type __a) {
+ _Type __c(__a);
+ return __c;
+ }
+ template <class _Type>
+ static _Type
+ __const_parameter_required_for_copy_constructor(_Type /* __a */,
+ const _Type& __b) {
+ _Type __c(__b);
+ return __c;
+ }
+ template <class _Type>
+ static _Type
+ __const_parameter_required_for_assignment_operator(_Type __a,
+ const _Type& __b) {
+ __a = __b;
+ return __a;
+ }
+ template <class _Type>
+ static _Type
+ __less_than_comparable_requirement_violation(_Type __a, _Type __b) {
+ if (__a < __b || __a > __b || __a <= __b || __a >= __b) return __a;
+ return __b;
+ }
+ template <class _Type>
+ static _Type
+ __equality_comparable_requirement_violation(_Type __a, _Type __b) {
+ if (__a == __b || __a != __b) return __a;
+ return __b;
+ }
+ template <class _Iterator>
+ static void
+ __dereference_operator_requirement_violation(_Iterator __i) {
+ __sink_unused_warning(*__i);
+ }
+ template <class _Iterator>
+ static void
+ __dereference_operator_and_assignment_requirement_violation(_Iterator __i) {
+ *__i = *__i;
+ }
+ template <class _Iterator>
+ static void
+ __preincrement_operator_requirement_violation(_Iterator __i) {
+ ++__i;
+ }
+ template <class _Iterator>
+ static void
+ __postincrement_operator_requirement_violation(_Iterator __i) {
+ __i++;
+ }
+ template <class _Iterator>
+ static void
+ __predecrement_operator_requirement_violation(_Iterator __i) {
+ --__i;
+ }
+ template <class _Iterator>
+ static void
+ __postdecrement_operator_requirement_violation(_Iterator __i) {
+ __i--;
+ }
+ template <class _Iterator, class _Type>
+ static void
+ __postincrement_operator_and_assignment_requirement_violation(_Iterator __i,
+ _Type __t) {
+ *__i++ = __t;
+ }
+ template <class _Iterator, class _Distance>
+ static _Iterator
+ __iterator_addition_assignment_requirement_violation(_Iterator __i,
+ _Distance __n) {
+ __i += __n;
+ return __i;
+ }
+ template <class _Iterator, class _Distance>
+ static _Iterator
+ __iterator_addition_requirement_violation(_Iterator __i, _Distance __n) {
+ __i = __i + __n;
+ __i = __n + __i;
+ return __i;
+ }
+ template <class _Iterator, class _Distance>
+ static _Iterator
+ __iterator_subtraction_assignment_requirement_violation(_Iterator __i,
+ _Distance __n) {
+ __i -= __n;
+ return __i;
+ }
+ template <class _Iterator, class _Distance>
+ static _Iterator
+ __iterator_subtraction_requirement_violation(_Iterator __i, _Distance __n) {
+ __i = __i - __n;
+ return __i;
+ }
+ template <class _Iterator, class _Distance>
+ static _Distance
+ __difference_operator_requirement_violation(_Iterator __i, _Iterator __j,
+ _Distance __n) {
+ __n = __i - __j;
+ return __n;
+ }
+ template <class _Exp, class _Type, class _Distance>
+ static _Type
+ __element_access_operator_requirement_violation(_Exp __x, _Type*,
+ _Distance __n) {
+ return __x[__n];
+ }
+ template <class _Exp, class _Type, class _Distance>
+ static void
+ __element_assignment_operator_requirement_violation(_Exp __x,
+ _Type* __t,
+ _Distance __n) {
+ __x[__n] = *__t;
+ }
+
+}; /* _STL_ERROR */
+
+/* Associated Type Requirements */
+
+_STLP_BEGIN_NAMESPACE
+template <class _Iterator> struct iterator_traits;
+_STLP_END_NAMESPACE
+
+template <class _Iter>
+struct __value_type_type_definition_requirement_violation {
+ typedef typename __STD::iterator_traits<_Iter>::value_type value_type;
+};
+
+template <class _Iter>
+struct __difference_type_type_definition_requirement_violation {
+ typedef typename __STD::iterator_traits<_Iter>::difference_type
+ difference_type;
+};
+
+template <class _Iter>
+struct __reference_type_definition_requirement_violation {
+ typedef typename __STD::iterator_traits<_Iter>::reference reference;
+};
+
+template <class _Iter>
+struct __pointer_type_definition_requirement_violation {
+ typedef typename __STD::iterator_traits<_Iter>::pointer pointer;
+};
+
+template <class _Iter>
+struct __iterator_category_type_definition_requirement_violation {
+ typedef typename __STD::iterator_traits<_Iter>::iterator_category
+ iterator_category;
+};
+
+/* Assignable Requirements */
+
+
+template <class _Type>
+struct _Assignable_concept_specification {
+ static void _Assignable_requirement_violation(_Type __a) {
+ _STL_ERROR::__assignment_operator_requirement_violation(__a);
+ _STL_ERROR::__copy_constructor_requirement_violation(__a);
+ _STL_ERROR::__const_parameter_required_for_copy_constructor(__a,__a);
+ _STL_ERROR::__const_parameter_required_for_assignment_operator(__a,__a);
+ }
+};
+
+/* DefaultConstructible Requirements */
+
+
+template <class _Type>
+struct _DefaultConstructible_concept_specification {
+ static void _DefaultConstructible_requirement_violation(_Type __a) {
+ _STL_ERROR::__default_constructor_requirement_violation(__a);
+ }
+};
+
+/* EqualityComparable Requirements */
+
+template <class _Type>
+struct _EqualityComparable_concept_specification {
+ static void _EqualityComparable_requirement_violation(_Type __a) {
+ _STL_ERROR::__equality_comparable_requirement_violation(__a, __a);
+ }
+};
+
+/* LessThanComparable Requirements */
+template <class _Type>
+struct _LessThanComparable_concept_specification {
+ static void _LessThanComparable_requirement_violation(_Type __a) {
+ _STL_ERROR::__less_than_comparable_requirement_violation(__a, __a);
+ }
+};
+
+/* TrivialIterator Requirements */
+
+template <class _TrivialIterator>
+struct _TrivialIterator_concept_specification {
+static void
+_TrivialIterator_requirement_violation(_TrivialIterator __i) {
+ typedef typename
+ __value_type_type_definition_requirement_violation<_TrivialIterator>::
+ value_type __T;
+ // Refinement of Assignable
+ _Assignable_concept_specification<_TrivialIterator>::
+ _Assignable_requirement_violation(__i);
+ // Refinement of DefaultConstructible
+ _DefaultConstructible_concept_specification<_TrivialIterator>::
+ _DefaultConstructible_requirement_violation(__i);
+ // Refinement of EqualityComparable
+ _EqualityComparable_concept_specification<_TrivialIterator>::
+ _EqualityComparable_requirement_violation(__i);
+ // Valid Expressions
+ _STL_ERROR::__dereference_operator_requirement_violation(__i);
+}
+};
+
+template <class _TrivialIterator>
+struct _Mutable_TrivialIterator_concept_specification {
+static void
+_Mutable_TrivialIterator_requirement_violation(_TrivialIterator __i) {
+ _TrivialIterator_concept_specification<_TrivialIterator>::
+ _TrivialIterator_requirement_violation(__i);
+ // Valid Expressions
+ _STL_ERROR::__dereference_operator_and_assignment_requirement_violation(__i);
+}
+};
+
+/* InputIterator Requirements */
+
+template <class _InputIterator>
+struct _InputIterator_concept_specification {
+static void
+_InputIterator_requirement_violation(_InputIterator __i) {
+ // Refinement of TrivialIterator
+ _TrivialIterator_concept_specification<_InputIterator>::
+ _TrivialIterator_requirement_violation(__i);
+ // Associated Types
+ __difference_type_type_definition_requirement_violation<_InputIterator>();
+ __reference_type_definition_requirement_violation<_InputIterator>();
+ __pointer_type_definition_requirement_violation<_InputIterator>();
+ __iterator_category_type_definition_requirement_violation<_InputIterator>();
+ // Valid Expressions
+ _STL_ERROR::__preincrement_operator_requirement_violation(__i);
+ _STL_ERROR::__postincrement_operator_requirement_violation(__i);
+}
+};
+
+/* OutputIterator Requirements */
+
+template <class _OutputIterator>
+struct _OutputIterator_concept_specification {
+static void
+_OutputIterator_requirement_violation(_OutputIterator __i) {
+ // Refinement of Assignable
+ _Assignable_concept_specification<_OutputIterator>::
+ _Assignable_requirement_violation(__i);
+ // Associated Types
+ __iterator_category_type_definition_requirement_violation<_OutputIterator>();
+ // Valid Expressions
+ _STL_ERROR::__dereference_operator_requirement_violation(__i);
+ _STL_ERROR::__preincrement_operator_requirement_violation(__i);
+ _STL_ERROR::__postincrement_operator_requirement_violation(__i);
+ _STL_ERROR::
+ __postincrement_operator_and_assignment_requirement_violation(__i, *__i);
+}
+};
+
+/* ForwardIterator Requirements */
+
+template <class _ForwardIterator>
+struct _ForwardIterator_concept_specification {
+static void
+_ForwardIterator_requirement_violation(_ForwardIterator __i) {
+ // Refinement of InputIterator
+ _InputIterator_concept_specification<_ForwardIterator>::
+ _InputIterator_requirement_violation(__i);
+}
+};
+
+template <class _ForwardIterator>
+struct _Mutable_ForwardIterator_concept_specification {
+static void
+_Mutable_ForwardIterator_requirement_violation(_ForwardIterator __i) {
+ _ForwardIterator_concept_specification<_ForwardIterator>::
+ _ForwardIterator_requirement_violation(__i);
+ // Refinement of OutputIterator
+ _OutputIterator_concept_specification<_ForwardIterator>::
+ _OutputIterator_requirement_violation(__i);
+}
+};
+
+/* BidirectionalIterator Requirements */
+
+template <class _BidirectionalIterator>
+struct _BidirectionalIterator_concept_specification {
+static void
+_BidirectionalIterator_requirement_violation(_BidirectionalIterator __i) {
+ // Refinement of ForwardIterator
+ _ForwardIterator_concept_specification<_BidirectionalIterator>::
+ _ForwardIterator_requirement_violation(__i);
+ // Valid Expressions
+ _STL_ERROR::__predecrement_operator_requirement_violation(__i);
+ _STL_ERROR::__postdecrement_operator_requirement_violation(__i);
+}
+};
+
+template <class _BidirectionalIterator>
+struct _Mutable_BidirectionalIterator_concept_specification {
+static void
+_Mutable_BidirectionalIterator_requirement_violation(
+ _BidirectionalIterator __i)
+{
+ _BidirectionalIterator_concept_specification<_BidirectionalIterator>::
+ _BidirectionalIterator_requirement_violation(__i);
+ // Refinement of mutable_ForwardIterator
+ _Mutable_ForwardIterator_concept_specification<_BidirectionalIterator>::
+ _Mutable_ForwardIterator_requirement_violation(__i);
+ typedef typename
+ __value_type_type_definition_requirement_violation<
+ _BidirectionalIterator>::value_type __T;
+ typename _Mutable_trait<__T>::_Type* __tmp_ptr = 0;
+ // Valid Expressions
+ _STL_ERROR::
+ __postincrement_operator_and_assignment_requirement_violation(__i,
+ *__tmp_ptr);
+}
+};
+
+/* RandomAccessIterator Requirements */
+
+template <class _RandAccIter>
+struct _RandomAccessIterator_concept_specification {
+static void
+_RandomAccessIterator_requirement_violation(_RandAccIter __i) {
+ // Refinement of BidirectionalIterator
+ _BidirectionalIterator_concept_specification<_RandAccIter>::
+ _BidirectionalIterator_requirement_violation(__i);
+ // Refinement of LessThanComparable
+ _LessThanComparable_concept_specification<_RandAccIter>::
+ _LessThanComparable_requirement_violation(__i);
+ typedef typename
+ __value_type_type_definition_requirement_violation<_RandAccIter>
+ ::value_type
+ value_type;
+ typedef typename
+ __difference_type_type_definition_requirement_violation<_RandAccIter>
+ ::difference_type
+ _Dist;
+ typedef typename _Mutable_trait<_Dist>::_Type _MutDist;
+
+ // Valid Expressions
+ _STL_ERROR::__iterator_addition_assignment_requirement_violation(__i,
+ _MutDist());
+ _STL_ERROR::__iterator_addition_requirement_violation(__i,
+ _MutDist());
+ _STL_ERROR::
+ __iterator_subtraction_assignment_requirement_violation(__i,
+ _MutDist());
+ _STL_ERROR::__iterator_subtraction_requirement_violation(__i,
+ _MutDist());
+ _STL_ERROR::__difference_operator_requirement_violation(__i, __i,
+ _MutDist());
+ typename _Mutable_trait<value_type>::_Type* __dummy_ptr = 0;
+ _STL_ERROR::__element_access_operator_requirement_violation(__i,
+ __dummy_ptr,
+ _MutDist());
+}
+};
+
+template <class _RandAccIter>
+struct _Mutable_RandomAccessIterator_concept_specification {
+static void
+_Mutable_RandomAccessIterator_requirement_violation(_RandAccIter __i)
+{
+ _RandomAccessIterator_concept_specification<_RandAccIter>::
+ _RandomAccessIterator_requirement_violation(__i);
+ // Refinement of mutable_BidirectionalIterator
+ _Mutable_BidirectionalIterator_concept_specification<_RandAccIter>::
+ _Mutable_BidirectionalIterator_requirement_violation(__i);
+ typedef typename
+ __value_type_type_definition_requirement_violation<_RandAccIter>
+ ::value_type
+ value_type;
+ typedef typename
+ __difference_type_type_definition_requirement_violation<_RandAccIter>
+ ::difference_type
+ _Dist;
+
+ typename _Mutable_trait<value_type>::_Type* __tmp_ptr = 0;
+ // Valid Expressions
+ _STL_ERROR::__element_assignment_operator_requirement_violation(__i,
+ __tmp_ptr, _Dist());
+}
+};
+
+#define _STLP_TYPEDEF_REQUIREMENT(__REQUIREMENT) \
+template <class Type> \
+struct __##__REQUIREMENT##__typedef_requirement_violation { \
+ typedef typename Type::__REQUIREMENT __REQUIREMENT; \
+};
+
+_STLP_TYPEDEF_REQUIREMENT(value_type);
+_STLP_TYPEDEF_REQUIREMENT(difference_type);
+_STLP_TYPEDEF_REQUIREMENT(size_type);
+_STLP_TYPEDEF_REQUIREMENT(reference);
+_STLP_TYPEDEF_REQUIREMENT(const_reference);
+_STLP_TYPEDEF_REQUIREMENT(pointer);
+_STLP_TYPEDEF_REQUIREMENT(const_pointer);
+
+
+template <class _Alloc>
+struct _Allocator_concept_specification {
+static void
+_Allocator_requirement_violation(_Alloc __a) {
+ // Refinement of DefaultConstructible
+ _DefaultConstructible_concept_specification<_Alloc>::
+ _DefaultConstructible_requirement_violation(__a);
+ // Refinement of EqualityComparable
+ _EqualityComparable_concept_specification<_Alloc>::
+ _EqualityComparable_requirement_violation(__a);
+ // Associated Types
+ __value_type__typedef_requirement_violation<_Alloc>();
+ __difference_type__typedef_requirement_violation<_Alloc>();
+ __size_type__typedef_requirement_violation<_Alloc>();
+ __reference__typedef_requirement_violation<_Alloc>();
+ __const_reference__typedef_requirement_violation<_Alloc>();
+ __pointer__typedef_requirement_violation<_Alloc>();
+ __const_pointer__typedef_requirement_violation<_Alloc>();
+ typedef typename _Alloc::value_type _Type;
+ _STLP_REQUIRES_SAME_TYPE(typename _Alloc::rebind<_Type>::other, _Alloc);
+}
+};
+
+#endif /* _STLP_USE_CONCEPT_CHECKS */
+
+#endif /* __CONCEPT_CHECKS_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/config/_aix.h b/sources/android/stlport/stlport/stl/config/_aix.h
new file mode 100644
index 0000000..45ea8b6
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_aix.h
@@ -0,0 +1,3 @@
+#define _STLP_PLATFORM "AIX"
+
+#define _STLP_USE_UNIX_IO
diff --git a/sources/android/stlport/stlport/stl/config/_android.h b/sources/android/stlport/stlport/stl/config/_android.h
new file mode 100644
index 0000000..a9f1cd8
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_android.h
@@ -0,0 +1,76 @@
+#ifndef __stl_config__android_h
+#define __stl_config__android_h
+
+#define _STLP_PLATFORM "Android"
+
+// Mostly Unix-like.
+#define _STLP_UNIX 1
+
+// Have pthreads support.
+#define _PTHREADS
+
+// Don't have native <cplusplus> headers
+#define _STLP_HAS_NO_NEW_C_HEADERS 1
+
+// Use unix for streams
+#define _STLP_USE_UNIX_IO 1
+
+// No rtti support
+#define _STLP_NO_RTTI 1
+
+// C library is in the global namespace.
+#define _STLP_VENDOR_GLOBAL_CSTD 1
+
+// Don't have underlying local support.
+#undef _STLP_REAL_LOCALE_IMPLEMENTED
+
+// No pthread_spinlock_t in Android
+#define _STLP_DONT_USE_PTHREAD_SPINLOCK 1
+
+// Enable thread support
+#undef _NOTHREADS
+
+// Little endian platform.
+#define _STLP_LITTLE_ENDIAN 1
+
+// No <exception> headers
+#define _STLP_NO_EXCEPTION_HEADER 1
+
+// No throwing exceptions
+#define _STLP_NO_EXCEPTIONS 1
+
+// No need to define our own namespace
+#define _STLP_NO_OWN_NAMESPACE 1
+
+// Use __new_alloc instead of __node_alloc, so we don't need static functions.
+#define _STLP_USE_SIMPLE_NODE_ALLOC 1
+
+// Don't use extern versions of range errors, so we don't need to
+// compile as a library.
+#define _STLP_USE_NO_EXTERN_RANGE_ERRORS 1
+
+// The system math library doesn't have long double variants, e.g
+// sinl, cosl, etc
+#define _STLP_NO_VENDOR_MATH_L 1
+
+// Define how to include our native headers.
+#define _STLP_NATIVE_HEADER(header) <usr/include/header>
+#define _STLP_NATIVE_C_HEADER(header) <../include/header>
+#define _STLP_NATIVE_CPP_C_HEADER(header) <../../system/include/header>
+#define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) <../../system/include/header>
+#define _STLP_NATIVE_OLD_STREAMS_HEADER(header) <usr/include/header>
+
+// Include most of the gcc settings.
+#include <stl/config/_gcc.h>
+
+// Do not use glibc, Android is missing some things.
+#undef _STLP_USE_GLIBC
+
+// No exceptions.
+#define _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT 1
+#define _STLP_NO_UNEXPECTED_EXCEPT_SUPPORT 1
+
+// Android does have include_next but it doesn't work well in our build system.
+#undef _STLP_HAS_INCLUDE_NEXT
+
+#endif /* __stl_config__android_h */
diff --git a/sources/android/stlport/stlport/stl/config/_apcc.h b/sources/android/stlport/stlport/stl/config/_apcc.h
new file mode 100644
index 0000000..7b4e139
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_apcc.h
@@ -0,0 +1,30 @@
+// STLport config file for Apogee 4.x
+
+#define _STLP_COMPILER "Apogee"
+
+#define _STLP_NO_NEW_NEW_HEADER 1
+#define _STLP_HAS_NO_NEW_C_HEADERS 1
+
+#if defined(_XOPEN_SOURCE) && (_XOPEN_VERSION - 0 >= 4)
+# define _STLP_RAND48 1
+#endif
+// # define _STLP_RAND48 1
+#define _STLP_LONG_LONG long long
+#define _STLP_NO_BAD_ALLOC 1
+#define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1
+#define _STLP_NON_TYPE_TMPL_PARAM_BUG 1
+// # define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1
+#define _STLP_NO_EXCEPTION_HEADER 1
+
+#undef _STLP_LINK_TIME_INSTANTIATION
+#define _STLP_LINK_TIME_INSTANTIATION 1
+
+#ifdef __STDLIB
+# undef _STLP_NO_NEW_C_HEADERS
+# undef _STLP_NO_NEW_NEW_HEADER
+# undef _STLP_NO_BAD_ALLOC
+# undef _STLP_LONG_LONG
+#else
+# undef _STLP_NO_EXCEPTION_SPEC
+# define _STLP_NO_EXCEPTION_SPEC 1
+#endif
diff --git a/sources/android/stlport/stlport/stl/config/_apple.h b/sources/android/stlport/stlport/stl/config/_apple.h
new file mode 100644
index 0000000..899ed14
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_apple.h
@@ -0,0 +1,118 @@
+/* STLport configuration file
+ * It is internal STLport header - DO NOT include it directly
+ */
+
+/* common configuration settings for Apple MPW MrCpp / SCpp */
+
+#define _STLP_COMPILER "spec me!"
+
+#if defined(__MRC__) && __MRC__ < 0x500
+# error Apple's MPW MrCpp v.5.0.0 or better compiler required
+#endif
+#if defined(__SC__) && __SC__ < 0x890
+# error Apple's MPW SCpp v.8.9.0 or better compiler required
+#endif
+
+/* TODO: Check that this config is necessary for all compiler versions.
+ * It is here for historical reasons for the moment.
+ */
+#define _STLP_NO_CONTAINERS_EXTENSION
+
+#ifdef qMacApp
+# ifndef __CONDITIONALMACROS__ /* skip including ConditionalMacros_AC.h if ConditionalMacros.h is already included */
+# include <CoreSwitches_AC.h>
+# include <ConditionalMacros_AC.h>
+# include <Types_AC.h>
+# define _STLP_FILE__ _FILE_AC
+# define _STLP_DEBUG_MESSAGE
+# define __stl_debug_message ProgramBreak_AC
+# include <ConditionalMacros.h>
+# endif
+# include <Types.h>
+#else
+# include <ConditionalMacros.h>
+# include <Types.h>
+#endif
+
+#define _STLP_UINT32_T UInt32
+typedef int wint_t;
+
+#ifndef TYPE_BOOL
+# error <ConditionalMacros.h> must be included. (TYPE_BOOL)
+#endif
+#if !TYPE_BOOL
+# define _STLP_NO_BOOL
+# define _STLP_DONT_USE_BOOL_TYPEDEF
+#endif
+
+#ifndef TYPE_LONGLONG
+# error <ConditionalMacros.h> must be included. (TYPE_LONGLONG)
+#endif
+#if TYPE_LONGLONG
+# define _STLP_LONG_LONG long long
+#endif
+
+#if !__option(exceptions)
+# define _STLP_HAS_NO_EXCEPTIONS
+#endif
+
+#define _STLP_DEBUG_MESSAGE_POST DebugStr("\pSTL diagnosis issued. See 'stderr' for detail.");
+#define _STLP_ASSERT_MSG_TRAILER " "
+
+#ifdef _STLP_DEBUG
+# define _STLP_THROW(x) (DebugStr("\pSTL is about to throw exception: "#x),throw x)
+#endif
+
+#if defined(__MRC__)
+# ifndef __spillargs
+# define __spillargs 1 // MrCpp requires this symbol to be defined as 1 to properly handle va_start; ref.[ file stdarg.h; line 26 ]
+# endif
+#endif
+
+#if defined(__SC__)
+#define _STLP_VENDOR_LONG_DOUBLE_MATH //*TY 12/03/2000 - SCpp's native math type is long double
+#endif
+
+#ifndef _STLP_NATIVE_INCLUDE_PATH
+# if __option(unix_includes)
+# define _STLP_NATIVE_INCLUDE_PATH ../CIncludes // expects the alias to {CIncludes} under the same folder as {STL}
+# else
+# define _STLP_NATIVE_INCLUDE_PATH ::CIncludes // expects the alias to {CIncludes} under the same folder as {STL}
+# endif
+#endif
+#if !defined(_STLP_MAKE_HEADER)
+# if !__option(unix_includes)
+# define _STLP_MAKE_HEADER(path, header) <path:header> // Mac uses ":" for directory delimiter
+# endif
+#endif
+
+# define _STLD _DBG // to keep the length of generated symbols within the compiler limitation
+
+#define _STLP_USE_STDIO_IO 1 //*TY 02/24/2000 - see also ; ref.[ file _fstream.h; line 36 ]
+#define _STLP_NO_THREADS //*TY 12/17/2000 - multi-thread capability not explored, yet.
+#undef _REENTRANT //*ty 11/24/2001 - to make sure no thread facility is activated
+#define _NOTHREADS //*ty 12/07/2001 -
+
+// native library limitations
+#define _STLP_VENDOR_GLOBAL_STD // mpw's c++ libs do not utilize namespace std yet
+#define _STLP_NO_BAD_ALLOC // known limitation
+#define _STLP_HAS_NO_NEW_C_HEADERS // known limitation
+#define _STLP_NO_NEW_NEW_HEADER // known limitation
+#define _STLP_NO_NATIVE_MBSTATE_T // known limitation
+#define _STLP_NO_NATIVE_WIDE_FUNCTIONS // known limitation
+#define _STLP_NO_NATIVE_WIDE_STREAMS // known limitation
+#define _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT // known limitation
+#define _STLP_BROKEN_EXCEPTION_CLASS // known limitation
+
+// compiler limitations
+# define _STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS
+
+# define _STLP_MPWFIX_TRY try{ //*TY 06/01/2000 - exception handling bug workaround
+# define _STLP_MPWFIX_CATCH }catch(...){throw;} //*TY 06/01/2000 - exception handling bug workaround
+# define _STLP_MPWFIX_CATCH_ACTION(action) }catch(...){action;throw;} //*TY 06/01/2000 - exception handling bug workaround
+# define _STLP_THROW_RETURN_BUG // known limitation
+# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION // known limitation
+# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX // known limitation
+# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER // known limitation
+# define _STLP_NO_RELOPS_NAMESPACE // known limitation
+// end of stl_apple.h
diff --git a/sources/android/stlport/stlport/stl/config/_as400.h b/sources/android/stlport/stlport/stl/config/_as400.h
new file mode 100644
index 0000000..28d960b
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_as400.h
@@ -0,0 +1,55 @@
+// STLport configuration file
+// It is internal STLport header - DO NOT include it directly
+
+// AS/400 C++ config
+
+# ifdef _REENTRANT
+# define _PTHREADS
+# endif
+
+# define _STLP_NO_NEW_NEW_HEADER 1
+
+# define _STLP_NO_BOOL
+# define _STLP_LIMITED_DEFAULT_TEMPLATES
+
+# define _STLP_HAS_NO_NAMESPACES
+# define _STLP_NEED_TYPENAME
+# define _STLP_NEED_EXPLICIT
+# define _STLP_HAS_NO_EXCEPTIONS
+# define _STLP_NO_EXCEPTION_SPEC
+# define _STLP_NO_ARROW_OPERATOR
+# define _STLP_NO_NEW_STYLE_CASTS
+
+# define _STLP_NEED_MUTABLE
+# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX
+# define _STLP_NO_BAD_ALLOC
+# define _STLP_NO_MEMBER_TEMPLATES
+# define _STLP_NO_MEMBER_TEMPLATE_CLASSES
+# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD
+# define _STLP_NO_QUALIFIED_FRIENDS
+# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION
+# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER
+
+# define _STLP_NO_METHOD_SPECIALIZATION
+# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS
+
+// # define _STLP_NO_EXCEPTION_HEADER
+
+# define _STLP_HAS_NO_NEW_C_HEADERS
+
+# define _STLP_STATIC_CONST_INIT_BUG
+# define _STLP_THROW_RETURN_BUG
+# define _STLP_LINK_TIME_INSTANTIATION
+# define _STLP_NO_TEMPLATE_CONVERSIONS
+
+# define _STLP_NON_TYPE_TMPL_PARAM_BUG 1
+# define _STLP_TRIVIAL_DESTRUCTOR_BUG 1
+
+# if defined(_LONG_LONG)
+# define _STLP_LONG_LONG long long
+# endif
+# if defined(_PTHREADS)
+# define _MULTI_THREADED
+# endif
+// fbp : to fix __partition() problem
+# define _STLP_NONTEMPL_BASE_MATCH_BUG 1
diff --git a/sources/android/stlport/stlport/stl/config/_auto_link.h b/sources/android/stlport/stlport/stl/config/_auto_link.h
new file mode 100644
index 0000000..8898c55
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_auto_link.h
@@ -0,0 +1,61 @@
+/* We do not use auto link feature when:
+ * - user asked not to use it (_STLP_DONT_USE_AUTO_LINK)
+ * - STLport is used only as a STL library (_STLP_NO_IOSTREAMS || _STLP_USE_NO_IOSTREAMS)
+ * - we are building a C translation unit, STLport is a C++ Standard library implementation
+ */
+#if !defined (__BUILDING_STLPORT) && !defined (_STLP_DONT_USE_AUTO_LINK) && \
+ !defined (_STLP_NO_IOSTREAMS) && !defined (_STLP_USE_NO_IOSTREAMS) && \
+ defined (__cplusplus)
+
+# define _STLP_STRINGIZE(X) _STLP_STRINGIZE_AUX(X)
+# define _STLP_STRINGIZE_AUX(X) #X
+
+# if defined (_STLP_DEBUG)
+# define _STLP_LIB_OPTIM_MODE "stld"
+# elif defined (_DEBUG)
+# define _STLP_LIB_OPTIM_MODE "d"
+# else
+# define _STLP_LIB_OPTIM_MODE ""
+# endif
+
+# if defined (_STLP_LIB_NAME_MOTIF)
+# define _STLP_LIB_MOTIF "_"_STLP_LIB_NAME_MOTIF
+# else
+# define _STLP_LIB_MOTIF ""
+# endif
+
+# if defined (_STLP_USE_DYNAMIC_LIB)
+# if defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB)
+# define _STLP_LIB_TYPE "_x"
+# else
+# define _STLP_LIB_TYPE ""
+# endif
+# else
+# if defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB)
+# define _STLP_LIB_TYPE "_statix"
+# else
+# define _STLP_LIB_TYPE "_static"
+# endif
+# endif
+
+# if defined (_STLP_USE_DYNAMIC_LIB)
+# define _STLP_VERSION_STR "."_STLP_STRINGIZE(_STLPORT_MAJOR)"."_STLP_STRINGIZE(_STLPORT_MINOR)
+# else
+# define _STLP_VERSION_STR ""
+# endif
+
+# define _STLP_STLPORT_LIB "stlport"_STLP_LIB_OPTIM_MODE""_STLP_LIB_TYPE""_STLP_LIB_MOTIF""_STLP_VERSION_STR".lib"
+
+# if defined (_STLP_VERBOSE)
+# pragma message ("STLport: Auto linking to "_STLP_STLPORT_LIB)
+# endif
+# pragma comment (lib, _STLP_STLPORT_LIB)
+
+# undef _STLP_STLPORT_LIB
+# undef _STLP_LIB_OPTIM_MODE
+# undef _STLP_LIB_TYPE
+# undef _STLP_STRINGIZE_AUX
+# undef _STLP_STRINGIZE
+
+#endif /* _STLP_DONT_USE_AUTO_LINK */
+
diff --git a/sources/android/stlport/stlport/stl/config/_bc.h b/sources/android/stlport/stlport/stl/config/_bc.h
new file mode 100644
index 0000000..e3802dc
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_bc.h
@@ -0,0 +1,138 @@
+/* STLport configuration file
+ * It is internal STLport header - DO NOT include it directly */
+
+#define _STLP_COMPILER "Borland"
+
+#if (__BORLANDC__ < 0x551)
+# error - Borland compilers below version 5.5.1 not supported.
+#endif
+
+#pragma defineonoption _STLP_NO_RTTI -RT-
+
+#define _STLP_DONT_SUP_DFLT_PARAM
+
+#if (__BORLANDC__ >= 0x580)
+# define _STLP_HAS_INCLUDE_NEXT
+# define _STLP_NATIVE_HEADER(header) <../include/##header>
+# define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) <../include/dinkumware/##header>
+# define _STLP_NO_NEW_C_HEADERS
+# define _STLP_NO_FORCE_INSTANTIATE
+#endif
+
+#if (__BORLANDC__ >= 0x570) && (__BORLANDC__ < 0x580)
+# define _STLP_NO_NEW_C_HEADERS
+# define _STLP_NO_FORCE_INSTANTIATE
+# define _STLP_DEF_CONST_DEF_PARAM_BUG
+# define _STLP_USE_DEFAULT_FILE_OFFSET
+
+# if defined (__cplusplus)
+# define _STLP_NATIVE_CPP_C_INCLUDE_PATH ../include/c++/ ## GCC_VERSION
+# define _STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH ../include/c++/ ## GCC_VERSION
+# endif
+
+# undef _SYS_CDEFS_H
+# include </usr/include/sys/cdefs.h>
+
+# ifdef __MT__
+# define _PTHREADS
+# if !defined (_RTLDLL)
+# define _STLP_DONT_USE_PTHREAD_SPINLOCK
+# endif
+# else
+# define _NOTHREADS
+# endif
+
+# pragma defineonoption _CPPUNWIND -xd
+# define _STLP_NO_EXCEPTION_HEADER
+# define _STLP_DONT_USE_EXCEPTIONS
+#endif
+
+#if (__BORLANDC__ >= 0x560) && (__BORLANDC__ < 0x570)
+# define _USE_OLD_RW_STL
+#endif
+
+#if (__BORLANDC__ >= 0x560)
+# if !defined (__BUILDING_STLPORT)
+# define NOWINBASEINTERLOCK
+# endif
+# define _STLP_LANG_INVARIANT_DEFINED
+#endif
+
+#if (__BORLANDC__ < 0x590)
+# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER
+# define _STLP_DLLEXPORT_NEEDS_PREDECLARATION
+ // <bitset> problems
+# define _STLP_MEMBER_SPECIALIZATION_BUG 1
+# ifdef __cplusplus
+# define _STLP_TR1 _STLP_STD_NAME::tr1::
+# endif
+#endif
+
+#if (__BORLANDC__ < 0x564)
+# define _STLP_QUALIFIED_SPECIALIZATION_BUG
+# define _STLP_NO_MOVE_SEMANTIC
+#endif
+
+#define _STLP_DONT_USE_PRIV_NAMESPACE
+#define _STLP_NO_TYPENAME_BEFORE_NAMESPACE
+#define _STLP_NO_VENDOR_STDLIB_L
+#define _STLP_NO_VENDOR_MATH_F
+#define _STLP_DONT_USE_SHORT_STRING_OPTIM 1
+
+#if (__BORLANDC__ < 0x570) || (__BORLANDC__ >= 0x580)
+#define _STLP_NO_NATIVE_MBSTATE_T
+#undef _STLP_NO_UNEXPECTED_EXCEPT_SUPPORT
+#endif
+
+#if (__BORLANDC__ < 0x580) && !defined (_RTLDLL)
+# define _UNCAUGHT_EXCEPTION 1
+#endif
+
+// <limits> problem
+#define _STLP_STATIC_CONST_INIT_BUG
+
+#define _STLP_HAS_SPECIFIC_PROLOG_EPILOG 1
+
+#define _STLP_LONG_LONG __int64
+
+// auto enable thread safety and exceptions:
+#ifndef _CPPUNWIND
+# define _STLP_HAS_NO_EXCEPTIONS
+#endif
+
+#if defined (__MT__) && !defined (_NOTHREADS)
+# define _STLP_THREADS
+#endif
+
+#define _STLP_EXPORT_DECLSPEC __declspec(dllexport)
+#define _STLP_IMPORT_DECLSPEC __declspec(dllimport)
+
+#define _STLP_CLASS_EXPORT_DECLSPEC __declspec(dllexport)
+#define _STLP_CLASS_IMPORT_DECLSPEC __declspec(dllimport)
+
+#if defined (_DLL)
+# define _STLP_DLL
+#endif
+#if defined (_RTLDLL)
+# define _STLP_RUNTIME_DLL
+#endif
+#include <stl/config/_detect_dll_or_lib.h>
+#undef _STLP_RUNTIME_DLL
+#undef _STLP_DLL
+
+#if defined (_STLP_USE_DYNAMIC_LIB)
+# define _STLP_USE_DECLSPEC 1
+# if defined (__BUILDING_STLPORT)
+# define _STLP_CALL __cdecl __export
+# else
+# define _STLP_CALL __cdecl
+# endif
+#else
+# define _STLP_CALL __cdecl
+#endif
+
+#if !defined (__linux__)
+# include <stl/config/_auto_link.h>
+#endif
+
+#include <stl/config/_feedback.h>
diff --git a/sources/android/stlport/stlport/stl/config/_como.h b/sources/android/stlport/stlport/stl/config/_como.h
new file mode 100644
index 0000000..6076f88
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_como.h
@@ -0,0 +1,207 @@
+
+// STLport configuration file
+// It is internal STLport header - DO NOT include it directly
+
+#define _STLP_COMPILER "Comeau"
+
+#include <stl/config/_native_headers.h>
+
+#define _STLP_UINT32_T unsigned int
+
+#define _STLP_HAS_NO_NEW_C_HEADERS
+// #define _STLP_VENDOR_GLOBAL_EXCEPT_STD
+#define _STLP_LONG_LONG long long
+
+
+//
+// ADDITIONS FOR COMEAU C++, made by Comeau Computing.
+// We can be reached through comeau@comeaucomputing.com
+// You shouldn't need to change anything below here for Comeau C++.
+// If you do, please tell us at comeau@comeaucomputing.com
+//
+// Changes made here, AND THROUGH ALL FILES, based upon the __COMO__ macro
+// (and SIMILAR NAMES INVOLVING COMO).... no doubt some of this will
+// change as SGI integrates the changes into their code base since
+// some changes are not really Comeau C++ specific, but required to
+// make the SGI code compliant with Standard C++).
+//
+// Testing was done with Comeau C++ 4.2.44 and 4.2.45.2. Changes were made for
+// both Comeau relaxed mode and Comeau strict mode, especially for end user code
+// (that is, some of the .cxx files cannot compile in strict mode, because they
+// contain extensions to Standard C++, however their object code forms can
+// be used once compiled in relaxed mode, even if the end user code uses
+// strict mode).
+//
+// These changes may also work for some earlier versions of Comeau C++,
+// though we have not tested them.
+//
+// Actual mods made under RedHat 6.1 LINUX, should be ok with SuSE too and
+// other LINUX's, and older Caldera LINUX, Solaris/SPARC, SunOS, SCO UNIX,
+// and NetBSD. Other platforms may be added. Comeau will also perform
+// custom ports for you.
+//
+// Check libcomo details at http://www.comeaucomputing.com/libcomo and
+// http://www.comeaucomputing.com
+//
+// History of Comeau changes (this is rough, as work was often going on in parallel):
+// BETA1 July 14, 2000, Initial port for RedHat 6.1 INTEL/ELF
+// BETA2 Aug 4, 2000, Stronger RedHat support
+// Support for Comeau strict mode for end user code
+// BETA3 Aug 22, 2000, Support for other LINUX/INTEL/ELF's, including older ones
+// BETA4 Sept 2, 2000, Initial support for SCO UNIX + other UNIX x86 SVR3's
+// Stronger support for end user Comeau strict mode
+// BETA5 Oct 5, 2000, Initial support for Solaris/SPARC
+// More SCO support (though still incomplete)
+// BETA6 Feb 5, 2001, Minor mods to accomodate Comeau C++ 4.2.45.1
+// BETA7 Mar 13, 2001, Verified with Comeau C++ 4.2.45.2
+// Minor NetBSD support
+// BETA8 Apr 1. 2001, Initial support for SunOS/SPARC
+// BETA9 Apr 7, 2001, Stronger SCO support + other UNIX x86 SVR3's
+// Mods for an fpos_t problem for some LINUXes
+// Mods since Destroy did not work in strict mode
+// BETA10 Apr 12. 2001, Stronger NetBSD support
+//
+// PLANNED:
+// BETAx TBA TBA, 2001, NetBSD, UNIXWARE, and Windows support expected
+//
+
+
+#ifdef __linux__
+
+# define _STLP_NO_NATIVE_MBSTATE_T 1
+# define _STLP_NO_NATIVE_WIDE_FUNCTIONS 1
+# define _STLP_NO_NATIVE_WIDE_STREAMS 1
+# define _STLP_NO_LONG_DOUBLE 1
+
+// Comeau C++ under LINUX/INTEL/ELF
+// Preprocess away "long long" routines for now, even in relaxed mode
+# define __wcstoull_internal_defined 1
+# define __wcstoll_internal_defined 1
+
+#endif /* __COMO__ under __linux__ */
+
+#ifdef __USING_x86SVR3x_WITH_COMO /* SCO et al */
+/* UNIX 386+ SVR3 mods made with __USING_x86SVR3x_WITH_COMO
+ in other sources, not here */
+# define atan2l atan2
+# define cosl cos
+# define sinl sin
+# define sqrtl sqrt
+# include <math.h>
+ inline long double expl(long double arg) { return exp(arg); }
+ inline long double logl(long double arg) { return log(arg); }
+# define log10l log10
+
+# define sinhl sinh
+# define coshl cosh
+# define fabsl fabs
+namespace std {
+ inline int min(int a, int b) { return a>b ? b : a; }
+}
+#endif
+
+#ifdef sun
+// Comeau C++ under Solaris/SPARC or SunOS
+
+#ifdef solarissparc
+#define __USING_SOLARIS_SPARC_WITH_COMO /* show this in the source when grep'ing for COMO */
+// Note comowchar.h for Solaris/SPARC wchar stuff
+
+#include <math.h>
+# define sinf sin
+# define sinl sin
+# define sinhf sinh
+# define sinhl sinh
+# define cosf cos
+# define cosl cos
+# define coshf cosh
+# define coshl cosh
+# define atan2l atan2
+# define atan2f atan2
+ inline float logf(float arg) { return log(arg); }
+ inline long double logl(long double arg) { return log(arg); }
+# define log10f log10
+# define log10l log10
+# define expf exp
+ inline long double expl(long double arg) { return exp(arg); }
+# define sqrtf sqrt
+# define sqrtl sqrt
+# define fabsf fabs
+# define fabsl fabs
+#else
+#define __USING_SUNOS_WITH_COMO
+
+#define __unix 1
+#define __EXTENSIONS__ /* This might create undue noise somewhere */
+#endif
+#endif /* sun */
+
+#if defined(__NetBSD__)
+// From non-como #ifdef __GNUC__ above
+#undef _STLP_NO_FUNCTION_PTR_IN_CLASS_TEMPLATE
+#define __unix 1
+
+#include <sys/cdefs.h>
+// Some joker #define'd __END_DECLS as };
+#undef __END_DECLS
+#define __END_DECLS }
+
+// <sys/stat.h> prob
+#include <sys/cdefs.h>
+#undef __RENAME
+#define __RENAME(x)
+
+#define wchar_t __COMO_WCHAR_T
+#include <stddef.h>
+#undef wchar_t
+
+#include <math.h>
+# ifdef BORIS_DISABLED
+# define atan2l atan2
+# define cosl cos
+# define sinl sin
+# define sqrtl sqrt
+ inline long double expl(long double arg) { return exp(arg); }
+ inline long double logl(long double arg) { return log(arg); }
+# define log10l log10
+# define sinhl sinh
+# define coshl cosh
+# define fabsl fabs
+# endif
+#endif /* __NetBSD__ under __COMO__ */
+
+// Shouldn't need to change anything below here for Comeau C++
+// If so, tell us at comeau@comeaucomputing.com
+
+#define _STLP_NO_DRAND48
+
+#define _STLP_PARTIAL_SPECIALIZATION_SYNTAX
+#define _STLP_NO_USING_CLAUSE_IN_CLASS
+
+#if __COMO_VERSION__ < 4300
+#if __COMO_VERSION__ >= 4245
+#define _STLP_NO_EXCEPTION_HEADER /**/
+ // Is this needed?
+# include <stdexcept.stdh>
+#endif
+#define _STLP_NO_BAD_ALLOC /**/
+#define _STLP_USE_AUTO_PTR_CONVERSIONS /**/
+#endif
+
+// this one is true only with MS
+# if defined (_MSC_VER)
+# define _STLP_WCHAR_T_IS_USHORT 1
+# if _MSC_VER <= 1200
+# define _STLP_VENDOR_GLOBAL_CSTD
+# endif
+# if _MSC_VER < 1100
+# define _STLP_NO_BAD_ALLOC 1
+# define _STLP_NO_EXCEPTION_HEADER 1
+# define _STLP_NO_NEW_NEW_HEADER 1
+# define _STLP_USE_NO_IOSTREAMS 1
+# endif
+# endif
+
+// # define __EDG_SWITCHES
+
+
diff --git a/sources/android/stlport/stlport/stl/config/_cray.h b/sources/android/stlport/stlport/stl/config/_cray.h
new file mode 100644
index 0000000..55327c1
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_cray.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#define _STLP_COMPILER "CC"
+
+// Mostly correct guess, change it for Alpha (and other environments
+// that has 64-bit "long")
+# define _STLP_UINT32_T unsigned long
+
+// Uncomment if long long is available
+# define _STLP_LONG_LONG long long
+
+// Uncomment this if your compiler can't inline while(), for()
+# define _STLP_LOOP_INLINE_PROBLEMS 1
+
+// Uncomment this if your compiler does not support exceptions
+// Cray C++ supports exceptions when '-h exceptions' option is user;
+// therefore '-D_STLP_HAS_NO_EXCEPTIONS' must be used when '-h exceptions'
+// is NOT used.
+//# define _STLP_HAS_NO_EXCEPTIONS 1
+
+// Delete?
+// Define this if compiler lacks <exception> header
+//# define _STLP_NO_EXCEPTION_HEADER 1
+
+// Uncomment this if your C library has lrand48() function
+# define _STLP_RAND48 1
+
+// Uncomment if native new-style C library headers lile <cstddef>, etc are not available.
+# define _STLP_HAS_NO_NEW_C_HEADERS 1
+
+// uncomment if new-style headers <new> is available
+# define _STLP_NO_NEW_NEW_HEADER 1
+
+// uncomment this if <iostream> and other STD headers put their stuff in ::namespace,
+// not std::
+# define _STLP_VENDOR_GLOBAL_STD
+
+// uncomment this if <cstdio> and the like put stuff in ::namespace,
+// not std::
+# define _STLP_VENDOR_GLOBAL_CSTD
+
+# define _STLP_NATIVE_C_HEADER(__x) </usr/include/##__x>
+// WARNING: Following is hardcoded to the system default C++ include files
+# define _STLP_NATIVE_CPP_RUNTIME_HEADER(__x) </opt/ctl/CC/CC/include/##__x>
+
+
+# define _STLP_NO_NATIVE_MBSTATE_T
+# define _STLP_NO_USING_FOR_GLOBAL_FUNCTIONS
+//# define _STLP_VENDOR_GLOBAL_EXCEPT_STD
diff --git a/sources/android/stlport/stlport/stl/config/_cygwin.h b/sources/android/stlport/stlport/stl/config/_cygwin.h
new file mode 100644
index 0000000..8610743
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_cygwin.h
@@ -0,0 +1,9 @@
+#define _STLP_PLATFORM "Cygwin"
+
+#define _STLP_UNIX
+
+#ifndef _STLP_USE_STDIO_IO
+# define _STLP_USE_UNIX_IO
+#endif
+
+#define _STLP_LDOUBLE_96
diff --git a/sources/android/stlport/stlport/stl/config/_dec.h b/sources/android/stlport/stlport/stl/config/_dec.h
new file mode 100644
index 0000000..fc8ace7
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_dec.h
@@ -0,0 +1,113 @@
+#define _STLP_COMPILER "Dec"
+
+# define _STLP_HAS_SPECIFIC_PROLOG_EPILOG
+
+# define _STLP_NATIVE_HEADER(header) <../cxx/##header>
+# define _STLP_NATIVE_C_HEADER(x) <../include/##x>
+
+#if (__DECCXX_VER < 60300000)
+# define _STLP_NATIVE_CPP_C_HEADER(header) <../cxx/##header>
+#else
+# define _STLP_NATIVE_CPP_C_HEADER(header) </usr/include/cxx_cname/##header>
+#endif
+
+# define _STLP_NATIVE_OLD_STREAMS_HEADER(header) <../cxx/##header>
+# define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) <../cxx/##header>
+
+/* Alpha is little-endian */
+# define _STLP_LITTLE_ENDIAN
+
+// collisions
+# define _STLP_DONT_PUT_STLPORT_IN_STD
+
+#if (__DECCXX_VER < 60000000)
+
+/*
+ automatic template instantiation does not
+ work with namespaces ;(
+*/
+# define _STLP_HAS_NO_NAMESPACES 1
+
+# define _STLP_NO_NEW_NEW_HEADER 1
+
+# define _STLP_NO_WCHAR_T 1
+# define _STLP_NEED_EXPLICIT 1
+
+# define _STLP_NO_BOOL 1
+# define _STLP_NEED_TYPENAME 1
+# define _STLP_NO_NEW_STYLE_CASTS 1
+# define _STLP_NEED_MUTABLE 1
+# define _STLP_NO_BAD_ALLOC 1
+
+
+# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX 1
+
+# define _STLP_NO_MEMBER_TEMPLATES 1
+# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1
+# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1
+# define _STLP_NO_QUALIFIED_FRIENDS 1
+# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1
+# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1
+# define _STLP_NON_TYPE_TMPL_PARAM_BUG 1
+# define _STLP_BROKEN_USING_DIRECTIVE 1
+# define _STLP_NO_EXCEPTION_HEADER 1
+# define _STLP_DEF_CONST_PLCT_NEW_BUG 1
+# define _STLP_DEF_CONST_DEF_PARAM_BUG 1
+
+#endif
+
+
+#ifndef __NO_USE_STD_IOSTREAM
+/* default is to use new iostreams, anyway */
+# ifndef __USE_STD_IOSTREAM
+# define __USE_STD_IOSTREAM
+# endif
+#endif
+
+/*
+# ifndef __STD_STRICT_ANSI_ERRORS
+# endif
+*/
+
+#ifndef __EXCEPTIONS
+# define _STLP_HAS_NO_EXCEPTIONS 1
+#endif
+
+# ifdef __IMPLICIT_INCLUDE_ENABLED
+
+/* but, works with ours ;). */
+# define _STLP_LINK_TIME_INSTANTIATION 1
+# else
+# undef _STLP_LINK_TIME_INSTANTIATION
+# endif
+
+# if defined (__IMPLICIT_USING_STD) && !defined (__NO_USE_STD_IOSTREAM)
+/*
+ we should ban that !
+ # error "STLport won't work with new iostreams and std:: being implicitly included. Please use -std strict_ansi[_errors] or specify __NO_USE_STD_IOSTREAM"
+*/
+# endif
+
+# if (defined (__STD_STRICT_ANSI) || defined (__STD_STRICT_ANSI_ERRORS))
+# define _STLP_STRICT_ANSI 1
+# else
+/* we want to enforce it */
+# define _STLP_LONG_LONG long long
+# endif
+
+/* unsigned 32-bit integer type */
+# define _STLP_UINT32_T unsigned int
+#if defined(_XOPEN_SOURCE) && (_XOPEN_VERSION - 0 >= 4)
+# define _STLP_RAND48 1
+#endif
+/* # define _STLP_RAND48 1 */
+
+# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1
+
+# if (__DECCXX_VER <= 60600000)
+# define _STLP_HAS_NO_NEW_C_HEADERS 1
+# endif
+
+#if !defined (_NOTHREADS) && !defined (_STLP_THREADS_DEFINED)
+# define _STLP_DEC_THREADS
+#endif
diff --git a/sources/android/stlport/stlport/stl/config/_dec_vms.h b/sources/android/stlport/stlport/stl/config/_dec_vms.h
new file mode 100644
index 0000000..44a0fb8
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_dec_vms.h
@@ -0,0 +1,89 @@
+// OpenVMS version
+
+#define _STLP_COMPILER "Dec Vms"
+
+# define _STLP_NATIVE_HEADER(header) <sys$library:##header>
+# define _STLP_NATIVE_C_HEADER(x) <sys$library:##x>
+# define _STLP_NATIVE_CPP_C_HEADER(header) <sys$library:##header>
+# define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) <sys$library:##header>
+
+#if (__DECCXX_VER < 60000000)
+
+// automatic template instantiation does not
+// work with namespaces ;(
+# define _STLP_HAS_NO_NAMESPACES 1
+
+# define _STLP_NO_WCHAR_T 1
+# define _STLP_NEED_EXPLICIT 1
+
+# define _STLP_NO_BOOL 1
+# define _STLP_NEED_TYPENAME 1
+# define _STLP_NO_NEW_STYLE_CASTS 1
+# define _STLP_NEED_MUTABLE 1
+# define _STLP_NO_BAD_ALLOC 1
+
+# define _STLP_NO_NEW_NEW_HEADER 1
+# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX 1
+
+# define _STLP_NO_MEMBER_TEMPLATES 1
+# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1
+# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1
+# define _STLP_NO_QUALIFIED_FRIENDS 1
+# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1
+# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1
+# define _STLP_NON_TYPE_TMPL_PARAM_BUG 1
+# define _STLP_BROKEN_USING_DIRECTIVE 1
+# define _STLP_NO_EXCEPTION_HEADER 1
+# define _STLP_DEF_CONST_PLCT_NEW_BUG 1
+# define _STLP_DEF_CONST_DEF_PARAM_BUG 1
+
+#endif
+
+
+#ifdef __NO_USE_STD_IOSTREAM
+# define _STLP_USE_NO_IOSTREAMS 1
+# else
+// default is to use new iostreams, anyway
+# ifndef __USE_STD_IOSTREAM
+# define __USE_STD_IOSTREAM
+# endif
+#endif
+
+#ifndef __EXCEPTIONS
+# define _STLP_HAS_NO_EXCEPTIONS 1
+#endif
+
+# ifdef __IMPLICIT_INCLUDE_ENABLED
+
+#ifdef _STLP_USE_NO_IOSTREAMS
+// implicit include introduces conflicts
+// between stlport and native lib.
+# undef __IMPLICIT_INCLUDE_ENABLED
+#endif
+
+// but, works with ours ;).
+# define _STLP_LINK_TIME_INSTANTIATION 1
+
+# endif
+
+# if defined (__IMPLICIT_USING_STD) && !defined (__NO_USE_STD_IOSTREAM)
+// we should ban that !
+# error "STLport won't work with new iostreams and std:: being implicitly included. Please use -std strict_ansi[_errors] or specify __NO_USE_STD_IOSTREAM"
+# endif
+
+# if !(defined (__STD_STRICT_ANSI) || defined (__STD_STRICT_ANSI_ERRORS))
+// we want to enforce it
+# define _STLP_LONG_LONG long long
+# endif
+
+// unsigned 32-bit integer type
+# define _STLP_UINT32_T unsigned int
+#if defined(_XOPEN_SOURCE) && (_XOPEN_VERSION - 0 >= 4)
+# define _STLP_RAND48 1
+#endif
+// # define _STLP_RAND48 1
+
+# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1
+
+#define _STLP_HAS_NO_NEW_C_HEADERS 1
+
diff --git a/sources/android/stlport/stlport/stl/config/_detect_dll_or_lib.h b/sources/android/stlport/stlport/stl/config/_detect_dll_or_lib.h
new file mode 100644
index 0000000..a062e69
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_detect_dll_or_lib.h
@@ -0,0 +1,74 @@
+/* File used to define macros:
+ * _STLP_USE_DYNAMIC_LIB: To signal use STLport as a dll or build of the
+ * STLport dlls.
+ * _STLP_USE_STATIC_LIB: To signal use of STLport as a static lib or build of
+ * the STLport static libs.
+ * _STLP_USING_CROSS_NATIVE_RUNTIME_LIB: Signal that we are using a native runtime
+ * in a version different from the STLport one.
+ * If _STLP_USE_DYNAMIC_LIB or _STLP_USE_STATIC_LIB is alreday defined it means that
+ * user forces use of a specific version. In this case _STLP_USING_CROSS_NATIVE_RUNTIME_LIB
+ * will surely be defined otherwise there is no need to force macro defines.
+ *
+ * Before including this file the compiler must define:
+ * _STLP_DLL: If we are building a dll
+ * _STLP_RUNTIME_DLL: If we are using native runtime as a dll
+ */
+#if defined (__BUILDING_STLPORT)
+# undef _STLP_USE_DYNAMIC_LIB
+# undef _STLP_USE_STATIC_LIB
+# if defined (_STLP_DLL)
+/* We are building the STLport dll */
+# define _STLP_USE_DYNAMIC_LIB
+# if !defined (_STLP_RUNTIME_DLL)
+# define _STLP_USING_CROSS_NATIVE_RUNTIME_LIB
+# endif
+# else
+# define _STLP_USE_STATIC_LIB
+# if defined (_STLP_RUNTIME_DLL)
+# define _STLP_USING_CROSS_NATIVE_RUNTIME_LIB
+# endif
+# endif
+#else
+# if !defined (_STLP_NO_IOSTREAMS)
+/* STLport use only depend on _STLP_RUNTIME_DLL as we are replacing
+ * the native runtime.
+ */
+# if defined (_STLP_RUNTIME_DLL)
+# if !defined (_STLP_USE_STATIC_LIB)
+# if !defined (_STLP_USE_DYNAMIC_LIB)
+# define _STLP_USE_DYNAMIC_LIB
+# endif
+# else
+/* The user is forcing use of STLport as a dynamic library. We signal it so
+ * that the STLport namespace will be modify to report such a combination
+ * and force the user to link with the rebuilt STLport library.
+ */
+# define _STLP_USING_CROSS_NATIVE_RUNTIME_LIB
+# endif
+# else
+# if !defined(_STLP_USE_DYNAMIC_LIB)
+# if !defined (_STLP_USE_STATIC_LIB)
+# define _STLP_USE_STATIC_LIB
+# endif
+# else
+/* Idem previous remark but the user forces use of the static native runtime.
+ */
+# define _STLP_USING_CROSS_NATIVE_RUNTIME_LIB
+# endif
+# endif
+# else
+/* If we do not build and use STLport libs we consider that we are in a static lib
+ * mode as only dynamic lib needs additional export/import specifier.
+ */
+# define _STLP_USE_STATIC_LIB
+# endif
+#endif
+
+/* we don't have a static native runtime library on evc3/evc4 */
+#ifdef _STLP_WCE
+# undef _STLP_USING_CROSS_NATIVE_RUNTIME_LIB
+#endif
+
+#if !defined (_STLP_USE_DYNAMIC_LIB) && !defined (_STLP_USE_STATIC_LIB)
+# error Unknown STLport usage config (dll/lib?)
+#endif
diff --git a/sources/android/stlport/stlport/stl/config/_dm.h b/sources/android/stlport/stlport/stl/config/_dm.h
new file mode 100644
index 0000000..4f70732
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_dm.h
@@ -0,0 +1,121 @@
+// STLport configuration file for Digital Mars C++
+
+#define _STLP_COMPILER __DMC_VERSION_STRING__
+
+#if (__DMC__ < 0x849)
+# error "Digital Mars C++ compilers before version 8.49 are not supported!"
+#endif
+
+/* DMC goes too far in template instanciation and tries to fully instanciate
+ * slist<pair<const int, string> > for instance. The generation of assignment
+ * operator fails of course so we are force to use mutable key for this compiler.
+ */
+#define _STLP_NO_CONST_IN_PAIR
+#define _STLP_DONT_SUP_DFLT_PARAM
+
+#ifndef _CPPUNWIND
+# define _STLP_NO_EXCEPTIONS
+#endif
+
+#ifndef _CPPRTTI
+# define _STLP_NO_RTTI
+#endif
+
+#define _STLP_VENDOR_GLOBAL_CSTD
+
+//DMC prefer enum to real static const variable because it do not consider
+//static const as const enough to be used in switch declaration...
+#define _STLP_STATIC_CONST_INIT_BUG
+
+#if !defined (_WIN32)
+// it's not fully supported on non-Win32 platforms
+# define _STLP_NO_NATIVE_WIDE_FUNCTIONS
+#endif
+
+/* _STLP_NO_OWN_NAMESPACE is defined because Digital Mars' linker and libarian
+ appear to have problems with STLport namespaces. Summary of the issues:
+
+ STATIC: Digital Mars' librarian (lib.exe) may fail with "len <= IDMAX" error
+ if _STLP_DEBUG is defined. This is because Digital Mars' librarian uses
+ Microsoft OMF format, which limits identifier length to about 512 bytes.
+ With STLport namespaces, some identifiers such as Category_Map in
+ src/locale_catalog.cpp may exceed the maximum OMF identifier length.
+
+ DYNAMIC: Export issues with cin, cout, cerr, clog in src/iostream.cpp.
+ Exports in Digital Mars 'def' file must match mangled names in iostream.cpp.
+ With STLport namespaces, the mangled names in the intermediate files no
+ longer match these pre-defined exports. To use STLport dynamic libraries
+ and STLport namespaces with Digital Mars, the pre-defined exports in
+ src/iostream.cpp and the related Digital Mars 'def' files would need to be
+ revised. */
+#define _STLP_NO_OWN_NAMESPACE 1
+
+// select threads strategy
+#if defined (_MT) && !defined (_STLP_NO_THREADS)
+# define _STLP_THREADS
+#endif
+
+#ifndef _BOOL_DEFINED
+# define _STLP_NO_BOOL
+#else
+# define _STLP_DONT_USE_BOOL_TYPEDEF
+#endif
+
+#if _INTEGRAL_MAX_BITS >= 64
+# define _STLP_LONG_LONG long long
+#endif
+
+#define _STLP_MARK_PARAMETER_AS_UNUSED(X)
+#define _STLP_DONT_USE_PRIV_NAMESPACE
+#define _STLP_PRIV
+#define _STLP_THROW_RETURN_BUG
+
+#if !defined (_DLL)
+# undef _STLP_NO_UNEXPECTED_EXCEPT_SUPPORT
+#endif
+
+#if (__DMC__ < 0x849)
+# define _STLP_NO_BAD_ALLOC
+#endif
+
+#define _STLP_USE_ABBREVS
+#define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER
+
+#define _STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND
+#define _STLP_EXPORT_DECLSPEC __declspec(dllexport)
+#define _STLP_IMPORT_DECLSPEC __declspec(dllimport)
+
+#define _STLP_CLASS_EXPORT_DECLSPEC __declspec(dllexport)
+#define _STLP_CLASS_IMPORT_DECLSPEC __declspec(dllimport)
+
+#define _STLP_NEED_ADDITIONAL_STATIC_DECLSPEC
+
+//#define _STLP_IMPORT_TEMPLATE_KEYWORD __declspec(dllimport)
+//#define _STLP_EXPORT_TEMPLATE_KEYWORD __declspec(dllexport)
+
+#if defined (_WINDLL)
+# define _STLP_DLL
+#endif
+#if defined (_DLL)
+# define _STLP_RUNTIME_DLL
+#endif
+#include <stl/config/_detect_dll_or_lib.h>
+#undef _STLP_RUNTIME_DLL
+#undef _STLP_DLL
+
+#if defined (_STLP_USE_DYNAMIC_LIB)
+# define _STLP_USE_DECLSPEC 1
+# if defined (__BUILDING_STLPORT)
+# define _STLP_CALL __export
+# else
+# define _STLP_CALL
+# endif
+#else
+# define _STLP_CALL
+#endif
+
+#include <stl/config/_auto_link.h>
+
+#undef __SC__
+
+#include <stl/config/_feedback.h>
diff --git a/sources/android/stlport/stlport/stl/config/_epilog.h b/sources/android/stlport/stlport/stl/config/_epilog.h
new file mode 100644
index 0000000..30d1e24
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_epilog.h
@@ -0,0 +1,29 @@
+#if defined (_STLP_MSVC) || defined (__ICL)
+
+# pragma warning (pop)
+# pragma pack (pop)
+
+#elif defined (__BORLANDC__)
+
+# pragma option pop
+# pragma option -w-pow // -w-8062 Previous options and warnings not restored
+
+#elif defined (__sgi) && !defined (__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+
+# pragma reset woff 1174
+# pragma reset woff 1375
+# pragma reset woff 1209
+/* from iterator_base.h */
+# pragma reset woff 1183
+
+#elif defined (__DECCXX)
+
+# ifdef __PRAGMA_ENVIRONMENT
+# pragma __environment __restore
+# endif
+
+#elif defined (__IBMCPP__)
+
+# pragma info(restore)
+
+#endif
diff --git a/sources/android/stlport/stlport/stl/config/_evc.h b/sources/android/stlport/stlport/stl/config/_evc.h
new file mode 100644
index 0000000..c460450
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_evc.h
@@ -0,0 +1,333 @@
+/*
+ * File to have Microsoft eMbedded Visual C++ 3.0 and .NET working with STLport
+ * May 2004
+ * Origin : Zdenek Nemec - zero@mapfactor.com
+ * Michael Fink - vividos@users.sourceforge.net
+ */
+
+#ifndef _STLP_EVC_H
+#define _STLP_EVC_H
+
+#define _STLP_COMPILER "eMbedded Visual C++"
+
+// This flag is being used by STLport to support
+// old-fashioned Windows CE SDK (see stl_wince.h)
+// do not use with eMebedded Visual C++ 3 or 4!
+#ifdef _STLP_WINCE
+# undef _STLP_WINCE
+#endif
+
+/* Compiler dependent define. The following defines may be available:
+ * _STLP_WCE_EVC3 when compiling under eMbedded Visual C++ 3
+ * _STLP_WCE_NET when compiling under eMbedded Visual C++ .NET
+ * _STLP_WCE always defined when compiling with one of the above
+ */
+#undef _STLP_WCE_EVC3
+#undef _STLP_WCE_NET
+
+#if (_WIN32_WCE > 300)
+# define _STLP_WCE_NET UNDER_CE
+#elif (_WIN32_WCE == 300)
+# define _STLP_WCE_EVC3 UNDER_CE
+#else
+# error No support for Windows CE below 3.0!
+#endif
+
+// This is defined for all platforms using Windows CE
+#define _STLP_WCE
+
+/* All Windows CE versions up to at least version 5 are little-endian, even
+ * if the hardware (like e.g. MIPS) can be configured for big-endian, too. */
+#define _STLP_LITTLE_ENDIAN
+
+// Ensure _DEBUG is defined.
+#if defined (DEBUG) && !defined (_DEBUG)
+# define _DEBUG
+#endif
+
+// inherit all msvc6 options
+#include <stl/config/_msvc.h>
+
+// CE up to at least version 5 has no C locale support
+#define _STLP_NO_LOCALE_SUPPORT
+
+#if _WIN32_WCE >= 420
+ // SDKs built with PB5 have terminate&co in namespace std...
+# define _STLP_VENDOR_TERMINATE_STD _STLP_VENDOR_STD
+# define _STLP_VENDOR_UNCAUGHT_EXCEPTION_STD _STLP_VENDOR_STD
+ // ...and new_handler/set_new_handler in the global namespace.
+# define _STLP_GLOBAL_NEW_HANDLER 1
+#endif
+
+// Always threaded in eMbedded Visual C++ 3.0 and .NET
+#ifndef _MT
+# define _MT
+#endif
+
+// we don't have a static native runtime library
+#undef _STLP_USING_CROSS_NATIVE_RUNTIME_LIB
+
+#if _WIN32_WCE < 400
+// no long double under CE3 and older
+# define _STLP_NO_LONG_DOUBLE
+#endif
+
+// no *f and *l math functions available
+#define _STLP_NO_VENDOR_MATH_F
+#define _STLP_NO_VENDOR_MATH_L
+
+/*
+ * Redirect cout, cerr and clog:
+ * If defined redirect cout, cerr and clog to
+ * files stdout.txt, stderr.txt and stdlog.txt
+ */
+//# define _STLP_REDIRECT_STDSTREAMS
+
+/*
+ * Static class members may generate LNK1179:
+ * Wrong COMDAT packing may cause LNK1179 error.
+ * For details see http://groups.google.com/groups?th=8a05c82c4ffee280
+ * example P78. This define is not used/needed at this moment
+ * but may came handy in future...
+ */
+//# define _STLP_STATIC_MEMBERS_BUG
+
+// Use wide-string interface of windows native functions (CreateFile...).
+// Note that this should be defined all the time while under CE.
+#if defined (UNICODE)
+# define _STLP_USE_WIDE_INTERFACE
+#endif
+
+// Force exception std to std instead of __std_alias.
+#if defined (__cplusplus) && !defined (_STLP_HAS_NO_NAMESPACES)
+# ifdef _STLP_VENDOR_EXCEPT_STD
+# undef _STLP_VENDOR_EXCEPT_STD
+# endif
+# define _STLP_VENDOR_EXCEPT_STD std
+#endif
+
+// short string optimization bug under evc3, evc4 using ARM compiler
+#if _MSC_VER < 1400 && (defined (ARM) || defined (_ARM_))
+# define _STLP_DONT_USE_SHORT_STRING_OPTIM
+#endif
+
+// when using MFC, disable another placement new declaration, since there is one in wcealt.h
+#if !defined (__BUILDING_STLPORT) && defined (_MFC_VER)
+# define __PLACEMENT_NEW_INLINE
+#endif
+
+// threads
+#undef _REENTRANT
+#define _REENTRANT
+#undef _NOTHREADS
+
+// Use old fashioned headers (ctime vs. time.h).
+#undef _STLP_NO_NEW_C_HEADERS
+#define _STLP_NO_NEW_C_HEADERS
+
+// exception handling support: only on evc4 and user added /GX to project settings
+#if defined (_STLP_WCE_EVC3) || !defined (_CPPUNWIND)
+# define _STLP_NO_EXCEPTION_HEADER
+# define _STLP_NO_EXCEPTIONS
+# undef _STLP_USE_EXCEPTIONS
+# ifndef _STLP_THROW_BAD_ALLOC
+# define _STLP_THROW_BAD_ALLOC { _STLP_WINCE_TRACE(L"out of memory"); ExitThread(1); }
+# endif
+#endif
+
+#define _STLP_WINCE_TRACE(msg) OutputDebugString(msg)
+
+/*
+ * eMbedded Visual C++ .NET specific settings
+ */
+#if defined (_STLP_WCE_NET)
+
+// evc4 has no locale and time support
+# define _STLP_NO_LOCALE_SUPPORT
+# define _STLP_NO_TIME_SUPPORT
+
+// ptrdiff_t is not defined in evc4 headers
+# ifndef _PTRDIFF_T_DEFINED
+ typedef int ptrdiff_t;
+# define _PTRDIFF_T_DEFINED
+# endif
+
+/*
+ * Helper macros for including the native headers in cases where a file with
+ * the same name also exists in the STLport include folder. The idea behind
+ * this is that we first go up one directory and then down into a dir that
+ * is only present in the native install but not in STLport.
+ *
+ */
+# if !defined (_STLP_NATIVE_INCLUDE_PATH)
+# if defined (_X86_)
+# if defined (_STLP_WCE_TARGET_PROC_SUBTYPE_EMULATOR)
+# define _STLP_NATIVE_INCLUDE_PATH ../Emulator
+# else
+# define _STLP_NATIVE_INCLUDE_PATH ../X86
+# endif
+# elif defined (_ARM_)
+# if _MSC_VER < 1400
+ // eVC3/4
+# if defined (ARMV4)
+# define _STLP_NATIVE_INCLUDE_PATH ../Armv4
+# elif defined (ARMV4I)
+# define _STLP_NATIVE_INCLUDE_PATH ../Armv4i
+# elif defined (ARMV4T)
+# define _STLP_NATIVE_INCLUDE_PATH ../Armv4t
+# else
+# error Unknown ARM SDK.
+# endif
+# else
+ // VC8 crosscompiling for CE
+# if defined (ARMV4)
+ // VC8 bundled Pocket PC 2003 SDK don't have a target CPU subfolder.
+# if defined(WIN32_PLATFORM_PSPC)
+# define _STLP_NATIVE_INCLUDE_PATH ../Include
+# else
+# define _STLP_NATIVE_INCLUDE_PATH ../Armv4
+# endif
+# elif defined(ARMV4I) || defined(ARMV4T)
+# define _STLP_NATIVE_INCLUDE_PATH ../Armv4i
+# else
+# error Unknown ARM SDK.
+# endif
+# endif
+# elif defined (_MIPS_)
+# if defined (MIPS16)
+# define _STLP_NATIVE_INCLUDE_PATH ../mips16
+# elif defined (MIPSII)
+# define _STLP_NATIVE_INCLUDE_PATH ../mipsII
+# elif defined (MIPSII_FP)
+# define _STLP_NATIVE_INCLUDE_PATH ../mipsII_fp
+# elif defined (MIPSIV)
+# define _STLP_NATIVE_INCLUDE_PATH ../mipsIV
+# elif defined (MIPSIV_FP)
+# define _STLP_NATIVE_INCLUDE_PATH ../mipsIV_fp
+# else
+# error Unknown MIPS SDK.
+# endif
+# elif defined (SHx)
+# if defined (SH3)
+# define _STLP_NATIVE_INCLUDE_PATH ../sh3
+# elif defined (SH4)
+# define _STLP_NATIVE_INCLUDE_PATH ../sh4
+# else
+# error Unknown SHx SDK.
+# endif
+# else
+# error Unknown SDK.
+# endif
+# endif /* !_STLP_NATIVE_INCLUDE_PATH */
+
+/* Workaround when using MFCCE and using <new> together: MFCCE's wcealt.h doesn't
+ * check for __PLACEMENT_NEW_INLINE before defining operator new, so when <new>
+ * defines the operatore before, there will be an error C2084:
+ * "function 'void *__cdecl operator new(unsigned int,void *)' already has a body".
+ */
+# ifdef _STLP_USE_MFC
+# define __PLACEMENT_NEW_INLINE
+# endif
+
+#endif /* _STLP_WCE_NET */
+
+/*
+ * eMbedded Visual C++ 3.0 specific settings
+ */
+#if defined (_STLP_WCE_EVC3)
+
+# define _STLP_NO_NATIVE_MBSTATE_T
+
+// evc3 has no locale and time support
+# define _STLP_NO_LOCALE_SUPPORT
+# define _STLP_NO_TIME_SUPPORT
+
+// evc3 has new, but no explicit header
+# define _STLP_NO_NEW_HEADER
+# define _STLP_NO_NEW_NEW_HEADER
+
+// evc3 has no bad_alloc and no typeinfo
+# undef _STLP_NO_BAD_ALLOC
+# define _STLP_NO_BAD_ALLOC
+
+# undef _STLP_NO_TYPEINFO
+# define _STLP_NO_TYPEINFO
+
+// missing things in eMbedded Visual C++ 3.0 headers
+# ifndef _SIZE_T_DEFINED
+ typedef unsigned int size_t;
+# define _SIZE_T_DEFINED
+# endif
+
+# ifndef _WCHAR_T_DEFINED
+ typedef unsigned short wchar_t;
+# define _WCHAR_T_DEFINED
+# endif
+
+// ptrdiff_t is not defined in evc3 headers
+# ifndef _PTRDIFF_T_DEFINED
+ typedef int ptrdiff_t;
+# define _PTRDIFF_T_DEFINED
+# endif
+
+// clock_t is not defined in evc3 headers
+# ifndef _CLOCK_T_DEFINED
+ typedef long clock_t;
+# define _CLOCK_T_DEFINED
+# endif
+
+// Struct tm is not defined in evc3 headers
+# ifndef _TM_DEFINED
+struct tm {
+ int tm_sec; /* seconds after the minute - [0,59] */
+ int tm_min; /* minutes after the hour - [0,59] */
+ int tm_hour; /* hours since midnight - [0,23] */
+ int tm_mday; /* day of the month - [1,31] */
+ int tm_mon; /* months since January - [0,11] */
+ int tm_year; /* years since 1900 */
+ int tm_wday; /* days since Sunday - [0,6] */
+ int tm_yday; /* days since January 1 - [0,365] */
+ int tm_isdst; /* daylight savings time flag */
+};
+# define _TM_DEFINED
+# endif
+
+// define placement new and delete operator
+// note: when MFCCE headers are included first, don't define the new operator,
+// since it was already defined in wcealt.h
+# ifdef __cplusplus
+# ifndef __PLACEMENT_NEW_INLINE
+# ifndef _MFC_VER
+inline void *__cdecl operator new(size_t, void *_P) { return (_P); }
+# endif /* _MFC_VER */
+inline void __cdecl operator delete(void *, void *) { return; }
+# define __PLACEMENT_NEW_INLINE
+# endif
+# endif /* __cplusplus */
+
+// evc3 doesn't have native wide functions, e.g. fgetwc, wmemmove
+# define _STLP_NO_NATIVE_WIDE_FUNCTIONS
+
+// evc3 doesn't have assert.h
+# ifndef _ASSERT_DEFINED
+# define assert(expr) _STLP_ASSERT(expr)
+# define _ASSERT_DEFINED
+# endif
+
+#endif /* _STLP_WCE_EVC3 */
+
+/*
+ * original call: TerminateProcess(GetCurrentProcess(), 0);
+ * we substitute the GetCurrentProcess() with the result of the inline function
+ * defined in kfuncs.h, since we then can avoid including <windows.h> at all.
+ * all needed Win32 API functions are defined in <stl/_windows.h>
+ */
+#ifndef _ABORT_DEFINED
+# define _STLP_ABORT() TerminateProcess(reinterpret_cast<HANDLE>(66), 0)
+# define _ABORT_DEFINED
+#endif
+
+// Notice: windows.h isn't included here anymore; all needed defines are in
+// stl/_windows.h now
+
+#endif /* _STLP_EVC_H */
diff --git a/sources/android/stlport/stlport/stl/config/_feedback.h b/sources/android/stlport/stlport/stl/config/_feedback.h
new file mode 100644
index 0000000..0171ca5
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_feedback.h
@@ -0,0 +1,43 @@
+/* Helper header to give feedback about build environment configuration
+ * thanks to #pragma message directives.
+ */
+
+#if defined (_STLP_VERBOSE)
+# define _STLP_VERBOSE_MODE_SUPPORTED
+
+# if defined (_STLP_COMPILER)
+# pragma message (_STLP_COMPILER)
+# endif
+
+# if defined (_STLP_NO_RTTI)
+# pragma message ("STLport: RTTI support -> Disabled")
+# else
+# pragma message ("STLport: RTTI support -> Enabled")
+# endif
+
+# if defined (_STLP_HAS_NO_EXCEPTIONS)
+# pragma message ("STLport: Exception support -> Disabled")
+# else
+# pragma message ("STLport: Exception support -> Enabled")
+# endif
+
+# if defined (_STLP_THREADS)
+# pragma message ("STLport: Threading model -> Multi")
+# else
+# pragma message ("STLport: Threading model -> Mono")
+# endif
+
+# if defined (_STLP_USE_DYNAMIC_LIB)
+# pragma message ("STLport: Library model -> Dynamic")
+# else
+# pragma message ("STLport: Library model -> Static")
+# endif
+
+# if defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB)
+# if defined (_STLP_USE_DYNAMIC_LIB)
+# pragma message ("STLport: Native library model -> Static")
+# else
+# pragma message ("STLport: Native library model -> Dynamic")
+# endif
+# endif
+#endif
diff --git a/sources/android/stlport/stlport/stl/config/_freebsd.h b/sources/android/stlport/stlport/stl/config/_freebsd.h
new file mode 100644
index 0000000..ab9339b
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_freebsd.h
@@ -0,0 +1,3 @@
+#define _STLP_PLATFORM "Free BSD"
+
+#define _STLP_USE_UNIX_IO
diff --git a/sources/android/stlport/stlport/stl/config/_fujitsu.h b/sources/android/stlport/stlport/stl/config/_fujitsu.h
new file mode 100644
index 0000000..cf91e05
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_fujitsu.h
@@ -0,0 +1,7 @@
+/* STLport configuration for Fujitsu compiler : looks like a perfect one ! */
+#define _STLP_COMPILER "Fujitsu"
+
+#define _STLP_NATIVE_INCLUDE_PATH ../std
+#define _STLP_UINT32_T unsigned int
+#define _STLP_LONG_LONG long long
+#define _STLP_WCHAR_SUNPRO_EXCLUDE 1
diff --git a/sources/android/stlport/stlport/stl/config/_gcc.h b/sources/android/stlport/stlport/stl/config/_gcc.h
new file mode 100644
index 0000000..0d41863
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_gcc.h
@@ -0,0 +1,198 @@
+/* STLport configuration file
+ * It is internal STLport header - DO NOT include it directly
+ */
+
+#define _STLP_COMPILER "gcc"
+
+#define _STLP_HAS_INCLUDE_NEXT 1
+
+#if (__GNUC__ < 2) || ((__GNUC__ < 3) && ((__GNUC_MINOR__ < 95) || (__GNUC_MINOR__ == 96)))
+/* We do not support neither the unofficial 2.96 gcc version. */
+# error GNU compilers before 2.95 are not supported anymore.
+#endif
+
+/* Systems having GLIBC installed have different traits */
+#if defined (__linux__)
+# ifndef _STLP_USE_GLIBC
+# define _STLP_USE_GLIBC 1
+# endif
+# if defined (__UCLIBC__) && !defined (_STLP_USE_UCLIBC)
+# define _STLP_USE_UCLIBC 1
+# endif
+#endif
+
+#if defined (__CYGWIN__) && \
+ (__GNUC__ >= 3) && (__GNUC_MINOR__ >= 3) && !defined (_GLIBCPP_USE_C99)
+# define _STLP_NO_VENDOR_MATH_L
+# define _STLP_NO_VENDOR_STDLIB_L
+#endif
+
+#if (__GNUC__ < 3)
+# define _STLP_NO_VENDOR_STDLIB_L
+#endif
+
+#if (__GNUC__ < 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ < 4))
+/* define for gcc versions before 3.4.0. */
+# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD
+#endif
+
+#if !defined (_REENTRANT) && (defined (_THREAD_SAFE) || \
+ (defined (__OpenBSD__) && defined (_POSIX_THREADS)) || \
+ (defined (__MINGW32__) && defined (_MT)))
+# define _REENTRANT
+#endif
+
+#if defined (__DJGPP)
+# define _STLP_RAND48 1
+# define _NOTHREADS 1
+# undef _PTHREADS
+# define _STLP_LITTLE_ENDIAN
+#endif
+
+#if defined (__MINGW32__)
+/* Mingw32, egcs compiler using the Microsoft C runtime */
+# if (__GNUC__ >= 3)
+/* For gcc before version 3 this macro is defined below */
+# define _STLP_VENDOR_GLOBAL_CSTD
+# endif
+# undef _STLP_NO_DRAND48
+# define _STLP_NO_DRAND48
+# define _STLP_CALL
+#endif /* __MINGW32__ */
+
+#if defined (__CYGWIN__) || defined (__MINGW32__)
+# if !defined (_STLP_USE_STATIC_LIB)
+# define _STLP_USE_DECLSPEC 1
+# if !defined (_STLP_USE_DYNAMIC_LIB)
+# define _STLP_USE_DYNAMIC_LIB
+# endif
+# define _STLP_EXPORT_DECLSPEC __declspec(dllexport)
+# define _STLP_CLASS_EXPORT_DECLSPEC __declspec(dllexport)
+# define _STLP_CLASS_IMPORT_DECLSPEC __declspec(dllimport)
+# endif
+/* The following is defined independently of _STLP_USE_STATIC_LIB because it is also
+ * used to import symbols from PSDK under MinGW
+ */
+# define _STLP_IMPORT_DECLSPEC __declspec(dllimport)
+#else
+# if (__GNUC__ >= 4)
+# if !defined (_STLP_USE_STATIC_LIB)
+# if !defined (_STLP_USE_DYNAMIC_LIB)
+# define _STLP_USE_DYNAMIC_LIB
+# endif
+# define _STLP_USE_DECLSPEC 1
+# define _STLP_EXPORT_DECLSPEC __attribute__((visibility("default")))
+# define _STLP_IMPORT_DECLSPEC __attribute__((visibility("default")))
+# define _STLP_CLASS_EXPORT_DECLSPEC __attribute__((visibility("default")))
+# define _STLP_CLASS_IMPORT_DECLSPEC __attribute__((visibility("default")))
+# endif
+# endif
+#endif
+
+#if defined (__CYGWIN__) || defined (__MINGW32__) || !(defined (_STLP_USE_GLIBC) || defined (__sun) || defined(__APPLE__))
+# if !defined (__MINGW32__) && !defined (__CYGWIN__)
+# define _STLP_NO_NATIVE_MBSTATE_T 1
+# endif
+# if !defined (__MINGW32__) || (__GNUC__ < 3) || (__GNUC__ == 3) && (__GNUC_MINOR__ < 4)
+# define _STLP_NO_NATIVE_WIDE_FUNCTIONS 1
+# endif
+# define _STLP_NO_NATIVE_WIDE_STREAMS 1
+#endif
+
+#define _STLP_NORETURN_FUNCTION __attribute__((noreturn))
+
+/* Mac OS X is a little different with namespaces and cannot instantiate
+ * static data members in template classes */
+#if defined (__APPLE__)
+# if ((__GNUC__ < 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ < 3)))
+/* Mac OS X is missing a required typedef and standard macro */
+typedef unsigned int wint_t;
+# endif
+
+# define __unix
+
+# define _STLP_NO_LONG_DOUBLE
+
+/* Mac OS X needs all "::" scope references to be "std::" */
+# define _STLP_USE_NEW_C_HEADERS
+
+# define _STLP_NO_VENDOR_STDLIB_L
+
+#endif /* __APPLE__ */
+
+/* g++ 2.7.x and above */
+#define _STLP_LONG_LONG long long
+
+#ifdef _STLP_USE_UCLIBC
+ /* No *f math fuctions variants (i.e. sqrtf, fabsf, etc.) */
+# define _STLP_NO_VENDOR_MATH_F
+ /* No *l math fuctions variants (i.e. sqrtl, fabsl, etc.) */
+# define _STLP_NO_VENDOR_MATH_L
+# define _STLP_NO_LONG_DOUBLE
+#endif
+
+#if defined (__OpenBSD__) || defined (__FreeBSD__)
+# define _STLP_NO_VENDOR_MATH_L
+# define _STLP_NO_VENDOR_STDLIB_L /* no llabs */
+# ifndef __unix
+# define __unix
+# endif
+#endif
+
+#if defined (__alpha__)
+# define _STLP_NO_VENDOR_MATH_L
+#endif
+
+#if defined (__hpux)
+# define _STLP_VENDOR_GLOBAL_CSTD 1
+# define _STLP_NO_VENDOR_STDLIB_L /* no llabs */
+ /* No *f math fuctions variants (i.e. sqrtf, fabsf, etc.) */
+# define _STLP_NO_VENDOR_MATH_F
+#endif
+
+#if (__GNUC__ >= 3)
+# ifndef _STLP_HAS_NO_NEW_C_HEADERS
+/*
+# ifndef _STLP_USE_UCLIBC
+*/
+# define _STLP_HAS_NATIVE_FLOAT_ABS
+/*
+# endif
+*/
+# else
+# ifdef _STLP_USE_GLIBC
+# define _STLP_VENDOR_LONG_DOUBLE_MATH 1
+# endif
+# endif
+#endif
+
+#if (__GNUC__ < 3)
+# define _STLP_HAS_NO_NEW_C_HEADERS 1
+# define _STLP_VENDOR_GLOBAL_CSTD 1
+# define _STLP_DONT_USE_PTHREAD_SPINLOCK 1
+# ifndef __HONOR_STD
+# define _STLP_VENDOR_GLOBAL_EXCEPT_STD 1
+# endif
+/* egcs fails to initialize builtin types in expr. like this : new(p) char(); */
+# define _STLP_DEF_CONST_PLCT_NEW_BUG 1
+#endif
+
+#undef _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT
+#undef _STLP_NO_UNEXPECTED_EXCEPT_SUPPORT
+
+/* strict ANSI prohibits "long long" ( gcc) */
+#if defined ( __STRICT_ANSI__ )
+# undef _STLP_LONG_LONG
+#endif
+
+#ifndef __EXCEPTIONS
+# undef _STLP_DONT_USE_EXCEPTIONS
+# define _STLP_DONT_USE_EXCEPTIONS 1
+#endif
+
+#if (__GNUC__ >= 3)
+/* Instantiation scheme that used (default) in gcc 3 made void of sense explicit
+ instantiation within library: nothing except increased library size. - ptr
+ */
+# define _STLP_NO_FORCE_INSTANTIATE
+#endif
diff --git a/sources/android/stlport/stlport/stl/config/_hpacc.h b/sources/android/stlport/stlport/stl/config/_hpacc.h
new file mode 100644
index 0000000..920b8b4
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_hpacc.h
@@ -0,0 +1,129 @@
+/* STLport configuration file
+ * It is internal STLport header - DO NOT include it directly
+ */
+
+#define _STLP_COMPILER "aCC"
+
+/* system C-library dependent */
+#if defined (_XOPEN_SOURCE) && (_XOPEN_VERSION - 0 >= 4)
+# define _STLP_RAND48 1
+#endif
+/* # define _STLP_RAND48 1 */
+/* #define _STLP_NO_NATIVE_MBSTATE_T 1 */
+#define _STLP_HPACC_BROKEN_BUFEND 1
+#define _STLP_WCHAR_HPACC_EXCLUDE 1
+
+/* this was reported to help, just as with SUN CC 4.2 */
+#define _STLP_INLINE_STRING_LITERAL_BUG
+
+/* specific prolog is needed to select correct threads impl */
+#define _STLP_HAS_SPECIFIC_PROLOG_EPILOG
+
+/* HP aCC with +noeh */
+#ifdef __HPACC_NOEH
+# define _STLP_HAS_NO_EXCEPTIONS 1
+#endif
+
+#define _STLP_NO_FORCE_INSTANTIATE
+#define _STLP_LONG_LONG long long
+#define _STLP_NO_VENDOR_STDLIB_L
+
+/* The aCC6 compiler is using the EDG Front End. Unfortunately, prior to
+ * version A.06.12, defining the __EDG__ and __EDG_VERSION__ macros was
+ * disabled. It was corrected in A.06.12.
+ */
+#if ((__HP_aCC > 60000) && (__HP_aCC < 61200))
+# define __EDG__
+# define __EDG_VERSION__ 306
+#endif
+
+#if (__HP_aCC >= 32500 )
+# define _STLP_USE_NEW_C_HEADERS
+
+# define _STLP_FORCE_ALLOCATORS(t,a) \
+ typedef typename _Alloc_traits<t,a>::_Orig _STLP_dummy_type1;\
+ typedef typename _STLP_dummy_type1:: _STLP_TEMPLATE rebind<t>::other _STLP_dummy_type2;
+
+# if defined (_HP_NAMESPACE_STD) // option -AA
+/* from now, we have a full standard lib in namespace std
+ *
+ * -AA indicates that we are compiling against Rogue Wave 2.2.1
+ * STL shipped with the HP aCC compiler. -AA tells the compiler
+ * to use the STL defined in the include_std directory.
+ */
+# define _STLP_NATIVE_INCLUDE_PATH ../include_std
+# else // option -Aa
+# define _STLP_VENDOR_GLOBAL_STD 1
+# define _STLP_VENDOR_GLOBAL_CSTD 1
+# define _STLP_DONT_THROW_RANGE_ERRORS 1
+# endif
+#endif
+
+#if (__HP_aCC >= 31400 && __HP_aCC < 32500)
+# define _STLP_FORCE_ALLOCATORS(t,a) \
+typedef typename _Alloc_traits<t,a>::_Orig _STLP_dummy_type1;\
+typedef typename _STLP_dummy_type1:: _STLP_TEMPLATE rebind<t>::other _STLP_dummy_type2;
+# define _STLP_NO_CWCHAR
+# if defined (_NAMESPACE_STD) // option -AA
+/* from now, we have a full standard lib in namespace std */
+# define _STLP_NATIVE_INCLUDE_PATH ../include_std
+# else /* kind of compatibility mode */
+# define _STLP_VENDOR_GLOBAL_STD 1
+# define _STLP_VENDOR_GLOBAL_CSTD 1
+# define _STLP_DONT_THROW_RANGE_ERRORS 1
+# define _STLP_NO_ROPE 1
+# endif
+#endif /* 314 */
+
+#if ((__HP_aCC >= 30000 && __HP_aCC < 31400) || (__HP_aCC == 1)) // A.03.13: __HP_aCC == 1
+
+# if (__HP_aCC != 1)
+# define _STLP_HAS_NO_NEW_C_HEADERS 1
+# endif
+
+# define _STLP_NO_QUALIFIED_FRIENDS 1
+/* aCC bug ? need explicit args on constructors of partial specialized
+ * classes
+ */
+# define _STLP_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS 1
+/* ?? fbp : maybe present in some versions ? */
+# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1
+# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1
+/* <exception> and stuff is in global namespace */
+# define _STLP_VENDOR_GLOBAL_EXCEPT_STD
+/* fbp : moved here */
+# define _STLP_VENDOR_GLOBAL_CSTD 1
+/* # define _INCLUDE_HPUX_SOURCE */
+# define _XPG4
+# define _INCLUDE_XOPEN_SOURCE
+# define _INCLUDE_AES_SOURCE
+#endif
+
+#if (__HP_aCC <= 30000 && __HP_aCC >= 12100)
+/* Special kludge to workaround bug in aCC A.01.23, CR JAGac40634 */
+# ifdef _STLP_DEBUG
+static void _STLP_dummy_literal() { const char *p = "x";}
+static void _STLP_dummy_literal_2() { const char *p = "123456789"; }
+static void _STLP_dummy_literal_3() { const char *p = "123456700000000000000089";}
+# endif
+
+# define _STLP_VENDOR_GLOBAL_STD 1
+# define _STLP_VENDOR_GLOBAL_CSTD 1
+# define _STLP_DONT_THROW_RANGE_ERRORS 1
+# define _STLP_STATIC_CONST_INIT_BUG 1
+# if (__HP_aCC < 12700)
+/* new flag: on most HP compilers cwchar is missing */
+# define _STLP_NO_CWCHAR
+# endif
+
+# define _STLP_FORCE_ALLOCATORS(t,a) \
+ typedef typename _Alloc_traits<t,a>::_Orig _STLP_dummy_type1;\
+ typedef typename _STLP_dummy_type1:: _STLP_TEMPLATE rebind<t>::other _STLP_dummy_type2;
+#endif
+
+#if __HP_aCC == 1
+# define _STLP_BROKEN_USING_IN_CLASS
+# define _STLP_USING_BASE_MEMBER
+# define _STLP_NO_CWCHAR
+/* # define _STLP_NO_WCHAR_T 1 */
+#endif
diff --git a/sources/android/stlport/stlport/stl/config/_hpux.h b/sources/android/stlport/stlport/stl/config/_hpux.h
new file mode 100644
index 0000000..385c514
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_hpux.h
@@ -0,0 +1,17 @@
+#ifndef __stl_config__hpux_h
+#define __stl_config__hpux_h
+
+#define _STLP_PLATFORM "HP Unix"
+
+#define _STLP_USE_UNIX_IO
+
+#ifdef __GNUC__
+# define _STLP_NO_WCHAR_T
+# define _STLP_NO_CWCHAR
+# define _STLP_NO_LONG_DOUBLE
+# ifndef _POSIX_C_SOURCE
+# define _POSIX_C_SOURCE 199506
+# endif
+#endif
+
+#endif /* __stl_config__hpux_h */
diff --git a/sources/android/stlport/stlport/stl/config/_ibm.h b/sources/android/stlport/stlport/stl/config/_ibm.h
new file mode 100644
index 0000000..f74f6d9
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_ibm.h
@@ -0,0 +1,144 @@
+/* STLport configuration file
+ * It is internal STLport header - DO NOT include it directly
+ */
+
+#if defined (__IBMCPP__) || defined (__IBMC__)
+# define _STLP_COMPILER "Visual Age C++"
+#elif defined (__xlC__)
+# define _STLP_COMPILER "xlc"
+#else
+# error "Unknown compiler"
+#endif
+
+#if !defined(__IBMCPP__) || (__IBMCPP__ < 500)
+# define _STLP_HAS_NO_NEW_C_HEADERS 1
+#endif
+
+/* string literal problem, same as with SUN and aCC */
+# define _STLP_INLINE_STRING_LITERAL_BUG 1
+# define _STLP_HAS_NATIVE_FLOAT_ABS
+
+# define _STLP_DEF_CONST_PLCT_NEW_BUG 1
+# define _STLP_DEF_CONST_DEF_PARAM_BUG 1
+
+
+# ifdef __IBMCPP__
+# define _STLP_HAS_SPECIFIC_PROLOG_EPILOG
+# endif
+
+/* # if ( defined (__MULTI__) && defined (__WINDOWS__))
+ * # define _STLP_WIN32THREADS 1 Only Visual Age 3.5 for Windows
+ * # endif
+ */
+
+# if ( defined (__MULTI__) && defined (__OS2__))
+# define _STLP_OS2THREADS 1
+# endif
+
+/* __TEMPINC__ is set when /Ft+ option is used */
+# ifdef __TEMPINC__
+# define _STLP_LINK_TIME_INSTANTIATION 1
+# endif
+
+# if defined (__MVS__)
+/* long long support is buggy - reported by Tinny Ng
+ * # if __EXTENDED__ && __COMPILER_VER__ >= 0x22060000
+ * # define _STLP_LONG_LONG long long
+ * # endif
+ */
+/* boris : hstash reported it can be treated like UNIX */
+# define _STLP_NO_TYPEINFO 1
+# undef _STLP_NATIVE_INCLUDE_PATH
+# define _STLP_NATIVE_INCLUDE_PATH /usr/lpp/ioclib/include
+/* same for C headers like <string.h> */
+# undef _STLP_NATIVE_C_INCLUDE_PATH
+# define _STLP_NATIVE_C_INCLUDE_PATH /usr/include
+# define _STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH /usr/include
+
+# elif (defined (__WINDOWS__) || defined (_AIX) || defined (__OS2__) ) && (__IBMCPP__ >= 350)
+
+# define _STLP_LONG_LONG long long
+
+#endif
+
+#if !( defined( __xlC__ ) && __xlC__ >= 0x500 )
+
+/* AIX xlC 3.1 , 3.0.1 ==0x301
+ * Visual Age C++ 3.x
+ * OS-390 C++
+ * fbp : should be more version-specific!
+ */
+
+# define _STLP_NO_BOOL 1
+# define _STLP_DONT_USE_BOOL_TYPEDEF 1
+# define _STLP_LIMITED_DEFAULT_TEMPLATES 1
+# define _STLP_HAS_NO_NAMESPACES 1
+# define _STLP_NEED_TYPENAME 1
+# define _STLP_NEED_EXPLICIT 1
+# define _STLP_NO_ARROW_OPERATOR 1
+# define _STLP_NO_NEW_STYLE_CASTS 1
+# define _STLP_NO_WCHAR_T 1
+# define _STLP_NEED_MUTABLE 1
+# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX 1
+# define _STLP_NO_BAD_ALLOC 1
+
+# define _STLP_NO_MEMBER_TEMPLATES 1
+# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1
+# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1
+# define _STLP_NO_QUALIFIED_FRIENDS 1
+# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1
+# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1
+
+# define _STLP_NO_DEFAULT_NON_TYPE_PARAM 1
+# define _STLP_NO_METHOD_SPECIALIZATION 1
+# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1
+# define _STLP_NO_EXCEPTION_HEADER 1
+
+# define _STLP_NO_NEW_NEW_HEADER 1
+
+# if defined (__OS2__) && (__IBMCPP__ <= 350)
+# define _STLP_NO_TYPEINFO 1
+# endif
+# define _STLP_NO_NEW_NEW_HEADER 1
+
+# define _STLP_STATIC_CONST_INIT_BUG 1
+/* # define _STLP_THROW_RETURN_BUG 1 */
+
+
+# define _STLP_NO_TEMPLATE_CONVERSIONS 1
+# define _STLP_BASE_TYPEDEF_OUTSIDE_BUG 1
+
+/* AIX xlC, Visual Age 3.0 for OS/2 and MS */
+# define _STLP_TRIVIAL_DESTRUCTOR_BUG
+
+# define _STLP_NON_TYPE_TMPL_PARAM_BUG 1
+# define _STLP_NONTEMPL_BASE_MATCH_BUG 1
+
+#if __IBMCPP__ <= 350
+# define _STLP_NEED_UNREACHABLE_RETURN 1
+#endif
+
+#if __IBMCPP__ < 350
+# define _STLP_NO_LONG_DOUBLE 1
+#endif
+
+#if __IBMCPP__ >= 365
+/* does not have new C headers, but has div() */
+# define _STLP_LDIV
+#endif
+
+#endif /* xlC 5 */
+
+/* detect xlC5 by: */
+#if defined(__IBMCPP__) && (500 <= __IBMCPP__) && (__IBMCPP__ < 700)
+# define _STLP_USE_EXCEPTIONS 1
+# define _STLP_STATIC_CONST_INIT_BUG 1
+/* #pragma report(disable,CPPC1500029)
+ * unsigned 32-bit integer type
+ */
+# define _STLP_UINT32_T unsigned int
+# if defined(_XOPEN_SOURCE) && (_XOPEN_VERSION - 0 >= 4)
+# define _STLP_RAND48 1
+# endif
+/* # define _STLP_RAND48 1 */
+#endif /* __IBMCPP__ == 500 */
diff --git a/sources/android/stlport/stlport/stl/config/_icc.h b/sources/android/stlport/stlport/stl/config/_icc.h
new file mode 100644
index 0000000..1fc1bce
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_icc.h
@@ -0,0 +1,44 @@
+// STLport configuration file
+// It is internal STLport header - DO NOT include it directly
+// A list of Intel compiler for Linux portion of STLport settings.
+
+#define _STLP_COMPILER "Intel ICC"
+
+#define _STLP_LONG_LONG long long
+
+// Edit relative path below (or put full path) to get native
+// compiler headers included. Default is "../include".
+// C headers may reside in different directory, so separate macro is provided.
+#if (__INTEL_COMPILER < 800)
+# define _STLP_NATIVE_INCLUDE_PATH ../include
+# define _STLP_NATIVE_C_INCLUDE_PATH ../include
+# define _STLP_NATIVE_CPP_C_INCLUDE_PATH ../include
+#endif
+
+#if (__INTEL_COMPILER >= 800)
+# define _STLP_NATIVE_INCLUDE_PATH ../include/c++
+# define _STLP_NATIVE_C_INCLUDE_PATH ../include
+# define _STLP_NATIVE_CPP_C_INCLUDE_PATH ../include
+
+#endif /* __INTEL_COMPILER >= 800 */
+
+#define _STLP_HAS_NO_NEW_C_HEADERS 1
+#define _STLP_VENDOR_GLOBAL_CSTD 1
+
+/* Systems having GLIBC installed have different traits */
+#if !defined (_STLP_USE_GLIBC) && defined (__linux__)
+# define _STLP_USE_GLIBC
+# define _XOPEN_SOURCE 600
+#endif
+
+#undef _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT
+
+
+#ifndef __GNUC__
+# define __GNUC__ 3
+#endif
+
+//#define _STLP_NO_NATIVE_WIDE_FUNCTIONS 1
+
+#define _STLP_NO_FORCE_INSTANTIATE
+//#define _REENTRANT
diff --git a/sources/android/stlport/stlport/stl/config/_intel.h b/sources/android/stlport/stlport/stl/config/_intel.h
new file mode 100644
index 0000000..01e09d6
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_intel.h
@@ -0,0 +1,72 @@
+// STLport configuration file
+// It is internal STLport header - DO NOT include it directly
+
+#define _STLP_COMPILER "Intel ICL"
+
+#define _STLP_IMPORT_TEMPLATE_KEYWORD extern
+
+/* You need to undef following macro if your icl install is binded to MSVC 6
+ * native lib and you are building with /Qvc7 or /Qvc7.1 or /Qvc8 option.
+ */
+/* #define _STLP_MSVC_LIB 1200 */
+/* You need to undef following macro if your icl install is binded to MSVC .Net 2002
+ * native lib and you are building without any /Qvc* option or with /Qvc6 or /Qvc7.1
+ * or /Qvc8 option.
+ */
+/* #define _STLP_MSVC_LIB 1300 */
+/* You need to undef following macro if your icl install is binded to MSVC .Net 2003
+ * native lib and you are building without any /Qvc* option or with /Qvc6 or /Qvc7
+ * or /Qvc8 option.
+ */
+/* #define _STLP_MSVC_LIB 1310 */
+/* You need to undef following macro if your icl install is binded to MSVC 2005
+ * native lib and you are building without any /Qvc* option or with /Qvc6 or /Qvc7
+ * or /Qvc7.1 option.
+ */
+/* #define _STLP_MSVC_LIB 1400 */
+
+#include <stl/config/_msvc.h>
+
+#if defined (_STLP_DONT_RETURN_VOID)
+# undef _STLP_DONT_RETURN_VOID
+#endif
+
+#if (__ICL < 900)
+# define _STLP_NOTHROW
+#endif
+
+#if (__ICL <= 810)
+/* If method specialization is activated, compiler do not export some
+ * symbols anymore.
+ */
+# define _STLP_NO_METHOD_SPECIALIZATION 1
+#endif
+
+#if (__ICL >= 800 && __ICL < 900)
+# define _STLP_STATIC_CONST_INIT_BUG 1
+#endif
+
+#if (__ICL >= 450)
+# define _STLP_DLLEXPORT_NEEDS_PREDECLARATION 1
+#endif
+
+#if (__ICL < 450)
+/* only static STLport lib works for ICL */
+# undef _STLP_USE_STATIC_LIB
+# undef _STLP_USE_DYNAMIC_LIB
+# define _STLP_USE_STATIC_LIB
+/* disable hook which makes template symbols to be searched for in the library */
+# undef _STLP_NO_CUSTOM_IO
+#endif
+
+#undef _STLP_LONG_LONG
+#define _STLP_LONG_LONG long long
+
+#if defined (__cplusplus) && (__ICL >= 900) && (_STLP_MSVC_LIB < 1300)
+namespace std
+{
+ void _STLP_CALL unexpected();
+}
+#endif
+
+#include <stl/config/_feedback.h>
diff --git a/sources/android/stlport/stlport/stl/config/_kai.h b/sources/android/stlport/stlport/stl/config/_kai.h
new file mode 100644
index 0000000..267158f
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_kai.h
@@ -0,0 +1,43 @@
+// STLport config file for KAI C++ compiler
+
+#if defined(_XOPEN_SOURCE) && (_XOPEN_VERSION - 0 >= 4)
+# define _STLP_RAND48 1
+#endif
+
+# ifndef __KAI_STRICT /* _NO_LONGLONG */
+# define _STLP_LONG_LONG long long
+# endif
+
+# if !defined (__EXCEPTIONS) && ! defined (_EXCEPTIONS)
+# define _STLP_HAS_NO_EXCEPTIONS
+# endif
+
+# ifndef __BUILDING_STLPORT
+# define _STLP_LINK_TIME_INSTANTIATION 1
+# endif
+
+// two levels of macros do not work good with kcc.
+# define _STLP_NATIVE_HEADER(header) <../include/##header>
+# define _STLP_NATIVE_C_HEADER(header) <../include/##header>
+# define _STLP_NATIVE_CPP_C_HEADER(header) <../include/##header>
+# define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) <../include/##header>
+
+// KAI C++ uses EDG front-end, but apparently different switches
+// # define __EDG_SWITCHES 1
+
+# define _STLP_VENDOR_GLOBAL_CSTD 1
+# define _STLP_VENDOR_MB_NAMESPACE std
+
+// boris : some of those may also apply to KCC 3.4
+# if __KCC_VERSION < 4000
+# define _STLP_VENDOR_GLOBAL_EXCEPT_STD 1
+
+# endif
+
+# if defined (__sgi)
+// this requires some discrimination on whether we are actually on
+// a system officially supported by KAI.
+# define _STLP_HAS_NO_NEW_C_HEADERS 1
+# include <standards.h>
+# endif
+
diff --git a/sources/android/stlport/stlport/stl/config/_linux.h b/sources/android/stlport/stlport/stl/config/_linux.h
new file mode 100644
index 0000000..b36a766
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_linux.h
@@ -0,0 +1,125 @@
+#ifndef __stl_config__linux_h
+#define __stl_config__linux_h
+
+#define _STLP_PLATFORM "Linux"
+
+#include <features.h>
+
+/* This is defined wether library in use is glibc or not.
+ This may be treated as presence of GNU libc compatible
+ header files (these define is not really intended to check
+ for the presence of a particular library, but rather is used
+ to define an INTERFACE.) */
+#ifndef _STLP_USE_GLIBC
+# define _STLP_USE_GLIBC 1
+#endif
+
+#ifndef _STLP_USE_STDIO_IO
+# define _STLP_USE_UNIX_IO
+#endif
+
+/* #define _STLP_USE_STDIO_IO */
+
+/* If not explicitly specified otherwise, work with threads
+ */
+#if !defined(_STLP_NO_THREADS) && !defined(_REENTRANT)
+# define _REENTRANT
+#endif
+
+#if defined(_REENTRANT) && !defined(_PTHREADS)
+# define _PTHREADS
+#endif
+
+#ifdef __UCLIBC__ /* uClibc 0.9.27 */
+# define _STLP_USE_UCLIBC 1
+# if !defined(__UCLIBC_HAS_WCHAR__)
+# ifndef _STLP_NO_WCHAR_T
+# define _STLP_NO_WCHAR_T
+# endif
+# ifndef _STLP_NO_NATIVE_MBSTATE_T
+# define _STLP_NO_NATIVE_MBSTATE_T
+# endif
+# ifndef _STLP_NO_NATIVE_WIDE_STREAMS
+# define _STLP_NO_NATIVE_WIDE_STREAMS
+# endif
+# endif /* __UCLIBC_HAS_WCHAR__ */
+ /* Hmm, bogus _GLIBCPP_USE_NAMESPACES seems undefined... */
+# define _STLP_VENDOR_GLOBAL_CSTD 1
+#endif
+
+
+#if defined(_PTHREADS)
+# define _STLP_THREADS
+# define _STLP_PTHREADS
+/*
+# ifndef __USE_UNIX98
+# define __USE_UNIX98
+# endif
+*/
+/* This feature exist at least since glibc 2.2.4 */
+/* # define __FIT_XSI_THR */ /* Unix 98 or X/Open System Interfaces Extention */
+# ifdef __USE_XOPEN2K
+/* The IEEE Std. 1003.1j-2000 introduces functions to implement spinlocks. */
+# ifndef __UCLIBC__ /* There are no spinlocks in uClibc 0.9.27 */
+# define _STLP_USE_PTHREAD_SPINLOCK
+# else
+# ifndef _STLP_DONT_USE_PTHREAD_SPINLOCK
+ /* in uClibc (0.9.26) pthread_spinlock* declared in headers
+ * but absent in library */
+# define _STLP_DONT_USE_PTHREAD_SPINLOCK
+# endif
+# endif
+# ifndef _STLP_DONT_USE_PTHREAD_SPINLOCK
+# define _STLP_USE_PTHREAD_SPINLOCK
+# define _STLP_STATIC_MUTEX _STLP_mutex
+# endif
+/* # define __FIT_PSHARED_MUTEX */
+# endif
+#endif
+
+/* Endiannes */
+#include <endian.h>
+#if !defined(__BYTE_ORDER) || !defined(__LITTLE_ENDIAN) || !defined(__BIG_ENDIAN)
+# error "One of __BYTE_ORDER, __LITTLE_ENDIAN and __BIG_ENDIAN undefined; Fix me!"
+#endif
+
+#if ( __BYTE_ORDER == __LITTLE_ENDIAN )
+# define _STLP_LITTLE_ENDIAN 1
+#elif ( __BYTE_ORDER == __BIG_ENDIAN )
+# define _STLP_BIG_ENDIAN 1
+#else
+# error "__BYTE_ORDER neither __BIG_ENDIAN nor __LITTLE_ENDIAN; Fix me!"
+#endif
+
+#if defined(__GNUC__) && (__GNUC__ < 3)
+# define _STLP_NO_NATIVE_WIDE_FUNCTIONS 1
+#endif
+
+#ifdef __GLIBC__
+# if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3) || (__GLIBC__ > 2)
+/* From glibc 2.3.x default allocator is malloc_alloc, if was not defined other */
+# if !defined(_STLP_USE_MALLOC) && !defined(_STLP_USE_NEWALLOC) && !defined(_STLP_USE_PERTHREAD_ALLOC) && !defined(_STLP_USE_NODE_ALLOC)
+# define _STLP_USE_MALLOC 1
+# endif
+# endif
+/* Following platforms has no long double:
+ * - Alpha
+ * - PowerPC
+ * - SPARC, 32-bits (64-bits platform has long double)
+ * - MIPS, 32-bits
+ * - ARM
+ * - SH4
+ */
+# if defined(__alpha__) || \
+ defined(__ppc__) || defined(PPC) || defined(__powerpc__) || \
+ ((defined(__sparc) || defined(__sparcv9) || defined(__sparcv8plus)) && !defined ( __WORD64 ) && !defined(__arch64__)) /* ? */ || \
+ (defined(_MIPS_SIM) && (_MIPS_SIM == _ABIO32)) || \
+ defined(__arm__) || \
+ defined(__sh__)
+ /* # if defined(__NO_LONG_DOUBLE_MATH) */
+# define _STLP_NO_LONG_DOUBLE
+# endif
+#endif
+
+
+#endif /* __stl_config__linux_h */
diff --git a/sources/android/stlport/stlport/stl/config/_mac.h b/sources/android/stlport/stlport/stl/config/_mac.h
new file mode 100644
index 0000000..575c183
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_mac.h
@@ -0,0 +1,6 @@
+#define _STLP_PLATFORM "Mac"
+
+#define _STLP_MAC 1
+
+#error Looks like unsupported platform
+#define _STLP_USE_UNIX_EMULATION_IO
diff --git a/sources/android/stlport/stlport/stl/config/_macosx.h b/sources/android/stlport/stlport/stl/config/_macosx.h
new file mode 100644
index 0000000..54a9222
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_macosx.h
@@ -0,0 +1,9 @@
+#define _STLP_PLATFORM "Mac OS X"
+
+#if defined (__BIG_ENDIAN__)
+# define _STLP_BIG_ENDIAN 1
+#elif defined (__LITTLE_ENDIAN__)
+# define _STLP_LITTLE_ENDIAN 1
+#endif
+
+#define _STLP_USE_UNIX_IO
diff --git a/sources/android/stlport/stlport/stl/config/_mlc.h b/sources/android/stlport/stlport/stl/config/_mlc.h
new file mode 100644
index 0000000..8687d0b
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_mlc.h
@@ -0,0 +1,7 @@
+// STLport configuration file
+// It is internal STLport header - DO NOT include it directly
+
+#define _STLP_NO_MEMBER_TEMPLATES // Compiler does not support member templates
+#define _STLP_NO_MEMBER_TEMPLATE_CLASSES // Compiler does not support member template classes
+
+#define _STLP_HAS_NEW_NEW_HEADER
diff --git a/sources/android/stlport/stlport/stl/config/_msvc.h b/sources/android/stlport/stlport/stl/config/_msvc.h
new file mode 100644
index 0000000..418d018
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_msvc.h
@@ -0,0 +1,265 @@
+/* STLport configuration file
+ * It is internal STLport header - DO NOT include it directly
+ * Microsoft Visual C++ 6.0, 7.0, 7.1, 8.0, ICL
+ */
+
+#if !defined (_STLP_COMPILER)
+# define _STLP_COMPILER "Microsoft Visual Studio C++"
+#endif
+
+#if !defined (__ICL) && !defined (_STLP_MSVC)
+# define _STLP_MSVC _MSC_VER
+#endif
+
+#if !defined (_STLP_MSVC_LIB)
+# define _STLP_MSVC_LIB _MSC_VER
+#endif
+
+#if defined (__BUILDING_STLPORT) && defined (_MANAGED)
+/* Building a managed version of STLport is not supported because we haven't
+ * found a good reason to support it. However, building a managed translation
+ * unit using STLport _is_ supported.
+ */
+# error Sorry but building a managed version of STLport is not supported.
+#endif
+
+#if defined (_STLP_USING_PLATFORM_SDK_COMPILER)
+/* This is a specific section for compilers coming with platform SDKs. Native
+ * library coming with it is different from the one coming with commercial
+ * MSVC compilers so there is some specific settings.
+ */
+# define _STLP_NATIVE_INCLUDE_PATH ../crt
+# define _STLP_VENDOR_GLOBAL_CSTD
+# define _STLP_VENDOR_TERMINATE_STD
+# define _STLP_GLOBAL_NEW_HANDLER
+# if (_STLP_MSVC_LIB <= 1400)
+/* We hope this bug will be fixed in future versions. */
+# define _STLP_NEW_DONT_THROW_BAD_ALLOC 1
+# endif
+#endif
+
+#define _STLP_CALL __cdecl
+
+#ifndef _STLP_LONG_LONG
+# define _STLP_LONG_LONG __int64
+#endif
+
+#define _STLP_PRAGMA_ONCE
+
+/* These switches depend on compiler flags. We are hoping here that compilers
+ * simulating MSVC behavior use identical macros to report compilation context.
+ * Otherwise those macros will have to be undef in specific compiler configuration
+ * files.
+ */
+#ifndef _CPPUNWIND
+# define _STLP_DONT_USE_EXCEPTIONS 1
+#endif
+
+#ifndef _CPPRTTI
+# define _STLP_NO_RTTI 1
+#endif
+
+#if defined (_MT) && !defined (_STLP_NO_THREADS)
+# define _STLP_THREADS 1
+#endif
+
+#if !defined (_NATIVE_WCHAR_T_DEFINED)
+# define _STLP_WCHAR_T_IS_USHORT 1
+#endif
+
+#define _STLP_NO_VENDOR_STDLIB_L 1
+
+#if defined (_STLP_MSVC)
+
+# if (_STLP_MSVC < 1200)
+# error Microsoft Visual C++ compilers before version 6 (SP5) are not supported.
+# endif
+
+# define _STLP_NORETURN_FUNCTION __declspec(noreturn)
+
+/* Full compiler version comes from boost library intrinsics.hpp header. */
+# if defined (_MSC_FULL_VER) && (_MSC_FULL_VER >= 140050215)
+# define _STLP_HAS_TRIVIAL_CONSTRUCTOR(T) __has_trivial_constructor(T)
+# define _STLP_HAS_TRIVIAL_COPY(T) __has_trivial_copy(T)
+# define _STLP_HAS_TRIVIAL_ASSIGN(T) __has_trivial_assign(T)
+# define _STLP_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
+# define _STLP_IS_POD(T) __is_pod(T)
+# define _STLP_HAS_TYPE_TRAITS_INTRINSICS
+# endif
+
+# ifndef _STLP_MSVC50_COMPATIBILITY
+# define _STLP_MSVC50_COMPATIBILITY 1
+# endif
+
+# define _STLP_DLLEXPORT_NEEDS_PREDECLARATION 1
+# define _STLP_HAS_SPECIFIC_PROLOG_EPILOG 1
+# define _STLP_NO_STATIC_CONST_DEFINITION 1
+
+/* # ifndef __BUILDING_STLPORT
+ * # define _STLP_USE_TEMPLATE_EXPORT 1
+ * # endif
+ */
+
+/** Note: the macro _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT is defined
+unconditionally and undef'ed here when applicable. */
+# if defined (UNDER_CE)
+/* eVCx:
+uncaught_exception is declared in the SDKs delivered with eVC4 (eVC3 is
+unknown) and they all reside in namespace 'std' there. However, they are not
+part of any lib so linking fails. When using VC8 to crosscompile for CE 5 on
+an ARMV4I, the uncaught_exception test fails, the function returns the wrong
+value. */
+/* All eVCs up to at least VC8/CE5 have a broken new operator that
+ returns null instead of throwing bad_alloc. */
+# define _STLP_NEW_DONT_THROW_BAD_ALLOC 1
+# else
+/* VCx:
+These are present at least since VC6, but the uncaught_exception() of VC6 is
+broken, it returns the wrong value in the unittests. 7.1 and later seem to
+work, 7.0 is still unknown (we assume it works until negative report). */
+# if (_STLP_MSVC >= 1300)// VC7 and later
+# undef _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT
+# endif
+# if (_STLP_MSVC < 1300)
+# define _STLP_NOTHROW
+# endif
+# endif
+
+# if (_STLP_MSVC <= 1300)
+# define _STLP_STATIC_CONST_INIT_BUG 1
+# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1
+# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1
+/* There is no partial spec, and MSVC breaks on simulating it for iterator_traits queries */
+# define _STLP_USE_OLD_HP_ITERATOR_QUERIES
+# define _STLP_NO_TYPENAME_IN_TEMPLATE_HEADER
+# define _STLP_NO_METHOD_SPECIALIZATION 1
+# define _STLP_DEF_CONST_PLCT_NEW_BUG 1
+# define _STLP_NO_TYPENAME_ON_RETURN_TYPE 1
+/* VC++ cannot handle default allocator argument in template constructors */
+# define _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS
+# define _STLP_NO_QUALIFIED_FRIENDS 1
+# endif
+
+# if (_STLP_MSVC < 1300) /* including MSVC 6.0 */
+# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1
+# define _STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE 1
+# endif
+
+# define _STLP_HAS_NATIVE_FLOAT_ABS 1
+
+// TODO: some eVC4 compilers report _MSC_VER 1201 or 1202, which category do they belong to?
+# if (_STLP_MSVC > 1200) && (_STLP_MSVC < 1310)
+# define _STLP_NO_MOVE_SEMANTIC
+# endif
+
+# if (_STLP_MSVC < 1300)
+/* TODO: remove this if it is handled and documented elsewhere
+ * dums: VC6 do not handle correctly member templates of class that are explicitely
+ * instanciated to be exported. There is a workaround, seperate the non template methods
+ * from the template ones within 2 different classes and only export the non template one.
+ * It is implemented for basic_string and locale at the writing of this note.
+ * However this problem hos not been considered as important enough to remove template member
+ * methods for other classes. Moreover Boost (www.boost.org) required it to be granted.
+ * The workaround is activated thanks to the _STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND macro defined
+ * later in this config file.
+ */
+/*
+# if defined (_DLL)
+# define _STLP_NO_MEMBER_TEMPLATES 1
+# endif
+*/
+
+/* Boris : not defining this macro for SP5 causes other problems */
+/*# if !defined (_MSC_FULL_VER) || (_MSC_FULL_VER < 12008804 ) */
+# define _STLP_NO_USING_FOR_GLOBAL_FUNCTIONS 1
+/*# endif */
+# define _STLP_DONT_USE_BOOL_TYPEDEF 1
+# define _STLP_DONT_RETURN_VOID 1
+# endif
+
+# if (_STLP_MSVC < 1300) /* MSVC 6.0 and earlier */
+# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1
+/* defined for DEBUG and NDEBUG too, to allow user mix own debug build with STLP release library */
+# define _STLP_USE_ABBREVS
+# endif
+
+#endif /* _STLP_MSVC */
+
+/* The desktop variants starting with VC8 have a set of more secure replacements
+ * for the error-prone string handling functions of the C standard lib. */
+/* When user do not consider 'unsafe' string functions as deprecated using _CRT_SECURE_NO_DEPRECATE
+ * macro we use 'unsafe' functions for performance reasons. */
+#if (_STLP_MSVC_LIB >= 1400) && !defined (_STLP_USING_PLATFORM_SDK_COMPILER) && !defined (UNDER_CE) && \
+ !defined (_CRT_SECURE_NO_DEPRECATE)
+# define _STLP_USE_SAFE_STRING_FUNCTIONS 1
+#endif
+
+#if (_STLP_MSVC_LIB <= 1310)
+# define _STLP_VENDOR_GLOBAL_CSTD
+#endif
+
+#if (_STLP_MSVC_LIB >= 1300) && !defined(UNDER_CE)
+/* Starting with MSVC 7.0 and compilers simulating it,
+ * we assume that the new SDK is granted:
+ */
+# define _STLP_NEW_PLATFORM_SDK 1
+#endif
+
+#if (_STLP_MSVC_LIB < 1300) /* including MSVC 6.0 */
+# define _STLP_GLOBAL_NEW_HANDLER 1
+# define _STLP_VENDOR_UNEXPECTED_STD
+# define _STLP_NEW_DONT_THROW_BAD_ALLOC 1
+#endif
+
+#define _STLP_EXPORT_DECLSPEC __declspec(dllexport)
+#define _STLP_IMPORT_DECLSPEC __declspec(dllimport)
+#define _STLP_CLASS_EXPORT_DECLSPEC __declspec(dllexport)
+#define _STLP_CLASS_IMPORT_DECLSPEC __declspec(dllimport)
+
+#if defined (__DLL) || defined (_DLL) || defined (_RTLDLL) || defined (_AFXDLL)
+# define _STLP_RUNTIME_DLL
+#endif
+#if defined (__BUILDING_STLPORT) && \
+ (defined (_STLP_USE_DYNAMIC_LIB) || \
+ defined (_STLP_RUNTIME_DLL) && !defined (_STLP_USE_STATIC_LIB))
+# define _STLP_DLL
+#endif
+#include <stl/config/_detect_dll_or_lib.h>
+#undef _STLP_RUNTIME_DLL
+#undef _STLP_DLL
+
+#if defined (_STLP_USE_DYNAMIC_LIB)
+# undef _STLP_USE_DECLSPEC
+# define _STLP_USE_DECLSPEC 1
+# if defined (_STLP_MSVC) && (_STLP_MSVC < 1300)
+# define _STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND 1
+# endif
+#endif
+
+#if !defined (_STLP_IMPORT_TEMPLATE_KEYWORD)
+# if !defined (_MSC_EXTENSIONS) || defined (_STLP_MSVC) && (_STLP_MSVC >= 1300)
+# define _STLP_IMPORT_TEMPLATE_KEYWORD
+# else
+# define _STLP_IMPORT_TEMPLATE_KEYWORD extern
+# endif
+#endif
+#define _STLP_EXPORT_TEMPLATE_KEYWORD
+
+#include <stl/config/_auto_link.h>
+
+#if defined (_STLP_USING_PLATFORM_SDK_COMPILER)
+/* The Windows 64 bits SDK required for the moment link to bufferoverflowU.lib for
+ * additional buffer overrun checks. Rather than require the STLport build system and
+ * users to explicitely link with it we use the MSVC auto link feature.
+ */
+# if !defined (_STLP_DONT_USE_AUTO_LINK) || defined (__BUILDING_STLPORT)
+# pragma comment (lib, "bufferoverflowU.lib")
+# if defined (_STLP_VERBOSE)
+# pragma message ("STLport: Auto linking to bufferoverflowU.lib")
+# endif
+# endif
+#endif
+
+#if defined (_STLP_MSVC)
+# include <stl/config/_feedback.h>
+#endif
diff --git a/sources/android/stlport/stlport/stl/config/_mwerks.h b/sources/android/stlport/stlport/stl/config/_mwerks.h
new file mode 100644
index 0000000..f91f3b1
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_mwerks.h
@@ -0,0 +1,159 @@
+// STLport configuration file
+// It is internal STLport header - DO NOT include it directly
+
+#define _STLP_COMPILER "Metrowerk Codewarrior"
+
+// Bring in definition of __MSL__ and related items
+#include <mslGlobals.h>
+#include <ansi_parms.h>
+
+//
+// Compiler features
+//
+
+
+// *** CodeWarrior Compiler Common Features ***
+# if __option(longlong)
+# define _STLP_LONG_LONG long long
+# endif
+
+# define _STLP_USE_UNIX_EMULATION_IO 1
+
+# define _STLP_USE_AUTO_PTR_CONVERSIONS 1
+
+# ifdef __INTEL__
+# define _STLP_LITTLE_ENDIAN
+# else
+# define _STLP_BIG_ENDIAN
+# endif
+
+#if defined(_MSL_NO_LOCALE)
+#define _STLP_NO_IMPORT_LOCALE
+#endif
+#if !__option( wchar_type )
+# define _STLP_WCHAR_T_IS_USHORT
+#endif
+
+# if __MWERKS__ < 0x3000
+// *** CodeWarrior Compiler Common Bugs ***
+# define __MSL_FIX_ITERATORS__(myType) // Some MSL headers rely on this
+# define _STLP_THROW_RETURN_BUG 1
+# endif
+
+// *** Version-specific settings ***
+
+# if __MWERKS__ >= 0x2405
+# define _STLP_HAS_NATIVE_FLOAT_ABS
+# endif
+
+# if __MWERKS__ < 0x2405
+# define _STLP_STATIC_CONST_INIT_BUG
+# endif
+
+# if __MWERKS__ <= 0x2303
+# define _STLP_NO_TEMPLATE_CONVERSIONS 1
+# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1
+# endif
+
+# if __MWERKS__ < 0x2301
+# define _STLP_MEMBER_SPECIALIZATION_BUG 1
+# endif
+
+# if __MWERKS__ < 0x2300 // CW Pro5 features
+# define _STLP_INLINE_MEMBER_TEMPLATES 1
+# define _STLP_RELOPS_IN_STD_BUG 1
+# define _STLP_DEF_CONST_PLCT_NEW_BUG 1
+# define _STLP_DEF_CONST_DEF_PARAM_BUG 1
+# define _STLP_NO_TYPENAME_ON_RETURN_TYPE
+# endif
+
+# if __MWERKS__ < 0x2200 // CW Pro4 features
+# define _STLP_BROKEN_USING_DIRECTIVE 1
+# define _STLP_NO_MEMBER_TEMPLATES 1
+# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1
+# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1
+# define _STLP_NO_QUALIFIED_FRIENDS 1
+# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1
+# endif
+
+# if __MWERKS__ < 0x2100 // CW Pro3 features
+# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1
+# define _STLP_HAS_NO_NAMESPACES 1
+# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1
+
+# define _STLP_NEED_TYPENAME 1
+# define _STLP_NO_ARROW_OPERATOR 1
+# define _STLP_TEMPLATE_PARAM_SUBTYPE_BUG 1
+# define _STLP_FORCED_INLINE_INSTANTIATION_BUG 1
+# define _STLP_MULTI_CONST_TEMPLATE_ARG_BUG 1
+# define _STLP_INLINE_NAME_RESOLUTION_BUG 1
+// *** Metrowerks Standard Library Bug ***
+# define _STLP_MSVC50_COMPATIBILITY 1
+# endif
+
+# if __MWERKS__ < 0x2000 // v. 2.0 features
+# define _STLP_NO_WCHAR_T 1
+# define _STLP_NO_DEFAULT_NON_TYPE_PARAM 1
+# define _STLP_NON_TYPE_TMPL_PARAM_BUG 1 // dwa 8/21/97 - this bug fixed for CWPro2
+# endif
+
+# if __MWERKS__ < 0x1900 // dwa 8/19/97 - 1.9 Compiler feature defines
+# define _STLP_LIMITED_DEFAULT_TEMPLATES 1
+# define _STLP_BASE_TYPEDEF_BUG 1
+# define _STLP_BASE_MATCH_BUG 1
+# define _STLP_NONTEMPL_BASE_MATCH_BUG 1
+# define _STLP_DEFAULT_TYPE_PARAM 1 // More limited template parameters
+
+# if __MWERKS__ < 0x1800
+ __GIVE_UP_WITH_STL(CW_18)
+# endif
+
+# endif
+
+
+// fixes to native inclusion wrappers.
+# if __MWERKS__ >= 0x2300 // CWPro5 changes paths - dwa 2/28/99
+# define _STLP_NATIVE_INCLUDE_PATH ../include
+# define _STLP_NATIVE_C_INCLUDE_PATH ../include
+# define _STLP_NATIVE_HEADER(header) <../include/##header>
+# define _STLP_NATIVE_CPP_C_HEADER(header) <../include/##header>
+# define _STLP_NATIVE_C_HEADER(header) <../include/##header>
+# define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) <../include/##header>
+# else
+
+# define _STLP_NATIVE_INCLUDE_PATH Macintosh HD:Codewarrior Pro 4:Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C++:Include
+# define _STLP_NATIVE_C_INCLUDE_PATH Macintosh HD:Codewarrior Pro 4:Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C:MSL Common:Public Includes
+# define _STLP_NATIVE_HEADER(header) <Macintosh HD:Codewarrior Pro 4:Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C++:Include:##header>
+# define _STLP_NATIVE_CPP_C_HEADER(header) <Macintosh HD:Codewarrior Pro 4:Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C++:Include:##header>
+# define _STLP_NATIVE_C_HEADER(header) <Macintosh HD:Codewarrior Pro 4:Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C:MSL Common:Public Includes:##header>
+# define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) <Macintosh HD:Codewarrior Pro 4:Metrowerks CodeWarrior:Metrowerks Standard Library:MSL C:MSL Common:Public Includes:##header>
+
+# endif
+
+//Following block come from boost intrinsics.hpp file:
+#if defined (__MSL_CPP__) && (__MSL_CPP__ >= 0x8000)
+ // Metrowerks compiler is acquiring intrinsic type traits support
+ // post version 8. We hook into the published interface to pick up
+ // user defined specializations as well as compiler intrinsics as
+ // and when they become available:
+# include <msl_utility>
+# define _STLP_HAS_TRIVIAL_CONSTRUCTOR(T) Metrowerks::has_trivial_default_ctor<T>::value
+# define _STLP_HAS_TRIVIAL_COPY(T) Metrowerks::has_trivial_copy_ctor<T>::value
+# define _STLP_HAS_TRIVIAL_ASSIGN(T) Metrowerks::has_trivial_assignment<T>::value
+# define _STLP_HAS_TRIVIAL_DESTRUCTOR(T) Metrowerks::has_trivial_dtor<T>::value
+# define _STLP_IS_POD(T) Metrowerks::is_POD<T>::value
+# define _STLP_HAS_TYPE_TRAITS_INTRINSICS
+#endif
+
+// fbp
+# if !defined( __MSL_CPP__ ) || __MSL_CPP__ <= 0x4105
+# define _STLP_NO_NATIVE_WIDE_STREAMS 1
+# endif
+
+# if defined(__MACH__)
+# define _STLP_MAC
+# define O_BINARY 0
+# elif defined(macintosh)
+# define _NOTHREADS
+# endif
+# define _STLP_DLLEXPORT_NEEDS_PREDECLARATION 1
diff --git a/sources/android/stlport/stlport/stl/config/_native_headers.h b/sources/android/stlport/stlport/stl/config/_native_headers.h
new file mode 100644
index 0000000..f1f4bc9
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_native_headers.h
@@ -0,0 +1,50 @@
+ /*
+ *
+ * Copyright (c) 2006
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if !defined (_STLP_MAKE_HEADER)
+# define _STLP_MAKE_HEADER(path, header) <path/header>
+#endif
+
+#if !defined (_STLP_NATIVE_HEADER)
+# if !defined (_STLP_NATIVE_INCLUDE_PATH)
+# define _STLP_NATIVE_INCLUDE_PATH ../include
+# endif
+# define _STLP_NATIVE_HEADER(header) _STLP_MAKE_HEADER(_STLP_NATIVE_INCLUDE_PATH,header)
+#endif
+
+/* For some compilers, C headers like <stdio.h> are located in separate directory */
+#if !defined (_STLP_NATIVE_C_HEADER)
+# if !defined (_STLP_NATIVE_C_INCLUDE_PATH)
+# define _STLP_NATIVE_C_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH
+# endif
+# define _STLP_NATIVE_C_HEADER(header) _STLP_MAKE_HEADER(_STLP_NATIVE_C_INCLUDE_PATH,header)
+#endif
+
+/* For some compilers, C-library headers like <cstdio> are located in separate directory */
+#if !defined (_STLP_NATIVE_CPP_C_HEADER)
+# if !defined (_STLP_NATIVE_CPP_C_INCLUDE_PATH)
+# define _STLP_NATIVE_CPP_C_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH
+# endif
+# define _STLP_NATIVE_CPP_C_HEADER(header) _STLP_MAKE_HEADER(_STLP_NATIVE_CPP_C_INCLUDE_PATH,header)
+#endif
+
+/* Some compilers locate basic C++ runtime support headers (<new>, <typeinfo>, <exception>) in separate directory */
+#if !defined ( _STLP_NATIVE_CPP_RUNTIME_HEADER )
+# if !defined (_STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH)
+# define _STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH
+# endif
+# define _STLP_NATIVE_CPP_RUNTIME_HEADER(header) _STLP_MAKE_HEADER(_STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH,header)
+#endif
diff --git a/sources/android/stlport/stlport/stl/config/_openbsd.h b/sources/android/stlport/stlport/stl/config/_openbsd.h
new file mode 100644
index 0000000..86a19d1
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_openbsd.h
@@ -0,0 +1,12 @@
+#define _STLP_PLATFORM "Open BSD"
+
+#define _STLP_USE_UNIX_IO
+
+#if defined (_POSIX_THREADS) && !defined (_STLP_THREADS)
+# define _STLP_THREADS
+#endif
+
+#if defined (_POSIX_THREADS) && !defined (_STLP_DONT_USE_PTHREAD_SPINLOCK)
+# define _STLP_USE_PTHREAD_SPINLOCK
+# define _STLP_STATIC_MUTEX _STLP_mutex
+#endif
diff --git a/sources/android/stlport/stlport/stl/config/_prolog.h b/sources/android/stlport/stlport/stl/config/_prolog.h
new file mode 100644
index 0000000..a16a794
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_prolog.h
@@ -0,0 +1,43 @@
+
+#if defined (_STLP_MSVC) || defined (__ICL)
+
+# pragma warning (push)
+# include <stl/config/_warnings_off.h>
+/* We are forcing the alignment to guaranty that libraries are use
+ * with the same alignment as the one use to build them.
+ */
+# if !defined (_WIN64)
+# pragma pack(push, 8)
+# else
+# pragma pack(push, 16)
+# endif
+
+#elif defined (__BORLANDC__)
+
+# pragma option push
+# pragma option -Vx- -Ve- -a8 -b -pc
+# include <stl/config/_warnings_off.h>
+
+#elif defined (__sgi) && !defined (__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
+
+# pragma set woff 1209
+# pragma set woff 1174
+# pragma set woff 1375
+/* from iterator_base.h */
+# pragma set woff 1183
+
+#elif defined (__DECCXX)
+
+# ifdef __PRAGMA_ENVIRONMENT
+# pragma __environment __save
+# pragma __environment __header_defaults
+# endif
+
+#elif defined (__IBMCPP__)
+/* supress EDC3130: A constant is being used as a conditional expression */
+# pragma info(nocnd)
+#elif defined (__WATCOMCPLUSPLUS__)
+# pragma warning 604 10 /* must lookahead to determine... */
+# pragma warning 594 10 /* resolved as declaration/type */
+# pragma warning 595 10 /* resolved as an expression */
+#endif
diff --git a/sources/android/stlport/stlport/stl/config/_sgi.h b/sources/android/stlport/stlport/stl/config/_sgi.h
new file mode 100644
index 0000000..7500f3d
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_sgi.h
@@ -0,0 +1,94 @@
+// STLport configuration file
+// It is internal STLport header - DO NOT include it directly
+
+#define _STLP_COMPILER "CC"
+
+#define _STLP_HAS_SPECIFIC_PROLOG_EPILOG
+
+// define native include path before trying to include anything
+
+#define _STLP_NATIVE_HEADER(__x) </usr/include/CC/##__x>
+#define _STLP_NATIVE_C_HEADER(__x) </usr/include/##__x>
+#define _STLP_NATIVE_OLD_STREAMS_HEADER(__x) </usr/include/CC/##__x>
+#define _STLP_NATIVE_CPP_C_HEADER(__x) </usr/include/CC/##__x>
+#define _STLP_NATIVE_CPP_RUNTIME_HEADER(__x) </usr/include/CC/##__x>
+
+#define _STLP_NO_NATIVE_MBSTATE_T
+
+#define _STLP_NO_USING_FOR_GLOBAL_FUNCTIONS
+#define _STLP_NO_NATIVE_WIDE_FUNCTIONS
+#define _STLP_NO_MEMBER_TEMPLATE_CLASSES
+
+// #define _STLP_NO_BAD_ALLOC
+
+#define _STL_HAS_NAMESPACES
+
+#if ! defined (__EXCEPTIONS) && ! defined (_STLP_NO_EXCEPTIONS)
+# define _STLP_NO_EXCEPTIONS
+#endif
+
+#define __EDG_SWITCHES
+
+#define _STLP_USE_SGI_STRING 1
+
+#define _STLP_HAS_NO_NEW_C_HEADERS 1
+// # define _STLP_VENDOR_GLOBAL_EXCEPT_STD
+
+#define _STLP_NO_POST_COMPATIBLE_SECTION
+
+#include <standards.h>
+
+#if !(_COMPILER_VERSION >= 730)
+# define _STLP_NO_NEW_NEW_HEADER 1
+#endif
+
+#if (_COMPILER_VERSION >= 730 && defined(_STANDARD_C_PLUS_PLUS))
+# define _STLP_EXTERN_RANGE_ERRORS
+#endif
+
+#if !defined(_BOOL)
+# define _STLP_NO_BOOL
+#endif
+#if defined(_MIPS_SIM) && _MIPS_SIM == _ABIO32
+# define _STLP_STATIC_CONST_INIT_BUG
+#endif
+
+#if (_COMPILER_VERSION < 720) || (defined(_MIPS_SIM) && _MIPS_SIM == _ABIO32)
+# define _STLP_DEF_CONST_PLCT_NEW_BUG
+# define _STLP_DEF_CONST_DEF_PARAM_BUG
+#endif
+#if !((_COMPILER_VERSION >= 730) && defined(_MIPS_SIM) && _MIPS_SIM != _ABIO32)
+# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD
+#endif
+#if !defined(_STANDARD_C_PLUS_PLUS)
+# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS
+#endif
+#if !((_COMPILER_VERSION >= 721) && defined(_NAMESPACES))
+# define _STLP_HAS_NO_NAMESPACES
+#endif
+#if (_COMPILER_VERSION < 721) || !defined(_STL_HAS_NAMESPACES) || defined(_STLP_NO_NAMESPACES)
+# define _STLP_NO_EXCEPTION_HEADER
+#endif
+#if _COMPILER_VERSION < 730 || !defined(_STANDARD_C_PLUS_PLUS) || !defined(_NAMESPACES)
+# define _STLP_NO_BAD_ALLOC
+#endif
+#if defined(_LONGLONG) && defined(_SGIAPI) && _SGIAPI
+# define _STLP_LONG_LONG long long
+#endif
+#if !(_COMPILER_VERSION >= 730 && defined(_STANDARD_C_PLUS_PLUS))
+# define _STLP_USE_NO_IOSTREAMS
+#endif
+#if !(_COMPILER_VERSION >= 730 && defined(_STANDARD_C_PLUS_PLUS))
+# define _STLP_NO_AT_MEMBER_FUNCTION
+#endif
+// # if !(_COMPILER_VERSION >= 730 && defined(_STANDARD_C_PLUS_PLUS))
+#if !(_COMPILER_VERSION >= 721 && defined(_STANDARD_C_PLUS_PLUS))
+# define _STLP_NO_TEMPLATE_CONVERSIONS
+#endif
+#if !((_COMPILER_VERSION >= 730) && defined(_MIPS_SIM) && _MIPS_SIM != _ABIO32)
+# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER
+#endif
+
+#if !defined (_NOTHREADS) && !defined (_STLP_THREADS_DEFINED) && !defined (__GNUC__)
+# define _STLP_SGI_THREADS
+#endif
diff --git a/sources/android/stlport/stlport/stl/config/_solaris.h b/sources/android/stlport/stlport/stl/config/_solaris.h
new file mode 100644
index 0000000..8756a06
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_solaris.h
@@ -0,0 +1,77 @@
+#ifndef __stl_config__solaris_h
+#define __stl_config__solaris_h
+
+#define _STLP_PLATFORM "Sun Solaris"
+
+/* include system features file */
+#include <sys/feature_tests.h>
+
+/* system-dependent defines */
+#define _STLP_USE_UNIX_IO
+
+#ifdef __GNUC__
+/*
+ * See comments (and configuration defines) in the host.h
+ */
+# if !(defined(__SunOS_5_5_1) || defined(__SunOS_5_6) || defined(__SunOS_5_7) || \
+ defined(__SunOS_5_8) || defined(__SunOS_5_9) || defined(__SunOS_5_10))
+# error Uncomment one of the defines (__SunOS_5_x) in the file stlport/stl/config/host.h
+# endif
+#endif
+
+#if defined (__SunOS_5_8) && ! defined (_STLP_HAS_NO_NEW_C_HEADERS) && ( __cplusplus >= 199711L)
+# define _STLP_HAS_NATIVE_FLOAT_ABS
+#endif
+
+#if defined(_XOPEN_SOURCE) && (_XOPEN_VERSION - 0 >= 4)
+# define _STLP_RAND48 1
+#endif
+
+#if (defined(_XOPEN_SOURCE) && (_XOPEN_VERSION - 0 == 4)) || defined (__SunOS_5_6)
+# define _STLP_WCHAR_SUNPRO_EXCLUDE 1
+# define _STLP_NO_NATIVE_WIDE_FUNCTIONS 1
+#endif
+
+/* boris : this should always be defined for Solaris 5 & 6. Any ideas how to do it? */
+#if !(defined ( __KCC ) && __KCC_VERSION > 3400 ) && \
+ ((defined(__SunOS_5_5_1) || defined(__SunOS_5_6) ))
+# ifndef _STLP_NO_NATIVE_MBSTATE_T
+# define _STLP_NO_NATIVE_MBSTATE_T 1
+# endif
+#endif /* KCC */
+
+/* For SPARC we use lightweight synchronization */
+#if defined (__sparc) /* && (defined (_REENTRANT) || defined (_PTHREADS)) */
+# if ( (defined (__GNUC__) && defined (__sparc_v9__)) || \
+ defined (__sparcv9) ) \
+ && !defined(_NOTHREADS) && !defined (_STLP_NO_SPARC_SOLARIS_THREADS)
+# define _STLP_SPARC_SOLARIS_THREADS
+# define _STLP_THREADS_DEFINED
+# endif
+#endif
+
+/* gcc does not support ELF64 yet ; however; it supports ultrasparc + v8plus.
+ * limits.h contains invalid values for this combination
+ */
+#ifdef __GNUC__
+# if (defined (__sparc_v9__) || defined (__sparcv9)) && !defined ( __WORD64 ) && !defined(__arch64__)
+# define __LONG_MAX__ 2147483647L
+# endif
+#endif
+
+/*
+ * Attention! See comments (and configuration defines) in the host.h
+ * (you host may has MATH_F and MATH_L functions)
+ *
+ */
+#if !defined(__SunOS_5_10) && !defined(_STLP_SOLARIS_MATH_PATCH)
+# define _STLP_NO_VENDOR_MATH_F
+# define _STLP_NO_VENDOR_MATH_L
+#endif
+
+#ifdef __GNUC__
+# define _STLP_WCHAR_BORLAND_EXCLUDE
+# define _STLP_NO_NATIVE_WIDE_FUNCTIONS 1
+#endif
+
+#endif /* __stl_config__solaris_h */
diff --git a/sources/android/stlport/stlport/stl/config/_sunprocc.h b/sources/android/stlport/stlport/stl/config/_sunprocc.h
new file mode 100644
index 0000000..15fe5cd
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_sunprocc.h
@@ -0,0 +1,166 @@
+// STLport configuration file
+// It is internal STLport header - DO NOT include it directly
+
+#define _STLP_COMPILER "Sunpro CC"
+
+#define _STLP_LONG_LONG long long
+
+// GAB: 11/09/05
+// Starting with 5.0 the STLport code expects to be
+// instantiated during compile time. This is due to undefing
+// a number of defines that are also used in the c versions
+// of the file. When they are undefed the c version fails to
+// compile.
+// # define _STLP_LINK_TIME_INSTANTIATION 1
+
+#if ! defined(_BOOL)
+# define _STLP_NO_BOOL 1
+#endif
+
+// compatibility mode stuff
+#if (__SUNPRO_CC >= 0x510) && (!defined (__SUNPRO_CC_COMPAT) || (__SUNPRO_CC_COMPAT == 5 ))
+# define _STLP_NATIVE_INCLUDE_PATH ../CC/Cstd
+# define _STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH ../CC
+#elif (__SUNPRO_CC >= 0x500) && (!defined (__SUNPRO_CC_COMPAT) || (__SUNPRO_CC_COMPAT == 5 ))
+# define _STLP_NATIVE_INCLUDE_PATH ../CC
+#elif (defined (__SUNPRO_CC_COMPAT) && __SUNPRO_CC_COMPAT == 4)
+# define _STLP_NATIVE_INCLUDE_PATH ../CC4
+#else
+# define _STLP_NATIVE_INCLUDE_PATH ../CC
+#endif
+
+#define _STLP_STATIC_CONST_INIT_BUG 1
+
+#if (__SUNPRO_CC < 0x530)
+// those are tested and proved not to work...
+# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1
+# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1
+# define _STLP_USE_OLD_HP_ITERATOR_QUERIES
+#endif
+
+#ifdef _STLP_USE_NO_IOSTREAMS
+# define _STLP_HAS_NO_NEW_C_HEADERS 1
+#endif
+
+// those do not depend on compatibility
+#if (__SUNPRO_CC < 0x510)
+# define _STLP_NO_TYPENAME_ON_RETURN_TYPE 1
+# define _STLP_NONTEMPL_BASE_MATCH_BUG 1
+#endif
+
+#if (__SUNPRO_CC < 0x510) || (defined (__SUNPRO_CC_COMPAT) && (__SUNPRO_CC_COMPAT < 5))
+
+# define _STLP_NO_QUALIFIED_FRIENDS 1
+
+// no partial , just for explicit one
+# define _STLP_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS
+# define _STLP_NON_TYPE_TMPL_PARAM_BUG 1
+
+# define _STLP_NO_MEMBER_TEMPLATES 1
+
+# define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1
+# define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS
+# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1
+#endif
+
+// Features that depend on compatibility switch
+#if ( __SUNPRO_CC < 0x500 ) || (defined (__SUNPRO_CC_COMPAT) && (__SUNPRO_CC_COMPAT < 5))
+
+# ifndef _STLP_USE_NO_IOSTREAMS
+# define _STLP_USE_NO_IOSTREAMS 1
+# endif
+# define _STLP_NO_NEW_NEW_HEADER 1
+// # define _STLP_NO_RELOPS_NAMESPACE
+# define _STLP_HAS_NO_NAMESPACES 1
+# define _STLP_NEED_MUTABLE 1
+# define _STLP_NO_BAD_ALLOC 1
+# define _STLP_NO_EXCEPTION_HEADER 1
+# define _STLP_NATIVE_C_INCLUDE_PATH ../include
+#elif (__SUNPRO_CC < 0x510)
+// # define _STLP_NATIVE_C_HEADER(header) <../CC/##header##.SUNWCCh>
+# define _STLP_NATIVE_CPP_C_HEADER(header) <../CC/##header##.SUNWCCh>
+# define _STLP_NATIVE_C_INCLUDE_PATH /usr/include
+#elif defined( __SunOS_5_5_1 ) || defined( __SunOS_5_6 ) || defined( __SunOS_5_7 )
+# define _STLP_NATIVE_C_INCLUDE_PATH ../CC/std
+# define _STLP_NATIVE_CPP_C_INCLUDE_PATH ../CC/std
+#else
+# define _STLP_NATIVE_C_INCLUDE_PATH /usr/include
+# define _STLP_NATIVE_CPP_C_INCLUDE_PATH ../CC/std
+#endif
+
+#if ( __SUNPRO_CC < 0x500 )
+
+# undef _STLP_NATIVE_C_HEADER
+# undef _STLP_NATIVE_CPP_C_HEADER
+
+# define wint_t __wint_t
+// famous CC 4.2 bug
+# define _STLP_INLINE_STRING_LITERAL_BUG 1
+// /usr/include
+# define _STLP_NATIVE_C_INCLUDE_PATH ../include
+
+// 4.2 cannot handle iterator_traits<_Tp>::iterator_category as a return type ;(
+# define _STLP_USE_OLD_HP_ITERATOR_QUERIES
+
+// 4.2 does not like it
+# undef _STLP_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS
+
+# define _STLP_LIMITED_DEFAULT_TEMPLATES 1
+
+# define _STLP_NEED_TYPENAME 1
+# define _STLP_NEED_EXPLICIT 1
+# define _STLP_NO_BAD_ALLOC 1
+# define _STLP_NO_ARROW_OPERATOR 1
+
+# define _STLP_DEF_CONST_PLCT_NEW_BUG 1
+# define _STLP_DEF_CONST_DEF_PARAM_BUG 1
+# define _STLP_GLOBAL_NESTED_RETURN_TYPE_PARAM_BUG 1
+# undef _STLP_HAS_NO_NEW_C_HEADERS
+# define _STLP_HAS_NO_NEW_C_HEADERS 1
+// # define _STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS
+
+# if ( __SUNPRO_CC < 0x420 )
+# define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX 1
+# define _STLP_NO_NEW_STYLE_CASTS 1
+# define _STLP_NO_METHOD_SPECIALIZATION 1
+# if ( __SUNPRO_CC > 0x401 )
+# if (__SUNPRO_CC==0x410)
+# define _STLP_BASE_TYPEDEF_OUTSIDE_BUG 1
+# endif
+# else
+ // SUNPro C++ 4.0.1
+# define _STLP_BASE_MATCH_BUG 1
+# define _STLP_BASE_TYPEDEF_BUG 1
+# if (( __SUNPRO_CC < 0x401 ) && !defined(__SUNPRO_C))
+ __GIVE_UP_WITH_STL(SUNPRO_401)
+# endif
+# endif /* 4.0.1 */
+# endif /* 4.2 */
+#endif /* < 5.0 */
+
+#ifndef _MBSTATET_H
+# define _MBSTATET_H
+# undef _MBSTATE_T
+# define _MBSTATE_T
+typedef struct __mbstate_t {
+# if defined(_LP64)
+ long __filler[4];
+# else
+ int __filler[6];
+# endif
+} __mbstate_t;
+# ifndef _STLP_HAS_NO_NAMESPACES
+namespace std {
+ typedef __mbstate_t mbstate_t;
+}
+using std::mbstate_t;
+# else
+typedef __mbstate_t mbstate_t;
+# endif
+#endif /* __MBSTATET_H */
+
+#if !defined(_STLP_HAS_NO_NEW_C_HEADERS) && !defined(_STLP_NO_NEW_C_HEADERS)
+/* Since Sun Studio uses <iso/stdlib_iso.h>, we are at its
+ * mercy. GCC is built on top of <stdlib.h>. */
+#define _STLP_NO_VENDOR_STDLIB_L
+#endif
diff --git a/sources/android/stlport/stlport/stl/config/_system.h b/sources/android/stlport/stlport/stl/config/_system.h
new file mode 100644
index 0000000..c0b4add
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_system.h
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/*
+ * Purpose of this file :
+ *
+ * To hold COMPILER-SPECIFIC portion of STLport settings.
+ * In general, user should not edit this file unless
+ * using the compiler not recognized below.
+ *
+ * If your compiler is not being recognized yet,
+ * please look for definitions of macros in stl_mycomp.h,
+ * copy stl_mycomp.h to stl_YOUR_COMPILER_NAME,
+ * adjust flags for your compiler, and add <include config/stl_YOUR_COMPILER_NAME>
+ * to the secton controlled by unique macro defined internaly by your compiler.
+ *
+ * To change user-definable settings, please edit <user_config.h>
+ *
+ */
+
+#ifndef __stl_config__system_h
+#define __stl_config__system_h
+
+#if defined (__sun)
+# include <stl/config/_solaris.h>
+# if defined (__GNUC__)
+# include <stl/config/_gcc.h>
+# elif defined (__SUNPRO_CC) || defined (__SUNPRO_C)
+# include <stl/config/_sunprocc.h>
+/*
+# ifdef __KCC
+# include <stl/config/_kai.h>
+# endif
+*/
+# elif defined (__APOGEE__) /* Apogee 4.x */
+# include <stl/config/_apcc.h>
+# elif defined (__FCC_VERSION) /* Fujitsu Compiler, v4.0 assumed */
+# include <stl/config/_fujitsu.h>
+# endif
+#elif defined (__hpux)
+# include <stl/config/_hpux.h>
+# if defined (__GNUC__)
+# include <stl/config/_gcc.h>
+# elif defined (__HP_aCC)
+# include <stl/config/_hpacc.h>
+# endif
+#elif defined (ANDROID)
+/* Android mobile phone platform. Somewhat but not entirely GNU/Linux-like */
+# include <stl/config/_android.h>
+#elif defined (linux) || defined (__linux__)
+# include <stl/config/_linux.h>
+# if defined (__BORLANDC__)
+# include <stl/config/_bc.h> /* Borland C++ 0x570 */
+/* Intel's icc define __GNUC__! */
+# elif defined (__INTEL_COMPILER)
+# include <stl/config/_icc.h>
+# elif defined (__GNUC__)
+# include <stl/config/_gcc.h>
+# endif
+/*
+# ifdef __KCC
+# include <stl/config/_kai.h>
+# endif
+*/
+#elif defined (__FreeBSD__)
+# include <stl/config/_freebsd.h>
+# if defined (__GNUC__)
+# include <stl/config/_gcc.h>
+# endif
+#elif defined (__OpenBSD__)
+# include <stl/config/_openbsd.h>
+# if defined (__GNUC__)
+# include <stl/config/_gcc.h>
+# endif
+#elif defined (__sgi) /* IRIX? */
+# define _STLP_PLATFORM "SGI Irix"
+# if defined (__GNUC__)
+# include <stl/config/_gcc.h>
+# else
+# include <stl/config/_sgi.h>
+# endif
+#elif defined (__OS400__) /* AS/400 C++ */
+# define _STLP_PLATFORM "OS 400"
+# if defined (__GNUC__)
+# include <stl/config/_gcc.h>
+# else
+# include <stl/config/_as400.h>
+# endif
+#elif defined (_AIX)
+# include <stl/config/_aix.h>
+# if defined (__xlC__) || defined (__IBMC__) || defined ( __IBMCPP__ )
+ /* AIX xlC, Visual Age C++ , OS-390 C++ */
+# include <stl/config/_ibm.h>
+# endif
+#elif defined (_CRAY) /* Cray C++ 3.4 or 3.5 */
+# define _STLP_PLATFORM "Cray"
+# include <config/_cray.h>
+#elif defined (__DECCXX) || defined (__DECC)
+# define _STLP_PLATFORM "DECC"
+# ifdef __vms
+# include <stl/config/_dec_vms.h>
+# else
+# include <stl/config/_dec.h>
+# endif
+#elif defined (macintosh) || defined (_MAC)
+# include <stl/config/_mac.h>
+# if defined (__MWERKS__)
+# include <stl/config/_mwerks.h>
+# endif
+#elif defined (__APPLE__)
+# include <stl/config/_macosx.h>
+# ifdef __GNUC__
+# include <stl/config/_gcc.h>
+# endif
+#elif defined (__CYGWIN__)
+# include <stl/config/_cygwin.h>
+# if defined (__GNUC__)
+# include <stl/config/_gcc.h>
+# endif
+#elif defined (__MINGW32__)
+# define _STLP_PLATFORM "MinGW"
+# if defined (__GNUC__)
+# include <stl/config/_gcc.h>
+# endif
+# include <stl/config/_windows.h>
+#elif defined (_WIN32) || defined (__WIN32) || defined (WIN32) || defined (__WIN32__) || \
+ defined (__WIN16) || defined (WIN16) || defined (_WIN16)
+# if defined ( __BORLANDC__ ) /* Borland C++ / CodeGear C++ */
+# include <stl/config/_bc.h>
+# elif defined (__WATCOM_CPLUSPLUS__) || defined (__WATCOMC__) /* Watcom C++ */
+# include <stl/config/_watcom.h>
+# elif defined (__COMO__) || defined (__COMO_VERSION_)
+# include <stl/config/_como.h>
+# elif defined (__DMC__) /* Digital Mars C++ */
+# include <stl/config/_dm.h>
+# elif defined (__ICL) /* Intel reference compiler for Win */
+# include <stl/config/_intel.h>
+# elif defined (__MWERKS__)
+# include <stl/config/_mwerks.h>
+# elif defined (_MSC_VER) && (_MSC_VER >= 1200) && defined (UNDER_CE)
+ /* Microsoft eMbedded Visual C++ 3.0, 4.0 (.NET) */
+# include <stl/config/_evc.h>
+# elif defined (_MSC_VER)
+ /* Microsoft Visual C++ 6.0, 7.0, 7.1, 8.0 */
+# include <stl/config/_msvc.h>
+# endif
+
+# include <stl/config/_windows.h>
+#else
+# error Unknown platform !!
+#endif
+
+#if !defined (_STLP_COMPILER)
+/* Unable to identify the compiler, issue error diagnostic.
+ * Edit <config/stl_mycomp.h> to set STLport up for your compiler. */
+# include <stl/config/stl_mycomp.h>
+#endif
+
+#endif /* __stl_config__system_h */
diff --git a/sources/android/stlport/stlport/stl/config/_warnings_off.h b/sources/android/stlport/stlport/stl/config/_warnings_off.h
new file mode 100644
index 0000000..77e9815
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_warnings_off.h
@@ -0,0 +1,51 @@
+/* This header turns off warnings that STLport headers generate for compiled
+ * user code.
+ */
+
+#if defined (_STLP_MSVC)
+# if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) || \
+ defined (_STLP_SIGNAL_RUNTIME_COMPATIBILITY) || defined (_STLP_CHECK_RUNTIME_COMPATIBILITY)
+/*
+ * 31/07/2004: dums - now that we do not export the basic_string class anymore but only a base class
+ * we have to disable this warning as the string are used as data members type of many iostream classes.
+ */
+# pragma warning ( disable : 4251 ) // ignore template classes being exported in .dll's
+# endif
+
+# if (_STLP_MSVC < 1300) // VC6, eVC3, eVC4
+# pragma warning( disable : 4097 ) // typedef-name used as based class of (...)
+# pragma warning( disable : 4231 ) // non standard extension : 'extern' before template instanciation
+# pragma warning( disable : 4244 ) // implicit conversion: possible loss of data
+# pragma warning( disable : 4284 ) // for -> operator
+//This warning is necessary because of the native platform headers:
+# pragma warning( disable : 4290 ) // c++ exception specification ignored
+# pragma warning( disable : 4514 ) // unreferenced inline function has been removed
+# pragma warning( disable : 4660 ) // template-class specialization '...' is already instantiated
+# pragma warning( disable : 4701 ) // local variable '...' may be used without having been initialized
+# pragma warning( disable : 4710 ) // function (...) not inlined
+# pragma warning( disable : 4786 ) // identifier truncated to 255 characters
+# endif
+
+# if (_STLP_MSVC < 1400)
+# pragma warning( disable : 4511 ) // copy constructor cannot be generated
+# endif
+
+//Pool of common warnings for all MSVC supported versions:
+//Many are only useful if warning level is set to 4.
+# pragma warning( disable : 4100 ) // unreferenced formal parameter
+# 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 : 4245 ) // conversion from 'enum ' to 'unsigned int', signed/unsigned mismatch
+# pragma warning( disable : 4355 ) // this used in base member initializer list (used in rope implementation)
+# pragma warning( disable : 4510 ) // default constructor cannot be generated
+# pragma warning( disable : 4512 ) // assignment operator could not be generated
+# pragma warning( disable : 4571 ) // catch(...) blocks compiled with /EHs do not catch or re-throw Structured Exceptions
+# pragma warning( disable : 4610 ) // struct '...' can never be instantiated - user defined construtor required
+#elif defined (__BORLANDC__)
+# pragma option -w-ccc // -w-8008 Condition is always true OR Condition is always false
+# pragma option -w-inl // -w-8027 Functions containing reserved words are not expanded inline
+# pragma option -w-ngu // -w-8041 Negating unsigned value
+# pragma option -w-pow // -w-8062 Previous options and warnings not restored
+# pragma option -w-rch // -w-8066 Unreachable code
+# pragma option -w-par // -w-8057 Parameter 'parameter' is never used
+#endif
diff --git a/sources/android/stlport/stlport/stl/config/_watcom.h b/sources/android/stlport/stlport/stl/config/_watcom.h
new file mode 100644
index 0000000..b0d2def
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_watcom.h
@@ -0,0 +1,151 @@
+// STLport configuration file
+// It is internal STLport header - DO NOT include it directly
+
+#define _STLP_COMPILER "Watcom"
+
+#if (__WATCOMC__ < 1250)
+# error Not supported!
+#endif
+
+#ifndef _CPPRTTI
+# define _STLP_NO_RTTI 1
+#endif
+
+// for switches (-xs, -xss, -xst)
+#if !(defined (__SW_XS) || defined (__SW_XSS) || defined(__SW_XST))
+# define _STLP_HAS_NO_EXCEPTIONS 1
+#endif
+
+#if defined (_MT) && !defined (_NOTHREADS)
+# define _STLP_THREADS 1
+#endif
+
+#define _STLP_NO_VENDOR_STDLIB_L
+#define _STLP_NO_VENDOR_MATH_F
+#define _STLP_NO_VENDOR_MATH_L
+
+#define _STLP_LONG_LONG long long
+
+#define _STLP_CALL __cdecl
+#define _STLP_IMPORT_DECLSPEC __declspec(dllimport)
+
+#define _STLP_NO_CONST_IN_PAIR
+
+//#define _STLP_DONT_USE_PRIV_NAMESPACE
+//#define _STLP_NO_MOVE_SEMANTIC
+//#define _STLP_NO_TYPENAME_IN_TEMPLATE_HEADER
+#define _STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE
+
+#define _STLP_NO_RELOPS_NAMESPACE
+
+#define _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS
+#define _STLP_NO_STATIC_CONST_DEFINITION
+
+//#define _STLP_HAS_SPECIFIC_PROLOG_EPILOG
+#define _STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS
+//#define _STLP_USE_OLD_HP_ITERATOR_QUERIES
+
+#define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1
+#define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1
+//#define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1
+//#define _STLP_NO_MEMBER_TEMPLATES 1
+//#define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1
+
+//#define _STLP_LIMITED_DEFAULT_TEMPLATES 1
+//#define _STLP_HAS_NO_NAMESPACES 1
+//#define _STLP_NEED_TYPENAME 1
+
+#define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS 1
+
+//#define _STLP_STATIC_CONST_INIT_BUG 1
+// #define _STLP_THROW_RETURN_BUG 1
+//#define _STLP_NO_TEMPLATE_CONVERSIONS 1
+
+#define _STLP_BASE_TYPEDEF_OUTSIDE_BUG 1
+
+#define _STLP_NO_DEFAULT_NON_TYPE_PARAM 1
+#define _STLP_NON_TYPE_TMPL_PARAM_BUG 1
+
+//#define _STLP_NONTEMPL_BASE_MATCH_BUG
+//#define _STLP_NO_EXCEPTION_HEADER 1
+#define _STLP_NO_BAD_ALLOC 1
+
+//#define _STLP_NO_TYPENAME_ON_RETURN_TYPE
+//#define _STLP_NESTED_TYPE_PARAM_BUG 1
+
+//#define _STLP_NO_USING_FOR_GLOBAL_FUNCTIONS 1
+
+#define _STLP_NO_ARROW_OPERATOR 1
+// This one is present in 11, but apparently has bugs (with auto_ptr).
+//#define _STLP_NO_NEW_STYLE_CASTS 1
+
+// Get rid of Watcom's min and max macros
+#undef min
+#undef max
+
+// On QNX, headers are supposed to be found in /usr/include,
+// so default "../include" should work.
+#ifndef __QNX__
+# define _STLP_NATIVE_INCLUDE_PATH ../h
+#else
+// boris : is this true or just the header is not in /usr/include ?
+# define _STLP_NO_TYPEINFO 1
+#endif
+
+// Inline replacements for locking calls under Watcom
+// Define _STLP_NO_WATCOM_INLINE_INTERLOCK to keep using
+// standard WIN32 calls
+// Define _STL_MULTIPROCESSOR to enable lock
+#define _STLP_NO_WATCOM_INLINE_INTERLOCK
+#if !defined(_STLP_NO_WATCOM_INLINE_INTERLOCK)
+
+long __stl_InterlockedIncrement( long *var );
+long __stl_InterlockedDecrement( long *var );
+
+#ifdef _STL_MULTIPROCESSOR
+// Multiple Processors, add lock prefix
+#pragma aux __stl_InterlockedIncrement parm [ ecx ] = \
+ ".586" \
+ "mov eax, 1" \
+ "lock xadd [ecx], eax" \
+ "inc eax" \
+ value [eax];
+
+
+#pragma aux __stl_InterlockedDecrement parm [ ecx ] = \
+ ".586" \
+ "mov eax, 0FFFFFFFFh" \
+ "lock xadd [ecx], eax" \
+ "dec eax" \
+ value [eax];
+#else
+// Single Processor, lock prefix not needed
+#pragma aux __stl_InterlockedIncrement parm [ ecx ] = \
+ ".586" \
+ "mov eax, 1" \
+ "xadd [ecx], eax" \
+ "inc eax" \
+ value [eax];
+
+#pragma aux __stl_InterlockedDecrement parm [ ecx ] = \
+ ".586" \
+ "mov eax, 0FFFFFFFFh" \
+ "xadd [ecx], eax" \
+ "dec eax" \
+ value [eax];
+#endif // _STL_MULTIPROCESSOR
+
+long __stl_InterlockedExchange( long *Destination, long Value );
+
+// xchg has auto-lock
+#pragma aux __stl_InterlockedExchange parm [ecx] [eax] = \
+ ".586" \
+ "xchg eax, [ecx]" \
+ value [eax];
+
+# define _STLP_ATOMIC_INCREMENT(__x) __stl_InterlockedIncrement((long*)__x)
+# define _STLP_ATOMIC_DECREMENT(__x) __stl_InterlockedDecrement((long*)__x)
+# define _STLP_ATOMIC_EXCHANGE(__x, __y) __stl_InterlockedExchange((long*)__x, (long)__y)
+# define _STLP_ATOMIC_EXCHANGE_PTR(__x, __y) __stl_InterlockedExchange((long*)__x, (long)__y)
+#endif /* INLINE INTERLOCK */
+
diff --git a/sources/android/stlport/stlport/stl/config/_windows.h b/sources/android/stlport/stlport/stl/config/_windows.h
new file mode 100644
index 0000000..6b42e11
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/_windows.h
@@ -0,0 +1,291 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_INTERNAL_WINDOWS_H
+#define _STLP_INTERNAL_WINDOWS_H
+
+#if !defined (_STLP_PLATFORM)
+# define _STLP_PLATFORM "Windows"
+#endif
+
+#if !defined (_STLP_BIG_ENDIAN) && !defined (_STLP_LITTLE_ENDIAN)
+# if defined (_MIPSEB)
+# define _STLP_BIG_ENDIAN 1
+# endif
+# if defined (__i386) || defined (_M_IX86) || defined (_M_ARM) || \
+ defined (__amd64__) || defined (_M_AMD64) || defined (__x86_64__) || \
+ defined (__alpha__)
+# define _STLP_LITTLE_ENDIAN 1
+# endif
+# if defined (__ia64__)
+ /* itanium allows both settings (for instance via gcc -mbig-endian) - hence a seperate check is required */
+# if defined (__BIG_ENDIAN__)
+# define _STLP_BIG_ENDIAN 1
+# else
+# define _STLP_LITTLE_ENDIAN 1
+# endif
+# endif
+#endif /* _STLP_BIG_ENDIAN */
+
+#if !defined (_STLP_WINDOWS_H_INCLUDED)
+# define _STLP_WINDOWS_H_INCLUDED
+# if defined (__BUILDING_STLPORT)
+# include <stl/config/_native_headers.h>
+/* Here we define _STLP_OUTERMOST_HEADER_ID to avoid indirect inclusion
+ * of STLport stuffs from C/C++ Standard headers exposed by STLport
+ * as configuration is not yet completed. */
+# if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x100
+# endif
+# if !defined (WIN32_LEAN_AND_MEAN)
+# define WIN32_LEAN_AND_MEAN
+# endif
+# if !defined (VC_EXTRALEAN)
+# define VC_EXTRALEAN
+# endif
+/* Don't let windows.h define its min and max macros. */
+# if !defined (NOMINMAX)
+# define NOMINMAX
+# endif
+# if !defined (STRICT)
+# define STRICT
+# endif
+# if defined (_STLP_USE_MFC)
+# include <afx.h>
+# else
+# include <windows.h>
+# endif
+# if (_STLP_OUTERMOST_HEADER_ID == 0x100)
+# undef _STLP_OUTERMOST_HEADER_ID
+# endif
+# else
+/* This section serves as a replacement for windows.h header. */
+# if defined (__cplusplus)
+extern "C" {
+# endif
+# if (defined (_M_AMD64) || defined (_M_IA64) || (!defined (_STLP_WCE) && defined (_M_MRX000)) || defined (_M_ALPHA) || \
+ (defined (_M_PPC) && (_STLP_MSVC_LIB >= 1000))) && !defined (RC_INVOKED)
+# define InterlockedIncrement _InterlockedIncrement
+# define InterlockedDecrement _InterlockedDecrement
+# define InterlockedExchange _InterlockedExchange
+# define _STLP_STDCALL
+# else
+# if defined (_MAC)
+# define _STLP_STDCALL _cdecl
+# else
+# define _STLP_STDCALL __stdcall
+# endif
+# endif
+
+# if defined (_STLP_NEW_PLATFORM_SDK)
+_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedIncrement(long volatile *);
+_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedDecrement(long volatile *);
+_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedExchange(long volatile *, long);
+# if defined (_WIN64)
+_STLP_IMPORT_DECLSPEC void* _STLP_STDCALL _InterlockedExchangePointer(void* volatile *, void*);
+# endif
+# elif !defined (_STLP_WCE)
+/* boris : for the latest SDK, you may actually need the other version of the declaration (above)
+ * even for earlier VC++ versions. There is no way to tell SDK versions apart, sorry ...
+ */
+_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedIncrement(long*);
+_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedDecrement(long*);
+_STLP_IMPORT_DECLSPEC long _STLP_STDCALL InterlockedExchange(long*, long);
+# else
+/* start of eMbedded Visual C++ specific section */
+# include <stl/config/_native_headers.h>
+
+/* Don't let windef.h define its min and max macros. */
+# if !defined (NOMINMAX)
+# define NOMINMAX
+# endif
+# include <windef.h> /* needed for basic windows types */
+
+ /** in SDKs generated with PB5, windef.h somehow includes headers which then
+ define setjmp. */
+# if (_WIN32_WCE >= 0x500)
+# define _STLP_NATIVE_SETJMP_H_INCLUDED
+# endif
+
+# ifndef _WINBASE_ /* winbase.h already included? */
+long WINAPI InterlockedIncrement(long*);
+long WINAPI InterlockedDecrement(long*);
+long WINAPI InterlockedExchange(long*, long);
+# endif
+
+# ifndef __WINDOWS__ /* windows.h already included? */
+
+# if defined (x86)
+# include <winbase.h> /* needed for inline versions of Interlocked* functions */
+# endif
+
+# ifndef _MFC_VER
+
+# define MessageBox MessageBoxW
+int WINAPI MessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType);
+
+# define wvsprintf wvsprintfW
+int WINAPI wvsprintfW(LPWSTR, LPCWSTR, va_list ArgList);
+
+void WINAPI ExitThread(DWORD dwExitCode);
+
+# if !defined (COREDLL)
+# define _STLP_WCE_WINBASEAPI DECLSPEC_IMPORT
+# else
+# define _STLP_WCE_WINBASEAPI
+# endif
+
+_STLP_WCE_WINBASEAPI int WINAPI
+MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr,
+ int cbMultiByte, LPWSTR lpWideCharStr, int cchWideChar);
+
+_STLP_WCE_WINBASEAPI UINT WINAPI GetACP();
+
+_STLP_WCE_WINBASEAPI BOOL WINAPI TerminateProcess(HANDLE hProcess, DWORD uExitCode);
+
+# define OutputDebugString OutputDebugStringW
+void WINAPI OutputDebugStringW(LPCWSTR);
+
+_STLP_WCE_WINBASEAPI void WINAPI Sleep(DWORD);
+
+# undef _STLP_WCE_WINBASEAPI
+
+# endif /* !_MFC_VER */
+
+# endif /* !__WINDOWS__ */
+
+/* end of eMbedded Visual C++ specific section */
+# endif
+
+# if !defined (_STLP_WCE)
+_STLP_IMPORT_DECLSPEC void _STLP_STDCALL Sleep(unsigned long);
+_STLP_IMPORT_DECLSPEC void _STLP_STDCALL OutputDebugStringA(const char* lpOutputString);
+# endif
+
+# if defined (InterlockedIncrement)
+# pragma intrinsic(_InterlockedIncrement)
+# pragma intrinsic(_InterlockedDecrement)
+# pragma intrinsic(_InterlockedExchange)
+# if defined (_WIN64)
+# pragma intrinsic(_InterlockedExchangePointer)
+# endif
+# endif
+# if defined (__cplusplus)
+} /* extern "C" */
+# endif
+
+# endif
+
+/* Here we use a macro different than the InterlockedExchangePointer SDK one
+ * to avoid macro definition conflict. */
+# if !defined (_WIN64)
+/* Under 32 bits platform we rely on a simple InterlockedExchange call. */
+# if defined (__cplusplus)
+/* We do not define this function if we are not in a C++ translation unit just
+ * because of the 'inline' keyword portability issue it would introduce. We will
+ * have to fix it the day we need this function for a C translation unit.
+ */
+inline
+void* _STLP_CALL STLPInterlockedExchangePointer(void* volatile* __a, void* __b) {
+# if defined (_STLP_MSVC)
+/* Here MSVC produces warning if 64 bits portability issue is activated.
+ * MSVC do not see that _STLP_ATOMIC_EXCHANGE_PTR is a macro which content
+ * is based on the platform, Win32 or Win64
+ */
+# pragma warning (push)
+# pragma warning (disable : 4311) // pointer truncation from void* to long
+# pragma warning (disable : 4312) // conversion from long to void* of greater size
+# endif
+# if !defined (_STLP_NO_NEW_STYLE_CASTS)
+ return reinterpret_cast<void*>(InterlockedExchange(reinterpret_cast<long*>(const_cast<void**>(__a)),
+ reinterpret_cast<long>(__b)));
+# else
+ return (void*)InterlockedExchange((long*)__a, (long)__b);
+# endif
+# if defined (_STLP_MSVC)
+# pragma warning (pop)
+# endif
+}
+# endif
+# else
+# define STLPInterlockedExchangePointer _InterlockedExchangePointer
+# endif
+
+#endif /* _STLP_WINDOWS_H_INCLUDED */
+
+/* _STLP_WIN95_LIKE signal the Windows 95 OS or assimilated Windows OS version that
+ * has Interlockeded[Increment, Decrement] Win32 API functions not returning modified
+ * value.
+ */
+#if (defined (WINVER) && (WINVER < 0x0410) && (!defined (_WIN32_WINNT) || (_WIN32_WINNT < 0x400))) || \
+ (!defined (WINVER) && (defined (_WIN32_WINDOWS) && (_WIN32_WINDOWS < 0x0410) || \
+ (defined (_WIN32_WINNT) && (_WIN32_WINNT < 0x400))))
+# define _STLP_WIN95_LIKE
+#endif
+
+/* Between Windows 95 (0x400) and later Windows OSes an API enhancement forces us
+ * to change _Refcount_Base internal struct. As _Refcount_base member methods might
+ * be partially inlined we need to check that STLport build/use are coherent. To do
+ * so we try to generate a link time error thanks to the following macro.
+ * This additional check is limited to old compilers that might still be used with
+ * Windows 95. */
+#if (defined (_DEBUG) || defined (_STLP_DEBUG)) && \
+ (defined (_STLP_MSVC) && (_STLP_MSVC < 1310) || \
+ defined (__GNUC__) && (__GNUC__ < 3))
+/* We invert symbol names based on macro detection, when building for Windows
+ * 95 we expose a
+ * building_for_windows95_or_previous_but_library_built_for_windows98_or_later
+ * function in order to have a more obvious link error message signaling how
+ * the lib has been built and how it is used. */
+# if defined (__BUILDING_STLPORT)
+# if defined (_STLP_WIN95_LIKE)
+# define _STLP_SIGNAL_RUNTIME_COMPATIBILITY building_for_windows95_but_library_built_for_at_least_windows98
+# else
+# define _STLP_SIGNAL_RUNTIME_COMPATIBILITY building_for_at_least_windows98_but_library_built_for_windows95
+# endif
+# else
+# if defined (_STLP_WIN95_LIKE)
+# define _STLP_CHECK_RUNTIME_COMPATIBILITY building_for_windows95_but_library_built_for_at_least_windows98
+# else
+# define _STLP_CHECK_RUNTIME_COMPATIBILITY building_for_at_least_windows98_but_library_built_for_windows95
+# endif
+# endif
+#endif
+
+#if defined (__WIN16) || defined (WIN16) || defined (_WIN16)
+# define _STLP_WIN16
+#else
+# define _STLP_WIN32
+#endif
+
+#if defined(_STLP_WIN32)
+# define _STLP_USE_WIN32_IO /* CreateFile/ReadFile/WriteFile */
+#endif
+
+#if defined(__MINGW32__) && !defined(_STLP_USE_STDIO_IO)
+# define _STLP_USE_WIN32_IO /* CreateFile/ReadFile/WriteFile */
+#endif /* __MINGW32__ */
+
+#ifdef _STLP_WIN16
+# define _STLP_USE_UNIX_EMULATION_IO /* _open/_read/_write */
+# define _STLP_LDOUBLE_80
+#endif
+
+#endif /* _STLP_INTERNAL_WINDOWS_H */
diff --git a/sources/android/stlport/stlport/stl/config/compat.h b/sources/android/stlport/stlport/stl/config/compat.h
new file mode 100644
index 0000000..434f314
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/compat.h
@@ -0,0 +1,80 @@
+
+/*
+ * Compatibility section
+ * This section sets new-style macros based on old-style ones, for compatibility
+ */
+
+#if defined (__STL_DEBUG) && !defined (_STLP_DEBUG)
+# define _STLP_DEBUG __STL_DEBUG
+#endif
+#if defined (__STL_NO_ANACHRONISMS) && !defined (_STLP_NO_ANACHRONISMS)
+# define _STLP_NO_ANACHRONISMS __STL_NO_ANACHRONISMS
+#endif
+#if defined (__STL_NO_EXTENSIONS) && !defined (_STLP_NO_EXTENSIONS)
+# define _STLP_NO_EXTENSIONS __STL_NO_EXTENSIONS
+#endif
+#if defined (__STL_NO_EXCEPTIONS) && !defined (_STLP_NO_EXCEPTIONS)
+# define _STLP_NO_EXCEPTIONS __STL_NO_EXCEPTIONS
+#endif
+#if defined (__STL_NO_NAMESPACES) && !defined (_STLP_NO_NAMESPACES)
+# define _STLP_NO_NAMESPACES __STL_NO_NAMESPACES
+#endif
+#if defined (__STL_MINIMUM_DEFAULT_TEMPLATE_PARAMS) && !defined (_STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS)
+# define _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS __STL_MINIMUM_DEFAULT_TEMPLATE_PARAMS
+#endif
+#if defined (__STL_NO_OWN_NAMESPACE) && !defined (_STLP_NO_OWN_NAMESPACE)
+# define _STLP_NO_OWN_NAMESPACE __STL_NO_OWN_NAMESPACE
+#endif
+
+#if defined (__STL_NO_RELOPS_NAMESPACE) && !defined (_STLP_NO_RELOPS_NAMESPACE)
+# define _STLP_NO_RELOPS_NAMESPACE __STL_NO_RELOPS_NAMESPACE
+#endif
+
+#if defined (__STL_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_UNINITIALIZED)
+# define _STLP_DEBUG_UNINITIALIZED __STL_DEBUG_UNINITIALIZED
+#endif
+#if defined (__STL_SHRED_BYTE) && !defined (_STLP_SHRED_BYTE)
+# define _STLP_SHRED_BYTE __STL_SHRED_BYTE
+#endif
+#if defined (__STL_USE_MFC) && !defined (_STLP_USE_MFC)
+# define _STLP_USE_MFC __STL_USE_MFC
+#endif
+
+#if defined (__STL_USE_NEWALLOC) && !defined (_STLP_USE_NEWALLOC)
+# define _STLP_USE_NEWALLOC __STL_USE_NEWALLOC
+#endif
+#if defined (__STL_USE_MALLOC) && !defined (_STLP_USE_MALLOC)
+# define _STLP_USE_MALLOC __STL_USE_MALLOC
+#endif
+
+#if defined (__STL_DEBUG_ALLOC) && !defined (_STLP_DEBUG_ALLOC)
+# define _STLP_DEBUG_ALLOC __STL_DEBUG_ALLOC
+#endif
+
+#if defined (__STL_DEBUG_MESSAGE) && !defined (_STLP_DEBUG_MESSAGE)
+# define _STLP_DEBUG_MESSAGE __STL_DEBUG_MESSAGE
+#endif
+
+#if defined (__STL_DEBUG_TERMINATE) && !defined (_STLP_DEBUG_TERMINATE)
+# define _STLP_DEBUG_TERMINATE __STL_DEBUG_TERMINATE
+#endif
+
+#if defined (__STL_USE_ABBREVS) && !defined (_STLP_USE_ABBREVS)
+# define _STLP_USE_ABBREVS __STL_USE_ABBREVS
+#endif
+
+#if defined (__STL_NO_MSVC50_COMPATIBILITY) && !defined (_STLP_NO_MSVC50_COMPATIBILITY)
+# define _STLP_NO_MSVC50_COMPATIBILITY __STL_NO_MSVC50_COMPATIBILITY
+#endif
+
+/* STLport do not support anymore the iostream wrapper mode so this macro should
+ * always been define for other libraries that was using it:
+ */
+#if !defined (_STLP_OWN_IOSTREAMS)
+# define _STLP_OWN_IOSTREAMS
+#endif
+
+#if defined (_STLP_NO_OWN_IOSTREAMS)
+# error STLport do not support anymore the wrapper mode. If you want to use STLport \
+use its iostreams implementation or no iostreams at all.
+#endif
diff --git a/sources/android/stlport/stlport/stl/config/features.h b/sources/android/stlport/stlport/stl/config/features.h
new file mode 100644
index 0000000..b5b4e3a
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/features.h
@@ -0,0 +1,1079 @@
+ /*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_FEATURES_H
+#define _STLP_FEATURES_H
+
+/*
+ * Purpose of this file:
+ *
+ * Defines all STLport settings.
+ * This file is actually a wrapper : it includes compiler-specific
+ * settings from <config/stlcomp.h>
+ * and user-defined settings from <config/user_config.h>.
+ * See <config/stl_mycomp.h> and <config/user_config.h> for the description
+ * of those macros
+ *
+ */
+
+/* Definition of the STLport version informations */
+#include <stl/_stlport_version.h>
+
+/* Other macros defined by this file:
+
+ * bool, true, and false, if _STLP_NO_BOOL is defined.
+ * typename, as a null macro if it's not already a keyword.
+ * explicit, as a null macro if it's not already a keyword.
+ * namespace-related macros (_STLP_STD, _STLP_BEGIN_NAMESPACE, etc.)
+ * exception-related macros (_STLP_TRY, _STLP_UNWIND, etc.)
+ * _STLP_ASSERT, either as a test or as a null macro, depending on
+ whether or not _STLP_ASSERTIONS is defined.
+*/
+
+/* Definition of the 2 STLport debug levels */
+#define _STLP_STLPORT_DBG_LEVEL 1
+#define _STLP_STANDARD_DBG_LEVEL 2
+
+/* Placeholder for user to override settings.
+ * It could be also used to mask settings from
+ * different directories.
+ */
+#include <stl/config/user_config.h>
+
+#if defined (_STLP_DEBUG) && !defined (_STLP_DEBUG_LEVEL)
+# define _STLP_DEBUG_LEVEL _STLP_STLPORT_DBG_LEVEL
+#endif
+
+#if defined (__BUILDING_STLPORT)
+/* For the STLport implementation we can use everything:
+ */
+# if defined (_STLP_NO_ANACHRONISMS)
+# undef _STLP_NO_ANACHRONISMS
+# endif
+# if defined (_STLP_NO_EXTENSIONS)
+# undef _STLP_NO_EXTENSIONS
+# endif
+/* Moreover there are things that have no sens:
+ */
+# if defined (_STLP_NO_IOSTREAMS)
+# error If you do not use iostreams you do not need to build the STLport library.
+# endif
+#endif
+
+/* ========================================================= */
+/* This file is used for compatibility; it accepts old-style config
+ switches */
+#include <stl/config/compat.h>
+
+/* Common configuration file for this particular installation. */
+#include <stl/config/host.h>
+
+/* Operational Environment specific */
+#include <stl/config/_system.h>
+
+/* ========================================================= */
+
+/* some fixes to configuration. This also includes modifications
+ * of STLport switches depending on compiler flags,
+ * or settings applicable to a group of compilers, such as
+ * to all who use EDG front-end.
+ */
+#include <stl/config/stl_confix.h>
+
+#if !defined (_STLP_NO_MEMBER_TEMPLATES) && !defined (_STLP_MEMBER_TEMPLATES)
+# define _STLP_MEMBER_TEMPLATES 1
+#endif
+
+#if !defined (_STLP_NO_MEMBER_TEMPLATE_CLASSES) && !defined (_STLP_MEMBER_TEMPLATE_CLASSES)
+# define _STLP_MEMBER_TEMPLATE_CLASSES 1
+#endif
+
+#if defined (_STLP_NO_MEMBER_TEMPLATE_CLASSES) && !defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)
+# define _STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE 1
+#endif
+
+#if !defined (_STLP_NO_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+# define _STLP_CLASS_PARTIAL_SPECIALIZATION 1
+#endif
+
+#if !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) && !defined (_STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER)
+# define _STLP_FUNCTION_TMPL_PARTIAL_ORDER 1
+#endif
+
+#if !defined (_STLP_DONT_USE_SHORT_STRING_OPTIM) && !defined (_STLP_USE_SHORT_STRING_OPTIM)
+# define _STLP_USE_SHORT_STRING_OPTIM 1
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES) && !defined (_STLP_NO_EXTENSIONS) && \
+ !defined (_STLP_NO_CONTAINERS_EXTENSION) && !defined (_STLP_USE_CONTAINERS_EXTENSION)
+# define _STLP_USE_CONTAINERS_EXTENSION
+#endif
+
+#if defined (_STLP_USE_CONTAINERS_EXTENSION)
+# define _STLP_TEMPLATE_FOR_CONT_EXT template <class _KT>
+#else
+# define _STLP_TEMPLATE_FOR_CONT_EXT
+#endif
+
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS) && \
+ (defined (_STLP_NO_CLASS_PARTIAL_SPECIALIZATION) && defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS))
+# error Sorry but according the STLport settings your compiler can not support the pointer specialization feature.
+#endif
+
+#if defined (_STLP_WHOLE_NATIVE_STD) && defined (_STLP_NO_OWN_NAMESPACE)
+# error Sorry but asking for both STLport to be in the real std namespace and also having STLport import all native std stuff \
+ is invalid, chose one or none.
+#endif
+
+#if defined (_STLP_VERBOSE) && !defined (_STLP_VERBOSE_MODE_SUPPORTED)
+# error Sorry but the verbose mode is not implemented for your compiler.
+#endif
+
+#if defined (_STLP_NO_IOSTREAMS) && \
+ !defined (_STLP_USE_NEWALLOC) && !defined (_STLP_USE_MALLOC)
+# define _STLP_USE_NEWALLOC
+#endif
+
+#if !defined (_STLP_BIG_ENDIAN) && !defined (_STLP_LITTLE_ENDIAN)
+# if defined (_MIPSEB) || defined (__sparc) || defined (_AIX) || \
+ defined (__hpux) || defined (macintosh) || defined (_MAC)
+# define _STLP_BIG_ENDIAN 1
+# elif defined (__i386) || defined (_M_IX86) || defined (_M_ARM) || \
+ defined (__amd64__) || defined (_M_AMD64) || defined (__x86_64__) || \
+ defined (__alpha__)
+# define _STLP_LITTLE_ENDIAN 1
+# elif defined (__ia64__)
+ /* itanium allows both settings (for instance via gcc -mbig-endian) - hence a seperate check is required */
+# if defined (__BIG_ENDIAN__)
+# define _STLP_BIG_ENDIAN 1
+# else
+# define _STLP_LITTLE_ENDIAN 1
+# endif
+# else
+# error "can't determine endianess"
+# endif
+#endif /* _STLP_BIG_ENDIAN */
+
+/* ==========================================================
+ * final workaround tuning based on given flags
+ * ========================================================== */
+
+#ifndef _STLP_UINT32_T
+# define _STLP_UINT32_T unsigned long
+#endif
+#ifndef _STLP_ABORT
+# define _STLP_ABORT() abort()
+#endif
+
+#if !defined (_STLP_HAS_NO_NAMESPACES)
+# if defined _STLP_NO_NAMESPACES
+# undef _STLP_USE_NAMESPACES
+# else
+/* assume it as the default, turn it off later if NO_NAMESPACES selected */
+# undef _STLP_USE_NAMESPACES
+# define _STLP_USE_NAMESPACES 1
+# endif
+#endif
+
+#if defined (_STLP_NO_IOSTREAMS)
+# define _STLP_USE_NO_IOSTREAMS
+#endif
+
+/* Operating system recognition (basic) */
+#if (defined(__unix) || defined(__linux__) || defined(__QNX__) || defined(_AIX) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__Lynx__) || defined(__hpux) || defined(__sgi)) && \
+ !defined (_STLP_UNIX)
+# define _STLP_UNIX 1
+#endif /* __unix */
+
+#if !defined (_STLP_NO_LONG_DOUBLE)
+# define _STLP_LONGEST_FLOAT_TYPE long double
+#else
+# define _STLP_LONGEST_FLOAT_TYPE double
+#endif
+
+/* Native headers access macros */
+#if !defined (_STLP_HAS_INCLUDE_NEXT)
+# include <stl/config/_native_headers.h>
+#endif
+
+/* shared library tune-up */
+
+#if defined (__BUILDING_STLPORT)
+/* if we are rebuilding right now, place everything here */
+# undef _STLP_DESIGNATED_DLL
+# define _STLP_DESIGNATED_DLL 1
+#endif
+
+/* Use own namespace always if possible and not explicitly instructed otherwise */
+#if defined (_STLP_USE_NAMESPACES) && !defined (_STLP_BROKEN_USING_DIRECTIVE) && \
+ !defined (_STLP_NO_OWN_NAMESPACE)
+# undef _STLP_USE_OWN_NAMESPACE
+# define _STLP_USE_OWN_NAMESPACE 1
+#else
+# undef _STLP_WHOLE_NATIVE_STD
+#endif
+
+#if !defined (_NOTHREADS) && !defined (_STLP_THREADS_DEFINED)
+
+# if defined (_PTHREADS)
+# define _STLP_PTHREADS
+# define _STLP_THREADS
+# endif
+# if defined (_UITHREADS)
+# define _STLP_UITHREADS
+# define _STLP_THREADS
+# endif
+
+# if defined (_STLP_WIN32) && !defined (_STLP_PTHREADS)
+# define _STLP_WIN32THREADS 1
+# elif ((defined (__sun) && !defined (__linux__)) || defined (_UITHREADS) ) && \
+ !defined(_STLP_PTHREADS)
+# define _STLP_UITHREADS
+# else
+# define _STLP_PTHREADS
+# endif /* __sgi */
+# define _STLP_THREADS_DEFINED
+#endif
+
+#if (defined (_REENTRANT) || defined (_THREAD_SAFE)) && !defined (_STLP_THREADS)
+# define _STLP_THREADS
+#endif
+
+#ifndef _STLP_STATIC_MUTEX
+# define _STLP_STATIC_MUTEX _STLP_mutex_base
+#endif
+
+#if (defined (_MFC_VER) || defined (_AFXDLL)) && !defined (_STLP_USE_MFC)
+# define _STLP_USE_MFC 1
+#endif
+
+#if defined (_STLP_THREADS)
+# define _STLP_VOLATILE volatile
+#else
+# define _STLP_VOLATILE
+#endif
+
+#if !defined (_STLP_USE_NEW_C_HEADERS) && !defined (_STLP_HAS_NO_NEW_C_HEADERS)
+# define _STLP_USE_NEW_C_HEADERS
+#endif
+/* disable new-style headers if requested */
+#if defined (_STLP_NO_NEW_C_HEADERS)
+# undef _STLP_USE_NEW_C_HEADERS
+#endif
+
+#if defined (_STLP_BASE_TYPEDEF_BUG)
+# undef _STLP_BASE_TYPEDEF_OUTSIDE_BUG
+# define _STLP_BASE_TYPEDEF_OUTSIDE_BUG 1
+#endif
+
+#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+# define _STLP_GLOBAL_NESTED_RETURN_TYPE_PARAM_BUG
+#endif
+
+/* SUNpro 4.2 inline string literal bug */
+#ifdef _STLP_INLINE_STRING_LITERAL_BUG
+# define _STLP_FIX_LITERAL_BUG(__x) __x = __x;
+#else
+# define _STLP_FIX_LITERAL_BUG(__x)
+#endif
+
+#if defined (_STLP_NON_TYPE_TMPL_PARAM_BUG)
+# undef _STLP_NO_DEFAULT_NON_TYPE_PARAM
+# define _STLP_NO_DEFAULT_NON_TYPE_PARAM 1
+#endif
+
+#if !defined (_STLP_STATIC_ASSERT)
+/* Some compiler support 0 size array so we use negative size array to generate
+ * a compilation time error.
+ */
+# define _STLP_STATIC_ASSERT(expr) typedef char __static_assert[expr ? 1 : -1];
+#endif
+
+/* apple mpw exception handling bug */
+#ifndef _STLP_MPWFIX_TRY
+# define _STLP_MPWFIX_TRY
+#endif
+#ifndef _STLP_MPWFIX_CATCH
+# define _STLP_MPWFIX_CATCH
+#endif
+#ifndef _STLP_MPWFIX_CATCH_ACTION
+# define _STLP_MPWFIX_CATCH_ACTION(action)
+#endif
+
+#if !defined (_STLP_WEAK)
+# define _STLP_WEAK
+#endif
+
+/* default parameters as template types derived from arguments ( not always supported ) */
+#if defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+# define _STLP_DFL_TMPL_PARAM( classname, defval ) class classname
+#else
+# if !defined (_STLP_DEFAULT_TYPE_PARAM)
+# define _STLP_DEFAULT_TYPE_PARAM 1
+# endif
+# define _STLP_DFL_TMPL_PARAM( classname, defval ) class classname = defval
+#endif
+
+#if defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+# define _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_Key, _Tp ) class _Alloc
+#else
+# define _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_Key, _Tp ) \
+ class _Alloc = allocator< pair < _Key, _Tp > >
+#endif
+
+/* default parameters as complete types */
+#if defined (_STLP_DEFAULT_TYPE_PARAM)
+# define _STLP_DFL_TYPE_PARAM( classname, defval ) class classname = defval
+# define _STLP_DFL_NON_TYPE_PARAM(type,name,val) type name = val
+#else
+# define _STLP_DFL_TYPE_PARAM( classname, defval ) class classname
+# define _STLP_DFL_NON_TYPE_PARAM(type,name,val) type name
+#endif
+
+/* SGI compatibility */
+
+#ifdef _STLP_NO_WCHAR_T
+# ifndef _STLP_NO_NATIVE_WIDE_STREAMS
+# define _STLP_NO_NATIVE_WIDE_STREAMS 1
+# endif
+#else
+# define _STLP_HAS_WCHAR_T 1
+#endif
+
+#if !defined (_STLP_NO_AT_MEMBER_FUNCTION)
+# define _STLP_CAN_THROW_RANGE_ERRORS 1
+#endif
+
+/* debug mode tool */
+#if defined (_STLP_DEBUG)
+# define _STLP_NON_DBG_NAME(X) _NonDbg_##X
+#endif
+
+/* pointer specialization tool */
+#if defined (_STLP_USE_PTR_SPECIALIZATIONS)
+# define _STLP_PTR_IMPL_NAME(X) _Impl_##X
+#endif
+
+#if defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND) || \
+ defined (_STLP_SIGNAL_RUNTIME_COMPATIBILITY) || defined (_STLP_CHECK_RUNTIME_COMPATIBILITY)
+# define _STLP_NO_MEM_T_NAME(X) _NoMemT_##X
+#endif
+
+/* this always mean the C library is in global namespace */
+#if defined (_STLP_HAS_NO_NEW_C_HEADERS) && !defined (_STLP_VENDOR_GLOBAL_CSTD)
+# define _STLP_VENDOR_GLOBAL_CSTD 1
+#endif
+
+/* Depending of whether compiler supports namespaces,
+ * tune the parameters for vendor-supplied libraries.
+ * This section is guarded by _STLP_HAS_NO_NAMESPACES, not by _STLP_USE_NAMESPACES,
+ * since it depends only on the native features, not on user's preference whether
+ * to use namespace for STLport or not.
+ */
+#if !defined (_STLP_HAS_NO_NAMESPACES)
+/* Import some vendor's headers into corresponding STLport ones if they might be needed
+ * (if we wrap native iostreams and use namepace other than std::) */
+# if defined (_STLP_WHOLE_NATIVE_STD)
+# define _STLP_IMPORT_VENDOR_STD 1
+# endif
+
+/* if using stlport:: namespace or if C library stuff is not in vendor's std::,
+ * try importing 'em.
+ * MSVC has ambiguity problem when we try to import C-style std:: stuff back into global namespace */
+# if defined (_STLP_USE_NAMESPACES) && (defined(_STLP_USE_OWN_NAMESPACE) || defined (_STLP_VENDOR_GLOBAL_CSTD))
+# define _STLP_IMPORT_VENDOR_CSTD 1
+# endif
+
+# if defined (_STLP_NO_USING_FOR_GLOBAL_FUNCTIONS) && !defined (_STLP_DO_IMPORT_CSTD_FUNCTIONS)
+# define _STLP_NO_CSTD_FUNCTION_IMPORTS
+# endif
+
+# define _STLP_USING_NAMESPACE(x) using namespace x ;
+
+namespace std { }
+namespace __std_alias = std;
+
+/* assume std:: namespace for C++ std library if not being told otherwise */
+# if defined (_STLP_VENDOR_GLOBAL_STD)
+# define _STLP_VENDOR_STD
+# else
+# define _STLP_VENDOR_STD std
+# endif
+
+/* tune things that come from C library */
+# if defined (_STLP_VENDOR_GLOBAL_CSTD) || !defined(_STLP_USE_NEW_C_HEADERS)
+/* in old-style headers, C functions go to global scope. */
+# define _STLP_VENDOR_CSTD
+# define _STLP_USING_VENDOR_CSTD
+# else
+# define _STLP_VENDOR_CSTD _STLP_VENDOR_STD
+# define _STLP_USING_VENDOR_CSTD _STLP_USING_NAMESPACE(_STLP_VENDOR_CSTD)
+# endif /* _STLP_VENDOR_CSTD */
+/* exception, typeinfo, new - always come from the vendor */
+# if !defined (_STLP_VENDOR_EXCEPT_STD)
+# if defined (_STLP_VENDOR_GLOBAL_EXCEPT_STD)
+# define _STLP_VENDOR_EXCEPT_STD
+# else
+# define _STLP_VENDOR_EXCEPT_STD _STLP_VENDOR_STD
+# endif
+# endif
+# define _STLP_OLD_IO_NAMESPACE
+# if !defined (_STLP_VENDOR_MB_NAMESPACE)
+# define _STLP_VENDOR_MB_NAMESPACE _STLP_VENDOR_CSTD
+# endif
+#else
+/* compiler has no namespace support */
+# define _STLP_VENDOR_STD
+# define _STLP_VENDOR_CSTD
+# define _STLP_USING_NAMESPACE(x)
+# define _STLP_USING_VENDOR_CSTD
+# define _STLP_VENDOR_EXCEPT_STD
+#endif
+
+#if defined (_STLP_USE_NAMESPACES)
+
+# if defined (_STLP_USE_OWN_NAMESPACE)
+# if !defined (_STLP_STD_NAME)
+# if !defined (_STLP_DEBUG)
+# if !defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB)
+# ifndef _STLP_THREADS
+# define _STLP_STD_NAME stlpmtx_std
+# else
+# define _STLP_STD_NAME stlp_std
+# endif
+# else
+# ifndef _STLP_THREADS
+# define _STLP_STD_NAME stlpxmtx_std
+# else
+# define _STLP_STD_NAME stlpx_std
+# endif
+# endif
+# else
+/*
+ * The STLport debug mode is binary incompatible with the other modes,
+ * lets make it clear on the STLport namespace to generate link errors rather
+ * than runtime ones.
+ */
+# if !defined (_STLP_USING_CROSS_NATIVE_RUNTIME_LIB)
+# ifndef _STLP_THREADS
+# define _STLP_STD_NAME stlpdmtx_std
+# else
+# define _STLP_STD_NAME stlpd_std
+# endif
+# else
+# ifndef _STLP_THREADS
+# define _STLP_STD_NAME stlpdxmtx_std
+# else
+# define _STLP_STD_NAME stlpdx_std
+# endif
+# endif
+# endif
+# endif
+namespace _STLP_STD_NAME { }
+# else
+# define _STLP_STD_NAME std
+# endif /* _STLP_USE_OWN_NAMESPACE */
+
+# define _STLP_BEGIN_NAMESPACE namespace _STLP_STD_NAME {
+# define _STLP_BEGIN_TR1_NAMESPACE namespace tr1 {
+# define _STLP_END_NAMESPACE }
+
+/* decide whether or not we use separate namespace for rel ops */
+# if defined (_STLP_NO_RELOPS_NAMESPACE)
+# define _STLP_BEGIN_RELOPS_NAMESPACE _STLP_BEGIN_NAMESPACE namespace rel_ops {}
+# define _STLP_END_RELOPS_NAMESPACE }
+# else
+/* Use std::rel_ops namespace */
+# define _STLP_BEGIN_RELOPS_NAMESPACE _STLP_BEGIN_NAMESPACE namespace rel_ops {
+# define _STLP_END_RELOPS_NAMESPACE } }
+# define _STLP_USE_SEPARATE_RELOPS_NAMESPACE
+# endif /* Use std::rel_ops namespace */
+
+# define _STLP_STD ::_STLP_STD_NAME
+# if !defined (_STLP_TR1)
+# define _STLP_TR1 _STLP_STD::tr1::
+# endif
+
+# if !defined (_STLP_DONT_USE_PRIV_NAMESPACE)
+# define _STLP_PRIV_NAME priv
+# define _STLP_PRIV _STLP_STD::_STLP_PRIV_NAME::
+# define _STLP_MOVE_TO_PRIV_NAMESPACE namespace _STLP_PRIV_NAME {
+# define _STLP_MOVE_TO_STD_NAMESPACE }
+# else
+# if !defined (_STLP_PRIV)
+# define _STLP_PRIV _STLP_STD::
+# endif
+# define _STLP_MOVE_TO_PRIV_NAMESPACE
+# define _STLP_MOVE_TO_STD_NAMESPACE
+# endif
+
+/* Official STLport namespace when std is not redefined.
+ * Here we don't use a macro because we do not need it and because
+ * stlport is used as file name by boost and folder name under beos:
+ */
+namespace stlport = _STLP_STD_NAME;
+
+/* Backward compatibility:
+ */
+namespace _STL = _STLP_STD_NAME;
+#undef __STLPORT_NAMESPACE
+#define __STLPORT_NAMESPACE _STLP_STD_NAME
+
+#else /* _STLP_USE_NAMESPACES */
+/* STLport is being put into global namespace */
+# define _STLP_STD
+# define _STLP_PRIV
+# define _STLP_TR1
+# define _STLP_BEGIN_NAMESPACE
+# define _STLP_BEGIN_TR1_NAMESPACE
+# define _STLP_END_NAMESPACE
+# define _STLP_MOVE_TO_PRIV_NAMESPACE
+# define _STLP_MOVE_TO_STD_NAMESPACE
+
+/* boris : it was found out that _STLP_USE_SEPARATE_RELOPS_NAMESPACE
+ causes less problems than having relational operator templates in global namespace
+ Please define _STLP_NO_RELOPS_NAMESPACE in config/user_config.h if your code rely on them. */
+# if !defined (_STLP_NO_RELOPS_NAMESPACE)
+# define _STLP_USE_SEPARATE_RELOPS_NAMESPACE
+# endif
+# define _STLP_BEGIN_RELOPS_NAMESPACE
+# define _STLP_END_RELOPS_NAMESPACE
+# undef _STLP_USE_OWN_NAMESPACE
+#endif /* _STLP_USE_NAMESPACES */
+
+#define STLPORT_CSTD _STLP_VENDOR_CSTD
+#define STLPORT _STLP_STD_NAME
+
+#if defined(_STLP_BOGUS_TEMPLATE_TYPE_MATCHING_BUG)
+# define _STLP_SIMPLE_TYPE(T) _stl_trivial_proxy<T>
+#else
+# define _STLP_SIMPLE_TYPE(T) T
+#endif
+
+#ifndef _STLP_RAND48
+# define _STLP_NO_DRAND48
+#endif
+
+/* advanced keywords usage */
+#define __C_CAST(__x, __y) ((__x)(__y))
+#ifndef _STLP_NO_NEW_STYLE_CASTS
+# define __CONST_CAST(__x,__y) const_cast<__x>(__y)
+# define __STATIC_CAST(__x,__y) static_cast<__x>(__y)
+# define __REINTERPRET_CAST(__x,__y) reinterpret_cast<__x>(__y)
+#else
+# define __STATIC_CAST(__x,__y) __C_CAST(__x, __y)
+# define __CONST_CAST(__x,__y) __C_CAST(__x, __y)
+# define __REINTERPRET_CAST(__x,__y) __C_CAST(__x, __y)
+#endif
+
+#if defined (_STLP_NEED_TYPENAME) && ! defined (typename)
+# define typename
+#endif
+
+#if defined (_STLP_NEED_TYPENAME) || defined (_STLP_NO_TYPENAME_ON_RETURN_TYPE )
+# define _STLP_TYPENAME_ON_RETURN_TYPE
+#else
+# define _STLP_TYPENAME_ON_RETURN_TYPE typename
+#endif
+
+#ifdef _STLP_NO_TYPENAME_IN_TEMPLATE_HEADER
+# define _STLP_HEADER_TYPENAME
+#else
+# define _STLP_HEADER_TYPENAME typename
+#endif
+
+#ifdef _STLP_NO_TYPENAME_BEFORE_NAMESPACE
+# define _STLP_TYPENAME
+#else
+# define _STLP_TYPENAME typename
+#endif
+
+#ifndef _STLP_NO_MEMBER_TEMPLATE_KEYWORD
+# define _STLP_TEMPLATE template
+#else
+# define _STLP_TEMPLATE
+#endif
+
+#if defined (_STLP_USE_CONTAINERS_EXTENSION)
+# define _STLP_KEY_TYPE_FOR_CONT_EXT(type)
+# define _STLP_TEMPLATE_FOR_CONT_EXT template <class _KT>
+#else
+# define _STLP_KEY_TYPE_FOR_CONT_EXT(type) typedef type _KT;
+# define _STLP_TEMPLATE_FOR_CONT_EXT
+#endif
+
+#if defined (_STLP_NEED_EXPLICIT) && !defined (explicit)
+# define explicit
+#endif
+
+#if !defined (_STLP_NEED_MUTABLE)
+# define _STLP_MUTABLE(type, x) x
+#else
+# define _STLP_MUTABLE(type, x) __CONST_CAST(type*, this)->x
+# define mutable
+#endif
+
+#if defined (_STLP_NO_SIGNED_BUILTINS)
+/* old HP-UX doesn't understand "signed" keyword */
+# define signed
+#endif
+
+#if defined (_STLP_LOOP_INLINE_PROBLEMS)
+# define _STLP_INLINE_LOOP
+#else
+# define _STLP_INLINE_LOOP inline
+#endif
+
+#ifndef _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX
+# define _STLP_TEMPLATE_NULL template<>
+#else
+# define _STLP_TEMPLATE_NULL
+#endif
+
+#ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER
+# define _STLP_OPERATOR_TEMPLATE
+#else
+# define _STLP_OPERATOR_TEMPLATE _STLP_TEMPLATE_NULL
+#endif
+
+#ifndef _STLP_CLASS_PARTIAL_SPECIALIZATION
+/* unless we have other compiler problem, try simulating partial spec here */
+# if !defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS)
+# define _STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS
+# endif
+/* For your own iterators, please use inheritance from iterator<> instead of these obsolete queries. */
+# if (defined (_STLP_NESTED_TYPE_PARAM_BUG) || !defined (_STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS))
+# if ! defined ( _STLP_USE_OLD_HP_ITERATOR_QUERIES )
+# define _STLP_USE_OLD_HP_ITERATOR_QUERIES
+# endif
+# elif defined ( _STLP_NO_ANACHRONISMS )
+# undef _STLP_USE_OLD_HP_ITERATOR_QUERIES
+# endif
+#endif
+
+#ifndef _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS
+# define _STLP_NULL_TMPL_ARGS <>
+# else
+# define _STLP_NULL_TMPL_ARGS
+#endif
+
+#if !defined (_STLP_ALLOCATOR_TYPE_DFL)
+# if defined (_STLP_DONT_SUP_DFLT_PARAM)
+# define _STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS
+# endif
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+# define _STLP_ALLOCATOR_TYPE_DFL
+# else
+# define _STLP_ALLOCATOR_TYPE_DFL = allocator_type()
+# endif
+#endif
+
+/* When the compiler do not correctly initialized the basic types value in default parameters we prefer
+ * to avoid them to be able to correct this bug.
+ */
+#if defined (_STLP_DEF_CONST_DEF_PARAM_BUG)
+# define _STLP_DONT_SUP_DFLT_PARAM 1
+#endif
+
+#if defined (__SGI_STL_NO_ARROW_OPERATOR) && ! defined (_STLP_NO_ARROW_OPERATOR)
+# define _STLP_NO_ARROW_OPERATOR
+#endif
+
+#if !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+# if !(defined (_STLP_NO_ARROW_OPERATOR)) && \
+ !defined (_STLP_NO_MSVC50_COMPATIBILITY) && !defined (_STLP_MSVC50_COMPATIBILITY)
+/* this one is needed for proper reverse_iterator<> operator ->() handling */
+# define _STLP_MSVC50_COMPATIBILITY 1
+# endif
+#endif
+
+#if defined ( _STLP_CLASS_PARTIAL_SPECIALIZATION )
+# if (defined(__IBMCPP__) && (500 <= __IBMCPP__) && (__IBMCPP__ < 600) )
+# define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \
+ typedef typename _STLP_STD :: reverse_iterator<const_iterator> const_reverse_iterator; \
+ typedef typename _STLP_STD :: reverse_iterator<iterator> reverse_iterator
+# elif (defined (__sgi) && ! defined (__GNUC__)) || defined (__SUNPRO_CC) || defined (__xlC__)
+# define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \
+ typedef _STLP_STD:: _STLP_TEMPLATE reverse_iterator<const_iterator> const_reverse_iterator; \
+ typedef _STLP_STD:: _STLP_TEMPLATE reverse_iterator<iterator> reverse_iterator
+# else
+# define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \
+ typedef _STLP_STD::reverse_iterator<const_iterator> const_reverse_iterator; \
+ typedef _STLP_STD::reverse_iterator<iterator> reverse_iterator
+# endif
+#else /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+# if defined (_STLP_MSVC50_COMPATIBILITY)
+# define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \
+ typedef _STLP_STD::__reverse_iterator<const_iterator, value_type, const_reference, \
+ const_pointer, difference_type> const_reverse_iterator; \
+ typedef _STLP_STD::__reverse_iterator<iterator, value_type, reference, pointer, difference_type> \
+ reverse_iterator
+# else
+# define _STLP_DECLARE_REVERSE_ITERATORS(__reverse_iterator) \
+ typedef _STLP_STD::__reverse_iterator<const_iterator, value_type, const_reference, \
+ difference_type> const_reverse_iterator; \
+ typedef _STLP_STD::__reverse_iterator<iterator, value_type, \
+ reference, difference_type> \
+ reverse_iterator
+# endif
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+#define _STLP_DECLARE_BIDIRECTIONAL_REVERSE_ITERATORS \
+ _STLP_DECLARE_REVERSE_ITERATORS(reverse_bidirectional_iterator)
+#define _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS \
+ _STLP_DECLARE_REVERSE_ITERATORS(reverse_iterator)
+
+#define __IMPORT_CONTAINER_TYPEDEFS(_Super) \
+ typedef typename _Super::value_type value_type; \
+ typedef typename _Super::size_type size_type; \
+ typedef typename _Super::difference_type difference_type; \
+ typedef typename _Super::reference reference; \
+ typedef typename _Super::const_reference const_reference; \
+ typedef typename _Super::pointer pointer; \
+ typedef typename _Super::const_pointer const_pointer; \
+ typedef typename _Super::allocator_type allocator_type;
+
+
+#define __IMPORT_ITERATORS(_Super) \
+ typedef typename _Super::iterator iterator; \
+ typedef typename _Super::const_iterator const_iterator;
+
+#define __IMPORT_REVERSE_ITERATORS(_Super) \
+ typedef typename _Super::const_reverse_iterator const_reverse_iterator; \
+ typedef typename _Super::reverse_iterator reverse_iterator;
+
+#define __IMPORT_SUPER_COPY_ASSIGNMENT(__derived_name, _Self, _SUPER) \
+ __derived_name(const _Super& __x) : _SUPER(__x) {} \
+ _Self& operator=(const _Super& __x) { \
+ *(_Super*)this = __x; \
+ return *this; \
+ } \
+ __derived_name(const _Self& __x) : _SUPER(__x) {} \
+ _Self& operator=(const _Self& __x) { \
+ *(_Super*)this = __x; \
+ return *this; \
+ }
+
+#define __IMPORT_WITH_ITERATORS(_Super) \
+ __IMPORT_CONTAINER_TYPEDEFS(_Super) __IMPORT_ITERATORS(_Super)
+
+#define __IMPORT_WITH_REVERSE_ITERATORS(_Super) \
+ __IMPORT_WITH_ITERATORS(_Super) __IMPORT_REVERSE_ITERATORS(_Super)
+
+#if defined (_STLP_TRIVIAL_CONSTRUCTOR_BUG)
+# define __TRIVIAL_CONSTRUCTOR(__type) __type() {}
+#else
+# define __TRIVIAL_CONSTRUCTOR(__type)
+#endif
+
+#if defined (_STLP_TRIVIAL_DESTRUCTOR_BUG)
+# define __TRIVIAL_DESTRUCTOR(__type) ~__type() {}
+#else
+# define __TRIVIAL_DESTRUCTOR(__type)
+#endif
+
+#define __TRIVIAL_STUFF(__type) \
+ __TRIVIAL_CONSTRUCTOR(__type) __TRIVIAL_DESTRUCTOR(__type)
+
+#if defined (_STLP_STATIC_CONST_INIT_BUG)
+# define _STLP_STATIC_CONSTANT(__type, __assignment) enum { __assignment }
+#else
+# define _STLP_STATIC_CONSTANT(__type, __assignment) static const __type __assignment
+#endif
+
+#if defined (_STLP_HAS_NO_EXCEPTIONS)
+# define _STLP_NO_EXCEPTIONS
+#endif
+
+#if !defined (_STLP_DONT_USE_EXCEPTIONS) && !defined (_STLP_NO_EXCEPTIONS) && !defined (_STLP_USE_EXCEPTIONS)
+# define _STLP_USE_EXCEPTIONS
+#endif
+
+#if defined (_STLP_USE_EXCEPTIONS)
+# define _STLP_TRY try
+# define _STLP_CATCH_ALL catch(...)
+# ifndef _STLP_THROW
+# define _STLP_THROW(x) throw x
+# endif
+# define _STLP_RETHROW throw
+
+# define _STLP_UNWIND(action) catch(...) { action; throw; }
+
+# ifdef _STLP_THROW_RETURN_BUG
+# define _STLP_RET_AFTER_THROW(data) return data;
+# else
+# define _STLP_RET_AFTER_THROW(data)
+# endif
+
+# if !defined (_STLP_THROWS)
+# define _STLP_THROWS(x) throw(x)
+# endif
+# if !defined (_STLP_NOTHROW)
+# define _STLP_NOTHROW throw()
+# endif
+#else
+# define _STLP_TRY
+# define _STLP_CATCH_ALL if (false)
+# ifndef _STLP_THROW
+# define _STLP_THROW(x)
+# endif
+# define _STLP_RETHROW {}
+# define _STLP_UNWIND(action)
+# define _STLP_THROWS(x)
+# define _STLP_NOTHROW
+# define _STLP_RET_AFTER_THROW(data)
+#endif
+
+/*
+ * Here we check _STLP_NO_EXCEPTIONS which means that the compiler has no
+ * exception support but not the _STLP_USE_EXCEPTIONS which simply means
+ * that the user do not want to use them.
+ */
+#if !defined (_STLP_NO_EXCEPTIONS) && !defined (_STLP_NO_EXCEPTION_SPEC)
+# define _STLP_THROWS_INHERENTLY(x) throw x
+# define _STLP_NOTHROW_INHERENTLY throw()
+#else
+# define _STLP_THROWS_INHERENTLY(x)
+# define _STLP_NOTHROW_INHERENTLY
+#endif
+
+/* STLport function not returning are functions that throw so we translate
+ * the noreturn functions in throwing functions taking also into account
+ * exception support activation.
+ */
+#if defined (_STLP_NORETURN_FUNCTION) && !defined (_STLP_NO_EXCEPTIONS) && \
+ !defined (_STLP_FUNCTION_THROWS)
+# define _STLP_FUNCTION_THROWS _STLP_NORETURN_FUNCTION
+#else
+# define _STLP_FUNCTION_THROWS
+#endif
+
+#if defined(_STLP_NO_BOOL)
+# if (defined (__IBMCPP__) && (__IBMCPP__ < 400)) && ! defined (_AIX)
+# include <isynonym.hpp>
+# if defined (__OS400__)
+typedef int bool;
+# elif !( defined (__xlC__) || defined (_AIX))
+typedef Boolean bool;
+# endif
+# else
+# if defined(_STLP_YVALS_H)
+# include <yvals.h>
+# else
+# if defined (_STLP_DONT_USE_BOOL_TYPEDEF)
+# define bool int
+# else
+typedef int bool;
+# endif
+# define true 1
+# define false 0
+# endif
+# endif /* __IBMCPP__ */
+#else
+# define _STLP_BOOL_KEYWORD 1
+#endif /* _STLP_NO_BOOL */
+
+/* uninitialized value filler */
+#ifndef _STLP_SHRED_BYTE
+/* This value is designed to cause problems if an error occurs */
+# define _STLP_SHRED_BYTE 0xA3
+#endif /* _STLP_SHRED_BYTE */
+
+/* shared library tune-up */
+#ifndef _STLP_IMPORT_DECLSPEC
+# define _STLP_IMPORT_DECLSPEC
+#endif
+
+/* a keyword used to instantiate export template */
+#ifndef _STLP_EXPORT_TEMPLATE_KEYWORD
+# define _STLP_EXPORT_TEMPLATE_KEYWORD
+#endif
+#ifndef _STLP_IMPORT_TEMPLATE_KEYWORD
+# define _STLP_IMPORT_TEMPLATE_KEYWORD
+#endif
+
+#if !defined (_STLP_NO_CONST_IN_PAIR)
+# define _STLP_CONST const
+#else
+# define _STLP_CONST
+#endif
+
+#ifdef _STLP_USE_NO_IOSTREAMS
+/*
+ * If we do not use iostreams we do not use the export/import
+ * techniques to avoid build of the STLport library.
+ */
+# undef _STLP_USE_DECLSPEC
+/* We also undef USE_DYNAMIC_LIB macro as this macro add some code
+ * to use the dynamic (shared) STLport library for some platform/compiler
+ * configuration leading to problem when not linking to the STLport lib.
+ */
+# undef _STLP_USE_DYNAMIC_LIB
+#endif
+
+#if defined (_STLP_DLLEXPORT_NEEDS_PREDECLARATION) && defined (_STLP_USE_DECLSPEC)
+# if ! defined (_STLP_USE_TEMPLATE_EXPORT)
+/* this setting turns on "extern template" extension use */
+# define _STLP_USE_TEMPLATE_EXPORT
+# endif
+# if defined (_STLP_DESIGNATED_DLL) && ! defined (_STLP_NO_FORCE_INSTANTIATE)
+# define _STLP_NO_FORCE_INSTANTIATE
+# endif
+#endif
+
+#if defined (_STLP_DESIGNATED_DLL) /* This is a lib which will contain STLport exports */
+# define _STLP_EXPORT _STLP_EXPORT_TEMPLATE_KEYWORD
+#else
+# define _STLP_EXPORT _STLP_IMPORT_TEMPLATE_KEYWORD
+#endif
+
+#ifndef _STLP_EXPORT_TEMPLATE
+# define _STLP_EXPORT_TEMPLATE _STLP_EXPORT template
+#endif
+
+#if defined (_STLP_USE_DECLSPEC) /* using export/import technique */
+
+# ifndef _STLP_EXPORT_DECLSPEC
+# define _STLP_EXPORT_DECLSPEC
+# endif
+# ifndef _STLP_IMPORT_DECLSPEC
+# define _STLP_IMPORT_DECLSPEC
+# endif
+# ifndef _STLP_CLASS_EXPORT_DECLSPEC
+# define _STLP_CLASS_EXPORT_DECLSPEC
+# endif
+# ifndef _STLP_CLASS_IMPORT_DECLSPEC
+# define _STLP_CLASS_IMPORT_DECLSPEC
+# endif
+# if defined (_STLP_DESIGNATED_DLL) /* This is a lib which will contain STLport exports */
+# define _STLP_DECLSPEC _STLP_EXPORT_DECLSPEC
+# define _STLP_CLASS_DECLSPEC _STLP_CLASS_EXPORT_DECLSPEC
+# else
+# define _STLP_DECLSPEC _STLP_IMPORT_DECLSPEC /* Other modules, importing STLport exports */
+# define _STLP_CLASS_DECLSPEC _STLP_CLASS_IMPORT_DECLSPEC
+# endif
+
+#else /* Not using DLL export/import specifications */
+
+# define _STLP_DECLSPEC
+# define _STLP_CLASS_DECLSPEC
+
+#endif
+
+#define _STLP_EXPORT_TEMPLATE_CLASS _STLP_EXPORT template class _STLP_CLASS_DECLSPEC
+
+#if defined (_STLP_NEED_ADDITIONAL_STATIC_DECLSPEC)
+# define _STLP_STATIC_DECLSPEC _STLP_DECLSPEC
+#else
+# define _STLP_STATIC_DECLSPEC
+#endif
+
+#if !defined (_STLP_CALL)
+# define _STLP_CALL
+#endif
+
+#ifndef _STLP_USE_NO_IOSTREAMS
+
+# if defined (__DECCXX) && ! defined (__USE_STD_IOSTREAM)
+# define __USE_STD_IOSTREAM
+# endif
+
+/* We only need to expose details of streams implementation
+ if we use non-standard i/o or are building STLport*/
+# if defined (__BUILDING_STLPORT) || defined (_STLP_NO_FORCE_INSTANTIATE) || !defined(_STLP_NO_CUSTOM_IO)
+# define _STLP_EXPOSE_STREAM_IMPLEMENTATION 1
+# endif
+
+/* We only need to expose details of global implementation if we are building STLport
+ or have not instantiated everything in the lib */
+# if defined (__BUILDING_STLPORT) || defined (_STLP_NO_FORCE_INSTANTIATE)
+# undef _STLP_EXPOSE_GLOBALS_IMPLEMENTATION
+# define _STLP_EXPOSE_GLOBALS_IMPLEMENTATION 1
+# endif
+
+#else /* _STLP_USE_NO_IOSTREAMS */
+/* when we are not using SGI iostreams, we must expose globals, but not streams implementation */
+# define _STLP_EXPOSE_GLOBALS_IMPLEMENTATION
+#endif /* _STLP_USE_NO_IOSTREAMS */
+
+#ifdef _STLP_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS
+# define _STLP_PSPEC2(t1,t2) < t1,t2 >
+# define _STLP_PSPEC3(t1,t2,t3) < t1,t2,t3 >
+#else
+# define _STLP_PSPEC2(t1,t2) /* nothing */
+# define _STLP_PSPEC3(t1,t2,t3) /* nothing */
+#endif
+
+/* Activation of the partial template workaround:
+ */
+#if !defined(_STLP_DONT_USE_PARTIAL_SPEC_WRKD) &&\
+ (!defined(_STLP_CLASS_PARTIAL_SPECIALIZATION) || !defined(_STLP_FUNCTION_TMPL_PARTIAL_ORDER))
+# define _STLP_USE_PARTIAL_SPEC_WORKAROUND
+#endif
+
+#ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
+# define _STLP_RELOPS_OPERATORS(_TMPL, _TP) \
+_TMPL inline bool _STLP_CALL operator!=(const _TP& __x, const _TP& __y) {return !(__x == __y);}\
+_TMPL inline bool _STLP_CALL operator>(const _TP& __x, const _TP& __y) {return __y < __x;}\
+_TMPL inline bool _STLP_CALL operator<=(const _TP& __x, const _TP& __y) { return !(__y < __x);}\
+_TMPL inline bool _STLP_CALL operator>=(const _TP& __x, const _TP& __y) { return !(__x < __y);}
+#else
+# define _STLP_RELOPS_OPERATORS(_TMPL, _TP)
+#endif
+
+#if defined ( _STLP_USE_ABBREVS )
+# include <stl/_abbrevs.h>
+#endif
+
+/* Some really useful macro */
+#define _STLP_ARRAY_SIZE(A) sizeof(A) / sizeof(A[0])
+#define _STLP_ARRAY_AND_SIZE(A) A, sizeof(A) / sizeof(A[0])
+
+#if !defined (_STLP_MARK_PARAMETER_AS_UNUSED)
+# define _STLP_MARK_PARAMETER_AS_UNUSED(X) (void*)X;
+#endif
+
+#if defined (_STLP_CHECK_RUNTIME_COMPATIBILITY)
+# if defined (_STLP_USE_NO_IOSTREAMS)
+# undef _STLP_CHECK_RUNTIME_COMPATIBILITY
+# else
+/* The extern "C" simply makes the symbol simpler. */
+#if defined (__cplusplus)
+extern "C"
+#endif
+void _STLP_DECLSPEC _STLP_CALL _STLP_CHECK_RUNTIME_COMPATIBILITY();
+# endif
+#endif
+
+/* some cleanup */
+#undef _STLP_DONT_USE_BOOL_TYPEDEF
+#undef _STLP_YVALS_H
+#undef _STLP_LOOP_INLINE_PROBLEMS
+#undef _STLP_NEED_EXPLICIT
+#undef _STLP_NEED_TYPENAME
+#undef _STLP_NO_NEW_STYLE_CASTS
+#undef __AUTO_CONFIGURED
+
+#endif /* _STLP_FEATURES_H */
diff --git a/sources/android/stlport/stlport/stl/config/host.h b/sources/android/stlport/stlport/stl/config/host.h
new file mode 100644
index 0000000..b4b6089
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/host.h
@@ -0,0 +1,342 @@
+/*
+ * This file defines site configuration.
+ */
+
+/*
+ * _STLP_NO_THREADS: if defined, STLport don't use any
+ * multithreading support. Synonym is _NOTHREADS
+ */
+/*
+#define _NOTHREADS
+#define _STLP_NO_THREADS
+*/
+
+/* _PTHREADS: if defined, use POSIX threads for multithreading support. */
+/*
+#define _PTHREADS
+*/
+
+/* compatibility section
+ */
+
+#if (defined (_STLP_NOTHREADS) || defined (_STLP_NO_THREADS) || defined (NOTHREADS))
+# if !defined (_NOTHREADS)
+# define _NOTHREADS
+# endif
+# if !defined (_STLP_NO_THREADS)
+# define _STLP_NO_THREADS
+# endif
+#endif
+
+#if !defined(_STLP_USE_DYNAMIC_LIB) && !defined(_STLP_USE_STATIC_LIB)
+/*
+ * Turn _STLP_USE_DYNAMIC_LIB to enforce use of .dll version of STLport library.
+ * NOTE: please do that only if you know what you are doing!
+ * Changing default will require you to change makefiles in "build" accordingly
+ * and to rebuild STLPort library!
+ * On UNIX, this has no effect, see build/lib/README for make tags.
+ * See STLport configuration file (build/lib/configure.bat) for help in building
+ * the require library versions.
+ */
+/*
+#define _STLP_USE_DYNAMIC_LIB
+*/
+
+/*
+ * Turn _STLP_USE_STATIC_LIB to enforce use of static version of STLport library.
+ * NOTE: please do that only if you know what you are doing!
+ * Changing default will require you to change makefile in "build" accordingly
+ * and to rebuild STLPort library!
+ * On UNIX, this has no effect, see build/lib/README for make tags.
+ * See STLport configuration file (build/lib/configure.bat) for help in building
+ * the require library versions.
+ */
+/*
+#define _STLP_USE_STATIC_LIB
+*/
+#endif
+
+/*
+ * Edit relative path below (or put full path) to get native
+ * compiler vendor's headers included. Default is "../include"
+ * for _STLP_NATIVE_INCLUDE_PATH, default for other macros is
+ * _STLP_NATIVE_INCLUDE_PATH.
+ * Hint: never install STLport in the directory that ends with "include"
+ */
+/*
+#undef _STLP_NATIVE_INCLUDE_PATH
+#define _STLP_NATIVE_INCLUDE_PATH ../include
+*/
+/* same for C library headers like <cstring> */
+/*
+#undef _STLP_NATIVE_CPP_C_INCLUDE_PATH
+#define _STLP_NATIVE_CPP_C_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH
+*/
+/* same for C headers like <string.h> */
+/*
+#undef _STLP_NATIVE_C_INCLUDE_PATH
+#define _STLP_NATIVE_C_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH
+*/
+/* Some compilers locate basic C++ runtime support headers (<new>, <typeinfo>, <exception>) in separate directory */
+/*
+#undef _STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH
+#define _STLP_NATIVE_CPP_RUNTIME_INCLUDE_PATH _STLP_NATIVE_INCLUDE_PATH
+*/
+
+/*
+ * If namespases available, STLport use own namespace (and masquerade
+ * it as std). Disable own namespace may cause undefined behaviour.
+ */
+/*
+#define _STLP_NO_OWN_NAMESPACE 1
+*/
+
+/*
+ * Uncomment _STLP_LEAKS_PEDANTIC to force deallocation of ALL allocated
+ * memory chunks. Normally not required. But if you worry about quazi-leaks
+ * (may be reported by some leaks detection tools), use
+ * _STLP_LEAKS_PEDANTIC. It should be used with _STLP_USE_NEWALLOC or
+ * _STLP_USE_MALLOC (see below), the default node_alloc allocator also clean
+ * its internal memory pool but only if STLport is used as a dynamic library
+ * under Win32 (using MSVC like compilers).
+ */
+/*
+#define _STLP_LEAKS_PEDANTIC 1
+*/
+
+/*
+ * Uncomment _STLP_USE_NEWALLOC to force allocator<T> to use plain "new"
+ * instead of STLport optimized node allocator engine.
+ */
+/*
+#define _STLP_USE_NEWALLOC 1
+*/
+
+/*
+ * Uncomment _STLP_USE_MALLOC to force allocator<T> to use plain "malloc"
+ * instead of STLport optimized node allocator engine.
+ *
+ * This is default allocator for glibc 2.3.x and later, if not mentioned other
+ */
+/*
+#define _STLP_USE_MALLOC 1
+*/
+
+/*
+ * Uncomment _STLP_USE_PERTHREAD_ALLOC to force allocator<T> to use
+ * a specific implementation targetting the massively multi-threaded
+ * environment. The implementation is based on the POSIX pthread
+ * interface.
+ */
+/*
+#define _STLP_USE_PERTHREAD_ALLOC 1
+*/
+
+/*
+ * Uncomment _STLP_USE_NODE_ALLOC if you want to force allocator<T> to use
+ * "node_alloc" allocator (this is default allocator for STLport, if not
+ * used other above, except glibc 2.3.x and later, where default is
+ * "malloc", due to better results)
+ */
+/*
+#define _STLP_USE_NODE_ALLOC 1
+*/
+
+/*
+ * Set _STLP_DEBUG_ALLOC to use allocators that perform memory debugging,
+ * such as padding/checking for memory consistency
+ */
+/*
+#define _STLP_DEBUG_ALLOC 1
+*/
+
+/*
+ * For compiler not supporting partial template specialization or ordering of
+ * template functions STLport implement a workaround based on inheritance
+ * detection. This inheritance can introduce trouble in client code when
+ * a user class derived a STL container (which is not advised as STL containers
+ * do not have virtual destructors). To disable this workaround turn this macro on:
+ */
+/*
+#define _STLP_DONT_USE_PARTIAL_SPEC_WRKD 1
+*/
+
+/*
+ * Uncomment this to force all debug diagnostic to be directed through a
+ * user-defined global function:
+ * void __stl_debug_message(const char * format_str, ...)
+ * instead of predefined STLport routine.
+ * This allows you to take control of debug message output.
+ * Default routine calls fprintf(stderr,...)
+ * Note : If you set this macro, you must supply __stl_debug_message
+ * function definition somewhere.
+ */
+/*
+#define _STLP_DEBUG_MESSAGE 1
+*/
+
+/*
+ * Uncomment this to force all failed assertions to be executed through
+ * user-defined global function:
+ * void __stl_debug_terminate(void). This allows
+ * you to take control of assertion behaviour for debugging purposes.
+ * Default routine calls _STLP_ABORT().
+ * Note : If you set this macro, you must supply __stl_debug_terminate
+ * function definition somewhere.
+ */
+/*
+#define _STLP_DEBUG_TERMINATE 1
+*/
+
+/*
+ * Uncomment that to disable exception handling code
+ */
+/*
+#define _STLP_DONT_USE_EXCEPTIONS 1
+*/
+
+/*
+ * _STLP_NO_NAMESPACES: if defined, don't put the library in namespace
+ * stlport:: or std::, even if the compiler supports namespaces
+ */
+/*
+#define _STLP_NO_NAMESPACES 1
+*/
+
+/*==========================================================
+ * Compatibility section
+ *==========================================================*/
+
+/*
+ * Use abbreviated class names for linker benefit (don't affect interface).
+ * This option is obsolete, but should work in this release.
+ *
+ */
+/*
+#define _STLP_USE_ABBREVS
+*/
+
+/*
+ * This definition precludes STLport reverse_iterator to be compatible with
+ * other parts of MSVC library. (With partial specialization, it just
+ * has no effect).
+ * Use it _ONLY_ if you use SGI-style reverse_iterator<> template explicitly
+ */
+/*
+#define _STLP_NO_MSVC50_COMPATIBILITY 1
+*/
+
+/*
+ * Use obsolete overloaded template functions iterator_category(), value_type(), distance_type()
+ * for querying iterator properties. Please note those names are non-standard and are not guaranteed
+ * to be used by every implementation. However, this setting is on by default when partial specialization
+ * is not implemented in the compiler and cannot be simulated (only if _STLP_NO_ANACHRONISMS is not set).
+ * Use of those interfaces for user-defined iterators is strongly discouraged:
+ * please use public inheritance from iterator<> template to achieve desired effect.
+ * Second form is to disable old-style queries in any case.
+ */
+/*
+#define _STLP_USE_OLD_HP_ITERATOR_QUERIES
+#define _STLP_NO_OLD_HP_ITERATOR_QUERIES
+*/
+
+
+/*
+ * On systems with support of large files (_LARGEFILE_SOURCE,
+ * _LARGEFILE64_SOURCE defined) we will use 64-bit file offset, even if
+ * __USE_FILE_OFFSET64 or _FILE_OFFSET_BITS not defined or _FILE_OFFSET_BITS
+ * less than 64. In the last case sizeof(std::streamoff) may not be equal to
+ * sizeof(off_t); if you want to force equal size of off_t and streamoff,
+ * uncomment macro below. But pay attention, this has influence on libstlport
+ * and in future usage it may cause conflict with defined _FILE_OFFSET_BITS macro.
+ */
+
+/*
+#define _STLP_USE_DEFAULT_FILE_OFFSET
+*/
+
+/*
+ * _STLP_USE_STDIO_IO, _STLP_USE_UNIX_IO: force selection of stdio calls
+ * (fopen/flose/fread/fwrite) under fstream buffers or unistd calls
+ * (open/close/read/write + mmap). On systems that have both (i.e. most Unixes)
+ * _STLP_USE_UNIX_IO is used.
+ *
+ * There is a third variant for Windows: _STLP_USE_WIN32_IO, that based
+ * on Windows calls (CreateFile/CloseHandle/ReadFile/WriteFile + CreateFileMapping,
+ * MapViewOfFile)
+ *
+ * Uncomment only one define here!
+ */
+/*
+#define _STLP_USE_UNIX_IO
+*/
+/*
+#define _STLP_USE_STDIO_IO
+*/
+/*
+#define _STLP_USE_WIN32_IO
+ */
+
+/*==========================================================================*/
+
+/* This section contains swithes which should be off by default,
+ * but so few compilers would have it undefined, so that we set them here,
+ * with the option to be turned off later in compiler-specific file
+ */
+
+#define _STLP_NO_UNCAUGHT_EXCEPT_SUPPORT
+#define _STLP_NO_UNEXPECTED_EXCEPT_SUPPORT
+
+/*==========================================================================*/
+
+#if defined(__sun) && defined(__GNUC__)
+/* __SunOS_5_x is not defined in headers, and there is no way to derive it from headers only;
+ * nevertheless this macro defined automagically by SunPro compilers family;
+ *
+ * gcc know nothing about it, but defining it with -D on compiler command line
+ * is a bad idea from one side, and this info still useful when we want to use
+ * (or don't use) some Solaris version-specific features from other side.
+ * Of course, the best way is to define it in spec file, but this is beyond our scope.
+ *
+ * Uncomment ONE of the following, depends on what Solaris version you use.
+ */
+
+/*
+#define __SunOS_5_5_1
+ */
+/*
+#define __SunOS_5_6
+ */
+/*
+#define __SunOS_5_7
+ */
+/*
+#define __SunOS_5_8
+ */
+/*
+#define __SunOS_5_9
+ */
+/*
+#define __SunOS_5_10
+ */
+#endif
+
+#if defined(__sun)
+/* With following patches Solaris 8 and 9 will have *l and *f (long double and float)
+ * variants of math functions:
+ * SunOS 5.8 patch 111721-04 (May/08/2003)
+ * <http://sunsolve.sun.com/search/document.do?assetkey=1-21-111721-04-1>
+ * SunOS 5.9 patch 111722-04 (May/08/2003)
+ * <http://sunsolve.sun.com/search/document.do?assetkey=1-21-111722-04-1>
+ * Solaris 10 has this functions from box.
+ */
+/*
+#define _STLP_SOLARIS_MATH_PATCH
+ */
+#endif
+
+/*
+ Local Variables:
+ mode:C++
+ End:
+*/
diff --git a/sources/android/stlport/stlport/stl/config/stl_confix.h b/sources/android/stlport/stlport/stl/config/stl_confix.h
new file mode 100644
index 0000000..ddcdf1d
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/stl_confix.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/*
+ * STLport configuration file
+ * It is internal STLport header - DO NOT include it directly
+ * Purpose of this file : to define STLport settings that depend on
+ * compiler flags or can be otherwise missed
+ *
+ */
+
+#ifndef _STLP_CONFIX_H
+#define _STLP_CONFIX_H
+
+/* If, by any chance, C compiler gets there, try to help it to pass smoothly */
+#if ! defined (__cplusplus) && ! defined (_STLP_HAS_NO_NAMESPACES)
+# define _STLP_HAS_NO_NAMESPACES
+#endif
+
+#if defined (__MINGW32__)
+# define _STLP_NO_DRAND48
+#endif
+
+/* Modena C++ library */
+#if defined (__MWERKS__) && __MWERKS__ <= 0x2303 || (defined (__KCC) && __KCC_VERSION < 3400)
+# include <mcompile.h>
+# define _STLP_USE_MSIPL 1
+# if defined (__KCC) || (defined(__MSL_CPP__) && \
+ ( (__MSL_CPP__ >= 0x5000 && defined( _MSL_NO_MESSAGE_FACET )) || \
+ (__MSL_CPP__ < 0x5000 && defined( MSIPL_NL_TYPES ))))
+# define _STLP_NO_NATIVE_MESSAGE_FACET 1
+# endif
+#endif
+
+/* common switches for EDG front-end */
+/* __EDG_SWITCHES do not seem to be an official EDG macro.
+ * We keep it for historical reason. */
+#if defined (__EDG_SWITCHES)
+# if !(defined(_TYPENAME) || defined (_TYPENAME_IS_KEYWORD))
+# undef _STLP_NEED_TYPENAME
+# define _STLP_NEED_TYPENAME 1
+# endif
+# ifndef _WCHAR_T_IS_KEYWORD
+# undef _STLP_NO_WCHAR_T
+# define _STLP_NO_WCHAR_T 1
+# endif
+# ifndef _PARTIAL_SPECIALIZATION_OF_CLASS_TEMPLATES
+# undef _STLP_NO_CLASS_PARTIAL_SPECIALIZATION
+# define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1
+# endif
+# ifndef _MEMBER_TEMPLATES
+# undef _STLP_NO_MEMBER_TEMPLATES
+# define _STLP_NO_MEMBER_TEMPLATES 1
+# undef _STLP_NO_MEMBER_TEMPLATE_CLASSES
+# define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1
+# endif
+# ifndef _MEMBER_TEMPLATE_KEYWORD
+# undef _STLP_NO_MEMBER_TEMPLATE_KEYWORD
+# define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1
+# endif
+# if !defined (__EXCEPTIONS) && ! defined (_EXCEPTIONS)
+# undef _STLP_HAS_NO_EXCEPTIONS
+# define _STLP_HAS_NO_EXCEPTIONS
+# endif
+# undef __EDG_SWITCHES
+#endif /* EDG */
+
+/* __EDG_VERSION__ is an official EDG macro, compilers based
+ * on EDG have to define it. */
+#if defined (__EDG_VERSION__)
+# if (__EDG_VERSION__ >= 244) && !defined (_STLP_HAS_INCLUDE_NEXT)
+# define _STLP_HAS_INCLUDE_NEXT
+# endif
+# if (__EDG_VERSION__ <= 240) && !defined (_STLP_DONT_RETURN_VOID)
+# define _STLP_DONT_RETURN_VOID
+# endif
+# if !defined (__EXCEPTIONS) && !defined (_STLP_HAS_NO_EXCEPTIONS)
+# define _STLP_HAS_NO_EXCEPTIONS
+# endif
+# if !defined (__NO_LONG_LONG) && !defined (_STLP_LONG_LONG)
+# define _STLP_LONG_LONG long long
+# endif
+#endif
+
+#endif
diff --git a/sources/android/stlport/stlport/stl/config/stl_mycomp.h b/sources/android/stlport/stlport/stl/config/stl_mycomp.h
new file mode 100644
index 0000000..f92902f
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/stl_mycomp.h
@@ -0,0 +1,282 @@
+/*
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/*
+ * Purpose of this file :
+ *
+ * A list of COMPILER-SPECIFIC portion of STLport settings.
+ * This file is provided to help in manual configuration
+ * of STLport. This file is being included by stlcomp.h
+ * when STLport is unable to identify your compiler.
+ * Please remove the error diagnostic below before adjusting
+ * macros.
+ *
+ */
+#ifndef _STLP_MYCOMP_H
+#define _STLP_MYCOMP_H
+
+#error "Your compiler version is not recognized by STLport. Please edit <stlport/stl/config/stl_mycomp.h>"
+
+//==========================================================
+
+// the values choosen here as defaults try to give
+// maximum functionality on the most conservative settings
+
+// Mostly correct guess, change it for Alpha (and other environments
+// that has 64-bit "long")
+// # define _STLP_UINT32_T unsigned long
+
+// Disables wchar_t functionality
+// # define _STLP_NO_WCHAR_T 1
+
+// Define if wchar_t is not an intrinsic type, and is actually a typedef to unsigned short.
+// # define _STLP_WCHAR_T_IS_USHORT 1
+
+// Uncomment if long long is available
+// # define _STLP_LONG_LONG long long
+
+// Uncomment if long double is not available
+// # define _STLP_NO_LONG_DOUBLE 1
+
+// Uncomment this if your compiler does not support "typename" keyword
+// # define _STLP_NEED_TYPENAME 1
+
+// Uncomment this if your compiler does not support "mutable" keyword
+// # define _STLP_NEED_MUTABLE 1
+
+// Uncomment this if your compiler does not support "explicit" keyword
+// # define _STLP_NEED_EXPLICIT 1
+
+// Uncomment if new-style-casts like const_cast<> are not available
+// # define _STLP_NO_NEW_STYLE_CASTS 1
+
+// Uncomment this if your compiler does not have "bool" type
+// # define _STLP_NO_BOOL 1
+
+// Uncomment this if your compiler does not have "bool" type, but has "bool" keyword reserved
+// # define _STLP_DONT_USE_BOOL_TYPEDEF 1
+
+// Uncomment this if your compiler does not have "bool" type, but defines "bool" in <yvals.h>
+// # define _STLP_YVALS_H 1
+
+// Uncomment this if your compiler has limited or no default template arguments for classes
+// # define _STLP_LIMITED_DEFAULT_TEMPLATES 1
+
+// Uncomment this if your compiler support only complete (not dependent on other parameters)
+// types as default parameters for class templates
+// # define _STLP_DEFAULT_TYPE_PARAM 1
+
+// Uncomment this if your compiler do not support default parameters in template class methods
+// # define _STLP_DONT_SUP_DFLT_PARAM 1
+
+// Uncomment this if your compiler has problem with not-type
+// default template parameters
+// # define _STLP_NO_DEFAULT_NON_TYPE_PARAM 1
+
+// Define if compiler has
+// trouble with functions getting non-type-parameterized classes as parameters
+// # define _STLP_NON_TYPE_TMPL_PARAM_BUG 1
+
+// Uncomment this if your compiler does not support namespaces
+// # define _STLP_HAS_NO_NAMESPACES 1
+
+// Uncomment if "using" keyword does not work with template types
+// # define _STLP_BROKEN_USING_DIRECTIVE 1
+
+// Uncomment this if your compiler does not support exceptions
+// # define _STLP_HAS_NO_EXCEPTIONS 1
+
+// Uncomment this when you are able to detect that the user do not
+// want to use the exceptions feature.
+// # define _STLP_DONT_USE_EXCEPTIONS 1
+
+// Uncomment this if your compiler does not support exception specifications
+// # define _STLP_NO_EXCEPTION_SPEC
+
+// Define this if your compiler requires return statement after throw()
+// # define _STLP_THROW_RETURN_BUG 1
+
+// Define this if your compiler do not support return of void
+// # define _STLP_DONT_RETURN_VOID 1
+
+// Header <new> that comes with the compiler
+// does not define bad_alloc exception
+// # define _STLP_NO_BAD_ALLOC 1
+
+// Define this if your compiler do not throw bad_alloc from the new operator
+// # define _STLP_NEW_DONT_THROW_BAD_ALLOC 1
+
+// Define this if your compiler has no rtti support or if it has been disabled
+// # define _STLP_NO_RTTI 1
+
+// Define this if there is no native type_info definition
+// # define _STLP_NO_TYPEINFO 1
+
+// Uncomment if member template methods are not available
+// # define _STLP_NO_MEMBER_TEMPLATES 1
+
+// Uncomment if member template classes are not available
+// # define _STLP_NO_MEMBER_TEMPLATE_CLASSES 1
+
+// Uncomment if your compiler do not support the std::allocator rebind technique
+// This is a special case of bad member template classes support, it is automatically
+// defined if _STLP_NO_MEMBER_TEMPLATE_CLASSES is defined.
+// # define _STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE 1
+
+// Uncomment if no "template" keyword should be used with member template classes
+// # define _STLP_NO_MEMBER_TEMPLATE_KEYWORD 1
+
+// Compiler does not accept friend declaration qualified with namespace name.
+// # define _STLP_NO_QUALIFIED_FRIENDS 1
+
+// Uncomment if partial specialization is not available
+// # define _STLP_NO_CLASS_PARTIAL_SPECIALIZATION 1
+
+// Define if class being partially specialized require full name (template parameters)
+// of itself for method declarations
+// # define _STLP_PARTIAL_SPEC_NEEDS_TEMPLATE_ARGS
+
+// Compiler has problem with qualified specializations (cont int, volatile int...)
+// # define _STLP_QUALIFIED_SPECIALIZATION_BUG
+
+// Compiler has problems specializing members of partially
+// specialized class
+// # define _STLP_MEMBER_SPECIALIZATION_BUG
+
+// Uncomment if partial order of template functions is not available
+// # define _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER 1
+
+// Uncomment if specialization of methods is not allowed
+// # define _STLP_NO_METHOD_SPECIALIZATION 1
+
+// Uncomment if full specialization does not use partial spec. syntax : template <> struct ....
+// # define _STLP_NO_PARTIAL_SPECIALIZATION_SYNTAX 1
+
+// Uncomment if compiler does not support explicit template arguments for functions
+// # define _STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS
+
+// Uncomment this if your compiler can't inline while(), for()
+// # define _STLP_LOOP_INLINE_PROBLEMS 1
+
+// Define if the compiler fails to match a template function argument of base
+// # define _STLP_BASE_MATCH_BUG 1
+
+// Define if the compiler fails to match a template function argument of base
+// (non-template)
+//# define _STLP_NONTEMPL_BASE_MATCH_BUG 1
+
+// Define if the compiler rejects outline method definition
+// explicitly taking nested types/typedefs
+// # define _STLP_NESTED_TYPE_PARAM_BUG 1
+
+// Compiler requires typename keyword on outline method definition
+// explicitly taking nested types/typedefs
+// #define _STLP_TYPENAME_ON_RETURN_TYPE
+
+// Define if the baseclass typedefs not visible from outside
+// # define _STLP_BASE_TYPEDEF_OUTSIDE_BUG 1
+
+// if your compiler have serious problems with typedefs, try this one
+// # define _STLP_BASE_TYPEDEF_BUG 1
+
+// Uncomment if getting errors compiling mem_fun* adaptors
+// # define _STLP_MEMBER_POINTER_PARAM_BUG 1
+
+// Uncomment if the compiler can't handle a constant-initializer in the
+// declaration of a static const data member of integer type.
+// (See section 9.4.2, paragraph 4, of the C++ standard.)
+// # define _STLP_STATIC_CONST_INIT_BUG
+
+// Uncomment to indicate that the compiler do not like static constant
+// definition.
+// Meaningfull only if _STLP_STATIC_CONST_INIT_BUG is not defined.
+// # define _STLP_NO_STATIC_CONST_DEFINITION
+
+// Define if default constructor for builtin integer type fails to initialize it to 0
+// In expression like new(&char) char():
+//# define _STLP_DEF_CONST_PLCT_NEW_BUG 1
+// In default function parameter like _M_method(_Tp __x = _Tp())
+//# define _STLP_DEF_CONST_DEF_PARAM_BUG 1
+
+// Defined if constructor
+// required to explicitly call member's default constructors for const objects
+// # define _STLP_CONST_CONSTRUCTOR_BUG 1
+
+// Defined if the compiler has trouble calling POD-types constructors/destructors
+// # define _STLP_TRIVIAL_CONSTRUCTOR_BUG 1
+// # define _STLP_TRIVIAL_DESTRUCTOR_BUG 1
+
+// Define if having problems specializing maps/sets with
+// key type being const
+// # define _STLP_MULTI_CONST_TEMPLATE_ARG_BUG
+
+// Uncomment this to disable -> operators on all iterators
+// # define _STLP_NO_ARROW_OPERATOR 1
+
+// Uncomment this to disble at() member functions for containers
+// # define _STLP_NO_AT_MEMBER_FUNCTION 1
+
+// Define this if compiler lacks <exception> header
+// # define _STLP_NO_EXCEPTION_HEADER 1
+
+// Uncomment this if your C library has lrand48() function
+// # define _STLP_RAND48 1
+
+// Uncomment if native new-style C library headers lile <cstddef>, etc are not available.
+// # define _STLP_HAS_NO_NEW_C_HEADERS 1
+
+// uncomment if new-style headers <new> is available
+// # define _STLP_HAS_NEW_NEW_HEADER 1
+
+// uncomment this if <iostream> and other STD headers put their stuff in ::namespace,
+// not std::
+// # define _STLP_VENDOR_GLOBAL_STD
+
+// uncomment this if <cstdio> and the like put stuff in ::namespace,
+// not std::
+// # define _STLP_VENDOR_GLOBAL_CSTD
+
+// uncomment this if your compiler consider as ambiguous a function imported within
+// the stlport namespace and called without scope (:: or std::)
+// # define _STLP_NO_USING_FOR_GLOBAL_FUNCTIONS 1
+
+// uncomment this if your compiler define all the C math functions C++ additional
+// overloads in ::namespace and not only in std::.
+// # define _STLP_HAS_GLOBAL_C_MATH_FUNCTIONS 1
+
+// Edit relative path below (or put full path) to get native
+// compiler headers included. Default is "../include".
+// C headers may reside in different directory, so separate macro is provided.
+// Hint : never install STLport in the directory that ends with "include"
+// # define _STLP_NATIVE_INCLUDE_PATH ../include
+// # define _STLP_NATIVE_C_INCLUDE_PATH ../include
+// # define _STLP_NATIVE_CPP_C_INCLUDE_PATH ../include
+
+// This macro constructs header path from directory and name.
+// You may change it if your compiler does not understand "/".
+// # define _STLP_MAKE_HEADER(path, header) <path/header>
+
+// This macro constructs native include header path from include path and name.
+// You may have do define it if experimenting problems with preprocessor
+// # define _STLP_NATIVE_HEADER(header) _STLP_MAKE_HEADER(_STLP_NATIVE_INCLUDE_PATH,header)
+
+// Same for C headers
+// #define _STLP_NATIVE_C_HEADER(header)
+
+//==========================================================
+#endif
diff --git a/sources/android/stlport/stlport/stl/config/user_config.h b/sources/android/stlport/stlport/stl/config/user_config.h
new file mode 100644
index 0000000..4efd727
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/config/user_config.h
@@ -0,0 +1,326 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+/*
+ * Purpose of this file :
+ *
+ * To hold user-definable portion of STLport settings which may be overridden
+ * on per-project basis.
+ * Please note that if you use STLport iostreams (compiled library) then you have
+ * to use consistent settings when you compile STLport library and your project.
+ * Those settings are defined in host.h and have to be the same for a given
+ * STLport installation.
+ */
+
+
+/*==========================================================
+ * User-settable macros that control compilation:
+ * Features selection
+ *==========================================================*/
+
+/*
+ * Use this switch for embedded systems where no iostreams are available
+ * at all. STLport own iostreams will also get disabled automatically then.
+ * You can either use STLport iostreams, or no iostreams.
+ * If you want iostreams, you have to compile library in ../build/lib
+ * and supply resulting library at link time.
+ */
+/*
+#define _STLP_NO_IOSTREAMS 1
+*/
+
+/*
+ * Set _STLP_DEBUG to turn the "Debug Mode" on.
+ * That gets you checked iterators/ranges in the manner
+ * of "Safe STL". Very useful for debugging. Thread-safe.
+ * Please do not forget to link proper STLport library flavor
+ * (e.g libstlportstlg.so or libstlportstlg.a) when you set this flag
+ * in STLport iostreams mode, namespace customization guaranty that you
+ * link to the right library.
+ */
+/*
+#define _STLP_DEBUG 1
+*/
+/*
+ * You can also choose the debug level:
+ * STLport debug level: Default value
+ * Check only what the STLport implementation consider as invalid.
+ * It also change the iterator invalidation schema.
+ * Standard debug level: Check for all operations the standard consider as "undefined behavior"
+ * even if STlport implement it correctly. It also invalidates iterators
+ * more often.
+ */
+/*
+#define _STLP_DEBUG_LEVEL _STLP_STLPORT_DBG_LEVEL
+#define _STLP_DEBUG_LEVEL _STLP_STANDARD_DBG_LEVEL
+*/
+/* When an inconsistency is detected by the 'safe STL' the program will abort.
+ * If you prefer an exception define the following macro. The thrown exception
+ * will be the Standard runtime_error exception.
+ */
+/*
+#define _STLP_DEBUG_MODE_THROWS
+ */
+
+/*
+ * _STLP_NO_CUSTOM_IO : define this if you do not instantiate basic_xxx iostream
+ * classes with custom types (which is most likely the case). Custom means types
+ * other than char, wchar_t, char_traits<> and allocator<> like
+ * basic_ostream<my_char_type, my_traits<my_char_type> > or
+ * basic_string<char, char_traits<char>, my_allocator >
+ * When this option is on, most non-inline template functions definitions for iostreams
+ * are not seen by the client which saves a lot of compile time for most compilers,
+ * also object and executable size for some.
+ * Default is off, just not to break compilation for those who do use those types.
+ * That also guarantees that you still use optimized standard i/o when you compile
+ * your program without optimization. Option does not affect STLport library build; you
+ * may use the same binary library with and without this option, on per-project basis.
+ */
+/*
+#define _STLP_NO_CUSTOM_IO
+*/
+
+/*
+ * _STLP_NO_RELOPS_NAMESPACE: if defined, don't put the relational
+ * operator templates (>, <=, >=, !=) in namespace std::rel_ops, even
+ * if the compiler supports namespaces.
+ * Note : if the compiler do not support namespaces, those operators are not be provided by default,
+ * to simulate hiding them into rel_ops. This was proved to resolve many compiler bugs with ambiguity.
+ */
+/*
+#define _STLP_NO_RELOPS_NAMESPACE 1
+*/
+
+/*
+ * If STLport use its own namespace, see _STLP_NO_OWN_NAMESPACE in host.h, it will try
+ * by default to rename std:: for the user to stlport::. If you do not want this feature,
+ * please define the following switch and then use stlport::
+ */
+/*
+#define _STLP_DONT_REDEFINE_STD 1
+*/
+
+/*
+ * _STLP_WHOLE_NATIVE_STD : only meaningful if STLport uses its own namespace.
+ * Normally, STLport only imports necessary components from native std:: namespace.
+ * You might want everything from std:: being available in std:: namespace when you
+ * include corresponding STLport header (like STLport <map> provides std::map as well, etc.),
+ * if you are going to use both stlport:: and std:: components in your code.
+ * Otherwise this option is not recommended as it increases the size of your object files
+ * and slows down compilation.
+ * Beware, if you do not use STLport iostream (_STLP_NO_IOSTREAMS above), ask STLport to
+ * not rename std:: in stlport:: and try to have access to whole native Standard stuff then
+ * STLport will only throw exceptions from the std namespace and not from stlport.
+ * For instance a problem in stlport::vector::at will throw a std::out_of_range exception
+ * and not a stlport::out_of_range.
+ * Notice that STLport exceptions inherits from std::exception.
+ */
+/*
+#define _STLP_WHOLE_NATIVE_STD
+*/
+
+/*
+ * Use this option to catch uninitialized members in your classes.
+ * When it is set, construct() and destroy() fill the class storage
+ * with _STLP_SHRED_BYTE (see below).
+ * Note : _STLP_DEBUG and _STLP_DEBUG_ALLOC don't set this option automatically.
+ */
+/*
+#define _STLP_DEBUG_UNINITIALIZED 1
+#define _STLP_DEBUG_ALLOC 1
+*/
+
+/*
+ * Uncomment and provide a definition for the byte with which raw memory
+ * will be filled if _STLP_DEBUG_ALLOC or _STLP_DEBUG_UNINITIALIZED is defined.
+ * Choose a value which is likely to cause a noticeable problem if dereferenced
+ * or otherwise abused. A good value may already be defined for your platform.
+ */
+/*
+#define _STLP_SHRED_BYTE 0xA3
+*/
+
+/*
+ * This option is for gcc users only and only affects systems where native linker
+ * does not let gcc to implement automatic instantiation of static template data members/
+ * It is being put in this file as there is no way to check if we are using GNU ld automatically,
+ * so it becomes user's responsibility.
+ */
+/*
+#define _STLP_GCC_USES_GNU_LD
+*/
+
+/*==========================================================
+ * Compatibility section
+ *==========================================================*/
+
+/*
+ * Define this macro to disable anachronistic constructs (like the ones used in HP STL and
+ * not included in final standard, etc.
+ */
+/*
+#define _STLP_NO_ANACHRONISMS 1
+*/
+
+/*
+ * Define this macro to disable STLport extensions (for example, to make sure your code will
+ * compile with some other implementation )
+ */
+/*
+#define _STLP_NO_EXTENSIONS 1
+*/
+
+/*
+ * You should define this macro if compiling with MFC - STLport <stl/config/_windows.h>
+ * then include <afx.h> instead of <windows.h> to get synchronisation primitives
+ */
+/*
+#define _STLP_USE_MFC 1
+*/
+
+/*
+ * boris : this setting is here as we cannot detect precense of new Platform SDK automatically
+ * If you are using new PSDK with VC++ 6.0 or lower,
+ * please define this to get correct prototypes for InterlockedXXX functions
+ */
+/*
+#define _STLP_NEW_PLATFORM_SDK 1
+*/
+
+/*
+ * For the same reason as the one above we are not able to detect easily use
+ * of the compiler coming with the Platform SDK instead of the one coming with
+ * a Microsoft Visual Studio release. This change native C/C++ library location
+ * and implementation, please define this to get correct STLport configuration.
+ */
+/*
+#define _STLP_USING_PLATFORM_SDK_COMPILER 1
+*/
+
+/*
+ * Some compilers support the automatic linking feature.
+ * Uncomment the following if you prefer to specify the STLport library
+ * to link with yourself.
+ * For the moment, this feature is only supported and implemented within STLport
+ * by the Microsoft compilers.
+ */
+/*
+#define _STLP_DONT_USE_AUTO_LINK 1
+*/
+
+/*
+ * If you customize the STLport generated library names don't forget to give
+ * the motif you used during configuration here if you still want the auto link
+ * to work. (Do not remove double quotes in the macro value)
+ */
+/*
+#define _STLP_LIB_NAME_MOTIF "???"
+ */
+
+/*
+ * Uncomment to get feedback at compilation time about result of build environment
+ * introspection.
+ */
+/*
+#define _STLP_VERBOSE 1
+*/
+
+/*
+ * Use minimum set of default arguments on template classes that have more
+ * than one - for example map<>, set<>.
+ * This has effect only if _STLP_LIMITED_DEFAULT_TEMPLATES is on.
+ * If _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS is set, you'll be able to compile
+ * set<T> with those compilers, but you'll have to use __set__<T, less<T>>
+ *
+ * Affects : map<>, multimap<>, set<>, multiset<>, hash_*<>,
+ * queue<>, priority_queue<>, stack<>, istream_iterator<>
+ */
+/*
+#define _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS 1
+*/
+
+/*
+ * The agregation of strings using the + operator is an expensive operation
+ * as it requires construction of temporary objects that need memory allocation
+ * and deallocation. The problem can be even more important if you are adding
+ * several strings together in a single expression. To avoid this problem STLport
+ * implement expression template. With this technique addition of 2 strings is not
+ * a string anymore but a temporary object having a reference to each of the
+ * original strings involved in the expression. This object carry information
+ * directly to the destination string to set its size correctly and only make
+ * a single call to the allocator. This technique also works for the addition of
+ * N elements where elements are basic_string, C string or a single character.
+ * The drawback can be longer compilation time and bigger executable size.
+ * Another problem is that some compilers (gcc) fail to use string proxy object
+ * if do with class derived from string (see unit tests for details).
+ * STLport rebuild: Yes
+ */
+/*
+#define _STLP_USE_TEMPLATE_EXPRESSION 1
+*/
+
+
+/*
+ * By default the STLport basic_string implementation use a little static buffer
+ * (of 16 chars when writing this doc) to avoid systematically memory allocation
+ * in case of little basic_string. The drawback of such a method is bigger
+ * basic_string size and some performance penalty for method like swap. If you
+ * prefer systematical dynamic allocation turn on this macro.
+ * STLport rebuild: Yes
+ */
+/*
+#define _STLP_DONT_USE_SHORT_STRING_OPTIM 1
+*/
+
+/*
+ * To reduce the famous code bloat trouble due to the use of templates STLport grant
+ * a specialization of some containers for pointer types. So all instanciations
+ * of those containers with a pointer type will use the same implementation based on
+ * a container of void*. This feature has shown very good result on object files size
+ * but after link phase and optimization you will only experiment benefit if you use
+ * many container with pointer types.
+ * There are however a number of limitation to use this option:
+ * - with compilers not supporting partial template specialization feature, you won't
+ * be able to access some nested container types like iterator as long as the
+ * definition of the type used to instanciate the container will be incomplete
+ * (see IncompleteClass definition in test/unit/vector_test.cpp).
+ * - you won't be able to use complex Standard allocator implementations which are
+ * allocators having pointer nested type not being a real C pointer.
+ */
+/*
+#define _STLP_USE_PTR_SPECIALIZATIONS 1
+*/
+
+/*
+ * To achieve many different optimizations within the template implementations STLport
+ * uses some type traits technique. With this macro you can ask STLport to use the famous
+ * boost type traits rather than the internal one. The advantages are more compiler
+ * integration and a better support. If you only define this macro once the STLport has been
+ * built you just have to add the boost install path within your include path. If you want
+ * to use this feature at STLport built time you will have to define the
+ * STLP_BUILD_BOOST_PATH enrironment variable with the value of the boost library path.
+ */
+
+/*
+#define _STLP_USE_BOOST_SUPPORT 1
+*/
+
+
+/*==========================================================*/
+
+/*
+ Local Variables:
+ mode: C++
+ End:
+*/
diff --git a/sources/android/stlport/stlport/stl/debug/_debug.c b/sources/android/stlport/stlport/stl/debug/_debug.c
new file mode 100644
index 0000000..99d5c6b
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/debug/_debug.c
@@ -0,0 +1,628 @@
+/*
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_DEBUG_C
+#define _STLP_DEBUG_C
+
+#if defined (_STLP_DEBUG)
+#if defined (_STLP_THREADS)
+# if !defined (_STLP_NEED_MUTABLE)
+# define _STLP_ACQUIRE_LOCK(_Lock) _Lock._M_acquire_lock();
+# define _STLP_RELEASE_LOCK(_Lock) _Lock._M_release_lock();
+# else
+# define _STLP_ACQUIRE_LOCK(_Lock) ((_STLP_mutex&)_Lock)._M_acquire_lock();
+# define _STLP_RELEASE_LOCK(_Lock) ((_STLP_mutex&)_Lock)._M_release_lock();
+# endif /* _STLP_NEED_MUTABLE */
+#else
+# define _STLP_ACQUIRE_LOCK(_Lock)
+# define _STLP_RELEASE_LOCK(_Lock)
+#endif /* _STLP_THREADS */
+
+_STLP_BEGIN_NAMESPACE
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+//==========================================================
+// global non-inline functions
+//==========================================================
+// [ i1, i2)
+#if !defined (__DMC__)
+template <class _Iterator>
+inline bool _STLP_CALL
+stlp_in_range_aux(const _Iterator& __it, const _Iterator& __first,
+ const _Iterator& __last, const random_access_iterator_tag &) {
+ return ( __it >= __first &&
+ __it < __last);
+}
+#endif
+
+template <class _Iterator1, class _Iterator>
+#if defined (_STLP_MSVC)
+inline bool _STLP_CALL stlp_in_range_aux(_Iterator1 __it, const _Iterator& __first,
+#else
+inline bool _STLP_CALL stlp_in_range_aux(const _Iterator1& __it, const _Iterator& __first,
+#endif
+ const _Iterator& __last, const forward_iterator_tag &) {
+ _Iterator1 __i(__first);
+ for (; __i != __last && __i != __it; ++__i);
+ return (__i != __last);
+}
+
+#if defined (_STLP_NONTEMPL_BASE_MATCH_BUG)
+template <class _Iterator1, class _Iterator>
+inline bool _STLP_CALL
+stlp_in_range_aux(const _Iterator1& __it, const _Iterator& __first,
+ const _Iterator& __last, const bidirectional_iterator_tag &) {
+ _Iterator1 __i(__first);
+ for (; __i != __last && __i != __it; ++__i);
+ return (__i != __last);
+}
+#endif
+
+template <class _Iterator>
+bool _STLP_CALL __check_range_aux(const _Iterator& __first, const _Iterator& __last,
+ const __false_type& /*_IsIntegral*/) {
+ _STLP_VERBOSE_RETURN(__valid_range(__first,__last), _StlMsg_INVALID_RANGE )
+ return true;
+}
+
+template <class _Integral>
+bool _STLP_CALL __check_range_aux(_Integral /*__first*/, _Integral /*__last*/,
+ const __true_type& /*_IsIntegral*/)
+{ return true; }
+
+template <class _Iterator>
+bool _STLP_CALL __check_range(const _Iterator& __first, const _Iterator& __last) {
+ typedef typename _IsIntegral<_Iterator>::_Ret _Integral;
+ return __check_range_aux(__first, __last, _Integral());
+}
+
+template <class _Iterator>
+bool _STLP_CALL __check_range(const _Iterator& __it,
+ const _Iterator& __start, const _Iterator& __finish) {
+ _STLP_VERBOSE_RETURN(stlp_in_range(__it, __start, __finish),
+ _StlMsg_NOT_IN_RANGE_1)
+ return true;
+}
+
+template <class _Iterator>
+bool _STLP_CALL __check_range(const _Iterator& __first, const _Iterator& __last,
+ const _Iterator& __start, const _Iterator& __finish) {
+ _STLP_VERBOSE_RETURN(stlp_in_range(__first, __last, __start, __finish),
+ _StlMsg_NOT_IN_RANGE_2)
+ return true;
+}
+
+template <class _Tp>
+bool _STLP_CALL __check_ptr_range(const _Tp* __first, const _Tp* __last) {
+ _STLP_VERBOSE_RETURN((__first != 0 || __last == 0), _StlMsg_INVALID_ARGUMENT)
+ _STLP_VERBOSE_RETURN(__valid_range(__first, __last, random_access_iterator_tag()),
+ _StlMsg_INVALID_RANGE)
+ return true;
+}
+
+//===============================================================
+template <class _Iterator>
+void _STLP_CALL __invalidate_range(const __owned_list* __base,
+ const _Iterator& __first,
+ const _Iterator& __last) {
+ typedef __owned_link _L_type;
+ _STLP_ACQUIRE_LOCK(__base->_M_lock)
+ _L_type* __prev = __CONST_CAST(_L_type*, &__base->_M_node);
+ _L_type* __pos = __prev->_M_next;
+
+ while (__pos != 0) {
+ if (!(&__first == __STATIC_CAST(_Iterator*, __pos) || &__last == __STATIC_CAST(_Iterator*, __pos)) &&
+ stlp_in_range_aux(__STATIC_CAST(_Iterator*, __pos)->_M_iterator,
+ __first._M_iterator, __last._M_iterator,
+ _STLP_ITERATOR_CATEGORY(__first, _Iterator))) {
+ __pos->_M_owner = 0;
+ __prev->_M_next = __pos->_M_next;
+ }
+ else {
+ __prev = __pos;
+ }
+ __pos = __prev->_M_next;
+ }
+ _STLP_RELEASE_LOCK(__base->_M_lock)
+}
+
+template <class _Iterator>
+void _STLP_CALL __invalidate_iterator(const __owned_list* __base,
+ const _Iterator& __it) {
+ typedef __owned_link _L_type;
+ _STLP_ACQUIRE_LOCK(__base->_M_lock)
+ _L_type* __prev = __CONST_CAST(_L_type*, &__base->_M_node);
+ _L_type* __pos = __prev->_M_next;
+ while (__pos != 0) {
+ // this requires safe iterators to be derived from __owned_link
+ if ((__pos != __STATIC_CAST(const _L_type*, &__it)) &&
+ (__STATIC_CAST(_Iterator*, __pos)->_M_iterator == __it._M_iterator)) {
+ __pos->_M_owner = 0;
+ __prev->_M_next = __pos->_M_next;
+ }
+ else {
+ __prev = __pos;
+ }
+ __pos = __prev->_M_next;
+ }
+ _STLP_RELEASE_LOCK(__base->_M_lock)
+}
+
+template <class _Iterator>
+void _STLP_CALL __change_range_owner(const _Iterator& __first,
+ const _Iterator& __last,
+ const __owned_list* __dst) {
+ if (__first._Owner() == __dst)
+ return;
+
+ typedef __owned_link _L_type;
+ // Check __stl_debug_engine<_Dummy>::_Swap_owners comments to see why there is no lock here
+ //_STLP_ACQUIRE_LOCK(__base->_M_lock)
+ __owned_list *__base = __CONST_CAST(__owned_list*, __first._Owner());
+ _L_type* __src_prev = &__base->_M_node;
+ _L_type* __pos = __src_prev->_M_next;
+ _L_type* __dst_prev = __CONST_CAST(_L_type*, &__dst->_M_node);
+
+ while (__pos != 0) {
+ if (!(&__first == __STATIC_CAST(_Iterator*, __pos) || &__last == __STATIC_CAST(_Iterator*, __pos)) &&
+ stlp_in_range_aux(__STATIC_CAST(_Iterator*, __pos)->_M_iterator,
+ __first._M_iterator, __last._M_iterator,
+ _STLP_ITERATOR_CATEGORY(__first, _Iterator))) {
+ __pos->_M_owner = __CONST_CAST(__owned_list*, __dst);
+ //remove __pos from __base:
+ __src_prev->_M_next = __pos->_M_next;
+ //add __pos to __dst:
+ __pos->_M_next = __dst_prev->_M_next;
+ __dst_prev->_M_next = __pos;
+ }
+ else {
+ __src_prev = __pos;
+ }
+ __pos = __src_prev->_M_next;
+ }
+
+#if defined(_STLP_WCE) && defined(_ARM_)
+ // Note: This part is needed for compiling under Windows CE under ARM and correctly using
+ // _STLP_DEBUG mode. This comes from a bug in the ARM compiler where checked iterators that
+ // are passed by value are not copied over correctly. When __change_range_owner is called,
+ // e.g. in std::list::splice() the wrong _M_owner field gets modified and the __first
+ // iterator has the old _M_owner field, but was moved to the new __owned_list. Setting
+ // the first iterator's _M_owner field fixes this. Ugly but works.
+ __pos = __CONST_CAST(_Iterator*, &__first);
+ __pos->_M_owner = __CONST_CAST(__owned_list*, __dst);
+#endif
+ //_STLP_RELEASE_LOCK(__base->_M_lock)
+}
+
+template <class _Iterator>
+void _STLP_CALL __change_ite_owner(const _Iterator& __it,
+ const __owned_list* __dst) {
+ if (__it._Owner() == __dst)
+ return;
+
+ typedef __owned_link _L_type;
+ // Check __stl_debug_engine<_Dummy>::_Swap_owners comments to see why there is no lock here
+ //_STLP_ACQUIRE_LOCK(__base->_M_lock)
+ __owned_list *__base = __CONST_CAST(__owned_list*, __it._Owner());
+ _L_type* __prev = &__base->_M_node;
+ _L_type* __pos = __prev->_M_next;
+ _L_type* __dst_prev = __CONST_CAST(_L_type*, &__dst->_M_node);
+
+ while (__pos != 0) {
+ // this requires safe iterators to be derived from __owned_link
+ if ((__pos != __STATIC_CAST(const _L_type*, &__it)) &&
+ (__STATIC_CAST(_Iterator*, __pos)->_M_iterator == __it._M_iterator)) {
+ __pos->_M_owner = __CONST_CAST(__owned_list*, __dst);
+ //remove __pos from __base:
+ __prev->_M_next = __pos->_M_next;
+ //add __pos to __dst:
+ __pos->_M_next = __dst_prev->_M_next;
+ __dst_prev->_M_next = __pos;
+ }
+ else {
+ __prev = __pos;
+ }
+ __pos = __prev->_M_next;
+ }
+ //_STLP_RELEASE_LOCK(__base->_M_lock)
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_DEBUG */
+
+#if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION)
+
+# ifndef _STLP_INTERNAL_CSTDLIB
+# include <stl/_cstdlib.h>
+# endif
+
+//==========================================================
+// .c section
+// owned_list non-inline methods and global functions
+//==========================================================
+
+# if defined (_STLP_ASSERTIONS)
+
+_STLP_BEGIN_NAMESPACE
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+# if !defined (_STLP_STRING_LITERAL)
+# define _STLP_STRING_LITERAL(__x) __x
+# endif
+
+# if defined (_STLP_USE_WIDE_INTERFACE)
+// note: WinCE needs this to format single-byte strings in __stl_debug_engine::_Message
+# define _STLP_PERCENT_S "%hs"
+# else
+# define _STLP_PERCENT_S "%s"
+# endif /* _STLP_USE_WIDE_INTERFACE */
+
+# define _STLP_MESSAGE_TABLE_BODY = { \
+_STLP_STRING_LITERAL("\n" _STLP_PERCENT_S "(%d): STL error: " _STLP_PERCENT_S "\n"), \
+_STLP_STRING_LITERAL(_STLP_PERCENT_S "(%d): STL assertion failure : " _STLP_PERCENT_S "\n" _STLP_ASSERT_MSG_TRAILER), \
+_STLP_STRING_LITERAL("\n" _STLP_PERCENT_S "(%d): STL error : " _STLP_PERCENT_S "\n" _STLP_PERCENT_S "(%d): STL assertion failure: " _STLP_PERCENT_S " \n" _STLP_ASSERT_MSG_TRAILER), \
+_STLP_STRING_LITERAL("Invalid argument to operation (see operation documentation)"), \
+_STLP_STRING_LITERAL("Taking an iterator out of destroyed (or otherwise corrupted) container"), \
+_STLP_STRING_LITERAL("Trying to extract an object out from empty container"),\
+_STLP_STRING_LITERAL("Past-the-end iterator could not be erased"), \
+_STLP_STRING_LITERAL("Index out of bounds"), \
+_STLP_STRING_LITERAL("Container doesn't own the iterator"), \
+_STLP_STRING_LITERAL("Container is owner of the iterator, but should not"), \
+_STLP_STRING_LITERAL("Uninitialized or invalidated (by mutating operation) iterator used"), \
+_STLP_STRING_LITERAL("Uninitialized or invalidated (by mutating operation) lefthand iterator in expression"), \
+_STLP_STRING_LITERAL("Uninitialized or invalidated (by mutating operation) righthand iterator in expression"), \
+_STLP_STRING_LITERAL("Iterators used in expression are from different owners"), \
+_STLP_STRING_LITERAL("Iterator could not be dereferenced (past-the-end ?)"), \
+_STLP_STRING_LITERAL("Range [first,last) is invalid"), \
+_STLP_STRING_LITERAL("Iterator is not in range [first,last)"), \
+_STLP_STRING_LITERAL("Range [first,last) is not in range [start,finish)"), \
+_STLP_STRING_LITERAL("The advance would produce invalid iterator"), \
+_STLP_STRING_LITERAL("Iterator is singular (advanced beyond the bounds ?)"), \
+_STLP_STRING_LITERAL("Invalid strict weak ordering predicate, if pred(a, b) then we should have !pred(b, a)"), \
+_STLP_STRING_LITERAL("Invalid equivalent predicate, if pred(a, b) then we should have pred(b, a)"), \
+_STLP_STRING_LITERAL("Memory block deallocated twice"), \
+_STLP_STRING_LITERAL("Deallocating a block that was never allocated"), \
+_STLP_STRING_LITERAL("Deallocating a memory block allocated for another type"), \
+_STLP_STRING_LITERAL("Size of block passed to deallocate() doesn't match block size"), \
+_STLP_STRING_LITERAL("Pointer underrun - safety margin at front of memory block overwritten"), \
+_STLP_STRING_LITERAL("Pointer overrrun - safety margin at back of memory block overwritten"), \
+_STLP_STRING_LITERAL("Attempt to dereference null pointer returned by auto_ptr::get()"), \
+_STLP_STRING_LITERAL("Memory allocation function returned a wrongly align memory block"), \
+_STLP_STRING_LITERAL("Unknown problem") \
+ }
+
+template <class _Dummy>
+const char* __stl_debug_engine<_Dummy>::_Message_table[_StlMsg_MAX] _STLP_MESSAGE_TABLE_BODY;
+
+# undef _STLP_STRING_LITERAL
+# undef _STLP_PERCENT_S
+
+_STLP_MOVE_TO_STD_NAMESPACE
+_STLP_END_NAMESPACE
+
+# if !defined (_STLP_DEBUG_MESSAGE)
+# ifndef _STLP_INTERNAL_CSTDARG
+# include <stl/_cstdarg.h>
+# endif
+# ifndef _STLP_INTERNAL_CSTDIO
+# include <stl/_cstdio.h>
+# endif
+# if defined (_STLP_DEBUG_MODE_THROWS) && !defined (_STLP_RANGE_ERRORS_H)
+# include <stl/_range_errors.h>
+# endif
+
+_STLP_BEGIN_NAMESPACE
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Dummy>
+void _STLP_CALL
+__stl_debug_engine<_Dummy>::_Message(const char * __format_str, ...) {
+ STLPORT_CSTD::va_list __args;
+ va_start( __args, __format_str );
+
+# if !defined (_STLP_DEBUG_MODE_THROWS)
+# if defined (_STLP_USE_WIDE_INTERFACE)
+ TCHAR __buffer[512];
+ int _convert = strlen(__format_str) + 1;
+ LPWSTR _lpw = (LPWSTR)alloca(_convert * sizeof(wchar_t));
+ _lpw[0] = '\0';
+ MultiByteToWideChar(GetACP(), 0, __format_str, -1, _lpw, _convert);
+ wvsprintf(__buffer, _lpw, __args);
+ _STLP_WINCE_TRACE(__buffer);
+# elif defined (_STLP_WIN32) && (defined(_STLP_MSVC) || defined (__ICL))
+ char __buffer [4096];
+
+# if !defined (_STLP_USE_SAFE_STRING_FUNCTIONS)
+ vsnprintf(__buffer, _STLP_ARRAY_SIZE(__buffer), __format_str, __args);
+# else
+ vsnprintf_s(__buffer, _STLP_ARRAY_SIZE(__buffer), _TRUNCATE, __format_str, __args);
+# endif
+
+ OutputDebugStringA(__buffer);
+
+# elif defined (__amigaos__)
+ STLPORT_CSTD::vfprintf(stderr, __format_str, (char *)__args);
+# else
+ STLPORT_CSTD::vfprintf(stderr, __format_str, __args);
+# endif
+# else
+ char __buffer[4096];
+
+# if defined (_STLP_USE_SAFE_STRING_FUNCTIONS)
+ vsnprintf_s(__buffer, _STLP_ARRAY_SIZE(__buffer), _TRUNCATE, __format_str, __args);
+# elif defined (_STLP_WIN32) && (defined(_STLP_MSVC) || defined (__ICL))
+ vsnprintf(__buffer, _STLP_ARRAY_SIZE(__buffer), __format_str, __args);
+# else
+ vsprintf(__buffer, __format_str, __args);
+# endif
+# endif
+
+# ifdef _STLP_DEBUG_MESSAGE_POST
+ _STLP_DEBUG_MESSAGE_POST
+# endif
+
+ va_end(__args);
+
+# if defined (_STLP_DEBUG_MODE_THROWS)
+ __stl_throw_runtime_error(__buffer);
+# endif
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+_STLP_END_NAMESPACE
+
+# else
+_STLP_BEGIN_NAMESPACE
+_STLP_MOVE_TO_PRIV_NAMESPACE
+template <class _Dummy>
+void _STLP_CALL
+__stl_debug_engine<_Dummy>::_Message(const char * __format_str, ...)
+{}
+_STLP_MOVE_TO_STD_NAMESPACE
+_STLP_END_NAMESPACE
+# endif /* _STLP_DEBUG_MESSAGE */
+
+_STLP_BEGIN_NAMESPACE
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Dummy>
+void _STLP_CALL
+__stl_debug_engine<_Dummy>::_IndexedError(int __error_ind, const char* __f, int __l) {
+ __stl_debug_message(_Message_table[_StlFormat_ERROR_RETURN],
+ __f, __l, _Message_table[__error_ind]);
+}
+
+template <class _Dummy>
+void _STLP_CALL
+__stl_debug_engine<_Dummy>::_VerboseAssert(const char* __expr, int __error_ind, const char* __f, int __l) {
+ __stl_debug_message(_Message_table[_StlFormat_VERBOSE_ASSERTION_FAILURE],
+ __f, __l, _Message_table[__error_ind], __f, __l, __expr);
+ __stl_debug_terminate();
+}
+
+template <class _Dummy>
+void _STLP_CALL
+__stl_debug_engine<_Dummy>::_Assert(const char* __expr, const char* __f, int __l) {
+ __stl_debug_message(_Message_table[_StlFormat_ASSERTION_FAILURE],__f, __l, __expr);
+ __stl_debug_terminate();
+}
+
+// if exceptions are present, sends unique exception
+// if not, calls abort() to terminate
+template <class _Dummy>
+void _STLP_CALL
+__stl_debug_engine<_Dummy>::_Terminate()
+{ _STLP_ABORT(); }
+
+_STLP_MOVE_TO_STD_NAMESPACE
+_STLP_END_NAMESPACE
+
+# endif /* _STLP_ASSERTIONS */
+
+# if defined (_STLP_DEBUG)
+
+_STLP_BEGIN_NAMESPACE
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+//==========================================================
+// owned_list non-inline methods
+//==========================================================
+
+template <class _Dummy>
+void _STLP_CALL
+__stl_debug_engine<_Dummy>::_Invalidate_all(__owned_list* __l) {
+ _STLP_ACQUIRE_LOCK(__l->_M_lock);
+ _Stamp_all(__l, 0);
+ __l->_M_node._M_next =0;
+ _STLP_RELEASE_LOCK(__l->_M_lock);
+}
+
+// boris : this is unasafe routine; should be used from within critical section only !
+template <class _Dummy>
+void _STLP_CALL
+__stl_debug_engine<_Dummy>::_Stamp_all(__owned_list* __l, __owned_list* __o) {
+ // crucial
+ if (__l->_M_node._M_owner) {
+ for (__owned_link* __pos = (__owned_link*)__l->_M_node._M_next;
+ __pos != 0; __pos = (__owned_link*)__pos->_M_next) {
+ _STLP_ASSERT(__pos->_Owner()== __l)
+ __pos->_M_owner=__o;
+ }
+ }
+}
+
+template <class _Dummy>
+void _STLP_CALL
+__stl_debug_engine<_Dummy>::_Verify(const __owned_list* __l) {
+ _STLP_ACQUIRE_LOCK(__l->_M_lock);
+ if (__l) {
+ _STLP_ASSERT(__l->_M_node._Owner() != 0)
+ for (__owned_link* __pos = (__owned_link*)__l->_M_node._M_next;
+ __pos != 0; __pos = (__owned_link*)__pos->_M_next) {
+ _STLP_ASSERT(__pos->_Owner()== __l)
+ }
+ }
+ _STLP_RELEASE_LOCK(__l->_M_lock);
+}
+
+template <class _Dummy>
+void _STLP_CALL
+__stl_debug_engine<_Dummy>::_Swap_owners(__owned_list& __x, __owned_list& __y) {
+ /*
+ * according to the standard : --no swap() function invalidates any references,
+ * pointers, or iterators referring to the elements of the containers being swapped.
+ */
+
+ __owned_link* __tmp;
+
+ /*
+ * boris : there is a deadlock potential situation here if we lock two containers sequentially.
+ * As user is supposed to provide its own synchronization around swap() ( it is unsafe to do any container/iterator access
+ * in parallel with swap()), we just do not use any locking at all -- that behaviour is closer to non-debug version
+ */
+
+ __tmp = __x._M_node._M_next;
+
+ _Stamp_all(&__x, &__y);
+ _Stamp_all(&__y, &__x);
+
+ __x._M_node._M_next = __y._M_node._M_next;
+ __y._M_node._M_next = __tmp;
+}
+
+template <class _Dummy>
+void _STLP_CALL
+__stl_debug_engine<_Dummy>::_Set_owner(__owned_list& __src, __owned_list& __dst) {
+ if (&__src == &__dst)
+ return;
+
+ // Check __stl_debug_engine<_Dummy>::_Swap_owners comments to see why there is no lock here
+ typedef __owned_link _L_type;
+ _L_type* __prev = &__src._M_node;
+ _L_type* __pos = __prev->_M_next;
+
+ while (__pos != 0) {
+ __pos->_M_owner = &__dst;
+ __prev = __pos;
+ __pos = __prev->_M_next;
+ }
+ __prev->_M_next = __dst._M_node._M_next;
+ __dst._M_node._M_next = __src._M_node._M_next;
+ __src._M_node._M_next = 0;
+}
+
+template <class _Dummy>
+void _STLP_CALL
+__stl_debug_engine<_Dummy>::_M_detach(__owned_list* __l, __owned_link* __c_node) {
+ if (__l != 0) {
+
+ _STLP_VERBOSE_ASSERT(__l->_Owner()!=0, _StlMsg_INVALID_CONTAINER)
+
+ _STLP_ACQUIRE_LOCK(__l->_M_lock)
+ // boris : re-test the condition in case someone else already deleted us
+ if(__c_node->_M_owner != 0) {
+ __owned_link* __prev, *__next;
+
+ for (__prev = &__l->_M_node; (__next = __prev->_M_next) != __c_node;
+ __prev = __next) {
+ _STLP_ASSERT(__next && __next->_Owner() == __l)
+ }
+
+ __prev->_M_next = __c_node->_M_next;
+ __c_node->_M_owner=0;
+ }
+ _STLP_RELEASE_LOCK(__l->_M_lock)
+ }
+}
+
+template <class _Dummy>
+void _STLP_CALL
+__stl_debug_engine<_Dummy>::_M_attach(__owned_list* __l, __owned_link* __c_node) {
+ if (__l ==0) {
+ (__c_node)->_M_owner = 0;
+ } else {
+ _STLP_VERBOSE_ASSERT(__l->_Owner()!=0, _StlMsg_INVALID_CONTAINER)
+ _STLP_ACQUIRE_LOCK(__l->_M_lock)
+ __c_node->_M_owner = __l;
+ __c_node->_M_next = __l->_M_node._M_next;
+ __l->_M_node._M_next = __c_node;
+ _STLP_RELEASE_LOCK(__l->_M_lock)
+ }
+}
+
+template <class _Dummy>
+void* _STLP_CALL
+__stl_debug_engine<_Dummy>::_Get_container_ptr(const __owned_link* __l) {
+ const __owned_list* __owner = __l->_Owner();
+ _STLP_VERBOSE_RETURN_0(__owner != 0, _StlMsg_INVALID_ITERATOR)
+ void* __ret = __CONST_CAST(void*,__owner->_Owner());
+ _STLP_VERBOSE_RETURN_0(__ret !=0, _StlMsg_INVALID_CONTAINER)
+ return __ret;
+}
+
+template <class _Dummy>
+bool _STLP_CALL
+__stl_debug_engine<_Dummy>::_Check_same_owner(const __owned_link& __i1,
+ const __owned_link& __i2) {
+ _STLP_VERBOSE_RETURN(__i1._Valid(), _StlMsg_INVALID_LEFTHAND_ITERATOR)
+ _STLP_VERBOSE_RETURN(__i2._Valid(), _StlMsg_INVALID_RIGHTHAND_ITERATOR)
+ _STLP_VERBOSE_RETURN((__i1._Owner() == __i2._Owner()), _StlMsg_DIFFERENT_OWNERS)
+ return true;
+}
+
+template <class _Dummy>
+bool _STLP_CALL
+__stl_debug_engine<_Dummy>::_Check_same_or_null_owner(const __owned_link& __i1,
+ const __owned_link& __i2) {
+ _STLP_VERBOSE_RETURN(__i1._Owner() == __i2._Owner(), _StlMsg_DIFFERENT_OWNERS)
+ return true;
+}
+
+template <class _Dummy>
+bool _STLP_CALL
+__stl_debug_engine<_Dummy>::_Check_if_owner( const __owned_list * __l, const __owned_link& __it) {
+ const __owned_list* __owner_ptr = __it._Owner();
+ _STLP_VERBOSE_RETURN(__owner_ptr != 0, _StlMsg_INVALID_ITERATOR)
+ _STLP_VERBOSE_RETURN(__l == __owner_ptr, _StlMsg_NOT_OWNER)
+ return true;
+}
+
+template <class _Dummy>
+bool _STLP_CALL
+__stl_debug_engine<_Dummy>::_Check_if_not_owner( const __owned_list * __l, const __owned_link& __it) {
+ const __owned_list* __owner_ptr = __it._Owner();
+ _STLP_VERBOSE_RETURN(__owner_ptr != 0, _StlMsg_INVALID_ITERATOR)
+ _STLP_VERBOSE_RETURN(__l != __owner_ptr, _StlMsg_SHOULD_NOT_OWNER)
+ return true;
+}
+
+_STLP_MOVE_TO_STD_NAMESPACE
+_STLP_END_NAMESPACE
+
+# endif /* _STLP_DEBUG */
+
+#endif /* if defined (EXPOSE_GLOBALS_IMPLEMENTATION) */
+
+#endif /* header guard */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/debug/_debug.h b/sources/android/stlport/stlport/stl/debug/_debug.h
new file mode 100644
index 0000000..6a2a8ce
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/debug/_debug.h
@@ -0,0 +1,473 @@
+/*
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_DEBUG_H
+#define _STLP_DEBUG_H
+
+#if (defined (_STLP_DEBUG) || defined (_STLP_DEBUG_ALLOC)) && \
+ !defined (_STLP_ASSERTIONS)
+# define _STLP_ASSERTIONS 1
+#endif
+
+#if defined (_STLP_ASSERTIONS)
+
+# if !defined (_STLP_FILE__)
+# define _STLP_FILE__ __FILE__
+# endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+enum {
+ //General errors
+ _StlFormat_ERROR_RETURN,
+ _StlFormat_ASSERTION_FAILURE,
+ _StlFormat_VERBOSE_ASSERTION_FAILURE,
+ _StlMsg_INVALID_ARGUMENT,
+ //Container/Iterator related errors
+ _StlMsg_INVALID_CONTAINER,
+ _StlMsg_EMPTY_CONTAINER,
+ _StlMsg_ERASE_PAST_THE_END,
+ _StlMsg_OUT_OF_BOUNDS,
+ _StlMsg_NOT_OWNER,
+ _StlMsg_SHOULD_NOT_OWNER,
+ _StlMsg_INVALID_ITERATOR,
+ _StlMsg_INVALID_LEFTHAND_ITERATOR,
+ _StlMsg_INVALID_RIGHTHAND_ITERATOR,
+ _StlMsg_DIFFERENT_OWNERS ,
+ _StlMsg_NOT_DEREFERENCEABLE ,
+ _StlMsg_INVALID_RANGE ,
+ _StlMsg_NOT_IN_RANGE_1 ,
+ _StlMsg_NOT_IN_RANGE_2 ,
+ _StlMsg_INVALID_ADVANCE ,
+ _StlMsg_SINGULAR_ITERATOR ,
+ //Bad predicate for sorting
+ _StlMsg_INVALID_STRICT_WEAK_PREDICATE,
+ _StlMsg_INVALID_EQUIVALENT_PREDICATE,
+ // debug alloc messages
+ _StlMsg_DBA_DELETED_TWICE ,
+ _StlMsg_DBA_NEVER_ALLOCATED ,
+ _StlMsg_DBA_TYPE_MISMATCH ,
+ _StlMsg_DBA_SIZE_MISMATCH ,
+ _StlMsg_DBA_UNDERRUN ,
+ _StlMsg_DBA_OVERRUN ,
+ // auto_ptr messages
+ _StlMsg_AUTO_PTR_NULL ,
+ //Memory alignent message
+ _StlMsg_WRONG_MEMORY_ALIGNMENT,
+ _StlMsg_UNKNOWN
+ /* _StlMsg_MAX */
+};
+
+/* have to hardcode that ;() */
+# define _StlMsg_MAX 31
+
+class __owned_link;
+class __owned_list;
+
+# if defined (_STLP_DEBUG_MODE_THROWS)
+# define _STLP_MESSAGE_NORETURN _STLP_FUNCTION_THROWS
+# else
+# define _STLP_MESSAGE_NORETURN
+# endif
+
+template <class _Dummy>
+class __stl_debug_engine {
+public:
+ // Basic routine to report any debug message
+ // Use _STLP_DEBUG_MESSAGE to override
+ static void _STLP_MESSAGE_NORETURN _STLP_CALL _Message(const char * format_str, ...);
+
+ // Micsellanous function to report indexed error message
+ static void _STLP_CALL _IndexedError(int __ind, const char* __f, int __l);
+
+ // Basic assertion report mechanism.
+ // Reports failed assertion via __stl_debug_message and calls _Terminate
+ // if _STLP_DEBUG_TERMINATE is specified, calls __stl_debug_terminate instead
+ static void _STLP_CALL _Assert(const char* __expr, const char* __f, int __l);
+
+ // The same, with additional diagnostics
+ static void _STLP_CALL _VerboseAssert(const char* __expr, int __error_ind, const char* __f, int __l);
+
+ // If exceptions are present, sends unique exception
+ // If not, calls _STLP_ABORT() to terminate
+ // Use _STLP_DEBUG_TERMINATE to override
+ static void _STLP_CALL _Terminate();
+
+# if defined (_STLP_DEBUG)
+ // owned_list/link delegate non-inline functions here
+
+ static bool _STLP_CALL _Check_same_owner( const __owned_link& __i1,
+ const __owned_link& __i2);
+ static bool _STLP_CALL _Check_same_or_null_owner( const __owned_link& __i1,
+ const __owned_link& __i2);
+ static bool _STLP_CALL _Check_if_owner( const __owned_list*, const __owned_link&);
+
+ static bool _STLP_CALL _Check_if_not_owner( const __owned_list*, const __owned_link&);
+
+ static void _STLP_CALL _Verify(const __owned_list*);
+
+ static void _STLP_CALL _Swap_owners(__owned_list&, __owned_list&);
+
+ static void _STLP_CALL _Invalidate_all(__owned_list*);
+
+ static void _STLP_CALL _Set_owner(__owned_list& /*src*/, __owned_list& /*dst*/);
+
+ static void _STLP_CALL _Stamp_all(__owned_list*, __owned_list*);
+
+ static void _STLP_CALL _M_detach(__owned_list*, __owned_link*);
+
+ static void _STLP_CALL _M_attach(__owned_list*, __owned_link*);
+
+ // accessor : check and get pointer to the container
+ static void* _STLP_CALL _Get_container_ptr(const __owned_link*);
+# endif
+
+ // debug messages and formats
+ static const char* _Message_table[_StlMsg_MAX];
+};
+
+# undef _STLP_MESSAGE_NORETURN
+
+# if defined (_STLP_USE_TEMPLATE_EXPORT)
+_STLP_EXPORT_TEMPLATE_CLASS __stl_debug_engine<bool>;
+# endif
+
+typedef __stl_debug_engine<bool> __stl_debugger;
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+# if !defined (_STLP_ASSERT)
+# define _STLP_ASSERT(expr) \
+ if (!(expr)) { _STLP_PRIV __stl_debugger::_Assert( # expr, _STLP_FILE__, __LINE__); }
+# endif
+
+#else
+# define _STLP_ASSERT(expr)
+#endif
+
+// this section is for _STLP_DEBUG only
+#if defined (_STLP_DEBUG)
+
+# if !defined (_STLP_VERBOSE_ASSERT)
+// fbp : new form not requiring ";"
+# define _STLP_VERBOSE_ASSERT(expr, __diag_num) \
+ if (!(expr)) { _STLP_PRIV __stl_debugger::_VerboseAssert\
+ ( # expr, _STLP_PRIV __diag_num, _STLP_FILE__, __LINE__ ); \
+ }
+# endif
+
+# define _STLP_DEBUG_CHECK(expr) _STLP_ASSERT(expr)
+
+# if (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
+# define _STLP_STD_DEBUG_CHECK(expr) _STLP_DEBUG_CHECK(expr)
+# else
+# define _STLP_STD_DEBUG_CHECK(expr)
+# endif
+
+# if !defined (_STLP_VERBOSE_RETURN)
+# define _STLP_VERBOSE_RETURN(__expr,__diag_num) if (!(__expr)) { \
+ _STLP_PRIV __stl_debugger::_IndexedError(__diag_num, _STLP_FILE__ , __LINE__); \
+ return false; }
+# endif
+
+# if !defined (_STLP_VERBOSE_RETURN_0)
+# define _STLP_VERBOSE_RETURN_0(__expr,__diag_num) if (!(__expr)) { \
+ _STLP_PRIV __stl_debugger::_IndexedError(__diag_num, _STLP_FILE__, __LINE__); \
+ return 0; }
+# endif
+
+# ifndef _STLP_INTERNAL_THREADS_H
+# include <stl/_threads.h>
+# endif
+
+# ifndef _STLP_INTERNAL_ITERATOR_BASE_H
+# include <stl/_iterator_base.h>
+# endif
+
+# ifndef _STLP_TYPE_TRAITS_H
+# include <stl/type_traits.h>
+# endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+/*
+ * Special debug iterator traits having an additionnal static member
+ * method _Check. It is used by the slist debug implementation to check
+ * the special before_begin iterator.
+ */
+template <class _Traits>
+struct _DbgTraits : _Traits {
+ typedef _DbgTraits<typename _Traits::_ConstTraits> _ConstTraits;
+ typedef _DbgTraits<typename _Traits::_NonConstTraits> _NonConstTraits;
+
+ template <class _Iterator>
+ static bool _Check(const _Iterator&) {return true;}
+};
+
+//=============================================================
+template <class _Iterator>
+inline bool _STLP_CALL __valid_range(const _Iterator& __i1 ,const _Iterator& __i2,
+ const random_access_iterator_tag&)
+{ return (__i1 < __i2) || (__i1 == __i2); }
+
+template <class _Iterator>
+inline bool _STLP_CALL __valid_range(const _Iterator& __i1 ,const _Iterator& __i2,
+ const bidirectional_iterator_tag&) {
+ // check if comparable
+ bool __dummy(__i1==__i2);
+ return (__dummy==__dummy);
+}
+
+template <class _Iterator>
+inline bool _STLP_CALL __valid_range(const _Iterator& __i1 ,const _Iterator& __i2,
+ const forward_iterator_tag&) {
+ // check if comparable
+ bool __dummy(__i1==__i2);
+ return (__dummy==__dummy);
+}
+
+template <class _Iterator>
+inline bool _STLP_CALL __valid_range(const _Iterator&,const _Iterator&,
+ const input_iterator_tag&)
+{ return true; }
+
+template <class _Iterator>
+inline bool _STLP_CALL __valid_range(const _Iterator&,const _Iterator&,
+ const output_iterator_tag&)
+{ return true; }
+
+template <class _Iterator>
+inline bool _STLP_CALL __valid_range(const _Iterator& __i1, const _Iterator& __i2)
+{ return __valid_range(__i1,__i2,_STLP_ITERATOR_CATEGORY(__i1, _Iterator)); }
+
+// Note : that means in range [i1, i2].
+template <class _Iterator>
+inline bool _STLP_CALL stlp_in_range(const _Iterator& _It,
+ const _Iterator& __i1, const _Iterator& __i2)
+{ return __valid_range(__i1,_It) && __valid_range(_It,__i2); }
+
+template <class _Iterator>
+inline bool _STLP_CALL stlp_in_range(const _Iterator& __first, const _Iterator& __last,
+ const _Iterator& __start, const _Iterator& __finish)
+{ return __valid_range(__first,__last) && __valid_range(__start,__first) && __valid_range(__last,__finish); }
+
+//==========================================================
+class _STLP_CLASS_DECLSPEC __owned_link {
+public:
+ // Note: This and the following special defines for compiling under Windows CE under ARM
+ // is needed for correctly using _STLP_DEBUG mode. This comes from a bug in the ARM
+ // compiler where checked iterators that are passed by value call _M_attach with the wrong
+ // this pointer and calling _M_detach can't find the correct pointer to the __owned_link.
+ // This is circumvented by managing a _M_self pointer that points to the correct value.
+ // Ugly but works.
+#if defined(_STLP_WCE) && defined(_ARM_)
+ __owned_link() : _M_self(this), _M_owner(0) {}
+ __owned_link(const __owned_list* __c) : _M_self(this), _M_owner(0), _M_next(0)
+ { __stl_debugger::_M_attach(__CONST_CAST(__owned_list*,__c), this); }
+ __owned_link(const __owned_link& __rhs): _M_self(this), _M_owner(0)
+ { __stl_debugger::_M_attach(__CONST_CAST(__owned_list*,__rhs._M_owner), this); }
+#else
+ __owned_link() : _M_owner(0) {}
+ __owned_link(const __owned_list* __c) : _M_owner(0), _M_next(0)
+ { __stl_debugger::_M_attach(__CONST_CAST(__owned_list*,__c), this); }
+ __owned_link(const __owned_link& __rhs): _M_owner(0)
+ { __stl_debugger::_M_attach(__CONST_CAST(__owned_list*,__rhs._M_owner), this); }
+#endif
+ __owned_link& operator=(const __owned_link& __rhs) {
+ __owned_list* __new_owner = __CONST_CAST(__owned_list*,__rhs._M_owner);
+ __owned_list* __old_owner = _M_owner;
+ if ( __old_owner != __new_owner ) {
+ __stl_debugger::_M_detach(__old_owner, this);
+ __stl_debugger::_M_attach(__new_owner, this);
+ }
+ return *this;
+ }
+#if defined(_STLP_WCE) && defined(_ARM_)
+ ~__owned_link() {
+ __stl_debugger::_M_detach(_M_owner, _M_self);
+ _Invalidate();
+ }
+#else
+ ~__owned_link() {
+ __stl_debugger::_M_detach(_M_owner, this);
+ _Invalidate();
+ }
+#endif
+
+ const __owned_list* _Owner() const { return _M_owner; }
+ __owned_list* _Owner() { return _M_owner; }
+ void _Set_owner(const __owned_list* __o) { _M_owner= __CONST_CAST(__owned_list*,__o); }
+ bool _Valid() const { return _M_owner != 0; }
+ void _Invalidate() { _M_owner = 0; _M_next = 0; }
+ void _Link_to_self() { _M_next = 0; }
+
+ __owned_link* _Next() { return _M_next; }
+ const __owned_link* _Next() const { return _M_next; }
+
+public:
+#if defined(_STLP_WCE) && defined(_ARM_)
+ __owned_link* _M_self;
+#endif
+
+ __owned_list* _M_owner;
+ __owned_link* _M_next;
+};
+
+
+class _STLP_CLASS_DECLSPEC __owned_list {
+public:
+ __owned_list(void* __o) {
+ // fprintf(stderr, "__owned_list(): %p\n",(void*)this);
+ _M_node._M_owner = __REINTERPRET_CAST(__owned_list*,__o);
+ _M_node._M_next = 0;
+ }
+ ~__owned_list() {
+ // fprintf(stderr, "~__owned_list(): %p\n",(void*)this);
+ _Invalidate_all();
+ // that prevents detach
+ _M_node._Invalidate();
+ }
+ const void* _Owner() const { return (const void*)_M_node._M_owner; }
+ void* _Owner() { return (void*)_M_node._M_owner; }
+ bool _Valid() const { return _M_node._M_owner != 0; }
+ void _Invalidate() { _M_node._M_owner = 0; }
+
+ __owned_link* _First() { return _M_node._Next(); }
+ __owned_link* _Last() { return 0 ; }
+
+ const __owned_link* _First() const { return (__owned_link*)_M_node._M_next; }
+ const __owned_link* _Last() const { return 0 ;}
+
+ void _Verify() const { __stl_debugger::_Verify(this); }
+ void _Swap_owners(__owned_list& __y) { __stl_debugger::_Swap_owners(*this, __y); }
+ void _Invalidate_all() { __stl_debugger::_Invalidate_all(this); }
+ void _Set_owner(__owned_list& __y) { __stl_debugger::_Set_owner(*this, __y); }
+
+ mutable __owned_link _M_node;
+ mutable _STLP_mutex _M_lock;
+
+private:
+ // should never be called, should be left not implemented,
+ // but some compilers complain about it ;(
+ __owned_list(const __owned_list&){}
+ __owned_list& operator = (const __owned_list&) { return *this; }
+
+ friend class __owned_link;
+ friend class __stl_debug_engine<bool>;
+};
+
+
+//==========================================================
+
+// forward declaratioins
+
+template <class _Iterator>
+bool _STLP_CALL __check_range(const _Iterator&, const _Iterator&);
+template <class _Iterator>
+bool _STLP_CALL __check_range(const _Iterator&,
+ const _Iterator&, const _Iterator&);
+template <class _Iterator>
+bool _STLP_CALL __check_range(const _Iterator&, const _Iterator& ,
+ const _Iterator&, const _Iterator& );
+template <class _Tp>
+bool _STLP_CALL __check_ptr_range(const _Tp*, const _Tp*);
+
+template <class _Iterator>
+void _STLP_CALL __invalidate_range(const __owned_list* __base,
+ const _Iterator& __first,
+ const _Iterator& __last);
+
+template <class _Iterator>
+void _STLP_CALL __invalidate_iterator(const __owned_list* __base,
+ const _Iterator& __it);
+
+template <class _Iterator>
+void _STLP_CALL __change_range_owner(const _Iterator& __first,
+ const _Iterator& __last,
+ const __owned_list* __dst);
+
+template <class _Iterator>
+void _STLP_CALL __change_ite_owner(const _Iterator& __it,
+ const __owned_list* __dst);
+
+//============================================================
+inline bool _STLP_CALL
+__check_same_owner(const __owned_link& __i1, const __owned_link& __i2)
+{ return __stl_debugger::_Check_same_owner(__i1,__i2); }
+
+inline bool _STLP_CALL
+__check_same_or_null_owner(const __owned_link& __i1, const __owned_link& __i2)
+{ return __stl_debugger::_Check_same_or_null_owner(__i1,__i2); }
+
+template <class _Iterator>
+inline bool _STLP_CALL __check_if_owner( const __owned_list* __owner,
+ const _Iterator& __it)
+{ return __stl_debugger::_Check_if_owner(__owner, (const __owned_link&)__it); }
+
+template <class _Iterator>
+inline bool _STLP_CALL __check_if_not_owner( const __owned_list* __owner,
+ const _Iterator& __it)
+{ return __stl_debugger::_Check_if_not_owner(__owner, (const __owned_link&)__it); }
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#else
+# define _STLP_VERBOSE_ASSERT(expr, diagnostic)
+# define _STLP_DEBUG_CHECK(expr)
+#endif /* _STLP_DEBUG */
+
+#if defined (_STLP_ASSERTIONS)
+
+# if !defined (_STLP_ASSERT_MSG_TRAILER)
+# define _STLP_ASSERT_MSG_TRAILER
+# endif
+
+// dwa 12/30/98 - if _STLP_DEBUG_MESSAGE is defined, the user can supply own definition.
+# if !defined (_STLP_DEBUG_MESSAGE)
+# define __stl_debug_message __stl_debugger::_Message
+# else
+extern void __stl_debug_message(const char * format_str, ...);
+# endif
+
+// fbp: if _STLP_DEBUG_TERMINATE is defined, the user can supply own definition.
+# if !defined (_STLP_DEBUG_TERMINATE)
+# define __stl_debug_terminate __stl_debugger::_Terminate
+# else
+extern void __stl_debug_terminate();
+# endif
+
+#endif
+
+#if defined (_STLP_ASSERTIONS) && !defined (_STLP_LINK_TIME_INSTANTIATION)
+# include <stl/debug/_debug.c>
+#endif
+
+#endif /* DEBUG_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/debug/_deque.h b/sources/android/stlport/stlport/stl/debug/_deque.h
new file mode 100644
index 0000000..f5c5ff5
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/debug/_deque.h
@@ -0,0 +1,414 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_DBG_DEQUE_H
+#define _STLP_INTERNAL_DBG_DEQUE_H
+
+#ifndef _STLP_DBG_ITERATOR_H
+# include <stl/debug/_iterator.h>
+#endif
+
+#define _STLP_NON_DBG_DEQUE _STLP_PRIV _STLP_NON_DBG_NAME(deque) <_Tp,_Alloc>
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS)
+template <class _Tp, class _Alloc>
+inline _Tp* value_type(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_DEQUE >&)
+{ return (_Tp*)0; }
+template <class _Tp, class _Alloc>
+inline random_access_iterator_tag iterator_category(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_DEQUE >&)
+{ return random_access_iterator_tag(); }
+#endif
+
+template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) >
+class deque :
+#if !defined (__DMC__)
+ private
+#endif
+ _STLP_PRIV __construct_checker<_STLP_NON_DBG_DEQUE >
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ , public __stlport_class<deque<_Tp, _Alloc> >
+#endif
+{
+ typedef deque<_Tp,_Alloc> _Self;
+ typedef _STLP_NON_DBG_DEQUE _Base;
+ typedef _STLP_PRIV __construct_checker<_STLP_NON_DBG_DEQUE > _ConstructCheck;
+
+public:
+ // Basic types
+ __IMPORT_CONTAINER_TYPEDEFS(_Base)
+
+ // Iterators
+ typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _DbgTraits<_Nonconst_traits<value_type> > > iterator;
+ typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _DbgTraits<_Const_traits<value_type> > > const_iterator;
+
+ _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS;
+
+protected:
+ _Base _M_non_dbg_impl;
+ _STLP_PRIV __owned_list _M_iter_list;
+
+ void _Invalidate_all()
+ { _M_iter_list._Invalidate_all(); }
+ void _Invalidate_iterator(const iterator& __it)
+ { _STLP_PRIV __invalidate_iterator(&_M_iter_list,__it); }
+ void _Invalidate_iterators(const iterator& __first, const iterator& __last)
+ { _STLP_PRIV __invalidate_range(&_M_iter_list, __first, __last); }
+
+public:
+ // Basic accessors
+ allocator_type get_allocator() const { return _M_non_dbg_impl.get_allocator(); }
+
+ iterator begin() { return iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
+ iterator end() { return iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
+ const_iterator begin() const { return const_iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
+ const_iterator end() const { return const_iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
+
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+ const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+ const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+
+ reference operator[](size_type __n) {
+ _STLP_VERBOSE_ASSERT(__n < size(), _StlMsg_OUT_OF_BOUNDS)
+ return _M_non_dbg_impl[__n];
+ }
+ const_reference operator[](size_type __n) const {
+ _STLP_VERBOSE_ASSERT(__n < size(), _StlMsg_OUT_OF_BOUNDS)
+ return _M_non_dbg_impl[__n];
+ }
+
+ reference at(size_type __n) { return _M_non_dbg_impl.at(__n); }
+ const_reference at(size_type __n) const { return _M_non_dbg_impl.at(__n); }
+
+ reference front() {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ return *begin();
+ }
+ const_reference front() const {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ return *begin();
+ }
+ reference back() {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ return *(--end());
+ }
+ const_reference back() const {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ return *(--end());
+ }
+
+ // Constructor, destructor.
+ explicit deque(const allocator_type& __a = allocator_type()) :
+ _M_non_dbg_impl(__a), _M_iter_list(&_M_non_dbg_impl) {}
+ deque(const _Self& __x) :
+ _ConstructCheck(__x), _M_non_dbg_impl(__x._M_non_dbg_impl),
+ _M_iter_list(&_M_non_dbg_impl) {}
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+ explicit deque(size_type __n, const value_type& __x = _Tp(),
+#else
+ deque(size_type __n, const value_type& __x,
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ const allocator_type& __a = allocator_type()) :
+ _M_non_dbg_impl(__n, __x, __a), _M_iter_list(&_M_non_dbg_impl) {}
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+ explicit deque(size_type __n) :
+ _M_non_dbg_impl(__n), _M_iter_list(&_M_non_dbg_impl) {}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ deque(__move_source<_Self> src)
+ : _M_non_dbg_impl(__move_source<_Base>(src.get()._M_non_dbg_impl)),
+ _M_iter_list(&_M_non_dbg_impl) {
+# if defined (_STLP_NO_EXTENSIONS) || (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
+ src.get()._M_iter_list._Invalidate_all();
+# else
+ src.get()._M_iter_list._Set_owner(_M_iter_list);
+# endif
+ }
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ deque(_InputIterator __first, _InputIterator __last,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _ConstructCheck(__first, __last),
+ _M_non_dbg_impl(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last), __a),
+ _M_iter_list(&_M_non_dbg_impl) {
+ }
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ deque(_InputIterator __first, _InputIterator __last)
+ : _ConstructCheck(__first, __last),
+ _M_non_dbg_impl(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last)),
+ _M_iter_list(&_M_non_dbg_impl) {
+ }
+# endif
+#else
+ deque(const value_type* __first, const value_type* __last,
+ const allocator_type& __a = allocator_type())
+ : _ConstructCheck(__first, __last),
+ _M_non_dbg_impl(__first, __last, __a),
+ _M_iter_list(&_M_non_dbg_impl) {
+ }
+
+ deque(const_iterator __first, const_iterator __last,
+ const allocator_type& __a = allocator_type())
+ : _ConstructCheck(__first, __last),
+ _M_non_dbg_impl(__first._M_iterator, __last._M_iterator, __a),
+ _M_iter_list(&_M_non_dbg_impl) {
+ }
+#endif
+
+ _Self& operator=(const _Self& __x) {
+ if (this != &__x) {
+ _Invalidate_all();
+ _M_non_dbg_impl = __x._M_non_dbg_impl;
+ }
+ return *this;
+ }
+
+ bool empty() const { return _M_non_dbg_impl.empty(); }
+ size_type size() const { return _M_non_dbg_impl.size(); }
+ size_type max_size() const { return _M_non_dbg_impl.max_size(); }
+
+ void swap(_Self& __x) {
+ _M_iter_list._Swap_owners(__x._M_iter_list);
+ _M_non_dbg_impl.swap(__x._M_non_dbg_impl);
+ }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+public:
+ void assign(size_type __n, const _Tp& __val) {
+ _Invalidate_all();
+ _M_non_dbg_impl.assign(__n, __val);
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void assign(_InputIterator __first, _InputIterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _Invalidate_all();
+ _M_non_dbg_impl.assign(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
+ }
+#else
+ void assign(const_iterator __first, const_iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _Invalidate_all();
+ _M_non_dbg_impl.assign(__first._M_iterator, __last._M_iterator);
+ }
+ void assign(const value_type *__first, const value_type *__last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first, __last))
+ _Invalidate_all();
+ _M_non_dbg_impl.assign(__first, __last);
+ }
+#endif
+
+public: // push_* and pop_*
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ void push_back(const value_type& __t = _Tp()) {
+#else
+ void push_back(const value_type& __t) {
+#endif
+ _Invalidate_all();
+ _M_non_dbg_impl.push_back(__t);
+ }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ void push_back() {
+ _Invalidate_all();
+ _M_non_dbg_impl.push_back();
+ }
+#endif
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ void push_front(const value_type& __t = _Tp()) {
+#else
+ void push_front(const value_type& __t) {
+#endif
+ _Invalidate_all();
+ _M_non_dbg_impl.push_front(__t);
+ }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ void push_front() {
+ _Invalidate_all();
+ _M_non_dbg_impl.push_front();
+ }
+#endif
+
+ void pop_back() {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ _Invalidate_iterator(end());
+ _M_non_dbg_impl.pop_back();
+ }
+
+ void pop_front() {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ _Invalidate_iterator(begin());
+ _M_non_dbg_impl.pop_front();
+ }
+
+public: // Insert
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ iterator insert(iterator __pos, const value_type& __x = _Tp()) {
+#else
+ iterator insert(iterator __pos, const value_type& __x) {
+#endif
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _Invalidate_all();
+ return iterator(&_M_iter_list, _M_non_dbg_impl.insert(__pos._M_iterator, __x));
+ }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ iterator insert(iterator __pos) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _Invalidate_all();
+ return iterator(&_M_iter_list, _M_non_dbg_impl.insert(__pos._M_iterator));
+ }
+#endif
+
+ void insert(iterator __pos, size_type __n, const value_type& __x) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ if (__n != 0) _Invalidate_all();
+ _M_non_dbg_impl.insert(__pos._M_iterator, __n, __x);
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ // We perform invalidate first to detect self referencing in __check_range as __first and __last
+ // will have been invalidated.
+ if (__first != __last) _Invalidate_all();
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _M_non_dbg_impl.insert(__pos._M_iterator,
+ _STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
+ }
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES)
+ void insert(iterator __pos,
+ const value_type* __first, const value_type* __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first, __last))
+ if (__first != __last) _Invalidate_all();
+ _M_non_dbg_impl.insert(__pos._M_iterator, __first, __last);
+ }
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION)
+ void insert(iterator __pos,
+ const_iterator __first, const_iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ //Sequence requirements 23.1.1 Table 67:
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_not_owner(&_M_iter_list, __first));
+ if (__first != __last) _Invalidate_all();
+ _M_non_dbg_impl.insert(__pos._M_iterator, __first._M_iterator, __last._M_iterator);
+ }
+
+ void insert(iterator __pos,
+ iterator __first, iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ //Sequence requirements 23.1.1 Table 67:
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_not_owner(&_M_iter_list, __first));
+ if (__first != __last) _Invalidate_all();
+ _M_non_dbg_impl.insert(__pos._M_iterator, __first._M_iterator, __last._M_iterator);
+ }
+#endif
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size, const value_type& __x = _Tp()) {
+#else
+ void resize(size_type __new_size, const value_type& __x) {
+#endif
+ if (__new_size != size()) {
+ if ((__new_size > size()) || (__new_size < size() - 1))
+ _Invalidate_all();
+ else
+ _Invalidate_iterator(end());
+ }
+ _M_non_dbg_impl.resize(__new_size, __x);
+ }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type new_size) { resize(new_size, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+#endif
+
+ // Erase
+ iterator erase(iterator __pos) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
+ if (__pos._M_iterator == _M_non_dbg_impl.begin()) {
+ _Invalidate_iterator(__pos);
+ } else {
+ typename _Base::iterator tmp = --(_M_non_dbg_impl.end());
+ if (__pos._M_iterator == tmp)
+ _Invalidate_iterator(__pos);
+ else
+ _Invalidate_all();
+ }
+ return iterator (&_M_iter_list, _M_non_dbg_impl.erase(__pos._M_iterator));
+ }
+
+ iterator erase(iterator __first, iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, begin(), end()))
+ if (!empty()) {
+ if (__first._M_iterator == _M_non_dbg_impl.begin() ||
+ __last._M_iterator == _M_non_dbg_impl.end())
+ _Invalidate_iterators(__first, __last);
+ else
+ _Invalidate_all();
+ }
+ return iterator (&_M_iter_list, _M_non_dbg_impl.erase(__first._M_iterator, __last._M_iterator));
+ }
+
+ void clear() {
+ _Invalidate_all();
+ _M_non_dbg_impl.clear();
+ }
+};
+
+_STLP_END_NAMESPACE
+
+#undef _STLP_NON_DBG_DEQUE
+
+#endif /* _STLP_INTERNAL_DEQUE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/debug/_hashtable.h b/sources/android/stlport/stlport/stl/debug/_hashtable.h
new file mode 100644
index 0000000..523f7e3
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/debug/_hashtable.h
@@ -0,0 +1,340 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_DBG_HASHTABLE_H
+#define _STLP_INTERNAL_DBG_HASHTABLE_H
+
+// Hashtable class, used to implement the hashed associative containers
+// hash_set, hash_map, hash_multiset, and hash_multimap,
+// unordered_set, unordered_map, unordered_multiset, unordered_multimap
+
+#ifndef _STLP_DBG_ITERATOR_H
+# include <stl/debug/_iterator.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Key, class _Equal>
+class _DbgEqual {
+public:
+ _DbgEqual() {}
+ _DbgEqual(const _Equal& __eq) : _M_non_dbg_eq(__eq) {}
+ _DbgEqual(const _DbgEqual& __eq) : _M_non_dbg_eq(__eq._M_non_dbg_eq) {}
+
+#if !defined (_STLP_USE_CONTAINERS_EXTENSION)
+ bool operator () (const _Key& __lhs, const _Key& __rhs) const
+#else
+ template <class _Kp1, class _Kp2>
+ bool operator () (const _Kp1& __lhs, const _Kp2& __rhs) const
+#endif
+ {
+#if !defined (_STLP_USE_CONTAINERS_EXTENSION)
+ _STLP_VERBOSE_ASSERT(_M_non_dbg_eq(__rhs, __lhs) == _M_non_dbg_eq(__lhs, __rhs), _StlMsg_INVALID_EQUIVALENT_PREDICATE)
+#endif
+ return _M_non_dbg_eq(__lhs, __rhs) ? true : false;
+ }
+
+ _Equal non_dbg_key_eq() const { return _M_non_dbg_eq; }
+private:
+ _Equal _M_non_dbg_eq;
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+#define _STLP_NON_DBG_HT \
+_STLP_PRIV _STLP_NON_DBG_NAME(hashtable) <_Val, _Key, _HF, _Traits, _ExK, _STLP_PRIV _DbgEqual<_Key, _EqK>, _All>
+
+#if defined (_STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS)
+template <class _Val, class _Key, class _HF,
+ class _ExK, class _EqK, class _All>
+inline _Val*
+value_type(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_HT >&)
+{ return (_Val*)0; }
+
+template <class _Val, class _Key, class _HF,
+ class _ExK, class _EqK, class _All>
+inline forward_iterator_tag
+iterator_category(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_HT >&)
+{ return forward_iterator_tag(); }
+#endif
+
+template <class _Val, class _Key, class _HF,
+ class _Traits, class _ExK, class _EqK, class _All>
+class hashtable {
+ typedef hashtable<_Val, _Key, _HF, _Traits, _ExK, _EqK, _All> _Self;
+ typedef _STLP_NON_DBG_HT _Base;
+
+ typedef typename _Traits::_NonConstTraits _NonConstTraits;
+ typedef typename _Traits::_ConstTraits _ConstTraits;
+ typedef typename _Traits::_NonConstLocalTraits _NonConstLocalTraits;
+ typedef typename _Traits::_ConstLocalTraits _ConstLocalTraits;
+
+ _Base _M_non_dbg_impl;
+ _STLP_PRIV __owned_list _M_iter_list;
+
+public:
+ typedef _Key key_type;
+ typedef _HF hasher;
+ typedef _EqK key_equal;
+
+ __IMPORT_CONTAINER_TYPEDEFS(_Base)
+
+ typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _DbgTraits<_NonConstTraits> > iterator;
+ typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _DbgTraits<_ConstTraits> > const_iterator;
+ //typedef _STLP_PRIV _DBG_iter<_Base, _DbgTraits<_NonConstLocalTraits> > local_iterator;
+ typedef iterator local_iterator;
+ //typedef _STLP_PRIV _DBG_iter<_Base, _DbgTraits<_ConstLocalTraits> > const_local_iterator;
+ typedef const_iterator const_local_iterator;
+
+ typedef typename _Base::iterator _Base_iterator;
+ typedef typename _Base::const_iterator _Base_const_iterator;
+
+ hasher hash_funct() const { return _M_non_dbg_impl.hash_funct(); }
+ key_equal key_eq() const { return _M_non_dbg_impl.key_eq().non_dbg_key_eq(); }
+
+private:
+ void _Invalidate_iterator(const const_iterator& __it)
+ { _STLP_PRIV __invalidate_iterator(&_M_iter_list, __it); }
+ void _Invalidate_iterators(const const_iterator& __first, const const_iterator& __last)
+ { _STLP_PRIV __invalidate_range(&_M_iter_list, __first, __last); }
+
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+public:
+ allocator_type get_allocator() const { return _M_non_dbg_impl.get_allocator(); }
+
+ hashtable(size_type __n,
+ const _HF& __hf,
+ const _EqK& __eql,
+ const _ExK& __ext,
+ const allocator_type& __a = allocator_type())
+ : _M_non_dbg_impl(__n, __hf, __eql, __ext, __a),
+ _M_iter_list(&_M_non_dbg_impl) {}
+
+ hashtable(size_type __n,
+ const _HF& __hf,
+ const _EqK& __eql,
+ const allocator_type& __a = allocator_type())
+ : _M_non_dbg_impl(__n, __hf, __eql, __a),
+ _M_iter_list(&_M_non_dbg_impl) {}
+
+ hashtable(const _Self& __ht)
+ : _M_non_dbg_impl(__ht._M_non_dbg_impl),
+ _M_iter_list(&_M_non_dbg_impl) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ hashtable(__move_source<_Self> src)
+ : _M_non_dbg_impl(__move_source<_Base>(src.get()._M_non_dbg_impl)),
+ _M_iter_list(&_M_non_dbg_impl) {
+# if defined (_STLP_NO_EXTENSIONS) || (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
+ src.get()._M_iter_list._Invalidate_all();
+# else
+ src.get()._M_iter_list._Set_owner(_M_iter_list);
+# endif
+ }
+#endif
+
+ size_type size() const { return _M_non_dbg_impl.size(); }
+ size_type max_size() const { return _M_non_dbg_impl.max_size(); }
+ bool empty() const { return _M_non_dbg_impl.empty(); }
+
+ _Self& operator=(const _Self& __ht) {
+ if (this != &__ht) {
+ //Should not invalidate end iterator
+ _Invalidate_iterators(begin(), end());
+ _M_non_dbg_impl = __ht._M_non_dbg_impl;
+ }
+ return *this;
+ }
+
+ void swap(_Self& __ht) {
+ _M_iter_list._Swap_owners(__ht._M_iter_list);
+ _M_non_dbg_impl.swap(__ht._M_non_dbg_impl);
+ }
+
+ iterator begin() { return iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
+ iterator end() { return iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
+ local_iterator begin(size_type __n) {
+ //TODO: Add checks for iterator locality -> avoids comparison between different bucket iterators
+ _STLP_VERBOSE_ASSERT((__n < bucket_count()), _StlMsg_INVALID_ARGUMENT)
+ return local_iterator(&_M_iter_list, _M_non_dbg_impl.begin(__n));
+ }
+ local_iterator end(size_type __n) {
+ //TODO: Add checks for iterator locality -> avoids comparison between different bucket iterators
+ _STLP_VERBOSE_ASSERT((__n < bucket_count()), _StlMsg_INVALID_ARGUMENT)
+ return local_iterator(&_M_iter_list, _M_non_dbg_impl.end(__n));
+ }
+
+ const_iterator begin() const { return const_iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
+ const_iterator end() const { return const_iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
+ const_local_iterator begin(size_type __n) const {
+ //TODO: Add checks for iterator locality -> avoids comparison between different bucket iterators
+ _STLP_VERBOSE_ASSERT((__n < bucket_count()), _StlMsg_INVALID_ARGUMENT)
+ return const_local_iterator(&_M_iter_list, _M_non_dbg_impl.begin(__n));
+ }
+ const_local_iterator end(size_type __n) const {
+ //TODO: Add checks for iterator locality -> avoids comparison between different bucket iterators
+ _STLP_VERBOSE_ASSERT((__n < bucket_count()), _StlMsg_INVALID_ARGUMENT)
+ return const_local_iterator(&_M_iter_list, _M_non_dbg_impl.end(__n));
+ }
+
+ pair<iterator, bool> insert_unique(const value_type& __obj) {
+ pair<_Base_iterator, bool> __res = _M_non_dbg_impl.insert_unique(__obj);
+ return pair<iterator, bool>(iterator(&_M_iter_list, __res.first), __res.second);
+ }
+
+ iterator insert_equal(const value_type& __obj)
+ { return iterator(&_M_iter_list, _M_non_dbg_impl.insert_equal(__obj)); }
+
+ pair<iterator, bool> insert_unique_noresize(const value_type& __obj) {
+ pair<_Base_iterator, bool> __res = _M_non_dbg_impl.insert_unique_noresize(__obj);
+ return pair<iterator, bool>(iterator(&_M_iter_list, __res.first), __res.second);
+ }
+
+ iterator insert_equal_noresize(const value_type& __obj)
+ { return iterator(&_M_iter_list, _M_non_dbg_impl.insert_equal_noresize(__obj)); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void insert_unique(_InputIterator __f, _InputIterator __l) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l))
+ _M_non_dbg_impl.insert_unique(_STLP_PRIV _Non_Dbg_iter(__f), _STLP_PRIV _Non_Dbg_iter(__l));
+ }
+
+ template <class _InputIterator>
+ void insert_equal(_InputIterator __f, _InputIterator __l){
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l))
+ _M_non_dbg_impl.insert_equal(_STLP_PRIV _Non_Dbg_iter(__f), _STLP_PRIV _Non_Dbg_iter(__l));
+ }
+
+#else
+ void insert_unique(const value_type* __f, const value_type* __l) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__f, __l))
+ _M_non_dbg_impl.insert_unique(__f, __l);
+ }
+
+ void insert_equal(const value_type* __f, const value_type* __l) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__f, __l))
+ _M_non_dbg_impl.insert_equal(__f, __l);
+ }
+
+ void insert_unique(const_iterator __f, const_iterator __l) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l))
+ _M_non_dbg_impl.insert_unique(__f._M_iterator, __l._M_iterator);
+ }
+
+ void insert_equal(const_iterator __f, const_iterator __l) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l))
+ _M_non_dbg_impl.insert_equal(__f._M_iterator, __l._M_iterator);
+ }
+#endif
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __key)
+ { return iterator(&_M_iter_list, _M_non_dbg_impl.find(__key)); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __key) const
+ { return const_iterator(&_M_iter_list, _M_non_dbg_impl.find(__key)); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __key) const { return _M_non_dbg_impl.count(__key); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator, iterator> equal_range(const _KT& __key) {
+ pair<_Base_iterator, _Base_iterator> __res = _M_non_dbg_impl.equal_range(__key);
+ return pair<iterator,iterator> (iterator(&_M_iter_list,__res.first),
+ iterator(&_M_iter_list,__res.second));
+ }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator> equal_range(const _KT& __key) const {
+ pair <_Base_const_iterator, _Base_const_iterator> __res = _M_non_dbg_impl.equal_range(__key);
+ return pair<const_iterator,const_iterator> (const_iterator(&_M_iter_list,__res.first),
+ const_iterator(&_M_iter_list,__res.second));
+ }
+
+ size_type erase(const key_type& __key) {
+ pair<iterator, iterator> __p = equal_range(__key);
+ size_type __n = _STLP_STD::distance(__p.first, __p.second);
+ _Invalidate_iterators(__p.first, __p.second);
+ _M_non_dbg_impl.erase(__p.first._M_iterator, __p.second._M_iterator);
+ return __n;
+ }
+
+ void erase(const const_iterator& __it) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__it))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __it))
+ _Invalidate_iterator(__it);
+ _M_non_dbg_impl.erase(__it._M_iterator);
+ }
+ void erase(const_iterator __first, const_iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last,
+ const_iterator(begin()), const_iterator(end())))
+ _Invalidate_iterators(__first, __last);
+ _M_non_dbg_impl.erase(__first._M_iterator, __last._M_iterator);
+ }
+
+ void rehash(size_type __num_buckets_hint) { _M_non_dbg_impl.rehash(__num_buckets_hint); }
+ void resize(size_type __num_elements_hint) { _M_non_dbg_impl.resize(__num_elements_hint); }
+
+ void clear() {
+ _Invalidate_iterators(begin(), end());
+ _M_non_dbg_impl.clear();
+ }
+
+ reference _M_insert(const value_type& __obj) { return _M_non_dbg_impl._M_insert(__obj); }
+
+ size_type bucket_count() const { return _M_non_dbg_impl.bucket_count(); }
+ size_type max_bucket_count() const { return _M_non_dbg_impl.max_bucket_count(); }
+ size_type elems_in_bucket(size_type __n) const {
+ _STLP_VERBOSE_ASSERT((__n < bucket_count()), _StlMsg_INVALID_ARGUMENT)
+ return _M_non_dbg_impl.elems_in_bucket(__n);
+ }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type bucket(const _KT& __k) const { return _M_non_dbg_impl.bucket(__k); }
+
+ float load_factor() const { return _M_non_dbg_impl.load_factor(); }
+ float max_load_factor() const { return _M_non_dbg_impl.max_load_factor(); }
+ void max_load_factor(float __z) {
+ _STLP_VERBOSE_ASSERT((__z > 0.0f), _StlMsg_INVALID_ARGUMENT)
+ _M_non_dbg_impl.max_load_factor(__z);
+ }
+};
+
+_STLP_END_NAMESPACE
+
+#undef _STLP_NON_DBG_HT
+
+#endif /* _STLP_INTERNAL_HASHTABLE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/debug/_iterator.h b/sources/android/stlport/stlport/stl/debug/_iterator.h
new file mode 100644
index 0000000..b2c8956
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/debug/_iterator.h
@@ -0,0 +1,457 @@
+/*
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_DBG_ITERATOR_H
+#define _STLP_DBG_ITERATOR_H
+
+#ifndef _STLP_INTERNAL_PAIR_H
+# include <stl/_pair.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+# include <stl/_alloc.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+//============================================================
+
+template <class _Iterator>
+void _Decrement(_Iterator& __it, const bidirectional_iterator_tag &)
+{ --__it; }
+
+template <class _Iterator>
+void _Decrement(_Iterator& __it, const random_access_iterator_tag &)
+{ --__it; }
+
+template <class _Iterator>
+void _Decrement(_Iterator& __it, const forward_iterator_tag &)
+{ _STLP_ASSERT(0) }
+
+template <class _Iterator>
+void _Advance(_Iterator&, ptrdiff_t, const forward_iterator_tag &)
+{ _STLP_ASSERT(0) }
+
+template <class _Iterator>
+void _Advance(_Iterator& __it, ptrdiff_t, const bidirectional_iterator_tag &)
+{ _STLP_ASSERT(0) }
+
+template <class _Iterator>
+void _Advance(_Iterator& __it, ptrdiff_t __n, const random_access_iterator_tag &)
+{ __it += __n; }
+
+template <class _Iterator>
+ptrdiff_t _DBG_distance(const _Iterator& __x, const _Iterator& __y, const random_access_iterator_tag &)
+{ return __x - __y; }
+
+template <class _Iterator>
+ptrdiff_t _DBG_distance(const _Iterator&, const _Iterator&, const forward_iterator_tag &) {
+ _STLP_ASSERT(0)
+ return 0;
+}
+
+template <class _Iterator>
+ptrdiff_t _DBG_distance(const _Iterator&, const _Iterator&, const bidirectional_iterator_tag &) {
+ _STLP_ASSERT(0)
+ return 0;
+}
+
+template <class _Iterator>
+bool _CompareIt(const _Iterator&, const _Iterator&, const forward_iterator_tag &) {
+ _STLP_ASSERT(0)
+ return false;
+}
+
+template <class _Iterator>
+bool _CompareIt(const _Iterator&, const _Iterator&, const bidirectional_iterator_tag &) {
+ _STLP_ASSERT(0)
+ return false;
+}
+
+template <class _Iterator>
+bool _CompareIt(const _Iterator& __x, const _Iterator& __y, const random_access_iterator_tag &)
+{ return __x < __y; }
+
+template <class _Iterator>
+bool _Dereferenceable(const _Iterator& __it)
+{ return (__it._Get_container_ptr() != 0) && !(__it._M_iterator == (__it._Get_container_ptr())->end()); }
+
+template <class _Iterator>
+bool _Incrementable(const _Iterator& __it, ptrdiff_t __n, const forward_iterator_tag &)
+{ return (__n == 1) && _Dereferenceable(__it); }
+
+template <class _Iterator>
+bool _Incrementable(const _Iterator& __it, ptrdiff_t __n, const bidirectional_iterator_tag &) {
+ typedef typename _Iterator::_Container_type __container_type;
+ __container_type* __c = __it._Get_container_ptr();
+ return (__c != 0) && ((__n == 1 && __it._M_iterator != __c->end() ) ||
+ (__n == -1 && __it._M_iterator != __c->begin()));
+}
+
+template <class _Iterator>
+bool _Incrementable(const _Iterator& __it, ptrdiff_t __n, const random_access_iterator_tag &) {
+ typedef typename _Iterator::_Container_type __container_type;
+ __container_type* __c = __it._Get_container_ptr();
+ if (__c == 0) return false;
+ ptrdiff_t __new_pos = (__it._M_iterator - __c->begin()) + __n;
+ return (__new_pos >= 0) && (__STATIC_CAST(typename __container_type::size_type, __new_pos) <= __c->size());
+}
+
+
+template <class _Container>
+struct _DBG_iter_base : public __owned_link {
+public:
+ typedef typename _Container::value_type value_type;
+ typedef typename _Container::reference reference;
+ typedef typename _Container::pointer pointer;
+ typedef ptrdiff_t difference_type;
+ //private:
+ typedef typename _Container::iterator _Nonconst_iterator;
+ typedef typename _Container::const_iterator _Const_iterator;
+ typedef _Container _Container_type;
+
+#ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
+ typedef typename iterator_traits<_Const_iterator>::iterator_category _Iterator_category;
+#else
+ typedef typename _Container::_Iterator_category _Iterator_category;
+#endif
+ typedef _Iterator_category iterator_category;
+
+ _DBG_iter_base() : __owned_link(0) {}
+ _DBG_iter_base(const __owned_list* __c, const _Const_iterator& __it) :
+#if defined(__HP_aCC) && (__HP_aCC < 60000)
+ __owned_link(__c), _M_iterator(*__REINTERPRET_CAST(const _Nonconst_iterator *, &__it)) {}
+#else
+ __owned_link(__c), _M_iterator(*(const _Nonconst_iterator*)&__it) {}
+#endif
+ _Container* _Get_container_ptr() const {
+ return (_Container*)__stl_debugger::_Get_container_ptr(this);
+ }
+
+ void __increment();
+ void __decrement();
+ void __advance(ptrdiff_t __n);
+
+// protected:
+ _Nonconst_iterator _M_iterator;
+};
+
+template <class _Container>
+inline void _DBG_iter_base<_Container>::__increment() {
+ _STLP_DEBUG_CHECK(_Incrementable(*this, 1, _Iterator_category()))
+ ++_M_iterator;
+}
+
+template <class _Container>
+inline void _DBG_iter_base<_Container>::__decrement() {
+ _STLP_DEBUG_CHECK(_Incrementable(*this, -1, _Iterator_category()))
+ _Decrement(_M_iterator, _Iterator_category());
+}
+
+template <class _Container>
+inline void _DBG_iter_base<_Container>::__advance(ptrdiff_t __n) {
+ _STLP_DEBUG_CHECK(_Incrementable(*this, __n, _Iterator_category()))
+ _Advance(_M_iterator, __n, _Iterator_category());
+}
+
+template <class _Container>
+ptrdiff_t operator-(const _DBG_iter_base<_Container>& __x,
+ const _DBG_iter_base<_Container>& __y ) {
+ typedef typename _DBG_iter_base<_Container>::_Iterator_category _Iterator_category;
+ _STLP_DEBUG_CHECK(__check_same_owner(__x, __y))
+ return _DBG_distance(__x._M_iterator,__y._M_iterator, _Iterator_category());
+}
+
+template <class _Container, class _Traits>
+struct _DBG_iter_mid : public _DBG_iter_base<_Container> {
+ typedef _DBG_iter_mid<_Container, typename _Traits::_NonConstTraits> _Nonconst_self;
+ typedef typename _Container::iterator _Nonconst_iterator;
+ typedef typename _Container::const_iterator _Const_iterator;
+
+ _DBG_iter_mid() {}
+
+ explicit _DBG_iter_mid(const _Nonconst_self& __it) :
+ _DBG_iter_base<_Container>(__it) {}
+
+ _DBG_iter_mid(const __owned_list* __c, const _Const_iterator& __it) :
+ _DBG_iter_base<_Container>(__c, __it) {}
+};
+
+template <class _Container, class _Traits>
+struct _DBG_iter : public _DBG_iter_mid<_Container, _Traits> {
+ typedef _DBG_iter_base<_Container> _Base;
+public:
+ typedef typename _Base::value_type value_type;
+ typedef typename _Base::difference_type difference_type;
+ typedef typename _Traits::reference reference;
+ typedef typename _Traits::pointer pointer;
+
+ typedef typename _Base::_Nonconst_iterator _Nonconst_iterator;
+ typedef typename _Base::_Const_iterator _Const_iterator;
+
+private:
+ typedef _DBG_iter<_Container, _Traits> _Self;
+ typedef _DBG_iter_mid<_Container, typename _Traits::_NonConstTraits> _Nonconst_mid;
+
+public:
+
+#ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
+ typedef typename _Base::iterator_category iterator_category;
+#endif
+ typedef typename _Base::_Iterator_category _Iterator_category;
+
+public:
+ _DBG_iter() {}
+ // boris : real type of iter would be nice
+ _DBG_iter(const __owned_list* __c, const _Const_iterator& __it) :
+ _DBG_iter_mid<_Container, _Traits>(__c, __it) {}
+
+ // This allows conversions from iterator to const_iterator without being
+ // redundant with the copy constructor below.
+ _DBG_iter(const _Nonconst_mid& __rhs) :
+ _DBG_iter_mid<_Container, _Traits>(__rhs) {}
+
+ _DBG_iter(const _Self& __rhs) :
+ _DBG_iter_mid<_Container, _Traits>(__rhs) {}
+
+ // This allows conversions from iterator to const_iterator without being
+ // redundant with the copy assignment operator below.
+ _Self& operator=(const _Nonconst_mid& __rhs) {
+ (_Base&)*this = __rhs;
+ return *this;
+ }
+
+ _Self& operator=(const _Self& __rhs) {
+ (_Base&)*this = __rhs;
+ return *this;
+ }
+
+ reference operator*() const;
+
+ _STLP_DEFINE_ARROW_OPERATOR
+
+ _Self& operator++() {
+ this->__increment();
+ return *this;
+ }
+ _Self operator++(int) {
+ _Self __tmp = *this;
+ this->__increment();
+ return __tmp;
+ }
+ _Self& operator--() {
+ this->__decrement();
+ return *this;
+ }
+ _Self operator--(int) {
+ _Self __tmp = *this;
+ this->__decrement();
+ return __tmp;
+ }
+
+ _Self& operator+=(difference_type __n) {
+ this->__advance(__n);
+ return *this;
+ }
+
+ _Self& operator-=(difference_type __n) {
+ this->__advance(-__n);
+ return *this;
+ }
+ _Self operator+(difference_type __n) const {
+ _Self __tmp(*this);
+ __tmp.__advance(__n);
+ return __tmp;
+ }
+ _Self operator-(difference_type __n) const {
+ _Self __tmp(*this);
+ __tmp.__advance(-__n);
+ return __tmp;
+ }
+ reference operator[](difference_type __n) const { return *(*this + __n); }
+};
+
+template <class _Container, class _Traits>
+inline
+#if defined (_STLP_NESTED_TYPE_PARAM_BUG)
+_STLP_TYPENAME_ON_RETURN_TYPE _Traits::reference
+#else
+_STLP_TYPENAME_ON_RETURN_TYPE _DBG_iter<_Container, _Traits>::reference
+#endif
+_DBG_iter<_Container, _Traits>::operator*() const {
+ _STLP_DEBUG_CHECK(_Dereferenceable(*this))
+ _STLP_DEBUG_CHECK(_Traits::_Check(*this))
+ return *this->_M_iterator;
+}
+
+template <class _Container>
+inline bool
+operator==(const _DBG_iter_base<_Container>& __x, const _DBG_iter_base<_Container>& __y) {
+ _STLP_DEBUG_CHECK(__check_same_or_null_owner(__x, __y))
+ return __x._M_iterator == __y._M_iterator;
+}
+
+template <class _Container>
+inline bool
+operator<(const _DBG_iter_base<_Container>& __x, const _DBG_iter_base<_Container>& __y) {
+ _STLP_DEBUG_CHECK(__check_same_or_null_owner(__x, __y))
+ typedef typename _DBG_iter_base<_Container>::_Iterator_category _Category;
+ return _CompareIt(__x._M_iterator , __y._M_iterator, _Category());
+}
+
+template <class _Container>
+inline bool
+operator>(const _DBG_iter_base<_Container>& __x,
+ const _DBG_iter_base<_Container>& __y) {
+ typedef typename _DBG_iter_base<_Container>::_Iterator_category _Category;
+ return _CompareIt(__y._M_iterator , __x._M_iterator, _Category());
+}
+
+template <class _Container>
+inline bool
+operator>=(const _DBG_iter_base<_Container>& __x, const _DBG_iter_base<_Container>& __y) {
+ _STLP_DEBUG_CHECK(__check_same_or_null_owner(__x, __y))
+ typedef typename _DBG_iter_base<_Container>::_Iterator_category _Category;
+ return !_CompareIt(__x._M_iterator , __y._M_iterator, _Category());
+}
+
+template <class _Container>
+inline bool
+operator<=(const _DBG_iter_base<_Container>& __x,
+ const _DBG_iter_base<_Container>& __y) {
+ typedef typename _DBG_iter_base<_Container>::_Iterator_category _Category;
+ return !_CompareIt(__y._M_iterator , __x._M_iterator, _Category());
+}
+
+template <class _Container>
+inline bool
+operator!=(const _DBG_iter_base<_Container>& __x,
+ const _DBG_iter_base<_Container>& __y) {
+ _STLP_DEBUG_CHECK(__check_same_or_null_owner(__x, __y))
+ return __x._M_iterator != __y._M_iterator;
+}
+
+//------------------------------------------
+
+template <class _Container, class _Traits>
+inline _DBG_iter<_Container, _Traits>
+operator+(ptrdiff_t __n, const _DBG_iter<_Container, _Traits>& __it) {
+ _DBG_iter<_Container, _Traits> __tmp(__it);
+ return __tmp += __n;
+}
+
+
+template <class _Iterator>
+inline _Iterator _Non_Dbg_iter(_Iterator __it)
+{ return __it; }
+
+#if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+template <class _Container, class _Traits>
+inline typename _DBG_iter<_Container, _Traits>::_Nonconst_iterator
+_Non_Dbg_iter(const _DBG_iter<_Container, _Traits>& __it)
+{ return __it._M_iterator; }
+#endif
+
+/*
+ * Helper classes to check iterator range or pointer validity
+ * at construction time.
+ */
+template <class _Container>
+class __construct_checker {
+ typedef typename _Container::value_type value_type;
+protected:
+ __construct_checker() {}
+
+ __construct_checker(const value_type* __p) {
+ _STLP_VERBOSE_ASSERT((__p != 0), _StlMsg_INVALID_ARGUMENT)
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIter>
+ __construct_checker(const _InputIter& __f, const _InputIter& __l) {
+ typedef typename _IsIntegral<_InputIter>::_Ret _Integral;
+ _M_check_dispatch(__f, __l, _Integral());
+ }
+
+ template <class _Integer>
+ void _M_check_dispatch(_Integer , _Integer, const __true_type& /*IsIntegral*/) {}
+
+ template <class _InputIter>
+ void _M_check_dispatch(const _InputIter& __f, const _InputIter& __l, const __false_type& /*IsIntegral*/) {
+ _STLP_DEBUG_CHECK(__check_range(__f,__l))
+ }
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION)
+ __construct_checker(const value_type* __f, const value_type* __l) {
+ _STLP_DEBUG_CHECK(__check_ptr_range(__f,__l))
+ }
+
+ typedef _DBG_iter_base<_Container> _IteType;
+ __construct_checker(const _IteType& __f, const _IteType& __l) {
+ _STLP_DEBUG_CHECK(__check_range(__f,__l))
+ }
+#endif
+#if defined (__BORLANDC__)
+ ~__construct_checker(){}
+#endif
+};
+
+#if defined (_STLP_USE_OLD_HP_ITERATOR_QUERIES)
+# if defined (_STLP_NESTED_TYPE_PARAM_BUG) ||\
+ (defined (__SUNPRO_CC) && __SUNPRO_CC < 0x600)
+# define _STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS 1
+# endif
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _Container>
+inline ptrdiff_t*
+distance_type(const _STLP_PRIV _DBG_iter_base<_Container>&) { return (ptrdiff_t*) 0; }
+
+# if !defined (_STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS)
+template <class _Container>
+inline _STLP_TYPENAME_ON_RETURN_TYPE _STLP_PRIV _DBG_iter_base<_Container>::value_type*
+value_type(const _STLP_PRIV _DBG_iter_base<_Container>&) {
+ typedef _STLP_TYPENAME _STLP_PRIV _DBG_iter_base<_Container>::value_type _Val;
+ return (_Val*)0;
+}
+
+template <class _Container>
+inline _STLP_TYPENAME_ON_RETURN_TYPE _STLP_PRIV _DBG_iter_base<_Container>::_Iterator_category
+iterator_category(const _STLP_PRIV _DBG_iter_base<_Container>&) {
+ typedef _STLP_TYPENAME _STLP_PRIV _DBG_iter_base<_Container>::_Iterator_category _Category;
+ return _Category();
+}
+# endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+#endif /* _STLP_USE_OLD_HP_ITERATOR_QUERIES */
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* INTERNAL_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/debug/_list.h b/sources/android/stlport/stlport/stl/debug/_list.h
new file mode 100644
index 0000000..c45e1e7
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/debug/_list.h
@@ -0,0 +1,495 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_DBG_LIST_H
+#define _STLP_INTERNAL_DBG_LIST_H
+
+#ifndef _STLP_INTERNAL_ALGO_H
+# include <stl/_algo.h>
+#endif
+
+#ifndef _STLP_DBG_ITERATOR_H
+# include <stl/debug/_iterator.h>
+#endif
+
+#define _STLP_NON_DBG_LIST _STLP_PRIV _STLP_NON_DBG_NAME(list) <_Tp, _Alloc>
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS)
+template <class _Tp, class _Alloc>
+inline _Tp*
+value_type(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_LIST >&)
+{ return (_Tp*)0; }
+template <class _Tp, class _Alloc>
+inline bidirectional_iterator_tag
+iterator_category(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_LIST >&)
+{ return bidirectional_iterator_tag(); }
+#endif
+
+template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) >
+class list :
+#if !defined (__DMC__)
+ private
+#endif
+ _STLP_PRIV __construct_checker<_STLP_NON_DBG_LIST >
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ , public __stlport_class<list<_Tp, _Alloc> >
+#endif
+{
+ typedef _STLP_NON_DBG_LIST _Base;
+ typedef list<_Tp, _Alloc> _Self;
+ typedef _STLP_PRIV __construct_checker<_STLP_NON_DBG_LIST > _ConstructCheck;
+
+public:
+ __IMPORT_CONTAINER_TYPEDEFS(_Base)
+
+public:
+ typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _DbgTraits<_Nonconst_traits<value_type> > > iterator;
+ typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _DbgTraits<_Const_traits<value_type> > > const_iterator;
+
+ _STLP_DECLARE_BIDIRECTIONAL_REVERSE_ITERATORS;
+
+private:
+ _Base _M_non_dbg_impl;
+ _STLP_PRIV __owned_list _M_iter_list;
+
+ void _Invalidate_iterator(const iterator& __it)
+ { _STLP_PRIV __invalidate_iterator(&_M_iter_list, __it); }
+ void _Invalidate_iterators(const iterator& __first, const iterator& __last)
+ { _STLP_PRIV __invalidate_range(&_M_iter_list, __first, __last); }
+
+ typedef typename _Base::iterator _Base_iterator;
+
+public:
+ explicit list(const allocator_type& __a = allocator_type()) :
+ _M_non_dbg_impl(__a), _M_iter_list(&_M_non_dbg_impl) {}
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+ explicit list(size_type __n, const _Tp& __x = _Tp(),
+#else
+ list(size_type __n, const _Tp& __x,
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM*/
+ const allocator_type& __a = allocator_type())
+ : _M_non_dbg_impl(__n, __x, __a), _M_iter_list(&_M_non_dbg_impl) {}
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+ explicit list(size_type __n)
+ : _M_non_dbg_impl(__n), _M_iter_list(&_M_non_dbg_impl) {}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ list(__move_source<_Self> src)
+ : _M_non_dbg_impl(__move_source<_Base>(src.get()._M_non_dbg_impl)),
+ _M_iter_list(&_M_non_dbg_impl) {
+# if defined (_STLP_NO_EXTENSIONS) || (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
+ src.get()._M_iter_list._Invalidate_all();
+# else
+ src.get()._M_iter_list._Set_owner(_M_iter_list);
+# endif
+ }
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ list(_InputIterator __first, _InputIterator __last,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _ConstructCheck(__first, __last),
+ _M_non_dbg_impl(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last), __a),
+ _M_iter_list(&_M_non_dbg_impl) {}
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ list(_InputIterator __first, _InputIterator __last)
+ : _ConstructCheck(__first, __last),
+ _M_non_dbg_impl(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last)),
+ _M_iter_list(&_M_non_dbg_impl) {}
+# endif
+#else
+
+ list(const value_type* __first, const value_type* __last,
+ const allocator_type& __a = allocator_type())
+ : _ConstructCheck(__first, __last),
+ _M_non_dbg_impl(__first, __last, __a),
+ _M_iter_list(&_M_non_dbg_impl) {}
+ list(const_iterator __first, const_iterator __last,
+ const allocator_type& __a = allocator_type())
+ : _ConstructCheck(__first, __last),
+ _M_non_dbg_impl(__first._M_iterator, __last._M_iterator, __a),
+ _M_iter_list(&_M_non_dbg_impl) {}
+
+#endif
+
+ list(const _Self& __x) :
+ _ConstructCheck(__x),
+ _M_non_dbg_impl(__x._M_non_dbg_impl) , _M_iter_list(&_M_non_dbg_impl) {}
+
+ _Self& operator=(const _Self& __x) {
+ if (this != &__x) {
+ //Should not invalidate end iterator
+ _Invalidate_iterators(begin(), end());
+ _M_non_dbg_impl = __x._M_non_dbg_impl;
+ }
+ return *this;
+ }
+
+ allocator_type get_allocator() const { return _M_non_dbg_impl.get_allocator(); }
+
+ iterator begin() { return iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
+ const_iterator begin() const { return const_iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
+
+ iterator end() { return iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
+ const_iterator end() const { return const_iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
+
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+
+ const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+ const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+
+ size_type size() const { return _M_non_dbg_impl.size(); }
+ size_type max_size() const { return _M_non_dbg_impl.max_size(); }
+ bool empty() const { return _M_non_dbg_impl.empty(); }
+
+ // those are here to enforce checking
+ reference front() {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ return *begin();
+ }
+ const_reference front() const {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ return *begin();
+ }
+ reference back() {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ return *(--end());
+ }
+ const_reference back() const {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ return *(--end());
+ }
+
+ void swap(_Self& __x) {
+ _M_iter_list._Swap_owners(__x._M_iter_list);
+ _M_non_dbg_impl.swap(__x._M_non_dbg_impl);
+ }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+ iterator insert(iterator __pos, const _Tp& __x = _Tp()) {
+#else
+ iterator insert(iterator __pos, const _Tp& __x) {
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
+ return iterator(&_M_iter_list,_M_non_dbg_impl.insert(__pos._M_iterator, __x) );
+ }
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+ iterator insert(iterator __pos) { return insert(__pos, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _M_non_dbg_impl.insert(__pos._M_iterator,
+ _STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
+ }
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES)
+ void insert(iterator __pos, const _Tp* __first, const _Tp* __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first, __last))
+ _M_non_dbg_impl.insert(__pos._M_iterator, __first, __last);
+ }
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION)
+ void insert(iterator __pos,
+ const_iterator __first, const_iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+# if (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
+ _STLP_STD_DEBUG_CHECK(__check_if_not_owner(&_M_iter_list, __first))
+# endif
+ _M_non_dbg_impl.insert(__pos._M_iterator, __first._M_iterator, __last._M_iterator);
+ }
+ void insert(iterator __pos,
+ iterator __first, iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+# if (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
+ _STLP_STD_DEBUG_CHECK(__check_if_not_owner(&_M_iter_list, __first))
+# endif
+ _M_non_dbg_impl.insert(__pos._M_iterator, __first._M_iterator, __last._M_iterator);
+ }
+#endif
+
+ void insert(iterator __pos, size_type __n, const _Tp& __x) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
+ _M_non_dbg_impl.insert(__pos._M_iterator, __n, __x);
+ }
+
+ void push_back(const_reference __x) { _M_non_dbg_impl.push_back(__x); }
+ void pop_back() {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ _Invalidate_iterator(end());
+ _M_non_dbg_impl.pop_back();
+ }
+
+ void push_front(const_reference __x) { _M_non_dbg_impl.push_front(__x); }
+ void pop_front() {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ _Invalidate_iterator(begin());
+ _M_non_dbg_impl.pop_front();
+ }
+
+ iterator erase(iterator __pos) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
+ _Invalidate_iterator(__pos);
+ return iterator(&_M_iter_list,_M_non_dbg_impl.erase(__pos._M_iterator));
+ }
+ iterator erase(iterator __first, iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, begin(), end()))
+ _Invalidate_iterators(__first, __last);
+ return iterator (&_M_iter_list, _M_non_dbg_impl.erase(__first._M_iterator, __last._M_iterator));
+ }
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size, const _Tp& __x = _Tp()) {
+#else
+ void resize(size_type __new_size, const _Tp& __x) {
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ _Base_iterator __i = _M_non_dbg_impl.begin();
+ size_type __len = 0;
+ for ( ; __i != _M_non_dbg_impl.end() && __len < __new_size; ++__i, ++__len);
+
+ if (__len == __new_size)
+ erase(iterator(&_M_iter_list, __i), end());
+ else // __i == end()
+ _M_non_dbg_impl.insert(_M_non_dbg_impl.end(), __new_size - __len, __x);
+ }
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size) { resize(__new_size, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void assign(_InputIterator __first, _InputIterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _M_non_dbg_impl.assign(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
+ _Invalidate_iterators(begin(), end());
+ }
+#else
+ void assign(const _Tp* __first, const _Tp* __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first, __last))
+ _M_non_dbg_impl.assign(__first, __last);
+ _Invalidate_iterators(begin(), end());
+ }
+
+ void assign(iterator __first, iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _M_non_dbg_impl.assign(__first._M_iterator, __last._M_iterator);
+ _Invalidate_iterators(begin(), end());
+ }
+
+ void assign(const_iterator __first, const_iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _M_non_dbg_impl.assign(__first._M_iterator, __last._M_iterator);
+ _Invalidate_iterators(begin(), end());
+ }
+#endif
+
+ void assign(size_type __n, const _Tp& __val) {
+ _Invalidate_iterators(begin(), end());
+ _M_non_dbg_impl.assign(__n, __val);
+ }
+
+ void remove(const _Tp& __x) {
+ _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
+ while (__first != __last) {
+ _Base_iterator __next = __first;
+ ++__next;
+ if (__x == *__first) {
+ _Invalidate_iterator(iterator(&_M_iter_list, __first));
+ _M_non_dbg_impl.erase(__first);
+ }
+ __first = __next;
+ }
+ }
+
+ void clear() {
+ _Invalidate_iterators(begin(), end());
+ _M_non_dbg_impl.clear();
+ }
+
+public:
+ void splice(iterator __pos, _Self& __x) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
+ _M_non_dbg_impl.splice(__pos._M_iterator, __x._M_non_dbg_impl);
+#if (_STLP_DEBUG_LEVEL != _STLP_STANDARD_DBG_LEVEL)
+ if (get_allocator() == __x.get_allocator())
+ __x._M_iter_list._Set_owner(_M_iter_list);
+ else
+#endif
+ // Std: 23.2.2.4:4
+ // end iterator is not invalidated:
+ __x._Invalidate_iterators(__x.begin(), __x.end());
+ }
+
+ void splice(iterator __pos, _Self& __x, iterator __i) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__i))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&(__x._M_iter_list),__i))
+ _M_non_dbg_impl.splice(__pos._M_iterator, __x._M_non_dbg_impl, __i._M_iterator);
+#if (_STLP_DEBUG_LEVEL != _STLP_STANDARD_DBG_LEVEL)
+ if (get_allocator() == __x.get_allocator())
+ _STLP_PRIV __change_ite_owner(__i, &_M_iter_list);
+ else
+#endif
+ // Std: 23.2.2.4:7
+ __x._Invalidate_iterator(__i);
+ }
+
+ void splice(iterator __pos, _Self& __x, iterator __first, iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, __x.begin(), __x.end()))
+ _STLP_DEBUG_CHECK(this == &__x ? !_STLP_PRIV __check_range(__pos, __first, __last) : true)
+#if (_STLP_DEBUG_LEVEL != _STLP_STANDARD_DBG_LEVEL)
+ if (this->get_allocator() == __x.get_allocator())
+ _STLP_PRIV __change_range_owner(__first, __last, &_M_iter_list);
+ else
+#endif
+ // Std: 23.2.2.4:12
+ __x._Invalidate_iterators(__first, __last);
+ _M_non_dbg_impl.splice(__pos._M_iterator, __x._M_non_dbg_impl, __first._M_iterator, __last._M_iterator);
+ }
+
+ void merge(_Self& __x) {
+#if !defined (_STLP_NO_EXTENSIONS)
+ _STLP_DEBUG_CHECK(_STLP_STD::is_sorted(begin()._M_iterator, end()._M_iterator))
+ _STLP_DEBUG_CHECK(_STLP_STD::is_sorted(__x.begin()._M_iterator, __x.end()._M_iterator))
+#endif
+ _M_non_dbg_impl.merge(__x._M_non_dbg_impl);
+ if (this->get_allocator() == __x.get_allocator()) {
+ __x._M_iter_list._Set_owner(_M_iter_list);
+ }
+ else {
+ __x._Invalidate_iterators(__x.begin(), __x.end());
+ }
+ }
+ void reverse() {
+ _M_non_dbg_impl.reverse();
+ }
+ void unique() {
+ _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
+ if (__first == __last) return;
+ _Base_iterator __next = __first;
+ while (++__next != __last) {
+ if (*__first == *__next) {
+ _Invalidate_iterator(iterator(&_M_iter_list, __next));
+ _M_non_dbg_impl.erase(__next);
+ }
+ else
+ __first = __next;
+ __next = __first;
+ }
+ }
+ void sort() {
+ _M_non_dbg_impl.sort();
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _Predicate>
+ void remove_if(_Predicate __pred) {
+ _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
+ while (__first != __last) {
+ _Base_iterator __next = __first;
+ ++__next;
+ if (__pred(*__first)) {
+ _Invalidate_iterator(iterator(&_M_iter_list, __first));
+ _M_non_dbg_impl.erase(__first);
+ }
+ __first = __next;
+ }
+ }
+
+ template <class _BinaryPredicate>
+ void unique(_BinaryPredicate __binary_pred) {
+ _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
+ if (__first == __last) return;
+ _Base_iterator __next = __first;
+ while (++__next != __last) {
+ if (__binary_pred(*__first, *__next)) {
+ _Invalidate_iterator(iterator(&_M_iter_list, __next));
+ _M_non_dbg_impl.erase(__next);
+ }
+ else
+ __first = __next;
+ __next = __first;
+ }
+ }
+
+ template <class _StrictWeakOrdering>
+ void merge(_Self& __x, _StrictWeakOrdering __comp) {
+#if !defined (_STLP_NO_EXTENSIONS)
+ _STLP_DEBUG_CHECK(_STLP_STD::is_sorted(_M_non_dbg_impl.begin(), _M_non_dbg_impl.end(), __comp))
+ _STLP_DEBUG_CHECK(_STLP_STD::is_sorted(__x.begin()._M_iterator, __x.end()._M_iterator, __comp))
+#endif
+ _M_non_dbg_impl.merge(__x._M_non_dbg_impl, __comp);
+ if (this->get_allocator() == __x.get_allocator()) {
+ __x._M_iter_list._Set_owner(_M_iter_list);
+ }
+ else {
+ __x._Invalidate_iterators(__x.begin(), __x.end());
+ }
+ }
+
+ template <class _StrictWeakOrdering>
+ void sort(_StrictWeakOrdering __comp) {
+ _M_non_dbg_impl.sort(__comp);
+ }
+#endif
+};
+
+
+_STLP_END_NAMESPACE
+
+#undef _STLP_NON_DBG_LIST
+
+#endif /* _STLP_INTERNAL_LIST_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/debug/_slist.h b/sources/android/stlport/stlport/stl/debug/_slist.h
new file mode 100644
index 0000000..2eeaf36
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/debug/_slist.h
@@ -0,0 +1,613 @@
+/*
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_DBG_SLIST_H
+#define _STLP_INTERNAL_DBG_SLIST_H
+
+#ifndef _STLP_DBG_ITERATOR_H
+# include <stl/debug/_iterator.h>
+#endif
+
+#define _STLP_NON_DBG_SLIST _STLP_PRIV _STLP_NON_DBG_NAME(slist) <_Tp, _Alloc>
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS)
+template <class _Tp, class _Alloc>
+inline _Tp*
+value_type(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_SLIST >&)
+{ return (_Tp*)0; }
+
+template <class _Tp, class _Alloc>
+inline forward_iterator_tag
+iterator_category(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_SLIST >&)
+{ return forward_iterator_tag(); }
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+/*
+ * slist special debug traits version.
+ */
+template <class _Traits>
+struct _SlistDbgTraits : _Traits {
+ typedef _SlistDbgTraits<typename _Traits::_ConstTraits> _ConstTraits;
+ typedef _SlistDbgTraits<typename _Traits::_NonConstTraits> _NonConstTraits;
+
+ /*
+ * We don't want the before_begin iterator to return false at _Dereferenceable
+ * call to do not break the current debug framework but calling * operator should
+ * fail.
+ */
+ template <class _Iterator>
+ static bool _Check(const _Iterator& __it)
+ { return !(__it._M_iterator == (__it._Get_container_ptr())->before_begin()); }
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) >
+class slist :
+#if !defined (__DMC__)
+ private
+#endif
+ _STLP_PRIV __construct_checker<_STLP_NON_DBG_SLIST >
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ , public __stlport_class<slist<_Tp, _Alloc> >
+#endif
+{
+private:
+ typedef _STLP_NON_DBG_SLIST _Base;
+ typedef slist<_Tp,_Alloc> _Self;
+ typedef _STLP_PRIV __construct_checker<_STLP_NON_DBG_SLIST > _ConstructCheck;
+
+public:
+
+ __IMPORT_CONTAINER_TYPEDEFS(_Base)
+
+ typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _SlistDbgTraits<_Nonconst_traits<value_type> > > iterator;
+ typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _SlistDbgTraits<_Const_traits<value_type> > > const_iterator;
+
+ allocator_type get_allocator() const { return _M_non_dbg_impl.get_allocator(); }
+private:
+ _Base _M_non_dbg_impl;
+ _STLP_PRIV __owned_list _M_iter_list;
+
+ void _Invalidate_iterator(const iterator& __it)
+ { _STLP_PRIV __invalidate_iterator(&_M_iter_list, __it); }
+ void _Invalidate_iterators(const iterator& __first, const iterator& __last)
+ { _STLP_PRIV __invalidate_range(&_M_iter_list, __first, __last); }
+
+ typedef typename _Base::iterator _Base_iterator;
+
+public:
+ explicit slist(const allocator_type& __a = allocator_type())
+ : _M_non_dbg_impl(__a) , _M_iter_list(&_M_non_dbg_impl) {}
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+ explicit slist(size_type __n, const value_type& __x = _Tp(),
+#else
+ slist(size_type __n, const value_type& __x,
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ const allocator_type& __a = allocator_type())
+ : _M_non_dbg_impl(__n, __x, __a), _M_iter_list(&_M_non_dbg_impl) {}
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+ explicit slist(size_type __n) : _M_non_dbg_impl(__n) , _M_iter_list(&_M_non_dbg_impl) {}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ slist(__move_source<_Self> src)
+ : _M_non_dbg_impl(__move_source<_Base>(src.get()._M_non_dbg_impl)),
+ _M_iter_list(&_M_non_dbg_impl) {
+# if defined (_STLP_NO_EXTENSIONS) || (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
+ src.get()._M_iter_list._Invalidate_all();
+# else
+ src.get()._M_iter_list._Set_owner(_M_iter_list);
+# endif
+ }
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ // We don't need any dispatching tricks here, because _M_insert_after_range
+ // already does them.
+ template <class _InputIterator>
+ slist(_InputIterator __first, _InputIterator __last,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _ConstructCheck(__first, __last),
+ _M_non_dbg_impl(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last), __a),
+ _M_iter_list(&_M_non_dbg_impl) {}
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ slist(_InputIterator __first, _InputIterator __last)
+ : _ConstructCheck(__first, __last),
+ _M_non_dbg_impl(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last)),
+ _M_iter_list(&_M_non_dbg_impl) {}
+# endif
+#else
+
+ slist(const value_type* __first, const value_type* __last,
+ const allocator_type& __a = allocator_type())
+ : _ConstructCheck(__first, __last),
+ _M_non_dbg_impl(__first, __last, __a),
+ _M_iter_list(&_M_non_dbg_impl) {}
+
+ slist(const_iterator __first, const_iterator __last,
+ const allocator_type& __a = allocator_type() )
+ : _ConstructCheck(__first, __last),
+ _M_non_dbg_impl(__first._M_iterator, __last._M_iterator, __a),
+ _M_iter_list(&_M_non_dbg_impl) {}
+#endif
+
+ slist(const _Self& __x) :
+ _ConstructCheck(__x),
+ _M_non_dbg_impl(__x._M_non_dbg_impl), _M_iter_list(&_M_non_dbg_impl) {}
+
+ _Self& operator= (const _Self& __x) {
+ if (this != &__x) {
+ _Invalidate_iterators(begin(), end());
+ _M_non_dbg_impl = __x._M_non_dbg_impl;
+ }
+ return *this;
+ }
+
+ ~slist() {}
+
+ void assign(size_type __n, const value_type& __val) {
+ _Invalidate_iterators(begin(), end());
+ _M_non_dbg_impl.assign(__n, __val);
+ }
+
+ iterator before_begin()
+ { return iterator(&_M_iter_list, _M_non_dbg_impl.before_begin()); }
+ const_iterator before_begin() const
+ { return const_iterator(&_M_iter_list, _M_non_dbg_impl.before_begin()); }
+
+ iterator begin()
+ { return iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
+ const_iterator begin() const
+ { return const_iterator(&_M_iter_list, _M_non_dbg_impl.begin());}
+
+ iterator end()
+ { return iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
+ const_iterator end() const
+ { return const_iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
+
+ bool empty() const { return _M_non_dbg_impl.empty(); }
+ size_type size() const { return _M_non_dbg_impl.size(); }
+ size_type max_size() const { return _M_non_dbg_impl.max_size(); }
+
+ void swap(_Self& __x) {
+ _M_iter_list._Swap_owners(__x._M_iter_list);
+ _M_non_dbg_impl.swap(__x._M_non_dbg_impl);
+ }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+ reference front() {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ return _M_non_dbg_impl.front();
+ }
+ const_reference front() const {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ return _M_non_dbg_impl.front();
+ }
+ void push_front(const_reference __x) { _M_non_dbg_impl.push_front(__x); }
+ void pop_front() {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ _M_non_dbg_impl.pop_front();
+ }
+ iterator previous(const_iterator __pos) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
+ return iterator(&_M_iter_list, _M_non_dbg_impl.previous(__pos._M_iterator));
+ }
+ const_iterator previous(const_iterator __pos) const {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
+ return const_iterator(&_M_iter_list, _M_non_dbg_impl.previous(__pos._M_iterator));
+ }
+
+public:
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ iterator insert_after(iterator __pos, const value_type& __x = _Tp()) {
+#else
+ iterator insert_after(iterator __pos, const value_type& __x) {
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ return iterator(&_M_iter_list,_M_non_dbg_impl.insert_after(__pos._M_iterator, __x));
+ }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+ iterator insert_after(iterator __pos) {
+ return insert_after(__pos, _STLP_DEFAULT_CONSTRUCTED(_Tp));
+ }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+ void insert_after(iterator __pos, size_type __n, const value_type& __x) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _M_non_dbg_impl.insert_after(__pos._M_iterator, __n, __x);
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void assign(_InputIterator __first, _InputIterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _Invalidate_iterators(begin(), end());
+ _M_non_dbg_impl.assign(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
+ }
+#else
+ void assign(const_iterator __first, const_iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _Invalidate_iterators(begin(), end());
+ _M_non_dbg_impl.assign(__first._M_iterator, __last._M_iterator);
+ }
+ void assign(const value_type *__first, const value_type *__last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first, __last))
+ _Invalidate_iterators(begin(), end());
+ _M_non_dbg_impl.assign(__first, __last);
+ }
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InIter>
+ void insert_after(iterator __pos, _InIter __first, _InIter __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _M_non_dbg_impl.insert_after(__pos._M_iterator,
+ _STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
+ }
+
+ template <class _InIter>
+ void insert(iterator __pos, _InIter __first, _InIter __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _M_non_dbg_impl.insert(__pos._M_iterator,
+ _STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
+ }
+#else
+ void insert_after(iterator __pos,
+ const_iterator __first, const_iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _M_non_dbg_impl.insert_after(__pos._M_iterator, __first._M_iterator, __last._M_iterator);
+ }
+ void insert_after(iterator __pos,
+ const value_type* __first, const value_type* __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first, __last))
+ _M_non_dbg_impl.insert_after(__pos._M_iterator, __first, __last);
+ }
+
+ void insert(iterator __pos, const_iterator __first, const_iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _M_non_dbg_impl.insert(__pos._M_iterator, __first._M_iterator, __last._M_iterator);
+ }
+ void insert(iterator __pos, const value_type* __first,
+ const value_type* __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
+ _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first, __last))
+ _M_non_dbg_impl.insert(__pos._M_iterator, __first, __last);
+ }
+#endif
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ iterator insert(iterator __pos, const value_type& __x = _Tp()) {
+#else
+ iterator insert(iterator __pos, const value_type& __x) {
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
+ return iterator(&_M_iter_list, _M_non_dbg_impl.insert(__pos._M_iterator, __x));
+ }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+ iterator insert(iterator __pos) {
+ return insert(__pos, _STLP_DEFAULT_CONSTRUCTED(_Tp));
+ }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+ void insert(iterator __pos, size_type __n, const value_type& __x) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
+ _M_non_dbg_impl.insert(__pos._M_iterator, __n, __x);
+ }
+
+public:
+ iterator erase_after(iterator __pos) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
+ iterator __tmp = __pos; ++__tmp;
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__tmp))
+ _Invalidate_iterator(__tmp);
+ return iterator(&_M_iter_list, _M_non_dbg_impl.erase_after(__pos._M_iterator));
+ }
+ iterator erase_after(iterator __before_first, iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__before_first))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__before_first, __last, begin(), end()))
+ iterator __tmp = __before_first; ++__tmp;
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__tmp))
+ _Invalidate_iterators(__tmp, __last);
+ return iterator(&_M_iter_list, _M_non_dbg_impl.erase_after(__before_first._M_iterator, __last._M_iterator));
+ }
+
+ iterator erase(iterator __pos) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
+ _STLP_VERBOSE_ASSERT(__pos._M_iterator != _M_non_dbg_impl.before_begin(), _StlMsg_INVALID_ARGUMENT)
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _Invalidate_iterator(__pos);
+ return iterator(&_M_iter_list, _M_non_dbg_impl.erase(__pos._M_iterator));
+ }
+ iterator erase(iterator __first, iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, begin(), end()))
+ _Invalidate_iterators(__first, __last);
+ return iterator(&_M_iter_list, _M_non_dbg_impl.erase(__first._M_iterator, __last._M_iterator));
+ }
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size, const value_type& __x = _Tp()) {
+#else
+ void resize(size_type __new_size, const value_type& __x) {
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ _M_non_dbg_impl.resize(__new_size, __x);
+ }
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size) { resize(__new_size, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+ void clear() {
+ _Invalidate_iterators(begin(), end());
+ _M_non_dbg_impl.clear();
+ }
+
+public:
+ // Removes all of the elements from the list __x to *this, inserting
+ // them immediately after __pos. __x must not be *this. Complexity:
+ // linear in __x.size().
+ void splice_after(iterator __pos, _Self& __x) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
+ _STLP_VERBOSE_ASSERT(!(&__x == this), _StlMsg_INVALID_ARGUMENT)
+ _M_non_dbg_impl.splice_after(__pos._M_iterator, __x._M_non_dbg_impl);
+ if (get_allocator() == __x.get_allocator()) {
+ __x._M_iter_list._Set_owner(_M_iter_list);
+ }
+ else {
+ __x._Invalidate_iterators(__x.begin(), __x.end());
+ }
+ }
+
+ // Moves the element that follows __prev to *this, inserting it immediately
+ // after __pos. This is constant time.
+ void splice_after(iterator __pos, _Self& __x, iterator __prev) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__prev))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&__x._M_iter_list, __prev))
+ iterator __elem = __prev; ++__elem;
+ _M_non_dbg_impl.splice_after(__pos._M_iterator, __x._M_non_dbg_impl, __prev._M_iterator);
+ if (get_allocator() == __x.get_allocator()) {
+ _STLP_PRIV __change_ite_owner(__elem, &_M_iter_list);
+ }
+ else {
+ __x._Invalidate_iterator(__elem);
+ }
+ }
+
+ // Moves the range [__before_first + 1, __before_last + 1) to *this,
+ // inserting it immediately after __pos. This is constant time.
+ void splice_after(iterator __pos, _Self& __x,
+ iterator __before_first, iterator __before_last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__before_first, __before_last))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&__x._M_iter_list, __before_first))
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__before_first))
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__before_last))
+ iterator __first = __before_first; ++__first;
+ iterator __last = __before_last; ++__last;
+ if (get_allocator() == __x.get_allocator()) {
+ _STLP_PRIV __change_range_owner(__first, __last, &_M_iter_list);
+ }
+ else {
+ __x._Invalidate_iterators(__first, __last);
+ }
+ _M_non_dbg_impl.splice_after(__pos._M_iterator, __x._M_non_dbg_impl,
+ __before_first._M_iterator, __before_last._M_iterator);
+ }
+
+ void splice(iterator __pos, _Self& __x) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
+ _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
+ _STLP_VERBOSE_ASSERT(!(&__x == this), _StlMsg_INVALID_ARGUMENT)
+ _M_non_dbg_impl.splice(__pos._M_iterator, __x._M_non_dbg_impl);
+ if (get_allocator() == __x.get_allocator()) {
+ __x._M_iter_list._Set_owner(_M_iter_list);
+ }
+ else {
+ __x._Invalidate_iterators(__x.begin(), __x.end());
+ }
+ }
+
+ void splice(iterator __pos, _Self& __x, iterator __i) {
+ //__pos should be owned by *this and not be the before_begin iterator
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
+ _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
+ //__i should be dereferenceable, not before_begin and be owned by __x
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__i))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&__x._M_iter_list ,__i))
+ _STLP_VERBOSE_ASSERT(!(__i == __x.before_begin()), _StlMsg_INVALID_ARGUMENT)
+ if (get_allocator() == __x.get_allocator()) {
+ _STLP_PRIV __change_ite_owner(__i, &_M_iter_list);
+ }
+ else {
+ __x._Invalidate_iterator(__i);
+ }
+ _M_non_dbg_impl.splice(__pos._M_iterator, __x._M_non_dbg_impl, __i._M_iterator);
+ }
+
+ void splice(iterator __pos, _Self& __x, iterator __first, iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
+ _STLP_VERBOSE_ASSERT(!(__pos._M_iterator == _M_non_dbg_impl.before_begin()), _StlMsg_INVALID_ARGUMENT)
+ //_STLP_VERBOSE_ASSERT(&__x != this, _StlMsg_INVALID_ARGUMENT)
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, __x.begin(), __x.end()))
+ if (get_allocator() == __x.get_allocator()) {
+ _STLP_PRIV __change_range_owner(__first, __last, &_M_iter_list);
+ }
+ else {
+ __x._Invalidate_iterators(__first, __last);
+ }
+ _M_non_dbg_impl.splice(__pos._M_iterator, __x._M_non_dbg_impl,
+ __first._M_iterator, __last._M_iterator);
+ }
+
+ void reverse()
+ { _M_non_dbg_impl.reverse(); }
+
+ void remove(const value_type& __val) {
+ _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
+ while (__first != __last) {
+ _Base_iterator __next = __first;
+ ++__next;
+ if (__val == *__first) {
+ _Invalidate_iterator(iterator(&_M_iter_list, __first));
+ _M_non_dbg_impl.erase(__first);
+ }
+ __first = __next;
+ }
+ }
+ void unique() {
+ _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
+ if (__first == __last) return;
+ _Base_iterator __next = __first;
+ while (++__next != __last) {
+ if (*__first == *__next) {
+ _Invalidate_iterator(iterator(&_M_iter_list, __next));
+ _M_non_dbg_impl.erase(__next);
+ }
+ else
+ __first = __next;
+ __next = __first;
+ }
+ }
+ void merge(_Self& __x) {
+ _STLP_VERBOSE_ASSERT(&__x != this, _StlMsg_INVALID_ARGUMENT)
+#if !defined (_STLP_NO_EXTENSIONS)
+ /* comments below due to bug in GCC compilers: ones eat all memory and die if see
+ * something like namespace_name::func_name() - ptr
+ */
+ _STLP_DEBUG_CHECK( /* _STLP_STD:: */ is_sorted(_M_non_dbg_impl.begin(), _M_non_dbg_impl.end()))
+ _STLP_DEBUG_CHECK( /* _STLP_STD:: */ is_sorted(__x.begin()._M_iterator, __x.end()._M_iterator))
+#endif
+ _M_non_dbg_impl.merge(__x._M_non_dbg_impl);
+ if (get_allocator() == __x.get_allocator()) {
+ __x._M_iter_list._Set_owner(_M_iter_list);
+ }
+ else {
+ __x._Invalidate_iterators(__x.begin(), __x.end());
+ }
+ }
+ void sort() {
+ _M_non_dbg_impl.sort();
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _Predicate>
+ void remove_if(_Predicate __pred) {
+ _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
+ while (__first != __last) {
+ _Base_iterator __next = __first;
+ ++__next;
+ if (__pred(*__first)) {
+ _Invalidate_iterator(iterator(&_M_iter_list, __first));
+ _M_non_dbg_impl.erase(__first);
+ }
+ __first = __next;
+ }
+ }
+
+ template <class _BinaryPredicate>
+ void unique(_BinaryPredicate __pred) {
+ _Base_iterator __first = _M_non_dbg_impl.begin(), __last = _M_non_dbg_impl.end();
+ if (__first == __last) return;
+ _Base_iterator __next = __first;
+ while (++__next != __last) {
+ if (__binary_pred(*__first, *__next)) {
+ _Invalidate_iterator(iterator(&_M_iter_list, __next));
+ _M_non_dbg_impl.erase(__next);
+ }
+ else
+ __first = __next;
+ __next = __first;
+ }
+ }
+
+ template <class _StrictWeakOrdering>
+ void merge(_Self& __x, _StrictWeakOrdering __ord) {
+ _STLP_VERBOSE_ASSERT(&__x != this, _StlMsg_INVALID_ARGUMENT)
+#if !defined (_STLP_NO_EXTENSIONS)
+ /* comments below due to bug in GCC compilers: ones eat all memory and die if see
+ * something like namespace_name::func_name() - ptr
+ */
+ _STLP_DEBUG_CHECK( /* _STLP_STD:: */ is_sorted(_M_non_dbg_impl.begin(), _M_non_dbg_impl.end(), __ord))
+ _STLP_DEBUG_CHECK( /* _STLP_STD:: */ is_sorted(__x.begin()._M_iterator, __x.end()._M_iterator, __ord))
+#endif
+ _M_non_dbg_impl.merge(__x._M_non_dbg_impl, __ord);
+ if (get_allocator() == __x.get_allocator()) {
+ __x._M_iter_list._Set_owner(_M_iter_list);
+ }
+ else {
+ __x._Invalidate_iterators(__x.begin(), __x.end());
+ }
+ }
+
+ template <class _StrictWeakOrdering>
+ void sort(_StrictWeakOrdering __comp)
+ { _M_non_dbg_impl.sort(__comp); }
+#endif
+};
+
+_STLP_END_NAMESPACE
+
+#undef _STLP_NON_DBG_SLIST
+
+#endif /* _STLP_INTERNAL_DBG_SLIST_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/debug/_string.h b/sources/android/stlport/stlport/stl/debug/_string.h
new file mode 100644
index 0000000..49f7ab2
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/debug/_string.h
@@ -0,0 +1,828 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+#ifndef _STLP_DBG_STRING_H
+#define _STLP_DBG_STRING_H
+
+#ifndef _STLP_DBG_ITERATOR_H
+# include <stl/debug/_iterator.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#define _STLP_NON_DBG_STRING_NAME _STLP_NON_DBG_NAME(str)
+#define _STLP_NON_DBG_STRING _STLP_PRIV _STLP_NON_DBG_STRING_NAME <_CharT, _Traits, _Alloc>
+
+#if defined (_STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS)
+template <class _CharT,class _Traits, class _Alloc>
+inline _CharT*
+value_type(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_STRING >&)
+{ return (_CharT*)0; }
+template <class _CharT, class _Traits, class _Alloc>
+inline random_access_iterator_tag
+iterator_category(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_STRING >&)
+{ return random_access_iterator_tag(); }
+#endif
+
+template <class _CharT, class _Traits, class _Alloc>
+class basic_string :
+#if !defined (__DMC__)
+ private
+#else
+ public
+#endif
+ _STLP_PRIV __construct_checker<_STLP_NON_DBG_STRING >
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (basic_string)
+ , public __stlport_class<basic_string<_CharT, _Traits, _Alloc> >
+#endif
+{
+protected:
+ typedef _STLP_NON_DBG_STRING _Base;
+ typedef basic_string<_CharT, _Traits, _Alloc> _Self;
+ typedef _STLP_PRIV __construct_checker<_STLP_NON_DBG_STRING > _ConstructCheck;
+ typedef typename _IsPOD<_CharT>::_Type _Char_Is_POD;
+
+public:
+ __IMPORT_CONTAINER_TYPEDEFS(_Base)
+ typedef typename _Base::traits_type traits_type;
+ typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _DbgTraits<_Nonconst_traits<value_type> > > iterator;
+ typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _DbgTraits<_Const_traits<value_type> > > const_iterator;
+ _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS;
+
+public: // Constructor, destructor, assignment.
+ typedef typename _Base::_Reserve_t _Reserve_t;
+
+private:
+ _Base _M_non_dbg_impl;
+ _STLP_PRIV __owned_list _M_iter_list;
+
+ void _Invalidate_all()
+ { _M_iter_list._Invalidate_all(); }
+ void _Compare_Capacity (size_type __old_capacity) {
+ if (this->capacity() > __old_capacity) {
+ _Invalidate_all();
+ }
+ }
+ void _Invalidate_iterator(const iterator& __it)
+ { _STLP_PRIV __invalidate_iterator(&_M_iter_list, __it); }
+ void _Invalidate_iterators(const iterator& __f, const iterator& __l)
+ { _STLP_PRIV __invalidate_range(&_M_iter_list, __f, __l); }
+
+public:
+#include <stl/_string_npos.h>
+
+ allocator_type get_allocator() const { return _M_non_dbg_impl.get_allocator(); }
+
+ explicit basic_string(const allocator_type& __a = allocator_type())
+ : _M_non_dbg_impl(__a), _M_iter_list(&_M_non_dbg_impl) {}
+
+ basic_string(_Reserve_t __r, size_t __n,
+ const allocator_type& __a = allocator_type())
+ : _M_non_dbg_impl(__r, __n, __a), _M_iter_list(&_M_non_dbg_impl) {}
+
+ basic_string(const _Self& __s)
+ : _ConstructCheck(__s),
+ _M_non_dbg_impl(__s._M_non_dbg_impl), _M_iter_list(&_M_non_dbg_impl) {}
+
+ basic_string(const _Self& __s, size_type __pos, size_type __n = npos,
+ const allocator_type& __a = allocator_type())
+ : _M_non_dbg_impl(__s._M_non_dbg_impl, __pos, __n, __a),
+ _M_iter_list(&_M_non_dbg_impl) {}
+
+ basic_string(const _CharT* __s, size_type __n,
+ const allocator_type& __a = allocator_type())
+ : _ConstructCheck(__s), _M_non_dbg_impl(__s, __n, __a),
+ _M_iter_list(&_M_non_dbg_impl) {}
+
+ basic_string(const _CharT* __s,
+ const allocator_type& __a = allocator_type())
+ : _ConstructCheck(__s),
+ _M_non_dbg_impl(__s, __a), _M_iter_list(&_M_non_dbg_impl) {}
+
+ basic_string(size_type __n, _CharT __c,
+ const allocator_type& __a = allocator_type())
+ : _M_non_dbg_impl(__n, __c, __a), _M_iter_list(&_M_non_dbg_impl) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ basic_string(__move_source<_Self> src)
+ : _M_non_dbg_impl(__move_source<_Base >(src.get()._M_non_dbg_impl)),
+ _M_iter_list(&_M_non_dbg_impl) {
+# if defined (_STLP_NO_EXTENSIONS) || (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
+ src.get()._M_iter_list._Invalidate_all();
+# else
+ src.get()._M_iter_list._Set_owner(_M_iter_list);
+# endif
+ }
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES)
+ basic_string(const _CharT* __f, const _CharT* __l,
+ const allocator_type& __a = allocator_type())
+ : _ConstructCheck(__f, __l),
+ _M_non_dbg_impl(__f, __l, __a), _M_iter_list(&_M_non_dbg_impl) {
+ }
+ basic_string(const_iterator __f, const_iterator __l,
+ const allocator_type & __a = allocator_type())
+ : _ConstructCheck(__f, __l),
+ _M_non_dbg_impl(__f._M_iterator, __l._M_iterator, __a), _M_iter_list(&_M_non_dbg_impl) {
+ }
+#else
+ template <class _InputIterator>
+ basic_string(_InputIterator __f, _InputIterator __l,
+ const allocator_type & __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _ConstructCheck(__f, __l),
+ _M_non_dbg_impl(_STLP_PRIV _Non_Dbg_iter(__f), _STLP_PRIV _Non_Dbg_iter(__l), __a),
+ _M_iter_list(&_M_non_dbg_impl) {}
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ basic_string(_InputIterator __f, _InputIterator __l)
+ : _ConstructCheck(__f, __l),
+ _M_non_dbg_impl(_STLP_PRIV _Non_Dbg_iter(__f), _STLP_PRIV _Non_Dbg_iter(__l)),
+ _M_iter_list(&_M_non_dbg_impl) {}
+# endif
+#endif
+
+private:
+ // constructor from non-debug version for substr
+ basic_string (const _Base& __x)
+ : _M_non_dbg_impl(__x), _M_iter_list(&_M_non_dbg_impl) {}
+
+public:
+ _Self& operator=(const _Self& __s) {
+ if (this != &__s) {
+ assign(__s);
+ }
+ return *this;
+ }
+
+ _Self& operator=(const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ return assign(__s);
+ }
+
+ _Self& operator=(_CharT __c) {
+ return assign(1, __c);
+ }
+
+ // Iterators.
+ iterator begin() { return iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
+ const_iterator begin() const { return const_iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
+ iterator end() { return iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
+ const_iterator end() const { return const_iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
+
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+ const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+
+ // Size, capacity, etc.
+ size_type size() const { return _M_non_dbg_impl.size(); }
+ size_type length() const { return _M_non_dbg_impl.length(); }
+ size_t max_size() const { return _M_non_dbg_impl.max_size(); }
+
+ void resize(size_type __n, _CharT __c) {
+ if (__n > capacity())
+ _Invalidate_all();
+ else if (__n < size())
+ _Invalidate_iterators(begin() + __n, end());
+ _M_non_dbg_impl.resize(__n, __c);
+ }
+ void resize(size_type __n) { resize(__n, _STLP_DEFAULT_CONSTRUCTED(_CharT)); }
+ size_type capacity() const { return _M_non_dbg_impl.capacity(); }
+
+ void reserve(size_type __s = 0) {
+ if (__s > capacity()) _Invalidate_all();
+ _M_non_dbg_impl.reserve(__s);
+ }
+
+ void clear() {
+ _Invalidate_all();
+ _M_non_dbg_impl.clear();
+ }
+
+ bool empty() const { return _M_non_dbg_impl.empty(); }
+
+ const_reference operator[](size_type __n) const {
+ _STLP_VERBOSE_ASSERT(__n <= this->size(), _StlMsg_OUT_OF_BOUNDS);
+ return _M_non_dbg_impl[__n];
+ }
+
+ reference operator[](size_type __n) {
+ _STLP_VERBOSE_ASSERT(__n < this->size(), _StlMsg_OUT_OF_BOUNDS)
+ return _M_non_dbg_impl[__n];
+ }
+
+ const_reference at(size_type __n) const { return _M_non_dbg_impl.at(__n); }
+ reference at(size_type __n) { return _M_non_dbg_impl.at(__n); }
+
+ // Append, operator+=, push_back.
+ _Self& operator+=(const _Self& __s) { return append(__s); }
+ _Self& operator+=(const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ return append(__s);
+ }
+ _Self& operator+=(_CharT __c) { return append(1, __c); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIter>
+ _Self& append(_InputIter __first, _InputIter __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.append(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES) || \
+ !defined (_STLP_NO_METHOD_SPECIALIZATION) && !defined (_STLP_NO_EXTENSIONS)
+ _Self& append(const _CharT* __f, const _CharT* __l) {
+ _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__f, __l))
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.append(__f, __l);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ _Self& append(const_iterator __f, const_iterator __l) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l))
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.append(__f._M_iterator, __l._M_iterator);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+#endif
+
+ _Self& append(const _Self& __s) {
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.append(__s._M_non_dbg_impl);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ _Self& append(const _Self& __s, size_type __pos, size_type __n) {
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.append(__s._M_non_dbg_impl, __pos, __n);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ _Self& append(const _CharT* __s, size_type __n) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.append(__s, __n);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ _Self& append(const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.append(__s);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ _Self& append(size_type __n, _CharT __c) {
+ size_type __old_capacity = this->capacity();
+ _M_non_dbg_impl.append(__n, __c);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ void push_back(_CharT __c) {
+ size_type __old_capacity = this->capacity();
+ _M_non_dbg_impl.push_back(__c);
+ _Compare_Capacity(__old_capacity);
+ }
+
+ void pop_back() {
+ _Invalidate_iterator(this->end());
+ _M_non_dbg_impl.pop_back();
+ }
+
+ // Assign
+ _Self& assign(const _Self& __s) {
+ _Invalidate_all();
+ _M_non_dbg_impl.assign(__s._M_non_dbg_impl);
+ return *this;
+ }
+
+ _Self& assign(const _Self& __s, size_type __pos, size_type __n) {
+ if (__pos < __s.size()) {
+ _Invalidate_all();
+ }
+ _M_non_dbg_impl.assign(__s._M_non_dbg_impl, __pos, __n);
+ return *this;
+ }
+
+ _Self& assign(const _CharT* __s, size_type __n) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ _Invalidate_all();
+ _M_non_dbg_impl.assign(__s, __s + __n);
+ return *this;
+ }
+
+ _Self& assign(const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ _Invalidate_all();
+ _M_non_dbg_impl.assign(__s);
+ return *this;
+ }
+
+ _Self& assign(size_type __n, _CharT __c) {
+ _Invalidate_all();
+ _M_non_dbg_impl.assign(__n, __c);
+ return *this;
+ }
+
+#if defined(_STLP_MEMBER_TEMPLATES)
+ template <class _InputIter>
+ inline _Self& assign(_InputIter __first, _InputIter __last) {
+ _STLP_FIX_LITERAL_BUG(__first) _STLP_FIX_LITERAL_BUG(__last)
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _Invalidate_all();
+ _M_non_dbg_impl.assign(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
+ return *this;
+ }
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES) || \
+ !defined (_STLP_NO_METHOD_SPECIALIZATION) && !defined (_STLP_NO_EXTENSIONS)
+ _Self& assign(const _CharT* __f, const _CharT* __l) {
+ _STLP_FIX_LITERAL_BUG(__f) _STLP_FIX_LITERAL_BUG(__l)
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__f, __l))
+ _Invalidate_all();
+ _M_non_dbg_impl.assign(__f, __l);
+ return *this;
+ }
+ _Self& assign(const_iterator __f, const_iterator __l) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l))
+ _Invalidate_all();
+ _M_non_dbg_impl.assign(__f._M_iterator, __l._M_iterator);
+ return *this;
+ }
+#endif
+
+ // Insert
+ _Self& insert(size_type __pos, const _Self& __s) {
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.insert(__pos, __s._M_non_dbg_impl);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ _Self& insert(size_type __pos, const _Self& __s,
+ size_type __beg, size_type __n) {
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.insert(__pos, __s._M_non_dbg_impl, __beg, __n);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ _Self& insert(size_type __pos, const _CharT* __s, size_type __n) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.insert(__pos, __s, __n);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ _Self& insert(size_type __pos, const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ return insert(__pos, __s, _Traits::length(__s));
+ }
+
+ _Self& insert(size_type __pos, size_type __n, _CharT __c) {
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.insert(__pos, __n, __c);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ iterator insert(iterator __p, _CharT __c) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
+ size_type __old_capacity = capacity();
+ typename _Base::iterator __ret = _M_non_dbg_impl.insert(__p._M_iterator, __c);
+ _Compare_Capacity(__old_capacity);
+ return iterator(&_M_iter_list, __ret);
+ }
+
+ void insert(iterator __p, size_t __n, _CharT __c) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.insert(__p._M_iterator, __n, __c);
+ _Compare_Capacity(__old_capacity);
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIter>
+ void insert(iterator __p, _InputIter __first, _InputIter __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first,__last))
+
+ size_type __old_capacity = this->capacity();
+ _M_non_dbg_impl.insert(__p._M_iterator,
+ _STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
+ _Compare_Capacity(__old_capacity);
+ }
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES)
+ void insert(iterator __p, const _CharT* __f, const _CharT* __l) {
+ _STLP_FIX_LITERAL_BUG(__f)_STLP_FIX_LITERAL_BUG(__l)
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__f,__l))
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.insert(__p._M_iterator, __f, __l);
+ _Compare_Capacity(__old_capacity);
+ }
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION)
+ // Those overloads are necessary to check self referencing correctly in non debug
+ // basic_string implementation
+ void insert(iterator __p, const_iterator __f, const_iterator __l) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f,__l))
+# if (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
+ _STLP_STD_DEBUG_CHECK(__check_if_not_owner(&_M_iter_list, __f))
+# endif
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.insert(__p._M_iterator, __f._M_iterator, __l._M_iterator);
+ _Compare_Capacity(__old_capacity);
+ }
+ void insert(iterator __p, iterator __f, iterator __l) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__p))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f,__l))
+# if (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
+ _STLP_STD_DEBUG_CHECK(__check_if_not_owner(&_M_iter_list, __f))
+# endif
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.insert(__p._M_iterator, __f._M_iterator, __l._M_iterator);
+ _Compare_Capacity(__old_capacity);
+ }
+#endif
+
+ // Erase.
+ _Self& erase(size_type __pos = 0, size_type __n = npos) {
+ if (__pos < size()) {
+ _Invalidate_iterators(begin() + __pos, end());
+ }
+ _M_non_dbg_impl.erase(__pos, __n);
+ return *this;
+ }
+ iterator erase(iterator __pos) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list,__pos))
+ _Invalidate_iterators(__pos, end());
+ return iterator(&_M_iter_list, _M_non_dbg_impl.erase(__pos._M_iterator));
+ }
+ iterator erase(iterator __f, iterator __l) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l, begin(), end()))
+ _Invalidate_iterators(__f, end());
+ return iterator(&_M_iter_list, _M_non_dbg_impl.erase(__f._M_iterator, __l._M_iterator));
+ }
+
+ // Substring.
+ _Self substr(size_type __pos = 0, size_type __n = npos) const
+ { return _M_non_dbg_impl.substr(__pos, __n); }
+
+ // Replace. (Conceptually equivalent to erase followed by insert.)
+ _Self& replace(size_type __pos, size_type __n, const _Self& __s) {
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.replace(__pos, __n, __s._M_non_dbg_impl);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ _Self& replace(size_type __pos1, size_type __n1, const _Self& __s,
+ size_type __pos2, size_type __n2) {
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.replace(__pos1, __n1, __s._M_non_dbg_impl, __pos2, __n2);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ _Self& replace(size_type __pos, size_type __n1, const _CharT* __s, size_type __n2) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.replace(__pos, __n1, __s, __n2);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ _Self& replace(size_type __pos, size_type __n1, const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.replace(__pos, __n1, __s);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ _Self& replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c) {
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.replace(__pos, __n1, __n2, __c);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ _Self& replace(iterator __f, iterator __l, const _Self& __s) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l, begin(), end()))
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.replace(__f._M_iterator, __l._M_iterator, __s._M_non_dbg_impl);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ _Self& replace(iterator __f, iterator __l, const _CharT* __s, size_type __n) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l, begin(), end()))
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.replace(__f._M_iterator, __l._M_iterator, __s, __n);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ _Self& replace(iterator __f, iterator __l, const _CharT* __s) {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l, begin(), end()))
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.replace(__f._M_iterator, __l._M_iterator, __s);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+ _Self& replace(iterator __f, iterator __l, size_type __n, _CharT __c) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l, begin(), end()))
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.replace(__f._M_iterator, __l._M_iterator, __n, __c);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIter>
+ _Self& replace(iterator __first, iterator __last,
+ _InputIter __f, _InputIter __l) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, begin(), end()))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l))
+
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.replace(__first._M_iterator, __last._M_iterator,
+ _STLP_PRIV _Non_Dbg_iter(__f), _STLP_PRIV _Non_Dbg_iter(__l));
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES)
+ _Self& replace(iterator __first, iterator __last,
+ const _CharT* __f, const _CharT* __l) {
+ _STLP_FIX_LITERAL_BUG(__f)_STLP_FIX_LITERAL_BUG(__l)
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, begin(), end()))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__f, __l))
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.replace(__first._M_iterator, __last._M_iterator, __f, __l);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION)
+ _Self& replace(iterator __first, iterator __last,
+ const_iterator __f, const_iterator __l) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, begin(), end()))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l))
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.replace(__first._M_iterator, __last._M_iterator,
+ __f._M_iterator, __l._M_iterator);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+ _Self& replace(iterator __first, iterator __last,
+ iterator __f, iterator __l) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, begin(), end()))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__f, __l))
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.replace(__first._M_iterator, __last._M_iterator,
+ __f._M_iterator, __l._M_iterator);
+ _Compare_Capacity(__old_capacity);
+ return *this;
+ }
+#endif
+
+ // Other modifier member functions.
+ void swap(_Self& __s) {
+ _M_iter_list._Swap_owners(__s._M_iter_list);
+ _M_non_dbg_impl.swap(__s._M_non_dbg_impl);
+ }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+ int compare(const _Self& __s) const
+ { return _M_non_dbg_impl.compare(__s._M_non_dbg_impl); }
+ int compare(size_type __pos, size_type __n, const _Self& __s) const
+ { return _M_non_dbg_impl.compare(__pos, __n, __s._M_non_dbg_impl); }
+ int compare(size_type __pos1, size_type __n1, const _Self& __s,
+ size_type __pos2, size_type __n2) const
+ { return _M_non_dbg_impl.compare(__pos1, __n1, __s._M_non_dbg_impl, __pos2, __n2); }
+ int compare(const _CharT* __s) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return _M_non_dbg_impl.compare(__s);
+ }
+ int compare(size_type __pos, size_type __n, const _CharT* __s) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return _M_non_dbg_impl.compare(__pos, __n, __s);
+ }
+ int compare(size_type __pos1, size_type __n1, const _CharT* __s,
+ size_type __n2) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ return _M_non_dbg_impl.compare(__pos1, __n1, __s, __n2);
+ }
+
+ // Helper functions for compare.
+ static int _STLP_CALL _M_compare(const _CharT* __f1, const _CharT* __l1,
+ const _CharT* __f2, const _CharT* __l2)
+ { return _Base::_M_compare(__f1, __l1, __f2, __l2); }
+ static int _STLP_CALL _M_compare(const_iterator __f1, const_iterator __l1,
+ const _CharT* __f2, const _CharT* __l2)
+ { return _Base::_M_compare(__f1._M_iterator, __l1._M_iterator, __f2, __l2); }
+ static int _STLP_CALL _M_compare(const _CharT* __f1, const _CharT* __l1,
+ const_iterator __f2, const_iterator __l2)
+ { return _Base::_M_compare(__f1, __l1, __f2._M_iterator, __l2._M_iterator); }
+ static int _STLP_CALL _M_compare(const_iterator __f1, const_iterator __l1,
+ const_iterator __f2, const_iterator __l2)
+ { return _Base::_M_compare(__f1._M_iterator, __l1._M_iterator, __f2._M_iterator, __l2._M_iterator); }
+
+ const _CharT* c_str() const { return _M_non_dbg_impl.c_str(); }
+ const _CharT* data() const { return _M_non_dbg_impl.data(); }
+
+ size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const
+ { return _M_non_dbg_impl.copy(__s, __n, __pos); }
+
+ // find.
+ size_type find(const _Self& __s, size_type __pos = 0) const
+ { return _M_non_dbg_impl.find(__s._M_non_dbg_impl, __pos); }
+ size_type find(const _CharT* __s, size_type __pos = 0) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ return _M_non_dbg_impl.find(__s, __pos);
+ }
+ size_type find(const _CharT* __s, size_type __pos, size_type __n) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ return _M_non_dbg_impl.find(__s, __pos, __n);
+ }
+ // WIE: Versant schema compiler 5.2.2 ICE workaround
+ size_type find(_CharT __c) const { return find(__c, 0); }
+ size_type find(_CharT __c, size_type __pos /* = 0 */) const
+ { return _M_non_dbg_impl.find(__c, __pos); }
+
+ // rfind.
+ size_type rfind(const _Self& __s, size_type __pos = npos) const
+ { return _M_non_dbg_impl.rfind(__s._M_non_dbg_impl, __pos); }
+ size_type rfind(const _CharT* __s, size_type __pos = npos) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ return _M_non_dbg_impl.rfind(__s, __pos);
+ }
+ size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ return _M_non_dbg_impl.rfind(__s, __pos, __n);
+ }
+ size_type rfind(_CharT __c, size_type __pos = npos) const
+ { return _M_non_dbg_impl.rfind(__c, __pos); }
+
+ // find_first_of
+ size_type find_first_of(const _Self& __s, size_type __pos = 0) const
+ { return _M_non_dbg_impl.find_first_of(__s._M_non_dbg_impl, __pos); }
+ size_type find_first_of(const _CharT* __s, size_type __pos = 0) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ return _M_non_dbg_impl.find_first_of(__s, __pos);
+ }
+ size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ return _M_non_dbg_impl.find_first_of(__s, __pos, __n);
+ }
+ size_type find_first_of(_CharT __c, size_type __pos = 0) const
+ { return _M_non_dbg_impl.find_first_of(__c, __pos); }
+
+ // find_last_of
+ size_type find_last_of(const _Self& __s, size_type __pos = npos) const
+ { return _M_non_dbg_impl.find_last_of(__s._M_non_dbg_impl, __pos); }
+ size_type find_last_of(const _CharT* __s, size_type __pos = npos) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ return _M_non_dbg_impl.find_last_of(__s, __pos);
+ }
+ size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ return _M_non_dbg_impl.find_last_of(__s, __pos, __n);
+ }
+ size_type find_last_of(_CharT __c, size_type __pos = npos) const
+ { return _M_non_dbg_impl.rfind(__c, __pos); }
+
+ // find_first_not_of
+ size_type find_first_not_of(const _Self& __s, size_type __pos = 0) const
+ { return _M_non_dbg_impl.find_first_not_of(__s._M_non_dbg_impl, __pos); }
+ size_type find_first_not_of(const _CharT* __s, size_type __pos = 0) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ return _M_non_dbg_impl.find_first_not_of(__s, __pos);
+ }
+ size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ return _M_non_dbg_impl.find_first_not_of(__s, __pos, __n);
+ }
+ size_type find_first_not_of(_CharT __c, size_type __pos = 0) const
+ { return _M_non_dbg_impl.find_first_not_of(__c, __pos); }
+
+ // find_last_not_of
+ size_type find_last_not_of(const _Self& __s, size_type __pos = npos) const
+ { return _M_non_dbg_impl.find_last_not_of(__s._M_non_dbg_impl, __pos); }
+ size_type find_last_not_of(const _CharT* __s, size_type __pos = npos) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ return _M_non_dbg_impl.find_last_not_of(__s, __pos);
+ }
+ size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const {
+ _STLP_FIX_LITERAL_BUG(__s)
+ _STLP_VERBOSE_ASSERT((__s != 0), _StlMsg_INVALID_ARGUMENT)
+ return _M_non_dbg_impl.find_last_not_of(__s, __pos, __n);
+ }
+ size_type find_last_not_of(_CharT __c, size_type __pos = npos) const
+ { return _M_non_dbg_impl.find_last_not_of(__c, __pos); }
+
+#if defined (_STLP_USE_TEMPLATE_EXPRESSION)
+# include <stl/debug/_string_sum_methods.h>
+#endif
+};
+
+// This is a hook to instantiate STLport exports in a designated DLL
+#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+_STLP_EXPORT_TEMPLATE_CLASS __construct_checker<_STLP_NON_DBG_STRING_NAME <char, char_traits<char>, allocator<char> > >;
+_STLP_MOVE_TO_STD_NAMESPACE
+_STLP_EXPORT_TEMPLATE_CLASS basic_string<char, char_traits<char>, allocator<char> >;
+# if defined (_STLP_HAS_WCHAR_T)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+_STLP_EXPORT_TEMPLATE_CLASS __construct_checker<_STLP_NON_DBG_STRING_NAME <wchar_t, char_traits<wchar_t>, allocator<wchar_t> > >;
+_STLP_MOVE_TO_STD_NAMESPACE
+_STLP_EXPORT_TEMPLATE_CLASS basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >;
+# endif
+#endif
+
+#undef _STLP_NON_DBG_STRING
+#undef _STLP_NON_DBG_STRING_NAME
+
+#if defined (__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 96)
+template <class _CharT, class _Traits, class _Alloc>
+const size_t basic_string<_CharT, _Traits, _Alloc>::npos = ~(size_t) 0;
+#endif
+
+#if defined (basic_string)
+_STLP_MOVE_TO_STD_NAMESPACE
+#undef basic_string
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_DBG_STRING */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/debug/_string_sum_methods.h b/sources/android/stlport/stlport/stl/debug/_string_sum_methods.h
new file mode 100644
index 0000000..3fca194
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/debug/_string_sum_methods.h
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/*
+ * All the necessary methods used for template expressions with basic_string
+ * This file do not have to be macro guarded as it is only used in the _string.h
+ * file and it is a part of the basic_string definition.
+ */
+
+ template <class _Left, class _Right, class _StorageDir>
+ basic_string(_STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir> const& __s)
+ : _M_non_dbg_impl(_Reserve_t(), __s.size(), __s.get_allocator()),
+ _M_iter_list(&_M_non_dbg_impl)
+ { _M_append_sum(__s, _M_non_dbg_impl); }
+
+ template <class _Left, class _Right, class _StorageDir>
+ basic_string(_STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir> const& __s,
+ size_type __pos, size_type __n = npos,
+ const allocator_type& __a = allocator_type())
+ : _M_non_dbg_impl(_Reserve_t(), (__pos <= __s.size()) ? ((min) (__n, __s.size() - __pos)) : 0, __a),
+ _M_iter_list(&_M_non_dbg_impl) {
+ size_type __size = __s.size();
+ if (__pos > __size)
+ //This call will generate the necessary out of range exception:
+ _M_non_dbg_impl.at(0);
+ else
+ _M_append_sum_pos(__s, __pos, (min) (__n, __size - __pos), _M_non_dbg_impl);
+ }
+
+private:
+ _Base& _M_append_fast(_STLP_PRIV __char_wrapper<_CharT> __c, _Base &__str)
+ { return __str += __c.getValue(); }
+ _Base& _M_append_fast(_CharT const* __s, size_type __s_size, _Base &__str)
+ { return __str.append(__s, __s_size); }
+ _Base& _M_append_fast(_STLP_PRIV __cstr_wrapper<_CharT> const& __s, _Base &__str)
+ { return _M_append_fast(__s.c_str(), __s.size(), __str); }
+ _Base& _M_append_fast(_STLP_PRIV __bstr_wrapper<_CharT, _Traits, _Alloc> __s, _Base &__str)
+ { return _M_append_fast(__s.b_str(), __str); }
+ _Base& _M_append_fast(_Self const& __s, _Base &__str)
+ { return _M_append_fast(__s.data(), __s.size(), __str); }
+ _Base& _M_append_fast(_STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc> const&, _Base &__str)
+ { return __str; }
+ template <class _Left, class _Right, class _StorageDir>
+ _Base& _M_append_fast(_STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir> const& __s, _Base &__str)
+ { return _M_append_fast(__s.getRhs(), _M_append_fast(__s.getLhs(), __str)); }
+
+ _Base& _M_append_fast_pos(_STLP_PRIV __char_wrapper<_CharT> __c, _Base &__str, size_type /*__pos*/, size_type __n) {
+ if (__n == 0)
+ return __str;
+ return __str += __c.getValue();
+ }
+ _Base& _M_append_fast_pos(_CharT const* __s, size_type __s_size, _Base &__str,
+ size_type __pos, size_type __n)
+ { return __str.append(__s + __pos, __s + __pos + (min)(__n, __s_size - __pos)); }
+ _Base& _M_append_fast_pos(_STLP_PRIV __cstr_wrapper<_CharT> const& __s, _Base &__str,
+ size_type __pos, size_type __n)
+ { return _M_append_fast_pos(__s.c_str(), __s.size(), __str, __pos, __n); }
+ _Base& _M_append_fast_pos(_STLP_PRIV __bstr_wrapper<_CharT, _Traits, _Alloc> __s, _Base &__str,
+ size_type __pos, size_type __n)
+ { return _M_append_fast_pos(__s.b_str(), __str, __pos, __n); }
+ _Base& _M_append_fast_pos(_Self const& __s, _Base &__str, size_type __pos, size_type __n)
+ { return _M_append_fast_pos(__s.data(), __s.size(), __str, __pos, __n); }
+ _Base& _M_append_fast_pos(_STLP_PRIV __sum_storage_elem<_CharT, _Traits, _Alloc> const&, _Base &__str,
+ size_type /*__pos*/, size_type /*__n*/)
+ { return __str; }
+
+ template <class _Left, class _Right, class _StorageDir>
+ _Base& _M_append_fast_pos(_STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir> const& __s,
+ _Base &__str, size_type __pos, size_type __n) {
+ if (__n == 0) {
+ return __str;
+ }
+ size_type __lhs_size = __s.getLhs().size();
+ if (__pos < __lhs_size) {
+ if (__n < (__lhs_size - __pos)) {
+ return _M_append_fast_pos(__s.getLhs(), __str, __pos, __n);
+ } else {
+ return _M_append_fast_pos(__s.getRhs(), _M_append_fast_pos(__s.getLhs(), __str, __pos, __n),
+ 0, __n - (__lhs_size - __pos));
+ }
+ } else {
+ return _M_append_fast_pos(__s.getRhs(), __str, __pos - __lhs_size, __n);
+ }
+ }
+
+ template <class _Left, class _Right, class _StorageDir>
+ _Self& _M_append_sum (_STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir> const& __s,
+ _Base &__impl) {
+ _M_append_fast(__s, __impl);
+ return *this;
+ }
+
+ template <class _Left, class _Right, class _StorageDir>
+ _Self& _M_append_sum_pos (_STLP_PRIV __bstr_sum<_CharT, _Traits, _Alloc, _Left, _Right, _StorageDir> const& __s,
+ size_type __pos, size_type __n, _Base &__impl) {
+ _M_non_dbg_impl.reserve(_M_non_dbg_impl.size() + (min) (__s.size() - __pos, __n));
+ _M_append_fast_pos(__s, __impl, __pos, __n);
+ return *this;
+ }
diff --git a/sources/android/stlport/stlport/stl/debug/_tree.h b/sources/android/stlport/stlport/stl/debug/_tree.h
new file mode 100644
index 0000000..a32eda2
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/debug/_tree.h
@@ -0,0 +1,317 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_DBG_TREE_H
+#define _STLP_INTERNAL_DBG_TREE_H
+
+#ifndef _STLP_DBG_ITERATOR_H
+# include <stl/debug/_iterator.h>
+#endif
+
+#ifndef _STLP_INTERNAL_FUNCTION_BASE_H
+# include <stl/_function_base.h>
+#endif
+
+#ifndef _STLP_INTERNAL_ALLOC_H
+# include <stl/_alloc.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Key, class _Compare>
+class _DbgCompare {
+public:
+ _DbgCompare() {}
+ _DbgCompare(const _Compare& __cmp) : _M_non_dbg_cmp(__cmp) {}
+ _DbgCompare(const _DbgCompare& __cmp) : _M_non_dbg_cmp(__cmp._M_non_dbg_cmp) {}
+
+#if !defined (_STLP_USE_CONTAINERS_EXTENSION)
+ bool operator () (const _Key& __lhs, const _Key& __rhs) const {
+#else
+ template <class _Kp1, class _Kp2>
+ bool operator () (const _Kp1& __lhs, const _Kp2& __rhs) const {
+#endif
+ if (_M_non_dbg_cmp(__lhs, __rhs)) {
+ return true;
+ }
+ return false;
+ }
+
+ _Compare non_dbg_key_comp() const { return _M_non_dbg_cmp; }
+private:
+ _Compare _M_non_dbg_cmp;
+};
+
+#define _STLP_NON_DBG_TREE _STLP_PRIV _STLP_NON_DBG_NAME(Rb_tree) <_Key, _STLP_PRIV _DbgCompare<_Key, _Compare>, _Value, _KeyOfValue, _Traits, _Alloc>
+
+#if defined (_STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS)
+_STLP_MOVE_TO_STD_NAMESPACE
+template <class _Key, class _Compare,
+ class _Value, class _KeyOfValue, class _Traits, class _Alloc >
+inline _Value*
+value_type(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_TREE >&)
+{ return (_Value*)0; }
+template <class _Key, class _Compare,
+ class _Value, class _KeyOfValue, class _Traits, class _Alloc >
+inline bidirectional_iterator_tag
+iterator_category(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_TREE >&)
+{ return bidirectional_iterator_tag(); }
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+template <class _Key, class _Compare,
+ class _Value, class _KeyOfValue, class _Traits,
+ _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Value>) >
+class _Rb_tree {
+ typedef _STLP_NON_DBG_TREE _Base;
+ typedef _Rb_tree<_Key, _Compare, _Value, _KeyOfValue, _Traits, _Alloc> _Self;
+ _Base _M_non_dbg_impl;
+ _STLP_PRIV __owned_list _M_iter_list;
+
+public:
+ __IMPORT_CONTAINER_TYPEDEFS(_Base)
+ typedef typename _Base::key_type key_type;
+
+ typedef typename _Traits::_NonConstTraits _NonConstIteTraits;
+ typedef typename _Traits::_ConstTraits _ConstIteTraits;
+ typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _DbgTraits<_NonConstIteTraits> > iterator;
+ typedef _STLP_PRIV _DBG_iter<_Base, _STLP_PRIV _DbgTraits<_ConstIteTraits> > const_iterator;
+
+ _STLP_DECLARE_BIDIRECTIONAL_REVERSE_ITERATORS;
+
+private:
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+ void _Invalidate_iterator(const iterator& __it)
+ { _STLP_PRIV __invalidate_iterator(&_M_iter_list,__it); }
+ void _Invalidate_iterators(const iterator& __first, const iterator& __last)
+ { _STLP_PRIV __invalidate_range(&_M_iter_list, __first, __last); }
+
+ typedef typename _Base::iterator _Base_iterator;
+ typedef typename _Base::const_iterator _Base_const_iterator;
+
+public:
+ _Rb_tree()
+ : _M_non_dbg_impl(), _M_iter_list(&_M_non_dbg_impl) {}
+ _Rb_tree(const _Compare& __comp)
+ : _M_non_dbg_impl(__comp), _M_iter_list(&_M_non_dbg_impl) {}
+ _Rb_tree(const _Compare& __comp, const allocator_type& __a)
+ : _M_non_dbg_impl(__comp, __a), _M_iter_list(&_M_non_dbg_impl) {}
+ _Rb_tree(const _Self& __x)
+ : _M_non_dbg_impl(__x._M_non_dbg_impl), _M_iter_list(&_M_non_dbg_impl) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ _Rb_tree(__move_source<_Self> src):
+ _M_non_dbg_impl(__move_source<_Base>(src.get()._M_non_dbg_impl)),
+ _M_iter_list(&_M_non_dbg_impl) {
+# if defined (_STLP_NO_EXTENSIONS) || (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
+ src.get()._M_iter_list._Invalidate_all();
+# else
+ src.get()._M_iter_list._Set_owner(_M_iter_list);
+# endif
+ }
+#endif
+
+ ~_Rb_tree() {}
+
+ _Self& operator=(const _Self& __x) {
+ if (this != &__x) {
+ //Should not invalidate end iterator:
+ _Invalidate_iterators(begin(), end());
+ _M_non_dbg_impl = __x._M_non_dbg_impl;
+ }
+ return *this;
+ }
+
+ allocator_type get_allocator() const { return _M_non_dbg_impl.get_allocator(); }
+ _Compare key_comp() const { return _M_non_dbg_impl.key_comp().non_dbg_key_comp(); }
+
+ iterator begin() { return iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
+ const_iterator begin() const { return const_iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
+ iterator end() { return iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
+ const_iterator end() const { return const_iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
+
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+ const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+
+ bool empty() const { return _M_non_dbg_impl.empty(); }
+ size_type size() const { return _M_non_dbg_impl.size(); }
+ size_type max_size() const { return _M_non_dbg_impl.max_size(); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __x) const { return _M_non_dbg_impl.count(__x); }
+
+ void swap(_Self& __t) {
+ _M_non_dbg_impl.swap(__t._M_non_dbg_impl);
+ _M_iter_list._Swap_owners(__t._M_iter_list);
+ }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __k)
+ { return iterator(&_M_iter_list, _M_non_dbg_impl.find(__k)); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __k) const
+ { return const_iterator(&_M_iter_list, _M_non_dbg_impl.find(__k)); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator lower_bound(const _KT& __x)
+ { return iterator(&_M_iter_list, _M_non_dbg_impl.lower_bound(__x)); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator lower_bound(const _KT& __x) const
+ { return const_iterator(&_M_iter_list, _M_non_dbg_impl.lower_bound(__x)); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator upper_bound(const _KT& __x)
+ { return iterator(&_M_iter_list, _M_non_dbg_impl.upper_bound(__x)); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator upper_bound(const _KT& __x) const
+ { return const_iterator(&_M_iter_list, _M_non_dbg_impl.upper_bound(__x)); }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator,iterator> equal_range(const _KT& __x) {
+ return pair<iterator, iterator>(iterator(&_M_iter_list, _M_non_dbg_impl.lower_bound(__x)),
+ iterator(&_M_iter_list, _M_non_dbg_impl.upper_bound(__x)));
+ }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator> equal_range(const _KT& __x) const {
+ return pair<const_iterator,const_iterator>(const_iterator(&_M_iter_list, _M_non_dbg_impl.lower_bound(__x)),
+ const_iterator(&_M_iter_list, _M_non_dbg_impl.upper_bound(__x)));
+ }
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator,iterator> equal_range_unique(const _KT& __x) {
+ _STLP_STD::pair<_Base_iterator, _Base_iterator> __p;
+ __p = _M_non_dbg_impl.equal_range_unique(__x);
+ return pair<iterator, iterator>(iterator(&_M_iter_list, __p.first), iterator(&_M_iter_list, __p.second));
+ }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator> equal_range_unique(const _KT& __x) const {
+ _STLP_STD::pair<_Base_const_iterator, _Base_const_iterator> __p;
+ __p = _M_non_dbg_impl.equal_range_unique(__x);
+ return pair<const_iterator, const_iterator>(const_iterator(&_M_iter_list, __p.first),
+ const_iterator(&_M_iter_list, __p.second));
+ }
+
+ pair<iterator,bool> insert_unique(const value_type& __x) {
+ _STLP_STD::pair<_Base_iterator, bool> __res = _M_non_dbg_impl.insert_unique(__x);
+ return pair<iterator, bool>(iterator(&_M_iter_list, __res.first), __res.second);
+ }
+ iterator insert_equal(const value_type& __x)
+ { return iterator(&_M_iter_list, _M_non_dbg_impl.insert_equal(__x)); }
+
+ iterator insert_unique(iterator __pos, const value_type& __x) {
+ _STLP_DEBUG_CHECK(__check_if_owner(&_M_iter_list,__pos))
+ return iterator(&_M_iter_list, _M_non_dbg_impl.insert_unique(__pos._M_iterator, __x));
+ }
+ iterator insert_equal(iterator __pos, const value_type& __x) {
+ _STLP_DEBUG_CHECK(__check_if_owner(&_M_iter_list, __pos))
+ return iterator(&_M_iter_list, _M_non_dbg_impl.insert_equal(__pos._M_iterator, __x));
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template<class _InputIterator>
+ void insert_equal(_InputIterator __first, _InputIterator __last) {
+ _STLP_DEBUG_CHECK(__check_range(__first,__last))
+ _M_non_dbg_impl.insert_equal(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
+ }
+ template<class _InputIterator>
+ void insert_unique(_InputIterator __first, _InputIterator __last) {
+ _STLP_DEBUG_CHECK(__check_range(__first,__last))
+ _M_non_dbg_impl.insert_unique(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
+ }
+#else
+ void insert_unique(const_iterator __first, const_iterator __last) {
+ _STLP_DEBUG_CHECK(__check_range(__first,__last))
+ _M_non_dbg_impl.insert_unique(__first._M_iterator, __last._M_iterator);
+ }
+ void insert_unique(const value_type* __first, const value_type* __last) {
+ _STLP_DEBUG_CHECK(__check_ptr_range(__first,__last))
+ _M_non_dbg_impl.insert_unique(__first, __last);
+ }
+ void insert_equal(const_iterator __first, const_iterator __last) {
+ _STLP_DEBUG_CHECK(__check_range(__first,__last))
+ _M_non_dbg_impl.insert_equal(__first._M_iterator, __last._M_iterator);
+ }
+ void insert_equal(const value_type* __first, const value_type* __last) {
+ _STLP_DEBUG_CHECK(__check_ptr_range(__first,__last))
+ _M_non_dbg_impl.insert_equal(__first, __last);
+ }
+#endif
+
+ void erase(iterator __pos) {
+ _STLP_DEBUG_CHECK(__check_if_owner(&_M_iter_list,__pos))
+ _STLP_DEBUG_CHECK(_Dereferenceable(__pos))
+ _Invalidate_iterator(__pos);
+ _M_non_dbg_impl.erase(__pos._M_iterator);
+ }
+ size_type erase(const key_type& __x) {
+ pair<iterator, iterator> __p = equal_range(__x);
+ size_type __n = _STLP_STD::distance(__p.first._M_iterator, __p.second._M_iterator);
+ _Invalidate_iterators(__p.first, __p.second);
+ _M_non_dbg_impl.erase(__p.first._M_iterator, __p.second._M_iterator);
+ return __n;
+ }
+ size_type erase_unique(const key_type& __x) {
+ _Base_iterator __i = _M_non_dbg_impl.find(__x);
+ if (__i != _M_non_dbg_impl.end()) {
+ _Invalidate_iterator(iterator(&_M_iter_list, __i));
+ _M_non_dbg_impl.erase(__i);
+ return 1;
+ }
+ return 0;
+ }
+
+ void erase(iterator __first, iterator __last) {
+ _STLP_DEBUG_CHECK(__check_range(__first, __last, begin(), end()))
+ _Invalidate_iterators(__first, __last);
+ _M_non_dbg_impl.erase(__first._M_iterator, __last._M_iterator);
+ }
+ void erase(const key_type* __first, const key_type* __last) {
+ while (__first != __last) erase(*__first++);
+ }
+
+ void clear() {
+ //should not invalidate end:
+ _Invalidate_iterators(begin(), end());
+ _M_non_dbg_impl.clear();
+ }
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+_STLP_END_NAMESPACE
+
+#undef _STLP_NON_DBG_TREE
+
+#endif /* _STLP_INTERNAL_DBG_TREE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/debug/_vector.h b/sources/android/stlport/stlport/stl/debug/_vector.h
new file mode 100644
index 0000000..c5800e9
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/debug/_vector.h
@@ -0,0 +1,425 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_INTERNAL_DBG_VECTOR_H
+#define _STLP_INTERNAL_DBG_VECTOR_H
+
+#ifndef _STLP_DBG_ITERATOR_H
+# include <stl/debug/_iterator.h>
+#endif
+
+#define _STLP_NON_DBG_VECTOR _STLP_PRIV _STLP_NON_DBG_NAME(vector) <_Tp, _Alloc>
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (_STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS)
+template <class _Tp, class _Alloc>
+inline _Tp*
+value_type(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_VECTOR >&)
+{ return (_Tp*)0; }
+template <class _Tp, class _Alloc>
+inline random_access_iterator_tag
+iterator_category(const _STLP_PRIV _DBG_iter_base< _STLP_NON_DBG_VECTOR >&)
+{ return random_access_iterator_tag(); }
+#endif
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _Tp, class _NcIt>
+struct _Vector_const_traits;
+
+template <class _Tp, class _NcIt>
+struct _Vector_nonconst_traits {
+ typedef _Nonconst_traits<_Tp> _BaseT;
+ typedef _Tp value_type;
+ typedef _Tp& reference;
+ typedef _Tp* pointer;
+ typedef _Vector_const_traits<_Tp, _NcIt> _ConstTraits;
+ typedef _Vector_nonconst_traits<_Tp, _NcIt> _NonConstTraits;
+};
+
+template <class _Tp, class _NcIt>
+struct _Vector_const_traits {
+ typedef _Const_traits<_Tp> _BaseT;
+ typedef _Tp value_type;
+ typedef const _Tp& reference;
+ typedef const _Tp* pointer;
+ typedef _Vector_const_traits<_Tp, _NcIt> _ConstTraits;
+ typedef _Vector_nonconst_traits<_Tp, _NcIt> _NonConstTraits;
+};
+
+_STLP_TEMPLATE_NULL
+struct _Vector_nonconst_traits<bool, _Bit_iterator> {
+ typedef _Bit_iterator::value_type value_type;
+ typedef _Bit_iterator::reference reference;
+ typedef _Bit_iterator::pointer pointer;
+ typedef _Vector_const_traits<bool, _Bit_iterator> _ConstTraits;
+ typedef _Vector_nonconst_traits<bool, _Bit_iterator> _NonConstTraits;
+};
+
+_STLP_TEMPLATE_NULL
+struct _Vector_const_traits<bool, _Bit_iterator> {
+ typedef _Bit_const_iterator::value_type value_type;
+ typedef _Bit_const_iterator::reference reference;
+ typedef _Bit_const_iterator::pointer pointer;
+ typedef _Vector_const_traits<bool, _Bit_iterator> _ConstTraits;
+ typedef _Vector_nonconst_traits<bool, _Bit_iterator> _NonConstTraits;
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) >
+class vector :
+#if !defined (__DMC__)
+ private
+#endif
+ _STLP_PRIV __construct_checker< _STLP_NON_DBG_VECTOR >
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ , public __stlport_class<vector<_Tp, _Alloc> >
+#endif
+{
+private:
+ typedef _STLP_NON_DBG_VECTOR _Base;
+ typedef vector<_Tp, _Alloc> _Self;
+ typedef _STLP_PRIV __construct_checker<_STLP_NON_DBG_VECTOR > _ConstructCheck;
+ _Base _M_non_dbg_impl;
+ _STLP_PRIV __owned_list _M_iter_list;
+
+public:
+ __IMPORT_CONTAINER_TYPEDEFS(_Base)
+
+ typedef _STLP_PRIV _DBG_iter<_Base,
+ _STLP_PRIV _DbgTraits<_STLP_PRIV _Vector_nonconst_traits<value_type, typename _Base::iterator> > > iterator;
+
+ typedef _STLP_PRIV _DBG_iter<_Base,
+ _STLP_PRIV _DbgTraits<_STLP_PRIV _Vector_const_traits<value_type, typename _Base::iterator> > > const_iterator;
+
+private:
+ void _Invalidate_all()
+ { _M_iter_list._Invalidate_all(); }
+ void _Invalidate_iterator(const iterator& __it)
+ { _STLP_PRIV __invalidate_iterator(&_M_iter_list, __it); }
+ void _Invalidate_iterators(const iterator& __first, const iterator& __last)
+ { _STLP_PRIV __invalidate_range(&_M_iter_list, __first, __last); }
+
+ void _Check_Overflow(size_type __nb) {
+ if (size() + __nb > capacity())
+ _Invalidate_all();
+ }
+ void _Compare_Capacity (size_type __old_capacity) {
+ if (capacity() > __old_capacity) {
+ _Invalidate_all();
+ }
+ }
+
+public:
+ _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS;
+
+ allocator_type get_allocator() const { return _M_non_dbg_impl.get_allocator(); }
+
+ iterator begin() { return iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
+ const_iterator begin() const { return const_iterator(&_M_iter_list, _M_non_dbg_impl.begin()); }
+ iterator end() { return iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
+ const_iterator end() const { return const_iterator(&_M_iter_list, _M_non_dbg_impl.end()); }
+
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+ const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+
+ size_type size() const { return _M_non_dbg_impl.size(); }
+ size_type max_size() const { return _M_non_dbg_impl.max_size(); }
+ size_type capacity() const { return _M_non_dbg_impl.capacity(); }
+ bool empty() const { return _M_non_dbg_impl.empty(); }
+
+ reference operator[](size_type __n) {
+ _STLP_VERBOSE_ASSERT(__n < size(), _StlMsg_OUT_OF_BOUNDS)
+ return _M_non_dbg_impl[__n];
+ }
+
+ const_reference operator[](size_type __n) const {
+ _STLP_VERBOSE_ASSERT(__n < size(), _StlMsg_OUT_OF_BOUNDS)
+ return _M_non_dbg_impl[__n];
+ }
+
+ reference at(size_type __n) { return _M_non_dbg_impl.at(__n); }
+ const_reference at(size_type __n) const { return _M_non_dbg_impl.at(__n); }
+
+ explicit vector(const allocator_type& __a = allocator_type())
+ : _M_non_dbg_impl(__a), _M_iter_list(&_M_non_dbg_impl) {}
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+ explicit vector(size_type __n, const _Tp& __x = _Tp(),
+#else
+ vector(size_type __n, const _Tp& __x,
+#endif
+ const allocator_type& __a = allocator_type())
+ : _M_non_dbg_impl(__n, __x, __a), _M_iter_list(&_M_non_dbg_impl) {}
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+ explicit vector(size_type __n)
+ : _M_non_dbg_impl(__n), _M_iter_list(&_M_non_dbg_impl) {}
+#endif
+
+ vector(const _Self& __x)
+ : _ConstructCheck(__x), _M_non_dbg_impl(__x._M_non_dbg_impl), _M_iter_list(&_M_non_dbg_impl) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ vector(__move_source<_Self> src)
+ : _M_non_dbg_impl(__move_source<_Base>(src.get()._M_non_dbg_impl)),
+ _M_iter_list(&_M_non_dbg_impl) {
+# if defined (_STLP_NO_EXTENSIONS) || (_STLP_DEBUG_LEVEL == _STLP_STANDARD_DBG_LEVEL)
+ src.get()._M_iter_list._Invalidate_all();
+# else
+ src.get()._M_iter_list._Set_owner(_M_iter_list);
+# endif
+ }
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ vector(_InputIterator __first, _InputIterator __last,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _ConstructCheck(__first, __last),
+ _M_non_dbg_impl(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last), __a),
+ _M_iter_list(&_M_non_dbg_impl) {}
+
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ vector(_InputIterator __first, _InputIterator __last)
+ : _ConstructCheck(__first, __last),
+ _M_non_dbg_impl(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last)),
+ _M_iter_list(&_M_non_dbg_impl) {}
+# endif
+#else
+ vector(const _Tp* __first, const _Tp* __last,
+ const allocator_type& __a = allocator_type())
+ : _ConstructCheck(__first, __last), _M_non_dbg_impl(__first, __last, __a),
+ _M_iter_list(&_M_non_dbg_impl) {}
+
+ // mysterious VC++ bug ?
+ vector(const_iterator __first, const_iterator __last ,
+ const allocator_type& __a = allocator_type())
+ : _ConstructCheck(__first, __last),
+ _M_non_dbg_impl(__first._M_iterator, __last._M_iterator, __a),
+ _M_iter_list(&_M_non_dbg_impl) {}
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ _Self& operator=(const _Self& __x) {
+ if (this != &__x) {
+ _Invalidate_all();
+ _M_non_dbg_impl = __x._M_non_dbg_impl;
+ }
+ return *this;
+ }
+
+ void reserve(size_type __n) {
+ if (capacity() < __n)
+ _Invalidate_all();
+ _M_non_dbg_impl.reserve(__n);
+ }
+
+ reference front() {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ return *begin();
+ }
+ const_reference front() const {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ return *begin();
+ }
+ reference back() {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ return *(--end());
+ }
+ const_reference back() const {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ return *(--end());
+ }
+
+ void swap(_Self& __x) {
+ _M_iter_list._Swap_owners(__x._M_iter_list);
+ _M_non_dbg_impl.swap(__x._M_non_dbg_impl);
+ }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+ iterator insert(iterator __pos, const _Tp& __x = _Tp()) {
+#else
+ iterator insert(iterator __pos, const _Tp& __x) {
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _Check_Overflow(1);
+ return iterator(&_M_iter_list, _M_non_dbg_impl.insert(__pos._M_iterator, __x));
+ }
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+ iterator insert(iterator __pos)
+ { return insert(__pos, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ // Check whether it's an integral type. If so, it's not an iterator.
+ template <class _InputIterator>
+ void insert(iterator __pos,
+ _InputIterator __first, _InputIterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.insert(__pos._M_iterator,
+ _STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
+ _Compare_Capacity(__old_capacity);
+ }
+#endif
+#if !defined (_STLP_MEMBER_TEMPLATES)
+ void insert (iterator __pos,
+ const value_type *__first, const value_type *__last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first,__last))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.insert(__pos._M_iterator, __first, __last);
+ _Compare_Capacity(__old_capacity);
+ }
+#endif
+
+#if !defined (_STLP_MEMBER_TEMPLATES) || !defined (_STLP_NO_METHOD_SPECIALIZATION)
+ void insert(iterator __pos,
+ const_iterator __first, const_iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first,__last))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ //Sequence requirements 23.1.1 Table 67:
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_not_owner(&_M_iter_list, __first));
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.insert(__pos._M_iterator, __first._M_iterator, __last._M_iterator);
+ _Compare_Capacity(__old_capacity);
+ }
+ void insert(iterator __pos,
+ iterator __first, iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first,__last))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ //Sequence requirements 23.1.1 Table 67:
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_not_owner(&_M_iter_list, __first));
+ size_type __old_capacity = capacity();
+ _M_non_dbg_impl.insert(__pos._M_iterator, __first._M_iterator, __last._M_iterator);
+ _Compare_Capacity(__old_capacity);
+ }
+#endif
+
+ void insert (iterator __pos, size_type __n, const _Tp& __x){
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _Check_Overflow(__n);
+ _M_non_dbg_impl.insert(__pos._M_iterator, __n, __x);
+ }
+
+ void pop_back() {
+ _STLP_VERBOSE_ASSERT(!empty(), _StlMsg_EMPTY_CONTAINER)
+ _Invalidate_iterator(end());
+ _M_non_dbg_impl.pop_back();
+ }
+ iterator erase(iterator __pos) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV _Dereferenceable(__pos))
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_if_owner(&_M_iter_list, __pos))
+ _Invalidate_iterators(__pos, end());
+ return iterator(&_M_iter_list, _M_non_dbg_impl.erase(__pos._M_iterator));
+ }
+ iterator erase(iterator __first, iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last, begin(), end()))
+ _Invalidate_iterators(__first, end());
+ return iterator(&_M_iter_list, _M_non_dbg_impl.erase(__first._M_iterator, __last._M_iterator));
+ }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size, const _Tp& __x = _STLP_DEFAULT_CONSTRUCTED(_Tp)) {
+#else
+ void resize(size_type __new_size, const _Tp& __x) {
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ if (__new_size > capacity()) {
+ _Invalidate_all();
+ }
+ else if (__new_size < size()) {
+ _Invalidate_iterators(begin() + __new_size, end());
+ }
+ _M_non_dbg_impl.resize(__new_size, __x);
+ }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size) { resize(__new_size, _STLP_DEFAULT_CONSTRUCTED(_Tp)); }
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void assign(_InputIterator __first, _InputIterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first,__last))
+ _Invalidate_all();
+ _M_non_dbg_impl.assign(_STLP_PRIV _Non_Dbg_iter(__first), _STLP_PRIV _Non_Dbg_iter(__last));
+ }
+#else
+private:
+ void _M_assign(const value_type *__first, const value_type *__last) {
+ _Invalidate_all();
+ _M_non_dbg_impl.assign(__first, __last);
+ }
+public:
+ void assign(const value_type *__first, const value_type *__last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_ptr_range(__first,__last))
+ _M_assign(__first, __last);
+ }
+
+ void assign(const_iterator __first, const_iterator __last) {
+ _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first,__last))
+ _M_assign(__first._M_iterator, __last._M_iterator);
+ }
+#endif
+
+public:
+ void assign(size_type __n, const _Tp& __val) {
+ _Invalidate_all();
+ _M_non_dbg_impl.assign(__n, __val);
+ }
+
+ void clear() {
+ _Invalidate_all();
+ _M_non_dbg_impl.clear();
+ }
+ void push_back(const _Tp& __x) {
+ _Check_Overflow(1);
+ _M_non_dbg_impl.push_back(__x);
+ }
+};
+
+_STLP_END_NAMESPACE
+
+#undef _STLP_NON_DBG_VECTOR
+
+#endif /* _STLP_DBG_VECTOR_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/msl_string.h b/sources/android/stlport/stlport/stl/msl_string.h
new file mode 100644
index 0000000..1fa4931
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/msl_string.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1998
+ * Mark of the Unicorn, Inc.
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation. Mark of the Unicorn, Inc. makes no
+ * representations about the suitability of this software for any
+ * purpose. It is provided "as is" without express or implied warranty.
+ *
+ */
+#if defined( _STLP_USE_MSIPL ) && !defined( _STLP_MSL_STRING_H_ )
+#define _STLP_MSL_STRING_H_
+
+//# define char_traits __msl_char_traits
+# define basic_string __msl_basic_string
+# define b_str_ref __msl_b_str_ref
+# define basic_istream __msl_basic_istream
+# define basic_ostream __msl_basic_ostream
+# define string __msl_string
+# define wstring __msl_wstring
+# define iterator_traits __msl_iterator_traits
+
+namespace std
+{
+ template<class charT, class traits> class basic_istream;
+ template<class charT, class traits> class basic_ostream;
+}
+
+#if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <string>
+#else
+# include _STLP_NATIVE_HEADER(string)
+#endif
+
+// # undef char_traits
+# undef basic_string
+# undef b_str_ref
+# undef basic_istream
+# undef basic_ostream
+# undef string
+# undef wstring
+# undef iterator_traits
+
+#endif
diff --git a/sources/android/stlport/stlport/stl/pointers/_deque.h b/sources/android/stlport/stlport/stl/pointers/_deque.h
new file mode 100644
index 0000000..f82a559
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/pointers/_deque.h
@@ -0,0 +1,390 @@
+/*
+ * Copyright (c) 2004
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_SPECIALIZED_DEQUE_H
+#define _STLP_SPECIALIZED_DEQUE_H
+
+#ifndef _STLP_POINTERS_SPEC_TOOLS_H
+# include <stl/pointers/_tools.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+/*
+ * struct helper to cast deque iterators:
+ */
+template <class _StorageT, class _ValueT>
+struct _DequeIteCast {
+ typedef _Deque_iterator<_ValueT, _Nonconst_traits<_ValueT> > iterator;
+ typedef _Deque_iterator<_ValueT, _Const_traits<_ValueT> > const_iterator;
+ typedef _Deque_iterator<_StorageT, _Nonconst_traits<_StorageT> > storage_iterator;
+ typedef _Deque_iterator<_StorageT, _Const_traits<_StorageT> > const_storage_iterator;
+ typedef _CastTraits<_StorageT, _ValueT> cast_traits;
+
+ static iterator to_value_type_ite (storage_iterator const& __ite) {
+ iterator tmp;
+ tmp._M_cur = cast_traits::to_value_type_ptr(__ite._M_cur);
+ tmp._M_first = cast_traits::to_value_type_ptr(__ite._M_first);
+ tmp._M_last = cast_traits::to_value_type_ptr(__ite._M_last);
+ tmp._M_node = cast_traits::to_value_type_pptr(__ite._M_node);
+ return tmp;
+ }
+ static storage_iterator to_storage_type_ite (iterator const& __ite) {
+ storage_iterator tmp;
+ tmp._M_cur = cast_traits::to_storage_type_ptr(__ite._M_cur);
+ tmp._M_first = cast_traits::to_storage_type_ptr(__ite._M_first);
+ tmp._M_last = cast_traits::to_storage_type_ptr(__ite._M_last);
+ tmp._M_node = cast_traits::to_storage_type_pptr(__ite._M_node);
+ return tmp;
+ }
+
+ static const_iterator to_value_type_cite (const_storage_iterator const& __ite) {
+ const_iterator tmp;
+ tmp._M_cur = cast_traits::to_value_type_ptr(__ite._M_cur);
+ tmp._M_first = cast_traits::to_value_type_ptr(__ite._M_first);
+ tmp._M_last = cast_traits::to_value_type_ptr(__ite._M_last);
+ tmp._M_node = cast_traits::to_value_type_pptr(__ite._M_node);
+ return tmp;
+ }
+
+ static const_storage_iterator to_storage_type_cite (const_iterator const& __ite) {
+ const_storage_iterator tmp;
+ tmp._M_cur = cast_traits::to_storage_type_ptr(__ite._M_cur);
+ tmp._M_first = cast_traits::to_storage_type_ptr(__ite._M_first);
+ tmp._M_last = cast_traits::to_storage_type_ptr(__ite._M_last);
+ tmp._M_node = cast_traits::to_storage_type_pptr(__ite._M_node);
+ return tmp;
+ }
+};
+
+#define DEQUE_IMPL _STLP_PTR_IMPL_NAME(deque)
+#if defined (__BORLANDC__) || defined (__DMC__)
+# define typename
+#endif
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<size_t, void*, allocator<void*> >;
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<void***, void**, allocator<void**> >;
+_STLP_EXPORT template struct _STLP_CLASS_DECLSPEC _Deque_iterator<void*, _Nonconst_traits<void*> >;
+_STLP_EXPORT_TEMPLATE_CLASS _Deque_base<void*,allocator<void*> >;
+_STLP_EXPORT_TEMPLATE_CLASS DEQUE_IMPL<void*,allocator<void*> >;
+#endif
+
+#if defined (_STLP_DEBUG)
+# define deque _STLP_NON_DBG_NAME(deque)
+#else
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) >
+class deque
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (deque)
+ : public __stlport_class<deque<_Tp, _Alloc> >
+#endif
+{
+ typedef _STLP_TYPENAME _STLP_PRIV _StorageType<_Tp>::_Type _StorageType;
+ typedef typename _Alloc_traits<_StorageType, _Alloc>::allocator_type _StorageTypeAlloc;
+ typedef _STLP_PRIV DEQUE_IMPL<_StorageType, _StorageTypeAlloc> _Base;
+ typedef deque<_Tp, _Alloc> _Self;
+
+ typedef _STLP_PRIV _CastTraits<_StorageType, _Tp> cast_traits;
+ typedef _STLP_PRIV _DequeIteCast<_StorageType, _Tp> ite_cast_traits;
+
+public:
+ typedef _Tp value_type;
+ typedef value_type* pointer;
+ typedef const value_type* const_pointer;
+ typedef value_type& reference;
+ typedef const value_type& const_reference;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef random_access_iterator_tag _Iterator_category;
+ _STLP_FORCE_ALLOCATORS(value_type, _Alloc)
+ typedef typename _Alloc_traits<value_type, _Alloc>::allocator_type allocator_type;
+ typedef _STLP_PRIV _Deque_iterator<value_type, _Nonconst_traits<value_type> > iterator;
+ typedef _STLP_PRIV _Deque_iterator<value_type, _Const_traits<value_type> > const_iterator;
+
+ _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS;
+
+public: // Basic accessors
+ iterator begin() { return ite_cast_traits::to_value_type_ite(_M_impl.begin()); }
+ iterator end() { return ite_cast_traits::to_value_type_ite(_M_impl.end()); }
+ const_iterator begin() const { return ite_cast_traits::to_value_type_cite(_M_impl.begin()); }
+ const_iterator end() const { return ite_cast_traits::to_value_type_cite(_M_impl.end()); }
+
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+ const_reverse_iterator rbegin() const
+ { return const_reverse_iterator(end()); }
+ const_reverse_iterator rend() const
+ { return const_reverse_iterator(begin()); }
+
+ reference operator[](size_type __n)
+ { return cast_traits::to_value_type_ref(_M_impl[__n]); }
+ const_reference operator[](size_type __n) const
+ { return cast_traits::to_value_type_cref(_M_impl[__n]); }
+
+ reference at(size_type __n)
+ { return cast_traits::to_value_type_ref(_M_impl.at(__n)); }
+ const_reference at(size_type __n) const
+ { return cast_traits::to_value_type_cref(_M_impl.at(__n)); }
+
+ reference front() { return cast_traits::to_value_type_ref(_M_impl.front()); }
+ reference back() { return cast_traits::to_value_type_ref(_M_impl.back()); }
+ const_reference front() const { return cast_traits::to_value_type_cref(_M_impl.front()); }
+ const_reference back() const { return cast_traits::to_value_type_cref(_M_impl.back()); }
+
+ size_type size() const { return _M_impl.size(); }
+ size_type max_size() const { return _M_impl.max_size(); }
+ bool empty() const { return _M_impl.empty(); }
+ allocator_type get_allocator() const { return _STLP_CONVERT_ALLOCATOR(_M_impl.get_allocator(), value_type); }
+
+ explicit deque(const allocator_type& __a = allocator_type())
+ : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+ deque(const _Self& __x) : _M_impl(__x._M_impl) {}
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ explicit deque(size_type __n, const value_type& __val = _STLP_DEFAULT_CONSTRUCTED(value_type),
+#else
+ deque(size_type __n, const value_type& __val,
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ const allocator_type& __a = allocator_type())
+ : _M_impl(__n, cast_traits::to_storage_type_cref(__val), _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+ // int,long variants may be needed
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+ explicit deque(size_type __n) : _M_impl(__n) {}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ deque(_InputIterator __first, _InputIterator __last,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+#if !defined (_STLP_USE_ITERATOR_WRAPPER)
+ : _M_impl(__first, __last,
+ _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {
+#else
+ : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {
+#endif
+#if defined (_STLP_USE_ITERATOR_WRAPPER)
+ insert(end(), __first, __last);
+#endif
+ }
+
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ deque(_InputIterator __first, _InputIterator __last)
+# if !defined (_STLP_USE_ITERATOR_WRAPPER)
+ : _M_impl(__first, __last) {}
+# else
+ { insert(end(), __first, __last); }
+# endif
+# endif
+
+#else
+ deque(const_pointer __first, const_pointer __last,
+ const allocator_type& __a = allocator_type() )
+ : _M_impl(cast_traits::to_storage_type_cptr(__first),
+ cast_traits::to_storage_type_cptr(__last),
+ _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+ deque(const_iterator __first, const_iterator __last,
+ const allocator_type& __a = allocator_type() )
+ : _M_impl(ite_cast_traits::to_storage_type_cite(__first),
+ ite_cast_traits::to_storage_type_cite(__last),
+ _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ deque(__move_source<_Self> src)
+ : _M_impl(__move_source<_Base>(src.get()._M_impl)) {}
+#endif
+
+ _Self& operator= (const _Self& __x) { _M_impl = __x._M_impl; return *this; }
+
+ void swap(_Self& __x) { _M_impl.swap(__x._M_impl); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+ void assign(size_type __n, const value_type& __val) {
+ _M_impl.assign(__n, cast_traits::to_storage_type_cref(__val));
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+private:
+ template <class _Integer>
+ void _M_assign_dispatch(_Integer __n, _Integer __val,
+ const __true_type&)
+ { _M_impl.assign(__n, __val); }
+
+ template <class _InputIterator>
+ void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+ const __false_type&) {
+ _M_impl.assign(_STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
+ }
+
+public:
+# endif
+ template <class _InputIterator>
+ void assign(_InputIterator __first, _InputIterator __last) {
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_assign_dispatch(__first, __last, _Integral());
+# else
+ _M_impl.assign(__first, __last);
+# endif
+ }
+#else
+ void assign(const_pointer __first, const_pointer __last)
+ { _M_impl.assign(cast_traits::to_storage_type_cptr(__first),
+ cast_traits::to_storage_type_cptr(__last)); }
+ void assign(const_iterator __first, const_iterator __last)
+ { _M_impl.assign(ite_cast_traits::to_storage_type_cite(__first),
+ ite_cast_traits::to_storage_type_cite(__last)); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ void push_back(const value_type& __t = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+ void push_back(const value_type& __t)
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+ { _M_impl.push_back(cast_traits::to_storage_type_cref(__t)); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ void push_front(const value_type& __t = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+ void push_front(const value_type& __t)
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+ { _M_impl.push_front(cast_traits::to_storage_type_cref(__t)); }
+
+# if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ void push_back() { _M_impl.push_back(); }
+ void push_front() { _M_impl.push_front(); }
+# endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+ void pop_back() { _M_impl.pop_back(); }
+ void pop_front() { _M_impl.pop_front(); }
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ iterator insert(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+ iterator insert(iterator __pos, const value_type& __x)
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+ { return ite_cast_traits::to_value_type_ite(_M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos),
+ cast_traits::to_storage_type_cref(__x))); }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ iterator insert(iterator __pos) { return insert(__pos, _STLP_DEFAULT_CONSTRUCTED(value_type)); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+ void insert(iterator __pos, size_type __n, const value_type& __x)
+ { _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos), __n, cast_traits::to_storage_type_cref(__x)); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+private:
+ template <class _Integer>
+ void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
+ const __true_type&) {
+ _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos), __n, __val);
+ }
+
+ template <class _InputIterator>
+ void _M_insert_dispatch(iterator __pos,
+ _InputIterator __first, _InputIterator __last,
+ const __false_type&) {
+ _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
+ }
+
+public:
+# endif
+
+ template <class _InputIterator>
+ void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+ // Check whether it's an integral type. If so, it's not an iterator.
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_insert_dispatch(__pos, __first, __last, _Integral());
+# else
+ _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos), __first, __last);
+# endif
+ }
+
+#else /* _STLP_MEMBER_TEMPLATES */
+ void insert(iterator __pos,
+ const_pointer __first, const_pointer __last) {
+ _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos),
+ cast_traits::to_storage_type_cptr(__first),
+ cast_traits::to_storage_type_cptr(__last));
+ }
+ void insert(iterator __pos,
+ const_iterator __first, const_iterator __last) {
+ _M_impl.insert(ite_cast_traits::to_storage_type_ite(__pos),
+ ite_cast_traits::to_storage_type_cite(__first),
+ ite_cast_traits::to_storage_type_cite(__last));
+ }
+
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+#if !defined (_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+ void resize(size_type __new_size, const value_type& __x)
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ { _M_impl.resize(__new_size, cast_traits::to_storage_type_cref(__x)); }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size) { _M_impl.resize(__new_size); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+ iterator erase(iterator __pos)
+ { return ite_cast_traits::to_value_type_ite(_M_impl.erase(ite_cast_traits::to_storage_type_ite(__pos))); }
+
+ iterator erase(iterator __first, iterator __last)
+ { return ite_cast_traits::to_value_type_ite(_M_impl.erase(ite_cast_traits::to_storage_type_ite(__first),
+ ite_cast_traits::to_storage_type_ite(__last))); }
+ void clear() { _M_impl.clear(); }
+
+private:
+ _Base _M_impl;
+};
+
+#if defined (deque)
+# undef deque
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#undef DEQUE_IMPL
+#if defined (__BORLANDC__) || defined (__DMC__)
+# undef typename
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_SPECIALIZED_DEQUE_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/pointers/_list.h b/sources/android/stlport/stlport/stl/pointers/_list.h
new file mode 100644
index 0000000..52a9262
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/pointers/_list.h
@@ -0,0 +1,345 @@
+/*
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_PTR_SPECIALIZED_LIST_H
+#define _STLP_PTR_SPECIALIZED_LIST_H
+
+#ifndef _STLP_POINTERS_SPEC_TOOLS_H
+# include <stl/pointers/_tools.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#define LIST_IMPL _STLP_PTR_IMPL_NAME(list)
+#if defined (__BORLANDC__) || defined (__DMC__)
+# define typename
+#endif
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+_STLP_EXPORT_TEMPLATE_CLASS _List_node<void*>;
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_EXPORT_TEMPLATE_CLASS allocator<_STLP_PRIV _List_node<void*> >;
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<_List_node_base, _List_node<void*>, allocator<_List_node<void*> > >;
+_STLP_EXPORT_TEMPLATE_CLASS _List_base<void*, allocator<void*> >;
+_STLP_EXPORT_TEMPLATE_CLASS LIST_IMPL<void*, allocator<void*> >;
+
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#if defined (_STLP_DEBUG)
+# define list _STLP_NON_DBG_NAME(list)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) >
+class list
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (list)
+ : public __stlport_class<list<_Tp, _Alloc> >
+#endif
+{
+ typedef _STLP_TYPENAME _STLP_PRIV _StorageType<_Tp>::_Type _StorageType;
+ typedef typename _Alloc_traits<_StorageType, _Alloc>::allocator_type _StorageTypeAlloc;
+ typedef _STLP_PRIV LIST_IMPL<_StorageType, _StorageTypeAlloc> _Base;
+ typedef typename _Base::iterator _BaseIte;
+ typedef typename _Base::const_iterator _BaseConstIte;
+ typedef _STLP_PRIV _CastTraits<_StorageType, _Tp> cast_traits;
+ typedef list<_Tp, _Alloc> _Self;
+
+public:
+ typedef _Tp value_type;
+ typedef value_type* pointer;
+ typedef const value_type* const_pointer;
+ typedef value_type& reference;
+ typedef const value_type& const_reference;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ _STLP_FORCE_ALLOCATORS(value_type, _Alloc)
+ typedef typename _Alloc_traits<value_type, _Alloc>::allocator_type allocator_type;
+ typedef bidirectional_iterator_tag _Iterator_category;
+
+ typedef _STLP_PRIV _List_iterator<value_type, _Nonconst_traits<value_type> > iterator;
+ typedef _STLP_PRIV _List_iterator<value_type, _Const_traits<value_type> > const_iterator;
+
+ _STLP_DECLARE_BIDIRECTIONAL_REVERSE_ITERATORS;
+
+ allocator_type get_allocator() const
+ { return _STLP_CONVERT_ALLOCATOR(_M_impl.get_allocator(), value_type); }
+
+ explicit list(const allocator_type& __a = allocator_type())
+ : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+ explicit list(size_type __n, const value_type& __val = _STLP_DEFAULT_CONSTRUCTED(value_type),
+#else
+ list(size_type __n, const value_type& __val,
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ const allocator_type& __a = allocator_type())
+ : _M_impl(__n, cast_traits::to_storage_type_cref(__val),
+ _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+ explicit list(size_type __n)
+ : _M_impl(__n) {}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ list(_InputIterator __first, _InputIterator __last,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+# if !defined (_STLP_USE_ITERATOR_WRAPPER)
+ : _M_impl(__first, __last, _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+# else
+ : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {
+ insert(begin(), __first, __last);
+ }
+# endif
+
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ list(_InputIterator __first, _InputIterator __last)
+# if !defined (_STLP_USE_WRAPPER_ITERATOR)
+ : _M_impl(__first, __last) {}
+# else
+ { insert(begin(), __first, __last); }
+# endif
+# endif
+
+#else /* _STLP_MEMBER_TEMPLATES */
+
+ list(const value_type *__first, const value_type *__last,
+ const allocator_type& __a = allocator_type())
+ : _M_impl(cast_traits::to_storage_type_cptr(__first),
+ cast_traits::to_storage_type_cptr(__last),
+ _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+ list(const_iterator __first, const_iterator __last,
+ const allocator_type& __a = allocator_type())
+ : _M_impl(_BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node),
+ _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ list(const _Self& __x) : _M_impl(__x._M_impl) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ list(__move_source<_Self> src)
+ : _M_impl(__move_source<_Base>(src.get()._M_impl)) {}
+#endif
+
+ iterator begin() { return iterator(_M_impl.begin()._M_node); }
+ const_iterator begin() const { return const_iterator(_M_impl.begin()._M_node); }
+
+ iterator end() { return iterator(_M_impl.end()._M_node); }
+ const_iterator end() const { return const_iterator(_M_impl.end()._M_node); }
+
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+ const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+
+ bool empty() const { return _M_impl.empty(); }
+ size_type size() const { return _M_impl.size(); }
+ size_type max_size() const { return _M_impl.max_size(); }
+
+ reference front() { return *begin(); }
+ const_reference front() const { return *begin(); }
+ reference back() { return *(--end()); }
+ const_reference back() const { return *(--end()); }
+
+ void swap(_Self &__x) { _M_impl.swap(__x._M_impl); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+ void clear() { _M_impl.clear(); }
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+ iterator insert(iterator __pos, const_reference __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+ iterator insert(iterator __pos, const_reference __x)
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+ { return iterator(_M_impl.insert(_BaseIte(__pos._M_node),
+ cast_traits::to_storage_type_cref(__x))._M_node); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+private:
+ template <class _Integer>
+ void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
+ const __true_type&)
+ { _M_impl.insert(_BaseIte(__pos._M_node), __n, __val); }
+
+ template <class _InputIterator>
+ void _M_insert_dispatch(iterator __pos,
+ _InputIterator __first, _InputIterator __last,
+ const __false_type&) {
+ _M_impl.insert(_BaseIte(__pos._M_node),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
+ }
+
+public:
+# endif
+
+ template <class _InputIterator>
+ void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+ // Check whether it's an integral type. If so, it's not an iterator.
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_insert_dispatch(__pos, __first, __last, _Integral());
+# else
+ _M_impl.insert(_BaseIte(__pos._M_node), __first, __last);
+# endif
+ }
+#else /* _STLP_MEMBER_TEMPLATES */
+ void insert(iterator __pos, const value_type *__first, const value_type *__last)
+ { _M_impl.insert(_BaseIte(__pos._M_node), cast_traits::to_storage_type_cptr(__first),
+ cast_traits::to_storage_type_cptr(__last)); }
+ void insert(iterator __pos, const_iterator __first, const_iterator __last)
+ { _M_impl.insert(_BaseIte(__pos._M_node), _BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node)); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ void insert(iterator __pos, size_type __n, const value_type& __x)
+ { _M_impl.insert(_BaseIte(__pos._M_node), __n, cast_traits::to_storage_type_cref(__x)); }
+
+ void push_front(const value_type& __x) { _M_impl.push_front(cast_traits::to_storage_type_cref(__x)); }
+ void push_back(const value_type& __x) { _M_impl.push_back(cast_traits::to_storage_type_cref(__x)); }
+
+#if defined (_STLP_DONT_SUP_DFLT_PARAM) && !defined (_STLP_NO_ANACHRONISMS)
+ iterator insert(iterator __pos) { return iterator(_M_impl.insert(__pos._M_node)._M_node); }
+ void push_front() { _M_impl.push_front();}
+ void push_back() { _M_impl.push_back();}
+# endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+ iterator erase(iterator __pos)
+ { return iterator(_M_impl.erase(_BaseIte(__pos._M_node))._M_node); }
+ iterator erase(iterator __first, iterator __last)
+ { return iterator(_M_impl.erase(_BaseIte(__first._M_node), _BaseIte(__last._M_node))._M_node); }
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+ void resize(size_type __new_size) { _M_impl.resize(__new_size); }
+ void resize(size_type __new_size, const value_type& __x)
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM*/
+ {_M_impl.resize(__new_size, cast_traits::to_storage_type_cref(__x));}
+
+ void pop_front() { _M_impl.pop_front(); }
+ void pop_back() { _M_impl.pop_back(); }
+
+ _Self& operator=(const _Self& __x)
+ { _M_impl = __x._M_impl; return *this; }
+ void assign(size_type __n, const value_type& __val)
+ { _M_impl.assign(__n, cast_traits::to_storage_type_cref(__val)); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+private:
+ template <class _Integer>
+ void _M_assign_dispatch(_Integer __n, _Integer __val, const __true_type&)
+ { _M_impl.assign(__n, __val); }
+
+ template <class _InputIterator>
+ void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+ const __false_type&) {
+ _M_impl.assign(_STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
+ }
+
+public:
+# endif
+
+ template <class _InputIterator>
+ void assign(_InputIterator __first, _InputIterator __last) {
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_assign_dispatch(__first, __last, _Integral());
+# else
+ _M_impl.assign(__first, __last);
+# endif
+ }
+#else
+ void assign(const value_type *__first, const value_type *__last) {
+ _M_impl.assign(cast_traits::to_storage_type_cptr(__first),
+ cast_traits::to_storage_type_cptr(__last));
+ }
+ void assign(const_iterator __first, const_iterator __last)
+ { _M_impl.assign(_BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node)); }
+#endif
+
+ void splice(iterator __pos, _Self& __x)
+ { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl); }
+ void splice(iterator __pos, _Self& __x, iterator __i)
+ { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl, _BaseIte(__i._M_node)); }
+ void splice(iterator __pos, _Self& __x, iterator __first, iterator __last)
+ { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl,
+ _BaseIte(__first._M_node), _BaseIte(__last._M_node)); }
+
+ void remove(const_reference __val)
+ { _M_impl.remove(cast_traits::to_storage_type_cref(__val)); }
+ void unique() { _M_impl.unique(); }
+ void merge(_Self& __x) { _M_impl.merge(__x._M_impl); }
+ void reverse() { _M_impl.reverse(); }
+ void sort() { _M_impl.sort(); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _Predicate>
+ void remove_if(_Predicate __pred)
+ { _M_impl.remove_if(_STLP_PRIV _UnaryPredWrapper<_StorageType, _Tp, _Predicate>(__pred)); }
+ template <class _BinaryPredicate>
+ void unique(_BinaryPredicate __bin_pred)
+ { _M_impl.unique(_STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _BinaryPredicate>(__bin_pred)); }
+
+ template <class _StrictWeakOrdering>
+ void merge(_Self &__x, _StrictWeakOrdering __comp)
+ { _M_impl.merge(__x._M_impl, _STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _StrictWeakOrdering>(__comp)); }
+
+ template <class _StrictWeakOrdering>
+ void sort(_StrictWeakOrdering __comp)
+ { _M_impl.sort(_STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _StrictWeakOrdering>(__comp)); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+private:
+ _Base _M_impl;
+};
+
+#if defined (list)
+# undef list
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#undef LIST_IMPL
+#if defined (__BORLANDC__) || defined (__DMC__)
+# undef typename
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_PTR_SPECIALIZED_LIST_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/pointers/_set.h b/sources/android/stlport/stlport/stl/pointers/_set.h
new file mode 100644
index 0000000..f997a5a
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/pointers/_set.h
@@ -0,0 +1,564 @@
+/*
+ * Copyright (c) 2005
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_PTR_SPECIALIZED_SET_H
+#define _STLP_PTR_SPECIALIZED_SET_H
+
+#ifndef _STLP_POINTERS_SPEC_TOOLS_H
+# include <stl/pointers/_tools.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#if defined (__BORLANDC__) || defined (__DMC__)
+# define typename
+#endif
+
+//Specific iterator traits creation
+_STLP_CREATE_ITERATOR_TRAITS(SetTraitsT, Const_traits)
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+_STLP_EXPORT template struct _STLP_CLASS_DECLSPEC less<void*>;
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+typedef _Rb_tree_node<void*> _Node;
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<_Rb_tree_node_base, _Node, allocator<_Node> >;
+_STLP_EXPORT_TEMPLATE_CLASS _Rb_tree_base<void*, allocator<void*> >;
+# if defined (_STLP_DEBUG)
+_STLP_EXPORT_TEMPLATE_CLASS _DbgCompare<void*, less<void*> >;
+# define _Rb_tree _STLP_NON_DBG_NAME(Rb_tree)
+_STLP_EXPORT_TEMPLATE_CLASS _Rb_tree<void*, _DbgCompare<void*, less<void*> >, void*, _Identity<void*>,
+ _SetTraitsT<void*>, allocator<void*> >;
+# undef _Rb_tree
+# endif
+_STLP_EXPORT_TEMPLATE_CLASS _Rb_tree<void*, less<void*>, void*, _Identity<void*>,
+ _SetTraitsT<void*>, allocator<void*> >;
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+template <class _Key, _STLP_DFL_TMPL_PARAM(_Compare, less<_Key>),
+ _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Key>) >
+class set
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ : public __stlport_class<set<_Key, _Compare, _Alloc> >
+#endif
+{
+#if !defined (__BORLANDC__)
+ typedef _STLP_PRIV _AssocStorageTypes<_Key, _Compare> _AssocStorageTypes;
+ typedef typename _AssocStorageTypes::_KeyStorageType _KeyStorageType;
+ typedef typename _AssocStorageTypes::_CompareStorageType _CompareStorageType;
+#else
+ typedef _STLP_PRIV _AssocStorageTypes<_Key, _Compare>::_KeyStorageType _KeyStorageType;
+ typedef _STLP_PRIV _AssocStorageTypes<_Key, _Compare>::_CompareStorageType _CompareStorageType;
+#endif
+ typedef typename _Alloc_traits<_KeyStorageType, _Alloc>::allocator_type _StorageTypeAlloc;
+ typedef _STLP_PRIV _CastTraits<_KeyStorageType, _Key> cast_traits;
+
+ typedef set<_Key, _Compare, _Alloc> _Self;
+public:
+ typedef _Key key_type;
+ typedef _Key value_type;
+ typedef _Compare key_compare;
+ typedef _Compare value_compare;
+
+protected:
+ //Specific iterator traits creation
+ typedef _STLP_PRIV _SetTraitsT<value_type> _SetTraits;
+ typedef _STLP_PRIV _Rb_tree<key_type, key_compare,
+ value_type, _STLP_PRIV _Identity<value_type>,
+ _SetTraits, _Alloc> _Priv_Rep_type;
+
+ typedef _STLP_PRIV _SetTraitsT<_KeyStorageType> _SetStorageTraits;
+
+public:
+ //dums: need the following public for the __move_traits framework
+ typedef _STLP_PRIV _Rb_tree<_KeyStorageType, _CompareStorageType,
+ _KeyStorageType, _STLP_PRIV _Identity<_KeyStorageType>,
+ _SetStorageTraits, _StorageTypeAlloc> _Rep_type;
+
+private:
+ typedef typename _Rep_type::iterator base_iterator;
+ typedef typename _Rep_type::const_iterator const_base_iterator;
+
+public:
+ typedef typename _Priv_Rep_type::pointer pointer;
+ typedef typename _Priv_Rep_type::const_pointer const_pointer;
+ typedef typename _Priv_Rep_type::reference reference;
+ typedef typename _Priv_Rep_type::const_reference const_reference;
+ typedef typename _Priv_Rep_type::iterator iterator;
+ typedef typename _Priv_Rep_type::const_iterator const_iterator;
+ typedef typename _Priv_Rep_type::reverse_iterator reverse_iterator;
+ typedef typename _Priv_Rep_type::const_reverse_iterator const_reverse_iterator;
+ typedef typename _Priv_Rep_type::size_type size_type;
+ typedef typename _Priv_Rep_type::difference_type difference_type;
+ typedef typename _Priv_Rep_type::allocator_type allocator_type;
+
+private:
+ _Rep_type _M_t; // red-black tree representing set
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+#if defined (_STLP_DEBUG)
+ static iterator _S_to_value_ite(const_base_iterator __ite)
+ { return iterator(__ite._Owner(), __ite._M_iterator._M_node); }
+ static base_iterator _S_to_storage_ite(const_iterator __ite)
+ { return base_iterator(__ite._Owner(), __ite._M_iterator._M_node); }
+#else
+ static iterator _S_to_value_ite(const_base_iterator __ite)
+ { return iterator(__ite._M_node); }
+ static base_iterator _S_to_storage_ite(const_iterator __ite)
+ { return base_iterator(__ite._M_node); }
+#endif
+
+public:
+ set() : _M_t(_CompareStorageType(), _StorageTypeAlloc()) {}
+ explicit set(const _Compare& __comp,
+ const allocator_type& __a = allocator_type())
+ : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {}
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ set(_InputIterator __first, _InputIterator __last)
+ : _M_t(_Compare(), _StorageTypeAlloc()) {
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+ _M_t.insert_unique(_STLP_TYPENAME _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
+# else
+ _M_t.insert_unique(__first, __last);
+# endif
+ }
+
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ set(_InputIterator __first, _InputIterator __last, const _Compare& __comp)
+ : _M_t(__comp, _StorageTypeAlloc()) {
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+ _M_t.insert_unique(_STLP_TYPENAME _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
+# else
+ _M_t.insert_unique(__first, __last);
+# endif
+ }
+# endif
+ template <class _InputIterator>
+ set(_InputIterator __first, _InputIterator __last, const _Compare& __comp,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+ _M_t.insert_unique(_STLP_TYPENAME _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
+# else
+ _M_t.insert_unique(__first, __last);
+# endif
+ }
+#else
+ set(const value_type* __first, const value_type* __last)
+ : _M_t(_Compare(), _StorageTypeAlloc()) {
+ _M_t.insert_unique(cast_traits::to_storage_type_cptr(__first),
+ cast_traits::to_storage_type_cptr(__last));
+ }
+
+ set(const value_type* __first, const value_type* __last,
+ const _Compare& __comp, const allocator_type& __a = allocator_type())
+ : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {
+ _M_t.insert_unique(cast_traits::to_storage_type_cptr(__first),
+ cast_traits::to_storage_type_cptr(__last));
+ }
+
+ set(const_iterator __first, const_iterator __last)
+ : _M_t(_Compare(), _StorageTypeAlloc())
+ { _M_t.insert_unique(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
+
+ set(const_iterator __first, const_iterator __last,
+ const _Compare& __comp, const allocator_type& __a = allocator_type())
+ : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType))
+ { _M_t.insert_unique(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ set(const _Self& __x) : _M_t(__x._M_t) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ set(__move_source<_Self> src)
+ : _M_t(__move_source<_Rep_type>(src.get()._M_t)) {}
+#endif
+
+ _Self& operator=(const _Self& __x) {
+ _M_t = __x._M_t;
+ return *this;
+ }
+
+ // accessors:
+ key_compare key_comp() const { return _M_t.key_comp(); }
+ value_compare value_comp() const { return _M_t.key_comp(); }
+ allocator_type get_allocator() const
+ { return _STLP_CONVERT_ALLOCATOR(_M_t.get_allocator(), value_type); }
+
+ iterator begin() { return _S_to_value_ite(_M_t.begin()); }
+ iterator end() { return _S_to_value_ite(_M_t.end()); }
+ const_iterator begin() const { return _S_to_value_ite(_M_t.begin()); }
+ const_iterator end() const { return _S_to_value_ite(_M_t.end()); }
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+ const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+ const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+ bool empty() const { return _M_t.empty(); }
+ size_type size() const { return _M_t.size(); }
+ size_type max_size() const { return _M_t.max_size(); }
+ void swap(_Self& __x) { _M_t.swap(__x._M_t); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+ // insert/erase
+ pair<iterator,bool> insert(const value_type& __x) {
+ pair<base_iterator, bool> ret = _M_t.insert_unique(cast_traits::to_storage_type_cref(__x));
+ return pair<iterator, bool>(_S_to_value_ite(ret.first), ret.second);
+ }
+ iterator insert(iterator __pos, const value_type& __x)
+ { return _S_to_value_ite(_M_t.insert_unique(_S_to_storage_ite(__pos), cast_traits::to_storage_type_cref(__x))); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void insert(_InputIterator __first, _InputIterator __last) {
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+ _M_t.insert_unique(_STLP_TYPENAME _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
+# else
+ _M_t.insert_unique(__first, __last);
+# endif
+ }
+#else
+ void insert(const_iterator __first, const_iterator __last)
+ { _M_t.insert_unique(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
+ void insert(const value_type* __first, const value_type* __last) {
+ _M_t.insert_unique(cast_traits::to_storage_type_cptr(__first),
+ cast_traits::to_storage_type_cptr(__last));
+ }
+#endif
+ void erase(iterator __pos)
+ { _M_t.erase(_S_to_storage_ite(__pos)); }
+ size_type erase(const key_type& __x)
+ { return _M_t.erase_unique(cast_traits::to_storage_type_cref(__x)); }
+ void erase(iterator __first, iterator __last)
+ { _M_t.erase(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
+ void clear() { _M_t.clear(); }
+
+ // set operations:
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __x) const
+ { return _S_to_value_ite(_M_t.find(cast_traits::to_storage_type_crefT(__x))); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __x)
+ { return _S_to_value_ite(_M_t.find(cast_traits::to_storage_type_crefT(__x))); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __x) const
+ { return _M_t.find(cast_traits::to_storage_type_crefT(__x)) == _M_t.end() ? 0 : 1; }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator lower_bound(const _KT& __x)
+ { return _S_to_value_ite(_M_t.lower_bound(cast_traits::to_storage_type_crefT(__x))); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator lower_bound(const _KT& __x) const
+ { return _S_to_value_ite(_M_t.lower_bound(cast_traits::to_storage_type_crefT(__x))); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator upper_bound(const _KT& __x)
+ { return _S_to_value_ite(_M_t.upper_bound(cast_traits::to_storage_type_crefT(__x))); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator upper_bound(const _KT& __x) const
+ { return _S_to_value_ite(_M_t.upper_bound(cast_traits::to_storage_type_crefT(__x))); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator, iterator> equal_range(const _KT& __x) {
+ pair<base_iterator, base_iterator> __ret;
+ __ret = _M_t.equal_range(cast_traits::to_storage_type_crefT(__x));
+ return pair<iterator, iterator>(_S_to_value_ite(__ret.first),
+ _S_to_value_ite(__ret.second));
+ }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator> equal_range(const _KT& __x) const {
+ pair<const_base_iterator, const_base_iterator> __ret;
+ __ret = _M_t.equal_range_unique(cast_traits::to_storage_type_crefT(__x));
+ return pair<const_iterator, const_iterator>(_S_to_value_ite(__ret.first),
+ _S_to_value_ite(__ret.second));
+ }
+};
+
+//Specific iterator traits creation
+_STLP_CREATE_ITERATOR_TRAITS(MultisetTraitsT, Const_traits)
+
+template <class _Key, _STLP_DFL_TMPL_PARAM(_Compare, less<_Key>),
+ _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Key>) >
+class multiset
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ : public __stlport_class<multiset<_Key, _Compare, _Alloc> >
+#endif
+{
+#if !defined (__BORLANDC__)
+ typedef _STLP_PRIV _AssocStorageTypes<_Key, _Compare> _AssocStorageTypes;
+ typedef typename _AssocStorageTypes::_KeyStorageType _KeyStorageType;
+ typedef typename _AssocStorageTypes::_CompareStorageType _CompareStorageType;
+#else
+ typedef _STLP_PRIV _AssocStorageTypes<_Key, _Compare>::_KeyStorageType _KeyStorageType;
+ typedef _STLP_PRIV _AssocStorageTypes<_Key, _Compare>::_CompareStorageType _CompareStorageType;
+#endif
+ typedef typename _Alloc_traits<_KeyStorageType, _Alloc>::allocator_type _StorageTypeAlloc;
+ typedef _STLP_PRIV _CastTraits<_KeyStorageType, _Key> cast_traits;
+
+ typedef multiset<_Key, _Compare, _Alloc> _Self;
+public:
+ // typedefs:
+ typedef _Key key_type;
+ typedef _Key value_type;
+ typedef _Compare key_compare;
+ typedef _Compare value_compare;
+
+protected:
+ //Specific iterator traits creation
+ typedef _STLP_PRIV _MultisetTraitsT<value_type> _MultisetTraits;
+ typedef _STLP_PRIV _Rb_tree<key_type, key_compare,
+ value_type, _STLP_PRIV _Identity<value_type>,
+ _MultisetTraits, _Alloc> _Priv_Rep_type;
+
+ typedef _STLP_PRIV _MultisetTraitsT<_KeyStorageType> _MultisetStorageTraits;
+public:
+ //dums: need the following public for the __move_traits framework
+ typedef _STLP_PRIV _Rb_tree<_KeyStorageType, _CompareStorageType,
+ _KeyStorageType, _STLP_PRIV _Identity<_KeyStorageType>,
+ _MultisetStorageTraits, _StorageTypeAlloc> _Rep_type;
+
+private:
+ typedef typename _Rep_type::iterator base_iterator;
+ typedef typename _Rep_type::const_iterator const_base_iterator;
+
+public:
+ typedef typename _Priv_Rep_type::pointer pointer;
+ typedef typename _Priv_Rep_type::const_pointer const_pointer;
+ typedef typename _Priv_Rep_type::reference reference;
+ typedef typename _Priv_Rep_type::const_reference const_reference;
+ typedef typename _Priv_Rep_type::iterator iterator;
+ typedef typename _Priv_Rep_type::const_iterator const_iterator;
+ typedef typename _Priv_Rep_type::reverse_iterator reverse_iterator;
+ typedef typename _Priv_Rep_type::const_reverse_iterator const_reverse_iterator;
+ typedef typename _Priv_Rep_type::size_type size_type;
+ typedef typename _Priv_Rep_type::difference_type difference_type;
+ typedef typename _Priv_Rep_type::allocator_type allocator_type;
+
+private:
+ _Rep_type _M_t; // red-black tree representing multiset
+ _STLP_KEY_TYPE_FOR_CONT_EXT(key_type)
+
+#if defined (_STLP_DEBUG)
+ static iterator _S_to_value_ite(const_base_iterator __ite)
+ { return iterator(__ite._Owner(), __ite._M_iterator._M_node); }
+ static base_iterator _S_to_storage_ite(const_iterator __ite)
+ { return base_iterator(__ite._Owner(), __ite._M_iterator._M_node); }
+#else
+ static iterator _S_to_value_ite(const_base_iterator __ite)
+ { return iterator(__ite._M_node); }
+ static base_iterator _S_to_storage_ite(const_iterator __ite)
+ { return base_iterator(__ite._M_node); }
+#endif
+
+public:
+ multiset() : _M_t(_Compare(), _StorageTypeAlloc()) {}
+ explicit multiset(const _Compare& __comp,
+ const allocator_type& __a = allocator_type())
+ : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {}
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ multiset(_InputIterator __first, _InputIterator __last)
+ : _M_t(_Compare(), _StorageTypeAlloc()) {
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+ _M_t.insert_equal(_STLP_TYPENAME _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
+# else
+ _M_t.insert_equal(__first, __last);
+# endif
+ }
+
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ multiset(_InputIterator __first, _InputIterator __last,
+ const _Compare& __comp)
+ : _M_t(__comp, _StorageTypeAlloc()) {
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+ _M_t.insert_equal(_STLP_TYPENAME _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
+# else
+ _M_t.insert_equal(__first, __last);
+# endif
+ }
+# endif
+ template <class _InputIterator>
+ multiset(_InputIterator __first, _InputIterator __last,
+ const _Compare& __comp,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+ : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+ _M_t.insert_equal(_STLP_TYPENAME _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
+# else
+ _M_t.insert_equal(__first, __last);
+# endif
+ }
+
+#else
+ multiset(const value_type* __first, const value_type* __last)
+ : _M_t(_Compare(), _StorageTypeAlloc()) {
+ _M_t.insert_equal(cast_traits::to_storage_type_cptr(__first),
+ cast_traits::to_storage_type_cptr(__last));
+ }
+
+ multiset(const value_type* __first, const value_type* __last,
+ const _Compare& __comp,
+ const allocator_type& __a = allocator_type())
+ : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType)) {
+ _M_t.insert_equal(cast_traits::to_storage_type_cptr(__first),
+ cast_traits::to_storage_type_cptr(__last));
+ }
+
+ multiset(const_iterator __first, const_iterator __last)
+ : _M_t(_Compare(), _StorageTypeAlloc())
+ { _M_t.insert_equal(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
+
+ multiset(const_iterator __first, const_iterator __last,
+ const _Compare& __comp,
+ const allocator_type& __a = allocator_type())
+ : _M_t(__comp, _STLP_CONVERT_ALLOCATOR(__a, _KeyStorageType))
+ { _M_t.insert_equal(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ multiset(const _Self& __x)
+ : _M_t(__x._M_t) {}
+
+ _Self& operator=(const _Self& __x) {
+ _M_t = __x._M_t;
+ return *this;
+ }
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ multiset(__move_source<_Self> src)
+ : _M_t(__move_source<_Rep_type>(src.get()._M_t)) {}
+#endif
+
+ // accessors:
+ key_compare key_comp() const { return _M_t.key_comp(); }
+ value_compare value_comp() const { return _M_t.key_comp(); }
+ allocator_type get_allocator() const
+ { return _STLP_CONVERT_ALLOCATOR(_M_t.get_allocator(), value_type); }
+
+ iterator begin() { return _S_to_value_ite(_M_t.begin()); }
+ iterator end() { return _S_to_value_ite(_M_t.end()); }
+ const_iterator begin() const { return _S_to_value_ite(_M_t.begin()); }
+ const_iterator end() const { return _S_to_value_ite(_M_t.end()); }
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+ const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+ const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+ bool empty() const { return _M_t.empty(); }
+ size_type size() const { return _M_t.size(); }
+ size_type max_size() const { return _M_t.max_size(); }
+ void swap(_Self& __x) { _M_t.swap(__x._M_t); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+ // insert/erase
+ iterator insert(const value_type& __x)
+ { return _S_to_value_ite(_M_t.insert_equal(cast_traits::to_storage_type_cref(__x))); }
+ iterator insert(iterator __pos, const value_type& __x) {
+ return _S_to_value_ite(_M_t.insert_equal(_S_to_storage_ite(__pos),
+ cast_traits::to_storage_type_cref(__x)));
+ }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void insert(_InputIterator __first, _InputIterator __last) {
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+ _M_t.insert_equal(_STLP_TYPENAME _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__first),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_KeyStorageType, _Key, _InputIterator>::_Ite(__last));
+# else
+ _M_t.insert_equal(__first, __last);
+# endif
+ }
+#else
+ void insert(const value_type* __first, const value_type* __last) {
+ _M_t.insert_equal(cast_traits::to_storage_type_cptr(__first),
+ cast_traits::to_storage_type_cptr(__last));
+ }
+ void insert(const_iterator __first, const_iterator __last)
+ { _M_t.insert_equal(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ void erase(iterator __pos)
+ { _M_t.erase(_S_to_storage_ite(__pos)); }
+ size_type erase(const key_type& __x)
+ { return _M_t.erase(cast_traits::to_storage_type_cref(__x)); }
+ void erase(iterator __first, iterator __last)
+ { _M_t.erase(_S_to_storage_ite(__first), _S_to_storage_ite(__last)); }
+ void clear() { _M_t.clear(); }
+
+ // multiset operations:
+
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator find(const _KT& __x)
+ { return _S_to_value_ite(_M_t.find(cast_traits::to_storage_type_crefT(__x))); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator find(const _KT& __x) const
+ { return _S_to_value_ite(_M_t.find(cast_traits::to_storage_type_crefT(__x))); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ size_type count(const _KT& __x) const
+ { return _M_t.count(cast_traits::to_storage_type_crefT(__x)); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator lower_bound(const _KT& __x)
+ { return _S_to_value_ite(_M_t.lower_bound(cast_traits::to_storage_type_crefT(__x))); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator lower_bound(const _KT& __x) const
+ { return _S_to_value_ite(_M_t.lower_bound(cast_traits::to_storage_type_crefT(__x))); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ iterator upper_bound(const _KT& __x)
+ { return _S_to_value_ite(_M_t.upper_bound(cast_traits::to_storage_type_crefT(__x))); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ const_iterator upper_bound(const _KT& __x) const
+ { return _S_to_value_ite(_M_t.upper_bound(cast_traits::to_storage_type_crefT(__x))); }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<iterator, iterator> equal_range(const _KT& __x) {
+ pair<base_iterator, base_iterator> __ret;
+ __ret = _M_t.equal_range(cast_traits::to_storage_type_crefT(__x));
+ return pair<iterator, iterator>(_S_to_value_ite(__ret.first),
+ _S_to_value_ite(__ret.second));
+ }
+ _STLP_TEMPLATE_FOR_CONT_EXT
+ pair<const_iterator, const_iterator> equal_range(const _KT& __x) const {
+ pair<const_base_iterator, const_base_iterator> __ret;
+ __ret = _M_t.equal_range(cast_traits::to_storage_type_crefT(__x));
+ return pair<const_iterator, const_iterator>(_S_to_value_ite(__ret.first),
+ _S_to_value_ite(__ret.second));
+ }
+};
+
+#if defined (__BORLANDC__) || defined (__DMC__)
+# undef typename
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_PTR_SPECIALIZED_SET_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/pointers/_slist.h b/sources/android/stlport/stlport/stl/pointers/_slist.h
new file mode 100644
index 0000000..76189fe
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/pointers/_slist.h
@@ -0,0 +1,427 @@
+/*
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_SPECIALIZED_SLIST_H
+#define _STLP_SPECIALIZED_SLIST_H
+
+#ifndef _STLP_POINTERS_SPEC_TOOLS_H
+# include <stl/pointers/_tools.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#define SLIST_IMPL _STLP_PTR_IMPL_NAME(slist)
+
+#if defined (__BORLANDC__) || defined (__DMC__)
+# define typename
+#endif
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+_STLP_EXPORT_TEMPLATE_CLASS _Slist_node<void*>;
+typedef _Slist_node<void*> _VoidPtrSNode;
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<_Slist_node_base, _VoidPtrSNode, allocator<_VoidPtrSNode> >;
+_STLP_EXPORT_TEMPLATE_CLASS _Slist_base<void*, allocator<void*> >;
+_STLP_EXPORT_TEMPLATE_CLASS SLIST_IMPL<void*, allocator<void*> >;
+
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#if defined (_STLP_DEBUG)
+# define slist _STLP_NON_DBG_NAME(slist)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) >
+class slist
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (slist)
+ : public __stlport_class<slist<_Tp, _Alloc> >
+#endif
+{
+ typedef _STLP_TYPENAME _STLP_PRIV _StorageType<_Tp>::_Type _StorageType;
+ typedef typename _Alloc_traits<_StorageType, _Alloc>::allocator_type _StorageTypeAlloc;
+ typedef _STLP_PRIV SLIST_IMPL<_StorageType, _StorageTypeAlloc> _Base;
+ typedef typename _Base::iterator _BaseIte;
+ typedef typename _Base::const_iterator _BaseConstIte;
+ typedef slist<_Tp, _Alloc> _Self;
+ typedef _STLP_PRIV _CastTraits<_StorageType, _Tp> cast_traits;
+ typedef _STLP_PRIV _Slist_node_base _Node_base;
+
+public:
+ typedef _Tp value_type;
+ typedef value_type* pointer;
+ typedef const value_type* const_pointer;
+ typedef value_type& reference;
+ typedef const value_type& const_reference;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef forward_iterator_tag _Iterator_category;
+
+ typedef _STLP_PRIV _Slist_iterator<value_type, _Nonconst_traits<value_type> > iterator;
+ typedef _STLP_PRIV _Slist_iterator<value_type, _Const_traits<value_type> > const_iterator;
+
+ _STLP_FORCE_ALLOCATORS(value_type, _Alloc)
+ typedef typename _Alloc_traits<value_type, _Alloc>::allocator_type allocator_type;
+
+public:
+ allocator_type get_allocator() const
+ { return _STLP_CONVERT_ALLOCATOR(_M_impl.get_allocator(), value_type); }
+
+ explicit slist(const allocator_type& __a = allocator_type())
+ : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+ explicit slist(size_type __n, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type),
+#else
+ slist(size_type __n, const value_type& __x,
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ const allocator_type& __a = allocator_type())
+ : _M_impl(__n, cast_traits::to_storage_type_cref(__x), _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+ explicit slist(size_type __n) : _M_impl(__n) {}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ // We don't need any dispatching tricks here, because _M_insert_after_range
+ // already does them.
+ template <class _InputIterator>
+ slist(_InputIterator __first, _InputIterator __last,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL)
+# if !defined (_STLP_USE_ITERATOR_WRAPPER)
+ : _M_impl(__first, __last, _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+# else
+ : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {
+ insert_after(before_begin(), __first, __last);
+ }
+# endif
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ // VC++ needs this crazyness
+ template <class _InputIterator>
+ slist(_InputIterator __first, _InputIterator __last)
+# if !defined (_STLP_USE_WRAPPER_ITERATOR)
+ : _M_impl(__first, __last) {}
+# else
+ { insert_after(before_begin(), __first, __last); }
+# endif
+# endif
+#else /* _STLP_MEMBER_TEMPLATES */
+ slist(const_iterator __first, const_iterator __last,
+ const allocator_type& __a = allocator_type() )
+ : _M_impl(_BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node),
+ _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+ slist(const value_type* __first, const value_type* __last,
+ const allocator_type& __a = allocator_type())
+ : _M_impl(cast_traits::to_storage_type_cptr(__first), cast_traits::to_storage_type_cptr(__last),
+ _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ slist(const _Self& __x) : _M_impl(__x._M_impl) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ slist(__move_source<_Self> src)
+ : _M_impl(__move_source<_Base>(src.get()._M_impl)) {}
+#endif
+
+ _Self& operator= (const _Self& __x) { _M_impl = __x._M_impl; return *this; }
+
+ void assign(size_type __n, const value_type& __val)
+ { _M_impl.assign(__n, cast_traits::to_storage_type_cref(__val)); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+private:
+ template <class _Integer>
+ void _M_assign_dispatch(_Integer __n, _Integer __val,
+ const __true_type&)
+ { _M_impl.assign(__n, __val); }
+
+ template <class _InputIterator>
+ void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+ const __false_type&) {
+ _M_impl.assign(_STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
+ }
+
+public:
+# endif
+
+ template <class _InputIterator>
+ void assign(_InputIterator __first, _InputIterator __last) {
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_assign_dispatch(__first, __last, _Integral());
+# else
+ _M_impl.assign(__first, __last);
+# endif
+ }
+#else
+ void assign(const value_type *__first, const value_type *__last) {
+ _M_impl.assign(cast_traits::to_storage_type_cptr(__first),
+ cast_traits::to_storage_type_cptr(__last));
+ }
+ void assign(const_iterator __first, const_iterator __last) {
+ _M_impl.assign(_BaseConstIte(__first._M_node),
+ _BaseConstIte(__last._M_node));
+ }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ iterator before_begin() { return iterator(_M_impl.before_begin()._M_node); }
+ const_iterator before_begin() const { return const_iterator(const_cast<_Node_base*>(_M_impl.before_begin()._M_node)); }
+
+ iterator begin() { return iterator(_M_impl.begin()._M_node); }
+ const_iterator begin() const { return const_iterator(const_cast<_Node_base*>(_M_impl.begin()._M_node));}
+
+ iterator end() { return iterator(_M_impl.end()._M_node); }
+ const_iterator end() const { return iterator(_M_impl.end()._M_node); }
+
+ size_type size() const { return _M_impl.size(); }
+ size_type max_size() const { return _M_impl.max_size(); }
+ bool empty() const { return _M_impl.empty(); }
+
+ void swap(_Self& __x) { _M_impl.swap(__x._M_impl); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+public:
+ reference front() { return *begin(); }
+ const_reference front() const { return *begin(); }
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+ void push_front(const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+ void push_front(const value_type& __x)
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+ { _M_impl.push_front(cast_traits::to_storage_type_cref(__x)); }
+
+# if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+ void push_front() { _M_impl.push_front();}
+# endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+ void pop_front() { _M_impl.pop_front(); }
+
+ iterator previous(const_iterator __pos)
+ { return iterator(_M_impl.previous(_BaseConstIte(__pos._M_node))._M_node); }
+ const_iterator previous(const_iterator __pos) const
+ { return const_iterator(const_cast<_Node_base*>(_M_impl.previous(_BaseConstIte(__pos._M_node))._M_node)); }
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+ iterator insert_after(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+ iterator insert_after(iterator __pos, const value_type& __x)
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ { return iterator(_M_impl.insert_after(_BaseIte(__pos._M_node),
+ cast_traits::to_storage_type_cref(__x))._M_node); }
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+ iterator insert_after(iterator __pos)
+ { return iterator(_M_impl.insert_after(_BaseIte(__pos._M_node))._M_node);}
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+ void insert_after(iterator __pos, size_type __n, const value_type& __x)
+ { _M_impl.insert_after(_BaseIte(__pos._M_node), __n, cast_traits::to_storage_type_cref(__x)); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+private:
+ template <class _Integer>
+ void _M_insert_after_dispatch(iterator __pos, _Integer __n, _Integer __val,
+ const __true_type&) {
+ _M_impl.insert_after(_BaseIte(__pos._M_node), __n, __val);
+ }
+
+ template <class _InputIterator>
+ void _M_insert_after_dispatch(iterator __pos,
+ _InputIterator __first, _InputIterator __last,
+ const __false_type&) {
+ _M_impl.insert_after(_BaseIte(__pos._M_node),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
+ }
+
+public:
+# endif
+
+ template <class _InputIterator>
+ void insert_after(iterator __pos, _InputIterator __first, _InputIterator __last) {
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+ // Check whether it's an integral type. If so, it's not an iterator.
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_insert_after_dispatch(__pos, __first, __last, _Integral());
+# else
+ _M_impl.insert_after(_BaseIte(__pos._M_node), __first, __last);
+# endif
+ }
+
+#else /* _STLP_MEMBER_TEMPLATES */
+ void insert_after(iterator __pos,
+ const_iterator __first, const_iterator __last)
+ { _M_impl.insert_after(_BaseIte(__pos._M_node),
+ _BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node)); }
+ void insert_after(iterator __pos,
+ const value_type* __first, const value_type* __last) {
+ _M_impl.insert_after(_BaseIte(__pos._M_node),
+ cast_traits::to_storage_type_cptr(__first),
+ cast_traits::to_storage_type_cptr(__last));
+ }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+ iterator insert(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+ iterator insert(iterator __pos, const value_type& __x)
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ { return iterator(_M_impl.insert(_BaseIte(__pos._M_node),
+ cast_traits::to_storage_type_cref(__x))._M_node); }
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+ iterator insert(iterator __pos)
+ { return iterator(_M_impl.insert(_BaseIte(__pos._M_node))._M_node); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+ void insert(iterator __pos, size_type __n, const value_type& __x)
+ { _M_impl.insert(_BaseIte(__pos._M_node), __n, cast_traits::to_storage_type_cref(__x)); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+private:
+ template <class _Integer>
+ void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
+ const __true_type&) {
+ _M_impl.insert(_BaseIte(__pos._M_node), __n, __val);
+ }
+
+ template <class _InputIterator>
+ void _M_insert_dispatch(iterator __pos,
+ _InputIterator __first, _InputIterator __last,
+ const __false_type&) {
+ _M_impl.insert(_BaseIte(__pos._M_node), _STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__first),
+ _STLP_TYPENAME _STLP_PRIV _IteWrapper<_StorageType, _Tp, _InputIterator>::_Ite(__last));
+ }
+
+public:
+# endif
+
+ template <class _InputIterator>
+ void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
+# if defined (_STLP_USE_ITERATOR_WRAPPER)
+ // Check whether it's an integral type. If so, it's not an iterator.
+ typedef typename _IsIntegral<_InputIterator>::_Ret _Integral;
+ _M_insert_dispatch(__pos, __first, __last, _Integral());
+# else
+ _M_impl.insert(_BaseIte(__pos._M_node), __first, __last);
+# endif
+ }
+
+#else /* _STLP_MEMBER_TEMPLATES */
+ void insert(iterator __pos, const_iterator __first, const_iterator __last)
+ { _M_impl.insert(_BaseIte(__pos._M_node), _BaseConstIte(__first._M_node), _BaseConstIte(__last._M_node)); }
+ void insert(iterator __pos, const value_type* __first, const value_type* __last)
+ { _M_impl.insert(_BaseIte(__pos._M_node), cast_traits::to_storage_type_cptr(__first),
+ cast_traits::to_storage_type_cptr(__last)); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ iterator erase_after(iterator __pos)
+ { return iterator(_M_impl.erase_after(_BaseIte(__pos._M_node))._M_node); }
+ iterator erase_after(iterator __before_first, iterator __last)
+ { return iterator(_M_impl.erase_after(_BaseIte(__before_first._M_node),
+ _BaseIte(__last._M_node))._M_node); }
+
+ iterator erase(iterator __pos)
+ { return iterator(_M_impl.erase(_BaseIte(__pos._M_node))._M_node); }
+ iterator erase(iterator __first, iterator __last)
+ { return iterator(_M_impl.erase(_BaseIte(__first._M_node), _BaseIte(__last._M_node))._M_node); }
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+ void resize(size_type __new_size, const value_type& __x)
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ { _M_impl.resize(__new_size, cast_traits::to_storage_type_cref(__x));}
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size) { _M_impl.resize(__new_size); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+ void clear() { _M_impl.clear(); }
+
+ void splice_after(iterator __pos, _Self& __x,
+ iterator __before_first, iterator __before_last)
+ { _M_impl.splice_after(_BaseIte(__pos._M_node), __x._M_impl,
+ _BaseIte(__before_first._M_node), _BaseIte(__before_last._M_node)); }
+ void splice_after(iterator __pos, _Self& __x, iterator __prev)
+ { _M_impl.splice_after(_BaseIte(__pos._M_node), __x._M_impl, _BaseIte(__prev._M_node)); }
+ void splice_after(iterator __pos, _Self& __x)
+ { _M_impl.splice_after(_BaseIte(__pos._M_node), __x._M_impl); }
+ void splice(iterator __pos, _Self& __x)
+ { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl); }
+ void splice(iterator __pos, _Self& __x, iterator __i)
+ { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl, _BaseIte(__i._M_node)); }
+ void splice(iterator __pos, _Self& __x, iterator __first, iterator __last)
+ { _M_impl.splice(_BaseIte(__pos._M_node), __x._M_impl,
+ _BaseIte(__first._M_node), _BaseIte(__last._M_node)); }
+
+ void reverse() { _M_impl.reverse(); }
+
+ void remove(const value_type& __val) { _M_impl.remove(cast_traits::to_storage_type_cref(__val)); }
+ void unique() { _M_impl.unique(); }
+ void merge(_Self& __x) { _M_impl.merge(__x._M_impl); }
+ void sort() {_M_impl.sort(); }
+
+#ifdef _STLP_MEMBER_TEMPLATES
+ template <class _Predicate>
+ void remove_if(_Predicate __pred)
+ { _M_impl.remove_if(_STLP_PRIV _UnaryPredWrapper<_StorageType, _Tp, _Predicate>(__pred)); }
+
+ template <class _BinaryPredicate>
+ void unique(_BinaryPredicate __pred)
+ { _M_impl.unique(_STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _BinaryPredicate>(__pred)); }
+
+ template <class _StrictWeakOrdering>
+ void merge(_Self& __x, _StrictWeakOrdering __comp)
+ { _M_impl.merge(__x._M_impl, _STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _StrictWeakOrdering>(__comp)); }
+
+ template <class _StrictWeakOrdering>
+ void sort(_StrictWeakOrdering __comp)
+ { _M_impl.sort(_STLP_PRIV _BinaryPredWrapper<_StorageType, _Tp, _StrictWeakOrdering>(__comp)); }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+private:
+ _Base _M_impl;
+};
+
+#if defined (slist)
+# undef slist
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#undef SLIST_IMPL
+
+#if defined (__BORLANDC__) || defined (__DMC__)
+# undef typename
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_SPECIALIZED_SLIST_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/stl/pointers/_tools.h b/sources/android/stlport/stlport/stl/pointers/_tools.h
new file mode 100644
index 0000000..ec94806
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/pointers/_tools.h
@@ -0,0 +1,471 @@
+/*
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_POINTERS_SPEC_TOOLS_H
+#define _STLP_POINTERS_SPEC_TOOLS_H
+
+#ifndef _STLP_TYPE_TRAITS_H
+# include <stl/type_traits.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+//Some usefull declarations:
+template <class _Tp> struct less;
+
+_STLP_MOVE_TO_PRIV_NAMESPACE
+
+template <class _StorageT, class _ValueT, class _BinaryPredicate>
+struct _BinaryPredWrapper;
+
+/*
+ * Since the compiler only allows at most one non-trivial
+ * implicit conversion we can make use of a shim class to
+ * be sure that functions below doesn't accept classes with
+ * implicit pointer conversion operators
+ */
+struct _VoidPointerShim
+{ _VoidPointerShim(void*); };
+struct _ConstVoidPointerShim
+{ _ConstVoidPointerShim(const void*); };
+struct _VolatileVoidPointerShim
+{ _VolatileVoidPointerShim(volatile void*); };
+struct _ConstVolatileVoidPointerShim
+{ _ConstVolatileVoidPointerShim(const volatile void*); };
+
+//The dispatch functions:
+template <class _Tp>
+char _UseVoidPtrStorageType(const __false_type& /*POD*/, const _Tp&);
+char _UseVoidPtrStorageType(const __true_type& /*POD*/, ...);
+char* _UseVoidPtrStorageType(const __true_type& /*POD*/, _VoidPointerShim);
+
+template <class _Tp>
+char _UseConstVoidPtrStorageType(const __false_type& /*POD*/, const _Tp&);
+char _UseConstVoidPtrStorageType(const __true_type& /*POD*/, ...);
+char* _UseConstVoidPtrStorageType(const __true_type& /*POD*/, _ConstVoidPointerShim);
+
+template <class _Tp>
+char _UseVolatileVoidPtrStorageType(const __false_type& /*POD*/, const _Tp&);
+char _UseVolatileVoidPtrStorageType(const __true_type& /*POD*/, ...);
+char* _UseVolatileVoidPtrStorageType(const __true_type& /*POD*/, _VolatileVoidPointerShim);
+
+template <class _Tp>
+char _UseConstVolatileVoidPtrStorageType(const __false_type& /*POD*/, const _Tp&);
+char _UseConstVolatileVoidPtrStorageType(const __true_type& /*POD*/, ...);
+char* _UseConstVolatileVoidPtrStorageType(const __true_type& /*POD*/, _ConstVolatileVoidPointerShim);
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+/* Thanks to class partial specialization the pointer specialization feature can even be used in
+ * presence of incomplete type:
+ * struct MyStruct {
+ * typedef vector<MyStruct> MyStructContainer;
+ * typedef MyStructContainer::iterator MyStructIterator;
+ * };
+ */
+
+template <class _Tp>
+struct _StorageType {
+ typedef _Tp _QualifiedType;
+ typedef _Tp _Type;
+ enum { use_const_volatile_void_ptr = 0 };
+};
+
+template <class _Tp>
+struct _StorageType<_Tp*> {
+ // Even if we detect a pointer type we use dispatch function to consider if it can be stored as a void*.
+ // For instance function pointer might not necessarily be convertible to void*.
+ enum { use_void_ptr = (sizeof(_UseVoidPtrStorageType(__true_type(),
+ __STATIC_CAST(_Tp*, 0))) == sizeof(char*)) };
+ enum { use_const_volatile_void_ptr = use_void_ptr };
+ typedef typename __select<use_void_ptr,
+ void*,
+ _Tp*>::_Ret _QualifiedType;
+ typedef _QualifiedType _Type;
+};
+
+template <class _Tp>
+struct _StorageType<_Tp const*> {
+ enum { use_void_ptr = (sizeof(_UseConstVoidPtrStorageType(__true_type(),
+ __STATIC_CAST(const _Tp*, 0))) == sizeof(char*)) };
+ enum { use_const_volatile_void_ptr = use_void_ptr };
+ typedef typename __select<use_void_ptr,
+ const void*,
+ const _Tp*>::_Ret _QualifiedType;
+ typedef typename __select<use_void_ptr,
+ void*,
+ const _Tp*>::_Ret _Type;
+};
+
+template <class _Tp>
+struct _StorageType<_Tp volatile*> {
+ enum { use_void_ptr = (sizeof(_UseVolatileVoidPtrStorageType(__true_type(),
+ __STATIC_CAST(_Tp volatile*, 0))) == sizeof(char*)) };
+ enum { use_const_volatile_void_ptr = use_void_ptr };
+ typedef typename __select<use_void_ptr,
+ volatile void*,
+ volatile _Tp*>::_Ret _QualifiedType;
+ typedef typename __select<use_void_ptr,
+ void*,
+ volatile _Tp*>::_Ret _Type;
+};
+
+template <class _Tp>
+struct _StorageType<_Tp const volatile*> {
+ enum { use_void_ptr = (sizeof(_UseConstVolatileVoidPtrStorageType(__true_type(),
+ __STATIC_CAST(_Tp const volatile*, 0))) == sizeof(char*)) };
+ enum { use_const_volatile_void_ptr = use_void_ptr };
+ typedef typename __select<use_void_ptr,
+ const volatile void*,
+ const volatile _Tp*>::_Ret _QualifiedType;
+ typedef typename __select<use_void_ptr,
+ void*,
+ const volatile _Tp*>::_Ret _Type;
+};
+#else
+template <class _Tp>
+struct _StorageType {
+ typedef typename __type_traits<_Tp>::is_POD_type _PODType;
+
+#if !defined (__BORLANDC__) || (__BORLANDC__ != 0x560)
+ static _Tp __null_rep();
+#else
+ static _Tp __null_rep;
+#endif
+ enum { use_void_ptr = (sizeof(_UseVoidPtrStorageType(_PODType(), __null_rep())) == sizeof(char*)) };
+ enum { use_const_void_ptr = (sizeof(_UseConstVoidPtrStorageType(_PODType(), __null_rep())) == sizeof(char*)) };
+ enum { use_volatile_void_ptr = (sizeof(_UseVolatileVoidPtrStorageType(_PODType(), __null_rep())) == sizeof(char*)) };
+ enum { use_const_volatile_void_ptr = (sizeof(_UseConstVolatileVoidPtrStorageType(_PODType(), __null_rep())) == sizeof(char*)) };
+
+ typedef typename __select<!use_const_volatile_void_ptr,
+ _Tp,
+ typename __select<use_void_ptr,
+ void*,
+ typename __select<use_const_void_ptr,
+ const void*,
+ typename __select<use_volatile_void_ptr,
+ volatile void*,
+ const volatile void*>::_Ret >::_Ret >::_Ret >::_Ret _QualifiedType;
+
+#if !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ /* If the compiler do not support the iterator_traits structure we cannot wrap
+ * iterators pass to container template methods. The iterator dereferenced value
+ * has to be storable without any cast in the chosen storage type. To guaranty
+ * that the void pointer has to be correctly qualified.
+ */
+ typedef _QualifiedType _Type;
+#else
+ /* With iterator_traits we can wrap passed iterators and make the necessary casts.
+ * We can always use a simple void* storage type:
+ */
+ typedef typename __select<use_const_volatile_void_ptr,
+ void*,
+ _Tp>::_Ret _Type;
+#endif
+};
+#endif
+
+template <class _Tp, class _Compare>
+struct _AssocStorageTypes {
+ typedef _StorageType<_Tp> _StorageTypeInfo;
+ typedef typename _StorageTypeInfo::_Type _SType;
+
+ //We need to also check that the comparison functor used to instanciate the assoc container
+ //is the default Standard less implementation:
+ enum { ptr_type = _StorageTypeInfo::use_const_volatile_void_ptr };
+ typedef typename _IsSTLportClass<_Compare>::_Ret _STLportLess;
+ enum { is_default_less = __type2bool<_STLportLess>::_Ret };
+ typedef typename __select<is_default_less, _SType, _Tp>::_Ret _KeyStorageType;
+ typedef typename __select<is_default_less && ptr_type,
+ _BinaryPredWrapper<_KeyStorageType, _Tp, _Compare>,
+ _Compare>::_Ret _CompareStorageType;
+};
+
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+/*
+ * Base struct to deal with qualifiers
+ */
+template <class _StorageT, class _QualifiedStorageT>
+struct _VoidCastTraitsAux {
+ typedef _QualifiedStorageT void_cv_type;
+ typedef _StorageT void_type;
+
+ static void_type * uncv_ptr(void_cv_type *__ptr)
+ { return __ptr; }
+ static void_type const* uncv_cptr(void_cv_type const*__ptr)
+ { return __ptr; }
+ static void_type ** uncv_pptr(void_cv_type **__ptr)
+ { return __ptr; }
+ static void_type & uncv_ref(void_cv_type & __ref)
+ { return __ref; }
+ static void_type const& uncv_cref(void_cv_type const& __ref)
+ { return __ref; }
+ static void_cv_type* cv_ptr(void_type *__ptr)
+ { return __ptr; }
+ static void_cv_type const* cv_cptr(void_type const*__ptr)
+ { return __ptr; }
+ static void_cv_type ** cv_pptr(void_type **__ptr)
+ { return __ptr; }
+ static void_cv_type & cv_ref(void_type & __ref)
+ { return __ref; }
+ static void_cv_type const& cv_cref(void_type const& __ref)
+ { return __ref; }
+};
+
+template <class _VoidCVType>
+struct _VoidCastTraitsAuxBase {
+ typedef _VoidCVType* void_cv_type;
+ typedef void* void_type;
+
+ static void_type* uncv_ptr(void_cv_type *__ptr)
+ { return __CONST_CAST(void_type*, __ptr); }
+ static void_type const* uncv_cptr(void_cv_type const*__ptr)
+ { return __CONST_CAST(void_type const*, __ptr); }
+ static void_type** uncv_pptr(void_cv_type **__ptr)
+ { return __CONST_CAST(void_type**, __ptr); }
+ static void_type& uncv_ref(void_cv_type &__ref)
+ { return __CONST_CAST(void_type&, __ref); }
+ static void_type const& uncv_cref(void_cv_type const& __ptr)
+ { return __CONST_CAST(void_type const&, __ptr); }
+ // The reverse versions
+ static void_cv_type * cv_ptr(void_type *__ptr)
+ { return __CONST_CAST(void_cv_type *, __ptr); }
+ static void_cv_type const* cv_cptr(void_type const*__ptr)
+ { return __CONST_CAST(void_cv_type const*, __ptr); }
+ static void_cv_type ** cv_pptr(void_type **__ptr)
+ { return __CONST_CAST(void_cv_type**, __ptr); }
+ static void_cv_type & cv_ref(void_type &__ref)
+ { return __CONST_CAST(void_cv_type &, __ref); }
+ static void_cv_type const& cv_cref(void_type const& __ref)
+ { return __CONST_CAST(void_cv_type const&, __ref); }
+};
+
+_STLP_TEMPLATE_NULL
+struct _VoidCastTraitsAux<void*, const void*> : _VoidCastTraitsAuxBase<void const>
+{};
+_STLP_TEMPLATE_NULL
+struct _VoidCastTraitsAux<void*, volatile void*> : _VoidCastTraitsAuxBase<void volatile>
+{};
+_STLP_TEMPLATE_NULL
+struct _VoidCastTraitsAux<void*, const volatile void*> : _VoidCastTraitsAuxBase<void const volatile>
+{};
+
+template <class _StorageT, class _ValueT>
+struct _CastTraits {
+ typedef _ValueT value_type;
+ typedef typename _StorageType<_ValueT>::_QualifiedType _QualifiedStorageT;
+ typedef _VoidCastTraitsAux<_StorageT, _QualifiedStorageT> cv_traits;
+ typedef typename cv_traits::void_type void_type;
+ typedef typename cv_traits::void_cv_type void_cv_type;
+
+ static value_type * to_value_type_ptr(void_type *__ptr)
+ { return __REINTERPRET_CAST(value_type *, cv_traits::cv_ptr(__ptr)); }
+ static value_type const* to_value_type_cptr(void_type const*__ptr)
+ { return __REINTERPRET_CAST(value_type const*, cv_traits::cv_cptr(__ptr)); }
+ static value_type ** to_value_type_pptr(void_type **__ptr)
+ { return __REINTERPRET_CAST(value_type **, cv_traits::cv_pptr(__ptr)); }
+ static value_type & to_value_type_ref(void_type &__ref)
+ { return __REINTERPRET_CAST(value_type &, cv_traits::cv_ref(__ref)); }
+ static value_type const& to_value_type_cref(void_type const& __ptr)
+ { return __REINTERPRET_CAST(value_type const&, cv_traits::cv_cref(__ptr)); }
+ // Reverse versions
+ static void_type * to_storage_type_ptr(value_type *__ptr)
+ { return cv_traits::uncv_ptr(__REINTERPRET_CAST(void_cv_type *, __ptr)); }
+ static void_type const* to_storage_type_cptr(value_type const*__ptr)
+ { return cv_traits::uncv_cptr(__REINTERPRET_CAST(void_cv_type const*, __ptr)); }
+ static void_type ** to_storage_type_pptr(value_type **__ptr)
+ { return cv_traits::uncv_pptr(__REINTERPRET_CAST(void_cv_type **, __ptr)); }
+ static void_type const& to_storage_type_cref(value_type const& __ref)
+ { return cv_traits::uncv_cref(__REINTERPRET_CAST(void_cv_type const&, __ref)); }
+
+ //Method used to treat set container template method extension
+ static void_type const& to_storage_type_crefT(value_type const& __ref)
+ { return to_storage_type_cref(__ref); }
+};
+
+template <class _Tp>
+struct _CastTraits<_Tp, _Tp> {
+ typedef _Tp storage_type;
+ typedef _Tp value_type;
+
+ static value_type * to_value_type_ptr(storage_type *__ptr)
+ { return __ptr; }
+ static value_type const* to_value_type_cptr(storage_type const*__ptr)
+ { return __ptr; }
+ static value_type ** to_value_type_pptr(storage_type **__ptr)
+ { return __ptr; }
+ static value_type & to_value_type_ref(storage_type &__ref)
+ { return __ref; }
+ static value_type const& to_value_type_cref(storage_type const&__ref)
+ { return __ref; }
+ // Reverse versions
+ static storage_type * to_storage_type_ptr(value_type *__ptr)
+ { return __ptr; }
+ static storage_type const* to_storage_type_cptr(value_type const*__ptr)
+ { return __ptr; }
+ static storage_type ** to_storage_type_pptr(value_type **__ptr)
+ { return __ptr; }
+ static storage_type const& to_storage_type_cref(value_type const& __ref)
+ { return __ref; }
+
+ //Method used to treat set container template method extension
+ template <class _Tp1>
+ static _Tp1 const& to_storage_type_crefT(_Tp1 const& __ref)
+ { return __ref; }
+};
+
+#define _STLP_USE_ITERATOR_WRAPPER
+
+template <class _StorageT, class _ValueT, class _Iterator>
+struct _IteWrapper {
+ typedef _CastTraits<_StorageT, _ValueT> cast_traits;
+ typedef iterator_traits<_Iterator> _IteTraits;
+
+ typedef typename _IteTraits::iterator_category iterator_category;
+ typedef _StorageT value_type;
+ typedef typename _IteTraits::difference_type difference_type;
+ typedef value_type* pointer;
+ typedef value_type const& const_reference;
+ //This wrapper won't be used for input so to avoid surprise
+ //the reference type will be a const reference:
+ typedef const_reference reference;
+
+ typedef _IteWrapper<_StorageT, _ValueT, _Iterator> _Self;
+ typedef _Self _Ite;
+
+ _IteWrapper(_Iterator &__ite) : _M_ite(__ite) {}
+
+ const_reference operator*() const { return cast_traits::to_storage_type_cref(*_M_ite); }
+
+ _Self& operator= (_Self const& __rhs) {
+ _M_ite = __rhs._M_ite;
+ return *this;
+ }
+
+ _Self& operator++() {
+ ++_M_ite;
+ return *this;
+ }
+
+ _Self& operator--() {
+ --_M_ite;
+ return *this;
+ }
+
+ _Self& operator += (difference_type __offset) {
+ _M_ite += __offset;
+ return *this;
+ }
+ difference_type operator -(_Self const& __other) const
+ { return _M_ite - __other._M_ite; }
+
+ bool operator == (_Self const& __other) const
+ { return _M_ite == __other._M_ite; }
+
+ bool operator != (_Self const& __other) const
+ { return _M_ite != __other._M_ite; }
+
+ bool operator < (_Self const& __rhs) const
+ { return _M_ite < __rhs._M_ite; }
+
+private:
+ _Iterator _M_ite;
+};
+
+template <class _Tp, class _Iterator>
+struct _IteWrapper<_Tp, _Tp, _Iterator>
+{ typedef _Iterator _Ite; };
+
+#else
+
+/*
+ * In this config the storage type is qualified in respect of the
+ * value_type qualification. Simple reinterpret_cast is enough.
+ */
+template <class _StorageT, class _ValueT>
+struct _CastTraits {
+ typedef _StorageT storage_type;
+ typedef _ValueT value_type;
+
+ static value_type * to_value_type_ptr(storage_type *__ptr)
+ { return __REINTERPRET_CAST(value_type*, __ptr); }
+ static value_type const* to_value_type_cptr(storage_type const*__ptr)
+ { return __REINTERPRET_CAST(value_type const*, __ptr); }
+ static value_type ** to_value_type_pptr(storage_type **__ptr)
+ { return __REINTERPRET_CAST(value_type **, __ptr); }
+ static value_type & to_value_type_ref(storage_type &__ref)
+ { return __REINTERPRET_CAST(value_type&, __ref); }
+ static value_type const& to_value_type_cref(storage_type const&__ref)
+ { return __REINTERPRET_CAST(value_type const&, __ref); }
+ // Reverse versions
+ static storage_type * to_storage_type_ptr(value_type *__ptr)
+ { return __REINTERPRET_CAST(storage_type*, __ptr); }
+ static storage_type const* to_storage_type_cptr(value_type const*__ptr)
+ { return __REINTERPRET_CAST(storage_type const*, __ptr); }
+ static storage_type ** to_storage_type_pptr(value_type **__ptr)
+ { return __REINTERPRET_CAST(storage_type **, __ptr); }
+ static storage_type const& to_storage_type_cref(value_type const&__ref)
+ { return __REINTERPRET_CAST(storage_type const&, __ref); }
+ template <class _Tp1>
+ static _Tp1 const& to_storage_type_crefT(_Tp1 const& __ref)
+ { return __ref; }
+};
+
+#endif
+
+//Wrapper functors:
+template <class _StorageT, class _ValueT, class _UnaryPredicate>
+struct _UnaryPredWrapper {
+ typedef _CastTraits<_StorageT, _ValueT> cast_traits;
+
+ _UnaryPredWrapper (_UnaryPredicate const& __pred) : _M_pred(__pred) {}
+
+ bool operator () (_StorageT const& __ref) const
+ { return _M_pred(cast_traits::to_value_type_cref(__ref)); }
+
+private:
+ _UnaryPredicate _M_pred;
+};
+
+template <class _StorageT, class _ValueT, class _BinaryPredicate>
+struct _BinaryPredWrapper {
+ typedef _CastTraits<_StorageT, _ValueT> cast_traits;
+
+ _BinaryPredWrapper () {}
+ _BinaryPredWrapper (_BinaryPredicate const& __pred) : _M_pred(__pred) {}
+
+ _BinaryPredicate get_pred() const { return _M_pred; }
+
+ bool operator () (_StorageT const& __fst, _StorageT const& __snd) const
+ { return _M_pred(cast_traits::to_value_type_cref(__fst), cast_traits::to_value_type_cref(__snd)); }
+
+ //Cast operator used to transparently access underlying predicate
+ //in set::key_comp() method
+ operator _BinaryPredicate() const
+ { return _M_pred; }
+
+private:
+ _BinaryPredicate _M_pred;
+};
+
+_STLP_MOVE_TO_STD_NAMESPACE
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_POINTERS_SPEC_TOOLS_H */
diff --git a/sources/android/stlport/stlport/stl/pointers/_vector.h b/sources/android/stlport/stlport/stl/pointers/_vector.h
new file mode 100644
index 0000000..64705bf
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/pointers/_vector.h
@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* NOTE: This is an internal header file, included by other STL headers.
+ * You should not attempt to use it directly.
+ */
+
+#ifndef _STLP_SPECIALIZED_VECTOR_H
+#define _STLP_SPECIALIZED_VECTOR_H
+
+#ifndef _STLP_POINTERS_SPEC_TOOLS_H
+# include <stl/pointers/_tools.h>
+#endif
+
+_STLP_BEGIN_NAMESPACE
+
+#define VECTOR_IMPL _STLP_PTR_IMPL_NAME(vector)
+
+#if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_USE_MSVC6_MEM_T_BUG_WORKAROUND)
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_PRIV _Vector_base<void*,allocator<void*> >;
+_STLP_EXPORT_TEMPLATE_CLASS _STLP_PRIV VECTOR_IMPL<void*, allocator<void*> >;
+#endif
+
+#if defined (_STLP_DEBUG)
+# define vector _STLP_NON_DBG_NAME(vector)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+#endif
+
+template <class _Tp, _STLP_DFL_TMPL_PARAM(_Alloc, allocator<_Tp>) >
+class vector
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (vector)
+ : public __stlport_class<vector<_Tp, _Alloc> >
+#endif
+{
+ /* In the vector implementation iterators are pointer which give a number
+ * of opportunities for optimization. To not break those optimizations
+ * iterators passed to template should not be wrapped for casting purpose.
+ * So vector implementation will always use a qualified void pointer type and
+ * won't use iterator wrapping.
+ */
+ typedef _STLP_TYPENAME _STLP_PRIV _StorageType<_Tp>::_QualifiedType _StorageType;
+ typedef typename _Alloc_traits<_StorageType, _Alloc>::allocator_type _StorageTypeAlloc;
+ typedef _STLP_PRIV VECTOR_IMPL<_StorageType, _StorageTypeAlloc> _Base;
+ typedef vector<_Tp, _Alloc> _Self;
+
+ typedef _STLP_PRIV _CastTraits<_StorageType, _Tp> cast_traits;
+
+public:
+ typedef _Tp value_type;
+ typedef value_type* pointer;
+ typedef const value_type* const_pointer;
+ typedef value_type* iterator;
+ typedef const value_type* const_iterator;
+ typedef value_type& reference;
+ typedef const value_type& const_reference;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef random_access_iterator_tag _Iterator_category;
+
+ _STLP_DECLARE_RANDOM_ACCESS_REVERSE_ITERATORS;
+ _STLP_FORCE_ALLOCATORS(value_type, _Alloc)
+ typedef typename _Alloc_traits<value_type, _Alloc>::allocator_type allocator_type;
+
+ allocator_type get_allocator() const
+ { return _STLP_CONVERT_ALLOCATOR(_M_impl.get_allocator(), value_type); }
+
+ iterator begin() { return cast_traits::to_value_type_ptr(_M_impl.begin()); }
+ const_iterator begin() const { return cast_traits::to_value_type_cptr(_M_impl.begin()); }
+ iterator end() { return cast_traits::to_value_type_ptr(_M_impl.end()); }
+ const_iterator end() const { return cast_traits::to_value_type_cptr(_M_impl.end()); }
+
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+ const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+ const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+
+ size_type size() const { return _M_impl.size(); }
+ size_type max_size() const { return _M_impl.max_size(); }
+
+ size_type capacity() const { return _M_impl.capacity(); }
+ bool empty() const { return _M_impl.empty(); }
+
+ reference operator[](size_type __n) { return cast_traits::to_value_type_ref(_M_impl[__n]); }
+ const_reference operator[](size_type __n) const { return cast_traits::to_value_type_cref(_M_impl[__n]); }
+
+ reference front() { return cast_traits::to_value_type_ref(_M_impl.front()); }
+ const_reference front() const { return cast_traits::to_value_type_cref(_M_impl.front()); }
+ reference back() { return cast_traits::to_value_type_ref(_M_impl.back()); }
+ const_reference back() const { return cast_traits::to_value_type_cref(_M_impl.back()); }
+
+ reference at(size_type __n) { return cast_traits::to_value_type_ref(_M_impl.at(__n)); }
+ const_reference at(size_type __n) const { return cast_traits::to_value_type_cref(_M_impl.at(__n)); }
+
+ explicit vector(const allocator_type& __a = allocator_type())
+ : _M_impl(_STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+ explicit vector(size_type __n, const value_type& __val = _STLP_DEFAULT_CONSTRUCTED(value_type),
+#else
+ vector(size_type __n, const value_type& __val,
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ const allocator_type& __a = allocator_type())
+ : _M_impl(__n, cast_traits::to_storage_type_cref(__val),
+ _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+ explicit vector(size_type __n)
+ : _M_impl(__n, allocator_type() ) {}
+#endif
+
+ vector(const _Self& __x)
+ : _M_impl(__x._M_impl) {}
+
+#if !defined (_STLP_NO_MOVE_SEMANTIC)
+ explicit vector(__move_source<_Self> src)
+ : _M_impl(__move_source<_Base>(src.get()._M_impl)) {}
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ vector(_InputIterator __first, _InputIterator __last,
+ const allocator_type& __a _STLP_ALLOCATOR_TYPE_DFL )
+ : _M_impl(__first, __last,
+ _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+
+# if defined (_STLP_NEEDS_EXTRA_TEMPLATE_CONSTRUCTORS)
+ template <class _InputIterator>
+ vector(_InputIterator __first, _InputIterator __last)
+ : _M_impl(__first, __last) {}
+# endif
+
+#else
+ vector(const_iterator __first, const_iterator __last,
+ const allocator_type& __a = allocator_type())
+ : _M_impl(cast_traits::to_storage_type_cptr(__first), cast_traits::to_storage_type_cptr(__last),
+ _STLP_CONVERT_ALLOCATOR(__a, _StorageType)) {}
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+ _Self& operator=(const _Self& __x) { _M_impl = __x._M_impl; return *this; }
+
+ void reserve(size_type __n) {_M_impl.reserve(__n);}
+ void assign(size_type __n, const value_type& __val)
+ { _M_impl.assign(__n, cast_traits::to_storage_type_cref(__val)); }
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void assign(_InputIterator __first, _InputIterator __last)
+ { _M_impl.assign(__first, __last); }
+#else
+ void assign(const_iterator __first, const_iterator __last) {
+ _M_impl.assign(cast_traits::to_storage_type_cptr(__first),
+ cast_traits::to_storage_type_cptr(__last));
+ }
+#endif /* _STLP_MEMBER_TEMPLATES */
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+ void push_back(const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+ void push_back(const value_type& __x)
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+ { _M_impl.push_back(cast_traits::to_storage_type_cref(__x)); }
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+ iterator insert(iterator __pos, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+ iterator insert(iterator __pos, const value_type& __x)
+#endif /*!_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+ { return cast_traits::to_value_type_ptr(_M_impl.insert(cast_traits::to_storage_type_ptr(__pos),
+ cast_traits::to_storage_type_cref(__x))); }
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM) && !defined(_STLP_NO_ANACHRONISMS)
+ void push_back() { _M_impl.push_back(); }
+ iterator insert(iterator __pos)
+ { return _M_impl.insert(cast_traits::to_storage_type_ptr(__pos)); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM && !_STLP_NO_ANACHRONISMS*/
+
+ void swap(_Self& __x) { _M_impl.swap(__x._M_impl); }
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(_Self& __x) { swap(__x); }
+#endif
+
+#if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _InputIterator>
+ void insert(iterator __pos, _InputIterator __first, _InputIterator __last)
+ { _M_impl.insert(cast_traits::to_storage_type_ptr(__pos), __first, __last); }
+#else
+ void insert(iterator __pos, const_iterator __first, const_iterator __last) {
+ _M_impl.insert(cast_traits::to_storage_type_ptr(__pos), cast_traits::to_storage_type_cptr(__first),
+ cast_traits::to_storage_type_cptr(__last));
+ }
+#endif
+
+ void insert (iterator __pos, size_type __n, const value_type& __x) {
+ _M_impl.insert(cast_traits::to_storage_type_ptr(__pos), __n, cast_traits::to_storage_type_cref(__x));
+ }
+
+ void pop_back() {_M_impl.pop_back();}
+ iterator erase(iterator __pos)
+ {return cast_traits::to_value_type_ptr(_M_impl.erase(cast_traits::to_storage_type_ptr(__pos)));}
+ iterator erase(iterator __first, iterator __last) {
+ return cast_traits::to_value_type_ptr(_M_impl.erase(cast_traits::to_storage_type_ptr(__first),
+ cast_traits::to_storage_type_ptr(__last)));
+ }
+
+#if !defined(_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size, const value_type& __x = _STLP_DEFAULT_CONSTRUCTED(value_type))
+#else
+ void resize(size_type __new_size, const value_type& __x)
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+ { _M_impl.resize(__new_size, cast_traits::to_storage_type_cref(__x)); }
+
+#if defined(_STLP_DONT_SUP_DFLT_PARAM)
+ void resize(size_type __new_size) { _M_impl.resize(__new_size); }
+#endif /*_STLP_DONT_SUP_DFLT_PARAM*/
+
+ void clear() { _M_impl.clear(); }
+
+private:
+ _Base _M_impl;
+};
+
+#if defined (vector)
+# undef vector
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+#undef VECTOR_IMPL
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_SPECIALIZED_VECTOR_H */
diff --git a/sources/android/stlport/stlport/stl/type_manips.h b/sources/android/stlport/stlport/stl/type_manips.h
new file mode 100644
index 0000000..410b59d
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/type_manips.h
@@ -0,0 +1,321 @@
+/*
+ *
+ * Copyright (c) 2003
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+
+#ifndef _STLP_TYPE_MANIPS_H
+#define _STLP_TYPE_MANIPS_H
+
+_STLP_BEGIN_NAMESPACE
+
+struct __true_type {};
+struct __false_type {};
+
+#if defined (_STLP_USE_NAMESPACES) && !defined (_STLP_DONT_USE_PRIV_NAMESPACE)
+_STLP_MOVE_TO_PRIV_NAMESPACE
+using _STLP_STD::__true_type;
+using _STLP_STD::__false_type;
+_STLP_MOVE_TO_STD_NAMESPACE
+#endif
+
+//bool to type
+template <int _Is>
+struct __bool2type
+{ typedef __true_type _Ret; };
+
+_STLP_TEMPLATE_NULL
+struct __bool2type<1> { typedef __true_type _Ret; };
+
+_STLP_TEMPLATE_NULL
+struct __bool2type<0> { typedef __false_type _Ret; };
+
+//type to bool
+template <class __bool_type>
+struct __type2bool { enum {_Ret = 1}; };
+
+_STLP_TEMPLATE_NULL
+struct __type2bool<__true_type> { enum {_Ret = 1}; };
+
+_STLP_TEMPLATE_NULL
+struct __type2bool<__false_type> { enum {_Ret = 0}; };
+
+//Negation
+template <class _BoolType>
+struct _Not { typedef __false_type _Ret; };
+
+_STLP_TEMPLATE_NULL
+struct _Not<__false_type> { typedef __true_type _Ret; };
+
+// logical and of 2 predicated
+template <class _P1, class _P2>
+struct _Land2 { typedef __false_type _Ret; };
+
+_STLP_TEMPLATE_NULL
+struct _Land2<__true_type, __true_type> { typedef __true_type _Ret; };
+
+// logical and of 3 predicated
+template <class _P1, class _P2, class _P3>
+struct _Land3 { typedef __false_type _Ret; };
+
+_STLP_TEMPLATE_NULL
+struct _Land3<__true_type, __true_type, __true_type> { typedef __true_type _Ret; };
+
+//logical or of 2 predicated
+template <class _P1, class _P2>
+struct _Lor2 { typedef __true_type _Ret; };
+
+_STLP_TEMPLATE_NULL
+struct _Lor2<__false_type, __false_type> { typedef __false_type _Ret; };
+
+// logical or of 3 predicated
+template <class _P1, class _P2, class _P3>
+struct _Lor3 { typedef __true_type _Ret; };
+
+_STLP_TEMPLATE_NULL
+struct _Lor3<__false_type, __false_type, __false_type> { typedef __false_type _Ret; };
+
+////////////////////////////////////////////////////////////////////////////////
+// class template __select
+// Selects one of two types based upon a boolean constant
+// Invocation: __select<_Cond, T, U>::Result
+// where:
+// flag is a compile-time boolean constant
+// T and U are types
+// Result evaluates to T if flag is true, and to U otherwise.
+////////////////////////////////////////////////////////////////////////////////
+// BEWARE: If the compiler do not support partial template specialization or nested template
+//classes the default behavior of the __select is to consider the condition as false and so return
+//the second template type!!
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+# if defined (__BORLANDC__)
+template <class _CondT, class _Tp1, class _Tp2>
+struct __selectT { typedef _Tp1 _Ret; };
+
+template <class _Tp1, class _Tp2>
+struct __selectT<__false_type, _Tp1, _Tp2> { typedef _Tp2 _Ret; };
+# endif
+
+# if !defined (__BORLANDC__) || (__BORLANDC__ >= 0x590)
+template <bool _Cond, class _Tp1, class _Tp2>
+struct __select { typedef _Tp1 _Ret; };
+
+template <class _Tp1, class _Tp2>
+struct __select<false, _Tp1, _Tp2> { typedef _Tp2 _Ret; };
+# else
+template <bool _Cond, class _Tp1, class _Tp2>
+struct __select
+{ typedef __selectT<typename __bool2type<_Cond>::_Ret, _Tp1, _Tp2>::_Ret _Ret; };
+# endif
+
+#else
+
+# if defined (_STLP_MEMBER_TEMPLATE_CLASSES)
+template <int _Cond>
+struct __select_aux {
+ template <class _Tp1, class _Tp2>
+ struct _In {
+ typedef _Tp1 _Ret;
+ };
+};
+
+_STLP_TEMPLATE_NULL
+struct __select_aux<0> {
+ template <class _Tp1, class _Tp2>
+ struct _In {
+ typedef _Tp2 _Ret;
+ };
+};
+
+template <int _Cond, class _Tp1, class _Tp2>
+struct __select {
+ typedef typename __select_aux<_Cond>::_STLP_TEMPLATE _In<_Tp1, _Tp2>::_Ret _Ret;
+};
+# else /* _STLP_MEMBER_TEMPLATE_CLASSES */
+//default behavior
+template <int _Cond, class _Tp1, class _Tp2>
+struct __select {
+ typedef _Tp2 _Ret;
+};
+# endif /* _STLP_MEMBER_TEMPLATE_CLASSES */
+
+#endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+/* Rather than introducing a new macro for the following constrution we use
+ * an existing one (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS) that
+ * is used for a similar feature.
+ */
+#if !defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS) && \
+ (!defined (__GNUC__) || (__GNUC__ > 2))
+// Helper struct that will forbid volatile qualified types:
+# if !defined (__BORLANDC__)
+struct _NoVolatilePointerShim { _NoVolatilePointerShim(const void*); };
+template <class _Tp>
+char _STLP_CALL _IsCopyableFun(bool, _NoVolatilePointerShim, _Tp const*, _Tp*); // no implementation is required
+char* _STLP_CALL _IsCopyableFun(bool, ...); // no implementation is required
+
+template <class _Src, class _Dst>
+struct _Copyable {
+ static _Src* __null_src();
+ static _Dst* __null_dst();
+ enum { _Ret = (sizeof(_IsCopyableFun(false, __null_src(), __null_src(), __null_dst())) == sizeof(char)) };
+ typedef typename __bool2type<_Ret>::_Ret _RetT;
+};
+# else
+template <class _Tp1, class _Tp2> struct _AreSameTypes;
+template <class _Tp> struct _IsUnQual;
+template <class _Src, class _Dst>
+struct _Copyable {
+ typedef typename _AreSameTypes<_Src, _Dst>::_Ret _Tr1;
+ typedef typename _IsUnQual<_Dst>::_Ret _Tr2;
+ typedef typename _Land2<_Tr1, _Tr2>::_Ret _RetT;
+ enum { _Ret = __type2bool<_RetT>::_Ret };
+};
+# endif
+#else
+template <class _Src, class _Dst>
+struct _Copyable {
+ enum { _Ret = 0 };
+ typedef __false_type _RetT;
+};
+#endif
+
+/*
+ * The following struct will tell you if 2 types are the same and if copying memory
+ * from the _Src type to the _Dst type is right considering qualifiers. If _Src and
+ * _Dst types are the same unqualified types _Ret will be false if:
+ * - any of the type has the volatile qualifier
+ * - _Dst is const qualified
+ */
+template <class _Src, class _Dst>
+struct _AreCopyable {
+ enum { _Same = _Copyable<_Src, _Dst>::_Ret };
+ typedef typename _Copyable<_Src, _Dst>::_RetT _Ret;
+};
+
+template <class _Tp1, class _Tp2>
+struct _AreSameTypes {
+ enum { _Same = 0 };
+ typedef __false_type _Ret;
+};
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+template <class _Tp>
+struct _AreSameTypes<_Tp, _Tp> {
+ enum { _Same = 1 };
+ typedef __true_type _Ret;
+};
+#endif
+
+#if !defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS)
+template <class _Src, class _Dst>
+struct _ConversionHelper {
+ static char _Test(bool, _Dst);
+ static char* _Test(bool, ...);
+ static _Src _MakeSource();
+};
+
+template <class _Src, class _Dst>
+struct _IsConvertible {
+ typedef _ConversionHelper<_Src*, const volatile _Dst*> _H;
+ enum { value = (sizeof(char) == sizeof(_H::_Test(false, _H::_MakeSource()))) };
+ typedef typename __bool2type<value>::_Ret _Ret;
+};
+
+# if defined (__BORLANDC__)
+# if (__BORLANDC__ < 0x590)
+template<class _Tp>
+struct _UnConstPtr { typedef _Tp _Type; };
+
+template<class _Tp>
+struct _UnConstPtr<_Tp*> { typedef _Tp _Type; };
+
+template<class _Tp>
+struct _UnConstPtr<const _Tp*> { typedef _Tp _Type; };
+# endif
+
+# if !defined (_STLP_QUALIFIED_SPECIALIZATION_BUG)
+template <class _Tp>
+struct _IsConst { typedef __false_type _Ret; };
+# else
+template <class _Tp>
+struct _IsConst { typedef _AreSameTypes<_Tp, const _Tp>::_Ret _Ret; };
+# endif
+
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_QUALIFIED_SPECIALIZATION_BUG)
+template <class _Tp>
+struct _IsConst <const _Tp> { typedef __true_type _Ret; };
+# endif
+
+# if (__BORLANDC__ < 0x590)
+template<class _Tp>
+struct _IsConst<_Tp*> { typedef _AreSameTypes<_Tp*, const _Tp*>::_Ret _Ret; };
+# endif
+template <class _Tp>
+struct _IsVolatile { typedef _AreSameTypes<_Tp, volatile _Tp>::_Ret _Ret; };
+
+template<class _Tp>
+struct _IsUnQual {
+ typedef _IsConst<_Tp>::_Ret _Tr1;
+ typedef _IsVolatile<_Tp>::_Ret _Tr2;
+ typedef _Not<_Tr1>::_Ret _NotCon;
+ typedef _Not<_Tr2>::_Ret _NotVol;
+ typedef _Land2<_NotCon, _NotVol>::_Ret _Ret;
+};
+
+# if !defined (_STLP_QUALIFIED_SPECIALIZATION_BUG)
+template <class _Tp> struct _UnQual { typedef _Tp _Type; };
+template <class _Tp> struct _UnQual<const _Tp> { typedef _Tp _Type; };
+template <class _Tp> struct _UnQual<volatile _Tp> { typedef _Tp _Type; };
+template <class _Tp> struct _UnQual<const volatile _Tp> { typedef _Tp _Type; };
+# endif
+# endif
+
+/* This struct is intended to say if a pointer can be convertible to an other
+ * taking into account cv qualifications. It shouldn't be instanciated with
+ * something else than pointer type as it uses pass by value parameter that
+ * results in compilation error when parameter type has a special memory
+ * alignment
+ */
+template <class _Src, class _Dst>
+struct _IsCVConvertible {
+# if !defined (__BORLANDC__) || (__BORLANDC__ >= 0x590)
+ typedef _ConversionHelper<_Src, _Dst> _H;
+ enum { value = (sizeof(char) == sizeof(_H::_Test(false, _H::_MakeSource()))) };
+# else
+ enum { _Is1 = __type2bool<_IsConst<_Src>::_Ret>::_Ret };
+ enum { _Is2 = _IsConvertible<_UnConstPtr<_Src>::_Type, _UnConstPtr<_Dst>::_Type>::value };
+ enum { value = _Is1 ? 0 : _Is2 };
+# endif
+ typedef typename __bool2type<value>::_Ret _Ret;
+};
+
+#else
+template <class _Src, class _Dst>
+struct _IsConvertible {
+ enum { value = 0 };
+ typedef __false_type _Ret;
+};
+
+template <class _Src, class _Dst>
+struct _IsCVConvertible {
+ enum { value = 0 };
+ typedef __false_type _Ret;
+};
+#endif
+
+_STLP_END_NAMESPACE
+
+#endif /* _STLP_TYPE_MANIPS_H */
diff --git a/sources/android/stlport/stlport/stl/type_traits.h b/sources/android/stlport/stlport/stl/type_traits.h
new file mode 100644
index 0000000..af0923d
--- /dev/null
+++ b/sources/android/stlport/stlport/stl/type_traits.h
@@ -0,0 +1,626 @@
+/*
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1997
+ * Moscow Center for SPARC Technology
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_TYPE_TRAITS_H
+#define _STLP_TYPE_TRAITS_H
+
+/*
+This header file provides a framework for allowing compile time dispatch
+based on type attributes. This is useful when writing template code.
+For example, when making a copy of an array of an unknown type, it helps
+to know if the type has a trivial copy constructor or not, to help decide
+if a memcpy can be used.
+
+The class template __type_traits provides a series of typedefs each of
+which is either __true_type or __false_type. The argument to
+__type_traits can be any type. The typedefs within this template will
+attain their correct values by one of these means:
+ 1. The general instantiation contain conservative values which work
+ for all types.
+ 2. Specializations may be declared to make distinctions between types.
+ 3. Some compilers (such as the Silicon Graphics N32 and N64 compilers)
+ will automatically provide the appropriate specializations for all
+ types.
+
+EXAMPLE:
+
+//Copy an array of elements which have non-trivial copy constructors
+template <class T> void copy(T* source, T* destination, int n, __false_type);
+//Copy an array of elements which have trivial copy constructors. Use memcpy.
+template <class T> void copy(T* source, T* destination, int n, __true_type);
+
+//Copy an array of any type by using the most efficient copy mechanism
+template <class T> inline void copy(T* source,T* destination,int n) {
+ copy(source, destination, n,
+ typename __type_traits<T>::has_trivial_copy_constructor());
+}
+*/
+
+#ifdef __WATCOMC__
+# include <stl/_cwchar.h>
+#endif
+
+#ifndef _STLP_TYPE_MANIPS_H
+# include <stl/type_manips.h>
+#endif
+
+#ifdef _STLP_USE_BOOST_SUPPORT
+# include <stl/boost_type_traits.h>
+# include <boost/type_traits/add_reference.hpp>
+# include <boost/type_traits/add_const.hpp>
+#endif /* _STLP_USE_BOOST_SUPPORT */
+
+_STLP_BEGIN_NAMESPACE
+
+#if !defined (_STLP_USE_BOOST_SUPPORT)
+
+// The following could be written in terms of numeric_limits.
+// We're doing it separately to reduce the number of dependencies.
+
+template <class _Tp> struct _IsIntegral
+{ typedef __false_type _Ret; };
+
+# ifndef _STLP_NO_BOOL
+_STLP_TEMPLATE_NULL struct _IsIntegral<bool>
+{ typedef __true_type _Ret; };
+# endif /* _STLP_NO_BOOL */
+
+_STLP_TEMPLATE_NULL struct _IsIntegral<char>
+{ typedef __true_type _Ret; };
+
+# ifndef _STLP_NO_SIGNED_BUILTINS
+_STLP_TEMPLATE_NULL struct _IsIntegral<signed char>
+{ typedef __true_type _Ret; };
+# endif
+
+_STLP_TEMPLATE_NULL struct _IsIntegral<unsigned char>
+{ typedef __true_type _Ret; };
+
+# if defined ( _STLP_HAS_WCHAR_T ) && ! defined (_STLP_WCHAR_T_IS_USHORT)
+_STLP_TEMPLATE_NULL struct _IsIntegral<wchar_t>
+{ typedef __true_type _Ret; };
+# endif /* _STLP_HAS_WCHAR_T */
+
+_STLP_TEMPLATE_NULL struct _IsIntegral<short>
+{ typedef __true_type _Ret; };
+
+_STLP_TEMPLATE_NULL struct _IsIntegral<unsigned short>
+{ typedef __true_type _Ret; };
+
+_STLP_TEMPLATE_NULL struct _IsIntegral<int>
+{ typedef __true_type _Ret; };
+
+_STLP_TEMPLATE_NULL struct _IsIntegral<unsigned int>
+{ typedef __true_type _Ret; };
+
+_STLP_TEMPLATE_NULL struct _IsIntegral<long>
+{ typedef __true_type _Ret; };
+
+_STLP_TEMPLATE_NULL struct _IsIntegral<unsigned long>
+{ typedef __true_type _Ret; };
+
+# ifdef _STLP_LONG_LONG
+_STLP_TEMPLATE_NULL struct _IsIntegral<_STLP_LONG_LONG>
+{ typedef __true_type _Ret; };
+
+_STLP_TEMPLATE_NULL struct _IsIntegral<unsigned _STLP_LONG_LONG>
+{ typedef __true_type _Ret; };
+# endif /* _STLP_LONG_LONG */
+
+template <class _Tp> struct _IsRational
+{ typedef __false_type _Ret; };
+
+_STLP_TEMPLATE_NULL struct _IsRational<float>
+{ typedef __true_type _Ret; };
+
+_STLP_TEMPLATE_NULL struct _IsRational<double>
+{ typedef __true_type _Ret; };
+
+# if !defined ( _STLP_NO_LONG_DOUBLE )
+_STLP_TEMPLATE_NULL struct _IsRational<long double>
+{ typedef __true_type _Ret; };
+# endif
+
+// Forward declarations.
+template <class _Tp> struct __type_traits;
+template <class _IsPOD> struct __type_traits_aux {
+ typedef __false_type has_trivial_default_constructor;
+ typedef __false_type has_trivial_copy_constructor;
+ typedef __false_type has_trivial_assignment_operator;
+ typedef __false_type has_trivial_destructor;
+ typedef __false_type is_POD_type;
+};
+
+_STLP_TEMPLATE_NULL
+struct __type_traits_aux<__false_type> {
+ typedef __false_type has_trivial_default_constructor;
+ typedef __false_type has_trivial_copy_constructor;
+ typedef __false_type has_trivial_assignment_operator;
+ typedef __false_type has_trivial_destructor;
+ typedef __false_type is_POD_type;
+};
+
+_STLP_TEMPLATE_NULL
+struct __type_traits_aux<__true_type> {
+ typedef __true_type has_trivial_default_constructor;
+ typedef __true_type has_trivial_copy_constructor;
+ typedef __true_type has_trivial_assignment_operator;
+ typedef __true_type has_trivial_destructor;
+ typedef __true_type is_POD_type;
+};
+
+template <class _Tp>
+struct _IsRef {
+ typedef __false_type _Ret;
+};
+
+# if defined (_STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS)
+/*
+ * Boris : simulation technique is used here according to Adobe Open Source License Version 1.0.
+ * Copyright 2000 Adobe Systems Incorporated and others. All rights reserved.
+ * Authors: Mat Marcus and Jesse Jones
+ * The original version of this source code may be found at
+ * http://opensource.adobe.com.
+ */
+
+struct _PointerShim {
+ /*
+ * Since the compiler only allows at most one non-trivial
+ * implicit conversion we can make use of a shim class to
+ * be sure that IsPtr below doesn't accept classes with
+ * implicit pointer conversion operators
+ */
+ _PointerShim(const volatile void*); // no implementation
+};
+
+// These are the discriminating functions
+char _STLP_CALL _IsP(bool, _PointerShim); // no implementation is required
+char* _STLP_CALL _IsP(bool, ...); // no implementation is required
+
+template <class _Tp>
+struct _IsPtr {
+ /*
+ * This template meta function takes a type T
+ * and returns true exactly when T is a pointer.
+ * One can imagine meta-functions discriminating on
+ * other criteria.
+ */
+ static _Tp& __null_rep();
+ enum { _Ptr = (sizeof(_IsP(false,__null_rep())) == sizeof(char)) };
+ typedef typename __bool2type<_Ptr>::_Ret _Ret;
+
+};
+
+// we make general case dependant on the fact the type is actually a pointer.
+template <class _Tp>
+struct __type_traits : __type_traits_aux<typename _IsPtr<_Tp>::_Ret> {};
+
+# else /* _STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS */
+
+template <class _Tp> struct _IsPtr {
+ typedef __false_type _Ret;
+};
+
+template <class _Tp>
+struct __type_traits {
+ typedef __true_type this_dummy_member_must_be_first;
+ /* Do not remove this member. It informs a compiler which
+ automatically specializes __type_traits that this
+ __type_traits template is special. It just makes sure that
+ things work if an implementation is using a template
+ called __type_traits for something unrelated. */
+
+ /* The following restrictions should be observed for the sake of
+ compilers which automatically produce type specific specializations
+ of this class:
+ - You may reorder the members below if you wish
+ - You may remove any of the members below if you wish
+ - You must not rename members without making the corresponding
+ name change in the compiler
+ - Members you add will be treated like regular members unless
+
+ you add the appropriate support in the compiler. */
+# if !defined (_STLP_HAS_TYPE_TRAITS_INTRINSICS)
+ typedef __false_type has_trivial_default_constructor;
+ typedef __false_type has_trivial_copy_constructor;
+ typedef __false_type has_trivial_assignment_operator;
+ typedef __false_type has_trivial_destructor;
+ typedef __false_type is_POD_type;
+# else
+ typedef typename __bool2type<_STLP_HAS_TRIVIAL_CONSTRUCTOR(_Tp)>::_Ret has_trivial_default_constructor;
+ typedef typename __bool2type<_STLP_HAS_TRIVIAL_COPY(_Tp)>::_Ret has_trivial_copy_constructor;
+ typedef typename __bool2type<_STLP_HAS_TRIVIAL_ASSIGN(_Tp)>::_Ret has_trivial_assignment_operator;
+ typedef typename __bool2type<_STLP_HAS_TRIVIAL_DESTRUCTOR(_Tp)>::_Ret has_trivial_destructor;
+ typedef typename __bool2type<_STLP_IS_POD(_Tp)>::_Ret is_POD_type;
+# endif
+};
+
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+template <class _Tp> struct _IsPtr<_Tp*>
+{ typedef __true_type _Ret; };
+template <class _Tp> struct _IsRef<_Tp&>
+{ typedef __true_type _Ret; };
+
+template <class _Tp> struct __type_traits<_Tp*> : __type_traits_aux<__true_type>
+{};
+# endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
+
+# endif /* _STLP_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS */
+
+// Provide some specializations. This is harmless for compilers that
+// have built-in __types_traits support, and essential for compilers
+// that don't.
+# if !defined (_STLP_QUALIFIED_SPECIALIZATION_BUG)
+# define _STLP_DEFINE_TYPE_TRAITS_FOR(Type) \
+_STLP_TEMPLATE_NULL struct __type_traits< Type > : __type_traits_aux<__true_type> {}; \
+_STLP_TEMPLATE_NULL struct __type_traits< const Type > : __type_traits_aux<__true_type> {}; \
+_STLP_TEMPLATE_NULL struct __type_traits< volatile Type > : __type_traits_aux<__true_type> {}; \
+_STLP_TEMPLATE_NULL struct __type_traits< const volatile Type > : __type_traits_aux<__true_type> {}
+# else
+# define _STLP_DEFINE_TYPE_TRAITS_FOR(Type) \
+_STLP_TEMPLATE_NULL struct __type_traits< Type > : __type_traits_aux<__true_type> {};
+# endif
+
+# ifndef _STLP_NO_BOOL
+_STLP_DEFINE_TYPE_TRAITS_FOR(bool);
+# endif /* _STLP_NO_BOOL */
+_STLP_DEFINE_TYPE_TRAITS_FOR(char);
+# ifndef _STLP_NO_SIGNED_BUILTINS
+_STLP_DEFINE_TYPE_TRAITS_FOR(signed char);
+# endif
+_STLP_DEFINE_TYPE_TRAITS_FOR(unsigned char);
+# if defined ( _STLP_HAS_WCHAR_T ) && ! defined (_STLP_WCHAR_T_IS_USHORT)
+_STLP_DEFINE_TYPE_TRAITS_FOR(wchar_t);
+# endif /* _STLP_HAS_WCHAR_T */
+
+_STLP_DEFINE_TYPE_TRAITS_FOR(short);
+_STLP_DEFINE_TYPE_TRAITS_FOR(unsigned short);
+_STLP_DEFINE_TYPE_TRAITS_FOR(int);
+_STLP_DEFINE_TYPE_TRAITS_FOR(unsigned int);
+_STLP_DEFINE_TYPE_TRAITS_FOR(long);
+_STLP_DEFINE_TYPE_TRAITS_FOR(unsigned long);
+
+# ifdef _STLP_LONG_LONG
+_STLP_DEFINE_TYPE_TRAITS_FOR(_STLP_LONG_LONG);
+_STLP_DEFINE_TYPE_TRAITS_FOR(unsigned _STLP_LONG_LONG);
+# endif /* _STLP_LONG_LONG */
+
+_STLP_DEFINE_TYPE_TRAITS_FOR(float);
+_STLP_DEFINE_TYPE_TRAITS_FOR(double);
+
+# if !defined ( _STLP_NO_LONG_DOUBLE )
+_STLP_DEFINE_TYPE_TRAITS_FOR(long double);
+# endif
+
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+template <class _ArePtrs, class _Src, class _Dst>
+struct _IsCVConvertibleIf
+{ typedef typename _IsCVConvertible<_Src, _Dst>::_Ret _Ret; };
+
+template <class _Src, class _Dst>
+struct _IsCVConvertibleIf<__false_type, _Src, _Dst>
+{ typedef __false_type _Ret; };
+# else
+# if defined (_STLP_MEMBER_TEMPLATE_CLASSES)
+template <class _ArePtrs>
+struct _IsCVConvertibleIfAux {
+ template <class _Src, class _Dst>
+ struct _In
+ { typedef typename _IsCVConvertible<_Src, _Dst>::_Ret _Ret; };
+};
+
+_STLP_TEMPLATE_NULL
+struct _IsCVConvertibleIfAux<__false_type> {
+ template <class _Src, class _Dst>
+ struct _In
+ { typedef __false_type _Ret; };
+};
+
+template <class _ArePtrs, class _Src, class _Dst>
+struct _IsCVConvertibleIf {
+ typedef typename _IsCVConvertibleIfAux<_ArePtrs>::_STLP_TEMPLATE _In<_Src, _Dst>::_Ret _Ret;
+};
+# else
+/* default behavior: we prefer to miss an optimization rather than taking the risk of
+ * a compilation error if playing with types with exotic memory alignment.
+ */
+template <class _ArePtrs, class _Src, class _Dst>
+struct _IsCVConvertibleIf
+{ typedef __false_type _Ret; };
+# endif
+# endif
+
+template <class _Src, class _Dst>
+struct _TrivialNativeTypeCopy {
+ typedef typename _IsPtr<_Src>::_Ret _Ptr1;
+ typedef typename _IsPtr<_Dst>::_Ret _Ptr2;
+ typedef typename _Land2<_Ptr1, _Ptr2>::_Ret _BothPtrs;
+ typedef typename _IsCVConvertibleIf<_BothPtrs, _Src, _Dst>::_Ret _Convertible;
+ typedef typename _Land2<_BothPtrs, _Convertible>::_Ret _Trivial1;
+
+ typedef typename __bool2type<(sizeof(_Src) == sizeof(_Dst))>::_Ret _SameSize;
+
+#if !defined (__BORLANDC__) || (__BORLANDC__ < 0x564)
+ typedef typename _IsIntegral<_Src>::_Ret _Int1;
+#else
+ typedef typename _UnQual<_Src>::_Type _UnQuSrc;
+ typedef typename _IsIntegral<_UnQuSrc>::_Ret _Int1;
+#endif
+ typedef typename _IsIntegral<_Dst>::_Ret _Int2;
+ typedef typename _Land2<_Int1, _Int2>::_Ret _BothInts;
+
+ typedef typename _IsRational<_Src>::_Ret _Rat1;
+ typedef typename _IsRational<_Dst>::_Ret _Rat2;
+ typedef typename _Land2<_Rat1, _Rat2>::_Ret _BothRats;
+
+ typedef typename _Lor2<_BothInts, _BothRats>::_Ret _BothNatives;
+#if !defined (__BORLANDC__) || (__BORLANDC__ >= 0x564)
+ typedef typename _Land2<_BothNatives, _SameSize>::_Ret _Trivial2;
+#else
+ typedef typename _IsUnQual<_Dst>::_Ret _UnQualDst;
+ typedef typename _Land3<_BothNatives, _SameSize, _UnQualDst>::_Ret _Trivial2;
+#endif
+ typedef typename _Lor2<_Trivial1, _Trivial2>::_Ret _Ret;
+};
+
+template <class _Src, class _Dst>
+struct _TrivialCopy {
+ typedef typename _TrivialNativeTypeCopy<_Src, _Dst>::_Ret _NativeRet;
+# if !defined (__BORLANDC__) || (__BORLANDC__ != 0x560)
+ typedef typename __type_traits<_Src>::has_trivial_assignment_operator _Tr1;
+# else
+ typedef typename _UnConstPtr<_Src*>::_Type _UnConstSrc;
+ typedef typename __type_traits<_UnConstSrc>::has_trivial_assignment_operator _Tr1;
+# endif
+ typedef typename _AreCopyable<_Src, _Dst>::_Ret _Tr2;
+ typedef typename _Land2<_Tr1, _Tr2>::_Ret _UserRet;
+ typedef typename _Lor2<_NativeRet, _UserRet>::_Ret _Ret;
+ static _Ret _Answer() { return _Ret(); }
+};
+
+template <class _Src, class _Dst>
+struct _TrivialUCopy {
+ typedef typename _TrivialNativeTypeCopy<_Src, _Dst>::_Ret _NativeRet;
+# if !defined (__BORLANDC__) || (__BORLANDC__ != 0x560)
+ typedef typename __type_traits<_Src>::has_trivial_copy_constructor _Tr1;
+# else
+ typedef typename _UnConstPtr<_Src*>::_Type _UnConstSrc;
+ typedef typename __type_traits<_UnConstSrc>::has_trivial_copy_constructor _Tr1;
+# endif
+ typedef typename _AreCopyable<_Src, _Dst>::_Ret _Tr2;
+ typedef typename _Land2<_Tr1, _Tr2>::_Ret _UserRet;
+ typedef typename _Lor2<_NativeRet, _UserRet>::_Ret _Ret;
+ static _Ret _Answer() { return _Ret(); }
+};
+
+template <class _Tp>
+struct _DefaultZeroValue {
+ typedef typename _IsIntegral<_Tp>::_Ret _Tr1;
+ typedef typename _IsRational<_Tp>::_Ret _Tr2;
+ typedef typename _IsPtr<_Tp>::_Ret _Tr3;
+ typedef typename _Lor3<_Tr1, _Tr2, _Tr3>::_Ret _Ret;
+};
+
+template <class _Tp>
+struct _TrivialInit {
+# if !defined (__BORLANDC__) || (__BORLANDC__ != 0x560)
+ typedef typename __type_traits<_Tp>::has_trivial_default_constructor _Tr1;
+# else
+ typedef typename _UnConstPtr<_Tp*>::_Type _Tp1;
+ typedef typename __type_traits<_Tp1>::has_trivial_copy_constructor _Tr1;
+# endif
+ typedef typename _DefaultZeroValue<_Tp>::_Ret _Tr2;
+ typedef typename _Not<_Tr2>::_Ret _Tr3;
+ typedef typename _Land2<_Tr1, _Tr3>::_Ret _Ret;
+ static _Ret _Answer() { return _Ret(); }
+};
+
+#endif /* !_STLP_USE_BOOST_SUPPORT */
+
+template <class _Tp>
+struct _IsPtrType {
+ typedef typename _IsPtr<_Tp>::_Ret _Type;
+ static _Type _Ret() { return _Type(); }
+};
+
+template <class _Tp>
+struct _IsRefType {
+ typedef typename _IsRef<_Tp>::_Ret _Type;
+ static _Type _Ret() { return _Type();}
+};
+
+template <class _Tp>
+struct __call_traits {
+#if defined (_STLP_USE_BOOST_SUPPORT) && !defined (_STLP_NO_EXTENSIONS)
+ typedef typename __select< ::boost::is_reference<_Tp>::value,
+ typename ::boost::add_const<_Tp>::type,
+ typename ::boost::add_reference< typename ::boost::add_const<_Tp>::type >::type>::_Ret const_param_type;
+ typedef typename __select< ::boost::is_reference<_Tp>::value,
+ typename ::boost::remove_const<_Tp>::type,
+ typename ::boost::add_reference<_Tp>::type>::_Ret param_type;
+#else
+ typedef const _Tp& const_param_type;
+ typedef _Tp& param_type;
+#endif
+};
+
+#if !defined (_STLP_USE_BOOST_SUPPORT) && !defined (_STLP_NO_EXTENSIONS) && defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+template <class _Tp>
+struct __call_traits<_Tp&> {
+ typedef _Tp& param_type;
+ typedef const _Tp& const_param_type;
+};
+template <class _Tp>
+struct __call_traits<const _Tp&> {
+ typedef _Tp& param_type;
+ typedef const _Tp& const_param_type;
+};
+#endif
+
+template <class _Tp1, class _Tp2>
+struct _BothPtrType {
+ typedef typename _IsPtr<_Tp1>::_Ret _IsPtr1;
+ typedef typename _IsPtr<_Tp2>::_Ret _IsPtr2;
+
+ typedef typename _Land2<_IsPtr1, _IsPtr2>::_Ret _Ret;
+ static _Ret _Answer() { return _Ret(); }
+};
+
+template <class _Tp1, class _Tp2, class _IsRef1, class _IsRef2>
+struct _OKToSwap {
+ typedef typename _AreSameTypes<_Tp1, _Tp2>::_Ret _Same;
+ typedef typename _Land3<_Same, _IsRef1, _IsRef2>::_Ret _Type;
+ static _Type _Answer() { return _Type(); }
+};
+
+template <class _Tp1, class _Tp2, class _IsRef1, class _IsRef2>
+inline _OKToSwap<_Tp1, _Tp2, _IsRef1, _IsRef2>
+_IsOKToSwap(_Tp1*, _Tp2*, const _IsRef1&, const _IsRef2&)
+{ return _OKToSwap<_Tp1, _Tp2, _IsRef1, _IsRef2>(); }
+
+template <class _Src, class _Dst>
+inline _TrivialCopy<_Src, _Dst> _UseTrivialCopy(_Src*, _Dst*)
+{ return _TrivialCopy<_Src, _Dst>(); }
+
+template <class _Src, class _Dst>
+inline _TrivialUCopy<_Src, _Dst> _UseTrivialUCopy(_Src*, _Dst*)
+{ return _TrivialUCopy<_Src, _Dst>(); }
+
+#if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) || defined (__BORLANDC__) || \
+ defined (__DMC__)
+struct _NegativeAnswer {
+ typedef __false_type _Ret;
+ static _Ret _Answer() { return _Ret(); }
+};
+
+template <class _Src, class _Dst>
+inline _NegativeAnswer _UseTrivialCopy(_Src*, const _Dst*)
+{ return _NegativeAnswer(); }
+
+template <class _Src, class _Dst>
+inline _NegativeAnswer _UseTrivialCopy(_Src*, volatile _Dst*)
+{ return _NegativeAnswer(); }
+
+template <class _Src, class _Dst>
+inline _NegativeAnswer _UseTrivialCopy(_Src*, const volatile _Dst*)
+{ return _NegativeAnswer(); }
+
+template <class _Src, class _Dst>
+inline _NegativeAnswer _UseTrivialUCopy(_Src*, const _Dst*)
+{ return _NegativeAnswer(); }
+
+template <class _Src, class _Dst>
+inline _NegativeAnswer _UseTrivialUCopy(_Src*, volatile _Dst*)
+{ return _NegativeAnswer(); }
+
+template <class _Src, class _Dst>
+inline _NegativeAnswer _UseTrivialUCopy(_Src*, const volatile _Dst*)
+{ return _NegativeAnswer(); }
+#endif
+
+template <class _Tp>
+inline _TrivialInit<_Tp> _UseTrivialInit(_Tp*)
+{ return _TrivialInit<_Tp>(); }
+
+template <class _Tp>
+struct _IsPOD {
+ typedef typename __type_traits<_Tp>::is_POD_type _Type;
+ static _Type _Answer() { return _Type(); }
+};
+
+template <class _Tp>
+inline _IsPOD<_Tp> _Is_POD(_Tp*)
+{ return _IsPOD<_Tp>(); }
+
+template <class _Tp>
+struct _DefaultZeroValueQuestion {
+ typedef typename _DefaultZeroValue<_Tp>::_Ret _Ret;
+ static _Ret _Answer() { return _Ret(); }
+};
+
+template <class _Tp>
+inline _DefaultZeroValueQuestion<_Tp> _HasDefaultZeroValue(_Tp*)
+{ return _DefaultZeroValueQuestion<_Tp>(); }
+
+/*
+ * Base class used:
+ * - to simulate partial template specialization
+ * - to simulate partial function ordering
+ * - to recognize STLport class from user specialized one
+ */
+template <class _Tp>
+struct __stlport_class
+{ typedef _Tp _Type; };
+
+template <class _Tp>
+struct _IsSTLportClass {
+ typedef typename _IsConvertible<_Tp, __stlport_class<_Tp> >::_Ret _Ret;
+#if defined (__BORLANDC__)
+ enum { _Is = _IsConvertible<_Tp, __stlport_class<_Tp> >::value };
+#endif
+};
+
+#if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+template <class _Tp>
+struct _SwapImplemented {
+ typedef typename _IsSTLportClass<_Tp>::_Ret _Ret;
+# if defined (__BORLANDC__)
+ enum { _Is = _IsSTLportClass<_Tp>::_Is };
+# endif
+};
+#endif
+
+template <class _Tp>
+class _TpWithState : private _Tp {
+ _TpWithState();
+ int _state;
+};
+
+/* This is an internal helper struct used to guess if we are working
+ * on a stateless class. It can only be instanciated with a class type. */
+template <class _Tp>
+struct _IsStateless {
+ enum { _Is = sizeof(_TpWithState<_Tp>) == sizeof(int) };
+ typedef typename __bool2type<_Is>::_Ret _Ret;
+};
+
+_STLP_END_NAMESPACE
+
+#ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
+# if defined (__BORLANDC__) || \
+ defined (__SUNPRO_CC) || \
+ (defined (__MWERKS__) && (__MWERKS__ <= 0x2303)) || \
+ (defined (__sgi) && defined (_COMPILER_VERSION)) || \
+ defined (__DMC__)
+# define _STLP_IS_POD_ITER(_It, _Tp) __type_traits< typename iterator_traits< _Tp >::value_type >::is_POD_type()
+# else
+# define _STLP_IS_POD_ITER(_It, _Tp) typename __type_traits< typename iterator_traits< _Tp >::value_type >::is_POD_type()
+# endif
+#else
+# define _STLP_IS_POD_ITER(_It, _Tp) _Is_POD( _STLP_VALUE_TYPE( _It, _Tp ) )._Answer()
+#endif
+
+#endif /* _STLP_TYPE_TRAITS_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/streambuf b/sources/android/stlport/stlport/streambuf
new file mode 100644
index 0000000..f4dc253
--- /dev/null
+++ b/sources/android/stlport/stlport/streambuf
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_STREAMBUF
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x1066
+# include <stl/_prolog.h>
+# define _STLP_STREAMBUF
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1066) && \
+ !(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
+# include <stl/_ioserr.h>
+
+# ifndef _STLP_INTERNAL_STREAMBUF
+# include <stl/_streambuf.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x1066) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <streambuf>
+# else
+# include _STLP_NATIVE_HEADER(streambuf)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1066)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_STREAMBUF */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/streambuf.h b/sources/android/stlport/stlport/streambuf.h
new file mode 100644
index 0000000..ff2bff5
--- /dev/null
+++ b/sources/android/stlport/stlport/streambuf.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+#ifndef _STLP_STREAMBUF_H
+#define _STLP_STREAMBUF_H
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x2067
+# include <stl/_prolog.h>
+#endif
+
+#include <stl/_ioserr.h>
+
+#include <streambuf>
+
+#include <ios.h>
+
+#ifndef _STLP_HAS_NO_NAMESPACES
+# ifdef _STLP_BROKEN_USING_DIRECTIVE
+_STLP_USING_NAMESPACE(stlport)
+# else
+using _STLP_STD::basic_streambuf;
+using _STLP_STD::streambuf;
+# ifndef _STLP_NO_WCHAR_T
+using _STLP_STD::wstreambuf;
+# endif
+# endif
+#endif /* _STLP_HAS_NO_NAMESPACES */
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x2067)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_STREAMBUF_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/string b/sources/android/stlport/stlport/string
new file mode 100644
index 0000000..74d4589
--- /dev/null
+++ b/sources/android/stlport/stlport/string
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 1997-1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STRING
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x68
+# include <stl/_prolog.h>
+# define _STLP_STRING
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x68)
+# ifndef _STLP_INTERNAL_STRING_H
+# include <stl/_string.h>
+# endif
+
+# ifndef _STLP_STRING_HASH_H
+# include <stl/_string_hash.h>
+# endif
+
+# if !defined (_STLP_USE_NO_IOSTREAMS) && !defined (_STLP_STRING_IO_H)
+# include <stl/_string_io.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x68) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <string>
+# else
+# include _STLP_NATIVE_HEADER(string)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x68)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_STRING */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/string.h b/sources/android/stlport/stlport/string.h
new file mode 100644
index 0000000..52013cf
--- /dev/null
+++ b/sources/android/stlport/stlport/string.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* Workaround for a "misbehaviour" when compiling resource scripts using
+ * eMbedded Visual C++. The standard .rc file includes windows header files,
+ * which in turn include string.h, which results in warnings and errors
+ */
+#ifndef _STLP_STRING_H
+
+#if !defined (RC_INVOKED)
+
+# ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x269
+# include <stl/_cprolog.h>
+# elif (_STLP_OUTERMOST_HEADER_ID == 0x269) && !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+# define _STLP_STRING_H
+# endif
+
+# if defined(_STLP_WCE_EVC3)
+struct _exception;
+# endif
+# if (_STLP_OUTERMOST_HEADER_ID != 0x269) || defined (_STLP_DONT_POP_HEADER_ID)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <string.h>
+# else
+# include _STLP_NATIVE_C_HEADER(string.h)
+# endif
+# else
+# if defined (__BORLANDC__) && !defined (__linux__)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <_str.h>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(_str.h)
+# endif
+# else
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <string.h>
+# else
+# include _STLP_NATIVE_C_HEADER(string.h)
+# endif
+# endif
+# endif
+
+# if (_STLP_OUTERMOST_HEADER_ID == 0x269)
+# if !defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+# endif
+#endif /* RC_INVOKED */
+#endif /* _STLP_STRING_H */
diff --git a/sources/android/stlport/stlport/strstream b/sources/android/stlport/stlport/strstream
new file mode 100644
index 0000000..247574f
--- /dev/null
+++ b/sources/android/stlport/stlport/strstream
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+// WARNING: The classes defined in this header are DEPRECATED. This
+// header is defined in section D.7.1 of the C++ standard, and it
+// MAY BE REMOVED in a future standard revision. You should use the
+// header <sstream> instead.
+
+
+#ifndef _STLP_STRSTREAM
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x1070
+# include <stl/_prolog.h>
+# define _STLP_STRSTREAM
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1070) && \
+ !(defined (_STLP_NO_IOSTREAMS) && defined (_STLP_IMPORT_VENDOR_STD))
+# include <stl/_ioserr.h>
+
+# ifndef _STLP_INTERNAL_STRSTREAM
+# include <stl/_strstream.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x1070) || defined (_STLP_IMPORT_VENDOR_STD)
+/* Even if deprecated strstream header is still part of the Standard. Remove
+ * _STLP_IMPORT_VENDOR_STD check if the native compiler library do not grant
+ * it anymore. */
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <strstream>
+# else
+# include _STLP_NATIVE_HEADER(strstream)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x1070)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_STRSTREAM */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/strstream.h b/sources/android/stlport/stlport/strstream.h
new file mode 100644
index 0000000..e302a16
--- /dev/null
+++ b/sources/android/stlport/stlport/strstream.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_STRSTREAM_H
+# define _STLP_STRSTREAM_H
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x2071
+# include <stl/_prolog.h>
+#endif
+
+#include <strstream>
+
+#include <iostream.h>
+
+
+#ifndef _STLP_HAS_NO_NAMESPACES
+
+# ifdef _STLP_BROKEN_USING_DIRECTIVE
+
+using namespace _STLP_STD;
+
+# else
+
+using _STLP_STD::strstreambuf;
+using _STLP_STD::istrstream;
+using _STLP_STD::ostrstream;
+using _STLP_STD::strstream;
+
+# endif /* _STLP_BROKEN_USING_DIRECTIVE */
+
+#endif /* _STLP_HAS_NO_NAMESPACES */
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x2071)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_STRSTREAM_H */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/time.h b/sources/android/stlport/stlport/time.h
new file mode 100644
index 0000000..e73aa85
--- /dev/null
+++ b/sources/android/stlport/stlport/time.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x272
+# include <stl/_cprolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x272) && ! defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+#endif
+
+#ifdef _STLP_WCE_EVC3
+/* only show message when directly including this file in a non-library build */
+# if !defined(__BUILDING_STLPORT) && (_STLP_OUTERMOST_HEADER_ID == 0x272)
+# pragma message("eMbedded Visual C++ 3 doesn't have a time.h header; STLport won't include native time.h here")
+# endif
+#else
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <time.h>
+# else
+# include _STLP_NATIVE_C_HEADER(time.h)
+# endif
+#endif
+
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x272)
+# if ! defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+#endif
diff --git a/sources/android/stlport/stlport/type_traits b/sources/android/stlport/stlport/type_traits
new file mode 100644
index 0000000..e6fe234
--- /dev/null
+++ b/sources/android/stlport/stlport/type_traits
@@ -0,0 +1,798 @@
+// -*- C++ -*- Time-stamp: <08/07/20 19:10:15 ptr>
+
+/*
+ * Copyright (c) 2007, 2008
+ * Petr Ovtchenkov
+ *
+ * Licensed under the Academic Free License version 3.0
+ *
+ * Derived from original <misc/type_traits.h> of 'complement' project
+ * [http://complement.sourceforge.net]
+ * to make it close to JTC1/SC22/WG21 C++ 0x working draft
+ * [http://www.open-std.org/Jtc1/sc22/wg21/docs/papers/2008/n2521.pdf]
+ */
+
+#ifndef __STLP_TYPE_TRAITS
+#define __STLP_TYPE_TRAITS
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x3
+# include <stl/_prolog.h>
+#endif
+
+// libstdc++ v3, timestamp 20050519 (3.4.4) has __type_traits,
+// libstdc++ v3, timestamp 20060306 (3.4.6) has __type_traits,
+// while libstdc++ v3, 20050921 (4.0.2) not; use libstdc++ instead
+// # if defined(STLPORT) || (defined(__GNUC__) && (__GNUC__ < 4)) /* !defined(__GLIBCXX__) || (defined(__GNUC__) && (__GNUC__ < 4)) */
+
+_STLP_BEGIN_NAMESPACE
+
+_STLP_BEGIN_TR1_NAMESPACE
+
+namespace detail {
+
+struct __select_types
+{
+ typedef char __t1;
+ struct __t2
+ {
+ char __two[2];
+ };
+};
+
+template <class _Tp>
+struct __instance :
+ public __select_types
+{
+ private:
+ template <class _Up>
+ static __t1 __test(_Up(*)[1]);
+
+ template <class>
+ static __t2 __test(...);
+
+ public:
+#ifdef _STLP_STATIC_CONST_INIT_BUG
+ static const bool __value;
+#else
+ static const bool __value = sizeof(__test<_Tp>(0)) == sizeof(__select_types::__t1);
+#endif
+
+};
+
+#ifdef _STLP_STATIC_CONST_INIT_BUG
+template <class _Tp>
+const bool __instance<_Tp>::__value = sizeof(__instance<_Tp>::__test<_Tp>(0)) == sizeof(__select_types::__t1);
+#endif
+
+template <class T>
+struct __uoc_aux : // union or class
+ public __select_types
+{
+ private:
+ template <class _Up>
+ static __t1 __test( int _Up::* );
+
+ template <class>
+ static __t2 __test(...);
+
+ public:
+#ifdef __FIT_NO_INLINE_TEMPLATE_STATIC_INITIALISATION
+ static const bool __value;
+#else
+ static const bool __value = sizeof(__test<T>(0)) == sizeof(__select_types::__t1);
+#endif
+};
+
+#ifdef __FIT_NO_INLINE_TEMPLATE_STATIC_INITIALISATION
+template <class T>
+const bool __uoc_aux<T>::__value = sizeof(__uoc_aux<T>::__test<T>(0)) == sizeof(__select_types::__t1);
+#endif
+
+template <class T>
+class __empty
+{ };
+
+template <class T, bool B>
+class __inheritance_aux
+{};
+
+template <class T>
+class __inheritance_aux<T,true> :
+ public T
+{
+ public:
+ virtual ~__inheritance_aux()
+ { }
+};
+
+#if 0
+template <class T, bool B>
+struct __virtual_aux
+{
+ public:
+#ifdef _STLP_STATIC_CONST_INIT_BUG
+ static const bool __value;
+#else
+ static const bool __value = B ? (sizeof(__inheritance_aux<T,B>) == sizeof(T)) : false;
+#endif
+};
+
+#ifdef _STLP_STATIC_CONST_INIT_BUG
+template <class T, bool B>
+const bool __virtual_aux<T,B>::__value = B ? (sizeof(__inheritance_aux<T,B>) == sizeof(T)) : false;
+#endif
+#endif
+
+} // namespace detail
+
+template <class _Tp, _Tp __v>
+struct integral_constant
+{
+ static const _Tp value = __v;
+ // enum { value = __v }; ?
+
+ typedef _Tp value_type;
+ typedef integral_constant<_Tp, __v> type;
+};
+
+typedef integral_constant<bool, true> true_type;
+typedef integral_constant<bool, false> false_type;
+
+namespace detail {
+
+template <typename _Tp>
+struct __is_union_or_class :
+ public integral_constant<bool, __uoc_aux<_Tp>::__value>
+{ };
+
+#if 0
+template<typename _Tp>
+struct __is_vtbl : // has virtual table?
+ public integral_constant<bool, __virtual_aux<_Tp,__is_union_or_class<_Tp>::value >::__value>
+{ };
+#endif
+
+template <typename _Tp>
+struct __is_vtbl : // has virtual table?
+ public integral_constant<bool, __is_union_or_class<_Tp>::value ? (sizeof(__inheritance_aux<_Tp,__is_union_or_class<_Tp>::value>) == sizeof(_Tp)) : false >
+{ };
+
+} // namespace detail
+
+#define __SPEC_(C,T,B) \
+template <> \
+struct C<T> : \
+ public integral_constant<bool, B> \
+{ }
+
+#define __CV_SPEC(C,T,B) \
+__SPEC_(C,T,B); \
+__SPEC_(C,const T,B); \
+__SPEC_(C,volatile T,B); \
+__SPEC_(C,const volatile T,B)
+
+#define __SPEC_1(C,T,B) \
+template <class _Tp> \
+struct C<T> : \
+ public integral_constant<bool, B> \
+{ }
+
+#define __CV_SPEC_1(C,T,B) \
+__SPEC_1(C,T,B); \
+__SPEC_1(C,T const,B); \
+__SPEC_1(C,T volatile,B); \
+__SPEC_1(C,T const volatile,B)
+
+#define __SPEC_2(C,T,B) \
+template <class _Tp1, class _Tp2> \
+struct C<T> : \
+ public integral_constant<bool, B> \
+{ }
+
+#define __CV_SPEC_2(C,T,B) \
+__SPEC_2(C,T,B); \
+__SPEC_2(C,T const,B); \
+__SPEC_2(C,T volatile,B); \
+__SPEC_2(C,T const volatile,B)
+
+// [4.5.1] primary type categories:
+
+template <class _Tp>
+struct is_void :
+ public false_type
+{ };
+
+template <>
+struct is_void<void> :
+ public true_type
+{ };
+
+template <class _Tp>
+struct is_integral :
+ public false_type
+{ };
+
+__CV_SPEC(is_integral,bool,true);
+__CV_SPEC(is_integral,char,true);
+__CV_SPEC(is_integral,signed char,true);
+__CV_SPEC(is_integral,unsigned char,true);
+__CV_SPEC(is_integral,wchar_t,true);
+__CV_SPEC(is_integral,short,true);
+__CV_SPEC(is_integral,unsigned short,true);
+__CV_SPEC(is_integral,int,true);
+__CV_SPEC(is_integral,unsigned int,true);
+__CV_SPEC(is_integral,long,true);
+__CV_SPEC(is_integral,unsigned long,true);
+__CV_SPEC(is_integral,long long,true);
+__CV_SPEC(is_integral,unsigned long long,true);
+
+template <class _Tp>
+struct is_floating_point :
+ public false_type
+{ };
+
+__CV_SPEC(is_floating_point,float,true);
+__CV_SPEC(is_floating_point,double,true);
+__CV_SPEC(is_floating_point,long double,true);
+
+template <class _Tp>
+struct is_array :
+ public false_type
+{ };
+
+template <class _Tp, std::size_t _Sz>
+struct is_array<_Tp[_Sz]> :
+ public true_type
+{ };
+
+template <class _Tp>
+struct is_array<_Tp[]> :
+ public true_type
+{ };
+
+template <class _Tp>
+struct is_pointer :
+ public false_type
+{ };
+
+__CV_SPEC_1(is_pointer,_Tp *,true);
+
+template <class _Tp>
+struct is_lvalue_reference :
+ public false_type
+{ };
+
+template <class _Tp>
+struct is_lvalue_reference<_Tp&> :
+ public true_type
+{ };
+
+template <class _Tp>
+struct is_rvalue_reference :
+ public false_type
+{ };
+
+// template <class _Tp>
+// struct is_rvalue_reference<_Tp&&> :
+// public true_type
+// { };
+
+template <class _Tp>
+struct is_reference :
+ public false_type
+{ };
+
+template <class _Tp>
+struct is_reference<_Tp&> :
+ public true_type
+{ };
+
+template <class _Tp>
+struct is_function :
+ public integral_constant<bool, !(detail::__instance<_Tp>::__value
+ || detail::__is_union_or_class<_Tp>::value
+ || is_reference<_Tp>::value
+ || is_void<_Tp>::value)>
+{ };
+
+template <class _Tp>
+struct is_member_object_pointer :
+ public false_type
+{ };
+
+// _SPEC_FULL2(is_member_object_pointer, _Tp1 _Tp2::*,!is_function<_Tp1>::value);
+
+template <class _Tp1, class _Tp2>
+struct is_member_object_pointer<_Tp1 _Tp2::*> :
+ public integral_constant<bool, !is_function<_Tp1>::value>
+{ };
+
+template <class _Tp1, class _Tp2>
+struct is_member_object_pointer<_Tp1 _Tp2::* const> :
+ public integral_constant<bool, !is_function<_Tp1>::value>
+{ };
+
+template <class _Tp1, class _Tp2>
+struct is_member_object_pointer<_Tp1 _Tp2::* volatile> :
+ public integral_constant<bool, !is_function<_Tp1>::value>
+{ };
+
+template <class _Tp1, class _Tp2>
+struct is_member_object_pointer<_Tp1 _Tp2::* const volatile> :
+ public integral_constant<bool, !is_function<_Tp1>::value>
+{ };
+
+template <class _Tp>
+struct is_member_function_pointer :
+ public false_type
+{ };
+
+// _SPEC_FULL2(is_member_function_pointer,_Tp1 _Tp2::*,is_function<_Tp1>::value);
+
+template <class _Tp1, class _Tp2>
+struct is_member_function_pointer<_Tp1 _Tp2::*> :
+ public integral_constant<bool, is_function<_Tp1>::value>
+{ };
+
+template <class _Tp1, class _Tp2>
+struct is_member_function_pointer<_Tp1 _Tp2::* const> :
+ public integral_constant<bool, is_function<_Tp1>::value>
+{ };
+
+template <class _Tp1, class _Tp2>
+struct is_member_function_pointer<_Tp1 _Tp2::* volatile> :
+ public integral_constant<bool, is_function<_Tp1>::value>
+{ };
+
+template <class _Tp1, class _Tp2>
+struct is_member_function_pointer<_Tp1 _Tp2::* const volatile> :
+ public integral_constant<bool, is_function<_Tp1>::value>
+{ };
+
+template <class _Tp>
+struct is_member_pointer :
+ public integral_constant<bool, (is_member_object_pointer<_Tp>::value || is_member_function_pointer<_Tp>::value)>
+{ };
+
+// 4.5.2 composite type categories
+
+template <class _Tp>
+struct is_arithmetic :
+ public integral_constant<bool, (is_integral<_Tp>::value || is_floating_point<_Tp>::value)>
+{ };
+
+template <class _Tp>
+struct is_fundamental :
+ public integral_constant<bool, (is_arithmetic<_Tp>::value || is_void<_Tp>::value)>
+{ };
+
+// [4.5.1] primary type categories (continued):
+
+template <class _Tp>
+struct is_enum :
+ public integral_constant<bool, !(is_fundamental<_Tp>::value
+ || is_array<_Tp>::value
+ || is_pointer<_Tp>::value
+ || is_reference<_Tp>::value
+ || is_member_pointer<_Tp>::value
+ || is_function<_Tp>::value
+ || detail::__is_union_or_class<_Tp>::value) >
+{ };
+
+template <class T>
+struct is_union
+{ };
+
+template <class T>
+struct is_class
+{ };
+
+// is_function (above)
+
+// 4.5.2 composite type categories (continued)
+
+// is_arithmetic (above)
+// is_fundamental (above)
+
+template <class _Tp>
+struct is_object :
+ public integral_constant<bool, (is_arithmetic<_Tp>::value ||
+ is_array<_Tp>::value ||
+ is_pointer<_Tp>::value ||
+ is_member_pointer<_Tp>::value ||
+ detail::__is_union_or_class<_Tp>::value)>
+{ };
+
+template <class _Tp>
+struct is_scalar :
+ public integral_constant<bool, (is_arithmetic<_Tp>::value
+ || is_enum<_Tp>::value
+ || is_pointer<_Tp>::value
+ || is_member_pointer<_Tp>::value)>
+{ };
+
+template <class _Tp>
+struct is_compound :
+ public integral_constant<bool, !is_fundamental<_Tp>::value>
+{ };
+
+// is_member_pointer
+
+// 4.5.3 type properties:
+
+template <class _Tp>
+struct is_const :
+ public false_type
+{ };
+
+template <class _Tp>
+struct is_const<_Tp const> :
+ public true_type
+{ };
+
+template <class _Tp>
+struct is_volatile :
+ public false_type
+{ };
+
+template <class _Tp>
+struct is_volatile<_Tp volatile> :
+ public true_type
+{ };
+
+
+// 4.7.3 array modifications:
+
+template <class _Tp>
+struct remove_extent
+{
+ typedef _Tp type;
+};
+
+template <class _Tp, std::size_t _Sz>
+struct remove_extent<_Tp[_Sz]>
+{
+ typedef _Tp type;
+};
+
+template <class _Tp>
+struct remove_extent<_Tp[]>
+{
+ typedef _Tp type;
+};
+
+template <class _Tp>
+struct remove_all_extents
+{
+ typedef _Tp type;
+};
+
+template <class _Tp, std::size_t _Size>
+struct remove_all_extents<_Tp[_Size]>
+{
+ typedef typename remove_all_extents<_Tp>::type type;
+};
+
+template<typename _Tp>
+struct remove_all_extents<_Tp[]>
+{
+ typedef typename remove_all_extents<_Tp>::type type;
+};
+
+// 4.5.3 type properties (continued):
+
+template <class _Tp>
+struct is_trivial :
+ public integral_constant<bool, (is_void<_Tp>::value
+ || is_scalar<typename remove_all_extents<_Tp>::type>::value)>
+{ };
+
+template <class _Tp>
+struct is_standard_layout :
+ public integral_constant<bool, (is_void<_Tp>::value
+ || is_scalar<typename remove_all_extents<_Tp>::type>::value)>
+{ };
+
+template <class _Tp>
+struct is_pod :
+ public integral_constant<bool, (is_void<_Tp>::value
+ || is_scalar<typename remove_all_extents<_Tp>::type>::value)>
+{ };
+
+template<typename _Tp>
+struct is_empty
+ : public integral_constant<bool, (detail::__is_union_or_class<_Tp>::value
+ && (sizeof(detail::__empty<_Tp>) == sizeof(_Tp)))>
+{ };
+
+// is_polimorphic
+// is_abstract
+
+template <class _Tp>
+struct has_trivial_constructor :
+ public integral_constant<bool, is_pod<_Tp>::value>
+{ };
+
+template <class _Tp>
+struct has_trivial_copy :
+ public integral_constant<bool, is_pod<_Tp>::value>
+{ };
+
+template <class _Tp>
+struct has_trivial_assign :
+ public integral_constant<bool, is_pod<_Tp>::value>
+{ };
+
+template <class _Tp>
+struct has_trivial_destructor :
+ public integral_constant<bool, is_pod<_Tp>::value>
+{ };
+
+template <class _Tp>
+struct has_nothrow_constructor :
+ public integral_constant<bool, is_pod<_Tp>::value>
+{ };
+
+template <class _Tp>
+struct has_nothrow_copy :
+ public integral_constant<bool, is_pod<_Tp>::value>
+{ };
+
+template <class _Tp>
+struct has_nothrow_assign :
+ public integral_constant<bool, is_pod<_Tp>::value>
+{ };
+
+template <class _Tp>
+struct has_virtual_destructor :
+ public false_type
+{ };
+
+template <class _Tp>
+struct is_signed :
+ public false_type
+{ };
+
+__CV_SPEC(is_signed,signed char,true);
+__CV_SPEC(is_signed,short,true);
+__CV_SPEC(is_signed,int,true);
+__CV_SPEC(is_signed,long,true);
+__CV_SPEC(is_signed,long long,true);
+
+template <class _Tp>
+struct is_unsigned :
+ public false_type
+{ };
+
+__CV_SPEC(is_unsigned,unsigned char,true);
+__CV_SPEC(is_unsigned,unsigned short,true);
+__CV_SPEC(is_unsigned,unsigned int,true);
+__CV_SPEC(is_unsigned,unsigned long,true);
+__CV_SPEC(is_unsigned,unsigned long long,true);
+
+// alignment_of
+// rank
+// extent
+
+// 4.6 type relations:
+
+template <class _Tp1, class _Tp2>
+struct is_same :
+ public false_type
+{ };
+
+template <class _Tp>
+struct is_same<_Tp, _Tp> :
+ public true_type
+{ };
+
+// is_base_of
+// is_convertible
+
+// 4.7.1 const-volatile modifications
+
+template <class _Tp>
+struct remove_const
+{
+ typedef _Tp type;
+};
+
+template <class _Tp>
+struct remove_const<_Tp const>
+{
+ typedef _Tp type;
+};
+
+template <class _Tp>
+struct remove_volatile
+{
+ typedef _Tp type;
+};
+
+template <class _Tp>
+struct remove_volatile<_Tp volatile>
+{
+ typedef _Tp type;
+};
+
+template <class _Tp>
+struct remove_cv
+{
+ typedef typename remove_const<typename remove_volatile<_Tp>::type>::type type;
+};
+
+template <class _Tp>
+struct add_const
+{
+ typedef _Tp const type;
+};
+
+template <class _Tp>
+struct add_volatile
+{
+ typedef _Tp volatile type;
+};
+
+template <class _Tp>
+struct add_cv
+{
+ typedef typename add_const<typename add_volatile<_Tp>::type>::type type;
+};
+
+// 4.7.2 reference modifications:
+
+template <class _Tp>
+struct remove_reference
+{
+ typedef _Tp type;
+};
+
+template <class _Tp>
+struct remove_reference<_Tp&>
+{
+ typedef _Tp type;
+};
+
+template <class _Tp>
+struct add_reference
+{
+ typedef _Tp& type;
+};
+
+template <class _Tp>
+struct add_reference<_Tp&>
+{
+ typedef _Tp& type;
+};
+
+// 4.7.3 array modifications (see above)
+
+// 4.7.4 pointer modifications:
+
+template <class _Tp>
+struct remove_pointer
+{
+ typedef _Tp type;
+};
+
+template <class _Tp>
+struct remove_pointer<_Tp *>
+{
+ typedef _Tp type;
+};
+
+template <class _Tp>
+struct remove_pointer<_Tp * const>
+{
+ typedef _Tp type;
+};
+
+template <class _Tp>
+struct remove_pointer<_Tp * volatile>
+{
+ typedef _Tp type;
+};
+
+template <class _Tp>
+struct remove_pointer<_Tp * const volatile>
+{
+ typedef _Tp type;
+};
+
+template <class _Tp>
+struct add_pointer
+{
+ typedef typename remove_reference<_Tp>::type * type;
+};
+
+// 20.5.7 other transformations:
+
+// template <std::size_t Len, std::size_t Align> struct aligned_storage;
+// template <std::size_t Len, class... Types> struct aligned_union;
+
+namespace detail {
+
+template <bool,class _U>
+struct _decay_aux2
+{
+ typedef typename remove_cv<_U>::type type;
+};
+
+template <class _U>
+struct _decay_aux2<true,_U>
+{
+ typedef typename add_pointer<_U>::type type;
+};
+
+template <bool, class _U>
+struct _decay_aux1
+{
+ typedef typename _decay_aux2<is_function<_U>::value,_U>::type type;
+};
+
+template <class _U>
+struct _decay_aux1<true,_U>
+{
+ typedef typename remove_extent<_U>::type* type;
+};
+
+} // namespace detail
+
+template <class _Tp>
+class decay
+{
+ private:
+ typedef typename remove_reference<_Tp>::type _U;
+
+ public:
+ typedef typename detail::_decay_aux1<is_array<_U>::value,_U>::type type;
+};
+
+template <bool, class _Tp = void>
+struct enable_if
+{
+};
+
+template <class _Tp>
+struct enable_if<true,_Tp>
+{
+ typedef _Tp type;
+};
+
+template <bool, class _Tp1, class _Tp2>
+struct conditional
+{
+ typedef _Tp2 type;
+};
+
+template <class _Tp1, class _Tp2>
+struct conditional<true,_Tp1,_Tp2>
+{
+ typedef _Tp1 type;
+};
+
+// template <class... _Tp> struct common_type;
+
+#undef __CV_SPEC
+#undef __SPEC_
+#undef __CV_SPEC_1
+#undef __SPEC_1
+#undef __CV_SPEC_2
+#undef __SPEC_2
+
+_STLP_END_NAMESPACE // tr1
+
+_STLP_END_NAMESPACE
+
+// # else // __GLIBCXX__ && (__GNUC__ >= 4) && !STLPORT
+// # include <tr1/type_traits>
+// # endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x3)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif // __STLP_TYPE_TRAITS
+
diff --git a/sources/android/stlport/stlport/typeinfo b/sources/android/stlport/stlport/typeinfo
new file mode 100644
index 0000000..269123f
--- /dev/null
+++ b/sources/android/stlport/stlport/typeinfo
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_TYPEINFO
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x473
+# include <stl/_prolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x473) && !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+# define _STLP_TYPEINFO
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x473) && !defined (_STLP_DONT_POP_HEADER_ID)
+# ifndef _STLP_INTERNAL_TYPEINFO
+# include <stl/_typeinfo.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x473) || defined (_STLP_DONT_POP_HEADER_ID) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <typeinfo>
+# else
+# include _STLP_NATIVE_CPP_RUNTIME_HEADER(typeinfo)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x473)
+# if !defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+#endif
+
+#endif
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/typeinfo.h b/sources/android/stlport/stlport/typeinfo.h
new file mode 100644
index 0000000..0cea71a
--- /dev/null
+++ b/sources/android/stlport/stlport/typeinfo.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+// DMC has hardcoded inclusion of typeinfo.h at the begining of any translation unit.
+// So inclusion of this header will directly reference the native header. This is not
+// a problem as typeinfo.h is neither a C nor C++ Standard header, this header should
+// never be used in user code.
+#if defined (__DMC__)
+// We define _STLP_OUTERMOST_HEADER_ID to signal to other STLport headers that inclusion
+// is done from native typeinfo.h (see exception header).
+# define _STLP_OUTERMOST_HEADER_ID 0x874
+# include <../include/typeinfo.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#else
+# ifndef _STLP_OLDSTD_typeinfo
+# define _STLP_OLDSTD_typeinfo
+
+# ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x874
+# include <stl/_prolog.h>
+# endif
+
+# ifndef _STLP_NO_TYPEINFO
+
+# if defined (__GNUC__)
+# undef _STLP_OLDSTD_typeinfo
+# include <typeinfo>
+# define _STLP_OLDSTD_typeinfo
+# else
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <typeinfo.h>
+# elif !defined (__BORLANDC__) || (__BORLANDC__ < 0x580)
+# include _STLP_NATIVE_CPP_RUNTIME_HEADER(typeinfo.h)
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(typeinfo.h)
+# endif
+# if defined (__BORLANDC__) && (__BORLANDC__ >= 0x580) || \
+ defined (__DMC__)
+using std::type_info;
+using std::bad_typeid;
+using std::bad_cast;
+# endif
+# endif
+
+// if <typeinfo> already included, do not import anything
+
+# if defined (_STLP_USE_OWN_NAMESPACE) && !(defined (_STLP_TYPEINFO) && !defined (_STLP_NO_NEW_NEW_HEADER))
+
+_STLP_BEGIN_NAMESPACE
+
+using /*_STLP_VENDOR_EXCEPT_STD */ :: type_info;
+# if !(defined(__MRC__) || (defined(__SC__) && !defined(__DMC__)))
+using /* _STLP_VENDOR_EXCEPT_STD */ :: bad_typeid;
+# endif
+
+using /* _STLP_VENDOR_EXCEPT_STD */ :: bad_cast;
+
+_STLP_END_NAMESPACE
+
+# endif /* _STLP_OWN_NAMESPACE */
+
+# endif /* _STLP_NO_TYPEINFO */
+
+# if (_STLP_OUTERMOST_HEADER_ID == 0x874)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# endif
+
+# endif /* _STLP_OLDSTD_typeinfo */
+
+#endif /* __DMC__ */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/unordered_map b/sources/android/stlport/stlport/unordered_map
new file mode 100644
index 0000000..09fa0d2
--- /dev/null
+++ b/sources/android/stlport/stlport/unordered_map
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2004,2005
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_UNORDERED_MAP
+#define _STLP_UNORDERED_MAP
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x4030
+# include <stl/_prolog.h>
+#endif
+
+#ifdef _STLP_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <stl/_unordered_map.h>
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x4030)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_UNORDERED_MAP */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/unordered_set b/sources/android/stlport/stlport/unordered_set
new file mode 100644
index 0000000..14de437
--- /dev/null
+++ b/sources/android/stlport/stlport/unordered_set
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2004,2005
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_UNORDERED_SET
+#define _STLP_UNORDERED_SET
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x4031
+# include <stl/_prolog.h>
+#endif
+
+#ifdef _STLP_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <stl/_unordered_set.h>
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x4031)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_UNORDERED_SET */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/using/cstring b/sources/android/stlport/stlport/using/cstring
new file mode 100644
index 0000000..42c5660
--- /dev/null
+++ b/sources/android/stlport/stlport/using/cstring
@@ -0,0 +1,60 @@
+using _STLP_VENDOR_CSTD::size_t;
+
+#if !defined (_STLP_NO_CSTD_FUNCTION_IMPORTS)
+# if defined (__MSL__) && __MC68K__ && !_No_BlockMove && __dest_os == __mac_os
+# undef memcpy
+# undef memmove
+inline void* memcpy(void* dst, const void* src, size_t len)
+{ return _STLP_VENDOR_CSTD::__memcpy(dst, src, len); }
+inline void* memmove(void* dst, const void* src, size_t len)
+{ return _STLP_VENDOR_CSTD::__memmove(dst, src, len); }
+# else
+using _STLP_VENDOR_CSTD::memmove;
+using _STLP_VENDOR_CSTD::memcpy;
+# endif
+
+# if !defined (_STLP_WCE)
+// these functions just don't exist on Windows CE
+using _STLP_VENDOR_CSTD::strcoll;
+using _STLP_VENDOR_CSTD::strerror;
+using _STLP_VENDOR_CSTD::strxfrm;
+# endif
+
+# if defined (__BORLANDC__)
+extern "C++" {
+# endif
+using _STLP_VENDOR_CSTD::memchr;
+using _STLP_VENDOR_CSTD::strchr;
+using _STLP_VENDOR_CSTD::strpbrk;
+using _STLP_VENDOR_CSTD::strrchr;
+using _STLP_VENDOR_CSTD::strstr;
+# if defined (__BORLANDC__)
+}
+# endif
+
+using _STLP_VENDOR_CSTD::memcmp;
+using _STLP_VENDOR_CSTD::memset;
+
+using _STLP_VENDOR_CSTD::strcat;
+
+# if !defined (strcmp) || !defined (__BORLANDC__)
+using _STLP_VENDOR_CSTD::strcmp;
+# else
+using ::strcmp;
+# endif
+
+# if !defined (strcpy) || !defined (__BORLANDC__)
+using _STLP_VENDOR_CSTD::strcpy;
+# else
+using ::strcpy;
+# endif
+using _STLP_VENDOR_CSTD::strcspn;
+using _STLP_VENDOR_CSTD::strlen;
+using _STLP_VENDOR_CSTD::strncat;
+using _STLP_VENDOR_CSTD::strncmp;
+
+using _STLP_VENDOR_CSTD::strncpy;
+using _STLP_VENDOR_CSTD::strspn;
+
+using _STLP_VENDOR_CSTD::strtok;
+#endif /* _STLP_NO_CSTD_FUNCTION_IMPORTS */
diff --git a/sources/android/stlport/stlport/using/export b/sources/android/stlport/stlport/using/export
new file mode 100644
index 0000000..2d3afcd
--- /dev/null
+++ b/sources/android/stlport/stlport/using/export
@@ -0,0 +1,12 @@
+cstring
+fstream
+iomanip
+ios
+iosfwd
+iostream
+istream
+locale
+ostream
+sstream
+streambuf
+strstream
diff --git a/sources/android/stlport/stlport/using/fstream b/sources/android/stlport/stlport/using/fstream
new file mode 100644
index 0000000..e79e048
--- /dev/null
+++ b/sources/android/stlport/stlport/using/fstream
@@ -0,0 +1,19 @@
+#ifdef _STLP_BROKEN_USING_DIRECTIVE
+using namespace _STLP_STD;
+#else
+using _STLP_NEW_IO_NAMESPACE::basic_filebuf;
+using _STLP_NEW_IO_NAMESPACE::filebuf;
+using _STLP_NEW_IO_NAMESPACE::basic_ifstream;
+using _STLP_NEW_IO_NAMESPACE::basic_ofstream;
+using _STLP_NEW_IO_NAMESPACE::ifstream;
+using _STLP_NEW_IO_NAMESPACE::ofstream;
+using _STLP_NEW_IO_NAMESPACE::basic_fstream;
+using _STLP_NEW_IO_NAMESPACE::fstream;
+
+# ifndef _STLP_NO_WIDE_STREAMS
+using _STLP_NEW_IO_NAMESPACE::wofstream;
+using _STLP_NEW_IO_NAMESPACE::wfilebuf;
+using _STLP_NEW_IO_NAMESPACE::wifstream;
+using _STLP_NEW_IO_NAMESPACE::wfstream;
+# endif
+#endif
diff --git a/sources/android/stlport/stlport/using/h/fstream.h b/sources/android/stlport/stlport/using/h/fstream.h
new file mode 100644
index 0000000..6600568
--- /dev/null
+++ b/sources/android/stlport/stlport/using/h/fstream.h
@@ -0,0 +1,4 @@
+using ::streambuf;
+using ::ifstream;
+using ::ofstream;
+using ::fstream;
diff --git a/sources/android/stlport/stlport/using/h/iomanip.h b/sources/android/stlport/stlport/using/h/iomanip.h
new file mode 100644
index 0000000..99e48d9
--- /dev/null
+++ b/sources/android/stlport/stlport/using/h/iomanip.h
@@ -0,0 +1,6 @@
+using ::setiosflags;
+using ::resetiosflags;
+// using ::setbase;
+using ::setfill;
+using ::setprecision;
+using ::setw;
diff --git a/sources/android/stlport/stlport/using/h/iostream.h b/sources/android/stlport/stlport/using/h/iostream.h
new file mode 100644
index 0000000..e85f4e2
--- /dev/null
+++ b/sources/android/stlport/stlport/using/h/iostream.h
@@ -0,0 +1,24 @@
+using _STLP_OLD_IO_NAMESPACE::istream;
+using _STLP_OLD_IO_NAMESPACE::ostream;
+
+/* HP aCC include files re-define these when THREAD_SAFE */
+#if !defined(cin)
+using _STLP_OLD_IO_NAMESPACE::cin;
+#endif
+#if !defined(cout)
+using _STLP_OLD_IO_NAMESPACE::cout;
+#endif
+#if !defined(cerr)
+using _STLP_OLD_IO_NAMESPACE::cerr;
+#endif
+#if !defined(clog)
+using _STLP_OLD_IO_NAMESPACE::clog;
+#endif
+
+using _STLP_OLD_IO_NAMESPACE::endl;
+using _STLP_OLD_IO_NAMESPACE::ends;
+
+using _STLP_OLD_IO_NAMESPACE::ios;
+using _STLP_OLD_IO_NAMESPACE::flush;
+
+// using _STLP_OLD_IO_NAMESPACE::ws;
diff --git a/sources/android/stlport/stlport/using/h/ostream.h b/sources/android/stlport/stlport/using/h/ostream.h
new file mode 100644
index 0000000..6ba3f88
--- /dev/null
+++ b/sources/android/stlport/stlport/using/h/ostream.h
@@ -0,0 +1,6 @@
+using _STLP_OLD_IO_NAMESPACE::ostream;
+using _STLP_OLD_IO_NAMESPACE::endl;
+using _STLP_OLD_IO_NAMESPACE::ends;
+using _STLP_OLD_IO_NAMESPACE::flush;
+
+// using _STLP_OLD_IO_NAMESPACE::ws;
diff --git a/sources/android/stlport/stlport/using/h/streambuf.h b/sources/android/stlport/stlport/using/h/streambuf.h
new file mode 100644
index 0000000..459de3d
--- /dev/null
+++ b/sources/android/stlport/stlport/using/h/streambuf.h
@@ -0,0 +1 @@
+using ::streambuf;
diff --git a/sources/android/stlport/stlport/using/h/strstream.h b/sources/android/stlport/stlport/using/h/strstream.h
new file mode 100644
index 0000000..a7d9f11
--- /dev/null
+++ b/sources/android/stlport/stlport/using/h/strstream.h
@@ -0,0 +1,4 @@
+using _STLP_OLD_IO_NAMESPACE::strstreambuf;
+using _STLP_OLD_IO_NAMESPACE::istrstream;
+using _STLP_OLD_IO_NAMESPACE::ostrstream;
+using _STLP_OLD_IO_NAMESPACE::strstream;
diff --git a/sources/android/stlport/stlport/using/iomanip b/sources/android/stlport/stlport/using/iomanip
new file mode 100644
index 0000000..8a7c792
--- /dev/null
+++ b/sources/android/stlport/stlport/using/iomanip
@@ -0,0 +1,6 @@
+using _STLP_NEW_IO_NAMESPACE::setiosflags;
+using _STLP_NEW_IO_NAMESPACE::resetiosflags;
+using _STLP_NEW_IO_NAMESPACE::setbase;
+using _STLP_NEW_IO_NAMESPACE::setfill;
+using _STLP_NEW_IO_NAMESPACE::setprecision;
+using _STLP_NEW_IO_NAMESPACE::setw;
diff --git a/sources/android/stlport/stlport/using/ios b/sources/android/stlport/stlport/using/ios
new file mode 100644
index 0000000..d89b495
--- /dev/null
+++ b/sources/android/stlport/stlport/using/ios
@@ -0,0 +1,41 @@
+# ifdef _STLP_BROKEN_USING_DIRECTIVE
+using namespace _STLP_NEW_IO_NAMESPACE;
+# else
+
+using _STLP_NEW_IO_NAMESPACE::ios;
+using _STLP_NEW_IO_NAMESPACE::streamoff;
+using _STLP_NEW_IO_NAMESPACE::streamsize;
+
+using _STLP_NEW_IO_NAMESPACE::ios_base;
+using _STLP_NEW_IO_NAMESPACE::basic_ios;
+
+// _lib.std.ios.manip_, manipulators:
+using _STLP_NEW_IO_NAMESPACE::boolalpha;
+using _STLP_NEW_IO_NAMESPACE::noboolalpha;
+using _STLP_NEW_IO_NAMESPACE::showbase;
+using _STLP_NEW_IO_NAMESPACE::noshowbase;
+using _STLP_NEW_IO_NAMESPACE::showpoint;
+using _STLP_NEW_IO_NAMESPACE::noshowpoint;
+using _STLP_NEW_IO_NAMESPACE::showpos;
+using _STLP_NEW_IO_NAMESPACE::noshowpos;
+using _STLP_NEW_IO_NAMESPACE::skipws;
+using _STLP_NEW_IO_NAMESPACE::noskipws;
+using _STLP_NEW_IO_NAMESPACE::uppercase;
+using _STLP_NEW_IO_NAMESPACE::nouppercase;
+
+// _lib.adjustfield.manip_ adjustfield:
+using _STLP_NEW_IO_NAMESPACE::internal;
+using _STLP_NEW_IO_NAMESPACE::left;
+using _STLP_NEW_IO_NAMESPACE::right;
+
+// _lib.basefield.manip_ basefield:
+using _STLP_NEW_IO_NAMESPACE::dec;
+using _STLP_NEW_IO_NAMESPACE::hex;
+using _STLP_NEW_IO_NAMESPACE::oct;
+
+// _lib.floatfield.manip_ floatfield:
+using _STLP_NEW_IO_NAMESPACE::fixed;
+using _STLP_NEW_IO_NAMESPACE::scientific;
+
+# endif /* _STLP_BROKEN_USING_DIRECTIVE */
+
diff --git a/sources/android/stlport/stlport/using/iosfwd b/sources/android/stlport/stlport/using/iosfwd
new file mode 100644
index 0000000..b564e81
--- /dev/null
+++ b/sources/android/stlport/stlport/using/iosfwd
@@ -0,0 +1,54 @@
+# if defined (_STLP_USE_NEW_IOSTREAMS)
+using _STLP_NEW_IO_NAMESPACE::char_traits;
+using _STLP_NEW_IO_NAMESPACE::basic_ios;
+using _STLP_NEW_IO_NAMESPACE::basic_streambuf;
+using _STLP_NEW_IO_NAMESPACE::basic_istream;
+using _STLP_NEW_IO_NAMESPACE::basic_ostream;
+using _STLP_NEW_IO_NAMESPACE::basic_iostream;
+using _STLP_NEW_IO_NAMESPACE::basic_stringbuf;
+using _STLP_NEW_IO_NAMESPACE::basic_istringstream;
+using _STLP_NEW_IO_NAMESPACE::basic_ostringstream;
+using _STLP_NEW_IO_NAMESPACE::basic_stringstream;
+using _STLP_NEW_IO_NAMESPACE::basic_filebuf;
+using _STLP_NEW_IO_NAMESPACE::basic_ifstream;
+using _STLP_NEW_IO_NAMESPACE::basic_ofstream;
+using _STLP_NEW_IO_NAMESPACE::basic_fstream;
+using _STLP_NEW_IO_NAMESPACE::fpos;
+using _STLP_NEW_IO_NAMESPACE::istreambuf_iterator;
+using _STLP_NEW_IO_NAMESPACE::ostreambuf_iterator;
+using _STLP_NEW_IO_NAMESPACE::stringbuf;
+using _STLP_NEW_IO_NAMESPACE::istringstream;
+using _STLP_NEW_IO_NAMESPACE::ostringstream;
+using _STLP_NEW_IO_NAMESPACE::stringstream;
+# endif
+
+using _STLP_NEW_IO_NAMESPACE::ios;
+using _STLP_NEW_IO_NAMESPACE::streambuf;
+using _STLP_NEW_IO_NAMESPACE::istream;
+using _STLP_NEW_IO_NAMESPACE::ostream;
+using _STLP_NEW_IO_NAMESPACE::iostream;
+
+using _STLP_NEW_IO_NAMESPACE::filebuf;
+using _STLP_NEW_IO_NAMESPACE::ifstream;
+using _STLP_NEW_IO_NAMESPACE::ofstream;
+using _STLP_NEW_IO_NAMESPACE::fstream;
+
+using _STLP_NEW_IO_NAMESPACE::streampos;
+using _STLP_NEW_IO_NAMESPACE::streamoff;
+
+# if !defined (_STLP_NO_WIDE_STREAMS)
+using _STLP_NEW_IO_NAMESPACE::wios;
+using _STLP_NEW_IO_NAMESPACE::wstreambuf;
+using _STLP_NEW_IO_NAMESPACE::wistream;
+using _STLP_NEW_IO_NAMESPACE::wostream;
+using _STLP_NEW_IO_NAMESPACE::wiostream;
+using _STLP_NEW_IO_NAMESPACE::wstringbuf;
+using _STLP_NEW_IO_NAMESPACE::wistringstream;
+using _STLP_NEW_IO_NAMESPACE::wostringstream;
+using _STLP_NEW_IO_NAMESPACE::wstringstream;
+using _STLP_NEW_IO_NAMESPACE::wfilebuf;
+using _STLP_NEW_IO_NAMESPACE::wifstream;
+using _STLP_NEW_IO_NAMESPACE::wofstream;
+using _STLP_NEW_IO_NAMESPACE::wfstream;
+using _STLP_NEW_IO_NAMESPACE::wstreampos;
+# endif
diff --git a/sources/android/stlport/stlport/using/iostream b/sources/android/stlport/stlport/using/iostream
new file mode 100644
index 0000000..6169afb
--- /dev/null
+++ b/sources/android/stlport/stlport/using/iostream
@@ -0,0 +1,14 @@
+
+# include <using/istream>
+
+using _STLP_VENDOR_STD::cin;
+using _STLP_VENDOR_STD::cout;
+using _STLP_VENDOR_STD::cerr;
+using _STLP_VENDOR_STD::clog;
+
+# if ! defined (_STLP_NO_WIDE_STREAMS)
+using _STLP_VENDOR_STD::wcin;
+using _STLP_VENDOR_STD::wcout;
+using _STLP_VENDOR_STD::wcerr;
+using _STLP_VENDOR_STD::wclog;
+# endif
diff --git a/sources/android/stlport/stlport/using/istream b/sources/android/stlport/stlport/using/istream
new file mode 100644
index 0000000..baf10d2
--- /dev/null
+++ b/sources/android/stlport/stlport/using/istream
@@ -0,0 +1,16 @@
+# include <using/ostream>
+
+using _STLP_NEW_IO_NAMESPACE::basic_istream;
+using _STLP_NEW_IO_NAMESPACE::basic_iostream;
+
+using _STLP_NEW_IO_NAMESPACE::istream;
+using _STLP_NEW_IO_NAMESPACE::iostream;
+
+# if !defined (_STLP_NO_NATIVE_WIDE_STREAMS)
+using _STLP_NEW_IO_NAMESPACE::wistream;
+using _STLP_NEW_IO_NAMESPACE::wiostream;
+# endif
+
+#if !(defined (_STLP_MSVC) && (_STLP_MSVC < 1200))
+using _STLP_NEW_IO_NAMESPACE::ws;
+#endif
diff --git a/sources/android/stlport/stlport/using/locale b/sources/android/stlport/stlport/using/locale
new file mode 100644
index 0000000..aa99b5b
--- /dev/null
+++ b/sources/android/stlport/stlport/using/locale
@@ -0,0 +1,65 @@
+#if !defined(_STLP_NO_IMPORT_LOCALE)
+
+// from <cwchar>
+#if !defined (_STLP_NO_MBSTATE_T)
+using _STLP_VENDOR_MB_NAMESPACE::mbstate_t;
+#endif
+
+// _lib.locale_, locale:
+using _STLP_NEW_IO_NAMESPACE::locale;
+using _STLP_NEW_IO_NAMESPACE::use_facet;
+using _STLP_NEW_IO_NAMESPACE::has_facet;
+
+// _lib.locale.convenience_, convenience interfaces:
+using _STLP_NEW_IO_NAMESPACE::isspace;
+using _STLP_NEW_IO_NAMESPACE::isprint;
+using _STLP_NEW_IO_NAMESPACE::iscntrl;
+using _STLP_NEW_IO_NAMESPACE::isupper;
+using _STLP_NEW_IO_NAMESPACE::islower;
+using _STLP_NEW_IO_NAMESPACE::isalpha;
+using _STLP_NEW_IO_NAMESPACE::isdigit;
+using _STLP_NEW_IO_NAMESPACE::ispunct;
+using _STLP_NEW_IO_NAMESPACE::isxdigit;
+using _STLP_NEW_IO_NAMESPACE::isalnum;
+using _STLP_NEW_IO_NAMESPACE::isgraph;
+using _STLP_NEW_IO_NAMESPACE::toupper;
+using _STLP_NEW_IO_NAMESPACE::tolower;
+
+// _lib.category.ctype_ and _lib.facet.ctype.special_, ctype:
+using _STLP_NEW_IO_NAMESPACE::ctype_base;
+using _STLP_NEW_IO_NAMESPACE::ctype;
+using _STLP_NEW_IO_NAMESPACE::ctype_byname;
+using _STLP_NEW_IO_NAMESPACE::codecvt_base;
+using _STLP_NEW_IO_NAMESPACE::codecvt;
+using _STLP_NEW_IO_NAMESPACE::codecvt_byname;
+
+// _lib.category.numeric_ and _lib.facet.numpunct_, numeric:
+using _STLP_NEW_IO_NAMESPACE::num_get;
+using _STLP_NEW_IO_NAMESPACE::num_put;
+using _STLP_NEW_IO_NAMESPACE::numpunct;
+using _STLP_NEW_IO_NAMESPACE::numpunct_byname;
+
+// _lib.category.collate_, collation:
+using _STLP_NEW_IO_NAMESPACE::collate;
+using _STLP_NEW_IO_NAMESPACE::collate_byname;
+
+// _lib.category.time_, date and time:
+using _STLP_NEW_IO_NAMESPACE::time_base;
+using _STLP_NEW_IO_NAMESPACE::time_get;
+using _STLP_NEW_IO_NAMESPACE::time_get_byname;
+using _STLP_NEW_IO_NAMESPACE::time_put;
+using _STLP_NEW_IO_NAMESPACE::time_put_byname;
+
+// _lib.category.monetary_, money:
+using _STLP_NEW_IO_NAMESPACE::money_base;
+using _STLP_NEW_IO_NAMESPACE::money_get;
+using _STLP_NEW_IO_NAMESPACE::money_put;
+using _STLP_NEW_IO_NAMESPACE::moneypunct;
+using _STLP_NEW_IO_NAMESPACE::moneypunct_byname;
+
+#if !defined (_STLP_OWN_IOSTREAMS) && !defined (_STLP_NO_NATIVE_MESSAGE_FACET)
+using _STLP_NEW_IO_NAMESPACE::messages_base;
+using _STLP_NEW_IO_NAMESPACE::messages;
+using _STLP_NEW_IO_NAMESPACE::messages_byname;
+#endif // _MSL_NO_MESSAGE_FACET
+#endif /* !defined(_STLP_NO_IMPORT_LOCALE) */
diff --git a/sources/android/stlport/stlport/using/ostream b/sources/android/stlport/stlport/using/ostream
new file mode 100644
index 0000000..162b32d
--- /dev/null
+++ b/sources/android/stlport/stlport/using/ostream
@@ -0,0 +1,10 @@
+using _STLP_NEW_IO_NAMESPACE::basic_ostream;
+using _STLP_NEW_IO_NAMESPACE::ostream;
+
+# ifndef _STLP_NO_WIDE_STREAMS
+using _STLP_NEW_IO_NAMESPACE::wostream;
+# endif
+
+using _STLP_NEW_IO_NAMESPACE::endl;
+using _STLP_NEW_IO_NAMESPACE::ends;
+using _STLP_NEW_IO_NAMESPACE::flush;
diff --git a/sources/android/stlport/stlport/using/sstream b/sources/android/stlport/stlport/using/sstream
new file mode 100644
index 0000000..925c37e
--- /dev/null
+++ b/sources/android/stlport/stlport/using/sstream
@@ -0,0 +1,16 @@
+using _STLP_NEW_IO_NAMESPACE::basic_stringbuf;
+using _STLP_NEW_IO_NAMESPACE::stringbuf;
+
+using _STLP_NEW_IO_NAMESPACE::basic_istringstream;
+using _STLP_NEW_IO_NAMESPACE::basic_ostringstream;
+using _STLP_NEW_IO_NAMESPACE::basic_stringstream;
+using _STLP_NEW_IO_NAMESPACE::istringstream;
+using _STLP_NEW_IO_NAMESPACE::ostringstream;
+using _STLP_NEW_IO_NAMESPACE::stringstream;
+
+#ifndef _STLP_NO_WIDE_STREAMS
+using _STLP_NEW_IO_NAMESPACE::wstringbuf;
+using _STLP_NEW_IO_NAMESPACE::wistringstream;
+using _STLP_NEW_IO_NAMESPACE::wostringstream;
+using _STLP_NEW_IO_NAMESPACE::wstringstream;
+#endif
diff --git a/sources/android/stlport/stlport/using/streambuf b/sources/android/stlport/stlport/using/streambuf
new file mode 100644
index 0000000..308241d
--- /dev/null
+++ b/sources/android/stlport/stlport/using/streambuf
@@ -0,0 +1,5 @@
+using _STLP_NEW_IO_NAMESPACE::basic_streambuf;
+using _STLP_NEW_IO_NAMESPACE::streambuf;
+#ifndef _STLP_NO_WIDE_STREAMS
+using _STLP_NEW_IO_NAMESPACE::wstreambuf;
+# endif
diff --git a/sources/android/stlport/stlport/using/strstream b/sources/android/stlport/stlport/using/strstream
new file mode 100644
index 0000000..eb26ac1
--- /dev/null
+++ b/sources/android/stlport/stlport/using/strstream
@@ -0,0 +1,4 @@
+using _STLP_NEW_IO_NAMESPACE::strstreambuf;
+using _STLP_NEW_IO_NAMESPACE::istrstream;
+using _STLP_NEW_IO_NAMESPACE::ostrstream;
+using _STLP_NEW_IO_NAMESPACE::strstream;
diff --git a/sources/android/stlport/stlport/utility b/sources/android/stlport/stlport/utility
new file mode 100644
index 0000000..4aaaa59
--- /dev/null
+++ b/sources/android/stlport/stlport/utility
@@ -0,0 +1,60 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_UTILITY
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x75
+# include <stl/_prolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x75) && !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+# define _STLP_UTILITY
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x75) && !defined (_STLP_DONT_POP_HEADER_ID)
+# ifndef _STLP_INTERNAL_PAIR_H
+# include <stl/_pair.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x75) || defined (_STLP_DONT_POP_HEADER_ID) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <utility>
+# else
+# include _STLP_NATIVE_HEADER(utility)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x75)
+# if !defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+#endif
+
+#endif /* _STLP_UTILITY */
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/valarray b/sources/android/stlport/stlport/valarray
new file mode 100644
index 0000000..0cb0776
--- /dev/null
+++ b/sources/android/stlport/stlport/valarray
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 1999
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_VALARRAY
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x76
+# include <stl/_prolog.h>
+# define _STLP_VALARRAY
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x76)
+# ifndef _STLP_VALARRAY_H
+# include <stl/_valarray.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x76) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <valarray>
+# else
+# include _STLP_NATIVE_HEADER(valarray)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x76)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_VALARRAY */
+
+
+// Local Variables:
+// mode:C++
+// End:
diff --git a/sources/android/stlport/stlport/vector b/sources/android/stlport/stlport/vector
new file mode 100644
index 0000000..92c41b7
--- /dev/null
+++ b/sources/android/stlport/stlport/vector
@@ -0,0 +1,59 @@
+/*
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Copyright (c) 1996,1997
+ * Silicon Graphics Computer Systems, Inc.
+ *
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef _STLP_VECTOR
+
+#ifndef _STLP_OUTERMOST_HEADER_ID
+# define _STLP_OUTERMOST_HEADER_ID 0x77
+# include <stl/_prolog.h>
+# define _STLP_VECTOR
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x77)
+# ifndef _STLP_INTERNAL_ALGOBASE_H
+# include <stl/_algobase.h>
+# endif
+
+# ifndef _STLP_INTERNAL_VECTOR_H
+# include <stl/_vector.h>
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID != 0x77) || defined (_STLP_IMPORT_VENDOR_STD)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <vector>
+# else
+# include _STLP_NATIVE_HEADER(vector)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x77)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+#endif
+
+#endif /* _STLP_VECTOR */
+
+// Local Variables:
+// mode:C++
+// End:
+
diff --git a/sources/android/stlport/stlport/wchar.h b/sources/android/stlport/stlport/wchar.h
new file mode 100644
index 0000000..6d66799
--- /dev/null
+++ b/sources/android/stlport/stlport/wchar.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x278
+# include <stl/_cprolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x278) && !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+#endif
+
+#if !defined (_STLP_WCE_EVC3) && !defined (_STLP_NO_WCHAR_T)
+
+# if defined (__BORLANDC__) && !defined (__linux__)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <_str.h>
+# else
+# include _STLP_NATIVE_CPP_C_HEADER(_str.h)
+# endif
+# ifdef __cplusplus
+using _STLP_VENDOR_CSTD::strlen;
+using _STLP_VENDOR_CSTD::strspn;
+# endif
+# endif
+
+# if (((__GNUC__ < 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ < 3))) && defined (__APPLE__)) || defined (__OpenBSD__)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <stddef.h>
+# else
+# include _STLP_NATIVE_C_HEADER(stddef.h)
+# endif
+# else
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# include_next <wchar.h>
+# else
+# include _STLP_NATIVE_C_HEADER(wchar.h)
+# endif
+# endif
+#endif /* !defined (_STLP_WCE_EVC3) && !defined (_STLP_NO_WCHAR_T) */
+
+#ifndef _STLP_INTERNAL_MBSTATE_T
+# include <stl/_mbstate_t.h>
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x278)
+# if ! defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+#endif
+
diff --git a/sources/android/stlport/stlport/wctype.h b/sources/android/stlport/stlport/wctype.h
new file mode 100644
index 0000000..c64ab9b
--- /dev/null
+++ b/sources/android/stlport/stlport/wctype.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 1999
+ * Boris Fomitchev
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#if !defined (_STLP_OUTERMOST_HEADER_ID)
+# define _STLP_OUTERMOST_HEADER_ID 0x279
+# include <stl/_cprolog.h>
+#elif (_STLP_OUTERMOST_HEADER_ID == 0x279) && !defined (_STLP_DONT_POP_HEADER_ID)
+# define _STLP_DONT_POP_HEADER_ID
+#endif
+
+/* evc3 doesn't have wctype.h */
+#if !defined(_STLP_WCE_EVC3)
+# if defined (_STLP_HAS_INCLUDE_NEXT)
+# if defined (__hpux)
+# include_next <stdarg.h>
+# include_next <wchar.h>
+# endif
+# include_next <wctype.h>
+# else
+# if defined (__hpux)
+# include _STLP_NATIVE_C_HEADER(stdarg.h)
+# include _STLP_NATIVE_C_HEADER(wchar.h)
+# endif
+# include _STLP_NATIVE_C_HEADER(wctype.h)
+# endif
+#endif
+
+#if (_STLP_OUTERMOST_HEADER_ID == 0x279)
+# if ! defined (_STLP_DONT_POP_HEADER_ID)
+# include <stl/_epilog.h>
+# undef _STLP_OUTERMOST_HEADER_ID
+# else
+# undef _STLP_DONT_POP_HEADER_ID
+# endif
+#endif
diff --git a/sources/android/stlport/test/.gitignore b/sources/android/stlport/test/.gitignore
new file mode 100644
index 0000000..ee40a85
--- /dev/null
+++ b/sources/android/stlport/test/.gitignore
@@ -0,0 +1,2 @@
+obj
+libs
diff --git a/sources/android/stlport/test/jni/Android.mk b/sources/android/stlport/test/jni/Android.mk
new file mode 100644
index 0000000..f8f5cb3
--- /dev/null
+++ b/sources/android/stlport/test/jni/Android.mk
@@ -0,0 +1,27 @@
+# The source files are actually located under ../unit
+LOCAL_PATH := $(dir $(call my-dir))
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := test_stlport
+
+unit_path := $(dir $(LOCAL_PATH))/unit
+sources := $(wildcard $(unit_path)/*.cpp $(unit_path)/*.c)
+sources := $(sources:$(LOCAL_PATH)/%=%)
+
+# Both a C and a C++ source file with the same basename
+sources := $(filter-out unit/string_header_test.c,$(sources))
+
+# Exceptions are disabled for now
+sources := $(filter-out unit/exception_test.cpp,$(sources))
+
+# This test enters an infinit loop for unknown reasons!
+sources := $(filter-out unit/codecvt_test.cpp,$(sources))
+
+LOCAL_SRC_FILES := $(sources)
+LOCAL_SRC_FILES += unit/cppunit/test_main.cpp
+
+LOCAL_STATIC_LIBRARIES := stlport_static
+include $(BUILD_EXECUTABLE)
+
+$(call import-module,android/stlport)
+
diff --git a/sources/android/stlport/test/unit/_template.cpp b/sources/android/stlport/test/unit/_template.cpp
new file mode 100644
index 0000000..a2a86d6
--- /dev/null
+++ b/sources/android/stlport/test/unit/_template.cpp
@@ -0,0 +1,31 @@
+#include <vector>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class Test : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(Test);
+ CPPUNIT_TEST(test);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void test();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(Test);
+
+//
+// tests implementation
+//
+void Test::test()
+{
+ CPPUNIT_ASSERT(true);
+}
diff --git a/sources/android/stlport/test/unit/accum_test.cpp b/sources/android/stlport/test/unit/accum_test.cpp
new file mode 100644
index 0000000..bb58561
--- /dev/null
+++ b/sources/android/stlport/test/unit/accum_test.cpp
@@ -0,0 +1,50 @@
+#include <vector>
+#include <numeric>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class AccumTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(AccumTest);
+ CPPUNIT_TEST(accum1);
+ CPPUNIT_TEST(accum2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void accum1();
+ void accum2();
+ static int mult(int initial_, int element_);
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(AccumTest);
+
+//
+// tests implementation
+//
+void AccumTest::accum1()
+{
+ vector<int> v(5);
+ for(int i = 0; (size_t)i < v.size(); ++i)
+ v[i] = i + 1;
+ int sum = accumulate(v.begin(), v.end(), 0);
+ CPPUNIT_ASSERT(sum==15);
+}
+void AccumTest::accum2()
+{
+ vector<int> v(5);
+ for(int i = 0; (size_t)i < v.size(); ++i)
+ v[i] = i + 1;
+ int prod = accumulate(v.begin(), v.end(), 1, mult);
+ CPPUNIT_ASSERT(prod==120);
+}
+int AccumTest::mult(int initial_, int element_)
+{
+ return initial_ * element_;
+}
diff --git a/sources/android/stlport/test/unit/adj_test.cpp b/sources/android/stlport/test/unit/adj_test.cpp
new file mode 100644
index 0000000..588838c
--- /dev/null
+++ b/sources/android/stlport/test/unit/adj_test.cpp
@@ -0,0 +1,135 @@
+#include <vector>
+#include <numeric>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class AdjTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(AdjTest);
+ CPPUNIT_TEST(adjfind0);
+ CPPUNIT_TEST(adjfind1);
+ CPPUNIT_TEST(adjfind2);
+ CPPUNIT_TEST(adjdiff0);
+ CPPUNIT_TEST(adjdiff1);
+ CPPUNIT_TEST(adjdiff2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void adjfind0();
+ void adjfind1();
+ void adjfind2();
+ void adjdiff0();
+ void adjdiff1();
+ void adjdiff2();
+ static int equal_length(const char* v1_, const char* v2_);
+ static int mult(int a_, int b_);
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(AdjTest);
+
+//
+// tests implementation
+//
+void AdjTest::adjfind0()
+{
+ int numbers1 [5] = { 1, 2, 4, 8, 16 };
+ int numbers2 [5] = { 5, 3, 2, 1, 1 };
+
+ int* location = adjacent_find((int*)numbers1, (int*)numbers1 + 5);
+ CPPUNIT_ASSERT(location == numbers1 + 5); // no adj so loc should be _last
+
+ location = adjacent_find((int*)numbers2, (int*)numbers2 + 5);
+ CPPUNIT_ASSERT(location != numbers2 + 5); // adj location off should be 3 (first 1)
+ CPPUNIT_ASSERT((location - numbers2)==3);
+}
+void AdjTest::adjfind1()
+{
+ typedef vector<int> IntVector;
+ IntVector v(10);
+ for (int i = 0; (size_t)i < v.size(); ++i)
+ v[i] = i;
+ IntVector::iterator location;
+ location = adjacent_find(v.begin(), v.end());
+ CPPUNIT_ASSERT(location == v.end());
+ v[6] = 7;
+ location = adjacent_find(v.begin(), v.end());
+ CPPUNIT_ASSERT(location != v.end());
+}
+void AdjTest::adjfind2()
+{
+ typedef vector <const char*> CStrVector;
+
+ const char* names[] = { "Brett", "Graham", "Jack", "Mike", "Todd" };
+
+ const int nameCount = sizeof(names)/sizeof(names[0]);
+ CStrVector v(nameCount);
+ for(int i = 0; i < nameCount; i++)
+ v[i] = names[i];
+ CStrVector::iterator location;
+ location = adjacent_find(v.begin(), v.end(), equal_length);
+
+ CPPUNIT_ASSERT(location != v.end());
+}
+int AdjTest::equal_length(const char* v1_, const char* v2_)
+{
+ return ::strlen(v1_) == ::strlen(v2_);
+}
+void AdjTest::adjdiff0()
+{
+ int numbers[5] = { 1, 2, 4, 8, 16 };
+ int difference[5];
+ adjacent_difference(numbers, numbers + 5, (int*)difference);
+ CPPUNIT_ASSERT(difference[0]==1);
+ CPPUNIT_ASSERT(difference[1]==1);
+ CPPUNIT_ASSERT(difference[2]==2);
+ CPPUNIT_ASSERT(difference[3]==4);
+ CPPUNIT_ASSERT(difference[4]==8);
+}
+void AdjTest::adjdiff1()
+{
+ vector <int> v(10);
+ for(int i = 0; (size_t)i < v.size(); ++i)
+ v[i] = i * i;
+ vector<int> result(v.size());
+ adjacent_difference(v.begin(), v.end(), result.begin());
+ CPPUNIT_ASSERT(result[0]==0)
+ CPPUNIT_ASSERT(result[1]==1)
+ CPPUNIT_ASSERT(result[2]==3)
+ CPPUNIT_ASSERT(result[3]==5)
+ CPPUNIT_ASSERT(result[4]==7)
+ CPPUNIT_ASSERT(result[5]==9)
+ CPPUNIT_ASSERT(result[6]==11)
+ CPPUNIT_ASSERT(result[7]==13)
+ CPPUNIT_ASSERT(result[8]==15)
+ CPPUNIT_ASSERT(result[9]==17)
+}
+void AdjTest::adjdiff2()
+{
+ vector <int> v(10);
+ for (int i = 0; (size_t)i < v.size(); ++i)
+ v[i] = i + 1;
+ vector <int> result(v.size());
+ adjacent_difference(v.begin(), v.end(), result.begin(), mult);
+ CPPUNIT_ASSERT(result[0]==1)
+ CPPUNIT_ASSERT(result[1]==2)
+ CPPUNIT_ASSERT(result[2]==6)
+ CPPUNIT_ASSERT(result[3]==12)
+ CPPUNIT_ASSERT(result[4]==20)
+ CPPUNIT_ASSERT(result[5]==30)
+ CPPUNIT_ASSERT(result[6]==42)
+ CPPUNIT_ASSERT(result[7]==56)
+ CPPUNIT_ASSERT(result[8]==72)
+ CPPUNIT_ASSERT(result[9]==90)
+}
+int AdjTest::mult(int a_, int b_)
+{
+ return a_ * b_;
+}
diff --git a/sources/android/stlport/test/unit/advance_test.cpp b/sources/android/stlport/test/unit/advance_test.cpp
new file mode 100644
index 0000000..bd7a168
--- /dev/null
+++ b/sources/android/stlport/test/unit/advance_test.cpp
@@ -0,0 +1,38 @@
+#include <vector>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class AdvanceTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(AdvanceTest);
+ CPPUNIT_TEST(adv);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void adv();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(AdvanceTest);
+
+//
+// tests implementation
+//
+void AdvanceTest::adv()
+{
+ typedef vector <int> IntVector;
+ IntVector v(10);
+ for (int i = 0; (size_t)i < v.size(); ++i)
+ v[i] = i;
+ IntVector::iterator location = v.begin();
+ CPPUNIT_ASSERT(*location==0);
+ advance(location, 5);
+ CPPUNIT_ASSERT(*location==5);
+}
diff --git a/sources/android/stlport/test/unit/alg_test.cpp b/sources/android/stlport/test/unit/alg_test.cpp
new file mode 100644
index 0000000..da4977a
--- /dev/null
+++ b/sources/android/stlport/test/unit/alg_test.cpp
@@ -0,0 +1,364 @@
+#include <list>
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+# include <slist>
+#endif
+#include <deque>
+#include <vector>
+#include <algorithm>
+#include <functional>
+#include <map>
+#include <string>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class AlgTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(AlgTest);
+ CPPUNIT_TEST(min_max);
+ CPPUNIT_TEST(count_test);
+ CPPUNIT_TEST(sort_test);
+ CPPUNIT_TEST(search_n_test);
+ CPPUNIT_TEST(find_first_of_test);
+ CPPUNIT_TEST(find_first_of_nsc_test);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void min_max();
+ void count_test();
+ void sort_test();
+ void search_n_test();
+ void find_first_of_test();
+ void find_first_of_nsc_test();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(AlgTest);
+
+//
+// tests implementation
+//
+void AlgTest::min_max()
+{
+ int i = min(4, 7);
+ CPPUNIT_ASSERT( i == 4 );
+ char c = max('a', 'z');
+ CPPUNIT_ASSERT( c == 'z' );
+
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ c = min('a', 'z', greater<char>());
+ CPPUNIT_ASSERT( c == 'z' );
+ i = max(4, 7, greater<int>());
+ CPPUNIT_ASSERT( i == 4 );
+#endif
+}
+
+void AlgTest::count_test()
+{
+ {
+ int i[] = { 1, 4, 2, 8, 2, 2 };
+ int n = count(i, i + 6, 2);
+ CPPUNIT_ASSERT(n==3);
+#if defined (STLPORT) && !defined (_STLP_NO_ANACHRONISMS)
+ n = 0;
+ count(i, i + 6, 2, n);
+ CPPUNIT_ASSERT(n==3);
+#endif
+ }
+ {
+ vector<int> i;
+ i.push_back(1);
+ i.push_back(4);
+ i.push_back(2);
+ i.push_back(8);
+ i.push_back(2);
+ i.push_back(2);
+ int n = count(i.begin(), i.end(), 2);
+ CPPUNIT_ASSERT(n==3);
+#if defined (STLPORT) && !defined (_STLP_NO_ANACHRONISMS)
+ n = 0;
+ count(i.begin(), i.end(), 2, n);
+ CPPUNIT_ASSERT(n==3);
+#endif
+ }
+}
+
+void AlgTest::sort_test()
+{
+ {
+ vector<int> years;
+ years.push_back(1962);
+ years.push_back(1992);
+ years.push_back(2001);
+ years.push_back(1999);
+ sort(years.begin(), years.end());
+ CPPUNIT_ASSERT(years[0]==1962);
+ CPPUNIT_ASSERT(years[1]==1992);
+ CPPUNIT_ASSERT(years[2]==1999);
+ CPPUNIT_ASSERT(years[3]==2001);
+ }
+ {
+ deque<int> years;
+ years.push_back(1962);
+ years.push_back(1992);
+ years.push_back(2001);
+ years.push_back(1999);
+ sort(years.begin(), years.end()); // <-- changed!
+ CPPUNIT_ASSERT(years[0]==1962);
+ CPPUNIT_ASSERT(years[1]==1992);
+ CPPUNIT_ASSERT(years[2]==1999);
+ CPPUNIT_ASSERT(years[3]==2001);
+ }
+}
+
+#define ARRAY_SIZE(arr) sizeof(arr) / sizeof(arr[0])
+
+void AlgTest::search_n_test()
+{
+ int ints[] = {0, 1, 2, 3, 3, 4, 4, 4, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5};
+
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ //search_n
+ //Forward iterator
+ {
+ slist<int> slint(ints, ints + ARRAY_SIZE(ints));
+ slist<int>::iterator slit = search_n(slint.begin(), slint.end(), 2, 2);
+ CPPUNIT_ASSERT( slit != slint.end() );
+ CPPUNIT_ASSERT( *(slit++) == 2 );
+ CPPUNIT_ASSERT( *slit == 2 );
+ }
+#endif
+
+ //Bidirectionnal iterator
+ {
+ list<int> lint(ints, ints + ARRAY_SIZE(ints));
+ list<int>::iterator lit = search_n(lint.begin(), lint.end(), 3, 3);
+ CPPUNIT_ASSERT( lit != lint.end() );
+ CPPUNIT_ASSERT( *(lit++) == 3 );
+ CPPUNIT_ASSERT( *(lit++) == 3 );
+ CPPUNIT_ASSERT( *lit == 3 );
+ }
+
+ //Random access iterator
+ {
+ deque<int> dint(ints, ints + ARRAY_SIZE(ints));
+ deque<int>::iterator dit = search_n(dint.begin(), dint.end(), 4, 4);
+ CPPUNIT_ASSERT( dit != dint.end() );
+ CPPUNIT_ASSERT( *(dit++) == 4 );
+ CPPUNIT_ASSERT( *(dit++) == 4 );
+ CPPUNIT_ASSERT( *(dit++) == 4 );
+ CPPUNIT_ASSERT( *dit == 4 );
+ }
+
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ //search_n with predicate
+ //Forward iterator
+ {
+ slist<int> slint(ints, ints + ARRAY_SIZE(ints));
+ slist<int>::iterator slit = search_n(slint.begin(), slint.end(), 2, 1, greater<int>());
+ CPPUNIT_ASSERT( slit != slint.end() );
+ CPPUNIT_ASSERT( *(slit++) > 1 );
+ CPPUNIT_ASSERT( *slit > 2 );
+ }
+#endif
+
+ //Bidirectionnal iterator
+ {
+ list<int> lint(ints, ints + ARRAY_SIZE(ints));
+ list<int>::iterator lit = search_n(lint.begin(), lint.end(), 3, 2, greater<int>());
+ CPPUNIT_ASSERT( lit != lint.end() );
+ CPPUNIT_ASSERT( *(lit++) > 2 );
+ CPPUNIT_ASSERT( *(lit++) > 2 );
+ CPPUNIT_ASSERT( *lit > 2 );
+ }
+
+ //Random access iterator
+ {
+ deque<int> dint(ints, ints + ARRAY_SIZE(ints));
+ deque<int>::iterator dit = search_n(dint.begin(), dint.end(), 4, 3, greater<int>());
+ CPPUNIT_ASSERT( dit != dint.end() );
+ CPPUNIT_ASSERT( *(dit++) > 3 );
+ CPPUNIT_ASSERT( *(dit++) > 3 );
+ CPPUNIT_ASSERT( *(dit++) > 3 );
+ CPPUNIT_ASSERT( *dit > 3 );
+ }
+
+ // test for bug reported by Jim Xochellis
+ {
+ int array[] = {0, 0, 1, 0, 1, 1};
+ int* array_end = array + sizeof(array) / sizeof(*array);
+ CPPUNIT_ASSERT(search_n(array, array_end, 3, 1) == array_end);
+ }
+
+ // test for bug with counter == 1, reported by Timmie Smith
+ {
+ int array[] = {0, 1, 2, 3, 4, 5};
+ int* array_end = array + sizeof(array) / sizeof(*array);
+ CPPUNIT_ASSERT( search_n(array, array_end, 1, 1, equal_to<int>() ) == &array[1] );
+ }
+}
+
+struct MyIntComparable {
+ MyIntComparable(int val) : _val(val) {}
+ bool operator == (const MyIntComparable& other) const
+ { return _val == other._val; }
+
+private:
+ int _val;
+};
+
+void AlgTest::find_first_of_test()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ slist<int> intsl;
+ intsl.push_front(1);
+ intsl.push_front(2);
+
+ {
+ vector<int> intv;
+ intv.push_back(0);
+ intv.push_back(1);
+ intv.push_back(2);
+ intv.push_back(3);
+
+ vector<int>::iterator first;
+ first = find_first_of(intv.begin(), intv.end(), intsl.begin(), intsl.end());
+ CPPUNIT_ASSERT( first != intv.end() );
+ CPPUNIT_ASSERT( *first == 1 );
+ }
+ {
+ vector<int> intv;
+ intv.push_back(3);
+ intv.push_back(2);
+ intv.push_back(1);
+ intv.push_back(0);
+
+ vector<int>::iterator first;
+ first = find_first_of(intv.begin(), intv.end(), intsl.begin(), intsl.end());
+ CPPUNIT_ASSERT( first != intv.end() );
+ CPPUNIT_ASSERT( *first == 2 );
+ }
+#endif
+
+ list<int> intl;
+ intl.push_front(1);
+ intl.push_front(2);
+
+ {
+ vector<int> intv;
+ intv.push_back(0);
+ intv.push_back(1);
+ intv.push_back(2);
+ intv.push_back(3);
+
+ vector<int>::iterator first;
+ first = find_first_of(intv.begin(), intv.end(), intl.begin(), intl.end());
+ CPPUNIT_ASSERT( first != intv.end() );
+ CPPUNIT_ASSERT( *first == 1 );
+ }
+ {
+ vector<int> intv;
+ intv.push_back(3);
+ intv.push_back(2);
+ intv.push_back(1);
+ intv.push_back(0);
+
+ vector<int>::iterator first;
+ first = find_first_of(intv.begin(), intv.end(), intl.begin(), intl.end());
+ CPPUNIT_ASSERT( first != intv.end() );
+ CPPUNIT_ASSERT( *first == 2 );
+ }
+ {
+ char chars[] = {1, 2};
+
+ vector<int> intv;
+ intv.push_back(0);
+ intv.push_back(1);
+ intv.push_back(2);
+ intv.push_back(3);
+
+ vector<int>::iterator first;
+ first = find_first_of(intv.begin(), intv.end(), chars, chars + sizeof(chars));
+ CPPUNIT_ASSERT( first != intv.end() );
+ CPPUNIT_ASSERT( *first == 1 );
+ }
+ {
+ unsigned char chars[] = {1, 2, 255};
+
+ vector<int> intv;
+ intv.push_back(-10);
+ intv.push_back(1029);
+ intv.push_back(255);
+ intv.push_back(4);
+
+ vector<int>::iterator first;
+ first = find_first_of(intv.begin(), intv.end(), chars, chars + sizeof(chars));
+ CPPUNIT_ASSERT( first != intv.end() );
+ CPPUNIT_ASSERT( *first == 255 );
+ }
+ {
+ signed char chars[] = {93, 2, -101, 13};
+
+ vector<int> intv;
+ intv.push_back(-10);
+ intv.push_back(1029);
+ intv.push_back(-2035);
+ intv.push_back(-101);
+ intv.push_back(4);
+
+ vector<int>::iterator first;
+ first = find_first_of(intv.begin(), intv.end(), chars, chars + sizeof(chars));
+ CPPUNIT_ASSERT( first != intv.end() );
+ CPPUNIT_ASSERT( *first == -101 );
+ }
+ {
+ char chars[] = {1, 2};
+
+ vector<MyIntComparable> intv;
+ intv.push_back(0);
+ intv.push_back(1);
+ intv.push_back(2);
+ intv.push_back(3);
+
+ vector<MyIntComparable>::iterator first;
+ first = find_first_of(intv.begin(), intv.end(), chars, chars + sizeof(chars));
+ CPPUNIT_ASSERT( first != intv.end() );
+ CPPUNIT_ASSERT( *first == 1 );
+ }
+}
+
+typedef pair<int, string> Pair;
+
+struct ValueFinder :
+ public binary_function<const Pair&, const string&, bool>
+{
+ bool operator () ( const Pair &p, const string& value ) const
+ { return p.second == value; }
+};
+
+void AlgTest::find_first_of_nsc_test()
+{
+ // Non-symmetrical comparator
+
+ map<int, string> m;
+ vector<string> values;
+
+ m[1] = "one";
+ m[4] = "four";
+ m[10] = "ten";
+ m[20] = "twenty";
+
+ values.push_back( "four" );
+ values.push_back( "ten" );
+
+ map<int, string>::iterator i = find_first_of(m.begin(), m.end(), values.begin(), values.end(), ValueFinder());
+
+ CPPUNIT_ASSERT( i != m.end() );
+ CPPUNIT_ASSERT( i->first == 4 || i->first == 10 );
+ CPPUNIT_ASSERT( i->second == "four" || i->second == "ten" );
+}
diff --git a/sources/android/stlport/test/unit/algorithm_header_test.cpp b/sources/android/stlport/test/unit/algorithm_header_test.cpp
new file mode 100644
index 0000000..8c3577f
--- /dev/null
+++ b/sources/android/stlport/test/unit/algorithm_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <algorithm>
diff --git a/sources/android/stlport/test/unit/allocator_test.cpp b/sources/android/stlport/test/unit/allocator_test.cpp
new file mode 100644
index 0000000..2760cd1
--- /dev/null
+++ b/sources/android/stlport/test/unit/allocator_test.cpp
@@ -0,0 +1,168 @@
+#include <memory>
+#include <vector>
+
+#include <cstdio>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class AllocatorTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(AllocatorTest);
+ CPPUNIT_TEST(zero_allocation);
+#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ CPPUNIT_TEST(bad_alloc_test);
+#endif
+#if defined (STLPORT) && defined (_STLP_THREADS) && defined (_STLP_USE_PERTHREAD_ALLOC)
+ CPPUNIT_TEST(per_thread_alloc);
+#endif
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void zero_allocation();
+ void bad_alloc_test();
+ void per_thread_alloc();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(AllocatorTest);
+
+//
+// tests implementation
+//
+void AllocatorTest::zero_allocation()
+{
+ typedef allocator<char> CharAllocator;
+ CharAllocator charAllocator;
+
+ char* buf = charAllocator.allocate(0);
+ charAllocator.deallocate(buf, 0);
+
+ charAllocator.deallocate(0, 0);
+}
+
+#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+
+struct BigStruct
+{
+ char _data[4096];
+};
+
+void AllocatorTest::bad_alloc_test()
+{
+ typedef allocator<BigStruct> BigStructAllocType;
+ BigStructAllocType bigStructAlloc;
+
+ try {
+ //Lets try to allocate almost 4096 Go (on most of the platforms) of memory:
+ BigStructAllocType::pointer pbigStruct = bigStructAlloc.allocate(1024 * 1024 * 1024);
+
+ //Allocation failed but no exception thrown
+ CPPUNIT_ASSERT( pbigStruct != 0 );
+
+ // Just it case it succeeds:
+ bigStructAlloc.deallocate(pbigStruct, 1024 * 1024 * 1024);
+ }
+ catch (bad_alloc const&) {
+ }
+ catch (...) {
+ //We shouldn't be there:
+ //Not bad_alloc exception thrown.
+ CPPUNIT_FAIL;
+ }
+}
+#endif
+
+#if defined (STLPORT) && defined (_STLP_THREADS) && defined (_STLP_USE_PERTHREAD_ALLOC)
+# include <pthread.h>
+
+class SharedDatas
+{
+public:
+ typedef vector<int, per_thread_allocator<int> > thread_vector;
+
+ SharedDatas(size_t nbElems) : threadVectors(nbElems, (thread_vector*)0) {
+ pthread_mutex_init(&mutex, 0);
+ pthread_cond_init(&condition, 0);
+ }
+
+ ~SharedDatas() {
+ for (size_t i = 0; i < threadVectors.size(); ++i) {
+ delete threadVectors[i];
+ }
+ }
+
+ size_t initThreadVector() {
+ size_t ret;
+
+ pthread_mutex_lock(&mutex);
+
+ for (size_t i = 0; i < threadVectors.size(); ++i) {
+ if (threadVectors[i] == 0) {
+ threadVectors[i] = new thread_vector();
+ ret = i;
+ break;
+ }
+ }
+
+ if (ret != threadVectors.size() - 1) {
+ //We wait for other thread(s) to call this method too:
+ printf("Thread %d wait\n", ret);
+ pthread_cond_wait(&condition, &mutex);
+ }
+ else {
+ //We are the last thread calling this method, we signal this
+ //to the other thread(s) that might be waiting:
+ printf("Thread %d signal\n", ret);
+ pthread_cond_signal(&condition);
+ }
+
+ pthread_mutex_unlock(&mutex);
+
+ return ret;
+ }
+
+ thread_vector& getThreadVector(size_t index) {
+ //We return other thread thread_vector instance:
+ return *threadVectors[(index + 1 == threadVectors.size()) ? 0 : index + 1];
+ }
+
+private:
+ pthread_mutex_t mutex;
+ pthread_cond_t condition;
+ vector<thread_vector*> threadVectors;
+};
+
+void* f(void* pdatas) {
+ SharedDatas *psharedDatas = (SharedDatas*)pdatas;
+
+ int threadIndex = psharedDatas->initThreadVector();
+
+ for (int i = 0; i < 100; ++i) {
+ psharedDatas->getThreadVector(threadIndex).push_back(i);
+ }
+
+ return 0;
+}
+
+void AllocatorTest::per_thread_alloc()
+{
+ const size_t nth = 2;
+ SharedDatas datas(nth);
+ pthread_t t[nth];
+
+ size_t i;
+ for (i = 0; i < nth; ++i) {
+ pthread_create(&t[i], 0, f, &datas);
+ }
+
+ for (i = 0; i < nth; ++i ) {
+ pthread_join(t[i], 0);
+ }
+}
+#endif
diff --git a/sources/android/stlport/test/unit/assert_header_test.c b/sources/android/stlport/test/unit/assert_header_test.c
new file mode 100644
index 0000000..a478877
--- /dev/null
+++ b/sources/android/stlport/test/unit/assert_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <assert.h>
diff --git a/sources/android/stlport/test/unit/bcompos_test.cpp b/sources/android/stlport/test/unit/bcompos_test.cpp
new file mode 100644
index 0000000..d117fab
--- /dev/null
+++ b/sources/android/stlport/test/unit/bcompos_test.cpp
@@ -0,0 +1,55 @@
+#include <algorithm>
+#include "unary.h"
+
+#include "cppunit/cppunit_proxy.h"
+
+#if defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class BcomposTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(BcomposTest);
+#if !defined (STLPORT) || defined (_STLP_NO_EXTENSIONS)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(bcompos1);
+ CPPUNIT_TEST(bcompos2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void bcompos1();
+ void bcompos2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(BcomposTest);
+
+//
+// tests implementation
+//
+void BcomposTest::bcompos1()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ int array [6] = { -2, -1, 0, 1, 2, 3 };
+
+ binary_compose<logical_and<bool>, odd, positive>
+ b = binary_compose<logical_and<bool>, odd, positive>(logical_and<bool>(), odd(), positive());
+
+ int* p = find_if((int*)array, (int*)array + 6, b);
+ CPPUNIT_ASSERT(p != array + 6);
+#endif
+}
+
+void BcomposTest::bcompos2()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ int array [6] = { -2, -1 , 0, 1, 2, 3 };
+
+ int* p = find_if((int*)array, (int*)array + 6,
+ compose2(logical_and<bool>(), odd(), positive()));
+ CPPUNIT_ASSERT(p != array + 6);
+#endif
+}
diff --git a/sources/android/stlport/test/unit/bind_test.cpp b/sources/android/stlport/test/unit/bind_test.cpp
new file mode 100644
index 0000000..8773baa
--- /dev/null
+++ b/sources/android/stlport/test/unit/bind_test.cpp
@@ -0,0 +1,149 @@
+#include <algorithm>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class BindTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(BindTest);
+ CPPUNIT_TEST(bind1st1);
+ CPPUNIT_TEST(bind2nd1);
+ CPPUNIT_TEST(bind2nd2);
+#if !defined (STLPORT) || \
+ defined (_STLP_NO_EXTENSIONS) || !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(bind2nd3);
+ CPPUNIT_TEST(bind_memfn);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void bind1st1();
+ void bind2nd1();
+ void bind2nd2();
+ void bind2nd3();
+ void bind_memfn();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(BindTest);
+
+class pre_increment : public binary_function<int, int, int> {
+public:
+ int operator()(int incr, int& val) const
+ { return val += incr; }
+};
+
+class post_increment : public binary_function<int, int, int> {
+public:
+ int operator()(int& val, int incr) const
+ { return val += incr; }
+};
+
+
+//
+// tests implementation
+//
+void BindTest::bind1st1()
+{
+ int array [3] = { 1, 2, 3 };
+ int* p = remove_if((int*)array, (int*)array + 3, bind1st(less<int>(), 2));
+
+ CPPUNIT_ASSERT(p == &array[2]);
+ CPPUNIT_ASSERT(array[0] == 1);
+ CPPUNIT_ASSERT(array[1] == 2);
+
+ for_each((int*)array, (int*)array + 3, bind1st(pre_increment(), 1));
+ CPPUNIT_ASSERT(array[0] == 2);
+ CPPUNIT_ASSERT(array[1] == 3);
+ CPPUNIT_ASSERT(array[2] == 4);
+
+ for_each((int*)array, (int*)array + 3, bind2nd(post_increment(), 1));
+ CPPUNIT_ASSERT(array[0] == 3);
+ CPPUNIT_ASSERT(array[1] == 4);
+ CPPUNIT_ASSERT(array[2] == 5);
+}
+
+void BindTest::bind2nd1()
+{
+ int array [3] = { 1, 2, 3 };
+ replace_if(array, array + 3, binder2nd<greater<int> >(greater<int>(), 2), 4);
+
+ CPPUNIT_ASSERT(array[0]==1);
+ CPPUNIT_ASSERT(array[1]==2);
+ CPPUNIT_ASSERT(array[2]==4);
+}
+void BindTest::bind2nd2()
+{
+ int array [3] = { 1, 2, 3 };
+ replace_if(array, array + 3, bind2nd(greater<int>(), 2), 4);
+ CPPUNIT_ASSERT(array[0]==1);
+ CPPUNIT_ASSERT(array[1]==2);
+ CPPUNIT_ASSERT(array[2]==4);
+}
+
+int test_func1 (const int ¶m1, const int ¶m2) {
+ return param1 + param2;
+}
+
+int test_func2 (int ¶m1, int param2) {
+ param1 += param2;
+ return param1 + param2;
+}
+
+void BindTest::bind2nd3()
+{
+#if defined (STLPORT) && \
+ !defined (_STLP_NO_EXTENSIONS) && defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ int array[3] = { 1, 2, 3 };
+ transform(array, array + 3, array, bind2nd(ptr_fun(test_func1), 1));
+ transform(array, array + 3, array, bind1st(ptr_fun(test_func1), -1));
+ CPPUNIT_ASSERT(array[0] == 1);
+ CPPUNIT_ASSERT(array[1] == 2);
+ CPPUNIT_ASSERT(array[2] == 3);
+
+ transform(array, array + 3, array, bind2nd(ptr_fun(test_func2), 10));
+ CPPUNIT_ASSERT(array[0] == 21);
+ CPPUNIT_ASSERT(array[1] == 22);
+ CPPUNIT_ASSERT(array[2] == 23);
+#endif
+}
+
+class A
+{
+ public:
+ A() : m_n( 0 )
+ {}
+
+ void f( int n ) const {
+#if defined (STLPORT)
+ _STLP_MUTABLE(A, m_n) = n;
+#else
+ m_n = n;
+#endif
+ }
+
+ int v() const
+ { return m_n; }
+
+ private:
+ mutable int m_n;
+};
+
+void BindTest::bind_memfn()
+{
+#if defined (STLPORT) && \
+ !defined (_STLP_NO_EXTENSIONS) && defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ A array[3];
+
+ for_each( array, array + 3, bind2nd( mem_fun_ref(&A::f), 12 ) );
+
+ CPPUNIT_CHECK( array[0].v() == 12 );
+#endif
+}
diff --git a/sources/android/stlport/test/unit/binsert_test.cpp b/sources/android/stlport/test/unit/binsert_test.cpp
new file mode 100644
index 0000000..e085a5c
--- /dev/null
+++ b/sources/android/stlport/test/unit/binsert_test.cpp
@@ -0,0 +1,54 @@
+#include <vector>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class BinsertTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(BinsertTest);
+ CPPUNIT_TEST(binsert1);
+ CPPUNIT_TEST(binsert2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void binsert1();
+ void binsert2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(BinsertTest);
+
+//
+// tests implementation
+//
+void BinsertTest::binsert1()
+{
+ const char* array [] = { "laurie", "jennifer", "leisa" };
+ vector<const char*> names;
+ back_insert_iterator<vector<const char*> > bit(names);
+ bit = copy(array, array + 3, bit);
+
+ CPPUNIT_ASSERT(!strcmp(names[0],array[0]));
+ CPPUNIT_ASSERT(!strcmp(names[1],array[1]));
+ CPPUNIT_ASSERT(!strcmp(names[2],array[2]));
+
+ copy(array, array + 3, bit);
+ CPPUNIT_ASSERT(!strcmp(names[3],array[0]));
+ CPPUNIT_ASSERT(!strcmp(names[4],array[1]));
+ CPPUNIT_ASSERT(!strcmp(names[5],array[2]));
+}
+void BinsertTest::binsert2()
+{
+ const char* array [] = { "laurie", "jennifer", "leisa" };
+ vector<const char*> names;
+ copy(array, array + 3, back_inserter(names));
+ CPPUNIT_ASSERT(!strcmp(names[0],array[0]));
+ CPPUNIT_ASSERT(!strcmp(names[1],array[1]));
+ CPPUNIT_ASSERT(!strcmp(names[2],array[2]));
+}
diff --git a/sources/android/stlport/test/unit/bitset_header_test.cpp b/sources/android/stlport/test/unit/bitset_header_test.cpp
new file mode 100644
index 0000000..dbd5cc2
--- /dev/null
+++ b/sources/android/stlport/test/unit/bitset_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <bitset>
diff --git a/sources/android/stlport/test/unit/bitset_test.cpp b/sources/android/stlport/test/unit/bitset_test.cpp
new file mode 100644
index 0000000..141f646
--- /dev/null
+++ b/sources/android/stlport/test/unit/bitset_test.cpp
@@ -0,0 +1,110 @@
+#include <bitset>
+#include <algorithm>
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# include <sstream>
+#endif
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class BitsetTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(BitsetTest);
+ CPPUNIT_TEST(bitset1);
+#if defined (STLPORT) && defined (_STLP_USE_NO_IOSTREAMS)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(iostream);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void bitset1();
+ void iostream();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(BitsetTest);
+
+//
+// tests implementation
+//
+void BitsetTest::bitset1()
+{
+ bitset<13U> b1(0xFFFF);
+ bitset<13U> b2(0x1111);
+ CPPUNIT_ASSERT(b1.size() == 13);
+ CPPUNIT_ASSERT(b1 == 0x1FFF);
+ CPPUNIT_ASSERT(b2.size() == 13);
+ CPPUNIT_ASSERT(b2 == 0x1111);
+
+#if !defined (STLPORT) || !defined (_STLP_NON_TYPE_TMPL_PARAM_BUG)
+ b1 = b1 ^ (b2 << 2);
+ CPPUNIT_ASSERT(b1 == 0x1BBB);
+
+ CPPUNIT_ASSERT(b1.count() == 10);
+ CPPUNIT_ASSERT(b2.count() == 4);
+
+# if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ size_t __pos = b2._Find_first();
+ CPPUNIT_ASSERT( __pos == 0 );
+ __pos = b2._Find_next(__pos);
+ CPPUNIT_ASSERT( __pos == 4 );
+ __pos = b2._Find_next(__pos);
+ CPPUNIT_ASSERT( __pos == 8 );
+ __pos = b2._Find_next(__pos);
+ CPPUNIT_ASSERT( __pos == 12 );
+ __pos = b2._Find_next(__pos);
+ CPPUNIT_ASSERT( __pos == 13 );
+# endif
+#endif
+
+#if !defined (STLPORT) || !defined (_STLP_NO_MEMBER_TEMPLATES) && !defined (_STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS)
+ string representation = b2.to_string<char, char_traits<char>, allocator<char> >();
+ CPPUNIT_ASSERT( representation == "1000100010001" );
+# if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
+ wstring wrepresentation = b2.to_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >();
+ CPPUNIT_ASSERT( wrepresentation == L"1000100010001" );
+# endif
+#else
+ CPPUNIT_ASSERT( b2.to_string() == "1000100010001" );
+#endif
+}
+
+void BitsetTest::iostream()
+{
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+ {
+ stringstream sstr;
+ bitset<13U> b(0x1111);
+ sstr << b;
+ CPPUNIT_ASSERT( sstr.str() == "1000100010001" );
+
+ bitset<13U> b1;
+ sstr >> b1;
+ CPPUNIT_ASSERT( b1.test(0) );
+ CPPUNIT_ASSERT( b1.test(4) );
+ CPPUNIT_ASSERT( b1.test(8) );
+ CPPUNIT_ASSERT( b1.test(12) );
+ }
+# if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
+ {
+ wstringstream sstr;
+ bitset<13U> b(0x1111);
+ sstr << b;
+ CPPUNIT_ASSERT( sstr.str() == L"1000100010001" );
+
+ bitset<13U> b1;
+ sstr >> b1;
+ CPPUNIT_ASSERT( b1.test(0) );
+ CPPUNIT_ASSERT( b1.test(4) );
+ CPPUNIT_ASSERT( b1.test(8) );
+ CPPUNIT_ASSERT( b1.test(12) );
+ }
+# endif
+#endif
+}
diff --git a/sources/android/stlport/test/unit/bnegate_test.cpp b/sources/android/stlport/test/unit/bnegate_test.cpp
new file mode 100644
index 0000000..888b036
--- /dev/null
+++ b/sources/android/stlport/test/unit/bnegate_test.cpp
@@ -0,0 +1,48 @@
+#include <algorithm>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class BnegateTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(BnegateTest);
+ CPPUNIT_TEST(bnegate1);
+ CPPUNIT_TEST(bnegate2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void bnegate1();
+ void bnegate2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(BnegateTest);
+
+//
+// tests implementation
+//
+void BnegateTest::bnegate1()
+{
+ int array [4] = { 4, 9, 7, 1 };
+
+ sort(array, array + 4, binary_negate<greater<int> >(greater<int>()));
+ CPPUNIT_ASSERT(array[0]==1);
+ CPPUNIT_ASSERT(array[1]==4);
+ CPPUNIT_ASSERT(array[2]==7);
+ CPPUNIT_ASSERT(array[3]==9);
+}
+void BnegateTest::bnegate2()
+{
+ int array [4] = { 4, 9, 7, 1 };
+ sort(array, array + 4, not2(greater<int>()));
+ CPPUNIT_ASSERT(array[0]==1);
+ CPPUNIT_ASSERT(array[1]==4);
+ CPPUNIT_ASSERT(array[2]==7);
+ CPPUNIT_ASSERT(array[3]==9);
+}
diff --git a/sources/android/stlport/test/unit/boost_check.cpp b/sources/android/stlport/test/unit/boost_check.cpp
new file mode 100644
index 0000000..4bf7b95
--- /dev/null
+++ b/sources/android/stlport/test/unit/boost_check.cpp
@@ -0,0 +1,49 @@
+#ifndef WITHOUT_STLPORT
+#include <stl/config/user_config.h>
+
+#ifdef _STLP_USE_BOOST_SUPPORT
+
+#include <boost/config.hpp>
+
+#endif // _STLP_USE_BOOST_SUPPORT
+
+#else
+
+#if 0 // Problem 1:
+/* *******************************
+../../../stlport/functional:63: error: 'boost::mem_fn' has not been declared
+../../../stlport/functional:64: error: 'boost::bind' has not been declared
+../../../stlport/functional:67: error: '::_1' has not been declared
+../../../stlport/functional:68: error: '::_2' has not been declared
+../../../stlport/functional:69: error: '::_3' has not been declared
+../../../stlport/functional:70: error: '::_4' has not been declared
+../../../stlport/functional:71: error: '::_5' has not been declared
+../../../stlport/functional:72: error: '::_6' has not been declared
+../../../stlport/functional:73: error: '::_7' has not been declared
+../../../stlport/functional:74: error: '::_8' has not been declared
+../../../stlport/functional:75: error: '::_9' has not been declared
+ ******************************* */
+
+#include <boost/bind.hpp>
+
+#endif // Problem 1
+
+#if 0 // Problem 2
+
+#include <boost/function.hpp>
+
+#endif // Problem 2
+
+#if 0 // Problem 3
+
+#include <boost/function/function_base.hpp>
+
+#endif // Problem 3
+
+#if 0 // Problem 4
+
+#include <boost/function/function1.hpp>
+
+#endif // Problem 4
+
+#endif
diff --git a/sources/android/stlport/test/unit/bound_test.cpp b/sources/android/stlport/test/unit/bound_test.cpp
new file mode 100644
index 0000000..f7cc6e2
--- /dev/null
+++ b/sources/android/stlport/test/unit/bound_test.cpp
@@ -0,0 +1,80 @@
+#include <vector>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class BoundTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(BoundTest);
+ CPPUNIT_TEST(lwrbnd1);
+ CPPUNIT_TEST(lwrbnd2);
+ CPPUNIT_TEST(uprbnd1);
+ CPPUNIT_TEST(uprbnd2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void lwrbnd1();
+ void lwrbnd2();
+ void uprbnd1();
+ void uprbnd2();
+
+ static bool char_str_less(const char* a_, const char* b_)
+ {
+ return strcmp(a_, b_) < 0 ? 1 : 0;
+ }
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(BoundTest);
+
+//
+// tests implementation
+//
+void BoundTest::uprbnd1()
+{
+ int arr[20];
+ for(int i = 0; i < 20; i++)
+ {
+ arr[i] = i/4;
+ }
+ int location = upper_bound((int*)arr, (int*)arr + 20, 3) - arr;
+ CPPUNIT_ASSERT(location==16);
+}
+
+void BoundTest::uprbnd2()
+{
+ char const* str [] = { "a", "a", "b", "b", "q", "w", "z" };
+
+ const unsigned strCt = sizeof(str)/sizeof(str[0]);
+
+ int location = (upper_bound((char const**)str, (char const**)str + strCt, (const char *)"d", char_str_less) - str);
+ CPPUNIT_ASSERT(location==4);
+}
+void BoundTest::lwrbnd1()
+{
+ vector <int> v1(20);
+ for (int i = 0; (size_t)i < v1.size(); ++i)
+ {
+ v1[i] = i/4;
+ }
+ // 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3 4 4 4 4
+ vector<int>::iterator location = lower_bound(v1.begin(), v1.end(), 3);
+
+ CPPUNIT_ASSERT((location - v1.begin())==12);
+}
+
+void BoundTest::lwrbnd2()
+{
+ char const* str [] = { "a", "a", "b", "b", "q", "w", "z" };
+
+ const unsigned strCt = sizeof(str)/sizeof(str[0]);
+ char const** location = lower_bound((char const**)str, (char const**)str + strCt, (const char *)"d", char_str_less);
+
+ CPPUNIT_ASSERT((location - str) == 4);
+}
diff --git a/sources/android/stlport/test/unit/bsearch_test.cpp b/sources/android/stlport/test/unit/bsearch_test.cpp
new file mode 100644
index 0000000..27dcc02
--- /dev/null
+++ b/sources/android/stlport/test/unit/bsearch_test.cpp
@@ -0,0 +1,49 @@
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class BsearchTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(BsearchTest);
+ CPPUNIT_TEST(bsearch1);
+ CPPUNIT_TEST(bsearch2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void bsearch1();
+ void bsearch2();
+ static bool str_compare(const char* a_, const char* b_);
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(BsearchTest);
+
+//
+// tests implementation
+//
+void BsearchTest::bsearch1()
+{
+ int vector[100];
+ for(int i = 0; i < 100; i++)
+ vector[i] = i;
+ CPPUNIT_ASSERT(binary_search(vector, vector + 100, 42));
+}
+
+void BsearchTest::bsearch2()
+{
+ char const* labels[] = { "aa", "dd", "ff", "jj", "ss", "zz" };
+ const unsigned count = sizeof(labels) / sizeof(labels[0]);
+ // DEC C++ generates incorrect template instatiation code
+ // for "ff" so must cast
+ CPPUNIT_ASSERT(binary_search(labels, labels + count, (const char *)"ff", str_compare));
+}
+bool BsearchTest::str_compare(const char* a_, const char* b_)
+{
+ return strcmp(a_, b_) < 0 ? 1 : 0;
+}
diff --git a/sources/android/stlport/test/unit/bvector_test.cpp b/sources/android/stlport/test/unit/bvector_test.cpp
new file mode 100644
index 0000000..b0c4912
--- /dev/null
+++ b/sources/android/stlport/test/unit/bvector_test.cpp
@@ -0,0 +1,71 @@
+#include <vector>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class BvectorTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(BvectorTest);
+#if !defined (STLPORT) || defined (_STLP_NO_EXTENSIONS)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(bvec1);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void bvec1();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(BvectorTest);
+
+//
+// tests implementation
+//
+void BvectorTest::bvec1()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ bool ii[3]= {1,0,1};
+ bit_vector b(3);
+
+ CPPUNIT_ASSERT(b[0]==0);
+ CPPUNIT_ASSERT(b[1]==0);
+ CPPUNIT_ASSERT(b[2]==0);
+
+ b[0] = b[2] = 1;
+
+ CPPUNIT_ASSERT(b[0]==1);
+ CPPUNIT_ASSERT(b[1]==0);
+ CPPUNIT_ASSERT(b[2]==1);
+
+ b.insert(b.begin(),(bool*)ii, ii+2);
+
+ CPPUNIT_ASSERT(b[0]==1);
+ CPPUNIT_ASSERT(b[1]==0);
+ CPPUNIT_ASSERT(b[2]==1);
+ CPPUNIT_ASSERT(b[3]==0);
+ CPPUNIT_ASSERT(b[4]==1);
+
+ bit_vector bb = b;
+ if (bb != b)
+ exit(1);
+
+ b[0] |= 0;
+ b[1] |= 0;
+ b[2] |= 1;
+ b[3] |= 1;
+ CPPUNIT_ASSERT(!((b[0] != 1) || (b[1] != 0) || (b[2] != 1) || (b[3] != 1)));
+
+
+ bb[0] &= 0;
+ bb[1] &= 0;
+ bb[2] &= 1;
+ bb[3] &= 1;
+ CPPUNIT_ASSERT(!((bb[0] != 0) || (bb[1] != 0) || (bb[2] != 1) || (bb[3] != 0)));
+#endif
+}
diff --git a/sources/android/stlport/test/unit/c_limits_header_test.c b/sources/android/stlport/test/unit/c_limits_header_test.c
new file mode 100644
index 0000000..04b2bf2
--- /dev/null
+++ b/sources/android/stlport/test/unit/c_limits_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <limits.h>
diff --git a/sources/android/stlport/test/unit/c_locale_header_test.c b/sources/android/stlport/test/unit/c_locale_header_test.c
new file mode 100644
index 0000000..8dbec46
--- /dev/null
+++ b/sources/android/stlport/test/unit/c_locale_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <locale.h>
diff --git a/sources/android/stlport/test/unit/cassert_header_test.cpp b/sources/android/stlport/test/unit/cassert_header_test.cpp
new file mode 100644
index 0000000..bafdf32
--- /dev/null
+++ b/sources/android/stlport/test/unit/cassert_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <cassert>
diff --git a/sources/android/stlport/test/unit/cctype_header_test.cpp b/sources/android/stlport/test/unit/cctype_header_test.cpp
new file mode 100644
index 0000000..8a67339
--- /dev/null
+++ b/sources/android/stlport/test/unit/cctype_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <cctype>
diff --git a/sources/android/stlport/test/unit/cerrno_header_test.cpp b/sources/android/stlport/test/unit/cerrno_header_test.cpp
new file mode 100644
index 0000000..c0e1d5a
--- /dev/null
+++ b/sources/android/stlport/test/unit/cerrno_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <cerrno>
diff --git a/sources/android/stlport/test/unit/cfloat_header_test.cpp b/sources/android/stlport/test/unit/cfloat_header_test.cpp
new file mode 100644
index 0000000..4579c73
--- /dev/null
+++ b/sources/android/stlport/test/unit/cfloat_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <cfloat>
diff --git a/sources/android/stlport/test/unit/ciso646_header_test.cpp b/sources/android/stlport/test/unit/ciso646_header_test.cpp
new file mode 100644
index 0000000..4b7b257
--- /dev/null
+++ b/sources/android/stlport/test/unit/ciso646_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <ciso646>
diff --git a/sources/android/stlport/test/unit/climits_header_test.cpp b/sources/android/stlport/test/unit/climits_header_test.cpp
new file mode 100644
index 0000000..cf71b9f
--- /dev/null
+++ b/sources/android/stlport/test/unit/climits_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <climits>
diff --git a/sources/android/stlport/test/unit/clocale_header_test.cpp b/sources/android/stlport/test/unit/clocale_header_test.cpp
new file mode 100644
index 0000000..5d3b36a
--- /dev/null
+++ b/sources/android/stlport/test/unit/clocale_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <clocale>
diff --git a/sources/android/stlport/test/unit/cmath_header_test.cpp b/sources/android/stlport/test/unit/cmath_header_test.cpp
new file mode 100644
index 0000000..5c9b7cb
--- /dev/null
+++ b/sources/android/stlport/test/unit/cmath_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <cmath>
diff --git a/sources/android/stlport/test/unit/cmath_test.cpp b/sources/android/stlport/test/unit/cmath_test.cpp
new file mode 100644
index 0000000..07185e9
--- /dev/null
+++ b/sources/android/stlport/test/unit/cmath_test.cpp
@@ -0,0 +1,170 @@
+#define _STLP_DO_IMPORT_CSTD_FUNCTIONS
+
+#include <limits>
+#include <cmath>
+//We also test math functions imported from stdlib.h or
+//defined in cstdlib
+#include <cstdlib>
+
+#include "math_aux.h"
+#include "cppunit/cppunit_proxy.h"
+
+//This test purpose is to check the right import of math.h C symbols
+//into the std namespace so we do not use the using namespace std
+//specification
+
+//
+// TestCase class
+//
+class CMathTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(CMathTest);
+#if defined (STLPORT) && !defined (_STLP_USE_NAMESPACES)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(import_checks);
+ CPPUNIT_TEST_SUITE_END();
+
+ protected:
+ void import_checks();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(CMathTest);
+
+//
+// tests implementation
+//
+void CMathTest::import_checks()
+{
+#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+ int int_val = -1;
+ long long_val = -1l;
+ float float_val = -1.0f;
+ double double_val = -1.0;
+# if !defined (_STLP_NO_LONG_DOUBLE)
+ long double long_double_val = -1.0l;
+# endif
+
+ CPPUNIT_CHECK( are_equals(std::abs(int_val), -int_val) );
+ CPPUNIT_CHECK( are_equals(std::abs(long_val), -long_val) );
+ CPPUNIT_CHECK( are_equals(std::labs(long_val), -long_val) );
+ CPPUNIT_CHECK( are_equals(std::abs(float_val), -float_val) );
+ CPPUNIT_CHECK( are_equals(std::abs(double_val), -double_val) );
+# if !defined (_STLP_NO_LONG_DOUBLE)
+ CPPUNIT_CHECK( are_equals(std::abs(long_double_val), -long_double_val) );
+# endif
+
+ CPPUNIT_CHECK( are_equals(std::fabs(float_val), -float_val) );
+ CPPUNIT_CHECK( are_equals(std::fabs(double_val), -double_val) );
+# if !defined (_STLP_NO_LONG_DOUBLE)
+ CPPUNIT_CHECK( are_equals(std::fabs(long_double_val), -long_double_val) );
+# endif
+
+ std::div_t div_res = std::div(3, 2);
+ CPPUNIT_CHECK( div_res.quot == 1 );
+ CPPUNIT_CHECK( div_res.rem == 1 );
+ std::ldiv_t ldiv_res = std::ldiv(3l, 2l);
+ CPPUNIT_CHECK( ldiv_res.quot == 1l );
+ CPPUNIT_CHECK( ldiv_res.rem == 1l );
+ ldiv_res = std::div(3l, 2l);
+ CPPUNIT_CHECK( ldiv_res.quot == 1l );
+ CPPUNIT_CHECK( ldiv_res.rem == 1l );
+
+ std::srand(2);
+ int rand_val = std::rand();
+ CPPUNIT_CHECK( rand_val >= 0 && rand_val <= RAND_MAX );
+
+ CPPUNIT_CHECK( are_equals(std::floor(1.5), 1.0) );
+ CPPUNIT_CHECK( are_equals(std::ceil(1.5), 2.0) );
+ CPPUNIT_CHECK( are_equals(std::fmod(1.5, 1.0), 0.5) );
+ CPPUNIT_CHECK( are_equals(std::sqrt(4.0), 2.0) );
+ CPPUNIT_CHECK( are_equals(std::pow(2.0, 2), 4.0) );
+ /*
+ * Uncomment the following to check that it generates an ambiguous call
+ * as there is no Standard pow(int, int) function only pow(double, int),
+ * pow(float, int) and some others...
+ * If it do not generate a compile time error it should at least give
+ * the good result.
+ */
+ //CPPUNIT_CHECK( are_equals(std::pow(10, -2), 0.01) );
+ CPPUNIT_CHECK( are_equals(std::pow(10.0, -2), 0.01) );
+ CPPUNIT_CHECK( are_equals(std::exp(0.0), 1.0) );
+ CPPUNIT_CHECK( are_equals(std::log(std::exp(1.0)), 1.0) );
+ CPPUNIT_CHECK( are_equals(std::log10(100.0), 2.0) );
+# if !defined (STLPORT) || !defined (_STLP_USING_PLATFORM_SDK_COMPILER) || !defined (_WIN64)
+ CPPUNIT_CHECK( are_equals(std::modf(100.5, &double_val), 0.5) );
+ CPPUNIT_CHECK( are_equals(double_val, 100.0) );
+# endif
+ double_val = std::frexp(8.0, &int_val);
+ CPPUNIT_CHECK( are_equals(double_val * std::pow(2.0, int_val), 8.0) );
+ CPPUNIT_CHECK( are_equals(std::ldexp(1.0, 2), 4.0) );
+ CPPUNIT_CHECK( are_equals(std::cos(std::acos(1.0)), 1.0) );
+ CPPUNIT_CHECK( are_equals(std::sin(std::asin(1.0)), 1.0) );
+ CPPUNIT_CHECK( are_equals(std::tan(std::atan(1.0)), 1.0) );
+ CPPUNIT_CHECK( are_equals(std::tan(std::atan2(1.0, 1.0)), 1.0) );
+ CPPUNIT_CHECK( are_equals(std::cosh(0.0), 1.0) );
+ CPPUNIT_CHECK( are_equals(std::sinh(0.0), 0.0) );
+# if !defined (STLPORT) || !defined (_STLP_USING_PLATFORM_SDK_COMPILER) || !defined (_M_AMD64)
+ CPPUNIT_CHECK( are_equals(std::tanh(0.0), 0.0) );
+# endif
+
+ CPPUNIT_CHECK( are_equals(std::floor(1.5f), 1.0f) );
+ CPPUNIT_CHECK( are_equals(std::ceil(1.5f), 2.0f) );
+ CPPUNIT_CHECK( are_equals(std::fmod(1.5f, 1.0f), 0.5f) );
+ CPPUNIT_CHECK( are_equals(std::sqrt(4.0f), 2.0f) );
+ CPPUNIT_CHECK( are_equals(std::pow(2.0f, 2), 4.0f) );
+ CPPUNIT_CHECK( are_equals(std::exp(0.0f), 1.0f) );
+ CPPUNIT_CHECK( are_equals(std::log(std::exp(1.0f)), 1.0f) );
+ CPPUNIT_CHECK( are_equals(std::log10(100.0f), 2.0f) );
+# if !defined (STLPORT) || !defined (_STLP_USING_PLATFORM_SDK_COMPILER) || !defined (_WIN64)
+ CPPUNIT_CHECK( are_equals(std::modf(100.5f, &float_val), 0.5f) );
+ CPPUNIT_CHECK( are_equals(float_val, 100.0f) );
+# endif
+ float_val = std::frexp(8.0f, &int_val);
+ CPPUNIT_CHECK( are_equals(float_val * std::pow(2.0f, int_val), 8.0f) );
+ CPPUNIT_CHECK( are_equals(std::ldexp(1.0f, 2), 4.0f) );
+ CPPUNIT_CHECK( are_equals(std::cos(std::acos(1.0f)), 1.0f) );
+ CPPUNIT_CHECK( are_equals(std::sin(std::asin(1.0f)), 1.0f) );
+ CPPUNIT_CHECK( are_equals(std::tan(std::atan(1.0f)), 1.0f) );
+ CPPUNIT_CHECK( are_equals(std::tan(std::atan2(1.0f, 1.0f)), 1.0f) );
+ CPPUNIT_CHECK( are_equals(std::cosh(0.0f), 1.0f) );
+ CPPUNIT_CHECK( are_equals(std::sinh(0.0f), 0.0f) );
+# if !defined (STLPORT) || !defined (_STLP_USING_PLATFORM_SDK_COMPILER) || !defined (_M_AMD64)
+ CPPUNIT_CHECK( are_equals(std::tanh(0.0f), 0.0f) );
+# endif
+
+# if !defined (_STLP_NO_LONG_DOUBLE)
+ CPPUNIT_CHECK( are_equals(std::floor(1.5l), 1.0l) );
+ CPPUNIT_CHECK( are_equals(std::ceil(1.5l), 2.0l) );
+ CPPUNIT_CHECK( are_equals(std::fmod(1.5l, 1.0l), 0.5l) );
+ CPPUNIT_CHECK( are_equals(std::sqrt(4.0l), 2.0l) );
+ CPPUNIT_CHECK( are_equals(std::pow(2.0l, 2), 4.0l) );
+ CPPUNIT_CHECK( are_equals(std::exp(0.0l), 1.0l) );
+ CPPUNIT_CHECK( are_equals(std::log(std::exp(1.0l)), 1.0l) );
+ CPPUNIT_CHECK( are_equals(std::log10(100.0l), 2.0l) );
+# if !defined (STLPORT) || !defined (_STLP_USING_PLATFORM_SDK_COMPILER) || !defined (_WIN64)
+ CPPUNIT_CHECK( are_equals(std::modf(100.5l, &long_double_val), 0.5l) );
+ CPPUNIT_CHECK( are_equals(long_double_val, 100.0l) );
+# endif
+ long_double_val = std::frexp(8.0l, &int_val);
+ CPPUNIT_CHECK( are_equals(long_double_val * std::pow(2.0l, int_val), 8.0l) );
+ CPPUNIT_CHECK( are_equals(std::ldexp(1.0l, 2), 4.0l) );
+ CPPUNIT_CHECK( are_equals(std::cos(std::acos(1.0l)), 1.0l) );
+ CPPUNIT_CHECK( are_equals(std::sin(std::asin(1.0l)), 1.0l) );
+ CPPUNIT_CHECK( are_equals(std::tan(0.0l), 0.0l) );
+ CPPUNIT_CHECK( are_equals(std::atan(0.0l), 0.0l) );
+ CPPUNIT_CHECK( are_equals(std::atan2(0.0l, 1.0l), 0.0l) );
+ CPPUNIT_CHECK( are_equals(std::cosh(0.0l), 1.0l) );
+ CPPUNIT_CHECK( are_equals(std::sinh(0.0l), 0.0l) );
+# if !defined (STLPORT) || !defined (_STLP_USING_PLATFORM_SDK_COMPILER) || !defined (_M_AMD64)
+ CPPUNIT_CHECK( are_equals(std::tanh(0.0l), 0.0l) );
+# endif
+# endif
+
+ CPPUNIT_CHECK( are_equals(std::sqrt(std::sqrt(std::sqrt(256.0))), 2.0) );
+ CPPUNIT_CHECK( are_equals(std::sqrt(std::sqrt(std::sqrt(256.0f))), 2.0f) );
+# if !defined (_STLP_NO_LONG_DOUBLE)
+ CPPUNIT_CHECK( are_equals(std::sqrt(std::sqrt(std::sqrt(256.0l))), 2.0l) );
+# endif
+#endif
+}
diff --git a/sources/android/stlport/test/unit/codecvt_test.cpp b/sources/android/stlport/test/unit/codecvt_test.cpp
new file mode 100644
index 0000000..56b168b
--- /dev/null
+++ b/sources/android/stlport/test/unit/codecvt_test.cpp
@@ -0,0 +1,656 @@
+#include <string>
+
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# include <fstream>
+# include <locale>
+# include <stdexcept>
+# include <cstdio> // for WEOF
+
+# include "cppunit/cppunit_proxy.h"
+
+# if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+# endif
+
+//
+// TestCase class
+//
+class CodecvtTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(CodecvtTest);
+#if defined (STLPORT) && defined (_STLP_NO_MEMBER_TEMPLATES)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(variable_encoding);
+ CPPUNIT_STOP_IGNORE;
+#if defined (STLPORT) && (defined (_STLP_NO_WCHAR_T) || !defined (_STLP_USE_EXCEPTIONS))
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(in_out_test);
+ CPPUNIT_TEST(length_test);
+ CPPUNIT_TEST(imbue_while_reading);
+ CPPUNIT_TEST(special_encodings);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void variable_encoding();
+ void in_out_test();
+ void length_test();
+ void imbue_while_reading();
+ void special_encodings();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(CodecvtTest);
+
+#if defined (STLPORT)
+# define __NO_THROW _STLP_NOTHROW
+#else
+# define __NO_THROW throw()
+#endif
+
+
+/* Codecvt facet eating some characters from the external buffer.
+ * Transform '01' in 'a'
+ */
+struct eater_codecvt : public codecvt<char, char, mbstate_t> {
+ typedef codecvt<char,char,mbstate_t> base;
+
+ explicit eater_codecvt(size_t refs = 0) : base(refs) {}
+
+ // primitive conversion
+ virtual base::result
+ do_in(mbstate_t& mb,
+ const char* ebegin, const char* eend, const char*& ecur,
+ char* ibegin, char* iend, char*& icur) const __NO_THROW {
+ char *state = (char*)&mb;
+ ecur = ebegin;
+ icur = ibegin;
+
+ while (ecur != eend) {
+ if (icur == iend)
+ return partial;
+ if (*ecur == '0' || *state == 1) {
+ if (*state != 1) {
+ ++ecur;
+ }
+ if (ecur == eend) {
+ *state = 1;
+ return ok;
+ }
+
+ if (*ecur == '1') {
+ *icur = 'a';
+ }
+ else {
+ *(icur++) = '0';
+ if (icur == iend) {
+ if (*state != 1) {
+ --ecur;
+ }
+ return partial;
+ }
+ *icur = *ecur;
+ }
+ }
+ else {
+ *icur = *ecur;
+ }
+
+ *state = 0;
+ ++icur;
+ ++ecur;
+ }
+
+ return ok;
+ }
+
+ // claim it's not a null-conversion
+ virtual bool do_always_noconv() const __NO_THROW
+ { return false; }
+
+ // claim it doesn't have a fixed-length encoding
+ virtual int do_encoding() const __NO_THROW
+ { return 0; }
+
+ // implemented for consistency with do_in overload
+ virtual int do_length(mbstate_t &state,
+ const char *efrom, const char *eend, size_t m) const {
+ char *ibegin = new char[m];
+ const char *ecur = efrom;
+ char *icur = ibegin;
+ mbstate_t tmp = state;
+ do_in(tmp, efrom, eend, ecur, ibegin, ibegin + m, icur);
+ delete[] ibegin;
+ return ecur - efrom;
+ }
+
+ virtual int do_max_length() const __NO_THROW
+ { return 2; }
+
+#ifdef __DMC__
+ static locale::id id;
+#endif
+};
+
+#ifdef __DMC__
+locale::id eater_codecvt::id;
+
+locale::id& _GetFacetId(const eater_codecvt*)
+{ return eater_codecvt::id; }
+#endif
+
+/* Codecvt facet generating more characters than the ones read from the
+ * external buffer, transform '01' in 'abc'
+ * This kind of facet do not allow systematical positionning in the external
+ * buffer (tellg -> -1), when you just read a 'a' you are at an undefined
+ * external buffer position.
+ */
+struct generator_codecvt : public codecvt<char, char, mbstate_t> {
+ typedef codecvt<char,char,mbstate_t> base;
+
+ explicit generator_codecvt(size_t refs = 0) : base(refs) {}
+
+ // primitive conversion
+ virtual base::result
+ do_in(mbstate_t& mb,
+ const char* ebegin, const char* eend, const char*& ecur,
+ char* ibegin, char* iend, char*& icur) const __NO_THROW {
+ //Access the mbstate information in a portable way:
+ char *state = (char*)&mb;
+ ecur = ebegin;
+ icur = ibegin;
+
+ if (icur == iend) return ok;
+
+ if (*state == 2) {
+ *(icur++) = 'b';
+ if (icur == iend) {
+ *state = 3;
+ return ok;
+ }
+ *(icur++) = 'c';
+ *state = 0;
+ }
+ else if (*state == 3) {
+ *(icur++) = 'c';
+ *state = 0;
+ }
+
+ while (ecur != eend) {
+ if (icur == iend)
+ return ok;
+ if (*ecur == '0' || *state == 1) {
+ if (*state != 1) {
+ ++ecur;
+ }
+ if (ecur == eend) {
+ *state = 1;
+ return partial;
+ }
+
+ if (*ecur == '1') {
+ *(icur++) = 'a';
+ if (icur == iend) {
+ *state = 2;
+ return ok;
+ }
+ *(icur++) = 'b';
+ if (icur == iend) {
+ *state = 3;
+ return ok;
+ }
+ *icur = 'c';
+ }
+ else {
+ *(icur++) = '0';
+ if (icur == iend) {
+ if (*state != 1) {
+ --ecur;
+ }
+ return ok;
+ }
+ *icur = *ecur;
+ }
+ }
+ else {
+ *icur = *ecur;
+ }
+
+ *state = 0;
+ ++icur;
+ ++ecur;
+ }
+
+ return ok;
+ }
+
+ // claim it's not a null-conversion
+ virtual bool do_always_noconv() const __NO_THROW
+ { return false; }
+
+ // claim it doesn't have a fixed-length encoding
+ virtual int do_encoding() const __NO_THROW
+ { return 0; }
+
+ // implemented for consistency with do_in overload
+ virtual int do_length(mbstate_t &mb,
+ const char *efrom, const char *eend, size_t m) const {
+ const char *state = (const char*)&mb;
+ int offset = 0;
+ if (*state == 2)
+ offset = 2;
+ else if (*state == 3)
+ offset = 1;
+
+ char *ibegin = new char[m + offset];
+ const char *ecur = efrom;
+ char *icur = ibegin;
+ mbstate_t tmpState = mb;
+ do_in(tmpState, efrom, eend, ecur, ibegin, ibegin + m + offset, icur);
+ /*
+ char *state = (char*)&tmpState;
+ if (*state != 0) {
+ if (*state == 1)
+ --ecur;
+ else if (*state == 2 || *state == 3) {
+ //Undefined position, we return -1:
+ ecur = efrom - 1;
+ }
+ }
+ else {
+ if (*((char*)&mb) != 0) {
+ //We take into account the character that hasn't been counted yet in
+ //the previous decoding step:
+ ecur++;
+ }
+ }
+ */
+ delete[] ibegin;
+ return (int)min((size_t)(ecur - efrom), m);
+ }
+
+ virtual int do_max_length() const __NO_THROW
+ { return 0; }
+#ifdef __DMC__
+ static locale::id id;
+#endif
+};
+
+#ifdef __DMC__
+locale::id generator_codecvt::id;
+
+locale::id& _GetFacetId(const generator_codecvt*)
+{ return generator_codecvt::id; }
+#endif
+
+//
+// tests implementation
+//
+#include <iostream>
+void CodecvtTest::variable_encoding()
+{
+#if !defined (STLPORT) || !defined (_STLP_NO_MEMBER_TEMPLATES)
+ //We first generate the file used for test:
+ const char* fileName = "test_file.txt";
+ {
+ ofstream ostr(fileName);
+ //Maybe we simply do not have write access to repository
+ CPPUNIT_ASSERT( ostr.good() );
+ for (int i = 0; i < 2048; ++i) {
+ ostr << "0123456789";
+ }
+ CPPUNIT_ASSERT( ostr.good() );
+ }
+
+ {
+ ifstream istr(fileName);
+ CPPUNIT_ASSERT( istr.good() );
+ CPPUNIT_ASSERT( !istr.eof() );
+
+ eater_codecvt codec(1);
+ locale loc(locale::classic(), &codec);
+
+ istr.imbue(loc);
+ CPPUNIT_ASSERT( istr.good() );
+ CPPUNIT_ASSERT( (int)istr.tellg() == 0 );
+
+ int theoricalPos = 0;
+ do {
+ int c = istr.get();
+ if (char_traits<char>::eq_int_type(c, char_traits<char>::eof())) {
+ break;
+ }
+ ++theoricalPos;
+ if (c == 'a') {
+ ++theoricalPos;
+ }
+
+ CPPUNIT_ASSERT( (int)istr.tellg() == theoricalPos );
+ }
+ while (!istr.eof());
+ cerr << "out!\n";
+ CPPUNIT_ASSERT( istr.eof() );
+ cerr << "fin!\n";
+ }
+
+# if 0
+ /* This test is broken, not sure if it is really possible to get a position in
+ * a locale having a codecvt such as generator_codecvt. Maybe generator_codecvt
+ * is not a valid theorical example of codecvt implementation. */
+ {
+ ifstream istr(fileName);
+ CPPUNIT_ASSERT( istr.good() );
+ CPPUNIT_ASSERT( !istr.eof() );
+
+ generator_codecvt codec(1);
+ locale loc(locale::classic(), &codec);
+
+ istr.imbue(loc);
+ CPPUNIT_ASSERT( istr.good() );
+ CPPUNIT_ASSERT( (int)istr.tellg() == 0 );
+
+ int theoricalPos = 0;
+ int theoricalTellg;
+ do {
+ char c = istr.get();
+ if (c == char_traits<char>::eof()) {
+ break;
+ }
+ switch (c) {
+ case 'a':
+ case 'b':
+ theoricalTellg = -1;
+ break;
+ case 'c':
+ ++theoricalPos;
+ default:
+ ++theoricalPos;
+ theoricalTellg = theoricalPos;
+ break;
+ }
+
+ if ((int)istr.tellg() != theoricalTellg) {
+ CPPUNIT_ASSERT( (int)istr.tellg() == theoricalTellg );
+ }
+ }
+ while (!istr.eof());
+
+ CPPUNIT_ASSERT( istr.eof() );
+ }
+# endif
+#endif
+}
+
+void CodecvtTest::in_out_test()
+{
+#if !defined (STLPORT) || !(defined (_STLP_NO_WCHAR_T) || !defined (_STLP_USE_EXCEPTIONS))
+ try {
+ locale loc("");
+
+ typedef codecvt<wchar_t, char, mbstate_t> cdecvt_type;
+ if (has_facet<cdecvt_type>(loc)) {
+ cdecvt_type const& cdect = use_facet<cdecvt_type>(loc);
+ {
+ cdecvt_type::state_type state;
+ memset(&state, 0, sizeof(cdecvt_type::state_type));
+ string from("abcdef");
+ const char* next_from;
+ wchar_t to[1];
+ wchar_t *next_to;
+ cdecvt_type::result res = cdect.in(state, from.data(), from.data() + from.size(), next_from,
+ to, to + sizeof(to) / sizeof(wchar_t), next_to);
+ CPPUNIT_ASSERT( res == cdecvt_type::ok );
+ CPPUNIT_ASSERT( next_from == from.data() + 1 );
+ CPPUNIT_ASSERT( next_to == &to[0] + 1 );
+ CPPUNIT_ASSERT( to[0] == L'a');
+ }
+ {
+ cdecvt_type::state_type state;
+ memset(&state, 0, sizeof(cdecvt_type::state_type));
+ wstring from(L"abcdef");
+ const wchar_t* next_from;
+ char to[1];
+ char *next_to;
+ cdecvt_type::result res = cdect.out(state, from.data(), from.data() + from.size(), next_from,
+ to, to + sizeof(to) / sizeof(char), next_to);
+ CPPUNIT_ASSERT( res == cdecvt_type::ok );
+ CPPUNIT_ASSERT( next_from == from.data() + 1 );
+ CPPUNIT_ASSERT( next_to == &to[0] + 1 );
+ CPPUNIT_ASSERT( to[0] == 'a');
+ }
+ }
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+#endif
+}
+
+void CodecvtTest::length_test()
+{
+#if !defined (STLPORT) || !(defined (_STLP_NO_WCHAR_T) || !defined (_STLP_USE_EXCEPTIONS))
+ try {
+ locale loc("");
+
+ typedef codecvt<wchar_t, char, mbstate_t> cdecvt_type;
+ if (has_facet<cdecvt_type>(loc)) {
+ cdecvt_type const& cdect = use_facet<cdecvt_type>(loc);
+ {
+ cdecvt_type::state_type state;
+ memset(&state, 0, sizeof(cdecvt_type::state_type));
+ string from("abcdef");
+ int res = cdect.length(state, from.data(), from.data() + from.size(), from.size());
+ CPPUNIT_ASSERT( (size_t)res == from.size() );
+ }
+ }
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+#endif
+}
+
+#if !defined (STLPORT) || !(defined (_STLP_NO_WCHAR_T) || !defined (_STLP_USE_EXCEPTIONS))
+typedef std::codecvt<wchar_t, char, mbstate_t> my_codecvt_base;
+
+class my_codecvt : public my_codecvt_base {
+public:
+ explicit my_codecvt(size_t r = 0)
+ : my_codecvt_base(r) {}
+
+protected:
+ virtual result do_in(state_type& /*state*/, const extern_type* first1,
+ const extern_type* last1, const extern_type*& next1,
+ intern_type* first2, intern_type* last2,
+ intern_type*& next2) const {
+ for ( next1 = first1, next2 = first2; next1 < last1; next1 += 2 ) {
+ if ( (last1 - next1) < 2 || (last2 - next2) < 1 )
+ return partial;
+ *next2++ = (intern_type)((*(next1 + 1) << 8) | (*next1 & 255));
+ }
+ return ok;
+ }
+ virtual bool do_always_noconv() const __NO_THROW
+ { return false; }
+ virtual int do_max_length() const __NO_THROW
+ { return 2; }
+ virtual int do_encoding() const __NO_THROW
+ { return 2; }
+};
+#endif
+
+void CodecvtTest::imbue_while_reading()
+{
+#if !defined (STLPORT) || !(defined (_STLP_NO_WCHAR_T) || !defined (_STLP_USE_EXCEPTIONS))
+ {
+ wofstream ofs( "test.txt" );
+ const wchar_t buf[] = L" ";
+ for ( int i = 0; i < 4098; ++i ) {
+ ofs << buf[0];
+ }
+ }
+
+ wifstream ifs("test.txt"); // a file containing 4098 wchars
+
+ ifs.imbue( locale(locale(), new my_codecvt) );
+ ifs.get();
+ ifs.seekg(0);
+ ifs.imbue( locale() );
+ ifs.ignore(4096);
+ int ch = ifs.get();
+ CPPUNIT_CHECK( ch != (int)WEOF );
+#endif
+}
+
+void CodecvtTest::special_encodings()
+{
+#if !defined (STLPORT) || (!defined (_STLP_NO_WCHAR_T) && defined (_STLP_USE_EXCEPTIONS))
+ {
+ locale loc(locale::classic(), new codecvt_byname<wchar_t, char, mbstate_t>("C"));
+ codecvt<wchar_t, char, mbstate_t> const& cvt = use_facet<codecvt<wchar_t, char, mbstate_t> >(loc);
+ mbstate_t state;
+ memset(&state, 0, sizeof(mbstate_t));
+ char c = '0';
+ const char *from_next;
+ wchar_t wc;
+ wchar_t *to_next;
+ CPPUNIT_ASSERT( cvt.in(state, &c, &c + 1, from_next, &wc, &wc, to_next) == codecvt_base::ok );
+ CPPUNIT_ASSERT( to_next == &wc );
+ CPPUNIT_ASSERT( cvt.in(state, &c, &c + 1, from_next, &wc, &wc + 1, to_next) == codecvt_base::ok );
+ CPPUNIT_ASSERT( wc == L'0' );
+ CPPUNIT_ASSERT( to_next == &wc + 1 );
+ }
+ try
+ {
+ wstring cp936_wstr;
+ const string cp936_str = "\xd6\xd0\xb9\xfa\xc9\xe7\xbb\xe1\xbf\xc6\xd1\xa7\xd4\xba\xb7\xa2\xb2\xbc\x32\x30\x30\x38\xc4\xea\xa1\xb6\xbe\xad\xbc\xc3\xc0\xb6\xc6\xa4\xca\xe9\xa1\xb7\xd6\xb8\xb3\xf6\xa3\xac\x32\x30\x30\x37\xc4\xea\xd6\xd0\xb9\xfa\xbe\xad\xbc\xc3\xd4\xf6\xb3\xa4\xd3\xc9\xc6\xab\xbf\xec\xd7\xaa\xcf\xf2\xb9\xfd\xc8\xc8\xb5\xc4\xc7\xf7\xca\xc6\xc3\xf7\xcf\xd4\xd4\xa4\xbc\xc6\xc8\xab\xc4\xea\x47\x44\x50\xd4\xf6\xcb\xd9\xbd\xab\xb4\xef\x31\x31\x2e\x36\x25\xa1\xa3";
+ locale loc(locale::classic(), ".936", locale::ctype);
+ codecvt<wchar_t, char, mbstate_t> const& cvt = use_facet<codecvt<wchar_t, char, mbstate_t> >(loc);
+ mbstate_t state;
+ memset(&state, 0, sizeof(mbstate_t));
+
+ codecvt_base::result res;
+
+ {
+ wchar_t wbuf[4096];
+ // Check we will have enough room for the generated wide string generated from the whole char buffer:
+ int len = cvt.length(state, cp936_str.data(), cp936_str.data() + cp936_str.size(), sizeof(wbuf) / sizeof(wchar_t));
+ CPPUNIT_ASSERT( cp936_str.size() == (size_t)len );
+
+ const char *from_next;
+ wchar_t *to_next;
+ res = cvt.in(state, cp936_str.data(), cp936_str.data() + cp936_str.size(), from_next,
+ wbuf, wbuf + sizeof(wbuf) / sizeof(wchar_t), to_next);
+ CPPUNIT_ASSERT( res == codecvt_base::ok );
+ CPPUNIT_ASSERT( from_next == cp936_str.data() + cp936_str.size() );
+ cp936_wstr.assign(wbuf, to_next);
+ }
+
+ {
+ const wchar_t *from_next;
+ char buf[4096];
+ char *to_next;
+ res = cvt.out(state, cp936_wstr.data(), cp936_wstr.data() + cp936_wstr.size(), from_next,
+ buf, buf + sizeof(buf), to_next);
+ CPPUNIT_ASSERT( res == codecvt_base::ok );
+ CPPUNIT_CHECK( string(buf, to_next) == cp936_str );
+ }
+ }
+ catch (const runtime_error&)
+ {
+ CPPUNIT_MESSAGE("Not enough platform localization support to check 936 code page encoding.");
+ }
+ try
+ {
+ const string utf8_str = "\xe4\xb8\xad\xe5\x9b\xbd\xe7\xa4\xbe\xe4\xbc\x9a\xe7\xa7\x91\xe5\xad\xa6\xe9\x99\xa2\xe5\x8f\x91\xe5\xb8\x83\x32\x30\x30\x38\xe5\xb9\xb4\xe3\x80\x8a\xe7\xbb\x8f\xe6\xb5\x8e\xe8\x93\x9d\xe7\x9a\xae\xe4\xb9\xa6\xe3\x80\x8b\xe6\x8c\x87\xe5\x87\xba\xef\xbc\x8c\x32\x30\x30\x37\xe5\xb9\xb4\xe4\xb8\xad\xe5\x9b\xbd\xe7\xbb\x8f\xe6\xb5\x8e\xe5\xa2\x9e\xe9\x95\xbf\xe7\x94\xb1\xe5\x81\x8f\xe5\xbf\xab\xe8\xbd\xac\xe5\x90\x91\xe8\xbf\x87\xe7\x83\xad\xe7\x9a\x84\xe8\xb6\x8b\xe5\x8a\xbf\xe6\x98\x8e\xe6\x98\xbe\xe9\xa2\x84\xe8\xae\xa1\xe5\x85\xa8\xe5\xb9\xb4\x47\x44\x50\xe5\xa2\x9e\xe9\x80\x9f\xe5\xb0\x86\xe8\xbe\xbe\x31\x31\x2e\x36\x25\xe3\x80\x82";
+ wstring utf8_wstr;
+ locale loc(locale::classic(), new codecvt_byname<wchar_t, char, mbstate_t>(".utf8"));
+ codecvt<wchar_t, char, mbstate_t> const& cvt = use_facet<codecvt<wchar_t, char, mbstate_t> >(loc);
+ mbstate_t state;
+ memset(&state, 0, sizeof(mbstate_t));
+
+ codecvt_base::result res;
+
+ {
+ wchar_t wbuf[4096];
+ // Check we will have enough room for the wide string generated from the whole char buffer:
+ int len = cvt.length(state, utf8_str.data(), utf8_str.data() + utf8_str.size(), sizeof(wbuf) / sizeof(wchar_t));
+ CPPUNIT_ASSERT( utf8_str.size() == (size_t)len );
+
+ const char *from_next;
+ wchar_t *to_next;
+ res = cvt.in(state, utf8_str.data(), utf8_str.data() + utf8_str.size(), from_next,
+ wbuf, wbuf + sizeof(wbuf) / sizeof(wchar_t), to_next);
+ CPPUNIT_ASSERT( res == codecvt_base::ok );
+ CPPUNIT_ASSERT( from_next == utf8_str.data() + utf8_str.size() );
+ utf8_wstr.assign(wbuf, to_next);
+
+ // Try to read one char after the other:
+ wchar_t wc;
+ const char* from = utf8_str.data();
+ const char* from_end = from + utf8_str.size();
+ from_next = utf8_str.data();
+ size_t length = 1;
+ size_t windex = 0;
+ while (from + length <= from_end) {
+ res = cvt.in(state, from, from + length, from_next,
+ &wc, &wc + 1, to_next);
+ switch (res) {
+ case codecvt_base::ok:
+ // reset length:
+ from = from_next;
+ length = 1;
+ CPPUNIT_ASSERT( wc == utf8_wstr[windex++] );
+ wc = 0;
+ break;
+ case codecvt_base::partial:
+ if (from_next == from)
+ // from_next hasn't move so we have to pass more chars
+ ++length;
+ else
+ // char between from and from_next has been eaten, we simply restart
+ // conversion from from_next:
+ from = from_next;
+ continue;
+ case codecvt_base::error:
+ case codecvt_base::noconv:
+ CPPUNIT_FAIL;
+ //break;
+ }
+ }
+ CPPUNIT_ASSERT( windex == utf8_wstr.size() );
+ }
+
+ {
+ const wchar_t *from_next;
+ char buf[4096];
+ char *to_next;
+ res = cvt.out(state, utf8_wstr.data(), utf8_wstr.data() + utf8_wstr.size(), from_next,
+ buf, buf + sizeof(buf), to_next);
+ CPPUNIT_ASSERT( res == codecvt_base::ok );
+ CPPUNIT_CHECK( string(buf, to_next) == utf8_str );
+ }
+
+ {
+ // Check that an obviously wrong UTF8 encoded string is correctly detected:
+ const string bad_utf8_str("\xdf\xdf\xdf\xdf\xdf");
+ wchar_t wc;
+ const char *from_next;
+ wchar_t *to_next;
+ res = cvt.in(state, bad_utf8_str.data(), bad_utf8_str.data() + bad_utf8_str.size(), from_next,
+ &wc, &wc + 1, to_next);
+ CPPUNIT_ASSERT( res == codecvt_base::error );
+ }
+ }
+ catch (const runtime_error&)
+ {
+ CPPUNIT_MESSAGE("Not enough platform localization support to check UTF8 encoding.");
+ }
+#endif
+}
+
+#endif
diff --git a/sources/android/stlport/test/unit/collate_facets_test.cpp b/sources/android/stlport/test/unit/collate_facets_test.cpp
new file mode 100644
index 0000000..b6a1b14
--- /dev/null
+++ b/sources/android/stlport/test/unit/collate_facets_test.cpp
@@ -0,0 +1,279 @@
+#include "locale_test.h"
+
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# include <locale>
+# include <stdexcept>
+# include <algorithm>
+# include <vector>
+
+# if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+# endif
+
+//
+// tests implementation
+//
+void LocaleTest::collate_facet()
+{
+ {
+ CPPUNIT_ASSERT( has_facet<collate<char> >(locale::classic()) );
+ collate<char> const& col = use_facet<collate<char> >(locale::classic());
+
+ char const str1[] = "abcdef1";
+ char const str2[] = "abcdef2";
+ const size_t size1 = sizeof(str1) / sizeof(str1[0]) - 1;
+ const size_t size2 = sizeof(str2) / sizeof(str2[0]) - 1;
+
+ CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 1) == 0 );
+ CPPUNIT_ASSERT( col.compare(str1, str1 + size1, str2, str2 + size2) == -1 );
+
+ //Smallest string should be before largest one:
+ CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 2, str2, str2 + size2 - 1) == -1 );
+ CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 2) == 1 );
+ }
+
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ try {
+ locale loc("fr_FR");
+ {
+ CPPUNIT_ASSERT( has_facet<collate<char> >(loc) );
+ collate<char> const& col = use_facet<collate<char> >(loc);
+
+ char const str1[] = "abcdef1";
+ char const str2[] = "abcdef2";
+ const size_t size1 = sizeof(str1) / sizeof(str1[0]) - 1;
+ const size_t size2 = sizeof(str2) / sizeof(str2[0]) - 1;
+
+ CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 1) == 0 );
+ CPPUNIT_ASSERT( col.compare(str1, str1 + size1, str2, str2 + size2) == -1 );
+
+ //Smallest string should be before largest one:
+ CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 2, str2, str2 + size2 - 1) == -1 );
+ CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 2) == 1 );
+ }
+ {
+ CPPUNIT_ASSERT( has_facet<collate<char> >(loc) );
+ collate<char> const& col = use_facet<collate<char> >(loc);
+
+ string strs[] = {"abdd", "abçd", "abbd", "abcd"};
+
+ string transformed[4];
+ for (size_t i = 0; i < 4; ++i) {
+ transformed[i] = col.transform(strs[i].data(), strs[i].data() + strs[i].size());
+ }
+
+ sort(strs, strs + 4, loc);
+ CPPUNIT_ASSERT( strs[0] == "abbd" );
+ CPPUNIT_ASSERT( strs[1] == "abcd" );
+ CPPUNIT_ASSERT( strs[2] == "abçd" );
+ CPPUNIT_ASSERT( strs[3] == "abdd" );
+
+ sort(transformed, transformed + 4);
+
+ CPPUNIT_ASSERT( col.transform(strs[0].data(), strs[0].data() + strs[0].size()) == transformed[0] );
+ CPPUNIT_ASSERT( col.transform(strs[1].data(), strs[1].data() + strs[1].size()) == transformed[1] );
+ CPPUNIT_ASSERT( col.transform(strs[2].data(), strs[2].data() + strs[2].size()) == transformed[2] );
+ CPPUNIT_ASSERT( col.transform(strs[3].data(), strs[3].data() + strs[3].size()) == transformed[3] );
+
+ // Check empty string result in empty key.
+ CPPUNIT_ASSERT( col.transform(strs[0].data(), strs[0].data()).empty() );
+
+ // Check that only characters that matter are taken into accout to build the key.
+ CPPUNIT_ASSERT( col.transform(strs[0].data(), strs[0].data() + 2) == col.transform(strs[1].data(), strs[1].data() + 2) );
+ }
+# if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
+ {
+ CPPUNIT_ASSERT( has_facet<collate<wchar_t> >(loc) );
+ collate<wchar_t> const& col = use_facet<collate<wchar_t> >(loc);
+
+ wchar_t const str1[] = L"abcdef1";
+ wchar_t const str2[] = L"abcdef2";
+ const size_t size1 = sizeof(str1) / sizeof(str1[0]) - 1;
+ const size_t size2 = sizeof(str2) / sizeof(str2[0]) - 1;
+
+ CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 1) == 0 );
+ CPPUNIT_ASSERT( col.compare(str1, str1 + size1, str2, str2 + size2) == -1 );
+
+ //Smallest string should be before largest one:
+ CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 2, str2, str2 + size2 - 1) == -1 );
+ CPPUNIT_ASSERT( col.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 2) == 1 );
+ }
+ {
+ size_t i;
+ CPPUNIT_ASSERT( has_facet<collate<wchar_t> >(loc) );
+ collate<wchar_t> const& col = use_facet<collate<wchar_t> >(loc);
+
+ // Here we would like to use L"abçd" but it looks like all compilers
+ // do not support storage of unicode characters in exe resulting in
+ // compilation error. We avoid this test for the moment.
+ wstring strs[] = {L"abdd", L"abcd", L"abbd", L"abcd"};
+
+ wstring transformed[4];
+ for (i = 0; i < 4; ++i) {
+ transformed[i] = col.transform(strs[i].data(), strs[i].data() + strs[i].size());
+ }
+
+ sort(strs, strs + 4, loc);
+ CPPUNIT_ASSERT( strs[0] == L"abbd" );
+ CPPUNIT_ASSERT( strs[1] == L"abcd" );
+ CPPUNIT_ASSERT( strs[2] == L"abcd" );
+ CPPUNIT_ASSERT( strs[3] == L"abdd" );
+
+ sort(transformed, transformed + 4);
+
+ CPPUNIT_ASSERT( col.transform(strs[0].data(), strs[0].data() + strs[0].size()) == transformed[0] );
+ CPPUNIT_ASSERT( col.transform(strs[1].data(), strs[1].data() + strs[1].size()) == transformed[1] );
+ CPPUNIT_ASSERT( col.transform(strs[2].data(), strs[2].data() + strs[2].size()) == transformed[2] );
+ CPPUNIT_ASSERT( col.transform(strs[3].data(), strs[3].data() + strs[3].size()) == transformed[3] );
+
+ CPPUNIT_ASSERT( col.transform(strs[0].data(), strs[0].data()).empty() );
+
+ CPPUNIT_ASSERT( col.transform(strs[0].data(), strs[0].data() + 2) == col.transform(strs[1].data(), strs[1].data() + 2) );
+ }
+# endif
+ }
+ catch (runtime_error const&) {
+ CPPUNIT_MESSAGE("No french locale to check collate facet");
+ }
+# endif
+}
+
+void LocaleTest::collate_by_name()
+{
+ /*
+ * Check of the 22.1.1.2.7 standard point. Construction of a locale
+ * instance from a null pointer or an unknown name should result in
+ * a runtime_error exception.
+ */
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+# if defined (STLPORT) || !defined (__GNUC__)
+ try {
+ locale loc(locale::classic(), new collate_byname<char>(static_cast<char const*>(0)));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+
+ try {
+ locale loc(locale::classic(), new collate_byname<char>("yasli_language"));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ string veryLongFacetName("LC_COLLATE=");
+ veryLongFacetName.append(512, '?');
+ locale loc(locale::classic(), new collate_byname<char>(veryLongFacetName.c_str()));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ locale loc(locale::classic(), "C", locale::collate);
+ }
+ catch (runtime_error const& e) {
+ CPPUNIT_MESSAGE( e.what() );
+ CPPUNIT_FAIL;
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ // On platform without real localization support we should rely on the "C" facet.
+ locale loc(locale::classic(), "", locale::collate);
+ }
+ catch (runtime_error const& e) {
+ CPPUNIT_MESSAGE( e.what() );
+ CPPUNIT_FAIL;
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ locale loc(locale::classic(), new collate_byname<char>("C"));
+
+ //We check that the C locale gives a lexicographical comparison:
+ collate<char> const& cfacet_byname = use_facet<collate<char> >(loc);
+ collate<char> const& cfacet = use_facet<collate<char> >(locale::classic());
+
+ char const str1[] = "abcdef1";
+ char const str2[] = "abcdef2";
+ const size_t size1 = sizeof(str1) / sizeof(str1[0]) - 1;
+ const size_t size2 = sizeof(str2) / sizeof(str2[0]) - 1;
+
+ CPPUNIT_ASSERT( cfacet_byname.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 1) ==
+ cfacet.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 1) );
+ CPPUNIT_ASSERT( cfacet_byname.compare(str1, str1 + size1, str2, str2 + size2) ==
+ cfacet.compare(str1, str1 + size1, str2, str2 + size2) );
+
+ //Smallest string should be before largest one:
+ CPPUNIT_ASSERT( cfacet_byname.compare(str1, str1 + size1 - 2, str2, str2 + size2 - 1) ==
+ cfacet.compare(str1, str1 + size1 - 2, str2, str2 + size2 - 1) );
+ CPPUNIT_ASSERT( cfacet_byname.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 2) ==
+ cfacet.compare(str1, str1 + size1 - 1, str2, str2 + size2 - 2) );
+
+ // We cannot play with 'ç' char here because doing so would make test result
+ // dependant on char being consider as signed or not...
+ string strs[] = {"abdd", /* "abçd",*/ "abbd", "abcd"};
+
+ vector<string> v1(strs, strs + sizeof(strs) / sizeof(strs[0]));
+ sort(v1.begin(), v1.end(), loc);
+ vector<string> v2(strs, strs + sizeof(strs) / sizeof(strs[0]));
+ sort(v2.begin(), v2.end(), locale::classic());
+ CPPUNIT_ASSERT( v1 == v2 );
+
+ CPPUNIT_ASSERT( (cfacet_byname.transform(v1[0].data(), v1[0].data() + v1[0].size()).compare(cfacet_byname.transform(v1[1].data(), v1[1].data() + v1[1].size())) ==
+ v1[0].compare(v1[1])) );
+ }
+ catch (runtime_error const& /* e */) {
+ /* CPPUNIT_MESSAGE( e.what() ); */
+ CPPUNIT_FAIL;
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+# if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
+# if defined (STLPORT) || !defined (__GNUC__)
+ try {
+ locale loc(locale::classic(), new collate_byname<wchar_t>(static_cast<char const*>(0)));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+
+ try {
+ locale loc(locale::classic(), new collate_byname<wchar_t>("yasli_language"));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+# endif
+}
+
+#endif
diff --git a/sources/android/stlport/test/unit/complete_digits.h b/sources/android/stlport/test/unit/complete_digits.h
new file mode 100644
index 0000000..0a3d933
--- /dev/null
+++ b/sources/android/stlport/test/unit/complete_digits.h
@@ -0,0 +1,19 @@
+#ifndef STLP_DIGITS_H
+#define STLP_DIGITS_H
+
+#include <string>
+
+inline void
+#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+complete_digits(std::string &digits)
+#else
+complete_digits(string &digits)
+#endif
+{
+ while (digits.size() < 2)
+ {
+ digits.insert(digits.begin(), '0');
+ }
+}
+
+#endif
diff --git a/sources/android/stlport/test/unit/complex_header_test.cpp b/sources/android/stlport/test/unit/complex_header_test.cpp
new file mode 100644
index 0000000..367f3d0
--- /dev/null
+++ b/sources/android/stlport/test/unit/complex_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <complex>
diff --git a/sources/android/stlport/test/unit/config_test.cpp b/sources/android/stlport/test/unit/config_test.cpp
new file mode 100644
index 0000000..92846ba
--- /dev/null
+++ b/sources/android/stlport/test/unit/config_test.cpp
@@ -0,0 +1,121 @@
+#include <new>
+#include <vector>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if defined (_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class ConfigTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(ConfigTest);
+#if !defined (STLPORT)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(placement_new_bug);
+ CPPUNIT_TEST(endianess);
+ CPPUNIT_TEST(template_function_partial_ordering);
+#if !defined (_STLP_USE_EXCEPTIONS)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(new_throw_bad_alloc);
+ CPPUNIT_TEST_SUITE_END();
+
+ protected:
+ void placement_new_bug();
+ void endianess();
+ void template_function_partial_ordering();
+ void new_throw_bad_alloc();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(ConfigTest);
+
+void ConfigTest::placement_new_bug()
+{
+#if defined (STLPORT)
+ int int_val = 1;
+ int *pint;
+ pint = new(&int_val) int();
+ CPPUNIT_ASSERT( pint == &int_val );
+# if defined (_STLP_DEF_CONST_PLCT_NEW_BUG)
+ CPPUNIT_ASSERT( int_val != 0 );
+# else
+ CPPUNIT_ASSERT( int_val == 0 );
+# endif
+#endif
+}
+
+void ConfigTest::endianess()
+{
+#if defined (STLPORT)
+ int val = 0x01020304;
+ char *ptr = (char*)(&val);
+# if defined (_STLP_BIG_ENDIAN)
+ //This test only work if sizeof(int) == 4, this is a known limitation
+ //that will be handle the day we find a compiler for which it is false.
+ CPPUNIT_ASSERT( *ptr == 0x01 ||
+ sizeof(int) > 4 && *ptr == 0x00 );
+# elif defined (_STLP_LITTLE_ENDIAN)
+ CPPUNIT_ASSERT( *ptr == 0x04 );
+# endif
+#endif
+}
+
+void ConfigTest::template_function_partial_ordering()
+{
+#if defined (STLPORT)
+ vector<int> vect1(10, 0);
+ int* pvect1Front = &vect1.front();
+ vector<int> vect2(10, 0);
+ int* pvect2Front = &vect2.front();
+
+ swap(vect1, vect2);
+
+# if defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) || defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ CPPUNIT_ASSERT( pvect1Front == &vect2.front() );
+ CPPUNIT_ASSERT( pvect2Front == &vect1.front() );
+# else
+ CPPUNIT_ASSERT( pvect1Front != &vect2.front() );
+ CPPUNIT_ASSERT( pvect2Front != &vect1.front() );
+# endif
+#endif
+}
+
+void ConfigTest::new_throw_bad_alloc()
+{
+#if defined (STLPORT) && defined (_STLP_USE_EXCEPTIONS)
+ try
+ {
+ /* We try to exhaust heap memory. However, we don't actually use the
+ largest possible size_t value bus slightly less in order to avoid
+ triggering any overflows due to the allocator adding some more for
+ its internal data structures. */
+ size_t const huge_amount = size_t(-1) - 1024;
+ void* pvoid = operator new (huge_amount);
+#if !defined (_STLP_NEW_DONT_THROW_BAD_ALLOC)
+ // Allocation should have fail
+ CPPUNIT_ASSERT( pvoid != 0 );
+#endif
+ // Just in case it succeeds:
+ operator delete(pvoid);
+ }
+ catch (const bad_alloc&)
+ {
+#if defined (_STLP_NEW_DONT_THROW_BAD_ALLOC)
+ // Looks like your compiler new operator finally throw bad_alloc, you can fix
+ // configuration.
+ CPPUNIT_FAIL;
+#endif
+ }
+ catch (...)
+ {
+ //We shouldn't be there:
+ //Not bad_alloc exception thrown.
+ CPPUNIT_FAIL;
+ }
+#endif
+}
diff --git a/sources/android/stlport/test/unit/copy_test.cpp b/sources/android/stlport/test/unit/copy_test.cpp
new file mode 100644
index 0000000..852e687
--- /dev/null
+++ b/sources/android/stlport/test/unit/copy_test.cpp
@@ -0,0 +1,129 @@
+#include <algorithm>
+#include <cstring>
+#include <vector>
+#include <iterator>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class CopyTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(CopyTest);
+ CPPUNIT_TEST(copy_array);
+ CPPUNIT_TEST(copy_volatile);
+ CPPUNIT_TEST(copy_vector);
+ CPPUNIT_TEST(copy_insert);
+ CPPUNIT_TEST(copy_back);
+ CPPUNIT_TEST(copy_back_array);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void copy_array();
+ void copy_volatile();
+ void copy_vector();
+ void copy_insert();
+ void copy_back();
+ void copy_back_array();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(CopyTest);
+
+//
+// tests implementation
+//
+void CopyTest::copy_array()
+{
+ char string[23] = "A string to be copied.";
+ char result[23];
+ copy(string, string + 23, result);
+ CPPUNIT_ASSERT(!strncmp(string, result, 23));
+}
+
+void CopyTest::copy_volatile()
+{
+ {
+ int a[] = {0, 1, 2, 3, 4, 5};
+ const size_t size = sizeof(a) / sizeof(a[0]);
+ volatile int va[size];
+ copy(a, a + size, va);
+ for (size_t i = 0; i != size; ++i) {
+ CPPUNIT_ASSERT( a[i] == va[i] );
+ }
+ }
+
+ {
+ const int a[] = {0, 1, 2, 3, 4, 5};
+ const size_t size = sizeof(a) / sizeof(a[0]);
+ volatile int va[size];
+ copy(a, a + size, va);
+ for (size_t i = 0; i != size; ++i) {
+ CPPUNIT_ASSERT( a[i] == va[i] );
+ }
+ }
+
+ // Following code can be activated to check that it doesn't compiled
+#if 0
+ {
+ int a[] = {0, 1, 2, 3, 4, 5};
+ const size_t size = sizeof(a) / sizeof(a[0]);
+ const volatile int va[size] = {5, 4, 3, 2, 1, 0};
+ copy(a, a + size, va);
+ for (size_t i = 0; i != size; ++i) {
+ CPPUNIT_ASSERT( a[i] == va[i] );
+ }
+ }
+#endif
+}
+
+void CopyTest::copy_vector()
+{
+ vector<int> v1(10);
+ for (int i = 0; (size_t)i < v1.size(); ++i)
+ v1[i] = i;
+
+ vector<int> v2(v1.size());
+ copy(v1.begin(), v1.end(), v2.begin());
+
+ CPPUNIT_ASSERT( v2 == v1 );
+}
+
+void CopyTest::copy_insert() {
+ vector<int> v1(10);
+ for (int loc = 0; (size_t)loc < v1.size(); ++loc)
+ v1[loc] = loc;
+ vector<int> v2;
+ insert_iterator<vector<int> > i(v2, v2.begin());
+ copy(v1.begin(), v1.end(), i);
+
+ CPPUNIT_ASSERT( v2 == v1 );
+}
+
+void CopyTest::copy_back()
+{
+ vector<int> v1(10);
+ for (int i = 0; (size_t)i < v1.size(); ++i)
+ v1[i] = i;
+ vector<int> v2(v1.size());
+ copy_backward(v1.begin(), v1.end(), v2.end());
+
+ CPPUNIT_ASSERT( v2 == v1 );
+}
+
+void CopyTest::copy_back_array()
+{
+ int numbers[5] = { 1, 2, 3, 4, 5 };
+
+ int result[5];
+ copy_backward(numbers, numbers + 5, (int*)result + 5);
+ CPPUNIT_ASSERT(result[0]==numbers[0]);
+ CPPUNIT_ASSERT(result[1]==numbers[1]);
+ CPPUNIT_ASSERT(result[2]==numbers[2]);
+ CPPUNIT_ASSERT(result[3]==numbers[3]);
+ CPPUNIT_ASSERT(result[4]==numbers[4]);
+}
diff --git a/sources/android/stlport/test/unit/count_test.cpp b/sources/android/stlport/test/unit/count_test.cpp
new file mode 100644
index 0000000..edf96e0
--- /dev/null
+++ b/sources/android/stlport/test/unit/count_test.cpp
@@ -0,0 +1,73 @@
+#include <algorithm>
+#include <vector>
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class CountTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(CountTest);
+ CPPUNIT_TEST(count0);
+ CPPUNIT_TEST(count1);
+ CPPUNIT_TEST(countif1);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void count0();
+ void count1();
+ void countif1();
+ static int odd(int a_);
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(CountTest);
+
+//
+// tests implementation
+//
+void CountTest::count0()
+{
+ int numbers[10] = { 1, 2, 4, 1, 2, 4, 1, 2, 4, 1 };
+
+ int result = count(numbers, numbers + 10, 1);
+ CPPUNIT_ASSERT(result==4);
+#if defined (STLPORT) && !defined (_STLP_NO_ANACHRONISMS)
+ result = 0;
+ count(numbers, numbers + 10, 1, result);
+ CPPUNIT_ASSERT(result==4);
+#endif
+}
+void CountTest::count1()
+{
+ vector <int> numbers(100);
+ for(int i = 0; i < 100; i++)
+ numbers[i] = i % 3;
+ int elements = count(numbers.begin(), numbers.end(), 2);
+ CPPUNIT_ASSERT(elements==33);
+#if defined (STLPORT) && !defined (_STLP_NO_ANACHRONISMS)
+ elements = 0;
+ count(numbers.begin(), numbers.end(), 2, elements);
+ CPPUNIT_ASSERT(elements==33);
+#endif
+}
+void CountTest::countif1()
+{
+ vector <int> numbers(100);
+ for(int i = 0; i < 100; i++)
+ numbers[i] = i % 3;
+ int elements = count_if(numbers.begin(), numbers.end(), odd);
+ CPPUNIT_ASSERT(elements==33);
+#if defined (STLPORT) && !defined (_STLP_NO_ANACHRONISMS)
+ elements = 0;
+ count_if(numbers.begin(), numbers.end(), odd, elements);
+ CPPUNIT_ASSERT(elements==33);
+#endif
+}
+int CountTest::odd(int a_)
+{
+ return a_ % 2;
+}
diff --git a/sources/android/stlport/test/unit/cppunit/cppunit_mini.h b/sources/android/stlport/test/unit/cppunit/cppunit_mini.h
new file mode 100644
index 0000000..98b4a7a
--- /dev/null
+++ b/sources/android/stlport/test/unit/cppunit/cppunit_mini.h
@@ -0,0 +1,225 @@
+/*
+ * Copyright (c) 2003, 2004
+ * Zdenek Nemec
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* $Id$ */
+
+#ifndef _CPPUNITMPFR_H_
+#define _CPPUNITMPFR_H_
+
+#if 0
+# define CPPUNIT_NS CppUnitMini
+#else
+# define CPPUNIT_NS
+#endif
+
+#include <string.h>
+
+#if 0
+namespace CPPUNIT_NS
+{
+#endif
+ class Reporter {
+ public:
+ virtual ~Reporter() {}
+ virtual void error(const char * /*macroName*/, const char * /*in_macro*/, const char * /*in_file*/, int /*in_line*/) {}
+ virtual void message( const char * /*msg*/ ) {}
+ virtual void progress( const char * /*in_className*/, const char * /*in_testName*/, bool /*ignored*/, bool /* explicit */) {}
+ virtual void end() {}
+ virtual void printSummary() {}
+ };
+
+ class TestFixture {
+ public:
+ virtual ~TestFixture() {}
+
+ //! \brief Set up context before running a test.
+ virtual void setUp() {}
+
+ //! Clean up after the test run.
+ virtual void tearDown() {}
+ };
+
+ class TestCase : public TestFixture {
+ public:
+ TestCase() { registerTestCase(this); }
+
+ void setUp() { m_failed = false; }
+ static int run(Reporter *in_reporter = 0, const char *in_testName = "", bool invert = false);
+ int numErrors() { return m_numErrors; }
+ static void registerTestCase(TestCase *in_testCase);
+
+ virtual void myRun(const char * /*in_name*/, bool /*invert*/ = false) {}
+
+ virtual void error(const char *in_macroName, const char *in_macro, const char *in_file, int in_line) {
+ m_failed = true;
+ if (m_reporter) {
+ m_reporter->error(in_macroName, in_macro, in_file, in_line);
+ }
+ }
+
+ static void message(const char *msg) {
+ if (m_reporter) {
+ m_reporter->message(msg);
+ }
+ }
+
+ bool equalDoubles(double in_expected, double in_real, double in_maxErr) {
+ double diff = in_expected - in_real;
+ if (diff < 0.) {
+ diff = -diff;
+ }
+ return diff < in_maxErr;
+ }
+
+ virtual void progress(const char *in_className, const char *in_functionName, bool ignored, bool explicitTest) {
+ ++m_numTests;
+ if (m_reporter) {
+ m_reporter->progress(in_className, in_functionName, ignored, explicitTest);
+ }
+ }
+
+ bool shouldRunThis(const char *in_desiredTest, const char *in_className, const char *in_functionName,
+ bool invert, bool explicit_test, bool &do_progress) {
+ if ((in_desiredTest) && (in_desiredTest[0] != '\0')) {
+ do_progress = false;
+ const char *ptr = strstr(in_desiredTest, "::");
+ if (ptr) {
+ bool match = (strncmp(in_desiredTest, in_className, strlen(in_className)) == 0) &&
+ (strncmp(ptr + 2, in_functionName, strlen(in_functionName)) == 0);
+ // Invert shall not make explicit test run:
+ return invert ? (match ? !match : !explicit_test)
+ : match;
+ }
+ bool match = (strcmp(in_desiredTest, in_className) == 0);
+ do_progress = match;
+ return !explicit_test && (match == !invert);
+ }
+ do_progress = true;
+ return !explicit_test;
+ }
+
+ void tearDown() {
+ if (m_failed)
+ ++m_numErrors;
+ m_reporter->end();
+ }
+
+ protected:
+ static int m_numErrors;
+ static int m_numTests;
+
+ private:
+ static TestCase *m_root;
+ TestCase *m_next;
+ bool m_failed;
+
+ static Reporter *m_reporter;
+ };
+#if 0
+}
+#endif
+
+#if !defined (CPPUNIT_MINI_HIDE_UNUSED_VARIABLE)
+# if defined (_MSC_VER)
+# define CPPUNIT_MINI_HIDE_UNUSED_VARIABLE(v) (v);
+# else
+# define CPPUNIT_MINI_HIDE_UNUSED_VARIABLE(v)
+# endif
+#endif
+
+#define CPPUNIT_TEST_SUITE(X) \
+ typedef CPPUNIT_NS::TestCase Base; \
+ virtual void myRun(const char *in_name, bool invert = false) { \
+ const char *className = #X; CPPUNIT_MINI_HIDE_UNUSED_VARIABLE(className) \
+ bool ignoring = false; CPPUNIT_MINI_HIDE_UNUSED_VARIABLE(ignoring)
+
+#if defined CPPUNIT_MINI_USE_EXCEPTIONS
+# define CPPUNIT_TEST_BASE(X, Y) \
+ { \
+ bool do_progress; \
+ bool shouldRun = shouldRunThis(in_name, className, #X, invert, Y, do_progress); \
+ if (shouldRun || do_progress) { \
+ setUp(); \
+ progress(className, #X, ignoring || !shouldRun, !ignoring && Y); \
+ if (shouldRun && !ignoring) { \
+ try { \
+ X(); \
+ } \
+ catch(...) { \
+ Base::error("Test Failed: An Exception was thrown.", #X, __FILE__, __LINE__); \
+ } \
+ } \
+ tearDown(); \
+ } \
+ }
+#else
+# define CPPUNIT_TEST_BASE(X, Y) \
+ { \
+ bool do_progress; \
+ bool shouldRun = shouldRunThis(in_name, className, #X, invert, Y, do_progress); \
+ if (shouldRun || do_progress) { \
+ setUp(); \
+ progress(className, #X, ignoring || !shouldRun, !ignoring && Y); \
+ if (shouldRun && !ignoring) \
+ X(); \
+ tearDown(); \
+ } \
+ }
+#endif
+
+#define CPPUNIT_TEST(X) CPPUNIT_TEST_BASE(X, false)
+#define CPPUNIT_EXPLICIT_TEST(X) CPPUNIT_TEST_BASE(X, true)
+
+#define CPPUNIT_IGNORE \
+ ignoring = true
+
+#define CPPUNIT_STOP_IGNORE \
+ ignoring = false
+
+#define CPPUNIT_TEST_SUITE_END() }
+
+#define CPPUNIT_TEST_SUITE_REGISTRATION(X) static X local
+
+#define CPPUNIT_CHECK(X) \
+ if (!(X)) { \
+ Base::error("CPPUNIT_CHECK", #X, __FILE__, __LINE__); \
+ }
+
+#define CPPUNIT_ASSERT(X) \
+ if (!(X)) { \
+ Base::error("CPPUNIT_ASSERT", #X, __FILE__, __LINE__); \
+ return; \
+ }
+
+#define CPPUNIT_FAIL { \
+ Base::error("CPPUNIT_FAIL", "", __FILE__, __LINE__); \
+ return; \
+ }
+
+#define CPPUNIT_ASSERT_EQUAL(X, Y) \
+ if ((X) != (Y)) { \
+ Base::error("CPPUNIT_ASSERT_EQUAL", #X","#Y, __FILE__, __LINE__); \
+ return; \
+ }
+
+#define CPPUNIT_ASSERT_DOUBLES_EQUAL(X, Y, Z) \
+ if (!equalDoubles((X), (Y), (Z))) { \
+ Base::error("CPPUNIT_ASSERT_DOUBLES_EQUAL", #X","#Y","#Z, __FILE__, __LINE__); \
+ return; \
+ }
+
+#define CPPUNIT_MESSAGE(m) CPPUNIT_NS::TestCase::message(m)
+
+#endif
diff --git a/sources/android/stlport/test/unit/cppunit/cppunit_proxy.h b/sources/android/stlport/test/unit/cppunit/cppunit_proxy.h
new file mode 100644
index 0000000..41cdc2a
--- /dev/null
+++ b/sources/android/stlport/test/unit/cppunit/cppunit_proxy.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2003, 2004
+ * Zdenek Nemec
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* $Id$ */
+
+#ifndef _CPPUNITPROXYINTERFACE_H_
+#define _CPPUNITPROXYINTERFACE_H_
+
+/*
+ * STLport specific
+ */
+#if !defined (CPPUNIT_MINI_USE_EXCEPTIONS) && \
+ (!defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS))
+# define CPPUNIT_MINI_USE_EXCEPTIONS
+#endif
+
+#include "cppunit_mini.h"
+
+#endif
diff --git a/sources/android/stlport/test/unit/cppunit/cppunit_timer.h b/sources/android/stlport/test/unit/cppunit/cppunit_timer.h
new file mode 100644
index 0000000..61f9076
--- /dev/null
+++ b/sources/android/stlport/test/unit/cppunit/cppunit_timer.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2006
+ * Francois Dumont
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#ifndef CPPUNIT_TIMER_H
+#define CPPUNIT_TIMER_H
+
+#if defined (_WIN32)
+# define CPPUNIT_WIN32_TIMER
+# include <windows.h>
+#endif
+
+class Timer {
+public:
+ Timer() {
+#if defined (CPPUNIT_WIN32_TIMER)
+ m_start.LowPart = m_restart.LowPart = m_stop.LowPart = 0;
+ m_start.HighPart = m_restart.HighPart = m_stop.HighPart = 0;
+ QueryPerformanceFrequency(&m_frequency);
+#endif
+ }
+
+ void start() {
+#if defined (CPPUNIT_WIN32_TIMER)
+ QueryPerformanceCounter(&m_start);
+#endif
+ }
+
+ void restart() {
+#if defined (CPPUNIT_WIN32_TIMER)
+ QueryPerformanceCounter(&m_restart);
+ if (m_start.HighPart == 0 && m_start.LowPart == 0) {
+ m_start = m_restart;
+ }
+#endif
+ }
+
+ void stop() {
+#if defined (CPPUNIT_WIN32_TIMER)
+ LARGE_INTEGER stop;
+ QueryPerformanceCounter(&stop);
+ if ((m_stop.HighPart != 0 || m_stop.LowPart != 0) &&
+ m_restart.HighPart != 0 && m_restart.LowPart != 0) {
+ m_stop.HighPart += (stop.HighPart - m_restart.HighPart);
+ if (stop.LowPart < m_restart.LowPart) {
+ if (m_restart.LowPart - stop.LowPart > m_stop.LowPart) {
+ m_stop.HighPart -= 1;
+ }
+ m_stop.LowPart -= m_restart.LowPart - stop.LowPart;
+ }
+ else {
+ if (stop.LowPart - m_restart.LowPart > 0xFFFFFFFF - m_stop.LowPart) {
+ m_stop.HighPart += 1;
+ }
+ m_stop.LowPart += stop.LowPart - m_restart.LowPart;
+ }
+ }
+ else {
+ m_stop = stop;
+ }
+#endif
+ }
+
+ double elapsedMilliseconds() const {
+#if defined (CPPUNIT_WIN32_TIMER)
+ LARGE_INTEGER elapsed;
+ elapsed.HighPart = m_stop.HighPart - m_start.HighPart;
+ elapsed.LowPart = m_stop.LowPart - m_start.LowPart;
+ return (double)elapsed.QuadPart / (double)m_frequency.QuadPart * 1000;
+#else
+ return 0;
+#endif
+ }
+
+ static bool supported() {
+#if defined (CPPUNIT_WIN32_TIMER)
+ return true;
+#else
+ return false;
+#endif
+ }
+
+private:
+#if defined (CPPUNIT_WIN32_TIMER)
+ LARGE_INTEGER m_frequency;
+ LARGE_INTEGER m_start, m_stop, m_restart;
+#endif
+};
+
+#endif
diff --git a/sources/android/stlport/test/unit/cppunit/file_reporter.h b/sources/android/stlport/test/unit/cppunit/file_reporter.h
new file mode 100644
index 0000000..2c7633b
--- /dev/null
+++ b/sources/android/stlport/test/unit/cppunit/file_reporter.h
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2003, 2004
+ * Zdenek Nemec
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+/* $Id$ */
+
+#ifndef _CPPUNITMINIFILEREPORTERINTERFACE_H_
+#define _CPPUNITMINIFILEREPORTERINTERFACE_H_
+
+#include <stdio.h>
+
+#include "cppunit_timer.h"
+
+//
+// CppUnit mini file(stream) reporter
+//
+class FileReporter : public CPPUNIT_NS::Reporter {
+private:
+ FileReporter(const FileReporter&);
+ FileReporter& operator=(const FileReporter&);
+public:
+ // reporting to stderr
+ explicit FileReporter(bool doMonitor = false):
+ m_numErrors(0), m_numIgnored(0), m_numExplicit(0), m_numTests(0), _myStream(false),
+ m_failed(false), m_doMonitor(doMonitor)
+ { _file = stderr; }
+
+ // reporting to the file with the given name
+ explicit FileReporter(const char* file, bool doMonitor = false):
+ m_numErrors(0), m_numIgnored(0), m_numExplicit(0), m_numTests(0), _myStream(true),
+ m_failed(false), m_doMonitor(doMonitor)
+ {
+#ifndef _STLP_USE_SAFE_STRING_FUNCTIONS
+ _file = fopen(file, "w");
+#else
+ fopen_s(&_file, file, "w");
+#endif
+ }
+
+ // reporting to the given file
+ explicit FileReporter(FILE* stream, bool doMonitor = false):
+ m_numErrors(0), m_numIgnored(0), m_numExplicit(0), m_numTests(0), _myStream(false),
+ m_failed(false), m_doMonitor(doMonitor)
+ { _file = stream; }
+
+ virtual ~FileReporter() {
+ if (_myStream)
+ fclose(_file);
+ else
+ fflush(_file);
+ }
+
+ virtual void error(const char *in_macroName, const char *in_macro, const char *in_file, int in_line) {
+ // Error might be called several times between 2 progress calls, we shouldn't however consider
+ // that a test failed twice so we simply keep the info that test failed, number of failed tests
+ // is computed later in end method.
+ m_failed = true;
+ fprintf(_file, "\n\n%s(%d) : %s(%s);", in_file, in_line, in_macroName, in_macro);
+ }
+
+ virtual void message( const char *msg )
+ { fprintf(_file, "\n\t%s", msg ); }
+
+ virtual void progress(const char *in_className, const char *in_shortTestName, bool ignored, bool explicitTest) {
+ if (m_doMonitor) {
+ m_globalTimer.restart();
+ m_testTimer.start();
+ }
+ ++m_numTests;
+ m_failed = false;
+ if (ignored)
+ ++m_numIgnored;
+ fprintf(_file, "%s::%s", in_className, in_shortTestName);
+ if (ignored) {
+ const char *ignoredReason;
+ if (explicitTest) {
+ ++m_numExplicit;
+ ignoredReason = " EXPLICIT";
+ }
+ else
+ ignoredReason = " IGNORED";
+
+ fprintf(_file, "%s", ignoredReason);
+ }
+ }
+
+ virtual void end() {
+ if (m_doMonitor) {
+ m_globalTimer.stop();
+ m_testTimer.stop();
+ fprintf(_file, " %f msec", m_testTimer.elapsedMilliseconds());
+ }
+ if (m_failed) {
+ ++m_numErrors;
+ }
+ fprintf(_file, "\n");
+ }
+
+ virtual void printSummary() {
+ if (m_numErrors > 0) {
+ fprintf(_file, "\nThere were errors! %d of %d tests", m_numErrors, m_numTests);
+ }
+ else {
+ fprintf(_file, "\nOK %d tests", m_numTests);
+ }
+
+ if (m_numIgnored > 0) {
+ fprintf(_file, ", %d ignored", m_numIgnored);
+ }
+
+ if (m_numExplicit > 0) {
+ fprintf(_file, " (%d explicit)", m_numExplicit);
+ }
+
+ if (m_doMonitor) {
+ fprintf(_file, " %f msec", m_globalTimer.elapsedMilliseconds());
+ }
+
+ fprintf(_file, "\n\n");
+ }
+private:
+ int m_numErrors;
+ int m_numIgnored;
+ int m_numExplicit;
+ int m_numTests;
+ // flag whether we own '_file' and are thus responsible for releasing it in the destructor
+ bool _myStream;
+ bool m_failed;
+ bool m_doMonitor;
+ Timer m_globalTimer, m_testTimer;
+ FILE* _file;
+};
+
+#endif /*_CPPUNITMINIFILEREPORTERINTERFACE_H_*/
diff --git a/sources/android/stlport/test/unit/cppunit/test_main.cpp b/sources/android/stlport/test/unit/cppunit/test_main.cpp
new file mode 100644
index 0000000..8519d4f
--- /dev/null
+++ b/sources/android/stlport/test/unit/cppunit/test_main.cpp
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2003, 2004
+ * Zdenek Nemec
+ *
+ * This material is provided "as is", with absolutely no warranty expressed
+ * or implied. Any use is at your own risk.
+ *
+ * Permission to use or copy this software for any purpose is hereby granted
+ * without fee, provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ *
+ */
+
+#include "cppunit_proxy.h"
+#include "file_reporter.h"
+#include "cppunit_timer.h"
+
+#include "stdio.h"
+
+#if 0
+namespace CPPUNIT_NS
+{
+#endif
+ int TestCase::m_numErrors = 0;
+ int TestCase::m_numTests = 0;
+
+ TestCase *TestCase::m_root = 0;
+ Reporter *TestCase::m_reporter = 0;
+
+ void TestCase::registerTestCase(TestCase *in_testCase) {
+ in_testCase->m_next = m_root;
+ m_root = in_testCase;
+ }
+
+ int TestCase::run(Reporter *in_reporter, const char *in_testName, bool invert) {
+ TestCase::m_reporter = in_reporter;
+
+ m_numErrors = 0;
+ m_numTests = 0;
+
+ TestCase *tmp = m_root;
+ while (tmp != 0) {
+ tmp->myRun(in_testName, invert);
+ tmp = tmp->m_next;
+ }
+ return m_numErrors;
+ }
+#if 0
+}
+#endif
+
+static void usage(const char* name)
+{
+ printf("Usage : %s [-t=<class>[::<test>]] [-x=<class>[::<test>]] [-f=<file>]%s\n",
+ name, Timer::supported() ? " [-m]": "");
+ printf("\t[-t=<class>[::<test>]] : test class or class::test to execute;\n");
+ printf("\t[-x=<class>[::<test>]] : test class or class::test to exclude from execution;\n");
+ printf("\t[-f=<file>] : output file");
+ if (Timer::supported())
+ printf(";\n\t[-m] : monitor test execution, display time duration for each test\n");
+ else
+ printf("\n");
+}
+
+int main(int argc, char** argv) {
+
+ // CppUnit(mini) test launcher
+ // command line option syntax:
+ // test [OPTIONS]
+ // where OPTIONS are
+ // -t=CLASS[::TEST] run the test class CLASS or member test CLASS::TEST
+ // -x=CLASS[::TEST] run all except the test class CLASS or member test CLASS::TEST
+ // -f=FILE save output in file FILE instead of stdout
+ // -m monitor test(s) execution
+ const char *fileName = 0;
+ const char *testName = "";
+ const char *xtestName = "";
+ bool doMonitoring = false;
+
+ for (int i = 1; i < argc; ++i) {
+ if (argv[i][0] == '-') {
+ if (!strncmp(argv[i], "-t=", 3)) {
+ testName = argv[i]+3;
+ continue;
+ }
+ else if (!strncmp(argv[i], "-f=", 3)) {
+ fileName = argv[i]+3;
+ continue;
+ }
+ else if (!strncmp(argv[i], "-x=", 3)) {
+ xtestName = argv[i]+3;
+ continue;
+ }
+ else if (Timer::supported() && !strncmp(argv[i], "-m", 2)) {
+ doMonitoring = true;
+ continue;
+ }
+ }
+
+ // invalid option, we display normal usage.
+ usage(argv[0]);
+ return 1;
+ }
+
+ CPPUNIT_NS::Reporter* reporter;
+ if (fileName != 0)
+ reporter = new FileReporter(fileName, doMonitoring);
+ else
+ reporter = new FileReporter(stdout, doMonitoring);
+
+ int num_errors;
+ if (xtestName[0] != 0) {
+ num_errors = CPPUNIT_NS::TestCase::run(reporter, xtestName, true);
+ } else {
+ num_errors = CPPUNIT_NS::TestCase::run(reporter, testName);
+ }
+
+ reporter->printSummary();
+ delete reporter;
+
+ return num_errors;
+}
+
+// See doc/README.intel for explanation about this code
+#if defined (STLPORT) && defined (__ICL) && (__ICL >= 900) && \
+ (_STLP_MSVC_LIB < 1300) && defined (_STLP_USE_DYNAMIC_LIB)
+# include <exception>
+
+# undef std
+namespace std
+{
+ void _STLP_CALL unexpected() {
+ unexpected_handler hdl;
+ set_unexpected(hdl = set_unexpected((unexpected_handler)0));
+ hdl();
+ }
+}
+#endif
diff --git a/sources/android/stlport/test/unit/csetjmp_header_test.cpp b/sources/android/stlport/test/unit/csetjmp_header_test.cpp
new file mode 100644
index 0000000..b817862
--- /dev/null
+++ b/sources/android/stlport/test/unit/csetjmp_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <csetjmp>
diff --git a/sources/android/stlport/test/unit/csignal_header_test.cpp b/sources/android/stlport/test/unit/csignal_header_test.cpp
new file mode 100644
index 0000000..9a9c6e0
--- /dev/null
+++ b/sources/android/stlport/test/unit/csignal_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <csignal>
diff --git a/sources/android/stlport/test/unit/cstdarg_header_test.cpp b/sources/android/stlport/test/unit/cstdarg_header_test.cpp
new file mode 100644
index 0000000..06cf0a5
--- /dev/null
+++ b/sources/android/stlport/test/unit/cstdarg_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <cstdarg>
diff --git a/sources/android/stlport/test/unit/cstddef_header_test.cpp b/sources/android/stlport/test/unit/cstddef_header_test.cpp
new file mode 100644
index 0000000..201d3f6
--- /dev/null
+++ b/sources/android/stlport/test/unit/cstddef_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <cstddef>
diff --git a/sources/android/stlport/test/unit/cstdio_header_test.cpp b/sources/android/stlport/test/unit/cstdio_header_test.cpp
new file mode 100644
index 0000000..e38a5e9
--- /dev/null
+++ b/sources/android/stlport/test/unit/cstdio_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <cstdio>
diff --git a/sources/android/stlport/test/unit/cstdlib_header_test.cpp b/sources/android/stlport/test/unit/cstdlib_header_test.cpp
new file mode 100644
index 0000000..f356079
--- /dev/null
+++ b/sources/android/stlport/test/unit/cstdlib_header_test.cpp
@@ -0,0 +1,13 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <cstdlib>
+
+//Just an additionnal compilation test for Borland that used to fail here.
+#if defined (__BORLANDC__)
+# include <process.h>
+#endif
diff --git a/sources/android/stlport/test/unit/cstring_header_test.cpp b/sources/android/stlport/test/unit/cstring_header_test.cpp
new file mode 100644
index 0000000..dd5d2cf
--- /dev/null
+++ b/sources/android/stlport/test/unit/cstring_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <cstring>
diff --git a/sources/android/stlport/test/unit/cstring_test.cpp b/sources/android/stlport/test/unit/cstring_test.cpp
new file mode 100644
index 0000000..b51da07
--- /dev/null
+++ b/sources/android/stlport/test/unit/cstring_test.cpp
@@ -0,0 +1,75 @@
+#define _STLP_DO_IMPORT_CSTD_FUNCTIONS
+
+#include <cstring>
+
+#include "cppunit/cppunit_proxy.h"
+
+//This test purpose is to check the right import of math.h C symbols
+//into the std namespace so we do not use the using namespace std
+//specification
+
+//
+// TestCase class
+//
+class CStringTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(CStringTest);
+#if defined (STLPORT) && !defined (_STLP_USE_NAMESPACES)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(import_checks);
+ CPPUNIT_TEST_SUITE_END();
+
+ protected:
+ void import_checks();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(CStringTest);
+
+#if defined (_MSC_VER) && (_MSC_VER >= 1400)
+//For deprecated symbols like strcat, strtok...
+# pragma warning (disable : 4996)
+#endif
+
+//
+// tests implementation
+//
+void CStringTest::import_checks()
+{
+#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+ std::size_t bar = 0;
+ CPPUNIT_CHECK( bar == 0 );
+
+ CPPUNIT_CHECK( std::memchr("foo", 'o', 3) != NULL );
+ CPPUNIT_CHECK( std::memcmp("foo1", "foo2", 3) == 0 );
+ char buf1[1], buf2[1];
+ CPPUNIT_CHECK( std::memcpy(buf1, buf2, 0) != NULL );
+ CPPUNIT_CHECK( std::memmove(buf1, buf2, 0) != NULL );
+ CPPUNIT_CHECK( std::memset(buf1, 0, 1) != NULL );
+ char buf[16]; buf[0] = 0;
+ const char* foo = "foo";
+# if !defined(_WIN32_WCE)
+ CPPUNIT_CHECK( std::strcoll("foo", "foo") == 0 );
+ CPPUNIT_CHECK( std::strerror(0) != NULL );
+# endif
+ CPPUNIT_CHECK( std::strcat((char*)buf, foo) == (char*)buf ); // buf <- foo
+ CPPUNIT_CHECK( std::strchr(foo, 'o') != NULL );
+ CPPUNIT_CHECK( std::strcmp("foo1", "foo2") < 0 );
+ CPPUNIT_CHECK( std::strcpy((char*)buf, foo) == (char*)buf ); // buf <- foo
+ CPPUNIT_CHECK( std::strcspn("foo", "o") == 1 );
+ CPPUNIT_CHECK( std::strlen("foo") == 3 );
+ CPPUNIT_CHECK( std::strncat((char*)buf, foo, 2) == (char*)buf ); // buf <- foofo
+ CPPUNIT_CHECK( std::strncmp("foo1", "foo2", 3) == 0 );
+ CPPUNIT_CHECK( std::strncpy((char*)buf, foo, 3) == (char*)buf ); // buf <- foo
+ CPPUNIT_CHECK( std::strpbrk(foo, "abcdo") == foo + 1 );
+ const char* foofoo = "foofoo";
+ CPPUNIT_CHECK( std::strrchr(foofoo, 'f') == foofoo + 3 );
+ CPPUNIT_CHECK( std::strspn(foofoo, "aofz") == 6 );
+ CPPUNIT_CHECK( std::strstr(foo, "") == foo );
+ char foofoobuf[] = "foofoo";
+ CPPUNIT_CHECK( std::strtok(foofoobuf, "z") != NULL );
+# if !defined(_WIN32_WCE)
+ CPPUNIT_CHECK( std::strxfrm((char*)buf, foo, 3) != 0 );
+# endif
+#endif
+}
diff --git a/sources/android/stlport/test/unit/ctime_header_test.cpp b/sources/android/stlport/test/unit/ctime_header_test.cpp
new file mode 100644
index 0000000..4e71c18
--- /dev/null
+++ b/sources/android/stlport/test/unit/ctime_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <ctime>
diff --git a/sources/android/stlport/test/unit/ctype_facets_test.cpp b/sources/android/stlport/test/unit/ctype_facets_test.cpp
new file mode 100644
index 0000000..9609e21
--- /dev/null
+++ b/sources/android/stlport/test/unit/ctype_facets_test.cpp
@@ -0,0 +1,520 @@
+#include "locale_test.h"
+
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# include <locale>
+# include <stdexcept>
+
+# if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+# endif
+
+static const char* tested_locales[] = {
+//name,
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ // We need exception support to check support of the following localizations.
+ "fr_FR",
+ "ru_RU.koi8r",
+ "en_GB",
+ "en_US",
+# endif
+ "",
+ "C"
+};
+
+//
+// tests implementation
+//
+void LocaleTest::_ctype_facet( const locale& loc)
+{
+ CPPUNIT_ASSERT( has_facet<ctype<char> >(loc) );
+ ctype<char> const& ct = use_facet<ctype<char> >(loc);
+ //is
+ {
+ CPPUNIT_ASSERT( ct.is(ctype_base::digit, '0') );
+ CPPUNIT_ASSERT( ct.is(ctype_base::upper, 'A') );
+ CPPUNIT_ASSERT( ct.is(ctype_base::lower, 'a') );
+ CPPUNIT_ASSERT( ct.is(ctype_base::alpha, 'A') );
+ CPPUNIT_ASSERT( ct.is(ctype_base::space, ' ') );
+ CPPUNIT_ASSERT( !ct.is(ctype_base::space, '2') );
+ CPPUNIT_ASSERT( ct.is(ctype_base::punct, '.') );
+ CPPUNIT_ASSERT( ct.is(ctype_base::xdigit, 'a') );
+ }
+
+ //is range
+ {
+ char values[] = "0Aa .";
+ ctype_base::mask res[sizeof(values)];
+ ct.is(values, values + sizeof(values), res);
+ // '0'
+ CPPUNIT_ASSERT( (res[0] & ctype_base::print) != 0 );
+ CPPUNIT_ASSERT( (res[0] & ctype_base::digit) != 0 );
+ CPPUNIT_ASSERT( (res[0] & ctype_base::xdigit) != 0 );
+ // 'A'
+ CPPUNIT_ASSERT( (res[1] & ctype_base::print) != 0 );
+ CPPUNIT_ASSERT( (res[1] & ctype_base::alpha) != 0 );
+ CPPUNIT_ASSERT( (res[1] & ctype_base::xdigit) != 0 );
+ CPPUNIT_ASSERT( (res[1] & ctype_base::upper) != 0 );
+ // 'a'
+ CPPUNIT_ASSERT( (res[2] & ctype_base::print) != 0 );
+ CPPUNIT_ASSERT( (res[2] & ctype_base::alpha) != 0 );
+ CPPUNIT_ASSERT( (res[2] & ctype_base::xdigit) != 0 );
+ CPPUNIT_ASSERT( (res[2] & ctype_base::lower) != 0 );
+ CPPUNIT_ASSERT( (res[2] & ctype_base::space) == 0 );
+ // ' '
+ CPPUNIT_ASSERT( (res[3] & ctype_base::print) != 0 );
+ CPPUNIT_ASSERT( (res[3] & ctype_base::space) != 0 );
+ CPPUNIT_ASSERT( (res[3] & ctype_base::digit) == 0 );
+ // '.'
+ CPPUNIT_ASSERT( (res[4] & ctype_base::print) != 0 );
+ CPPUNIT_ASSERT( (res[4] & ctype_base::punct) != 0 );
+ CPPUNIT_ASSERT( (res[4] & ctype_base::digit) == 0 );
+ }
+
+ //scan_is
+ {
+ char range[] = "abAc123 .";
+ const char *rbeg = range;
+ const char *rend = range + sizeof(range);
+
+ const char *res;
+ res = ct.scan_is((ctype_base::mask)(ctype_base::alpha | ctype_base::lower), rbeg, rend);
+ CPPUNIT_ASSERT( res != rend );
+ CPPUNIT_ASSERT( *res == 'a' );
+
+ res = ct.scan_is(ctype_base::upper, rbeg, rend);
+ CPPUNIT_ASSERT( res != rend );
+ CPPUNIT_ASSERT( *res == 'A' );
+
+ res = ct.scan_is(ctype_base::punct, rbeg, rend);
+ CPPUNIT_ASSERT( res != rend );
+ CPPUNIT_ASSERT( *res == '.' );
+ }
+
+ //scan_not
+ {
+ char range[] = "abAc123 .";
+ const char *rbeg = range;
+ const char *rend = range + sizeof(range);
+
+ const char *res;
+ res = ct.scan_not((ctype_base::mask)(ctype_base::alpha | ctype_base::lower), rbeg, rend);
+ CPPUNIT_ASSERT( res != rend );
+ CPPUNIT_ASSERT( *res == '1' );
+
+ res = ct.scan_not(ctype_base::alpha, rbeg, rend);
+ CPPUNIT_ASSERT( res != rend );
+ CPPUNIT_ASSERT( *res == '1' );
+
+ res = ct.scan_not(ctype_base::punct, rbeg, rend);
+ CPPUNIT_ASSERT( res != rend );
+ CPPUNIT_ASSERT( *res == 'a' );
+ }
+
+ //toupper
+ {
+ CPPUNIT_ASSERT( ct.toupper('a') == 'A' );
+ CPPUNIT_ASSERT( ct.toupper('A') == 'A' );
+ CPPUNIT_ASSERT( ct.toupper('1') == '1' );
+ }
+
+ //toupper range
+ {
+ char range[] = "abAc1";
+ char expected_range[] = "ABAC1";
+ ct.toupper(range, range + sizeof(range));
+ CPPUNIT_ASSERT( equal(range, range + sizeof(range), expected_range) );
+ }
+
+ //tolower
+ {
+ CPPUNIT_ASSERT( ct.tolower('A') == 'a' );
+ CPPUNIT_ASSERT( ct.tolower('a') == 'a' );
+ CPPUNIT_ASSERT( ct.tolower('1') == '1' );
+ }
+
+ //tolower range
+ {
+ char range[] = "ABaC1";
+ char expected_range[] = "abac1";
+ ct.tolower(range, range + sizeof(range));
+ CPPUNIT_ASSERT( equal(range, range + sizeof(range), expected_range) );
+ }
+
+ //widen
+ {
+ CPPUNIT_ASSERT( ct.widen('a') == 'a' );
+ }
+
+ //widen range
+ {
+ char range[] = "ABaC1";
+ char res[sizeof(range)];
+ ct.widen(range, range + sizeof(range), res);
+ CPPUNIT_ASSERT( equal(range, range + sizeof(range), res) );
+ }
+
+ //narrow
+ {
+ CPPUNIT_ASSERT( ct.narrow('a', 'b') == 'a' );
+ }
+
+ //narrow range
+ {
+ char range[] = "ABaC1";
+ char res[sizeof(range)];
+ ct.narrow(range, range + sizeof(range), 'b', res);
+ CPPUNIT_ASSERT( equal(range, range + sizeof(range), res) );
+ }
+}
+
+void LocaleTest::_ctype_facet_w( const locale& loc )
+{
+# ifndef _STLP_NO_WCHAR_T
+ CPPUNIT_ASSERT( has_facet<ctype<wchar_t> >(loc) );
+ ctype<wchar_t> const& wct = use_facet<ctype<wchar_t> >(loc);
+ //is
+ {
+ CPPUNIT_CHECK( wct.is(ctype_base::digit, L'0') );
+ CPPUNIT_CHECK( wct.is(ctype_base::upper, L'A') );
+ CPPUNIT_CHECK( wct.is(ctype_base::lower, L'a') );
+ CPPUNIT_CHECK( wct.is(ctype_base::alpha, L'A') );
+ CPPUNIT_CHECK( wct.is(ctype_base::space, L' ') );
+ CPPUNIT_CHECK( !wct.is(ctype_base::space, L'2') );
+ CPPUNIT_CHECK( wct.is(ctype_base::punct, L'.') );
+ CPPUNIT_CHECK( wct.is(ctype_base::xdigit, L'a') );
+ }
+
+ //is range
+ {
+ wchar_t values[] = L"0Aa .";
+ ctype_base::mask res[sizeof(values) / sizeof(wchar_t)];
+ wct.is(values, values + (sizeof(values) / sizeof(wchar_t)), res);
+ // '0'
+ CPPUNIT_CHECK( (res[0] & ctype_base::print) != 0 );
+ CPPUNIT_CHECK( (res[0] & ctype_base::digit) != 0 );
+ CPPUNIT_CHECK( (res[0] & ctype_base::xdigit) != 0 );
+ // 'A'
+ CPPUNIT_CHECK( (res[1] & ctype_base::print) != 0 );
+ CPPUNIT_CHECK( (res[1] & ctype_base::alpha) != 0 );
+ CPPUNIT_CHECK( (res[1] & ctype_base::xdigit) != 0 );
+ CPPUNIT_CHECK( (res[1] & ctype_base::upper) != 0 );
+ // 'a'
+ CPPUNIT_CHECK( (res[2] & ctype_base::print) != 0 );
+ CPPUNIT_CHECK( (res[2] & ctype_base::alpha) != 0 );
+ CPPUNIT_CHECK( (res[2] & ctype_base::xdigit) != 0 );
+ CPPUNIT_CHECK( (res[2] & ctype_base::lower) != 0 );
+ CPPUNIT_CHECK( (res[2] & ctype_base::space) == 0 );
+ // ' '
+ CPPUNIT_CHECK( (res[3] & ctype_base::print) != 0 );
+ CPPUNIT_CHECK( (res[3] & ctype_base::space) != 0 );
+ CPPUNIT_CHECK( (res[3] & ctype_base::digit) == 0 );
+ // '.'
+ CPPUNIT_CHECK( (res[4] & ctype_base::print) != 0 );
+ CPPUNIT_CHECK( (res[4] & ctype_base::punct) != 0 );
+ CPPUNIT_CHECK( (res[4] & ctype_base::digit) == 0 );
+ }
+
+ //scan_is
+ {
+ wchar_t range[] = L"abAc123 .";
+ const wchar_t *rbeg = range;
+ const wchar_t *rend = range + (sizeof(range) / sizeof(wchar_t));
+
+ const wchar_t *res;
+ res = wct.scan_is((ctype_base::mask)(ctype_base::alpha | ctype_base::lower), rbeg, rend);
+ CPPUNIT_CHECK( res != rend );
+ CPPUNIT_CHECK( *res == L'a' );
+
+ res = wct.scan_is(ctype_base::upper, rbeg, rend);
+ CPPUNIT_CHECK( res != rend );
+ CPPUNIT_CHECK( *res == L'A' );
+
+ res = wct.scan_is(ctype_base::punct, rbeg, rend);
+ CPPUNIT_CHECK( res != rend );
+ CPPUNIT_CHECK( *res == L'.' );
+ }
+
+ //scan_not
+ {
+ wchar_t range[] = L"abAc123 .";
+ const wchar_t *rbeg = range;
+ const wchar_t *rend = range + (sizeof(range) / sizeof(wchar_t));
+
+ const wchar_t *res;
+ res = wct.scan_not((ctype_base::mask)(ctype_base::alpha | ctype_base::lower), rbeg, rend);
+ CPPUNIT_CHECK( res != rend );
+ CPPUNIT_CHECK( *res == L'1' );
+
+ res = wct.scan_not(ctype_base::alpha, rbeg, rend);
+ CPPUNIT_CHECK( res != rend );
+ CPPUNIT_CHECK( *res == L'1' );
+
+ res = wct.scan_not(ctype_base::punct, rbeg, rend);
+ CPPUNIT_CHECK( res != rend );
+ CPPUNIT_CHECK( *res == L'a' );
+ }
+
+ //toupper
+ {
+ CPPUNIT_CHECK( wct.toupper(L'a') == L'A' );
+ CPPUNIT_CHECK( wct.toupper(L'A') == L'A' );
+ CPPUNIT_CHECK( wct.toupper(L'1') == L'1' );
+ }
+
+ //toupper range
+ {
+ wchar_t range[] = L"abAc1";
+ wchar_t expected_range[] = L"ABAC1";
+ wct.toupper(range, range + sizeof(range) / sizeof(wchar_t));
+ CPPUNIT_CHECK( equal(range, range + sizeof(range) / sizeof(wchar_t), expected_range) );
+ }
+
+ //tolower
+ {
+ CPPUNIT_CHECK( wct.tolower(L'A') == L'a' );
+ CPPUNIT_CHECK( wct.tolower(L'a') == L'a' );
+ CPPUNIT_CHECK( wct.tolower(L'1') == L'1' );
+ }
+
+ //tolower range
+ {
+ wchar_t range[] = L"ABaC1";
+ wchar_t expected_range[] = L"abac1";
+ wct.tolower(range, range + sizeof(range) / sizeof(wchar_t));
+ CPPUNIT_CHECK( equal(range, range + sizeof(range) / sizeof(wchar_t), expected_range) );
+ }
+
+ //widen
+ {
+ CPPUNIT_CHECK( wct.widen('a') == L'a' );
+ }
+
+ //widen range
+ {
+ char range[] = "ABaC1";
+ wchar_t res[sizeof(range)];
+ wchar_t expected_res[] = L"ABaC1";
+ wct.widen(range, range + sizeof(range), res);
+ CPPUNIT_CHECK( equal(expected_res, expected_res + sizeof(range), res) );
+ }
+
+ //narrow
+ {
+ CPPUNIT_CHECK( wct.narrow(L'a', 'b') == L'a' );
+ }
+
+ //narrow range
+ {
+ wchar_t range[] = L"ABaC1";
+ char res[sizeof(range) / sizeof(wchar_t)];
+ char expected_res[] = "ABaC1";
+ wct.narrow(range, range + sizeof(range) / sizeof(wchar_t), 'b', res);
+ CPPUNIT_CHECK( equal(expected_res, expected_res + sizeof(range) / sizeof(wchar_t), res) );
+ }
+# endif
+}
+
+
+typedef void (LocaleTest::*_Test) (const locale&);
+static void test_supported_locale(LocaleTest& inst, _Test __test) {
+ size_t n = sizeof(tested_locales) / sizeof(tested_locales[0]);
+ for (size_t i = 0; i < n; ++i) {
+ locale loc;
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ try
+# endif
+ {
+ locale tmp(tested_locales[i]);
+ loc = tmp;
+ }
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ catch (runtime_error const&) {
+ //This locale is not supported.
+ continue;
+ }
+# endif
+
+ CPPUNIT_MESSAGE( loc.name().c_str() );
+ (inst.*__test)(loc);
+
+ {
+ locale tmp(locale::classic(), tested_locales[i], locale::ctype);
+ loc = tmp;
+ }
+ (inst.*__test)(loc);
+
+ {
+ locale tmp(locale::classic(), new ctype_byname<char>(tested_locales[i]));
+#ifndef _STLP_NO_WCHAR_T
+ locale tmp0(tmp, new ctype_byname<wchar_t>(tested_locales[i]));
+ tmp = tmp0;
+#endif
+ loc = tmp;
+ }
+ (inst.*__test)(loc);
+ }
+}
+
+void LocaleTest::ctype_facet()
+{
+ test_supported_locale(*this, &LocaleTest::_ctype_facet);
+#ifndef _STLP_NO_WCHAR_T
+ test_supported_locale(*this, &LocaleTest::_ctype_facet_w);
+#endif
+}
+
+void LocaleTest::ctype_by_name()
+{
+ /*
+ * Check of the 22.1.1.2.7 standard point. Construction of a locale
+ * instance from a null pointer or an unknown name should result in
+ * a runtime_error exception.
+ */
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+# if defined (STLPORT) || (!defined(__GNUC__) && (!defined (_MSC_VER) || (_MSC_VER > 1400)))
+ // libstdc++ call freelocate on bad locale
+ try {
+ locale loc(locale::classic(), new ctype_byname<char>(static_cast<char const*>(0)));
+ CPPUNIT_ASSERT( false );
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_ASSERT( false );
+ }
+# endif
+
+ try {
+ locale loc(locale::classic(), new ctype_byname<char>("yasli_language"));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+# if defined(STLPORT) || !defined(__GNUC__)
+ try {
+ locale loc(locale::classic(), new codecvt_byname<char, char, mbstate_t>(static_cast<char const*>(0)));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+
+ try {
+ locale loc(locale::classic(), new codecvt_byname<char, char, mbstate_t>("yasli_language"));
+ //STLport implementation do not care about name pass to this facet.
+# if !defined (STLPORT)
+ CPPUNIT_FAIL;
+# endif
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ locale loc(locale::classic(), new ctype_byname<char>("fr_FR"));
+ CPPUNIT_ASSERT( has_facet<ctype<char> >(loc) );
+ ctype<char> const& ct = use_facet<ctype<char> >(loc);
+ CPPUNIT_ASSERT( ct.is(ctype_base::mask(ctype_base::print | ctype_base::lower | ctype_base::alpha), 'ç') );
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ locale loc(locale::classic(), new ctype_byname<char>("C"));
+ ctype<char> const& cfacet_byname = use_facet<ctype<char> >(loc);
+ ctype<char> const& cfacet = use_facet<ctype<char> >(locale::classic());
+
+ for (char c = 0;; ++c) {
+ CPPUNIT_CHECK(cfacet_byname.is(ctype_base::space, c) == cfacet.is(ctype_base::space, c));
+ if (cfacet_byname.is(ctype_base::print, c) != cfacet.is(ctype_base::print, c))
+ {
+ CPPUNIT_CHECK(cfacet_byname.is(ctype_base::print, c) == cfacet.is(ctype_base::print, c));
+ }
+ CPPUNIT_CHECK(cfacet_byname.is(ctype_base::cntrl, c) == cfacet.is(ctype_base::cntrl, c));
+ CPPUNIT_CHECK(cfacet_byname.is(ctype_base::upper, c) == cfacet.is(ctype_base::upper, c));
+ CPPUNIT_CHECK(cfacet_byname.is(ctype_base::lower, c) == cfacet.is(ctype_base::lower, c));
+ CPPUNIT_CHECK(cfacet_byname.is(ctype_base::alpha, c) == cfacet.is(ctype_base::alpha, c));
+ CPPUNIT_CHECK(cfacet_byname.is(ctype_base::digit, c) == cfacet.is(ctype_base::digit, c));
+ CPPUNIT_CHECK(cfacet_byname.is(ctype_base::punct, c) == cfacet.is(ctype_base::punct, c));
+ CPPUNIT_CHECK(cfacet_byname.is(ctype_base::xdigit, c) == cfacet.is(ctype_base::xdigit, c));
+ CPPUNIT_CHECK(cfacet_byname.is(ctype_base::alnum, c) == cfacet.is(ctype_base::alnum, c));
+ CPPUNIT_CHECK(cfacet_byname.is(ctype_base::graph, c) == cfacet.is(ctype_base::graph, c));
+ if (c == 127) break;
+ }
+ }
+ catch (runtime_error const& /* e */) {
+ /* CPPUNIT_MESSAGE( e.what() ); */
+ CPPUNIT_FAIL;
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+# if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
+# if defined(STLPORT) || !defined(__GNUC__)
+ try {
+ locale loc(locale::classic(), new ctype_byname<wchar_t>(static_cast<char const*>(0)));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+
+ try {
+ locale loc(locale::classic(), new ctype_byname<wchar_t>("yasli_language"));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+# if defined(STLPORT) || !defined(__GNUC__)
+ try {
+ locale loc(locale::classic(), new codecvt_byname<wchar_t, char, mbstate_t>(static_cast<char const*>(0)));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+
+ try {
+ locale loc(locale::classic(), new codecvt_byname<wchar_t, char, mbstate_t>("yasli_language"));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+# endif
+}
+
+#endif
diff --git a/sources/android/stlport/test/unit/ctype_header_test.c b/sources/android/stlport/test/unit/ctype_header_test.c
new file mode 100644
index 0000000..8bd9fa6
--- /dev/null
+++ b/sources/android/stlport/test/unit/ctype_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <ctype.h>
diff --git a/sources/android/stlport/test/unit/cwchar_header_test.cpp b/sources/android/stlport/test/unit/cwchar_header_test.cpp
new file mode 100644
index 0000000..7a63390
--- /dev/null
+++ b/sources/android/stlport/test/unit/cwchar_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <cwchar>
diff --git a/sources/android/stlport/test/unit/cwctype_header_test.cpp b/sources/android/stlport/test/unit/cwctype_header_test.cpp
new file mode 100644
index 0000000..0746b83
--- /dev/null
+++ b/sources/android/stlport/test/unit/cwctype_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <cwctype>
diff --git a/sources/android/stlport/test/unit/deque_header_test.cpp b/sources/android/stlport/test/unit/deque_header_test.cpp
new file mode 100644
index 0000000..c945948
--- /dev/null
+++ b/sources/android/stlport/test/unit/deque_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <deque>
diff --git a/sources/android/stlport/test/unit/deque_test.cpp b/sources/android/stlport/test/unit/deque_test.cpp
new file mode 100644
index 0000000..6be7e01
--- /dev/null
+++ b/sources/android/stlport/test/unit/deque_test.cpp
@@ -0,0 +1,330 @@
+//Has to be first for StackAllocator swap overload to be taken
+//into account (at least using GCC 4.0.1)
+#include "stack_allocator.h"
+
+#include <deque>
+#include <algorithm>
+#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+# include <stdexcept>
+#endif
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class DequeTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(DequeTest);
+ CPPUNIT_TEST(deque1);
+ CPPUNIT_TEST(at);
+ CPPUNIT_TEST(insert);
+ CPPUNIT_TEST(erase);
+ CPPUNIT_TEST(auto_ref);
+ CPPUNIT_TEST(allocator_with_state);
+#if defined (STLPORT) && defined (_STLP_NO_MEMBER_TEMPLATES)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(optimizations_check);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void deque1();
+ void insert();
+ void erase();
+ void at();
+ void auto_ref();
+ void allocator_with_state();
+ void optimizations_check();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(DequeTest);
+
+//
+// tests implementation
+//
+void DequeTest::deque1()
+{
+ deque<int> d;
+ d.push_back(4);
+ d.push_back(9);
+ d.push_back(16);
+ d.push_front(1);
+
+ CPPUNIT_ASSERT( d[0] == 1 );
+ CPPUNIT_ASSERT( d[1] == 4 );
+ CPPUNIT_ASSERT( d[2] == 9 );
+ CPPUNIT_ASSERT( d[3] == 16 );
+
+ d.pop_front();
+ d[2] = 25;
+
+ CPPUNIT_ASSERT( d[0] == 4 );
+ CPPUNIT_ASSERT( d[1] == 9 );
+ CPPUNIT_ASSERT( d[2] == 25 );
+
+ //Some compile time tests:
+ deque<int>::iterator dit = d.begin();
+ deque<int>::const_iterator cdit(d.begin());
+ CPPUNIT_ASSERT( (dit - cdit) == 0 );
+ CPPUNIT_ASSERT( (cdit - dit) == 0 );
+ CPPUNIT_ASSERT( (dit - dit) == 0 );
+ CPPUNIT_ASSERT( (cdit - cdit) == 0 );
+ CPPUNIT_ASSERT(!((dit < cdit) || (dit > cdit) || (dit != cdit) || !(dit <= cdit) || !(dit >= cdit)));
+}
+
+void DequeTest::insert()
+{
+ deque<int> d;
+ d.push_back(0);
+ d.push_back(1);
+ d.push_back(2);
+ CPPUNIT_ASSERT( d.size() == 3 );
+
+ deque<int>::iterator dit;
+
+ //Insertion before begin:
+ dit = d.insert(d.begin(), 3);
+ CPPUNIT_ASSERT( dit != d.end() );
+ CPPUNIT_CHECK( *dit == 3 );
+ CPPUNIT_ASSERT( d.size() == 4 );
+ CPPUNIT_ASSERT( d[0] == 3 );
+
+ //Insertion after begin:
+ dit = d.insert(d.begin() + 1, 4);
+ CPPUNIT_ASSERT( dit != d.end() );
+ CPPUNIT_CHECK( *dit == 4 );
+ CPPUNIT_ASSERT( d.size() == 5 );
+ CPPUNIT_ASSERT( d[1] == 4 );
+
+ //Insertion at end:
+ dit = d.insert(d.end(), 5);
+ CPPUNIT_ASSERT( dit != d.end() );
+ CPPUNIT_CHECK( *dit == 5 );
+ CPPUNIT_ASSERT( d.size() == 6 );
+ CPPUNIT_ASSERT( d[5] == 5 );
+
+ //Insertion before last element:
+ dit = d.insert(d.end() - 1, 6);
+ CPPUNIT_ASSERT( dit != d.end() );
+ CPPUNIT_CHECK( *dit == 6 );
+ CPPUNIT_ASSERT( d.size() == 7 );
+ CPPUNIT_ASSERT( d[5] == 6 );
+
+ //Insertion of several elements before begin
+ d.insert(d.begin(), 2, 7);
+ CPPUNIT_ASSERT( d.size() == 9 );
+ CPPUNIT_ASSERT( d[0] == 7 );
+ CPPUNIT_ASSERT( d[1] == 7 );
+
+ //Insertion of several elements after begin
+ //There is more elements to insert than elements before insertion position
+ d.insert(d.begin() + 1, 2, 8);
+ CPPUNIT_ASSERT( d.size() == 11 );
+ CPPUNIT_ASSERT( d[1] == 8 );
+ CPPUNIT_ASSERT( d[2] == 8 );
+
+ //There is less elements to insert than elements before insertion position
+ d.insert(d.begin() + 3, 2, 9);
+ CPPUNIT_ASSERT( d.size() == 13 );
+ CPPUNIT_ASSERT( d[3] == 9 );
+ CPPUNIT_ASSERT( d[4] == 9 );
+
+ //Insertion of several elements at end:
+ d.insert(d.end(), 2, 10);
+ CPPUNIT_ASSERT( d.size() == 15 );
+ CPPUNIT_ASSERT( d[14] == 10 );
+ CPPUNIT_ASSERT( d[13] == 10 );
+
+ //Insertion of several elements before last:
+ //There is more elements to insert than elements after insertion position
+ d.insert(d.end() - 1, 2, 11);
+ CPPUNIT_ASSERT( d.size() == 17 );
+ CPPUNIT_ASSERT( d[15] == 11 );
+ CPPUNIT_ASSERT( d[14] == 11 );
+
+ //There is less elements to insert than elements after insertion position
+ d.insert(d.end() - 3, 2, 12);
+ CPPUNIT_ASSERT( d.size() == 19 );
+ CPPUNIT_ASSERT( d[15] == 12 );
+ CPPUNIT_ASSERT( d[14] == 12 );
+}
+
+void DequeTest::at() {
+ deque<int> d;
+ deque<int> const& cd = d;
+
+ d.push_back(10);
+ CPPUNIT_ASSERT( d.at(0) == 10 );
+ d.at(0) = 20;
+ CPPUNIT_ASSERT( cd.at(0) == 20 );
+
+#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ for (;;) {
+ try {
+ d.at(1) = 20;
+ CPPUNIT_ASSERT(false);
+ }
+ catch (out_of_range const&) {
+ return;
+ }
+ catch (...) {
+ CPPUNIT_ASSERT(false);
+ }
+ }
+#endif
+}
+
+void DequeTest::auto_ref()
+{
+ int i;
+ deque<int> ref;
+ for (i = 0; i < 5; ++i) {
+ ref.push_back(i);
+ }
+
+ deque<deque<int> > d_d_int(1, ref);
+ d_d_int.push_back(d_d_int[0]);
+ d_d_int.push_back(ref);
+ d_d_int.push_back(d_d_int[0]);
+ d_d_int.push_back(d_d_int[0]);
+ d_d_int.push_back(ref);
+
+ for (i = 0; i < 5; ++i) {
+ CPPUNIT_ASSERT( d_d_int[i] == ref );
+ }
+}
+
+void DequeTest::allocator_with_state()
+{
+ char buf1[1024];
+ StackAllocator<int> stack1(buf1, buf1 + sizeof(buf1));
+
+ char buf2[1024];
+ StackAllocator<int> stack2(buf2, buf2 + sizeof(buf2));
+
+ {
+ typedef deque<int, StackAllocator<int> > DequeInt;
+ DequeInt dint1(10, 0, stack1);
+ DequeInt dint1Cpy(dint1);
+
+ DequeInt dint2(10, 1, stack2);
+ DequeInt dint2Cpy(dint2);
+
+ dint1.swap(dint2);
+
+ CPPUNIT_ASSERT( dint1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( dint2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( dint1 == dint2Cpy );
+ CPPUNIT_ASSERT( dint2 == dint1Cpy );
+ CPPUNIT_ASSERT( dint1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( dint2.get_allocator() == stack1 );
+ }
+ CPPUNIT_ASSERT( stack1.ok() );
+ CPPUNIT_ASSERT( stack2.ok() );
+}
+
+struct Point {
+ int x, y;
+};
+
+struct PointEx : public Point {
+ PointEx() : builtFromBase(false) {}
+ PointEx(const Point&) : builtFromBase(true) {}
+
+ bool builtFromBase;
+};
+
+#if defined (STLPORT)
+# if defined (_STLP_USE_NAMESPACES)
+namespace std {
+# endif
+ _STLP_TEMPLATE_NULL
+ struct __type_traits<PointEx> {
+ typedef __false_type has_trivial_default_constructor;
+ typedef __true_type has_trivial_copy_constructor;
+ typedef __true_type has_trivial_assignment_operator;
+ typedef __true_type has_trivial_destructor;
+ typedef __true_type is_POD_type;
+ };
+# if defined (_STLP_USE_NAMESPACES)
+}
+# endif
+#endif
+
+//This test check that deque implementation do not over optimize
+//operation as PointEx copy constructor is trivial
+void DequeTest::optimizations_check()
+{
+#if !defined (STLPORT) || !defined (_STLP_NO_MEMBER_TEMPLATES)
+ deque<Point> d1(1);
+ CPPUNIT_ASSERT( d1.size() == 1 );
+
+ deque<PointEx> d2(d1.begin(), d1.end());
+ CPPUNIT_ASSERT( d2.size() == 1 );
+ CPPUNIT_ASSERT( d2[0].builtFromBase == true );
+
+ d2.insert(d2.end(), d1.begin(), d1.end());
+ CPPUNIT_ASSERT( d2.size() == 2 );
+ CPPUNIT_ASSERT( d2[1].builtFromBase == true );
+#endif
+}
+
+void DequeTest::erase()
+{
+ deque<int> dint;
+ dint.push_back(3);
+ dint.push_front(2);
+ dint.push_back(4);
+ dint.push_front(1);
+ dint.push_back(5);
+ dint.push_front(0);
+ dint.push_back(6);
+
+ deque<int>::iterator it(dint.begin() + 1);
+ CPPUNIT_ASSERT( *it == 1 );
+
+ dint.erase(dint.begin());
+ CPPUNIT_ASSERT( *it == 1 );
+
+ it = dint.end() - 2;
+ CPPUNIT_ASSERT( *it == 5 );
+
+ dint.erase(dint.end() - 1);
+ CPPUNIT_ASSERT( *it == 5 );
+
+ dint.push_back(6);
+ dint.push_front(0);
+
+ it = dint.begin() + 2;
+ CPPUNIT_ASSERT( *it == 2 );
+
+ dint.erase(dint.begin(), dint.begin() + 2);
+ CPPUNIT_ASSERT( *it == 2 );
+
+ it = dint.end() - 3;
+ CPPUNIT_ASSERT( *it == 4 );
+
+ dint.erase(dint.end() - 2, dint.end());
+ CPPUNIT_ASSERT( *it == 4 );
+}
+
+#if (!defined (STLPORT) || \
+ (!defined (_STLP_USE_PTR_SPECIALIZATIONS) || defined (_STLP_CLASS_PARTIAL_SPECIALIZATION))) && \
+ (!defined (_MSC_VER) || (_MSC_VER > 1400)) && \
+ (!defined(__GNUC__) || (__GNUC__ < 4) || (__GNUC_MINOR__ < 3))
+/* Simple compilation test: Check that nested types like iterator
+ * can be access even if type used to instanciate container is not
+ * yet completely defined.
+ */
+class IncompleteClass
+{
+ deque<IncompleteClass> instances;
+ typedef deque<IncompleteClass>::size_type size;
+};
+#endif
diff --git a/sources/android/stlport/test/unit/divides_test.cpp b/sources/android/stlport/test/unit/divides_test.cpp
new file mode 100644
index 0000000..73e35cd
--- /dev/null
+++ b/sources/android/stlport/test/unit/divides_test.cpp
@@ -0,0 +1,33 @@
+#include <numeric>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class DivideTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(DivideTest);
+ CPPUNIT_TEST(div);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void div();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(DivideTest);
+
+//
+// tests implementation
+//
+void DivideTest::div()
+{
+ int input [3] = { 2, 3, 4 };
+ int result = accumulate(input, input + 3, 48, divides<int>());
+ CPPUNIT_ASSERT(result==2);
+}
diff --git a/sources/android/stlport/test/unit/epilog_test.cpp b/sources/android/stlport/test/unit/epilog_test.cpp
new file mode 100644
index 0000000..07e28f3
--- /dev/null
+++ b/sources/android/stlport/test/unit/epilog_test.cpp
@@ -0,0 +1,10 @@
+#include <time.h>
+#include <string>
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+
+struct some_struct {
+ std::string s; // if std not properly redefined, error will be here
+};
+
+#endif
diff --git a/sources/android/stlport/test/unit/equal_test.cpp b/sources/android/stlport/test/unit/equal_test.cpp
new file mode 100644
index 0000000..91c0ae2
--- /dev/null
+++ b/sources/android/stlport/test/unit/equal_test.cpp
@@ -0,0 +1,178 @@
+#include <vector>
+#include <algorithm>
+#include <functional>
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class EqualTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(EqualTest);
+ CPPUNIT_TEST(equal_range0);
+ CPPUNIT_TEST(equal_range1);
+ CPPUNIT_TEST(equal_range2);
+ CPPUNIT_TEST(equal0);
+ CPPUNIT_TEST(equal1);
+ CPPUNIT_TEST(equal2);
+ CPPUNIT_TEST(equalto);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void equal_range0();
+ void equal_range1();
+ void equal_range2();
+ void equal0();
+ void equal1();
+ void equal2();
+ void equalto();
+ static bool values_squared(int a_, int b_);
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(EqualTest);
+
+//
+// tests implementation
+//
+void EqualTest::equal_range0()
+{
+ int numbers[10] = { 0, 0, 1, 1, 2, 2, 2, 2, 3, 3 };
+ pair<int*, int*> range = equal_range((int*)numbers, (int*)numbers + 10, 2);
+ CPPUNIT_ASSERT( (range.first - numbers) == 4 );
+ CPPUNIT_ASSERT( (range.second - numbers) == 8 );
+}
+
+void EqualTest::equal_range1()
+{
+ typedef vector <int> IntVec;
+ IntVec v(10);
+ for (int i = 0; (size_t)i < v.size(); ++i)
+ v[i] = i / 3;
+
+ pair<IntVec::iterator, IntVec::iterator> range = equal_range(v.begin(), v.end(), 2);
+ CPPUNIT_ASSERT( (range.first - v.begin()) == 6 );
+ CPPUNIT_ASSERT( (range.second - v.begin()) == 9 );
+ for (; range.first != range.second; ++range.first)
+ CPPUNIT_ASSERT( *range.first == 2 );
+
+ range = equal_range(v.begin(), v.end(), 4);
+ CPPUNIT_ASSERT( range.first == range.second );
+ CPPUNIT_ASSERT( range.first == v.end() );
+}
+
+struct Test {
+#if defined (__DMC__)
+ Test();
+#endif
+
+ Test(int val) : value(val) {}
+ int value;
+
+ bool operator == (int i) const
+ { return value == i; }
+};
+
+bool operator < (const Test& v1, int v2)
+{ return v1.value < v2; }
+
+bool operator < (int v1, const Test& v2)
+{ return v1 < v2.value; }
+
+#if defined (_MSC_VER) && !defined (STLPORT)
+bool operator < (const Test& v1, const Test& v2)
+{ return v1.value < v2.value; }
+#endif
+
+void EqualTest::equal_range2()
+{
+ char chars[] = "aabbccddggghhklllmqqqqssyyzz";
+
+ const unsigned count = sizeof(chars) - 1;
+ pair<char*, char*> range = equal_range((char*)chars, (char*)chars + count, 'q', less<char>());
+ CPPUNIT_ASSERT( (range.first - chars) == 18 );
+ CPPUNIT_ASSERT( (range.second - chars) == 22 );
+ for (; range.first != range.second; ++range.first)
+ CPPUNIT_ASSERT( *range.first == 'q' );
+
+ range = equal_range((char*)chars, (char*)chars + count, 'm', less<char>());
+ CPPUNIT_ASSERT( (range.second - range.first) == 1 );
+ CPPUNIT_ASSERT( *range.first == 'm' );
+
+ vector<Test> tv;
+ vector<Test>::iterator it;
+ pair<vector<Test>::iterator, vector<Test>::iterator> p;
+
+ for (int i = 0; i < 10; ++i) {
+ tv.push_back(i);
+ }
+
+ it = upper_bound(tv.begin(), tv.end(), 5);
+ CPPUNIT_ASSERT( it != tv.end() );
+ CPPUNIT_ASSERT( *it == 6 );
+
+ it = lower_bound(tv.begin(), tv.end(), 5);
+ CPPUNIT_ASSERT( it != tv.end() );
+ CPPUNIT_ASSERT( *it == 5 );
+
+ p = equal_range(tv.begin(), tv.end(), 5);
+ CPPUNIT_ASSERT( p.first != p.second );
+ CPPUNIT_ASSERT( p.first != tv.end() );
+ CPPUNIT_ASSERT( p.second != tv.end() );
+ CPPUNIT_ASSERT( *p.first == 5 );
+ CPPUNIT_ASSERT( *p.second == 6 );
+}
+
+void EqualTest::equal0()
+{
+ int numbers1[5] = { 1, 2, 3, 4, 5 };
+ int numbers2[5] = { 1, 2, 4, 8, 16 };
+ int numbers3[2] = { 1, 2 };
+
+ CPPUNIT_ASSERT( !equal(numbers1, numbers1 + 5, numbers2) );
+ CPPUNIT_ASSERT( equal(numbers3, numbers3 + 2, numbers1) );
+}
+
+void EqualTest::equal1()
+{
+ vector <int> v1(10);
+ for (int i = 0; (size_t)i < v1.size(); ++i)
+ v1[i] = i;
+ vector <int> v2(10);
+ CPPUNIT_ASSERT( !equal(v1.begin(), v1.end(), v2.begin()) );
+
+ copy(v1.begin(), v1.end(), v2.begin());
+ CPPUNIT_ASSERT( equal(v1.begin(), v1.end(), v2.begin()) )
+}
+
+void EqualTest::equal2()
+{
+ vector <int> v1(10);
+ vector <int> v2(10);
+ for (int i = 0; (size_t)i < v1.size(); ++i) {
+ v1[i] = i;
+ v2[i] = i * i;
+ }
+ CPPUNIT_ASSERT( equal(v1.begin(), v1.end(), v2.begin(), values_squared) );
+}
+
+void EqualTest::equalto()
+{
+ int input1 [4] = { 1, 7, 2, 2 };
+ int input2 [4] = { 1, 6, 2, 3 };
+
+ int output [4];
+ transform((int*)input1, (int*)input1 + 4, (int*)input2, (int*)output, equal_to<int>());
+ CPPUNIT_ASSERT( output[0] == 1 );
+ CPPUNIT_ASSERT( output[1] == 0 );
+ CPPUNIT_ASSERT( output[2] == 1 );
+ CPPUNIT_ASSERT( output[3] == 0 );
+}
+
+bool EqualTest::values_squared(int a_, int b_)
+{
+ return (a_ * a_ == b_);
+}
diff --git a/sources/android/stlport/test/unit/errno_header_test.c b/sources/android/stlport/test/unit/errno_header_test.c
new file mode 100644
index 0000000..0a0accb
--- /dev/null
+++ b/sources/android/stlport/test/unit/errno_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <errno.h>
diff --git a/sources/android/stlport/test/unit/exception_header_test.cpp b/sources/android/stlport/test/unit/exception_header_test.cpp
new file mode 100644
index 0000000..d784ab9
--- /dev/null
+++ b/sources/android/stlport/test/unit/exception_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <exception>
diff --git a/sources/android/stlport/test/unit/exception_test.cpp b/sources/android/stlport/test/unit/exception_test.cpp
new file mode 100644
index 0000000..1879945
--- /dev/null
+++ b/sources/android/stlport/test/unit/exception_test.cpp
@@ -0,0 +1,193 @@
+#include <exception>
+#include <stdexcept>
+#include <string>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if defined (STLPORT) && defined (_STLP_USE_NAMESPACES)
+/*
+ * This test case purpose is to check that the exception handling
+ * functions are correctly imported to the STLport namespace only
+ * if they have a right behavior.
+ * Otherwise they are not imported to report the problem as a compile
+ * time error.
+ */
+
+//
+// TestCase class
+//
+class ExceptionTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(ExceptionTest);
+#if defined (STLPORT) && !defined (_STLP_USE_EXCEPTIONS)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(what);
+#if defined (STLPORT) && defined (_STLP_NO_UNEXPECTED_EXCEPT_SUPPORT)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(unexpected_except);
+#if defined (STLPORT) && defined (_STLP_USE_EXCEPTIONS)
+ CPPUNIT_STOP_IGNORE;
+#endif
+#if defined (STLPORT) && defined (_STLP_NO_UNCAUGHT_EXCEPT_SUPPORT)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(uncaught_except);
+#if defined (STLPORT) && defined (_STLP_USE_EXCEPTIONS)
+ CPPUNIT_STOP_IGNORE;
+#endif
+ CPPUNIT_TEST(exception_emission);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void what();
+ void unexpected_except();
+ void uncaught_except();
+ void exception_emission();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(ExceptionTest);
+
+#if !defined (STLPORT) || !defined (_STLP_NO_UNEXPECTED_EXCEPT_SUPPORT)
+bool g_unexpected_called = false;
+void unexpected_hdl() {
+ g_unexpected_called = true;
+ throw std::bad_exception();
+}
+
+struct special_except {};
+void throw_func() {
+ throw special_except();
+}
+
+void throw_except_func() throw(std::exception) {
+ throw_func();
+}
+#endif
+
+void ExceptionTest::what()
+{
+ try {
+ throw std::runtime_error( std::string( "message" ) );
+ }
+ catch ( std::runtime_error& err ) {
+ CPPUNIT_CHECK( strcmp( err.what(), "message" ) == 0 );
+ }
+}
+
+void ExceptionTest::unexpected_except()
+{
+#if !defined (STLPORT) || !defined (_STLP_NO_UNEXPECTED_EXCEPT_SUPPORT)
+ std::unexpected_handler hdl = &unexpected_hdl;
+ std::set_unexpected(hdl);
+
+ try {
+ throw_except_func();
+ }
+ catch (std::bad_exception const&) {
+ CPPUNIT_ASSERT( true );
+ }
+ catch (special_except) {
+ CPPUNIT_ASSERT( false );
+ }
+ CPPUNIT_ASSERT( g_unexpected_called );
+#endif
+}
+
+#if !defined (STLPORT) || !defined (_STLP_NO_UNCAUGHT_EXCEPT_SUPPORT)
+struct UncaughtClassTest
+{
+ UncaughtClassTest(int &res) : _res(res)
+ {}
+
+ ~UncaughtClassTest() {
+ _res = std::uncaught_exception()?1:0;
+ }
+
+ int &_res;
+};
+#endif
+
+void ExceptionTest::uncaught_except()
+{
+#if !defined (STLPORT) || !defined (_STLP_NO_UNCAUGHT_EXCEPT_SUPPORT)
+ int uncaught_result = -1;
+ {
+ UncaughtClassTest test_inst(uncaught_result);
+ CPPUNIT_ASSERT( uncaught_result == -1 );
+ }
+ CPPUNIT_ASSERT( uncaught_result == 0 );
+
+ {
+ try {
+ uncaught_result = -1;
+ UncaughtClassTest test_inst(uncaught_result);
+ throw "exception";
+ }
+ catch (...) {
+ }
+ }
+ CPPUNIT_ASSERT( uncaught_result == 1 );
+#endif
+}
+
+void ExceptionTest::exception_emission()
+{
+#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ std::string foo = "foo";
+ try {
+ throw std::runtime_error(foo);
+ }
+ catch (std::runtime_error const& e) {
+ CPPUNIT_ASSERT( foo == e.what() );
+ std::runtime_error clone("");
+ clone = e;
+ CPPUNIT_ASSERT(foo == clone.what() );
+ }
+ catch (...) {
+ CPPUNIT_ASSERT( false );
+ }
+
+ try {
+ throw std::runtime_error(foo);
+ }
+ catch (std::runtime_error e) {
+ CPPUNIT_ASSERT( foo == e.what() );
+ std::runtime_error clone("");
+ clone = e;
+ CPPUNIT_ASSERT(foo == clone.what() );
+ }
+ catch (...) {
+ CPPUNIT_ASSERT( false );
+ }
+
+ std::string msg(512, 'a');
+ try {
+ throw std::runtime_error(msg);
+ }
+ catch (std::runtime_error const& e) {
+ CPPUNIT_ASSERT(msg == e.what() );
+ std::runtime_error clone("");
+ clone = e;
+ CPPUNIT_ASSERT(msg == clone.what() );
+ }
+ catch (...) {
+ CPPUNIT_ASSERT( false );
+ }
+
+ try {
+ throw std::runtime_error(msg);
+ }
+ catch (std::runtime_error e) {
+ CPPUNIT_ASSERT(msg == e.what() );
+ std::runtime_error clone("");
+ clone = e;
+ CPPUNIT_ASSERT(msg == clone.what() );
+ }
+ catch (...) {
+ CPPUNIT_ASSERT( false );
+ }
+#endif
+}
+#endif
diff --git a/sources/android/stlport/test/unit/fadapter.h b/sources/android/stlport/test/unit/fadapter.h
new file mode 100644
index 0000000..b1cceaf
--- /dev/null
+++ b/sources/android/stlport/test/unit/fadapter.h
@@ -0,0 +1,80 @@
+#ifndef _fadapter_h_
+#define _fadapter_h_
+
+#include <functional>
+
+// used as adaptor's return/argument type,
+// to allow binders/composers usage
+struct __void_tag {};
+
+#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+using std::unary_function;
+#endif
+
+template <class Result>
+class pointer_to_void_function {
+protected:
+ Result (*ptr)();
+public:
+ explicit pointer_to_void_function(Result (*x)()) : ptr(x) {}
+ Result operator()() const { return ptr(); }
+ Result operator()(__void_tag) const { return ptr(); }
+};
+
+// to feed composers
+template <class Arg1>
+struct projectvoid : public unary_function<Arg1,__void_tag> {
+ __void_tag operator()(const Arg1& x) const { return __void_tag(); }
+};
+
+#if !defined (_STLP_MEMBER_POINTER_PARAM_BUG)
+
+template <class Result>
+pointer_to_void_function<Result> ptr_fun(Result (*x)()) {
+ return pointer_to_void_function<Result>(x);
+}
+
+// alternate name
+template <class Result>
+pointer_to_void_function<Result> ptr_gen(Result (*x)()) {
+ return pointer_to_void_function<Result>(x);
+}
+
+#endif /* !defined (_STLP_MEMBER_POINTER_PARAM_BUG) */
+
+template <class Arg>
+class pointer_to_unary_procedure /* :public unary_function<Arg, __void_tag> */ {
+protected:
+ typedef void (*fun_type)(Arg);
+ fun_type ptr;
+public:
+ typedef Arg argument_type;
+ pointer_to_unary_procedure() {}
+ pointer_to_unary_procedure(fun_type x) : ptr(x) {}
+ void operator() (Arg x) const { ptr(x); }
+};
+
+template <class Arg>
+inline pointer_to_unary_procedure<Arg> ptr_proc(void (*x)(Arg)) {
+ return pointer_to_unary_procedure<Arg>(x);
+}
+
+template <class Arg1, class Arg2>
+class pointer_to_binary_procedure /* : public unary_function<Arg1, Arg2, __void_tag> */ {
+protected:
+ typedef void (*fun_type)(Arg1, Arg2);
+ fun_type ptr;
+public:
+ typedef Arg1 first_argument_type;
+ typedef Arg2 second_argument_type;
+ pointer_to_binary_procedure() {}
+ pointer_to_binary_procedure(fun_type x) : ptr(x) {}
+ void operator() (Arg1 x, Arg2 y) const { ptr(x, y); }
+};
+
+template <class Arg1, class Arg2>
+inline pointer_to_binary_procedure<Arg1, Arg2> ptr_proc(void (*x)(Arg1, Arg2)) {
+ return pointer_to_binary_procedure<Arg1, Arg2>(x);
+}
+
+#endif
diff --git a/sources/android/stlport/test/unit/fib.h b/sources/android/stlport/test/unit/fib.h
new file mode 100644
index 0000000..9c74038
--- /dev/null
+++ b/sources/android/stlport/test/unit/fib.h
@@ -0,0 +1,21 @@
+#ifndef _fib_h
+#define _fib_h
+class Fibonacci
+{
+ public:
+ Fibonacci() : v1(0), v2(1) {}
+ inline int operator()();
+ private:
+ int v1;
+ int v2;
+};
+
+inline int
+Fibonacci::operator()()
+{
+ int r = v1 + v2;
+ v1 = v2;
+ v2 = r;
+ return v1;
+}
+#endif // _fib_h
diff --git a/sources/android/stlport/test/unit/fill_test.cpp b/sources/android/stlport/test/unit/fill_test.cpp
new file mode 100644
index 0000000..22d3fe9
--- /dev/null
+++ b/sources/android/stlport/test/unit/fill_test.cpp
@@ -0,0 +1,61 @@
+#include <vector>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class FillTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(FillTest);
+ CPPUNIT_TEST(fill1);
+ CPPUNIT_TEST(filln1);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void fill1();
+ void filln1();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(FillTest);
+
+//
+// tests implementation
+//
+void FillTest::fill1()
+{
+ vector <int> v(10);
+ fill(v.begin(), v.end(), 42);
+
+ CPPUNIT_ASSERT(v[0]==42);
+ CPPUNIT_ASSERT(v[1]==42);
+ CPPUNIT_ASSERT(v[2]==42);
+ CPPUNIT_ASSERT(v[3]==42);
+ CPPUNIT_ASSERT(v[4]==42);
+ CPPUNIT_ASSERT(v[5]==42);
+ CPPUNIT_ASSERT(v[6]==42);
+ CPPUNIT_ASSERT(v[7]==42);
+ CPPUNIT_ASSERT(v[8]==42);
+ CPPUNIT_ASSERT(v[9]==42);
+}
+void FillTest::filln1()
+{
+ vector <int> v(10);
+ fill_n(v.begin(), v.size(), 42);
+
+ CPPUNIT_ASSERT(v[0]==42);
+ CPPUNIT_ASSERT(v[1]==42);
+ CPPUNIT_ASSERT(v[2]==42);
+ CPPUNIT_ASSERT(v[3]==42);
+ CPPUNIT_ASSERT(v[4]==42);
+ CPPUNIT_ASSERT(v[5]==42);
+ CPPUNIT_ASSERT(v[6]==42);
+ CPPUNIT_ASSERT(v[7]==42);
+ CPPUNIT_ASSERT(v[8]==42);
+ CPPUNIT_ASSERT(v[9]==42);
+}
diff --git a/sources/android/stlport/test/unit/find_test.cpp b/sources/android/stlport/test/unit/find_test.cpp
new file mode 100644
index 0000000..d910f33
--- /dev/null
+++ b/sources/android/stlport/test/unit/find_test.cpp
@@ -0,0 +1,135 @@
+#include <vector>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class FindTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(FindTest);
+ CPPUNIT_TEST(find0);
+ CPPUNIT_TEST(find1);
+ CPPUNIT_TEST(findif0);
+ CPPUNIT_TEST(findif1);
+ CPPUNIT_TEST(find_char);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void find0();
+ void find1();
+ void findif0();
+ void findif1();
+ void find_char();
+ static bool odd(int a_);
+ static bool div_3(int a_);
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(FindTest);
+
+//
+// tests implementation
+//
+void FindTest::find0()
+{
+ int numbers[10] = { 0, 1, 4, 9, 16, 25, 36, 49, 64 };
+
+ int *location = find((int*)numbers, (int*)numbers + 10, 25);
+
+ CPPUNIT_ASSERT((location - numbers)==5);
+
+ int *out_range = find((int*)numbers, (int*)numbers + 10, 128);
+
+ CPPUNIT_ASSERT( out_range == (int *)(numbers + 10) );
+}
+
+struct Key
+{
+ int data;
+
+ /* This operator should rather be global and commutative
+ but implementing it this way show that STLport used to
+ ask too much from the user code. */
+ bool operator == (int d) const
+ {
+ return data == d;
+ }
+};
+
+void FindTest::find1()
+{
+ int years[] = { 1942, 1952, 1962, 1972, 1982, 1992 };
+
+ const unsigned yearCount = sizeof(years) / sizeof(years[0]);
+ int* location = find((int*)years, (int*)years + yearCount, 1972);
+
+ CPPUNIT_ASSERT((location - years)==3);
+}
+
+void FindTest::findif0()
+{
+ {
+ int numbers[6] = { 2, 4, 8, 15, 32, 64 };
+ int *location = find_if((int*)numbers, (int*)numbers + 6, odd);
+
+ CPPUNIT_ASSERT((location - numbers)==3);
+
+ int numbers_even[6] = { 2, 4, 8, 16, 32, 64 };
+
+ int *out_range = find_if((int*)numbers_even, (int*)numbers_even + 6, odd);
+
+ CPPUNIT_ASSERT( out_range == (int *)(numbers_even + 6) );
+ }
+
+ {
+ Key keys[10] = { {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0} };
+ Key const* k = find(keys + 0, keys + 10, 5);
+ CPPUNIT_ASSERT( k == keys + 10 );
+ }
+}
+
+void FindTest::findif1()
+{
+ typedef vector <int> IntVec;
+ IntVec v(10);
+ for(int i = 0; (size_t)i < v.size(); ++i)
+ v[i] =(i + 1) *(i + 1);
+ IntVec::iterator iter;
+ iter = find_if(v.begin(), v.end(), div_3);
+ CPPUNIT_ASSERT((iter - v.begin())==2);
+}
+
+bool FindTest::odd(int a_)
+{
+ return (a_ % 2) != 0;
+}
+
+bool FindTest::div_3(int a_)
+{
+ return a_ % 3 ? 0 : 1;
+}
+
+void FindTest::find_char()
+{
+ char str[] = "abcdefghij";
+ char *pstr = (char*)str;
+ const char* cpstr = (const char*)str;
+ size_t str_size = sizeof(str) / sizeof(char);
+
+ char *d = find(pstr, pstr + str_size, 'd');
+ CPPUNIT_ASSERT( *d == 'd' );
+
+ const char *e = find(cpstr, cpstr + str_size, 'e');
+ CPPUNIT_ASSERT( *e == 'e' );
+
+ char *last = find(pstr, pstr + str_size, 'x');
+ CPPUNIT_ASSERT( last == pstr + str_size );
+
+ const char *clast = find(cpstr, cpstr + str_size, 'x');
+ CPPUNIT_ASSERT( clast == cpstr + str_size );
+}
diff --git a/sources/android/stlport/test/unit/finsert_test.cpp b/sources/android/stlport/test/unit/finsert_test.cpp
new file mode 100644
index 0000000..e45289e
--- /dev/null
+++ b/sources/android/stlport/test/unit/finsert_test.cpp
@@ -0,0 +1,58 @@
+#include <vector>
+#include <algorithm>
+#include <deque>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class FinsertTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(FinsertTest);
+ CPPUNIT_TEST(finsert1);
+ CPPUNIT_TEST(finsert2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void finsert1();
+ void finsert2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(FinsertTest);
+
+//
+// tests implementation
+//
+void FinsertTest::finsert1()
+{
+ char const* array [] = { "laurie", "jennifer", "leisa" };
+ deque<char const*> names;
+ front_insert_iterator<deque<char const*> > fit(names);
+ fit = copy(array, array + 3, front_insert_iterator<deque <char const*> >(names));
+
+ CPPUNIT_ASSERT(names[0]==array[2]);
+ CPPUNIT_ASSERT(names[1]==array[1]);
+ CPPUNIT_ASSERT(names[2]==array[0]);
+
+ copy(array, array + 3, fit);
+ CPPUNIT_ASSERT(names[3]==array[2]);
+ CPPUNIT_ASSERT(names[4]==array[1]);
+ CPPUNIT_ASSERT(names[5]==array[0]);
+}
+
+void FinsertTest::finsert2()
+{
+ char const* array [] = { "laurie", "jennifer", "leisa" };
+
+ deque<char const*> names;
+ copy(array, array + 3, front_inserter(names));
+
+ CPPUNIT_ASSERT(names[0]==array[2]);
+ CPPUNIT_ASSERT(names[1]==array[1]);
+ CPPUNIT_ASSERT(names[2]==array[0]);
+}
diff --git a/sources/android/stlport/test/unit/float_header_test.c b/sources/android/stlport/test/unit/float_header_test.c
new file mode 100644
index 0000000..bb3f28d
--- /dev/null
+++ b/sources/android/stlport/test/unit/float_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <float.h>
diff --git a/sources/android/stlport/test/unit/foreach_test.cpp b/sources/android/stlport/test/unit/foreach_test.cpp
new file mode 100644
index 0000000..76fd514
--- /dev/null
+++ b/sources/android/stlport/test/unit/foreach_test.cpp
@@ -0,0 +1,73 @@
+#include <vector>
+#include <algorithm>
+#include "fadapter.h"
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class ForeachTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(ForeachTest);
+ CPPUNIT_TEST(foreach0);
+ CPPUNIT_TEST(foreach1);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void foreach0();
+ void foreach1();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(ForeachTest);
+
+//
+// tests implementation
+//
+static void increase(int& a_)
+{
+ a_ += 1;
+}
+void ForeachTest::foreach0()
+{
+ int numbers[10] = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 };
+
+ for_each(numbers, numbers + 10, ptr_fun(increase));
+
+ CPPUNIT_ASSERT(numbers[0]==2);
+ CPPUNIT_ASSERT(numbers[1]==2);
+ CPPUNIT_ASSERT(numbers[2]==3);
+ CPPUNIT_ASSERT(numbers[3]==4);
+ CPPUNIT_ASSERT(numbers[4]==6);
+ CPPUNIT_ASSERT(numbers[5]==9);
+ CPPUNIT_ASSERT(numbers[6]==14);
+ CPPUNIT_ASSERT(numbers[7]==22);
+ CPPUNIT_ASSERT(numbers[8]==35);
+ CPPUNIT_ASSERT(numbers[9]==56);
+}
+static void sqr(int& a_)
+{
+ a_ = a_ * a_;
+}
+void ForeachTest::foreach1()
+{
+ vector<int> v1(10);
+ for (int i = 0; (size_t)i < v1.size(); ++i)
+ v1[i] = i;
+ for_each(v1.begin(), v1.end(), ptr_fun(sqr) );
+
+ CPPUNIT_ASSERT(v1[0]==0);
+ CPPUNIT_ASSERT(v1[1]==1);
+ CPPUNIT_ASSERT(v1[2]==4);
+ CPPUNIT_ASSERT(v1[3]==9);
+ CPPUNIT_ASSERT(v1[4]==16);
+ CPPUNIT_ASSERT(v1[5]==25);
+ CPPUNIT_ASSERT(v1[6]==36);
+ CPPUNIT_ASSERT(v1[7]==49);
+ CPPUNIT_ASSERT(v1[8]==64);
+ CPPUNIT_ASSERT(v1[9]==81);
+}
diff --git a/sources/android/stlport/test/unit/fstream_header_test.cpp b/sources/android/stlport/test/unit/fstream_header_test.cpp
new file mode 100644
index 0000000..7fbe268
--- /dev/null
+++ b/sources/android/stlport/test/unit/fstream_header_test.cpp
@@ -0,0 +1,10 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#if !defined (_STLP_NO_IOSTREAMS)
+# include <fstream>
+#endif
diff --git a/sources/android/stlport/test/unit/fstream_test.cpp b/sources/android/stlport/test/unit/fstream_test.cpp
new file mode 100644
index 0000000..ab38aaf
--- /dev/null
+++ b/sources/android/stlport/test/unit/fstream_test.cpp
@@ -0,0 +1,933 @@
+#include <string>
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# include <fstream>
+# include <iostream>
+# include <iomanip>
+# include <sstream>
+# include <vector>
+# include <stdexcept>
+
+#include <stdio.h>
+
+# include "full_streambuf.h"
+# include "cppunit/cppunit_proxy.h"
+
+# if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+# endif
+
+//The macro value gives approximately the generated file
+//size in Go
+//#define CHECK_BIG_FILE 4
+
+# if (!defined(STLPORT) && (defined (__GNUC__) && (__GNUC__ > 3))) || \
+ (defined (STLPORT) && !defined (_STLP_NO_CUSTOM_IO) && !defined (_STLP_NO_MEMBER_TEMPLATES) && \
+ !((defined (_STLP_MSVC) && (_STLP_MSVC < 1300)) || \
+ (defined (__GNUC__) && (__GNUC__ < 3)) || \
+ (defined (__SUNPRO_CC)) || \
+ (defined (__DMC__) && defined (_DLL))))
+# define DO_CUSTOM_FACET_TEST
+# endif
+
+//
+// TestCase class
+//
+class FstreamTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(FstreamTest);
+ CPPUNIT_TEST(output);
+ CPPUNIT_TEST(input);
+ CPPUNIT_TEST(input_char);
+ CPPUNIT_TEST(io);
+ CPPUNIT_TEST(err);
+ CPPUNIT_TEST(tellg);
+ CPPUNIT_TEST(tellp);
+ CPPUNIT_TEST(seek);
+ CPPUNIT_TEST(buf);
+ CPPUNIT_TEST(rdbuf);
+ CPPUNIT_TEST(streambuf_output);
+ CPPUNIT_TEST(win32_file_format);
+ CPPUNIT_TEST(null_stream);
+# if defined (STLPORT) && (defined (_STLP_NO_WCHAR_T) || !defined (_STLP_USE_EXCEPTIONS))
+ CPPUNIT_IGNORE;
+# endif
+ CPPUNIT_TEST(null_buf);
+# if !defined (STLPORT) || !defined (_STLP_WIN32)
+ CPPUNIT_TEST(offset);
+# endif
+# if defined (CHECK_BIG_FILE)
+ CPPUNIT_TEST(big_file);
+# endif
+# if !defined (DO_CUSTOM_FACET_TEST)
+ CPPUNIT_IGNORE;
+# endif
+ CPPUNIT_TEST(custom_facet);
+ CPPUNIT_TEST_SUITE_END();
+
+ protected:
+ void output();
+ void input();
+ void input_char();
+ void io();
+ void err();
+ void tellg();
+ void tellp();
+ void seek();
+ void buf();
+ void rdbuf();
+ void streambuf_output();
+ void win32_file_format();
+ void null_stream();
+ void null_buf();
+# if !defined (STLPORT) || !defined (_STLP_WIN32)
+ void offset();
+# endif
+ void custom_facet();
+# if defined (CHECK_BIG_FILE)
+ void big_file();
+# endif
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(FstreamTest);
+
+//
+// tests implementation
+//
+void FstreamTest::output()
+{
+ ofstream f( "test_file.txt" );
+
+#if 1
+ CPPUNIT_ASSERT (f.good());
+ f << 1;
+ CPPUNIT_ASSERT (f.good());
+ f << '\n';
+ CPPUNIT_ASSERT (f.good());
+ f << 2.0;
+ CPPUNIT_ASSERT (f.good());
+ f << '\n';
+ CPPUNIT_ASSERT (f.good());
+ f << "abcd\n";
+ CPPUNIT_ASSERT (f.good());
+ f << "ghk lm\n";
+ CPPUNIT_ASSERT (f.good());
+ f << "abcd ef";
+ CPPUNIT_ASSERT (f.good());
+#else
+ f << 1 << '\n' << 2.0 << '\n' << "abcd\n" << "ghk lm\n" << "abcd ef";
+ CPPUNIT_ASSERT (f.good());
+#endif
+ // CPPUNIT_ASSERT( s.str() == "1\n2\nabcd\nghk lm\nabcd ef" );
+}
+
+void FstreamTest::input()
+{
+ {
+ ifstream f( "test_file.txt" );
+ int i = 0;
+ f >> i;
+ CPPUNIT_ASSERT( f.good() );
+ CPPUNIT_ASSERT( i == 1 );
+ double d = 0.0;
+ f >> d;
+ CPPUNIT_ASSERT( f.good() );
+ CPPUNIT_ASSERT( d == 2.0 );
+ string str;
+ f >> str;
+ CPPUNIT_ASSERT( f.good() );
+ CPPUNIT_ASSERT( str == "abcd" );
+ char c;
+ f.get(c); // extract newline, that not extracted by operator >>
+ CPPUNIT_ASSERT( f.good() );
+ CPPUNIT_ASSERT( c == '\n' );
+ getline( f, str );
+ CPPUNIT_ASSERT( f.good() );
+ CPPUNIT_ASSERT( str == "ghk lm" );
+ getline( f, str );
+ CPPUNIT_ASSERT( f.eof() );
+ CPPUNIT_ASSERT( str == "abcd ef" );
+ }
+#if defined (STLPORT) && !defined (_STLP_USE_WIN32_IO)
+ {
+ ifstream in("/tmp");
+ if (in.good()) {
+ string s;
+ getline(in, s);
+ CPPUNIT_ASSERT( in.fail() );
+ }
+ }
+#endif
+}
+
+void FstreamTest::input_char()
+{
+ char buf[16] = { 0, '1', '2', '3' };
+ ifstream s( "test_file.txt" );
+ s >> buf;
+
+ CPPUNIT_ASSERT( buf[0] == '1' );
+ CPPUNIT_ASSERT( buf[1] == 0 );
+ CPPUNIT_ASSERT( buf[2] == '2' );
+}
+
+void FstreamTest::io()
+{
+ basic_fstream<char,char_traits<char> > f( "test_file.txt", ios_base::in | ios_base::out | ios_base::trunc );
+
+ CPPUNIT_ASSERT( f.is_open() );
+
+ f << 1 << '\n' << 2.0 << '\n' << "abcd\n" << "ghk lm\n" << "abcd ef";
+
+ // f.flush();
+ f.seekg( 0, ios_base::beg );
+
+ int i = 0;
+ f >> i;
+ CPPUNIT_ASSERT( f.good() );
+ CPPUNIT_ASSERT( i == 1 );
+ double d = 0.0;
+ f >> d;
+ CPPUNIT_ASSERT( d == 2.0 );
+ string s;
+ f >> s;
+ CPPUNIT_ASSERT( f.good() );
+ CPPUNIT_ASSERT( s == "abcd" );
+ char c;
+ f.get(c); // extract newline, that not extracted by operator >>
+ CPPUNIT_ASSERT( f.good() );
+ CPPUNIT_ASSERT( c == '\n' );
+ getline( f, s );
+ CPPUNIT_ASSERT( f.good() );
+ CPPUNIT_ASSERT( s == "ghk lm" );
+ getline( f, s );
+ CPPUNIT_ASSERT( !f.fail() );
+ CPPUNIT_ASSERT( s == "abcd ef" );
+ CPPUNIT_ASSERT( f.eof() );
+}
+
+void FstreamTest::err()
+{
+ basic_fstream<char,char_traits<char> > f( "test_file.txt", ios_base::in | ios_base::out | ios_base::trunc );
+
+ CPPUNIT_ASSERT( f.is_open() );
+
+ int i = 9;
+ f << i;
+ CPPUNIT_ASSERT( f.good() );
+ i = 0;
+ f.seekg( 0, ios_base::beg );
+ f >> i;
+ CPPUNIT_ASSERT( !f.fail() );
+ CPPUNIT_ASSERT( i == 9 );
+ f >> i;
+ CPPUNIT_ASSERT( f.fail() );
+ CPPUNIT_ASSERT( f.eof() );
+ CPPUNIT_ASSERT( i == 9 );
+}
+
+void FstreamTest::tellg()
+{
+ {
+ // bogus ios_base::binary is for Wins
+ ofstream of("test_file.txt", ios_base::out | ios_base::binary | ios_base::trunc);
+ CPPUNIT_ASSERT( of.is_open() );
+
+ for (int i = 0; i < 50; ++i) {
+ of << "line " << setiosflags(ios_base::right) << setfill('0') << setw(2) << i << "\n";
+ CPPUNIT_ASSERT( !of.fail() );
+ }
+ of.close();
+ }
+
+ {
+ // bogus ios_base::binary is for Wins
+ ifstream is("test_file.txt", ios_base::in | ios_base::binary);
+ CPPUNIT_ASSERT( is.is_open() );
+ char buf[64];
+
+ // CPPUNIT_ASSERT( is.tellg() == 0 );
+ streampos p = 0;
+ for (int i = 0; i < 50; ++i) {
+ is.read(buf, 0);
+ CPPUNIT_ASSERT( is.gcount() == 0 );
+ CPPUNIT_ASSERT( is.tellg() == p );
+ is.read( buf, 8 );
+ CPPUNIT_ASSERT( !is.fail() );
+ CPPUNIT_ASSERT( is.gcount() == 8 );
+ p += 8;
+ }
+ }
+
+ {
+ // bogus ios_base::binary is for Wins
+ ifstream is("test_file.txt", ios_base::in | ios_base::binary);
+ CPPUNIT_ASSERT( is.is_open() );
+
+ streampos p = 0;
+ for (int i = 0; i < 50; ++i) {
+ CPPUNIT_ASSERT( !is.fail() );
+ is.tellg();
+ CPPUNIT_ASSERT( is.tellg() == p );
+ p += 8;
+ is.seekg( p, ios_base::beg );
+ CPPUNIT_ASSERT( !is.fail() );
+ }
+ }
+
+ {
+ // bogus ios_base::binary is for Wins
+ ifstream is("test_file.txt", ios_base::in | ios_base::binary);
+ CPPUNIT_ASSERT( is.is_open() );
+
+ streampos p = 0;
+ for (int i = 0; i < 50; ++i) {
+ CPPUNIT_ASSERT( is.tellg() == p );
+ p += 8;
+ is.seekg( 8, ios_base::cur );
+ CPPUNIT_ASSERT( !is.fail() );
+ }
+ }
+}
+
+void FstreamTest::tellp()
+{
+ {
+ ofstream o( "test_file.txt" );
+
+ o << "123456";
+
+ CPPUNIT_CHECK( o.rdbuf()->pubseekoff( 0, ios_base::cur, ios_base::out ) == ofstream::pos_type(6) );
+ CPPUNIT_CHECK( o.tellp() == ofstream::pos_type(6) );
+ }
+ {
+ ofstream o( "test_file.txt" );
+
+ o << "123456789";
+
+ CPPUNIT_CHECK( o.rdbuf()->pubseekoff( 0, ios_base::cur, ios_base::out ) == ofstream::pos_type(9) );
+ CPPUNIT_CHECK( o.tellp() == ofstream::pos_type(9) );
+ }
+ /* According to the standard
+ ofstream o( "test_file.txt", ios_base::app | ios_base::out )
+ should give the same effect as fopen( "test_file.txt", "a" ).
+ Problem is fopen( "test_file.txt", "a" ) has a bit different behaviour
+ on different platforms, and this difference is not covered by specification.
+ After fopen( "test_file.txt", "a" ) in this context ftell( f ) == 9 for
+ Linux and Mac OS X (I expect the same for others POSIX-like platforms too);
+ on Windows (independently from version?) ftell( f ) == 0, i.e. write pointer not
+ shifted to EOF (but shifted to EOF just before write, as described in the specs).
+
+ It isn't specifications violation, neither for Linux and Mac OS X nor for Windows.
+
+ The code below is intended to demonstrate ambiguity (dependance from fopen implementation).
+ */
+ {
+ #ifdef WIN32
+ //In Windows, stlport and fopen use kernel32.CreateFile for open.
+ //File position is at BOF after open, unless we open with ios_base::ate
+ long expected_pos = 0;
+ #else
+ //On UNIX flavours, stlport and fopen use unix's open
+ //File position is at EOF after open
+ //
+ //3rd possible scenario, "other platforms" - _STLP_USE_STDIO_IO
+ //stlport uses fopen here. This case may fail this test, since the file position after
+ //fopen is implementation-dependent
+ long expected_pos = 9;
+ #endif
+ ofstream o( "test_file.txt", ios_base::app | ios_base::out );
+ CPPUNIT_CHECK( o.rdbuf()->pubseekoff( 0, ios_base::cur, ios_base::out ) == ofstream::pos_type(expected_pos) );
+ CPPUNIT_CHECK( o.tellp() == ofstream::pos_type(expected_pos) );
+ }
+ { // for reference, to test fopen/ftell behaviour in append mode:
+ #ifdef WIN32
+ long expected_pos = 0;
+ #else
+ long expected_pos = 9;
+ #endif
+ FILE* f = fopen( "test_file.txt", "a" );
+ CPPUNIT_CHECK( ftell( f ) == expected_pos );
+ fclose( f );
+ }
+ {
+ //In append mode, file is positioned at EOF just before a write.
+ // After a write, file is at EOF. This is implementation-independent.
+ ofstream o( "test_file.txt", ios_base::app | ios_base::out );
+ o << "X";
+ CPPUNIT_CHECK( o.rdbuf()->pubseekoff( 0, ios_base::cur, ios_base::out ) == ofstream::pos_type(10) );
+ CPPUNIT_CHECK( o.tellp() == ofstream::pos_type(10) );
+ }
+}
+
+void FstreamTest::buf()
+{
+ fstream ss( "test_file.txt", ios_base::in | ios_base::out | ios_base::binary | ios_base::trunc );
+
+ ss << "1234567\n89\n";
+ ss.seekg( 0, ios_base::beg );
+ char buf[10];
+ buf[7] = 'x';
+ ss.get( buf, 10 );
+ CPPUNIT_ASSERT( !ss.fail() );
+ CPPUNIT_ASSERT( buf[0] == '1' );
+ CPPUNIT_ASSERT( buf[1] == '2' );
+ CPPUNIT_ASSERT( buf[2] == '3' );
+ CPPUNIT_ASSERT( buf[3] == '4' );
+ CPPUNIT_ASSERT( buf[4] == '5' );
+ CPPUNIT_ASSERT( buf[5] == '6' );
+ CPPUNIT_ASSERT( buf[6] == '7' ); // 27.6.1.3 paragraph 10, paragraph 7
+ CPPUNIT_ASSERT( buf[7] == 0 ); // 27.6.1.3 paragraph 8
+ char c;
+ ss.get(c);
+ CPPUNIT_ASSERT( !ss.fail() );
+ CPPUNIT_ASSERT( c == '\n' ); // 27.6.1.3 paragraph 10, paragraph 7
+ ss.get(c);
+ CPPUNIT_ASSERT( !ss.fail() );
+ CPPUNIT_ASSERT( c == '8' );
+}
+
+void FstreamTest::seek()
+{
+ {
+ // Test in binary mode:
+ {
+ fstream s( "test_file.txt", ios_base::in | ios_base::out | ios_base::binary | ios_base::trunc );
+ CPPUNIT_ASSERT( s );
+
+ s << "1234567890\n";
+ CPPUNIT_ASSERT( s );
+ }
+
+ char b1[] = { 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x' };
+ fstream s( "test_file.txt", ios_base::in | ios_base::out | ios_base::binary );
+ CPPUNIT_ASSERT( s );
+
+ int chars_read = (int)s.rdbuf()->sgetn( b1, sizeof(b1) );
+ CPPUNIT_CHECK( chars_read == 11 );
+ CPPUNIT_CHECK( b1[9] == '0' );
+ CPPUNIT_ASSERT( s.rdbuf()->pubseekoff( 0, ios_base::cur ) == fstream::pos_type(chars_read) );
+ CPPUNIT_ASSERT( s.rdbuf()->pubseekoff( -chars_read, ios_base::cur ) == fstream::pos_type(0) );
+
+ char b2[10] = { 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y' };
+
+ CPPUNIT_ASSERT( s.rdbuf()->sgetn( b2, 10 ) == 10 );
+ CPPUNIT_CHECK( b2[9] == '0' );
+ }
+
+ {
+ // Test in text mode:
+ {
+ fstream s( "test_file.txt", ios_base::in | ios_base::out | ios_base::trunc );
+ CPPUNIT_ASSERT( s );
+
+ s << "1234567890\n";
+ CPPUNIT_ASSERT( s );
+ }
+
+ char b1[] = { 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x' };
+ fstream s( "test_file.txt", ios_base::in | ios_base::out );
+ CPPUNIT_ASSERT( s );
+
+ int chars_read = (int)s.rdbuf()->sgetn( b1, sizeof(b1) );
+ CPPUNIT_CHECK( chars_read == 11 );
+ CPPUNIT_CHECK( b1[9] == '0' );
+
+ fstream::pos_type pos = s.rdbuf()->pubseekoff(0, ios_base::cur);
+ // Depending on how '\n' is written in file, file position can be greater or equal to the number of chars_read read.
+ streamoff offset = pos;
+ CPPUNIT_ASSERT( offset >= chars_read );
+ offset = s.rdbuf()->pubseekoff( -offset, ios_base::cur );
+ CPPUNIT_ASSERT( offset == 0 );
+
+ char b2[10] = { 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y' };
+
+ CPPUNIT_ASSERT( s.rdbuf()->sgetn( b2, 5 ) == 5 );
+ CPPUNIT_CHECK( b2[4] == '5' );
+
+ pos = s.rdbuf()->pubseekoff(0, ios_base::cur);
+ CPPUNIT_ASSERT( pos == fstream::pos_type(5) );
+ CPPUNIT_ASSERT( s.rdbuf()->pubseekoff(-5, ios_base::cur) == fstream::pos_type(0) );
+ }
+
+#if !defined (STLPORT) || \
+ (!defined (_STLP_NO_WCHAR_T) && defined (_STLP_USE_EXCEPTIONS))
+ {
+ // Test with a wariable encoding:
+ locale loc;
+ try
+ {
+ locale tmp(locale::classic(), new codecvt_byname<wchar_t, char, mbstate_t>(".UTF8"));
+ loc = tmp;
+ }
+ catch (const runtime_error&)
+ {
+ // Localization no supported so no test:
+ return;
+ }
+
+ {
+ wfstream s( "test_file.txt", ios_base::in | ios_base::out | ios_base::trunc );
+ CPPUNIT_ASSERT( s );
+ s.imbue(loc);
+ CPPUNIT_ASSERT( s );
+
+ s << L"1234567890\n";
+ CPPUNIT_ASSERT( s );
+ }
+
+ wchar_t b1[] = { L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x', L'x' };
+ wfstream s( "test_file.txt", ios_base::in | ios_base::out );
+ CPPUNIT_ASSERT( s );
+ s.imbue(loc);
+ CPPUNIT_ASSERT( s );
+
+ int chars_read = (int)s.rdbuf()->sgetn( b1, sizeof(b1) / sizeof(wchar_t) );
+ CPPUNIT_CHECK( chars_read == 11 );
+ CPPUNIT_CHECK( b1[9] == L'0' );
+
+ fstream::pos_type pos = s.rdbuf()->pubseekoff(0, ios_base::cur);
+ // Depending on how '\n' is written in file, file position can be greater or equal to the number of chars_read read.
+ streamoff off = pos;
+ CPPUNIT_ASSERT( off >= chars_read );
+ off = s.rdbuf()->pubseekoff(-off, ios_base::cur);
+ CPPUNIT_ASSERT( off == -1 );
+ off = s.rdbuf()->pubseekoff(0, ios_base::beg);
+ CPPUNIT_ASSERT( off == 0 );
+
+ wchar_t b2[10] = { L'y', L'y', L'y', L'y', L'y', L'y', L'y', L'y', L'y', L'y' };
+
+ CPPUNIT_ASSERT( s.rdbuf()->sgetn( b2, 5 ) == 5 );
+ CPPUNIT_CHECK( b2[4] == L'5' );
+
+ pos = s.rdbuf()->pubseekoff(0, ios_base::cur);
+ CPPUNIT_ASSERT( pos == fstream::pos_type(5) );
+ //CPPUNIT_ASSERT( s.rdbuf()->pubseekoff(-5, ios_base::cur) == fstream::pos_type(0) );
+ }
+#endif
+}
+
+void FstreamTest::rdbuf()
+{
+ fstream ss( "test_file.txt", ios_base::in | ios_base::out | ios_base::binary | ios_base::trunc );
+
+ ss << "1234567\n89\n";
+ ss.seekg( 0, ios_base::beg );
+
+ ostringstream os;
+ ss.get( *os.rdbuf(), '\n' );
+ CPPUNIT_ASSERT( !ss.fail() );
+ char c;
+ ss.get(c);
+ CPPUNIT_ASSERT( !ss.fail() );
+ CPPUNIT_ASSERT( c == '\n' ); // 27.6.1.3 paragraph 12
+ CPPUNIT_ASSERT( os.str() == "1234567" );
+}
+
+void FstreamTest::streambuf_output()
+{
+ {
+ ofstream ofstr("test_file.txt", ios_base::binary);
+ if (!ofstr)
+ //No test if we cannot create the file
+ return;
+ ofstr << "01234567890123456789";
+ CPPUNIT_ASSERT( ofstr );
+ }
+
+ {
+ ifstream in("test_file.txt", ios_base::binary);
+ CPPUNIT_ASSERT( in );
+
+ full_streambuf full_buf(10);
+ ostream out(&full_buf);
+ CPPUNIT_ASSERT( out );
+
+ out << in.rdbuf();
+ CPPUNIT_ASSERT( out );
+ CPPUNIT_ASSERT( in );
+ CPPUNIT_ASSERT( full_buf.str() == "0123456789" );
+
+ out << in.rdbuf();
+ CPPUNIT_ASSERT( out.fail() );
+ CPPUNIT_ASSERT( in );
+
+ ostringstream ostr;
+ ostr << in.rdbuf();
+ CPPUNIT_ASSERT( ostr );
+ CPPUNIT_ASSERT( in );
+ CPPUNIT_ASSERT( ostr.str() == "0123456789" );
+ }
+
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ {
+ //If the output stream buffer throws:
+ ifstream in("test_file.txt", ios_base::binary);
+ CPPUNIT_ASSERT( in );
+
+ full_streambuf full_buf(10, true);
+ ostream out(&full_buf);
+ CPPUNIT_ASSERT( out );
+
+ out << in.rdbuf();
+ CPPUNIT_ASSERT( out.bad() );
+ CPPUNIT_ASSERT( in );
+ //out is bad we have no guaranty on what has been extracted:
+ //CPPUNIT_ASSERT( full_buf.str() == "0123456789" );
+
+ out.clear();
+ out << in.rdbuf();
+ CPPUNIT_ASSERT( out.fail() && out.bad() );
+ CPPUNIT_ASSERT( in );
+
+ ostringstream ostr;
+ ostr << in.rdbuf();
+ CPPUNIT_ASSERT( ostr );
+ CPPUNIT_ASSERT( in );
+ CPPUNIT_ASSERT( ostr.str() == "0123456789" );
+ }
+# endif
+}
+
+void FstreamTest::win32_file_format()
+{
+ const char* file_name = "win32_file_format.tmp";
+ const size_t nb_lines = 2049;
+ {
+ ofstream out(file_name);
+ CPPUNIT_ASSERT( out.good() );
+ out << 'a';
+ for (size_t i = 0; i < nb_lines - 1; ++i) {
+ out << '\n';
+ }
+ out << '\r';
+ CPPUNIT_ASSERT( out.good() );
+ }
+ {
+ ifstream in(file_name);
+ CPPUNIT_ASSERT( in.good() );
+ string line, last_line;
+ size_t nb_read_lines = 0;
+ while (getline(in, line)) {
+ ++nb_read_lines;
+ last_line = line;
+ }
+ CPPUNIT_ASSERT( in.eof() );
+ CPPUNIT_ASSERT( nb_read_lines == nb_lines );
+ CPPUNIT_ASSERT( !last_line.empty() && (last_line[0] == '\r') );
+ }
+}
+
+#if defined (DO_CUSTOM_FACET_TEST)
+struct my_state {
+ char dummy;
+};
+
+struct my_traits : public char_traits<char> {
+ typedef my_state state_type;
+ typedef fpos<state_type> pos_type;
+};
+
+#if !defined (STLPORT)
+//STLport grant a default implementation, other Standard libs implementation
+//do not necessarily do the same:
+namespace std {
+ template <>
+ class codecvt<char, char, my_state>
+ : public locale::facet, public codecvt_base {
+ public:
+ typedef char intern_type;
+ typedef char extern_type;
+ typedef my_state state_type;
+
+ explicit codecvt(size_t __refs = 0) : locale::facet(__refs) {}
+ result out(state_type&,
+ const intern_type* __from,
+ const intern_type*,
+ const intern_type*& __from_next,
+ extern_type* __to,
+ extern_type*,
+ extern_type*& __to_next) const
+ { __from_next = __from; __to_next = __to; return noconv; }
+
+ result in (state_type&,
+ const extern_type* __from,
+ const extern_type*,
+ const extern_type*& __from_next,
+ intern_type* __to,
+ intern_type*,
+ intern_type*& __to_next) const
+ { __from_next = __from; __to_next = __to; return noconv; }
+
+ result unshift(state_type&,
+ extern_type* __to,
+ extern_type*,
+ extern_type*& __to_next) const
+ { __to_next = __to; return noconv; }
+
+ int encoding() const throw()
+ { return 1; }
+
+ bool always_noconv() const throw()
+ { return true; }
+
+ int length(const state_type&,
+ const extern_type* __from,
+ const extern_type* __end,
+ size_t __max) const
+ { return (int)min(static_cast<size_t>(__end - __from), __max); }
+
+ int max_length() const throw()
+ { return 1; }
+
+ static locale::id id;
+ };
+
+ locale::id codecvt<char, char, my_state>::id;
+}
+# else
+# if defined (__BORLANDC__) && (__BORLANDC__ < 0x590)
+template <>
+locale::id codecvt<char, char, my_state>::id;
+# endif
+# endif
+#endif
+
+void FstreamTest::custom_facet()
+{
+#if defined (DO_CUSTOM_FACET_TEST)
+ const char* fileName = "test_file.txt";
+ //File preparation:
+ {
+ ofstream ofstr(fileName, ios_base::binary);
+ ofstr << "0123456789";
+ CPPUNIT_ASSERT( ofstr );
+ }
+
+ {
+ typedef basic_ifstream<char, my_traits> my_ifstream;
+ typedef basic_string<char, my_traits> my_string;
+
+ my_ifstream ifstr(fileName);
+ CPPUNIT_ASSERT( ifstr );
+
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ ifstr.imbue(locale::classic());
+ CPPUNIT_ASSERT( ifstr.fail() && !ifstr.bad() );
+ ifstr.clear();
+# endif
+ typedef codecvt<char, char, my_state> my_codecvt;
+ locale my_loc(locale::classic(), new my_codecvt());
+ // Check that my_codecvt has not replace default codecvt:
+ CPPUNIT_ASSERT( (has_facet<my_codecvt>(my_loc)) );
+ CPPUNIT_ASSERT( (has_facet<codecvt<char, char, mbstate_t> >(my_loc)) );
+# if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
+ CPPUNIT_ASSERT( (has_facet<codecvt<wchar_t, char, mbstate_t> >(my_loc)) );
+# endif
+ ifstr.imbue(my_loc);
+ CPPUNIT_ASSERT( ifstr.good() );
+ /*
+ my_string res;
+ ifstr >> res;
+ CPPUNIT_ASSERT( !ifstr.fail() );
+ CPPUNIT_ASSERT( !ifstr.bad() );
+ CPPUNIT_ASSERT( ifstr.eof() );
+ CPPUNIT_ASSERT( res == "0123456789" );
+ */
+ }
+#endif
+}
+
+# if defined (CHECK_BIG_FILE)
+void FstreamTest::big_file()
+{
+ vector<pair<streamsize, streamoff> > file_pos;
+
+ //Big file creation:
+ {
+ ofstream out("big_file.txt");
+ CPPUNIT_ASSERT( out );
+
+ //We are going to generate a file with the following schema for the content:
+ //0(1019 times)0000 //1023 characters + 1 charater for \n (for some platforms it will be a 1 ko line)
+ //0(1019 times)0001
+ //...
+ //0(1019 times)1234
+ //...
+
+ //Generation of the number of loop:
+ streamoff nb = 1;
+ for (int i = 0; i < 20; ++i) {
+ //This assertion check that the streamoff can at least represent the necessary integers values
+ //for this test:
+ CPPUNIT_ASSERT( (nb << 1) > nb );
+ nb <<= 1;
+ }
+ CPPUNIT_ASSERT( nb * CHECK_BIG_FILE >= nb );
+ nb *= CHECK_BIG_FILE;
+
+ //Preparation of the ouput stream state:
+ out << setiosflags(ios_base::right) << setfill('*');
+ for (streamoff index = 0; index < nb; ++index) {
+ if (index % 1024 == 0) {
+ file_pos.push_back(make_pair(out.tellp(), index));
+ CPPUNIT_ASSERT( file_pos.back().first != streamsize(-1) );
+ if (file_pos.size() > 1) {
+ CPPUNIT_ASSERT( file_pos[file_pos.size() - 1].first > file_pos[file_pos.size() - 2].first );
+ }
+ }
+ out << setw(1023) << index << '\n';
+ }
+ }
+
+ {
+ ifstream in("big_file.txt");
+ CPPUNIT_ASSERT( in );
+
+ string line;
+ vector<pair<streamsize, streamsize> >::const_iterator pit(file_pos.begin()),
+ pitEnd(file_pos.end());
+ for (; pit != pitEnd; ++pit) {
+ in.seekg((*pit).first);
+ CPPUNIT_ASSERT( in );
+ in >> line;
+ size_t lastStarPos = line.rfind('*');
+ CPPUNIT_ASSERT( atoi(line.substr(lastStarPos + 1).c_str()) == (*pit).second );
+ }
+ }
+
+ /*
+ The following test has been used to check that STLport do not generate
+ an infinite loop when the file size is larger than the streamsize and
+ streamoff representation (32 bits or 64 bits).
+ {
+ ifstream in("big_file.txt");
+ CPPUNIT_ASSERT( in );
+ char tmp[4096];
+ streamsize nb_reads = 0;
+ while ((!in.eof()) && in.good()){
+ in.read(tmp, 4096);
+ nb_reads += in.gcount();
+ }
+ }
+ */
+}
+# endif
+
+void FstreamTest::null_stream()
+{
+# if (defined (STLPORT) && defined (_STLP_USE_WIN32_IO)) || \
+ (!defined (STLPORT) && (defined (WIN32) || defined (_WIN32)))
+ const char* nullStreamName = "NUL";
+# else
+ const char* nullStreamName = "/dev/null";
+# endif
+ {
+ ofstream nullStream(nullStreamName);
+ CPPUNIT_CHECK( nullStream );
+ }
+
+ {
+ ofstream nullStream(nullStreamName, ios_base::ate);
+ CPPUNIT_CHECK( nullStream );
+ }
+
+ {
+ ofstream nullStream(nullStreamName, ios_base::trunc);
+ CPPUNIT_CHECK( nullStream );
+ }
+
+ {
+ ofstream nullStream(nullStreamName, ios_base::app);
+ CPPUNIT_CHECK( nullStream );
+ }
+
+ {
+ ifstream nullStream(nullStreamName);
+ CPPUNIT_CHECK( nullStream );
+ }
+
+ {
+ ifstream nullStream(nullStreamName, ios_base::ate);
+ CPPUNIT_CHECK( nullStream );
+ }
+
+ {
+ fstream nullStream(nullStreamName);
+ CPPUNIT_CHECK( nullStream );
+ }
+
+ {
+ fstream nullStream(nullStreamName, ios_base::in | ios_base::out | ios_base::ate);
+ CPPUNIT_CHECK( nullStream );
+ }
+
+ {
+ fstream nullStream(nullStreamName, ios_base::in | ios_base::out | ios_base::trunc);
+ CPPUNIT_CHECK( nullStream );
+ }
+}
+
+void FstreamTest::null_buf()
+{
+ /* **********************************************************************************
+
+ testcase for bug #1830513:
+ in _istream.c
+
+ template < class _CharT, class _Traits, class _Is_Delim>
+ streamsize _STLP_CALL __read_unbuffered(basic_istream<_CharT, _Traits>* __that,
+ basic_streambuf<_CharT, _Traits>* __buf,
+ streamsize _Num, _CharT* __s,
+ _Is_Delim __is_delim,
+ bool __extract_delim, bool __append_null,
+ bool __is_getline)
+
+ can't accept _Num == 0; this is legal case, and may happen from
+
+ template <class _CharT, class _Traits>
+ basic_istream<_CharT, _Traits>&
+ basic_istream<_CharT, _Traits>::getline(_CharT* __s, streamsize __n, _CharT __delim)
+
+ *********************************************************************************** */
+
+ fstream f( "test.txt", ios_base::in | ios_base::out | ios_base::trunc );
+ // string line;
+
+ for ( int i = 0; i < 0x200; ++i ) {
+ f.put( ' ' );
+ }
+
+ // const streambuf *b = f.rdbuf();
+
+ // string s;
+ char buf[1024];
+ buf[0] = 'a';
+ buf[1] = 'b';
+ buf[2] = 'c';
+
+ // getline( f, s );
+ // cerr << f.good() << endl;
+ f.seekg( 0, ios_base::beg );
+ // f.seekg( 0, ios_base::end );
+ // buf[0] = f.get();
+
+ // cerr << (void *)(b->_M_gptr()) << " " << (void *)(b->_M_egptr()) << endl;
+ // cerr << f.good() << endl;
+ // getline( f, s );
+ f.getline( buf, 1 ); // <-- key line
+ CPPUNIT_CHECK( buf[0] == 0 );
+ CPPUNIT_CHECK( f.fail() ); // due to delimiter not found while buffer was exhausted
+}
+
+# if !defined (STLPORT) || !defined (_STLP_WIN32)
+void FstreamTest::offset()
+{
+# if (defined(_LARGEFILE_SOURCE) || defined(_LARGEFILE64_SOURCE)) && !defined(_STLP_USE_DEFAULT_FILE_OFFSET)
+ CPPUNIT_CHECK( sizeof(streamoff) == 8 );
+# else
+ CPPUNIT_CHECK( sizeof(streamoff) == sizeof(off_t) );
+# endif
+}
+# endif
+
+#endif
diff --git a/sources/android/stlport/test/unit/full_streambuf.h b/sources/android/stlport/test/unit/full_streambuf.h
new file mode 100644
index 0000000..34766ac
--- /dev/null
+++ b/sources/android/stlport/test/unit/full_streambuf.h
@@ -0,0 +1,46 @@
+#ifndef _FULL_STREAM_H
+#define _FULL_STREAM_H
+
+#include <streambuf>
+
+/*
+ * This full_streambuf purpose is to act like a full disk to check the right behavior
+ * of the STLport code in such a case.
+ */
+
+class full_streambuf : public std::streambuf {
+public:
+ typedef std::streambuf _Base;
+
+ typedef _Base::int_type int_type;
+ typedef _Base::traits_type traits_type;
+
+ full_streambuf(size_t nb_output, bool do_throw = false)
+ : _nb_output(nb_output), _do_throw(do_throw)
+ {}
+
+ std::string const& str() const
+ { return _buf; }
+
+protected:
+ int_type overflow(int_type c) {
+ if (_nb_output == 0) {
+#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ if (_do_throw) {
+ throw "streambuf full";
+ }
+#endif
+ return traits_type::eof();
+ }
+ --_nb_output;
+ _buf += traits_type::to_char_type(c);
+ return c;
+ }
+
+private:
+ size_t _nb_output;
+ bool _do_throw;
+ std::string _buf;
+};
+
+#endif //_FULL_STREAM_H
diff --git a/sources/android/stlport/test/unit/func_test.cpp b/sources/android/stlport/test/unit/func_test.cpp
new file mode 100644
index 0000000..91ad1ef
--- /dev/null
+++ b/sources/android/stlport/test/unit/func_test.cpp
@@ -0,0 +1,76 @@
+#include <vector>
+#include <algorithm>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class FuncTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(FuncTest);
+ CPPUNIT_TEST(func1);
+ CPPUNIT_TEST(func2);
+ CPPUNIT_TEST(func3);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void func1();
+ void func2();
+ void func3();
+ static bool bigger(int i_);
+ static bool bigger_than(int x_, int y_);
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(FuncTest);
+
+//
+// tests implementation
+//
+bool FuncTest::bigger(int i_)
+{
+ return i_ > 3;
+}
+bool FuncTest::bigger_than(int x_, int y_)
+{
+ return x_ > y_;
+}
+void FuncTest::func1()
+{
+ vector<int>v;
+ v.push_back(4);
+ v.push_back(1);
+ v.push_back(5);
+ int n = count_if(v.begin(), v.end(), bigger);
+ CPPUNIT_ASSERT( n == 2 )
+}
+
+void FuncTest::func2()
+{
+ vector<int> v;
+ v.push_back(4);
+ v.push_back(1);
+ v.push_back(5);
+ sort(v.begin(), v.end(), bigger_than);
+
+ CPPUNIT_ASSERT( v[0] == 5 );
+ CPPUNIT_ASSERT( v[1] == 4 );
+ CPPUNIT_ASSERT( v[2] == 1 );
+}
+void FuncTest::func3()
+{
+ vector<int> v;
+ v.push_back(4);
+ v.push_back(1);
+ v.push_back(5);
+ sort(v.begin(), v.end(), greater<int>());
+
+ CPPUNIT_ASSERT( v[0] == 5 );
+ CPPUNIT_ASSERT( v[1] == 4 );
+ CPPUNIT_ASSERT( v[2] == 1 );
+}
diff --git a/sources/android/stlport/test/unit/functional_header_test.cpp b/sources/android/stlport/test/unit/functional_header_test.cpp
new file mode 100644
index 0000000..47bce72
--- /dev/null
+++ b/sources/android/stlport/test/unit/functional_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <functional>
diff --git a/sources/android/stlport/test/unit/generator_test.cpp b/sources/android/stlport/test/unit/generator_test.cpp
new file mode 100644
index 0000000..70ac945
--- /dev/null
+++ b/sources/android/stlport/test/unit/generator_test.cpp
@@ -0,0 +1,92 @@
+#include <vector>
+#include <algorithm>
+#include "fadapter.h"
+#include "fib.h"
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class GeneratorTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(GeneratorTest);
+ CPPUNIT_TEST(gener1);
+ CPPUNIT_TEST(gener2);
+ CPPUNIT_TEST(genern1);
+ CPPUNIT_TEST(genern2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void gener1();
+ void gener2();
+ void genern1();
+ void genern2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(GeneratorTest);
+
+//
+// tests implementation
+//
+
+static int cxxrand() { return rand();}
+
+void GeneratorTest::gener1()
+{
+ int numbers[10];
+#if defined(__MVS__)
+ generate(numbers, numbers + 10, ptr_gen(cxxrand));
+#else
+ generate(numbers, numbers + 10, cxxrand);
+#endif
+ // any suggestions?
+}
+void GeneratorTest::gener2()
+{
+ vector <int> v1(10);
+ Fibonacci generator;
+ generate(v1.begin(), v1.end(), generator);
+
+ CPPUNIT_ASSERT(v1[0]==1);
+ CPPUNIT_ASSERT(v1[1]==1);
+ CPPUNIT_ASSERT(v1[2]==2);
+ CPPUNIT_ASSERT(v1[3]==3);
+ CPPUNIT_ASSERT(v1[4]==5);
+ CPPUNIT_ASSERT(v1[5]==8);
+ CPPUNIT_ASSERT(v1[6]==13);
+ CPPUNIT_ASSERT(v1[7]==21);
+ CPPUNIT_ASSERT(v1[8]==34);
+ CPPUNIT_ASSERT(v1[9]==55);
+}
+void GeneratorTest::genern1()
+{
+#if !defined (_STLP_MEMBER_POINTER_PARAM_BUG)
+ //*TY 07/18/98 - added conditional
+ // since ptr_gen() is not defined under this condition
+ // (see xfunction.h)
+ vector <int> v1(10);
+ generate_n(v1.begin(), v1.size(), ptr_gen(cxxrand));
+#endif //_STLP_MEMBER_POINTER_PARAM_BUG //*TY 07/18/98 - added
+}
+void GeneratorTest::genern2()
+{
+ vector <int> v1(10);
+ Fibonacci generator;
+ generate_n(v1.begin(), v1.size(), generator);
+
+ CPPUNIT_ASSERT(v1[0]==1);
+ CPPUNIT_ASSERT(v1[1]==1);
+ CPPUNIT_ASSERT(v1[2]==2);
+ CPPUNIT_ASSERT(v1[3]==3);
+ CPPUNIT_ASSERT(v1[4]==5);
+ CPPUNIT_ASSERT(v1[5]==8);
+ CPPUNIT_ASSERT(v1[6]==13);
+ CPPUNIT_ASSERT(v1[7]==21);
+ CPPUNIT_ASSERT(v1[8]==34);
+ CPPUNIT_ASSERT(v1[9]==55);
+}
diff --git a/sources/android/stlport/test/unit/greater_test.cpp b/sources/android/stlport/test/unit/greater_test.cpp
new file mode 100644
index 0000000..a3b8585
--- /dev/null
+++ b/sources/android/stlport/test/unit/greater_test.cpp
@@ -0,0 +1,49 @@
+#include <vector>
+#include <algorithm>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class GreaterTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(GreaterTest);
+ CPPUNIT_TEST(greatert);
+ CPPUNIT_TEST(greatereq);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void greatert();
+ void greatereq();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(GreaterTest);
+
+//
+// tests implementation
+//
+void GreaterTest::greatert()
+{
+ int array[4] = { 3, 1, 4, 2 };
+ sort(array, array + 4, greater<int>() );
+
+ CPPUNIT_ASSERT(array[0]==4);
+ CPPUNIT_ASSERT(array[1]==3);
+ CPPUNIT_ASSERT(array[2]==2);
+ CPPUNIT_ASSERT(array[3]==1);
+}
+void GreaterTest::greatereq()
+{
+ int array [4] = { 3, 1, 4, 2 };
+ sort(array, array + 4, greater_equal<int>());
+ CPPUNIT_ASSERT(array[0]==4);
+ CPPUNIT_ASSERT(array[1]==3);
+ CPPUNIT_ASSERT(array[2]==2);
+ CPPUNIT_ASSERT(array[3]==1);
+}
diff --git a/sources/android/stlport/test/unit/hash_test.cpp b/sources/android/stlport/test/unit/hash_test.cpp
new file mode 100644
index 0000000..4ea913e
--- /dev/null
+++ b/sources/android/stlport/test/unit/hash_test.cpp
@@ -0,0 +1,434 @@
+//Has to be first for StackAllocator swap overload to be taken
+//into account (at least using GCC 4.0.1)
+#include "stack_allocator.h"
+
+#include <vector>
+#include <algorithm>
+#include <map>
+#include <set>
+
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+# include <hash_map>
+# include <hash_set>
+# include <rope>
+#endif
+
+#include <string>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if defined (__MVS__)
+const char star = 92;
+#else
+const char star = 42;
+#endif
+
+#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class HashTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(HashTest);
+#if !defined (STLPORT) || defined (_STLP_NO_EXTENSIONS)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(hmap1);
+ CPPUNIT_TEST(hmmap1);
+ CPPUNIT_TEST(hmmap2);
+ CPPUNIT_TEST(hmset1);
+ CPPUNIT_TEST(hset2);
+ CPPUNIT_TEST(insert_erase);
+ CPPUNIT_TEST(allocator_with_state);
+ //CPPUNIT_TEST(equality);
+ CPPUNIT_TEST_SUITE_END();
+
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ typedef hash_multiset<char, hash<char>, equal_to<char> > hmset;
+#endif
+
+protected:
+ void hmap1();
+ void hmmap1();
+ void hmmap2();
+ void hmset1();
+ void hset2();
+ void insert_erase();
+ //void equality();
+ void allocator_with_state();
+
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ typedef hash_multimap<int, int> hashType;
+ typedef multimap<int, int> mapType;
+
+ void check_keys( hashType& h, mapType& m );
+#endif
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(HashTest);
+
+//
+// tests implementation
+//
+void HashTest::hmap1()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ typedef hash_map<char, crope, hash<char>, equal_to<char> > maptype;
+ maptype m;
+ // Store mappings between roman numerals and decimals.
+ m['l'] = "50";
+ m['x'] = "20"; // Deliberate mistake.
+ m['v'] = "5";
+ m['i'] = "1";
+ CPPUNIT_ASSERT( !strcmp(m['x'].c_str(),"20") );
+ m['x'] = "10"; // Correct mistake.
+ CPPUNIT_ASSERT( !strcmp(m['x'].c_str(),"10") );
+
+ CPPUNIT_ASSERT( !strcmp(m['z'].c_str(),"") );
+
+ CPPUNIT_ASSERT( m.count('z')==1 );
+ pair<maptype::iterator, bool> p = m.insert(pair<const char, crope>('c', crope("100")));
+
+ CPPUNIT_ASSERT(p.second);
+
+ p = m.insert(pair<const char, crope>('c', crope("100")));
+ CPPUNIT_ASSERT(!p.second);
+
+ //Some iterators compare check, really compile time checks
+ maptype::iterator ite(m.begin());
+ maptype::const_iterator cite(m.begin());
+ cite = m.begin();
+ maptype const& cm = m;
+ cite = cm.begin();
+ CPPUNIT_ASSERT( ite == cite );
+ CPPUNIT_ASSERT( !(ite != cite) );
+ CPPUNIT_ASSERT( cite == ite );
+ CPPUNIT_ASSERT( !(cite != ite) );
+#endif
+}
+
+void HashTest::hmmap1()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ typedef hash_multimap<char, int, hash<char>,equal_to<char> > mmap;
+ mmap m;
+ CPPUNIT_ASSERT(m.count('X')==0);
+ m.insert(pair<const char,int>('X', 10)); // Standard way.
+ CPPUNIT_ASSERT(m.count('X')==1);
+// m.insert('X', 20); // Non-standard, but very convenient!
+ m.insert(pair<const char,int>('X', 20)); // jbuck: standard way
+ CPPUNIT_ASSERT(m.count('X')==2);
+// m.insert('Y', 32);
+ m.insert(pair<const char,int>('Y', 32)); // jbuck: standard way
+ mmap::iterator i = m.find('X'); // Find first match.
+
+ CPPUNIT_ASSERT((*i).first=='X');
+ CPPUNIT_ASSERT((*i).second==10);
+ i++;
+ CPPUNIT_ASSERT((*i).first=='X');
+ CPPUNIT_ASSERT((*i).second==20);
+ i++;
+ CPPUNIT_ASSERT((*i).first=='Y');
+ CPPUNIT_ASSERT((*i).second==32);
+ i++;
+ CPPUNIT_ASSERT(i==m.end());
+
+ size_t count = m.erase('X');
+ CPPUNIT_ASSERT(count==2);
+
+ //Some iterators compare check, really compile time checks
+ mmap::iterator ite(m.begin());
+ mmap::const_iterator cite(m.begin());
+ CPPUNIT_ASSERT( ite == cite );
+ CPPUNIT_ASSERT( !(ite != cite) );
+ CPPUNIT_ASSERT( cite == ite );
+ CPPUNIT_ASSERT( !(cite != ite) );
+
+ typedef hash_multimap<size_t, size_t> HMapType;
+ HMapType hmap;
+
+ //We fill the map to implicitely start a rehash.
+ for (size_t counter = 0; counter < 3077; ++counter)
+ hmap.insert(HMapType::value_type(1, counter));
+
+ hmap.insert(HMapType::value_type(12325, 1));
+ hmap.insert(HMapType::value_type(12325, 2));
+
+ CPPUNIT_ASSERT( hmap.count(12325) == 2 );
+
+ //At this point 23 goes to the same bucket as 12325, it used to reveal a bug.
+ hmap.insert(HMapType::value_type(23, 0));
+
+ CPPUNIT_ASSERT( hmap.count(12325) == 2 );
+#endif
+}
+
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+// Short demonstrator that helps reproducing a bug in the hash-table implementation
+// of STLPort 5.0.1/5.0.2.
+//
+// Problem: Fill a hash_multimap with entries of which many have the same key
+// Internally, entries with the same key are kept as one block within the same bucket.
+// Thus, when calling equal_range(key) the begin/end of that block is returned.
+// However, this code shows that for key =3, that block is destroyed after inserting the 194th element.
+// According to _hashtable.c we will have a rehash from size 193 to size 389 in that situation.
+// After that rehash, equal_range only returns 2 elements with key = 3 whereas there are 65 in it.
+// Reproduction:
+// In the main()-method we fill a hash_multimap as well as a multi_map with the same <key, data> pairs
+// After each insertion we call check_keys(...) to assure validity of these two containers.
+// This works fine up to the 193th insertion. Insertion 194 generates the bug.
+//
+// check_keys() works as follows:
+// (a) we check whether both containers contain the same number of elements.
+// (b) Assuming that the multi_map works correctly, we iterate over all its elements and check
+// whether we can find that key also in the hash_multimap. We collect all data for that specific
+// key in in a set ("collection"). Notice that data is unique by construction in main(), thus the
+// number of elements in the set must equal the number of entries in the hash_multimap and in the multimap
+// (c) We check if we have seen as many data elements in collection as we have seen in the multimap.
+// if so, we print "OK", otherwise we print a detailed key/data overview and assert.
+// Caution:
+// There are several configurations of the program that will NOT fail. (see comment in code below)
+// E.g. it seems that whenever the keys are more or less sorted, the problem does not occur.
+// Also, using numbers from 200 downto 1 or from 300 downto 1 cannot generate the problem,
+// whereas using 400 downto 1 will fail.
+// Finally, if we use key 1 (rather than key 3) we cannot generate a problem.
+
+void HashTest::check_keys( HashTest::hashType& h, HashTest::mapType& m )
+{
+ set<int> collection;
+
+ // (a) check sizes
+ CPPUNIT_CHECK( h.size() == m.size() );
+
+ // (b) iterate over multi_map
+ for ( mapType::iterator i = m.begin(); i != m.end(); ++i ) {
+ // look up that key in hash-table and keep all data in the set
+ pair<hashType::iterator,hashType::iterator> range = h.equal_range( i->first );
+ for ( hashType::iterator j = range.first; j != range.second; ++j ) {
+ collection.insert( j->second );
+ }
+ }
+ // (c) we should have seen as many elements as there are in the hash-table
+#if 0
+ if (collection.size() == h.size()) cout << " OK" << endl;
+ else {
+ // if not, please report
+ cout << " FAILED: " << endl;
+ int lastKey = -1;
+ // iterate over all elements in multi_map
+ for (mapType::iterator mIter = m.begin(); mIter != m.end(); mIter++) {
+ // new key? print a new status line
+ if (mIter->first != lastKey) {
+ cout << endl << "Key : " << mIter->first << endl;
+ lastKey = mIter->first;
+
+ // print all hashed values for that key
+ cout << " data in hash: ";
+ pair<hashType::iterator,hashType::iterator> range = h.equal_range(mIter->first);
+
+ for (hashType::iterator h = range.first; h != range.second; h++) {
+ assert (h->first == lastKey);
+ cerr << h->second << ", "; // print all data for that key in Hash-Table
+ }
+ cout << endl << " data in map: ";
+ }
+ // and print all member in multi-map until the next key occurs
+ cout << mIter->second << ", " ; // print all data for that key in Map
+ }
+ }
+#endif
+ CPPUNIT_CHECK( collection.size() == h.size() );
+}
+
+#endif
+
+void HashTest::hmmap2()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ hashType h;
+ mapType m;
+
+ // CAUTION the following configurations WORKS in our setting
+ // for (int id = 1; id != 400; id ++) and int key = (id %3 == 0 ? 3 : id)
+ // for (int id = 200; id != 1; id --) and int key = (id %3 == 0 ? 3 : id)
+ // for (int id = 300; id != 1; id --) and int key = (id %3 == 0 ? 3 : id)
+ // for (int id = 400; id != 1; id --) and int key = (id %3 == 0 ? 1 : id)
+ // for (int id = 4000; id != 1; id --) and int key = (id %3 == 0 ? 1 : id)
+ //
+ // whereas these will FAIL
+ // for (int id = 400; id != 1; id --) and int key = (id %3 == 0 ? 3 : id)
+ // for (int id = 4000; id != 1; id --) and int key = (id %3 == 0 ? 3 : id)
+ //
+
+ for ( int id = 400; id != 1; id-- ) {
+ // generate many entries with key 3, fill up with unique keys. Data is unique (needed in check_keys())
+ int key = (id % 3 == 0 ? 3 : id);
+
+ // keep hash_multi_map and multimap in sync
+ h.insert(make_pair(key, id));
+ m.insert(make_pair(key, id));
+
+ // check whether both contain the same elements
+ check_keys( h, m );
+ }
+#endif
+}
+
+void HashTest::hmset1()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ hmset s;
+ CPPUNIT_ASSERT( s.count(star) == 0 );
+ s.insert(star);
+ CPPUNIT_ASSERT( s.count(star) == 1 );
+ s.insert(star);
+ CPPUNIT_ASSERT( s.count(star) == 2 );
+ hmset::iterator i = s.find(char(40));
+ CPPUNIT_ASSERT( i == s.end() );
+
+ i = s.find(star);
+ CPPUNIT_ASSERT( i != s.end() )
+ CPPUNIT_ASSERT( *i == '*' );
+ CPPUNIT_ASSERT( s.erase(star) == 2 );
+#endif
+}
+void HashTest::hset2()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ hash_set<int, hash<int>, equal_to<int> > s;
+ pair<hash_set<int, hash<int>, equal_to<int> >::iterator, bool> p = s.insert(42);
+ CPPUNIT_ASSERT( p.second );
+ CPPUNIT_ASSERT( *(p.first) == 42 );
+
+ p = s.insert(42);
+ CPPUNIT_ASSERT( !p.second );
+#endif
+}
+
+void HashTest::insert_erase()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ typedef hash_map<string, size_t, hash<string>, equal_to<string> > hmap;
+ typedef hmap::value_type val_type;
+ {
+ hmap values;
+# if !defined (__BORLANDC__) || (__BORLANDC__ >= 0x564)
+ CPPUNIT_ASSERT( values.insert(val_type("foo", 0)).second );
+ CPPUNIT_ASSERT( values.insert(val_type("bar", 0)).second );
+ CPPUNIT_ASSERT( values.insert(val_type("abc", 0)).second );
+# else
+ CPPUNIT_ASSERT( values.insert(hmap::value_type("foo", 0)).second );
+ CPPUNIT_ASSERT( values.insert(hmap::value_type("bar", 0)).second );
+ CPPUNIT_ASSERT( values.insert(hmap::value_type("abc", 0)).second );
+# endif
+
+ CPPUNIT_ASSERT( values.erase("foo") == 1 );
+ CPPUNIT_ASSERT( values.erase("bar") == 1 );
+ CPPUNIT_ASSERT( values.erase("abc") == 1 );
+ }
+
+ {
+ hmap values;
+# if !defined (__BORLANDC__) || (__BORLANDC__ >= 0x564)
+ CPPUNIT_ASSERT( values.insert(val_type("foo", 0)).second );
+ CPPUNIT_ASSERT( values.insert(val_type("bar", 0)).second );
+ CPPUNIT_ASSERT( values.insert(val_type("abc", 0)).second );
+# else
+ CPPUNIT_ASSERT( values.insert(hmap::value_type("foo", 0)).second );
+ CPPUNIT_ASSERT( values.insert(hmap::value_type("bar", 0)).second );
+ CPPUNIT_ASSERT( values.insert(hmap::value_type("abc", 0)).second );
+# endif
+
+ CPPUNIT_ASSERT( values.erase("abc") == 1 );
+ CPPUNIT_ASSERT( values.erase("bar") == 1 );
+ CPPUNIT_ASSERT( values.erase("foo") == 1 );
+ }
+#endif
+}
+
+/*
+ * Here is the test showing why equality operator on hash containers
+ * has no meaning:
+
+struct equality_hash_func {
+ size_t operator () (size_t val) const {
+ return val % 10;
+ }
+};
+
+void HashTest::equality()
+{
+ hash_set<size_t, equality_hash_func, equal_to<size_t> > s1, s2;
+
+ s1.insert(10);
+ s1.insert(20);
+
+ s2.insert(20);
+ s2.insert(10);
+
+ //s1 and s2 contains both 10 and 20:
+ CPPUNIT_ASSERT( s1 == s2 );
+}
+*/
+
+void HashTest::allocator_with_state()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ char buf1[2048];
+ StackAllocator<int> stack1(buf1, buf1 + sizeof(buf1));
+
+ char buf2[2048];
+ StackAllocator<int> stack2(buf2, buf2 + sizeof(buf2));
+
+ {
+ typedef hash_set<int, hash<int>, equal_to<int>, StackAllocator<int> > HashSetInt;
+ HashSetInt hint1(10, hash<int>(), equal_to<int>(), stack1);
+
+ int i;
+ for (i = 0; i < 5; ++i)
+ hint1.insert(i);
+ HashSetInt hint1Cpy(hint1);
+
+ HashSetInt hint2(10, hash<int>(), equal_to<int>(), stack2);
+ for (; i < 10; ++i)
+ hint2.insert(i);
+ HashSetInt hint2Cpy(hint2);
+
+ hint1.swap(hint2);
+
+ CPPUNIT_ASSERT( hint1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( hint2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( hint1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( hint2.get_allocator() == stack1 );
+ }
+ CPPUNIT_ASSERT( stack1.ok() );
+ CPPUNIT_ASSERT( stack2.ok() );
+#endif
+}
+
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS) && \
+ (!defined (_STLP_USE_PTR_SPECIALIZATIONS) || defined (_STLP_CLASS_PARTIAL_SPECIALIZATION))
+# if !defined (__DMC__)
+
+/* Simple compilation test: Check that nested types like iterator
+ * can be access even if type used to instanciate container is not
+ * yet completely defined.
+ */
+class IncompleteClass
+{
+ hash_set<IncompleteClass> hsinstances;
+ typedef hash_set<IncompleteClass>::iterator hsit;
+ hash_multiset<IncompleteClass> hsminstances;
+ typedef hash_multiset<IncompleteClass>::iterator hsmit;
+
+ hash_map<IncompleteClass, IncompleteClass> hminstances;
+ typedef hash_map<IncompleteClass, IncompleteClass>::iterator hmit;
+ hash_multimap<IncompleteClass, IncompleteClass> hmminstances;
+ typedef hash_multimap<IncompleteClass, IncompleteClass>::iterator hmmit;
+};
+# endif
+#endif
diff --git a/sources/android/stlport/test/unit/heap_test.cpp b/sources/android/stlport/test/unit/heap_test.cpp
new file mode 100644
index 0000000..87eb75d
--- /dev/null
+++ b/sources/android/stlport/test/unit/heap_test.cpp
@@ -0,0 +1,108 @@
+#include <vector>
+#include <algorithm>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class HeapTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(HeapTest);
+ CPPUNIT_TEST(mkheap0);
+ CPPUNIT_TEST(mkheap1);
+ CPPUNIT_TEST(pheap1);
+ CPPUNIT_TEST(pheap2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void mkheap0();
+ void mkheap1();
+ void pheap1();
+ void pheap2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(HeapTest);
+
+//
+// tests implementation
+//
+void HeapTest::mkheap0()
+{
+ int numbers[6] = { 5, 10, 4, 13, 11, 19 };
+
+ make_heap(numbers, numbers + 6);
+ CPPUNIT_ASSERT(numbers[0]==19)
+ pop_heap(numbers, numbers + 6);
+ CPPUNIT_ASSERT(numbers[0]==13)
+ pop_heap(numbers, numbers + 5);
+ CPPUNIT_ASSERT(numbers[0]==11)
+ pop_heap(numbers, numbers + 4);
+ CPPUNIT_ASSERT(numbers[0]==10)
+ pop_heap(numbers, numbers + 3);
+ CPPUNIT_ASSERT(numbers[0]==5)
+ pop_heap(numbers, numbers + 2);
+ CPPUNIT_ASSERT(numbers[0]==4)
+ pop_heap(numbers, numbers + 1);
+}
+void HeapTest::mkheap1()
+{
+ int numbers[6] = { 5, 10, 4, 13, 11, 19 };
+
+ make_heap(numbers, numbers + 6, greater<int>());
+
+ CPPUNIT_ASSERT(numbers[0]==4)
+ pop_heap(numbers, numbers + 6, greater<int>());
+ CPPUNIT_ASSERT(numbers[0]==5)
+ pop_heap(numbers, numbers + 5, greater<int>());
+ CPPUNIT_ASSERT(numbers[0]==10)
+ pop_heap(numbers, numbers + 4, greater<int>());
+ CPPUNIT_ASSERT(numbers[0]==11)
+ pop_heap(numbers, numbers + 3, greater<int>());
+ CPPUNIT_ASSERT(numbers[0]==13)
+ pop_heap(numbers, numbers + 2, greater<int>());
+ CPPUNIT_ASSERT(numbers[0]==19)
+}
+void HeapTest::pheap1()
+{
+ vector<int> v;
+
+ v.push_back(1);
+ v.push_back(20);
+ v.push_back(4);
+ make_heap(v.begin(), v.end());
+
+ v.push_back(7);
+ push_heap(v.begin(), v.end());
+
+ sort_heap(v.begin(), v.end());
+
+ CPPUNIT_ASSERT(v[0]==1);
+ CPPUNIT_ASSERT(v[1]==4);
+ CPPUNIT_ASSERT(v[2]==7);
+ CPPUNIT_ASSERT(v[3]==20);
+}
+void HeapTest::pheap2()
+{
+ vector<int> v;
+
+ v.push_back(1);
+ v.push_back(20);
+ v.push_back(4);
+ make_heap(v.begin(), v.end(), greater<int>());
+
+ v.push_back(7);
+ push_heap(v.begin(), v.end(), greater<int>());
+
+ sort_heap(v.begin(), v.end(), greater<int>());
+
+ CPPUNIT_ASSERT(v[0]==20);
+ CPPUNIT_ASSERT(v[1]==7);
+ CPPUNIT_ASSERT(v[2]==4);
+ CPPUNIT_ASSERT(v[3]==1);
+}
diff --git a/sources/android/stlport/test/unit/includes_test.cpp b/sources/android/stlport/test/unit/includes_test.cpp
new file mode 100644
index 0000000..d641797
--- /dev/null
+++ b/sources/android/stlport/test/unit/includes_test.cpp
@@ -0,0 +1,87 @@
+#include <cstring>
+#include <vector>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class IncludesTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(IncludesTest);
+ CPPUNIT_TEST(incl0);
+ CPPUNIT_TEST(incl1);
+ CPPUNIT_TEST(incl2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void incl0();
+ void incl1();
+ void incl2();
+
+ static bool compare_strings(const char* s1_, const char* s2_)
+ {
+ return strcmp(s1_, s2_) < 0 ? 1 : 0;
+ }
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(IncludesTest);
+
+//
+// tests implementation
+//
+void IncludesTest::incl0()
+{
+ int numbers1[5] = { 1, 2, 3, 4, 5 };
+ //int numbers2[5] = { 1, 2, 4, 8, 16 };
+ int numbers3[2] = { 4, 8 };
+ bool r1=includes(numbers1, numbers1 + 5, numbers3, numbers3 + 2);
+ CPPUNIT_ASSERT(!r1);
+}
+void IncludesTest::incl1()
+{
+ vector<int> v1(10);
+ vector<int> v2(3);
+ int i;
+ for (i = 0; (size_t)i < v1.size(); ++i) {
+ v1[i] = i;
+ }
+
+ bool r1=includes(v1.begin(), v1.end(), v2.begin(), v2.end());
+ CPPUNIT_ASSERT(!r1);
+
+ for (i = 0; (size_t)i < v2.size(); ++i)
+ v2[i] = i + 3;
+
+ bool r2=includes(v1.begin(), v1.end(), v2.begin(), v2.end());
+ CPPUNIT_ASSERT(r2);
+}
+void IncludesTest::incl2()
+{
+ char const* names[] = { "Todd", "Mike", "Graham", "Jack", "Brett"};
+
+ const unsigned nameSize = sizeof(names)/sizeof(names[0]);
+ vector <char const*> v1(nameSize);
+ for (int i = 0; (size_t)i < v1.size(); ++i) {
+ v1[i] = names[i];
+ }
+ vector <char const*> v2(2);
+
+ v2[0] = "foo";
+ v2[1] = "bar";
+ sort(v1.begin(), v1.end(), compare_strings);
+ sort(v2.begin(), v2.end(), compare_strings);
+
+ bool r1 = includes(v1.begin(), v1.end(), v2.begin(), v2.end(), compare_strings);
+ CPPUNIT_ASSERT(!r1);
+
+ v2[0] = "Brett";
+ v2[1] = "Todd";
+ bool r2 = includes(v1.begin(), v1.end(), v2.begin(), v2.end(), compare_strings);
+ CPPUNIT_ASSERT(r2);
+}
diff --git a/sources/android/stlport/test/unit/innerprod_test.cpp b/sources/android/stlport/test/unit/innerprod_test.cpp
new file mode 100644
index 0000000..3d77f5d
--- /dev/null
+++ b/sources/android/stlport/test/unit/innerprod_test.cpp
@@ -0,0 +1,72 @@
+#include <vector>
+#include <algorithm>
+#include <numeric>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class InnerprodTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(InnerprodTest);
+ CPPUNIT_TEST(inprod0);
+ CPPUNIT_TEST(inprod1);
+ CPPUNIT_TEST(inprod2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void inprod0();
+ void inprod1();
+ void inprod2();
+
+ static size_t add(size_t a_, size_t b_) {
+ return a_ + b_;
+ }
+
+ static size_t mult(size_t a_, size_t b_) {
+ return a_ * b_;
+ }
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(InnerprodTest);
+
+//
+// tests implementation
+//
+void InnerprodTest::inprod0()
+{
+ int vector1[5] = { 1, 2, 3, 4, 5 };
+ int vector2[5] = { 1, 2, 3, 4, 5 };
+
+ int result;
+ result = inner_product(vector1, vector1 + 5, vector2, 0);
+ CPPUNIT_ASSERT(result==55);
+}
+void InnerprodTest::inprod1()
+{
+ vector<size_t> v1(3);
+ vector<size_t> v2(v1.size());
+ for (size_t i = 0; i < v1.size(); ++i) {
+ v1[i] = i + 1;
+ v2[i] = v1.size() - i;
+ }
+ size_t result = inner_product(v1.begin(), v1.end(), v2.begin(), (size_t)0);
+ CPPUNIT_ASSERT(result == 10);
+}
+void InnerprodTest::inprod2()
+{
+ vector<size_t> v1(3);
+ vector<size_t> v2(v1.size());
+ for(size_t i = 0; i < v1.size(); ++i) {
+ v1[i] = i + 1;
+ v2[i] = v1.size() - i;
+ }
+ size_t result=inner_product(v1.begin(), v1.end(), v2.begin(), (size_t)1, mult, add);
+
+ CPPUNIT_ASSERT(result == 64);
+}
diff --git a/sources/android/stlport/test/unit/inplace_test.cpp b/sources/android/stlport/test/unit/inplace_test.cpp
new file mode 100644
index 0000000..2c9bd99
--- /dev/null
+++ b/sources/android/stlport/test/unit/inplace_test.cpp
@@ -0,0 +1,61 @@
+#include <vector>
+#include <algorithm>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class InplaceTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(InplaceTest);
+ CPPUNIT_TEST(inplmrg1);
+ CPPUNIT_TEST(inplmrg2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void inplmrg1();
+ void inplmrg2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(InplaceTest);
+
+//
+// tests implementation
+//
+void InplaceTest::inplmrg1()
+{
+ int numbers[6] = { 1, 10, 42, 3, 16, 32 };
+ inplace_merge(numbers, numbers + 3, numbers + 6);
+
+ CPPUNIT_ASSERT(numbers[0]==1);
+ CPPUNIT_ASSERT(numbers[1]==3);
+ CPPUNIT_ASSERT(numbers[2]==10);
+ CPPUNIT_ASSERT(numbers[3]==16);
+ CPPUNIT_ASSERT(numbers[4]==32);
+ CPPUNIT_ASSERT(numbers[5]==42);
+}
+void InplaceTest::inplmrg2()
+{
+ vector<size_t> v1(10);
+ for(size_t i = 0; i < v1.size(); ++i)
+ v1[i] =(v1.size() - i - 1) % 5;
+
+ inplace_merge(v1.begin(), v1.begin() + 5, v1.end(), greater<size_t>());
+
+ CPPUNIT_ASSERT(v1[0]==4);
+ CPPUNIT_ASSERT(v1[1]==4);
+ CPPUNIT_ASSERT(v1[2]==3);
+ CPPUNIT_ASSERT(v1[3]==3);
+ CPPUNIT_ASSERT(v1[4]==2);
+ CPPUNIT_ASSERT(v1[5]==2);
+ CPPUNIT_ASSERT(v1[6]==1);
+ CPPUNIT_ASSERT(v1[7]==1);
+ CPPUNIT_ASSERT(v1[8]==0);
+ CPPUNIT_ASSERT(v1[9]==0);
+}
diff --git a/sources/android/stlport/test/unit/insert_test.cpp b/sources/android/stlport/test/unit/insert_test.cpp
new file mode 100644
index 0000000..e0ec1a2
--- /dev/null
+++ b/sources/android/stlport/test/unit/insert_test.cpp
@@ -0,0 +1,70 @@
+#include <deque>
+#include <vector>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class InsertTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(InsertTest);
+ CPPUNIT_TEST(insert1);
+ CPPUNIT_TEST(insert2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void insert1();
+ void insert2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(InsertTest);
+
+//
+// tests implementation
+//
+void InsertTest::insert1()
+{
+ char const* array1 [] = { "laurie", "jennifer", "leisa" };
+ char const* array2 [] = { "amanda", "saskia", "carrie" };
+
+ deque<char const*> names(array1, array1 + 3);
+ deque<char const*>::iterator i = names.begin() + 2;
+
+ insert_iterator<deque <char const*> > itd(names, i);
+ itd = copy(array2, array2 + 3, insert_iterator<deque <char const*> >(names, i));
+
+ CPPUNIT_ASSERT( !strcmp(names[0], "laurie") );
+ CPPUNIT_ASSERT( !strcmp(names[1], "jennifer") );
+ CPPUNIT_ASSERT( !strcmp(names[2], "amanda") );
+ CPPUNIT_ASSERT( !strcmp(names[3], "saskia") );
+ CPPUNIT_ASSERT( !strcmp(names[4], "carrie") );
+ CPPUNIT_ASSERT( !strcmp(names[5], "leisa") );
+
+ copy(array1, array1 + 3, itd);
+ CPPUNIT_ASSERT( !strcmp(names[5], "laurie") );
+ CPPUNIT_ASSERT( !strcmp(names[6], "jennifer") );
+ CPPUNIT_ASSERT( !strcmp(names[7], "leisa") );
+ CPPUNIT_ASSERT( !strcmp(names[8], "leisa") );
+}
+void InsertTest::insert2()
+{
+ char const* array1 [] = { "laurie", "jennifer", "leisa" };
+ char const* array2 [] = { "amanda", "saskia", "carrie" };
+
+ deque<char const*> names(array1, array1 + 3);
+ deque<char const*>::iterator i = names.begin() + 2;
+ copy(array2, array2 + 3, inserter(names, i));
+
+ CPPUNIT_ASSERT( !strcmp(names[0], "laurie") );
+ CPPUNIT_ASSERT( !strcmp(names[1], "jennifer") );
+ CPPUNIT_ASSERT( !strcmp(names[2], "amanda") );
+ CPPUNIT_ASSERT( !strcmp(names[3], "saskia") );
+ CPPUNIT_ASSERT( !strcmp(names[4], "carrie") );
+ CPPUNIT_ASSERT( !strcmp(names[5], "leisa") );
+}
diff --git a/sources/android/stlport/test/unit/ioiter_test.cpp b/sources/android/stlport/test/unit/ioiter_test.cpp
new file mode 100644
index 0000000..6f0aeb9
--- /dev/null
+++ b/sources/android/stlport/test/unit/ioiter_test.cpp
@@ -0,0 +1,110 @@
+#include <string>
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+#include <sstream>
+#include <vector>
+#include <iterator>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+class IoiterTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(IoiterTest);
+ CPPUNIT_TEST(ioiter_test);
+ CPPUNIT_TEST(assign_test);
+ CPPUNIT_TEST(assign2_test);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void ioiter_test();
+ void assign_test();
+ void assign2_test();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(IoiterTest);
+
+void IoiterTest::ioiter_test()
+{
+
+ char c;
+ const char *pc;
+ const char *strorg = "abcd";
+ string tmp;
+
+ string objStr(strorg);
+
+ istringstream objIStrStrm1(objStr);
+ istringstream objIStrStrm2(objStr);
+ istringstream objIStrStrm3(objStr);
+
+ pc = strorg;
+ string::size_type sz = strlen(strorg);
+ string::size_type i;
+ for ( i = 0; i < sz; ++i ) {
+ c = *pc++;
+ tmp += c;
+ }
+ CPPUNIT_ASSERT( tmp == "abcd" );
+
+ istreambuf_iterator<char, char_traits<char> > objIStrmbIt1( objIStrStrm1.rdbuf() );
+ istreambuf_iterator<char, char_traits<char> > end;
+
+ tmp.clear();
+
+ for ( i = 0; i < sz /* objIStrmbIt1 != end */; ++i ) {
+ c = *objIStrmbIt1++;
+ tmp += c;
+ }
+ CPPUNIT_ASSERT( tmp == "abcd" );
+
+ tmp.clear();
+
+ istreambuf_iterator<char, char_traits<char> > objIStrmbIt2( objIStrStrm2.rdbuf() );
+ for ( i = 0; i < sz; ++i ) {
+ c = *objIStrmbIt2;
+ tmp += c;
+ objIStrmbIt2++;
+ }
+ CPPUNIT_ASSERT( tmp == "abcd" );
+
+ tmp.clear();
+
+ istreambuf_iterator<char, char_traits<char> > objIStrmbIt3( objIStrStrm3.rdbuf() );
+
+ while ( objIStrmbIt3 != end ) {
+ c = *objIStrmbIt3++;
+ tmp += c;
+ }
+ CPPUNIT_ASSERT( tmp == "abcd" );
+}
+
+void IoiterTest::assign_test()
+{
+ stringstream s( "1234567890" );
+ vector<char> v;
+
+ v.assign( istreambuf_iterator<char>(s), istreambuf_iterator<char>() );
+ CPPUNIT_CHECK( v.size() == 10 );
+ if ( v.size() == 10 ) {
+ CPPUNIT_CHECK( v[0] == '1' );
+ CPPUNIT_CHECK( v[9] == '0' );
+ }
+}
+
+void IoiterTest::assign2_test()
+{
+ stringstream s( "1234567890" );
+ vector<char> v;
+
+ v.assign( istreambuf_iterator<char>(s.rdbuf()), istreambuf_iterator<char>() );
+ CPPUNIT_CHECK( v.size() == 10 );
+ if ( v.size() == 10 ) {
+ CPPUNIT_CHECK( v[0] == '1' );
+ CPPUNIT_CHECK( v[9] == '0' );
+ }
+}
+
+#endif
diff --git a/sources/android/stlport/test/unit/iomanip_header_test.cpp b/sources/android/stlport/test/unit/iomanip_header_test.cpp
new file mode 100644
index 0000000..fa0ab0f
--- /dev/null
+++ b/sources/android/stlport/test/unit/iomanip_header_test.cpp
@@ -0,0 +1,10 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#if !defined (_STLP_NO_IOSTREAMS)
+# include <iomanip>
+#endif
diff --git a/sources/android/stlport/test/unit/ios_header_test.cpp b/sources/android/stlport/test/unit/ios_header_test.cpp
new file mode 100644
index 0000000..c239643
--- /dev/null
+++ b/sources/android/stlport/test/unit/ios_header_test.cpp
@@ -0,0 +1,10 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#if !defined (_STLP_NO_IOSTREAMS)
+# include <ios>
+#endif
diff --git a/sources/android/stlport/test/unit/iosfwd_header_test.cpp b/sources/android/stlport/test/unit/iosfwd_header_test.cpp
new file mode 100644
index 0000000..8c3adcc
--- /dev/null
+++ b/sources/android/stlport/test/unit/iosfwd_header_test.cpp
@@ -0,0 +1,10 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#ifndef _STLP_NO_IOSTREAMS
+# include <iosfwd>
+#endif
diff --git a/sources/android/stlport/test/unit/iostream_header_test.cpp b/sources/android/stlport/test/unit/iostream_header_test.cpp
new file mode 100644
index 0000000..51e6df6
--- /dev/null
+++ b/sources/android/stlport/test/unit/iostream_header_test.cpp
@@ -0,0 +1,10 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#if !defined (_STLP_NO_IOSTREAMS)
+# include <iostream>
+#endif
diff --git a/sources/android/stlport/test/unit/iostream_test.cpp b/sources/android/stlport/test/unit/iostream_test.cpp
new file mode 100644
index 0000000..a4db5d8
--- /dev/null
+++ b/sources/android/stlport/test/unit/iostream_test.cpp
@@ -0,0 +1,116 @@
+#include <string>
+
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# include <sstream>
+//# include <locale>
+# include <iostream>
+//# include <stdexcept>
+
+# include "cppunit/cppunit_proxy.h"
+
+# if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+# endif
+
+//
+// TestCase class
+//
+class IOStreamTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(IOStreamTest);
+ CPPUNIT_TEST(manipulators);
+ CPPUNIT_TEST(in_avail);
+//#if defined (STLPORT) && defined (_STLP_NO_WCHAR_T)
+ //CPPUNIT_IGNORE;
+//#endif
+ //CPPUNIT_TEST(wimbue);
+ CPPUNIT_TEST_SUITE_END();
+
+private:
+ void manipulators();
+ void in_avail();
+ //void wimbue();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(IOStreamTest);
+
+//
+// tests implementation
+//
+void IOStreamTest::manipulators()
+{
+ {
+ istringstream istr;
+ istr.str("bar");
+
+ istr >> ws;
+ CPPUNIT_ASSERT( istr.good() );
+
+ string foo;
+ istr >> foo;
+ CPPUNIT_ASSERT( istr.eof() );
+ CPPUNIT_ASSERT( !istr.fail() );
+ CPPUNIT_ASSERT( foo == "bar" );
+
+ istr >> ws;
+ CPPUNIT_ASSERT( istr.eof() );
+ CPPUNIT_ASSERT( !istr.fail() );
+ istr.clear();
+ }
+
+ {
+ istringstream istr;
+ istr.str(" bar ");
+
+ istr >> ws;
+ CPPUNIT_ASSERT( istr.good() );
+
+ string foo;
+ istr >> foo;
+ CPPUNIT_ASSERT( !istr.eof() );
+ CPPUNIT_ASSERT( !istr.fail() );
+ CPPUNIT_ASSERT( foo == "bar" );
+
+ istr >> ws;
+ CPPUNIT_ASSERT( istr.eof() );
+ CPPUNIT_ASSERT( !istr.fail() );
+ istr.clear();
+ }
+}
+
+
+void IOStreamTest::in_avail()
+{
+ CPPUNIT_CHECK( cin.rdbuf()->in_avail() == 0 );
+ CPPUNIT_CHECK( cout.rdbuf()->in_avail() == -1 );
+ CPPUNIT_CHECK( clog.rdbuf()->in_avail() == -1 );
+ CPPUNIT_CHECK( cerr.rdbuf()->in_avail() == -1 );
+
+#if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
+ CPPUNIT_CHECK( wcin.rdbuf()->in_avail() == 0 );
+ CPPUNIT_CHECK( wcout.rdbuf()->in_avail() == 0 );
+ CPPUNIT_CHECK( wclog.rdbuf()->in_avail() == 0 );
+ CPPUNIT_CHECK( wcerr.rdbuf()->in_avail() == 0 );
+#endif
+}
+
+//void IOStreamTest::wimbue()
+//{
+//#if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
+// locale loc;
+// try {
+// locale tmp(".866");
+// loc = tmp;
+// }
+// catch (const runtime_error&) {
+// return;
+// }
+//
+// wcout.imbue(loc);
+// wcout << L"Hello world" << endl;
+// wcout.imbue(loc);
+// wcout << L"Hello world" << endl;
+//#endif
+//}
+
+#endif
diff --git a/sources/android/stlport/test/unit/iota.h b/sources/android/stlport/test/unit/iota.h
new file mode 100644
index 0000000..1cffefb
--- /dev/null
+++ b/sources/android/stlport/test/unit/iota.h
@@ -0,0 +1,18 @@
+#ifndef IOTA_H
+#define IOTA_H
+
+#include <numeric>
+
+//iota definition used in unit test
+template <typename _It, typename _Tp>
+void __iota(_It __first, _It __last, _Tp __val) {
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ iota(__first, __last, __val);
+#else
+ while (__first != __last) {
+ *__first++ = __val++;
+ }
+#endif
+}
+
+#endif
diff --git a/sources/android/stlport/test/unit/iota_test.cpp b/sources/android/stlport/test/unit/iota_test.cpp
new file mode 100644
index 0000000..24339b2
--- /dev/null
+++ b/sources/android/stlport/test/unit/iota_test.cpp
@@ -0,0 +1,47 @@
+#include <vector>
+#include <numeric>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class IotaTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(IotaTest);
+#if !defined (STLPORT) || defined (_STLP_NO_EXTENSIONS)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(iota1);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void iota1();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(IotaTest);
+
+//
+// tests implementation
+//
+void IotaTest::iota1()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ int numbers[10];
+ iota(numbers, numbers + 10, 42);
+ CPPUNIT_ASSERT(numbers[0]==42);
+ CPPUNIT_ASSERT(numbers[1]==43);
+ CPPUNIT_ASSERT(numbers[2]==44);
+ CPPUNIT_ASSERT(numbers[3]==45);
+ CPPUNIT_ASSERT(numbers[4]==46);
+ CPPUNIT_ASSERT(numbers[5]==47);
+ CPPUNIT_ASSERT(numbers[6]==48);
+ CPPUNIT_ASSERT(numbers[7]==49);
+ CPPUNIT_ASSERT(numbers[8]==50);
+ CPPUNIT_ASSERT(numbers[9]==51);
+#endif
+}
diff --git a/sources/android/stlport/test/unit/iso646_header_test.c b/sources/android/stlport/test/unit/iso646_header_test.c
new file mode 100644
index 0000000..41d7432
--- /dev/null
+++ b/sources/android/stlport/test/unit/iso646_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <iso646.h>
diff --git a/sources/android/stlport/test/unit/istmit_test.cpp b/sources/android/stlport/test/unit/istmit_test.cpp
new file mode 100644
index 0000000..c1e2d17
--- /dev/null
+++ b/sources/android/stlport/test/unit/istmit_test.cpp
@@ -0,0 +1,159 @@
+#include <algorithm>
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# include <sstream>
+# include <functional>
+# include <iterator>
+# include <vector>
+# include <string>
+#endif
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class IStreamIteratorTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(IStreamIteratorTest);
+#if defined (STLPORT) && defined (_STLP_USE_NO_IOSTREAMS)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(istmit1);
+#if !defined (STLPORT) || defined (_STLP_NO_EXTENSIONS)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(copy_n_test);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void istmit1();
+ void copy_n_test();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(IStreamIteratorTest);
+
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# if !defined (STLPORT) || !defined (_STLP_LIMITED_DEFAULT_TEMPLATES)
+typedef istream_iterator<char> istream_char_ite;
+typedef istream_iterator<int> istream_int_ite;
+typedef istream_iterator<string> istream_string_ite;
+# else
+typedef istream_iterator<char, ptrdiff_t> istream_char_ite;
+typedef istream_iterator<int, ptrdiff_t> istream_int_ite;
+typedef istream_iterator<string, ptrdiff_t> istream_string_ite;
+# endif
+#endif
+
+//
+// tests implementation
+//
+void IStreamIteratorTest::istmit1()
+{
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+ const char* buff = "MyString";
+ istringstream istr(buff);
+
+ char buffer[100];
+ size_t i = 0;
+ istr.unsetf(ios::skipws); // Disable white-space skipping.
+ istream_char_ite s(istr), meos;
+ while (!(s == meos) &&
+ //*TY 01/10/1999 - added end of stream check
+ // NOTE operator!= should not be used here ifndef _STLP_FUNCTION_TMPL_PARTIAL_ORDER
+ (*s != '\n') &&
+ (i < sizeof(buffer) / sizeof(buffer[0]))) { //*TY 07/28/98 - added index check
+ buffer[i++] = *s++;
+ }
+ buffer[i] = '\0'; // Null terminate buffer.
+
+ CPPUNIT_ASSERT(!strcmp(buffer, buff));
+
+ {
+ istringstream empty_istr;
+ CPPUNIT_ASSERT( istream_char_ite(empty_istr) == istream_char_ite() );
+ }
+#endif
+}
+
+void IStreamIteratorTest::copy_n_test()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS) && !defined (_STLP_USE_NO_IOSTREAMS)
+ //This test check that no character is lost while reading the istream
+ //through a istream_iterator.
+ {
+ istringstream istr("aabbcd");
+ string chars;
+ istream_char_ite ite = copy_n(copy_n(istream_char_ite(istr),
+ 2, back_inserter(chars)).first,
+ 2, back_inserter(chars)).first;
+ CPPUNIT_ASSERT( chars == "aabb" );
+ copy_n(ite, 2, back_inserter(chars));
+ CPPUNIT_ASSERT( chars == "aabbcd" );
+ }
+
+ {
+ istringstream istr("11 22 AA BB 33 44 CC DD");
+ vector<int> ints;
+ vector<string> strings;
+
+ copy_n(istream_int_ite(istr), 2, back_inserter(ints));
+ CPPUNIT_ASSERT( ints.size() == 2 );
+ CPPUNIT_ASSERT( ints[0] == 11 );
+ CPPUNIT_ASSERT( ints[1] == 22 );
+ ints.clear();
+ istr.clear();
+ copy_n(istream_string_ite(istr), 2, back_inserter(strings));
+ CPPUNIT_ASSERT( strings.size() == 2 );
+ CPPUNIT_ASSERT( strings[0] == "AA" );
+ CPPUNIT_ASSERT( strings[1] == "BB" );
+ strings.clear();
+ istr.clear();
+ /* The following code cannot work, '33' is extracted as a string
+ * in the previous copy_n call, this value is returned in the pair
+ * returned by copy_n but is lost as this istream_iterator is not used.
+ * copy_n and istream_iterator can only be combined safely if:
+ * - you always extract the same type of istream_iterator and you always reuse
+ * the istream_iterator returned by copy_n (see previous test with "aabbcd")
+ * - you extract different type of object and no object is convertible to an other
+ * as in this current test when you extract int and string (when you extract ints
+ * again it fails as int can be converted to strings.
+ *
+ copy_n(istream_int_ite(istr), 2, back_inserter(ints));
+ CPPUNIT_ASSERT( ints.size() == 2 );
+ CPPUNIT_ASSERT( ints[0] == 33 );
+ CPPUNIT_ASSERT( ints[1] == 44 );
+ istr.clear();
+ copy_n(istream_string_ite(istr), 2, back_inserter(strings));
+ CPPUNIT_ASSERT( strings.size() == 2 );
+ CPPUNIT_ASSERT( strings[0] == "CC" );
+ CPPUNIT_ASSERT( strings[1] == "DD" );
+ */
+ }
+
+ {
+ istringstream is("1 2 3 4 5 6 7 8 9 10");
+ vector<int> ints;
+ istream_iterator<int> itr(is);
+ itr = copy_n(itr, 0, back_inserter(ints)).first;
+ CPPUNIT_ASSERT( ints.empty() );
+ itr = copy_n(itr, -1, back_inserter(ints)).first;
+ CPPUNIT_ASSERT( ints.empty() );
+ itr = copy_n(itr, 2, back_inserter(ints)).first;
+ CPPUNIT_ASSERT( ints.size() == 2 );
+ CPPUNIT_ASSERT( ints[0] == 1 );
+ CPPUNIT_ASSERT( ints[1] == 2 );
+ itr = copy_n(itr, 2, back_inserter(ints)).first;
+ CPPUNIT_ASSERT( ints.size() == 4 );
+ CPPUNIT_ASSERT( ints[2] == 3 );
+ CPPUNIT_ASSERT( ints[3] == 4 );
+ itr = copy_n(itr, 2, back_inserter(ints)).first;
+ CPPUNIT_ASSERT( ints.size() == 6 );
+ CPPUNIT_ASSERT( ints[4] == 5 );
+ CPPUNIT_ASSERT( ints[5] == 6 );
+ }
+#endif
+}
diff --git a/sources/android/stlport/test/unit/istream_header_test.cpp b/sources/android/stlport/test/unit/istream_header_test.cpp
new file mode 100644
index 0000000..7c83854
--- /dev/null
+++ b/sources/android/stlport/test/unit/istream_header_test.cpp
@@ -0,0 +1,10 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#if !defined (_STLP_NO_IOSTREAMS)
+# include <istream>
+#endif
diff --git a/sources/android/stlport/test/unit/iter_test.cpp b/sources/android/stlport/test/unit/iter_test.cpp
new file mode 100644
index 0000000..52e4348
--- /dev/null
+++ b/sources/android/stlport/test/unit/iter_test.cpp
@@ -0,0 +1,169 @@
+#include <vector>
+#include <list>
+#include <algorithm>
+#include <numeric>
+
+#include "iota.h"
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class IterTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(IterTest);
+ CPPUNIT_TEST(iter1);
+ CPPUNIT_TEST(iter3);
+ CPPUNIT_TEST(iter4);
+ CPPUNIT_TEST(iterswp0);
+ CPPUNIT_TEST(iterswp1);
+ CPPUNIT_TEST(iterswp2);
+ CPPUNIT_TEST(iterswp3);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void iter1();
+ void iter3();
+ void iter4();
+ void iterswp0();
+ void iterswp1();
+ void iterswp2();
+ void iterswp3();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(IterTest);
+
+//
+// tests implementation
+//
+void IterTest::iter1()
+{
+ vector<const char*> v; // Vector of character strings.
+ v.push_back("zippy"); // First element.
+ v.push_back("motorboy"); // Second element.
+ typedef vector<const char*> vec;
+ unsigned counter = 0;
+ for (vec::iterator i = v.begin(); i != v.end(); ++i, ++counter) {
+ switch (counter) {
+ case 0:
+ CPPUNIT_ASSERT(!strcmp(*i, "zippy"));
+ break;
+ case 1:
+ CPPUNIT_ASSERT(!strcmp(*i, "motorboy"));
+ break;
+ default:
+ CPPUNIT_FAIL;
+ }
+ }
+}
+void IterTest::iter3()
+{
+ typedef vector<const char*> Vec;
+ Vec v; // Vector of character strings.
+ v.push_back("zippy"); // First element.
+ v.push_back("motorboy"); // Second element.
+ Vec::reverse_iterator it;
+ unsigned counter = 0;
+ for (it = v.rbegin(); it != v.rend(); ++it, ++counter) {
+ switch (counter) {
+ case 1:
+ CPPUNIT_ASSERT(!strcmp(*it, "zippy"));
+ break;
+ case 0:
+ CPPUNIT_ASSERT(!strcmp(*it, "motorboy"));
+ break;
+ default:
+ CPPUNIT_FAIL;
+ }
+ }
+}
+void IterTest::iter4()
+{
+ vector<int> v; // Empty vector of integers.
+ v.push_back(1);
+ v.push_back(2);
+ v.push_back(3);
+ // Position immediately after last item.
+ vector<int>::iterator i = v.end();
+ // Move back one and then access.
+ CPPUNIT_ASSERT((*--i)==3);
+ i -= 2; // Jump back two items.
+ CPPUNIT_ASSERT((*i)==1);
+}
+void IterTest::iterswp0()
+{
+ int numbers[6] = { 0, 1, 2, 3, 4, 5 };
+
+ iter_swap(numbers, numbers + 3);
+
+ CPPUNIT_ASSERT(numbers[0]==3);
+ CPPUNIT_ASSERT(numbers[1]==1);
+ CPPUNIT_ASSERT(numbers[2]==2);
+ CPPUNIT_ASSERT(numbers[3]==0);
+ CPPUNIT_ASSERT(numbers[4]==4);
+ CPPUNIT_ASSERT(numbers[5]==5);
+
+}
+void IterTest::iterswp1()
+{
+ vector<int> v1(6);
+ __iota(v1.begin(), v1.end(), 0);
+ iter_swap( v1.begin(), v1.begin() + 3 );
+
+ CPPUNIT_ASSERT(v1[0]==3);
+ CPPUNIT_ASSERT(v1[1]==1);
+ CPPUNIT_ASSERT(v1[2]==2);
+ CPPUNIT_ASSERT(v1[3]==0);
+ CPPUNIT_ASSERT(v1[4]==4);
+ CPPUNIT_ASSERT(v1[5]==5);
+}
+void IterTest::iterswp2()
+{
+ vector<bool> boolVector;
+
+ boolVector.push_back( true );
+ boolVector.push_back( false );
+
+ vector<bool>::iterator i1 = boolVector.begin();
+ vector<bool>::iterator i2 = boolVector.begin();
+ ++i2;
+
+ bool v0 = *i1;
+ bool v1 = *i2;
+
+ iter_swap( i1, i2 );
+
+ CPPUNIT_ASSERT(( *i1 == v1 && *i2 == v0 ));
+}
+
+
+void IterTest::iterswp3()
+{
+ vector<int> vvref(10, 10);
+ vector<int> lvref(10, 20);
+
+ vector<vector<int> > vvints(4, vvref);
+ list<vector<int> > lvints(4, lvref);
+
+ iter_swap(vvints.begin(), lvints.begin());
+ CPPUNIT_CHECK( vvints.front() == lvref );
+ CPPUNIT_CHECK( lvints.front() == vvref );
+
+ //const vector<vector<int> > &cvvints = vvints;
+ //iter_swap(cvvints.begin(), lvints.begin());
+ //iter_swap(lvints.begin(), cvvints.begin());
+
+#if defined (STLPORT) && defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ int *pvvint = &vvints.front().front();
+ int *plvint = &lvints.front().front();
+
+ iter_swap(vvints.begin(), lvints.begin());
+ //Check that elements have been swaped:
+ CPPUNIT_CHECK( pvvint == &lvints.front().front() );
+ CPPUNIT_CHECK( plvint == &vvints.front().front() );
+#endif
+}
diff --git a/sources/android/stlport/test/unit/iterator_header_test.cpp b/sources/android/stlport/test/unit/iterator_header_test.cpp
new file mode 100644
index 0000000..cb7ed29
--- /dev/null
+++ b/sources/android/stlport/test/unit/iterator_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <iterator>
diff --git a/sources/android/stlport/test/unit/less_test.cpp b/sources/android/stlport/test/unit/less_test.cpp
new file mode 100644
index 0000000..a87eae8
--- /dev/null
+++ b/sources/android/stlport/test/unit/less_test.cpp
@@ -0,0 +1,50 @@
+#include <vector>
+#include <algorithm>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class LessTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(LessTest);
+ CPPUNIT_TEST(lesst);
+ CPPUNIT_TEST(lesseqt);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void lesst();
+ void lesseqt();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(LessTest);
+
+//
+// tests implementation
+//
+void LessTest::lesst()
+{
+ int array [4] = { 3, 1, 4, 2 };
+ sort(array, array + 4, less<int>());
+
+ CPPUNIT_ASSERT(array[0]==1);
+ CPPUNIT_ASSERT(array[1]==2);
+ CPPUNIT_ASSERT(array[2]==3);
+ CPPUNIT_ASSERT(array[3]==4);
+}
+void LessTest::lesseqt()
+{
+ int array [4] = { 3, 1, 4, 2 };
+ sort(array, array + 4, less_equal<int>());
+
+ CPPUNIT_ASSERT(array[0]==1);
+ CPPUNIT_ASSERT(array[1]==2);
+ CPPUNIT_ASSERT(array[2]==3);
+ CPPUNIT_ASSERT(array[3]==4);
+}
diff --git a/sources/android/stlport/test/unit/lexcmp_test.cpp b/sources/android/stlport/test/unit/lexcmp_test.cpp
new file mode 100644
index 0000000..f913f41
--- /dev/null
+++ b/sources/android/stlport/test/unit/lexcmp_test.cpp
@@ -0,0 +1,48 @@
+#include <vector>
+#include <algorithm>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class LexcmpTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(LexcmpTest);
+ CPPUNIT_TEST(lexcmp1);
+ CPPUNIT_TEST(lexcmp2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void lexcmp1();
+ void lexcmp2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(LexcmpTest);
+
+//
+// tests implementation
+//
+void LexcmpTest::lexcmp1()
+{
+ const unsigned size = 6;
+ char n1[size] = "shoe";
+ char n2[size] = "shine";
+
+ bool before = lexicographical_compare(n1, n1 + size, n2, n2 + size);
+ CPPUNIT_ASSERT(!before);
+}
+void LexcmpTest::lexcmp2()
+{
+ const unsigned size = 6;
+ char n1[size] = "shoe";
+ char n2[size] = "shine";
+
+ bool before = lexicographical_compare(n1, n1 + size, n2, n2 + size, greater<char>());
+ CPPUNIT_ASSERT(before);
+}
diff --git a/sources/android/stlport/test/unit/limits_header_test.cpp b/sources/android/stlport/test/unit/limits_header_test.cpp
new file mode 100644
index 0000000..5954a04
--- /dev/null
+++ b/sources/android/stlport/test/unit/limits_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <limits>
diff --git a/sources/android/stlport/test/unit/limits_test.cpp b/sources/android/stlport/test/unit/limits_test.cpp
new file mode 100644
index 0000000..d8102ee
--- /dev/null
+++ b/sources/android/stlport/test/unit/limits_test.cpp
@@ -0,0 +1,317 @@
+/* boost limits_test.cpp test your <limits> file for important
+ *
+ * Copyright Jens Maurer 2000
+ * Permission to use, copy, modify, sell, and distribute this software
+ * is hereby granted without fee provided that the above copyright notice
+ * appears in all copies and that both that copyright notice and this
+ * permission notice appear in supporting documentation,
+ *
+ * Jens Maurer makes no representations about the suitability of this
+ * software for any purpose. It is provided "as is" without express or
+ * implied warranty.
+ *
+ */
+
+#include <limits>
+//#include <sstream>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class LimitTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(LimitTest);
+# if defined (__BORLANDC__)
+ /* Ignore FPU exceptions, set FPU precision to 64 bits */
+ unsigned int _float_control_word = _control87(0, 0);
+ _control87(PC_64|MCW_EM|IC_AFFINE, MCW_PC|MCW_EM|MCW_IC);
+# endif
+ CPPUNIT_TEST(test);
+ CPPUNIT_TEST(qnan_test);
+# if defined (__BORLANDC__)
+ /* Reset floating point control word */
+ _clear87();
+ _control87(_float_control_word, MCW_PC|MCW_EM|MCW_IC);
+# endif
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void test();
+ void qnan_test();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(LimitTest);
+
+#if defined (STLPORT) && defined (_STLP_STATIC_CONST_INIT_BUG)
+# define CHECK_COND(X) if (!(X)) { CPPUNIT_MESSAGE(#X); return false; }
+#else
+//This version force to have external linkage on static constant which might
+//reveal that _STLP_NO_STATIC_CONST_DEFINITION should be commented.
+bool check_cond(const bool& cond) { return cond; }
+# define CHECK_COND(X) if (!check_cond(X)) { CPPUNIT_MESSAGE(#X); return false; }
+#endif
+
+bool valid_sign_info(bool, bool)
+{ return true; }
+
+template <class _Tp>
+bool valid_sign_info(bool limit_is_signed, const _Tp &) {
+ return (limit_is_signed && _Tp(-1) < 0) ||
+ (!limit_is_signed && _Tp(-1) > 0);
+}
+
+template <class _Tp>
+bool test_integral_limits_base(const _Tp &, bool unknown_sign = true, bool is_signed = true) {
+ typedef numeric_limits<_Tp> lim;
+
+ CHECK_COND(lim::is_specialized);
+ CHECK_COND(lim::is_exact);
+ CHECK_COND(lim::is_integer);
+ CHECK_COND(!lim::is_iec559);
+ CHECK_COND(lim::min() < lim::max());
+ CHECK_COND((unknown_sign && ((lim::is_signed && (lim::min() != 0)) || (!lim::is_signed && (lim::min() == 0)))) ||
+ (!unknown_sign && ((lim::is_signed && is_signed) || (!lim::is_signed && !is_signed))));
+
+ if (unknown_sign) {
+ CHECK_COND(valid_sign_info(lim::is_signed, _Tp()));
+ }
+ return true;
+}
+
+template <class _Tp>
+bool test_integral_limits(const _Tp &val, bool unknown_sign = true, bool is_signed = true) {
+ if (!test_integral_limits_base(val, unknown_sign, is_signed))
+ return false;
+
+ typedef numeric_limits<_Tp> lim;
+
+ CHECK_COND(lim::is_modulo);
+
+ if (lim::is_bounded ||
+ (!lim::is_bounded && !lim::is_signed)) {
+ _Tp tmp = lim::min();
+ CHECK_COND( --tmp > lim::min() );
+ }
+
+ if (lim::is_bounded) {
+ _Tp tmp = lim::max();
+ CHECK_COND( ++tmp < lim::max() );
+ }
+
+ return true;
+}
+
+template <class _Tp>
+bool test_signed_integral_limits(const _Tp &__val) {
+ return test_integral_limits(__val, false, true);
+}
+template <class _Tp>
+bool test_unsigned_integral_limits(const _Tp &__val) {
+ return test_integral_limits(__val, false, false);
+}
+
+template <class _Tp>
+bool test_float_values(_Tp lhs, _Tp rhs)
+{ return lhs == rhs; }
+
+template <class _Tp>
+bool test_float_limits(const _Tp &) {
+ typedef numeric_limits<_Tp> lim;
+ CHECK_COND(lim::is_specialized);
+ CHECK_COND(!lim::is_modulo);
+ CHECK_COND(!lim::is_integer);
+ CHECK_COND(lim::is_signed);
+
+ CHECK_COND(lim::max() > 1000);
+ CHECK_COND(lim::min() > 0);
+ CHECK_COND(lim::min() < 0.001);
+ CHECK_COND(lim::epsilon() > 0);
+
+ if (lim::is_iec559) {
+ CHECK_COND(lim::has_infinity);
+ CHECK_COND(lim::has_quiet_NaN);
+ CHECK_COND(lim::has_signaling_NaN);
+ CHECK_COND(lim::has_denorm == denorm_present);
+ }
+
+ if (lim::has_denorm == denorm_absent) {
+ CHECK_COND(lim::denorm_min() == lim::min());
+ _Tp tmp = lim::min();
+ tmp /= 2;
+ if (tmp > 0 && tmp < lim::min()) {
+ // has_denorm could be denorm_present
+ CPPUNIT_MESSAGE("It looks like your compiler/platform supports denormalized floating point representation.");
+ }
+ }
+ else if (lim::has_denorm == denorm_present) {
+ CHECK_COND(lim::denorm_min() > 0);
+ CHECK_COND(lim::denorm_min() < lim::min());
+
+ _Tp tmp = lim::min();
+ while (tmp != 0) {
+ _Tp old_tmp = tmp;
+ tmp /= 2;
+ CHECK_COND(tmp < old_tmp);
+ CHECK_COND(tmp >= lim::denorm_min() || tmp == (_Tp)0);
+ //ostringstream str;
+ //str << "denorm_min = " << lim::denorm_min() << ", tmp = " << tmp;
+ //CPPUNIT_MESSAGE(str.str().c_str());
+ }
+ }
+
+ if (lim::has_infinity) {
+ const _Tp infinity = lim::infinity();
+ /* Make sure those values are not 0 or similar nonsense.
+ * Infinity must compare as if larger than the maximum representable value. */
+
+ _Tp val = lim::max();
+ val *= 2;
+
+ /* We use test_float_values because without it some compilers (gcc) perform weird
+ * optimization on the test giving unexpected result. */
+ CHECK_COND(test_float_values(val, infinity));
+
+ /*
+ ostringstream str;
+ str << "lim::max() = " << lim::max() << ", val = " << val << ", infinity = " << infinity;
+ CPPUNIT_MESSAGE( str.str().c_str() );
+ str.str(string());
+ str << "sizeof(_Tp) = " << sizeof(_Tp);
+ CPPUNIT_MESSAGE( str.str().c_str() );
+ if (sizeof(_Tp) == 4) {
+ str.str(string());
+ str << "val in hexa: " << showbase << hex << *((const unsigned int*)&val);
+ str << ", infinity in hexa: " << showbase << hex << *((const unsigned int*)&infinity);
+ }
+#if defined (_STLP_LONG_LONG)
+ else if (sizeof(_Tp) == sizeof(_STLP_LONG_LONG)) {
+ str.str(string());
+ str << "val in hexa: " << showbase << hex << *((const unsigned _STLP_LONG_LONG*)&val);
+ str << ", infinity in hexa: " << showbase << hex << *((const unsigned _STLP_LONG_LONG*)&infinity);
+ }
+#endif
+ else {
+ str.str(string());
+ str << "val: ";
+ for (int i = 0; i != sizeof(_Tp) / sizeof(unsigned short); ++i) {
+ if (i != 0) str << ' ';
+ str << showbase << hex << setw(4) << setfill('0') << *((const unsigned short*)&val + i);
+ }
+ str << ", infinity: ";
+ for (int i = 0; i != sizeof(_Tp) / sizeof(unsigned short); ++i) {
+ if (i != 0) str << ' ';
+ str << showbase << hex << setw(4) << setfill('0') << *((const unsigned short*)&infinity + i);
+ }
+ }
+ CPPUNIT_MESSAGE( str.str().c_str() );
+ str.str(string());
+ str << dec;
+ str << "lim::digits = " << lim::digits << ", lim::digits10 = " << lim::digits10 << endl;
+ str << "lim::min_exponent = " << lim::min_exponent << ", lim::min_exponent10 = " << lim::min_exponent10 << endl;
+ str << "lim::max_exponent = " << lim::max_exponent << ", lim::max_exponent10 = " << lim::max_exponent10 << endl;
+ CPPUNIT_MESSAGE( str.str().c_str() );
+ */
+
+ CHECK_COND(infinity == infinity);
+ CHECK_COND(infinity > lim::max());
+ CHECK_COND(-infinity < -lim::max());
+ }
+
+ return true;
+}
+
+//float generate_nan(float f) {
+// return 0.0f / f;
+//}
+template <class _Tp>
+bool test_qnan(const _Tp &) {
+ typedef numeric_limits<_Tp> lim;
+ if (lim::has_quiet_NaN) {
+ const _Tp qnan = lim::quiet_NaN();
+
+ //if (sizeof(_Tp) == 4) {
+ // ostringstream str;
+ // str << "qnan " << qnan << ", in hexa: " << showbase << hex << *((unsigned int*)&qnan);
+ // CPPUNIT_MESSAGE( str.str().c_str() );
+ // str.str("");
+ // float val = generate_nan(0.0f);
+ // str << "val " << val << ", in hexa: " << showbase << hex << *((unsigned int*)&val);
+ // CPPUNIT_MESSAGE( str.str().c_str() );
+ // str.str("");
+ // val = -qnan;
+ // str << "-qnan " << val << ", in hexa: " << showbase << hex << *((unsigned int*)&val);
+ // CPPUNIT_MESSAGE( str.str().c_str() );
+ //}
+ /* NaNs shall always compare "false" when compared for equality
+ * If one of these fail, your compiler may be optimizing incorrectly,
+ * or the STLport is incorrectly configured.
+ */
+ CHECK_COND(! (qnan == 42));
+ CHECK_COND(! (qnan == qnan));
+ CHECK_COND(qnan != 42);
+ CHECK_COND(qnan != qnan);
+
+ /* The following tests may cause arithmetic traps.
+ * CHECK_COND(! (qnan < 42));
+ * CHECK_COND(! (qnan > 42));
+ * CHECK_COND(! (qnan <= 42));
+ * CHECK_COND(! (qnan >= 42));
+ */
+ }
+ return true;
+}
+
+
+class ArbitraryType
+{};
+
+void LimitTest::test() {
+ CPPUNIT_CHECK(test_integral_limits_base(bool()));
+ CPPUNIT_CHECK(test_integral_limits(char()));
+ typedef signed char signed_char;
+ CPPUNIT_CHECK(test_signed_integral_limits(signed_char()));
+ typedef unsigned char unsigned_char;
+ CPPUNIT_CHECK(test_unsigned_integral_limits(unsigned_char()));
+# if defined (_STLP_HAS_WCHAR_T) && !defined (_STLP_WCHAR_T_IS_USHORT)
+ CPPUNIT_CHECK(test_integral_limits(wchar_t()));
+# endif
+ CPPUNIT_CHECK(test_signed_integral_limits(short()));
+ typedef unsigned short unsigned_short;
+ CPPUNIT_CHECK(test_unsigned_integral_limits(unsigned_short()));
+ CPPUNIT_CHECK(test_signed_integral_limits(int()));
+ typedef unsigned int unsigned_int;
+ CPPUNIT_CHECK(test_unsigned_integral_limits(unsigned_int()));
+ CPPUNIT_CHECK(test_signed_integral_limits(long()));
+ typedef unsigned long unsigned_long;
+ CPPUNIT_CHECK(test_unsigned_integral_limits(unsigned_long()));
+# if defined (_STLP_LONG_LONG)
+ typedef _STLP_LONG_LONG long_long;
+ CPPUNIT_CHECK(test_signed_integral_limits(long_long()));
+ typedef unsigned _STLP_LONG_LONG unsigned_long_long;
+ CPPUNIT_CHECK(test_unsigned_integral_limits(unsigned_long_long()));
+#endif
+
+ CPPUNIT_CHECK(test_float_limits(float()));
+ CPPUNIT_CHECK(test_float_limits(double()));
+# if !defined ( _STLP_NO_LONG_DOUBLE )
+ typedef long double long_double;
+ CPPUNIT_CHECK(test_float_limits(long_double()));
+# endif
+
+ CPPUNIT_ASSERT( !numeric_limits<ArbitraryType>::is_specialized );
+}
+
+void LimitTest::qnan_test() {
+ CPPUNIT_CHECK(test_qnan(float()));
+ CPPUNIT_CHECK(test_qnan(double()));
+# if !defined ( _STLP_NO_LONG_DOUBLE )
+ typedef long double long_double;
+ CPPUNIT_CHECK(test_qnan(long_double()));
+# endif
+}
diff --git a/sources/android/stlport/test/unit/list_header_test.cpp b/sources/android/stlport/test/unit/list_header_test.cpp
new file mode 100644
index 0000000..36cb6c4
--- /dev/null
+++ b/sources/android/stlport/test/unit/list_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <list>
diff --git a/sources/android/stlport/test/unit/list_test.cpp b/sources/android/stlport/test/unit/list_test.cpp
new file mode 100644
index 0000000..7345d40
--- /dev/null
+++ b/sources/android/stlport/test/unit/list_test.cpp
@@ -0,0 +1,468 @@
+//Has to be first for StackAllocator swap overload to be taken
+//into account (at least using GCC 4.0.1)
+#include "stack_allocator.h"
+
+#include <list>
+#include <algorithm>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class ListTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(ListTest);
+ CPPUNIT_TEST(list1);
+ CPPUNIT_TEST(list2);
+ CPPUNIT_TEST(list3);
+ CPPUNIT_TEST(list4);
+ CPPUNIT_TEST(erase);
+ CPPUNIT_TEST(resize);
+ CPPUNIT_TEST(push_back);
+ CPPUNIT_TEST(push_front);
+ CPPUNIT_TEST(allocator_with_state);
+ CPPUNIT_TEST(swap);
+ CPPUNIT_TEST(adl);
+ //CPPUNIT_TEST(const_list);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void list1();
+ void list2();
+ void list3();
+ void list4();
+ void erase();
+ void resize();
+ void push_back();
+ void push_front();
+ void allocator_with_state();
+ void swap();
+ void adl();
+ //void const_list();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(ListTest);
+
+//
+// tests implementation
+//
+void ListTest::list1()
+{
+ int array1 [] = { 9, 16, 36 };
+ int array2 [] = { 1, 4 };
+
+ list<int> l1(array1, array1 + 3);
+ list<int> l2(array2, array2 + 2);
+ list<int>::iterator i1 = l1.begin();
+ list<int>::iterator i2 = l2.begin();
+ list<int>::const_iterator ci(i1);
+ list<int>::const_iterator ci1(ci);
+ l1.splice(i1, l2);
+ i1 = l1.begin();
+ CPPUNIT_ASSERT( *i1++ == 1 );
+ CPPUNIT_ASSERT( *i1++ == 4 );
+ CPPUNIT_ASSERT( *i1++ == 9 );
+ CPPUNIT_ASSERT( *i1++ == 16 );
+ CPPUNIT_ASSERT( *i1++ == 36 );
+
+#if defined (STLPORT) && \
+ (!defined (_STLP_DEBUG) || (_STLP_DEBUG_LEVEL != _STLP_STANDARD_DBG_LEVEL))
+ CPPUNIT_ASSERT( i2 == l1.begin() );
+#endif
+
+ //Default construct check (_STLP_DEF_CONST_PLCT_NEW_BUG)
+ list<int> l(2);
+ i1 = l.begin();
+ CPPUNIT_ASSERT( *(i1++) == 0 );
+ CPPUNIT_ASSERT( *i1 == 0 );
+#if 0
+ //A small compilation time check to be activated from time to time,
+ //compilation should fail.
+ {
+ list<char>::iterator l_char_ite;
+ list<int>::iterator l_int_ite;
+ CPPUNIT_ASSERT( l_char_ite != l_int_ite );
+ }
+#endif
+}
+
+void ListTest::list2()
+{
+ int array1 [] = { 1, 16 };
+ int array2 [] = { 4, 9 };
+
+ list<int> l1(array1, array1 + 2);
+ list<int> l2(array2, array2 + 2);
+ list<int>::iterator i = l1.begin();
+ i++;
+ l1.splice(i, l2, l2.begin(), l2.end());
+ i = l1.begin();
+ CPPUNIT_ASSERT(*i++==1);
+ CPPUNIT_ASSERT(*i++==4);
+ CPPUNIT_ASSERT(*i++==9);
+ CPPUNIT_ASSERT(*i++==16);
+}
+
+void ListTest::list3()
+{
+ char array [] = { 'x', 'l', 'x', 't', 's', 's' };
+
+ list<char> str(array, array + 6);
+ list<char>::iterator i;
+
+ str.reverse();
+ i = str.begin();
+ CPPUNIT_ASSERT(*i++=='s');
+ CPPUNIT_ASSERT(*i++=='s');
+ CPPUNIT_ASSERT(*i++=='t');
+ CPPUNIT_ASSERT(*i++=='x');
+ CPPUNIT_ASSERT(*i++=='l');
+ CPPUNIT_ASSERT(*i++=='x');
+
+ str.remove('x');
+ i = str.begin();
+ CPPUNIT_ASSERT(*i++=='s');
+ CPPUNIT_ASSERT(*i++=='s');
+ CPPUNIT_ASSERT(*i++=='t');
+ CPPUNIT_ASSERT(*i++=='l');
+
+ str.unique();
+ i = str.begin();
+ CPPUNIT_ASSERT(*i++=='s');
+ CPPUNIT_ASSERT(*i++=='t');
+ CPPUNIT_ASSERT(*i++=='l');
+
+ str.sort();
+ i = str.begin();
+ CPPUNIT_ASSERT(*i++=='l');
+ CPPUNIT_ASSERT(*i++=='s');
+ CPPUNIT_ASSERT(*i++=='t');
+}
+
+void ListTest::list4()
+{
+ int array1 [] = { 1, 3, 6, 7 };
+ int array2 [] = { 2, 4 };
+
+ list<int> l1(array1, array1 + 4);
+ list<int> l2(array2, array2 + 2);
+ l1.merge(l2);
+ list<int>::iterator i = l1.begin();
+ CPPUNIT_ASSERT(*i++==1);
+ CPPUNIT_ASSERT(*i++==2);
+ CPPUNIT_ASSERT(*i++==3);
+ CPPUNIT_ASSERT(*i++==4);
+ CPPUNIT_ASSERT(*i++==6);
+ CPPUNIT_ASSERT(*i++==7);
+
+ //We use distance to avoid a simple call to an internal counter
+ CPPUNIT_ASSERT(distance(l1.begin(), l1.end()) == 6);
+ CPPUNIT_ASSERT(distance(l2.begin(), l2.end()) == 0);
+
+ l1.swap(l2);
+
+ CPPUNIT_ASSERT(distance(l1.begin(), l1.end()) == 0);
+ CPPUNIT_ASSERT(distance(l2.begin(), l2.end()) == 6);
+}
+
+void ListTest::erase()
+{
+ list<int> l;
+ l.push_back( 1 );
+ l.erase(l.begin());
+ CPPUNIT_ASSERT( l.empty() );
+
+ int array[] = { 0, 1, 2, 3 };
+ l.assign(array, array + 4);
+ list<int>::iterator lit;
+ lit = l.erase(l.begin());
+ CPPUNIT_ASSERT( *lit == 1 );
+
+ lit = l.erase(l.begin(), --l.end());
+ CPPUNIT_ASSERT( *lit == 3 );
+
+ l.clear();
+ CPPUNIT_ASSERT( l.empty() );
+}
+
+
+void ListTest::resize()
+{
+ {
+ list<int> l;
+ l.resize(5, 1);
+
+ size_t i;
+ list<int>::iterator lit(l.begin());
+ for (i = 0; i < 5; ++i) {
+ CPPUNIT_ASSERT( lit != l.end() );
+ CPPUNIT_ASSERT( *(lit++) == 1 );
+ }
+ CPPUNIT_ASSERT( lit == l.end() );
+
+ l.resize(3);
+ lit = l.begin();
+ for (i = 0; i < 3; ++i) {
+ CPPUNIT_ASSERT( lit != l.end() );
+ CPPUNIT_ASSERT( *(lit++) == 1 );
+ }
+ CPPUNIT_ASSERT( lit == l.end() );
+ }
+
+ {
+ list<int> l;
+ l.resize(5);
+
+ size_t i;
+ list<int>::iterator lit(l.begin());
+ for (i = 0; i < 5; ++i) {
+ CPPUNIT_ASSERT( lit != l.end() );
+ CPPUNIT_ASSERT( *(lit++) == 0 );
+ }
+ CPPUNIT_ASSERT( lit == l.end() );
+ }
+}
+
+void ListTest::push_back()
+{
+ list<int> l;
+ l.push_back( 1 );
+ l.push_back( 2 );
+ l.push_back( 3 );
+
+ list<int>::reverse_iterator r = l.rbegin();
+
+ CPPUNIT_ASSERT( *r == 3 );
+ l.push_back( 4 );
+ /*
+ * Following lines are commented, because ones show standard contradiction
+ * (24.4.1 and 23.2.2.3); but present behaviour is valid, 24.4.1, paragraphs 1 and 2,
+ * 24.4.1.3.3 and 23.1 paragraph 9 (Table 66). The 24.4.1 is more common rule,
+ * so it has preference under 23.2.2.3, by my opinion.
+ *
+ * - ptr
+ */
+ // CPPUNIT_ASSERT( *r == 3 );
+ // ++r;
+ // CPPUNIT_ASSERT( *r == 2 );
+}
+
+void ListTest::push_front()
+{
+ list<int> l;
+ l.push_back( 1 );
+ l.push_back( 2 );
+ l.push_back( 3 );
+
+ list<int>::iterator i = l.begin();
+
+ CPPUNIT_ASSERT( *i == 1 );
+ l.push_front( 0 );
+ CPPUNIT_ASSERT( *i == 1 );
+ ++i;
+ CPPUNIT_ASSERT( *i == 2 );
+}
+
+void ListTest::allocator_with_state()
+{
+ char buf1[1024];
+ StackAllocator<int> stack1(buf1, buf1 + sizeof(buf1));
+
+ char buf2[1024];
+ StackAllocator<int> stack2(buf2, buf2 + sizeof(buf2));
+
+ typedef list<int, StackAllocator<int> > ListInt;
+ {
+ //Swap with both list non empty
+ ListInt lint1(10, 0, stack1);
+ ListInt lint1Cpy(lint1);
+
+ ListInt lint2(10, 1, stack2);
+ ListInt lint2Cpy(lint2);
+
+ lint1.swap(lint2);
+
+ CPPUNIT_ASSERT( lint1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( lint2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( lint1 == lint2Cpy );
+ CPPUNIT_ASSERT( lint2 == lint1Cpy );
+ CPPUNIT_ASSERT( lint1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( lint2.get_allocator() == stack1 );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ {
+ //Swap with empty calle list
+ ListInt lint1(10, 0, stack1);
+ ListInt lint1Cpy(lint1);
+
+ ListInt lint2(stack2);
+ ListInt lint2Cpy(lint2);
+
+ lint1.swap(lint2);
+
+ CPPUNIT_ASSERT( lint1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( lint2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( lint1 == lint2Cpy );
+ CPPUNIT_ASSERT( lint2 == lint1Cpy );
+ CPPUNIT_ASSERT( lint1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( lint2.get_allocator() == stack1 );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ {
+ //Swap with empty caller list
+ ListInt lint1(stack1);
+ ListInt lint1Cpy(lint1);
+
+ ListInt lint2(10, 0, stack2);
+ ListInt lint2Cpy(lint2);
+
+ lint1.swap(lint2);
+
+ CPPUNIT_ASSERT( lint1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( lint2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( lint1 == lint2Cpy );
+ CPPUNIT_ASSERT( lint2 == lint1Cpy );
+ CPPUNIT_ASSERT( lint1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( lint2.get_allocator() == stack1 );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ {
+ ListInt lint1(10, 0, stack1);
+ ListInt lint2(10, 1, stack2);
+
+ lint1.splice(lint1.begin(), lint2);
+ CPPUNIT_ASSERT( lint1.size() == 20 );
+ CPPUNIT_ASSERT( lint2.empty() );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ {
+ ListInt lint1(10, 0, stack1);
+ ListInt lint2(10, 1, stack2);
+
+ lint1.splice(lint1.begin(), lint2, lint2.begin());
+ CPPUNIT_ASSERT( lint1.size() == 11 );
+ CPPUNIT_ASSERT( lint2.size() == 9 );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ {
+ ListInt lint1(10, 0, stack1);
+ ListInt lint2(10, 1, stack2);
+
+ ListInt::iterator lit(lint2.begin());
+ advance(lit, 5);
+ lint1.splice(lint1.begin(), lint2, lint2.begin(), lit);
+ CPPUNIT_ASSERT( lint1.size() == 15 );
+ CPPUNIT_ASSERT( lint2.size() == 5 );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ {
+ ListInt lint1(10, 0, stack1);
+ ListInt lint2(10, 1, stack2);
+
+ ListInt lintref(stack2);
+ lintref.insert(lintref.begin(), 10, 1);
+ lintref.insert(lintref.begin(), 10, 0);
+
+ lint1.merge(lint2);
+ CPPUNIT_ASSERT( lint1.size() == 20 );
+ CPPUNIT_ASSERT( lint1 == lintref );
+ CPPUNIT_ASSERT( lint2.empty() );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+
+#if defined (STLPORT) && !defined (_STLP_NO_MEMBER_TEMPLATES) && \
+ (!defined (_MSC_VER) || (_MSC_VER >= 1300))
+ {
+ //This is a compile time test.
+ //We check that sort implementation is correct when list is instanciated
+ //with an allocator that do not have a default constructor.
+ ListInt lint1(10, 0, stack1);
+ lint1.sort();
+ lint1.sort(greater<int>());
+ }
+#endif
+}
+
+/*
+void ListTest::const_list()
+{
+ list<const int> cint_list;
+ cint_list.push_back(1);
+ cint_list.push_front(2);
+}
+*/
+void ListTest::swap()
+{
+ list<int> lst1;
+ list<int> lst2;
+
+ lst1.push_back(1);
+ lst2.push_back(2);
+
+ lst1.swap( lst2 );
+
+ CPPUNIT_CHECK( lst1.front() == 2 );
+ CPPUNIT_CHECK( lst2.front() == 1 );
+ CPPUNIT_CHECK( lst1.size() == 1 );
+ CPPUNIT_CHECK( lst2.size() == 1 );
+
+ lst1.pop_front();
+ lst2.pop_front();
+
+ CPPUNIT_CHECK( lst1.empty() );
+ CPPUNIT_CHECK( lst2.empty() );
+}
+
+namespace foo {
+ class bar {};
+
+ template <class _It>
+ size_t distance(_It, _It);
+}
+
+void ListTest::adl()
+{
+ list<foo::bar> lbar;
+ CPPUNIT_ASSERT( lbar.size() == 0);
+}
+
+#if !defined (STLPORT) || \
+ !defined (_STLP_USE_PTR_SPECIALIZATIONS) || defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+/* Simple compilation test: Check that nested types like iterator
+ * can be access even if type used to instanciate container is not
+ * yet completely defined.
+ */
+class IncompleteClass
+{
+ list<IncompleteClass> instances;
+ typedef list<IncompleteClass>::iterator it;
+};
+#endif
diff --git a/sources/android/stlport/test/unit/locale_header_test.cpp b/sources/android/stlport/test/unit/locale_header_test.cpp
new file mode 100644
index 0000000..bb2dec1
--- /dev/null
+++ b/sources/android/stlport/test/unit/locale_header_test.cpp
@@ -0,0 +1,10 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#if !defined (_STLP_NO_IOSTREAMS)
+# include <locale>
+#endif
diff --git a/sources/android/stlport/test/unit/locale_test.cpp b/sources/android/stlport/test/unit/locale_test.cpp
new file mode 100644
index 0000000..71d3da9
--- /dev/null
+++ b/sources/android/stlport/test/unit/locale_test.cpp
@@ -0,0 +1,337 @@
+#include "locale_test.h"
+
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# include <sstream>
+# include <locale>
+# include <stdexcept>
+
+# if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+# endif
+
+static const char* tested_locales[] = {
+//name,
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ "fr_FR",
+ "ru_RU.koi8r",
+ "en_GB",
+ "en_US",
+# endif
+ "",
+ "C"
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(LocaleTest);
+
+//
+// tests implementation
+//
+typedef void (LocaleTest::*_Test) (const locale&);
+static void test_supported_locale(LocaleTest &inst, _Test __test) {
+ size_t n = sizeof(tested_locales) / sizeof(tested_locales[0]);
+ for (size_t i = 0; i < n; ++i) {
+ locale loc;
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ try {
+# endif
+ locale tmp(tested_locales[i]);
+ loc = tmp;
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ }
+ catch (runtime_error const&) {
+ //This locale is not supported.
+ continue;
+ }
+# endif
+ CPPUNIT_MESSAGE( loc.name().c_str() );
+ (inst.*__test)(loc);
+ }
+}
+
+void LocaleTest::locale_by_name() {
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ /*
+ * Check of the 22.1.1.2.7 standard point. Construction of a locale
+ * instance from a null pointer or an unknown name should result in
+ * a runtime_error exception.
+ */
+ try {
+ locale loc(static_cast<char const*>(0));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ locale loc("yasli_language");
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ string very_large_locale_name(1024, '?');
+ locale loc(very_large_locale_name.c_str());
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+#if defined (STLPORT) || !defined (_MSC_VER) || (_MSC_VER > 1400)
+ try {
+ string very_large_locale_name("LC_CTYPE=");
+ very_large_locale_name.append(1024, '?');
+ locale loc(very_large_locale_name.c_str());
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ string very_large_locale_name("LC_ALL=");
+ very_large_locale_name.append(1024, '?');
+ locale loc(very_large_locale_name.c_str());
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+#endif
+
+ try {
+ locale loc("C");
+ }
+ catch (runtime_error const& /* e */) {
+ /* CPPUNIT_MESSAGE( e.what() ); */
+ CPPUNIT_FAIL;
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ // On platform without real localization support we should rely on the "C" locale facet.
+ locale loc("");
+ }
+ catch (runtime_error const& /* e */) {
+ /* CPPUNIT_MESSAGE( e.what() ); */
+ CPPUNIT_FAIL;
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+# endif
+}
+
+void LocaleTest::loc_has_facet() {
+ locale loc("C");
+ typedef numpunct<char> implemented_facet;
+ CPPUNIT_ASSERT( has_facet<implemented_facet>(loc) );
+ /*
+ typedef num_put<char, back_insert_iterator<string> > not_implemented_facet;
+ CPPUNIT_ASSERT( !has_facet<not_implemented_facet>(loc) );
+ */
+}
+
+void LocaleTest::locale_init_problem() {
+# if !defined (STLPORT) || !defined (_STLP_NO_MEMBER_TEMPLATES)
+ test_supported_locale(*this, &LocaleTest::_locale_init_problem);
+# endif
+}
+
+/*
+ * Creation of a locale instance imply initialization of some STLport internal
+ * static objects first. We use a static instance of locale to check that this
+ * initialization is done correctly.
+ */
+static locale global_loc;
+static locale other_loc("");
+
+# if !defined (STLPORT) || !defined (_STLP_NO_MEMBER_TEMPLATES)
+void LocaleTest::_locale_init_problem( const locale& loc)
+{
+# if !defined (__APPLE__) && !defined (__FreeBSD__) || \
+ !defined(__GNUC__) || ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__> 3)))
+ typedef codecvt<char,char,mbstate_t> my_facet;
+# else
+// std::mbstate_t required for gcc 3.3.2 on FreeBSD...
+// I am not sure what key here---FreeBSD or 3.3.2...
+// - ptr 2005-04-04
+ typedef codecvt<char,char,std::mbstate_t> my_facet;
+# endif
+
+ locale loc_ref(global_loc);
+ {
+ locale gloc( loc_ref, new my_facet() );
+ CPPUNIT_ASSERT( has_facet<my_facet>( gloc ) );
+ //The following code is just here to try to confuse the reference counting underlying mecanism:
+ locale::global( locale::classic() );
+ locale::global( gloc );
+ }
+
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ try {
+# endif
+ ostringstream os("test") ;
+ locale loc2( loc, new my_facet() );
+ CPPUNIT_ASSERT( has_facet<my_facet>( loc2 ) );
+ os.imbue( loc2 );
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ }
+ catch ( runtime_error& ) {
+ CPPUNIT_FAIL;
+ }
+ catch ( ... ) {
+ CPPUNIT_FAIL;
+ }
+# endif
+
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ try {
+# endif
+ ostringstream os2("test2");
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ }
+ catch ( runtime_error& ) {
+ CPPUNIT_FAIL;
+ }
+ catch ( ... ) {
+ CPPUNIT_FAIL;
+ }
+# endif
+}
+#endif
+
+void LocaleTest::default_locale()
+{
+ locale loc( "" );
+}
+
+class dummy_facet : public locale::facet {
+public:
+ static locale::id id;
+};
+
+locale::id dummy_facet::id;
+
+void LocaleTest::combine()
+{
+# if (!defined (STLPORT) || \
+ (defined (_STLP_USE_EXCEPTIONS) && !defined (_STLP_NO_MEMBER_TEMPLATES) && !defined (_STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS)))
+ {
+ try {
+ locale loc("");
+ if (!has_facet<messages<char> >(loc)) {
+ loc.combine<messages<char> >(loc);
+ CPPUNIT_FAIL;
+ }
+ }
+ catch (const runtime_error & /* e */) {
+ /* CPPUNIT_MESSAGE( e.what() ); */
+ }
+
+ try {
+ locale loc;
+ if (!has_facet<dummy_facet>(loc)) {
+ loc.combine<dummy_facet>(loc);
+ CPPUNIT_FAIL;
+ }
+ }
+ catch (const runtime_error & /* e */) {
+ /* CPPUNIT_MESSAGE( e.what() ); */
+ }
+ }
+
+ locale loc1(locale::classic()), loc2;
+ size_t loc1_index = 0;
+ for (size_t i = 0; _get_ref_monetary(i) != 0; ++i) {
+ try {
+ {
+ locale loc(_get_ref_monetary_name(_get_ref_monetary(i)));
+ if (loc1 == locale::classic())
+ {
+ loc1 = loc;
+ loc1_index = i;
+ continue;
+ }
+ else
+ {
+ loc2 = loc;
+ }
+ }
+
+ //We can start the test
+ ostringstream ostr;
+ ostr << "combining '" << loc2.name() << "' money facets with '" << loc1.name() << "'";
+ CPPUNIT_MESSAGE( ostr.str().c_str() );
+
+ //We are going to combine money facets as all formats are different.
+ {
+ //We check that resulting locale has correctly acquire loc2 facets.
+ locale loc = loc1.combine<moneypunct<char, true> >(loc2);
+ loc = loc.combine<moneypunct<char, false> >(loc2);
+ loc = loc.combine<money_put<char> >(loc2);
+ loc = loc.combine<money_get<char> >(loc2);
+
+ //Check loc has the correct facets:
+ _money_put_get2(loc2, loc, _get_ref_monetary(i));
+
+ //Check loc1 has not been impacted:
+ _money_put_get2(loc1, loc1, _get_ref_monetary(loc1_index));
+
+ //Check loc2 has not been impacted:
+ _money_put_get2(loc2, loc2, _get_ref_monetary(i));
+ }
+ {
+ //We check that resulting locale has not wrongly acquire loc1 facets that hasn't been combine:
+ locale loc = loc2.combine<numpunct<char> >(loc1);
+ loc = loc.combine<time_put<char> >(loc1);
+ loc = loc.combine<time_get<char> >(loc1);
+
+ //Check loc has the correct facets:
+ _money_put_get2(loc2, loc, _get_ref_monetary(i));
+
+ //Check loc1 has not been impacted:
+ _money_put_get2(loc1, loc1, _get_ref_monetary(loc1_index));
+
+ //Check loc2 has not been impacted:
+ _money_put_get2(loc2, loc2, _get_ref_monetary(i));
+ }
+
+ {
+ // Check auto combination do not result in weird reference counting behavior
+ // (might generate a crash).
+ loc1.combine<numpunct<char> >(loc1);
+ }
+
+ loc1 = loc2;
+ loc1_index = i;
+ }
+ catch (runtime_error const&) {
+ //This locale is not supported.
+ continue;
+ }
+ }
+# endif
+}
+
+#endif
diff --git a/sources/android/stlport/test/unit/locale_test.h b/sources/android/stlport/test/unit/locale_test.h
new file mode 100644
index 0000000..ab97ac4
--- /dev/null
+++ b/sources/android/stlport/test/unit/locale_test.h
@@ -0,0 +1,94 @@
+#include <string>
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# include <iosfwd>
+
+# include "cppunit/cppunit_proxy.h"
+# include <locale>
+
+struct ref_monetary;
+struct ref_locale;
+
+# if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+# define STD std::
+# else
+# define STD
+# endif
+
+//
+// TestCase class
+//
+class LocaleTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(LocaleTest);
+# if defined (STLPORT) && !defined (_STLP_USE_EXCEPTIONS)
+ CPPUNIT_IGNORE;
+# endif
+ CPPUNIT_TEST(locale_by_name);
+ CPPUNIT_TEST(moneypunct_by_name);
+ CPPUNIT_TEST(time_by_name);
+ CPPUNIT_TEST(numpunct_by_name);
+ CPPUNIT_TEST(ctype_by_name);
+ CPPUNIT_TEST(collate_by_name);
+ CPPUNIT_TEST(messages_by_name);
+ CPPUNIT_STOP_IGNORE;
+ CPPUNIT_TEST(loc_has_facet);
+ CPPUNIT_TEST(num_put_get);
+ CPPUNIT_TEST(money_put_get);
+ CPPUNIT_TEST(money_put_X_bug);
+ CPPUNIT_TEST(time_put_get);
+ CPPUNIT_TEST(collate_facet);
+ CPPUNIT_TEST(ctype_facet);
+# if defined (STLPORT) && defined (_STLP_NO_MEMBER_TEMPLATES)
+ CPPUNIT_IGNORE;
+# endif
+ CPPUNIT_TEST(locale_init_problem);
+ CPPUNIT_STOP_IGNORE;
+ CPPUNIT_TEST(default_locale);
+# if !defined (STLPORT)
+ CPPUNIT_IGNORE;
+# endif
+ CPPUNIT_STOP_IGNORE;
+#if (defined (STLPORT) && \
+ (!defined (_STLP_USE_EXCEPTIONS) || defined (_STLP_NO_MEMBER_TEMPLATES) || defined (_STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS)))
+ CPPUNIT_IGNORE;
+# endif
+ CPPUNIT_TEST(combine);
+ CPPUNIT_TEST_SUITE_END();
+
+public:
+ void locale_by_name();
+ void loc_has_facet();
+ void num_put_get();
+ void numpunct_by_name();
+ void time_put_get();
+ void time_by_name();
+ void collate_facet();
+ void collate_by_name();
+ void ctype_facet();
+ void ctype_by_name();
+ void locale_init_problem();
+ void money_put_get();
+ void money_put_X_bug();
+ void moneypunct_by_name();
+ void default_locale();
+ void combine();
+ void messages_by_name();
+private:
+ void _loc_has_facet( const STD locale& );
+ void _num_put_get( const STD locale&, const ref_locale* );
+ void _time_put_get( const STD locale& );
+ void _ctype_facet( const STD locale& );
+ void _ctype_facet_w( const STD locale& );
+ void _locale_init_problem( const STD locale& );
+
+ static const ref_monetary* _get_ref_monetary(size_t);
+ static const char* _get_ref_monetary_name(const ref_monetary*);
+
+ void _money_put_get( const STD locale&, const ref_monetary* );
+ void _money_put_get2( const STD locale& loc, const STD locale& streamLoc, const ref_monetary* );
+ void _money_put_X_bug( const STD locale&, const ref_monetary* );
+};
+
+# undef STD
+#endif
+
diff --git a/sources/android/stlport/test/unit/logic_test.cpp b/sources/android/stlport/test/unit/logic_test.cpp
new file mode 100644
index 0000000..69ceea1
--- /dev/null
+++ b/sources/android/stlport/test/unit/logic_test.cpp
@@ -0,0 +1,65 @@
+#include <vector>
+#include <algorithm>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class LogicTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(LogicTest);
+ CPPUNIT_TEST(logicand);
+ CPPUNIT_TEST(logicnot);
+ CPPUNIT_TEST(logicor);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void logicand();
+ void logicnot();
+ void logicor();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(LogicTest);
+
+//
+// tests implementation
+//
+void LogicTest::logicand()
+{
+ bool input1 [4] = { true, true, false, true };
+ bool input2 [4] = { false, true, false, false };
+
+ bool output [4];
+ transform((bool*)input1, (bool*)input1 + 4, (bool*)input2, (bool*)output, logical_and<bool>());
+
+ CPPUNIT_ASSERT(output[0]==false);
+ CPPUNIT_ASSERT(output[1]==true);
+ CPPUNIT_ASSERT(output[2]==false);
+ CPPUNIT_ASSERT(output[3]==false);
+}
+void LogicTest::logicnot()
+{
+ bool input [7] = { 1, 0, 0, 1, 1, 1, 1 };
+
+ int n = count_if(input, input + 7, logical_not<bool>());
+ CPPUNIT_ASSERT( n == 2 );
+}
+void LogicTest::logicor()
+{
+ bool input1 [4] = { true, true, false, true };
+ bool input2 [4] = { false, true, false, false };
+
+ bool output [4];
+ transform((bool*)input1, (bool*)input1 + 4, (bool*)input2, (bool*)output, logical_or<bool>());
+
+ CPPUNIT_ASSERT(output[0]==true);
+ CPPUNIT_ASSERT(output[1]==true);
+ CPPUNIT_ASSERT(output[2]==false);
+ CPPUNIT_ASSERT(output[3]==true);
+}
diff --git a/sources/android/stlport/test/unit/macro_checks.cpp b/sources/android/stlport/test/unit/macro_checks.cpp
new file mode 100644
index 0000000..171a9fa
--- /dev/null
+++ b/sources/android/stlport/test/unit/macro_checks.cpp
@@ -0,0 +1,115 @@
+#include <cstdio>
+#include <cwchar>
+#include <climits>
+
+#if !defined (CHAR_BIT)
+# error Missing CHAR_BIT definition.
+#endif
+
+#if (CHAR_BIT < 0)
+# error Weird WCHAR_BIT value.
+#endif
+
+#if !defined (CHAR_MAX)
+# error Missing CHAR_MAX definition.
+#endif
+
+#if !defined (CHAR_MIN)
+# error Missing CHAR_MIN definition.
+#endif
+
+#if !(CHAR_MIN < CHAR_MAX)
+# error Weird CHAR_MIN or CHAR_MAX macro values.
+#endif
+
+#if !defined (INT_MAX)
+# error Missing INT_MAX definition.
+#endif
+
+#if !defined (INT_MIN)
+# error Missing INT_MIN definition.
+#endif
+
+#if !(INT_MIN < INT_MAX)
+# error Weird INT_MIN or INT_MAX macro values.
+#endif
+
+#if !defined (LONG_MAX)
+# error Missing LONG_MAX definition.
+#endif
+
+#if !defined (LONG_MIN)
+# error Missing LONG_MIN definition.
+#endif
+
+#if !(LONG_MIN < LONG_MAX)
+# error Weird LONG_MIN or LONG_MAX macro values.
+#endif
+
+#if !defined (SCHAR_MAX)
+# error Missing SCHAR_MAX definition.
+#endif
+
+#if !defined (SCHAR_MIN)
+# error Missing SCHAR_MIN definition.
+#endif
+
+#if !(SCHAR_MIN < SCHAR_MAX)
+# error Weird SCHAR_MIN or SCHAR_MAX macro values.
+#endif
+
+#if !defined (SHRT_MAX)
+# error Missing SHRT_MAX definition.
+#endif
+
+#if !defined (SHRT_MIN)
+# error Missing SHRT_MIN definition.
+#endif
+
+#if !(SHRT_MIN < SHRT_MAX)
+# error Weird SHRT_MIN or SHRT_MAX macro values.
+#endif
+
+#if !defined (WCHAR_MIN)
+# error Missing WCHAR_MIN definition.
+#endif
+
+#if !defined (WCHAR_MAX)
+# error Missing WCHAR_MAX definition.
+#endif
+
+#if !(WCHAR_MIN < WCHAR_MAX)
+# error Weird WCHAR_MIN or WCHAR_MAX macro value.
+#endif
+
+#if !defined (UCHAR_MAX)
+# error Missing UCHAR_MAX definition.
+#endif
+
+#if (UCHAR_MAX < 0)
+# error Weird UCHAR_MAX macro value.
+#endif
+
+#if !defined (UINT_MAX)
+# error Missing UINT_MAX definition.
+#endif
+
+#if (UINT_MAX < 0)
+# error Weird UINT_MAX macro value.
+#endif
+
+#if !defined (ULONG_MAX)
+# error Missing ULONG_MAX definition.
+#endif
+
+#if (ULONG_MAX < 0)
+# error Weird ULONG_MAX macro value.
+#endif
+
+#if !defined (USHRT_MAX)
+# error Missing USHRT_MAX definition.
+#endif
+
+#if (USHRT_MAX < 0)
+# error Weird USHRT_MAX macro value.
+#endif
diff --git a/sources/android/stlport/test/unit/map_header_test.cpp b/sources/android/stlport/test/unit/map_header_test.cpp
new file mode 100644
index 0000000..84cf154
--- /dev/null
+++ b/sources/android/stlport/test/unit/map_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <map>
diff --git a/sources/android/stlport/test/unit/map_test.cpp b/sources/android/stlport/test/unit/map_test.cpp
new file mode 100644
index 0000000..46256a9
--- /dev/null
+++ b/sources/android/stlport/test/unit/map_test.cpp
@@ -0,0 +1,454 @@
+//Has to be first for StackAllocator swap overload to be taken
+//into account (at least using GCC 4.0.1)
+#include "stack_allocator.h"
+
+#include <map>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class MapTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(MapTest);
+ CPPUNIT_TEST(map1);
+ CPPUNIT_TEST(mmap1);
+ CPPUNIT_TEST(mmap2);
+ CPPUNIT_TEST(iterators);
+ CPPUNIT_TEST(equal_range);
+ CPPUNIT_TEST(allocator_with_state);
+#if !defined (STLPORT) || !defined (_STLP_USE_CONTAINERS_EXTENSION)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(template_methods);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void map1();
+ void mmap1();
+ void mmap2();
+ void iterators();
+ void equal_range();
+ void allocator_with_state();
+ void template_methods();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(MapTest);
+
+//
+// tests implementation
+//
+void MapTest::map1()
+{
+ typedef map<char, int, less<char> > maptype;
+ maptype m;
+ // Store mappings between roman numerals and decimals.
+ m['l'] = 50;
+ m['x'] = 20; // Deliberate mistake.
+ m['v'] = 5;
+ m['i'] = 1;
+// cout << "m['x'] = " << m['x'] << endl;
+ CPPUNIT_ASSERT( m['x']== 20 );
+ m['x'] = 10; // Correct mistake.
+ CPPUNIT_ASSERT( m['x']== 10 );
+ CPPUNIT_ASSERT( m['z']== 0 );
+ //cout << "m['z'] = " << m['z'] << endl; // Note default value is added.
+ CPPUNIT_ASSERT( m.count('z') == 1 );
+ //cout << "m.count('z') = " << m.count('z') << endl;
+ pair<maptype::iterator, bool> p = m.insert(pair<const char, int>('c', 100));
+ CPPUNIT_ASSERT( p.second );
+ CPPUNIT_ASSERT( p.first != m.end() );
+ CPPUNIT_ASSERT( (*p.first).first == 'c' );
+ CPPUNIT_ASSERT( (*p.first).second == 100 );
+
+ p = m.insert(pair<const char, int>('c', 100));
+ CPPUNIT_ASSERT( !p.second ); // already existing pair
+ CPPUNIT_ASSERT( p.first != m.end() );
+ CPPUNIT_ASSERT( (*p.first).first == 'c' );
+ CPPUNIT_ASSERT( (*p.first).second == 100 );
+}
+
+void MapTest::mmap1()
+{
+ typedef multimap<char, int, less<char> > mmap;
+ mmap m;
+ CPPUNIT_ASSERT(m.count('X')==0);
+
+ m.insert(pair<const char, int>('X', 10)); // Standard way.
+ CPPUNIT_ASSERT(m.count('X')==1);
+
+ m.insert(pair<const char, int>('X', 20)); // jbuck: standard way
+ CPPUNIT_ASSERT(m.count('X')==2);
+
+ m.insert(pair<const char, int>('Y', 32)); // jbuck: standard way
+ mmap::iterator i = m.find('X'); // Find first match.
+#ifndef _STLP_CONST
+# define _STLP_CONST const
+#endif
+ pair<_STLP_CONST char, int> p('X', 10);
+ CPPUNIT_ASSERT(*i == p);
+ CPPUNIT_ASSERT((*i).first == 'X');
+ CPPUNIT_ASSERT((*i).second == 10);
+ i++;
+ CPPUNIT_ASSERT((*i).first == 'X');
+ CPPUNIT_ASSERT((*i).second == 20);
+ i++;
+ CPPUNIT_ASSERT((*i).first == 'Y');
+ CPPUNIT_ASSERT((*i).second == 32);
+ i++;
+ CPPUNIT_ASSERT(i == m.end());
+
+ size_t count = m.erase('X');
+ CPPUNIT_ASSERT(count==2);
+}
+void MapTest::mmap2()
+{
+ typedef pair<const int, char> pair_type;
+
+ pair_type p1(3, 'c');
+ pair_type p2(6, 'f');
+ pair_type p3(1, 'a');
+ pair_type p4(2, 'b');
+ pair_type p5(3, 'x');
+ pair_type p6(6, 'f');
+
+ typedef multimap<int, char, less<int> > mmap;
+
+ pair_type array [] = {
+ p1,
+ p2,
+ p3,
+ p4,
+ p5,
+ p6
+ };
+
+ mmap m(array + 0, array + 6);
+ mmap::iterator i;
+ i = m.lower_bound(3);
+ CPPUNIT_ASSERT((*i).first==3);
+ CPPUNIT_ASSERT((*i).second=='c');
+
+ i = m.upper_bound(3);
+ CPPUNIT_ASSERT((*i).first==6);
+ CPPUNIT_ASSERT((*i).second=='f');
+}
+
+
+void MapTest::iterators()
+{
+ typedef map<int, char, less<int> > int_map;
+ int_map imap;
+ {
+ int_map::iterator ite(imap.begin());
+ int_map::const_iterator cite(imap.begin());
+ CPPUNIT_ASSERT( ite == cite );
+ CPPUNIT_ASSERT( !(ite != cite) );
+ CPPUNIT_ASSERT( cite == ite );
+ CPPUNIT_ASSERT( !(cite != ite) );
+ }
+
+ typedef multimap<int, char, less<int> > mmap;
+ typedef mmap::value_type pair_type;
+
+ pair_type p1(3, 'c');
+ pair_type p2(6, 'f');
+ pair_type p3(1, 'a');
+ pair_type p4(2, 'b');
+ pair_type p5(3, 'x');
+ pair_type p6(6, 'f');
+
+ pair_type array [] = {
+ p1,
+ p2,
+ p3,
+ p4,
+ p5,
+ p6
+ };
+
+ mmap m(array+0, array + 6);
+
+ {
+ mmap::iterator ite(m.begin());
+ mmap::const_iterator cite(m.begin());
+ //test compare between const_iterator and iterator
+ CPPUNIT_ASSERT( ite == cite );
+ CPPUNIT_ASSERT( !(ite != cite) );
+ CPPUNIT_ASSERT( cite == ite );
+ CPPUNIT_ASSERT( !(cite != ite) );
+ }
+
+#if 0
+ /*
+ * A check that map and multimap iterators are NOT comparable
+ * the following code should generate a compile time error
+ */
+ {
+ int_map::iterator mite(imap.begin());
+ int_map::const_iterator mcite(imap.begin());
+ mmap::iterator mmite(m.begin());
+ mmap::const_iterator mmcite(m.begin());
+ CPPUNIT_ASSERT( !(mite == mmite) );
+ CPPUNIT_ASSERT( !(mcite == mmcite) );
+ CPPUNIT_ASSERT( mite != mmite );
+ CPPUNIT_ASSERT( mcite != mmcite );
+ CPPUNIT_ASSERT( !(mite == mmcite) );
+ CPPUNIT_ASSERT( !(mite == mmcite) );
+ CPPUNIT_ASSERT( mite != mmcite );
+ CPPUNIT_ASSERT( mite != mmcite );
+ }
+
+#endif
+
+ mmap::reverse_iterator ri = m.rbegin();
+ CPPUNIT_ASSERT( ri != m.rend() );
+ CPPUNIT_ASSERT( ri == m.rbegin() );
+ CPPUNIT_ASSERT( (*ri).first == 6 );
+ CPPUNIT_ASSERT( (*ri++).second == 'f' );
+ CPPUNIT_ASSERT( (*ri).first == 6 );
+ CPPUNIT_ASSERT( (*ri).second == 'f' );
+
+ mmap const& cm = m;
+ mmap::const_reverse_iterator rci = cm.rbegin();
+ CPPUNIT_ASSERT( rci != cm.rend() );
+ CPPUNIT_ASSERT( (*rci).first == 6 );
+ CPPUNIT_ASSERT( (*rci++).second == 'f' );
+ CPPUNIT_ASSERT( (*rci).first == 6 );
+ CPPUNIT_ASSERT( (*rci).second == 'f' );
+}
+
+void MapTest::equal_range()
+{
+ typedef map<char, int, less<char> > maptype;
+ {
+ maptype m;
+ m['x'] = 10;
+
+ pair<maptype::iterator, maptype::iterator> ret;
+ ret = m.equal_range('x');
+ CPPUNIT_ASSERT( ret.first != ret.second );
+ CPPUNIT_ASSERT( (*(ret.first)).first == 'x' );
+ CPPUNIT_ASSERT( (*(ret.first)).second == 10 );
+ CPPUNIT_ASSERT( ++(ret.first) == ret.second );
+ }
+ {
+ {
+ maptype m;
+
+ maptype::iterator i = m.lower_bound( 'x' );
+ CPPUNIT_ASSERT( i == m.end() );
+
+ i = m.upper_bound( 'x' );
+ CPPUNIT_ASSERT( i == m.end() );
+
+ pair<maptype::iterator, maptype::iterator> ret;
+ ret = m.equal_range('x');
+ CPPUNIT_ASSERT( ret.first == ret.second );
+ CPPUNIT_ASSERT( ret.first == m.end() );
+ }
+
+ {
+ const maptype m;
+ pair<maptype::const_iterator, maptype::const_iterator> ret;
+ ret = m.equal_range('x');
+ CPPUNIT_ASSERT( ret.first == ret.second );
+ CPPUNIT_ASSERT( ret.first == m.end() );
+ }
+ }
+}
+
+void MapTest::allocator_with_state()
+{
+ char buf1[1024];
+ StackAllocator<pair<const int, int> > stack1(buf1, buf1 + sizeof(buf1));
+
+ char buf2[1024];
+ StackAllocator<pair<const int, int> > stack2(buf2, buf2 + sizeof(buf2));
+
+ {
+ typedef map<int, int, less<int>, StackAllocator<pair<const int, int> > > MapInt;
+ less<int> intLess;
+ MapInt mint1(intLess, stack1);
+ int i;
+ for (i = 0; i < 5; ++i)
+ mint1.insert(MapInt::value_type(i, i));
+ MapInt mint1Cpy(mint1);
+
+ MapInt mint2(intLess, stack2);
+ for (; i < 10; ++i)
+ mint2.insert(MapInt::value_type(i, i));
+ MapInt mint2Cpy(mint2);
+
+ mint1.swap(mint2);
+
+ CPPUNIT_ASSERT( mint1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( mint2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( mint1 == mint2Cpy );
+ CPPUNIT_ASSERT( mint2 == mint1Cpy );
+ CPPUNIT_ASSERT( mint1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( mint2.get_allocator() == stack1 );
+ }
+ CPPUNIT_ASSERT( stack1.ok() );
+ CPPUNIT_ASSERT( stack2.ok() );
+}
+
+struct Key
+{
+ Key() : m_data(0) {}
+ explicit Key(int data) : m_data(data) {}
+
+ int m_data;
+};
+
+struct KeyCmp
+{
+ bool operator () (Key lhs, Key rhs) const
+ { return lhs.m_data < rhs.m_data; }
+
+ bool operator () (Key lhs, int rhs) const
+ { return lhs.m_data < rhs; }
+
+ bool operator () (int lhs, Key rhs) const
+ { return lhs < rhs.m_data; }
+};
+
+struct KeyCmpPtr
+{
+ bool operator () (Key const volatile *lhs, Key const volatile *rhs) const
+ { return (*lhs).m_data < (*rhs).m_data; }
+
+ bool operator () (Key const volatile *lhs, int rhs) const
+ { return (*lhs).m_data < rhs; }
+
+ bool operator () (int lhs, Key const volatile *rhs) const
+ { return lhs < (*rhs).m_data; }
+};
+
+void MapTest::template_methods()
+{
+#if defined (STLPORT) && defined (_STLP_USE_CONTAINERS_EXTENSION)
+ {
+ typedef map<Key, int, KeyCmp> Container;
+ typedef Container::value_type value;
+ Container cont;
+ cont.insert(value(Key(1), 1));
+ cont.insert(value(Key(2), 2));
+ cont.insert(value(Key(3), 3));
+ cont.insert(value(Key(4), 4));
+
+ CPPUNIT_ASSERT( cont.count(Key(1)) == 1 );
+ CPPUNIT_ASSERT( cont.count(1) == 1 );
+ CPPUNIT_ASSERT( cont.count(5) == 0 );
+
+ CPPUNIT_ASSERT( cont.find(2) != cont.end() );
+ CPPUNIT_ASSERT( cont.lower_bound(2) != cont.end() );
+ CPPUNIT_ASSERT( cont.upper_bound(2) != cont.end() );
+ CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) );
+
+ Container const& ccont = cont;
+ CPPUNIT_ASSERT( ccont.find(2) != ccont.end() );
+ CPPUNIT_ASSERT( ccont.lower_bound(2) != ccont.end() );
+ CPPUNIT_ASSERT( ccont.upper_bound(2) != ccont.end() );
+ CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.end(), ccont.end()) );
+ }
+
+ {
+ typedef map<Key*, int, KeyCmpPtr> Container;
+ typedef Container::value_type value;
+ Container cont;
+ Key key1(1), key2(2), key3(3), key4(4);
+ cont.insert(value(&key1, 1));
+ cont.insert(value(&key2, 2));
+ cont.insert(value(&key3, 3));
+ cont.insert(value(&key4, 4));
+
+ CPPUNIT_ASSERT( cont.count(1) == 1 );
+ CPPUNIT_ASSERT( cont.count(5) == 0 );
+
+ CPPUNIT_ASSERT( cont.find(2) != cont.end() );
+ CPPUNIT_ASSERT( cont.lower_bound(2) != cont.end() );
+ CPPUNIT_ASSERT( cont.upper_bound(2) != cont.end() );
+ CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) );
+
+ Container const& ccont = cont;
+ CPPUNIT_ASSERT( ccont.find(2) != ccont.end() );
+ CPPUNIT_ASSERT( ccont.lower_bound(2) != ccont.end() );
+ CPPUNIT_ASSERT( ccont.upper_bound(2) != ccont.end() );
+ CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.begin(), ccont.end()) );
+ }
+ {
+ typedef multimap<Key, int, KeyCmp> Container;
+ typedef Container::value_type value;
+ Container cont;
+ cont.insert(value(Key(1), 1));
+ cont.insert(value(Key(2), 2));
+ cont.insert(value(Key(3), 3));
+ cont.insert(value(Key(4), 4));
+
+ CPPUNIT_ASSERT( cont.count(Key(1)) == 1 );
+ CPPUNIT_ASSERT( cont.count(1) == 1 );
+ CPPUNIT_ASSERT( cont.count(5) == 0 );
+
+ CPPUNIT_ASSERT( cont.find(2) != cont.end() );
+ CPPUNIT_ASSERT( cont.lower_bound(2) != cont.end() );
+ CPPUNIT_ASSERT( cont.upper_bound(2) != cont.end() );
+ CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) );
+
+ Container const& ccont = cont;
+ CPPUNIT_ASSERT( ccont.find(2) != ccont.end() );
+ CPPUNIT_ASSERT( ccont.lower_bound(2) != ccont.end() );
+ CPPUNIT_ASSERT( ccont.upper_bound(2) != ccont.end() );
+ CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.end(), ccont.end()) );
+ }
+
+ {
+ typedef multimap<Key const volatile*, int, KeyCmpPtr> Container;
+ typedef Container::value_type value;
+ Container cont;
+ Key key1(1), key2(2), key3(3), key4(4);
+ cont.insert(value(&key1, 1));
+ cont.insert(value(&key2, 2));
+ cont.insert(value(&key3, 3));
+ cont.insert(value(&key4, 4));
+
+ CPPUNIT_ASSERT( cont.count(1) == 1 );
+ CPPUNIT_ASSERT( cont.count(5) == 0 );
+
+ CPPUNIT_ASSERT( cont.find(2) != cont.end() );
+ CPPUNIT_ASSERT( cont.lower_bound(2) != cont.end() );
+ CPPUNIT_ASSERT( cont.upper_bound(2) != cont.end() );
+ CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) );
+
+ Container const& ccont = cont;
+ CPPUNIT_ASSERT( ccont.find(2) != ccont.end() );
+ CPPUNIT_ASSERT( ccont.lower_bound(2) != ccont.end() );
+ CPPUNIT_ASSERT( ccont.upper_bound(2) != ccont.end() );
+ CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.begin(), ccont.end()) );
+ }
+#endif
+}
+
+#if !defined (STLPORT) || \
+ !defined (_STLP_USE_PTR_SPECIALIZATIONS) || defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+# if !defined (__DMC__)
+/* Simple compilation test: Check that nested types like iterator
+ * can be access even if type used to instanciate container is not
+ * yet completely defined.
+ */
+class IncompleteClass
+{
+ map<IncompleteClass, IncompleteClass> instances;
+ typedef map<IncompleteClass, IncompleteClass>::iterator it;
+ multimap<IncompleteClass, IncompleteClass> minstances;
+ typedef multimap<IncompleteClass, IncompleteClass>::iterator mit;
+};
+# endif
+#endif
diff --git a/sources/android/stlport/test/unit/math_aux.h b/sources/android/stlport/test/unit/math_aux.h
new file mode 100644
index 0000000..c1291af
--- /dev/null
+++ b/sources/android/stlport/test/unit/math_aux.h
@@ -0,0 +1,30 @@
+#ifndef __MATH_AUX_H
+#define __MATH_AUX_H
+
+#include <limits>
+
+#undef __STD
+#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+# define __STD std::
+#else
+# define __STD
+#endif
+
+/*
+ * This function is not only used to compare floating point values with a tolerance,
+ * it also leads to ambiguity problems if the called functions do not have the
+ * right prototype.
+ */
+template <class _Tp>
+bool are_equals(_Tp val, _Tp ref) {
+ if (val < ref) {
+ return (ref - val) <= __STD numeric_limits<_Tp>::epsilon();
+ }
+ else {
+ return (val - ref) <= __STD numeric_limits<_Tp>::epsilon();
+ }
+}
+
+#undef __STD
+
+#endif // __MATH_AUX_H
diff --git a/sources/android/stlport/test/unit/math_header_test.c b/sources/android/stlport/test/unit/math_header_test.c
new file mode 100644
index 0000000..9557496
--- /dev/null
+++ b/sources/android/stlport/test/unit/math_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <math.h>
diff --git a/sources/android/stlport/test/unit/max_test.cpp b/sources/android/stlport/test/unit/max_test.cpp
new file mode 100644
index 0000000..d8ab006
--- /dev/null
+++ b/sources/android/stlport/test/unit/max_test.cpp
@@ -0,0 +1,64 @@
+#include <vector>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class MaxTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(MaxTest);
+ CPPUNIT_TEST(max1);
+ CPPUNIT_TEST(max2);
+ CPPUNIT_TEST(maxelem1);
+ CPPUNIT_TEST(maxelem2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void max1();
+ void max2();
+ void maxelem1();
+ void maxelem2();
+
+ static bool str_compare(const char* a_, const char* b_)
+ { return strcmp(a_, b_) < 0 ? 1 : 0; }
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(MaxTest);
+
+//
+// tests implementation
+//
+void MaxTest::max1()
+{
+ int r = max(42, 100);
+ CPPUNIT_ASSERT( r == 100 );
+
+ int t = max(++r, 0);
+ CPPUNIT_ASSERT( t == 101 );
+}
+void MaxTest::max2()
+{
+ const char* r = max((const char*)"shoe", (const char*)"shine", str_compare);
+ CPPUNIT_ASSERT(!strcmp(r, "shoe"));
+}
+void MaxTest::maxelem1()
+{
+ int numbers[6] = { 4, 10, 56, 11, -42, 19 };
+
+ int* r = max_element((int*)numbers, (int*)numbers + 6);
+ CPPUNIT_ASSERT(*r==56);
+}
+void MaxTest::maxelem2()
+{
+ const char* names[] = { "Brett", "Graham", "Jack", "Mike", "Todd" };
+
+ const unsigned namesCt = sizeof(names) / sizeof(names[0]);
+ const char** r = max_element((const char**)names, (const char**)names + namesCt, str_compare);
+ CPPUNIT_ASSERT(!strcmp(*r, "Todd"));
+}
diff --git a/sources/android/stlport/test/unit/memory_header_test.cpp b/sources/android/stlport/test/unit/memory_header_test.cpp
new file mode 100644
index 0000000..afd9f05
--- /dev/null
+++ b/sources/android/stlport/test/unit/memory_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <memory>
diff --git a/sources/android/stlport/test/unit/memory_test.cpp b/sources/android/stlport/test/unit/memory_test.cpp
new file mode 100644
index 0000000..a117109
--- /dev/null
+++ b/sources/android/stlport/test/unit/memory_test.cpp
@@ -0,0 +1,67 @@
+#include <memory>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class MemoryTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(MemoryTest);
+#if defined (_STLP_MSVC) && (_STLP_MSVC < 1310)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(auto_ptr_test);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void auto_ptr_test();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(MemoryTest);
+
+#if !defined (_STLP_MSVC) || (_STLP_MSVC >= 1310)
+auto_ptr<int> CreateAutoPtr(int val)
+{ return auto_ptr<int>(new int(val)); }
+
+bool CheckEquality(auto_ptr<int> pint, int val)
+{ return *pint == val; }
+#endif
+
+//
+// tests implementation
+//
+void MemoryTest::auto_ptr_test()
+{
+#if !defined (_STLP_MSVC) || (_STLP_MSVC >= 1310)
+ {
+ auto_ptr<int> pint(new int(1));
+ CPPUNIT_ASSERT( *pint == 1 );
+ *pint = 2;
+ CPPUNIT_ASSERT( *pint == 2 );
+ }
+
+ {
+ auto_ptr<int> pint(CreateAutoPtr(3));
+ CPPUNIT_ASSERT( *pint == 3 );
+ CPPUNIT_ASSERT( CheckEquality(pint, 3) );
+ }
+
+ {
+ auto_ptr<const int> pint(new int(2));
+ CPPUNIT_ASSERT( *pint == 2 );
+ }
+ {
+ auto_ptr<volatile int> pint(new int(2));
+ CPPUNIT_ASSERT( *pint == 2 );
+ }
+ {
+ auto_ptr<const volatile int> pint(new int(2));
+ CPPUNIT_ASSERT( *pint == 2 );
+ }
+#endif
+}
diff --git a/sources/android/stlport/test/unit/merge_test.cpp b/sources/android/stlport/test/unit/merge_test.cpp
new file mode 100644
index 0000000..7435b8f
--- /dev/null
+++ b/sources/android/stlport/test/unit/merge_test.cpp
@@ -0,0 +1,97 @@
+#include <vector>
+#include <algorithm>
+#include <functional>
+#include <numeric>
+
+#include "iota.h"
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class MergeTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(MergeTest);
+ CPPUNIT_TEST(merge0);
+ CPPUNIT_TEST(merge1);
+ CPPUNIT_TEST(merge2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void merge0();
+ void merge1();
+ void merge2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(MergeTest);
+
+//
+// tests implementation
+//
+void MergeTest::merge0()
+{
+ int numbers1[5] = { 1, 6, 13, 25, 101 };
+ int numbers2[5] = {-5, 26, 36, 46, 99 };
+
+ int result[10];
+ merge((int*)numbers1, (int*)numbers1 + 5, (int*)numbers2, (int*)numbers2 + 5, (int*)result);
+
+ CPPUNIT_ASSERT(result[0]==-5);
+ CPPUNIT_ASSERT(result[1]==1);
+ CPPUNIT_ASSERT(result[2]==6);
+ CPPUNIT_ASSERT(result[3]==13);
+ CPPUNIT_ASSERT(result[4]==25);
+ CPPUNIT_ASSERT(result[5]==26);
+ CPPUNIT_ASSERT(result[6]==36);
+ CPPUNIT_ASSERT(result[7]==46);
+ CPPUNIT_ASSERT(result[8]==99);
+ CPPUNIT_ASSERT(result[9]==101);
+}
+void MergeTest::merge1()
+{
+ vector<int> v1(5);
+ vector<int> v2(v1.size());
+ __iota(v1.begin(), v1.end(), 0);
+ __iota(v2.begin(), v2.end(), 3);
+
+ vector <int> result(v1.size() + v2.size());
+ merge(v1.begin(), v1.end(), v2.begin(), v2.end(), result.begin());
+
+ CPPUNIT_ASSERT(result[0]==0);
+ CPPUNIT_ASSERT(result[1]==1);
+ CPPUNIT_ASSERT(result[2]==2);
+ CPPUNIT_ASSERT(result[3]==3);
+ CPPUNIT_ASSERT(result[4]==3);
+ CPPUNIT_ASSERT(result[5]==4);
+ CPPUNIT_ASSERT(result[6]==4);
+ CPPUNIT_ASSERT(result[7]==5);
+ CPPUNIT_ASSERT(result[8]==6);
+ CPPUNIT_ASSERT(result[9]==7);
+
+}
+void MergeTest::merge2()
+{
+ vector <int> v1(5);
+ vector <int> v2(v1.size());
+ for (int i = 0; (size_t)i < v1.size(); ++i) {
+ v1[i] = 10 - i;
+ v2[i] = 7 - i;
+ }
+ vector<int> result(v1.size() + v2.size());
+ merge(v1.begin(), v1.end(), v2.begin(), v2.end(), result.begin(), greater<int>() );
+
+ CPPUNIT_ASSERT(result[0]==10);
+ CPPUNIT_ASSERT(result[1]==9);
+ CPPUNIT_ASSERT(result[2]==8);
+ CPPUNIT_ASSERT(result[3]==7);
+ CPPUNIT_ASSERT(result[4]==7);
+ CPPUNIT_ASSERT(result[5]==6);
+ CPPUNIT_ASSERT(result[6]==6);
+ CPPUNIT_ASSERT(result[7]==5);
+ CPPUNIT_ASSERT(result[8]==4);
+ CPPUNIT_ASSERT(result[9]==3);
+}
diff --git a/sources/android/stlport/test/unit/messages_facets_test.cpp b/sources/android/stlport/test/unit/messages_facets_test.cpp
new file mode 100644
index 0000000..610bbaa
--- /dev/null
+++ b/sources/android/stlport/test/unit/messages_facets_test.cpp
@@ -0,0 +1,85 @@
+#include "locale_test.h"
+
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# include <locale>
+# include <stdexcept>
+
+# if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+# endif
+
+//
+// tests implementation
+//
+void LocaleTest::messages_by_name()
+{
+ /*
+ * Check of the 22.1.1.2.7 standard point. Construction of a locale
+ * instance from a null pointer or an unknown name should result in
+ * a runtime_error exception.
+ */
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+# if defined (STLPORT) || !defined (__GNUC__)
+ try {
+ locale loc(locale::classic(), new messages_byname<char>(static_cast<char const*>(0)));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+
+ try {
+ locale loc(locale::classic(), new messages_byname<char>("yasli_language"));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ /*
+ try {
+ locale loc(locale::classic(), new messages_byname<char>(""));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& e) {
+ CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+ */
+
+# if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
+# if defined (STLPORT) || !defined (__GNUC__)
+ try {
+ locale loc(locale::classic(), new messages_byname<wchar_t>(static_cast<char const*>(0)));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+
+ try {
+ locale loc(locale::classic(), new messages_byname<wchar_t>("yasli_language"));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+# endif
+}
+
+#endif
diff --git a/sources/android/stlport/test/unit/mfunptr_test.cpp b/sources/android/stlport/test/unit/mfunptr_test.cpp
new file mode 100644
index 0000000..d29d598
--- /dev/null
+++ b/sources/android/stlport/test/unit/mfunptr_test.cpp
@@ -0,0 +1,230 @@
+#include <functional>
+#include <memory>
+#include <vector>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class MemFunPtrTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(MemFunPtrTest);
+ CPPUNIT_TEST(mem_ptr_fun);
+#if defined (STLPORT) && !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ //This test require partial template specialization feature to avoid the
+ //reference to reference problem. No workaround yet for limited compilers.
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(find);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ // compile test not neccessary to run but...
+ void mem_ptr_fun();
+ void find();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(MemFunPtrTest);
+
+#if defined(_STLP_DONT_RETURN_VOID) && (defined(_STLP_NO_MEMBER_TEMPLATE_CLASSES) && defined(_STLP_NO_CLASS_PARTIAL_SPECIALIZATION))
+# define _STLP_DONT_TEST_RETURN_VOID
+#endif
+//else there is no workaround for the return void bug
+
+struct S1 { } s1;
+struct S2 { } s2;
+
+int f1(S1&);
+int f2(S1&, S2&);
+int f1c(const S1&);
+int f2c(const S1&, const S2&);
+
+void vf1(S1&);
+void vf2(S1&, S2&);
+void vf1c(const S1&);
+void vf2c(const S1&, const S2&);
+
+class Class {
+public:
+ int f0();
+ int f1(const S1&);
+
+ void vf0();
+ void vf1(const S1&);
+
+ int f0c() const;
+ int f1c(const S1&) const;
+
+ void vf0c() const;
+ void vf1c(const S1&) const;
+};
+
+//
+// tests implementation
+//
+void MemFunPtrTest::mem_ptr_fun()
+{
+ Class obj;
+ const Class& objc = obj;
+
+ // ptr_fun
+
+ ptr_fun(f1)(s1);
+ ptr_fun(f2)(s1, s2);
+
+ ptr_fun(f1c)(s1);
+ ptr_fun(f2c)(s1, s2);
+
+#ifndef _STLP_DONT_TEST_RETURN_VOID
+ ptr_fun(vf1)(s1);
+ ptr_fun(vf2)(s1, s2);
+
+ ptr_fun(vf1c)(s1);
+ ptr_fun(vf2c)(s1, s2);
+#endif /* _STLP_DONT_TEST_RETURN_VOID */
+
+ // mem_fun
+
+ mem_fun(&Class::f0)(&obj);
+ mem_fun(&Class::f1)(&obj, s1);
+
+#ifndef _STLP_DONT_TEST_RETURN_VOID
+ mem_fun(&Class::vf0)(&obj);
+ mem_fun(&Class::vf1)(&obj, s1);
+#endif /* _STLP_DONT_TEST_RETURN_VOID */
+
+ // mem_fun (const)
+
+ mem_fun(&Class::f0c)(&objc);
+ mem_fun(&Class::f1c)(&objc, s1);
+
+#ifndef _STLP_DONT_TEST_RETURN_VOID
+ mem_fun(&Class::vf0c)(&objc);
+ mem_fun(&Class::vf1c)(&objc, s1);
+#endif /* _STLP_DONT_TEST_RETURN_VOID */
+
+ // mem_fun_ref
+
+ mem_fun_ref(&Class::f0)(obj);
+ mem_fun_ref(&Class::f1)(obj, s1);
+
+#ifndef _STLP_DONT_TEST_RETURN_VOID
+ mem_fun_ref(&Class::vf0)(obj);
+ mem_fun_ref(&Class::vf1)(obj, s1);
+#endif /* _STLP_DONT_TEST_RETURN_VOID */
+
+ // mem_fun_ref (const)
+ mem_fun_ref(&Class::f0c)(objc);
+ mem_fun_ref(&Class::f1c)(objc, s1);
+
+#ifndef _STLP_DONT_TEST_RETURN_VOID
+ mem_fun_ref(&Class::vf0c)(objc);
+ mem_fun_ref(&Class::vf1c)(objc, s1);
+#endif /* _STLP_DONT_TEST_RETURN_VOID */
+}
+int f1(S1&)
+{return 1;}
+
+int f2(S1&, S2&)
+{return 2;}
+
+int f1c(const S1&)
+{return 1;}
+
+int f2c(const S1&, const S2&)
+{return 2;}
+
+void vf1(S1&)
+{}
+
+void vf2(S1&, S2&)
+{}
+
+void vf1c(const S1&)
+{}
+
+void vf2c(const S1&, const S2&)
+{}
+
+int Class::f0()
+{return 0;}
+
+int Class::f1(const S1&)
+{return 1;}
+
+void Class::vf0()
+{}
+
+void Class::vf1(const S1&)
+{}
+
+int Class::f0c() const
+{return 0;}
+
+int Class::f1c(const S1&) const
+{return 1;}
+
+void Class::vf0c() const
+{}
+
+void Class::vf1c(const S1&) const
+{}
+
+struct V {
+ public:
+ V(int _v) :
+ v(_v)
+ { }
+
+ bool f( int _v ) const { return (v == _v); }
+
+ int v;
+#if defined (__DMC__)
+ V(){}
+#endif
+};
+
+void MemFunPtrTest::find()
+{
+#if !defined (STLPORT) || defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ vector<V> v;
+
+ v.push_back( V(1) );
+ v.push_back( V(2) );
+ v.push_back( V(3) );
+
+ // step-by-step complication of work for compiler:
+
+ // step 1:
+ const_mem_fun1_ref_t<bool,V,int> pmf = mem_fun_ref( &V::f );
+ binder2nd<const_mem_fun1_ref_t<bool,V,int> > b(pmf, 2);
+ vector<V>::iterator i = find_if( v.begin(), v.end(), b );
+ CPPUNIT_ASSERT(i != v.end());
+ CPPUNIT_ASSERT(i->v == 2);
+
+ // step 2, just check that compiler understand what pass to bind2nd:
+ binder2nd<const_mem_fun1_ref_t<bool,V,int> > b2 = bind2nd( pmf, 2 );
+
+ // step 3, the same as step 1, but more intellect from compiler required:
+ binder2nd<const_mem_fun1_ref_t<bool,V,int> > b3 = bind2nd( mem_fun_ref( &V::f ), 2 );
+
+ vector<V>::iterator j = find_if( v.begin(), v.end(), b3 );
+ CPPUNIT_ASSERT(j != v.end());
+ CPPUNIT_ASSERT(j->v == 2);
+
+ // step 4, more brief, more complex:
+ vector<V>::iterator k = find_if( v.begin(), v.end(), bind2nd( mem_fun_ref( &V::f ), 2 ) );
+ CPPUNIT_ASSERT(k != v.end());
+ CPPUNIT_ASSERT(k->v == 2);
+#endif
+}
+
+#ifdef _STLP_DONT_TEST_RETURN_VOID
+# undef _STLP_DONT_TEST_RETURN_VOID
+#endif
diff --git a/sources/android/stlport/test/unit/min_test.cpp b/sources/android/stlport/test/unit/min_test.cpp
new file mode 100644
index 0000000..2f45ade
--- /dev/null
+++ b/sources/android/stlport/test/unit/min_test.cpp
@@ -0,0 +1,62 @@
+#include <vector>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class MinTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(MinTest);
+ CPPUNIT_TEST(min1);
+ CPPUNIT_TEST(min2);
+ CPPUNIT_TEST(minelem1);
+ CPPUNIT_TEST(minelem2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void min1();
+ void min2();
+ void minelem1();
+ void minelem2();
+ static bool str_compare(const char* a_, const char* b_)
+ { return strcmp(a_, b_) < 0 ? 1 : 0; }
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(MinTest);
+
+//
+// tests implementation
+//
+void MinTest::min1()
+{
+ int r = min(42, 100);
+ CPPUNIT_ASSERT( r == 42 );
+
+ r = min(--r, r);
+ CPPUNIT_ASSERT( r == 41 );
+}
+void MinTest::min2()
+{
+ const char* r = min((const char*)"shoe", (const char*)"shine", str_compare);
+ CPPUNIT_ASSERT(!strcmp(r, "shine"));
+}
+void MinTest::minelem1()
+{
+ int numbers[6] = { -10, 15, -100, 36, -242, 42 };
+ int* r = min_element((int*)numbers, (int*)numbers + 6);
+ CPPUNIT_ASSERT(*r==-242);
+}
+void MinTest::minelem2()
+{
+ const char* names[] = { "Brett", "Graham", "Jack", "Mike", "Todd" };
+
+ const unsigned namesCt = sizeof(names) / sizeof(names[0]);
+ const char** r = min_element((const char**)names, (const char**)names + namesCt, str_compare);
+ CPPUNIT_ASSERT(!strcmp(*r, "Brett"));
+}
diff --git a/sources/android/stlport/test/unit/mismatch_test.cpp b/sources/android/stlport/test/unit/mismatch_test.cpp
new file mode 100644
index 0000000..13f7cd0
--- /dev/null
+++ b/sources/android/stlport/test/unit/mismatch_test.cpp
@@ -0,0 +1,82 @@
+#include <numeric>
+#include <vector>
+#include <algorithm>
+
+#include "iota.h"
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class MismatchTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(MismatchTest);
+ CPPUNIT_TEST(mismatch0);
+ CPPUNIT_TEST(mismatch1);
+ CPPUNIT_TEST(mismatch2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void mismatch0();
+ void mismatch1();
+ void mismatch2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(MismatchTest);
+
+//
+// tests implementation
+//
+bool str_equal(const char* a_, const char* b_)
+{
+ return strcmp(a_, b_) == 0 ? 1 : 0;
+}
+void MismatchTest::mismatch0()
+{
+ int n1[5] = { 1, 2, 3, 4, 5 };
+ int n2[5] = { 1, 2, 3, 4, 5 };
+ int n3[5] = { 1, 2, 3, 2, 1 };
+
+ pair <int*, int*> result = mismatch((int*)n1, (int*)n1 + 5, (int*)n2);
+ CPPUNIT_ASSERT(result.first ==(n1 + 5) && result.second ==(n2 + 5));
+
+ result = mismatch((int*)n1, (int*)n1 + 5, (int*)n3);
+ CPPUNIT_ASSERT(!(result.first ==(n1 + 5) && result.second ==(n3 + 5)));
+ CPPUNIT_ASSERT((result.first - n1)==3);
+}
+void MismatchTest::mismatch1()
+{
+ typedef vector<int> IntVec;
+ IntVec v1(10);
+ __iota(v1.begin(), v1.end(), 0);
+ IntVec v2(v1);
+
+ pair <IntVec::iterator, IntVec::iterator> result = mismatch(v1.begin(), v1.end(), v2.begin());
+
+ CPPUNIT_ASSERT(result.first == v1.end() && result.second == v2.end());
+
+ v2[v2.size()/2] = 42;
+ result = mismatch(v1.begin(), v1.end(), v2.begin());
+ CPPUNIT_ASSERT(!(result.first == v1.end() && result.second == v2.end()));
+ CPPUNIT_ASSERT((result.first - v1.begin())==5);
+}
+void MismatchTest::mismatch2()
+{
+ const unsigned size = 5;
+ char const* n1[size] = { "Brett", "Graham", "Jack", "Mike", "Todd" };
+
+ char const* n2[size];
+ copy(n1, n1 + 5, (char const**)n2);
+ pair <char const**, char const**> result = mismatch((char const**)n1, (char const**)n1 + size, (char const**)n2, str_equal);
+
+ CPPUNIT_ASSERT(result.first == n1 + size && result.second == n2 + size);
+
+ n2[2] = "QED";
+ result = mismatch((char const**)n1, (char const**)n1 + size, (char const**)n2, str_equal);
+ CPPUNIT_ASSERT(!(result.first == n2 + size && result.second == n2 + size));
+ CPPUNIT_ASSERT((result.first - n1)==2);
+}
diff --git a/sources/android/stlport/test/unit/modulus_test.cpp b/sources/android/stlport/test/unit/modulus_test.cpp
new file mode 100644
index 0000000..2fab979
--- /dev/null
+++ b/sources/android/stlport/test/unit/modulus_test.cpp
@@ -0,0 +1,40 @@
+#include <algorithm>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class ModulusTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(ModulusTest);
+ CPPUNIT_TEST(modulus0);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void modulus0();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(ModulusTest);
+
+//
+// tests implementation
+//
+void ModulusTest::modulus0()
+{
+ int input1 [4] = { 6, 8, 10, 2 };
+ int input2 [4] = { 4, 2, 11, 3 };
+
+ int output [4];
+
+ transform((int*)input1, (int*)input1 + 4, (int*)input2, (int*)output, modulus<int>());
+ CPPUNIT_ASSERT(output[0]==2);
+ CPPUNIT_ASSERT(output[1]==0);
+ CPPUNIT_ASSERT(output[2]==10);
+ CPPUNIT_ASSERT(output[3]==2);
+}
diff --git a/sources/android/stlport/test/unit/money_facets_test.cpp b/sources/android/stlport/test/unit/money_facets_test.cpp
new file mode 100644
index 0000000..5ace770
--- /dev/null
+++ b/sources/android/stlport/test/unit/money_facets_test.cpp
@@ -0,0 +1,655 @@
+#include "locale_test.h"
+
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# include <locale>
+# include <sstream>
+# include <stdexcept>
+
+# if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+# endif
+
+struct ref_monetary {
+ const char *name;
+ const char *money_int_prefix;
+ const char *money_int_prefix_old;
+ const char *money_prefix;
+ const char *money_suffix;
+ const char *money_decimal_point;
+ const char *money_thousands_sep;
+};
+
+static const ref_monetary tested_locales[] = {
+//{ name, money_int_prefix, money_int_prefix_old, money_prefix, money_suffix, money_decimal_point, money_thousands_sep},
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ { "fr_FR", "EUR ", "FRF ", "", "", ",",
+# if defined (WIN32) || defined (_WIN32)
+ "\xa0" },
+# else
+ " " },
+# endif
+ { "ru_RU.koi8r", "RUB ", "RUR ", "", "\xd2\xd5\xc2", ".", " " },
+ { "en_GB", "GBP ", "", "\xa3", "", ".", "," },
+ { "en_US", "USD ", "", "$", "", ".", "," },
+# endif
+ { "C", "", "", "", "", " ", " " },
+};
+
+
+const ref_monetary* LocaleTest::_get_ref_monetary(size_t i)
+{
+ if (i < sizeof(tested_locales) / sizeof(tested_locales[0])) {
+ return tested_locales + i;
+ }
+ return 0;
+}
+
+const char* LocaleTest::_get_ref_monetary_name(const ref_monetary* _ref)
+{
+ return _ref->name;
+}
+
+void LocaleTest::_money_put_get( const locale& loc, const ref_monetary* rl )
+{
+ _money_put_get2(loc, loc, rl);
+}
+
+void LocaleTest::_money_put_get2( const locale& loc, const locale& streamLoc, const ref_monetary* prl )
+{
+ const ref_monetary &rl = *prl;
+ CPPUNIT_ASSERT( has_facet<money_put<char> >(loc) );
+ money_put<char> const& fmp = use_facet<money_put<char> >(loc);
+ CPPUNIT_ASSERT( has_facet<money_get<char> >(loc) );
+ money_get<char> const& fmg = use_facet<money_get<char> >(loc);
+
+ ostringstream ostr;
+ ostr.imbue(streamLoc);
+ ostr << showbase;
+
+ //Check a positive value (international format)
+ {
+ string str_res;
+ //money_put
+ {
+ CPPUNIT_ASSERT( (has_facet<moneypunct<char, true> >(loc)) );
+ moneypunct<char, true> const& intl_fmp = use_facet<moneypunct<char, true> >(loc);
+
+ ostreambuf_iterator<char, char_traits<char> > res = fmp.put(ostr, true, ostr, ' ', 123456);
+
+ CPPUNIT_ASSERT( !res.failed() );
+ str_res = ostr.str();
+ //CPPUNIT_MESSAGE(str_res.c_str());
+
+ size_t fieldIndex = 0;
+ size_t index = 0;
+
+ //On a positive value we skip the sign field if exists:
+ if (intl_fmp.pos_format().field[fieldIndex] == money_base::sign) {
+ ++fieldIndex;
+ }
+ // international currency abbreviation, if it is before value
+
+ /*
+ * int_curr_symbol
+ *
+ * The international currency symbol. The operand is a four-character
+ * string, with the first three characters containing the alphabetic
+ * international currency symbol in accordance with those specified
+ * in the ISO 4217 specification. The fourth character is the character used
+ * to separate the international currency symbol from the monetary quantity.
+ *
+ * (http://www.opengroup.org/onlinepubs/7990989775/xbd/locale.html)
+ */
+ string::size_type p = strlen( rl.money_int_prefix );
+ if (p != 0) {
+ CPPUNIT_ASSERT( intl_fmp.pos_format().field[fieldIndex] == money_base::symbol );
+ string::size_type p_old = strlen( rl.money_int_prefix_old );
+ CPPUNIT_ASSERT( (str_res.substr(index, p) == rl.money_int_prefix) ||
+ ((p_old != 0) &&
+ (str_res.substr(index, p_old) == rl.money_int_prefix_old)) );
+ if ( str_res.substr(index, p) == rl.money_int_prefix ) {
+ index += p;
+ } else {
+ index += p_old;
+ }
+ ++fieldIndex;
+ }
+
+ // space after currency
+ if (intl_fmp.pos_format().field[fieldIndex] == money_base::space ||
+ intl_fmp.pos_format().field[fieldIndex] == money_base::none) {
+ // iternational currency symobol has four chars, one of these chars
+ // is separator, so if format has space on this place, it should
+ // be skipped.
+ ++fieldIndex;
+ }
+
+ // sign
+ if (intl_fmp.pos_format().field[fieldIndex] == money_base::sign) {
+ ++fieldIndex;
+ }
+
+ // value
+ CPPUNIT_ASSERT( str_res[index++] == '1' );
+ if (!intl_fmp.grouping().empty()) {
+ CPPUNIT_ASSERT( str_res[index++] == /* intl_fmp.thousands_sep() */ *rl.money_thousands_sep );
+ }
+ CPPUNIT_ASSERT( str_res[index++] == '2' );
+ CPPUNIT_ASSERT( str_res[index++] == '3' );
+ CPPUNIT_ASSERT( str_res[index++] == '4' );
+ if (intl_fmp.frac_digits() != 0) {
+ CPPUNIT_ASSERT( str_res[index++] == /* intl_fmp.decimal_point() */ *rl.money_decimal_point );
+ }
+ CPPUNIT_ASSERT( str_res[index++] == '5' );
+ CPPUNIT_ASSERT( str_res[index++] == '6' );
+ ++fieldIndex;
+
+ // sign
+ if (intl_fmp.pos_format().field[fieldIndex] == money_base::sign) {
+ ++fieldIndex;
+ }
+
+ // space
+ if (intl_fmp.pos_format().field[fieldIndex] == money_base::space ) {
+ CPPUNIT_ASSERT( str_res[index++] == ' ' );
+ ++fieldIndex;
+ }
+
+ // sign
+ if (intl_fmp.pos_format().field[fieldIndex] == money_base::sign) {
+ ++fieldIndex;
+ }
+
+ //as space cannot be last the only left format can be none:
+ while ( fieldIndex < 3 ) {
+ CPPUNIT_ASSERT( intl_fmp.pos_format().field[fieldIndex] == money_base::none );
+ ++fieldIndex;
+ }
+ }
+
+ //money_get
+ {
+ ios_base::iostate err = ios_base::goodbit;
+ string digits;
+
+ istringstream istr(str_res);
+ ostr.str( "" );
+ ostr.clear();
+ fmg.get(istr, istreambuf_iterator<char, char_traits<char> >(), true, ostr, err, digits);
+ CPPUNIT_ASSERT( (err & (ios_base::failbit | ios_base::badbit)) == 0 );
+ CPPUNIT_ASSERT( digits == "123456" );
+ }
+ }
+
+ ostr.str("");
+ //Check a negative value (national format)
+ {
+ CPPUNIT_ASSERT( (has_facet<moneypunct<char, false> >(loc)) );
+ moneypunct<char, false> const& dom_fmp = use_facet<moneypunct<char, false> >(loc);
+ string str_res;
+ //Check money_put
+ {
+ ostreambuf_iterator<char, char_traits<char> > res = fmp.put(ostr, false, ostr, ' ', -123456);
+
+ CPPUNIT_ASSERT( !res.failed() );
+ str_res = ostr.str();
+ //CPPUNIT_MESSAGE(str_res.c_str());
+
+ size_t fieldIndex = 0;
+ size_t index = 0;
+
+ if (dom_fmp.neg_format().field[fieldIndex] == money_base::sign) {
+ CPPUNIT_ASSERT( str_res.substr(index, dom_fmp.negative_sign().size()) == dom_fmp.negative_sign() );
+ index += dom_fmp.negative_sign().size();
+ ++fieldIndex;
+ }
+
+ string::size_type p = strlen( rl.money_prefix );
+ if (p != 0) {
+ CPPUNIT_ASSERT( str_res.substr(index, p) == rl.money_prefix );
+ index += p;
+ ++fieldIndex;
+ }
+ if (dom_fmp.neg_format().field[fieldIndex] == money_base::space ||
+ dom_fmp.neg_format().field[fieldIndex] == money_base::none) {
+ CPPUNIT_ASSERT( str_res[index++] == ' ' );
+ ++fieldIndex;
+ }
+
+ CPPUNIT_ASSERT( str_res[index++] == '1' );
+ if (!dom_fmp.grouping().empty()) {
+ CPPUNIT_ASSERT( str_res[index++] == dom_fmp.thousands_sep() );
+ }
+ CPPUNIT_ASSERT( str_res[index++] == '2' );
+ CPPUNIT_ASSERT( str_res[index++] == '3' );
+ CPPUNIT_ASSERT( str_res[index++] == '4' );
+ if (dom_fmp.frac_digits() != 0) {
+ CPPUNIT_ASSERT( str_res[index++] == dom_fmp.decimal_point() );
+ }
+ CPPUNIT_ASSERT( str_res[index++] == '5' );
+ CPPUNIT_ASSERT( str_res[index++] == '6' );
+ ++fieldIndex;
+
+ //space cannot be last:
+ if ((fieldIndex < 3) &&
+ dom_fmp.neg_format().field[fieldIndex] == money_base::space) {
+ CPPUNIT_ASSERT( str_res[index++] == ' ' );
+ ++fieldIndex;
+ }
+
+ if (fieldIndex == 3) {
+ //If none is last we should not add anything to the resulting string:
+ if (dom_fmp.neg_format().field[fieldIndex] == money_base::none) {
+ CPPUNIT_ASSERT( index == str_res.size() );
+ } else {
+ CPPUNIT_ASSERT( dom_fmp.neg_format().field[fieldIndex] == money_base::symbol );
+ CPPUNIT_ASSERT( str_res.substr(index, strlen(rl.money_suffix)) == rl.money_suffix );
+ }
+ }
+ }
+
+ //money_get
+ {
+ ios_base::iostate err = ios_base::goodbit;
+# if defined (STLPORT)
+ _STLP_LONGEST_FLOAT_TYPE val;
+# else
+ long double val;
+# endif
+
+ istringstream istr(str_res);
+ fmg.get(istr, istreambuf_iterator<char, char_traits<char> >(), false, ostr, err, val);
+ CPPUNIT_ASSERT( (err & (ios_base::failbit | ios_base::badbit)) == 0 );
+ if (dom_fmp.negative_sign().empty()) {
+ //Without negative sign there is no way to guess the resulting amount sign ("C" locale):
+ CPPUNIT_ASSERT( val == 123456 );
+ }
+ else {
+ CPPUNIT_ASSERT( val == -123456 );
+ }
+ }
+ }
+}
+
+
+// Test for bug in case when number of digits in value less then number
+// of digits in fraction. I.e. '9' should be printed as '0.09',
+// if x.frac_digits() == 2.
+
+void LocaleTest::_money_put_X_bug( const locale& loc, const ref_monetary* prl )
+{
+ const ref_monetary &rl = *prl;
+ CPPUNIT_ASSERT( has_facet<money_put<char> >(loc) );
+ money_put<char> const& fmp = use_facet<money_put<char> >(loc);
+
+ ostringstream ostr;
+ ostr.imbue(loc);
+ ostr << showbase;
+
+ // ostr.str("");
+ // Check value with one decimal digit:
+ {
+ CPPUNIT_ASSERT( (has_facet<moneypunct<char, false> >(loc)) );
+ moneypunct<char, false> const& dom_fmp = use_facet<moneypunct<char, false> >(loc);
+ string str_res;
+ // Check money_put
+ {
+ ostreambuf_iterator<char, char_traits<char> > res = fmp.put(ostr, false, ostr, ' ', 9);
+
+ CPPUNIT_ASSERT( !res.failed() );
+ str_res = ostr.str();
+
+ size_t fieldIndex = 0;
+ size_t index = 0;
+
+ if (dom_fmp.pos_format().field[fieldIndex] == money_base::sign) {
+ CPPUNIT_ASSERT( str_res.substr(index, dom_fmp.positive_sign().size()) == dom_fmp.positive_sign() );
+ index += dom_fmp.positive_sign().size();
+ ++fieldIndex;
+ }
+
+ string::size_type p = strlen( rl.money_prefix );
+ if (p != 0) {
+ CPPUNIT_ASSERT( str_res.substr(index, p) == rl.money_prefix );
+ index += p;
+ ++fieldIndex;
+ }
+ if (dom_fmp.neg_format().field[fieldIndex] == money_base::space ||
+ dom_fmp.neg_format().field[fieldIndex] == money_base::none) {
+ CPPUNIT_ASSERT( str_res[index++] == ' ' );
+ ++fieldIndex;
+ }
+ if (dom_fmp.frac_digits() != 0) {
+ CPPUNIT_ASSERT( str_res[index++] == '0' );
+ CPPUNIT_ASSERT( str_res[index++] == dom_fmp.decimal_point() );
+ for ( int fd = 1; fd < dom_fmp.frac_digits(); ++fd ) {
+ CPPUNIT_ASSERT( str_res[index++] == '0' );
+ }
+ }
+ CPPUNIT_ASSERT( str_res[index++] == '9' );
+ ++fieldIndex;
+
+ //space cannot be last:
+ if ((fieldIndex < 3) &&
+ dom_fmp.neg_format().field[fieldIndex] == money_base::space) {
+ CPPUNIT_ASSERT( str_res[index++] == ' ' );
+ ++fieldIndex;
+ }
+
+ if (fieldIndex == 3) {
+ //If none is last we should not add anything to the resulting string:
+ if (dom_fmp.neg_format().field[fieldIndex] == money_base::none) {
+ CPPUNIT_ASSERT( index == str_res.size() );
+ } else {
+ CPPUNIT_ASSERT( dom_fmp.neg_format().field[fieldIndex] == money_base::symbol );
+ CPPUNIT_ASSERT( str_res.substr(index, strlen(rl.money_suffix)) == rl.money_suffix );
+ }
+ }
+ }
+ }
+
+ ostr.str("");
+ // Check value with two decimal digit:
+ {
+ CPPUNIT_ASSERT( (has_facet<moneypunct<char, false> >(loc)) );
+ moneypunct<char, false> const& dom_fmp = use_facet<moneypunct<char, false> >(loc);
+ string str_res;
+ // Check money_put
+ {
+ ostreambuf_iterator<char, char_traits<char> > res = fmp.put(ostr, false, ostr, ' ', 90);
+
+ CPPUNIT_ASSERT( !res.failed() );
+ str_res = ostr.str();
+
+ size_t fieldIndex = 0;
+ size_t index = 0;
+
+ if (dom_fmp.pos_format().field[fieldIndex] == money_base::sign) {
+ CPPUNIT_ASSERT( str_res.substr(index, dom_fmp.positive_sign().size()) == dom_fmp.positive_sign() );
+ index += dom_fmp.positive_sign().size();
+ ++fieldIndex;
+ }
+
+ string::size_type p = strlen( rl.money_prefix );
+ if (p != 0) {
+ CPPUNIT_ASSERT( str_res.substr(index, p) == rl.money_prefix );
+ index += p;
+ ++fieldIndex;
+ }
+ if (dom_fmp.neg_format().field[fieldIndex] == money_base::space ||
+ dom_fmp.neg_format().field[fieldIndex] == money_base::none) {
+ CPPUNIT_ASSERT( str_res[index++] == ' ' );
+ ++fieldIndex;
+ }
+ if (dom_fmp.frac_digits() != 0) {
+ CPPUNIT_ASSERT( str_res[index++] == '0' );
+ CPPUNIT_ASSERT( str_res[index++] == dom_fmp.decimal_point() );
+ for ( int fd = 1; fd < dom_fmp.frac_digits() - 1; ++fd ) {
+ CPPUNIT_ASSERT( str_res[index++] == '0' );
+ }
+ }
+ CPPUNIT_ASSERT( str_res[index++] == '9' );
+ if (dom_fmp.frac_digits() != 0) {
+ CPPUNIT_ASSERT( str_res[index++] == '0' );
+ }
+ ++fieldIndex;
+
+ //space cannot be last:
+ if ((fieldIndex < 3) &&
+ dom_fmp.neg_format().field[fieldIndex] == money_base::space) {
+ CPPUNIT_ASSERT( str_res[index++] == ' ' );
+ ++fieldIndex;
+ }
+
+ if (fieldIndex == 3) {
+ //If none is last we should not add anything to the resulting string:
+ if (dom_fmp.neg_format().field[fieldIndex] == money_base::none) {
+ CPPUNIT_ASSERT( index == str_res.size() );
+ } else {
+ CPPUNIT_ASSERT( dom_fmp.neg_format().field[fieldIndex] == money_base::symbol );
+ CPPUNIT_ASSERT( str_res.substr(index, strlen(rl.money_suffix)) == rl.money_suffix );
+ }
+ }
+ }
+ }
+}
+
+typedef void (LocaleTest::*_Test) (const locale&, const ref_monetary*);
+static void test_supported_locale(LocaleTest& inst, _Test __test) {
+ size_t n = sizeof(tested_locales) / sizeof(tested_locales[0]);
+ for (size_t i = 0; i < n; ++i) {
+ locale loc;
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ try
+# endif
+ {
+ locale tmp(tested_locales[i].name);
+ loc = tmp;
+ }
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ catch (runtime_error const&) {
+ //This locale is not supported.
+ continue;
+ }
+# endif
+ CPPUNIT_MESSAGE( loc.name().c_str() );
+ (inst.*__test)(loc, tested_locales + i);
+
+ {
+ locale tmp(locale::classic(), tested_locales[i].name, locale::monetary);
+ loc = tmp;
+ }
+ (inst.*__test)(loc, tested_locales + i);
+
+ {
+ locale tmp0(locale::classic(), new moneypunct_byname<char, true>(tested_locales[i].name));
+ locale tmp1(tmp0, new moneypunct_byname<char, false>(tested_locales[i].name));
+ loc = tmp1;
+ }
+ (inst.*__test)(loc, tested_locales + i);
+ }
+}
+
+void LocaleTest::money_put_get()
+{ test_supported_locale(*this, &LocaleTest::_money_put_get); }
+
+void LocaleTest::money_put_X_bug()
+{ test_supported_locale(*this, &LocaleTest::_money_put_X_bug); }
+
+void LocaleTest::moneypunct_by_name()
+{
+ /*
+ * Check of the 22.1.1.2.7 standard point. Construction of a locale
+ * instance from a null pointer or an unknown name should result in
+ * a runtime_error exception.
+ */
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+# if defined (STLPORT) || !defined (__GNUC__)
+ try {
+ locale loc(locale::classic(), new moneypunct_byname<char, true>(static_cast<char const*>(0)));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+
+ try {
+ locale loc(locale::classic(), new moneypunct_byname<char, true>("yasli_language"));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ string veryLongFacetName("LC_MONETARY=");
+ veryLongFacetName.append(512, '?');
+ locale loc(locale::classic(), new moneypunct_byname<char, true>(veryLongFacetName.c_str()));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+# if defined (STLPORT) || !defined (__GNUC__)
+ try {
+ locale loc(locale::classic(), new moneypunct_byname<char, false>(static_cast<char const*>(0)));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+
+ try {
+ locale loc(locale::classic(), new moneypunct_byname<char, false>("yasli_language"));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ string veryLongFacetName("LC_MONETARY=");
+ veryLongFacetName.append(512, '?');
+ locale loc(locale::classic(), new moneypunct_byname<char, false>(veryLongFacetName.c_str()));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ locale loc(locale::classic(), new moneypunct_byname<char, false>("C"));
+ moneypunct<char, false> const& cfacet_byname = use_facet<moneypunct<char, false> >(loc);
+ moneypunct<char, false> const& cfacet = use_facet<moneypunct<char, false> >(locale::classic());
+
+ money_base::pattern cp = cfacet.pos_format();
+ money_base::pattern cp_bn = cfacet_byname.pos_format();
+ CPPUNIT_CHECK( cp_bn.field[0] == cp.field[0] );
+ CPPUNIT_CHECK( cp_bn.field[1] == cp.field[1] );
+ CPPUNIT_CHECK( cp_bn.field[2] == cp.field[2] );
+ CPPUNIT_CHECK( cp_bn.field[3] == cp.field[3] );
+
+ CPPUNIT_CHECK( cfacet_byname.frac_digits() == cfacet.frac_digits() );
+ if (cfacet_byname.frac_digits() != 0)
+ CPPUNIT_CHECK( cfacet_byname.decimal_point() == cfacet.decimal_point() );
+ CPPUNIT_CHECK( cfacet_byname.grouping() == cfacet.grouping() );
+ if (!cfacet_byname.grouping().empty())
+ CPPUNIT_CHECK( cfacet_byname.thousands_sep() == cfacet.thousands_sep() );
+ CPPUNIT_CHECK( cfacet_byname.positive_sign() == cfacet.positive_sign() );
+ CPPUNIT_CHECK( cfacet_byname.negative_sign() == cfacet.negative_sign() );
+ }
+ catch (runtime_error const& /* e */) {
+ /* CPPUNIT_MESSAGE( e.what() ); */
+ CPPUNIT_FAIL;
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ locale loc(locale::classic(), new moneypunct_byname<char, true>("C"));
+ moneypunct<char, true> const& cfacet_byname = use_facet<moneypunct<char, true> >(loc);
+ moneypunct<char, true> const& cfacet = use_facet<moneypunct<char, true> >(locale::classic());
+
+ money_base::pattern cp = cfacet.pos_format();
+ money_base::pattern cp_bn = cfacet_byname.pos_format();
+ CPPUNIT_CHECK( cp_bn.field[0] == cp.field[0] );
+ CPPUNIT_CHECK( cp_bn.field[1] == cp.field[1] );
+ CPPUNIT_CHECK( cp_bn.field[2] == cp.field[2] );
+ CPPUNIT_CHECK( cp_bn.field[3] == cp.field[3] );
+
+ CPPUNIT_CHECK( cfacet_byname.frac_digits() == cfacet.frac_digits() );
+ if (cfacet_byname.frac_digits() != 0)
+ CPPUNIT_CHECK( cfacet_byname.decimal_point() == cfacet.decimal_point() );
+ CPPUNIT_CHECK( cfacet_byname.grouping() == cfacet.grouping() );
+ if (!cfacet_byname.grouping().empty())
+ CPPUNIT_CHECK( cfacet_byname.thousands_sep() == cfacet.thousands_sep() );
+ CPPUNIT_CHECK( cfacet_byname.positive_sign() == cfacet.positive_sign() );
+ CPPUNIT_CHECK( cfacet_byname.negative_sign() == cfacet.negative_sign() );
+ }
+ catch (runtime_error const& /* e */) {
+ /* CPPUNIT_MESSAGE( e.what() ); */
+ CPPUNIT_FAIL;
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ // On platform without real localization support we should rely on the "C" locale facet.
+ locale loc(locale::classic(), new moneypunct_byname<char, false>(""));
+ }
+ catch (runtime_error const& /* e */) {
+ /* CPPUNIT_MESSAGE( e.what() ); */
+ CPPUNIT_FAIL;
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+# if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
+# if defined (STLPORT) || !defined (__GNUC__)
+ try {
+ locale loc(locale::classic(), new moneypunct_byname<wchar_t, true>(static_cast<char const*>(0)));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+
+ try {
+ locale loc(locale::classic(), new moneypunct_byname<wchar_t, true>("yasli_language"));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+# if defined (STLPORT) || !defined (__GNUC__)
+ try {
+ locale loc(locale::classic(), new moneypunct_byname<wchar_t, false>(static_cast<char const*>(0)));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+
+ try {
+ locale loc(locale::classic(), new moneypunct_byname<wchar_t, false>("yasli_language"));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+# endif
+}
+
+#endif
diff --git a/sources/android/stlport/test/unit/multiset_test.cpp b/sources/android/stlport/test/unit/multiset_test.cpp
new file mode 100644
index 0000000..3e30917
--- /dev/null
+++ b/sources/android/stlport/test/unit/multiset_test.cpp
@@ -0,0 +1,127 @@
+#include <set>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class MultisetTest : public CPPUNIT_NS::TestCase
+{
+ typedef multiset<int, less<int> > mset;
+
+ CPPUNIT_TEST_SUITE(MultisetTest);
+ CPPUNIT_TEST(mset1);
+ CPPUNIT_TEST(mset3);
+ CPPUNIT_TEST(mset5);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void mset1();
+ void mset3();
+ void mset5();
+
+ static bool less_than(int a_, int b_)
+ {
+ return a_ < b_;
+ }
+
+ static bool greater_than(int a_, int b_)
+ {
+ return a_ > b_;
+ }
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(MultisetTest);
+
+//
+// tests implementation
+//
+void MultisetTest::mset1()
+{
+ mset s;
+ CPPUNIT_ASSERT(s.count(42) == 0);
+ s.insert(42);
+ CPPUNIT_ASSERT(s.count(42) == 1);
+ s.insert(42);
+ CPPUNIT_ASSERT(s.count(42) == 2);
+
+ mset::iterator i = s.find(40);
+ CPPUNIT_ASSERT(i == s.end());
+
+ i = s.find(42);
+ CPPUNIT_ASSERT(i != s.end());
+ size_t count = s.erase(42);
+ CPPUNIT_ASSERT(count == 2);
+}
+void MultisetTest::mset3()
+{
+ int array [] = { 3, 6, 1, 2, 3, 2, 6, 7, 9 };
+
+ //Check iterator on a mutable set
+ mset s(array, array + 9);
+ mset::iterator i;
+ i = s.lower_bound(3);
+ CPPUNIT_ASSERT(*i == 3);
+ i = s.upper_bound(3);
+ CPPUNIT_ASSERT(*i == 6);
+ pair<mset::iterator, mset::iterator> p = s.equal_range(5);
+ CPPUNIT_ASSERT(*(p.first) == 6);
+ CPPUNIT_ASSERT(*(p.second) == 6);
+
+ //Check const_iterator on a mutable multiset
+ mset::const_iterator ci;
+ ci = s.lower_bound(3);
+ CPPUNIT_ASSERT(*ci == 3);
+ ci = s.upper_bound(3);
+ CPPUNIT_ASSERT(*ci == 6);
+ pair<mset::const_iterator, mset::const_iterator> cp;
+#ifdef _STLP_MEMBER_TEMPLATES
+ cp = s.equal_range(5);
+ CPPUNIT_ASSERT(*(cp.first) == 6);
+ CPPUNIT_ASSERT(*(cp.second) == 6);
+#endif
+
+ //Check const_iterator on a const multiset
+ mset const& crs = s;
+ ci = crs.lower_bound(3);
+ CPPUNIT_ASSERT(*ci == 3);
+ ci = crs.upper_bound(3);
+ CPPUNIT_ASSERT(*ci == 6);
+ cp = crs.equal_range(5);
+ CPPUNIT_ASSERT(*(cp.first) == 6);
+ CPPUNIT_ASSERT(*(cp.second) == 6);
+}
+void MultisetTest::mset5()
+{
+ int array [] = { 3, 6, 1, 9 };
+ int j;
+
+ typedef pointer_to_binary_function<int, int, bool> fn_type;
+ typedef multiset<int, fn_type, allocator<int> > fn_mset;
+
+ fn_type f(less_than);
+ fn_mset s1(array+0, array + 4 , f );
+ fn_mset::const_iterator i = s1.begin();
+ for (j = 0; i != s1.end(); ++i, ++j) {
+ CPPUNIT_ASSERT(j != 0 || *i == 1);
+ CPPUNIT_ASSERT(j != 1 || *i == 3);
+ CPPUNIT_ASSERT(j != 2 || *i == 6);
+ CPPUNIT_ASSERT(j != 3 || *i == 9);
+ }
+
+ fn_type g(greater_than);
+ fn_mset s2(array, array + 4, g);
+ i = s2.begin();
+ for (j = 0; i != s2.end(); ++i, ++j) {
+ CPPUNIT_ASSERT(j != 0 || *i == 9);
+ CPPUNIT_ASSERT(j != 1 || *i == 6);
+ CPPUNIT_ASSERT(j != 2 || *i == 3);
+ CPPUNIT_ASSERT(j != 3 || *i == 1);
+ }
+
+}
diff --git a/sources/android/stlport/test/unit/mvctor_declaration_test.cpp b/sources/android/stlport/test/unit/mvctor_declaration_test.cpp
new file mode 100644
index 0000000..cb6f8a3
--- /dev/null
+++ b/sources/android/stlport/test/unit/mvctor_declaration_test.cpp
@@ -0,0 +1,369 @@
+#include <vector>
+#include <algorithm>
+#include <string>
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+# include <rope>
+#endif
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+# include <slist>
+#endif
+#include <list>
+#include <deque>
+#include <set>
+#include <map>
+#if defined (STLPORT)
+# include <unordered_set>
+# include <unordered_map>
+#endif
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+# include <hash_set>
+# include <hash_map>
+#endif
+#include <queue>
+#include <stack>
+
+#include "mvctor_test.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+# if defined (STLPORT)
+using namespace std::tr1;
+# endif
+#endif
+
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+
+# if defined (__GNUC__) && defined (_STLP_USE_NAMESPACES)
+// libstdc++ sometimes exposed its own __true_type in
+// global namespace resulting in an ambiguity.
+# define __true_type std::__true_type
+# define __false_type std::__false_type
+# endif
+
+static bool type_to_bool(__true_type)
+{ return true; }
+static bool type_to_bool(__false_type)
+{ return false; }
+
+template <class _Tp>
+static bool is_movable(const _Tp&) {
+ typedef typename __move_traits<_Tp>::implemented _MovableTp;
+ return type_to_bool(_MovableTp());
+}
+
+template <class _Tp>
+static bool is_move_complete(const _Tp&) {
+ typedef __move_traits<_Tp> _TpMoveTraits;
+ typedef typename _TpMoveTraits::complete _TpMoveComplete;
+ return type_to_bool(_TpMoveComplete());
+}
+
+struct specially_allocated_struct {
+ bool operator < (const specially_allocated_struct&) const;
+# if defined (__DMC__) // slist<_Tp,_Alloc>::remove error
+ bool operator==(const specially_allocated_struct&) const;
+# endif
+};
+
+#if defined (__DMC__)
+bool specially_allocated_struct::operator < (const specially_allocated_struct&) const
+{ return false; }
+#endif
+
+struct struct_with_specialized_less {};
+
+# if defined (_STLP_USE_NAMESPACES)
+namespace std {
+# endif
+ _STLP_TEMPLATE_NULL
+ class allocator<specially_allocated_struct> {
+ //This allocator just represent what a STLport could do and in this
+ //case the STL containers implemented with it should still be movable
+ //but not completely as we cannot do any hypothesis on what is in this
+ //allocator.
+ public:
+ typedef specially_allocated_struct value_type;
+ typedef value_type * pointer;
+ typedef const value_type* const_pointer;
+ typedef value_type& reference;
+ typedef const value_type& const_reference;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+# if defined (_STLP_MEMBER_TEMPLATE_CLASSES)
+ template <class _Tp1> struct rebind {
+ typedef allocator<_Tp1> other;
+ };
+# endif
+ allocator() _STLP_NOTHROW {}
+# if defined (_STLP_MEMBER_TEMPLATES)
+ template <class _Tp1> allocator(const allocator<_Tp1>&) _STLP_NOTHROW {}
+# endif
+ allocator(const allocator&) _STLP_NOTHROW {}
+ ~allocator() _STLP_NOTHROW {}
+ pointer address(reference __x) const { return &__x; }
+ const_pointer address(const_reference __x) const { return &__x; }
+ pointer allocate(size_type, const void* = 0) { return 0; }
+ void deallocate(pointer, size_type) {}
+ size_type max_size() const _STLP_NOTHROW { return 0; }
+ void construct(pointer, const_reference) {}
+ void destroy(pointer) {}
+ };
+
+ _STLP_TEMPLATE_NULL
+ struct less<struct_with_specialized_less> {
+ bool operator() (struct_with_specialized_less const&,
+ struct_with_specialized_less const&) const;
+ };
+
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+# if !defined (_STLP_NO_MOVE_SEMANTIC)
+# if defined (__BORLANDC__) && (__BORLANDC__ >= 0x564)
+ _STLP_TEMPLATE_NULL
+ struct __move_traits<vector<specially_allocated_struct> > {
+ typedef __true_type implemented;
+ typedef __false_type complete;
+ };
+ _STLP_TEMPLATE_NULL
+ struct __move_traits<deque<specially_allocated_struct> > {
+ typedef __true_type implemented;
+ typedef __false_type complete;
+ };
+ _STLP_TEMPLATE_NULL
+ struct __move_traits<list<specially_allocated_struct> > {
+ typedef __true_type implemented;
+ typedef __false_type complete;
+ };
+ _STLP_TEMPLATE_NULL
+ struct __move_traits<slist<specially_allocated_struct> > {
+ typedef __true_type implemented;
+ typedef __false_type complete;
+ };
+ _STLP_TEMPLATE_NULL
+ struct __move_traits<less<struct_with_specialized_less> > {
+ typedef __true_type implemented;
+ typedef __false_type complete;
+ };
+ _STLP_TEMPLATE_NULL
+ struct __move_traits<set<specially_allocated_struct> > {
+ typedef __true_type implemented;
+ typedef __false_type complete;
+ };
+ _STLP_TEMPLATE_NULL
+ struct __move_traits<multiset<specially_allocated_struct> > {
+ typedef __true_type implemented;
+ typedef __false_type complete;
+ };
+# endif
+# endif
+# endif
+
+# if defined (_STLP_USE_NAMESPACES)
+}
+# endif
+#endif
+
+void MoveConstructorTest::movable_declaration()
+{
+#if defined (STLPORT) && !defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS) && \
+ !defined (_STLP_NO_MOVE_SEMANTIC)
+ //This test purpose is to check correct detection of the STL movable
+ //traits declaration
+ {
+ //string, wstring:
+ CPPUNIT_ASSERT( is_movable(string()) );
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_ASSERT( is_move_complete(string()) );
+# else
+ CPPUNIT_ASSERT( !is_move_complete(string()) );
+# endif
+# if defined (_STLP_HAS_WCHAR_T)
+ CPPUNIT_ASSERT( is_movable(wstring()) );
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_ASSERT( is_move_complete(wstring()) );
+# else
+ CPPUNIT_ASSERT( !is_move_complete(wstring()) );
+# endif
+# endif
+ }
+
+# if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ {
+ //crope, wrope:
+ CPPUNIT_ASSERT( is_movable(crope()) );
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_ASSERT( is_move_complete(crope()) );
+# else
+ CPPUNIT_ASSERT( !is_move_complete(crope()) );
+# endif
+# if defined (_STLP_HAS_WCHAR_T)
+ CPPUNIT_ASSERT( is_movable(wrope()) );
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_ASSERT( is_move_complete(wrope()) );
+# else
+ CPPUNIT_ASSERT( !is_move_complete(wrope()) );
+# endif
+# endif
+ }
+# endif
+
+ {
+ //vector:
+ CPPUNIT_ASSERT( is_movable(vector<char>()) );
+ CPPUNIT_ASSERT( is_movable(vector<specially_allocated_struct>()) );
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_ASSERT( is_move_complete(vector<char>()) );
+ CPPUNIT_ASSERT( !is_move_complete(vector<specially_allocated_struct>()) );
+# else
+ CPPUNIT_ASSERT( !is_move_complete(vector<char>()) );
+# endif
+ }
+
+ {
+ //deque:
+ CPPUNIT_ASSERT( is_movable(deque<char>()) );
+ CPPUNIT_ASSERT( is_movable(deque<specially_allocated_struct>()) );
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_ASSERT( is_move_complete(deque<char>()) );
+ CPPUNIT_ASSERT( !is_move_complete(deque<specially_allocated_struct>()) );
+# else
+ CPPUNIT_ASSERT( !is_move_complete(deque<char>()) );
+# endif
+ }
+
+ {
+ //list:
+ CPPUNIT_ASSERT( is_movable(list<char>()) );
+ CPPUNIT_ASSERT( is_movable(list<specially_allocated_struct>()) );
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_ASSERT( is_move_complete(list<char>()) );
+ CPPUNIT_ASSERT( !is_move_complete(list<specially_allocated_struct>()) );
+# else
+ CPPUNIT_ASSERT( !is_move_complete(list<char>()) );
+# endif
+ }
+
+# if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ {
+ //slist:
+ CPPUNIT_ASSERT( is_movable(slist<char>()) );
+ CPPUNIT_ASSERT( is_movable(slist<specially_allocated_struct>()) );
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_ASSERT( is_move_complete(slist<char>()) );
+ CPPUNIT_ASSERT( !is_move_complete(slist<specially_allocated_struct>()) );
+# else
+ CPPUNIT_ASSERT( !is_move_complete(slist<char>()) );
+# endif
+ }
+# endif
+
+ {
+ //queue:
+ CPPUNIT_ASSERT( is_movable(queue<char>()) );
+ CPPUNIT_ASSERT( is_movable(queue<specially_allocated_struct>()) );
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_ASSERT( is_move_complete(queue<char>()) );
+ CPPUNIT_ASSERT( !is_move_complete(queue<specially_allocated_struct>()) );
+# else
+ CPPUNIT_ASSERT( !is_move_complete(queue<char>()) );
+# endif
+ }
+
+ {
+ //stack:
+ CPPUNIT_ASSERT( is_movable(stack<char>()) );
+ CPPUNIT_ASSERT( is_movable(stack<specially_allocated_struct>()) );
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_ASSERT( is_move_complete(stack<char>()) );
+ CPPUNIT_ASSERT( !is_move_complete(stack<specially_allocated_struct>()) );
+# else
+ CPPUNIT_ASSERT( !is_move_complete(stack<char>()) );
+# endif
+ }
+
+#endif
+}
+
+void MoveConstructorTest::movable_declaration_assoc()
+{
+#if defined (STLPORT) && !defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS) && \
+ !defined (_STLP_NO_MOVE_SEMANTIC)
+ {
+ //associative containers, set multiset, map, multimap:
+
+ //For associative containers it is important that less is correctly recognize as
+ //the STLport less or a user specialized less:
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_ASSERT( is_move_complete(less<char>()) );
+# endif
+ CPPUNIT_ASSERT( !is_move_complete(less<struct_with_specialized_less>()) );
+
+ //set
+ CPPUNIT_ASSERT( is_movable(set<char>()) );
+ CPPUNIT_ASSERT( is_movable(set<specially_allocated_struct>()) );
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_ASSERT( is_move_complete(set<char>()) );
+ CPPUNIT_ASSERT( !is_move_complete(set<specially_allocated_struct>()) );
+# else
+ CPPUNIT_ASSERT( !is_move_complete(set<char>()) );
+# endif
+
+ //multiset
+ CPPUNIT_ASSERT( is_movable(multiset<char>()) );
+ CPPUNIT_ASSERT( is_movable(multiset<specially_allocated_struct>()) );
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_ASSERT( is_move_complete(multiset<char>()) );
+ CPPUNIT_ASSERT( !is_move_complete(multiset<specially_allocated_struct>()) );
+# else
+ CPPUNIT_ASSERT( !is_move_complete(multiset<char>()) );
+# endif
+
+ //map
+ CPPUNIT_ASSERT( is_movable(map<char, char>()) );
+ CPPUNIT_ASSERT( is_movable(map<specially_allocated_struct, char>()) );
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_ASSERT( is_move_complete(map<char, char>()) );
+ //Here even if allocator has been specialized for specially_allocated_struct
+ //this pecialization won't be used in default map instanciation as the default
+ //allocator is allocator<pair<specially_allocated_struct, char> >
+ CPPUNIT_ASSERT( is_move_complete(map<specially_allocated_struct, char>()) );
+# else
+ CPPUNIT_ASSERT( !is_move_complete(map<char, char>()) );
+# endif
+
+ //multimap
+ CPPUNIT_ASSERT( is_movable(multimap<char, char>()) );
+ CPPUNIT_ASSERT( is_movable(multimap<specially_allocated_struct, char>()) );
+# if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_ASSERT( is_move_complete(multimap<char, char>()) );
+ //Idem map remark
+ CPPUNIT_ASSERT( is_move_complete(multimap<specially_allocated_struct, char>()) );
+# else
+ CPPUNIT_ASSERT( !is_move_complete(multimap<char, char>()) );
+# endif
+ }
+#endif
+}
+
+void MoveConstructorTest::movable_declaration_hash()
+{
+#if defined (STLPORT) && !defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS) && \
+ !defined (_STLP_NO_MOVE_SEMANTIC)
+ {
+ //hashed containers, unordered_set unordered_multiset, unordered_map, unordered_multimap,
+ // hash_set, hash_multiset, hash_map, hash_multimap:
+
+ //We only check that they are movable, completness is not yet supported
+ CPPUNIT_ASSERT( is_movable(unordered_set<char>()) );
+ CPPUNIT_ASSERT( is_movable(unordered_multiset<char>()) );
+ CPPUNIT_ASSERT( is_movable(unordered_map<char, char>()) );
+ CPPUNIT_ASSERT( is_movable(unordered_multimap<char, char>()) );
+# if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ CPPUNIT_ASSERT( is_movable(hash_set<char>()) );
+ CPPUNIT_ASSERT( is_movable(hash_multiset<char>()) );
+ CPPUNIT_ASSERT( is_movable(hash_map<char, char>()) );
+ CPPUNIT_ASSERT( is_movable(hash_multimap<char, char>()) );
+# endif
+ }
+#endif
+}
+
diff --git a/sources/android/stlport/test/unit/mvctor_test.cpp b/sources/android/stlport/test/unit/mvctor_test.cpp
new file mode 100644
index 0000000..ddac32f
--- /dev/null
+++ b/sources/android/stlport/test/unit/mvctor_test.cpp
@@ -0,0 +1,816 @@
+#include <vector>
+#include <algorithm>
+#include <string>
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+# include <slist>
+#endif
+#include <list>
+#include <deque>
+#include <set>
+#if defined (STLPORT)
+# include <unordered_set>
+#endif
+
+#include "mvctor_test.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+# if defined (STLPORT)
+using namespace std::tr1;
+# endif
+#endif
+
+CPPUNIT_TEST_SUITE_REGISTRATION(MoveConstructorTest);
+
+//
+// tests implementation
+//
+void MoveConstructorTest::move_construct_test()
+{
+ //cout << "vector<vector<int>>";
+ vector<int> const ref_vec(10, 0);
+ vector<vector<int> > v_v_ints(1, ref_vec);
+
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ int *pint = &(v_v_ints.front().front());
+#endif
+
+ size_t cur_capacity = v_v_ints.capacity();
+ while (v_v_ints.capacity() <= cur_capacity) {
+ v_v_ints.push_back(ref_vec);
+ }
+
+ //v_v_ints has been resized
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT((pint == &v_v_ints.front().front()));
+#endif
+
+ //cout << "vector<vector<int>>::erase";
+ //We need at least 3 elements:
+ while (v_v_ints.size() < 3) {
+ v_v_ints.push_back(ref_vec);
+ }
+
+ //We erase the 2nd
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ pint = &v_v_ints[2].front();
+#endif
+ v_v_ints.erase(v_v_ints.begin() + 1);
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT((pint == &v_v_ints[1].front()));
+#endif
+
+ //cout << "vector<string>";
+ string const ref_str("ref string, big enough to be a dynamic one");
+ vector<string> vec_strs(1, ref_str);
+
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ char const* pstr = vec_strs.front().c_str();
+#endif
+ cur_capacity = vec_strs.capacity();
+ while (vec_strs.capacity() <= cur_capacity) {
+ vec_strs.push_back(ref_str);
+ }
+
+ //vec_str has been resized
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT((pstr == vec_strs.front().c_str()));
+#endif
+
+ //cout << "vector<string>::erase";
+ //We need at least 3 elements:
+ while (vec_strs.size() < 3) {
+ vec_strs.push_back(ref_str);
+ }
+
+ //We erase the 2nd
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ pstr = vec_strs[2].c_str();
+#endif
+ vec_strs.erase(vec_strs.begin() + 1);
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT((pstr == vec_strs[1].c_str()));
+#endif
+
+ //cout << "swap(vector<int>, vector<int>)";
+ vector<int> elem1(10, 0), elem2(10, 0);
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ int *p1 = &elem1.front();
+ int *p2 = &elem2.front();
+#endif
+ swap(elem1, elem2);
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT(((p1 == &elem2.front()) && (p2 == &elem1.front())));
+#endif
+
+ {
+ vector<bool> bit_vec(5, true);
+ bit_vec.insert(bit_vec.end(), 5, false);
+ vector<vector<bool> > v_v_bits(1, bit_vec);
+
+ /*
+ * This is a STLport specific test as we are using internal implementation
+ * details to check that the move has been correctly handled. For other
+ * STL implementation it is only a compile check.
+ */
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+# if defined (_STLP_DEBUG)
+ unsigned int *punit = v_v_bits.front().begin()._M_iterator._M_p;
+# else
+ unsigned int *punit = v_v_bits.front().begin()._M_p;
+# endif
+#endif
+
+ cur_capacity = v_v_bits.capacity();
+ while (v_v_bits.capacity() <= cur_capacity) {
+ v_v_bits.push_back(bit_vec);
+ }
+
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ //v_v_bits has been resized
+# if defined (_STLP_DEBUG)
+ CPPUNIT_ASSERT( punit == v_v_bits.front().begin()._M_iterator._M_p );
+# else
+ CPPUNIT_ASSERT( punit == v_v_bits.front().begin()._M_p );
+# endif
+#endif
+ }
+
+ // zero: don't like this kind of tests
+ // because of template test function
+ // we should find another way to provide
+ // move constructor testing...
+
+/*
+ standard_test1(list<int>(10));
+
+
+ standard_test1(slist<int>(10));
+
+ standard_test1(deque<int>(10));
+*/
+
+ /*
+ int int_values[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+
+ set<int> int_set(int_values, int_values + sizeof(in_values) / sizeof(int));
+ standard_test1(int_set);
+
+ multiset<int> int_multiset(int_values, int_values + sizeof(in_values) / sizeof(int));
+ standard_test1(int_multiset);
+ */
+
+ /*
+ CheckFullMoveSupport(string());
+ CheckFullMoveSupport(vector<int>());
+ CheckFullMoveSupport(deque<int>());
+ CheckFullMoveSupport(list<int>());
+ CheckFullMoveSupport(slist<int>());
+ */
+}
+
+void MoveConstructorTest::deque_test()
+{
+ //Check the insert range method.
+ //To the front:
+ {
+# if !defined (STLPORT) || !defined (_STLP_DEBUG) || !defined (_STLP_NO_MEMBER_TEMPLATES)
+ deque<vector<int> > vect_deque;
+ vector<int*> bufs;
+ vect_deque.assign(3, vector<int>(10));
+ bufs.push_back(&vect_deque[0].front());
+ bufs.push_back(&vect_deque[1].front());
+ bufs.push_back(&vect_deque[2].front());
+
+ int nb_insert = 5;
+ //Initialize to 1 to generate a front insertion:
+ int pos = 1;
+ while (nb_insert--) {
+ vector<vector<int> > vect_vect(2, vector<int>(10));
+ vect_deque.insert(vect_deque.begin() + pos, vect_vect.begin(), vect_vect.end());
+ bufs.insert(bufs.begin() + pos, &vect_deque[pos].front());
+ bufs.insert(bufs.begin() + pos + 1, &vect_deque[pos + 1].front());
+ ++pos;
+ }
+ CPPUNIT_ASSERT( vect_deque.size() == 13 );
+# if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ for (int i = 0; i < 5; ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &vect_deque[i].front() );
+ CPPUNIT_ASSERT( bufs[11 - i] == &vect_deque[11 - i].front() );
+ }
+# endif
+# endif
+ }
+
+ //To the back
+ {
+# if !defined (STLPORT) || !defined (_STLP_DEBUG) || !defined (_STLP_NO_MEMBER_TEMPLATES)
+ deque<vector<int> > vect_deque;
+ vector<int*> bufs;
+ vect_deque.assign(3, vector<int>(10));
+ bufs.push_back(&vect_deque[0].front());
+ bufs.push_back(&vect_deque[1].front());
+ bufs.push_back(&vect_deque[2].front());
+
+ int nb_insert = 5;
+ //Initialize to 2 to generate a back insertion:
+ int pos = 2;
+ while (nb_insert--) {
+ vector<vector<int> > vect_vect(2, vector<int>(10));
+ vect_deque.insert(vect_deque.begin() + pos, vect_vect.begin(), vect_vect.end());
+ bufs.insert(bufs.begin() + pos, &vect_deque[pos].front());
+ bufs.insert(bufs.begin() + pos + 1, &vect_deque[pos + 1].front());
+ ++pos;
+ }
+ CPPUNIT_ASSERT( vect_deque.size() == 13 );
+# if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ for (int i = 0; i < 5; ++i) {
+ CPPUNIT_ASSERT( bufs[i + 1] == &vect_deque[i + 1].front() );
+ CPPUNIT_ASSERT( bufs[12 - i] == &vect_deque[12 - i].front() );
+ }
+# endif
+# endif
+ }
+
+ //Check the different erase methods.
+ {
+ deque<vector<int> > vect_deque;
+ vect_deque.assign(20, vector<int>(10));
+ deque<vector<int> >::iterator vdit(vect_deque.begin()), vditEnd(vect_deque.end());
+ vector<int*> bufs;
+ for (; vdit != vditEnd; ++vdit) {
+ bufs.push_back(&vdit->front());
+ }
+
+ {
+ // This check, repeated after each operation, check the deque consistency:
+ deque<vector<int> >::iterator it = vect_deque.end() - 5;
+ int nb_incr = 0;
+ for (; it != vect_deque.end() && nb_incr <= 6; ++nb_incr, ++it) {}
+ CPPUNIT_ASSERT( nb_incr == 5 );
+ }
+
+ {
+ //erase in front:
+ vect_deque.erase(vect_deque.begin() + 2);
+ bufs.erase(bufs.begin() + 2);
+ CPPUNIT_ASSERT( vect_deque.size() == 19 );
+ deque<vector<int> >::iterator dit(vect_deque.begin()), ditEnd(vect_deque.end());
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ for (size_t i = 0; dit != ditEnd; ++dit, ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &dit->front() );
+ }
+#endif
+ }
+
+ {
+ deque<vector<int> >::iterator it = vect_deque.end() - 5;
+ int nb_incr = 0;
+ for (; it != vect_deque.end() && nb_incr <= 6; ++nb_incr, ++it) {}
+ CPPUNIT_ASSERT( nb_incr == 5 );
+ }
+
+ {
+ //erase in the back:
+ vect_deque.erase(vect_deque.end() - 2);
+ bufs.erase(bufs.end() - 2);
+ CPPUNIT_ASSERT( vect_deque.size() == 18 );
+ deque<vector<int> >::iterator dit(vect_deque.begin()), ditEnd(vect_deque.end());
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ for (size_t i = 0; dit != ditEnd; ++dit, ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &dit->front() );
+ }
+#endif
+ }
+
+ {
+ deque<vector<int> >::iterator it = vect_deque.end() - 5;
+ int nb_incr = 0;
+ for (; it != vect_deque.end() && nb_incr < 6; ++nb_incr, ++it) {}
+ CPPUNIT_ASSERT( nb_incr == 5 );
+ }
+
+ {
+ //range erase in front
+ vect_deque.erase(vect_deque.begin() + 3, vect_deque.begin() + 5);
+ bufs.erase(bufs.begin() + 3, bufs.begin() + 5);
+ CPPUNIT_ASSERT( vect_deque.size() == 16 );
+ deque<vector<int> >::iterator dit(vect_deque.begin()), ditEnd(vect_deque.end());
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ for (size_t i = 0; dit != ditEnd; ++dit, ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &dit->front() );
+ }
+#endif
+ }
+
+ {
+ deque<vector<int> >::iterator it = vect_deque.end() - 5;
+ int nb_incr = 0;
+ for (; it != vect_deque.end() && nb_incr <= 6; ++nb_incr, ++it) {}
+ CPPUNIT_ASSERT( nb_incr == 5 );
+ }
+
+ {
+ //range erase in back
+ vect_deque.erase(vect_deque.end() - 5, vect_deque.end() - 3);
+ bufs.erase(bufs.end() - 5, bufs.end() - 3);
+ CPPUNIT_ASSERT( vect_deque.size() == 14 );
+ deque<vector<int> >::iterator dit(vect_deque.begin()), ditEnd(vect_deque.end());
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ for (size_t i = 0; dit != ditEnd; ++dit, ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &dit->front() );
+ }
+#endif
+ }
+ }
+
+ //Check the insert value(s)
+ {
+ deque<vector<int> > vect_deque;
+ vect_deque.assign(20, vector<int>(10));
+ deque<vector<int> >::iterator vdit(vect_deque.begin()), vditEnd(vect_deque.end());
+ vector<int*> bufs;
+ for (; vdit != vditEnd; ++vdit) {
+ bufs.push_back(&vdit->front());
+ }
+
+ {
+ //2 values in front:
+ vect_deque.insert(vect_deque.begin() + 2, 2, vector<int>(10));
+ bufs.insert(bufs.begin() + 2, &vect_deque[2].front());
+ bufs.insert(bufs.begin() + 3, &vect_deque[3].front());
+ CPPUNIT_ASSERT( vect_deque.size() == 22 );
+ deque<vector<int> >::iterator dit(vect_deque.begin()), ditEnd(vect_deque.end());
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ for (size_t i = 0; dit != ditEnd; ++dit, ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &dit->front() );
+ }
+#endif
+ }
+
+ {
+ //2 values in back:
+ vect_deque.insert(vect_deque.end() - 2, 2, vector<int>(10));
+ bufs.insert(bufs.end() - 2, &vect_deque[20].front());
+ bufs.insert(bufs.end() - 2, &vect_deque[21].front());
+ CPPUNIT_ASSERT( vect_deque.size() == 24 );
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ deque<vector<int> >::iterator dit(vect_deque.begin()), ditEnd(vect_deque.end());
+ for (size_t i = 0; dit != ditEnd; ++dit, ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &dit->front() );
+ }
+#endif
+ }
+
+ {
+ //1 value in front:
+ deque<vector<int> >::iterator ret;
+ ret = vect_deque.insert(vect_deque.begin() + 2, vector<int>(10));
+ bufs.insert(bufs.begin() + 2, &vect_deque[2].front());
+ CPPUNIT_ASSERT( vect_deque.size() == 25 );
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( &ret->front() == bufs[2] );
+ deque<vector<int> >::iterator dit(vect_deque.begin()), ditEnd(vect_deque.end());
+ for (size_t i = 0; dit != ditEnd; ++dit, ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &dit->front() );
+ }
+#endif
+ }
+
+ {
+ //1 value in back:
+ deque<vector<int> >::iterator ret;
+ ret = vect_deque.insert(vect_deque.end() - 2, vector<int>(10));
+ bufs.insert(bufs.end() - 2, &vect_deque[23].front());
+ CPPUNIT_ASSERT( vect_deque.size() == 26 );
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( &ret->front() == bufs[23] );
+ deque<vector<int> >::iterator dit(vect_deque.begin()), ditEnd(vect_deque.end());
+ for (size_t i = 0; dit != ditEnd; ++dit, ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &dit->front() );
+ }
+#endif
+ }
+ }
+}
+
+void MoveConstructorTest::vector_test()
+{
+ //Check the insert range method.
+ //To the front:
+ {
+ vector<vector<int> > vect_vector;
+ vector<int*> bufs;
+ vect_vector.assign(3, vector<int>(10));
+ bufs.push_back(&vect_vector[0].front());
+ bufs.push_back(&vect_vector[1].front());
+ bufs.push_back(&vect_vector[2].front());
+
+ int nb_insert = 5;
+ int pos = 1;
+ while (nb_insert--) {
+ vector<vector<int> > vect_vect(2, vector<int>(10));
+ vect_vector.insert(vect_vector.begin() + pos, vect_vect.begin(), vect_vect.end());
+ bufs.insert(bufs.begin() + pos, &vect_vector[pos].front());
+ bufs.insert(bufs.begin() + pos + 1, &vect_vector[pos + 1].front());
+ ++pos;
+ }
+ CPPUNIT_ASSERT( vect_vector.size() == 13 );
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ for (int i = 0; i < 5; ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &vect_vector[i].front() );
+ CPPUNIT_ASSERT( bufs[11 - i] == &vect_vector[11 - i].front() );
+ }
+#endif
+ }
+
+ //To the back
+ {
+ vector<vector<int> > vect_vector;
+ vector<int*> bufs;
+ vect_vector.assign(3, vector<int>(10));
+ bufs.push_back(&vect_vector[0].front());
+ bufs.push_back(&vect_vector[1].front());
+ bufs.push_back(&vect_vector[2].front());
+
+ int nb_insert = 5;
+ //Initialize to 2 to generate a back insertion:
+ int pos = 2;
+ while (nb_insert--) {
+ vector<vector<int> > vect_vect(2, vector<int>(10));
+ vect_vector.insert(vect_vector.begin() + pos, vect_vect.begin(), vect_vect.end());
+ bufs.insert(bufs.begin() + pos, &vect_vector[pos].front());
+ bufs.insert(bufs.begin() + pos + 1, &vect_vector[pos + 1].front());
+ ++pos;
+ }
+ CPPUNIT_ASSERT( vect_vector.size() == 13 );
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ for (int i = 0; i < 5; ++i) {
+ CPPUNIT_ASSERT( bufs[i + 1] == &vect_vector[i + 1].front() );
+ CPPUNIT_ASSERT( bufs[12 - i] == &vect_vector[12 - i].front() );
+ }
+#endif
+ }
+
+ //Check the different erase methods.
+ {
+ vector<vector<int> > vect_vector;
+ vect_vector.assign(20, vector<int>(10));
+ vector<vector<int> >::iterator vdit(vect_vector.begin()), vditEnd(vect_vector.end());
+ vector<int*> bufs;
+ for (; vdit != vditEnd; ++vdit) {
+ bufs.push_back(&vdit->front());
+ }
+
+ {
+ // This check, repeated after each operation, check the vector consistency:
+ vector<vector<int> >::iterator it = vect_vector.end() - 5;
+ int nb_incr = 0;
+ for (; it != vect_vector.end() && nb_incr <= 6; ++nb_incr, ++it) {}
+ CPPUNIT_ASSERT( nb_incr == 5 );
+ }
+
+ {
+ //erase in front:
+ vect_vector.erase(vect_vector.begin() + 2);
+ bufs.erase(bufs.begin() + 2);
+ CPPUNIT_ASSERT( vect_vector.size() == 19 );
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ vector<vector<int> >::iterator dit(vect_vector.begin()), ditEnd(vect_vector.end());
+ for (size_t i = 0; dit != ditEnd; ++dit, ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &dit->front() );
+ }
+#endif
+ }
+
+ {
+ vector<vector<int> >::iterator it = vect_vector.end() - 5;
+ int nb_incr = 0;
+ for (; it != vect_vector.end() && nb_incr <= 6; ++nb_incr, ++it) {}
+ CPPUNIT_ASSERT( nb_incr == 5 );
+ }
+
+ {
+ //erase in the back:
+ vect_vector.erase(vect_vector.end() - 2);
+ bufs.erase(bufs.end() - 2);
+ CPPUNIT_ASSERT( vect_vector.size() == 18 );
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ vector<vector<int> >::iterator dit(vect_vector.begin()), ditEnd(vect_vector.end());
+ for (size_t i = 0; dit != ditEnd; ++dit, ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &dit->front() );
+ }
+#endif
+ }
+
+ {
+ vector<vector<int> >::iterator it = vect_vector.end() - 5;
+ int nb_incr = 0;
+ for (; it != vect_vector.end() && nb_incr < 6; ++nb_incr, ++it) {}
+ CPPUNIT_ASSERT( nb_incr == 5 );
+ }
+
+ {
+ //range erase in front
+ vect_vector.erase(vect_vector.begin() + 3, vect_vector.begin() + 5);
+ bufs.erase(bufs.begin() + 3, bufs.begin() + 5);
+ CPPUNIT_ASSERT( vect_vector.size() == 16 );
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ vector<vector<int> >::iterator dit(vect_vector.begin()), ditEnd(vect_vector.end());
+ for (size_t i = 0; dit != ditEnd; ++dit, ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &dit->front() );
+ }
+#endif
+ }
+
+ {
+ vector<vector<int> >::iterator it = vect_vector.end() - 5;
+ int nb_incr = 0;
+ for (; it != vect_vector.end() && nb_incr <= 6; ++nb_incr, ++it) {}
+ CPPUNIT_ASSERT( nb_incr == 5 );
+ }
+
+ {
+ //range erase in back
+ vect_vector.erase(vect_vector.end() - 5, vect_vector.end() - 3);
+ bufs.erase(bufs.end() - 5, bufs.end() - 3);
+ CPPUNIT_ASSERT( vect_vector.size() == 14 );
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ vector<vector<int> >::iterator dit(vect_vector.begin()), ditEnd(vect_vector.end());
+ for (size_t i = 0; dit != ditEnd; ++dit, ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &dit->front() );
+ }
+#endif
+ }
+ }
+
+ //Check the insert value(s)
+ {
+ vector<vector<int> > vect_vector;
+ vect_vector.assign(20, vector<int>(10));
+ vector<vector<int> >::iterator vdit(vect_vector.begin()), vditEnd(vect_vector.end());
+ vector<int*> bufs;
+ for (; vdit != vditEnd; ++vdit) {
+ bufs.push_back(&vdit->front());
+ }
+
+ {
+ //2 values in front:
+ vect_vector.insert(vect_vector.begin() + 2, 2, vector<int>(10));
+ bufs.insert(bufs.begin() + 2, &vect_vector[2].front());
+ bufs.insert(bufs.begin() + 3, &vect_vector[3].front());
+ CPPUNIT_ASSERT( vect_vector.size() == 22 );
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ vector<vector<int> >::iterator dit(vect_vector.begin()), ditEnd(vect_vector.end());
+ for (size_t i = 0; dit != ditEnd; ++dit, ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &dit->front() );
+ }
+#endif
+ }
+
+ {
+ //2 values in back:
+ vect_vector.insert(vect_vector.end() - 2, 2, vector<int>(10));
+ bufs.insert(bufs.end() - 2, &vect_vector[20].front());
+ bufs.insert(bufs.end() - 2, &vect_vector[21].front());
+ CPPUNIT_ASSERT( vect_vector.size() == 24 );
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ vector<vector<int> >::iterator dit(vect_vector.begin()), ditEnd(vect_vector.end());
+ for (size_t i = 0; dit != ditEnd; ++dit, ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &dit->front() );
+ }
+#endif
+ }
+
+ {
+ //1 value in front:
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ vector<vector<int> >::iterator ret =
+#endif
+ vect_vector.insert(vect_vector.begin() + 2, vector<int>(10));
+ bufs.insert(bufs.begin() + 2, &vect_vector[2].front());
+ CPPUNIT_ASSERT( vect_vector.size() == 25 );
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( &ret->front() == bufs[2] );
+ vector<vector<int> >::iterator dit(vect_vector.begin()), ditEnd(vect_vector.end());
+ for (size_t i = 0; dit != ditEnd; ++dit, ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &dit->front() );
+ }
+#endif
+ }
+
+ {
+ //1 value in back:
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ vector<vector<int> >::iterator ret =
+#endif
+ vect_vector.insert(vect_vector.end() - 2, vector<int>(10));
+ bufs.insert(bufs.end() - 2, &vect_vector[23].front());
+ CPPUNIT_ASSERT( vect_vector.size() == 26 );
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( &ret->front() == bufs[23] );
+ vector<vector<int> >::iterator dit(vect_vector.begin()), ditEnd(vect_vector.end());
+ for (size_t i = 0; dit != ditEnd; ++dit, ++i) {
+ CPPUNIT_ASSERT( bufs[i] == &dit->front() );
+ }
+#endif
+ }
+ }
+
+ //The following tests are checking move contructor implementations:
+ const string long_str("long enough string to force dynamic allocation");
+ {
+ //vector move contructor:
+ vector<vector<string> > vect(10, vector<string>(10, long_str));
+ vector<string> strs;
+ size_t index = 0;
+ for (;;) {
+ vector<vector<string> >::iterator it(vect.begin());
+ advance(it, index % vect.size());
+ strs.push_back(it->front());
+ it->erase(it->begin());
+ if (it->empty()) {
+ vect.erase(it);
+ if (vect.empty())
+ break;
+ }
+ index += 3;
+ }
+ CPPUNIT_ASSERT( strs.size() == 10 * 10 );
+ vector<string>::iterator it(strs.begin()), itEnd(strs.end());
+ for (; it != itEnd; ++it) {
+ CPPUNIT_ASSERT( *it == long_str );
+ }
+ }
+
+ {
+ //deque move contructor:
+# if !defined (__DMC__)
+ vector<deque<string> > vect(10, deque<string>(10, long_str));
+# else
+ deque<string> deq_str = deque<string>(10, long_str);
+ vector<deque<string> > vect(10, deq_str);
+# endif
+ vector<string> strs;
+ size_t index = 0;
+ for (;;) {
+ vector<deque<string> >::iterator it(vect.begin());
+ advance(it, index % vect.size());
+ strs.push_back(it->front());
+ it->pop_front();
+ if (it->empty()) {
+ vect.erase(it);
+ if (vect.empty())
+ break;
+ }
+ index += 3;
+ }
+ CPPUNIT_ASSERT( strs.size() == 10 * 10 );
+ vector<string>::iterator it(strs.begin()), itEnd(strs.end());
+ for (; it != itEnd; ++it) {
+ CPPUNIT_ASSERT( *it == long_str );
+ }
+ }
+
+ {
+ //list move contructor:
+ vector<list<string> > vect(10, list<string>(10, long_str));
+ vector<string> strs;
+ size_t index = 0;
+ for (;;) {
+ vector<list<string> >::iterator it(vect.begin());
+ advance(it, index % vect.size());
+ strs.push_back(it->front());
+ it->pop_front();
+ if (it->empty()) {
+ vect.erase(it);
+ if (vect.empty())
+ break;
+ }
+ index += 3;
+ }
+ CPPUNIT_ASSERT( strs.size() == 10 * 10 );
+ vector<string>::iterator it(strs.begin()), itEnd(strs.end());
+ for (; it != itEnd; ++it) {
+ CPPUNIT_ASSERT( *it == long_str );
+ }
+ }
+
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ {
+ //slist move contructor:
+ vector<slist<string> > vect(10, slist<string>(10, long_str));
+ vector<string> strs;
+ size_t index = 0;
+ while (true) {
+ vector<slist<string> >::iterator it(vect.begin());
+ advance(it, index % vect.size());
+ strs.push_back(it->front());
+ it->pop_front();
+ if (it->empty()) {
+ vect.erase(it);
+ if (vect.empty())
+ break;
+ }
+ index += 3;
+ }
+ CPPUNIT_ASSERT( strs.size() == 10 * 10 );
+ vector<string>::iterator it(strs.begin()), itEnd(strs.end());
+ for (; it != itEnd; ++it) {
+ CPPUNIT_ASSERT( *it == long_str );
+ }
+ }
+#endif
+
+ {
+ //binary tree move contructor:
+ multiset<string> ref;
+ for (size_t i = 0; i < 10; ++i) {
+ ref.insert(long_str);
+ }
+ vector<multiset<string> > vect(10, ref);
+ vector<string> strs;
+ size_t index = 0;
+ for (;;) {
+ vector<multiset<string> >::iterator it(vect.begin());
+ advance(it, index % vect.size());
+ strs.push_back(*it->begin());
+ it->erase(it->begin());
+ if (it->empty()) {
+ vect.erase(it);
+ if (vect.empty())
+ break;
+ }
+ index += 3;
+ }
+ CPPUNIT_ASSERT( strs.size() == 10 * 10 );
+ vector<string>::iterator it(strs.begin()), itEnd(strs.end());
+ for (; it != itEnd; ++it) {
+ CPPUNIT_ASSERT( *it == long_str );
+ }
+ }
+
+#if defined (STLPORT)
+# if !defined (__DMC__)
+ {
+ //hash container move contructor:
+ unordered_multiset<string> ref;
+ for (size_t i = 0; i < 10; ++i) {
+ ref.insert(long_str);
+ }
+ vector<unordered_multiset<string> > vect(10, ref);
+ vector<string> strs;
+ size_t index = 0;
+ while (true) {
+ vector<unordered_multiset<string> >::iterator it(vect.begin());
+ advance(it, index % vect.size());
+ strs.push_back(*it->begin());
+ it->erase(it->begin());
+ if (it->empty()) {
+ vect.erase(it);
+ if (vect.empty())
+ break;
+ }
+ index += 3;
+ }
+ CPPUNIT_ASSERT( strs.size() == 10 * 10 );
+ vector<string>::iterator it(strs.begin()), itEnd(strs.end());
+ for (; it != itEnd; ++it) {
+ CPPUNIT_ASSERT( *it == long_str );
+ }
+ }
+# endif
+#endif
+}
+
+#if defined (__BORLANDC__)
+/* Specific Borland test case to show a really weird compiler behavior.
+ */
+class Standalone
+{
+public:
+ //Uncomment following to pass the test
+ //Standalone() {}
+ ~Standalone() {}
+
+ MovableStruct movableStruct;
+ vector<int> intVector;
+};
+
+void MoveConstructorTest::nb_destructor_calls()
+{
+ MovableStruct::reset();
+
+ try
+ {
+ Standalone standalone;
+ throw "some exception";
+ MovableStruct movableStruct;
+ }
+ catch (const char*)
+ {
+ CPPUNIT_ASSERT( MovableStruct::nb_dft_construct_call == 1 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 1 );
+ }
+}
+#endif
diff --git a/sources/android/stlport/test/unit/mvctor_test.h b/sources/android/stlport/test/unit/mvctor_test.h
new file mode 100644
index 0000000..8314db6
--- /dev/null
+++ b/sources/android/stlport/test/unit/mvctor_test.h
@@ -0,0 +1,97 @@
+#include <cstdio> //size_t and STLport macros
+
+#include "cppunit/cppunit_proxy.h"
+
+//
+// TestCase class
+//
+class MoveConstructorTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(MoveConstructorTest);
+ CPPUNIT_TEST(move_construct_test);
+ CPPUNIT_TEST(deque_test);
+ CPPUNIT_TEST(vector_test);
+ CPPUNIT_TEST(move_traits);
+#if !defined (STLPORT) || defined (_STLP_NO_MOVE_SEMANTIC) || \
+ defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS) || \
+ (defined (__BORLANDC__) && (__BORLANDC__ < 0x564))
+ CPPUNIT_IGNORE;
+# endif
+ CPPUNIT_TEST(movable_declaration)
+ CPPUNIT_TEST(movable_declaration_assoc)
+ CPPUNIT_TEST(movable_declaration_hash)
+#if defined (__BORLANDC__)
+ CPPUNIT_STOP_IGNORE;
+ CPPUNIT_TEST(nb_destructor_calls);
+#endif
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void move_construct_test();
+ void deque_test();
+ void vector_test();
+ void move_traits();
+ void movable_declaration();
+ void movable_declaration_assoc();
+ void movable_declaration_hash();
+ void nb_destructor_calls();
+
+ /*
+ template <class _Container>
+ void standard_test1(_Container const& ref_cont) {
+ vector<_Container> vec_cont(1, ref_cont);
+ typedef typename _Container::value_type value_type;
+ value_type *pvalue = &(*vec_cont.front().begin());
+ size_t cur_capacity= vec_cont.capacity();
+ //force reallocation
+ while (cur_capacity == vec_cont.capacity()) {
+ vec_cont.push_back(ref_cont);
+ }
+ bool b=( (pvalue==(&(*vec_cont.front().begin()))) );
+ CPPUNIT_ASSERT(b);
+ }
+ */
+
+private:
+ void move_traits_vec();
+ void move_traits_vec_complete();
+ void move_traits_deq();
+ void move_traits_deq_complete();
+};
+
+struct MovableStruct {
+ MovableStruct() { ++nb_dft_construct_call; }
+ MovableStruct(MovableStruct const&) { ++nb_cpy_construct_call; }
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+# if defined (_STLP_USE_NAMESPACES)
+ MovableStruct(std::__move_source<MovableStruct>)
+# else
+ MovableStruct(__move_source<MovableStruct>)
+# endif
+ { ++nb_mv_construct_call; }
+#endif
+ ~MovableStruct() { ++nb_destruct_call; }
+
+ MovableStruct& operator = (const MovableStruct&) {
+ ++nb_assignment_call;
+ return *this;
+ }
+
+ static void reset() {
+ nb_dft_construct_call = nb_cpy_construct_call = nb_mv_construct_call = 0;
+ nb_assignment_call = 0;
+ nb_destruct_call = 0;
+ }
+
+ static size_t nb_dft_construct_call;
+ static size_t nb_cpy_construct_call;
+ static size_t nb_mv_construct_call;
+ static size_t nb_assignment_call;
+ static size_t nb_destruct_call;
+
+ //Dummy data just to control struct sizeof
+ //As node allocator implementation align memory blocks on 2 * sizeof(void*)
+ //we give MovableStruct the same size in order to have expected allocation
+ //and not more
+ void* dummy_data[2];
+};
diff --git a/sources/android/stlport/test/unit/mvctor_traits_test.cpp b/sources/android/stlport/test/unit/mvctor_traits_test.cpp
new file mode 100644
index 0000000..7cea98f
--- /dev/null
+++ b/sources/android/stlport/test/unit/mvctor_traits_test.cpp
@@ -0,0 +1,460 @@
+#include <vector>
+#include <deque>
+
+#include "mvctor_test.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+size_t MovableStruct::nb_dft_construct_call = 0;
+size_t MovableStruct::nb_cpy_construct_call = 0;
+size_t MovableStruct::nb_mv_construct_call = 0;
+size_t MovableStruct::nb_assignment_call = 0;
+size_t MovableStruct::nb_destruct_call = 0;
+
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+# if defined (_STLP_USE_NAMESPACES)
+namespace std {
+# endif
+ _STLP_TEMPLATE_NULL
+ struct __move_traits<MovableStruct> {
+ typedef __true_type implemented;
+ typedef __false_type complete;
+ };
+# if defined (_STLP_USE_NAMESPACES)
+}
+# endif
+#endif
+
+struct CompleteMovableStruct {
+ CompleteMovableStruct() { ++nb_dft_construct_call; }
+ CompleteMovableStruct(CompleteMovableStruct const&) { ++nb_cpy_construct_call; }
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CompleteMovableStruct(__move_source<CompleteMovableStruct>) { ++nb_mv_construct_call; }
+#endif
+ ~CompleteMovableStruct() { ++nb_destruct_call; }
+
+ CompleteMovableStruct& operator = (const CompleteMovableStruct&) {
+ ++nb_assignment_call;
+ return *this;
+ }
+ static void reset() {
+ nb_dft_construct_call = nb_cpy_construct_call = nb_mv_construct_call = 0;
+ nb_assignment_call = 0;
+ nb_destruct_call = 0;
+ }
+
+ static size_t nb_dft_construct_call;
+ static size_t nb_cpy_construct_call;
+ static size_t nb_mv_construct_call;
+ static size_t nb_assignment_call;
+ static size_t nb_destruct_call;
+
+ //See MovableStruct
+ void* dummy_data[2];
+};
+
+size_t CompleteMovableStruct::nb_dft_construct_call = 0;
+size_t CompleteMovableStruct::nb_cpy_construct_call = 0;
+size_t CompleteMovableStruct::nb_mv_construct_call = 0;
+size_t CompleteMovableStruct::nb_assignment_call = 0;
+size_t CompleteMovableStruct::nb_destruct_call = 0;
+
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+# if defined (_STLP_USE_NAMESPACES)
+namespace std {
+# endif
+ _STLP_TEMPLATE_NULL
+ struct __move_traits<CompleteMovableStruct> {
+ typedef __true_type implemented;
+ typedef __true_type complete;
+ };
+# if defined (_STLP_USE_NAMESPACES)
+}
+# endif
+#endif
+
+void MoveConstructorTest::move_traits()
+{
+ move_traits_vec();
+ move_traits_vec_complete();
+ move_traits_deq();
+ move_traits_deq_complete();
+}
+
+void MoveConstructorTest::move_traits_vec()
+{
+ {
+ {
+ vector<MovableStruct> vect;
+ vect.push_back(MovableStruct());
+ vect.push_back(MovableStruct());
+ vect.push_back(MovableStruct());
+ vect.push_back(MovableStruct());
+
+ // vect contains 4 elements
+ CPPUNIT_ASSERT( MovableStruct::nb_dft_construct_call == 4 );
+#if defined (STLPORT)
+# if !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( MovableStruct::nb_cpy_construct_call == 4 );
+ CPPUNIT_ASSERT( MovableStruct::nb_mv_construct_call == 3 );
+# else
+ CPPUNIT_ASSERT( MovableStruct::nb_cpy_construct_call == 7 );
+# endif
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 7 );
+#elif !defined (_MSC_VER)
+ CPPUNIT_ASSERT( MovableStruct::nb_cpy_construct_call == 7 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 7 );
+#else
+ CPPUNIT_ASSERT( MovableStruct::nb_cpy_construct_call == 14 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 14 );
+#endif
+ CPPUNIT_ASSERT( MovableStruct::nb_assignment_call == 0 );
+
+ // Following test violate requirements to sequiences (23.1.1 Table 67)
+ /*
+ vect.insert(vect.begin() + 2, vect.begin(), vect.end());
+ // vect contains 8 elements
+ CPPUNIT_ASSERT( MovableStruct::nb_dft_construct_call == 4 );
+ CPPUNIT_ASSERT( MovableStruct::nb_cpy_construct_call == 8 );
+ CPPUNIT_ASSERT( MovableStruct::nb_mv_construct_call == 7 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 11 );
+ */
+
+ MovableStruct::reset();
+ vector<MovableStruct> v2 = vect;
+ CPPUNIT_ASSERT( MovableStruct::nb_dft_construct_call == 0 );
+ CPPUNIT_ASSERT( MovableStruct::nb_cpy_construct_call == 4 );
+ CPPUNIT_ASSERT( MovableStruct::nb_mv_construct_call == 0 );
+ CPPUNIT_ASSERT( MovableStruct::nb_assignment_call == 0 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 0 );
+
+ MovableStruct::reset();
+ vect.insert(vect.begin() + 2, v2.begin(), v2.end() );
+
+ // vect contains 8 elements
+ CPPUNIT_ASSERT( MovableStruct::nb_dft_construct_call == 0 );
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( MovableStruct::nb_cpy_construct_call == 4 );
+ CPPUNIT_ASSERT( MovableStruct::nb_mv_construct_call == 4 );
+#else
+ CPPUNIT_ASSERT( MovableStruct::nb_cpy_construct_call == 8 );
+#endif
+ CPPUNIT_ASSERT( MovableStruct::nb_assignment_call == 0 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 4 );
+
+ MovableStruct::reset();
+ vect.erase(vect.begin(), vect.begin() + 2 );
+
+ // vect contains 6 elements
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( MovableStruct::nb_mv_construct_call == 6 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 8 );
+#else
+ CPPUNIT_ASSERT_EQUAL( MovableStruct::nb_assignment_call, 6 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 2 );
+#endif
+
+ MovableStruct::reset();
+ vect.erase(vect.end() - 2, vect.end());
+
+ // vect contains 4 elements
+ CPPUNIT_ASSERT( MovableStruct::nb_mv_construct_call == 0 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 2 );
+
+ MovableStruct::reset();
+ vect.erase(vect.begin());
+
+ // vect contains 3 elements
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( MovableStruct::nb_mv_construct_call == 3 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 4 );
+#else
+ CPPUNIT_ASSERT( MovableStruct::nb_assignment_call == 3 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 1 );
+#endif
+
+ MovableStruct::reset();
+ }
+ //vect with 3 elements and v2 with 4 elements are now out of scope
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 3 + 4 );
+ }
+}
+
+void MoveConstructorTest::move_traits_vec_complete()
+{
+ {
+ {
+ vector<CompleteMovableStruct> vect;
+ vect.push_back(CompleteMovableStruct());
+ vect.push_back(CompleteMovableStruct());
+ vect.push_back(CompleteMovableStruct());
+ vect.push_back(CompleteMovableStruct());
+
+ // vect contains 4 elements
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_dft_construct_call == 4 );
+#if defined (STLPORT)
+# if !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_cpy_construct_call == 4 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_mv_construct_call == 3 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 4 );
+# else
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_cpy_construct_call == 7 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 7 );
+# endif
+#elif !defined (_MSC_VER)
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_cpy_construct_call == 7 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 7 );
+#else
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_cpy_construct_call == 14 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 14 );
+#endif
+
+ // Following test violate requirements to sequiences (23.1.1 Table 67)
+ /*
+ vect.insert(vect.begin() + 2, vect.begin(), vect.end());
+
+ // vect contains 8 elements
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_dft_construct_call == 4 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_cpy_construct_call == 8 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_mv_construct_call == 7 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 4 );
+ */
+
+ CompleteMovableStruct::reset();
+ vector<CompleteMovableStruct> v2 = vect;
+
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_dft_construct_call == 0 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_cpy_construct_call == 4 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_mv_construct_call == 0 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 0 );
+
+ CompleteMovableStruct::reset();
+ vect.insert(vect.begin() + 2, v2.begin(), v2.end());
+
+ // vect contains 8 elements
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_dft_construct_call == 0 );
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_cpy_construct_call == 4 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_mv_construct_call == 4 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 0 );
+#else
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_cpy_construct_call == 8 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 4 );
+#endif
+
+ CompleteMovableStruct::reset();
+ vect.erase(vect.begin(), vect.begin() + 2);
+
+ // vect contains 6 elements
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_mv_construct_call == 6 );
+#else
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_assignment_call == 6 );
+#endif
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 2 );
+
+ CompleteMovableStruct::reset();
+ vect.erase(vect.end() - 2, vect.end());
+
+ // vect contains 4 elements
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_mv_construct_call == 0 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 2 );
+
+ CompleteMovableStruct::reset();
+ vect.erase(vect.begin());
+
+ // vect contains 3 elements
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_mv_construct_call == 3 );
+#else
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_assignment_call == 3 );
+#endif
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 1 );
+
+ CompleteMovableStruct::reset();
+ }
+ //vect with 3 elements and v2 with 4 elements are now out of scope
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 3 + 4 );
+ }
+}
+
+void MoveConstructorTest::move_traits_deq()
+{
+ {
+ MovableStruct::reset();
+ {
+ deque<MovableStruct> deq;
+ deq.push_back(MovableStruct());
+ deq.push_back(MovableStruct());
+ deq.push_back(MovableStruct());
+ deq.push_back(MovableStruct());
+
+ // deq contains 4 elements
+ CPPUNIT_ASSERT( MovableStruct::nb_dft_construct_call == 4 );
+ CPPUNIT_ASSERT( MovableStruct::nb_cpy_construct_call == 4 );
+ CPPUNIT_ASSERT( MovableStruct::nb_mv_construct_call == 0 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 4 );
+
+ // Following test violate requirements to sequiences (23.1.1 Table 67)
+ /*
+ deq.insert(deq.begin() + 2, deq.begin(), deq.end());
+ // deq contains 8 elements
+ CPPUNIT_ASSERT( MovableStruct::nb_dft_construct_call == 4 );
+ CPPUNIT_ASSERT( MovableStruct::nb_cpy_construct_call == 8 );
+ CPPUNIT_ASSERT( MovableStruct::nb_mv_construct_call == 7 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 11 );
+ */
+
+ MovableStruct::reset();
+ deque<MovableStruct> d2 = deq;
+
+ CPPUNIT_ASSERT( MovableStruct::nb_dft_construct_call == 0 );
+ CPPUNIT_ASSERT( MovableStruct::nb_cpy_construct_call == 4 );
+ CPPUNIT_ASSERT( MovableStruct::nb_mv_construct_call == 0 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 0 );
+
+ MovableStruct::reset();
+ deq.insert(deq.begin() + 2, d2.begin(), d2.end() );
+
+ // deq contains 8 elements
+ CPPUNIT_ASSERT( MovableStruct::nb_dft_construct_call == 0 );
+ CPPUNIT_ASSERT( MovableStruct::nb_cpy_construct_call == 4 );
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( MovableStruct::nb_mv_construct_call == 2 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 2 );
+#else
+ CPPUNIT_ASSERT( MovableStruct::nb_assignment_call == 2 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 0 );
+#endif
+
+ MovableStruct::reset();
+ deq.erase(deq.begin() + 1, deq.begin() + 3 );
+
+ // deq contains 6 elements
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( MovableStruct::nb_mv_construct_call == 1 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 3 );
+#else
+ //Following check is highly deque implementation dependant so
+ //it might not always work...
+ CPPUNIT_ASSERT( MovableStruct::nb_assignment_call == 1 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 2 );
+#endif
+
+ MovableStruct::reset();
+ deq.erase(deq.end() - 3, deq.end() - 1);
+
+ // deq contains 4 elements
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( MovableStruct::nb_mv_construct_call == 1 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 3 );
+#else
+ CPPUNIT_ASSERT( MovableStruct::nb_assignment_call == 1 );
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 2 );
+#endif
+
+ MovableStruct::reset();
+ deq.erase(deq.begin());
+
+ // deq contains 3 elements
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( MovableStruct::nb_mv_construct_call == 0 );
+#else
+ CPPUNIT_ASSERT( MovableStruct::nb_assignment_call == 0 );
+#endif
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 1 );
+
+ MovableStruct::reset();
+ }
+ //deq with 3 elements and d2 with 4 elements are now out of scope
+ CPPUNIT_ASSERT( MovableStruct::nb_destruct_call == 3 + 4 );
+ }
+}
+
+void MoveConstructorTest::move_traits_deq_complete()
+{
+ {
+ CompleteMovableStruct::reset();
+ {
+ deque<CompleteMovableStruct> deq;
+ deq.push_back(CompleteMovableStruct());
+ deq.push_back(CompleteMovableStruct());
+ deq.push_back(CompleteMovableStruct());
+ deq.push_back(CompleteMovableStruct());
+
+ // deq contains 4 elements
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_dft_construct_call == 4 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_cpy_construct_call == 4 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_mv_construct_call == 0 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 4 );
+
+ // Following test violate requirements to sequiences (23.1.1 Table 67)
+ /*
+ deq.insert(deq.begin() + 2, deq.begin(), deq.end());
+
+ // deq contains 8 elements
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_dft_construct_call == 4 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_cpy_construct_call == 8 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_mv_construct_call == 7 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 4 );
+ */
+
+ CompleteMovableStruct::reset();
+ deque<CompleteMovableStruct> d2 = deq;
+
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_dft_construct_call == 0 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_cpy_construct_call == 4 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_mv_construct_call == 0 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 0 );
+
+ CompleteMovableStruct::reset();
+ deq.insert(deq.begin() + 2, d2.begin(), d2.end());
+
+ // deq contains 8 elements
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_dft_construct_call == 0 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_cpy_construct_call == 4 );
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_mv_construct_call == 2 );
+#else
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_assignment_call == 2 );
+#endif
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 0 );
+
+ CompleteMovableStruct::reset();
+ deq.erase(deq.begin() + 1, deq.begin() + 3);
+
+ // deq contains 6 elements
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_mv_construct_call == 1 );
+#else
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_assignment_call == 1 );
+#endif
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 2 );
+
+ CompleteMovableStruct::reset();
+ deq.erase(deq.end() - 3, deq.end() - 1);
+
+ // deq contains 4 elements
+#if defined (STLPORT) && !defined (_STLP_NO_MOVE_SEMANTIC)
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_mv_construct_call == 1 );
+#else
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_assignment_call == 1 );
+#endif
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 2 );
+
+ CompleteMovableStruct::reset();
+ deq.erase(deq.begin());
+
+ // deq contains 3 elements
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_mv_construct_call == 0 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_assignment_call == 0 );
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 1 );
+
+ CompleteMovableStruct::reset();
+ }
+ //deq with 3 elements and v2 with 4 elements are now out of scope
+ CPPUNIT_ASSERT( CompleteMovableStruct::nb_destruct_call == 3 + 4 );
+ }
+}
diff --git a/sources/android/stlport/test/unit/neq_test.cpp b/sources/android/stlport/test/unit/neq_test.cpp
new file mode 100644
index 0000000..7769e42
--- /dev/null
+++ b/sources/android/stlport/test/unit/neq_test.cpp
@@ -0,0 +1,54 @@
+#include <vector>
+#include <algorithm>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class NeqTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(NeqTest);
+ CPPUNIT_TEST(negate0);
+ CPPUNIT_TEST(nequal0);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void negate0();
+ void nequal0();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(NeqTest);
+
+//
+// tests implementation
+//
+void NeqTest::negate0()
+{
+ int input [3] = { 1, 2, 3 };
+
+ int output[3];
+ transform((int*)input, (int*)input + 3, (int*)output, negate<int>());
+
+ CPPUNIT_ASSERT(output[0]==-1);
+ CPPUNIT_ASSERT(output[1]==-2);
+ CPPUNIT_ASSERT(output[2]==-3);
+}
+void NeqTest::nequal0()
+{
+ int input1 [4] = { 1, 7, 2, 2 };
+ int input2 [4] = { 1, 6, 2, 3 };
+
+ int output [4];
+ transform((int*)input1, (int*)input1 + 4, (int*)input2, (int*)output, not_equal_to<int>());
+
+ CPPUNIT_ASSERT(output[0]==0);
+ CPPUNIT_ASSERT(output[1]==1);
+ CPPUNIT_ASSERT(output[2]==0);
+ CPPUNIT_ASSERT(output[3]==1);
+}
diff --git a/sources/android/stlport/test/unit/new_header_test.cpp b/sources/android/stlport/test/unit/new_header_test.cpp
new file mode 100644
index 0000000..1884299
--- /dev/null
+++ b/sources/android/stlport/test/unit/new_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <new>
diff --git a/sources/android/stlport/test/unit/nthelm_test.cpp b/sources/android/stlport/test/unit/nthelm_test.cpp
new file mode 100644
index 0000000..75c26d1
--- /dev/null
+++ b/sources/android/stlport/test/unit/nthelm_test.cpp
@@ -0,0 +1,84 @@
+#include <vector>
+#include <algorithm>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class NthElemTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(NthElemTest);
+ CPPUNIT_TEST(nthelem0);
+ CPPUNIT_TEST(nthelem1);
+ CPPUNIT_TEST(nthelem2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void nthelem0();
+ void nthelem1();
+ void nthelem2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(NthElemTest);
+
+//
+// tests implementation
+//
+void NthElemTest::nthelem0()
+{
+ int numbers[7] = { 5, 2, 4, 1, 0, 3 ,77};
+ nth_element(numbers, numbers + 3, numbers + 6);
+
+ CPPUNIT_ASSERT(numbers[0]==1);
+ CPPUNIT_ASSERT(numbers[1]==0);
+ CPPUNIT_ASSERT(numbers[2]==2);
+ CPPUNIT_ASSERT(numbers[3]==3);
+ CPPUNIT_ASSERT(numbers[4]==4);
+ CPPUNIT_ASSERT(numbers[5]==5);
+}
+void NthElemTest::nthelem1()
+{
+ //6 8 5 1 7 4 1 5 2 6
+ //1 1 4 2 5 5 6 7 8 6
+ int numbers[10] = { 6, 8, 5, 1, 7, 4, 1, 5, 2, 6 };
+
+ vector <int> v1(numbers, numbers+10);
+ nth_element(v1.begin(), v1.begin() + v1.size() / 2, v1.end());
+
+ CPPUNIT_ASSERT(v1[0]==1);
+ CPPUNIT_ASSERT(v1[1]==1);
+ CPPUNIT_ASSERT(v1[2]==4);
+ CPPUNIT_ASSERT(v1[3]==2);
+ CPPUNIT_ASSERT(v1[4]==5);
+ CPPUNIT_ASSERT(v1[5]==5);
+ CPPUNIT_ASSERT(v1[6]==6);
+ CPPUNIT_ASSERT(v1[7]==7);
+ CPPUNIT_ASSERT(v1[8]==8);
+ CPPUNIT_ASSERT(v1[9]==6);
+}
+void NthElemTest::nthelem2()
+{
+ //4 5 4 2 1 7 4 3 1 6
+ //6 7 4 4 5 4 3 2 1 1
+
+ int numbers[10] = { 4, 5, 4, 2, 1, 7, 4, 3, 1, 6 };
+ vector <int> v1(numbers, numbers+10);
+ nth_element(v1.begin(), v1.begin() + v1.size() / 2, v1.end(), greater<int>());
+
+ CPPUNIT_ASSERT(v1[0]==6);
+ CPPUNIT_ASSERT(v1[1]==7);
+ CPPUNIT_ASSERT(v1[2]==4);
+ CPPUNIT_ASSERT(v1[3]==4);
+ CPPUNIT_ASSERT(v1[4]==5);
+ CPPUNIT_ASSERT(v1[5]==4);
+ CPPUNIT_ASSERT(v1[6]==3);
+ CPPUNIT_ASSERT(v1[7]==2);
+ CPPUNIT_ASSERT(v1[8]==1);
+ CPPUNIT_ASSERT(v1[9]==1);
+}
diff --git a/sources/android/stlport/test/unit/num_facets_test.cpp b/sources/android/stlport/test/unit/num_facets_test.cpp
new file mode 100644
index 0000000..bc5195f
--- /dev/null
+++ b/sources/android/stlport/test/unit/num_facets_test.cpp
@@ -0,0 +1,297 @@
+#include "locale_test.h"
+
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# include <locale>
+# include <sstream>
+# include <stdexcept>
+
+# include "complete_digits.h"
+
+# if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+# endif
+
+struct ref_locale {
+ const char *name;
+ const char *decimal_point;
+ const char *thousands_sep;
+};
+
+static const ref_locale tested_locales[] = {
+//{ name, decimal_point, thousands_sepy_thousands_sep},
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ { "fr_FR", ",", "\xa0"},
+ { "ru_RU.koi8r", ",", "."},
+ { "en_GB", ".", ","},
+ { "en_US", ".", ","},
+# endif
+ { "C", ".", ","},
+};
+
+//
+// tests implementation
+//
+void LocaleTest::_num_put_get( const locale& loc, const ref_locale* prl ) {
+ const ref_locale& rl = *prl;
+ CPPUNIT_ASSERT( has_facet<numpunct<char> >(loc) );
+ numpunct<char> const& npct = use_facet<numpunct<char> >(loc);
+ CPPUNIT_ASSERT( npct.decimal_point() == *rl.decimal_point );
+
+ float val = 1234.56f;
+ ostringstream fostr;
+ fostr.imbue(loc);
+ fostr << val;
+
+ string ref = "1";
+ if (!npct.grouping().empty()) {
+ ref += npct.thousands_sep();
+ }
+ ref += "234";
+ ref += npct.decimal_point();
+ ref += "56";
+ //cout << "In " << loc.name() << " 1234.56 is written: " << fostr.str() << endl;
+ CPPUNIT_ASSERT( fostr.str() == ref );
+
+ val = 12345678.9f;
+ ref = "1";
+ ref += npct.decimal_point();
+ ref += "23457e+";
+ string digits = "7";
+ complete_digits(digits);
+ ref += digits;
+ fostr.str("");
+ fostr << val;
+ CPPUNIT_ASSERT( fostr.str() == ref );
+
+ val = 1000000000.0f;
+ fostr.str("");
+ fostr << val;
+ digits = "9";
+ complete_digits(digits);
+ CPPUNIT_ASSERT( fostr.str() == string("1e+") + digits );
+
+ val = 1234.0f;
+ ref = "1";
+ if (!npct.grouping().empty()) {
+ ref += npct.thousands_sep();
+ }
+ ref += "234";
+ fostr.str("");
+ fostr << val;
+ CPPUNIT_ASSERT( fostr.str() == ref );
+
+ val = 10000001.0f;
+ fostr.str("");
+ fostr << val;
+ digits = "7";
+ complete_digits(digits);
+ CPPUNIT_ASSERT( fostr.str() == string("1e+") + digits );
+
+ if (npct.grouping().size() == 1 && npct.grouping()[0] == 3) {
+ int ival = 1234567890;
+ fostr.str("");
+ fostr << ival;
+ ref = "1";
+ ref += npct.thousands_sep();
+ ref += "234";
+ ref += npct.thousands_sep();
+ ref += "567";
+ ref += npct.thousands_sep();
+ ref += "890";
+ CPPUNIT_ASSERT( fostr.str() == ref );
+ }
+
+#if defined (__BORLANDC__)
+ num_put<char> const& nput = use_facet<num_put<char> >(loc);
+ typedef numeric_limits<double> limd;
+ fostr.setf(ios_base::uppercase | ios_base::showpos);
+
+ if (limd::has_infinity) {
+ double infinity = limd::infinity();
+ fostr.str("");
+ nput.put(fostr, fostr, ' ', infinity);
+ CPPUNIT_ASSERT( fostr.str() == string("+Inf") );
+ }
+
+ if (limd::has_quiet_NaN) {
+ /* Ignore FPU exceptions */
+ unsigned int _float_control_word = _control87(0, 0);
+ _control87(EM_INVALID|EM_INEXACT, MCW_EM);
+ double qnan = limd::quiet_NaN();
+ /* Reset floating point control word */
+ _clear87();
+ _control87(_float_control_word, MCW_EM);
+ fostr.str("");
+ nput.put(fostr, fostr, ' ', qnan);
+ CPPUNIT_ASSERT( fostr.str() == string("+NaN") );
+ }
+#endif
+}
+
+typedef void (LocaleTest::*_Test) (const locale&, const ref_locale*);
+static void test_supported_locale(LocaleTest& inst, _Test __test) {
+ size_t n = sizeof(tested_locales) / sizeof(tested_locales[0]);
+ for (size_t i = 0; i < n; ++i) {
+ locale loc;
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ try
+# endif
+ {
+ locale tmp(tested_locales[i].name);
+ loc = tmp;
+ }
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ catch (runtime_error const&) {
+ //This locale is not supported.
+ continue;
+ }
+# endif
+ CPPUNIT_MESSAGE( loc.name().c_str() );
+ (inst.*__test)(loc, tested_locales + i);
+
+ {
+ locale tmp(locale::classic(), tested_locales[i].name, locale::numeric);
+ loc = tmp;
+ }
+ (inst.*__test)(loc, tested_locales + i);
+
+ {
+ locale tmp(locale::classic(), new numpunct_byname<char>(tested_locales[i].name));
+ loc = tmp;
+ }
+ (inst.*__test)(loc, tested_locales + i);
+ }
+}
+
+void LocaleTest::num_put_get()
+{ test_supported_locale(*this, &LocaleTest::_num_put_get); }
+
+void LocaleTest::numpunct_by_name()
+{
+ /*
+ * Check of the 22.1.1.2.7 standard point. Construction of a locale
+ * instance from a null pointer or an unknown name should result in
+ * a runtime_error exception.
+ */
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+# if defined (STLPORT) || !defined (__GNUC__)
+ try {
+ locale loc(locale::classic(), new numpunct_byname<char>(static_cast<char const*>(0)));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+
+ try {
+ locale loc(locale::classic(), new numpunct_byname<char>("yasli_language"));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ string veryLongFacetName("LC_NUMERIC=");
+ veryLongFacetName.append(512, '?');
+ locale loc(locale::classic(), new numpunct_byname<char>(veryLongFacetName.c_str()));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ locale loc(locale::classic(), "C", locale::numeric);
+ }
+ catch (runtime_error const& e) {
+ CPPUNIT_MESSAGE( e.what() );
+ CPPUNIT_FAIL;
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ // On platform without real localization support we should rely on the "C" facet.
+ locale loc(locale::classic(), "", locale::numeric);
+ }
+ catch (runtime_error const& e) {
+ CPPUNIT_MESSAGE( e.what() );
+ CPPUNIT_FAIL;
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ locale loc(locale::classic(), new numpunct_byname<char>("C"));
+ numpunct<char> const& cfacet_byname = use_facet<numpunct<char> >(loc);
+ numpunct<char> const& cfacet = use_facet<numpunct<char> >(locale::classic());
+
+ CPPUNIT_CHECK( cfacet_byname.decimal_point() == cfacet.decimal_point() );
+ CPPUNIT_CHECK( cfacet_byname.grouping() == cfacet.grouping() );
+ if (!cfacet.grouping().empty())
+ CPPUNIT_CHECK( cfacet_byname.thousands_sep() == cfacet.thousands_sep() );
+# if !defined (STLPORT) || !defined (__GLIBC__)
+ CPPUNIT_CHECK( cfacet_byname.truename() == cfacet.truename() );
+ CPPUNIT_CHECK( cfacet_byname.falsename() == cfacet.falsename() );
+# endif
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ CPPUNIT_FAIL;
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ // On platform without real localization support we should rely on the "C" locale facet.
+ locale loc(locale::classic(), new numpunct_byname<char>(""));
+ }
+ catch (runtime_error const& e) {
+ CPPUNIT_MESSAGE( e.what() );
+ CPPUNIT_FAIL;
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+# if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
+# if defined (STLPORT) || !defined (__GNUC__)
+ try {
+ locale loc(locale::classic(), new numpunct_byname<wchar_t>(static_cast<char const*>(0)));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+
+ try {
+ locale loc(locale::classic(), new numpunct_byname<wchar_t>("yasli_language"));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+# endif
+}
+
+#endif
diff --git a/sources/android/stlport/test/unit/num_put_get_test.cpp b/sources/android/stlport/test/unit/num_put_get_test.cpp
new file mode 100644
index 0000000..13b250f
--- /dev/null
+++ b/sources/android/stlport/test/unit/num_put_get_test.cpp
@@ -0,0 +1,1266 @@
+#include <limits>
+
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# include <iomanip>
+# include <string>
+# include <sstream>
+# include <cstdio>
+/*
+# include <iostream>
+# include <ieee754.h>
+*/
+
+# include "complete_digits.h"
+# include "cppunit/cppunit_proxy.h"
+
+# if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+# endif
+
+//
+// TestCase class
+//
+class NumPutGetTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(NumPutGetTest);
+# if defined (__BORLANDC__)
+ /* Ignore FPU exceptions, set FPU precision to 64 bits */
+ unsigned int _float_control_word = _control87(0, 0);
+ _control87(PC_64|MCW_EM|IC_AFFINE, MCW_PC|MCW_EM|MCW_IC);
+# endif
+ CPPUNIT_TEST(num_put_float);
+ CPPUNIT_TEST(num_put_integer);
+ CPPUNIT_TEST(num_get_float);
+ CPPUNIT_TEST(num_get_integer);
+ CPPUNIT_TEST(inhex);
+ CPPUNIT_TEST(pointer);
+ CPPUNIT_TEST(fix_float_long);
+ CPPUNIT_TEST(custom_numpunct);
+# if defined (__BORLANDC__)
+ /* Reset floating point control word */
+ _clear87();
+ _control87(_float_control_word, MCW_PC|MCW_EM|MCW_IC);
+# endif
+ CPPUNIT_TEST_SUITE_END();
+
+private:
+ void num_put_float();
+ void num_put_integer();
+ void num_get_float();
+ void num_get_integer();
+ void inhex();
+ void pointer();
+ void fix_float_long();
+ void custom_numpunct();
+
+ static bool check_float(float val, float ref)
+ {
+ float epsilon = numeric_limits<float>::epsilon();
+ return val <= ref + epsilon && val >= ref - epsilon;
+ }
+
+ static bool check_double(double val, double ref)
+ {
+ double epsilon = numeric_limits<double>::epsilon();
+ return val <= ref + epsilon && val >= ref - epsilon;
+ }
+
+ static string reset_stream(ostringstream &ostr)
+ {
+ string tmp = ostr.str();
+ ostr.str("");
+ return tmp;
+ }
+
+#if !defined (STLPORT) || !defined (_STLP_NO_MEMBER_TEMPLATES)
+ template <class F>
+ void check_get_float( F v )
+ {
+ F in_val_d = v;
+ typedef numeric_limits<F> limits;
+ {
+ stringstream str;
+
+ str << "1E+" << limits::max_exponent10;
+
+ str >> in_val_d;
+ CPPUNIT_ASSERT(!str.fail());
+ CPPUNIT_ASSERT(str.eof());
+ CPPUNIT_CHECK( in_val_d == in_val_d );
+ CPPUNIT_CHECK( in_val_d != limits::infinity() );
+ }
+ {
+ stringstream str;
+
+ str << "-1E+" << limits::max_exponent10;
+
+ str >> in_val_d;
+ CPPUNIT_ASSERT(!str.fail());
+ CPPUNIT_ASSERT(str.eof());
+ CPPUNIT_CHECK( in_val_d == in_val_d );
+ CPPUNIT_CHECK( in_val_d != -limits::infinity() );
+ }
+ {
+ stringstream str;
+
+ str << "1E" << limits::min_exponent10;
+
+ str >> in_val_d;
+ CPPUNIT_ASSERT(!str.fail());
+ CPPUNIT_ASSERT(str.eof());
+ CPPUNIT_CHECK( in_val_d == in_val_d );
+ CPPUNIT_CHECK( in_val_d != F(0.0) );
+ }
+ {
+ stringstream str;
+
+ str << "1E+" << (limits::max_exponent10 + 1);
+
+ str >> in_val_d;
+ CPPUNIT_ASSERT(!str.fail());
+ CPPUNIT_ASSERT(str.eof());
+ CPPUNIT_CHECK( in_val_d == in_val_d );
+ CPPUNIT_CHECK( in_val_d == limits::infinity() );
+ }
+ {
+ stringstream str;
+
+ str << "-1E+" << (limits::max_exponent10 + 1);
+
+ str >> in_val_d;
+ CPPUNIT_ASSERT(!str.fail());
+ CPPUNIT_ASSERT(str.eof());
+ CPPUNIT_CHECK( in_val_d == in_val_d );
+ CPPUNIT_CHECK( in_val_d == -limits::infinity() );
+ }
+ {
+ stringstream str;
+
+ str << "1E" << (limits::min_exponent10 - 1);
+
+ str >> in_val_d;
+ CPPUNIT_ASSERT(!str.fail());
+ CPPUNIT_ASSERT(str.eof());
+ CPPUNIT_CHECK( in_val_d == in_val_d );
+ CPPUNIT_CHECK( in_val_d >= F(0.0) && in_val_d <= limits::min() );
+ }
+#if !defined (__MINGW32__)
+ {
+ stringstream str;
+
+ str << limits::max();
+
+ CPPUNIT_ASSERT(!str.fail());
+ CPPUNIT_CHECK( str.str() != "inf" );
+ CPPUNIT_CHECK( str.str() != "-inf" );
+ CPPUNIT_CHECK( str.str() != "nan" );
+ CPPUNIT_CHECK( str.str() != "-nan" );
+ //CPPUNIT_MESSAGE( str.str().c_str() );
+
+ //str.str("");
+ //str << limits::max_exponent10;
+ //CPPUNIT_MESSAGE( str.str().c_str() );
+
+ str >> in_val_d;
+
+ CPPUNIT_ASSERT(!str.fail());
+ CPPUNIT_ASSERT(str.eof());
+ CPPUNIT_CHECK( in_val_d == in_val_d );
+ CPPUNIT_CHECK( in_val_d != limits::infinity() );
+ }
+ {
+ stringstream str;
+
+ str << fixed << limits::max();
+
+ CPPUNIT_ASSERT(!str.fail());
+ CPPUNIT_CHECK( str.str() != "inf" );
+ CPPUNIT_CHECK( str.str() != "-inf" );
+ CPPUNIT_CHECK( str.str() != "nan" );
+ CPPUNIT_CHECK( str.str() != "-nan" );
+ //CPPUNIT_MESSAGE( str.str().c_str() );
+
+ //str.str("");
+ //str << limits::max_exponent10;
+ //CPPUNIT_MESSAGE( str.str().c_str() );
+
+ str >> in_val_d;
+
+ CPPUNIT_ASSERT(!str.fail());
+ CPPUNIT_ASSERT(str.eof());
+ CPPUNIT_CHECK( in_val_d == in_val_d );
+ CPPUNIT_CHECK( in_val_d != limits::infinity() );
+ }
+ {
+ stringstream str;
+
+ str << scientific << setprecision(50) << limits::max();
+
+ CPPUNIT_ASSERT(!str.fail());
+ CPPUNIT_CHECK( str.str() != "inf" );
+ CPPUNIT_CHECK( str.str() != "-inf" );
+ CPPUNIT_CHECK( str.str() != "nan" );
+ CPPUNIT_CHECK( str.str() != "-nan" );
+ //CPPUNIT_MESSAGE( str.str().c_str() );
+
+ //str.str("");
+ //str << limits::max_exponent10;
+ //CPPUNIT_MESSAGE( str.str().c_str() );
+
+ str >> in_val_d;
+
+ CPPUNIT_ASSERT(!str.fail());
+ CPPUNIT_ASSERT(str.eof());
+ CPPUNIT_CHECK( in_val_d == in_val_d );
+ CPPUNIT_CHECK( in_val_d != limits::infinity() );
+ }
+#endif
+ {
+ stringstream str;
+
+ str << limits::infinity();
+
+ CPPUNIT_ASSERT( !str.fail() );
+ CPPUNIT_ASSERT( !limits::has_infinity || str.str() == "inf" );
+ }
+ {
+ stringstream str;
+
+ str << -limits::infinity();
+
+ CPPUNIT_ASSERT( !str.fail() );
+ CPPUNIT_ASSERT( !limits::has_infinity || str.str() == "-inf" );
+ }
+ {
+ stringstream str;
+
+ str << limits::quiet_NaN();
+
+ CPPUNIT_ASSERT( !str.fail() );
+ CPPUNIT_ASSERT( !limits::has_quiet_NaN || str.str() == "nan" );
+ }
+ {
+ stringstream str;
+
+ str << -limits::quiet_NaN();
+
+ CPPUNIT_ASSERT( !str.fail() );
+ CPPUNIT_ASSERT( !limits::has_quiet_NaN || str.str() == "-nan" );
+ }
+ {
+ stringstream str;
+
+ str << "0." << string(limits::max_exponent10, '0') << "1e" << (limits::max_exponent10 + 1);
+ CPPUNIT_ASSERT( !str.fail() );
+
+ str >> in_val_d;
+ CPPUNIT_ASSERT( !str.fail() );
+ CPPUNIT_ASSERT( str.eof() );
+ CPPUNIT_CHECK( in_val_d == 1 );
+ }
+ {
+ stringstream str;
+
+ str << "1" << string(-(limits::min_exponent10 - 1), '0') << "e" << (limits::min_exponent10 - 1);
+ CPPUNIT_ASSERT( !str.fail() );
+
+ str >> in_val_d;
+ CPPUNIT_ASSERT( !str.fail() );
+ CPPUNIT_ASSERT( str.eof() );
+ CPPUNIT_CHECK( in_val_d == 1 );
+ }
+# if defined (_STLPORT_VERSION) && (_STLPORT_VERSION >= 0x530)
+ // The following tests are showing that simply changing stream
+ // precision lead to different result. Do not seems to be a real
+ // problem, simply rounding approximation but additional study should
+ // be done after 5.2 release.
+ {
+ stringstream str;
+ str << setprecision(limits::digits10 + 2) << limits::max();
+
+ CPPUNIT_MESSAGE(str.str().c_str());
+ CPPUNIT_ASSERT( !str.fail() );
+
+ F val;
+ str >> val;
+
+ CPPUNIT_ASSERT( !str.fail() );
+ CPPUNIT_ASSERT( limits::infinity() > val );
+ }
+ {
+ stringstream str;
+ str << setprecision(limits::digits10 + 1) << limits::max();
+
+ CPPUNIT_MESSAGE(str.str().c_str());
+ CPPUNIT_ASSERT( !str.fail() );
+
+ F val;
+ str >> val;
+
+ CPPUNIT_ASSERT( !str.fail() );
+ CPPUNIT_ASSERT( limits::infinity() > val );
+ }
+# endif
+ }
+#else
+# define __check_get_float( F ) \
+ void check_get_float( F v ) \
+ { \
+ F in_val_d = v; \
+ { \
+ stringstream str; \
+ \
+ str << "1E+" << numeric_limits<F>::max_exponent10; \
+ \
+ str >> in_val_d; \
+ CPPUNIT_ASSERT(!str.fail()); \
+ CPPUNIT_ASSERT(str.eof()); \
+ CPPUNIT_CHECK( in_val_d == in_val_d ); \
+ CPPUNIT_CHECK( in_val_d != numeric_limits<F>::infinity() ); \
+ } \
+ { \
+ stringstream str; \
+ \
+ str << "-1E+" << numeric_limits<F>::max_exponent10; \
+ \
+ str >> in_val_d; \
+ CPPUNIT_ASSERT(!str.fail()); \
+ CPPUNIT_ASSERT(str.eof()); \
+ CPPUNIT_CHECK( in_val_d == in_val_d ); \
+ CPPUNIT_CHECK( in_val_d != -numeric_limits<F>::infinity() ); \
+ } \
+ { \
+ stringstream str; \
+ \
+ str << "1E" << numeric_limits<F>::min_exponent10; \
+ \
+ str >> in_val_d; \
+ CPPUNIT_ASSERT(!str.fail()); \
+ CPPUNIT_ASSERT(str.eof()); \
+ CPPUNIT_CHECK( in_val_d == in_val_d ); \
+ CPPUNIT_CHECK( in_val_d != F(0.0) ); \
+ } \
+ { \
+ stringstream str; \
+ \
+ str << "1E+" << (numeric_limits<F>::max_exponent10 + 1); \
+ \
+ str >> in_val_d; \
+ CPPUNIT_ASSERT(!str.fail()); \
+ CPPUNIT_ASSERT(str.eof()); \
+ CPPUNIT_CHECK( in_val_d == in_val_d ); \
+ CPPUNIT_CHECK( in_val_d == numeric_limits<F>::infinity() ); \
+ } \
+ { \
+ stringstream str; \
+ \
+ str << "-1E+" << (numeric_limits<F>::max_exponent10 + 1); \
+ \
+ str >> in_val_d; \
+ CPPUNIT_ASSERT(!str.fail()); \
+ CPPUNIT_ASSERT(str.eof()); \
+ CPPUNIT_CHECK( in_val_d == in_val_d ); \
+ CPPUNIT_CHECK( in_val_d == -numeric_limits<F>::infinity() ); \
+ } \
+ { \
+ stringstream str; \
+ \
+ str << "1E" << (numeric_limits<F>::min_exponent10 - 1); \
+ \
+ str >> in_val_d; \
+ CPPUNIT_ASSERT(!str.fail()); \
+ CPPUNIT_ASSERT(str.eof()); \
+ CPPUNIT_CHECK( in_val_d == in_val_d ); \
+ CPPUNIT_CHECK( in_val_d >= F(0.0) && in_val_d <= numeric_limits<F>::min() ); \
+ } \
+ }
+
+ __check_get_float( float )
+ __check_get_float( double )
+# if !defined (STLPORT) || !defined (_STLP_NO_LONG_DOUBLE)
+ __check_get_float( long double )
+# endif
+# undef __check_get_float
+#endif // _STLP_NO_MEMBER_TEMPLATES
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(NumPutGetTest);
+
+#if defined (_MSC_VER)
+# pragma warning (disable : 4056)
+# pragma warning (disable : 4756)
+#endif
+
+//
+// tests implementation
+//
+void NumPutGetTest::num_put_float()
+{
+ {
+ string output, digits;
+
+ {
+ ostringstream ostr;
+ ostr << 1.23457e+17f;
+ CPPUNIT_ASSERT(ostr.good());
+ output = reset_stream(ostr);
+ digits = "17";
+ complete_digits(digits);
+ CPPUNIT_CHECK(output == string("1.23457e+") + digits );
+ }
+
+ {
+ ostringstream ostr;
+ ostr << setprecision(200) << 1.23457e+17f;
+ CPPUNIT_ASSERT(ostr.good());
+ output = reset_stream(ostr);
+ CPPUNIT_CHECK( output.size() < 200 );
+ }
+
+ {
+ ostringstream ostr;
+ ostr << setprecision(200) << numeric_limits<float>::min();
+ CPPUNIT_ASSERT(ostr.good());
+ output = reset_stream(ostr);
+ CPPUNIT_CHECK( output.size() < 200 );
+ }
+
+ {
+ ostringstream ostr;
+ ostr << fixed << 1.23457e+17f;
+ CPPUNIT_ASSERT(ostr.good());
+ output = reset_stream(ostr);
+ CPPUNIT_CHECK(output.size() == 25);
+ CPPUNIT_CHECK(output.substr(0, 5) == "12345");
+ CPPUNIT_CHECK(output.substr(18) == ".000000");
+ }
+
+ {
+ ostringstream ostr;
+ ostr << fixed << showpos << 1.23457e+17f;
+ CPPUNIT_ASSERT(ostr.good());
+ output = reset_stream(ostr);
+ CPPUNIT_CHECK(output.size() == 26);
+ CPPUNIT_CHECK(output.substr(0, 6) == "+12345");
+ CPPUNIT_CHECK(output.substr(19) == ".000000");
+ }
+
+ {
+ ostringstream ostr;
+ ostr << fixed << showpos << setprecision(100) << 1.23457e+17f;
+ CPPUNIT_ASSERT(ostr.good());
+ output = reset_stream(ostr);
+ CPPUNIT_CHECK(output.size() == 120);
+ CPPUNIT_CHECK(output.substr(0, 6) == "+12345");
+ CPPUNIT_CHECK(output.substr(19) == ".0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" );
+ }
+
+ {
+ ostringstream ostr;
+ ostr << scientific << setprecision(8) << 0.12345678f;
+ CPPUNIT_ASSERT(ostr.good());
+ output = reset_stream(ostr);
+ digits = "1";
+ complete_digits(digits);
+ CPPUNIT_CHECK(output == string("1.23456780e-") + digits );
+ }
+
+ {
+ ostringstream ostr;
+ ostr << fixed << setprecision(8) << setw(30) << setfill('0') << 0.12345678f;
+ CPPUNIT_ASSERT(ostr.good());
+ output = reset_stream(ostr);
+ CPPUNIT_CHECK(output == "000000000000000000000.12345678");
+ }
+
+ {
+ ostringstream ostr;
+ ostr << fixed << showpos << setprecision(8) << setw(30) << setfill('0') << 0.12345678f;
+ CPPUNIT_ASSERT(ostr.good());
+ output = reset_stream(ostr);
+ CPPUNIT_CHECK(output == "0000000000000000000+0.12345678");
+ }
+
+ {
+ ostringstream ostr;
+ ostr << fixed << showpos << setprecision(8) << setw(30) << left << setfill('0') << 0.12345678f;
+ CPPUNIT_ASSERT(ostr.good());
+ output = reset_stream(ostr);
+ CPPUNIT_CHECK(output == "+0.123456780000000000000000000");
+ }
+
+ {
+ ostringstream ostr;
+ ostr << fixed << showpos << setprecision(8) << setw(30) << internal << setfill('0') << 0.12345678f;
+ CPPUNIT_ASSERT(ostr.good());
+ output = reset_stream(ostr);
+ CPPUNIT_CHECK(output == "+00000000000000000000.12345678");
+ }
+
+ {
+ ostringstream ostr;
+ ostr << fixed << showpos << setprecision(100) << 1.234567e+17;
+ CPPUNIT_ASSERT(ostr.good());
+ output = reset_stream(ostr);
+ CPPUNIT_CHECK(output.size() == 120);
+ CPPUNIT_CHECK(output.substr(0, 6) == "+12345");
+ CPPUNIT_CHECK(output.substr(19) == ".0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" );
+ }
+
+#if !defined (STLPORT) || !defined (_STLP_NO_LONG_DOUBLE)
+ {
+ ostringstream ostr;
+ ostr << fixed << showpos << setprecision(100) << 1.234567e+17l;
+ CPPUNIT_ASSERT(ostr.good());
+ output = reset_stream(ostr);
+ CPPUNIT_CHECK(output.size() == 120);
+ CPPUNIT_CHECK(output.substr(0, 6) == "+12345");
+ CPPUNIT_CHECK(output.substr(19) == ".0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" );
+ }
+#endif
+
+ {
+ ostringstream ostr;
+ ostr << scientific << setprecision(50) << 0.0;
+ CPPUNIT_ASSERT(ostr.good());
+ output = reset_stream(ostr);
+ CPPUNIT_CHECK( output == "0.00000000000000000000000000000000000000000000000000e+00" );
+ }
+ {
+ ostringstream ostr;
+ ostr << fixed << setprecision(100) << numeric_limits<float>::max();
+ CPPUNIT_ASSERT(ostr.good());
+ output = reset_stream(ostr);
+ //CPPUNIT_MESSAGE( output.c_str() );
+ }
+
+ {
+ ostringstream ostr;
+ ostr << setprecision(100) << numeric_limits<double>::max();
+ CPPUNIT_ASSERT(ostr.good());
+ output = reset_stream(ostr);
+ //CPPUNIT_MESSAGE( output.c_str() );
+ }
+
+#if !defined (STLPORT) || !defined (_STLP_NO_LONG_DOUBLE)
+ {
+ ostringstream ostr;
+ ostr << setprecision(100) << numeric_limits<long double>::max();
+ CPPUNIT_ASSERT(ostr.good());
+ output = reset_stream(ostr);
+ //CPPUNIT_MESSAGE( output.c_str() );
+ }
+#endif
+
+ //{
+ // ostringstream ostr;
+ // ostr << setprecision(-numeric_limits<float>::min_exponent10 + numeric_limits<float>::digits10 + 9) << numeric_limits<float>::min();
+ // CPPUNIT_ASSERT(ostr.good());
+ // output = reset_stream(ostr);
+ // //CPPUNIT_MESSAGE( output.c_str() );
+ //}
+
+ //{
+ // ostringstream ostr;
+ // ostr << setprecision(-numeric_limits<double>::min_exponent10 + numeric_limits<double>::digits10) << numeric_limits<double>::min();
+ // CPPUNIT_ASSERT(ostr.good());
+ // output = reset_stream(ostr);
+ // //CPPUNIT_MESSAGE( output.c_str() );
+ //}
+
+//#if !defined (STLPORT) || !defined (_STLP_NO_LONG_DOUBLE)
+// {
+// ostringstream ostr;
+// ostr << setprecision(-numeric_limits<long double>::min_exponent10 + numeric_limits<long double>::digits10) << numeric_limits<long double>::min();
+// CPPUNIT_ASSERT(ostr.good());
+// output = reset_stream(ostr);
+// CPPUNIT_MESSAGE( output.c_str() );
+// }
+//#endif
+ }
+
+ {
+ ostringstream str;
+
+ str.setf(ios::fixed, ios::floatfield);
+ str << 1.0e+5;
+ // cerr << str.str() << endl;
+ CPPUNIT_CHECK( str.str() == "100000.000000" );
+
+ reset_stream(str);
+ str.precision(0);
+ str << 1.0e+5;
+ CPPUNIT_CHECK( str.str() == "100000" );
+
+ reset_stream(str);
+ str.precision(4);
+ str << 1.0e+5;
+ CPPUNIT_CHECK( str.str() == "100000.0000" );
+
+ reset_stream(str);
+ str.precision(0);
+ str << 1.0e+83;
+ CPPUNIT_CHECK( str.str().size() == 84 );
+ //printf("\nC result: %.0f\n", 1.0e+83);
+ //CPPUNIT_MESSAGE( str.str().c_str() );
+ //CPPUNIT_CHECK( str.str() == "100000000000000000000000000000000000000000000000000000000000000000000000000000000000" );
+
+ // cerr.setf(ios::fixed, ios::floatfield);
+ // cerr << DBL_MAX << endl;
+ // cerr << 1.0e+37 << endl;
+ }
+}
+
+#define CHECK_COMPLETE(type, val, base, showbase, showpos, casing, width, adjust, expected) \
+{ \
+ type tmp = val; \
+ ostringstream ostr; \
+ ostr << base << showbase << showpos << casing << setw(width) << adjust << tmp; \
+ CPPUNIT_CHECK( ostr.str() == expected ); \
+}
+
+#define CHECK(type, val, base, expected) \
+ CHECK_COMPLETE(type, val, base, noshowbase, noshowpos, nouppercase, 0, right, expected)
+
+void NumPutGetTest::num_put_integer()
+{
+ //octal outputs
+ {
+ CHECK(short, 0, oct, "0")
+ CHECK(short, 1, oct, "1")
+ CHECK(short, 12345, oct, "30071")
+ if (sizeof(short) == 2) {
+ CHECK(short, -1, oct, "177777")
+ CHECK(short, -12345, oct, "147707")
+ }
+
+ CHECK(unsigned short, 0, oct, "0")
+ CHECK(unsigned short, 12345, oct, "30071")
+
+ CHECK(int, 0, oct, "0")
+ CHECK(int, 12345678, oct, "57060516")
+ if (sizeof(int) == 4) {
+ CHECK(int, -1, oct, "37777777777")
+ CHECK(int, -12345678, oct, "37720717262")
+ }
+
+ CHECK(unsigned int, 0, oct, "0")
+ CHECK(unsigned int, 12345678, oct, "57060516")
+
+ CHECK(long, 0, oct, "0")
+ CHECK(long, 12345678, oct, "57060516")
+ if (sizeof(long) == 4) {
+ CHECK(long, -1, oct, "37777777777")
+ CHECK(long, -12345678, oct, "37720717262")
+ }
+
+ CHECK(unsigned long, 0, oct, "0")
+ CHECK(unsigned long, 12345678, oct, "57060516")
+
+#if defined (STLPORT) && defined (_STLP_LONG_LONG)
+ CHECK(_STLP_LONG_LONG, 0, oct, "0")
+ CHECK(_STLP_LONG_LONG, 12345678, oct, "57060516")
+ if (sizeof(_STLP_LONG_LONG) == 8) {
+ CHECK(_STLP_LONG_LONG, -1, oct, "1777777777777777777777")
+ CHECK(_STLP_LONG_LONG, -12345678, oct, "1777777777777720717262")
+ }
+
+ CHECK(unsigned _STLP_LONG_LONG, 0, oct, "0")
+ CHECK(unsigned _STLP_LONG_LONG, 12345678, oct, "57060516")
+#endif
+
+ //Even with showbase, 0 value gives "0" (see printf documentation)
+ CHECK_COMPLETE(short, 0, oct, showbase, noshowpos, nouppercase, 0, right, "0")
+ CHECK_COMPLETE(short, 0, oct, showbase, showpos, nouppercase, 6, right, " 0")
+
+ CHECK_COMPLETE(short, 1, oct, showbase, noshowpos, nouppercase, 6, right, " 01")
+ CHECK_COMPLETE(short, 1, oct, showbase, noshowpos, nouppercase, 6, left, "01 ")
+ CHECK_COMPLETE(short, 1, oct, showbase, showpos, nouppercase, 6, internal, " 01")
+ }
+
+ //decimal outputs
+ {
+ CHECK(short, 0, dec, "0")
+ CHECK(short, -1, dec, "-1")
+ CHECK(short, 12345, dec, "12345")
+ CHECK(short, -12345, dec, "-12345")
+
+ CHECK(unsigned short, 0, dec, "0")
+ CHECK(unsigned short, 12345, dec, "12345")
+
+ CHECK(int, 0, dec, "0")
+ CHECK(int, -1, dec, "-1")
+ CHECK(int, 12345678, dec, "12345678")
+ CHECK(int, -12345678, dec, "-12345678")
+
+ CHECK(unsigned int, 0, dec, "0")
+ CHECK(unsigned int, 12345678, dec, "12345678")
+
+ CHECK(long, 0, dec, "0")
+ CHECK(long, -1, dec, "-1")
+ CHECK(long, 12345678, dec, "12345678")
+ CHECK(long, -12345678, dec, "-12345678")
+
+ CHECK(unsigned long, 0, dec, "0")
+ CHECK(unsigned long, 12345678, dec, "12345678")
+#if defined (STLPORT) && defined (_STLP_LONG_LONG)
+ CHECK(_STLP_LONG_LONG, 0, dec, "0")
+ CHECK(_STLP_LONG_LONG, -1, dec, "-1")
+ CHECK(_STLP_LONG_LONG, 12345678, dec, "12345678")
+ CHECK(_STLP_LONG_LONG, -12345678, dec, "-12345678")
+
+ CHECK(unsigned _STLP_LONG_LONG, 0, dec, "0")
+ CHECK(unsigned _STLP_LONG_LONG, 12345678, dec, "12345678")
+#endif
+
+ CHECK_COMPLETE(short, 0, dec, showbase, showpos, nouppercase, 0, right, "+0")
+ CHECK_COMPLETE(short, 0, dec, showbase, showpos, nouppercase, 6, right, " +0")
+ CHECK_COMPLETE(short, 1, dec, showbase, showpos, nouppercase, 6, right, " +1")
+ CHECK_COMPLETE(short, 1, dec, showbase, showpos, nouppercase, 6, left, "+1 ")
+ CHECK_COMPLETE(short, 1, dec, showbase, showpos, nouppercase, 6, internal, "+ 1")
+ }
+
+ //hexadecimal outputs
+ {
+ CHECK(short, 0, hex, "0")
+ CHECK(short, 12345, hex, "3039")
+ if (sizeof(short) == 2) {
+ CHECK(short, -1, hex, "ffff")
+ CHECK(short, -12345, hex, "cfc7")
+ }
+
+ CHECK(unsigned short, 0, hex, "0")
+ CHECK(unsigned short, 12345, hex, "3039")
+
+ CHECK(int, 0, hex, "0")
+ CHECK(int, 12345678, hex, "bc614e")
+ if (sizeof(int) == 4) {
+ CHECK(int, -1, hex, "ffffffff")
+ CHECK(int, -12345678, hex, "ff439eb2")
+ }
+
+ CHECK(unsigned int, 0, hex, "0")
+ CHECK(unsigned int, 12345678, hex, "bc614e")
+
+ CHECK(long, 0, hex, "0")
+ CHECK(long, 12345678, hex, "bc614e")
+ if (sizeof(long) == 4) {
+ CHECK(long, -1, hex, "ffffffff")
+ CHECK(long, -12345678, hex, "ff439eb2")
+ }
+
+ CHECK(unsigned long, 0, hex, "0")
+ CHECK(unsigned long, 12345678, hex, "bc614e")
+#if defined (STLPORT) && defined (_STLP_LONG_LONG)
+ CHECK(_STLP_LONG_LONG, 0, hex, "0")
+ CHECK(_STLP_LONG_LONG, 12345678, hex, "bc614e")
+ if (sizeof(_STLP_LONG_LONG) == 8) {
+ CHECK(_STLP_LONG_LONG, -1, hex, "ffffffffffffffff")
+ CHECK(_STLP_LONG_LONG, -12345678, hex, "ffffffffff439eb2")
+ }
+
+ CHECK(unsigned _STLP_LONG_LONG, 0, hex, "0")
+ CHECK(unsigned _STLP_LONG_LONG, 12345678, hex, "bc614e")
+#endif
+
+ //Even with showbase, 0 value gives "0" output (see printf documentation)
+ CHECK_COMPLETE(short, 0, hex, showbase, showpos, nouppercase, 0, right, "0")
+ CHECK_COMPLETE(short, 0, hex, showbase, noshowpos, nouppercase, 6, right, " 0")
+ CHECK_COMPLETE(short, 0, hex, showbase, noshowpos, nouppercase, 6, internal, " 0")
+
+ CHECK_COMPLETE(short, 1, hex, showbase, noshowpos, nouppercase, 6, right, " 0x1")
+ CHECK_COMPLETE(short, 1, hex, showbase, noshowpos, nouppercase, 6, left, "0x1 ")
+ CHECK_COMPLETE(short, 1, hex, showbase, noshowpos, nouppercase, 6, internal, "0x 1")
+ CHECK_COMPLETE(short, 1, hex, showbase, noshowpos, uppercase, 6, left, "0X1 ")
+ CHECK_COMPLETE(short, 1, hex, showbase, showpos, uppercase, 6, internal, "0X 1")
+ }
+}
+
+void NumPutGetTest::num_get_float()
+{
+ float in_val;
+
+ istringstream istr;
+
+ istr.str("1.2345");
+ istr >> in_val;
+ CPPUNIT_ASSERT(!istr.fail());
+ CPPUNIT_ASSERT(istr.eof());
+ CPPUNIT_ASSERT(check_float(in_val, 1.2345f));
+ istr.clear();
+
+ istr.str("-1.2345");
+ istr >> in_val;
+ CPPUNIT_ASSERT(!istr.fail());
+ CPPUNIT_ASSERT(istr.eof());
+ CPPUNIT_ASSERT(check_float(in_val, -1.2345f));
+ istr.clear();
+
+ istr.str("+1.2345");
+ istr >> in_val;
+ CPPUNIT_ASSERT(!istr.fail());
+ CPPUNIT_ASSERT(check_float(in_val, 1.2345f));
+ istr.clear();
+
+ istr.str("000000000000001.234500000000");
+ istr >> in_val;
+ CPPUNIT_ASSERT(!istr.fail());
+ CPPUNIT_ASSERT(istr.eof());
+ CPPUNIT_ASSERT(check_float(in_val, 1.2345f));
+ istr.clear();
+
+ istr.str("1.2345e+04");
+ istr >> in_val;
+ CPPUNIT_ASSERT(!istr.fail());
+ CPPUNIT_ASSERT(istr.eof());
+ CPPUNIT_ASSERT(check_float(in_val, 12345.0f));
+ istr.clear();
+
+ CPPUNIT_MESSAGE( "float" );
+ check_get_float( 0.0F );
+ CPPUNIT_MESSAGE( "double" );
+ check_get_float( 0.0 );
+#if !defined (STLPORT) || !defined (_STLP_NO_LONG_DOUBLE)
+ CPPUNIT_MESSAGE( "long double" );
+ check_get_float( 0.0L );
+#endif
+ {
+ stringstream str;
+
+ str << "1e" << numeric_limits<double>::max_exponent10;
+ CPPUNIT_ASSERT(!str.fail());
+
+ float val;
+ str >> val;
+ CPPUNIT_ASSERT(!str.fail());
+ CPPUNIT_ASSERT(str.eof());
+ CPPUNIT_ASSERT( numeric_limits<double>::max_exponent10 <= numeric_limits<float>::max_exponent10 ||
+ val == numeric_limits<float>::infinity() );
+ }
+ {
+ stringstream str;
+
+ str << "1e" << numeric_limits<double>::min_exponent10;
+ CPPUNIT_ASSERT(!str.fail());
+
+ float val;
+ str >> val;
+ CPPUNIT_ASSERT(!str.fail());
+ CPPUNIT_ASSERT(str.eof());
+ CPPUNIT_ASSERT( numeric_limits<double>::min_exponent10 >= numeric_limits<float>::min_exponent10 ||
+ val == 0.0f );
+ }
+#if !defined (STLPORT) || !defined (_STLP_NO_LONG_DOUBLE)
+ {
+ stringstream str;
+
+ str << "1e" << numeric_limits<long double>::max_exponent10;
+ CPPUNIT_ASSERT(!str.fail());
+
+ double val;
+ str >> val;
+ CPPUNIT_ASSERT(!str.fail());
+ CPPUNIT_ASSERT(str.eof());
+ CPPUNIT_ASSERT( numeric_limits<long double>::max_exponent10 <= numeric_limits<double>::max_exponent10 ||
+ val == numeric_limits<double>::infinity() );
+ }
+ {
+ stringstream str;
+
+ str << "1e" << numeric_limits<long double>::min_exponent10;
+ CPPUNIT_ASSERT(!str.fail());
+
+ double val;
+ str >> val;
+ CPPUNIT_ASSERT(!str.fail());
+ CPPUNIT_ASSERT(str.eof());
+ CPPUNIT_ASSERT( numeric_limits<long double>::min_exponent10 >= numeric_limits<double>::min_exponent10 ||
+ val == 0.0 );
+ }
+ {
+ const char* p = "2.718281828459045235360287471352662497757247093e0";
+ std::stringstream s;
+ s << p;
+ long double x;
+ s >> x;
+ CPPUNIT_ASSERT( x > 2.70l && x < 2.72l );
+ }
+#endif
+}
+
+void NumPutGetTest::num_get_integer()
+{
+ //octal input
+ {
+ istringstream istr;
+ istr.str("30071");
+ short val;
+ istr >> oct >> val;
+ CPPUNIT_ASSERT( !istr.fail() );
+ CPPUNIT_ASSERT( istr.eof() );
+ CPPUNIT_ASSERT( val == 12345 );
+ istr.clear();
+
+ if (sizeof(short) == 2) {
+ istr.str("177777");
+ istr >> oct >> val;
+ CPPUNIT_ASSERT( !istr.fail() );
+ CPPUNIT_ASSERT( istr.eof() );
+ CPPUNIT_ASSERT( val == -1 );
+ istr.clear();
+ }
+ }
+
+ //decimal input
+ {
+ istringstream istr;
+ istr.str("10000");
+ short val = -1;
+ istr >> val;
+ CPPUNIT_ASSERT( !istr.fail() );
+ CPPUNIT_ASSERT( istr.eof() );
+ CPPUNIT_ASSERT( val == 10000 );
+ istr.clear();
+
+ istr.str("+10000");
+ val = -1;
+ istr >> val;
+ CPPUNIT_ASSERT( !istr.fail() );
+ CPPUNIT_ASSERT( istr.eof() );
+ CPPUNIT_ASSERT( val == 10000 );
+ istr.clear();
+
+ if (sizeof(short) == 2) {
+ val = -1;
+ istr.str("10000000");
+ istr >> val;
+ CPPUNIT_ASSERT( istr.fail() );
+ CPPUNIT_ASSERT( istr.eof() );
+ CPPUNIT_ASSERT( val == -1 );
+ istr.clear();
+ }
+
+ val = -1;
+ istr.str("0x0");
+ istr >> val;
+ CPPUNIT_ASSERT( !istr.fail() );
+ CPPUNIT_ASSERT( !istr.eof() );
+ CPPUNIT_ASSERT( val == 0 );
+ istr.clear();
+
+ val = -1;
+ istr.str("000001");
+ istr >> val;
+ CPPUNIT_ASSERT( !istr.fail() );
+ CPPUNIT_ASSERT( istr.eof() );
+ CPPUNIT_ASSERT( val == 1 );
+ istr.clear();
+ }
+
+ //hexadecimal input
+ {
+ istringstream istr;
+ istr.str("3039");
+ short val = -1;
+ istr >> hex >> val;
+ CPPUNIT_ASSERT( !istr.fail() );
+ CPPUNIT_ASSERT( istr.eof() );
+ CPPUNIT_ASSERT( val == 12345 );
+ istr.clear();
+
+ istr.str("x3039");
+ val = -1;
+ istr >> hex >> val;
+ CPPUNIT_ASSERT( istr.fail() );
+ CPPUNIT_ASSERT( !istr.eof() );
+ CPPUNIT_ASSERT( val == -1 );
+ istr.clear();
+
+ istr.str("03039");
+ val = -1;
+ istr >> hex >> val;
+ CPPUNIT_ASSERT( !istr.fail() );
+ CPPUNIT_ASSERT( istr.eof() );
+ CPPUNIT_ASSERT( val == 12345 );
+ istr.clear();
+
+ istr.str("0x3039");
+ istr >> hex >> val;
+ CPPUNIT_ASSERT( !istr.fail() );
+ CPPUNIT_ASSERT( istr.eof() );
+ CPPUNIT_ASSERT( val == 12345 );
+ istr.clear();
+
+ if (sizeof(short) == 2) {
+ val = -1;
+ istr.str("cfc7");
+ istr >> hex >> val;
+ CPPUNIT_ASSERT( !istr.fail() );
+ CPPUNIT_ASSERT( istr.eof() );
+ CPPUNIT_ASSERT( val == -12345 );
+ istr.clear();
+ }
+ }
+}
+
+void NumPutGetTest::inhex()
+{
+ {
+ ostringstream s;
+ s << hex << 0;
+ CPPUNIT_CHECK( s.str() == "0" );
+ }
+ {
+ ostringstream s;
+ s << hex << 0xff;
+ CPPUNIT_CHECK( s.str() == "ff" );
+ }
+ {
+ ostringstream s;
+ s << hex << setw( 4 ) << 0xff;
+ CPPUNIT_CHECK( s.str() == " ff" );
+ }
+ {
+ ostringstream s;
+ s << hex << setw( 4 ) << 0;
+ CPPUNIT_CHECK( s.str() == " 0" );
+ }
+ {
+ ostringstream s;
+ s << hex << showbase << 0;
+ CPPUNIT_CHECK( s.str() == "0" );
+ }
+ {
+ ostringstream s;
+ s << hex << showbase << 0xff;
+ CPPUNIT_CHECK( s.str() == "0xff" );
+ }
+ {
+ ostringstream s;
+ s << hex << showbase << setw( 4 ) << 0xff;
+ CPPUNIT_CHECK( s.str() == "0xff" );
+ }
+ { // special case for regression (partially duplicate CHECK_COMPLETE above):
+ ostringstream s;
+ s.setf( ios_base::internal, ios_base::adjustfield );
+ s << hex << showbase << setw(8+2) << 0;
+ CPPUNIT_CHECK( s.str() == " 0" );
+ }
+}
+
+void NumPutGetTest::pointer()
+{
+ // Problem with printing pointer to null
+
+ /*
+ * Really C's formatting not help here, due to:
+ *
+ * p The argument shall be a pointer to void. The value of
+ * the pointer is converted to a sequence of printable characters,
+ * in an implementation-defined manner.
+ */
+ {
+ /*
+ char buf[128];
+ void *p = (void *)0xff00;
+ sprintf( buf, "%p", p );
+ // cerr << buf << endl;
+ // Hmmm, I see 0xff00 on box with 32-bits address; pointer like 'unsigned hex'?
+ if ( sizeof( p ) == 2 ) {
+ CPPUNIT_ASSERT( strcmp( buf, "0xff00" ) == 0 );
+ } else if ( sizeof( p ) == 4 ) {
+ CPPUNIT_ASSERT( strcmp( buf, "0x0000ff00" ) == 0 );
+ } else if ( sizeof( p ) == 8 ) {
+ CPPUNIT_ASSERT( strcmp( buf, "0x000000000000ff00" ) == 0 );
+ } else {
+ CPPUNIT_CHECK( sizeof( p ) == 2 || sizeof( p ) == 4 || sizeof( p ) == 8 );
+ }
+ */
+ }
+ {
+ /*
+ char buf[128];
+ void *p = 0;
+ */
+ // sprintf( buf, "%p", p );
+ /* Cool. "%p" print '(nil)'; "%#x" print '0' */
+ // sprintf( buf, "%#x", (unsigned)p );
+ // cerr << buf << endl;
+ }
+ {
+ ostringstream s;
+ void *p = (void *)0xff00;
+ s << p;
+ CPPUNIT_ASSERT( s.good() );
+ if ( sizeof( p ) == 2 ) {
+ CPPUNIT_ASSERT( s.str() == "0xff00" );
+ } else if ( sizeof( p ) == 4 ) {
+ CPPUNIT_ASSERT( s.str() == "0x0000ff00" ); // this pass
+ } else if ( sizeof( p ) == 8 ) {
+ CPPUNIT_ASSERT( s.str() == "0x000000000000ff00" );
+ } else {
+ CPPUNIT_CHECK( sizeof( p ) == 2 || sizeof( p ) == 4 || sizeof( p ) == 8 );
+ }
+ }
+ {
+ ostringstream s;
+ void *p = 0;
+ s << p;
+ CPPUNIT_ASSERT( s.good() );
+ if ( sizeof( p ) == 2 ) {
+ CPPUNIT_ASSERT( s.str() == "0x0000" );
+ } else if ( sizeof( p ) == 4 ) {
+ CPPUNIT_ASSERT( s.str() == "0x00000000" ); // but this will fail, if follow %p
+ } else if ( sizeof( p ) == 8 ) {
+ CPPUNIT_ASSERT( s.str() == "0x0000000000000000" );
+ } else {
+ CPPUNIT_CHECK( sizeof( p ) == 2 || sizeof( p ) == 4 || sizeof( p ) == 8 );
+ }
+ }
+}
+
+void NumPutGetTest::fix_float_long()
+{
+ ostringstream str;
+
+ str.setf(ios::fixed, ios::floatfield);
+ str << 1.0e+5;
+ CPPUNIT_CHECK( str.str() == "100000.000000" );
+
+ reset_stream(str);
+ str.precision(0);
+ str << 1.0e+5;
+ CPPUNIT_CHECK( str.str() == "100000" );
+
+ reset_stream(str);
+ str.precision(4);
+ str << 1.0e+5;
+ CPPUNIT_CHECK( str.str() == "100000.0000" );
+
+ reset_stream(str);
+ str.precision(0);
+ str << 1.0e+83;
+ {
+ istringstream istr( str.str() );
+ double f;
+ istr >> f;
+ CPPUNIT_CHECK( !istr.fail() );
+ if ( int(numeric_limits<double>::digits10) < 83 ) {
+ double delta = 1.0;
+ for ( int ee = 83 - int(numeric_limits<double>::digits10); ee > 0; --ee ) {
+ delta *= 10.0;
+ }
+ // we may loss some digits here, but not more than mantissa:
+ CPPUNIT_CHECK( (f > (1.0e+83 - delta)) && (f < (1.0e+83 + delta)) );
+ } else {
+ CPPUNIT_CHECK( check_double(f, 1.0e+83) );
+ }
+ }
+
+#if 0 // #ifndef _STLP_NO_LONG_DOUBLE
+ reset_stream(str);
+ str.precision(0);
+ str << 1.0e+83l;
+ {
+ istringstream istr( str.str() );
+ long double f;
+ istr >> f;
+ CPPUNIT_CHECK( !istr.fail() );
+ if ( int(numeric_limits<long double>::digits10) < 83 ) {
+ long double delta = 1.0l;
+ for ( int ee = 83 - int(numeric_limits<long double>::digits10); ee > 0; --ee ) {
+ delta *= 10.0l;
+ }
+ // we may loss some digits here, but not more than mantissa:
+ cerr << "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" << endl;
+ cerr << str.str() << endl;
+ cerr << delta << endl;
+ cerr << f << endl;
+ CPPUNIT_CHECK( (f > (1.0e+83l - delta)) && (f < (1.0e+83l + delta)) );
+ } else {
+ CPPUNIT_CHECK( check_double(f, 1.0e+83l) );
+ }
+ }
+#endif
+
+ reset_stream(str);
+ str.precision(0);
+ str << numeric_limits<double>::max();
+ {
+ istringstream istr( str.str() );
+ double f;
+ istr >> f;
+ CPPUNIT_CHECK( !istr.fail() );
+ if ( int(numeric_limits<double>::digits10) < int(numeric_limits<double>::max_exponent10) ) {
+ double delta = 9.0;
+ for ( int ee = int(numeric_limits<double>::max_exponent10) - int(numeric_limits<double>::digits10); ee > 0; --ee ) {
+ delta *= 10.0;
+ }
+ // we may loss some digits here, but not more than mantissa:
+ CPPUNIT_CHECK( (f > (numeric_limits<double>::max() - delta)) );
+ }
+ }
+
+#if 0 // #ifndef _STLP_NO_LONG_DOUBLE
+ reset_stream(str);
+ str.precision(0);
+ str << numeric_limits<long double>::max();
+ {
+ istringstream istr( str.str() );
+ long double f;
+ istr >> f;
+ CPPUNIT_CHECK( !istr.fail() );
+ if ( int(numeric_limits<long double>::digits10) < int(numeric_limits<long double>::max_exponent10) ) {
+ long double delta = 1.0l;
+ for ( int ee = int(numeric_limits<long double>::max_exponent10) - int(numeric_limits<long double>::digits10); ee > 0; --ee ) {
+ delta *= 10.0l;
+ }
+ // we may loss some digits here, but not more than mantissa:
+ CPPUNIT_CHECK( (f > (numeric_limits<long double>::max() - delta)) );
+ }
+ }
+#endif
+}
+
+class CommaSepNumPunct : public numpunct<char> {
+ char do_thousands_sep() const { return ','; }
+ string do_grouping() const { return string("\1\2\3") + (char)CHAR_MAX; }
+};
+
+#define CHECK2(val, expected) \
+ os.str(""); os << fixed << setprecision(3) << showpos << val; \
+ CPPUNIT_ASSERT( os.str() == expected )
+
+void NumPutGetTest::custom_numpunct()
+{
+ ostringstream os;
+ locale loc(os.getloc(), new CommaSepNumPunct());
+ os.imbue(loc);
+
+ CHECK2(1, "+1");
+ CHECK2(10, "+1,0");
+ CHECK2(100, "+10,0");
+ CHECK2(1000, "+1,00,0");
+
+ CHECK2(1.234, "+1.234");
+ CHECK2(123.456, "+12,3.456");
+ CHECK2(1234.567, "+1,23,4.567");
+ CHECK2(12345.678, "+12,34,5.678");
+ CHECK2(123456.789, "+123,45,6.789");
+ CHECK2(1234567.891, "+1,234,56,7.891");
+ CHECK2(123456789.123, "+123,456,78,9.123");
+ //CHECK2(100000000000000000000000000000.0, "+100000000000000000000000,000,00,0.000");
+ CHECK2(numeric_limits<double>::infinity(), "+inf");
+
+ CHECK2(-1.234, "-1.234");
+ CHECK2(-123.456, "-12,3.456");
+ CHECK2(-1234.567, "-1,23,4.567");
+ CHECK2(-12345.678, "-12,34,5.678");
+ CHECK2(-123456.789, "-123,45,6.789");
+ CHECK2(-1234567.891, "-1,234,56,7.891");
+ CHECK2(-123456789.123, "-123,456,78,9.123");
+ //CHECK2(-100000000000000000000000000000.0, "-100000000000000000000000,000,00,0.000");
+ CHECK2(-numeric_limits<double>::infinity(), "-inf");
+}
+
+#endif
diff --git a/sources/android/stlport/test/unit/numeric_header_test.cpp b/sources/android/stlport/test/unit/numeric_header_test.cpp
new file mode 100644
index 0000000..38d23dd
--- /dev/null
+++ b/sources/android/stlport/test/unit/numeric_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <numeric>
diff --git a/sources/android/stlport/test/unit/ostmit_test.cpp b/sources/android/stlport/test/unit/ostmit_test.cpp
new file mode 100644
index 0000000..f94353e
--- /dev/null
+++ b/sources/android/stlport/test/unit/ostmit_test.cpp
@@ -0,0 +1,52 @@
+#include <iterator>
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+#include <string>
+#include <sstream>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class OstreamIteratorTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(OstreamIteratorTest);
+ CPPUNIT_TEST(ostmit0);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void ostmit0();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(OstreamIteratorTest);
+
+//
+// tests implementation
+//
+void OstreamIteratorTest::ostmit0()
+{
+ // not necessary, tested in copy_test
+ int array [] = { 1, 5, 2, 4 };
+
+ const char* text = "hello";
+
+ ostringstream os;
+
+ ostream_iterator<char> iter(os);
+ copy(text, text + 5, iter);
+ CPPUNIT_ASSERT(os.good());
+ os << ' ';
+ CPPUNIT_ASSERT(os.good());
+
+ ostream_iterator<int> iter2(os);
+ copy(array, array + 4, iter2);
+ CPPUNIT_ASSERT(os.good());
+ CPPUNIT_ASSERT(os.str() == "hello 1524");
+}
+
+#endif
diff --git a/sources/android/stlport/test/unit/ostream_header_test.cpp b/sources/android/stlport/test/unit/ostream_header_test.cpp
new file mode 100644
index 0000000..9c9ccb4
--- /dev/null
+++ b/sources/android/stlport/test/unit/ostream_header_test.cpp
@@ -0,0 +1,10 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#if !defined (_STLP_NO_IOSTREAMS)
+# include <ostream>
+#endif
diff --git a/sources/android/stlport/test/unit/pair_test.cpp b/sources/android/stlport/test/unit/pair_test.cpp
new file mode 100644
index 0000000..6fc5172
--- /dev/null
+++ b/sources/android/stlport/test/unit/pair_test.cpp
@@ -0,0 +1,46 @@
+#include <utility>
+#include <vector>
+#include <algorithm>
+#include <string>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+class PairTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(PairTest);
+ CPPUNIT_TEST(pair0);
+ CPPUNIT_TEST(init);
+ CPPUNIT_TEST_SUITE_END();
+
+ protected:
+ void pair0();
+ void init();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(PairTest);
+
+void PairTest::pair0()
+{
+ pair<int, int> p = make_pair(1, 10);
+
+ CPPUNIT_ASSERT(p.first==1);
+ CPPUNIT_ASSERT(p.second==10);
+}
+
+void PairTest::init()
+{
+ pair<int, string> PAIR_ARRAY[] = { pair<int, string>(0, "0") };
+
+ int PAIR_ARRAY_SIZE = sizeof(PAIR_ARRAY) > 0 ? sizeof(PAIR_ARRAY) / sizeof(PAIR_ARRAY[0]) : 0;
+
+
+ for ( int i = 0; i < PAIR_ARRAY_SIZE; i++ ) {
+ CPPUNIT_CHECK( PAIR_ARRAY[i].first == 0 );
+ CPPUNIT_CHECK( PAIR_ARRAY[i].second == "0" );
+ PAIR_ARRAY[i].second = "1";
+ }
+}
diff --git a/sources/android/stlport/test/unit/partial_test.cpp b/sources/android/stlport/test/unit/partial_test.cpp
new file mode 100644
index 0000000..b7650fd
--- /dev/null
+++ b/sources/android/stlport/test/unit/partial_test.cpp
@@ -0,0 +1,248 @@
+#include <numeric>
+#include <vector>
+#include <algorithm>
+#include <functional>
+
+#if defined (STLPORT) && defined (_STLP_DEBUG) && defined (_STLP_DEBUG_MODE_THROWS)
+# define _STLP_DO_CHECK_BAD_PREDICATE
+# include <stdexcept>
+#endif
+
+#include "iota.h"
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class PartialTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(PartialTest);
+ CPPUNIT_TEST(parsrt0);
+ CPPUNIT_TEST(parsrt1);
+ CPPUNIT_TEST(parsrt2);
+ CPPUNIT_TEST(parsrtc0);
+ CPPUNIT_TEST(parsrtc1);
+ CPPUNIT_TEST(parsrtc2);
+#if defined (_STLP_DO_CHECK_BAD_PREDICATE)
+ CPPUNIT_TEST(bad_predicate_detected);
+#endif
+ CPPUNIT_TEST(partsum0);
+ CPPUNIT_TEST(partsum1);
+ CPPUNIT_TEST(partsum2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void parsrt0();
+ void parsrt1();
+ void parsrt2();
+ void parsrtc0();
+ void parsrtc1();
+ void parsrtc2();
+ void partsum0();
+ void partsum1();
+ void partsum2();
+ void bad_predicate_detected();
+
+ static bool str_compare(const char* a_, const char* b_)
+ {
+ return strcmp(a_, b_) < 0 ? 1 : 0;
+ }
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(PartialTest);
+
+//
+// tests implementation
+//
+void PartialTest::parsrt0()
+{
+ int numbers[6] = { 5, 2, 4, 3, 1, 6 };
+
+ partial_sort((int*)numbers, (int*)numbers + 3, (int*)numbers + 6);
+
+ // 1 2 3 5 4 6
+ CPPUNIT_ASSERT(numbers[0]==1);
+ CPPUNIT_ASSERT(numbers[1]==2);
+ CPPUNIT_ASSERT(numbers[2]==3);
+ CPPUNIT_ASSERT(numbers[3]==5);
+ CPPUNIT_ASSERT(numbers[4]==4);
+ CPPUNIT_ASSERT(numbers[5]==6);
+}
+
+void PartialTest::parsrt1()
+{
+ // 8 8 5 3 7 6 5 3 2 4
+ // 2 3 3 4 5 8 8 7 6 5
+ int numbers[10] ={ 8, 8, 5, 3, 7, 6, 5, 3, 2, 4 };
+
+ vector <int> v1(numbers, numbers+10);
+ partial_sort(v1.begin(), v1.begin() + v1.size() / 2, v1.end());
+
+ CPPUNIT_ASSERT(v1[0]==2);
+ CPPUNIT_ASSERT(v1[1]==3);
+ CPPUNIT_ASSERT(v1[2]==3);
+ CPPUNIT_ASSERT(v1[3]==4);
+ CPPUNIT_ASSERT(v1[4]==5);
+ CPPUNIT_ASSERT(v1[5]==8);
+ CPPUNIT_ASSERT(v1[6]==8);
+ CPPUNIT_ASSERT(v1[7]==7);
+ CPPUNIT_ASSERT(v1[8]==6);
+ CPPUNIT_ASSERT(v1[9]==5);
+}
+
+void PartialTest::parsrt2()
+{
+ char const* names[] = { "aa", "ff", "dd", "ee", "cc", "bb" };
+
+ const unsigned nameSize = sizeof(names) / sizeof(names[0]);
+ vector <char const*> v1(nameSize);
+ for(size_t i = 0; i < v1.size(); i++)
+ v1[i] = names[i];
+
+ partial_sort(v1.begin(), v1.begin() + nameSize / 2, v1.end(), str_compare);
+
+ // aa bb cc ff ee dd
+ CPPUNIT_ASSERT( strcmp(v1[0], "aa") == 0 );
+ CPPUNIT_ASSERT( v1[0] == names[0] );
+ CPPUNIT_ASSERT( strcmp(v1[1], "bb") == 0 );
+ CPPUNIT_ASSERT( v1[1] == names[5] );
+ CPPUNIT_ASSERT( strcmp(v1[2], "cc") == 0 );
+ CPPUNIT_ASSERT( v1[2] == names[4] );
+ CPPUNIT_ASSERT( strcmp(v1[3], "ff") == 0 );
+ CPPUNIT_ASSERT( v1[3] == names[1] );
+ CPPUNIT_ASSERT( strcmp(v1[4], "ee") == 0 );
+ CPPUNIT_ASSERT( v1[4] == names[3] );
+ CPPUNIT_ASSERT( strcmp(v1[5], "dd") == 0 );
+ CPPUNIT_ASSERT( v1[5] == names[2] );
+}
+
+void PartialTest::parsrtc0()
+{
+ int numbers[6] = { 5, 2, 4, 3, 1, 6 };
+
+ int result[3];
+ partial_sort_copy((int*)numbers, (int*)numbers + 6, (int*)result, (int*)result + 3);
+ //1 2 3
+ CPPUNIT_ASSERT(result[0]==1);
+ CPPUNIT_ASSERT(result[1]==2);
+ CPPUNIT_ASSERT(result[2]==3);
+}
+
+void PartialTest::parsrtc1()
+{
+ int numbers[10] ={ 3, 0, 4, 3, 2, 8, 2, 7, 7, 5 };
+
+ //3 0 4 3 2 8 2 7 7 5
+ //0 2 2 3 3
+
+ vector <int> v1(numbers, numbers+10);
+ vector <int> result(5);
+
+ partial_sort_copy(v1.begin(), v1.end(), result.begin(), result.end());
+ CPPUNIT_ASSERT(result[0]==0);
+ CPPUNIT_ASSERT(result[1]==2);
+ CPPUNIT_ASSERT(result[2]==2);
+ CPPUNIT_ASSERT(result[3]==3);
+ CPPUNIT_ASSERT(result[4]==3);
+}
+
+void PartialTest::parsrtc2()
+{
+ char const* names[] = { "aa", "ff", "dd", "ee", "cc", "bb" };
+
+ const unsigned nameSize = sizeof(names) / sizeof(names[0]);
+ vector <char const*> v1(nameSize);
+ for(size_t i = 0; i < v1.size(); i++)
+ v1[i] = names[i];
+ vector <char const*> result(3);
+ partial_sort_copy(v1.begin(), v1.end(), result.begin(), result.end(), str_compare);
+
+ // aa bb cc
+ CPPUNIT_ASSERT( strcmp( result[0], "aa" ) == 0 );
+ CPPUNIT_ASSERT( result[0] == names[0] );
+ CPPUNIT_ASSERT( strcmp( result[1], "bb" ) == 0 );
+ CPPUNIT_ASSERT( result[1] == names[5] );
+ CPPUNIT_ASSERT( strcmp( result[2], "cc" ) == 0 );
+ CPPUNIT_ASSERT( result[2] == names[4] );
+}
+
+#if defined (_STLP_DO_CHECK_BAD_PREDICATE)
+void PartialTest::bad_predicate_detected()
+{
+ int numbers[] = { 0, 0, 1, 0, 0, 1, 0, 0 };
+ const size_t s = sizeof(numbers) / sizeof(numbers[0]);
+
+ try {
+ partial_sort(numbers, numbers + s / 2, numbers + s, less_equal<int>());
+
+ //Here is means that no exception has been raised
+ CPPUNIT_ASSERT( false );
+ }
+ catch (runtime_error const&)
+ { /*OK bad predicate has been detected.*/ }
+
+ try {
+ vector<int> result(s);
+ partial_sort_copy(numbers, numbers + s, result.begin(), result.end(), less_equal<int>());
+
+ //Here is means that no exception has been raised
+ CPPUNIT_ASSERT( false );
+ }
+ catch (runtime_error const&)
+ { /*OK bad predicate has been detected.*/ }
+}
+#endif
+
+void PartialTest::partsum0()
+{
+ int numbers[6] = { 1, 2, 3, 4, 5, 6 };
+
+ int result[6];
+ partial_sum((int*)numbers, (int*)numbers + 6, (int*)result);
+
+ // 1 3 6 10 15 21
+ CPPUNIT_ASSERT(result[0]==1);
+ CPPUNIT_ASSERT(result[1]==3);
+ CPPUNIT_ASSERT(result[2]==6);
+ CPPUNIT_ASSERT(result[3]==10);
+ CPPUNIT_ASSERT(result[4]==15);
+ CPPUNIT_ASSERT(result[5]==21);
+}
+
+void PartialTest::partsum1()
+{
+ vector <int> v1(10);
+ __iota(v1.begin(), v1.end(), 0);
+ vector <int> v2(v1.size());
+ partial_sum(v1.begin(), v1.end(), v2.begin());
+
+ // 0 1 3 6 10 15 21 28 36 45
+ CPPUNIT_ASSERT(v2[0]==0);
+ CPPUNIT_ASSERT(v2[1]==1);
+ CPPUNIT_ASSERT(v2[2]==3);
+ CPPUNIT_ASSERT(v2[3]==6);
+ CPPUNIT_ASSERT(v2[4]==10);
+ CPPUNIT_ASSERT(v2[5]==15);
+ CPPUNIT_ASSERT(v2[6]==21);
+ CPPUNIT_ASSERT(v2[7]==28);
+ CPPUNIT_ASSERT(v2[8]==36);
+ CPPUNIT_ASSERT(v2[9]==45);
+}
+
+void PartialTest::partsum2()
+{
+ vector <int> v1(5);
+ __iota(v1.begin(), v1.end(), 1);
+ vector <int> v2(v1.size());
+ partial_sum(v1.begin(), v1.end(), v2.begin(), multiplies<int>());
+ // 1 2 6 24 120
+ CPPUNIT_ASSERT(v2[0]==1);
+ CPPUNIT_ASSERT(v2[1]==2);
+ CPPUNIT_ASSERT(v2[2]==6);
+ CPPUNIT_ASSERT(v2[3]==24);
+ CPPUNIT_ASSERT(v2[4]==120);
+}
diff --git a/sources/android/stlport/test/unit/partition_test.cpp b/sources/android/stlport/test/unit/partition_test.cpp
new file mode 100644
index 0000000..cc5c91b
--- /dev/null
+++ b/sources/android/stlport/test/unit/partition_test.cpp
@@ -0,0 +1,130 @@
+#include <algorithm>
+#include <vector>
+#include <cstdlib>
+#include <iterator>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class PartitionTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(PartitionTest);
+ CPPUNIT_TEST(ptition0);
+ CPPUNIT_TEST(ptition1);
+ CPPUNIT_TEST(stblptn0);
+ CPPUNIT_TEST(stblptn1);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void ptition0();
+ void ptition1();
+ void stblptn0();
+ void stblptn1();
+
+ struct less_n {
+ less_n(int limit, size_t &nb_calls)
+ : _limit(limit), _nb_calls(nb_calls) {}
+
+ bool operator() (int a_) const {
+ ++_nb_calls;
+ return a_ < _limit;
+ }
+
+ int _limit;
+ size_t &_nb_calls;
+
+ private:
+ //explicitely defined as private to avoid warnings:
+ less_n& operator = (less_n const&);
+ };
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(PartitionTest);
+
+//
+// tests implementation
+//
+void PartitionTest::stblptn0()
+{
+ int numbers[6] = { 10, 5, 11, 20, 6, -2 };
+
+ size_t nb_pred_calls = 0;
+ stable_partition((int*)numbers, (int*)numbers + 6, less_n(10, nb_pred_calls));
+ // 5 6 -2 10 11 20
+ CPPUNIT_ASSERT(numbers[0]==5);
+ CPPUNIT_ASSERT(numbers[1]==6);
+ CPPUNIT_ASSERT(numbers[2]==-2);
+ CPPUNIT_ASSERT(numbers[3]==10);
+ CPPUNIT_ASSERT(numbers[4]==11);
+ CPPUNIT_ASSERT(numbers[5]==20);
+
+ //Complexity check:
+ CPPUNIT_ASSERT( nb_pred_calls == sizeof(numbers) / sizeof(numbers[0]) );
+}
+void PartitionTest::stblptn1()
+{
+ //5 5 2 10 0 12 5 0 0 19
+ //5 5 2 10 0 5 0 0 12 19
+ int numbers[] = { 5, 5, 2, 10, 0, 12, 5, 0, 0, 19 };
+ vector <int> v1(numbers, numbers+10);
+
+ size_t nb_pred_calls = 0;
+ stable_partition(v1.begin(), v1.end(), less_n(11, nb_pred_calls));
+
+ CPPUNIT_ASSERT(v1[0]==5);
+ CPPUNIT_ASSERT(v1[1]==5);
+ CPPUNIT_ASSERT(v1[2]==2);
+ CPPUNIT_ASSERT(v1[3]==10);
+ CPPUNIT_ASSERT(v1[4]==0);
+ CPPUNIT_ASSERT(v1[5]==5);
+ CPPUNIT_ASSERT(v1[6]==0);
+ CPPUNIT_ASSERT(v1[7]==0);
+ CPPUNIT_ASSERT(v1[8]==12);
+ CPPUNIT_ASSERT(v1[9]==19);
+ CPPUNIT_ASSERT( nb_pred_calls == v1.size() );
+}
+void PartitionTest::ptition0()
+{
+ int numbers[6] = { 6, 12, 3, 10, 1, 20 };
+ size_t nb_pred_calls = 0;
+ // 6 1 3 10 12 20
+ partition((int*)numbers, (int*)numbers + 6, less_n(10, nb_pred_calls));
+ CPPUNIT_ASSERT(numbers[0]==6);
+ CPPUNIT_ASSERT(numbers[1]==1);
+ CPPUNIT_ASSERT(numbers[2]==3);
+ CPPUNIT_ASSERT(numbers[3]==10);
+ CPPUNIT_ASSERT(numbers[4]==12);
+ CPPUNIT_ASSERT(numbers[5]==20);
+
+ CPPUNIT_ASSERT( nb_pred_calls == sizeof(numbers) / sizeof(numbers[0]) );
+}
+void PartitionTest::ptition1()
+{
+ // 19 3 11 14 10 19 8 17 9 6
+ // 6 3 9 8 10 19 14 17 11 19
+
+ int numbers[10] ={ 19, 3, 11, 14, 10, 19, 8, 17, 9, 6 };
+
+ vector <int> v1(numbers, numbers+10);
+ size_t nb_pred_calls = 0;
+ partition(v1.begin(), v1.end(), less_n(11, nb_pred_calls));
+
+ CPPUNIT_ASSERT(v1[0]==6);
+ CPPUNIT_ASSERT(v1[1]==3);
+ CPPUNIT_ASSERT(v1[2]==9);
+ CPPUNIT_ASSERT(v1[3]==8);
+ CPPUNIT_ASSERT(v1[4]==10);
+ CPPUNIT_ASSERT(v1[5]==19);
+ CPPUNIT_ASSERT(v1[6]==14);
+ CPPUNIT_ASSERT(v1[7]==17);
+ CPPUNIT_ASSERT(v1[8]==11);
+ CPPUNIT_ASSERT(v1[9]==19);
+ CPPUNIT_ASSERT( nb_pred_calls == v1.size() );
+}
diff --git a/sources/android/stlport/test/unit/perm_test.cpp b/sources/android/stlport/test/unit/perm_test.cpp
new file mode 100644
index 0000000..5be6ea0
--- /dev/null
+++ b/sources/android/stlport/test/unit/perm_test.cpp
@@ -0,0 +1,228 @@
+#include <vector>
+#include <algorithm>
+#include <numeric>
+#include <iterator>
+#include <functional>
+
+#include "iota.h"
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class PermTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(PermTest);
+ CPPUNIT_TEST(nextprm0);
+ CPPUNIT_TEST(nextprm1);
+ CPPUNIT_TEST(nextprm2);
+ CPPUNIT_TEST(prevprm0);
+ CPPUNIT_TEST(prevprm1);
+ CPPUNIT_TEST(prevprm2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void nextprm0();
+ void nextprm1();
+ void nextprm2();
+ void prevprm0();
+ void prevprm1();
+ void prevprm2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(PermTest);
+
+//
+// tests implementation
+//
+void PermTest::prevprm0()
+{
+ int v1[3] = { 0, 1, 2 };
+ prev_permutation(v1, v1 + 3);
+
+ CPPUNIT_ASSERT(v1[0]==2);
+ CPPUNIT_ASSERT(v1[1]==1);
+ CPPUNIT_ASSERT(v1[2]==0);
+}
+void PermTest::prevprm1()
+{
+ vector <int> v1(3);
+ __iota(v1.begin(), v1.end(), 0);
+
+ prev_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==2);
+ CPPUNIT_ASSERT(v1[1]==1);
+ CPPUNIT_ASSERT(v1[2]==0);
+ prev_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==2);
+ CPPUNIT_ASSERT(v1[1]==0);
+ CPPUNIT_ASSERT(v1[2]==1);
+ prev_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==1);
+ CPPUNIT_ASSERT(v1[1]==2);
+ CPPUNIT_ASSERT(v1[2]==0);
+ prev_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==1);
+ CPPUNIT_ASSERT(v1[1]==0);
+ CPPUNIT_ASSERT(v1[2]==2);
+ prev_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==0);
+ CPPUNIT_ASSERT(v1[1]==2);//
+ CPPUNIT_ASSERT(v1[2]==1);
+ prev_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==0);
+ CPPUNIT_ASSERT(v1[1]==1);
+ CPPUNIT_ASSERT(v1[2]==2);
+ prev_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==2);
+ CPPUNIT_ASSERT(v1[1]==1);
+ CPPUNIT_ASSERT(v1[2]==0);
+ prev_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==2);
+ CPPUNIT_ASSERT(v1[1]==0);
+ CPPUNIT_ASSERT(v1[2]==1);
+ prev_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==1);
+ CPPUNIT_ASSERT(v1[1]==2);
+ CPPUNIT_ASSERT(v1[2]==0);
+}
+void PermTest::prevprm2()
+{
+ vector <int> v1(3);
+ __iota(v1.begin(), v1.end(), 0);
+
+ prev_permutation(v1.begin(), v1.end(), greater<int>());
+ CPPUNIT_ASSERT(v1[0]==0);
+ CPPUNIT_ASSERT(v1[1]==2);
+ CPPUNIT_ASSERT(v1[2]==1);
+ prev_permutation(v1.begin(), v1.end(), greater<int>());
+ CPPUNIT_ASSERT(v1[0]==1);
+ CPPUNIT_ASSERT(v1[1]==0);
+ CPPUNIT_ASSERT(v1[2]==2);
+ prev_permutation(v1.begin(), v1.end(), greater<int>());
+ CPPUNIT_ASSERT(v1[0]==1);
+ CPPUNIT_ASSERT(v1[1]==2);
+ CPPUNIT_ASSERT(v1[2]==0);
+ prev_permutation(v1.begin(), v1.end(), greater<int>());
+ CPPUNIT_ASSERT(v1[0]==2);
+ CPPUNIT_ASSERT(v1[1]==0);
+ CPPUNIT_ASSERT(v1[2]==1);
+ prev_permutation(v1.begin(), v1.end(), greater<int>());
+ CPPUNIT_ASSERT(v1[0]==2);
+ CPPUNIT_ASSERT(v1[1]==1);
+ CPPUNIT_ASSERT(v1[2]==0);
+ prev_permutation(v1.begin(), v1.end(), greater<int>());
+ CPPUNIT_ASSERT(v1[0]==0);
+ CPPUNIT_ASSERT(v1[1]==1);
+ CPPUNIT_ASSERT(v1[2]==2);
+ prev_permutation(v1.begin(), v1.end(), greater<int>());
+ CPPUNIT_ASSERT(v1[0]==0);
+ CPPUNIT_ASSERT(v1[1]==2);
+ CPPUNIT_ASSERT(v1[2]==1);
+ prev_permutation(v1.begin(), v1.end(), greater<int>());
+ CPPUNIT_ASSERT(v1[0]==1);
+ CPPUNIT_ASSERT(v1[1]==0);
+ CPPUNIT_ASSERT(v1[2]==2);
+ prev_permutation(v1.begin(), v1.end(), greater<int>());
+ CPPUNIT_ASSERT(v1[0]==1);
+ CPPUNIT_ASSERT(v1[1]==2);
+ CPPUNIT_ASSERT(v1[2]==0);
+}
+void PermTest::nextprm0()
+{
+ int v1[3] = { 0, 1, 2 };
+ next_permutation(v1, v1 + 3);
+
+ CPPUNIT_ASSERT(v1[0]==0);
+ CPPUNIT_ASSERT(v1[1]==2);
+ CPPUNIT_ASSERT(v1[2]==1);
+}
+void PermTest::nextprm1()
+{
+ vector <int> v1(3);
+ __iota(v1.begin(), v1.end(), 0);
+
+ next_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==0);
+ CPPUNIT_ASSERT(v1[1]==2);
+ CPPUNIT_ASSERT(v1[2]==1);
+ next_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==1);
+ CPPUNIT_ASSERT(v1[1]==0);
+ CPPUNIT_ASSERT(v1[2]==2);
+ next_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==1);
+ CPPUNIT_ASSERT(v1[1]==2);
+ CPPUNIT_ASSERT(v1[2]==0);
+ next_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==2);
+ CPPUNIT_ASSERT(v1[1]==0);
+ CPPUNIT_ASSERT(v1[2]==1);
+ next_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==2);
+ CPPUNIT_ASSERT(v1[1]==1);
+ CPPUNIT_ASSERT(v1[2]==0);
+ next_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==0);
+ CPPUNIT_ASSERT(v1[1]==1);
+ CPPUNIT_ASSERT(v1[2]==2);
+ next_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==0);
+ CPPUNIT_ASSERT(v1[1]==2);
+ CPPUNIT_ASSERT(v1[2]==1);
+ next_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==1);
+ CPPUNIT_ASSERT(v1[1]==0);
+ CPPUNIT_ASSERT(v1[2]==2);
+ next_permutation(v1.begin(), v1.end());
+ CPPUNIT_ASSERT(v1[0]==1);
+ CPPUNIT_ASSERT(v1[1]==2);
+ CPPUNIT_ASSERT(v1[2]==0);
+}
+void PermTest::nextprm2()
+{
+ vector <char> v1(3);
+ __iota(v1.begin(), v1.end(), 'A');
+
+ next_permutation(v1.begin(), v1.end(), less<char>());
+ CPPUNIT_ASSERT(v1[0]=='A');
+ CPPUNIT_ASSERT(v1[1]=='C');
+ CPPUNIT_ASSERT(v1[2]=='B');
+ next_permutation(v1.begin(), v1.end(), less<char>());
+ CPPUNIT_ASSERT(v1[0]=='B');
+ CPPUNIT_ASSERT(v1[1]=='A');
+ CPPUNIT_ASSERT(v1[2]=='C');
+ next_permutation(v1.begin(), v1.end(), less<char>());
+ CPPUNIT_ASSERT(v1[0]=='B');
+ CPPUNIT_ASSERT(v1[1]=='C');
+ CPPUNIT_ASSERT(v1[2]=='A');
+ next_permutation(v1.begin(), v1.end(), less<char>());
+ CPPUNIT_ASSERT(v1[0]=='C');
+ CPPUNIT_ASSERT(v1[1]=='A');
+ CPPUNIT_ASSERT(v1[2]=='B');
+ next_permutation(v1.begin(), v1.end(), less<char>());
+ CPPUNIT_ASSERT(v1[0]=='C');
+ CPPUNIT_ASSERT(v1[1]=='B');
+ CPPUNIT_ASSERT(v1[2]=='A');
+ next_permutation(v1.begin(), v1.end(), less<char>());
+ CPPUNIT_ASSERT(v1[0]=='A');
+ CPPUNIT_ASSERT(v1[1]=='B');
+ CPPUNIT_ASSERT(v1[2]=='C');
+ next_permutation(v1.begin(), v1.end(), less<char>());
+ CPPUNIT_ASSERT(v1[0]=='A');
+ CPPUNIT_ASSERT(v1[1]=='C');
+ CPPUNIT_ASSERT(v1[2]=='B');
+ next_permutation(v1.begin(), v1.end(), less<char>());
+ CPPUNIT_ASSERT(v1[0]=='B');
+ CPPUNIT_ASSERT(v1[1]=='A');
+ CPPUNIT_ASSERT(v1[2]=='C');
+ next_permutation(v1.begin(), v1.end(), less<char>());
+ CPPUNIT_ASSERT(v1[0]=='B');
+ CPPUNIT_ASSERT(v1[1]=='C');
+ CPPUNIT_ASSERT(v1[2]=='A');
+
+}
diff --git a/sources/android/stlport/test/unit/plusminus_test.cpp b/sources/android/stlport/test/unit/plusminus_test.cpp
new file mode 100644
index 0000000..ee6f5c6
--- /dev/null
+++ b/sources/android/stlport/test/unit/plusminus_test.cpp
@@ -0,0 +1,52 @@
+#include <numeric>
+#include <algorithm>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class PlusMinusTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(PlusMinusTest);
+ CPPUNIT_TEST(plus0);
+ CPPUNIT_TEST(minus0);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void plus0();
+ void minus0();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(PlusMinusTest);
+
+//
+// tests implementation
+//
+void PlusMinusTest::plus0()
+{
+ int input1 [4] = { 1, 6, 11, 8 };
+ int input2 [4] = { 1, 5, 2, 3 };
+
+ int total = inner_product(input1, input1 + 4, input2, 0, plus<int>(), multiplies <int>());
+
+ CPPUNIT_ASSERT(total==77);
+}
+void PlusMinusTest::minus0()
+{
+ int input1 [4] = { 1, 5, 7, 8 };
+ int input2 [4] = { 1, 4, 8, 3 };
+
+ int output [4];
+
+ transform((int*)input1, (int*)input1 + 4, (int*)input2, (int*)output, minus<int>());
+ CPPUNIT_ASSERT(output[0]==0);
+ CPPUNIT_ASSERT(output[1]==1);
+ CPPUNIT_ASSERT(output[2]==-1);
+ CPPUNIT_ASSERT(output[3]==5);
+}
diff --git a/sources/android/stlport/test/unit/ptr2_test.cpp b/sources/android/stlport/test/unit/ptr2_test.cpp
new file mode 100644
index 0000000..9a1155c
--- /dev/null
+++ b/sources/android/stlport/test/unit/ptr2_test.cpp
@@ -0,0 +1,84 @@
+#include <vector>
+#include <algorithm>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class Ptr2Test : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(Ptr2Test);
+ CPPUNIT_TEST(ptrbin1);
+ CPPUNIT_TEST(ptrbin2);
+ CPPUNIT_TEST(ptrun1);
+ CPPUNIT_TEST(ptrun2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void ptrbin1();
+ void ptrbin2();
+ void ptrun1();
+ void ptrun2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(Ptr2Test);
+
+//
+// tests implementation
+//
+static int sum(int x_, int y_)
+{
+ return x_ + y_;
+}
+bool even(int n_)
+{
+ return(n_ % 2) == 0;
+}
+void Ptr2Test::ptrbin1()
+{
+ int input1 [4] = { 7, 2, 3, 5 };
+ int input2 [4] = { 1, 5, 5, 8 };
+
+ int output [4];
+ transform((int*)input1, (int*)input1 + 4, (int*)input2, (int*)output, pointer_to_binary_function<int, int, int>(sum));
+
+ CPPUNIT_ASSERT(output[0]==8);
+ CPPUNIT_ASSERT(output[1]==7);
+ CPPUNIT_ASSERT(output[2]==8);
+ CPPUNIT_ASSERT(output[3]==13);
+}
+void Ptr2Test::ptrbin2()
+{
+ int input1 [4] = { 7, 2, 3, 5 };
+ int input2 [4] = { 1, 5, 5, 8 };
+
+ int output [4];
+ transform((int*)input1, (int*)input1 + 4, (int*)input2, (int*)output, ptr_fun(sum));
+
+ CPPUNIT_ASSERT(output[0]==8);
+ CPPUNIT_ASSERT(output[1]==7);
+ CPPUNIT_ASSERT(output[2]==8);
+ CPPUNIT_ASSERT(output[3]==13);
+}
+void Ptr2Test::ptrun1()
+{
+ int array [3] = { 1, 2, 3 };
+
+ int* p = find_if((int*)array, (int*)array + 3, pointer_to_unary_function<int, bool>(even));
+ CPPUNIT_ASSERT(p != array+3);
+ CPPUNIT_ASSERT(*p==2);
+}
+void Ptr2Test::ptrun2()
+{
+ int array [3] = { 1, 2, 3 };
+
+ int* p = find_if((int*)array, (int*)array + 3, ptr_fun(even));
+ CPPUNIT_ASSERT(p != array+3);
+ CPPUNIT_ASSERT(*p==2);
+}
diff --git a/sources/android/stlport/test/unit/ptrspec_test.cpp b/sources/android/stlport/test/unit/ptrspec_test.cpp
new file mode 100644
index 0000000..6d0fcf5
--- /dev/null
+++ b/sources/android/stlport/test/unit/ptrspec_test.cpp
@@ -0,0 +1,232 @@
+#include <vector>
+#include <list>
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+# include <slist>
+#endif
+#include <deque>
+#include <set>
+#include <iterator>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class PtrSpecTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(PtrSpecTest);
+ CPPUNIT_TEST(ptr_specialization_test);
+ CPPUNIT_TEST(function_pointer);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ /// this seems to be compile only test but...
+ void ptr_specialization_test();
+ void function_pointer();
+
+ template <class _Tp>
+ struct unary_pred {
+ bool operator () (_Tp *__ptr) const {
+ return *__ptr == 0;
+ }
+ };
+
+ template <class _Tp>
+ struct binary_pred {
+ bool operator () (_Tp *__first, _Tp *__second) const {
+ return *__first < *__second;
+ }
+ };
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(PtrSpecTest);
+
+#define TEST_INSTANCIATE_CONTAINER(cont) \
+ template class cont<int*>; \
+ template class cont<int const*>; \
+ template class cont<int volatile*>; \
+ template class cont<int const volatile*>
+
+#if !defined(_MSC_VER) || (_MSC_VER > 1200) // excluding MSVC 6.0
+TEST_INSTANCIATE_CONTAINER(vector);
+TEST_INSTANCIATE_CONTAINER(list);
+# if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+TEST_INSTANCIATE_CONTAINER(slist);
+# endif
+TEST_INSTANCIATE_CONTAINER(deque);
+TEST_INSTANCIATE_CONTAINER(set);
+TEST_INSTANCIATE_CONTAINER(multiset);
+#endif
+
+//Function to test pointer to function support:
+void FTypeInstance() {}
+
+//Class to test pointer to member method support:
+class AClass {
+public:
+ void func() {}
+};
+
+//
+// tests implementation
+//
+void PtrSpecTest::ptr_specialization_test()
+{
+ int *int_array[] = {0, 0, 0};
+ int const* cint_array[] = {0, 0, 0};
+
+ {
+ vector<void*> void_vect;
+ deque<void*> void_deque;
+ list<void*> void_list;
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ slist<void*> void_slist;
+#endif
+ }
+
+ {
+ typedef void (*FType)();
+ vector<FType> func_vector;
+ func_vector.push_back(&FTypeInstance);
+ }
+
+#if !defined(__GNUC__) || (__GNUC__ > 2)
+ {
+ typedef void (AClass::*MFType)();
+ vector<MFType> mem_func_vector;
+ mem_func_vector.push_back(&AClass::func);
+ }
+#endif
+
+ vector<int*> pint_vect;
+ vector<int*> pint_vect2;
+ vector<int const*> pcint_vect;
+ list<int*> pint_list;
+ list<int*> pint_list2;
+ list<int const*> pcint_list;
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ slist<int*> pint_slist;
+ slist<int*> pint_slist2;
+ slist<int const*> pcint_slist;
+#endif
+ deque<int*> pint_deque;
+ deque<int*> pint_deque2;
+ deque<int const*> pcint_deque;
+
+#if !defined (STLPORT) || defined (_STLP_MEMBER_TEMPLATES)
+ vector<int*> pint_vect_from_list(pint_list.begin(), pint_list.end());
+#endif
+ pint_vect.insert(pint_vect.end(), pint_vect2.begin(), pint_vect2.end());
+ pint_vect.insert(pint_vect.end(), int_array, int_array + 3);
+ pint_vect2.insert(pint_vect2.end(), int_array, int_array + 3);
+ pcint_vect.insert(pcint_vect.end(), int_array, int_array + 3);
+ pcint_vect.insert(pcint_vect.end(), cint_array, cint_array + 3);
+#if !defined (STLPORT) || !defined(_STLP_DEBUG) || defined(_STLP_MEMBER_TEMPLATES)
+ pcint_vect.insert(pcint_vect.end(), pint_vect2.begin(), pint_vect2.end());
+#endif
+ pcint_vect.insert(pcint_vect.end(), int_array, int_array + 3);
+#if !defined (STLPORT) || defined (_STLP_MEMBER_TEMPLATES)
+ pint_vect.insert(pint_vect.end(), pint_list.begin(), pint_list.end());
+ pcint_vect.insert(pcint_vect.end(), pint_list.begin(), pint_list.end());
+ pcint_vect.insert(pcint_vect.end(), pcint_list.begin(), pcint_list.end());
+ pint_vect.assign(pint_list.begin(), pint_list.end());
+ pcint_vect.assign(pint_list.begin(), pint_list.end());
+#endif
+ pint_vect.assign(int_array, int_array + 3);
+ pcint_vect.assign(int_array, int_array + 3);
+ pcint_vect.assign(cint_array, cint_array + 3);
+ copy(int_array, int_array + 3, back_inserter(pint_vect));
+
+#if !defined (STLPORT) || defined (_STLP_MEMBER_TEMPLATES)
+ pint_list.sort(binary_pred<int>());
+ pcint_list.sort(binary_pred<int const>());
+ pint_list.unique(binary_pred<int>());
+ pcint_list.unique(binary_pred<int const>());
+ pint_list.merge(pint_list, binary_pred<int>());
+ pcint_list.merge(pcint_list, binary_pred<int const>());
+ pint_list.remove_if(unary_pred<int>());
+ pcint_list.remove_if(unary_pred<int const>());
+#endif
+
+ copy(int_array, int_array + 3, back_inserter(pint_list));
+ copy(int_array, int_array + 3, back_inserter(pint_list2));
+ pint_list.insert(pint_list.end(), pint_list2.begin(), pint_list2.end());
+#if !defined (STLPORT) || defined (_STLP_MEMBER_TEMPLATES)
+ pcint_list.insert(pcint_list.end(), pint_list.begin(), pint_list.end());
+#endif
+#if !defined (STLPORT) || !defined(_STLP_DEBUG) || defined(_STLP_MEMBER_TEMPLATES)
+ pint_list.insert(pint_list.end(), pint_vect.begin(), pint_vect.end());
+ pcint_list.insert(pcint_list.end(), pint_vect.begin(), pint_vect.end());
+ pcint_list.insert(pcint_list.end(), pcint_vect.begin(), pcint_vect.end());
+ list<int*> pint_list_from_vect(pint_vect.begin(), pint_vect.end());
+ pint_list.assign(pint_vect.begin(), pint_vect.end());
+ pcint_list.assign(pint_vect.begin(), pint_vect.end());
+#endif
+ pint_list.insert(pint_list.begin(), int_array, int_array + 3);
+ pint_list.insert(pint_list.end(), int_array, int_array + 3);
+ pcint_list.insert(pcint_list.end(), int_array, int_array + 3);
+ pcint_list.insert(pcint_list.end(), cint_array, cint_array + 3);
+ pint_list.assign(int_array, int_array + 3);
+ pcint_list.assign(int_array, int_array + 3);
+ pcint_list.assign(cint_array, cint_array + 3);
+ //pint_list.assign(pcint_vect.begin(), pcint_vect.end());
+
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ copy(int_array, int_array + 3, front_inserter(pint_slist));
+ copy(int_array, int_array + 3, front_inserter(pint_slist2));
+ pint_slist.insert(pint_slist.end(), pint_slist2.begin(), pint_slist2.end());
+# if defined (_STLP_MEMBER_TEMPLATES)
+ pcint_slist.insert(pcint_slist.end(), pint_slist.begin(), pint_slist.end());
+# endif
+# if !defined (_STLP_DEBUG) || defined (_STLP_MEMBER_TEMPLATES)
+ pint_slist.insert(pint_slist.end(), pint_vect.begin(), pint_vect.end());
+ pcint_slist.insert(pcint_slist.end(), pint_vect.begin(), pint_vect.end());
+ pcint_slist.insert(pcint_slist.end(), pcint_vect.begin(), pcint_vect.end());
+ slist<int*> pint_slist_from_vect(pint_vect.begin(), pint_vect.end());
+ pint_slist.assign(pint_vect.begin(), pint_vect.end());
+ pcint_slist.assign(pint_vect.begin(), pint_vect.end());
+# endif
+ pint_slist.insert(pint_slist.end(), int_array, int_array + 3);
+ pcint_slist.insert(pcint_slist.end(), int_array, int_array + 3);
+ pcint_slist.insert(pcint_slist.end(), cint_array, cint_array + 3);
+ pint_slist.assign(int_array, int_array + 3);
+ pcint_slist.assign(int_array, int_array + 3);
+ pcint_slist.assign(cint_array, cint_array + 3);
+ //pint_slist.assign(pcint_vect.begin(), pcint_vect.end());
+#endif
+
+ copy(int_array, int_array + 3, back_inserter(pint_deque));
+ copy(int_array, int_array + 3, back_inserter(pint_deque2));
+ pint_deque.insert(pint_deque.end(), pint_deque2.begin(), pint_deque2.end());
+#if !defined (STLPORT) || defined (_STLP_MEMBER_TEMPLATES)
+ pcint_deque.insert(pcint_deque.end(), pint_deque.begin(), pint_deque.end());
+#endif
+#if !defined (STLPORT) || !defined(_STLP_DEBUG) || defined(_STLP_MEMBER_TEMPLATES)
+ pint_deque.insert(pint_deque.end(), pint_vect.begin(), pint_vect.end());
+ pcint_deque.insert(pcint_deque.end(), pint_vect.begin(), pint_vect.end());
+ pcint_deque.insert(pcint_deque.end(), pcint_vect.begin(), pcint_vect.end());
+ deque<int*> pint_deque_from_vect(pint_vect.begin(), pint_vect.end());
+ pint_deque.assign(pint_vect.begin(), pint_vect.end());
+ pcint_deque.assign(pint_vect.begin(), pint_vect.end());
+#endif
+ pint_deque.insert(pint_deque.end(), int_array, int_array + 3);
+ pcint_deque.insert(pcint_deque.end(), int_array, int_array + 3);
+ pcint_deque.insert(pcint_deque.end(), cint_array, cint_array + 3);
+ pint_deque.assign(int_array, int_array + 3);
+ pcint_deque.assign(int_array, int_array + 3);
+ pcint_deque.assign(cint_array, cint_array + 3);
+}
+
+typedef void (*Func)(int);
+void f1(int) {}
+
+void PtrSpecTest::function_pointer()
+{
+ vector<Func> fs;
+ fs.push_back(&f1);
+ CPPUNIT_ASSERT( !fs.empty() );
+}
diff --git a/sources/android/stlport/test/unit/queue_header_test.cpp b/sources/android/stlport/test/unit/queue_header_test.cpp
new file mode 100644
index 0000000..4149c22
--- /dev/null
+++ b/sources/android/stlport/test/unit/queue_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <queue>
diff --git a/sources/android/stlport/test/unit/queue_test.cpp b/sources/android/stlport/test/unit/queue_test.cpp
new file mode 100644
index 0000000..2e6add3
--- /dev/null
+++ b/sources/android/stlport/test/unit/queue_test.cpp
@@ -0,0 +1,64 @@
+#include <vector>
+#include <algorithm>
+#include <list>
+#include <deque>
+#include <queue>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class QueueTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(QueueTest);
+ CPPUNIT_TEST(pqueue1);
+ CPPUNIT_TEST(queue1);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void pqueue1();
+ void queue1();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(QueueTest);
+
+//
+// tests implementation
+//
+void QueueTest::pqueue1()
+{
+ priority_queue<int, deque<int>, less<int> > q;
+ q.push(42);
+ q.push(101);
+ q.push(69);
+
+ CPPUNIT_ASSERT( q.top()==101 );
+ q.pop();
+ CPPUNIT_ASSERT( q.top()==69 );
+ q.pop();
+ CPPUNIT_ASSERT( q.top()==42 );
+ q.pop();
+
+ CPPUNIT_ASSERT(q.empty());
+}
+void QueueTest::queue1()
+{
+ queue<int, list<int> > q;
+ q.push(42);
+ q.push(101);
+ q.push(69);
+
+ CPPUNIT_ASSERT( q.front()==42 );
+ q.pop();
+ CPPUNIT_ASSERT( q.front()==101 );
+ q.pop();
+ CPPUNIT_ASSERT( q.front()==69 );
+ q.pop();
+
+ CPPUNIT_ASSERT(q.empty());
+}
diff --git a/sources/android/stlport/test/unit/rawriter_test.cpp b/sources/android/stlport/test/unit/rawriter_test.cpp
new file mode 100644
index 0000000..0c8438a
--- /dev/null
+++ b/sources/android/stlport/test/unit/rawriter_test.cpp
@@ -0,0 +1,66 @@
+#include <algorithm>
+#include <iterator>
+#include <memory>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+class X
+{
+ public:
+ X(int i_ = 0) : i(i_) {}
+ ~X() {}
+ operator int() const { return i; }
+
+ private:
+ int i;
+};
+
+
+//
+// TestCase class
+//
+class RawriterTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(RawriterTest);
+ CPPUNIT_TEST(rawiter1);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void rawiter1();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(RawriterTest);
+
+//
+// tests implementation
+//
+void RawriterTest::rawiter1()
+{
+ allocator<X> a;
+ typedef X* x_pointer;
+ x_pointer save_p, p;
+ p = a.allocate(5);
+ save_p=p;
+ raw_storage_iterator<X*, X> r(p);
+ int i;
+ for(i = 0; i < 5; i++)
+ *r++ = X(i);
+
+ CPPUNIT_ASSERT(*p++ == 0);
+ CPPUNIT_ASSERT(*p++ == 1);
+ CPPUNIT_ASSERT(*p++ == 2);
+ CPPUNIT_ASSERT(*p++ == 3);
+ CPPUNIT_ASSERT(*p++ == 4);
+
+//#if defined (STLPORT) || defined (__GNUC__)
+ a.deallocate(save_p, 5);
+/*
+#else
+ a.deallocate(save_p);
+#endif
+*/
+}
diff --git a/sources/android/stlport/test/unit/reference_wrapper_test.cpp b/sources/android/stlport/test/unit/reference_wrapper_test.cpp
new file mode 100644
index 0000000..4e3fb41
--- /dev/null
+++ b/sources/android/stlport/test/unit/reference_wrapper_test.cpp
@@ -0,0 +1,85 @@
+#include <functional>
+
+#if !defined(_STLP_NO_EXTENSIONS) && defined(_STLP_USE_BOOST_SUPPORT)
+
+#include <typeinfo>
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+class RefWrapperTest :
+ public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(RefWrapperTest);
+ CPPUNIT_TEST(ref);
+ CPPUNIT_TEST(cref);
+ CPPUNIT_TEST_SUITE_END();
+
+ protected:
+ void ref();
+ void cref();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(RefWrapperTest);
+
+void RefWrapperTest::ref()
+{
+ typedef std::tr1::reference_wrapper<int> rr_type;
+
+ CPPUNIT_CHECK( (::boost::is_convertible<rr_type, int&>::value) );
+ CPPUNIT_CHECK( (::boost::is_same<rr_type::type, int>::value) );
+
+ int i = 1;
+ int j = 2;
+
+ rr_type r1 = std::tr1::ref(i);
+
+ CPPUNIT_CHECK( r1.get() == 1 );
+
+ r1 = std::tr1::ref(j);
+
+ CPPUNIT_CHECK( r1.get() == 2 );
+
+ i = 3;
+
+ CPPUNIT_CHECK( r1.get() == 2 );
+
+ j = 4;
+
+ CPPUNIT_CHECK( r1.get() == 4 );
+
+ r1.get() = 5;
+
+ CPPUNIT_CHECK( j == 5 );
+}
+
+void RefWrapperTest::cref()
+{
+ typedef std::tr1::reference_wrapper<const int> crr_type;
+
+ CPPUNIT_CHECK( (::boost::is_convertible<crr_type, const int&>::value) );
+ CPPUNIT_CHECK( (::boost::is_same<crr_type::type, const int>::value) );
+
+ int i = 1;
+ int j = 2;
+
+ crr_type r1 = std::tr1::cref(i);
+
+ CPPUNIT_CHECK( r1.get() == 1 );
+
+ r1 = std::tr1::cref(j);
+
+ CPPUNIT_CHECK( r1.get() == 2 );
+
+ i = 3;
+
+ CPPUNIT_CHECK( r1.get() == 2 );
+
+ j = 4;
+
+ CPPUNIT_CHECK( r1.get() == 4 );
+}
+
+#endif /* !_STLP_NO_EXTENSIONS && _STLP_USE_BOOST_SUPPORT */
diff --git a/sources/android/stlport/test/unit/resolve_name.cpp b/sources/android/stlport/test/unit/resolve_name.cpp
new file mode 100644
index 0000000..dc7c123
--- /dev/null
+++ b/sources/android/stlport/test/unit/resolve_name.cpp
@@ -0,0 +1,83 @@
+#define _STLP_DO_IMPORT_CSTD_FUNCTIONS
+#include <cmath>
+
+#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+
+namespace NS1 {
+
+bool f()
+{
+ double d( 1.0 );
+
+ d = sqrt( d );
+ d = ::sqrt( d );
+ d = std::sqrt( d );
+ return d == 1.0;
+}
+
+}
+
+namespace {
+
+bool g()
+{
+ double d( 1.0 );
+
+ d = sqrt( d );
+ d = ::sqrt( d );
+ d = std::sqrt( d );
+ return d == 1.0;
+}
+
+}
+
+// VC6 consider call to sqrt ambiguous as soon as using namespace std has
+// been invoked.
+#if !defined (STLPORT) || !defined (_STLP_MSVC) || (_STLP_MSVC >= 1300)
+using namespace std;
+#endif
+
+bool h()
+{
+ double d( 1.0 );
+
+ d = sqrt( d );
+ d = ::sqrt( d );
+ d = std::sqrt( d );
+ return d == 1.0;
+}
+
+struct sq
+{
+ sq() {}
+
+ double sqroot( double x ) {
+ using std::sqrt;
+ return sqrt(x);
+ }
+};
+
+#endif
+
+
+#if 0 // Do nothing, this should be compiled only
+
+#include "cppunit/cppunit_proxy.h"
+
+class ResolveNameTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(ResolveNameTest);
+ CPPUNIT_TEST(cstyle);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void cstyle();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(ResolveNameTest);
+
+void ResolveNameTest::cstyle()
+{
+}
+
+#endif
diff --git a/sources/android/stlport/test/unit/reviter_test.cpp b/sources/android/stlport/test/unit/reviter_test.cpp
new file mode 100644
index 0000000..15a3c34
--- /dev/null
+++ b/sources/android/stlport/test/unit/reviter_test.cpp
@@ -0,0 +1,72 @@
+#include <vector>
+#include <list>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class ReviterTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(ReviterTest);
+ CPPUNIT_TEST(reviter1);
+ CPPUNIT_TEST(reviter2);
+ CPPUNIT_TEST(revbit1);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void reviter1();
+ void reviter2();
+ void revbit1();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(ReviterTest);
+
+//
+// tests implementation
+//
+void ReviterTest::reviter1()
+{
+ int array [] = { 1, 5, 2, 3 };
+
+ vector<int> v(array, array + 4);
+ typedef vector<int>::reverse_iterator reviter;
+ reviter r(v.rend());
+ r--;
+
+ CPPUNIT_ASSERT(*r-- == 1);
+ CPPUNIT_ASSERT(*r-- == 5);
+ CPPUNIT_ASSERT(*r-- == 2);
+ CPPUNIT_ASSERT(*r == 3);
+ CPPUNIT_ASSERT(r==v.rbegin());
+}
+void ReviterTest::reviter2()
+{
+ int array [] = { 1, 5, 2, 3 };
+
+ vector<int> v(array, array + 4);
+ vector<int>::reverse_iterator r;
+ r = v.rbegin();
+ CPPUNIT_ASSERT(*r++ == 3);
+ CPPUNIT_ASSERT(*r++ == 2);
+ CPPUNIT_ASSERT(*r++ == 5);
+ CPPUNIT_ASSERT(*r++ == 1);
+ CPPUNIT_ASSERT(r==v.rend());
+}
+void ReviterTest::revbit1()
+{
+ int array [] = { 1, 5, 2, 3 };
+
+ list<int> v(array, array + 4);
+ list<int>::reverse_iterator r(v.rbegin());
+ CPPUNIT_ASSERT(*r++ == 3);
+ CPPUNIT_ASSERT(*r++ == 2);
+ CPPUNIT_ASSERT(*r++ == 5);
+ CPPUNIT_ASSERT(*r++ == 1);
+ CPPUNIT_ASSERT(r==v.rend());
+}
diff --git a/sources/android/stlport/test/unit/rm_cp_test.cpp b/sources/android/stlport/test/unit/rm_cp_test.cpp
new file mode 100644
index 0000000..3e3a4d6
--- /dev/null
+++ b/sources/android/stlport/test/unit/rm_cp_test.cpp
@@ -0,0 +1,245 @@
+#include <vector>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class RmCpTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(RmCpTest);
+ CPPUNIT_TEST(remcopy1);
+ CPPUNIT_TEST(remcpif1);
+ CPPUNIT_TEST(remif1);
+ CPPUNIT_TEST(remove1);
+ CPPUNIT_TEST(repcpif1);
+ CPPUNIT_TEST(replace0);
+ CPPUNIT_TEST(replace1);
+ CPPUNIT_TEST(replcpy1);
+ CPPUNIT_TEST(replif1);
+ CPPUNIT_TEST(revcopy1);
+ CPPUNIT_TEST(reverse1);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void remcopy1();
+ void remcpif1();
+ void remif1();
+ void remove1();
+ void repcpif1();
+ void replace0();
+ void replace1();
+ void replcpy1();
+ void replif1();
+ void revcopy1();
+ void reverse1();
+
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(RmCpTest);
+
+static bool odd(int a_)
+{
+ return (a_ % 2) != 0;
+}
+//
+// tests implementation
+//
+
+void RmCpTest::reverse1()
+{
+ int numbers[6] = { 0, 1, 2, 3, 4, 5 };
+
+ reverse(numbers, numbers + 6);
+ CPPUNIT_ASSERT(numbers[0]==5);
+ CPPUNIT_ASSERT(numbers[1]==4);
+ CPPUNIT_ASSERT(numbers[2]==3);
+ CPPUNIT_ASSERT(numbers[3]==2);
+ CPPUNIT_ASSERT(numbers[4]==1);
+ CPPUNIT_ASSERT(numbers[5]==0);
+}
+
+void RmCpTest::revcopy1()
+{
+ int numbers[6] = { 0, 1, 2, 3, 4, 5 };
+
+ int result[6];
+ reverse_copy((int*)numbers, (int*)numbers + 6, (int*)result);
+ // 5 4 3 2 1 0
+ CPPUNIT_ASSERT(result[0]==5);
+ CPPUNIT_ASSERT(result[1]==4);
+ CPPUNIT_ASSERT(result[2]==3);
+ CPPUNIT_ASSERT(result[3]==2);
+ CPPUNIT_ASSERT(result[4]==1);
+ CPPUNIT_ASSERT(result[5]==0);
+}
+
+void RmCpTest::replif1()
+{
+ vector <int> v1(10);
+ for (int i = 0; (size_t)i < v1.size(); ++i)
+ v1[i] = i % 5;
+
+ replace_if(v1.begin(), v1.end(), odd, 42);
+
+ // 0 42 2 42 4 0 42 2 42 4
+ CPPUNIT_ASSERT(v1[0]==0);
+ CPPUNIT_ASSERT(v1[1]==42);
+ CPPUNIT_ASSERT(v1[2]==2);
+ CPPUNIT_ASSERT(v1[3]==42);
+ CPPUNIT_ASSERT(v1[4]==4);
+ CPPUNIT_ASSERT(v1[5]==0);
+ CPPUNIT_ASSERT(v1[6]==42);
+ CPPUNIT_ASSERT(v1[7]==2);
+ CPPUNIT_ASSERT(v1[8]==42);
+ CPPUNIT_ASSERT(v1[9]==4);
+}
+
+void RmCpTest::replcpy1()
+{
+ int numbers[6] = { 0, 1, 2, 0, 1, 2 };
+ int result[6] = { 0, 0, 0, 0, 0, 0 };
+
+ replace_copy((int*)numbers, (int*)numbers + 6, (int*)result, 2, 42);
+ CPPUNIT_ASSERT(result[0]==0);
+ CPPUNIT_ASSERT(result[1]==1);
+ CPPUNIT_ASSERT(result[2]==42);
+ CPPUNIT_ASSERT(result[3]==0);
+ CPPUNIT_ASSERT(result[4]==1);
+ CPPUNIT_ASSERT(result[5]==42);
+}
+
+void RmCpTest::replace0()
+{
+ int numbers[6] = { 0, 1, 2, 0, 1, 2 };
+
+ replace(numbers, numbers + 6, 2, 42);
+
+ // 0 1 42 0 1 42
+ CPPUNIT_ASSERT(numbers[0]==0);
+ CPPUNIT_ASSERT(numbers[1]==1);
+ CPPUNIT_ASSERT(numbers[2]==42);
+ CPPUNIT_ASSERT(numbers[3]==0);
+ CPPUNIT_ASSERT(numbers[4]==1);
+ CPPUNIT_ASSERT(numbers[5]==42);
+}
+
+void RmCpTest::replace1()
+{
+ vector <int> v1(10);
+ for (int i = 0; (size_t)i < v1.size(); ++i)
+ v1[i] = i % 5;
+ replace(v1.begin(), v1.end(), 2, 42);
+
+ // 0 1 2 3 4 0 1 2 3 4
+ // 0 1 42 3 4 0 1 42 3 4
+ CPPUNIT_ASSERT(v1[0]==0);
+ CPPUNIT_ASSERT(v1[1]==1);
+ CPPUNIT_ASSERT(v1[2]==42);
+ CPPUNIT_ASSERT(v1[3]==3);
+ CPPUNIT_ASSERT(v1[4]==4);
+ CPPUNIT_ASSERT(v1[5]==0);
+ CPPUNIT_ASSERT(v1[6]==1);
+ CPPUNIT_ASSERT(v1[7]==42);
+ CPPUNIT_ASSERT(v1[8]==3);
+ CPPUNIT_ASSERT(v1[9]==4);
+}
+
+void RmCpTest::repcpif1()
+{
+ vector <int> v1(10);
+ for (int i = 0; (size_t)i < v1.size(); ++i)
+ v1[i] = i % 5;
+ vector <int> v2(v1.size());
+
+ // 0 1 2 3 4 0 1 2 3 4
+ // 0 1 2 3 4 0 1 2 3 4
+ // 0 42 2 42 4 0 42 2 42 4
+ replace_copy_if(v1.begin(), v1.end(), v2.begin(), odd, 42);
+ CPPUNIT_ASSERT(v1[0]==0);
+ CPPUNIT_ASSERT(v1[1]==1);
+ CPPUNIT_ASSERT(v1[2]==2);
+ CPPUNIT_ASSERT(v1[3]==3);
+ CPPUNIT_ASSERT(v1[4]==4);
+ CPPUNIT_ASSERT(v1[5]==0);
+ CPPUNIT_ASSERT(v1[6]==1);
+ CPPUNIT_ASSERT(v1[7]==2);
+ CPPUNIT_ASSERT(v1[8]==3);
+ CPPUNIT_ASSERT(v1[9]==4);
+
+ CPPUNIT_ASSERT(v2[0]==0);
+ CPPUNIT_ASSERT(v2[1]==42);
+ CPPUNIT_ASSERT(v2[2]==2);
+ CPPUNIT_ASSERT(v2[3]==42);
+ CPPUNIT_ASSERT(v2[4]==4);
+ CPPUNIT_ASSERT(v2[5]==0);
+ CPPUNIT_ASSERT(v2[6]==42);
+ CPPUNIT_ASSERT(v2[7]==2);
+ CPPUNIT_ASSERT(v2[8]==42);
+ CPPUNIT_ASSERT(v2[9]==4);
+}
+
+void RmCpTest::remove1()
+{
+ int numbers[6] = { 1, 2, 3, 1, 2, 3 };
+ remove((int*)numbers, (int*)numbers + 6, 1);
+
+ // 2 3 2 3 2 3
+ CPPUNIT_ASSERT(numbers[0]==2);
+ CPPUNIT_ASSERT(numbers[1]==3);
+ CPPUNIT_ASSERT(numbers[2]==2);
+ CPPUNIT_ASSERT(numbers[3]==3);
+ CPPUNIT_ASSERT(numbers[4]==2);
+ CPPUNIT_ASSERT(numbers[5]==3);
+}
+
+void RmCpTest::remif1()
+{
+ int numbers[6] = { 0, 0, 1, 1, 2, 2 };
+
+ remove_if((int*)numbers, (int*)numbers + 6, odd);
+
+ // 0 0 2 2 2 2
+ CPPUNIT_ASSERT(numbers[0]==0);
+ CPPUNIT_ASSERT(numbers[1]==0);
+ CPPUNIT_ASSERT(numbers[2]==2);
+ CPPUNIT_ASSERT(numbers[3]==2);
+ CPPUNIT_ASSERT(numbers[4]==2);
+ CPPUNIT_ASSERT(numbers[5]==2);
+}
+
+void RmCpTest::remcopy1()
+{
+ int numbers[6] = { 1, 2, 3, 1, 2, 3 };
+ int result[6] = { 0, 0, 0, 0, 0, 0 };
+
+ remove_copy((int*)numbers, (int*)numbers + 6, (int*)result, 2);
+
+ CPPUNIT_ASSERT(result[0]==1);
+ CPPUNIT_ASSERT(result[1]==3);
+ CPPUNIT_ASSERT(result[2]==1);
+ CPPUNIT_ASSERT(result[3]==3);
+ CPPUNIT_ASSERT(result[4]==0);
+ CPPUNIT_ASSERT(result[5]==0);
+}
+
+void RmCpTest::remcpif1()
+{
+ int numbers[6] = { 1, 2, 3, 1, 2, 3 };
+ int result[6] = { 0, 0, 0, 0, 0, 0 };
+
+ remove_copy_if((int*)numbers, (int*)numbers + 6, (int*)result, odd);
+
+ // 2 2 0 0 0 0
+ CPPUNIT_ASSERT(result[0]==2);
+ CPPUNIT_ASSERT(result[1]==2);
+ CPPUNIT_ASSERT(result[2]==0);
+ CPPUNIT_ASSERT(result[3]==0);
+ CPPUNIT_ASSERT(result[4]==0);
+ CPPUNIT_ASSERT(result[5]==0);
+}
diff --git a/sources/android/stlport/test/unit/rndshf_test.cpp b/sources/android/stlport/test/unit/rndshf_test.cpp
new file mode 100644
index 0000000..ad57a53
--- /dev/null
+++ b/sources/android/stlport/test/unit/rndshf_test.cpp
@@ -0,0 +1,73 @@
+#include <numeric>
+#include <vector>
+#include <algorithm>
+
+#include "iota.h"
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class RndShuffleTest : public CPPUNIT_NS::TestCase
+{
+ class MyRandomGenerator
+ {
+ public:
+ unsigned long operator()(unsigned long n_)
+ {
+ return rand() % n_;
+ }
+ };
+ CPPUNIT_TEST_SUITE(RndShuffleTest);
+ CPPUNIT_TEST(rndshuf0);
+ CPPUNIT_TEST(rndshuf2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void rndshuf0();
+ void rndshuf2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(RndShuffleTest);
+
+//
+// tests implementation
+//
+void RndShuffleTest::rndshuf0()
+{
+ int numbers[6] = { 1, 2, 3, 4, 5, 6 };
+
+ random_shuffle(numbers, numbers + 6);
+
+ CPPUNIT_ASSERT(count(numbers, numbers+6, 1)==1);
+ CPPUNIT_ASSERT(count(numbers, numbers+6, 2)==1);
+ CPPUNIT_ASSERT(count(numbers, numbers+6, 3)==1);
+ CPPUNIT_ASSERT(count(numbers, numbers+6, 4)==1);
+ CPPUNIT_ASSERT(count(numbers, numbers+6, 5)==1);
+ CPPUNIT_ASSERT(count(numbers, numbers+6, 6)==1);
+}
+void RndShuffleTest::rndshuf2()
+{
+ vector <int> v1(10);
+ __iota(v1.begin(), v1.end(), 0);
+
+ MyRandomGenerator r;
+ for(int i = 0; i < 3; i++)
+ {
+ random_shuffle(v1.begin(), v1.end(), r);
+ CPPUNIT_ASSERT(count(v1.begin(), v1.end(), 0)==1);
+ CPPUNIT_ASSERT(count(v1.begin(), v1.end(), 1)==1);
+ CPPUNIT_ASSERT(count(v1.begin(), v1.end(), 2)==1);
+ CPPUNIT_ASSERT(count(v1.begin(), v1.end(), 3)==1);
+ CPPUNIT_ASSERT(count(v1.begin(), v1.end(), 4)==1);
+ CPPUNIT_ASSERT(count(v1.begin(), v1.end(), 5)==1);
+ CPPUNIT_ASSERT(count(v1.begin(), v1.end(), 6)==1);
+ CPPUNIT_ASSERT(count(v1.begin(), v1.end(), 7)==1);
+ CPPUNIT_ASSERT(count(v1.begin(), v1.end(), 8)==1);
+ CPPUNIT_ASSERT(count(v1.begin(), v1.end(), 9)==1);
+ }
+}
diff --git a/sources/android/stlport/test/unit/rope_test.cpp b/sources/android/stlport/test/unit/rope_test.cpp
new file mode 100644
index 0000000..c12fec8
--- /dev/null
+++ b/sources/android/stlport/test/unit/rope_test.cpp
@@ -0,0 +1,189 @@
+//Small header to get STLport numerous defines:
+#include <utility>
+
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+# include <rope>
+
+# if !defined (_STLP_USE_NO_IOSTREAMS)
+# include <sstream>
+# endif
+#endif
+
+#include "cppunit/cppunit_proxy.h"
+
+// #include <stdlib.h> // for rand etc
+
+#if defined (_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class RopeTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(RopeTest);
+#if !defined (STLPORT) || defined (_STLP_NO_EXTENSIONS) || defined (_STLP_USE_NO_IOSTREAMS)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(io);
+#if defined (_STLP_USE_NO_IOSTREAMS)
+ CPPUNIT_STOP_IGNORE;
+#endif
+ CPPUNIT_TEST(find1);
+ CPPUNIT_TEST(find2);
+ CPPUNIT_TEST(construct_from_char);
+ CPPUNIT_TEST(bug_report);
+#if !defined (_STLP_MEMBER_TEMPLATES)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(test_saved_rope_iterators);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void io();
+ void find1();
+ void find2();
+ void construct_from_char();
+ void bug_report();
+ void test_saved_rope_iterators();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(RopeTest);
+
+//
+// tests implementation
+//
+void RopeTest::io()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS) && !defined (_STLP_USE_NO_IOSTREAMS)
+ char const* cstr = "rope test string";
+ crope rstr(cstr);
+
+ {
+ ostringstream ostr;
+ ostr << rstr;
+
+ CPPUNIT_ASSERT( ostr );
+ CPPUNIT_ASSERT( ostr.str() == cstr );
+ }
+#endif
+}
+
+void RopeTest::find1()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ crope r("Fuzzy Wuzzy was a bear");
+ crope::size_type n = r.find( "hair" );
+ CPPUNIT_ASSERT( n == crope::npos );
+
+ n = r.find("ear");
+
+ CPPUNIT_ASSERT( n == (r.size() - 3) );
+#endif
+}
+
+void RopeTest::find2()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ crope r("Fuzzy Wuzzy was a bear");
+ crope::size_type n = r.find( 'e' );
+ CPPUNIT_ASSERT( n == (r.size() - 3) );
+#endif
+}
+
+void RopeTest::construct_from_char()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ crope r('1');
+ char const* s = r.c_str();
+ CPPUNIT_ASSERT( '1' == s[0] && '\0' == s[1] );
+#endif
+}
+
+// Test used for a bug report from Peter Hercek
+void RopeTest::bug_report()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ //first create a rope bigger than crope::_S_copy_max = 23
+ // so that any string addition is added to a new leaf
+ crope evilRope("12345678901234567890123_");
+ //crope* pSevenCharRope( new TRope("1234567") );
+ crope sevenCharRope0("12345678");
+ crope sevenCharRope1("1234567");
+ // add _Rope_RopeRep<c,a>::_S_alloc_granularity-1 = 7 characters
+ evilRope += "1234567"; // creates a new leaf
+ crope sevenCharRope2("1234567");
+ // add one more character to the leaf
+ evilRope += '8'; // here is the write beyond the allocated memory
+ CPPUNIT_ASSERT( strcmp(sevenCharRope2.c_str(), "1234567") == 0 );
+#endif
+}
+
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+const char str[] = "ilcpsklryvmcpjnbpbwllsrehfmxrkecwitrsglrexvtjmxypu\
+nbqfgxmuvgfajclfvenhyuhuorjosamibdnjdbeyhkbsomblto\
+uujdrbwcrrcgbflqpottpegrwvgajcrgwdlpgitydvhedtusip\
+pyvxsuvbvfenodqasajoyomgsqcpjlhbmdahyviuemkssdslde\
+besnnngpesdntrrvysuipywatpfoelthrowhfexlwdysvspwlk\
+fblfdf";
+
+crope create_rope( int len )
+{
+ int l = len/2;
+ crope result;
+ if(l <= 2)
+ {
+ static int j = 0;
+ for(int i = 0; i < len; ++i)
+ {
+ // char c = 'a' + rand() % ('z' - 'a');
+ result.append(1, /* c */ str[j++] );
+ j %= sizeof(str);
+ }
+ }
+ else
+ {
+ result = create_rope(len/2);
+ result.append(create_rope(len/2));
+ }
+ return result;
+}
+
+#endif
+
+void RopeTest::test_saved_rope_iterators()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS) && \
+ defined (_STLP_MEMBER_TEMPLATES)
+ //
+ // Try and create a rope with a complex tree structure:
+ //
+ // srand(0);
+ crope r = create_rope(300);
+ string expected(r.begin(), r.end());
+ CPPUNIT_ASSERT(expected.size() == r.size());
+ CPPUNIT_ASSERT(equal(expected.begin(), expected.end(), r.begin()));
+ crope::const_iterator i(r.begin()), j(r.end());
+ int pos = 0;
+ while(i != j)
+ {
+ crope::const_iterator k;
+ // This initial read triggers the bug:
+ CPPUNIT_ASSERT(*i);
+ k = i;
+ int newpos = pos;
+ // Now make sure that i is incremented into the next leaf:
+ while(i != j)
+ {
+ CPPUNIT_ASSERT(*i == expected[newpos]);
+ ++i;
+ ++newpos;
+ }
+ // Back up from stored value and continue:
+ i = k;
+ ++i;
+ ++pos;
+ }
+#endif
+}
diff --git a/sources/android/stlport/test/unit/rotate_test.cpp b/sources/android/stlport/test/unit/rotate_test.cpp
new file mode 100644
index 0000000..730bf28
--- /dev/null
+++ b/sources/android/stlport/test/unit/rotate_test.cpp
@@ -0,0 +1,133 @@
+#include <numeric>
+#include <vector>
+#include <algorithm>
+
+#include "iota.h"
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class RotateTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(RotateTest);
+ CPPUNIT_TEST(rotate0);
+ CPPUNIT_TEST(rotate1);
+ CPPUNIT_TEST(rotcopy0);
+ CPPUNIT_TEST(rotcopy1);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void rotate0();
+ void rotate1();
+ void rotcopy0();
+ void rotcopy1();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(RotateTest);
+
+//
+// tests implementation
+//
+void RotateTest::rotate0()
+{
+ int numbers[6] = { 0, 1, 2, 3, 4, 5 };
+ // 3 4 5 0 1 2
+ rotate((int*)numbers, numbers + 3, numbers + 6);
+ CPPUNIT_ASSERT(numbers[0]==3);
+ CPPUNIT_ASSERT(numbers[1]==4);
+ CPPUNIT_ASSERT(numbers[2]==5);
+ CPPUNIT_ASSERT(numbers[3]==0);
+ CPPUNIT_ASSERT(numbers[4]==1);
+ CPPUNIT_ASSERT(numbers[5]==2);
+}
+void RotateTest::rotate1()
+{
+ vector <int> v1(10);
+ __iota(v1.begin(), v1.end(), 0);
+
+ rotate(v1.begin(), v1.begin()+1, v1.end());
+ CPPUNIT_ASSERT(v1[0]==1);
+ CPPUNIT_ASSERT(v1[1]==2);
+ CPPUNIT_ASSERT(v1[2]==3);
+ CPPUNIT_ASSERT(v1[3]==4);
+ CPPUNIT_ASSERT(v1[4]==5);
+ CPPUNIT_ASSERT(v1[5]==6);
+ CPPUNIT_ASSERT(v1[6]==7);
+ CPPUNIT_ASSERT(v1[7]==8);
+ CPPUNIT_ASSERT(v1[8]==9);
+ CPPUNIT_ASSERT(v1[9]==0);
+
+ rotate(v1.begin(), v1.begin()+2, v1.end());
+ CPPUNIT_ASSERT(v1[0]==3);
+ CPPUNIT_ASSERT(v1[1]==4);
+ CPPUNIT_ASSERT(v1[2]==5);
+ CPPUNIT_ASSERT(v1[3]==6);
+ CPPUNIT_ASSERT(v1[4]==7);
+ CPPUNIT_ASSERT(v1[5]==8);
+ CPPUNIT_ASSERT(v1[6]==9);
+ CPPUNIT_ASSERT(v1[7]==0);
+ CPPUNIT_ASSERT(v1[8]==1);
+ CPPUNIT_ASSERT(v1[9]==2);
+
+ rotate(v1.begin(), v1.begin()+7, v1.end());
+ CPPUNIT_ASSERT(v1[0]==0);
+ CPPUNIT_ASSERT(v1[1]==1);
+ CPPUNIT_ASSERT(v1[2]==2);
+ CPPUNIT_ASSERT(v1[3]==3);
+ CPPUNIT_ASSERT(v1[4]==4);
+ CPPUNIT_ASSERT(v1[5]==5);
+ CPPUNIT_ASSERT(v1[6]==6);
+ CPPUNIT_ASSERT(v1[7]==7);
+ CPPUNIT_ASSERT(v1[8]==8);
+ CPPUNIT_ASSERT(v1[9]==9);
+
+}
+void RotateTest::rotcopy0()
+{
+ int numbers[6] = { 0, 1, 2, 3, 4, 5 };
+
+ int result[6];
+ rotate_copy((int*)numbers, (int*)numbers + 3, (int*)numbers + 6, (int*)result);
+ // 3 4 5 0 1 2
+ CPPUNIT_ASSERT(result[0]==3);
+ CPPUNIT_ASSERT(result[1]==4);
+ CPPUNIT_ASSERT(result[2]==5);
+ CPPUNIT_ASSERT(result[3]==0);
+ CPPUNIT_ASSERT(result[4]==1);
+ CPPUNIT_ASSERT(result[5]==2);
+}
+void RotateTest::rotcopy1()
+{
+ vector <int> v1(10);
+ __iota(v1.begin(), v1.end(), 0);
+ vector <int> v2(v1.size());
+
+ rotate_copy(v1.begin(), v1.begin()+1, v1.end(), v2.begin());
+ CPPUNIT_ASSERT(v2[0]==1);
+ CPPUNIT_ASSERT(v2[1]==2);
+ CPPUNIT_ASSERT(v2[2]==3);
+ CPPUNIT_ASSERT(v2[3]==4);
+ CPPUNIT_ASSERT(v2[4]==5);
+ CPPUNIT_ASSERT(v2[5]==6);
+ CPPUNIT_ASSERT(v2[6]==7);
+ CPPUNIT_ASSERT(v2[7]==8);
+ CPPUNIT_ASSERT(v2[8]==9);
+ CPPUNIT_ASSERT(v2[9]==0);
+
+ rotate_copy(v1.begin(), v1.begin()+3, v1.end(), v2.begin());
+ CPPUNIT_ASSERT(v2[0]==3);
+ CPPUNIT_ASSERT(v2[1]==4);
+ CPPUNIT_ASSERT(v2[2]==5);
+ CPPUNIT_ASSERT(v2[3]==6);
+ CPPUNIT_ASSERT(v2[4]==7);
+ CPPUNIT_ASSERT(v2[5]==8);
+ CPPUNIT_ASSERT(v2[6]==9);
+ CPPUNIT_ASSERT(v2[7]==0);
+ CPPUNIT_ASSERT(v2[8]==1);
+ CPPUNIT_ASSERT(v2[9]==2);
+}
diff --git a/sources/android/stlport/test/unit/search_test.cpp b/sources/android/stlport/test/unit/search_test.cpp
new file mode 100644
index 0000000..f7dd33d
--- /dev/null
+++ b/sources/android/stlport/test/unit/search_test.cpp
@@ -0,0 +1,89 @@
+#include <vector>
+#include <numeric>
+#include <algorithm>
+
+#include "iota.h"
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class SearchTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(SearchTest);
+ CPPUNIT_TEST(search0);
+ CPPUNIT_TEST(search1);
+ CPPUNIT_TEST(search2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void search0();
+ void search1();
+ void search2();
+
+ static bool str_equal(const char* a_, const char* b_)
+ {
+ return strcmp(a_, b_) == 0 ? 1 : 0;
+ }
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(SearchTest);
+
+//
+// tests implementation
+//
+void SearchTest::search0()
+{
+ int v1[6] = { 1, 1, 2, 3, 5, 8 };
+ int v2[6] = { 0, 1, 2, 3, 4, 5 };
+ int v3[2] = { 3, 4 };
+
+ int* location;
+ location = search((int*)v1, (int*)v1 + 6, (int*)v3, (int*)v3 + 2);
+ CPPUNIT_ASSERT(location == v1 + 6);
+
+ location = search((int*)v2, (int*)v2 + 6, (int*)v3, (int*)v3 + 2);
+ CPPUNIT_ASSERT(location != v2 + 6);
+ CPPUNIT_ASSERT(location - v2 == 3);
+}
+void SearchTest::search1()
+{
+ typedef vector <int> IntVec;
+ IntVec v1(10);
+ __iota(v1.begin(), v1.end(), 0);
+ IntVec v2(3);
+ __iota(v2.begin(), v2.end(), 50);
+
+ IntVec::iterator location;
+ location = search(v1.begin(), v1.end(), v2.begin(), v2.end());
+
+ CPPUNIT_ASSERT(location == v1.end());
+
+ __iota(v2.begin(), v2.end(), 4);
+
+ location = search(v1.begin(), v1.end(), v2.begin(), v2.end());
+
+ CPPUNIT_ASSERT(location != v1.end());
+ CPPUNIT_ASSERT(location - v1.begin() == 4);
+}
+void SearchTest::search2()
+{
+ char const* grades[] = { "A", "B", "C", "D", "F" };
+ char const* letters[] = { "Q", "E", "D" };
+ const unsigned gradeCount = sizeof(grades) / sizeof(grades[0]);
+ const unsigned letterCount = sizeof(letters) / sizeof(letters[0]);
+ char const** location = search((char const**)grades, (char const**)grades + gradeCount, (char const**)letters, (char const**)letters + letterCount, str_equal);
+
+ CPPUNIT_ASSERT(location == grades + gradeCount);
+
+ copy((char const**)grades + 1, (char const**)grades + 1 + letterCount, (char const**)letters);
+ location = search((char const**)grades, (char const**)grades + gradeCount, (char const**)letters, (char const**)letters + letterCount, str_equal);
+
+ CPPUNIT_ASSERT(location != grades + gradeCount);
+ CPPUNIT_ASSERT(location - grades == 1);
+
+}
diff --git a/sources/android/stlport/test/unit/set_header_test.cpp b/sources/android/stlport/test/unit/set_header_test.cpp
new file mode 100644
index 0000000..8335e13
--- /dev/null
+++ b/sources/android/stlport/test/unit/set_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <set>
diff --git a/sources/android/stlport/test/unit/set_test.cpp b/sources/android/stlport/test/unit/set_test.cpp
new file mode 100644
index 0000000..9070b2f
--- /dev/null
+++ b/sources/android/stlport/test/unit/set_test.cpp
@@ -0,0 +1,507 @@
+//Has to be first for StackAllocator swap overload to be taken
+//into account (at least using GCC 4.0.1)
+#include "stack_allocator.h"
+
+#include <set>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class SetTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(SetTest);
+ CPPUNIT_TEST(set1);
+ CPPUNIT_TEST(set2);
+ CPPUNIT_TEST(erase);
+ CPPUNIT_TEST(insert);
+ CPPUNIT_TEST(find);
+ CPPUNIT_TEST(bounds);
+ CPPUNIT_TEST(specialized_less);
+ CPPUNIT_TEST(implementation_check);
+ CPPUNIT_TEST(allocator_with_state);
+ CPPUNIT_TEST(reverse_iterator_test);
+#if !defined (STLPORT) || !defined (_STLP_USE_CONTAINERS_EXTENSION)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(template_methods);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void set1();
+ void set2();
+ void erase();
+ void insert();
+ void find();
+ void bounds();
+ void specialized_less();
+ void implementation_check();
+ void allocator_with_state();
+ void reverse_iterator_test();
+ void template_methods();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(SetTest);
+
+
+//
+// tests implementation
+//
+void SetTest::set1()
+{
+ set<int, less<int> > s;
+ CPPUNIT_ASSERT (s.count(42) == 0);
+ s.insert(42);
+ CPPUNIT_ASSERT (s.count(42) == 1);
+ s.insert(42);
+ CPPUNIT_ASSERT (s.count(42) == 1);
+ size_t count = s.erase(42);
+ CPPUNIT_ASSERT (count == 1);
+}
+
+void SetTest::set2()
+{
+ typedef set<int, less<int> > int_set;
+ int_set s;
+ pair<int_set::iterator, bool> p = s.insert(42);
+ CPPUNIT_ASSERT (p.second == true);
+ p = s.insert(42);
+ CPPUNIT_ASSERT (p.second == false);
+
+ int array1 [] = { 1, 3, 6, 7 };
+ s.insert(array1, array1 + 4);
+ CPPUNIT_ASSERT (distance(s.begin(), s.end()) == 5);
+
+ int_set s2;
+ s2.swap(s);
+ CPPUNIT_ASSERT (distance(s2.begin(), s2.end()) == 5);
+ CPPUNIT_ASSERT (distance(s.begin(), s.end()) == 0);
+
+ int_set s3;
+ s3.swap(s);
+ s3.swap(s2);
+ CPPUNIT_ASSERT (distance(s.begin(), s.end()) == 0);
+ CPPUNIT_ASSERT (distance(s2.begin(), s2.end()) == 0);
+ CPPUNIT_ASSERT (distance(s3.begin(), s3.end()) == 5);
+}
+
+void SetTest::erase()
+{
+ set<int, less<int> > s;
+ s.insert(1);
+ s.erase(s.begin());
+ CPPUNIT_ASSERT( s.empty() );
+
+ size_t nb = s.erase(1);
+ CPPUNIT_ASSERT(nb == 0);
+}
+
+void SetTest::insert()
+{
+ set<int> s;
+ set<int>::iterator i = s.insert( s.end(), 0 );
+ CPPUNIT_ASSERT( *i == 0 );
+}
+
+void SetTest::find()
+{
+ set<int> s;
+
+ CPPUNIT_ASSERT( s.find(0) == s.end() );
+
+ set<int> const& crs = s;
+
+ CPPUNIT_ASSERT( crs.find(0) == crs.end() );
+}
+
+void SetTest::bounds()
+{
+ int array1 [] = { 1, 3, 6, 7 };
+ set<int> s(array1, array1 + sizeof(array1) / sizeof(array1[0]));
+ set<int> const& crs = s;
+
+ set<int>::iterator sit;
+ set<int>::const_iterator scit;
+ pair<set<int>::iterator, set<int>::iterator> pit;
+ pair<set<int>::const_iterator, set<int>::const_iterator> pcit;
+
+ //Check iterator on mutable set
+ sit = s.lower_bound(2);
+ CPPUNIT_ASSERT( sit != s.end() );
+ CPPUNIT_ASSERT( *sit == 3 );
+
+ sit = s.upper_bound(5);
+ CPPUNIT_ASSERT( sit != s.end() );
+ CPPUNIT_ASSERT( *sit == 6 );
+
+ pit = s.equal_range(6);
+ CPPUNIT_ASSERT( pit.first != pit.second );
+ CPPUNIT_ASSERT( pit.first != s.end() );
+ CPPUNIT_ASSERT( *pit.first == 6 );
+ CPPUNIT_ASSERT( pit.second != s.end() );
+ CPPUNIT_ASSERT( *pit.second == 7 );
+
+ pit = s.equal_range(4);
+ CPPUNIT_ASSERT( pit.first == pit.second );
+ CPPUNIT_ASSERT( pit.first != s.end() );
+ CPPUNIT_ASSERT( *pit.first == 6 );
+ CPPUNIT_ASSERT( pit.second != s.end() );
+ CPPUNIT_ASSERT( *pit.second == 6 );
+
+ //Check const_iterator on mutable set
+ scit = s.lower_bound(2);
+ CPPUNIT_ASSERT( scit != s.end() );
+ CPPUNIT_ASSERT( *scit == 3 );
+
+ scit = s.upper_bound(5);
+ CPPUNIT_ASSERT( scit != s.end() );
+ CPPUNIT_ASSERT( *scit == 6 );
+
+#ifdef _STLP_MEMBER_TEMPLATES
+ pcit = s.equal_range(6);
+ CPPUNIT_ASSERT( pcit.first != pcit.second );
+ CPPUNIT_ASSERT( pcit.first != s.end() );
+ CPPUNIT_ASSERT( *pcit.first == 6 );
+ CPPUNIT_ASSERT( pcit.second != s.end() );
+ CPPUNIT_ASSERT( *pcit.second == 7 );
+#endif
+
+ //Check const_iterator on const set
+ scit = crs.lower_bound(2);
+ CPPUNIT_ASSERT( scit != crs.end() );
+ CPPUNIT_ASSERT( *scit == 3 );
+
+ scit = crs.upper_bound(5);
+ CPPUNIT_ASSERT( scit != crs.end() );
+ CPPUNIT_ASSERT( *scit == 6 );
+
+ pcit = crs.equal_range(6);
+ CPPUNIT_ASSERT( pcit.first != pcit.second );
+ CPPUNIT_ASSERT( pcit.first != crs.end() );
+ CPPUNIT_ASSERT( *pcit.first == 6 );
+ CPPUNIT_ASSERT( pcit.second != crs.end() );
+ CPPUNIT_ASSERT( *pcit.second == 7 );
+}
+
+
+class SetTestClass {
+public:
+ SetTestClass (int data) : _data(data)
+ {}
+
+ int data() const {
+ return _data;
+ }
+
+private:
+ int _data;
+};
+
+#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+namespace std {
+#endif
+#if defined (STLPORT)
+ _STLP_TEMPLATE_NULL
+#else
+ template <>
+#endif
+ struct less<SetTestClass> {
+ bool operator () (SetTestClass const& lhs, SetTestClass const& rhs) const {
+ return lhs.data() < rhs.data();
+ }
+ };
+#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+}
+#endif
+
+void SetTest::specialized_less()
+{
+ set<SetTestClass> s;
+ s.insert(SetTestClass(1));
+ s.insert(SetTestClass(3));
+ s.insert(SetTestClass(2));
+ s.insert(SetTestClass(0));
+
+ set<SetTestClass>::iterator sit(s.begin()), sitEnd(s.end());
+ int i = 0;
+ for (; sit != sitEnd; ++sit, ++i) {
+ CPPUNIT_ASSERT( sit->data() == i );
+ }
+}
+
+void SetTest::implementation_check()
+{
+ set<int> tree;
+ tree.insert(1);
+ set<int>::iterator it = tree.begin();
+ int const& int_ref = *it++;
+ CPPUNIT_ASSERT( int_ref == 1 );
+
+ CPPUNIT_ASSERT( it == tree.end() );
+ CPPUNIT_ASSERT( it != tree.begin() );
+
+ set<int>::const_iterator cit = tree.begin();
+ int const& int_cref = *cit++;
+ CPPUNIT_ASSERT( int_cref == 1 );
+}
+
+void SetTest::reverse_iterator_test()
+{
+ set<int> tree;
+ tree.insert(1);
+ tree.insert(2);
+
+ {
+ set<int>::reverse_iterator rit(tree.rbegin());
+ CPPUNIT_ASSERT( *(rit++) == 2 );
+ CPPUNIT_ASSERT( *(rit++) == 1 );
+ CPPUNIT_ASSERT( rit == tree.rend() );
+ }
+
+ {
+ set<int> const& ctree = tree;
+ set<int>::const_reverse_iterator rit(ctree.rbegin());
+ CPPUNIT_ASSERT( *(rit++) == 2 );
+ CPPUNIT_ASSERT( *(rit++) == 1 );
+ CPPUNIT_ASSERT( rit == ctree.rend() );
+ }
+}
+
+void SetTest::allocator_with_state()
+{
+ char buf1[1024];
+ StackAllocator<int> stack1(buf1, buf1 + sizeof(buf1));
+
+ char buf2[1024];
+ StackAllocator<int> stack2(buf2, buf2 + sizeof(buf2));
+
+ int i;
+ typedef set<int, less<int>, StackAllocator<int> > SetInt;
+ less<int> intLess;
+
+ {
+ SetInt sint1(intLess, stack1);
+ for (i = 0; i < 5; ++i)
+ sint1.insert(i);
+ SetInt sint1Cpy(sint1);
+
+ SetInt sint2(intLess, stack2);
+ for (; i < 10; ++i)
+ sint2.insert(i);
+ SetInt sint2Cpy(sint2);
+
+ sint1.swap(sint2);
+
+ CPPUNIT_ASSERT( sint1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( sint2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( sint1 == sint2Cpy );
+ CPPUNIT_ASSERT( sint2 == sint1Cpy );
+ CPPUNIT_ASSERT( sint1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( sint2.get_allocator() == stack1 );
+ }
+ CPPUNIT_ASSERT( stack1.ok() );
+ CPPUNIT_ASSERT( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ {
+ SetInt sint1(intLess, stack1);
+ SetInt sint1Cpy(sint1);
+
+ SetInt sint2(intLess, stack2);
+ for (i = 0; i < 10; ++i)
+ sint2.insert(i);
+ SetInt sint2Cpy(sint2);
+
+ sint1.swap(sint2);
+
+ CPPUNIT_ASSERT( sint1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( sint2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( sint1 == sint2Cpy );
+ CPPUNIT_ASSERT( sint2 == sint1Cpy );
+ CPPUNIT_ASSERT( sint1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( sint2.get_allocator() == stack1 );
+ }
+ CPPUNIT_ASSERT( stack1.ok() );
+ CPPUNIT_ASSERT( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ {
+ SetInt sint1(intLess, stack1);
+ for (i = 0; i < 10; ++i)
+ sint1.insert(i);
+ SetInt sint1Cpy(sint1);
+
+ SetInt sint2(intLess, stack2);
+ SetInt sint2Cpy(sint2);
+
+ sint1.swap(sint2);
+
+ CPPUNIT_ASSERT( sint1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( sint2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( sint1 == sint2Cpy );
+ CPPUNIT_ASSERT( sint2 == sint1Cpy );
+ CPPUNIT_ASSERT( sint1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( sint2.get_allocator() == stack1 );
+ }
+ CPPUNIT_ASSERT( stack1.ok() );
+ CPPUNIT_ASSERT( stack2.ok() );
+ stack1.reset(); stack2.reset();
+}
+
+struct Key
+{
+ Key() : m_data(0) {}
+ explicit Key(int data) : m_data(data) {}
+
+ int m_data;
+};
+
+struct KeyCmp
+{
+ bool operator () (Key lhs, Key rhs) const
+ { return lhs.m_data < rhs.m_data; }
+
+ bool operator () (Key lhs, int rhs) const
+ { return lhs.m_data < rhs; }
+
+ bool operator () (int lhs, Key rhs) const
+ { return lhs < rhs.m_data; }
+};
+
+struct KeyCmpPtr
+{
+ bool operator () (Key const volatile *lhs, Key const volatile *rhs) const
+ { return (*lhs).m_data < (*rhs).m_data; }
+
+ bool operator () (Key const volatile *lhs, int rhs) const
+ { return (*lhs).m_data < rhs; }
+
+ bool operator () (int lhs, Key const volatile *rhs) const
+ { return lhs < (*rhs).m_data; }
+};
+
+void SetTest::template_methods()
+{
+#if defined (STLPORT) && defined (_STLP_USE_CONTAINERS_EXTENSION)
+ {
+ typedef set<Key, KeyCmp> KeySet;
+ KeySet keySet;
+ keySet.insert(Key(1));
+ keySet.insert(Key(2));
+ keySet.insert(Key(3));
+ keySet.insert(Key(4));
+
+ CPPUNIT_ASSERT( keySet.count(Key(1)) == 1 );
+ CPPUNIT_ASSERT( keySet.count(1) == 1 );
+ CPPUNIT_ASSERT( keySet.count(5) == 0 );
+
+ CPPUNIT_ASSERT( keySet.find(2) != keySet.end() );
+ CPPUNIT_ASSERT( keySet.lower_bound(2) != keySet.end() );
+ CPPUNIT_ASSERT( keySet.upper_bound(2) != keySet.end() );
+ CPPUNIT_ASSERT( keySet.equal_range(2) != make_pair(keySet.begin(), keySet.end()) );
+
+ KeySet const& ckeySet = keySet;
+ CPPUNIT_ASSERT( ckeySet.find(2) != ckeySet.end() );
+ CPPUNIT_ASSERT( ckeySet.lower_bound(2) != ckeySet.end() );
+ CPPUNIT_ASSERT( ckeySet.upper_bound(2) != ckeySet.end() );
+ CPPUNIT_ASSERT( ckeySet.equal_range(2) != make_pair(ckeySet.begin(), ckeySet.end()) );
+ }
+
+ {
+ typedef set<Key*, KeyCmpPtr> KeySet;
+ KeySet keySet;
+ Key key1(1), key2(2), key3(3), key4(4);
+ keySet.insert(&key1);
+ keySet.insert(&key2);
+ keySet.insert(&key3);
+ keySet.insert(&key4);
+
+ CPPUNIT_ASSERT( keySet.count(1) == 1 );
+ CPPUNIT_ASSERT( keySet.count(5) == 0 );
+
+ CPPUNIT_ASSERT( keySet.find(2) != keySet.end() );
+ CPPUNIT_ASSERT( keySet.lower_bound(2) != keySet.end() );
+ CPPUNIT_ASSERT( keySet.upper_bound(2) != keySet.end() );
+ CPPUNIT_ASSERT( keySet.equal_range(2) != make_pair(keySet.begin(), keySet.end()) );
+
+ KeySet const& ckeySet = keySet;
+ CPPUNIT_ASSERT( ckeySet.find(2) != ckeySet.end() );
+ CPPUNIT_ASSERT( ckeySet.lower_bound(2) != ckeySet.end() );
+ CPPUNIT_ASSERT( ckeySet.upper_bound(2) != ckeySet.end() );
+ CPPUNIT_ASSERT( ckeySet.equal_range(2) != make_pair(ckeySet.begin(), ckeySet.end()) );
+ }
+ {
+ typedef multiset<Key, KeyCmp> KeySet;
+ KeySet keySet;
+ keySet.insert(Key(1));
+ keySet.insert(Key(2));
+ keySet.insert(Key(3));
+ keySet.insert(Key(4));
+
+ CPPUNIT_ASSERT( keySet.count(Key(1)) == 1 );
+ CPPUNIT_ASSERT( keySet.count(1) == 1 );
+ CPPUNIT_ASSERT( keySet.count(5) == 0 );
+
+ CPPUNIT_ASSERT( keySet.find(2) != keySet.end() );
+ CPPUNIT_ASSERT( keySet.lower_bound(2) != keySet.end() );
+ CPPUNIT_ASSERT( keySet.upper_bound(2) != keySet.end() );
+ CPPUNIT_ASSERT( keySet.equal_range(2) != make_pair(keySet.begin(), keySet.end()) );
+
+ KeySet const& ckeySet = keySet;
+ CPPUNIT_ASSERT( ckeySet.find(2) != ckeySet.end() );
+ CPPUNIT_ASSERT( ckeySet.lower_bound(2) != ckeySet.end() );
+ CPPUNIT_ASSERT( ckeySet.upper_bound(2) != ckeySet.end() );
+ CPPUNIT_ASSERT( ckeySet.equal_range(2) != make_pair(ckeySet.begin(), ckeySet.end()) );
+ }
+
+ {
+ typedef multiset<Key const volatile*, KeyCmpPtr> KeySet;
+ KeySet keySet;
+ Key key1(1), key2(2), key3(3), key4(4);
+ keySet.insert(&key1);
+ keySet.insert(&key2);
+ keySet.insert(&key3);
+ keySet.insert(&key4);
+
+ CPPUNIT_ASSERT( keySet.count(1) == 1 );
+ CPPUNIT_ASSERT( keySet.count(5) == 0 );
+
+ CPPUNIT_ASSERT( keySet.find(2) != keySet.end() );
+ CPPUNIT_ASSERT( keySet.lower_bound(2) != keySet.end() );
+ CPPUNIT_ASSERT( keySet.upper_bound(2) != keySet.end() );
+ CPPUNIT_ASSERT( keySet.equal_range(2) != make_pair(keySet.begin(), keySet.end()) );
+
+ KeySet const& ckeySet = keySet;
+ CPPUNIT_ASSERT( ckeySet.find(2) != ckeySet.end() );
+ CPPUNIT_ASSERT( ckeySet.lower_bound(2) != ckeySet.end() );
+ CPPUNIT_ASSERT( ckeySet.upper_bound(2) != ckeySet.end() );
+ CPPUNIT_ASSERT( ckeySet.equal_range(2) != make_pair(ckeySet.begin(), ckeySet.end()) );
+ }
+#endif
+}
+
+#if !defined (STLPORT) || \
+ !defined (_STLP_USE_PTR_SPECIALIZATIONS) || defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+# if !defined (__DMC__)
+/* Simple compilation test: Check that nested types like iterator
+ * can be access even if type used to instanciate container is not
+ * yet completely defined.
+ */
+class IncompleteClass
+{
+ set<IncompleteClass> instances;
+ typedef set<IncompleteClass>::iterator it;
+ multiset<IncompleteClass> minstances;
+ typedef multiset<IncompleteClass>::iterator mit;
+};
+# endif
+#endif
diff --git a/sources/android/stlport/test/unit/setdiff_test.cpp b/sources/android/stlport/test/unit/setdiff_test.cpp
new file mode 100644
index 0000000..8fa2dda
--- /dev/null
+++ b/sources/android/stlport/test/unit/setdiff_test.cpp
@@ -0,0 +1,134 @@
+#include <numeric>
+#include <string>
+#include <iterator>
+#include <vector>
+#include <algorithm>
+#include <functional>
+
+#include "iota.h"
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class SetDifferenceTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(SetDifferenceTest);
+ CPPUNIT_TEST(setdiff0);
+ CPPUNIT_TEST(setdiff1);
+ CPPUNIT_TEST(setdiff2);
+ CPPUNIT_TEST(setsymd0);
+ CPPUNIT_TEST(setsymd1);
+ CPPUNIT_TEST(setsymd2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void setdiff0();
+ void setdiff1();
+ void setdiff2();
+ void setsymd0();
+ void setsymd1();
+ void setsymd2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(SetDifferenceTest);
+
+//
+// tests implementation
+//
+void SetDifferenceTest::setsymd0()
+{
+ int v1[3] = { 13, 18, 23 };
+ int v2[4] = { 10, 13, 17, 23 };
+ int result[4] = { 0, 0, 0, 0 };
+
+ set_symmetric_difference((int*)v1, (int*)v1 + 3, (int*)v2, (int*)v2 + 4, (int*)result);
+ CPPUNIT_ASSERT(result[0]==10);
+ CPPUNIT_ASSERT(result[1]==17);
+ CPPUNIT_ASSERT(result[2]==18);
+ CPPUNIT_ASSERT(result[3]==0);
+}
+
+void SetDifferenceTest::setsymd1()
+{
+ vector<int> v1(10);
+ __iota(v1.begin(), v1.end(), 0);
+ vector<int> v2(10);
+ __iota(v2.begin(), v2.end(), 7);
+
+ vector<int> diff;
+ set_symmetric_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), back_inserter(diff));
+ CPPUNIT_ASSERT( diff.size() == 14 );
+ int int_res[] = {0, 1, 2, 3, 4, 5, 6, 10, 11, 12, 13, 14, 15, 16};
+ for (int i = 0; i < 14; ++i) {
+ CPPUNIT_ASSERT( diff[i] == int_res[i] );
+ }
+}
+
+void SetDifferenceTest::setsymd2()
+{
+ const char* word1 = "ABCDEFGHIJKLMNO";
+ const char* word2 = "LMNOPQRSTUVWXYZ";
+
+ string diff;
+ set_symmetric_difference(word1, word1 + ::strlen(word1), word2, word2 + ::strlen(word2),
+ back_inserter(diff), less<char>());
+ CPPUNIT_ASSERT( diff.size() == 22 );
+ char char_res[] = "ABCDEFGHIJKPQRSTUVWXYZ";
+ for (int i = 0; i < 22; ++i) {
+ CPPUNIT_ASSERT( diff[i] == char_res[i] );
+ }
+}
+
+void SetDifferenceTest::setdiff0()
+{
+ int v1[3] = { 13, 18, 23 };
+ int v2[4] = { 10, 13, 17, 23 };
+ int result[4] = { 0, 0, 0, 0 };
+ //18 0 0 0
+ //10 17 23 0
+
+ set_difference((int*)v1, (int*)v1 + 3, (int*)v2, (int*)v2 + 4, (int*)result);
+ CPPUNIT_ASSERT( result[0] == 18 );
+ CPPUNIT_ASSERT( result[1] == 0 );
+ CPPUNIT_ASSERT( result[2] == 0 );
+ CPPUNIT_ASSERT( result[3] == 0 );
+
+ set_difference((int*)v2, (int*)v2 + 4, (int*)v1, (int*)v1 + 2, (int*)result);
+ CPPUNIT_ASSERT( result[0] == 10 );
+ CPPUNIT_ASSERT( result[1] == 17 );
+ CPPUNIT_ASSERT( result[2] == 23 );
+ CPPUNIT_ASSERT( result[3] == 0 );
+}
+
+void SetDifferenceTest::setdiff1()
+{
+ vector<int> v1(10);
+ __iota(v1.begin(), v1.end(), 0);
+ vector<int> v2(10);
+ __iota(v2.begin(), v2.end(), 7);
+
+ vector<int> diff;
+ set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), back_inserter(diff));
+ CPPUNIT_ASSERT( diff.size() == 7 );
+ for (int i = 0; i < 7; ++i) {
+ CPPUNIT_ASSERT( diff[i] == i );
+ }
+}
+
+void SetDifferenceTest::setdiff2()
+{
+ const char* word1 = "ABCDEFGHIJKLMNO";
+ const char* word2 = "LMNOPQRSTUVWXYZ";
+
+ string diff;
+ set_difference(word1, word1 + ::strlen(word1), word2, word2 + ::strlen(word2), back_inserter(diff), less<char>());
+ CPPUNIT_ASSERT( diff.size() == 11 );
+ for (int i = 0; i < 11; ++i) {
+ CPPUNIT_ASSERT( diff[i] == ('A' + i) );
+ }
+}
diff --git a/sources/android/stlport/test/unit/setinter_test.cpp b/sources/android/stlport/test/unit/setinter_test.cpp
new file mode 100644
index 0000000..ffcfd78
--- /dev/null
+++ b/sources/android/stlport/test/unit/setinter_test.cpp
@@ -0,0 +1,79 @@
+#include <numeric>
+#include <string>
+#include <iterator>
+#include <vector>
+#include <algorithm>
+#include <functional>
+
+#include "iota.h"
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class SetIntersectionTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(SetIntersectionTest);
+ CPPUNIT_TEST(setintr0);
+ CPPUNIT_TEST(setintr1);
+ CPPUNIT_TEST(setintr2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void setintr0();
+ void setintr1();
+ void setintr2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(SetIntersectionTest);
+
+//
+// tests implementation
+//
+void SetIntersectionTest::setintr0()
+{
+ int v1[3] = { 13, 18, 23 };
+ int v2[4] = { 10, 13, 17, 23 };
+ int result[4] = { 0, 0, 0, 0 };
+
+ set_intersection((int*)v1, (int*)v1 + 3, (int*)v2, (int*)v2 + 4, (int*)result);
+
+ CPPUNIT_ASSERT(result[0]==13);
+ CPPUNIT_ASSERT(result[1]==23);
+ CPPUNIT_ASSERT(result[2]==0);
+ CPPUNIT_ASSERT(result[3]==0);
+}
+
+void SetIntersectionTest::setintr1()
+{
+ vector <int> v1(10);
+ __iota(v1.begin(), v1.end(), 0);
+ vector <int> v2(10);
+ __iota(v2.begin(), v2.end(), 7);
+
+ vector<int> inter;
+ set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), back_inserter(inter));
+ CPPUNIT_ASSERT( inter.size() == 3 );
+ CPPUNIT_ASSERT( inter[0] == 7 );
+ CPPUNIT_ASSERT( inter[1] == 8 );
+ CPPUNIT_ASSERT( inter[2] == 9 );
+}
+
+void SetIntersectionTest::setintr2()
+{
+ const char* word1 = "ABCDEFGHIJKLMNO";
+ const char* word2 = "LMNOPQRSTUVWXYZ";
+
+ string inter;
+ set_intersection(word1, word1 + ::strlen(word1), word2, word2 + ::strlen(word2),
+ back_inserter(inter), less<char>());
+ CPPUNIT_ASSERT( inter.size() == 4 );
+ CPPUNIT_ASSERT( inter[0] == 'L' );
+ CPPUNIT_ASSERT( inter[1] == 'M' );
+ CPPUNIT_ASSERT( inter[2] == 'N' );
+ CPPUNIT_ASSERT( inter[3] == 'O' );
+}
diff --git a/sources/android/stlport/test/unit/setjmp_header_test.c b/sources/android/stlport/test/unit/setjmp_header_test.c
new file mode 100644
index 0000000..9496289
--- /dev/null
+++ b/sources/android/stlport/test/unit/setjmp_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <setjmp.h>
diff --git a/sources/android/stlport/test/unit/setjmp_header_test2.cpp b/sources/android/stlport/test/unit/setjmp_header_test2.cpp
new file mode 100644
index 0000000..00e4e4a
--- /dev/null
+++ b/sources/android/stlport/test/unit/setjmp_header_test2.cpp
@@ -0,0 +1,15 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+
+/*
+ * Sometimes, if native setjmp.h was included first, the setjmp functions
+ * situated in global namespace, not in vendor's std. This may confuse
+ * following csetjmp
+ */
+#include <setjmp.h>
+#include <csetjmp>
diff --git a/sources/android/stlport/test/unit/setunion_test.cpp b/sources/android/stlport/test/unit/setunion_test.cpp
new file mode 100644
index 0000000..577953e
--- /dev/null
+++ b/sources/android/stlport/test/unit/setunion_test.cpp
@@ -0,0 +1,81 @@
+#include <numeric>
+#include <string>
+#include <iterator>
+#include <vector>
+#include <algorithm>
+#include <functional>
+
+#include "iota.h"
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class SetUnionTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(SetUnionTest);
+ CPPUNIT_TEST(setunon0);
+ CPPUNIT_TEST(setunon1);
+ CPPUNIT_TEST(setunon2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void setunon0();
+ void setunon1();
+ void setunon2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(SetUnionTest);
+
+//
+// tests implementation
+//
+void SetUnionTest::setunon0()
+{
+ int v1[3] = { 13, 18, 23 };
+ int v2[4] = { 10, 13, 17, 23 };
+ int result[7] = { 0, 0, 0, 0, 0, 0, 0 };
+
+ set_union((int*)v1, (int*)v1 + 3, (int*)v2, (int*)v2 + 4, (int*)result);
+
+ CPPUNIT_ASSERT(result[0]==10);
+ CPPUNIT_ASSERT(result[1]==13);
+ CPPUNIT_ASSERT(result[2]==17);
+ CPPUNIT_ASSERT(result[3]==18);
+ CPPUNIT_ASSERT(result[4]==23);
+ CPPUNIT_ASSERT(result[5]==0);
+ CPPUNIT_ASSERT(result[6]==0);
+}
+
+void SetUnionTest::setunon1()
+{
+ vector <int> v1(10);
+ __iota(v1.begin(), v1.end(), 0);
+ vector <int> v2(10);
+ __iota(v2.begin(), v2.end(), 7);
+
+ vector<int> diff;
+ set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), back_inserter(diff));
+ CPPUNIT_ASSERT( diff.size() == 17 );
+ for (int i = 0; i < 17; ++i) {
+ CPPUNIT_ASSERT( diff[i] == i );
+ }
+}
+
+void SetUnionTest::setunon2()
+{
+ const char* word1 = "ABCDEFGHIJKLMNO";
+ const char* word2 = "LMNOPQRSTUVWXYZ";
+
+ string diff;
+ set_union(word1, word1 + ::strlen(word1), word2, word2 + ::strlen(word2),
+ back_inserter(diff), less<char>());
+ CPPUNIT_ASSERT( diff.size() == 26 );
+ for (int i = 0; i < 26; ++i) {
+ CPPUNIT_ASSERT( diff[i] == ('A' + i) );
+ }
+}
diff --git a/sources/android/stlport/test/unit/shared_ptr_test.cpp b/sources/android/stlport/test/unit/shared_ptr_test.cpp
new file mode 100644
index 0000000..a5393de
--- /dev/null
+++ b/sources/android/stlport/test/unit/shared_ptr_test.cpp
@@ -0,0 +1,41 @@
+#include <memory>
+
+#if !defined(_STLP_NO_EXTENSIONS) && defined(_STLP_USE_BOOST_SUPPORT)
+
+// #include <typeinfo>
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+class SharedPtrTest :
+ public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(SharedPtrTest);
+ CPPUNIT_TEST(shared_from_this);
+ CPPUNIT_TEST_SUITE_END();
+
+ protected:
+ void shared_from_this();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(SharedPtrTest);
+
+struct X;
+
+struct X :
+ public std::tr1::enable_shared_from_this<X>
+{
+};
+
+void SharedPtrTest::shared_from_this()
+{
+ std::tr1::shared_ptr<X> p( new X );
+ std::tr1::shared_ptr<X> q = p->shared_from_this();
+
+ CPPUNIT_CHECK( p == q );
+ CPPUNIT_CHECK( !(p < q) && !(q < p) ); // p and q share ownership
+}
+
+#endif /* !_STLP_NO_EXTENSIONS && _STLP_USE_BOOST_SUPPORT */
diff --git a/sources/android/stlport/test/unit/signal_header_test.c b/sources/android/stlport/test/unit/signal_header_test.c
new file mode 100644
index 0000000..e179eb2
--- /dev/null
+++ b/sources/android/stlport/test/unit/signal_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <signal.h>
diff --git a/sources/android/stlport/test/unit/slist_test.cpp b/sources/android/stlport/test/unit/slist_test.cpp
new file mode 100644
index 0000000..383ece2
--- /dev/null
+++ b/sources/android/stlport/test/unit/slist_test.cpp
@@ -0,0 +1,554 @@
+//Has to be first for StackAllocator swap overload to be taken
+//into account (at least using GCC 4.0.1)
+#include "stack_allocator.h"
+
+#include <algorithm>
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+# include <slist>
+# if !defined (_STLP_USE_NO_IOSTREAMS)
+# include <sstream>
+# endif
+# include <iterator>
+# include <functional>
+#endif
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+#if !defined (STLPORT) && defined(__GNUC__)
+using namespace __gnu_cxx;
+#endif
+
+//
+// TestCase class
+//
+class SlistTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(SlistTest);
+#if !defined (STLPORT) || defined (_STLP_NO_EXTENSIONS) || defined (_STLP_USE_NO_IOSTREAMS)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(slist1);
+#if defined (STLPORT) && defined (_STLP_USE_NO_IOSTREAMS)
+ CPPUNIT_STOP_IGNORE;
+#endif
+ CPPUNIT_TEST(erase);
+ CPPUNIT_TEST(insert);
+ CPPUNIT_TEST(splice);
+ CPPUNIT_TEST(allocator_with_state);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void slist1();
+ void erase();
+ void insert();
+ void splice();
+ void allocator_with_state();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(SlistTest);
+
+//
+// tests implementation
+//
+void SlistTest::slist1()
+{
+#if defined (STLPORT) && !defined (_STLP_USE_NO_IOSTREAMS) && !defined (_STLP_NO_EXTENSIONS)
+/*
+original: xlxtss
+reversed: sstxlx
+removed: sstl
+uniqued: stl
+sorted: lst
+*/
+
+ char array [] = { 'x', 'l', 'x', 't', 's', 's' };
+ ostringstream os;
+ ostream_iterator<char> o(os,"");
+ slist<char> str(array+0, array + 6);
+ slist<char>::iterator i;
+ //Check const_iterator construction from iterator
+ slist<char>::const_iterator ci(i);
+ slist<char>::const_iterator ci2(ci);
+// cout << "reversed: ";
+ str.reverse();
+ for(i = str.begin(); i != str.end(); i++)
+ os << *i;
+ stringbuf* buff=os.rdbuf();
+ string result=buff->str();
+ CPPUNIT_ASSERT(!strcmp(result.c_str(),"sstxlx"));
+
+ //cout << "removed: ";
+ str.remove('x');
+ ostringstream os2;
+ for(i = str.begin(); i != str.end(); i++)
+ os2 << *i;
+ buff=os2.rdbuf();
+ result=buff->str();
+ CPPUNIT_ASSERT(!strcmp(result.c_str(),"sstl"));
+
+
+ //cout << "uniqued: ";
+ str.unique();
+ ostringstream os3;
+ for(i = str.begin(); i != str.end(); i++)
+ os3 << *i;
+ buff=os3.rdbuf();
+ result=buff->str();
+ CPPUNIT_ASSERT(!strcmp(result.c_str(),"stl"));
+
+ //cout << "sorted: ";
+ str.sort();
+ ostringstream os4;
+ for(i = str.begin(); i != str.end(); i++)
+ os4 << *i;
+ buff = os4.rdbuf();
+ result = buff->str();
+ CPPUNIT_ASSERT(!strcmp(result.c_str(),"lst"));
+
+ //A small compilation time check to be activated from time to time:
+# if 0
+ {
+ slist<char>::iterator sl_char_ite;
+ slist<int>::iterator sl_int_ite;
+ CPPUNIT_ASSERT( sl_char_ite != sl_int_ite );
+ }
+# endif
+#endif
+}
+
+void SlistTest::erase()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ int array[] = { 0, 1, 2, 3, 4 };
+ slist<int> sl(array, array + 5);
+ slist<int>::iterator slit;
+
+ slit = sl.erase(sl.begin());
+ CPPUNIT_ASSERT( *slit == 1);
+
+ ++slit++; ++slit;
+ slit = sl.erase(sl.begin(), slit);
+ CPPUNIT_ASSERT( *slit == 3 );
+
+ sl.assign(array, array + 5);
+
+ slit = sl.erase_after(sl.begin());
+ CPPUNIT_ASSERT( *slit == 2 );
+
+ slit = sl.begin(); ++slit; ++slit;
+ slit = sl.erase_after(sl.begin(), slit);
+ CPPUNIT_ASSERT( *slit == 3 );
+
+ sl.erase_after(sl.before_begin());
+ CPPUNIT_ASSERT( sl.front() == 3 );
+#endif
+}
+
+void SlistTest::insert()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ int array[] = { 0, 1, 2, 3, 4 };
+
+ //insert
+ {
+ slist<int> sl;
+
+ sl.insert(sl.begin(), 5);
+ CPPUNIT_ASSERT( sl.front() == 5 );
+ CPPUNIT_ASSERT( sl.size() == 1 );
+
+ //debug mode check:
+ //sl.insert(sl.before_begin(), array, array + 5);
+
+ sl.insert(sl.begin(), array, array + 5);
+ CPPUNIT_ASSERT( sl.size() == 6 );
+ int i;
+ slist<int>::iterator slit(sl.begin());
+ for (i = 0; slit != sl.end(); ++slit, ++i) {
+ CPPUNIT_ASSERT( *slit == i );
+ }
+ }
+
+ //insert_after
+ {
+ slist<int> sl;
+
+ //debug check:
+ //sl.insert_after(sl.begin(), 5);
+
+ sl.insert_after(sl.before_begin(), 5);
+ CPPUNIT_ASSERT( sl.front() == 5 );
+ CPPUNIT_ASSERT( sl.size() == 1 );
+
+ sl.insert_after(sl.before_begin(), array, array + 5);
+ CPPUNIT_ASSERT( sl.size() == 6 );
+ int i;
+ slist<int>::iterator slit(sl.begin());
+ for (i = 0; slit != sl.end(); ++slit, ++i) {
+ CPPUNIT_ASSERT( *slit == i );
+ }
+ }
+#endif
+}
+
+void SlistTest::splice()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ int array[] = { 0, 1, 2, 3, 4 };
+
+ //splice
+ {
+ slist<int> sl1(array, array + 5);
+ slist<int> sl2(array, array + 5);
+ slist<int>::iterator slit;
+
+ //a no op:
+ sl1.splice(sl1.begin(), sl1, sl1.begin());
+ CPPUNIT_ASSERT( sl1 == sl2 );
+
+ slit = sl1.begin(); ++slit;
+ //a no op:
+ sl1.splice(slit, sl1, sl1.begin());
+ CPPUNIT_ASSERT( sl1 == sl2 );
+
+ sl1.splice(sl1.end(), sl1, sl1.begin());
+ slit = sl1.begin();
+ CPPUNIT_ASSERT( *(slit++) == 1 );
+ CPPUNIT_ASSERT( *(slit++) == 2 );
+ CPPUNIT_ASSERT( *(slit++) == 3 );
+ CPPUNIT_ASSERT( *(slit++) == 4 );
+ CPPUNIT_ASSERT( *slit == 0 );
+ sl1.splice(sl1.begin(), sl1, slit);
+ CPPUNIT_ASSERT( sl1 == sl2 );
+
+ sl1.splice(sl1.begin(), sl2);
+ size_t i;
+ for (i = 0, slit = sl1.begin(); slit != sl1.end(); ++slit, ++i) {
+ if (i == 5) i = 0;
+ CPPUNIT_ASSERT( *slit == array[i] );
+ }
+
+ slit = sl1.begin();
+ advance(slit, 5);
+ CPPUNIT_ASSERT( *slit == 0 );
+ sl2.splice(sl2.begin(), sl1, sl1.begin(), slit);
+ CPPUNIT_ASSERT( sl1 == sl2 );
+
+ slit = sl1.begin(); ++slit;
+ sl1.splice(sl1.begin(), sl1, slit, sl1.end());
+ slit = sl1.begin();
+ CPPUNIT_ASSERT( *(slit++) == 1 );
+ CPPUNIT_ASSERT( *(slit++) == 2 );
+ CPPUNIT_ASSERT( *(slit++) == 3 );
+ CPPUNIT_ASSERT( *(slit++) == 4 );
+ CPPUNIT_ASSERT( *slit == 0 );
+
+ // a no op
+ sl2.splice(sl2.end(), sl2, sl2.begin(), sl2.end());
+ for (i = 0, slit = sl2.begin(); slit != sl2.end(); ++slit, ++i) {
+ CPPUNIT_ASSERT( i < 5 );
+ CPPUNIT_ASSERT( *slit == array[i] );
+ }
+
+ slit = sl2.begin();
+ advance(slit, 3);
+ sl2.splice(sl2.end(), sl2, sl2.begin(), slit);
+ slit = sl2.begin();
+ CPPUNIT_ASSERT( *(slit++) == 3 );
+ CPPUNIT_ASSERT( *(slit++) == 4 );
+ CPPUNIT_ASSERT( *(slit++) == 0 );
+ CPPUNIT_ASSERT( *(slit++) == 1 );
+ CPPUNIT_ASSERT( *slit == 2 );
+ }
+
+ //splice_after
+ {
+ slist<int> sl1(array, array + 5);
+ slist<int> sl2(array, array + 5);
+ slist<int>::iterator slit;
+
+ //a no op:
+ sl1.splice_after(sl1.begin(), sl1, sl1.begin());
+ CPPUNIT_ASSERT( sl1 == sl2 );
+
+ sl1.splice_after(sl1.before_begin(), sl1, sl1.begin());
+ slit = sl1.begin();
+ CPPUNIT_ASSERT( *(slit++) == 1 );
+ CPPUNIT_ASSERT( *(slit++) == 0 );
+ CPPUNIT_ASSERT( *(slit++) == 2 );
+ CPPUNIT_ASSERT( *(slit++) == 3 );
+ CPPUNIT_ASSERT( *slit == 4 );
+ sl1.splice_after(sl1.before_begin(), sl1, sl1.begin());
+ CPPUNIT_ASSERT( sl1 == sl2 );
+
+ sl1.splice_after(sl1.before_begin(), sl2);
+ size_t i;
+ for (i = 0, slit = sl1.begin(); slit != sl1.end(); ++slit, ++i) {
+ if (i == 5) i = 0;
+ CPPUNIT_ASSERT( *slit == array[i] );
+ }
+
+ slit = sl1.begin();
+ advance(slit, 4);
+ CPPUNIT_ASSERT( *slit == 4 );
+ sl2.splice_after(sl2.before_begin(), sl1, sl1.before_begin(), slit);
+ CPPUNIT_ASSERT( sl1 == sl2 );
+
+ sl1.splice_after(sl1.before_begin(), sl1, sl1.begin(), sl1.previous(sl1.end()));
+ slit = sl1.begin();
+ CPPUNIT_ASSERT( *(slit++) == 1 );
+ CPPUNIT_ASSERT( *(slit++) == 2 );
+ CPPUNIT_ASSERT( *(slit++) == 3 );
+ CPPUNIT_ASSERT( *(slit++) == 4 );
+ CPPUNIT_ASSERT( *slit == 0 );
+
+ // a no op
+ sl2.splice_after(sl2.before_begin(), sl2, sl2.before_begin(), sl2.previous(sl2.end()));
+ for (i = 0, slit = sl2.begin(); slit != sl2.end(); ++slit, ++i) {
+ CPPUNIT_ASSERT( i < 5 );
+ CPPUNIT_ASSERT( *slit == array[i] );
+ }
+
+ slit = sl2.begin();
+ advance(slit, 2);
+ sl2.splice_after(sl2.previous(sl2.end()), sl2, sl2.before_begin(), slit);
+ slit = sl2.begin();
+ CPPUNIT_ASSERT( *(slit++) == 3 );
+ CPPUNIT_ASSERT( *(slit++) == 4 );
+ CPPUNIT_ASSERT( *(slit++) == 0 );
+ CPPUNIT_ASSERT( *(slit++) == 1 );
+ CPPUNIT_ASSERT( *slit == 2 );
+ }
+#endif
+}
+
+
+void SlistTest::allocator_with_state()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ char buf1[1024];
+ StackAllocator<int> stack1(buf1, buf1 + sizeof(buf1));
+
+ char buf2[1024];
+ StackAllocator<int> stack2(buf2, buf2 + sizeof(buf2));
+
+ typedef slist<int, StackAllocator<int> > SlistInt;
+ {
+ SlistInt slint1(10, 0, stack1);
+ SlistInt slint1Cpy(slint1);
+
+ SlistInt slint2(10, 1, stack2);
+ SlistInt slint2Cpy(slint2);
+
+ slint1.swap(slint2);
+
+ CPPUNIT_ASSERT( slint1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( slint2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( slint1 == slint2Cpy );
+ CPPUNIT_ASSERT( slint2 == slint1Cpy );
+ CPPUNIT_ASSERT( slint1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( slint2.get_allocator() == stack1 );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ {
+ SlistInt slint1(stack1);
+ SlistInt slint1Cpy(slint1);
+
+ SlistInt slint2(10, 1, stack2);
+ SlistInt slint2Cpy(slint2);
+
+ slint1.swap(slint2);
+
+ CPPUNIT_ASSERT( slint1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( slint2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( slint1 == slint2Cpy );
+ CPPUNIT_ASSERT( slint2 == slint1Cpy );
+ CPPUNIT_ASSERT( slint1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( slint2.get_allocator() == stack1 );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ {
+ SlistInt slint1(10, 0, stack1);
+ SlistInt slint1Cpy(slint1);
+
+ SlistInt slint2(stack2);
+ SlistInt slint2Cpy(slint2);
+
+ slint1.swap(slint2);
+
+ CPPUNIT_ASSERT( slint1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( slint2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( slint1 == slint2Cpy );
+ CPPUNIT_ASSERT( slint2 == slint1Cpy );
+ CPPUNIT_ASSERT( slint1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( slint2.get_allocator() == stack1 );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ //splice(iterator, slist)
+ {
+ SlistInt slint1(10, 0, stack1);
+ SlistInt slint2(10, 1, stack2);
+
+ slint1.splice(slint1.begin(), slint2);
+ CPPUNIT_ASSERT( slint1.size() == 20 );
+ CPPUNIT_ASSERT( slint2.empty() );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ //splice(iterator, slist, iterator)
+ {
+ SlistInt slint1(10, 0, stack1);
+ SlistInt slint2(10, 1, stack2);
+
+ slint1.splice(slint1.begin(), slint2, slint2.begin());
+ CPPUNIT_ASSERT( slint1.size() == 11 );
+ CPPUNIT_ASSERT( slint2.size() == 9 );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ //splice(iterator, slist, iterator, iterator)
+ {
+ SlistInt slint1(10, 0, stack1);
+ SlistInt slint2(10, 1, stack2);
+
+ SlistInt::iterator lit(slint2.begin());
+ advance(lit, 5);
+ slint1.splice(slint1.begin(), slint2, slint2.begin(), lit);
+ CPPUNIT_ASSERT( slint1.size() == 15 );
+ CPPUNIT_ASSERT( slint2.size() == 5 );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ //splice_after(iterator, slist)
+ {
+ SlistInt slint1(10, 0, stack1);
+ SlistInt slint2(10, 1, stack2);
+
+ slint1.splice_after(slint1.before_begin(), slint2);
+ CPPUNIT_ASSERT( slint1.size() == 20 );
+ CPPUNIT_ASSERT( slint2.empty() );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ //splice_after(iterator, slist, iterator)
+ {
+ SlistInt slint1(10, 0, stack1);
+ SlistInt slint2(10, 1, stack2);
+
+ slint1.splice_after(slint1.before_begin(), slint2, slint2.before_begin());
+ CPPUNIT_ASSERT( slint1.size() == 11 );
+ CPPUNIT_ASSERT( slint2.size() == 9 );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ //splice_after(iterator, slist, iterator, iterator)
+ {
+ SlistInt slint1(10, 0, stack1);
+ SlistInt slint2(10, 1, stack2);
+
+ SlistInt::iterator lit(slint2.begin());
+ advance(lit, 4);
+ slint1.splice_after(slint1.before_begin(), slint2, slint2.before_begin(), lit);
+ CPPUNIT_ASSERT( slint1.size() == 15 );
+ CPPUNIT_ASSERT( slint2.size() == 5 );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ //merge(slist)
+ {
+ SlistInt slint1(10, 0, stack1);
+ SlistInt slint2(10, 1, stack2);
+
+ SlistInt slintref(stack2);
+ slintref.insert_after(slintref.before_begin(), 10, 1);
+ slintref.insert_after(slintref.before_begin(), 10, 0);
+
+ slint1.merge(slint2);
+ CPPUNIT_ASSERT( slint1.size() == 20 );
+ CPPUNIT_ASSERT( slint1 == slintref );
+ CPPUNIT_ASSERT( slint2.empty() );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+
+ //merge(slist, predicate)
+# if (!defined (STLPORT) || !defined (_STLP_NO_MEMBER_TEMPLATES)) && \
+ (!defined (_MSC_VER) || (_MSC_VER >= 1300))
+ {
+ SlistInt slint1(10, 0, stack1);
+ SlistInt slint2(10, 1, stack2);
+
+ SlistInt slintref(stack2);
+ slintref.insert_after(slintref.before_begin(), 10, 0);
+ slintref.insert_after(slintref.before_begin(), 10, 1);
+
+ slint1.merge(slint2, greater<int>());
+ CPPUNIT_ASSERT( slint1.size() == 20 );
+ CPPUNIT_ASSERT( slint1 == slintref );
+ CPPUNIT_ASSERT( slint2.empty() );
+ }
+ CPPUNIT_CHECK( stack1.ok() );
+ CPPUNIT_CHECK( stack2.ok() );
+
+ //sort
+ {
+ //This is rather a compile time test.
+ //We check that sort implementation is correct when list is instanciated
+ //with an allocator that do not have a default constructor.
+ SlistInt slint1(stack1);
+ slint1.push_front(1);
+ slint1.insert_after(slint1.before_begin(), 10, 0);
+ greater<int> gt;
+ slint1.sort(gt);
+ CPPUNIT_ASSERT( slint1.front() == 1 );
+ slint1.sort();
+ SlistInt::iterator slit(slint1.begin());
+ advance(slit, 10);
+ CPPUNIT_ASSERT( *slit == 1 );
+ }
+# endif
+#endif
+}
+
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS) && \
+ (!defined (_STLP_USE_PTR_SPECIALIZATIONS) || defined (_STLP_CLASS_PARTIAL_SPECIALIZATION))
+# if !defined (__DMC__)
+/* Simple compilation test: Check that nested types like iterator
+ * can be access even if type used to instanciate container is not
+ * yet completely defined.
+ */
+class IncompleteClass
+{
+ slist<IncompleteClass> instances;
+ typedef slist<IncompleteClass>::iterator it;
+};
+# endif
+#endif
diff --git a/sources/android/stlport/test/unit/sort_test.cpp b/sources/android/stlport/test/unit/sort_test.cpp
new file mode 100644
index 0000000..49bc946
--- /dev/null
+++ b/sources/android/stlport/test/unit/sort_test.cpp
@@ -0,0 +1,217 @@
+#include <vector>
+#include <algorithm>
+#include <functional>
+
+#if defined (STLPORT) && defined (_STLP_DEBUG) && defined (_STLP_DEBUG_MODE_THROWS)
+# define _STLP_DO_CHECK_BAD_PREDICATE
+# include <stdexcept>
+#endif
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class SortTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(SortTest);
+ CPPUNIT_TEST(sort1);
+ CPPUNIT_TEST(sort2);
+ CPPUNIT_TEST(sort3);
+ CPPUNIT_TEST(sort4);
+ CPPUNIT_TEST(stblsrt1);
+ CPPUNIT_TEST(stblsrt2);
+#if defined (_STLP_DO_CHECK_BAD_PREDICATE)
+ CPPUNIT_TEST(bad_predicate_detected);
+#endif
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void sort1();
+ void sort2();
+ void sort3();
+ void sort4();
+ void stblsrt1();
+ void stblsrt2();
+ void bad_predicate_detected();
+
+ static bool string_less(const char* a_, const char* b_)
+ {
+ return strcmp(a_, b_) < 0 ? 1 : 0;
+ }
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(SortTest);
+
+//
+// tests implementation
+//
+void SortTest::stblsrt1()
+{
+ //Check that stable_sort do sort
+ int numbers[6] = { 1, 50, -10, 11, 42, 19 };
+ stable_sort(numbers, numbers + 6);
+ //-10 1 11 19 42 50
+ CPPUNIT_ASSERT(numbers[0]==-10);
+ CPPUNIT_ASSERT(numbers[1]==1);
+ CPPUNIT_ASSERT(numbers[2]==11);
+ CPPUNIT_ASSERT(numbers[3]==19);
+ CPPUNIT_ASSERT(numbers[4]==42);
+ CPPUNIT_ASSERT(numbers[5]==50);
+
+ char const* letters[6] = {"bb", "aa", "ll", "dd", "qq", "cc" };
+ stable_sort(letters, letters + 6, string_less);
+ // aa bb cc dd ll qq
+ CPPUNIT_ASSERT( strcmp(letters[0], "aa") == 0 );
+ CPPUNIT_ASSERT( strcmp(letters[1], "bb") == 0 );
+ CPPUNIT_ASSERT( strcmp(letters[2], "cc") == 0 );
+ CPPUNIT_ASSERT( strcmp(letters[3], "dd") == 0 );
+ CPPUNIT_ASSERT( strcmp(letters[4], "ll") == 0 );
+ CPPUNIT_ASSERT( strcmp(letters[5], "qq") == 0 );
+}
+
+struct Data {
+ Data(int index, int value)
+ : m_index(index), m_value(value) {}
+
+ bool operator == (const Data& other) const
+ { return m_index == other.m_index && m_value == other.m_value; }
+ bool operator < (const Data& other) const
+ { return m_value < other.m_value; }
+
+private:
+ int m_index, m_value;
+};
+
+void SortTest::stblsrt2()
+{
+ //Check that stable_sort is stable:
+ Data datas[] = {
+ Data(0, 10),
+ Data(1, 8),
+ Data(2, 6),
+ Data(3, 6),
+ Data(4, 6),
+ Data(5, 4),
+ Data(6, 9)
+ };
+ stable_sort(datas, datas + 7);
+
+ CPPUNIT_ASSERT( datas[0] == Data(5, 4) );
+ CPPUNIT_ASSERT( datas[1] == Data(2, 6) );
+ CPPUNIT_ASSERT( datas[2] == Data(3, 6) );
+ CPPUNIT_ASSERT( datas[3] == Data(4, 6) );
+ CPPUNIT_ASSERT( datas[4] == Data(1, 8) );
+ CPPUNIT_ASSERT( datas[5] == Data(6, 9) );
+ CPPUNIT_ASSERT( datas[6] == Data(0, 10) );
+}
+
+void SortTest::sort1()
+{
+ int numbers[6] = { 1, 50, -10, 11, 42, 19 };
+
+ sort(numbers, numbers + 6);
+ // -10 1 11 19 42 50
+ CPPUNIT_ASSERT(numbers[0]==-10);
+ CPPUNIT_ASSERT(numbers[1]==1);
+ CPPUNIT_ASSERT(numbers[2]==11);
+ CPPUNIT_ASSERT(numbers[3]==19);
+ CPPUNIT_ASSERT(numbers[4]==42);
+ CPPUNIT_ASSERT(numbers[5]==50);
+}
+
+void SortTest::sort2()
+{
+ int numbers[] = { 1, 50, -10, 11, 42, 19 };
+
+ int count = sizeof(numbers) / sizeof(numbers[0]);
+ sort(numbers, numbers + count, greater<int>());
+
+ // 50 42 19 11 1 -10
+ CPPUNIT_ASSERT(numbers[5]==-10);
+ CPPUNIT_ASSERT(numbers[4]==1);
+ CPPUNIT_ASSERT(numbers[3]==11);
+ CPPUNIT_ASSERT(numbers[2]==19);
+ CPPUNIT_ASSERT(numbers[1]==42);
+ CPPUNIT_ASSERT(numbers[0]==50);
+}
+
+void SortTest::sort3()
+{
+ vector<bool> boolVector;
+
+ boolVector.push_back( true );
+ boolVector.push_back( false );
+
+ sort( boolVector.begin(), boolVector.end() );
+
+ CPPUNIT_ASSERT(boolVector[0]==false);
+ CPPUNIT_ASSERT(boolVector[1]==true);
+}
+
+/*
+ * A small utility class to check a potential compiler bug
+ * that can result in a bad sort algorithm behavior. The type
+ * _Tp of the SortTestFunc has to be SortTestAux without any
+ * reference qualifier.
+ */
+struct SortTestAux {
+ SortTestAux (bool &b) : _b(b)
+ {}
+
+ SortTestAux (SortTestAux const&other) : _b(other._b) {
+ _b = true;
+ }
+
+ bool &_b;
+
+private:
+ //explicitely defined as private to avoid warnings:
+ SortTestAux& operator = (SortTestAux const&);
+};
+
+template <class _Tp>
+void SortTestFunc (_Tp) {
+}
+
+void SortTest::sort4()
+{
+ bool copy_constructor_called = false;
+ SortTestAux instance(copy_constructor_called);
+ SortTestAux &r_instance = instance;
+ SortTestAux const& rc_instance = instance;
+
+ SortTestFunc(r_instance);
+ CPPUNIT_ASSERT(copy_constructor_called);
+ copy_constructor_called = false;
+ SortTestFunc(rc_instance);
+ CPPUNIT_ASSERT(copy_constructor_called);
+}
+
+#if defined (_STLP_DO_CHECK_BAD_PREDICATE)
+void SortTest::bad_predicate_detected()
+{
+ int numbers[] = { 0, 0, 1, 0, 0, 1, 0, 0 };
+ try {
+ sort(numbers, numbers + sizeof(numbers) / sizeof(numbers[0]), less_equal<int>());
+
+ //Here is means that no exception has been raised
+ CPPUNIT_ASSERT( false );
+ }
+ catch (runtime_error const&)
+ { /*OK bad predicate has been detected.*/ }
+
+ try {
+ stable_sort(numbers, numbers + sizeof(numbers) / sizeof(numbers[0]), less_equal<int>());
+
+ //Here is means that no exception has been raised
+ CPPUNIT_ASSERT( false );
+ }
+ catch (runtime_error const&)
+ { /*OK bad predicate has been detected.*/ }
+}
+#endif
diff --git a/sources/android/stlport/test/unit/sstream_header_test.cpp b/sources/android/stlport/test/unit/sstream_header_test.cpp
new file mode 100644
index 0000000..784f79a
--- /dev/null
+++ b/sources/android/stlport/test/unit/sstream_header_test.cpp
@@ -0,0 +1,10 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#if !defined (_STLP_NO_IOSTREAMS)
+# include <sstream>
+#endif
diff --git a/sources/android/stlport/test/unit/sstream_test.cpp b/sources/android/stlport/test/unit/sstream_test.cpp
new file mode 100644
index 0000000..c22066d
--- /dev/null
+++ b/sources/android/stlport/test/unit/sstream_test.cpp
@@ -0,0 +1,487 @@
+#include <string>
+#include "math_aux.h"
+
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# include <sstream>
+# include <memory>
+
+# include "full_streambuf.h"
+
+# include "cppunit/cppunit_proxy.h"
+
+# if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+# endif
+
+//
+// TestCase class
+//
+class SstreamTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(SstreamTest);
+ CPPUNIT_TEST(output);
+ CPPUNIT_TEST(input);
+ CPPUNIT_TEST(input_char);
+ CPPUNIT_TEST(io);
+ CPPUNIT_TEST(err);
+ CPPUNIT_TEST(err_long);
+ CPPUNIT_TEST(maxint);
+ CPPUNIT_TEST(init_in);
+ CPPUNIT_TEST(init_out);
+ CPPUNIT_TEST(buf);
+ CPPUNIT_TEST(rdbuf);
+ CPPUNIT_TEST(streambuf_output);
+ CPPUNIT_TEST(seek);
+ CPPUNIT_TEST(seekp);
+ CPPUNIT_TEST(seek_gp);
+ CPPUNIT_TEST(tellp);
+ CPPUNIT_TEST(negative);
+ CPPUNIT_TEST_SUITE_END();
+
+ protected:
+ void output();
+ void input();
+ void input_char();
+ void io();
+ void err();
+ void err_long();
+ void maxint();
+ void init_in();
+ void init_out();
+ void buf();
+ void rdbuf();
+ void streambuf_output();
+ void seek();
+ void seekp();
+ void seek_gp();
+ void tellp();
+ void negative();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(SstreamTest);
+
+//
+// tests implementation
+//
+void SstreamTest::output()
+{
+ {
+ ostringstream s;
+
+ s << 1 << '\n' << 2.0 << '\n' << "abcd\n" << "ghk lm\n" << "abcd ef";
+ CPPUNIT_ASSERT( s.good() );
+ CPPUNIT_ASSERT( s.str() == "1\n2\nabcd\nghk lm\nabcd ef" );
+ }
+
+ //Following tests are mostly used to reveal problem with the MSVC /Wp64 option
+ //used to track 64 bits portability issue:
+ {
+ ostringstream s;
+ size_t i = 0;
+ s << i;
+ CPPUNIT_ASSERT( s.good() );
+ CPPUNIT_ASSERT( s.str() == "0" );
+ }
+ {
+ ostringstream s;
+ ptrdiff_t i = 0;
+ s << i;
+ CPPUNIT_ASSERT( s.good() );
+ CPPUNIT_ASSERT( s.str() == "0" );
+ }
+}
+
+void SstreamTest::input()
+{
+ {
+ istringstream s( "1\n2\nabcd\nghk lm\nabcd ef" );
+ int i = 0;
+ s >> i;
+ CPPUNIT_ASSERT( s.good() );
+ CPPUNIT_ASSERT( i == 1 );
+ double d = 0.0;
+ s >> d;
+ CPPUNIT_ASSERT( s.good() );
+ CPPUNIT_ASSERT( d == 2.0 );
+ string str;
+ s >> str;
+ CPPUNIT_ASSERT( s.good() );
+ CPPUNIT_ASSERT( str == "abcd" );
+ char c;
+ s.get(c); // extract newline, that not extracted by operator >>
+ CPPUNIT_ASSERT( s.good() );
+ CPPUNIT_ASSERT( c == '\n' );
+ getline( s, str );
+ CPPUNIT_ASSERT( s.good() );
+ CPPUNIT_ASSERT( str == "ghk lm" );
+ getline( s, str );
+ CPPUNIT_ASSERT( s.eof() );
+ CPPUNIT_ASSERT( str == "abcd ef" );
+ }
+ {
+ istringstream s("0");
+ size_t i = 1;
+ s >> i;
+ CPPUNIT_ASSERT( !s.fail() );
+ CPPUNIT_ASSERT( s.eof() );
+ CPPUNIT_ASSERT( i == 0 );
+ }
+}
+
+void SstreamTest::input_char()
+{
+ char buf[16] = { 0, '1', '2', '3' };
+ istringstream s( "0" );
+ s >> buf;
+
+ CPPUNIT_ASSERT( buf[0] == '0' );
+ CPPUNIT_ASSERT( buf[1] == 0 );
+ CPPUNIT_ASSERT( buf[2] == '2' );
+}
+
+
+void SstreamTest::io()
+{
+ stringstream s;
+ s << 1 << '\n' << 2.0 << '\n' << "abcd\n" << "ghk lm\n" << "abcd ef";
+ CPPUNIT_ASSERT( s.good() );
+
+ int i = 0;
+ s >> i;
+ CPPUNIT_ASSERT( i == 1 );
+ CPPUNIT_ASSERT( s.good() );
+ double d = 0.0;
+ s >> d;
+ CPPUNIT_ASSERT( d == 2.0 );
+ CPPUNIT_ASSERT( s.good() );
+ string str;
+ s >> str;
+ CPPUNIT_ASSERT( str == "abcd" );
+ CPPUNIT_ASSERT( s.good() );
+ char c;
+ s.get(c); // extract newline, that not extracted by operator >>
+ CPPUNIT_ASSERT( s.good() );
+ CPPUNIT_ASSERT( c == '\n' );
+ getline( s, str );
+ CPPUNIT_ASSERT( s.good() );
+ CPPUNIT_ASSERT( str == "ghk lm" );
+ getline( s, str );
+ CPPUNIT_ASSERT( str == "abcd ef" );
+ CPPUNIT_ASSERT( s.eof() );
+}
+
+void SstreamTest::err()
+{
+ stringstream s( "9" );
+
+ int i = 0;
+ s >> i;
+ CPPUNIT_ASSERT( !s.fail() );
+ CPPUNIT_ASSERT( i == 9 );
+ s >> i;
+ CPPUNIT_ASSERT( s.fail() );
+ CPPUNIT_ASSERT( s.eof() );
+ CPPUNIT_ASSERT( i == 9 );
+}
+
+void SstreamTest::err_long()
+{
+ stringstream s( "9" );
+
+ long i = 0;
+ s >> i;
+ CPPUNIT_ASSERT( !s.fail() );
+ CPPUNIT_ASSERT( i == 9 );
+ s >> i;
+ CPPUNIT_ASSERT( s.fail() );
+ CPPUNIT_ASSERT( s.eof() );
+ CPPUNIT_ASSERT( i == 9 );
+}
+
+void SstreamTest::maxint()
+{
+ stringstream s;
+
+ s << INT_MAX << " " << UINT_MAX << " " << LONG_MAX << " " << ULONG_MAX << " "
+ << INT_MIN << " " << LONG_MIN;
+ CPPUNIT_ASSERT( s.good() );
+
+ int i = 0;
+ unsigned int u = 0;
+ long l = 0;
+ unsigned long ul = 0;
+
+ s >> i >> u >> l >> ul;
+ CPPUNIT_ASSERT( s.good() );
+ CPPUNIT_ASSERT( i == INT_MAX );
+ CPPUNIT_ASSERT( u == UINT_MAX );
+ CPPUNIT_ASSERT( l == LONG_MAX );
+ CPPUNIT_ASSERT( ul == ULONG_MAX );
+
+ s >> i >> l;
+ CPPUNIT_ASSERT( !s.fail() );
+ CPPUNIT_ASSERT( i == INT_MIN );
+ CPPUNIT_ASSERT( l == LONG_MIN );
+}
+
+void SstreamTest::init_in()
+{
+ istringstream is( "12345" );
+ int n;
+
+ is >> n;
+ CPPUNIT_ASSERT( !is.fail() );
+ CPPUNIT_ASSERT( n == 12345 );
+
+ istringstream dis( "1.2345" );
+ double d;
+
+ dis >> d;
+ CPPUNIT_ASSERT( !dis.fail() );
+ CPPUNIT_ASSERT( are_equals(d, 1.2345) );
+
+ istringstream fis( "1.2345" );
+ float f;
+
+ fis >> f;
+ CPPUNIT_ASSERT( !fis.fail() );
+ CPPUNIT_ASSERT( are_equals(f, 1.2345f) );
+}
+
+void SstreamTest::init_out()
+{
+ ostringstream os( "12345" );
+ CPPUNIT_ASSERT( os.str() == "12345" );
+
+ os << 67;
+ CPPUNIT_ASSERT( os.good() );
+
+ // This satisfy to the Standard:
+ // CPPUNIT_ASSERT( os.str() == "67345" );
+ // But we don't know the reason, why standard state that.
+
+ /*
+ * 27.7.1.1: ... then copies the content of str into the basic_sringbuf
+ * underlying character sequence and initializes the input and output
+ * sequences according to which. If which & ios_base::out is true, initializes
+ * the output sequence with underlying sequence. ...
+ *
+ * I can treat this as 'like output was performed', and then I should bump
+ * put pointer... Looks like more useful then my previous treatment.
+ *
+ * - ptr
+ */
+
+ CPPUNIT_ASSERT( os.str() == "1234567" );
+
+
+ os.str( "89ab" );
+ CPPUNIT_ASSERT( os.str() == "89ab" );
+
+ os << 10;
+ CPPUNIT_ASSERT( os.good() );
+ // CPPUNIT_ASSERT( os.str() == "10ab" );
+ CPPUNIT_ASSERT( os.str() == "89ab10" );
+}
+
+void SstreamTest::buf()
+{
+ stringstream ss;
+
+ ss << "1234567\n89\n";
+ char buf[10];
+ buf[7] = 'x';
+ ss.get( buf, 10 );
+ CPPUNIT_ASSERT( !ss.fail() );
+ CPPUNIT_ASSERT( buf[0] == '1' );
+ CPPUNIT_ASSERT( buf[1] == '2' );
+ CPPUNIT_ASSERT( buf[2] == '3' );
+ CPPUNIT_ASSERT( buf[3] == '4' );
+ CPPUNIT_ASSERT( buf[4] == '5' );
+ CPPUNIT_ASSERT( buf[5] == '6' );
+ CPPUNIT_ASSERT( buf[6] == '7' ); // 27.6.1.3 paragraph 10, paragraph 7
+ CPPUNIT_ASSERT( buf[7] == 0 ); // 27.6.1.3 paragraph 8
+ char c;
+ ss.get(c);
+ CPPUNIT_ASSERT( !ss.fail() );
+ CPPUNIT_ASSERT( c == '\n' ); // 27.6.1.3 paragraph 10, paragraph 7
+ ss.get(c);
+ CPPUNIT_ASSERT( !ss.fail() );
+ CPPUNIT_ASSERT( c == '8' );
+}
+
+void SstreamTest::rdbuf()
+{
+ stringstream ss;
+
+ ss << "1234567\n89\n";
+
+ ostringstream os;
+ ss.get( *os.rdbuf(), '\n' );
+ CPPUNIT_ASSERT( !ss.fail() );
+ char c;
+ ss.get(c);
+ CPPUNIT_ASSERT( !ss.fail() );
+ CPPUNIT_ASSERT( c == '\n' ); // 27.6.1.3 paragraph 12
+ CPPUNIT_ASSERT( os.str() == "1234567" );
+}
+
+void SstreamTest::streambuf_output()
+{
+ {
+ istringstream in("01234567890123456789");
+ CPPUNIT_ASSERT( in );
+
+ full_streambuf full_buf(10);
+ ostream out(&full_buf);
+ CPPUNIT_ASSERT( out );
+
+ out << in.rdbuf();
+ CPPUNIT_ASSERT( out );
+ CPPUNIT_ASSERT( in );
+ //out is good we can check what has been extracted:
+ CPPUNIT_ASSERT( full_buf.str() == "0123456789" );
+
+ out << in.rdbuf();
+ CPPUNIT_ASSERT( out.fail() );
+ CPPUNIT_ASSERT( in );
+
+ ostringstream ostr;
+ ostr << in.rdbuf();
+ CPPUNIT_ASSERT( ostr );
+ CPPUNIT_ASSERT( in );
+ CPPUNIT_ASSERT( ostr.str() == "0123456789" );
+ }
+
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ {
+ //If the output stream buffer throws:
+ istringstream in("01234567890123456789");
+ CPPUNIT_ASSERT( in );
+
+ full_streambuf full_buf(10, true);
+ ostream out(&full_buf);
+ CPPUNIT_ASSERT( out );
+
+ out << in.rdbuf();
+ CPPUNIT_ASSERT( out.bad() );
+ CPPUNIT_ASSERT( in );
+ //out is bad we have no guaranty on what has been extracted:
+ //CPPUNIT_ASSERT( full_buf.str() == "0123456789" );
+
+ out.clear();
+ out << in.rdbuf();
+ CPPUNIT_ASSERT( out.fail() && out.bad() );
+ CPPUNIT_ASSERT( in );
+
+ ostringstream ostr;
+ ostr << in.rdbuf();
+ CPPUNIT_ASSERT( ostr );
+ CPPUNIT_ASSERT( in );
+ CPPUNIT_ASSERT( ostr.str() == "01234567890123456789" );
+ }
+# endif
+}
+
+void SstreamTest::seek()
+{
+ stringstream s( "0123456789" );
+
+ CPPUNIT_ASSERT( s.tellg() == stringstream::pos_type(0) );
+ s.seekg( 6, ios::beg );
+ CPPUNIT_ASSERT( s.tellg() == stringstream::pos_type(6) );
+ s.seekg( -3, ios::cur );
+ CPPUNIT_ASSERT( s.tellg() == stringstream::pos_type(3) );
+
+ istringstream is( "0123456789" );
+ CPPUNIT_ASSERT( is.tellg() == stringstream::pos_type(0) );
+ is.seekg( 6, ios::beg );
+ CPPUNIT_ASSERT( is.tellg() == stringstream::pos_type(6) );
+ is.seekg( -3, ios::cur );
+ CPPUNIT_ASSERT( is.tellg() == stringstream::pos_type(3) );
+}
+
+void SstreamTest::seekp()
+{
+ ostringstream s;
+
+ s << "1234567";
+ CPPUNIT_CHECK( s.tellp() == stringstream::pos_type(7) );
+ CPPUNIT_CHECK( s.str() == "1234567" );
+ s.seekp( 0 );
+ s << "X";
+ CPPUNIT_CHECK( s.str() == "X234567" );
+ s.seekp( 0, ios::beg );
+ s << "Y";
+ CPPUNIT_CHECK( s.str() == "Y234567" );
+}
+
+void SstreamTest::seek_gp()
+{
+ stringstream ss( "1" );
+
+ /* ISO/IEC 14882 2003 (and 1998 too) assume change as get as put positions
+ with seekg and seekp (27.6.1.3, par 38; 27.6.2.4 par 2),
+ but this contradict to common practice and proposed draft N2588
+ (27.6.1.3, par 41; 27.6.2.5, par 4)
+
+ Now STLport implement (i.e. change behaviour ) the draft's point of view.
+ */
+
+ ss.seekg( 0, ios::beg );
+ ss.seekp( 0, ios::end );
+
+ ss << "2";
+
+ string str;
+
+ ss >> str;
+
+ /* CPPUNIT_CHECK( str == "2" ); --- according ISO/IEC 14882 2003 */
+ CPPUNIT_CHECK( str == "12" );
+}
+
+void SstreamTest::tellp()
+{
+ {
+ ostringstream o( "1" );
+
+ o << "23456";
+
+ CPPUNIT_CHECK( o.rdbuf()->pubseekoff( 0, ios_base::cur, ios_base::out ) == stringstream::pos_type(6) );
+ CPPUNIT_CHECK( o.tellp() == stringstream::pos_type(6) );
+ }
+ {
+ ostringstream o;
+
+ o << "123456";
+
+ CPPUNIT_CHECK( o.rdbuf()->pubseekoff( 0, ios_base::cur, ios_base::out ) == stringstream::pos_type(6) );
+ CPPUNIT_CHECK( o.tellp() == stringstream::pos_type(6) );
+ }
+ {
+ ostringstream o( "1" );
+
+ o << "23456789";
+
+ CPPUNIT_CHECK( o.rdbuf()->pubseekoff( 0, ios_base::cur, ios_base::out ) == stringstream::pos_type(9) );
+ CPPUNIT_CHECK( o.tellp() == stringstream::pos_type(9) );
+ }
+}
+
+
+template < class T >
+string to_string( const T& v )
+{
+ ostringstream oss;
+ oss << v;
+ return oss.str();
+}
+
+void SstreamTest::negative()
+{
+ CPPUNIT_CHECK( to_string<int>(-1) == "-1" );
+ CPPUNIT_CHECK( to_string<long>(-1) == "-1" );
+}
+
+#endif
diff --git a/sources/android/stlport/test/unit/stack_allocator.h b/sources/android/stlport/test/unit/stack_allocator.h
new file mode 100644
index 0000000..93db960
--- /dev/null
+++ b/sources/android/stlport/test/unit/stack_allocator.h
@@ -0,0 +1,206 @@
+#ifndef STLPORT_UNIT_TEST_STACK_ALLOCATOR_H
+#define STLPORT_UNIT_TEST_STACK_ALLOCATOR_H
+
+#include <algorithm>
+
+#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+//For bad_alloc:
+# include <new>
+#endif
+
+#undef __STD
+#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+# define __STD std::
+#else
+# define __STD
+#endif
+
+struct State {
+ char *m_beg, *m_end, *m_cur;
+ bool m_isOk, m_swaped;
+ int m_nbAlloc;
+
+ //The following members are shared among all StackAllocator instance created from
+ //a reference StackAllocator instance:
+ char **m_sharedCur;
+ bool *m_sharedOk;
+ int *m_sharedNbAlloc;
+
+#if defined (__DMC__)
+ State(){}
+#endif
+
+ State(char *beg, char *end)
+ : m_beg(beg), m_end(end), m_cur(m_beg), m_isOk(true), m_swaped(false), m_nbAlloc(0),
+ m_sharedCur(&m_cur), m_sharedOk(&m_isOk), m_sharedNbAlloc(&m_nbAlloc) {}
+
+ State(const State& other)
+ : m_beg(other.m_beg), m_end(other.m_end), m_cur(0),
+ m_isOk(true), m_swaped(other.m_swaped), m_nbAlloc(0),
+ m_sharedCur(other.m_sharedCur), m_sharedOk(other.m_sharedOk),
+ m_sharedNbAlloc(other.m_sharedNbAlloc) {}
+};
+
+/* This allocator is not thread safe:
+ */
+template <class _Tp>
+struct StackAllocator
+#if defined (STLPORT) && \
+ defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ //Special Borland workaround that have problem with function
+ //overloading when one of the overloaded version is a template
+ //one. This is the case for the std::swap function.
+ : public __STD __stlport_class<StackAllocator<_Tp> >
+#endif
+{
+ typedef _Tp value_type;
+ typedef value_type * pointer;
+ typedef const _Tp* const_pointer;
+ typedef _Tp& reference;
+ typedef const _Tp& const_reference;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+
+#if defined (__DMC__)
+ StackAllocator(){}
+#endif
+
+ StackAllocator(char *beg, char *end)
+ : m_state(beg, end) {}
+
+ const State& getState() const { return m_state; }
+#if !defined (STLPORT) || defined (_STLP_MEMBER_TEMPLATES)
+ template <class _OtherTp>
+ StackAllocator(StackAllocator<_OtherTp> const& other)
+ : m_state(other.getState()) {}
+#else
+ StackAllocator(const State& state)
+ : m_state(state) {}
+#endif
+
+#if !defined (STLPORT) || defined (_STLP_MEMBER_TEMPLATE_CLASSES)
+ template <class _Other>
+ struct rebind {
+ typedef StackAllocator<_Other> other;
+ };
+#endif
+
+ _Tp* allocate(size_type n, void* = 0) {
+ if (n == 0)
+ return 0;
+
+ ++(*m_state.m_sharedNbAlloc);
+
+ if (*m_state.m_sharedCur + (n * sizeof(_Tp)) < m_state.m_end) {
+ char *ret = *m_state.m_sharedCur;
+ *m_state.m_sharedCur += n * sizeof(_Tp);
+ return reinterpret_cast<_Tp*>(ret);
+ }
+#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ throw __STD bad_alloc();
+# if defined (__DMC__)
+ return 0;
+# endif
+#else
+ return 0;
+#endif
+ }
+
+#if defined (STLPORT) && \
+ defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ //Necessary extension to make StackAllocator a real STLport allocator
+ //implementation:
+ _Tp* _M_allocate(size_type n, size_type &new_n) {
+ new_n = n;
+ return allocate(n);
+ }
+#endif
+
+ void deallocate(pointer p, size_type n) {
+ if (p == 0)
+ return;
+
+ --(*m_state.m_sharedNbAlloc);
+
+ if ((char*)p == (*m_state.m_sharedCur - n * sizeof(_Tp))) {
+ *m_state.m_sharedCur -= n * sizeof(_Tp);
+ }
+
+ if ((char*)p < m_state.m_beg || (char*)p >= m_state.m_end) {
+ //An object has been returned to the bad allocator instance:
+ *m_state.m_sharedOk = false;
+ }
+ }
+
+ pointer address(reference __x) const {return &__x;}
+ const_pointer address(const_reference __x) const { return &__x; }
+ size_type max_size() const { return m_state.m_end - *m_state.m_sharedCur; }
+ void construct(pointer __p, const_reference __val) { new(__p) _Tp(__val); }
+ void destroy(pointer __p) { __p->~_Tp(); }
+
+ bool ok() const { return m_state.m_isOk && (m_state.m_nbAlloc == 0); }
+ void reset () {
+ m_state.m_cur = m_state.m_beg;
+ m_state.m_isOk = true;
+ m_state.m_swaped = false;
+ }
+ bool swaped() const { return m_state.m_swaped; }
+ void swap(StackAllocator &other) {
+ __STD swap(m_state, other.m_state);
+ m_state.m_swaped = true;
+ other.m_state.m_swaped = true;
+ }
+#if defined (STLPORT) && \
+ defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ void _M_swap_workaround(StackAllocator& __x) { swap(__x); }
+#endif
+
+ //2 StackAllocator instance are identical if they are built on top
+ //of the same buffer.
+ bool operator == (StackAllocator const& other) const
+ { return m_state.m_beg == other.m_state.m_beg; }
+
+ bool operator != (StackAllocator const& other) const
+ { return !(*this == other); }
+
+private:
+ State m_state;
+};
+
+#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+namespace std {
+#endif
+
+# if defined (STLPORT) && (defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE) || !defined (_STLP_MEMBER_TEMPLATES))
+template <class _Tp1, class _Tp2>
+inline StackAllocator<_Tp2>&
+__stl_alloc_rebind(StackAllocator<_Tp1>& __a, const _Tp2*) { return (StackAllocator<_Tp2>&)(__a); }
+template <class _Tp1, class _Tp2>
+inline StackAllocator<_Tp2>
+__stl_alloc_create(const StackAllocator<_Tp1>& __a, const _Tp2*) { return StackAllocator<_Tp2>(__a.getState()); }
+# endif
+
+# if !defined (STLPORT) || defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ template <class _Tp>
+ inline void swap(StackAllocator<_Tp>& __a, StackAllocator<_Tp>& __b)
+ { __a.swap(__b); }
+# elif !defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+//The following overloads depends on instanciation, if new unit tests are written
+//with new StackAllocator instanciations associated swap overload should also be
+//written
+inline void swap(StackAllocator<int>& __a, StackAllocator<int>& __b)
+{ __a.swap(__b); }
+inline void swap(StackAllocator<char>& __a, StackAllocator<char>& __b)
+{ __a.swap(__b); }
+inline void swap(StackAllocator<pair<const int, int> >& __a,
+ StackAllocator<pair<const int, int> >& __b)
+{ __a.swap(__b); }
+# endif
+
+#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+}
+#endif
+
+#undef __STD
+
+#endif //STLPORT_UNIT_TEST_STACK_ALLOCATOR_H
diff --git a/sources/android/stlport/test/unit/stack_header_test.cpp b/sources/android/stlport/test/unit/stack_header_test.cpp
new file mode 100644
index 0000000..39946ea
--- /dev/null
+++ b/sources/android/stlport/test/unit/stack_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <stack>
diff --git a/sources/android/stlport/test/unit/stack_test.cpp b/sources/android/stlport/test/unit/stack_test.cpp
new file mode 100644
index 0000000..5ff2aaa
--- /dev/null
+++ b/sources/android/stlport/test/unit/stack_test.cpp
@@ -0,0 +1,60 @@
+#include <algorithm>
+#include <list>
+#include <queue>
+#include <deque>
+#include <stack>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class StackTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(StackTest);
+ CPPUNIT_TEST(stack1);
+ CPPUNIT_TEST(stack2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void stack1();
+ void stack2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(StackTest);
+
+//
+// tests implementation
+//
+void StackTest::stack1()
+{
+ stack<int, deque<int> > s;
+ s.push(42);
+ s.push(101);
+ s.push(69);
+ CPPUNIT_ASSERT(s.top()==69);
+ s.pop();
+ CPPUNIT_ASSERT(s.top()==101);
+ s.pop();
+ CPPUNIT_ASSERT(s.top()==42);
+ s.pop();
+ CPPUNIT_ASSERT(s.empty());
+}
+void StackTest::stack2()
+{
+ stack<int, list<int> > s;
+ s.push(42);
+ s.push(101);
+ s.push(69);
+ CPPUNIT_ASSERT(s.top()==69);
+ s.pop();
+ CPPUNIT_ASSERT(s.top()==101);
+ s.pop();
+ CPPUNIT_ASSERT(s.top()==42);
+ s.pop();
+ CPPUNIT_ASSERT(s.empty());
+}
diff --git a/sources/android/stlport/test/unit/stdarg_header_test.c b/sources/android/stlport/test/unit/stdarg_header_test.c
new file mode 100644
index 0000000..9901cba
--- /dev/null
+++ b/sources/android/stlport/test/unit/stdarg_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <stdarg.h>
diff --git a/sources/android/stlport/test/unit/stddef_header_test.c b/sources/android/stlport/test/unit/stddef_header_test.c
new file mode 100644
index 0000000..eb00372
--- /dev/null
+++ b/sources/android/stlport/test/unit/stddef_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <stddef.h>
diff --git a/sources/android/stlport/test/unit/stdexcept_header_test.cpp b/sources/android/stlport/test/unit/stdexcept_header_test.cpp
new file mode 100644
index 0000000..d8114e6
--- /dev/null
+++ b/sources/android/stlport/test/unit/stdexcept_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <stdexcept>
diff --git a/sources/android/stlport/test/unit/stdio_header_test.c b/sources/android/stlport/test/unit/stdio_header_test.c
new file mode 100644
index 0000000..d8f42c1
--- /dev/null
+++ b/sources/android/stlport/test/unit/stdio_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <stdio.h>
diff --git a/sources/android/stlport/test/unit/stdlib_header_test.c b/sources/android/stlport/test/unit/stdlib_header_test.c
new file mode 100644
index 0000000..a43f906
--- /dev/null
+++ b/sources/android/stlport/test/unit/stdlib_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <stdlib.h>
diff --git a/sources/android/stlport/test/unit/stldbg_include.cpp b/sources/android/stlport/test/unit/stldbg_include.cpp
new file mode 100644
index 0000000..ab2c9a8
--- /dev/null
+++ b/sources/android/stlport/test/unit/stldbg_include.cpp
@@ -0,0 +1,40 @@
+/*
+ * This is compile-time test for situation below not happen.
+ * STLport use many defines and auxilary structures, namespaces and templates
+ * that included via _prolog.h. After preprocessor phase we may see:
+ *
+ * extern "C" {
+ *
+ * namespace std { }
+ *
+ *
+ * This is bad, but acceptable. But in STLPORT_DEBUG mode we can see
+ *
+ * extern "C" {
+ *
+ * namespace std {
+ * namespace private {
+ *
+ * template <class _Dummy>
+ * class __stl_debug_engine {
+ *
+ *
+ * This lead to compile-time error.
+ * [This due to sys/types.h contains
+ *
+ * __BEGIN_DECLS
+ * #include <bits/types.h>
+ *
+ *
+ * i.e. include other headers within extern "C" { scope. Bad, but this is fact.]
+ *
+ * Origin of problem: STLport provide proxy-headers as for C++ headers, as for C
+ * headers. For C headers, we shouldn't expose C++ constructions, because system
+ * headers may include each other by unexpected way (from STLport point of view).
+ *
+ * - ptr, 2007-04-05
+ */
+
+#ifdef __unix
+# include <sys/types.h>
+#endif
diff --git a/sources/android/stlport/test/unit/streambuf_header_test.cpp b/sources/android/stlport/test/unit/streambuf_header_test.cpp
new file mode 100644
index 0000000..935f909
--- /dev/null
+++ b/sources/android/stlport/test/unit/streambuf_header_test.cpp
@@ -0,0 +1,10 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#if !defined (_STLP_NO_IOSTREAMS)
+# include <streambuf>
+#endif
diff --git a/sources/android/stlport/test/unit/string_header_test.c b/sources/android/stlport/test/unit/string_header_test.c
new file mode 100644
index 0000000..a242eeb
--- /dev/null
+++ b/sources/android/stlport/test/unit/string_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <string.h>
diff --git a/sources/android/stlport/test/unit/string_header_test.cpp b/sources/android/stlport/test/unit/string_header_test.cpp
new file mode 100644
index 0000000..4f36b27
--- /dev/null
+++ b/sources/android/stlport/test/unit/string_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <string>
diff --git a/sources/android/stlport/test/unit/string_test.cpp b/sources/android/stlport/test/unit/string_test.cpp
new file mode 100644
index 0000000..987d68e
--- /dev/null
+++ b/sources/android/stlport/test/unit/string_test.cpp
@@ -0,0 +1,1427 @@
+//To make GLib C++ closer to STLport behavior we need this macro:
+//Only mandatory when building unit tests without STLport, do not change
+//anything when building with STLport
+#define _GLIBCXX_FULLY_DYNAMIC_STRING
+
+//Has to be first for StackAllocator swap overload to be taken
+//into account (at least using GCC 4.0.1)
+#include "stack_allocator.h"
+
+#include <vector>
+#include <deque>
+#include <string>
+#include <algorithm>
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# include <sstream>
+#endif
+
+#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+# include <stdexcept>
+#endif
+
+#if !defined (STLPORT) || defined (_STLP_THREADS)
+# if defined (STLPORT) && defined (_STLP_PTHREADS) || \
+ defined (__GNUC__) && !defined (__MINGW32__)
+# define USE_PTHREAD_API
+# include <pthread.h>
+# endif
+
+# if defined (STLPORT) && defined (_STLP_WIN32THREADS) || \
+ defined (__GNUC__) && defined (__MINGW32__) || \
+ defined (_MSC_VER)
+# define USE_WINDOWS_API
+# include <windows.h>
+# endif
+#endif
+
+#include "stack_allocator.h"
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class StringTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(StringTest);
+ CPPUNIT_TEST(constructor);
+ CPPUNIT_TEST(trivial_char_compare);
+ CPPUNIT_TEST(reserve);
+ CPPUNIT_TEST(assign);
+ CPPUNIT_TEST(erase);
+ CPPUNIT_TEST(data);
+ CPPUNIT_TEST(c_str);
+ CPPUNIT_TEST(null_char);
+ CPPUNIT_TEST(insert);
+ CPPUNIT_TEST(replace);
+ CPPUNIT_TEST(resize);
+ CPPUNIT_TEST(short_string);
+ CPPUNIT_TEST(find);
+ CPPUNIT_TEST(bogus_edge_find);
+ CPPUNIT_TEST(rfind);
+ CPPUNIT_TEST(find_last_of);
+ CPPUNIT_TEST(find_last_not_of);
+ CPPUNIT_TEST(copy);
+#if !defined (USE_PTHREAD_API) && !defined (USE_WINDOWS_API)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(mt);
+ CPPUNIT_STOP_IGNORE;
+ CPPUNIT_TEST(short_string_optim_bug);
+ CPPUNIT_TEST(compare);
+ CPPUNIT_TEST(template_expression);
+#if defined (STLPORT) && ((defined (_STLP_MSVC) && (_STLP_MSVC < 1300)) || \
+ (defined(__GNUC__) && defined(_STLP_USE_TEMPLATE_EXPRESSION) && \
+ ((__GNUC__ < 4) || (__GNUC__ == 4 && __GNUC_MINOR__ < 1)) ) )
+# define TE_TMP_TEST_IGNORED
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(te_tmp);
+#if defined (TE_TMP_TEST_IGNORED)
+ CPPUNIT_STOP_IGNORE;
+#endif
+ CPPUNIT_TEST(oper_tmp);
+#if defined (STLPORT) && defined (_STLP_NO_WCHAR_T)
+ CPPUNIT_IGNORE;
+#endif
+#if defined (__CYGWIN__) && !defined (STLPORT)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(template_wexpression);
+ CPPUNIT_STOP_IGNORE;
+#if defined (STLPORT) && defined (_STLP_USE_NO_IOSTREAMS)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(io);
+ CPPUNIT_STOP_IGNORE;
+#if defined (STLPORT) && defined (_STLP_NO_CUSTOM_IO)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(allocator_with_state);
+ CPPUNIT_STOP_IGNORE;
+ CPPUNIT_TEST(capacity);
+ CPPUNIT_TEST(concat24);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void constructor();
+ void trivial_char_compare();
+ void reserve();
+ void erase();
+ void data();
+ void c_str();
+ void null_char();
+ void insert();
+ void replace();
+ void resize();
+ void short_string();
+ void find();
+ void bogus_edge_find();
+ void rfind();
+ void find_last_of();
+ void find_last_not_of();
+ void copy();
+ void assign();
+ void mt();
+ void short_string_optim_bug();
+ void compare();
+ void template_expression();
+ void te_tmp();
+ void oper_tmp();
+ void template_wexpression();
+ void io();
+ void allocator_with_state();
+ void capacity();
+ void concat24();
+
+ static string func(const string& par) {
+ string tmp( par );
+ return tmp;
+ }
+
+#if defined (USE_PTHREAD_API) || defined (USE_WINDOWS_API)
+# if defined (USE_PTHREAD_API)
+ static void* f(void*)
+# else
+ static DWORD __stdcall f(void*)
+# endif
+ {
+ string s( "qyweyuewunfkHBUKGYUGL,wehbYGUW^(@T@H!BALWD:h^&@#*@(#:JKHWJ:CND" );
+
+ for ( int i = 0; i < 2000000; ++i ) {
+ string sx = func( s );
+ }
+
+ return 0;
+ }
+#endif
+
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(StringTest);
+
+//
+// tests implementation
+//
+void StringTest::constructor()
+{
+#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ try {
+ string s((size_t)-1, 'a');
+ CPPUNIT_FAIL;
+ }
+ catch (length_error const&) {
+ }
+ catch (...) {
+ //Expected exception is length_error:
+ CPPUNIT_FAIL;
+ }
+#endif
+}
+
+void StringTest::trivial_char_compare()
+{
+ string s( "message" );
+
+ CPPUNIT_CHECK( s == "message" );
+ CPPUNIT_CHECK( "message" == s );
+}
+
+void StringTest::reserve()
+{
+ string s;
+#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ try {
+ s.reserve(s.max_size() + 1);
+ CPPUNIT_FAIL;
+ }
+ catch (length_error const&) {
+ }
+ catch (...) {
+ //Expected exception is length_error:
+ CPPUNIT_FAIL;
+ }
+#endif
+}
+
+void StringTest::mt()
+{
+#if defined (USE_PTHREAD_API) || defined (USE_WINDOWS_API)
+ const int nth = 2;
+# if defined (USE_PTHREAD_API)
+ pthread_t t[nth];
+
+ for ( int i = 0; i < nth; ++i ) {
+ pthread_create( &t[i], 0, f, 0 );
+ }
+
+ for ( int i = 0; i < nth; ++i ) {
+ pthread_join( t[i], 0 );
+ }
+# endif // PTHREAD
+
+# if defined (USE_WINDOWS_API)
+ //DWORD start = GetTickCount();
+
+ HANDLE t[nth];
+
+ int i; // VC6 not support in-loop scope of cycle var
+ for ( i = 0; i < nth; ++i ) {
+ t[i] = CreateThread(NULL, 0, f, 0, 0, NULL);
+ }
+
+ if (WaitForMultipleObjects(nth, t, TRUE, INFINITE) == WAIT_FAILED) {
+ // On some platforms (evc3/evc4) WaitForMultipleObjects() with fWaitAll == TRUE
+ // is not supported. We then wait with a loop on each thread:
+ for ( i = 0; i < nth; ++i ) {
+ WaitForSingleObject(t[i], INFINITE);
+ }
+ }
+
+ /*
+ DWORD duration = GetTickCount() - start;
+ ostringstream ostr;
+ ostr << "Duration: " << duration << endl;
+ CPPUNIT_MESSAGE(ostr.str().c_str());
+ */
+# endif
+#endif
+}
+
+void StringTest::short_string()
+{
+ string const ref_short_str1("str1"), ref_short_str2("str2");
+ string short_str1(ref_short_str1), short_str2(ref_short_str2);
+ string const ref_long_str1("str 1");
+ string const ref_long_str2("str 2");
+ string long_str1(ref_long_str1), long_str2(ref_long_str2);
+
+ CPPUNIT_ASSERT(short_str1 == ref_short_str1);
+ CPPUNIT_ASSERT(long_str1 == ref_long_str1);
+
+ {
+ string str1(short_str1);
+ str1 = long_str1;
+ CPPUNIT_ASSERT(str1 == ref_long_str1);
+ }
+
+ {
+ string str1(long_str1);
+ str1 = short_str1;
+ CPPUNIT_ASSERT(str1 == ref_short_str1);
+ }
+
+ {
+ short_str1.swap(short_str2);
+ CPPUNIT_ASSERT((short_str1 == ref_short_str2) && (short_str2 == ref_short_str1));
+ short_str1.swap(short_str2);
+ }
+
+ {
+ long_str1.swap(long_str2);
+ CPPUNIT_ASSERT((long_str1 == ref_long_str2) && (long_str2 == ref_long_str1));
+ long_str1.swap(long_str2);
+ }
+
+ {
+ short_str1.swap(long_str1);
+ CPPUNIT_ASSERT((short_str1 == ref_long_str1) && (long_str1 == ref_short_str1));
+ short_str1.swap(long_str1);
+ }
+
+ {
+ long_str1.swap(short_str1);
+ CPPUNIT_ASSERT((short_str1 == ref_long_str1) && (long_str1 == ref_short_str1));
+ long_str1.swap(short_str1);
+ }
+
+ {
+ string a(256, 'a');
+ string b(256, 'b');
+ const char* as = a.c_str();
+ const char* bs = b.c_str();
+ swap(a, b);
+ CPPUNIT_ASSERT( a.c_str() == bs );
+ CPPUNIT_ASSERT( b.c_str() == as );
+ }
+
+ {
+ //This is to test move constructor
+ vector<string> str_vect;
+ str_vect.push_back(short_str1);
+ str_vect.push_back(long_str1);
+ str_vect.push_back(short_str2);
+ str_vect.push_back(long_str2);
+ CPPUNIT_ASSERT((str_vect[0] == ref_short_str1) &&
+ (str_vect[1] == ref_long_str1) &&
+ (str_vect[2] == ref_short_str2) &&
+ (str_vect[3] == ref_long_str2));
+ }
+}
+
+void StringTest::erase()
+{
+ char const* c_str = "Hello, World!";
+ string str(c_str);
+ CPPUNIT_ASSERT( str == c_str );
+
+ str.erase(str.begin() + 1, str.end() - 1); // Erase all but first and last.
+
+ size_t i;
+ for (i = 0; i < str.size(); ++i) {
+ switch ( i ) {
+ case 0:
+ CPPUNIT_ASSERT( str[i] == 'H' );
+ break;
+ case 1:
+ CPPUNIT_ASSERT( str[i] == '!' );
+ break;
+ default:
+ CPPUNIT_FAIL;
+ }
+ }
+
+ str.insert(1, c_str);
+ str.erase(str.begin()); // Erase first element.
+ str.erase(str.end() - 1); // Erase last element.
+ CPPUNIT_ASSERT( str == c_str );
+ str.clear(); // Erase all.
+ CPPUNIT_ASSERT( str.empty() );
+
+ str = c_str;
+ CPPUNIT_ASSERT( str == c_str );
+
+ str.erase(1, str.size() - 1); // Erase all but first and last.
+ for (i = 0; i < str.size(); i++) {
+ switch ( i ) {
+ case 0:
+ CPPUNIT_ASSERT( str[i] == 'H' );
+ break;
+ case 1:
+ CPPUNIT_ASSERT( str[i] == '!' );
+ break;
+ default:
+ CPPUNIT_FAIL;
+ }
+ }
+
+ str.erase(1);
+ CPPUNIT_ASSERT( str == "H" );
+}
+
+void StringTest::data()
+{
+ string xx;
+
+ CPPUNIT_ASSERT( xx.data() != 0 ); // ISO-IEC-14882:1998(E), 21.3.6, paragraph 3
+#if 0
+ /* This test really not required: in ISO-IEC-14882:1998(E) paragraph 3 stated:
+ * '... and can have zero added to it', again: 'CAN', but not 'MUST'.
+ * That's why I am comment this test. But I don't remove it due to I had
+ * unevident problem with misinterpretation of data() return (i.e. data()
+ * and c_str() provide different functionality!) and expect that this is
+ * more-or-less common pitfall.
+ * - ptr
+ */
+ string low( "2004-01-01" );
+ // Blocks A and B should follow each other.
+ // Block A:
+ xx = "123456";
+ xx += low;
+ if ( strcmp( xx.data(), "1234562004-01-01" ) != 0 ) {
+ return -1;
+ }
+ // End of block A
+
+ // Block B:
+ xx = "1234";
+ xx += ";";
+
+ if ( strcmp( xx.data(), "1234;" ) != 0 ) {
+ return -1;
+ }
+ // End of block B
+#endif
+}
+
+void StringTest::c_str()
+{
+ string low( "2004-01-01" );
+ string xx;
+ string yy;
+
+ CPPUNIT_ASSERT( *(yy.c_str()) == '\0' ); // ISO-IEC-14882:1998(E), 21.3.6, paragraph 1
+
+ // Blocks A and B should follow each other.
+ // Block A:
+ xx = "123456";
+ xx += low;
+ CPPUNIT_ASSERT( strcmp( xx.c_str(), "1234562004-01-01" ) == 0 );
+ // End of block A
+
+ // Block B:
+ xx = "1234";
+ xx += ";";
+ CPPUNIT_ASSERT( strcmp( xx.c_str(), "1234;" ) == 0 );
+ // End of block B
+}
+
+void StringTest::null_char()
+{
+ // ISO/IEC 14882:1998(E), ISO/IEC 14882:2003(E), 21.3.4 ('... the const version')
+ const string s( "123456" );
+
+ CPPUNIT_CHECK( s[s.size()] == '\0' );
+
+#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ try {
+ //Check is only here to avoid warning about value of expression not used
+ CPPUNIT_CHECK( s.at(s.size()) == '\0' );
+ CPPUNIT_FAIL;
+ }
+ catch (out_of_range const&) {
+ CPPUNIT_ASSERT( true );
+ }
+ catch ( ... ) {
+ CPPUNIT_FAIL;
+ }
+#endif
+}
+
+void StringTest::insert()
+{
+ string strorg = "This is test string for string calls";
+ string str;
+ /*
+ * In case of reallocation there is no auto reference problem
+ * so we reserve a big enough string to be sure to test this
+ * particular point.
+ */
+ str.reserve(100);
+ str = strorg;
+
+ //test self insertion:
+ str.insert(10, str.c_str() + 5, 15);
+ CPPUNIT_ASSERT( str == "This is teis test string st string for string calls" );
+
+ str = strorg;
+ str.insert(15, str.c_str() + 5, 25);
+ CPPUNIT_ASSERT( str == "This is test stis test string for stringring for string calls" );
+
+ str = strorg;
+ str.insert(0, str.c_str() + str.size() - 4, 4);
+ CPPUNIT_ASSERT( str == "allsThis is test string for string calls" );
+
+ str = strorg;
+ str.insert(0, str.c_str() + str.size() / 2 - 1, str.size() / 2 + 1);
+ CPPUNIT_ASSERT( str == "ng for string callsThis is test string for string calls" );
+
+ str = strorg;
+ string::iterator b = str.begin();
+ string::const_iterator s = str.begin() + str.size() / 2 - 1;
+ string::const_iterator e = str.end();
+ str.insert( b, s, e );
+ CPPUNIT_ASSERT( str == "ng for string callsThis is test string for string calls" );
+
+ str = strorg;
+ str.insert(str.begin(), str.begin() + str.size() / 2 - 1, str.end());
+ CPPUNIT_ASSERT( str == "ng for string callsThis is test string for string calls" );
+
+#ifdef _STLP_MEMBER_TEMPLATES
+ vector<int> int_vect;
+ //Just a compile time test:
+ str.insert(str.end(), int_vect.begin(), int_vect.end());
+#endif
+
+ string str0;
+ str0.insert(str0.begin(), 5, '0');
+ CPPUNIT_ASSERT( str0 == "00000" );
+
+ string str1;
+ {
+ string::size_type pos = 0, nb = 2;
+ str1.insert(pos, nb, '1');
+ }
+ CPPUNIT_ASSERT( str1 == "11" );
+
+ str0.insert(0, str1);
+ CPPUNIT_ASSERT( str0 == "1100000" );
+
+ string str2("2345");
+ str0.insert(str0.size(), str2, 1, 2);
+ CPPUNIT_ASSERT( str0 == "110000034" );
+
+ str1.insert(str1.begin() + 1, 2, '2');
+ CPPUNIT_ASSERT( str1 == "1221" );
+
+ str1.insert(2, "333333", 3);
+ CPPUNIT_ASSERT( str1 == "1233321" );
+
+ str1.insert(4, "4444");
+ CPPUNIT_ASSERT( str1 == "12334444321" );
+
+ str1.insert(str1.begin() + 6, '5');
+ CPPUNIT_ASSERT( str1 == "123344544321" );
+}
+
+void StringTest::replace()
+{
+ /*
+ * This test case is for the non template basic_string::replace method,
+ * this is why we play with the const iterators and reference to guaranty
+ * that the right method is called.
+ */
+ const string v( "78" );
+ string s( "123456" );
+ string const& cs = s;
+
+ string::iterator i = s.begin() + 1;
+ s.replace(i, i + 3, v.begin(), v.end());
+ CPPUNIT_ASSERT( s == "17856" );
+
+ s = "123456";
+ i = s.begin() + 1;
+ s.replace(i, i + 1, v.begin(), v.end());
+ CPPUNIT_ASSERT( s == "1783456" );
+
+ s = "123456";
+ i = s.begin() + 1;
+ string::const_iterator ci = s.begin() + 1;
+ s.replace(i, i + 3, ci + 3, cs.end());
+ CPPUNIT_ASSERT( s == "15656" );
+
+ s = "123456";
+ i = s.begin() + 1;
+ ci = s.begin() + 1;
+ s.replace(i, i + 3, ci, ci + 2);
+ CPPUNIT_ASSERT( s == "12356" );
+
+ s = "123456";
+ i = s.begin() + 1;
+ ci = s.begin() + 1;
+ s.replace(i, i + 3, ci + 1, cs.end());
+ CPPUNIT_ASSERT( s == "1345656" );
+
+ s = "123456";
+ i = s.begin();
+ ci = s.begin() + 1;
+ s.replace(i, i, ci, ci + 1);
+ CPPUNIT_CHECK( s == "2123456" );
+
+ s = "123456";
+ s.replace(s.begin() + 4, s.end(), cs.begin(), cs.end());
+ CPPUNIT_ASSERT( s == "1234123456" );
+
+ /*
+ * This is the test for the template replace method.
+ */
+ s = "123456";
+ string::iterator b = s.begin() + 4;
+ string::iterator e = s.end();
+ string::const_iterator rb = s.begin();
+ string::const_iterator re = s.end();
+ s.replace(b, e, rb, re);
+ CPPUNIT_ASSERT( s == "1234123456" );
+
+ s = "123456";
+ s.replace(s.begin() + 4, s.end(), s.begin(), s.end());
+ CPPUNIT_ASSERT( s == "1234123456" );
+
+ string strorg("This is test string for string calls");
+ string str = strorg;
+ str.replace(5, 15, str.c_str(), 10);
+ CPPUNIT_ASSERT( str == "This This is tefor string calls" );
+
+ str = strorg;
+ str.replace(5, 5, str.c_str(), 10);
+ CPPUNIT_ASSERT( str == "This This is test string for string calls" );
+
+#if (defined (STLPORT) && defined(_STLP_MEMBER_TEMPLATES)) || ( !defined (STLPORT) && !defined(__GNUC__) )
+ deque<char> cdeque;
+ cdeque.push_back('I');
+ str.replace(str.begin(), str.begin() + 11, cdeque.begin(), cdeque.end());
+ CPPUNIT_ASSERT( str == "Is test string for string calls" );
+#endif
+}
+
+void StringTest::resize()
+{
+ string s;
+
+ s.resize(0);
+
+ CPPUNIT_ASSERT( *s.c_str() == 0 );
+
+ s = "1234567";
+
+ s.resize(0);
+ CPPUNIT_ASSERT( *s.c_str() == 0 );
+
+ s = "1234567";
+ s.resize(1);
+ CPPUNIT_ASSERT( s.size() == 1 );
+ CPPUNIT_ASSERT( *s.c_str() == '1' );
+ CPPUNIT_ASSERT( *(s.c_str() + 1) == 0 );
+
+ s = "1234567";
+ s.resize(10);
+ CPPUNIT_ASSERT( s.size() == 10 );
+ CPPUNIT_ASSERT( s[6] == '7' );
+ CPPUNIT_ASSERT( s[7] == 0 );
+ CPPUNIT_ASSERT( s[8] == 0 );
+ CPPUNIT_ASSERT( s[9] == 0 );
+}
+
+void StringTest::find()
+{
+ string s("one two three one two three");
+ CPPUNIT_ASSERT( s.find("one") == 0 );
+ CPPUNIT_ASSERT( s.find('t') == 4 );
+ CPPUNIT_ASSERT( s.find('t', 5) == 8 );
+ //We are trying to get a const reference to the npos string static member to
+ //force the compiler to allocate memory for this variable. It is used to reveal
+ //a bug of STLport which was simply declaring npos without instanciating it.
+#if defined (STLPORT) && defined (_STLP_STATIC_CONST_INIT_BUG)
+ string::size_type const& npos_local = string::npos;
+#else
+# define npos_local string::npos
+#endif
+ CPPUNIT_ASSERT( s.find("four") == npos_local );
+ CPPUNIT_ASSERT( s.find("one", string::npos) == npos_local );
+
+ CPPUNIT_ASSERT( s.find_first_of("abcde") == 2 );
+
+ CPPUNIT_ASSERT( s.find_first_not_of("enotw ") == 9 );
+
+ string empty;
+ CPPUNIT_ASSERT( s.substr(s.find(empty), empty.size()) == empty );
+}
+
+void StringTest::bogus_edge_find()
+{
+ /* ISO/IEC 14882 2003, 21.3.6.1 basic_string::find [lib.string::find]
+ *
+ * size_type find(const basic_string<charT,traits,Allocator>& str,
+ * size_type pos = 0) const;
+ * Effects: Determines the lowest position xpos, if possible, such that
+ * both of the following conditions obtain:
+ * pos <= xpos and xpos + str.size() <= size();
+ * at(xpos+I) == str.at(I) for all elements I of the string controlled by str.
+ * Returns: xpos if the function can determine such a value for xpos. Otherwise,
+ * returns npos.
+ * Notes: Uses traits::eq().
+ *
+ * ===
+ * So, from formal point of view
+ * string s; string::size_type p = s.find( "", 0, 0 );
+ * should return 0 in p, i.e. position out-of-bound of string, so
+ * code like following is bad:
+ * string s;
+ *
+ * string::size_type p = s.find( "", 0, 0 );
+ *
+ * ...
+ *
+ * if ( p != string::npos ) { // normal
+ * char ch = s[p]; // Arghhhhhhhhhh
+ * }
+ *
+ * People near Standard commete has opinion opposite to my. Even if it looks
+ * like bogus behaviour for me, it should be fixed.
+ */
+
+ {
+ string s;
+ string::size_type p = s.find( "", 0, 0 );
+
+ /* CPPUNIT_CHECK( p == string::npos ); */
+ CPPUNIT_CHECK( p == 0 ); // bogus result, isn't it?
+ }
+ {
+ string s( "123" );
+ string::size_type p = s.find( "", 0, 0 );
+
+ CPPUNIT_CHECK( p == 0 );
+ }
+ {
+ string s( "123" );
+ string::size_type p = s.find( "", 1, 0 );
+
+ CPPUNIT_CHECK( p == 1 );
+ }
+ {
+ string s( "" );
+ string::size_type p = s.find( "", 1, 0 );
+
+ CPPUNIT_CHECK( p == string::npos );
+ }
+ {
+ string s( "123" );
+ string::size_type p = s.find( "", 3, 0 );
+
+ CPPUNIT_CHECK( p == 3 ); // bogus result, isn't it?
+ }
+ {
+ string s;
+ string::size_type p = s.rfind( "", 0, 0 );
+
+ /* CPPUNIT_CHECK( p == string::npos ); */
+ CPPUNIT_CHECK( p == 0 ); // bogus result, isn't it?
+ }
+ {
+ string s( "123" );
+ string::size_type p = s.rfind( "", 0, 0 );
+
+ CPPUNIT_CHECK( p == 0 );
+ }
+ {
+ string s( "123" );
+ string::size_type p = s.rfind( "", 1, 0 );
+
+ CPPUNIT_CHECK( p == 1 );
+ }
+ {
+ string s( "" );
+ string::size_type p = s.rfind( "", 1, 0 );
+
+ CPPUNIT_CHECK( p == 0 ); // bogus result, isn't it?
+ }
+ {
+ string s( "123" );
+ string::size_type p = s.rfind( "", 3, 0 );
+
+ CPPUNIT_CHECK( p == 3 ); // bogus result, isn't it?
+ }
+}
+
+void StringTest::rfind()
+{
+ // 21.3.6.2
+ string s("one two three one two three");
+
+ CPPUNIT_ASSERT( s.rfind("two") == 18 );
+ CPPUNIT_ASSERT( s.rfind("two", 0) == string::npos );
+ CPPUNIT_ASSERT( s.rfind("two", 11) == 4 );
+ CPPUNIT_ASSERT( s.rfind('w') == 19 );
+
+ string test( "aba" );
+
+ CPPUNIT_CHECK( test.rfind( "a", 2, 1 ) == 2 );
+ CPPUNIT_CHECK( test.rfind( "a", 1, 1 ) == 0 );
+ CPPUNIT_CHECK( test.rfind( "a", 0, 1 ) == 0 );
+
+ CPPUNIT_CHECK( test.rfind( 'a', 2 ) == 2 );
+ CPPUNIT_CHECK( test.rfind( 'a', 1 ) == 0 );
+ CPPUNIT_CHECK( test.rfind( 'a', 0 ) == 0 );
+}
+
+void StringTest::find_last_of()
+{
+ // 21.3.6.4
+ string s("one two three one two three");
+
+ CPPUNIT_ASSERT( s.find_last_of("abcde") == 26 );
+
+ string test( "aba" );
+
+ CPPUNIT_CHECK( test.find_last_of( "a", 2, 1 ) == 2 );
+ CPPUNIT_CHECK( test.find_last_of( "a", 1, 1 ) == 0 );
+ CPPUNIT_CHECK( test.find_last_of( "a", 0, 1 ) == 0 );
+
+ CPPUNIT_CHECK( test.find_last_of( 'a', 2 ) == 2 );
+ CPPUNIT_CHECK( test.find_last_of( 'a', 1 ) == 0 );
+ CPPUNIT_CHECK( test.find_last_of( 'a', 0 ) == 0 );
+}
+
+void StringTest::find_last_not_of()
+{
+ // 21.3.6.6
+ string s("one two three one two three");
+
+ CPPUNIT_ASSERT( s.find_last_not_of("ehortw ") == 15 );
+
+ string test( "aba" );
+
+ CPPUNIT_CHECK( test.find_last_not_of( "a", 2, 1 ) == 1 );
+ CPPUNIT_CHECK( test.find_last_not_of( "b", 2, 1 ) == 2 );
+ CPPUNIT_CHECK( test.find_last_not_of( "a", 1, 1 ) == 1 );
+ CPPUNIT_CHECK( test.find_last_not_of( "b", 1, 1 ) == 0 );
+ CPPUNIT_CHECK( test.find_last_not_of( "a", 0, 1 ) == string::npos );
+ CPPUNIT_CHECK( test.find_last_not_of( "b", 0, 1 ) == 0 );
+
+ CPPUNIT_CHECK( test.find_last_not_of( 'a', 2 ) == 1 );
+ CPPUNIT_CHECK( test.find_last_not_of( 'b', 2 ) == 2 );
+ CPPUNIT_CHECK( test.find_last_not_of( 'a', 1 ) == 1 );
+ CPPUNIT_CHECK( test.find_last_not_of( 'b', 1 ) == 0 );
+ CPPUNIT_CHECK( test.find_last_not_of( 'a', 0 ) == string::npos );
+ CPPUNIT_CHECK( test.find_last_not_of( 'b', 0 ) == 0 );
+}
+
+void StringTest::copy()
+{
+ string s("foo");
+ char dest[4];
+ dest[0] = dest[1] = dest[2] = dest[3] = 1;
+ s.copy(dest, 4);
+ int pos = 0;
+ CPPUNIT_ASSERT( dest[pos++] == 'f' );
+ CPPUNIT_ASSERT( dest[pos++] == 'o' );
+ CPPUNIT_ASSERT( dest[pos++] == 'o' );
+ CPPUNIT_ASSERT( dest[pos++] == 1 );
+
+ dest[0] = dest[1] = dest[2] = dest[3] = 1;
+ s.copy(dest, 4, 2);
+ pos = 0;
+ CPPUNIT_ASSERT( dest[pos++] == 'o' );
+ CPPUNIT_ASSERT( dest[pos++] == 1 );
+
+#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ try {
+ s.copy(dest, 4, 5);
+ CPPUNIT_FAIL;
+ }
+ catch (out_of_range const&) {
+ }
+ catch ( ... ) {
+ CPPUNIT_FAIL;
+ }
+#endif
+}
+
+void StringTest::assign()
+{
+ string s;
+ char const* cstr = "test string for assign";
+
+ s.assign(cstr, cstr + 22);
+ CPPUNIT_ASSERT( s == "test string for assign" );
+
+ string s2("other test string");
+ s.assign(s2);
+ CPPUNIT_ASSERT( s == s2 );
+
+ static string str1;
+ static string str2;
+
+ // short string optim:
+ str1 = "123456";
+ // longer than short string:
+ str2 = "1234567890123456789012345678901234567890";
+
+ CPPUNIT_ASSERT(str1[5] == '6');
+ CPPUNIT_ASSERT(str2[29] == '0');
+}
+
+/* This test is to check if string properly supports the short string
+ * optimization. It has been found out that eMbedded Visual C++ 3.0 and .NET
+ * compilers for the ARM platform fail to pass structs and classes of certain
+ * size per value. This seems to be a known compiler bug. For other processors
+ * (e.g. x86) the error doesn't occur.
+ * (The ARM compiler creates a temporary object from teststr on the stack, to
+ * pass it to the helper function. It uses the copy constructor for this.
+ * After this the temporary object is copied to another place on the stack.
+ * The result is that the _M_finish pointer then points to the wrong buffer
+ * end and the size of the short string is incorrectly calculated.)
+ */
+void StringTest::short_string_optim_bug()
+{
+ string teststr("shortest");
+
+ bool short_string_optim_bug_helper(string teststr);
+
+ CPPUNIT_ASSERT(true == short_string_optim_bug_helper(teststr));
+}
+
+bool short_string_optim_bug_helper(string teststr)
+{
+ size_t ss = teststr.size();
+ return (ss == 8);
+}
+
+void StringTest::compare()
+{
+ string str1("abcdef");
+ string str2;
+
+ str2 = "abcdef";
+ CPPUNIT_ASSERT( str1.compare(str2) == 0 );
+ str2 = "abcde";
+ CPPUNIT_ASSERT( str1.compare(str2) > 0 );
+ str2 = "abcdefg";
+ CPPUNIT_ASSERT( str1.compare(str2) < 0 );
+
+ CPPUNIT_ASSERT( str1.compare("abcdef") == 0 );
+ CPPUNIT_ASSERT( str1.compare("abcde") > 0 );
+ CPPUNIT_ASSERT( str1.compare("abcdefg") < 0 );
+
+ str2 = "cde";
+ CPPUNIT_ASSERT( str1.compare(2, 3, str2) == 0 );
+ str2 = "cd";
+ CPPUNIT_ASSERT( str1.compare(2, 3, str2) > 0 );
+ str2 = "cdef";
+ CPPUNIT_ASSERT( str1.compare(2, 3, str2) < 0 );
+
+ str2 = "abcdef";
+ CPPUNIT_ASSERT( str1.compare(2, 3, str2, 2, 3) == 0 );
+ CPPUNIT_ASSERT( str1.compare(2, 3, str2, 2, 2) > 0 );
+ CPPUNIT_ASSERT( str1.compare(2, 3, str2, 2, 4) < 0 );
+
+ CPPUNIT_ASSERT( str1.compare(2, 3, "cdefgh", 3) == 0 );
+ CPPUNIT_ASSERT( str1.compare(2, 3, "cdefgh", 2) > 0 );
+ CPPUNIT_ASSERT( str1.compare(2, 3, "cdefgh", 4) < 0 );
+}
+
+/*
+class mystring : public string {
+public:
+ mystring() {}
+ mystring(string const& s) : string(s) {}
+
+ mystring& operator = (string const& s) {
+ string::operator = (s);
+ return *this;
+ };
+};
+*/
+
+void StringTest::template_expression()
+{
+ string one("one"), two("two"), three("three");
+ string space(1, ' ');
+
+ // check availability of [un]equality operators
+ {
+ // string-string
+ one == two;
+ one != two;
+ // string-literal
+ one == "two";
+ one != "two";
+ // literal-string
+ "one" == two;
+ "one" != two;
+ // strsum-string
+ (one + two) == three;
+ (one + two) != three;
+ // string-strsum
+ one == (two + three);
+ one != (two + three);
+ // strsum-literal
+ (one + two) == "three";
+ (one + two) != "three";
+ // literal-strsum
+ "one" == (two + three);
+ "one" != (two + three);
+ // strsum-strsum
+ (one + two) == (two + three);
+ (one + two) != (two + three);
+ }
+
+ {
+ string result(one + ' ' + two + ' ' + three);
+ CPPUNIT_CHECK( result == "one two three" );
+ }
+
+ {
+ string result(one + ' ' + two + ' ' + three, 4);
+ CPPUNIT_CHECK( result == "two three" );
+ }
+
+ {
+ string result(one + ' ' + two + ' ' + three, 4, 3);
+ CPPUNIT_CHECK( result == "two" );
+ }
+
+ //2 members expressions:
+ CPPUNIT_CHECK( (' ' + one) == " one" );
+ CPPUNIT_CHECK( (one + ' ') == "one " );
+ CPPUNIT_CHECK( (one + " two") == "one two" );
+ CPPUNIT_CHECK( ("one " + two) == "one two" );
+ CPPUNIT_CHECK( (one + space) == "one " );
+
+ //3 members expressions:
+ CPPUNIT_CHECK( ((one + space) + "two") == "one two" );
+ CPPUNIT_CHECK( ("one" + (space + two)) == "one two" );
+ CPPUNIT_CHECK( ((one + space) + two) == "one two" );
+ CPPUNIT_CHECK( (one + (space + two)) == "one two" );
+ CPPUNIT_CHECK( ((one + space) + 't') == "one t" );
+ CPPUNIT_CHECK( ('o' + (space + two)) == "o two" );
+
+ //4 members expressions:
+ CPPUNIT_CHECK( ((one + space) + (two + space)) == "one two " );
+
+ //special operators
+ {
+ string result;
+ result = one + space + two;
+ CPPUNIT_CHECK( result == "one two" );
+
+ result += space + three;
+ CPPUNIT_CHECK( result == "one two three" );
+ }
+
+ //special append method
+ {
+ string result;
+ //Use reserve to avoid reallocation and really test auto-referencing problems:
+ result.reserve(64);
+
+ result.append(one + space + two);
+ CPPUNIT_CHECK( result == "one two" );
+
+ result.append(space + result + space + three);
+ CPPUNIT_CHECK( result == "one two one two three" );
+
+ result = "one two";
+ result.append(space + three, 1, 2);
+ CPPUNIT_ASSERT( result == "one twoth" );
+
+ result.append(space + result);
+ CPPUNIT_CHECK( result == "one twoth one twoth" );
+ }
+
+ //special assign method
+ {
+ string result;
+ //Use reserve to avoid reallocation and really test auto-referencing problems:
+ result.reserve(64);
+
+ result.assign(one + space + two + space + three);
+ CPPUNIT_CHECK( result == "one two three" );
+
+ result.assign(one + space + two + space + three, 3, 5);
+ CPPUNIT_CHECK( result == " two " );
+
+ result.assign(one + result + three);
+ CPPUNIT_CHECK( result == "one two three" );
+ }
+
+ {
+ CPPUNIT_CHECK( !(one + ' ' + two).empty() );
+
+ char result = (one + ' ' + two)[3];
+ CPPUNIT_CHECK( result == ' ' );
+
+ result = (one + ' ' + two).at(3);
+ CPPUNIT_CHECK( result == ' ' );
+
+#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ try {
+ result = (one + ' ' + two).at(10);
+ CPPUNIT_FAIL;
+ }
+ catch (out_of_range const&) {
+ CPPUNIT_ASSERT( result == ' ' );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+#endif
+ }
+
+ /*
+ mystring a("ing");
+ //gcc failed to compile following expression when template expressions are activated.
+ //MSVC sees no problem. gcc limitation or MSVC is too cool ??
+ mystring b = "str" + a;
+ */
+}
+
+#if !defined (TE_TMP_TEST_IGNORED)
+class superstring
+{
+ public:
+ superstring() :
+ s("super")
+ {}
+
+ superstring( const string& str ) :
+ s( str )
+ {}
+
+ superstring operator / (const string& str )
+ { return superstring( s + "/" + str ); }
+
+ superstring operator / (const char* str )
+ { return superstring( s + "/" + str ); }
+
+ private:
+ string s;
+};
+#endif
+
+void StringTest::te_tmp()
+{
+#if !defined (TE_TMP_TEST_IGNORED)
+ superstring s;
+ string more( "more" );
+ string less( "less" );
+
+ superstring r = s / (more + less);
+#endif
+}
+
+class mypath
+{
+ public:
+ mypath( const string& s ) :
+ p( s )
+ { }
+
+ const mypath& operator / ( const string& );
+ const string& str() const
+ { return p; }
+
+ private:
+ string p;
+};
+
+const mypath& mypath::operator /( const string& s )
+{
+ p += '/';
+ p += s;
+ return *this;
+}
+
+void StringTest::oper_tmp()
+{
+ string s1( "path1" );
+ string s2( ".ext" );
+
+ string& rs1 = s1;
+ string& rs2 = s2;
+
+ CPPUNIT_CHECK( (mypath( string( "/root" ) ) / (rs1 + rs2)).str() == "/root/path1.ext" );
+}
+
+void StringTest::template_wexpression()
+{
+#if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
+# if !defined (__CYGWIN__) || defined (STLPORT)
+ wstring one(L"one"), two(L"two"), three(L"three");
+ wstring space(L" ");
+
+ {
+ wstring result(one + L' ' + two + L' ' + three);
+ CPPUNIT_CHECK( result == L"one two three" );
+ }
+
+ {
+ wstring result(one + L' ' + two + L' ' + three, 4);
+ CPPUNIT_CHECK( result == L"two three" );
+ }
+
+ {
+ wstring result(one + L' ' + two + L' ' + three, 4, 3);
+ CPPUNIT_CHECK( result == L"two" );
+ }
+
+ //2 members expressions:
+ CPPUNIT_CHECK( (L' ' + one) == L" one" );
+ CPPUNIT_CHECK( (one + L' ') == L"one " );
+ CPPUNIT_CHECK( (one + L" two") == L"one two" );
+ CPPUNIT_CHECK( (L"one " + two) == L"one two" );
+ CPPUNIT_CHECK( (one + space) == L"one " );
+
+ //3 members expressions:
+ CPPUNIT_CHECK( ((one + space) + L"two") == L"one two" );
+ CPPUNIT_CHECK( (L"one" + (space + two)) == L"one two" );
+ CPPUNIT_CHECK( ((one + space) + two) == L"one two" );
+ CPPUNIT_CHECK( (one + (space + two)) == L"one two" );
+ CPPUNIT_CHECK( ((one + space) + L't') == L"one t" );
+ CPPUNIT_CHECK( (L'o' + (space + two)) == L"o two" );
+
+ //4 members expressions:
+ CPPUNIT_CHECK( ((one + space) + (two + space)) == L"one two " );
+
+ //special operators
+ {
+ wstring result;
+ result = one + space + two;
+ CPPUNIT_CHECK( result == L"one two" );
+
+ result += space + three;
+ CPPUNIT_CHECK( result == L"one two three" );
+ }
+
+ //special append method
+ {
+ wstring result;
+ //Use reserve to avoid reallocation and really test auto-referencing problems:
+ result.reserve(64);
+
+ result.append(one + space + two);
+ CPPUNIT_CHECK( result == L"one two" );
+
+ result.append(space + result + space + three);
+ CPPUNIT_CHECK( result == L"one two one two three" );
+
+ result = L"one two";
+ result.append(space + three, 1, 2);
+ CPPUNIT_ASSERT( result == L"one twoth" );
+
+ result.append(space + result);
+ CPPUNIT_CHECK( result == L"one twoth one twoth" );
+ }
+
+ //special assign method
+ {
+ wstring result;
+ //Use reserve to avoid reallocation and really test auto-referencing problems:
+ result.reserve(64);
+
+ result.assign(one + space + two + space + three);
+ CPPUNIT_CHECK( result == L"one two three" );
+
+ result.assign(one + space + two + space + three, 3, 5);
+ CPPUNIT_CHECK( result == L" two " );
+
+ result.assign(one + result + three);
+ CPPUNIT_CHECK( result == L"one two three" );
+ }
+
+ {
+ CPPUNIT_CHECK( !(one + L' ' + two).empty() );
+
+ wchar_t result = (one + L' ' + two)[3];
+ CPPUNIT_CHECK( result == L' ' );
+
+ result = (one + L' ' + two).at(3);
+ CPPUNIT_CHECK( result == L' ' );
+
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ try {
+ result = (one + L' ' + two).at(10);
+ CPPUNIT_FAIL;
+ }
+ catch (out_of_range const&) {
+ CPPUNIT_ASSERT( result == L' ' );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+ }
+# endif
+#endif
+}
+
+void StringTest::io()
+{
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+ string str("STLport");
+ {
+ ostringstream ostr;
+ ostr << str;
+ CPPUNIT_ASSERT( ostr.good() );
+ CPPUNIT_ASSERT( ostr.str() == str );
+ }
+ {
+ istringstream istr(str);
+ string istr_content;
+ istr >> istr_content;
+ CPPUNIT_ASSERT( !istr.fail() && istr.eof() );
+ CPPUNIT_ASSERT( istr_content == str );
+ }
+ {
+ istringstream istr(str);
+ istr.width(3);
+ string istr_content;
+ istr >> istr_content;
+ CPPUNIT_ASSERT( !istr.fail() && !istr.eof() );
+ CPPUNIT_ASSERT( istr_content == "STL" );
+ }
+#endif
+}
+
+void StringTest::allocator_with_state()
+{
+#if !(defined (STLPORT) && defined (_STLP_NO_CUSTOM_IO))
+
+ char buf1[1024];
+ StackAllocator<char> stack1(buf1, buf1 + sizeof(buf1));
+
+ char buf2[1024];
+ StackAllocator<char> stack2(buf2, buf2 + sizeof(buf2));
+
+ typedef basic_string<char, char_traits<char>, StackAllocator<char> > StackString;
+ {
+ StackString str1("string stack1", stack1);
+ StackString str1Cpy(str1);
+
+ StackString str2("string stack2", stack2);
+ StackString str2Cpy(str2);
+
+ str1.swap(str2);
+
+ CPPUNIT_ASSERT( str1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( str2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( str1 == str2Cpy );
+ CPPUNIT_ASSERT( str2 == str1Cpy );
+ CPPUNIT_ASSERT( str1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( str2.get_allocator() == stack1 );
+ }
+ CPPUNIT_ASSERT( stack1.ok() );
+ CPPUNIT_ASSERT( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+ {
+ StackString str1("longer string from stack1 allocator instance for dynamic allocation", stack1);
+ StackString str1Cpy(str1);
+
+ StackString str2("longer string from stack2 allocator instance for dynamic allocation", stack2);
+ StackString str2Cpy(str2);
+
+ str1.swap(str2);
+
+ CPPUNIT_ASSERT( str1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( str2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( str1 == str2Cpy );
+ CPPUNIT_ASSERT( str2 == str1Cpy );
+ CPPUNIT_ASSERT( str1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( str2.get_allocator() == stack1 );
+ }
+ CPPUNIT_ASSERT( stack1.ok() );
+ CPPUNIT_ASSERT( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+
+ {
+ StackString str1("string stack1", stack1);
+ StackString str1Cpy(str1);
+
+ StackString str2("longer string from stack2 allocator instance for dynamic allocation", stack2);
+ StackString str2Cpy(str2);
+
+ str1.swap(str2);
+
+ CPPUNIT_ASSERT( str1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( str2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( str1 == str2Cpy );
+ CPPUNIT_ASSERT( str2 == str1Cpy );
+ CPPUNIT_ASSERT( str1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( str2.get_allocator() == stack1 );
+ }
+ CPPUNIT_ASSERT( stack1.ok() );
+ CPPUNIT_ASSERT( stack2.ok() );
+ stack1.reset(); stack2.reset();
+
+
+ {
+ StackString str1("longer string from stack1 allocator instance for dynamic allocation", stack1);
+ StackString str1Cpy(str1);
+
+ StackString str2("string stack2", stack2);
+ StackString str2Cpy(str2);
+
+ str1.swap(str2);
+
+ CPPUNIT_ASSERT( str1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( str2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( str1 == str2Cpy );
+ CPPUNIT_ASSERT( str2 == str1Cpy );
+ CPPUNIT_ASSERT( str1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( str2.get_allocator() == stack1 );
+ }
+ CPPUNIT_ASSERT( stack1.ok() );
+ CPPUNIT_ASSERT( stack2.ok() );
+ stack1.reset(); stack2.reset();
+#endif
+}
+
+void StringTest::capacity()
+{
+ string s;
+
+ CPPUNIT_CHECK( s.capacity() > 0 );
+ CPPUNIT_CHECK( s.capacity() < s.max_size() );
+ CPPUNIT_CHECK( s.capacity() >= s.size() );
+
+#ifndef _STLP_SHORT_STRING_SZ
+# define _STLP_SHORT_STRING_SZ 16 // see stlport/stl/_string_base.h
+#endif
+
+ for ( int i = 0; i < _STLP_SHORT_STRING_SZ + 2; ++i ) {
+ s += ' ';
+ CPPUNIT_CHECK( s.capacity() > 0 );
+ CPPUNIT_CHECK( s.capacity() < s.max_size() );
+ CPPUNIT_CHECK( s.capacity() >= s.size() );
+ }
+}
+
+void StringTest::concat24()
+{
+ string s = string( "123456789012345678901234" ) + string( "123456789012345678901234" );
+
+ CPPUNIT_CHECK( s.length() == 48 );
+ CPPUNIT_CHECK( s[23] == '4' );
+ CPPUNIT_CHECK( s[24] == '1' );
+ CPPUNIT_CHECK( s[47] == '4' );
+}
diff --git a/sources/android/stlport/test/unit/strstream_buffer_read_test.cpp b/sources/android/stlport/test/unit/strstream_buffer_read_test.cpp
new file mode 100644
index 0000000..978ac0c
--- /dev/null
+++ b/sources/android/stlport/test/unit/strstream_buffer_read_test.cpp
@@ -0,0 +1,35 @@
+/*
+ * Note: Strstreams are really broken in STLport. But strstreams are
+ * obsolete, and even if ones was mentioned in D7.1--D7.4 of
+ * Standard, we have no wish to spent time with repair ones.
+ */
+#if !defined (_STLP_NO_IOSTREAMS)
+# include <strstream>
+
+# include "cppunit/cppunit_proxy.h"
+
+# if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+# endif
+
+class StrstreamBufferTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(StrstreamBufferTest);
+ CPPUNIT_TEST(read_from_buffer);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void read_from_buffer();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(StrstreamBufferTest);
+
+void StrstreamBufferTest::read_from_buffer()
+{
+ char hello[] = "Hello";
+ strstream stream(hello, sizeof(hello), ios_base::in);
+ char cur;
+ stream >> cur;
+ CPPUNIT_ASSERT(cur == 'H');
+}
+#endif
diff --git a/sources/android/stlport/test/unit/strstream_header_test.cpp b/sources/android/stlport/test/unit/strstream_header_test.cpp
new file mode 100644
index 0000000..3d7504a
--- /dev/null
+++ b/sources/android/stlport/test/unit/strstream_header_test.cpp
@@ -0,0 +1,10 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#if !defined (_STLP_NO_IOSTREAMS)
+# include <strstream>
+#endif
diff --git a/sources/android/stlport/test/unit/strstream_test.cpp b/sources/android/stlport/test/unit/strstream_test.cpp
new file mode 100644
index 0000000..195570c
--- /dev/null
+++ b/sources/android/stlport/test/unit/strstream_test.cpp
@@ -0,0 +1,49 @@
+#include <string>
+
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# include <strstream>
+# include <limits>
+
+# include "cppunit/cppunit_proxy.h"
+
+# if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+# endif
+
+//
+// TestCase class
+//
+class StrstreamTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(StrstreamTest);
+ CPPUNIT_TEST(input);
+ CPPUNIT_TEST_SUITE_END();
+
+private:
+ void input();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(StrstreamTest);
+
+//
+// tests implementation
+//
+void StrstreamTest::input()
+{
+# if defined (STLPORT) && defined (_STLP_LONG_LONG)
+ {
+ istrstream is("652208307");
+ _STLP_LONG_LONG rval = 0;
+ is >> rval;
+ CPPUNIT_ASSERT( rval == 652208307 );
+ }
+ {
+ istrstream is("-652208307");
+ _STLP_LONG_LONG rval = 0;
+ is >> rval;
+ CPPUNIT_ASSERT( rval == -652208307 );
+ }
+}
+# endif
+
+#endif
diff --git a/sources/android/stlport/test/unit/swap_test.cpp b/sources/android/stlport/test/unit/swap_test.cpp
new file mode 100644
index 0000000..056cabf
--- /dev/null
+++ b/sources/android/stlport/test/unit/swap_test.cpp
@@ -0,0 +1,165 @@
+#include <vector>
+#include <algorithm>
+#include <vector>
+#include <queue>
+
+#if 0 /* temporary: investigation of problem with swap */
+#include <iostream>
+#include <typeinfo>
+#endif
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class SwapTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(SwapTest);
+ CPPUNIT_TEST(swap1);
+ CPPUNIT_TEST(swprnge1);
+ CPPUNIT_TEST(swap_container_non_spec);
+#if defined (STLPORT) && \
+ !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) && !defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(swap_container_spec);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void swap1();
+ void swprnge1();
+ void swap_container_non_spec();
+ void swap_container_spec();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(SwapTest);
+
+//
+// tests implementation
+//
+void SwapTest::swap1()
+{
+ int a = 42;
+ int b = 19;
+ swap(a, b);
+
+ CPPUNIT_ASSERT(a==19);
+ CPPUNIT_ASSERT(b==42);
+}
+
+void SwapTest::swprnge1()
+{
+ char word1[] = "World";
+ char word2[] = "Hello";
+ swap_ranges((char*)word1, (char*)word1 + ::strlen(word1), (char*)word2);
+ CPPUNIT_ASSERT(!strcmp(word1, "Hello"));
+ CPPUNIT_ASSERT(!strcmp(word2, "World"));
+}
+
+class Obj
+{
+ public:
+ Obj() :
+ v( 0 )
+ { }
+ Obj( const Obj& ) :
+ v( 1 )
+ { }
+
+ Obj& operator =( const Obj& )
+ { v = 2; return *this; }
+
+ int v;
+};
+
+/*
+ * Following two tests check the corectness of specialization of swap():
+ * for containers with container::swap method swap( a, b ) should
+ * use a.swap( b ), but don't try to do this substitution for container
+ * without swap method (in this case swap should be made via explicit members
+ * exchange; this assume usage of temporary object)
+ *
+ */
+void SwapTest::swap_container_non_spec()
+{
+ queue<Obj> v1;
+ queue<Obj> v2;
+
+ v1.push( Obj() );
+ v1.back().v = -1;
+ v1.push( Obj() );
+ v1.back().v = -2;
+
+ v2.push( Obj() );
+ v2.back().v = 10;
+ v2.push( Obj() );
+ v2.back().v = 11;
+ v2.push( Obj() );
+ v2.back().v = 12;
+
+ CPPUNIT_CHECK( v1.size() == 2 );
+ CPPUNIT_CHECK( v2.size() == 3 );
+
+ swap( v1, v2 ); // this shouldn't try make it as v1.swap( v2 ), no queue::swap method!
+
+ CPPUNIT_CHECK( v1.size() == 3 );
+ CPPUNIT_CHECK( v2.size() == 2 );
+
+ // either copy constructor or assignment operator
+ CPPUNIT_CHECK( v1.front().v == 1 || v1.front().v == 2 );
+ CPPUNIT_CHECK( v1.back().v == 1 || v1.back().v == 2 );
+ CPPUNIT_CHECK( v2.front().v == 1 || v2.front().v == 2 );
+ CPPUNIT_CHECK( v2.back().v == 1 || v2.back().v == 2 );
+}
+
+void SwapTest::swap_container_spec()
+{
+#if 0 /* temporary: investigation of problem with swap */
+ if ( typeid(/* _STLP_PRIV */ _SwapImplemented<vector<Obj> >::_Ret) == typeid(_STLP_PRIV __false_type) ) {
+ cerr << "false type" << endl;
+ } else if ( typeid(/* _STLP_PRIV */ _SwapImplemented<vector<Obj> >::_Ret) == typeid(_STLP_PRIV __true_type) ) {
+ cerr << "true type" << endl;
+ } else {
+ cerr << "unknown type" << endl;
+ }
+#endif /* end of temporary */
+#if !defined (STLPORT) || \
+ defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) || defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ vector<Obj> v1;
+ vector<Obj> v2;
+
+ v1.push_back( Obj() );
+ v1.push_back( Obj() );
+
+ v1[0].v = -1;
+ v1[1].v = -2;
+
+ v2.push_back( Obj() );
+ v2.push_back( Obj() );
+ v2.push_back( Obj() );
+
+ v2[0].v = 10;
+ v2[1].v = 11;
+ v2[2].v = 12;
+
+ CPPUNIT_CHECK( v1.size() == 2 );
+ CPPUNIT_CHECK( v2.size() == 3 );
+
+ swap( v1, v2 ); // this should has effect v1.swap( v2 )
+
+ CPPUNIT_CHECK( v1.size() == 3 );
+ CPPUNIT_CHECK( v2.size() == 2 );
+
+ CPPUNIT_CHECK( v1[0].v == 10 );
+ CPPUNIT_CHECK( v1[1].v == 11 );
+ CPPUNIT_CHECK( v1[2].v == 12 );
+
+ CPPUNIT_CHECK( v2[0].v == -1 );
+ CPPUNIT_CHECK( v2[1].v == -2 );
+#endif
+}
diff --git a/sources/android/stlport/test/unit/test_errno.cpp b/sources/android/stlport/test/unit/test_errno.cpp
new file mode 100644
index 0000000..ad77d3a
--- /dev/null
+++ b/sources/android/stlport/test/unit/test_errno.cpp
@@ -0,0 +1,56 @@
+//We are including stdlib.h and stddef.h first because under MSVC
+//those headers contains a errno macro definition without the underlying value
+//definition.
+#include <stdlib.h>
+#include <stddef.h>
+
+#include <errno.h>
+#include <errno.h> // not typo, check errno def/undef/redef
+
+#ifndef _STLP_WCE
+
+#include "cppunit/cppunit_proxy.h"
+
+//
+// TestCase class
+//
+class ErrnoTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(ErrnoTest);
+ CPPUNIT_TEST(check);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void check();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(ErrnoTest);
+
+void ErrnoTest::check()
+{
+ //We are using ERANGE as it is part of the C++ ISO (see Table 26 in section 19.3)
+ //Using ERANGE improve the test as it means that the native errno.h file has really
+ //been included.
+ errno = ERANGE;
+
+ CPPUNIT_ASSERT( errno == ERANGE );
+ errno = 0;
+
+/* Note: in common, you can't write ::errno or std::errno,
+ * due to errno in most cases is just a macro, that frequently
+ * (in MT environment errno is a per-thread value) expand to something like
+ * (*__errno_location()). I don't know way how masquerade such
+ * things: name of macro can't include ::.
+ *
+ * - ptr, 2005-03-30
+ */
+# if 0
+ if ( ::errno != 0 ) {
+ return 1;
+ }
+ if ( std::errno != 0 ) {
+ return 1;
+ }
+# endif
+}
+#endif // _STLP_WCE
diff --git a/sources/android/stlport/test/unit/time_facets_test.cpp b/sources/android/stlport/test/unit/time_facets_test.cpp
new file mode 100644
index 0000000..19a7a3a
--- /dev/null
+++ b/sources/android/stlport/test/unit/time_facets_test.cpp
@@ -0,0 +1,402 @@
+#include "locale_test.h"
+
+#if !defined (STLPORT) || !defined (_STLP_USE_NO_IOSTREAMS)
+# include <locale>
+# include <sstream>
+# include <memory>
+# include <stdexcept>
+
+# if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+# endif
+
+static const char* tested_locales[] = {
+// name,
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ "fr_FR",
+ "ru_RU.koi8r",
+ "en_GB",
+ "en_US",
+# endif
+ "",
+ "C"
+};
+
+void LocaleTest::_time_put_get( const locale& loc )
+{
+ {
+ typedef time_put<char, ostreambuf_iterator<char, char_traits<char> > > time_put_facet;
+ CPPUNIT_ASSERT( has_facet<time_put_facet>(loc) );
+ const time_put_facet& tmp = use_facet<time_put_facet>(loc);
+
+ struct tm xmas = { 0, 0, 12, 25, 11, 93 };
+ ostringstream ostr;
+ ostr.imbue(loc);
+ string format = "%B %d %Y";
+
+ time_put_facet::iter_type ret = tmp.put(ostr, ostr, ' ', &xmas, format.data(), format.data() + format.size());
+ CPPUNIT_ASSERT( !ret.failed() );
+
+ /*
+ * In other words, user conformation is required for reliable parsing
+ * of user-entered dates and times, but machine-generated formats can be
+ * parsed reliably. This allows parsers to be aggressive about interpreting
+ * user variations on standard format.
+ *
+ * ISO/IEC 14882, 22.2.5.1
+ */
+ typedef time_get<char, istreambuf_iterator<char, char_traits<char> > > time_get_facet;
+ CPPUNIT_ASSERT( has_facet<time_get_facet>(loc) );
+ const time_get_facet& tmg = use_facet<time_get_facet>(loc);
+ basic_ios<char> io(0);
+ io.imbue(loc);
+
+ istringstream istr( ostr.str() );
+ istreambuf_iterator<char, char_traits<char> > i( istr );
+ istreambuf_iterator<char, char_traits<char> > e;
+ ios_base::iostate err = ios_base::goodbit;
+ struct tm other = { 15, 20, 9, 14, 7, 105 };
+
+ i = tmg.get_monthname( i, e, io, err, &other );
+ CPPUNIT_ASSERT( err == ios_base::goodbit );
+ CPPUNIT_ASSERT( other.tm_mon == xmas.tm_mon );
+
+ ++i; ++i; ++i; ++i; // skip day of month and spaces around it
+ i = tmg.get_year( i, e, io, err, &other );
+
+ CPPUNIT_ASSERT( err == ios_base::eofbit );
+ CPPUNIT_ASSERT( other.tm_year == xmas.tm_year );
+
+ ostringstream ostrX;
+ ostrX.imbue(loc);
+ format = "%x %X";
+
+ ret = tmp.put(ostrX, ostrX, ' ', &xmas, format.data(), format.data() + format.size());
+ CPPUNIT_ASSERT( !ret.failed() );
+
+ istringstream istrX( ostrX.str() );
+ istreambuf_iterator<char, char_traits<char> > j( istrX );
+
+ err = ios_base::goodbit;
+
+ struct tm yet_more = { 15, 20, 9, 14, 7, 105 };
+
+ j = tmg.get_date( j, e, io, err, &yet_more );
+
+ CPPUNIT_ASSERT( err == ios_base::goodbit );
+
+ CPPUNIT_ASSERT( yet_more.tm_sec != xmas.tm_sec );
+ CPPUNIT_ASSERT( yet_more.tm_min != xmas.tm_min );
+ CPPUNIT_ASSERT( yet_more.tm_hour != xmas.tm_hour );
+ CPPUNIT_ASSERT( yet_more.tm_mday == xmas.tm_mday );
+ CPPUNIT_ASSERT( yet_more.tm_mon == xmas.tm_mon );
+ CPPUNIT_ASSERT( yet_more.tm_year == xmas.tm_year );
+
+ ++j; // skip space
+
+ j = tmg.get_time( j, e, io, err, &yet_more );
+
+ CPPUNIT_ASSERT( err == ios_base::eofbit || err == ios_base::goodbit );
+
+ CPPUNIT_ASSERT( yet_more.tm_sec == xmas.tm_sec );
+ CPPUNIT_ASSERT( yet_more.tm_min == xmas.tm_min );
+ CPPUNIT_ASSERT( yet_more.tm_hour == xmas.tm_hour );
+ CPPUNIT_ASSERT( yet_more.tm_mday == xmas.tm_mday );
+ CPPUNIT_ASSERT( yet_more.tm_mon == xmas.tm_mon );
+ CPPUNIT_ASSERT( yet_more.tm_year == xmas.tm_year );
+ }
+# if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
+ {
+ typedef time_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > > time_put_facet;
+ CPPUNIT_ASSERT( has_facet<time_put_facet>(loc) );
+ const time_put_facet& tmp = use_facet<time_put_facet>(loc);
+
+ struct tm xmas = { 0, 0, 12, 25, 11, 93 };
+ wostringstream ostr;
+ ostr.imbue(loc);
+ wstring format = L"%B %d %Y";
+
+ time_put_facet::iter_type ret = tmp.put(ostr, ostr, ' ', &xmas, format.data(), format.data() + format.size());
+ CPPUNIT_ASSERT( !ret.failed() );
+
+ /*
+ * In other words, user conformation is required for reliable parsing
+ * of user-entered dates and times, but machine-generated formats can be
+ * parsed reliably. This allows parsers to be aggressive about interpreting
+ * user variations on standard format.
+ *
+ * ISO/IEC 14882, 22.2.5.1
+ */
+ typedef time_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > > time_get_facet;
+ CPPUNIT_ASSERT( has_facet<time_get_facet>(loc) );
+ const time_get_facet& tmg = use_facet<time_get_facet>(loc);
+ // Intentional instantiation with char to show a bug in a previous STLport version.
+ basic_ios<char> io(0);
+ io.imbue(loc);
+
+ wistringstream istr( ostr.str() );
+ istreambuf_iterator<wchar_t, char_traits<wchar_t> > i( istr );
+ istreambuf_iterator<wchar_t, char_traits<wchar_t> > e;
+ ios_base::iostate err = ios_base::goodbit;
+ struct tm other = { 15, 20, 9, 14, 7, 105 };
+
+ i = tmg.get_monthname( i, e, io, err, &other );
+ CPPUNIT_ASSERT( err == ios_base::goodbit );
+ CPPUNIT_ASSERT( other.tm_mon == xmas.tm_mon );
+
+ ++i; ++i; ++i; ++i; // skip day of month and spaces around it
+ i = tmg.get_year( i, e, io, err, &other );
+
+ CPPUNIT_ASSERT( err == ios_base::eofbit );
+ CPPUNIT_ASSERT( other.tm_year == xmas.tm_year );
+
+ wostringstream ostrX;
+ ostrX.imbue(loc);
+ format = L"%x %X";
+
+ ret = tmp.put(ostrX, ostrX, ' ', &xmas, format.data(), format.data() + format.size());
+ CPPUNIT_ASSERT( !ret.failed() );
+
+ wistringstream istrX( ostrX.str() );
+ istreambuf_iterator<wchar_t, char_traits<wchar_t> > j( istrX );
+
+ err = ios_base::goodbit;
+
+ struct tm yet_more = { 15, 20, 9, 14, 7, 105 };
+
+ j = tmg.get_date( j, e, io, err, &yet_more );
+
+ CPPUNIT_ASSERT( err == ios_base::goodbit );
+
+ CPPUNIT_ASSERT( yet_more.tm_sec != xmas.tm_sec );
+ CPPUNIT_ASSERT( yet_more.tm_min != xmas.tm_min );
+ CPPUNIT_ASSERT( yet_more.tm_hour != xmas.tm_hour );
+ CPPUNIT_ASSERT( yet_more.tm_mday == xmas.tm_mday );
+ CPPUNIT_ASSERT( yet_more.tm_mon == xmas.tm_mon );
+ CPPUNIT_ASSERT( yet_more.tm_year == xmas.tm_year );
+
+ ++j; // skip space
+
+ j = tmg.get_time( j, e, io, err, &yet_more );
+
+ CPPUNIT_ASSERT( err == ios_base::eofbit || err == ios_base::goodbit );
+
+ CPPUNIT_ASSERT( yet_more.tm_sec == xmas.tm_sec );
+ CPPUNIT_ASSERT( yet_more.tm_min == xmas.tm_min );
+ CPPUNIT_ASSERT( yet_more.tm_hour == xmas.tm_hour );
+ CPPUNIT_ASSERT( yet_more.tm_mday == xmas.tm_mday );
+ CPPUNIT_ASSERT( yet_more.tm_mon == xmas.tm_mon );
+ CPPUNIT_ASSERT( yet_more.tm_year == xmas.tm_year );
+ }
+# endif
+}
+
+typedef void (LocaleTest::*_Test) (const locale&);
+static void test_supported_locale(LocaleTest& inst, _Test __test) {
+ size_t n = sizeof(tested_locales) / sizeof(tested_locales[0]);
+ for (size_t i = 0; i < n; ++i) {
+ locale loc;
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ try
+# endif
+ {
+ locale tmp(tested_locales[i]);
+ loc = tmp;
+ }
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ catch (runtime_error const&) {
+ //This locale is not supported.
+ continue;
+ }
+# endif
+ CPPUNIT_MESSAGE( loc.name().c_str() );
+ (inst.*__test)(loc);
+
+ {
+ locale tmp(locale::classic(), tested_locales[i], locale::time);
+ loc = tmp;
+ }
+ (inst.*__test)(loc);
+
+ {
+ typedef time_put_byname<char, ostreambuf_iterator<char, char_traits<char> > > time_put_facet;
+ locale tmp0(locale::classic(), new time_put_facet(tested_locales[i]));
+ typedef time_get_byname<char, istreambuf_iterator<char, char_traits<char> > > time_get_facet;
+ locale tmp1(tmp0, new time_get_facet(tested_locales[i]));
+ loc = tmp1;
+ }
+ (inst.*__test)(loc);
+ }
+}
+
+void LocaleTest::time_put_get()
+{ test_supported_locale(*this, &LocaleTest::_time_put_get); }
+
+void LocaleTest::time_by_name()
+{
+# if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ /*
+ * Check of the 22.1.1.2.7 standard point. Construction of a locale
+ * instance from a null pointer or an unknown name should result in
+ * a runtime_error exception.
+ */
+# if defined (STLPORT) || !defined (_MSC_VER) || (_MSC_VER > 1400)
+ try {
+ locale loc(locale::classic(), new time_put_byname<char, ostreambuf_iterator<char, char_traits<char> > >(static_cast<char const*>(0)));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+# endif
+
+ try {
+ locale loc(locale::classic(), new time_put_byname<char, ostreambuf_iterator<char, char_traits<char> > >("yasli_language"));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ string veryLongFacetName("LC_TIME=");
+ veryLongFacetName.append(512, '?');
+ locale loc(locale::classic(), new time_put_byname<char, ostreambuf_iterator<char, char_traits<char> > >(veryLongFacetName.c_str()));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ locale loc(locale::classic(), new time_get_byname<char, istreambuf_iterator<char, char_traits<char> > >(static_cast<char const*>(0)));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ locale loc(locale::classic(), new time_get_byname<char, istreambuf_iterator<char, char_traits<char> > >("yasli_language"));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ string veryLongFacetName("LC_TIME=");
+ veryLongFacetName.append(512, '?');
+ locale loc(locale::classic(), new time_get_byname<char, istreambuf_iterator<char, char_traits<char> > >(veryLongFacetName.c_str()));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const& /* e */) {
+ //CPPUNIT_MESSAGE( e.what() );
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ locale loc(locale::classic(), "C", locale::time);
+ }
+ catch (runtime_error const& /* e */) {
+ /* CPPUNIT_MESSAGE( e.what() ); */
+ CPPUNIT_FAIL;
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ // On platform without real localization support we should rely on the "C" facet.
+ locale loc(locale::classic(), "", locale::time);
+ }
+ catch (runtime_error const& /* e */) {
+ /* CPPUNIT_MESSAGE( e.what() ); */
+ CPPUNIT_FAIL;
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ locale loc(locale::classic(), new time_get_byname<char, istreambuf_iterator<char, char_traits<char> > >("C"));
+ }
+ catch (runtime_error const& /* e */) {
+ /* CPPUNIT_MESSAGE( e.what() ); */
+ CPPUNIT_FAIL;
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ // On platform without real localization support we should rely on the "C" locale facet.
+ locale loc(locale::classic(), new time_get_byname<char, istreambuf_iterator<char, char_traits<char> > >(""));
+ }
+ catch (runtime_error const& /* e */) {
+ /* CPPUNIT_MESSAGE( e.what() ); */
+ CPPUNIT_FAIL;
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+# if !defined (STLPORT) || !defined (_STLP_NO_WCHAR_T)
+ try {
+ locale loc(locale::classic(), new time_put_byname<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >(static_cast<char const*>(0)));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ locale loc(locale::classic(), new time_put_byname<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >("yasli_language"));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ locale loc(locale::classic(), new time_get_byname<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >(static_cast<char const*>(0)));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+ try {
+ locale loc(locale::classic(), new time_get_byname<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >("yasli_language"));
+ CPPUNIT_FAIL;
+ }
+ catch (runtime_error const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+
+# endif
+# endif
+}
+
+#endif
diff --git a/sources/android/stlport/test/unit/time_header_test.c b/sources/android/stlport/test/unit/time_header_test.c
new file mode 100644
index 0000000..dbfe64b
--- /dev/null
+++ b/sources/android/stlport/test/unit/time_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <time.h>
diff --git a/sources/android/stlport/test/unit/times_test.cpp b/sources/android/stlport/test/unit/times_test.cpp
new file mode 100644
index 0000000..aa13925
--- /dev/null
+++ b/sources/android/stlport/test/unit/times_test.cpp
@@ -0,0 +1,34 @@
+#include <algorithm>
+#include <numeric>
+#include <functional>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class TimesTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(TimesTest);
+ CPPUNIT_TEST(times);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void times();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(TimesTest);
+
+//
+// tests implementation
+//
+void TimesTest::times()
+{
+ int input [4] = { 1, 5, 7, 2 };
+ int total = accumulate(input, input + 4, 1, multiplies<int>());
+ CPPUNIT_ASSERT(total==70);
+}
diff --git a/sources/android/stlport/test/unit/transform_test.cpp b/sources/android/stlport/test/unit/transform_test.cpp
new file mode 100644
index 0000000..81649e1
--- /dev/null
+++ b/sources/android/stlport/test/unit/transform_test.cpp
@@ -0,0 +1,80 @@
+#include <string>
+#include <iterator>
+#include <vector>
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class TransformTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(TransformTest);
+ CPPUNIT_TEST(trnsfrm1);
+ CPPUNIT_TEST(trnsfrm2);
+ CPPUNIT_TEST(self_str);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void trnsfrm1();
+ void trnsfrm2();
+ void self_str();
+
+ static int negate_int(int a_) {
+ return -a_;
+ }
+ static char map_char(char a_, int b_) {
+ return char(a_ + b_);
+ }
+ static char shift( char c ) {
+ return char(((int)c + 1) % 256);
+ }
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(TransformTest);
+
+//
+// tests implementation
+//
+void TransformTest::trnsfrm1()
+{
+ int numbers[6] = { -5, -1, 0, 1, 6, 11 };
+
+ int result[6];
+ transform((int*)numbers, (int*)numbers + 6, (int*)result, negate_int);
+
+ CPPUNIT_ASSERT(result[0]==5);
+ CPPUNIT_ASSERT(result[1]==1);
+ CPPUNIT_ASSERT(result[2]==0);
+ CPPUNIT_ASSERT(result[3]==-1);
+ CPPUNIT_ASSERT(result[4]==-6);
+ CPPUNIT_ASSERT(result[5]==-11);
+}
+void TransformTest::trnsfrm2()
+{
+#if defined (__MVS__)
+ int trans[] = {-11, 4, -6, -6, -18, 0, 18, -14, 6, 0, -1, -59};
+#else
+ int trans[] = {-4, 4, -6, -6, -10, 0, 10, -6, 6, 0, -1, -77};
+#endif
+ char n[] = "Larry Mullen";
+ const size_t count = ::strlen(n);
+
+ string res;
+ transform(n, n + count, trans, back_inserter(res), map_char);
+ CPPUNIT_ASSERT( res == "Hello World!" )
+}
+
+void TransformTest::self_str()
+{
+ string s( "0123456789abcdefg" );
+ string r( "123456789:bcdefgh" );
+ transform( s.begin(), s.end(), s.begin(), shift );
+ CPPUNIT_ASSERT( s == r );
+}
+
diff --git a/sources/android/stlport/test/unit/type_traits_test.cpp b/sources/android/stlport/test/unit/type_traits_test.cpp
new file mode 100644
index 0000000..d881451
--- /dev/null
+++ b/sources/android/stlport/test/unit/type_traits_test.cpp
@@ -0,0 +1,593 @@
+#include <algorithm>
+#include <vector>
+#include <string>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if defined (_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class TypeTraitsTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(TypeTraitsTest);
+#if !defined (STLPORT)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(manips);
+ CPPUNIT_TEST(integer);
+ CPPUNIT_TEST(rational);
+ CPPUNIT_TEST(pointer_type);
+#if defined (STLPORT) && !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(reference_type);
+#if defined (STLPORT)
+ CPPUNIT_STOP_IGNORE;
+#endif
+ CPPUNIT_TEST(both_pointer_type);
+ CPPUNIT_TEST(ok_to_use_memcpy);
+ CPPUNIT_TEST(ok_to_use_memmove);
+ CPPUNIT_TEST(trivial_destructor);
+ CPPUNIT_TEST(is_POD);
+ CPPUNIT_TEST(stlport_class);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void manips();
+ void integer();
+ void rational();
+ void pointer_type();
+ void reference_type();
+ void both_pointer_type();
+ void ok_to_use_memcpy();
+ void ok_to_use_memmove();
+ void trivial_destructor();
+ void is_POD();
+ void stlport_class();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(TypeTraitsTest);
+
+#if defined (STLPORT)
+
+# if defined (__GNUC__) && defined (_STLP_USE_NAMESPACES)
+// libstdc++ sometimes exposed its own __true_type type in global
+// namespace resulting in an ambiguity.
+# define __true_type std::__true_type
+# define __false_type std::__false_type
+# endif
+
+int type_to_value(__true_type)
+{ return 1; }
+int type_to_value(__false_type)
+{ return 0; }
+
+int* int_pointer;
+int const* int_const_pointer;
+int volatile* int_volatile_pointer;
+int const volatile* int_const_volatile_pointer;
+int int_val = 0;
+int const int_const_val = 0;
+int volatile int_volatile_val = 0;
+int & int_ref = int_val;
+int const& int_const_ref = int_val;
+int const volatile& int_const_volatile_ref = int_val;
+
+//A type that represent any type:
+struct any_type
+{
+ //Dummy operations to forbid to compilers with intrinsic
+ //type traits support to consider this type as a POD.
+ any_type() : m_data(1) {}
+ any_type(const any_type&) : m_data(2) {}
+ any_type& operator = (const any_type&)
+ { m_data = 3; return *this; }
+ ~any_type() { m_data = 0; }
+
+ size_t m_data;
+};
+
+any_type any;
+any_type* any_pointer;
+any_type const* any_const_pointer;
+any_type volatile* any_volatile_pointer;
+any_type const volatile* any_const_volatile_pointer;
+
+//A type that represent any pod type
+struct any_pod_type
+{};
+
+# if defined (_STLP_USE_BOOST_SUPPORT)
+//Mandatory for compilers without without partial template specialization.
+BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(any_pod_type)
+# endif
+
+any_pod_type any_pod;
+any_pod_type* any_pod_pointer;
+any_pod_type const* any_pod_const_pointer;
+any_pod_type volatile* any_pod_volatile_pointer;
+any_pod_type const volatile* any_pod_const_volatile_pointer;
+
+# if defined (_STLP_USE_NAMESPACES)
+namespace std {
+# endif
+ _STLP_TEMPLATE_NULL
+ struct __type_traits<any_pod_type> {
+ typedef __true_type has_trivial_default_constructor;
+ typedef __true_type has_trivial_copy_constructor;
+ typedef __true_type has_trivial_assignment_operator;
+ typedef __true_type has_trivial_destructor;
+ typedef __true_type is_POD_type;
+ };
+# if defined (_STLP_USE_NAMESPACES)
+}
+# endif
+
+struct base
+{};
+struct derived : public base
+{};
+
+//
+// tests implementation
+//
+template <typename _Src, typename _Dst>
+int is_convertible(_Src, _Dst) {
+# if !defined(__BORLANDC__)
+ typedef typename _IsConvertible<_Src, _Dst>::_Ret _Ret;
+# else
+ enum { _Is = _IsConvertible<_Src, _Dst>::value };
+ typedef typename __bool2type<_Is>::_Ret _Ret;
+# endif
+ return type_to_value(_Ret());
+}
+
+template <typename _Src, typename _Dst>
+int is_cv_convertible(_Src, _Dst) {
+# if !defined(__BORLANDC__)
+ typedef typename _IsCVConvertible<_Src, _Dst>::_Ret _Ret;
+# else
+ enum { _Is = _IsCVConvertible<_Src, _Dst>::value };
+ typedef typename __bool2type<_Is>::_Ret _Ret;
+# endif
+ return type_to_value(_Ret());
+}
+#endif
+
+void TypeTraitsTest::manips()
+{
+#if defined (STLPORT)
+ {
+ typedef __bool2type<0>::_Ret _ZeroRet;
+ CPPUNIT_ASSERT( type_to_value(_ZeroRet()) == 0 );
+ typedef __bool2type<1>::_Ret _OneRet;
+ CPPUNIT_ASSERT( type_to_value(_OneRet()) == 1 );
+ typedef __bool2type<65456873>::_Ret _AnyRet;
+ CPPUNIT_ASSERT( type_to_value(_AnyRet()) == 1 );
+ }
+
+ {
+ CPPUNIT_ASSERT( __type2bool<__true_type>::_Ret == 1 );
+ CPPUNIT_ASSERT( __type2bool<__false_type>::_Ret == 0 );
+ CPPUNIT_ASSERT( __type2bool<any_type>::_Ret == 1 );
+ }
+
+ {
+ typedef _Not<__true_type>::_Ret _NotTrueRet;
+ CPPUNIT_ASSERT( type_to_value(_NotTrueRet()) == 0 );
+ typedef _Not<__false_type>::_Ret _NotFalseRet;
+ CPPUNIT_ASSERT( type_to_value(_NotFalseRet()) == 1 );
+ }
+
+ {
+ typedef _Land2<__true_type, __true_type>::_Ret _TrueTrueRet;
+ CPPUNIT_ASSERT( type_to_value(_TrueTrueRet()) == 1 );
+ typedef _Land2<__true_type, __false_type>::_Ret _TrueFalseRet;
+ CPPUNIT_ASSERT( type_to_value(_TrueFalseRet()) == 0 );
+ typedef _Land2<__false_type, __true_type>::_Ret _FalseTrueRet;
+ CPPUNIT_ASSERT( type_to_value(_FalseTrueRet()) == 0 );
+ typedef _Land2<__false_type, __false_type>::_Ret _FalseFalseRet;
+ CPPUNIT_ASSERT( type_to_value(_FalseFalseRet()) == 0 );
+ }
+
+ {
+ typedef _Land3<__true_type, __true_type, __true_type>::_Ret _TrueTrueTrueRet;
+ CPPUNIT_ASSERT( type_to_value(_TrueTrueTrueRet()) == 1 );
+ typedef _Land3<__true_type, __true_type, __false_type>::_Ret _TrueTrueFalseRet;
+ CPPUNIT_ASSERT( type_to_value(_TrueTrueFalseRet()) == 0 );
+ typedef _Land3<__true_type, __false_type, __true_type>::_Ret _TrueFalseTrueRet;
+ CPPUNIT_ASSERT( type_to_value(_TrueFalseTrueRet()) == 0 );
+ typedef _Land3<__true_type, __false_type, __false_type>::_Ret _TrueFalseFalseRet;
+ CPPUNIT_ASSERT( type_to_value(_TrueFalseFalseRet()) == 0 );
+ typedef _Land3<__false_type, __true_type, __true_type>::_Ret _FalseTrueTrueRet;
+ CPPUNIT_ASSERT( type_to_value(_FalseTrueTrueRet()) == 0 );
+ typedef _Land3<__false_type, __true_type, __false_type>::_Ret _FalseTrueFalseRet;
+ CPPUNIT_ASSERT( type_to_value(_FalseTrueFalseRet()) == 0 );
+ typedef _Land3<__false_type, __false_type, __true_type>::_Ret _FalseFalseTrueRet;
+ CPPUNIT_ASSERT( type_to_value(_FalseFalseTrueRet()) == 0 );
+ typedef _Land3<__false_type, __false_type, __false_type>::_Ret _FalseFalseFalseRet;
+ CPPUNIT_ASSERT( type_to_value(_FalseFalseFalseRet()) == 0 );
+ }
+
+ {
+ typedef _Lor2<__true_type, __true_type>::_Ret _TrueTrueRet;
+ CPPUNIT_ASSERT( type_to_value(_TrueTrueRet()) == 1 );
+ typedef _Lor2<__true_type, __false_type>::_Ret _TrueFalseRet;
+ CPPUNIT_ASSERT( type_to_value(_TrueFalseRet()) == 1 );
+ typedef _Lor2<__false_type, __true_type>::_Ret _FalseTrueRet;
+ CPPUNIT_ASSERT( type_to_value(_FalseTrueRet()) == 1 );
+ typedef _Lor2<__false_type, __false_type>::_Ret _FalseFalseRet;
+ CPPUNIT_ASSERT( type_to_value(_FalseFalseRet()) == 0 );
+ }
+
+ {
+ typedef _Lor3<__true_type, __true_type, __true_type>::_Ret _TrueTrueTrueRet;
+ CPPUNIT_ASSERT( type_to_value(_TrueTrueTrueRet()) == 1 );
+ typedef _Lor3<__true_type, __true_type, __false_type>::_Ret _TrueTrueFalseRet;
+ CPPUNIT_ASSERT( type_to_value(_TrueTrueFalseRet()) == 1 );
+ typedef _Lor3<__true_type, __false_type, __true_type>::_Ret _TrueFalseTrueRet;
+ CPPUNIT_ASSERT( type_to_value(_TrueFalseTrueRet()) == 1 );
+ typedef _Lor3<__true_type, __false_type, __false_type>::_Ret _TrueFalseFalseRet;
+ CPPUNIT_ASSERT( type_to_value(_TrueFalseFalseRet()) == 1 );
+ typedef _Lor3<__false_type, __true_type, __true_type>::_Ret _FalseTrueTrueRet;
+ CPPUNIT_ASSERT( type_to_value(_FalseTrueTrueRet()) == 1 );
+ typedef _Lor3<__false_type, __true_type, __false_type>::_Ret _FalseTrueFalseRet;
+ CPPUNIT_ASSERT( type_to_value(_FalseTrueFalseRet()) == 1 );
+ typedef _Lor3<__false_type, __false_type, __true_type>::_Ret _FalseFalseTrueRet;
+ CPPUNIT_ASSERT( type_to_value(_FalseFalseTrueRet()) == 1 );
+ typedef _Lor3<__false_type, __false_type, __false_type>::_Ret _FalseFalseFalseRet;
+ CPPUNIT_ASSERT( type_to_value(_FalseFalseFalseRet()) == 0 );
+ }
+
+ {
+ typedef __select<1, __true_type, __false_type>::_Ret _SelectFirstRet;
+ CPPUNIT_ASSERT( type_to_value(_SelectFirstRet()) == 1 );
+ typedef __select<0, __true_type, __false_type>::_Ret _SelectSecondRet;
+ CPPUNIT_ASSERT( type_to_value(_SelectSecondRet()) == 0 );
+# if defined (__BORLANDC__)
+ typedef __selectT<__true_type, __true_type, __false_type>::_Ret _SelectFirstRet;
+ CPPUNIT_ASSERT( type_to_value(_SelectFirstRet()) == 1 );
+ typedef __selectT<__false_type, __true_type, __false_type>::_Ret _SelectSecondRet;
+ CPPUNIT_ASSERT( type_to_value(_SelectSecondRet()) == 0 );
+# endif
+ }
+
+ {
+ base b;
+ derived d;
+ const derived cd = d;
+ base *pb = &b;
+ derived *pd = &d;
+ derived const *pcd = pd;
+ CPPUNIT_CHECK( is_convertible(any, b) == 0 );
+ CPPUNIT_CHECK( is_convertible(d, b) == 1 );
+ CPPUNIT_CHECK( is_convertible(cd, b) == 1 );
+ // _IsCVConvertible only needs to work for pointer type:
+ //CPPUNIT_CHECK( is_cv_convertible(d, b) == 1 );
+ //CPPUNIT_CHECK( is_cv_convertible(cd, b) == 0 );
+
+ //_IsConvertible do not need to work for pointers:
+ //CPPUNIT_CHECK( is_convertible(pd, pb) == 1 );
+ //CPPUNIT_CHECK( is_convertible(pcd, pb) == 1 );
+
+ CPPUNIT_CHECK( is_cv_convertible(pd, pb) == 1 );
+ CPPUNIT_CHECK( is_cv_convertible(pcd, pb) == 0 );
+ }
+#endif
+}
+
+#if defined (STLPORT)
+template <typename _Type>
+int is_integer(_Type) {
+ typedef typename _IsIntegral<_Type>::_Ret _Ret;
+ return type_to_value(_Ret());
+}
+#endif
+
+void TypeTraitsTest::integer()
+{
+#if defined (STLPORT)
+ CPPUNIT_ASSERT( is_integer(bool()) == 1 );
+ CPPUNIT_ASSERT( is_integer(char()) == 1 );
+ typedef signed char signed_char;
+ CPPUNIT_ASSERT( is_integer(signed_char()) == 1 );
+ typedef unsigned char unsigned_char;
+ CPPUNIT_ASSERT( is_integer(unsigned_char()) == 1 );
+# if defined (_STLP_HAS_WCHAR_T)
+ CPPUNIT_ASSERT( is_integer(wchar_t()) == 1 );
+# endif
+ CPPUNIT_ASSERT( is_integer(short()) == 1 );
+ typedef unsigned short unsigned_short;
+ CPPUNIT_ASSERT( is_integer(unsigned_short()) == 1 );
+ CPPUNIT_ASSERT( is_integer(int()) == 1 );
+ typedef unsigned int unsigned_int;
+ CPPUNIT_ASSERT( is_integer(unsigned_int()) == 1 );
+ CPPUNIT_ASSERT( is_integer(long()) == 1 );
+ typedef unsigned long unsigned_long;
+ CPPUNIT_ASSERT( is_integer(unsigned_long()) == 1 );
+# if defined (_STLP_LONG_LONG)
+ typedef _STLP_LONG_LONG long_long;
+ CPPUNIT_ASSERT( is_integer(long_long()) == 1 );
+ typedef unsigned _STLP_LONG_LONG unsigned_long_long;
+ CPPUNIT_ASSERT( is_integer(unsigned_long_long()) == 1 );
+# endif
+ CPPUNIT_ASSERT( is_integer(float()) == 0 );
+ CPPUNIT_ASSERT( is_integer(double()) == 0 );
+# if !defined ( _STLP_NO_LONG_DOUBLE )
+ typedef long double long_double;
+ CPPUNIT_ASSERT( is_integer(long_double()) == 0 );
+# endif
+ CPPUNIT_ASSERT( is_integer(any) == 0 );
+ CPPUNIT_ASSERT( is_integer(any_pointer) == 0 );
+#endif
+}
+
+#if defined (STLPORT)
+template <typename _Type>
+int is_rational(_Type) {
+ typedef typename _IsRational<_Type>::_Ret _Ret;
+ return type_to_value(_Ret());
+}
+#endif
+
+void TypeTraitsTest::rational()
+{
+#if defined (STLPORT)
+ CPPUNIT_ASSERT( is_rational(bool()) == 0 );
+ CPPUNIT_ASSERT( is_rational(char()) == 0 );
+ typedef signed char signed_char;
+ CPPUNIT_ASSERT( is_rational(signed_char()) == 0 );
+ typedef unsigned char unsigned_char;
+ CPPUNIT_ASSERT( is_rational(unsigned_char()) == 0 );
+# if defined (_STLP_HAS_WCHAR_T)
+ CPPUNIT_ASSERT( is_rational(wchar_t()) == 0 );
+# endif
+ CPPUNIT_ASSERT( is_rational(short()) == 0 );
+ typedef unsigned short unsigned_short;
+ CPPUNIT_ASSERT( is_rational(unsigned_short()) == 0 );
+ CPPUNIT_ASSERT( is_rational(int()) == 0 );
+ typedef unsigned int unsigned_int;
+ CPPUNIT_ASSERT( is_rational(unsigned_int()) == 0 );
+ CPPUNIT_ASSERT( is_rational(long()) == 0 );
+ typedef unsigned long unsigned_long;
+ CPPUNIT_ASSERT( is_rational(unsigned_long()) == 0 );
+# if defined (_STLP_LONG_LONG)
+ typedef _STLP_LONG_LONG long_long;
+ CPPUNIT_ASSERT( is_rational(long_long()) == 0 );
+ typedef unsigned _STLP_LONG_LONG unsigned_long_long;
+ CPPUNIT_ASSERT( is_rational(unsigned_long_long()) == 0 );
+# endif
+ CPPUNIT_ASSERT( is_rational(float()) == 1 );
+ CPPUNIT_ASSERT( is_rational(double()) == 1 );
+# if !defined ( _STLP_NO_LONG_DOUBLE )
+ typedef long double long_double;
+ CPPUNIT_ASSERT( is_rational(long_double()) == 1 );
+# endif
+ CPPUNIT_ASSERT( is_rational(any) == 0 );
+ CPPUNIT_ASSERT( is_rational(any_pointer) == 0 );
+#endif
+}
+
+#if defined (STLPORT)
+template <typename _Type>
+int is_pointer_type(_Type) {
+ return type_to_value(_IsPtrType<_Type>::_Ret());
+}
+#endif
+
+void TypeTraitsTest::pointer_type()
+{
+#if defined (STLPORT)
+ CPPUNIT_ASSERT( is_pointer_type(int_val) == 0 );
+ CPPUNIT_ASSERT( is_pointer_type(int_pointer) == 1 );
+ CPPUNIT_ASSERT( is_pointer_type(int_const_pointer) == 1 );
+ CPPUNIT_ASSERT( is_pointer_type(int_volatile_pointer) == 1 );
+ CPPUNIT_ASSERT( is_pointer_type(int_const_volatile_pointer) == 1 );
+ CPPUNIT_ASSERT( is_pointer_type(int_ref) == 0 );
+ CPPUNIT_ASSERT( is_pointer_type(int_const_ref) == 0 );
+ CPPUNIT_ASSERT( is_pointer_type(any) == 0 );
+ CPPUNIT_ASSERT( is_pointer_type(any_pointer) == 1 );
+#endif
+}
+
+void TypeTraitsTest::reference_type()
+{
+#if defined (STLPORT) && defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_ASSERT( type_to_value(_IsRefType<int>::_Ret()) == 0 );
+ CPPUNIT_ASSERT( type_to_value(_IsRefType<int*>::_Ret()) == 0 );
+ CPPUNIT_ASSERT( type_to_value(_IsRefType<int&>::_Ret()) == 1 );
+ CPPUNIT_ASSERT( type_to_value(_IsRefType<int const&>::_Ret()) == 1 );
+ CPPUNIT_ASSERT( type_to_value(_IsRefType<int const volatile&>::_Ret()) == 1 );
+
+ CPPUNIT_ASSERT( type_to_value(_IsOKToSwap(int_pointer, int_pointer, __true_type(), __true_type())._Answer()) == 1 );
+ CPPUNIT_ASSERT( type_to_value(_IsOKToSwap(int_pointer, int_pointer, __false_type(), __false_type())._Answer()) == 0 );
+#endif
+}
+
+#if defined (STLPORT)
+template <typename _Tp1, typename _Tp2>
+int are_both_pointer_type (_Tp1, _Tp2) {
+ return type_to_value(_BothPtrType<_Tp1, _Tp2>::_Answer());
+}
+#endif
+
+void TypeTraitsTest::both_pointer_type()
+{
+#if defined (STLPORT)
+ CPPUNIT_CHECK( are_both_pointer_type(int_val, int_val) == 0 );
+ CPPUNIT_CHECK( are_both_pointer_type(int_pointer, int_pointer) == 1 );
+ CPPUNIT_CHECK( are_both_pointer_type(int_const_pointer, int_const_pointer) == 1 );
+ CPPUNIT_CHECK( are_both_pointer_type(int_volatile_pointer, int_volatile_pointer) == 1 );
+ CPPUNIT_CHECK( are_both_pointer_type(int_const_volatile_pointer, int_const_volatile_pointer) == 1 );
+ CPPUNIT_CHECK( are_both_pointer_type(int_ref, int_ref) == 0 );
+ CPPUNIT_CHECK( are_both_pointer_type(int_const_ref, int_const_ref) == 0 );
+ CPPUNIT_CHECK( are_both_pointer_type(any, any) == 0 );
+ CPPUNIT_CHECK( are_both_pointer_type(any_pointer, any_pointer) == 1 );
+#endif
+}
+
+#if defined (STLPORT)
+template <typename _Tp1, typename _Tp2>
+int is_ok_to_use_memcpy(_Tp1 val1, _Tp2 val2) {
+ return type_to_value(_UseTrivialCopy(val1, val2)._Answer());
+}
+#endif
+
+void TypeTraitsTest::ok_to_use_memcpy()
+{
+#if defined (STLPORT) && !defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS)
+ CPPUNIT_CHECK( is_ok_to_use_memcpy(int_pointer, int_pointer) == 1 );
+ CPPUNIT_CHECK( is_ok_to_use_memcpy(int_const_pointer, int_pointer) == 1 );
+ CPPUNIT_CHECK( is_ok_to_use_memcpy(int_pointer, int_volatile_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memcpy(int_pointer, int_const_volatile_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memcpy(int_const_pointer, int_const_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memcpy(int_const_pointer, int_volatile_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memcpy(int_const_pointer, int_const_volatile_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memcpy(int_const_volatile_pointer, int_const_volatile_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memcpy(int_pointer, any_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memcpy(any_pointer, int_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memcpy(any_pointer, any_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memcpy(any_pointer, any_const_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memcpy(any_pod_pointer, int_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memcpy(any_pod_pointer, any_pod_pointer) == 1 );
+ CPPUNIT_CHECK( is_ok_to_use_memcpy(any_pod_pointer, any_pod_const_pointer) == 0 );
+ vector<float> **pvf = 0;
+ vector<int> **pvi = 0;
+ CPPUNIT_CHECK( is_ok_to_use_memcpy(pvf, pvi) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memcpy(pvi, pvf) == 0 );
+#endif
+}
+
+#if defined (STLPORT)
+template <typename _Tp1, typename _Tp2>
+int is_ok_to_use_memmove(_Tp1 val1, _Tp2 val2) {
+ return type_to_value(_UseTrivialUCopy(val1, val2)._Answer());
+}
+#endif
+
+void TypeTraitsTest::ok_to_use_memmove()
+{
+#if defined (STLPORT) && !defined (_STLP_DONT_SIMULATE_PARTIAL_SPEC_FOR_TYPE_TRAITS)
+ CPPUNIT_CHECK( is_ok_to_use_memmove(int_pointer, int_pointer) == 1 );
+ CPPUNIT_CHECK( is_ok_to_use_memmove(int_const_pointer, int_pointer) == 1 );
+ CPPUNIT_CHECK( is_ok_to_use_memmove(int_pointer, int_volatile_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memmove(int_pointer, int_const_volatile_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memmove(int_const_pointer, int_const_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memmove(int_const_pointer, int_volatile_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memmove(int_const_pointer, int_const_volatile_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memmove(int_const_volatile_pointer, int_const_volatile_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memmove(int_pointer, any_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memmove(any_pointer, int_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memmove(any_pointer, any_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memmove(any_pointer, any_const_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memmove(any_pod_pointer, int_pointer) == 0 );
+ CPPUNIT_CHECK( is_ok_to_use_memmove(any_pod_pointer, any_pod_pointer) == 1 );
+ CPPUNIT_CHECK( is_ok_to_use_memmove(any_pod_pointer, any_pod_const_pointer) == 0 );
+#endif
+}
+
+#if defined (STLPORT)
+template <typename _Tp>
+int has_trivial_destructor(_Tp) {
+ typedef typename __type_traits<_Tp>::has_trivial_destructor _TrivialDestructor;
+ return type_to_value(_TrivialDestructor());
+}
+
+struct DestructorMonitor
+{
+ ~DestructorMonitor()
+ { ++nb_destructor_call; }
+
+ static size_t nb_destructor_call;
+};
+
+size_t DestructorMonitor::nb_destructor_call = 0;
+
+# if defined (_STLP_USE_NAMESPACES)
+namespace std {
+# endif
+ _STLP_TEMPLATE_NULL
+ struct __type_traits<DestructorMonitor> {
+ typedef __true_type has_trivial_default_constructor;
+ typedef __true_type has_trivial_copy_constructor;
+ typedef __true_type has_trivial_assignment_operator;
+ typedef __true_type has_trivial_destructor;
+ typedef __true_type is_POD_type;
+ };
+# if defined (_STLP_USE_NAMESPACES)
+}
+# endif
+#endif
+
+void TypeTraitsTest::trivial_destructor()
+{
+#if defined (STLPORT)
+ CPPUNIT_CHECK( has_trivial_destructor(int_pointer) == 1 );
+ CPPUNIT_CHECK( has_trivial_destructor(int_const_pointer) == 1 );
+ CPPUNIT_CHECK( has_trivial_destructor(int_volatile_pointer) == 1 );
+ CPPUNIT_CHECK( has_trivial_destructor(int_const_volatile_pointer) == 1 );
+ CPPUNIT_CHECK( has_trivial_destructor(any_pointer) == 1 );
+ CPPUNIT_CHECK( has_trivial_destructor(any) == 0 );
+ CPPUNIT_CHECK( has_trivial_destructor(any_pointer) == 1 );
+ CPPUNIT_CHECK( has_trivial_destructor(any_pod) == 1 );
+ CPPUNIT_CHECK( has_trivial_destructor(string()) == 0 );
+
+ //Check of the meta information impact in a container implementation
+ {
+ vector<DestructorMonitor> v(10);
+ DestructorMonitor::nb_destructor_call = 0;
+ }
+ CPPUNIT_CHECK( DestructorMonitor::nb_destructor_call == 0 );
+#endif
+}
+
+#if defined (STLPORT)
+template <typename _Tp>
+int is_POD_type(_Tp) {
+ typedef typename __type_traits<_Tp>::is_POD_type _IsPODType;
+ return type_to_value(_IsPODType());
+}
+#endif
+
+void TypeTraitsTest::is_POD()
+{
+#if defined (STLPORT)
+ CPPUNIT_CHECK( is_POD_type(int_pointer) == 1 );
+ CPPUNIT_CHECK( is_POD_type(int_const_pointer) == 1 );
+ CPPUNIT_CHECK( is_POD_type(int_volatile_pointer) == 1 );
+ CPPUNIT_CHECK( is_POD_type(int_const_volatile_pointer) == 1 );
+ CPPUNIT_CHECK( is_POD_type(any_pointer) == 1 );
+ CPPUNIT_CHECK( is_POD_type(any) == 0 );
+ CPPUNIT_CHECK( is_POD_type(any_pointer) == 1 );
+ CPPUNIT_CHECK( is_POD_type(any_pod) == 1 );
+ CPPUNIT_CHECK( is_POD_type(string()) == 0 );
+#endif
+}
+
+#if defined (STLPORT)
+template <typename _Tp>
+int is_stlport_class(_Tp) {
+ typedef _IsSTLportClass<_Tp> _STLportClass;
+# if !defined (__BORLANDC__)
+ typedef typename _STLportClass::_Ret _Is;
+# else
+ typedef typename __bool2type<_STLportClass::_Is>::_Ret _Is;
+# endif
+ return type_to_value(_Is());
+}
+#endif
+
+void TypeTraitsTest::stlport_class()
+{
+#if defined (STLPORT)
+ CPPUNIT_CHECK( is_stlport_class(allocator<char>()) == 1 );
+# if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
+ CPPUNIT_CHECK( is_stlport_class(string()) == 1 );
+# endif
+ CPPUNIT_CHECK( is_stlport_class(any) == 0 );
+#endif
+}
diff --git a/sources/android/stlport/test/unit/typeinfo_header_test.cpp b/sources/android/stlport/test/unit/typeinfo_header_test.cpp
new file mode 100644
index 0000000..7e3f5eb
--- /dev/null
+++ b/sources/android/stlport/test/unit/typeinfo_header_test.cpp
@@ -0,0 +1,20 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <typeinfo>
+
+#if 0 /* !defined (_STLP_NO_RTTI) && !defined (_STLP_NO_TYPEINFO) */
+/* SourceForge: STLport bug report 1721844
+ * type_info is not a member of stlp_std
+ */
+class A {};
+
+void type_info_header_test()
+{
+ const std::type_info& ti = typeid(A);
+}
+#endif
diff --git a/sources/android/stlport/test/unit/unary.h b/sources/android/stlport/test/unit/unary.h
new file mode 100644
index 0000000..8c9ef43
--- /dev/null
+++ b/sources/android/stlport/test/unit/unary.h
@@ -0,0 +1,23 @@
+#ifndef _unary_h
+#define _unary_h
+#include <cmath>
+#include <cfloat>
+#include <functional> //*TY 12/26/1998 - added to get unary_function
+
+#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)
+using std::unary_function;
+#endif
+
+struct odd : public unary_function<int, bool> {
+ bool operator()(int n_) const { return(n_ % 2) == 1; }
+};
+
+struct positive : public unary_function<int, bool> {
+ bool operator()(int n_) const { return n_ >= 0; }
+};
+
+struct square_root : public unary_function<double, double> {
+ double operator()(double x_) const
+ { return ::sqrt(x_); }
+};
+#endif // _unary_h
diff --git a/sources/android/stlport/test/unit/unary_test.cpp b/sources/android/stlport/test/unit/unary_test.cpp
new file mode 100644
index 0000000..ee480b7
--- /dev/null
+++ b/sources/android/stlport/test/unit/unary_test.cpp
@@ -0,0 +1,98 @@
+#include <vector>
+#include "unary.h"
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class UnaryTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(UnaryTest);
+#if !defined (STLPORT) || defined (_STLP_NO_EXTENSIONS)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(ucompos1);
+ CPPUNIT_TEST(ucompos2);
+ CPPUNIT_STOP_IGNORE;
+ CPPUNIT_TEST(unegate1);
+ CPPUNIT_TEST(unegate2);
+#if defined (STLPORT) && !defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(unegate3);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void ucompos1();
+ void ucompos2();
+ void unegate1();
+ void unegate2();
+ void unegate3();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(UnaryTest);
+
+//
+// tests implementation
+//
+void UnaryTest::unegate1()
+{
+ int array [3] = { 1, 2, 3 };
+ //unary_negate<odd>::argument_type arg_val = 0;
+ int* p = find_if((int*)array, (int*)array + 3, unary_negate<odd>(odd()));
+ CPPUNIT_ASSERT((p != array + 3));
+ CPPUNIT_ASSERT(*p==2);
+}
+void UnaryTest::unegate2()
+{
+ int array [3] = { 1, 2, 3 };
+ int* p = find_if((int*)array, (int*)array + 3, not1(odd()));
+ CPPUNIT_ASSERT(p != array + 3);
+ CPPUNIT_ASSERT(*p==2);
+}
+
+bool test_func(int param) {
+ return param < 3;
+}
+void UnaryTest::unegate3()
+{
+#if !defined (STLPORT) || defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+ int array [3] = { 1, 2, 3 };
+ int* p = find_if((int*)array, (int*)array + 3, not1(ptr_fun(test_func)));
+ CPPUNIT_ASSERT(p != array + 3);
+ CPPUNIT_ASSERT(*p==3);
+#endif
+}
+
+void UnaryTest::ucompos1()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ int input [3] = { -1, -4, -16 };
+
+ double output[3];
+ transform((int*)input, (int*)input + 3, output, unary_compose<square_root, negate<int> >(square_root(), negate<int>()));
+
+ CPPUNIT_ASSERT(output[0]==1);
+ CPPUNIT_ASSERT(output[1]==2);
+ CPPUNIT_ASSERT(output[2]==4);
+#endif
+}
+void UnaryTest::ucompos2()
+{
+#if defined (STLPORT) && !defined (_STLP_NO_EXTENSIONS)
+ int input [3] = { -1, -4, -16 };
+
+ double output [3];
+ transform((int*)input, (int*)input + 3, output, compose1(square_root(), negate<int>()));
+
+ CPPUNIT_ASSERT(output[0]==1);
+ CPPUNIT_ASSERT(output[1]==2);
+ CPPUNIT_ASSERT(output[2]==4);
+#endif
+}
diff --git a/sources/android/stlport/test/unit/uninitialized_test.cpp b/sources/android/stlport/test/unit/uninitialized_test.cpp
new file mode 100644
index 0000000..37884f7
--- /dev/null
+++ b/sources/android/stlport/test/unit/uninitialized_test.cpp
@@ -0,0 +1,245 @@
+#include <memory>
+#include <vector>
+#include <list>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class UninitializedTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(UninitializedTest);
+ CPPUNIT_TEST(copy_test);
+ //CPPUNIT_TEST(fill_test);
+ //CPPUNIT_TEST(fill_n_test);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void copy_test();
+ void fill_test();
+ void fill_n_test();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(UninitializedTest);
+
+struct NotTrivialCopyStruct {
+ NotTrivialCopyStruct() : member(0) {}
+ NotTrivialCopyStruct(NotTrivialCopyStruct const&) : member(1) {}
+
+ int member;
+};
+
+struct TrivialCopyStruct {
+ TrivialCopyStruct() : member(0) {}
+ TrivialCopyStruct(TrivialCopyStruct const&) : member(1) {}
+
+ int member;
+};
+
+struct TrivialInitStruct {
+ TrivialInitStruct()
+ { ++nbConstructorCalls; }
+
+ static size_t nbConstructorCalls;
+};
+
+size_t TrivialInitStruct::nbConstructorCalls = 0;
+
+#if defined (STLPORT)
+# if defined (_STLP_USE_NAMESPACES)
+namespace std {
+# endif
+ _STLP_TEMPLATE_NULL
+ struct __type_traits<TrivialCopyStruct> {
+ typedef __false_type has_trivial_default_constructor;
+ //This is a wrong declaration just to check that internaly a simple memcpy is called:
+ typedef __true_type has_trivial_copy_constructor;
+ typedef __true_type has_trivial_assignment_operator;
+ typedef __true_type has_trivial_destructor;
+ typedef __false_type is_POD_type;
+ };
+
+ _STLP_TEMPLATE_NULL
+ struct __type_traits<TrivialInitStruct> {
+ //This is a wrong declaration just to check that internaly no initialization is done:
+ typedef __true_type has_trivial_default_constructor;
+ typedef __true_type has_trivial_copy_constructor;
+ typedef __true_type has_trivial_assignment_operator;
+ typedef __true_type has_trivial_destructor;
+ typedef __false_type is_POD_type;
+ };
+# if defined (_STLP_USE_NAMESPACES)
+}
+# endif
+#endif
+
+struct base {};
+struct derived : public base {};
+
+//
+// tests implementation
+//
+void UninitializedTest::copy_test()
+{
+ {
+ //Random iterators
+ {
+ vector<NotTrivialCopyStruct> src(10);
+ vector<NotTrivialCopyStruct> dst(10);
+ uninitialized_copy(src.begin(), src.end(), dst.begin());
+ vector<NotTrivialCopyStruct>::const_iterator it(dst.begin()), end(dst.end());
+ for (; it != end; ++it) {
+ CPPUNIT_ASSERT( (*it).member == 1 );
+ }
+ }
+ {
+ /** Note: we use static arrays here so the iterators are always
+ pointers, even in debug mode. */
+ size_t const count = 10;
+ TrivialCopyStruct src[count];
+ TrivialCopyStruct dst[count];
+
+ TrivialCopyStruct* it = src + 0;
+ TrivialCopyStruct* end = src + count;
+ for (; it != end; ++it) {
+ (*it).member = 0;
+ }
+
+ uninitialized_copy(src+0, src+count, dst+0);
+ for (it = dst+0, end = dst+count; it != end; ++it) {
+#if defined (STLPORT)
+ /* If the member is 1, it means that library has not found any
+ optimization oportunity and called the regular copy-ctor instead. */
+ CPPUNIT_ASSERT( (*it).member == 0 );
+#else
+ CPPUNIT_ASSERT( (*it).member == 1 );
+#endif
+ }
+ }
+ }
+
+ {
+ //Bidirectional iterator
+ {
+ vector<NotTrivialCopyStruct> src(10);
+ list<NotTrivialCopyStruct> dst(10);
+
+ list<NotTrivialCopyStruct>::iterator it(dst.begin()), end(dst.end());
+ for (; it != end; ++it) {
+ (*it).member = -1;
+ }
+
+ uninitialized_copy(src.begin(), src.end(), dst.begin());
+
+ for (it = dst.begin(); it != end; ++it) {
+ CPPUNIT_ASSERT( (*it).member == 1 );
+ }
+ }
+
+ {
+ list<NotTrivialCopyStruct> src(10);
+ vector<NotTrivialCopyStruct> dst(10);
+
+ vector<NotTrivialCopyStruct>::iterator it(dst.begin()), end(dst.end());
+ for (; it != end; ++it) {
+ (*it).member = -1;
+ }
+
+ uninitialized_copy(src.begin(), src.end(), dst.begin());
+
+ for (it = dst.begin(); it != end; ++it) {
+ CPPUNIT_ASSERT( (*it).member == 1 );
+ }
+ }
+ }
+
+ {
+ //Using containers of native types:
+#if !defined (STLPORT) || !defined (_STLP_NO_MEMBER_TEMPLATES)
+ {
+ vector<int> src;
+ int i;
+ for (i = -5; i < 6; ++i) {
+ src.push_back(i);
+ }
+
+ //Building a vector result in a uninitialized_copy call internally
+ vector<unsigned int> dst(src.begin(), src.end());
+ vector<unsigned int>::const_iterator it(dst.begin());
+ for (i = -5; i < 6; ++i, ++it) {
+ CPPUNIT_ASSERT( *it == (unsigned int)i );
+ }
+ }
+
+ {
+ vector<char> src;
+ char i;
+ for (i = -5; i < 6; ++i) {
+ src.push_back(i);
+ }
+
+ //Building a vector result in a uninitialized_copy call internally
+ vector<unsigned int> dst(src.begin(), src.end());
+ vector<unsigned int>::const_iterator it(dst.begin());
+ for (i = -5; i < 6; ++i, ++it) {
+ CPPUNIT_ASSERT( *it == (unsigned int)i );
+ }
+ }
+
+ {
+ vector<int> src;
+ int i;
+ for (i = -5; i < 6; ++i) {
+ src.push_back(i);
+ }
+
+ //Building a vector result in a uninitialized_copy call internally
+ vector<float> dst(src.begin(), src.end());
+ vector<float>::const_iterator it(dst.begin());
+ for (i = -5; i < 6; ++i, ++it) {
+ CPPUNIT_ASSERT( *it == (float)i );
+ }
+ }
+
+ {
+ vector<vector<float>*> src(10);
+ vector<vector<float>*> dst(src.begin(), src.end());
+ }
+
+ {
+ derived d;
+ //base *pb = &d;
+ derived *pd = &d;
+ //base **ppb = &pd;
+ vector<derived*> src(10, pd);
+ vector<base*> dst(src.begin(), src.end());
+ vector<base*>::iterator it(dst.begin()), end(dst.end());
+ for (; it != end; ++it) {
+ CPPUNIT_ASSERT( (*it) == pd );
+ }
+ }
+#endif
+ }
+
+ {
+ //Vector initialization:
+ vector<TrivialInitStruct> vect(10);
+ //Just 1 constructor call for the default value:
+ CPPUNIT_ASSERT( TrivialInitStruct::nbConstructorCalls == 1 );
+ }
+}
+
+/*
+void UninitializedTest::fill_test()
+{
+}
+
+void UninitializedTest::fill_n_test()
+{
+}
+*/
diff --git a/sources/android/stlport/test/unit/unique_test.cpp b/sources/android/stlport/test/unit/unique_test.cpp
new file mode 100644
index 0000000..b080b7b
--- /dev/null
+++ b/sources/android/stlport/test/unit/unique_test.cpp
@@ -0,0 +1,105 @@
+#include <algorithm>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class UniqueTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(UniqueTest);
+ CPPUNIT_TEST(uniqcpy1);
+ CPPUNIT_TEST(uniqcpy2);
+ CPPUNIT_TEST(unique1);
+ CPPUNIT_TEST(unique2);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void uniqcpy1();
+ void uniqcpy2();
+ void unique1();
+ void unique2();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(UniqueTest);
+
+static bool str_equal(const char* a_, const char* b_)
+{ return *a_ == *b_; }
+//
+// tests implementation
+//
+void UniqueTest::unique1()
+{
+ int numbers[8] = { 0, 1, 1, 2, 2, 2, 3, 4 };
+ unique((int*)numbers, (int*)numbers + 8);
+ // 0 1 2 3 4 2 3 4
+ CPPUNIT_ASSERT(numbers[0]==0);
+ CPPUNIT_ASSERT(numbers[1]==1);
+ CPPUNIT_ASSERT(numbers[2]==2);
+ CPPUNIT_ASSERT(numbers[3]==3);
+ CPPUNIT_ASSERT(numbers[4]==4);
+ CPPUNIT_ASSERT(numbers[5]==2);
+ CPPUNIT_ASSERT(numbers[6]==3);
+ CPPUNIT_ASSERT(numbers[7]==4);
+}
+
+void UniqueTest::unique2()
+{
+ const char* labels[] = {"Q", "Q", "W", "W", "E", "E", "R", "T", "T", "Y", "Y"};
+
+ const unsigned count = sizeof(labels) / sizeof(labels[0]);
+
+ unique((const char**)labels, (const char**)labels + count, str_equal);
+
+ // QWERTY
+ CPPUNIT_ASSERT(*labels[0] == 'Q');
+ CPPUNIT_ASSERT(*labels[1] == 'W');
+ CPPUNIT_ASSERT(*labels[2] == 'E');
+ CPPUNIT_ASSERT(*labels[3] == 'R');
+ CPPUNIT_ASSERT(*labels[4] == 'T');
+ CPPUNIT_ASSERT(*labels[5] == 'Y');
+
+}
+
+void UniqueTest::uniqcpy1()
+{
+ int numbers[8] = { 0, 1, 1, 2, 2, 2, 3, 4 };
+ int result[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+
+ unique_copy((int*)numbers, (int*)numbers + 8, (int*)result);
+
+ // 0 1 2 3 4 0 0 0
+ CPPUNIT_ASSERT(result[0]==0);
+ CPPUNIT_ASSERT(result[1]==1);
+ CPPUNIT_ASSERT(result[2]==2);
+ CPPUNIT_ASSERT(result[3]==3);
+ CPPUNIT_ASSERT(result[4]==4);
+ CPPUNIT_ASSERT(result[5]==0);
+ CPPUNIT_ASSERT(result[6]==0);
+ CPPUNIT_ASSERT(result[7]==0);
+}
+
+void UniqueTest::uniqcpy2()
+{
+ const char* labels[] = {"Q", "Q", "W", "W", "E", "E", "R", "T", "T", "Y", "Y"};
+ const char **plabels = (const char**)labels;
+
+ const size_t count = sizeof(labels) / sizeof(labels[0]);
+ const char* uCopy[count];
+ const char **puCopy = &uCopy[0];
+ fill(puCopy, puCopy + count, "");
+
+ unique_copy(plabels, plabels + count, puCopy, str_equal);
+
+ //QWERTY
+ CPPUNIT_ASSERT(*uCopy[0] == 'Q');
+ CPPUNIT_ASSERT(*uCopy[1] == 'W');
+ CPPUNIT_ASSERT(*uCopy[2] == 'E');
+ CPPUNIT_ASSERT(*uCopy[3] == 'R');
+ CPPUNIT_ASSERT(*uCopy[4] == 'T');
+ CPPUNIT_ASSERT(*uCopy[5] == 'Y');
+}
diff --git a/sources/android/stlport/test/unit/unordered_test.cpp b/sources/android/stlport/test/unit/unordered_test.cpp
new file mode 100644
index 0000000..8d47ca7
--- /dev/null
+++ b/sources/android/stlport/test/unit/unordered_test.cpp
@@ -0,0 +1,676 @@
+#include <vector>
+#include <algorithm>
+#include <string>
+#if defined (STLPORT)
+# include <unordered_map>
+# include <unordered_set>
+#endif
+
+//#include <iostream>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+# if defined (STLPORT)
+using namespace std::tr1;
+# endif
+#endif
+
+//
+// TestCase class
+//
+class UnorderedTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(UnorderedTest);
+#if !defined (STLPORT)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(uset);
+ CPPUNIT_TEST(umultiset);
+ CPPUNIT_TEST(umap);
+ CPPUNIT_TEST(umultimap);
+ CPPUNIT_TEST(user_case);
+ CPPUNIT_TEST(hash_policy);
+ CPPUNIT_TEST(buckets);
+ CPPUNIT_TEST(equal_range);
+ CPPUNIT_EXPLICIT_TEST(benchmark1);
+ CPPUNIT_EXPLICIT_TEST(benchmark2);
+#if !defined (_STLP_USE_CONTAINERS_EXTENSION)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(template_methods);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void uset();
+ void umultiset();
+ void umap();
+ void umultimap();
+ void user_case();
+ void hash_policy();
+ void buckets();
+ void equal_range();
+ void benchmark1();
+ void benchmark2();
+ void template_methods();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(UnorderedTest);
+
+const int NB_ELEMS = 2000;
+
+//
+// tests implementation
+//
+void UnorderedTest::uset()
+{
+#if defined (STLPORT)
+ typedef unordered_set<int, hash<int>, equal_to<int> > usettype;
+ usettype us;
+
+ //Small compilation check of the copy constructor:
+ usettype us2(us);
+ //And assignment operator
+ us = us2;
+
+ int i;
+ pair<usettype::iterator, bool> ret;
+ for (i = 0; i < NB_ELEMS; ++i) {
+ ret = us.insert(i);
+ CPPUNIT_ASSERT( ret.second );
+ CPPUNIT_ASSERT( *ret.first == i );
+
+ ret = us.insert(i);
+ CPPUNIT_ASSERT( !ret.second );
+ CPPUNIT_ASSERT( *ret.first == i );
+ }
+
+ vector<int> us_val;
+
+ usettype::local_iterator lit, litEnd;
+ for (i = 0; i < NB_ELEMS; ++i) {
+ lit = us.begin(us.bucket(i));
+ litEnd = us.end(us.bucket(i));
+
+ usettype::size_type bucket_pos = us.bucket(*lit);
+ for (; lit != litEnd; ++lit) {
+ CPPUNIT_ASSERT( us.bucket(*lit) == bucket_pos );
+ us_val.push_back(*lit);
+ }
+ }
+
+ //A compilation time check to uncomment from time to time
+ {
+ //usettype::iterator it;
+ //CPPUNIT_ASSERT( it != lit );
+ }
+
+ sort(us_val.begin(), us_val.end());
+ for (i = 0; i < NB_ELEMS; ++i) {
+ CPPUNIT_ASSERT( us_val[i] == i );
+ }
+#endif
+}
+
+void UnorderedTest::umultiset()
+{
+#if defined (STLPORT)
+ typedef unordered_multiset<int, hash<int>, equal_to<int> > usettype;
+ usettype us;
+
+ int i;
+ usettype::iterator ret;
+ for (i = 0; i < NB_ELEMS; ++i) {
+ ret = us.insert(i);
+ CPPUNIT_ASSERT( *ret == i );
+
+ ret = us.insert(i);
+ CPPUNIT_ASSERT( *ret == i );
+ }
+
+ CPPUNIT_ASSERT( us.size() == 2 * NB_ELEMS );
+ vector<int> us_val;
+
+ usettype::local_iterator lit, litEnd;
+ for (i = 0; i < NB_ELEMS; ++i) {
+ lit = us.begin(us.bucket(i));
+ litEnd = us.end(us.bucket(i));
+
+ usettype::size_type bucket_pos = us.bucket(*lit);
+ for (; lit != litEnd; ++lit) {
+ CPPUNIT_ASSERT( us.bucket(*lit) == bucket_pos );
+ us_val.push_back(*lit);
+ }
+ }
+
+ sort(us_val.begin(), us_val.end());
+ for (i = 0; i < NB_ELEMS; ++i) {
+ CPPUNIT_ASSERT( us_val[2 * i] == i );
+ CPPUNIT_ASSERT( us_val[2 * i + 1] == i );
+ }
+#endif
+}
+
+void UnorderedTest::umap()
+{
+#if defined (STLPORT)
+ typedef unordered_map<int, int, hash<int>, equal_to<int> > umaptype;
+ umaptype us;
+
+ //Compilation check of the [] operator:
+ umaptype us2;
+ us[0] = us2[0];
+ us.clear();
+
+ {
+ //An other compilation check
+ typedef unordered_map<int, umaptype> uumaptype;
+ uumaptype uus;
+ umaptype const& uref = uus[0];
+ umaptype ucopy = uus[0];
+ ucopy = uref;
+ //Avoids warning:
+ //(void*)&uref;
+ }
+
+ int i;
+ pair<umaptype::iterator, bool> ret;
+ for (i = 0; i < NB_ELEMS; ++i) {
+ umaptype::value_type p1(i, i);
+ ret = us.insert(p1);
+ CPPUNIT_ASSERT( ret.second );
+ CPPUNIT_ASSERT( *ret.first == p1 );
+
+ umaptype::value_type p2(i, i + 1);
+ ret = us.insert(p2);
+ CPPUNIT_ASSERT( !ret.second );
+ CPPUNIT_ASSERT( *ret.first == p1 );
+ }
+
+ {
+ //Lets look for some values to see if everything is normal:
+ umaptype::iterator umit;
+ for (int j = 0; j < NB_ELEMS; j += NB_ELEMS / 100) {
+ umit = us.find(j);
+
+ CPPUNIT_ASSERT( umit != us.end() );
+ CPPUNIT_ASSERT( (*umit).second == j );
+ }
+ }
+
+ CPPUNIT_ASSERT( us.size() == (size_t)NB_ELEMS );
+ vector<pair<int, int> > us_val;
+
+ umaptype::local_iterator lit, litEnd;
+ for (i = 0; i < NB_ELEMS; ++i) {
+ lit = us.begin(us.bucket(i));
+ litEnd = us.end(us.bucket(i));
+
+ umaptype::size_type bucket_pos = us.bucket((*lit).first);
+ for (; lit != litEnd; ++lit) {
+ CPPUNIT_ASSERT( us.bucket((*lit).first) == bucket_pos );
+ us_val.push_back(make_pair((*lit).first, (*lit).second));
+ }
+ }
+
+ sort(us_val.begin(), us_val.end());
+ for (i = 0; i < NB_ELEMS; ++i) {
+ CPPUNIT_ASSERT( us_val[i] == make_pair(i, i) );
+ }
+#endif
+}
+
+void UnorderedTest::umultimap()
+{
+#if defined (STLPORT)
+ typedef unordered_multimap<int, int, hash<int>, equal_to<int> > umaptype;
+ umaptype us;
+
+ int i;
+ umaptype::iterator ret;
+ for (i = 0; i < NB_ELEMS; ++i) {
+ umaptype::value_type p(i, i);
+ ret = us.insert(p);
+ CPPUNIT_ASSERT( *ret == p );
+
+ ret = us.insert(p);
+ CPPUNIT_ASSERT( *ret == p );
+ }
+
+ CPPUNIT_ASSERT( us.size() == 2 * NB_ELEMS );
+ typedef pair<int, int> ptype;
+ vector<ptype> us_val;
+
+ umaptype::local_iterator lit, litEnd;
+ for (i = 0; i < NB_ELEMS; ++i) {
+ lit = us.begin(us.bucket(i));
+ litEnd = us.end(us.bucket(i));
+
+ umaptype::size_type bucket_pos = us.bucket((*lit).first);
+ for (; lit != litEnd; ++lit) {
+ CPPUNIT_ASSERT( us.bucket((*lit).first) == bucket_pos );
+ us_val.push_back(ptype((*lit).first, (*lit).second));
+ }
+ }
+
+ sort(us_val.begin(), us_val.end());
+ for (i = 0; i < NB_ELEMS; ++i) {
+ ptype p(i, i);
+ CPPUNIT_ASSERT( us_val[i * 2] == p );
+ CPPUNIT_ASSERT( us_val[i * 2 + 1] == p );
+ }
+#endif
+}
+
+void UnorderedTest::user_case()
+{
+#if defined (STLPORT)
+ typedef unordered_map<int, string> UnorderedMap1;
+ typedef unordered_map<int, UnorderedMap1> UnorderedMap2;
+
+ UnorderedMap1 foo;
+ UnorderedMap2 bar;
+
+ foo.insert(UnorderedMap1::value_type(1, string("test1")));
+ foo.insert(UnorderedMap1::value_type(2, string("test2")));
+ foo.insert(UnorderedMap1::value_type(3, string("test3")));
+ foo.insert(UnorderedMap1::value_type(4, string("test4")));
+ foo.insert(UnorderedMap1::value_type(5, string("test5")));
+
+ bar.insert(UnorderedMap2::value_type(0, foo));
+ UnorderedMap2::iterator it = bar.find(0);
+ CPPUNIT_ASSERT( it != bar.end() );
+
+ UnorderedMap1 &body = it->second;
+ UnorderedMap1::iterator cur = body.find(3);
+ CPPUNIT_ASSERT( cur != body.end() );
+
+ body.erase(body.begin(), body.end());
+ CPPUNIT_ASSERT( body.empty() );
+#endif
+}
+
+void UnorderedTest::hash_policy()
+{
+#if defined (STLPORT)
+ unordered_set<int> int_uset;
+
+ CPPUNIT_ASSERT( int_uset.max_load_factor() == 1.0f );
+ CPPUNIT_ASSERT( int_uset.load_factor() == 0.0f );
+
+ size_t nbInserts = int_uset.bucket_count() - 1;
+ for (int i = 0; (size_t)i < nbInserts; ++i) {
+ int_uset.insert(i);
+ }
+ CPPUNIT_ASSERT( int_uset.size() == nbInserts );
+
+ int_uset.max_load_factor(0.5f);
+ int_uset.rehash(0);
+ CPPUNIT_ASSERT( int_uset.load_factor() < int_uset.max_load_factor() );
+
+ size_t bucketsHint = int_uset.bucket_count() + 1;
+ int_uset.rehash(bucketsHint);
+ CPPUNIT_ASSERT( int_uset.bucket_count() >= bucketsHint );
+
+ CPPUNIT_ASSERT( int_uset.key_eq()(10, 10) );
+ CPPUNIT_ASSERT( int_uset.hash_function()(10) == 10 );
+#endif
+}
+
+void UnorderedTest::buckets()
+{
+#if defined (STLPORT)
+ unordered_set<int> int_uset;
+
+ CPPUNIT_ASSERT( int_uset.bucket_count() < int_uset.max_bucket_count() );
+
+ int i;
+ size_t nbBuckets = int_uset.bucket_count();
+ size_t nbInserts = int_uset.bucket_count() - 1;
+ for (i = 0; (size_t)i < nbInserts; ++i) {
+ int_uset.insert(i);
+ }
+ CPPUNIT_ASSERT( nbBuckets == int_uset.bucket_count() );
+
+ size_t bucketSizes = 0;
+ for (i = 0; (size_t)i < nbBuckets; ++i) {
+ bucketSizes += int_uset.bucket_size(i);
+ }
+ CPPUNIT_ASSERT( bucketSizes == int_uset.size() );
+#endif
+}
+
+void UnorderedTest::equal_range()
+{
+#if defined (STLPORT)
+ typedef unordered_multiset<size_t> umset;
+ {
+ //General test
+ umset iumset;
+ iumset.max_load_factor(10.0f);
+
+ size_t nbBuckets = iumset.bucket_count();
+
+ for (size_t i = 0; i < nbBuckets; ++i) {
+ iumset.insert(i);
+ iumset.insert(i + nbBuckets);
+ iumset.insert(i + 2 * nbBuckets);
+ iumset.insert(i + 3 * nbBuckets);
+ iumset.insert(i + 4 * nbBuckets);
+ }
+
+ CPPUNIT_ASSERT( nbBuckets == iumset.bucket_count() );
+ CPPUNIT_ASSERT( iumset.size() == 5 * nbBuckets );
+
+ pair<umset::iterator, umset::iterator> p = iumset.equal_range(1);
+ CPPUNIT_ASSERT( p.first != p.second );
+
+ size_t nbElems = iumset.size();
+ nbElems -= distance(p.first, p.second);
+ for (umset::iterator j = p.first; j != p.second;) {
+ iumset.erase(j++);
+ }
+
+ CPPUNIT_ASSERT( nbElems == iumset.size() );
+
+ p = iumset.equal_range(2);
+ CPPUNIT_ASSERT( p.first != p.second );
+ nbElems -= distance(p.first, p.second);
+ iumset.erase(p.first, p.second);
+ CPPUNIT_ASSERT( nbElems == iumset.size() );
+ }
+
+ {
+ //More specific test that tries to put many values in the same bucket
+ umset iumset;
+
+ size_t i;
+ //We are going to add at least 20 values, to get a stable hash container while doing that
+ //we force a large number of buckets:
+ iumset.rehash(193);
+
+ size_t nbBuckets = iumset.bucket_count();
+ const size_t targetedBucket = nbBuckets / 2;
+
+ //Lets put 10 values in the targeted bucket:
+ for (i = 0; i < 10; ++i) {
+ iumset.insert(targetedBucket + (i * nbBuckets));
+ }
+
+ //We put again 10 values in the targeted bucket and in reverse order:
+ for (i = 9; i <= 10; --i) {
+ iumset.insert(targetedBucket + (i * nbBuckets));
+ }
+
+ //Now we put some more elements until hash container is resized:
+ i = 0;
+ while (iumset.bucket_count() == nbBuckets) {
+ iumset.insert(i++);
+ }
+
+ //CPPUNIT_ASSERT( iumset.bucket_size(targetedBucket) == 21 );
+
+ pair<umset::iterator, umset::iterator> p = iumset.equal_range(targetedBucket);
+ CPPUNIT_ASSERT( p.first != p.second );
+ CPPUNIT_ASSERT( distance(p.first, p.second) == 3 );
+
+ // Now we remove some elements until hash container is resized:
+ nbBuckets = iumset.bucket_count();
+ while (iumset.bucket_count() == nbBuckets &&
+ !iumset.empty()) {
+ iumset.erase(iumset.begin());
+ }
+ CPPUNIT_ASSERT( iumset.load_factor() <= iumset.max_load_factor() );
+
+ // Adding an element back shouldn't change number of buckets:
+ nbBuckets = iumset.bucket_count();
+ iumset.insert(0);
+ CPPUNIT_ASSERT( iumset.bucket_count() == nbBuckets );
+ }
+
+ {
+ srand(0);
+ for (int runs = 0; runs < 2; ++runs) {
+ size_t magic = rand();
+ umset hum;
+ size_t c = 0;
+ for (int i = 0; i < 10000; ++i) {
+ if ((rand() % 500) == 0) {
+ hum.insert(magic);
+ ++c;
+ }
+ else {
+ size_t r;
+ while ((r = rand()) == magic)
+ ;
+ hum.insert(r);
+ }
+
+ /*
+ if ((float)(hum.size() + 1) / (float)hum.bucket_count() > hum.max_load_factor()) {
+ cout << "Hash container dump: Nb elems: " << hum.size() << ", Nb buckets: " << hum.bucket_count() << "\n";
+ for (size_t b = 0; b < hum.bucket_count(); ++b) {
+ if (hum.bucket_size(b) != 0) {
+ umset::local_iterator litBegin(hum.begin(b)), litEnd(hum.end(b));
+ cout << "B" << b << ": ";
+ for (umset::local_iterator lit = litBegin; lit != litEnd; ++lit) {
+ if (lit != litBegin) {
+ cout << " - ";
+ }
+ cout << *lit;
+ }
+ cout << "\n";
+ }
+ }
+ cout << endl;
+ }
+ */
+ }
+ CPPUNIT_ASSERT( hum.count(magic) == c );
+ }
+ }
+#endif
+}
+
+void UnorderedTest::benchmark1()
+{
+#if defined (STLPORT)
+ typedef unordered_multiset<size_t> umset;
+
+ const size_t target = 500000;
+ umset iumset;
+ iumset.max_load_factor(10);
+ size_t i;
+ for (i = 0; i < target; ++i) {
+ iumset.insert(i);
+ }
+
+ for (i = 0; i < target; ++i) {
+ iumset.erase(i);
+ }
+#endif
+}
+
+void UnorderedTest::benchmark2()
+{
+#if defined (STLPORT)
+ typedef unordered_multiset<size_t> umset;
+
+ const size_t target = 500000;
+ umset iumset;
+ iumset.max_load_factor(10);
+ size_t i;
+ for (i = 0; i < target; ++i) {
+ iumset.insert(target - i);
+ }
+
+ for (i = 0; i < target; ++i) {
+ iumset.erase(target - i);
+ }
+#endif
+}
+
+struct Key
+{
+ Key() : m_data(0) {}
+ explicit Key(int data) : m_data(data) {}
+
+ int m_data;
+
+#if defined (__DMC__) // slist<_Tp,_Alloc>::remove error
+ bool operator==(const Key&) const;
+#endif
+};
+
+struct KeyHash
+{
+ size_t operator () (Key key) const
+ { return (size_t)key.m_data; }
+
+ size_t operator () (int data) const
+ { return (size_t)data; }
+};
+
+struct KeyEqual
+{
+ bool operator () (Key lhs, Key rhs) const
+ { return lhs.m_data == rhs.m_data; }
+
+ bool operator () (Key lhs, int rhs) const
+ { return lhs.m_data == rhs; }
+
+ bool operator () (int lhs, Key rhs) const
+ { return lhs == rhs.m_data; }
+};
+
+struct KeyHashPtr
+{
+ size_t operator () (Key const volatile *key) const
+ { return (size_t)key->m_data; }
+
+ size_t operator () (int data) const
+ { return (size_t)data; }
+};
+
+struct KeyEqualPtr
+{
+ bool operator () (Key const volatile *lhs, Key const volatile *rhs) const
+ { return lhs->m_data == rhs->m_data; }
+
+ bool operator () (Key const volatile *lhs, int rhs) const
+ { return lhs->m_data == rhs; }
+
+ bool operator () (int lhs, Key const volatile *rhs) const
+ { return lhs == rhs->m_data; }
+};
+
+void UnorderedTest::template_methods()
+{
+#if defined (STLPORT) && defined (_STLP_USE_CONTAINERS_EXTENSION)
+ {
+ typedef unordered_set<Key, KeyHash, KeyEqual> Container;
+ Container cont;
+ cont.insert(Key(1));
+ cont.insert(Key(2));
+ cont.insert(Key(3));
+ cont.insert(Key(4));
+
+ CPPUNIT_ASSERT( cont.count(Key(1)) == 1 );
+ CPPUNIT_ASSERT( cont.count(1) == 1 );
+ CPPUNIT_ASSERT( cont.count(5) == 0 );
+
+ CPPUNIT_ASSERT( cont.find(2) != cont.end() );
+ CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) );
+
+ Container const& ccont = cont;
+ CPPUNIT_ASSERT( ccont.find(2) != ccont.end() );
+ CPPUNIT_ASSERT( ccont.bucket(2) == ccont.bucket(2) );
+ CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.begin(), ccont.end()) );
+ }
+
+ {
+ typedef unordered_set<Key*, KeyHashPtr, KeyEqualPtr> Container;
+ Container cont;
+ Key key1(1), key2(2), key3(3), key4(4);
+ cont.insert(&key1);
+ cont.insert(&key2);
+ cont.insert(&key3);
+ cont.insert(&key4);
+
+ CPPUNIT_ASSERT( cont.count(1) == 1 );
+ CPPUNIT_ASSERT( cont.count(5) == 0 );
+
+ CPPUNIT_ASSERT( cont.find(2) != cont.end() );
+ CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) );
+
+ Container const& ccont = cont;
+ CPPUNIT_ASSERT( ccont.find(2) != ccont.end() );
+ CPPUNIT_ASSERT( ccont.bucket(2) == ccont.bucket(2) );
+ CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.begin(), ccont.end()) );
+ }
+ {
+ typedef unordered_multiset<Key, KeyHash, KeyEqual> Container;
+ Container cont;
+ cont.insert(Key(1));
+ cont.insert(Key(2));
+ cont.insert(Key(1));
+ cont.insert(Key(2));
+
+ CPPUNIT_ASSERT( cont.count(Key(1)) == 2 );
+ CPPUNIT_ASSERT( cont.count(1) == 2 );
+ CPPUNIT_ASSERT( cont.count(5) == 0 );
+
+ CPPUNIT_ASSERT( cont.find(2) != cont.end() );
+ CPPUNIT_ASSERT( cont.equal_range(1) != make_pair(cont.end(), cont.end()) );
+
+ Container const& ccont = cont;
+ CPPUNIT_ASSERT( ccont.find(2) != ccont.end() );
+ CPPUNIT_ASSERT( ccont.bucket(2) == ccont.bucket(2) );
+ CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.end(), ccont.end()) );
+ }
+
+ {
+ typedef unordered_multiset<Key const volatile*, KeyHashPtr, KeyEqualPtr> Container;
+ Container cont;
+ Key key1(1), key2(2), key3(3), key4(4);
+ cont.insert(&key1);
+ cont.insert(&key2);
+ cont.insert(&key3);
+ cont.insert(&key4);
+
+ CPPUNIT_ASSERT( cont.count(1) == 1 );
+ CPPUNIT_ASSERT( cont.count(5) == 0 );
+
+ CPPUNIT_ASSERT( cont.find(2) != cont.end() );
+ CPPUNIT_ASSERT( cont.equal_range(2) != make_pair(cont.begin(), cont.end()) );
+
+ Container const& ccont = cont;
+ CPPUNIT_ASSERT( ccont.find(2) != ccont.end() );
+ CPPUNIT_ASSERT( ccont.bucket(2) == ccont.bucket(2) );
+ CPPUNIT_ASSERT( ccont.equal_range(2) != make_pair(ccont.begin(), ccont.end()) );
+ }
+#endif
+}
+
+#if defined (STLPORT) && \
+ (!defined (_STLP_USE_PTR_SPECIALIZATIONS) || defined (_STLP_CLASS_PARTIAL_SPECIALIZATION))
+# if !defined (__DMC__)
+/* Simple compilation test: Check that nested types like iterator
+ * can be access even if type used to instanciate container is not
+ * yet completely defined.
+ */
+class IncompleteClass
+{
+ unordered_set<IncompleteClass> usinstances;
+ typedef unordered_set<IncompleteClass>::iterator usit;
+ unordered_multiset<IncompleteClass> usminstances;
+ typedef unordered_multiset<IncompleteClass>::iterator usmit;
+
+ unordered_map<IncompleteClass, IncompleteClass> uminstances;
+ typedef unordered_map<IncompleteClass, IncompleteClass>::iterator umit;
+ unordered_multimap<IncompleteClass, IncompleteClass> umminstances;
+ typedef unordered_multimap<IncompleteClass, IncompleteClass>::iterator ummit;
+};
+# endif
+#endif
diff --git a/sources/android/stlport/test/unit/utility_header_test.cpp b/sources/android/stlport/test/unit/utility_header_test.cpp
new file mode 100644
index 0000000..78d67fb
--- /dev/null
+++ b/sources/android/stlport/test/unit/utility_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <utility>
diff --git a/sources/android/stlport/test/unit/valarray_header_test.cpp b/sources/android/stlport/test/unit/valarray_header_test.cpp
new file mode 100644
index 0000000..f736264
--- /dev/null
+++ b/sources/android/stlport/test/unit/valarray_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <valarray>
diff --git a/sources/android/stlport/test/unit/valarray_test.cpp b/sources/android/stlport/test/unit/valarray_test.cpp
new file mode 100644
index 0000000..87ee3dc
--- /dev/null
+++ b/sources/android/stlport/test/unit/valarray_test.cpp
@@ -0,0 +1,121 @@
+#include <valarray>
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class ValarrayTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(ValarrayTest);
+ CPPUNIT_TEST(transcendentals);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void transcendentals();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(ValarrayTest);
+
+//
+// tests implementation
+//
+// For the moment this test is just a complitation test
+// everyone is welcome to do a real good unit test for
+// valarray functionality.
+void ValarrayTest::transcendentals()
+{
+#ifdef __SUNPRO_CC
+ using std::abs;
+#endif
+ {
+ valarray<double> darray;
+ valarray<double> tmp;
+ tmp = abs(darray);
+ tmp = acos(darray);
+ tmp = asin(darray);
+ tmp = atan(darray);
+ tmp = atan2(darray, tmp);
+ tmp = atan2(1.0, darray);
+ tmp = atan2(darray, 1.0);
+ tmp = cos(darray);
+ tmp = cosh(darray);
+ tmp = sin(darray);
+ tmp = sinh(darray);
+ tmp = tan(darray);
+#if !defined (STLPORT) || !defined (_STLP_USING_PLATFORM_SDK_COMPILER) || !defined (_M_AMD64)
+ tmp = tanh(darray);
+#endif
+ tmp = exp(darray);
+ tmp = log(darray);
+ tmp = log10(darray);
+ tmp = pow(darray, tmp);
+ tmp = pow(1.0, darray);
+ tmp = pow(darray, 1.0);
+ tmp = sqrt(darray);
+ }
+ {
+ valarray<float> farray;
+ valarray<float> tmp;
+ tmp = abs(farray);
+ tmp = acos(farray);
+ tmp = asin(farray);
+ tmp = atan(farray);
+ tmp = atan2(farray, tmp);
+ tmp = atan2(1.0f, farray);
+ tmp = atan2(farray, 1.0f);
+ tmp = cos(farray);
+ tmp = cosh(farray);
+ tmp = sin(farray);
+ tmp = sinh(farray);
+ tmp = tan(farray);
+#if !defined (STLPORT) || !defined (_STLP_USING_PLATFORM_SDK_COMPILER) || !defined (_M_AMD64)
+ tmp = tanh(farray);
+#endif
+ tmp = exp(farray);
+ tmp = log(farray);
+ tmp = log10(farray);
+ tmp = pow(farray, tmp);
+ tmp = pow(1.0f, farray);
+ tmp = pow(farray, 1.0f);
+ tmp = sqrt(farray);
+ }
+#if !defined (STLPORT) || !defined (_STLP_NO_LONG_DOUBLE)
+ {
+ valarray<long double> ldarray;
+ valarray<long double> tmp;
+ tmp = abs(ldarray);
+ tmp = acos(ldarray);
+ tmp = asin(ldarray);
+ tmp = atan(ldarray);
+ tmp = atan2(ldarray, tmp);
+ tmp = atan2(1.0l, ldarray);
+ tmp = atan2(ldarray, 1.0l);
+ tmp = cos(ldarray);
+ tmp = cosh(ldarray);
+ tmp = sin(ldarray);
+ tmp = sinh(ldarray);
+ tmp = tan(ldarray);
+# if !defined (STLPORT) || !defined (_STLP_USING_PLATFORM_SDK_COMPILER) || !defined (_M_AMD64)
+ tmp = tanh(ldarray);
+# endif
+ tmp = exp(ldarray);
+ tmp = log(ldarray);
+ tmp = log10(ldarray);
+ tmp = pow(ldarray, tmp);
+ tmp = pow(1.0l, ldarray);
+ tmp = pow(ldarray, 1.0l);
+ tmp = sqrt(ldarray);
+ }
+#endif
+ valarray<double> v0(2, 10);
+ valarray<double> v1(v0[slice(0, 1, 5)]);
+ v0[slice(0, 1, 5)] = 5;
+ valarray<double> v2(v0[gslice()]);
+ //valarray<double> v3(v0[valarray<bool>()]);
+ valarray<double> v4(v0[valarray<size_t>()]);
+}
diff --git a/sources/android/stlport/test/unit/vector_header_test.cpp b/sources/android/stlport/test/unit/vector_header_test.cpp
new file mode 100644
index 0000000..69d2bfa
--- /dev/null
+++ b/sources/android/stlport/test/unit/vector_header_test.cpp
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <vector>
diff --git a/sources/android/stlport/test/unit/vector_test.cpp b/sources/android/stlport/test/unit/vector_test.cpp
new file mode 100644
index 0000000..a23ba1d
--- /dev/null
+++ b/sources/android/stlport/test/unit/vector_test.cpp
@@ -0,0 +1,553 @@
+//Has to be first for StackAllocator swap overload to be taken
+//into account (at least using GCC 4.0.1)
+#include "stack_allocator.h"
+
+#include <vector>
+#include <algorithm>
+#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+# include <stdexcept>
+#endif
+
+#include "cppunit/cppunit_proxy.h"
+
+#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
+using namespace std;
+#endif
+
+//
+// TestCase class
+//
+class VectorTest : public CPPUNIT_NS::TestCase
+{
+ CPPUNIT_TEST_SUITE(VectorTest);
+ CPPUNIT_TEST(vec_test_1);
+ CPPUNIT_TEST(vec_test_2);
+ CPPUNIT_TEST(vec_test_3);
+ CPPUNIT_TEST(vec_test_4);
+ CPPUNIT_TEST(vec_test_5);
+ CPPUNIT_TEST(vec_test_6);
+ CPPUNIT_TEST(vec_test_7);
+ CPPUNIT_TEST(capacity);
+ CPPUNIT_TEST(at);
+ CPPUNIT_TEST(pointer);
+ CPPUNIT_TEST(auto_ref);
+ CPPUNIT_TEST(allocator_with_state);
+ CPPUNIT_TEST(iterators);
+#if defined (STLPORT) && defined (_STLP_NO_MEMBER_TEMPLATES)
+ CPPUNIT_IGNORE;
+#endif
+ CPPUNIT_TEST(optimizations_check);
+ CPPUNIT_TEST(assign_check);
+ CPPUNIT_STOP_IGNORE;
+ CPPUNIT_TEST(ebo);
+ CPPUNIT_TEST_SUITE_END();
+
+protected:
+ void vec_test_1();
+ void vec_test_2();
+ void vec_test_3();
+ void vec_test_4();
+ void vec_test_5();
+ void vec_test_6();
+ void vec_test_7();
+ void capacity();
+ void at();
+ void pointer();
+ void auto_ref();
+ void allocator_with_state();
+ void iterators();
+ void optimizations_check();
+ void assign_check();
+ void ebo();
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(VectorTest);
+
+//
+// tests implementation
+//
+void VectorTest::vec_test_1()
+{
+ vector<int> v1; // Empty vector of integers.
+
+ CPPUNIT_ASSERT( v1.empty() == true );
+ CPPUNIT_ASSERT( v1.size() == 0 );
+
+ // CPPUNIT_ASSERT( v1.max_size() == INT_MAX / sizeof(int) );
+ // cout << "max_size = " << v1.max_size() << endl;
+ v1.push_back(42); // Add an integer to the vector.
+
+ CPPUNIT_ASSERT( v1.size() == 1 );
+
+ CPPUNIT_ASSERT( v1[0] == 42 );
+
+ {
+ vector<vector<int> > vect(10);
+ vector<vector<int> >::iterator it(vect.begin()), end(vect.end());
+ for (; it != end; ++it) {
+ CPPUNIT_ASSERT( (*it).empty() );
+ CPPUNIT_ASSERT( (*it).size() == 0 );
+ CPPUNIT_ASSERT( (*it).capacity() == 0 );
+ CPPUNIT_ASSERT( (*it).begin() == (*it).end() );
+ }
+ }
+}
+
+void VectorTest::vec_test_2()
+{
+ vector<double> v1; // Empty vector of doubles.
+ v1.push_back(32.1);
+ v1.push_back(40.5);
+ vector<double> v2; // Another empty vector of doubles.
+ v2.push_back(3.56);
+
+ CPPUNIT_ASSERT( v1.size() == 2 );
+ CPPUNIT_ASSERT( v1[0] == 32.1 );
+ CPPUNIT_ASSERT( v1[1] == 40.5 );
+
+ CPPUNIT_ASSERT( v2.size() == 1 );
+ CPPUNIT_ASSERT( v2[0] == 3.56 );
+ size_t v1Cap = v1.capacity();
+ size_t v2Cap = v2.capacity();
+
+ v1.swap(v2); // Swap the vector's contents.
+
+ CPPUNIT_ASSERT( v1.size() == 1 );
+ CPPUNIT_ASSERT( v1.capacity() == v2Cap );
+ CPPUNIT_ASSERT( v1[0] == 3.56 );
+
+ CPPUNIT_ASSERT( v2.size() == 2 );
+ CPPUNIT_ASSERT( v2.capacity() == v1Cap );
+ CPPUNIT_ASSERT( v2[0] == 32.1 );
+ CPPUNIT_ASSERT( v2[1] == 40.5 );
+
+ v2 = v1; // Assign one vector to another.
+
+ CPPUNIT_ASSERT( v2.size() == 1 );
+ CPPUNIT_ASSERT( v2[0] == 3.56 );
+}
+
+void VectorTest::vec_test_3()
+{
+ typedef vector<char> vec_type;
+
+ vec_type v1; // Empty vector of characters.
+ v1.push_back('h');
+ v1.push_back('i');
+
+ CPPUNIT_ASSERT( v1.size() == 2 );
+ CPPUNIT_ASSERT( v1[0] == 'h' );
+ CPPUNIT_ASSERT( v1[1] == 'i' );
+
+ vec_type v2(v1.begin(), v1.end());
+ v2[1] = 'o'; // Replace second character.
+
+ CPPUNIT_ASSERT( v2.size() == 2 );
+ CPPUNIT_ASSERT( v2[0] == 'h' );
+ CPPUNIT_ASSERT( v2[1] == 'o' );
+
+ CPPUNIT_ASSERT( (v1 == v2) == false );
+
+ CPPUNIT_ASSERT( (v1 < v2) == true );
+}
+
+void VectorTest::vec_test_4()
+{
+ vector<int> v(4);
+
+ v[0] = 1;
+ v[1] = 4;
+ v[2] = 9;
+ v[3] = 16;
+
+ CPPUNIT_ASSERT( v.front() == 1 );
+ CPPUNIT_ASSERT( v.back() == 16 );
+
+ v.push_back(25);
+
+ CPPUNIT_ASSERT( v.back() == 25 );
+ CPPUNIT_ASSERT( v.size() == 5 );
+
+ v.pop_back();
+
+ CPPUNIT_ASSERT( v.back() == 16 );
+ CPPUNIT_ASSERT( v.size() == 4 );
+}
+
+void VectorTest::vec_test_5()
+{
+ int array [] = { 1, 4, 9, 16 };
+
+ vector<int> v(array, array + 4);
+
+ CPPUNIT_ASSERT( v.size() == 4 );
+
+ CPPUNIT_ASSERT( v[0] == 1 );
+ CPPUNIT_ASSERT( v[1] == 4 );
+ CPPUNIT_ASSERT( v[2] == 9 );
+ CPPUNIT_ASSERT( v[3] == 16 );
+}
+
+void VectorTest::vec_test_6()
+{
+ int array [] = { 1, 4, 9, 16, 25, 36 };
+
+ vector<int> v(array, array + 6);
+ vector<int>::iterator vit;
+
+ CPPUNIT_ASSERT( v.size() == 6 );
+ CPPUNIT_ASSERT( v[0] == 1 );
+ CPPUNIT_ASSERT( v[1] == 4 );
+ CPPUNIT_ASSERT( v[2] == 9 );
+ CPPUNIT_ASSERT( v[3] == 16 );
+ CPPUNIT_ASSERT( v[4] == 25 );
+ CPPUNIT_ASSERT( v[5] == 36 );
+
+ vit = v.erase( v.begin() ); // Erase first element.
+ CPPUNIT_ASSERT( *vit == 4 );
+
+ CPPUNIT_ASSERT( v.size() == 5 );
+ CPPUNIT_ASSERT( v[0] == 4 );
+ CPPUNIT_ASSERT( v[1] == 9 );
+ CPPUNIT_ASSERT( v[2] == 16 );
+ CPPUNIT_ASSERT( v[3] == 25 );
+ CPPUNIT_ASSERT( v[4] == 36 );
+
+ vit = v.erase(v.end() - 1); // Erase last element.
+ CPPUNIT_ASSERT( vit == v.end() );
+
+ CPPUNIT_ASSERT( v.size() == 4 );
+ CPPUNIT_ASSERT( v[0] == 4 );
+ CPPUNIT_ASSERT( v[1] == 9 );
+ CPPUNIT_ASSERT( v[2] == 16 );
+ CPPUNIT_ASSERT( v[3] == 25 );
+
+
+ v.erase(v.begin() + 1, v.end() - 1); // Erase all but first and last.
+
+ CPPUNIT_ASSERT( v.size() == 2 );
+ CPPUNIT_ASSERT( v[0] == 4 );
+ CPPUNIT_ASSERT( v[1] == 25 );
+
+}
+
+void VectorTest::vec_test_7()
+{
+ int array1 [] = { 1, 4, 25 };
+ int array2 [] = { 9, 16 };
+
+ vector<int> v(array1, array1 + 3);
+ vector<int>::iterator vit;
+ vit = v.insert(v.begin(), 0); // Insert before first element.
+ CPPUNIT_ASSERT( *vit == 0 );
+
+ vit = v.insert(v.end(), 36); // Insert after last element.
+ CPPUNIT_ASSERT( *vit == 36 );
+
+ CPPUNIT_ASSERT( v.size() == 5 );
+ CPPUNIT_ASSERT( v[0] == 0 );
+ CPPUNIT_ASSERT( v[1] == 1 );
+ CPPUNIT_ASSERT( v[2] == 4 );
+ CPPUNIT_ASSERT( v[3] == 25 );
+ CPPUNIT_ASSERT( v[4] == 36 );
+
+ // Insert contents of array2 before fourth element.
+ v.insert(v.begin() + 3, array2, array2 + 2);
+
+ CPPUNIT_ASSERT( v.size() == 7 );
+
+ CPPUNIT_ASSERT( v[0] == 0 );
+ CPPUNIT_ASSERT( v[1] == 1 );
+ CPPUNIT_ASSERT( v[2] == 4 );
+ CPPUNIT_ASSERT( v[3] == 9 );
+ CPPUNIT_ASSERT( v[4] == 16 );
+ CPPUNIT_ASSERT( v[5] == 25 );
+ CPPUNIT_ASSERT( v[6] == 36 );
+
+ v.clear();
+ CPPUNIT_ASSERT( v.empty() );
+
+ v.insert(v.begin(), 5, 10);
+ CPPUNIT_ASSERT( v.size() == 5 );
+ CPPUNIT_ASSERT( v[0] == 10 );
+ CPPUNIT_ASSERT( v[1] == 10 );
+ CPPUNIT_ASSERT( v[2] == 10 );
+ CPPUNIT_ASSERT( v[3] == 10 );
+ CPPUNIT_ASSERT( v[4] == 10 );
+
+ /*
+ {
+ vector<float> vf(2.0f, 3.0f);
+ CPPUNIT_ASSERT( vf.size() == 2 );
+ CPPUNIT_ASSERT( vf.front() == 3.0f );
+ CPPUNIT_ASSERT( vf.back() == 3.0f );
+ }
+ */
+}
+
+struct TestStruct
+{
+ unsigned int a[3];
+};
+
+void VectorTest::capacity()
+{
+ {
+ vector<int> v;
+
+ CPPUNIT_ASSERT( v.capacity() == 0 );
+ v.push_back(42);
+ CPPUNIT_ASSERT( v.capacity() >= 1 );
+ v.reserve(5000);
+ CPPUNIT_ASSERT( v.capacity() >= 5000 );
+ }
+
+ {
+ //Test that used to generate an assertion when using __debug_alloc.
+ vector<TestStruct> va;
+ va.reserve(1);
+ va.reserve(2);
+ }
+}
+
+void VectorTest::at() {
+ vector<int> v;
+ vector<int> const& cv = v;
+
+ v.push_back(10);
+ CPPUNIT_ASSERT( v.at(0) == 10 );
+ v.at(0) = 20;
+ CPPUNIT_ASSERT( cv.at(0) == 20 );
+
+#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)
+ try {
+ v.at(1) = 20;
+ CPPUNIT_FAIL;
+ }
+ catch (out_of_range const&) {
+ }
+ catch (...) {
+ CPPUNIT_FAIL;
+ }
+#endif
+}
+
+void VectorTest::pointer()
+{
+ vector<int *> v1;
+ vector<int *> v2 = v1;
+ vector<int *> v3;
+
+ v3.insert( v3.end(), v1.begin(), v1.end() );
+}
+
+void VectorTest::auto_ref()
+{
+ vector<int> ref;
+ for (int i = 0; i < 5; ++i) {
+ ref.push_back(i);
+ }
+
+ vector<vector<int> > v_v_int(1, ref);
+ v_v_int.push_back(v_v_int[0]);
+ v_v_int.push_back(ref);
+ v_v_int.push_back(v_v_int[0]);
+ v_v_int.push_back(v_v_int[0]);
+ v_v_int.push_back(ref);
+
+ vector<vector<int> >::iterator vvit(v_v_int.begin()), vvitEnd(v_v_int.end());
+ for (; vvit != vvitEnd; ++vvit) {
+ CPPUNIT_ASSERT( *vvit == ref );
+ }
+
+ /*
+ * Forbidden by the Standard:
+ v_v_int.insert(v_v_int.end(), v_v_int.begin(), v_v_int.end());
+ for (vvit = v_v_int.begin(), vvitEnd = v_v_int.end();
+ vvit != vvitEnd; ++vvit) {
+ CPPUNIT_ASSERT( *vvit == ref );
+ }
+ */
+}
+
+void VectorTest::allocator_with_state()
+ {
+ char buf1[1024];
+ StackAllocator<int> stack1(buf1, buf1 + sizeof(buf1));
+
+ char buf2[1024];
+ StackAllocator<int> stack2(buf2, buf2 + sizeof(buf2));
+
+ {
+ typedef vector<int, StackAllocator<int> > VectorInt;
+ VectorInt vint1(10, 0, stack1);
+ VectorInt vint1Cpy(vint1);
+
+ VectorInt vint2(10, 1, stack2);
+ VectorInt vint2Cpy(vint2);
+
+ vint1.swap(vint2);
+
+ CPPUNIT_ASSERT( vint1.get_allocator().swaped() );
+ CPPUNIT_ASSERT( vint2.get_allocator().swaped() );
+
+ CPPUNIT_ASSERT( vint1 == vint2Cpy );
+ CPPUNIT_ASSERT( vint2 == vint1Cpy );
+ CPPUNIT_ASSERT( vint1.get_allocator() == stack2 );
+ CPPUNIT_ASSERT( vint2.get_allocator() == stack1 );
+ }
+ CPPUNIT_ASSERT( stack1.ok() );
+ CPPUNIT_ASSERT( stack2.ok() );
+ }
+
+struct Point {
+ int x, y;
+};
+
+struct PointEx : public Point {
+ PointEx() : builtFromBase(false) {}
+ PointEx(const Point&) : builtFromBase(true) {}
+
+ bool builtFromBase;
+};
+
+#if defined (STLPORT)
+# if defined (_STLP_USE_NAMESPACES)
+namespace std {
+# endif
+ _STLP_TEMPLATE_NULL
+ struct __type_traits<PointEx> {
+ typedef __false_type has_trivial_default_constructor;
+ typedef __true_type has_trivial_copy_constructor;
+ typedef __true_type has_trivial_assignment_operator;
+ typedef __true_type has_trivial_destructor;
+ typedef __true_type is_POD_type;
+ };
+# if defined (_STLP_USE_NAMESPACES)
+}
+# endif
+#endif
+
+//This test check that vector implementation do not over optimize
+//operation as PointEx copy constructor is trivial
+void VectorTest::optimizations_check()
+{
+#if !defined (STLPORT) || !defined (_STLP_NO_MEMBER_TEMPLATES)
+ vector<Point> v1(1);
+ CPPUNIT_ASSERT( v1.size() == 1 );
+
+ vector<PointEx> v2(v1.begin(), v1.end());
+ CPPUNIT_ASSERT( v2.size() == 1 );
+ CPPUNIT_ASSERT( v2[0].builtFromBase == true );
+#endif
+}
+
+void VectorTest::assign_check()
+{
+#if !defined (STLPORT) || !defined (_STLP_NO_MEMBER_TEMPLATES)
+ vector<int> v(3,1);
+ int array[] = { 1, 2, 3, 4, 5 };
+
+ v.assign( array, array + 5 );
+ CPPUNIT_CHECK( v[4] == 5 );
+ CPPUNIT_CHECK( v[0] == 1 );
+ CPPUNIT_CHECK( v[1] == 2 );
+#endif
+}
+
+void VectorTest::iterators()
+{
+ vector<int> vint(10, 0);
+ vector<int> const& crvint = vint;
+
+ CPPUNIT_ASSERT( vint.begin() == vint.begin() );
+ CPPUNIT_ASSERT( crvint.begin() == vint.begin() );
+ CPPUNIT_ASSERT( vint.begin() == crvint.begin() );
+ CPPUNIT_ASSERT( crvint.begin() == crvint.begin() );
+
+ CPPUNIT_ASSERT( vint.begin() != vint.end() );
+ CPPUNIT_ASSERT( crvint.begin() != vint.end() );
+ CPPUNIT_ASSERT( vint.begin() != crvint.end() );
+ CPPUNIT_ASSERT( crvint.begin() != crvint.end() );
+
+ CPPUNIT_ASSERT( vint.rbegin() == vint.rbegin() );
+ // Not Standard:
+ //CPPUNIT_ASSERT( vint.rbegin() == crvint.rbegin() );
+ //CPPUNIT_ASSERT( crvint.rbegin() == vint.rbegin() );
+ CPPUNIT_ASSERT( crvint.rbegin() == crvint.rbegin() );
+
+ CPPUNIT_ASSERT( vint.rbegin() != vint.rend() );
+ // Not Standard:
+ //CPPUNIT_ASSERT( vint.rbegin() != crvint.rend() );
+ //CPPUNIT_ASSERT( crvint.rbegin() != vint.rend() );
+ CPPUNIT_ASSERT( crvint.rbegin() != crvint.rend() );
+}
+
+
+#if !defined (STLPORT) || \
+ !defined (_STLP_USE_PTR_SPECIALIZATIONS) || defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+/* Simple compilation test: Check that nested types like iterator
+ * can be access even if type used to instanciate container is not
+ * yet completely defined.
+ */
+class IncompleteClass
+{
+ vector<IncompleteClass> instances;
+ typedef vector<IncompleteClass>::iterator it;
+};
+#endif
+
+#if defined (STLPORT)
+# define NOTHROW _STLP_NOTHROW
+#else
+# define NOTHROW throw()
+#endif
+
+/* This allocator implementation purpose is simply to break some
+ * internal STLport mecanism specific to the STLport own allocator
+ * implementation. */
+template <class _Tp>
+struct NotSTLportAllocator : public allocator<_Tp> {
+#if !defined (STLPORT) || defined (_STLP_MEMBER_TEMPLATE_CLASSES)
+ template <class _Tp1> struct rebind {
+ typedef NotSTLportAllocator<_Tp1> other;
+ };
+#endif
+ NotSTLportAllocator() NOTHROW {}
+#if !defined (STLPORT) || defined (_STLP_MEMBER_TEMPLATES)
+ template <class _Tp1> NotSTLportAllocator(const NotSTLportAllocator<_Tp1>&) NOTHROW {}
+#endif
+ NotSTLportAllocator(const NotSTLportAllocator<_Tp>&) NOTHROW {}
+ ~NotSTLportAllocator() NOTHROW {}
+};
+
+/* This test check a potential issue with empty base class
+ * optimization. Some compilers (VC6) do not implement it
+ * correctly resulting ina wrong behavior. */
+void VectorTest::ebo()
+{
+ // We use heap memory as test failure can corrupt vector internal
+ // representation making executable crash on vector destructor invocation.
+ // We prefer a simple memory leak, internal corruption should be reveal
+ // by size or capacity checks.
+ typedef vector<int, NotSTLportAllocator<int> > V;
+ V *pv1 = new V(1, 1);
+ V *pv2 = new V(10, 2);
+
+ size_t v1Capacity = pv1->capacity();
+ size_t v2Capacity = pv2->capacity();
+
+ pv1->swap(*pv2);
+
+ CPPUNIT_ASSERT( pv1->size() == 10 );
+ CPPUNIT_ASSERT( pv1->capacity() == v2Capacity );
+ CPPUNIT_ASSERT( (*pv1)[5] == 2 );
+
+ CPPUNIT_ASSERT( pv2->size() == 1 );
+ CPPUNIT_ASSERT( pv2->capacity() == v1Capacity );
+ CPPUNIT_ASSERT( (*pv2)[0] == 1 );
+
+ delete pv2;
+ delete pv1;
+}
+
diff --git a/sources/android/stlport/test/unit/wchar_header_test.c b/sources/android/stlport/test/unit/wchar_header_test.c
new file mode 100644
index 0000000..36376fe
--- /dev/null
+++ b/sources/android/stlport/test/unit/wchar_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <wchar.h>
diff --git a/sources/android/stlport/test/unit/wctype_header_test.c b/sources/android/stlport/test/unit/wctype_header_test.c
new file mode 100644
index 0000000..639878c
--- /dev/null
+++ b/sources/android/stlport/test/unit/wctype_header_test.c
@@ -0,0 +1,8 @@
+/* This test purpose is simply to check Standard header independancy that
+ * is to say that the header can be included alone without any previous
+ * include.
+ * Additionnaly, for C Standard headers that STLport expose, it can also be
+ * used to check that files included by those headers are compatible with
+ * pure C compilers.
+ */
+#include <wctype.h>
