SZS v2.18a

1 files changed, 8065 insertions, 0 deletions

diff --git a/project/dclib/dclib-basics.c b/project/dclib/dclib-basics.c
new file mode 100644
index 0000000..74676d0
--- /dev/null
+++ b/project/dclib/dclib-basics.c
@@ -0,0 +1,8065 @@
+
+/***************************************************************************
+ *                                                                         *
+ *                     _____     ____                                      *
+ *                    |  __ \   / __ \   _     _ _____                     *
+ *                    | |  \ \ / /  \_\ | |   | |  _  \                    *
+ *                    | |   \ \| |      | |   | | |_| |                    *
+ *                    | |   | || |      | |   | |  ___/                    *
+ *                    | |   / /| |   __ | |   | |  _  \                    *
+ *                    | |__/ / \ \__/ / | |___| | |_| |                    *
+ *                    |_____/   \____/  |_____|_|_____/                    *
+ *                                                                         *
+ *                       Wiimms source code library                        *
+ *                                                                         *
+ ***************************************************************************
+ *                                                                         *
+ *        Copyright (c) 2012-2020 by Dirk Clemens <wiimm@wiimm.de>         *
+ *                                                                         *
+ ***************************************************************************
+ *                                                                         *
+ *   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 option) 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.                          *
+ *                                                                         *
+ *   See file gpl-2.0.txt or http://www.gnu.org/licenses/gpl-2.0.txt       *
+ *                                                                         *
+ ***************************************************************************/
+
+#define _GNU_SOURCE 1
+
+#ifndef WIN_SZS_LIB
+  // needed for GetTermWidthFD()
+  #include <sys/ioctl.h>
+#endif
+
+#include <string.h>
+#include <unistd.h>
+#include <time.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <fcntl.h>
+
+#include "dclib-basics.h"
+#include "dclib-debug.h"
+#include "dclib-file.h"
+#include "dclib-utf8.h"
+#include "dclib-network.h"
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		some basic string functions		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+const char EmptyQuote[]	  = "\"\"";	// Ignored by FreeString()
+const char EmptyString[4] = "\0\0\0";	// Ignored by FreeString()
+const char MinusString[4] = "-\0\0";	// Ignored by FreeString()
+
+const char LoDigits[0x41] =
+	"0123456789"
+	"abcdefghijklmnopqrstuvwxyz"
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+	".+";
+
+const char HiDigits[0x41] =
+	"0123456789"
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+	"abcdefghijklmnopqrstuvwxyz"
+	".+";
+
+const char Tabs20[21] = // 20 * TABS + NULL
+	"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";
+
+const char LF20[21] = // 20 * LF + NULL
+	"\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n";
+
+const char Space200[201] = // 200 * ' ' + NULL
+	"                                                  "
+	"                                                  "
+	"                                                  "
+	"                                                  ";
+
+const char Minus300[301] = // 300 * '-' + NULL
+	"--------------------------------------------------"
+	"--------------------------------------------------"
+	"--------------------------------------------------"
+	"--------------------------------------------------"
+	"--------------------------------------------------"
+	"--------------------------------------------------";
+
+const char Underline200[201] = // 200 * '_' + NULL
+	"__________________________________________________"
+	"__________________________________________________"
+	"__________________________________________________"
+	"__________________________________________________";
+
+const char Hash200[201] = // 200 * '#' + NULL
+	"##################################################"
+	"##################################################"
+	"##################################################"
+	"##################################################";
+
+const char Slash200[201] = // 200 * '/' + NULL
+	"//////////////////////////////////////////////////"
+	"//////////////////////////////////////////////////"
+	"//////////////////////////////////////////////////"
+	"//////////////////////////////////////////////////";
+
+// UTF-8 => 3 bytes per char
+const char ThinLine300_3[901] = // 300 * '─' (U+2500) + NULL
+	"──────────────────────────────────────────────────"
+	"──────────────────────────────────────────────────"
+	"──────────────────────────────────────────────────"
+	"──────────────────────────────────────────────────"
+	"──────────────────────────────────────────────────"
+	"──────────────────────────────────────────────────";
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void PrintSettingsDCLIB ( FILE *f, int indent )
+{
+    DASSERT(f);
+    indent = NormalizeIndent(indent);
+    MARK_USED(indent); // for the case, that all other conditions fail!
+
+ #ifdef DCLIB_NETWORK
+    fprintf(f,"%*s" "DCLIB_NETWORK\n",indent,"");
+ #endif
+
+ #ifdef DCLIB_TERMINAL
+    fprintf(f,"%*s" "DCLIB_TERMINAL\n",indent,"");
+ #endif
+
+ #ifdef DCLIB_MYSQL
+    fprintf(f,"%*s" "DCLIB_MYSQL\n",indent,"");
+ #endif
+
+ #ifdef DCLIB_HAVE_USABLE_SIZE
+    fprintf(f,"%*s" "DCLIB_HAVE_USABLE_SIZE\n",indent,"");
+ #endif
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void SetupMultiProcessing()
+{
+    multi_processing = true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void SetupProgname ( int argc, char ** argv, ccp tname, ccp tvers, ccp ttitle )
+{
+    if (tname)
+	toolname = tname;
+    if (tvers)
+	toolversion = tvers;
+    if (ttitle)
+	tooltitle = ttitle;
+
+    if (!progpath)
+    {
+	char path[PATH_MAX];
+	int res = GetProgramPath( path, sizeof(path), true, argc > 0 ? argv[0] : 0 );
+	if ( res > 0 )
+	    progpath = STRDUP(path);
+    }
+
+    if ( argc > 0 && *argv && **argv )
+    {
+	ccp slash = strrchr(*argv,'/');
+	progname = slash ? slash + 1 : *argv;
+    }
+    else
+	progname = toolname && *toolname ? toolname : "?";
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp ProgramPath()
+{
+    static bool done = false;
+    if ( !progpath && !done )
+    {
+	done = true;
+
+	char path[PATH_MAX];
+	int res = GetProgramPath( path, sizeof(path), true, 0 );
+	if ( res > 0 )
+	    progpath = STRDUP(path);
+    }
+    return progpath;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp ProgramDirectory()
+{
+    if (!progdir)
+    {
+	ccp path = ProgramPath();
+	if (path)
+	{
+	    ccp end = strrchr(path,'/');
+	    const uint len = end ? end - path : strlen(path);
+	    progdir = MEMDUP(path,len);
+	}
+    }
+    return progdir;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef __CYGWIN__
+
+ccp ProgramPathNoExt()
+{
+    static ccp res = 0;
+    if (!res)
+    {
+	res = ProgramPath();
+	if (res)
+	{
+	    ccp slash = strrchr(res,'/');
+	    ccp ext = strrchr( slash ? slash + 1 : res, '.' );
+	    if (ext)
+		res = MEMDUP(res,ext-res);
+	}
+    }
+    return res;
+}
+
+#endif // __CYGWIN__
+
+///////////////////////////////////////////////////////////////////////////////
+
+int GetProgramPath
+(
+    // returns strlen(buf) on success, -1 on failure
+
+    char  *buf,		// buffer for the result; empty string on failure.
+    uint  buf_size,	// size of buffer
+    bool  check_proc,	// true: read files of /proc/... to find path
+    ccp	  argv0		// not NULL: analyse this argument (argv[0])
+)
+{
+    char path[PATH_MAX], path2[PATH_MAX];
+
+
+    //--- read files of /proc/...
+
+    if (check_proc)
+    {
+	static ccp tab[] =
+	{
+	    "/proc/self/exe",
+	    "/proc/curproc/file",
+	    "/proc/self/path/a.out",
+	    0
+	};
+
+	ccp *ptr;
+	for ( ptr = tab; *ptr; ptr++ )
+	    if ( realpath(*ptr,path) && *path )
+		return StringCopyS(buf,buf_size,path) - buf;
+    }
+
+
+    //--- analyze argv0
+
+    if (argv0)
+    {
+	if ( *argv0 == '/' )
+	{
+	    // absolute path
+	    if ( realpath(argv0,path) && *path )
+		return StringCopyS(buf,buf_size,path) - buf;
+	}
+	else if (strchr(argv0,'/'))
+	{
+	    // relative path
+	    if ( getcwd(path2,sizeof(path2)) > 0 )
+	    {
+		ccp p2 = PathCatPP(path2,sizeof(path2),path,argv0);
+		if ( realpath(p2,path) && *path )
+		    return StringCopyS(buf,buf_size,path) - buf;
+	    }
+	}
+	else
+	{
+	    // simple name => search in path environment
+	    uint arglen = strlen(argv0);
+	    if ( arglen < sizeof(path2) - 2 )
+	    {
+		ccp dest_end = path2 + sizeof(path2) - 1 - arglen;
+		ccp env = getenv("PATH");
+		while ( env && *env )
+		{
+		    while ( *env == ':' )
+			env++;
+		    char *dest = path2;
+		    while ( *env && *env != ':' && dest < dest_end )
+			*dest++ = *env++;
+		    *dest++ = '/';
+		    memcpy(dest,argv0,arglen+1);
+		    if ( realpath(path2,path) && *path )
+			return StringCopyS(buf,buf_size,path) - buf;
+		}
+	    }
+	}
+    }
+
+
+    //--- failed
+
+    *buf = 0;
+    return -1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void FreeString ( ccp str )
+{
+    noTRACE("FreeString(%p) EmptyString=%p MinusString=%p\n",
+	    str, EmptyString, MinusString );
+    if ( str != EmptyString && str != EmptyQuote && str != MinusString )
+	FREE((char*)str);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * StringCopyE ( char * buf, ccp buf_end, ccp src )
+{
+    // RESULT: end of copied string pointing to NULL
+    // 'src' may be a NULL pointer.
+
+    if ( buf >= buf_end )
+	return (char*)buf_end - 1;
+
+    DASSERT(buf);
+    DASSERT(buf<buf_end);
+    buf_end--;
+
+    if (src)
+	while( buf < buf_end && *src )
+	    *buf++ = *src++;
+
+    *buf = 0;
+    return buf;
+}
+
+//-----------------------------------------------------------------------------
+
+char * StringCopyS ( char * buf, size_t buf_size, ccp src )
+{
+    return StringCopyE(buf,buf+buf_size,src);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * StringCopyEM ( char * buf, ccp buf_end, ccp src, size_t max_copy )
+{
+    // RESULT: end of copied string pointing to NULL
+    // 'src' may be a NULL pointer.
+
+    ASSERT(buf);
+    ASSERT(buf<buf_end);
+    buf_end--;
+    if ( max_copy >= 0 && buf + max_copy < buf_end )
+	buf_end = buf + max_copy;
+
+    if (src)
+	while( buf < buf_end && *src )
+	    *buf++ = *src++;
+
+    *buf = 0;
+    return buf;
+}
+
+//-----------------------------------------------------------------------------
+
+char * StringCopySM ( char * buf, size_t buf_size, ccp src, size_t max_copy )
+{
+    return StringCopyEM(buf,buf+buf_size,src,max_copy);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * StringCat2E ( char * buf, ccp buf_end, ccp src1, ccp src2 )
+{
+    // RESULT: end of copied string pointing to NULL
+    // 'src*' may be a NULL pointer.
+
+    ASSERT(buf);
+    ASSERT(buf<buf_end);
+    buf_end--;
+
+    if (src1)
+	while( buf < buf_end && *src1 )
+	    *buf++ = *src1++;
+
+    if (src2)
+	while( buf < buf_end && *src2 )
+	    *buf++ = *src2++;
+
+    *buf = 0;
+    return buf;
+}
+
+//-----------------------------------------------------------------------------
+
+char * StringCat2S ( char * buf, size_t buf_size, ccp src1, ccp src2 )
+{
+    return StringCat2E(buf,buf+buf_size,src1,src2);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * StringCat3E ( char * buf, ccp buf_end, ccp src1, ccp src2, ccp src3 )
+{
+    // RESULT: end of copied string pointing to NULL
+    // 'src*' may be a NULL pointer.
+
+    ASSERT(buf);
+    ASSERT(buf<buf_end);
+    buf_end--;
+
+    if (src1)
+	while( buf < buf_end && *src1 )
+	    *buf++ = *src1++;
+
+    if (src2)
+	while( buf < buf_end && *src2 )
+	    *buf++ = *src2++;
+
+    if (src3)
+	while( buf < buf_end && *src3 )
+	    *buf++ = *src3++;
+
+    *buf = 0;
+    return buf;
+}
+
+//-----------------------------------------------------------------------------
+
+char * StringCat3S ( char * buf, size_t buf_size, ccp src1, ccp src2, ccp src3 )
+{
+    return StringCat3E(buf,buf+buf_size,src1,src2,src3);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// [[?]]
+
+char * StringCat2A  ( ccp src1, ccp src2 )
+{
+    mem_t mem = MemCat2A( MemByString(src1), MemByString(src2) );
+    return (char*)mem.ptr;
+}
+
+//-----------------------------------------------------------------------------
+
+char * StringCat3A  ( ccp src1, ccp src2, ccp src3 )
+{
+    mem_t mem = MemCat3A( MemByString(src1), MemByString(src2), MemByString(src3) );
+    return (char*)mem.ptr;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * StringLowerE ( char * buf, ccp buf_end, ccp src )
+{
+    // RESULT: end of copied string pointing to NULL
+    // 'src' may be a NULL pointer.
+
+    if ( buf >= buf_end )
+	return (char*)buf_end - 1;
+
+    DASSERT(buf);
+    DASSERT(buf<buf_end);
+    buf_end--;
+
+    if (src)
+	while( buf < buf_end && *src )
+	    *buf++ = tolower((int)*src++);
+
+    *buf = 0;
+    return buf;
+}
+
+//-----------------------------------------------------------------------------
+
+char * StringLowerS ( char * buf, size_t buf_size, ccp src )
+{
+    return StringLowerE(buf,buf+buf_size,src);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * StringUpperE ( char * buf, ccp buf_end, ccp src )
+{
+    // RESULT: end of copied string pointing to NULL
+    // 'src' may be a NULL pointer.
+
+    if ( buf >= buf_end )
+	return (char*)buf_end - 1;
+
+    DASSERT(buf);
+    DASSERT(buf<buf_end);
+    buf_end--;
+
+    if (src)
+	while( buf < buf_end && *src )
+	    *buf++ = toupper((int)*src++);
+
+    *buf = 0;
+    return buf;
+}
+
+//-----------------------------------------------------------------------------
+
+char * StringUpperS ( char * buf, size_t buf_size, ccp src )
+{
+    return StringUpperE(buf,buf+buf_size,src);
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////				PathCat*()		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * PathCatBufPP ( char * buf, size_t bufsize, ccp path1, ccp path2 )
+{
+    // concatenate path + path; returns buf
+
+    DASSERT(buf);
+    DASSERT(bufsize);
+
+    if ( !path1 || !*path1 )
+    {
+	if (path2)
+	    StringCopyS(buf,bufsize,path2);
+	else
+	    *buf = 0;
+	return buf;
+    }
+
+    char * ptr = StringCopyS(buf,bufsize-1,path1);
+    DASSERT( ptr > buf );
+    if ( ptr[-1] != '/' )
+	*ptr++ = '/';
+    if (path2)
+    {
+	while ( *path2 == '/' )
+	    path2++;
+	StringCopyE(ptr,buf+bufsize,path2);
+    }
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PathCatPP ( char * buf, size_t bufsize, ccp path1, ccp path2 )
+{
+    // concatenate path + path; returns path1 | path2 | buf
+
+    if ( !path1 || !*path1 )
+	return path2 ? path2 : "";
+
+    if ( !path2 || !*path2 )
+	return path1;
+
+    char * ptr = StringCopyS(buf,bufsize-1,path1);
+    DASSERT( ptr > buf );
+    if ( ptr[-1] != '/' )
+	*ptr++ = '/';
+    while ( *path2 == '/' )
+	path2++;
+    StringCopyE(ptr,buf+bufsize,path2);
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PathAllocPP ( ccp path1, ccp path2 )
+{
+    char buf[PATH_MAX];
+    return STRDUP(PathCatPP(buf,sizeof(buf),path1,path2));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * PathCatBufPPE ( char * buf, size_t bufsize, ccp path1, ccp path2, ccp ext )
+{
+    // concatenate path + path; returns (by definition) path1 | path2 | buf
+
+    DASSERT(buf);
+    DASSERT(bufsize);
+
+    char *ptr = path1 ? StringCopyS(buf,bufsize-1,path1) : buf;
+    *ptr = 0;
+
+    if (path2)
+    {
+	if ( ptr > buf && ptr[-1] != '/' )
+	    *ptr++ = '/';
+	while ( *path2 == '/' )
+	    path2++;
+	ptr = StringCopyE(ptr,buf+bufsize,path2);
+    }
+
+    if (ext)
+	StringCopyE(ptr,buf+bufsize,ext);
+
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// PathCatPPE() is inline
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PathAllocPPE ( ccp path1, ccp path2, ccp ext )
+{
+    char buf[PATH_MAX];
+    return STRDUP(PathCatPPE(buf,sizeof(buf),path1,path2,ext));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * PathCatBufBP ( char *buf, size_t bufsize, ccp base, ccp path )
+{
+    // PathCatBP() is special: path can be part of buf
+
+    if (!path)
+	path = "";
+    if ( *path == '/' || base && !*base )
+    {
+	// already absolute | no base to add
+	StringCopyS(buf,bufsize,path);
+	return buf;
+    }
+
+
+    //--- now copy base or cwd
+
+    while ( path[0] == '.' && path[1] == '/' )
+	path += 2;
+
+    char buf2[PATH_MAX];
+    StringCopyS(buf2,sizeof(buf2),path);
+
+    char *dest;
+    if (base)
+	dest = StringCopyS(buf,bufsize,base);
+    else
+    {
+	char *cwd = getcwd(buf,bufsize);
+	if (cwd)
+	    dest = buf + strlen(buf);
+	else
+	{
+	    // on error: return fallback
+	    dest = StringCopyS(buf,bufsize,"./");
+	}
+    }
+    StringCat2E(dest,buf+bufsize,"/",buf2);
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PathCatBP ( char *buf, size_t bufsize, ccp base, ccp path )
+{
+    // PathCatBP() is special: path can be part of buf
+
+    if ( path && *path == '/' || base && !*base )
+	return path; // already absolute | no base to add
+
+    return PathCatBufBP(buf,bufsize,base,path);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PathAllocBP ( ccp base, ccp path )
+{
+    char buf[PATH_MAX];
+    return STRDUP(PathCatBP(buf,sizeof(buf),base,path));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * PathCatBufBPP ( char * buf, size_t bufsize, ccp base, ccp path1, ccp path2 )
+{
+    ccp path = PathCatPP(buf,bufsize,path1,path2);
+    return PathCatBufBP(buf,bufsize,base,path);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PathCatBPP ( char * buf, size_t bufsize, ccp base, ccp path1, ccp path2 )
+{
+    ccp path = PathCatPP(buf,bufsize,path1,path2);
+    return PathCatBP(buf,bufsize,base,path);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PathAllocBPP ( ccp base, ccp path1, ccp path2 )
+{
+    char buf[PATH_MAX];
+    return STRDUP(PathCatBPP(buf,sizeof(buf),base,path1,path2));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * PathCatBufBPPE ( char * buf, size_t bufsize, ccp base, ccp path1, ccp path2, ccp ext )
+{
+    ccp path = PathCatPPE(buf,bufsize,path1,path2,ext);
+    return PathCatBufBP(buf,bufsize,base,path);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PathCatBPPE ( char * buf, size_t bufsize, ccp base, ccp path1, ccp path2, ccp ext )
+{
+    ccp path = PathCatPPE(buf,bufsize,path1,path2,ext);
+    return PathCatBP(buf,bufsize,base,path);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PathAllocBPPE ( ccp base, ccp path1, ccp path2, ccp ext )
+{
+    char buf[PATH_MAX];
+    return STRDUP(PathCatBPPE(buf,sizeof(buf),base,path1,path2,ext));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * PathCombine ( char *buf, uint buf_size, ccp path, ccp base_path )
+{
+    DASSERT(buf);
+    DASSERT( buf_size > 10 );
+
+    if (!path)
+	path = "";
+
+    char *dest = buf;
+    if ( base_path && *base_path && *path != '/' )
+    {
+	StringCopyS(buf,buf_size,base_path);
+	char *p = strrchr(buf,'/');
+	if (p)
+	    dest = p+1;
+    }
+
+    StringCopyE(dest,buf+buf_size,path);
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * PathCombineFast ( char *buf, uint buf_size, ccp path, ccp base_path )
+{
+    DASSERT(buf);
+    DASSERT( buf_size > 10 );
+
+    if (!path)
+	path = "";
+
+    if ( !base_path || !*base_path || *path == '/' )
+	return (char*)path;
+
+    StringCopyS(buf,buf_size,base_path);
+    char *p = strrchr(buf,'/');
+    if (!p)
+	return (char*)path;
+
+    StringCopyE(p+1,buf+buf_size,path);
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * NewFileExtE ( char * buf, ccp buf_end, ccp path, ccp ext )
+{
+    DASSERT( buf);
+    DASSERT( buf_end);
+    DASSERT( buf_end > buf );
+
+    char * end = path && path != buf
+			? StringCopyE(buf,buf_end-1,path)
+			: buf + strlen(buf);
+    DASSERT( end < buf_end );
+
+    char * ptr = end;
+    while ( ptr > buf && *--ptr != '/' )
+	if ( *ptr == '.' )
+	{
+	    end = ptr;
+	    break;
+	}
+
+    if ( ext && *ext )
+    {
+	if ( *ext != '.' )
+	    *end++ = '.';
+	end = StringCopyE(end,buf_end,ext);
+    }
+
+    *end = 0;
+    return end;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * NewFileExtS ( char * buf, size_t bufsize, ccp path, ccp ext )
+{
+    return NewFileExtE(buf,buf+bufsize,path,ext);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int StrPathCmp ( ccp path1, ccp path2 )
+{
+    if ( path1[0] == '.' && path1[1] == '/' )
+	path1 += 2;
+    if ( path2[0] == '.' && path2[1] == '/' )
+	path2 += 2;
+    return strcmp(path1,path2);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int PathCmp
+(
+    ccp		path1,		// NULL or first path
+    ccp		path2,		// NULL or second path
+    uint	mode		// bit field:
+				//  1: skip (multiple) leading './'
+				//  2: compare case insensitive
+				//  4: sort with respect for unsigned decimal numbers
+)
+{
+    if (!path2)
+	return path1 != 0;
+    if (!path1)
+	return -1;
+
+    noPRINT("PathCmp( | %s | %s | %u )\n",path1,path2,mode);
+
+    //--- skip './'
+
+    if ( mode & 1 )
+    {
+	while ( path1[0] == '.' && path1[1] == '/' )
+	    path1 += 2;
+	while ( path2[0] == '.' && path2[1] == '/' )
+	    path2 += 2;
+    }
+
+
+    //--- eliminate equal characters
+
+    while ( *path1 == *path2 )
+    {
+	if (!*path1)
+	    return 0;
+	path1++;
+	path2++;
+    }
+
+
+    //--- start the case+path test
+
+    ccp p1 = path1;
+    ccp p2 = path2;
+
+    const uint ignore_case = mode & 2;
+
+    while ( *p1 || *p2 )
+    {
+	int ch1, ch2;
+	if (ignore_case)
+	{
+	    ch1 = (uchar)tolower((int)*p1++);
+	    ch2 = (uchar)tolower((int)*p2++);
+	}
+	else
+	{
+	    ch1 = (uchar)*p1++;
+	    ch2 = (uchar)*p2++;
+	}
+	int stat = ch1 - ch2;
+	noPRINT("%02x,%02x,%c  %02x,%02x,%c -> %2d\n",
+		p1[-1], ch1, ch1, p2[-1], ch2, ch2, stat );
+
+	if (stat)
+	{
+	    if ( mode & 4 )
+	    {
+		p1--;
+		while ( *p1 == '0' )
+		    p1++;
+		ccp q1 = p1;
+		while ( *q1 >= '0' && *q1 <= '9' )
+		    q1++;
+		const int len1 = q1 - p1;
+
+		if (len1)
+		{
+		    p2--;
+		    while ( *p2 == '0' )
+			p2++;
+		    ccp q2 = p2;
+		    while ( *q2 >= '0' && *q2 <= '9' )
+			q2++;
+		    const int len2 = q2 - p2;
+
+		    if (len2)
+		    {
+			int stat2 = len1 - len2;
+			if (!stat2)
+			    stat2 = memcmp(p1,p2,len1);
+			if (stat2)
+			    return stat2;
+		    }
+		}
+	    }
+	    return ch1 == '/' ? -1 : ch2 == '/' ? 1 : stat;
+	}
+
+	if ( ch1 == '/' )
+	    break;
+    }
+
+    return strcmp(path1,path2);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int StrNumCmp ( ccp a, ccp b )
+{
+    if (!b)
+	return a != 0;
+    if (!a)
+	return -1;
+
+    for(;;)
+    {
+	const int va = *a++ & 0xff;
+	const int vb = *b++ & 0xff;
+	const int delta = va - vb;
+
+	if (delta)
+	{
+	    if ( va < '0' || va > '9' || vb < '0' || vb > '9' )
+		return delta; // no number
+
+	    //--- both are numbers
+
+	    a--;
+	    while ( *a == '0' )
+		a++;
+	    ccp start_a = a;
+	    while ( *a >= '0' && *a <= '9' )
+		a++;
+
+	    b--;
+	    while ( *b == '0' )
+		b++;
+	    ccp start_b = b;
+	    while ( *b >= '0' && *b <= '9' )
+		b++;
+
+	    // compare num length
+	    int num_delta = ( a - start_a ) - ( b - start_b );
+	    if (num_delta)
+		return num_delta;
+
+	    // compare numeric values
+	    while ( start_a < a )
+	    {
+		num_delta = *start_a++ - *start_b++;
+		if (num_delta)
+		    return num_delta;
+	    }
+
+	    // number identical, but not string
+	    return delta;
+	}
+	else if (!va)
+	    return 0;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint CountEqual ( cvp m1, cvp m2, uint size )
+{
+    const u8 *p1 = m1;
+    const u8 *p2 = m2;
+    while ( size-- )
+	if ( *p1++ != *p2++ )
+	    return  p1 - (u8*)m1 - 1;
+    return p1 - (u8*)m1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int ReplaceToBuf
+(
+    // returns -1 on error (buf to small) or the length of the resulting string.
+    // In the later case, a 0 byte is appended, but not counting for the length.
+
+    char	*buf,		// pointer to buf
+    uint	buf_size,	// size of 'buf'
+
+    ccp		src1,		// NULL or source, maybe part of 'buf'
+    int		src1_len,	// length of 'src1', if -1: determine by strlen()
+    int		pos,		// robust replace position, <0: relative to end
+    int		rm_len,		// robust num of chars to remove, <0: rm before 'pos'
+
+    ccp		src2,		// NULL or source to insert, must not be part of 'buf'
+    int		src2_len	// lengh of 'src2', if -1: determine by strlen()
+)
+{
+    DASSERT(buf);
+
+    //--- normalize source #2
+
+    if (!src2)
+	src2_len = 0;
+    else if ( src2_len < 0 )
+	src2_len = strlen(src2);
+
+
+    //--- if source #1 available
+
+    if (src1)
+    {
+	//--- check src1 length
+
+	if ( src1_len < 0 )
+	    src1_len = strlen(src1);
+
+	if (!src1_len)
+	    goto no_src1;
+
+
+	//--- normalize 'pos'
+
+	if ( pos < 0 )
+	{
+	    pos += src1_len;
+	    if ( pos < 0 )
+	    {
+		if ( rm_len > 0 )
+		{
+		    rm_len += pos;
+		    if ( rm_len < 0 )
+			rm_len = 0;
+		}
+		pos = 0;
+	    }
+	}
+	else if ( pos > src1_len )
+	    pos = src1_len;
+
+
+	//--- normalize 'rm_len'
+
+	if ( rm_len < 0 )
+	{
+	    rm_len = -rm_len;
+	    if ( rm_len < pos )
+		pos -= rm_len;
+	    else
+	    {
+		rm_len = pos;
+		pos = 0;
+	    }
+	}
+	else
+	{
+	    const int max = src1_len - pos;
+	    if ( rm_len > max )
+		rm_len = max;
+	}
+
+	const int res_len = src1_len + src2_len - rm_len;
+	if ( res_len >= buf_size )
+	    return -1;
+
+
+	//--- copy src1
+
+	if ( src1 > buf )
+	{
+	    memmove( buf, src1, pos );
+	    const int pos2 = pos + rm_len;
+	    memmove( buf+pos+src2_len, src1+pos2, src1_len-pos2 );
+	}
+	else
+	{
+	    const int pos2 = pos + rm_len;
+	    memmove( buf+pos+src2_len, src1+pos2, src1_len-pos2 );
+	    memmove( buf, src1, pos );
+	}
+
+
+	//--- copy src2 & terminate
+
+	memcpy( buf+pos, src2, src2_len );
+	buf[res_len] = 0;
+	return res_len;
+    }
+
+  no_src1:
+    if ( src2_len < buf_size )
+    {
+	memcpy(buf,src2,src2_len);
+	buf[src2_len] = 0;
+	return src2_len;
+    }
+
+    return -1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int NormalizeIndent ( int indent )
+{
+    return indent < 0 ? 0 : indent < 50 ? indent : 50;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * SkipControls ( ccp src )
+{
+    // skips all character 1..SPACE
+    // 'src' can be NULL
+
+    if (src)
+	while ( *src > 0 && *src <= ' ' )
+	    src++;
+
+    return (char*)src;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * SkipControlsE ( ccp src, ccp end )
+{
+    // skips all character 0..SPACE
+    // if end==NULL: Use SkipControls()
+    // 'src' can be NULL
+
+    if (!end)
+	return SkipControls(src);
+
+    if (src)
+	while ( src < end && (uchar)*src <= ' ' )
+	    src++;
+
+    return (char*)src;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * SkipControls1 ( ccp src, char ch1 )
+{
+    // skips all character 1..SPACE and 'ch1'
+    // 'src' can be NULL
+
+    if (src)
+	while ( *src > 0 && *src <= ' ' || *src == ch1 )
+	    src++;
+
+    return (char*)src;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * SkipControlsE1 ( ccp src, ccp end, char ch1 )
+{
+    // skips all character 0..SPACE and 'ch1'
+    // if end==NULL: Use SkipControls1()
+    // 'src' can be NULL
+
+    if (!end)
+	return SkipControls1(src,ch1);
+
+    if (src)
+	while ( src < end && ( (uchar)*src <= ' ' || *src == ch1 ))
+	    src++;
+
+    return (char*)src;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * SkipControls2 ( ccp src, char ch1, char ch2 )
+{
+    // skips all character 1..SPACE and 'ch1' and 'ch2'
+    // 'src' can be NULL
+
+    if (src)
+	while ( *src > 0 && *src <= ' ' || *src == ch1 || *src == ch2 )
+	    src++;
+
+    return (char*)src;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * SkipControlsE2 ( ccp src, ccp end, char ch1, char ch2 )
+{
+    // skips all character 0..SPACE and 'ch1' and 'ch2'
+    // if end==NULL: Use SkipControls2()
+    // 'src' can be NULL
+
+    if (!end)
+	return SkipControls2(src,ch1,ch2);
+
+    if (src)
+	while ( src < end && ( (uchar)*src <= ' ' || *src == ch1  || *src == ch2 ))
+	    src++;
+
+    return (char*)src;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+// return the number of chars until first EOL ( \0 | \r | \n );
+// pointer are NULL save
+
+uint LineLen ( ccp ptr )
+{
+    if (!ptr)
+	return 0;
+
+    ccp p = ptr;
+    while ( *p && *p != '\n' && *p != '\r' )
+	p++;
+    return p - ptr;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint LineLenE ( ccp ptr, ccp end )
+{
+    if (!ptr)
+	return 0;
+    if (!end)
+	return LineLen(ptr);
+
+    ccp p = ptr;
+    while ( p < end && *p && *p != '\n' && *p != '\r' )
+	p++;
+    return p - ptr;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+uint TrimBlanks
+(
+    char	*str,		// pointer to string, modified
+    ccp		end		// NULL or end of string
+)
+{
+    char *src  = str;
+    char *dest = str;
+
+    bool space = false;
+    while ( end ? src < end : *src )
+    {
+	DASSERT( dest <= src );
+	uchar ch = *src++;
+	if ( ch > ' ' )
+	{
+	    if (space)
+	    {
+		space = false;
+		if ( dest > str )
+		    *dest++ = ' ';
+	    }
+	    *dest++ = ch;
+	}
+	else if ( ch == ' ' )
+	    space = true;
+    }
+
+    if ( !end || dest < end )
+	*dest = 0;
+
+    return dest - str;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanName
+(
+    // return a pointer to the first unused character
+    char	*buf,		// destination buffer, terminated with NULL
+    uint	buf_size,	// size of 'buf', must be >0
+    ccp		str,		// source string
+    ccp		end,		// NULL or end of 'str'
+    bool	allow_signs	// true: allow '-' and '+'
+)
+{
+    DASSERT(buf);
+    DASSERT(buf_size);
+    if (!str)
+    {
+	*buf = 0;
+	return 0;
+    }
+
+    //--- skip leading blanks
+
+    if (end)
+	while ( str < end && (uchar)*str <= ' ' )
+	    str++;
+    else
+	while ( str < end && *str && (uchar)*str <= ' ' )
+	    str++;
+
+    char *dest = buf, *dest_end = buf + buf_size - 1;
+    while ( end ? str < end : *str )
+    {
+	const int ch = *str;
+	if ( isalnum(ch) || ch == '_' || allow_signs && ( ch =='-' || ch == '+' ) )
+	{
+	    str++;
+	    if ( dest < dest_end )
+		*dest++ = toupper(ch);
+	}
+	else
+	    break;
+    }
+    *dest = 0;
+
+    if (end)
+	while ( str < end && (uchar)*str <= ' ' )
+	    str++;
+    else
+	while ( str < end && *str && (uchar)*str <= ' ' )
+	    str++;
+
+    return (char*)str;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintVersion
+(
+    char		* buf,		// result buffer
+					// If NULL, a local circulary static buffer is used
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    u32			version		// version number to print
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 20 );
+
+    version = htonl(version); // we use big endian here
+    const u8 * v = (const u8 *)&version;
+
+    if (v[2])
+    {
+	if ( !v[3] || v[3] == 0xff )
+	    snprintf(buf,buf_size,"%u.%02x.%02x",v[0],v[1],v[2]);
+	else
+	    snprintf(buf,buf_size,"%u.%02x.%02x.beta%u",v[0],v[1],v[2],v[3]);
+    }
+    else
+    {
+	if ( !v[3] || v[3] == 0xff )
+	    snprintf(buf,buf_size,"%u.%02x",v[0],v[1]);
+	else
+	    snprintf(buf,buf_size,"%u.%02x.beta%u",v[0],v[1],v[3]);
+    }
+
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintID
+(
+    const void		* id,		// ID to convert in printable format
+    size_t		id_len,		// len of 'id'
+    void		* buf		// Pointer to buffer, size >= id_len + 1
+					// If NULL, a local circulary static buffer is used
+)
+{
+    if (!buf)
+	buf = GetCircBuf( id_len + 1);
+
+    ccp src = id;
+    char * dest = buf;
+    while ( id_len-- > 0 )
+    {
+	const char ch = *src++;
+	*dest++ = ch >= ' ' && ch < 0x7f ? ch : '.';
+    }
+    *dest = 0;
+
+    return buf;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    circ buf			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static char circ_buf[CIRC_BUF_SIZE];
+static char *circ_ptr = circ_buf;
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * GetCircBuf
+(
+    // never returns NULL, but always ALIGN(4)
+
+    u32		buf_size	// wanted buffer size, caller must add 1 for NULL-term
+				// if buf_size > CIRC_BUF_MAX_ALLOC:
+				//  ==> ERROR0(ERR_OUT_OF_MEMORY)
+)
+{
+    DASSERT( circ_ptr >= circ_buf && circ_ptr <= circ_buf + sizeof(circ_buf) );
+
+    buf_size = buf_size + 3 & ~3;
+    if ( buf_size > CIRC_BUF_MAX_ALLOC )
+    {
+	ERROR0(ERR_OUT_OF_MEMORY,
+		"Circulary buffer too small: needed=%u, half-size=%zu\n",
+		buf_size, sizeof(circ_buf)/2 );
+	ASSERT(0);
+	exit(ERR_OUT_OF_MEMORY);
+    }
+
+    if ( circ_buf + sizeof(circ_buf) - circ_ptr < buf_size )
+	circ_ptr = circ_buf;
+
+    char *result = circ_ptr;
+    circ_ptr = result + buf_size;
+    DASSERT( circ_ptr >= circ_buf && circ_ptr <= circ_buf + sizeof(circ_buf) );
+
+    noPRINT("CIRC-BUF: %3u -> %3zu / %3zu / %3zu\n",
+		buf_size, result-circ_buf, circ_ptr-circ_buf, sizeof(circ_buf) );
+    return result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * CopyCircBuf
+(
+    // never returns NULL, but always ALIGN(4)
+
+    cvp		data,		// source to copy
+    u32		data_size	// see GetCircBuf()
+)
+{
+    char *dest = GetCircBuf(data_size);
+    memcpy(dest,data,data_size);
+    return dest;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * CopyCircBuf0
+(
+    // never returns NULL, but always ALIGN(4)
+    // an additional char is alloced and set to NULL
+
+    cvp		data,		// source to copy
+    u32		data_size	// see GetCircBuf()
+)
+{
+    char *dest = GetCircBuf(data_size+1);
+    memcpy(dest,data,data_size);
+    dest[data_size] = 0;
+    return dest;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintCircBuf
+(
+    ccp		format,		// format string for vsnprintf()
+    ...				// arguments for 'format'
+)
+{
+    char buf[CIRC_BUF_MAX_ALLOC-1];
+    va_list arg;
+    va_start(arg,format);
+    const int len = vsnprintf(buf,sizeof(buf),format,arg);
+    va_end(arg);
+
+    return len > 0 ? CopyCircBuf0(buf,len) : (char*)EmptyString;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ReleaseCircBuf
+(
+    ccp	    end_buf,		// pointer to end of previous alloced buffer
+    uint    release_size	// number of bytes to give back from end
+)
+{
+    DASSERT( circ_ptr >= circ_buf && circ_ptr <= circ_buf + sizeof(circ_buf) );
+
+    if ( end_buf == circ_ptr
+	&& release_size <= CIRC_BUF_MAX_ALLOC
+	&& circ_ptr >= circ_buf + release_size )
+    {
+	circ_ptr -= release_size;
+	DASSERT( circ_ptr >= circ_buf && circ_ptr <= circ_buf + sizeof(circ_buf) );
+    }
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			struct FastBuf_t		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+FastBuf_t * InitializeFastBuf ( cvp mem, uint size )
+{
+    DASSERT(mem);
+    DASSERT( size >= sizeof(FastBuf_t) );
+
+    FastBuf_t *fb = (FastBuf_t*)mem;
+
+    int buf_size = (int)size - offsetof(FastBuf_t,fast_buf);
+    if ( buf_size < sizeof(fb->fast_buf) )
+    {
+	PrintError(__FUNCTION__,__FILE__,__LINE__,0,ERR_OUT_OF_MEMORY,
+		"Out of memory, FastBuf_t is at least %zd bytes to short.",
+			sizeof(fb->fast_buf) - size );
+	ASSERT(0);
+	return 0;
+    }
+
+    fb->fast_buf_size = buf_size;
+    fb->buf = fb->ptr = fb->fast_buf;
+    fb->end = fb->buf + buf_size - 1;
+    DASSERT( fb->buf < fb->end );
+    return fb;
+}
+
+//-----------------------------------------------------------------------------
+
+FastBuf_t * InitializeFastBufAlloc ( FastBuf_t *fb, uint size )
+{
+    DASSERT(fb);
+    InitializeFastBuf(fb,sizeof(*fb));
+
+    const uint new_size = GetGoodAllocSize(size+10);
+    fb->buf = MALLOC(new_size);
+    fb->ptr = fb->buf;
+    fb->end = fb->buf + new_size - 1;
+    return fb;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define RESET_FASTBUF(fb) fb->buf = fb->ptr = fb->fast_buf; \
+			  fb->end = fb->buf + fb->fast_buf_size - 1;
+
+void ResetFastBuf ( FastBuf_t *fb )
+{
+    DASSERT(fb);
+    if ( fb->buf != fb->fast_buf )
+	FREE(fb->buf);
+
+    RESET_FASTBUF(fb)
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp GetFastBufStatus ( const FastBuf_t *fb )
+{
+    char info[100];
+    int len = snprintf(info,sizeof(info),"%s=%u/%u",
+		fb->buf == fb->fast_buf ? "FastBuf" : "Alloc",
+		(uint)(fb->ptr - fb->buf), (uint)(fb->end - fb->buf) );
+    return CopyCircBuf(info,len+1);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * MoveFromFastBufString ( FastBuf_t *fb )
+{
+    DASSERT(fb);
+    *fb->ptr = 0;
+
+    char *res;
+    if ( fb->buf == fb->fast_buf )
+    {
+	res = MEMDUP(fb->buf,fb->ptr-fb->buf);
+	fb->ptr = fb->buf;
+    }
+    else
+    {
+	res = fb->buf;
+	RESET_FASTBUF(fb)
+    }
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+mem_t MoveFromFastBufMem ( FastBuf_t *fb )
+{
+    DASSERT(fb);
+    *fb->ptr = 0;
+
+    mem_t res;
+    res.len = fb->ptr - fb->buf;
+
+    if ( fb->buf == fb->fast_buf )
+    {
+	res.ptr = MEMDUP(fb->buf,res.len);
+	fb->ptr = fb->buf;
+    }
+    else
+    {
+	res.ptr = fb->buf;
+	RESET_FASTBUF(fb)
+    }
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * GetSpaceFastBuf ( FastBuf_t *fb, uint size )
+{
+    DASSERT(fb);
+    if ( size > fb->end - fb->ptr )
+    {
+	const uint used = fb->ptr - fb->buf;
+	const uint new_size = GetGoodAllocSize( used + used/4 + size + 1000 );
+	if ( fb->buf == fb->fast_buf )
+	{
+	    fb->buf = MALLOC(new_size);
+	    memcpy(fb->buf,fb->fast_buf,used);
+	}
+	else
+	    fb->buf = REALLOC(fb->buf,new_size);
+	fb->ptr = fb->buf + used;
+	fb->end = fb->buf + new_size - 1;
+    }
+
+    char *res = fb->ptr;
+    fb->ptr += size;
+    return res;
+}
+
+//-----------------------------------------------------------------------------
+
+int ReserveSpaceFastBuf ( FastBuf_t *fb, uint size )
+{
+    DASSERT(fb);
+    if ( size > 0 )
+	fb->ptr = GetSpaceFastBuf(fb,size);
+    return fb->end - fb->ptr;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint InsertFastBuf ( FastBuf_t *fb, int index, cvp source, int size )
+{
+    DASSERT(fb);
+    DASSERT(source||!size);
+
+    if ( size < 0 )
+	size = strlen(source);
+
+    const uint len = fb->ptr - fb->buf;
+    index = CheckIndex1(len,index);
+    noPRINT("index=%d/%d/%zd, size=%d\n",index,len,fb->end-fb->buf,size);
+
+    char *ptr = GetSpaceFastBuf(fb,size);
+    char *dest = fb->buf + index;
+    DASSERT( dest >= fb->buf );
+    DASSERT( dest + size + len <= fb->end );
+
+    memmove(dest+size,dest,ptr-dest);
+    memcpy(dest,source,size);
+    return index;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * AppendFastBuf ( FastBuf_t *fb, cvp source, int size )
+{
+    DASSERT(fb);
+    DASSERT(source||!size);
+
+    if ( size < 0 )
+	size = strlen(source);
+
+    char *dest = GetSpaceFastBuf(fb,size);
+    memcpy(dest,source,size);
+    return dest;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void AppendUTF8CharFastBuf ( FastBuf_t *fb, u32 code )
+{
+    char buf[8];
+    const uint len = PrintUTF8Char(buf,code) - buf;
+
+    char *dest = GetSpaceFastBuf(fb,len);
+    memcpy(dest,buf,len);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void AppendBE16FastBuf ( FastBuf_t *fb, u16 num )
+{
+    DASSERT(fb);
+
+    char *dest = GetSpaceFastBuf(fb,sizeof(num));
+    write_be16(dest,num);
+}
+
+//-----------------------------------------------------------------------------
+
+void AppendBE32FastBuf ( FastBuf_t *fb, u32 num )
+{
+    DASSERT(fb);
+
+    char *dest = GetSpaceFastBuf(fb,sizeof(num));
+    write_be32(dest,num);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void AppendInt64FastBuf ( FastBuf_t *fb, u64 val, IntMode_t mode )
+{
+    DASSERT(fb);
+
+    switch(mode)
+    {
+	case IMD_UNSET:
+	    AppendFastBuf(fb,&val,sizeof(val));
+	    break;
+
+	case IMD_BE1:
+	case IMD_LE1:	AppendCharFastBuf(fb,val); break;
+
+	case IMD_BE2:	write_be16(GetSpaceFastBuf(fb,2),val); break;
+	case IMD_BE3:	write_be24(GetSpaceFastBuf(fb,3),val); break;
+	case IMD_BE4:	write_be32(GetSpaceFastBuf(fb,4),val); break;
+	case IMD_BE5:	write_be40(GetSpaceFastBuf(fb,5),val); break;
+	case IMD_BE6:	write_be48(GetSpaceFastBuf(fb,6),val); break;
+	case IMD_BE7:	write_be56(GetSpaceFastBuf(fb,7),val); break;
+	case IMD_BE0:
+	case IMD_BE8:	write_be64(GetSpaceFastBuf(fb,8),val); break;
+
+	case IMD_LE2:	write_le16(GetSpaceFastBuf(fb,2),val); break;
+	case IMD_LE3:	write_le24(GetSpaceFastBuf(fb,3),val); break;
+	case IMD_LE4:	write_le32(GetSpaceFastBuf(fb,4),val); break;
+	case IMD_LE5:	write_le40(GetSpaceFastBuf(fb,5),val); break;
+	case IMD_LE6:	write_le48(GetSpaceFastBuf(fb,6),val); break;
+	case IMD_LE7:	write_le56(GetSpaceFastBuf(fb,7),val); break;
+	case IMD_LE0:
+	case IMD_LE8:	write_le64(GetSpaceFastBuf(fb,8),val); break;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char *  WriteFastBuf ( FastBuf_t *fb, uint offset, cvp source, int size )
+{
+    DASSERT(fb);
+
+    uint oldlen = fb->ptr - fb->buf;
+    uint minlen = offset + size;
+    if ( minlen > oldlen )
+    {
+	char *ptr = GetSpaceFastBuf(fb,minlen-oldlen);
+	memset(ptr,0,minlen-oldlen);
+    }
+    DASSERT( fb->ptr - fb->buf >= minlen );
+    char *dest = fb->buf + offset;
+    if (source)
+	memcpy( dest, source, size );
+    return dest;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint AssignFastBuf ( FastBuf_t *fb, cvp source, int size )
+{
+    DASSERT(fb);
+
+    if ( size < 0 )
+	size = strlen(source);
+
+    if ( source == fb->buf )
+    {
+	const uint used = fb->ptr - fb->buf;
+	if ( size < used )
+	    fb->ptr = fb->buf + size;
+	else
+	    size = used;
+    }
+    else
+    {
+	fb->ptr = fb->buf;
+	if (source)
+	    AppendFastBuf(fb,source,size);
+	*fb->ptr = 0;
+    }
+    return size;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint DropFastBuf ( FastBuf_t *fb, int index, int size )
+{
+    DASSERT(fb);
+    if (size)
+    {
+	const uint len = fb->ptr - fb->buf;
+	index = CheckIndex1(len,index);
+	if ( size < 0 )
+	{
+	    size = -size;
+	    if ( size > index )
+		size = index;
+	    index -= size;
+	}
+	int index2 = CheckIndex1(len,index+size);
+	size = index2 - index;
+	if (size)
+	{
+	    memmove(fb->buf+index,fb->buf+index2,len-index2+1);
+	    fb->ptr -= size;
+	}
+    }
+
+    return size;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void CopyFastBuf ( FastBuf_t *dest, const FastBuf_t *src )
+{
+    if ( dest && dest != src )
+    {
+	if (!src)
+	    ClearFastBuf(dest);
+	else
+	    AssignFastBuf( dest, src->buf, src->ptr - src->buf );
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void MoveFastBuf ( FastBuf_t *dest, FastBuf_t *src )
+{
+    if ( dest && src && dest != src )
+    {
+	if ( src->buf != src->fast_buf )
+	{
+	    // src is allocated
+	    if ( dest->buf != dest->fast_buf )
+		FREE(dest->buf);
+	    dest->buf = src->buf;
+	    dest->ptr = src->ptr;
+	    dest->end = src->end;
+	    InitializeFastBuf( src, offsetof(FastBuf_t,fast_buf) + src->fast_buf_size );
+	}
+	else
+	    AssignFastBuf( dest, src->buf, src->ptr - src->buf );
+    }
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    alloc info			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+bool alloc_info_calced		= false;
+uint alloc_info_overhead	=   8;	// default values
+uint alloc_info_block_size	=  16;
+uint alloc_info_add1		=   7;
+uint alloc_info_add2		=   8;
+uint alloc_info_mask		= ~15;
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint SetupAllocInfo()
+{
+    if (!alloc_info_calced)
+    {
+	alloc_info_calced = true;
+
+	enum { MAX = 200 };
+
+	char *alloc[MAX+1];
+	memset(alloc,0,sizeof(alloc));
+
+	uint i, mask_found = ~0;
+	for ( i = 1; i <= MAX; i++ )
+	{
+	    alloc[i] = (char*)MALLOC(i);
+	    noPRINT("%4x: %p [%zx]\n",i,alloc[i],alloc[i]-alloc[ i>0 ? i-1 : 0 ] );
+	    if ( i > 1 )
+	    {
+		int diff = abs ( alloc[i-1] - alloc[i] );
+		mask_found &= diff - 1;
+	    }
+	}
+	const int lo0 = FindLowest0Bit(&mask_found,1);
+	const int hi1 = FindHighest1Bit(&mask_found,1);
+	PRINT("mask: %08x, lo0=%d, hi1=%d\n",mask_found,lo0,hi1);
+
+	if ( hi1 + 1 == lo0 )
+	{
+	    // -> maske besteht aus hi1 '1' gefolgt von ausnahmslos '0'
+
+	    alloc_info_mask = ~mask_found;
+	    alloc_info_block_size = mask_found + 1;
+	    PRINT("alloc_info_block_size = %d, alloc_info_mask = 0x%x\n",
+			alloc_info_block_size, alloc_info_mask );
+
+	    int found = 0x100;
+	    for ( i = 2; i <= MAX; i++ )
+	    {
+		const int diff = abs ( alloc[i-1] - alloc[i] ) - i;
+		if ( diff >= 0 && found > diff )
+		    found = diff;
+	    }
+
+	    if ( found < MAX )
+	    {
+		alloc_info_overhead = found;
+		found %= alloc_info_block_size;
+		alloc_info_add1 = found - 1;
+		alloc_info_add2 = alloc_info_block_size - found;
+		PRINT("alloc_info_overhead = %d, alloc_info_add = %d, %d\n",
+			alloc_info_overhead, alloc_info_add1, alloc_info_add2 );
+	    }
+	}
+
+	for ( i = 1; i <= MAX; i++ )
+	    FREE(alloc[i]);
+    }
+
+    return alloc_info_block_size;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    SplitArg_t			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetSplitArg ( SplitArg_t *sa )
+{
+    DASSERT(sa);
+    FREE(sa->argv);
+    FREE(sa->temp);
+    InitializeSplitArg(sa);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanSplitArg
+(
+    // returns arg->argc;
+
+    SplitArg_t	    *arg,	// pointer to object
+    bool	    init_arg,	// true: call InitializeSplitArg()
+    ccp		    src,	// NULL or source string
+    ccp		    src_end,	// end of 'src'; if NULL: calculated by strlen(src)
+    char	    *work_buf	// pointer to a buffer for strings, may be 'src'
+				// size must be: length of 'src' + 1
+				// if NULL, a temporary buffer is alloced.
+)
+{
+    DASSERT(arg);
+    if (init_arg)
+	InitializeSplitArg(arg);
+    else
+	ResetSplitArg(arg);
+
+    if (!src)
+	src = EmptyString;
+    if (!src_end)
+	src_end = src + strlen(src);
+
+ #ifdef TEST0
+    enum { N_PREDEF = 5 };
+ #else
+    enum { N_PREDEF = 250 };
+ #endif
+    char *argv_predef[N_PREDEF+1],
+	**argv_buf  = argv_predef,
+	**argv_dest = argv_predef,
+	**argv_end  = argv_predef + N_PREDEF;
+    *argv_dest++ = progname ? (char*)progname : "";
+    uint argv_size = 0;
+
+    if (!work_buf)
+    {
+	arg->temp_size = src_end - src + 1;
+	arg->temp = work_buf = MALLOC(arg->temp_size);
+    }
+    char *dest = work_buf;
+
+
+    //--- main loop
+
+    for(;;)
+    {
+	while ( src < src_end
+		&& ( !*src || *src == ' ' || *src == '\t' || *src == '\r' || *src == '\n' ))
+	{
+	    src++;
+	}
+	if ( src == src_end )
+	    break;
+
+	if ( argv_dest == argv_end )
+	{
+	    PRINT("NEED MORE: %zu/%zu size=%u: |%s|\n",
+			argv_dest-argv_buf, argv_end-argv_buf, argv_size, src );
+	    const uint idx = argv_dest - argv_buf;
+	    if (argv_size)
+	    {
+		argv_size += N_PREDEF;
+		argv_buf = REALLOC(argv_buf,(argv_size+1)*sizeof(*argv_buf));
+	    }
+	    else
+	    {
+		argv_size = 2*N_PREDEF;
+		char **temp = MALLOC((argv_size+1)*sizeof(*argv_buf));
+		memcpy(temp,argv_buf,idx*sizeof(*argv_buf));
+		argv_buf = temp;
+	    }
+	    argv_dest = argv_buf + idx;
+	    argv_end  = argv_buf + argv_size;
+	}
+
+	*argv_dest++ = dest;
+	while ( src < src_end )
+	{
+	    const char ch = *src;
+	    if ( !ch || ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n' )
+		break;
+	    src++;
+	    if ( ch == '\\' && src < src_end )
+		*dest++ = *src++;
+	    else if ( ch == '\'' )
+	    {
+		while ( src < src_end && *src != '\'' )
+		    *dest++ = *src++;
+		if ( src < src_end )
+		    src++;
+	    }
+	    else if ( ch == '"'  )
+	    {
+		while ( src < src_end && *src != '"' )
+		{
+		    char ch = *src++;
+		    if ( ch == '\\' )
+		    {
+			uint code;
+			src = ScanEscape(&code,src,src_end);
+			ch = code;
+		    }
+		    *dest++ = ch;
+		}
+		if ( src < src_end )
+		    src++;
+	    }
+	    else
+		*dest++ = ch;
+	}
+	*dest++ = 0;
+    }
+
+    *argv_dest = 0;
+    arg->argc = argv_dest - argv_buf;
+    if ( argv_size )
+    {
+	DASSERT( argv_buf != argv_predef );
+	arg->argv_size = argv_size;
+	arg->argv = argv_buf;
+    }
+    else
+    {
+	DASSERT( argv_buf == argv_predef );
+	arg->argv_size = arg->argc;
+	arg->argv = MEMDUP(argv_buf,(arg->argv_size+1)*sizeof(*argv_dest));
+    }
+
+    return arg->argc;
+};
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			struct mem_t			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+mem_t EmptyMem	= {EmptyString,0};
+mem_t NullMem	= {0,0};
+
+///////////////////////////////////////////////////////////////////////////////
+
+mem_t MidMem ( const mem_t src, int begin, int count )
+{
+    begin = CheckIndex1(src.len,begin);
+    if ( count < 0 )
+    {
+	count  = -count;
+	begin -= count;
+	if ( begin < 0 )
+	{
+	    count += begin;
+	    begin  = 0;
+	}
+    }
+
+    mem_t res;
+    res.ptr = src.ptr + begin;
+    const int max = src.len - begin;
+    res.len = count < max ? count : max;
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+mem_t BeforeMem ( const mem_t src, ccp ref )
+{
+    mem_t res;
+    res.ptr = src.ptr;
+    res.len = ref < src.ptr		? 0
+	    : ref <= src.ptr + src.len	? ref - src.ptr
+	    : src.len;
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+mem_t BehindMem ( const mem_t src, ccp ref )
+{
+    mem_t res;
+    if ( ref <= src.ptr )
+	res = src;
+    else if ( ref <= src.ptr + src.len )
+    {
+	res.ptr = ref;
+	res.len = src.ptr + src.len - ref;
+    }
+    else
+    {
+	res.ptr = src.ptr + src.len;
+	res.len = 0;
+    }
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int CmpMem ( const mem_t s1, const mem_t s2 )
+{
+    if ( s1.len < s2.len )
+    {
+	const int stat = memcmp(s1.ptr,s2.ptr,s1.len);
+	return stat ? stat : -1;
+    }
+
+    const int stat = memcmp(s1.ptr,s2.ptr,s2.len);
+    return stat ? stat : s1.len > s2.len;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int StrCmpMem ( const mem_t mem, ccp str )
+{
+    const uint slen = str ? strlen(str) : 0;
+
+    if ( mem.len < slen )
+    {
+	const int stat = memcmp(mem.ptr,str,mem.len);
+	return stat ? stat : -1;
+    }
+
+    const int stat = memcmp(mem.ptr,str,slen);
+    return stat ? stat : mem.len > slen;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool LeftStrCmpMemEQ ( const mem_t mem, ccp str )
+{
+    const uint slen = str ? strlen(str) : 0;
+    return mem.len <= slen && !memcmp(mem.ptr,str,mem.len);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+mem_t MemCat2A ( const mem_t m1, const mem_t m2 )
+{
+    const uint len1 = m1.len >= 0 ? m1.len : strlen(m1.ptr);
+    const uint len2 = m2.len >= 0 ? m2.len : strlen(m2.ptr);
+
+    char *dest;
+    mem_t res;
+    res.len = len1 + len2;
+    res.ptr = dest = MALLOC(res.len+1);
+    dest[res.len] = 0;
+
+    if (len1)
+	memcpy(dest,m1.ptr,len1);
+    if (len2)
+	memcpy(dest+len1,m2.ptr,len2);
+
+    return res;
+}
+
+//-----------------------------------------------------------------------------
+
+mem_t MemCat3A ( const mem_t m1, const mem_t m2, const mem_t m3 )
+{
+    const uint len1 = m1.len >= 0 ? m1.len : strlen(m1.ptr);
+    const uint len2 = m2.len >= 0 ? m2.len : strlen(m2.ptr);
+    const uint len3 = m3.len >= 0 ? m3.len : strlen(m3.ptr);
+
+    char *dest;
+    mem_t res;
+    res.len = len1 + len2 + len3;
+    res.ptr = dest = MALLOC(res.len+1);
+    dest[res.len] = 0;
+
+    if (len1)
+	memcpy(dest,m1.ptr,len1);
+    if (len2)
+	memcpy(dest+len1,m2.ptr,len2);
+    if (len3)
+	memcpy(dest+len1+len2,m3.ptr,len3);
+
+    return res;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			struct mem_list_t		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void InitializeMemList ( mem_list_t *ml )
+{
+    DASSERT(ml);
+    memset(ml,0,sizeof(*ml));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetMemList ( mem_list_t *ml )
+{
+    DASSERT(ml);
+    FREE(ml->list);
+    FREE(ml->buf);
+    memset(ml,0,sizeof(*ml));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void MoveMemList ( mem_list_t *dest, mem_list_t *src )
+{
+    if ( dest != src )
+    {
+	if (!dest)
+	    ResetMemList(src);
+	else
+	{
+	    ResetMemList(dest);
+	    if (src)
+	    {
+		memcpy(dest,src,sizeof(*dest));
+		memset(src,0,sizeof(*src));
+	    }
+	}
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void GrowBufMemList ( mem_list_t *ml, uint need_size )
+{
+    if ( ml->buf_size < need_size )
+    {
+	PRINT("MEM-LIST: MALLOC/BUF(%u)\n",need_size);
+	char *new_buf = MALLOC(need_size);
+
+	//--- copy existing strings
+
+	char *bufptr = new_buf;
+	mem_t *dest = ml->list;
+	uint i;
+	for ( i = 0; i < ml->used; i++, dest++ )
+	    if ( dest->len )
+	    {
+		memcpy(bufptr,dest->ptr,dest->len);
+		dest->ptr = bufptr;
+		bufptr += dest->len;
+		*bufptr++ = 0;
+		DASSERT( bufptr <= new_buf + need_size );
+		noPRINT("OLD: %p,%u\n",dest->ptr,dest->len);
+	    }
+	FREE(ml->buf);
+	ml->buf = new_buf;
+	ml->buf_used = bufptr - new_buf;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void PrepareMemList ( mem_list_t *ml, uint n_elem, uint buf_size )
+{
+    DASSERT(ml);
+    if ( ml->size < n_elem )
+    {
+	ml->size = n_elem;
+	PRINT("MEM-LIST: REALLOC/LIST(%u)\n",ml->size);
+	ml->list = REALLOC(ml->list,sizeof(*ml->list)*ml->size);
+    }
+
+    GrowBufMemList(ml,buf_size);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void InsertMemListN
+(
+    mem_list_t		*ml,		// valid destination mem_list
+    int			pos,		// insert position => CheckIndex1()
+    const mem_t		*src,		// source list
+    uint		src_len,	// number of elements in source list
+    uint		src_ignore	// 0: insert all
+					// 1: ignore NULL
+					// 2: ignore NULL and empty
+					// 3: replace NULL by EmptyString
+)
+{
+    DASSERT(ml);
+    DASSERT( src || !src_len );
+
+    //--- count needed size and elements
+
+    const mem_t	*sptr, *src_end = src + src_len;
+
+    uint need_size = 0, add_elem = 0;
+    for ( sptr = src; sptr < src_end; sptr++ )
+    {
+	if ( sptr->len )
+	{
+	    need_size += sptr->len + 1; // always terminate with NULL
+	    add_elem++;
+	}
+	else if ( !src_ignore || src_ignore == 1 && sptr->ptr || src_ignore == 3 )
+	    add_elem++;
+    }
+
+    if (!add_elem)
+	return;
+
+
+    //--- string pool management
+
+    if (!ml->used)
+	ml->buf_used = 0;
+
+    char *new_buf, *bufptr;
+    if ( ml->buf_used + need_size <= ml->buf_size )
+    {
+	new_buf = 0;
+	bufptr = ml->buf + ml->buf_used;
+	ml->buf_used += need_size;
+    }
+    else
+    {
+	need_size += ml->buf_used + 20;
+	need_size += need_size/10;
+
+	// don't use GrowBufMemList() here, because the old buffer is needed
+	// BUT: char old_buf = ml->buf; ml->buf = 0; GrowBufMemList(ml,need_size)
+
+	PRINT("MEM-LIST: MALLOC/BUF(%u)\n",need_size);
+	bufptr = new_buf = MALLOC(need_size);
+
+	//--- copy existing strings
+
+	mem_t *dest = ml->list;
+	uint i;
+	for ( i = 0; i < ml->used; i++, dest++ )
+	    if ( dest->len )
+	    {
+		memcpy(bufptr,dest->ptr,dest->len);
+		dest->ptr = bufptr;
+		bufptr += dest->len;
+		*bufptr++ = 0;
+		DASSERT( bufptr <= new_buf+need_size );
+		noPRINT("OLD: %p,%u\n",dest->ptr,dest->len);
+	    }
+    }
+
+
+    //--- realloc list if necessary
+
+    const uint need_elem = ml->used + add_elem;
+    if ( need_elem > ml->size )
+    {
+	ml->size = need_elem + 5 + need_elem/10;
+	PRINT("MEM-LIST: REALLOC/LIST(%u)\n",ml->size);
+	ml->list = REALLOC(ml->list,sizeof(*ml->list)*ml->size);
+    }
+
+    pos = CheckIndex1(ml->used,pos);
+    mem_t *dest = ml->list + pos;
+    if ( pos < ml->used )
+	memmove(dest+add_elem,dest,sizeof(*dest)*(ml->used-pos));
+    ml->used += add_elem;
+
+
+    //--- iterate source list
+
+    for ( sptr = src; sptr < src_end; sptr++ )
+    {
+	if (sptr->len)
+	{
+	    dest->ptr = bufptr;
+	    memcpy(bufptr,sptr->ptr,sptr->len);
+	    dest->len = sptr->len;
+	    bufptr += sptr->len;
+	    *bufptr++ = 0;
+	    DASSERT( bufptr <= ( new_buf ? new_buf+need_size : ml->buf + ml->buf_size ) );
+	    noPRINT("NEW: %p,%u\n",dest->ptr,dest->len);
+	    dest++;
+	    DASSERT( dest <= ml->list + ml->used );
+	}
+	else if ( !src_ignore || src_ignore == 1 && sptr->ptr )
+	{
+	    dest->ptr = sptr->ptr ? EmptyString : NULL;
+	    dest->len = 0;
+	    dest++;
+	    DASSERT( dest <= ml->list + ml->used );
+	}
+	else if ( src_ignore == 3 )
+	{
+	    dest->ptr = EmptyString;
+	    dest->len = 0;
+	    dest++;
+	    DASSERT( dest <= ml->list + ml->used );
+	}
+    }
+    DASSERT_MSG( dest == ml->list + pos + add_elem,
+		"DEST= %zu != %u+%u == %u",
+		dest-ml->list, pos, add_elem, pos+add_elem );
+
+
+    //--- clean
+
+    if (new_buf)
+    {
+	DASSERT(ml->buf != new_buf);
+	FREE(ml->buf);
+	ml->buf = new_buf;
+	ml->buf_size = need_size;
+    }
+    ml->buf_used = bufptr - ml->buf;
+    DASSERT( ml->buf_used <= ml->buf_size );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void CatMemListN
+(
+    mem_list_t		*dest,		// valid destination mem_list
+    const mem_list_t	**src_list,	// list with mem lists, element may be NULL
+    uint		n_src_list,	// number of elements in 'src'
+    uint		src_ignore	// 0: insert all
+					// 1: ignore NULL
+					// 2: ignore NULL and empty
+					// 3: replace NULL by EmptyString
+)
+{
+    DASSERT(dest);
+    DASSERT( src_list || !n_src_list );
+
+
+    //--- count needed size and elements
+
+    uint need_size = 0, need_elem = 0;
+    bool dest_is_source = false;
+
+    const mem_list_t **list_ptr, **src_list_end = src_list + n_src_list;
+    for ( list_ptr = src_list; list_ptr < src_list_end; list_ptr++ )
+    {
+	if (!*list_ptr)
+	    continue;
+
+	if ( *list_ptr == dest )
+	    dest_is_source = true;
+
+	const mem_t *sptr = (*list_ptr)->list, *send = sptr + (*list_ptr)->used;
+	for ( ; sptr < send; sptr++ )
+	{
+	    if ( sptr->len )
+	    {
+		need_size += sptr->len + 1; // always terminate with NULL
+		need_elem++;
+	    }
+	    else if ( !src_ignore || src_ignore == 1 && sptr->ptr || src_ignore == 3 )
+		need_elem++;
+	}
+    }
+
+    PRINT("CatMemList(N=%u) n_elem=%u, size=%u, dest_is_source=%d\n",
+		n_src_list,need_elem,need_size,dest_is_source);
+    if (!need_elem)
+    {
+	dest->used = 0;
+	return;
+    }
+
+
+    //--- setup dest buffers
+
+    char *new_buf = dest_is_source || need_size > dest->buf_size
+			? MALLOC(need_size) : dest->buf;
+    mem_t *new_list = dest_is_source || need_elem > dest->size
+			? MALLOC(sizeof(*new_list)*need_elem) : dest->list;
+
+
+
+    //--- assign values
+
+    char *bufptr = new_buf;
+    mem_t *listptr = new_list;
+
+    for ( list_ptr = src_list; list_ptr < src_list_end; list_ptr++ )
+    {
+	if (!*list_ptr)
+	    continue;
+
+	const mem_t *sptr = (*list_ptr)->list, *send = sptr + (*list_ptr)->used;
+	for ( ; sptr < send; sptr++ )
+	{
+	    if (sptr->len)
+	    {
+		listptr->ptr = bufptr;
+		memcpy(bufptr,sptr->ptr,sptr->len);
+		listptr->len = sptr->len;
+		bufptr += sptr->len;
+		*bufptr++ = 0;
+		DASSERT( bufptr <= new_buf + need_size );
+		noPRINT("NEW: %p,%u\n",dest->ptr,dest->len);
+		listptr++;
+		DASSERT( listptr <= new_list + need_elem );
+	    }
+	    else if ( !src_ignore || src_ignore == 1 && sptr->ptr )
+	    {
+		listptr->ptr = sptr->ptr ? EmptyString : NULL;
+		listptr->len = 0;
+		listptr++;
+		DASSERT( listptr <= new_list + need_elem );
+	    }
+	    else if ( src_ignore == 3 )
+	    {
+		listptr->ptr = EmptyString;
+		listptr->len = 0;
+		listptr++;
+		DASSERT( listptr <= new_list + need_elem );
+	    }
+	}
+    }
+    DASSERT( bufptr == new_buf + need_size );
+    DASSERT( listptr == new_list + need_elem );
+
+
+    //--- terminate
+
+    dest->buf_used = need_size;
+    if ( new_buf != dest->buf )
+    {
+	FREE(dest->buf);
+	dest->buf = new_buf;
+	dest->buf_size = need_size;
+    }
+
+    dest->used = need_elem;
+    if ( new_list != dest->list )
+    {
+	FREE(dest->list);
+	dest->list = new_list;
+	dest->size = need_elem;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+uint LeftMemList ( mem_list_t *ml, int count )
+{
+    DASSERT(ml);
+    return ml->used = CheckIndex1(ml->used,count);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint RightMemList ( mem_list_t *ml, int count )
+{
+    DASSERT(ml);
+
+    const uint begin = CheckIndex1End(ml->used,-count);
+    if (begin)
+    {
+	ml->used -= begin;
+	memmove( ml->list, ml->list + begin, ml->used * sizeof(*ml->list) );
+    }
+    return ml->used;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint MidMemList ( mem_list_t *ml, int begin, int count )
+{
+    DASSERT(ml);
+
+    begin = CheckIndex1(ml->used,begin);
+    if ( count < 0 )
+    {
+	count  = -count;
+	begin -= count;
+	if ( begin < 0 )
+	{
+	    count += begin;
+	    begin  = 0;
+	}
+    }
+
+    const uint max = ml->used - begin;
+    if ( count > max )
+	count = max;
+    memmove( ml->list, ml->list + begin, count * sizeof(*ml->list) );
+    return ml->used = count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint ExtractMemList ( mem_list_t *ml, int begin, int end )
+{
+    DASSERT(ml);
+    ml->used = CheckIndex2(ml->used,&begin,&end);
+    memmove( ml->list, ml->list + begin, ml->used * sizeof(*ml->list) );
+    return ml->used;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint ExtractEndMemList ( mem_list_t *ml, int begin, int end )
+{
+    DASSERT(ml);
+    ml->used = CheckIndex2End(ml->used,&begin,&end);
+    memmove( ml->list, ml->list + begin, ml->used * sizeof(*ml->list) );
+    return ml->used;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint RemoveMemList ( mem_list_t *ml, int begin, int end )
+{
+    DASSERT(ml);
+    const uint sub = CheckIndex2(ml->used,&begin,&end);
+    memmove( ml->list + begin, ml->list + end, ( ml->used - end ) * sizeof(*ml->list) );
+    return ml->used -= sub;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint RemoveEndMemList ( mem_list_t *ml, int begin, int end )
+{
+    DASSERT(ml);
+    const uint sub = CheckIndex2End(ml->used,&begin,&end);
+    memmove( ml->list + begin, ml->list + end, ( ml->used - end ) * sizeof(*ml->list) );
+    return ml->used -= sub;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    MemPool_t			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetMemPool ( MemPool_t *mp )
+{
+    DASSERT(mp);
+    MemPoolChunk_t *ptr = mp->chunk;
+    while (ptr)
+    {
+	MemPoolChunk_t *next = ptr->next;
+	FREE(ptr);
+	ptr = next;
+    }
+    InitializeMemPool(mp,mp->chunk_size);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void * MallocMemPool ( MemPool_t *mp, uint size )
+{
+    DASSERT(mp);
+    if (!size)
+	return (char*)EmptyString;
+
+    if ( size > mp->space )
+    {
+	uint data_size = size > mp->chunk_size ? size : mp->chunk_size;
+	if ( data_size < 0x400 )
+	    data_size = 0x400;
+	MemPoolChunk_t *chunk = MALLOC(sizeof(MemPoolChunk_t)+data_size);
+	DASSERT(chunk);
+	chunk->next = mp->chunk;
+	mp->chunk = chunk;
+	mp->space = data_size;
+    }
+
+    DASSERT(mp->chunk);
+    DASSERT(mp->space >= size );
+
+    mp->space -= size;
+    return mp->chunk->data + mp->space;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void * CallocMemPool ( MemPool_t *mp, uint size )
+{
+    DASSERT(mp);
+    void *res = MallocMemPool(mp,size);
+    DASSERT(res);
+    memset(res,0,size);
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void * MallocMemPoolA ( MemPool_t *mp, uint size, uint align )
+{
+    DASSERT(mp);
+    char *res = MallocMemPool(mp,size);
+    DASSERT(res);
+    const uint fix = mp->space - mp->space / align * align;
+    res -= fix;
+    mp->space -= fix;
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void * CallocMemPoolA ( MemPool_t *mp, uint size, uint align )
+{
+    DASSERT(mp);
+    void *res = MallocMemPoolA(mp,size,align);
+    DASSERT(res);
+    memset(res,0,size);
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void * MemDupMemPool ( MemPool_t *mp, cvp source, uint size )
+{
+    DASSERT(mp);
+    DASSERT(source||!size);
+
+    char *res = MallocMemPool(mp,size+1);
+    memcpy(res,source,size);
+    res[size] = 0;
+    return res;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    CircBuf_t			///////////////
+///////////////////////////////////////////////////////////////////////////////
+// [[CircBuf_t]]
+
+void InitializeCircBuf ( CircBuf_t *cb, uint size )
+{
+    DASSERT(cb);
+    memset(cb,0,sizeof(*cb));
+    cb->size = size; //data is alloced on first insertion
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetCircBuf ( CircBuf_t *cb )
+{
+    DASSERT(cb);
+    FREE(cb->buf);
+    cb->buf = 0;
+    cb->used = cb->pos = 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint WriteCircBuf ( CircBuf_t *cb, cvp data, uint size )
+{
+    DASSERT(cb);
+    DASSERT(data||!size);
+
+    if ( !size || !cb->size )
+	return 0;
+
+    if (!cb->buf)
+    {
+	cb->buf = MALLOC(cb->size);
+	DASSERT(cb->buf);
+	cb->used = cb->pos = 0;
+    }
+
+    ccp d = data;
+    if ( size >= cb->size )
+    {
+	cb->used = cb->size;
+	cb->pos = 0;
+	memcpy( cb->buf, d + (size-cb->size), cb->size );
+	//fprintf(stderr,"INS*: %d+%d = %d / %d\n",cb->pos,cb->used,cb->pos+cb->used,cb->size);
+	return cb->size;
+    }
+
+    const int ins_count = size;
+    int ins_pos = cb->pos + cb->used;
+    if ( ins_pos >= cb->size )
+	ins_pos -= cb->size;
+
+    if ( ins_pos + size > cb->size )
+    {
+	const uint copy_len = cb->size - ins_pos;
+	//fprintf(stderr,"COPY %u..%u\n",ins_pos,ins_pos+copy_len);
+	memcpy( cb->buf + ins_pos, d, copy_len );
+	size	-= copy_len;
+	d	+= copy_len;
+	ins_pos	 = 0;
+    }
+
+    DASSERT( size > 0 );
+    DASSERT( ins_pos <= cb->size );
+    DASSERT( ins_pos + size <= cb->size );
+    //fprintf(stderr,"COPY %u..%u\n",ins_pos,ins_pos+size);
+    memcpy( cb->buf + ins_pos, d, size );
+
+    cb->used += ins_count;
+    if ( cb->used > cb->size )
+    {
+	cb->pos += cb->used - cb->size;
+	if ( cb->pos >= cb->size )
+	    cb->pos -= cb->size;
+	cb->used = cb->size;
+    }
+
+    //fprintf(stderr,"INS: %d+%d = %d / %d\n",cb->pos,cb->used,cb->pos+cb->used,cb->size);
+    return ins_count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint PeakCircBuf ( CircBuf_t *cb, char *buf, uint buf_size )
+{
+    DASSERT(cb);
+    DASSERT(buf||!buf_size);
+
+    if ( !cb->size || !buf_size )
+	return 0;
+
+    if ( buf_size > cb->used )
+	buf_size = cb->used;
+
+    uint count = cb->size - cb->pos;
+    if ( count > buf_size )
+	count -= buf_size;
+
+    memcpy( buf, cb->buf + cb->pos, count );
+    if ( count < buf_size )
+    {
+	const uint copy_len = buf_size - count;
+	memcpy( buf+count, cb->buf, copy_len );
+	count += copy_len;
+    }
+    return count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint ReadCircBuf ( CircBuf_t *cb, char *buf, uint buf_size )
+{
+    DASSERT(cb);
+    const uint count = PeakCircBuf(cb,buf,buf_size);
+    return DropCircBuf(cb,count);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint DropCircBuf ( CircBuf_t *cb, uint size )
+{
+    DASSERT(cb);
+
+    if ( size >= cb->used )
+    {
+	const uint res = cb->used;
+	cb->pos = cb->used = 0;
+	return res;
+    }
+
+    cb->used -= size;
+    cb->pos += size;
+    if ( cb->pos >= cb->size )
+	cb->pos -= cb->size;
+    return size;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ClearCircBuf ( CircBuf_t *cb )
+{
+    DASSERT(cb);
+    cb->used = cb->pos = 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint PurgeCircBuf ( CircBuf_t *cb )
+{
+    DASSERT(cb);
+
+    if ( cb->used && cb->pos )
+    {
+	char *temp = MALLOC(cb->size);
+	PeakCircBuf(cb,temp,cb->used);
+	FREE(cb->buf);
+	cb->buf = temp;
+    }
+    cb->pos = 0;
+    return cb->used;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		    enum CopyMode_t interface		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void * CopyData
+(
+    const void		*data,		// data to copy/move/link
+    uint		size,		// size of 'data'
+    CopyMode_t		mode,		// copy mode
+    bool		*res_alloced	// not NULL:
+					//   store true, if data must be freed
+					//   otherwise store false
+)
+{
+    DASSERT( data || !size );
+    if ( !data || !size )
+    {
+	if (res_alloced)
+	    *res_alloced = false;
+	return (void*)EmptyString;
+    }
+
+    if (res_alloced)
+	*res_alloced = mode != CPM_LINK;
+
+    return mode == CPM_MOVE || mode == CPM_LINK
+		? (void*)data
+		: MEMDUP(data,size);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void FreeData
+(
+    const void		*data,		// data to free
+    CopyMode_t		mode		// copy mode
+)
+{
+    if ( mode != CPM_LINK && data != EmptyString )
+	FREE((void*)data);
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		ContainerData_t, Container_t		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+Container_t * CreateContainer
+(
+    // returns 'c' or the alloced container
+    // 'c' is always initialized
+
+    Container_t		*c,		// valid container, alloc one if NULL
+    int			protect,	// initial value for protection
+    const void		*data,		// data to copy/move/link
+    uint		size,		// size of 'data'
+    CopyMode_t		mode		// copy mode on creation
+)
+{
+    if (!c)
+	c = MALLOC(sizeof(*c));
+    memset(c,0,sizeof(*c));
+    c->protect_level = protect;
+
+    ContainerData_t *cdata = CALLOC(sizeof(*cdata),1);
+    c->cdata		= cdata;
+
+    cdata->data		= CopyData(data,size,mode,&cdata->data_alloced);
+    cdata->size		= size;
+    cdata->ref_count	= 1;
+    if ( protect > 0 )
+	cdata->protect_count++;
+    return c;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+Container_t * InheritContainer
+(
+    // returns 'c' or the alloced container
+
+    Container_t		*c,		// valid container, alloc one if NULL
+    int			protect,	// initial value for protection
+    const Container_t	*parent,	// NULL or valid parent container
+    const void		*data,		// data to copy/move/link
+    uint		size		// size of 'data'
+)
+{
+    if (!c)
+	c = CALLOC(sizeof(*c),1);
+
+    if ( InContainerS(parent,data,size) || !InContainerS(c,data,size) )
+    {
+	UnlinkContainerData(c);
+	UseContainerData(c,protect,parent);
+    }
+    return c;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool AssignContainer
+(
+    // return TRUE on new ContainerData_t
+
+    Container_t		*c,		// valid container; if NULL: only FREE(data)
+    int			protect,	// new protection level
+    const void		*data,		// data to copy/move/link
+    uint		size,		// size of 'data'
+    CopyMode_t		mode		// copy mode on creation
+)
+{
+    if (c)
+    {
+	SetProtectContainer(c,protect);
+
+	if (!InContainerS(c,data,size))
+	{
+	    UnlinkContainerData(c);
+	    ContainerData_t *cdata = CALLOC(sizeof(*cdata),1);
+	    c->cdata		= cdata;
+	    cdata->data		= CopyData(data,size,mode,&cdata->data_alloced);
+	    cdata->size		= size;
+	    cdata->ref_count	= 1;
+	    if ( protect > 0 )
+		cdata->protect_count++;
+	    return true;
+	}
+    }
+
+    if ( mode == CPM_MOVE )
+	FREE((void*)data);
+    return false;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetContainer
+(
+    Container_t		*c		// container to reset => no data
+)
+{
+    if (c)
+    {
+	UnlinkContainerData(c);
+	memset(c,0,sizeof(*c));
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void DeleteContainer
+(
+    Container_t		*c		// container to reset and to free => no data
+)
+{
+    if (c)
+    {
+	UnlinkContainerData(c);
+	FREE(c);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void UnlinkContainerData
+(
+    Container_t		*c		// container to reset => no data
+)
+{
+    if ( c && c->cdata )
+    {
+	ContainerData_t *cdata = c->cdata;
+	if ( c->protect_level > 0 )
+	    cdata->protect_count--;
+	c->cdata = 0;
+	if ( !--cdata->ref_count )
+	{
+	    if (cdata->data_alloced)
+		FREE((void*)cdata->data);
+	    FREE(cdata);
+	}
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+ContainerData_t * LinkContainerData
+(
+    // increment 'ref_count' and return NULL or current container-data
+    // => use CatchContainerData() to complete operation
+
+    const Container_t	*c		// NULL or valid container
+)
+{
+    if ( !c || !c->cdata )
+	return 0;
+
+    c->cdata->ref_count++;
+    return c->cdata;
+}
+
+//-----------------------------------------------------------------------------
+
+ContainerData_t * MoveContainerData
+(
+    // return NULL or unlinked current container-data
+    // => use CatchContainerData() to complete operation
+    Container_t		*c		// NULL or valid container
+)
+{
+    if ( !c || !c->cdata )
+	return 0;
+
+    ContainerData_t *cdata = c->cdata;
+    cdata->ref_count++;
+    UnlinkContainerData(c);
+    return cdata;
+}
+
+//-----------------------------------------------------------------------------
+
+Container_t * CatchContainerData
+(
+    // returns 'c' or the alloced container
+    // 'c' is always initialized
+
+    Container_t		*c,		// valid container, alloc one if NULL
+    int			protect,	// initial value for protection
+    ContainerData_t	*cdata		// if not NULL: catch this
+)
+{
+    if (!c)
+	c = MALLOC(sizeof(*c));
+    memset(c,0,sizeof(*c));
+    c->protect_level = protect;
+
+    if (cdata)
+    {
+	c->cdata = cdata;
+	if ( protect > 0 )
+	    cdata->protect_count++;
+    }
+    return c;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+ContainerData_t * DisjoinContainerData
+(
+    // Disjoin data container date without freeing it. Call either
+    // JoinContainerData() or FreeContainerData() to finish operation.
+    // Reference counters are not modified.
+    // Return the data container or NULL
+
+    Container_t		*c		// NULL or valid container
+)
+{
+    ContainerData_t *res = 0;
+    if ( c && c->cdata )
+    {
+	const int old_protect = SetProtectContainer(c,0);
+	res = c->cdata;
+	c->cdata = 0;
+	SetProtectContainer(c,old_protect);
+    }
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void JoinContainerData
+(
+    // Join a data container, that was diosjoined by DisjoinContainerData()
+    // Reference counters are not modified.
+
+    Container_t		*c,		// container to reset => no data
+    ContainerData_t	*cdata		// NULL or container-data to join
+)
+{
+    if (c)
+    {
+	UnlinkContainerData(c);
+	DASSERT(!c->cdata);
+	if (cdata)
+	{
+	    const int old_protect = SetProtectContainer(c,0);
+	    c->cdata = cdata;
+	    SetProtectContainer(c,old_protect);
+	}
+    }
+    else
+	FreeContainerData(cdata);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void FreeContainerData
+(
+    // Decrement the reference counter of an already disjoined data container
+    // and free it if unused.
+
+    ContainerData_t	*cdata		// NULL or container-data to free
+)
+{
+    if ( cdata && !--cdata->ref_count )
+    {
+	if (cdata->data_alloced)
+	    FREE((void*)cdata->data);
+	FREE(cdata);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+bool ModifyAllContainer
+(
+    // prepare modification of container-data, create a copy if necessary
+    // return true, if a new container-data is used
+
+    Container_t		*c		// NULL or valid container
+)
+{
+    if ( c && c->cdata && !ModificationAllowed(c) )
+    {
+	ContainerData_t *oldcd	= c->cdata;
+	ContainerData_t *newcd	= CALLOC(sizeof(*newcd),1);
+	newcd->data		= MEMDUP(oldcd->data,oldcd->size);
+	newcd->size		= oldcd->size;
+	newcd->data_alloced	= true;
+	newcd->ref_count	= 1;
+	if ( c->protect_level > 0 )
+	    newcd->protect_count++;
+	UnlinkContainerData(c);
+	c->cdata = newcd;
+	return true;
+    }
+    return false;
+}
+
+//-----------------------------------------------------------------------------
+
+bool ModifyContainer
+(
+    // prepare modification of container-data, create an extract if necessary
+    // return true, if a new container-data is used
+
+    Container_t		*c,		// NULL or valid container
+    const void		*data,		// data to copy/move/link
+    uint		size,		// size of 'data'
+    CopyMode_t		mode		// copy mode on creation
+)
+{
+    if ( c && c->cdata && ( !ModificationAllowed(c) || !InContainerS(c,data,size) ))
+    {
+	ContainerData_t *newcd	= CALLOC(sizeof(*newcd),1);
+	newcd->data		= CopyData(data,size,mode,&newcd->data_alloced);
+	newcd->size		= size;
+	newcd->ref_count	= 1;
+	if ( c->protect_level > 0 )
+	    newcd->protect_count++;
+	UnlinkContainerData(c);
+	c->cdata = newcd;
+	return true;
+    }
+
+    if ( mode == CPM_MOVE )
+	FREE((void*)data);
+    return false;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int SetProtectContainer
+(
+    // returns 'c' new protection level
+    Container_t		*c,		// valid container, alloc one if NULL
+    int			new_protect	// new protection value
+)
+{
+    DASSERT(c);
+    if (c->cdata)
+    {
+	if ( new_protect > 0 )
+	{
+	    if ( c->protect_level <= 0 )
+		c->cdata->protect_count++;
+	}
+	else
+	{
+	    if ( c->protect_level > 0 )
+		c->cdata->protect_count--;
+	}
+    }
+    return c->protect_level = new_protect;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+uint DumpInfoContainer
+(
+    // return the number of printed lines
+
+    FILE		*f,		// valid output file
+    const ColorSet_t	*colset,	// NULL or color set
+    int			indent,		// indent the output
+    ccp			prefix,		// not NULL: use it as prefix behind indention
+    const Container_t	*c,		// dump infos for this container, NULL allowed
+    uint		hexdump_len	// max number of bytes used for a hexdump
+)
+{
+    DASSERT(f);
+    if (!c)
+	return 0;
+
+    indent = NormalizeIndent(indent);
+    if (!colset)
+	colset = GetColorSet0();
+
+    fprintf(f,"%*s%s%s%smod=%d, PL=%d, ",
+	indent,"",
+	colset->caption, prefix ? prefix : "",
+	colset->status, ModificationAllowed(c), c->protect_level );
+    uint line_count = DumpInfoContainerData(f,0,0,0,c->cdata,hexdump_len,indent+2);
+    if (!line_count)
+    {
+	fputs("<no-data>",f);
+	line_count++;
+    }
+    fprintf(f,"%s\n",colset->reset);
+    return line_count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint DumpInfoContainerData
+(
+    // return the number of printed lines
+
+    FILE		*f,		// valid output file
+    const ColorSet_t	*colset,	// NULL or color set
+    int			indent,		// indent of output
+    ccp			prefix,		// not NULL: use it as prefix behind indention
+    const
+      ContainerData_t	*cdata,		// dump infos for this container-data, NULL allowed
+    uint		hexdump_len,	// max number of bytes used for a hexdump
+    int			hexdump_indent	// indent of hexdump
+)
+{
+    DASSERT(f);
+    if (!cdata)
+	return 0;
+
+    indent = NormalizeIndent(indent);
+    if (!colset)
+	colset = GetColorSet0();
+
+    fprintf(f,"%*s%s%s%sPC=%d, RC=%d, alloc=%d, size=%u=0x%x, addr=%p\n",
+	indent,"",
+	colset->caption, prefix ? prefix : "", colset->status,
+	cdata->protect_count, cdata->ref_count, cdata->data_alloced,
+	cdata->size, cdata->size, cdata->data );
+
+    if ( hexdump_len > 0 && cdata->data && cdata->size )
+    {
+	if ( hexdump_len > cdata->size )
+	    hexdump_len = cdata->size;
+	return 1 + HexDump16(f,hexdump_indent,0,cdata->data,hexdump_len);
+    }
+    return 1;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			split strings			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+uint SplitByCharMem
+(
+    // 'mem_list' will be padded with {EmptyString,0}
+
+    mem_t		*mem_list,	// array of mem_t
+    uint		n_mem,		// number of elements of 'mem_list'
+    mem_t		source,		// source string
+    char		sep		// separator character
+)
+{
+    DASSERT(mem_list);
+    DASSERT(n_mem>1);
+
+    ccp src = source.ptr;
+    ccp end = src + source.len;
+
+    mem_t *mem = mem_list;
+    mem_t *last = mem + n_mem - 1;
+
+    while ( mem < last )
+    {
+	mem->ptr = src;
+	while ( src < end && *src != sep )
+	    src++;
+
+	mem->len = src - mem->ptr;
+	mem++;
+
+	if ( ++src > end )
+	    break;
+    }
+
+    if ( src <= end )
+    {
+	mem->ptr = src;
+	mem->len = end - src;
+	mem++;
+    }
+    const uint result = mem - mem_list;
+
+    while ( mem <= last )
+    {
+	mem->ptr = EmptyString;
+	mem->len = 0;
+	mem++;
+    }
+
+    return result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint SplitByTextMem
+(
+    // 'mem_list' will be padded with {EmptyString,0}
+
+    mem_t		*mem_list,	// array of mem_t
+    uint		n_mem,		// number of elements of 'mem_list'
+    mem_t		source,		// source string
+    mem_t		sep		// separator text
+)
+{
+    DASSERT(mem_list);
+    DASSERT(n_mem>0);
+
+    ccp src = source.ptr;
+    ccp end = src + source.len;
+
+    mem_t *mem = mem_list;
+    mem_t *last = mem + n_mem - 1;
+
+    if ( sep.len > 0 && sep.len <= source.len )
+    {
+	ccp cmp_max = end - sep.len;
+	while ( mem < last )
+	{
+	    mem->ptr = src;
+	    while ( src <= cmp_max && memcmp(src,sep.ptr,sep.len) )
+		src++;
+
+	    if ( src > cmp_max )
+	    {
+		mem->len = end - mem->ptr;
+		mem++;
+		src = end + 1;
+		break;
+	    }
+
+	    mem->len = src - mem->ptr;
+	    mem++;
+	    src += sep.len;
+	}
+    }
+
+    if ( src <= end )
+    {
+	mem->ptr = src;
+	mem->len = end - src;
+	mem++;
+    }
+    const uint result = mem - mem_list;
+
+    while ( mem <= last )
+    {
+	mem->ptr = EmptyString;
+	mem->len = 0;
+	mem++;
+    }
+
+
+    return result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint SplitByCharMemList
+(
+    mem_list_t		*ml,		// valid destination mem_list
+    bool		init_ml,	// true: initialize 'ml' first
+    mem_t		source,		// source string
+    char		sep,		// separator character
+    int			max_fields	// >0: max number of result fields
+)
+{
+    DASSERT(ml);
+    if (init_ml)
+	InitializeMemList(ml);
+    ml->used = 0;
+
+    if ( max_fields <= 0 )
+	max_fields = INT_MAX;
+    GrowBufMemList(ml,source.len+1);
+
+    ccp src = source.ptr;
+    ccp end = src + source.len;
+
+    while ( max_fields-- > 1 )
+    {
+	mem_t mem;
+	mem.ptr = src;
+	while ( src < end && *src != sep )
+	    src++;
+
+	mem.len = src - mem.ptr;
+	AppendMemListN(ml,&mem,1,0);
+	if ( ++src > end )
+	    break;
+    }
+
+    if ( src <= end )
+    {
+	mem_t mem = { src, end - src };
+	AppendMemListN(ml,&mem,1,0);
+    }
+
+    return ml->used;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint SplitByTextMemList
+(
+    mem_list_t		*ml,		// valid destination mem_list
+    bool		init_ml,	// true: initialize 'ml' first
+    mem_t		source,		// source string
+    mem_t		sep,		// separator text
+    int			max_fields	// >0: max number of result fields
+)
+{
+    DASSERT(ml);
+    if (init_ml)
+	InitializeMemList(ml);
+    ml->used = 0;
+
+    if ( max_fields <= 0 )
+	max_fields = INT_MAX;
+    GrowBufMemList(ml,source.len+1);
+
+    ccp src = source.ptr;
+    ccp end = src + source.len;
+
+    if ( sep.len > 0 && sep.len <= source.len )
+    {
+	ccp cmp_max = end - sep.len;
+	while ( max_fields-- > 1 )
+	{
+	    mem_t mem;
+	    mem.ptr = src;
+	    while ( src <= cmp_max && memcmp(src,sep.ptr,sep.len) )
+		src++;
+
+	    if ( src > cmp_max )
+	    {
+		mem.len = end - mem.ptr;
+		AppendMemListN(ml,&mem,1,0);
+		src = end + 1;
+		break;
+	    }
+
+	    mem.len = src - mem.ptr;
+	    AppendMemListN(ml,&mem,1,0);
+	    src += sep.len;
+	}
+    }
+
+    if ( src <= end )
+    {
+	mem_t mem = { src, end - src };
+	AppendMemListN(ml,&mem,1,0);
+    }
+
+    return ml->used;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			 MatchPattern()			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static ccp AnalyseBrackets
+(
+    ccp		pattern,
+    ccp		* p_start,
+    bool	* p_negate,
+    int		* p_multiple
+)
+{
+    ASSERT(pattern);
+
+    bool negate = false;
+    if ( *pattern == '^' )
+    {
+	pattern++;
+	negate = true;
+    }
+    if (p_negate)
+	*p_negate = negate;
+
+    int multiple = 0;
+    if ( *pattern == '+' )
+    {
+	pattern++;
+	multiple = 1;
+    }
+    else if ( *pattern == '*' )
+    {
+	pattern++;
+	multiple = 2;
+    }
+    if (p_multiple)
+	*p_multiple = multiple;
+
+    if (p_start)
+	*p_start = pattern;
+
+    if (*pattern) // ']' allowed in first position
+	pattern++;
+    while ( *pattern && *pattern++ != ']' ) // find end
+	;
+
+    return pattern;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static bool MatchBracktes
+(
+    char	ch,
+    ccp		pattern,
+    bool	negate
+)
+{
+    if (!ch)
+	return false;
+
+    bool ok = false;
+    ccp p = pattern;
+    for (; !ok && *p && ( p == pattern || *p != ']' ); p++ )
+    {
+	if ( *p == '-' )
+	{
+	    if ( ch <= *++p && ch >= p[-2] )
+	    {
+		if (negate)
+		    return false;
+		ok = true;
+	    }
+	}
+	else
+	{
+	    if ( *p == '\\' )
+		p++;
+
+	    if ( *p == ch )
+	    {
+		if (negate)
+		    return false;
+		ok = true;
+	    }
+	}
+    }
+    return ok || negate;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static bool MatchPatternHelper
+(
+    ccp		pattern,
+    ccp		text,
+    bool	skip_end,
+    int		alt_depth,
+    char	path_sep	// path separator character, standard is '/'
+)
+{
+    ASSERT(pattern);
+    ASSERT(text);
+    noTRACE(" - %d,%d |%s|%s|\n",skip_end,alt_depth,pattern,text);
+
+    char ch;
+    while ( ( ch = *pattern++ ) != 0 )
+    {
+	switch (ch)
+	{
+	   case '*':
+		if ( *pattern == '*' )
+		{
+		    pattern++;
+		    if (*pattern)
+			while (!MatchPatternHelper(pattern,text,skip_end,alt_depth,path_sep))
+			    if (!*text++)
+				return false;
+		}
+		else
+		{
+		    while (!MatchPatternHelper(pattern,text,skip_end,alt_depth,path_sep))
+			if ( *text == path_sep || !*text++ )
+			    return false;
+		}
+		return true;
+
+	    case '#':
+		if ( *text < '0' || *text > '9' )
+		    return false;
+		while ( *text >= '0' && *text <= '9' )
+			if (MatchPatternHelper(pattern,++text,skip_end,alt_depth,path_sep))
+			    return true;
+		return false;
+
+	    case ' ':
+		if ( *text < 1 || * text > ' ' )
+		    return false;
+		text++;
+		break;
+
+	    case '?':
+		if ( !*text || *text == path_sep )
+		    return false;
+		text++;
+		break;
+
+	    case '[':
+		{
+		    ccp start;
+		    bool negate;
+		    int multiple;
+		    TRACELINE;
+		    pattern = AnalyseBrackets(pattern,&start,&negate,&multiple);
+		    TRACELINE;
+
+		    if ( multiple < 2 && !MatchBracktes(*text++,start,negate) )
+			return false;
+
+		    if (multiple)
+		    {
+			while (!MatchPatternHelper(pattern,text,skip_end,alt_depth,path_sep))
+			    if (!MatchBracktes(*text++,start,negate))
+				return false;
+			return true;
+		    }
+		}
+		break;
+
+	   case '{':
+		for(;;)
+		{
+		    if (MatchPatternHelper(pattern,text,skip_end,alt_depth+1,path_sep))
+			return true;
+		    // skip until next ',' || '}'
+		    int skip_depth = 1;
+		    while ( skip_depth > 0 )
+		    {
+			ch = *pattern++;
+			switch(ch)
+			{
+			    case 0:
+				return false;
+
+			    case '\\':
+				if (!*pattern)
+				    return false;
+				pattern++;
+				break;
+
+			    case '{':
+				skip_depth++;
+				break;
+
+			    case ',':
+				if ( skip_depth == 1 )
+				    skip_depth--;
+				break;
+
+			    case '}':
+				if (!--skip_depth)
+				    return false;
+				break;
+
+			    case '[': // [2do] forgotten marker?
+				pattern = AnalyseBrackets(pattern,0,0,0);
+				break;
+			}
+		    }
+		}
+
+	   case ',':
+		if (alt_depth)
+		{
+		    alt_depth--;
+		    int skip_depth = 1;
+		    while ( skip_depth > 0 )
+		    {
+			ch = *pattern++;
+			switch(ch)
+			{
+			    case 0:
+				return false;
+
+			    case '\\':
+				if (!*pattern)
+				    return false;
+				pattern++;
+				break;
+
+			    case '{':
+				skip_depth++;
+				break;
+
+			    case '}':
+				skip_depth--;
+				break;
+
+			    case '[': // [2do] forgotten marker?
+				pattern = AnalyseBrackets(pattern,0,0,0);
+				break;
+			}
+		    }
+		}
+		else if ( *text++ != ch )
+		    return false;
+		break;
+
+	   case '}':
+		if ( !alt_depth && *text++ != ch )
+		    return false;
+		break;
+
+	   case '$':
+		if ( !*pattern && !*text )
+		    return true;
+		if ( *text++ != ch )
+		    return false;
+		break;
+
+	   case '\\':
+		ch = *pattern++;
+		// fall through
+
+	   default:
+		if ( *text++ != ch )
+		    return false;
+		break;
+	}
+    }
+    return skip_end || *text == 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool MatchPatternFull
+(
+    ccp		pattern,	// pattern text
+    ccp		text		// raw text
+)
+{
+    TRACE("MatchPattern(|%s|%s|)\n",pattern,text);
+    if ( !pattern || !*pattern )
+	return true;
+
+    if (!text)
+	text = "";
+
+    if ( *pattern == '^' )
+	pattern++;
+
+    return MatchPatternHelper(pattern,text,false,0,'/');
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool MatchPattern
+(
+    ccp		pattern,	// pattern text
+    ccp		text,		// raw text
+    char	path_sep	// path separator character, standard is '/'
+)
+{
+    TRACE("MatchPattern(|%s|%s|%c|)\n",pattern,text,path_sep);
+    if ( !pattern || !*pattern )
+	return true;
+
+    if (!text)
+	text = "";
+
+    const size_t plen = strlen(pattern);
+    ccp last = pattern + plen - 1;
+    char last_ch = *last;
+    int count = 0;
+    while ( last > pattern && *--last == '\\' )
+	count++;
+    if ( count & 1 )
+	last_ch = 0; // no special char!
+
+    if ( *pattern == path_sep || *pattern == '^' )
+    {
+	pattern++;
+	return MatchPatternHelper(pattern,text,last_ch!='$',0,path_sep);
+    }
+
+    while (*text)
+	if (MatchPatternHelper(pattern,text++,last_ch!='$',0,path_sep))
+	    return true;
+
+    return false;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+ccp MatchStringField ( const StringField_t * sf, ccp key )
+{
+    DASSERT(sf);
+    DASSERT(key);
+
+    ccp *ptr = sf->field, *end;
+    for ( end = ptr + sf->used; ptr < end; ptr++ )
+	if (MatchPattern(*ptr,key,'/'))
+	    return *ptr;
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ParamFieldItem_t * MatchParamField ( const ParamField_t * pf, ccp key )
+{
+    DASSERT(pf);
+    DASSERT(key);
+
+    ParamFieldItem_t *ptr = pf->field, *end;
+    for ( end = ptr + pf->used; ptr < end; ptr++ )
+	if (MatchPattern(ptr->key,key,'/'))
+	    return ptr;
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * MatchRuleLine
+(
+    // returns a pointer to the first non scanned char
+
+    int		*status,	// not NULL: return match status here
+				//   -2: no prefix found  (no ruile found)
+				//   -1: empty line (no ruile found)
+				//    0: rule found, but don't match
+				//    1: rule found and match
+    ccp		src,		// source line, scanned until CONTROL
+    char	rule_prefix,	// NULL or a rule-beginning-char'
+    ccp		path,		// path to verify
+    char	path_sep	// path separator character, standard is '/'
+)
+{
+    int local_status;
+    if (!status)
+	status = &local_status;
+
+    while ( *src > 0 && *src <= ' ' && *src != '\n' )
+	src++;
+
+    if (rule_prefix)
+    {
+	if ( *src != rule_prefix )
+	{
+	    *status = -2;
+	    return (char*)src;
+	}
+	src++;
+	while ( *src > 0 && *src <= ' ' && *src != '\n' )
+	    src++;
+    }
+
+    ccp start = src;
+    while ( (uchar)*src >= ' ' )
+	src++;
+
+    char buf[1000];
+    uint len = src - start;
+    if (!len)
+    {
+	*status = -1;
+	return (char*)src;
+    }
+
+    if ( len > sizeof(buf)-1 )
+	 len = sizeof(buf)-1;
+    memcpy(buf,start,len);
+    buf[len] = 0;
+
+    *status = MatchPattern(buf,path,path_sep);
+    return (char*)src;
+}
+
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			scan keywords			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+const KeywordTab_t *GetKewordById
+(
+    const KeywordTab_t	*key_tab,	// NULL or pointer to command table
+    s64			id		// id to search
+)
+{
+    if (key_tab)
+    {
+	const KeywordTab_t *key;
+	for ( key = key_tab; *key->name1; key++ )
+	    if ( key->id == id )
+		return key;
+    }
+
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+const KeywordTab_t *GetKewordByIdAndOpt
+(
+    const KeywordTab_t	*key_tab,	// NULL or pointer to command table
+    s64			id,		// id to search
+    s64			opt		// opt to search
+)
+{
+    if (key_tab)
+    {
+	const KeywordTab_t *key;
+	for ( key = key_tab; *key->name1; key++ )
+	    if ( key->id == id && key->opt == opt )
+		return key;
+    }
+
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+const KeywordTab_t * ScanKeyword
+(
+    int			* res_abbrev,	// NULL or pointer to result 'abbrev_count'
+    ccp			arg,		// argument to scan
+    const KeywordTab_t	* key_tab	// valid pointer to command table
+)
+{
+    DASSERT(arg);
+    char key_buf[KEYWORD_NAME_MAX];
+
+    char *dest = key_buf;
+    char *end  = key_buf + sizeof(key_buf) - 1;
+    while ( *arg && *arg != ',' && *arg != ';' && dest < end )
+	*dest++ = toupper((int)*arg++);
+    *dest = 0;
+    const int key_len = dest - key_buf;
+
+    int favor_count = 0, abbrev_count = 0;
+    const KeywordTab_t *ct, *key_ct = 0;
+    const KeywordTab_t *favor_ct = 0, *favor_prev = 0, *abbrev_ct = 0, *abbrev_prev = 0;
+    for ( ct = key_tab; ct->name1; ct++ )
+    {
+	if ( !strcmp(ct->name1,key_buf) )
+	{
+	    key_ct = ct;
+	    break;
+	}
+
+	bool name2_abbrev = false;
+	if (ct->name2)
+	{
+	    if (!strcmp(ct->name2,key_buf))
+	    {
+		key_ct = ct;
+		break;
+	    }
+	    name2_abbrev = !memcmp(ct->name2,key_buf,key_len);
+	}
+
+	if ( name2_abbrev && !memcmp(ct->name1,key_buf,strlen(ct->name1)) )
+	{
+	    if (!favor_ct)
+	    {
+		favor_prev = favor_ct = ct;
+		favor_count++;
+	    }
+	    else if ( favor_prev->id != ct->id || favor_prev->opt != ct->opt )
+	    {
+		favor_prev = ct;
+		favor_count++;
+	    }
+	}
+
+	if ( *key_buf == '_' ) // no abbreviations for commands beginning with '_'
+	    continue;
+
+	if ( name2_abbrev || !memcmp(ct->name1,key_buf,key_len) )
+	{
+	    if (!abbrev_ct)
+	    {
+		abbrev_prev = abbrev_ct = ct;
+		abbrev_count++;
+	    }
+	    else if ( abbrev_prev->id != ct->id || abbrev_prev->opt != ct->opt )
+	    {
+		abbrev_prev = ct;
+		abbrev_count++;
+	    }
+	}
+    }
+
+    if (key_ct)
+	abbrev_count = 0;
+    else if ( favor_count == 1 )
+    {
+	key_ct = favor_ct;
+	abbrev_count = 0;
+    }
+    else if ( abbrev_count == 1 )
+	key_ct = abbrev_ct;
+    else if (!abbrev_count)
+	abbrev_count = -1;
+
+    if (res_abbrev)
+	*res_abbrev = abbrev_count;
+
+    return key_ct;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+s64 ScanKeywordListEx
+(
+    ccp			arg,		// argument to scan
+    const KeywordTab_t	* key_tab,	// valid pointer to command table
+    KeywordCallbackFunc	func,		// NULL or calculation function
+    bool		allow_prefix,	// allow '-' | '+' | '=' as prefix
+    u32			max_number,	// allow numbers < 'max_number' (0=disabled)
+    s64			result,		// start value for result
+
+    uint		err_mode,	// bit field:
+					//	1: continue on error
+    ccp			err_msg,	// not NULL: print a warning message:
+					//   "<ERR_MSG>: Unknown keyword: <KEY>"
+    enumError		err_code,	// use 'err_code' for the 'err_msg'
+    uint		*err_count	// not NULL: store errors here
+)
+{
+    ASSERT(arg);
+
+    char key_buf[KEYWORD_NAME_MAX];
+    char *end  = key_buf + sizeof(key_buf) - 1;
+    uint err_cnt = 0;
+
+    for(;;)
+    {
+	while ( *arg > 0 && *arg <= ' ' || *arg == ',' || *arg == '.' )
+	    arg++;
+
+	if ( !*arg || *arg == '#' )
+	    break;
+
+	char *dest = key_buf;
+	while ( *arg > ' ' && *arg != ',' && *arg != '.' && *arg != '#'
+		&& ( *arg != '+' || dest == key_buf ) && dest < end )
+	    *dest++ = *arg++;
+	*dest = 0;
+	char prefix = 0;
+	int abbrev_count;
+	const KeywordTab_t * cptr = ScanKeyword(&abbrev_count,key_buf,key_tab);
+	if ( !cptr && allow_prefix && key_buf[1]
+	    && (   *key_buf == '+' || *key_buf == '-'
+		|| *key_buf == '/' || *key_buf == '=' ))
+	{
+	    prefix = *key_buf == '/' ? '-' : *key_buf;
+	    cptr = ScanKeyword(&abbrev_count,key_buf+1,key_tab);
+	}
+
+	KeywordTab_t ct_num = { 0, key_buf, 0, 0 };
+	if ( max_number && abbrev_count )
+	{
+	    char * start = key_buf + (prefix!=0);
+	    ulong num = str2l(start,&dest,10);
+	    if ( num < max_number && dest > start && !*dest )
+	    {
+		ct_num.id = num;
+		cptr = &ct_num;
+	    }
+	}
+
+	noPRINT("cptr=%p [%s], opt=%llx, prefix=%02x\n",
+		cptr, cptr ? cptr->name1 : "", cptr ? cptr->opt : 0, prefix );
+	if ( !cptr || cptr->opt && prefix && prefix != '+' )
+	{
+	    if (err_msg)
+	    {
+		if ( abbrev_count > 1 )
+		    ERROR0(err_code,"%s: Ambiguous keyword: %s\n",err_msg,key_buf);
+		else
+		    ERROR0(err_code,"%s: Unknown keyword: %s\n",err_msg,key_buf);
+	    }
+	    err_cnt++;
+	    if ( err_mode & 1 )
+		continue;
+	    result = M1(result);
+	    break;
+	}
+
+	if (func)
+	{
+	    const s64 res = func(0,key_buf,key_tab,cptr,prefix,result);
+	    if ( res == M1(res) )
+	    {
+		if ( !(err_mode & 1) )
+		{
+		    result = res;
+		    break;
+		}
+	    }
+	    else
+		result = res;
+	}
+	else
+	{
+	    switch (prefix)
+	    {
+		case 0:
+		case '+': result  =  result & ~cptr->opt | cptr->id; break;
+		case '-': result &= ~cptr->id; break;
+		case '=': result  =  cptr->id; break;
+	    }
+	}
+    }
+
+    if (err_count)
+	*err_count = err_cnt;
+   return result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError ScanKeywordListFunc
+(
+    ccp			arg,		// argument to scan
+    const KeywordTab_t	* key_tab,	// valid pointer to command table
+    KeywordCallbackFunc	func,		// calculation function
+    void		* param,	// used define parameter for 'func'
+    bool		allow_prefix	// allow '-' | '+' | '=' as prefix
+)
+{
+    ASSERT(arg);
+    ASSERT(func);
+
+    char key_buf[KEYWORD_NAME_MAX];
+    char *end  = key_buf + sizeof(key_buf) - 1;
+
+    for(;;)
+    {
+	while ( *arg > 0 && *arg <= ' ' || *arg == ','  || *arg == '.' )
+	    arg++;
+
+	if (!*arg)
+	    return ERR_OK;
+
+	char *dest = key_buf;
+	while ( *arg > ' ' && *arg != ',' && *arg != '.'
+		&& ( *arg != '+' || dest == key_buf ) && dest < end )
+	    *dest++ = *arg++;
+	*dest = 0;
+	char prefix = 0;
+	int abbrev_count;
+	const KeywordTab_t * cptr = ScanKeyword(&abbrev_count,key_buf,key_tab);
+	if ( !cptr && allow_prefix && key_buf[1]
+	    && ( *key_buf == '+' || *key_buf == '-' || *key_buf == '/' || *key_buf == '=' ))
+	{
+	    prefix = *key_buf == '/' ? '-' : *key_buf;
+	    cptr = ScanKeyword(&abbrev_count,key_buf+1,key_tab);
+	}
+
+	const enumError err = func(param,key_buf,key_tab,cptr,prefix,0);
+	if (err)
+	    return err;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static s64 ScanKeywordListMaskHelper
+(
+    void		* param,	// NULL or user defined parameter
+    ccp			name,		// normalized name of option
+    const KeywordTab_t	* key_tab,	// valid pointer to command table
+    const KeywordTab_t	* key,		// valid pointer to found command
+    char		prefix,		// 0 | '-' | '+' | '='
+    s64			result		// current value of result
+)
+{
+    return key->opt
+		? result & ~key->opt | key->id
+		: key->id;
+}
+
+//-----------------------------------------------------------------------------
+
+s64 ScanKeywordListMask
+(
+    ccp			arg,		// argument to scan
+    const KeywordTab_t	* key_tab	// valid pointer to command table
+)
+{
+    return ScanKeywordList(arg,key_tab,ScanKeywordListMaskHelper,false,0,0,0,0);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint CollectAmbiguousKeywords
+(
+    char		*buf,		// destination buffer, 200 bytes are good
+    uint		buf_size,	// size of buffer
+    const KeywordTab_t	* key_tab,	// NULL or pointer to command table
+    ccp			key_arg		// analyzed command
+)
+{
+    DASSERT(buf);
+    DASSERT(buf_size>10);
+    DASSERT(key_tab);
+    DASSERT(key_arg);
+
+    int n = 0;
+    char *dest = buf, *buf_end = buf + buf_size - 2;
+    const int arg_len = strlen(key_arg);
+    int last_id = -1;
+
+    const KeywordTab_t *ct;
+    for ( ct = key_tab; ct->name1 && dest < buf_end; ct++ )
+    {
+	if ( ct->id != last_id )
+	{
+	    ccp ok = 0;
+	    if (!strncasecmp(key_arg,ct->name1,arg_len))
+		ok = ct->name1;
+	    else if ( ct->name2 && !strncasecmp(key_arg,ct->name2,arg_len))
+		ok = ct->name2;
+	    if (ok)
+	    {
+		if (!n++)
+		{
+		    *dest++ = ' ';
+		    *dest++ = '[';
+		}
+		else if ( n > 5 )
+		{
+		    dest = StringCopyE(dest,buf_end,",...");
+		    break;
+		}
+		else
+		    *dest++ = ',';
+		dest = StringCopyE(dest,buf_end,ok);
+		last_id = ct->id;
+	    }
+	}
+    }
+    if ( dest > buf+1 )
+	*dest++ = ']';
+    else
+	dest = buf;
+    *dest = 0;
+    return dest - buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError PrintKeywordError
+(
+    const KeywordTab_t	* key_tab,	// NULL or pointer to command table
+    ccp			key_arg,	// analyzed command
+    int			key_stat,	// status of ScanKeyword()
+    ccp			prefix,		// NULL or first prefix for messages
+    ccp			object		// NULL or object for error messages
+					//	default= 'command'
+)
+{
+    DASSERT(key_arg);
+
+    if ( !object || !*object )
+	object = "command";
+
+    if ( key_stat <= 0 )
+	return ERROR0(ERR_SYNTAX,"%sUnknown %s: %s\n",
+		prefix ? prefix : "", object, key_arg );
+
+    char buf[1000], *dest = buf;
+    if (key_tab)
+    {
+	int n = 0;
+	ccp buf_end = buf + sizeof(buf) - 2;
+	const int arg_len = strlen(key_arg);
+	const KeywordTab_t *ct;
+	int last_id = -1;
+
+	for ( ct = key_tab; ct->name1 && dest < buf_end; ct++ )
+	{
+	    if ( ct->id != last_id )
+	    {
+		ccp ok = 0;
+		if (!strncasecmp(key_arg,ct->name1,arg_len))
+		    ok = ct->name1;
+		else if ( ct->name2 && !strncasecmp(key_arg,ct->name2,arg_len))
+		    ok = ct->name2;
+		if (ok)
+		{
+		    if (!n++)
+		    {
+			*dest++ = ' ';
+			*dest++ = '[';
+		    }
+		    else if ( n > 5 )
+		    {
+			dest = StringCopyE(dest,buf_end,",...");
+			break;
+		    }
+		    else
+			*dest++ = ',';
+		    dest = StringCopyE(dest,buf_end,ok);
+		    last_id = ct->id;
+		}
+	    }
+	}
+	if ( dest > buf+1 )
+	    *dest++ = ']';
+	else
+	    dest = buf;
+    }
+    *dest = 0;
+
+    return ERROR0(ERR_SYNTAX,"%s%c%s abbreviation is ambiguous: %s%s\n",
+		prefix ? prefix : "",
+		toupper((int)*object), object+1, key_arg, buf );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintKeywordList
+(
+    // returns a pointer to the result buffer
+
+    char		*buf,		// result buffer
+					// If NULL, a local circulary static buffer
+					// with max CIRC_BUF_MAX_ALLOC bytes is used
+    uint		buf_size,	// size of 'buf', at least 10 bytes if buf is set
+    uint		*ret_length,	// not NULL: store result length here
+
+    const KeywordTab_t	*tab,		// related keyword table
+    u64			mode,		// mode to print
+    u64			default_mode,	// NULL or default mode
+    u64			hide_mode	// bit field to hide parameters
+)
+{
+    DASSERT( !buf || buf_size >= 10 );
+    char temp[CIRC_BUF_MAX_ALLOC];
+    if (!buf)
+    {
+	buf = temp;
+	buf_size = sizeof(temp);
+    }
+
+    char *dest = buf;
+    char *end = buf + buf_size - 1;
+
+    mode = mode | hide_mode;
+    u64 mode1 = mode;
+
+    for ( ; tab->name1 && dest < end; tab++ )
+    {
+	if ( !tab->id || tab->opt & hide_mode )
+	    continue;
+
+	if ( tab->opt ? (mode & tab->opt) == tab->id : mode & tab->id )
+	{
+	    if ( dest > buf )
+		*dest++ = ',';
+	    dest = StringCopyE(dest,end,tab->name1);
+	    mode &= ~(tab->id|tab->opt);
+	}
+    }
+
+    if ( default_mode && mode1 == (default_mode|hide_mode) )
+	dest = StringCopyE(dest,end," (default)");
+    else if (!mode1)
+	dest = StringCopyE(dest,end,"(none)");
+
+    *dest = 0;
+    const uint len = dest - buf;
+    if (ret_length)
+	*ret_length = len;
+
+    if ( buf == temp )
+    {
+	buf = GetCircBuf(len+1);
+	memcpy(buf,temp,len+1);
+    }
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanKeywordOffOn
+(
+    // returns 0 for '0|OFF';  1 for '1|ON;  -1 for empty;  -2 on error
+
+    ccp			arg,		// argument to scan
+    uint		max_num,	// >0: additionally accept+return number <= max_num
+    ccp			object		// NULL (silent) or object for error messages
+)
+{
+    if (!arg||!*arg)
+	return -1;
+
+    static const KeywordTab_t keytab[] =
+    {
+	{ 0,	"OFF",	"0",	0 },
+	{ 1,	"ON",	"1",	0 },
+	{0,0,0,0}
+    };
+
+    int status;
+    const KeywordTab_t *key = ScanKeyword(&status,arg,keytab);
+    if (key)
+	return key->id;
+
+    if ( max_num > 0 )
+    {
+	char *end;
+	const uint num = str2ul(arg,&end,10);
+	if ( !*end && num <= max_num )
+	    return num;
+    }
+
+    if (object)
+	PrintKeywordError(keytab,arg,status,0,object);
+
+    return -2;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			OFF/AUTO/ON/FORCE		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+const KeywordTab_t KeyTab_OFF_AUTO_ON[] =
+{
+  { OFFON_OFF,		"OFF",		"-1",	0 },
+  { OFFON_OFF,		"DISABLED",	0,	0 },
+  { OFFON_AUTO,		"AUTO",		"0",	0 },
+  { OFFON_ON,		"ON",		"1",	0 },
+  { OFFON_ON,		"ENABLED",	0,	0 },
+  { OFFON_FORCE,	"FORCE",	"2",	0 },
+  { 0,0,0,0 }
+};
+
+//-----------------------------------------------------------------------------
+
+int ScanKeywordOffAutoOn
+(
+    // returns one of OFFON_*
+
+    ccp			arg,		// argument to scan
+    int			on_empty,	// return this value on empty
+    uint		max_num,	// >0: additionally accept+return number <= max_num
+    ccp			object		// NULL (silent) or object for error messages
+)
+{
+    if ( !arg || !*arg )
+	return on_empty;
+
+    int status;
+    const KeywordTab_t *key = ScanKeyword(&status,arg,KeyTab_OFF_AUTO_ON);
+    if (key)
+	return key->id;
+
+    if ( max_num > 0 )
+    {
+	char *end;
+	const int num = str2l(arg,&end,10);
+	if ( !*end && num >= OFFON_OFF && num <= max_num )
+	    return num;
+    }
+
+    if (object)
+	PrintKeywordError(KeyTab_OFF_AUTO_ON,arg,status,0,object);
+
+    return OFFON_ERROR;
+}
+
+//-----------------------------------------------------------------------------
+
+ccp GetKeywordOffAutoOn ( OffOn_t value )
+{
+    const KeywordTab_t *key = GetKewordById(KeyTab_OFF_AUTO_ON,value);
+    return key ? key->name1 : "?";
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			scan command lists		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int ExecCommandOfList ( CommandList_t *cli )
+{
+    DASSERT(cli);
+    if ( cli->n_bin )
+    {
+	printf("%3u. %s [n_bin=%u] = |%.*s|\n",
+	    cli->cmd_count, cli->cmd, cli->n_bin, cli->param_len, cli->param );
+	uint i;
+	for ( i = 0; i <  cli->n_bin; i++ )
+	{
+	    printf(" > binary #%u, len=%u\n",i,cli->bin[0].len);
+	    HexDump16( stdout,5,0, cli->bin[i].ptr,
+			cli->bin[i].len < 0x20 ? cli->bin[i].len : 0x20 );
+	}
+    }
+    else
+	printf("%3u. %s = |%.*s|\n",
+	    cli->cmd_count, cli->cmd, cli->param_len, cli->param );
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanCommandList
+(
+    // returns -1 on 'cli->fail_count'; otherwise 'cli->cmd_count'
+
+    CommandList_t	*cli,	    // valid command list
+    CommandListFunc	func	    // NULL or function for each command
+)
+{
+    DASSERT(cli);
+
+    static uint log_pid	= 0;
+    static uint log_seq	= 0;
+    static FILE *log	= 0;
+
+    if ( cli->log_fname && cli->log_level && !log_pid )
+    {
+	log_pid = getpid();
+	log = fopen(cli->log_fname,"ab");
+	if (log)
+	{
+	    fcntl(fileno(log),F_SETFD,FD_CLOEXEC);
+	    fprintf(log,"\n#\f\n#OPEN %s, pid=%d\n\n",
+			PrintTimeByFormat("%F %T %z",time(0)), log_pid );
+	}
+    }
+    uint log_level = log ? cli->log_level : 0;
+
+    cli->read_cmd_len = 0;
+    const char sep = cli->command_sep ? cli->command_sep : ';';
+    ccp cmd = cli->command, end = cmd + cli->command_len;
+    if ( log_level > 0 )
+    {
+	fprintf(log,"\n++ %u.%u len=%u\n",
+			log_pid, ++log_seq, cli->command_len );
+	fflush(log);
+    }
+
+    for(;;)
+    {
+	cli->n_bin = 0;
+	memset(cli->bin,0,sizeof(cli->bin));
+
+	//--- skip blanks and terminators => find begin of record
+
+	while ( cmd < end && ( (uchar)*cmd <= ' ' || *cmd == sep ))
+	    cmd++;
+	cli->read_cmd_len = cmd - cli->command; // definitley scanned!
+
+	if ( cmd >= end )
+	    break;
+
+	cli->record = (u8*)cmd;
+
+
+	//--- find end of command+param
+
+	ccp endcmd = memchr(cmd,sep,end-cmd);
+	if (!endcmd)
+	{
+	    if (!cli->is_terminated)
+		goto abort;
+	    endcmd = end;
+	}
+
+
+	//--- scan and copy command
+
+	ccp param = cmd;
+	while ( param < endcmd && ( isalnum(*param) || *param == '-' || *param == '_' ) )
+	    param++;
+	cli->cmd_len = param - cmd;
+	if ( cli->cmd_len > sizeof(cli->cmd)-1 )
+	     cli->cmd_len = sizeof(cli->cmd)-1;
+
+	if ( log_level > 1 )
+	{
+	    fprintf(log,">%.*s\n",cli->cmd_len,cmd);
+	    fflush(log);
+	}
+
+	if (cli->change_case)
+	{
+	    char *dest = cli->cmd;
+	    uint count = cli->cmd_len;
+	    if ( cli->change_case == 1 )
+		while ( count-- > 0 )
+		    *dest++ = tolower((int)*cmd++);
+	    else
+		while ( count-- > 0 )
+		    *dest++ = toupper((int)*cmd++);
+	    *dest = 0;
+	}
+	else
+	{
+	    memcpy(cli->cmd,cmd,cli->cmd_len);
+	    cli->cmd[cli->cmd_len] = 0;
+	}
+
+
+	//--- scan binary
+
+	while ( cli->n_bin < COMMAND_LIST_N_BIN )
+	{
+	    while ( param < endcmd && ( *param == ' ' || *param == '\t' ))
+		param++;
+
+	    if ( param == endcmd || *param != '\1' )
+		break; // no binary!
+
+	    //-- From now on for binary examintation, only 'end' is relevant,
+	    //-- because binary data may contain the separator character.
+
+	    if ( param+3 > end )
+	    {
+		if ( log_level > 1 )
+		{
+		    fprintf(log,"bin incomplete\n");
+		    fflush(log);
+		}
+
+		if (cli->is_terminated)
+		{
+		    // now we have a conflict:
+		    fprintf(stderr,
+			"#WARN: Conflict in ExecCommandOfList():"
+			" Stream is terminated, but binary not: %s\n",
+			cli->user_ts ? cli->user_ts->info : "" );
+
+		    if (log)
+		    {
+			fprintf(log,"#WARN: Conflict: Stream is terminated, but binary not!\n");
+			fflush(log);
+		    }
+		}
+		goto abort; // incomplete
+	    }
+
+	    const uint bin_len = be16(++param);
+	    param += 2;
+	    if ( log_level > 2 )
+	    {
+		fprintf(log,"bin %u,%u..%u/%u%s\n",
+			bin_len,
+			(uint)(param - cli->command),
+			(uint)(param - cli->command + bin_len),
+			cli->command_len,
+			param + bin_len > end ? " incomplete" : "" );
+		fflush(log);
+	    }
+	    if ( param + bin_len > end )
+		goto abort; // incomplete
+
+	    cli->bin[cli->n_bin].ptr = param;
+	    cli->bin[cli->n_bin].len = bin_len;
+	    param += bin_len;
+	    cli->n_bin++;
+
+	    //-- rescan 'endcmd' after binary block
+
+	    endcmd = memchr(param,sep,end-param);
+	    if (!endcmd)
+	    {
+		if (!cli->is_terminated)
+		    goto abort; // incomplete
+		endcmd = end;
+	    }
+	}
+
+
+	//--- calc record length
+
+	cli->input_len = (u8*)endcmd - cli->record;
+	if ( endcmd < end )
+	    cli->input_len++;
+
+
+	//--- scan param
+
+	while ( param < endcmd && (uchar)*param <= ' ' )
+	    param++;
+	if ( param < endcmd && *param == '=' )
+	{
+	    param++;
+	    while ( param < endcmd && (uchar)*param <= ' ' )
+		param++;
+	}
+
+	ccp endparam = endcmd-1;
+	while ( endparam > param && (uchar)*endparam <= ' ' )
+	    endparam--;
+	endparam++;
+
+	if ( log_level > 2 && endparam > param )
+	{
+	    const uint plen = endparam - param, max = 25;
+	    if ( plen <= max )
+		fprintf(log,"par %.*s\n",plen,param);
+	    else
+		fprintf(log,"par %.*s…+%u\n",max,param,plen-max);
+	    fflush(log);
+	}
+
+	if (cli->term_param)
+	{
+	    if ( cli->term_param > 1 )
+	    {
+		((char*)endparam)[0] = sep;
+		endparam++;
+	    }
+	    else
+		((char*)endparam)[0] = 0;
+	}
+
+	cli->param		= param;
+	cli->param_len		= endparam - param;
+	cli->record_len		= endparam - (ccp)cli->record;
+	cli->read_cmd_len	= endcmd   - (ccp)cli->command;
+	cmd			= endcmd;
+
+
+	//--- execute command
+
+	if ( log_level > 3 )
+	{
+	    fprintf(log,"func\n");
+	    fflush(log);
+	    const int stat = func(cli);
+	    fprintf(log,"s=%d\n",stat);
+	    fflush(log);
+	    if ( stat < 0 )
+		break;
+	}
+	else if ( func && func(cli) < 0 )
+	    break;
+
+	cli->cmd_count++;
+    }
+
+ abort:;
+    if ( log_level > 1 || log && cli->read_cmd_len > cli->command_len )
+    {
+	fprintf(log,"-- %u,%u/%u%s\n",
+		cli->cmd_count,
+		cli->read_cmd_len, cli->command_len,
+		cli->read_cmd_len > cli->command_len ? " #FAIL!" : "" );
+	fflush(log);
+    }
+
+    // should never happen
+    if ( cli->read_cmd_len > cli->command_len )
+	 cli->read_cmd_len = cli->command_len;
+
+    return cli->fail_count ? -1 : cli->cmd_count;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			global commands			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError Command_ARGTEST ( int argc, char ** argv )
+{
+    printf("ARGUMENT TEST: %u arguments:\n",argc);
+
+    int idx;
+    for ( idx = 0; idx < argc; idx++ )
+	printf("%4u.: |%s|\n",idx,argv[idx]);
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError Command_COLORS
+(
+    int		level,		// only used, if mode==NULL
+				//  <  0: status message (ignore mode)
+				//  >= 1: include names
+				//  >= 2: include alt names
+				//  >= 3: include color names incl bold
+				//  >= 4: include background color names
+    uint	mode,		// output mode => see PrintColorSetHelper()
+    uint	format		// output format => see PrintColorSetEx()
+)
+{
+    if (!colout)
+	SetupStdMsg();
+
+    if ( level < 0 )
+    {
+	printf("%s--color=%d [%s], colorize=%d [%s]\n"
+		"term=%s\n"
+		"stdout: tty=%d, mode=%d [%s], have-color=%d, n-colors=%u%s\n",
+		colout->status,
+		opt_colorize, GetColorModeName(opt_colorize,"?"),
+		colorize_stdout, GetColorModeName(colorize_stdout,"?"),
+		getenv("TERM"), isatty(fileno(stdout)),
+		colout->col_mode, GetColorModeName(colout->col_mode,"?"),
+		colout->colorize, colout->n_colors, colout->reset );
+	return ERR_OK;
+    }
+
+    if ( !mode && level > 0 )
+	switch (level)
+	{
+	    case 1:  mode = 0x08; break;
+	    case 2:  mode = 0x18; break;
+	    case 3:  mode = 0x1b; break;
+	    default: mode = 0x1f; break;
+	}
+
+    if (!format)
+    {
+	const ColorMode_t col_mode = colout ? colout->col_mode : COLMD_AUTO;
+	PrintTextModes( stdout, 4, col_mode );
+	PrintColorModes( stdout, 4, col_mode, GCM_ALT );
+     #ifdef TEST
+	PrintColorModes( stdout, 4, col_mode, GCM_ALT|GCM_SHORT );
+     #endif
+    }
+    if ( mode || format )
+	PrintColorSetEx(stdout,4,colout,mode,format);
+    return ERR_OK;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		global commands: TESTCOLORS		///////////////
+///////////////////////////////////////////////////////////////////////////////
+// [[color_info_t]]
+
+typedef struct color_info_t
+{
+    bool	valid;		// >0: data below is valid
+
+    u8		m_index;	// index of 0..255 for "\e[*m"
+
+    s8		m_red;		// -1:invalid, 0..5:  red value of 'm_index'
+    s8		m_green;	// -1:invalid, 0..5:  green value of 'm_index'
+    s8		m_blue;		// -1:invalid, 0..5:  blue value of 'm_index'
+    s8		m_gray;		// -1:invalid, 0..23: gray value of 'm_index'
+
+    u32		ref_color;	// reference colors, based on 'm_index';
+    u32		src_color;	// scanned color
+}
+color_info_t;
+
+///////////////////////////////////////////////////////////////////////////////
+
+static bool AssignColorInfo ( color_info_t *ci, u32 rgb )
+{
+    DASSERT(ci);
+    memset(ci,0,sizeof(*ci));
+
+    ci->src_color = rgb & 0xffffff;
+    ci->m_index   = ConvertColorRGBToM256(ci->src_color);
+    ci->ref_color = ConvertColorM256ToRGB(ci->m_index);
+
+    const uint r = ci->ref_color >> 16 & 0xff;
+    const uint g = ci->ref_color >>  8 & 0xff;
+    const uint b = ci->ref_color       & 0xff;
+
+    ci->m_red   = SingleColorToM6(r);
+    ci->m_green = SingleColorToM6(g);
+    ci->m_blue  = SingleColorToM6(b);
+
+    ci->m_gray  = ( r + g + b + 21 ) / 30;
+    if ( ci->m_gray > 23 )
+	ci->m_gray = 23;
+    else if ( ci->m_gray > 0 )
+	ci->m_gray--;
+
+    return ci->valid = 1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static bool ScanColorInfo ( color_info_t *ci, ccp arg )
+{
+    DASSERT(ci);
+    memset(ci,0,sizeof(*ci));
+    if ( arg && *arg )
+    {
+	arg = SkipControls(arg);
+
+	ulong num, r, g, b;
+	if ( *arg >= 'g' && *arg <= 'z' )
+	{
+	    const char mode = *arg;
+	    arg = SkipControls(arg+1);
+
+	    num = str2ul(arg,0,10);
+	    switch (mode)
+	    {
+		case 'm':
+		    return AssignColorInfo(ci,ConvertColorM256ToRGB(num));
+
+		case 'g':
+		    return AssignColorInfo(ci,ConvertColorM256ToRGB(232 + num % 24));
+
+		case 'c':
+		    r = num / 100 % 10;
+		    g = num / 10  % 10;
+		    b = num       % 10;
+		    goto rgb5;
+	    }
+	}
+	else
+	{
+	    char *end;
+	    num = str2ul(arg,&end,16);
+
+	    ci->valid = true;
+	    if ( end - arg <= 3 )
+	    {
+		r = num >> 8 & 15;
+		g = num >> 4 & 15;
+		b = num      & 15;
+
+		rgb5:
+		if ( r > 5 ) r = 5;
+		if ( g > 5 ) g = 5;
+		if ( b > 5 ) b = 5;
+		return AssignColorInfo(ci,ConvertColorM256ToRGB(16 + 36*r + 6*g + b));
+	    }
+	    return AssignColorInfo(ci,num);
+	}
+    }
+
+    return ci->valid;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void PrintColorInfo ( FILE *f, color_info_t *ci )
+{
+    DASSERT(f);
+    DASSERT(ci);
+
+    if (ci->valid)
+	fprintf(f," %06x -> %06x : %3u : %u,%u,%u : %2u"
+		" \e[48;5;16;38;5;%um test \e[0m"
+		" \e[48;5;244;38;5;%um test \e[0m"
+		" \e[48;5;231;38;5;%um test \e[0m "
+		" \e[38;5;16;48;5;%um test \e[0m"
+		" \e[38;5;244;48;5;%um test \e[0m"
+		" \e[38;5;231;48;5;%um test \e[0m\n",
+		ci->src_color, ci->ref_color,
+		ci->m_index, ci->m_red, ci->m_green, ci->m_blue, ci->m_gray,
+		ci->m_index, ci->m_index, ci->m_index,
+		ci->m_index, ci->m_index, ci->m_index );
+    else
+	fputs(" --\n",f);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError Command_TESTCOLORS ( int argc, char ** argv )
+{
+ #if HAVE_PRINT
+    GetColorByName(colout,"blue");
+ #endif
+
+    printf("TEST COLORS: %u arguments:\n",argc);
+
+    bool sep = true;
+    int idx;
+    for ( idx = 0; idx < argc; idx++ )
+    {
+	ccp minus = strchr(argv[idx],'-');
+	if ( minus || sep )
+	{
+	    putchar('\n');
+	    sep = false;
+	    if ( strlen(argv[idx]) == 1 )
+		continue;
+	}
+
+	color_info_t ci1;
+	ScanColorInfo(&ci1,argv[idx]);
+	PrintColorInfo(stdout,&ci1);
+
+	if (!minus)
+	    continue;
+
+	color_info_t ci2;
+	ScanColorInfo(&ci2,minus+1);
+	if ( ci2.ref_color == ci1.ref_color )
+	    continue;
+
+	int r1 = ci1.ref_color >> 16 & 0xff;
+	int g1 = ci1.ref_color >>  8 & 0xff;
+	int b1 = ci1.ref_color       & 0xff;
+	int r2 = ci2.ref_color >> 16 & 0xff;
+	int g2 = ci2.ref_color >>  8 & 0xff;
+	int b2 = ci2.ref_color       & 0xff;
+
+	int n_steps = abs( r2 - r1 );
+	int diff = abs( g2 - g1 );
+	if ( n_steps < diff )
+	    n_steps = diff;
+	diff = abs( b2 - b1 );
+	if ( n_steps < diff )
+	    n_steps = diff;
+
+	u8 prev_m = ci1.m_index;
+	u32 prev_rgb = ci1.ref_color;
+	int i;
+	for ( i = 1; i <= n_steps; i++ )
+	{
+	    uint r = ( r2 - r1 ) * i / n_steps + r1;
+	    uint g = ( g2 - g1 ) * i / n_steps + g1;
+	    uint b = ( b2 - b1 ) * i / n_steps + b1;
+	    u8 new_m = ConvertColorRGB3ToM256(r,g,b);
+	    if ( prev_m != new_m )
+	    {
+		prev_m = new_m;
+		color_info_t ci3;
+		AssignColorInfo(&ci3,r<<16|g<<8|b);
+		if ( prev_rgb != ci3.ref_color )
+		{
+		    prev_rgb = ci3.src_color = ci3.ref_color;
+		    PrintColorInfo(stdout,&ci3);
+		}
+	    }
+	}
+	sep = true;
+    }
+    putchar('\n');
+    return ERR_OK;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			color helpers			///////////////
+///////////////////////////////////////////////////////////////////////////////
+//
+// https://en.wikipedia.org/wiki/ANSI_escape_code
+// https://jonasjacek.github.io/colors/
+//
+// 0..15:  000000 800000 008000 808000  000080 800080 008080 c0c0c0
+//	   808080 ff0000 00ff00 ffff00  0000ff ff00ff 00ffff ffffff
+//		=> real colors varies on implementation
+//
+// 6x6x6: 0 95 135 175 215 255 == 00 5f 87 af d7 ff
+//
+// gray:  8 18 28 ... 238 == 08 12 1c 26 30 3a ... e4 ee f8
+//
+///////////////////////////////////////////////////////////////////////////////
+//
+//  mkw-ana testcol 000000-ffffff
+//  mkw-ana testcol 500-550 550-050 050-055 055-005 005-505 505-500
+//
+///////////////////////////////////////////////////////////////////////////////
+
+u32 ColorTab_M0_M15[16] =
+{
+	0x000000, 0x800000, 0x008000, 0x808000,
+	0x000080, 0x800080, 0x008080, 0xc0c0c0,
+	0x808080, 0xff0000, 0x00ff00, 0xffff00,
+	0x0000ff, 0xff00ff, 0x00ffff, 0xffffff,
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+u8 ConvertColorRGB3ToM256 ( u8 r, u8 g, u8 b )
+{
+    // 0..5
+    const uint r6 = SingleColorToM6(r);
+    const uint g6 = SingleColorToM6(g);
+    const uint b6 = SingleColorToM6(b);
+
+    u8	 m256	= 36*r6 + 6*g6 + b6 + 16;
+    uint delta	= abs ( ( r6 ? 55 + 40 * r6 : 0 ) - r  )
+		+ abs ( ( g6 ? 55 + 40 * g6 : 0 ) - g  )
+		+ abs ( ( b6 ? 55 + 40 * b6 : 0 ) - b  );
+
+    //printf("%02x>%u %02x>%u %02x>%u : m=%u delta=%d\n",r,r6,g,g6,b,b6,m256,delta);
+
+    uint m, gray, prev = 0x1000000;
+    for ( m = 232, gray = 8; m < 256; m++, gray += 10 )
+    {
+	const uint d = abs( gray - r ) + abs( gray - g ) + abs( gray - b );
+	if ( d > prev )
+	    break;
+	if ( d <= delta )
+	{
+	    delta = d;
+	    m256  = m;
+	}
+	prev = d;
+    }
+
+    return m256;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u8 ConvertColorRGBToM256 ( u32 rgb )
+{
+    return ConvertColorRGB3ToM256( rgb >> 16, rgb >> 8, rgb );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u32 ConvertColorM256ToRGB ( u8 m256 )
+{
+    if ( m256 < 16 )
+	return ColorTab_M0_M15[m256];
+
+    if ( m256 < 232 )
+    {
+	m256 -= 16;
+	const uint r =  m256 / 36;
+	const uint g =  m256 / 6 % 6;
+	const uint b =  m256 % 6;
+
+	u32 col = 0;
+	if (r) col |= 0x370000 + 0x280000 * r;
+	if (g) col |= 0x003700 + 0x002800 * g;
+	if (b) col |= 0x000037 + 0x000028 * b;
+	return col;
+    }
+
+    m256 -= 232;
+    return 0x080808 + m256 * 0x0a0a0a;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			dynamic data support		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetDD ( DynData_t *dd )
+{
+    if (dd)
+    {
+	FREE(dd->data);
+	dd->data = 0;
+	dd->len = dd->size = 0;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void InsertDD ( DynData_t *dd, const void *data, uint data_size )
+{
+    DASSERT(dd);
+    DASSERT( !dd->data == !dd->size );
+    DASSERT( dd->len <= dd->size );
+
+    if ( !data || !data_size )
+	dd->len = 0;
+    else
+    {
+	if ( data_size > dd->size )
+	{
+	    FREE(dd->data);
+	    dd->data = MALLOC(data_size);
+	    dd->size = data_size;
+	}
+
+	memcpy(dd->data,data,data_size);
+	dd->len = data_size;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetDDL ( DynDataList_t *ddl )
+{
+    if (ddl)
+    {
+	DynData_t *dd  = ddl->list;
+	DynData_t *end = dd + ddl->used;
+	for ( ; dd < end; dd++ )
+	    FREE(dd->data);
+
+	FREE(ddl->list);
+	ddl->list = 0;
+	ddl->used = ddl->size = 0;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+DynData_t *InsertDDL
+(
+    DynDataList_t	*ddl,		// valid dynamic data list
+    uint		index,		// element index to change
+    const void		*data,		// NULL or data to assign
+    uint		data_size	// size of data
+)
+{
+    DASSERT(ddl);
+    DASSERT( !ddl->list == !ddl->size );
+    DASSERT( ddl->used <= ddl->size );
+
+    if ( index >= ddl->size )
+    {
+	const uint new_size = 11 * index / 10 + 10;
+	ddl->list = REALLOC( ddl->list, sizeof(*ddl->list) * new_size );
+	memset( ddl->list + ddl->size, 0, (new_size - ddl->size) * sizeof(*ddl->list) );
+	ddl->size = new_size;
+    }
+
+    if ( ddl->used <= index )
+    {
+	uint idx;
+	for ( idx = ddl->used; idx < index; idx++ )
+	    ddl->list[idx].len = 0;
+	ddl->used = index+1;
+    }
+
+    DynData_t *dd = ddl->list + index;
+    InsertDD(dd,data,data_size);
+    return dd;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+DynData_t *GetDDL
+(
+    DynDataList_t	*ddl,		// valid dynamic data list
+    uint		index,		// element index to get
+    uint		create		// create an empty element if not exist
+)
+{
+    DASSERT(ddl);
+    DASSERT( !ddl->list == !ddl->size );
+    DASSERT( ddl->used <= ddl->size );
+
+    return index < ddl->used
+		? ddl->list + ddl->used
+		: create
+		    ? InsertDDL(ddl, index >= create ? index : create-1, 0,0)
+		    : 0;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			  StringField_t			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetStringField ( StringField_t * sf )
+{
+    DASSERT(sf);
+    if (sf)
+    {
+	if ( sf->used > 0 )
+	{
+	    DASSERT(sf->field);
+	    ccp *ptr = sf->field, *end;
+	    for ( end = ptr + sf->used; ptr < end; ptr++ )
+		FreeString(*ptr);
+	}
+	FREE(sf->field);
+
+	int (*func_cmp)( ccp s1, ccp s2 ) = sf->func_cmp;
+	InitializeStringField(sf);
+	sf->func_cmp = func_cmp;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void MoveStringField ( StringField_t * dest, StringField_t * src )
+{
+    DASSERT(src);
+    DASSERT(dest);
+    if ( src != dest )
+    {
+	ResetStringField(dest);
+	dest->field	= src->field;
+	dest->used	= src->used;
+	dest->size	= src->size;
+	dest->func_cmp	= src->func_cmp;
+
+	InitializeStringField(src);
+	src->func_cmp	= dest->func_cmp;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int FindStringFieldIndex ( const StringField_t * sf, ccp key, int not_found_value )
+{
+    bool found;
+    const int idx = FindStringFieldHelper(sf,&found,key);
+    return found ? idx : not_found_value;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp FindStringField ( const StringField_t * sf, ccp key )
+{
+    bool found;
+    const int idx = FindStringFieldHelper(sf,&found,key);
+    return found ? sf->field[idx] : 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp * InsertStringFieldHelper ( StringField_t * sf, int idx )
+{
+    DASSERT(sf);
+    DASSERT( sf->used <= sf->size );
+    noPRINT("+SF: %u/%u/%u\n",idx,sf->used,sf->size);
+    if ( sf->used == sf->size )
+    {
+	sf->size += 0x100;
+	sf->field = REALLOC(sf->field,sf->size*sizeof(*sf->field));
+    }
+    DASSERT( idx <= sf->used );
+    ccp * dest = sf->field + idx;
+    memmove(dest+1,dest,(sf->used-idx)*sizeof(*dest));
+    sf->used++;
+    return dest;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool InsertStringField ( StringField_t * sf, ccp key, bool move_key )
+{
+    if (!key)
+	return 0;
+
+    bool found;
+    int idx = FindStringFieldHelper(sf,&found,key);
+    if (found)
+    {
+	if (move_key)
+	    FreeString(key);
+    }
+    else
+    {
+	ccp * dest = InsertStringFieldHelper(sf,idx);
+	*dest = move_key ? key : STRDUP(key);
+    }
+
+    return !found;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool RemoveStringField ( StringField_t * sf, ccp key )
+{
+    bool found;
+    uint idx = FindStringFieldHelper(sf,&found,key);
+    if (found)
+    {
+	sf->used--;
+	ASSERT( idx <= sf->used );
+	ccp * dest = sf->field + idx;
+	FreeString(*dest);
+	memmove(dest,dest+1,(sf->used-idx)*sizeof(*dest));
+    }
+    return found;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint RemoveStringFieldByIndex ( StringField_t * sf, int index, int n )
+{
+    DASSERT(sf);
+
+    if ( index < 0 )
+	index += sf->used;
+    if ( n < 0 )
+    {
+	index += n;
+	n -= n;
+    }
+
+    if ( index < 0 )
+	index = 0;
+    int last = index + n;
+    if ( last > sf->used )
+	last = sf->used;
+    if ( index >= last )
+	return 0;
+
+    ccp * src = sf->field + index;
+    ccp * end = sf->field + last;
+    while ( src < end )
+	FreeString(*src++);
+
+    memmove( sf->field + index, src, ( sf->used - last) * sizeof(*sf->field) );
+    const uint rm = last - index;
+    sf->used -= rm;
+    return rm;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void AppendStringField ( StringField_t * sf, ccp key, bool move_key )
+{
+    DASSERT(sf);
+    if (key)
+    {
+	DASSERT( sf->used <= sf->size );
+	noPRINT(">SF: %u/%u\n",sf->used,sf->size);
+	if ( sf->used == sf->size )
+	{
+	    sf->size += 0x100;
+	    sf->field = REALLOC(sf->field,sf->size*sizeof(*sf->field));
+	}
+	TRACE("AppendStringField(%s,%d) %d/%d\n",key,move_key,sf->used,sf->size);
+	ccp *dest = sf->field + sf->used++;
+	*dest = move_key ? key : STRDUP(key);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void SortStringField ( StringField_t * sf )
+{
+    DASSERT(sf);
+    if ( sf->used > 1 )
+    {
+	StringField_t temp;
+	InitializeStringField(&temp);
+	temp.func_cmp = sf->func_cmp;
+	uint i;
+	for ( i = 0; i < sf->used; i++ )
+	    InsertStringField(&temp,sf->field[i],true);
+	sf->used = 0;
+	MoveStringField(sf,&temp);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint FindStringFieldHelper ( const StringField_t * sf, bool * p_found, ccp key )
+{
+    DASSERT(sf);
+
+    int (*cmp)( ccp s1, ccp s2 ) = sf->func_cmp ? sf->func_cmp : strcmp;
+
+    int beg = 0;
+    if ( sf && key )
+    {
+	int end = sf->used - 1;
+	while ( beg <= end )
+	{
+	    const uint idx = (beg+end)/2;
+	    const int stat = cmp(key,sf->field[idx]);
+	    if ( stat < 0 )
+		end = idx - 1;
+	    else if ( stat > 0 )
+		beg = idx + 1;
+	    else
+	    {
+		noTRACE("FindStringFieldHelper(%s) FOUND=%d/%d/%d\n",
+			key, idx, sf->used, sf->size );
+		if (p_found)
+		    *p_found = true;
+		return idx;
+	    }
+	}
+    }
+
+    noTRACE("FindStringFieldHelper(%s) failed=%d/%d/%d\n",
+		key, beg, sf->used, sf->size );
+
+    if (p_found)
+	*p_found = false;
+    return beg;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError LoadStringField
+(
+    StringField_t	* sf,		// string field
+    bool		init_sf,	// true: initialize 'sf' first
+    bool		sort,		// true: sort 'sf'
+    ccp			filename,	// filename of source file
+    bool		silent		// true: don't print open/read errors
+)
+{
+    ASSERT(sf);
+    DASSERT(filename);
+    DASSERT(*filename);
+
+    TRACE("LoadStringField(%p,%d,%d,%s,%d)\n",sf,init_sf,sort,filename,silent);
+
+    if (init_sf)
+	InitializeStringField(sf);
+
+    FILE * f = fopen(filename,"rb");
+    if (!f)
+    {
+	if (!silent)
+	    ERROR1(ERR_CANT_OPEN,"Can't open file: %s\n",filename);
+	return ERR_CANT_OPEN;
+    }
+
+    char iobuf[10000];
+    while (fgets(iobuf,sizeof(iobuf)-1,f))
+    {
+	char *ptr = iobuf;
+	while (*ptr)
+	    ptr++;
+	if ( ptr > iobuf && ptr[-1] == '\n' )
+	{
+	    ptr--;
+	    if ( ptr > iobuf && ptr[-1] == '\r' )
+		ptr--;
+	}
+
+	if ( ptr > iobuf )
+	{
+	    *ptr++ = 0;
+	    const size_t len = ptr-iobuf;
+	    ptr = MALLOC(len);
+	    memcpy(ptr,iobuf,len);
+	    if (sort)
+		InsertStringField(sf,ptr,true);
+	    else
+		AppendStringField(sf,ptr,true);
+	}
+    }
+
+    fclose(f);
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError SaveStringField
+(
+    StringField_t	* sf,		// valid string field
+    ccp			filename,	// filename of dest file
+    bool		rm_if_empty	// true: rm dest file if 'sf' is empty
+)
+{
+    ASSERT(sf);
+    ASSERT(filename);
+    ASSERT(*filename);
+
+    TRACE("SaveStringField(%p,%s,%d)\n",sf,filename,rm_if_empty);
+
+    if ( !sf->used && rm_if_empty )
+    {
+	unlink(filename);
+	return ERR_OK;
+    }
+
+    FILE * f = fopen(filename,"wb");
+    if (!f)
+	return ERROR1(ERR_CANT_CREATE,"Can't create file: %s\n",filename);
+
+    enumError err = WriteStringField(f,filename,sf,0,0);
+    fclose(f);
+    return err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError WriteStringField
+(
+    FILE		* f,		// open destination file
+    ccp			filename,	// NULL or filename (needed on write error)
+    StringField_t	* sf,		// valid string field
+    ccp			prefix,		// not NULL: insert prefix before each line
+    ccp			eol		// end of line text (if NULL: use LF)
+)
+{
+    if (!prefix)
+	prefix = "";
+    if (!eol)
+	eol = "\n";
+
+    ccp *ptr = sf->field, *end;
+    for ( end = ptr + sf->used; ptr < end; ptr++ )
+	if ( fprintf(f,"%s%s%s",prefix,*ptr,eol) < 0 )
+	    return ERROR1(ERR_WRITE_FAILED,
+			"Error while writing string list: %s\n",
+			filename ? filename : "?" );
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void SaveCurrentStateStringField
+(
+    FILE		*f,		// output file
+    ccp			name_prefix,	// NULL or prefix of name, up to 40 chars
+    uint		tab_pos,	// tab pos of '='
+    const StringField_t	*sf,		// valid string field
+    EncodeMode_t	emode		// encoding mode
+)
+{
+    DASSERT(f);
+    DASSERT(sf);
+
+    if (!name_prefix)
+	name_prefix = EmptyString;
+
+    int base = 8*tab_pos + 7 - strlen(name_prefix);
+    fprintf(f,"%sn%.*s= %u\n", name_prefix, (base-1)/8, Tabs20, sf->used );
+
+    char buf[5000], name[10];
+
+    uint i;
+    for ( i = 0; i < sf->used; i++ )
+    {
+	const uint len = snprintf(name,sizeof(name),"%u",i);
+	mem_t mem = EncodeByModeMem(buf,sizeof(buf),sf->field[i],-1,emode);
+	fprintf(f, "%s%s%.*s= %s\n",
+		name_prefix, name, (base-len)/8, Tabs20, mem.ptr );
+	if ( mem.ptr != buf )
+	    FreeMem(&mem);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void RestoreStateStringField
+(
+    RestoreState_t	*rs,		// info data, may be modified
+    ccp			name_prefix,	// NULL or prefix of name, up to 40 chars
+    StringField_t	*sf,		// string field
+    bool		init_sf,	// true: initialize 'sf', otherwise reset
+    EncodeMode_t	emode		// encoding mode
+)
+{
+    DASSERT(rs);
+    DASSERT(sf);
+
+    if (init_sf)
+	InitializeStringField(sf);
+    else
+	ResetStringField(sf);
+
+    if (!name_prefix)
+	name_prefix = EmptyString;
+
+    char name[50];
+    snprintf(name,sizeof(name),"%sn",name_prefix);
+    int n = GetParamFieldINT(rs,name,0);
+    PRINT("RestoreStateStringField(), N=%d\n",n);
+    if ( n > 0 )
+    {
+	sf->size = n;
+	sf->field = MALLOC(sf->size*sizeof(*sf->field));
+
+	uint i;
+	for ( i = 0; i < n; i++ )
+	{
+	    snprintf(name,sizeof(name),"%s%u",name_prefix,i);
+	    ParamFieldItem_t *pfi = GetParamField(rs,name);
+	    if (pfi)
+	    {
+		mem_t mem = DecodeByModeMem(0,0,pfi->data,-1,emode);
+		AppendStringField(sf,mem.ptr,true);
+	    }
+	}
+    }
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			  ParamField_t			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void InitializeParamField ( ParamField_t * pf )
+{
+    DASSERT(pf);
+    memset(pf,0,sizeof(*pf));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetParamField ( ParamField_t * pf )
+{
+    DASSERT(pf);
+    if (pf)
+    {
+	if ( pf->used > 0 )
+	{
+	    DASSERT(pf->field);
+	    ParamFieldItem_t *ptr = pf->field, *end;
+	    for ( end = ptr + pf->used; ptr < end; ptr++ )
+	    {
+		FreeString(ptr->key);
+		if (pf->free_data)
+		    FREE(ptr->data);
+	    }
+	}
+	FREE(pf->field);
+
+	const bool free_data = pf->free_data;
+	int (*func_cmp)( ccp s1, ccp s2 ) = pf->func_cmp;
+	InitializeParamField(pf);
+	pf->free_data = free_data;
+	pf->func_cmp = func_cmp;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void MoveParamField ( ParamField_t * dest, ParamField_t * src )
+{
+    DASSERT(src);
+    DASSERT(dest);
+    if ( src != dest )
+    {
+	ResetParamField(dest);
+	dest->field	= src->field;
+	dest->used	= src->used;
+	dest->size	= src->size;
+	dest->free_data	= src->free_data;
+	InitializeParamField(src);
+	src->free_data	= dest->free_data;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int FindParamFieldIndex ( const ParamField_t * pf, ccp key, int not_found_value )
+{
+    bool found;
+    const int idx = FindParamFieldHelper(pf,&found,key);
+    return found ? idx : not_found_value;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ParamFieldItem_t * FindParamField ( const ParamField_t * pf, ccp key )
+{
+    bool found;
+    const int idx = FindParamFieldHelper(pf,&found,key);
+    return found ? pf->field + idx : 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ParamFieldItem_t * FindParamFieldByNum ( const ParamField_t * pf, uint num )
+{
+    DASSERT(pf);
+    noTRACE("FindParamFieldByNum(%x)\n",num);
+
+    ParamFieldItem_t *ptr = pf->field, *end;
+    for ( end = ptr + pf->used; ptr < end; ptr++ )
+	if ( ptr->num == num )
+	    return ptr;
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static ParamFieldItem_t * InsertParamFieldHelper ( ParamField_t * pf, int idx )
+{
+    DASSERT(pf);
+    DASSERT( pf->used <= pf->size );
+    noPRINT("+SF: %u/%u/%u\n",idx,pf->used,pf->size);
+    if ( pf->used == pf->size )
+    {
+	pf->size += 0x100;
+	pf->field = REALLOC(pf->field,pf->size*sizeof(*pf->field));
+    }
+    DASSERT( idx <= pf->used );
+    ParamFieldItem_t * dest = pf->field + idx;
+    memmove(dest+1,dest,(pf->used-idx)*sizeof(*dest));
+    pf->used++;
+    return dest;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ParamFieldItem_t * FindInsertParamField
+	( ParamField_t * pf, ccp key, bool move_key, bool *old_found )
+{
+    if (!key)
+	return 0;
+
+    noTRACE("InsertParamField(%s,%x)\n",key,num);
+
+    bool found;
+    int idx = FindParamFieldHelper(pf,&found,key);
+    ParamFieldItem_t *item;
+    if (found)
+    {
+	if (move_key)
+	    FreeString(key);
+	item = pf->field + idx;
+    }
+    else
+    {
+	item = InsertParamFieldHelper(pf,idx);
+	item->key  = move_key ? key : STRDUP(key);
+	item->num  = 0;
+	item->data = 0;
+    }
+
+    if (old_found)
+	*old_found = found;
+    return item;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ParamFieldItem_t * CountParamField ( ParamField_t * pf, ccp key, bool move_key )
+{
+    ParamFieldItem_t *item = FindInsertParamField(pf,key,move_key,0);
+    if (item)
+	item->num++;
+    return item;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool InsertParamField
+	( ParamField_t * pf, ccp key, bool move_key, uint num, cvp data )
+{
+    if (!key)
+	return 0;
+
+    noTRACE("InsertParamField(%s,%x)\n",key,num);
+
+    bool found;
+    int idx = FindParamFieldHelper(pf,&found,key);
+    if (found)
+    {
+	if (move_key)
+	    FreeString(key);
+	if (pf->free_data)
+	    FREE((void*)data);
+    }
+    else
+    {
+	ParamFieldItem_t * dest = InsertParamFieldHelper(pf,idx);
+	dest->key  = move_key ? key : STRDUP(key);
+	dest->num  = num;
+	dest->data = (void*)data;
+    }
+
+    return !found;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ParamFieldItem_t * InsertParamFieldEx
+	( ParamField_t * pf, ccp key, bool move_key, uint num, bool *p_found )
+{
+    if (!key)
+	return 0;
+
+    noTRACE("InsertParamField(%s,%x)\n",key,num);
+
+    bool found;
+    int idx = FindParamFieldHelper(pf,&found,key);
+    if (p_found)
+	*p_found = found;
+
+    if (found)
+    {
+	if (move_key)
+	    FreeString(key);
+	return pf->field + idx;
+    }
+
+    ParamFieldItem_t * dest = InsertParamFieldHelper(pf,idx);
+    dest->key  = move_key ? key : STRDUP(key);
+    dest->num  = num;
+    dest->data = 0;
+    return dest;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool ReplaceParamField
+	( ParamField_t * pf, ccp key, bool move_key, uint num, cvp data )
+{
+    if (!key)
+	return 0;
+
+    noTRACE("InsertParamField(%s,%x)\n",key,num);
+
+    bool found;
+    int idx = FindParamFieldHelper(pf,&found,key);
+    if (found)
+    {
+	if (move_key)
+	    FreeString(key);
+
+	ParamFieldItem_t * dest = pf->field + idx;
+	dest->num = num;
+	FREE(dest->data);
+	dest->data = (void*)data;
+    }
+    else
+    {
+	ParamFieldItem_t * dest = InsertParamFieldHelper(pf,idx);
+	dest->key  = move_key ? key : STRDUP(key);
+	dest->num  = num;
+	dest->data = (void*)data;
+    }
+
+    return !found;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool RemoveParamField ( ParamField_t * pf, ccp key )
+{
+    bool found;
+    uint idx = FindParamFieldHelper(pf,&found,key);
+    if (found)
+    {
+	pf->used--;
+	ASSERT( idx <= pf->used );
+	ParamFieldItem_t * dest = pf->field + idx;
+	FreeString(dest->key);
+	if (pf->free_data)
+	    FREE(dest->data);
+	memmove(dest,dest+1,(pf->used-idx)*sizeof(*dest));
+    }
+    return found;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ParamFieldItem_t * AppendParamField
+	( ParamField_t * pf, ccp key, bool move_key, uint num, cvp data )
+{
+    DASSERT(pf);
+    if (key)
+    {
+	DASSERT( pf->used <= pf->size );
+	noPRINT(">SF: %u/%u\n",pf->used,pf->size);
+	if ( pf->used == pf->size )
+	{
+	    pf->size += 0x100;
+	    pf->field = REALLOC(pf->field,pf->size*sizeof(*pf->field));
+	}
+	TRACE("AppendParamField(%s,%d) %d/%d\n",key,move_key,pf->used,pf->size);
+	ParamFieldItem_t * dest = pf->field + pf->used++;
+	dest->key  = move_key ? key : STRDUP(key);
+	dest->num  = num;
+	dest->data = (void*)data;
+	return dest;
+    }
+
+    if (pf->free_data)
+	FREE((void*)data);
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint FindParamFieldHelper ( const ParamField_t * pf, bool * p_found, ccp key )
+{
+    DASSERT(pf);
+
+    int (*cmp)( ccp s1, ccp s2 ) = pf->func_cmp ? pf->func_cmp : strcmp;
+
+    int beg = 0;
+    if ( pf && key )
+    {
+	int end = pf->used - 1;
+	while ( beg <= end )
+	{
+	    uint idx = (beg+end)/2;
+	    int stat = cmp(key,pf->field[idx].key);
+	    if ( stat < 0 )
+		end = idx - 1 ;
+	    else if ( stat > 0 )
+		beg = idx + 1;
+	    else
+	    {
+		noTRACE("FindParamFieldHelper(%s) FOUND=%d/%d/%d\n",
+			key, idx, pf->used, pf->size );
+		if (p_found)
+		    *p_found = true;
+		return idx;
+	    }
+	}
+    }
+
+    noTRACE("FindParamFieldHelper(%s) failed=%d/%d/%d\n",
+		key, beg, pf->used, pf->size );
+
+    if (p_found)
+	*p_found = false;
+    return beg;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    Memory Maps			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void InitializeMemMap ( MemMap_t * mm )
+{
+    DASSERT(mm);
+    memset(mm,0,sizeof(*mm));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetMemMap ( MemMap_t * mm )
+{
+    DASSERT(mm);
+
+    uint i;
+    if (mm->field)
+    {
+	for ( i = 0; i < mm->used; i++ )
+	    FREE(mm->field[i]);
+	FREE(mm->field);
+    }
+    memset(mm,0,sizeof(*mm));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void CopyMemMap
+(
+    MemMap_t		* mm1,		// merged mem map, not NULL, cleared
+    const MemMap_t	* mm2,		// NULL or second mem map
+    bool		use_tie		// TRUE: use InsertMemMapTie()
+)
+{
+    DASSERT(mm1);
+    ResetMemMap(mm1);
+    MergeMemMap(mm1,mm2,use_tie);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void MergeMemMap
+(
+    MemMap_t		* mm1,		// merged mem map, not NULL, not cleared
+    const MemMap_t	* mm2,		// NULL or second mem map
+    bool		use_tie		// TRUE: use InsertMemMapTie()
+)
+{
+    DASSERT(mm1);
+    if (mm2)
+    {
+	uint i;
+	for ( i = 0; i < mm2->used; i++ )
+	{
+	    const MemMapItem_t *src = mm2->field[i];
+	    if (src)
+	    {
+		MemMapItem_t *it = use_tie
+			? InsertMemMapTie(mm1,src->off,src->size)
+			: InsertMemMap(mm1,src->off,src->size);
+		if (it)
+		    StringCopyS(it->info,sizeof(it->info),src->info);
+	    }
+	}
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+MemMapItem_t * FindMemMap ( MemMap_t * mm, off_t off, off_t size )
+{
+    DASSERT(mm);
+
+    off_t off_end = off + size;
+    int beg = 0;
+    int end = mm->used - 1;
+    while ( beg <= end )
+    {
+	uint idx = (beg+end)/2;
+	MemMapItem_t * mi = mm->field[idx];
+	if ( off_end <= mi->off )
+	    end = idx - 1 ;
+	else if ( off >= mi->off + mi->size )
+	    beg = idx + 1;
+	else
+	    return mi;
+    }
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint InsertMemMapIndex
+(
+    // returns the index of the new item
+
+    MemMap_t		* mm,		// mem map pointer
+    off_t		off,		// offset of area
+    off_t		size		// size of area
+)
+{
+    DASSERT(mm);
+    uint idx = FindMemMapHelper(mm,off,size);
+
+    DASSERT( mm->used <= mm->size );
+    if ( mm->used == mm->size )
+    {
+	mm->size += 64;
+	mm->field = REALLOC(mm->field,mm->size*sizeof(*mm->field));
+    }
+
+    DASSERT( idx <= mm->used );
+    MemMapItem_t ** dest = mm->field + idx;
+    memmove(dest+1,dest,(mm->used-idx)*sizeof(*dest));
+    mm->used++;
+
+    MemMapItem_t * mi = MALLOC(sizeof(MemMapItem_t));
+    mi->off  = off;
+    mi->size = size;
+    mi->overlap = 0;
+    *dest = mi;
+    return idx;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+MemMapItem_t * InsertMemMap
+(
+    // returns a pointer to a new item (never NULL)
+
+    MemMap_t		* mm,		// mem map pointer
+    off_t		off,		// offset of area
+    off_t		size		// size of area
+)
+{
+    const uint idx = InsertMemMapIndex(mm,off,size);
+    // a C sequence point is important here
+    return mm->field[idx];
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static bool TieMemMap
+(
+    // returns true if element are tied togehther
+
+    MemMap_t		* mm,		// mem map pointer
+    uint		idx,		// tie element 'idx' and 'idx+1'
+    bool		force		// always tie and not only if overlapped
+)
+{
+    DASSERT(mm);
+    DASSERT( idx+1 < mm->used );
+
+    MemMapItem_t * i1 = mm->field[idx];
+    MemMapItem_t * i2 = mm->field[idx+1];
+    if ( force || i1->off + i1->size >= i2->off )
+    {
+	const off_t new_size = i2->off + i2->size - i1->off;
+	if ( i1->size < new_size )
+	     i1->size = new_size;
+	FREE(i2);
+	idx++;
+	mm->used--;
+	memmove( mm->field + idx,
+		 mm->field + idx + 1,
+		 ( mm->used - idx ) * sizeof(MemMapItem_t*) );
+
+	return true;
+    }
+    return false;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+MemMapItem_t * InsertMemMapTie
+(
+    // returns a pointer to a new or existing item (never NULL)
+
+    MemMap_t		* mm,		// mem map pointer
+    off_t		off,		// offset of area
+    off_t		size		// size of area
+)
+{
+    uint idx = InsertMemMapIndex(mm,off,size);
+
+    if ( idx > 0 && TieMemMap(mm,idx-1,false) )
+	idx--;
+
+    while ( idx + 1 < mm->used && TieMemMap(mm,idx,false) )
+	;
+
+    return mm->field[idx];
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void InsertMemMapWrapper
+(
+	void		* param,	// user defined parameter
+	u64		offset,		// offset of object
+	u64		size,		// size of object
+	ccp		info		// info about object
+)
+{
+    noTRACE("InsertMemMapWrapper(%p,%llx,%llx,%s)\n",param,offset,size,info);
+    DASSERT(param);
+    MemMapItem_t * mi = InsertMemMap(param,offset,size);
+    StringCopyS(mi->info,sizeof(mi->info),info);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint FindMemMapHelper ( MemMap_t * mm, off_t off, off_t size )
+{
+    DASSERT(mm);
+
+    int beg = 0;
+    int end = mm->used - 1;
+    while ( beg <= end )
+    {
+	uint idx = (beg+end)/2;
+	MemMapItem_t * mi = mm->field[idx];
+	if ( off < mi->off )
+	    end = idx - 1 ;
+	else if ( off > mi->off )
+	    beg = idx + 1;
+	else if ( size < mi->size )
+	    end = idx - 1 ;
+	else if ( size > mi->size )
+	    beg = idx + 1;
+	else
+	{
+	    TRACE("FindMemMapHelper(%llx,%llx) FOUND=%d/%d/%d\n",
+		    (u64)off, (u64)size, idx, mm->used, mm->size );
+	    return idx;
+	}
+    }
+
+    TRACE("FindStringFieldHelper(%llx,%llx) failed=%d/%d/%d\n",
+		(u64)off, (u64)size, beg, mm->used, mm->size );
+    return beg;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint CalcOverlapMemMap ( MemMap_t * mm )
+{
+    DASSERT(mm);
+
+    uint i, count = 0;
+    MemMapItem_t * prev = 0;
+    for ( i = 0; i < mm->used; i++ )
+    {
+	MemMapItem_t * ptr = mm->field[i];
+	ptr->overlap = 0;
+	if ( prev && ptr->off < prev->off + prev->size )
+	{
+	    ptr ->overlap |= 1;
+	    prev->overlap |= 2;
+	    count++;
+	}
+	prev = ptr;
+    }
+    return count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u64 FindFreeSpaceMemMap
+(
+    // return address or NULL on not-found
+
+    const MemMap_t	* mm,
+    u64			addr_beg,	// first possible address
+    u64			addr_end,	// last possible address
+    u64			size,		// minimal size
+    u64			align,		// aligning
+    u64			*space		// not NULL: store available space here
+)
+{
+    DASSERT(mm);
+
+    if (!size)
+	goto term;
+
+    if (!align)
+	align = 1;
+    addr_beg = ALIGN64(addr_beg,align);
+
+    uint i;
+    for ( i = 0; i < mm->used; i++ )
+    {
+	MemMapItem_t *mi = mm->field[i];
+	const u64 end = ALIGN64( mi->off + mi->size, align );
+	if ( mi->off > addr_beg )
+	{
+	    u64 found_space = ALIGNOFF64(mi->off,align) - addr_beg;
+	    if ( size <= found_space )
+	    {
+		if (space)
+		    *space = found_space;
+		return addr_beg;
+	    }
+	}
+	if ( addr_beg < end )
+	    addr_beg = end;
+    }
+
+    u64 found_space = ALIGNOFF64(addr_end,align) - addr_beg;
+    if ( size <= found_space )
+    {
+	if (space)
+	    *space = found_space;
+	return addr_beg;
+    }
+
+ term:
+    if (space)
+	*space = 0;
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void PrintMemMap ( MemMap_t * mm, FILE * f, int indent, ccp info_head )
+{
+    DASSERT(mm);
+    if ( !f || !mm->used )
+	return;
+
+    CalcOverlapMemMap(mm);
+    indent = NormalizeIndent(indent);
+
+    static char ovl[][3] = { "  ", "!.", ".!", "!!" };
+
+    if (!info_head)
+	info_head = "info";
+    int i, max_ilen = strlen(info_head);
+    for ( i = 0; i < mm->used; i++ )
+    {
+	MemMapItem_t * ptr = mm->field[i];
+	ptr->info[sizeof(ptr->info)-1] = 0;
+	const int ilen = strlen(ptr->info);
+	if ( max_ilen < ilen )
+	    max_ilen = ilen;
+    }
+
+    fprintf(f,"%*s      unused :  off(beg) ..  off(end) :      size : %s\n%*s%.*s\n",
+	    indent, "", info_head,
+	    indent, "", max_ilen+52, Minus300 );
+
+    off_t max_end = mm->begin;
+    for ( i = 0; i < mm->used; i++ )
+    {
+	MemMapItem_t * ptr = mm->field[i];
+	if ( !i && max_end > ptr->off )
+	    max_end = ptr->off;
+	const off_t end = ptr->off + ptr->size;
+	if ( ptr->off > max_end )
+	    fprintf(f,"%*s%s%10llx :%10llx ..%10llx :%10llx : %s\n",
+		indent, "", ovl[ptr->overlap&3], (u64)( ptr->off - max_end ),
+		(u64)ptr->off, (u64)end, (u64)ptr->size, ptr->info );
+	else
+	    fprintf(f,"%*s%s           :%10llx ..%10llx :%10llx : %s\n",
+		indent, "", ovl[ptr->overlap&3],
+		(u64)ptr->off, (u64)end, (u64)ptr->size, ptr->info );
+	if ( max_end < end )
+	    max_end = end;
+    }
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		    Memory Map: Scan addresses		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanAddress
+(
+    // returns first not scanned char of 'arg'
+
+    ScanAddr_t	* result,	// result, initialized by ScanAddress()
+    ccp		arg,		// format: ADDR | ADDR:END | ADDR#SIZE
+    uint	default_base	// base for numbers without '0x' prefix
+				//  0: C like with octal support
+				// 10: standard value for decimal numbers
+				// 16: standard value for hex numbers
+)
+{
+    DASSERT(result);
+    memset(result,0,sizeof(*result));
+    if (!arg)
+	return 0;
+
+    ccp end = ScanUINT(&result->addr,arg,default_base);
+    if ( end == arg )
+	return (char*)arg;
+    arg = end;
+    while ( *arg == ' ' || *arg == '\t' )
+	arg++;
+    result->size = 1;
+    result->stat = 1;
+
+    if ( *arg == ':' )
+    {
+	uint addr2;
+	end = ScanUINT(&addr2,++arg,default_base);
+	if ( end == arg )
+	    return(char*) arg-1;
+
+	result->size = addr2 > result->addr ? addr2 - result->addr : 0;
+	result->stat = 2;
+    }
+    else if ( *arg == '#' )
+    {
+	end = ScanUINT(&result->size,++arg,default_base);
+	result->stat = 2;
+    }
+
+    return (char*)end;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint InsertAddressMemMap
+(
+    // returns the number of added addresses
+
+    MemMap_t	* mm,		// mem map pointer
+    bool	use_tie,	// TRUE: use InsertMemMapTie()
+    ccp		arg,		// comma separated list of addresses
+				// formats: ADDR | ADDR:END | ADDR#SIZE
+    uint	default_base	// base for numbers without '0x' prefix
+				//  0: C like with octal support
+				// 10: standard value for decimal numbers
+				// 16: standard value for hex numbers
+)
+{
+    DASSERT(mm);
+    if (!arg)
+	return 0;
+
+    uint count = 0;
+    while (*arg)
+    {
+	ScanAddr_t addr;
+	arg = ScanAddress(&addr,arg,default_base);
+	if (addr.stat)
+	{
+	    if (use_tie)
+		InsertMemMapTie(mm,addr.addr,addr.size);
+	    else
+		InsertMemMap(mm,addr.addr,addr.size);
+	    count++;
+	}
+
+	while ( *arg && *arg != ' ' && *arg != '\t' && *arg != ',' )
+	    arg++;
+	while ( *arg == ' ' || *arg == '\t' || *arg == ',' )
+	    arg++;
+    }
+
+    return count;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    DataBuf_t			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void InitializeDataBuf
+	( DataBuf_t *db, uint buf_size, DataBufFill_t func, void *user_data )
+{
+    DASSERT(db);
+    memset(db,0,sizeof(*db));
+
+    if (buf_size)
+    {
+	db->size = buf_size;
+	db->buf = MALLOC(buf_size);
+	db->buf_end = db->buf + buf_size;
+	db->data = db->data_end = db->buf;
+    }
+
+    db->fill_func = func;
+    db->user_data = user_data;
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetDataBuf ( DataBuf_t *db )
+{
+    if (db)
+    {
+	DASSERT(!DumpDataBuf(stderr,0,db,true));
+	FREE(db->buf);
+	memset(db,0,sizeof(*db));
+	DASSERT(!DumpDataBuf(stderr,0,db,true));
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResizeDataBuf ( DataBuf_t *db, uint new_buf_size )
+{
+    DASSERT(db);
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+    DASSERT(new_buf_size>0);
+
+    if (!db->buf)
+	return;
+
+    PackDataBuf(db);
+    db->buf = REALLOC(db->buf,new_buf_size);
+    db->buf_end = db->buf + new_buf_size;
+    db->size = new_buf_size;
+    if ( db->used > new_buf_size )
+	 db->used = new_buf_size;
+    db->data = db->buf;
+    db->data_end = db->data + db->used;
+
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ClearDataBuf ( DataBuf_t *db, uint new_buf_size_if_not_null )
+{
+    DASSERT(db);
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+
+    db->offset = 0;
+    db->data = db->data_end = db->buf;
+    db->used = 0;
+    db->offset = 0;
+    if (new_buf_size_if_not_null)
+	ResizeDataBuf(db,new_buf_size_if_not_null);
+
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void EmptyDataBuf ( DataBuf_t *db )
+{
+    DASSERT(db);
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+
+    db->data = db->data_end = db->buf;
+    db->used = 0;
+
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void PackDataBuf ( DataBuf_t *db )
+{
+    DASSERT(db);
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+
+    if ( !db->used || !db->buf )
+    {
+	db->data = db->data_end = db->buf;
+    }
+    else if ( db->data > db->buf )
+    {
+	if ( db->data < db->data_end )
+	{
+	    // easy case: FREE1 DATA FREE2
+
+	    memmove(db->buf,db->data,db->used);
+	}
+	else
+	{
+	    // case: DATA2 FREE DATA1
+
+	    uint d1len = db->buf_end  - db->data;
+	    uint d2len = db->data_end - db->buf;
+	    DASSERT( d1len + d2len == db->used );
+
+ #ifdef TEST0
+	    u8 temp[10];
+ #else
+	    u8 temp[0x8000];
+ #endif
+	    if ( d2len <= sizeof(temp) && d2len < d1len )
+	    {
+		memcpy(temp,db->buf,d2len);
+		memmove(db->buf,db->data,d1len);
+		memcpy(db->buf+d1len,temp,d2len);
+	    }
+	    else if ( d1len <= sizeof(temp) )
+	    {
+		memcpy(temp,db->data,d1len);
+		memmove(db->buf+d1len,db->buf,d2len);
+		memcpy(db->buf,temp,d1len);
+	    }
+	    else
+	    {
+		noPRINT("PACK %u+%u/%u, temp=%zu\n",d2len,d1len,db->size,sizeof(temp));
+		// use a dynamic buffer => [2do]] optimize later
+		u8 *temp = MEMDUP(db->buf,d2len);
+		memmove(db->buf,db->data,d1len);
+		memcpy(db->buf+d1len,temp,d2len);
+		FREE(temp);
+	    }
+	}
+	db->data = db->buf;
+	db->data_end = db->data + db->used;
+    }
+
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+// debugging
+
+bool IsValidDataBuf ( DataBuf_t *db )
+{
+    if ( !db || db->used > db->size )
+	return false;
+
+    if (db->buf)
+    {
+	if ( db->buf_end != db->buf + db->size
+		|| db->data < db->buf || db->data >= db->buf_end )
+	    return false;
+
+	u8 *end = db->data + db->used;
+	if ( end > db->buf_end )
+	    end -= db->size;
+	return end == db->data_end;
+    }
+
+    return !db->size && !db->buf_end && !db->data && !db->data_end;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool DumpDataBuf ( FILE *f, uint indent, DataBuf_t *db, bool if_invalid )
+{
+    DASSERT(f);
+    DASSERT(db);
+    if ( if_invalid && IsValidDataBuf(db) )
+	return false;
+
+    fflush(stdout);
+    fflush(stderr);
+    indent = NormalizeIndent(indent);
+    if (!db)
+    {
+	fprintf(f,"%*sdata_buf_t: NULL\n",indent,"");
+	return true;
+    }
+
+    if (!db->buf)
+    {
+	fprintf(f,"%*sdata_buf_t buf: Invalid buf\n",indent,"");
+	return true;
+    }
+
+    fprintf(f,"%*sdata_buf_t %p .. %d, data %d .. %d, used %u/%u, off=%llu\n",
+	indent,"", db->buf, (int)(db->buf_end - db->buf),
+	(int)(db->data - db->buf), (int)(db->data_end - db->buf),
+	db->used, db->size, db->offset );
+
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void FillPatternDataBuf ( DataBuf_t *db )
+{
+    // fill the buffer with a test pattern:
+    //	'-' for unused bytes
+    //	">0123456789<" in a longer or shorter form for used bytes
+
+    DASSERT(db);
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+
+    memset(db->buf,'-',db->size);
+
+    if ( db->used <= 1 )
+    {
+	if ( db->used == 1 )
+	    *db->data = '+';
+	return;
+    }
+
+    u8 *ptr = db->data;
+    u8 *end = ptr + db->used - 1;
+    if ( end >= db->buf_end )
+	end -= db->size;
+    *ptr++ = '>';
+    *end = '<';
+    uint i = 0, len = end - ptr;
+    if ( len > db->size )
+	len += db->size;
+    for(;;)
+    {
+	if ( ptr == db->buf_end )
+	    ptr = db->buf;
+	if ( ptr == end )
+	    break;
+	*ptr++ = 'a' + i/len;
+	i += 26;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+uint InsertDataBuf
+(
+    // Insert at top of buffer.
+    // Return the number of inserted bytes
+
+    DataBuf_t	*db,		// valid pointer to data buffer
+    const void	*data,		// data to insert
+    uint	data_size,	// size of 'data'
+    bool	all_or_none	// true: insert complete data or nothing
+)
+{
+    DASSERT(db);
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+
+    uint space = db->size - db->used;
+    if ( data_size > space )
+    {
+	if (all_or_none)
+	    return 0;
+	data_size = space;
+    }
+
+    if (!db->used)
+	db->data = db->data_end = db->buf + data_size;
+    db->used += data_size;
+
+    uint copy_len = db->data - db->buf;
+    if ( copy_len > data_size )
+	 copy_len = data_size;
+    memcpy(db->data-copy_len,data,copy_len);
+    db->data -= copy_len;
+    if ( data_size > copy_len )
+    {
+	const uint copy_len2 = data_size - copy_len;
+	memcpy(db->buf_end-copy_len2,(u8*)data+copy_len,copy_len2);
+	db->data = db->buf_end - copy_len2;
+    }
+
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+    return data_size;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint AppendDataBuf
+(
+    // Append data at end of buffer
+    // Return the number of inserted bytes
+
+    DataBuf_t	*db,		// valid pointer to data buffer
+    const void	*data,		// data to insert
+    uint	data_size,	// size of 'data'
+    bool	all_or_none	// true: insert complete data or nothing
+)
+{
+    DASSERT(db);
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+
+    uint space = db->size - db->used;
+    noPRINT("APPEND %u/%u [%u/%u]\n",data_size,space,db->used,db->size);
+    if ( data_size > space )
+    {
+	if (all_or_none)
+	    return 0;
+	data_size = space;
+    }
+
+    if (!db->used)
+	db->data = db->data_end = db->buf;
+    db->used += data_size;
+
+    uint copy_len = db->buf_end - db->data_end;
+    if ( copy_len > data_size )
+	 copy_len = data_size;
+    memcpy(db->data_end,data,copy_len);
+    db->data_end += copy_len;
+    if ( data_size > copy_len )
+    {
+	const uint copy_len2 = data_size - copy_len;
+	memcpy(db->buf,(u8*)data+copy_len,copy_len2);
+	db->data_end = db->buf + copy_len2;
+    }
+
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+    return data_size;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void * GetPtrDataBuf
+(
+    // Return a pointer to the data and make sure,
+    // that the data is not wrapped. Return NULL if failed.
+
+    DataBuf_t	*db,		// valid pointer to data buffer
+    uint	data_size,	// number of needed bytes
+    uint	align,		// >1: Data alignment is also needed.
+				//  Only 2,4,8,16,... are allowed, but not verified.
+				//  Begin of buffer is always well aligned.
+    bool	drop		// true: On success, drop data from buffer
+				//       In real, the data is available and only
+				//       the pointers and counters are updated.
+)
+{
+    DASSERT(db);
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+
+    if (!data_size)
+	return db->data;
+    if ( data_size > db->used )
+    {
+	if ( data_size <= db->size && db->fill_func )
+	    db->fill_func(db,data_size-db->used,0);
+	if ( data_size > db->used )
+	    return 0;
+    }
+
+    if ( db->data + data_size > db->buf_end )
+	PackDataBuf(db);
+    else if ( align > 1 )
+    {
+	const uint offset = db->data - db->buf;
+	if ( offset & (align-1) )
+	    PackDataBuf(db);
+    }
+
+    u8 *res = db->data;
+    if (drop)
+    {
+	db->data += data_size;
+	db->used -= data_size;
+	DASSERT(!DumpDataBuf(stderr,0,db,true));
+    }
+
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint CopyDataBuf
+(
+    // Copy data from buffer, but don't remove it
+    // Return the number of copied bytes
+
+    DataBuf_t	*db,		// valid pointer to data buffer
+    void	*dest,		// destination buffer wit at least 'max_size' space
+    uint	min_read,	// return with 0 read bytes if less bytes available
+				// if 'min_read' > 'size', NULL is returned
+    uint	max_read	// try to read upto 'max_read' bytes
+)
+{
+    DASSERT(db);
+    DASSERT(dest);
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+
+    if ( min_read > db->used )
+    {
+	if ( min_read <= db->size && db->fill_func )
+	    db->fill_func(db,min_read-db->used,0);
+	if ( min_read > db->used )
+	    return 0;
+    }
+
+    if ( max_read > db->used )
+	 max_read = db->used;
+    uint copy_len1 = db->buf_end - db->data;
+    if ( copy_len1 >= max_read )
+	memcpy(dest,db->data,max_read);
+    else
+    {
+	memcpy(dest,db->data,copy_len1);
+	memcpy((u8*)dest+copy_len1,db->buf,max_read-copy_len1);
+    }
+
+    return max_read;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint GetDataBuf
+(
+    // Copy data from buffer and remove it
+    // Return the number of copied bytes
+
+    DataBuf_t	*db,		// valid pointer to data buffer
+    void	*dest,		// destination buffer wit at least 'max_size' space
+    uint	min_read,	// return with 0 read bytes if less bytes available
+    uint	max_read	// try to read upto 'max_read' bytes
+)
+{
+    DASSERT(db);
+    DASSERT(dest);
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+
+    if ( min_read > db->used )
+    {
+	if ( min_read <= db->size && db->fill_func )
+	    db->fill_func(db,min_read-db->used,0);
+	if ( min_read > db->used )
+	    return 0;
+    }
+
+    if ( max_read > db->used )
+	 max_read = db->used;
+    uint copy_len1 = db->buf_end - db->data;
+    if ( copy_len1 >= max_read )
+	memcpy(dest,db->data,max_read);
+    else
+    {
+	memcpy(dest,db->data,copy_len1);
+	memcpy((u8*)dest+copy_len1,db->buf,max_read-copy_len1);
+    }
+
+    db->used -= max_read;
+    if (db->used)
+    {
+	db->data += max_read;
+	if ( db->data >= db->buf_end )
+	    db->data -= db->size;
+    }
+    else
+	db->data = db->data_end = db->buf;
+
+    db->offset += max_read;
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+    return max_read;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint SkipDataBuf
+(
+    // Skip 'skip_size' from input stream. Read more data if needed.
+    // Return the number of really skiped bytes
+    // If <skip_size is returned, no more data is available.
+
+    DataBuf_t	*db,		// valid pointer to data buffer
+    uint	skip_size	// number of bytes to drop
+)
+{
+    DASSERT(db);
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+
+    uint skipped = 0;
+    for(;;)
+    {
+	uint stat = DropDataBuf(db,skip_size);
+	skipped += stat;
+	skip_size -= stat;
+	if (!skip_size)
+	    break;
+
+	if (db->fill_func)
+	{
+	    const uint max_fill = skip_size < db->size ? skip_size : db->size;
+	    db->fill_func(db,max_fill,0);
+	}
+
+	if (!db->used)
+	    break;
+    }
+
+    db->offset += skipped;
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+    return skipped;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint DropDataBuf
+(
+    // Remove upto 'drop_size' bytes from buffer.
+    // Return the number of dropped bytes.
+
+    DataBuf_t	*db,		// valid pointer to data buffer
+    uint	drop_size	// number of bytes to drop
+)
+{
+    DASSERT(db);
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+
+    if ( drop_size >= db->used )
+    {
+	drop_size = db->used;
+	db->used = 0;
+	db->data = db->data_end = db->buf;
+    }
+    else
+    {
+	db->data += drop_size;
+	if ( db->data >= db->buf_end )
+	    db->data -= db->size;
+	db->used -= drop_size;
+    }
+    db->offset += drop_size;
+
+    DASSERT(!DumpDataBuf(stderr,0,db,true));
+    return drop_size;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		ResizeElement_t, ResizeHelper_t		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void InitializeResize
+(
+    ResizeHelper_t	*r,		// data structure
+    uint		s_size,		// size of source
+    uint		d_size		// size of dest
+)
+{
+    DASSERT(r);
+    memset(r,0,sizeof(*r));
+
+    r->src_size	= s_size;
+    r->dest_size= d_size;
+    if ( !s_size || !d_size )
+	return;
+
+    const uint divisor = gcd(s_size,d_size);
+    s_size /= divisor;
+    d_size /= divisor;
+
+    r->sum_factor  = s_size;
+    r->half_factor = r->sum_factor/2;
+
+    r->idx_inc   = s_size / d_size;
+    r->frac_inc  = s_size % d_size;
+    r->frac_next = d_size;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static bool CalcResize ( ResizeHelper_t *r )
+{
+    DASSERT(r);
+
+    ResizeElement_t *re = r->elem;
+    re[0].n_elem = re[1].n_elem = re[2].n_elem = 0;
+    DASSERT(!re[3].n_elem);
+
+    if ( r->src_idx >= r->src_size || r->dest_idx >= r->dest_size )
+	return false;
+
+    uint sum = r->sum_factor;
+    if (r->src_frac)
+    {
+	uint max = r->frac_next - r->src_frac;
+	if ( max > sum )
+	    max = sum;
+	re->n_elem  = 1;
+	re->factor  = max;
+	re++;
+	sum -= max;
+    }
+
+    if ( sum >= r->frac_next )
+    {
+	const uint n = sum / r->frac_next;
+	re->n_elem  = n;
+	re->factor  = r->frac_next;
+	re++;
+	sum -= n * r->frac_next;
+    }
+
+    if ( sum > 0 )
+    {
+	re->n_elem  = 1;
+	re->factor  = sum;
+	re++;
+    }
+
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool FirstResize ( ResizeHelper_t *r )
+{
+    DASSERT(r);
+
+    r->dest_idx = r->src_idx = r->src_frac = 0;
+    memset(r->elem,0,sizeof(r->elem));
+    return CalcResize(r);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool NextResize ( ResizeHelper_t *r )
+{
+    DASSERT(r);
+
+    r->dest_idx++;
+    r->src_idx  += r->idx_inc;
+    r->src_frac += r->frac_inc;
+    if ( r->src_frac >= r->frac_next )
+    {
+	r->src_frac -= r->frac_next;
+	r->src_idx++;
+    }
+
+    return CalcResize(r);
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    GrowBuffer_t		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static const uint grow_buffer_size_factor = 0x100;
+
+///////////////////////////////////////////////////////////////////////////////
+
+void InitializeGrowBuffer ( GrowBuffer_t *gb, uint max_buf_size )
+{
+    DASSERT(gb);
+    memset(gb,0,sizeof(*gb));
+    gb->grow_size = grow_buffer_size_factor;
+    gb->max_size  = ( max_buf_size + grow_buffer_size_factor - 1 )
+		    / grow_buffer_size_factor * grow_buffer_size_factor;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetGrowBuffer ( GrowBuffer_t *gb )
+{
+    DASSERT(gb);
+    FREE(gb->buf);
+    const uint grow_size = gb->grow_size;
+    InitializeGrowBuffer(gb,gb->max_size);
+    gb->grow_size = grow_size;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint GetSpaceGrowBuffer
+(
+    // returns the maximal possible space
+    const GrowBuffer_t	*gb	// valid grow-buffer object
+)
+{
+    DASSERT(gb);
+    const uint max = gb->max_size > gb->size ? gb->max_size : gb->size;
+    return max - gb->used;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint PrepareGrowBuffer
+(
+    // returns the number of available space, smaller than or equal 'size'
+
+    GrowBuffer_t	*gb,	// valid grow-buffer object
+    uint		size,	// needed size
+    bool		force	// always alloc enough space and return 'size'
+)
+{
+ #if HAVE_DASSERT
+    DASSERT(gb);
+    if (gb->buf)
+    {
+	DASSERT( gb->used <= gb->size );
+	DASSERT( gb->ptr >= gb->buf );
+	DASSERT( gb->ptr + gb->used <= gb->buf + gb->size );
+    }
+    else
+    {
+	DASSERT(!gb->ptr);
+	DASSERT(!gb->size);
+	DASSERT(!gb->used);
+    }
+ #endif
+
+    if (!gb->buf)
+    {
+	//--- initial setup of buffer
+
+	if ( gb->grow_size < grow_buffer_size_factor )
+	    gb->grow_size = grow_buffer_size_factor;
+	else
+	    gb->grow_size = gb->grow_size
+			    / grow_buffer_size_factor * grow_buffer_size_factor;
+	gb->size = ( size / gb->grow_size + 1 ) * gb->grow_size;
+
+	if ( gb->max_size < grow_buffer_size_factor )
+	    gb->max_size = grow_buffer_size_factor;
+	else
+	    gb->max_size = gb->max_size
+			   / grow_buffer_size_factor * grow_buffer_size_factor;
+	if ( gb->size > gb->max_size )
+	    gb->size = gb->max_size;
+
+	if ( gb->size < size && force )
+	    gb->size =	( size + gb->grow_size )
+			/ gb->grow_size * gb->grow_size - 1;
+
+	gb->buf = gb->ptr = MALLOC(gb->size+1);  // 1 extra byte for NULL-TERM
+	gb->used = 0;
+    }
+    else
+    {
+	if (!gb->grow_size)
+	    gb->grow_size = grow_buffer_size_factor;
+	if (!gb->used)
+	    gb->ptr = gb->buf;
+    }
+    DASSERT(gb->grow_size);
+
+    uint avail = gb->size - gb->used;
+    if ( size > avail && ( force || gb->size < gb->max_size ) )
+    {
+	//--- grow buffer
+
+	gb->size = ( size + gb->used + gb->grow_size )
+		   / gb->grow_size * gb->grow_size - 1;
+	DASSERT( gb->used <= gb->size );
+	u8 *newbuf = MALLOC(gb->size+1); // 1 extra byte for NULL-TERM
+	memcpy(newbuf,gb->ptr,gb->used);
+	FREE(gb->buf);
+	gb->buf = gb->ptr = newbuf;
+    }
+
+    uint space = ( gb->buf + gb->size ) - ( gb->ptr + gb->used );
+    if ( space < size && gb->buf != gb->ptr )
+    {
+	memmove(gb->buf,gb->ptr,gb->used);
+	gb->ptr = gb->buf;
+	space = gb->size - gb->used;
+    }
+
+    DASSERT( gb->used <= gb->size );
+    DASSERT( gb->ptr >= gb->buf );
+    DASSERT( gb->ptr + gb->used <= gb->buf + gb->size );
+
+    return size < space ? size : space;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint InsertGrowBuffer
+(
+    // returns the number of inserted bytes
+
+    GrowBuffer_t	*gb,	// valid grow-buffer object
+    const void		*data,	// data to insert
+    uint		size	// size of 'data'
+)
+{
+    DASSERT(gb);
+    size = PrepareGrowBuffer(gb,size,false);
+    DASSERT( gb->ptr + gb->used + size <= gb->buf + gb->size );
+    memcpy( gb->ptr + gb->used, data, size );
+    gb->used += size;
+    gb->ptr[gb->used] = 0;
+    if ( gb->max_used < gb->used )
+	 gb->max_used = gb->used;
+
+    DASSERT( gb->used <= gb->size );
+    DASSERT( gb->ptr >= gb->buf );
+    DASSERT( gb->ptr + gb->used <= gb->buf + gb->size );
+
+    return size;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char *tiparm ( ccp str, ... );
+
+uint InsertCapNGrowBuffer
+(
+    // insert 'cap_1' or 'cap_n' depending of 'n' and the existence of 'cap_*'
+    // returns the number of inserted bytes
+
+    GrowBuffer_t	*gb,	// valid grow-buffer object
+    int			n,	// repeat number; if <1: insert nothing
+    mem_t		cap_1,	// default for N=1
+    mem_t		cap_n	// default for N>1
+)
+{
+    DASSERT(gb);
+
+    if ( n <= 0 )
+	return 0;
+
+    if ( n == 1 && cap_1.len )
+	return InsertMemGrowBuffer(gb,cap_1);
+
+ #if DCLIB_TERMINAL
+    if (cap_n.len)
+    {
+	ccp str = tiparm(cap_n.ptr,n);
+	if (str)
+	    return InsertGrowBuffer(gb,str,strlen(str));
+    }
+ #endif
+
+    if (!cap_1.len)
+	return 0;
+
+    const uint total = cap_1.len * n;
+    PrepareGrowBuffer(gb,total,true);
+    u8 *ptr = gb->ptr + gb->used;
+    while ( n-- > 0 )
+    {
+	memcpy(ptr,cap_1.ptr,cap_1.len);
+	ptr += cap_1.len;
+    }
+    gb->used += total;
+    gb->ptr[gb->used] = 0;
+    if ( gb->max_used < gb->used )
+	 gb->max_used = gb->used;
+    return total;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint WriteCapN
+(
+    // print 'cap_1' or 'cap_n' depending of 'n' and the existence of 'cap_*'
+    // returns the number of printed bytes
+
+    FILE		*f,	// valid FILE
+    int			n,	// repeat number; if <1: insert nothing
+    mem_t		cap_1,	// default for N=1
+    mem_t		cap_n	// default for N>1
+)
+{
+    DASSERT(f);
+
+    if ( n <= 0 )
+	return 0;
+
+    if ( n == 1 && cap_1.len )
+	return fwrite(cap_1.ptr,cap_1.len,1,f);
+
+ #if DCLIB_TERMINAL
+    if (cap_n.len)
+    {
+	ccp str = tiparm(cap_n.ptr,n);
+	if (str)
+	    return fwrite(str,strlen(str),1,f);
+    }
+ #endif
+
+    if (!cap_1.len)
+	return 0;
+
+    const uint total = cap_1.len * n;
+    while ( n-- > 0 )
+	fwrite(cap_1.ptr,cap_1.len,1,f);
+    return total;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint InsertCatchedGrowBuffer
+(
+    // returns the number of inserted bytes
+
+    GrowBuffer_t	*gb,	// valid grow-buffer object
+    SavedStdFiles_t	*ssf	// saved output and catched data
+)
+{
+    DASSERT(gb);
+    DASSERT(ssf);
+
+    TermCatchStdFiles(ssf);
+    uint stat = 0;
+    if (ssf->data)
+    {
+	PrepareGrowBuffer(gb,ssf->size,true);
+	stat = InsertGrowBuffer(gb,ssf->data,ssf->size);
+	XFREE(ssf->data);
+	ssf->data = 0;
+	ssf->size = 0;
+    }
+    return stat;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+uint PrintArgGrowBuffer
+(
+    // returns the number of inserted bytes
+
+    GrowBuffer_t	*gb,	// valid grow-buffer object
+    ccp			format,	// format string for vfprintf()
+    va_list		arg	// parameters for 'format'
+)
+{
+    DASSERT(gb);
+    DASSERT(format);
+
+    char buf[10000];
+
+    va_list arg2;
+    va_copy(arg2,arg);
+    int stat = vsnprintf(buf,sizeof(buf),format,arg2);
+    va_end(arg2);
+
+    if ( stat < sizeof(buf) )
+	return InsertGrowBuffer(gb,buf,stat);
+
+
+    //--- buffer too small, use dynamic memory
+
+    noPRINT("PrintArgGrowBuffer() -> MALLOC(%u)\n",stat+1);
+
+    char *dest = MALLOC(stat+1);
+    stat = vsnprintf(dest,stat+1,format,arg);
+
+    const uint res = InsertGrowBuffer(gb,dest,stat);
+    FREE(dest);
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint PrintGrowBuffer
+(
+    // returns the number of inserted bytes
+
+    GrowBuffer_t	*gb,	// valid grow-buffer object
+    ccp			format,	// format string for vfprintf()
+    ...				// arguments for 'vsnprintf(format,...)'
+)
+{
+    DASSERT(gb);
+    DASSERT(format);
+
+    va_list arg;
+    va_start(arg,format);
+    enumError err = PrintArgGrowBuffer(gb,format,arg);
+    va_end(arg);
+    return err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint ConvertToCrLfGrowBuffer
+(
+    // returns the number of inserted CR bytes
+
+    GrowBuffer_t	*gb,	// valid grow-buffer object
+    uint		begin	// index to begin with conversion
+)
+{
+    DASSERT(gb);
+    uint count = 0;
+
+    if ( begin < gb->used )
+    {
+	//--- count LF without CR
+
+	u8 *ptr = gb->ptr + begin;
+	u8 *end = gb->ptr + gb->used;
+	for ( ; ptr < end; ptr++ )
+	{
+	    if ( *ptr == '\r' )
+		ptr++;
+	    else if ( *ptr == '\n' )
+		count++;
+	}
+
+	if ( count > 0 )
+	{
+	    PrepareGrowBuffer(gb,count,true);
+	    u8 *src  = gb->ptr + gb->used;
+	    u8 *dest = src + count;
+	    u8 *beg  = gb->ptr + begin;
+	    while ( src > beg )
+	    {
+		const char ch = *--src;
+		*--dest = ch;
+		if ( ch == '\n' && src[-1] != '\r' )
+		    *--dest = '\r';
+	    }
+	    DASSERT( src == dest );
+	    gb->used += count;
+	    gb->ptr[gb->used] = 0;
+	    if ( gb->max_used < gb->used )
+		gb->max_used = gb->used;
+	}
+    }
+    return count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint ClearGrowBuffer ( GrowBuffer_t *gb )
+{
+    DASSERT(gb);
+    gb->ptr = gb->buf;
+    if (gb->ptr)
+	*gb->ptr = 0;
+    gb->used = 0;
+    return gb->size;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint PurgeGrowBuffer ( GrowBuffer_t *gb )
+{
+    if (!gb->used)
+	return ClearGrowBuffer(gb);
+
+    if ( gb->ptr > gb->buf )
+    {
+	memmove(gb->buf,gb->ptr,gb->used);
+	gb->ptr = gb->buf;
+    }
+    return gb->size - gb->used;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint DropGrowBuffer
+(
+    // returns the number of dropped bytes
+
+    GrowBuffer_t	*gb,		// valid grow-buffer object
+    uint		size		// number of bytes to drop
+)
+{
+ #if HAVE_DASSERT
+    DASSERT(gb);
+    if (gb->buf)
+    {
+	DASSERT_MSG( gb->used < gb->size, "%d/%d\n",gb->used,gb->size);
+	DASSERT( gb->ptr >= gb->buf );
+	DASSERT( gb->ptr + gb->used <= gb->buf + gb->size );
+    }
+    else
+    {
+	DASSERT(!gb->ptr);
+	DASSERT(!gb->size);
+	DASSERT(!gb->used);
+    }
+ #endif
+
+    if (!gb->buf)
+	return 0;
+
+    if ( size >= gb->used )
+    {
+	size = gb->used;
+	gb->used = 0;
+	gb->ptr = gb->buf;
+	*gb->ptr = 0;
+	return size;
+    }
+
+    gb->ptr  += size;
+    gb->used -= size;
+    return size;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void LogGrowBuffer
+(
+    FILE		*f,		// output file
+    int			indent,		// indention
+    const GrowBuffer_t	*gb,		// valid grow-buffer
+    ccp			format,		// format string for vfprintf()
+    ...					// arguments for 'vfprintf(format,...)'
+)
+{
+    DASSERT(f);
+    DASSERT(gb);
+    indent = NormalizeIndent(indent);
+
+    fprintf(f,"%*sTB: size=%s/%s/%s  idx=%s  grow=%s/%s  disabled=%d",
+	indent,"",
+	PrintSize1024(0,0,gb->used,DC_SFORM_TINY|DC_SFORM_ALIGN),
+	PrintSize1024(0,0,gb->max_used,DC_SFORM_TINY|DC_SFORM_ALIGN),
+	PrintSize1024(0,0,gb->size,DC_SFORM_TINY|DC_SFORM_ALIGN),
+	PrintNumberU6(0,0,gb->ptr-gb->buf,true),
+	PrintSize1024(0,0,gb->grow_size,DC_SFORM_TINY|DC_SFORM_ALIGN),
+	PrintSize1024(0,0,gb->max_size,DC_SFORM_TINY|DC_SFORM_ALIGN),
+	gb->disabled );
+
+    if (format)
+    {
+	fputs(" : ",f);
+	va_list arg;
+	va_start(arg,format);
+	vfprintf(f,format,arg);
+	va_end(arg);
+    }
+
+    fputc('\n',f);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+#ifndef __APPLE__
+
+FILE * OpenFileGrowBuffer
+(
+    // returns a FILE opened by fmemopen() => call CloseFileGrowBuffer()
+
+    GrowBuffer_t	*gb,		// valid grow-buffer object
+    uint		size		// needed size
+)
+{
+    DASSERT(gb);
+    uint space = PurgeGrowBuffer(gb);
+    if ( space < size )
+	space = PrepareGrowBuffer(gb,size,true);
+    return fmemopen( gb->ptr + gb->used, space, "w" );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int CloseFileGrowBuffer
+(
+    // returns the number of wirtten bytes, or -1 on error
+    GrowBuffer_t	*gb,		// valid grow-buffer object
+    FILE		*f		// FILE returned by OpenFileGrowBuffer()
+)
+{
+    DASSERT(gb);
+    if (!f)
+	return -1;
+
+    const int stat = ftell(f);
+    if ( stat >= 0 && gb->ptr + gb->used + stat <= gb->buf + gb->size )
+	gb->used += stat;
+
+    fclose(f);
+    return stat;
+}
+
+#endif // !__APPLE__
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+#define GROW_BUFFER_CHUNK_SIZE 3*1024 // multiple of 3 because of BASE64 (3->4)
+
+void SaveCurrentStateGrowBuffer
+(
+    FILE		*f,		// output file
+    ccp			name_prefix,	// NULL or prefix of name
+    uint		tab_pos,	// tab pos of '='
+    const GrowBuffer_t	*gb		// valid grow-buffer
+)
+{
+    DASSERT(f);
+    DASSERT(gb);
+
+    if (!name_prefix)
+	name_prefix = EmptyString;
+
+    const int base = 8*tab_pos + 7 - strlen(name_prefix);
+
+    fprintf(f,
+	"%s" "disabled%.*s= %u\n"
+	"%s" "used%.*s= %u\n"
+	"%s" "size%.*s= %u\n"
+	"%s" "grow-size%.*s= %u\n"
+	"%s" "max-size%.*s= %u\n"
+	,name_prefix, (base-8)/8, Tabs20, gb->disabled
+	,name_prefix, (base-4)/8, Tabs20, gb->used
+	,name_prefix, (base-4)/8, Tabs20, gb->size
+	,name_prefix, (base-9)/8, Tabs20, gb->grow_size
+	,name_prefix, (base-8)/8, Tabs20, gb->max_size
+	);
+
+    char buf[4*GROW_BUFFER_CHUNK_SIZE/3+10], name[20];
+    uint start,i;
+
+    for ( start = i = 0; start < gb->used; i++ )
+    {
+	uint size = gb->used - start;
+	if ( size > GROW_BUFFER_CHUNK_SIZE )
+	    size = GROW_BUFFER_CHUNK_SIZE;
+
+	const uint len = snprintf(name,sizeof(name),"data-%u",i);
+	EncodeBase64(buf,sizeof(buf),(ccp)gb->ptr+start,size,0,true,0,0);
+	fprintf(f, "%s%s%.*s= %s\n",
+		name_prefix, name, (base-len)/8, Tabs20, buf );
+
+	start += size;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void RestoreStateGrowBuffer
+(
+    GrowBuffer_t	*gb,		// valid grow-buffer
+    ccp			name_prefix,	// NULL or prefix of name
+    RestoreState_t	*rs		// info data, can be modified (cleaned after call)
+)
+{
+    DASSERT(gb);
+    DASSERT(rs);
+
+    ResetGrowBuffer(gb);
+
+    if (!name_prefix)
+	name_prefix = EmptyString;
+
+    char name[200]; // name buf
+    snprintf(name,sizeof(name),"%sused",name_prefix);
+    int size = GetParamFieldUINT(rs,name,0);
+    snprintf(name,sizeof(name),"%sdisabled",name_prefix);
+    gb->disabled = GetParamFieldINT(rs,name,gb->disabled) > 0;
+
+    if ( size > 0 )
+    {
+	char buf[2*GROW_BUFFER_CHUNK_SIZE];
+
+	PrepareGrowBuffer(gb,size,true);
+	uint index = 0;
+	while ( size > 0 )
+	{
+	    snprintf(name,sizeof(name),"%sdata-%u",name_prefix,index++);
+	    int res = GetParamFieldBUF(buf,sizeof(buf),rs,name,ENCODE_BASE64URL,0);
+	    if ( res < 0 )
+		break;
+
+	    InsertGrowBuffer(gb,buf,res);
+	    size -= res;
+	}
+
+     #ifdef TEST0
+	if ( gb->used > 10000 )
+	{
+	    fprintf(stderr,"--- ResetGrowBuffer() size = %d\n",gb->used);
+	    fwrite(gb->ptr,1,gb->used,stderr);
+	    fprintf(stderr,"--- ResetGrowBuffer() size = %d\n",gb->used);
+	}
+     #endif
+    }
+
+
+    //--- known as 'unused'
+
+    if ( rs->log_mode & RSL_UNUSED_NAMES )
+    {
+	static ccp name_tab[] =
+	{
+	   "size",
+	   "grow-size",
+	   "max-size",
+	    0
+	};
+
+	ccp *np;
+	for ( np = name_tab; *np; np++ )
+	{
+	    StringCat2S(name,sizeof(name),name_prefix,*np);
+	    GetParamField(rs,name);
+	}
+    }
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    misc			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int opt_new = 0;
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint CreateUniqueId ( int range )
+{
+    static uint unique_id = 1;
+    const uint ret = unique_id;
+    if ( range > 0 )
+	unique_id += range;
+    return ret;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void Sha1Hex2Bin ( sha1_hash_t bin, ccp src, ccp end )
+{
+    DASSERT(bin);
+    DASSERT(src);
+
+    uint i;
+    for ( i = 0; i < 20; i++ )
+	bin[i] = ScanDigits(&src,end,16,2,0);
+}
+
+//-----------------------------------------------------------------------------
+
+void Sha1Bin2Hex ( sha1_hex_t hex, cvp bin )
+{
+    DASSERT(hex);
+    DASSERT(bin);
+
+    snprintf(hex,sizeof(sha1_hex_t),"%08x%08x%08x%08x%08x",
+	be32(bin), be32(bin+4), be32(bin+8), be32(bin+12), be32(bin+16) );
+}
+
+//-----------------------------------------------------------------------------
+
+ccp GetSha1Hex ( cvp bin )
+{
+    DASSERT(bin);
+
+    char *hex = GetCircBuf(sizeof(sha1_hex_t));
+    Sha1Bin2Hex(hex,bin);
+    return hex;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////				END			///////////////
+///////////////////////////////////////////////////////////////////////////////
+