SZS v2.18a

1 files changed, 1511 insertions, 0 deletions

diff --git a/project/src/lib-xbmg.c b/project/src/lib-xbmg.c
new file mode 100644
index 0000000..3f5417e
--- /dev/null
+++ b/project/src/lib-xbmg.c
@@ -0,0 +1,1511 @@
+
+/***************************************************************************
+ *                         _______ _______ _______                         *
+ *                        |  ___  |____   |  ___  |                        *
+ *                        | |   |_|    / /| |   |_|                        *
+ *                        | |_____    / / | |_____                         *
+ *                        |_____  |  / /  |_____  |                        *
+ *                         _    | | / /    _    | |                        *
+ *                        | |___| |/ /____| |___| |                        *
+ *                        |_______|_______|_______|                        *
+ *                                                                         *
+ *                            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 <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <dirent.h>
+
+#include "lib-xbmg.h"
+#include "lib-szs.h"
+#include "dclib-utf8.h"
+#include "lib-mkw.h"
+#include "db-mkw.h"
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    MKW hooks			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static int GetTrackIndexXBMG ( uint idx, int result_on_invalid )
+{
+    return idx < BMG_N_TRACK
+		? track_pos[idx]
+		: idx < BMG_N_CT_TRACK
+		? idx
+		: result_on_invalid;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static int GetArenaIndexXBMG ( uint idx, int result_on_invalid )
+{
+    return idx < BMG_N_ARENA
+		? arena_pos[idx]
+		: result_on_invalid;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+static ccp GetContainerNameXBMG ( const bmg_t *bmg )
+{
+    DASSERT(bmg);
+
+    if ( bmg->szs && bmg->szs->fname && *bmg->szs->fname )
+    {
+	ccp name = strrchr(bmg->szs->fname,'/');
+	return name ? name + 1 : bmg->szs->fname;
+    }
+    return 0;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			   options			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void SetupBMG ( ccp opt_filter_bmg )
+{
+    DASSERT( MID_CT_END		<= MAX_FILTER_MSG );
+    DASSERT( MID_CT_CUP_END	<= MAX_FILTER_MSG );
+    DASSERT( MID_CT_TRACK_END	<= MAX_FILTER_MSG );
+    DASSERT( MID_CT_CUP_REF_END	<= MAX_FILTER_MSG );
+
+    DASSERT( MID_LE_END		<= MAX_FILTER_MSG );
+    DASSERT( MID_LE_CUP_END	<= MAX_FILTER_MSG );
+    DASSERT( MID_LE_TRACK_END	<= MAX_FILTER_MSG );
+    DASSERT( MID_LE_CUP_REF_END	<= MAX_FILTER_MSG );
+
+    //--- general setting
+
+    opt_bmg_force_count		= force_count;
+    opt_bmg_support_mkw		= true;
+    opt_bmg_support_ctcode	= ctcode_enabled;
+    opt_bmg_support_lecode	= lecode_enabled;
+    opt_bmg_rcup_fill_limit	=  0x80;
+    opt_bmg_track_fill_limit	= 0x200;
+    opt_bmg_export		= export_count > 0 ;
+ #ifdef TEST
+    opt_bmg_allow_print		= true;
+ #else
+    opt_bmg_allow_print		= verbose > 1;
+ #endif
+    opt_bmg_use_slots		= true;
+    opt_bmg_use_raw_sections	= true;
+
+    if (opt_align)
+	opt_bmg_align = ALIGN32(opt_align,4);
+
+    GetTrackIndexBMG		= GetTrackIndexXBMG;
+    GetArenaIndexBMG		= GetArenaIndexXBMG;
+    GetContainerNameBMG		= GetContainerNameXBMG;
+
+
+    //--- compatibility settings
+
+    if ( compatible < COMPAT_2_08 )
+    {
+	opt_bmg_use_slots	 = false;
+	opt_bmg_use_raw_sections = false;
+    }
+
+    if ( compatible < COMPAT_1_44 )
+    {
+	opt_bmg_old_escapes = true;
+    }
+
+    if ( compatible < COMPAT_1_39 )
+    {
+	opt_bmg_inline_attrib = false;
+	opt_bmg_color_name = BMG_CNL_BASICS;
+    }
+
+    if ( compatible < COMPAT_1_23 )
+    {
+	opt_bmg_colors = 0;
+	opt_bmg_color_name = BMG_CNL_NONE;
+    }
+
+    if (opt_filter_bmg)
+	ScanOptFilterBMG(opt_filter_bmg);
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			ScanTextBMG()			///////////////
+///////////////////////////////////////////////////////////////////////////////
+// [[obsolete]] ?
+
+static char * scan_attrib ( u8 *dest, uint size, ccp src )
+{
+    DASSERT(dest);
+    DASSERT( size <= BMG_ATTRIB_SIZE );
+    memset(dest,0,BMG_ATTRIB_SIZE);
+
+    while ( *src ==  ' ' || *src == '\t' )
+	src++;
+    const bool have_brackets = *src == '[';
+    if ( have_brackets )
+	src++;
+
+    int idx = 0, add_idx = 0;
+    for(;;)
+    {
+	while ( *src ==  ' ' || *src == '\t' )
+	    src++;
+
+	if ( *src == ',' )
+	{
+	    src++;
+	    idx++;
+	    add_idx = 0;
+	}
+	else if ( *src == '/' )
+	{
+	    src++;
+	    idx = ALIGN32(idx+1,4);
+	    add_idx = 0;
+	}
+	else if ( *src == '%' )
+	{
+	    src++;
+	    char *end;
+	    u32 num = str2ul(src,&end,16);
+	    if ( src == end )
+		break;
+
+	    idx = ALIGN32(idx+add_idx,4);
+	    noPRINT("U32[0x%02x/%02x]: %8x\n",idx,size,num);
+
+	    char buf[4];
+	    write_be32(buf,num);
+	    const int max_copy = (int)size - (int)idx;
+	    if ( max_copy > 0 )
+		memcpy(dest+idx,buf, max_copy < 4 ? max_copy : 4 );
+	    idx += 3;
+	    add_idx = 1;
+	    src = end;
+	}
+	else
+	{
+	    char *end;
+	    u8 num = str2ul(src,&end,16);
+	    if ( src == end )
+		break;
+
+	    idx += add_idx;
+	    noPRINT("U8[0x%02x/%02x]: %8x\n",idx,size,num);
+	    if ( idx < size )
+		dest[idx] = num;
+	    add_idx = 1;
+	    src = end;
+	}
+    }
+    //HexDump16(stderr,0,0,dest,size);
+
+    if ( have_brackets && *src == ']' )
+	src++;
+    return (char*)src;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			LoadXBMG()			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static int read_bmg
+(
+    struct szs_iterator_t	*it,	// iterator struct with all infos
+    bool			term	// true: termination hint
+)
+{
+    DASSERT(it);
+    DASSERT(it->szs);
+    if (term)
+	return 0;
+
+    const u8 * data = it->szs->data + it->off;
+// [[analyse-magic]]
+    file_format_t fform = GetByMagicFF(data,it->size,it->size);
+    if ( fform != FF_BMG && fform != FF_BMG_TXT )
+	return 0;
+
+    bmg_t *bmg = it->param;
+    DASSERT(bmg);
+    bmg->src_count++;
+    PRINT("BMG #%u found: %s\n",bmg->src_count,it->name);
+
+    bmg_t temp;
+    enumError err = ScanBMG(&temp,true,it->name,data,it->size);
+    if (!err)
+	PatchBMG(bmg,&temp,BMG_PM_OVERWRITE,0,true);
+    else if ( bmg->max_err < err )
+	bmg->max_err = err;
+    ResetBMG(&temp);
+
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError LoadXBMG
+(
+    bmg_t		* bmg,		// pointer to valid bmg
+    bool		initialize,	// true: initialize 'bmg'
+    ccp			fname,		// filename of source
+    bool		allow_archive,	// true: concat BMGs of archives to 1 source
+    bool		ignore_no_file	// ignore if file does not exists
+					// and return warning ERR_NOT_EXISTS
+)
+{
+    DASSERT(bmg);
+    DASSERT(fname);
+    PRINT("LoadXBMG(%p,init=%d,,aa=%d,ign=%d) fname=%s\n",
+		bmg, initialize, allow_archive, ignore_no_file, fname );
+
+    if (initialize)
+	InitializeBMG(bmg);
+    else
+	ResetBMG(bmg);
+
+    if (!strcmp(fname,"0"))
+    {
+	bmg->is_text_src = false;
+	bmg->fname = STRDUP(fname);
+	return ERR_OK;
+    }
+
+    szs_extract_t eszs;
+    enumError err = ExtractSZS(&eszs,true,fname,0,ignore_no_file);
+    if (err)
+	return err;
+
+    if (eszs.data)
+    {
+	bmg->data_alloced = eszs.data_alloced;
+	bmg->data_size	= eszs.data_size;
+	bmg->data	= eszs.data;
+	eszs.data	= 0;
+	bmg->fname	= eszs.fname;
+	eszs.fname	= 0;
+	ResetExtractSZS(&eszs);
+    }
+    else
+    {
+	szs_file_t szs; // use 'szs_file_t' for automatic decompression
+	InitializeSZS(&szs);
+	err = LoadSZS(&szs,fname,true,ignore_no_file,true);
+	if ( allow_archive && IsArchiveFF(szs.fform_arch) )
+	{
+	    bmg->src_is_arch = true;
+	    IterateFilesSZS(&szs,read_bmg,bmg,false,0,-1,SORT_NONE);
+	    bmg->fname = szs.fname;
+	    szs.fname = 0;
+	    ResetSZS(&szs);
+	    if ( !bmg->max_err && !bmg->src_count )
+		bmg->max_err = ERR_NO_SOURCE_FOUND;
+	    noPRINT("BMG/FNAME=%s\n",bmg->fname);
+	    return bmg->max_err;
+	}
+
+	bmg->data	= szs.data;
+	bmg->data_size	= szs.size;
+	bmg->data_alloced = szs.data_alloced;
+	bmg->fatt	= szs.fatt;
+	bmg->fname	= szs.fname;
+	szs.data	= 0;
+	szs.data_alloced= 0;
+	szs.fname	= 0;
+	ResetSZS(&szs);
+
+	if (err)
+	    return err;
+    }
+
+    return ScanBMG(bmg,false,0,0,0);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError ScanRawDataBMG
+(
+    bmg_t		* bmg,		// BMG data structure
+    bool		init_bmg,	// true: initialize 'bmg' first
+    struct raw_data_t	* raw		// valid raw data
+)
+{
+    DASSERT(bmg);
+    DASSERT(raw);
+
+    PRINT("BMG/FF: %u = %s\n",raw->fform,GetNameFF(raw->fform,0));
+
+    if (init_bmg)
+	InitializeBMG(bmg);
+    else
+	ResetBMG(bmg);
+    if (!raw->data)
+	return ERR_OK;
+
+    if (IsArchiveFF(raw->fform))
+    {
+	bmg->src_is_arch = true;
+	szs_file_t  szs;
+// [[fname+]]
+	AssignSZS(&szs,true,raw->data,raw->data_size,false,raw->fform,bmg->fname);
+	szs.fname = raw->fname;
+	raw->fname = 0;
+	IterateFilesSZS(&szs,read_bmg,bmg,false,0,-1,SORT_NONE);
+	bmg->fname = szs.fname;
+	szs.fname = 0;
+	noPRINT("BMG/FNAME=%s\n",bmg->fname);
+	ResetSZS(&szs);
+	if ( !bmg->max_err && !bmg->src_count )
+	    bmg->max_err = ERR_NO_SOURCE_FOUND;
+	return bmg->max_err;
+    }
+
+    return ScanBMG(bmg,init_bmg,raw->fname,raw->data,raw->data_size);
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			SaveRawXBMG()			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError SaveRawXBMG
+(
+    bmg_t		* bmg,		// pointer to valid bmg
+    ccp			fname,		// filename of destination
+    bool		set_time	// true: set time stamps
+)
+{
+    DASSERT(bmg);
+    DASSERT(fname);
+
+    return SaveRawBMG( bmg, fname,
+		GetFileModeByOpt(testmode,fname,bmg->fname), set_time );
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			SaveTextXBMG()			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError SaveTextXBMG
+(
+    bmg_t		* bmg,		// pointer to valid bmg
+    ccp			fname,		// filename of destination
+    bool		set_time	// true: set time stamps
+)
+{
+    DASSERT(bmg);
+    DASSERT(fname);
+
+    return SaveTextBMG( bmg, fname,
+		GetFileModeByOpt(testmode,fname,bmg->fname),
+		set_time, long_count > 0,
+		brief_count > 0 ? brief_count : !print_header );
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    Patching			///////////////
+///////////////////////////////////////////////////////////////////////////////
+// [[patch_bmg_cond_t]]
+
+typedef struct patch_bmg_cond_t
+{
+    bool not;		// true: enable patching, if not any mid is found
+    u32  mid[3];	// up to 3 MIDs
+}
+patch_bmg_cond_t;
+
+//-----------------------------------------------------------------------------
+
+static bmg_t *patch_bmg	 = 0;	// list with loaded BMG files for --patch-bmg
+static int n_patch_bmg	 = 0;	// number of elements of 'patch_bmg'
+int have_bmg_patch_count = 0;	// >0: have bmg patch
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptPatchMessage ( ccp arg )
+{
+    ccp eq = strchr(arg,'=');
+    if (!eq)
+	eq = strchr(arg,','); // only for compatibility, 2011-07 => leave it
+
+    char keyword[100];
+    StringCopyS(keyword,sizeof(keyword),arg);
+    if ( eq && eq-arg < sizeof(keyword) )
+	keyword[eq-arg] = 0;
+
+
+    //--- analyse condition
+
+    patch_bmg_cond_t cond;
+    cond.not = false;
+
+    char *sep = strchr(keyword,'?');
+    if (!sep)
+    {
+	 cond.not = true;
+	 sep = strchr(keyword,'!');
+    }
+
+    if (sep)
+	*sep++ = 0;
+
+
+    //--- analyse keyword
+
+    const KeywordTab_t *cmd = ScanKeyword(0,keyword,PatchKeysBMG);
+    if (!cmd)
+    {
+	ERROR0(ERR_SYNTAX,"Option --patch-bmg: Invalid patch mode: '%s'\n",keyword);
+	return 1;
+    }
+
+    if ( cmd->opt && !eq )
+    {
+	ERROR0(ERR_SYNTAX,
+		"Option --patch-bmg: Missing '=%s' for keyword '%s': %s\n",
+		cmd->opt == 1 ? "filename" : "parameter", cmd->name1, arg );
+	return 1;
+    }
+    else if ( !cmd->opt && eq )
+    {
+	ERROR0(ERR_SYNTAX,
+		"Option --patch-bmg: Parameter not allowed for '%s': %s\n",
+		cmd->name1, arg );
+	return 1;
+    }
+
+
+    //--- complete condition scanning
+
+    bool cond_valid = false;
+
+    if ( sep && *sep )
+    {
+	char *end;
+	int stat = ScanMidBMG(0,cond.mid,cond.mid+1,cond.mid+2,sep,0,&end);
+	if ( stat < 0 || *end )
+	    ERROR0(ERR_WARNING,
+		"Option --patch-bmg: Invalid message condition: %s %c %s\n",
+		cmd->name1, cond.not ? '!' : '?', sep );
+	else
+		cond_valid = stat > 0;
+	PRINT("STAT=%d, NOT=%d, MID=%x,%x,%x => valid=%d\n",
+		stat, cond.not, cond.mid[0], cond.mid[1], cond.mid[2], cond_valid );
+    }
+
+
+    //--- store record
+
+    patch_bmg_cond_t *pcond = cond_valid ? ALLOCDUP(&cond,sizeof(cond)) : 0;
+
+    const uint num = cmd->id | cmd->opt << BMG_PM__SHIFT_OPT;
+    if ( cmd->opt == 2 )
+    {
+	char buf[10000];
+	ScanEscapedString(buf,sizeof(buf),eq+1,-1,true,0,0);
+	AppendParamField(&patch_bmg_list,buf,false,num,pcond);
+    }
+    else if (cmd->opt)
+	AppendParamField(&patch_bmg_list,eq+1,false,num,pcond);
+    else
+	AppendParamField(&patch_bmg_list,EmptyString,true,num,pcond);
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptMacroBMG ( ccp arg )
+{
+
+    bmg_t temp;
+    enumError stat = LoadXBMG(&temp,true,arg,true,false);
+    if (!stat)
+    {
+	if (!bmg_macros)
+	{
+	    bmg_macros = MALLOC(sizeof(*bmg_macros));
+	    InitializeBMG(bmg_macros);
+	}
+	PatchOverwriteBMG(bmg_macros,&temp,true);
+    }
+
+    ResetBMG(&temp);
+    return stat != ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError SetupPatchingListBMG()
+{
+    uint max_err = ERR_OK;
+
+    if ( n_patch_bmg != patch_bmg_list.used )
+    {
+	if (n_patch_bmg)
+	    have_patch_count--, have_bmg_patch_count--;
+
+	ResetPatchingListBMG();
+	n_patch_bmg = patch_bmg_list.used;
+	patch_bmg = CALLOC(n_patch_bmg,sizeof(*patch_bmg));
+
+	int i;
+	for ( i = 0; i < n_patch_bmg; i++ )
+	{
+	    ParamFieldItem_t *pi = patch_bmg_list.field + i;
+	    if ( pi->num >> BMG_PM__SHIFT_OPT == 1 )
+	    {
+		enumError err = LoadXBMG(patch_bmg+i,true,pi->key,true,false);
+		if ( err > ERR_WARNING && err > max_err )
+		    max_err = err;
+	    }
+	}
+
+	if (n_patch_bmg)
+	    have_patch_count++, have_bmg_patch_count++;
+    }
+
+    return max_err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetPatchingListBMG()
+{
+    int i;
+    for ( i = 0; i < n_patch_bmg; i++ )
+	ResetBMG(patch_bmg+i);
+    FREE(patch_bmg);
+    patch_bmg = 0;
+    n_patch_bmg = 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError UsePatchingListBMG ( bmg_t * dest )
+{
+    if (!n_patch_bmg)
+	SetupPatchingListBMG();
+    DASSERT( n_patch_bmg == patch_bmg_list.used );
+
+    int i;
+    enumError stat = ERR_OK;
+    for ( i = 0; i < n_patch_bmg; i++ )
+    {
+	ParamFieldItem_t *pi = patch_bmg_list.field + i;
+	if (pi->data)
+	{
+	    patch_bmg_cond_t *cond = pi->data;
+	    bool found = 0;
+	    uint i;
+	    for ( i = 0; !found && i < sizeof(cond->mid)/sizeof(*cond->mid); i++ )
+		found = cond->mid[i] && FindItemBMG(dest,cond->mid[i]);
+
+	    PRINT("COND FOUND: mid=%x,%x,%x, not=%d => found=%d => %s\n",
+			cond->mid[0], cond->mid[1], cond->mid[2], cond->not,
+			found, found^cond->not ? "EXEC" : "SKIP" );
+
+	    if (!(found^cond->not))
+		continue;
+	}
+
+	enumError err = PatchBMG( dest, patch_bmg+i,
+					pi->num & BMG_PM__MASK_CMD, pi->key, false );
+	if ( err > ERR_WARNING )
+	    return err;
+	if ( err == ERR_DIFFER )
+	    stat = ERR_DIFFER;
+    }
+
+    if (opt_points_used)
+    {
+	char buf[500];
+	strcpy(buf,"points=");
+	PrintMkwPointsLIST(buf+7,sizeof(buf)-7,MkwPointsTab,2);
+
+	bmg_item_t * dptr = InsertItemBMG(dest,MID_VERSUS_POINTS,0,0,0);
+	if (dptr)
+	    AssignItemTextBMG(dptr,buf,-1);
+    }
+
+    if (filter_message)
+    {
+	bmg_item_t * dptr = dest->item;
+	bmg_item_t * dend = dptr + dest->item_used;
+
+	bool dirty = false;
+	for ( ; dptr < dend; dptr++ )
+	{
+	    if ( dptr->mid >= MAX_FILTER_MSG || !filter_message[dptr->mid] )
+	    {
+		FreeItemBMG(dptr);
+		dptr->text  = 0;
+		ResetAttribBMG(dest,dptr);
+		dirty = true;
+	    }
+	}
+	if ( dirty && stat < ERR_DIFFER )
+	    stat = ERR_DIFFER;
+    }
+
+    return stat;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint ListPatchingListBMG ( FILE *f, int indent, ccp title )
+{
+    DASSERT(f);
+    if (!patch_bmg_list.used)
+	return 0;
+
+    indent = NormalizeIndent(indent);
+
+    if (title && *title)
+	fprintf(f,"%*s%s [N=%u]\n",indent,"",title,patch_bmg_list.used);
+    indent += 3;
+
+    uint i;
+    for ( i = 0; i < patch_bmg_list.used; i++ )
+    {
+	ParamFieldItem_t *pi = patch_bmg_list.field + i;
+	fprintf(f,"%*s%-9s",indent,"",GetPatchNameBMG(pi->num));
+
+	char buf[1000];
+	PrintEscapedString(buf,sizeof(buf),pi->key,-1,CHMD__ALL,0,0);
+	switch( pi->num >> BMG_PM__SHIFT_OPT )
+	{
+	    case 1: fprintf(f," file: %s\n",buf); break;
+	    case 2: fprintf(f," parameter: %s\n",buf); break;
+	    default: fputc('\n',f); break;
+	}
+    }
+
+    return patch_bmg_list.used;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp GetPatchNameBMG ( uint cmd )
+{
+    cmd &= BMG_PM__MASK_CMD;
+    const KeywordTab_t *kt;
+    for ( kt = PatchKeysBMG; kt->name1; kt++ )
+	if ( kt->id == cmd )
+	    return kt->name1;
+
+    const uint buf_size = 6;
+    char *buf = GetCircBuf(buf_size);
+    snprintf(buf,buf_size,"[%u]",cmd);
+    return buf;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			   DiffBMG()			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static void print_only_in
+(
+    uint		index,		// index of relevant bmg (1|2)
+    const bmg_item_t	* bi,		// relevant bmg item
+    int			width		// width out output lines
+)
+{
+    DASSERT(bi);
+    char msg[300], attrib[BMG_ATTRIB_BUF_SIZE], text[1000];
+    PrintAttribBMG(attrib,sizeof(attrib),bi->attrib,bi->attrib_used,0,true);
+    const int msg_len = snprintfS(msg,sizeof(msg),
+			"* Only in source #%u:%6x %s",
+			index, bi->mid, attrib );
+
+    width -= msg_len + 7;
+    if ( width <= 0 )
+	printf("%s\n",msg);
+    else
+    {
+	PrintString16BMG(text,sizeof(text),bi->text,bi->len,
+			BMG_UTF8_MAX_DIFF,0,opt_bmg_colors);
+	printf("%s %.*s\n",msg,width,text);
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void print_differ
+(
+    const bmg_item_t	* bi1,		// first bmg item
+    const bmg_item_t	* bi2,		// second bmg item
+    ccp			message,	// differ message
+    bool		text_differ,	// true: print text of both
+    int			width		// width out output lines
+)
+{
+    DASSERT(bi1);
+    DASSERT(bi2);
+    DASSERT( bi1->mid == bi2->mid );
+
+    char attrib1[BMG_ATTRIB_BUF_SIZE], attrib2[BMG_ATTRIB_BUF_SIZE];
+    PrintAttribBMG(attrib1,sizeof(attrib1),bi1->attrib,bi1->attrib_used,0,true);
+    PrintAttribBMG(attrib2,sizeof(attrib2),bi2->attrib,bi2->attrib_used,0,true);
+
+    char msg[50+2*BMG_ATTRIB_BUF_SIZE], text[1000];
+    const int msg_len = !strcmp(attrib1,attrib2)
+	? snprintf(msg,sizeof(msg),
+			"* %-18s%6x %s", message, bi1->mid, attrib1 )
+	: snprintf(msg,sizeof(msg),
+			"* %-18s%6x %s %s", message, bi1->mid, attrib1, attrib2 );
+
+    if (text_differ)
+    {
+	width -= 8;
+	if ( width < 20 )
+	     width = 20;
+
+	printf("%s\n",msg);
+	int min_len, max_len;
+	if ( bi1->len < bi2->len )
+	{
+	    min_len = bi1->len;
+	    max_len = bi2->len;
+	}
+	else
+	{
+	    min_len = bi2->len;
+	    max_len = bi1->len;
+	}
+
+	u16 *t1 = bi1->text;
+	u16 *t2 = bi2->text;
+	u16 *end = t1 + min_len;
+	while ( t1 < end && *t1 == *t2 )
+	    t1++, t2++;
+	int diff_idx = t1 - bi1->text;
+
+	if ( diff_idx > max_len - width/2 )
+	     diff_idx = max_len - width/2;
+	if ( diff_idx < 0 )
+	     diff_idx = 0;
+
+	PrintString16BMG(text,sizeof(text), bi1->text+diff_idx,
+			bi1->len-diff_idx, BMG_UTF8_MAX_DIFF, 0, opt_bmg_colors );
+	printf("    1: %.*s\n",width,text);
+	PrintString16BMG(text,sizeof(text), bi2->text+diff_idx,
+			bi2->len-diff_idx, BMG_UTF8_MAX_DIFF, 0, opt_bmg_colors );
+	printf("    2: %.*s\n",width,text);
+    }
+    else
+    {
+	width -= msg_len + 7;
+	if ( width <= 0 )
+	    printf("%s\n",msg);
+	else
+	{
+	    PrintString16BMG(text,sizeof(text),bi1->text,bi1->len,
+				BMG_UTF8_MAX,0,opt_bmg_colors);
+	    printf("%s %.*s\n",msg,width,text);
+	}
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError DiffBMG
+(
+    const bmg_t		* bmg1,		// first bmg
+    const bmg_t		* bmg2,		// second bmg
+    bool		quiet,		// true: be quiet
+    int			width		// width out output lines
+)
+{
+    PRINT("DiffSZS(%p,%p,%d,%d)\n",bmg1,bmg2,quiet,width);
+    DASSERT(bmg1);
+    DASSERT(bmg2);
+
+
+    const bmg_item_t * p1 = bmg1->item;
+    const bmg_item_t * e1 = p1 + bmg1->item_used;
+    const bmg_item_t * p2 = bmg2->item;
+    const bmg_item_t * e2 = p2 + bmg2->item_used;
+
+    PRINT("PTR: %p..%p/%u, %p..%p/%u\n",
+		p1, e1, bmg1->item_used,
+		p2, e2, bmg2->item_used );
+
+    int differ = 0;
+    while ( p1 && p1 < e1 && p2 && p2 < e2 )
+    {
+	noPRINT("\t%s : %s\n",p1->path,p2->path);
+
+	if ( p1->mid < p2->mid )
+	{
+	    if (quiet)
+		return ERR_DIFFER;
+	    differ++;
+	    print_only_in(1,p1,width);
+	    p1++;
+	    continue;
+	}
+
+	if ( p1->mid > p2->mid )
+	{
+	    if (quiet)
+		return ERR_DIFFER;
+	    differ++;
+	    print_only_in(2,p2,width);
+	    p2++;
+	    continue;
+	}
+
+	const bool attrib_differ
+		=  p1->attrib_used != p2->attrib_used
+		|| memcmp(p1->attrib,p2->attrib,p1->attrib_used);
+	if ( p1->len != p2->len
+		|| memcmp(p1->text,p2->text,p1->len*sizeof(*p1->text)) )
+	{
+	    if (quiet)
+		return ERR_DIFFER;
+	    differ++;
+	    ccp msg = attrib_differ ? "Text+attr differ:" : "Text differ:";
+	    print_differ(p1,p2,msg,true,width);
+	}
+	else if ( attrib_differ )
+	{
+	    if (quiet)
+		return ERR_DIFFER;
+	    differ++;
+	    print_differ(p1,p2,"Attributes differ:",false,width);
+	}
+
+	p1++;
+	p2++;
+    }
+
+    while ( p1 && p1 < e1 )
+    {
+	if (quiet)
+	    return ERR_DIFFER;
+	differ++;
+	print_only_in(1,p1,width);
+	p1++;
+    }
+
+    while ( p2 && p2 < e2 )
+    {
+	if (quiet)
+	    return ERR_DIFFER;
+	differ++;
+	print_only_in(2,p2,width);
+	p2++;
+    }
+
+    return differ ? ERR_DIFFER : ERR_OK;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			   ScanOptLoadBMG()		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+bmg_t opt_load_bmg = {0};
+bool opt_patch_names = false;
+
+//-----------------------------------------------------------------------------
+
+int ScanOptLoadBMG ( ccp arg )
+{
+    if ( !arg || !*arg )
+	return 0;
+
+    bmg_t temp;
+    enumError err = LoadXBMG(&temp,true,arg,true,false);
+    if (!err)
+	PatchBMG(&opt_load_bmg,&temp,BMG_PM_OVERWRITE,0,true);
+    ResetBMG(&temp);
+    return err > ERR_WARNING;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			ScanOptFilterBMG()		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+u8 * filter_message = 0; // NULL or field with 'MAX_FILTER_MSG' elements
+
+//-----------------------------------------------------------------------------
+
+enum
+{
+    MD_NONE, MD_ID, MD_PARAM, MD_GENERIC, MD_ALL, MD_CHAT,
+
+                MD_CUPS,    MD_TRACKS,    MD_ARENAS,
+    MD_CTCODE,  MD_CTCUPS,  MD_CTTRACKS,  MD_CTARENAS,  MD_CTREFS,
+    MD_LECODE,  MD_LECUPS,  MD_LETRACKS,  MD_LEARENAS,  MD_LEREFS,
+    MD_XCODE,   MD_XCUPS,   MD_XTRACKS,   MD_XARENAS,   MD_XREFS,
+    MD_ALLCODE, MD_ALLCUPS, MD_ALLTRACKS, MD_ALLARENAS, MD_ALLREFS,
+};
+
+//-----------------------------------------------------------------------------
+
+static void ScanOptMsgJob ( int mode, u8 value )
+{
+    if ( mode >= MD_XCODE && mode <= MD_XREFS )
+    {
+	if (opt_bmg_support_lecode)
+	    mode = mode - MD_XCODE + MD_LECODE;
+	else if (opt_bmg_support_ctcode)
+	    mode = mode - MD_XCODE + MD_CTCODE;
+    }
+
+    switch(mode)
+    {
+	case MD_NONE:
+	    PRINT("SET ALL = %d\n",!value);
+	    memset(filter_message,!value,MAX_FILTER_MSG);
+	    break;
+
+	case MD_ID:
+	    filter_message[MID_PARAM_IDENTIFY] = value;
+	    break;
+
+	case MD_PARAM:
+	    filter_message[MID_PARAM_IDENTIFY] = value;
+	    memset( filter_message + MID_PARAM_BEG, value,
+		    MID_PARAM_END - MID_PARAM_BEG );
+	    break;
+
+	case MD_CUPS:
+	    PRINT("SET CUPS = %d\n",value);
+	    memset( filter_message + MID_RCUP_BEG, value,
+		    MID_RCUP_END - MID_RCUP_BEG );
+	    memset( filter_message + MID_BCUP_BEG, value,
+		    MID_BCUP_END - MID_BCUP_BEG );
+	    ScanOptMsgJob(MD_XCUPS,value);
+	    ScanOptMsgJob(MD_XREFS,value);
+	    break;
+
+	case MD_TRACKS:
+	    PRINT("SET TRACKS = %d\n",value);
+	    memset(filter_message+MKW_TRACK_MID_1,value,MKW_N_TRACKS);
+	    memset(filter_message+MKW_TRACK_MID_2,value,MKW_N_TRACKS);
+	    ScanOptMsgJob(MD_XTRACKS,value);
+	    ScanOptMsgJob(MD_XREFS,value);
+	    break;
+
+	case MD_ARENAS:
+	    PRINT("SET ARENAS = %d\n",value);
+	    memset(filter_message+MKW_ARENA_MID_1,value,MKW_N_ARENAS);
+	    memset(filter_message+MKW_ARENA_MID_2,value,MKW_N_ARENAS);
+	    ScanOptMsgJob(MD_XARENAS,value);
+	    break;
+
+	case MD_CHAT:
+	    PRINT("SET CHAT = %d\n",value);
+	    memset(filter_message+MID_CHAT_BEG,value,BMG_N_CHAT);
+	    break;
+
+    //-- ct-code
+
+	case MD_CTCODE:
+	    PRINT("SET CT-CODE = %d\n",value);
+	    memset( filter_message + MID_CT_BEG, value,
+		    MID_CT_END - MID_CT_BEG );
+	    break;
+
+	case MD_CTCUPS:
+	    PRINT("SET CT-CUPS = %d\n",value);
+	    memset( filter_message + MID_CT_CUP_BEG, value,
+		    MID_CT_CUP_END - MID_CT_CUP_BEG );
+	    break;
+
+	case MD_CTTRACKS:
+	    PRINT("SET CT-TRACKS = %d\n",value);
+	    memset( filter_message + MID_CT_TRACK_BEG, value,
+		    MID_CT_TRACK_END - MID_CT_TRACK_BEG );
+	    break;
+
+	case MD_CTARENAS:
+	    PRINT("SET CT-ARENAS = %d\n",value);
+	    memset( filter_message + MID_CT_ARENA_BEG, value,
+		    MID_CT_ARENA_END - MID_CT_ARENA_BEG );
+	    break;
+
+	case MD_CTREFS:
+	    PRINT("SET CT-REFS = %d\n",value);
+	    memset( filter_message + MID_CT_CUP_REF_BEG, value,
+		    MID_CT_CUP_REF_END - MID_CT_CUP_REF_BEG );
+	    break;
+
+    //-- le-code
+
+	case MD_LECODE:
+	    PRINT("SET LE-CODE = %d\n",value);
+	    memset( filter_message + MID_LE_BEG,
+		    value, MID_LE_END - MID_LE_BEG );
+	    break;
+
+	case MD_LECUPS:
+	    PRINT("SET LE-CUPS = %d\n",value);
+	    memset( filter_message + MID_LE_CUP_BEG, value,
+		    MID_LE_CUP_END - MID_LE_CUP_BEG );
+	    break;
+
+	case MD_LETRACKS:
+	    PRINT("SET LE-TRACKS = %d\n",value);
+	    memset( filter_message + MID_LE_TRACK_BEG, value,
+		    MID_LE_TRACK_END - MID_LE_TRACK_BEG );
+	    break;
+
+	case MD_LEARENAS:
+	    PRINT("SET LE-ARENAS = %d\n",value);
+	    memset( filter_message + MID_LE_ARENA_BEG, value,
+		    MID_LE_ARENA_END - MID_LE_ARENA_BEG );
+	    break;
+
+	case MD_LEREFS:
+	    PRINT("SET LE-REFS = %d\n",value);
+	    memset( filter_message + MID_LE_CUP_REF_BEG, value,
+		    MID_LE_CUP_REF_END - MID_LE_CUP_REF_BEG );
+	    break;
+
+    //-- all*
+
+	case MD_ALLCODE:
+	    ScanOptMsgJob(MD_CTCODE,value);
+	    ScanOptMsgJob(MD_LECODE,value);
+	    break;
+
+	case MD_ALLCUPS:
+	    ScanOptMsgJob(MD_CUPS,value);
+	    ScanOptMsgJob(MD_CTCUPS,value);
+	    ScanOptMsgJob(MD_LECUPS,value);
+	    break;
+
+	case MD_ALLTRACKS:
+	    ScanOptMsgJob(MD_TRACKS,value);
+	    ScanOptMsgJob(MD_CTTRACKS,value);
+	    ScanOptMsgJob(MD_LETRACKS,value);
+	    break;
+
+	case MD_ALLARENAS:
+	    ScanOptMsgJob(MD_ARENAS,value);
+	    ScanOptMsgJob(MD_CTARENAS,value);
+	    ScanOptMsgJob(MD_LEARENAS,value);
+	    break;
+
+	case MD_ALLREFS:
+	    ScanOptMsgJob(MD_CTREFS,value);
+	    ScanOptMsgJob(MD_LEREFS,value);
+	    break;
+
+
+    //-- misc
+
+	case MD_GENERIC:
+	    PRINT("SET GENRIC = %d\n",value);
+	    memset(filter_message+MID_GENERIC_BEG,value,BMG_N_GENERIC);
+	    break;
+
+	case MD_ALL:
+	    PRINT("SET ALL = %d\n",value);
+	    memset(filter_message,value,MAX_FILTER_MSG);
+	    break;
+    }
+}
+
+//-----------------------------------------------------------------------------
+
+int ScanOptFilterBMG ( ccp arg )
+{
+    // >>> see SetupBMG() for MID assertions!
+
+    if ( !arg || !*arg )
+	return 0;
+
+    if (!filter_message)
+    {
+	while ( *arg > 0 && *arg <= ' ' )
+	    arg++;
+
+	PRINT("FILTER-MESSAGE: ALLOC SET %d\n",*arg == '-');
+	filter_message = MALLOC(MAX_FILTER_MSG);
+	memset( filter_message, *arg == '-', MAX_FILTER_MSG );
+    }
+
+    //------------------------------------------------------------------
+    // MD_CTCODE..MD_CTREFS & MD_LECODE..MD_LEREFS & MD_XCODE..MD_XREFS
+    // must have the same order to support X-calcualtions below!
+    //------------------------------------------------------------------
+
+    static const KeywordTab_t opt_msg[] =
+    {
+	{ MD_NONE,	"NONE",			0,	0 },
+	{ MD_ID,	"IDENTIFICATION",	"ID",	0 },
+	{ MD_PARAM,	"PARAM",		0,	0 },
+	 { MD_GENERIC,	"GENERIC",		0,	0 },
+	 { MD_ALL,	"ALL",			0,	0 },
+	{ MD_CUPS,	"CUPS",			0,	0 },
+	{ MD_TRACKS,	"TRACKS",		0,	0 },
+	{ MD_ARENAS,	"ARENAS",		0,	0 },
+	{ MD_CHAT,	"CHAT",			0,	0 },
+	 { MD_CTCODE,	"CTCODE",		"CT",	0 },
+	 { MD_CTCUPS,	"CTCUPS",		0,	0 },
+	 { MD_CTTRACKS,	"CTTRACKS",		0,	0 },
+	 { MD_CTARENAS,	"CTARENAS",		0,	0 },
+	 { MD_CTREFS,	"CTREFS",		0,	0 },
+	{ MD_LECODE,	"LECODE",		"LE",	0 },
+	{ MD_LECUPS,	"LECUPS",		0,	0 },
+	{ MD_LETRACKS,	"LETRACKS",		0,	0 },
+	{ MD_LEARENAS,	"LEARENAS",		0,	0 },
+	{ MD_LEREFS,	"LEREFS",		0,	0 },
+	 { MD_XCODE,	"XCODE",		"X",	0 },
+	 { MD_XCUPS,	"XCUPS",		0,	0 },
+	 { MD_XTRACKS,	"XTRACKS",		0,	0 },
+	 { MD_XARENAS,	"XARENAS",		0,	0 },
+	 { MD_XREFS,	"XREFS",		0,	0 },
+	{ MD_ALLCODE,	"ALLCODE",		0,	0 },
+	{ MD_ALLCUPS,	"ALLCUPS",		0,	0 },
+	{ MD_ALLTRACKS,	"ALLTRACKS",		0,	0 },
+	{ MD_ALLARENAS,	"ALLARENAS",		0,	0 },
+	{ MD_ALLREFS,	"ALLREFS",		0,	0 },
+	{0,0,0,0}
+    };
+
+    for(;;)
+    {
+	while ( *arg > 0 && *arg <= ' ' || *arg == ',' || *arg == '+' )
+	    arg++;
+	if (!*arg)
+	    break;
+
+	const u8 value = *arg != '-';
+	if (!value)
+	    arg++;
+
+	char keyname[20], *dest = keyname;
+	while (isalnum((int)*arg))
+	{
+	    if ( dest < keyname + sizeof(keyname)-1 )
+		*dest++ = *arg;
+	    arg++;
+	}
+	*dest = 0;
+
+	if ( dest > keyname+1 )
+	{
+	    const KeywordTab_t * key = ScanKeyword(0,keyname,opt_msg);
+	    if (key)
+	    {
+		ScanOptMsgJob(key->id,value);
+		continue;
+	    }
+	}
+
+	u32 a1, a2, a3;
+	if ( ScanMidBMG(0,&a1,&a2,&a3,keyname,dest,0) < 1 )
+	{
+	    ERROR0(ERR_SYNTAX,"Option --msg: Invalid parameter: %s\n",keyname);
+	    return 1;
+	}
+	if (!a2)
+	    a2 = a1;
+	if (!a3)
+	    a3 = a1;
+
+	while ( *arg > 0 && *arg <= ' ' )
+	    arg++;
+	if ( *arg != ':' )
+	{
+	    PRINT("MID FOUND: %x,%x,%x := %u\n",a1,a2,a3,value);
+	    if ( a1 < MAX_FILTER_MSG )
+		filter_message[a1] = value;
+	    if ( a2 < MAX_FILTER_MSG )
+		filter_message[a2] = value;
+	    if ( a3 < MAX_FILTER_MSG )
+		filter_message[a3] = value;
+	    continue;
+	}
+	arg++;
+
+	u32 b1, b2, b3;
+	if ( ScanMidBMG(0,&b1,&b2,&b3,arg,0,(char**)&arg) < 1 )
+	{
+	    ERROR0(ERR_SYNTAX,"Option --msg: Invalid parameter: %s\n",keyname);
+	    return 1;
+	}
+	if (!b2)
+	    b2 = b1;
+	if (!b3)
+	    b3 = b1;
+
+	PRINT("MID FOUND: %x..%x, %x..%x, %x..%x := %u\n",a1,b1,a2,b2,a3,b3,value);
+
+	if ( ++b1 > MAX_FILTER_MSG )
+	    b1 = MAX_FILTER_MSG;
+	if ( a1 < b1 )
+	    memset( filter_message+a1, value, b1-a1 );
+
+	if ( ++b2 > MAX_FILTER_MSG )
+	    b2 = MAX_FILTER_MSG;
+	if ( a2 < b2 )
+	    memset( filter_message+a2, value, b2-a2 );
+
+	if ( ++b3 > MAX_FILTER_MSG )
+	    b3 = MAX_FILTER_MSG;
+	if ( a3 < b3 )
+	    memset( filter_message+a3, value, b3-a3 );
+    }
+
+    if ( logging > 1 )
+	HexDump016(stderr,0,0,filter_message,MAX_FILTER_MSG);
+
+    return 0;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			 cmd_bmg_cat()			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError cmd_bmg_cat ( bool mix )
+{
+    stdlog = stderr;
+
+    enumError err = SetupPatchingListBMG();
+    if ( err > ERR_WARNING )
+	return err;
+
+    bmg_t mix_bmg;
+    InitializeBMG(&mix_bmg);
+
+    raw_data_t raw;
+    InitializeRawData(&raw);
+
+    uint mix_count = 0;
+    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,0,opt_ignore>0,FF_BMG);
+
+	if ( err == ERR_NOT_EXISTS || err > ERR_WARNING && opt_ignore )
+	    continue;
+	if ( err > ERR_WARNING )
+	    return err;
+
+	if ( verbose >= 0 || testmode )
+	    fprintf(stdlog,"%sCAT %s:%s\n",
+			verbose > 0 ? "\n" : "",
+			GetNameFF(raw.fform,0), raw.fname );
+
+	bmg_t bmg;
+	err = ScanRawDataBMG(&bmg,true,&raw);
+	if ( err > ERR_WARNING )
+	    return err;
+
+	err = UsePatchingListBMG(&bmg);
+	if ( err > ERR_WARNING )
+	    return err;
+
+	if (mix)
+	{
+	    PatchBMG(&mix_bmg,&bmg,BMG_PM_OVERWRITE,0,true);
+	    mix_count++;
+	}
+	else if (!testmode)
+	{
+	    err = SaveTextXBMG(&bmg,"-",false);
+	    fflush(stdout);
+	    if ( err > ERR_WARNING )
+		return err;
+	}
+	ResetBMG(&bmg);
+    }
+
+    if ( !testmode && mix )
+    {
+	if (!mix_count)
+	{
+	    err = UsePatchingListBMG(&mix_bmg);
+	    if ( err > ERR_WARNING )
+		return err;
+	}
+
+	err = SaveTextXBMG(&mix_bmg,"-",false);
+	fflush(stdout);
+	if ( err > ERR_WARNING )
+	    return err;
+    }
+
+    ResetBMG(&mix_bmg);
+    ResetRawData(&raw);
+    return cmd_err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			 cmd_bmg_identifier()		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError cmd_bmg_identifier()
+{
+    stdlog = stderr;
+
+    ct_bmg_t ctb;
+    SetupCtBMG(&ctb,CTM_OPTIONS,CTM_OPTIONS);
+
+    bmg_t bmg;
+    InitializeBMG(&bmg);
+    PatchIdentificationBMG(&bmg,&ctb);
+    SaveTextXBMG(&bmg,"-",false);
+    fflush(stdout);
+
+    ResetBMG(&bmg);
+    ResetCtBMG(&ctb);
+    return ERR_OK;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    scan options		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptBmgEncoding ( ccp arg )
+{
+    const KeywordTab_t *cmd = ScanKeyword(0,arg,TabEncodingBMG);
+    if (!cmd)
+    {
+	ERROR0(ERR_SYNTAX,
+		"Option --bmg-encoding: Invalid mode: '%s'\n",arg);
+	return 1;
+    }
+
+    if (cmd->opt)
+	ERROR0(ERR_WARNING,
+		"Option --bmg-encoding: Mode »%s« not supported yet!\n",
+		GetEncodingNameBMG(cmd->id,"?") );
+
+    opt_bmg_encoding = cmd->id;
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptBmgInfSize ( ccp arg, bool is_wbmgt )
+{
+    if ( !arg || !*arg )
+    {
+	opt_bmg_inf_size = 0;
+	return 0;
+    }
+
+    char *end;
+    uint num = str2ul(arg,&end,10);
+    if ( end == arg || *end )
+    {
+	ERROR0(ERR_SYNTAX,
+		"Option --%sinf-size: Not a number: %s\n",
+		is_wbmgt ? "" : "bmg-", arg );
+	return 1;
+    }
+
+    if ( num < 4 || num > BMG_INF_LIMIT )
+    {
+	ERROR0(ERR_SEMANTIC,
+		"Option --%sinf-size: Number must be in range 4..%u: %s\n",
+		is_wbmgt ? "" : "bmg-", BMG_INF_LIMIT, arg );
+	return 1;
+    }
+    opt_bmg_inf_size = num;
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptBmgMid ( ccp arg )
+{
+    const int stat = ScanKeywordOffAutoOn(arg,OFFON_ON,OFFON_FORCE,"Option --bmg-mid");
+    if ( stat == OFFON_ERROR )
+	return 1;
+
+    opt_bmg_mid = stat;
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static int scan_opt_attrib ( bool *flag, u8* attrib, ccp opt, ccp arg )
+{
+    DASSERT(flag);
+    DASSERT(attrib);
+    DASSERT(opt);
+
+    *flag = false;
+    memset(attrib,0,BMG_ATTRIB_SIZE);
+    if ( !arg || !*arg )
+	return 0;
+
+    ccp end = scan_attrib(attrib,BMG_ATTRIB_SIZE,arg);
+    if (end)
+	while ( *end == ' ' || *end == '\t' )
+	    end++;
+    if ( !end || *end )
+    {
+	ERROR0(ERR_SYNTAX,
+		"Option --%s: Invalid attribute vector: %s\n", opt, arg );
+	return 1;
+    }
+
+    *flag = true;
+    return 0;
+}
+
+//-----------------------------------------------------------------------------
+
+int ScanOptForceAttrib ( ccp arg )
+{
+    return scan_opt_attrib(&opt_bmg_force_attrib,bmg_force_attrib,"force-attrib",arg);
+}
+
+//-----------------------------------------------------------------------------
+
+int ScanOptDefAttrib ( ccp arg )
+{
+    return scan_opt_attrib(&opt_bmg_def_attrib,bmg_def_attrib,"def-attrib",arg);
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    END				///////////////
+///////////////////////////////////////////////////////////////////////////////