/*************************************************************************** * * * _____ ____ * * | __ \ / __ \ _ _ _____ * * | | \ \ / / \_\ | | | | _ \ * * | | \ \| | | | | | |_| | * * | | | || | | | | | ___/ * * | | / /| | __ | | | | _ \ * * | |__/ / \ \__/ / | |___| | |_| | * * |_____/ \____/ |_____|_|_____/ * * * * 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