From: hama <hama@siduction.net>
Date: Mon, 29 Dec 2014 23:23:57 +0000 (+0100)
Subject: Refactoring, ported to WIN32
X-Git-Url: https://gitweb.hamatoma.de/?a=commitdiff_plain;h=1bef68af861eee75cbbe93075ff099741cd53715;p=crepublib

Refactoring, ported to WIN32
---

diff --git a/.gitignore b/.gitignore
index 23f8dcb..028bb5e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,6 @@
 *.o
 dirtool
 alltest
+.hg/
+Debug/
+.settings/
diff --git a/base/ReByteBuffer.cpp b/base/ReByteBuffer.cpp
index ee44320..8168d5c 100644
--- a/base/ReByteBuffer.cpp
+++ b/base/ReByteBuffer.cpp
@@ -5,7 +5,14 @@
  *      Author: wk
  */
 
-#include "rebase.hpp"
+#include "base/rebase.hpp"
+
+#ifdef __linux__
+extern void* memcpy (void* dest, const void* src, size_t n);
+extern void* memmove (void* dest, const void* src, size_t n);
+extern int memcmp (const void* s1, const void* s2, size_t n);
+extern int snprintf (char* s, size_t maxlen, const char* format, ...);
+#endif
 
 /** @brief Constructor.
  *
@@ -18,33 +25,49 @@ ReByteBuffer::ReByteBuffer(size_t delta)
 	// m_primaryBuffer
 	m_buffer(m_primaryBuffer),
 	m_length(0),
-	m_size(sizeof m_primaryBuffer - 1)
+	m_capacity(sizeof m_primaryBuffer - 1)
 {
 	m_buffer[0] = '\0';
 }
-/** @brief Copy constructor.
+/** @brief Constructor.
  *
  * @param source	The instance to copy (C string).
  */
-ReByteBuffer::ReByteBuffer(const char* source)
-	:
-	m_delta(256),
+ReByteBuffer::ReByteBuffer(const char* source) :
+	m_delta(PRIMARY_BUFFER_SIZE),
 	// m_primaryBuffer
 	m_buffer(m_primaryBuffer),
 	m_length(0),
-	m_size(sizeof m_primaryBuffer)
+	m_capacity(sizeof m_primaryBuffer)
 {
 	m_buffer[0] = '\0';
 	append(source);
 }
+
+/** @brief Constructor.
+ *
+ * @param source			The byte sequence to copy
+ * @param sourceLength	length of <code>source</code>
+ */
+ReByteBuffer::ReByteBuffer(const Byte* source, size_t sourceLength) :
+	m_delta(PRIMARY_BUFFER_SIZE),
+	// m_primaryBuffer
+	m_buffer(m_primaryBuffer),
+	m_length(0),
+	m_capacity(sizeof m_primaryBuffer)
+{
+	m_buffer[0] = '\0';
+	append(source, sourceLength);
+}
+
 /** @brief Destructor.
  *
  */
 ReByteBuffer::~ReByteBuffer(){
 	if (m_buffer != m_primaryBuffer)
-		delete m_buffer;
+		delete[] m_buffer;
 	m_buffer = NULL;
-	m_size = 0;
+	m_capacity = 0;
 	m_length = 0;
 }
 /** @brief Copy constructor.
@@ -53,13 +76,13 @@ ReByteBuffer::~ReByteBuffer(){
  */
 ReByteBuffer::ReByteBuffer(const ReByteBuffer& source)
 	:
-	m_delta(source.getDelta()),
+	m_delta(source.delta()),
 	// m_primaryBuffer
 	m_buffer(m_primaryBuffer),
 	m_length(0),
-	m_size(sizeof m_primaryBuffer)
+	m_capacity(sizeof m_primaryBuffer)
 {
-	append(source.getBuffer(), source.getLength());
+	append(source.buffer(), source.length());
 }
 
 /** @brief The assignment operator.
@@ -69,8 +92,8 @@ ReByteBuffer::ReByteBuffer(const ReByteBuffer& source)
  * @return The instance itself.
  */
 ReByteBuffer& ReByteBuffer::operator =(const ReByteBuffer& source){
-	m_delta = source.getDelta();
-	set(source.getBuffer(), source.getLength());
+	m_delta = source.delta();
+	set(source.buffer(), source.length());
 	return *this;
 }
 
@@ -92,7 +115,7 @@ ReByteBuffer&  ReByteBuffer::append(const Byte* source, size_t length){
 	if (length == (size_t) -1)
 		length = strlen(source);
 	ensureSize(m_length + length);
-	memcpy(m_buffer + m_length, source, length);
+	memcpy((void*)(m_buffer + m_length), source, length);
 	m_length += length;
 	m_buffer[m_length] = '\0';
 	return *this;
@@ -113,7 +136,7 @@ ReByteBuffer&  ReByteBuffer::append(const Byte* source, size_t length){
  * @return *this (for chaining).
  */
 ReByteBuffer&  ReByteBuffer::appendInt(int number, const char* format){
-	char buffer [256];
+	char buffer [128];
 
 	snprintf(buffer, sizeof buffer, format, number);
 	size_t length = strlen(buffer);
@@ -139,7 +162,7 @@ ReByteBuffer&  ReByteBuffer::appendInt(int number, const char* format){
  * @return *this (for chaining).
  */
 ReByteBuffer& ReByteBuffer::append(ReByteBuffer& source){
-	return append(source.getBuffer(), source.getLength());
+	return append(source.buffer(), source.length());
 }
 
 /** Converts a subsequence into an integer.
@@ -174,6 +197,46 @@ int ReByteBuffer::atoi(size_t start, int end) const{
 	}
 	return rc;
 }
+
+/**
+ * Counts the occurrencies of a given byte sequence.
+ *
+ * @param toCount				the byte sequence to count
+ * @param lengthOfToCount	-1: length is <code>strlen(toCount)</count><br>
+ * 								otherwise: length of <code>toCount</count>.
+ */
+int ReByteBuffer::count(const char* toCount, size_t lengthToCount){
+	int rc = 0;
+	size_t start = 0;
+	if (lengthToCount == (size_t)-1)
+		lengthToCount = strlen(toCount);
+	while( (start = indexOf(toCount, lengthToCount, start)) != (size_t) -1){
+		rc++;
+		start += lengthToCount;
+	}
+	return rc;
+}
+
+/**
+ * Tests whether the buffer ends with a given a byte sequence.
+ *
+ * @param tail			the byte sequence to test
+ * @param tailLength -1: <code>strlen(tail)</code><br>
+ * 						otherwise: the length of <code>tail</code>
+ * @param ignoreCase	<code>true</code>: the comparison is case insensitive<br>
+ * 						<code>false</code>: the comparison is case sensitive<br>
+ * @return				<code>true</code>: the buffer ends with <code>tail</code><br>
+ * 						<code>false</code>: otherwise
+ */
+bool ReByteBuffer::endsWith(const Byte* tail, size_t tailLength,
+			bool ignoreCase) const {
+	bool rc;
+	if (tailLength == (size_t)-1)
+		tailLength = strlen(tail);
+	rc = indexOf(tail, tailLength, m_length - tailLength, m_length, ignoreCase) >= 0;
+	return rc;
+}
+
 /** @brief Ensures that there is enough space.
  *
  * <p>If not it will be allocated and the old value will be copied.
@@ -185,20 +248,24 @@ int ReByteBuffer::atoi(size_t start, int end) const{
  * @param size	At the end the size will be at least this value.
  */
 void ReByteBuffer::ensureSize(size_t size){
-	if (m_size < size){
-		if (size - m_size < m_delta)
-			size = m_size + m_delta;
+	if (m_capacity < size){
+		if (size - m_capacity < m_delta)
+			size = m_capacity + m_delta;
 			// Think for the ending '\0':
 		Byte* buffer = new Byte[size + 1];
 		assert(buffer != NULL);
-		memcpy(buffer, m_buffer, m_length);
+		if (m_length > 0)
+			memcpy(buffer, m_buffer, m_length);
+		buffer[m_length] = '\0';
 		if (m_buffer != m_primaryBuffer)
 			delete m_buffer;
 		m_buffer = buffer;
-		m_size = size;
+		m_capacity = size;
 	}
 }
-/** @brief Search for a byte sequence in the internal buffer.
+/** @brief Searches for a byte sequence in the internal buffer.
+ *
+ * Finds the first occurrence of a byte sequence in a given range.
  *
  * <pre><code>Example:
  * ReByteBuffer buf;
@@ -209,20 +276,73 @@ void ReByteBuffer::ensureSize(size_t size){
  * @param toFind		The sequence to find.
  * @param toFindLength	Length of <code>toFind</code>.
  * 						If -1 the <code>strlen(toFind)</code> will be taken.
- * @param start			The index of the internal buffer where the search starts.
+ * @param start		The search respects the indices in the range [start, end[
+ * @param end			-1: no upper limit to search<br>
+ * 						otherwise: the first index above the search range
+ * @param ignoreCase	<code>true</code>: case insensitive search<br>
+ * 						<code>true</code>: case sensitive search
+ * @return 	-1: The sequence could not be found.
+ * 			Otherwise: The index of <code>toFind</code> in the internal buffer.
+ */
+int ReByteBuffer::indexOf(const Byte* toFind, size_t toFindLength, int start,
+		int end, bool ignoreCase) const{
+	if (toFindLength == (size_t) -1)
+		toFindLength = strlen(toFind);
+	int rc = -1;
+	if (end < 0 || end > (int) m_length)
+		end = m_length;
+	if (start >= 0 && start <= int(m_length - toFindLength)
+				&& end >= (int) toFindLength && end <= (int) m_length){
+		while(rc < 0 && start <= int(end - toFindLength)){
+			if (ignoreCase ? strncasecmp(toFind, m_buffer + start, toFindLength) == 0
+						: memcmp(toFind, m_buffer + start, toFindLength) == 0)
+				rc = start;
+			else
+				start++;
+		}
+	}
+	return rc;
+}
+/** @brief Searches revers for a byte sequence in the internal buffer.
+ *
+ * Finds the last occurrence of a byte sequence in a given range.
  *
+ * <pre><code>Example:
+ * ReByteBuffer buf;
+ * buf.set("12abc123", 8);
+ * assert(5 == buf.rindexOf("12", -1, 3));
+ * </code></pre>
+ *
+ * @param toFind		The sequence to find.
+ * @param toFindLength	Length of <code>toFind</code>.
+ * 						If -1 the <code>strlen(toFind)</code> will be taken.
+ * @param start		The search respects the indices in the range [start, end[
+ * @param end			-1: no upper limit to search<br>
+ * 						otherwise: the first index above the search range
+ * @param ignoreCase	<code>true</code>: case insensitive search<br>
+ * 						<code>true</code>: case sensitive search
  * @return 	-1: The sequence could not be found.
  * 			Otherwise: The index of <code>toFind</code> in the internal buffer.
  */
-int ReByteBuffer::indexOf(const Byte* toFind, size_t toFindLength, int start) const{
+int ReByteBuffer::rindexOf(const Byte* toFind, size_t toFindLength, int start,
+		int end, bool ignoreCase) const{
 	if (toFindLength == (size_t) -1)
 		toFindLength = strlen(toFind);
 	int rc = -1;
-	while(rc < 0 && start <= int(m_length - toFindLength)){
-		if (memcmp(toFind, m_buffer + start, toFindLength) == 0)
-			rc = start;
-		else
-			start++;
+	if (end < 0 || end > (int) m_length)
+		end = m_length;
+	if (start >= 0 && start <= int (m_length - toFindLength)
+				&& end >= (int) toFindLength && end <= (int) m_length){
+		int current = end - toFindLength;
+		while(current >= start){
+			if (ignoreCase ? strncasecmp(toFind, m_buffer + current, toFindLength) != 0
+						: memcmp(toFind, m_buffer + current, toFindLength) != 0)
+				current--;
+			else{
+				rc = current;
+				break;
+			}
+		}
 	}
 	return rc;
 }
@@ -361,3 +481,21 @@ bool ReByteBuffer::splice(size_t ix, size_t replacedLength,
 	}
 	return rc;
 }
+/**
+ * Tests whether the buffer starts with a given a byte sequence.
+ *
+ * @param head			the byte sequence to test
+ * @param headLength -1: <code>strlen(tail)</code><br>
+ * 						otherwise: the length of <code>tail</code>
+ * @param ignoreCase	<code>true</code>: the comparison is case insensitive<br>
+ * 						<code>false</code>: the comparison is case sensitive<br>
+ * @return				<code>true</code>: the buffer starts with <code>head</code><br>
+ * 						<code>false</code>: otherwise
+ */
+bool ReByteBuffer::startsWith(const Byte* head, size_t headLength, const bool ignoreCase) const{
+	bool rc;
+	if (headLength == (size_t) -1)
+		headLength = strlen(head);
+	rc = indexOf(head, headLength, 0, headLength, ignoreCase) == 0;
+	return rc;
+}
diff --git a/base/ReByteBuffer.hpp b/base/ReByteBuffer.hpp
index 5fe2949..883bfd0 100644
--- a/base/ReByteBuffer.hpp
+++ b/base/ReByteBuffer.hpp
@@ -8,6 +8,8 @@
 #ifndef REBYTEBUFFER_H_
 #define REBYTEBUFFER_H_
 
+#define PRIMARY_BUFFER_SIZE 512
+
 /** @brief An efficient dynamic memory buffer.
  *
  * Implements a very efficient dynamic byte sequence.
@@ -33,8 +35,9 @@ class ReByteBuffer {
 public:
 	typedef char Byte;
 public:
-	ReByteBuffer(size_t delta = 512);
+	ReByteBuffer(size_t delta = PRIMARY_BUFFER_SIZE);
 	ReByteBuffer(const char* source);
+	ReByteBuffer(const Byte* source, size_t sourceLength);
 	virtual ~ReByteBuffer();
 	ReByteBuffer(const ReByteBuffer& source);
 	ReByteBuffer& operator =(const ReByteBuffer& source);
@@ -50,30 +53,33 @@ public:
 		return index >= m_length ? 0 : m_buffer[index];
 	}
 	int atoi(size_t start = 0, int end = -1) const;
+	bool endsWith(const Byte* tail, size_t tailLength = -1,
+				bool ignoreCase = false) const;
 	void ensureSize(size_t size);
 	/** @brief Returns the buffer.
 	 * @return The internal used buffer.
 	 */
-	inline Byte* getBuffer() const{
+	inline Byte* buffer() const{
 		return m_buffer;
 	}
 	/**@brief Returns the minimum allocation unit.
 	 * @return The minimum of bytes to allocate.
 	 */
-	inline size_t getDelta() const{
+	inline size_t delta() const{
 		return m_delta;
 	}
+	int count(const char* toCount, size_t lengthToCount = -1);
 	/**@brief Returns the length of the buffer (the count of used bytes).
 	 * @return The count of the allocated bytes in the internal buffer.
 	 */
-	inline size_t getLength() const{
+	inline size_t length() const{
 		return m_length;
 	}
 	/**@brief Returns the current size of the internal buffer.
 	 * @return The  current size of the internal buffer.
 	 */
-	inline size_t getSize() const{
-		return m_size;
+	inline size_t capacity() const{
+		return m_capacity;
 	}
 	/** @brief Finds the index of the first occurrence of a given byte.
 	 * @param toFind	This byte will be searched.
@@ -86,7 +92,8 @@ public:
 				return start - 1;
 		return -1;
 	}
-	int indexOf(const Byte* toFind, size_t toFindLength, int start = 0) const;
+	int indexOf(const Byte* toFind, size_t toFindLength,
+				int start = 0, int end = -1, bool ignoreCase = false) const;
 	/** @brief Inserts a byte sequence.
 	 * @param ix	The position in the internal buffer for the insertion.
 	 * @param source			The sequence to insert.
@@ -123,6 +130,8 @@ public:
 				return start + 1;
 		return -1;
 	}
+	int rindexOf(const Byte* toFind, size_t toFindLength,
+				int start = 0, int end = -1, bool ignoreCase = false) const;
 	/** @brief Sets the content of the buffer by copying a byte sequence.
 	 * @param source	The byte sequence to copy.
 	 * @param length	The length of <code>source</code>.
@@ -135,6 +144,9 @@ public:
 	ReByteBuffer& setLengthAndFill(size_t length, Byte filler = 0);
 
 	bool splice(size_t ix, size_t replacedLength, const Byte* source, size_t length);
+	bool startsWith(const Byte* head, size_t headLength = -1,
+				const bool ignoreCase = false) const;
+
 	/** @brief Returns the buffer content as C string.
 	 * This is exactly the same result as from <code>getBuffer()</code>.
 	 * @return The internal used buffer.
@@ -146,13 +158,13 @@ protected:
 		// The minimum difference between old and new size after a new allocation.
 	size_t		m_delta;
 		//@ If the needed space is small enough this buffer will be used.
-	char 		m_primaryBuffer[512];
+	char 		m_primaryBuffer[PRIMARY_BUFFER_SIZE];
 		//@ The internal buffer. Points to <code>m_primaryBuffer</code> if the space is small enough.
 	char* 		m_buffer;
 		//@ The used bytes in <code>m_buffer</code>.
 	size_t		m_length;
 		//@ The size of <code>m_buffer</code>.
-	size_t		m_size;
+	size_t		m_capacity;
 };
 
 #endif /* REBYTEBUFFER_H_ */
diff --git a/base/ReCString.cpp b/base/ReCString.cpp
index 95b0a2b..a5252dd 100644
--- a/base/ReCString.cpp
+++ b/base/ReCString.cpp
@@ -5,7 +5,7 @@
  *      Author: wk
  */
 
-#include "../base/restring.hpp"
+#include "base/rebase.hpp"
 
 /** @brief Replaces a substring by another.
  *
@@ -34,7 +34,8 @@ void replaceSubstring(char* start, size_t bufferSize, size_t lengthReplaced,
 		if (lengthTail + lengthNew - lengthReplaced > bufferSize)
 			globalLogger()->sayF(LOG_ERROR|GRAN_USER|CAT_LIB, LC_CSTRING_REPLACE_1,
 					i18n("+++ The name size exceeds: $1 / $2\n"))
-					.arg(int(lengthTail + lengthNew - lengthReplaced)).arg((int) bufferSize)
+					.arg(int(lengthTail + lengthNew - lengthReplaced))
+					.arg((int) bufferSize)
 					.end();
 		else {
 			memmove(start + lengthNew, tail, lengthTail);
diff --git a/base/ReConfigFile.cpp b/base/ReConfigFile.cpp
index 25b1210..9f0db53 100644
--- a/base/ReConfigFile.cpp
+++ b/base/ReConfigFile.cpp
@@ -4,7 +4,7 @@
  * @brief Configuration file handling for *.ini files.
  */
 
-#include "rebase.hpp"
+#include "base/rebase.hpp"
 
 const char* ReConfigFile::m_trueValues = i18nm(";true;t;1;j;ja;yes;");
 const char* ReConfigFile::m_falseValues = i18nm(";false;f;0;n;nein;no;");
@@ -109,7 +109,7 @@ void ReConfigFile::getString(const char* key, ReByteBuffer& buffer, const char*
 bool ReConfigFile::getBool(const char* key, bool defaultVal){
 	ReByteBuffer value;
 	getString(key, value, NULL);
-	int rc = defaultVal;
+	bool rc = defaultVal;
 	if (ReStringUtils::isInList(value.str(), i18n(m_falseValues)))
 		rc = false;
 	else if (ReStringUtils::isInList(value.str(), i18n(m_trueValues)))
@@ -121,46 +121,3 @@ bool ReConfigFile::getBool(const char* key, bool defaultVal){
 			.arg(i18n(m_trueValues)).end();
 	return rc;
 }
-
-#if defined RE_TESTUNIT
-class TestReConfigFile : public ReTestUnit {
-	typedef ReHashList::Byte Byte;
-public:
-	TestReConfigFile() : ReTestUnit("ReConfigFile", __FILE__){
-		run();
-	}
-private:
-	void run(){
-		testBasic();
-	}
-	void testBasic(){
-		createTestDir();
-		ReByteBuffer fn;
-		fn.append(getTestDir(), -1).append("reconfigfile.cfg", -1);
-		createFile(fn.str(), "#x.int=a\nx.int=1\nx.bool=true\nx.str=abc\nx.bool2=0\nstring=abc\n");
-		ReConfigFile config(fn.str());
-		checkT(config.isValid());
-		checkEqu(1, config.getInteger("x.int", 2));
-		checkEqu(2, config.getInteger("x.int2", 2));
-
-		checkT(config.getBool("x.bool", true));
-		checkT(config.getBool("x.bool", false));
-		checkT(config.getBool("y.bool", true));
-		checkF(config.getBool("y.bool", false));
-
-		checkF(config.getBool("x.bool2", true));
-		checkF(config.getBool("x.bool2", false));
-
-		ReByteBuffer buffer;
-		config.getString("string", buffer, "x");
-		checkEqu("abc", buffer.str());
-		config.getString("string1", buffer, "x");
-		checkEqu("x", buffer.str());
-	}
-};
-extern void testReConfigFile(void);
-
-void testReConfigFile(void){
-	TestReConfigFile unit;
-}
-#endif /*RE_TESTUNIT*/
diff --git a/base/ReDirectory.cpp b/base/ReDirectory.cpp
index 73c1222..d8fc298 100644
--- a/base/ReDirectory.cpp
+++ b/base/ReDirectory.cpp
@@ -5,71 +5,95 @@
  *      Author: wk
  */
 
-#include "rebase.hpp"
-
+#include "base/rebase.hpp"
 
 /** @brief Constructor.
  */
-ReDirectory::ReDirectory()
-	:
+ReDirectory::ReDirectory() :
 	m_valid(false),
-	m_dir(NULL),
 	m_path(),
+   m_pattern(),
+#if defined __linux__
+	m_dir(NULL),
 	m_entry(NULL),
-	m_pattern(),
-	m_isRegExpr(false),
-	m_regExprFlags(0)
+	// m_regExpr
+	m_regExprFlags(0),
+	m_regExprIsInitialized(false),
+	m_isRegExpr(false)
+#elif defined __WIN32__
+    m_handle(0)
+    //m_data()
+#endif
 {
 }
 /** @brief Constructor.
  *
  * @param path		The path of the directory.
  */
-ReDirectory::ReDirectory(const char* path)
-	:
+ReDirectory::ReDirectory(const char* path) :
 	m_valid(false),
-	m_dir(NULL),
 	m_path(),
-	m_entry(NULL),
 	m_pattern(),
-	m_isRegExpr(false),
-	m_regExprFlags(0)
+#if defined __linux__
+	m_dir(NULL),
+	m_entry(NULL),
+	// m_regExpr
+	m_regExprFlags(0),
+	m_regExprIsInitialized(false),
+	m_isRegExpr(false)
+#elif defined __WIN32__
+	 m_handle(0)
+	 //m_data()
+#endif
 {
+#if defined __linux__
+	memset(&m_regExpr, 0, sizeof m_regExpr);
+#endif
 	setDir(path);
 }
 /** @brief Destructor.
  */
 ReDirectory::~ReDirectory(){
+#if defined __linux__
 	if (m_dir != NULL){
 		closedir(m_dir);
 		m_dir = NULL;
 		m_valid = false;
 	}
+	if (m_regExprIsInitialized)
+		regfree(&m_regExpr);
+#elif defined __WIN32__
+#endif
 }
 /** @brief Sets the directory.
  *
  * @param path		The name of the directory.
  */
 void ReDirectory::setDir(const char* path){
+	m_path.set(path, -1);
+#if defined __linux__
 	if (m_dir != NULL){
 		closedir(m_dir);
 		m_dir = NULL;
 	}
 	m_entry = NULL;
-	m_path.set(path, -1);
 	m_dir = opendir(path);
 	m_valid = m_dir != NULL;
 	if (m_valid){
-		if (m_path.at(m_path.getLength() - 1) != ReStringUtils::pathSeparator())
+		if (m_path.at(m_path.length() - 1) != ReStringUtils::pathSeparator())
 			m_path.append(ReStringUtils::pathSeparatorStr(), 1);
 	}
+#elif defined __WIN32__
+    struct stat info;
+    m_valid = stat(path, &info) == 0 && S_ISDIR(info.st_mode);
+#endif
 }
 /** @brief Returns the name of the directory.
  *
  * @return The name of the directory.
  */
 const char* ReDirectory::getDir(void) const {
-	return m_path.getBuffer();
+	return m_path.buffer();
 }
 
 /** @brief Tests whether the directory state is valid.
@@ -84,7 +108,9 @@ bool ReDirectory::isValid(){
  * @param flags		Usefull flags are: REG_ICASE: ignore case.
  */
 void ReDirectory::setRegExprFlags(int flags){
+#if defined __linux__
 	m_regExprFlags = flags;
+#endif
 }
 
 /** @brief Find the first file with a given filename pattern.
@@ -99,8 +125,12 @@ bool ReDirectory::findFirst(const char* pattern, bool isRegExpr){
 	if (m_valid){
 		m_pattern.set(pattern, -1);
 		m_isRegExpr = isRegExpr;
+#if defined __linux__
 		if (isRegExpr){
+			if (m_regExprIsInitialized)
+				regfree(&m_regExpr);
 			int rc2 = regcomp(&m_regExpr, pattern, m_regExprFlags);
+			m_regExprIsInitialized = true;
 
 			if (rc2 != 0){
 				rc = false;
@@ -114,6 +144,10 @@ bool ReDirectory::findFirst(const char* pattern, bool isRegExpr){
 			m_entry = NULL;
 			rc = findNext();
 		}
+#elif defined __WIN32__
+        m_handle = FindFirstFileA(pattern, &m_data);
+        rc = m_handle != INVALID_HANDLE_VALUE;
+#endif
 	}
 	return rc;
 }
@@ -124,6 +158,7 @@ bool ReDirectory::findFirst(const char* pattern, bool isRegExpr){
 bool ReDirectory::findNext(){
 	bool rc = false;
 	if (m_valid){
+#if defined __linux__
 		while (! rc &&  (m_entry = readdir(m_dir)) != NULL){
 			if (m_isRegExpr){
 				regmatch_t match[10];
@@ -135,6 +170,10 @@ bool ReDirectory::findNext(){
 					rc = true;
 			}
 		}
+#elif defined __WIN32__
+        if (m_handle != INVALID_HANDLE_VALUE)
+            rc = FindNextFileA(m_handle, &m_data) != 0;
+#endif
 	}
 	return rc;
 }
@@ -149,12 +188,14 @@ bool ReDirectory::findNext(){
 bool ReDirectory::findYoungest(ReByteBuffer& filename){
 	bool rc = false;
 	filename.setLength(0);
+	ReByteBuffer fullname;
+
+#if defined __linux__
 	if (m_entry != NULL)
 	{
-		ReByteBuffer fullname;
-		fullname.append(m_path);
-		size_t length = fullname.getLength();
-		struct stat info;
+	    fullname.append(m_path);
+	    size_t length = fullname.length();
+	    struct stat info;
 		timespec youngest;
 		youngest.tv_sec = youngest.tv_nsec = 0;
 		do{
@@ -171,6 +212,20 @@ bool ReDirectory::findYoungest(ReByteBuffer& filename){
 
 		} while(findNext());
 	}
+#elif defined __WIN32__
+        FILETIME youngest;
+        memset(&youngest, 0, sizeof youngest);
+		do{
+            if (m_data.ftLastWriteTime.dwHighDateTime > youngest.dwHighDateTime
+                || m_data.ftLastWriteTime.dwHighDateTime == youngest.dwHighDateTime
+                    &&  m_data.ftLastWriteTime.dwLowDateTime > youngest.dwLowDateTime){
+                youngest = m_data.ftLastWriteTime;
+                filename.set(m_data.cFileName, -1);
+				rc = true;
+			}
+
+		} while(findNext());
+#endif
 	return rc;
 }
 /** @brief Returns the name of the current file found by the last <code>findFirst()</code>
@@ -180,8 +235,12 @@ bool ReDirectory::findYoungest(ReByteBuffer& filename){
  *
  */
 const char* ReDirectory::currentFile(){
+#if defined __linux__
 	const char* rc = m_entry == NULL ? NULL : m_entry->d_name;
-	return rc;
+#elif defined __WIN32__
+   const char* rc = m_data.cFileName;
+#endif
+   return rc;
 }
 /** @brief Returns the full path of the current file or a given node.
  *
@@ -197,11 +256,18 @@ const char* ReDirectory::currentFile(){
 ReByteBuffer& ReDirectory::fullpath(ReByteBuffer& path, const char* name){
 	path.setLength(0);
 	if (name != NULL){
-		path.append(m_path);
+        path.set(m_path.str(), m_path.length());
 		path.append(name, -1);
-	} else if (m_valid && m_entry != NULL){
-		path.append(m_path);
-		path.append(m_entry->d_name, -1);
+	} else if (m_valid){
+#if defined __linux__
+        if (m_entry != NULL){
+		    path.append(m_path);
+		    path.append(m_entry->d_name, -1);
+        }
+#elif defined __WIN32__
+        path.set(m_path.str(), m_path.length());
+		path.append(m_data.cFileName, -1);
+#endif
 	}
 	return path;
 }
@@ -213,46 +279,3 @@ ReByteBuffer& ReDirectory::fullpath(ReByteBuffer& path, const char* name){
  * @param useRegExpr	True: <code>pattern</code> is a regular expression.
  */
 
-#if defined RE_TESTUNIT
-class TestReDirectory : public ReTestUnit {
-public:
-	TestReDirectory() : ReTestUnit("ReFileFinder", __FILE__){
-		run();
-	}
-private:
-	void run(){
-		createTestDir();
-		ReByteBuffer dir;
-		dir.set(getTestDir(), -1);
-		ReByteBuffer file1 = dir;
-		file1.append("abc.1.txt", -1);
-		createFile(file1.str(), "abc1");
-
-		ReByteBuffer file2 = dir;
-		file2.append("abc.2.txt", -1);
-		createFile(file2.str(), "abc2");
-
-		ReDirectory finder(dir.str());
-		checkT(finder.isValid());
-
-		checkT(finder.findFirst("abc.*.txt", false));
-		checkEqu("abc.1.txt", finder.currentFile());
-		checkT(finder.findNext());
-		checkEqu("abc.2.txt", finder.currentFile());
-		checkF(finder.findNext());
-		checkF(finder.findFirst("abx.*.txt", false));
-
-		checkT(finder.findFirst("abc[.][0-9][.]txt", true));
-		checkEqu("abc.1.txt", finder.currentFile());
-		checkT(finder.findNext());
-		checkEqu("abc.2.txt", finder.currentFile());
-		checkF(finder.findNext());
-		checkF(finder.findFirst("abx[.][0-9][.]txt", true));
-	}
-};
-extern void testReDirectory(void);
-
-void testReDirectory(void){
-	TestReDirectory unit;
-}
-#endif /*RE_TESTUNIT*/
diff --git a/base/ReDirectory.hpp b/base/ReDirectory.hpp
index 3e93a43..81634b1 100644
--- a/base/ReDirectory.hpp
+++ b/base/ReDirectory.hpp
@@ -7,7 +7,6 @@
 
 #ifndef REFILEFINDER_H_
 #define REFILEFINDER_H_
-
 /** <code>ReDirectory</code> searches files using pattern matching and/or file date.
  */
 class ReDirectory{
@@ -27,15 +26,21 @@ public:
 	ReByteBuffer& fullpath(ReByteBuffer& path, const char* name = NULL);
 private:
 		//@ true: The directory is ok. false: The directory is undefined.
-	bool				m_valid;
-	DIR* 				m_dir;
+	bool m_valid;
 		//@ The name of the current directory. Always ends with slash!
-	ReByteBuffer 		m_path;
-	struct dirent*		m_entry;
-	ReByteBuffer		m_pattern;
-	bool				m_isRegExpr;
-	regex_t				m_regExpr;
+	ReByteBuffer m_path;
+	ReByteBuffer m_pattern;
+#if defined __linux__
+	DIR*  m_dir;
+	struct dirent* m_entry;
+	regex_t m_regExpr;
+	int m_regExprFlags;
+	bool m_regExprIsInitialized;
 		// Flags for the regular expressions: REG_ICASE: ignore Case.
-	int					m_regExprFlags;
+	bool m_isRegExpr;
+#elif defined __WIN32__
+    HANDLE m_handle;
+    WIN32_FIND_DATAA m_data;
+#endif
 };
 #endif /* REFILEFINDER_H_ */
diff --git a/base/ReException.cpp b/base/ReException.cpp
index 7876bf8..cf8581a 100644
--- a/base/ReException.cpp
+++ b/base/ReException.cpp
@@ -5,7 +5,7 @@
  *      Author: wk
  */
 
-#include "rebase.hpp"
+#include "base/rebase.hpp"
 
 /** @brief Constructor.
  *
@@ -24,7 +24,7 @@ ReException::ReException()
  */
 ReException::ReException(const char* message)
 	:
-	m_message(strdup(message))
+	m_message(_strdup(message))
 {
 }
 /** @brief Constructor.
@@ -39,7 +39,7 @@ ReException::ReException(const char* message, const char* file, int lineNo)
 {
 	char buffer[512];
 	snprintf(buffer, sizeof buffer, "%s [%.100s-%d]", message, file, lineNo);
-	m_message = strdup(buffer);
+	m_message = _strdup(buffer);
 }
 /** @brief Destructor.
  */
@@ -50,13 +50,13 @@ ReException::~ReException(){
 
 ReException::ReException(const ReException& source)
 	:
-	m_message(strdup(source.getMessage()))
+	m_message(_strdup(source.getMessage()))
 {
 }
 ReException& ReException::operator =(const ReException& source){
 	if (m_message != NULL)
 		free((void*) m_message);
-	m_message = strdup(source.getMessage());
+	m_message = _strdup(source.getMessage());
 	return *this;
 }
 
@@ -72,7 +72,7 @@ ReFormatException::ReFormatException(const char* message, const char* format)
 {
 	char buffer[512];
 	snprintf(buffer, sizeof buffer, "%s%s", message, format == NULL ? "" : format);
-	m_message = strdup(buffer);
+	m_message = _strdup(buffer);
 
 }
 /** @brief Constructor.
@@ -90,7 +90,7 @@ ReFormatException::ReFormatException(const char* message, const char* format,
 	char buffer[512];
 	snprintf(buffer, sizeof buffer, "%s%s [%.100s-%d]",
 		message, format == NULL ? "" : format, file, lineNo);
-	m_message = strdup(buffer);
+	m_message = _strdup(buffer);
 }
 
 /** @brief Constructor.
@@ -105,7 +105,7 @@ ReBoundsException::ReBoundsException(const char* name, int index, int bound)
 	const char* format = index < bound
 		? i18n("%s: index underflow: %d / %d") : i18n("%s: index overflow: %d / %d");
 	snprintf(buffer, sizeof buffer, format, name, index, bound);
-	m_message = strdup(buffer);
+	m_message = _strdup(buffer);
 }
 /** @brief Constructor.
  *
@@ -123,73 +123,6 @@ ReBoundsException::ReBoundsException(const char* name, int index, int bound, con
 	const char* format = index < bound
 		? i18n("%s: index underflow: %d / %d [%s-%d]") : i18n("%s: index overflow: %d / %d [%s-%d]");
 	snprintf(buffer, sizeof buffer, format, name, index, bound, file, line);
-	m_message = strdup(buffer);
+	m_message = _strdup(buffer);
 }
 
-#if defined RE_TESTUNIT
-class TestReException : public ReTestUnit, public ReVarArgTrigger {
-public:
-	TestReException()
-		:
-		ReTestUnit("ReException", __FILE__),
-		m_argNo(0),
-		m_maxNo(0)
-	{
-		run();
-	}
-	virtual void newArg(int no, int maxNo){
-		m_argNo = no;
-		m_maxNo = maxNo;
-	}
-private:
-	void run(){
-		try{
-			throw ReException("ReException");
-			checkT(false);
-		} catch (ReException& e){
-			log(false, e.getMessage());
-		}
-		try{
-			throw ReException("ReException", __FILE__, __LINE__);
-			checkT(false);
-		} catch (ReException& e){
-			log(false, e.getMessage());
-		}
-		try{
-			throw ReFormatException("ReFormatException", "format");
-			checkT(false);
-		} catch (ReException& e){
-			log(false, e.getMessage());
-		}
-		try{
-			throw ReFormatException("ReFormatException", "format",  __FILE__, __LINE__);
-			checkT(false);
-		} catch (ReException& e){
-			log(false, e.getMessage());
-		}
-		try{
-			throw ReBoundsException("myArray", 101, 100);
-			checkT(false);
-		} catch (ReException& e){
-			log(false, e.getMessage());
-		}
-
-		try{
-			throw ReBoundsException("myArray", -1, 0,  __FILE__, __LINE__);
-			checkT(false);
-		} catch (ReException& e){
-			log(false, e.getMessage());
-		}
-
-	}
-private:
-	int m_argNo;
-	int m_maxNo;
-};
-extern void testReException(void);
-
-void testReException(void){
-	TestReException unit;
-}
-#endif /*RE_TESTUNIT*/
-
diff --git a/base/ReException.hpp b/base/ReException.hpp
index 2aa09ec..173b8eb 100644
--- a/base/ReException.hpp
+++ b/base/ReException.hpp
@@ -27,7 +27,7 @@ public:
 	inline void setMessage(const char* message){
 		if (m_message != NULL)
 			free((void *) m_message);
-		m_message = strdup(message);
+		m_message = _strdup(message);
 	}
 	/** @brief Returns the message.
 	 * @returns The description of the exception.
diff --git a/base/ReHashList.cpp b/base/ReHashList.cpp
index 88b9501..178eae2 100644
--- a/base/ReHashList.cpp
+++ b/base/ReHashList.cpp
@@ -5,7 +5,7 @@
  *      Author: wk
  */
 
-#include "rebase.hpp"
+#include "base/rebase.hpp"
 
 /** Constructor.
  */
@@ -36,13 +36,13 @@ void ReHashList::put(const Byte* key, size_t keyLength,
 	int ix = find(key, keyLength);
 	bool storeValue = false;
 	if (ix < 0){
-		ReSeqList::Index pos = m_values.getLength();
+		ReSeqList::Index pos = m_values.length();
 		storeValue = true;
 		m_keys.add(-1, key, keyLength, pos);
 	} else {
 		Sequence* seq = m_keys.getInfo(ix);
 		// m_tag contains the index into <code>m_values</code>.
-		Byte* ptr = m_values.getBuffer() + seq->m_tag;
+		Byte* ptr = m_values.buffer() + seq->m_tag;
 		size_t valLength = * (size_t *) ptr;
 		// Can we take the old storage?
 		if (valLength >= valueLength){
@@ -52,7 +52,7 @@ void ReHashList::put(const Byte* key, size_t keyLength,
 			memcpy(ptr, value, valueLength);
 		} else {
 			storeValue = true;
-			seq->m_tag = m_values.getLength();
+			seq->m_tag = m_values.length();
 		}
 	}
 	if (storeValue){
@@ -74,7 +74,7 @@ void ReHashList::put(const char* key, const char* value){
  * @param value			The value.
  */
 void ReHashList::put(const ReByteBuffer& key, const ReByteBuffer& value){
-	put(key.getBuffer(), key.getLength(), value.getBuffer(), value.getLength());
+	put(key.buffer(), key.length(), value.buffer(), value.length());
 }
 /** @brief Returns the value of a key value pair.
  *
@@ -94,7 +94,7 @@ bool ReHashList::get(const Byte* key, size_t keyLength,
 	if (rc){
 		ReSeqList::Sequence* seq = m_keys.getInfo(ix);
 		// m_tag contains the index into m_values:
-		Byte* ptr = m_values.getBuffer() + seq->m_tag;
+		Byte* ptr = m_values.buffer() + seq->m_tag;
 		// m_values contains <length><sequence>:
 		size_t valLength = * (size_t*) ptr;
 		ptr += sizeof (size_t);
@@ -111,7 +111,7 @@ bool ReHashList::get(const Byte* key, size_t keyLength,
  */
 bool ReHashList::get(const ReByteBuffer& key,
 		ReByteBuffer value) const{
-	bool rc = get(key.getBuffer(), key.getLength(), value);
+	bool rc = get(key.buffer(), key.length(), value);
 	return rc;
 }
 /** @brief Deletes all entries in the list.
@@ -138,14 +138,14 @@ bool ReHashList::next(size_t& position, ReByteBuffer* key, ReByteBuffer* value){
 		if (key != NULL){
 			const Byte* ptr = m_keys.getContent() + seq->m_index;
 			key->setLength(seq->m_length);
-			memcpy(key->getBuffer(), ptr, seq->m_length);
+			memcpy(key->buffer(), ptr, seq->m_length);
 		}
 		if (value != NULL){
-			const Byte* ptr = m_values.getBuffer() + seq->m_tag;
+			const Byte* ptr = m_values.buffer() + seq->m_tag;
 			size_t length = * (size_t*) ptr;
 			ptr += sizeof (size_t);
 			value->setLength(length);
-			memcpy(value->getBuffer(), ptr, length);
+			memcpy(value->buffer(), ptr, length);
 		}
 	}
 	return rc;
@@ -174,71 +174,4 @@ int ReHashList::find(const Byte* key, size_t length) const{
 	return rc;
 }
 
-#if defined RE_TESTUNIT
-class TestReHashList : public ReTestUnit {
-public:
-	TestReHashList() : ReTestUnit("ReHashList", __FILE__){
-		run();
-	}
-private:
-	void run(){
-		testBasic();
-		testNext();
-	}
-	void testBasic(){
-		ReHashList hash;
-		ReByteBuffer key, value;
-
-		hash.put("abc", "123");
-		checkT(hash.get("abc", -1, value));
-		checkEqu("123", value.str());
-
-		hash.put("ab", "999");
-		checkT(hash.get("ab", -1, value));
-		checkEqu("999", value.str());
-
-		checkT(hash.get("abc", -1, value));
-		checkEqu("123", value.str());
-
-		hash.put("abc", "!!!");
-		checkT(hash.get("abc", -1, value));
-		checkEqu("!!!", value.str());
-
-		checkT(hash.get("ab", -1, value));
-		checkEqu("999", value.str());
-
-		hash.put("abc", "longer");
-		checkT(hash.get("abc", -1, value));
-		checkEqu("longer", value.str());
-
-		checkT(hash.get("ab", -1, value));
-		checkEqu("999", value.str());
-	}
-	void testNext(){
-		ReHashList hash;
-		hash.put("1", "8");
-		hash.put("2", "4");
-		hash.put("4", "2");
-		hash.put("8", "1");
-		int flagsKey = 0;
-		int flagsVal = 0;
-		size_t pos = 0;
-		ReByteBuffer key, value;
-		while(hash.next(pos, &key, &value)){
-			int x = atol(key.getBuffer());
-			int y = atol(value.getBuffer());
-			checkEqu(8, x * y);
-			flagsKey += x;
-			flagsVal += y;
-		}
-		checkEqu(15, flagsKey);
-		checkEqu(15, flagsVal);
-	}
-};
-extern void testReHashList(void);
-
-void testReHashList(void){
-	TestReHashList unit;
-}
-#endif /*RE_TESTUNIT*/
 
diff --git a/base/ReI18N.cpp b/base/ReI18N.cpp
index c40a121..9936342 100644
--- a/base/ReI18N.cpp
+++ b/base/ReI18N.cpp
@@ -5,7 +5,7 @@
  *      Author: wk
  */
 
-#include "../base/restring.hpp"
+#include "base/rebase.hpp"
 
 //@ The current language. If NULL no language has been chosen.
 ReI18N::LanguagePack*	ReI18N::m_current = 0;
@@ -184,27 +184,3 @@ ReVarArgs&  ReI18N::trF(const char* key, ReVarArgs& args){
 	return args;
 }
 
-#if defined RE_TESTUNIT
-class TestReI18N : public ReTestUnit {
-public:
-	TestReI18N()
-		:
-		ReTestUnit("ReI18N", __FILE__)
-	{
-		run();
-	}
-private:
-	void run(){
-		checkEqu("dies ist ein Test", i18n("this is a test"));
-		checkEqu("eins: 1 zwei: 2", i18nf("one: $1 two: $2").arg(1).arg(2).asCString());
-
-	}
-};
-extern void testReI18N(void);
-
-void testReI18N(void){
-	TestReI18N unit;
-}
-#endif /*RE_TESTUNIT*/
-
-
diff --git a/base/ReLogger.cpp b/base/ReLogger.cpp
index 9a2699f..8a9df3c 100644
--- a/base/ReLogger.cpp
+++ b/base/ReLogger.cpp
@@ -5,8 +5,11 @@
  *      Author: wk
  */
 
-#include "rebase.hpp"
+#include "base/rebase.hpp"
 
+#ifdef __linux__
+extern size_t strftime (char* s, size_t maxsize, const char* format, const struct tm* tp);
+#endif
 
 ReLogger* ReLogger::m_globalLogger = NULL;
 
@@ -19,15 +22,20 @@ ReLogger* ReLogger::m_globalLogger = NULL;
  */
 ReLogger* ReLogger::globalLogger(){
 	if (m_globalLogger == NULL){
-		ReStreamAppender* stream = new ReStreamAppender(stderr);
-		ReFileAppender* file = new ReFileAppender();
-		file->setConfig("globallogger", 5, 1000100);
 		m_globalLogger = new ReLogger();
-		m_globalLogger->addAppender(stream);
-		m_globalLogger->addAppender(file);
+		m_globalLogger->addStandardAppenders(true, "globallogger");
 	}
 	return m_globalLogger;
 }
+/**
+ * Frees the resources of the global logger (if it exists).
+ */
+void ReLogger::freeGlobalLogger(){
+	if (m_globalLogger != NULL){
+		delete m_globalLogger;
+		m_globalLogger = NULL;
+	}
+}
 /** @brief Constructor.
  */
 ReAppender::ReAppender()
@@ -104,6 +112,10 @@ ReStreamAppender::ReStreamAppender(FILE* stream)
 /** @brief Destructor.
  */
 ReStreamAppender::~ReStreamAppender(){
+	if (m_stream != NULL){
+		fclose(m_stream);
+		m_stream = NULL;
+	}
 }
 
 /** @brief Puts a message into the internal stream.
@@ -113,13 +125,15 @@ ReStreamAppender::~ReStreamAppender(){
  */
 void ReStreamAppender::say(ReLogger* logger, const char* message){
 	const char* prefix = logger->getStandardPrefix();
-	fputs(prefix, m_stream);
-	if (message != NULL)
-		fputs(message, m_stream);
-	else
-		fputs(logger->asCString(), m_stream);
-	fputc('\n', m_stream);
-	fflush(m_stream);
+    if (m_stream != NULL){
+	    fputs(prefix, m_stream);
+	    if (message != NULL)
+		    fputs(message, m_stream);
+	    else
+		    fputs(logger->asCString(), m_stream);
+	    fputc('\n', m_stream);
+	    fflush(m_stream);
+    }
 }
 /** @brief Constructor.
  */
@@ -166,7 +180,7 @@ void ReFileAppender::setConfig(const char* pattern, int maxFiles, int maxSize){
 	ReByteBuffer fn, protocol, path, name, ext;
 	ReStringUtils::splitPath(m_filePattern, &protocol, &path, &name, &ext);
 	ReStringUtils::joinPath(fn, &protocol, &path, NULL, NULL);
-	if (fn.getLength() == 0)
+	if (fn.length() == 0)
 		fn.set(".", 1);
 	ReDirectory dir(fn.str());
 	if (! dir.isValid()){
@@ -175,7 +189,11 @@ void ReFileAppender::setConfig(const char* pattern, int maxFiles, int maxSize){
 	} else {
 		ReStringUtils::joinPath(fn, NULL, NULL, &name, &ext);
 		int ix = fn.indexOf(placeholder, -1, 0);
+#if defined __linux__
 		fn.splice(ix, 4, "[0-9]{4}", -1);
+#elif defined __WIN32__
+		fn.splice(ix, 4, "*", -1);
+#endif
 
 		// Looking for the current logfile:
 		if (! dir.findFirst(fn.str(), true)){
@@ -188,13 +206,17 @@ void ReFileAppender::setConfig(const char* pattern, int maxFiles, int maxSize){
 		struct stat info;
 		ReByteBuffer fullname;
 		dir.fullpath(fullname, fn.str());
+#ifdef __WIN32__
+#define lstat stat
+#endif
 		int rc = lstat(fullname.str(), &info);
 
 		if (rc == 0 && (m_currentSize = info.st_size) > m_maxSize)
 			changeFile();
 		else{
 			m_stream = fopen(fullname.str(), "a");
-			assert(m_stream != NULL);
+			if (m_stream == NULL)
+				assert(m_stream != NULL);
 		}
 	}
 }
@@ -215,7 +237,7 @@ void ReFileAppender::changeFile(){
 		snprintf(filename, sizeof filename, m_filePattern, fileNo);
 		struct stat info;
 		if (lstat(filename, &info) == 0)
-			unlink(filename);
+			_unlink(filename);
 		else
 			break;
 	}
@@ -240,8 +262,10 @@ ReLogger::ReLogger(bool isGlobal)
 	m_stdFileAppender(NULL),
 	m_locationOfOpenSayF(0)
 {
-	if (isGlobal)
+	if (isGlobal){
+		delete m_globalLogger;
 		m_globalLogger = this;
+	}
 	m_standardPrefix[0] = '\0';
 }
 /** @brief Destructor.
@@ -255,6 +279,8 @@ ReLogger::~ReLogger(){
 	delete[] m_appenderList;
 	m_appenderList = NULL;
 	m_appenderListSize = 0;
+	if (m_globalLogger == this)
+		m_globalLogger = NULL;
 }
 /** @brief Issues a log message.
  *
@@ -296,7 +322,8 @@ ReVarArgs& ReLogger::sayF(ReClassCategoryGranularity mode, ReLogLocation locatio
 		const char* format){
 	if (m_locationOfOpenSayF != 0){
 		char message[128];
-		snprintf(message, sizeof message, "missing ReLogger::end(): Location: %d", m_locationOfOpenSayF);
+		snprintf(message, sizeof message, "missing ReLogger::end(): Location: %d",
+					m_locationOfOpenSayF);
 		say(LOG_ERROR|GRAN_USER|CAT_LIB, LC_LOGGER_SAYF_OPEN, message);
 	}
 	m_locationOfOpenSayF = location;
@@ -394,32 +421,3 @@ void ReLogger::end(void){
 	m_locationOfOpenSayF = 0;
 }
 
-#if defined RE_TESTUNIT
-class TestReLogger : public ReTestUnit {
-public:
-	TestReLogger() : ReTestUnit("ReLogger", __FILE__){
-		run();
-	}
-private:
-	void run(){
-		ReStreamAppender app1(stdout);
-		app1.setMode(CAT_ALL, CAT_ALL, CAT_ALL, GRAN_ALL);
-
-		ReLogger logger;
-		logger.addAppender(&app1);
-		log(false, "2 Errors and a warning:");
-		logger.say(LOG_ABORT | CAT_TEST | GRAN_TRACE, __LINE__, "abort");;
-		logger.say(LOG_ERROR | CAT_TEST, __LINE__, "error");
-		logger.say(LOG_WARNING | CAT_TEST, __LINE__, "warning");
-
-		logger.sayF(CAT_TEST, __LINE__, "Two: $1 eleven: $021").arg(2).arg(1).end();
-		globalLogger()->say(CAT_LIB, __LINE__, "globalLogger()");
-	}
-};
-extern void testReLogger(void);
-
-void testReLogger(void){
-	TestReLogger unit;
-}
-#endif /*RE_TESTUNIT*/
-
diff --git a/base/ReLogger.hpp b/base/ReLogger.hpp
index 422adfc..07a3178 100644
--- a/base/ReLogger.hpp
+++ b/base/ReLogger.hpp
@@ -134,6 +134,7 @@ protected:
 class ReLogger : public ReVarArgs {
 public:
 	static ReLogger* globalLogger();
+	static void freeGlobalLogger();
 	static ReLogger* m_globalLogger;
 public:
 	ReLogger(bool isGlobal = true);
diff --git a/base/ReProgramArgs.cpp b/base/ReProgramArgs.cpp
index 7deb6aa..b275e27 100644
--- a/base/ReProgramArgs.cpp
+++ b/base/ReProgramArgs.cpp
@@ -5,7 +5,7 @@
  *      Author: wk
  */
 
-#include "rebase.hpp"
+#include "base/rebase.hpp"
 
 
 /** @brief Constructor.
@@ -146,7 +146,7 @@ void ReProgramArgs::addInt(const char* name, const char* description,
 	ReByteBuffer number;
 	number.appendInt(defaultVal);
 	addProperties(name, description, shortOpt, longOpt, DT_INT,
-		number.str(), number.getLength());
+		number.str(), number.length());
 }
 
 /** @brief Adds an option with a boolean value.
@@ -198,9 +198,9 @@ bool ReProgramArgs::getBool(const char* name) {
 		ReOptionException(this, i18n("$1 is not an option name"), name);
 
 	properties.split(buffer.str(), '\1');
-	if (properties.getCStr(IxType)[0] != 'b')
+	if (properties.strOf(IxType)[0] != 'b')
 		ReOptionException(this, i18n("$1 is not an boolean option. Type is $2"), name,
-			properties.getCStr(IxType));
+			properties.strOf(IxType));
 
 	m_values.get(name, -1, buffer);
 	bool rc = buffer.at(1) == 't';
@@ -223,9 +223,9 @@ int ReProgramArgs::getInt(const char* name) {
 		ReOptionException(this, i18n("$1 is not an option name"), name);
 
 	properties.split(buffer.str(), '\1');
-	if (properties.getCStr(IxType)[0] != DT_INT)
+	if (properties.strOf(IxType)[0] != DT_INT)
 		ReOptionException(this, i18n("$1 is not an integer option. Type is $2"), name,
-			properties.getCStr(IxType));
+			properties.strOf(IxType));
 
 	m_values.get(name, -1, buffer);
 	int rc = buffer.atoi(1);
@@ -247,13 +247,13 @@ const char* ReProgramArgs::getString(const char* name, ReByteBuffer& buffer) {
 		ReOptionException(this, i18n("$1 is not an option name"), name);
 
 	properties.split(buffer.str(), '\1');
-	DataType dataType = (DataType) properties.getCStr(IxType)[0];
+	DataType dataType = (DataType) properties.strOf(IxType)[0];
 	if (dataType != DT_STRING && dataType != DT_STRING_EMPTY)
 		ReOptionException(this, i18n("$1 is not a string option. Type is $2"), name,
-			properties.getCStr(IxType));
+			properties.strOf(IxType));
 
 	m_values.get(name, -1, buffer);
-	const char* rc = buffer.getBuffer() + 1;
+	const char* rc = buffer.buffer() + 1;
 	return rc;
 }
 
@@ -310,10 +310,10 @@ void ReProgramArgs::search(char shortName, const char* longName,
 	}
 	while (! found && m_properties.next(position, &name, &properties)){
 		list.split(properties.str(), '\1');
-		if (longName == NULL && shortName == list.getCStr(IxShort)[0])
+		if (longName == NULL && shortName == list.strOf(IxShort)[0])
 			found = true;
-		else if (lengthLongName > 0 && list.getLength(IxLong) == lengthLongName + 1
-			&& strncmp(longName, list.getCStr(IxLong), lengthLongName) == 0)
+		else if (lengthLongName > 0 && list.sizeOf(IxLong) == lengthLongName + 1
+			&& strncmp(longName, list.strOf(IxLong), lengthLongName) == 0)
 			found = true;
 	}
 	if (! found){
@@ -377,7 +377,7 @@ bool ReProgramArgs::analyseShort(const char* opt, const char* nextArg){
 		again = false;
 
 		search(opt[0], NULL, name, properties);
-		const char* dataType = properties.getCStr(IxType);
+		const char* dataType = properties.strOf(IxType);
 		const char* nameStr = name.str();
 		// Forget the option short name:
 		opt++;
@@ -410,7 +410,7 @@ bool ReProgramArgs::analyseShort(const char* opt, const char* nextArg){
 			} else if (opt[0] == '+')
 				opt++;
 			// Invert the default value:
-			if (properties.getCStr(IxDefault)[0] == 't')
+			if (properties.strOf(IxDefault)[0] == 't')
 				value = value[0] =='t' ? "f" : "t";
 			setValue(nameStr, value, dataType);
 			again = opt[0] != '\0';
@@ -435,7 +435,7 @@ void ReProgramArgs::analyseLong(const char* opt){
 	search('\0', opt, name, properties);
 
 	const char* nameStr = name.str();
-	const char* dataType = properties.getCStr(IxType);
+	const char* dataType = properties.strOf(IxType);
 	const char* value = strchr(opt, '=');
 	if (value != NULL)
 		value++;
@@ -470,7 +470,7 @@ void ReProgramArgs::analyseLong(const char* opt){
 			ReOptionException(this, i18n("Option $1: Not a boolean value: $2. Use true or false"),
 					nameStr, value);
 		// Invert the default value:
-		if (properties.getCStr(IxDefault)[0] == 't')
+		if (properties.strOf(IxDefault)[0] == 't')
 			boolValue = boolValue[0] =='t' ? "f" : "t";
 		setValue(nameStr, boolValue, dataType);
 		break;
@@ -532,8 +532,8 @@ void ReProgramArgs::help(const char* message, bool issueLastError, ReStringList&
 		ReStringList properties;
 		properties.split(prop.str(), '\1');
 		line.setLength(0);
-		DataType dataType = DataType(properties.getCStr(IxType)[0]);
-		const char* shortName = properties.getCStr(IxShort);
+		DataType dataType = DataType(properties.strOf(IxType)[0]);
+		const char* shortName = properties.strOf(IxShort);
 		param.setLength(0);
 		switch(dataType){
 		case DT_INT:
@@ -552,19 +552,19 @@ void ReProgramArgs::help(const char* message, bool issueLastError, ReStringList&
 			line.append("-", 1).append(shortName, 1);
 			line.append(param.str(), -1).append(" ", 1).append(i18n(" or "), -1);
 		}
-		line.append(i18n("--"), -1).append(properties.getCStr(IxLong), -1);
-		if (param.getLength() > 0)
+		line.append(i18n("--"), -1).append(properties.strOf(IxLong), -1);
+		if (param.length() > 0)
 			line.append("=", -1).append(param.str(), -1)
-				.append(i18n(" Default value: "), -1).append(properties.getCStr(IxDefault), -1);
+				.append(i18n(" Default value: "), -1).append(properties.strOf(IxDefault), -1);
 		lines.append(line.str());
-		line.set("\t", 1).append(properties.getCStr(IxDescr), -1);
+		line.set("\t", 1).append(properties.strOf(IxDescr), -1);
 		lines.append(line.str());
 	}
 	if (m_examples.getCount() > 0){
 		lines.append(i18n("Example:"));
 		lines.append(m_examples);
 	}
-	if (issueLastError && m_lastError.getLength() > 0){
+	if (issueLastError && m_lastError.length() > 0){
 		line.set("+++ ", 4).append(m_lastError.str(), -1);
 		lines.append(line.str());
 	}
@@ -579,119 +579,7 @@ void ReProgramArgs::help(const char* message, bool issueLastError, FILE* stream)
 	ReStringList lines;
 	help(message, issueLastError, lines);
 	for(size_t ii = 0; ii < lines.getCount(); ii++){
-		fputs(lines.getCStr(ii), stream);
+		fputs(lines.strOf(ii), stream);
 		fputc('\n', stream);
 	}
 }
-
-#if defined RE_TESTUNIT
-class TestReProgramArgs : public ReTestUnit {
-public:
-	TestReProgramArgs()
-		:
-		ReTestUnit("ReProgramArgs", __FILE__)
-	{
-		run();
-	}
-private:
-	void run(){
-		testLong();
-		testShort();
-	}
-	void testShort(){
-		ReProgramArgs args("test <opts> <args>\nThis tests the usage of ReProgramArgs",
-				"$0 -b+ -B- file dir\n\ttest of an example");
-
-		args.addBool("boolarg", "This is a boolean arg", 'b', "boolval", false);
-		args.addBool("boolarg2", "This is the 2nd boolean arg", 'B', "boolval2", true);
-		args.addBool("boolarg3", "This is the 3rd boolean arg", 'x', "boolval3", false);
-		args.addBool("boolarg4", "This is the 4th boolean arg", 'Y', "boolval4", true);
-		args.addInt("intarg", "This is an integer arg", 'i', "intval", 9);
-		args.addInt("intarg2", "This is the 2nd integer arg", 'I', "intval", 1000);
-		args.addString("stringarg", "This string must be non empty", 's', "string", false, "abc");
-		args.addString("stringarg2", "This 2nd string must be non empty", 'u', "string2", false, "undef");
-		args.addString("estringarg", "This string may be empty", 'S', "estring", true, "empty");
-		args.addString("estringarg2", "This 2nd string may be empty", 'U', "estring2", true, "undef2");
-
-		checkF(args.getBool("boolarg"));
-		checkEqu(9, args.getInt("intarg"));
-		ReByteBuffer buffer;
-		checkEqu("empty", args.getString("estringarg", buffer));
-		checkEqu("abc", args.getString("stringarg", buffer));
-
-		const char* vector[] = {
-			"testprog", "-bB+i123", "-S", "-x-", "-Y+", "-s", "2nd string", "arg1", "arg2"
-		};
-		args.init(sizeof vector / sizeof vector[0], (char**) vector);
-
-		checkEqu("testprog", args.getProgramName());
-		checkT(args.getBool("boolarg"));
-		checkF(args.getBool("boolarg2"));
-		checkF(args.getBool("boolarg3"));
-		checkF(args.getBool("boolarg4"));
-		checkEqu(123, args.getInt("intarg"));
-		checkEqu(1000, args.getInt("intarg2"));
-		checkEqu("", args.getString("estringarg", buffer));
-		checkEqu("2nd string", args.getString("stringarg", buffer));
-		checkEqu("undef", args.getString("stringarg2", buffer));
-		checkEqu("undef2", args.getString("estringarg2", buffer));
-		checkEqu("testprog", args.getProgramName());
-		checkEqu("arg1", args.getArg(0));
-		checkEqu("arg2", args.getArg(1));
-		checkEqu(2, args.getArgCount());
-
-		args.help("Not really an error!", false, stdout);
-	}
-	void testLong(){
-		const char* call[] = {
-				"test <opts> <args>",
-				"This tests the usage of ReProgramArgs",
-				NULL
-		};
-		const char* examples[] = { "test -intval=10 --boolval=t",  NULL};
-		ReProgramArgs args(call, examples);
-
-		args.addBool("boolarg", "This is a boolean arg", 'b', "boolval", false);
-		char none = ReProgramArgs::HIDDEN_SHORT_NAME;
-		args.addBool("boolarg2", "This is the 2nd boolean arg", none, "boolval2", true);
-		args.addBool("boolarg3", "This is the 3rd boolean arg", 'x', "boolval3", false);
-		args.addBool("boolarg4", "This is the 3rd boolean arg", none, "boolval4", true);
-		args.addInt("intarg", "This is an integer arg", 'i', "intval", 9);
-		args.addString("stringarg", "This string must be non empty", 's', "string", false, "abc");
-		args.addString("estringarg", "This string may be empty", none, "estring", true, "empty");
-		args.addString("estringarg2", "This 2nd string may be empty", 'U', "estring2", true, "undef2");
-		args.addString("estringarg3", "This 3thrd string may be empty", 'V', "estring3", true, "undef3");
-
-		ReByteBuffer buffer;
-		const char* vector[] = {
-			"testprog",
-			"--boolval", "--boolval2=true", "--boolval3=f", "--boolval4=0",
-			"--intval=3",
-			"--string=x y", "--estring=", "--estring2=not empty",
-			"arg1", "arg2"
-		};
-		args.init(sizeof vector / sizeof vector[0], (char**) vector);
-
-		checkEqu("testprog", args.getProgramName());
-		checkT(args.getBool("boolarg"));
-		checkF(args.getBool("boolarg2"));
-		checkF(args.getBool("boolarg3"));
-		checkT(args.getBool("boolarg4"));
-		checkEqu(3, args.getInt("intarg"));
-		checkEqu("x y", args.getString("stringarg", buffer));
-		checkEqu("", args.getString("estringarg", buffer));
-		checkEqu("not empty", args.getString("estringarg2", buffer));
-		checkEqu("arg1", args.getArg(0));
-		checkEqu("arg2", args.getArg(1));
-		checkEqu(2, args.getArgCount());
-		args.help(NULL, false, stdout);
-	}
-};
-extern void testReProgramArgs(void);
-
-void testReProgramArgs(void){
-	TestReProgramArgs unit;
-}
-#endif /*RE_TESTUNIT*/
-
-
diff --git a/base/ReSeqList.cpp b/base/ReSeqList.cpp
index 4d5625a..9f5e3a7 100644
--- a/base/ReSeqList.cpp
+++ b/base/ReSeqList.cpp
@@ -5,7 +5,7 @@
  *      Author: wk
  */
 
-#include "rebase.hpp"
+#include "base/rebase.hpp"
 
 /** @brief Constructor.
  *
@@ -60,7 +60,7 @@ void ReSeqList::add(Index index, const Byte* source, size_t sourceLength, Tag ta
 	Sequence seq;
 	if (sourceLength == (size_t) -1)
 		sourceLength = strlen(source) + 1;
-	seq.m_index = m_content.getLength();
+	seq.m_index = m_content.length();
 	seq.m_length = sourceLength;
 	seq.m_tag = tag;
 	m_content.append(source, sourceLength);
@@ -82,8 +82,8 @@ void ReSeqList::add(Index index, const Byte* source, size_t sourceLength, Tag ta
 bool ReSeqList::get(Index index, ReByteBuffer& value, Tag* tag) const{
 	bool rc = false;
 	if (index < getCount()){
-		Sequence* seq = ((Sequence*)m_list.getBuffer()) + index;
-		value.set(m_content.getBuffer() + seq->m_index, seq->m_length);
+		Sequence* seq = ((Sequence*)m_list.buffer()) + index;
+		value.set(m_content.buffer() + seq->m_index, seq->m_length);
 		if (tag != NULL)
 			*tag = seq->m_tag;
 		rc = true;
@@ -107,12 +107,12 @@ void ReSeqList::set(Index index, const Byte* source, size_t sourceLength, Tag ta
 		seq->m_tag = tag;
 		if (seq->m_length >= sourceLength){
 			// Use the existing space:
-			memcpy(m_content.getBuffer() + seq->m_index, source, sourceLength);
+			memcpy(m_content.buffer() + seq->m_index, source, sourceLength);
 			m_lost += seq->m_length - sourceLength;
 		} else {
 			// New space must be allocated:
 			m_lost += seq->m_length;
-			seq->m_index = m_content.getLength();
+			seq->m_index = m_content.length();
 			m_content.append(source, sourceLength);
 		}
 	}
@@ -125,7 +125,7 @@ void ReSeqList::remove(Index index){
 	if (index <= getCount()){
 		Sequence* seq = getInfo(index);
 		// Is this the last entry in m_content?
-		if (seq->m_index + seq->m_length >= m_content.getLength()){
+		if (seq->m_index + seq->m_length >= m_content.length()){
 			// We can free the content:
 			m_content.setLength(seq->m_index);
 		} else {
@@ -143,106 +143,4 @@ void ReSeqList::clear(){
 	m_list.setLength(0);
 }
 
-#if defined RE_TESTUNIT
-class TestReSeqList : public ReTestUnit {
-public:
-	TestReSeqList() : ReTestUnit("ReSeqList", __FILE__){
-		run();
-	}
-private:
-	void run(){
-		testBase();
-		testRemove();
-	}
-	void testBase(){
-		ReSeqList list;
-		ReByteBuffer value;
-		ReSeqList::Tag tag = 0;
-
-		list.add(-1, "123", -1, 100);
-		checkEqu(1, list.getCount());
-		checkT(list.get(0, value, &tag));
-		checkEqu("123", value.str());
-		checkEqu(100, tag);
-
-		list.add(-1, "ab", -1, 200);
-		checkEqu(2, list.getCount());
-		checkT(list.get(0, value));
-		checkEqu("123", value.str());
-		checkT(list.get(1, value, &tag));
-		checkEqu("ab", value.str());
-		checkEqu(200, tag);
-
-		list.add(0, "xyz", -1, 300);
-		checkEqu(3, list.getCount());
-		checkT(list.get(0, value, &tag));
-		checkEqu("xyz", value.str());
-		checkT(list.get(1, value));
-		checkEqu("123", value.str());
-		checkT(list.get(2, value));
-		checkEqu("ab", value.str());
-		checkEqu(300, tag);
-
-		list.add(1, "vw", -1, 400);
-		checkEqu(4, list.getCount());
-		checkT(list.get(0, value));
-		checkEqu("xyz", value.str());
-		checkT(list.get(1, value, &tag));
-		checkEqu("vw", value.str());
-		checkT(list.get(2, value));
-		checkEqu("123", value.str());
-		checkT(list.get(3, value));
-		checkEqu("ab", value.str());
-		checkEqu(400, tag);
-
-		list.clear();
-		checkEqu(0, list.getCount());
-		checkF(list.get(0, value));
-	}
-	void testRemove(){
-		ReSeqList list;
-		ReByteBuffer value;
-		ReSeqList::Tag tag = 0;
-
-		list.add(-1, "abc", -1, 100);
-		list.add(-1, "def12", -1, 200);
-		list.add(-1, "ghi", -1, 300);
-		list.add(-1, "jkl134", -1, 400);
-
-		list.remove(3);
-		checkEqu(3, list.getCount());
-		list.get(0, value, &tag);
-		checkEqu("abc", value.str());
-		checkEqu(100, tag);
-		list.get(1, value, &tag);
-		checkEqu("def12", value.str());
-		checkEqu(200, tag);
-		list.get(2, value, &tag);
-		checkEqu("ghi", value.str());
-		checkEqu(300, tag);
-
-
-		list.remove(1);
-		checkEqu(2, list.getCount());
-		list.get(0, value, &tag);
-		checkEqu("abc", value.str());
-		checkEqu(100, tag);
-		list.get(1, value, &tag);
-		checkEqu("ghi", value.str());
-		checkEqu(300, tag);
-
-		list.remove(0);
-		checkEqu(1, list.getCount());
-		list.get(0, value, &tag);
-		checkEqu("ghi", value.str());
-		checkEqu(300, tag);
-
-	}
-};
-extern void testReSeqList(void);
-
-void testReSeqList(void){
-	TestReSeqList unit;
-}
-#endif /*RE_TESTUNIT*/
 
diff --git a/base/ReSeqList.hpp b/base/ReSeqList.hpp
index 34c938f..5299cec 100644
--- a/base/ReSeqList.hpp
+++ b/base/ReSeqList.hpp
@@ -25,7 +25,7 @@ class ReSeqList {
 public:
 	typedef char Byte;
 	typedef unsigned int Index;
-	typedef long int Tag;
+	typedef int64_t Tag;
 	typedef struct {
 		Index 	m_index;
 		size_t 	m_length;
@@ -46,14 +46,14 @@ public:
 	 * @return The number of defined entries in the list (array).
 	 */
 	inline Index getCount() const {
-		return m_list.getLength() / sizeof (Sequence);
+		return m_list.length() / sizeof (Sequence);
 	}
 protected:
 	/** @brief Returns a pointer of the content buffer.
 	 * @return A pointer of the first byte of the content buffer.
 	 */
 	inline const Byte* getContent() const {
-		return m_content.getBuffer();
+		return m_content.buffer();
 	}
 	friend class ReHashList;
 	/** @brief Returns the info of an entry of the list.
@@ -61,7 +61,7 @@ protected:
 	 * @return The pointer of the entry.
 	 */
 	inline Sequence* getInfo(Index index) const {
-		return &((Sequence*) m_list.getBuffer())[index];
+		return &((Sequence*) m_list.buffer())[index];
 	}
 
 protected:
diff --git a/base/ReStringList.cpp b/base/ReStringList.cpp
index 6d4930f..37a66f5 100644
--- a/base/ReStringList.cpp
+++ b/base/ReStringList.cpp
@@ -5,7 +5,7 @@
  *      Author: wk
  */
 
-#include "../base/restring.hpp"
+#include "base/rebase.hpp"
 
 /** @brief Constructor.
  */
@@ -23,11 +23,11 @@ ReStringList::~ReStringList() {
 /** @brief Appends a string at the end.
  *
  * @param source	The new string.
- * @param tag		An item which will stored with the string. It can be retrieved by the same index.
+ * @param tagOf		An item which will stored with the string. It can be retrieved by the same index.
  * 				T	his class knows nothing about this.
  */
-void ReStringList::append(const char* source, Tag tag){
-	add(-1, source, -1, tag);
+void ReStringList::append(const char* source, Tag tagOf){
+	add(-1, source, -1, tagOf);
 }
 /** @brief Appends a stringlist at the end.
  *
@@ -35,31 +35,31 @@ void ReStringList::append(const char* source, Tag tag){
  */
 void ReStringList::append(ReStringList& source){
 	for (size_t ii = 0; ii < source.getCount(); ii++)
-		add(-1, source.getCStr(ii), -1, source.getTag(ii));
+		add(-1, source.strOf(ii), -1, source.tagOf(ii));
 }
 /** @brief Inserts a string at a given index.
  *
  * If the index exceeds the length of the array it will be appended.
  *
  * @param source	The new string.
- * @param tag		An item which will stored with the string. It can be retrieved by the same index.
+ * @param tagOf		An item which will stored with the string. It can be retrieved by the same index.
  * 					This class knows nothing about this.
  */
-void ReStringList::insert(Index index, const char* source, Tag tag){
-	add(index, source, -1, tag);
+void ReStringList::insert(Index index, const char* source, Tag tagOf){
+	add(index, source, -1, tagOf);
 }
-/** @brief Replaces an element in the internal array: a string and a tag.
+/** @brief Replaces an element in the internal array: a string and a tagOf.
  *
  * @param index 	The element with this index will be replaced.
  * @param source	The new string of the replaced element.
- * @param tag		The tag of the replace element.
+ * @param tagOf		The tagOf of the replace element.
  */
-void ReStringList::replace(Index index, const char* source, Tag tag){
-	set(index, source, -1, tag);
+void ReStringList::replace(Index index, const char* source, Tag tagOf){
+	set(index, source, -1, tagOf);
 }
 /** @brief Replaces a string in the internal array.
  *
- * The tag of the element remains unchanged.
+ * The tagOf of the element remains unchanged.
  *
  * @param index 	The element with this index will be replaced.
  * @param source	The new string of the replaced element.
@@ -70,17 +70,17 @@ void ReStringList::replaceString(Index index, const char* source){
 		set(index, source, -1, seq->m_tag);
 	}
 }
-/** @brief Replaces a tag in the internal array.
+/** @brief Replaces a tagOf in the internal array.
  *
  * The string of the element remains unchanged.
  *
  * @param index 	The element with this index will be replaced.
  * @param source	The new string of the replaced element.
  */
-void ReStringList::replaceTag(Index index, Tag tag){
+void ReStringList::replaceTag(Index index, Tag tagOf){
 	if (index < getCount()){
 		Sequence* seq = getInfo(index);
-		seq->m_tag = tag;
+		seq->m_tag = tagOf;
 	}
 }
 
@@ -91,24 +91,24 @@ void ReStringList::replaceTag(Index index, Tag tag){
  * @return 	NULL: The index is too large.
  * 			Otherwise: The wanted string.
  */
-const char* ReStringList::getCStr(Index index) const{
+const char* ReStringList::strOf(Index index) const{
 	const char* rc = NULL;
 	if (index < getCount()){
 		Sequence* seq = getInfo(index);
-		rc = m_content.getBuffer() + seq->m_index;
+		rc = m_content.buffer() + seq->m_index;
 	}
 	return rc;
 }
-/** @brief Returns the tag given by an index.
+/** @brief Returns the tagOf given by an index.
  *
- * A tag is an additional info stored with the string.
+ * A tagOf is an additional info stored with the string.
  *
- * @param index		The index of the wanted tag.
+ * @param index		The index of the wanted tagOf.
  *
  * @return 	-1: The index is too large.
- * 			Otherwise: The wanted tag.
+ * 			Otherwise: The wanted tagOf.
  */
-ReSeqList::Tag ReStringList::getTag(Index index) const{
+ReSeqList::Tag ReStringList::tagOf(Index index) const{
 	Tag rc = -1;
 	if (index < getCount()){
 		Sequence* seq = getInfo(index);
@@ -116,14 +116,15 @@ ReSeqList::Tag ReStringList::getTag(Index index) const{
 	}
 	return rc;
 }
-/** @brief Returns the length of the string given by an index.
+/** @brief Returns the length of the byte sequence given by an index.
  *
  * @param index		The index of the wanted string length.
  *
  * @return 	0: The index is too large.
- * 			Otherwise: The length of the <code>index</code>-th string.
+ * 			Otherwise: The length of the <code>index</code>-th sequence
+ * 			(including the trailing '\0').
  */
-size_t ReStringList::ReStringList::getLength(Index index) const{
+size_t ReStringList::sizeOf(Index index) const{
 	size_t rc = 0;
 	if (index < getCount()){
 		Sequence* seq = getInfo(index);
@@ -131,11 +132,27 @@ size_t ReStringList::ReStringList::getLength(Index index) const{
 	}
 	return rc;
 }
+/** @brief Returns the length of the string given by an index.
+ *
+ * @param index		The index of the wanted string length.
+ *
+ * @return 	0: The index is too large.
+ * 			Otherwise: The length of the <code>index</code>-th sequence
+ * 			(excluding the trailing '\0').
+ */
+size_t ReStringList::strLengthOf(Index index) const{
+	size_t rc = 0;
+	if (index < getCount()){
+		Sequence* seq = getInfo(index);
+		rc = seq->m_length - 1;
+	}
+	return rc;
+}
 /** @brief Returns the sum of all string lengths stored in the array.
  *
  * @return The sum of all string lengths stored in the array.
  */
-size_t ReStringList::sumOfLength() const{
+size_t ReStringList::sumOfSizes() const{
 	size_t rc = 0;
 
 	for (int ii = getCount() - 1; ii >= 0; ii--){
@@ -144,6 +161,19 @@ size_t ReStringList::sumOfLength() const{
 	}
 	return rc;
 }
+/** @brief Returns the sum of all string lengths stored in the array.
+ *
+ * @return The sum of all string lengths stored in the array.
+ */
+size_t ReStringList::sumOfStrLengths() const{
+	size_t rc = 0;
+
+	for (int ii = getCount() - 1; ii >= 0; ii--){
+		Sequence* seq = getInfo(ii);
+		rc += seq->m_length - 1;
+	}
+	return rc;
+}
 /** @brief Returns the index of a given string in the array.
  *
  * @param toFind		The string which will be searched.
@@ -158,8 +188,8 @@ ReSeqList::Index ReStringList::indexOf(const char* toFind,
 	Index rc = (Index) -1;
 	Index count = getCount();
 
-	for (; rc == (size_t) -1 && start < count; start++){
-		const char* item = getCStr(start);
+	for (; rc == (Index) -1 && start < count; start++){
+		const char* item = strOf(start);
 		int rc2;
 		if (ignoreCase)
 			rc2 = strcasecmp(item, toFind);
@@ -185,8 +215,8 @@ ReSeqList::Index ReStringList::nextStartingWith(Index start,
 	Index count = getCount();
 	size_t length = strlen(prefix);
 
-	for (; rc == (size_t) -1 && start < count; start++){
-		const char* item = getCStr(start);
+	for (; rc == (Index) -1 && start < count; start++){
+		const char* item = strOf(start);
 		int rc2;
 		if (ignoreCase)
 			rc2 = strncasecmp(item, prefix, length);
@@ -221,7 +251,7 @@ void ReStringList::split(const char* list, char separator, bool append){
 		item.append(list, length);
 		// Append '\0':
 		item.append("", 1);
-		add(-1, item.getBuffer(), length + 1);
+		add(-1, item.buffer(), length + 1);
 		list = end + 1;
 		if (separator == '\n' && list[0] == '\r')
 			list++;
@@ -242,7 +272,7 @@ void ReStringList::join(const char* separator, ReByteBuffer& result){
 	size_t lengthSep = strlen(separator);
 
 	for (size_t ix = 0; ix < count; ix++){
-		result.append(getCStr(ix), getLength(ix) - 1);
+		result.append(strOf(ix), sizeOf(ix) - 1);
 		if (ix != count - 1 && separator != NULL)
 			result.append(separator, lengthSep);
 	}
@@ -262,7 +292,7 @@ bool ReStringList::writeToFile(const char* filename,
 	if (fp){
 		size_t count = getCount();
 		for (size_t ix = 0; ix < count; ix++){
-			fputs(getCStr(ix), fp);
+			fputs(strOf(ix), fp);
 			if (ix != count - 1 && separator != NULL)
 				fputs(separator, fp);
 		}
@@ -295,6 +325,7 @@ bool ReStringList::readFromFile(const char* filename, bool cutNewline){
 			}
 			add(-1, line, length + 1);
 		}
+		fclose(fp);
 	}
 	return rc;
 }
@@ -312,8 +343,8 @@ int ReStringList::firstDiff(const ReStringList& toCompare) const{
 	for (size_t ix = 0; rc == -1 && ix < getCount(); ix++){
 		if (ix >= toCompare.getCount())
 			rc = (int) ix;
-		else if (getLength(ix) != toCompare.getLength(ix)
-				|| strcmp(getCStr(ix), toCompare.getCStr(ix)) != 0)
+		else if (sizeOf(ix) != toCompare.sizeOf(ix)
+				|| strcmp(strOf(ix), toCompare.strOf(ix)) != 0)
 			rc = (int) ix;
 	}
 	if (rc == -1 && getCount() < toCompare.getCount())
@@ -334,264 +365,3 @@ bool ReStringList::equal(const ReStringList& toCompare) const{
 	bool rc = getCount() == toCompare.getCount() && firstDiff(toCompare) == -1;
 	return rc;
 }
-
-#if defined RE_TESTUNIT
-class TestReStringList : public ReTestUnit {
-public:
-	TestReStringList() : ReTestUnit("ReStringList", __FILE__){
-		run();
-	}
-private:
-	void run(){
-		testBase();
-		testReplace();
-		testJoin();
-		testEqu();
-		testFile();
-	}
-	void testReplace(){
-		ReStringList list;
-
-		list.append("123", 100);
-		checkEqu(100, list.getTag(0));
-		list.append("2", 200);
-		checkEqu(100, list.getTag(0));
-		checkEqu(200, list.getTag(1));
-		list.append("34", 300);
-		checkEqu(100, list.getTag(0));
-		checkEqu(200, list.getTag(1));
-		checkEqu(300, list.getTag(2));
-
-		list.replace(0, "1", 111);
-		checkEqu("1", list.getCStr(0));
-		checkEqu(111, list.getTag(0));
-		checkEqu(200, list.getTag(1));
-		checkEqu(300, list.getTag(2));
-
-		list.replace(1, "124", 222);
-		checkEqu("124", list.getCStr(1));
-		checkEqu(111, list.getTag(0));
-		checkEqu(222, list.getTag(1));
-		checkEqu(300, list.getTag(2));
-
-		checkEqu(300, list.getTag(2));
-		list.replaceString(2, "4");
-		checkEqu("4", list.getCStr(2));
-		checkEqu(111, list.getTag(0));
-		checkEqu(222, list.getTag(1));
-		checkEqu(300, list.getTag(2));
-
-		list.replaceTag(2, 123);
-		checkEqu("4", list.getCStr(2));
-		checkEqu(111, list.getTag(0));
-		checkEqu(222, list.getTag(1));
-		checkEqu(123, list.getTag(2));
-	}
-	void testEqu(){
-		ReStringList list1;
-		ReStringList list2;
-
-		list1.split("1;2;1;3", ';');
-		list2.split("1\n2\n1\n3", '\n');
-		checkEqu(-1, list1.firstDiff(list2));
-		checkEqu(-1, list2.firstDiff(list1));
-		checkT(list1.equal(list2));
-		checkT(list2.equal(list1));
-
-		list1.insert(2, "x");
-		list1.remove(3);
-		checkEqu(2, list1.firstDiff(list2));
-		checkEqu(2, list2.firstDiff(list1));
-		checkF(list1.equal(list2));
-		checkF(list2.equal(list1));
-
-		list2.replace(2, "x");
-		checkEqu(-1, list1.firstDiff(list2));
-		checkEqu(-1, list2.firstDiff(list1));
-		checkT(list1.equal(list2));
-		checkT(list2.equal(list1));
-
-		list2.remove(3);
-		checkEqu(3, list1.firstDiff(list2));
-		checkEqu(3, list2.firstDiff(list1));
-		checkF(list1.equal(list2));
-		checkF(list2.equal(list1));
-
-		list1.replace(0, "");
-		checkEqu(0, list1.firstDiff(list2));
-		checkEqu(0, list2.firstDiff(list1));
-		checkF(list1.equal(list2));
-		checkF(list2.equal(list1));
-
-		list1.clear();
-		list2.clear();
-		checkEqu(-1, list1.firstDiff(list2));
-		checkEqu(-1, list2.firstDiff(list1));
-		checkT(list1.equal(list2));
-		checkT(list2.equal(list1));
-
-		list1.append("fjkdajfdkla");
-		checkEqu(0, list1.firstDiff(list2));
-		checkEqu(0, list2.firstDiff(list1));
-		checkF(list1.equal(list2));
-		checkF(list2.equal(list1));
-	}
-	void testJoin(){
-		ReStringList list;
-		const char* str = "1;abc;xyz;4;;99";
-		list.split(str, ';');
-		checkEqu(6, list.getCount());
-		checkEqu("1", list.getCStr(0));
-		checkEqu("abc", list.getCStr(1));
-		checkEqu("xyz", list.getCStr(2));
-		checkEqu("4", list.getCStr(3));
-		checkEqu("", list.getCStr(4));
-		checkEqu("99", list.getCStr(5));
-		ReByteBuffer value;
-		list.join(";", value);
-		checkEqu(str, value.str());
-
-		list.split("1\r\n2\n\r3", '\n');
-		checkEqu(3, list.getCount());
-		checkEqu("1", list.getCStr(0));
-		checkEqu("2", list.getCStr(1));
-		checkEqu("3", list.getCStr(2));
-
-		list.split("xyz\tXYZ", '\t', true);
-		checkEqu(5, list.getCount());
-		checkEqu("1", list.getCStr(0));
-		checkEqu("2", list.getCStr(1));
-		checkEqu("3", list.getCStr(2));
-		checkEqu("xyz", list.getCStr(3));
-		checkEqu("XYZ", list.getCStr(4));
-
-
-	}
-	void testFile(){
-		createTestDir();
-		ReByteBuffer file;
-		file.set(getTestDir(), -1).append("abc.csv", -1);
-
-		ReStringList list;
-		const char* str = "1;abc;xyz;4;;99";
-		list.split(str, ';');
-		list.writeToFile(file.str(), "\n");
-
-		ReStringList list2;
-		list2.readFromFile(file.str(), true);
-
-		checkEqu(-1, list2.firstDiff(list2));
-	}
-	void testBase(){
-		ReStringList list;
-		ReByteBuffer value;
-
-		list.append("123", 100);
-		list.append("a", 200);
-		list.append("vwxyz", 300);
-
-		checkEqu(3, list.getCount());
-		int index = 0;
-		checkEqu("123", list.getCStr(index));
-		checkEqu(4, list.getLength(index));
-		checkEqu(100, list.getTag(index));
-
-		index++;
-		checkEqu("a", list.getCStr(index));
-		checkEqu(2, list.getLength(index));
-		checkEqu(200, list.getTag(index));
-
-		index++;
-		checkEqu("vwxyz", list.getCStr(index));
-		checkEqu(6, list.getLength(index));
-		checkEqu(300, list.getTag(index));
-
-		checkEqu(12, list.sumOfLength());
-
-		list.insert(0, "0", 50);
-		checkEqu(4, list.getCount());
-		checkEqu(14, list.sumOfLength());
-
-		index = 0;
-		checkEqu("0", list.getCStr(index));
-		checkEqu(2, list.getLength(index));
-		checkEqu(50, list.getTag(index));
-
-		index++;
-		checkEqu("123", list.getCStr(index));
-		checkEqu(4, list.getLength(index));
-		checkEqu(100, list.getTag(index));
-
-		index++;
-		checkEqu("a", list.getCStr(index));
-		checkEqu(2, list.getLength(index));
-		checkEqu(200, list.getTag(index));
-
-		index++;
-		checkEqu("vwxyz", list.getCStr(index));
-		checkEqu(6, list.getLength(index));
-		checkEqu(300, list.getTag(index));
-
-		checkEqu(0, list.indexOf("0"));
-		checkEqu(1, list.indexOf("123"));
-		checkEqu(2, list.indexOf("a"));
-		checkEqu(2, list.indexOf("A", true));
-		checkEqu(3, list.indexOf("vwxyz"));
-		checkEqu(3, list.indexOf("VwXyz", true));
-
-		checkEqu(0, list.indexOf("0", false, 0));
-		checkEqu(1, list.indexOf("123", false, 1));
-		checkEqu(2, list.indexOf("a", false, 1));
-		checkEqu(2, list.indexOf("a", false, 2));
-		checkEqu(2, list.indexOf("A", true, 2));
-		checkEqu(3, list.indexOf("vwxyz", false, 2));
-		checkEqu(3, list.indexOf("vwxyz", false, 3));
-		checkEqu(3, list.indexOf("VwXyz", true, 3));
-
-		checkEqu(-1, list.indexOf("A"));
-		checkEqu(-1, list.indexOf("0123"));
-		checkEqu(-1, list.indexOf("a", false, 3));
-		checkEqu(-1, list.indexOf("A", true, 3));
-
-		checkEqu(0, list.nextStartingWith(0, "0"));
-		checkEqu(1, list.nextStartingWith(0, "12"));
-		checkEqu(2, list.nextStartingWith(0, "a"));
-		checkEqu(2, list.nextStartingWith(1, "a"));
-		checkEqu(2, list.nextStartingWith(2, "a"));
-		checkEqu(2, list.nextStartingWith(0, "A", true));
-		checkEqu(-1, list.nextStartingWith(2, "Ab", true));
-		checkEqu(-1, list.nextStartingWith(0, "b", true));
-
-		checkEqu(3, list.nextStartingWith(0, "vwxy", false));
-		checkEqu(3, list.nextStartingWith(0, "vwxy", true));
-		checkEqu(-1, list.nextStartingWith(0, "vWxY", false));
-
-		ReStringList list2;
-		list2.append("a", 100);
-		list2.append("b", 200);
-		list2.append("c", 300);
-		ReStringList list3;
-		list3.append("x", 1000);
-		list3.append("y", 2000);
-
-		list2.append(list3);
-		checkEqu(5, list2.getCount());
-		checkEqu("a", list2.getCStr(0));
-		checkEqu(100, list2.getTag(0));
-		checkEqu("b", list2.getCStr(1));
-		checkEqu(200, list2.getTag(1));
-		checkEqu("c", list2.getCStr(2));
-		checkEqu(300, list2.getTag(2));
-		checkEqu("x", list2.getCStr(3));
-		checkEqu(1000, list2.getTag(3));
-		checkEqu("y", list2.getCStr(4));
-		checkEqu(2000, list2.getTag(4));
-	}
-};
-extern void testReStringList(void);
-
-void testReStringList(void){
-	TestReStringList unit;
-}
-#endif /*RE_TESTUNIT*/
-
diff --git a/base/ReStringList.hpp b/base/ReStringList.hpp
index ceb35da..3ead88d 100644
--- a/base/ReStringList.hpp
+++ b/base/ReStringList.hpp
@@ -35,21 +35,22 @@ public:
 public:
 	void append(const char* source, Tag tag = 0);
 	void append(ReStringList& source);
+	Index indexOf(const char* toFind, bool ignoreCase = false, Index start = 0) const;
 	void insert(Index index, const char* source, Tag tag = 0);
+	void join(const char* separator, ReByteBuffer& result);
+	Index nextStartingWith(Index index, const char* prefix, bool ignoreCase = false);
 	void replace(Index index, const char* source, Tag tag = 0);
 	void replaceString(Index index, const char* source);
 	void replaceTag(Index index, Tag tag);
+	const char* strOf(Index index) const;
+	size_t sizeOf(Index index) const;
+	void split(const char* list, char separator, bool append = false);
+	size_t strLengthOf(Index index) const;
+	size_t sumOfSizes() const;
+	size_t sumOfStrLengths() const;
+	Tag tagOf(Index index) const;
 
-	const char* getCStr(Index index) const;
-	Tag getTag(Index index) const;
-	size_t getLength(Index index) const;
-	size_t sumOfLength() const;
 
-	Index indexOf(const char* toFind, bool ignoreCase = false, Index start = 0) const;
-	Index nextStartingWith(Index index, const char* prefix, bool ignoreCase = false);
-
-	void split(const char* list, char separator, bool append = false);
-	void join(const char* separator, ReByteBuffer& result);
 
 	int firstDiff(const ReStringList& toCompare) const;
 	bool equal(const ReStringList& toCompare) const;
diff --git a/base/ReStringUtils.cpp b/base/ReStringUtils.cpp
index 794a2be..e3dc476 100644
--- a/base/ReStringUtils.cpp
+++ b/base/ReStringUtils.cpp
@@ -5,7 +5,7 @@
  *      Author: wk
  */
 
-#include "../base/restring.hpp"
+#include "base/rebase.hpp"
 
 char ReStringUtils::slash = ReStringUtils::initPathSeparator();
 const char* ReStringUtils::slashStr = NULL;
@@ -224,190 +224,3 @@ bool ReStringUtils::isInList(const char* phrase, const char* list,
 	}
 	return rc;
 }
-
-#if defined RE_TESTUNIT
-class TestReStringUtils : public ReTestUnit {
-public:
-	TestReStringUtils() : ReTestUnit("ReStringUtils", __FILE__){
-		run();
-	}
-private:
-	void run(){
-		testStrnicmp();
-		testIsInList();
-		testSplitPath();
-	}
-	void testStrnicmp(){
-		checkT(ReStringUtils::strnicmp("abc", "abc", 3) == 0);
-		checkT(ReStringUtils::strnicmp("abc", "ab", 3) > 0);
-		checkT(ReStringUtils::strnicmp("ab", "abc", 3) < 0);
-
-		checkT(ReStringUtils::strnicmp("aBc", "Abc", 3) == 0);
-		checkT(ReStringUtils::strnicmp("Abc", "aB", 3) > 0);
-		checkT(ReStringUtils::strnicmp("AB", "abc", 3) < 0);
-
-		checkT(ReStringUtils::strnicmp("ABC", "ABD", 2) == 0);
-		checkT(ReStringUtils::strnicmp("abC", "ABD", 2) == 0);
-
-		checkT(ReStringUtils::strnicmp("AAC", "ABD", 2) < 0);
-		checkT(ReStringUtils::strnicmp("aaC", "ABD", 2) < 0);
-
-		checkT(ReStringUtils::strnicmp("", "x", 99) < 0);
-		checkT(ReStringUtils::strnicmp("x", "", 99) > 0);
-
-		checkT(ReStringUtils::strnicmp("abc", "abc", 99) == 0);
-		checkT(ReStringUtils::strnicmp("abc", "ab", 99) > 0);
-		checkT(ReStringUtils::strnicmp("ab", "abc", 99) < 0);
-	}
-	void testIsInList(){
-		checkT(ReStringUtils::isInList("abc", ";abc;def", true));
-		checkT(ReStringUtils::isInList("aBc", ";abc;def", true));
-		checkF(ReStringUtils::isInList("aBc", ";abc;def", false));
-
-		checkF(ReStringUtils::isInList("aBc", ";abc;def", false));
-
-		checkT(ReStringUtils::isInList("abc", ";a;abc;def", true));
-		checkT(ReStringUtils::isInList("aBc", ";b;abc;def", true));
-		checkF(ReStringUtils::isInList("aBc", ";c;abc;def", false));
-
-		checkF(ReStringUtils::isInList("aBc", ";a;abcabc;def", false));
-
-		checkT(ReStringUtils::isInList("abc", ";abc", true));
-		checkT(ReStringUtils::isInList("aBc", ";abc", true));
-		checkF(ReStringUtils::isInList("aBc", ";abc", false));
-
-		checkF(ReStringUtils::isInList("aBc", ";abc", false));
-
-	}
-	void testSplitPath(){
-		ReByteBuffer fullname, protocol, path, name, ext;
-		const char* fn = "file:/etc/samba/smb.cnf";
-
-		ReStringUtils::splitPath(fn, &protocol, &path, &name, &ext);
-		checkEqu("file:", protocol.str());
-		checkEqu("/etc/samba/", path.str());
-		checkEqu("smb", name.str());
-		checkEqu(".cnf", ext.str());
-
-		ReStringUtils::joinPath(fullname, &protocol, &path, &name, &ext);
-		checkEqu(fn, fullname.str());
-
-		fn = "/etc/samba/smb.cnf";
-
-		ReStringUtils::splitPath(fn, &protocol, &path, &name, &ext);
-		checkEqu("", protocol.str());
-		checkEqu("/etc/samba/", path.str());
-		checkEqu("smb", name.str());
-		checkEqu(".cnf", ext.str());
-
-		ReStringUtils::joinPath(fullname, &protocol, &path, &name, &ext);
-		checkEqu(fn, fullname.str());
-
-		fn = "smb.cnf";
-
-		ReStringUtils::splitPath(fn, &protocol, &path, &name, &ext);
-		checkEqu("", protocol.str());
-		checkEqu("", path.str());
-		checkEqu("smb", name.str());
-		checkEqu(".cnf", ext.str());
-
-		ReStringUtils::joinPath(fullname, &protocol, &path, &name, &ext);
-		checkEqu(fn, fullname.str());
-
-		fn = "smb";
-
-		ReStringUtils::splitPath(fn, &protocol, &path, &name, &ext);
-		checkEqu("", protocol.str());
-		checkEqu("", path.str());
-		checkEqu("smb", name.str());
-		checkEqu("", ext.str());
-
-		ReStringUtils::joinPath(fullname, &protocol, &path, &name, &ext);
-		checkEqu(fn, fullname.str());
-
-		fn = "file:smb.003.cnf";
-
-		ReStringUtils::splitPath(fn, &protocol, &path, &name, &ext);
-		checkEqu("file:", protocol.str());
-		checkEqu("", path.str());
-		checkEqu("smb.003", name.str());
-		checkEqu(".cnf", ext.str());
-
-		ReStringUtils::joinPath(fullname, &protocol, &path, &name, &ext);
-		checkEqu(fn, fullname.str());
-
-		fn = "file:/etc.bak/smb";
-
-		ReStringUtils::splitPath(fn, &protocol, &path, &name, &ext);
-		checkEqu("file:", protocol.str());
-		checkEqu("/etc.bak/", path.str());
-		checkEqu("smb", name.str());
-		checkEqu("", ext.str());
-
-		ReStringUtils::joinPath(fullname, &protocol, &path, &name, &ext);
-		checkEqu(fn, fullname.str());
-
-		fn = "file:/etc/samba/smb.cnf";
-
-		ReStringUtils::splitPath(fn, NULL, &path, &name, &ext);
-		checkEqu("file:", protocol.str());
-		checkEqu("smb", name.str());
-		checkEqu(".cnf", ext.str());
-
-		ReStringUtils::joinPath(fullname, &protocol, NULL, &name, &ext);
-		checkEqu("file:smb.cnf", fullname.str());
-
-		fn = "file:/etc/samba/smb.cnf";
-
-		ReStringUtils::splitPath(fn, NULL, NULL, &name, &ext);
-		checkEqu("smb", name.str());
-		checkEqu(".cnf", ext.str());
-
-		ReStringUtils::joinPath(fullname, NULL, NULL, &name, &ext);
-		checkEqu("smb.cnf", fullname.str());
-
-		fn = "file:/etc/samba/smb.cnf";
-
-		ReStringUtils::splitPath(fn, NULL, NULL, &name, NULL);
-		//checkEqu("", protocol.str());
-		//checkEqu("/etc/samba/", path.str());
-		checkEqu("smb", name.str());
-		//checkEqu(".cnf", ext.str());
-
-		ReStringUtils::joinPath(fullname, NULL, NULL, &name, NULL);
-		checkEqu("smb", fullname.str());
-
-		fn = "file:/etc/samba/smb.cnf";
-
-		ReStringUtils::splitPath(fn, NULL, &path, NULL, &ext);
-		//checkEqu("", protocol.str());
-		checkEqu("/etc/samba/", path.str());
-		//checkEqu("smb", name.str());
-		checkEqu(".cnf", ext.str());
-
-		ReStringUtils::joinPath(fullname, NULL, &path, NULL, &ext);
-		checkEqu("/etc/samba/.cnf", fullname.str());
-
-		ReStringUtils::joinPath(fullname, "http:", "//any.de/", "name", ".ext");
-		checkEqu("http://any.de/name.ext", fullname.str());
-
-		ReStringUtils::joinPath(fullname, NULL, "/any.de/", "name", ".ext");
-		checkEqu("/any.de/name.ext", fullname.str());
-
-		ReStringUtils::joinPath(fullname, NULL, NULL, "name", ".ext");
-		checkEqu("name.ext", fullname.str());
-
-		ReStringUtils::joinPath(fullname, NULL, NULL, "name", NULL);
-		checkEqu("name", fullname.str());
-
-		ReStringUtils::joinPath(fullname, "file:", "/", NULL, NULL);
-		checkEqu("file:/", fullname.str());
-	}
-};
-extern void testReStringUtils(void);
-
-void testReStringUtils(void){
-	TestReStringUtils unit;
-}
-#endif /*RE_TESTUNIT*/
-
diff --git a/base/ReTestUnit.cpp b/base/ReTestUnit.cpp
index 4d72caa..8efab79 100644
--- a/base/ReTestUnit.cpp
+++ b/base/ReTestUnit.cpp
@@ -4,9 +4,7 @@
  *  Created on: 04.05.2010
  *      Author: wk
  */
-#include <stdarg.h>
-
-#include "rebase.hpp"
+#include "base/rebase.hpp"
 /** @brief Constructor.
  *
  * @param name			The name of the test class.
@@ -15,9 +13,9 @@
  */
 ReTestUnit::ReTestUnit(const char* name, const char* sourceFile)
 	:
-	m_name(strdup(name)),
+	m_name(_strdup(name)),
 	m_errorCount(0),
-	m_sourceFile(strdup(sourceFile))
+	m_sourceFile(_strdup(sourceFile))
 {
 	logF(false, i18n("Start %s"), name);
 }
@@ -86,13 +84,39 @@ void ReTestUnit::assertNotNull(void* pointer, int lineNo){
  * @param current		The current value.
  * @param lineNo		The line number of the test (for the error messge).
  */
-void ReTestUnit::assertEqual(long expected, long current, int lineNo){
+void ReTestUnit::assertEqual(int expected, int current, int lineNo){
+	if (expected != current){
+		logF(true, i18n("%s-%d: expected: %ld (%lx) current: %ld (%lx)"),
+			m_sourceFile, lineNo, expected, expected, current, current);
+		m_errorCount++;
+	}
+}
+/** @brief Compares two integer values. If not equal this will be logged.
+ *
+ * @param expected		The expected value
+ * @param current		The current value.
+ * @param lineNo		The line number of the test (for the error messge).
+ */
+void ReTestUnit::assertEqual(unsigned int expected, unsigned int current, int lineNo){
 	if (expected != current){
 		logF(true, i18n("%s-%d: expected: %ld (%lx) current: %ld (%lx)"),
 			m_sourceFile, lineNo, expected, expected, current, current);
 		m_errorCount++;
 	}
 }
+/** @brief Compares two integer values. If not equal this will be logged.
+ *
+ * @param expected		The expected value
+ * @param current		The current value.
+ * @param lineNo		The line number of the test (for the error messge).
+ */
+void ReTestUnit::assertEqual(int64_t expected, int64_t current, int lineNo){
+	if (expected != current){
+		logF(true, i18n("%s-%d: expected: %lld (%llx) current: %lld (%llx)"),
+			m_sourceFile, lineNo, expected, expected, current, current);
+		m_errorCount++;
+	}
+}
 /** @brief Compares two string values. If not equal this will be logged.
  *
  * @param expected		The expected value
@@ -118,7 +142,7 @@ void ReTestUnit::assertFileExists(const char* name, int lineNo){
 		logF(true, i18n("%s-%d: File does not exist: %s"),
 			m_sourceFile, lineNo, name);
 		m_errorCount++;
-	} else if ((info.st_mode & __S_IFDIR) != 0){
+	} else if (S_ISDIR(info.st_mode)){
 		logF(true, i18n("%s-%d: File does exist but this is a directory: %s"),
 			m_sourceFile, lineNo, name);
 		m_errorCount++;
@@ -142,6 +166,11 @@ void ReTestUnit::createTestDir(){
 	strcat(ptr, "retestunit");
 	strcat(ptr, ReStringUtils::pathSeparatorStr());
 	struct stat info;
+#ifdef __WIN32__
+#define lstat stat
+#define mkdir(name, flags) _mkdir(name)
+#define ALLPERMS 0
+#endif
 	if (lstat(name, &info) != 0)
 		mkdir(name, ALLPERMS);
 	else{
@@ -191,7 +220,7 @@ void ReTestUnit::assertDirExists(const char* dir, int lineNo){
 		logF(true, i18n("%s-%d: Directory does not exist: %s"),
 			m_sourceFile, lineNo, dir);
 		m_errorCount++;
-	} else if ((info.st_mode & __S_IFDIR) == 0){
+	} else if (! S_ISDIR(info.st_mode)){
 		logF(true, i18n("%s-%d: File exists but this is not a directory: %s"),
 			m_sourceFile, lineNo, dir);
 		m_errorCount++;
diff --git a/base/ReTestUnit.hpp b/base/ReTestUnit.hpp
index 3a8bc6c..94c7c2a 100644
--- a/base/ReTestUnit.hpp
+++ b/base/ReTestUnit.hpp
@@ -22,7 +22,9 @@ public:
 	void assertFalse(bool conditon, int lineNo);
 	void assertNull(void* pointer, int lineNo);
 	void assertNotNull(void* pointer, int lineNo);
-	void assertEqual(long expected, long current, int lineNo);
+    void assertEqual(int64_t expected, int64_t current, int lineNo);
+	void assertEqual(int expected, int current, int lineNo);
+	void assertEqual(unsigned int expected, unsigned int current, int lineNo);
 	void assertEqual(const char* expected, const char* current, int lineNo);
 
 	void createTestDir();
diff --git a/base/ReVarArgs.cpp b/base/ReVarArgs.cpp
index 96e8eea..262bc5d 100644
--- a/base/ReVarArgs.cpp
+++ b/base/ReVarArgs.cpp
@@ -14,7 +14,7 @@
  *     .arg(info.st_size, "%8d").arg(info.st_size, "%8x").asCString();
  * </code></pre>
  */
-#include "rebase.hpp"
+#include "base/rebase.hpp"
 
 int const ReVarArgs::STD_SPACE = 20;
 char const ReVarArgs::PLACE_HOLDER_MARK = '$';
@@ -132,10 +132,10 @@ void ReVarArgs::replacePlaceholder(){
 			}
 			if (argNo > m_argNo){
 				throw ReFormatException(i18n("Too large argument number: "),
-					m_format.getBuffer() + position,
+					m_format.buffer() + position,
 					 __FILE__, __LINE__);
 			} else {
-				char* arg = m_argBuffer.getBuffer() + m_args[argNo];
+				char* arg = m_argBuffer.buffer() + m_args[argNo];
 				size_t argLen = strlen(arg);
 				m_format.splice(position, argNoLen, arg, argLen);
 				position += argLen;
@@ -145,7 +145,7 @@ void ReVarArgs::replacePlaceholder(){
 	}
 	if (found < m_argNo)
 		throw ReFormatException(i18n("Format contains to few placeholders"),
-			m_format.getBuffer(), __FILE__, __LINE__);
+			m_format.buffer(), __FILE__, __LINE__);
 }
 /** @brief Stores an argument.
  *
@@ -158,7 +158,7 @@ void ReVarArgs::store(const char* value, int length){
 	if (length < 0)
 		length = strlen(value);
 		// Store the first index of the argument in <code>m_argBuffer</code>.
-	m_args[++m_argNo] = m_argBuffer.getLength();
+	m_args[++m_argNo] = m_argBuffer.length();
 		// Store the string with trailing '\0':
 	m_argBuffer.append(value, length);
 	m_argBuffer.append("", 1);
@@ -172,7 +172,7 @@ void ReVarArgs::store(const char* value, int length){
  *
  * @return The instance itself. This is useful for chaining.
  */
-ReVarArgs& ReVarArgs::ReVarArgs::arg(int value, const char* format){
+ReVarArgs& ReVarArgs::arg(int value, const char* format){
 	char number[256];
 	snprintf(number, sizeof number, format, value);
 	store(number);
@@ -215,10 +215,10 @@ ReVarArgs& ReVarArgs::arg(const char* value, int minWidth, int maxWidth, bool al
 		ReByteBuffer buffer;
 		buffer.setLengthAndFill(minWidth, ' ');
 		if (alignRight)
-			memcpy(buffer.getBuffer() + minWidth - length, value, length);
+			memcpy(buffer.buffer() + minWidth - length, value, length);
 		else
-			memcpy(buffer.getBuffer(), value, length);
-		store (buffer.getBuffer(), buffer.getLength());
+			memcpy(buffer.buffer(), value, length);
+		store (buffer.buffer(), buffer.length());
 	}
 	return *this;
 }
@@ -246,13 +246,13 @@ ReVarArgs& ReVarArgs::arg(double value, const char* format){
 const char* ReVarArgs::asCString(){
 	if (m_argNo != m_maxArgNo)
 		throw ReFormatException(i18n("To few arguments"),
-			m_format.getBuffer());
+			m_format.buffer());
 
 	if (! m_stringIsReady){
 		replacePlaceholder();
 		m_stringIsReady = true;
 	}
-	return m_format.getBuffer();
+	return m_format.buffer();
 }
 
 /** @brief Stores a trigger.
@@ -280,60 +280,3 @@ void ReVarArgs::registerTrigger(ReVarArgTrigger* trigger){
 void ReVarArgs::end(void){
 	// Nothing to do in this base class
 }
-
-#if defined RE_TESTUNIT
-class TestReVarArgs : public ReTestUnit, public ReVarArgTrigger {
-public:
-	TestReVarArgs()
-		:
-		ReTestUnit("ReVarArgs", __FILE__),
-		m_argNo(0),
-		m_maxNo(0)
-	{
-		run();
-	}
-	virtual void newArg(int no, int maxNo){
-		m_argNo = no;
-		m_maxNo = maxNo;
-	}
-private:
-	void run(){
-		ReVarArgs list("$1 $$ $2");
-		list.registerTrigger(this);
-
-		list.arg(0).arg(9, "%03u");
-		checkEqu(m_argNo, 2);
-		checkEqu(m_maxNo, 2);
-		checkEqu("0 $ 009", list.asCString());
-
-
-		list.reset("x$1y$2");
-		list.arg(1.5);
-		checkEqu(m_argNo, 1);
-		checkEqu(m_maxNo, 2);
-		list.arg(2.45,"%7.3f");
-		checkEqu(m_argNo, 2);
-		checkEqu(m_maxNo, 2);
-		checkEqu("x1.500000y  2.450", list.asCString());
-
-		list.reset("$2,$1!$3;$4");
-		list.arg("1").arg("ab", 4);
-		list.arg("xy", 0, 1);
-		checkEqu(m_argNo, 3);
-		checkEqu(m_maxNo, 4);
-		list.arg("ww", 5, 0, true);
-		checkEqu(m_argNo, 4);
-		checkEqu(m_maxNo, 4);
-		checkEqu("ab  ,1!x;   ww", list.asCString());
-	}
-private:
-	int m_argNo;
-	int m_maxNo;
-};
-extern void testReVarArgs(void);
-
-void testReVarArgs(void){
-	TestReVarArgs unit;
-}
-#endif /*RE_TESTUNIT*/
-
diff --git a/base/rebase.hpp b/base/rebase.hpp
index bbcd5b1..8a6dd87 100644
--- a/base/rebase.hpp
+++ b/base/rebase.hpp
@@ -16,21 +16,25 @@
 #include <errno.h>
 #include <ctype.h>
 #include <assert.h>
+#include <stdarg.h>
 
-#define __LINUX__
-
-#if defined __LINUX__
+#if defined __linux__
 
+#include <stddef.h>
 #include <dirent.h>
 #include <fnmatch.h>
 #include <regex.h>
 #include <unistd.h>
 #include <inttypes.h>
 
-#elif defined WIN32
+#define _strdup strdup
+#define _unlink unlink
+//#define _
+#elif defined __WIN32__
 
+#include <direct.h>
+#include <windows.h>
 typedef _int64 int64_t;
-
 #endif
 
 #define RE_TESTUNIT
@@ -51,5 +55,13 @@ typedef _int64 int64_t;
 
 typedef unsigned char byte_t;
 
+#if defined __linux__
+#elif defined __WIN32__
+#define strncasecmp(s1, s2, n) _strnicmp(s1, s2, n)
+#define strcasecmp(s1, s2) _stricmp(s1, s2)
+#define snprintf _snprintf
+#define S_ISDIR(mode) (((mode) & _S_IFDIR) != 0)
+#endif
+
 #include "../base/baselocations.hpp"
 #endif /* REBASE_HPP_ */
diff --git a/cunit/basetest.cpp b/cunit/basetest.cpp
index ff4a23a..8c3f126 100644
--- a/cunit/basetest.cpp
+++ b/cunit/basetest.cpp
@@ -4,7 +4,7 @@
  *  Created on: 05.05.2010
  *      Author: wk
  */
-#include "../base/rebase.hpp"
+#include "base/rebase.hpp"
 #if defined RE_TESTUNIT
 extern void testReBase(void);
 void testReBase(void){
diff --git a/cunit/cuHashList.cpp b/cunit/cuHashList.cpp
new file mode 100644
index 0000000..8a3bc84
--- /dev/null
+++ b/cunit/cuHashList.cpp
@@ -0,0 +1,67 @@
+#include "base/rebase.hpp"
+
+class TestReHashList : public ReTestUnit {
+public:
+	TestReHashList() : ReTestUnit("ReHashList", __FILE__){
+		run();
+	}
+private:
+	void run(){
+		testBasic();
+		testNext();
+	}
+	void testBasic(){
+		ReHashList hash;
+		ReByteBuffer key, value;
+
+		hash.put("abc", "123");
+		checkT(hash.get("abc", -1, value));
+		checkEqu("123", value.str());
+
+		hash.put("ab", "999");
+		checkT(hash.get("ab", -1, value));
+		checkEqu("999", value.str());
+
+		checkT(hash.get("abc", -1, value));
+		checkEqu("123", value.str());
+
+		hash.put("abc", "!!!");
+		checkT(hash.get("abc", -1, value));
+		checkEqu("!!!", value.str());
+
+		checkT(hash.get("ab", -1, value));
+		checkEqu("999", value.str());
+
+		hash.put("abc", "longer");
+		checkT(hash.get("abc", -1, value));
+		checkEqu("longer", value.str());
+
+		checkT(hash.get("ab", -1, value));
+		checkEqu("999", value.str());
+	}
+	void testNext(){
+		ReHashList hash;
+		hash.put("1", "8");
+		hash.put("2", "4");
+		hash.put("4", "2");
+		hash.put("8", "1");
+		int flagsKey = 0;
+		int flagsVal = 0;
+		size_t pos = 0;
+		ReByteBuffer key, value;
+		while(hash.next(pos, &key, &value)){
+			int x = atol(key.buffer());
+			int y = atol(value.buffer());
+			checkEqu(8, x * y);
+			flagsKey += x;
+			flagsVal += y;
+		}
+		checkEqu(15, flagsKey);
+		checkEqu(15, flagsVal);
+	}
+};
+extern void testReHashList(void);
+
+void testReHashList(void){
+	TestReHashList unit;
+}
diff --git a/cunit/cuReByteBuffer.cpp b/cunit/cuReByteBuffer.cpp
index 927fc17..8688570 100644
--- a/cunit/cuReByteBuffer.cpp
+++ b/cunit/cuReByteBuffer.cpp
@@ -4,7 +4,7 @@
  *  Created on: 27.11.2010
  *      Author: wk
  */
-#include "../base/rebase.hpp"
+#include "base/rebase.hpp"
 class TestReByteBuffer : public ReTestUnit {
 	typedef ReByteBuffer::Byte Byte;
 public:
@@ -13,58 +13,181 @@ public:
 	}
 private:
 	void run(){
+		testCount();
+		testEnsureSizeGetLength();
+		testIndexOf();
+		testRIndexOf();
+		testStartsWidth();
+		testEndsWidth();
 		testOpAssignCopyConstructor();
 		testAt();
-		testEnsureSizeGetLength();
 		testBasic();
 		testAtoi();
-		testIndexOfRIndexOf();
+		testIndexOfCharRIndexOfChar();
+		testRIndexOf();
 		testInsert();
 		testRemove();
 		testSplice();
 		testReplace();
 	}
+	void testCount(){
+		ReByteBuffer buffer("aabbaabb");
+		checkEqu(4, buffer.count("a"));
+		checkEqu(4, buffer.count("b"));
+		checkEqu(2, buffer.count("ab"));
+		checkEqu(1, buffer.count("aabbaabb"));
+	}
+	void testStartsWidth(){
+		// . . . . . . . . . 01234567
+		ReByteBuffer buffer("aabbaabb");
+		// case sensitive
+		checkT(buffer.startsWith("aabbaabb", -1, false));
+		checkT(buffer.startsWith("aabbaabb", 8, false));
+		checkT(buffer.startsWith("a", -1, false));
+		checkT(buffer.startsWith("aab", -1, false));
+		checkT(buffer.startsWith("ax", 1, false));
+
+		// case insensitive
+		checkT(buffer.startsWith("AabbaabB", -1, true));
+		checkT(buffer.startsWith("aabbaabB", 8, true));
+		checkT(buffer.startsWith("A", -1, true));
+		checkT(buffer.startsWith("aAb", -1, true));
+		checkT(buffer.startsWith("Aax", 2, true));
+		checkT(buffer.startsWith("aab", -1, false));
+
+		// not matching:
+		checkF(buffer.startsWith("b", 1, false));
+		checkF(buffer.startsWith("ab", 2, false));
+		checkF(buffer.startsWith("A", 1, false));
+		checkF(buffer.startsWith("Ab", 2, false));
+
+		// binary:
+		buffer.buffer()[1] = '\0';
+		ReByteBuffer buffer2("aab");
+		ReByteBuffer buffer3("aax");
+		buffer2.buffer()[1] = '\0';
+		buffer3.buffer()[1] = '\0';
+		checkT(buffer.startsWith(buffer2.str(), 3, false));
+		checkF(buffer.startsWith(buffer3.str(), 3, false));
+		buffer2.buffer()[0] = 'A';
+		buffer3.buffer()[0] = 'A';
+		checkT(buffer.startsWith(buffer2.str(), 3, true));
+		checkF(buffer.startsWith(buffer3.str(), 3, true));
+	}
+
+	void testEndsWidth(){
+		// . . . . . . . . . 01234567
+		ReByteBuffer buffer("aabbaabb");
+		// case sensitive
+		checkT(buffer.endsWith("b", -1, false));
+		checkT(buffer.endsWith("abb", -1, false));
+		checkT(buffer.endsWith("bx", 1, false));
+
+		// case insensitive
+		checkT(buffer.endsWith("B", -1, true));
+		checkT(buffer.endsWith("aBb", -1, true));
+		checkT(buffer.endsWith("Bbx", 2, true));
+		checkT(buffer.endsWith("Abb", -1, true));
+
+		// not matching:
+		checkF(buffer.endsWith("a", -1, false));
+		checkF(buffer.endsWith("a", 1, false));
+		checkF(buffer.endsWith("ab", 2, false));
+		checkF(buffer.endsWith("B", 1, false));
+		checkF(buffer.endsWith("Ab", 2, false));
+
+		// binary:
+		buffer.buffer()[6] = '\0';
+		ReByteBuffer buffer2("abb");
+		buffer2.buffer()[1] = '\0';
+		checkT(buffer.endsWith(buffer2.str(), 3, false));
+		buffer2.buffer()[0] = 'A';
+		checkT(buffer.endsWith(buffer2.str(), 3, true));
+	}
+
+	void testIndexOf(){
+		// . . . . . . . . . 01234567
+		ReByteBuffer buffer("aabbaabb");
+		// const Byte* toFind, size_t toFindLength, int start,int end, bool ignoreCase
+		checkEqu(0, buffer.indexOf("aa", -1, 0, -1, false));
+		int ix;
+		for (ix = 1; ix <= 4; ix++)
+			checkEqu(4, buffer.indexOf("aa", 2, ix, -1, false));
+		checkEqu(4, buffer.indexOf("aa", 2, 1, 6, false));
+		checkEqu(-1, buffer.indexOf("aa", 2, 1, 5, false));
+		checkEqu(1, buffer.indexOf("ab", 2, 0, -1, false));
+		checkEqu(-1, buffer.indexOf("Aa", 2, 0, -1, false));
+
+		checkEqu(0, buffer.indexOf("aA", 2, 0, -1, true));
+		for (ix = 1; ix <= 4; ix++)
+			checkEqu(4, buffer.indexOf("Aa", 2, ix, -1, true));
+		checkEqu(4, buffer.indexOf("aA", 2, 1, 6, true));
+		checkEqu(-1, buffer.indexOf("Aa", 2, 1, 5, true));
+		checkEqu(1, buffer.indexOf("aB", 2, 0, -1, true));
+	}
+	void testRIndexOf(){
+		// . . . . . . . . . 01234567
+		ReByteBuffer buffer("aabbaabb");
+		// const Byte* toFind, size_t toFindLength, int start,int end, bool ignoreCase
+		checkEqu(4, buffer.rindexOf("aa", -1, 0, -1, false));
+		int ix;
+		for (ix = 9; ix >= 6; ix--)
+			checkEqu(4, buffer.rindexOf("aa", 2, 0, ix, false));
+		checkEqu(0, buffer.rindexOf("aa", 2, 0, 5, false));
+		checkEqu(-1, buffer.rindexOf("aa", 2, 1, 3, false));
+		checkEqu(1, buffer.rindexOf("ab", 2, 0, 5, false));
+		checkEqu(1, buffer.rindexOf("ab", 2, 1, 5, false));
+		checkEqu(-1, buffer.rindexOf("Aa", 2, 0, -1, false));
+
+		for (ix = 9; ix >= 6; ix--)
+			checkEqu(4, buffer.rindexOf("Aa", 2, 0, ix, true));
+		checkEqu(0, buffer.rindexOf("aA", 2, 0, 5, true));
+		checkEqu(-1, buffer.rindexOf("Aa", 2, 1, 3, true));
+		checkEqu(1, buffer.rindexOf("aB", 2, 0, 5, true));
+		checkEqu(1, buffer.rindexOf("Ab", 2, 1, 5, true));
+		checkEqu(4, buffer.rindexOf("Aa", 2, 0, -1, true));
+	}
 	void testBasic(){
 		ReByteBuffer buffer(10);
 
 		buffer.append((Byte*)"123", 3);
-		checkEqu("123", buffer.getBuffer());
+		checkEqu("123", buffer.buffer());
 		checkEqu("123", buffer.str());
-		checkEqu(3, buffer.getLength());
+		checkEqu(3u, buffer.length());
 		buffer.append((Byte*)"ab", 2);
-		checkEqu("123ab", buffer.getBuffer());
-		checkEqu(5, buffer.getLength());
+		checkEqu("123ab", buffer.buffer());
+		checkEqu(5u, buffer.length());
 
 		buffer.setLengthAndFill(8, 'x');
-		checkEqu("123abxxx", buffer.getBuffer());
-		checkEqu(8, buffer.getLength());
+		checkEqu("123abxxx", buffer.buffer());
+		checkEqu(8u, buffer.length());
 		buffer.setLength(3);
-		checkEqu("123", buffer.getBuffer());
-		checkEqu(3, buffer.getLength());
+		checkEqu("123", buffer.buffer());
+		checkEqu(3u, buffer.length());
 
 		buffer.setLengthAndFill(511, 'y');
 		buffer.setLengthAndFill(512, 'z');
-		checkEqu("yyz", buffer.getBuffer() + 509);
-		checkEqu(521, buffer.getSize());
+		checkEqu("yyz", buffer.buffer() + 509);
+		checkEqu(521u, buffer.capacity());
 
 		ReByteBuffer buffer2;
 		buffer2.set("xyz", -1);
 		buffer.set("abc", -1);
-		checkEqu("abc", buffer.getBuffer());
-		checkEqu(3, buffer.getLength());
+		checkEqu("abc", buffer.buffer());
+		checkEqu(3u, buffer.length());
 		buffer.append(buffer2);
-		checkEqu("abcxyz", buffer.getBuffer());
+		checkEqu("abcxyz", buffer.buffer());
 		checkEqu("abcxyz", buffer.str());
-		checkEqu(6, buffer.getLength());
+		checkEqu(6u, buffer.length());
 
 		buffer.setLength(0);
 		buffer.appendInt(-1);
 		checkEqu("-1", buffer.str());
-		checkEqu(2, buffer.getLength());
+		checkEqu(2u, buffer.length());
 
 		buffer.appendInt(9, "%03d");
 		checkEqu("-1009", buffer.str());
-		checkEqu(5, buffer.getLength());
+		checkEqu(5u, buffer.length());
 	}
 	void testOpAssignCopyConstructor() {
 		ReByteBuffer buf1;
@@ -82,8 +205,8 @@ private:
 	void testAt(){
 		ReByteBuffer buf1;
 		buf1.set("abc", 3);
-		for (size_t ii = 0; ii < buf1.getLength(); ii++){
-			checkEqu('a' + ii, buf1.at(ii));
+		for (size_t ii = 0; ii < buf1.length(); ii++){
+			checkEqu(int('a' + ii), (int) buf1.at(ii));
 		}
 		checkEqu(0, buf1.at(-1));
 		checkEqu(0, buf1.at(3));
@@ -134,33 +257,33 @@ private:
 		checkEqu(0, buffer.atoi(5, 6));
 
 		buffer.set("0x98765432", -1);
-		checkEqu(0x98765432, buffer.atoi());
+		checkEqu(0x98765432, (unsigned) buffer.atoi());
 
 		buffer.set("0xabcdef01", -1);
-		checkEqu(0xabcdef01, buffer.atoi());
+		checkEqu(0xabcdef01, (unsigned) buffer.atoi());
 		buffer.set("0xABCDEF01", -1);
-		checkEqu(0xabcdef01, buffer.atoi());
+		checkEqu(0xabcdef01, (unsigned) buffer.atoi());
 		buffer.set("0xaFFe01", -1);
-		checkEqu(0xaFFe01, buffer.atoi());
+		checkEqu(0xaFFe01u, (unsigned) buffer.atoi());
 	}
 	void testEnsureSizeGetLength(){
 		ReByteBuffer buf1;
 		buf1.ensureSize(2000);
-		checkEqu(2000, buf1.getSize());
+		checkEqu(2000u, buf1.capacity());
 		buf1.set("0123456789", 10);
-		checkEqu(10, buf1.getLength());
+		checkEqu(10u, buf1.length());
 
 		buf1.setLength(5);
 		checkEqu("01234", buf1.str());
-		checkEqu(5, buf1.getLength());
+		checkEqu(5u, buf1.length());
 
 		buf1.setLengthAndFill(8, 'X');
 		checkEqu("01234XXX", buf1.str());
-		checkEqu(8, buf1.getLength());
-		checkEqu(2000, buf1.getSize());
+		checkEqu(8u, buf1.length());
+		checkEqu(2000u, buf1.capacity());
 	}
 
-	void testIndexOfRIndexOf(){
+	void testIndexOfCharRIndexOfChar(){
 		ReByteBuffer buffer;
 		buffer.set("123123", -1);
 		checkEqu(0, buffer.indexOf('1'));
@@ -201,19 +324,19 @@ private:
 		ReByteBuffer buf1;
 		checkT(buf1.insert(0, "123", 2));
 		checkEqu("12", buf1.str());
-		checkEqu(2, buf1.getLength());
+		checkEqu(2u, buf1.length());
 
 		checkT(buf1.insert(0, "abc", 1));
 		checkEqu("a12", buf1.str());
-		checkEqu(3, buf1.getLength());
+		checkEqu(3u, buf1.length());
 
 		checkT(buf1.insert(1, "x", 1));
 		checkEqu("ax12", buf1.str());
-		checkEqu(4, buf1.getLength());
+		checkEqu(4u, buf1.length());
 
 		checkT(buf1.insert(4, "yz", 2));
 		checkEqu("ax12yz", buf1.str());
-		checkEqu(6, buf1.getLength());
+		checkEqu(6u, buf1.length());
 
 		checkF(buf1.insert(-1, "-", 1));
 		checkF(buf1.insert(8, "/", 1));
@@ -224,27 +347,27 @@ private:
 		buf1.set("1234567890", 10);
 		checkT(buf1.remove(0, 2));
 		checkEqu("34567890", buf1.str());
-		checkEqu(8, buf1.getLength());
+		checkEqu(8u, buf1.length());
 
 		checkF(buf1.remove(-1, 2));
 		checkEqu("34567890", buf1.str());
-		checkEqu(8, buf1.getLength());
+		checkEqu(8u, buf1.length());
 
 		checkF(buf1.remove(9, 2));
 		checkEqu("34567890", buf1.str());
-		checkEqu(8, buf1.getLength());
+		checkEqu(8u, buf1.length());
 
 		checkT(buf1.remove(7, 2));
 		checkEqu("3456789", buf1.str());
-		checkEqu(7, buf1.getLength());
+		checkEqu(7u, buf1.length());
 
 		checkT(buf1.remove(5, 2));
 		checkEqu("34567", buf1.str());
-		checkEqu(5, buf1.getLength());
+		checkEqu(5u, buf1.length());
 
 		checkT(buf1.remove(0, 99));
 		checkEqu("", buf1.str());
-		checkEqu(0, buf1.getLength());
+		checkEqu(0u, buf1.length());
 	}
 	void testReplace(){
 		ReByteBuffer buffer;
@@ -265,29 +388,29 @@ private:
 
 		buffer.append((Byte*) "12.ab", 5);
 		checkT(buffer.splice(0, 0, "xy", 2));
-		checkEqu("xy12.ab", buffer.getBuffer());
+		checkEqu("xy12.ab", buffer.buffer());
 		buffer.splice(2, 2, NULL, 0);
-		checkEqu("xy.ab", buffer.getBuffer());
+		checkEqu("xy.ab", buffer.buffer());
 		buffer.splice(0, 2, "w", 1);
-		checkEqu("w.ab", buffer.getBuffer());
+		checkEqu("w.ab", buffer.buffer());
 
 		buffer.setLength(0);
 		buffer.append((Byte*) "123", 3);
 		buffer.insert(1, "ab", 2);
-		checkEqu("1ab23", buffer.getBuffer());
-		checkEqu(5, buffer.getLength());
+		checkEqu("1ab23", buffer.buffer());
+		checkEqu(5u, buffer.length());
 		buffer.remove(0, 1);
-		checkEqu("ab23", buffer.getBuffer());
-		checkEqu(4, buffer.getLength());
+		checkEqu("ab23", buffer.buffer());
+		checkEqu(4u, buffer.length());
 		buffer.remove(3, 55);
-		checkEqu("ab2", buffer.getBuffer());
-		checkEqu(3, buffer.getLength());
+		checkEqu("ab2", buffer.buffer());
+		checkEqu(3u, buffer.length());
 		buffer.remove(2, 2);
-		checkEqu("ab", buffer.getBuffer());
-		checkEqu(2, buffer.getLength());
+		checkEqu("ab", buffer.buffer());
+		checkEqu(2u, buffer.length());
 		buffer.remove(1, 1);
-		checkEqu("a", buffer.getBuffer());
-		checkEqu(1, buffer.getLength());
+		checkEqu("a", buffer.buffer());
+		checkEqu(1u, buffer.length());
 	}
 };
 extern void testReByteBuffer(void);
diff --git a/cunit/cuReCString.cpp b/cunit/cuReCString.cpp
index ae5aaa8..97de41f 100644
--- a/cunit/cuReCString.cpp
+++ b/cunit/cuReCString.cpp
@@ -4,7 +4,8 @@
  *  Created on: 23.11.2010
  *      Author: wk
  */
-#include "../base/restring.hpp"
+#include "base/rebase.hpp"
+#include "string/restring.hpp"
 
 class TestReString : public ReTestUnit {
 public:
diff --git a/cunit/cuReDirectory.cpp b/cunit/cuReDirectory.cpp
new file mode 100644
index 0000000..abfae07
--- /dev/null
+++ b/cunit/cuReDirectory.cpp
@@ -0,0 +1,43 @@
+#include "base/rebase.hpp"
+
+class TestReDirectory : public ReTestUnit {
+public:
+	TestReDirectory() : ReTestUnit("ReFileFinder", __FILE__){
+		run();
+	}
+private:
+	void run(){
+		createTestDir();
+		ReByteBuffer dir;
+		dir.set(getTestDir(), -1);
+		ReByteBuffer file1 = dir;
+		file1.append("abc.1.txt", -1);
+		createFile(file1.str(), "abc1");
+
+		ReByteBuffer file2 = dir;
+		file2.append("abc.2.txt", -1);
+		createFile(file2.str(), "abc2");
+
+		ReDirectory finder(dir.str());
+		checkT(finder.isValid());
+
+		checkT(finder.findFirst("abc.*.txt", false));
+		checkEqu("abc.1.txt", finder.currentFile());
+		checkT(finder.findNext());
+		checkEqu("abc.2.txt", finder.currentFile());
+		checkF(finder.findNext());
+		checkF(finder.findFirst("abx.*.txt", false));
+
+		checkT(finder.findFirst("abc[.][0-9][.]txt", true));
+		checkEqu("abc.1.txt", finder.currentFile());
+		checkT(finder.findNext());
+		checkEqu("abc.2.txt", finder.currentFile());
+		checkF(finder.findNext());
+		checkF(finder.findFirst("abx[.][0-9][.]txt", true));
+	}
+};
+extern void testReDirectory(void);
+
+void testReDirectory(void){
+	TestReDirectory unit;
+}
diff --git a/cunit/cuReException.cpp b/cunit/cuReException.cpp
new file mode 100644
index 0000000..0b5e3af
--- /dev/null
+++ b/cunit/cuReException.cpp
@@ -0,0 +1,67 @@
+#include "base/rebase.hpp"
+
+class TestReException : public ReTestUnit, public ReVarArgTrigger {
+public:
+	TestReException()
+		:
+		ReTestUnit("ReException", __FILE__),
+		m_argNo(0),
+		m_maxNo(0)
+	{
+		run();
+	}
+	virtual void newArg(int no, int maxNo){
+		m_argNo = no;
+		m_maxNo = maxNo;
+	}
+private:
+	void run(){
+		try{
+			throw ReException("ReException");
+			checkT(false);
+		} catch (ReException& e){
+			log(false, e.getMessage());
+		}
+		try{
+			throw ReException("ReException", __FILE__, __LINE__);
+			checkT(false);
+		} catch (ReException& e){
+			log(false, e.getMessage());
+		}
+		try{
+			throw ReFormatException("ReFormatException", "format");
+			checkT(false);
+		} catch (ReException& e){
+			log(false, e.getMessage());
+		}
+		try{
+			throw ReFormatException("ReFormatException", "format",  __FILE__, __LINE__);
+			checkT(false);
+		} catch (ReException& e){
+			log(false, e.getMessage());
+		}
+		try{
+			throw ReBoundsException("myArray", 101, 100);
+			checkT(false);
+		} catch (ReException& e){
+			log(false, e.getMessage());
+		}
+
+		try{
+			throw ReBoundsException("myArray", -1, 0,  __FILE__, __LINE__);
+			checkT(false);
+		} catch (ReException& e){
+			log(false, e.getMessage());
+		}
+
+	}
+private:
+	int m_argNo;
+	int m_maxNo;
+};
+extern void testReException(void);
+
+void testReException(void){
+	TestReException unit;
+}
+
diff --git a/cunit/cuReI18N.cpp b/cunit/cuReI18N.cpp
new file mode 100644
index 0000000..b19a929
--- /dev/null
+++ b/cunit/cuReI18N.cpp
@@ -0,0 +1,23 @@
+#include "base/rebase.hpp"
+
+class TestReI18N : public ReTestUnit {
+public:
+	TestReI18N()
+		:
+		ReTestUnit("ReI18N", __FILE__)
+	{
+		run();
+	}
+private:
+	void run(){
+		checkEqu("dies ist ein Test", i18n("this is a test"));
+		checkEqu("eins: 1 zwei: 2", i18nf("one: $1 two: $2").arg(1).arg(2).asCString());
+
+	}
+};
+extern void testReI18N(void);
+
+void testReI18N(void){
+	TestReI18N unit;
+}
+
diff --git a/cunit/cuReLogger.cpp b/cunit/cuReLogger.cpp
new file mode 100644
index 0000000..d9c4838
--- /dev/null
+++ b/cunit/cuReLogger.cpp
@@ -0,0 +1,28 @@
+#include "base/rebase.hpp"
+
+class TestReLogger : public ReTestUnit {
+public:
+	TestReLogger() : ReTestUnit("ReLogger", __FILE__){
+		run();
+	}
+private:
+	void run(){
+		ReStreamAppender app1(stdout);
+		app1.setMode(CAT_ALL, CAT_ALL, CAT_ALL, GRAN_ALL);
+
+		ReLogger logger(false);
+		logger.addAppender(&app1);
+		log(false, "2 Errors and a warning:");
+		logger.say(LOG_ABORT | CAT_TEST | GRAN_TRACE, __LINE__, "abort");;
+		logger.say(LOG_ERROR | CAT_TEST, __LINE__, "error");
+		logger.say(LOG_WARNING | CAT_TEST, __LINE__, "warning");
+
+		logger.sayF(CAT_TEST, __LINE__, "Two: $1 eleven: $021").arg(2).arg(1).end();
+		globalLogger()->say(CAT_LIB, __LINE__, "globalLogger()");
+	}
+};
+extern void testReLogger(void);
+
+void testReLogger(void){
+	TestReLogger unit;
+}
diff --git a/cunit/cuReMatcher.cpp b/cunit/cuReMatcher.cpp
new file mode 100644
index 0000000..f29f22e
--- /dev/null
+++ b/cunit/cuReMatcher.cpp
@@ -0,0 +1,168 @@
+/*
+ * cuReMatcher.cpp
+ *
+ *  Created on: 25.12.2014
+ *      Author: hm
+ */
+
+#include "base/rebase.hpp"
+#include "string/restring.hpp"
+
+class TestReMatcher : public ReTestUnit {
+public:
+	TestReMatcher() : ReTestUnit("ReMatcher", __FILE__){
+		run();
+	}
+private:
+	void run(){
+		testPatternList();
+		testMatch();
+		testSearch();
+		testMatchManyStars();
+		testSearchManyStars();
+	}
+	void testPatternList(){
+		RePatternList list;
+		list.set(";*.cpp;^cu*;*.hpp;", true);
+		checkT(list.match("a.hpp"));
+
+		checkT(list.match("a.cpp"));
+		checkT(list.match("a.hpp"));
+		checkF(list.match("cuA.hpp"));
+		checkF(list.match("a.hpp~"));
+		list.set(" * ^*~");
+		checkT(list.match("a.hpp"));
+		checkF(list.match("a.hpp~"));
+	}
+	void testMatch(){
+		ReSimpleMatcher matcher("abc*.x");
+
+		matcher.setIgnoreCase(false);
+		checkT(matcher.match("abc.x"));
+		checkT(matcher.match("abcd.x"));
+		checkF(matcher.match("abc.x~"));
+		checkF(matcher.match("_abc.x"));
+		checkF(matcher.match("aBc.x"));
+		checkF(matcher.match("abc.X"));
+
+		matcher.setIgnoreCase(true);
+		checkT(matcher.match("abc.x"));
+		checkT(matcher.match("abcd.x"));
+		checkF(matcher.match("abc.x~"));
+		checkF(matcher.match("_abc.x"));
+		checkT(matcher.match("aBc.x"));
+		checkT(matcher.match("abc.X"));
+		checkT(matcher.match("aBcdef.X"));
+	}
+	void testMatchManyStars(){
+		ReSimpleMatcher matcher("a*b*c*x");
+
+		matcher.setIgnoreCase(false);
+		checkT(matcher.match("abcd.x"));
+		checkT(matcher.match("a1b2c456d.x"));
+		checkF(matcher.match("A1B2C456d.X"));
+
+		matcher.setIgnoreCase(true);
+		checkT(matcher.match("abcd.x"));
+		checkT(matcher.match("a1b2c456d.x"));
+		checkT(matcher.match("aBcD.x"));
+		checkT(matcher.match("A1B2C456d.X"));
+
+		matcher.compile("*.cpp");
+		matcher.setIgnoreCase(false);
+		checkT(matcher.match("abcd.cpp"));
+		checkF(matcher.match("abcd.cppx"));
+		matcher.setIgnoreCase(true);
+		checkT(matcher.match("abcd.CPP"));
+		checkF(matcher.match("abcd.CPP~"));
+
+		matcher.compile("t*");
+		matcher.setIgnoreCase(false);
+		checkT(matcher.match("test"));
+		checkF(matcher.match("xtest"));
+		matcher.setIgnoreCase(true);
+		checkT(matcher.match("Test"));
+		checkF(matcher.match("xTest"));
+
+		matcher.setNotPattern(true);
+		checkT(matcher.isNotPattern());
+		checkF(matcher.match("Test"));
+		checkT(matcher.match("xTest"));
+
+		matcher.compile("*");
+		matcher.setNotPattern(false);
+		checkT(matcher.match(""));
+		checkT(matcher.match("x"));
+
+		checkF(matcher.isNotPattern());
+		matcher.setNotPattern(true);
+		checkT(matcher.isNotPattern());
+		checkF(matcher.match(""));
+		checkF(matcher.match("x"));
+	}
+	void testSearch(){
+		ReSimpleMatcher matcher("abc*.x");
+		matcher.setIgnoreCase(false);
+
+		checkT(matcher.search("abc.x"));
+		checkT(matcher.search("abcd.x"));
+		checkT(matcher.search("abc.x~"));
+		checkT(matcher.search("_abc.x"));
+		checkF(matcher.search("aBc.x"));
+		checkF(matcher.search("abc.X"));
+		checkT(matcher.search("Xabcdef.xY"));
+		matcher.setIgnoreCase(true);
+		checkT(matcher.search("abc.x"));
+		checkT(matcher.search("abcd.x"));
+		checkT(matcher.search("abc.x~"));
+		checkT(matcher.search("_abc.x"));
+		checkT(matcher.search("aBc.x"));
+		checkT(matcher.search("abc.X"));
+		checkT(matcher.search("aBcdef.X"));
+		checkT(matcher.search("Xabcdef.xY"));
+
+		matcher.compile("*.cpp");
+		matcher.setIgnoreCase(false);
+		checkT(matcher.search("abcd.cpp"));
+		checkT(matcher.search("abcd.cpp~"));
+		checkT(matcher.search(".cpp"));
+		checkF(matcher.search("abcd.cxppx"));
+		matcher.setIgnoreCase(true);
+		checkT(matcher.search("abcd.CPP"));
+		checkF(matcher.search("abcd.CP~"));
+
+		matcher.compile("t");
+		matcher.setIgnoreCase(false);
+		checkT(matcher.search("t"));
+		checkT(matcher.search("test"));
+		checkT(matcher.search("rest"));
+		checkF(matcher.search("xyz"));
+		matcher.setIgnoreCase(true);
+		checkT(matcher.search("T"));
+		checkT(matcher.search("Test"));
+		checkT(matcher.search("resT"));
+		checkF(matcher.search("xyz"));
+	}
+	void testSearchManyStars(){
+		ReSimpleMatcher matcher("*a*b*c*x*");
+
+		matcher.setIgnoreCase(false);
+		checkT(matcher.match("abcd.x"));
+		checkT(matcher.match("a1b2c456d.x"));
+		checkF(matcher.match("A1B2C456d.X"));
+
+		matcher.setIgnoreCase(true);
+		checkT(matcher.match("abcd.x"));
+		checkT(matcher.match("a1b2c456d.x"));
+		checkT(matcher.match("aBcD.x"));
+		checkT(matcher.match("A1B2C456d.X"));
+	}
+};
+extern void testReMatcher(void);
+
+void testReMatcher(void){
+	TestReMatcher unit;
+}
+
+
+
diff --git a/cunit/cuReProgramArgs.cpp b/cunit/cuReProgramArgs.cpp
new file mode 100644
index 0000000..2932176
--- /dev/null
+++ b/cunit/cuReProgramArgs.cpp
@@ -0,0 +1,109 @@
+#include "base/rebase.hpp"
+
+class TestReProgramArgs : public ReTestUnit {
+public:
+	TestReProgramArgs()
+		:
+		ReTestUnit("ReProgramArgs", __FILE__)
+	{
+		run();
+	}
+private:
+	void run(){
+		testLong();
+		testShort();
+	}
+	void testShort(){
+		ReProgramArgs args("test <opts> <args>\nThis tests the usage of ReProgramArgs",
+				"$0 -b+ -B- file dir\n\ttest of an example");
+
+		args.addBool("boolarg", "This is a boolean arg", 'b', "boolval", false);
+		args.addBool("boolarg2", "This is the 2nd boolean arg", 'B', "boolval2", true);
+		args.addBool("boolarg3", "This is the 3rd boolean arg", 'x', "boolval3", false);
+		args.addBool("boolarg4", "This is the 4th boolean arg", 'Y', "boolval4", true);
+		args.addInt("intarg", "This is an integer arg", 'i', "intval", 9);
+		args.addInt("intarg2", "This is the 2nd integer arg", 'I', "intval", 1000);
+		args.addString("stringarg", "This string must be non empty", 's', "string", false, "abc");
+		args.addString("stringarg2", "This 2nd string must be non empty", 'u', "string2", false, "undef");
+		args.addString("estringarg", "This string may be empty", 'S', "estring", true, "empty");
+		args.addString("estringarg2", "This 2nd string may be empty", 'U', "estring2", true, "undef2");
+
+		checkF(args.getBool("boolarg"));
+		checkEqu(9, args.getInt("intarg"));
+		ReByteBuffer buffer;
+		checkEqu("empty", args.getString("estringarg", buffer));
+		checkEqu("abc", args.getString("stringarg", buffer));
+
+		const char* vector[] = {
+			"testprog", "-bB+i123", "-S", "-x-", "-Y+", "-s", "2nd string", "arg1", "arg2"
+		};
+		args.init(sizeof vector / sizeof vector[0], (char**) vector);
+
+		checkEqu("testprog", args.getProgramName());
+		checkT(args.getBool("boolarg"));
+		checkF(args.getBool("boolarg2"));
+		checkF(args.getBool("boolarg3"));
+		checkF(args.getBool("boolarg4"));
+		checkEqu(123, args.getInt("intarg"));
+		checkEqu(1000, args.getInt("intarg2"));
+		checkEqu("", args.getString("estringarg", buffer));
+		checkEqu("2nd string", args.getString("stringarg", buffer));
+		checkEqu("undef", args.getString("stringarg2", buffer));
+		checkEqu("undef2", args.getString("estringarg2", buffer));
+		checkEqu("testprog", args.getProgramName());
+		checkEqu("arg1", args.getArg(0));
+		checkEqu("arg2", args.getArg(1));
+		checkEqu(2, args.getArgCount());
+
+		args.help("Not really an error!", false, stdout);
+	}
+	void testLong(){
+		const char* call[] = {
+				"test <opts> <args>",
+				"This tests the usage of ReProgramArgs",
+				NULL
+		};
+		const char* examples[] = { "test -intval=10 --boolval=t",  NULL};
+		ReProgramArgs args(call, examples);
+
+		args.addBool("boolarg", "This is a boolean arg", 'b', "boolval", false);
+		char none = ReProgramArgs::HIDDEN_SHORT_NAME;
+		args.addBool("boolarg2", "This is the 2nd boolean arg", none, "boolval2", true);
+		args.addBool("boolarg3", "This is the 3rd boolean arg", 'x', "boolval3", false);
+		args.addBool("boolarg4", "This is the 3rd boolean arg", none, "boolval4", true);
+		args.addInt("intarg", "This is an integer arg", 'i', "intval", 9);
+		args.addString("stringarg", "This string must be non empty", 's', "string", false, "abc");
+		args.addString("estringarg", "This string may be empty", none, "estring", true, "empty");
+		args.addString("estringarg2", "This 2nd string may be empty", 'U', "estring2", true, "undef2");
+		args.addString("estringarg3", "This 3thrd string may be empty", 'V', "estring3", true, "undef3");
+
+		ReByteBuffer buffer;
+		const char* vector[] = {
+			"testprog",
+			"--boolval", "--boolval2=true", "--boolval3=f", "--boolval4=0",
+			"--intval=3",
+			"--string=x y", "--estring=", "--estring2=not empty",
+			"arg1", "arg2"
+		};
+		args.init(sizeof vector / sizeof vector[0], (char**) vector);
+
+		checkEqu("testprog", args.getProgramName());
+		checkT(args.getBool("boolarg"));
+		checkF(args.getBool("boolarg2"));
+		checkF(args.getBool("boolarg3"));
+		checkT(args.getBool("boolarg4"));
+		checkEqu(3, args.getInt("intarg"));
+		checkEqu("x y", args.getString("stringarg", buffer));
+		checkEqu("", args.getString("estringarg", buffer));
+		checkEqu("not empty", args.getString("estringarg2", buffer));
+		checkEqu("arg1", args.getArg(0));
+		checkEqu("arg2", args.getArg(1));
+		checkEqu(2, args.getArgCount());
+		args.help(NULL, false, stdout);
+	}
+};
+extern void testReProgramArgs(void);
+
+void testReProgramArgs(void){
+	TestReProgramArgs unit;
+}
diff --git a/cunit/cuReSeqList.cpp b/cunit/cuReSeqList.cpp
new file mode 100644
index 0000000..8cee5f2
--- /dev/null
+++ b/cunit/cuReSeqList.cpp
@@ -0,0 +1,102 @@
+#include "base/rebase.hpp"
+
+class TestReSeqList : public ReTestUnit {
+public:
+	TestReSeqList() : ReTestUnit("ReSeqList", __FILE__){
+		run();
+	}
+private:
+	void run(){
+		testBase();
+		testRemove();
+	}
+	void testBase(){
+		ReSeqList list;
+		ReByteBuffer value;
+		ReSeqList::Tag tag = 0;
+
+		list.add(-1, "123", -1, 100);
+		checkEqu(1u, list.getCount());
+		checkT(list.get(0, value, &tag));
+		checkEqu("123", value.str());
+		checkEqu((int64_t) 100, tag);
+
+		list.add(-1, "ab", -1, 200);
+		checkEqu(2u, list.getCount());
+		checkT(list.get(0, value));
+		checkEqu("123", value.str());
+		checkT(list.get(1, value, &tag));
+		checkEqu("ab", value.str());
+		checkEqu(200ll, tag);
+
+		list.add(0, "xyz", -1, 300);
+		checkEqu(3u, list.getCount());
+		checkT(list.get(0, value, &tag));
+		checkEqu("xyz", value.str());
+		checkT(list.get(1, value));
+		checkEqu("123", value.str());
+		checkT(list.get(2, value));
+		checkEqu("ab", value.str());
+		checkEqu(300ll, tag);
+
+		list.add(1, "vw", -1, 400);
+		checkEqu(4u, list.getCount());
+		checkT(list.get(0, value));
+		checkEqu("xyz", value.str());
+		checkT(list.get(1, value, &tag));
+		checkEqu("vw", value.str());
+		checkT(list.get(2, value));
+		checkEqu("123", value.str());
+		checkT(list.get(3, value));
+		checkEqu("ab", value.str());
+		checkEqu(400ll, tag);
+
+		list.clear();
+		checkEqu(0u, list.getCount());
+		checkF(list.get(0, value));
+	}
+	void testRemove(){
+		ReSeqList list;
+		ReByteBuffer value;
+		ReSeqList::Tag tag = 0;
+
+		list.add(-1, "abc", -1, 100);
+		list.add(-1, "def12", -1, 200);
+		list.add(-1, "ghi", -1, 300);
+		list.add(-1, "jkl134", -1, 400);
+
+		list.remove(3);
+		checkEqu(3u, list.getCount());
+		list.get(0, value, &tag);
+		checkEqu("abc", value.str());
+		checkEqu(100ll, tag);
+		list.get(1, value, &tag);
+		checkEqu("def12", value.str());
+		checkEqu(200ll, tag);
+		list.get(2, value, &tag);
+		checkEqu("ghi", value.str());
+		checkEqu(300ll, tag);
+
+
+		list.remove(1);
+		checkEqu(2u, list.getCount());
+		list.get(0, value, &tag);
+		checkEqu("abc", value.str());
+		checkEqu(100ll, tag);
+		list.get(1, value, &tag);
+		checkEqu("ghi", value.str());
+		checkEqu(300ll, tag);
+
+		list.remove(0);
+		checkEqu(1u, list.getCount());
+		list.get(0, value, &tag);
+		checkEqu("ghi", value.str());
+		checkEqu(300ll, tag);
+
+	}
+};
+extern void testReSeqList(void);
+
+void testReSeqList(void){
+	TestReSeqList unit;
+}
diff --git a/cunit/cuReStringList.cpp b/cunit/cuReStringList.cpp
new file mode 100644
index 0000000..2bd4b66
--- /dev/null
+++ b/cunit/cuReStringList.cpp
@@ -0,0 +1,261 @@
+#include "base/rebase.hpp"
+
+class TestReStringList : public ReTestUnit {
+public:
+	TestReStringList() : ReTestUnit("ReStringList", __FILE__){
+		run();
+	}
+private:
+	void run(){
+		testBase();
+		testReplace();
+		testJoin();
+		testEqu();
+		testFile();
+	}
+	void testReplace(){
+		ReStringList list;
+
+		list.append("123", 100);
+		checkEqu((int64_t) 100, list.tagOf(0));
+		list.append("2", 200);
+		checkEqu((int64_t) 100, list.tagOf(0));
+		checkEqu((int64_t) 200, list.tagOf(1));
+		list.append("34", 300);
+		checkEqu((int64_t) 100, list.tagOf(0));
+		checkEqu((int64_t) 200, list.tagOf(1));
+		checkEqu((int64_t) 300, list.tagOf(2));
+
+		list.replace(0, "1", 111);
+		checkEqu("1", list.strOf(0));
+		checkEqu((int64_t) 111, list.tagOf(0));
+		checkEqu((int64_t) 200, list.tagOf(1));
+		checkEqu((int64_t) 300, list.tagOf(2));
+
+		list.replace(1, "124", 222);
+		checkEqu("124", list.strOf(1));
+		checkEqu((int64_t) 111, list.tagOf(0));
+		checkEqu((int64_t) 222, list.tagOf(1));
+		checkEqu((int64_t) 300, list.tagOf(2));
+
+		checkEqu((int64_t) 300, list.tagOf(2));
+		list.replaceString(2, "4");
+		checkEqu("4", list.strOf(2));
+		checkEqu((int64_t) 111, list.tagOf(0));
+		checkEqu((int64_t) 222, list.tagOf(1));
+		checkEqu((int64_t) 300, list.tagOf(2));
+
+		list.replaceTag(2, 123);
+		checkEqu("4", list.strOf(2));
+		checkEqu((int64_t) 111, list.tagOf(0));
+		checkEqu((int64_t) 222, list.tagOf(1));
+		checkEqu((int64_t) 123, list.tagOf(2));
+	}
+	void testEqu(){
+		ReStringList list1;
+		ReStringList list2;
+
+		list1.split("1;2;1;3", ';');
+		list2.split("1\n2\n1\n3", '\n');
+		checkEqu(-1, list1.firstDiff(list2));
+		checkEqu(-1, list2.firstDiff(list1));
+		checkT(list1.equal(list2));
+		checkT(list2.equal(list1));
+
+		list1.insert(2, "x");
+		list1.remove(3);
+		checkEqu(2, list1.firstDiff(list2));
+		checkEqu(2, list2.firstDiff(list1));
+		checkF(list1.equal(list2));
+		checkF(list2.equal(list1));
+
+		list2.replace(2, "x");
+		checkEqu(-1, list1.firstDiff(list2));
+		checkEqu(-1, list2.firstDiff(list1));
+		checkT(list1.equal(list2));
+		checkT(list2.equal(list1));
+
+		list2.remove(3);
+		checkEqu(3, list1.firstDiff(list2));
+		checkEqu(3, list2.firstDiff(list1));
+		checkF(list1.equal(list2));
+		checkF(list2.equal(list1));
+
+		list1.replace(0, "");
+		checkEqu(0, list1.firstDiff(list2));
+		checkEqu(0, list2.firstDiff(list1));
+		checkF(list1.equal(list2));
+		checkF(list2.equal(list1));
+
+		list1.clear();
+		list2.clear();
+		checkEqu(-1, list1.firstDiff(list2));
+		checkEqu(-1, list2.firstDiff(list1));
+		checkT(list1.equal(list2));
+		checkT(list2.equal(list1));
+
+		list1.append("fjkdajfdkla");
+		checkEqu(0, list1.firstDiff(list2));
+		checkEqu(0, list2.firstDiff(list1));
+		checkF(list1.equal(list2));
+		checkF(list2.equal(list1));
+	}
+	void testJoin(){
+		ReStringList list;
+		const char* str = "1;abc;xyz;4;;99";
+		list.split(str, ';');
+		checkEqu(6U, list.getCount());
+		checkEqu("1", list.strOf(0));
+		checkEqu("abc", list.strOf(1));
+		checkEqu("xyz", list.strOf(2));
+		checkEqu("4", list.strOf(3));
+		checkEqu("", list.strOf(4));
+		checkEqu("99", list.strOf(5));
+		ReByteBuffer value;
+		list.join(";", value);
+		checkEqu(str, value.str());
+
+		list.split("1\r\n2\n\r3", '\n');
+		checkEqu(3U, list.getCount());
+		checkEqu("1", list.strOf(0));
+		checkEqu("2", list.strOf(1));
+		checkEqu("3", list.strOf(2));
+
+		list.split("xyz\tXYZ", '\t', true);
+		checkEqu(5U, list.getCount());
+		checkEqu("1", list.strOf(0));
+		checkEqu("2", list.strOf(1));
+		checkEqu("3", list.strOf(2));
+		checkEqu("xyz", list.strOf(3));
+		checkEqu("XYZ", list.strOf(4));
+
+
+	}
+	void testFile(){
+		createTestDir();
+		ReByteBuffer file;
+		file.set(getTestDir(), -1).append("abc.csv", -1);
+
+		ReStringList list;
+		const char* str = "1;abc;xyz;4;;99";
+		list.split(str, ';');
+		list.writeToFile(file.str(), "\n");
+
+		ReStringList list2;
+		list2.readFromFile(file.str(), true);
+
+		checkEqu(-1, list2.firstDiff(list2));
+	}
+	void testBase(){
+		ReStringList list;
+		ReByteBuffer value;
+
+		list.append("123", 100);
+		checkEqu(0U, list.indexOf("123"));
+		list.append("a", 200);
+		list.append("vwxyz", 300);
+
+		checkEqu(3U, list.getCount());
+		int index = 0;
+		checkEqu("123", list.strOf(index));
+		checkEqu(4U, list.sizeOf(index));
+		checkEqu((int64_t) 100, list.tagOf(index));
+
+		index++;
+		checkEqu("a", list.strOf(index));
+		checkEqu(2U, list.sizeOf(index));
+		checkEqu((int64_t) 200, list.tagOf(index));
+
+		index++;
+		checkEqu("vwxyz", list.strOf(index));
+		checkEqu(6U, list.sizeOf(index));
+		checkEqu((int64_t) 300, list.tagOf(index));
+
+		checkEqu(12U, list.sumOfSizes());
+
+		list.insert(0, "0", 50);
+		checkEqu(4U, list.getCount());
+		checkEqu(14U, list.sumOfSizes());
+
+		index = 0;
+		checkEqu("0", list.strOf(index));
+		checkEqu(2U, list.sizeOf(index));
+		checkEqu((int64_t) 50, list.tagOf(index));
+
+		index++;
+		checkEqu("123", list.strOf(index));
+		checkEqu(4U, list.sizeOf(index));
+		checkEqu((int64_t) 100, list.tagOf(index));
+
+		index++;
+		checkEqu("a", list.strOf(index));
+		checkEqu(2U, list.sizeOf(index));
+		checkEqu((int64_t) 200, list.tagOf(index));
+
+		index++;
+		checkEqu("vwxyz", list.strOf(index));
+		checkEqu(6U, list.sizeOf(index));
+		checkEqu((int64_t) 300, list.tagOf(index));
+
+		checkEqu(0U, list.indexOf("0"));
+		checkEqu(1U, list.indexOf("123"));
+		checkEqu(2u, list.indexOf("a"));
+		checkEqu(2u, list.indexOf("A", true));
+		checkEqu(3u, list.indexOf("vwxyz"));
+		checkEqu(3u, list.indexOf("VwXyz", true));
+
+		checkEqu(0u, list.indexOf("0", false, 0));
+		checkEqu(1u, list.indexOf("123", false, 1));
+		checkEqu(2u, list.indexOf("a", false, 1));
+		checkEqu(2u, list.indexOf("a", false, 2));
+		checkEqu(2u, list.indexOf("A", true, 2));
+		checkEqu(3u, list.indexOf("vwxyz", false, 2));
+		checkEqu(3u, list.indexOf("vwxyz", false, 3));
+		checkEqu(3u, list.indexOf("VwXyz", true, 3));
+
+		checkEqu((ReStringList::Index) -1, list.indexOf("A"));
+		checkEqu((ReStringList::Index) -1, list.indexOf("0123"));
+		checkEqu((ReStringList::Index) -1, list.indexOf("a", false, 3));
+		checkEqu((ReStringList::Index) -1, list.indexOf("A", true, 3));
+
+		checkEqu(0u, list.nextStartingWith(0, "0"));
+		checkEqu(1u, list.nextStartingWith(0, "12"));
+		checkEqu(2u, list.nextStartingWith(0, "a"));
+		checkEqu(2u, list.nextStartingWith(1, "a"));
+		checkEqu(2u, list.nextStartingWith(2, "a"));
+		checkEqu(2u, list.nextStartingWith(0, "A", true));
+		checkEqu((ReStringList::Index) -1, list.nextStartingWith(2, "Ab", true));
+		checkEqu((ReStringList::Index) -1, list.nextStartingWith(0, "b", true));
+
+		checkEqu(3u, list.nextStartingWith(0, "vwxy", false));
+		checkEqu(3u, list.nextStartingWith(0, "vwxy", true));
+		checkEqu((ReStringList::Index) -1, list.nextStartingWith(0, "vWxY", false));
+
+		ReStringList list2;
+		list2.append("a", 100);
+		list2.append("b", 200);
+		list2.append("c", 300);
+		ReStringList list3;
+		list3.append("x", 1000);
+		list3.append("y", 2000);
+
+		list2.append(list3);
+		checkEqu(5u, list2.getCount());
+		checkEqu("a", list2.strOf(0));
+		checkEqu(100ll, list2.tagOf(0));
+		checkEqu("b", list2.strOf(1));
+		checkEqu(200ll, list2.tagOf(1));
+		checkEqu("c", list2.strOf(2));
+		checkEqu(300ll, list2.tagOf(2));
+		checkEqu("x", list2.strOf(3));
+		checkEqu(1000ll, list2.tagOf(3));
+		checkEqu("y", list2.strOf(4));
+		checkEqu(2000ll, list2.tagOf(4));
+	}
+};
+extern void testReStringList(void);
+
+void testReStringList(void){
+	TestReStringList unit;
+}
+
diff --git a/cunit/cuReStringUtils.cpp b/cunit/cuReStringUtils.cpp
new file mode 100644
index 0000000..4832454
--- /dev/null
+++ b/cunit/cuReStringUtils.cpp
@@ -0,0 +1,185 @@
+#include "base/rebase.hpp"
+
+class TestReStringUtils : public ReTestUnit {
+public:
+	TestReStringUtils() : ReTestUnit("ReStringUtils", __FILE__){
+		run();
+	}
+private:
+	void run(){
+		testStrnicmp();
+		testIsInList();
+		testSplitPath();
+	}
+	void testStrnicmp(){
+		checkT(ReStringUtils::strnicmp("abc", "abc", 3) == 0);
+		checkT(ReStringUtils::strnicmp("abc", "ab", 3) > 0);
+		checkT(ReStringUtils::strnicmp("ab", "abc", 3) < 0);
+
+		checkT(ReStringUtils::strnicmp("aBc", "Abc", 3) == 0);
+		checkT(ReStringUtils::strnicmp("Abc", "aB", 3) > 0);
+		checkT(ReStringUtils::strnicmp("AB", "abc", 3) < 0);
+
+		checkT(ReStringUtils::strnicmp("ABC", "ABD", 2) == 0);
+		checkT(ReStringUtils::strnicmp("abC", "ABD", 2) == 0);
+
+		checkT(ReStringUtils::strnicmp("AAC", "ABD", 2) < 0);
+		checkT(ReStringUtils::strnicmp("aaC", "ABD", 2) < 0);
+
+		checkT(ReStringUtils::strnicmp("", "x", 99) < 0);
+		checkT(ReStringUtils::strnicmp("x", "", 99) > 0);
+
+		checkT(ReStringUtils::strnicmp("abc", "abc", 99) == 0);
+		checkT(ReStringUtils::strnicmp("abc", "ab", 99) > 0);
+		checkT(ReStringUtils::strnicmp("ab", "abc", 99) < 0);
+	}
+	void testIsInList(){
+		checkT(ReStringUtils::isInList("abc", ";abc;def", true));
+		checkT(ReStringUtils::isInList("aBc", ";abc;def", true));
+		checkF(ReStringUtils::isInList("aBc", ";abc;def", false));
+
+		checkF(ReStringUtils::isInList("aBc", ";abc;def", false));
+
+		checkT(ReStringUtils::isInList("abc", ";a;abc;def", true));
+		checkT(ReStringUtils::isInList("aBc", ";b;abc;def", true));
+		checkF(ReStringUtils::isInList("aBc", ";c;abc;def", false));
+
+		checkF(ReStringUtils::isInList("aBc", ";a;abcabc;def", false));
+
+		checkT(ReStringUtils::isInList("abc", ";abc", true));
+		checkT(ReStringUtils::isInList("aBc", ";abc", true));
+		checkF(ReStringUtils::isInList("aBc", ";abc", false));
+
+		checkF(ReStringUtils::isInList("aBc", ";abc", false));
+
+	}
+	void testSplitPath(){
+		ReByteBuffer fullname, protocol, path, name, ext;
+		const char* fn = "file:/etc/samba/smb.cnf";
+
+		ReStringUtils::splitPath(fn, &protocol, &path, &name, &ext);
+		checkEqu("file:", protocol.str());
+		checkEqu("/etc/samba/", path.str());
+		checkEqu("smb", name.str());
+		checkEqu(".cnf", ext.str());
+
+		ReStringUtils::joinPath(fullname, &protocol, &path, &name, &ext);
+		checkEqu(fn, fullname.str());
+
+		fn = "/etc/samba/smb.cnf";
+
+		ReStringUtils::splitPath(fn, &protocol, &path, &name, &ext);
+		checkEqu("", protocol.str());
+		checkEqu("/etc/samba/", path.str());
+		checkEqu("smb", name.str());
+		checkEqu(".cnf", ext.str());
+
+		ReStringUtils::joinPath(fullname, &protocol, &path, &name, &ext);
+		checkEqu(fn, fullname.str());
+
+		fn = "smb.cnf";
+
+		ReStringUtils::splitPath(fn, &protocol, &path, &name, &ext);
+		checkEqu("", protocol.str());
+		checkEqu("", path.str());
+		checkEqu("smb", name.str());
+		checkEqu(".cnf", ext.str());
+
+		ReStringUtils::joinPath(fullname, &protocol, &path, &name, &ext);
+		checkEqu(fn, fullname.str());
+
+		fn = "smb";
+
+		ReStringUtils::splitPath(fn, &protocol, &path, &name, &ext);
+		checkEqu("", protocol.str());
+		checkEqu("", path.str());
+		checkEqu("smb", name.str());
+		checkEqu("", ext.str());
+
+		ReStringUtils::joinPath(fullname, &protocol, &path, &name, &ext);
+		checkEqu(fn, fullname.str());
+
+		fn = "file:smb.003.cnf";
+
+		ReStringUtils::splitPath(fn, &protocol, &path, &name, &ext);
+		checkEqu("file:", protocol.str());
+		checkEqu("", path.str());
+		checkEqu("smb.003", name.str());
+		checkEqu(".cnf", ext.str());
+
+		ReStringUtils::joinPath(fullname, &protocol, &path, &name, &ext);
+		checkEqu(fn, fullname.str());
+
+		fn = "file:/etc.bak/smb";
+
+		ReStringUtils::splitPath(fn, &protocol, &path, &name, &ext);
+		checkEqu("file:", protocol.str());
+		checkEqu("/etc.bak/", path.str());
+		checkEqu("smb", name.str());
+		checkEqu("", ext.str());
+
+		ReStringUtils::joinPath(fullname, &protocol, &path, &name, &ext);
+		checkEqu(fn, fullname.str());
+
+		fn = "file:/etc/samba/smb.cnf";
+
+		ReStringUtils::splitPath(fn, NULL, &path, &name, &ext);
+		checkEqu("file:", protocol.str());
+		checkEqu("smb", name.str());
+		checkEqu(".cnf", ext.str());
+
+		ReStringUtils::joinPath(fullname, &protocol, NULL, &name, &ext);
+		checkEqu("file:smb.cnf", fullname.str());
+
+		fn = "file:/etc/samba/smb.cnf";
+
+		ReStringUtils::splitPath(fn, NULL, NULL, &name, &ext);
+		checkEqu("smb", name.str());
+		checkEqu(".cnf", ext.str());
+
+		ReStringUtils::joinPath(fullname, NULL, NULL, &name, &ext);
+		checkEqu("smb.cnf", fullname.str());
+
+		fn = "file:/etc/samba/smb.cnf";
+
+		ReStringUtils::splitPath(fn, NULL, NULL, &name, NULL);
+		//checkEqu("", protocol.str());
+		//checkEqu("/etc/samba/", path.str());
+		checkEqu("smb", name.str());
+		//checkEqu(".cnf", ext.str());
+
+		ReStringUtils::joinPath(fullname, NULL, NULL, &name, NULL);
+		checkEqu("smb", fullname.str());
+
+		fn = "file:/etc/samba/smb.cnf";
+
+		ReStringUtils::splitPath(fn, NULL, &path, NULL, &ext);
+		//checkEqu("", protocol.str());
+		checkEqu("/etc/samba/", path.str());
+		//checkEqu("smb", name.str());
+		checkEqu(".cnf", ext.str());
+
+		ReStringUtils::joinPath(fullname, NULL, &path, NULL, &ext);
+		checkEqu("/etc/samba/.cnf", fullname.str());
+
+		ReStringUtils::joinPath(fullname, "http:", "//any.de/", "name", ".ext");
+		checkEqu("http://any.de/name.ext", fullname.str());
+
+		ReStringUtils::joinPath(fullname, NULL, "/any.de/", "name", ".ext");
+		checkEqu("/any.de/name.ext", fullname.str());
+
+		ReStringUtils::joinPath(fullname, NULL, NULL, "name", ".ext");
+		checkEqu("name.ext", fullname.str());
+
+		ReStringUtils::joinPath(fullname, NULL, NULL, "name", NULL);
+		checkEqu("name", fullname.str());
+
+		ReStringUtils::joinPath(fullname, "file:", "/", NULL, NULL);
+		checkEqu("file:/", fullname.str());
+	}
+};
+extern void testReStringUtils(void);
+
+void testReStringUtils(void){
+	TestReStringUtils unit;
+}
diff --git a/cunit/cuReTraverser.cpp b/cunit/cuReTraverser.cpp
index 7ad4b2e..1fecf21 100644
--- a/cunit/cuReTraverser.cpp
+++ b/cunit/cuReTraverser.cpp
@@ -21,7 +21,7 @@ private:
 		ReTraverser traverser("/tmp/test");
 		int level = 0;
 		const DirStatus_t* entry = traverser.nextFile(level);
-		checkEqu("xy12.ab", nameOfEntry(entry));
+		//checkEqu("xy12.ab", nameOfEntry(entry));
 	}
 };
 extern void testReTraverser(void);
diff --git a/cunit/cuReVarArgs.cpp b/cunit/cuReVarArgs.cpp
new file mode 100644
index 0000000..e6d0aea
--- /dev/null
+++ b/cunit/cuReVarArgs.cpp
@@ -0,0 +1,55 @@
+#include "base/rebase.hpp"
+
+class TestReVarArgs : public ReTestUnit, public ReVarArgTrigger {
+public:
+	TestReVarArgs()
+		:
+		ReTestUnit("ReVarArgs", __FILE__),
+		m_argNo(0),
+		m_maxNo(0)
+	{
+		run();
+	}
+	virtual void newArg(int no, int maxNo){
+		m_argNo = no;
+		m_maxNo = maxNo;
+	}
+private:
+	void run(){
+		ReVarArgs list("$1 $$ $2");
+		list.registerTrigger(this);
+
+		list.arg(0).arg(9, "%03u");
+		checkEqu(m_argNo, 2);
+		checkEqu(m_maxNo, 2);
+		checkEqu("0 $ 009", list.asCString());
+
+
+		list.reset("x$1y$2");
+		list.arg(1.5);
+		checkEqu(m_argNo, 1);
+		checkEqu(m_maxNo, 2);
+		list.arg(2.45,"%7.3f");
+		checkEqu(m_argNo, 2);
+		checkEqu(m_maxNo, 2);
+		checkEqu("x1.500000y  2.450", list.asCString());
+
+		list.reset("$2,$1!$3;$4");
+		list.arg("1").arg("ab", 4);
+		list.arg("xy", 0, 1);
+		checkEqu(m_argNo, 3);
+		checkEqu(m_maxNo, 4);
+		list.arg("ww", 5, 0, true);
+		checkEqu(m_argNo, 4);
+		checkEqu(m_maxNo, 4);
+		checkEqu("ab  ,1!x;   ww", list.asCString());
+	}
+private:
+	int m_argNo;
+	int m_maxNo;
+};
+extern void testReVarArgs(void);
+
+void testReVarArgs(void){
+	TestReVarArgs unit;
+}
diff --git a/cunit/cuReconfig.cpp b/cunit/cuReconfig.cpp
new file mode 100644
index 0000000..94c22cd
--- /dev/null
+++ b/cunit/cuReconfig.cpp
@@ -0,0 +1,42 @@
+#include "base/rebase.hpp"
+
+class TestReConfigFile : public ReTestUnit {
+	typedef ReHashList::Byte Byte;
+public:
+	TestReConfigFile() : ReTestUnit("ReConfigFile", __FILE__){
+		run();
+	}
+private:
+	void run(){
+		testBasic();
+	}
+	void testBasic(){
+		createTestDir();
+		ReByteBuffer fn;
+		fn.append(getTestDir(), -1).append("reconfigfile.cfg", -1);
+		createFile(fn.str(), "#x.int=a\nx.int=1\nx.bool=true\nx.str=abc\nx.bool2=0\nstring=abc\n");
+		ReConfigFile config(fn.str());
+		checkT(config.isValid());
+		checkEqu(1, config.getInteger("x.int", 2));
+		checkEqu(2, config.getInteger("x.int2", 2));
+
+		checkT(config.getBool("x.bool", true));
+		checkT(config.getBool("x.bool", false));
+		checkT(config.getBool("y.bool", true));
+		checkF(config.getBool("y.bool", false));
+
+		checkF(config.getBool("x.bool2", true));
+		checkF(config.getBool("x.bool2", false));
+
+		ReByteBuffer buffer;
+		config.getString("string", buffer, "x");
+		checkEqu("abc", buffer.str());
+		config.getString("string1", buffer, "x");
+		checkEqu("x", buffer.str());
+	}
+};
+extern void testReConfigFile(void);
+
+void testReConfigFile(void){
+	TestReConfigFile unit;
+}
diff --git a/cunit/testall.cpp b/cunit/testall.cpp
index 6635971..554b33d 100644
--- a/cunit/testall.cpp
+++ b/cunit/testall.cpp
@@ -6,7 +6,9 @@
  */
 #include "base/rebase.hpp"
 #include "os/reos.hpp"
+#ifdef __RE_TEST__
 #include "net/renet.hpp"
+#endif
 
 void testBase(){
 	extern void testReByteBuffer();
@@ -41,10 +43,12 @@ void testString(){
 	testReStringUtils();
 	extern void testReString(void);
 	testReString();
+	extern void testReMatcher();
+	testReMatcher();
 }
 void testOs(){
 	void testReTraverser();
-	testReTraverser();
+	//testReTraverser();
 }
 void testAll(){
 	try
diff --git a/net/ReUdpConnection.cpp b/net/ReUdpConnection.cpp
index 6c2ad5b..2aeb961 100644
--- a/net/ReUdpConnection.cpp
+++ b/net/ReUdpConnection.cpp
@@ -36,7 +36,7 @@ ReUdpConnection::~ReUdpConnection() {
  *
  * @return The IP address as string.
  */
-const char* ReUdpConnection::getAddress() const {
+const char* ReUdpConnection::address() const {
 	const char* rc = inet_ntoa(m_address.sin_addr);
 	return rc;
 }
@@ -75,7 +75,7 @@ int ReUdpConnection::receive(int timeout, ReByteBuffer* buffer, bool doLog){
 		doRead = FD_ISSET(m_socket, &rdset);
 	}
 	buffer->ensureSize(8096 + 1);
-	size_t size = buffer->getSize();
+	size_t size = buffer->capacity();
 	buffer->setLength(size);
 	if (!doRead)
 		m_logger->sayF(LOG_WARNING|GRAN_USER|CAT_NETWORK, LC_UDPCONNECTION_RECEIVE_2,
@@ -83,16 +83,16 @@ int ReUdpConnection::receive(int timeout, ReByteBuffer* buffer, bool doLog){
 	else {
 		int length = recvfrom(
 			m_socket,
-			buffer->getBuffer(), size - 1, 0,
+			buffer->buffer(), size - 1, 0,
 			(struct sockaddr *) &m_address,
 			&addrLength);
 		buffer->setLength(length >= 0 ? length : 0);
 		if (doLog)
 			m_logger->sayF(LOG_INFO|GRAN_USER|CAT_NETWORK, LC_UDPCONNECTION_RECEIVE_1,
-				"$1:$2 $3").arg(getAddress()).arg(m_port)
-				.arg(buffer->getBuffer()).end();
+				"$1:$2 $3").arg(address()).arg(m_port)
+				.arg(buffer->buffer()).end();
 	}
-	return buffer->getLength();
+	return buffer->length();
 }
 /** @brief Sends a message.
  *
@@ -112,7 +112,7 @@ int ReUdpConnection::send(const char* buffer, int bufferLength){
 	if (rc <= 0)
         m_logger->sayF(LOG_ERROR|GRAN_USER|CAT_NETWORK, LC_UDPCONNECTION_SEND_1,
         		i18n("Sending failed: $1:$2 $3"))
-        		.arg(getAddress()).arg(m_port).arg(strerror(errno)).end();
+        		.arg(address()).arg(m_port).arg(strerror(errno)).end();
 	else
         m_logger->sayF(LOG_INFO|GRAN_USER|CAT_NETWORK, LC_UDPCONNECTION_SEND_2,
         		i18n("$1 bytes sent")).arg(rc).end();
@@ -122,7 +122,7 @@ int ReUdpConnection::send(const char* buffer, int bufferLength){
  *
  * @return The internal buffer.
  */
-ReByteBuffer& ReUdpConnection::getBuffer(){
+ReByteBuffer& ReUdpConnection::buffer(){
 	return m_buffer;
 }
 
@@ -132,7 +132,7 @@ void ReUdpConnection::close(){
 	if (m_socket != 0)
 	{
         m_logger->sayF(LOG_INFO|GRAN_USER|CAT_NETWORK, LC_UDPCONNECTION_CLOSE_1,
-        		i18n("Connection has been closed: $1:$2")).arg(getAddress()).arg(m_port).end();
+        		i18n("Connection has been closed: $1:$2")).arg(address()).arg(m_port).end();
 		if (::close(m_socket) != 0)
 	        m_logger->sayF(LOG_ERROR|GRAN_USER|CAT_NETWORK, LC_UDPCONNECTION_CLOSE_2,
 	        		i18n("socket close failed: $1")).arg(strerror(errno)).end();
@@ -264,12 +264,12 @@ void ReUdpMaster::run(){
 		answer.setLength(0);
 		if (canLog(m_buffer))
 			m_logger->sayF(LOG_INFO|GRAN_USER|CAT_NETWORK, LC_UDPCONNECTION_RUN_1,
-				"$1:$2 $3").arg(getAddress()).arg(m_port)
-				.arg(m_buffer.getBuffer()).end();
+				"$1:$2 $3").arg(address()).arg(m_port)
+				.arg(m_buffer.buffer()).end();
 
 		again = handlePage(m_buffer, answer, *this);
-		if (answer.getLength() > 0){
-			send(answer.getBuffer(), answer.getLength());
+		if (answer.length() > 0){
+			send(answer.buffer(), answer.length());
 		}
 	}
 }
diff --git a/net/ReUdpConnection.hpp b/net/ReUdpConnection.hpp
index 2b729d1..48ffd49 100644
--- a/net/ReUdpConnection.hpp
+++ b/net/ReUdpConnection.hpp
@@ -22,13 +22,13 @@ public:
 	ReUdpConnection(bool isServer, ReLogger* logger);
 	virtual ~ReUdpConnection();
 public:
-	const char* getAddress() const;
-	int getPort() const
+	const char* address() const;
+	int port() const
 	{ return m_port; }
 	int receive(int timeout = 0, ReByteBuffer* buffer = NULL, bool doLog = true);
 	int send(const char* buffer, int bufferLength = -1);
 	void close();
-	ReByteBuffer& getBuffer();
+	ReByteBuffer& buffer();
 protected:
 	int m_socket;
 	struct sockaddr_in m_address;
diff --git a/os/ReTraverser.cpp b/os/ReTraverser.cpp
index 61a73aa..098860e 100644
--- a/os/ReTraverser.cpp
+++ b/os/ReTraverser.cpp
@@ -1,381 +1,305 @@
-/*
- * ReTraverser.cpp
- *
- *  Created on: 23.12.2014
- *      Author: hm
- */
-
-#include "../base/rebase.hpp"
-#include "os/reos.hpp"
-
-#ifdef __LINUX__
-#define isUndefHandle(handle) ((handle) == NULL)
-#define findFirstEntry(path, data) opendir(path)
-#define findNextEntry(handle,data) (((data) = readdir(handle)) != NULL)
-#define closeDir(handle) closedir(handle)
-#define initEntryBuffer(entry)
-#define setHandleUndef(h) ((h) = NULL)
-#else
-#define isUndefHandle(handle) ((handle) == INVALID_HANDLE_VALUE)
-#define setHandleUndef(h) ((h) = INVALID_HANDLE_VALUE)
-#define findFirstEntry(path, pattern, data) FindFirstFileA(path, pattern, data)
-#define findNextEntry(handle, data) (FindNextFileA(handle, data) != 0)
-#define closeDir(handle) FindClose(handle)
-#define initEntryBuffer(entry) ((entry)->m_data = &(entry)->m_buffer)
-#endif
-
-/**
- * Constructor.
- */
-ReMatcher::ReMatcher() :
-	m_prefix(1),
-	m_suffix(1),
-	m_tokens(0),
-	m_findAll(false),
-	m_ignoreCase(true),
-	m_notPattern(false)
-{
-	memset((void*) m_tokenStart, 0, sizeof m_tokenStart);
-	memset((void*) m_tokenEnd, 0, sizeof m_tokenEnd);
-	memset((void*) m_tokenLength, 0, sizeof m_tokenLength);
-	memset((void*) m_type, 0, sizeof m_type);
-}
-/**
- * Constructor.
- *
- * @param pattern		the search pattern
- */
-ReMatcher::ReMatcher(const char* pattern) :
-	m_prefix(1),
-	m_suffix(1),
-	m_tokens(0),
-	m_findAll(false),
-	m_ignoreCase(true),
-	m_notPattern(false)
-{
-	memset((void*) m_tokenStart, 0, sizeof m_tokenStart);
-	memset((void*) m_tokenEnd, 0, sizeof m_tokenEnd);
-	memset((void*) m_tokenLength, 0, sizeof m_tokenLength);
-	memset((void*) m_type, 0, sizeof m_type);
-	compile(pattern);
-}
-/**
- * Destructor.
- */
-ReMatcher::~ReMatcher(){
-}
-
-/**
- * Compiles the pattern into a internal structure.
- *
- * @param pattern		pattern to compile
- * @return			<code>true</code>: success<br>
- * 					<code>false</code>: error occurred
- */
-bool ReMatcher::compile(const char* pattern){
-	bool rc = true;
-	const char* start = strchr(pattern, '*');
-	size_t length = strlen(pattern);
-	if (start == NULL){
-		m_prefix = pattern;
-		m_suffix = pattern;
-	} else {
-		if (length == 1)
-			m_findAll = true;
-		else{
-			size_t ix = size_t(start - pattern);
-			if (start != pattern){
-				m_prefix.append(pattern, ix);
-			}
-			if (ix < length - 1){
-				m_suffix.append(start + 1, length - ix);
-			}
-		}
-	}
-	return rc;
-}
-/**
- * Tests whether a name matches the pattern stored in the instance.
- *
- * @param name		the name to test
- * @return			<code>true</code>: ! m_notPattern: the name matches<br>
- * 											 m_notPattern: the name matches not<br>
- * 					<code>false</code>: otherwise
- */
-bool ReMatcher::match(const char* name){
-	bool rc = m_findAll;
-	if (! rc){
-		size_t width = m_prefix.getLength();
-		if (width == 0)
-			rc = true;
-		else {
-			rc = m_ignoreCase ? strncasecmp(name, m_prefix.str(), width) == 0
-						: strncmp(name, m_prefix.str(), width) == 0;
-		}
-		if (rc && (width = m_suffix.getLength()) != 0){
-			size_t length = strlen(name);
-			rc = length >= m_suffix.getLength();
-			if (rc){
-				const char* tail = name + length - width;
-				rc = m_ignoreCase ? strncasecmp(tail, m_suffix.str(), width) == 0
-							: strncmp(tail, m_suffix.str(), width) == 0;
-			}
-		}
-	}
-	if (m_notPattern)
-		rc = ! rc;
-	return rc;
-}
-
-/**
- * Constructor.
- */
-RePatternList::RePatternList() :
-	m_patterns(NULL),
-	m_count(0)
-{
-}
-/**
- * Destructor.
- */
-RePatternList::~RePatternList(){
-	destroy();
-}
-void RePatternList::destroy(){
-	if (m_patterns != NULL){
-		for (int ix = 0; ix < m_count; ix++){
-			delete m_patterns[ix];
-			m_patterns[ix] = NULL;
-		}
-	}
-	delete[] m_patterns;
-	m_patterns = NULL;
-}
-/**
- * Tests whether a name matches at least one of the patterns.
- * @param name		name to test
- * @return			<code>true</code>: at least one pattern matches<br>
- * 					<code>false</code>: no pattern matches
- */
-bool RePatternList::match(const char* name){
-	bool rc = false;
-	for (int ix = 0; ix < m_count; ix++)
-		if (m_patterns[ix]->match(name)){
-			rc = true;
-			break;
-		}
-	return rc;
-}
-/**
- * Sets the pattern list from a string.
- *
- * @param patterns	a string with one or more patterns
- * @param separator	NULL: the first char of <code>patterns</code> is the the separator<br>
- * 						otherwise: the separator between the patterns
- */
-void RePatternList::set(const char* patterns, const char* separator){
-	char buffer[2];
-	destroy();
-	if (separator == NULL){
-		buffer[0] = patterns[0];
-		buffer[1] = '\0';
-		separator = buffer;
-		patterns++;
-	}
-	const char* start = patterns;
-	m_count = 1;
-	size_t length = strlen(separator);
-	while( (start = strstr(start, separator)) != NULL){
-		m_count++;
-		start += length;
-	}
-	m_patterns = new ReMatcher*[m_count];
-	int ix = 0;
-	start = patterns;
-	const char* end;
-	while( (end = strstr(start, separator)) != NULL){
-		setOne(ix, start, end - start);
-		start = end + length;
-		ix++;
-	}
-	setOne(ix, start, strlen(start));
-}
-
-/**
- * Sets one pattern in the pattern list.
- *
- * @param ix				index of the pattern in the list
- * @param pattern			the pattern string
- * @param patternLength	the length of <code>pattern</code>
- */
-void RePatternList::setOne(int ix, const char* pattern, size_t patternLength){
-	ReByteBuffer buffer;
-	buffer.append(pattern, patternLength);
-	m_patterns[ix] = new ReMatcher(buffer.str());
-}
-/**
- * Constructor.
- */
-DirEntryFilter_t::DirEntryFilter_t() :
-	m_regulars(true),
-	m_specials(true),
-	m_directories(true),
-	m_nodePatterns(),
-	m_pathPatterns(),
-	m_minSize(0),
-	m_maxSize(-1),
-	m_minAge(0),
-	m_maxAge(0)
-{
-}
-/**
- *
- */
-bool DirEntryFilter_t::match(DirStatus_t& entry){
-	bool rc = false;
-	do {
-		if (! m_directories && isDirEntry(&entry))
-			break;
-		if (m_specials && (isDirEntry(&entry) || isRegularEntry(&entry)))
-			break;
-		if (m_regulars && ! isRegularEntry(&entry))
-			break;
-		if (m_minSize > 0 && sizeOfEntry(&entry) > m_minSize)
-			break;
-		if (m_maxSize >= 0 && sizeOfEntry(&entry) < m_maxSize)
-			break;
-		if (m_minAge != 0 && modifiedOfEntry(&entry) < m_minAge)
-			break;
-		if (m_maxAge != 0 && modifiedOfEntry(&entry) > m_maxAge)
-			break;
-		if (m_nodePatterns != NULL && ! m_nodePatterns->match(nameOfEntry(&entry)))
-			break;
-		if (m_pathPatterns != NULL && ! m_pathPatterns->match(entry.m_path.str()))
-			break;
-		rc = true;
-	} while(false);
-	return rc;
-};
-
-/**
- * Returns the status of the current file (lazy loading).
- *
- * @return	the status of the current file
- */
-struct stat* DirStatus_t::getStatus() {
-	if (m_status.st_ino == 0)
-		if (stat(m_data->d_name, &m_status) != 0)
-			memset((void*) &m_status, 0, sizeof m_status);
-	return &m_status;
-}
-
-/**
- * Constructor.
- *
- * @param base		the base directory. The traversal starts at this point
- */
-ReTraverser::ReTraverser(const char* base) :
-	m_level(-1),
-	m_base(base)
-{
-	initEntry(base, 0);
-}
-
-/**
- * Destructor.
- */
-ReTraverser::~ReTraverser() {
-}
-
-/**
- * Returns the info about the next file in the directory tree traversal.
- *
- * @param level	OUT: the level relative to the base.<br>
- * 					0 means the file is inside the base.<br>
- * 					Not defined if the result is NULL
- * @return NULL	no more files<br>
- * 					otherwise: the stack entry with the next file in the
- * 					directory tree. May be a directory too
- */
-DirStatus_t* ReTraverser::rawNextFile(int& level)
-{
-	DirStatus_t* rc = NULL;
-	bool again = false;
-	do{
-		if (m_level < 0){
-			initEntry(m_base.str(), 0);
-			if (! isUndefHandle(m_dirs[0].m_handle))
-				rc = &m_dirs[0];
-		} else {
-			DirStatus_t* current = &m_dirs[level];
-			if (findNextEntry(current->m_handle, current->m_data)){
-				if (current->m_passNo != m_passNoForDirSearch){
-					rc = &m_dirs[m_level];
-				} else {
-
-				}
-			} else {
-				if (current->m_passNo == 1){
-					initEntry(m_base.str(), m_level);
-					current->m_passNo = 2;
-					if (! isUndefHandle(m_dirs[0].m_handle))
-						rc = &m_dirs[0];
-				}
-			}
-		}
-	} while(again);
-	return rc;
-}
-/**
- * Returns the info about the next file matching the filter options.
- *
- * @param level	OUT: the level relative to the base.<br>
- * 					0 means the file is inside the base.<br>
- * 					Not defined if the result is NULL
- * @param filter	NULL: every file matches<br>
- * 					otherwise: each found file must match this filter conditions
- * @return NULL	no more files<br>
- * 					otherwise: the info about the next file in the
- * 					directory tree
- */
-DirStatus_t* ReTraverser::nextFile(int& level, DirEntryFilter_t* filter){
-	DirStatus_t* rc = rawNextFile(level);
-	while (rc != NULL){
-		if (filter == NULL || filter->match(*rc)){
-			break;
-		}
-	}
-	return rc;
-}
-
-/**
- * Initializes an entry in the directory entry stack.
- *
- * @param path		the name of the directory belonging to the entry
- * @param level	the index of the entry in the stack
- */
-void ReTraverser::initEntry(const char* path, int level){
-	if (level < MAX_ENTRY_STACK_DEPTH){
-		DirStatus_t* current = &m_dirs[level];
-		initEntryBuffer(current);
-		current->m_handle = findFirstEntry(path, &m_current->m_data);
-		m_level = level;
-	}
-}
-
-/**
- * Frees the resources of an entry of the directory entry stack.
- *
- * @param level	the index of the entry in the stack
- */
-void ReTraverser::freeEntry(int level){
-	if (level < MAX_ENTRY_STACK_DEPTH){
-		DirStatus_t* current = &m_dirs[level];
-		if (! isUndefHandle(current->m_handle)){
-			closeDir(current->m_handle);
-			setHandleUndef(current->m_handle);
-		}
-		current->m_path.setLength(0);
-	}
-}
-
+/*
+ * ReTraverser.cpp
+ *
+ *  Created on: 23.12.2014
+ *      Author: hm
+ */
+
+#include "base/rebase.hpp"
+#include "os/reos.hpp"
+
+#ifdef __linux__
+const char ReTraverser::m_separator = '/';
+const char* const ReTraverser::m_separatorStr = "/";
+#elif defined __WIN32__
+const char ReTraverser::m_separator = '\\';
+const char* const ReTraverser::m_separatorStr = "\\";
+#endif
+
+#ifdef __linux__
+#define isUndefHandle(handle) ((handle) == NULL)
+#define findFirstEntry(path, data) opendir(path)
+#define findNextEntry(handle,data) (((data) = readdir(handle)) != NULL)
+#define closeDir(handle) closedir(handle)
+#define initEntryBuffer(entry)
+#define setHandleUndef(h) ((h) = NULL)
+#else
+#define isUndefHandle(handle) ((handle) == INVALID_HANDLE_VALUE)
+#define setHandleUndef(h) ((h) = INVALID_HANDLE_VALUE)
+HANDLE findFirstEntry(const char* path, DirInfoStruct_t* data){
+    ReByteBuffer thePath(path);
+    thePath.append("\\*");
+    HANDLE rc = FindFirstFileA(thePath.str(), data);
+    return rc;
+}
+#define findNextEntry(handle, data) (FindNextFileA(handle, data) != 0)
+#define closeDir(handle) FindClose(handle)
+#define initEntryBuffer(entry) ((entry)->m_data = &(entry)->m_dataBuffer)
+#endif
+
+const char* DirStatus_t::nameOfEntry() const{
+#ifdef __linux__
+    return m_data->d_name;
+#elif defined __WIN32__
+    return m_data->cFileName;
+#endif
+}
+bool DirStatus_t::isDirectory() {
+#ifdef __linux__
+    return (m_data->d_type != DT_UNKNOWN && m_data->d_type == DT_DIR) || S_ISDIR(getStatus()->st_mode);
+#elif defined __WIN32__
+    return 0 != (m_dataBuffer.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
+#endif
+}
+bool DirStatus_t::isLink() {
+	bool rc;
+#ifdef __linux__
+    rc = (m_data->d_type != DT_UNKNOWN && m_data->d_type == DT_LNK) || S_ISLNK(getStatus()->st_mode);
+#elif defined __WIN32__
+    rc = 0 != (m_dataBuffer.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT);
+#endif
+    return rc;
+}
+bool DirStatus_t::isRegular() {
+#ifdef __linux__
+    return (m_data->d_type != DT_UNKNOWN && m_data->d_type == DT_REG) || S_ISREG(getStatus()->st_mode);
+#elif defined __WIN32__
+    return 0 != (m_dataBuffer.dwFileAttributes & (FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_DEVICE));
+#endif
+}
+FileSize_t DirStatus_t::fileSize() {
+#ifdef __linux__
+    return getStatus()->st_size;
+#elif defined __WIN32__
+    return ((int64_t) m_dataBuffer.nFileSizeHigh << 32) + m_dataBuffer.nFileSizeLow;
+#endif
+}
+const FileTime_t* DirStatus_t::modified() {
+#ifdef __linux__
+    return &(getStatus()->st_mtime);
+#elif defined __WIN32__
+    return &m_dataBuffer.ftLastWriteTime;
+#endif
+}
+
+time_t DirStatus_t::filetimeToTime(const FileTime_t* filetime){
+#ifdef __linux__
+    return *filetime;
+#elif defined __WIN32__
+    // takes the last modified date
+    LARGE_INTEGER date, adjust;
+    date.HighPart = filetime->dwHighDateTime;
+    date.LowPart = filetime->dwLowDateTime;
+    // 100-nanoseconds = milliseconds * 10000
+    adjust.QuadPart = 11644473600000 * 10000;
+    // removes the diff between 1970 and 1601
+    date.QuadPart -= adjust.QuadPart;
+    // converts back from 100-nanoseconds to seconds
+    return (time_t) (date.QuadPart / 10000000);
+#endif
+}
+
+void  DirStatus_t::timeToFiletime(time_t time, FileTime_t& filetime){
+#ifdef __linux__
+    filetime = time;
+#elif defined __WIN32__
+    LONGLONG ll = Int32x32To64(time, 10000000) + 116444736000000000;
+    filetime.dwLowDateTime = (DWORD)ll;
+    filetime.dwHighDateTime = ll >> 32;;
+#endif
+}
+
+/**
+ * Constructor.
+ */
+DirEntryFilter_t::DirEntryFilter_t() :
+	m_regulars(true),
+	m_specials(true),
+	m_directories(true),
+	m_nodePatterns(),
+	m_pathPatterns(),
+	m_minSize(0),
+	m_maxSize(-1),
+	m_minAge(),
+	m_maxAge()
+{
+}
+/**
+ *
+ */
+bool DirEntryFilter_t::match(DirStatus_t& entry){
+	bool rc = false;
+	do {
+		if (! m_directories && entry.isDirectory())
+			break;
+        if (m_specials && (entry.isDirectory() || entry.isRegular()))
+			break;
+		if (m_regulars && ! entry.isRegular())
+			break;
+        if (m_minSize > 0 && entry.fileSize() > m_minSize)
+			break;
+		if (m_maxSize >= 0 && entry.fileSize() < m_maxSize)
+			break;
+		if (m_minAge != 0 && DirStatus_t::filetimeToTime(entry.modified()) < m_minAge)
+			break;
+		if (m_maxAge != 0 && DirStatus_t::filetimeToTime(entry.modified()) > m_maxAge)
+			break;
+		if (m_nodePatterns != NULL && ! m_nodePatterns->match(entry.nameOfEntry()))
+			break;
+		if (m_pathPatterns != NULL && ! m_pathPatterns->match(entry.m_path.str()))
+			break;
+		rc = true;
+	} while(false);
+	return rc;
+};
+
+#ifdef __linux__
+/**
+ * Returns the status of the current file (lazy loading).
+ *
+ * @return	the status of the current file
+ */
+struct stat* DirStatus_t::getStatus() {
+	if (m_status.st_ino == 0)
+		if (stat(m_data->d_name, &m_status) != 0)
+			memset((void*) &m_status, 0, sizeof m_status);
+	return &m_status;
+}
+#endif
+
+/**
+ * Constructor.
+ *
+ * @param base		the base directory. The traversal starts at this point
+ */
+ReTraverser::ReTraverser(const char* base) :
+	m_level(-1),
+	m_base(base)
+{
+	initEntry(base, 0);
+}
+
+/**
+ * Destructor.
+ */
+ReTraverser::~ReTraverser() {
+}
+
+/**
+ * Returns the info about the next file in the directory tree traversal.
+ *
+ * @param level	OUT: the level relative to the base.<br>
+ * 					0 means the file is inside the base.<br>
+ * 					Not defined if the result is NULL
+ * @return NULL	no more files<br>
+ * 					otherwise: the stack entry with the next file in the
+ * 					directory tree. May be a directory too
+ */
+DirStatus_t* ReTraverser::rawNextFile(int& level)
+{
+	DirStatus_t* rc = NULL;
+	bool again = false;
+	do{
+		if (m_level < 0){
+			// first call:
+			initEntry(m_base.str(), 0);
+			if (! isUndefHandle(m_dirs[0].m_handle))
+				rc = &m_dirs[0];
+		} else {
+			DirStatus_t* current = &m_dirs[level];
+			if (findNextEntry(current->m_handle, current->m_data)){
+				// a file or directory found:
+				if (current->m_passNo != m_passNoForDirSearch){
+					// we search for any file:
+					rc = &m_dirs[m_level];
+				} else {
+					// we are interested only in subdirectories:
+					again = true;
+					if (rc->isDirectory()){
+						// open a new level:
+						level++;
+						m_base.append(ReTraverser::m_separatorStr);
+						m_base.append(rc->nameOfEntry());
+						initEntry(m_base.str(), level + 1);
+					}
+				}
+			} else {
+				// the current subdir does not have more files:
+				if (current->m_passNo == 1){
+					// we start the second pass:
+					initEntry(m_base.str(), m_level);
+					current->m_passNo = 2;
+					if (! isUndefHandle(m_dirs[0].m_handle))
+						rc = &m_dirs[0];
+					else
+						again = true;
+				} else {
+					// this subdirectory is complete. We go to the parent directory:
+					closeDir(current->m_handle);
+					setHandleUndef(current->m_handle);
+					if (--level > 0){
+						again = true;
+					}
+				}
+			}
+		}
+	} while(again);
+	return rc;
+}
+/**
+ * Returns the info about the next file matching the filter options.
+ *
+ * @param level	OUT: the level relative to the base.<br>
+ * 					0 means the file is inside the base.<br>
+ * 					Not defined if the result is NULL
+ * @param filter	NULL: every file matches<br>
+ * 					otherwise: each found file must match this filter conditions
+ * @return NULL	no more files<br>
+ * 					otherwise: the info about the next file in the
+ * 					directory tree
+ */
+DirStatus_t* ReTraverser::nextFile(int& level, DirEntryFilter_t* filter){
+	DirStatus_t* rc = rawNextFile(level);
+	while (rc != NULL){
+		if (filter == NULL || filter->match(*rc)){
+			break;
+		}
+		rc = rawNextFile(level);
+	}
+	return rc;
+}
+
+/**
+ * Initializes an entry in the directory entry stack.
+ *
+ * @param path		the name of the directory belonging to the entry
+ * @param level	the index of the entry in the stack
+ */
+void ReTraverser::initEntry(const char* path, int level){
+	if (level < MAX_ENTRY_STACK_DEPTH){
+		DirStatus_t* current = &m_dirs[level];
+		initEntryBuffer(current);
+		current->m_handle = findFirstEntry(path, current->m_data);
+		if (! isUndefHandle(current->m_handle)){
+			current->m_path.set(path, -1);
+		}
+		m_level = level;
+	}
+}
+
+/**
+ * Frees the resources of an entry of the directory entry stack.
+ *
+ * @param level	the index of the entry in the stack
+ */
+void ReTraverser::freeEntry(int level){
+	if (level < MAX_ENTRY_STACK_DEPTH){
+		DirStatus_t* current = &m_dirs[level];
+		if (! isUndefHandle(current->m_handle)){
+			closeDir(current->m_handle);
+			setHandleUndef(current->m_handle);
+		}
+		current->m_path.setLength(0);
+	}
+}
+
diff --git a/os/ReTraverser.hpp b/os/ReTraverser.hpp
index 75e7db0..8ce31d8 100644
--- a/os/ReTraverser.hpp
+++ b/os/ReTraverser.hpp
@@ -8,13 +8,16 @@
 #ifndef OS_RETRAVERSER_HPP_
 #define OS_RETRAVERSER_HPP_
 
-#ifdef __LINUX__
+#include "string/ReMatcher.hpp"
+#ifdef __linux__
 #include <sys/types.h>
  #include <sys/stat.h>
 
 typedef DIR* FindFileHandle_t;
 typedef __off_t FileSize_t;
 typedef struct dirent DirInfoStruct_t;
+typedef time_t FileTime_t;
+#if 0
 #define nameOfEntry(entry) ((entry)->m_data->d_name)
 #define isDirEntry(entry)	(((entry)->m_data->d_type != DT_UNKNOWN && (entry)->m_data->d_type == DT_DIR) \
 			|| S_ISDIR((entry)->getStatus()->st_mode))
@@ -24,71 +27,37 @@ typedef struct dirent DirInfoStruct_t;
 			|| S_ISREG((entry)->getStatus()->st_mode))
 #define sizeOfEntry(entry) ((entry)->getStatus()->st_size)
 #define modifiedOfEntry(entry) ((entry)->getStatus()->st_mtime)
+#endif
 #else
 typedef int64_t FileSize_t;
+typedef FILETIME FileTime_t;
 typedef HANDLE FindFileHandle_t;
 typedef WIN32_FIND_DATAA DirInfoStruct_t;
-#define nameOfEntry(entry) ((entry)->m_data->d_name)
-#define isDirEntry(data)	(data.getStatus()) & )
 #endif
 class DirStatus_t{
+public:
+    const char* nameOfEntry() const;
+    bool isDirectory();
+    bool isLink();
+    bool isRegular();
+    FileSize_t fileSize();
+    const FileTime_t* modified();
 public:
 	ReByteBuffer m_path;
 	DirInfoStruct_t* m_data;
 	FindFileHandle_t m_handle;
 	int m_passNo;
-#if defined __LINUX__
+#if defined __linux__
 	struct stat m_status;
 public:
 	struct stat* getStatus();
 #elif defined WIN32
-	DirInfoStruct_t m_buffer;
+        // the buffer for m_data:
+	DirInfoStruct_t m_dataBuffer;
 #endif
-
-};
-#define MAX_MATCHER_TOKEN 32
-class ReMatcher {
-public:
-	enum TokenType_t {
-		TT_UNDEF,
-		TT_STRING,
-		TT_STAR,
-		TT_ONE_CHAR,
-		TT_CHAR_CLASS
-	};
 public:
-	ReMatcher();
-	ReMatcher(const char* pattern);
-	~ReMatcher();
-public:
-	bool compile(const char* pattern);
-	bool match(const char* name);
-private:
-	ReByteBuffer m_prefix;
-	ReByteBuffer m_suffix;
-	ReByteBuffer m_pattern;
-	int m_tokenStart[MAX_MATCHER_TOKEN];
-	int m_tokenEnd[MAX_MATCHER_TOKEN];
-	int m_tokenLength[MAX_MATCHER_TOKEN];
-	TokenType_t m_type[MAX_MATCHER_TOKEN];
-	int m_tokens;
-	bool m_findAll;
-	bool m_ignoreCase;
-	bool m_notPattern;
-};
-class RePatternList{
-public:
-	RePatternList();
-	~RePatternList();
-public:
-	void destroy();
-	bool match(const char* pattern);
-	void set(const char* patterns, const char* separator = NULL);
-private:
-	void setOne(int ix, const char* pattern, size_t patternLength);
-private:
-	ReMatcher** m_patterns;
-	int m_count;
+    static time_t filetimeToTime(const FileTime_t* time);
+    static void timeToFiletime(time_t time, FileTime_t& filetime);
 };
 class DirEntryFilter_t {
 public:
@@ -126,6 +95,9 @@ protected:
 	/// each directory will be passed twice: for all files + for directories only
 	/// 1: depth first 2: breadth first
 	int m_passNoForDirSearch;
+public:
+	static const char m_separator;
+	static const char* const m_separatorStr;
 };
 
 #endif /* OS_RETRAVERSER_HPP_ */
diff --git a/os/reos.hpp b/os/reos.hpp
index e5efc38..4d513c7 100644
--- a/os/reos.hpp
+++ b/os/reos.hpp
@@ -7,13 +7,14 @@
 
 #ifndef OS_REOS_HPP_
 #define OS_REOS_HPP_
-#define __LINUX__
-#if defined __LINUX__
+
+#if defined __linux__
 #include "unistd.h"
 #include <dirent.h>
-#elif defined WIN32
+#elif defined __WIN32__
 #include <tchar.h>
 #include "windows.h"
+#include <winnt.h>
 #else
 #error "unknown os"
 #endif
diff --git a/string/ReMatcher.cpp b/string/ReMatcher.cpp
new file mode 100644
index 0000000..3e613ea
--- /dev/null
+++ b/string/ReMatcher.cpp
@@ -0,0 +1,316 @@
+/*
+ * ReMatcher.cpp
+ *
+ *  Created on: 25.12.2014
+ *      Author: hm
+ */
+
+#include "base/rebase.hpp"
+#include "string/ReMatcher.hpp"
+
+#ifdef __linux__
+extern int strncasecmp (const char* s1, const char* s2, size_t n);
+extern int strncmp (const char* s1, const char* s2, size_t n);
+extern void* memset (void *s, int c, size_t n);
+#endif 
+
+/**
+ * Constructor.
+ */
+ReMatcher::ReMatcher() :
+	m_findAll(false),
+	m_ignoreCase(true),
+	m_notPattern(false)
+{
+}
+
+/**
+ * Destructor
+ */
+ReMatcher::~ReMatcher() {
+}
+
+/**
+ * Constructor.
+ */
+ReSimpleMatcher::ReSimpleMatcher() :
+	ReMatcher(),
+	m_pattern(),
+	m_tokens()
+{
+}
+
+
+/**
+ * Constructor.
+ *
+ * @param pattern		the search pattern
+ */
+ReSimpleMatcher::ReSimpleMatcher(const char* pattern) :
+	ReMatcher(),
+	m_pattern(),
+	m_tokens()
+{
+	compile(pattern);
+}
+/**
+ * Destructor.
+ */
+ReSimpleMatcher::~ReSimpleMatcher(){
+}
+
+/**
+ * Compiles the pattern into a internal structure.
+ *
+ * @param pattern		pattern to compile
+ * @return			<code>true</code>: success<br>
+ * 					<code>false</code>: error occurred
+ */
+bool ReSimpleMatcher::compile(const char* pattern){
+	bool rc = true;
+	m_pattern.set(pattern, -1);
+	if (strcmp(pattern, "*") == 0){
+		m_findAll = true;
+	} else {
+		m_tokens.split(pattern, '*');
+	}
+	return rc;
+}
+/**
+ * Tests whether a name matches the pattern stored in the instance.
+ *
+ * This method is anchored: search always starts at the begin of <code>name</code>.
+ * @param toTest	the string to test
+ * @param hit		OUT: hit data. May be NULL
+ * @return			<code>true</code>: ! m_notPattern: the name matches<br>
+ * 											 m_notPattern: the name matches not<br>
+ * 					<code>false</code>: otherwise
+ */
+bool ReSimpleMatcher::match(const ReByteBuffer& toTest, ReHit* hit) const{
+	bool rc = m_findAll;
+	if (! rc){
+		do {
+			size_t length0 = m_tokens.strLengthOf(0);
+			// Does the anchor match?
+			if (length0 > 0 && ! toTest.startsWith(m_tokens.strOf(0), length0,
+						m_ignoreCase)){
+					break;
+			}
+			// Does the tail match?
+			int last = m_tokens.getCount() - 1;
+			if (last == 0){
+				rc = true;
+				break;
+			}
+			size_t lengthLast = m_tokens.strLengthOf(last);
+			if (lengthLast > 0 && ! toTest.endsWith(m_tokens.strOf(last),
+						lengthLast, m_ignoreCase)){
+				break;
+			}
+			// only anchor and tail?
+			if (last == 1){
+				rc = true;
+				break;
+			}
+			rc = searchTokens(toTest, 1, last - 1, hit, false);
+		} while(false);
+	}
+	if (m_notPattern)
+		rc = ! rc;
+	return rc;
+}
+
+/**
+ * Search all tokens from a given index.
+ *
+ * This method may be recursive (if greedy).
+ *
+ * @param name		the name to test
+ * @param index	the index of the first token to find
+ * @param hit		OUT: hit data. May be NULL
+ * @param greedy	<code>true</code>: the longest possible match will be found<br>
+ * 					<code>false</code>: the shortest possible match will be found
+ * @return			<code>true</code>: ! m_notPattern: the name matches<br>
+ * 											 m_notPattern: the name matches not<br>
+ * 					<code>false</code>: otherwise
+ */
+bool ReSimpleMatcher::searchTokens(const ReByteBuffer& toTest, int from, int to,
+			ReHit* hit, bool greedy) const{
+	bool rc = true;
+	if (! greedy){
+		int current = 0;
+		for (int ix = from; ix <= to; ix++){
+			size_t length = m_tokens.strLengthOf(ix);
+			if (length == 0)
+				continue;
+			current = toTest.indexOf(m_tokens.strOf(ix), length, current, -1,
+						m_ignoreCase);
+			if (current < 0){
+				rc = false;
+				break;
+			}
+			if (hit != NULL){
+				hit->setStart(current);
+				hit->setEnd(current + length);
+			}
+		}
+	} else {
+		assert(false);
+	}
+	return rc;
+}
+/**
+ * Tests whether a name matches the pattern stored in the instance.
+ *
+ * This method is not anchored: the pattern may be located anywhere
+ * in the <code>name</code>.
+ * @param name		the name to test
+ * @param hit		OUT: hit data. May be NULL
+ * @param greedy	<code>true</code>: the longest possible match will be found<br>
+ * 					<code>false</code>: the shortest possible match will be found
+ * @return			<code>true</code>: ! m_notPattern: the name matches<br>
+ * 											 m_notPattern: the name matches not<br>
+ * 					<code>false</code>: otherwise
+ */
+bool ReSimpleMatcher::search(const ReByteBuffer& toTest, ReHit* hit, bool greedy) const{
+	bool rc = m_findAll;
+	if (! rc){
+		size_t last = m_tokens.getCount();
+		size_t length0 = m_tokens.strLengthOf(0);
+		size_t lengthLast = m_tokens.strLengthOf(last);
+		rc = searchTokens(toTest, length0 == 0 ? 1 : 0,
+					lengthLast == 0 ? last - 1 : last, hit, greedy);
+	}
+	if (m_notPattern)
+		rc = ! rc;
+	return rc;
+}
+
+/**
+ * Constructor.
+ */
+RePatternList::RePatternList() :
+	m_patterns(NULL),
+	m_count(0)
+{
+}
+/**
+ * Destructor.
+ */
+RePatternList::~RePatternList(){
+	destroy();
+}
+void RePatternList::destroy(){
+	if (m_patterns != NULL){
+		for (int ix = 0; ix < m_count; ix++){
+			delete m_patterns[ix];
+			m_patterns[ix] = NULL;
+		}
+	}
+	delete[] m_patterns;
+	m_patterns = NULL;
+}
+/**
+ * Tests whether a name matches at least one of the patterns.
+ *
+ * <pre>Examples:
+ * list: ";*.cpp;^test*;*.hpp"
+ * returns true: "a.cpp" "xy.hpp"
+ * returns false: "x.img", "test.cpp"
+ * </pre>
+ *
+ * @param name		name to test
+ * @return			<code>true</code>: at least one pattern matches and no
+ * 					"not-pattern" matches<br>
+ * 					<code>false</code>: no pattern matches or at least one
+ * 					"not-pattern" matches
+ */
+bool RePatternList::match(const char* name){
+	bool rc = false;
+	int count = m_startNot < 0 ? m_count : m_count - m_startNot + 1;
+	// matches at least one positive pattern?
+	for (int ix = 0; ix < count; ix++)
+		if (m_patterns[ix]->match(name)){
+			rc = true;
+			break;
+		}
+	if (rc && m_startNot >= 0){
+		for (int ix = m_startNot; ix < m_count; ix++)
+			if (m_patterns[ix]->match(name)){
+				rc = false;
+				break;
+			}
+	}
+	return rc;
+}
+/**
+ * Sets the pattern list from a string.
+ *
+ * @param patterns	a string with one or more patterns
+ * @param ignoreCase	<code>true</code>: the search will be case insensitive<br>
+ * 						<code>false</code>: the search will be case sensitive
+ * @param separator	NULL: the first char of <code>patterns</code> is the the separator<br>
+ * 						otherwise: the separator between the patterns
+ * @param notPrefix	if this prefix starts a pattern, the result of a search
+ * 						will be reversed: found returns <code>false</code><br>
+ * 						NULL: no not prefix exists
+ */
+void RePatternList::set(const char* patterns, bool ignoreCase,
+			const char* separator, const char* notPrefix){
+	char buffer[2];
+	destroy();
+	if (separator == NULL){
+		buffer[0] = patterns[0];
+		buffer[1] = '\0';
+		separator = buffer;
+		patterns++;
+	}
+	int sepLength = strlen(separator);
+	ReByteBuffer theNotPattern(notPrefix == NULL ? "" : notPrefix);
+	ReByteBuffer thePatterns(patterns);
+	if (thePatterns.endsWith(separator)){
+		thePatterns.setLength(thePatterns.length() - sepLength);
+	}
+	m_count = thePatterns.count(separator) + 1;
+	m_patterns = new ReSimpleMatcher*[m_count];
+	m_startNot = m_count;
+	int ixInsert = 0;
+	int current = 0;
+	int last = 0;
+	while( (current = thePatterns.indexOf(separator, sepLength, last)) != -1){
+		ixInsert = setOne(ixInsert, thePatterns.str() + last, current - last, ignoreCase,
+					theNotPattern);
+		last = current + sepLength;
+	}
+	setOne(ixInsert, patterns + last, strlen(thePatterns.str() + last),
+				ignoreCase, theNotPattern);
+	if (m_startNot >= m_count)
+		m_startNot = -1;
+}
+
+/**
+ * Sets one pattern in the pattern list.
+ *
+ * @param index			index of the pattern in the list (if not a "not pattern")
+ * @param pattern			the pattern string
+ * @param patternLength	the length of <code>pattern</code>
+ * @param ignoreCase		<code>true</code>: the search will be case insensitive<br>
+ * 							<code>false</code>: the search will be case sensitive
+ * @param notPrefix		if this prefix starts a pattern, the result of a search
+ * 							will be reversed: found returns <code>false</code><br>
+ * 							NULL: no not prefix exists
+ * @return					ix: the pattern was a "not pattern"<br>
+ * 							ix + 1: otherwise
+ */
+int RePatternList::setOne(int index, const char* pattern, size_t patternLength,
+			bool ignoreCase, const ReByteBuffer& notPrefix){
+	ReByteBuffer thePattern (pattern, patternLength);
+	bool isNotPattern = (notPrefix.length() > 0
+				&& thePattern.startsWith(notPrefix.str(), notPrefix.length()));
+	int start = isNotPattern ? notPrefix.length() : 0;
+	// not patterns will be inserted at the bottom:
+	int ix = isNotPattern ? --m_startNot : index;
+	m_patterns[ix] = new ReSimpleMatcher(thePattern.str() + start);
+	m_patterns[ix]->setIgnoreCase(ignoreCase);
+	return isNotPattern ? index: index + 1;
+}
diff --git a/string/ReMatcher.hpp b/string/ReMatcher.hpp
new file mode 100644
index 0000000..e9b3506
--- /dev/null
+++ b/string/ReMatcher.hpp
@@ -0,0 +1,106 @@
+/*
+ * ReMatcher.hpp
+ *
+ *  Created on: 25.12.2014
+ *      Author: hm
+ */
+
+#ifndef STRING_REMATCHER_HPP_
+#define STRING_REMATCHER_HPP_
+
+class ReHit {
+public:
+	ReHit();
+
+	inline int getEnd() const {
+		return m_end;
+	}
+
+	inline void setEnd(int end) {
+		m_end = end;
+	}
+
+	inline int getStart() const {
+		return m_start;
+	}
+
+	inline void setStart(int start) {
+		m_start = start;
+	}
+private:
+	int m_start;
+	int m_end;
+};
+
+class ReMatcher {
+public:
+	ReMatcher();
+	virtual ~ReMatcher();
+public:
+	virtual bool compile(const char* pattern) = 0;
+	virtual bool match(const ReByteBuffer& toTest, ReHit* hit = NULL) const = 0;
+	virtual bool search(const ReByteBuffer& toTest, ReHit* hit = NULL,
+				bool greedy = false) const = 0;
+public:
+	inline bool isIgnoreCase() const {
+		return m_ignoreCase;
+	}
+
+	inline void setIgnoreCase(bool ignoreCase) {
+		m_ignoreCase = ignoreCase;
+	}
+
+	inline bool isNotPattern() const {
+		return m_notPattern;
+	}
+
+	inline void setNotPattern(bool notPattern) {
+		m_notPattern = notPattern;
+	}
+
+protected:
+	bool m_findAll;
+	bool m_ignoreCase;
+	bool m_notPattern;
+};
+
+class ReSimpleMatcher: public ReMatcher {
+public:
+	ReSimpleMatcher();
+	ReSimpleMatcher(const char* pattern);
+	virtual ~ReSimpleMatcher();
+public:
+	virtual bool compile(const char* pattern);
+	virtual bool match(const ReByteBuffer& toTest, ReHit* hit = NULL) const;
+	virtual bool search(const ReByteBuffer& toTest, ReHit* hit = NULL,
+				bool greedy = false) const;
+protected:
+	bool searchTokens(const ReByteBuffer& toTest, int from, int to,
+				ReHit* hit, bool greedy) const;
+private:
+	ReByteBuffer m_pattern;
+	ReStringList m_tokens;
+};
+
+class RePatternList{
+public:
+	RePatternList();
+	~RePatternList();
+public:
+	void destroy();
+	bool match(const char* pattern);
+	void set(const char* patterns, bool ignoreCase = false,
+				const char* separator = NULL, const char* notPrefix = "^");
+private:
+	int setOne(int index, const char* pattern, size_t patternLength,
+				bool ignoreCase, const ReByteBuffer& notPrefix);
+private:
+	// store of all patterns: the not patterns are at the bottom
+	ReSimpleMatcher** m_patterns;
+	// count of all patterns (including not patterns:
+	int m_count;
+	// index of the first not pattern. If -1: not "not pattern":
+	int m_startNot;
+};
+
+#endif /* STRING_REMATCHER_HPP_ */
diff --git a/string/restring.hpp b/string/restring.hpp
new file mode 100644
index 0000000..d233d62
--- /dev/null
+++ b/string/restring.hpp
@@ -0,0 +1,13 @@
+/*
+ * restring.hpp
+ *
+ *  Created on: 25.12.2014
+ *      Author: hm
+ */
+
+#ifndef STRING_RESTRING_HPP_
+#define STRING_RESTRING_HPP_
+
+#include "string/ReMatcher.hpp"
+
+#endif /* STRING_RESTRING_HPP_ */