Added KDE3 version of kvirc

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/kvirc@1095341 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

22 files changed, 8923 insertions, 0 deletions

diff --git a/src/kvilib/core/Makefile.am b/src/kvilib/core/Makefile.am
new file mode 100644
index 00000000..c84487eb
--- /dev/null
+++ b/src/kvilib/core/Makefile.am
@@ -0,0 +1,5 @@
+###############################################################################
+# KVirc IRC client Makefile - 16.12.98 Szymon Stefanek <[email protected]>
+###############################################################################
+
+EXTRA_DIST       = *.cpp *.h
diff --git a/src/kvilib/core/kvi_bswap.h b/src/kvilib/core/kvi_bswap.h
new file mode 100644
index 00000000..5d5ef5bb
--- /dev/null
+++ b/src/kvilib/core/kvi_bswap.h
@@ -0,0 +1,63 @@
+#ifndef _KVI_BSWAP_H_
+#define _KVI_BSWAP_H_
+
+//=============================================================================
+//
+//   File : kvi_bswap.h
+//   Creation date : Fri Mar 19 1999 03:15:21 CEST by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 1999-2006 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+#include "kvi_settings.h"
+#include "kvi_inttypes.h"
+
+
+// KVILIB_API has been removed from therse two functions
+// these should always go inlined
+
+inline kvi_u64_t kvi_swap64(kvi_u64_t i)
+{
+	// abcdefgh to hgfedcba
+	return ((i << 56) |                /* h to a */
+			((i & 0xff00) << 40) |     /* g to b */
+			((i & 0xff0000) << 24) |   /* f to c */
+			((i & 0xff000000) << 8) |  /* e to d */
+			((i >> 8) & 0xff000000) |  /* d to e */
+			((i >> 24) & 0xff0000) |   /* c to f */
+			((i >> 40) & 0xff00) |     /* b to g */
+			(i >> 56));                /* a to h */
+}
+
+inline kvi_u32_t kvi_swap32(kvi_u32_t i)
+{
+	// abcd to dcba
+	return ((i << 24) | ((i & 0xff00) << 8) | ((i >> 8) & 0xff00) | (i >> 24));
+}
+
+inline kvi_u16_t kvi_swap16(kvi_u16_t i)
+{
+	// ab to ba
+	return ((i << 8) | (i >> 8));
+}
+
+
+
+
+#endif // !_KVI_BSWAP_H_
diff --git a/src/kvilib/core/kvi_error.cpp b/src/kvilib/core/kvi_error.cpp
new file mode 100644
index 00000000..6497c757
--- /dev/null
+++ b/src/kvilib/core/kvi_error.cpp
@@ -0,0 +1,237 @@
+//=============================================================================
+//
+//   File : kvi_error.cpp
+//   Creation date : Sun Jul 02 2000 18:37:02 by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 1999-2006 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+#define __KVILIB__
+
+#define _KVI_ERROR_CPP_
+
+#include "kvi_locale.h"
+#include "kvi_error.h"
+#include "kvi_settings.h"
+
+
+#ifdef COMPILE_ON_WINDOWS
+#include <winsock2.h> // for the WSAE* error codes
+#endif
+
+#include <errno.h>
+
+#ifdef HAVE_STRERROR
+#include <string.h> // for strerror()
+#endif
+
+// FIXME: This stuff should basically die and be eventually replaced with some
+//        helper functions for handling ONLY system errors.
+//
+// WARNING: getDescription() is not even thread safe... it will die in the near future
+
+const char * g_errorTable[KVI_NUM_ERRORS]=
+{
+	__tr_no_lookup("Success"),                                                  // 000: success 
+	__tr_no_lookup("Unknown error"),                                            // 001: unkonwnError
+	__tr_no_lookup("Internal error"),                                           // 002: internalError
+	__tr_no_lookup("Unknown command"),                                          // 003: unknownCommand
+	__tr_no_lookup("Missing closing brace"),                                    // 004: missingClosingBrace
+	__tr_no_lookup("Unexpected end of command in string"),                      // 005: unexpectedEndInString
+	__tr_no_lookup("Unexpected end of command in dictionary key"),              // 006: unexpectedEndInDictionaryKey
+	__tr_no_lookup("Switch dash without switch letter"),                        // 007: switchDashWithoutSwitchLetter
+	__tr_no_lookup("Unknown function"),                                         // 008: unknownFunction
+	__tr_no_lookup("Unexpected end of command in parenthesis"),                 // 009: unexpectedEndInParenthesis
+	__tr_no_lookup("Unexpected end of command in function parameters"),         // 010: unexpectedEndInFunctionParams
+	__tr_no_lookup("Missing variable name"),                                    // 011: missingVariableName
+	__tr_no_lookup("Variable or identifier expected"),                          // 012: variableOrIdentifierExpected
+	__tr_no_lookup("Left operand is not a number"),                             // 013: leftOperandIsNotANumber
+	__tr_no_lookup("Multiple operations not supported for numeric operators"),  // 014: multipleOpsNotSupportedForOperator
+	__tr_no_lookup("Division by zero"),                                         // 015: divisionByZero
+	__tr_no_lookup("Modulo by zero"),                                           // 016: moduloByZero
+	__tr_no_lookup("Right operand is not a number"),                            // 017: rightOperandIsNotANumber
+	__tr_no_lookup("Unterminated expression (missing ')' ?)"),                  // 018: unterminatedExpression
+	__tr_no_lookup("Unterminated subexpression (Parenthesis mismatch)"),        // 019: unterminatedSubexpression
+	__tr_no_lookup("Unexpected character"),                                     // 020: unexpectedCharacter
+	__tr_no_lookup("Unknown operator"),                                         // 021: unknownOperator
+	__tr_no_lookup("No host to resolve"),                                       // 022
+	__tr_no_lookup("(DNS Internal) Unsupported address family"),                // 023
+	__tr_no_lookup("Valid name but the host has no IP address"),                // 024
+	__tr_no_lookup("Unrecoverable nameserver error (crashed ?)"),               // 025
+	__tr_no_lookup("Dns temporaneous fault (try again)"),                       // 026
+	__tr_no_lookup("(DNS Internal) Bad flags"),                                 // 027
+	__tr_no_lookup("(DNS Internal) Out of memory"),                             // 028
+	__tr_no_lookup("(DNS Internal) Service not supported"),                     // 029
+	__tr_no_lookup("Unknown node (host not found)"),                            // 030
+	__tr_no_lookup("(DNS Internal) Unsupported socket type"),                   // 031
+	__tr_no_lookup("Dns query failed"),                                         // 032
+	__tr_no_lookup("This KVIrc executable has no IPV6 support"),                // 033
+	__tr_no_lookup("Host not found"),                                           // 034
+	__tr_no_lookup("(DNS Internal) IPC failure (slave data corrupted)"),        // 035
+	__tr_no_lookup("Another connection in progress"),                           // 036
+	__tr_no_lookup("Invalid IP address"),                                       // 037
+	__tr_no_lookup("Socket creation failed"),                                   // 038
+	__tr_no_lookup("Failed to put the socket in non blocking mode"),            // 039
+	__tr_no_lookup("Bad file descriptor"),                                      // 040
+	__tr_no_lookup("Out of address space"),                                     // 041
+	__tr_no_lookup("Connection refused"),                                       // 042
+	__tr_no_lookup("Kernel networking panic"),                                  // 043
+	__tr_no_lookup("Connection timed out"),                                     // 044
+	__tr_no_lookup("Network is unreachable"),                                   // 045
+	__tr_no_lookup("Broken pipe"),                                              // 046
+	__tr_no_lookup("Invalid proxy address"),                                    // 047
+	__tr_no_lookup("Remote end has closed the connection"),                     // 048
+	__tr_no_lookup("Invalid irc context id"),                                   // 049
+	__tr_no_lookup("Error in loading module"),                                  // 050
+	__tr_no_lookup("No such module command"),                                   // 051
+	__tr_no_lookup("No such module function"),                                  // 052
+	__tr_no_lookup("Left operand is not a dictionary reference"),               // 053
+	__tr_no_lookup("Right operand is not a dictionary reference"),              // 054
+	__tr_no_lookup("Missing object class name"),                                // 055
+	__tr_no_lookup("No such object class"),                                     // 056
+	__tr_no_lookup("No such object"),                                           // 057
+	__tr_no_lookup("No such object function"),                                  // 058
+	__tr_no_lookup("Invalid left operand"),                                     // 059
+	__tr_no_lookup("Not enough parameters"),                                    // 060
+	__tr_no_lookup("Integer parameter expected"),                               // 061
+	__tr_no_lookup("Invalid parameter"),                                        // 062
+	__tr_no_lookup("No such file"),                                             // 063
+	__tr_no_lookup("Open parenthesis expected"),                                // 064
+	__tr_no_lookup("Open brace expected"),                                      // 065
+	__tr_no_lookup("Can't kill a builtin class"),                               // 066
+	__tr_no_lookup("The SOCKSV4 protocol lacks IpV6 support"),                  // 067
+	__tr_no_lookup("Unrecognized proxy reply"),                                 // 068
+	__tr_no_lookup("Proxy response: auth failed: access denied"),
+	__tr_no_lookup("Proxy response: No acceptable auth method: request rejected"),
+	__tr_no_lookup("Proxy response: request failed"),
+	__tr_no_lookup("Proxy response: ident failed"),
+	__tr_no_lookup("Proxy response: ident not matching"),
+	__tr_no_lookup("Proxy response: general SOCKS failure"),
+	__tr_no_lookup("Proxy response: connection not allowed"),
+	__tr_no_lookup("Proxy response: network unreachable"),
+	__tr_no_lookup("Proxy response: host unreachable"),
+	__tr_no_lookup("Proxy response: connection refused"),
+	__tr_no_lookup("Proxy response: TTL expired"),
+	__tr_no_lookup("Proxy response: command not supported"),
+	__tr_no_lookup("Proxy response: address type not supported"),
+	__tr_no_lookup("Proxy response: invalid address"),
+	__tr_no_lookup("Invalid port number"),
+	__tr_no_lookup("Socket not connected"),
+	__tr_no_lookup("Insufficient resources to complete the operation"),
+	__tr_no_lookup("Can't setup a listening socket : bind failed"),
+	__tr_no_lookup("Can't resolve the localhost name"),
+	__tr_no_lookup("Unsupported image format"),
+	__tr_no_lookup("Can't open file for appending"),
+	__tr_no_lookup("Can't open file for writing"),
+	__tr_no_lookup("File I/O error"),
+	__tr_no_lookup("Acknowledge error"),
+	__tr_no_lookup("Can't open file for reading"),
+	__tr_no_lookup("Can't send a zero-size file"),
+	__tr_no_lookup("Missing popup name"),
+	__tr_no_lookup("'item', 'popup', 'label' or 'separator' keyword expected"),
+	__tr_no_lookup("Self modification not allowed"),
+	__tr_no_lookup("UNUSED"),
+	__tr_no_lookup("Feature not available"),
+	__tr_no_lookup("Unexpected characters in array index"),
+	__tr_no_lookup("Unexpected end in expression"),
+	__tr_no_lookup("Unexpected end in array index"),
+	__tr_no_lookup("Connection thru HTTP proxy failed"),
+	__tr_no_lookup("Case , match , regexp , default or break keyword expected"),
+	__tr_no_lookup("Access denied"),
+	__tr_no_lookup("Address already in use"),
+	__tr_no_lookup("Can't assign the requested address"),
+	__tr_no_lookup("Connection reset by peer"),
+	__tr_no_lookup("Host unreachable (no route to host)"),
+	__tr_no_lookup("Variable expected"),
+	__tr_no_lookup("Invalid array index: positive integer expected"),
+	__tr_no_lookup("listen() call failed"),
+	__tr_no_lookup("This executable has been compiled without SSL support"),
+	__tr_no_lookup("Secure Socket Layer error"),
+	__tr_no_lookup("Slash (/) character expected"),
+	__tr_no_lookup("Unknown string manipulation operation"),
+	__tr_no_lookup("Operation aborted"),
+	__tr_no_lookup("Unexpected token"),
+	__tr_no_lookup("Scope object already defined (unexpected @)"),
+	__tr_no_lookup("There is no $this pointer in this scope (unexpected @)")
+};
+
+namespace KviError
+{
+	const char * getUntranslatedDescription(int iErrorCode)
+	{
+		if((iErrorCode < KVI_NUM_ERRORS) && (iErrorCode >= 0))
+			return g_errorTable[iErrorCode];
+#ifdef HAVE_STRERROR
+		if(iErrorCode < 0)return strerror(-iErrorCode);
+#endif
+		return g_errorTable[KviError_unknownError];
+	}
+	
+	QString getDescription(int iErrorCode)
+	{
+		return __tr2qs_no_xgettext(getUntranslatedDescription(iErrorCode));
+	}
+	
+	int translateSystemError(int iErrNo)
+	{
+#ifdef COMPILE_ON_WINDOWS
+		switch(iErrNo)
+		{
+			case EBADF:		       return KviError_badFileDescriptor;          break;
+			case WSAEINVAL:
+			case WSAEFAULT:
+			case EFAULT:           return KviError_outOfAddressSpace;          break;
+			case WSAECONNREFUSED:  return KviError_connectionRefused;          break;
+			case WSAENOTSOCK:      return KviError_kernelNetworkingPanic;      break;
+			case WSAETIMEDOUT:     return KviError_connectionTimedOut;         break;
+			case WSAENETUNREACH:   return KviError_networkUnreachable;         break;
+			case EPIPE:			   return KviError_brokenPipe;                 break;
+			case WSAENOTCONN:      return KviError_socketNotConnected;         break;
+	
+			case WSAEACCES:        return KviError_accessDenied;               break;
+			case WSAEADDRINUSE:    return KviError_addressAlreadyInUse;        break;
+			case WSAEADDRNOTAVAIL: return KviError_cantAssignRequestedAddress; break;
+			case WSAEAFNOSUPPORT:  return KviError_unsupportedAddressFamily;   break;
+			case WSAECONNRESET:    return KviError_connectionResetByPeer;      break;
+			case WSAEHOSTUNREACH:  return KviError_hostUnreachable;            break;
+	
+			//case ENOBUFS:      return KviError_insufficientResources; break;
+			// Unhandled error...pass errno to the strerror function
+			default:              return -iErrNo;                              break;
+		}
+#else
+		switch(iErrNo)
+		{
+			case EBADF:        return KviError_badFileDescriptor;     break;
+			case EFAULT:       return KviError_outOfAddressSpace;     break;
+			case ECONNREFUSED: return KviError_connectionRefused;     break;
+			case ENOTSOCK:     return KviError_kernelNetworkingPanic; break;
+			case ETIMEDOUT:    return KviError_connectionTimedOut;    break;
+			case ENETUNREACH:  return KviError_networkUnreachable;    break;
+			case EPIPE:        return KviError_brokenPipe;            break;
+			case ENOTCONN:     return KviError_socketNotConnected;    break;
+			case ENOBUFS:      return KviError_insufficientResources; break;
+			case EHOSTUNREACH: return KviError_hostUnreachable;       break;
+			// Unhandled error...pass errno to the strerror function
+			default:           return -iErrNo;                        break;
+		}
+#endif
+	}
+};
+
diff --git a/src/kvilib/core/kvi_error.h b/src/kvilib/core/kvi_error.h
new file mode 100644
index 00000000..7ab55e88
--- /dev/null
+++ b/src/kvilib/core/kvi_error.h
@@ -0,0 +1,188 @@
+#ifndef _KVI_ERROR_H_
+#define _KVI_ERROR_H_
+//=============================================================================
+//
+//   File : kvi_error.h
+//   Creation date : Sun Jul 02 2000 18:35:56 by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 1999-2006 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+#include "kvi_settings.h"
+#include "kvi_qstring.h"
+
+#define KviError_success 0
+#define KviError_unknownError 1
+#define KviError_internalError 2
+#define KviError_unknownCommand 3
+#define KviError_missingClosingBrace 4
+#define KviError_unexpectedEndInString 5
+#define KviError_unexpectedEndInDictionaryKey 6
+#define KviError_switchDashWithoutSwitchLetter 7
+#define KviError_unknownFunction 8
+#define KviError_unexpectedEndInParenthesis 9
+#define KviError_unexpectedEndInFunctionParams 10
+#define KviError_missingVariableName 11
+#define KviError_variableOrIdentifierExpected 12
+#define KviError_leftOperandIsNotANumber 13
+#define KviError_multipleOpsNotSupportedForOperator 14
+#define KviError_divisionByZero 15
+#define KviError_moduloByZero 16
+#define KviError_rightOperandIsNotANumber 17
+#define KviError_unterminatedExpression 18
+#define KviError_unterminatedSubexpression 19
+#define KviError_unexpectedCharacter 20
+#define KviError_unknownOperator 21
+
+#define KviError_noHostToResolve 22
+#define KviError_unsupportedAddressFamily 23
+#define KviError_validNameButNoIpAddress 24
+#define KviError_unrecoverableNameserverError 25
+#define KviError_dnsTemporaneousFault 26
+#define KviError_dnsInternalErrorBadFlags 27
+#define KviError_dnsInternalErrorOutOfMemory 28
+#define KviError_dnsInternalErrorServiceNotSupported 29
+#define KviError_dnsNoName 30
+#define KviError_dnsInternalErrorUnsupportedSocketType 31
+#define KviError_dnsQueryFailed 32
+#define KviError_noIpV6Support 33
+#define KviError_hostNotFound 34
+#define KviError_dnsInternalIPCFailure 35
+
+#define KviError_anotherConnectionInProgress 36
+#define KviError_invalidIpAddress 37
+#define KviError_socketCreationFailed 38
+#define KviError_asyncSocketFailed 39
+#define KviError_badFileDescriptor 40
+#define KviError_outOfAddressSpace 41
+#define KviError_connectionRefused 42
+#define KviError_kernelNetworkingPanic 43
+#define KviError_connectionTimedOut 44
+#define KviError_networkUnreachable 45
+#define KviError_brokenPipe 46
+#define KviError_invalidProxyAddress 47
+#define KviError_remoteEndClosedConnection 48
+
+#define KviError_invalidIrcContextId 49
+#define KviError_errorInLoadingModule 50
+#define KviError_noSuchModuleCommand 51
+#define KviError_noSuchModuleFunction 52
+
+#define KviError_leftOperandIsNotADictionaryReference 53
+#define KviError_rightOperandIsNotADictionaryReference 54
+
+#define KviError_missingObjectClassName 55
+#define KviError_noSuchObjectClass 56
+#define KviError_noSuchObject 57
+#define KviError_noSuchObjectFunction 58
+
+#define KviError_invalidLeftOperand 59
+
+#define KviError_notEnoughParameters 60
+#define KviError_integerParameterExpected 61
+#define KviError_invalidParameter 62
+
+#define KviError_noSuchFile 63
+
+#define KviError_openParenthesisExpected 64
+#define KviError_openBraceExpected 65
+
+#define KviError_cantKillABuiltinClass 66
+#define KviError_socksV4LacksIpV6Support 67
+#define KviError_unrecognizedProxyReply 68
+#define KviError_proxyAuthFailed 69
+#define KviError_proxyNoAcceptableAuthMethod 70
+
+#define KviError_proxyReply91RequestFailed 71
+#define KviError_proxyReply92IdentFailed 72
+#define KviError_proxyReply93IdentNotMatching 73
+#define KviError_proxyReply01GeneralSOCKSFailure 74
+#define KviError_proxyReply02ConnectionNotAllowed 75
+#define KviError_proxyReply03NetworkUnreachable 76
+#define KviError_proxyReply04HostUnreachable 77
+#define KviError_proxyReply05ConnectionRefused 78
+#define KviError_proxyReply06TTLExpired 79
+#define KviError_proxyReply07CommandNotSupported 80
+#define KviError_proxyReply08AddressTypeNotSupported 81
+#define KviError_proxyReply09InvalidAddress 82
+
+#define KviError_invalidPortNumber 83
+#define KviError_socketNotConnected 84
+#define KviError_insufficientResources 85
+#define KviError_bindFailed 86
+#define KviError_cantResolveLocalhost 87
+
+#define KviError_unsupportedImageFormat 88
+
+#define KviError_cantOpenFileForAppending 89
+#define KviError_cantOpenFileForWriting 90
+#define KviError_fileIOError 91
+#define KviError_acknowledgeError 92
+#define KviError_cantOpenFileForReading 93
+#define KviError_cantSendAZeroSizeFile 94
+
+#define KviError_missingPopupName 95
+#define KviError_itemPopupOrSeparatorExpected 96
+#define KviError_selfModificationNotAllowed 97
+
+//#define KviError_recursionTooDeep 98
+#define KviError_featureNotAvailable 99
+
+#define KviError_unexpectedCharactersInArrayIndex 100
+#define KviError_unexpectedEndInExpression 101
+#define KviError_unexpectedEndInArrayIndex 102
+
+#define KviError_proxyHttpFailure 103
+#define KviError_caseMatchRegexpDefaultOrBreakExpected 104
+
+
+#define KviError_accessDenied 105
+#define KviError_addressAlreadyInUse 106
+#define KviError_cantAssignRequestedAddress 107
+#define KviError_connectionResetByPeer 108
+#define KviError_hostUnreachable 109
+
+#define KviError_variableExpected 110
+#define KviError_invalidArrayIndex 111
+
+#define KviError_listenFailed 112
+
+#define KviError_noSSLSupport 113
+#define KviError_SSLError 114
+
+#define KviError_slashCharacterExpected 115
+#define KviError_unknownStringManipulationOperator 116
+
+#define KviError_operationAborted 117
+
+#define KviError_unexpectedToken 118
+
+#define KviError_scopeObjectAlreadyDefined 119
+#define KviError_noThisObject 120
+
+#define KVI_NUM_ERRORS 121
+
+namespace KviError
+{
+	KVILIB_API QString getDescription(int iErrorCode);
+	KVILIB_API const char * getUntranslatedDescription(int iErrorCode);
+	KVILIB_API int translateSystemError(int iErrNo);
+};
+
+#endif //_KVI_ERROR_H_
diff --git a/src/kvilib/core/kvi_heapobject.cpp b/src/kvilib/core/kvi_heapobject.cpp
new file mode 100644
index 00000000..7568086d
--- /dev/null
+++ b/src/kvilib/core/kvi_heapobject.cpp
@@ -0,0 +1,96 @@
+//=============================================================================
+//
+//   File : kvi_heapobject.cpp
+//   Created on Wed 24 Mar 2004 04:45:17 by Szymon Stefanek
+//
+//   This file is part of the KVIrc IRC client distribution
+//   Copyright (C) 2004-2006 Szymon Stefanek <pragma at kvirc dot net>
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+#define __KVILIB__
+
+
+#include "kvi_heapobject.h"
+#include "kvi_malloc.h"
+
+// On windows we need to override new and delete operators
+// to ensure that always the right new/delete pair is called for an object instance
+// This bug jumps out because windows uses a local heap for each
+// executable module (exe or dll).
+// (this is a well known bug described in Q122675 of MSDN)
+
+// on Linux it is not needed: there is a single global heap
+
+
+
+// 05.02.2005 : scalar/vector deleting destructors in modules
+//
+// There are also other issues involving the MSVC compiler.
+// When the operator new is called on an object with a virtual
+// destructor the compiler generates a helper function
+// called "vector deleting destructor" that is used to both
+// free the object's memory and call the object's destructor.
+// (In fact there is also a "scalar deleting destructor" but
+// MSVC seems to call the vector version also for scalar deletes ?!?)
+// The problem arises when operator new is called in a module:
+// the helper function gets stuffed in one of the module's sections
+// and when the module is unloaded any attempt to delete
+// the object will simply jump into no man's land.
+
+// An "unhandled exception" in a "call [%eax]" corresponding
+// to a delete <pointer> may be a symptom of this problem.
+
+// I haven't been able to find a solution nicer than having
+// a static allocation function in each class that can be
+// created from inside a module and destroyed anywhere else
+// and has a virtual destructor.
+
+#ifdef COMPILE_ON_WINDOWS
+	void * KviHeapObject::operator new(size_t uSize)
+	{
+		return kvi_malloc(uSize);
+	}
+	
+	void KviHeapObject::operator delete(void * pData)
+	{
+		kvi_free(pData);
+	}
+
+	void * KviHeapObject::operator new[](size_t uSize)
+	{
+		return kvi_malloc(uSize);
+	}
+	
+	void KviHeapObject::operator delete[](void * pData)
+	{
+		kvi_free(pData);
+	}
+
+	// these are the debug versions...
+	void * KviHeapObject::operator new(size_t uSize,const char *,int)
+	{
+		return kvi_malloc(uSize);
+	}
+	
+	void KviHeapObject::operator delete(void * pData,const char *,int)
+	{
+		kvi_free(pData);
+	}
+#endif
+
+
diff --git a/src/kvilib/core/kvi_heapobject.h b/src/kvilib/core/kvi_heapobject.h
new file mode 100644
index 00000000..3d1638cf
--- /dev/null
+++ b/src/kvilib/core/kvi_heapobject.h
@@ -0,0 +1,50 @@
+#ifndef _KVI_HEAPOBJECT_H_
+#define _KVI_HEAPOBJECT_H_
+//=============================================================================
+//
+//   File : kvi_heapobject.h
+//   Created on Wed 24 Mar 2004 04:45:17 by Szymon Stefanek
+//
+//   This file is part of the KVIrc IRC client distribution
+//   Copyright (C) 2004-2006 Szymon Stefanek <pragma at kvirc dot net>
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+#include "kvi_settings.h"
+
+// See kvi_heapobject.cpp for comments on this class
+
+#ifdef COMPILE_ON_WINDOWS
+	
+	class KVILIB_API KviHeapObject
+	{
+	public:
+		void * operator new(size_t uSize);
+		void operator delete(void * pData);
+		void * operator new[](size_t uSize);
+		void operator delete[](void * pData);
+		void * operator new(size_t uSize,const char *,int);
+		void operator delete(void * pData,const char *,int);
+	};
+#else //!COMPILE_ON_WINDOWS
+	class KVILIB_API KviHeapObject
+	{
+		// on other platforms this crap is not necessary
+	};
+#endif //!COMPILE_ON_WINDOWS
+
+#endif //!_KVI_HEAPOBJECT_H_
diff --git a/src/kvilib/core/kvi_inttypes.h b/src/kvilib/core/kvi_inttypes.h
new file mode 100644
index 00000000..6405ee79
--- /dev/null
+++ b/src/kvilib/core/kvi_inttypes.h
@@ -0,0 +1,95 @@
+#ifndef _KVI_INTTYPES_H_
+#define _KVI_INTTYPES_H_
+//=============================================================================
+//
+//   File : kvi_inttypes.h
+//   Creation date : Wed Sep  4 22:28:00 2002 GMT by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 2002-2006 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+#include "kvi_settings.h"
+
+#ifdef COMPILE_ON_WINDOWS
+	// we don't have a configure script here
+	// so we can't check the size of types
+	// We rely on the ms specific definitions then
+	typedef __int64 kvi_i64_t;
+	typedef unsigned __int64 kvi_u64_t;
+	typedef int kvi_i32_t;
+	typedef unsigned int kvi_u32_t;
+	typedef short int kvi_i16_t;
+	typedef short unsigned int kvi_u16_t;
+	typedef char kvi_i8_t;
+	typedef unsigned char kvi_u8_t;
+#else
+	#if SIZEOF_LONG_INT == 8
+		// the most common case on 64 bit machines
+		typedef long int kvi_i64_t;
+		typedef unsigned long int kvi_u64_t;
+	#elif SIZEOF_INT == 8
+		// 64 bit ints ?.. a Cray ? :D
+		typedef int kvi_i64_t;
+		typedef unsigned int kvi_u64_t;
+	#elif SIZEOF_LONG_LONG_INT == 8
+		// the most common case on 32 bit machines
+		typedef long long int kvi_i64_t;
+		typedef unsigned long long int kvi_u64_t;
+	#else
+		// attempt to live without a 64bit integer type anyway...
+		// dunno if it will work tough...
+		typedef long long int kvi_i64_t;
+		typedef unsigned long long int kvi_u64_t;
+	#endif
+
+	#if SIZEOF_INT == 4
+		// the most common case
+		typedef int kvi_i32_t;
+		typedef unsigned int kvi_u32_t;
+	#elif SIZEOF_SHORT_INT == 4
+		// 32 bit shorts ?.. a Cray ? :D
+		typedef short int kvi_i32_t;
+		typedef short unsigned int kvi_u32_t;
+	#elif SIZEOF_LONG_INT == 4
+		typedef long int kvi_i32_t;
+		typedef unsigned long int kvi_u32_t;
+	#else
+		#error "Can't find a 32 bit integral type on this system"
+		#error "Please report to pragma at kvirc dot net"
+	#endif
+
+	#if SIZEOF_SHORT_INT == 2
+		// the most common case
+		typedef short int kvi_i16_t;
+		typedef short unsigned int kvi_u16_t;
+	#elif SIZEOF_INT == 2
+		// this isn't going to work anyway, I think..
+		typedef int kvi_i16_t;
+		typedef long int kvi_u16_t;
+	#else
+		#error "Can't find a 16 bit integral type on this system"
+		#error "Please report to pragma at kvirc dot net"
+	#endif
+
+	// assume that char is always 8 bit
+	typedef char kvi_i8_t;
+	typedef unsigned char kvi_u8_t;
+#endif
+
+#endif //_KVI_INTTYPES_H_
diff --git a/src/kvilib/core/kvi_malloc.cpp b/src/kvilib/core/kvi_malloc.cpp
new file mode 100644
index 00000000..9c418ec5
--- /dev/null
+++ b/src/kvilib/core/kvi_malloc.cpp
@@ -0,0 +1,198 @@
+//=============================================================================
+//
+//   File : kvi_malloc.cpp
+//   Creation date : Sun Jun 18 2000 18:26:27 CEST by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 1999-2006 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+//=============================================================================
+// C memory allocation routines
+// This stuff is rather unused, because in normal compilations
+// kvi_malloc , kvi_free and kvi_realloc are macros (see kvi_malloc.h)
+//=============================================================================
+
+#define __KVILIB__
+
+#define _KVI_MALLOC_CPP_
+#include "kvi_malloc.h"
+
+#include <stdio.h>
+
+
+
+#ifdef COMPILE_MEMORY_PROFILE
+
+	//
+	// Memory profile stuff
+	// Used to find memory leaks etc...
+	//
+
+	#include "kvi_pointerlist.h"
+
+	typedef struct _KviMallocEntry {
+		struct _KviMallocEntry * prev;
+		void                   * pointer;
+		int                      size;
+		void                   * return_addr1;
+		void                   * return_addr2;
+		struct _KviMallocEntry * next;
+	} KviMallocEntry;
+
+	int              g_iMaxRequestSize           = 0;
+	void           * g_pMaxRequestReturnAddress1 = 0;
+	void           * g_pMaxRequestReturnAddress2 = 0;
+	unsigned int     g_iMallocCalls              = 0;
+	unsigned int     g_iReallocCalls             = 0;
+	unsigned int     g_iFreeCalls                = 0;
+	unsigned int     g_iTotalMemAllocated        = 0;
+	unsigned int     g_uAllocationPeak           = 0;
+	KviMallocEntry * g_pEntries                  = 0;
+
+	void * kvi_malloc(int size)
+	{
+		g_iMallocCalls ++;
+		g_iTotalMemAllocated += size;
+		if(g_iTotalMemAllocated > g_uAllocationPeak)g_uAllocationPeak = g_iTotalMemAllocated;
+		if(g_iMaxRequestSize < size){
+			g_iMaxRequestSize = size;
+			g_pMaxRequestReturnAddress1 = __builtin_return_address(1);
+			g_pMaxRequestReturnAddress2 = __builtin_return_address(2);
+		}
+		KviMallocEntry * e = (KviMallocEntry *)malloc(sizeof(KviMallocEntry));
+		e->pointer = malloc(size);
+		e->size = size;
+		e->return_addr1 = __builtin_return_address(1);
+		e->return_addr2 = __builtin_return_address(2);
+		e->next = g_pEntries;
+		e->prev = 0;
+		if(g_pEntries)g_pEntries->prev = e;
+		g_pEntries = e;
+		return e->pointer;
+	}
+
+	void * kvi_realloc(void * ptr,int size)
+	{
+		g_iReallocCalls ++;
+		if(ptr == 0)return kvi_malloc(size);
+		if(g_iMaxRequestSize < size){
+			g_iMaxRequestSize = size;
+			g_pMaxRequestReturnAddress1 = __builtin_return_address(1);
+			g_pMaxRequestReturnAddress2 = __builtin_return_address(2);
+		}
+		KviMallocEntry *e = g_pEntries;
+		while(e){
+			if(e->pointer == ptr){
+				g_iTotalMemAllocated -= e->size;
+				g_iTotalMemAllocated += size;
+				if(g_iTotalMemAllocated > g_uAllocationPeak)g_uAllocationPeak = g_iTotalMemAllocated;
+				e->pointer = realloc(ptr,size);
+				e->size = size;
+				e->return_addr1 = __builtin_return_address(1);
+				e->return_addr2 = __builtin_return_address(2);
+				return e->pointer;
+			}
+			e = e->next;
+		}
+		fprintf(stderr,"Attempt to realloc an inexisting pointer (%p) (called from %p (%p))\n",ptr,__builtin_return_address(1),__builtin_return_address(2));
+		return realloc(ptr,size);
+	}
+
+	void kvi_free(void * ptr)
+	{
+		g_iFreeCalls++;
+		if(ptr == 0){
+			fprintf(stderr,"Attempt to free a null pointer (called from %p (%p))\n",__builtin_return_address(1),__builtin_return_address(2));
+			exit(-1);
+		}
+		KviMallocEntry * e= g_pEntries;
+		while(e){
+			if(e->pointer == ptr){
+				g_iTotalMemAllocated -= e->size;
+				if(e->prev){
+					if(e == g_pEntries)fprintf(stderr,"Mem profiling internal error!\n");
+					e->prev->next = e->next;
+					if(e->next)e->next->prev = e->prev;
+				} else {
+					if(e != g_pEntries)fprintf(stderr,"Mem profiling internal error!\n");
+					if(e->next)e->next->prev = 0;
+					g_pEntries = e->next;
+				}
+				free(e);
+				return;
+			}
+			e = e->next;
+		}
+		fprintf(stderr,"Attempt to free an inexisting pointer (%p) (called from %p (%p))\n",ptr,__builtin_return_address(1),__builtin_return_address(2));
+	}
+
+	void kvi_memory_profile() __attribute__((destructor));
+	void kvi_memory_profile()
+	{
+		unsigned int countUnfreed = 0;
+		KviMallocEntry * e = g_pEntries;
+		while(e){
+			countUnfreed++;
+			e = e->next;
+		}
+		fprintf(stderr,"|====|====|====|====|====|====|====|====\n");
+		fprintf(stderr,"| Memory profile for KVIrc\n");
+		fprintf(stderr,"| Unfreed chunks : %d\n",countUnfreed);
+		fprintf(stderr,"| Total unfreed memory : %u bytes\n",g_iTotalMemAllocated);
+		fprintf(stderr,"|====|====|====|====|====|====|====|====\n");
+		fprintf(stderr,"| Possible unfreed chunks dump:\n");
+		e = g_pEntries;
+		while(e){
+			fprintf(stderr,"|====|====|\n");
+			fprintf(stderr,"| Currently unfreed chunk: %p\n",e->pointer);
+			fprintf(stderr,"| Size: %d\n",e->size);
+			fprintf(stderr,"| Caller address 1: %p\n",e->return_addr1);
+			fprintf(stderr,"| Caller address 2: %p\n",e->return_addr2);
+			if(e->size > 10)fprintf(stderr,"| Data: %.10s\n",e->pointer);
+			else if(e->size > 5)fprintf(stderr,"| Data: %.5s\n",e->pointer);
+			KviMallocEntry *toFree = e;
+			e = e->next;
+			free(toFree);
+		}
+		fprintf(stderr,"|====|====|====|====|====|====|====|====\n");
+		fprintf(stderr,"| Allocation peak : %u bytes\n",g_uAllocationPeak);
+		fprintf(stderr,"|====|====|====|====|====|====|====|====\n");
+		fprintf(stderr,"| Max request size : %d bytes\n",g_iMaxRequestSize);
+		fprintf(stderr,"| Called from %p (%p)\n",g_pMaxRequestReturnAddress1,g_pMaxRequestReturnAddress2);
+		fprintf(stderr,"|====|====|====|====|====|====|====|====\n");
+		fprintf(stderr,"| Malloc calls: %u\n",g_iMallocCalls);
+		fprintf(stderr,"| Realloc calls: %u\n",g_iReallocCalls);
+		fprintf(stderr,"| Free calls: %u\n",g_iFreeCalls);
+		fprintf(stderr,"|====|====|====|====|====|====|====|====\n");
+	}
+
+#else
+
+	#ifdef COMPILE_MEMORY_CHECKS
+
+	void outOfMemory()
+	{
+		//What a cool message :)
+		fprintf(stderr,"Virtual memory exhausted in malloc call....bye!\n");
+		exit(-1);
+	}
+
+	#endif
+
+#endif
diff --git a/src/kvilib/core/kvi_malloc.h b/src/kvilib/core/kvi_malloc.h
new file mode 100644
index 00000000..8a7204a5
--- /dev/null
+++ b/src/kvilib/core/kvi_malloc.h
@@ -0,0 +1,88 @@
+#ifndef _KVI_MALLOC_H_
+#define _KVI_MALLOC_H_
+
+//=============================================================================
+//
+//   File : kvi_malloc.h
+//   Creation date : Sun Jun 18 2000 18:18:36 CEST by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 1999-2006 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+//=============================================================================
+// C memory allocation routines: macros in common compilations
+//=============================================================================
+
+#include "kvi_settings.h"
+
+#include <stdlib.h>
+
+#ifdef COMPILE_MEMORY_PROFILE
+
+	#ifdef COMPILE_ON_WINDOWS
+		#error "This stuff should be never compiled on Windows"
+	#endif
+
+	extern void * kvi_malloc(int size);
+	extern void * kvi_realloc(void * ptr,int size);
+	extern void   kvi_free(void * ptr);
+
+#else
+
+	#ifndef COMPILE_MEMORY_CHECKS
+
+		// These two are the "common" ones
+		#define kvi_malloc(__size_) malloc(__size_)
+		#define kvi_realloc(__ptr_,__size_) realloc((void *)__ptr_,__size_)
+
+	#else
+
+		#ifdef COMPILE_ON_WINDOWS
+			#error "This stuff should be never compiled on Windows"
+		#endif
+
+		// Want to check all the pointers
+		#define kvi_malloc(__size_) kvi_safe_malloc(__size_)
+		#define kvi_realloc(__ptr_,__size_) kvi_safe_realloc((void *)__ptr_,__size_)
+	
+		#ifndef _KVI_MALLOC_CPP_
+			extern void outOfMemory();
+		#endif
+
+		inline void * kvi_safe_malloc(int size)
+		{
+			void * ptr = malloc(size);
+			if(!ptr)outOfMemory();
+			return ptr;
+		}
+
+		inline void * kvi_safe_realloc(void * ptr,int size)
+		{
+			ptr = realloc(ptr,size);
+			if(!ptr)outOfMemory();
+			return ptr;
+		}
+
+	#endif //COMPILE_MEMORY_CHECKS
+
+	#define kvi_free(__ptr_) free((void *)__ptr_)
+
+#endif
+
+#endif //_KVI_MALLOC_H_
diff --git a/src/kvilib/core/kvi_memmove.cpp b/src/kvilib/core/kvi_memmove.cpp
new file mode 100644
index 00000000..1beb920a
--- /dev/null
+++ b/src/kvilib/core/kvi_memmove.cpp
@@ -0,0 +1,253 @@
+//=============================================================================
+//
+//   File : kvi_memmove.cpp
+//   Creation date : Sun Jun 18 2000 18:27:50 CEST by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 1999-2006 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+#define __KVILIB__
+
+#define _KVI_DEBUG_CHECK_RANGE_
+#include "kvi_debug.h"
+
+#define _KVI_MEMMOVE_CPP_
+#include "kvi_memmove.h"
+
+// FIXME: #warning "With system memmove could be guessed by configure"
+
+#ifndef COMPILE_WITH_SYSTEM_MEMMOVE
+	
+	#ifdef COMPILE_ix86_ASM
+
+
+		void *kvi_memmove(void * dst_ptr,const void *src_ptr,int len)
+		{
+			__range_valid(dst_ptr);
+			__range_valid(src_ptr);
+			__range_valid(len >= 0);
+			// Save pointer registers
+			asm("	pushl %esi");                     // save %esi
+			asm("	pushl %edi");                     // save %edi
+			// Load arguments
+			asm("	movl 16(%ebp),%ecx");             // %ecx = len
+			asm("	movl 12(%ebp),%esi");             // %esi = src
+			asm("	movl 8(%ebp),%edi");              // %edi = dst
+			// Compare src and dest
+			asm("	cmpl %esi,%edi");                 // %edi - %esi
+			asm("	jbe move_from_bottom_to_top");    // if(%edi < %esi) jump to move_from_bottom_to_top
+			// dst_ptr > src_ptr
+			asm("	addl %ecx,%esi");                 // %esi += %ecx (src_ptr += len);
+			asm("	addl %ecx,%edi");                 // %edi += %ecx (dst_ptr += len);
+			asm("	decl %esi");                      // %esi--; (src_ptr--);
+			asm("	decl %edi");                      // %edi--; (dst_ptr--);
+			asm("	std");                            // set direction flag (decrement esi and edi in movsb)
+			// Optimization : check for non-odd len (1,3,5,7...)
+			asm("	shr $1,%ecx");                    // %ecx >> 1 , shifted bit -> CF
+			asm("	jnc move_two_bytes_top_to_bottom_directly");  // if !carry (CF == 0) skip this move
+			// Move the first byte (non-odd)
+			asm("	movsb %ds:(%esi),%es:(%edi)");    // *dst-- = *src-- if DF  else *dst++ = *src++
+			asm("move_two_bytes_top_to_bottom_directly:");
+			asm("	decl %esi");                      // %esi--; (src_ptr--);
+			asm("	decl %edi");                      // %edi--; (dst_ptr--);
+			asm("move_two_bytes_top_to_bottom:");
+			asm("	shr $1,%ecx");                    // %ecx >> 1 , shifted bit -> CF
+			asm("	jnc move_the_rest_top_to_bottom_directly"); // if !carry (CF == 0) skip this move
+			// Move the next two bytes
+			asm("	movsw %ds:(%esi),%es:(%edi)");    // *((word *)dst)-- = *((word)src)-- if DF else *((word *)dst)++ = *((word)src)++
+			asm("move_the_rest_top_to_bottom_directly:");
+			asm("	subl $2,%esi");                   // %esi-=2; (src-=2);
+			asm("   subl $2,%edi");                   // %edi-=2; (dst-=2);
+			asm("   jmp move_the_rest");              // call last repnz movsl
+			// dst_ptr <= src_ptr
+			asm("move_from_bottom_to_top:");
+			asm("	cld");                            // clear direction flag (increment esi and edi in movsb)
+			// Optimization : check for non-odd len (1,3,5,7...)
+			asm("	shr $1,%ecx");                    // %ecx >> 1 , shifted bit -> CF
+			asm("	jnc move_two_bytes");             // if !carry (CF == 0) skip this move
+			// Move the first byte (non-odd)
+			asm("	movsb %ds:(%esi),%es:(%edi)");    // *dst-- = *src-- if DF  else *dst++ = *src++
+			// Optimization : pass 2 , check for %2 and %3
+			asm("move_two_bytes:");
+			asm("	shr $1,%ecx");                    // %ecx >> 1 , shifted bit -> CF
+			asm("	jnc move_the_rest");              // if !carry (CF == 0) skip this move
+			// Move the next two bytes
+			asm("	movsw %ds:(%esi),%es:(%edi)");    // *((word *)dst)-- = *((word)src)-- if DF else *((word *)dst)++ = *((word)src)++
+			// Main move remaining part
+			asm("move_the_rest:");
+			asm("	repnz; movsl %ds:(%esi),%es:(%edi)"); // loop moving 4 bytes at once (increment or decrement as above)
+			// Restore pointer registers
+			asm("	popl %edi");                      // restore %edi
+			asm("	popl %esi");                      // restore %esi
+			return dst_ptr; //asm("   movl 8(%ebp),%eax"); <-- gcc will put that (AFTER THE OPTIMISATION PASS!)
+		}
+	
+		void *kvi_memmoveodd(void * dst_ptr,const void *src_ptr,int len)
+		{
+			__range_valid(dst_ptr);
+			__range_valid(src_ptr);
+			__range_valid(len >= 0);
+			// Save pointer registers
+			asm("	pushl %esi");                     // save %esi
+			asm("	pushl %edi");                     // save %edi
+			// Load arguments
+			asm("	movl 16(%ebp),%ecx");             // %ecx = len
+			asm("	movl 12(%ebp),%esi");             // %esi = src
+			asm("	movl 8(%ebp),%edi");              // %edi = dst
+			// Compare src and dest
+			asm("	cmpl %esi,%edi");                 // %edi - %esi
+			asm("	jbe xmove_from_bottom_to_top");    // if(%edi < %esi) jump to move_from_bottom_to_top
+			// dst_ptr > src_ptr
+			asm("	addl %ecx,%esi");                 // %esi += %ecx (src_ptr += len);
+			asm("	addl %ecx,%edi");                 // %edi += %ecx (dst_ptr += len);
+			asm("	std");                            // set direction flag (decrement esi and edi in movsb)
+			// start moving
+			asm("	shr $2,%ecx");                    // %ecx >> 2 , last shifted bit -> CF
+			asm("	jnc xmove_the_rest_top_to_bottom_directly"); // if !carry (CF == 0) skip this move
+			// Move the next two bytes
+			asm("	subl $2,%esi");                   // %esi-=2; (src_ptr-=2);
+			asm("	subl $2,%edi");                   // %edi-=2; (dst_ptr-=2);
+			asm("	movsw %ds:(%esi),%es:(%edi)");    // *((word *)dst)-- = *((word)src)-- if DF else *((word *)dst)++ = *((word)src)++
+			asm("	subl $2,%esi");                   // %esi-=2; (src_ptr-=2);
+			asm("	subl $2,%edi");                   // %edi-=2; (dst_ptr-=2);
+			asm("   jmp xmove_the_rest");
+			asm("xmove_the_rest_top_to_bottom_directly:");
+			asm("	subl $4,%esi");                   // %esi-=4; (src-=4);
+			asm("   subl $4,%edi");                   // %edi-=4; (dst-=4);
+			asm("   jmp xmove_the_rest");              // call last repnz movsl
+			// dst_ptr <= src_ptr
+			asm("xmove_from_bottom_to_top:");
+			asm("	cld");                            // clear direction flag (increment esi and edi in movsb)
+			// move it
+			asm("	shr $2,%ecx");                    // %ecx >> 2 , last shifted bit -> CF
+			asm("	jnc xmove_the_rest");              // if !carry (CF == 0) skip this move
+			// Move the next two bytes
+			asm("	movsw %ds:(%esi),%es:(%edi)");    // *((word *)dst)-- = *((word)src)-- if DF else *((word *)dst)++ = *((word)src)++
+			// Main move remaining part
+			asm("xmove_the_rest:");
+			asm("	repnz; movsl %ds:(%esi),%es:(%edi)"); // loop moving 4 bytes at once (increment or decrement as above)
+			// Restore pointer registers
+			asm("	popl %edi");                      // restore %edi
+			asm("	popl %esi");                      // restore %esi
+			return dst_ptr; //asm("   movl 8(%ebp),%eax"); <-- gcc will put that (AFTER THE OPTIMISATION PASS!)
+		}
+
+	#else // ndef COMPILE_ix86_ASM
+	
+
+
+		// The next 4 functions could be optimized with the & and shift technique
+		// used in the assembly implementations but the compilers usually
+		// will not translate the carry bit trick producing code
+		// that works slower on short block of memory (really near the average case)
+	
+		// The trick would be:
+		//
+		//    if(len & 1) // the length is even
+		//       *dst-- = *src--; // move one byte
+		//    len >> 1; // drop the last bit (thus divide by 2)
+		//    if(len & 1) // the length is still even
+		//       *((short *)dst)-- = *((short *)src)--; // move two bytes
+		//    len >> 1; // again drop the last bit (thus divide by 2)
+		//    while(len--)*((int *)dst)-- = *((int *)src)--; // move four bytes at a time
+		//
+		//
+	
+		void *kvi_memmove(void *dst_ptr,const void *src_ptr,int len)
+		{
+			__range_valid(dst_ptr);
+			__range_valid(src_ptr);
+			__range_valid(len >= 0);
+			register char *dst;
+			register const char *src;
+			if(dst_ptr > src_ptr){
+				dst = (char *)dst_ptr + len - 1;
+				src = (const char *)src_ptr + len - 1;
+				while(len--)*dst-- = *src--;
+		    } else { //it is valid even if dst_ptr == src_ptr 
+				dst = (char *)dst_ptr;
+				src = (const char *)src_ptr;
+				while(len--)*dst++ = *src++;
+		    }
+		    return dst_ptr;
+		}
+	
+		void *kvi_memmoveodd(void *dst_ptr,const void *src_ptr,int len)
+		{
+			__range_valid(dst_ptr);
+			__range_valid(src_ptr);
+			__range_valid(len >= 0);
+			__range_valid((len & 1) == 0);
+			register short *dst;
+			register const short *src;
+			if(dst_ptr > src_ptr){
+				dst = (short *) (((char *)dst_ptr) + len - 2);
+				src = (const short *) (((const char *)src_ptr) + len - 2);
+				while(len > 0)
+				{
+					*dst-- = *src--;
+					len -= 2;
+				}
+		    } else { //it is valid even if dst_ptr == src_ptr 
+				dst = (short *)dst_ptr;
+				src = (const short *)src_ptr;
+				while(len > 0)
+				{
+					*dst++ = *src++;
+					len -= 2;
+				}
+		    }
+		    return dst_ptr;
+		}
+		
+		void kvi_fastmove(void *dst_ptr,const void *src_ptr,int len)
+		{
+			__range_valid(dst_ptr);
+			__range_valid(src_ptr);
+			__range_valid(len >= 0);
+			register const char *src = (const char *)src_ptr;
+			register char *dst = (char *)dst_ptr;
+			while(len--)*dst++ = *src++;
+		}
+	
+		void kvi_fastmoveodd(void *dst_ptr,const void *src_ptr,int len)
+		{
+			__range_valid(dst_ptr);
+			__range_valid(src_ptr);
+			__range_valid(len >= 0);
+			__range_valid((len & 1) == 0);
+			register const short *src = (const short *)src_ptr;
+			register short *dst = (short *)dst_ptr;
+			while(len > 0){
+				*dst++ = *src++;
+				len -= 2;
+			}
+		}
+
+	#endif // !COMPILE_ix86_ASM
+	
+	void kvi_memset(void *dst_ptr,char c,int len)
+	{
+		__range_valid(dst_ptr);
+		__range_valid(len >= 0);
+		register char *dst = (char *)dst_ptr;
+		while(len--)*dst++ = c;
+	}
+
+#endif // !COMPILE_WITH_SYSTEM_MEMMOVE
diff --git a/src/kvilib/core/kvi_memmove.h b/src/kvilib/core/kvi_memmove.h
new file mode 100644
index 00000000..d1319a41
--- /dev/null
+++ b/src/kvilib/core/kvi_memmove.h
@@ -0,0 +1,105 @@
+#ifndef _KVI_MEMMOVE_H_
+#define _KVI_MEMMOVE_H_
+
+//=============================================================================
+//
+//   File : kvi_memmove.h
+//   Creation date : Fri Mar 19 1999 03:15:21 CEST by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 1999-2006 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+#define __KVILIB__
+
+#include "kvi_settings.h"
+
+//#undef COMPILE_WITH_SYSTEM_MEMMOVE
+//#define COMPILE_MMX_ASM
+
+#ifndef _KVI_MEMMOVE_CPP_
+
+	#ifdef COMPILE_WITH_SYSTEM_MEMMOVE
+
+		#include <string.h>
+
+		#define kvi_memmove memmove
+		#define kvi_memmoveodd memmove
+		#define kvi_memset memset
+		#define kvi_fastmove memcpy
+		#define kvi_fastmoveodd memcpy
+
+	#else
+
+		#ifdef COMPILE_ON_WINDOWS
+			#error "This stuff should be never compiled on Windows"
+		#endif
+
+		extern void *kvi_memmove(void *dst_ptr,const void *src_ptr,int len);
+		extern void *kvi_memmoveodd(void *dst_ptr,const void *src_ptr,int len);
+		extern void *kvi_memset(void *dst_ptr,char c,int len);
+		// In fastmove the src and dst may not overlap
+	
+		#ifdef COMPILE_ix86_ASM
+
+			// WE WANT repnz; movsq\n"!!!
+
+			inline void kvi_fastmove(void * dst_ptr,const void *src_ptr,int len)
+			{
+				__asm__ __volatile__(
+					"	cld\n"
+					"	shr $1,%0\n"
+					"	jnc 1f\n"
+					"	movsb\n"
+					"1:\n"
+					"	shr $1,%0\n"
+					"	jnc 2f\n"
+					"	movsw\n"
+					"2:\n"
+					"	repnz; movsl\n"
+					: "=c" (len), "=&S" (src_ptr), "=&D" (dst_ptr)
+					: "0"  (len), "1"   (src_ptr), "2"   (dst_ptr)
+				);
+			}
+
+			inline void kvi_fastmoveodd(void * dst_ptr,const void *src_ptr,int len)
+			{
+				__asm__ __volatile__(
+					"	cld\n"
+					"	shr $2,%0\n"
+					"	jnc 1f\n"
+					"	movsw\n"
+					"1:\n"
+					"	repnz; movsl\n"
+					: "=c" (len), "=&S" (src_ptr), "=&D" (dst_ptr)
+					: "0"  (len), "1"   (src_ptr), "2"   (dst_ptr)
+				);
+			}
+
+		#else // ! COMPILE_ix86_ASM
+
+			extern void kvi_fastmove(void *dst_ptr,const void *src_ptr,int len);
+			extern void kvi_fastmoveodd(void *dst_ptr,const void *src_ptr,int len);
+
+		#endif // !COMPILE_ix86_ASM
+
+	#endif // COMPILE_WITH_SYSTEM_MEMMOVE
+
+#endif // _KVI_MEMMOVE_CPP_
+
+#endif // !_KVI_MEMMOVE_H_
diff --git a/src/kvilib/core/kvi_pointerhashtable.h b/src/kvilib/core/kvi_pointerhashtable.h
new file mode 100644
index 00000000..9066c091
--- /dev/null
+++ b/src/kvilib/core/kvi_pointerhashtable.h
@@ -0,0 +1,999 @@
+#ifndef _KVI_POINTERHASHTABLE_H_
+#define _KVI_POINTERHASHTABLE_H_
+//=================================================================================================
+//
+//   File : kvi_pointerhashtable.h
+//   Creation date : Sat Jan 12 2008 04:53 by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 2008 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=================================================================================================
+
+#include "kvi_settings.h"
+#include "kvi_pointerlist.h"
+#include "kvi_string.h"
+#include "kvi_qstring.h"
+#include "kvi_malloc.h"
+#include "kvi_memmove.h"
+
+#include <ctype.h>
+
+///
+/// Hash functions for various data types
+///
+
+inline unsigned int kvi_hash_hash(const char * szKey,bool bCaseSensitive)
+{
+	unsigned int uResult = 0;
+	if(bCaseSensitive)
+	{
+		while(*szKey)
+		{
+			uResult += (unsigned char)(*(szKey));
+			szKey++;
+		}
+	} else {
+		while(*szKey)
+		{
+			uResult += (unsigned char)tolower(*(szKey));
+			szKey++;
+		}
+	}
+	return uResult;
+}
+
+inline bool kvi_hash_key_equal(const char * szKey1,const char * szKey2,bool bCaseSensitive)
+{
+	if(bCaseSensitive)
+	{
+		while(*szKey1 && *szKey2)
+		{
+			if(*szKey1 != *szKey2)
+				return false;
+			szKey1++;
+			szKey2++;
+		}
+	} else {
+		while(*szKey1 && *szKey2)
+		{
+			if(tolower(*szKey1) != tolower(*szKey2))
+				return false;
+			szKey1++;
+			szKey2++;
+		}
+	}
+	return true;
+}
+
+inline void kvi_hash_key_copy(const char * const &szFrom,const char * &szTo,bool bDeepCopy)
+{
+	if(bDeepCopy)
+	{
+		int len = kvi_strLen(szFrom);
+		char * dst = (char *)kvi_malloc(len+1);
+		kvi_fastmove(dst,szFrom,len+1);
+		szTo = dst;
+	} else {
+		szTo = szFrom; // we never modify it anyway
+	}
+}
+
+inline void kvi_hash_key_destroy(const char * &szKey,bool bDeepCopy)
+{
+	if(bDeepCopy)
+		kvi_free(szKey);
+}
+
+inline const char * & kvi_hash_key_default(const char **)
+{
+	static const char * static_null = NULL;
+	return static_null;
+}
+
+inline unsigned int kvi_hash_hash(const KviStr &szKey,bool bCaseSensitive)
+{
+	unsigned int uResult = 0;
+	const char * p = szKey.ptr();
+	if(bCaseSensitive)
+	{
+		while(*p)
+		{
+			uResult += *((const unsigned char *)p);
+			p++;
+		}
+	} else {
+		while(*p)
+		{
+			uResult += tolower(*((const unsigned char *)p));
+			p++;
+		}
+	}
+	return uResult;
+}
+
+inline bool kvi_hash_key_equal(const KviStr &szKey1,const KviStr &szKey2)
+{
+	return kvi_hash_key_equal(szKey1.ptr(),szKey2.ptr());
+}
+
+inline void kvi_hash_key_copy(const KviStr &szFrom,KviStr &szTo,bool)
+{
+	szTo = szFrom;
+}
+
+inline void kvi_hash_key_destroy(KviStr &szKey,bool)
+{
+}
+
+inline const KviStr & kvi_hash_key_default(KviStr *)
+{
+	return KviStr::emptyString();
+}
+
+inline unsigned int kvi_hash_hash(const int &iKey,bool)
+{
+	return (unsigned int)iKey;
+}
+
+inline bool kvi_hash_key_equal(const int &iKey1,const int &iKey2,bool)
+{
+	return iKey1 == iKey2;
+}
+
+inline void kvi_hash_key_copy(const int &iKeyFrom,int &iKeyTo,bool)
+{
+	iKeyTo = iKeyFrom;
+}
+
+inline void kvi_hash_key_destroy(int &iKey,bool)
+{
+}
+
+inline const int & kvi_hash_key_default(int *)
+{
+	static int static_default = 0;
+	return static_default;
+}
+
+inline unsigned int kvi_hash_hash(const unsigned short &iKey,bool)
+{
+	return (unsigned int)iKey;
+}
+
+inline bool kvi_hash_key_equal(const unsigned short &iKey1,const unsigned short &iKey2,bool)
+{
+	return iKey1 == iKey2;
+}
+
+inline void kvi_hash_key_copy(const unsigned short &iKeyFrom,unsigned short &iKeyTo,bool)
+{
+	iKeyTo = iKeyFrom;
+}
+
+inline void kvi_hash_key_destroy(unsigned short &iKey,bool)
+{
+}
+
+inline const unsigned short & kvi_hash_key_default(unsigned short *)
+{
+	static unsigned short static_default = 0;
+	return static_default;
+}
+
+
+inline unsigned int kvi_hash_hash(void * pKey,bool)
+{
+	unsigned char * pBytes = (unsigned char *)&(pKey);
+	unsigned char * pEnd = pBytes + sizeof(void *);
+	unsigned int uSum = 0;
+	while(pBytes < pEnd)
+	{
+		uSum += *pBytes;
+		pBytes++;
+	}
+	return uSum;
+}
+
+inline bool kvi_hash_key_equal(void *pKey1,void *pKey2,bool)
+{
+	return pKey1 == pKey2;
+}
+
+inline void kvi_hash_key_copy(void * const &pKeyFrom,void *&pKeyTo,bool)
+{
+	pKeyTo = pKeyFrom;
+}
+
+inline void kvi_hash_key_destroy(void *iKey,bool)
+{
+}
+
+inline void * & kvi_hash_key_default(void *)
+{
+	static void * static_default = NULL;
+	return static_default;
+}
+
+inline unsigned int kvi_hash_hash(const QString &szKey,bool bCaseSensitive)
+{
+	unsigned int uResult = 0;
+	const QChar * p = KviQString::nullTerminatedArray(szKey);
+	if(!p)return 0;
+	if(bCaseSensitive)
+	{
+		while(p->unicode())
+		{
+			uResult += p->unicode();
+			p++;
+		}
+	} else {
+		while(p->unicode())
+		{
+#ifdef COMPILE_USE_QT4
+			uResult += p->toLower().unicode();
+#else
+			uResult += p->lower().unicode();
+#endif
+			p++;
+		}
+	}
+	return uResult;
+}
+
+inline bool kvi_hash_key_equal(const QString &szKey1,const QString &szKey2,bool bCaseSensitive)
+{
+	if(bCaseSensitive)
+		return KviQString::equalCS(szKey1,szKey2);
+	return KviQString::equalCI(szKey1,szKey2);
+}
+
+inline void kvi_hash_key_copy(const QString &szFrom,QString &szTo,bool)
+{
+	szTo = szFrom;
+}
+
+inline void kvi_hash_key_destroy(QString &szKey,bool)
+{
+}
+
+inline const QString & kvi_hash_key_default(QString *)
+{
+	return KviQString::empty;
+}
+
+template<typename Key,typename T> class KviPointerHashTable;
+template<typename Key,typename T> class KviPointerHashTableIterator;
+
+template<typename Key,typename T> class KviPointerHashTableEntry
+{
+	friend class KviPointerHashTable<Key,T>;
+protected:
+	T  * pData;
+	Key  hKey;
+public:
+	Key & key(){ return hKey; };
+	T * data(){ return pData; };
+};
+
+///
+///
+/// \class KviPointerHashTable
+/// \brief A fast pointer hash table implementation
+///
+/// A very cool, very fast hash table implementation :P
+///
+/// To use this hash table you need to provide implementations
+/// for the following functions:
+///
+/// \verbatim
+///
+/// unsigned int kvi_hash_hash(const Key &hKey,bool bCaseSensitive);
+/// bool kvi_hash_key_equal(const Key &hKey1,const Key &hKey2,bool bCaseSensitive);
+/// void kvi_hash_key_copy(const Key &hKeyFrom,Key &hKeyTo,bool bDeepCopy);
+/// void kvi_hash_key_destroy(Key &hKey,bool bIsDeepCopy);
+/// const Key & kvi_hash_key_default(Key *);
+///
+/// \endverbatim
+///
+/// Implementations for the most likey Key data types are provided below.
+/// KviPointerHashTable will automagically work with const char *,QString,KviStr
+/// and integer types as keys.
+///
+/// For string Key types, the hash table may or may not be case sensitive.
+/// For other Key types the case sensitive flag has no meaning and will
+/// (hopefully) be optimized out by the compiler.
+///
+/// For pointer based keys the hash table may or may not mantain deep copies
+/// of Key data. For example, with char * keys, if deep copying is enabled
+/// then a private copy of the string data will be mantained. With deep
+/// copying disabled only char * pointers will be kept. For types
+/// that do not have meaning of deep copy the deep copying code will
+/// (hopefully) be optimized out by the compiler.
+///
+/// The hashtable mantains an array of KviPointerList based buckets.
+/// The number of buckets may be specified by the application user
+/// and does NOT need to be a prime number. Yet better to have it a power
+/// of two so the memory allocation routines will feel better and are
+/// less likely to waste space.
+///
+template<class Key,class T> class KviPointerHashTable
+{
+	friend class KviPointerHashTableIterator<Key,T>;
+protected:
+	KviPointerList<KviPointerHashTableEntry<Key,T> >      ** m_pDataArray;
+	bool                                                     m_bAutoDelete;
+	unsigned int                                             m_uSize;
+	unsigned int                                             m_uCount;
+	bool                                                     m_bCaseSensitive;
+	bool                                                     m_bDeepCopyKeys;
+	unsigned int                                             m_uIteratorIdx;
+public:
+	///
+	/// Returns the item associated to the key hKey
+	/// or NULL if no such item exists in the hash table.
+	/// Places the hash table iterator at the position
+	/// of the item found.
+	///
+	T * find(const Key & hKey)
+	{
+		m_uIteratorIdx = kvi_hash_hash(hKey,m_bCaseSensitive) % m_uSize;
+		if(!m_pDataArray[m_uIteratorIdx])return 0;
+		for(KviPointerHashTableEntry<Key,T> * e = m_pDataArray[m_uIteratorIdx]->first();e;e = m_pDataArray[m_uIteratorIdx]->next())
+		{
+			if(kvi_hash_key_equal(e->hKey,hKey,m_bCaseSensitive))return (T *)e->pData;
+		}
+		return 0;
+	}
+	
+	///
+	/// Returns the item associated to the key hKey
+	/// or NULL if no such item exists in the hash table.
+	/// Places the hash table iterator at the position
+	/// of the item found. This is an alias to find().
+	///
+	T * operator[](const Key & hKey)
+	{
+		return find(hKey);
+	}
+
+	///
+	/// Returns the number of items in this hash table
+	///
+	unsigned int count() const
+	{
+		return m_uCount;
+	}
+
+	///
+	/// Returns true if the hash table is empty
+	///
+	bool isEmpty() const
+	{
+		return m_uCount == 0;
+	}
+
+	///
+	/// Inserts the item pData at the position specified by the key hKey.
+	/// Replaces any previous item with the same key
+	/// The replaced item is deleted if autodelete is enabled.
+	/// The hash table iterator is placed at the newly inserted item.
+	///
+	void insert(const Key & hKey,T * pData)
+	{
+		if(!pData)return;
+		unsigned int uEntry = kvi_hash_hash(hKey,m_bCaseSensitive) % m_uSize;
+		if(!m_pDataArray[uEntry])m_pDataArray[uEntry] = new KviPointerList<KviPointerHashTableEntry<Key,T> >(true);
+		for(KviPointerHashTableEntry<Key,T> * e = m_pDataArray[uEntry]->first();e;e = m_pDataArray[uEntry]->next())
+		{
+			if(kvi_hash_key_equal(e->hKey,hKey,m_bCaseSensitive))
+			{
+				if(!m_bCaseSensitive)
+				{
+					// must change the key too
+					kvi_hash_key_destroy(e->hKey,m_bDeepCopyKeys);
+					kvi_hash_key_copy(hKey,e->hKey,m_bDeepCopyKeys);
+				}
+				if(m_bAutoDelete)delete e->pData;
+				e->pData = pData;
+				return;
+			}
+		}
+		KviPointerHashTableEntry<Key,T> * n = new KviPointerHashTableEntry<Key,T>;
+		kvi_hash_key_copy(hKey,n->hKey,m_bDeepCopyKeys);
+		n->pData = pData;
+		m_pDataArray[uEntry]->append(n);
+		m_uCount++;
+	}
+
+	///
+	/// Inserts the item pData at the position specified by the key hKey.
+	/// Replaces any previous item with the same key
+	/// The replaced item is deleted if autodelete is enabled.
+	/// The hash table iterator is placed at the newly inserted item.
+	/// This is just an alias to insert() with a different name.
+	///
+	void replace(const Key & hKey,T * pData)
+	{
+		insert(hKey,pData);
+	}
+
+	///
+	/// Removes the item pointer associated to the key hKey, if such an item
+	/// exists in the hash table. The item is deleted if autodeletion
+	/// is enabled. Returns true if the item was found and removed and false if it wasn't found.
+	/// Invalidates the hash table iterator.
+	///
+	bool remove(const Key & hKey)
+	{
+		unsigned int uEntry = kvi_hash_hash(hKey,m_bCaseSensitive) % m_uSize;
+		if(!m_pDataArray[uEntry])return false;
+		for(KviPointerHashTableEntry<Key,T> * e = m_pDataArray[uEntry]->first();e;e = m_pDataArray[uEntry]->next())
+		{
+			if(kvi_hash_key_equal(e->hKey,hKey,m_bCaseSensitive))
+			{
+				kvi_hash_key_destroy(e->hKey,m_bDeepCopyKeys);
+				if(m_bAutoDelete)delete ((T *)(e->pData));
+				m_pDataArray[uEntry]->removeRef(e);
+				if(m_pDataArray[uEntry]->isEmpty())
+				{
+					delete m_pDataArray[uEntry];
+					m_pDataArray[uEntry] = 0;
+				}
+				m_uCount--;
+				return true;
+			}
+		}
+		return false;
+	}
+
+	///
+	/// Removes the first occurence of the item pointer pRef. The item is deleted if autodeletion
+	/// is enabled. Returns true if the pointer was found and false otherwise
+	/// Invalidates the hash table iterator.
+	///
+	bool removeRef(const T * pRef)
+	{
+		for(unsigned int i=0;i<m_uSize;i++)
+		{
+			if(m_pDataArray[i])
+			{
+				for(KviPointerHashTableEntry<Key,T> * e = m_pDataArray[i]->first();e;e = m_pDataArray[i]->next())
+				{
+					if(e->pData == pRef)
+					{
+						kvi_hash_key_destroy(e->hKey,m_bDeepCopyKeys);
+						if(m_bAutoDelete)delete ((T *)(e->pData));
+						m_pDataArray[i]->removeRef(e);
+						if(m_pDataArray[i]->isEmpty())
+						{
+							delete m_pDataArray[i];
+							m_pDataArray[i] = 0;
+						}
+						m_uCount--;
+						return true;
+					}
+				}
+			}			
+		}
+		return false;
+	}
+
+	///
+	/// Removes all the items from the hash table.
+	/// The items are deleted if autodeletion is enabled.
+	/// Invalidates the hash table iterator.
+	///
+	void clear()
+	{
+		for(unsigned int i=0;i<m_uSize;i++)
+		{
+			if(m_pDataArray[i])
+			{
+				for(KviPointerHashTableEntry<Key,T> * e = m_pDataArray[i]->first();e;e = m_pDataArray[i]->next())
+				{
+					kvi_hash_key_destroy(e->hKey,m_bDeepCopyKeys);
+					if(m_bAutoDelete)
+						delete ((T *)(e->pData));
+				}
+				delete m_pDataArray[i];
+				m_pDataArray[i] = 0;
+			}
+		}
+		m_uCount = 0;
+	}
+
+	///
+	/// Searches for the item pointer pRef and returns
+	/// it's hash table entry, if found, and NULL otherwise.
+	/// The hash table iterator is placed at the item found.
+	///
+	KviPointerHashTableEntry<Key,T> * findRef(const T * pRef)
+	{
+		for(m_uIteratorIdx = 0;m_uIteratorIdx<m_uSize;m_uIteratorIdx++)
+		{
+			if(m_pDataArray[m_uIteratorIdx])
+			{
+				for(KviPointerHashTableEntry<Key,T> * e = m_pDataArray[m_uIteratorIdx]->first();e;e = m_pDataArray[m_uIteratorIdx]->next())
+				{
+					if(e->pData == pRef)return e;
+				}
+			}
+		}
+		return 0;
+	}
+
+	///
+	/// Returns the entry pointed by the hash table iterator.
+	/// This function must be preceeded by a call to firstEntry(), first()
+	/// or findRef().
+	///
+	KviPointerHashTableEntry<Key,T> * currentEntry()
+	{
+		if(m_uIteratorIdx >= m_uSize)return 0;
+		if(m_pDataArray[m_uIteratorIdx])return m_pDataArray[m_uIteratorIdx]->current();
+		return 0;
+	}
+
+	///
+	/// Places the hash table iterator at the first entry
+	/// and returns it.
+	///
+	KviPointerHashTableEntry<Key,T> * firstEntry()
+	{
+		m_uIteratorIdx = 0;
+		while(m_uIteratorIdx < m_uSize && (!m_pDataArray[m_uIteratorIdx]))
+		{
+			m_uIteratorIdx++;
+		}
+		if(m_uIteratorIdx == m_uSize)return 0;
+		return m_pDataArray[m_uIteratorIdx]->first();
+	}
+
+	///
+	/// Places the hash table iterator at the next entry
+	/// and returns it.
+	/// This function must be preceeded by a call to firstEntry(), first()
+	/// or findRef().
+	///
+	KviPointerHashTableEntry<Key,T> * nextEntry()
+	{
+		if(m_uIteratorIdx >= m_uSize)return 0;
+
+		if(m_uIteratorIdx < m_uSize)
+		{
+			KviPointerHashTableEntry<Key,T> * t = m_pDataArray[m_uIteratorIdx]->next();
+			if(t)return t;
+		}
+
+		m_uIteratorIdx++;
+
+		while(m_uIteratorIdx < m_uSize && (!m_pDataArray[m_uIteratorIdx]))
+		{
+			m_uIteratorIdx++;
+		}
+
+		if(m_uIteratorIdx == m_uSize)return 0;
+
+		return m_pDataArray[m_uIteratorIdx]->first();
+
+	}
+
+	///
+	/// Returns the data value pointer pointed by the hash table iterator.
+	/// This function must be preceeded by a call to firstEntry(), first()
+	/// or findRef().
+	///
+	T * current()
+	{
+		if(m_uIteratorIdx >= m_uSize)return 0;
+		if(m_pDataArray[m_uIteratorIdx])
+		{
+			KviPointerHashTableEntry<Key,T> * e = m_pDataArray[m_uIteratorIdx]->current();
+			if(!e)return 0;
+			return e->data();
+		}
+		return 0;
+	}
+	
+	///
+	/// Returns the key pointed by the hash table iterator.
+	/// This function must be preceeded by a call to firstEntry(), first()
+	/// or findRef().
+	///
+	const Key & currentKey()
+	{
+		if(m_uIteratorIdx >= m_uSize)return kvi_hash_key_default(((Key *)NULL));
+		if(m_pDataArray[m_uIteratorIdx])
+		{
+			KviPointerHashTableEntry<Key,T> * e = m_pDataArray[m_uIteratorIdx]->current();
+			if(!e)return kvi_hash_key_default(((Key *)NULL));
+			return e->key();
+		}
+		return kvi_hash_key_default(((Key *)NULL));
+	}
+
+	///
+	/// Places the hash table iterator at the first entry
+	/// and returns the associated data value pointer.
+	///
+	T * first()
+	{
+		m_uIteratorIdx = 0;
+		while(m_uIteratorIdx < m_uSize && (!m_pDataArray[m_uIteratorIdx]))
+		{
+			m_uIteratorIdx++;
+		}
+		if(m_uIteratorIdx == m_uSize)return 0;
+		KviPointerHashTableEntry<Key,T> * e = m_pDataArray[m_uIteratorIdx]->first();
+		if(!e)return 0;
+		return e->data();
+	}
+
+	///
+	/// Places the hash table iterator at the next entry
+	/// and returns the associated data value pointer.
+	/// This function must be preceeded by a call to firstEntry(), first()
+	/// or findRef().
+	///
+	T * next()
+	{
+		if(m_uIteratorIdx >= m_uSize)return 0;
+
+		if(m_uIteratorIdx < m_uSize)
+		{
+			KviPointerHashTableEntry<Key,T> * t = m_pDataArray[m_uIteratorIdx]->next();
+			if(t)
+			{
+				return t->data();
+			}
+		}
+
+		m_uIteratorIdx++;
+
+		while(m_uIteratorIdx < m_uSize && (!m_pDataArray[m_uIteratorIdx]))
+		{
+			m_uIteratorIdx++;
+		}
+
+		if(m_uIteratorIdx == m_uSize)return 0;
+
+		KviPointerHashTableEntry<Key,T> * e = m_pDataArray[m_uIteratorIdx]->first();
+		if(!e)return 0;
+		return e->data();
+	}
+
+	///
+	/// Removes all items in the hash table and then
+	/// makes a complete shallow copy of the data contained in t.
+	/// The removed items are deleted if autodeletion is enabled.
+	/// The hash table iterator is invalidated.
+	/// Does not change autodelete flag: make sure you not delete the items twice :)
+	///
+	void copyFrom(KviPointerHashTable<Key,T> &t)
+	{
+		clear();
+		for(KviPointerHashTableEntry<Key,T> * e = t.firstEntry();e;e = t.nextEntry())
+			insert(e->key(),e->data());
+	}
+
+	///
+	/// Inserts a complete shallow copy of the data contained in t.
+	/// The hash table iterator is invalidated.
+	///
+	void insert(KviPointerHashTable<Key,T> &t)
+	{
+		for(KviPointerHashTableEntry<Key,T> * e = t.firstEntry();e;e = t.nextEntry())
+			insert(e->key(),e->data());
+	}
+
+	///
+	/// Enables or disabled the autodeletion feature.
+	/// Items are deleted upon removal when the feature is enabled.
+	///
+	void setAutoDelete(bool bAutoDelete)
+	{
+		m_bAutoDelete = bAutoDelete;
+	}
+
+	///
+	/// Creates an empty hash table.
+	/// Automatic deletion is enabled.
+	///
+	/// \param uSize The number of hash buckets: does NOT necesairly need to be prime
+	/// \param bCaseSensitive Are the key comparisons case sensitive ?
+	/// \param Do we need to mantain deep copies of keys ?
+	///
+	KviPointerHashTable(unsigned int uSize = 32,bool bCaseSensitive = true,bool bDeepCopyKeys = true)
+	{
+		m_uCount = 0;
+		m_bCaseSensitive = bCaseSensitive;
+		m_bAutoDelete = true;
+		m_bDeepCopyKeys = bDeepCopyKeys;
+		m_uSize = uSize > 0 ? uSize : 32;
+		m_pDataArray = new KviPointerList<KviPointerHashTableEntry<Key,T> > *[m_uSize];
+		for(unsigned int i=0;i<m_uSize;i++)m_pDataArray[i] = NULL;
+	}
+
+	///
+	/// First creates an empty hash table
+	/// and then inserts a copy of all the item pointers present in t.
+	/// The autodelete feature is automatically disabled (take care!).
+	///
+	KviPointerHashTable(KviPointerHashTable<Key,T> &t)
+	{
+		m_uCount = 0;
+		m_bAutoDelete = false;
+		m_bCaseSensitive = t.m_bCaseSensitive;
+		m_bDeepCopyKeys = t.m_bDeepCopyKeys;
+		m_uSize = t.m_uSize;
+		m_pDataArray = new KviPointerList<KviPointerHashTableEntry<Key,T> > *[m_uSize];
+		for(unsigned int i=0;i<m_uSize;i++)m_pDataArray[i] = NULL;
+		copyFrom(t);
+	}
+
+	///
+	/// Destroys the hash table and all the items contained within.
+	/// Items are deleted if autodeletion is enabled.
+	///
+	~KviPointerHashTable()
+	{
+		clear();
+		delete [] m_pDataArray;
+	}
+};
+
+template<typename Key,typename T> class KviPointerHashTableIterator
+{
+protected:
+	const KviPointerHashTable<Key,T>                         * m_pHashTable;
+	unsigned int                                               m_uEntryIndex;
+	KviPointerListIterator<KviPointerHashTableEntry<Key,T> > * m_pIterator;
+public:
+	///
+	/// Creates an iterator copy.
+	/// The new iterator points exactly to the item pointed by src.
+	///
+	void operator = (const KviPointerHashTableIterator<Key,T> &src)
+	{
+		m_pHashTable = src.m_pHashTable;
+		m_uEntryIndex = src.m_uEntryIndex;
+		if(src.m_pIterator)
+			m_pIterator = new KviPointerListIterator<KviPointerHashTableEntry<Key,T> >(*(src.m_pIterator));
+		else
+			m_pIterator = NULL;
+	}
+
+	///
+	/// Moves the iterator to the first element of the hash table.
+	/// Returns true in case of success or false if the hash table is empty.
+	///
+	bool moveFirst()
+	{
+		if(m_pIterator)
+		{
+			delete m_pIterator;
+			m_pIterator = NULL;
+		}
+
+		m_uEntryIndex = 0;
+		while((m_uEntryIndex < m_pHashTable->m_uSize) && (!(m_pHashTable->m_pDataArray[m_uEntryIndex])))
+		{
+			m_uEntryIndex++;
+		}
+
+		if(m_uEntryIndex == m_pHashTable->m_uSize)
+			return false;
+
+		m_pIterator = new KviPointerListIterator<KviPointerHashTableEntry<Key,T> >(*(m_pHashTable->m_pDataArray[m_uEntryIndex]));
+		bool bRet = m_pIterator->moveFirst();
+		if(!bRet)
+		{
+			delete m_pIterator;
+			m_pIterator = NULL;
+		}
+		return bRet;
+	}
+	
+	///
+	/// Moves the iterator to the last element of the hash table.
+	/// Returns true in case of success or false if the hash table is empty.
+	///
+	bool moveLast()
+	{
+		if(m_pIterator)
+		{
+			delete m_pIterator;
+			m_pIterator = NULL;
+		}
+
+		m_uEntryIndex = m_pHashTable->m_uSize;
+		while(m_uEntryIndex > 0)
+		{
+			m_uEntryIndex--;
+			if(m_pHashTable->m_pDataArray[m_uEntryIndex])
+			{
+				m_pIterator = new KviPointerListIterator<KviPointerHashTableEntry<Key,T> >(*(m_pHashTable->m_pDataArray[m_uEntryIndex]));
+				bool bRet = m_pIterator->moveLast();
+				if(!bRet)
+				{
+					delete m_pIterator;
+					m_pIterator = NULL;
+				}
+				return bRet;
+			}
+		}
+		return false;
+	}
+
+	///
+	/// Moves the iterator to the next element of the hash table.
+	/// The iterator must be actually valid for this function to work.
+	/// Returns true in case of success or false if there is no next item.
+	///
+	bool moveNext()
+	{
+		if(!m_pIterator)
+			return false;
+		if(m_pIterator->moveNext())
+			return true;
+		if(m_pIterator)
+		{
+			delete m_pIterator;
+			m_pIterator = NULL;
+		}
+		m_uEntryIndex++;
+		while((m_uEntryIndex < m_pHashTable->m_uSize) && (!(m_pHashTable->m_pDataArray[m_uEntryIndex])))
+		{
+			m_uEntryIndex++;
+		}
+		if(m_uEntryIndex == m_pHashTable->m_uSize)
+			return false;
+		m_pIterator = new KviPointerListIterator<KviPointerHashTableEntry<Key,T> >(*(m_pHashTable->m_pDataArray[m_uEntryIndex]));
+		bool bRet = m_pIterator->moveFirst();
+		if(!bRet)
+		{
+			delete m_pIterator;
+			m_pIterator = NULL;
+		}
+		return bRet;
+	}
+	
+	///
+	/// Moves the iterator to the next element of the hash table.
+	/// The iterator must be actually valid for this function to work.
+	/// Returns true in case of success or false if there is no next item.
+	/// This is just an alias to moveNext().
+	///
+	bool operator ++()
+	{
+		return moveNext();
+	}
+	
+	///
+	/// Moves the iterator to the previous element of the hash table.
+	/// The iterator must be actually valid for this function to work.
+	/// Returns true in case of success or false if there is no previous item.
+	///
+	bool movePrev()
+	{
+		if(!m_pIterator)
+			return false;
+		if(m_pIterator->movePrev())
+			return true;
+		if(m_pIterator)
+		{
+			delete m_pIterator;
+			m_pIterator = NULL;
+		}
+		if(m_uEntryIndex >= m_pHashTable->m_uSize)
+			return false;
+		while(m_uEntryIndex > 0)
+		{
+			m_uEntryIndex--;
+			if(m_pHashTable->m_pDataArray[m_uEntryIndex])
+			{
+				m_pIterator = new KviPointerListIterator<KviPointerHashTableEntry<Key,T> >(*(m_pHashTable->m_pDataArray[m_uEntryIndex]));
+				bool bRet = m_pIterator->moveLast();
+				if(!bRet)
+				{
+					delete m_pIterator;
+					m_pIterator = NULL;
+				}
+				return bRet;
+			}
+		}
+		return false;
+	}
+
+	
+	///
+	/// Moves the iterator to the previous element of the hash table.
+	/// The iterator must be actually valid for this function to work.
+	/// Returns true in case of success or false if there is no previous item.
+	/// This is just an alias to movePrev() with a different name.
+	///
+	bool operator --()
+	{
+		return movePrev();
+	}
+
+	///
+	/// Returs the value pointed by the iterator
+	/// or a default constructed value if the iterator is not valid.
+	/// This is an alias to operator *() with just a different name.
+	///
+	T * current() const
+	{
+		return m_pIterator ? m_pIterator->current()->data() : NULL;
+	}
+
+	///
+	/// Returs the value pointed by the iterator
+	/// or a default constructed value if the iterator is not valid.
+	/// This is an alias to current() with just a different name.
+	///
+	T * operator *() const
+	{
+		return m_pIterator ? m_pIterator->current()->data() : NULL;
+	}
+	
+	///
+	/// Returs the key pointed by the iterator
+	/// or a default constructed key if the iterator is not valid.
+	///
+	const Key & currentKey() const
+	{
+		return m_pIterator ? m_pIterator->current()->key() : kvi_hash_key_default(((Key *)NULL));
+	}
+
+	///
+	/// Moves the iterator to the first element of the hash table.
+	/// Returns the first item found or NULL if the hash table is empty.
+	///
+	T * toFirst()
+	{
+		if(!moveFirst())
+			return NULL;
+		return current();
+	}
+public:
+	///
+	/// Creates an iterator pointing to the first item in the hash table, if any.
+	///
+	KviPointerHashTableIterator(const KviPointerHashTable<Key,T> &hTable)
+	{
+		m_pHashTable = &hTable;
+		m_uEntryIndex = 0;
+		m_pIterator = NULL;
+		moveFirst();
+	}
+	
+	///
+	/// Destroys the iterator
+	///
+	~KviPointerHashTableIterator()
+	{
+		if(m_pIterator)
+			delete m_pIterator;
+	}
+};
+
+
+
+
+#endif //_KVI_POINTERHASHTABLE_H_
diff --git a/src/kvilib/core/kvi_pointerlist.h b/src/kvilib/core/kvi_pointerlist.h
new file mode 100644
index 00000000..381780c8
--- /dev/null
+++ b/src/kvilib/core/kvi_pointerlist.h
@@ -0,0 +1,1069 @@
+#ifndef _KVI_POINTERLIST_H_
+#define _KVI_POINTERLIST_H_
+//=================================================================================================
+//
+//   File : kvi_pointerlist.h
+//   Creation date : Tue Jul 6 1999 14:52:20 by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 1999-2007 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=================================================================================================
+//=============================================================================
+//
+//   C++ Template based double linked pointer list class
+//   Original ss_list.h Created on 10 Dec 2001
+//   Copyright (C) 2001-2007 Szymon Stefanek (pragma at kvirc dot net)
+//   Added to KVIrc on 02 Jan 2008.
+//
+//=============================================================================
+
+// Qt changes the collection classes too much and too frequently.
+// I think we need to be independent of that to the maximum degree possible.
+// That's why we have our own fast pointer list class.
+// This does not depend on Qt AT ALL and has an interface similar
+// to the Qt<=3.x series. The pointer lists with the autodelete
+// feature was great and I don't completly understand why they have
+// been removed from Qt4 in favor of the value based non-autodeleting
+// lists... anyway: here we go :)
+
+#include "kvi_settings.h"
+
+template<typename T> class KviPointerList;
+template<typename T> class KviPointerListIterator;
+
+#ifndef NULL
+	#define NULL 0
+#endif
+
+///
+/// \internal
+///
+class KviPointerListNode
+{
+public:
+	KviPointerListNode * m_pPrev;
+	void               * m_pData;
+	KviPointerListNode * m_pNext;
+};
+
+///
+/// \class KviPointerListIterator
+/// \brief A fast KviPointerList iterator.
+///
+/// This class allows traversing the list sequentially.
+/// Multilpe iterators can traverse the list at the same time.
+/// 
+/// Iteration example 1:
+///
+/// \verbatim
+/// KviPointerListIterator<T> it(list);
+/// for(bool b = it.moveFirst();b;b = it.moveNext())
+/// {
+///     T * pData = it.data();
+///     doSomethingWithData(pData);
+/// }
+/// \endverbatim
+///
+/// Iteration example 2:
+///
+/// \verbatim
+/// KviPointerListIterator<T> it(list);
+/// if(it.moveFirst())
+/// {
+///     do {
+///         T * pData = it.data();
+///         doSomethingWithData(pData);
+///     } while(it.moveNext());
+/// }
+/// \endverbatim
+///
+/// Iteration example 3:
+///
+/// \verbatim
+/// KviPointerListIterator<T> it(list.iteratorAt(10));
+/// if(it.isValid())
+/// {
+///    do {
+///         T * pData = it.data();
+///         doSomethingWithData(pData);
+///    while(it.movePrev());
+/// }
+/// \endverbatim
+///
+/// Please note that you must NOT remove any item from
+/// the list when using the iterators. An iterator pointing
+/// to a removed item will crash your application if you use it.
+/// The following code will NOT work (and crash):
+///
+/// \verbatim
+/// KviPointerList<T> l;
+/// l.append(new KviStr("x"));
+/// l.append(new KviStr("y"));
+/// KviPointerListIterator<T> it(l);
+/// it.moveFirst();
+/// l.removeFirst();
+/// KviStr * tmp = it.data(); <-- this will crash
+/// \endverbatim
+///
+/// In the rare cases in that you need to remove items
+/// while traversing the list you should put them
+/// in a temporary list and remove them after the iteration.
+///
+/// I've choosen this way because usually you don't modify
+/// the list while traversing it and a fix for this
+/// would add a constant overhead to several list operation.
+/// You just must take care of it yourself.
+///
+/// \warning This class is not thread safe by itself.
+///
+template<typename T> class KviPointerListIterator
+{
+protected:
+	KviPointerList<T>                 * m_pList;
+	KviPointerListNode                * m_pNode;
+public:
+	///
+	/// Creates an iterator copy.
+	/// The new iterator points exactly to the item pointed by src.
+	///
+	KviPointerListIterator(const KviPointerListIterator<T> &src)
+	{
+		m_pList = src.m_pList;
+		m_pNode = src.m_pNode;
+	}
+
+	///
+	/// Creates an iterator for the list l.
+	/// The iterator points to the first list item, if any.
+	///
+	KviPointerListIterator(KviPointerList<T> &l)
+	{
+		m_pList = (KviPointerList<T> *)&l;
+		m_pNode = m_pList->m_pHead;
+	}
+
+	///
+	/// Creates an iterator for the list l.
+	/// The iterator points to the specified list node.
+	///
+	KviPointerListIterator(KviPointerList<T> &l,KviPointerListNode * pNode)
+	{
+		m_pList = (KviPointerList<T> *)&l;
+		m_pNode = pNode;
+	}
+
+	///
+	/// Creates an iterator copy.
+	/// The new iterator points exactly to the item pointed by src.
+	///
+	void operator = (const KviPointerListIterator<T> &src)
+	{
+		m_pList = src.m_pList;
+		m_pNode = src.m_pNode;
+	}
+public:
+	///
+	/// Moves the iterator to the first element of the list.
+	/// Returns true in case of success or false if the list is empty.
+	///
+	bool moveFirst()
+	{
+		m_pNode = m_pList->m_pHead;
+		return m_pNode != NULL;
+	}
+	
+	///
+	/// Moves the iterator to the last element of the list.
+	/// Returns true in case of success or false if the list is empty.
+	///
+	bool moveLast()
+	{
+		m_pNode = m_pList->m_pTail;
+		return m_pNode != NULL;
+	}
+
+	///
+	/// Moves the iterator to the next element of the list.
+	/// The iterator must be actually valid for this function to work.
+	/// Returns true in case of success or false if there is no next item.
+	///
+	bool moveNext()
+	{
+		if(!m_pNode)return false;
+		m_pNode = m_pNode->m_pNext;
+		return m_pNode != NULL;
+	}
+
+	///
+	/// Moves the iterator to the next element of the list.
+	/// The iterator must be actually valid for this operator to work.
+	/// Returns true in case of success or false if there is no next item.
+	/// This is just a convenient alias to moveNext().
+	///
+	bool operator ++()
+	{
+		if(!m_pNode)return false;
+		m_pNode = m_pNode->m_pNext;
+		return m_pNode != NULL;
+	}
+
+	///
+	/// Moves the iterator to the previous element of the list.
+	/// The iterator must be actually valid for this function to work.
+	/// Returns true in case of success or false if there is no previous item.
+	///
+	bool movePrev()
+	{
+		if(!m_pNode)return false;
+		m_pNode = m_pNode->m_pPrev;
+		return m_pNode != NULL;
+	}
+
+	///
+	/// Moves the iterator to the previous element of the list.
+	/// The iterator must be actually valid for this operator to work.
+	/// Returns true in case of success or false if there is no previous item.
+	/// This is just a convenient alias to movePrev().
+	///
+	bool operator --()
+	{
+		if(!m_pNode)return false;
+		m_pNode = m_pNode->m_pPrev;
+		return m_pNode != NULL;
+	}
+
+	///
+	/// Returs the value pointed by the iterator
+	/// or NULL if the iterator is not valid.
+	///
+	T * current()
+	{
+		return m_pNode ? (T *)(m_pNode->m_pData) : NULL;
+	}
+
+	///
+	/// Returs the value pointed by the iterator
+	/// or NULL if the iterator is not valid.
+	/// This is just an alias to current().
+	///
+	T * operator *()
+	{
+		return m_pNode ? (T *)(m_pNode->m_pData) : NULL;
+	}
+
+	///
+	/// Returns true if this iterator points to a valid
+	/// element of the list and false otherwise.
+	///
+	bool isValid()
+	{
+		return m_pNode != NULL;
+	}
+};
+
+///
+/// \class KviPointerList
+/// \brief A template double linked list of pointers.
+///
+/// The main advantage of this type of list is speed.
+/// Insertion of pointers is very fast when compared
+/// to the typical "copy constructor" call used
+/// in the "plain type" template list implementations.
+///
+/// Iterating over pointers is also very fast and this
+/// class contains an internal iterator that allows to
+/// write loops in a compact and clean way.
+/// See the first(), next(), current() and findRef()
+/// functions for the description of this feature.
+///
+/// There is also a non-const external iterator
+/// that you can use to traverse the list concurrently.
+/// There is no const iterator (and no const access methods)
+/// since the list provides the autoDelete() method
+/// which vould implicitly violate constness.
+/// If you have to deal with const objects then
+/// you need to use a QList instead.
+///
+/// Your objects also do not need to support copy constructors
+/// or >= operators. This class will work fine without them
+/// as opposed to a plain QList.
+///
+/// This class also supports automatic deletion of the inseted items.
+/// See the setAutoDelete() and autoDelete() members for the
+/// description of the feature.
+///
+/// Typcal usage:
+///
+/// \verbatim
+///   KviPointerList<MyClass> list();
+///   list.append(new MyClass());
+///   list.append(new MyClass());
+///   ...
+///   for(MyClass * c = list.first();c;c = list.next())doSomethingWith(c);
+///   delete list; // autodelete is set to true in the constructor
+/// \endverbatim
+///
+/// \warning This class is absolutely NOT thread safe. You must
+/// protect concurrent access from multiple threads by
+/// using an external synchronization tool (such as KviMutex).
+///
+template<typename T> class KviPointerList
+{
+	friend class KviPointerListIterator<T>;
+protected:
+	bool   m_bAutoDelete;   //< do we automatically delete items when they are removed ?
+
+	KviPointerListNode * m_pHead;         //< our list head pointer (NULL if there are no items in the list)
+	KviPointerListNode * m_pTail;         //< our list tail
+	KviPointerListNode * m_pAux;          //< our iteration pointer
+
+	unsigned int m_uCount;  //< the count of items in the list
+protected:
+	///
+	/// \internal
+	///
+	/// inserts the item d before the item ref or at the beginning
+	/// if ref is not found in the list
+	/// also sets the current iteration pointer to the newly inserted item
+	///
+	void insertBeforeSafe(KviPointerListNode * ref,const T * d)
+	{
+		m_pAux = ref;
+		KviPointerListNode * n = new KviPointerListNode;
+		n->m_pPrev = m_pAux->m_pPrev;
+		n->m_pNext = m_pAux;
+		if(m_pAux->m_pPrev)
+		{
+			m_pAux->m_pPrev->m_pNext = n;
+		} else {
+			m_pHead = n;
+		}
+		m_pAux->m_pPrev = n;
+		n->m_pData = (void *)d;
+		m_uCount++;
+	}
+
+	///
+	/// \internal
+	///
+	/// Grabs the first element from the list src
+	/// and puts it as the first element of this list.
+	///
+	void grabFirstAndPrepend(KviPointerList<T> * src)
+	{
+		KviPointerListNode * pNewHead = src->m_pHead;
+		if(!pNewHead)
+			return;
+
+		if(pNewHead->m_pNext)
+		{
+			src->m_pHead = pNewHead->m_pNext;
+			src->m_pHead->m_pPrev = NULL;
+		} else {
+			src->m_pHead = NULL;
+			src->m_pTail = NULL;
+		}
+
+		if(m_pHead)
+		{
+			m_pHead->m_pPrev = pNewHead;
+			pNewHead->m_pNext = m_pHead;
+			m_pHead = pNewHead;
+		} else {
+			m_pHead = pNewHead;
+			m_pTail = pNewHead;
+			m_pHead->m_pNext = NULL;
+		}
+		m_uCount++;
+		src->m_uCount--;
+	}
+
+	///
+	/// \internal
+	///
+	/// Removes the current iteration item assuming that it is valid.
+	///
+	void removeCurrentSafe()
+	{
+		if(m_pAux->m_pPrev)
+			m_pAux->m_pPrev->m_pNext = m_pAux->m_pNext;
+		else
+			m_pHead = m_pAux->m_pNext;
+		if(m_pAux->m_pNext)
+			m_pAux->m_pNext->m_pPrev = m_pAux->m_pPrev;
+		else
+			m_pTail = m_pAux->m_pPrev;
+		const T * pAuxData = (const T *)(m_pAux->m_pData);
+		delete m_pAux;
+		m_pAux = NULL;
+		m_uCount--;
+		if(m_bAutoDelete)
+			delete pAuxData; // this can cause recursion, so do it at the end
+	}
+
+public:
+	///
+	/// Inserts the list src inside this list
+	/// by respecting the sort order.
+	/// The src list elements are removed.
+	///
+	void merge(KviPointerList<T> * src)
+	{
+		m_pAux = m_pHead;
+		KviPointerListNode * n = src->m_pHead;
+		m_uCount += src->m_uCount;
+		while(m_pAux && n)
+		{
+			if(kvi_compare((const T *)(m_pAux->m_pData),(const T *)(n->m_pData)) > 0)
+			{
+				// our element is greater, n->m_pData goes first
+				KviPointerListNode * pNext = n->m_pNext;
+				n->m_pPrev = m_pAux->m_pPrev; // his prev becomes 
+				n->m_pNext = m_pAux;
+				if(m_pAux->m_pPrev)
+					m_pAux->m_pPrev->m_pNext = n;
+				else
+					m_pHead = n;
+				m_pAux->m_pPrev = n;
+				n = pNext;
+			} else {
+				// that element is greater
+				m_pAux = m_pAux->m_pNext;
+			}
+		}
+		if(n)
+		{
+			// last items to append
+			if(m_pTail)
+			{
+				m_pTail->m_pNext = n;
+				n->m_pPrev = m_pTail;
+			} else {
+				m_pHead = n;
+				m_pTail = n;
+				n->m_pPrev = NULL;
+			}
+			m_pTail = src->m_pTail;
+		}
+
+		src->m_pHead = NULL;
+		src->m_pTail = NULL;
+		src->m_uCount = 0;
+	}
+	
+	void swap(KviPointerList<T> * src)
+	{
+		KviPointerListNode * n = m_pHead;
+		m_pHead = src->m_pHead;
+		src->m_pHead = n;
+		n = m_pTail;
+		m_pTail = src->m_pTail;
+		src->m_pTail = n;
+		unsigned int uCount = m_uCount;
+		m_uCount = src->m_uCount;
+		src->m_uCount = uCount;
+	}
+
+
+	///
+	/// Sorts this list in ascending order.
+	/// There must be an int kvi_compare(const T *p1,const T *p2) function
+	/// which returns a value less than, equal to
+	/// or greater than zero when the item p1 is considered lower than,
+	/// equal to or greater than p2.
+	///
+	void sort()
+	{
+		if(m_uCount < 2)return;
+
+		KviPointerList<T> carry;
+		KviPointerList<T> tmp[64];
+		KviPointerList * fill = &tmp[0];
+		KviPointerList * counter;
+
+		do {
+			carry.grabFirstAndPrepend(this);
+			
+			for(counter = &tmp[0];counter != fill && !counter->isEmpty();++counter)
+			{
+				counter->merge(&carry);
+				carry.swap(counter);
+			}
+			carry.swap(counter);
+			if(counter == fill)
+				++fill;
+		} while(m_uCount > 0);
+
+		for(counter = &tmp[1];counter != fill;++counter)
+			counter->merge(counter-1);
+		swap(fill-1);
+	}
+
+	///
+	/// Inserts the item respecting the sorting order inside the list.
+	/// The list itself must be already sorted for this to work correctly.
+	/// There must be a int kvi_compare(const T *p1,const T * p2)
+	/// that returns a value less than, equal to
+	/// or greater than zero when the item p1 is considered lower than,
+	/// equal to or greater than p2. 
+	///
+	void inSort(T * t)
+	{
+		KviPointerListNode * x = m_pHead;
+		while(x && (kvi_compare(((T *)x->m_pData),t) > 0))x = x->m_pNext;
+		if(!x)append(t);
+		else insertBeforeSafe(x,t);
+	}
+
+	///
+	/// Returns true if the list is empty
+	///
+	bool isEmpty() const
+	{
+		return (m_pHead == NULL);
+	}
+
+	///
+	/// Returns the count of the items in the list
+	///
+	unsigned int count() const
+	{
+		return m_uCount;
+	}
+
+	///
+	/// Sets the iteration pointer to the first item in the list
+	/// and returns that item (or 0 if the list is empty)
+	///
+	T * first()
+	{
+		if(!m_pHead)
+		{
+			m_pAux = NULL;
+			return NULL;
+		}
+		m_pAux = m_pHead;
+		return (T *)(m_pAux->m_pData);
+	}
+
+	///
+	/// Removes the first element from the list
+	/// and returns it to the caller. This function
+	/// obviously never deletes the item (regadless of autoDeletion()).
+	///
+	T * takeFirst()
+	{
+		if(!m_pHead)return NULL;
+		T * pData = (T *)m_pHead->m_pData;
+		if(m_pHead->m_pNext)
+		{
+			m_pHead = m_pHead->m_pNext;
+			delete m_pHead->m_pPrev;
+			m_pHead->m_pPrev = NULL;
+		} else {
+			delete m_pHead;
+			m_pHead = NULL;
+			m_pTail = NULL;
+		}
+		m_uCount--;
+		return pData;
+	}
+
+	///
+	/// Returns an iterator pointing to the first item of the list.
+	///
+	KviPointerListIterator<T> iteratorAtFirst()
+	{
+		return KviPointerListIterator<T>(*this,m_pHead);
+	}
+
+	///
+	/// Sets the iteration pointer to the last item in the list
+	/// and returns that item (or 0 if the list is empty)
+	///
+	T * last()
+	{
+		if(!m_pTail)
+		{
+			m_pAux = NULL;
+			return NULL;
+		}
+		m_pAux = m_pTail;
+		return (T *)(m_pAux->m_pData);
+	}
+
+	///
+	/// Returns an iterator pointing to the first item of the list.
+	///
+	KviPointerListIterator<T> iteratorAtLast()
+	{
+		return KviPointerListIterator<T>(*this,m_pTail);
+	}
+
+	///
+	/// Returns the current iteration item
+	/// A call to this function MUST be preceded by a call to
+	/// first(),last(),at() or findRef()
+	///
+	T * current()
+	{
+		return (T *)(m_pAux->m_pData);
+	}
+
+	///
+	/// Returns the current iteration item
+	/// A call to this function should be preceded by a call to
+	/// first(),last(),at() or findRef().
+	/// This function will return a NULL pointer if the current
+	/// item has been invalidated due to a remove operation.
+	///
+	T * safeCurrent()
+	{
+		return m_pAux ? (T *)(m_pAux->m_pData) : NULL;
+	}
+
+
+	///
+	/// Returns an iterator pointing to the current item in the list.
+	/// A call to this function MUST be preceded by a call to
+	/// first(),last(),at() or findRef()
+	///
+	KviPointerListIterator<T> iteratorAtCurrent()
+	{
+		return KviPointerListIterator<T>(*this,m_pAux);
+	}
+
+	///
+	/// Sets the iteration pointer to the next item in the list
+	/// and returns that item (or 0 if the end of the list has been reached)
+	/// A call to this function MUST be preceded by a _succesfull_ call to
+	/// first(),last(),at() or findRef().
+	///
+	T * next()
+	{
+		if(!m_pAux)return NULL;
+		m_pAux = m_pAux->m_pNext;
+		if(m_pAux)return (T *)(m_pAux->m_pData);
+		return NULL;
+	}
+
+	///
+	/// Sets the iteration pointer to the previous item in the list
+	/// and returns that item (or 0 if the beginning of the list has been reached)
+	/// A call to this function MUST be preceded by a _succesfull_ call to
+	/// first(),last(),at() or findRef()
+	///
+	T * prev()
+	{
+		if(!m_pAux)return NULL;
+		m_pAux = m_pAux->m_pPrev;
+		if(m_pAux)return (T *)(m_pAux->m_pData);
+		return NULL;
+	}
+
+	///
+	/// Sets the iteration pointer to the nTh item in the list
+	/// and returns that item (or 0 if the index is out of range)
+	///
+	T * at(int idx)
+	{
+		T * t = first();
+		int cnt = 0;
+		while(t)
+		{
+			if(idx == cnt)return t;
+			t = next();
+			cnt++;
+		}
+		return 0;
+	}
+
+	///
+	/// Returns an iterator pointing to the item at the specified index.
+	///
+	KviPointerListIterator<T> iteratorAt(int idx)
+	{
+		KviPointerListNode * n = m_pHead;
+		int cnt = 0;
+		while(n)
+		{
+			if(idx == cnt)
+				return KviPointerListIterator<T>(*this,n);
+			n = n->m_pNext;
+			cnt++;
+		}
+		return KviPointerListIterator<T>(*this,NULL);
+	}
+
+	///
+	/// Sets the iteration pointer to the item with pointer d
+	/// and returns its position (zero based index) in the list or -1 if the
+	/// item cannot be found
+	///
+	int findRef(const T * d)
+	{
+		int ret = 0;
+		for(T * t = first();t;t = next())
+		{
+			if(t == d)return ret;
+			ret++;
+		}
+		return -1;
+	}
+
+	///
+	/// Returns an iterator pointing to the item with pointer d.
+	///
+	KviPointerListIterator<T> iteratorAtRef(const T * d)
+	{
+		KviPointerListNode * n = m_pHead;
+		while(n)
+		{
+			if(n->m_pData == d)
+				return KviPointerListIterator<T>(*this,n);
+			n = n->m_pNext;
+		}
+		return KviPointerListIterator<T>(*this,NULL);
+	}
+
+	///
+	/// Appends an item at the end of the list
+	///
+	void append(const T * d)
+	{
+		if(!m_pHead)
+		{
+			m_pHead = new KviPointerListNode;
+			m_pHead->m_pPrev = NULL;
+			m_pHead->m_pNext = NULL;
+			m_pHead->m_pData = (void *)d;
+			m_pTail = m_pHead;
+		} else {
+			m_pTail->m_pNext = new KviPointerListNode;
+			m_pTail->m_pNext->m_pPrev = m_pTail;
+			m_pTail->m_pNext->m_pNext = NULL;
+			m_pTail->m_pNext->m_pData = (void *)d;
+			m_pTail = m_pTail->m_pNext;
+		}
+		m_uCount++;
+	}
+
+	///
+	/// Appends all the items from the list l to this list
+	///
+	void append(KviPointerList<T> * l)
+	{
+		for(T * t = l->first();t;t = l->next())append(t);
+	}
+
+	///
+	/// Prepends (inserts in head position) all the items from
+	/// the list l to this list
+	///
+	void prepend(KviPointerList<T> * l)
+	{
+		for(T * t = l->last();t;t = l->prev())prepend(t);
+	}
+
+	///
+	/// Inserts the item d in the head position
+	///
+	void prepend(const T * d)
+	{
+		if(!m_pHead)
+		{
+			m_pHead = new KviPointerListNode;
+			m_pHead->m_pPrev = NULL;
+			m_pHead->m_pNext = NULL;
+			m_pHead->m_pData = (void *)d;
+			m_pTail = m_pHead;
+		} else {
+			m_pHead->m_pPrev = new KviPointerListNode;
+			m_pHead->m_pPrev->m_pNext = m_pHead;
+			m_pHead->m_pPrev->m_pPrev = NULL;
+			m_pHead->m_pPrev->m_pData = (void *)d;
+			m_pHead =  m_pHead->m_pPrev;
+			m_uCount++;
+		}
+	}
+
+	///
+	/// Inserts the item d at the zero-based position
+	/// specified by iIndex. If the specified position
+	/// is out of the list then the item is appended.
+	/// Note that this function costs O(n).
+	/// It's really better to use insertAfter() or
+	/// insertBefore(), if possible.
+	///
+	void insert(int iIndex,const T * d)
+	{
+		m_pAux = m_pHead;
+		while(m_pAux && iIndex > 0)
+		{
+			iIndex--;
+			m_pAux = m_pAux->m_pNext;
+		}
+		if(m_pAux)
+			insertBeforeSafe(m_pAux,d);
+		else
+			append(d);
+	}
+
+	///
+	/// Removes the firstitem (if any)
+	/// the item is deleted if autoDelete() is set to true
+	///
+	bool removeFirst()
+	{
+		if(!m_pHead)return false;
+		const T * pAuxData;
+		if(m_pHead->m_pNext)
+		{
+			m_pHead = m_pHead->m_pNext;
+			pAuxData = (const T *)(m_pHead->m_pPrev->m_pData);
+			delete m_pHead->m_pPrev;
+			m_pHead->m_pPrev = NULL;
+		} else {
+			pAuxData = (const T *)(m_pHead->m_pData);
+			delete m_pHead;
+			m_pHead = NULL;
+			m_pTail = NULL;
+		}
+		m_pAux = NULL;
+		m_uCount--;
+		if(m_bAutoDelete)
+			delete pAuxData;
+		return true;
+	}
+
+	///
+	/// Removes the firstitem (if any)
+	/// the item is deleted if autoDelete() is set to true
+	///
+	bool removeLast()
+	{
+		if(!m_pTail)return false;
+		const T * pAuxData;
+		if(m_pTail->m_pPrev)
+		{
+			m_pTail = m_pTail->m_pPrev;
+			pAuxData = (const T *)(m_pTail->m_pNext->m_pData);
+			delete m_pTail->m_pNext;
+			m_pTail->m_pNext = NULL;
+		} else {
+			pAuxData = (const T *)(m_pTail->m_pData);
+			delete m_pTail;
+			m_pHead = NULL;
+			m_pTail = NULL;
+		}
+		m_pAux = NULL;
+		m_uCount--;
+		if(m_bAutoDelete)
+			delete pAuxData;
+		return true;
+	}
+
+	///
+	/// Removes the item at zero-based position iIndex.
+	/// Does nothing and returns false if iIndex is out of the list.
+	/// Please note that this function costs O(n).
+	///
+	bool remove(int iIndex)
+	{
+		m_pAux = m_pHead;
+		while(m_pAux && iIndex > 0)
+		{
+			iIndex--;
+			m_pAux = m_pAux->m_pNext;
+		}
+		if(!m_pAux)
+			return false;
+		removeCurrentSafe();
+		return true;
+	}
+
+	///
+	/// Sets the autodelete flag
+	/// When this flag is on (default) , all the items
+	/// are deleted when removed from the list (or when the list is destroyed
+	/// or cleared explicitly)
+	///
+	void setAutoDelete(bool bAutoDelete)
+	{
+		m_bAutoDelete = bAutoDelete;
+	}
+
+	///
+	/// Returns the autodelete flag.
+	///
+	bool autoDelete()
+	{
+		return m_bAutoDelete;
+	};
+
+	///
+	/// Removes all the items from the list 
+	/// (the items are deleted if the autoDelete() flag is set to true)
+	///
+	void clear()
+	{
+		while(m_pHead)removeFirst();
+	}
+
+	///
+	/// Removes the current iteration item.
+	/// Returns true if the current iteration item was valid (and was removed)
+	/// and false otherwise.
+	///
+	bool removeCurrent()
+	{
+		if(!m_pAux)
+			return false;
+		removeCurrentSafe();
+		return true;
+	}
+
+	///
+	/// Removes the item pointed by d (if found in the list)
+	/// the item is deleted if the autoDelete() flag is set to true)
+	/// Returns true if the item was in the list and false otherwise.
+	///
+	bool removeRef(const T * d)
+	{
+		if(findRef(d) == -1)return false;
+		removeCurrentSafe();
+		return true;
+	}
+
+	///
+	/// inserts the item d after the item ref or at the end
+	/// if ref is not found in the list
+	/// also sets the current iteration pointer to the newly inserted item
+	///
+	void insertAfter(const T * ref,const T * d)
+	{
+		if(findRef(ref) == -1)
+		{
+			append(d);
+			return;
+		}
+		KviPointerListNode * n = new KviPointerListNode;
+		n->m_pPrev = m_pAux;
+		n->m_pNext = m_pAux->m_pNext;
+		if(m_pAux->m_pNext)
+			m_pAux->m_pNext->m_pPrev = n;
+		else
+			m_pTail = n;
+		m_pAux->m_pNext = n;
+		n->m_pData = (void *)d;
+		m_uCount++;
+	}
+
+	///
+	/// inserts the item d before the item ref or at the beginning
+	/// if ref is not found in the list
+	/// also sets the current iteration pointer to the newly inserted item
+	///
+	void insertBefore(const T * ref,const T * d)
+	{
+		if(findRef(ref) == -1)
+		{
+			prepend(d);
+			return;
+		}
+		KviPointerListNode * n = new KviPointerListNode;
+		n->m_pPrev = m_pAux->m_pPrev;
+		n->m_pNext = m_pAux;
+		if(m_pAux->m_pPrev)
+			m_pAux->m_pPrev->m_pNext = n;
+		else
+			m_pHead = n;
+		m_pAux->m_pPrev = n;
+		n->m_pData = (void *)d;
+		m_uCount++;
+	}
+
+	///
+	/// Inverts the elements in the list.
+	///
+	void invert()
+	{
+		if(!m_pHead)return;
+		KviPointerListNode * oldHead = m_pHead;
+		KviPointerListNode * oldTail = m_pTail;
+		KviPointerListNode * n = m_pHead;
+		while(n)
+		{
+			KviPointerListNode * next = n->m_pNext;
+			n->m_pNext = n->m_pPrev;
+			n->m_pPrev = next;
+			n = next;
+		}
+		m_pTail = oldHead;
+		m_pHead = oldTail;
+	}
+
+	///
+	/// clears the list and inserts all the items from the list l
+	///
+	void copyFrom(KviPointerList<T> * l)
+	{
+		clear();
+		for(T * t = l->first();t;t = l->next())append(t);
+	}
+
+	///
+	/// equivalent to copyFrom(l)
+	///
+	KviPointerList<T> & operator = (KviPointerList<T> &l)
+	{
+		copyFrom(&l);
+		return *this;
+	}
+
+	///
+	/// creates a template list
+	///
+	KviPointerList<T>(bool bAutoDelete = true)
+	{
+		m_bAutoDelete = bAutoDelete;
+		m_pHead = NULL;
+		m_pTail = NULL;
+		m_uCount = 0;
+		m_pAux	= NULL;
+	};
+
+	///
+	/// destroys the list
+	/// if autoDelete() is set to true, all the items are deleted
+	///
+	virtual ~KviPointerList<T>()
+	{
+		clear();
+	};
+};
+
+#define KviPointerListBase KviPointerList
+
+// BROKEN MSVC LINKER
+#ifdef COMPILE_ON_WINDOWS
+	#include "kvi_string.h"
+	template class KVILIB_API KviPointerList<KviStr>;
+#endif
+
+#endif //_KVI_POINTERLIST_H_
diff --git a/src/kvilib/core/kvi_qcstring.h b/src/kvilib/core/kvi_qcstring.h
new file mode 100644
index 00000000..0693e205
--- /dev/null
+++ b/src/kvilib/core/kvi_qcstring.h
@@ -0,0 +1,39 @@
+#ifndef _KVI_QCSTRING_H_
+#define _KVI_QCSTRING_H_
+
+//=============================================================================
+//
+//   File : kvi_qcstring.h
+//   Creation date : Thu Jan 18 2007 00:34:33 CEST by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 2007 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+#include "kvi_settings.h"
+
+#ifdef COMPILE_USE_QT4
+	#include <q3cstring.h> // includes <qbytearray.h>
+	#define KviQCString QByteArray
+#else
+	// this is dead in Qt 4.x
+	#include <qcstring.h>
+	#define KviQCString QCString
+#endif
+
+#endif //!_KVI_QCSTRING_H_
diff --git a/src/kvilib/core/kvi_qstring.cpp b/src/kvilib/core/kvi_qstring.cpp
new file mode 100644
index 00000000..eba255aa
--- /dev/null
+++ b/src/kvilib/core/kvi_qstring.cpp
@@ -0,0 +1,1125 @@
+//=============================================================================
+//
+//   File : kvi_qstring.cpp
+//   Creation date : Mon Aug 04 2003 13:36:33 CEST by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 2003-2006 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+//=============================================================================
+//
+// Helper functions for the QString class
+//
+//=============================================================================
+
+#define __KVILIB__
+
+
+#include "kvi_qstring.h"
+#include "kvi_string.h"
+#include "kvi_malloc.h"
+#include "kvi_locale.h"
+
+#include <ctype.h> // for tolower()
+#include <stdio.h> // for sprintf()
+#include <qregexp.h> 
+
+// kvi_string.cpp
+extern unsigned char iso88591_toLower_map[256];
+extern unsigned char iso88591_toUpper_map[256];
+
+#define MY_MIN(a,b) (((a) < (b)) ? (a) : (b))
+
+namespace KviQString
+{
+	// The global empty (and null) string
+	const QString empty;
+
+	bool equalCSN(const QString &sz1,const QString &sz2,unsigned int len)
+	{
+		if(len == 0)return true; // assume equal
+		const QChar * c1 = sz1.unicode();
+		const QChar * c2 = sz2.unicode();
+		unsigned int lmin = MY_MIN(sz1.length(),sz2.length());
+		if(lmin < len)return false;
+		const QChar * c1e = c1 + len;
+		
+		if(!c1 || !c2)return (c1 == c2);
+		
+		while(c1 < c1e)
+		{
+			if(c1->unicode() != c2->unicode())return false;
+			c1++;
+			c2++;
+		}
+		return (c1 == c1e);
+	}
+
+	bool equalCIN(const QString &sz1,const QString &sz2,unsigned int len)
+	{
+		if(len == 0)return true; // assume equal
+		const QChar * c1 = sz1.unicode();
+		const QChar * c2 = sz2.unicode();
+		unsigned int lmin = MY_MIN(sz1.length(),sz2.length());
+		if(lmin < len)return false;
+		const QChar * c1e = c1 + len;
+
+		if(!c1 || !c2)return (c1 == c2);
+
+		while(c1 < c1e)
+		{
+#ifdef COMPILE_USE_QT4
+			if(c1->toLower().unicode() != c2->toLower().unicode())return false;
+#else
+			if(c1->lower().unicode() != c2->lower().unicode())return false;
+#endif
+			c1++;
+			c2++;
+		}
+		return (c1 == c1e);
+	}
+
+	bool equalCSN(const QString &sz1,const char * sz2,unsigned int len)
+	{
+		if(len == 0)return true; // assume equal
+		const QChar * c1 = sz1.unicode();
+		if(sz1.length() < len)return false;
+		const QChar * c1e = c1 + len;
+
+		if(!sz2)return !c1;
+		if(!c1)return !sz2;
+
+		while((c1 < c1e) && (*sz2))
+		{
+			if(c1->unicode() != *sz2)return false;
+			c1++;
+			sz2++;
+		}
+		return (c1 == c1e);
+	}
+
+	bool equalCIN(const QString &sz1,const char * sz2,unsigned int len)
+	{
+		if(len == 0)return true; // assume equal
+		const QChar * c1 = sz1.unicode();
+		if(sz1.length() < len)return false;
+		const QChar * c1e = c1 + len;
+
+		if(!sz2)return !c1;
+		if(!c1)return !(*sz2);
+
+		while((c1 < c1e) && (*sz2))
+		{
+#ifdef COMPILE_USE_QT4
+			if(c1->toLower().unicode() != tolower(*sz2))return false;
+#else
+			if(c1->lower().unicode() != tolower(*sz2))return false;
+#endif
+			c1++;
+			sz2++;
+		}
+		return (c1 == c1e);
+	}
+
+	// sz2 is assumed to be null terminated, sz1 is not!
+	bool equalCIN(const QString &sz1,const QChar *sz2,unsigned int len)
+	{
+		if(len == 0)return true; // assume equal
+		const QChar * c1 = sz1.unicode();
+		if(sz1.length() < len)return false;
+		const QChar * c1e = c1 + len;
+
+		if(!sz2)return !c1;
+		if(!c1)return !(sz2->unicode());
+
+		while((c1 < c1e) && (sz2->unicode()))
+		{
+#ifdef COMPILE_USE_QT4
+			if(c1->toLower().unicode() != sz2->toLower().unicode())return false;
+#else
+			if(c1->lower().unicode() != sz2->lower().unicode())return false;
+#endif
+			c1++;
+			sz2++;
+		}
+		return (c1 == c1e);
+	}
+
+	QString makeSizeReadable(size_t bytes)
+	{
+		double size = bytes;
+		if(size<900)
+			return QString(__tr2qs("%1 bytes")).arg(size,0,'f',3);
+
+		size/=1024;
+		if(size<900)
+			return QString(__tr2qs("%1 KB")).arg(size,0,'f',3);
+
+		size/=1024;
+		if(size<900)
+			return QString(__tr2qs("%1 MB")).arg(size,0,'f',3);
+
+		//Pirated DVD?;)
+		size/=1024;
+		if(size<900)
+			return QString(__tr2qs("%1 GB")).arg(size,0,'f',3);
+
+		//Uhm.. We are downloading a whole internet:)))
+		size/=1024;
+		return QString(__tr2qs("%1 TB")).arg(size,0,'f',3);
+	}
+
+	bool equalCS(const QString &sz1,const QString &sz2)
+	{
+		if(sz1.length() != sz2.length())return false;
+
+		const QChar * c1 = sz1.unicode();
+		const QChar * c2 = sz2.unicode();
+		const QChar * c1e = c1 + sz1.length();
+		
+		if(!c1 || !c2)return (c1 == c2);
+		
+		while(c1 < c1e)
+		{
+			if(c1->unicode() != c2->unicode())return false;
+			c1++;
+			c2++;
+		}
+		return (c1 == c1e);
+	}
+
+	bool equalCI(const QString &sz1,const QString &sz2)
+	{
+		if(sz1.length() != sz2.length())return false;
+
+		const QChar * c1 = sz1.unicode();
+		const QChar * c2 = sz2.unicode();
+		const QChar * c1e = c1 + sz1.length();
+
+		if(!c1 || !c2)return (c1 == c2);
+
+		while(c1 < c1e)
+		{
+#ifdef COMPILE_USE_QT4
+			if(c1->toLower().unicode() != c2->toLower().unicode())return false;
+#else
+			if(c1->lower().unicode() != c2->lower().unicode())return false;
+#endif
+			c1++;
+			c2++;
+		}
+		return (c1 == c1e);
+	}
+
+	// sz2 is assumed to be null terminated, sz1 is not!
+	bool equalCI(const QString &sz1,const QChar *sz2)
+	{
+		const QChar * c1 = sz1.unicode();
+		const QChar * c1e = c1 + sz1.length();
+
+		if(!c1 || !sz2)return (c1 == sz2);
+
+		while(c1 < c1e)
+		{
+			if(!sz2->unicode())return false; // sz1 has at least another character
+#ifdef COMPILE_USE_QT4
+			if(c1->toLower().unicode() != sz2->toLower().unicode())return false;
+#else
+			if(c1->lower().unicode() != sz2->lower().unicode())return false;
+#endif
+			c1++;
+			sz2++;
+		}
+		return (c1 == c1e) && (!sz2->unicode());
+	}
+
+	bool equalCS(const QString &sz1,const char * sz2)
+	{
+		const QChar * c1 = sz1.unicode();
+		const QChar * c1e = c1 + sz1.length();
+
+		if(!c1)return !sz2;
+
+		while((c1 < c1e) && (*sz2))
+		{
+			if(c1->unicode() != *sz2)return false;
+			c1++;
+			sz2++;
+		}
+		return ((c1 == c1e) && (*sz2 == '\0'));
+	}
+
+	bool equalCI(const QString &sz1,const char * sz2)
+	{
+		const QChar * c1 = sz1.unicode();
+		const QChar * c1e = c1 + sz1.length();
+
+		if(!c1)return !sz2;
+
+		while((c1 < c1e) && (*sz2))
+		{
+#ifdef COMPILE_USE_QT4
+			if(c1->toLower().unicode() != tolower(*sz2))return false;
+#else
+			if(c1->lower().unicode() != tolower(*sz2))return false;
+#endif
+			c1++;
+			sz2++;
+		}
+		return ((c1 == c1e) && (*sz2 == '\0'));
+	}
+
+	int cmpCS(const QString &sz1,const QString &sz2)
+	{
+		const QChar * c1 = sz1.unicode();
+		const QChar * c2 = sz2.unicode();
+		const QChar * c1e = c1 + sz1.length();
+		const QChar * c2e = c2 + sz2.length();
+
+		if(!c1)
+		{
+			if(!c2)return 0;
+			return -1;
+		}
+		if(!c2)return 1;
+
+
+		for(;;)
+		{
+			if(c1 >= c1e)
+			{
+				if(c2 < c2e)return /* 0 */ - (c2->unicode());
+				return 0;
+			}
+			if(c2 >= c2e)return c1->unicode() /* - 0 */;
+
+			int diff = c1->unicode() - c2->unicode();
+			if(diff)return diff;
+
+			c1++;
+			c2++;
+		}
+
+		return 0; // never here
+	}
+
+	int cmpCI(const QString &sz1,const QString &sz2)
+	{
+		const QChar * c1 = sz1.unicode();
+		const QChar * c2 = sz2.unicode();
+		const QChar * c1e = c1 + sz1.length();
+		const QChar * c2e = c2 + sz2.length();
+
+		if(!c1)
+		{
+			if(!c2)return 0;
+			return -1;
+		}
+		if(!c2)return 1;
+
+		for(;;)
+		{
+			if(c1 >= c1e)
+			{
+#ifdef COMPILE_USE_QT4
+				if(c2 < c2e)return /* 0 */ - (c2->toLower().unicode());
+#else
+				if(c2 < c2e)return /* 0 */ - (c2->lower().unicode());
+#endif
+				return 0;
+			}
+#ifdef COMPILE_USE_QT4
+			if(c2 >= c2e)return c1->toLower().unicode() /* - 0 */;
+#else
+			if(c2 >= c2e)return c1->lower().unicode() /* - 0 */;
+#endif
+
+#ifdef COMPILE_USE_QT4
+			int diff = c1->toLower().unicode() - c2->toLower().unicode();
+#else
+			int diff = c1->lower().unicode() - c2->lower().unicode();
+#endif
+			if(diff)return diff;
+
+			c1++;
+			c2++;
+		}
+
+		return 0; // never here
+	}
+
+	int cmpCIN(const QString &sz1,const QString &sz2,unsigned int len)
+	{
+		if(len == 0)return 0; // assume equal
+		unsigned int l1 = MY_MIN(len,sz1.length());
+		unsigned int l = MY_MIN(l1,sz2.length()); // FIXME: THIS IS NOT OK
+
+		const QChar * c1 = sz1.unicode();
+		const QChar * c2 = sz2.unicode();
+		const QChar * c1e = c1 + l;
+
+		if(!c1)
+		{
+			if(!c2)return 0;
+			return -1;
+		}
+		if(!c2)return 1;
+
+		int diff = 0;
+
+#ifdef COMPILE_USE_QT4
+		while((c1 < c1e) && !(diff = (c1->toLower().unicode() - c2->toLower().unicode())))
+#else
+		while((c1 < c1e) && !(diff = (c1->lower().unicode() - c2->lower().unicode())))
+#endif
+		{
+			c1++;
+			c2++;
+		}
+
+		return diff;
+	}
+
+	void ensureLastCharIs(QString &szString,const QChar &c)
+	{
+		if(!lastCharIs(szString,c))szString.append(c);
+	}
+
+	QString getToken(QString &szString,const QChar &sep)
+	{
+		int i=0;
+		while(i < szString.length())
+		{
+			if(szString[i] == sep)break;
+			i++;
+		}
+		QString ret;
+		if(i == szString.length())
+		{
+			ret = szString;
+			szString = "";
+		} else {
+			ret = szString.left(i);
+			while(i < szString.length())
+			{
+				if(szString[i] != sep)break;
+				i++;
+			}
+			if(i == szString.length())szString = "";
+			else szString.remove(0,i);
+		}
+		return ret;
+	}
+
+	void stripRightWhiteSpace(QString &s)
+	{
+		int iRemove = 0;
+		while(iRemove < s.length())
+		{
+			if(s.at(s.length() - (iRemove + 1)).isSpace())iRemove++;
+			else break;
+		}
+		if(iRemove > 0)s.remove(s.length() - iRemove,iRemove);
+	}
+
+	void stripRight(QString &s,const QChar &c)
+	{
+		int iRemove = 0;
+		while(iRemove < s.length())
+		{
+			if(s.at(s.length() - (iRemove + 1)) == c)iRemove++;
+			else break;
+		}
+		if(iRemove > 0)s.remove(s.length() - iRemove,iRemove);
+	}
+
+	void stripLeft(QString &s,const QChar &c)
+	{
+		int iRemove = 0;
+		while(iRemove < s.length())
+		{
+			if(s[iRemove] == c)
+				iRemove++;
+			else
+				break;
+		}
+		if(iRemove > 0)s.remove(0,iRemove);
+	}
+
+	void detach(QString &sz)
+	{
+#ifdef COMPILE_USE_QT4
+		sz.resize(sz.length());
+#else
+		sz.setLength(sz.length());
+#endif
+	}
+
+	const QChar * nullTerminatedArray(const QString &sz)
+	{
+		//sz.setLength(sz.length()); // detach!
+#ifdef COMPILE_USE_QT4
+		return sz.constData();
+#else
+		return (const QChar *)sz.ucs2(); // MAY BE NULL!
+#endif
+	}
+	
+	void appendNumber(QString &s,double dReal)
+	{
+		char buffer[512];
+		::sprintf(buffer,"%f",dReal);
+		s.append(buffer);
+	}
+	
+	void appendNumber(QString &s,int iInteger)
+	{
+		char buffer[64];
+		::sprintf(buffer,"%d",iInteger);
+		s.append(buffer);
+	}
+
+	void appendNumber(QString &s,kvi_i64_t iInteger)
+	{
+		char buffer[64];
+		::sprintf(buffer,"%ld",iInteger);
+		s.append(buffer);
+	}
+	
+	void appendNumber(QString &s,kvi_u64_t uInteger)
+	{
+		char buffer[64];
+		::sprintf(buffer,"%lu",uInteger);
+		s.append(buffer);
+	}
+	
+	void appendNumber(QString &s,unsigned int uInteger)
+	{
+		char buffer[64];
+		::sprintf(buffer,"%u",uInteger);
+		s.append(buffer);
+	}
+
+	void vsprintf(QString &s,const QString &szFmt,kvi_va_list list)
+	{
+#define MEMINCREMENT 32
+
+		int reallen = 0;
+		int allocsize = MEMINCREMENT;
+
+		//s.setLength(allocsize);
+
+		const QChar * fmt = nullTerminatedArray(szFmt);
+		if(!fmt)
+		{
+			s = QString::null;
+			return;
+		}
+
+		QChar * buffer = (QChar *)kvi_malloc(sizeof(QChar) * allocsize);
+		//QChar * p = (QChar *)s.unicode();
+
+		char *argString;
+		long argValue;
+		unsigned long argUValue;
+	
+		//9999999999999999999999999999999\0
+		char numberBuffer[32]; //enough ? 10 is enough for 32bit unsigned int...
+		char *pNumBuf;
+		unsigned int tmp;
+
+		QChar * p = buffer;
+
+#define INCREMENT_MEM \
+		{ \
+			allocsize += MEMINCREMENT; \
+			buffer = (QChar *)kvi_realloc(buffer,sizeof(QChar) * allocsize); \
+			p = buffer + reallen; \
+		}
+
+#define INCREMENT_MEM_BY(numchars) \
+		{ \
+			allocsize += numchars + MEMINCREMENT; \
+			buffer = (QChar *)kvi_realloc(buffer,sizeof(QChar) * allocsize); \
+			p = buffer + reallen; \
+		}
+
+
+		for(; fmt->unicode() ; ++fmt)
+		{
+			if(reallen == allocsize)INCREMENT_MEM
+
+			//copy up to a '%'
+			if(fmt->unicode() != '%')
+			{
+				*p++ = *fmt;
+				reallen++;
+				continue;
+			}
+
+			++fmt; //skip this '%'
+			switch(fmt->unicode())
+			{
+				case 's': // char * string
+				{
+					argString = kvi_va_arg(list,char *);
+					if(!argString)argString = "[!NULL!]";
+					QString str(argString);
+					if(str.isEmpty())continue;
+					int len = str.length();
+					const QChar * ch = str.unicode();
+					if(!ch)continue;
+					if((allocsize - reallen) < len)INCREMENT_MEM_BY(len)
+					while(len--)*p++ = *ch++;
+					reallen += str.length();
+					continue;
+				}
+				case 'S': // KviStr * string
+				{
+					KviStr * str = kvi_va_arg(list,KviStr *);
+					if(!str)continue;
+					if((allocsize - reallen) < str->len())INCREMENT_MEM_BY(str->len())
+					argString = str->ptr();
+					while(*argString)*p++ = QChar(*argString++);
+					reallen += str->len();
+					continue;
+				}
+				case 'Q': // QString * string
+				{
+					QString * str = kvi_va_arg(list,QString *);
+					if(!str)continue;
+					if(str->isEmpty())continue;
+					int len = str->length();
+					const QChar * ch = str->unicode();
+					if(!ch)continue;
+					if((allocsize - reallen) < len)INCREMENT_MEM_BY(len)
+					while(len--)*p++ = *ch++;
+					reallen += str->length();
+					continue;
+				}
+				case 'c': //char
+				{
+					//
+					// I'm not sure about this...
+					// In the linux kernel source the
+					// unsigned char is extracted from an integer type.
+					// We assume that gcc stacks a char argument
+					// as sizeof(int) bytes value.
+					// Is this always true ?
+					//
+					*p++ = (char)kvi_va_arg(list,int);
+					reallen++;
+					continue;
+				}
+				case 'q': // QChar *
+				{
+					//
+					// I'm not sure about this...
+					// In the linux kernel source the
+					// unsigned char is extracted from an integer type.
+					// We assume that gcc stacks a char argument
+					// as sizeof(int) bytes value.
+					// Is this always true ?
+					//
+					*p++ = *((QChar *)kvi_va_arg(list,QChar *));
+					reallen++;
+					continue;
+				}
+				case 'd': //signed integer
+				{
+					argValue = kvi_va_arg(list,int);
+					if(argValue < 0)
+					{ //negative integer
+						*p++ = '-';
+						reallen++;
+						argValue = -argValue; //need to have it positive
+						// most negative integer exception (avoid completely senseless (non digit) responses)
+						if(argValue < 0)argValue = 0;  //we get -0 here
+					}
+					//write the number in a temporary buffer
+					pNumBuf = numberBuffer;
+					do {
+						tmp = argValue / 10;
+						*pNumBuf++ = argValue - (tmp * 10) + '0';
+					} while((argValue = tmp));
+					//copy now....
+					argUValue = pNumBuf - numberBuffer; //length of the number string
+					if((allocsize - reallen) < (int)argUValue)INCREMENT_MEM_BY(argUValue)
+					do { *p++ = QChar(*--pNumBuf); } while(pNumBuf != numberBuffer);
+					reallen += argUValue;
+					continue;
+				}
+				case 'u': //unsigned integer
+				{
+					argUValue = kvi_va_arg(list,unsigned int); //many implementations place int here
+					//write the number in a temporary buffer
+					pNumBuf = numberBuffer;
+					do {
+						tmp = argUValue / 10;
+						*pNumBuf++ = argUValue - (tmp * 10) + '0';
+					} while((argUValue = tmp));
+					//copy now....
+					argValue = pNumBuf - numberBuffer; //length of the number string
+					if((allocsize - reallen) < argValue)INCREMENT_MEM_BY(argValue)
+					do { *p++ = *--pNumBuf; } while(pNumBuf != numberBuffer);
+					reallen += argValue;
+					continue;
+				}
+				case 'h':
+				case 'x': // hexadecimal unsigned integer
+				{
+					static char hexsmalldigits[]="0123456789abcdef";
+					argUValue = kvi_va_arg(list,unsigned int); //many implementations place int here
+					//write the number in a temporary buffer
+					pNumBuf = numberBuffer;
+					do {
+						tmp = argUValue / 16;
+						*pNumBuf++ = hexsmalldigits[argUValue - (tmp * 16)];
+					} while((argUValue = tmp));
+					//copy now....
+					argValue = pNumBuf - numberBuffer; //length of the number string
+					if((allocsize - reallen) < argValue)INCREMENT_MEM_BY(argValue)
+					do { *p++ = *--pNumBuf; } while(pNumBuf != numberBuffer);
+					reallen += argValue;
+					continue;
+				}
+				case 'H':
+				case 'X': // hexadecimal unsigned integer
+				{
+					static char hexbigdigits[]="0123456789ABCDEF";
+					argUValue = kvi_va_arg(list,unsigned int); //many implementations place int here
+					//write the number in a temporary buffer
+					pNumBuf = numberBuffer;
+					do {
+						tmp = argUValue / 16;
+						*pNumBuf++ = hexbigdigits[argUValue - (tmp * 16)];
+					} while((argUValue = tmp));
+					//copy now....
+					argValue = pNumBuf - numberBuffer; //length of the number string
+					if((allocsize - reallen) < argValue)INCREMENT_MEM_BY(argValue)
+					do { *p++ = *--pNumBuf; } while(pNumBuf != numberBuffer);
+					reallen += argValue;
+					continue;
+				}
+				default: //a normal percent followed by some char
+				{
+					*p++ = '%';  //write it
+					reallen++;
+					if(fmt->unicode())
+					{
+						if(reallen == allocsize)INCREMENT_MEM
+						*p++ = *fmt;
+						reallen++;
+					}
+					continue;
+				}
+			}
+		}
+
+		s.setUnicode(buffer,reallen);
+		kvi_free(buffer);
+		//s.squeeze();
+	}
+
+
+	QString & sprintf(QString &s,const QString &szFmt,...)
+	{
+		kvi_va_list list;
+		kvi_va_start_by_reference(list,szFmt);
+		//print...with max 256 chars
+		KviQString::vsprintf(s,szFmt,list);
+		kvi_va_end(list);
+		return s;
+	}
+
+	void appendFormatted(QString &s,const QString &szFmt,...)
+	{
+		QString tmp;
+		kvi_va_list list;
+		kvi_va_start_by_reference(list,szFmt);
+		//print...with max 256 chars
+		KviQString::vsprintf(tmp,szFmt,list);
+		kvi_va_end(list);
+		s.append(tmp);
+	}
+
+	bool matchWildExpressionsCI(const QString &szM1,const QString &szM2)
+	{
+		//Matches two regular expressions containging wildcards (* and ?)
+	
+		//          s1
+		//          m1
+		// mask1 : *xor
+		// mask2 : xorand*xor
+		//         m2
+		//          s2
+	
+		//                        s2
+		//                       m2
+		//                       | 
+		// [email protected]
+		//
+		// *!*@*.net
+		//      |
+		//      m1
+		//      s1
+		//
+
+#ifdef COMPILE_USE_QT4
+		const QChar * m1 = (const QChar *)szM1.constData();
+		const QChar * m2 = (const QChar *)szM2.constData();
+#else
+		const QChar * m1 = (const QChar *)szM1.ucs2();
+		const QChar * m2 = (const QChar *)szM2.ucs2();
+#endif
+
+		if(!(m1 && m2 && (m1->unicode())))return false;
+		const QChar * savePos1 = 0;
+		const QChar * savePos2 = m2;
+		while(m1->unicode())
+		{
+			//loop managed by m1 (initially first mask)
+			if(m1->unicode()=='*')
+			{
+				//Found a wildcard in m1
+				savePos1 = ++m1;            //move to the next char and save the position...this is our jolly
+				if(!savePos1->unicode())return true;  //last was a wildcard , matches everything ahead...
+				savePos2 = m2+1;            //next return state for the second string
+				continue;                   //and return
+			}
+			if(!m2->unicode())return false;         //m2 finished and we had something to match here!
+#ifdef COMPILE_USE_QT4
+			if(m1->toLower()==m2->toLower())
+#else
+			if(m1->lower()==m2->lower())
+#endif
+			{
+				//chars matched
+				m1++;                       //Go ahead in the two strings
+				m2++;                       //
+				if((!(m1->unicode())) && m2->unicode() && savePos1)
+				{
+					//m1 finished , but m2 not yet and we have a savePosition for m1 (there was a wildcard)...
+					//retry matching the string following the * from the savePos2 (one char ahead last time)
+					m1 = savePos1;          //back to char after wildcard
+					m2 = savePos2;          //back to last savePos2
+					savePos2++;             //next savePos2 will be next char
+				}
+			} else {
+				if(m2->unicode() == '*')
+				{
+					//A wlidcard in the second string
+					//Invert the game : mask1 <-> mask2
+					//mask2 now leads the game...
+					savePos1 = m1;          //aux
+					m1 = m2;                //...swap
+					m2 = savePos1;          //...swap
+					savePos1 = m1;          //sync save pos1
+					savePos2 = m2 + 1;      //sync save pos2
+					continue;               //...and again
+				}
+				// m1 != m2 , m1 != * , m2 != *
+				if((m1->unicode() == '?') || (m2->unicode() == '?'))
+				{
+					m1++;
+					m2++;
+					if((!(m1->unicode())) && m2->unicode() && savePos1)
+					{
+						//m1 finished , but m2 not yet and we have a savePosition for m1 (there was a wildcard)...
+						//retry matching the string following the * from the savePos2 (one char ahead last time)
+						m1 = savePos1;          //back to char after wildcard
+						m2 = savePos2;          //back to last savePos2
+						savePos2++;             //next savePos2 will be next char
+					}
+				} else {
+					if(savePos1)
+					{
+						//Have a jolly man...allow not matching...
+						m1 = savePos1;          //go back to char after wildcard...need to rematch...
+						m2 = savePos2;          //back to last savePos2
+						savePos2++;             //and set next savePos2
+					} else return false;        //No previous wildcards...not matched!
+				}
+			}
+		}
+		return (!(m2->unicode()));           //m1 surely finished , so for the match , m2 must be finished too
+	}
+
+	bool matchStringCI(const QString &szExp,const QString &szStr,bool bIsRegExp,bool bExact)
+	{
+		QString szWildcard;
+#ifdef COMPILE_USE_QT4
+		QChar* ptr=(QChar*)szExp.constData();
+#else
+		QChar* ptr=(QChar*)szExp.ucs2();
+#endif
+		if(!ptr) return 0;
+		while(ptr->unicode())
+		{
+			if((ptr->unicode()=='[') || (ptr->unicode()==']'))
+			{
+				szWildcard.append("[");
+				szWildcard.append(*ptr);
+				szWildcard.append("]");
+			} else {
+				szWildcard.append(*ptr);
+			}
+			ptr++;
+		}
+#ifdef COMPILE_USE_QT4
+		QRegExp re(szWildcard,Qt::CaseInsensitive,bIsRegExp ? QRegExp::RegExp : QRegExp::Wildcard);
+#else
+		QRegExp re(szWildcard,false,!bIsRegExp);
+#endif
+		if(bExact) return re.exactMatch(szStr);
+#ifdef COMPILE_USE_QT4
+		return re.indexIn(szStr) != -1;
+#else
+		return re.search(szStr) != -1;
+#endif
+	}
+
+	bool matchStringCS(const QString &szExp,const QString &szStr,bool bIsRegExp,bool bExact)
+	{
+		QString szWildcard;
+#ifdef COMPILE_USE_QT4
+		QChar* ptr=(QChar*)szExp.constData();
+#else
+		QChar* ptr=(QChar*)szExp.ucs2();
+#endif
+		if(!ptr) return 0;
+		while(ptr->unicode())
+		{
+			if((ptr->unicode()=='[')) // <-- hum ?
+			{
+				szWildcard.append("[");
+				szWildcard.append(*ptr);
+				szWildcard.append("]");
+			} else {
+				szWildcard.append(*ptr);
+			}
+			ptr++;
+		}
+#ifdef COMPILE_USE_QT4
+		QRegExp re(szWildcard,Qt::CaseSensitive,bIsRegExp ? QRegExp::RegExp : QRegExp::Wildcard);
+#else
+		QRegExp re(szWildcard,true,!bIsRegExp);
+#endif
+		if(bExact) return re.exactMatch(szStr);
+#ifdef COMPILE_USE_QT4
+		return re.indexIn(szStr) != -1;
+#else
+		return re.search(szStr) != -1;
+#endif
+	}
+
+	void cutFromFirst(QString &s,const QChar &c,bool bIncluded)
+	{
+#ifdef COMPILE_USE_QT4
+		int idx = s.indexOf(c);
+#else
+		int idx = s.find(c);
+#endif
+		if(idx == -1)return;
+		s.truncate(bIncluded ? idx : idx + 1);
+	}
+
+	void cutFromLast(QString &s,const QChar &c,bool bIncluded)
+	{
+#ifdef COMPILE_USE_QT4
+		int idx = s.lastIndexOf(c);
+#else
+		int idx = s.findRev(c);
+#endif
+		if(idx == -1)return;
+		s.truncate(bIncluded ? idx : idx + 1);
+	}
+	
+	void cutToFirst(QString &s,const QChar &c,bool bIncluded,bool bClearIfNotFound)
+	{
+#ifdef COMPILE_USE_QT4
+		int idx = s.indexOf(c);
+#else
+		int idx = s.find(c);
+#endif
+		if(idx == -1)
+		{
+			if(bClearIfNotFound)s = "";
+			return;
+		}
+		s.remove(0,bIncluded ? idx + 1 : idx);
+	}
+	
+	void cutToLast(QString &s,const QChar &c,bool bIncluded,bool bClearIfNotFound)
+	{
+#ifdef COMPILE_USE_QT4
+		int idx = s.lastIndexOf(c);
+#else
+		int idx = s.findRev(c);
+#endif
+		if(idx == -1)
+		{
+			if(bClearIfNotFound)s = "";
+			return;
+		}
+		s.remove(0,bIncluded ? idx + 1 : idx);
+	}
+
+	void cutFromFirst(QString &s,const QString &c,bool bIncluded)
+	{
+#ifdef COMPILE_USE_QT4
+		int idx = s.indexOf(c);
+#else
+		int idx = s.find(c);
+#endif
+		if(idx == -1)return;
+		s.truncate(bIncluded ? idx : idx + c.length());
+	}
+
+	void cutFromLast(QString &s,const QString &c,bool bIncluded)
+	{
+#ifdef COMPILE_USE_QT4
+		int idx = s.lastIndexOf(c);
+#else
+		int idx = s.findRev(c);
+#endif
+		if(idx == -1)return;
+		s.truncate(bIncluded ? idx : idx + c.length());
+	}
+	
+	void cutToFirst(QString &s,const QString &c,bool bIncluded,bool bClearIfNotFound)
+	{
+#ifdef COMPILE_USE_QT4
+		int idx = s.indexOf(c);
+#else
+		int idx = s.find(c);
+#endif
+		if(idx == -1)
+		{
+			if(bClearIfNotFound)s = "";
+			return;
+		}
+		s.remove(0,bIncluded ? idx + c.length() : idx);
+	}
+	
+	void cutToLast(QString &s,const QString &c,bool bIncluded,bool bClearIfNotFound)
+	{
+#ifdef COMPILE_USE_QT4
+		int idx = s.lastIndexOf(c);
+#else
+		int idx = s.findRev(c);
+#endif
+		if(idx == -1)
+		{
+			if(bClearIfNotFound)s = "";
+			return;
+		}
+		s.remove(0,bIncluded ? idx + c.length() : idx);
+	}
+
+	QString upperISO88591(const QString &szSrc)
+	{
+		const QChar * c = nullTerminatedArray(szSrc);
+		if(!c)
+		{
+			QString ret;
+			return ret;
+		}
+		QChar * buffer = (QChar *)kvi_malloc(sizeof(QChar) * szSrc.length());
+		QChar * b = buffer;
+		unsigned short us = c->unicode();
+		while(us)
+		{
+			if(us < 256)
+				*b=QChar((unsigned short)iso88591_toUpper_map[us]);
+			else
+				*b = *c;
+			c++;
+			b++;
+			us = c->unicode();
+		}
+		QString ret(buffer,szSrc.length());
+		kvi_free(buffer);
+		return ret;
+	}
+	
+	QString lowerISO88591(const QString &szSrc)
+	{
+		const QChar * c = nullTerminatedArray(szSrc);
+		if(!c)
+		{
+			QString ret;
+			return ret;
+		}
+		QChar * buffer = (QChar *)kvi_malloc(sizeof(QChar) * szSrc.length());
+		QChar * b = buffer;
+		unsigned short us = c->unicode();
+		while(us)
+		{
+			if(us < 256)
+			{
+				*b=QChar((unsigned short)iso88591_toLower_map[us]);
+			} else
+				*b = *c;
+			c++;
+			b++;
+			us = c->unicode();
+		}
+		QString ret(buffer,szSrc.length());
+		kvi_free(buffer);
+		return ret;
+	}
+
+	void transliterate(QString &s,const QString &szToFind,const QString &szReplacement)
+	{
+		int i=0;
+		int il = MY_MIN(szToFind.length(),szReplacement.length());
+		while(i < il)
+		{
+			int k=0;
+			int kl = s.length();
+			while(k < kl)
+			{
+				if(s[k] == szToFind[i])s[k] = szReplacement[i];
+				k++;
+			}
+			i++;
+		}
+	}
+	
+	static char hexdigits[16] = { '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f' };
+	
+	void bufferToHex(QString &szRetBuffer,const unsigned char * buffer,unsigned int len)
+	{
+#ifdef COMPILE_USE_QT4
+		szRetBuffer.resize(len * 2);
+#else
+		szRetBuffer.setLength(len * 2);
+#endif
+		unsigned int i=0;
+		while(i < (len*2))
+		{
+			szRetBuffer[int(i)] = QChar( (unsigned int) hexdigits[(*buffer) / 16] );
+			i++;
+			szRetBuffer[int(i)] = QChar( (unsigned int)hexdigits[(*buffer) % 16] );
+			i++;
+			buffer++;
+		}
+	}
+};
diff --git a/src/kvilib/core/kvi_qstring.h b/src/kvilib/core/kvi_qstring.h
new file mode 100644
index 00000000..c82063e9
--- /dev/null
+++ b/src/kvilib/core/kvi_qstring.h
@@ -0,0 +1,293 @@
+#ifndef _KVI_QSTRING_H_
+#define _KVI_QSTRING_H_
+
+//=============================================================================
+//
+//   File : kvi_qstring.h
+//   Creation date : Mon Aug 04 2003 13:36:33 CEST by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 2003-2006 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+//=============================================================================
+//
+// Helper functions for the QString class
+//
+//=============================================================================
+
+#include "kvi_settings.h"
+#include "kvi_inttypes.h"
+#include "kvi_stdarg.h"
+#include "kvi_qcstring.h"
+
+#include <qstring.h>
+
+///
+/// \namespace KviQString
+///
+/// \brief A namespace for QString helper functions
+///
+/// This namespace contains several helper functions
+/// that are used when dealing with QString.
+///
+namespace KviQString
+{
+	extern KVILIB_API QString makeSizeReadable(size_t size);
+	extern KVILIB_API bool equalCS(const QString &sz1,const QString &sz2);
+	extern KVILIB_API bool equalCI(const QString &sz1,const QString &sz2);
+	extern KVILIB_API bool equalCS(const QString &sz1,const char * sz2);
+	extern KVILIB_API bool equalCI(const QString &sz1,const char * sz2);
+	// sz2 is assumed to be null terminated here!
+	extern KVILIB_API bool equalCI(const QString &sz1,const QChar * sz2);
+	inline bool equalCS(const char * sz1,const QString &sz2)
+		{ return equalCS(sz2,sz1); };
+	inline bool equalCI(const char * sz1,const QString &sz2)
+		{ return equalCI(sz2,sz1); };
+	// sz1 is assumed to be null terminated here!
+	inline bool equalCI(const QChar * sz1,const QString &sz2)
+		{ return equalCI(sz2,sz1); };
+
+	extern KVILIB_API bool equalCSN(const QString &sz1,const QString &sz2,unsigned int len);
+	extern KVILIB_API bool equalCIN(const QString &sz1,const QString &sz2,unsigned int len);
+	extern KVILIB_API bool equalCSN(const QString &sz1,const char * sz2,unsigned int len);
+	extern KVILIB_API bool equalCIN(const QString &sz1,const char * sz2,unsigned int len);
+	// sz2 is assumed to be null terminated here!
+	extern KVILIB_API bool equalCIN(const QString &sz1,const QChar * sz2,unsigned int len);
+	inline bool equalCSN(const char * sz1,const QString &sz2,unsigned int len)
+		{ return equalCSN(sz2,sz1,len); };
+	inline bool equalCIN(const char * sz1,const QString &sz2,unsigned int len)
+		{ return equalCIN(sz2,sz1,len); };
+	// sz1 is assumed to be null terminated here!
+	inline bool equalCIN(const QChar * sz1,const QString &sz2,unsigned int len)
+		{ return equalCIN(sz2,sz1,len); };
+
+	//note that greater here means that come AFTER in the alphabetic order
+	// return < 0 ---> str1 < str2
+	// return = 0 ---> str1 = str2
+	// return > 0 ---> str1 > str2
+	extern KVILIB_API int cmpCI(const QString &sz1,const QString &sz2);
+	extern KVILIB_API int cmpCIN(const QString &sz1,const QString &sz2,unsigned int len);
+	extern KVILIB_API int cmpCS(const QString &sz1,const QString &sz2);
+
+	extern KVILIB_API void detach(QString &sz);
+
+	// this makes the QString sz appear as a null terminated array
+	// it MAY RETURN 0 when the QString is null!
+	extern KVILIB_API const QChar * nullTerminatedArray(const QString &sz);
+
+	inline bool lastCharIs(QString &szString,const QChar &c)
+					{ return szString.endsWith(c); };
+
+	extern KVILIB_API void ensureLastCharIs(QString &szString,const QChar &c);
+
+	// wild expression matching
+	extern KVILIB_API bool matchWildExpressionsCI(const QString &szM1,const QString &szM2);
+	// wild or regexp matching
+	extern KVILIB_API bool matchStringCI(const QString &szExp,const QString &szStr,bool bIsRegExp = false,bool bExact = false);
+	extern KVILIB_API bool matchStringCS(const QString &szExp,const QString &szStr,bool bIsRegExp = false,bool bExact = false);
+
+	extern KVILIB_API void vsprintf(QString &s,const QString &szFmt,kvi_va_list list);
+	extern KVILIB_API QString & sprintf(QString &s,const QString &szFmt,...);
+	extern KVILIB_API void stripRightWhiteSpace(QString &s);
+	extern KVILIB_API void stripLeft(QString &s,const QChar &c);
+	extern KVILIB_API void stripRight(QString &s,const QChar &c);
+	extern KVILIB_API void appendFormatted(QString &s,const QString &szFmt,...);
+	extern KVILIB_API void appendNumber(QString &s,double dReal);
+	extern KVILIB_API void appendNumber(QString &s,kvi_i64_t iInteger);
+	extern KVILIB_API void appendNumber(QString &s,int iInteger);
+	extern KVILIB_API void appendNumber(QString &s,unsigned int uInteger);
+	extern KVILIB_API void appendNumber(QString &s,kvi_u64_t uInteger);
+	
+	extern KVILIB_API void cutFromFirst(QString &s,const QChar &c,bool bIncluded = true);
+	extern KVILIB_API void cutFromLast(QString &s,const QChar &c,bool bIncluded = true);
+	extern KVILIB_API void cutToFirst(QString &s,const QChar &c,bool bIncluded = true,bool bClearIfNotFound = false);
+	extern KVILIB_API void cutToLast(QString &s,const QChar &c,bool bIncluded = true,bool bClearIfNotFound = false);
+	extern KVILIB_API void cutFromFirst(QString &s,const QString &c,bool bIncluded = true);
+	extern KVILIB_API void cutFromLast(QString &s,const QString &c,bool bIncluded = true);
+	extern KVILIB_API void cutToFirst(QString &s,const QString &c,bool bIncluded = true,bool bClearIfNotFound = false);
+	extern KVILIB_API void cutToLast(QString &s,const QString &c,bool bIncluded = true,bool bClearIfNotFound = false);
+	
+	extern KVILIB_API QString upperISO88591(const QString &szSrc);
+	extern KVILIB_API QString lowerISO88591(const QString &szSrc);
+	extern KVILIB_API QString getToken(QString &szString,const QChar &sep);
+	
+	extern KVILIB_API void transliterate(QString &s,const QString &szToFind,const QString &szReplacement);
+
+	extern KVILIB_API void bufferToHex(QString &szRetBuffer,const unsigned char * buffer,unsigned int len);
+
+	// a global empty string (note that this is ALSO NULL under Qt 3.x)
+	extern KVILIB_API const QString empty;
+
+	///
+	/// A portability wrapper which with Qt3 and Qt4.
+	/// Returns a lowcase version of the parameter string.
+	///
+	inline QString toLower(const QString &s)
+	{
+#ifdef COMPILE_USE_QT4
+		return s.toLower();
+#else
+		return s.lower();
+#endif
+	}
+	
+	inline int find(const QString &s,QChar c,int index = 0,bool cs = true)
+	{
+#ifdef COMPILE_USE_QT4
+		return s.indexOf(c,index,cs ? Qt::CaseSensitive : Qt::CaseInsensitive);
+#else
+		return s.find(c,index,cs);
+#endif
+	}
+
+	inline int find(const QString &s,char c,int index = 0,bool cs = true)
+	{
+#ifdef COMPILE_USE_QT4
+		return s.indexOf(c,index,cs ? Qt::CaseSensitive : Qt::CaseInsensitive);
+#else
+		return s.find(c,index,cs);
+#endif
+	}
+
+	inline int find(const QString &s,const QString & str,int index = 0,bool cs = true)
+	{
+#ifdef COMPILE_USE_QT4
+		return s.indexOf(str,index,cs ? Qt::CaseSensitive : Qt::CaseInsensitive);
+#else
+		return s.find(str,index,cs);
+#endif
+	}
+
+	inline int find(const QString &s,const QRegExp & rx,int index = 0)
+	{
+#ifdef COMPILE_USE_QT4
+		return s.indexOf(rx,index);
+#else
+		return s.find(rx,index);
+#endif
+	}
+
+	inline int find(const QString &s,const char * str,int index = 0)
+	{
+#ifdef COMPILE_USE_QT4
+		return s.indexOf(QString(str),index);
+#else
+		return s.find(str,index);
+#endif
+	}
+
+	inline int findRev(const QString &s,QChar c,int index = -1,bool cs = true)
+	{
+#ifdef COMPILE_USE_QT4
+		return s.lastIndexOf(c,index,cs ? Qt::CaseSensitive : Qt::CaseInsensitive);
+#else
+		return s.findRev(c,index,cs);
+#endif
+	}
+
+	inline int findRev(const QString &s,char c,int index = -1,bool cs = true)
+	{
+#ifdef COMPILE_USE_QT4
+		return s.lastIndexOf(c,index,cs ? Qt::CaseSensitive : Qt::CaseInsensitive);
+#else
+		return s.findRev(c,index,cs);
+#endif
+	}
+
+	inline int findRev(const QString &s,const QString & str,int index = -1,bool cs = true)
+	{
+#ifdef COMPILE_USE_QT4
+		return s.lastIndexOf(str,index,cs ? Qt::CaseSensitive : Qt::CaseInsensitive);
+#else
+		return s.findRev(str,index,cs);
+#endif
+	}
+
+	inline int findRev(const QString &s,const QRegExp & rx,int index = -1)
+	{
+#ifdef COMPILE_USE_QT4
+		return s.lastIndexOf(rx,index);
+#else
+		return s.findRev(rx,index);
+#endif
+	}
+
+	inline int findRev(const QString &s,const char * str,int index = -1)
+	{
+#ifdef COMPILE_USE_QT4
+		return s.lastIndexOf(QString(str),index);
+#else
+		return s.findRev(str,index);
+#endif
+	}
+
+	inline QString trimmed(const QString &s)
+	{
+#ifdef COMPILE_USE_QT4
+		return s.trimmed();
+#else
+		return s.stripWhiteSpace();
+#endif
+	}
+
+	// WARNING: DO NOT USE CONSTRUCTS LIKE char * c = KviQString::toUtf8(something).data();
+	//          They are dangerous since with many compilers the returned string gets destroyed
+	//          at the end of the instruction and the c pointer gets thus invalidated.
+	//          Use
+	//           KviQCString tmp = KviQString::toUtf8(something);
+	//           char * c = tmp.data(); 
+	//          instead.
+	//          Yes, I know that it sucks, but it's the only way to
+	//          transit to qt 4.x more or less cleanly...
+	inline KviQCString toUtf8(const QString &s)
+	{
+#ifdef COMPILE_USE_QT4
+		return s.toUtf8();
+#else
+		return s.utf8();
+#endif
+	}
+
+	inline KviQCString toLocal8Bit(const QString &s)
+	{
+		return s.local8Bit();
+	}
+	
+	inline kvi_i64_t toI64(QString &szNumber,bool * bOk)
+	{
+#if SIZEOF_LONG_INT == 8
+		return szNumber.toLong(bOk);
+#else
+		return szNumber.toLongLong(bOk);
+#endif
+	}
+	
+	inline kvi_u64_t toU64(QString &szNumber,bool * bOk)
+	{
+#if SIZEOF_LONG_INT == 8
+		return szNumber.toULong(bOk);
+#else
+		return szNumber.toULongLong(bOk);
+#endif
+	}
+};
+
+// QT4SUX: Because QString::null is gone. QString() is SLOWER than QString::null since it invokes a constructor and destructor.
+
+#endif //!_KVI_QSTRING_H_
diff --git a/src/kvilib/core/kvi_strasm.h b/src/kvilib/core/kvi_strasm.h
new file mode 100644
index 00000000..5d3b19ca
--- /dev/null
+++ b/src/kvilib/core/kvi_strasm.h
@@ -0,0 +1,194 @@
+#ifndef _KVI_STRASM_H_
+#define _KVI_STRASM_H_
+
+//=============================================================================
+//
+//   File : kvi_strasm.h
+//   Creation date : Sun Jun 18 2000 18:38:26 by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 1999-2000 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+//=============================================================================
+//
+//   Inline assembly implementations of the commonly used string functions
+//   These will work only on i386 based machines and can be compiled
+//   only by gcc
+//
+//=============================================================================
+
+extern inline bool kvi_strEqualCS(const char * str1,const char * str2)
+{
+	// An instruction pattern is really useful in this case.
+	// When inlining, GCC can optimize to load esi and edi
+	// directly with the strings , without pushing and getting it
+	// from the stack...
+	register bool eax;
+	__asm__ __volatile__ (
+		"	cld\n"
+		"1:\n"
+		"	lodsb %%ds:(%%esi),%%al\n"
+		"	scasb %%es:(%%edi),%%al\n"
+		"	jne 2f\n"
+		"	testb %%al,%%al\n"
+		"	jne 1b\n"
+		"	movl $0x1,%%eax\n"
+		"	jmp 3f\n"
+		"2:\n"
+		"	xorl %%eax,%%eax\n"
+		"3:"
+		: "=a" (eax), "=&S" (str1), "=&D" (str2)
+		:             "1"   (str1), "2"   (str2)
+	);
+	return eax;
+}
+
+extern inline bool kvi_strEqualCSN(const char * str1,const char * str2,int len)	
+{
+	register bool eax;
+	__asm__ __volatile__ (
+		"1:\n"
+		"	decl %3\n"
+		"	js 2f\n"
+		"	movb (%1),%%al\n"
+		"	incl %1\n"
+		"	cmpb %%al,(%2)\n"
+		"	jne 3f\n"
+		"	incl %2\n"
+		"	testb %%al,%%al\n"
+		"	jne 1b\n"
+		"2:\n"
+		"	movl $0x1,%%eax\n"
+		"	jmp 4f\n"
+		"3:\n"
+		"	xorl %%eax,%%eax\n"
+		"4:\n"
+		: "=a" (eax),  "=r" (str1), "=r" (str2), "=r" (len)
+		:              "1"  (str1), "2"  (str2), "3"  (len)
+	);
+	return eax;
+}
+
+// OPTIMIZATION
+// The following two functions are used to compare a variable string with one in that
+// only A-Z<->a-z case insensivity is significant.
+// For example 
+// kvi_strEqualNoLocalCI("a string that does not contain any strange char",str2)
+// will always give the correct result
+// These will NOT work with localizable characters:
+// 'a' with umlaut will be not equal to 'A' with umlaut
+
+extern inline bool kvi_strEqualNoLocaleCI(const char *str1,const char *str2)
+{
+	// Trivial implementation
+	// Ignores completely locales....only A-Z chars are transformed to a-z
+	// Anyway...it will work for IRC :)
+	register int reg;
+	register bool eax;
+	__asm__ __volatile__ (
+		"1:\n"
+		"	movb (%2),%%al\n"
+		"	cmpb $65,%%al\n"
+		"	jb 2f\n"
+		"	cmpb $90,%%al\n"
+		"	ja 2f\n"
+		"	addb $32,%%al\n"
+		"2:\n"
+		"	movb (%3),%b1\n"
+		"	cmpb $65,%b1\n"
+		"	jb 3f\n"
+		"	cmpb $90,%b1\n"
+		"	ja 3f\n"
+		"	addb $32,%b1\n"
+		"3:\n"
+		"	cmpb %%al,%b1\n"
+		"	jne 4f\n"
+		"	incl %2\n"
+		"	incl %3\n"
+		"	testb %%al,%%al\n"
+		"	jne 1b\n"
+		"	movl $1,%%eax\n"
+		"	jmp 5f\n"
+		"4:\n"
+		"	xorl %%eax,%%eax\n"
+		"5:\n"
+		: "=a" (eax), "=q" (reg), "=r" (str1), "=r" (str2)
+		:                         "2"  (str1), "3"  (str2)
+	);
+	return eax;
+}
+
+extern inline bool kvi_strEqualNoLocaleCIN(const char *str1,const char *str2,int len)
+{
+
+	register int reg;
+	register bool eax;
+	__asm__ __volatile__ (
+		"1:\n"
+		"	decl %4\n"
+		"	js 4f\n"
+		"	movb (%2),%%al\n"
+		"	cmpb $65,%%al\n"
+		"	jb 2f\n"
+		"	cmpb $90,%%al\n"
+		"	ja 2f\n"
+		"	addb $32,%%al\n"
+		"2:\n"
+		"	movb (%3),%b1\n"
+		"	cmpb $65,%b1\n"
+		"	jb 3f\n"
+		"	cmpb $90,%b1\n"
+		"	ja 3f\n"
+		"	addb $32,%b1\n"
+		"3:\n"
+		"	cmpb %%al,%b1\n"
+		"	jne 5f\n"
+		"	incl %2\n"
+		"	incl %3\n"
+		"	testb %%al,%%al\n"
+		"	jne 1b\n"
+		"4:\n"
+		"	movl $1,%%eax\n"
+		"	jmp 6f\n"
+		"5:\n"
+		"	xorl %%eax,%%eax\n"
+		"6:\n"
+		: "=a" (eax), "=q" (reg), "=r" (str1), "=r" (str2), "=r" (len)
+		:                         "2"  (str1), "3"  (str2), "4"  (len)
+	);
+	return eax;
+}
+
+
+extern inline int kvi_strLen(const char * str)
+{
+	register int ecx;
+	__asm__ __volatile__(
+		"	cld\n"
+		"	repne\n"
+		"	scasb\n"
+		"	notl %0\n"
+		"	decl %0"
+		: "=c" (ecx),        "=&D" (str)
+		: "0"  (0xffffffff), "1"   (str), "a" (0)
+	);
+	return ecx;
+}
+
+#endif //_KVI_STRASM_H_
diff --git a/src/kvilib/core/kvi_string.cpp b/src/kvilib/core/kvi_string.cpp
new file mode 100644
index 00000000..3f201352
--- /dev/null
+++ b/src/kvilib/core/kvi_string.cpp
@@ -0,0 +1,3063 @@
+//=============================================================================
+//
+//   File : kvi_string.cpp
+//   Creation date : Fri Mar 19 1999 03:20:45 by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 1999-2001 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+#define __KVILIB__
+
+
+#define _KVI_DEBUG_CHECK_RANGE_
+#include "kvi_debug.h"
+
+#define _KVI_STRING_CPP_
+#include "kvi_string.h"
+
+#include "kvi_memmove.h"
+#include "kvi_malloc.h"
+
+#include "kvi_qstring.h"
+
+kvi_wslen_t kvi_wstrlen(const kvi_wchar_t * str)
+{
+	const kvi_wchar_t * ptr = str;
+	while(*ptr)ptr++;
+	return (ptr - str);
+}
+
+
+// %s = Latin1 char string (can't be null)
+// %d = signed int (short,char)
+// %u = unsigned int (short,char)
+// %c = char value (kvi_wchar_t value)
+
+// %f = double value
+
+// %w = kvi_wchar_t string (can't be null)
+
+// %S = Latin1 KviStr pointer (#ifdef WSTRINGCONFIG_USE_KVISTR) : can't be NULL!
+// %W = KviWStr pointer : can't be NULL!
+// %Q = QString pointer : can't be NULL!
+
+#define _WSTRING_WMEMCPY(_dst,_src,_len) kvi_fastmoveodd((void *)(_dst),(const void *)(_src),sizeof(kvi_wchar_t) * (_len))
+#define _WSTRING_STRLEN(_str) kvi_strLen(_str)
+
+#define WVSNPRINTF_BODY \
+\
+	register kvi_wchar_t *p; \
+	long int argValue; \
+	unsigned long argUValue; \
+\
+	kvi_wchar_t numberBuffer[32]; \
+	kvi_wchar_t *pNumBuf; \
+	unsigned int tmp; \
+\
+	for(p=buffer ; *fmt ; ++fmt) \
+	{ \
+		if(len < 1)return (-1); \
+\
+		if(*fmt != '%') \
+		{ \
+			*p++ = *fmt; \
+			--len; \
+			continue; \
+		} \
+\
+		++fmt; \
+\
+		switch(*fmt) \
+		{ \
+			case 's': \
+			{ \
+				char * argString = kvi_va_arg(list,char *); \
+				argValue = (int)_WSTRING_STRLEN(argString); \
+				if(len <= argValue)return (-1); \
+				while(*argString)*p++ = *argString++; \
+				len -= argValue; \
+			} \
+			break; \
+			case 'S': \
+			{ \
+				KviStr * pString = kvi_va_arg(list,KviStr *); \
+				char * argString = pString->ptr(); \
+				if(len <= ((int)(pString->len())))return (-1); \
+				while(*argString)*p++ = *argString++; \
+				len -= pString->len(); \
+			} \
+			break; \
+			case 'Q': \
+			{ \
+				QString * pString = kvi_va_arg(list,QString *); \
+				if(pString->length() > 0) \
+				{ \
+					if(len <= ((int)(pString->length())))return (-1); \
+					_WSTRING_WMEMCPY(p,pString->unicode(),pString->length()); \
+					p += pString->length(); \
+					len -= pString->length(); \
+				} \
+			} \
+			break; \
+			case 'd': \
+				argValue = kvi_va_arg(list,int); \
+				if(argValue < 0) \
+				{ \
+					*p++ = '-'; \
+					if(--len == 0)return (-1); \
+					argValue = -argValue; \
+					if(argValue < 0)argValue = 0; \
+				} \
+				pNumBuf = numberBuffer; \
+				do { \
+					tmp = argValue / 10; \
+					*pNumBuf++ = argValue - (tmp * 10) + '0'; \
+				} while((argValue = tmp)); \
+				argUValue = pNumBuf - numberBuffer; \
+				if(((unsigned int)len) <= argUValue)return (-1); \
+				do { \
+					*p++ = *--pNumBuf; \
+				} while(pNumBuf != numberBuffer); \
+				len -= argUValue; \
+			break; \
+			case 'u': \
+				argUValue = kvi_va_arg(list,unsigned int); \
+				pNumBuf = numberBuffer; \
+				do { \
+					tmp = argUValue / 10; \
+					*pNumBuf++ = argUValue - (tmp * 10) + '0'; \
+				} while((argUValue = tmp)); \
+				argValue = pNumBuf - numberBuffer; \
+				if(len <= argValue)return (-1); \
+				do { \
+					*p++ = *--pNumBuf; \
+				} while(pNumBuf != numberBuffer); \
+				len -= argValue; \
+			break; \
+			case 'f': \
+			{ \
+				double dVal = (double)kvi_va_arg(list,double); \
+				char sprintfBuffer[32]; \
+				argValue = sprintf(sprintfBuffer,"%f",dVal); \
+				if(len <= argValue)return (-1); \
+				char * pSprintfBuffer = sprintfBuffer; \
+				while(*pSprintfBuffer)*p++ = *pSprintfBuffer++; \
+				len -= argValue; \
+			} \
+			break; \
+			case 'c': \
+				*p++ = (kvi_wchar_t)kvi_va_arg(list,int); \
+				--len; \
+			break; \
+			default: \
+				*p++ = '%';  \
+				if(--len == 0)return (-1); \
+				if(*fmt){ \
+					*p++ = *fmt; \
+					--len; \
+				} \
+			break; \
+		} \
+		continue; \
+	} \
+	if(len < 1)return (-1); \
+	*p = 0; \
+	return p-buffer;
+
+int kvi_wvsnprintcf(kvi_wchar_t *buffer,kvi_wslen_t len,const char *fmt,kvi_va_list list)
+{
+	WVSNPRINTF_BODY
+}
+
+int kvi_wvsnprintf(kvi_wchar_t *buffer,kvi_wslen_t len,const kvi_wchar_t *fmt,kvi_va_list list)
+{
+	WVSNPRINTF_BODY
+}
+
+bool kvi_qstringEqualCI(const QString &s1,const QString &s2)
+{
+	const QChar * p1 = s1.unicode();
+	const QChar * p2 = s2.unicode();
+	int l = s1.length() < s2.length() ? s1.length() : s2.length();
+#ifdef COMPILE_USE_QT4
+	while(l-- && (p1->toLower() == p2->toLower()))p1++,p2++;
+#else
+	while(l-- && (p1->lower() == p2->lower()))p1++,p2++;
+#endif
+	if(l==-1)return true;
+	return false;
+}
+
+bool kvi_matchStringCI(register const char * exp,register const char * str)
+{
+	//               a
+	//               .
+	// exp = a*x?mem*a
+	// str = arexoxmexamemizazv
+	//                         .
+	//                         n
+	const char * afterWild = 0;
+	const char * nextStrToCheck = 0;
+
+	while(*exp)
+	{
+		if(*exp == '*')
+		{
+			// exp is a wildcard...
+			afterWild = ++exp;
+			nextStrToCheck = str + 1;
+			if(!(*exp))return true; // and it's the last char in the string: matches everything ahead
+			continue;
+		}
+
+		if(!(*str))return false; // str finished but we had something to match :(
+
+		if(tolower(*exp) == tolower(*str))
+		{
+			// chars matched
+			++exp;
+			++str;
+			if((!(*exp)) && *str)goto check_recovery;
+			continue;
+		}
+
+		if(*exp == '?')
+		{
+			// any-char wildcard
+			++exp;
+			++str;
+			continue;
+		}
+
+check_recovery:
+		// chars unmatched!!!
+		if(afterWild)
+		{
+			// we had a wildcard in exp...
+			// let's use this jolly then
+			exp = afterWild;
+			str = nextStrToCheck;
+			nextStrToCheck++;
+			// and try to compare now
+			continue;
+		}
+
+		return false; // no match :(
+	}
+	return (!(*str));
+}
+
+
+bool kvi_matchStringCS(register const char * exp,register const char * str)
+{
+	//               a
+	//               .
+	// exp = a*x?mem*a
+	// str = arexoxmexamemizazv
+	//                         .
+	//                         n
+	const char * afterWild = 0;
+	const char * nextStrToCheck = 0;
+
+	while(*exp)
+	{
+		if(*exp == '*')
+		{
+			// exp is a wildcard...
+			afterWild = ++exp;
+			nextStrToCheck = str + 1;
+			if(!(*exp))return true; // and it's the last char in the string: matches everything ahead
+			continue;
+		}
+
+		if(!(*str))return false; // str finished but we had something to match :(
+
+		if(*exp == *str)
+		{
+			// chars matched
+			++exp;
+			++str;
+			if((!(*exp)) && *str)goto check_recovery;
+			continue;
+		}
+
+		if(*exp == '?')
+		{
+			// any-char wildcard
+			++exp;
+			++str;
+			continue;
+		}
+
+check_recovery:
+		// chars unmatched!!!
+		if(afterWild)
+		{
+			// we had a wildcard in exp...
+			// let's use this jolly then
+			exp = afterWild;
+			str = nextStrToCheck;
+			nextStrToCheck++;
+			// and try to compare now
+			continue;
+		}
+
+		return false; // no match :(
+	}
+	return (!(*str));
+}
+
+
+
+bool kvi_matchStringWithTerminator(register const char * exp,register const char * str,char terminator,const char ** r1,const char ** r2)
+{
+#define NOT_AT_END(__str) (*__str && (*__str != terminator))
+
+	//               a
+	//               .
+	// exp = a*x?mem*a
+	// str = arexoxmexamemizazv
+	//                         .
+	//                         n
+	const char * afterWild = 0;
+	const char * nextStrToCheck = 0;
+
+	while(NOT_AT_END(exp))
+	{
+		if(*exp == '*')
+		{
+			// exp is a wildcard...
+			afterWild = ++exp;
+			nextStrToCheck = str + 1;
+			if(!(NOT_AT_END(exp)))
+			{
+				while(NOT_AT_END(str))str++;
+				*r1 = exp;
+				*r2 = str;
+				return true; // and it's the last char in the string: matches everything ahead
+			}
+			continue;
+		}
+
+		if(!(*str))return false; // str finished but we had something to match :(
+
+		if(tolower(*exp) == tolower(*str))
+		{
+			// chars matched
+			++exp;
+			++str;
+			if((!(NOT_AT_END(exp))) && NOT_AT_END(str))goto check_recovery;
+			continue;
+		}
+
+		if(*exp == '?')
+		{
+			// any-char wildcard
+			++exp;
+			++str;
+			continue;
+		}
+
+check_recovery:
+		// chars unmatched!!!
+		if(afterWild)
+		{
+			// we had a wildcard in exp...
+			// let's use this jolly then
+			exp = afterWild;
+			str = nextStrToCheck;
+			nextStrToCheck++;
+			// and try to compare now
+			continue;
+		}
+
+		return false; // no match :(
+	}
+	*r1 = exp;
+	*r2 = str;
+	return (!(NOT_AT_END(str)));
+
+#undef NOT_AT_END
+}
+
+bool kvi_matchWildExpr(register const char *m1,register const char *m2)
+{
+	//Matches two regular expressions containging wildcards (* and ?)
+
+	//          s1
+	//          m1
+	// mask1 : *xor
+	// mask2 : xorand*xor
+	//         m2
+	//          s2
+
+	//                        s2
+	//                       m2
+	//                       | 
+	// [email protected]
+	//
+	// *!*@*.net
+	//      |
+	//      m1
+	//      s1
+	//
+
+	if(!(m1 && m2 && (*m1)))return false;
+	const char * savePos1 = 0;
+	const char * savePos2 = m2;
+	while(*m1)
+	{
+		//loop managed by m1 (initially first mask)
+		if(*m1=='*')
+		{
+			//Found a wildcard in m1
+			savePos1 = ++m1;            //move to the next char and save the position...this is our jolly
+			if(!*savePos1)return true;  //last was a wildcard , matches everything ahead...
+			savePos2 = m2+1;            //next return state for the second string
+			continue;                   //and return
+		}
+		if(!(*m2))return false;         //m2 finished and we had something to match here!
+		if(tolower(*m1)==tolower(*m2))
+		{
+			//chars matched
+			m1++;                       //Go ahead in the two strings
+			m2++;                       //
+			if((!(*m1)) && *m2 && savePos1)
+			{
+				//m1 finished , but m2 not yet and we have a savePosition for m1 (there was a wildcard)...
+				//retry matching the string following the * from the savePos2 (one char ahead last time)
+				m1 = savePos1;          //back to char after wildcard
+				m2 = savePos2;          //back to last savePos2
+				savePos2++;             //next savePos2 will be next char
+			}
+		} else {
+			if(*m2 == '*')
+			{
+				//A wlidcard in the second string
+				//Invert the game : mask1 <-> mask2
+				//mask2 now leads the game...
+				savePos1 = m1;          //aux
+				m1 = m2;                //...swap
+				m2 = savePos1;          //...swap
+				savePos1 = m1;          //sync save pos1
+				savePos2 = m2 + 1;      //sync save pos2
+				continue;               //...and again
+			}
+			// m1 != m2 , m1 != * , m2 != *
+			if((*m1 == '?') || (*m2 == '?'))
+			{
+				m1++;
+				m2++;
+				if((!(*m1)) && *m2 && savePos1)
+				{
+					//m1 finished , but m2 not yet and we have a savePosition for m1 (there was a wildcard)...
+					//retry matching the string following the * from the savePos2 (one char ahead last time)
+					m1 = savePos1;          //back to char after wildcard
+					m2 = savePos2;          //back to last savePos2
+					savePos2++;             //next savePos2 will be next char
+				}
+			} else {
+				if(savePos1)
+				{
+					//Have a jolly man...allow not matching...
+					m1 = savePos1;          //go back to char after wildcard...need to rematch...
+					m2 = savePos2;          //back to last savePos2
+					savePos2++;             //and set next savePos2
+				} else return false;        //No previous wildcards...not matched!
+			}
+		}
+	}
+	return (!(*m2));                     //m1 surely finished , so for the match , m2 must be finished too
+
+}
+
+/*
+
+	WARNING: Don't remove: working code but actually unused in KVIrc
+			Later it might become useful
+
+bool kvi_matchWildExprCS(register const char *m1,register const char *m2)
+{
+	if(!(m1 && m2 && (*m1)))return false;
+	const char * savePos1 = 0;
+	const char * savePos2 = m2;
+	while(*m1){ //loop managed by m1 (initially first mask)
+		if(*m1=='*'){
+			//Found a wildcard in m1
+			savePos1 = ++m1;            //move to the next char and save the position...this is our jolly
+			if(!*savePos1)return true;  //last was a wildcard , matches everything ahead...
+			savePos2 = m2+1;            //next return state for the second string
+			continue;                   //and return
+		}
+		if(!(*m2))return false;         //m2 finished and we had something to match here!
+		if((*m1)==(*m2)){
+			//chars matched
+			m1++;                       //Go ahead in the two strings
+			m2++;                       //
+			if((!(*m1)) && *m2 && savePos1){
+				//m1 finished , but m2 not yet and we have a savePosition for m1 (there was a wildcard)...
+				//retry matching the string following the * from the savePos2 (one char ahead last time)
+				m1 = savePos1;          //back to char after wildcard
+				m2 = savePos2;          //back to last savePos2
+				savePos2++;             //next savePos2 will be next char
+			}
+		} else {
+			if(*m2 == '*'){
+				//A wlidcard in the second string
+				//Invert the game : mask1 <-> mask2
+				//mask2 now leads the game...
+				savePos1 = m1;          //aux
+				m1 = m2;                //...swap
+				m2 = savePos1;          //...swap
+				savePos1 = m1;          //sync save pos1
+				savePos2 = m2 + 1;      //sync save pos2
+				continue;               //...and again
+			}
+			if(savePos1){               //Have a jolly man...allow not matching...
+				m1 = savePos1;          //go back to char after wildcard...need to rematch...
+				m2 = savePos2;          //back to last savePos2
+				savePos2++;             //and set next savePos2
+			} else return false;        //No previous wildcards...not matched!
+		}
+	}
+	return (!(*m2));                     //m1 surely finished , so for the match , m2 must be finished too
+
+}
+*/
+
+bool kvi_matchWildExprWithTerminator(register const char *m1,register const char *m2,char terminator,
+			const char ** r1,const char ** r2)
+{
+	//Matches two regular expressions containging wildcards
+
+#define NOT_AT_END(__str) (*__str && (*__str != terminator))
+
+	bool bSwapped = false;
+	if(!(m1 && m2 && (NOT_AT_END(m1))))return false;
+	const char * savePos1 = 0;
+	const char * savePos2 = m2;
+	while(NOT_AT_END(m1))
+	{
+		//loop managed by m1 (initially first mask)
+		if(*m1=='*')
+		{
+			//Found a wildcard in m1
+			savePos1 = ++m1;            //move to the next char and save the position...this is our jolly
+			if(!NOT_AT_END(savePos1))
+			{
+				//last was a wildcard , matches everything ahead...
+				while(NOT_AT_END(m2))m2++;
+				*r1 = bSwapped ? m2 : m1;
+				*r2 = bSwapped ? m1 : m2;
+				return true;
+			}
+			savePos2 = m2+1;            //next return state for the second string
+			continue;                   //and return
+		}
+		if(!NOT_AT_END(m2))return false;         //m2 finished and we had something to match here!
+		if(tolower(*m1)==tolower(*m2))
+		{
+			//chars matched
+			m1++;                       //Go ahead in the two strings
+			m2++;                       //
+			if((!NOT_AT_END(m1)) && NOT_AT_END(m2) && savePos1)
+			{
+				//m1 finished , but m2 not yet and we have a savePosition for m1 (there was a wildcard)...
+				//retry matching the string following the * from the savePos2 (one char ahead last time)
+				m1 = savePos1;          //back to char after wildcard
+				m2 = savePos2;          //back to last savePos2
+				savePos2++;             //next savePos2 will be next char
+			}
+		} else {
+			if(*m2 == '*')
+			{
+				//A wlidcard in the second string
+				//Invert the game : mask1 <-> mask2
+				//mask2 now leads the game...
+				bSwapped = !bSwapped;
+				savePos1 = m1;          //aux
+				m1 = m2;                //...swap
+				m2 = savePos1;          //...swap
+				savePos1 = m1;          //sync save pos1
+				savePos2 = m2 + 1;      //sync save pos2
+				continue;               //...and again
+			}
+			// m1 != m2 , m1 != * , m2 != *
+			if((*m1 == '?') || (*m2 == '?'))
+			{
+				m1++;
+				m2++;
+				if((!NOT_AT_END(m1)) && NOT_AT_END(m2) && savePos1)
+				{
+					//m1 finished , but m2 not yet and we have a savePosition for m1 (there was a wildcard)...
+					//retry matching the string following the * from the savePos2 (one char ahead last time)
+					m1 = savePos1;          //back to char after wildcard
+					m2 = savePos2;          //back to last savePos2
+					savePos2++;             //next savePos2 will be next char
+				}
+			} else {
+				if(savePos1)
+				{
+					//Have a jolly man...allow not matching...
+					m1 = savePos1;          //go back to char after wildcard...need to rematch...
+					m2 = savePos2;          //back to last savePos2
+					savePos2++;             //and set next savePos2
+				} else return false;        //No previous wildcards...not matched!
+			}
+		}
+	}
+	*r1 = bSwapped ? m2 : m1;
+	*r2 = bSwapped ? m1 : m2;
+
+	return (!NOT_AT_END(m2));           //m1 surely finished , so for the match , m2 must be finished too
+
+#undef NOT_AT_END
+}
+
+
+
+const char * kvi_extractToken(KviStr &str,const char *aux_ptr,char sep)
+{
+	__range_valid(aux_ptr);
+	while(*aux_ptr && (*aux_ptr == sep))aux_ptr++;
+	const char *p=aux_ptr;
+	while(*p && (*p != sep))p++;
+	str.m_len=p-aux_ptr;
+	str.m_ptr = (char *)kvi_realloc(str.m_ptr,str.m_len+1);
+	kvi_fastmove(str.m_ptr,aux_ptr,str.m_len);
+	*(str.m_ptr+str.m_len)='\0';
+	while(*p && (*p == sep))p++;
+	return p;
+}
+
+const char * kvi_extractUpTo(KviStr &str,const char *aux_ptr,char sep)
+{
+	__range_valid(aux_ptr);
+	const char *p=aux_ptr;
+	while(*p && (*p != sep))p++;
+	str.m_len=p-aux_ptr;
+	str.m_ptr = (char *)kvi_realloc(str.m_ptr,str.m_len+1);
+	kvi_fastmove(str.m_ptr,aux_ptr,str.m_len);
+	*(str.m_ptr+str.m_len)='\0';
+	return p;
+}
+
+int kvi_vsnprintf(char *buffer,int len,const char *fmt,kvi_va_list list)
+{
+	__range_valid(fmt);
+	__range_valid(buffer);
+	__range_valid(len > 0); //printing 0 characters is senseless
+
+	register char *p;
+	char *argString;
+	long argValue;
+	unsigned long argUValue;
+
+	//9999999999999999999999999999999\0
+	char numberBuffer[32]; //enough ? 10 is enough for 32bit unsigned int...
+	char *pNumBuf;
+	unsigned int tmp;
+
+
+	for(p=buffer ; *fmt ; ++fmt)
+	{
+		if(len < 1)return (-1); //not enough space ... (in fact this could be len < 2 for the terminator)
+		//copy up to a '%'
+		if(*fmt != '%')
+		{
+			*p++ = *fmt;
+			--len;
+			continue;
+		}
+
+		++fmt; //skip this '%'
+		switch(*fmt)
+		{
+			case 's': //string
+				argString = kvi_va_arg(list,char *);
+				if(!argString)continue;
+				argValue = (long)strlen(argString);
+				//check for space...
+				if(len <= argValue)return (-1); //not enough space for buffer and terminator
+				while(*argString)*p++ = *argString++;
+				len -= argValue;
+				continue;
+			case 'd': //signed integer
+				argValue = kvi_va_arg(list,int);
+				if(argValue < 0){ //negative integer
+					*p++ = '-';
+					if(--len == 0)return (-1);
+					argValue = -argValue; //need to have it positive
+					// most negative integer exception (avoid completely senseless (non digit) responses)
+					if(argValue < 0)argValue = 0;  //we get -0 here
+				}
+				//write the number in a temporary buffer
+				pNumBuf = numberBuffer;
+				do {
+					tmp = argValue / 10;
+					*pNumBuf++ = argValue - (tmp * 10) + '0';
+				} while((argValue = tmp));
+				//copy now....
+				argUValue = pNumBuf - numberBuffer; //length of the number string
+				if(((uint)len) <= argUValue)return (-1); //not enough space for number and terminator
+				do { *p++ = *--pNumBuf; } while(pNumBuf != numberBuffer);
+				len -= argUValue;
+				continue;
+			case 'u': //unsigned integer
+				argUValue = kvi_va_arg(list,unsigned int); //many implementations place int here
+				//write the number in a temporary buffer
+				pNumBuf = numberBuffer;
+				do {
+					tmp = argUValue / 10;
+					*pNumBuf++ = argUValue - (tmp * 10) + '0';
+				} while((argUValue = tmp));
+				//copy now....
+				argValue = pNumBuf - numberBuffer; //length of the number string
+				if(len <= argValue)return (-1); //not enough space for number and terminator
+				do { *p++ = *--pNumBuf; } while(pNumBuf != numberBuffer);
+				len -= argValue;
+				continue;
+			case 'c': //char
+				//
+				// I'm not sure about this...
+				// In the linux kernel source the
+				// unsigned char is extracted from an integer type.
+				// We assume that gcc stacks a char argument
+				// as sizeof(int) bytes value.
+				// Is this always true ?
+				//
+				*p++ = (char)kvi_va_arg(list,int);
+				--len;
+				continue;
+			case 'Q': // QString! (this should almost never happen)
+			{
+				QString * s = kvi_va_arg(list,QString *);
+				KviQCString cs = KviQString::toUtf8(*s);
+				const char * t = cs.data();
+				if(!t)continue; // nothing to do
+				//check for space...
+				if(len <= (int)cs.length())return (-1); //not enough space for buffer and terminator
+				while(*t)*p++ = *t++;
+				len -= cs.length();
+				continue;
+			}
+			default: //a normal percent
+				*p++ = '%';  //write it
+				if(--len == 0)return (-1); //not enough space for next char or terminator
+				if(*fmt){        //this if is just in case that we have a % at the end of the string.
+					*p++ = *fmt; //and write this char
+					--len;
+				}
+				continue;
+		}
+	}
+	if(len < 1)return (-1); //missing space for terminator
+	*p = '\0';
+	return p-buffer;
+}
+
+//
+// Nearly the same as the above function...
+//
+
+int kvi_irc_vsnprintf(char *buffer,const char *fmt,kvi_va_list list,bool *bTruncated)
+{
+	__range_valid(fmt);
+	__range_valid(buffer);
+	if( !( buffer && fmt) ) return false;
+	register char *p;
+	char *argString;
+	long argValue;
+	unsigned long argUValue;
+	char numberBuffer[64]; //enough ? 10 is enough for 32bit unsigned int...
+	char *pNumBuf;
+	unsigned int tmp;
+	*bTruncated = false;
+	int len = 512;
+
+	for (p=buffer ; *fmt ; ++fmt) {
+		if(len < 3)goto truncate;
+		//copy up to a '%'
+		if (*fmt != '%') {
+			*p++ = *fmt;
+			--len;
+			continue;
+		}
+		++fmt; //skip this '%'
+		switch(*fmt){
+			case 's': //string
+				argString = kvi_va_arg(list,char *);
+				if(!argString)continue;
+				//check for space...
+				while(*argString){
+					*p++ = *argString++;
+					if(--len < 3)goto truncate;
+				}
+				continue;
+			case 'Q': // QString! (this should almost never happen)
+			{
+				QString * s = kvi_va_arg(list,QString *);
+				KviQCString cs = KviQString::toUtf8(*s);
+				const char * t = cs.data();
+				if(!t)continue; // nothing to do
+				while(*t)
+				{
+					*p++ = *t++;
+					if(--len < 3)goto truncate;
+				}
+				continue;
+			}
+			case 'd': //signed integer
+				argValue = kvi_va_arg(list,int);
+				if(argValue < 0){ //negative integer
+					*p++ = '-';
+					if(--len < 3)goto truncate; //place just for CRLF
+					argValue = -argValue; //need to have it positive
+					if(argValue < 0)argValue = 0; // -0 (hack the exception)
+				}
+				//write the number in a temporary buffer
+				pNumBuf = numberBuffer;
+				do {
+					tmp = argValue / 10;
+					*pNumBuf++ = argValue - (tmp * 10) + '0';
+				} while((argValue = tmp));
+				//copy now....
+				do {
+					*p++ = *--pNumBuf;
+					if(--len < 3)goto truncate;
+				} while(pNumBuf != numberBuffer);
+				continue;
+			case 'u': //unsigned integer
+				argUValue = kvi_va_arg(list,unsigned int); //many implementations place int here
+				//write the number in a temporary buffer
+				pNumBuf = numberBuffer;
+				do {
+					tmp = argUValue / 10;
+					*pNumBuf++ = argUValue - (tmp * 10) + '0';
+				} while((argUValue = tmp));
+				//copy now....
+				if(--len < 3)goto truncate; //no place for digits
+				do {
+					*p++ = *--pNumBuf;
+					if(--len < 3)goto truncate;
+				} while(pNumBuf != numberBuffer);
+				continue;
+			case 'c': //char
+				*p++ = (char)kvi_va_arg(list,int);
+				--len;
+				continue;
+			default: //a normal percent
+				*p++ = '%';  //write it
+				if(--len < 3)goto truncate; //not enough space for next char
+				if(*fmt){        //this if is just in case that we have a % at the end of the string.
+					*p++ = *fmt; //and write this char
+					--len;
+				}
+				continue;
+		}
+	}
+	//succesfull finish
+	__range_valid(len >= 2);
+	*p++ = '\r';
+	*p   = '\n';
+	return ((p-buffer)+1);
+truncate:
+	__range_valid(len >= 2);
+	*bTruncated = true;
+	*p++ = '\r';
+	*p   = '\n';
+	return ((p-buffer)+1);
+}
+
+#ifndef COMPILE_ix86_ASM
+
+bool kvi_strEqualCS(const char *str1,const char *str2)
+{
+	__range_valid(str1);
+	__range_valid(str2);
+	if( !( str1 && str2 ) ) return false;
+	register unsigned char *s1 = (unsigned char *)str1;
+	register unsigned char *s2 = (unsigned char *)str2;
+	while(*s1)if(*s1++ != *s2++)return false;
+	return (*s1 == *s2);
+}
+
+bool kvi_strEqualCSN(const char *str1,const char *str2,int len)
+{
+	__range_valid(str1);
+	__range_valid(str2);
+	__range_valid(len >= 0);
+	if( !( str1 && str2 && (len >= 0) ) ) return false;
+	register unsigned char *s1 = (unsigned char *)str1;
+	register unsigned char *s2 = (unsigned char *)str2;
+	while(len-- && *s1)if(*s1++ != *s2++)return false;
+	return (len < 0);
+}
+
+#endif
+
+bool kvi_strEqualCIN(const char *str1,const char *str2,int len)
+{
+	__range_valid(str1);
+	__range_valid(str2);
+	__range_valid(len >= 0);
+	if( !( str1 && str2 && (len >= 0) ) ) return false;
+	register unsigned char *s1 = (unsigned char *)str1;
+	register unsigned char *s2 = (unsigned char *)str2;
+	while(len-- && *s1)if(tolower(*s1++) != tolower(*s2++))return false;
+	return (len < 0);
+}
+
+bool kvi_strEqualCI(const char *str1,const char *str2)
+{
+	__range_valid(str1);
+	__range_valid(str2);
+	if( !( str1 && str2) ) return false;
+	register unsigned char *s1 = (unsigned char *)str1;
+	register unsigned char *s2 = (unsigned char *)str2;
+	while(*s1)if(tolower(*s1++) != tolower(*s2++))return false;
+	return (*s1 == *s2);
+}
+
+//note that greater here means that come AFTER in the alphabetic order
+// return < 0 ---> str1 < str2
+// return = 0 ---> str1 = str2
+// return > 0 ---> str1 > str2
+int kvi_strcmpCI(const char *str1,const char *str2)
+{
+	//abcd abce
+	__range_valid(str1);
+	__range_valid(str2);
+	if( !( str1 && str2) ) return false;
+	register unsigned char *s1 = (unsigned char *)str1;
+	register unsigned char *s2 = (unsigned char *)str2;
+	int diff;
+	unsigned char rightchar;
+	while(!(diff=(rightchar=tolower(*s1++)) - tolower(*s2++)))if(!rightchar)break;
+    return diff; //diff is nonzero or end of both was reached (it is positive if *s2 > *s1
+}
+
+//
+////note that greater here means that come AFTER in the alphabetic order
+//// return < 0 ---> str1 < str2
+//// return = 0 ---> str1 = str2
+//// return > 0 ---> str1 > str2
+//int kvi_strcmpCIN(const char *str1,const char *str2,int len)
+//{
+//	//abcd abce
+//	__range_valid(str1);
+//	__range_valid(str2);
+//	register unsigned char *s1 = (unsigned char *)str1;
+//	register unsigned char *s2 = (unsigned char *)str2;
+//	int diff;
+//	unsigned char rightchar;
+//	while(len--)
+//	{
+//		if(!(diff=(rightchar=tolower(*s1++)) - tolower(*s2++)))break;
+//		if(!rightchar)break;
+//	}
+//    return diff; //diff is nonzero or end of both was reached (it is positive if *s2 > *s1
+//}
+
+int kvi_strcmpCS(const char *str1,const char *str2)
+{
+	//abcd abce
+	__range_valid(str1);
+	__range_valid(str2);
+	if( !( str1 && str2) ) return false;
+	register unsigned char *s1 = (unsigned char *)str1;
+	register unsigned char *s2 = (unsigned char *)str2;
+	int diff;
+	while(!(diff=(*s1)-(*s2++)))if(!*s1++)break;
+    return diff; //diff is nonzero or end of both was reached (it is positive if *s2 > *s1
+}
+
+int kvi_strMatchRevCS(const char *str1, const char *str2, int index)
+{
+	__range_valid(str1);
+	__range_valid(str2);
+	if( !( str1 && str2) ) return false;
+	register char *s1=(char *)str1;
+	register char *s2=(char *)str2;
+
+	int curlen=(int)strlen(str1);
+	int diff;
+
+	if (index<0 || index >= curlen) index = curlen-1;
+
+	s1+=index;
+	while (*s2) s2++;
+	s2--;
+
+	// now start comparing
+	while (1){
+		/* in this case, we have str1 = "lo" and str2 = "hello" */
+		if (s1<str1 && !(s2<str2)) return 256;
+		if (s2<str2) return 0;
+		if ((diff=(*s1)-(*s2))) return diff;
+		s1--;
+		s2--;
+	}
+}   
+
+KviStr::KviStr()
+{
+	m_ptr = (char *)kvi_malloc(1);
+	*m_ptr = '\0';
+	m_len = 0;
+}
+
+KviStr::KviStr(const char *str)
+{
+	//Deep copy constructor
+	if(str){
+		//Deep copy
+		m_len = (int)strlen(str);
+		m_ptr = (char *)kvi_malloc(m_len+1);
+		kvi_fastmove(m_ptr,str,m_len+1);
+	} else {
+		m_ptr = (char *)kvi_malloc(1);
+		*m_ptr = '\0';
+		m_len = 0;
+	}
+}
+
+KviStr::KviStr(const KviQCString &str)
+{
+	//Deep copy constructor
+	if(str.data())
+	{
+		//Deep copy
+		m_len = str.length();
+		m_ptr = (char *)kvi_malloc(m_len+1);
+		kvi_fastmove(m_ptr,str,m_len+1);
+	} else {
+		m_ptr = (char *)kvi_malloc(1);
+		*m_ptr = '\0';
+		m_len = 0;
+	}
+}
+
+
+KviStr::KviStr(const char *str,int len)
+{
+	__range_valid(str);
+	//__range_valid(len <= ((int)strlen(str))); <-- we trust the user here (and a strlen() call may run AFTER len if data is not null terminated)
+	__range_valid(len >= 0);
+	m_len = len;
+	m_ptr = (char *)kvi_malloc(m_len+1);
+	kvi_fastmove(m_ptr,str,m_len);
+	*(m_ptr+m_len) = '\0';
+}
+
+KviStr::KviStr(const char *bg,const char *end)
+{
+	__range_valid(bg);
+	__range_valid(end);
+	__range_valid(bg <= end);
+	m_len = end-bg;
+	m_ptr = (char *)kvi_malloc(m_len +1);
+	kvi_fastmove(m_ptr,bg,m_len);
+	*(m_ptr + m_len)='\0';
+}
+
+KviStr::KviStr(KviFormatConstructorTag tag,const char *fmt,...)
+{
+	m_ptr=(char *)kvi_malloc(256);
+	//First try
+	kvi_va_list list;
+	kvi_va_start(list,fmt);
+	//print...with max 256 chars
+	m_len=kvi_vsnprintf(m_ptr,256,fmt,list);
+	kvi_va_end(list);
+
+	//check if we failed
+	if(m_len < 0){
+		//yes , failed....
+		int dummy=256;
+		do{ //we failed , so retry with 256 more chars
+			dummy+=256;
+			//realloc
+			m_ptr=(char *)kvi_realloc(m_ptr,dummy);
+			//print...
+			kvi_va_start(list,fmt);
+			m_len=kvi_vsnprintf(m_ptr,dummy,fmt,list);
+			kvi_va_end(list);
+		} while(m_len < 0);
+	}
+	//done...
+	//now m_len is the length of the written string not including the terminator...
+	//perfect! :)
+	m_ptr=(char *)kvi_realloc(m_ptr,m_len+1);
+}
+
+KviStr::KviStr(const KviStr &str)
+{
+	__range_valid(str.m_ptr);
+	m_len = str.m_len;
+	m_ptr = (char *)kvi_malloc(m_len+1);
+	kvi_fastmove(m_ptr,str.m_ptr,m_len+1);
+}
+
+KviStr::KviStr(const QString &str)
+{
+	KviQCString sz = KviQString::toUtf8(str);
+	if(sz.length() > 0)
+	{
+		m_len = sz.length();
+		m_ptr = (char *)kvi_malloc(m_len+1);
+		kvi_fastmove(m_ptr,sz.data(),m_len+1);
+	} else {
+		m_ptr = (char *)kvi_malloc(1);
+		*m_ptr = '\0';
+		m_len = 0;
+	}
+}
+
+KviStr::KviStr(char c,int fillLen)
+{
+	__range_valid(fillLen >= 0);
+	m_len = fillLen;
+	m_ptr = (char *)kvi_malloc(m_len+1);
+	register char *p=m_ptr;
+	while(fillLen--)*p++=c;
+	*p='\0';
+}
+
+
+KviStr::KviStr(const kvi_wchar_t * unicode)
+{
+	if(!unicode)
+	{
+		m_len = 0;
+		m_ptr = (char *)kvi_malloc(1);
+		*m_ptr = 0;
+	} else {
+		m_len = kvi_wstrlen(unicode);
+		m_ptr = (char *)kvi_malloc(m_len + 1);
+		register char * p = m_ptr;
+		while(*unicode)*p++ = *unicode++;
+		*p = 0;
+	}
+}
+
+KviStr::KviStr(const kvi_wchar_t * unicode,int len)
+{
+	m_len = len;
+	m_ptr = (char *)kvi_malloc(m_len + 1);
+	register char * p = m_ptr;
+	char * end = p + len;
+	while(p != end)
+	{
+		*p++ = *unicode++;
+	}
+	*p = 0;
+}
+
+
+
+
+KviStr::~KviStr()
+{
+	kvi_free(m_ptr);
+}
+
+void KviStr::setLength(int iLen)
+{
+	__range_valid(iLen >= 0);
+	m_len = iLen;
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+	*(m_ptr + m_len) = '\0';
+}
+
+KviStr & KviStr::operator=(const KviStr &str)
+{
+	__range_valid(str.m_ptr);
+	__range_valid(str.m_ptr != m_ptr);
+	m_len = str.m_len;
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+	kvi_fastmove(m_ptr,str.m_ptr,m_len+1);
+	return (*this);
+}
+
+KviStr & KviStr::operator=(const KviQCString &str)
+{
+	m_len = str.length();
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+	if(str.data())kvi_fastmove(m_ptr,str.data(),m_len+1);
+	else *m_ptr = 0;
+	return (*this);
+}
+
+KviStr & KviStr::operator=(const char *str)
+{
+	//__range_valid(str);
+	if(str){
+		m_len = (int)strlen(str);
+		m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+		kvi_memmove(m_ptr,str,m_len+1);
+	} else {
+		m_ptr = (char *)kvi_realloc(m_ptr,1);
+		*m_ptr = '\0';
+		m_len = 0;
+	}
+	return (*this);
+}
+
+void KviStr::clear()
+{
+	m_ptr = (char *)kvi_realloc(m_ptr,1);
+	*m_ptr = '\0';
+	m_len = 0;
+}
+
+
+bool KviStr::hasNonWhiteSpaceData() const
+{
+	const char * aux = m_ptr;
+	while(*aux)
+	{
+		if(((*aux) != ' ') && ((*aux) != '\t'))return true;
+		aux++;
+	}
+	return false;
+}
+
+static char hexdigits[16] = { '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f' };
+
+void KviStr::bufferToHex(const char *buffer,int len)
+{
+	__range_valid(buffer);
+	m_len = (len * 2);
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len + 1);
+	char * aux = m_ptr;
+	while(len)
+	{
+		*aux = hexdigits[(unsigned int)(((unsigned char)(*buffer)) / 16)];
+		aux++;
+		*aux = hexdigits[(unsigned int)(((unsigned char)(*buffer)) % 16)];
+		aux++;
+		len--;
+		buffer++;
+	}
+	*(m_ptr+m_len) = '\0';
+}
+
+
+
+static char get_decimal_from_hex_digit_char(char dgt)
+{
+	if((dgt >= '0') && (dgt <= '9'))return (dgt - '0');
+	if((dgt >= 'A') && (dgt <= 'F'))return (10 + (dgt - 'A'));
+	if((dgt >= 'a') && (dgt <= 'f'))return (10 + (dgt - 'a'));
+	return -1;
+}
+
+// This is just error-correcting...it treats non hex stuff as zeros
+/*
+static inline char get_decimal_from_hex_digit_char(char dgt)
+{
+	char c = pedantic_get_decimal_from_hex_digit(dgt);
+	if(c == -1)return 0;
+	return c;
+}
+
+int KviStr::hexToBuffer(char ** buffer,bool bNullToNewlines)
+{
+	int len;
+	if(m_len % 2)len = (m_len / 2) + 1;
+	else len = (m_len / 2);
+	*buffer = (char *)kvi_malloc(len);
+
+	char * ptr = *buffer;
+
+	char * aux = m_ptr;
+	while(*aux)
+	{
+		*ptr = get_decimal_from_hex_digit_char(*aux) * 16;
+		aux++;
+		if(*aux)
+		{
+			*ptr += get_decimal_from_hex_digit_char(*aux);
+			aux++;
+		}
+		if(bNullToNewlines)if(!(*ptr))*ptr = '\n';
+		ptr++;
+	}
+	return len;
+}
+*/
+
+int KviStr::hexToBuffer(char ** buffer,bool bNullToNewlines)
+{
+	*buffer = 0;
+	if((m_len == 0) || (m_len & 1))return -1; // this is an error
+	int len = (m_len / 2);
+	if(len < 1)return -1;
+	*buffer = (char *)kvi_malloc(len);
+
+	char * ptr = *buffer;
+	char * aux = m_ptr;
+
+	char aux2;
+
+	while(*aux)
+	{
+		*ptr = get_decimal_from_hex_digit_char(*aux) * 16;
+		if(*ptr == -1)
+		{
+			kvi_free(*buffer);
+			*buffer = 0;
+			return -1;
+		}
+		aux++;
+		aux2 = get_decimal_from_hex_digit_char(*aux);
+		if(aux2 == -1)
+		{
+			kvi_free(*buffer);
+			*buffer = 0;
+			return -1;
+		}
+		*ptr += aux2;
+		aux++;
+		if(bNullToNewlines)if(!(*ptr))*ptr = '\n';
+		ptr++;
+	}
+	return len;
+}
+
+static const char * base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+
+void KviStr::bufferToBase64(const char * buffer,int len)
+{
+	m_len = (len / 3) << 2;
+	if(len % 3)m_len += 4;
+
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len + 1);
+
+	unsigned char aux1,aux2,aux3;
+	char * aux_ptr = m_ptr;
+	while(len > 2)
+	{
+		aux1 = (unsigned char)*buffer++;
+		aux2 = (unsigned char)*buffer++;
+		aux3 = (unsigned char)*buffer++;
+		*aux_ptr++ = base64_chars[(aux1 & 0xFC) >> 2];
+		*aux_ptr++ = base64_chars[((aux1 & 0x03) << 4) | ((aux2 & 0xF0) >> 4)];
+		*aux_ptr++ = base64_chars[((aux2 & 0x0F) << 2) | ((aux3 & 0xC0) >> 6)];
+		*aux_ptr++ = base64_chars[(aux3 & 0x3F)];
+		len -= 3;
+	}
+	switch(len)
+	{
+		case 2:
+			aux1 = (unsigned char)*buffer++;
+			aux2 = (unsigned char)*buffer++;
+			*aux_ptr++ = base64_chars[(aux1 & 0xFC) >> 2];
+			*aux_ptr++ = base64_chars[((aux1 & 0x03) << 4) | ((aux2 & 0xF0) >> 4)];
+			*aux_ptr++ = base64_chars[((aux2 & 0x0F) << 2)];
+			*aux_ptr++ = '=';
+		break;
+		case 1:
+			aux1 = (unsigned char)*buffer++;
+			aux2 = (unsigned char)*buffer++;
+			*aux_ptr++ = base64_chars[(aux1 & 0xFC) >> 2];
+			*aux_ptr++ = base64_chars[((aux1 & 0x03) << 4)];
+			*aux_ptr++ = '=';
+			*aux_ptr++ = '=';
+		break;
+	}
+	*aux_ptr = 0;
+}
+
+static unsigned char get_base64_idx(char base64)
+{
+	if((base64 >= 'A') && (base64 <= 'Z'))return (base64 - 'A');
+	if((base64 >= 'a') && (base64 <= 'z'))return ((base64 - 'a') + 26);
+	if((base64 >= '0') && (base64 <= '9'))return ((base64 - '0') + 52);
+	if(base64 == '+')return 62;
+	if(base64 == '/')return 63;
+	if(base64 == '=')return 64;
+	return 65;
+}
+
+
+int KviStr::base64ToBuffer(char ** buffer,bool bNullToNewlines)
+{
+	*buffer = 0;
+	if((m_len == 0) || (m_len & 3))return -1; // this is an error
+	int len = (m_len >> 2) * 3;
+	*buffer = (char *)kvi_malloc(len);
+
+	char * auxBuf = *buffer;
+
+	unsigned char aux1,aux2,aux3,aux4;
+	char * aux_ptr = m_ptr;
+
+	int newLen = len;
+
+	while(*aux_ptr)
+	{
+		if(newLen != len)
+		{
+			// ops... there was a padding and we still have chars after it
+			// this is an error
+			kvi_free(*buffer);
+			*buffer = 0;
+			return -1;
+		}
+		aux1 = get_base64_idx(*aux_ptr++);
+		aux2 = get_base64_idx(*aux_ptr++);
+		aux3 = get_base64_idx(*aux_ptr++);
+		aux4 = get_base64_idx(*aux_ptr++);
+		if((aux3 > 64) || (aux4 > 64))
+		{
+			// error
+			kvi_free(*buffer);
+			*buffer = 0;
+			return -1;
+		}
+		if((aux1 | aux2) > 63)
+		{
+			// again error...impossible padding
+			kvi_free(*buffer);
+			*buffer = 0;
+			return -1;
+		}
+		if(aux4 == 64)
+		{
+			if(aux3 == 64)
+			{
+				// Double padding, only one digit here
+				*auxBuf++ = (char)((aux1 << 2) | (aux2 >> 4));
+				newLen -= 2;
+			} else {
+				// Single padding, two digits here
+				*auxBuf++ = (char)((aux1 << 2) | (aux2 >> 4)); // >> 4 is a shr , not a ror! :)
+				*auxBuf++ = (char)((aux2 << 4) | (aux3 >> 2));
+				newLen -= 1;
+			}
+		} else {
+			if(aux3 == 64)
+			{
+				// error... impossible padding
+				kvi_free(*buffer);
+				*buffer = 0;
+				return -1;
+			} else {
+				// Ok , no padding, three digits here
+				*auxBuf++ = (char)((aux1 << 2) | (aux2 >> 4));
+				*auxBuf++ = (char)((aux2 << 4) | (aux3 >> 2));
+				*auxBuf++ = (char)((aux3 << 6) | aux4);
+			}
+		}
+	}
+
+	if(newLen != len)*buffer = (char *)kvi_realloc(*buffer,newLen);
+	return newLen;
+}
+
+KviStr & KviStr::setStr(const char *str,int len)
+{
+	if(!str)
+	{
+		clear();
+		return *this;
+	}
+	int alen = (int)strlen(str);
+	if((len < 0) || (len > alen))m_len = alen;
+	else m_len = len;
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+	kvi_memmove(m_ptr,str,m_len);
+	*(m_ptr+m_len) = '\0';
+	return (*this);
+}
+
+KviStr & KviStr::operator=(const QString &str)
+{
+	KviQCString sz = KviQString::toUtf8(str);
+	if(sz.length() > 0){
+		m_len = sz.length();
+		m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+		kvi_fastmove(m_ptr,sz.data(),m_len+1);
+	} else {
+		m_ptr = (char *)kvi_realloc(m_ptr,1);
+		*m_ptr = '\0';
+		m_len = 0;
+	}
+	return (*this);
+}
+
+KviStr & KviStr::operator=(char c)
+{
+	m_len = 1;
+	m_ptr = (char *)kvi_realloc(m_ptr,2);
+	*m_ptr = c;
+	*(m_ptr+1)='\0';
+	return (*this);
+}
+
+void KviStr::append(char c)
+{
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+2);
+	*(m_ptr+m_len)=c;
+	m_len++;
+	*(m_ptr+m_len)='\0';
+}
+
+void KviStr::append(const KviStr &str)
+{
+	__range_valid(str.m_ptr);
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+str.m_len+1);
+	kvi_fastmove((m_ptr+m_len),str.m_ptr,str.m_len+1);
+	m_len += str.m_len;
+}
+
+void KviStr::append(const char *str)
+{
+	if(!str)return;
+	int len = (int)strlen(str);
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+len+1);
+	kvi_fastmove((m_ptr+m_len),str,len+1);
+	m_len += len;
+}
+
+void KviStr::append(const QString &str)
+{
+	KviQCString sz = KviQString::toUtf8(str);
+	if(sz.length() < 1)return;
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+sz.length()+1);
+	kvi_fastmove((m_ptr+m_len),sz.data(),sz.length()+1);
+	m_len += sz.length();
+}
+
+void KviStr::append(const char *str,int len)
+{
+	__range_valid(str);
+//	__range_valid(len <= ((int)strlen(str)));
+	__range_valid(len >= 0);
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+len+1);
+	kvi_fastmove((m_ptr+m_len),str,len);
+	m_len += len;
+	*(m_ptr + m_len)='\0';
+}
+
+void KviStr::append(KviFormatConstructorTag tag,const char *fmt,...)
+{
+	int auxLen;
+	m_ptr=(char *)kvi_realloc(m_ptr,m_len + 256);
+	//First try
+	kvi_va_list list;
+	kvi_va_start(list,fmt);
+	//print...with max 256 chars
+	auxLen =kvi_vsnprintf(m_ptr + m_len,256,fmt,list);
+	kvi_va_end(list);
+
+	//check if we failed
+	if(auxLen < 0){
+		//yes , failed....
+		int dummy=256;
+		do{ //we failed , so retry with 256 more chars
+			dummy+=256;
+			//realloc
+			m_ptr=(char *)kvi_realloc(m_ptr,m_len + dummy);
+			//print...
+			kvi_va_start(list,fmt);
+			auxLen=kvi_vsnprintf(m_ptr + m_len,dummy,fmt,list);
+			kvi_va_end(list);
+		} while(auxLen < 0);
+	}
+	m_len += auxLen;
+	//done...
+	//now m_len is the length of the written string not including the terminator...
+	//perfect! :)
+	m_ptr=(char *)kvi_realloc(m_ptr,m_len+1);
+}
+
+void KviStr::extractFromString(const char *begin,const char *end)
+{
+	__range_valid(begin);
+	__range_valid(end);
+	__range_valid(end >= begin);
+	m_len = end-begin;
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+	kvi_fastmove(m_ptr,begin,m_len);
+	*(m_ptr + m_len)='\0';
+}
+
+void KviStr::prepend(const KviStr &str)
+{
+	__range_valid(str.m_ptr);
+	__range_valid(str.m_ptr != m_ptr);
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+str.m_len+1);
+	kvi_memmove((m_ptr+str.m_len),m_ptr,m_len+1); //move self
+	kvi_fastmove(m_ptr,str.m_ptr,str.m_len);
+	m_len += str.m_len;
+}
+
+void KviStr::prepend(const char *str)
+{
+	if(!str)return;
+	int len = (int)strlen(str);
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+len+1);
+	kvi_memmove((m_ptr+len),m_ptr,m_len+1); //move self
+	kvi_fastmove(m_ptr,str,len);
+	m_len += len;
+}
+
+void KviStr::prepend(const char *str,int len)
+{
+	__range_valid(str);
+	__range_valid(len <= ((int)strlen(str)));
+	__range_valid(len >= 0);
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+len+1);
+	kvi_memmove((m_ptr+len),m_ptr,m_len+1); //move self
+	kvi_fastmove(m_ptr,str,len);
+	m_len += len;
+}
+
+unsigned char iso88591_toUpper_map[256]=
+{
+	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+	0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+	0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+	0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
+	0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
+	0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+	0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+	0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+	0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+	0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+	0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
+	0x60, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+	0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+	0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+	0x58, 0x59, 0x5a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
+	0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+	0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+	0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+	0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+	0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+	0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+	0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+	0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+	0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+	0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+	0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+	0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+	0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+	0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+	0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
+	0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
+};
+
+void KviStr::toUpperISO88591()
+{
+	register char *p=m_ptr;
+	while(*p)
+	{
+		*p=(char)iso88591_toUpper_map[(unsigned char)*p];
+		p++;
+	}
+}
+
+void KviStr::toUpper()
+{
+	register char *p=m_ptr;
+	while(*p)
+	{
+		*p=toupper(*p);
+		p++;
+	}
+}
+
+unsigned char iso88591_toLower_map[256]=
+{
+	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+	0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+	0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+	0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
+	0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
+	0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+	0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+	0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
+	0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
+	0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
+	0x78, 0x79, 0x7a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
+	0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
+	0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
+	0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
+	0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
+	0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+	0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+	0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+	0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+	0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+	0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+	0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+	0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+	0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+	0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+	0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+	0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+	0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+	0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+	0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
+	0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
+};
+
+void KviStr::toLowerISO88591()
+{
+	register char *p=m_ptr;
+	while(*p)
+	{
+		*p=(char)iso88591_toLower_map[(unsigned char)*p];
+		p++;
+	}
+}
+
+
+void KviStr::toLower()
+{
+	register char *p=m_ptr;
+	while(*p)
+	{
+		*p=tolower(*p);
+		p++;
+	}
+}
+
+KviStr KviStr::upper() const
+{
+	KviStr tmp(*this);
+	tmp.toUpper();
+	return tmp;
+}
+
+KviStr KviStr::upperISO88591() const
+{
+	KviStr tmp(*this);
+	tmp.toUpperISO88591();
+	return tmp;
+}
+
+KviStr KviStr::lower() const
+{
+	KviStr tmp(*this);
+	tmp.toLower();
+	return tmp;
+}
+
+KviStr KviStr::lowerISO88591() const
+{
+	KviStr tmp(*this);
+	tmp.toLowerISO88591();
+	return tmp;
+}
+
+KviStr KviStr::left(int maxLen) const
+{
+	if(maxLen <= 0)
+	{
+		KviStr empty;
+		return empty;
+	}
+	if(maxLen > m_len)maxLen=m_len;
+	KviStr str(m_ptr,maxLen);
+	return str;
+}
+
+KviStr KviStr::right(int maxLen) const
+{
+	if(maxLen <= 0)
+	{
+		KviStr empty;
+		return empty;
+	}
+	if(maxLen > m_len)maxLen=m_len;
+	KviStr str((m_ptr+(m_len-maxLen)),maxLen);
+	return str;
+}
+
+KviStr KviStr::middle(int idx,int maxLen) const
+{
+	__range_valid(maxLen >= 0);
+	__range_valid(idx >= 0);
+	if((maxLen <= 0) || (idx < 0)){ //max len negative...invalid params
+		KviStr ret;
+		return ret;
+	}
+	if((maxLen + idx) <= m_len){ //valid params
+		KviStr str(m_ptr+idx,maxLen);
+		return str;
+	}
+	if(idx < m_len){ //string shorter than requested
+		KviStr str(m_ptr+idx);
+		return str;
+	}
+	// idx out of bounds
+	KviStr ret;
+	return ret;
+}
+
+KviStr ** KviStr::splitToArray(char sep,int max,int * realCount) const
+{
+	KviStr ** strings = (KviStr **)kvi_malloc(sizeof(KviStr *));
+	int number = 0;
+	char * ptr = m_ptr;
+	char * last = ptr;
+	while((max > 0) && *ptr)
+	{
+		strings = (KviStr **)kvi_realloc((void *)strings,sizeof(KviStr *) * (number + 2));
+		if(max > 1)
+		{
+			while(*ptr && (*ptr != sep))ptr++;
+			strings[number] = new KviStr(last,ptr - last);
+		} else {
+			strings[number] = new KviStr(ptr);
+		}
+		number++;
+		max--;
+		if(*ptr)
+		{
+			ptr++;
+			last = ptr;
+		}
+	}
+	if(realCount)*realCount = number;
+	strings[number] = 0;
+	return strings;
+}
+/*
+	WORKING BUT UNUSED
+
+KviStr ** KviStr::splitToArray(const char * sep,int max,int * realCount) const
+{
+	KviStr ** strings = (KviStr **)kvi_malloc(sizeof(KviStr *));
+	KviStr tmp = *this;
+	int idx = tmp.findFirstIdx(sep);
+	int number = 0;
+	int seplen = kvi_strLen(sep);
+
+
+	while(idx != -1)
+	{
+		strings = (KviStr **)kvi_realloc(sizeof(KviStr *) * (number + 2));
+		strings[number] = new KviStr(tmp.ptr(),idx);
+		tmp.cutLeft(idx + seplen);
+		number++;
+		idx = tmp.findFirstIdx(sep);
+	}
+
+	if(tmp.hasData())
+	{
+		strings = (KviStr **)kvi_realloc(sizeof(KviStr *) * (number + 2));
+		strings[number] = new KviStr(tmp);
+		number++;
+	}
+
+	if(realCount)*realCount = number;
+	strings[number] = 0;
+	return strings;
+}
+*/
+void KviStr::freeArray(KviStr ** strings)
+{
+	if(!strings)return;
+	KviStr ** aux = strings;
+	while(*aux)
+	{
+		delete (*aux); // delete (KviStr *)
+		aux++;
+	}
+	kvi_free(strings);
+}
+
+void KviStr::freeBuffer(char * buffer)
+{
+	if(!buffer)return;
+	kvi_free(buffer);
+}
+
+void KviStr::joinFromArray(KviStr ** strings,const char * sep,bool bLastSep)
+{
+	setLen(0);
+	if(!strings)return;
+
+	while(*strings)
+	{
+		append(*(*strings));
+		strings++;
+		if(*strings)
+		{
+			if(sep)append(sep);
+		} else {
+			if(sep && bLastSep)append(sep);
+		}
+	}
+}
+
+KviStr & KviStr::insert(int idx,const char *data)
+{
+	__range_valid(data);
+	if(idx <= m_len){
+		int len = (int)strlen(data);
+		m_ptr = (char *)kvi_realloc(m_ptr,m_len+len+1);
+		kvi_memmove(m_ptr+idx+len,m_ptr+idx,(m_len - idx)+1);
+		kvi_fastmove(m_ptr+idx,data,len);
+		m_len+=len;
+	}
+	return (*this);
+}
+
+KviStr & KviStr::insert(int idx,char c)
+{
+	if(idx <= m_len){
+		m_ptr = (char *)kvi_realloc(m_ptr,m_len+2);
+		kvi_memmove(m_ptr+idx+1,m_ptr+idx,(m_len - idx)+1);
+		m_len++;
+		*(m_ptr + idx) = c;
+	}
+	return (*this);
+}
+
+// FIXME: #warning "Double check the following two functions !!!"
+
+KviStr & KviStr::hexEncodeWithTable(const unsigned char table[256])
+{
+	char * aux = m_ptr;
+	char * begin = m_ptr;
+
+	char * n  = 0;
+	int curSize = 0;
+
+	while(*aux)
+	{
+		if(table[*((unsigned char *)aux)] || (*aux == '%'))
+		{
+			int len = aux - begin;
+			n = (char *)kvi_realloc(n,curSize + len + 3);
+			kvi_memmove(n + curSize,begin,len);
+			curSize += len;
+
+			n[curSize] = '%';
+			curSize++;
+			n[curSize] = hexdigits[(unsigned int)(((unsigned char)(*aux)) / 16)];
+			curSize++;
+			n[curSize] = hexdigits[(unsigned int)(((unsigned char)(*aux)) % 16)];
+			curSize++;
+
+			aux++;
+			begin = aux;
+
+		} else aux++;
+	}
+
+	int len = aux - begin;
+	n = (char *)kvi_realloc(n,curSize + len + 1);
+	kvi_memmove(n + curSize,begin,len);
+	curSize += len;
+
+	n[curSize] = '\0';
+
+	kvi_free((void *)m_ptr);
+	m_ptr = n;
+	m_len = curSize;
+
+	return (*this);
+}
+
+KviStr & KviStr::hexEncodeWhiteSpace()
+{
+	static unsigned char ascii_jump_table[256]=
+	{
+		//	000 001 002 003 004 005 006 007   008 009 010 011 012 013 014 015 
+		//	NUL SOH STX ETX EOT ENQ ACK BEL   BS  HT  LF  VT  FF  CR  SO  SI
+			1  ,1  ,1  ,1  ,1  ,1  ,1  ,1    ,1  ,1  ,1  ,1  ,1  ,1  ,1  ,1  ,
+		//	016 017 018 019 020 021 022 023   024 025 026 027 028 029 030 031 
+		//	DLE DC1 DC2 DC3 DC4 NAK SYN ETB   CAN EM  SUB ESC FS  GS  RS  US
+			1  ,1  ,1  ,1  ,1  ,1  ,1  ,1    ,1  ,1  ,1  ,1  ,1  ,1  ,1  ,1  ,
+		//	032 033 034 035 036 037 038 039   040 041 042 043 044 045 046 047 
+		//	    !   "   #   $   %   &   '     (   )   *   +   ,   -   .   /   
+			1  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+		//	048 049 050 051 052 053 054 055   056 057 058 059 060 061 062 063 
+		//	0   1   2   3   4   5   6   7     8   9   :   ;   <   =   >   ?   
+			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+		//	064 065 066 067 068 069 070 071   072 073 074 075 076 077 078 079 
+		//	@   A   B   C   D   E   F   G     H   I   J   K   L   M   N   O   
+			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+		//	080 081 082 083 084 085 086 087   088 089 090 091 092 093 094 095 
+		//	P   Q   R   S   T   U   V   W     X   Y   Z   [   \   ]   ^   _   
+			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+		//	096 097 098 099 100 101 102 103   104 105 106 107 108 109 110 111 
+		//	`   a   b   c   d   e   f   g     h   i   j   k   l   m   n   o   
+			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+		//	112 113 114 115 116 117 118 119   120 121 122 123 124 125 126 127 
+		//	p   q   r   s   t   u   v   w     x   y   z   {   |   }   ~      
+			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+		//	128 129 130 131 132 133 134 135   136 137 138 139 140 141 142 143 
+		//	                                                  
+			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+		//	144 145 146 147 148 149 150 151   152 153 154 155 156 157 158 159 
+		//	                                                  
+			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+		//	160 161 162 163 164 165 166 167   168 169 170 171 172 173 174 175 
+		//	                                                  
+			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+		//	176 177 178 179 180 181 182 183   184 185 186 187 188 189 190 191 
+		//	                                                  
+			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+		//	192 193 194 195 196 197 198 199   200 201 202 203 204 205 206 207 
+		//	�  �  �  �  �  �  �  �    �  �  �  �  �  �  �  �  
+			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+		//	208 209 210 211 212 213 214 215   216 217 218 219 220 221 222 223 
+		//	�  �  �  �  �  �  �  �    �  �  �  �  �  �  �  �  
+			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+		//	224 225 226 227 228 229 230 231   232 233 234 235 236 237 238 239 
+		//	�  �  �  �  �  �  �  �    �  �  �  �  �  �  �  �  
+			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+		//	240 241 242 243 244 245 246 247   248 249 250 251 252 253 254 255 
+		//	�  �  �  �  �  �  �  �                            
+			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0
+	};
+
+	return hexEncodeWithTable(ascii_jump_table);
+}
+
+KviStr & KviStr::hexDecode(const char * pFrom)
+{
+	// WARNING: pFrom can be also m_ptr here!
+	const char * aux = pFrom;
+	const char * begin = pFrom;
+
+	char * n  = 0;
+	int curSize = 0;
+
+	while(*aux)
+	{
+		if(*aux == '%')
+		{
+			// move last block
+			int len = aux - begin;
+			n = (char *)kvi_realloc(n,curSize + len + 1);
+			kvi_memmove(n + curSize,begin,len);
+			curSize += len;
+
+			// get the hex code
+			aux++;
+
+			char theChar = get_decimal_from_hex_digit_char(*aux);
+			if(theChar < 0)
+			{
+				n[curSize] = '%'; // wrong code...just a '%'
+				curSize++;
+			} else {
+				aux++;
+				char theChar2 = get_decimal_from_hex_digit_char(*aux);
+				if(theChar2 < 0)
+				{
+					// wrong code...just a '%' and step back
+					n[curSize] = '%';
+					curSize++;
+					aux--;
+				} else {
+					n[curSize] = (theChar * 16) + theChar2;
+					curSize++;
+					aux++;
+				}
+			}
+
+			begin = aux;
+
+		} else aux++;
+	}
+
+	int len = aux - begin;
+	n = (char *)kvi_realloc(n,curSize + len + 2);
+	kvi_memmove(n + curSize,begin,len);
+	curSize += len;
+	n[curSize] = '\0';
+
+	kvi_free((void *)m_ptr);
+	m_ptr = n;
+	m_len = curSize;
+
+	return (*this);
+}
+
+KviStr & KviStr::replaceAll(char c,const char *str)
+{
+	int idx = findFirstIdx(c);
+	KviStr tmp;
+	while(idx >= 0){
+		if(idx > 0)tmp += left(idx);
+		cutLeft(idx+1);
+		tmp.append(str);
+		idx = findFirstIdx(c);
+	}
+	tmp.append(*this);
+	// Now copy
+	m_len = tmp.m_len;
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+	kvi_fastmove(m_ptr,tmp.m_ptr,m_len+1);
+	return (*this);
+}
+
+KviStr & KviStr::replaceAll(char *toFind,const char *str,bool bCaseS)
+{
+	int len = (int)strlen(toFind);
+	int idx = findFirstIdx(toFind,bCaseS);
+	KviStr tmp;
+	while(idx >= 0)
+	{
+		if(idx > 0)tmp += left(idx);
+		cutLeft(idx+len);
+		tmp.append(str);
+		idx = findFirstIdx(toFind,bCaseS);
+	}
+	tmp.append(*this);
+	// Now copy
+	m_len = tmp.m_len;
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+	kvi_fastmove(m_ptr,tmp.m_ptr,m_len+1);
+	return (*this);
+}
+
+KviStr & KviStr::transliterate(const char * szToFind,const char * szReplacement)
+{
+	while(*szToFind && *szReplacement)
+	{
+		char * p = m_ptr;
+		while(*p)
+		{
+			if(*p == *szToFind)*p = *szReplacement;
+			++p;
+		}
+		++szToFind;
+		++szReplacement;
+	}
+	return (*this);
+}
+
+
+int KviStr::occurences(char c,bool caseS) const
+{
+	register char *p = m_ptr;
+	int cnt=0;
+	if(caseS){
+		while(*p){
+			if(*p == c)cnt++;
+			p++;
+		}
+	} else {
+		char b=tolower(c);
+		while(*p){
+			if(tolower(*p) == b)cnt++;
+			p++;
+		}
+	}
+	return cnt;
+}
+
+int KviStr::occurences(const char *str,bool caseS) const
+{
+	__range_valid(str);
+	register char *p = m_ptr;
+	int cnt=0;
+	int len = (int)strlen(str);
+	if(caseS){
+		while(*p){
+			if(*p == *str){
+				if(kvi_strEqualCSN(p,str,len))cnt++;
+			}
+			p++;
+		}
+	} else {
+		while(*p){
+			char c = tolower(*str);
+			if(tolower(*p) == c){
+				if(kvi_strEqualCIN(p,str,len))cnt++;
+			}
+			p++;
+		}
+	}
+	return cnt;
+}
+
+bool KviStr::contains(char c,bool caseS) const
+{
+	register char *p = m_ptr;
+	if(caseS)
+	{
+		while(*p)
+		{
+			if(*p == c)return true;
+			p++;
+		}
+	} else {
+		char b=tolower(c);
+		while(*p)
+		{
+			if(tolower(*p) == b)return true;
+			p++;
+		}
+	}
+	return false;
+}
+
+bool KviStr::contains(const char *str,bool caseS) const
+{
+	__range_valid(str);
+	register char *p = m_ptr;
+	int len = (int)strlen(str);
+	if(caseS)
+	{
+		while(*p)
+		{
+			if(*p == *str)
+			{
+				if(kvi_strEqualCSN(p,str,len))return true;
+			}
+			p++;
+		}
+	} else {
+		while(*p)
+		{
+			char c = tolower(*str);
+			if(tolower(*p) == c)
+			{
+				if(kvi_strEqualCIN(p,str,len))return true;
+			}
+			p++;
+		}
+	}
+	return false;
+}
+
+
+KviStr & KviStr::setNum(long num)
+{
+	char numberBuffer[30];
+	bool bNegative = false;
+	long tmp;
+	register char *p;
+	register char *pNumBuf = numberBuffer;
+
+	// somebody can explain me why 	-(-2147483648) = -2147483648 ? (2^31)
+	// it is like signed char x = 128 ---> 10000000 that is signed -0 (!?)
+	// mmmmh...or it is assumed to be -128 (a number rappresentation exception)
+	// at least on my machine it happens...
+
+	// found the solution by myself today...
+	//
+	// ABS(3)              Linux Programmer's Manual              ABS(3)
+	// NAME
+	//        abs - computes the absolute value of an integer.
+	// ...
+	// DESCRIPTION
+	//        The abs() function computes the absolute value of the integer argument j.
+	// RETURN VALUE
+	//        Returns the absolute value of the integer argument.
+	// CONFORMING TO
+	//        SVID 3, POSIX, BSD 4.3, ISO 9899
+	// NOTE ##################################################################################
+	//        Trying to take the absolute value of the most negative integer is not defined.
+	// #######################################################################################
+
+	// so should i use temporaneous doubles to make calculations ?
+
+	if(num < 0){ //negative integer
+		bNegative = true;
+		num = -num; //need to have it positive
+		if(num < 0){ // 2^31 exception
+			// We need to avoid absurd responses like ".(./),." :)
+			num = 0; // we get a negative zero here...it is still an exception
+		}
+	}
+
+	//write the number in a temporary buffer (at least '0')
+	do {
+		tmp = num / 10;
+		*pNumBuf++ = num - (tmp * 10) + '0';
+	} while((num = tmp));
+
+	//copy now....
+	m_len = pNumBuf - numberBuffer; //length of the number string
+	if(bNegative){
+		m_len++;
+		m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+		p=m_ptr;
+		*p++='-';
+	} else {
+		m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+		p=m_ptr;
+	}
+	do { *p++ = *--pNumBuf; } while(pNumBuf != numberBuffer);
+	*(m_ptr + m_len)='\0';
+	return (*this);
+}
+
+KviStr & KviStr::setNum(unsigned long num)
+{
+	char numberBuffer[30];
+	unsigned long tmp;
+	register char *p;
+	register char *pNumBuf = numberBuffer;
+
+	//write the number in a temporary buffer (at least '0')
+	do {
+		tmp = num / 10;
+		*pNumBuf++ = num - (tmp * 10) + '0';
+	} while((num = tmp));
+
+	//copy now....
+	m_len = pNumBuf - numberBuffer; //length of the number string
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+	p=m_ptr;
+	do { *p++ = *--pNumBuf; } while(pNumBuf != numberBuffer);
+	*(m_ptr + m_len)='\0';
+	return (*this);
+}
+
+long KviStr::toLong(bool *bOk) const
+{
+	long result = 0;
+	if(bOk)*bOk = false;
+	register char *p=m_ptr;
+	bool bNeg = false;
+	while(isspace(*p))p++; //skip spaces
+	if(*p == '-'){
+		bNeg = true;
+		p++;
+	} else {
+		if(*p == '+')p++;
+	}
+	if(isdigit(*p)){                      //point to something interesting ?
+		do{
+			result = (result * 10) + (*p - '0');
+			p++;
+		} while(isdigit(*p));
+		if(bNeg)result = -result;
+		while(isspace(*p))p++;        //skip trailing spaces
+		if(*p)return 0;               //if this is not the end...die.
+		if(bOk)*bOk = true;
+		return result;
+	}
+	return 0;
+}
+
+unsigned long KviStr::toULong(bool *bOk) const
+{
+	unsigned long result = 0;
+	if(bOk)*bOk = false;
+	register char *p=m_ptr;
+	while(isspace(*p))p++; //skip spaces
+	if(isdigit(*p)){                      //point to something interesting ?
+		do{
+			result = (result * 10) + (*p - '0');
+			p++;
+		} while(isdigit(*p));
+		while(isspace(*p))p++;        //skip trailing spaces
+		if(*p)return 0;               //if this is not the end...die.
+		if(bOk)*bOk = true;
+		return result;
+	}
+	return 0;
+}
+
+long KviStr::toLongExt(bool *bOk,int base)
+{
+	if(m_len == 0){
+		if(bOk)*bOk = false;
+		return 0;
+	}
+	char * endptr;
+	long result = strtol(m_ptr,&endptr,base);
+	if(*endptr){
+		// must be whitespaces , otherwise there is trailing garbage inside
+		while(isspace(*endptr) && (*endptr))endptr++;
+		if(*endptr){
+			// still not at the end
+			// trailing garbage not allowed
+			if(bOk)*bOk = false;
+			return result;
+		}
+	}
+	if(bOk)*bOk = true;
+	return result;
+}
+
+//
+//working code , but unused in kvirc
+//
+//unsigned long KviStr::toULongExt(bool *bOk = 0,int base = 0)
+//{
+//	if(m_len == 0){
+//		if(bOk)*bOk = false;
+//		return 0;
+//	}
+//	char * endptr;
+//	unsigned long result = strtoul(m_ptr,&endptr,base);
+//	if(*endptr != '\0'){
+//		if(bOk)*bOk = false;
+//	}
+//	return result;	
+//}
+
+KviStr & KviStr::cutLeft(int len)
+{
+	__range_valid(len >= 0);
+	if(len <= m_len){
+		m_len -= len;
+		kvi_memmove(m_ptr,m_ptr+len,m_len+1);
+		m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+	} else {
+		m_ptr = (char *)kvi_realloc(m_ptr,1);
+		*m_ptr = '\0';
+		m_len = 0;
+	}
+	return (*this);
+}
+
+KviStr & KviStr::cutRight(int len)
+{
+	__range_valid(len >= 0);
+	if(len <= m_len){
+		m_len -= len;
+		m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+		*(m_ptr +m_len)='\0';
+	} else {
+		m_ptr = (char *)kvi_realloc(m_ptr,1);
+		*m_ptr = '\0';
+		m_len = 0;
+	}
+	return (*this);
+}
+
+KviStr & KviStr::cut(int idx,int len)
+{
+	__range_valid(idx >= 0);
+	__range_valid(len >= 0);
+	if(idx < m_len){
+		// idx = 3 len = 3 m_len = 10
+		// 0123456789
+		// abcdefghij
+		//    ^  ^
+		//   p1  p2
+		char * p1 = m_ptr+idx;
+		if(len + idx > m_len)len = m_len - idx;
+		char * p2 = p1+len;
+		kvi_memmove(p1,p2,(m_len - (len+idx)) +1);
+		m_len -= len;
+		m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+	}
+	return (*this);
+}
+
+KviStr & KviStr::cutToFirst(char c,bool bIncluded)
+{
+	int idx = findFirstIdx(c);
+	if(idx != -1)cutLeft(bIncluded ? idx + 1 : idx);
+	return (*this);
+}
+
+KviStr KviStr::leftToFirst(char c,bool bIncluded) const
+{
+	int idx = findFirstIdx(c);
+	if(idx == -1)return KviStr(*this);
+	return KviStr(m_ptr,bIncluded ? idx + 1 : idx);
+}
+
+
+KviStr KviStr::leftToLast(char c,bool bIncluded) const
+{
+	int idx = findLastIdx(c);
+	return KviStr(m_ptr,bIncluded ? idx + 1 : idx);
+}
+
+KviStr & KviStr::cutFromFirst(char c,bool bIncluded)
+{
+	int idx = findFirstIdx(c);
+	if(idx != -1)cutRight(bIncluded ? (m_len - idx) : (m_len - (idx + 1)));
+	return (*this);
+}
+
+KviStr & KviStr::cutToLast(char c,bool bIncluded)
+{
+	int idx = findLastIdx(c);
+	if(idx != -1)cutLeft(bIncluded ? idx + 1 : idx);
+	return (*this);
+}
+
+KviStr & KviStr::cutFromLast(char c,bool bIncluded)
+{
+	int idx = findLastIdx(c);
+	if(idx != -1)cutRight(bIncluded ? (m_len - idx) : (m_len - (idx + 1)));
+	return (*this);
+}
+
+KviStr & KviStr::cutToFirst(const char *c,bool bIncluded)
+{
+	int len = (int)strlen(c);
+	int idx = findFirstIdx(c);
+	if(idx != -1)cutLeft(bIncluded ? idx + len : idx);
+	return (*this);
+}
+
+KviStr & KviStr::cutFromFirst(const char *c,bool bIncluded)
+{
+	int len = (int)strlen(c);
+	int idx = findFirstIdx(c);
+	if(idx != -1)cutRight(bIncluded ? (m_len - idx) : (m_len - (idx + len)));
+	return (*this);
+}
+
+KviStr & KviStr::cutToLast(const char *c,bool bIncluded)
+{
+	int len = (int)strlen(c);
+	int idx = findLastIdx(c);
+	if(idx != -1)cutLeft(bIncluded ? idx + len : idx);
+	return (*this);
+}
+
+KviStr & KviStr::cutFromLast(const char *c,bool bIncluded)
+{
+	int len = (int)strlen(c);
+	int idx = findLastIdx(c);
+	if(idx != -1)cutRight(bIncluded ? (m_len - idx) : (m_len - (idx + len)));
+	return (*this);
+}
+
+KviStr & KviStr::setLen(int len)
+{
+	__range_valid(len >= 0);
+	m_ptr = (char *)kvi_realloc(m_ptr,len+1);
+	*(m_ptr+len)='\0';
+	m_len = len;
+	return (*this);
+}
+
+KviStr & KviStr::stripLeftWhiteSpace()
+{
+	register char *p=m_ptr;
+	while(isspace(*p))p++;
+	m_len -= (p-m_ptr);
+	kvi_memmove(m_ptr,p,m_len+1);
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+	return (*this);
+}
+
+KviStr & KviStr::stripLeft(char c)
+{
+	__range_valid(c != '\0');
+	register char *p=m_ptr;
+	while(*p == c)p++;
+	m_len -= (p-m_ptr);
+	kvi_memmove(m_ptr,p,m_len+1);
+	m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+	return (*this);
+}
+
+bool KviStr::getToken(KviStr & str,char sep)
+{
+	__range_valid(str.m_ptr);
+	__range_valid(str.m_ptr != m_ptr);
+	register char *p=m_ptr;
+	//skip to the end
+	while(*p && (*p != sep))p++;
+	//0123456789
+	//abcd xyz
+	//^   ^
+	str.m_len = p-m_ptr;
+	str.m_ptr = (char *)kvi_realloc(str.m_ptr,str.m_len+1);
+	kvi_fastmove(str.m_ptr,m_ptr,str.m_len);
+	*(str.m_ptr + str.m_len)='\0';
+	while(*p && (*p == sep))p++;
+	cutLeft(p-m_ptr);
+	return (m_len != 0);
+}
+
+bool KviStr::getLine(KviStr &str)
+{
+	__range_valid(str.m_ptr);
+	__range_valid(str.m_ptr != m_ptr);
+	if(m_len == 0)return false;
+	register char *p=m_ptr;
+	//skip to the end
+	while(*p && (*p != '\n'))p++;
+	//0123456789
+	//abcd xyz
+	//^   ^
+	str.m_len = p-m_ptr;
+	str.m_ptr = (char *)kvi_realloc(str.m_ptr,str.m_len+1);
+	kvi_fastmove(str.m_ptr,m_ptr,str.m_len);
+	*(str.m_ptr + str.m_len)='\0';
+	p++;
+	cutLeft(p-m_ptr);
+	return true;
+}
+
+KviStr KviStr::getToken(char sep)
+{
+	register char *p=m_ptr;
+	while(*p && (*p != sep))p++;
+	KviStr ret(m_ptr,p);
+	while(*p && (*p == sep))p++;
+	cutLeft(p-m_ptr);
+	return ret;
+}
+
+KviStr & KviStr::sprintf(const char *fmt,...)
+{
+	m_ptr=(char *)kvi_realloc(m_ptr,256);
+	//First try
+	kvi_va_list list;
+	kvi_va_start(list,fmt);
+	//print...with max 256 chars
+	m_len=kvi_vsnprintf(m_ptr,256,fmt,list);
+	kvi_va_end(list);
+
+	//check if we failed
+	if(m_len < 0){
+		//yes , failed....
+		int dummy=256;
+		do{ //we failed , so retry with 256 more chars
+			dummy+=256;
+			//realloc
+			m_ptr=(char *)kvi_realloc(m_ptr,dummy);
+			//print...
+			kvi_va_start(list,fmt);
+			m_len=kvi_vsnprintf(m_ptr,dummy,fmt,list);
+			kvi_va_end(list);
+		} while(m_len < 0);
+	}
+	//done...
+	//now m_len is the length of the written string not including the terminator...
+	//perfect! :)
+	m_ptr=(char *)kvi_realloc(m_ptr,m_len+1);
+	return (*this);
+}
+
+int KviStr::find(const char *str,int idx,bool caseS) const
+{
+	if(idx >= m_len)return -1;
+	register char *p=m_ptr + idx;
+	int len = (int)strlen(str);
+	if(caseS){
+		for(;;){
+			while(*p && (*p != *str))p++;
+			if(*p){
+				if(kvi_strEqualCSN(str,p,len))return (p-m_ptr);
+				else p++;
+			} else return -1;
+		}
+	} else {
+		for(;;){
+			char tmp = toupper(*str);
+			while(*p && (toupper(*p) != tmp))p++;
+			if(*p){
+				if(kvi_strEqualCIN(str,p,len))return (p-m_ptr);
+				else p++;
+			} else return -1;
+		}
+	}
+}
+
+int KviStr::find(char c,int idx) const
+{
+	if(idx >= m_len)return -1;
+	register char *p=m_ptr + idx;
+	while(*p && (*p != c))p++;
+	return (*p ? p-m_ptr : -1);
+}
+
+
+int KviStr::findRev(const char *str,int idx,bool caseS) const
+{
+	if((m_len + idx) < 0)return -1;
+	register char *p=m_ptr + m_len + idx;
+	int len = (int)strlen(str);
+	if(caseS)
+	{
+		for(;;)
+		{
+			while((p >= m_ptr) && (*p != *str))p--;
+			if(p >= m_ptr){
+				if(kvi_strEqualCSN(str,p,len))return (p-m_ptr);
+				else p--;
+			} else return -1;
+		}
+	} else {
+		for(;;){
+			char tmp = toupper(*str);
+			while((p >= m_ptr) && (toupper(*p) != tmp))p--;
+			if(p >= m_ptr){
+				if(kvi_strEqualCIN(str,p,len))return (p-m_ptr);
+				else p--;
+			} else return -1;
+		}
+	}
+}
+
+int KviStr::findFirstIdx(char c) const
+{
+	register char *p=m_ptr;
+	while(*p && (*p != c))p++;
+	return (*p ? p-m_ptr : -1);
+}
+
+int KviStr::findFirstIdx(const char *str,bool caseS) const
+{
+	// This function can't be used to search inside
+	// multibyte encoded strings... convert your
+	// code to QString and use QString::findRev().
+	// We must throw away KviStr at all in this case...
+
+	// return QString(m_ptr).find(QString(str),0,caseS);;
+	
+	// Both this KviStr and the const char * str are assumed
+	// to be in the proper (and same) encoding.
+	// If KviStr is in encoding A then QString(m_ptr) might
+	// or not be decoded correctly.
+	// Also if KviStr is in UTF-8 (for example), then
+	// a position in QString() does not map to the position in the char array
+	// since a single UNICODE char may use one or more bytes...
+
+	__range_valid(str);
+	register char *p=m_ptr;
+	int len = (int)strlen(str);
+	if(caseS){
+		for(;;){
+			while(*p && (*p != *str))p++;
+			if(*p){
+				if(kvi_strEqualCSN(str,p,len))return (p-m_ptr);
+				else p++;
+			} else return -1;
+		}
+	} else {
+		// this will NOT work for strings that aren't in the current system encoding :(
+		for(;;){
+			char tmp = toupper(*str);
+			while(*p && (toupper(*p) != tmp))p++;
+			if(*p){
+				if(kvi_strEqualCIN(str,p,len))return (p-m_ptr);
+				else p++;
+			} else return -1;
+		}
+	}
+}
+
+int KviStr::findLastIdx(char c) const
+{
+	//Empty string ?
+	if(m_len < 1)return -1;
+	//p points to the last character in the string
+	register char *p=((m_ptr+m_len)-1);
+	//go back until we find a match or we run to the first char in the string.
+	while((*p != c) && (p > m_ptr))p--;
+	//if *p == c --> matched , else we are at the beginning of the string.
+	return ((*p == c)? p-m_ptr : -1);
+}
+
+int KviStr::findLastIdx(const char *str,bool caseS) const
+{
+	// This function can't be used to search inside
+	// multibyte encoded strings... convert your
+	// code to QString and use QString::findRev().
+	// We must throw away KviStr at all in this case...
+
+	// return QString(m_ptr).findRev(QString(str),-1,caseS);
+
+	__range_valid(str);
+	//Calc the len of the searched string
+	int len = (int)strlen(str);
+	//Too long ?
+	if(m_len < len)return -1;
+	//p points to the last character in the string
+	register char *p=((m_ptr+m_len)-1);
+	if(caseS){
+		for(;;){
+			//go back until we find a character that mathes or we run to the first char.
+			while((*p != *str) && (p > m_ptr))p--;
+			if(*p == *str){
+				//maybe occurence....
+				if(kvi_strEqualCSN(str,p,len))return (p-m_ptr);
+				else {
+					//Nope...continue if there is more data to check...
+					if(p == m_ptr)return -1;
+					p--;
+				}
+			} else return -1; //Beginning of the string
+		}
+	} else {
+		// case insensitive
+		for(;;){
+			//go back until we find a character that mathes or we run to the first char.
+			char tmp = toupper(*str);
+			while((toupper(*p) != tmp) && (p > m_ptr))p--;
+			if(toupper(*p) == tmp){
+				//maybe occurence....
+				if(kvi_strEqualCIN(str,p,len))return (p-m_ptr);
+				else {
+					//Nope...continue if there is more data to check...
+					if(p == m_ptr)return -1;
+					p--;
+				}
+			} else return -1; //Beginning of the string
+		}
+	}
+}
+
+KviStr & KviStr::stripWhiteSpace()
+{
+	// 0123456789
+	//    abcd   0
+	// ^        ^
+	// left   right
+	register char *left=m_ptr;
+	register char *right=m_ptr+m_len-1;
+	// skip initial spaces
+	while(isspace(*left))left++;
+	if(*left){
+		// valid string , left points to first non-space
+		while((right >= left) && isspace(*right))right--;
+		// 0123456789
+		//    abcd   0
+		//    ^  ^
+		// left   right	
+		m_len = (right - left)+1;
+		kvi_memmove(m_ptr,left,m_len);
+		m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+		*(m_ptr+m_len)='\0';
+	} else {
+		m_ptr = (char *)kvi_realloc(m_ptr,1);
+		*m_ptr = '\0';
+		m_len = 0;
+	}
+	return (*this);
+}
+
+KviStr & KviStr::stripRightWhiteSpace()
+{
+	if(*m_ptr)
+	{
+		register char *right=m_ptr+m_len-1;
+		const char *start=right;
+		while((right >= m_ptr) && isspace( *right ))right--;
+		if(right != start)
+		{
+			m_len = (right - m_ptr) + 1;
+			m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+			*(m_ptr+m_len)='\0';
+		}
+	}
+	return (*this);
+}
+
+KviStr & KviStr::stripRight(char c)
+{
+	if(*m_ptr)
+	{
+		register char *right=m_ptr+m_len-1;
+		const char *start=right;
+		while((right >= m_ptr) && (*right == c))right--;
+		if(right != start)
+		{
+			m_len = (right - m_ptr) + 1;
+			m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+			*(m_ptr+m_len)='\0';
+		}
+	}
+	return (*this);
+}
+
+KviStr & KviStr::stripSpace()
+{
+	// 0123456789
+	//    abcd   0
+	// ^        ^
+	// left   right
+	register char *left=m_ptr;
+	register char *right=m_ptr+m_len-1;
+	// skip initial spaces
+	while((*left == ' ') || (*left == '\t'))left++;
+	if(*left){
+		// valid string , left points to first non-space
+		while((right >= left) && ((*right == ' ') || (*right == '\t')))right--;
+		// 0123456789
+		//    abcd   0
+		//    ^  ^
+		// left   right	
+		m_len = (right - left)+1;
+		kvi_memmove(m_ptr,left,m_len);
+		m_ptr = (char *)kvi_realloc(m_ptr,m_len+1);
+		*(m_ptr+m_len)='\0';
+	} else {
+		m_ptr = (char *)kvi_realloc(m_ptr,1);
+		*m_ptr = '\0';
+		m_len = 0;
+	}
+	return (*this);
+}
+
+bool KviStr::isNum() const
+{
+	register char *p=m_ptr;
+	while(isspace(*p))p++;
+	if(*p=='-')p++;
+	if(!isdigit(*p))return false;
+	while(isdigit(*p))p++;
+	while(isspace(*p))p++;
+	return (*p=='\0');
+}
+
+bool KviStr::isUnsignedNum() const
+{
+	register char *p=m_ptr;
+	while(isspace(*p))p++;
+	if(!isdigit(*p))return false;
+	while(isdigit(*p))p++;
+	while(isspace(*p))p++;
+	return (*p=='\0');
+}
+
+static KviStr g_szApplicationWideEmptyString;
+
+KviStr & KviStr::emptyString()
+{
+	return g_szApplicationWideEmptyString;
+}
+
+
+bool KviStr::ext_contains(register const char * data,const char * item,bool caseS)
+{
+	if(item && data)
+	{
+		int len = (int)strlen(item);
+		char c = tolower(*item);
+		if(caseS)
+		{
+			while(*data)
+			{
+				while(*data && (tolower(*data) != c))data++;
+				if(*data)
+				{
+					if(kvi_strEqualCSN(item,data,len))return true;
+					else data++;
+				}
+			}
+		} else {
+			while(*data)
+			{
+				while(*data && (tolower(*data) != c))data++;
+				if(*data)
+				{
+					if(kvi_strEqualCIN(item,data,len))return true;
+					else data++;
+				}
+			}
+		}
+	}
+	return false;
+}
+
+
+//void KviStr::pointerToBitString(const void * ptr)
+//{
+//	m_len = (sizeof(void *) * 8);
+//	m_ptr = kvi_realloc(m_ptr,m_len + 1);
+//	for(int i=0;i < m_len;i++)
+//	{
+//		m_ptr[i] = (ptr & 1) ? '1' : '0';
+//		ptr >> 1;
+//	}
+//	m_ptr[i] = '\0';
+//}
+//
+//void * KviStr::bitStringToPointer()
+//{
+//	if(m_len != (sizeof(void *) * 8))return 0;
+//	const char * aux = m_ptr;
+//	void * ptr = 0;
+//	for(int i=m_len - 1;i >= 0;i--)
+//	{
+//		if(m_ptr[i] == '1')ptr &= 1;
+//		else if(m_ptr[i] !='0')return 0;
+//		ptr << 1;
+//	}
+//	return ptr;
+//}
+
+
+
+
+//	static char ascii_jump_table[256]=
+//	{
+//		//	000 001 002 003 004 005 006 007   008 009 010 011 012 013 014 015 
+//		//	NUL SOH STX ETX EOT ENQ ACK BEL   BS  HT  LF  VT  FF  CR  SO  SI
+//			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+//		//	016 017 018 019 020 021 022 023   024 025 026 027 028 029 030 031 
+//		//	DLE DC1 DC2 DC3 DC4 NAK SYN ETB   CAN EM  SUB ESC FS  GS  RS  US
+//			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+//		//	032 033 034 035 036 037 038 039   040 041 042 043 044 045 046 047 
+//		//	    !   "   #   $   %   &   '     (   )   *   +   ,   -   .   /   
+//			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+//		//	048 049 050 051 052 053 054 055   056 057 058 059 060 061 062 063 
+//		//	0   1   2   3   4   5   6   7     8   9   :   ;   <   =   >   ?   
+//			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+//		//	064 065 066 067 068 069 070 071   072 073 074 075 076 077 078 079 
+//		//	@   A   B   C   D   E   F   G     H   I   J   K   L   M   N   O   
+//			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+//		//	080 081 082 083 084 085 086 087   088 089 090 091 092 093 094 095 
+//		//	P   Q   R   S   T   U   V   W     X   Y   Z   [   \   ]   ^   _   
+//			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+//		//	096 097 098 099 100 101 102 103   104 105 106 107 108 109 110 111 
+//		//	`   a   b   c   d   e   f   g     h   i   j   k   l   m   n   o   
+//			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+//		//	112 113 114 115 116 117 118 119   120 121 122 123 124 125 126 127 
+//		//	p   q   r   s   t   u   v   w     x   y   z   {   |   }   ~      
+//			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+//		//	128 129 130 131 132 133 134 135   136 137 138 139 140 141 142 143 
+//		//	                                                  
+//			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+//		//	144 145 146 147 148 149 150 151   152 153 154 155 156 157 158 159 
+//		//	                                                  
+//			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+//		//	160 161 162 163 164 165 166 167   168 169 170 171 172 173 174 175 
+//		//	                                                  
+//			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+//		//	176 177 178 179 180 181 182 183   184 185 186 187 188 189 190 191 
+//		//	                                                  
+//			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+//		//	192 193 194 195 196 197 198 199   200 201 202 203 204 205 206 207 
+//		//	�  �  �  �  �  �  �  �    �  �  �  �  �  �  �  �  
+//			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+//		//	208 209 210 211 212 213 214 215   216 217 218 219 220 221 222 223 
+//		//	�  �  �  �  �  �  �  �    �  �  �  �  �  �  �  �  
+//			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+//		//	224 225 226 227 228 229 230 231   232 233 234 235 236 237 238 239 
+//		//	�  �  �  �  �  �  �  �    �  �  �  �  �  �  �  �  
+//			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,
+//		//	240 241 242 243 244 245 246 247   248 249 250 251 252 253 254 255 
+//		//	�  �  �  �  �  �  �  �                            
+//			0  ,0  ,0  ,0  ,0  ,0  ,0  ,0    ,0  ,0  ,0  ,0  ,0  ,0  ,0  ,0
+//	};
diff --git a/src/kvilib/core/kvi_string.h b/src/kvilib/core/kvi_string.h
new file mode 100644
index 00000000..602173cd
--- /dev/null
+++ b/src/kvilib/core/kvi_string.h
@@ -0,0 +1,552 @@
+#ifndef _KVI_STRING_H_
+#define _KVI_STRING_H_
+//=============================================================================
+//
+//   File : kvi_string.h
+//   Creation date : Fri Mar 19 1999 03:06:26 by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 1999-2001 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=============================================================================
+
+#include "kvi_settings.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#ifdef HAVE_STRINGS_H
+	#include <strings.h> // useless ?
+#endif
+
+#include <qglobal.h>
+#include <qstring.h>
+
+
+#include "kvi_qcstring.h"
+#include "kvi_inttypes.h"
+#include "kvi_heapobject.h"
+#include "kvi_stdarg.h"
+
+
+
+//
+//  sigh...
+//  IRC is not UNICODE ...(yet) :(
+//
+
+#undef __KVI_EXTERN
+#ifdef _KVI_STRING_CPP_
+	#define __KVI_EXTERN
+#else
+	#define __KVI_EXTERN extern
+#endif
+
+
+__KVI_EXTERN KVILIB_API bool kvi_qstringEqualCI(const QString &s1,const QString &s2);
+
+
+// Include inlined assembly implementations if required
+#ifdef COMPILE_ix86_ASM
+	#include "kvi_strasm.h"
+#else
+	// Returns true if the string str1 is equal to str2. case sensitive.
+	__KVI_EXTERN KVILIB_API bool kvi_strEqualCS(const char *str1,const char *str2);
+	// Returns true if the forst len characters of string str1 are equal to str2.
+	// case sensitive.
+	// Note that if str1 or str2 are shorter than len characters then are considered as NOT equal!
+	__KVI_EXTERN KVILIB_API bool kvi_strEqualCSN(const char *str1,const char *str2,int len);
+	// no such tricks in non-asm
+	#define kvi_strEqualNoLocaleCI(str1,str2) kvi_strEqualCI(str1,str2)
+	#define kvi_strEqualNoLocaleCIN(str1,str2,len) kvi_strEqualCIN(str1,str2,len)
+	#define kvi_strLen(str) strlen(str)
+#endif
+
+// Returns true if the string str1 is equal to str2.
+// case insensitive.
+__KVI_EXTERN KVILIB_API bool kvi_strEqualCI(const char *str1,const char *str2);
+// Returns true if the forst len characters of string str1 are equal to str2.
+// case insensitive.
+// Note that if str1 or str2 are shorter than len characters then are considered as NOT equal!
+__KVI_EXTERN KVILIB_API bool kvi_strEqualCIN(const char *str1,const char *str2,int len);
+// My own implementations of strcmp and strncasecmp
+// Once I wrote it , I KNOW what they do : ALWAYS :)
+// Note that greater here means that comes AFTER in the alphabetic order.
+__KVI_EXTERN KVILIB_API int kvi_strcmpCI(const char *str1,const char *str2);
+//__KVI_EXTERN KVILIB_API int kvi_strcmpCIN(const char *str1,const char *str2,int len);
+__KVI_EXTERN KVILIB_API int kvi_strcmpCS(const char *str1,const char *str2);
+
+// some wide char stuff
+typedef kvi_u16_t kvi_wchar_t;
+typedef kvi_u32_t kvi_wslen_t;
+
+__KVI_EXTERN KVILIB_API kvi_wslen_t kvi_wstrlen(const kvi_wchar_t * str);
+__KVI_EXTERN KVILIB_API int kvi_wvsnprintcf(kvi_wchar_t * buffer,kvi_wslen_t len,const char *fmt,kvi_va_list list);
+__KVI_EXTERN KVILIB_API int kvi_wvsnprintf(kvi_wchar_t * buffer,kvi_wslen_t len,const kvi_wchar_t *fmt,kvi_va_list list);
+
+//=============================================================================
+//
+// A simple string class.<br>
+// -No data sharing.<br>
+// -Not UNICODE.<br>
+// -Has ALWAYS NON-NULL DATA.<br>
+// -(Maybe)Unsafe :)<br>
+// WARNING : Handle with care and use at own risk :)<br>
+//
+//=============================================================================
+
+class KVILIB_API KviStr : public KviHeapObject
+{
+public:
+	// No particular reason for these two names...
+	// It is just because I like it :)
+
+	enum KviFormatConstructorTag { Format , Sprintf };
+
+	//=============================================================================
+	// Constructors
+	//=============================================================================
+
+	// Empty string == "", len = 0, 1 byte allocated
+	KviStr();
+
+	// Deep copy of the NULL TERMINATED string (NULL str SAFE)
+	KviStr(const char *str);
+
+	// Copy len characters from string str (NOT NULL str SAFE, str MUST be at least len chars long)
+	KviStr(const char *str,int len);
+
+	// bg and end are pointers to a SINGLE string.<br>
+	// A string is extracted starting from bg and ending at end (not included).<br>
+	KviStr(const char *bg,const char *end);
+
+	// Format constructor.<br>
+	// tag is....yes....a dummy number used to resolve ambiguities.<br>
+	// It is SAFE: will fail only if we run out of memory,<br>
+	// but can handle only %s %d %u and %c.
+	KviStr(KviFormatConstructorTag tag,const char *fmt,...);
+
+	// Carbon copy :)...fast
+	KviStr(const KviStr &str);
+
+	// Compat with QT...<br>
+	// WARNING : With QT2.x it WILL loose UNICODE data.<br>
+	// Safe even if the QString is null.
+	KviStr(const QString &str);
+
+	KviStr(const KviQCString &str);
+
+	// Fill sonstructor.
+	// Creates a string long fillLen characters filled with character c.<br>
+	KviStr(char c,int fillLen = 1);
+
+	KviStr(const kvi_wchar_t * unicode);
+
+	KviStr(const kvi_wchar_t * unicode,int len);
+
+	// just free(m_ptr)
+	~KviStr();
+public:
+	//yes...public..but think it as private...:)
+	char *m_ptr; // pointer to allocated buffer , do not change this!
+	int   m_len; // string data length not including the terminator
+
+public:
+	//=============================================================================
+	// Basic const interface (read stuff)
+	//=============================================================================
+
+	// Internal data buffer
+	char * ptr() const              { return m_ptr; };
+	// Length: fast, cached
+	int len() const                 { return m_len; };
+
+	// I hate this operator...but sometimes it is really useful
+	// especially in macros (kvi_options.cpp)
+	operator const char * () const  { return m_ptr; };
+
+	bool isEmpty() const            { return (m_len == 0); };
+	bool hasData() const            { return (m_len != 0); };
+
+	// this is better than string = "", it does not call strlen
+	void clear();
+
+	// forces the length of this string to be iLen (iLen does NOT include the trailing null : it is automatically added)
+	void setLength(int iLen);
+
+	// Returns true if there is something "readable" inside the string
+	bool hasNonWhiteSpaceData() const;
+
+	// Character at zero-based index : always safe!
+	char & at(int idx) const        { return ((idx < m_len) ? m_ptr[idx] : m_ptr[m_len]);        };
+
+	// character checks
+	bool lastCharIs(char ch)  const { return (m_len > 0) ? (*(m_ptr + m_len - 1) == ch) : false; };
+	bool firstCharIs(char ch) const { return (*m_ptr == ch);                                     };
+
+	// upper and lower case copies
+	KviStr upper() const;
+	KviStr lower() const;
+	KviStr upperISO88591() const;
+	KviStr lowerISO88591() const;
+
+	// left , right & co.
+	// all parameters are safety-checked
+	KviStr left(int maxLen) const;
+	KviStr right(int maxLen) const ;
+	KviStr middle(int idx,int maxLen) const;
+
+	KviStr leftToFirst(char c,bool bIncluded = false) const;
+	KviStr leftToLast(char c,bool bIncluded = false) const;
+//	KviStr leftToFirst(const char * str); const;
+
+	//=============================================================================
+	// Non-const interface (write stuff)
+	//=============================================================================
+
+	// Null terminator is NOT included in len
+	KviStr & setLen(int len);
+	// str must not be 0, but len can be anything (it is checked)
+	KviStr & setStr(const char *str,int len = -1);
+	// Like the special constructor that gets the same args.
+	void extractFromString(const char *begin,const char *end);
+
+
+	// Safe sprintf. This one will never write past the end of the string
+	// It can handle only %s %d %u and %c format flags.
+	KviStr & sprintf(const char *fmt,...);
+
+	// append functions
+	void append(const KviStr &str);
+	void append(const QString &str);
+	void append(char c);
+	void append(const char *str);                                     // str CAN be 0
+	void append(const char *str,int len);                             // str CAN NOT be 0, and MUST be at least len chars long
+	void append(KviFormatConstructorTag dummy,const char *fmt,...);
+
+	// prepend stuff , same as above
+	void prepend(const KviStr &str);
+	void prepend(const char *str);                                    // str CAN be 0
+	void prepend(const char *str,int len);                            // str CAN NOT be 0, and MUST be at least len chars long
+
+	// if lastCharIs ch does nothing otherwise appends it
+	void ensureLastCharIs(char ch)              { if(!lastCharIs(ch))append(ch);        };
+
+	// Change THIS string to uppercase or lowercase
+	void toUpperISO88591();
+	void toUpper(); // this is LOCALE AWARE (in Turkish it maps i to Ý!)
+	void toLowerISO88591();
+	void toLower();
+
+	// Assignment
+	KviStr & operator=(const KviStr &str);       // deep copy
+	KviStr & operator=(const char *str);         // str can be NULL here
+	KviStr & operator=(char c);                  // 2 bytes allocated ,m_len = 1
+	KviStr & operator=(const QString &str);
+	KviStr & operator=(const KviQCString &str);
+
+	// Append operators
+	KviStr & operator+=(const KviStr &str)      { append(str); return (*this);          };
+	KviStr & operator+=(const char *str)        { append(str); return (*this);          };
+	KviStr & operator+=(char c)                 { append(c);   return (*this);          };
+	KviStr & operator+=(const QString &str)     { append(str); return (*this);          };
+
+	// Comparison
+	bool equalsCI(const KviStr &other) const { if(m_len != other.m_len)return false; return kvi_strEqualCI(m_ptr,other.m_ptr); };
+	bool equalsCS(const KviStr &other) const { if(m_len != other.m_len)return false; return kvi_strEqualCS(m_ptr,other.m_ptr); };
+	bool equalsCI(const char * other) const { return kvi_strEqualCI(m_ptr,other); };
+	bool equalsCS(const char * other) const { return kvi_strEqualCS(m_ptr,other); };
+	bool equalsCIN(const char * other,int len) const { return kvi_strEqualCIN(m_ptr,other,len); };
+	bool equalsCSN(const char * other,int len) const { return kvi_strEqualCSN(m_ptr,other,len); };
+
+	//=============================================================================
+	// HEX and Base64 stuff
+	//=============================================================================
+
+	// HEX transforms functions
+	void bufferToHex(const char *buffer,int len);
+	// Allocates the needed buffer and returns the allocated length,
+	// returns -1 in case of error (and allocates nothing)
+	// The string MUST contain only hex digits, and the digits MUST be in couples. (len % 2) must equal 0!
+	// So this will fail also if there are leading or trailing spaces!
+	int hexToBuffer(char ** buffer,bool bNullToNewlines = false);
+	// BASE64 stuff
+	void bufferToBase64(const char * buffer,int len);
+	// same as hexToBuffer but obviously transforms base64 notation to binary data (len % 4) must equal 0!
+	int base64ToBuffer(char ** buffer,bool bNullToNewlines = false);
+
+	// frees a buffer allocated by hexToBuffer or base64ToBuffer
+	static void freeBuffer(char * buffer);
+
+	//=============================================================================
+	// Splitters
+	//=============================================================================
+
+	// cut
+	KviStr & cutLeft(int len);             // kills the first len characters
+	KviStr & cutRight(int len);            // kills the last len characters
+	KviStr & cut(int idx,int len);
+	KviStr & cutToFirst(char c,bool bIncluded = true); // cuts the left part of the string up to the first character c or does nothing if the char c is not in the string
+	KviStr & cutToLast(char c,bool bIncluded = true);
+	KviStr & cutFromFirst(char c,bool bIncluded = true);
+	KviStr & cutFromLast(char c,bool bIncluded = true);
+	KviStr & cutToFirst(const char *c,bool bIncluded = true); // cuts the left part of the string up to the first character c or does nothing if the char c is not in the string
+	KviStr & cutToLast(const char *c,bool bIncluded = true);
+	KviStr & cutFromFirst(const char *c,bool bIncluded = true);
+	KviStr & cutFromLast(const char *c,bool bIncluded = true);
+	// & paste
+	KviStr & insert(int idx,const char *data);
+	KviStr & insert(int idx,char c);
+	//Replaces all occurences of char c with the string str
+	KviStr & replaceAll(char c,const char *str);
+	//same as above but with a string
+	KviStr & replaceAll(char *toFind,const char *str,bool bCaseS = true);
+	
+	KviStr & transliterate(const char * szToFind,const char * szReplacement);
+
+	// Strips whitespace characters from beginning of this string.
+	KviStr & stripLeftWhiteSpace();
+	KviStr & stripRightWhiteSpace();
+	// Stips inital and final WHITESPACE characters (see man isspace),<br>
+	// and returns a reference to this string.
+	KviStr & stripWhiteSpace();
+
+	// Strips spaces and tabs only
+	KviStr & stripSpace();
+	// Strips all occurences of the character c from the beginning of the string.<br>
+	// Note that c can not be '\0' :)
+	KviStr & stripLeft(char c);
+	KviStr & stripRight(char c);
+
+	//=============================================================================
+	// Tokenize
+	//=============================================================================
+
+	// Extracts (copy to str and remove) a token from this string ,<br>
+	// and returns true if there are more tokens to extract<br>
+	// Does not strip initial separators!!<br>
+	// str can NOT be this string.
+	bool getToken(KviStr &str,char sep);
+	// Does not strip initial separators!<br>
+	// Can assign also to this string.
+	KviStr getToken(char sep);
+	// Extracts a line from the string.<br>
+	// Returns false if there was no data to extract
+	bool getLine(KviStr &str);
+
+	// splits this string in a null-terminated array of strings
+	// separated by sep.
+	KviStr ** splitToArray(char sep,int max,int * realCount) const;
+	//KviStr ** splitToArray(const char * sep,int max,int * realCount) const;
+	static void freeArray(KviStr ** strings);
+	// joins the array to this string
+	// if sep is not 0 , it is inserted between the strings
+	// if bLastSep is true and sep is non 0 , then sep is also appended at the end
+	// of the buffer (after the last string)
+	void joinFromArray(KviStr ** strings,const char * sep = 0,bool bLastSep = false);
+
+	//=============================================================================
+	// Utils
+	//=============================================================================
+
+	// encodes chars that have nonzero in the jumptable
+	// into %HH equivalents
+	KviStr & hexEncodeWithTable(const unsigned char table[256]);
+	KviStr & hexEncodeWhiteSpace();
+	KviStr & hexDecode(const char * pFrom);
+	KviStr & hexDecode(){ return hexDecode(m_ptr); };
+
+	//=============================================================================
+	// Contains / occurence count
+	//=============================================================================
+
+	// Returns true if at least one occurence of str is found
+	bool contains(const char *str,bool caseS=true) const;
+	// Returns true if at least one occurence of character c is found in this string
+	bool contains(char c,bool caseS=true) const;
+	// Returns the number of occurences of string str in this string.<br>
+	// Overlapped matches are counted.
+	int occurences(const char *str,bool caseS=true) const;
+	// Returns the number of occurences of character c in this string
+	int occurences(char c,bool caseS=true) const;
+
+	//=============================================================================
+	// Find
+	//=============================================================================
+
+	// Finds the first occurence of the character c in this string,<br>
+	// and returns its zero-based index or -1 if c can not be found.<br>
+	// c can NOT be '\0' here.
+	int findFirstIdx(char c) const;
+	// Finds the first occurence of the sub-string str in this string,<br>
+	// and returns its zero-based index or -1 if the sub-string can not be found.<br>
+	// str can NOT be 0 here.
+	int findFirstIdx(const char *str,bool caseS = true) const;
+	// Finds the last occurence of the character c in this string,<br>
+	// and returns its zero-based index or -1 if the character can not be found.
+	int findLastIdx(char c) const;
+	// Finds the last occurence of the sub-string str in this string,<br>
+	// and returns its zero-based index or -1 if the sub-string can not be found.<br>
+	// str can NOT be 0 here.
+	int findLastIdx(const char *str,bool caseS = true) const;
+
+	int find(char c,int startIdx) const;
+	int find(const char * str,int startIdx,bool caseS = true) const;
+	int findRev(const char * str,int startIdx,bool caseS = true) const;
+
+	//=============================================================================
+	// Numbers
+	//=============================================================================
+
+	// everything in base 10.... no overflow checks here
+	long toLong(bool *bOk=0) const;
+	unsigned long toULong(bool *bOk=0) const;
+	char toChar(bool *bOk=0) const              { return (char)toLong(bOk);             };
+	unsigned char toUChar(bool *bOk=0) const    { return (unsigned char)toULong(bOk);   };
+	int toInt(bool *bOk=0) const                { return (int)toLong(bOk);              };
+	unsigned int toUInt(bool *bOk=0) const      { return (unsigned int)toULong(bOk);    };
+	short toShort(bool *bOk=0) const            { return (short)toLong(bOk);            };
+	unsigned short toUShort(bool *bOk=0) const  { return (unsigned short)toLong(bOk);   };
+
+	KviStr & setNum(long num);
+	KviStr & setNum(unsigned long num);
+
+	KviStr & setNum(int num)                    { return setNum((long)num);             };
+	KviStr & setNum(unsigned int num)           { return setNum((unsigned long)num);    };
+	KviStr & setNum(short num)                  { return setNum((long)num);             };
+	KviStr & setNum(unsigned short num)         { return setNum((unsigned long)num);    };
+	KviStr & setNum(char num)                   { return setNum((long)num);             };
+	KviStr & setNum(unsigned char num)          { return setNum((unsigned long)num);    };
+
+	// Retuns true if the string contains only digits and an optional '-' character
+	// at the beginning.<be>
+	// Space characters are allowed at the begginning and the end.<br>
+	// There is no overflow check!
+	bool isNum() const;
+	bool isUnsignedNum() const;
+
+	// special functions for multiple bases
+	long toLongExt(bool *bOk = 0,int base = 0);
+	// unsigned long toULongExt(bool *bOk = 0,int base = 0); //never used
+
+	// returns an empty string...
+	// this if often useful!
+	static KviStr & emptyString();
+	
+	//=============================================================================
+	// Dead interface
+	//=============================================================================
+
+	// Transform a pointer to a string with all 0 and 1
+	// void pointerToBitString(const void * ptr);
+	// Get a pointer from a string all of 0 and 1 : return 0 if invalid
+	// void * bitStringToPointer();
+
+	//=============================================================================
+	// "External string" helper functions
+	//=============================================================================
+
+	// FIXME: Should it be KviStrExt::contains namespace ?
+	static bool ext_contains(register const char * data,const char * item,bool caseS = true);
+};
+
+// FIXME: the functions below should end in the KviStr namespace ???
+
+
+// Cool string parsing function.
+// It will extract the first found token from the string aux_ptr , and return
+// a pointer to the beginning of the next token , or end of the string.
+// It skips the initial sep characters!
+__KVI_EXTERN KVILIB_API const char * kvi_extractToken(KviStr &str,const char *aux_ptr,char sep =' ');
+// Does not skip the beginning separators!
+// Extracts data from the string up to the next separator character or the end of the string.
+// and returns a pointer to that separator (or string end).
+__KVI_EXTERN KVILIB_API const char * kvi_extractUpTo(KviStr &str,const char *aux_ptr,char sep=' ');
+// Reduced vsnprintf...
+// Handles %s,%c,%d,%u  (%% are TWO percents here and not one.)
+// Returns -1 if the formatted string exceeded the buffer length.
+// Otherwise returns the length of the formatted buffer...(not including '\0')
+__KVI_EXTERN KVILIB_API int kvi_vsnprintf(char *buffer,int len,const char *fmt,kvi_va_list list);
+// Reduced vsnprintf: special version for irc.
+// Handles %s,%c,%d,%u  (%% are TWO percents here and not one.)
+// Writes up to 510 characters and terminates the string with a CRLF
+// Sets bTruncated if the requested format string was too large to fit in 512 bytes
+// otherwise sets it to false; The buffer MUST be at least 512 bytes long.
+// Always returns the length of the formatted buffer...(max 512 - min 2=CRLF)
+__KVI_EXTERN KVILIB_API int kvi_irc_vsnprintf(char *buffer,const char *fmt,kvi_va_list list,bool *bTruncated);
+
+// WILDCARD EXPRESSION MATCHING FUNCTIONS
+
+// Returns true if the two regular expressions with wildcards matches
+__KVI_EXTERN KVILIB_API bool kvi_matchWildExpr(register const char *m1,register const char *m2);
+// Returns true if the two regular expressions with wildcards matches, case sensitive
+//__KVI_EXTERN bool kvi_matchWildExprCS(register const char *m1,register const char *m2); // actually unused
+// Same as kvi_matchWildExpr but with an additional char that acts as string terminator
+// If there is a match this function returns true and puts the pointers where it stopped in r1 and r2
+__KVI_EXTERN KVILIB_API bool kvi_matchWildExprWithTerminator(register const char *m1,register const char *m2,char terminator,
+			const char ** r1,const char ** r2);
+
+// Returns true if the wildcard expression exp matches the string str
+__KVI_EXTERN KVILIB_API bool kvi_matchStringCI(register const char * exp,register const char * str);
+#define kvi_matchString kvi_matchStringCI
+__KVI_EXTERN KVILIB_API bool kvi_matchStringCS(register const char * exp,register const char * str);
+__KVI_EXTERN KVILIB_API bool kvi_matchStringWithTerminator(register const char * exp,register const char * str,char terminator,const char ** r1,const char ** r2);
+
+// This function works like a particular case of strncmp.
+// It evaluates if str2 is the terminal part of str1.
+// example: if str1 is "this is an experiment" and str2 is "xperiment"
+// return 0.
+// With the index parameter, the match start on str1 from the specified
+// index. For example:
+// if str1 is "this is an experiment" and str2 is "an" we have return !0
+// but "this is an experiment"
+//      012345678901234567890
+// if we call kvi_strsubRevCS("this is an experiment","an", 9) we got a match.
+__KVI_EXTERN KVILIB_API int kvi_strMatchRevCS(const char *str1, const char *str2, int index=-1);
+
+// KviStr comparison non-member operators
+__KVI_EXTERN KVILIB_API inline bool operator==(const KviStr &left,const KviStr &right)
+{ return (left.m_len == right.m_len) ? kvi_strEqualCS(left.m_ptr,right.m_ptr) : false; }
+__KVI_EXTERN KVILIB_API inline bool operator==(const KviStr &left,const char *right)
+{ return kvi_strEqualCS(left.m_ptr,right); }
+__KVI_EXTERN KVILIB_API inline bool operator==(const char *left,const KviStr &right)
+{ return kvi_strEqualCS(left,right.m_ptr); }
+__KVI_EXTERN KVILIB_API inline bool operator!=(const KviStr &left,const KviStr &right)
+{ return !kvi_strEqualCS(left.m_ptr,right.m_ptr); }
+__KVI_EXTERN KVILIB_API inline bool operator!=(const KviStr &left,const char *right)
+{ return !kvi_strEqualCS(left.m_ptr,right); }
+__KVI_EXTERN KVILIB_API inline bool operator!=(const char *left,const KviStr &right)
+{ return !kvi_strEqualCS(left,right.m_ptr); }
+
+__KVI_EXTERN KVILIB_API inline KviStr operator+(const KviStr &left,const KviStr &right)
+{ KviStr ret(left); ret += right; return ret; }
+__KVI_EXTERN KVILIB_API inline KviStr operator+(const KviStr &left,const char *right)
+{ KviStr ret(left); ret += right; return ret; }
+__KVI_EXTERN KVILIB_API inline KviStr operator+(const char *left,const KviStr &right)
+{ KviStr ret(left); ret += right; return ret; }
+__KVI_EXTERN KVILIB_API inline KviStr operator+(const KviStr &left,char right)
+{ KviStr ret(left); ret += right; return ret; }
+__KVI_EXTERN KVILIB_API inline KviStr operator+(char left,const KviStr &right)
+{ KviStr ret(left); ret += right; return ret; }
+
+inline int kvi_compare(const KviStr * p1,const KviStr * p2)
+{
+	return kvi_strcmpCI(p1->ptr(),p2->ptr());
+}
+
+#endif //_KVI_STRING_H_
diff --git a/src/kvilib/core/kvi_stringarray.cpp b/src/kvilib/core/kvi_stringarray.cpp
new file mode 100644
index 00000000..d160ce28
--- /dev/null
+++ b/src/kvilib/core/kvi_stringarray.cpp
@@ -0,0 +1,119 @@
+//=================================================================================================
+//
+//   File : kvi_stringarray.cpp
+//   Creation date : Tue Jun 6 02:20:20 by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 2002 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=================================================================================================
+
+#define __KVILIB__
+
+
+#include "kvi_stringarray.h"
+#include "kvi_malloc.h"
+
+KviStringArray::KviStringArray()
+{
+	m_uSize = 0;
+	m_pData = 0;
+	m_uHighestIdx = 0;
+}
+
+KviStringArray::~KviStringArray()
+{
+	if(m_pData)clear();
+}
+
+
+void KviStringArray::clear()
+{
+	if(!m_pData)return;
+	for(unsigned int i=0;i<m_uSize;i++)
+	{
+		if(m_pData[i])delete m_pData[i];
+	}
+	kvi_free(m_pData);
+	m_pData = 0;
+	m_uHighestIdx = 0;
+	m_uSize = 0;
+}
+
+void KviStringArray::insert(unsigned int uIdx,KviStr * pVal)
+{
+	if(m_uSize <= uIdx)
+	{
+		unsigned int uOldSize = m_uSize;
+		m_uSize = uIdx + KVI_STRING_ARRAY_FREESPACE_SIZE;
+		m_pData = (KviStr **)kvi_realloc(m_pData,m_uSize * sizeof(KviStr *));
+		for(unsigned int u = uOldSize;u < m_uSize;u++)
+		{
+			m_pData[u] = 0;
+		}
+	} else {
+		if(m_pData[uIdx])delete m_pData[uIdx];
+	}
+	if(uIdx > m_uHighestIdx)m_uHighestIdx = uIdx;
+	m_pData[uIdx] = pVal;
+}
+
+void KviStringArray::remove(unsigned int uIdx)
+{
+	if(uIdx > m_uHighestIdx)return;
+	if(m_pData[uIdx])
+	{
+		delete m_pData[uIdx];
+		m_pData[uIdx] = 0;
+		if(uIdx == m_uHighestIdx)
+		{
+			// shrink the array
+			if(m_uHighestIdx == 0)clear();
+			else {
+				unsigned int u = m_uHighestIdx - 1;
+				while(!m_pData[u])u--;
+				if((m_uHighestIdx - u) > KVI_STRING_ARRAY_FREESPACE_SIZE)shrink(u);
+				else m_uHighestIdx = u; // just set the max index
+			}
+		}
+	}
+}
+
+void KviStringArray::shrink(unsigned int uMaxItem)
+{
+	m_uHighestIdx = uMaxItem;
+	m_uSize = uMaxItem + 1;
+	m_pData = (KviStr **)kvi_realloc(m_pData,sizeof(KviStr *) * m_uSize);
+}
+
+void KviStringArray::copyFrom(KviStringArray * a)
+{
+	clear();
+	m_uSize = a->m_uSize;
+	m_uHighestIdx = a->m_uHighestIdx;
+	if(m_uSize > 0)
+	{
+		m_pData = (KviStr **)kvi_malloc(sizeof(KviStr *) * m_uSize);
+		for(unsigned int i=0;i<m_uSize;i++)
+		{
+			if(a->m_pData[i])m_pData[i] = new KviStr(*(a->m_pData[i]));
+			else m_pData[i] = 0;
+		}
+	} else {
+		m_pData = 0;
+	}
+}
diff --git a/src/kvilib/core/kvi_stringarray.h b/src/kvilib/core/kvi_stringarray.h
new file mode 100644
index 00000000..3db9a564
--- /dev/null
+++ b/src/kvilib/core/kvi_stringarray.h
@@ -0,0 +1,55 @@
+#ifndef _KVI_STRINGARRAY_H_
+#define _KVI_STRINGARRAY_H_
+//=================================================================================================
+//
+//   File : kvi_stringarray.h
+//   Creation date : Tue Jun 6 02:20:20 by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 2002 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=================================================================================================
+
+#include "kvi_settings.h"
+#include "kvi_string.h"
+#include "kvi_heapobject.h"
+
+#define KVI_STRING_ARRAY_FREESPACE_SIZE 16
+
+class KVILIB_API KviStringArray : public KviHeapObject
+{
+public:
+	KviStringArray();
+	~KviStringArray();
+public:
+	unsigned int   m_uSize;
+	unsigned int   m_uHighestIdx;
+	KviStr      ** m_pData;
+public:
+	void clear();
+	void insert(unsigned int uIdx,KviStr * pVal);
+	void copyFrom(KviStringArray * a);
+	unsigned int size(){ return (m_uSize == 0) ? 0 : (m_uHighestIdx + 1); };
+	bool isEmpty(){ return m_uSize == 0; };
+	void remove(unsigned int uIdx);
+	void shrink(unsigned int uMaxItem);
+	KviStr * uncheckedAt(unsigned int uIdx){ return m_pData[uIdx]; };
+	KviStr * at(unsigned int uIdx){ return m_uSize > uIdx ? m_pData[uIdx] : 0; };
+	KviStr * getAt(unsigned int uIdx){ KviStr * t = at(uIdx); if(t)m_pData[uIdx] = 0; return t; };
+};
+
+#endif //_KVI_STRINGARRAY_H_
diff --git a/src/kvilib/core/kvi_valuelist.h b/src/kvilib/core/kvi_valuelist.h
new file mode 100644
index 00000000..fde9d5b6
--- /dev/null
+++ b/src/kvilib/core/kvi_valuelist.h
@@ -0,0 +1,37 @@
+#ifndef _KVI_VALUELIST_H_
+#define _KVI_VALUELIST_H_
+//=================================================================================================
+//
+//   File : kvi_valuelist.h
+//   Creation date : Mon Jan 15 2007 04:53 by Szymon Stefanek
+//
+//   This file is part of the KVirc irc client distribution
+//   Copyright (C) 2007 Szymon Stefanek (pragma at kvirc dot net)
+//
+//   This program is FREE software. You can redistribute it and/or
+//   modify it under the terms of the GNU General Public License
+//   as published by the Free Software Foundation; either version 2
+//   of the License, or (at your opinion) any later version.
+//
+//   This program is distributed in the HOPE that it will be USEFUL,
+//   but WITHOUT ANY WARRANTY; without even the implied warranty of
+//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+//   See the GNU General Public License for more details.
+//
+//   You should have received a copy of the GNU General Public License
+//   along with this program. If not, write to the Free Software Foundation,
+//   Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+//
+//=================================================================================================
+
+#include "kvi_settings.h"
+
+#ifdef COMPILE_USE_QT4
+	#include <q3valuelist.h>
+	#define KviValueList Q3ValueList
+#else
+	#include <qvaluelist.h>
+	#define KviValueList QValueList
+#endif
+
+#endif //_KVI_VALUELIST_H_