SZS v2.18a

1 files changed, 1356 insertions, 0 deletions

diff --git a/project/src/wkclt.c b/project/src/wkclt.c
new file mode 100644
index 0000000..891f7e1
--- /dev/null
+++ b/project/src/wkclt.c
@@ -0,0 +1,1356 @@
+
+/***************************************************************************
+ *                         _______ _______ _______                         *
+ *                        |  ___  |____   |  ___  |                        *
+ *                        | |   |_|    / /| |   |_|                        *
+ *                        | |_____    / / | |_____                         *
+ *                        |_____  |  / /  |_____  |                        *
+ *                         _    | | / /    _    | |                        *
+ *                        | |___| |/ /____| |___| |                        *
+ *                        |_______|_______|_______|                        *
+ *                                                                         *
+ *                            Wiimms SZS Tools                             *
+ *                          https://szs.wiimm.de/                          *
+ *                                                                         *
+ ***************************************************************************
+ *                                                                         *
+ *   This file is part of the SZS project.                                 *
+ *   Visit https://szs.wiimm.de/ for project details and sources.          *
+ *                                                                         *
+ *   Copyright (c) 2011-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       *
+ *                                                                         *
+ ***************************************************************************/
+
+#include "lib-kcl.h"
+#include "lib-szs.h"
+#include "ui.h" // [[dclib]] wrapper
+#include "ui-wkclt.c"
+#include <math.h>
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			definitions			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+#define TITLE WKCLT_SHORT ": " WKCLT_LONG " v" VERSION " r" REVISION \
+	" " SYSTEM " - " AUTHOR " - " DATE
+
+static const char autoname[] = "/course.kcl";
+
+extern const char text_kcl_flag_template_cr[];
+
+//
+///////////////////////////////////////////////////////////////////////////////
+
+static void help_exit ( bool xmode )
+{
+    fputs( TITLE "\n", stdout );
+
+    if (xmode)
+    {
+	int cmd;
+	for ( cmd = 0; cmd < CMD__N; cmd++ )
+	    PrintHelpCmd(&InfoUI_wkclt,stdout,0,cmd,0,0,URI_HOME);
+    }
+    else
+	PrintHelpCmd(&InfoUI_wkclt,stdout,0,0,"HELP",0,URI_HOME);
+
+    exit(ERR_OK);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void print_version_section ( bool print_sect_header )
+{
+    if (print_sect_header)
+	fputs("[version]\n",stdout);
+
+    const u32 base = 0x04030201;
+    const u8 * e = (u8*)&base;
+    const u32 endian = be32(e);
+
+    printf( "prog=" WKCLT_SHORT "\n"
+	    "name=" WKCLT_LONG "\n"
+	    "version=" VERSION "\n"
+	    "beta=%d\n"
+	    "revision=" REVISION  "\n"
+	    "system=" SYSTEM "\n"
+	    "endian=%u%u%u%u %s\n"
+	    "author=" AUTHOR "\n"
+	    "date=" DATE "\n"
+	    "url=" URI_HOME WKCLT_SHORT "\n"
+	    "\n"
+	    , BETA_VERSION
+	    , e[0], e[1], e[2], e[3]
+	    , endian == 0x01020304 ? "little"
+		: endian == 0x04030201 ? "big" : "mixed" );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void version_exit()
+{
+    if ( brief_count > 1 )
+	fputs( VERSION "\n", stdout );
+    else if (brief_count)
+	fputs( VERSION " r" REVISION " " SYSTEM "\n", stdout );
+    else if (print_sections)
+	print_version_section(true);
+    else if (long_count)
+	print_version_section(false);
+    else
+	fputs( TITLE "\n", stdout );
+
+    exit(ERR_OK);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void print_title ( FILE * f )
+{
+    static bool done = false;
+    if (!done)
+    {
+	done = true;
+	if (print_sections)
+	    print_version_section(true);
+	else if ( verbose >= 1 && f == stdout )
+	    fprintf(f,"\n%s\n\n",TITLE);
+	else
+	    fprintf(f,"*****  %s  *****\n",TITLE);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static const KeywordTab_t * current_command = 0;
+
+static void hint_exit ( enumError stat )
+{
+    if ( current_command )
+	fprintf(stderr,
+	    "-> Type '%s help %s' (pipe it to a pager like 'less') for more help.\n\n",
+	    progname, CommandInfo[current_command->id].name1 );
+    else
+	fprintf(stderr,
+	    "-> Type '%s -h' or '%s help' (pipe it to a pager like 'less') for more help.\n\n",
+	    progname, progname );
+    exit(stat);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define SYNTAX_ERROR syntax_error(__FUNCTION__,__FILE__,__LINE__)
+
+static void syntax_error ( ccp func, ccp file, uint line )
+{
+    if ( current_command
+	&& current_command->id >= 0
+	&& current_command->id < InfoUI_wkclt.n_cmd )
+    {
+	const InfoCommand_t *ic = InfoUI_wkclt.cmd_info + current_command->id;
+	if (strchr(ic->syntax,'\n'))
+	{
+	    ccp src = ic->syntax;
+	    char *dest = iobuf;
+	    while (*src)
+		if ( (*dest++ = *src++) == '\n' )
+		{
+		    *dest++ = ' ';
+		    *dest++ = ' ';
+		    *dest++ = ' ';
+		}
+	    *dest = 0;
+	    PrintErrorFile(func,file,line,0,0,ERR_SYNTAX,"Syntax:\n   %s\n",iobuf);
+	}
+	else
+	    PrintErrorFile(func,file,line,0,0,ERR_SYNTAX,"Syntax: %s\n",ic->syntax);
+    }
+    else
+	PrintErrorFile(func,file,line,0,0,ERR_SYNTAX,"Syntax Error!\n");
+    exit(ERR_SYNTAX);
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			command test			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError cmd_test_options()
+{
+    printf("\nOptions (compatibility: %s; format: hex=dec):\n",PrintOptCompatible());
+
+    printf("  test:        %16x = %12d\n",testmode,testmode);
+    printf("  verbose:     %16x = %12d\n",verbose,verbose);
+    printf("  width:       %16x = %12d\n",opt_width,opt_width);
+    printf("  escape-char: %16x = %12d\n",escape_char,escape_char);
+    printf("  kcl modes:   %16llx = \"%s\"\n",(u64)KCL_MODE,GetKclMode());
+    printf("  tri-area:    %16g\n",opt_tri_area);
+    printf("  tri-height:  %16g\n",opt_tri_height);
+
+    if (opt_xtridata)
+	printf("  xtridata:    %16x = %12d [support %sabled]\n",
+		opt_xtridata, opt_xtridata, SUPPORT_KCL_XTRIDATA ? "en" : "dis" );
+
+    if ( kcl_script_list.used == 1 )
+	printf("  kcl script:  %s\n",kcl_script_list.field[0]);
+    else if ( kcl_script_list.used >  1 )
+    {
+	printf("  %u kcl scripts:\n",kcl_script_list.used);
+	uint i;
+	for ( i = 0; i < kcl_script_list.used; i++ )
+	    printf("%6d.: %s\n",i+1,kcl_script_list.field[i]);
+    }
+    if (opt_slot)
+	printf("  slot:        %16x = \"%s\"\n",opt_slot,PrintSlotMode(opt_slot));
+
+    DumpTransformationOpt();
+
+    if (opt_tracks)
+	DumpTrackList(0,0,0);
+    if (opt_arenas)
+	DumpArenaList(0,0,0);
+
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError cmd_test()
+{
+ #if 1 || !defined(TEST) // test options
+
+    return cmd_test_options();
+
+ #else
+
+    ParamList_t *param;
+    for ( param = first_param; param; param = param->next )
+    {
+	//NORMALIZE_FILENAME_PARAM(param);
+    }
+    return ERR_OK;
+
+ #endif
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			command export			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError cmd_export()
+{
+    SetupVarsKCL();
+    return ExportHelper("kcl");
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			command cat			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError cmd_cat()
+{
+    stdlog = stderr;
+    enable_kcl_drop_auto++;
+
+    raw_data_t raw;
+    InitializeRawData(&raw);
+
+    enumError cmd_err = ERR_OK;
+    ParamList_t *param;
+    for ( param = first_param; param; param = param->next )
+    {
+	NORMALIZE_FILENAME_PARAM(param);
+	enumError err = LoadRawData(&raw,false,param->arg,autoname,opt_ignore>0,FF_KCL);
+	if ( err == ERR_NOT_EXISTS || err > ERR_WARNING && opt_ignore )
+	    continue;
+	if ( err > ERR_WARNING )
+	    return err;
+
+	CheckMode_t mode = GetCheckMode(false,false,true,false);
+	if ( verbose >= 0 || testmode )
+	{
+	    mode = GetCheckMode(true,false,true,false);
+	    fprintf(stdlog,"%sCAT %s:%s\n",
+			verbose > 0 ? "\n" : "",
+			GetNameFF(raw.fform,0), raw.fname );
+	    fflush(stdlog);
+	}
+
+	kcl_t kcl;
+	err = ScanRawDataKCL(&kcl,true,&raw,mode,true);
+	if ( err > ERR_WARNING )
+	    return err;
+
+	if (!testmode)
+	{
+	    err = SaveTextKCL(&kcl,"-",false);
+	    fflush(stdout);
+	    if ( err > ERR_WARNING )
+		return err;
+	}
+	ResetKCL(&kcl);
+    }
+
+    ResetRawData(&raw);
+    return cmd_err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		  command encode/decode			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError cmd_convert ( int cmd_id, ccp cmd_name, ccp def_path )
+{
+    if ( cmd_id == CMD_DECODE )
+	enable_kcl_drop_auto++;
+    CheckOptDest(def_path,false);
+
+    raw_data_t raw;
+    InitializeRawData(&raw);
+
+    ParamList_t *param;
+    for ( param = first_param; param; param = param->next )
+    {
+	NORMALIZE_FILENAME_PARAM(param);
+	enumError err = LoadRawData(&raw,false,param->arg,autoname,opt_ignore>0,FF_KCL);
+	if ( err == ERR_NOT_EXISTS || err > ERR_WARNING && opt_ignore )
+	    continue;
+	if ( err > ERR_WARNING )
+	    return err;
+
+	char dest[PATH_MAX];
+	const file_format_t dest_ff = cmd_id == CMD_ENCODE ? FF_KCL : FF_KCL_TXT;
+
+	SubstDest(dest,sizeof(dest),param->arg,opt_dest,def_path,
+			GetExtFF(dest_ff,0),false);
+
+	if ( verbose >= 0 || testmode )
+	{
+	    fprintf(stdlog,"%s%s%s %s:%s -> %s:%s\n",
+			verbose > 0 ? "\n" : "",
+			testmode ? "WOULD " : "", cmd_name,
+			GetNameFF(raw.fform,0), raw.fname,
+			GetNameFF(dest_ff,0), dest );
+	    fflush(stdlog);
+	}
+
+	kcl_t kcl;
+	InitializeKCL(&kcl);
+	kcl.fform_outfile = dest_ff;
+	err = ScanRawDataKCL(&kcl,false,&raw,global_check_mode,true);
+	if ( err > ERR_WARNING )
+	    return err;
+
+	if (!testmode)
+	{
+	    err = dest_ff == FF_KCL
+			? SaveRawKCL(&kcl,dest,opt_preserve)
+			: SaveTextKCL(&kcl,dest,opt_preserve);
+	    fflush(stdout);
+	    if ( err > ERR_WARNING )
+		return err;
+	}
+	ResetKCL(&kcl);
+    }
+
+    ResetRawData(&raw);
+    return ERR_OK;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			command copy			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError cmd_copy()
+{
+    if (!opt_dest)
+    {
+	if (!first_param)
+	    return ERROR0(ERR_MISSING_PARAM, "Missing destination parameter!\n" );
+
+	ParamList_t *param;
+	for ( param = first_param; param->next; param = param->next )
+	    ;
+	ASSERT(param);
+	ASSERT(!param->next);
+	SetDest(param->arg,false);
+	param->arg = 0;
+    }
+
+    enable_kcl_drop_auto = 0;
+    file_format_t fform_dest = FF_UNKNOWN;
+    ccp point = strrchr(opt_dest,'.');
+    if (point)
+    {
+	if (!strcasecmp(point,".kcl"))
+	    fform_dest = FF_KCL;
+	else if ( !strcasecmp(point,".obj") || !strcasecmp(point,".txt") )
+	{
+	    fform_dest = FF_WAV_OBJ;
+	    enable_kcl_drop_auto++;
+	}
+    }
+    PRINT("fform(dest) = %s: %s\n",GetNameFF(0,fform_dest),opt_dest);
+
+    raw_data_t raw;
+    InitializeRawData(&raw);
+
+    int done_count = 0;
+    ParamList_t *param;
+    for ( param = first_param; param; param = param->next )
+    {
+	if (!param->arg)
+	    continue;
+	NORMALIZE_FILENAME_PARAM(param);
+	done_count++;
+
+	enumError err = LoadRawData(&raw,false,param->arg,autoname,opt_ignore>0,FF_KCL);
+	if ( err == ERR_NOT_EXISTS || err > ERR_WARNING && opt_ignore )
+	    continue;
+	if ( err > ERR_WARNING )
+	    return err;
+
+	const file_format_t dest_ff = fform_dest != FF_UNKNOWN
+					? fform_dest
+					: raw.fform;
+
+	kcl_t kcl;
+	InitializeKCL(&kcl);
+	kcl.fform_outfile = dest_ff;
+	err = ScanRawDataKCL(&kcl,false,&raw,global_check_mode,true);
+	if ( err > ERR_WARNING )
+	    return err;
+
+	char dest[PATH_MAX];
+	SubstDest(dest,sizeof(dest),param->arg,opt_dest,"\1P/\1N\1?T",
+			GetExtFF(dest_ff,0),false);
+	if ( verbose >= 0 || testmode )
+	{
+	    fprintf(stdlog,"%s%sCOPY %s:%s -> %s:%s\n",
+			verbose > 0 ? "\n" : "",
+			testmode ? "WOULD " : "",
+			GetNameFF(raw.fform,0), kcl.fname,
+			GetNameFF(dest_ff,0), dest );
+	    fflush(stdlog);
+	}
+
+	if (!testmode)
+	{
+	    err = dest_ff == FF_KCL
+			? SaveRawKCL(&kcl,dest,opt_preserve)
+			: SaveTextKCL(&kcl,dest,opt_preserve);
+	    fflush(stdout);
+	    if ( err > ERR_WARNING )
+		return err;
+	}
+
+	ResetKCL(&kcl);
+    }
+    ResetRawData(&raw);
+
+    if (!done_count)
+	SYNTAX_ERROR;
+
+    return ERR_OK;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			command cff			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static ccp cff_func_f ( u16 flag )
+{
+    const uint bufsize = 20;
+    char *buf = GetCircBuf(bufsize);
+    DASSERT(buf);
+    snprintf(buf,bufsize,"f(0x%02x,0x%03x)",
+	flag % N_KCL_TYPE, flag / N_KCL_TYPE );
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static ccp cff_func_a ( u16 flag )
+{
+    const uint bufsize = 20;
+    char *buf = GetCircBuf(bufsize);
+    DASSERT(buf);
+    snprintf(buf,bufsize,"a(0x%02x,%u,%u,%u,%u)",
+	flag % N_KCL_TYPE,
+	flag >> 13 & 7,
+	flag >> 11 & 3,
+	flag >>  8 & 7,
+	flag >>  5 & 7 );
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static ccp cff_func_i ( u16 flag )
+{
+    const uint bufsize = 20;
+    char *buf = GetCircBuf(bufsize);
+    DASSERT(buf);
+    snprintf(buf,bufsize,"i(0x%02x,%u,%u)",
+	flag % N_KCL_TYPE,
+	flag >> 5 & 7,
+	flag >> 8 & 15 );
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError cmd_cff()
+{
+    CheckOptDest(KCL_FLAG_FILE1,false);
+
+    raw_data_t raw;
+    InitializeRawData(&raw);
+    uint *flag_count = AllocFlagCount();
+    char dest_buf[PATH_MAX];
+
+    ParamList_t *param;
+    for ( param = first_param; param; param = param->next )
+    {
+	NORMALIZE_FILENAME_PARAM(param);
+	enumError err = LoadRawData(&raw,false,param->arg,autoname,opt_ignore>0,FF_KCL);
+	if ( err == ERR_NOT_EXISTS || err > ERR_WARNING && opt_ignore )
+	    continue;
+	if ( err > ERR_WARNING )
+	    return err;
+
+	kcl_t kcl;
+	err = ScanRawDataKCL(&kcl,true,&raw,global_check_mode,true);
+	if ( err > ERR_WARNING )
+	    return err;
+
+	LoadFlagFileKCL(&kcl);
+
+	if ( kcl.fform == FF_KCL )
+	{
+	    CountFlagsKCL(&kcl,flag_count);
+
+	    uint i;
+	    for ( i = 0; i < N_KCL_FLAG; i++ )
+		if (flag_count[i])
+		{
+		    StringCopyS(dest_buf,sizeof(dest_buf),GetGroupNameKCL(i,false));
+		    char *p;
+		    for ( p = dest_buf; *p; p++ )
+			*p = toupper((int)*p);
+		    GetFlagByNameKCL(&kcl,dest_buf,0);
+		}
+	}
+
+	bool append = true;
+	ccp dest = kcl.flag_fname;
+	PRINT("DEST: %s\n",dest);
+	if (!dest)
+	{
+	    SubstDest(dest_buf,sizeof(dest_buf),param->arg,opt_dest,
+			0,KCL_FLAG_EXT,false);
+	    dest = dest_buf;
+	    append = false;
+	}
+
+	if ( verbose >= 0 || testmode )
+	{
+	    fprintf(stdlog,"%s%s%s %s for %s:%s\n",
+			verbose > 0 ? "\n" : "",
+			testmode ? "WOULD " : "",
+			!kcl.flag_missing.used ? "SKIP  "
+				: append ? "APPEND" : "CREATE",
+			dest, GetNameFF(kcl.fform,0), kcl.fname );
+	    fflush(stdlog);
+	}
+
+	if ( !testmode && kcl.flag_missing.used )
+	{
+	    File_t F;
+	    enumError err;
+	    if (append)
+	    {
+		err = AppendFILE(&F,true,dest,false,opt_mkdir);
+		if (!err)
+		    fputs("\r\n",F.f);
+	    }
+	    else
+	    {
+		err = CreateFileOpt(&F,true,dest,false,0);
+		if (!err)
+		    fputs(text_kcl_flag_template_cr,F.f);
+	    }
+
+	    if (!err)
+	    {
+		uint i, fw = 29;
+		for ( i = 0; i < kcl.flag_missing.used; i++ )
+		{
+		    FormatFieldItem_t *it = kcl.flag_missing.list + i;
+		    const uint len = strlen(it->key);
+		    if ( fw < len )
+			fw = len;
+		}
+		fw = ( fw + 10 ) / 8 * 8 + 5;
+
+		for ( i = 0; i < kcl.flag_missing.used; i++ )
+		{
+		    FormatFieldItem_t *it = kcl.flag_missing.list + i;
+		    int tablen = (fw-strlen(it->key))/8;
+		    if ( tablen < 1 )
+			tablen = 1;
+		    const bool is_auto = IsAutoFlagKCL(it->num);
+		    const u16 num = is_auto ? 0 : it->num; // unsigned with reduced num of bits
+		    if ( long_count > 1 )
+		    {
+			if (brief_count)
+			    fprintf(F.f,
+				"  %s%.*s= %s",
+				it->key, tablen, Tabs20,
+				cff_func_a(num) );
+			else
+			    fprintf(F.f,
+				"  %s%.*s= %s # %s  %s  0x%04x",
+				it->key, tablen, Tabs20,
+				cff_func_a(num), cff_func_f(num), cff_func_i(num), num );
+		    }
+		    else if (long_count)
+		    {
+			if (brief_count)
+			    fprintf(F.f,
+				"  %s%.*s= %s",
+				it->key, tablen, Tabs20,
+				cff_func_f(num) );
+			else
+			    fprintf(F.f,
+				"  %s%.*s= %s # %s  %s  0x%04x",
+				it->key, tablen, Tabs20,
+				cff_func_f(num), cff_func_a(num), cff_func_i(num), num );
+		    }
+		    else if (brief_count)
+			fprintf(F.f,
+				"  %s%.*s= 0x%04x",
+				it->key, tablen, Tabs20, num );
+		    else
+			fprintf(F.f,
+				"  %s%.*s= 0x%04x  #  %s  %s  %s",
+				it->key, tablen, Tabs20,
+				num, cff_func_f(num), cff_func_a(num), cff_func_i(num) );
+
+		    fputs(is_auto ? " # edit this line!\r\n" : "\r\n", F.f );
+		}
+		fputs("\r\n",F.f);
+	    }
+
+	    CloseFile(&F,false);
+	    if ( err > ERR_WARNING )
+		return err;
+	}
+	ResetKCL(&kcl);
+    }
+
+    FREE(flag_count);
+    ResetRawData(&raw);
+    return ERR_OK;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			command flags			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError cmd_flags()
+{
+    stdlog = stderr;
+    uint *count = AllocFlagCount();
+
+    raw_data_t raw;
+    InitializeRawData(&raw);
+
+    enumError cmd_err = ERR_OK;
+    ParamList_t *param;
+    for ( param = first_param; param; param = param->next )
+    {
+	NORMALIZE_FILENAME_PARAM(param);
+	enumError err = LoadRawData(&raw,false,param->arg,autoname,opt_ignore>0,FF_KCL);
+	if ( err == ERR_NOT_EXISTS || err > ERR_WARNING && opt_ignore )
+	    continue;
+	if ( err > ERR_WARNING )
+	    return err;
+
+	if ( verbose >= 0 || testmode )
+	    fprintf(stdout,"%sKCL Flags of %s:%s\n",
+			verbose > 0 ? "\n" : "",
+			GetNameFF(raw.fform,0), raw.fname );
+
+	kcl_t kcl;
+	err = ScanRawDataKCL(&kcl,true,&raw,global_check_mode,true);
+	if ( err > ERR_WARNING )
+	    return err;
+
+	if (!testmode)
+	{
+	    const uint n = kcl.tridata.used;
+	    CountFlagsKCL(&kcl,count);
+	    uint tcount[N_KCL_TYPE];
+	    memset(tcount,0,sizeof(tcount));
+
+	    if ( print_header && !brief_count )
+		printf("\n  flag    type  variant        triangle count\n"
+			 "-----------------------------------------------\n");
+
+	    uint i, j;
+	    for ( i = 0; i < N_KCL_TYPE; i++ )
+	    {
+		int done = 0;
+		for ( j = i; j < N_KCL_FLAG; j += N_KCL_TYPE )
+		    if (count[j])
+		    {
+			tcount[i] += count[j];
+			if (!brief_count)
+			{
+			    done++;
+			    printf(" 0x%04x = 0x%02x | 0x%03x << 5 :%7u = %6.2f%%\n",
+				j, j & 0x1f, j >> 5,
+				count[j], 100.0 * count[j] / n );
+			}
+		    }
+		if ( done && print_header )
+		    putchar('\n');
+	    }
+
+	    if (print_header)
+		printf( "\n"
+			"   type    triangle count   type description\n"
+			"--------------------------------------------------\n");
+
+	    for ( i = 0; i < N_KCL_TYPE; i++ )
+		if (tcount[i])
+		    printf(" T 0x%02x :%7u = %6.2f%%  %s\n",
+			i, tcount[i], 100.0 * tcount[i] / n,
+			kcl_type[i].info );
+	    putchar('\n');
+	}
+	ResetKCL(&kcl);
+	fflush(stdout);
+    }
+
+    ResetRawData(&raw);
+    FREE(count);
+    return cmd_err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			command dump			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError cmd_dump ( bool brief_level, int cmd )
+{
+    stdlog = stderr;
+
+    if ( brief_level > 0 )
+    {
+	RegisterOptionByIndex(&InfoUI_wkclt,OPT_BRIEF,brief_level,false);
+	brief_count += brief_level;
+    }
+
+    raw_data_t raw;
+    InitializeRawData(&raw);
+
+    enumError cmd_err = ERR_OK;
+    ParamList_t *param;
+    for ( param = first_param; param; param = param->next )
+    {
+	NORMALIZE_FILENAME_PARAM(param);
+	enumError err = LoadRawData(&raw,false,param->arg,autoname,opt_ignore>0,FF_KCL);
+	if ( err == ERR_NOT_EXISTS || err > ERR_WARNING && opt_ignore )
+	    continue;
+	if ( err > ERR_WARNING )
+	    return err;
+
+	if ( verbose >= 0 || testmode )
+	    fprintf(stdout,"%s%s of %s:%s\r\n",
+			verbose > 0 ? "\r\n" : "",
+			cmd == CMD_LIST
+				? "LIST"	: cmd == CMD_TRIANGLES
+				? "TRIANGLES"	: "DUMP",
+			GetNameFF(raw.fform,0), raw.fname );
+
+	kcl_t kcl;
+	InitializeKCL(&kcl);
+	kcl.fform_outfile = FF_KCL;
+	err = ScanRawDataKCL(&kcl,false,&raw,global_check_mode,true);
+	if ( err > ERR_WARNING )
+	    return err;
+
+	if (!testmode)
+	{
+	    err = cmd == CMD_LIST
+			? DumpTrianglesKCL(&kcl,"-")
+			: cmd == CMD_TRIANGLES
+			? ListTrianglesKCL(&kcl,"-",!brief_count,long_count)
+			: DumpKCL(&kcl,"-",!brief_count,long_count);
+	    fflush(stdout);
+	    if ( err > ERR_WARNING )
+		return err;
+	}
+	ResetKCL(&kcl);
+    }
+
+    ResetRawData(&raw);
+    return cmd_err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			command traverse		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError cmd_traverse ( bool fall )
+{
+    stdlog = stderr;
+
+    uint width = 100;
+    u32 type_mask = M1(type_mask);
+
+    char fall_hint[50] = {0};
+    if (fall)
+    {
+	const Var_t *var = FindConst("WIDTH");
+	if ( var && var->mode != VAR_UNSET )
+	{
+	    int temp = GetIntV(var);
+	    if ( temp > 0 )
+		width = temp;
+	}
+
+	var = FindConst("MASK");
+	if ( var && var->mode != VAR_UNSET )
+	    type_mask = GetIntV(var);
+
+	snprintf(fall_hint,sizeof(fall_hint),
+			" [width=%u,mask=0x%x]", width, type_mask );
+    }
+
+    raw_data_t raw;
+    InitializeRawData(&raw);
+
+    ParamList_t *param = first_param;
+	NORMALIZE_FILENAME_PARAM(param);
+    enumError err = LoadRawData(&raw,false,first_param->arg,autoname,opt_ignore>0,FF_KCL);
+    if ( err == ERR_NOT_EXISTS || err > ERR_WARNING )
+	return err;
+
+    if ( verbose >= 0 || testmode )
+    {
+	fprintf(stdlog,"\nANALYZE OCTREE OF %s:%s%s\n\n",
+			GetNameFF(raw.fform,0), raw.fname, fall_hint );
+	fflush(stdlog);
+    }
+
+    kcl_t kcl;
+    err = ScanRawDataKCL(&kcl,true,&raw,0,true);
+    if ( err > ERR_WARNING || !param )
+	return err;
+
+    uint np = 1;
+    enumError max_err = ERR_OK;
+    for ( param = param->next; param; param = param->next, np++ )
+    {
+	char name[50];
+	snprintf(name,sizeof(name),"Point #%u",np);
+
+	DEFINE_VAR(pt);
+	err = ScanVectorExpr(param->arg,name,&pt);
+	if ( max_err < err )
+	     max_err = err;
+
+	if (fall)
+	{
+	    int kcl_flag;
+	    double height = FallKCL(&kcl,stdout,pt.d3,width,
+						long_count,type_mask,&kcl_flag);
+	    if (brief_count>1)
+		printf("%11.3f\n",height);
+	    else if (brief_count)
+		printf("%11.3f %11.3f %11.3f\n",
+		    pt.d3.x, height, pt.d3.z );
+	    else if ( kcl_flag >= 0 )
+		printf("%11.3f %11.3f %11.3f  0x%04x\n",
+		    pt.d3.x, height, pt.d3.z, kcl_flag );
+	    else
+		printf("%11.3f %11.3f %11.3f      -1\n",
+		    pt.d3.x, height, pt.d3.z );
+	}
+	else
+	    err = TraverseOctreeKCL( &kcl, stdout, pt.d3,
+					brief_count<=0, long_count );
+	fflush(stdout);
+	if ( max_err < err )
+	     max_err = err;
+    }
+
+    ResetKCL(&kcl);
+    ResetRawData(&raw);
+    return max_err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			command check			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError cmd_check()
+{
+    patch_action_log_disabled++;
+    raw_data_t raw;
+    InitializeRawData(&raw);
+
+    enumError cmd_err = ERR_OK;
+    ParamList_t *param;
+    for ( param = first_param; param; param = param->next )
+    {
+	NORMALIZE_FILENAME_PARAM(param);
+	enumError err = LoadRawData(&raw,false,param->arg,autoname,opt_ignore>0,FF_KCL);
+	if ( err == ERR_NOT_EXISTS || err > ERR_WARNING && opt_ignore )
+	    continue;
+	if ( err > ERR_WARNING )
+	    return err;
+
+	const bool check_verbose = verbose > 0 || long_count > 0;
+	CheckMode_t mode = GetCheckMode(false,brief_count>0,verbose<0,check_verbose);
+	if ( verbose >= 0 || testmode )
+	{
+	    ColorSet_t col;
+	    SetupColorSet(&col,stdlog);
+	    mode = GetCheckMode(true,brief_count>0,false,check_verbose);
+	    fprintf(stdlog,"%s%sCHECK %s:%s%s\n",
+			verbose > 0 ? "\n" : "",
+			col.heading, GetNameFF(raw.fform,0), raw.fname, col.reset );
+	    fflush(stdlog);
+	}
+
+	kcl_t kcl;
+	err = ScanRawDataKCL(&kcl,true,&raw,0,true);
+	if ( err <= ERR_WARNING && ( !mode || CheckKCL(&kcl,mode) ))
+	    cmd_err = ERR_DIFFER;
+	fflush(stdout);
+	ResetKCL(&kcl);
+	if ( err > ERR_WARNING )
+	    return err;
+    }
+
+    ResetRawData(&raw);
+    return cmd_err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			command analyze			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static void analyze_kcl ( kcl_t *kcl )
+{
+    DASSERT(kcl);
+
+    double v_min	=  INFINITY;
+    double v_max_neg	= -INFINITY;
+    double v_min_pos	=  INFINITY;
+    double v_max	= -INFINITY;
+
+    float  n_min	=  INFINITY;
+    float  n_max_neg	= -INFINITY;
+    float  n_min_pos	=  INFINITY;
+    float  n_max	= -INFINITY;
+
+    uint n		= 0;
+    const uint n_tri	= kcl->tridata.used;
+
+    kcl_tridata_t *td_base = (kcl_tridata_t*)kcl->tridata.list;
+    kcl_tridata_t *td, *td_end = td_base + n_tri;
+    for ( td = td_base; td < td_end; td++ )
+    {
+	if ( td->status & TD_INVALID_NORM )
+	    continue;
+
+	n++;
+
+	double *d = td->pt->v;
+	uint nd = 3;
+	for ( ; nd > 0; nd--, d++ )
+	{
+	    if ( v_min > *d ) v_min = *d;
+	    if ( v_max < *d ) v_max = *d;
+	    if ( *d > 0.0 && v_min_pos > *d ) v_min_pos = *d;
+	    if ( *d < 0.0 && v_max_neg < *d ) v_max_neg = *d;
+	}
+
+	float *f = td->normal->v;
+	uint nf = sizeof(td->normal)/sizeof(float);
+	for ( ; nf > 0; nf--, f++ )
+	{
+	    if ( n_min > *f ) n_min = *f;
+	    if ( n_max < *f ) n_max = *f;
+	    if ( *f > 0.0 && n_min_pos > *f ) n_min_pos = *f;
+	    if ( *f < 0.0 && n_max_neg < *f ) n_max_neg = *f;
+	    //printf("XX: %08x\n",*(u32*)f);
+	}
+    }
+
+
+    printf(
+	"\n"
+	"%5u / %-5u     vertex         normal\n"
+	"--------------------------------------------\n"
+	" min:          %13.6e  %13.6e\n"
+	" max negative: %13.6e  %13.6e\n"
+	" min positive: %13.6e  %13.6e\n"
+	" max:          %13.6e  %13.6e\n"
+	"\n",
+	n, n_tri,
+	v_min,		n_min,
+	v_max_neg,	n_max_neg,
+	v_min_pos,	n_min_pos,
+	v_max,		n_max );
+
+    // Value found in Nintendos tracks:
+    // -v_max_neg == v_min_pos == 1.001358e-05 == 0x1.5p-17 == 21.0>>21
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError cmd_analyze()
+{
+    stdlog = stderr;
+
+    raw_data_t raw;
+    InitializeRawData(&raw);
+
+    enumError cmd_err = ERR_OK;
+    ParamList_t *param;
+    for ( param = first_param; param; param = param->next )
+    {
+	NORMALIZE_FILENAME_PARAM(param);
+	enumError err = LoadRawData(&raw,false,param->arg,autoname,opt_ignore>0,FF_KCL);
+	if ( err == ERR_NOT_EXISTS || err > ERR_WARNING && opt_ignore )
+	    continue;
+	if ( err > ERR_WARNING )
+	    return err;
+
+	if ( verbose >= 0 || testmode )
+	    fprintf(stdout,"%sAnalyze %s:%s\r\n",
+			verbose > 0 ? "\r\n" : "",
+			GetNameFF(raw.fform,0), raw.fname );
+
+	kcl_t kcl;
+	err = ScanRawDataKCL(&kcl,true,&raw,0,true);
+	if ( err > ERR_WARNING )
+	    return err;
+
+	analyze_kcl(&kcl);
+	ResetKCL(&kcl);
+    }
+
+    ResetRawData(&raw);
+    return cmd_err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError cmd_blow()
+{
+    stdlog = stderr;
+
+    raw_data_t raw;
+    InitializeRawData(&raw);
+
+    enumError cmd_err = ERR_OK;
+    ParamList_t *param;
+    for ( param = first_param; param; param = param->next )
+    {
+	NORMALIZE_FILENAME_PARAM(param);
+	enumError err = LoadRawData(&raw,false,param->arg,autoname,opt_ignore>0,FF_KCL);
+	if ( err == ERR_NOT_EXISTS || err > ERR_WARNING && opt_ignore )
+	    continue;
+	if ( err > ERR_WARNING )
+	    return err;
+
+	kcl_t kcl;
+	err = ScanRawDataKCL(&kcl,true,&raw,0,true);
+	if ( err > ERR_WARNING )
+	    return err;
+
+	uint blow = CalcBlowSizeKCL(&kcl);
+	fprintf(stdout,"%6u = blow size of %s:%s\r\n",
+			blow, GetNameFF(kcl.fform,0), kcl.fname );
+	ResetKCL(&kcl);
+    }
+
+    ResetRawData(&raw);
+    return cmd_err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////                   check options                 ///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError CheckOptions ( int argc, char ** argv, bool is_env )
+{
+    TRACE("CheckOptions(%d,%p,%d) optind=%d\n",argc,argv,is_env,optind);
+
+    optind = 0;
+    int err = 0;
+
+    for(;;)
+    {
+      const int opt_stat = getopt_long(argc,argv,OptionShort,OptionLong,0);
+      if ( opt_stat == -1 )
+	break;
+
+      RegisterOptionByName(&InfoUI_wkclt,opt_stat,1,is_env);
+
+      switch ((enumGetOpt)opt_stat)
+      {
+	case GO__ERR:		err++; break;
+
+	case GO_VERSION:	version_exit();
+	case GO_HELP:		help_exit(false);
+	case GO_XHELP:		help_exit(true);
+	case GO_ALLOW_ALL:	allow_all = true; break;
+	case GO_COMPATIBLE:	err += ScanOptCompatible(optarg); break;
+	case GO_WIDTH:		err += ScanOptWidth(optarg); break;
+	case GO_QUIET:		verbose = verbose > -1 ? -1 : verbose - 1; break;
+	case GO_VERBOSE:	verbose = verbose <  0 ?  0 : verbose + 1; break;
+	case GO_LOGGING:	logging++; break;
+	case GO_DE:		use_de = true; break;
+	case GO_CT_CODE:	ctcode_enabled = true; break;
+	case GO_LE_CODE:	lecode_enabled = true; break;
+	case GO_COLORS:		err += ScanOptColorize(0,optarg,0); break;
+	case GO_NO_COLORS:	opt_colorize = COLMD_OFF; break;
+
+	case GO_CHDIR:		err += ScanOptChdir(optarg); break;
+	case GO_CONST:		err += ScanOptConst(optarg); break;
+	case GO_SCALE:		err += ScanOptScale(optarg); break;
+	case GO_SHIFT:		err += ScanOptShift(optarg); break;
+	case GO_XSS:		err += ScanOptXSS(0,optarg); break;
+	case GO_YSS:		err += ScanOptXSS(1,optarg); break;
+	case GO_ZSS:		err += ScanOptXSS(2,optarg); break;
+	case GO_ROT:		err += ScanOptRotate(optarg); break;
+	case GO_XROT:		err += ScanOptXRotate(0,optarg); break;
+	case GO_YROT:		err += ScanOptXRotate(1,optarg); break;
+	case GO_ZROT:		err += ScanOptXRotate(2,optarg); break;
+	case GO_TRANSLATE:	err += ScanOptTranslate(optarg); break;
+	case GO_NULL:		force_transform |= 1; break;
+	case GO_NEXT:		err += NextTransformation(false); break;
+	case GO_ASCALE:		err += ScanOptAScale(optarg); break;
+	case GO_AROT:		err += ScanOptARotate(optarg); break;
+	case GO_TFORM_SCRIPT:	err += ScanOptTformScript(optarg); break;
+	case GO_KCL:		err += ScanOptKcl(optarg); break;
+	case GO_KCL_FLAG:	err += ScanOptKclFlag(optarg); break;
+	case GO_KCL_SCRIPT:	err += ScanOptKclScript(optarg); break;
+	case GO_TRI_AREA:	err += ScanOptTriArea(optarg); break;
+	case GO_TRI_HEIGHT:	err += ScanOptTriHeight(optarg); break;
+	case GO_FLAG_FILE:	opt_flag_file = optarg; break;
+	case GO_XTRIDATA:	opt_xtridata = optarg ? str2ul(optarg,0,10) : 1; break;
+	case GO_SLOT:		err += ScanOptSlot(optarg); break;
+
+	case GO_UTF_8:		use_utf8 = true; break;
+	case GO_NO_UTF_8:	use_utf8 = false; break;
+
+	case GO_TEST:		testmode++; break;
+	case GO_FORCE:		force_count++; break;
+	case GO_REPAIR_MAGICS:	err += ScanOptRepairMagic(optarg); break;
+	case GO_TINY:		err += ScanOptTiny(optarg); break;
+
+ #if OPT_OLD_NEW
+	case GO_OLD:		opt_new = opt_new>0 ? -1 : opt_new-1; break;
+	case GO_STD:		opt_new = 0; break;
+	case GO_NEW:		opt_new = opt_new<0 ? +1 : opt_new+1; break;
+ #endif
+	case GO_EXTRACT:	opt_extract = optarg; break;
+
+	case GO_ESC:		err += ScanEscapeChar(optarg) < 0; break;
+	case GO_DEST:		SetDest(optarg,false); break;
+	case GO_DEST2:		SetDest(optarg,true); break;
+	case GO_OVERWRITE:	opt_overwrite = true; break;
+	case GO_NUMBER:		opt_number = true; break;
+	case GO_REMOVE_DEST:	opt_remove_dest = true; break;
+	case GO_UPDATE:		opt_update = true; break;
+	case GO_PRESERVE:	opt_preserve = true; break;
+	case GO_IGNORE:		opt_ignore++; break;
+
+	case GO_MAX_FILE_SIZE:	err += ScanOptMaxFileSize(optarg); break;
+	case GO_TRACKS:		err += ScanOptTracks(optarg); break;
+	case GO_ARENAS:		err += ScanOptArenas(optarg); break;
+
+	case GO_ROUND:		opt_round = true; break;
+	case GO_LONG:		long_count++; break;
+	case GO_NO_HEADER:	print_header = false; break;
+	case GO_BRIEF:		brief_count++; break;
+	case GO_NO_PARAM:	print_param = false; break;
+	case GO_NO_ECHO:	opt_no_echo = true; break;
+	case GO_NO_CHECK:	opt_no_check = true; break;
+	case GO_SECTIONS:	print_sections++; break;
+
+	// no default case defined
+	//	=> compiler checks the existence of all enum values
+      }
+    }
+
+ #ifdef DEBUG
+    DumpUsedOptions(&InfoUI_wkclt,TRACE_FILE,11);
+ #endif
+    CloseTransformation();
+    NormalizeOptions( verbose > 3 && !is_env ? 2 : 0 );
+    SetupKCL();
+
+    return !err ? ERR_OK : max_error ? max_error : ERR_SYNTAX;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////                   check command                 ///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError CheckCommand ( int argc, char ** argv )
+{
+    const KeywordTab_t * cmd_ct = CheckCommandHelper(argc,argv,CommandTab);
+    if (!cmd_ct)
+	hint_exit(ERR_SYNTAX);
+
+    TRACE("COMMAND FOUND: #%lld = %s\n",(u64)cmd_ct->id,cmd_ct->name1);
+    current_command = cmd_ct;
+
+    if (!allow_all)
+    {
+	enumError err = VerifySpecificOptions(&InfoUI_wkclt,cmd_ct);
+	if (err)
+	    hint_exit(err);
+    }
+    WarnDepractedOptions(&InfoUI_wkclt);
+
+    if ( cmd_ct->id != CMD_ARGTEST )
+    {
+	argc -= optind+1;
+	argv += optind+1;
+
+	if ( cmd_ct->id == CMD_TEST )
+	    while ( argc-- > 0 )
+		AddParam(*argv++);
+	else
+	    while ( argc-- > 0 )
+		AtFileHelper(*argv++,AddParam);
+    }
+
+    enumError err = ERR_OK;
+    switch ((enumCommands)cmd_ct->id)
+    {
+	case CMD_VERSION:	version_exit();
+	case CMD_HELP:		PrintHelp(&InfoUI_wkclt,stdout,0,"HELP",0,URI_HOME,
+					first_param ? first_param->arg : 0 ); break;
+	case CMD_ARGTEST:	err = cmd_argtest(argc,argv); break;
+	case CMD_TEST:		err = cmd_test(); break;
+	case CMD_COLORS:	err = Command_COLORS(brief_count?-brief_count:long_count,0,0); break;
+	case CMD_ERROR:		err = cmd_error(); break;
+	case CMD_FILETYPE:	err = cmd_filetype(); break;
+	case CMD_FILEATTRIB:	err = cmd_fileattrib(); break;
+	case CMD_EXPORT:	err = cmd_export(); break;
+
+	case CMD_SYMBOLS:	err = DumpSymbols(SetupVarsKCL()); break;
+	case CMD_FUNCTIONS:	SetupVarsKCL(); err = ListParserFunctions(); break;
+	case CMD_CALCULATE:	err = ParserCalc(SetupVarsKCL()); break;
+	case CMD_MATRIX:	err = cmd_matrix(); break;
+	case CMD_FLOAT:		err = cmd_float(); break;
+
+	case CMD_CAT:		err = cmd_cat(); break;
+	case CMD_DECODE:	err = cmd_convert(cmd_ct->id,"DECODE","\1P/\1N.obj"); break;
+	case CMD_ENCODE:	err = cmd_convert(cmd_ct->id,"ENCODE","\1P/\1N\1?T"); break;
+	case CMD_COPY:		err = cmd_copy(); break;
+	case CMD_CFF:		err = cmd_cff(); break;
+	case CMD_FLAGS:		err = cmd_flags(); break;
+	case CMD_DUMP:		err = cmd_dump(0,CMD_DUMP); break;
+	case CMD_DBRIEF:	err = cmd_dump(1,CMD_DUMP); break;
+	case CMD_LIST:		err = cmd_dump(0,CMD_LIST); break;
+	case CMD_TRIANGLES:	err = cmd_dump(0,CMD_TRIANGLES); break;
+	case CMD_TRAVERSE:	err = cmd_traverse(false); break;
+	case CMD_FALL:		err = cmd_traverse(true); break;
+	case CMD_CHECK:		err = cmd_check(); break;
+	case CMD_ANALYZE:	err = cmd_analyze(); break;
+	case CMD_BLOW:		err = cmd_blow(); break;
+
+	// no default case defined
+	//	=> compiler checks the existence of all enum values
+
+	case CMD__NONE:
+	case CMD__N:
+	    help_exit(false);
+    }
+
+    return PrintErrorStat(err,verbose,cmd_ct->name1);
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			   main()			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+#if SZS_WRAPPER
+    int main_wkclt ( int argc, char ** argv )
+#else
+    int main ( int argc, char ** argv )
+#endif
+{
+    print_title_func = print_title;
+    SetupLib(argc,argv,WKCLT_SHORT);
+
+    //----- process arguments
+
+    if ( argc < 2 )
+    {
+	printf("\n%s\n%s\nVisit %s%s for more info.\n\n",
+		text_logo, TITLE, URI_HOME, WKCLT_SHORT );
+	hint_exit(ERR_OK);
+    }
+
+    enumError err = CheckEnvOptions("WKCLT_OPT",CheckOptions);
+    if (err)
+	hint_exit(err);
+
+    err = CheckOptions(argc,argv,false);
+    if (err)
+	hint_exit(err);
+
+    err = CheckCommand(argc,argv);
+    DUMP_TRACE_ALLOC(TRACE_FILE);
+
+    if (SIGINT_level)
+	err = ERROR0(ERR_INTERRUPT,"Program interrupted by user.");
+    return err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    END				///////////////
+///////////////////////////////////////////////////////////////////////////////