Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-06-28 08:51:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

[STLPORT]

Browse source 
Copy stlport from cmake branch 3/3

svn path=/trunk/; revision=51780
This commit is contained in:
Timo Kreuzer 2011-05-16 12:58:52 +00:00
parent 1eeb11da5f
commit e89305e733
320 changed files with 48753 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

554
reactos/lib/3rdparty/stlport/doc/FAQ vendored Normal file
View file

@ -0,0 +1,554 @@
Content
Q1 About STLport and availability
Q1.0 What is STLport?
Q1.1 What are the benefits from using STLport?
Q1.2 What versions of STLport are available?
Q1.3 Where is the documentation or user guide?
Q1.4 What is the version policy?
Q2 General
Q2.0 Do I need a C++ compiler?
Q2.1 Do I need runtime libraries from C++ compiler?
Q2.2 Can I use containers and algorithms from STLport and iostreams from
library that ship with my compiler?
Q2.3 Can I mix STL implementations in my project?
Q2.4 When I switch to STLport in my application, I get errors. Is STLport
so bad?
Q3 Building
Q3.0 On my XXXX Linux n.n g++ headers are in /usr/include/g++, but they
are looked for in /usr/include/3.3.1. Is it a STLport bug?
Q3.1 Do I need to build library to use STLport?
Q3.2 During library compilation with MS VC++ 6.0 I see following error report:...
Q3.3 Has anybody succeeded building STLport on OS Y with compiler K n.n?
Q3.4 Does STLport support cross-compilation?
Q4 Installation
Q4.1 I tried "make -f gcc.mak install", but it install nothing into
/usr/local/. How I can install headers into /usr/local/include and
libs into /usr/local/lib?
Q5 Bug report
Q5.0 I found a bug, how can I report about it?
Q6 Design
Q6.0 In STLport, files like locale.h, setjmp.h, stdlib.h, etc.,
do nothing except include native headers. Why are these files present in STLport?
Q6.1 Is STLport a replacement for headers and libraries that shipout
with compiler?
Q6.2 My tool detects memory leaks in applications with STLport. Is this leak
from STLport?
Q6.3 When running unit tests, I have errors in LocaleTest test fixture, how bad
is it?
Q6.4 set or multiset iterators are immutable like const_iterators, why ?
Answers
========================================================================
Q1.0 What is STLport?
A1.0 STLport is an implementation of the C++ Standard Library, as described
in the INTERNATIONAL STANDARD ISO/IEC 14882:1998(E) and latest
ISO/IEC 14882:2003(E).
========================================================================
Q1.1 What are the benefits from using STLport?
A1.1
- For multiplatform/multicompilers project a coherent Standard Library
implementation.
- An easy to use STL safe mode detecting bad use of containers and
iterators.
- Some original optimizations: template expression for string
concatenation, short string optimization, move semantic for STL containers
combination like vector of vector, an efficient std::allocator.
========================================================================
Q1.2 What versions of STLport are available?
A1.2
========================================================================
Q1.3 Where is the user guide?
A1.3 There is no real user guide for the moment. You can find some information
in README files in doc folder. As STLport is a C++ Standard library
implementation you might find information you need at the following
locations:
- The ISO/IEC 14882:2003 document you can buy for a very cheap price.
- For STL containers you can use SGI documentation (http://www.sgi.com/tech/stl/).
Beware however, STL described in this document is not identical to the
Standardized version described in ISO/IEC. This documentation can be very
useful for STLport extensions like hash containers (hash_map, hash_set...)
- You can also use the documentation coming with your compiler as most
of the information will also apply to STLport. Take care to description
reported as 'implementation specific'.
========================================================================
Q1.4 What is the version policy?
A1.4 STLport version information contains three numbers like '5.1.0'. '5'
is the major version number, '1' is the minor and '0' is the patch level.
Policy for this numbers are:
- changes in major version number: radical modification, new era.
- changes in minor version number: significant changes, new features,
changes in interface part; switching to an STLport library with a different
minor version require recompilation of all modules depending on it.
- changes in patch level: bugfixes; we keep in mind binary compatibility,
but really can't strongly guarantee it; switching to an STLport library
with different patch level do not require rebuild of modules---rebuilding and
installing the STLport libraries should work; however, as STLport contains
a lot of template code, you should pay attention to fact that all you modules
was build with SAME STLport headers---otherwise problems possible;
recompilation of one part with only rebuilding STLport might not be enough
to get all the fixes in your application so even in this case rebuilding
your modules is advised.
========================================================================
Q2.0 Do I need a C++ compiler?
A2.0 STLport is a C++ library. So the answer is 'yes, you do'.
========================================================================
Q2.1 Do I need runtime libraries from C++ compiler?
A2.1 In any case, the C++ language support from compiler is required
for STLport (operators new, delete, RTTI, exceptions support). That's why
in most cases you need some runtime libraries from the C++ compiler.
========================================================================
Q2.2 Can I use containers and algorithms from STLport and iostreams from
the library that ships with my compiler?
A2.2 The short answer is 'No'.
Indeed co-existence of two implementations possible, but this required
a lot of knowledge as about both implementations, as about compiler and
linkage. This issues should be taken into account both within STL library and
during library usage. In common you can't use both implementation
in the same namespace. So you should separate STL implementations into
different namespaces. But due to absent of compilers that has full-featured
support of Argument Dependent Lookup (ADL) (aka Koenig Lookup), you have no
possibilty to select one or another implementation.
ADL problem.
In wrapper mode, all std references are replaced, thanks a simple macro,
by the stlp_std namespace. Everything from the native compiler std namespace
is injected to the stlp_std namespace with many using std::* directives.
The problem arise when you specialized a standard class for one of your
user types. You do it within the std namespace that, in wrapper mode
becomes the stlp_std namespace. Then this specialization is just invisible
from the native std namespace and won't be used.
Things are somewhat worse: the problem arises even without any explicit
specializations. It is not a bug, but the fact that old compilers just
did not tried to find functions in the namespaces where arguments' classes
are defined (indeed no compilers with full-featured support of ADL yet).
Mix implementation via library.
Let's reduce all the complexity of STLport to some very simple example:
namespace std {
class string
{
public:
class iterator { };
iterator begin();
iterator end();
};
template<class I, class T>
void find(I begin, I end, T value);
} // namespace std
namespace stlport {
using std::string;
template<class I, class T>
void find(I begin, I end, T value);
void gee()
{
string s;
find(s.begin(), s.end(), 10);
}
} // namespace stlport
When a compiler supporting ADL finds the call to `find' within gee() function
it should examine both namespace `stlport' and namespace `std' for
the presence of `find'. It is caused by the fact that s.begin() returns
object of type `std::string::iterator' which obviously defined in namespace
`std' and the heart of ADL is finding functions not only within namespaces
where the call is being made but also in the namespaces where the classes
of arguments are defined...
So, in our example compiler ends with two templates satisfying the call
`find(s.begin(), s.end(), 10)': `std::find' and `stlport::find'.
Since compiler can not choose any one of them it reports ambiguity.
There is another aspect of mix implementations.
Let's consider following code:
a.h:
#include <string>
class A {
public:
A() {}
void push( const string s );
string _str;
};
a.cpp:
#include "a.h"
void A::push( const string s )
{
_str = s;
}
b.cpp:
#include "a.h"
string s;
A a;
void gee()
{
a.push( s );
}
Now build library from a.cpp with string implementation Impl1;
then build application with b.cpp that use string implementation Impl2,
and link with mentioned above library. Compiler will pass. Linker may
pass too. But your application will crash (or randomly crash) either on
call a.push, or on assignment _str = s. This is evident here, but not
evident in real applications.
The conclusion is: "Using Wrapper mode is very hard and we removed support
for it".
========================================================================
Q2.3 Can I mix STL implementations in my project?
A2.3 Yes you can but each implementations will rely in its own namespace
with no direct interaction between them. You will first need to correctly
configure STLport thanks to 2 macros in user_config.h file.
- _STLP_DONT_REDEFINE_STD tells STLport not to define the std macro that is
used to replace std reference in your code with STLport namespace.
- _STLP_WHOLE_NATIVE_STD tells STLport to always include native header each
time a Standard header is included in your code.
Here is a small code sample that do not require any modification in STLport
install:
#define _STLP_DONT_REDEFINE_STD
#define _STLP_WHOLE_NATIVE_STD
#include <string>
void foo()
{
std::string std_str("std");
stlport::string stlport_str("stlport");
stlport_str.append(std_str.begin(), std_str.end());
// Following is wrong because there is no assignment
// operator for stlport::string on std::string.
//std_str = stlport_str;
}
Note: You can use 'std' iterators from native implementation in STLport
template methods like in the 'stlport_str.append' method call above because
STLport is adding the necessary code to interpret native iterators like
STLport iterators. You won't be able however to do the opposite as native
implementation do not know anything about STLport iterators.
========================================================================
Q2.4 When I switch to STLport in my application, I get errors. Is STLport
so bad?
A2.4 Before you post such message, please, check STLport WHITHOUT YOUR code:
- build STLport library
- build STLport unit tests
- run STLport unit tests
If any of above steps fail, please, make sure that you carefully followed
build instructions (in most cases you definitely should reread
instructions and check that you correctly unpack archive in case you see
'file not found' message). Build instructions you can found in files
INSTALL, doc/README.*, build/README*, build/test/unit/README*.
If you are sure, submit bug report here:
https://sourceforge.net/projects/stlport
Don't forget to describe your operational environment, compiler version and
STLport version.
========================================================================
Q3.0 On my XXXX Linux n.n g++ headers are in /usr/include/g++, but they
are looked for in /usr/include/3.3.1. Is it a STLport bug?
A3.0 Path to native compiler headers for GCC correspond to default path
after build/install compiler (i.e. paths from compiler origo).
Package maintainers can use any path by own taste---we can't satisfy
variety of distributions/packages.
So you can:
- fix path in stlport administration config file stlport/stl/config/host.h,
see _STLP_NATIVE_INCLUDE_PATH macro and related.
- create a link to the native compiler headers like expected by STLport
- make request to package maintainer
- build and install compiler
Note: Starting with version 5.2, STLport uses the include_next preprocessing
command to access native headers so you shouldn't experiment this problem
anymore when this feature is supported by your compiler preprocessor.
========================================================================
Q3.1 Do I need to build a library to use STLport?
A3.1 You may omit usage (and, thus building) STLport library, but in this
case you can't use iostreams, locale, complex.
========================================================================
Q3.2 During library compilation with MS VC++ 6.0 I see following error report:
C:\Program Files\Microsoft SDK\Include\.\winbase.h(1123) : error C2733: second C linkage of overloaded function 'InterlockedIncrement' not allowed
C:\Program Files\Microsoft SDK\Include\.\winbase.h(1121) : see declaration of 'InterlockedIncrement'
C:\Program Files\Microsoft SDK\Include\.\winbase.h(1130) : error C2733: second C linkage of overloaded function 'InterlockedDecrement' not allowed
C:\Program Files\Microsoft SDK\Include\.\winbase.h(1128) : see declaration of 'InterlockedDecrement'
C:\Program Files\Microsoft SDK\Include\.\winbase.h(1138) : error C2733: second C linkage of overloaded function 'InterlockedExchange' not allowed
C:\Program Files\Microsoft SDK\Include\.\winbase.h(1135) : see declaration of 'InterlockedExchange'
A3.2 You have a Platform SDK installed. Uncomment line
#define _STLP_NEW_PLATFORM_SDK 1
in the file stlport/stl/config/user_config.h. There is no way to detect SDK
presence during preprocessor stage, which is why you have to make this
change manually.
========================================================================
Q3.3 Has anybody succeeded building STLport on OS S with compiler K n.n?
A3.3 See report about results of regression tests here: build/test/unit/STATUS.
========================================================================
Q3.4 Does STLport support cross-compilation?
A3.4 In case of GCC, use something like following sequence:
(./configure --target=${CROSSTARGET}; cd build/lib; \
export PATH=${BASECROSS}/bin:${PATH}; make -f gcc.mak install-release-shared)
where CROSSTARGET is GCC's cross prefix (something like 'i586-pc-linux-gnu',
if C++ cross compiler named as 'i586-pc-linux-gnu-c++'), BASECROSS is base of
cross-compiler's location (i.e. ${BASECROSS}/bin in case above is a location
of 'i586-pc-linux-gnu-c++').
In case of non-GCC crossecompilers, we need hands-made target system identification.
The sample of such compiler (supported by STLport) is MetroWerks Codewarrior
for Novell Netware (mwccnlm).
========================================================================
Q4.1 I tried "make -f gcc.mak install", but it installs nothing into
/usr/local/. How I can install headers into /usr/local/include and
libs into /usr/local/lib?
A4.1 Installation in any system-wide place is issue of either 'package builder'
or system administrator. He/she should be familiar with building package
procedure and/or understand where headers and libraries should be situated.
The place choice not issue of STLport.
You can just use
(cd ${STLPORT_SRC}/lib; tar cf - . ) | (cd ${TARGET_LIB_DIR}; tar xf - ); \
(cd ${STLPORT_SRC}; tar cf - stlport) | (cd ${TARGET_INCLUDE_DIR}; tar xf - )
Sometimes we will think about 'make install', but not now.
========================================================================
Q5.0 I found a bug, how I can report about it?
A5.0
0. Ensure that this is really a bug (standard violation, incorrect
behaviour with correct usage).
1. Ensure that bug is in STLport, not in your code (you can use _STLP_DEBUG
for that, see stlport/stl/config/user_config.h).
2. Ensure that you correctly built STLport---build and run unit tests
(build/test/unit) first with default settings, then with your settings
(if you changed any).
3. Write a short test that demonstrates the bug.
4. Make sure that this test case is really new, i.e. not covered by unit
tests (test/unit/*).
5. Compare your results with reported runs of unit tests (build/test/unit/STATUS).
6. Write bug description and test here
https://sourceforge.net/projects/stlport
DON'T FORGET TO DESCRIBE:
- OPERATIONAL ENVIRONMENT
- COMPILER VERSION
- STLPORT VERSION
- RESULT OF UNIT TESTS
Keep in mind, that your bug MUST be reproduced by other people, so give
enough information (but compactly, give only essential information).
========================================================================
Q6.0 In STLport files like locale.h, setjmp.h, stdlib.h, etc., do
nothing except include native headers. Why are these files present in STLport?
A6.0 Sometimes native C headers are using C++ ones or are refering
to the std namespace. That's why, if stddef was absent in STLport, then
#include <string>
#include <stddef.h>
may cause problem in following code, because std redefined in the end of
<string> header, and std may be used in stddef.h:
__BEGIN_NAMESPACE_STD
....
__END_NAMESPACE_STD
where __BEGIN_NAMESPACE_STD is defined as 'namespace std {'.
To avoid this, STLport has stddef.h header and provide correct masquerade
for std.
========================================================================
Q6.1 Is STLport a replacement for headers and libraries that shipout
with compiler?
A6.1 In general no. In any case C++ language support from compiler is required
for STLport (operators new, delete, RTTI, exceptions support). STLport also
uses 'native' headers and libraries to take interface to system functions and
variables.
========================================================================
Q6.2 My tool detects memory leaks in application with STLport. Is this leak
from STLport?
A6.2 In most cases these are 'pseudo memory leaks' that some tools
wrongly detect.
In the default compile of STLport, the node allocator is used to allocate
internal memory. The node allocator works by pre-allocating a large chunk of
memory and handing out small memory blocks. The memory chunk is not freed
during running an application that uses STLport (i.e. it is not returned to
the system, but reused inside application).
See also http://www.sgi.com/tech/stl/alloc.html
There are tools like BoundsChecker, Purify or Valgrind that check for memory
leaks, for memory that isn't freed when no longer used. These tools may report
false memory leaks when one uses STLport's node allocator. The memory chunk is
normally freed at application end, but the memory checkers usually report memory
leaks before that point. Another memory problem might be reported when you use
shared libraries (e.g. DLL, this problem specific for Windows DLL model) that
uses STLport internally and are statically link to it. If memory is allocated in
a dll and released in an other then the STLport node allocator will keep the
released memory for a future use. If you do not use this memory then your
application global memory consumption will grow until the app crash even if there
is no real memory leak. This is why you should always use a coherent configuration
everything in dll or everything in static lib.
There are ways to remove the pseudo memory leaks (since the memory is properly
freed at the end of the program, the leaks are just pseudo-ones). You could use
another allocator that is used in STLport. Open the file
"./stlport/stl/config/host.h" and uncomment either one of the following:
_STLP_USE_NEWALLOC enables a simple allocator that uses "new/delete"
_STLP_USE_MALLOC enables a simple allocator that uses "malloc/free"
The new/delete allocator has the advantage of giving an entry point to track
memory starvation, see set_new_handler in your compiler doc or the C++ Standard
for more information.
Alternatively you can define the following symbol, just uncomment it in
"./stlport/stl/config/host.h".
_STLP_LEAKS_PEDANTIC
The symbol forces freeing all memory chunks. Also see the comments around the
symbol in the config file.
Note that you have to recompile STLport AND your application and all of your
dependent libraries if you make any change to the file!
There are also some defines that help in debugging memory problems in STLport.
In _STLP_DEBUG mode, just also define the following symbols, either in
"./stlport/stl/config/user_config.h" or in your project settings:
_STLP_DEBUG_ALLOC
_STLP_DEBUG_UNINITIALIZED
You don't need to rebuild STLport for these options, but you have to rebuild
your application and all of your dependent libraries if you make any change to
the file.
========================================================================
Q6.3 When running unit tests, I have errors in LocaleTest test fixture, how bad
is it?
A6.3 Failures in LocaleTest tests do not mean that your platform/compiler is not
fully supported by STLport. Platform independant localization tests are very hard
to write as Standard localization API has not been design to make unit test easy.
In STLport unit tests suite we have hard coded some expected values. Those values
depends on your OS configuration explaining why sometimes the tests are failing.
========================================================================
Q6.4 set or multiset iterators are immutable like const_iterators, why ?
A6.4 With set or multiset associative containers or even newly introduced
tr1::unordered_set and tr1::unordered_multiset key is confuse with data. It
means that modifying the data is also modifying the key. Modifying the key
might corrupt the container internal data structure so STLport prefer to
make this problem obvious and only return a const access to the key with
immutable iterators. Your solutions are:
- prefer map/multimap and split the key and the data
- use const_cast when you want to change a set/multiset element.

154
reactos/lib/3rdparty/stlport/doc/README.borland vendored Normal file
View file

@ -0,0 +1,154 @@
==================================================
STLport README for Borland C++ compilers.
==================================================
by: Francois Dumont, dums@stlport.com, last edited 20 May 2006
============
Introduction
============
This document describes how STLport can be compiled and used with
Borland compilers.
For any further comments or questions visit STLport mailing lists
http://stlport.sourceforge.net/Maillists.shtml or forums
https://sourceforge.net/forum/?group_id=146814
=============
Prerequisites
=============
To build and use STLport you will need following tools and libraries:
- Borland C++ compiler package 5.5.1 or higher version.
In order to build STLport the Borland compiler and linker have to
be correctly configurated too. That is to say:
* For the Borland compiler bcc32:
In Borland's 'bin' directory (same directory as bcc32.exe), create a
bcc32.cfg file containing the compiler option giving it the path to
native Borland headers:
-I%BORLAND_PATH%\BCC55\include
* For the resource compiler brcc32:
Create an environment variable INCLUDE containing path to native Borland
headers and especially the windows.h file
set INCLUDE=%BORLAND_PATH%\BCC55\include
* For the Borland linker ilink32:
You need to give path to both the Borland libs and Borland PSDK libs.
For that you have to create, in the same directory as ilink32.exe, a
configuration file, ilink32.cfg, that contains:
-L%BORLAND_PATH%\BCC55\lib;%BORLAND_PATH%\BCC55\lib\PSDK
- A GNU make tool. You can get one from www.mingw.org or www.cygwin.com.
See README.mingw or README.cygwin for additional informations.
===================
Configuring STLport
===================
This is intended to be an optional step, if you want to use default
configuration simply jump to next chapter 'Building STLport'. Open a console
and go to the STLport build/lib folder. Run
configure --help
This command will present you the different available build options. Just follow
the instructions to set STLport configuration according your needs. For example,
to set the typical configuration for most Borland compilers, run
configure -c bcc
================
Building STLport
================
This is a step by step description of the actions to take in order to build
and install the STLport libraries:
1. Open a console, you can use a Msys, Cygwin or Windows console.
2. Go to the STLport build/lib folder:
cd C:\STLport\build\lib
3. Run the following command:
make -fbcc.mak install
Where 'make' is the GNU make utility you have installed. The name of
GNU make utility may differ, such as 'mingw32-make'. -f is a make option
telling it which makefile to use. You have of course to choose the
appropriate makefile for your compiler, 'bcc.mak' in our case.
Once the command returns you will have all the necessary import libraries
in STLport's 'lib' folder and DLLs in STLport's 'bin' folder. For a
description of the generated libraries check the FAQ file in the 'doc' folder.
For a quick start guide to the STLport make system, see the README file in the
'build/lib' folder.
===============
Testing STLport
===============
You can use the unit tests to verify STLport behaves correctly. Change into
STLport's 'build/test/unit' folder and type:
make -fbcc.mak install
This will build and install the unit tests with STLport dynamic libraries.
Once the unit tests are built you just need to run them. They can be found
in STLport's bin, bin-g or bin-stlg folders. To rebuild the unit tests
with STLport static libraries, type:
make -fbcc.mak clean
make -fbcc.mak install-static
=============
Using STLport
=============
Adjust your include and link paths in Borland IDE or in the command line config
files. In the include files add the path to STLport's 'stlport' folder. Make sure
it is the first directory listed there. Add STLport's 'lib' folder for the library
files (order of paths doesn't matter here).
Now you should be ready to use STLport.
============
Known limitations
============
1. If you extend a locale facet based on a Standard facet definition you will
have to grant your own facet id defition. Ex extracted from
test/unit/fstream_test.cpp:
#include <locale>
using namespace std;
struct my_state {
char dummy;
};
struct my_traits : public char_traits<char> {
typedef my_state state_type;
typedef fpos<state_type> pos_type;
};
class my_codecvt : public codecvt<char, char, my_state>
{};
// Mandatory locale facet id definition:
template <>
locale::id codecvt<char, char, my_state>::id;
2. If you get a linker memory error, e.g. LME351, it probably means that full
source debugging is enabled and Borland's .TDS file has exceeded the memory
capacity of Borland's linker (ilink32.exe). To resolve this error, check
Borland's website for the latest patch for ilink32.exe. In the alternative,
disable full source debugging in build\Makefiles\gmake\bcc.mak by deleting
the -v option in the OPT settings.
3. For "'uname' is not recognized . . .", see "Configuring STLport" above.

43
reactos/lib/3rdparty/stlport/doc/README.cygwin vendored Normal file
View file

@ -0,0 +1,43 @@
The cygwin platform is used to build STLport with different compilers.
- gcc (native compiler):
Makefile : gcc.mak
Notes:
1. Static builds (archive)
If you use the static version of the STLport libraries you have
to define the _STLP_USE_STATIC_LIB macro in order to have your
executable linked correctly.
2. Link
Under this platform STLport is complete replacement for libstdc++.
It means that when you were linking with libstdc++ (-lstdc++) you only
have to replace it with STLport (-lstlport.5.2 for instance). However
default gcc behavior is to automatically link libstdc++ and a number of
other system libs. To avoid this behavior you have to use the -nodefaultlibs
compiler option and explicitely give all libraries by yourself. See build of
unit tests to see what library you might need, here is the list when this
note was written:
without -mnocygwin option:
-lstlportg.5.2 -lgcc -lm -lc -lpthread -lkernel32
with -mno-cygwin option:
-lstlportg.5.2 -lgcc -lmingw32 -lmingwex -lmsvcrt -lm -lmoldname
-lcoldname -lkernel32
3. No cygwin
To build STLport libraries that do not depend on cygwin1.dll
making them freely redistributable pass the following option to
the configure script:
./configure --with-extra-cflags=-mno-cygwin --with-extra-cxxflags=-mno-cygwin
- Borland C++ compiler

81
reactos/lib/3rdparty/stlport/doc/README.dmc vendored Normal file
View file

@ -0,0 +1,81 @@
==================================================
STLport README for Digital Mars C++ compilers.
==================================================
Build of STLport with Digital Mars C++ compiler is very similar
to the one for Microsoft Visual Studio compiler (see README.msvc).
Below are some additional hints. [DMC users are encouraged to
contribute additional information.]
=============
Prerequisites
=============
- Digital Mars C++ 8.49 or above
- A GNU environment with make tool. Prefer MinGW/MSys to Cygwin because the
latter contains a link command that is also the name of the Digital Mars linker
and you might experiment collision between both commands.
See README.mingw for additional information.
===================
Installing STLport
===================
- STLport directory can be almost anywhere EXCEPT native dm\include directory.
===================
Configuring STLport
===================
- In a console window go to the STLport build\lib folder. Run
configure -c dmc
================
Building STLport
================
- To build STLport libraries:
cd [STLport dir]\build\lib
[mingw32-make] -f dmc.mak install
- To build STLport (dynamic) unit tests:
cd [STLport dir]\build\test\unit
[mingw32-make] -f dmc.mak install
============
Known issues
============
1. typeinfo.h
DMC forces inclusion of typeinfo.h header at the begining of any
translation unit. This breaks the STLport include schema, especially
when building the library. As a workaround STLport typeinfo.h simply
include native DMC header not performing any internal STLport work as
importing things to STLport namespace. As a result typeinfo.h should
never be reference in user code, as it is neither a C nor a C++ header
this is not considered as a major limitation. The C++ Standard header
is typeinfo.
2. link.exe and lib.exe
STLport makefiles for DMC use dm_link and dm_lib instead of link and lib to
avoid conflicts with other vendors' linkers and archivers. To build STLport
with DMC, please copy or rename the following files:
copy dm\bin\link.exe dm\bin\dm_link.exe
copy dm\bin\lib.exe dm\bin\dm_lib.exe
3. Free online version.
If DMC's free online version reports compiler or linker errors, the
solution may be in a free online CD update. Download and unzip all free
CD patches for versions 8.30 and above, in consecutive order, overwriting
previous files. Then install free online version 8.49 or above, overwriting
previous files.

157
reactos/lib/3rdparty/stlport/doc/README.evc3 vendored Normal file
View file

@ -0,0 +1,157 @@
========================================
STLport README for eMbedded Visual C++ 3
========================================
by: Michael Fink, vividos@users.sourceforge.net, last edited 2005-11-15
============
Introduction
============
This document describes how STLport can be compiled and used with Microsoft
eMbedded Visual C++ 3.
For any further comments or questsion visit STLport mailing lists
http://stlport.sourceforge.net/Maillists.shtml or forums
https://sourceforge.net/forum/?group_id=146814
=============
Prerequisites
=============
To build and use STLport you will need following tools and libraries:
- eMbedded Visual C++ 3.0
- latest CVS version of STLport, use info from page
'http://stlport.sourceforge.net/CVS.shtml' to get it.
Note that you may have to get a different branch, please check out the
STLport forum "Announcements" which sourcecode is being worked on.
================
Building STLport
================
Note: if you don't plan to use the iostreams part of STLport (via the define
_STLP_NO_IOSTREAMS), you don't have to build the library. You can skip straight
to the "Using STLport" section.
If you want to compile for the Pocket PC 2002 SDK (which in most cases you want)
be sure to set the PLATFORM environment variable to "Pocket PC 2002", e.g. with
this command:
set PLATFORM=Pocket PC 2002
Open a command line prompt and execute the batch file that sets up compiling
for ARM or x86 processors. These files usually are in a folder like
'C:\Program Files\Windows CE eMbedded Tools\EVC\WCE300\BIN\' and are called
WCEARM.bat and WCEx86.bat. Check if the environment variables are set up
properly after that call. You can also adjust the batch files to have the
PLATFORM variable set automatically.
Go into STLport's 'build\lib' folder and type:
configure.bat -c evc3
The makefiles are configured with the given settings. Call configure.bat with
the --help option to see all options. The program automatically tells you which
command line to use. If you want to install the libraries, add the "install"
target as follows:
nmake /fmsvc.mak install
All libraries (debug, stldebug, release) are now built, static and shared
ones. Import libraries (.lib files) are put in the 'lib\evc3-arm' folder, DLLs
are put in the 'bin\evc3-arm' folder. If you use another target platform, the
name of the folder is changed accordingly, e.g. evc3-x86 for emulator files.
Once STLport is built you can decrease the size of the STLport folder by
removing intermediate build files. This is done with the following command:
nmake /fmsvc.mak clobber
Note: MIPS platform is also available for build, but it may not compile or work
properly. Use with caution!
===============
Testing STLport
===============
You can use the unit tests to verify STLport behaves correctly. Change into
STLports 'build\test\unit' folder and type:
nmake /fmsvc.mak install
If you want to build the unit tests for the emulator, you have to reconfigure
STLport with the configure.bat, as described above.
Once the unit tests are built, upload the binary (found in the 'bin\evc3-arm'
folder) to your device or emulator and start it (the test runs for about 30
seconds, depending on the speed of the device). The file 'stlp_test.txt' is
created in the root folder of the device, which contains the unit test
results. It should report no errors.
=============
Using STLport
=============
Adjust your include and link paths in eVC3 in 'Tools -> Options -> Directories'
and add the paths for all platforms and CPUs on which you want to use STLport.
In the include files add the path to STLport's 'stlport' folder. Make sure it
is the first directory listed there. Add STLport's 'lib\evc3-arm' or
'lib\evc3-x86' (depending on what target you use) folder for the library files
(order of paths doesn't matter here).
There are some preprocessor defines that control usage of the STLport in evc3
projects:
Define the symbol _STLP_USE_STATIC_LIB when you want to statically link against
STLport. The linker will remove unused classes and methods then, saving some
space in the executable.
If you don't want to use the iostreams part of the library, you can specify the
define _STLP_NO_IOSTREAMS. In this mode there is no need to link against the
library.
STLport uses automatic linking to find the proper .lib file. If you want to see
what import library STLport is going to use, define _STLP_VERBOSE_AUTO_LINK.
When not using automatic linking (by specifying _STLP_DONT_USE_AUTO_LINK), you
have to specify the proper .lib file in the Project Settings, on the "link" tab.
The .lib names have the following syntax:
stlport(d|stld)[_static].<STLport-Version>.lib
Examples:
stlport_static.5.0.lib - static release version, Version 5.0.0
stlportd_50.lib - dll debug version, Version 5.0.0
Note that usage of the _STLP_DEBUG mode is currently not recommended for
eMbedded Visual C++ builds using the ARM compiler, due to a compiler bug.
When using STLport together with MFC, be sure to include the MFC headers first,
then include STLport headers, e.g. in your Stdafx.h. This way STLport correctly
recognizes MFC usage. You also can define the macro _STLP_USE_MFC, either in
your project settings or in stlport/stl/config/user_config.h.
Now you should be ready to use STLport.
============
Known issues
============
- Unit Tests in _STLP_DEBUG mode (target 'stldbg-shared') fails in
__stl_debug_engine::_M_detach() for several tests due to unknown reasons.
A compiler bug in the ARM compiler is suspected.
There is currently no workaround for this bug. It is recommended to not use
_STLP_DEBUG mode.
- Resource compiler issue:
The resource compiler is not a C++ compiler, it is a compiler that translates
resource files, i.e. files that describe dialogs, strings, version information
and other parts of the GUI on MS Windows systems.
The problem is that it includes files from the C/C++ include path, and
STLport uses mechanisms the resource compiler can't handle, e.g. using macro
names longer than 31 characters.
The workaround is to guard all affected headers (stdio.h, string.h, stdarg.h,
stdlib.h, ctype.h) against this. The resource compiler is detected by the
macro RC_INVOKED.
- See also README.evc4 issues.

126
reactos/lib/3rdparty/stlport/doc/README.evc4 vendored Normal file
View file

@ -0,0 +1,126 @@
========================================
STLport README for eMbedded Visual C++ 4
========================================
by: Zdenek Nemec, zero@mapfactor.com, last edited 2005-10-17
============
Introduction
============
This document should provide step-by-step guidance for installing, testing and using the STLport library under Windows CE .NET 4.x
(aka Windows Mobile 2003 aka Pocket PC 2003).
For any further comments or questions visit the STLport mailing lists
http://stlport.sourceforge.net/Maillists.shtml or forums
https://sourceforge.net/forum/?group_id=146814
=============
Prerequisites
=============
To build and use the STLport you will need following tools and libraries:
- eMbedded Visual C++ 4.0 SP4
- an SDK for your target platform with RTTI support
================
Building STLport
================
First, make sure that RTTI is available. Not all SDKs that come with eVC4 also include
the necessary libs, but there is a patch for the PPC2003 SDK, available at
http://support.microsoft.com/default.aspx?scid=kb;[LN];830482.
Second, open command line and set proper system variables.
This can be done by using batch files under your 'eMbedded Visual C++' directory(use either WCEemulator.BAT if you want to build STLport for the emulator or WCEARMV4.BAT if you intend to aim an ARM device).
NOTE: If you are using Microsoft's batch files to set system variables check if both WCEROOT and SDKROOT vars are set to correct locations. example:
WCEROOT=C:\Program Files\Microsoft eMbedded C++ 4.0
SDKROOT=C:\Program Files\Windows CE Tools
Third, when you are 100percent sure you've set correctly systems variables go to the STLport/build/lib dir and run the configure.bat with
proper -c option (ie. "-c evc4"),
then invoke following command: 'nmake /fmsvc.mak install' to build the library.
If anything goes wrong check if you met all prerequisities and if you set system vars accordingly to the makfile you are using.
At the end of build process you should have some libs installed in STLport/lib/evc4-arm or STLport/lib/evc4-x86 and dynamic libs in STLport/bin directory.
You might want to repeat all those steps if you would like to have
e.g. both ARM and x86 emulator binaries, just don't forget to do
'nmake /fmsvc.mak clobber' before new build.
Note: MIPS platform is also available for build, but it may not compile or work properly. Use with caution!
===============
Testing STLport
===============
When you successfuly build STLport libs, you should go to STLport/test/unit directory build and run the STLP test suite.
Use 'nmake /fmsvc.mak' and keep in mind that you still have to have proper system variables set!
Once test build has finished upload and run stlp_unit_test.exe to your emulator or device.
Wait for a while (aprox. 2mins) until all tests are done.
You should see two files next to your binary now.
Check stlp_test.txt for any errors. If all tests passed you are ready to deploy STLport.
If some test fails don't worry and check the STLport forum if it's already reported bug or you have found a new one.
=============
Using STLport
=============
Setting up the IDE:
Before you start using STLport you have to set proper include and libraries search paths.
Go to 'Tools'>'Options' menu in your eVC 4.0 and then to 'Directories' tab.
For every platform you want to use STLport add STLport/stlport directory to the FIRST place in 'Include Files'
and STLport/lib directory in 'Library files' section.
Setting up projects:
When using STLport together with MFC, you have to define _STLP_USE_MFC to properly include and use STLport.
By default, exception support is not activated. You can detect this via _CPPUNWIND and activate this via /GX.
Without exception support, e.g. std::bad_alloc is not available, causing compile errors for some code.
Also, there is only one runtime available but the IDE doesn't add the corresponding switch to the command line.
The right switch (selecting a dynamically linked runtime) is IMHO /MD or /MDd. This then also switches STLport to dynamic linking.
Alternatively, you can #define _DLL for your project, which achieves the same but, again IMHO, is a less clean solution.
============
Known issues
============
- The compilers that come with eVC4 are almost bug-to-bug compatible with
the one from VC6, so most workarounds for that compiler apply here, too.
- There is a bug in the MIPS compiler that comes with eVC4 which only surfaces
under certain conditions:
* in release mode with global optimizations on (#pragma optimize("g", on))
* a baseclass has (at least) two pointer members
* a derived class adds no data members
* the derived class' cctor defers to the basclass' compiler-generated cctor
* it is passed as template parameter to a function
The smallest testcase I could come up with is this:
struct base {
void* ptr1;
void* ptr2;
};
struct derived: public base {
derived() {}
derived(const derived& __x): base(__x) {}
};
template<typename SomeType> void function( SomeType st1, SomeType st2) {}
struct test {
derived tmp;
~test() { function(tmp, tmp); }
};
test test;
..which causes an internal compiler error. Removing the base::ptr1, adding data
to derived, making function() a normal function, or turning off optimization
(#pragma optimize("g", off)) all causes the code to compile. This bug affects
iterators of deque and vector<bool>.
- Because of interdependancy between STLport and native Standard library headers
STLport headers should always be included first in your translation unit (.cpp
file). That is to say that:
//Wrong headers order:
#include <windows.h>
#include <cstdlib>
// Correct headers order
#include <cstdlib>
#include <windows.h>

98
reactos/lib/3rdparty/stlport/doc/README.evc8 vendored Normal file
View file

@ -0,0 +1,98 @@
setup VC8 for CE:
------------------
- VC8 doesn't have any setup batchfiles that prepare the environment for compiling
with CE. You can take those from eVC4 and adapt them or write your own. This snippet
should get you going:
rem you need to adapt at least these three
set OSVERSION=WCE500
set PLATFORM=MY_OWN_PLATFORM
set TARGETCPU=MIPSII
rem the compiler is always cl.exe, different compilers are in different paths
set CC=cl.exe
rem obviously, these need to be adjusted to where you installed VS2005 and the SDKs
set VSINSTALLDIR=C:\Programme\Microsoft Visual Studio 8
set SDKROOT=C:\Programme\Windows CE Tools
set PATH=%VSINSTALLDIR%\VC\ce\bin\x86_mips;%VSINSTALLDIR%\VC\bin;%VSINSTALLDIR%\Common7\IDE;%PATH%
set PLATFORMROOT=%SDKROOT%\%OSVERSION%\%PLATFORM%
rem add libs and includes from the SDK
set INCLUDE=%PLATFORMROOT%\include\%TARGETCPU%;%PLATFORMROOT%\MFC\include;%PLATFORMROOT%\ATL\include
set LIB=%PLATFORMROOT%\lib\%TARGETCPU%;%PLATFORMROOT%\MFC\lib\%TARGETCPU%;%PLATFORMROOT%\ATL\lib\%TARGETCPU%
rem add libs that came with VC8
rem Note: there are more libs and includes under ce\atlmfc, not sure if these are needed.
set LIB=%LIB%;%VSINSTALLDIR%\VC\ce\lib\%TARGETCPU%
- The snippet below can be used to build STLport for Pocket PC 2003 (using the
Pocket PC 2003 SDK shipped with Visual Studio 2005, this is the SDK used when
compiling programs from within the IDE):
set OSVERSION=WCE420
set PLATFORM=POCKET PC 2003
set TARGETCPU=ARMV4
rem the compiler is always cl.exe, different compilers are in different paths
set CC=cl.exe
rem obviously, these need to be adjusted to where you installed VS2005
set VSINSTALLDIR=C:\Program Files\Microsoft Visual Studio 8
set SDKROOT=%VSINSTALLDIR%\SmartDevices\SDK
set PATH=%VSINSTALLDIR%\VC\ce\bin\x86_arm;%VSINSTALLDIR%\VC\bin;%VSINSTALLDIR%\Common7\IDE;%PATH%
set PLATFORMROOT=%SDKROOT%\PocketPC2003
rem add libs and includes from the SDK
set INCLUDE=%PLATFORMROOT%\include
set LIB=%PLATFORMROOT%\lib\%TARGETCPU%
rem add libs that came with VC8
set INCLUDE=%INCLUDE%;%VSINSTALLDIR%\VC\ce\atlmfc\include
set LIB=%LIB%;%VSINSTALLDIR%\VC\ce\lib\%TARGETCPU%;%VSINSTALLDIR%\VC\ce\atlmfc\lib\%TARGETCPU%
You should now be able to run cl.exe for the target you expected.
- The cross compilers of VC8 are the same version as for the native target, i.e. MSC14.
- The cross compiler for MIPS has the same bug as mentioned in doc/README.evc4 and
the same workaround applies. However, using 'whole program optimization', it results
in an error in the link phase.
- In order for STLport to recognize which target you are compiling for, you need to have
some macros defined, e.g. for the target architecture. The compilers do that partially on
their own, but not sufficiently. Therefore, STLport requires these defines:
-- These are generally set for CE:
_UNICODE;UNICODE;_WIN32;WIN32;UNDER_CE;WINCE;
-- This one uses an environment variable to set the CE version:
_WIN32_WCE=$(CEVER);
-- These are used to help STLport recognise the target architecture:
$(ARCHFAM);$(_ARCHFAM_);$(INSTRUCTIONSET)
Note that the instructionset is not strictly needed for x86 but definitely for ARM. It
doesn't hurt for x86 though, so I'd always set these in any new project.
-- For release builds:
NDEBUG;
-- For debug builds:
DEBUG;_DEBUG;
-- For debug builds with additional STLport diagnostics:
DEBUG;_DEBUG;_STLP_DEBUG;
-- For MFC applications:
_AFXDLL;
- Further settings:
Code generation: Multithreaded [Debug] DLL
Language: enable RTTI
Optimization: maximise speed and enable whole program optimization for release builds
- Linker settings:
Ignore specific libraries: libc.lib;libcd.lib
Commandline: /SUBSYSTEM:WINDOWSCE
Optimisation: /LTCG for release builds
- Resource compiler:
Define: UNDER_CE;WINCE;_WIN32_WCE=$(CEVER)

95
reactos/lib/3rdparty/stlport/doc/README.evc9 vendored Normal file
View file

@ -0,0 +1,95 @@
setup VC9 for CE:
------------------
- VC9 doesn't have any setup batchfiles that prepare the environment for compiling
with CE. You can take those from eVC4 and adapt them or write your own. This snippet
should get you going:
rem you need to adapt at least these three
set OSVERSION=WCE500
set PLATFORM=MY_OWN_PLATFORM
set TARGETCPU=MIPSII
rem the compiler is always cl.exe, different compilers are in different paths
set CC=cl.exe
rem obviously, these need to be adjusted to where you installed VS2008 and the SDKs
set VSINSTALLDIR=C:\Programme\Microsoft Visual Studio 9.0
set SDKROOT=C:\Programme\Windows CE Tools
set PATH=%VSINSTALLDIR%\VC\ce\bin\x86_mips;%VSINSTALLDIR%\VC\bin;%VSINSTALLDIR%\Common7\IDE;%PATH%
set PLATFORMROOT=%SDKROOT%\%OSVERSION%\%PLATFORM%
rem add libs and includes from the SDK
set INCLUDE=%PLATFORMROOT%\include\%TARGETCPU%;%PLATFORMROOT%\MFC\include;%PLATFORMROOT%\ATL\include
set LIB=%PLATFORMROOT%\lib\%TARGETCPU%;%PLATFORMROOT%\MFC\lib\%TARGETCPU%;%PLATFORMROOT%\ATL\lib\%TARGETCPU%
rem add libs that came with VC9
rem Note: there are more libs and includes under ce\atlmfc, you need to add these
rem instead of the ones in the SDK if you want to use the newer version of ATL/MFC.
set LIB=%LIB%;%VSINSTALLDIR%\VC\ce\lib\%TARGETCPU%
- The snippet below can be used to build STLport for Pocket PC 2003 (using the
Pocket PC 2003 SDK shipped with Visual Studio 2008, this is the SDK used when
compiling programs from within the IDE):
set OSVERSION=WCE420
set PLATFORM=POCKET PC 2003
set TARGETCPU=ARMV4
rem the compiler is always cl.exe, different compilers are in different paths
set CC=cl.exe
rem obviously, these need to be adjusted to where you installed VS2008
set VSINSTALLDIR=C:\Program Files\Microsoft Visual Studio 9.0
set SDKROOT=%VSINSTALLDIR%\SmartDevices\SDK
set PATH=%VSINSTALLDIR%\VC\ce\bin\x86_arm;%VSINSTALLDIR%\VC\bin;%VSINSTALLDIR%\Common7\IDE;%PATH%
set PLATFORMROOT=%SDKROOT%\PocketPC2003
rem add libs and includes from the SDK
set INCLUDE=%PLATFORMROOT%\include
set LIB=%PLATFORMROOT%\lib\%TARGETCPU%
rem add libs that came with VC9
set INCLUDE=%INCLUDE%;%VSINSTALLDIR%\VC\ce\atlmfc\include
set LIB=%LIB%;%VSINSTALLDIR%\VC\ce\lib\%TARGETCPU%;%VSINSTALLDIR%\VC\ce\atlmfc\lib\%TARGETCPU%
You should now be able to run cl.exe for the target you expected.
- The cross compilers of VC9 are the same version as for the native target, i.e. MSC15.
- In order for STLport to recognize which target you are compiling for, you need to have
some macros defined, e.g. for the target architecture. The compilers do that partially on
their own, but not sufficiently. Therefore, STLport requires these defines:
-- These are generally set for CE:
_UNICODE;UNICODE;_WIN32;WIN32;UNDER_CE;WINCE;
-- This one uses an environment variable to set the CE version:
_WIN32_WCE=$(CEVER);
-- These are used to help STLport recognise the target architecture:
$(ARCHFAM);$(_ARCHFAM_);$(INSTRUCTIONSET)
Note that the instructionset is not strictly needed for x86 but definitely for ARM. It
doesn't hurt for x86 though, so I'd always set these in any new project.
-- For release builds:
NDEBUG;
-- For debug builds:
DEBUG;_DEBUG;
-- For debug builds with additional STLport diagnostics:
DEBUG;_DEBUG;_STLP_DEBUG;
-- For MFC applications:
_AFXDLL;
- Further settings:
Code generation: Multithreaded [Debug] DLL
Language: enable RTTI
Optimization: maximise speed and enable whole program optimization for release builds
- Linker settings:
Ignore specific libraries: libc.lib;libcd.lib
Commandline: /SUBSYSTEM:WINDOWSCE
Optimisation: /LTCG for release builds
- Resource compiler:
Define: UNDER_CE;WINCE;_WIN32_WCE=$(CEVER)

19
reactos/lib/3rdparty/stlport/doc/README.intel vendored Normal file
View file

@ -0,0 +1,19 @@
Build of STLport with Intel C++ compiler for Windows is identical
to the one for Microsoft Visual Studio compiler (see README.msvc).
Known issues:
1. If you have bind your Intel C++ compiler to the Visual Studio 6
install and build your application without the -Qvc6 option you might
experiement linking issue concerning 'std::unexpected' missing symbol.
The reason of this problem is that without -Qvc6, ICL adds necessary
code to invoke std::unexpected function when a raised exception is
different to the one specified in a function prototype. As VC6 library
do not contain this symbol ICL cannot find it anywhere.
As a workaround, STLport has its own std::unexpected implementation
that you will find in src/dll_main.cpp. ICL is looking for a static
symbol so if you use STLport static lib ICL will use its std::unexpected
implementation but if you use STLport dynamic lib then ICL won't find
it. You only need then to copy/paste the STLport implementation somewhere
in your implementation and ICL will be happy.

55
reactos/lib/3rdparty/stlport/doc/README.mingw vendored Normal file
View file

@ -0,0 +1,55 @@
The MinGW GNU make command can be used to build STLport with different
compilers
- gcc (native compiler):
Makefile : gcc.mak
Notes:
1. Static library (archive)
If you use the static version of the STLport libraries
you have to define the _STLP_USE_STATIC_LIB macro in order
to have your executable linked correctly.
2. Shell
You will need MSys in order to build STLport.
Be carefull about what make command you are using. STLport comes with a
GNU make build system design for unix like platforms, make files have not
been adapted for the Windows platform. So you have to use the make command
coming with the MinGW package 'mingw32-make' and not the one coming with MSys
that is a portage of the GNU make for Windows.
3. Threading configuration
STLport libraries are built per default in order to be used in a
multithreaded environment. Under MinGW it means that we use the '-mthread'
compiler option. Don't forget to add it to your compiler command line too
if you want to use STLport libraries. You can also ask for not thread
safe libraries using the --no-thread configure script option.
4. Linking
In this environment STLport is almost complete replacement for libstdc++.
It means that when you were linking with libstdc++ (-lstdc++) you only have
to replace it with STLport (-lstlport.5.2 for instance) and with libsupc++
containing language compiler support (lsupc++). However default gcc
behavior is to automatically link libstdc++ and a number of other system libs.
To avoid this behavior you have to use the -nodefaultlibs compiler option and
explicitely give all libraries by yourself. See build of unit tests to see what
library you might need, here is the list when this note was written:
-lstlportg.5.2 -lsupc++ -lgcc_s -lmingw32 -lmingwex -lmsvcrt -lm -lmoldname
-lcoldname -lkernel32
- Borland C++ compiler:
Makefile : bcc.mak
- Digital Mars C++ compiler:
Makefile : dmc.mak

186
reactos/lib/3rdparty/stlport/doc/README.msvc vendored Normal file
View file

@ -0,0 +1,186 @@
==================================================
STLport README for Microsoft Visual C++ compilers.
==================================================
by: Francois Dumont, dums@stlport.com, last edited 08/02/2005
============
Introduction
============
This document describes how STLport can be compiled and used with Microsoft
Visual C++ 6 SP5. It can also be used for the MSVC++ family.
For any further comments or questsion visit STLport mailing lists
http://stlport.sourceforge.net/Maillists.shtml or forums
https://sourceforge.net/forum/?group_id=146814
=============
Prerequisites
=============
To build and use STLport you will need following tools and libraries:
- Microsoft Visual C++ 6.0 with at least Service Pack 5 or any higher
version.
===================
Configuring STLport
===================
In a console window go to the STLport build/lib folder. Run
configure --help
This command will present you the different available build options. Just follow
the instructions to set STLport configuration according your needs. The only
mandatory configuration is to declare what is the compiler you are going to
use, for MSVC 6 it is:
configure -c msvc6
================
Building STLport
================
This is a step by step description of the actions to take in order to have
the STLport library built:
1. Open a console window. You can get it executing cmd or command depending
on your Windows OS.
2. Go to MSVC++ Bin directory with a default MSVC6 install it is
cd "C:\Program Files\Microsoft Visual Studio\VC98\Bin"
3. Run the vcvars32.bat script. This sets the environment variables required
to have the MSVC++ compiler run during the build process. The most important
one is the PATH variable so that you can call the cl.exe command which is the
MSVC++ command line compiler. [You may omit this step, if you chose 'Install paths
to access command-line tools' during Microsoft Visual Studio installation procedure.]
4. Go to the STLport build/lib folder:
cd C:\STLport\build\lib
5. Run the following command:
nmake /fmsvc.mak install
nmake is the make utility from Microsoft. /f is an nmake option
telling it which make file script to use. You have of course to grant the
closer make file to your effective compiler, msvc.mak in our case.
Once the command returns, you will have all the necessary libraries within
the STLport lib folder. For a description of the generated libraries check the README
file within the src folder.
===============
Testing STLport
===============
You can use the unit tests to verify STLport behaves correctly. Change into
STLports 'build/test/unit' folder and type:
nmake /fmsvc.mak install
Once the unit test is built you just need to run it. They can be found
within the STLport bin folder.
=============
Using STLport
=============
Adjust your include and link paths in MSVC IDE (in 'Tools -> Options -> Directories'
for MSVC6 IDE). In the include files add the path to STLport's 'stlport' folder.
Make sure it is the first directory listed there. Add STLport's 'lib' folder for
the library files (order of paths doesn't matter here).
There are some preprocessor defines that control usage of the STLport in msvc
projects:
If you don't want to use the iostreams part of the library, you can specify the
define _STLP_NO_IOSTREAMS. In this mode there is no need to link against the
library.
STLport uses automatic linking to find the proper .lib file. If you want to see
what import library STLport is going to use, define _STLP_VERBOSE_AUTO_LINK.
When not using automatic linking (by specifying _STLP_DONT_USE_AUTO_LINK), you
have to specify the proper .lib file in the Project Settings, on the "link" tab.
The .lib names have the following syntax:
stlport[d|stld][_x,_static,_statix].<STLport-Version>.lib
d : debug build
stld: debug build with _STLP_DEBUG (STL safe) mode
_x: Build of STLport as a dll but statically link to the native runtime.
_static : build of a static library
_statix : build of a static library link dynamically to the native runtime.
Examples:
stlport_static.5.0.lib - static release version, Version 5.0.0
stlportd.5.0.lib - dll debug version, Version 5.0.0
When using STLport together with MFC, be sure to include the MFC headers first,
then include STLport headers, e.g. in your Stdafx.h. This way STLport correctly
recognizes MFC usage. You also can define the macro _STLP_USE_MFC, either in
your project settings or in stlport/stl/config/user_config.h.
In order to enhance debugging with STLport you can optionally add the content of
the etc/autoexp.dat file in the autoexp.dat file coming with your Visual Studio
install.
Now you should be ready to use STLport.
============
Known issues
============
1. InterlockedIncrement
If you experiment trouble with the InterlockedIncrement Win32 API function
like the following message:
C:\Program Files\Microsoft SDK\Include\.\winbase.h(1392) : error C2733: second C
linkage of overloaded function 'InterlockedIncrement' not allowed
C:\Program Files\Microsoft SDK\Include\.\winbase.h(1390) : see declaration of
'InterlockedIncrement'
It means that you are using the new Microsoft platform SDK. There is no
way to known it from STLport code so you have to signal it in the
stlport/stl/config/user_config.h file (uncomment _STLP_NEW_PLATFORM_SDK in this file).
2. Native C/C++ library headers location
If you experiment trouble with location of ctime and other Standard headers
while building or using STLport you might be using the compiler coming with a
platform SDK. If so please uncomment _STLP_USING_PLATFORM_SDK_COMPILER in
stlport/stl/config/user_config.h. If it still do not find native headers you will
perhaps need to change native headers relative path used by STLport. In this case use
_STLP_NATIVE_INCLUDE_PATH and associated macro in stlport/stl/config/host.h.
4. C symbols in std namespace
The compiler of MSVC++ 6 has a bug when dealing with symbols existant in both
the global namespace and symbols imported by a using-directive or a
using-declaration - it will report an ambiguous call to an overloaded
function (error C2668). Example:
void function();
namespace ns {
void function();
// or:
// using ::function;
}
using ns::function;
// or:
// using namespace ns;
void call() {
function();
}
Since we anticipate that using-declarations or even using-directives are common
use, STLport by default doesn't import or wrap functions that exist in both the
global namespace and namespace std, in particular those are functions with C
origin like fopen() or abs(). Also, it defines additional overloads for
functions like abs() (overloaded for int, long, float, double, long double) in
the global namespace.
In order to make STLport include them in the std namespace, you can define the
_STLP_DO_IMPORT_CSTD_FUNCTIONS macro. Doing so, you will have to explicitely
scope all your functions calls like std::abs() though - otherwise you only get
the global abs(int) from the C library.

51
reactos/lib/3rdparty/stlport/doc/README.utf8 vendored Normal file
View file

@ -0,0 +1,51 @@
Here is a description of how you can use STLport to read/write utf8 files.
utf8 is a way of encoding wide characters. As so, management of encoding in
the C++ Standard library is handle by the codecvt locale facet which is part
of the ctype category. However utf8 only describe how encoding must be
performed, it cannot be used to classify characters so it is not enough info
to know how to generate the whole ctype category facets of a locale
instance.
In C++ it means that the following code will throw an exception to
signal that creation failed:
#include <locale>
// Will throw a std::runtime_error exception.
std::locale loc(".utf8");
For the same reason building a locale with the ctype facets based on
UTF8 is also wrong:
// Will throw a std::runtime_error exception:
std::locale loc(locale::classic(), ".utf8", std::locale::ctype);
The only solution to get a locale instance that will handle utf8 encoding
is to specifically signal that the codecvt facet should be based on utf8
encoding:
// Will succeed if there is necessary platform support.
locale loc(locale::classic(), new codecvt_byname<wchar_t, char, mbstate_t>(".utf8"));
Once you have obtain a locale instance you can inject it in a file stream to
read/write utf8 files:
std::fstream fstr("file.utf8");
fstr.imbue(loc);
You can also access the facet directly to perform utf8 encoding/decoding operations:
typedef std::codecvt<wchar_t, char, mbstate_t> codecvt_t;
const codecvt_t& encoding = use_facet<codecvt_t>(loc);
Notes:
1. The dot ('.') is mandatory in front of utf8. This is a POSIX convention, locale
names have the following format:
language[_country[.encoding]]
Ex: 'fr_FR'
'french'
'ru_RU.koi8r'
2. utf8 encoding is only supported for the moment under Windows. The less common
utf7 encoding is also supported.

94
reactos/lib/3rdparty/stlport/doc/README.wince vendored Normal file
View file

@ -0,0 +1,94 @@
Programming under MS Windows CE with STLport
=============================================
This is supposed to give an overview for programming on MS Windows CE, with and
partially without STLport, what tools are available and what common pitfalls
exist. Note that for every supported compiler there is another readme file which
explains the specifics of that compiler.
Available compilers:
---------------------
- Embedded Visual C++ 3 (eVC3): this IDE/compiler is for the CE3 target platforms.
The included compiler is MSC12, the same as for VC6, so many workarounds for its
'features' apply here, too. STLport works out of the box with this.
- Embedded Visual C++ 4 (eVC4): basically the same as eVC3, but it can compile for
CE4.x and 5. Note that currently (2007-03-06) I haven't tested this with CE5,
because you can use a better compiler using VC8/VS2005. This compiler can be
downloaded for free from the MS website, including a product activation key.
STLport works out of the box with this.
- Visual C++ 8 (VC8) aka Visual Studio 2005 (VS2005): with this version (and
partially already version 7) the embedded and desktop IDEs have been merged again,
so it supports compiling for MS Windows CE, versions 5 and later. Note that the
freely downloadable express edition does not(!) allow compiling for CE. This IDE
uses MSC14 as compiler. STLport works out of the box with CE5.
- Platform Builders (PB): this tool is used to create a CE image. You can select the
modules (e.g. Explorer, but also C++ RTTI) you include in the image. These IDEs use
several different compilers (MSC12-14). STLport hasn't been tested with this
IDE, AFAIK.
- There used to be an addon for VC6(?) that allowed compiling for CE. This plugin
has been superceeded by eVC3/4 and support for it has been removed from STLport in
version 5.
- Others: some vendors (e.g. Intel) provide compilers that are able to generate
CE executables. I'm not aware of an attempt to compile STLport with them.
Environment specialties:
-------------------------
- In order to develop for a platform, the first thing you need is a so-called SDK.
This package includes headers and libraries that (more or less) resemble the APIs
available on the device. The IDEs come with a basic selection of SDKs, but in
general you need to retrieve an according SDK from the vendor. If you are the
vendor, you can generate an SDK for a platform with Platform Builder.
- The provided API is typically a subset of the 'normal' win32 API. Often, some
features are simply not supported, like security descriptors when opening files.
Also, these APIs are only supported for wchar_t strings, e.g. only CreateFileW()
and not CreateFileA().
- CE doesn't have a current directory, hence no relative paths to that dir. You can
have relative parts in global paths though.
- CE doesn't have environment variables, thus STLport can't support e.g.
setenv/getenv. It also doesn't attempt to provide workarounds.
- Since many features are optional (see the description of Platform Builder), it
is possible that you don't have e.g. a console that std::cout could write to. The
same applies to exceptions (see e.g. the add-on lib for RTTI for eVC4). Other
features might go amiss, too. This makes it hard for STLport to adapt to, in
particular because this information is not available outside PB, a header might
declare a function that in fact is not present. Keep this in mind when you get
linker errors.
- The supplied C++ standard library is extremely cut down, e.g. iostreams and
locales are missing completely.
- The supplied standard C API is at best rudimentary. Functions like e.g. time() or
clock() are declared but not defined. STLport doesn't include any workarounds for
these missing functions at present.
- All compilers are cross-compilers, i.e. you run them on a win32 host and they
produce executable code for the target platform. The same applies to the debugger,
which is connected via serial, USB or ethernet. Alternatively, there are emulators
that run on the host machine and simulate the target platform.
- The entrypoint for executables is generally WinMain. Normally, you would have
switched to a normal main() using /SUBSYSTEM:CONSOLE on the linker commandline.
The linkers for at least CE4 and 5 don't understand this switch, they claim it
conflicts with CE targets. Instead, set the entrypoint directly to
mainACRTStartup.
- The name of a DLL loaded via an import library can't be longer than 32 chars. If
this is not the case, the application will behave as if the DLL was not present or
couldn't be loaded for whatever other reason. This limitation applies to at least
CE 4 and 5.

55
reactos/lib/3rdparty/stlport/doc/README.windows vendored Normal file
View file

@ -0,0 +1,55 @@
Note for Windows users:
It is highly recommended to declare the Windows OS version you are
targetting when building the library as well as when using it. You can do so
thanks to the well known Microsoft macros WINVER, _WIN32_WINDOWS or
_WIN32_WINNT, see your platform SDK documentation for a description
of those macros and how to use them. To define it when building the
library, use the configure script --extra-cxxflag option. Here is the
configuration to build STLport using Visual Studio 2005 and targetting
Windows XP:
configure -c msvc8 --extra-cxxflag "/D_WIN32_WINNT=0x0501"
If you do not declare it at build time STLport will adapt to the PSDK in
use, windows.h gives a default value to WINVER. However, when using the
library, windows.h is not necessarily included, at least not by STLport
internally, so none of the macros are defined which will result in an
inconsistency in the build process which most of time will generate undefined
behavior at runtime.
Here is the main reason for following this advise, the Windows 95
compatibility issue:
Because of a modification in the behavior of the Win32 API functions
InterlockedIncrement and InterlockedDecrement after Windows 95, STLport
libraries built for Windows 95 cannot be used to generate an application
built for Windows XP for instance. So, if you build STLport with a Windows
95 PSDK, STLport will be ready for Windows 95. If you then use it without
defining _WIN32_WINDOWS to signal Windows 95 compatibility, STLport will
consider that it can use latest Windows OS features like the new
InterlockedIncrement and InterlockedDecrement functions which change the
memory footprint of some internal STLport objects making it incompatible
with the libraries built for Windows 95.
Normally, doing so wouldn't generate any compilation or link error, you
would only experiment undefined behavior at runtime. In order to make this
problem more obvious STLport forces a link time error in debug mode (_DEBUG
macro defined).
Unresolved symbol will be:
- 'building_for_at_least_windows98_but_library_built_for_windows95'
if you are trying to use STLport libraries built for Windows 98 or later
to generate an application targetting the Windows 95 platform.
- 'building_for_windows95_but_library_built_for_at_least_windows98'
if you are trying to use STLport libraries built for Windows 95 to generate
an appliation targetting the
Windows XP platform for instance.
Of course, targetting the latest Windows OS versions will give you the best
performance from STLport. This is why when none of the platform macros are
defined STLport consider that there is no minimum OS requirement and will
use the latest API functions. There is only one exception to this behavior,
the SwitchToThread function that is used only if you define _WIN32_WINNT to a
value higher or equal to 0X0400.

82
reactos/lib/3rdparty/stlport/doc/build_system.txt vendored Normal file
View file

@ -0,0 +1,82 @@
The STLport build system
========================
This is a basic overview of the STLport build system. At the moment, I'm only familiar
with the working of the nmake variant, i.e. for MSVC, eVC and ICC/win32, other variants
may differ.
Overview:
----------
There are three basic classes to consider while building:
1. The used make tool (currently that is make (GNU make) an nmake (Microsoft)).
2. The used compiler
3. The target type, either application or library
Other than that, there are three different settings corresponding to the three different
STLport modes, 'release', 'debug' and 'STLdebug' and each one has two modes for either
static or dynamic linking.
The whole build system lies under the build/ dir of the source tree. There, it first
branches to Makefiles/ (which contains the base of the build system) and to lib/ (which
contains files to build the STLport library) and test/ (which contains files to build
tests) (TODO: what is the misc/ folder for?).
Under Makefiles/, you see the initially mentioned branching according to the build tool.
Here is also where the configure.bat file puts the generated config.mak file. (TODO:
what are the other files in that folder?)
nmake:
-------
Under nmake/, you then find the common support files for the different compilers and
files that define generic rules. Here, it then splits into app/ and lib/, which are
structured similar to each other and to the common nmake/ dir. In each dir you have
files for the different compilers that are used to make application specific or library
specific settings.
The branching in the three STLport modes and the static/dynamic linking is not visible
in the file structure but only in the used nmake variables.
In order to make clear which file includes which other file, here an example when
compiling the STLport library for eVC4. The call issued is 'nmake /f evc4.mak' in the
build/lib folder. From there, the following include tree is created:
build/lib/evc.mak
build/Makefiles/config.mak ; generated by configure.bat
build/Makefiles/nmake/top.mak
build/Makefiles/config.mak
build/Makefiles/nmake/sysid.mak
build/Makefiles/nmake/sys.mak
build/Makefiles/nmake/evc4.mak ; evc4 from config
build/Makefiles/nmake/evc-common.mak
build/Makefiles/nmake/targetdirs.mak
build/Makefiles/nmake/extern.mak
build/Makefiles/nmake/targets.mak
build/Makefiles/nmake/rules-o.mak
build/Makefiles/nmake/clean.mak
build/Makefiles/nmake/lib/top.mak ; would be app/top.mak when building an application
build/Makefiles/nmake/lib/macro.mak
build/Makefiles/nmake/lib/evc4.mak ; evc4 from config
build/Makefiles/nmake/lib/evc-common.mak
build/Makefiles/nmake/lib/rules-so.mak
build/Makefiles/nmake/lib/rules-a.mak
build/Makefiles/nmake/lib/rules-install-so.mak
build/Makefiles/nmake/lib/rules-install-a.mak
build/Makefiles/nmake/lib/clean.mak
TODO: build/Makefiles/config.mak is included both by build/lib/evc.mak and by
build/Makefiles/nmake/top.mak.
Known issues:
--------------
- nmake: MSC doesn't support generating dependency information for makefiles. So, unless
you modify the direct source file for an object file, no recompilation is triggered! You
need to either delete all object files that need to be recompiled or 'make clean'
- There are targets to only install e.g. the shared STLdebug version but there is no
such thing for making clean. This would be useful in the context of above issue for
making a selective clean only.

90
reactos/lib/3rdparty/stlport/doc/pointer_specialization.txt vendored Normal file
View file

@ -0,0 +1,90 @@
********************************************************************
* This document describe the STLport container pointer *
* specialization feature. *
********************************************************************
What is it for:
The major problem of template code is the potentialy huge binary
size that can result from the compilation. Each template type
instanciation is a new type from the compiler point of view even if
the generated binaries are identicals. To avoid this binary duplication
STLport grant the partial pointer specialization for 4 containers:
- vector
- deque
- list
- slist
How does it work:
The pointer specialization consists in using a void* container
instanciation for any container of pointers, including pointers
to cv qualified types. So the container pointer specializations
are only bridges that forward all the method calls to the
underlying void* container instanciation. The bridge job is to
cast the pointer type to and from the void* type.
Why only those 4 containers:
Some of you might wonder why none of the associative containers
or hash containers has been specialized. Lets take the set container
as an example. Its declaration is
template <class _Tp,
class _Compare = less<_Tp>,
class _Alloc = allocator<_Tp> >
class set;
In a first thought you can imagine a partial specialization like
the following:
template <class _Tp, class _Compare, class _Alloc>
class set<_Tp*, _Compare, _Alloc>
What would be the underlying container for such a partial
specialization? The _Alloc type is supposed to have a rebind member
method so you can easily find the _VoidAlloc type. The _Compare type,
on the other hand, do not have this kind of Standard requirements.
So you need to wrap the _Compare type within a _WrapCompare type
that will take care of all the cast work. The underlying container
type will be:
set<void*, _WrapCompare<_Tp, _Compare>, _VoidAlloc>
The problem of such a type is that it is still dependent on the
original _Tp type for the _WrapCompare instanciation. So each set
instanciation will have a distinct underlying void* container and
we fall back on a binary duplication trouble.
On a second thought a possible solution is to limit the partial
specialization like that:
template <class _Tp, class _Alloc>
class set<_Tp*, less<_Tp*>, _Alloc>
We only specialized the set container if the comparison functor
is the Standard less struct. The underlying container would be:
set<void*, less<void*>, _VoidAlloc>
It looks fine but it is wrong. Actually a STL user is free to
specialized the less struct for any pointer type even the basic one.
In such a situation the client would think that the set is ordered
according its own functor but will finally have a set ordered according
the less<void*> functor. The less specialization issue also show that
the underlying cannot be a
set<void*, less<void*>, _VoidAlloc>
but will have to be a
set<void*, __less<void*>, _VoidAlloc>
where __less would be equivalent to the standard less functor but
would not be specializable because unreachable from the client code.
There is of course a solution for this specialization issue. We
need to be able to detect the less specialization. The partial set
specialization would have to be used only if the less functor is
the default STLport implementation based on the strict ordering operator.
No doubt that a solution to this problem will be soon found.

133
reactos/lib/3rdparty/stlport/doc/stlport_namespaces.txt vendored Normal file
View file

@ -0,0 +1,133 @@
This document present the STLport namespace schema and give additionnal
information about how STLport replace the native C++ Standard library
coming with your compiler.
1. What is the STLport namespace ?
As STLport is a C++ Standard library implementation the STLport namespace
is 'std'. In normal use this is all you need to know and you can stop reading
here.
2. How does STLport replace native C++ Standard library ?
STLport defines a macro 'std' that replaces all references of std in the
user code by a different name. This technique has has some drawback but also
advantages. The drawback is that you cannot declared Standard component like
that:
//foo.h
namespace std
{
template <class _Tp>
class allocator;
}
void f1(const std::allocator<int>&);
//foo.cpp
#include "foo.h"
#include <memory>
void f1(const std::allocator<int>& alloc)
{
//implementation
}
//bar.cpp
#include "foo.h"
#include <memory>
int main(int, char**)
{
std::allocator<int> alloc;
f1(alloc);
}
If you build this code you will surely have a compilation error as f1 is declared
as taking a std::allocator parameter but you are calling it using an STLport allocator
instance that is not in the std namespace. The good news is that this drawback is easy
to detect as it will generate compilation error or at least link time error. The only
workaround is to include an arbitrary Standard header before the allocator declaration.
Good candidates for that are <utility> or <cerrno> as they are small headers. Including
those headers will replace std with the STLport namespace.
The advantage of this macro replacement is that we can customize the STLport namespace
depending on the compilation options. For instance the STLport safe mode you can use by
defining _STLP_DEBUG is not binary compatible with a normal debug build. To ensure that
no one will ever build code without _STLP_DEBUG and link with STLport library built with
this option the namespace is different so that it will generate link time error rather
than random crashes during application execution.
3. Why not having use namespace injection ?
An other way to replace native Standard C++ library implementation would have been to
use namespace injection:
namespace std
{
using namespace stlport;
}
This solution has a first major drawback which is that STLport would be much more sensible
to native headers. If you include a C++ native headers that indirectly define for instance
the vector class it is going to conflict with the STLport vector definition.
Moreover this solution just does not work for a very simple reason. The C++ Standard
allows users to specialized some of the Standard algorithms. This specialization has to
be done in the same namespace as the main template declaration:
//In an STLport header:
namespace stlport
{
template <class _Tp>
struct less
{
bool operator () (const _Tp& x, const _Tp& y) const;
};
}
//User code:
struct MyStruct;
namespace std
{
template <>
struct less<MyStruct>
{
};
}
As you can see the specialization is not in the STLport less namespace and it
won't be used in associative containers for instance.
4. What is the STLport specific namespace ?
The official STLport namespace is: stlport. Once again this is not the real namespace
where all the Standard stuff are. As the real STLport namespace change depending on compilation
options you cannot use it directly. So stlport is an alias of the real STLport namespace.
5. What are the other STLport namespaces ?
Those names are given for information purpose and should never be used in any user code. The
default STLport namespace is: stlp_std. Here is the list of the customized namespaces:
- stlpd_std : when _STLP_DEBUG is defined
- stlpx_std : when you use STLport as a shared library linked to the static version of the native
runtime or when you build the static STLport library linked with the dynamic version. This option
is only supported by a limited number of compilers.
- stlpmtx_std : when building STLport as not thread safe.
You can also have combination of those extension like stlpdxmtx_std or stlpdmtx_std...
There is also an other STLport namespace for STLport internal functions or struct/class: priv.
namespace stlport
{
namespace priv
{
}
}

3088
reactos/lib/3rdparty/stlport/etc/ChangeLog vendored Normal file
View file

File diff suppressed because it is too large Load diff

668
reactos/lib/3rdparty/stlport/etc/ChangeLog-4.0 vendored Normal file
View file

@ -0,0 +1,668 @@
The following fix was made in 4.0 since 4.0 Release Candidate :
* _threads.h/_config.h : for all platforms, static mutexes made non-indirect
* _iterator_base.h : made possible to choose between iterator_traits approach
and old-style iterator queries like iterator_category(), value_type(), etc.
(Thanks to John R. Bandela for pointing this out)
* _config.h, stl_user_config.h : introduced __STL_OLD_HP_ITERATOR_QUERIES switch to
allow old-style and new-style iterator queries (for all compilers).
iterator_traits<> made always defined.
* _ptr_specialize.h - specializations of type_traits<> for compilers w/o partial spec
moved into separate file. Added iterator_traits<> specializations for pointer types
for __STL_NO_OLD_HP_ITERATOR_QUERIES case. Macro __STL_POINTERS_SPECIALIZE is now available
to specialize both type_traits and iterator_traits for a pointer to user-defined
type (latter for standard-style iterator queries mode only)
* vc5.mak : __STL_NO_FORCE_INSTANTIATE flag restored
* _site_config.h : if __STL_NO_NEW_IOSTREAMS or __STL_NO_IOSTREAMS specified,
SGI iostreams are being turned off. __STL_NO_SGI_IOSTREAMS moved into stl_user_config.h
(Thanks to Sathish T C for the report)
* stl_watcom.h : _REENTRANT is being set if _MT is set (thanks to Ricardo E. Gayoso for the input)
The following fix was made in 4.0 Release Candidate :
* _threads.h, _alloc.c : fixed use of _STL_mutex_base instead of _STL_STATIC_MUTEX macro
The following changes were made in 4.0 Release Candidate since 4.0 beta 8:
* fstream.cpp : WIN32 fstreambuf::open flag mapping fixed
(thanks to Alberto Barbati for the reports)
* ctype.cpp : fixed classic table regarding ios_base::print/ios_base::space
conflict (thanks to Alberto Barbati for the report)
* cmath : added same workaround for SUN's math exception/std::exception name clash
as was there in math.h before
* _streambuf.c : added "typename" to out-of-line functions (thanks to Michael Tsirkin for the report)
* README fixed to be consistent about SGI iostreams setting (thanks to Ed Brey for the report)
* _bitset.h : fixed SUN CC 4.2 crash with -g option (thanks to Alex Vanic for the report),
fixed bug in bitset<>::reference base bitset typedef
* _threads.h/.c - fixed issue with inconsistent system's macro for initialization
and warning about partially bracketed initializer
* debug/_vector.h : fixed _Vector_nonconst_traits specialization for bit_vector
(thanks for Dave Abrahams for the fix & reminder)
* config/msvc.h - addidional level 4 warnings suppressed (thanks to Ed Brey for the report)
* _ios.h : fixed DLL export decl for MSVC (thanks to Alberto Barbati for the report)
* stdio_streambuf.cpp : compatibility fix for glibc 2.2 (thanks to Bill Shanahan for the patch)
* _iterator_base.h : added iterator<output_iterator_tag, void,..> specialization;
_stream_iterator.h : ostream_iterator changed to inherit from iterator<>
(thanks to Raphael Bossek for the report)
* INSTALL : added some exaples and fixed typos (thanks to Beman Dawes for the report)
* _site_config.h : more consistency checks for MT (thanks to John Maddock for the input)
* _messages_facets.h : added DLL export decls (thanks to John Maddock for the report)
* complex_io_w.cpp : fixed specialization syntax for aCC (thanks to Paul E. Blanchard for the report)
* complex_exp.cpp : fixed pow() bug for negative arguments (thanks to Anton Sergeev for the report)
* _fstream.h/_streambuf.h : MRC/MPW workarounds (thanks for Tsutomu Yoshida for the report)
* using/fstream.h : added missing end-of-line (thanks to Jean-Francois Panisset for the report)
* <typeinfo> : workaround for VC++ 6.0 defining type_info in gobal namespace (thanks to Bosko Ivanisevic for pointing that out)
* _threads.h/_threads.c/pthread_alloc : improved pthreads portability (thatnks to Michael Tsirkin for the patch)
* _debug.h/_debug.c : __STL_ASSERT/__STL_VERBOSE_ASSERT/__STL_VERBOSE_RETUN macros guarded to be overridable by user (thanks to Tony Gould for the input)
* _valarray.h : added assert to operator=
* config/vc_select_lib.h : added _AFXDLL recognition (thanks to Andrew Phipps for input)
* _rope.h : added default constructors to please gcc-2.7.2
* _set.h/_hash_set.h : pointer and reference typedefs fixed (thanks to Anton Sergeev for the report)
* stl/_config.h : stl_user config.h included prior to other parts of configuration
(thanks to Frank Samuel for the report)
The following changes were made in 4.0 beta 8 since 4.0 beta 7:
* Merged changes for 06/08 SGI library snapshot; mostly in locale
* Merged series of fixes/workarounds by Tsutomu Yoshida (thanks!):
* _rope.c - fixed memory leak bug;
* _debug.c/_debug.h - added extra zero-initialization for more robustness;
* _list.h - MPW - specific fixes;
* _hashtable.h - fixed debug renaming clash for __STL_USE_ABBREVS
* EH workarounds to make Apple compilers behave
* _fstream.c : fixed tellg() bug in text mode
* <csignal> : added sig_atomic_t import
* series of fixes for HP aCC 1.23 ( thanks to Michael Tsirkin for the patch ):
_bvector.h : all relops are specialized;
stl_hpacc.h - fixed config;
hpacc.mak : added makefiles for HP aCC in src and test
debug/_iterator.h, debug/_vector.h - removed future errors due to baseclass member use
* <cstdlib> : added import of system() call (thanks to Petr Ovchenkov for the report)
* _REENTRANT is now set by default to be on for all SGI iostreams compilations.
Same is being enforced if SGI iostreams are used.
* _pair.h : added workaround for make_pair in case of char literals
(extension, only works with partial function order)
* config/stl_gcc.h - fixed configuration problem for "g++-3" directory used in Cygnus and Mingw
distributions for gcc-2.95.2, while all other platforms use "g++". Added recognition section.
Thanks to Dave Abrahams for the report.
* config/stl_mlc.h : added support for MLC compiler (thanks to Anton Sergeev for the patch)
* <memory> : auto_ptr simplified (thanks to Kon Tantos for problem report)
* num_get.cpp : included <ostream> to get external symbols right.
* stl_ibm.h : __STL_NO_TYPEINFO added for OS/2 (thanks to Willie Arbuckle for the report)
* stl_bc.h : fixed enforcement of static library until dynamic made to work (thanks to J. Lambert for the report)
* src/stlport.rc : improved version definition to work with mingw32, <winres.h> changed to <windows.h>
* src/mingw32.mak : Made use of stlport.rc for DLL build (thanks to Danny Smith for the suggestion)
* debug/_vector.h : name clash removed for _Base (thanks to Will Fike for the report)
* _monetary.h - added "static const bool intl" member to meneypunct<> templates
(thanks to Anton Sergeev for the report)
* _bitset.h : added forward friend decraration for reference (thanks to Anton Sergeev for the report)
* _tree.h : made _Rb_tree_base_iterator::_M_node initialized in default constructor (thanks to Dean Sturtevant for the report)
* _set.h : reinterpret_cast<> changed to C-style cast (thanks to Dave Abrahams for the suggestion)
* Use of raw SGI allocators (like __node_alloc) as an allocator parameter deprecated,
available only with __STL_USE_RAW_SGI_ALLOCATORS macro. May be removed later.
__allocator<T> still available unless __STL_NO_EXTENSIONS is specified
* _limits.h/_limits.c - alignment fix for Solaris;
* Modified __format_float* routines to take long double as parameter;
(thatnks to Anthony Williams for the patch)
* debug/_iterator.h - wrappers for noncompliant compilers moved under
#ifdef __SGI_STL_NO_ARROW_OPERATOR (thanks to Dave Abrahams for the input)
* _numeric_facets.h - num_put<> , num_get<> virtual members made outline to work
aroung gcc-2.95 bug.
* <cstdio> : undefined obsolete C macros : getchar/putchar & the like.
* ctype.cpp : fixed bug with ctype<char>::is (const char*, const char*, mask)
* ctype.cpp : fixed is(print) for certain platforms where print is a separate flag
* ftstream.cpp : fixed corner case bug for Win32 text output (thanks for Dirk Schreib for the report)
* _streambuf.h, _fstream.h, stdio_strembuf.h : fixed overflow/pbackfail() virtuals definition;
* _bitset.h : _M_copy_from_string fixed for non-member-template case (thanks to Alex Vanic for the report)
* gcc-glibc.mak, common_macros.mak : GLIBC compilation fixes (thanks to Thomas Witt for the report)
* WCHAR_MIN, WCHAR_MAX definitions moved from <limits> to <cwchar>
* char_traits<char>::to_char_type : parameter changed to int
* <cstddef> included in <new> (for size_t)
* _codecvt<>::do_length: fixed first parameter to be const mbstate_t &;
virtual fns moved into .cpp, to work aroung gcc bugs
* _complex.h : fixed complex<>::operator= and constructors signature to take const T&
* _istream.c : fixed formatted input involving binary '0'
* locale_impl.cpp : insertion of time_put<wchar_t> fixed
The following changes were made in 4.0 beta 7 since 4.0 beta 6:
* Merged series of fixes/workarounds by Tsutomu Yoshida (thanks!):
* cmath, _complex.h, stl_apple.h, _deque.h - MPW/MRC specific workarounds
* _bitset.h - removed the obsolete _WordT template parameters.
* _ctype.h, _codecvt.h, _collate.h, _istream.h, _messages_facets.h, _monetary.c
_monetary.h, _numeric_facets.h, _time_facets.h - added workaround for locale's nested class.
* _ostream.c_ostream.h - added proposed modification against the <ostream> circular inclusion problem.
* test/eh/test_deque.cpp - removed the obsolete template argument
* _bitset.h - removed obsolete adaptor (thanks to Alex Vanic for the report)
* _[io]stream.h - removed extra DLL specs (thanks to Danny Smith for the report)
* stl_msvc.h - fixed bug caused static lib to always be selected
* gcc.mak - fixed AR definition for static link
* Added workaround for static locale::id member in DLL for mingw32 (thanks for Danny Smith for the report)
* _string_io.h : added _widen() to get getline() compile with wchar (somewhat missing in b6 , thanks to Mikhail Leonov for reminder)
* threads.h - fixed guards for DreamSega WinCE (thanks to Ben Nason for the report)
* fstream.cpp : fixed truncation for WIN32 (thanks to Bruce Alderson for the report)
* _istream.c/_M_ignore_unbuffered() - fixed count bug
* _istream.c/ readsome() : fixed extra failbit setting on eof
* __get_integer - enhanced using a table; input value made unchanged in case of error.
* __get_base_or_zero - more code factored out
* stl_wince.h : fixed assert() definition for Win CE (thanks to Andrew Waters for the report)
* vc_select_lib.h " fixed __declspec selection for Win CE (thanks to Andrew Waters for the report)
* _rope.c - fixed bug in _S_destr_concat_char_iter (thanks to E.Musser for the fix)
* debug/_vector.h - fixed DLL export for vector<void*>
* _vector.h, _deque.h, _bvector.h - obsolete guards around at() methods removed ;
* type_traits.h - WinCE compatibility fixes for -> operator definition ;
* _vector.h, _deque,h - removed extra casts (thanks to Andrew Waters for the report)
* _algobase.h - optimized lexicografical_compare() overload for char*
The following changes were made in 4.0 beta 6 since 4.0 beta 5:
* Merged changes from SGI STL snapshots 04/03, 04/14, 04/18.
* Iostreams ported to Apple MPW/MRC (thanks to Tsutomu Yoshida for the contribution)
* Iostreams ported to OSF1/Tru64 (thanks to Marc W. Mengel for the contribution)
* Iostreams ported to FreeBSD ( Thanks to Sms for the contribution)
* <deque> : extra template parameter removed
* locale::id, locale::facet : reverted to nested classes as standard prescribes
* _string_io.h : added _widen() to get getline() compile with wchar (thanks to Mikhail Leonov for the patch)
* collate_byname[_w].cpp : fixes for VC++ 5.0 build w/__STL_DEBUG (thanks to Petr Ovchenkov for the patch)
* <complex> : __STL_COMPLEX_NAMESPACE defined before inclusion of impl. header
(thanks to Matthew Kelly for the patch)
* makefiles in "src" : improved to get each compiler to put object files in separate directory :
./obj/$(COMP)/Debug, etc. COMP is given some default value for each compiler, but may be also overridden.
* "src" subdirectory : added stlport_prefix.h file for precompiled header support;
VC++ makefiles make use of them
* stl/_iterator_base.h : provided __STL_NONTEMPL_BASE_MATCH_BUG
workaround for new form of distance().
* <limits> : added cast to WCHAR_MAX definition (thanks for Dave Abrahams for the report).
* stl_user_config.h, stl/_config.h - setting splitted and organized more properly.
* time_facets.cpp - extra instantiations removed (thanks to Matti Rintala for the report).
* stdio_streambuf.h : added explicit qualifications of C lib functions for gcc-2.91
* SGI code used for compatibility w/older versions are guarded with #ifndef __STL_NO_ANACHRONISMS
* SGI extensions are guarded with #ifndef __STL_NO_EXTENSIONS
* SGI/HP anachronisms are guarded with #ifndef __STL_NO_ANACHRONISMS
* <typeinfo> : .h file included if __STL_NO_NEW_NEW header is set
(thanks to Willie Arbuckle for the report)
* Suppresed spurious BC55 warnings about iterators
* complex_io.h - fixed operators declarations for MetroWerks
* debug/_slist.h - cleaned up use of stl_debug_do obsolete macro (thanks to Matti Rintala)
* debug/_iterator.h, debug/_vector.h - fixed relaxed iterator constructors (thanks to Dave Abrahams for the patch)
* stl/_complex.h - fixes for gcc-2.95 on IRIX (thanks to Marc W. Mengel)
* debug/_iterator.h : fixed relaxed const/non-const iterator construction for debug mode
(thanks to Dave Abrahams for the patch)
* collate : added workaround for SUNpro linker (thanks to Petr Ovchenkov for the fix)
* _ios.h, _streambuf.h - added obsolete stuff required by the standard
* _config.h/stdexcept - introduced __STL_NOTHROW_INHERITED to be used when we actually need
exception specification due to inheritance (thanks to Joe for the report)
* _locale.h:104 : fixed ummaned parameters
* _tempbuf.h - fixed absent inclusion of _tempbuf.c
* <exception> : relaxed rules for importing vendor symbols
* _deque.h - added != operator
* _streambuf.h - fixed snextc() bug for wchar_t
* <ostream>, _numeric_facets.h - circular dependency resolved
* stl/_iosfwd.h - added include guard
* basic_[io]stream::sentry made inner class again (as per standard)
for non-DLL compilations.
* vector<void*> is used in locale implementation to reduce code bloat,
vector<void*> exported from DLL
* <stdexcept> : exported more stuff
* stl_intel.h : ICL config merged into stl_msvc.h
* gcc.mak - fixed for shared target
The following changes were made in 4.0 beta 5 since 4.0 beta 4:
* _hastable.c:263 : removed inneeded cast (thanks to Will Fike for the report)
* debug/_string.h : added conversion to non-SGI string (thanks to Todd Richmond for the report)
* _complex.h : fixed DLL declarations for i/o operators
* _ostream.h : fixed sentry behavoiur and DLL specs.
* _istream.h : fixed DLL specs, optimized some try/catch blocks
* _vector.h : fixed vector::insert body definition for __STL_INLINE_MEMBER_TEMPLATES
* <exception> : more compilers listed as having full exception header
* debug/_debug.h : added namespace to __STL_ASSERT for EH test which uses this internal macro.
* resource info fixed (thanks to Michael Entin for the report)
* debug/_string.h : fixed _M_start resolution bug (thanks to Rob for the report )
* <new> : added import of new_handler stuff from vendor namespace (thanks to Niran Bala for the report).
* src/c_locale_glibc - missed directory contents restored (thanks to Todd Rider for the report)
* mwerks_prj - project updated for new file set, target names for x86 changed to conform to common schema
* _ostream.c/_istream.c : fixed lookup for _S_eof symbol (thanks to Anton Sergeev for the report)
* _ios.h - fixed VC++ DLL warning for specializations
* stl_ibm.h - disabled "long long" due to incomplete support on MVS by request (thanks to Tinny Ng)
* char_traits.h - worked around weird gcc internal bug (__sz identifier changed to _Sz)
The following changes were made in 4.0 beta 4 since 4.0 beta 3:
* "src" directory : source divided into smaller parts to be more manageable and to
get more cache locality
* throw specifications removed (macros made void) - thanks to Dave Abrahams for the suggestion
* stl/_list.c - fixed reverse() "inline",
_deque.h - fixed cast bug for xlC (thanks to Alex Vanic for the reports)
* stl/_strstream.h - fixed DLL specs (thanks to Parcival Willems for the report)
* stl/_string.h, debug/_string.h - fixed conversion from native string with __STL_DEBUG
(thanks to Todd Richmond for the report).
* stl/_istream.h - fixed clash of "__N" symbol with ctype.h macro for some compilers
(thanks to Kees de Bruin for the report)
* Configuration fixed for Borland C++ 5.02 compiler [ deque still does not work with it ]
* gcc-2.7.2 configuration fixed
* SGI iostreams now work for Borland 5.5 with static lib , some problems with
locale initialization when DLL is used.
* __get_c_string exported in DLL (thanks to Ed Ball for the report).
* ENDIAN fixes for CodeWarrior/DEC (thanks to Kevin Wooten for bringing this up)
* wrap_std/h/strstream.h - added missing wrapper (Thanks to Laurent for the report)
* stl_hpacc.h - fixed #endif bug,
_limits.h/.c - fixed array initialization,
_string_io.h, _locale.h - fixed circular dependancy,
_set.[hc], _hashtable.c, _set.h - added __REINTERPRET_CAST need by some compilers;
_i[o]stream.c, _rope.[hc] - lookup fixed for dependant symbols
(thanks to Alain Miniussi for the reports)
After-release minor bugfixes for beta3:
* stl/_list.c - fixed reverse() [ new SGI code, merged unported first ]
Thanks for everybody who reported it.
* stl/_bvector.h : fixed ambiguity problem with relational iterators
for __STL_NO_BOOL case (thanks to Alex Vanic for the report).
* stl/_alloc.c, stl/_threads.c - fixed static member definitions for compilers
that lack automatic static data members (gcc-2.7). Thanks to Huang-Ming Huang
for the report.
* standard wide streams initialization bug on Win32 fixed (thanks to Harold Putman for the
report)
The following changes were made in 4.0 beta 3 since 4.0 beta 2:
* Merged SGI changes from 02/18 snapshot.
* Ming32W (gcc Win32 port using MS runtime lib) is now fully supported.
* .dll build schema improved, now builds with mingw32 and Borland C++
(Borland has some problem with numeric i/o)
* VC++ version bugfixes in <xstring>/<xutility>/<xstring>
(thanks to Todd Richmond for the report)
* _bvector.h - relational operators defined only for "bit_vector",
not for "vector" specializations (thanks to Edward Ball for the report)
* src/locale_impl.h - fixed multiple defined symbol problem with gcc
(Thanks to Matti Rintala for the report)
* config/stl_ibm.h - __STL_NO_TYPEINFO added (thanks for Tinny Ng).
* <string> : _stl_string_io.h/c introduced to fight inter-dependencies
* _bvector.h - added fix for -tempinc compilation on AIX (thanks to Alex Vanic for the patch)
* fstream.cpp - _M_write bug for Win32 text mode fixed (thanks to Mike Pyle)
* _string.h : debug version included prior to _string.c;
* debug/_debug.h/.c, debug/_deque.h, debug/_string.h - fixed debug mode bugs;
Apple compilers config fixes / iostream wrapping fixes / EH test fixes,
(thanks to Tsutomu Youshida for the patch)
* csetjmp/setjmp.h - guards added against VC++ #defines (thanks to Gavin Wood)
* stl/_iosfwd.h : __STL_DEFAULT_CONSTRUCTED used instead of __STL_NULL_CHAR_INIT
(thanks to Alex Vanic for the report)
* __stl_get_c_string() - made extern non-template for SGI iostreams mode.
* __cdecl calling convention fixes - now works for debug & non-debug code.
* _limits.h/.c : static data moved from inline functions into a class.
* stlport_msvc.rc resource file added for DLL's (thanks to Michael Entin)
* stlport/config/stl_wince.h : added abort()/assert() definitions
(thanks to Gavin Wood for the report)
* Initial iostreams port for xlC (thanks to Alexander Vanic for the patch).
* config files - made safe for C compilers
* src/c_locale_stub.c - made structure for full platform-dependent
locales other than "C". Glibc implementation merged.
The following changes were made in 4.0 release candidate 2 since 4.0 release candidate 1:
* Solid approach to __STL_DEFAULT_CONSTRUCTOR_BUG problem implemented,
rope.h typo fixed (thanks to Alex Vanic for the report)
* getline and stream operators moved from _istream.c to _string.c
where they belong (thanks for Petr Ovchenkov)
* <new> fixed to import nothrow and nothrow_t
* Borland C++ 5.5 (free compiler) supported (iostreams won't compile yet).
* SUN CC 6.0 EA - new features unabled (most announced features still don't work though)
* HP ACC configuration updated, some fixes for new aCC beta(thanks to Alain Miniussi).
* Windows CE compatibility fixed (thanks to Gavin Wood for the report)
* <sstream> fixed for non-SGI case, ios.cpp bug in __STL_NO_EXCEPTIONS
mode fixed, debug iterators fix (thanks to Todd Richmond).
* VC++ 5.0 and 4.2 compatibility fixed (thanks to Ilya for the report)
* __cdecl calling convention explicitly specified for VC++ & static/global functions.
* vc_common.mk : debug type changed to CV (thanks to Mike Pyle for the solution)
* fstream.cpp : Win32 text mode : bugs fixed, SGI code used.
fixed _M_open() creation flags for Win32 (thanks to Mike Pyle for the report)
* "install" target added for VC++ to install .dll's into Win system directory.
* __STL_USE_STATIC_LIB switch added to add flexibility to VC++ linking.
* __stl_debug_message for WIN32/Unicode/MFC improved
(thanks to Edward Ball, Chvetsov for the reports)
* MVS fix for auto_ptr<> (thanks to Tinny Ng)
* debug/_tree.h, debug/_vector.h "typename" fixes, thanks to Matti Rintala.
* c_locale.h : fix for Solaris 2.5.x (thanks to B. K. Oxley)
* _bvector.h : Watcom compatibility fixed (thanks to Ricardo E. Gayoso for the report)
* __STL_DONT_REDEFINE_STD flag behaviour fixed
The following changes were made in 4.0 release candidate 1 since 3.2.2 Beta 4 :
* Merged changes made to SGI standard library snapshot on 01/28.
* Fixed bug with istream reading numbers in hex mode (thanks to Dave Abrahams
for the patch).
* Debug mode redesigned (again) - no extra namespaces is being used
Finally, it works for MSVC and all other platforms.
* __SGI_STL_OWN_IOSTREAMS made to be the default mode except few platforms
not provided with makefiles to build STLport yet.
* Changed strategy on redefinig std:: namespace.
prolog/epilog technology used to get clean namespace wrapping.
It also allows for managing stack of pragmas
(see stlport/stl/config/_prolog.h,_epilog.h) to get rid of warnings.
Note : default namespace changed to _STL:: to satisfy implementation
constraints and to allow for more compact symbols.
"stlport::" namespace is still defined for backwards compatibility.
* iostreams library now compiles on HP with aCC (thanks to Steven Serocki for the patch).
* Configuration for SUN Workshop 6.0 EA provided.
* For VC++, corresponding [selected by /MT(d) or /MD(d) switch]
STLport iostreams library is being linked automatically - all you
need is to put library in lib search path or specify additional library path.
* Ability to turn on all warnings in your own code if you're using
a compiler with appropriate support (e.g. MSVC6).
* Small fixes posted to the forum integrated:
* config/stl_wince.h : added __STL_HAS_NO_NEW_C_HEADERS switch
* wrap_std/strsream : fixed preprocessor bug, strstream.h included
when not using new-style headers
* other fixes
The following changes were made in 3.2.2 beta 4 since 3.2.2 Beta 3:
* Merged changes made to SGI standard library snapshot on 01/10.
* Major restructuring of header files - for maintainability and
8.3 filesystems benefit.
* Major debug mode improvements - new debug mode now works with
VC++, gcc, intel, SUNpro, MetroWerks.
* Regression test suite changed to new-style headers - thanks to
Dima Pasechnik for the initial port.
* <rope> fixes for Watcom
* many miscellanous fixes.
The following changes were made in 3.2.2 beta 3 since 3.2.2 Beta 2:
* Merged changes made to SGI standard library snapshot in December.
* std:: is not used for STLport namespace even with SGI iostreams,
to avoid possible clashes and facilitate 3rd-party library use.
Same macro redefinition technique for stlport:: used to keep clients
code with literal std:: happy as in native iostreams mode.
* C library headers wrapping changed to allow multiple inclusion tricks
(needed by gcc-2.95 mostly)
* gcc-2.95 and CodeWarrior configurations updated.
* HP aCC fixes applied.
* Visual C++ - added static library targets, build refined.
Fixed memory-mapping bugs.
* auto_ptr updated, now it passes polymorphic tests with VC++.
* Many small bugfixes.
The following changes were made in 3.2.2 beta 2 since 3.2.2 Beta 1:
* Fixed SUN CC deque<> problem with -g
* Added configuration and makefiles for DEC VMS, Borland and Win32 gcc.
* Merged changes made to November SGI standard library snapshot.
* config changes - "configure" made obsolete and moved into "stlport/config/new_compiler".
* __STL_TYPENAME_ON_RETURN_TYPE handling changed.
* Miscellanous fixes.
The following changes were made in 3.2.2 Beta 1 since 3.2.1 release:
* SGI iostreams adopted. To use SGI iostreams, user have to set
__SGI_STL_OWN_IOSTREAMS flag and to build the library in "src"
directory to link with. Please read INSTALL file for detailed
instructions.
Default setting is NOT to use SGI iostreams (wrappers used as before).
* Debug mode completely redesigned - debug mode containers are
implemented in terms of wrappers around non-debug ones.
That provides for more clean and efficient implementation and
binary compatibility between debug and non-debug versions.
* Additional configurations added for platforms :
- gcc-2.95
- SUNpro CC 5.0 in "compatibility" mode
"configure" made obsolete.
* Bugfixes reported by users since 3.2.1 release merged
The following changes were made in 3.2.1 since 3.2 release:
* Now, by default, STLPort renames std:: namespace for user
if __STL_USE_OWN_NAMESPACE is used. To make it possible, many new
wrapper headers introduced. Internally, STLport uses stlport:: namespace,
so no link- or run- time clashes are possible, and you don't have to rebuild
the runtime lib (which you don't want to).
This feature makes STLport usable out-of-the box, without any modifications
for client code, with any compiler.
* Code bloat reduction : hashtable<T> uses vector<void*> internally.
* Vector : efficiency/code bloat reduction fixes.
* Visual C++ : DLL export is supported for allocators and strings. To use it,
please define __STL_USE_DECLSPEC in all modules and __STL_DESIGNATED_DLL
for the DLL which is supposed to instantiate STLport exports (at least one
source of this DLL must include <string>.
* Visual C++ : for MT synchronization, <windows.h> is not included anymore.
* For Sunpro C++ 5.0 : all headers are linked into stlport/SC5, so only
one include path is needed. Note that SC5.0 has problems with relative
search path. It is easy to work around : in your makefiles, instead of
"STL_INCL=../.." , write "STL_INCL=${PWD}/../..".
* Configuration files provided for compilers :
KAI C++
DEC C++ (6.x, 5.x)
Borland 5.02 is back on the road (finally !)
* Windows CE config provided for Visual C++.
* __STL_NO_IOSTREAMS switch introduced for embedded platforms.
* Lots of minor config fixes and improvements for various platforms.

8350
reactos/lib/3rdparty/stlport/etc/ChangeLog-5.1 vendored Normal file
View file

File diff suppressed because it is too large Load diff

138
reactos/lib/3rdparty/stlport/etc/ReleaseNote.txt vendored Normal file
View file

@ -0,0 +1,138 @@
5.2:
- Major modifications:
* Use of #include_next to access native platform/compiler headers when the
preprocessor support it. Enhance STLport portability as native header path do
not have to be adapted each time the header structure is modified.
* Yet a modification of the include schema in all C++ Standard headers. Now
_STLP_WHOLE_NATIVE_STD mode works as expected, used in conjonction with
_STLP_DONT_REDEFINE_STD it is possible to use STLport in stlport namespace at
the same time as using native library in std namespace.
* Use of the gcc visibility feature for gcc versions after 4.0.
* For builds under Windows, STLport now adapt to the PSDK used to build it. It
should be the same as the one used when building an application using the
STLport libs. A compatibility detection mecanism has been implemented in order
to report not homogeneous build environment with a link error rather than undefined
runtime error.
- Enhancements:
* Use of malloc based allocator on system having GlibC 2.3 and later, keep
node allocator for others.
* Delay instanciation of type traits type in vector and deque implementation to
be able to use some of the nested types like iterator even if type used to
instanciate the container is not completely defined.
* Container pointer specialization feature now works even with incomplete types
thanks to use of partial template specialization.
5.1:
- Major modifications
* Folder architecture: All configuration files are now in stlport/stl/config folder.
stlport/stl_user_config.h renamed and moved as stlport/stl/config/user_config.h.
stlport/stl/_site_config.h renamed and moved as stlport/stl/config/hosts.h.
STLport configuration now also try to seperate platform configuration from compiler
one.
* Allocators implementation is in src folder to enhance encapsulation. Default
allocator when using STLport without building it (_STLP_NO_IOSTREAMS) is the simple
new/delete based allocator, node allocator is the default when building the lib.
* Access to native headers has been modified to make STLport less dependant on
native headers internal includes, should improve portability.
* Segregation of headers has been improved. You might have to add now missing
functional or algorithm Standard headers include in your code.
- Enhancements
* Support enhancements:
- Borland compilers starting with the free one (5.5.1)
- HP aC++/ANSI C B3910B A.06.06
- Visual Studio 2005 for Windows CE
- Use of intrinsic type traits support of Visual Studio 2005
* Improved meta programming techniques especially in uninitialized_* algorithms.
If you need a vector of null pointer prefer to write 'vector<void*> v(10)' rather
than 'vector<void*> v(10, (void*)0)'.
* Fully functional pointer specialization feature (_STLP_USE_PTR_SPECIALIZATIONS).
* Extension of template search methods in associative and hashed container has
been completed.
* STL safe mode: Now detect badly implemented strict weak ordering functors, assert
if a < b && b < a. Same for equivalent functor used in hash container implementation,
assert if a <=> b but !(b <=> a).
* Improved locale creation delay on Windows platform.
* STL containers implementation now correctly handle allocators with state. This kind
of allocator has to overload swap method if any specific action has to be made when
swaping 2 instances.
* STLport is ready for safe string functions *_s (_STLP_USE_SAFE_STRING_FUNCTIONS)
* Many bug fixes, see etc/ChangeLog-5.1.
5.0:
- Major modifications
* No more wrapper mode: you can use STLport iostreams or no iostreams
at all.
* _STLP_NO_CUSTOM_IO now also hide basic_string implementation
* internal namespace schema has been modified, see doc folder for additionnal
informations.
- Enhancements
* Support of many modern C++ compilers and platforms
- gcc 3.4.0 and later
- MSVC .Net 2002, 2003 and MSVC 2005 Beta
- Windows CE
see build/test/unit/STATUS for a complete list of tested platforms/compilers
* Move semantic: vector or deque of any other STL containers are using
move semantic when resized or modified rather than copy.
* New checks in safe STL mode like null pointer or check of iterator range
pass to container constructors.
* Expression template for string concatenation operations (available
throught the _STLP_USE_TEMPLATE_EXPRESSION config option)
* Implementation of the short string optimization trick, basic_string have
a small static buffer in this case.
* STL containers vector, deque, list and slist pointer specialization to
limit code bloats (see _STLP_USE_PTR_SPECIALIZATIONS on config file)
* Use of boost type_traits rather than internal equivalent when requested
(see _STLP_USE_BOOST_SUPPORT in config file)
* set/multiset, or map/multimap iterators cannot be compared anymore.
* unordered_set, unordered_multiset, unordered_map, unordered_multimap hash
containers implementation specified in the TR1 document.
* Thanks to the _STLP_LEAKS_PEDANTIC config option you can ask STLport to
clean its memory pool before being unloaded, useful to only detect real
memory leak problems.
* Creation of configuration scripts to make STLport configuration easier.
* Improvment of some algorithm like search_n or stable_sort.
* Ported to 64 bits platforms.
* Large file ( > 4 Go) stream support on Win32 platform.

96
reactos/lib/3rdparty/stlport/etc/STLport-4.5.1.spec vendored Normal file
View file

@ -0,0 +1,96 @@
%define MAKEFILE gcc-linux.mak
Summary: Complete C++ standard library
Name: STLport
Version: 4.5.1
Release: 1
Copyright: free (see license), see /usr/share/doc/%{name}-%{version}/license.html
URL: http://www.stlport.org/
Packager: Levente Farkas <lfarkas@mindmaker.hu>
Group: System Environment/Languages
Icon: stlport_powered_white.gif
Source0: http://www.stlport.org/archive/%{name}-%{version}.tar.gz
Patch0: STLport-rename.patch
#Patch1: STLport-rules.patch
#Patch2: STLport-install-dir.patch
Buildroot: %{_tmppath}/%{name}-%{version}-%(id -u -n)
%description
STLport is a multiplatform STL implementation based on SGI STL.
This package contains the runtime library for STLport.
%package -n STLport-devel
Summary: Complete C++ standard library header files and libraries
Group: Development/Libraries
Requires: STLport = %{version}
%description -n STLport-devel
STLport is a multiplatform STL implementation based on SGI STL. Complete
C++ standard library, including <complex> and SGI STL iostreams. If you
would like to use your code with STLport add
"-nostdinc++ -I/usr/include/stlport" when compile and -lstlport_gcc when
link (eg: gcc -nostdinc++ -I/usr/include/stlport x.cc -lstlport_gcc).
%prep
%setup
%patch0 -p1
#%patch1 -p1
#%patch2 -p1
%build
cd src
make -f %{MAKEFILE} INSTALLDIR=$RPM_BUILD_ROOT/usr clean all
%install
rm -rf $RPM_BUILD_ROOT
cd src
make -f %{MAKEFILE} INSTALLDIR=$RPM_BUILD_ROOT/usr install
cd $RPM_BUILD_ROOT/usr/include/stlport
ln -s . ext
%clean
rm -rf $RPM_BUILD_ROOT
%post -p /sbin/ldconfig
%postun -p /sbin/ldconfig
%post -n STLport-devel
/sbin/ldconfig
%postun -n STLport-devel
/sbin/ldconfig
%files
%defattr(-,root,root)
%doc doc/license.html
/usr/lib/libstlport_gcc.so
#/usr/lib/libstlport_gcc.so.%{version}
/usr/lib/libstlport_gcc.so.4.5
%files -n STLport-devel
%defattr(-,root,root)
%doc INSTALL README doc etc test
/usr/lib/libstlport_gcc*.a
/usr/lib/libstlport_gcc_*debug.so*
/usr/include/*
%changelog
* Mon Dec 10 2001 Levente Farkas <lfarkas@mindmaker.hu>
- upgrade to 4.5.1
* Fri Nov 16 2001 Levente Farkas <lfarkas@mindmaker.hu>
- merge with Harold's changes
* Thu Nov 15 2001 <stlport@lanceerplaats.nl>
- rebuild for RedHat 7.2, spec file fixes.
* Tue Oct 2 2001 Levente Farkas <lfarkas@mindmaker.hu>
- upgrade to 4.5
* Thu Oct 26 2000 Levente Farkas <lfarkas@mindmaker.hu>
- upgrade to 4.1-b3
* Thu Jul 17 2000 Levente Farkas <lfarkas@mindmaker.hu>
- initial release use STLport-4.0

96
reactos/lib/3rdparty/stlport/etc/STLport-4.5.3.spec vendored Normal file
View file

@ -0,0 +1,96 @@
%define MAKEFILE gcc-linux.mak
Summary: Complete C++ standard library
Name: STLport
Version: 4.5.3
Release: 1
Copyright: free (see license), see /usr/share/doc/%{name}-%{version}/license.html
URL: http://www.stlport.org/
Packager: Levente Farkas <lfarkas@mindmaker.hu>
Group: System Environment/Languages
Icon: stlport_powered_white.gif
Source0: http://www.stlport.org/archive/%{name}-%{version}.tar.gz
#Patch0: STLport-rename.patch
#Patch1: STLport-rules.patch
#Patch2: STLport-install-dir.patch
Buildroot: %{_tmppath}/%{name}-%{version}-%(id -u -n)
%description
STLport is a multiplatform STL implementation based on SGI STL.
This package contains the runtime library for STLport.
%package -n STLport-devel
Summary: Complete C++ standard library header files and libraries
Group: Development/Libraries
Requires: STLport = %{version}
%description -n STLport-devel
STLport is a multiplatform STL implementation based on SGI STL. Complete
C++ standard library, including <complex> and SGI STL iostreams. If you
would like to use your code with STLport add
"-nostdinc++ -I/usr/include/stlport" when compile and -lstlport_gcc when
link (eg: gcc -nostdinc++ -I/usr/include/stlport x.cc -lstlport_gcc).
%prep
%setup
%patch0 -p1
#%patch1 -p1
#%patch2 -p1
%build
cd src
make -f %{MAKEFILE} INSTALLDIR=$RPM_BUILD_ROOT/usr clean all
%install
rm -rf $RPM_BUILD_ROOT
cd src
make -f %{MAKEFILE} INSTALLDIR=$RPM_BUILD_ROOT/usr install
cd $RPM_BUILD_ROOT/usr/include/stlport
ln -s . ext
%clean
rm -rf $RPM_BUILD_ROOT
%post -p /sbin/ldconfig
%postun -p /sbin/ldconfig
%post -n STLport-devel
/sbin/ldconfig
%postun -n STLport-devel
/sbin/ldconfig
%files
%defattr(-,root,root)
%doc doc/license.html
/usr/lib/libstlport_gcc.so
#/usr/lib/libstlport_gcc.so.%{version}
/usr/lib/libstlport_gcc.so.4.5
%files -n STLport-devel
%defattr(-,root,root)
%doc INSTALL README doc etc test
/usr/lib/libstlport_gcc*.a
/usr/lib/libstlport_gcc_*debug.so*
/usr/include/*
%changelog
* Mon Dec 10 2001 Levente Farkas <lfarkas@mindmaker.hu>
- upgrade to 4.5.1
* Fri Nov 16 2001 Levente Farkas <lfarkas@mindmaker.hu>
- merge with Harold's changes
* Thu Nov 15 2001 <stlport@lanceerplaats.nl>
- rebuild for RedHat 7.2, spec file fixes.
* Tue Oct 2 2001 Levente Farkas <lfarkas@mindmaker.hu>
- upgrade to 4.5
* Thu Oct 26 2000 Levente Farkas <lfarkas@mindmaker.hu>
- upgrade to 4.1-b3
* Thu Jul 17 2000 Levente Farkas <lfarkas@mindmaker.hu>
- initial release use STLport-4.0

99
reactos/lib/3rdparty/stlport/etc/STLport-4.6.spec vendored Normal file
View file

@ -0,0 +1,99 @@
%define MAKEFILE gcc-linux.mak
Summary: Complete C++ standard library
Name: STLport
Version: 4.6
Release: 1
Copyright: free (see license), see /usr/share/doc/%{name}-%{version}/license.html
URL: http://www.stlport.org/
Packager: Levente Farkas <lfarkas@mindmaker.hu>
Group: System Environment/Languages
Icon: stlport_powered_white.gif
Source0: http://www.stlport.org/archive/%{name}-%{version}.tar.gz
#Patch0: STLport-rename.patch
#Patch1: STLport-rules.patch
#Patch2: STLport-install-dir.patch
Buildroot: %{_tmppath}/%{name}-%{version}-%(id -u -n)
%description
STLport is a multiplatform STL implementation based on SGI STL.
This package contains the runtime library for STLport.
%package -n STLport-devel
Summary: Complete C++ standard library header files and libraries
Group: Development/Libraries
Requires: STLport = %{version}
%description -n STLport-devel
STLport is a multiplatform STL implementation based on SGI STL. Complete
C++ standard library, including <complex> and SGI STL iostreams. If you
would like to use your code with STLport add
"-nostdinc++ -I/usr/include/stlport" when compile and -lstlport_gcc when
link (eg: gcc -nostdinc++ -I/usr/include/stlport x.cc -lstlport_gcc).
%prep
%setup
%patch0 -p1
#%patch1 -p1
#%patch2 -p1
%build
cd src
make -f %{MAKEFILE} INSTALLDIR=$RPM_BUILD_ROOT/usr clean all
%install
rm -rf $RPM_BUILD_ROOT
cd src
make -f %{MAKEFILE} INSTALLDIR=$RPM_BUILD_ROOT/usr install
cd $RPM_BUILD_ROOT/usr/include/stlport
ln -s . ext
%clean
rm -rf $RPM_BUILD_ROOT
%post -p /sbin/ldconfig
%postun -p /sbin/ldconfig
%post -n STLport-devel
/sbin/ldconfig
%postun -n STLport-devel
/sbin/ldconfig
%files
%defattr(-,root,root)
%doc doc/license.html
/usr/lib/libstlport_gcc.so
#/usr/lib/libstlport_gcc.so.%{version}
/usr/lib/libstlport_gcc.so.4.6
%files -n STLport-devel
%defattr(-,root,root)
%doc INSTALL README doc etc test
/usr/lib/libstlport_gcc*.a
/usr/lib/libstlport_gcc_*debug.so*
/usr/include/*
%changelog
* Fri Oct 31 2003 <boris@stlport.com>
- upgrade to 4.6
* Mon Dec 10 2001 Levente Farkas <lfarkas@mindmaker.hu>
- upgrade to 4.5.1
* Fri Nov 16 2001 Levente Farkas <lfarkas@mindmaker.hu>
- merge with Harold's changes
* Thu Nov 15 2001 <stlport@lanceerplaats.nl>
- rebuild for RedHat 7.2, spec file fixes.
* Tue Oct 2 2001 Levente Farkas <lfarkas@mindmaker.hu>
- upgrade to 4.5
* Thu Oct 26 2000 Levente Farkas <lfarkas@mindmaker.hu>
- upgrade to 4.1-b3
* Thu Jul 17 2000 Levente Farkas <lfarkas@mindmaker.hu>
- initial release use STLport-4.0

835
reactos/lib/3rdparty/stlport/etc/autoexp.dat vendored Normal file
View file

@ -0,0 +1,835 @@
;------------------------------------------------------------------------------
; This is the description of STLport data structures in Visual Studio debugger
; language. Those descriptions has been tested with Visual C++ 2005 Express
; Edition, you are welcome to report successful usage with any other Visual
; Studio version.
; Those descriptions has been tested with STLport 5.2.0.
; How to use: Copy/Paste this file content in the autoexp.dat file you will find
; in your Visual Studio install, for instance
; C:\Program Files\Microsoft Visual Studio 8\Common7\Packages\Debugger, in the
; [Visualizer] section.
; TODO: Enhance debug iterator visualization to report end iterators.
; TODO: Add visualization for rope.
; TODO: Fix bitset visualization.
;------------------------------------------------------------------------------
;------------------------------------------------------------------------------
; stlport::basic_string
;------------------------------------------------------------------------------
stlp_std::basic_string<char,*>|stlpx_std::basic_string<char,*>|stlpmtx_std::basic_string<char,*>|stlpxmtx_std::basic_string<char,*>|stlpd_std::priv::_NonDbg_str<char,*>|stlpdx_std::priv::_NonDbg_str<char,*>|stlpdmtx_std::priv::_NonDbg_str<char,*>|stlpdxmtx_std::priv::_NonDbg_str<char,*>{
preview
(
[$c._M_start_of_storage._M_data, s]
)
stringview
(
[$c._M_start_of_storage._M_data, s]
)
children
(
#(
[raw view]: [$c,!],
buffer: [(unsigned int)$c._M_start_of_storage._M_data, x],
length: $c._M_finish - $c._M_start_of_storage._M_data,
capacity: #if($c._M_start_of_storage._M_data == $c._M_buffers._M_static_buf)
(
$c._DEFAULT_SIZE
)
#else
(
$c._M_buffers._M_end_of_storage - $c._M_start_of_storage._M_data
),
#array
(
expr: $c._M_start_of_storage._M_data[$i],
size: $c._M_finish - $c._M_start_of_storage._M_data
)
)
)
}
stlp_std::basic_string<unsigned short,*>|stlp_std::basic_string<wchar_t,*>|stlpx_std::basic_string<unsigned short,*>|stlpx_std::basic_string<wchar_t,*>|stlpmtx_std::basic_string<unsigned short,*>|stlpmtx_std::basic_string<wchar_t,*>|stlpxmtx_std::basic_string<unsigned short,*>|stlpxmtx_std::basic_string<wchar_t,*>|stlpd_std::priv::_NonDbg_str<unsigned short,*>|stlpd_std::priv::_NonDbg_str<wchar_t,*>|stlpdx_std::priv::_NonDbg_str<unsigned short,*>|stlpdx_std::priv::_NonDbg_str<wchar_t,*>|stlpdmtx_std::priv::_NonDbg_str<unsigned short,*>|stlpdmtx_std::priv::_NonDbg_str<wchar_t,*>|stlpdxmtx_std::priv::_NonDbg_str<unsigned short,*>|stlpdxmtx_std::priv::_NonDbg_str<wchar_t,*>{
preview
(
[$c._M_start_of_storage._M_data, su]
)
stringview
(
[$c._M_start_of_storage._M_data, su]
)
children
(
#(
[raw view]: [$c,!],
buffer: [(unsigned int)$c._M_start_of_storage._M_data, x],
length: $c._M_finish - $c._M_start_of_storage._M_data,
capacity: #if($c._M_start_of_storage._M_data == $c._M_buffers._M_static_buf)
(
$c._DEFAULT_SIZE
)
#else
(
$c._M_buffers._M_end_of_storage - $c._M_start_of_storage._M_data
),
#array
(
expr: $c._M_start_of_storage._M_data[$i],
size: $c._M_finish - $c._M_start_of_storage._M_data
)
)
)
}
stlpd_std::basic_string<*>|stlpdx_std::basic_string<*>|stlpdmtx_std::basic_string<*>|stlpdxmtx_std::basic_string<*>{
preview
(
$c._M_non_dbg_impl
)
stringview
(
$c._M_non_dbg_impl
)
children
(
#(
[raw view]: [$c,!],
string: $c._M_non_dbg_impl
)
)
}
;------------------------------------------------------------------------------
; stlport::vector
;------------------------------------------------------------------------------
stlp_std::vector<bool,*>|stlpx_std::vector<bool,*>|stlpmtx_std::vector<bool,*>|stlpxmtx_std::vector<bool,*>|stlpd_std::priv::_NonDbg_vector<bool,*>|stlpdx_std::priv::_NonDbg_vector<bool,*>|stlpdmtx_std::priv::_NonDbg_vector<bool,*>|stlpdxmtx_std::priv::_NonDbg_vector<bool,*>{
preview
(
#(
"[",
($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset,
"](",
#array
(
expr : ($c._M_start._M_p[$i / (sizeof(unsigned int) * 8)] >> ($i % (sizeof(unsigned int) * 8))),
size : (($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset)
) : (bool)($e & 1),
")"
)
)
children
(
#(
[raw view]: [$c,!],
buffer : [(unsigned int)$c._M_start._M_p, x],
size : (($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset),
#array
(
expr : ($c._M_start._M_p[$i / (sizeof(unsigned int) * 8)] >> ($i % (sizeof(unsigned int) * 8))),
size : (($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset)
) : (bool)($e & 1)
)
)
}
stlp_std::priv::_Bit_iter<*>|stlpx_std::priv::_Bit_iter<*>|stlpmtx_std::priv::_Bit_iter<*>|stlpxmtx_std::priv::_Bit_iter<*>|stlpd_std::priv::_Bit_iter<*>|stlpdx_std::priv::_Bit_iter<*>|stlpdmtx_std::priv::::_Bit_iter<*>|stlpdxmtx_std::priv::_Bit_iter<*>{
preview
(
#(
(bool) (((*$c._M_p) >> $c._M_offset) & 1)
)
)
children
(
#(
[raw view]: [$c,!],
value : (bool) (((*$c._M_p) >> $c._M_offset) & 1)
)
)
}
stlp_std::vector<*>|stlpx_std::vector<*>|stlpmtx_std::vector<*>|stlpxmtx_std::vector<*>|stlpd_std::priv::_NonDbg_vector<*>|stlpdx_std::priv::_NonDbg_vector<*>|stlpdmtx_std::priv::_NonDbg_vector<*>|stlpdxmtx_std::priv::_NonDbg_vector<*>{
preview
(
#(
"[",
$c._M_finish - $c._M_start,
"/",
$c._M_end_of_storage._M_data - $c._M_start,
"](",
#array
(
expr : ($c._M_start)[$i],
size : $c._M_finish - $c._M_start
),
")"
)
)
children
(
#(
[raw view]: [$c,!],
size : $c._M_finish - $c._M_start,
capacity : $c._M_end_of_storage._M_data - $c._M_start,
#array
(
expr : ($c._M_start)[$i],
size : $c._M_finish - $c._M_start
)
)
)
}
stlpd_std::vector<*>|stlpdx_std::vector<*>|stlpdmtx_std::vector<*>|stlpdxmtx_std::vector<*>{
preview
(
$c._M_non_dbg_impl
)
children
(
#(
[raw view] : [$c,!],
vector : $c._M_non_dbg_impl
)
)
}
;------------------------------------------------------------------------------
; stlport::deque
;------------------------------------------------------------------------------
stlp_std::deque<*,*>|stlpx_std::deque<*,*>|stlpmtx_std::deque<*,*>|stlpxmtx_std::deque<*,*>|stlpd_std::priv::_NonDbg_deque<*,*>|stlpdx_std::priv::_NonDbg_deque<*,*>|stlpdmtx_std::priv::_NonDbg_deque<*,*>|stlpdxmtx_std::priv::_NonDbg_deque<*,*>{
preview
(
#if (((unsigned int)($c._M_start._M_cur + 1) - ((unsigned int)$c._M_start._M_cur)) < _MAX_BYTES)
(
#(
"[",
(($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur),
"/",
($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1)) - 1,
"](",
#array
(
expr : *(*($c._M_start._M_node + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) / (_MAX_BYTES / sizeof($T1)))) + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) % (_MAX_BYTES / sizeof($T1)))),
size : (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur)
),
")"
)
)
#else
(
#(
"[",
$c._M_finish._M_node - $c._M_start._M_node,
"/",
$c._M_finish._M_node - $c._M_start._M_node,
"](",
#array
(
expr : **($c._M_start._M_node + $i),
size : $c._M_finish._M_node - $c._M_start._M_node
),
")"
)
)
)
children
(
#if (((unsigned int)($c._M_start._M_cur + 1) - ((unsigned int)$c._M_start._M_cur)) < _MAX_BYTES)
(
#(
[raw view]: [$c,!],
size : (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur),
capacity : ($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1)) - 1,
front free space : $c._M_start._M_cur - $c._M_start._M_first,
back free space : $c._M_finish._M_last - $c._M_finish._M_cur - 1,
#array
(
expr : *(*($c._M_start._M_node + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) / (_MAX_BYTES / sizeof($T1)))) + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) % (_MAX_BYTES / sizeof($T1)))),
size : (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur)
)
)
)
#else
(
#(
[raw view] : [$c,!],
size : $c._M_finish._M_node - $c._M_start._M_node,
capacity : $c._M_finish._M_node - $c._M_start._M_node,
front free space : $c._M_start._M_cur - $c._M_start._M_first,
back free space : $c._M_finish._M_last - $c._M_finish._M_cur - 1,
#array
(
expr : **($c._M_start._M_node + $i),
size : $c._M_finish._M_node - $c._M_start._M_node
)
)
)
)
}
stlp_std::priv::_Deque_iterator<*>|stlpx_std::priv::_Deque_iterator<*>|stlpmtx_std::priv::_Deque_iterator<*>|stlpxmtx_std::priv::_Deque_iterator<*>|stlpd_std::priv::_Deque_iterator<*>|stlpdx_std::priv::_Deque_iterator<*>|stlpdmtx_std::priv::_Deque_iterator<*>|stlpdxmtx_std::priv::_Deque_iterator<*>{
preview
(
*($c._M_cur)
)
children
(
#(
[raw view] : [$c, !],
ptr : [(unsigned int)($c._M_cur), x],
value : *($c._M_cur)
)
)
}
stlpd_std::deque<*>|stlpdx_std::deque<*>|stlpdmtx_std::deque<*>|stlpdxmtx_std::deque<*>{
preview
(
$c._M_non_dbg_impl
)
children
(
#(
[raw view] : [$c,!],
deque : $c._M_non_dbg_impl
)
)
}
;------------------------------------------------------------------------------
; stlport::list
;------------------------------------------------------------------------------
stlp_std::list<*,*>|stlpx_std::list<*,*>|stlpmtx_std::list<*,*>|stlpxmtx_std::list<*,*>|stlpd_std::priv::_NonDbg_list<*,*>|stlpdx_std::priv::_NonDbg_list<*,*>|stlpdmtx_std::priv::_NonDbg_list<*,*>|stlpdxmtx_std::priv::_NonDbg_list<*,*>{
preview
(
#(
"(",
#list
(
head : $c._M_node._M_data._M_next,
skip : &($c._M_node._M_data),
next : _M_next,
): #( *($T1*)(&($e) + 1)),
")"
)
)
children
(
#(
[raw view]: [$c,!],
#list
(
head : $c._M_node._M_data._M_next,
skip : &($c._M_node._M_data),
next : _M_next,
): #( *($T1*)(&($e) + 1))
)
)
}
stlp_std::priv::_List_iterator<*,*>|stlpx_std::priv::_List_iterator<*,*>|stlpmtx_std::priv::_List_iterator<*,*>|stlpxmtx_std::priv::_List_iterator<*,*>|stlpd_std::priv::_List_iterator<*,*>|stlpdx_std::priv::_List_iterator<*,*>|stlpdmtx_std::priv::_List_iterator<*,*>|stlpdxmtx_std::priv::_List_iterator<*,*>{
preview
(
#(*($T1 *)($c._M_node + 1))
)
children
(
#(
[raw view] : [$c, !],
ptr : [(unsigned int)($c._M_node + 1), x],
value : *($T1 *)($c._M_node + 1)
)
)
}
stlpd_std::list<*,*>|stlpdx_std::list<*,*>|stlpdmtx_std::list<*,*>|stlpdxmtx_std::list<*,*>{
preview
(
$c._M_non_dbg_impl
)
children
(
#(
[raw view] : [$c,!],
list : $c._M_non_dbg_impl
)
)
}
;------------------------------------------------------------------------------
; stlport::slist
;------------------------------------------------------------------------------
stlp_std::slist<*,*>|stlpx_std::slist<*,*>|stlpmtx_std::slist<*,*>|stlpxmtx_std::slist<*,*>|stlpd_std::priv::_NonDbg_slist<*,*>|stlpdx_std::priv::_NonDbg_slist<*,*>|stlpdmtx_std::priv::_NonDbg_slist<*,*>|stlpdxmtx_std::priv::_NonDbg_slist<*,*>{
preview
(
#(
"(",
#list
(
head : $c._M_head._M_data._M_next,
skip : &($c._M_head._M_data),
next : _M_next,
): #( *($T1*)(&($e) + 1)),
")"
)
)
children
(
#(
[raw view]: [$c,!],
#list
(
head : $c._M_head._M_data._M_next,
skip : &($c._M_head._M_data),
next : _M_next,
): #( *($T1*)(&($e) + 1))
)
)
}
stlp_std::priv::_Slist_iterator<*,*>|stlpx_std::priv::_Slist_iterator<*,*>|stlpmtx_std::priv::_Slist_iterator<*,*>|stlpxmtx_std::priv::_Slist_iterator<*,*>|stlpd_std::priv::_Slist_iterator<*,*>|stlpdx_std::priv::_Slist_iterator<*,*>|stlpdmtx_std::priv::_Slist_iterator<*,*>|stlpdxmtx_std::priv::_Slist_iterator<*,*>{
preview
(
#(*($T1 *)($c._M_node + 1))
)
children
(
#(
[raw view] : [$c,!],
ptr : [(unsigned int)($c._M_node + 1), x],
value : *($T1 *)($c._M_node + 1)
)
)
}
stlpd_std::slist<*,*>|stlpdx_std::slist<*,*>|stlpdmtx_std::slist<*,*>|stlpdxmtx_std::slist<*,*>{
preview
(
$c._M_non_dbg_impl
)
children
(
#(
[raw view] : [$c,!],
[slist] : $c._M_non_dbg_impl
)
)
}
;------------------------------------------------------------------------------
; stlport::pair
;------------------------------------------------------------------------------
stlp_std::pair<*,*>|stlpx_std::pair<*,*>|stlpmtx_std::pair<*,*>|stlpxmtx_std::pair<*,*>|stlpd_std::pair<*,*>|stlpdx_std::pair<*,*>|stlpdmtx_std::pair<*,*>|stlpdxmtx_std::pair<*,*>{
preview
(
#(
"(",
$c.first,
", ",
$c.second,
")"
)
)
}
;------------------------------------------------------------------------------
; stlport::map, stlport::multimap, stlport::set, stlport::multiset
;------------------------------------------------------------------------------
stlp_std::map<*>|stlpx_std::map<*>|stlpmtx_std::map<*>|stlpxmtx_std::map<*>|stlp_std::multimap<*>|stlpx_std::multimap<*>|stlpmtx_std::multimap<*>|stlpxmtx_std::multimap<*>|stlp_std::set<*>|stlpx_std::set<*>|stlpmtx_std::set<*>|stlpxmtx_std::set<*>|stlp_std::multiset<*>|stlpx_std::multiset<*>|stlpmtx_std::multiset<*>|stlpxmtx_std::multiset<*>{
preview
(
#(
"[",
$c._M_t._M_node_count,
"](",
$c._M_t,
")"
)
)
children
(
#(
[raw view]: [$c,!],
size: [$c._M_t._M_node_count],
tree: $c._M_t
)
)
}
stlpd_std::map<*>|stlpdx_std::map<*>|stlpdmtx_std::map<*>|stlpdxmtx_std::map<*>|stlpd_std::multimap<*>|stlpdx_std::multimap<*>|stlpdmtx_std::multimap<*>|stlpdxmtx_std::multimap<*>|stlpd_std::set<*>|stlpdx_std::set<*>|stlpdmtx_std::set<*>|stlpdxmtx_std::set<*>|stlpd_std::multiset<*>|stlpdx_std::multiset<*>|stlpdmtx_std::multiset<*>|stlpdxmtx_std::multiset<*>{
preview
(
#(
"[",
$c._M_t._M_non_dbg_impl._M_node_count,
"](",
$c._M_t._M_non_dbg_impl,
")"
)
)
children
(
#(
[raw view]: [$c,!],
size: $c._M_t._M_non_dbg_impl._M_node_count,
tree: $c._M_t._M_non_dbg_impl
)
)
}
stlp_std::priv::_Rb_tree<*,*,*,*,*>|stlpx_std::priv::_Rb_tree<*,*,*,*,*>|stlpmtx_std::priv::_Rb_tree<*,*,*,*,*>|stlpxmtx_std::priv::_Rb_tree<*,*,*,*,*>|stlpd_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>|stlpdx_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>|stlpdmtx_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>|stlpdxmtx_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>{
preview
(
#tree
(
head : $c._M_header._M_data._M_parent,
skip : &($c._M_header._M_data),
size : $c._M_node_count,
left : _M_left,
right : _M_right
): #(*($T3 *)(&($e) + 1))
)
children
(
#(
[raw view]: [$c,!],
#tree
(
head : $c._M_header._M_data._M_parent,
skip : &($c._M_header._M_data),
size : $c._M_node_count,
left : _M_left,
right : _M_right
) : #(*($T3 *)(&($e) + 1))
)
)
}
stlp_std::priv::_Rb_tree_iterator<*,*>|stlpx_std::priv::_Rb_tree_iterator<*,*>|stlpmtx_std::priv::_Rb_tree_iterator<*,*>|stlpxmtx_std::priv::_Rb_tree_iterator<*,*>|stlpd_std::priv::_Rb_tree_iterator<*,*>|stlpdx_std::priv::_Rb_tree_iterator<*,*>|stlpdmtx_std::priv::_Rb_tree_iterator<*,*>|stlpdxmtx_std::priv::_Rb_tree_iterator<*,*>{
preview
(
[*($T1*)($c._M_node + 1)]
)
children
(
#(
[raw view]: [$c,!],
value: [*($T1*)($c._M_node + 1)],
ptr: [(unsigned int)($c._M_node + 1), x]
)
)
}
;------------------------------------------------------------------------------
; stlport::hash_map, stlport::hash_multimap, stlport::hash_set, stlport::hash_multiset
; stlport::unordered_map, stlport::unordered_multimap, stlport::unordered_set, stlport::unordered_multiset
;------------------------------------------------------------------------------
stlp_std::hash_map<*>|stlpx_std::hash_map<*>|stlpmtx_std::hash_map<*>|stlpxmtx_std::hash_map<*>|stlp_std::hash_multimap<*>|stlpx_std::hash_multimap<*>|stlpmtx_std::hash_multimap<*>|stlpxmtx_std::hash_multimap<*>|stlp_std::hash_set<*>|stlpx_std::hash_set<*>|stlpmtx_std::hash_set<*>|stlpxmtx_std::hash_set<*>|stlp_std::hash_multiset<*>|stlpx_std::hash_multiset<*>|stlpmtx_std::hash_multiset<*>|stlpxmtx_std::hash_multiset<*>|stlp_std::tr1::unordered_map<*>|stlpx_std::tr1::unordered_map<*>|stlpmtx_std::tr1::unordered_map<*>|stlpxmtx_std::tr1::unordered_map<*>|stlp_std::tr1::unordered_multimap<*>|stlpx_std::tr1::unordered_multimap<*>|stlpmtx_std::tr1::unordered_multimap<*>|stlpxmtx_std::tr1::unordered_multimap<*>|stlp_std::tr1::unordered_set<*>|stlpx_std::tr1::unordered_set<*>|stlpmtx_std::tr1::unordered_set<*>|stlpxmtx_std::tr1::unordered_set<*>|stlp_std::tr1::unordered_multiset<*>|stlpx_std::tr1::unordered_multiset<*>|stlpmtx_std::tr1::unordered_multiset<*>|stlpxmtx_std::tr1::unordered_multiset<*>{
preview
(
#(
"[",
$c._M_ht._M_num_elements,
"]",
$c._M_ht
)
)
children
(
#(
[raw view]: [$c,!],
hashtable: $c._M_ht
)
)
}
stlpd_std::hash_map<*>|stlpdx_std::hash_map<*>|stlpdmtx_std::hash_map<*>|stlpdxmtx_std::hash_map<*>|stlpd_std::hash_multimap<*>|stlpdx_std::hash_multimap<*>|stlpdmtx_std::hash_multimap<*>|stlpdxmtx_std::hash_multimap<*>|stlpd_std::hash_set<*>|stlpdx_std::hash_set<*>|stlpdmtx_std::hash_set<*>|stlpdxmtx_std::hash_set<*>|stlpd_std::hash_multiset<*>|stlpdx_std::hash_multiset<*>|stlpdmtx_std::hash_multiset<*>|stlpdxmtx_std::hash_multiset<*>|stlpd_std::tr1::unordered_map<*>|stlpdx_std::tr1::unordered_map<*>|stlpdmtx_std::tr1::unordered_map<*>|stlpdxmtx_std::tr1::unordered_map<*>|stlpd_std::tr1::unordered_multimap<*>|stlpdx_std::tr1::unordered_multimap<*>|stlpdmtx_std::tr1::unordered_multimap<*>|stlpdxmtx_std::tr1::unordered_multimap<*>|stlpd_std::tr1::unordered_set<*>|stlpdx_std::tr1::unordered_set<*>|stlpdmtx_std::tr1::unordered_set<*>|stlpdxmtx_std::tr1::unordered_set<*>|stlpd_std::tr1::unordered_multiset<*>|stlpdx_std::tr1::unordered_multiset<*>|stlpdmtx_std::tr1::unordered_multiset<*>|stlpdxmtx_std::tr1::unordered_multiset<*>{
preview
(
#(
"[",
$c._M_ht._M_non_dbg_impl._M_num_elements,
"]",
$c._M_ht._M_non_dbg_impl
)
)
children
(
#(
[raw view]: [$c,!],
hashtable: $c._M_ht._M_non_dbg_impl
)
)
}
stlp_std::hashtable<*,*>|stlpx_std::hashtable<*,*>|stlpmtx_std::hashtable<*,*>|stlpxmtx_std::hashtable<*,*>|stlpd_std::priv::_NonDbg_hashtable<*,*>|stlpdx_std::priv::_NonDbg_hashtable<*,*>|stlpdmtx_std::priv::_NonDbg_hashtable<*,*>|stlpdxmtx_std::priv::_NonDbg_hashtable<*,*>{
preview
(
$c._M_elems
)
children
(
#(
[raw view]: [$c,!],
size : $c._M_num_elements,
load factor : (float)$c._M_num_elements / ($c._M_buckets._M_finish - $c._M_buckets._M_start),
max load factor: $c._M_max_load_factor,
buckets : $c._M_buckets,
elements : $c._M_elems
)
)
}
;------------------------------------------------------------------------------
; stlport::queue, stlport::priority_queue, stlport::stack
;------------------------------------------------------------------------------
stlp_std::queue<*>|stlpx_std::queue<*>|stlpmtx_std::queue<*>|stlpxmtx_std::queue<*>|stlpd_std::queue<*>|stlpdx_std::queue<*>|stlpdmtx_std::queue<*>|stlpdxmtx_std::queue<*>|stlp_std::priority_queue<*>|stlpx_std::priority_queue<*>|stlpmtx_std::priority_queue<*>|stlpxmtx_std::priority_queue<*>|stlpd_std::priority_queue<*>|stlpdx_std::priority_queue<*>|stlpdmtx_std::priority_queue<*>|stlpdxmtx_std::priority_queue<*>|stlp_std::stack<*>|stlpx_std::stack<*>|stlpmtx_std::stack<*>|stlpxmtx_std::stack<*>|stlpd_std::stack<*>|stlpdx_std::stack<*>|stlpdmtx_std::stack<*>|stlpdxmtx_std::stack<*>{
preview
(
$c.c
)
children
(
#(
[raw view] : [$c,!],
container : $c.c
)
)
}
;------------------------------------------------------------------------------
; stlport debug iterator
;------------------------------------------------------------------------------
stlp_std::priv::_DBG_iter<*>|stlpx_std::priv::_DBG_iter<*>|stlpmtx_std::priv::_DBG_iter<*>|stlpxmtx_std::priv::_DBG_iter<*>|stlpd_std::priv::_DBG_iter<*>|stlpdx_std::priv::_DBG_iter<*>|stlpdmtx_std::priv::_DBG_iter<*>|stlpdxmtx_std::priv::_DBG_iter<*>{
preview
(
#if($c._M_owner != 0)
(
$c._M_iterator
)
#else
(
"undefined"
)
)
children
(
#(
#if($c._M_owner != 0)
(
#(
[raw view] : [$c,!],
[iterator] : $c._M_iterator,
[valid] : [true]
)
)
#else
(
#(
[raw view] : [$c,!],
[valid] : [false]
)
)
)
)
}
;------------------------------------------------------------------------------
; stlport::bitset
; TODO: Fix it, it doesn't work as expected even when adding an enum to the bitset
; class to get access to the bitset static size rather than using $T1.
;------------------------------------------------------------------------------
stdp_std::bitset<*,*>|stdpx_std::bitset<*,*>|stdpmtx_std::bitset<*,*>|stdpxmtx_std::bitset<*,*>|stdpd_std::bitset<*>|stdpdx_std::bitset<*>|stdpdmtx_std::bitset<*>|stdpdxmtx_std::bitset<*>{
preview
(
#(
"[",
$T1,
"](",
#array
(
expr : ($c._M_w[$i / (sizeof(unsigned long) * 8)] >> ($i % (sizeof(unsigned long) * 8))),
size : $T1
) : [($e & 1),d],
")"
)
)
children
(
#array
(
expr : ($c._M_w[$i / (sizeof(unsigned long) * 8)] >> ($i % (sizeof(unsigned long) * 8))),
size : $T1
) : (bool)($e & 1)
)
}
stdp_std::bitset<*>::reference|stdpx_std::bitset<*>::reference|stdpmtx_std::bitset<*>::reference|stdpxmtx_std::bitset<*>::reference|stdpd_std::bitset<*>::reference|stdpdx_std::bitset<*>::reference|stdpdmtx_std::bitset<*>::reference|stdpdxmtx_std::bitset<*>{
preview
(
#(
"bitset[", $c._M_bpos, "] = ",
(bool)(*($c._M_wp) >> $c._M_bpos) & 1)
)
)
}
;------------------------------------------------------------------------------
; stlport::auto_ptr
;------------------------------------------------------------------------------
stlp_std::auto_ptr<*>|stlpx_std::auto_ptr<*>|stlpmtx_std::auto_ptr<*>|stlpxmtx_std::auto_ptr<*>|stlpd_std::auto_ptr<*>|stlpdx_std::auto_ptr<*>|stlpdmtx_std::auto_ptr<*>|stlpdxmtx_std::auto_ptr<*>{
preview
(
#if(($c._M_p) != 0)
(
[*($T1 *)$c._M_p]
)
#else
(
"null"
)
)
children
(
#if(($c._M_p) != 0)
(
#(
[raw view]: [$c,!],
ptr: [(unsigned int)$c._M_p, x],
value: [*($T1 *)$c._M_p]
)
)
#else
(
#(
[raw view]: [$c,!]
)
)
)
}
;------------------------------------------------------------------------------
; stlport::complex
;------------------------------------------------------------------------------
stlp_std::complex<*>|stlpx_std::complex<*>|stlpmtx_std::complex<*>|stlpxmtx_std::complex<*>|stlpd_std::complex<*>|stlpdx_std::complex<*>|stlpdmtx_std::complex<*>|stlpdxmtx_std::complex<*>{
children
(
#(
real: $e._M_re,
imaginary: $e._M_im
)
)
preview
(
#if($e._M_im != 0)
(
#if ($e._M_re != 0)
( ; Real and Imaginary components
#if ($e._M_im >= 0)
(
#($e._M_re,"+i*", $e._M_im)
)
#else
(
#($e._M_re,"-i*", -$e._M_im)
)
)
#else
( ; Purely imaginary
#if ($e._M_im >= 0.0)
(
#("i*", $e._M_im)
)
#else
(
#("-i*", -$e._M_im)
)
)
)
#else
( ; Purely real
$e._M_re
)
)
}
;------------------------------------------------------------------------------
; stlport::valarray
;------------------------------------------------------------------------------
stlp_std::valarray<*>|stlpx_std::valarray<*>|stlpmtx_std::valarray<*>|stlpxmtx_std::valarray<*>|stlpd_std::valarray<*>|stlpdx_std::valarray<*>|stlpdmtx_std::valarray<*>|stlpdxmtx_std::valarray<*>{
preview
(
#(
"[",
$c._M_size ,
"](",
#array
(
expr : ($c._M_first)[$i],
size : $c._M_size
),
")"
)
)
children
(
#array
(
expr : ($c._M_first)[$i],
size : $c._M_size
)
)
}
stlp_std::slice|stlpx_std::slice|stlpmtx_std::slice|stlpxmtx_std::slice|stlpd_std::slice|stlpdx_std::slice|stlpdmtx_std::slice|stlpdxmtx_std::slice{
preview
(
#(
"start = ",
$c._M_start,
", size = ",
$c._M_length,
", stride = ",
$c._M_stride
)
)
children
(
#(
[raw view] : [$c,!],
start : $c._M_start,
size : $c._M_length,
stride : $c._M_stride
)
)
}
stlp_std::gslice|stlpx_std::gslice|stlpmtx_std::gslice|stlpxmtx_std::gslice|stlpd_std::gslice|stlpdx_std::gslice|stlpdmtx_std::gslice|stlpdxmtx_std::gslice{
preview
(
#(
"start = ",
$c._M_start,
", sizes = ",
$c._M_lengths,
", strides = ",
$c._M_strides
)
)
children
(
#(
[raw view] : [$c,!],
start : $c._M_start,
sizes : $c._M_lengths,
strides : $c._M_strides
)
)
}

309
reactos/lib/3rdparty/stlport/etc/msvcincl.dat vendored Normal file
View file

@ -0,0 +1,309 @@
algo.h
algobase.h
algorith.h
algorithm
alloc.h
bitset
bitset.h
bvector.h
cassert
cassert.h
cctype
cctype.h
cerrno
cerrno.h
cfloat
cfloat.h
char_traits.h
climits
climits.h
clocale
clocale.h
cmath
cmath.h
complex
complex.h
concept_checks.h
configure
configure.in
csetjmp
csetjmp.h
csignal
csignal.h
cstdarg
cstdarg.h
cstddef
cstddef.h
cstdio
cstdio.h
cstdlib
cstdlib.h
cstring
cstring.h
ctime
ctime.h
ctype.h
cwchar
cwchar.h
cwctype
cwctype.h
c_locale.h
defalloc.h
deque
deque.h
exceptio.h
exception
exception.h
export
fstream
fstream.h
function.h
functional
hashtable.h
hash_map
hash_map.h
hash_set
hash_set.h
heap.h
iomanip
iomanip.h
ios
ios.h
iosfwd
iosfwd.h
iostream
iostream.h
istream
istream.h
iterator
iterator.h
limits
limits.h
list
list.h
locale
locale.h
map
map.h
math.h
mem.h
memory
memory.h
mmemory.h
msl_string.h
multimap.h
multiset.h
new
new.h
numeric
numeric.h
numeric.h
ostream
ostream.h
pair.h
pthread.h
pthread_alloc
pthread_alloc.h
queue
queue.h
rope
rope.h
set
set.h
setjmp.h
signal.h
slist
slist.h
sstream
sstream.h
stack
stack.h
stdarg.h
stddef.h
stddef.h
stdexcep.h
stdexcept
stdio.h
stdio_streambuf
stdlib.h
stdlib.h
stlcomp.h
stlconf.h.in
stl_apcc.h
stl_apple.bak.h
stl_apple.h
stl_as400.h
stl_bc.h
stl_como.h
stl_confix.h
stl_dec.h
stl_dec_vms.h
stl_fujitsu.h
stl_gcc.h
stl_hpacc.h
stl_ibm.h
stl_intel.h
stl_kai.h
stl_mlc.h
stl_msvc.h
stl_mwerks.h
stl_mycomp.h
stl_sco.h
stl_select_lib.h
stl_sgi.h
stl_solaris.h
stl_sunpro.h
stl_symantec.h
stl_tmpl.h
stl_user_config.h
stl_watcom.h
stl_wince.h
streambu.h
streambuf
streambuf.h
string
string.h
strstrea.h
strstream
strstream.h
tempbuf.h
time.h
tree.h
typeinfo
typeinfo.h
type_traits.h
utility
utility.h
valarray
valarray.h
vc_select_lib.h
vector
vector.h
wchar.h
wctype.h
_abbrevs.h
_algo.c
_algo.h
_algobase.c
_algobase.h
_alloc.c
_alloc.h
_alloc_old.h
_auto_ptr.h
_bitset.c
_bitset.h
_bvector.h
_check_config.h
_codecvt.h
_collate.h
_complex.c
_complex.h
_config.h
_config_compat.h
_config_compat_post.h
_construct.h
_ctraits_fns.h
_ctype.h
_cwchar.h
_debug.c
_debug.h
_deque.c
_deque.h
_epilog.h
_epilog.h
_exception.h
_fstream.c
_fstream.h
_function.h
_function_base.h
_hashtable.c
_hashtable.h
_hash_fun.h
_hash_map.h
_hash_set.h
_heap.c
_heap.h
_ios.c
_ios.h
_iosfwd.h
_ios_base.h
_istream.c
_istream.h
_istreambuf_iterator.h
_iterator.h
_iterator.h
_iterator_base.h
_iterator_old.h
_limits.c
_limits.h
_list.c
_list.h
_list.h
_locale.h
_map.h
_messages_facets.h
_mmap.h
_monetary.c
_monetary.h
_msvc_warnings_off.h
_null_stream.h
_numeric.c
_numeric.h
_numpunct.h
_num_get.c
_num_get.h
_num_put.c
_num_put.h
_ostream.c
_ostream.h
_ostreambuf_iterator.h
_pair.h
_prolog.h
_pthread_alloc.h
_ptrs_specialize.h
_queue.h
_range_errors.h
_raw_storage_iter.h
_relops.h
_relops_cont.h
_relops_template.h
_rope.c
_rope.h
_set.h
_set_operators.h
_site_config.h
_slist.c
_slist.h
_slist_base.c
_slist_base.h
_sparc_atomic.h
_sstream.c
_sstream.h
_stack.h
_stdio_file.h
_stdio_file.h.new
_streambuf.c
_streambuf.h
_streambuf_iterator.h
_stream_iterator.h
_string.c
_string.h
_string_fwd.c
_string_fwd.h
_string_hash.h
_string_io.c
_string_io.h
_strstream.h
_tempbuf.c
_tempbuf.h
_threads.c
_threads.h
_time_facets.c
_time_facets.h
_tree.c
_tree.h
_uninitialized.h
_valarray.c
_valarray.h
_vector.c
_vector.h

34
reactos/lib/3rdparty/stlport/etc/std_headers.txt vendored Normal file
View file

@ -0,0 +1,34 @@
algorithm
bitset
complex
deque
fstream
functional
hash_map
hash_set
iomanip
ios
iosfwd
iostream
istream
iterator
limits
list
locale
map
memory
numeric
ostream
pthread_alloc
queue
set
slist
sstream
stack
stdexcept
streambuf
string
strstream
utility
valarray
vector

17
reactos/lib/3rdparty/stlport/etc/std_headers_c.txt vendored Normal file
View file

@ -0,0 +1,17 @@
cassert
cctype
cerrno
cfloat
climits
clocale
cmath
csetjmp
csignal
cstdarg
cstddef
cstdio
cstdlib
cstring
ctime
cwchar
cwctype

13
reactos/lib/3rdparty/stlport/etc/std_headers_c_h.txt vendored Normal file
View file

@ -0,0 +1,13 @@
ctype.h
locale.h
math.h
setjmp.h
signal.h
stdarg.h
stddef.h
stdio.h
stdlib.h
string.h
time.h
wchar.h
wctype.h

8
reactos/lib/3rdparty/stlport/etc/std_headers_classic_iostreams.txt vendored Normal file
View file

@ -0,0 +1,8 @@
fstream.h
iomanip.h
ios.h
iostream.h
istream.h
ostream.h
streambuf.h
strstream.h

3
reactos/lib/3rdparty/stlport/etc/std_headers_cpp_runtime.txt vendored Normal file
View file

@ -0,0 +1,3 @@
exception
new
typeinfo

3
reactos/lib/3rdparty/stlport/etc/std_headers_cpp_runtime_h.txt vendored Normal file
View file

@ -0,0 +1,3 @@
exception.h
new.h
typeinfo.h

6
reactos/lib/3rdparty/stlport/test/compiler/Makefile.inc vendored Normal file
View file

@ -0,0 +1,6 @@
# -*- makefile -*- Time-stamp: <04/10/17 21:16:38 ptr>
PRGNAME = compiler_test
SRC_CPP = ttei1.cpp ttei2.cpp ttei3.cpp ttei4.cpp ttei5.cpp ttei6.cpp ttei7.cpp \
partial_spec.cpp movable.cpp
SRC_CC = eh.cc

29
reactos/lib/3rdparty/stlport/test/compiler/README vendored Normal file
View file

@ -0,0 +1,29 @@
1. About this tests
This is tests to check whether compiler understand or not some language
construction. It is NOT tests for language support libraries, only tests for
compiler!
The main purposes of this tests is to help for developers to find correct
workarounds, if compiler don't understand some (correct) language constructions.
--------------------------------------------------------
2. Compilation
Compilation with GNU Make utility and gcc compiler:
make -f gcc.mak -k
--------------------------------------------------------
Notes about tests.
ttei1.cpp, ttei2.cpp, ttei3.cpp, ttei4.cpp, ttei5.cpp:
tests for template-in-the-template explicit specialization.
Indeed ttei3.cpp, ttei4.cpp, ttei5.cpp suggest syntax not approved by standard
(14.7.3, paragraphs 16--18), but ttei3.cpp, ttei4.cpp accepted (recheck!) by VC6,
while ttei5.cpp accepted by gcc before 3.4.0.

12
reactos/lib/3rdparty/stlport/test/compiler/StTerm-order/Makefile vendored Normal file
View file

@ -0,0 +1,12 @@
# -*- Makefile -*- Time-stamp: <03/07/09 18:08:47 ptr>
SRCROOT := ../../../build
COMPILER_NAME := gcc
# WITHOUT_STLPORT = 1
# STLPORT_DIR := ../../..
include Makefile.inc
include ${SRCROOT}/Makefiles/top.mak
#CXXFLAGS += -fuse-cxa-atexit
LDFLAGS += -Wl,-rpath=${STLPORT_LIB_DIR}

4
reactos/lib/3rdparty/stlport/test/compiler/StTerm-order/Makefile.inc vendored Normal file
View file

@ -0,0 +1,4 @@
# -*- makefile -*- Time-stamp: <02/07/14 14:03:13 ptr>
PRGNAME = stterm-test
SRC_CC = stterm-test.cc

117
reactos/lib/3rdparty/stlport/test/compiler/StTerm-order/stterm-test.cc vendored Normal file
View file

@ -0,0 +1,117 @@
/*
* The conversation with Matti Rintala on STLport forum 2005-08-24:
*
* Do you mean ISO/IEC 14882 3.6.3 [basic.start.term]?
*
* Yes. "Destructors (12.4) for initialized objects of static storage duration
* (declared at block scope or at namespace scope) are called as a result
* of returning from main and as a result of calling exit (18.3). These objects
* are destroyed in the reverse order of the completion of their constructor
* or of the completion of their dynamic initialization."
*
* I found a confirmation on the web that gcc may not strictly conform
* to this behaviour in certains cases unless -fuse-cxa-atexit is used.
*
* Test below give (without -fuse-cxa-atexit)
Init::Init()
Init::use_it
It ctor done <-- 0
Init::use_it done
Init ctor done <-- 1
Init2 ctor done <-- 2
It dtor done <-- 0
Init2 dtor done <-- 2
Init dtor done <-- 1
* but should:
Init::Init()
Init::use_it
It ctor done <-- 0
Init::use_it done
Init ctor done <-- 1
Init2 ctor done <-- 2
Init2 dtor done <-- 2
Init dtor done <-- 1
It dtor done <-- 0
*/
#include <stdio.h>
using namespace std;
class Init
{
public:
Init();
~Init();
static void use_it();
};
class Init2
{
public:
Init2();
~Init2();
};
static Init init;
static Init2 init2;
class It
{
public:
It();
~It();
};
Init::Init()
{
printf( "Init::Init()\n" );
use_it();
printf( "Init ctor done\n" );
}
Init::~Init()
{
printf( "Init dtor done\n" );
}
void Init::use_it()
{
printf( "Init::use_it\n" );
static It it;
printf( "Init::use_it done\n" );
}
Init2::Init2()
{
printf( "Init2 ctor done\n" );
}
Init2::~Init2()
{
printf( "Init2 dtor done\n" );
}
It::It()
{
printf( "It ctor done\n" );
}
It::~It()
{
printf( "It dtor done\n" );
}
int main()
{
return 0;
}

60
reactos/lib/3rdparty/stlport/test/compiler/eh.cc vendored Normal file
View file

@ -0,0 +1,60 @@
#include <list> /* required, to expose allocator */
#include <stdexcept>
#include <stdio.h>
using namespace std;
struct BigStruct
{
char _data[4096];
};
void 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);
// CPPUNIT_ASSERT( pbigStruct != 0 && "Allocation failed but no exception thrown" );
}
catch (bad_alloc const&) {
printf( "Ok\n" );
}
catch (...) {
//We shouldn't be there:
// CPPUNIT_ASSERT( false && "Not bad_alloc exception thrown." );
}
}
void bad_alloc_test1()
{
try {
allocator<BigStruct> all;
BigStruct *bs = all.allocate(1024*1024*1024);
// throw bad_alloc();
}
catch ( bad_alloc const & ) {
printf( "I am here\n" );
}
catch ( ... ) {
}
}
int main()
{
bad_alloc_test();
#if 0
try {
throw bad_alloc();
}
catch ( bad_alloc& ) {
}
catch ( ... ) {
}
#endif
return 0;
}

12
reactos/lib/3rdparty/stlport/test/compiler/gcc.mak vendored Normal file
View file

@ -0,0 +1,12 @@
# -*- Makefile -*- Time-stamp: <04/03/14 23:50:57 ptr>
SRCROOT := ../../build
COMPILER_NAME := gcc
ALL_TAGS := compile-only
STLPORT_DIR := ../..
include Makefile.inc
include ${SRCROOT}/Makefiles/top.mak
compile-only: $(OUTPUT_DIRS) $(OBJ)

20
reactos/lib/3rdparty/stlport/test/compiler/movable.cpp vendored Normal file
View file

@ -0,0 +1,20 @@
#include <list>
#include <vector>
#include <string>
using namespace std;
struct S :
public string
{
};
void test()
{
list<S> l;
l.push_back( S() );
vector<S> v;
v.push_back( S() );
}

34
reactos/lib/3rdparty/stlport/test/compiler/partial_spec.cpp vendored Normal file
View file

@ -0,0 +1,34 @@
/*
* It is known that this code not compiled by following compilers:
*
* MSVC 6
*
* It is known that this code compiled by following compilers:
*
* MSVC 8
* gcc 4.1.1
*/
/*
* This code represent what STLport waits from a compiler which support
* the partial template function ordering (!_STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER)
*/
template <class T1>
struct template_struct {};
template <class T1>
int func(T1 p1);
template <class T1>
int func(template_struct<T1>);
int foo()
{
int tmp1 = 0;
template_struct<int> tmp2;
func(tmp1);
func(tmp2);
return 0;
}

31
reactos/lib/3rdparty/stlport/test/compiler/ttei1.cpp vendored Normal file
View file

@ -0,0 +1,31 @@
/*
* It is known that this code not compiled by following compilers:
* gcc 2.95.3
* MSVC 6
*
* It is known that this code compiled by following compilers:
* gcc 3.3.3
* gcc 3.4.1
* MSVC 8 Beta
*/
struct A
{
private:
struct B
{
template <typename T>
static void f( T& ) {}
template <bool V>
struct C
{
template <typename T>
static void f( T& ) {}
};
};
};
template <> template <typename T>
void A::B::C<true>::f( T& ) {}

31
reactos/lib/3rdparty/stlport/test/compiler/ttei2.cpp vendored Normal file
View file

@ -0,0 +1,31 @@
/*
* It is known that this code not compiled by following compilers:
*
* It is known that this code compiled by following compilers:
* gcc 2.95.3
* gcc 3.3.3
* gcc 3.4.1
* MSVC 6
* MSVC 8
*/
struct A
{
private:
struct B
{
template <typename T>
static void f( T& ) {}
template <bool V>
struct C
{
};
};
};
template <>
struct A::B::C<true>
{
};

43
reactos/lib/3rdparty/stlport/test/compiler/ttei3.cpp vendored Normal file
View file

@ -0,0 +1,43 @@
/*
* It is known that this code not compiled by following compilers:
* gcc 2.95.3
* gcc 3.3.3
* gcc 3.4.1
* gcc 4.1.1
*
* It is known that this code compiled by following compilers:
*
* MSVC 6
* MSVC 8 Beta
*/
/*
* Indeed this code is wrong: explicit template specialization
* have to appear out-of-class.
*
*/
struct A
{
private:
struct B
{
template <typename T>
static void f( T& ) {}
template <bool V>
struct C
{
template <typename T>
static void f( T& ) {}
};
template <>
struct C<true>
{
template <typename T>
static void f( T& ) {}
};
};
};

42
reactos/lib/3rdparty/stlport/test/compiler/ttei4.cpp vendored Normal file
View file

@ -0,0 +1,42 @@
/*
* It is known that this code not compiled by following compilers:
* gcc 2.95.3
* gcc 3.3.3
* gcc 3.4.1
* gcc 4.1.1
*
* It is known that this code compiled by following compilers:
*
* MSVC 6
* MSVC 8 Beta
*/
/*
* Indeed this code is wrong: 1. explicit template specialization
* have to appear out-of-class; 2. specialized struct C have to
* have function f.
*
*/
struct A
{
private:
struct B
{
template <typename T>
static void f( T& ) {}
template <bool V>
struct C
{
template <typename T>
static void f( T& ) {}
};
template <>
struct C<true>
{
};
};
};

43
reactos/lib/3rdparty/stlport/test/compiler/ttei5.cpp vendored Normal file
View file

@ -0,0 +1,43 @@
/*
* It is known that this code not compiled by following compilers:
* gcc 3.4.1
* gcc 4.1.1
*
* It is known that this code compiled by following compilers:
* gcc 2.95.3
* gcc 3.3.3
*
* MSVC 6
* MSVC 8 Beta
*/
/*
* Indeed this code is wrong: explicit template specialization
* have to appear out-of-class.
*
*/
struct A
{
private:
struct B
{
template <typename T>
static void f( T& ) {}
template <bool V>
struct C
{
template <typename T>
static void f( T& ) {}
};
template <>
struct C<true>
{
template <typename T>
static void f( T& ) {}
};
};
};

30
reactos/lib/3rdparty/stlport/test/compiler/ttei6.cpp vendored Normal file
View file

@ -0,0 +1,30 @@
/*
* It is known that this code not compiled by following compilers:
*
* It is known that this code compiled by following compilers:
*
* MSVC 6
* MSVC 8 Beta
*/
/*
* This code represent what STLport waits from a compiler which support
* member template classes (!_STLP_NO_MEMBER_TEMPLATE_CLASSES)
*/
template <typename T1>
struct A
{
template <typename T2>
struct B
{
typedef T2 _Type;
};
};
template <typename T1, typename T2>
struct C
{
typedef typename A<T1>:: template B<T2>::_Type ABType;
};

31
reactos/lib/3rdparty/stlport/test/compiler/ttei7.cpp vendored Normal file
View file

@ -0,0 +1,31 @@
/*
* It is known that this code not compiled by following compilers:
*
* MSVC 6
*
* It is known that this code compiled by following compilers:
*
* MSVC 8 Beta
*/
/*
* This code represent what STLport waits from a compiler which support
* the rebind member template class technique (!_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)
*/
template <typename T1>
struct A
{
template <typename T2>
struct B
{
typedef A<T2> _Type;
};
};
template <typename T, typename A>
struct C
{
typedef typename A:: template B<T>::_Type _ATType;
};

198
reactos/lib/3rdparty/stlport/test/eh/LeakCheck.h vendored Normal file
View file

@ -0,0 +1,198 @@
/*
* Copyright (c) 1997
* 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 makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
/***********************************************************************************
LeakCheck.h
SUMMARY: A suite of template functions for verifying the behavior of
operations in the presence of exceptions. Requires that the operations
be written so that each operation that could cause an exception causes
simulate_possible_failure() to be called (see "nc_alloc.h").
***********************************************************************************/
#ifndef INCLUDED_MOTU_LeakCheck
#define INCLUDED_MOTU_LeakCheck 1
#include "Prefix.h"
#include "nc_alloc.h"
#include <cstdio>
#include <cassert>
#include <iterator>
#include <iostream>
EH_BEGIN_NAMESPACE
template <class T1, class T2>
inline ostream& operator << (
ostream& s,
const pair <T1, T2>& p) {
return s<<'['<<p.first<<":"<<p.second<<']';
}
EH_END_NAMESPACE
/*===================================================================================
CheckInvariant
EFFECTS: Generalized function to check an invariant on a container. Specialize
this for particular containers if such a check is available.
====================================================================================*/
template <class C>
void CheckInvariant(const C&)
{}
/*===================================================================================
WeakCheck
EFFECTS: Given a value and an operation, repeatedly applies the operation to a
copy of the value triggering the nth possible exception, where n increments
with each repetition until no exception is thrown or max_iters is reached.
Reports any detected memory leaks and checks any invariant defined for the
value type whether the operation succeeds or fails.
====================================================================================*/
template <class Value, class Operation>
void WeakCheck(const Value& v, const Operation& op, long max_iters = 2000000) {
bool succeeded = false;
bool failed = false;
gTestController.SetCurrentTestCategory("weak");
for (long count = 0; !succeeded && !failed && count < max_iters; ++count) {
gTestController.BeginLeakDetection();
{
Value dup = v;
#ifndef EH_NO_EXCEPTIONS
try {
#endif
gTestController.SetFailureCountdown(count);
op( dup );
succeeded = true;
#ifndef EH_NO_EXCEPTIONS
}
catch (...) {} // Just try again.
#endif
gTestController.CancelFailureCountdown();
CheckInvariant(dup);
}
failed = gTestController.ReportLeaked();
EH_ASSERT( !failed );
if ( succeeded )
gTestController.ReportSuccess(count);
}
EH_ASSERT( succeeded || failed ); // Make sure the count hasn't gone over
}
/*===================================================================================
ConstCheck
EFFECTS: Similar to WeakCheck (above), but for operations which may not modify
their arguments. The operation is performed on the value itself, and no
invariant checking is performed. Leak checking still occurs.
====================================================================================*/
template <class Value, class Operation>
void ConstCheck(const Value& v, const Operation& op, long max_iters = 2000000) {
bool succeeded = false;
bool failed = false;
gTestController.SetCurrentTestCategory("const");
for (long count = 0; !succeeded && !failed && count < max_iters; ++count) {
gTestController.BeginLeakDetection();
{
#ifndef EH_NO_EXCEPTIONS
try {
#endif
gTestController.SetFailureCountdown(count);
op( v );
succeeded = true;
#ifndef EH_NO_EXCEPTIONS
}
catch(...) {} // Just try again.
# endif
gTestController.CancelFailureCountdown();
}
failed = gTestController.ReportLeaked();
EH_ASSERT( !failed );
if ( succeeded )
gTestController.ReportSuccess(count);
}
EH_ASSERT( succeeded || failed ); // Make sure the count hasn't gone over
}
/*===================================================================================
StrongCheck
EFFECTS: Similar to WeakCheck (above), but additionally checks a component of
the "strong guarantee": if the operation fails due to an exception, the
value being operated on must be unchanged, as checked with operator==().
CAVEATS: Note that this does not check everything required for the strong
guarantee, which says that if an exception is thrown, the operation has no
effects. Do do that we would have to check that no there were no side-effects
on objects which are not part of v (e.g. iterator validity must be preserved).
====================================================================================*/
template <class Value, class Operation>
void StrongCheck(const Value& v, const Operation& op, long max_iters = 2000000) {
bool succeeded = false;
bool failed = false;
gTestController.SetCurrentTestCategory("strong");
for ( long count = 0; !succeeded && !failed && count < max_iters; count++ ) {
gTestController.BeginLeakDetection();
{
Value dup = v;
{
#ifndef EH_NO_EXCEPTIONS
try {
#endif
gTestController.SetFailureCountdown(count);
op( dup );
succeeded = true;
gTestController.CancelFailureCountdown();
# ifndef EH_NO_EXCEPTIONS
}
catch (...) {
gTestController.CancelFailureCountdown();
bool unchanged = (dup == v);
EH_ASSERT( unchanged );
if ( !unchanged ) {
#if 0
typedef typename Value::value_type value_type;
EH_STD::ostream_iterator<value_type> o(EH_STD::cerr, " ");
EH_STD::cerr<<"EH test FAILED:\nStrong guaranee failed !\n";
EH_STD::copy(dup.begin(), dup.end(), o);
EH_STD::cerr<<"\nOriginal is:\n";
EH_STD::copy(v.begin(), v.end(), o);
EH_STD::cerr<<EH_STD::endl;
#endif
failed = true;
}
} // Just try again.
# endif
CheckInvariant(v);
}
}
bool leaked = gTestController.ReportLeaked();
EH_ASSERT( !leaked );
if ( leaked )
failed = true;
if ( succeeded )
gTestController.ReportSuccess(count);
}
EH_ASSERT( succeeded || failed ); // Make sure the count hasn't gone over
}
#endif // INCLUDED_MOTU_LeakCheck

313
reactos/lib/3rdparty/stlport/test/eh/Prefix.h vendored Normal file
View file

@ -0,0 +1,313 @@
/***********************************************************************************
Prefix.h
* Copyright (c) 1997
* 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 makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
SUMMARY: Configuration #defines for STL EH test suite
***********************************************************************************/
#ifndef INCLUDED_MOTU_Prefix
#define INCLUDED_MOTU_Prefix 1
// Gives much more thorough checking, but may slow the tests
// considerably if your malloc is slow.
#define TESTCLASS_DEEP_DATA 1
# ifndef NO_FAST_ALLOCATOR
// # define NO_FAST_ALLOCATOR
# endif
// Define this to use the SGI STL. Undefine it to test a different installation
#ifndef EH_NO_SGI_STL
# define EH_USE_SGI_STL 1
#endif
#if EH_USE_SGI_STL
#define EH_ASSERT _STLP_ASSERT
//=========================================================================
// SGI STL-specific #defines
// These control the behavior of the test suite when used with the SGI
// STL. They have no effect when testing other STL implementations.
//=========================================================================
#ifndef _STLP_USE_NEWALLOC
# define _STLP_USE_NEWALLOC
#endif
#if 0 // !defined (_STLP_NO_CUSTOM_IO) && ! defined (__BORLANDC__)
# define _STLP_NO_CUSTOM_IO
#endif
// Just include something to get whatever configuration header we're using.
#include <utility>
#ifndef _STLP_CALL
# define _STLP_CALL
#endif
#if defined(_STLP_USE_NAMESPACES)
# define EH_USE_NAMESPACES _STLP_USE_NAMESPACES
#endif
#define EH_BEGIN_NAMESPACE _STLP_BEGIN_NAMESPACE
#define EH_END_NAMESPACE _STLP_END_NAMESPACE
#define EH_NEW_HEADERS 1
//#if defined (_STLP_USE_NEW_IOSTREAMS)
#define EH_NEW_IOSTREAMS 1
//#endif
#if !defined (_STLP_USE_EXCEPTIONS)
# define EH_NO_EXCEPTIONS
#endif
#if defined (_STLP_TEMPLATE_PARAM_SUBTYPE_BUG)
# define EH_TEMPLATE_PARAM_SUBTYPE_BUG _STLP_TEMPLATE_PARAM_SUBTYPE_BUG
#endif
#if defined(_STLP_MULTI_CONST_TEMPLATE_ARG_BUG)
# define EH_MULTI_CONST_TEMPLATE_ARG_BUG _STLP_MULTI_CONST_TEMPLATE_ARG_BUG
#endif
#if defined (STLPORT)
# define EH_STD STLPORT
#elif defined(__STD)
# define EH_STD __STD
#endif
// we want to be portable here, so std:: won't work.
#if defined(STLPORT_CSTD)
# define EH_CSTD STLPORT_CSTD
#else
# define EH_CSTD std
#endif
#define EH_DISTANCE(a, b, result) EH_STD::distance(a, b, result)
#define EH_HASHED_CONTAINERS_IMPLEMENTED 1
#define EH_HASH_CONTAINERS_SUPPORT_RESIZE 1
#define EH_HASH_CONTAINERS_SUPPORT_ITERATOR_CONSTRUCTION 1
#define EH_SLIST_IMPLEMENTED 1
#define EH_SELECT1ST_HINT __select1st_hint
// fbp : DEC cxx is unable to compile it for some reason
#if !(defined (__DECCXX) || defined (__amigaos__) || \
(defined (__GNUC__) && (__GNUC__ <= 2) && (__GNUC_MINOR__ < 8)))
# define EH_ROPE_IMPLEMENTED 1
#endif
#define EH_STRING_IMPLEMENTED 1
// # define EH_BITSET_IMPLEMENTED 1
//# define EH_VALARRAY_IMPLEMENTED 1 - we have no tests yet for valarray
#define stl_destroy EH_STD::destroy
#include <memory>
template <class _Tp>
class /*_STLP_CLASS_DECLSPEC*/ EH_allocator;
template <class _Tp>
class /*_STLP_CLASS_DECLSPEC*/ EH_allocator {
public:
typedef _Tp value_type;
typedef value_type * pointer;
typedef const _Tp* const_pointer;
typedef _Tp& reference;
typedef const _Tp& const_reference;
typedef EH_CSTD::size_t size_type;
typedef EH_CSTD::ptrdiff_t difference_type;
# if defined (_STLP_MEMBER_TEMPLATE_CLASSES)
template <class _Tp1> struct rebind {
typedef EH_allocator<_Tp1> other;
};
# endif
EH_allocator() _STLP_NOTHROW {}
# if defined (_STLP_MEMBER_TEMPLATES)
template <class _Tp1> EH_allocator(const EH_allocator<_Tp1>&) _STLP_NOTHROW {}
# endif
EH_allocator(const EH_allocator<_Tp>&) _STLP_NOTHROW {}
~EH_allocator() _STLP_NOTHROW {}
pointer address(reference __x) { 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) const {
return __n != 0 ? __REINTERPRET_CAST(value_type*,EH_STD::__new_alloc::allocate(__n * sizeof(value_type))) : 0;
}
// __p is permitted to be a null pointer, only if n==0.
void deallocate(pointer __p, size_type __n) const {
_STLP_ASSERT( (__p == 0) == (__n == 0) )
if (__p != 0) EH_STD::__new_alloc::deallocate((void*)__p, __n * sizeof(value_type));
}
// backwards compatibility
void deallocate(pointer __p) const { if (__p != 0) EH_STD::__new_alloc::deallocate((void*)__p, sizeof(value_type)); }
size_type max_size() const _STLP_NOTHROW { return size_t(-1) / sizeof(value_type); }
void construct(pointer __p, const _Tp& __val) const { stlport::construct(__p, __val); }
void destroy(pointer __p) const { stlport::destroy(__p); }
};
template <class _T1> inline bool _STLP_CALL operator==(const EH_allocator<_T1>&, const EH_allocator<_T1>&) { return true; }
template <class _T1> inline bool _STLP_CALL operator!=(const EH_allocator<_T1>&, const EH_allocator<_T1>&) { return false; }
_STLP_BEGIN_NAMESPACE
// 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 EH_allocator<_Tp2>& _STLP_CALL
__stl_alloc_rebind(EH_allocator<_Tp1>& __a, const _Tp2*) { return (EH_allocator<_Tp2>&)(__a); }
template <class _Tp1, class _Tp2>
inline EH_allocator<_Tp2> _STLP_CALL
__stl_alloc_create(const EH_allocator<_Tp1>&, const _Tp2*) { return EH_allocator<_Tp2>(); }
_STLP_END_NAMESPACE
# define eh_allocator(T) ::EH_allocator<T>
# define EH_BIT_VECTOR_IMPLEMENTED
# if defined(_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined(_STLP_NO_BOOL)
# define EH_BIT_VECTOR EH_STD::vector<bool, eh_allocator(bool) >
# else
# ifdef _STLP_NO_BOOL
# undef EH_BIT_VECTOR_IMPLEMENTED
# else
# define EH_BIT_VECTOR EH_STD::vector<bool, eh_allocator(bool) >
# endif
# endif
#else // !USE_SGI_STL
//=========================================================================
// Configuration for testing other non-SGI STL implementations
//=========================================================================
// Metrowerks configuration
# ifdef __MWERKS__
# define EH_ASSERT assert
// Get MSL configuration header
# include <ansi_parms.h>
# if __MSL__ >= 24
# define EH_NEW_HEADERS 1
# if defined (_MSL_USING_NAMESPACE)
# define EH_USE_NAMESPACES 1
# endif
# define EH_BIT_VECTOR vector<bool>
# define EH_DISTANCE( a, b, result ) do { result = distance( a, b ); } while (0)
# else
# error No configuration for earlier versions of MSL
# endif // __MSL__ >= 24
// Bugs fixed in CWPro3
# if __MWERKS__ < 0x2100
# define EH_TEMPLATE_PARAM_SUBTYPE_BUG 1
# endif
// Bugs in CWPro3
# if __MWERKS__ <= 0x2110
# define EH_MULTI_CONST_TEMPLATE_ARG_BUG 1
# else
# pragma warning not sure the above bug is fixed yet
# endif
# define EH_SLIST_IMPLEMENTED 1
//# define EH_HASHED_CONTAINERS_IMPLEMENTED 1
# define EH_NEW_IOSTREAMS 1
# define EH_USE_NOTHROW 1
# endif // Metrowerks configuration
#if defined (__SUNPRO_CC)
# define stl_destroy __RWSTD::__destroy
# define EH_DISTANCE( a, b, result ) distance( a, b, result )
# define EH_BIT_VECTOR EH_STD::vector<bool>
# define EH_NEW_HEADERS 1
# define EH_USE_NAMESPACES 1
# define EH_NEW_IOSTREAMS 1
# define EH_ASSERT assert
# define EH_STRING_IMPLEMENTED 1
# elif defined (__KCC)
# define stl_destroy EH_STD::destroy
# define EH_DISTANCE( a, b, result ) do { result = distance( a, b ); } while (0)
# define EH_BIT_VECTOR EH_STD::vector<bool>
# define EH_NEW_HEADERS 1
# define EH_USE_NAMESPACES 1
# define EH_NEW_IOSTREAMS 1
# define EH_ASSERT assert
# define EH_CSTD
# define EH_STRING_IMPLEMENTED 1
# define EH_MULTI_CONST_TEMPLATE_ARG_BUG 1
# define EH_SELECT1ST_HINT select1st
# else
# define stl_destroy destroy
#endif
//
// Compiler-independent configuration
//
# ifdef EH_USE_NAMESPACES
# ifdef STLPORT
# define EH_STD STLPORT
# else
# define EH_STD std
# endif
# ifdef STLPORT_CSTD
# define EH_STD STLPORT_CSTD
# else
# define EH_STD std
# endif
# define EH_BEGIN_NAMESPACE namespace EH_STD {
# define EH_END_NAMESPACE }
# else
# define EH_BEGIN_NAMESPACE
# define EH_END_NAMESPACE
# define EH_STD
# endif
# ifndef EH_CSTD
# define EH_CSTD EH_STD
# endif
#endif // !USE_SGI_STL
//
// Library-independent configuration.
//
#if defined( EH_MULTI_CONST_TEMPLATE_ARG_BUG) && !defined( EH_SELECT1ST_HINT )
template <class Pair, class U>
// JDJ (CW Pro1 doesn't like const when first_type is also const)
struct eh_select1st_hint : public unary_function<Pair, U> {
const U& operator () (const Pair& x) const { return x.first; }
};
# define EH_SELECT1ST_HINT eh_select1st_hint
#endif
#if EH_USE_NAMESPACES
# define EH_USE_STD using namespace EH_STD;
#else
# define EH_USE_STD
#endif
#if defined (EH_USE_NAMESPACES) && !defined(_STLP_VENDOR_GLOBAL_CSTD)
# define USING_CSTD_NAME(name) using EH_CSTD :: name;
#else
# define USING_CSTD_NAME(name)
#endif
#endif // INCLUDED_MOTU_Prefix

81
reactos/lib/3rdparty/stlport/test/eh/SortClass.h vendored Normal file
View file

@ -0,0 +1,81 @@
/***********************************************************************************
SortClass.h
* Copyright (c) 1997
* 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 makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
SUMMARY: A class designed to test operations that compares objects. All
comparisons on SortClass may fail. Also records its own address for
the sake of testing the stability of sorting algorithms.
***********************************************************************************/
#if ! defined (INCLUDED_MOTU_SortClass)
#define INCLUDED_MOTU_SortClass 1
# include "Prefix.h"
# include "TestClass.h"
class SortClass : public TestClass
{
public:
enum { kRange = 100 };
SortClass( int v ) : TestClass( v ), addr(0) {
ResetAddress();
}
SortClass() : TestClass( (int)get_random(kRange) ), addr(0) {
ResetAddress();
}
bool operator<( const TestClass& rhs ) const
{
simulate_possible_failure();
return (const TestClass&)*this < ( rhs );
}
bool operator==( const TestClass& rhs ) const
{
simulate_possible_failure();
return (const TestClass&)*this == ( rhs );
}
SortClass* GetAddress() const { return addr; }
void ResetAddress() { addr = this; }
private:
SortClass* addr;
};
inline bool operator>( const SortClass& lhs, const SortClass& rhs ) {
return rhs < lhs;
}
inline bool operator<=( const SortClass& lhs, const SortClass& rhs ) {
return !(rhs < lhs);
}
inline bool operator>=( const SortClass& lhs, const SortClass& rhs ) {
return !(lhs < rhs);
}
inline bool operator != ( const SortClass& lhs, const SortClass& rhs ) {
return !(lhs == rhs);
}
#if defined( __MWERKS__ ) && __MWERKS__ <= 0x3000 && !__SGI_STL
# if defined( __MSL__ ) && __MSL__ < 0x2406
__MSL_FIX_ITERATORS__(SortClass);
__MSL_FIX_ITERATORS__(const SortClass);
# endif
#endif
#endif // INCLUDED_MOTU_SortClass

24
reactos/lib/3rdparty/stlport/test/eh/TestClass.cpp vendored Normal file
View file

@ -0,0 +1,24 @@
/***********************************************************************************
TestClass.cpp
* Copyright (c) 1997
* 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 makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
***********************************************************************************/
#include "TestClass.h"
#include <iostream>
std::ostream& operator << (std::ostream& s, const TestClass& t) {
return s << t.value();
}

161
reactos/lib/3rdparty/stlport/test/eh/TestClass.h vendored Normal file
View file

@ -0,0 +1,161 @@
/***********************************************************************************
TestClass.h
* Copyright (c) 1997-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 makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
SUMMARY: TestClass simulates a class that uses resources. It is designed to
cause exceptions when it is constructed or copied.
***********************************************************************************/
#ifndef INCLUDED_MOTU_TestClass
#define INCLUDED_MOTU_TestClass 1
# include "Prefix.h"
# include <functional>
# include <utility>
# include <climits>
#include <iosfwd>
#include "random_number.h"
#include "nc_alloc.h"
class TestClass
{
public:
inline TestClass();
inline TestClass( int value );
inline TestClass( const TestClass& rhs );
inline ~TestClass();
inline TestClass& operator=( const TestClass& rhs );
inline int value() const;
inline TestClass operator!() const;
bool operator==( const TestClass& rhs ) const
{
return value() == rhs.value();
}
bool operator<( const TestClass& rhs ) const {
return value() < rhs.value();
}
protected:
static inline unsigned int get_random(unsigned range = UINT_MAX);
private:
inline void Init( int value );
#if TESTCLASS_DEEP_DATA
int *p;
#else
int v;
#endif
};
#if defined( __MWERKS__ ) && __MWERKS__ <= 0x3000 && !__SGI_STL
# if defined( __MSL__ ) && __MSL__ < 0x2406
# include <iterator.h>
__MSL_FIX_ITERATORS__(TestClass);
__MSL_FIX_ITERATORS__(const TestClass);
typedef EH_STD::pair<const TestClass, TestClass> pair_testclass_testclass;
__MSL_FIX_ITERATORS__( pair_testclass_testclass );
__MSL_FIX_ITERATORS__( const pair_testclass_testclass );
# endif
#endif
inline void TestClass::Init( int value )
{
#if TESTCLASS_DEEP_DATA
p = new int( value );
#else
simulate_constructor();
v = value;
#endif
}
inline TestClass::TestClass()
{
Init( int(get_random()) );
}
inline TestClass::TestClass( int value )
{
Init( value );
}
inline TestClass::TestClass( const TestClass& rhs )
{
Init( rhs.value() );
}
inline TestClass::~TestClass()
{
#if TESTCLASS_DEEP_DATA
delete p;
#else
simulate_destructor();
#endif
}
inline TestClass& TestClass::operator=( const TestClass& rhs )
{
#if TESTCLASS_DEEP_DATA
int *newP = new int( rhs.value() );
delete p;
p = newP;
#else
simulate_possible_failure();
v = rhs.value();
#endif
return *this;
}
inline int TestClass::value() const
{
#if TESTCLASS_DEEP_DATA
return *p;
#else
return v;
#endif
}
inline TestClass TestClass::operator!() const
{
return TestClass( value()+1 );
}
inline bool operator>( const TestClass& lhs, const TestClass& rhs ) {
return rhs < lhs;
}
inline bool operator>=( const TestClass& lhs, const TestClass& rhs ) {
return !(lhs < rhs);
}
inline bool operator<=( const TestClass& lhs, const TestClass& rhs ) {
return !(rhs < lhs);
}
inline bool operator != ( const TestClass& lhs, const TestClass& rhs ) {
return lhs.value() != rhs.value();
}
inline unsigned int TestClass::get_random( unsigned range )
{
return random_number( range );
}
extern std::ostream& operator << ( std::ostream& s, const TestClass&);
#endif // INCLUDED_MOTU_TestClass

59
reactos/lib/3rdparty/stlport/test/eh/Tests.h vendored Normal file
View file

@ -0,0 +1,59 @@
/***********************************************************************************
Tests.h
* Copyright (c) 1997
* 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 makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
SUMMARY: Declarations of all of the tests in the exception test suite.
***********************************************************************************/
#if ! defined (INCLUDED_MOTU_Tests)
#define INCLUDED_MOTU_Tests 1
#include "Prefix.h"
void test_algobase();
void test_algo();
void test_list();
void test_map();
void test_multimap();
void test_set();
void test_multiset();
void test_vector();
void test_deque();
void test_bit_vector();
#if defined (EH_HASHED_CONTAINERS_IMPLEMENTED)
void test_hash_map();
void test_hash_multimap();
void test_hash_set();
void test_hash_multiset();
#endif
#if defined (EH_ROPE_IMPLEMENTED)
void test_rope();
#endif
#if defined( EH_SLIST_IMPLEMENTED )
void test_slist();
#endif
#if defined( EH_STRING_IMPLEMENTED )
void test_string();
#endif
#if defined( EH_BITSET_IMPLEMENTED )
void test_bitset();
#endif
#if defined( EH_VALARRAY_IMPLEMENTED )
void test_valarray();
#endif
#endif // INCLUDED_MOTU_Tests

46
reactos/lib/3rdparty/stlport/test/eh/ThrowCompare.h vendored Normal file
View file

@ -0,0 +1,46 @@
/***********************************************************************************
ThrowCompare.h
Interface for the ThrowCompare class
* Copyright (c) 1997
* 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 makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
***********************************************************************************/
#ifndef ThrowCompare_H_
#define ThrowCompare_H_
#include "Prefix.h"
#include "TestClass.h"
struct ThrowCompare {
bool operator()( const TestClass& a, const TestClass& b ) const {
simulate_possible_failure();
return a < b;
}
};
struct ThrowEqual {
inline bool operator()( const TestClass& a, const TestClass& b ) const {
simulate_possible_failure();
return a == b;
}
};
struct ThrowHash { // : private ThrowCompare
inline EH_CSTD::size_t operator()( const TestClass& a ) const {
simulate_possible_failure();
return EH_CSTD::size_t(a.value());
}
};
#endif // ThrowCompare_H_

78
reactos/lib/3rdparty/stlport/test/eh/bcb.mak vendored Normal file
View file

@ -0,0 +1,78 @@
# ---------------------------------------------------------------------------
BCC32=bcc32
CPP32=cpp32
!if !$d(BCB)
BCB = $(MAKEDIR)\..
!endif
# ---------------------------------------------------------------------------
# IDE SECTION
# ---------------------------------------------------------------------------
# The following section of the project makefile is managed by the BCB IDE.
# It is recommended to use the IDE to change any of the values in this
# section.
# ---------------------------------------------------------------------------
# ---------------------------------------------------------------------------
PROJECT = eh_test.exe
OBJFILES = TestClass.obj \
nc_alloc.obj \
random_number.obj \
test_algo.obj \
test_algobase.obj \
test_bit_vector.obj \
test_bitset.obj \
test_deque.obj \
test_hash_map.obj \
test_hash_set.obj \
test_list.obj \
test_map.obj \
test_rope.obj \
test_set.obj \
test_slist.obj \
test_string.obj \
test_valarray.obj \
test_vector.obj main.obj
# ---------------------------------------------------------------------------
PATHCPP = .;
PATHPAS = .;
PATHASM = .;
PATHRC = .;
# USERDEFINES = _STLP_NO_OWN_IOSTREAMS
USERDEFINES = _DEBUG
SYSDEFINES = _RTLDLL;NO_STRICT;USEPACKAGES
# SYSDEFINES = NO_STRICT;USEPACKAGES
# ---------------------------------------------------------------------------
CFLAG1 = -w- -jb -j1 -I.;..\..\stlport;$(BCB)\include; -Od -v -N -x -xp -tWC -D$(SYSDEFINES);$(USERDEFINES)
LDFLAGS = -L..\..\lib;$(BCB)\..\lib cw32i.lib stlp.4.5.lib
.autodepend
# ---------------------------------------------------------------------------
all : $(PROJECT)
cd ..\..\lib
..\test\eh\eh_test.exe -s 100
$(PROJECT) : $(OBJFILES)
$(BCC32) -e$(PROJECT) $(CFLAG1) $(LDFLAGS) $(OBJFILES)
clean:
del *.obj *.exe *.core *.tds
# ---------------------------------------------------------------------------
.cpp.obj:
$(BCC32) $(CFLAG1) -n$(@D) -c $<
.cpp.exe:
$(BCC32) $(CFLAG1) $(LDFLAGS) -n$(@D) $<
.cpp.i:
$(CPP32) $(CFLAG1) -n. -Sr -Ss -Sd {$< }
# ---------------------------------------------------------------------------

39
reactos/lib/3rdparty/stlport/test/eh/bug.cpp vendored Normal file
View file

@ -0,0 +1,39 @@
#include <set>
#include <vector>
#include <iostream>
#include <boost/timer.hpp>
#include <boost/lexical_cast.hpp>
struct compare
{
bool operator()(int* x, int* y)
{ return *x < *y; }
};
int main(int argc, char const* const argv[])
{
std::size_t niters = argc < 2 ? 1000 : boost::lexical_cast<std::size_t>(argv[1]);
boost::timer t;
std::vector<int> v;
for (int n = 0; n < niters; ++n)
{
v.insert(v.begin() + v.size()/2, n);
}
std::cout << "vector fill: " << t.elapsed() << std::endl;
std::multiset<int*,compare> m;
for (int n = 0; n < niters; ++n)
{
m.insert(&v[n]);
}
std::cout << "map fill 1: " << t.elapsed() << std::endl;
for (int n = 0; n < niters; ++n)
{
m.insert(&v[n]);
}
std::cout << "map fill 2: " << t.elapsed() << std::endl;
}

69
reactos/lib/3rdparty/stlport/test/eh/como-linux.mak vendored Normal file
View file

@ -0,0 +1,69 @@
#
# Note : this makefile has been tested for como-4.3.0.1+gcc-2.96 on Redhat 7.3
#
.SUFFIXES:
.SUFFIXES: .cc .cpp .o .exe .out
srcdir = .
VPATH = .
# point this to proper location
STL_INCL=../../stlport
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = ./eh_test
TEST = ./eh_test.out
CC = como
CXX = $(CC)
CXXFLAGS = -DLIBCIO= --diag_suppress=68 -D__null=0L -D__GNUG__ -D_STLP_DEBUG -I${STL_INCL} -I. ${CXX_EXTRA_FLAGS}
LIBS = -L../../lib -lstlport_como_stldebug -lpthread -lm
LIBSTDCXX =
check: $(TEST)
$(TEST_EXE) : $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBS) -o $(TEST_EXE)
$(TEST) : $(TEST_EXE)
$(TEST_EXE)
SUFFIXES: .cpp.o.exe.out.res
%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H -o $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBS) -o $*
./$* > $@
-rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
%.E: %.cpp
$(CXX) $(CXXFLAGS) -E $< -o $@
clean:
-rm -fr ${TEST_EXE} *.out *.o *.ii *.ti

67
reactos/lib/3rdparty/stlport/test/eh/como.mak vendored Normal file
View file

@ -0,0 +1,67 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
srcdir = .
VPATH = .
# point this to proper location
STL_INCL=../../stlport
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = ./eh_test
TEST = ./eh_test.out
CC = e:\lang\como\bin\como
CXX = $(CC)
# __COMO__ appears not to be defined automatically ;(
CXXFLAGS = -D__COMO__ -D_MSC_VER=1200 --exceptions --microsoft -D_STLP_DEBUG -I${STL_INCL} -I. ${CXX_EXTRA_FLAGS}
LIBS = -lm
LIBSTDCXX =
check: $(TEST)
$(TEST_EXE) : $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBS) -o $(TEST_EXE)
$(TEST) : $(TEST_EXE)
$(TEST_EXE)
SUFFIXES: .cpp.o.exe.out.res
%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H -o $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBS) -o $*
./$* > $@
-rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
%.E: %.cpp
$(CXX) $(CXXFLAGS) -E $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o *.rpo *.obj *.out core *~ Templates.DB

56
reactos/lib/3rdparty/stlport/test/eh/cray.mak vendored Normal file
View file

@ -0,0 +1,56 @@
SHELL=/bin/sh
# srcdir = .
# VPATH = .
STL_INCL=-I${PWD}/../../stlport/
AUX_LIST=TestClass.o main.o nc_alloc.o random_number.o
TEST_LIST=test_algo.o \
test_algobase.o test_list.o test_slist.o \
test_bit_vector.o test_vector.o \
test_deque_cray.o test_set.o test_map.o \
test_hash_map.o test_hash_set.o test_rope.o \
test_string.o test_bitset.o test_valarray.o
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST)
EXECS = $(LIST:%.o=%)
TESTS = $(LIST:%.o=%.out)
TEST_EXE = eh_test
TEST = eh_test.out
CC = CC
CXX = $(CC)
#CXXFLAGS = -hexceptions -DEH_DELETE_HAS_THROW_SPEC -I. ${STL_INCL} ${DEBUG_FLAGS}
CXXFLAGS = -D_STLP_HAS_NO_EXCEPTIONS -I. ${STL_INCL} ${DEBUG_FLAGS}
#LIBS = -L../../lib -lstlportx -lpthread
LIBS = -L../../lib -lstlport -lpthread
.SUFFIXES: .cpp .i .o .out
check: $(TEST)
$(TEST) : $(OBJECTS)
$(CXX) $(CXXFLAGS) $(LIBS) $(OBJECTS) -o $(TEST_EXE)
./$(TEST_EXE) -s 100
.cpp.o:
$(CXX) $(CXXFLAGS) $< -c -o $@
.cpp.i:
$(CXX) $(CXXFLAGS) $< -E > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $*.cpp -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $(LIBS) $*.o -o $*
./$* -q
-rm -f $*
clean:
-rm -fr ${TEST_EXE} *.o *.ii *.out core

123
reactos/lib/3rdparty/stlport/test/eh/cygwin.mak vendored Normal file
View file

@ -0,0 +1,123 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
srcdir = .
VPATH = .
# point this to proper location
STL_INCL=-I../../stlport
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=obj/%.o) $(STAT_MODULE)
D_OBJECTS = $(LIST:%.cpp=d_obj/%.o) $(STAT_MODULE)
NOSGI_OBJECTS = $(LIST:%.cpp=nosgi_obj/%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = ./eh_test
D_TEST_EXE = ./eh_test_d
NOSGI_TEST_EXE = ./eh_test_nosgi
TEST = ./eh_test.out
D_TEST = ./eh_test_d.out
NOSGI_TEST = ./eh_test_nosgi.out
CC = c++
CXX = $(CC)
# dwa 12/22/99 -- had to turn off -ansi flag so we could use SGI IOSTREAMS
# also, test_slist won't compile with -O3/-O2 when targeting PPC. It fails
# in the assembler with 'invalid relocation type'
CXXFLAGS = -Wall -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW
D_CXXFLAGS = -Wall -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW -D_STLP_DEBUG -D_STLP_USE_STATIC_LIB
NOSGI_CXXFLAGS = -Wall -g -O2 ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -D_STLP_NO_OWN_IOSTREAMS -D_STLP_DEBUG_UNINITIALIZED -DEH_VECTOR_OPERATOR_NEW
check: $(TEST)
LIBS = -lm
D_LIBSTLPORT = -L../../lib -lstlport_cygwin_stldebug
LIBSTLPORT = -L../../lib -lstlport_cygwin
all: $(TEST_EXE) $(D_TEST_EXE) $(NOSGI_TEST_EXE)
check_nosgi: $(NOSGI_TEST)
check_d: $(D_TEST)
OBJDIR=obj
D_OBJDIR=d_obj
NOSGI_OBJDIR=nosgi_obj
$(OBJDIR):
mkdir obj
$(D_OBJDIR):
mkdir d_obj
$(NOSGI_OBJDIR):
mkdir nosgi_obj
$(TEST_EXE) : $(OBJDIR) $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBSTLPORT) $(LIBS) -o $(TEST_EXE)
$(D_TEST_EXE) : $(D_OBJDIR) $(D_OBJECTS)
$(CXX) $(D_CXXFLAGS) $(D_OBJECTS) $(D_LIBSTLPORT) $(LIBS) -o $(D_TEST_EXE)
$(NOSGI_TEST_EXE) : $(NOSGI_OBJDIR) $(NOSGI_OBJECTS)
$(CXX) $(NOSGI_CXXFLAGS) $(NOSGI_OBJECTS) $(LIBS) -o $(NOSGI_TEST_EXE)
$(TEST) : $(TEST_EXE)
echo "Cygwin has bugs in exception handling, runnning w/o throwing exceptions..."
./$(TEST_EXE) -e
$(D_TEST) : $(D_TEST_EXE)
echo "Cygwin has bugs in exception handling, runnning w/o throwing exceptions..."
./$(D_TEST_EXE) -e
$(NOSGI_TEST) : $(NOSGI_TEST_EXE)
echo "Cygwin has bugs in exception handling, runnning w/o throwing exceptions..."
./$(NOSGI_TEST_EXE) -e
SUFFIXES: .cpp.o.exe.out.res
nosgi_obj/%.o : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -c -o $@
d_obj/%.o : %.cpp
$(CXX) $(D_CXXFLAGS) $< -c -o $@
obj/%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
nosgi_obj/%.i : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -E -H > $@
d_obj/%.i : %.cpp
$(CXX) $(D_CXXFLAGS) $< -E -H > $@
obj/%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -D_STLP_DEBUG -D_REENTRANT -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(D_LIBSTLPORT) $(LIBS) -o $*
./$* > $@
-rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
%.E: %.cpp
$(CXX) $(CXXFLAGS) -E $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o */*.o *.rpo *.obj *.out core *~ Templates.DB

73
reactos/lib/3rdparty/stlport/test/eh/deccxx.mak vendored Normal file
View file

@ -0,0 +1,73 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
SHELL=/bin/sh
# srcdir = .
# VPATH = .
# point this to proper location
STL_INCL= -I../../stlport
# STL_INCL= -DEH_NO_SGI_STL
AUX_LIST=TestClass.o main.o nc_alloc.o random_number.o
TEST_LIST=test_algo.o \
test_algobase.o test_list.o test_slist.o \
test_bit_vector.o test_vector.o \
test_deque.o test_set.o test_map.o \
test_hash_map.o test_hash_set.o test_rope.o \
test_string.o test_bitset.o test_valarray.o
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST)
EXECS = $(LIST:%.o=%)
TESTS = $(LIST:%.o=%.out)
TEST_EXE = eh_test
TEST = eh_test.out
CC = cxx
CXX = $(CC)
# -std strict_ansi_errors
CXXFLAGS = ${STL_INCL} -std strict_ansi_errors -DEH_VECTOR_OPERATOR_NEW -DEH_DELETE_HAS_THROW_SPEC -gall
# CXXFLAGS = ${STL_INCL} -std strict_ansi_errors -DEH_VECTOR_OPERATOR_NEW -DEH_DELETE_HAS_THROW_SPEC
# This is to test with native STL
# CXXFLAGS = +w2 -xildoff -D_STLP_USE_NEWALLOC -DEH_NO_SGI_STL -DEH_NEW_HEADERS -DEH_VECTOR_OPERATOR_NEW -DEH_DELETE_HAS_THROW_SPEC
LIBS = -L../../lib -lstlport_dec -lm
LIBSTDCXX =
.SUFFIXES: .cpp .i .o .out .res
check: $(TEST)
$(TEST) : $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBS) -o $(TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" ./$(TEST_EXE) -s 100
.cpp.o:
$(CXX) $(CXXFLAGS) $< -c -o $@
.cpp.i:
$(CXX) $(CXXFLAGS) $< -E > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $*.cpp -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBS) -o $*
./$* -q
-rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $*.cpp -o $@
clean:
-rm -fr ${TEST_EXE} *.o *.rpo *.obj *.out core *~ Templates.DB SunWS_cache cxx_repository

54
reactos/lib/3rdparty/stlport/test/eh/descrip.mms vendored Normal file
View file

@ -0,0 +1,54 @@
# ;;; -*- Mode:makefile;-*-
# Generated manually for MMS
# point this to proper location
STL_INCL= /include="../../stlport"
# STL_INCL= -DEH_NO_SGI_STL
.SUFFIXES .obj .cpp
all : check
AUX_LIST=TestClass.obj,main.obj,nc_alloc.obj,random_number.obj
TEST_LIST=test_algo.obj,-
test_algobase.obj,test_list.obj,test_slist.obj,-
test_bit_vector.obj,test_vector.obj,-
test_deque.obj,test_set.obj,test_map.obj,-
test_hash_map.obj,test_hash_set.obj,test_rope.obj,-
test_string.obj,test_bitset.obj,test_valarray.obj
LIST=$(AUX_LIST),$(TEST_LIST)
OBJECTS = $(LIST)
EXECS = $(LIST:%.obj=%.exe)
TESTS = $(LIST:%.obj=%.out)
TEST_EXE = eh_test.exe
TEST = eh_test.out
CC = cxx
CXX = $(CC)
LINK = cxxlink
# -std strict_ansi_errors
CXXFLAGS = $(STL_INCL) /define=(__NO_USE_STD_IOSTREAM,EH_VECTOR_OPERATOR_NEW,EH_DELETE_HAS_THROW_SPEC)
# This is to test with native STL
# CXXFLAGS = +w2 -xildoff -D__STL_USE_NEWALLOC -DEH_NO_SGI_STL -DEH_NEW_HEADERS -DEH_VECTOR_OPERATOR_NEW -DEH_DELETE_HAS_THROW_SPEC
LIBS =
LIBSTDCXX =
check : $(TEST)
$(TEST) : $(OBJECTS)
$(LINK)/exe=$(TEST_EXE) $(OBJECTS) $(LIBS)
run $(TEST_EXE)
.cpp.obj :
$(CXX) $(CXXFLAGS) /obj=$@ $<

121
reactos/lib/3rdparty/stlport/test/eh/djgpp.mak vendored Normal file
View file

@ -0,0 +1,121 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
srcdir = .
VPATH = .
# point this to proper location
STL_INCL=-I../../stlport
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=obj/%.o) $(STAT_MODULE)
D_OBJECTS = $(LIST:%.cpp=d_obj/%.o) $(STAT_MODULE)
NOSGI_OBJECTS = $(LIST:%.cpp=nosgi_obj/%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = ./eh_test
D_TEST_EXE = ./eh_test_d
NOSGI_TEST_EXE = ./eh_test_nosgi
TEST = ./eh_test.out
D_TEST = ./eh_test_d.out
NOSGI_TEST = ./eh_test_nosgi.out
CC = gcc
CXX = $(CC)
# dwa 12/22/99 -- had to turn off -ansi flag so we could use SGI IOSTREAMS
# also, test_slist won't compile with -O3/-O2 when targeting PPC. It fails
# in the assembler with 'invalid relocation type'
CXXFLAGS = -Wall -ftemplate-depth-32 -mbnu210 -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW -D_STLP_NO_SGI_IOSTREAMS
D_CXXFLAGS = -Wall -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW -D_STLP_DEBUG -D_STLP_USE_STATIC_LIB
NOSGI_CXXFLAGS = -Wall -g -O2 ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -D_STLP_NO_SGI_IOSTREAMS -D_STLP_DEBUG_UNINITIALIZED -DEH_VECTOR_OPERATOR_NEW
check: $(TEST)
LIBS = -lstdcxx -lm
D_LIBSTLPORT = ../../lib/libstlport_djgpp_debug_static.a
LIBSTLPORT = ../../lib/libstlport_djgpp_stldebug_static.a
all: $(TEST_EXE) $(D_TEST_EXE) $(NOSGI_TEST_EXE)
check_nosgi: $(NOSGI_TEST)
check_d: $(D_TEST)
OBJDIR=obj
D_OBJDIR=d_obj
NOSGI_OBJDIR=nosgi_obj
$(OBJDIR):
mkdir obj
$(D_OBJDIR):
mkdir d_obj
$(NOSGI_OBJDIR):
mkdir nosgi_obj
$(TEST_EXE) : $(OBJDIR) $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBSTLPORT) $(LIBS) -o $(TEST_EXE)
$(D_TEST_EXE) : $(D_OBJDIR) $(D_OBJECTS)
$(CXX) $(D_CXXFLAGS) $(D_OBJECTS) $(D_LIBSTLPORT) $(LIBS) -o $(D_TEST_EXE)
$(NOSGI_TEST_EXE) : $(NOSGI_OBJDIR) $(NOSGI_OBJECTS)
$(CXX) $(NOSGI_CXXFLAGS) $(NOSGI_OBJECTS) $(LIBS) -o $(NOSGI_TEST_EXE)
$(TEST) : $(TEST_EXE)
$(TEST_EXE)
$(D_TEST) : $(D_TEST_EXE)
$(D_TEST_EXE)
$(NOSGI_TEST) : $(NOSGI_TEST_EXE)
$(NOSGI_TEST_EXE)
SUFFIXES: .cpp.o.exe.out.res
nosgi_obj/%.o : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -c -o $@
d_obj/%.o : %.cpp
$(CXX) $(D_CXXFLAGS) $< -c -o $@
obj/%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
nosgi_obj/%.i : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -E -H > $@
d_obj/%.i : %.cpp
$(CXX) $(D_CXXFLAGS) $< -E -H > $@
obj/%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBS) -o $*
./$* > $@
-rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
%.E: %.cpp
$(CXX) $(CXXFLAGS) -E $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o */*.o *.rpo *.obj *.out core *~ Templates.DB

75
reactos/lib/3rdparty/stlport/test/eh/egcs.mak vendored Normal file
View file

@ -0,0 +1,75 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
srcdir = .
VPATH = .
# point this to proper location
STL_INCL=../../stlport
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = ./eh_test
TEST = ./eh_test.out
CC = egcs-c++
CXX = $(CC)
# for egcs
REPO_FLAGS =
# CXXFLAGS = -g -Wall -I${STL_INCL} -I. -D_STLP_USE_NEWALLOC -D_STLP_DEBUG_ALLOC ${REPO_FLAGS} -DEH_NEW_HEADERS
# CXXFLAGS = -Wall -ansi -I${STL_INCL} -I. -D_STLP_DEBUG ${REPO_FLAGS} ${CXX_EXTRA_FLAGS}
CXXFLAGS = -Wall -g -D_STLP_USE_NEWALLOC -DNO_FAST_ALLOCATOR -ansi -I${STL_INCL} -I. ${REPO_FLAGS} ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW -D_STLP_DEBUG -D_STLP_NO_DEBUG_EXCEPTIONS
# CXXFLAGS = -Wall -I${STL_INCL} -I. -D_STLP_USE_NEWALLOC ${REPO_FLAGS} ${CXX_EXTRA_FLAGS}
LIBS = -lm
LIBSTDCXX =
check: $(TEST)
$(TEST_EXE) : $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBS) -o $(TEST_EXE)
$(TEST) : $(TEST_EXE)
$(TEST_EXE)
SUFFIXES: .cpp.o.exe.out.res
%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H -o $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBS) -o $*
./$* > $@
-rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
%.E: %.cpp
$(CXX) $(CXXFLAGS) -E $< -o $@
clean:
-rm -fr ${TEST_EXE} $(OBJDIR) $(D_OBJDIR) $(NOSGI_OBJDIR) *.o *.rpo *.obj *.out core *~ Templates.DB

37
reactos/lib/3rdparty/stlport/test/eh/export vendored Normal file
View file

@ -0,0 +1,37 @@
LeakCheck.h
Prefix.h
SortClass.h
TestClass.cpp
TestClass.h
Tests.h
ThrowCompare.h
export
gcc.mak
main.cpp
nc_alloc.cpp
nc_alloc.h
random_number.cpp
random_number.h
sunpro.mak
test_algo.cpp
test_algobase.cpp
test_assign_op.h
test_bit_vector.cpp
test_bitset.cpp
test_construct.h
test_deque.cpp
test_hash_map.cpp
test_hash_resize.h
test_hash_set.cpp
test_insert.h
test_list.cpp
test_map.cpp
test_push_back.h
test_push_front.h
test_rope.cpp
test_set.cpp
test_slist.cpp
test_string.cpp
test_valarray.cpp
test_vector.cpp
vc.mak

109
reactos/lib/3rdparty/stlport/test/eh/gcc-99r1.mak vendored Normal file
View file

@ -0,0 +1,109 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
srcdir = .
VPATH = .
# point this to proper location
STL_INCL=-I../../stlport
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=obj/%.o) $(STAT_MODULE)
D_OBJECTS = $(LIST:%.cpp=d_obj/%.o) $(STAT_MODULE)
NOSGI_OBJECTS = $(LIST:%.cpp=nosgi_obj/%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = ./eh_test
D_TEST_EXE = ./eh_test_d
NOSGI_TEST_EXE = ./eh_test_nosgi
TEST = ./eh_test.out
D_TEST = ./eh_test_d.out
NOSGI_TEST = ./eh_test_nosgi.out
CC =c++
CXX = $(CC)
# dwa 12/22/99 -- had to turn off -ansi flag so we could use SGI IOSTREAMS
# also, test_slist won't compile with -O3/-O2 when targeting PPC. It fails
# in the assembler with 'invalid relocation type'
CXXFLAGS = -Wall -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW -g -D_STLP_HAS_NO_NAMESPACES
D_CXXFLAGS = -Wall -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW -D_STLP_DEBUG
NOSGI_CXXFLAGS = -Wall -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -D_STLP_NO_OWN_IOSTREAMS -DEH_VECTOR_OPERATOR_NEW
check: $(TEST)
LIBS = -lm
D_LIBSTLPORT = -L../../lib -lstlport_gcc_stldebug
LIBSTLPORT = -L../../lib -lstlport_gcc
all: $(TEST_EXE) $(D_TEST_EXE) $(NOSGI_TEST_EXE)
check_nosgi: $(NOSGI_TEST)
check_d: $(D_TEST)
$(TEST_EXE) : $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBSTLPORT) $(LIBS) -o $(TEST_EXE)
$(D_TEST_EXE) : $(D_OBJECTS)
$(CXX) $(D_CXXFLAGS) $(D_OBJECTS) $(D_LIBSTLPORT) $(LIBS) -o $(D_TEST_EXE)
$(NOSGI_TEST_EXE) : $(NOSGI_OBJECTS)
$(CXX) $(NOSGI_CXXFLAGS) $(NOSGI_OBJECTS) $(LIBS) -o $(NOSGI_TEST_EXE)
$(TEST) : $(TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" time ./$(TEST_EXE) -s 100
$(D_TEST) : $(D_TEST_EXE)
$(D_TEST_EXE)
$(NOSGI_TEST) : $(NOSGI_TEST_EXE)
$(NOSGI_TEST_EXE)
SUFFIXES: .cpp.o.exe.out.res
nosgi_obj/%.o : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -c -o $@
d_obj/%.o : %.cpp
$(CXX) $(D_CXXFLAGS) $< -c -o $@
obj/%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
nosgi_obj/%.i : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -E -H > $@
d_obj/%.i : %.cpp
$(CXX) $(D_CXXFLAGS) $< -E -H > $@
obj/%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -O2 -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBSTLPORT) $(LIBS) -o $*
./$* > $@
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
%.E: %.cpp
$(CXX) $(CXXFLAGS) -E $< -o $@
clean:
-rm -fr ${TEST_EXE} $(D_TEST_EXE) *.o */*.o *.rpo *.obj *.out core *~ Templates.DB

119
reactos/lib/3rdparty/stlport/test/eh/gcc-amigaos-m68k.mak vendored Normal file
View file

@ -0,0 +1,119 @@
#
# This requires GNU make.
#
srcdir = .
VPATH = .
SHELL = /bin/sh
# point this to proper location
STL_INCL = -I../../stlport
AUX_LIST = TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST = test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST = ${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=obj/%.o) $(STAT_MODULE)
D_OBJECTS = $(LIST:%.cpp=d_obj/%.o) $(STAT_MODULE)
NOSGI_OBJECTS = $(LIST:%.cpp=nosgi_obj/%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = ./eh_test
D_TEST_EXE = ./eh_test_d
NOSGI_TEST_EXE = ./eh_test_nosgi
TEST = ./eh_test.out
D_TEST = ./eh_test_d.out
NOSGI_TEST = ./eh_test_nosgi.out
CC = gcc
CXX = g++
CXXFLAGS = -s -noixemul -m68020 -Wall -O2 ${STL_INCL} -I. -DEH_VECTOR_OPERATOR_NEW
D_CXXFLAGS = -Wall -g -O ${STL_INCL} -I. -DEH_VECTOR_OPERATOR_NEW -D_STLP_DEBUG -D_STLP_USE_STATIC_LIB
NOSGI_CXXFLAGS = -Wall -g -O2 ${STL_INCL} -I. -D_STLP_NO_OWN_IOSTREAMS -D_STLP_DEBUG_UNINITIALIZED -DEH_VECTOR_OPERATOR_NEW
check: $(TEST)
LIBS = -lm
D_LIBSTLPORT = -L../../lib -lstlport_gcc_stldebug
LIBSTLPORT = -L../../lib -lstlport_gcc
all: $(TEST_EXE)
check_nosgi: $(NOSGI_TEST)
check_d: $(D_TEST)
OBJDIR=obj
D_OBJDIR=d_obj
NOSGI_OBJDIR=nosgi_obj
$(OBJDIR):
mkdir obj
$(D_OBJDIR):
mkdir d_obj
$(NOSGI_OBJDIR):
mkdir nosgi_obj
$(TEST_EXE) : $(OBJDIR) $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBSTLPORT) $(LIBS) -o $(TEST_EXE)
$(D_TEST_EXE) : $(D_OBJDIR) $(D_OBJECTS)
$(CXX) $(D_CXXFLAGS) $(D_OBJECTS) $(D_LIBSTLPORT) $(LIBS) -o $(D_TEST_EXE)
$(NOSGI_TEST_EXE) : $(NOSGI_OBJDIR) $(NOSGI_OBJECTS)
$(CXX) $(NOSGI_CXXFLAGS) $(NOSGI_OBJECTS) $(LIBS) -o $(NOSGI_TEST_EXE)
$(TEST) : $(TEST_EXE)
$(TEST_EXE) -s 100
$(D_TEST) : $(D_TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" ./$(D_TEST_EXE) -s 100
$(NOSGI_TEST) : $(NOSGI_TEST_EXE)
$(NOSGI_TEST_EXE)
SUFFIXES: .cpp.o.exe.out.res
nosgi_obj/%.o : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -c -o $@
d_obj/%.o : %.cpp
$(CXX) $(D_CXXFLAGS) $< -c -o $@
obj/%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
nosgi_obj/%.i : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -E -H > $@
d_obj/%.i : %.cpp
$(CXX) $(D_CXXFLAGS) $< -E -H > $@
obj/%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBS) -o $*
./$* > $@
-rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
%.E: %.cpp
$(CXX) $(CXXFLAGS) -E $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o */*.o *.rpo *.obj *.out core *~ Templates.DB

122
reactos/lib/3rdparty/stlport/test/eh/gcc-apple-macosx.mak vendored Normal file
View file

@ -0,0 +1,122 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
srcdir = .
VPATH = .
SHELL=/bin/sh
# point this to proper location
STL_INCL=-I../../stlport
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=obj/%.o) $(STAT_MODULE)
D_OBJECTS = $(LIST:%.cpp=d_obj/%.o) $(STAT_MODULE)
NOSGI_OBJECTS = $(LIST:%.cpp=nosgi_obj/%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = ./eh_test
D_TEST_EXE = ./eh_test_d
NOSGI_TEST_EXE = ./eh_test_nosgi
TEST = ./eh_test.out
D_TEST = ./eh_test_d.out
NOSGI_TEST = ./eh_test_nosgi.out
CC = g++
CXX = $(CC)
# dwa 12/22/99 -- had to turn off -ansi flag so we could use SGI IOSTREAMS
# also, test_slist won't compile with -O3/-O2 when targeting PPC. It fails
# in the assembler with 'invalid relocation type'
CXXFLAGS = -Wall -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW
D_CXXFLAGS = -Wall -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW -D_STLP_DEBUG -D_STLP_USE_STATIC_LIB
NOSGI_CXXFLAGS = -Wall -g -O2 ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -D_STLP_NO_OWN_IOSTREAMS -D_STLP_DEBUG_UNINITIALIZED -DEH_VECTOR_OPERATOR_NEW
check: $(TEST)
LIBS = -lm
D_LIBSTLPORT = -L../../lib -lstlport_gcc_debug
LIBSTLPORT = -L../../lib -lstlport_gcc
all: $(TEST_EXE) $(D_TEST_EXE) $(NOSGI_TEST_EXE)
check_nosgi: $(NOSGI_TEST)
check_d: $(D_TEST)
OBJDIR=obj
D_OBJDIR=d_obj
NOSGI_OBJDIR=nosgi_obj
$(OBJDIR):
mkdir obj
$(D_OBJDIR):
mkdir d_obj
$(NOSGI_OBJDIR):
mkdir nosgi_obj
$(TEST_EXE) : $(OBJDIR) $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBSTLPORT) $(LIBS) -o $(TEST_EXE)
$(D_TEST_EXE) : $(D_OBJDIR) $(D_OBJECTS)
$(CXX) $(D_CXXFLAGS) $(D_OBJECTS) $(D_LIBSTLPORT) $(LIBS) -o $(D_TEST_EXE)
$(NOSGI_TEST_EXE) : $(NOSGI_OBJDIR) $(NOSGI_OBJECTS)
$(CXX) $(NOSGI_CXXFLAGS) $(NOSGI_OBJECTS) $(LIBS) -o $(NOSGI_TEST_EXE)
$(TEST) : $(TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" time ./$(TEST_EXE) -s 100
$(D_TEST) : $(D_TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" ./$(D_TEST_EXE) -s 100
$(NOSGI_TEST) : $(NOSGI_TEST_EXE)
$(NOSGI_TEST_EXE)
SUFFIXES: .cpp.o.exe.out.res
nosgi_obj/%.o : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -c -o $@
d_obj/%.o : %.cpp
$(CXX) $(D_CXXFLAGS) $< -c -o $@
obj/%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
nosgi_obj/%.i : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -E -H > $@
d_obj/%.i : %.cpp
$(CXX) $(D_CXXFLAGS) $< -E -H > $@
obj/%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBSTLPORT) $(LIBS) -o $*
./$* > $@
# -rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
%.E: %.cpp
$(CXX) $(CXXFLAGS) -E $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o */*.o *.rpo *.obj *.out core *~ Templates.DB

123
reactos/lib/3rdparty/stlport/test/eh/gcc-freebsd.mak vendored Normal file
View file

@ -0,0 +1,123 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
srcdir = .
VPATH = .
SHELL=/bin/sh
# point this to proper location
STL_INCL=-I../../stlport
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=obj/%.o) $(STAT_MODULE)
D_OBJECTS = $(LIST:%.cpp=d_obj/%.o) $(STAT_MODULE)
NOSGI_OBJECTS = $(LIST:%.cpp=nosgi_obj/%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = ./eh_test
D_TEST_EXE = ./eh_test_d
NOSGI_TEST_EXE = ./eh_test_nosgi
TEST = ./eh_test.out
D_TEST = ./eh_test_d.out
NOSGI_TEST = ./eh_test_nosgi.out
CC = c++ -pthread
CXX = $(CC)
# dwa 12/22/99 -- had to turn off -ansi flag so we could use SGI IOSTREAMS
# also, test_slist won't compile with -O3/-O2 when targeting PPC. It fails
# in the assembler with 'invalid relocation type'
CXXFLAGS = -Wall -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW
D_CXXFLAGS = -Wall -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW -D_STLP_DEBUG -D_STLP_USE_STATIC_LIB
NOSGI_CXXFLAGS = -Wall -g -O2 ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -D_STLP_NO_OWN_IOSTREAMS -D_STLP_DEBUG_UNINITIALIZED -DEH_VECTOR_OPERATOR_NEW
check: $(TEST)
LIBS = -lm
D_LIBSTLPORT = -L../../lib -lstlport_gcc_stldebug
LIBSTLPORT = -L../../lib -lstlport_gcc
all: $(TEST_EXE) $(D_TEST_EXE) $(NOSGI_TEST_EXE)
check_nosgi: $(NOSGI_TEST)
check_d: $(D_TEST)
OBJDIR=obj
D_OBJDIR=d_obj
NOSGI_OBJDIR=nosgi_obj
$(OBJDIR):
mkdir obj
$(D_OBJDIR):
mkdir d_obj
$(NOSGI_OBJDIR):
mkdir nosgi_obj
$(TEST_EXE) : $(OBJDIR) $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBSTLPORT) $(LIBS) -o $(TEST_EXE)
$(D_TEST_EXE) : $(D_OBJDIR) $(D_OBJECTS)
$(CXX) $(D_CXXFLAGS) $(D_OBJECTS) $(D_LIBSTLPORT) $(LIBS) -o $(D_TEST_EXE)
$(NOSGI_TEST_EXE) : $(NOSGI_OBJDIR) $(NOSGI_OBJECTS)
$(CXX) $(NOSGI_CXXFLAGS) $(NOSGI_OBJECTS) $(LIBS) -o $(NOSGI_TEST_EXE)
$(TEST) : $(TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" ./$(TEST_EXE) -s 100
$(D_TEST) : $(D_TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" ./$(D_TEST_EXE) -s 100
$(NOSGI_TEST) : $(NOSGI_TEST_EXE)
$(NOSGI_TEST_EXE)
SUFFIXES: .cpp.o.exe.out.res
nosgi_obj/%.o : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -c -o $@
d_obj/%.o : %.cpp
$(CXX) $(D_CXXFLAGS) $< -c -o $@
obj/%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
nosgi_obj/%.i : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -E -H > $@
d_obj/%.i : %.cpp
$(CXX) $(D_CXXFLAGS) $< -E -H > $@
obj/%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBS) -o $*
./$* > $@
-rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
%.E: %.cpp
$(CXX) $(CXXFLAGS) -E $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o */*.o *.rpo *.obj *.out core *~ Templates.DB

123
reactos/lib/3rdparty/stlport/test/eh/gcc-hp11.mak vendored Normal file
View file

@ -0,0 +1,123 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
srcdir = .
VPATH = .
SHELL=/bin/sh
# point this to proper location
STL_INCL=-I../../stlport
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=obj/%.o) $(STAT_MODULE)
D_OBJECTS = $(LIST:%.cpp=d_obj/%.o) $(STAT_MODULE)
NOSGI_OBJECTS = $(LIST:%.cpp=nosgi_obj/%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = ./eh_test
D_TEST_EXE = ./eh_test_d
NOSGI_TEST_EXE = ./eh_test_nosgi
TEST = ./eh_test.out
D_TEST = ./eh_test_d.out
NOSGI_TEST = ./eh_test_nosgi.out
# CC = g++ -pthreads
CC = g++ -D_REENTRANT -D_POSIX_C_SOURCE=199506L -D__EXTENSIONS__
CXX = $(CC)
# dwa 12/22/99 -- had to turn off -ansi flag so we could use SGI IOSTREAMS
# also, test_slist won't compile with -O3/-O2 when targeting PPC. It fails
# in the assembler with 'invalid relocation type'
CXXFLAGS = -Wall -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW
D_CXXFLAGS = -Wall -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW -D_STLP_DEBUG -D_STLP_USE_STATIC_LIB
NOSGI_CXXFLAGS = -Wall -g -O2 ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -D_STLP_NO_OWN_IOSTREAMS -D_STLP_DEBUG_UNINITIALIZED -DEH_VECTOR_OPERATOR_NEW
check: $(TEST)
LIBS = -lpthread -lm
D_LIBSTLPORT = -L../../lib -lstlport_gcc_debug
LIBSTLPORT = -L../../lib -lstlport_gcc
all: $(TEST_EXE) $(D_TEST_EXE) $(NOSGI_TEST_EXE)
check_nosgi: $(NOSGI_TEST)
check_d: $(D_TEST)
OBJDIR=obj
D_OBJDIR=d_obj
NOSGI_OBJDIR=nosgi_obj
$(OBJDIR):
mkdir obj
$(D_OBJDIR):
mkdir d_obj
$(NOSGI_OBJDIR):
mkdir nosgi_obj
$(TEST_EXE) : $(OBJDIR) $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBSTLPORT) $(LIBS) -o $(TEST_EXE)
$(D_TEST_EXE) : $(D_OBJDIR) $(D_OBJECTS)
$(CXX) $(D_CXXFLAGS) $(D_OBJECTS) $(D_LIBSTLPORT) $(LIBS) -o $(D_TEST_EXE)
$(NOSGI_TEST_EXE) : $(NOSGI_OBJDIR) $(NOSGI_OBJECTS)
$(CXX) $(NOSGI_CXXFLAGS) $(NOSGI_OBJECTS) $(LIBS) -o $(NOSGI_TEST_EXE)
$(TEST) : $(TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" time ./$(TEST_EXE) -s 100
$(D_TEST) : $(D_TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" ./$(D_TEST_EXE) -s 100
$(NOSGI_TEST) : $(NOSGI_TEST_EXE)
$(NOSGI_TEST_EXE)
SUFFIXES: .cpp.o.exe.out.res
nosgi_obj/%.o : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -c -o $@
d_obj/%.o : %.cpp
$(CXX) $(D_CXXFLAGS) $< -c -o $@
obj/%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
nosgi_obj/%.i : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -E -H > $@
d_obj/%.i : %.cpp
$(CXX) $(D_CXXFLAGS) $< -E -H > $@
obj/%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -D_STLP_DEBUG -D_STLP_NO_OWN_IOSTREAMS -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBSTLPORT) $(LIBS) -o $*
./$* > $@
# -rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
%.E: %.cpp
$(CXX) $(CXXFLAGS) -E $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o */*.o *.rpo *.obj *.out core *~ Templates.DB

122
reactos/lib/3rdparty/stlport/test/eh/gcc-irix.mak vendored Normal file
View file

@ -0,0 +1,122 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
srcdir = .
VPATH = .
SHELL=/bin/sh
# point this to proper location
STL_INCL=-I../../stlport
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=obj/%.o) $(STAT_MODULE)
D_OBJECTS = $(LIST:%.cpp=d_obj/%.o) $(STAT_MODULE)
NOSGI_OBJECTS = $(LIST:%.cpp=nosgi_obj/%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = ./eh_test
D_TEST_EXE = ./eh_test_d
NOSGI_TEST_EXE = ./eh_test_nosgi
TEST = ./eh_test.out
D_TEST = ./eh_test_d.out
NOSGI_TEST = ./eh_test_nosgi.out
CC = g++
CXX = $(CC)
# dwa 12/22/99 -- had to turn off -ansi flag so we could use SGI IOSTREAMS
# also, test_slist won't compile with -O3/-O2 when targeting PPC. It fails
# in the assembler with 'invalid relocation type'
CXXFLAGS = -Wall -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW
D_CXXFLAGS = -Wall -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW -D_STLP_DEBUG -D_STLP_USE_STATIC_LIB
NOSGI_CXXFLAGS = -Wall -g -O2 ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -D_STLP_NO_OWN_IOSTREAMS -D_STLP_DEBUG_UNINITIALIZED -DEH_VECTOR_OPERATOR_NEW
check: $(TEST)
LIBS = -lm
D_LIBSTLPORT = -L../../lib -lstlport_gcc_debug
LIBSTLPORT = -L../../lib -lstlport_gcc
all: $(TEST_EXE) $(D_TEST_EXE) $(NOSGI_TEST_EXE)
check_nosgi: $(NOSGI_TEST)
check_d: $(D_TEST)
OBJDIR=obj
D_OBJDIR=d_obj
NOSGI_OBJDIR=nosgi_obj
$(OBJDIR):
mkdir obj
$(D_OBJDIR):
mkdir obj
$(NOSGI_OBJDIR):
mkdir obj
$(TEST_EXE) : $(OBJDIR) $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBSTLPORT) $(LIBS) -o $(TEST_EXE)
$(D_TEST_EXE) : $(D_OBJDIR) $(D_OBJECTS)
$(CXX) $(D_CXXFLAGS) $(D_OBJECTS) $(D_LIBSTLPORT) $(LIBS) -o $(D_TEST_EXE)
$(NOSGI_TEST_EXE) : $(NOSGI_OBJDIR) $(NOSGI_OBJECTS)
$(CXX) $(NOSGI_CXXFLAGS) $(NOSGI_OBJECTS) $(LIBS) -o $(NOSGI_TEST_EXE)
$(TEST) : $(TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" time ./$(TEST_EXE) -s 100
$(D_TEST) : $(D_TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" ./$(D_TEST_EXE) -s 100
$(NOSGI_TEST) : $(NOSGI_TEST_EXE)
$(NOSGI_TEST_EXE)
SUFFIXES: .cpp.o.exe.out.res
nosgi_obj/%.o : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -c -o $@
d_obj/%.o : %.cpp
$(CXX) $(D_CXXFLAGS) $< -c -o $@
obj/%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
nosgi_obj/%.i : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -E -H > $@
d_obj/%.i : %.cpp
$(CXX) $(D_CXXFLAGS) $< -E -H > $@
obj/%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -D_STLP_DEBUG -D_STLP_NO_OWN_IOSTREAMS -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBSTLPORT) $(LIBS) -o $*
./$* > $@
# -rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
%.E: %.cpp
$(CXX) $(CXXFLAGS) -E $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o */*.o *.rpo *.obj *.out core *~ Templates.DB

120
reactos/lib/3rdparty/stlport/test/eh/gcc-linux.mak vendored Normal file
View file

@ -0,0 +1,120 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
SHELL=/bin/sh
srcdir = .
VPATH = .
# point this to proper location
STL_INCL=-I../../stlport
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=obj/%.o) $(STAT_MODULE)
D_OBJECTS = $(LIST:%.cpp=d_obj/%.o) $(STAT_MODULE)
NOSGI_OBJECTS = $(LIST:%.cpp=nosgi_obj/%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = ./eh_test
D_TEST_EXE = ./eh_test_d
NOSGI_TEST_EXE = ./eh_test_nosgi
TEST = ./eh_test.out
D_TEST = ./eh_test_d.out
NOSGI_TEST = ./eh_test_nosgi.out
CC = c++ -pthread
CXX = $(CC)
# dwa 12/22/99 -- had to turn off -ansi flag so we could use SGI IOSTREAMS
# also, test_slist won't compile with -O3/-O2 when targeting PPC. It fails
# in the assembler with 'invalid relocation type'
CXXFLAGS = -Wall ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW
D_CXXFLAGS = -Wall -g ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW -D_STLP_DEBUG -D_STLP_USE_STATIC_LIB
NOSGI_CXXFLAGS = -Wall -g -O2 ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -D_STLP_NO_OWN_IOSTREAMS -D_STLP_DEBUG_UNINITIALIZED -DEH_VECTOR_OPERATOR_NEW
check: $(TEST)
LIBS = -lm
D_LIBSTLPORT = -L../../lib -lstlport_gcc_stldebug
LIBSTLPORT = -L../../lib -lstlport_gcc
all: $(TEST_EXE) $(D_TEST_EXE) $(NOSGI_TEST_EXE)
check_nosgi: $(NOSGI_TEST)
check_d: $(D_TEST)
OBJDIR=obj
D_OBJDIR=d_obj
NOSGI_OBJDIR=nosgi_obj
$(OBJDIR):
mkdir obj
$(D_OBJDIR):
mkdir d_obj
$(NOSGI_OBJDIR):
mkdir nosgi_obj
$(TEST_EXE) : $(OBJDIR) $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBSTLPORT) $(LIBS) -o $(TEST_EXE)
$(D_TEST_EXE) : $(D_OBJDIR) $(D_OBJECTS)
$(CXX) $(D_CXXFLAGS) $(D_OBJECTS) $(D_LIBSTLPORT) $(LIBS) -o $(D_TEST_EXE)
$(NOSGI_TEST_EXE) : $(NOSGI_OBJDIR) $(NOSGI_OBJECTS)
$(CXX) $(NOSGI_CXXFLAGS) $(NOSGI_OBJECTS) $(LIBS) -o $(NOSGI_TEST_EXE)
$(TEST) : $(TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" ./$(TEST_EXE) -s 100
$(D_TEST) : $(D_TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" ./$(D_TEST_EXE) -s 100
$(NOSGI_TEST) : $(NOSGI_TEST_EXE)
$(NOSGI_TEST_EXE)
SUFFIXES: .cpp.o.exe.out.res
nosgi_obj/%.o : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -c -o $@
d_obj/%.o : %.cpp
$(CXX) $(D_CXXFLAGS) $< -c -o $@
obj/%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
nosgi_obj/%.i : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -E -H > $@
d_obj/%.i : %.cpp
$(CXX) $(D_CXXFLAGS) $< -E -H > $@
obj/%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(D_CXXFLAGS) $< -c -USINGLE -DMAIN -o $*.o
$(CXX) $(D_CXXFLAGS) $*.o $(LIBS) $(D_LIBSTLPORT) -o $*
./$* > $@
# -rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
%.E: %.cpp
$(CXX) $(CXXFLAGS) -E $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o */*.o *.rpo *.obj *.out core *~ Templates.DB

122
reactos/lib/3rdparty/stlport/test/eh/gcc-netbsd.mak vendored Normal file
View file

@ -0,0 +1,122 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
srcdir = .
VPATH = .
SHELL=/bin/sh
# point this to proper location
STL_INCL=-I../../stlport
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=obj/%.o) $(STAT_MODULE)
D_OBJECTS = $(LIST:%.cpp=d_obj/%.o) $(STAT_MODULE)
NOSGI_OBJECTS = $(LIST:%.cpp=nosgi_obj/%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = ./eh_test
D_TEST_EXE = ./eh_test_d
NOSGI_TEST_EXE = ./eh_test_nosgi
TEST = ./eh_test.out
D_TEST = ./eh_test_d.out
NOSGI_TEST = ./eh_test_nosgi.out
CC = c++
CXX = $(CC)
# dwa 12/22/99 -- had to turn off -ansi flag so we could use SGI IOSTREAMS
# also, test_slist won't compile with -O3/-O2 when targeting PPC. It fails
# in the assembler with 'invalid relocation type'
CXXFLAGS = -Wall -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW
D_CXXFLAGS = -Wall -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW -D_STLP_DEBUG -D_STLP_USE_STATIC_LIB
NOSGI_CXXFLAGS = -Wall -g -O2 ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -D_STLP_NO_OWN_IOSTREAMS -D_STLP_DEBUG_UNINITIALIZED -DEH_VECTOR_OPERATOR_NEW
check: $(TEST)
LIBS = -lm -lpthread
D_LIBSTLPORT = -L../../lib -R../../lib -lstlport_gcc_stldebug
LIBSTLPORT = -L../../lib -R../../lib -lstlport_gcc
all: $(TEST_EXE) $(D_TEST_EXE) $(NOSGI_TEST_EXE)
check_nosgi: $(NOSGI_TEST)
check_d: $(D_TEST)
OBJDIR=obj
D_OBJDIR=d_obj
NOSGI_OBJDIR=nosgi_obj
$(OBJDIR):
mkdir obj
$(D_OBJDIR):
mkdir d_obj
$(NOSGI_OBJDIR):
mkdir nosgi_obj
$(TEST_EXE) : $(OBJDIR) $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBSTLPORT) $(LIBS) -o $(TEST_EXE)
$(D_TEST_EXE) : $(D_OBJDIR) $(D_OBJECTS)
$(CXX) $(D_CXXFLAGS) $(D_OBJECTS) $(D_LIBSTLPORT) $(LIBS) -o $(D_TEST_EXE)
$(NOSGI_TEST_EXE) : $(NOSGI_OBJDIR) $(NOSGI_OBJECTS)
$(CXX) $(NOSGI_CXXFLAGS) $(NOSGI_OBJECTS) $(LIBS) -o $(NOSGI_TEST_EXE)
$(TEST) : $(TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" ./$(TEST_EXE) -s 100
$(D_TEST) : $(D_TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" ./$(D_TEST_EXE) -s 100
$(NOSGI_TEST) : $(NOSGI_TEST_EXE)
$(NOSGI_TEST_EXE)
SUFFIXES: .cpp.o.exe.out.res
nosgi_obj/%.o : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -c -o $@
d_obj/%.o : %.cpp
$(CXX) $(D_CXXFLAGS) $< -c -o $@
obj/%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
nosgi_obj/%.i : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -E -H > $@
d_obj/%.i : %.cpp
$(CXX) $(D_CXXFLAGS) $< -E -H > $@
obj/%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBS) -o $*
./$* > $@
-rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
%.E: %.cpp
$(CXX) $(CXXFLAGS) -E $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o */*.o *.rpo *.obj *.out core *~ Templates.DB

122
reactos/lib/3rdparty/stlport/test/eh/gcc.mak vendored Normal file
View file

@ -0,0 +1,122 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
srcdir = .
VPATH = .
SHELL=/bin/sh
# point this to proper location
STL_INCL=-I../../stlport
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=obj/%.o) $(STAT_MODULE)
D_OBJECTS = $(LIST:%.cpp=d_obj/%.o) $(STAT_MODULE)
NOSGI_OBJECTS = $(LIST:%.cpp=nosgi_obj/%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = ./eh_test
D_TEST_EXE = ./eh_test_d
NOSGI_TEST_EXE = ./eh_test_nosgi
TEST = ./eh_test.out
D_TEST = ./eh_test_d.out
NOSGI_TEST = ./eh_test_nosgi.out
CC = g++ -pthread
CXX = $(CC)
# dwa 12/22/99 -- had to turn off -ansi flag so we could use SGI IOSTREAMS
# also, test_slist won't compile with -O3/-O2 when targeting PPC. It fails
# in the assembler with 'invalid relocation type'
CXXFLAGS = -Wall -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW
D_CXXFLAGS = -Wall -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW -D_STLP_DEBUG -D_STLP_USE_STATIC_LIB
NOSGI_CXXFLAGS = -Wall -g -O2 ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -D_STLP_NO_OWN_IOSTREAMS -D_STLP_DEBUG_UNINITIALIZED -DEH_VECTOR_OPERATOR_NEW
check: $(TEST)
LIBS = -lm
D_LIBSTLPORT = -L../../lib -lstlport_gcc_debug
LIBSTLPORT = -L../../lib -lstlport_gcc
all: $(TEST_EXE) $(D_TEST_EXE) $(NOSGI_TEST_EXE)
check_nosgi: $(NOSGI_TEST)
check_d: $(D_TEST)
OBJDIR=obj
D_OBJDIR=d_obj
NOSGI_OBJDIR=nosgi_obj
$(OBJDIR):
mkdir obj
$(D_OBJDIR):
mkdir d_obj
$(NOSGI_OBJDIR):
mkdir nosgi_obj
$(TEST_EXE) : $(OBJDIR) $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBSTLPORT) $(LIBS) -o $(TEST_EXE)
$(D_TEST_EXE) : $(D_OBJDIR) $(D_OBJECTS)
$(CXX) $(D_CXXFLAGS) $(D_OBJECTS) $(D_LIBSTLPORT) $(LIBS) -o $(D_TEST_EXE)
$(NOSGI_TEST_EXE) : $(NOSGI_OBJDIR) $(NOSGI_OBJECTS)
$(CXX) $(NOSGI_CXXFLAGS) $(NOSGI_OBJECTS) $(LIBS) -o $(NOSGI_TEST_EXE)
$(TEST) : $(TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" time ./$(TEST_EXE) -s 100
$(D_TEST) : $(D_TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" ./$(D_TEST_EXE) -s 100
$(NOSGI_TEST) : $(NOSGI_TEST_EXE)
$(NOSGI_TEST_EXE)
SUFFIXES: .cpp.o.exe.out.res
nosgi_obj/%.o : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -c -o $@
d_obj/%.o : %.cpp
$(CXX) $(D_CXXFLAGS) $< -c -o $@
obj/%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
nosgi_obj/%.i : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -E -H > $@
d_obj/%.i : %.cpp
$(CXX) $(D_CXXFLAGS) $< -E -H > $@
obj/%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBSTLPORT) $(LIBS) -o $*
./$* > $@
# -rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
%.E: %.cpp
$(CXX) $(CXXFLAGS) -E $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o */*.o *.rpo *.obj *.out core *~ Templates.DB

93
reactos/lib/3rdparty/stlport/test/eh/gcc7.mak vendored Normal file
View file

@ -0,0 +1,93 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
srcdir = .
VPATH = .
# point this to proper location
STL_INCL=-I../../stlport
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=obj/%.o) $(STAT_MODULE)
D_OBJECTS = $(LIST:%.cpp=d_obj/%.o) $(STAT_MODULE)
NOSGI_OBJECTS = $(LIST:%.cpp=nosgi_obj/%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = ./eh_test
D_TEST_EXE = ./eh_test_d
NOSGI_TEST_EXE = ./eh_test_nosgi
TEST = ./eh_test.out
D_TEST = ./eh_test_d.out
NOSGI_TEST = ./eh_test_nosgi.out
CC = c++
CXX = $(CC)
CXXFLAGS = -Wall -fhandle-exceptions -g ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -D_STLP_NO_OWN_IOSTREAMS -D_STLP_DEBUG_UNINITIALIZED
check: $(TEST)
LIBS = -lm
D_LIBSTLPORT = -L../../lib -lstlport_gcc_debug
LIBSTLPORT = -L../../lib -lstlport_gcc
all: $(TEST_EXE) $(D_TEST_EXE) $(NOSGI_TEST_EXE)
check_nosgi: $(NOSGI_TEST)
check_d: $(D_TEST)
$(TEST_EXE) : $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBS) -o $(TEST_EXE)
$(TEST) : $(TEST_EXE)
$(TEST_EXE)
$(D_TEST) : $(D_TEST_EXE)
$(D_TEST_EXE)
$(NOSGI_TEST) : $(NOSGI_TEST_EXE)
$(NOSGI_TEST_EXE)
SUFFIXES: .cpp.o.exe.out.res
nosgi_obj/%.o : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -c -o $@
d_obj/%.o : %.cpp
$(CXX) $(D_CXXFLAGS) $< -c -o $@
obj/%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
obj/%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBS) -o $*
./$* > $@
-rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
%.E: %.cpp
$(CXX) $(CXXFLAGS) -E $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o */*.o *.rpo *.obj *.out core *~ Templates.DB

81
reactos/lib/3rdparty/stlport/test/eh/hp.mak vendored Normal file
View file

@ -0,0 +1,81 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
# SHELL=/bin/sh
# srcdir = .
# VPATH = .
# point this to proper location
STL_INCL= -I../../stlport
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
OBJECTS = test_algo.o \
test_algobase.o test_list.o test_slist.o \
test_bit_vector.o test_vector.o \
test_deque.o test_set.o test_map.o \
test_hash_map.o test_hash_set.o test_rope.o \
test_string.o test_bitset.o test_valarray.o
LIST=${AUX_LIST} ${TEST_LIST}
# OBJECTS = $(LIST:%.cpp=%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = eh_test
TEST = eh_test.out
CC = CC
CXX = $(CC)
CXXFLAGS = -w ${STL_INCL} -D_STLP_NO_CUSTOM_IO
LIBS = -lm
LIBSTLPORT = -L../../lib -lstlport_hp
check: $(TEST)
all: $(TEST_EXE)
echo done.
$(TEST_EXE) : $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) ${LIBSTLPORT} $(LIBS) -o $(TEST_EXE)
$(TEST) : $(TEST_EXE)
$(TEST_EXE)
SUFFIXES: .cpp .o .i .s .out .res .y
.cpp.o :
$(CXX) $(CXXFLAGS) $< -c -o $@
.cpp.i :
$(CXX) $(CXXFLAGS) $< -E -H > $@
.cpp.out:
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBS) -o $*
./$* -q
-rm -f $*
.cpp.s:
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o *.rpo *.obj *.out core *~ Templates.DB SunWS_cache

119
reactos/lib/3rdparty/stlport/test/eh/hpacc.mak vendored Normal file
View file

@ -0,0 +1,119 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
srcdir = .
VPATH = .
# point this to proper location
STL_INCL=-I../../stlport
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=obj/%.o) $(STAT_MODULE)
D_OBJECTS = $(LIST:%.cpp=d_obj/%.o) $(STAT_MODULE)
NOSGI_OBJECTS = $(LIST:%.cpp=nosgi_obj/%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = ./eh_test
D_TEST_EXE = ./eh_test_d
NOSGI_TEST_EXE = ./eh_test_nosgi
TEST = ./eh_test.out
D_TEST = ./eh_test_d.out
NOSGI_TEST = ./eh_test_nosgi.out
CC = aCC
CXX = $(CC)
CXX_EXTRA_FLAGS = -AA -DEH_DELETE_HAS_THROW_SPEC
# dwa 12/22/99 -- had to turn off -ansi flag so we could use SGI IOSTREAMS
# also, test_slist won't compile with -O3/-O2 when targeting PPC. It fails
# in the assembler with 'invalid relocation type'
CXXFLAGS = -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW
D_CXXFLAGS = -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW -D_STLP_DEBUG -D_STLP_USE_STATIC_LIB
NOSGI_CXXFLAGS = -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -D_STLP_NO_OWN_IOSTREAMS -D_STLP_DEBUG_UNINITIALIZED -DEH_VECTOR_OPERATOR_NEW
check: $(TEST)
HP_VERSION=$(shell uname -r)
ifeq (${HP_VERSION},B.10.20)
PTHREAD_LIB=-lcma
else
PTHREAD_LIB=-lpthread +nostl
endif
LIBS = $(PTHREAD_LIB) -lm
D_LIBSTLPORT = -L../../lib -lstlport_aCC_debug
LIBSTLPORT = -L../../lib -lstlport_aCC
all: $(TEST_EXE) $(D_TEST_EXE) $(NOSGI_TEST_EXE)
check_nosgi: $(NOSGI_TEST)
check_d: $(D_TEST)
$(TEST_EXE) : $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBSTLPORT) $(LIBS) -o $(TEST_EXE)
$(D_TEST_EXE) : $(D_OBJECTS)
$(CXX) $(D_CXXFLAGS) $(D_OBJECTS) $(D_LIBSTLPORT) $(LIBS) -o $(D_TEST_EXE)
$(NOSGI_TEST_EXE) : $(NOSGI_OBJECTS)
$(CXX) $(NOSGI_CXXFLAGS) $(NOSGI_OBJECTS) $(LIBS) -o $(NOSGI_TEST_EXE)
$(TEST) : $(TEST_EXE)
$(TEST_EXE)
$(D_TEST) : $(D_TEST_EXE)
$(D_TEST_EXE)
$(NOSGI_TEST) : $(NOSGI_TEST_EXE)
$(NOSGI_TEST_EXE)
SUFFIXES: .cpp.o.exe.out.res
nosgi_obj/%.o : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -c -o $@
d_obj/%.o : %.cpp
$(CXX) $(D_CXXFLAGS) $< -c -o $@
obj/%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
nosgi_obj/%.i : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -E -H > $@
d_obj/%.i : %.cpp
$(CXX) $(D_CXXFLAGS) $< -E -H > $@
obj/%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBS) -o $*
./$* > $@
-rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
%.E: %.cpp
$(CXX) $(CXXFLAGS) -E $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o */*.o *.rpo *.obj *.out core *~ Templates.DB

69
reactos/lib/3rdparty/stlport/test/eh/intel.mak vendored Normal file
View file

@ -0,0 +1,69 @@
# Microsoft Developer Studio Generated NMAKE File, Format Version 4.10
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
!IF "$(OS)" == "Windows_NT"
NULL=
!ELSE
NULL=nul
!ENDIF
################################################################################
# Begin Project
RSC=rc.exe
CPP=icl.exe
F90=fl32.exe
OUTDIR=.
INTDIR=.
# set this directories
STL_INCL=../../stlport
VC_INCL=.
# d:/vc41/msdev/include
Dep_stl = TestClass.obj main.obj nc_alloc.obj \
random_number.obj test_algo.obj test_algobase.obj test_bit_vector.obj test_deque.obj \
test_hash_map.obj test_hash_set.obj test_list.obj test_map.obj test_rope.obj test_set.obj \
test_slist.obj test_vector.obj test_string.obj test_bitset.obj test_valarray.obj
LINK32=link.exe
CPP_PROJ=/nologo /W3 /GX /D "WIN32" /MTd /Zi /Gm /Od /D "_CONSOLE" /I$(STL_INCL) /I. /D_DEBUG
CPP_LIBS = /link /libpath:"..\..\lib"
check: eh_test.out
eh_test.out : $(Dep_stl)
$(CPP) $(CPP_PROJ) $(Dep_stl) -o eh_test.exe $(CPP_LIBS)
.\eh_test.exe
echo done
clean :
-@erase "$(INTDIR)\*.obj"
-@erase "$(OUTDIR)\*.exe"
-@erase "$(OUTDIR)\*.obj"
.exe.out:
$< > $@
.cpp.exe:
$(CPP) $(CPP_PROJ) -DMAIN $< $(CPP_LIBS)
.c.obj:
$(CPP) $(CPP_PROJ) /c $<
.cpp.obj:
$(CPP) $(CPP_PROJ) /c $<
.cxx.obj:
$(CPP) $(CPP_PROJ) /c $<
.cpp.E:
$(CPP) $(CPP_PROJ) -E $< >$*.E
.cpp.sbr:
$(CPP) $(CPP_PROJ) $<

109
reactos/lib/3rdparty/stlport/test/eh/intel45.mak vendored Normal file
View file

@ -0,0 +1,109 @@
# Microsoft Developer Studio Generated NMAKE File, Format Version 4.10
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
!IF "$(OS)" == "Windows_NT"
NULL=
!ELSE
NULL=nul
!ENDIF
################################################################################
# Begin Project
RSC=rc.exe
CPP=icl.exe
LINK32=xilink.exe
OUTDIR=.
INTDIR=.
# set this directories
STL_PATH=..\..
Dep_stl = TestClass.obj main.obj nc_alloc.obj \
random_number.obj test_algo.obj test_algobase.obj test_bit_vector.obj test_deque.obj \
test_hash_map.obj test_hash_set.obj test_list.obj test_map.obj test_rope.obj test_set.obj \
test_slist.obj test_vector.obj test_string.obj test_bitset.obj test_valarray.obj
CPP_LIBS = /link /incremental:no /LIBPATH:$(STL_PATH)\lib
#disable warnings complaining about debug ...info exceeded....
CPP_PRJ_EXTRA = /Qwd985
CPP_PRJ_CMN = /nologo /W3 /GR /GX /DWIN32 /D_WINDOWS /D_CONSOLE /I$(STL_PATH)\stlport /I.
#
LIBTYPE = STATIC
# LIBTYPE = DYNAMIC
#
#DEBUG = STL
DEBUG = ON
#DEBUG =
#
IOS = SGI
#IOS = NOSGI
#IOS = NONE
!IF "$(IOS)" == "NOSGI"
CPP_PRJ_IOS = /D_STLP_NO_OWN_IOSTREAMS
!ELSEIF "$(IOS)" == "NONE"
CPP_PRJ_IOS = /D_STLP_NO_IOSTREAM
!ELSE
CPP_PRJ_IOS =
!ENDIF
#MT/MD etc should be LAST in CPP_PRJ_LIBTYP string!!!
#Library selection should be BEFORE debug processing!!!
!IF "$(LIBTYPE)" == "STATIC"
CPP_PRJ_LIBTYP = /MT
!ELSE
CPP_PRJ_LIBTYP = /MD
!ENDIF
!IF "$(DEBUG)" == ""
CPP_PRJ_DBG = /DNDEBUG /O2 /Qsox-
!ELSE
CPP_PRJ_LIBTYP = $(CPP_PRJ_LIBTYP)d
CPP_PRJ_DBG = /D_DEBUG /Od
!IF "$(DEBUG)" == "STL"
CPP_PRJ_DBG = $(CPP_PRJ_DBG) /D_STLP_DEBUG
!ENDIF
CPP_PRJ_CMN = $(CPP_PRJ_CMN) /Zi /Gm
!ENDIF
CPP_PROJ = $(CPP_PRJ_CMN) $(CPP_PRJ_EXTRA) $(CPP_PRJ_IOS) $(CPP_PRJ_LIBTYP) $(CPP_PRJ_DBG)
check: eh_test.out
eh_test.out : $(Dep_stl)
$(CPP) $(CPP_PROJ) $(Dep_stl) /Feeh_test.exe $(CPP_LIBS)
cd ..\..\lib
..\test\eh\eh_test.exe -s 100
echo done
clean :
-@erase "$(INTDIR)\*.obj"
-@erase "$(OUTDIR)\*.exe"
-@erase "$(OUTDIR)\*.obj"
.exe.out:
$< > $@
.cpp.exe:
$(CPP) $(CPP_PROJ) -DMAIN $<
.c.obj:
$(CPP) $(CPP_PROJ) /c $<
.cpp.obj:
$(CPP) $(CPP_PROJ) /c $<
.cxx.obj:
$(CPP) $(CPP_PROJ) /c $<
.cpp.E:
$(CPP) $(CPP_PROJ) -E $< >$*.E
.cpp.sbr:
$(CPP) $(CPP_PROJ) $<

115
reactos/lib/3rdparty/stlport/test/eh/intel50.mak vendored Normal file
View file

@ -0,0 +1,115 @@
# Microsoft Developer Studio Generated NMAKE File, Format Version 4.10
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
!IF "$(OS)" == "Windows_NT"
NULL=
!ELSE
NULL=nul
!ENDIF
################################################################################
# Begin Project
RSC=rc.exe
CPP=icl.exe
LINK32=xilink.exe
OUTDIR=.
INTDIR=.
# set this directories
STL_PATH=..\..
Dep_stl = TestClass.obj main.obj nc_alloc.obj \
random_number.obj test_algo.obj test_algobase.obj test_bit_vector.obj test_deque.obj \
test_hash_map.obj test_hash_set.obj test_list.obj test_map.obj test_rope.obj test_set.obj \
test_slist.obj test_vector.obj test_string.obj test_bitset.obj test_valarray.obj
# linker finds proper STLport lib automatically, only path to the library is needed
CPP_PRJ_LINK = /link /incremental:no /LIBPATH:$(STL_PATH)\lib
#disable warnings complaining about debug ...info exceeded....
CPP_PRJ_EXTRA = /Qwd985
CPP_PRJ_CMN = /nologo /W3 /GR /GX /DWIN32 /D_WINDOWS /D_CONSOLE /I$(STL_PATH)\stlport /I.
#
LIBTYPE = STATIC
# LIBTYPE = DYNAMIC
#
#DEBUG = STL
DEBUG = ON
#DEBUG =
#
IOS = SGI
#IOS = NOSGI
#IOS = NONE
!IF "$(IOS)" == "NOSGI"
CPP_PRJ_IOS = /D_STLP_NO_SGI_IOSTREAMS
!ELSEIF "$(IOS)" == "NONE"
CPP_PRJ_IOS = /D_STLP_NO_IOSTREAM
!ELSE
CPP_PRJ_IOS =
!ENDIF
#MT/MD etc should be LAST in CPP_PRJ_LIBTYP string!!!
#Library selection should be BEFORE debug processing!!!
!IF "$(LIBTYPE)" == "STATIC"
CPP_PRJ_LIBTYP = /D_STLP_USE_STATIC_LIB /MT
!ELSE
CPP_PRJ_LIBTYP = /D_STLP_USE_DYNAMIC_LIB /MD
!ENDIF
!IF "$(DEBUG)" == ""
CPP_PRJ_DBG = /DNDEBUG /O2 /Qsox-
!ELSE
CPP_PRJ_LIBTYP = $(CPP_PRJ_LIBTYP)d
CPP_PRJ_DBG = /D_DEBUG /Od
!IF "$(DEBUG)" == "STL"
CPP_PRJ_DBG = $(CPP_PRJ_DBG) /D_STLP_DEBUG
!ENDIF
CPP_PRJ_CMN = $(CPP_PRJ_CMN) /Zi /Gm
!ENDIF
CPP_IGNORE_LIB = LIBCMT
#CPP_PRJ_LINK = $(CPP_PRJ_LINK) /NODEFAULTLIB:$(CPP_IGNORE_LIB)
CPP_PRJ_LINK = $(CPP_PRJ_LINK) /VERBOSE:LIB
CPP_PROJ = $(CPP_PRJ_CMN) $(CPP_PRJ_EXTRA) $(CPP_PRJ_IOS) $(CPP_PRJ_LIBTYP) $(CPP_PRJ_DBG)
check: eh_test.out
eh_test.out : $(Dep_stl)
$(CPP) $(CPP_PROJ) $(Dep_stl) /Feeh_test.exe $(CPP_PRJ_LINK)
# fbp : this is to locate DLL
cd ..\..\lib
..\test\eh\eh_test.exe -s 100
echo done
clean :
-@erase "$(INTDIR)\*.obj"
-@erase "$(OUTDIR)\*.exe"
-@erase "$(OUTDIR)\*.obj"
.exe.out:
$< > $@
.cpp.exe:
$(CPP) $(CPP_PROJ) -DMAIN $< $(CPP_PRJ_LINK)
.c.obj:
$(CPP) $(CPP_PROJ) /c $<
.cpp.obj:
$(CPP) $(CPP_PROJ) /c $<
.cxx.obj:
$(CPP) $(CPP_PROJ) /c $<
.cpp.E:
$(CPP) $(CPP_PROJ) -E $< >$*.E
.cpp.sbr:
$(CPP) $(CPP_PROJ) $<

65
reactos/lib/3rdparty/stlport/test/eh/kai.mak vendored Normal file
View file

@ -0,0 +1,65 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# point this to proper location
STL_INCL= -I../../stlport
# STL_INCL= -DEH_NO_SGI_STL
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
# TEST_LIST=test_deque.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = eh_test
TEST = eh_test.out
CC = KCC
CXX = $(CC)
CXXFLAGS = -w -mt --one_per ${STL_INCL} -D_STLP_USE_NEWALLOC -DEH_VECTOR_OPERATOR_NEW -DEH_DELETE_HAS_THROW_SPEC
# This is to test with native STL
# CXXFLAGS = -w -mt --one_per -D_STLP_USE_NEWALLOC -DEH_NO_SGI_STL -DEH_NEW_HEADERS -DEH_VECTOR_OPERATOR_NEW -DEH_DELETE_HAS_THROW_SPEC
# This is to test with STLport iostreams
LIBS = -L../../lib -lstlport_kcc -lm
LIBSTDCXX =
check: $(TEST)
$(TEST) : $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBS) -o $(TEST_EXE)
$(TEST_EXE)
SUFFIXES: .cpp.o.out.res
%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBS) -o $*
./$* -q
-rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o *.rpo *.obj *.out core *~ Templates.DB SunWS_cache ti_files

60
reactos/lib/3rdparty/stlport/test/eh/locale.cpp vendored Normal file
View file

@ -0,0 +1,60 @@
#include <exception>
#include <iostream>
#include <locale>
#include <ctime>
using namespace std;
void main()
{
try
{
locale c_loc;
//locale sys(c_loc, "LC_TIME=UKR_UKR.OCP;LC_NUMERIC=RUS_RUS.OCP;LC_CTYPE=ukr_ukr.ocp;", locale::numeric | locale::time | locale::ctype);
locale sys(".ocp");
locale::global(sys);
cin.imbue(sys);
cout.imbue(sys);
cout<<"Locale name is: "<<sys.name().c_str()<<'\n';
cout<<"Enter real number:";
double value;
cin>>value;
cout<<value<<'\n';
// Time test.
long lcur_time;
time(&lcur_time);
struct tm* cur_time=localtime(&lcur_time);
const numpunct<char>& num_punct=use_facet<numpunct<char> >(cout.getloc());
cout << num_punct.decimal_point() << '\n';
const time_put<char, ostreambuf_iterator<char, char_traits<char> > >& time_fac=
use_facet<time_put<char, ostreambuf_iterator<char, char_traits<char> > > >(cout.getloc());
time_fac.put(cout, cout, NULL, cur_time, 'x'); cout<<'\n';
time_fac.put(cout, cout, NULL, cur_time, 'x', '#'); cout<<'\n';
time_fac.put(cout, cout, NULL, cur_time, 'X'); cout<<'\n';
time_fac.put(cout, cout, NULL, cur_time, 'c'); cout<<'\n';
time_fac.put(cout, cout, NULL, cur_time, 'c', '#'); cout<<'\n';
time_fac.put(cout, cout, NULL, cur_time, 'I'); cout<<'\n';
const ctype<char>& char_type=use_facet<ctype<char> >(cout.getloc());
if(char_type.is(ctype_base::upper, '<EFBFBD>')) puts("Upper");
if(char_type.is(ctype_base::lower, '¯')) puts("Lower");
puts("Next");
if(isupper('<EFBFBD>', cout.getloc())) puts("Upper");
if(islower('¯', cout.getloc())) puts("Lower");
/*for(int ch=128; ch<256; ch++)
printf("Character %c (%d) - upper %c, lower %c\n",(char)ch, ch,toupper((char)ch, cout.getloc()), tolower((char)ch, cout.getloc()));*/
}
catch(exception &e)
{
cout<<"Exception fired:\n"<<e.what()<<'\n';
}
catch(...)
{
cout<<"Unknown exception throwed!\n";
}
cout.flush();
}

407
reactos/lib/3rdparty/stlport/test/eh/main.cpp vendored Normal file
View file

@ -0,0 +1,407 @@
/***********************************************************************************
Main.cpp
* Copyright (c) 1997
* 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 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
* 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. 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.
***********************************************************************************/
#include "Prefix.h"
#include "Tests.h"
#if defined (EH_NEW_IOSTREAMS)
# include <iostream>
# else
# include <iostream.h>
#endif
#if defined(macintosh)&&(!defined(__MRC__) && !defined(__SC__)) || defined (_MAC) && defined(__MWERKS__)
# include <console.h>
# include <Types.h>
# include <Strings.h>
# ifdef EH_NEW_HEADERS
# include <cstdio>
# include <cstring>
# include <cassert>
# else
# include <stdio.h>
# include <string.h>
# include <assert.h>
# endif
# if defined (_STL_DEBUG)
# if defined ( EH_USE_SGI_STL )
// Override assertion behavior
# include <cstdarg>
//# include <stldebug.h>
void STLPORT::__stl_debug_message(const char * format_str, ...)
{
std::va_list args;
va_start( args, format_str );
char msg[256];
std::vsnprintf(msg, sizeof(msg)/sizeof(*msg) - 1, format_str, args );
DebugStr( c2pstr(msg) );
}
# else
/*===================================================================================
__assertion_failed (override standard library function)
EFFECTS: Breaks into the debugger and shows the assertion. This implementation
is Mac-specific; others could be added for other platforms.
====================================================================================*/
extern "C"
{
void __assertion_failed(char *condition, char *testfilename, int lineno);
void __assertion_failed(char *condition, char *testfilename, int lineno)
{
char msg[256];
std::strncpy( msg, condition, 255 );
std::strncat( msg, ": ", 255 );
std::strncat( msg, testfilename, 255 );
std::strncat( msg, ", ", 255 );
char line[20];
std::sprintf( line, "%d", lineno );
std::strncat( msg, line, 255 );
DebugStr( c2pstr( msg ) );
}
}
# endif
# endif
#endif
#include "nc_alloc.h"
#if defined (EH_NEW_HEADERS)
# include <vector>
# include <cstring>
# else
# include <vector.h>
# include <string.h>
#endif
#include "TestClass.h"
#include "LeakCheck.h"
#include "test_construct.h"
#ifdef __BORLANDC__
# include <except.h>
#endif
# if defined(EH_USE_NAMESPACES)
namespace // dwa 1/21/00 - must use unnamed namespace here to avoid conflict under gcc using native streams
{
using namespace std;
// using std::cerr;
// using std::endl;
}
# endif
/*===================================================================================
usage (file-static helper)
EFFECTS: Prints a message describing the command-line parameters
====================================================================================*/
static void usage(const char* name)
{
cerr<<"Usage : "<<name<<" [-n <iterations>] [-s <size>] [-l] [-e] [-q]/[-v] [-t] [test_name...]\n";
cerr<<"\t[-n <iterations>] : number of test iterations, default==100;"<<endl;
cerr<<"\t[-s <size>] : base value for random container sizes, default==1000;"<<endl;
cerr<<"\t[-e] : don't throw exceptions, test for leak in normal conditions;"<<endl;
// This option was never actually used -- dwa 9/22/97
// cerr<<"\t[-i] : ignore leak errors;"<<endl;
cerr<<"\t[-q] : quiet mode;"<<endl;
cerr<<"\t[-v] : verbose mode;"<<endl;
cerr<<"\t[-t] : track each allocation;"<<endl;
cerr<<"\t[test name [test name...]] : run only some of the tests by name (default==all tests):"<<endl;
cerr<<"\t\tpossible test names are : algo vector bit_vector list slist deque set map hash_set hash_map rope string bitset valarray"<<endl;
EH_CSTD::exit(1);
}
#ifdef EH_NEW_HEADERS
# include <set>
#else
# include <set.h>
#endif
#if defined(_WIN32_WCE)
#include <fstream>
#endif
int _STLP_CALL main(int argc, char** argv)
{
#if defined(_WIN32_WCE)
std::ofstream file( "\\eh_test.txt" );
std::streambuf* old_cout_buf = cout.rdbuf(file.rdbuf());
std::streambuf* old_cerr_buf = cerr.rdbuf(file.rdbuf());
#endif
#if defined( __MWERKS__ ) && defined( macintosh ) // Get command line.
argc = ccommand(&argv);
// Allow the i/o window to be repositioned.
// EH_STD::string s;
// getline(EH_STD::cin, s);
#endif
unsigned int niters=2;
bool run_all=true;
bool run_slist = false;
bool run_list = false;
bool run_vector = false;
bool run_bit_vector = false;
bool run_deque = false;
bool run_hash_map = false;
bool run_hash_set = false;
bool run_set = false;
bool run_map = false;
bool run_algo = false;
bool run_algobase = false;
bool run_rope = false;
bool run_string = false;
bool run_bitset = false;
bool run_valarray = false;
int cur_argv;
char *p, *p1;
#if defined (EH_NEW_IOSTREAMS)
std::ios_base::sync_with_stdio(false);
#endif
cerr << argv[0]<<" : Exception handling testsuite.\n";
cerr.flush();
bool track_allocations = false;
// parse parameters :
// leak_test [-iterations] [-test] ...
for (cur_argv=1; cur_argv<argc; cur_argv++) {
p = argv[cur_argv];
if (*p == '-') {
switch (p[1]) {
case 'q':
gTestController.SetVerbose(false);
break;
case 'v':
gTestController.SetVerbose(true);
break;
#if 0 // This option was never actually used -- dwa 9/22/97
case 'i':
gTestController.IgnoreLeaks(true);
break;
#endif
case 'n':
p1 = argv[++cur_argv];
if (p1 && EH_CSTD::sscanf(p1, "%i", &niters)==1)
cerr <<" Doing "<<niters<<" iterations\n";
else
usage(argv[0]);
break;
case 't':
track_allocations = true;
break;
case 'e':
gTestController.TurnOffExceptions();
break;
case 's':
p1 = argv[++cur_argv];
if (p1 && EH_CSTD::sscanf(p1, "%i", &random_base)==1)
cerr <<" Setting "<<random_base<<" as base for random sizes.\n";
else
usage(argv[0]);
break;
default:
usage(argv[0]);
break;
}
} else {
run_all = false;
// test name
if (EH_CSTD::strcmp(p, "algo")==0) {
run_algo=true;
} else if (EH_CSTD::strcmp(p, "vector")==0) {
run_vector=true;
} else if (EH_CSTD::strcmp(p, "bit_vector")==0) {
run_bit_vector=true;
} else if (EH_CSTD::strcmp(p, "list")==0) {
run_list=true;
} else if (EH_CSTD::strcmp(p, "slist")==0) {
run_slist=true;
} else if (EH_CSTD::strcmp(p, "deque")==0) {
run_deque=true;
} else if (EH_CSTD::strcmp(p, "set")==0) {
run_set=true;
} else if (EH_CSTD::strcmp(p, "map")==0) {
run_map=true;
} else if (EH_CSTD::strcmp(p, "hash_set")==0) {
run_hash_set=true;
} else if (EH_CSTD::strcmp(p, "hash_map")==0) {
run_hash_map=true;
} else if (EH_CSTD::strcmp(p, "rope")==0) {
run_rope=true;
} else if (EH_CSTD::strcmp(p, "string")==0) {
run_string=true;
} else if (EH_CSTD::strcmp(p, "bitset")==0) {
run_bitset=true;
} else if (EH_CSTD::strcmp(p, "valarray")==0) {
run_valarray=true;
} else {
usage(argv[0]);
}
}
}
gTestController.TrackAllocations( track_allocations );
// Over and over...
for ( unsigned i = 0; i < niters ; i++ )
{
cerr << "iteration #" << i << "\n";
if (run_all || run_algobase) {
gTestController.SetCurrentContainer("algobase");
cerr << "EH test : algobase" << endl;
test_algobase();
}
if (run_all || run_algo) {
gTestController.SetCurrentContainer("algo");
cerr << "EH test : algo" << endl;
test_algo();
}
if (run_all || run_vector) {
gTestController.SetCurrentContainer("vector");
cerr << "EH test : vector" << endl;
test_vector();
}
#if defined( EH_BIT_VECTOR_IMPLEMENTED )
if (run_all || run_bit_vector) {
gTestController.SetCurrentContainer("bit_vector");
cerr << "EH test : bit_vector" << endl;
test_bit_vector();
}
#endif
if (run_all || run_list) {
gTestController.SetCurrentContainer("list");
cerr << "EH test : list" << endl;
test_list();
}
#if defined( EH_SLIST_IMPLEMENTED )
if (run_all || run_slist) {
gTestController.SetCurrentContainer("slist");
cerr << "EH test : slist" << endl;
test_slist();
}
#endif // EH_SLIST_IMPLEMENTED
if (run_all || run_deque) {
gTestController.SetCurrentContainer("deque");
cerr << "EH test : deque" << endl;
test_deque();
}
if (run_all || run_set) {
gTestController.SetCurrentContainer("set");
cerr << "EH test : set" << endl;
test_set();
gTestController.SetCurrentContainer("multiset");
cerr << "EH test : multiset" << endl;
test_multiset();
}
if (run_all || run_map) {
gTestController.SetCurrentContainer("map");
cerr << "EH test : map" << endl;
test_map();
gTestController.SetCurrentContainer("multimap");
cerr << "EH test : multimap" << endl;
test_multimap();
}
#if defined( EH_HASHED_CONTAINERS_IMPLEMENTED )
if (run_all || run_hash_map) {
gTestController.SetCurrentContainer("hash_map");
cerr << "EH test : hash_map" << endl;
test_hash_map();
gTestController.SetCurrentContainer("hash_multimap");
cerr << "EH test : hash_multimap" << endl;
test_hash_multimap();
}
if (run_all || run_hash_set) {
gTestController.SetCurrentContainer("hash_set");
cerr << "EH test : hash_set" << endl;
test_hash_set();
gTestController.SetCurrentContainer("hash_multiset");
cerr << "EH test : hash_multiset" << endl;
test_hash_multiset();
}
#endif // EH_HASHED_CONTAINERS_IMPLEMENTED
#if defined( EH_ROPE_IMPLEMENTED )
// CW1.8 can't compile this for some reason!
#if !( defined(__MWERKS__) && __MWERKS__ < 0x1900 )
if (run_all || run_rope) {
gTestController.SetCurrentContainer("rope");
cerr << "EH test : rope" << endl;
test_rope();
}
#endif
#endif // EH_ROPE_IMPLEMENTED
#if defined( EH_STRING_IMPLEMENTED )
if (run_all || run_string) {
gTestController.SetCurrentContainer("string");
cerr << "EH test : string" << endl;
test_string();
}
#endif
#if defined( EH_BITSET_IMPLEMENTED )
if (run_all || run_bitset) {
gTestController.SetCurrentContainer("bitset");
cerr << "EH test : bitset" << endl;
test_bitset();
}
#endif
#if defined( EH_VALARRAY_IMPLEMENTED )
if (run_all || run_bitset) {
gTestController.SetCurrentContainer("valarray");
cerr << "EH test : valarray" << endl;
test_valarray();
}
#endif
}
gTestController.TrackAllocations( false );
cerr << "EH test : Done\n";
#if defined(_WIN32_WCE)
cout.rdbuf(old_cout_buf);
cerr.rdbuf(old_cerr_buf);
file.close();
#endif
return 0;
}

111
reactos/lib/3rdparty/stlport/test/eh/mingw32.mak vendored Normal file
View file

@ -0,0 +1,111 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
srcdir = .
VPATH = .
# point this to proper location
STL_INCL=-I../../stlport
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=obj/%.o) $(STAT_MODULE)
D_OBJECTS = $(LIST:%.cpp=d_obj/%.o) $(STAT_MODULE)
NOSGI_OBJECTS = $(LIST:%.cpp=nosgi_obj/%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = ./eh_test
D_TEST_EXE = ./eh_test_d
NOSGI_TEST_EXE = ./eh_test_nosgi
TEST = ./eh_test.out
D_TEST = ./eh_test_d.out
NOSGI_TEST = ./eh_test_nosgi.out
CC = c++
CXX = $(CC)
# dwa 12/22/99 -- had to turn off -ansi flag so we could use SGI IOSTREAMS
# also, test_slist won't compile with -O3/-O2 when targeting PPC. It fails
# in the assembler with 'invalid relocation type'
CXXFLAGS = -Wall -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW
D_CXXFLAGS = -Wall -g -O ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -DEH_VECTOR_OPERATOR_NEW -D_STLP_DEBUG -D_STLP_USE_STATIC_LIB
NOSGI_CXXFLAGS = -Wall -g -O2 ${STL_INCL} -I. ${CXX_EXTRA_FLAGS} -D_STLP_NO_OWN_IOSTREAMS -D_STLP_DEBUG_UNINITIALIZED -DEH_VECTOR_OPERATOR_NEW
check: $(TEST)
LIBS = -lm
D_LIBSTLPORT = -L../../lib -lstlport_mingw32_debug_static
LIBSTLPORT = -L../../lib -lstlport_mingw32_static
all: $(TEST_EXE) $(D_TEST_EXE) $(NOSGI_TEST_EXE)
check_nosgi: $(NOSGI_TEST)
check_d: $(D_TEST)
$(TEST_EXE) : $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBSTLPORT) $(LIBS) -o $(TEST_EXE)
$(D_TEST_EXE) : $(D_OBJECTS)
$(CXX) $(D_CXXFLAGS) $(D_OBJECTS) $(D_LIBSTLPORT) $(LIBS) -o $(D_TEST_EXE)
$(NOSGI_TEST_EXE) : $(NOSGI_OBJECTS)
$(CXX) $(NOSGI_CXXFLAGS) $(NOSGI_OBJECTS) $(LIBS) -o $(NOSGI_TEST_EXE)
$(TEST) : $(TEST_EXE)
$(TEST_EXE)
$(D_TEST) : $(D_TEST_EXE)
$(D_TEST_EXE)
$(NOSGI_TEST) : $(NOSGI_TEST_EXE)
$(NOSGI_TEST_EXE)
SUFFIXES: .cpp.o.exe.out.res
nosgi_obj/%.o : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -c -o $@
d_obj/%.o : %.cpp
$(CXX) $(D_CXXFLAGS) $< -c -o $@
obj/%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
nosgi_obj/%.i : %.cpp
$(CXX) $(NOSGI_CXXFLAGS) $< -E -H > $@
d_obj/%.i : %.cpp
$(CXX) $(D_CXXFLAGS) $< -E -H > $@
obj/%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBS) -o $*
./$* > $@
-rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
%.E: %.cpp
$(CXX) $(CXXFLAGS) -E $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o */*.o *.rpo *.obj *.out core *~ Templates.DB

193
reactos/lib/3rdparty/stlport/test/eh/mwerks_console_OS_X.c vendored Normal file
View file

@ -0,0 +1,193 @@
/* Metrowerks Standard Library
* Copyright © 1995-2002 Metrowerks Corporation. All rights reserved.
*
* $Date$
* $Revision$
*/
#include <ansi_parms.h>
#include <size_t.h>
#include <console.h>
#include <unistd.h>
#if __MACH__
short InstallConsole(short fd)
{
#pragma unused (fd)
return 0;
}
#else
#include <Carbon.h>
typedef int (*ReadPtr)(int, void *, __std(size_t));
typedef int (*WritePtr)(int, const void *, __std(size_t));
static struct
{
Boolean isLoaded;
CFBundleRef theBundle;
ReadPtr theRead;
WritePtr theWrite;
} __msl_os_x;
static OSErr __msl_CreateFrameworkBundleFromName(CFStringRef theFrameworkName,
CFBundleRef *theBundle)
{
OSErr theErr;
FSRef theRef;
CFURLRef theFrameworkURL;
CFURLRef theBundleURL;
/* Find the folder containing all the frameworks */
theErr = FSFindFolder(kOnAppropriateDisk, kFrameworksFolderType, false, &theRef);
if (theErr == noErr)
{
/* Turn the framework folder FSRef into a CFURL */
theFrameworkURL = CFURLCreateFromFSRef(kCFAllocatorSystemDefault, &theRef);
if (theFrameworkURL != NULL)
{
/* Create a CFURL pointing to the desired framework */
theBundleURL = CFURLCreateCopyAppendingPathComponent(kCFAllocatorSystemDefault,
theFrameworkURL, theFrameworkName, false);
CFRelease(theFrameworkURL);
if (theBundleURL != NULL)
{
/* Turn the CFURL into a bundle reference */
*theBundle = CFBundleCreate(kCFAllocatorSystemDefault, theBundleURL);
CFRelease(theBundleURL);
}
}
}
return theErr;
}
short InstallConsole(short fd)
{
#pragma unused (fd)
OSErr theErr;
short theResult;
theResult = -1;
/* Start with no bundle */
__msl_os_x.isLoaded = false;
__msl_os_x.theBundle = NULL;
__msl_os_x.theRead = NULL;
__msl_os_x.theWrite = NULL;
/* Create a bundle reference based on its name */
theErr = __msl_CreateFrameworkBundleFromName(CFSTR("System.framework"),
&__msl_os_x.theBundle);
if ((theErr == noErr) && (__msl_os_x.theBundle != NULL))
{
theResult = 0;
__msl_os_x.isLoaded = CFBundleLoadExecutable(__msl_os_x.theBundle);
if (__msl_os_x.isLoaded)
{
/* Lookup the functions in the bundle by name */
__msl_os_x.theRead = (ReadPtr)
CFBundleGetFunctionPointerForName(__msl_os_x.theBundle, CFSTR("read"));
__msl_os_x.theWrite = (WritePtr)
CFBundleGetFunctionPointerForName(__msl_os_x.theBundle, CFSTR("write"));
}
}
return theResult;
}
#endif
void RemoveConsole(void)
{
#if !__MACH__
if (__msl_os_x.theBundle != NULL)
{
if (__msl_os_x.isLoaded)
{
__msl_os_x.theRead = NULL;
__msl_os_x.theWrite = NULL;
CFBundleUnloadExecutable(__msl_os_x.theBundle);
__msl_os_x.isLoaded = false;
}
CFRelease(__msl_os_x.theBundle);
__msl_os_x.theBundle = NULL;
}
#endif
}
long WriteCharsToConsole(char *buffer, long n)
{
#if __MACH__
return write(1, buffer, n);
#else
/* Call the function if it was found */
if (__msl_os_x.theWrite == NULL)
return -1;
else
return __msl_os_x.theWrite(1, buffer, n);
#endif
}
#if __MACH__
long WriteCharsToErrorConsole(char *buffer, long n)
{
return write(2, buffer, n);
}
#endif
long ReadCharsFromConsole(char *buffer, long n)
{
#if __MACH__
return read(0, buffer, n);
#else
/* Call the function if it was found */
if (__msl_os_x.theRead == NULL)
return -1;
else
return __msl_os_x.theRead(0, buffer, n);
#endif
}
/* JWW - This code should never be reached, but it's needed for link purposes */
char *__ttyname(long fildes)
{
#pragma unused (fildes)
/* all streams have the same name */
static char *__devicename = "Terminal";
if (fildes >= 0 && fildes <= 2)
return (__devicename);
return (0L);
}
int kbhit(void)
{
return 0;
}
int getch(void)
{
return 0;
}
void clrscr()
{
return;
}
/* Change record:
* JWW 010919 Created Mach-O console stubs file
* JWW 020418 Use __std() for all size_t, and #include <size_t.h> to get proper C++ definitions
*/

8
reactos/lib/3rdparty/stlport/test/eh/mwerks_debug_prefix.h vendored Normal file
View file

@ -0,0 +1,8 @@
//mwerks_debug_prefix.h
#define _STLP_NO_FORCE_INSTANTIATE 1// for debugging
#define EH_VECTOR_OPERATOR_NEW 1
#define _STLP_DEBUG 1 // enable the use of allocation debugging
#if __MWERKS__ >= 0x3000
#include <MSLCarbonPrefix.h>
#endif

5
reactos/lib/3rdparty/stlport/test/eh/mwerks_nosgi_debug_prefix.h vendored Normal file
View file

@ -0,0 +1,5 @@
//mwerks_nosgi_debug_prefix.h
#define _STLP_NO_SGI_IOSTREAMS 1
#define _STLP_NO_FORCE_INSTANTIATE 1 // for debugging
#define _STLP_DEBUG_UNINITIALIZED 1 // enable the use of allocation debugging
#define EH_VECTOR_OPERATOR_NEW 1

5
reactos/lib/3rdparty/stlport/test/eh/mwerks_nosgi_prefix.h vendored Normal file
View file

@ -0,0 +1,5 @@
//mwerks_nosgi_prefix.h
#define _STLP_NO_SGI_IOSTREAMS 1
#define _STLP_NO_FORCE_INSTANTIATE 1 // for debugging
#define EH_VECTOR_OPERATOR_NEW 1
#define NDEBUG 1

8
reactos/lib/3rdparty/stlport/test/eh/mwerks_prefix.h vendored Normal file
View file

@ -0,0 +1,8 @@
//mwerks_prefix.h
#define _STLP_NO_FORCE_INSTANTIATE 1// for debugging
#define EH_VECTOR_OPERATOR_NEW 1
#define NDEBUG 1
#if __MWERKS__ >= 0x3000
#include <MSLCarbonPrefix.h>
#endif

328
reactos/lib/3rdparty/stlport/test/eh/nc_alloc.cpp vendored Normal file
View file

@ -0,0 +1,328 @@
/************************************************************************************************
NC_ALLOC.CPP
* Copyright (c) 1997
* 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 makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
************************************************************************************************/
#include "nc_alloc.h"
#include <string>
#if defined (EH_NEW_HEADERS)
# include <new>
# include <cassert>
# include <cstdlib>
#else
# include <assert.h>
# include <stdlib.h>
# include <new.h>
#endif
#if defined (EH_NEW_IOSTREAMS)
# include <iostream>
#else
# include <iostream.h>
#endif
long alloc_count = 0;
long object_count = 0;
long TestController::possible_failure_count = 0;
const char* TestController::current_test = "<unknown>";
const char* TestController::current_test_category = "no category";
const char* TestController::current_container = 0;
bool TestController::nc_verbose = true;
bool TestController::never_fail = false;
bool TestController::track_allocations = false;
bool TestController::leak_detection_enabled = false;
TestController gTestController;
//************************************************************************************************
void TestController::maybe_fail(long) {
if (never_fail || Failure_threshold() == kNotInExceptionTest)
return;
// throw if allocation would satisfy the threshold
if (possible_failure_count++ >= Failure_threshold()) {
// what about doing some standard new_handler() behavior here (to test it!) ???
// reset and simulate an out-of-memory failure
Failure_threshold() = kNotInExceptionTest;
#ifndef EH_NO_EXCEPTIONS
throw EH_STD::bad_alloc();
#endif
}
}
#if defined (EH_HASHED_CONTAINERS_IMPLEMENTED)
# if defined (__SGI_STL)
# if defined (EH_NEW_HEADERS)
# include <hash_set>
# else
# include <hash_set.h>
# endif
# elif defined (__MSL__)
# include <hashset.h>
# else
# error what do I include to get hash_set?
# endif
#else
# if defined (EH_NEW_HEADERS)
# include <set>
# else
# include <set.h>
# endif
#endif
#if !defined (EH_HASHED_CONTAINERS_IMPLEMENTED)
typedef EH_STD::set<void*, EH_STD::less<void*> > allocation_set;
#else
USING_CSTD_NAME(size_t)
struct hash_void {
size_t operator()(void* x) const { return (size_t)x; }
};
typedef EH_STD::hash_set<void*, ::hash_void, EH_STD::equal_to<void*> > allocation_set;
#endif
static allocation_set& alloc_set() {
static allocation_set s;
return s;
}
// Prevents infinite recursion during allocation
static bool using_alloc_set = false;
#if !defined (NO_FAST_ALLOCATOR)
//
// FastAllocator -- speeds up construction of TestClass objects when
// TESTCLASS_DEEP_DATA is enabled, and speeds up tracking of allocations
// when the suite is run with the -t option.
//
class FastAllocator {
public:
//FastAllocator() : mFree(0), mUsed(0) {}
static void *Allocate(size_t s) {
void *result = 0;
if (s <= sizeof(Block)) {
if (mFree != 0) {
result = mFree;
mFree = mFree->next;
}
else if (mBlocks != 0 && mUsed < kBlockCount) {
result = (void*)&mBlocks[mUsed++];
}
}
return result;
}
static bool Free(void* p) {
Block* b = (Block*)p;
if (mBlocks == 0 || b < mBlocks || b >= mBlocks + kBlockCount)
return false;
b->next = mFree;
mFree = b;
return true;
}
struct Block;
friend struct Block;
enum {
// Number of fast allocation blocks to create.
kBlockCount = 1500,
// You may need to adjust this number for your platform.
// A good choice will speed tests. A bad choice will still work.
kMinBlockSize = 48
};
struct Block {
union {
Block *next;
double dummy; // fbp - force alignment
char dummy2[kMinBlockSize];
};
};
static Block* mBlocks;
static Block *mFree;
static size_t mUsed;
};
FastAllocator::Block *FastAllocator::mBlocks =
(FastAllocator::Block*)EH_CSTD::calloc( sizeof(FastAllocator::Block), FastAllocator::kBlockCount );
FastAllocator::Block *FastAllocator::mFree;
size_t FastAllocator::mUsed;
static FastAllocator gFastAllocator;
#endif
inline char* AllocateBlock(size_t s) {
#if !defined (NO_FAST_ALLOCATOR)
char * const p = (char*)gFastAllocator.Allocate( s );
if (p != 0)
return p;
#endif
return (char*)EH_CSTD::malloc(s);
}
static void* OperatorNew( size_t s ) {
if (!using_alloc_set) {
simulate_possible_failure();
++alloc_count;
}
char *p = AllocateBlock(s);
if (gTestController.TrackingEnabled() &&
gTestController.LeakDetectionEnabled() &&
!using_alloc_set) {
using_alloc_set = true;
bool inserted = alloc_set().insert(p).second;
// Suppress warning about unused variable.
inserted;
EH_ASSERT(inserted);
using_alloc_set = false;
}
return p;
}
void* _STLP_CALL operator new(size_t s)
#ifdef EH_DELETE_HAS_THROW_SPEC
throw(EH_STD::bad_alloc)
#endif
{ return OperatorNew( s ); }
#ifdef EH_USE_NOTHROW
void* _STLP_CALL operator new(size_t size, const EH_STD::nothrow_t&) throw() {
try {
return OperatorNew( size );
}
catch (...) {
return 0;
}
}
#endif
#if 1 /* defined (EH_VECTOR_OPERATOR_NEW) */
void* _STLP_CALL operator new[](size_t size ) throw(EH_STD::bad_alloc) {
return OperatorNew( size );
}
# ifdef EH_USE_NOTHROW
void* _STLP_CALL operator new[](size_t size, const EH_STD::nothrow_t&) throw() {
try {
return OperatorNew(size);
}
catch (...) {
return 0;
}
}
# endif
void _STLP_CALL operator delete[](void* ptr) throw()
{ operator delete( ptr ); }
#endif
#if defined (EH_DELETE_HAS_THROW_SPEC)
void _STLP_CALL operator delete(void* s) throw()
#else
void _STLP_CALL operator delete(void* s)
#endif
{
if ( s != 0 ) {
if ( !using_alloc_set ) {
--alloc_count;
if ( gTestController.TrackingEnabled() && gTestController.LeakDetectionEnabled() ) {
using_alloc_set = true;
allocation_set::iterator p = alloc_set().find( (char*)s );
EH_ASSERT( p != alloc_set().end() );
alloc_set().erase( p );
using_alloc_set = false;
}
}
# if ! defined (NO_FAST_ALLOCATOR)
if ( !gFastAllocator.Free( s ) )
# endif
EH_CSTD::free(s);
}
}
/*===================================================================================
ClearAllocationSet (private helper)
EFFECTS: Empty the set of allocated blocks.
====================================================================================*/
void TestController::ClearAllocationSet() {
if (!using_alloc_set) {
using_alloc_set = true;
alloc_set().clear();
using_alloc_set = false;
}
}
bool TestController::ReportLeaked() {
EndLeakDetection();
EH_ASSERT( !using_alloc_set || (alloc_count == static_cast<int>(alloc_set().size())) );
if (alloc_count != 0 || object_count != 0) {
EH_STD::cerr<<"\nEH TEST FAILURE !\n";
PrintTestName(true);
if (alloc_count)
EH_STD::cerr << "ERROR : " << alloc_count << " outstanding allocations.\n";
if (object_count)
EH_STD::cerr << "ERROR : " << object_count << " non-destroyed objects.\n";
alloc_count = object_count = 0;
return true;
}
return false;
}
/*===================================================================================
PrintTestName
EFFECTS: Prints information about the current test. If err is false, ends with
an ellipsis, because the test is ongoing. If err is true an error is being
reported, and the output ends with an endl.
====================================================================================*/
void TestController::PrintTestName(bool err) {
if (current_container)
EH_STD::cerr<<"["<<current_container<<"] :";
EH_STD::cerr<<"testing "<<current_test <<" (" << current_test_category <<")";
if (err)
EH_STD::cerr<<EH_STD::endl;
else
EH_STD::cerr<<" ... ";
}
void TestController::ReportSuccess(int count) {
if (nc_verbose)
EH_STD::cerr<<(count+1)<<" try successful"<<EH_STD::endl;
}
long& TestController::Failure_threshold() {
static long failure_threshold = kNotInExceptionTest;
return failure_threshold;
}

184
reactos/lib/3rdparty/stlport/test/eh/nc_alloc.h vendored Normal file
View file

@ -0,0 +1,184 @@
/***********************************************************************************
TestController.h
SUMMARY: An "faux-singleton" object to encapsulate a hodgepodge of state and
functionality relating to the test suite. Probably should be broken
into smaller pieces.
* Copyright (c) 1997
* 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 makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
***********************************************************************************/
#if !INCLUDED_MOTU_nc_alloc
#define INCLUDED_MOTU_nc_alloc 1
#include "Prefix.h"
#if defined (EH_NEW_HEADERS)
# include <utility>
#else
# include <pair.h>
#endif
extern long alloc_count;
extern long object_count;
struct TestController {
// Report that the current test has succeeded.
static void ReportSuccess(int);
//
// Leak detection
//
// Turn the recording of the addresses of individual allocated
// blocks on or off. If not called, allocations will only be
// counted, but deallocations won't be checked for validity.
static void TrackAllocations( bool );
static bool TrackingEnabled();
// Call this to begin a new leak-detection cycle. Resets all
// allocation counts, etc.
static void BeginLeakDetection();
// Returns true iff leak detection is currently in effect
static bool LeakDetectionEnabled();
// Ends leak detection and reports any resource leaks.
// Returns true if any occurred.
static bool ReportLeaked();
//
// Exception-safety
//
// Don't test for exception-safety
static void TurnOffExceptions();
// Set operator new to fail on the nth invocation
static void SetFailureCountdown( long n );
// Set operator new to never fail.
static void CancelFailureCountdown();
// Throws an exception if the count has been reached. Call this
// before every operation that might fail in the real world.
static void maybe_fail(long);
//
// Managing verbose feedback.
//
// Call to begin a strong, weak, or const test. If verbose
// reporting is enabled, prints the test category.
static void SetCurrentTestCategory( const char* str );
// Call to set the name of the container being tested.
static void SetCurrentContainer( const char* str );
// Sets the name of the current test.
static void SetCurrentTestName(const char* str);
// Turn verbose reporting on or off.
static void SetVerbose(bool val);
private:
enum { kNotInExceptionTest = -1 };
static void ClearAllocationSet();
static void EndLeakDetection();
static void PrintTestName( bool err=false );
static long& Failure_threshold();
static long possible_failure_count;
static const char* current_test;
static const char* current_test_category;
static const char* current_container;
static bool nc_verbose;
static bool never_fail;
static bool track_allocations;
static bool leak_detection_enabled;
};
extern TestController gTestController;
//
// inline implementations
//
inline void simulate_possible_failure() {
gTestController.maybe_fail(0);
}
inline void simulate_constructor() {
gTestController.maybe_fail(0);
++object_count;
}
inline void simulate_destructor() {
--object_count;
}
inline void TestController::TrackAllocations(bool track) {
track_allocations = track;
}
inline bool TestController::TrackingEnabled() {
return track_allocations;
}
inline void TestController::SetFailureCountdown(long count) {
Failure_threshold() = count;
possible_failure_count = 0;
}
inline void TestController::CancelFailureCountdown() {
Failure_threshold() = kNotInExceptionTest;
}
inline void TestController::BeginLeakDetection() {
alloc_count = 0;
object_count = 0;
ClearAllocationSet();
leak_detection_enabled = true;
}
inline bool TestController::LeakDetectionEnabled() {
return leak_detection_enabled;
}
inline void TestController::EndLeakDetection() {
leak_detection_enabled = false;
}
inline void TestController::SetCurrentTestCategory(const char* str) {
current_test_category = str;
if (nc_verbose)
PrintTestName();
}
inline void TestController::SetCurrentContainer(const char* str) {
current_container=str;
}
inline void TestController::SetCurrentTestName(const char* str) {
current_test = str;
}
inline void TestController::SetVerbose(bool val) {
nc_verbose = val;
}
inline void TestController::TurnOffExceptions() {
never_fail = true;
}
#endif // INCLUDED_MOTU_nc_alloc

39
reactos/lib/3rdparty/stlport/test/eh/random_number.cpp vendored Normal file
View file

@ -0,0 +1,39 @@
/***********************************************************************************
random_number.cpp
* Copyright (c) 1997
* 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 makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
***********************************************************************************/
#include "random_number.h"
#include "Prefix.h"
#if defined (EH_NEW_HEADERS)
# include <functional>
# include <cstdlib>
#else
# include <function.h>
# include <stdlib.h>
#endif
unsigned random_number( size_t range )
{
#if !defined( __SGI_STL )
if (range == 0) return 0;
return (unsigned)(EH_STD::rand() + EH_STD::rand()) % range;
#else
static EH_STD::subtractive_rng rnd;
if (range==0) return 0;
return rnd(range);
#endif
}
// default base for random container sizes
unsigned random_base = 1000;

27
reactos/lib/3rdparty/stlport/test/eh/random_number.h vendored Normal file
View file

@ -0,0 +1,27 @@
/***********************************************************************************
random_number.h
* Copyright (c) 1997-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 makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
***********************************************************************************/
#ifndef RANDOM_NUMBER_DWA120298_H_
#define RANDOM_NUMBER_DWA120298_H_
#include <stddef.h>
// Return a random number in the given range.
unsigned random_number( size_t range );
// default base for random container sizes
extern unsigned random_base;
#endif // #include guard

62
reactos/lib/3rdparty/stlport/test/eh/sgi_mipspro.mak vendored Normal file
View file

@ -0,0 +1,62 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
SHELL=/bin/sh
# srcdir = .
# VPATH = .
STL_INCL=-I${PWD}/../../stlport/
# STL_INCL= -DEH_NO_SGI_STL
AUX_LIST=TestClass.o main.o nc_alloc.o random_number.o
TEST_LIST=test_algo.o \
test_algobase.o test_list.o test_slist.o \
test_bit_vector.o test_vector.o \
test_deque.o test_set.o test_map.o \
test_hash_map.o test_hash_set.o test_rope.o \
test_string.o test_bitset.o test_valarray.o
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST)
EXECS = $(LIST:%.o=%)
TESTS = $(LIST:%.o=%.out)
TEST_EXE = eh_test
TEST = eh_test.out
CC = CC
CXX = $(CC)
# CXXFLAGS = -J 4 -ansi -LANG:std -I. ${STL_INCL} ${DEBUG_FLAGS} -I. -D_STLP_NO_OWN_IOSTREAMS -D_STLP_NO_NEW_IOSTREAMS
CXXFLAGS = -J 4 -ansi -LANG:std -I. ${STL_INCL} ${DEBUG_FLAGS} -I.
LIBS = -L../../lib -lstlport_mipspro -lm
LIBSTDCXX =
.SUFFIXES: .cpp .i .o .out .res
check: $(TEST)
$(TEST) : $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) $(LIBS) -o $(TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" ./$(TEST_EXE) -s 100
.cpp.o:
$(CXX) $(CXXFLAGS) $< -c -o $@
.cpp.i:
$(CXX) $(CXXFLAGS) $< -E > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $*.cpp -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBS) -o $*
./$* -q
-rm -f $*
clean:
-rm -fr ${TEST_EXE} *.o *.rpo *.obj *.out core *~ Templates.DB SunWS_cache cxx_repository

69
reactos/lib/3rdparty/stlport/test/eh/sunpro-64.mak vendored Normal file
View file

@ -0,0 +1,69 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
SHELL=/bin/sh
# point this to proper location
STL_INCL= -I${PWD}/../../stlport
# STL_INCL= -DEH_NO_SGI_STL
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = eh_test
TEST = eh_test.out
CC = CC
CXX = $(CC)
CXXFLAGS = ${STL_INCL} -xarch=v9 -library=no%Cstd -features=rtti -DEH_VECTOR_OPERATOR_NEW -DEH_DELETE_HAS_THROW_SPEC -xildoff -g -D_REENTRANT -DNO_FAST_ALLOCATOR
# This is to test with native STL
# CXXFLAGS = +w2 -xildoff -D_STLP_USE_NEWALLOC -DEH_NO_SGI_STL -DEH_NEW_HEADERS -DEH_VECTOR_OPERATOR_NEW -DEH_DELETE_HAS_THROW_SPEC
LIBS = -lm
LIBSTDCXX =
LIBSTLPORT = -library=no%Cstd -L../../lib -lstlport_sunpro64
check: $(TEST)
$(TEST) : $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) ${LIBSTLPORT} $(LIBS) -o $(TEST_EXE)
LD_LIBRARY_PATH="../../lib;${LD_LIBRARY_PATH}" ./$(TEST_EXE) -s 100
SUFFIXES: .cpp.o.out.res
%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBS) -o $*
./$* -q
-rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o *.rpo *.obj *.out core *~ Templates.DB SunWS_cache

71
reactos/lib/3rdparty/stlport/test/eh/sunpro.mak vendored Normal file
View file

@ -0,0 +1,71 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
SHELL=/bin/sh
# point this to proper location
STL_INCL= -I${PWD}/../../stlport
# STL_INCL= -DEH_NO_SGI_STL
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = eh_test
TEST = eh_test.out
CC = CC
CXX = $(CC)
# CXXFLAGS = ${STL_INCL} -library=no%Cstd -qoption ccfe -instlib=../../lib/libstlport_sunpro.so -features=rtti -DEH_VECTOR_OPERATOR_NEW -DEH_DELETE_HAS_THROW_SPEC
CXXFLAGS = ${STL_INCL} -library=no%Cstd -features=rtti -DEH_VECTOR_OPERATOR_NEW -DEH_DELETE_HAS_THROW_SPEC
# This is to test with native STL
# CXXFLAGS = +w2 -xildoff -D_STLP_USE_NEWALLOC -DEH_NO_SGI_STL -DEH_NEW_HEADERS -DEH_VECTOR_OPERATOR_NEW -DEH_DELETE_HAS_THROW_SPEC
LIBS = -lm
LIBSTDCXX =
LIBSTLPORT = -library=no%Cstd -L../../lib -lstlport_sunpro
check: $(TEST)
$(TEST) : $(OBJECTS)
$(CXX) $(CXXFLAGS) $(OBJECTS) ${LIBSTLPORT} $(LIBS) -o $(TEST_EXE)
LD_LIBRARY_PATH="../../lib;${LD_LIBRARY_PATH}" ./$(TEST_EXE) -s 100
SUFFIXES: .cpp.o.out.res
%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBS) ${LIBSTLPORT} -o $*
LD_LIBRARY_PATH="../../lib;${LD_LIBRARY_PATH}" ./$*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o *.rpo *.obj *.out core *~ Templates.DB SunWS_cache

76
reactos/lib/3rdparty/stlport/test/eh/sunpro42.mak vendored Normal file
View file

@ -0,0 +1,76 @@
# ;;; -*- Mode:makefile;-*-
# Generated automatically from Makefile.in by configure.
# This requires GNU make.
# SHELL=/bin/sh
# srcdir = .
# VPATH = .
SHELL=/bin/sh
# point this to proper location
STL_INCL= -I../../stlport
# STL_INCL= -DEH_NO_SGI_STL
AUX_LIST=TestClass.cpp main.cpp nc_alloc.cpp random_number.cpp
TEST_LIST=test_algo.cpp \
test_algobase.cpp test_list.cpp test_slist.cpp \
test_bit_vector.cpp test_vector.cpp \
test_deque.cpp test_set.cpp test_map.cpp \
test_hash_map.cpp test_hash_set.cpp test_rope.cpp \
test_string.cpp test_bitset.cpp test_valarray.cpp
LIST=${AUX_LIST} ${TEST_LIST}
OBJECTS = $(LIST:%.cpp=%.o) $(STAT_MODULE)
EXECS = $(LIST:%.cpp=%)
TESTS = $(LIST:%.cpp=%.out)
TEST_EXE = eh_test
TEST = eh_test.out
CC = CC
CXX = $(CC)
CXXFLAGS = $(ARCHF) +w2 -mt -features=rtti ${STL_INCL}
# CXXFLAGS = +w2 ${STL_INCL}
LIBS = -lm
LIBSTLPORT = -L../../lib -lstlport_sunpro42
check: $(TEST)
$(TEST) : $(OBJECTS)
echo 'Info: For CC 4.x, warnings from ld in the form "symbol `XXX' has differing sizes" are normal.'
$(CXX) $(CXXFLAGS) $(OBJECTS) ${LIBSTLPORT} $(LIBS) -o $(TEST_EXE)
LD_LIBRARY_PATH="../../lib:$(LD_LIBRARY_PATH)" ./$(TEST_EXE) -s 100
SUFFIXES: .cpp.o.out.res
%.o : %.cpp
$(CXX) $(CXXFLAGS) $< -c -o $@
%.i : %.cpp
$(CXX) $(CXXFLAGS) $< -E -H > $@
%.out: %.cpp
$(CXX) $(CXXFLAGS) $< -c -USINGLE -DMAIN -g -o $*.o
$(CXX) $(CXXFLAGS) $*.o $(LIBSTLPORT) $(LIBS) -o $*
./$* -q
-rm -f $*
%.s: %.cpp
$(CXX) $(CXXFLAGS) -O4 -S -pto $< -o $@
clean:
-rm -fr ${TEST_EXE} *.o *.rpo *.obj *.out core *~ Templates.DB SunWS_cache

42
reactos/lib/3rdparty/stlport/test/eh/test.cpp vendored Normal file
View file

@ -0,0 +1,42 @@
#include <iostream>
#include <set>
#include <vector>
template<class T>
inline void printElements(const T& coll, const char* msg = "")
{
typename T::const_iterator it;
std::cout << msg;
for(it = coll.begin(); it != coll.end(); ++it) {
std::cout << *it << ' ';
}
std::cout << std:: endl;
}
int main(int /* argc */, char** /* argv */)
{
std::set<int> set1, set2;
std::vector<int> aVector;
aVector.push_back(1);
aVector.push_back(1);
set1.insert(aVector.begin(), aVector.end());
set2.insert(1);
set2.insert(1);
printElements(aVector, "vector: ");
printElements(set1, "set1 : ");
printElements(set2, "set2 : ");
return 0;
}
# if 0
# include <iostream>
main()
{
// std::stringstream tstr;
std::cout<<"hello world\n";
}
# endif

261
reactos/lib/3rdparty/stlport/test/eh/test_algo.cpp vendored Normal file
View file

@ -0,0 +1,261 @@
/***********************************************************************************
test_algo.cpp
* Copyright (c) 1997
* 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 makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
***********************************************************************************/
#include "Tests.h"
#include "LeakCheck.h"
#include "SortClass.h"
#if defined (EH_NEW_HEADERS)
# include <algorithm>
# include <cassert>
#else
# include <algo.h>
# include <assert.h>
#endif
#if defined (EH_NEW_IOSTREAMS)
# include <iostream>
#else
# include <iostream.h>
#endif
//
// SortBuffer -- a buffer of SortClass objects that can be used to test sorting.
//
struct SortBuffer
{
enum { kBufferSize = 100 };
SortClass* begin() { return items; }
const SortClass* begin() const { return items; }
SortClass* end() { return items + kBufferSize; }
const SortClass* end() const { return items + kBufferSize; }
// Sort each half of the buffer and reset the address of each element
// so that merge() can be tested for stability.
void PrepareMerge()
{
EH_STD::sort( begin(), begin() + ( end() - begin() )/2 );
EH_STD::sort( begin() + ( end() - begin() )/2, end() );
for ( SortClass* p = begin(); p != end(); p++ )
p->ResetAddress();
}
SortBuffer()
{
PrepareMerge();
}
SortBuffer( const SortBuffer& rhs )
{
SortClass* q = begin();
for ( const SortClass* p = rhs.begin() ; p != rhs.end(); p++,q++ )
*q = *p;
}
private:
SortClass items[kBufferSize];
};
//
// less_by_reference -- a functor for comparing objects against a
// constant value.
//
template <class T>
struct less_by_reference
{
less_by_reference( const T& arg ) : fArg(arg) {}
bool operator()( const T& x ) const { return x < fArg; }
private:
const T& fArg;
};
struct test_stable_partition
{
test_stable_partition( const SortBuffer& buf )
: orig( buf ), partitionPoint(SortClass::kRange / 2) {
gTestController.SetCurrentTestName("stable_partition()");
}
void operator()( SortBuffer& buf ) const
{
less_by_reference<SortClass> throw_cmp( partitionPoint );
SortClass* d = EH_STD::stable_partition( buf.begin(), buf.end(), throw_cmp );
// Suppress warning about unused variable.
d;
// If we get here no exception occurred during the operation.
// Stop any potential failures that might occur during verification.
gTestController.CancelFailureCountdown();
// Prepare an array of counts of the occurrence of each value in
// the legal range.
unsigned counts[SortClass::kRange];
EH_STD::fill_n( counts, (int)SortClass::kRange, 0 );
for ( const SortClass *q = orig.begin(); q != orig.end(); q++ )
counts[ q->value() ]++;
less_by_reference<TestClass> cmp( partitionPoint );
for ( const SortClass* p = buf.begin(); p != buf.end(); p++ )
{
// Check that adjacent items with the same value haven't been
// reordered. This could be a more thorough test.
if ( p != buf.begin() && p->value() == p[-1].value() ) {
EH_ASSERT( p->GetAddress() > p[-1].GetAddress() );
}
// Check that the partitioning worked.
EH_ASSERT( (p < d) == cmp( *p ) );
// Decrement the appropriate count for each value.
counts[ p->value() ]--;
}
// Check that the values were only rearranged, and none were lost.
for ( unsigned j = 0; j < SortClass::kRange; j++ ) {
EH_ASSERT( counts[j] == 0 );
}
}
private:
const SortBuffer& orig;
SortClass partitionPoint;
};
void assert_sorted_version( const SortBuffer& orig, const SortBuffer& buf );
/*===================================================================================
assert_sorted_version
EFFECTS: Asserts that buf is a stable-sorted version of orig.
====================================================================================*/
void assert_sorted_version( const SortBuffer& orig, const SortBuffer& buf )
{
// Stop any potential failures that might occur during verification.
gTestController.CancelFailureCountdown();
// Prepare an array of counts of the occurrence of each value in
// the legal range.
unsigned counts[SortClass::kRange];
EH_STD::fill_n( counts, (int)SortClass::kRange, 0 );
for ( const SortClass *q = orig.begin(); q != orig.end(); q++ )
counts[ q->value() ]++;
// Check that each element is greater than the previous one, or if they are
// equal, that their order has been preserved.
for ( const SortClass* p = buf.begin(); p != buf.end(); p++ )
{
if ( p != buf.begin() ) {
EH_ASSERT( p->value() > p[-1].value()
|| p->value() == p[-1].value() && p->GetAddress() > p[-1].GetAddress() );
}
// Decrement the appropriate count for each value.
counts[ p->value() ]--;
}
// Check that the values were only rearranged, and none were lost.
for ( unsigned j = 0; j < SortClass::kRange; j++ ) {
EH_ASSERT( counts[j] == 0 );
}
}
//
// The test operators
//
struct test_stable_sort_1
{
test_stable_sort_1( const SortBuffer& buf )
: orig( buf ) {
gTestController.SetCurrentTestName("stable_sort() #1");
}
void operator()( SortBuffer& buf ) const
{
EH_STD::stable_sort( buf.begin(), buf.end() );
assert_sorted_version( orig, buf );
}
private:
const SortBuffer& orig;
};
struct test_stable_sort_2
{
test_stable_sort_2( const SortBuffer& buf )
: orig( buf ) {
gTestController.SetCurrentTestName("stable_sort() #2");
}
void operator()( SortBuffer& buf ) const
{
EH_STD::stable_sort( buf.begin(), buf.end(), EH_STD::less<SortClass>() );
assert_sorted_version( orig, buf );
}
private:
const SortBuffer& orig;
};
struct test_inplace_merge_1
{
test_inplace_merge_1( SortBuffer& buf )
: orig( buf ) {
gTestController.SetCurrentTestName("inplace_merge #1()");
}
void operator()( SortBuffer& buf ) const
{
EH_STD::inplace_merge( buf.begin(), buf.begin() + ( buf.end() - buf.begin() )/2, buf.end() );
assert_sorted_version( orig, buf );
}
private:
const SortBuffer& orig;
};
struct test_inplace_merge_2
{
test_inplace_merge_2( SortBuffer& buf )
: orig( buf ) {
gTestController.SetCurrentTestName("inplace_merge() #2");
}
void operator()( SortBuffer& buf ) const
{
EH_STD::inplace_merge( buf.begin(), buf.begin() + ( buf.end() - buf.begin() )/2, buf.end(),
EH_STD::less<SortClass>() );
assert_sorted_version( orig, buf );
}
private:
const SortBuffer& orig;
};
void test_algo()
{
SortBuffer mergeBuf;
mergeBuf.PrepareMerge();
EH_STD::cerr<<"EH test : testing algo.h"<<EH_STD::endl;
WeakCheck( mergeBuf, test_inplace_merge_1( mergeBuf ) );
WeakCheck( mergeBuf, test_inplace_merge_2( mergeBuf ) );
SortBuffer buf;
WeakCheck( buf, test_stable_sort_1( buf ) );
WeakCheck( buf, test_stable_sort_2( buf ) );
WeakCheck( buf, test_stable_partition( buf ) );
}

Some files were not shown because too many files have changed in this diff Show more