diff options
Diffstat (limited to '')
| -rwxr-xr-x | project/dclib/lib-bmg.c | 6346 |
1 files changed, 6346 insertions, 0 deletions
diff --git a/project/dclib/lib-bmg.c b/project/dclib/lib-bmg.c new file mode 100755 index 0000000..4e42c9c --- /dev/null +++ b/project/dclib/lib-bmg.c @@ -0,0 +1,6346 @@ + +/*************************************************************************** + * * + * _____ ____ * + * | __ \ / __ \ _ _ _____ * + * | | \ \ / / \_\ | | | | _ \ * + * | | \ \| | | | | | |_| | * + * | | | || | | | | | ___/ * + * | | / /| | __ | | | | _ \ * + * | |__/ / \ \__/ / | |___| | |_| | * + * |_____/ \____/ |_____|_|_____/ * + * * + * Wiimms source code library * + * * + *************************************************************************** + * * + * Copyright (c) 2012-2020 by Dirk Clemens <wiimm@wiimm.de> * + * * + *************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * See file gpl-2.0.txt or http://www.gnu.org/licenses/gpl-2.0.txt * + * * + ***************************************************************************/ + +#define _GNU_SOURCE 1 +#include <errno.h> + +#include "lib-bmg.h" +#include "dclib-utf8.h" +#include "dclib-xdump.h" + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// compiler options /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#if 1 + #define ENABLE_BMG_REGEX 1 +#else + #define ENABLE_BMG_REGEX 0 +#endif + +#if ENABLE_BMG_REGEX + #include "dclib-regex.h" +#endif + +//----------------------------------------------------------------------------- + +#if defined(TEST) || defined(DEBUG) || HAVE_WIIMM_EXT + #define COMPARE_CREATE 1 // 0=off, 1=on +#else + #define COMPARE_CREATE 0 +#endif + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// global bmg options /////////////// +/////////////////////////////////////////////////////////////////////////////// + +uint opt_bmg_force_count = 0; // >0: force some operations +uint opt_bmg_align = 0x20; // alignment of raw-bg sections +bool opt_bmg_export = 0; // true: optimize for exports +bool opt_bmg_no_attrib = 0; // true: suppress attributes +bool opt_bmg_x_escapes = 0; // true: use x-scapes insetad of z-escapes +bool opt_bmg_old_escapes = 0; // true: use only old escapes +int opt_bmg_single_line = 0; // >0: single line, >1: suppress atrributes +bool opt_bmg_support_mkw = 0; // true: support MKW specific extensions +bool opt_bmg_support_ctcode = 0; // true: support MKW/CT-CODE specific extensions +bool opt_bmg_support_lecode = 0; // true: support MKW/LE-CODE specific extensions +uint opt_bmg_rcup_fill_limit = 0; // >0: limit racing cups to reduce BMG size +uint opt_bmg_track_fill_limit= 0; // >0: limit tracks to reduce BMG size +bool opt_bmg_inline_attrib = true; // true: print attrinbutes inline +int opt_bmg_colors = 1; // use c-escapss: 0:off, 1:auto, 2:on +ColNameLevelBMG opt_bmg_color_name = BMG_CNL_ALL; +uint opt_bmg_max_recurse = 10; // max recurse depth +bool opt_bmg_allow_print = 0; // true: allow '$' to print a log message +bool opt_bmg_use_slots = 0; // true: use predifined slots +bool opt_bmg_use_raw_sections= 0; // true: use raw sections + +//----------------------------------------------------------------------------- + +int opt_bmg_encoding = BMG_ENC__UNDEFINED; +uint opt_bmg_inf_size = 0; +OffOn_t opt_bmg_mid = OFFON_AUTO; +bool opt_bmg_force_attrib = false; +bool opt_bmg_def_attrib = false; + +u8 bmg_force_attrib[BMG_ATTRIB_SIZE]; +u8 bmg_def_attrib[BMG_ATTRIB_SIZE]; + +bmg_t *bmg_macros = 0; + +//----------------------------------------------------------------------------- + +const KeywordTab_t PatchKeysBMG[] = +{ + // 'opt' + // 0: no param + // 1: file param + // 2: string param + + { BMG_PM_PRINT, "PRINT", 0, 1 }, + { BMG_PM_FORMAT, "FORMAT", 0, 2 }, + #if ENABLE_BMG_REGEX + { BMG_PM_REGEX, "REGEXP", 0, 2 }, + { BMG_PM_RM_REGEX, "RM-REGEXP", "RMREGEXP", 2 }, + #endif + { BMG_PM_ID, "ID", 0, 0 }, + { BMG_PM_ID_ALL, "ID-ALL", "IDALL", 0 }, + { BMG_PM_UNICODE, "UNICODE", 0, 0 }, + { BMG_PM_RM_ESCAPES, "RM-ESCAPES", "RMESCAPES", 0 }, + + { BMG_PM_REPLACE, "REPLACE", 0, 1 }, + { BMG_PM_INSERT, "INSERT", 0, 1 }, + { BMG_PM_OVERWRITE, "OVERWRITE", 0, 1 }, + { BMG_PM_DELETE, "DELETE", 0, 1 }, + { BMG_PM_MASK, "MASK", 0, 1 }, + { BMG_PM_EQUAL, "EQUAL", 0, 1 }, + { BMG_PM_NOT_EQUAL, "NOTEQUAL", "NEQUAL", 1 }, + + { BMG_PM_GENERIC, "GENERIC", 0, 0 }, + { BMG_PM_RM_CUPS, "RM-CUPS", "RMCUPS", 0 }, + + { BMG_PM_CT_COPY, "CT-COPY", "CTCOPY", 0 }, + { BMG_PM_CT_FORCE_COPY, "CT-FORCE-COPY","CTFORCECOPY", 0 }, + { BMG_PM_CT_FILL, "CT-FILL", "CTFILL", 0 }, + + { BMG_PM_LE_COPY, "LE-COPY", "LECOPY", 0 }, + { BMG_PM_LE_FORCE_COPY, "LE-FORCE-COPY","LEFORCECOPY", 0 }, + { BMG_PM_LE_FILL, "LE-FILL", "LEFILL", 0 }, + + { BMG_PM_X_COPY, "X-COPY", "XCOPY", 0 }, + { BMG_PM_X_FORCE_COPY, "X-FORCE-COPY", "XFORCECOPY", 0 }, + { BMG_PM_X_FILL, "X-FILL", "XFILL", 0 }, + + { BMG_PM_RM_FILLED, "RM-FILLED", "XFILLED", 0 }, + + { 0,0,0,0 } +}; + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// print & scan string16 /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static const KeywordTab_t bmg_color[] = +{ + { 0x0000, "OFF", "NONE", BMG_CNL_BASICS }, + { 0x0000, "GRAY", "GREY", BMG_CNL_BASICS }, + { 0x0001, "RED4", 0, BMG_CNL_BASICS }, + { 0x0002, "WHITE", 0, BMG_CNL_BASICS }, + + { 0x0008, "TRANSP", "TRANSPARENT", BMG_CNL_BASICS }, + { 0x0008, "CLEAR", 0, BMG_CNL_BASICS }, + + { 0x0010, "YOR0", "YR0", BMG_CNL_YOR }, + { 0x0011, "YOR1", "YR1", BMG_CNL_YOR }, + { 0x0012, "YOR2", "YR2", BMG_CNL_YOR }, + { 0x0013, "YOR3", "YR3", BMG_CNL_YOR }, + { 0x0014, "YOR4", "YR4", BMG_CNL_YOR }, + { 0x0015, "YOR5", "YR5", BMG_CNL_YOR }, + { 0x0016, "YOR6", "YR6", BMG_CNL_YOR }, + { 0x0017, "YOR7", "YR7", BMG_CNL_YOR }, + + { 0x0020, "RED2", 0, BMG_CNL_BASICS }, + { 0x0021, "BLUE1", "BLUE", BMG_CNL_BASICS }, + + { 0x0030, "YELLOW", 0, BMG_CNL_BASICS }, + { 0x0031, "BLUE2", 0, BMG_CNL_BASICS }, + { 0x0032, "RED3", 0, BMG_CNL_BASICS }, + { 0x0033, "GREEN", 0, BMG_CNL_BASICS }, + + { 0x0040, "RED1", "RED", BMG_CNL_BASICS }, + + {0,0,0,0} +}; + +/////////////////////////////////////////////////////////////////////////////// + +uint GetWordLength16BMG ( const u16 *source ) +{ + DASSERT(source); + u16 code = ntohs(*source); + if ( code != 0x1a ) + return 1; + const uint len = ( ((u8*)source)[2] + 1 & 0xfe ) / 2; + return len ? len : 1; +} + +/////////////////////////////////////////////////////////////////////////////// + +uint GetLength16BMG +( + const u16 *source, // source + uint max_len // max possible length +) +{ + DASSERT(source); + + const u16 *src = source, *src_end = src + max_len; + + while ( src < src_end ) + { + u16 code = ntohs(*src++); + if (!code) + return src - source - 1; + + if ( code == 0x1a ) + { + // nintendos special escape sequence! + const uint len = *(u8*)src+1 & 0xfe; + if ( len > 0 ) + src += len - 1; + } + } + + const uint len = src - source; + return len < max_len ? len : max_len; +} + +/////////////////////////////////////////////////////////////////////////////// +#undef TEST_MODE // 0:off, 1:compare, 2:replace +#if HAVE_WIIMM_EXT + #define TEST_MODE 1 +#else + #define TEST_MODE 0 +#endif +//-------------------------------------------------- + +uint PrintString16BMG +( + char *buf, // destination buffer + uint buf_size, // size of 'buf' + const u16 *src, // source + int src_len, // length of source in u16 words, -1:NULL term + u16 utf8_max, // max code printed as UTF-8 + uint quote, // 0:no quotes, 1:escape ", 2: print in quotes + int use_color // 0:no, 1:use, 2:use all +) +{ + DASSERT(buf); + DASSERT( buf_size >= 100 ); + DASSERT(src); + + //-------------------------------------------------- + #if TEST_MODE > 1 + //-------------------------------------------------- + + if ( buf_size < 2 ) + { + *buf = 0; + return 0; + } + + struct { FastBuf_t b; char space[1000]; } fb; + InitializeFastBuf(&fb,sizeof(fb)); + PrintFastBuf16BMG(&fb.b,src,src_len,utf8_max,quote,use_color); + mem_t mem = GetFastBufMem(&fb.b); + + if ( mem.len >= buf_size ) + mem.len = buf_size - 1; + memcpy(buf,mem.ptr,mem.len); + buf[mem.len] = 0; + ResetFastBuf(&fb.b); + return mem.len; + + //-------------------------------------------------- + #else // TEST_MODE <= 1 + //-------------------------------------------------- + + #if TEST_MODE == 1 + struct { FastBuf_t b; char space[1000]; } fb; + InitializeFastBuf(&fb,sizeof(fb)); + PrintFastBuf16BMG(&fb.b,src,src_len,utf8_max,quote,use_color); + #endif + + if ( buf_size < 30 ) + { + #if TEST_MODE == 1 + ResetFastBuf(&fb.b); + #endif + *buf = 0; + return 0; + } + + #undef PRINT_UTF8_MAX + //#define PRINT_UTF8_MAX 0xdb7f + + if ( utf8_max < 0x7f ) + utf8_max = 0x7f; + #ifdef PRINT_UTF8_MAX + else if ( utf8_max > PRINT_UTF8_MAX ) + utf8_max = PRINT_UTF8_MAX; + #endif + + char *dest = buf, *last_u = 0; + char *dest_end = dest + buf_size - 25; + const u16 * src_end = src + ( src_len < 0 ? buf_size : src_len ); + + if (quote>1) + *dest++ = '"'; + + while ( dest < dest_end && src < src_end ) + { + u16 code = ntohs(*src++); + if ( !code && src_len < 0 ) + break; + + if ( code == 0x1a ) + { + // nintendos special escape sequence! + uint total_words = *(u8*)src+1 >> 1; + if ( total_words >= 3 && src + total_words - 1 <= src_end ) + { + //HexDump(stdout,1,0,2,2*total_words,src-1,2*total_words); + const u16 code2 = ntohs(*src++); + if ( code2 == 0x800 && use_color > 0 && be16(src) == 1 ) + { + const u16 color = be16(src+1); + const KeywordTab_t *kt; + for ( kt = bmg_color; kt->name1 && kt->id != color; kt++ ) + ; + if ( kt->name1 && opt_bmg_color_name >= kt->opt ) + { + *dest++ = '\\'; + *dest++ = 'c'; + *dest++ = '{'; + ccp name = kt->name1; + while (*name) + *dest++ = tolower((int)*name++); + *dest++ = '}'; + } + else + dest += sprintf(dest,"\\c{%x}",color); + src += 2; + continue; + } + + if ( code2 == 0x801 ) + { + if ( opt_bmg_old_escapes || last_u != dest ) + dest = snprintfE(dest,dest_end,"\\u{%x}",be32(src)); + else + dest = snprintfE(dest-1,dest_end,",%x}",be32(src)); + last_u = dest; + src += 2; + continue; + } + + if ( ( total_words > 6 || opt_bmg_x_escapes ) && opt_bmg_old_escapes ) + { + src -= 2; + while ( total_words-- > 0 ) + dest = snprintfE(dest,dest_end,"\\x{%x}",ntohs(*src++)); + continue; + } + else if ( opt_bmg_x_escapes ) + { + if ( dest < dest_end ) + { + dest = StringCopyE(dest,dest_end,"\\x{1a"); + src--; + while ( total_words-- > 1 ) + dest = snprintfE(dest,dest_end,",%x",ntohs(*src++)); + } + *dest++ = '}'; + continue; + } + + u64 xcode = 0; + switch( total_words & 3 ) + { + case 3 & 3: xcode = be16(src); src += 1; break; + case 4 & 3: xcode = be32(src); src += 2; break; + case 5 & 3: xcode = be48(src); src += 3; break; + case 6 & 3: xcode = be64(src); src += 4; break; + } + + dest = snprintfE(dest,dest_end,"\\z{%x,%llx",code2,xcode); + while ( total_words > 6 ) + { + dest = snprintfE(dest,dest_end,",%llx",be64(src)); + src += 4; + total_words -= 4; + } + *dest++ = '}'; + continue; + } + } + + if ( code < ' ' || code == 0x7f || code == 0xff ) + { + *dest++ = '\\'; + switch(code) + { + case '\\': *dest++ = '\\'; break; + case '\a': *dest++ = 'a'; break; + case '\b': *dest++ = 'b'; break; + case '\f': *dest++ = 'f'; break; + case '\n': *dest++ = 'n'; break; + case '\r': *dest++ = 'r'; break; + case '\t': *dest++ = 't'; break; + case '\v': *dest++ = 'v'; break; + + default: + *dest++ = ( code >> 6 & 3 ) | '0'; + *dest++ = ( code >> 3 & 7 ) | '0'; + *dest++ = ( code & 7 ) | '0'; + } + } + #ifdef PRINT_UTF8_MAX + else if ( code > utf8_max ) + dest += sprintf(dest,"\\x{%x}",code); + #else + else if ( quote && code == '"' ) + { + *dest++ = '\\'; + *dest++ = '"'; + } + else if ( code > utf8_max + || code >= 0xdb80 && code <= 0xf8ff // surrogates & private use + || ( code & 0xffff ) >= 0xfffe // invalid + ) + { + dest = snprintfE(dest,dest_end,"\\x{%x}",code); + } + #endif + else + dest = PrintUTF8Char(dest,code); + } + + if ( dest > buf && dest[-1] == ' ' ) + { + dest[-1] = '\\'; + *dest++ = '0'; + *dest++ = '4'; + *dest++ = '0'; + } + + if (quote>1) + *dest++ = '"'; + + *dest = 0; + + #if TEST_MODE == 1 + const mem_t mem = GetFastBufMem(&fb.b); + if ( mem.len < buf_size ) + { + + XDump_t xd; + InitializeXDump(&xd); + xd.f = stderr; + xd.indent = 2; + xd.assumed_size = mem.len; + XDiff( &xd, buf,dest-buf,true, mem.ptr,mem.len,true, 5,false ); + } + ResetFastBuf(&fb.b); + #endif + + return dest - buf; + + //-------------------------------------------------- + #endif // TEST_MODE <= 1 + //-------------------------------------------------- +} + +/////////////////////////////////////////////////////////////////////////////// + +uint PrintFastBuf16BMG +( + // return the number of appended bytes + + FastBuf_t *fb, // destination buffer (data appended) + const u16 *src, // source + int src_len, // length of source in u16 words, -1:NULL term + u16 utf8_max, // max code printed as UTF-8 + uint quote, // 0:no quotes, 1:escape ", 2: print in quotes + int use_color // >0: use \c{...} +) +{ + DASSERT(fb); + DASSERT(src); + + #undef PRINT_UTF8_MAX + //#define PRINT_UTF8_MAX 0xdb7f + + if ( utf8_max < 0x7f ) + utf8_max = 0x7f; + #ifdef PRINT_UTF8_MAX + else if ( utf8_max > PRINT_UTF8_MAX ) + utf8_max = PRINT_UTF8_MAX; + #endif + + const uint start_len = GetFastBufLen(fb); + + char buf[1300]; + char *dest = buf; + char *dest_term = dest + sizeof(buf) - 1; + char *dest_end = dest_term - 270; // escape sequence with 256 bytes possible + char *last_u = 0; + + if ( src_len < 0 ) + src_len = GetLength16BMG(src,1000000); + const u16 * src_end = src + src_len; + + if (quote>1) + *dest++ = '"'; + + while ( src < src_end ) + { + if ( dest >= dest_end ) + { + AppendFastBuf(fb,buf,dest-buf); + dest = buf; + last_u = 0; + } + + u16 code = ntohs(*src++); + if ( !code && src_len < 0 ) + break; + + if ( code == 0x1a ) + { + // nintendos special escape sequence! + uint total_words = *(u8*)src+1 >> 1; + if ( total_words >= 3 && src + total_words - 1 <= src_end ) + { + //HexDump(stdout,1,0,2,2*total_words,src-1,2*total_words); + const u16 code2 = ntohs(*src++); + if ( code2 == 0x800 && use_color > 0 && be16(src) == 1 ) + { + const u16 color = be16(src+1); + const KeywordTab_t *kt; + for ( kt = bmg_color; kt->name1 && kt->id != color; kt++ ) + ; + if ( kt->name1 && opt_bmg_color_name >= kt->opt ) + { + *dest++ = '\\'; + *dest++ = 'c'; + *dest++ = '{'; + ccp name = kt->name1; + while (*name) + *dest++ = tolower((int)*name++); + *dest++ = '}'; + } + else + dest += sprintf(dest,"\\c{%x}",color); + src += 2; + continue; + } + + if ( code2 == 0x801 ) + { + if ( opt_bmg_old_escapes || last_u != dest ) + dest = snprintfE(dest,dest_term,"\\u{%x}",be32(src)); + else + dest = snprintfE(dest-1,dest_term,",%x}",be32(src)); + last_u = dest; + src += 2; + continue; + } + + if ( ( total_words > 6 || opt_bmg_x_escapes ) && opt_bmg_old_escapes ) + { + src -= 2; + while ( total_words-- > 0 ) + dest = snprintfE(dest,dest_term,"\\x{%x}",ntohs(*src++)); + continue; + } + else if ( opt_bmg_x_escapes ) + { + if ( dest < dest_term ) + { + dest = StringCopyE(dest,dest_term,"\\x{1a"); + src--; + while ( total_words-- > 1 ) + dest = snprintfE(dest,dest_term,",%x",ntohs(*src++)); + } + *dest++ = '}'; + continue; + } + + u64 xcode = 0; + switch( total_words & 3 ) + { + case 3 & 3: xcode = be16(src); src += 1; break; + case 4 & 3: xcode = be32(src); src += 2; break; + case 5 & 3: xcode = be48(src); src += 3; break; + case 6 & 3: xcode = be64(src); src += 4; break; + } + + dest = snprintfE(dest,dest_term,"\\z{%x,%llx",code2,xcode); + while ( total_words > 6 ) + { + dest = snprintfE(dest,dest_term,",%llx",be64(src)); + src += 4; + total_words -= 4; + } + *dest++ = '}'; + continue; + } + } + + if ( code < ' ' || code == 0x7f || code == 0xff ) + { + *dest++ = '\\'; + switch(code) + { + case '\\': *dest++ = '\\'; break; + case '\a': *dest++ = 'a'; break; + case '\b': *dest++ = 'b'; break; + case '\f': *dest++ = 'f'; break; + case '\n': *dest++ = 'n'; break; + case '\r': *dest++ = 'r'; break; + case '\t': *dest++ = 't'; break; + case '\v': *dest++ = 'v'; break; + + default: + *dest++ = ( code >> 6 & 3 ) | '0'; + *dest++ = ( code >> 3 & 7 ) | '0'; + *dest++ = ( code & 7 ) | '0'; + } + } + #ifdef PRINT_UTF8_MAX + else if ( code > utf8_max ) + dest += sprintf(dest,"\\x{%x}",code); + #else + else if ( quote && code == '"' ) + { + *dest++ = '\\'; + *dest++ = '"'; + } + else if ( code > utf8_max + || code >= 0xdb80 && code <= 0xf8ff // surrogates & private use + || ( code & 0xffff ) >= 0xfffe // invalid + ) + { + dest = snprintfE(dest,dest_term,"\\x{%x}",code); + } + #endif + else + dest = PrintUTF8Char(dest,code); + } + + if ( dest > buf && dest[-1] == ' ' ) + { + dest[-1] = '\\'; + *dest++ = '0'; + *dest++ = '4'; + *dest++ = '0'; + } + + if (quote>1) + *dest++ = '"'; + + AppendFastBuf(fb,buf,dest-buf); + return GetFastBufLen(fb) - start_len; +} + +/////////////////////////////////////////////////////////////////////////////// + +#if 0 +uint ScanFastBuf16BMG +( + + FastBuf_t *fb, // destination buffer + ccp src, // UTF-8 source + int src_len, // length of source, -1: determine with strlen() + const bmg_t *bmg // NULL or support for \m{...} +); +#endif + +uint ScanString16BMG +( + u16 * buf, // destination buffer + uint buf_size, // size of 'buf' in u16 words + ccp src, // UTF-8 source + int src_len, // length of source, -1: determine with strlen() + const bmg_t *bmg // NULL or support for \m{...} +) +{ + DASSERT(buf); + DASSERT(src); + + u16 * dest = buf; + u16 * dest_end = dest + buf_size; + ccp src_end = src + ( src_len < 0 ? strlen(src) : src_len ); + + while ( dest < dest_end && src < src_end ) + { + if ( *src == '\\' && src+1 < src_end ) + { + src++; + switch(*src++) + { + case '\\': *dest++ = htons('\\'); break; + case 'a': *dest++ = htons('\a'); break; + case 'b': *dest++ = htons('\b'); break; + case 'f': *dest++ = htons('\f'); break; + case 'n': *dest++ = htons('\n'); break; + case 'r': *dest++ = htons('\r'); break; + case 't': *dest++ = htons('\t'); break; + case 'v': *dest++ = htons('\v'); break; + + case 'm': + case 'M': + if ( src < src_end && *src == '{' ) + { + const char mode = src[-1]; + src++; + bmg_scan_mid_t scan; + for(;;) + { + while ( src < src_end && *src == ',' ) + src++; + if ( ScanBMGMID(&scan,0,src,src_end) < 1 ) + break; + src = scan.scan_end; + + PRINT("\\M{%x} : bmg=%d\n",scan.mid[0],bmg!=0); + + const bmg_item_t *dptr = 0; + if ( bmg && mode == 'm' ) + dptr = FindItemBMG(bmg,scan.mid[0]); + if ( !dptr && bmg_macros ) + dptr = FindItemBMG(bmg_macros,scan.mid[0]); + + if (!dptr) + { + char buf[16]; + snprintf(buf,sizeof(buf),"\\%c{%x}",mode,scan.mid[0]); + ccp src = buf; + while ( *src && dest < dest_end ) + *dest++ = htons(*src++); + } + else if ( dptr->text ) + { + const u16 *copy = dptr->text; + const u16 *copy_end = copy + dptr->len; + while ( copy < copy_end && dest < dest_end ) + *dest++ = *copy++; + } + if ( *src != ',' ) + break; + } + if ( *src == '}' ) + src++; + } + break; + + case 'x': + { + const bool have_brace = *src == '{'; + if (have_brace) + src++; + for(;;) + { + char *end; + u16 code = strtoul(src,&end,16); + src = end; + if ( dest < dest_end ) + *dest++ = htons(code); + if ( !have_brace || *src != ',' ) + break; + src++; + } + if ( have_brace && *src == '}' ) + src++; + } + break; + + case 'z': + { + const bool have_brace = *src == '{'; + if (have_brace) + src++; + char * end; + const u16 code1 = strtoul(src,&end,16); + src = end; + uint total_words = code1+0x100 >> 9; + if ( dest + total_words <= dest_end ) + { + *dest++ = htons(0x1a); + *dest++ = htons(code1); + u64 xcode = 0; + if ( *src == ',' ) + { + xcode = strtoull(src+1,&end,16); + src = end; + } + switch( total_words & 3 ) + { + case 3 & 3: write_be16(dest,xcode); dest += 1; break; + case 4 & 3: write_be32(dest,xcode); dest += 2; break; + case 5 & 3: write_be48(dest,xcode); dest += 3; break; + case 6 & 3: write_be64(dest,xcode); dest += 4; break; + } + while ( total_words > 6 ) + { + total_words -= 4; + if ( *src == ',' ) + { + xcode = strtoull(src+1,&end,16); + src = end; + } + else + xcode = 0; + write_be64(dest,xcode); + dest += 4; + } + while ( *src == ',' ) + { + strtoull(src+1,&end,16); + src = end; + } + } + if ( have_brace && *src == '}' ) + src++; + } + break; + + case 'u': + { + const bool have_brace = *src == '{'; + if (have_brace) + src++; + for(;;) // >>>>> comma list support since v1.44 <<<<< + { + char * end; + u32 code = strtoul(src,&end,16); + src = end; + if ( dest + 4 <= dest_end ) + { + *dest++ = htons(0x001a); + *dest++ = htons(0x0801); + *dest++ = htons(code>>16); + *dest++ = htons(code); + } + if ( !have_brace || *src != ',' ) + break; + src++; + } + if ( have_brace && *src == '}' ) + src++; + } + break; + + case 'c': + { + const bool have_brace = *src == '{'; + if (have_brace) + src++; + + u16 code = 0; + if ( *src >= '0' && *src <= '9' ) + { + char *end; + code = strtoul(src,&end,16); + src = end; + } + else + { + char keyname[50], *kp = keyname; + while (isalnum((int)*src)) + { + if ( kp < keyname + sizeof(keyname) - 1 ) + *kp++ = *src; + src++; + } + *kp = 0; + + const KeywordTab_t *key = ScanKeyword(0,keyname,bmg_color); + if (key) + code = key->id; + else + code = strtoul(keyname,0,16); + } + if ( have_brace && *src == '}' ) + src++; + + if ( dest + 4 <= dest_end ) + { + *dest++ = htons(0x001a); + *dest++ = htons(0x0800); + *dest++ = htons(0x0001); + *dest++ = htons(code); + } + } + break; + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + { + src--; + u16 code = 0; + int idx; + for ( idx = 0; idx < 3 && *src >= '0' && *src <= '7'; idx++ ) + code = code << 3 | *src++ - '0'; + *dest++ = htons(code); + } + break; + + default: + *dest++ = htons('\\'); + src--; + break; + } + } + else + *dest++ = htons(ScanUTF8AnsiChar(&src)); + } + + return dest - buf; +} + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +static unsigned long int strtoul16 +( + const u16 * ptr16, + u16 ** end16, + int base +) +{ + DASSERT(ptr16); + + char buf[100]; + char * dest = buf; + const u16 * p16 = ptr16; + while ( dest < buf + sizeof(buf)-1 ) + { + int ch = be16(p16++); + if ( ch >= '0' && ch <= '9' + || ch >= 'a' && ch <= 'f' + || ch >= 'A' && ch <= 'F' + || ch == 'x' + || ch == 'X' + || isspace(ch) + ) + { + *dest++ = ch; + } + else + break; + } + DASSERT( dest < buf + sizeof(buf) ); + *dest = 0; + + char *end; + unsigned long num = strtoul(buf,&end,base); + if (end16) + *end16 = (u16*)ptr16 + (end-buf); + return num; +} + +/////////////////////////////////////////////////////////////////////////////// + +static u16 * skip_ctrl16 ( const u16 * ptr ) +{ + DASSERT(ptr); + for(;;) + { + const u16 ch = be16(ptr); + if ( !ch || ch > ' ' ) + return (u16*)ptr; + ptr++; + } +} + +/////////////////////////////////////////////////////////////////////////////// + +static u16 * ScanRange16U32 +( + const u16 * arg, // text to scan (valid pointer) + u32 * p_stat, // NULL or return status: + // number of scanned numbers (0..2) + u32 * p_n1, // first return value (valid pointer) + u32 * p_n2, // second return value (valid pointer) + u32 min, // min allowed value (fix num) + u32 max // max allowed value (fix num) +) +{ + DASSERT(arg); + DASSERT(p_n1); + DASSERT(p_n2); + TRACE("ScanRange16U32()\n"); + + int stat = 0; + + u32 n1 = ~(u32)0, n2 = 0; + arg = skip_ctrl16(arg); + + if ( be16(arg) == '-' ) + n1 = min; + else + { + u16 * end; + u32 num = strtoul16(arg,&end,0); + if ( arg == end ) + goto abort; + + stat = 1; + arg = skip_ctrl16(end); + n1 = num; + } + + if ( be16(arg) != '-' ) + { + stat = 1; + n2 = n1; + goto abort; + } + + arg = skip_ctrl16(arg+1); + u16 * end; + n2 = strtoul16(arg,&end,0); + if ( end == arg ) + n2 = max; + stat = 2; + arg = end; + + abort: + + if ( stat > 0 ) + { + if ( n1 < min ) + n1 = min; + if ( n2 > max ) + n2 = max; + } + + if ( !stat || n1 > n2 ) + { + stat = 0; + n1 = ~(u32)0; + n2 = 0; + } + + if (p_stat) + *p_stat = stat; + *p_n1 = n1; + *p_n2 = n2; + + arg = skip_ctrl16(arg); + + TRACE("END ScanRange16U32() stat=%u, n=%u..%u\n",stat,n1,n2); + return (u16*)arg; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// ScanSectionsBMG() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +bmg_sect_list_t * ScanSectionsBMG ( cvp data, uint size ) +{ + //--- initialize + + if ( !data || size < sizeof(bmg_header_t) || memcmp(data,BMG_MAGIC,8) ) + return 0; + + bmg_sect_list_t sl; + memset(&sl,0,sizeof(sl)); + sl.header = (bmg_header_t*)data; + sl.source_size = ntohl(sl.header->size); + sl.n_sections = ntohl(sl.header->n_sections); + + FastBuf_t fb; + InitializeFastBufAlloc(&fb,10*sizeof(bmg_sect_info_t)); + + bmg_sect_info_t si; + + + //--- scan sections + + u8 *data_end = (u8*)data + size; + bmg_section_t *sect = (bmg_section_t*)(sl.header+1); + for(;;) + { + if ( (u8*)sect + sizeof(*sect) > data_end ) + break; + + memset(&si,0,sizeof(si)); + si.offset = (u8*)sect - (u8*)data; + si.sect_size = si.real_size = ntohl(sect->size); + if ( (u8*)sect + si.real_size > data_end ) + si.real_size = data_end - (u8*)sect; + + si.sect = sect; + si.info = "?"; + + if (!memcmp(sect->magic,BMG_INF_MAGIC,sizeof(sect->magic))) + { + sl.pinf = (bmg_inf_t*)sect; + si.head_size = sizeof(bmg_inf_t); + si.elem_size = ntohs(sl.pinf->inf_size); + si.n_elem_head = ntohs(sl.pinf->n_msg); + si.known = true; + si.supported = true; + si.info = "offset & attributes"; + } + else if (!memcmp(sect->magic,BMG_DAT_MAGIC,sizeof(sect->magic))) + { + sl.pdat = (bmg_dat_t*)sect; + si.head_size = sizeof(bmg_dat_t); + si.known = true; + si.supported = true; + si.info = "string pool"; + } + else if (!memcmp(sect->magic,BMG_STR_MAGIC,sizeof(sect->magic))) + { + sl.pstr = (bmg_str_t*)sect; + si.head_size = sizeof(bmg_str_t); + si.known = true; + si.supported = false; + si.info = "secondary string pool"; + } + else if (!memcmp(sect->magic,BMG_MID_MAGIC,sizeof(sect->magic))) + { + sl.pmid = (bmg_mid_t*)sect; + si.head_size = sizeof(bmg_mid_t); + si.elem_size = sizeof(u32); + si.n_elem_head = ntohs(sl.pinf->n_msg); + si.known = true; + si.supported = true; + si.info = "message ids"; + } + else if (!memcmp(sect->magic,BMG_FLW_MAGIC,sizeof(sect->magic))) + { + sl.pflw = (bmg_flw_t*)sect; + si.known = true; + } + else if (!memcmp(sect->magic,BMG_FLI_MAGIC,sizeof(sect->magic))) + { + sl.pfli = (bmg_fli_t*)sect; + si.known = true; + } + + if (si.elem_size) + { + si.n_elem = ( si.real_size - si.head_size ) / si.elem_size; + if ( si.n_elem_head && si.n_elem > si.n_elem_head ) + si.n_elem = si.n_elem_head; + } + + if ( si.head_size && si.head_size < si.real_size ) + { + si.is_empty = true; + const u8 *ptr = (u8*)sect + si.head_size; + const u8 *end = (u8*)sect + si.real_size; + while ( ptr < end ) + if ( *ptr++ ) + { + si.is_empty = false; + break; + } + } + + sect = (bmg_section_t*)( (u8*)sect + si.real_size ); + AppendFastBuf(&fb,&si,sizeof(si)); + sl.n_info++; + } + + + //--- finalize + + memset(&si,0,sizeof(si)); + AppendFastBuf(&fb,&si,sizeof(si)); + + mem_t mem = GetFastBufMem(&fb); + sl.this_size = sizeof(sl) + mem.len; + bmg_sect_list_t *dest = MALLOC(sl.this_size); + memcpy(dest,&sl,sizeof(sl)); + memcpy(dest->info,mem.ptr,mem.len); + ResetFastBuf(&fb); + return dest; +} + +/////////////////////////////////////////////////////////////////////////////// + +const bmg_sect_info_t * SearchSectionBMG +( + const bmg_sect_list_t *sl, // valid, created by ScanSectionsBMG() + cvp search, // magic to search + bool abbrev, // if not found: allow abbreviations _> strcmp() + bool icase // if not found: ignore case and try again +) +{ + DASSERT(sl); + + // make sure, that magic is null terminated + char magic[5]; + memcpy(magic,search,4); + magic[4] = 0; + + + //--- search exact + + const bmg_sect_info_t *si; + for ( si = sl->info; si->sect; si++ ) + if (!memcmp(magic,si->sect->magic,4)) + return si; + + + //--- search abbrev + + const uint mlen = strlen(magic); + if (!mlen) + abbrev = false; + + if (abbrev) + { + for ( si = sl->info; si->sect; si++ ) + if (!memcmp(magic,si->sect->magic,mlen)) + return si; + } + + + //--- search icase + + if (icase) + { + uint i; + for ( i = 0; i < 4; i++ ) + magic[i] = tolower((int)magic[i]); + + const bmg_sect_info_t *abbrev_found = 0; + char buf[5]; + + for ( si = sl->info; si->sect; si++ ) + { + for ( i = 0; i < 4; i++ ) + buf[i] = tolower((int)si->sect->magic[i]); + + if (!memcmp(magic,buf,4)) + return si; + if ( abbrev && !memcmp(magic,buf,mlen) ) + abbrev_found = si; + } + return abbrev_found; + } + + return 0; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct bmg_raw_section_t /////////////// +/////////////////////////////////////////////////////////////////////////////// + +bmg_raw_section_t * GetRawSectionBMG ( bmg_t *bmg, cvp magic ) +{ + DASSERT(bmg); + DASSERT(magic); + + bmg_raw_section_t *raw; + for ( raw = bmg->first_raw; raw; raw = raw->next ) + if (!memcmp(raw->magic,magic,sizeof(raw->magic))) + { + PRINT("GetRawSectionBMG(%s), found\n",PrintID(magic,4,0)); + return raw; + } + + PRINT("GetRawSectionBMG(%s), not found\n",PrintID(magic,4,0)); + return 0; +} + +/////////////////////////////////////////////////////////////////////////////// + +bmg_raw_section_t * CreateRawSectionBMG ( bmg_t *bmg, cvp magic ) +{ + bmg_raw_section_t **raw; + for ( raw = &bmg->first_raw; *raw; raw = &(*raw)->next ) + if (!memcmp((*raw)->magic,magic,sizeof((*raw)->magic))) + { + PRINT("CreateRawSectionBMG(%s), found\n",PrintID(magic,4,0)); + return (*raw); + } + + DASSERT(raw); + PRINT("CreateRawSectionBMG(%s), create\n",PrintID(magic,4,0)); + bmg_raw_section_t *p = CALLOC(1,sizeof(*p)); + memcpy(p->magic,magic,sizeof(p->magic)); + InitializeFastBuf(&p->data,sizeof(p->data)); + return *raw = p; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// attribute helpers /////////////// +/////////////////////////////////////////////////////////////////////////////// + +void ResetAttribBMG +( + const bmg_t * bmg, // pointer to bmg + bmg_item_t * item // dest item +) +{ + DASSERT(bmg); + DASSERT(item); + + item->slot = BMG_NO_PREDEF_SLOT; + item->attrib_used = bmg->attrib_used; + memcpy(item->attrib,bmg->attrib,sizeof(item->attrib)); +} + +/////////////////////////////////////////////////////////////////////////////// + +void CopyAttribBMG +( + const bmg_t * dest, // pointer to destination bmg + bmg_item_t * dptr, // dest item + const bmg_item_t * sptr // source item +) +{ + DASSERT(dest); + DASSERT(dptr); + DASSERT(sptr); + + DASSERT( dest->attrib_used <= BMG_ATTRIB_SIZE ); + DASSERT( sptr->attrib_used <= BMG_ATTRIB_SIZE ); + + if ( sptr->slot != BMG_NO_PREDEF_SLOT ) + dptr->slot = sptr->slot; + + if ( opt_bmg_force_attrib ) + { + //dptr->attrib_used = dest->attrib_used; + memcpy(dptr->attrib,bmg_force_attrib,dptr->attrib_used); + } + else if ( sptr->attrib_used ) + { + if ( dest->attrib_used <= sptr->attrib_used ) + dptr->attrib_used = dest->attrib_used; + else + { + dptr->attrib_used = sptr->attrib_used; + memset( dptr->attrib+dptr->attrib_used, 0, BMG_ATTRIB_SIZE - sptr->attrib_used ); + } + memcpy(dptr->attrib,sptr->attrib,dptr->attrib_used); + } +} + +/////////////////////////////////////////////////////////////////////////////// + +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; +} + +/////////////////////////////////////////////////////////////////////////////// + +static void copy_param +( + bmg_t * dest, // pointer to destination bmg + const bmg_t * src // pointer to source bmg +) +{ + DASSERT(dest); + DASSERT(src); + + if ( !dest->param_defined && src->param_defined ) + { + memcpy(dest->attrib,src->attrib,sizeof(dest->attrib)); + dest->inf_size = src->inf_size; + dest->have_mid = src->have_mid; + dest->attrib_used = src->attrib_used; + dest->use_color_names = src->use_color_names; + dest->use_mkw_messages = src->use_mkw_messages; + dest->param_defined = true; + } +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct bmg_item_t /////////////// +/////////////////////////////////////////////////////////////////////////////// + +// special values for bmg_item_t::text +u16 bmg_null_entry[] = {0}; + +////////////////////////////////////////////////////////////////////////////// + +void FreeItemBMG( bmg_item_t * bi ) +{ + DASSERT(bi); + if (bi->text) + { + if ( bi->alloced_size && !isSpecialEntryBMG(bi->text) ) + FREE( bi->text); + bi->text = bmg_null_entry; + } + bi->len = bi->alloced_size = 0; +} + +/////////////////////////////////////////////////////////////////////////////// + +void AssignItemText16BMG +( + bmg_item_t * bi, // valid item + const u16 * text16, // text to store + int len // length of 'text16'. + // if -1: detect length by finding + // first NULL value. +) +{ + DASSERT(bi); + if ( !text16 || isSpecialEntryBMG(text16) ) + { + FreeItemBMG(bi); + bi->text = (u16*)text16; + return; + } + + if ( len < 0 ) + { + const u16 * ptr = text16; + while (*ptr) + ptr++; + len = ptr - text16; + } + + if ( bi->text && bi->alloced_size ) + { + if ( len+1 <= bi->alloced_size ) + { + memcpy(bi->text,text16,len*sizeof(*bi->text)); + bi->text[len] = 0; + bi->len = len; + return; + } + FREE(bi->text); + } + + bi->alloced_size = len + 1; + bi->len = len; + bi->text = CALLOC(bi->alloced_size,sizeof(*bi->text)); + memcpy(bi->text,text16,len*sizeof(*bi->text)); +} + +/////////////////////////////////////////////////////////////////////////////// + +void AssignItemScanTextBMG +( + bmg_item_t * bi, // valid item + ccp utf8, // UTF-8 text to scan + int len // length of 'utf8'. + // if -1: detect length with strlen() +) +{ + DASSERT(bi); + + if (!utf8) + AssignItemText16BMG(bi,0,0); + else + { + const uint bufsize = 10000; + u16 buf[bufsize]; + len = ScanString16BMG(buf,bufsize,utf8,len,0); + AssignItemText16BMG(bi,buf,len); + } +} + +/////////////////////////////////////////////////////////////////////////////// + +void AssignItemTextBMG +( + bmg_item_t * bi, // valid item + ccp utf8, // UTF-8 text to store + int len // length of 'utf8'. + // if -1: detect length with strlen() +) +{ + DASSERT(bi); + + if (!utf8) + AssignItemText16BMG(bi,0,0); + else + { + u16 buf[10000]; + u16 *ptr = buf; + u16 *end = buf + sizeof(buf)/sizeof(*buf); + + if ( len < 0 ) + { + while ( ptr < end ) + { + ulong code = ScanUTF8AnsiChar(&utf8); + if (!code) + break; + *ptr++ = htons(code); + } + } + else + { + ccp utf8_end = utf8 + len; + while ( utf8 < utf8_end && ptr < end ) + *ptr++ = htons(ScanUTF8AnsiCharE(&utf8,utf8_end)); + } + AssignItemText16BMG(bi,buf,ptr-buf); + } +} + +/////////////////////////////////////////////////////////////////////////////// + +bool IsItemEqualBMG +( + const bmg_item_t * bi1, // NULL or valid item + const bmg_item_t * bi2 // NULL or valid item +) +{ + if ( bi1 == bi2 ) + return true; + if ( !bi1 || !bi2 ) + return false; + + return bi1->len == bi2->len + && bi1->attrib_used == bi2->attrib_used + && !memcmp(bi1->text,bi2->text,bi1->len*sizeof(*bi2->text)) + && !memcmp(bi1->attrib,bi2->attrib,bi1->attrib_used); +} + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +static uint find_item_helper ( const bmg_t * bmg, u32 mid, bool * found ) +{ + DASSERT(bmg); + DASSERT(found); + + int beg = 0; + int end = bmg->item_used - 1; + while ( beg <= end ) + { + const uint idx = (beg+end)/2; + const bmg_item_t * item = bmg->item + idx; + if ( mid < item->mid ) + end = idx - 1 ; + else if ( mid > item->mid ) + beg = idx + 1; + else + { + *found = true; + return idx; + } + } + + *found = false; + return beg; +} + +/////////////////////////////////////////////////////////////////////////////// + +bmg_item_t * FindItemBMG ( const bmg_t * bmg, u32 mid ) +{ + DASSERT(bmg); + + bool found; + uint idx = find_item_helper(bmg,mid,&found); + DASSERT( idx < bmg->item_used || idx == bmg->item_used && !found ); + + return found ? bmg->item + idx : 0; +} + +/////////////////////////////////////////////////////////////////////////////// + +bmg_item_t * FindAnyItemBMG ( const bmg_t * bmg, u32 mid ) +{ + DASSERT(bmg); + + bool found; + uint idx = find_item_helper(bmg,mid,&found); + DASSERT( idx < bmg->item_used || idx == bmg->item_used && !found ); + + bmg_item_t * item = bmg->item + idx; + if (!found) + { + bmg_item_t * item_end = bmg->item + bmg->item_used; + while ( item < item_end && item->mid < mid ) + item++; + } + return item; +} + +/////////////////////////////////////////////////////////////////////////////// + +bmg_item_t * InsertItemBMG + ( bmg_t *bmg, u32 mid, u8 *attrib, uint attrib_used, bool *old_item ) +{ + DASSERT(bmg); + DASSERT( attrib_used <= BMG_ATTRIB_SIZE ); + + if (opt_bmg_force_attrib) + { + attrib_used = bmg->attrib_used; + attrib = bmg_force_attrib; + } + else if ( attrib_used > bmg->attrib_used ) + attrib_used = bmg->attrib_used; + + bmg->param_defined = true; // don't accept modifications on patch + + //if ( attrib && attrib_used ) HexDump16(stderr,0,0x100,attrib,attrib_used); + + bool found; + uint idx = find_item_helper(bmg,mid,&found); + DASSERT( idx < bmg->item_used || idx == bmg->item_used && !found ); + + if (old_item) + *old_item = found; + + if (found) + { + bmg_item_t * item = bmg->item + idx; + if ( attrib && attrib_used ) + { + item->attrib_used = bmg->attrib_used; + memcpy(item->attrib,bmg->attrib,sizeof(item->attrib)); + memcpy(item->attrib,attrib,attrib_used); + } + return item; + } + + DASSERT( bmg->item_used <= bmg->item_size ); + if ( bmg->item_used == bmg->item_size ) + { + bmg->item_size += 1000; + bmg->item = REALLOC(bmg->item,bmg->item_size*sizeof(*bmg->item)); + } + + bmg_item_t * item = bmg->item + idx; + memmove( item+1, item, (bmg->item_used-idx) * sizeof(*bmg->item) ); + bmg->item_used++; + DASSERT( idx < bmg->item_used ); + memset(item,0,sizeof(*item)); + item->mid = mid; + item->slot = BMG_NO_PREDEF_SLOT; + + memcpy(item->attrib,bmg->attrib,sizeof(item->attrib)); + if ( attrib && attrib_used ) + { + item->attrib_used = bmg->attrib_used; + memcpy(item->attrib,attrib,attrib_used); + } + return item; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool DeleteItemBMG ( bmg_t *bmg, u32 mid ) +{ + DASSERT(bmg); + + bmg_item_t *dptr = FindItemBMG(bmg,mid); + if (dptr) + { + FreeItemBMG(dptr); + dptr->text = 0; + ResetAttribBMG(bmg,dptr); + return true; + } + + return false; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool HavePredifinedSlots ( bmg_t *bmg ) +{ + DASSERT(bmg); + + bmg_item_t *bi, *bi_end = bmg->item + bmg->item_used; + for ( bi = bmg->item; bi < bi_end; bi++ ) + if ( bi->text && bi->slot != BMG_NO_PREDEF_SLOT ) + return bmg->have_predef_slots = true; + return bmg->have_predef_slots = false; +} + +/////////////////////////////////////////////////////////////////////////////// + +u16 * ModifiyItem +( + // return a fixed 'ptr' + bmg_item_t * bi, // valid item, prepare text modification + const u16 * ptr // NULL or a pointer within 'bi->text' +) +{ + DASSERT(bi); + + if (!bi->alloced_size) + { + const uint size = (bi->len+1) * sizeof(*bi->text); + u16 *text = MALLOC(size); + memcpy(text,bi->text,size); + if (ptr) + ptr = text + ( ptr - bi->text ); + bi->text = text; + bi->alloced_size = bi->len; + } + return (u16*)ptr; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// MKW hooks /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static int GetTrackIndexBMG0 ( uint idx, int result_on_invalid ) +{ + static const u8 track_pos[BMG_N_TRACK] = + { + 8, 1, 2, 4, 0, 5, 6, 7, 9,15,11, 3, 14,10,12,13, + 16,20,25,26, 27,31,23,18, 21,30,29,17, 24,22,19,28 + }; + + return idx < BMG_N_TRACK + ? track_pos[idx] + : idx < BMG_N_CT_TRACK + ? idx + : result_on_invalid; +} + +int (*GetTrackIndexBMG) ( uint idx, int result_on_invalid ) = GetTrackIndexBMG0; + +/////////////////////////////////////////////////////////////////////////////// + +static int GetArenaIndexBMG0 ( uint idx, int result_on_invalid ) +{ + static const u8 arena_pos[BMG_N_ARENA] = { 1,0,3,2,4, 7,8,9,5,6 }; + + return idx < BMG_N_ARENA + ? arena_pos[idx] + : result_on_invalid; +} + +int (*GetArenaIndexBMG) ( uint idx, int result_on_invalid ) = GetArenaIndexBMG0; + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// bmg encoding support /////////////// +/////////////////////////////////////////////////////////////////////////////// + +const KeywordTab_t TabEncodingBMG[] = +{ + // if opt==1: not implemented yet + { BMG_ENC_CP1252, "CP-1252", "CP1252", 0 }, + { BMG_ENC_CP1252, "1", 0, 0 }, + + { BMG_ENC_UTF16BE, "UTF-16BE", "UTF16BE", 0 }, + { BMG_ENC_UTF16BE, "2", 0, 0 }, + + { BMG_ENC_SHIFT_JIS, "SHIFT-JIS", "SHIFTJIS", 0 }, + { BMG_ENC_SHIFT_JIS, "3", "SJIS", 0 }, + + { BMG_ENC_UTF8, "UTF-8", "UTF8", 0 }, + { BMG_ENC_UTF8, "4", 0, 0 }, + + { BMG_ENC__UNDEFINED, "AUTO", "UNDEFINED", 0 }, + { 0,0,0,0 } +}; + +//----------------------------------------------------------------------------- + +ccp GetEncodingNameBMG ( int encoding, ccp return_if_invalid ) +{ + switch (encoding) + { + case BMG_ENC_CP1252: return "CP1252"; + case BMG_ENC_UTF16BE: return "UTF-16/be"; + case BMG_ENC_SHIFT_JIS: return "Shift-JIS"; + case BMG_ENC_UTF8: return "UTF-8"; + } + return return_if_invalid; +} + +//----------------------------------------------------------------------------- + +int CheckEncodingBMG ( int encoding, int return_if_invalid ) +{ + return encoding >= BMG_ENC__MIN && encoding <= BMG_ENC__MAX + ? encoding : return_if_invalid; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// setup/reset bmg_t /////////////// +/////////////////////////////////////////////////////////////////////////////// + +void AssignEncodingBMG ( bmg_t * bmg, int encoding ) +{ + if ( encoding >= BMG_ENC__MIN && encoding <= BMG_ENC__MAX ) + bmg->encoding = encoding; +} + +/////////////////////////////////////////////////////////////////////////////// + +void AssignInfSizeBMG ( bmg_t * bmg, uint inf_size ) +{ + bmg->param_defined = true; + + if ( inf_size < 4 || inf_size > BMG_INF_LIMIT ) + { + ERROR0(ERR_WARNING, + "INF data size is outside allowed range 4..%u => ignored: %s\n", + BMG_INF_LIMIT, bmg->fname ); + return; + } + + if ( inf_size > BMG_INF_MAX_SIZE ) + ERROR0(ERR_WARNING, + "INF data size is %u bytes, but only %u bytes are supported." + " The additional bytes are always assumed to be NULL: %s", + inf_size, BMG_INF_MAX_SIZE, bmg->fname ); + + bmg->inf_size = opt_bmg_inf_size ? opt_bmg_inf_size : inf_size; + bmg->attrib_used = bmg->inf_size - 4; + if ( bmg->attrib_used > sizeof(bmg->attrib) ) + bmg->attrib_used = sizeof(bmg->attrib); + if (opt_bmg_def_attrib) + memcpy(bmg->attrib,bmg_def_attrib,bmg->attrib_used); + + if ( inf_size != 8 ) + { + // not MKW => change defaults + if ( bmg->use_color_names == 2 ) + bmg->use_color_names = 1; + if ( bmg->use_mkw_messages == 2 ) + bmg->use_mkw_messages = 1; + } +} + +/////////////////////////////////////////////////////////////////////////////// + +void InitializeBMG ( bmg_t * bmg ) +{ + ASSERT( MID_VERSUS_POINTS >= MID_PARAM_BEG + && MID_VERSUS_POINTS < MID_PARAM_END ); + + DASSERT(bmg); + memset(bmg,0,sizeof(*bmg)); + bmg->have_mid = 1; + bmg->encoding = BMG_ENC__DEFAULT; + bmg->use_slots = opt_bmg_use_slots; + bmg->use_raw_sections = opt_bmg_use_raw_sections; + + bmg->unknown_inf_0c = BMG_INF_DEFAULT_0C; + bmg->unknown_mid_0a = BMG_MID_DEFAULT_0A; + bmg->unknown_mid_0c = BMG_MID_DEFAULT_0C; + + //-- setup for MKW + + if (opt_bmg_support_mkw) + { + bmg->use_color_names = 1; + bmg->use_mkw_messages = 1; + AssignInfSizeBMG(bmg,BMG_INF_STD_SIZE); + + if ( !opt_bmg_def_attrib && bmg->attrib_used == 4 ) + write_be32(bmg->attrib,BMG_INF_STD_ATTRIB); + } +} + +/////////////////////////////////////////////////////////////////////////////// + +void ResetBMG ( bmg_t * bmg ) +{ + DASSERT(bmg); + + bmg_item_t * bi = bmg->item; + bmg_item_t * bi_end = bi + bmg->item_used; + while ( bi < bi_end ) + FreeItemBMG(bi++); + + FREE(bmg->item); + + if (bmg->data_alloced) + FREE(bmg->data); + FREE(bmg->raw_data); + FreeString(bmg->fname); + + bmg_raw_section_t *raw = bmg->first_raw; + while (raw) + { + ResetFastBuf(&raw->data); + bmg_raw_section_t *del = raw; + raw = raw->next; + FREE(del); + } + + memset(bmg,0,sizeof(*bmg)); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// ScanRawBMG() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static int CompareU32 ( const u32 *a, const u32 *b ) +{ + return *a < *b ? -1 : *a > *b; +} + +//----------------------------------------------------------------------------- + +static u32 FindMajority32 ( cvp first, uint n_elem, uint delta ) +{ + DASSERT( first || !n_elem ); + + if ( n_elem < 3 ) + return n_elem ? *(u32*)first : 0; + + u32 *buf = MALLOC(n_elem*sizeof(*buf)); + + uint i; + for ( i = 0; i < n_elem; i++ ) + { + buf[i] = *(u32*)first; + first = (u32*)( (u8*)first + delta ); + } + //HexDump16(stderr,0,0,buf,64); + qsort(buf,n_elem,sizeof(*buf),(qsort_func)CompareU32); + + uint max_val = 0, max_count = 0; + const u32 *ptr = buf; + const u32 *end = ptr + n_elem; + while ( ptr < end ) + { + const u32 *beg = ptr; + const u32 val = *ptr++; + while ( ptr < end && *ptr == val ) + ptr++; + if ( ptr - beg > max_count ) + { + max_count = ptr - beg; + max_val = val; + } + } + + FREE(buf); + return max_val; +} + +/////////////////////////////////////////////////////////////////////////////// + +static void scan_raw_cp1252 + ( bmg_item_t *bi, const u8 *start, const u8 *end, FastBuf_t *fb ) +{ + u8 buf[4]; + const u8 *ptr; + for ( ptr = start; ptr < end && *ptr; ) + { + u16 code = *ptr++; + if ( code >= 0x80 && code < 0xa0 ) + code = TableCP1252_80[code-0x80]; + if ( code == 0x1a ) + { + const uint len = *ptr++; + if ( len > 2 ) + { + buf[0] = 0; + buf[1] = 0x1a; + buf[2] = len+1; + AppendFastBuf(fb,buf,3); + AppendFastBuf(fb,ptr,len-2); + if (!(len&1)) + AppendFastBuf(fb,buf,1); + ptr += len - 2; + } + } + else + { + code = htons(code); + AppendFastBuf(fb,&code,2); + } + } + + const mem_t mem = GetFastBufMem(fb); + AssignItemText16BMG(bi,(u16*)mem.ptr,mem.len/2); +} + +//----------------------------------------------------------------------------- + +static void scan_raw_utf16 ( bmg_item_t *bi, const u8 *start, const u8 *end ) +{ + const u8 *ptr; + for ( ptr = start; ptr < end; ptr += 2 ) + { + if (!ptr[0]) + { + if (!ptr[1]) + break; + if ( ptr[1] == 0x1a ) + { + ptr += 2; + const uint skip = *ptr + 1 & 0x1e; + if ( skip > 4 ) + ptr += skip - 4; + } + } + } + + AssignItemText16BMG( bi, (u16*)start, ( ptr - start )/2 ); +} + +//----------------------------------------------------------------------------- + +static void scan_raw_shift_jis + ( bmg_item_t *bi, const u8 *start, const u8 *end, FastBuf_t *fb ) +{ + u8 buf[4]; + const u8 *ptr; + for ( ptr = start; ptr < end; ) + { + int code = ScanShiftJISChar(&ptr); + if (!code) + break; + if ( code == 0x1a ) + { + const uint len = *ptr++; + if ( len > 2 ) + { + buf[0] = 0; + buf[1] = 0x1a; + buf[2] = len+1; + AppendFastBuf(fb,buf,3); + AppendFastBuf(fb,ptr,len-2); + if (!(len&1)) + AppendFastBuf(fb,buf,1); + ptr += len - 2; + } + } + else if ( code >= 0 ) + { + code = htons(code); + AppendFastBuf(fb,&code,2); + } + } + + const mem_t mem = GetFastBufMem(fb); + AssignItemText16BMG(bi,(u16*)mem.ptr,mem.len/2); +} + +//----------------------------------------------------------------------------- + +static void scan_raw_utf8 + ( bmg_item_t *bi, const u8 *start, const u8 *end, FastBuf_t *fb ) +{ + u8 buf[4]; + const u8 *ptr; + for ( ptr = start; ptr < end && *ptr; ) + { + u32 code = ScanUTF8AnsiCharE((ccp*)&ptr,(ccp)end); + if ( code >= 0x80 && code < 0xa0 ) + code = TableCP1252_80[code -0x80]; + if ( code == 0x1a ) + { + const uint len = *ptr++; + if ( len > 2 ) + { + buf[0] = 0; + buf[1] = 0x1a; + buf[2] = len+1; + AppendFastBuf(fb,buf,3); + AppendFastBuf(fb,ptr,len-2); + if (!(len&1)) + AppendFastBuf(fb,buf,1); + ptr += len - 2; + } + } + else + { + code = htons(code); + AppendFastBuf(fb,&code,2); + } + } + + const mem_t mem = GetFastBufMem(fb); + AssignItemText16BMG(bi,(u16*)mem.ptr,mem.len/2); +} + +/////////////////////////////////////////////////////////////////////////////// + +enumError ScanRawBMG ( bmg_t * bmg ) +{ + DASSERT(bmg); + DASSERT(bmg->data); + + const bmg_header_t * bh = (bmg_header_t*)bmg->data; + DASSERT(!memcmp(bh->magic,BMG_MAGIC,sizeof(bh->magic))); + + u32 data_size = ntohl(bh->size); + if ( data_size > bmg->data_size ) + { + ERROR0(ERR_WARNING, + "BMG is %u bytes shorter than announced: %s", + data_size - bmg->data_size, bmg->fname ); + data_size = bmg->data_size; + } + + const bmg_sect_list_t *sl = ScanSectionsBMG(bmg->data,data_size); + if ( !sl || !sl->header ) + return ERROR0(ERR_INVALID_DATA,"Invalid BMG data: %s",bmg->fname); + + + //--- check encoding + + bmg->encoding = bh->encoding; + switch (bmg->encoding) + { + case BMG_ENC_CP1252: + case BMG_ENC_UTF16BE: + case BMG_ENC_SHIFT_JIS: + case BMG_ENC_UTF8: + //>>> ok! <<< + break; + + default: + if (!opt_bmg_force_count) + return ERROR0(ERR_ERROR, + "Can't read BMG with encoding #%u (%s): %s\n", + bmg->encoding, GetEncodingNameBMG(bmg->encoding,"?"), + bmg->fname ); + ERROR0(ERR_WARNING, + "Try to read BMG with unsupported encoding #%u (%s): %s\n", + bmg->encoding, GetEncodingNameBMG(bmg->encoding,"?"), + bmg->fname ); + } + + + //--- iterate sections + + const bmg_sect_info_t *si; + for ( si = sl->info; si->sect; si++ ) + { + if ( si->real_size < si->sect_size ) + ERROR0(ERR_WARNING, + "Size of BMG section %s set to %u bytes (%u lesser than announced): %s\n", + PrintID(si->sect->magic,4,0), + si->real_size, si->sect_size - si->real_size, bmg->fname ); + + if ( !si->supported ) + { + bmg_raw_section_t *raw = CreateRawSectionBMG(bmg,si->sect->magic); + DASSERT(raw); + AssignFastBuf( &raw->data, si->sect->data, + si->real_size - sizeof(bmg_section_t) ); + raw->total_size = si->real_size; + PRINT("SCAN/RAW SECTION »%s« data: %u = 0x%x, total: %u = 0x%x\n", + PrintID(raw->magic,4,0), + GetFastBufLen(&raw->data), GetFastBufLen(&raw->data), + raw->total_size, raw->total_size ); + } + } + + PRINT("%p %p %p\n",sl->pinf,sl->pdat,sl->pmid); + const bmg_inf_t *pinf = bmg->inf = sl->pinf; + const bmg_dat_t *pdat = bmg->dat = sl->pdat; + const bmg_mid_t *pmid = bmg->mid = sl->pmid; + + if ( !sl->pinf || !sl->pdat ) + return ERROR0(ERR_INVALID_DATA,"Corrupted BMG file: %s\n",bmg->fname); + + bmg->unknown_inf_0c = ntohl(pinf->unknown_0c); + + uint max_item; + bmg->have_mid = pmid != 0; + if (bmg->have_mid) + { + bmg->unknown_mid_0a = ntohs(pmid->unknown_0a); + bmg->unknown_mid_0c = ntohl(pmid->unknown_0c); + + max_item = ( ntohl(pmid->size) - sizeof(*pmid) ) / sizeof(*pmid->mid); + if ( max_item > ntohs(pmid->n_msg) ) + max_item = ntohs(pmid->n_msg); + PRINT("BMG with MID1: N=%u [inf=%u,mid=%u], %s\n", + max_item, ntohs(pinf->n_msg), ntohs(pmid->n_msg), bmg->fname ); + } + else + { + max_item = ntohs(pinf->n_msg); + PRINT("BMG without MID1: N=%u, %s\n",max_item,bmg->fname); + } + + const uint max_offset = ( ntohl(pdat->size) - sizeof(*pdat) ) + / sizeof(*pdat->text_pool); + const u8 *text_end = pdat->text_pool + max_offset; + + const u8 *raw_inf = (u8*)pinf->list; + const uint src_inf_size = ntohs(pinf->inf_size); + AssignInfSizeBMG(bmg,src_inf_size); + + + //--- find default attributes + + if (!opt_bmg_def_attrib) + { + uint idx; + for ( idx = 0; idx < bmg->attrib_used; idx += 4 ) + { + const u32 major = FindMajority32(raw_inf+idx+4,max_item,src_inf_size); + noPRINT("-> IDX: %2u -> %8x\n",idx,ntohl(major)); + memcpy(bmg->attrib+idx,&major,4); + } + //HexDump16(stderr,8,0x10,bmg->attrib,bmg->attrib_used); + } + + + //--- decode raw files + + struct { FastBuf_t b; char space[500]; } fb_mgr; + InitializeFastBuf(&fb_mgr,sizeof(fb_mgr)); + #if HAVE_PRINT + uint ins_count = 0, empty_count = 0; + #endif + + uint prev_mid = 0; + uint slot, unsort_count = 0, ffff_count = 0; + for ( slot = 0; slot < max_item; slot++, raw_inf += src_inf_size ) + { + bmg_inf_item_t *item = (bmg_inf_item_t*)raw_inf; + const u32 offset = ntohl(item->offset); + + u32 mid = pmid ? ntohl(pmid->mid[slot]) : slot; + if ( mid == 0xffff && !offset ) + ffff_count++; + if ( mid < prev_mid ) + unsort_count++; + prev_mid = mid; + + #ifdef TEST + if ( offset >= max_offset ) + return ERROR0(ERR_INVALID_DATA, + "Invalid pointer at file offset 0x%zx (INF item #%u): %s\n", + (u8*)&pinf->list[slot].offset - bmg->data, slot, bmg->fname); + #else + if ( offset >= max_offset ) + return ERROR0(ERR_INVALID_DATA,"Corrupted BMG file: %s\n",bmg->fname); + #endif + + #if HAVE_PRINT0 + { + bmg_item_t *bi = FindItemBMG(bmg,mid); + if (bi) + PRINT("MID EXISTS: %x, slot:%x\n",mid,slot); + } + #endif + + bmg_item_t *bi = InsertItemBMG(bmg,mid,item->attrib,bmg->attrib_used,0); + DASSERT(bi); + bi->slot = slot < BMG_NO_PREDEF_SLOT ? slot : BMG_NO_PREDEF_SLOT; + + if (!offset) + { + #if HAVE_PRINT + empty_count++; + #endif + AssignItemText16BMG(bi,bmg_null_entry,0); + continue; + } + + switch (bmg->encoding) + { + case BMG_ENC_CP1252: + ClearFastBuf(&fb_mgr.b); + scan_raw_cp1252( bi, pdat->text_pool + offset, text_end, &fb_mgr.b ); + break; + + case BMG_ENC_UTF16BE: + scan_raw_utf16( bi, pdat->text_pool + offset, text_end ); + break; + + case BMG_ENC_SHIFT_JIS: + ClearFastBuf(&fb_mgr.b); + scan_raw_shift_jis( bi, pdat->text_pool + offset, text_end, &fb_mgr.b ); + break; + + case BMG_ENC_UTF8: + ClearFastBuf(&fb_mgr.b); + scan_raw_utf8( bi, pdat->text_pool + offset, text_end, &fb_mgr.b ); + break; + + default: + // fallback for cast opt_bmg_force_count>0 + DASSERT(opt_bmg_force_count); + ClearFastBuf(&fb_mgr.b); + scan_raw_cp1252( bi, pdat->text_pool + offset, text_end, &fb_mgr.b ); + break; + } + + #if HAVE_PRINT + ins_count++; + #endif + } + + #if HAVE_PRINT + PRINT("BMG: %u+%u=%u/%u messages inserted => %u | n(unsort)=%d, n(ffff)=%d\n", + empty_count, ins_count, empty_count+ins_count, + max_item, bmg->item_used, + unsort_count, ffff_count ); + #endif + ResetFastBuf(&fb_mgr.b); + + bmg->have_predef_slots = pmid && max_item > 1 + && ( unsort_count > 1 || ffff_count > 1 ); + + if (bmg->have_predef_slots) + { + bmg_item_t *bi = FindItemBMG(bmg,0xffff); + if ( bi && isSpecialEntryBMG(bi->text) ) + AssignItemText16BMG(bi,0,0); + } + else + { + // clear slots settings + bmg_item_t *bi, *bi_end = bmg->item + bmg->item_used; + for ( bi = bmg->item; bi < bi_end; bi++ ) + bi->slot = BMG_NO_PREDEF_SLOT; + } + + return ERR_OK; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// ScanTextBMG() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +int (*AtHookBMG) ( bmg_t * bmg, ccp line, ccp line_end ) = 0; + +/////////////////////////////////////////////////////////////////////////////// + +static char * GetNext ( ccp ptr, ccp end ) +{ + DASSERT(ptr); + DASSERT(end); + + while ( ptr < end && ( *ptr == ' ' || *ptr == '\t' || *ptr == '\r' ) ) + ptr++; + return (char*)ptr; +} + +/////////////////////////////////////////////////////////////////////////////// +// [[xbuf]] GetText ( FastBuf_t *fb ccp ptr, ccp end, uint *len ) + +static char * GetText ( char *buf, uint bufsize, ccp ptr, ccp end, uint *len ) +{ + DASSERT(buf); + DASSERT(bufsize>10); + + char *dest = buf; + char *dest_end = buf + bufsize - 1; + + ptr = GetNext(ptr,end); + + if ( ptr < end && ( *ptr == '\'' || *ptr == '\"' ) ) + { + const char quote = *ptr++; + while ( ptr < end && *ptr != quote ) + { + if ( dest < dest_end ) + *dest++ = *ptr; + ptr++; + } + if ( *ptr == quote ) + ptr++; + } + else + { + while ( ptr < end && (uchar)*ptr > ' ' ) + { + if ( dest < dest_end ) + *dest++ = *ptr; + ptr++; + } + } + + *dest = 0; + if (len) + *len = dest - buf; + return GetNext(ptr,end); +} + +/////////////////////////////////////////////////////////////////////////////// + +enumError ScanTextBMG ( bmg_t * bmg ) +{ + DASSERT(bmg); + TRACE("SCAN BMG/TEXT: %s\n",bmg->fname); + bmg->is_text_src = true; + + ccp ptr = (ccp)bmg->data; + ccp end = ptr + bmg->data_size; + ptr += GetTextBOMLen(ptr,bmg->data_size); + + ccp bmg_name = 0; +// [[xbuf]] + char xbuf[2*BMG_MSG_BUF_SIZE]; + enumError err_stat = ERR_OK; + u32 cond = 0; + + ParamField_t assign; + InitializeParamField(&assign); + assign.free_data = true; + + for(;;) + { + while ( ptr < end && (uchar)*ptr <= ' ' ) + ptr++; + if ( ptr >= end ) + break; + + ccp start = ptr = GetNext(ptr,end); + while ( ptr < end && *ptr != '\r' && *ptr != '\n' ) + ptr++; + + if ( *start == '@' ) + { + if (AtHookBMG) + { + const int stat = AtHookBMG(bmg,start,ptr); + if ( stat < -1 ) + continue; + if ( stat >= 0 ) + { + err_stat = stat; + break; + } + } + + start = GetNext(start+1,ptr); + const bool silent = start < ptr && *start == '!'; + if (silent) + start = GetNext(start+1,ptr); + + if ( *start == '?' ) + { + // SYNTAX/IF: '@?' MID_COND + + u32 mid; + ScanMidBMG(bmg,&mid,0,0,start+1,end,(char**)&start); + if ( ptr >= end ) + break; + cond = mid; + continue; + } + + if ( *start == '=' ) + { + // SYNTAX/MATCH: '@=' PATTERN [':'] LINE + + uint len; +// [[xbuf]] + start = GetText(xbuf,sizeof(xbuf),start+1,ptr,&len); + if (len) + { +// [[xbuf]] + PRINT("MATCH |%s|\n",xbuf); + if (!bmg_name) + { + bmg_name = GetNameBMG(bmg,0); + PRINT("NAME |%s|\n",bmg_name); + } + +// [[xbuf?]] + if (MatchPattern(xbuf,bmg_name,'/')) + { + ptr = GetNext(start,ptr); + if ( *ptr == ':' ) + ptr++; + } + } + continue; + } + + if ( *start == '$' ) + { + // SYNTAX/ECHO: '@$' TEXT_TO_EOL + + if (opt_bmg_allow_print) + { + start++; + printf("#%.*s\n",(int)(ptr-start),start); + } + continue; + } + + const bool close_current = *start == '>'; + if ( close_current || *start == '<' ) + { + // SYNTAX/GOTO: '@' ['!'] '>' FILE + // SYNTAX/INCLUDE: '@' ['!'] '<' FILE + + uint len; +// [[xbuf]] + start = GetText(xbuf,sizeof(xbuf),start+1,ptr,&len); + if ( len && bmg->recurse_depth < opt_bmg_max_recurse ) + { + PRINT("BMG/%s: %s\n",close_current?"GOTO":"INCLUDE",xbuf); + bmg_t bmg2; +// [[xbuf?]] + const enumError err + = LoadBMG(&bmg2,true,bmg->fname,xbuf,silent?FM_SILENT:0); + if ( err == ERR_OK ) + PatchOverwriteBMG(bmg,&bmg2,true); + ResetBMG(&bmg2); + if ( close_current && err != ERR_CANT_OPEN ) + break; + } + continue; + } + + char namebuf[100], *nptr = namebuf; + while ( start < ptr && *start > ' ' && *start < 'z' && *start != '=' ) + { + if ( nptr < namebuf + sizeof(namebuf) - 1 ) + *nptr++ = toupper((int)*start); + start++; + } + *nptr = 0; + start = GetNext(start,ptr); + + + //--- settings without mandatory '=' + + const bool have_equal = start < ptr && *start == '='; + if (have_equal) + start = GetNext(start+1,ptr); + + if (!strcmp(namebuf,"SECTION")) + { + bmg->current_raw = 0; + uint len = ScanEscapedString(namebuf,sizeof(namebuf), + start, ptr-start, false, -1, 0 ); + if (!len) + continue; + if ( len > 4 ) + { + ERROR0(ERR_WARNING, + "@SECTION name exceeds 4 [%u] characters: %s\n", + len, namebuf ); + continue; + } + while ( len < 4 ) + namebuf[len++] = 0; + PRINT("@SECTION »%s« %02x %02x %02x %02x\n", + PrintID(namebuf,4,0), + namebuf[0], namebuf[1], namebuf[2], namebuf[3] ); + bmg->current_raw = CreateRawSectionBMG(bmg,namebuf); + DASSERT(bmg->current_raw); + ClearFastBuf(&bmg->current_raw->data); + continue; + } + + if (!strcmp(namebuf,"X")) + { + if (!bmg->current_raw) + continue; + + // skip addr + + ccp p = start; + while (isalnum((int)*p)) + p++; + if ( p > start && *p == ':' ) + start = p+1; + + for (;;) + { + start = GetNext(start,ptr); + if ( start >= ptr || *start == ':' ) + break; + char *end; + uint num = str2ul(start,&end,16); + if ( end == start ) + break; + start = end; + AppendCharFastBuf(&bmg->current_raw->data,num); + } + continue; + } + + + //--- settings with mandatory '=' + + if ( !have_equal || start >= ptr ) + continue; + + noPRINT("PARAM: %s = |%.*s|\n",namebuf,(int)(ptr-start),start); + if (!strcmp(namebuf,"ENCODING")) + AssignEncodingBMG(bmg,str2l(start,0,10)); + else if (!strcmp(namebuf,"BMG-MID")) + bmg->have_mid = str2ul(start,0,10) > 0; + else if (!strcmp(namebuf,"INF-SIZE")) + AssignInfSizeBMG(bmg,str2ul(start,0,10)); + else if (!strcmp(namebuf,"DEFAULT-ATTRIBS")) + { + noPRINT("--- SCAN ATTRIB: %.*s\n",(int)(ptr-start),start); + scan_attrib(bmg->attrib,bmg->attrib_used,start); + //HEXDUMP16(0,0,bmg->attrib,bmg->attrib_used); + } + else if (!strcmp(namebuf,"UNKNOWN-INF32-0C")) + bmg->unknown_inf_0c = str2ul(start,0,10); + else if (!strcmp(namebuf,"UNKNOWN-MID16-0A")) + bmg->unknown_mid_0a = str2ul(start,0,10); + else if (!strcmp(namebuf,"UNKNOWN-MID32-0C")) + bmg->unknown_mid_0c = str2ul(start,0,10); + continue; + } + + + //--- scan message ids + + u32 mid1 = 0, mid2 = 0, mid3 = 0; + const int mid_stat + = ScanMidBMG(bmg,&mid1,&mid2,&mid3,start,end,(char**)&start); + + if ( mid_stat <= 0 ) // not a valid message line + continue; + + //--- scan predifined slot + + bmg_slot_t slot = BMG_NO_PREDEF_SLOT; + if ( *start == '@' ) + { + char *end; + uint num = str2l(++start,&end,16); + PRINT0("SLOT[%#x] = %#x\n",mid1,num); + if ( end > start && num < BMG_NO_PREDEF_SLOT ) + slot = num; + start = GetNext(end,ptr); + } + + + //--- scan attributes + + u8 attrib_buf[BMG_ATTRIB_SIZE]; + memcpy(attrib_buf,bmg->attrib,sizeof(attrib_buf)); + uint attrib_used = 0; + + if ( *start == '[' ) + { + ccp aptr = scan_attrib(attrib_buf,bmg->attrib_used,start+1); + aptr = GetNext(aptr,ptr); + if ( *aptr == ']' ) + { + attrib_used = bmg->attrib_used; + start = GetNext(aptr+1,ptr); + } + } + + if ( *start == '/' || *start == '~' ) + { + if ( *start == '~' ) + { + attrib_used = bmg->attrib_used; + start = GetNext(start+1,ptr); + + if ( *start == '[' ) + scan_attrib(attrib_buf,attrib_used,start); + else + { + memset(attrib_buf,0,sizeof(attrib_buf)); + const u32 attr = str2ul(start,0,10); + write_be32(attrib_buf,attr); + } + } + + bmg_item_t * bi = InsertItemBMG(bmg,mid1,attrib_buf,attrib_used,0); + DASSERT(bi); + bi->slot = slot; + AssignItemText16BMG(bi,bmg_null_entry,0); + if (mid2) + { + bi = InsertItemBMG(bmg,mid2,attrib_buf,attrib_used,0); + DASSERT(bi); + bi->slot = slot; + AssignItemText16BMG(bi,bmg_null_entry,0); + } + if (mid3) + { + bi = InsertItemBMG(bmg,mid3,attrib_buf,attrib_used,0); + DASSERT(bi); + bi->slot = slot; + AssignItemText16BMG(bi,bmg_null_entry,0); + } + continue; + } + + if ( *start == ':' ) + { + start = GetNext(start+1,end); + ccp ptr = start; + while ( ptr < end && isalnum((int)*ptr) ) + ptr++; + + if ( ptr > start ) + { + u32 *tab[] = { &mid1, &mid2, &mid3, 0 }, **tptr; + for ( tptr = tab; *tptr; tptr++ ) + { + const u32 mid = **tptr; + if (mid) + { + DeleteItemBMG(bmg,mid); + + char midbuf[20]; + snprintf(midbuf,sizeof(midbuf),"%x",mid); + noPRINT("BMG ASSIGN: %5s = |%.*s|\n", + midbuf,(int)(ptr-start),start); + InsertParamField(&assign,midbuf,false,mid,MEMDUP(start,ptr-start)); + } + } + } + continue; + } + + if ( *start != '=' ) // not a valid line + continue; + +// [[xbuf]] + // assume that xbuf is large enough + // => make only simple and silent buffer overrun tests + +// [[xbuf?]] + char * in_beg = xbuf + sizeof(xbuf)/2; + char * in_end = xbuf + sizeof(xbuf) - 0x10; + DASSERT( in_beg < in_end ); + char * in_ptr = in_beg; + + for(;;) + { + if ( ptr[-1] == '\r' ) + ptr--; + start++; + if ( *start == ' ' ) + start++; + if ( start > ptr ) + start = ptr; + + int len = ptr - start; + if ( len > in_end - in_ptr ) + len = in_end - in_ptr; + memcpy(in_ptr,start,len); + in_ptr += len; + + while ( ptr < end && (uchar)*ptr <= ' ' ) + ptr++; + if ( ptr == end || *ptr != '+' ) + break; + + start = ptr; + while ( ptr < end && *ptr != '\n' ) + ptr++; + } + *in_ptr = 0; + + const int in_len = in_ptr - in_beg; + noPRINT("%x,%x,%x |%.*s|\n",mid1,mid2,mid3,in_len,in_beg); +// [[xbuf]] ScanFastBuf16BMG(); + u16 * dest_buf = (u16*)xbuf; + const uint len16 + = ScanString16BMG( dest_buf, sizeof(xbuf)/sizeof(u16), in_beg, in_len, bmg ); + + bmg_item_t * bi = InsertItemBMG(bmg,mid1,attrib_buf,attrib_used,0); + DASSERT(bi); + bi->cond = cond; + bi->slot = slot; + AssignItemText16BMG(bi,dest_buf,len16); + if (mid2) + { + bi = InsertItemBMG(bmg,mid2,attrib_buf,attrib_used,0); + DASSERT(bi); + bi->cond = cond; + bi->slot = slot; + AssignItemText16BMG(bi,dest_buf,len16); + } + if (mid3) + { + bi = InsertItemBMG(bmg,mid3,attrib_buf,attrib_used,0); + DASSERT(bi); + bi->cond = cond; + bi->slot = slot; + AssignItemText16BMG(bi,dest_buf,len16); + } + } + + + //--- manage assignments + + bool dirty = assign.used > 0; + while (dirty) + { + dirty = false; + ParamFieldItem_t *pfi = assign.field, *end; + for ( end = pfi + assign.used; pfi < end; pfi++ ) + { + if (!pfi->num) + continue; + + bmg_item_t *bi = FindItemBMG(bmg,pfi->num); + noPRINT("## %5x = %5s = |%s| -> found=%d, len=%d\n", + pfi->num, pfi->key, (ccp)pfi->data, bi!=0, bi ? bi->len : -1 ); + pfi->key = 0; + if ( bi && bi->len ) + { + pfi->num = 0; + continue; + } + + bmg_scan_mid_t scan; + ScanBMGMID(&scan,bmg,(ccp)pfi->data,0); + if ( scan.status < 1 ) + { + pfi->num = 0; + continue; + } + + uint i; + for ( i = 0; i < scan.n_mid; i++ ) + { + bmg_item_t *src = FindItemBMG(bmg,scan.mid[i]); + if ( src && src->text ) + { + bmg_item_t *dest + = InsertItemBMG(bmg,pfi->num,src->attrib,src->attrib_used,0); + DASSERT(dest); + + // src is invalid now => search again + src = FindItemBMG(bmg,scan.mid[i]); + if (src) + { + AssignItemText16BMG(dest,src->text,src->len); + dest->attrib_used = src->attrib_used; + memcpy(dest->attrib,src->attrib,dest->attrib_used); + dirty = true; + pfi->num = 0; + } + break; + } + } + } + } + ResetParamField(&assign); + + + //--- terminate + + if (bmg->data_alloced) + FREE(bmg->data); + bmg->data = 0; + bmg->data_size = 0; + + return err_stat; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// ScanBMG(), LoadBMG() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +enumError ScanBMG +( + bmg_t * bmg, // pointer to valid bmg + bool initialize, // true: initialize 'bmg' + ccp fname, // NULL or filename for error messages + const u8 * data, // data / if NULL: use internal data + size_t data_size // size of 'data' if data not NULL +) +{ + if (initialize) + InitializeBMG(bmg); + else if (data) + ResetBMG(bmg); + + if (data) + { + bmg->data = (u8*)data; + bmg->data_size = data_size; + } + + if (fname) + bmg->fname = STRDUP(fname); + + const bmg_header_t * bh = (bmg_header_t*)bmg->data; + if ( !memcmp(bh->magic,BMG_MAGIC,sizeof(bh->magic)) + && ntohl(bh->size) <= bmg->data_size ) + return ScanRawBMG(bmg); + + ccp ptr = (ccp)bmg->data + GetTextBOMLen(bmg->data,bmg->data_size); + if ( !memcmp(ptr,BMG_TEXT_MAGIC,4) ) + return ScanTextBMG(bmg); + + return ERROR0(ERR_INVALID_DATA,"No BMG file: %s\n",bmg->fname); +} + +/////////////////////////////////////////////////////////////////////////////// + +enumError LoadBMG +( + bmg_t * bmg, // pointer to valid bmg + bool initialize, // true: initialize 'bmg' + ccp parent_fname, // NULL or filename of parent for dir-extract + ccp fname, // filename of source + FileMode_t file_mode // open modes +) +{ + DASSERT(bmg); + DASSERT(fname); + PRINT("LoadBMG(%p,init=%d) fname=%s\n", bmg, initialize, fname ); + + if (initialize) + InitializeBMG(bmg); + else + ResetBMG(bmg); + + if (!strcmp(fname,"0")) + { + bmg->is_text_src = false; + bmg->fname = STRDUP(fname); + return ERR_OK; + } + + char path[PATH_MAX]; + if ( *fname != '/' && parent_fname ) + { + ccp slash = strrchr(parent_fname,'/'); + char *dest; + if (slash) + dest = StringCopySM(path,sizeof(path)-2,parent_fname,slash-parent_fname); + else + dest = StringCopyS(path,sizeof(path)-2,parent_fname); + *dest++ = '/'; + StringCopyE(dest,path+sizeof(path),fname); + fname = path; + } + noPRINT(">>> fname: |%s|d\n",fname); + + u8 *data; + uint size; + enumError err = OpenReadFile( fname, 0, file_mode, 0,0, + &data, &size, &bmg->fname, &bmg->fatt ); + if ( err == ERR_OK ) + { + bmg->data = data; + bmg->data_size = size; + bmg->data_alloced = true; + return ScanBMG(bmg,false,0,0,0); + } + + FREE(data); + return err; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct bmg_create_t /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static void grow_bi_list ( bmg_create_t *bc, uint slot ) +{ + if ( bc->bi_size <= slot ) + { + const uint esize = sizeof(*bc->bi_list); + const uint old_size = bc->bi_size; + const uint byte_size = ( slot + slot/8 + 10 ) * esize; + bc->bi_size = GetGoodAllocSize(byte_size) / esize; + bc->bi_list = REALLOC( bc->bi_list, bc->bi_size * esize ); + memset( bc->bi_list + old_size, 0, ( bc->bi_size - old_size ) * esize ); + PRINT("GROW BI-LIST: %u/%u/%u\n",slot,bc->bi_used,bc->bi_size); + } +} + +//----------------------------------------------------------------------------- + +void InitializeCreateBMG ( bmg_create_t *bc, bmg_t *bmg ) +{ + DASSERT(bc); + DASSERT(bmg); + + memset(bc,0,sizeof(*bc)); + bc->bmg = bmg; + bc->have_mid = opt_bmg_mid == OFFON_AUTO + ? bmg->have_mid : opt_bmg_mid >= OFFON_ON; + + uint n_predef = 0, other_count = 0; + bmg_item_t *bi, *bi_end = bmg->item + bmg->item_used; + for ( bi = bmg->item; bi < bi_end; bi++ ) + if (bi->text) + { + if ( bi->slot == BMG_NO_PREDEF_SLOT ) + other_count++; + else if ( n_predef <= bi->slot ) + n_predef = bi->slot + 1; + } + + bmg->have_predef_slots = n_predef >= 0; + if (n_predef) + { + grow_bi_list( bc, n_predef + other_count ); + + uint next = n_predef; + for ( bi = bc->bmg->item; bi < bi_end; bi++ ) + if (bi->text) + { + uint slot = bi->slot; + if ( slot >= n_predef || bc->bi_list[slot] ) + { + slot = next++; + grow_bi_list(bc,slot); + } + PRINT0(">>> ASSIGN %4x = %4x\n",slot,bi->mid); + bc->bi_list[slot] = bi; + } + + bc->bi_used = next; + PRINT("BI-LIST: %u/%u/%u\n",next,bc->bi_used,bc->bi_size); + } + + uint n_item = bc->bi_used; + if ( n_item < bmg->item_used ) + n_item = bmg->item_used; + + InitializeFastBufAlloc( &bc->inf, n_item * bmg->inf_size ); + InitializeFastBufAlloc( &bc->dat, n_item * 50 ); + InitializeFastBufAlloc( &bc->mid, n_item * sizeof(u32) ); + + if (bc->have_mid) + { + uint i; + for ( i = 0; i < bc->bi_used; i++ ) + AppendBE32FastBuf(&bc->mid,0xffff); + } +} + +//----------------------------------------------------------------------------- + +void ResetCreateBMG ( bmg_create_t *bc ) +{ + DASSERT(bc); + + FREE(bc->bi_list); + ResetFastBuf(&bc->inf); + ResetFastBuf(&bc->dat); + ResetFastBuf(&bc->mid); + memset(bc,0,sizeof(0)); +} + +//----------------------------------------------------------------------------- + +bmg_item_t * GetFirstBI ( bmg_create_t *bc ) +{ + DASSERT(bc); + DASSERT(bc->bmg); + + bc->bi = bc->bmg->item; + bc->bi_end = bc->bi + bc->bmg->item_used; + bc->slot = -1; + return GetNextBI(bc); +} + +//----------------------------------------------------------------------------- + +bmg_item_t * GetNextBI ( bmg_create_t *bc ) +{ + DASSERT(bc); + DASSERT(bc->bmg); + + bmg_t *bmg = bc->bmg; + + bmg_item_t *bi = 0; + int slot = bc->slot + 1; + if (bc->bi_list) + { + while ( slot < bc->bi_used && !bc->bi_list[slot] ) + slot++; + if ( slot < bc->bi_used ) + { + bi = bc->bi_list[slot]; + PRINT0(">>> BI/LIST: %4x: %04x\n",slot,bi->mid); + } + } + else if ( bc->bi < bc->bi_end ) + { + bi = bc->bi++; + PRINT0(">>> BI/DIRECT: %4x: %04x\n",slot,bi->mid); + } + + if (!bi) + { + bc->slot = -1; + return 0; + } + + //--- found: assign data + + bc->slot = slot; + + u32 *pmid = (u32*)WriteFastBuf( &bc->mid, bc->slot*sizeof(u32), + 0, sizeof(u32) ); + DASSERT(pmid); + *pmid = htonl(bi->mid); + + const uint inf_size = bmg->inf_size; + bmg_inf_item_t *ii = (bmg_inf_item_t*)WriteFastBuf + ( &bc->inf, bc->slot * inf_size, 0, inf_size ); + DASSERT(ii); + if ( !isSpecialEntryBMG(bi->text) ) + ii->offset = htonl(GetFastBufLen(&bc->dat)); + memcpy(ii->attrib,bi->attrib,bmg->attrib_used); + + if ( bc->n_msg <= bc->slot ) + bc->n_msg = bc->slot + 1; + return bi; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// CreateRawBMG() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static void create_raw_cp1252 ( bmg_create_t *bc ) +{ + DASSERT(bc); + DASSERT(bc->bmg); + DASSERT(!GetFastBufLen(&bc->dat)); + + AppendCharFastBuf(&bc->dat,0); + + bmg_item_t *bi; + for ( bi = GetFirstBI(bc); bi; bi = GetNextBI(bc) ) + { + if ( !isSpecialEntryBMG(bi->text) ) + { + const u16 *ptr = bi->text; + const u16 *end = ptr + bi->len; + while ( ptr < end ) + { + u16 code = ntohs(*ptr++); + if ( code == 0x1a ) + { + AppendCharFastBuf(&bc->dat,code); + uint len = *(u8*)ptr; + AppendCharFastBuf(&bc->dat,len-1); + AppendFastBuf(&bc->dat,(u8*)ptr+1,len-3); + ptr += (len-1)/2; + } + else if (code) + { + if ( code >= 0x100 ) + { + uint i; + for ( i = 0; i < 0x20; i++ ) + if ( TableCP1252_80[i] == code ) + { + code = i + 0x80; + break; + } + } + if ( code < 0x100 ) + AppendCharFastBuf(&bc->dat,code); + } + } + AppendCharFastBuf(&bc->dat,0); + } + } +} + +//----------------------------------------------------------------------------- + +static void create_raw_utf16 ( bmg_create_t *bc ) +{ + DASSERT(bc); + DASSERT(bc->bmg); + DASSERT(!GetFastBufLen(&bc->dat)); + + AppendBE16FastBuf(&bc->dat,0); + + bmg_item_t *bi; + for ( bi = GetFirstBI(bc); bi; bi = GetNextBI(bc) ) + { + if ( !isSpecialEntryBMG(bi->text) ) + { + AppendFastBuf( &bc->dat, bi->text, bi->len*2 ); + AppendBE16FastBuf(&bc->dat,0); + } + } +} + +//----------------------------------------------------------------------------- + +static void create_raw_shift_jis ( bmg_create_t *bc ) +{ + DASSERT(bc); + DASSERT(bc->bmg); + DASSERT(!GetFastBufLen(&bc->dat)); + + AppendCharFastBuf(&bc->dat,0); + + bmg_item_t *bi; + for ( bi = GetFirstBI(bc); bi; bi = GetNextBI(bc) ) + { + if ( !isSpecialEntryBMG(bi->text) ) + { + const u16 *ptr = bi->text; + const u16 *end = ptr + bi->len; + while ( ptr < end ) + { + const u16 code = ntohs(*ptr++); + if ( code == 0x1a ) + { + AppendCharFastBuf(&bc->dat,code); + uint len = *(u8*)ptr; + AppendCharFastBuf(&bc->dat,len-1); + AppendFastBuf(&bc->dat,(u8*)ptr+1,len-3); + ptr += (len-1)/2; + } + else + { + const int val = GetShiftJISChar(code); + if ( val >= 0x100 ) + AppendBE16FastBuf(&bc->dat,val); + else if ( val > 0 ) + AppendCharFastBuf(&bc->dat,val); + } + } + AppendCharFastBuf(&bc->dat,0); + } + } +} + +//----------------------------------------------------------------------------- + +static void create_raw_utf8 ( bmg_create_t *bc ) +{ + DASSERT(bc); + DASSERT(bc->bmg); + DASSERT(!GetFastBufLen(&bc->dat)); + + AppendCharFastBuf(&bc->dat,0); + + bmg_item_t *bi; + for ( bi = GetFirstBI(bc); bi; bi = GetNextBI(bc) ) + { + if ( !isSpecialEntryBMG(bi->text) ) + { + const u16 *ptr = bi->text; + const u16 *end = ptr + bi->len; + while ( ptr < end ) + { + u16 code = ntohs(*ptr++); + if ( code == 0x1a ) + { + AppendCharFastBuf(&bc->dat,code); + uint len = *(u8*)ptr; + AppendCharFastBuf(&bc->dat,len-1); + AppendFastBuf(&bc->dat,(u8*)ptr+1,len-3); + ptr += (len-1)/2; + } + else if (code) + AppendUTF8CharFastBuf(&bc->dat,code); + } + AppendCharFastBuf(&bc->dat,0); + } + } +} + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +enumError CreateRawBMG +( + bmg_t * bmg // pointer to valid BMG +) +{ + DASSERT(bmg); + TRACE("CreateRawBMG()\n"); + + + //--- setup bmg_create_t + + bmg_create_t bc; + InitializeCreateBMG(&bc,bmg); + PRINT("fb:inf: %s\n", GetFastBufStatus(&bc.inf) ); + PRINT("fb:dat: %s\n", GetFastBufStatus(&bc.dat) ); + PRINT("fb:mid: %s\n", GetFastBufStatus(&bc.mid) ); + + + //--- check encoding + + const int encoding = CheckEncodingBMG(opt_bmg_encoding,bmg->encoding); + switch (encoding) + { + case BMG_ENC_CP1252: + create_raw_cp1252(&bc); + break; + + case BMG_ENC_UTF16BE: + create_raw_utf16(&bc); + break; + + case BMG_ENC_SHIFT_JIS: + SetupGetShiftJISCache(); + create_raw_shift_jis(&bc); + break; + + case BMG_ENC_UTF8: + create_raw_utf8(&bc); + break; + + default: + return ERROR0(ERR_ERROR, + "Can't create BMG with encoding #%u (%s): %s\n", + encoding, GetEncodingNameBMG(encoding,"?"), bmg->fname ); + } + + + //--- count messages + +#if 0 + bmg_item_t *bi, *bi_end = bmg->item + bmg->item_used; + u32 n_msg = 0; + + for ( bi = bmg->item; bi < bi_end; bi++ ) + { + if (bi->text) + n_msg++; + } +#endif + + //--- count size of raw sections + + uint total_raw_size = 0, raw_count = 0; + if (bmg->use_raw_sections) + { + bmg_raw_section_t *raw; + for ( raw = bmg->first_raw; raw; raw = raw->next ) + { + const uint good_size = sizeof(bmg_section_t) + GetFastBufLen(&raw->data); + if ( raw->total_size < good_size ) + raw->total_size = ALIGN32(good_size, raw->next ? opt_bmg_align : 4 ); + total_raw_size += raw->total_size; + raw_count++; + } + } + + + //--- calculate sizes + + const mem_t inf = GetFastBufMem(&bc.inf); + const mem_t mid = GetFastBufMem(&bc.mid); + const mem_t dat = GetFastBufMem(&bc.dat); + + const u32 inf_size = ALIGN32( sizeof(bmg_inf_t) + inf.len, opt_bmg_align ); + const u32 dat_size = ALIGN32( sizeof(bmg_dat_t) + dat.len, opt_bmg_align ); + const u32 mid_size = bc.have_mid + ? ALIGN32( sizeof(bmg_mid_t) + mid.len, opt_bmg_align ) : 0; + + const u32 total_size = sizeof(bmg_header_t) + + inf_size + dat_size + mid_size + + total_raw_size; + + PRINT("SIZE(%u msg): %zx + %x[/%x] + %x + %x = %x\n", + bc.n_msg, sizeof(bmg_header_t), + inf_size, bmg->inf_size, dat_size, mid_size, total_size ); + + + //--- alloc data + + FREE(bmg->raw_data); + bmg->raw_data = CALLOC(total_size,1); + bmg->raw_data_size = total_size; + + + //---- setup bmg header + + bmg_header_t *bh = (bmg_header_t*)bmg->raw_data; + bh->size = htonl(total_size); + bh->n_sections = htonl( ( bc.have_mid ? 3 : 2 ) + raw_count ); + bh->encoding = encoding; + memcpy(bh->magic,BMG_MAGIC,sizeof(bh->magic)); + + u8 *dest = (u8*)(bh+1); + DASSERT( dest <= bmg->raw_data + total_size ); + + + //---- setup inf section + + bmg_inf_t *pinf = (bmg_inf_t*)dest; + pinf->size = htonl(inf_size); + pinf->n_msg = htons(bc.n_msg); + pinf->inf_size = htons(bmg->inf_size); + pinf->unknown_0c = htonl(bmg->unknown_inf_0c); + memcpy(pinf->magic,BMG_INF_MAGIC,sizeof(pinf->magic)); + memcpy(pinf->list,inf.ptr,inf.len); + + dest += inf_size; + DASSERT( dest <= bmg->raw_data + total_size ); + + + //---- setup dat section + + bmg_dat_t * pdat = (bmg_dat_t*)dest; + pdat->size = htonl(dat_size); + memcpy(pdat->magic,BMG_DAT_MAGIC,sizeof(pdat->magic)); + memcpy(pdat->text_pool,dat.ptr,dat.len); + + dest += dat_size; + DASSERT( dest <= bmg->raw_data + total_size ); + + + //---- setup mid section + + if (bc.have_mid) + { + bmg_mid_t *pmid = (bmg_mid_t*)dest; + pmid->size = htonl(mid_size); + pmid->n_msg = htons(bc.n_msg); + pmid->unknown_0a = htons(bmg->unknown_mid_0a); + pmid->unknown_0c = htonl(bmg->unknown_mid_0c); + memcpy(pmid->magic,BMG_MID_MAGIC,sizeof(pmid->magic)); + memcpy(pmid->mid,mid.ptr,mid.len); + + dest += mid_size; + DASSERT( dest <= bmg->raw_data + total_size ); + } + + + //---- copy raw sections + + if (total_raw_size) + { + bmg_raw_section_t *raw; + for ( raw = bmg->first_raw; raw; raw = raw->next ) + { + PRINT("SAVE/RAW SECTION »%s« data: %u = 0x%x, total: %u = 0x%x\n", + PrintID(raw->magic,4,0), + GetFastBufLen(&raw->data), GetFastBufLen(&raw->data), + raw->total_size, raw->total_size ); + + bmg_section_t *sect = (bmg_section_t*)dest; + memcpy(sect->magic,raw->magic,sizeof(sect->magic)); + sect->size = htonl(raw->total_size); + const mem_t mem = GetFastBufMem(&raw->data); + memcpy(sect->data,mem.ptr,mem.len); + + dest += raw->total_size; + DASSERT( dest <= bmg->raw_data + total_size ); + } + } + + + //--- clean + + DASSERT( dest == bmg->raw_data + total_size ); + + PRINT("fb:inf: %s\n", GetFastBufStatus(&bc.inf) ); + PRINT("fb:mid: %s\n", GetFastBufStatus(&bc.mid) ); + PRINT("fb:dat: %s\n", GetFastBufStatus(&bc.dat) ); + ResetCreateBMG(&bc); + return ERR_OK; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// SaveRawBMG() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +enumError SaveRawBMG +( + bmg_t * bmg, // pointer to valid bmg + ccp fname, // filename of destination + FileMode_t fmode, // create-file mode + bool set_time // true: set time stamps +) +{ + DASSERT(bmg); + DASSERT(fname); + PRINT("SaveRawBMG(%s,%d)\n",fname,set_time); + + + //--- create raw data + + enumError err = CreateRawBMG(bmg); + if (err) + return err; + DASSERT(bmg->raw_data); + DASSERT(bmg->raw_data_size); + + + //--- write to file + + File_t F; + err = CreateFile(&F,true,fname,fmode); + if ( err > ERR_WARNING || !F.f ) + return err; + SetFileAttrib(&F.fatt,&bmg->fatt,0); + + if ( fwrite(bmg->raw_data,1,bmg->raw_data_size,F.f) != bmg->raw_data_size ) + FILEERROR1(&F,ERR_WRITE_FAILED,"Write failed: %s\n",fname); + return ResetFile(&F,set_time); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// SaveTextBMG() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +char * PrintAttribBMG +( + char *buf, // destination buffer + uint buf_size, // size of 'buf', BMG_ATTRIB_BUF_SIZE is good + const u8 *attrib, // NULL or attrib to print + uint attrib_used, // used length of attrib + const u8 *def_attrib, // NULL or default attrib + bool force // true: always print '[]' +) +{ + DASSERT(buf); + DASSERT( buf_size >= 10 ); + DASSERT( attrib_used <= BMG_ATTRIB_SIZE); + + static u8 all0[BMG_ATTRIB_SIZE] = {0}; + + if ( !attrib + || !attrib_used +// [[BMG_ATTRIB_SIZE]] + || def_attrib && !memcmp(attrib,def_attrib,attrib_used) ) + { + if (force) + { + *buf++ = '['; + *buf++ = ']'; + } + *buf = 0; + return buf; + } + + char *buf_end = buf + buf_size - 2; + *buf++ = '['; + +// [[BMG_ATTRIB_SIZE]] + if (!memcmp(attrib,all0,attrib_used)) + *buf++ = '0'; + else + { + uint idx; + for ( idx = 0; idx < attrib_used; idx += 4 ) + { + if ( idx && buf < buf_end ) + *buf++ = '/'; + + u32 attrib_val = be32(attrib+idx); + ccp sep = ""; + while (attrib_val) + { + const uint val = (attrib_val >> 24) & 0xff; + if (val) + buf = snprintfE(buf,buf_end,"%s%x",sep,val); + else if ( *sep && buf < buf_end ) + *buf++ = *sep; + sep = ","; + attrib_val <<= 8; + } + } + while ( buf[-1] == '/' ) + buf--; + } + *buf++ = ']'; + *buf = 0; + return buf; +} + +/////////////////////////////////////////////////////////////////////////////// + +static void print_message + ( File_t *F, bmg_t *bmg, const bmg_item_t *bi, ccp mid_name ) +{ + DASSERT(bmg); + DASSERT(bi); + + if ( bmg->active_cond != bi->cond ) + { + bmg->active_cond = bi->cond; + fprintf(F->f,"@? %x\n",bmg->active_cond); + } + + ccp slot; + char slot_buf[10]; + if (!bmg->have_predef_slots) + slot = EmptyString; + else if ( bi->slot == BMG_NO_PREDEF_SLOT ) + slot = " "; + else + { + snprintf(slot_buf,sizeof(slot_buf)," @%04x",bi->slot); + slot = slot_buf; + } + + char attrib[100+BMG_ATTRIB_BUF_SIZE]; +// [[xbuf]] + char xbuf[BMG_MSG_BUF_SIZE]; + + const bool print_attrib + = !opt_bmg_no_attrib + && opt_bmg_single_line < 2 + && bi->attrib_used + && memcmp(bi->attrib,bmg->attrib,bmg->attrib_used); + + if ( print_attrib && !opt_bmg_inline_attrib ) + { + if ( bmg->attrib_used == 4 ) + { + // classic, compatible with all versions + fprintf(F->f,"%s\t~%s 0x%08x\r\n",mid_name,slot,be32(bi->attrib)); + } + else + { + // use new attrib vector + PrintAttribBMG( attrib, sizeof(attrib), + bi->attrib, bi->attrib_used, bmg->attrib, true ); + fprintf(F->f,"%s\t~%s %s\r\n",mid_name,slot,attrib); + } + } + + if ( print_attrib && opt_bmg_inline_attrib ) + { + char *dest = attrib + snprintfS(attrib,sizeof(attrib),"%s%s ",mid_name,slot); + dest = PrintAttribBMG( dest, attrib+sizeof(attrib)-dest, + bi->attrib, bi->attrib_used, bmg->attrib, false ); + *dest++ = ' '; + *dest = 0; + DASSERT( dest < attrib + sizeof(attrib) - 1 ); + } + else + if (*slot) + snprintf(attrib,sizeof(attrib),"%s%s ",mid_name,slot); + else + snprintf(attrib,sizeof(attrib),"%s\t",mid_name); + + if ( bi->text == bmg_null_entry ) + fprintf(F->f,"%s/\r\n",attrib); + else if ( bi->text ) + { + fputs(attrib,F->f); + const int use_colors = opt_bmg_colors != 1 + ? opt_bmg_colors + : bmg->use_color_names > 0; +// [[xbuf?]] + uint len = PrintString16BMG( xbuf, sizeof(xbuf), bi->text, bi->len, + BMG_UTF8_MAX, 0, use_colors ); +// [[xbuf?]] + ccp ptr = xbuf; + ccp end = ptr + len; + ccp sep = "="; + do + { + ccp start = ptr; + ccp temp_end = ptr + 72; + if ( temp_end > end ) + temp_end = end; + ccp good_break = 0; + if ( opt_bmg_single_line || opt_bmg_export ) + ptr = end; + + bool first_loop = true; + while ( ptr < temp_end && !good_break ) + { + for ( ; ptr <= temp_end; ptr++ ) + { + if ( ptr == end ) + { + good_break = ptr; + break; + } + + if ( *ptr == '\\' ) + { + if ( ++ptr >= temp_end ) + break; + if ( *ptr == 'n' ) + { + good_break = ++ptr; + break; + } + if ( *ptr != '\\' && ptr-start > 40 ) + { + good_break = ptr-1; + if (!first_loop) + break; + } + } + else if ( *ptr == ' ' && ptr-start > 40 ) + { + good_break = ptr; + if (!first_loop) + break; + } + } + temp_end = end; + first_loop = false; + } + if ( good_break && good_break < end - 8 ) + ptr = good_break; + + fprintf(F->f,"%s %.*s\r\n", sep, (int)(ptr-start), start ); + sep = "\t+"; + + } while ( ptr < end ); + } +} + +/////////////////////////////////////////////////////////////////////////////// + +enumError SaveTextBMG +( + bmg_t * bmg, // pointer to valid bmg + ccp fname, // filename of destination + FileMode_t fmode, // create-file mode + bool set_time, // true: set time stamps + bool force_numeric, // true: force numric MIDs + uint brief_count // >0: suppress syntax info + // >1: suppress all comments + // >2: suppress '#BMG' magic +) +{ + // use DOS/Windows line format -> unix can handle it ;) + + DASSERT(bmg); + DASSERT(fname); + PRINT("SaveTextBMG(%s,%d)\n",fname,set_time); + bmg->active_cond = 0; + + enum { BRIEF_ALL, BRIEF_NO_SYNTAX, BRIEF_NO_COMMENT, BRIEF_NO_MAGIC }; + + bool already_printed[BMG__VIP_N]; + memset(already_printed,0,sizeof(already_printed)); + char mid_name[10], abuf[BMG_ATTRIB_BUF_SIZE]; + + + static ccp param_announce = + "# All parameters begin with '@'. Unknown parameters are ignored on scanning.\r\n"; + + static const char text_head[] = + { + "#BMG <<< The first 4 characters '#BMG' are the magic for a BMG text file.\r\n" + "# <<< Don't remove them!\r\n" + "#\r\n" + "# Details about BMG text files are available in the Web:\r\n" + "# * Syntax and Semantics: https://szs.wiimm.de/doc/bmg/text\r\n" + "# * The BMG file format: https://szs.wiimm.de/r/wiki/BMG\r\n" + "#\r\n" + "#\f\r\n" + "#------------------------------------------------------------------------------\r\n" + }; + + static const char text_param[] = + { + "%s" + "\r\n" + "# Define encoding of BMG: 1=CP1252, 2=UTF-16/be, 3=Shift-JIS, 4=UTF-8\r\n" + "@ENCODING = %u\r\n" + "\r\n" + "# Create »MID1« section: 0:off, 1=on\r\n" + "@BMG-MID = %u\r\n" + "\r\n" + "# Size of each element of section 'INF1' (MKW=8).\r\n" + "# This setting has impact to attributes and MKW features.\r\n" + "@INF-SIZE = 0x%02x\r\n" + "\r\n" + "# Default attribute values for this BMG (MKW=[1])\r\n" + "@DEFAULT-ATTRIBS = %s\r\n" + "\r\n" + "# Use MKW specific color names: 0=off, 1=auto, 2=on\r\n" + "@COLOR-NAMES = %u\r\n" + "\r\n" + "# Use MKW messages and track names: 0=off, 1=auto, 2=on\r\n" + "@MKW-MESSAGES = %u\r\n" + "\r\n" + "#\f\r\n" + "#------------------------------------------------------------------------------\r\n" + }; + + static const char unknown_param[] = + { + "%s" + "\r\n" + "# This part define values for unknown parameters of section headers.\r\n" + "@UNKNOWN-INF32-0C = %#10x # 32 bit value of section INF1 offset 0x0c\r\n" + "@UNKNOWN-MID16-0A = %#10x # 16 bit value of section MID1 offset 0x0a\r\n" + "@UNKNOWN-MID32-0C = %#10x # 32 bit value of section MID1 offset 0x0c\r\n" + "\r\n" + "#\f\r\n" + "#------------------------------------------------------------------------------\r\n" + }; + + + //--- open file + + File_t F; + enumError err = CreateFile(&F,true,fname,fmode); + if ( err > ERR_WARNING || !F.f ) + return err; + SetFileAttrib(&F.fatt,&bmg->fatt,0); + + const bool print_full = brief_count == BRIEF_ALL && !opt_bmg_export; + if (print_full) + fwrite(text_head,1,sizeof(text_head)-1,F.f); + else if ( brief_count < BRIEF_NO_MAGIC ) + fprintf(F.f,"%s\r\n\r\n",BMG_TEXT_MAGIC); + + HavePredifinedSlots(bmg); + const int encoding = CheckEncodingBMG(opt_bmg_encoding,bmg->encoding); + + const bool print_settings // print only, if unusual + = encoding != BMG_ENC__DEFAULT + || bmg->attrib_used != 4 + || be32(bmg->attrib) != BMG_INF_STD_ATTRIB + || !bmg->have_mid + || !bmg->use_color_names + || !bmg->use_mkw_messages + ; + + if (print_settings) + { + PrintAttribBMG(abuf,sizeof(abuf),bmg->attrib,bmg->attrib_used,0,true); + if (print_full) + { + fprintf(F.f,text_param, + param_announce, + encoding, bmg->have_mid, bmg->inf_size, abuf, + bmg->use_color_names, bmg->use_mkw_messages ); + param_announce = ""; + } + else if ( brief_count < BRIEF_NO_MAGIC ) + fprintf(F.f,"@ENCODING = %u\r\n" + "@BMG-MID = %u\r\n" + "@INF-SIZE = 0x%02x\r\n" + "@DEFAULT-ATTRIBS = %s\r\n" + "@COLOR-NAMES = %u\r\n" + "@MKW-MESSAGES = %u\r\n" + "\r\n", + encoding, bmg->have_mid, bmg->inf_size, abuf, + bmg->use_color_names, bmg->use_mkw_messages ); + } + + if ( print_settings + || bmg->unknown_inf_0c != BMG_INF_DEFAULT_0C + || bmg->unknown_mid_0a != BMG_MID_DEFAULT_0A + || bmg->unknown_mid_0c != BMG_MID_DEFAULT_0C + ) + { + if (print_full) + fprintf(F.f,unknown_param, + param_announce, + bmg->unknown_inf_0c, + bmg->unknown_mid_0a, bmg->unknown_mid_0c ); + else if ( brief_count < BRIEF_NO_MAGIC ) + fprintf(F.f,"@UNKNOWN-INF32-0C = %#x\r\n" + "@UNKNOWN-MID16-0A = %#x\r\n" + "@UNKNOWN-MID32-0C = %#x\r\n" + "\r\n", + bmg->unknown_inf_0c, + bmg->unknown_mid_0a, bmg->unknown_mid_0c ); + } + + + //--- messages + + ccp intro = "\r\n"; + static const char intro_other[] = "\r\n#--- other messages\r\n\r\n"; + + const bool support_mkw + = opt_bmg_support_mkw + && !force_numeric + && !opt_bmg_export + && bmg->attrib_used == 4 + && be32(bmg->attrib) == BMG_INF_STD_ATTRIB + && bmg->have_mid + && !bmg->have_predef_slots; + + if (support_mkw) + { + //--- find track names + + int idx; + uint last_cup = 0; + for ( idx = 0; idx < BMG_N_TRACK; idx++ ) + { + const int tidx = GetTrackIndexBMG(idx,-1); + if ( tidx < 0 ) + continue; + + const bmg_item_t * bi1 = FindItemBMG(bmg,MID_TRACK1_BEG+tidx); + if (bi1) + { + const bmg_item_t * bi2 = FindItemBMG(bmg,MID_TRACK2_BEG+tidx); + if ( bi2 && IsItemEqualBMG(bi1,bi2) ) + { + const uint cup = idx / 4 + '1'; + if ( brief_count < BRIEF_NO_COMMENT && last_cup != cup ) + { + if (!last_cup) + { + intro = intro_other; + fprintf(F.f,"\r\n#--- standard track names\r\n\r\n"); + } + else + fputs("\r\n",F.f); + last_cup = cup; + } + snprintf(mid_name,sizeof(mid_name), " T%c%c", cup, idx % 4 + '1' ); + print_message(&F,bmg,bi1,mid_name); + + already_printed[ bi1->mid - MID__VIP_BEG ] = true; + already_printed[ bi2->mid - MID__VIP_BEG ] = true; + + if (opt_bmg_support_lecode) + { + bi2 = FindItemBMG(bmg,MID_LE_TRACK_BEG+tidx); + if ( bi2 && IsItemEqualBMG(bi1,bi2) ) + already_printed[ bi2->mid - MID__VIP_BEG ] = true; + } + else if (opt_bmg_support_ctcode) + { + bi2 = FindItemBMG(bmg,MID_CT_TRACK_BEG+tidx); + if ( bi2 && IsItemEqualBMG(bi1,bi2) ) + already_printed[ bi2->mid - MID__VIP_BEG ] = true; + } + } + } + } + + + //--- find battle names + + last_cup = 0; + for ( idx = 0; idx < BMG_N_ARENA; idx++ ) + { + const int tidx = GetArenaIndexBMG(idx,-1); + if ( tidx < 0 ) + continue; + + const bmg_item_t * bi1 = FindItemBMG(bmg,MID_ARENA1_BEG+tidx); + if (bi1) + { + const bmg_item_t * bi2 = FindItemBMG(bmg,MID_ARENA2_BEG+tidx); + if ( bi2 && IsItemEqualBMG(bi1,bi2) ) + { + const uint cup = idx / 5 + '1'; + if ( brief_count < BRIEF_NO_COMMENT && last_cup != cup ) + { + if (!last_cup) + { + intro = intro_other; + fprintf(F.f,"\r\n#--- battle track names\r\n\r\n"); + } + else + fputs("\r\n",F.f); + last_cup = cup; + } + snprintf(mid_name,sizeof(mid_name), " U%c%c", cup, idx % 5 + '1' ); + print_message(&F,bmg,bi1,mid_name); + + already_printed[ bi1->mid - MID__VIP_BEG ] = true; + already_printed[ bi2->mid - MID__VIP_BEG ] = true; + + if (opt_bmg_support_lecode) + { + bi2 = FindItemBMG(bmg,MID_LE_ARENA_BEG+tidx); + if ( bi2 && IsItemEqualBMG(bi1,bi2) ) + already_printed[ bi2->mid - MID__VIP_BEG ] = true; + } + else if (opt_bmg_support_ctcode) + { + bi2 = FindItemBMG(bmg,MID_CT_ARENA_BEG+tidx); + if ( bi2 && IsItemEqualBMG(bi1,bi2) ) + already_printed[ bi2->mid - MID__VIP_BEG ] = true; + } + } + } + } + + + //--- find chat strings + + const bmg_item_t * bi1 = FindAnyItemBMG(bmg,MID_CHAT_BEG); + const bmg_item_t * bi1end = FindAnyItemBMG(bmg,MID_CHAT_END); + if ( bi1 < bi1end ) + { + if ( brief_count < BRIEF_NO_COMMENT ) + { + intro = intro_other; + fprintf(F.f,"\r\n#--- online chat\r\n\r\n"); + } + + for ( ; bi1 < bi1end; bi1++ ) + { + DASSERT( bi1->mid >= MID_CHAT_BEG && bi1->mid <= MID_CHAT_END ); + snprintf(mid_name,sizeof(mid_name)," M%02u",bi1->mid-MID_CHAT_BEG+1); + print_message(&F,bmg,bi1,mid_name); + already_printed[bi1->mid-MID__VIP_BEG] = true; + } + } + } + + + //--- print messages not already printed + + struct sep_t { u32 mid; ccp info; }; + + static const struct sep_t sep_std_tab[] = + { + {0,0} + }; + + static const struct sep_t sep_mkw_tab[] = + { + { MID_ENGINE_BEG, "engines" }, + { MID_ENGINE_END, 0 }, + { MID_CHAT_BEG, "online chat" }, + { MID_CHAT_END, 0 }, + + { MID_RCUP_BEG, "racing cup names" }, + { MID_RCUP_END, 0 }, + { MID_TRACK1_BEG, "track names, 1. copy" }, + { MID_TRACK1_END, 0 }, + { MID_BCUP_BEG, "battle cup names" }, + { MID_BCUP_END, 0 }, + { MID_TRACK2_BEG, "track names, 2. copy" }, + { MID_TRACK2_END, 0 }, + + { MID_ARENA1_BEG, "arena names, 1. copy" }, + { MID_ARENA1_END, 0 }, + { MID_ARENA2_BEG, "arena names, 2. copy" }, + { MID_ARENA2_END, 0 }, + + { MID_PARAM_IDENTIFY, "identification for third party tools" }, + { MID_PARAM_IDENTIFY, 0 }, + + { MID_PARAM_BEG, "parameters for mkw-ana" }, + { MID_PARAM_END, 0 }, + + { MID_CT_TRACK_BEG, "CT-CODE: track names" }, + { MID_CT_TRACK_END, 0 }, + { MID_CT_CUP_BEG, "CT-CODE: cup names" }, + { MID_CT_CUP_END, 0 }, + { MID_CT_CUP_REF_BEG, "CT-CODE: track-to-cup reference" }, + { MID_CT_CUP_REF_END, 0 }, + + { MID_X_MESSAGE_BEG, "new messages for CT/LE-CODE" }, + { MID_X_MESSAGE_END, 0 }, + + { MID_LE_CUP_BEG, "LE-CODE: cup names" }, + { MID_LE_CUP_END, 0 }, + { MID_LE_TRACK_BEG, "LE-CODE: track names" }, + { MID_LE_TRACK_END, 0 }, + { MID_LE_CUP_REF_BEG, "LE-CODE: track-to-cup reference" }, + { MID_LE_CUP_REF_END, 0 }, + + {0,0} + }; + + #ifdef TEST + { + fflush(stdout); + const struct sep_t *sep; + for ( sep = sep_std_tab+1; sep->mid; sep++ ) + if ( sep[-1].mid > sep->mid ) + fprintf(stderr, + "Wrong order in sep_std_tab[%zu]:\n\t%04x %s\n\t%04x %s\n", + sep-sep_std_tab, sep[-1].mid, sep[-1].info, sep->mid, sep->info ); + for ( sep = sep_mkw_tab+1; sep->mid; sep++ ) + if ( sep[-1].mid > sep->mid ) + fprintf(stderr, + "Wrong order in sep_mkw_tab[%zu]:\n\t%04x %s\n\t%04x %s\n", + sep-sep_mkw_tab, sep[-1].mid, sep[-1].info, sep->mid, sep->info ); + fflush(stderr); + } + #endif + + const struct sep_t *sep_tab = support_mkw ? sep_mkw_tab : sep_std_tab; + const struct sep_t *sep = brief_count < BRIEF_NO_COMMENT ? sep_tab : 0; + + bmg_item_t * bi = bmg->item; + bmg_item_t * bi_end = bi + bmg->item_used; + for ( ; bi < bi_end; bi++ ) + { + const u32 mid = bi->mid; + if ( mid < MID__VIP_BEG + || mid >= MID__VIP_END + || !already_printed[mid-MID__VIP_BEG] + ) + { + if ( sep && sep->mid && mid >= sep->mid ) + { + sep++; + while ( sep->mid && mid >= sep->mid ) + sep++; + if ( sep > sep_tab+1 && sep[-2].mid == mid && sep[-2].info ) + fprintf(F.f,"\r\n#--- [%x] %s\r\n", mid, sep[-2].info ); + else if ( sep[-1].info ) + fprintf(F.f,"\r\n#--- [%x:%x] %s\r\n", + sep[-1].mid, sep->mid-1, sep[-1].info ); + else + fputs("\r\n",F.f); + intro = 0; + } + + if ( brief_count < BRIEF_NO_COMMENT && intro ) + { + fputs(intro,F.f); + intro = 0; + } + snprintf(mid_name,sizeof(mid_name),"%6x",bi->mid); + print_message(&F,bmg,bi,mid_name); + } + } + + + //--- raw sections + + if ( bmg->use_raw_sections && bmg->first_raw ) + { + XDump_t xd; + InitializeXDump(&xd); + SetupXDump(&xd,XDUMPC_DUMP); + xd.f = F.f; + xd.indent = 1; + xd.prefix = "@X"; + xd.eol = "\r\n"; + xd.format = XDUMPF_INT_1; + xd.print_format = false; + xd.print_summary= false; + + bmg_raw_section_t *raw; + for ( raw = bmg->first_raw; raw; raw = raw->next ) + { + PRINT("HEXDUMP SECTION »%s« data: %u = 0x%x, total: %u = 0x%x\n", + PrintID(raw->magic,4,0), + GetFastBufLen(&raw->data), GetFastBufLen(&raw->data), + raw->total_size, raw->total_size ); + + char name[20]; + fprintf(F.f,"\r\n#\f\r\n#--------------------------------------" + "----------------------------------------\r\n\r\n" + "@SECTION \"%s\"\r\n\r\n", + PrintEscapedString( name, sizeof(name), + raw->magic, sizeof(raw->magic), + CHMD_ESC, '"', 0) ); + + const mem_t data = GetFastBufMem(&raw->data); + xd.assumed_size = data.len; + XDump(&xd,data.ptr,data.len,true); + } + } + + + //--- terminate + + if ( brief_count < 2 ) + fputs("\r\n",F.f); + ResetFile(&F,set_time); + return ERR_OK; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// ScanBMGMID() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +int ScanBMGMID +( + // returns 'scan->status' + + bmg_scan_mid_t *scan, // result, never NULL + bmg_t *bmg, // NULL or bmg to update parameters + ccp src, // source pointer + ccp src_end // NULL or end of source +) +{ + DASSERT(scan); + + //---- setup + + memset(scan,0,sizeof(*scan)); + + ccp ptr = src; + if (!src) + return 0; + if (!src_end) + src_end = src + strlen(src); + + + //--- skip blanks and controls + + while ( ptr < src_end && (uchar)*ptr <= ' ' ) + ptr++; + if ( ptr == src_end ) + goto abort; + + + //--- find keyword + + ccp key = ptr; + while ( ptr < src_end && isalnum((int)*ptr) ) + ptr++; + const uint keylen = ptr - key; + + if ( keylen == 3 ) + { + if ( ( *key == 'T' || *key == 't' ) + && key[1] >= '1' && key[1] <= '8' + && key[2] >= '1' && key[2] <= '4' ) + { + int idx = 4 * ( key[1] - '1' ) + ( key[2] - '1' ); + DASSERT(GetTrackIndexBMG); + idx = GetTrackIndexBMG(idx,-1); + if ( idx >= 0 ) + { + scan->mid[0] = MID_TRACK1_BEG + idx; + scan->mid[1] = MID_TRACK2_BEG + idx; + scan->n_mid = 2; + if (opt_bmg_support_lecode) + { + scan->mid[2] = MID_LE_TRACK_BEG + idx; + scan->n_mid++; + } + else if (opt_bmg_support_ctcode) + { + scan->mid[2] = MID_CT_TRACK_BEG + idx; + scan->n_mid++; + } + if ( bmg && bmg->use_mkw_messages == 1 ) + bmg->use_mkw_messages = 2; + } + } + else if ( ( *key == 'U' || *key == 'u' ) + && key[1] >= '1' && key[1] <= '2' + && key[2] >= '1' && key[2] <= '5' ) + { + int idx = 5 * ( key[1] - '1' ) + ( key[2] - '1' ); + DASSERT(GetArenaIndexBMG); + idx = GetArenaIndexBMG(idx,-1); + if ( idx >= 0 ) + { + scan->mid[0] = MID_ARENA1_BEG + idx; + scan->mid[1] = MID_ARENA2_BEG + idx; + scan->n_mid = 2; + if (opt_bmg_support_lecode) + { + scan->mid[2] = MID_LE_ARENA_BEG + idx; + scan->n_mid++; + } + else if (opt_bmg_support_ctcode) + { + scan->mid[2] = MID_CT_ARENA_BEG + idx; + scan->n_mid++; + } + if ( bmg && bmg->use_mkw_messages == 1 ) + bmg->use_mkw_messages = 2; + } + } + else if ( *key == 'M' || *key == 'm' ) + { + char *end; + u32 num = strtoul(key+1,&end,10); + if ( num > 0 && num <= BMG_N_CHAT && end == ptr ) + { + scan->mid[0] = MID_CHAT_BEG + num - 1; + scan->n_mid = 1; + if ( bmg && bmg->use_mkw_messages == 1 ) + bmg->use_mkw_messages = 2; + } + } + } + + if ( !scan->n_mid && keylen ) + { + char *end; + uint num = strtoul(key,&end,16); + if ( end == ptr ) + { + scan->mid[0] = num; + scan->n_mid = 1; + } + else + scan->status = -1; + } + + if ( scan->n_mid > 0 ) + while ( ptr < src_end && ( *ptr == ' ' || *ptr == '\t' ) ) + ptr++; + + abort: + if (!scan->status) + scan->status = scan->n_mid; + scan->scan_end = scan->status > 0 ? (char*)ptr : (char*)src; + return scan->status; +} + +/////////////////////////////////////////////////////////////////////////////// + +int ScanMidBMG +( + // returns: + // -1: invalid MID + // 0: empty line + // 1: single mid found + // 2: double mid found (track or arena) + // 3: triple mid found (track or arena, CTCODE) + + bmg_t *bmg, // NULL or bmg to update parameters + u32 *ret_mid1, // return value: pointer to first MID + u32 *ret_mid2, // return value: pointer to second MID + u32 *ret_mid3, // return value: pointer to third MID + ccp src, // source pointer + ccp src_end, // NULL or end of source + char **scan_end // return value: NULL or end of scanned 'source' +) +{ +// [[2do]] + #if defined(TEST) || defined(DEBUG) || 1 + + bmg_scan_mid_t scan; + ScanBMGMID(&scan,bmg,src,src_end); + + if (ret_mid1) + *ret_mid1 = scan.n_mid > 0 ? scan.mid[0] : 0; + if (ret_mid2) + *ret_mid2 = scan.n_mid > 1 ? scan.mid[1] : 0; + if (ret_mid3) + *ret_mid3 = scan.n_mid > 2 ? scan.mid[2] : 0; + if (scan_end) + *scan_end = scan.scan_end; + return scan.status; + + #else + //---- setup + + u32 mid1 = 0, mid2 = 0, mid3 = 0; + int stat = 0; + ccp ptr = src; + + if (!src) + goto abort; + if (!src_end) + src_end = src + strlen(src); + + + //--- skip blanks and controls + + while ( ptr < src_end && (uchar)*ptr <= ' ' ) + ptr++; + if ( ptr == src_end ) + goto abort; + + + //--- find keyword + + ccp key = ptr; + while ( ptr < src_end && isalnum((int)*ptr) ) + ptr++; + const uint keylen = ptr - key; + + if ( keylen == 3 ) + { + if ( ( *key == 'T' || *key == 't' ) + && key[1] >= '1' && key[1] <= '8' + && key[2] >= '1' && key[2] <= '4' ) + { + int idx = 4 * ( key[1] - '1' )+ ( key[2] - '1' ); + DASSERT(GetTrackIndexBMG); + idx = GetTrackIndexBMG(idx,-1); + if ( idx >= 0 ) + { + mid1 = MID_TRACK1_BEG + idx; + mid2 = MID_TRACK2_BEG + idx; + stat = 2; + if (opt_bmg_support_lecode) + { + mid3 = MID_LE_TRACK_BEG + idx; + stat++; + } + else if (opt_bmg_support_ctcode) + { + mid3 = MID_CT_TRACK_BEG + idx; + stat++; + } + if ( bmg && bmg->use_mkw_messages == 1 ) + bmg->use_mkw_messages = 2; + } + } + else if ( ( *key == 'U' || *key == 'u' ) + && key[1] >= '1' && key[1] <= '2' + && key[2] >= '1' && key[2] <= '5' ) + { + int idx = 5 * ( key[1] - '1' ) + ( key[2] - '1' ); + DASSERT(GetArenaIndexBMG); + idx = GetArenaIndexBMG(idx,-1); + if ( idx >= 0 ) + { + mid1 = MID_ARENA1_BEG + idx; + mid2 = MID_ARENA2_BEG + idx; + stat = 2; + if (opt_bmg_support_lecode) + { + mid3 = MID_LE_ARENA_BEG + idx; + stat++; + } + else if (opt_bmg_support_ctcode) + { + mid3 = MID_CT_ARENA_BEG + idx; + stat++; + } + if ( bmg && bmg->use_mkw_messages == 1 ) + bmg->use_mkw_messages = 2; + } + } + else if ( *key == 'M' || *key == 'm' ) + { + char *end; + u32 num = strtoul(key+1,&end,10); + if ( num > 0 && num <= BMG_N_CHAT && end == ptr ) + { + mid1 = MID_CHAT_BEG + num - 1; + stat = 1; + if ( bmg && bmg->use_mkw_messages == 1 ) + bmg->use_mkw_messages = 2; + } + } + } + + if ( !stat && keylen ) + { + char *end; + uint num = strtoul(key,&end,16); + if ( end == ptr ) + { + mid1 = num; + stat = 1; + } + else + stat = -1; + } + + if ( stat > 0 ) + while ( ptr < src_end && ( *ptr == ' ' || *ptr == '\t' ) ) + ptr++; + + abort: + if (ret_mid1) + *ret_mid1 = mid1; + if (ret_mid2) + *ret_mid2 = mid2; + if (ret_mid3) + *ret_mid3 = mid3; + if (scan_end) + *scan_end = stat > 0 ? (char*)ptr : (char*)src; + return stat; + #endif +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// patch bmg: helpers /////////////// +/////////////////////////////////////////////////////////////////////////////// + +ccp (*GetContainerNameBMG) ( const bmg_t *bmg ) = 0; + +//----------------------------------------------------------------------------- + +ccp GetNameBMG ( const bmg_t *bmg, uint *name_len ) +{ + DASSERT(bmg); + + ccp name = 0; + if (GetContainerNameBMG) + name = GetContainerNameBMG(bmg); + + if ( !name && bmg->fname ) + { + name = bmg->src_is_arch ? 0 : strstr(bmg->fname,".d/"); + if (name) + { + while ( name > bmg->fname && name[-1] != '/' ) + name--; + } + else + { + name = strrchr(bmg->fname,'/'); + name = name ? name + 1 : bmg->fname; + } + } + + if (!name) + name = ""; + else + while ( *name == '.' ) + name++; + + if (name_len) + { + ccp end = strchr(name,'.'); + *name_len = end ? end-name : strlen(name); + } + + return name; +} + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +typedef struct format_message_t +{ + bmg_t *dest; // valid destination bmg + uint mod_count; // incremented for each modification + + ccp full_name; // NULL or full name of source file + uint full_len; // length of 'full_name' + ccp good_name; // NULL or good name of source file + uint good_len; // length of 'good_name' +} +format_message_t; + +//----------------------------------------------------------------------------- + +static bool format_message +( + format_message_t *fm, // valid object + bmg_item_t *dptr, // valid message + const u16 *format, // format string + uint format_len // length of 'format' +) +{ + DASSERT(fm); + DASSERT(fm->dest); + DASSERT(dptr); + DASSERT(format); + + + //--- line support + + typedef struct line_t + { + const u16 *beg; + const u16 *end; + } + line_t; + + const uint MAX_LINE = 100; + line_t line[100]; + uint n_line = 0; + + + //--- setup dest and source + + u16 buf[10000]; + u16 *dest = buf; + u16 *dest_end = buf + sizeof(buf)/sizeof(*buf); + u16* marker = buf; + + const u16 *source = format; + const u16 *source_end = format + format_len; + + + //--- main loop + + while ( dest < dest_end && source < source_end ) + { + if ( be16(source) != '%' ) + { + *dest++ = *source++; + continue; + } + + if ( source[0] == source[1] ) + { + source++; + *dest++ = *source++; + continue; + } + + PRINT("%04x = %c\n",be16(source), be16(source) & 0xff ); + const u16 *start = source++; + + u32 p1, p2, stat; + source = ScanRange16U32(source,&stat,&p1,&p2,0,~(u32)0); + if ( stat == 1 ) + p1 = 0; + else if ( stat < 1 ) + { + p1 = 0; + p2 = M1(p2); + } + + char buf8[50]; + uint copy_len = 0; + const u8 * copy_src8 = 0; + const u16 * copy_src16 = 0; + + const u16 conv_char = be16(source++); + switch (conv_char) + { + case 's': + case 'S': + copy_len = dptr->len; + copy_src16 = dptr->text; + break; + + case 'i': + copy_len = snprintf(buf8,sizeof(buf8),"%x",dptr->mid); + copy_src8 = (u8*)buf8; + break; + + case 'I': + copy_len = snprintf(buf8,sizeof(buf8),"%04x",dptr->mid); + copy_src8 = (u8*)buf8; + break; + + case 'n': + case 'N': + if (!fm->full_name) + { + fm->full_name = GetNameBMG(fm->dest,&fm->full_len); + if ( fm->full_len > 4 && !strncasecmp(fm->full_name,"Menu",4) ) + { + fm->good_name = fm->full_name + 4; + fm->good_len = fm->full_len - 4; + } + else + { + fm->good_name = fm->full_name; + fm->good_len = fm->full_len; + } + } + + if ( conv_char == 'N' ) + { + copy_len = fm->good_len; + copy_src8 = (u8*)fm->good_name; + } + else + { + copy_len = fm->full_len; + copy_src8 = (u8*)fm->full_name; + } + break; + + case 'm': + marker = dest; + break; + + case 'l': + case 'L': + case 'M': + if (!n_line) + { + const u16 *src = dptr->text; + const u16 *end = src + dptr->len; + while ( n_line < MAX_LINE ) + { + line[n_line].beg = src; + while ( src < end ) + { + if ( ntohs(*src) == '\n' ) + break; + + src += GetWordLength16BMG(src); + } + line[n_line].end = src; + n_line++; + if ( src >= end ) + break; + src++; + } + PRINT("L: %u lines found\n",n_line); + } + + if ( stat == 1 ) + p1 = p2; + if ( p2 > n_line-1 ) + p2 = n_line-1; + PRINT("L: select %u..%u/%u\n",p1,p2,n_line); + + if ( p1 <= p2 ) + { + copy_src16 = line[p1].beg; + copy_len = line[p2].end - copy_src16; + } + + if ( conv_char == 'M' ) + { + if ( !copy_len && marker ) + dest = marker; + //marker = 0; + copy_len = 0; + } + else + { + if ( !copy_len && conv_char == 'L' && marker ) + dest = marker; + //if ( conv_char == 'L' ) + // marker = 0; + } + p1 = 0; + p2 = M1(p2); + break; + + default: + copy_len = source - start; + copy_src16 = start; + break; + } + + if (copy_len) + { + // correct p1 and p2 + if ( p1 > copy_len ) + p1 = copy_len; + if ( p2 > copy_len ) + p2 = copy_len; + + u32 count = p2 - p1; + if (copy_src16) + { + copy_src16 += p1; + while ( count-- > 0 && dest < dest_end ) + *dest++ = *copy_src16++; + } + else if (copy_src8) + { + copy_src8 += p1; + while ( count-- > 0 && dest < dest_end ) + *dest++ = htons(*copy_src8++); + } + } + } + + const uint new_len = dest - buf; + if ( new_len != dptr->len || memcmp(buf,dptr->text,new_len*sizeof(*dest)) ) + { + AssignItemText16BMG(dptr,buf,dest-buf); + fm->mod_count++; + return true; + } + return false; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// patch bmg: functions /////////////// +/////////////////////////////////////////////////////////////////////////////// + +bool PatchPrintBMG +( + bmg_t * bmg_dest, // pointer to destination bmg + const bmg_t * bmg_src // pointer to source bmg +) +{ + //--------------------------------------// + // only only source source // + // in in != == // + // source patch patch patch // + //--------------------------------------// + // source - mix mix // + //--------------------------------------// + + DASSERT(bmg_dest); + DASSERT(bmg_src); + copy_param(bmg_dest,bmg_src); + + format_message_t fm; + memset(&fm,0,sizeof(fm)); + fm.dest = bmg_dest; + + bmg_item_t * dptr = bmg_dest->item; + bmg_item_t * dend = dptr + bmg_dest->item_used; + + const bmg_item_t * sptr = bmg_src->item; + const bmg_item_t * send = sptr + bmg_src->item_used; + + for ( ; dptr < dend; dptr++ ) + { + u32 mid = dptr->mid; + while ( sptr < send && sptr->mid < mid ) + sptr++; + if ( sptr == send ) + break; + if ( sptr->mid == mid ) + format_message(&fm,dptr,sptr->text,sptr->len); + } + return fm.mod_count > 0; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool PatchFormatBMG +( + bmg_t * bmg_dest, // pointer to destination bmg + const bmg_t * bmg_src, // pointer to source bmg + ccp format // format parameter +) +{ + DASSERT(bmg_dest); + DASSERT(bmg_src); + copy_param(bmg_dest,bmg_src); + + const uint form_size = 2000; + u16 form_buf[form_size]; + uint form_len = ScanString16BMG(form_buf,form_size,format,-1,bmg_dest); + + format_message_t fm; + memset(&fm,0,sizeof(fm)); + fm.dest = bmg_dest; + + bmg_item_t * dptr = bmg_dest->item; + bmg_item_t * dend = dptr + bmg_dest->item_used; + for ( ; dptr < dend; dptr++ ) + format_message(&fm,dptr,form_buf,form_len); + + return fm.mod_count > 0; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool PatchRegexBMG +( + bmg_t * bmg, // pointer to destination bmg + ccp regex // format parameter +) +{ + #if ENABLE_BMG_REGEX + DASSERT(bmg); + DASSERT(regex); + + PRINT("REGEX=%s\n",regex); + + Regex_t re; + enumError err = ScanRegex(&re,true,regex); + if ( err || !re.valid ) + { + ResetRegex(&re); + return false; + } + + char buf1[1000]; + struct { FastBuf_t b; char space[500]; } res; + InitializeFastBuf(&res,sizeof(res)); + + bool dirty = false; + bmg_item_t * iptr = bmg->item; + bmg_item_t * iend = iptr + bmg->item_used; + + for ( ; iptr < iend; iptr++ ) + { + uint len1 = PrintString16BMG( buf1, sizeof(buf1), iptr->text, iptr->len, + BMG_UTF8_MAX, 0, true ); +// printf("-> [%d] %s\n",len1,buf1); + + const int stat = ReplaceRegex(&re,&res.b,buf1,len1); + if ( stat >= 0 ) + { +// printf("{%d] %.*s\n",stat,stat,GetFastBufString(&res.b)); + AssignItemScanTextBMG(iptr,GetFastBufString(&res.b),stat); + dirty = true; + } + } + + ResetFastBuf(&res.b); + ResetRegex(&re); + return dirty; + + #else + return false; + #endif +} + +/////////////////////////////////////////////////////////////////////////////// + +bool PatchRmRegexBMG +( + bmg_t * bmg, // pointer to destination bmg + ccp regex // format parameter +) +{ + #if ENABLE_BMG_REGEX + DASSERT(bmg); + DASSERT(regex); + + PRINT("REGEX=%s\n",regex); + + Regex_t re; + enumError err = ScanRegex(&re,true,regex); + if ( err || !re.valid ) + { + ResetRegex(&re); + return false; + } + + char buf1[1000]; + struct { FastBuf_t b; char space[500]; } res; + InitializeFastBuf(&res,sizeof(res)); + + bool dirty = false; + bmg_item_t * iptr = bmg->item; + bmg_item_t * iend = iptr + bmg->item_used; + + for ( ; iptr < iend; iptr++ ) + { + uint len1 = PrintString16BMG( buf1, sizeof(buf1), iptr->text, iptr->len, + BMG_UTF8_MAX, 0, true ); + //printf("-> [%d] %s\n",len1,buf1); + + int stat = ReplaceRegex(&re,&res.b,buf1,len1); + if ( stat >= 0 ) + { + if (stat) + AssignItemScanTextBMG(iptr,GetFastBufString(&res.b),stat); + else + { + FreeItemBMG(iptr); + iptr->text = 0; + ResetAttribBMG(bmg,iptr); + } + dirty = true; + } + } + + ResetFastBuf(&res.b); + ResetRegex(&re); + return dirty; + + #else + return false; + #endif +} + +/////////////////////////////////////////////////////////////////////////////// + +bool PatchReplaceBMG +( + bmg_t * dest, // pointer to destination bmg + const bmg_t * src // pointer to source bmg +) +{ + //--------------------------------------// + // only only source source // + // in in != == // + // source patch patch patch // + //--------------------------------------// + // source - patch both // + //--------------------------------------// + + DASSERT(dest); + DASSERT(src); + copy_param(dest,src); + + bmg_item_t * dptr = dest->item; + bmg_item_t * dend = dptr + dest->item_used; + + const bmg_item_t * sptr = src->item; + const bmg_item_t * send = sptr + src->item_used; + + bool dirty = false; + for ( ; dptr < dend; dptr++ ) + { + if (!dptr->text) + continue; + + u32 mid = dptr->mid; + while ( sptr < send && sptr->mid < mid ) + sptr++; + if ( sptr == send ) + break; + + if ( sptr->mid == mid + && !IsItemEqualBMG(dptr,sptr) + && ( !sptr->cond || FindItemBMG(dest,sptr->cond) ) ) + { + FreeItemBMG(dptr); + DASSERT( dptr->mid == sptr->mid ); + + CopyAttribBMG(dest,dptr,sptr); + dptr->len = sptr->len; + dptr->text = sptr->text; + dirty = true; + } + } + return dirty; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool PatchInsertBMG +( + bmg_t * dest, // pointer to destination bmg + const bmg_t * src // pointer to source bmg +) +{ + //--------------------------------------// + // only only source source // + // in in != == // + // source patch patch patch // + //--------------------------------------// + // source patch source both // + //--------------------------------------// + + DASSERT(dest); + DASSERT(src); + copy_param(dest,src); + + const bmg_item_t * sptr = src->item; + const bmg_item_t * send = sptr + src->item_used; + + bool dirty = false; + for ( ; sptr < send; sptr++ ) + { + if ( sptr->cond && !FindItemBMG(dest,sptr->cond) ) + continue; + + bool old_item; + bmg_item_t * dptr = InsertItemBMG(dest,sptr->mid,0,0,&old_item); + if (!old_item) + { + FreeItemBMG(dptr); + DASSERT( dptr->mid == sptr->mid ); + + CopyAttribBMG(dest,dptr,sptr); + dptr->len = sptr->len; + dptr->text = sptr->text; + dirty = true; + } + } + return dirty; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool PatchOverwriteBMG +( + bmg_t * dest, // pointer to destination bmg + const bmg_t * src, // pointer to source bmg + bool dup_strings // true: allocate mem for copied strings +) +{ + //--------------------------------------// + // only only source source // + // in in != == // + // source patch patch patch // + //--------------------------------------// + // source patch patch both // + //--------------------------------------// + + DASSERT(dest); + DASSERT(src); + copy_param(dest,src); + + const bmg_item_t * sptr = src->item; + const bmg_item_t * send = sptr + src->item_used; + + bool dirty = false; + for ( ; sptr < send; sptr++ ) + { + if ( sptr->cond && !FindItemBMG(dest,sptr->cond) ) + continue; + + bool old_item; + bmg_item_t * dptr = InsertItemBMG(dest,sptr->mid,0,0,&old_item); + if ( !old_item || !IsItemEqualBMG(dptr,sptr) ) + { + if (dup_strings) + AssignItemText16BMG(dptr,sptr->text,sptr->len); + else + { + FreeItemBMG(dptr); + dptr->len = sptr->len; + dptr->text = sptr->text; + } + DASSERT( dptr->mid == sptr->mid ); + + CopyAttribBMG(dest,dptr,sptr); + dirty = true; + } + } + return dirty; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool PatchDeleteBMG +( + bmg_t * dest, // pointer to destination bmg + const bmg_t * src // pointer to source bmg +) +{ + //--------------------------------------// + // only only source source // + // in in != == // + // source patch patch patch // + //--------------------------------------// + // source - - - // + //--------------------------------------// + + DASSERT(dest); + DASSERT(src); + copy_param(dest,src); + + const bmg_item_t * sptr = src->item; + const bmg_item_t * send = sptr + src->item_used; + + bool dirty = false; + for ( ; sptr < send; sptr++ ) + { + bmg_item_t * dptr = FindItemBMG(dest,sptr->mid); + if (dptr) + { + FreeItemBMG(dptr); + DASSERT( dptr->mid == sptr->mid ); + dptr->text = 0; + ResetAttribBMG(dest,dptr); + dirty = true; + } + } + return dirty; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool PatchMaskBMG +( + bmg_t * dest, // pointer to destination bmg + const bmg_t * src // pointer to source bmg +) +{ + //--------------------------------------// + // only only source source // + // in in != == // + // source patch patch patch // + //--------------------------------------// + // - - source both // + //--------------------------------------// + + DASSERT(dest); + DASSERT(src); + copy_param(dest,src); + + bmg_item_t * dptr = dest->item; + bmg_item_t * dend = dptr + dest->item_used; + + bool dirty = false; + for ( ; dptr < dend; dptr++ ) + { + bmg_item_t * sptr = FindItemBMG(src,dptr->mid); + if (!sptr) + { + FreeItemBMG(dptr); + dptr->text = 0; + ResetAttribBMG(dest,dptr); + dirty = true; + } + } + return dirty; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool PatchEqualBMG +( + bmg_t * dest, // pointer to destination bmg + const bmg_t * src // pointer to source bmg +) +{ + //--------------------------------------// + // only only source source // + // in in != == // + // source patch patch patch // + //--------------------------------------// + // - - - both // + //--------------------------------------// + + DASSERT(dest); + DASSERT(src); + copy_param(dest,src); + + bmg_item_t * dptr = dest->item; + bmg_item_t * dend = dptr + dest->item_used; + + const bmg_item_t * sptr = src->item; + const bmg_item_t * send = sptr + src->item_used; + + bool dirty = false; + for ( ; dptr < dend; dptr++ ) + { + u32 mid = dptr->mid; + while ( sptr < send && sptr->mid < mid ) + sptr++; + if ( sptr == send ) + break; + if ( sptr == send || sptr->mid != mid || !IsItemEqualBMG(dptr,sptr) ) + { + FreeItemBMG(dptr); + dptr->text = 0; + ResetAttribBMG(dest,dptr); + dirty = true; + } + } + return dirty; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool PatchNotEqualBMG +( + bmg_t * dest, // pointer to destination bmg + const bmg_t * src // pointer to source bmg +) +{ + //--------------------------------------// + // only only source source // + // in in != == // + // source patch patch patch // + //--------------------------------------// + // - - source - // + //--------------------------------------// + + DASSERT(dest); + DASSERT(src); + copy_param(dest,src); + + bmg_item_t * dptr = dest->item; + bmg_item_t * dend = dptr + dest->item_used; + + const bmg_item_t * sptr = src->item; + const bmg_item_t * send = sptr + src->item_used; + + bool dirty = false; + for ( ; dptr < dend; dptr++ ) + { + u32 mid = dptr->mid; + while ( sptr < send && sptr->mid < mid ) + sptr++; + if ( sptr == send ) + break; + if ( sptr != send && sptr->mid == mid && IsItemEqualBMG(dptr,sptr) ) + { + FreeItemBMG(dptr); + dptr->text = 0; + ResetAttribBMG(dest,dptr); + dirty = true; + } + } + return dirty; +} + +/////////////////////////////////////////////////////////////////////////////// + +static bool generic_helper +( + bmg_t * dest, // pointer to destination bmg + const bmg_t * src, // pointer to source bmg + uint dest_id, // index fo message to create + uint src_id, // relevant source message + uint src_beg, // source message for begining tests + uint src_end // source message for end tests +) +{ + DASSERT(dest); + DASSERT(src); + + //--- find source messages + + const bmg_item_t *s0 = FindItemBMG(src,src_id); + if ( !s0 || !s0->text || !s0->len ) + return false; + + const bmg_item_t *s1 = FindItemBMG(src,src_beg); + if ( !s1 || !s1->text || !s1->len ) + return false; + + const bmg_item_t *s2 = FindItemBMG(src,src_end); + if ( !s2 || !s2->text || !s2->len ) + return false; + + + //--- compare beginning of text + + const u16 *b0 = s0->text; + const u16 *b1 = s1->text; + const uint maxlen = s0->len < s1->len ? s0->len : s1->len; + const u16 *b0end = b0 + maxlen; + + while ( b0 < b0end && *b0 == *b1 ) + b0++, b1++; + if ( b0 == b0end ) + return false; + + while ( b0 > s0->text && isalnum((int)be16(b0-1)) ) + b0--, b1--; + + PRINT("GENERIC: |%c%c%c| |%c%c%c|\n", + be16(b0+0) & 0xff, be16(b0+1) & 0xff, be16(b0+2) & 0xff, + be16(b1+0) & 0xff, be16(b1+1) & 0xff, be16(b1+2) & 0xff ); + + + //--- compare end of text + + const u16 *e0 = s0->text + s0->len - 1; + const u16 *e2 = s2->text + s2->len - 1; + while ( e0 > b0 && *e0 == *e2 ) + e0--, e2--; + e0++, e2++; + + const u16 *e0end = s0->text + s0->len; + while ( b0 < e0end && isalnum((int)be16(b0-1)) ) + e0++, e2++; + + if ( b0 < e0 ) + { + const uint len = e0 - b0; + bmg_item_t *dptr = InsertItemBMG(dest,dest_id,0,0,0); + DASSERT(dptr); + if ( !dptr->text + || dptr->len != len + || memcmp(dptr->text,b0,len*sizeof(*b0)) ) + { + AssignItemText16BMG(dptr,b0,len); + return true; + } + } + + return false; +} + +//----------------------------------------------------------------------------- + +bool PatchGenericBMG +( + bmg_t * dest, // pointer to destination bmg + const bmg_t * src // pointer to source bmg +) +{ + DASSERT(dest); + DASSERT(src); + bool dirty = false; + + dirty |= generic_helper(dest,src, MID_G_SMALL, 0x1f44, 0x1f46, 0x1f46 ); + dirty |= generic_helper(dest,src, MID_G_MEDIUM, 0x1f45, 0x1f46, 0x1f46 ); + dirty |= generic_helper(dest,src, MID_G_LARGE, 0x1f46, 0x1f44, 0x1f44 ); + + return dirty; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool PatchIdBMG +( + bmg_t * bmg_dest, // pointer to destination bmg + bool prefix_all // true: prefix all messages +) +{ + //--------------------------------------// + // only only source source // + // in in != == // + // source patch patch patch // + //--------------------------------------// + // prefix n.a. n.a. n.a. // + //--------------------------------------// + + + uint name_len; + ccp name = GetNameBMG(bmg_dest,&name_len); + noPRINT("\e[31;1m#### NAME=%s\e[0m\n",name); + if ( name_len > 4 && !strncasecmp(name,"menu",4) ) + name += 4, name_len -= 4; + + u16 buf[10000]; + u16 *bufend = buf + sizeof(buf)/sizeof(*buf); + + bool dirty = false; + bmg_item_t * dptr = bmg_dest->item; + bmg_item_t * dend = dptr + bmg_dest->item_used; + + for ( ; dptr < dend; dptr++ ) + { + if ( dptr->text && ( prefix_all || dptr->text != bmg_null_entry ) ) + { + u16 *dest = buf; + if (name_len) + *dest++ = htons(*name); + char num[20]; + snprintf(num,sizeof(num),"%x",dptr->mid); + ccp src = num; + while (*src) + *dest++ = htons(*src++); + + if ( dptr->text != bmg_null_entry ) + { + *dest++ = htons(':'); + + uint count = bufend - dest; + if ( count > dptr->len ) + count = dptr->len; + memcpy(dest,dptr->text,count*sizeof(*dest)); + dest += count; + } + AssignItemText16BMG(dptr,buf,dest-buf); + dirty = true; + } + } + + return dirty; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool PatchRmEscapesBMG +( + bmg_t * bmg, // pointer to destination bmg + bool unicode, // replace '\u{16bit}' by unicode chars + bool rm_escapes // remove 1A escapes +) +{ + DASSERT(bmg); + PRINT("patch_bmg_rm_escapes(unicode=%d,rm_esc=%d)\n",unicode,rm_escapes); + + bool dirty = false; + bmg_item_t * iptr = bmg->item; + bmg_item_t * iend = iptr + bmg->item_used; + + for ( ; iptr < iend; iptr++ ) + { + // fast find first escape + u16 *sp = iptr->text, *end = sp + iptr->len; + if (!sp) + continue; + while ( sp < end && ntohs(*sp) != 0x1a ) + sp++; + if ( sp == end ) + continue; + + sp = ModifiyItem(iptr,sp); + end = iptr->text + iptr->len; + DASSERT( iptr->alloced_size > 0 ); + + u16 *dp = sp; + while ( sp < end ) + { + if ( ntohs(*sp) != 0x1a ) + { + *dp++ = *sp++; + continue; + } + + if ( unicode && ntohs(sp[1]) == 0x0801 && !ntohs(sp[2]) ) + { + const u16 code = ntohs(sp[3]); + if ( code >= ' ' ) + { + *dp++ = sp[3]; + sp += 4; + HexDump16(stdout,0,0x100,iptr->text,(dp-iptr->text)*2); + HexDump16(stdout,0,0x200,sp,(iptr->text+iptr->len-sp)*2); + continue; + } + } + + const uint esc_len = ((u8*)sp)[2] & 0xfe; + if (!rm_escapes) + { + memmove(dp,sp,esc_len); + dp += esc_len/2; + } + sp += esc_len/2; + } + iptr->len = dp - iptr->text; + } + return dirty; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool PatchRmCupsBMG +( + bmg_t * bmg // pointer to destination bmg +) +{ + DASSERT(bmg); + bool dirty = false; + uint mid; + for ( mid = MID_RCUP_BEG; mid < MID_RCUP_END; mid++ ) + { + bmg_item_t * ptr = FindItemBMG(bmg,mid); + if (ptr) + { + FreeItemBMG(ptr); + DASSERT( ptr->mid == mid ); + ptr->text = 0; + ResetAttribBMG(bmg,ptr); + dirty = true; + } + } + return dirty; +} + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +static uint bmg_copy_helper +( + bmg_t * bmg, // pointer to bmg + bool force, // true: force replace + uint mid_src_1, // first source message id + uint mid_src_2, // NULL or second source message id + uint mid_src_3, // NULL or third source message id + uint mid_dest, // destination message id + uint n_mid // numbers of messages to procced +) +{ + DASSERT(bmg); + + uint i, count = 0; + for ( i = 0; i < n_mid; i++ ) + { + bmg_item_t * sptr = FindItemBMG(bmg,mid_src_1+i); + if ( !sptr && mid_src_2 ) + { + sptr = FindItemBMG(bmg,mid_src_2+i); + if ( !sptr && mid_src_3 ) + sptr = FindItemBMG(bmg,mid_src_3+i); + } + + if (sptr) + { + bool old_item; + bmg_item_t * dptr = InsertItemBMG(bmg,mid_dest+i,0,0,&old_item); + if ( force || !old_item || !dptr->len ) + { + AssignItemText16BMG(dptr,sptr->text,sptr->len); + CopyAttribBMG(bmg,dptr,sptr); + count++; + } + } + } + + return count; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool PatchCTCopyBMG +( + bmg_t * bmg // pointer to destination bmg +) +{ + uint dirty_count + = bmg_copy_helper( bmg, false, MID_TRACK1_BEG, MID_TRACK2_BEG, 0, + MID_CT_TRACK_BEG, BMG_N_TRACK ) + + bmg_copy_helper( bmg, false, MID_ARENA1_BEG, MID_ARENA2_BEG, 0, + MID_CT_ARENA_BEG, BMG_N_ARENA ) + + bmg_copy_helper( bmg, false, MID_RCUP_BEG, 0, 0, + MID_CT_CUP_BEG, + MID_RCUP_END - MID_RCUP_BEG ) + + bmg_copy_helper( bmg, false, MID_BCUP_BEG, 0, 0, + MID_CT_BCUP_BEG, + MID_BCUP_END - MID_BCUP_BEG ); + return dirty_count > 0; +} + +//----------------------------------------------------------------------------- + +bool PatchLECopyBMG +( + bmg_t * bmg // pointer to destination bmg +) +{ + uint dirty_count + = bmg_copy_helper( bmg, false, MID_ARENA1_BEG, MID_ARENA2_BEG, MID_CT_ARENA_BEG, + MID_LE_ARENA_BEG, BMG_N_ARENA ) + + bmg_copy_helper( bmg, false, MID_TRACK1_BEG, MID_TRACK2_BEG, MID_CT_TRACK_BEG, + MID_LE_TRACK_BEG, BMG_N_TRACK ) + + bmg_copy_helper( bmg, false, MID_RCUP_BEG, MID_CT_CUP_BEG, 0, + MID_LE_CUP_BEG, + MID_RCUP_END - MID_RCUP_BEG ) + + bmg_copy_helper( bmg, false, MID_BCUP_BEG, MID_CT_BCUP_BEG, 0, + MID_LE_BCUP_BEG, + MID_BCUP_END - MID_BCUP_BEG ); + return dirty_count > 0; +} + +//----------------------------------------------------------------------------- + +bool PatchXCopyBMG +( + bmg_t * bmg // pointer to destination bmg +) +{ + if (opt_bmg_support_lecode) + return PatchLECopyBMG(bmg); + if (opt_bmg_support_ctcode) + return PatchCTCopyBMG(bmg); + return false; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool PatchCTForceCopyBMG +( + bmg_t * bmg // pointer to destination bmg +) +{ + uint dirty_count + = bmg_copy_helper( bmg, true, MID_TRACK1_BEG, MID_TRACK2_BEG, 0, + MID_CT_TRACK_BEG, BMG_N_TRACK ) + + bmg_copy_helper( bmg, true, MID_ARENA1_BEG, MID_ARENA2_BEG, 0, + MID_CT_ARENA_BEG, BMG_N_ARENA ) + + bmg_copy_helper( bmg, true, MID_RCUP_BEG, 0, 0, + MID_CT_CUP_BEG, + MID_RCUP_END - MID_RCUP_BEG ) + + bmg_copy_helper( bmg, true, MID_BCUP_BEG, 0, 0, + MID_CT_BCUP_BEG, + MID_BCUP_END - MID_BCUP_BEG ); + return dirty_count > 0; +} + +//----------------------------------------------------------------------------- + +bool PatchLEForceCopyBMG +( + bmg_t * bmg // pointer to destination bmg +) +{ + uint dirty_count + = bmg_copy_helper( bmg, true, MID_TRACK1_BEG, MID_TRACK2_BEG, MID_CT_TRACK_BEG, + MID_LE_TRACK_BEG, BMG_N_TRACK ) + + bmg_copy_helper( bmg, true, MID_ARENA1_BEG, MID_ARENA2_BEG, MID_CT_ARENA_BEG, + MID_LE_ARENA_BEG, BMG_N_ARENA ) + + bmg_copy_helper( bmg, true, MID_RCUP_BEG, MID_CT_CUP_BEG, 0, + MID_LE_CUP_BEG, + MID_RCUP_END - MID_RCUP_BEG ) + + bmg_copy_helper( bmg, true, MID_BCUP_BEG, MID_CT_BCUP_BEG, 0, + MID_LE_BCUP_BEG, + MID_BCUP_END - MID_BCUP_BEG ); + return dirty_count > 0; +} + +//----------------------------------------------------------------------------- + +bool PatchXForceCopyBMG +( + bmg_t * bmg // pointer to destination bmg +) +{ + if (opt_bmg_support_lecode) + return PatchLEForceCopyBMG(bmg); + if (opt_bmg_support_ctcode) + return PatchCTForceCopyBMG(bmg); + return false; +} + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +bool PatchIdentificationBMG ( bmg_t *bmg, ct_bmg_t *ctb ) +{ + DASSERT(bmg); + DASSERT(ctb); + + bmg_item_t *bi = InsertItemBMG(bmg,MID_PARAM_IDENTIFY,0,0,0); + DASSERT(bi); + AssignItemTextBMG(bi,GetCtBMGIdentification(ctb,true),-1); + return true; +} + +//----------------------------------------------------------------------------- + +bool PatchFillBMG + ( bmg_t *bmg, ct_mode_t ct_mode, uint rcup_limit, uint track_limit ) +{ + ct_bmg_t ctb; + ct_mode = SetupCtBMG(&ctb,ct_mode,ct_mode); + if (!ctb.is_ct_code) + return false; + + + //--- check existence of at least one relevvant message + + bool found = false; + bmg_item_t *dptr = bmg->item; + bmg_item_t *dend = dptr + bmg->item_used; + for ( ; dptr < dend; dptr++ ) + { + const u32 m = dptr->mid; + if ( m >= MID_TRACK1_BEG && m < MID_TRACK1_END + || m >= MID_TRACK2_BEG && m < MID_TRACK2_END + || m >= MID_ARENA1_BEG && m < MID_ARENA1_END + || m >= MID_ARENA2_BEG && m < MID_ARENA2_END + || m >= MID_RCUP_BEG && m < MID_RCUP_END + || m >= MID_BCUP_BEG && m < MID_BCUP_END + || m >= ctb.track_name1.beg && m < ctb.track_name1.end + || m >= ctb.track_name2.beg && m < ctb.track_name2.end + || m >= ctb.arena_name1.beg && m < ctb.arena_name1.end + || m >= ctb.arena_name2.beg && m < ctb.arena_name2.end + || m >= ctb.rcup_name.beg && m < ctb.rcup_name.end + || m >= ctb.bcup_name.beg && m < ctb.bcup_name.end + || m == ctb.random.beg + ) + { + if ( dptr->text && dptr->text != bmg_null_entry ) + { + found = true; + break; + } + } + } + + if (!found) + return false; + + + //--- random + + char buf[100]; + bool dirty = false; + + if (ctb.random.beg) + { + bool old_item; + bmg_item_t * dptr = InsertItemBMG(bmg,ctb.random.beg,0,0,&old_item); + if ( !old_item || !dptr->len ) + { + AssignItemTextBMG(dptr,"???",3); + ResetAttribBMG(bmg,dptr); + dirty = true; + } + } + + + //--- fill arena names + + uint mid; + for ( mid = ctb.arena_name1.beg; mid < ctb.arena_name1.end; mid++ ) + { + bool old_item; + bmg_item_t * dptr = InsertItemBMG(bmg,mid,0,0,&old_item); + if ( !old_item || !dptr->len ) + { + const uint len + = snprintf(buf,sizeof(buf),"_A%u_",mid-ctb.arena_name1.beg); + AssignItemTextBMG(dptr,buf,len); + ResetAttribBMG(bmg,dptr); + dirty = true; + } + } + + + //--- fill track names + + if (!track_limit) + track_limit = opt_bmg_track_fill_limit; + uint max_track; + if (track_limit) + { + max_track = ctb.track_name1.beg + track_limit; + if ( max_track > ctb.track_name1.end ) + max_track = ctb.track_name1.end; + } + else + max_track = ctb.track_name1.end; + + for ( mid = ctb.track_name1.beg; mid < max_track; mid++ ) + { + bool old_item; + bmg_item_t * dptr = InsertItemBMG(bmg,mid,0,0,&old_item); + if ( !old_item || !dptr->len ) + { + const uint len + = snprintf(buf,sizeof(buf),"_T%03X_",mid-ctb.track_name1.beg); + AssignItemTextBMG(dptr,buf,len); + ResetAttribBMG(bmg,dptr); + dirty = true; + } + } + + + //--- fill battle cup names + + for ( mid = ctb.bcup_name.beg; mid < ctb.bcup_name.end; mid++ ) + { + bool old_item; + bmg_item_t * dptr = InsertItemBMG(bmg,mid,0,0,&old_item); + if ( !old_item || !dptr->len ) + { + const uint len + = snprintf(buf,sizeof(buf),"_B%u_",mid-ctb.bcup_name.beg); + AssignItemTextBMG(dptr,buf,len); + ResetAttribBMG(bmg,dptr); + dirty = true; + } + } + + + //--- fill racing cup names + + if (!rcup_limit) + rcup_limit = opt_bmg_rcup_fill_limit; + uint max_cup; + if (rcup_limit) + { + max_cup = ctb.rcup_name.beg + rcup_limit; + if ( max_cup > ctb.rcup_name.end ) + max_cup = ctb.rcup_name.end; + } + else + max_cup = ctb.rcup_name.end; + + for ( mid = ctb.rcup_name.beg; mid < max_cup; mid++ ) + { + bool old_item; + bmg_item_t * dptr = InsertItemBMG(bmg,mid,0,0,&old_item); + if ( !old_item || !dptr->len ) + { + const uint len + = snprintf(buf,sizeof(buf),"_R%u_",mid-ctb.rcup_name.beg); + AssignItemTextBMG(dptr,buf,len); + ResetAttribBMG(bmg,dptr); + dirty = true; + } + } + + //--- identification + + if (dirty) + PatchIdentificationBMG(bmg,&ctb); + + return dirty; +} + +//----------------------------------------------------------------------------- + +bool PatchXFillBMG ( bmg_t *bmg, uint rcup_limit, uint track_limit ) +{ + if (opt_bmg_support_lecode) + return PatchLEFillBMG(bmg,rcup_limit,track_limit); + + if (opt_bmg_support_ctcode) + return PatchCTFillBMG(bmg,rcup_limit,track_limit); + + return false; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool PatchRmFilledBMG ( bmg_t *bmg ) +{ + DASSERT(bmg); + + bool dirty = false; + bmg_item_t * iptr = bmg->item; + bmg_item_t * iend = iptr + bmg->item_used; + + for ( ; iptr < iend; iptr++ ) + { + if ( iptr->mid >= 0x4000 + && iptr->len > 3 + && ntohs(iptr->text[0]) == '_' + && ntohs(iptr->text[iptr->len-1]) == '_' ) + { + u16 ch = ntohs(iptr->text[1]); + if ( ch == 'A' || ch == 'T' || ch == 'B' || ch == 'R' ) + { + FreeItemBMG(iptr); + iptr->text = 0; + ResetAttribBMG(bmg,iptr); + dirty = true; + } + } + } + + return dirty; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// PatchRemove*BMG() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +bool PatchRemoveBMG ( bmg_t * bmg, int mid1, int mid2 ) +{ + DASSERT(bmg); + + bmg_item_t * ptr = bmg->item; + bmg_item_t * end = ptr + bmg->item_used; + + bool dirty = false; + for ( ; ptr < end && ptr->mid < mid2; ptr++ ) + { + if ( ptr->mid >= mid1 ) + { + FreeItemBMG(ptr); + ptr->text = 0; + ResetAttribBMG(bmg,ptr); + dirty = true; + } + } + return dirty; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// PatchBMG() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +enumError PatchBMG +( + bmg_t *dest, // pointer to destination bmg + const bmg_t *src, // pointer to source bmg + PatchModeBMG_t patch_mode, // patch mode + ccp string, // NULL or string parameter + bool dup_strings // true: alloc mem for copied strings (OVERWRITE) +) +{ + PRINT("PatchBMG(%p,%p,%u,%s,%d)\n", + dest, src, patch_mode, string, dup_strings ); + DASSERT(dest); + + bool dirty = false; + switch(patch_mode) + { + case BMG_PM_PRINT: dirty = PatchPrintBMG(dest,src); break; + case BMG_PM_FORMAT: dirty = PatchFormatBMG(dest,src,string); break; + case BMG_PM_REGEX: dirty = PatchRegexBMG(dest,string); break; + case BMG_PM_RM_REGEX: dirty = PatchRmRegexBMG(dest,string); break; + case BMG_PM_ID: dirty = PatchIdBMG(dest,false); break; + case BMG_PM_ID_ALL: dirty = PatchIdBMG(dest,true); break; + case BMG_PM_UNICODE: dirty = PatchRmEscapesBMG(dest,true,false); break; + case BMG_PM_RM_ESCAPES: dirty = PatchRmEscapesBMG(dest,false,true); break; + + case BMG_PM_REPLACE: dirty = PatchReplaceBMG(dest,src); break; + case BMG_PM_INSERT: dirty = PatchInsertBMG(dest,src); break; + case BMG_PM_OVERWRITE: dirty = PatchOverwriteBMG(dest,src,dup_strings); break; + case BMG_PM_DELETE: dirty = PatchDeleteBMG(dest,src); break; + case BMG_PM_MASK: dirty = PatchMaskBMG(dest,src); break; + case BMG_PM_EQUAL: dirty = PatchEqualBMG(dest,src); break; + case BMG_PM_NOT_EQUAL: dirty = PatchNotEqualBMG(dest,src); break; + + case BMG_PM_GENERIC: dirty = PatchGenericBMG(dest,dest); break; + case BMG_PM_RM_CUPS: dirty = PatchRmCupsBMG(dest); break; + + case BMG_PM_CT_COPY: dirty = PatchCTCopyBMG(dest); break; + case BMG_PM_CT_FORCE_COPY: dirty = PatchCTForceCopyBMG(dest); break; + case BMG_PM_CT_FILL: dirty = PatchCTFillBMG(dest,0,0); break; + + case BMG_PM_LE_COPY: dirty = PatchLECopyBMG(dest); break; + case BMG_PM_LE_FORCE_COPY: dirty = PatchLEForceCopyBMG(dest); break; + case BMG_PM_LE_FILL: dirty = PatchLEFillBMG(dest,0,0); break; + + case BMG_PM_X_COPY: dirty = PatchXCopyBMG(dest); break; + case BMG_PM_X_FORCE_COPY: dirty = PatchXForceCopyBMG(dest); break; + case BMG_PM_X_FILL: dirty = PatchXFillBMG(dest,0,0); break; + + case BMG_PM_RM_FILLED: dirty = PatchRmFilledBMG(dest); break; + + default: return ERROR0(ERR_NOT_IMPLEMENTED,0); + } + + if (dirty) + TouchFileAttrib(&dest->fatt); + + return dirty ? ERR_DIFFER : ERR_OK; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// CT/LE support /////////////// +/////////////////////////////////////////////////////////////////////////////// + +ct_mode_t NormalizeCtModeBMG ( ct_mode_t mode, ct_mode_t fallback ) +{ + for(;;) + { + switch(mode) + { + case CTM_NINTENDO: + case CTM_CTCODE: + case CTM_LECODE2: + return mode; + + case CTM_CTCODE_BASE: + return CTM_CTCODE; + + case CTM_LECODE1: + case CTM_LECODE_BASE: + return CTM_LECODE_DEF; + + case CTM_OPTIONS: + if (opt_bmg_support_lecode) + return CTM_LECODE2; + if (opt_bmg_support_ctcode) + return CTM_CTCODE; + return CTM_NINTENDO; + + case CTM_NO_INIT: + case CTM_AUTO: + break; + } + + mode = fallback; + fallback = CTM_OPTIONS; + } +} + +/////////////////////////////////////////////////////////////////////////////// + +ct_mode_t SetupCtModeBMG ( ct_mode_t mode ) +{ + mode = NormalizeCtModeBMG(mode,CTM_NINTENDO); + switch (mode) + { + case CTM_NINTENDO: + opt_bmg_support_mkw = true; + opt_bmg_support_ctcode = false; + opt_bmg_support_lecode = false; + break; + + case CTM_CTCODE: + opt_bmg_support_mkw = true; + opt_bmg_support_ctcode = true; + opt_bmg_support_lecode = false; + break; + + case CTM_LECODE2: + opt_bmg_support_mkw = true; + opt_bmg_support_ctcode = false; + opt_bmg_support_lecode = true; + break; + + default: + opt_bmg_support_mkw = false; + opt_bmg_support_ctcode = false; + opt_bmg_support_lecode = false; + break; + } + return mode; +} + +/////////////////////////////////////////////////////////////////////////////// + +ccp GetCtModeNameBMG ( ct_mode_t mode, bool full ) +{ + switch(mode) + { + case CTM_NINTENDO: return "Nintendo"; + case CTM_CTCODE: return "CT-CODE"; + case CTM_LECODE1: return full ? "LE-CODE v1" : "LE-CODE"; + case CTM_LECODE2: return full ? "LE-CODE v2" : "LE-CODE"; + default: return "?"; + } +} + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +ct_mode_t SetupCtBMG ( ct_bmg_t *ctb, ct_mode_t mode, ct_mode_t fallback ) +{ + mode = NormalizeCtModeBMG(mode,fallback); + if (ctb) + { + ctb->ct_mode = mode; + ctb->identify = MID_PARAM_IDENTIFY; + ctb->param.beg = MID_PARAM_BEG; + ctb->param.end = MID_PARAM_END; + ctb->param.n = ctb->param.end - ctb->param.beg; + + switch(mode) + { + case CTM_CTCODE: + ctb->version = 0; + ctb->is_ct_code = 1; + ctb->le_phase = 0; + + ctb->rcup_name.beg = MID_CT_RCUP_BEG; + ctb->rcup_name.end = MID_CT_RCUP_END; + ctb->bcup_name.beg = MID_CT_BCUP_BEG; + ctb->bcup_name.end = MID_CT_BCUP_END; + + ctb->track_name1.beg = MID_CT_TRACK_BEG; + ctb->track_name1.end = MID_CT_TRACK_END; + ctb->track_name2.beg = 0; + ctb->track_name2.end = 0; + + ctb->arena_name1.beg = MID_CT_ARENA_BEG; + ctb->arena_name1.end = MID_CT_ARENA_END; + ctb->arena_name2.beg = 0; + ctb->arena_name2.end = 0; + + ctb->cup_ref.beg = MID_CT_CUP_REF_BEG; + ctb->cup_ref.end = MID_CT_CUP_REF_END; + + ctb->random.beg = MID_CT_RANDOM; + ctb->random.end = MID_CT_RANDOM+1; + break; + + case CTM_LECODE1: + case CTM_LECODE2: + ctb->version = mode == CTM_LECODE2 ? 2 : 1; + ctb->le_phase = ctb->version; + ctb->is_ct_code = 2; + + ctb->rcup_name.beg = MID_LE_RCUP_BEG; + ctb->rcup_name.end = MID_LE_RCUP_END; + ctb->bcup_name.beg = MID_LE_BCUP_BEG; + ctb->bcup_name.end = MID_LE_BCUP_END; + + ctb->track_name1.beg = MID_LE_TRACK_BEG; + ctb->track_name1.end = MID_LE_TRACK_END; + ctb->track_name2.beg = 0; + ctb->track_name2.end = 0; + + ctb->arena_name1.beg = MID_LE_ARENA_BEG; + ctb->arena_name1.end = MID_LE_ARENA_END; + ctb->arena_name2.beg = 0; + ctb->arena_name2.end = 0; + + ctb->cup_ref.beg = MID_LE_CUP_REF_BEG; + ctb->cup_ref.end = MID_LE_CUP_REF_END; + + ctb->random.beg = 0; + ctb->random.end = 0; + break; + + default: + ctb->version = 0; + ctb->is_ct_code = 0; + ctb->le_phase = 0; + + ctb->rcup_name.beg = MID_RCUP_BEG; + ctb->rcup_name.end = MID_RCUP_END; + ctb->bcup_name.beg = MID_BCUP_BEG; + ctb->bcup_name.end = MID_BCUP_END; + + ctb->track_name1.beg = MID_TRACK1_BEG; + ctb->track_name1.end = MID_TRACK1_END; + ctb->track_name2.beg = MID_TRACK2_BEG; + ctb->track_name2.end = MID_TRACK2_END; + + ctb->arena_name1.beg = MID_ARENA1_BEG; + ctb->arena_name1.end = MID_ARENA1_END; + ctb->arena_name2.beg = MID_ARENA2_BEG; + ctb->arena_name2.end = MID_ARENA2_END; + + ctb->cup_ref.beg = 0; + ctb->cup_ref.end = 0; + + ctb->random.beg = MID_RANDOM; + ctb->random.end = MID_RANDOM+1; + break; + } + + u32 min = M1(u32), max = 0; + bmg_range_t *ptr; + for ( ptr = &ctb->rcup_name; ptr <= &ctb->random; ptr++ ) + { + ptr->n = ptr->end - ptr->beg; + if (ptr->n) + { + if ( min > ptr->beg ) min = ptr->beg; + if ( max < ptr->end ) max = ptr->end; + } + } + ctb->range.beg = min; + ctb->range.end = max; + ctb->range.n = max - min; + } + return mode; +} + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +#undef TAB +#define TAB(nam) ctb->nam.beg, ctb->nam.n + +ccp GetCtBMGIdentification ( ct_bmg_t *ctb, bool full ) +{ + DASSERT(ctb); + + ccp name = GetCtModeNameBMG(ctb->ct_mode,false); + char buf[200]; + int len; + if (full) + len = snprintf(buf,sizeof(buf), + "%x, %s, v=%x, ct=%x, le=%x, par=%x+%x," + " rcup=%x+%x, bcup=%x+%x, t1=%x+%x, t2=%x+%x," + " a1=%x+%x, a2=%x+%x, ref=%x+%x", + ctb->ct_mode, name, ctb->version, + ctb->is_ct_code==1, ctb->le_phase, + TAB(param), + TAB(rcup_name), TAB(bcup_name), + TAB(track_name1), TAB(track_name2), + TAB(arena_name1), TAB(arena_name2), + TAB(cup_ref) ); + else + len = snprintf(buf,sizeof(buf),"%x, %s v%d",ctb->ct_mode,name,ctb->version); + return len > 0 ? CopyCircBuf(buf,len+1) : EmptyString; +} + +#undef TAB + +/////////////////////////////////////////////////////////////////////////////// + +static void DumpCtMidHelper1 ( FILE *f, int indent, u32 id, ccp info ) +{ + DASSERT(f); + if (id) + fprintf(f,"%*s%-20s %04x\n", indent, "", info, id ); +} + +//----------------------------------------------------------------------------- + +static void DumpCtMidHelper2 ( FILE *f, int indent, bmg_range_t *id, ccp info ) +{ + DASSERT(f); + DASSERT(id); + if (id->beg) + fprintf(f,"%*s%-20s %04x .. %04x, %5u = 0x%04x\n", + indent, "", info, id->beg, id->end, id->n, id->n ); +} + +//----------------------------------------------------------------------------- + +void DumpCtBMG ( FILE *f, int indent, ct_bmg_t *ctb ) +{ + DASSERT(f); + DASSERT(ctb); + indent = NormalizeIndent(indent); + + #if defined(TEST) || defined(DEBUG) + fprintf(f,"%*s%s\n",indent,"",GetCtBMGIdentification(ctb,true)); + #else + fprintf(f,"%*s%s\n",indent,"",GetCtBMGIdentification(ctb,false)); + #endif + + indent += 2; + DumpCtMidHelper1( f,indent, ctb->identify, "Identification:" ); + DumpCtMidHelper2( f,indent, &ctb->param, "Parameters:" ); + DumpCtMidHelper2( f,indent, &ctb->range, "Data range:" ); + + DumpCtMidHelper2( f,indent, &ctb->rcup_name, " Racing cup names:" ); + DumpCtMidHelper2( f,indent, &ctb->bcup_name, " Battle cup names:" ); + DumpCtMidHelper2( f,indent, &ctb->track_name1, " Track names 1:" ); + DumpCtMidHelper2( f,indent, &ctb->track_name2, " Track names 2:" ); + DumpCtMidHelper2( f,indent, &ctb->arena_name1, " Battle names 1:" ); + DumpCtMidHelper2( f,indent, &ctb->arena_name2, " Battle names 2:" ); + DumpCtMidHelper2( f,indent, &ctb->cup_ref, " Cup reference:" ); + DumpCtMidHelper1( f,indent, ctb->random.beg, " Random text:" ); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// E N D /////////////// +/////////////////////////////////////////////////////////////////////////////// + |