From 1192c4575ea7afdf38e3fa0df4587a08620af11e Mon Sep 17 00:00:00 2001 From: root Date: Tue, 21 Jul 2020 10:00:46 +0200 Subject: SZS v2.18a --- project/dclib/lib-bmg.h | 1125 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1125 insertions(+) create mode 100755 project/dclib/lib-bmg.h (limited to 'project/dclib/lib-bmg.h') diff --git a/project/dclib/lib-bmg.h b/project/dclib/lib-bmg.h new file mode 100755 index 0000000..9ab5967 --- /dev/null +++ b/project/dclib/lib-bmg.h @@ -0,0 +1,1125 @@ + +/*************************************************************************** + * * + * _____ ____ * + * | __ \ / __ \ _ _ _____ * + * | | \ \ / / \_\ | | | | _ \ * + * | | \ \| | | | | | |_| | * + * | | | || | | | | | ___/ * + * | | / /| | __ | | | | _ \ * + * | |__/ / \ \__/ / | |___| | |_| | * + * |_____/ \____/ |_____|_|_____/ * + * * + * Wiimms source code library * + * * + *************************************************************************** + * * + * Copyright (c) 2012-2020 by Dirk Clemens * + * * + *************************************************************************** + * * + * 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 * + * * + ***************************************************************************/ + +#ifndef DC_LIB_BMG_H +#define DC_LIB_BMG_H 1 + +#define _GNU_SOURCE 1 +#include "dclib-basics.h" +#include "dclib-file.h" + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// basic consts /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#define BMG_ATTRIB_SIZE 40 // attrib size in bytes +#define BMG_ATTRIB_BUF_SIZE (10+4*BMG_ATTRIB_SIZE) // good buf size for attrib string +#define BMG_INF_MAX_SIZE (4+BMG_ATTRIB_SIZE) // max supported inf size +#define BMG_INF_LIMIT 1000 // max allowed inf size + +// [[xbuf]] +#define BMG_MSG_BUF_SIZE 20050 // good buf size for messages + +/////////////////////////////////////////////////////////////////////////////// + +#define BMG_MAGIC "MESGbmg1" +#define BMG_MAGIC8_NUM 0x4d455347626d6731ull + +#define BMG_TEXT_MAGIC "#BMG" +#define BMG_TEXT_MAGIC_NUM 0x23424d47 + +#define BMG_UTF8_MAX 0xfffd +#define BMG_UTF8_MAX_DIFF 0x058f // behind: from-right-to-left letters + +#define BMG_NO_PREDEF_SLOT 0xffff // only slots 0: force some operations +extern uint opt_bmg_align; // alignment of raw-bg sections +extern bool opt_bmg_export; // true: optimize for exports +extern bool opt_bmg_no_attrib; // true: suppress attributes +extern bool opt_bmg_x_escapes; // true: use x-scapes insetad of z-escapes +extern bool opt_bmg_old_escapes; // true: use only old escapes +extern int opt_bmg_single_line; // >0: single line, >1: suppress atrributes +extern bool opt_bmg_inline_attrib; // true: print attrinbutes inline +extern bool opt_bmg_support_mkw; // true: support MKW specific extensions +extern bool opt_bmg_support_ctcode; // true: support MKW/CT-CODE specific extensions +extern bool opt_bmg_support_lecode; // true: support MKW/LE-CODE specific extensions +extern uint opt_bmg_rcup_fill_limit;// >0: limit racing cups to reduce BMG size +extern uint opt_bmg_track_fill_limit;// >0: limit tracks to reduce BMG size +extern int opt_bmg_colors; // use c-escapes: 0:off, 1:auto, 2:on +extern ColNameLevelBMG opt_bmg_color_name; +extern uint opt_bmg_max_recurse; // max recurse depth +extern bool opt_bmg_allow_print; // true: allow '$' to print a log message +extern bool opt_bmg_use_slots; // true: use predifined slots +extern bool opt_bmg_use_raw_sections;// true: use raw sections + +//----------------------------------------------------------------------------- + +extern int opt_bmg_encoding; +extern uint opt_bmg_inf_size; +extern OffOn_t opt_bmg_mid; +extern bool opt_bmg_force_attrib; +extern bool opt_bmg_def_attrib; + +extern u8 bmg_force_attrib[BMG_ATTRIB_SIZE]; +extern u8 bmg_def_attrib[BMG_ATTRIB_SIZE]; + + +// 'PatchKeysBMG->opt' +// 0: no param +// 1: file param +// 2: string param +extern const KeywordTab_t PatchKeysBMG[]; + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// CT/LE support /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[ct_mode_t]] + +typedef enum ct_mode_t +{ + CTM_NO_INIT, // don't initialize, don't change value + CTM_NINTENDO, // original Nintendo mdoe with 32 tracks + CTM_AUTO, // use fallback + CTM_OPTIONS, // use options opt_bmg_support_{le,ct}code + + CTM_CTCODE_BASE = 0x10, // base for all CT-CODEs + CTM_CTCODE, // CT-CODE (v1) + + CTM_LECODE_BASE = 0x20, // base for all LE-CODEs + CTM_LECODE1, // LE-CODE phase 1 [[not longer used]] + CTM_LECODE2, // LE-CODE phase 2 + + CTM_LECODE_MIN = CTM_LECODE2, // minimal LE-PHASE + CTM_LECODE_DEF = CTM_LECODE2, // default LE-PHASE + CTM_LECODE_MAX = CTM_LECODE2, // maximal LE-PHASE +} +ct_mode_t; + +ct_mode_t NormalizeCtModeBMG ( ct_mode_t mode, ct_mode_t fallback ); +ct_mode_t SetupCtModeBMG ( ct_mode_t mode ); +ccp GetCtModeNameBMG ( ct_mode_t mode, bool full ); + +/////////////////////////////////////////////////////////////////////////////// +// [[bmg_range_t]] + +typedef struct bmg_range_t +{ + u32 beg; // id of first MID + u32 end; // id of last MID+1 + u32 n; // number of MIDs := end-beg +} +bmg_range_t; + +/////////////////////////////////////////////////////////////////////////////// +// [[ct_bmg_t]] + +typedef struct ct_bmg_t +{ + ct_mode_t ct_mode; // normalized CT mode + int version; // a version number + uint is_ct_code; // 0:off, 1:CT-CODE, 2:CT+LE-CODE + uint le_phase; // >0: LE-CODE enabled in phase # + + u32 identify; // MID if ifentification + bmg_range_t param; // MID range of parameters + + bmg_range_t range; // MID range of this section (min,max) + bmg_range_t rcup_name; // MID range of racing cup names + bmg_range_t bcup_name; // MID range of battle cup names (maybe part of rcup_name) + bmg_range_t track_name1; // MID range of track names, first set + bmg_range_t track_name2; // 0 or MID range of track names, second set + bmg_range_t arena_name1; // MID range of arena names, first set + bmg_range_t arena_name2; // 0 or MID range of arena names, second set + bmg_range_t cup_ref; // MID range of battle track_to_cup references + bmg_range_t random; // MID for RANDOM +} +ct_bmg_t; + +ct_mode_t SetupCtBMG ( ct_bmg_t *ctb, ct_mode_t mode, ct_mode_t fallback ); +static inline void ResetCtBMG ( ct_bmg_t *ctb ) {} +ccp GetCtBMGIdentification ( ct_bmg_t *ctb, bool full ); // message for MID_PARAM_IDENTIFY +void DumpCtBMG ( FILE *f, int indent, ct_bmg_t *ctb ); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// global string functions /////////////// +/////////////////////////////////////////////////////////////////////////////// + +// returns 1..N +uint GetWordLength16BMG ( const u16 *source ); + +uint GetLength16BMG +( + const u16 * sourse, // source + uint max_len // max possible length +); + +//----------------------------------------------------------------------------- + +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: use \c{...} +); + +// [[xbuf]] [[2do]] not implemented yet +uint PrintFastBuf16BMG +( + 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{...} +); + +//----------------------------------------------------------------------------- + +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{...} +); + +// [[xbuf]] [[2do]] not implemented yet +uint ScanFastBuf16BMG +( + FastBuf_t *fb, // destination buffer (data appended) + ccp src, // UTF-8 source + int src_len, // length of source, -1: determine with strlen() + const bmg_t *bmg // NULL or support for \m{...} +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct bmg_header_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[bmg_section_t]] + +typedef struct bmg_section_t +{ + /*00*/ char magic[4]; // a magic to identity the section + /*04*/ be32_t size; // total size of the section + /*08*/ u8 data[0]; // section data +} +__attribute__ ((packed)) bmg_section_t; + +//----------------------------------------------------------------------------- +// [[bmg_encoding_t]] + +typedef enum bmg_encoding_t +{ + BMG_ENC_CP1252 = 1, + BMG_ENC_UTF16BE = 2, // used in MKWii and AC + BMG_ENC_SHIFT_JIS = 3, + BMG_ENC_UTF8 = 4, + + BMG_ENC__MIN = BMG_ENC_CP1252, + BMG_ENC__DEFAULT = BMG_ENC_UTF16BE, + BMG_ENC__MAX = BMG_ENC_UTF8, + BMG_ENC__UNDEFINED = -1, // only for option --bmg-encoding +} +__attribute__ ((packed)) bmg_encoding_t; + +extern const KeywordTab_t TabEncodingBMG[]; +ccp GetEncodingNameBMG ( int encoding, ccp return_if_invalid ); +int CheckEncodingBMG ( int encoding, int return_if_invalid ); + +//----------------------------------------------------------------------------- +// [[bmg_header_t]] + +typedef struct bmg_header_t +{ + /*00*/ char magic[8]; // = BMG_MAGIC + /*08*/ be32_t size; // total size of file + /*0c*/ be32_t n_sections; // number of sections + /*10*/ bmg_encoding_t encoding; // text encoding + /*11*/ u8 unknown[15]; // unknown data + /*20*/ //bmg_section_t section[0]; // first section header + // -> disabled because MVC +} +__attribute__ ((packed)) bmg_header_t; + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct bmg_inf_t /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#define BMG_INF_MAGIC "INF1" +#define BMG_INF_STD_ATTRIB 0x01000000 +#define BMG_INF_STD_SIZE 8 +#define BMG_INF_DEFAULT_0C 0 + +//----------------------------------------------------------------------------- +// [[bmg_inf_item_t]] + +typedef struct bmg_inf_item_t +{ + /*00*/ u32 offset; // offset into text pool + /*04*/ u8 attrib[0]; // attribute bytes + // NKWii: MSByte used for font selection. +} +__attribute__ ((packed)) bmg_inf_item_t; + +//----------------------------------------------------------------------------- +// [[bmg_inf_t]] + +typedef struct bmg_inf_t +{ + /*00*/ char magic[4]; // = BMG_INF_MAGIC + /*04*/ be32_t size; // total size of the section + /*08*/ be16_t n_msg; // number of messages + /*0a*/ be16_t inf_size; // size of inf items + /*0c*/ be32_t unknown_0c; // = BMG_INF_DEFAULT_0C = 0 for MKW + /*10*/ bmg_inf_item_t list[0]; // message list with (offset,attribute) +} +__attribute__ ((packed)) bmg_inf_t; + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct bmg_dat_t + bmg_str_t /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#define BMG_DAT_MAGIC "DAT1" +#define BMG_STR_MAGIC "STR1" + +//----------------------------------------------------------------------------- +// [[bmg_dat_t]] + +typedef struct bmg_dat_t +{ + /*00*/ char magic[4]; // = BMG_DAT_MAGIC + /*04*/ be32_t size; // total size of the section + /*08*/ u8 text_pool[]; +} +__attribute__ ((packed)) bmg_dat_t; + +//----------------------------------------------------------------------------- + +// [[bmg_str_t]] +typedef bmg_dat_t bmg_str_t; + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct bmg_mid_t /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#define BMG_MID_MAGIC "MID1" +#define BMG_MID_DEFAULT_0A 0x1000 +#define BMG_MID_DEFAULT_0C 0 + +//----------------------------------------------------------------------------- +// [[bmg_mid_t]] + +typedef struct bmg_mid_t +{ + /*00*/ char magic[4]; // = BMG_MID_MAGIC + /*04*/ be32_t size; // total size of the section + /*08*/ be16_t n_msg; // number of messages + /*0a*/ be16_t unknown_0a; // = BMG_MID_DEFAULT_0A = 0x1000 for MKW + /*0c*/ be32_t unknown_0c; // = BMG_MID_DEFAULT_0C = 0 for MKW + /*10*/ u32 mid[0]; // message id table +} +__attribute__ ((packed)) bmg_mid_t; + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct bmg_flw_t /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#define BMG_FLW_MAGIC "FLW1" + +//----------------------------------------------------------------------------- +// [[bmg_flw_t]] + +typedef struct bmg_flw_t +{ + /*00*/ char magic[4]; // = BMG_FLW_MAGIC + /*04*/ be32_t size; // total size of the section + /*08*/ u8 unknown[]; // ??? [[2do]] +} +__attribute__ ((packed)) bmg_flw_t; + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct bmg_fli_t /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#define BMG_FLI_MAGIC "FLI1" + +//----------------------------------------------------------------------------- +// [[bmg_fli_t]] + +typedef struct bmg_fli_t +{ + /*00*/ char magic[4]; // = BMG_FLI_MAGIC + /*04*/ be32_t size; // total size of the section + /*08*/ u8 unknown[]; // ??? [[2do]] +} +__attribute__ ((packed)) bmg_fli_t; + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// bmg_sect_info_t & bmg_sect_list_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[bmg_sect_info_t]] + +typedef struct bmg_sect_info_t +{ + uint offset; // offset from beginning of file + uint sect_size; // section size by section header + uint real_size; // real section size + uint head_size; // size of section header + uint elem_size; // =0: unknown, >0: element size + uint n_elem_head; // elem_size>0: number of elements by header + uint n_elem; // 0: number of real elements + bmg_section_t *sect; // pointer to raw source data + // if NULL: list terminator + bool known; // true: section known + bool supported; // true: section fully supported + bool is_empty; // true: complete data is NULL +// bool use_str1; // true: SINF1 uses 2x 16-bit offsets to STR1 + ccp info; // short description +} +bmg_sect_info_t; + +//----------------------------------------------------------------------------- +// [[bmg_sect_list_t]] + +typedef struct bmg_sect_list_t +{ + // all pointers point into raw source data + + uint source_size; // valid source size + uint this_size; // total size of this including info[] + + bmg_header_t *header; // NULL or pointer to BMG file header + bmg_inf_t *pinf; // NULL or pointer to INF1 header + bmg_dat_t *pdat; // NULL or pointer to DAT1 header + bmg_str_t *pstr; // NULL or pointer to STR1 header + bmg_mid_t *pmid; // NULL or pointer to MID1 header + bmg_flw_t *pflw; // NULL or pointer to FLW1 header + bmg_fli_t *pfli; // NULL or pointer to FLI1 header + + uint n_sections; // number if secton, get by bmg header + uint n_info; // number of info records excluding terimination + bmg_sect_info_t info[]; // list of sections, + // terminated by a record with sect==NULL +} +bmg_sect_list_t; + +//----------------------------------------------------------------------------- + +// result is alloced => FREE(result) +bmg_sect_list_t * ScanSectionsBMG ( cvp data, uint size ); + +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 + bool icase // if not found: ignore case and try again +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct bmg_raw_section_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[bmg_raw_section_t]] + +typedef struct bmg_raw_section_t +{ + char magic[4]; // section magic + FastBuf_t data; // data buffer + uint total_size; // total size of section + // if 0: calculate it + struct + bmg_raw_section_t *next; // pointer to next element +} +bmg_raw_section_t; + +//----------------------------------------------------------------------------- + +bmg_raw_section_t * GetRawSectionBMG ( bmg_t *bmg, cvp magic ); +bmg_raw_section_t * CreateRawSectionBMG ( bmg_t *bmg, cvp magic ); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct bmg_item_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[bmg_item_t]] + +typedef struct bmg_item_t +{ + u32 mid; // message ID + u32 cond; // >0: message 'cond' must be defined + bmg_slot_t slot; // BMG_NO_PREDEF_SLOT or predifined slot + + u16 attrib_used; // used size of 'attrib' + u8 attrib[BMG_ATTRIB_SIZE];// attribute buffer, copy from 'inf' + // always padded with NULL + + u16 *text; // pointer to text + u16 len; // length in u16 words of 'text' + u16 alloced_size; // alloced size in u16 words of 'text' + // if 0: pointer to an other area + // ==> do not free or modify +} +__attribute__ ((packed)) bmg_item_t; + +//----------------------------------------------------------------------------- + +// special value for bmg_item_t::text +extern u16 bmg_null_entry[]; // = {0} + +static inline bool isSpecialEntryBMG ( const u16 *text ) +{ + return text == bmg_null_entry; +} + +//----------------------------------------------------------------------------- + +void FreeItemBMG( bmg_item_t * bi ); + +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() +); + +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() +); + +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. +); + +bool IsItemEqualBMG +( + const bmg_item_t * bi1, // NULL or valid item + const bmg_item_t * bi2 // NULL or valid item +); + +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' +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct bmg_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[bmg_t]] + +struct szs_file_t; + +typedef struct bmg_t +{ + //--- base info + + ccp fname; // alloced filename of loaded file + FileAttrib_t fatt; // file attribute + bool is_text_src; // true: source was text + + //--- container, used by SZS tools + + struct szs_file_t *szs; // NULL or pointer to containing SZS + + //--- multiple load support + + bool src_is_arch; // true: source is an archive + uint src_count; // number of scanned sources + enumError max_err; // max error + uint recurse_depth; // current recurse depth + + //--- raw data + + u8 * data; // raw data + uint data_size; // size of 'data' + bool data_alloced; // true: 'data' must be freed + + bmg_inf_t * inf; // pointer to 'INF1' data + bmg_dat_t * dat; // pointer to 'DAT1' data + bmg_mid_t * mid; // pointer to 'MID1' data + + //--- raw sections + + bmg_raw_section_t *first_raw; // NULL or pointer to chain of raw sections + bmg_raw_section_t *current_raw; // NULL or pointer to current raw sections + + //--- section header data + + u32 unknown_inf_0c; // section INF1 offset 0x0c + u16 unknown_mid_0a; // section MID1 offset 0x0a + u32 unknown_mid_0c; // section MID1 offset 0x0c + + //--- text map + + bmg_item_t * item; // item list + uint item_used; // number of used items + uint item_size; // number of alloced items + + //--- attributes and other parameters + + bmg_encoding_t encoding; // type of encoding + uint inf_size; // size of each 'inf' element + bool have_mid; // TRUE: enable MID1 creation + u8 attrib[BMG_ATTRIB_SIZE];// attribute buffer for defaults + u16 attrib_used; // used size of 'attrib', ALIGN(4) + u8 use_color_names; // 0:off, 1:auto, 2:on + u8 use_mkw_messages; // 0:off, 1:auto, 2:on + bool param_defined; // true: params above finally defined + + bool have_predef_slots; // temporary, set by HavePredifinedSlots() + bool use_slots; // init by opt_bmg_use_slots + bool use_raw_sections; // init by opt_bmg_use_raw_sections + u32 active_cond; // active condition (for text output) + + //--- raw data, created by CreateRawBMG() + + u8 * raw_data; // NULL or data + uint raw_data_size; // size of 'raw_data' + +} bmg_t; + +//----------------------------------------------------------------------------- + +extern bmg_t *bmg_macros; + +//----------------------------------------------------------------------------- + +bmg_item_t * FindItemBMG ( const bmg_t *bmg, u32 mid ); +bmg_item_t * FindAnyItemBMG ( const bmg_t *bmg, u32 mid ); +bmg_item_t * InsertItemBMG ( bmg_t *bmg, u32 mid, + u8 *attrib, uint attrib_used, bool *old_item ); +bool DeleteItemBMG ( bmg_t *bmg, u32 mid ); + +void ResetAttribBMG +( + const bmg_t * bmg, // pointer to bmg + bmg_item_t * item // dest item +); + +void CopyAttribBMG +( + const bmg_t * dest, // pointer to destination bmg + bmg_item_t * dptr, // dest item + const bmg_item_t * sptr // source item +); + +bool HavePredifinedSlots ( bmg_t *bmg ); + +//----------------------------------------------------------------------------- + +void InitializeBMG ( bmg_t * bmg ); +void ResetBMG ( bmg_t * bmg ); +void AssignEncodingBMG ( bmg_t * bmg, int encoding ); +void AssignInfSizeBMG ( bmg_t * bmg, uint inf_size ); + +//----------------------------------------------------------------------------- + +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_data // size of 'data' if data not NULL +); + +enumError ScanRawBMG ( bmg_t * bmg ); +enumError ScanTextBMG ( bmg_t * bmg ); + +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 +); + +//----------------------------------------------------------------------------- + +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 '[]' +); + +//----------------------------------------------------------------------------- + +enumError CreateRawBMG +( + bmg_t * bmg // pointer to valid BMG +); + +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 +); + +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 +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct bmg_create_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[bmg_create_t]] + +typedef struct bmg_create_t +{ + bmg_t *bmg; // current bmg + FastBuf_t inf; // INF1 data + FastBuf_t dat; // DAT1 data + FastBuf_t mid; // MID1 data + + bool have_mid; // true: have MID1 section + uint n_msg; // number of inserted messages + + //--- iterator -> GetFirstBI() + GetNextBI() + + int slot; // slot number + bmg_item_t *bi; // next bi + bmg_item_t *bi_end; // last bi + + bmg_item_t **bi_list; // list for predifined slots + uint bi_used; // number of used elements in 'bi_list' + uint bi_size; // number of alloced elements in 'bi_list' +} +bmg_create_t; + +//----------------------------------------------------------------------------- + +void InitializeCreateBMG( bmg_create_t *bc, bmg_t *bmg ); +void ResetCreateBMG ( bmg_create_t *bc ); + +bmg_item_t * GetFirstBI ( bmg_create_t *bc ); +bmg_item_t * GetNextBI ( bmg_create_t *bc ); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// struct bmg_scan_mid_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[bmg_scan_mid_t]] + +typedef struct bmg_scan_mid_t +{ + int status; // -1 for invalid, or 'n_mid' + int n_mid; // number of valid members in mid (0..3) + u32 mid[3]; // list of message IDs + // mid[0]: standard MID + // mid[1]: twin (track or arena) + // mid[2]: MID for LE_CODE or CT_CODE + char *scan_end; // NULL or end of scanned 'source' +} +bmg_scan_mid_t; + +//----------------------------------------------------------------------------- + +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 +); + +//----------------------------------------------------------------------------- +// [[obsolete]] wrapper for ScanBMGMID(); + +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' +); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// MKW hooks /////////////// +/////////////////////////////////////////////////////////////////////////////// + +extern int (*GetTrackIndexBMG) ( uint idx, int result_if_not_found ); +extern int (*GetArenaIndexBMG) ( uint idx, int result_if_not_found ); +extern ccp (*GetContainerNameBMG) ( const bmg_t * bmg ); + +extern int (*AtHookBMG) ( bmg_t * bmg, ccp line, ccp line_end ); +// On return status: +// -1: continue with scanning line +// -2: continue with next line +// >=0: close file and return status as error code + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// patch BMG /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[PatchModeBMG_t]] + +typedef enum PatchModeBMG_t +{ + // this mode descibes the operation: + // source := source x patch + + //--------------------------------------// + // only only source source // + // in in != == // + // source patch patch patch // + //--------------------------------------// + BMG_PM_PRINT, // source - print print // + BMG_PM_FORMAT, // ________use_parameter________ // + BMG_PM_REGEX, // ________use_parameter________ // + BMG_PM_RM_REGEX, // ________use_parameter________ // + BMG_PM_ID, // prefix n.a. n.a. n.a. // + BMG_PM_ID_ALL, // prefix n.a. n.a. n.a. // + BMG_PM_UNICODE, // ___no_patch_file_available___ // + BMG_PM_RM_ESCAPES, // ___no_patch_file_available___ // + //--------------------------------------// + BMG_PM_REPLACE, // source - patch both // + BMG_PM_INSERT, // source patch source both // + BMG_PM_OVERWRITE, // source patch patch both // + BMG_PM_DELETE, // source - - - // + BMG_PM_MASK, // - - source both // + BMG_PM_EQUAL, // - - - both // + BMG_PM_NOT_EQUAL, // - - source - // + //--------------------------------------// + BMG_PM_GENERIC, // ___no_patch_file_available___ // + BMG_PM_RM_CUPS, // ___no_patch_file_available___ // + BMG_PM_CT_COPY, // ___no_patch_file_available___ // + BMG_PM_CT_FORCE_COPY, // ___no_patch_file_available___ // + BMG_PM_CT_FILL, // ___no_patch_file_available___ // + BMG_PM_LE_COPY, // ___no_patch_file_available___ // + BMG_PM_LE_FORCE_COPY, // ___no_patch_file_available___ // + BMG_PM_LE_FILL, // ___no_patch_file_available___ // + BMG_PM_X_COPY, // ___no_patch_file_available___ // + BMG_PM_X_FORCE_COPY, // ___no_patch_file_available___ // + BMG_PM_X_FILL, // ___no_patch_file_available___ // + BMG_PM_RM_FILLED, // ___no_patch_file_available___ // + //--------------------------------------// + + //--- helpers + BMG_PM__MASK_CMD = 0xff, // relevant bits of the command + BMG_PM__SHIFT_OPT = 8 // shift the parameter option by 8 bits + +} PatchModeBMG_t; + +/////////////////////////////////////////////////////////////////////////////// + +enumError PatchBMG +( + bmg_t *dest, // pointer to destination bmg + const bmg_t *src, // pointer to source bmg + PatchModeBMG_t patch_mode, // patch mode + ccp format, // NULL or format parameter + bool dup_strings // true: alloc mem for copied strings (OVERWRITE) +); + +//----------------------------------------------------------------------------- + +bool PatchFormatBMG +( + bmg_t *dest, // pointer to destination bmg + const bmg_t *src, // pointer to source bmg + ccp format // format parameter +); + +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 +); + +bool PatchPrintBMG ( bmg_t * dest, const bmg_t * src ); +bool PatchReplaceBMG ( bmg_t * dest, const bmg_t * src ); +bool PatchInsertBMG ( bmg_t * dest, const bmg_t * src ); +bool PatchDeleteBMG ( bmg_t * dest, const bmg_t * src ); +bool PatchMaskBMG ( bmg_t * dest, const bmg_t * src ); +bool PatchEqualBMG ( bmg_t * dest, const bmg_t * src ); +bool PatchNotEqualBMG ( bmg_t * dest, const bmg_t * src ); +bool PatchGenericBMG ( bmg_t * dest, const bmg_t * src ); + +bool PatchRmCupsBMG ( bmg_t * bmg ); + +bool PatchCTCopyBMG ( bmg_t * bmg ); +bool PatchLECopyBMG ( bmg_t * bmg ); +bool PatchXCopyBMG ( bmg_t * bmg ); + +bool PatchCTForceCopyBMG( bmg_t * bmg ); +bool PatchLEForceCopyBMG( bmg_t * bmg ); +bool PatchXForceCopyBMG ( bmg_t * bmg ); + +bool PatchFillBMG + ( bmg_t *bmg, ct_mode_t ct_mode, uint rcup_limit, uint track_limit ); +bool PatchXFillBMG ( bmg_t *bmg, uint rcup_limit, uint track_limit ); +static inline bool PatchCTFillBMG ( bmg_t *bmg, uint rcup_limit, uint track_limit ) + { return PatchFillBMG(bmg,CTM_CTCODE,rcup_limit,track_limit); } +static inline bool PatchLEFillBMG ( bmg_t *bmg, uint rcup_limit, uint track_limit ) + { return PatchFillBMG(bmg,CTM_LECODE2,rcup_limit,track_limit); } + +bool PatchIdBMG +( + bmg_t * bmg, // pointer to destination bmg + bool prefix_all // true: prefix all messages +); + +bool PatchRmEscapesBMG +( + bmg_t * bmg, // pointer to destination bmg + bool unicode, // replace '\u{16bit}' by unicode chars + bool rm_escapes // remove 1A escapes +); + +// remove between mid1 and mid2-1 +bool PatchRemoveBMG ( bmg_t * bmg, int mid1, int mid2 ); +//bool PatchRemoveTracksBMG ( bmg_t * bmg, int track_limit ); +bool PatchIdentificationBMG ( bmg_t *bmg, ct_bmg_t *ctb ); + +//----------------------------------------------------------------------------- + +ccp GetNameBMG ( const bmg_t *bmg, uint *name_len ); + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// E N D /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#endif // DC_LIB_BMG_H 1 -- cgit v1.3.1