SZS v2.27a

1 files changed, 1631 insertions, 19 deletions

diff --git a/project/dclib/dclib-basics.c b/project/dclib/dclib-basics.c
index fdea8fc..964b5d2 100644
--- a/project/dclib/dclib-basics.c
+++ b/project/dclib/dclib-basics.c
@@ -14,16 +14,16 @@
  *                                                                         *
  ***************************************************************************
  *                                                                         *
- *        Copyright (c) 2012-2021 by Dirk Clemens <wiimm@wiimm.de>         *
+ *        Copyright (c) 2012-2022 by Dirk Clemens <wiimm@wiimm.de>         *
  *                                                                         *
  ***************************************************************************
  *                                                                         *
- *   This program is free software; you can redistribute it and/or modify  *
+ *   This library 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,       *
+ *   This library 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.                          *
@@ -39,6 +39,7 @@
 #include <time.h>
 #include <stdio.h>
 #include <stddef.h>
+#include <signal.h>
 #include <errno.h>
 #include <sys/time.h>
 #include <fcntl.h>
@@ -118,6 +119,14 @@ const char ThinLine300_3[901] = // 300 * '─' (U+2500) + NULL
 	"──────────────────────────────────────────────────"
 	"──────────────────────────────────────────────────";
 
+const char DoubleLine300_3[901] = // 300 * '═' (U+2550) + NULL
+	"══════════════════════════════════════════════════"
+	"══════════════════════════════════════════════════"
+	"══════════════════════════════════════════════════"
+	"══════════════════════════════════════════════════"
+	"══════════════════════════════════════════════════"
+	"══════════════════════════════════════════════════";
+
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -301,9 +310,9 @@ int GetProgramPath
 #ifdef __APPLE__
 
     //--- read apple path of executable
-    
+
     extern int _NSGetExecutablePath( char* buf, uint32_t * bufsize );
-     
+
     uint32_t size = sizeof(path);
     if (!_NSGetExecutablePath(path,&size))
     {
@@ -312,7 +321,7 @@ int GetProgramPath
 	return StringCopyS(buf,buf_size,path) - buf;
     }
 
-#else // !__APPLE__  
+#else // !__APPLE__
 
     //--- read files of /proc/...
 
@@ -332,7 +341,7 @@ int GetProgramPath
 		return StringCopyS(buf,buf_size,path) - buf;
     }
 
-#endif // !__APPLE__  
+#endif // !__APPLE__
 
 
     //--- analyze argv0
@@ -433,8 +442,8 @@ 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);
+    DASSERT(buf);
+    DASSERT(buf<buf_end);
     buf_end--;
     if ( max_copy >= 0 && buf + max_copy < buf_end )
 	buf_end = buf + max_copy;
@@ -536,6 +545,54 @@ char * StringCat3A ( ccp src1, ccp src2, ccp src3 )
 
 ///////////////////////////////////////////////////////////////////////////////
 
+ccp StringCenterE 
+(
+    char		* buf,		// result buffer; if NULL, circ-buf is used
+    ccp			buf_end,	// end of 'buf', NULL if buf==NULL
+    ccp			src,		// source string
+    int			width		// wanted width
+)
+{
+    if (!src)
+	src = "";
+    int n2 = strlen(src);
+    if ( n2 >= width )
+    {
+	if (!buf)
+	    return CopyCircBuf(src,n2+1);
+
+	StringCopyEM(buf,buf_end,src,n2);
+	return buf;
+    }
+
+    n2 = width - n2;
+    int n1 = n2/2;
+    n2 -= n1;
+
+    if (!buf)
+    {
+	buf = GetCircBuf(width+1);
+	buf_end = buf + width;
+    }    
+    else
+	buf_end--;
+
+    char *dest = buf;
+    while ( n1-- > 0 && dest < buf_end )
+	*dest++ = ' ';
+
+    while ( *src && dest < buf_end )
+	*dest++ = *src++;
+	
+    while ( n2-- > 0 && dest < buf_end )
+	*dest++ = ' ';
+
+    *dest = 0;
+    return buf;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
 char * StringLowerE ( char * buf, ccp buf_end, ccp src )
 {
     // RESULT: end of copied string pointing to NULL
@@ -658,6 +715,166 @@ char * MemUpperS ( char * buf, size_t buf_size, mem_t src )
 
 //
 ///////////////////////////////////////////////////////////////////////////////
+///////////////			Signals & Sleep			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+volatile int SIGINT_level	= 0;
+volatile int SIGHUP_level	= 0;
+volatile int SIGALRM_level	= 0;
+volatile int SIGCHLD_level	= 0;
+volatile int SIGPIPE_level	= 0;
+volatile int SIGUSR1_level	= 0;
+volatile int SIGUSR2_level	= 0;
+
+// no timout for SIGPIPE
+u_sec_t SIGINT_sec		= 0;
+u_sec_t SIGHUP_sec		= 0;
+u_sec_t SIGALRM_sec		= 0;
+u_sec_t SIGCHLD_sec		= 0;
+u_sec_t SIGUSR1_sec		= 0;
+u_sec_t SIGUSR2_sec		= 0;
+
+int  SIGINT_level_max		= 3;
+bool ignore_SIGINT		= false;
+bool ignore_SIGHUP		= false;
+
+int  redirect_signal_pid	= 0;
+LogFile_t log_signal_file	= {0};
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void inc_sig_handler ( volatile int *level, volatile uint *sec )
+{
+    DASSERT(level);
+    DASSERT(sec);
+
+    const uint now = GetTimeSec(false);
+
+    if ( now - *sec > 30 )
+	*level = 0;
+    *sec = now;
+    (*level)++;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void sig_handler ( int signum )
+{
+    fflush(stdout);
+    static bool had_sigpipe = false;
+
+    if (redirect_signal_pid)
+    {
+	kill(redirect_signal_pid,signum);
+	return;
+    }
+
+    switch(signum)
+    {
+      case SIGINT:
+	if (ignore_SIGINT)
+	    break;
+	// fall through
+
+      case SIGTERM:
+	inc_sig_handler(&SIGINT_level,&SIGINT_sec);
+	ccp signame = signum == SIGINT ? "INT" : "TERM";
+	if ( SIGINT_level > 1 )
+	    PrintLogFile(&log_signal_file,"#SIGNAL %s: level set to %d/%d\n",
+			signame, SIGINT_level, SIGINT_level_max );
+	if ( SIGINT_level >= SIGINT_level_max )
+	{
+	    PrintLogFile(&log_signal_file,"#SIGNAL %s: TERMINATE IMMEDIATELY!\n",signame);
+	    exit(0);
+	}
+	break;
+
+      case SIGHUP:
+	if (!ignore_SIGHUP)
+	{
+	    inc_sig_handler(&SIGHUP_level,&SIGHUP_sec);
+	    PrintLogFile(&log_signal_file,"#SIGNAL HUP: level set to %d\n",SIGHUP_level);
+	}
+	break;
+
+      case SIGCHLD:
+	SIGCHLD_level++;
+	PrintLogFile(&log_signal_file,"#SIGNAL CHLD: level set to %d\n",SIGCHLD_level);
+	break;
+
+      case SIGALRM:
+	inc_sig_handler(&SIGALRM_level,&SIGALRM_sec);
+	PrintLogFile(&log_signal_file,"#SIGNAL ALRM: level set to %d\n",SIGALRM_level);
+	break;
+
+      case SIGUSR1:
+	inc_sig_handler(&SIGUSR1_level,&SIGUSR1_sec);
+	PrintLogFile(&log_signal_file,"#SIGNAL USR1: level set to %d\n",SIGUSR1_level);
+	break;
+
+      case SIGUSR2:
+	inc_sig_handler(&SIGUSR2_level,&SIGUSR2_sec);
+	PrintLogFile(&log_signal_file,"#SIGNAL USR2: level set to %d\n",SIGUSR2_level);
+	break;
+
+      case SIGPIPE:
+	SIGPIPE_level++;
+	if (!had_sigpipe)
+	{
+	    PrintLogFile(&log_signal_file,"#SIGNAL SIGPIPE: %d\n",SIGPIPE_level);
+	    had_sigpipe = true;
+	}
+	if ( SIGPIPE_level >= 5 )
+	{
+	    PrintLogFile(&log_signal_file,"#SIGNAL SIGPIPE: TERMINATE IMMEDIATELY!\n");
+	    exit(0);
+	}
+	break;
+
+      default:
+	PrintLogFile(&log_signal_file,"#SIGNAL: %d\n",signum);
+    }
+    fflush(stderr);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void SetupSignalHandler ( int max_sigint_level, FILE *log_file )
+{
+    SIGINT_level_max = max_sigint_level;
+    if (log_file)
+    {
+	log_signal_file.log = log_file;
+	log_signal_file.flush = true;
+    }
+
+    static const int sigtab[] = { SIGTERM, SIGINT, SIGHUP, SIGALRM, SIGPIPE, -1 };
+    int i;
+    for ( i = 0; sigtab[i] >= 0; i++ )
+    {
+	struct sigaction sa;
+	memset(&sa,0,sizeof(sa));
+	sa.sa_handler = &sig_handler;
+	sigaction(sigtab[i],&sa,0);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int SleepNSec ( s_nsec_t nsec )
+{
+    if ( nsec > 0 )
+    {
+	struct timespec ts;
+	ts.tv_sec  = nsec / NSEC_PER_SEC;
+	ts.tv_nsec = nsec % NSEC_PER_SEC;
+	return nanosleep(&ts,0);
+    }
+    return 0;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
 ///////////////				PathCat*()		///////////////
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1165,6 +1382,67 @@ uint CountEqual ( cvp m1, cvp m2, uint size )
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
+char * SkipEscapes ( ccp str )
+{
+    if (str)
+    {
+	while ( *str == '\e' )
+	{
+	    str++;
+	    if ( *str == '[' )
+		str++;
+	    while ( *str > 0 && *str < 0x40 )
+		str++;
+	    if (*str)
+		str++;
+	}
+    }
+    return (char*)str;
+}
+
+//-----------------------------------------------------------------------------
+
+char * SkipEscapesE ( ccp str, ccp end )
+{
+    if (str)
+    {
+	if (!end)
+	    return SkipEscapes(str);
+
+	while ( str < end && *str == '\e' )
+	{
+	    str++;
+	    if ( str < end && *str == '[' )
+		str++;
+	    while ( str < end && *str > 0 && *str < 0x40 )
+		str++;
+	    if ( str < end )
+		str++;
+	}
+    }
+    return (char*)str;
+}
+
+//-----------------------------------------------------------------------------
+
+char * SkipEscapesS ( ccp str, int size )
+{
+    return size < 0 ? SkipEscapes(str) : SkipEscapesE(str,str+strlen(str));
+}
+
+//-----------------------------------------------------------------------------
+
+mem_t SkipEscapesM ( mem_t mem )
+{
+    mem_t res;
+    res.ptr = SkipEscapesE(mem.ptr,mem.ptr+mem.len);
+    res.len = mem.ptr + mem.len - res.ptr;
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
 int ReplaceToBuf
 (
     // returns -1 on error (buf to small) or the length of the resulting string.
@@ -1576,8 +1854,8 @@ char * PrintID
 ///////////////			    circ buf			///////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-static char circ_buf[CIRC_BUF_SIZE];
-static char *circ_ptr = circ_buf;
+static __thread char circ_buf[CIRC_BUF_SIZE];
+static __thread char *circ_ptr = 0;
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1597,6 +1875,8 @@ char * GetCircBuf
 				//  ==> ERROR0(ERR_OUT_OF_MEMORY)
 )
 {
+    if (!circ_ptr)
+	circ_ptr = circ_buf;
     DASSERT( circ_ptr >= circ_buf && circ_ptr <= circ_buf + sizeof(circ_buf) );
 
     buf_size = buf_size + 3 & ~3;
@@ -1725,6 +2005,8 @@ void ReleaseCircBuf
     uint    release_size	// number of bytes to give back from end
 )
 {
+    if (!circ_ptr)
+	circ_ptr = circ_buf;
     DASSERT( circ_ptr >= circ_buf && circ_ptr <= circ_buf + sizeof(circ_buf) );
 
     if ( end_buf == circ_ptr
@@ -1738,6 +2020,94 @@ void ReleaseCircBuf
 
 //
 ///////////////////////////////////////////////////////////////////////////////
+///////////////			PrintMode_t			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void SetupPrintMode ( PrintMode_t * pm )
+{
+    DASSERT(pm);
+
+    //-- stdout
+
+    if (!pm->fout)
+    {
+	pm->fout = stdout;
+	pm->cout = colout;
+    }
+    if (!pm->cout)
+	pm->cout = GetColorSet0();
+
+
+    //-- stderr
+
+    //if (!pm->ferr)	pm->ferr	= stderr;
+    if (!pm->cerr)
+	pm->cerr = GetColorSet0();
+
+
+    //-- stdlog
+
+    if (pm->flog)
+    {
+	if (!pm->clog)
+	    pm->clog = GetColorSet0();
+    }
+    else if (pm->ferr)
+    {
+	pm->flog = pm->ferr;
+	pm->clog = pm->cerr;
+    }
+    else
+    {
+	pm->flog = pm->fout;
+	pm->clog = pm->cout;
+    }
+
+
+    //-- misc
+
+    if (!pm->prefix)	pm->prefix	= EmptyString;
+    if (!pm->eol)	pm->eol		=	"\n";
+
+    pm->indent = NormalizeIndent(pm->indent);
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			get line by list		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+ccp GetLineByListHelper ( const int *list, ccp beg, ccp mid, ccp end, ccp line )
+{
+    DASSERT(list);
+    DASSERT(beg);
+    DASSERT(mid);
+    DASSERT(end);
+    DASSERT(line);
+
+    char buf[CIRC_BUF_MAX_ALLOC+20];
+    char *endbuf = buf + CIRC_BUF_MAX_ALLOC;
+    char *dest = buf;
+
+    for (;;)
+    {
+	int wd = *list++;
+	if ( wd < 0 )
+	    break;
+
+	dest = StringCopyE(dest,endbuf,beg);
+	beg = mid;
+	while ( wd-- > 0 )
+	    dest = StringCopyE(dest,endbuf,line);
+    }
+
+    dest = StringCopyE(dest,endbuf,end);
+    *dest++ = 0;
+    return dest <= endbuf ? CopyCircBuf(buf,dest-buf) : EmptyString;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
 ///////////////			struct FastBuf_t		///////////////
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -2343,6 +2713,473 @@ int ScanSplitArg
 
 //
 ///////////////////////////////////////////////////////////////////////////////
+///////////////			PointerList_t			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetPointerMgr ( PointerList_t *pl )
+{
+    if (pl)
+    {
+	FREE(pl->list);
+	InitializePointerMgr(pl,pl->grow);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void AddToPointerMgr ( PointerList_t *pl, const void *info )
+{
+    DASSERT(pl);
+    if (!info)
+	return;
+
+    // no duplicates!
+    for ( int i = 0; i < pl->used; i++ )
+	if ( pl->list[i] == info )
+	    return;
+
+    if ( pl->used == pl->size )
+    {
+	if ( pl->grow < 10 )
+	    pl->grow = 10;
+	pl->size += pl->size/2 + pl->grow;
+	pl->list = REALLOC ( pl->list, (pl->size+1) * sizeof(*pl->list) );
+    }
+    DASSERT( pl->used < pl->size );
+    void **dest = pl->list + pl->used++;
+    *dest++ = (void*)info;
+    *dest = 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void AddListToPointerMgr ( PointerList_t *pl, const void **list, int n_elem )
+{
+    if (list)
+    {
+	if ( n_elem < 0 )
+	    while (*list)
+		AddToPointerMgr(pl,*list++);
+	else
+	    while( --n_elem >= 0 )
+		AddToPointerMgr(pl,*list++);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ** DupPointerMgr ( PointerList_t *pl, bool reset )
+{
+    DASSERT(pl);
+    void **dest = MEMDUP( pl->list, (pl->used+1) * sizeof(*dest) );
+    if (reset)
+	ResetPointerMgr(pl);
+    return dest;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ** ReplacePointerMgr
+	( PointerList_t *pl, bool reset, const PointerList_t **old_list )
+{
+    FREE(old_list);
+    return DupPointerMgr(pl,reset);
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			ArgManager_t			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetArgManager ( ArgManager_t *am )
+{
+    static char *null_list[] = {0};
+
+    if (am)
+    {
+	if (am->size)
+	{
+	    uint i;
+	    for ( i = 0; i < am->argc; i++ )
+		FreeString(am->argv[i]);
+	    if ( am->argv != null_list )
+		FREE(am->argv);
+	}
+
+	const typeof(am->force_case) force_case = am->force_case;
+	memset(am,0,sizeof(*am));
+	am->force_case = force_case;
+	am->argv = null_list;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void SetupArgManager
+	( ArgManager_t *am, LowerUpper_t force_case, int argc, char ** argv, bool clone )
+{
+    DASSERT(am);
+    memset(am,0,sizeof(*am));
+    am->force_case = force_case;
+    if (clone)
+	CloneArgManager(am,argc,argv);
+    else
+	AttachArgManager(am,argc,argv);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void AttachArgManager ( ArgManager_t *am, int argc, char ** argv )
+{
+    DASSERT(am);
+    ResetArgManager(am);
+    am->argc = argc;
+    am->argv = argv;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void CloneArgManager ( ArgManager_t *am, int argc, char ** argv )
+{
+    DASSERT(am);
+    AttachArgManager(am,argc,argv);
+    PrepareEditArgManager(am,0);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void CopyArgManager ( ArgManager_t *dest, const ArgManager_t *src )
+{
+    DASSERT(dest);
+    if (!src)
+	ResetArgManager(dest);
+    else if( dest != src )
+	AttachArgManager(dest,src->argc,src->argv);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void MoveArgManager ( ArgManager_t *dest, ArgManager_t *src )
+{
+    DASSERT(dest);
+    ResetArgManager(dest);
+    if (src)
+    {
+	dest->argv = src->argv;
+	dest->argc = src->argc;
+	dest->size = src->size;
+	memset(src,0,sizeof(*src));
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void PrepareEditArgManager ( ArgManager_t *am, int needed_space )
+{
+    DASSERT(am);
+
+    uint new_size = am->argc;
+    if ( needed_space > 0 )
+	new_size += needed_space;
+    new_size = GetGoodAllocSize2(new_size+(new_size>>4)+10,sizeof(*am->argv));
+    PRINT("PrepareEditArgManager(,%d) n=%d, size: %d -> %d\n",
+		needed_space, am->argc, am->size, new_size );
+
+    if (am->size)
+	am->argv = REALLOC(am->argv,sizeof(*am->argv)*new_size);
+    else
+    {
+	char **old = am->argv;
+	am->argv = MALLOC(sizeof(*am->argv)*new_size);
+
+	uint i;
+	for ( i = 0; i < am->argc; i++ )
+	    am->argv[i] = old[i] ? STRDUP(old[i]) : 0;
+    }
+    am->size = new_size - 1;
+    DASSERT( am->argc <= am->size );
+    am->argv[am->argc] = 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint AppendArgManager ( ArgManager_t *am, ccp arg1, ccp arg2, bool move_arg )
+{
+    DASSERT(am);
+    PRINT("AppendArgManager(,%s,%s,%d)\n",arg1,arg2,move_arg);
+    return InsertArgManager(am,am->argc,arg1,arg2,move_arg);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static char ** insert_arg_manager
+	( ArgManager_t *am, char **dest, ccp p_arg, bool move_arg )
+{
+    DASSERT(am);
+    if (p_arg)
+    {
+	char *arg = (char*)p_arg;
+	if (!move_arg)
+	    arg = STRDUP(arg);
+
+	if ( am->force_case == LOUP_LOWER || am->force_case == LOUP_UPPER )
+	{
+	    ccp end = arg + strlen(arg) + 1;
+	    if (am->force_case == LOUP_LOWER)
+		StringLowerE(arg,end,arg);
+	    else
+		StringUpperE(arg,end,arg);
+	}
+	*dest++ = arg;
+    }
+    return dest;
+}
+
+//-----------------------------------------------------------------------------
+
+uint InsertArgManager
+	( ArgManager_t *am, int pos, ccp arg1, ccp arg2, bool move_arg )
+{
+    PRINT("InsertArgManager(,%d,%s,%s,%d)\n",pos,arg1,arg2,move_arg);
+
+    pos = CheckIndex1(am->argc,pos);
+    const int n = (arg1!=0) + (arg2!=0);
+    if (n)
+    {
+	PrepareEditArgManager(am,n);
+	DASSERT( pos>=0 && pos <= am->argc );
+	char **dest = am->argv + pos;
+	if ( pos < am->argc )
+	    memmove( dest+n, dest, (u8*)(am->argv+am->argc) - (u8*)dest );
+
+	dest = insert_arg_manager(am,dest,arg1,move_arg);
+	dest = insert_arg_manager(am,dest,arg2,move_arg);
+
+	am->argc += n;
+	am->argv[am->argc] = 0;
+    }
+    return pos+n;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint ReplaceArgManager
+	( ArgManager_t *am, int pos, ccp arg1, ccp arg2, bool move_arg )
+{
+    PRINT("ReplaceArgManager(,%d,%s,%s,%d)\n",pos,arg1,arg2,move_arg);
+
+    pos = CheckIndex1(am->argc,pos);
+    const int n = (arg1!=0) + (arg2!=0);
+    if (n)
+    {
+	PrepareEditArgManager(am,n);
+	DASSERT( pos>=0 && pos <= am->argc );
+	char **dest = am->argv + pos;
+	if (arg1)
+	{
+	    if ( pos++ < am->argc )
+		FreeString(*dest);
+	    *dest++ = move_arg ? (char*)arg1 : STRDUP(arg1);
+	}
+	if (arg2)
+	{
+	    if ( pos++ < am->argc )
+		FreeString(*dest);
+	    *dest++ = move_arg ? (char*)arg2 : STRDUP(arg2);
+	}
+	if ( pos > am->argc )
+	{
+	    am->argc = pos;
+	    am->argv[am->argc] = 0;
+	}
+    }
+    return pos;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint RemoveArgManager ( ArgManager_t *am, int pos, int count )
+{
+    DASSERT(am);
+
+ #if HAVE_PRINT
+    const int oldpos = pos;
+ #endif
+    const int n = CheckIndexC(am->argc,&pos,count);
+    PRINT("RemoveArgManager(,%d,%d) : remove n=%d: %d..%d\n",
+		oldpos, count, n, pos, pos+n );
+
+    DASSERT( pos >= 0 && pos <= am->argc );
+    DASSERT( n >= 0 && pos+n <= am->argc );
+
+    if ( n > 0 )
+    {
+	PrepareEditArgManager(am,0);
+	char **dest = am->argv + pos;
+
+	uint i;
+	for ( i = 0; i <n; i++ )
+	    FreeString(dest[i]);
+	am->argc -= n;
+	memmove( dest, dest+n, (u8*)(am->argv+am->argc) - (u8*)dest );
+	am->argv[am->argc] = 0;
+    }
+    return pos;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint ScanSimpleArgManager ( ArgManager_t *am, ccp src )
+{
+    uint count = 0;
+    if (src)
+    {
+	for(;;)
+	{
+	    while ( *src == ' ' || *src == '\t' )
+		src++;
+	    if (!*src)
+		break;
+
+	    ccp start = src;
+	    while ( *src && *src != ' ' && *src != '\t' )
+		src++;
+
+	    ccp arg = MEMDUP(start,src-start);
+	    AppendArgManager(am,arg,0,true);
+	}
+    }
+    return count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint ScanQuotedArgManager ( ArgManager_t *am, ccp src, bool is_utf8 )
+{
+    uint count = 0;
+    if (src)
+    {
+	char buf[10000], *bufend = buf + sizeof(buf) - 2;
+
+	for(;;)
+	{
+	    while ( *src == ' ' || *src == '\t' )
+		src++;
+	    if (!*src)
+		break;
+
+	    char *dest = buf;
+	    while ( dest < bufend )
+	    {
+		if ( *src == '\'' || *src == '\"' )
+		{
+		    uint scanned;
+		    dest += ScanEscapedString(dest,bufend-dest,src,-1,is_utf8,-1,&scanned);
+		    src += scanned;
+		}
+		else
+		{
+		    while ( dest < bufend && *src && *src != ' ' && *src != '\t'
+				&& *src != '\'' && *src != '\"' )
+		    {
+			if ( *src == '\\' && src[1] )
+			    src++;
+			*dest++ = *src++;
+		    }
+		}
+		if ( !*src || *src == ' ' || *src == '\t' )
+		    break;
+	    }
+	    ccp arg = MEMDUP(buf,dest-buf);
+	    AppendArgManager(am,arg,0,true);
+	}
+    }
+    return count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool CheckFilterArgManager ( const ArgManager_t *filter, ccp name )
+{
+    if ( !name || !*name )
+	return false;
+
+    if (!filter->argc)
+	return true;
+
+    char buf[200];
+    if ( filter->force_case == LOUP_LOWER )
+    {
+	StringLowerS(buf,sizeof(buf),name);
+	name = buf;
+    }
+    else if ( filter->force_case == LOUP_UPPER )
+    {
+	StringUpperS(buf,sizeof(buf),name);
+	name = buf;
+    }
+
+    bool fallback_status = true;
+    for ( int i = 0; i < filter->argc; i++ )
+    {
+	ccp arg = filter->argv[i];
+	const bool status = *arg != '/';
+	if (status)
+	    fallback_status = false;
+	else
+	    arg++;
+
+	const uint len = strlen(arg);
+	if ( *arg == '=' )
+	{
+	    if ( !strcmp(arg+1,name) )
+		return status;
+	}
+	else if ( *arg == '^' )
+	{
+	    if ( len > 1 && !strncmp(arg+1,name,len-1) )
+		return status;
+	}
+	else
+	    if ( len && strstr(name,arg) )
+		return status;
+    }
+
+    return fallback_status;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void DumpArgManager ( FILE *f, int indent, const ArgManager_t *am, ccp title )
+{
+    if ( !f || !am )
+	return;
+
+    indent = NormalizeIndent(indent);
+    if (title)
+	fprintf(f,"%*s" "ArgManager[%s]: N=%d",
+		indent,"", title, am->argc );
+    else
+	fprintf(f,"%*s" "ArgManager: N=%d", indent,"", am->argc );
+
+    if (am->size)
+	fprintf(f,"/%u\n",am->size);
+    else
+	fputc('\n',f);
+
+    if (am->argc)
+    {
+	char buf[10];
+	int fw = snprintf(buf,sizeof(buf),"%u",am->argc-1)+2;
+
+	uint i;
+	for ( i = 0; i < am->argc; i++ )
+	    fprintf(f,"%*s%*u: |%s|\n", indent,"", fw,i, am->argv[i] );
+    }
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
 ///////////////			struct mem_t			///////////////
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -2487,16 +3324,80 @@ mem_t MemCat3A ( const mem_t m1, const mem_t m2, const mem_t m3 )
     return res;
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// UTF8 support
+
+mem_t MidMem8 ( const mem_t src, int begin, int count )
+{
+    if ( !src.ptr || !src.len )
+	return src;
+
+    ccp src_end = src.ptr + src.len;
+    const int u8len = ScanUTF8LengthE(src.ptr,src_end);
+    begin = CheckIndex1(u8len,begin);
+    if ( count < 0 )
+    {
+	count  = -count;
+	begin -= count;
+	if ( begin < 0 )
+	{
+	    count += begin;
+	    begin  = 0;
+	}
+    }
+
+    mem_t res;
+    res.ptr = SkipUTF8CharE(src.ptr,src_end,begin);
+    const int max = u8len - begin;
+    res.len = SkipUTF8CharE( res.ptr, src_end, count < max ? count : max ) - res.ptr;
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+mem_t ExtractMem8 ( const mem_t src, int begin, int end )
+{
+    if ( !src.ptr || !src.len )
+	return src;
+
+    ccp src_end = src.ptr + src.len;
+    const int u8len = ScanUTF8LengthE(src.ptr,src_end);
+    const int count = CheckIndex2(u8len,&begin,&end);
+
+    mem_t res;
+    res.ptr = SkipUTF8CharE( src.ptr, src_end, begin );
+    res.len = SkipUTF8CharE( res.ptr, src_end, count ) - res.ptr;
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+mem_t ExtractEndMem8 ( const mem_t src, int begin, int end )
+{
+    if ( !src.ptr || !src.len )
+	return src;
+
+    ccp src_end = src.ptr + src.len;
+    const int u8len = ScanUTF8LengthE(src.ptr,src_end);
+    const int count = CheckIndex2End(u8len,&begin,&end);
+
+    mem_t res;
+    res.ptr = SkipUTF8CharE( src.ptr, src_end, begin );
+    res.len = SkipUTF8CharE( res.ptr, src_end, count ) - res.ptr;
+    return res;
+}
+
 //
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////			struct exmem_t			///////////////
+///////////////////////////////////////////////////////////////////////////////
 
 exmem_t EmptyExMem = {{EmptyString,0},0,false,false,false,false};
 exmem_t NullExMem  = {{0,0},0,false,false,false,false};
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void FreeExMem ( const exmem_t *em )
+void ResetExMem ( const exmem_t *em )
 {
     if (em)
     {
@@ -2508,6 +3409,23 @@ void FreeExMem ( const exmem_t *em )
 
 ///////////////////////////////////////////////////////////////////////////////
 
+void FreeExMem ( const exmem_t *em )
+{
+    if (em)
+    {
+	if (em->is_alloced)
+	{
+	    exmem_t *em2 = (exmem_t*)em;
+	    FreeString(em2->data.ptr);
+	    em2->data.ptr = 0;
+	    em2->data.len = 0;
+	    em2->is_alloced = false;
+	}
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 void FreeExMemCM ( const exmem_t *em, CopyMode_t copy_mode )
 {
     if ( em && copy_mode == CPM_MOVE )
@@ -2604,7 +3522,41 @@ void AssignExMem ( exmem_t *dest, const exmem_t *source, CopyMode_t copy_mode )
 
 ///////////////////////////////////////////////////////////////////////////////
 
-exmem_t CopyExMemS ( ccp string, int slen, CopyMode_t copy_mode )
+void AssignExMemS ( exmem_t *dest, cvp source, int slen, CopyMode_t copy_mode )
+{
+    if (dest)
+    {
+	ccp free_str = dest->is_alloced ? dest->data.ptr : 0;
+	const bool dest_key_alloced = dest->is_key_alloced;
+	memset(dest,0,sizeof(*dest));
+	dest->is_key_alloced = dest_key_alloced;
+
+	if (source)
+	{
+	    dest->data.len = slen < 0 ? strlen(source) : slen;
+	    switch (copy_mode)
+	    {
+		case CPM_COPY:
+		    dest->data.ptr	= MEMDUP(source,dest->data.len);
+		    dest->is_alloced	= true;
+		    break;
+
+		case CPM_MOVE:
+		    dest->is_alloced	= true;
+		    // fall through
+		case CPM_LINK:
+		    dest->data.ptr	= source;
+		    break;
+	    }
+	}
+	FreeString(free_str);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#if 0 // [[obsolete]] since 2021-11
+exmem_t CopyExMemS ( cvp string, int slen, CopyMode_t copy_mode )
 {
     exmem_t em = {{0}};
 
@@ -2630,6 +3582,7 @@ exmem_t CopyExMemS ( ccp string, int slen, CopyMode_t copy_mode )
 
     return  em;
 }
+#endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -5038,10 +5991,10 @@ int ScanKeywordOffOn
 const KeywordTab_t KeyTab_OFF_AUTO_ON[] =
 {
   { OFFON_OFF,		"OFF",		"-1",	0 },
-  { OFFON_OFF,		"DISABLED",	0,	0 },
+  { OFFON_OFF,		"DISABLED",	"NO",	0 },
   { OFFON_AUTO,		"AUTO",		"0",	0 },
   { OFFON_ON,		"ON",		"1",	0 },
-  { OFFON_ON,		"ENABLED",	0,	0 },
+  { OFFON_ON,		"ENABLED",	"YES",	0 },
   { OFFON_FORCE,	"FORCE",	"2",	0 },
   { 0,0,0,0 }
 };
@@ -6589,16 +7542,42 @@ exmem_key_t * AppendEML ( exmem_list_t * eml, ccp key, CopyMode_t cm_key,
 
 ///////////////////////////////////////////////////////////////////////////////
 
-bool RemoveEML ( exmem_list_t * eml, ccp key )
+bool RemoveByIndexEML ( exmem_list_t * eml, int index )
+{
+    if ( index < 0 )
+	index += eml->used;
+    if ( index >= 0 && index < eml->used )
+    {
+	DASSERT( eml->used > 0 );
+	eml->used--;
+	exmem_key_t * dest = eml->list + index;
+	if (dest->data.is_key_alloced)
+	    FreeString(dest->key);
+	FreeExMem(&dest->data);
+	if (eml->used)
+	    memmove(dest,dest+1,(eml->used-index)*sizeof(*dest));
+	else
+	    eml->is_unsorted = false;
+	return true;
+    }
+    return false;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool RemoveByKeyEML ( exmem_list_t * eml, ccp key )
 {
     bool found;
-    uint idx = FindHelperEML(eml,key,&found);
+    const uint index = FindHelperEML(eml,key,&found);
+ #if 1
+    return found && RemoveByIndexEML(eml,index);
+ #else // [[obsolete]] 2021-11
     if (found)
     {
 	DASSERT(eml->used);
 	eml->used--;
-	DASSERT( idx <= eml->used );
-	exmem_key_t * dest = eml->list + idx;
+	DASSERT( index <= eml->used );
+	exmem_key_t * dest = eml->list + index;
 	if (dest->data.is_key_alloced)
 	    FreeString(dest->key);
 	FreeExMem(&dest->data);
@@ -6608,6 +7587,7 @@ bool RemoveEML ( exmem_list_t * eml, ccp key )
 	    eml->is_unsorted = false;
     }
     return found;
+ #endif
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -6849,6 +7829,560 @@ void AddStandardSymbolsEML ( exmem_list_t * eml, bool overwrite )
 
 //
 ///////////////////////////////////////////////////////////////////////////////
+///////////////			MultiColumn			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetMultiColumn ( MultiColumn_t *mc )
+{
+    if (mc)
+    {
+	ResetEML(&mc->list);
+	memset(mc,0,sizeof(*mc));
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+exmem_key_t * PutLineMC
+	( MultiColumn_t *mc, uint opt, ccp key, ccp value, CopyMode_t cm_value )
+{
+    DASSERT(mc);
+    DASSERT(key);
+    DASSERT(value);
+
+    exmem_t data = ExMemByString(value);
+    exmem_key_t *res = AppendEML( &mc->list, key, CPM_LINK, &data, cm_value );
+    res->data.attrib = opt;
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+exmem_key_t * PrintLineMC
+	( MultiColumn_t *mc, uint opt, ccp key, ccp format, ... )
+{
+    char buf[1000];
+    va_list arg;
+    va_start(arg,format);
+    vsnprintf(buf,sizeof(buf),format,arg);
+    va_end(arg);
+    return PutLineMC(mc,opt,key,buf,CPM_COPY);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// [[mc_len_t]]
+
+typedef struct mc_len_t
+{
+    int key;	// key length
+    int val;	// val length
+}
+mc_len_t;
+
+//-----------------------------------------------------------------------------
+// [[mc_param_t]]
+
+#define MULTI_COLUMN_MAX_COLS 100
+
+typedef struct mc_param_t
+{
+    FILE	*f;		// output file
+    const ColorSet_t
+		*colset;	// color set for the frame
+    int		debug;		// debug level: 0..2
+
+    int		frame_mode;	// 0:ASCII, 1:single line, 2:double line
+    ccp		prefix;		// line prefix
+    int		prefix_fw;	// field width of 'prefix'
+    int		indent;		// indention excluding prefix
+    ccp		sep;		// separator for frame_mode 0 and 1
+    int		sep_fw;		// field width of 'sep'
+    ccp		eol;		// end-of-line string
+    int		fw;		// total field width
+
+    ccp		head_key;	// header string for key column
+    int		head_key_fw;	// field width of 'head_key'
+    ccp		head_val;	// header string for value column
+    int		head_val_fw;	// field width of 'head_val'
+
+    int		row_size;	// additional size for a row
+    int		col_size;	// additional size for a column
+
+    int		n_rows;		// number of rows
+    int		n_cols;		// number of columns
+
+    mc_len_t	*len_list;	// list of estimatest lengths
+    mc_len_t	fw_col[MULTI_COLUMN_MAX_COLS];
+				// field width for each column
+}
+mc_param_t;
+
+//-----------------------------------------------------------------------------
+
+static void mc_print_sep ( const mc_param_t *p )
+{
+    fprintf(p->f,"%s%*s",p->prefix,p->indent,"");
+
+    const mc_len_t *fw = p->fw_col;
+    for ( int col = 0; col < p->n_cols; col++, fw++ )
+    {
+	if (col)
+	    fputs("-+-",p->f);
+	fprintf(p->f,"%.*s",fw->key+fw->val+p->sep_fw,Minus300);
+    }
+    fputs(p->eol,p->f);
+}
+
+//-----------------------------------------------------------------------------
+
+static void mc_print_line1 ( const mc_param_t *p, ccp template )
+{
+    fprintf(p->f,"%s%*s%s%.3s",
+		p->prefix, p->indent,"",
+		p->colset->heading, template );
+
+    const mc_len_t *fw = p->fw_col;
+    for ( int col = 0; col < p->n_cols; col++, fw++ )
+    {
+	if (col)
+	    fprintf(p->f,"%.3s",template+3);
+	fprintf(p->f,"%.*s", 3*(fw->key+fw->val+p->sep_fw+2), ThinLine300_3 );
+    }
+
+    fprintf(p->f,"%.3s%s%s",template+6,p->colset->reset,p->eol);
+}
+
+//-----------------------------------------------------------------------------
+
+static void mc_print_line2 ( const mc_param_t *p, ccp template )
+{
+    fprintf(p->f,"%s%*s%s%.3s",
+		p->prefix, p->indent,"",
+		p->colset->heading, template );
+
+    const mc_len_t *fw = p->fw_col;
+    for ( int col = 0; col < p->n_cols; col++, fw++ )
+    {
+	if (col)
+	    fprintf(p->f,"%.3s",template+6);
+	fprintf(p->f,"%.*s%.3s%.*s",
+		3*(fw->key+2), DoubleLine300_3,
+		template+3,
+		3*(fw->val+2), DoubleLine300_3 );
+    }
+
+    fprintf(p->f,"%.3s%s%s",template+9,p->colset->reset,p->eol);
+}
+
+//-----------------------------------------------------------------------------
+
+int PrintMultiColumn ( const MultiColumn_t *mc )
+{
+    const u_usec_t start_time = GetTimerUSec();
+    if ( !mc || !mc->list.used )
+	return -1;
+
+
+    //--- setup
+
+    mc_param_t p = {0};
+    p.f		= mc->f ? mc->f : stdout;
+    p.colset	= mc->colset ? mc->colset : GetColorSet0();
+    p.debug	= mc->debug;
+    p.indent	= NormalizeIndent(mc->indent);
+
+    p.prefix = mc->prefix;
+    if (p.prefix)
+	p.prefix_fw = ScanEUTF8Length(p.prefix);
+    else
+    {
+	p.prefix = EmptyString;
+	p.prefix_fw = 0;
+    }
+
+    p.sep	= mc->sep ? mc->sep : " ";
+    p.sep_fw	= ScanEUTF8Length(p.sep);
+    p.eol	= mc->eol ? mc->eol : "\n";
+    p.fw	= !mc->fw ? 79 : mc->fw > 10 ? mc->fw : 10;
+
+    if ( mc->print_header )
+    {
+	p.head_key = mc->head_key ? mc->head_key : "Name";
+	p.head_key_fw = strlene8(p.head_key);
+
+	p.head_val = mc->head_val ? mc->head_val : "Value";
+	p.head_val_fw = strlene8(p.head_val);
+    }
+    else
+    {
+	p.head_key = p.head_val = EmptyString;
+	// p.head_key_fw = p.head_val_fw = 0; // initial value
+    }
+
+    switch (mc->frame_mode)
+    {
+     case 0:
+	p.frame_mode	=  0;
+	p.row_size	= -3;
+	p.col_size	=  3 + p.sep_fw;
+	break;
+
+     case 1:
+	p.frame_mode	= 1;
+	p.row_size	= 1;
+	p.col_size	= 3 + p.sep_fw;
+	break;
+
+     default:
+	p.frame_mode	= 2;
+	p.row_size	= 1;
+	p.col_size	= 6;
+	break;
+    }
+
+    if ( p.debug > 1 )
+	fprintf(p.f,
+		"#> debug=%d, pre=%s, indent=%d, eol=%s, fw=%d,"
+		" print[Fhf]=%d%d%d, min_rows=%d, max_cols=%d%s",
+		p.debug, QuoteStringS(p.prefix,0,CHMD__MODERN),
+		p.indent, QuoteStringS(p.eol,0,CHMD__MODERN), p.fw,
+		p.frame_mode, mc->print_header, mc->print_footer,
+		mc->min_rows, mc->max_cols, p.eol );
+
+
+    //--- find min width
+
+    p.len_list = MALLOC( mc->list.used * sizeof(*p.len_list) );
+    mc_len_t *len_ptr = p.len_list;
+
+    int min_fw = INT_MAX;
+    const exmem_key_t *list_end = mc->list.list + mc->list.used;
+    for ( const exmem_key_t *ptr = mc->list.list; ptr < list_end; ptr++ )
+    {
+	len_ptr->key = strlene8(ptr->key);
+	len_ptr->val = strlene8(ptr->data.data.ptr);
+	const int len = len_ptr->key + len_ptr->val;
+	if ( min_fw > len )
+	     min_fw = len;
+	len_ptr++;
+    }
+    min_fw += p.col_size;
+
+    const int avail_chars = p.fw - p.prefix_fw - p.indent - p.row_size;
+    int max_cols = ( avail_chars + p.col_size - 1 ) / min_fw;
+    if ( max_cols > MULTI_COLUMN_MAX_COLS )
+	 max_cols = MULTI_COLUMN_MAX_COLS;
+
+    const int min_rows = mc->min_rows > 1 ? mc->min_rows : 1;
+    const int temp = ( mc->list.used + min_rows - 1 ) / min_rows + 1;
+    if ( temp > 0 && max_cols > temp )
+	max_cols = temp;
+
+    if ( p.debug > 1 )
+	fprintf(p.f,
+		"#> src-lines=%d, min-fw=%d, min-rows=%d, max-cols=%d/%d%s",
+		mc->list.used, min_fw,
+		min_rows, max_cols, MULTI_COLUMN_MAX_COLS, p.eol );
+
+
+    //--- evaluate number of columns
+
+    for ( p.n_cols = max_cols; p.n_cols > 0; p.n_cols-- )
+    {
+	memset(p.fw_col,0,sizeof(p.fw_col));
+	mc_len_t len = { p.head_key_fw, p.head_val_fw };
+
+	p.n_rows = ( mc->list.used - 1 ) / p.n_cols + 1;
+	p.n_cols = ( mc->list.used - 1 ) / p.n_rows + 1;
+	if ( p.debug > 1 )
+	    fprintf(p.f, "#> … try %2u columns and %3u rows, %3u cells total%s",
+			p.n_cols, p.n_rows, p.n_cols*p.n_rows, p.eol );
+
+	int idx, row, col, total_fw = 0;
+	len_ptr = p.len_list;
+	for ( idx = row = col = 0; idx < mc->list.used; idx++, len_ptr++ )
+	{
+	    if ( len.key < len_ptr->key )
+		 len.key = len_ptr->key;
+	    if ( len.val < len_ptr->val )
+		 len.val = len_ptr->val;
+
+	    if ( ++row >= p.n_rows )
+	    {
+		total_fw += len.key + len.val + p.col_size;
+		if ( total_fw > avail_chars )
+		    break;
+		p.fw_col[col] = len;
+
+		len.key = p.head_key_fw;
+		len.val = p.head_val_fw;
+		row = 0;
+		col++;
+	    }
+	}
+	if ( col < p.n_cols )
+	{
+	    p.fw_col[col] = len;
+	    total_fw += len.key + len.val + p.col_size;
+	}
+	if ( total_fw <= avail_chars )
+	    break;
+    }
+
+    if ( p.n_cols < 1 )
+    {
+	p.n_rows = mc->list.used;
+	p.n_cols = 1;
+    }
+
+    if ( p.debug > 1 )
+    {
+	fprintf(p.f,"#> cols=%d, rows=%d, fw", p.n_cols, p.n_rows );
+	int total = 0;
+	const mc_len_t *fw = p.fw_col;
+	for ( int col = 0; col < p.n_cols; col++, fw++ )
+	{
+	    fprintf( p.f, "%c%u+%u", col ? ',' : '=', fw->key, fw->val );
+	    total += fw->key + fw->val + p.col_size;
+	}
+	fprintf(p.f," = %d/%d%s",total,avail_chars,p.eol);
+    }
+
+    //--- print columns
+
+    const u_usec_t output_time = GetTimerUSec();
+
+    uint out_lines = p.n_rows;
+    //----------------------
+    if ( p.frame_mode >= 2 )
+    //----------------------
+    {
+	mc_print_line2(&p,"╔╤╦╗");
+	out_lines++;
+
+	if (mc->print_header)
+	{
+	    fprintf(p.f,"%s%*s%s║%s",p.prefix,p.indent,"",p.colset->heading,p.colset->reset);
+	    const mc_len_t *fw = p.fw_col;
+	    for ( int col = 0; col < p.n_cols; col++, fw++ )
+		 fprintf(p.f," %s %s│%s %s %s║%s",
+				AlignEUTF8ToCircBuf(p.head_key,-fw->key,fw->key),
+				p.colset->heading, p.colset->reset,
+				AlignEUTF8ToCircBuf(p.head_val,-fw->val,fw->val),
+				p.colset->heading, p.colset->reset );
+	    fputs(p.eol,p.f);
+
+	    mc_print_line2(&p,"╠╪╬╣");
+	    out_lines += 2;
+	}
+
+	for ( int row = 0; row < p.n_rows; row++ )
+	{
+	    fprintf(p.f,"%s%*s%s║%s",p.prefix,p.indent,"",p.colset->heading,p.colset->reset);
+	    const exmem_key_t *ptr = mc->list.list + row;
+	    const mc_len_t *fw = p.fw_col;
+	    for ( int col = 0; col < p.n_cols; col++, ptr += p.n_rows, fw++ )
+	    {
+		if ( ptr < list_end )
+		{
+		    fprintf(p.f," %s %s│%s ",
+				AlignEUTF8ToCircBuf(ptr->key,-fw->key,fw->key),
+				p.colset->heading, p.colset->reset );
+
+		    if ( ptr->data.attrib > 1 )
+		    {
+			const int fw_attrib = ptr->data.attrib < fw->val ? ptr->data.attrib : fw->val;
+			const int fw_val = p.len_list[ptr-mc->list.list].val;
+			if ( fw_attrib <= fw_val )
+			    goto std2;
+			fprintf(p.f,"%s%*s %s║%s",
+				AlignEUTF8ToCircBuf(ptr->data.data.ptr,fw_attrib,fw_attrib),
+				fw_attrib - fw->val, "",
+				p.colset->heading, p.colset->reset );
+		    }
+		    else
+		    {
+		     std2:;
+			const int fw_val = ptr->data.attrib ? -fw->val : fw->val;
+			fprintf(p.f,"%s %s║%s",
+				AlignEUTF8ToCircBuf(ptr->data.data.ptr,fw_val,fw->val),
+				p.colset->heading, p.colset->reset );
+		    }
+		}
+		else
+		    fprintf(p.f," %*s %s│%s %*s %s║%s",
+				fw->key, "", p.colset->heading, p.colset->reset,
+				fw->val, "", p.colset->heading, p.colset->reset );
+	    }
+	    fputs(p.eol,p.f);
+	}
+
+	mc_print_line2(&p,"╚╧╩╝");
+	out_lines++;
+    }
+    //---------------------------
+    else if ( p.frame_mode >= 1 )
+    //---------------------------
+    {
+	mc_print_line1(&p,"┌┬┐");
+	out_lines++;
+
+	if (mc->print_header)
+	{
+	    fprintf(p.f,"%s%*s%s│%s",p.prefix,p.indent,"",p.colset->heading,p.colset->reset);
+	    const mc_len_t *fw = p.fw_col;
+	    for ( int col = 0; col < p.n_cols; col++, fw++ )
+		 fprintf(p.f," %s%s%s %s│%s",
+				AlignEUTF8ToCircBuf(p.head_key,-fw->key,fw->key),
+				p.sep,
+				AlignEUTF8ToCircBuf(p.head_val,-fw->val,fw->val),
+				p.colset->heading, p.colset->reset );
+
+	    fputs(p.eol,p.f);
+
+	    mc_print_line1(&p,"├┼┤");
+	    out_lines += 2;
+	}
+
+	for ( int row = 0; row < p.n_rows; row++ )
+	{
+	    fprintf(p.f,"%s%*s%s│%s",p.prefix,p.indent,"",p.colset->heading,p.colset->reset);
+	    const exmem_key_t *ptr = mc->list.list + row;
+	    const mc_len_t *fw = p.fw_col;
+	    for ( int col = 0; col < p.n_cols; col++, ptr += p.n_rows, fw++ )
+	    {
+		if ( ptr < list_end )
+		{
+		    fprintf(p.f," %s%s",
+				AlignEUTF8ToCircBuf(ptr->key,-fw->key,fw->key),
+				p.sep );
+
+		    if ( ptr->data.attrib > 1 )
+		    {
+			const int fw_attrib = ptr->data.attrib < fw->val ? ptr->data.attrib : fw->val;
+			const int fw_val = p.len_list[ptr-mc->list.list].val;
+			if ( fw_attrib <= fw_val )
+			    goto std1;
+			fprintf(p.f,"%s%*s %s│%s",
+				AlignEUTF8ToCircBuf(ptr->data.data.ptr,fw_attrib,fw_attrib),
+				fw_attrib - fw->val, "",
+				p.colset->heading, p.colset->reset );
+		    }
+		    else
+		    {
+		     std1:;
+			const int fw_val = ptr->data.attrib ? -fw->val : fw->val;
+			fprintf(p.f,"%s %s│%s",
+				AlignEUTF8ToCircBuf(ptr->data.data.ptr,fw_val,fw->val),
+				p.colset->heading, p.colset->reset );
+		    }
+		}
+		else
+		    fprintf(p.f," %*s %s│%s",
+				fw->key + fw->val + p.sep_fw, "",
+				p.colset->heading, p.colset->reset );
+	    }
+	    fputs(p.eol,p.f);
+	}
+
+	mc_print_line1(&p,"└┴┘");
+	out_lines++;
+    }
+    //-------------------
+    else // !p.frame_mode
+    //-------------------
+    {
+	if (mc->print_header)
+	{
+	    mc_print_sep(&p);
+
+	    fprintf(p.f,"%s%*s",p.prefix,p.indent,"");
+	    const mc_len_t *fw = p.fw_col;
+	    for ( int col = 0; col < p.n_cols; col++, fw++ )
+	    {
+		if (col)
+		    fputs(" | ",p.f);
+		fprintf(p.f,"%s%s%s",
+				AlignEUTF8ToCircBuf(p.head_key,-fw->key,fw->key),
+				p.sep,
+				AlignEUTF8ToCircBuf(p.head_val,-fw->val,fw->val) );
+	    }
+	    fputs(p.eol,p.f);
+	    out_lines += 2;
+	}
+
+	if ( mc->print_header || mc->print_footer )
+	{
+	    mc_print_sep(&p);
+	    out_lines++;
+	}
+
+	for ( int row = 0; row < p.n_rows; row++ )
+	{
+	    fprintf(p.f,"%s%*s",p.prefix,p.indent,"");
+	    const exmem_key_t *ptr = mc->list.list + row;
+	    const mc_len_t *fw = p.fw_col;
+	    for ( int col = 0; col < p.n_cols; col++, ptr += p.n_rows, fw++ )
+	    {
+		if (col)
+		    fputs(" | ",p.f);
+		if ( ptr < list_end )
+		{
+		    fprintf(p.f,"%s%s",
+				AlignEUTF8ToCircBuf(ptr->key,-fw->key,fw->key),
+				p.sep );
+
+
+		    if ( ptr->data.attrib > 1 )
+		    {
+			const int fw_attrib = ptr->data.attrib < fw->val ? ptr->data.attrib : fw->val;
+			const int fw_val = p.len_list[ptr-mc->list.list].val;
+			if ( fw_attrib <= fw_val )
+			    goto std0;
+			fprintf(p.f,"%s%*s",
+				AlignEUTF8ToCircBuf(ptr->data.data.ptr,fw_attrib,fw_attrib),
+				fw_attrib - fw->val, "" );
+		    }
+		    else
+		    {
+		     std0:;
+			const int fw_val = ptr->data.attrib ? -fw->val : fw->val;
+			fputs(AlignEUTF8ToCircBuf(ptr->data.data.ptr,fw_val,fw->val),p.f);
+		    }
+		}
+	    }
+	    fputs(p.eol,p.f);
+	}
+
+	if (mc->print_footer)
+	{
+	    mc_print_sep(&p);
+	    out_lines++;
+	}
+    }
+    //---------------------
+    // end-if !p.frame_mode
+    //---------------------
+
+
+    //--- terminate
+
+    if ( p.debug > 0 )
+    {
+	const u_usec_t now = GetTimerUSec();
+	fprintf(p.f,"#> setup in %llu us, %u ouput lines in %llu us, total %llu us%s",
+		output_time - start_time,
+		out_lines, now - output_time,
+		now - start_time,
+		p.eol );
+    }
+
+    FREE(p.len_list);
+    return out_lines;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
 ///////////////			    Memory Maps			///////////////
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -8638,6 +10172,84 @@ int opt_new = 0;
 
 ///////////////////////////////////////////////////////////////////////////////
 
+ccp GetIpModeName ( IpMode_t ipm )
+{
+    switch (ipm)
+    {
+	case IPV4_ONLY:  return "IPv4 only";
+	case IPV6_ONLY:  return "IPv6 only";
+	case IPV4_FIRST: return "IPv4 first";
+	case IPV6_FIRST: return "IPv6 first";
+    }
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ipv4_t GetIP4Mask ( int bits )
+{
+    return bits > 0 && bits < 32
+	? htonl( 0xffffffffu << (32-bits) )
+	: bits ? 0xffffffffu : 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ipv6_t GetIP6Mask ( int bits )
+{
+    ipv6_t ip6;
+    memset(&ip6,~0,sizeof(ip6));
+    if ( bits >= 0 && bits < 128 )
+    {
+	int idx = bits/32;
+	bits -= idx*32;
+	const u32 mask = htonl( bits ? 0xffffffffu << (32-bits) : 0 );
+	ip6.v32[idx++] &= mask;
+	while ( idx < 4 )
+	    ip6.v32[idx++] = 0;
+    }
+    return ip6;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int GetBitsByMask4 ( ipv4_t ip4_nbo )
+{
+    const int res = FindHighest0BitBE(&ip4_nbo,4);
+    return 31-res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int GetBitsByMask6 ( ipv6_t ip6_nbo )
+{
+    const int res = FindHighest0BitBE(&ip6_nbo,16);
+    return 127-res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int GetBitsBySA ( sockaddr_t *sa, int return_on_error )
+{
+    if (sa)
+    {
+	if ( sa->sa_family == AF_INET )
+	{
+	    sockaddr_in4_t *sa4 = (sockaddr_in4_t*)sa;
+	    return GetBitsByMask4(sa4->sin_addr.s_addr);
+	}
+
+	if ( sa->sa_family == AF_INET6 )
+	{
+	    sockaddr_in6_t *sa6 = (sockaddr_in6_t*)sa;
+	    return GetBitsByMask6(*(ipv6_t*)&sa6->sin6_addr);
+	}
+    }
+    return return_on_error;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 uint CreateUniqueIdN ( int range )
 {
     static uint unique_id = 1;