diff options
Diffstat (limited to '')
| -rw-r--r-- | project/src/lib-lex.c | 2952 |
1 files changed, 2952 insertions, 0 deletions
diff --git a/project/src/lib-lex.c b/project/src/lib-lex.c new file mode 100644 index 0000000..357e062 --- /dev/null +++ b/project/src/lib-lex.c @@ -0,0 +1,2952 @@ + +/*************************************************************************** + * _______ _______ _______ * + * | ___ |____ | ___ | * + * | | |_| / /| | |_| * + * | |_____ / / | |_____ * + * |_____ | / / |_____ | * + * _ | | / / _ | | * + * | |___| |/ /____| |___| | * + * |_______|_______|_______| * + * * + * Wiimms SZS Tools * + * https://szs.wiimm.de/ * + * * + *************************************************************************** + * * + * This file is part of the SZS project. * + * Visit https://szs.wiimm.de/ for project details and sources. * + * * + * Copyright (c) 2011-2021 by Dirk Clemens <wiimm@wiimm.de> * + * * + *************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * See file gpl-2.0.txt or http://www.gnu.org/licenses/gpl-2.0.txt * + * * + ***************************************************************************/ + +#include "dclib-xdump.h" +#include "lib-lex.h" +#include "lib-std.h" +#include "lib-mkw.h" +#include "lib-szs.h" +#include "lex.inc" + +#include <stddef.h> + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// DEBUG settings /////////////// +/////////////////////////////////////////////////////////////////////////////// + +#undef CHECK_FEATURES + +#if defined(TEST) || defined(DEBUG) || defined(HAVE_WIIMM_EXT) + #define CHECK_FEATURES 1 +#else + #define CHECK_FEATURES 0 +#endif + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// LEX action log /////////////// +/////////////////////////////////////////////////////////////////////////////// + +bool LEX_ACTION_LOG ( bool is_patch, const char * format, ... ) +{ + #if HAVE_PRINT + { + char buf[200]; + snprintf(buf,sizeof(buf),">>>[LEX]<<< %s",format); + va_list arg; + va_start(arg,format); + PRINT_ARG_FUNC(buf,arg); + va_end(arg); + } + #endif + +// if ( verbose > 2 || KMP_MODE & KMPMD_LOG || is_patch && ~KMP_MODE & KMPMD_SILENT ) + if ( verbose > 2 || is_patch ) + { + fflush(stdout); + fprintf(stdlog," %s>[LEX]%s ", + colset->heading, + is_patch ? colset->highlight : colset->info ); + va_list arg; + va_start(arg,format); + vfprintf(stdlog,format,arg); + va_end(arg); + fputs(colset->reset,stdlog); + fflush(stdlog); + return true; + } + + return false; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// features_szs_t /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[feature_var_t]] + +typedef struct feature_var_t +{ + u16 offset; // offset for features_szs_t + u8 index; // index or bit number of related analyse_szs_t + u8 no_lex; // suppress output for lex files + ccp name; // name of variable + ccp comment; // comment for variable +} +feature_var_t; + +#undef DEF_VAR +#define DEF_VAR(l,i,v,c) { offsetof(features_szs_t,v),i,l,#v,c } + +//----------------------------------------------------------------------------- + +static const feature_var_t szs_feature_list[] = +{ + DEF_VAR( 1,HAVESZS_COURSE_LEX, f_lex, "File course.lex" ), + DEF_VAR( 0,HAVESZS_ITEM_SLOT_TABLE, f_item_slot_table, "File ItemSlotTable/ItemSlotTable.slt" ), + DEF_VAR( 0,HAVESZS_OBJFLOW, f_objflow, "File common/ObjFlow.bin" ), + DEF_VAR( 0,HAVESZS_GHT_ITEM, f_ght_item, "File common/GeoHitTableItem.bin" ), + DEF_VAR( 0,HAVESZS_GHT_ITEM_OBJ, f_ght_item_obj, "File common/GeoHitTableItemObj.bin" ), + DEF_VAR( 0,HAVESZS_GHT_KART, f_ght_kart, "File common/GeoHitTableKart.bin" ), + DEF_VAR( 0,HAVESZS_GHT_KART_OBJ, f_ght_kart_obj, "File common/GeoHitTableKartObj.bin" ), + DEF_VAR( 0,HAVESZS_MINIGAME, f_minigame, "File common/minigame.kmg" ), + + {0,0,0,0,0} +}; + +//----------------------------------------------------------------------------- + +static const feature_var_t kmp_feature_list[] = +{ + DEF_VAR( 0,HAVEKMP_WOODBOX_HT, kmp_woodbox_ht, "KMP: Woodbox with fall height" ), + DEF_VAR( 0,HAVEKMP_MUSHROOM_CAR, kmp_mushroom_car, "KMP: penguin_m as mushroom car" ), + DEF_VAR( 0,HAVEKMP_PENGUIN_POS, kmp_penguin_pos, "KMP: Alternative start of penguin_m" ), + DEF_VAR( 0,HAVEKMP_SECOND_KTPT, kmp_second_ktpt, "KMP: Second KTPT with index -1" ), + DEF_VAR( 0,HAVEKMP_X_PFLAGS, kmp_extended_pflags, "KMP: Extended presence flags (XPF) used" ), + DEF_VAR( 0,HAVEKMP_X_COND, kmp_xpf_cond_obj, "KMP: XPF: Conditional object used" ), + DEF_VAR( 0,HAVEKMP_X_DEFOBJ, kmp_xpf_def_obj, "KMP: XPF: Definition object used" ), + DEF_VAR( 0,HAVEKMP_X_RANDOM, kmp_xpf_random, "KMP: XPF: Random scenarios used" ), + DEF_VAR( 0,HAVEKMP_EPROP_SPEED, kmp_eprop_speed, "KMP: Epropeller with speed setting" ), + DEF_VAR( 0,HAVEKMP_COOB_R, kmp_coob_riidefii, "KMP: Conditional OOB by Riidefi" ), + DEF_VAR( 0,HAVEKMP_COOB_K, kmp_coob_khacker, "KMP: Conditional OOB by kHacker35000vr" ), + DEF_VAR( 0,HAVEKMP_UOOB, kmp_uncond_oob, "KMP: Unconditional OOB" ), + + {0,0,0,0,0} +}; + +//----------------------------------------------------------------------------- + +static const feature_var_t lex_section_list[] = +{ + DEF_VAR( 1,HAVELEXS_FEA0, lex_sect_fea0, "LEX section FEA0" ), + DEF_VAR( 0,HAVELEXS_TEST, lex_sect_test, "LEX section TEST" ), + DEF_VAR( 0,HAVELEXS_SET1, lex_sect_set1, "LEX section SET1" ), + DEF_VAR( 0,HAVELEXS_CANN, lex_sect_cann, "LEX section CANN" ), + DEF_VAR( 0,HAVELEXS_HIPT, lex_sect_hipt, "LEX section HIPT" ), + // move HAVELEXS_TEST to here + + {0,0,0,0,0} +}; +//----------------------------------------------------------------------------- + +static const feature_var_t lex_feature_list[] = +{ + DEF_VAR( 0,HAVELEXF_TEST_ACTIVE, lex_test_active, "LEX: Active test scenario" ), + DEF_VAR( 0,HAVELEXF_ITEM_RANGE, lex_item_range, "LEX: Expand the range of item positions" ), + DEF_VAR( 0,HAVELEXF_CANNON, lex_cannon, "LEX: Alternative cannon settings" ), + DEF_VAR( 0,HAVELEXF_HIDE_POS, lex_hide_pos, "LEX: Hide position tracker conditionally" ), + // move HAVELEXF_TEST_ACTIVE to here + {0,0,0,0,0} +}; + +/////////////////////////////////////////////////////////////////////////////// +// [[feature_list_var_type]] + +enum feature_list_var_type +{ + FVT_BOOL_ARRAY, + FVT_BYTE_ARRAY, + FVT_UINT_BITS, +}; + +//----------------------------------------------------------------------------- +// [[feature_list_t]] + +typedef struct feature_list_t +{ + const feature_var_t *var; // var list + uint var_type; // one of enum feature_list_var_type + uint offset; // offset in analyse_szs_t + ccp ref_prefix; // prefix for references + ccp heading1; // heading1 + ccp heading2; // heading2 +} +feature_list_t; + +//----------------------------------------------------------------------------- + +static const feature_list_t feature_lists[] = +{ + { szs_feature_list, + FVT_BYTE_ARRAY, + offsetof(szs_have_t,szs), + "SZS file", + "Additional sub-files found in SZS file", + "0:no file, 1:unmodified file, 2:modified file" }, + + { kmp_feature_list, + FVT_BOOL_ARRAY, + offsetof(szs_have_t,kmp), + "KMP feature", + "Special features found in KMP (sub-file course.kmp)", + 0 }, + + { lex_section_list, + FVT_UINT_BITS, + offsetof(szs_have_t,lex_sect), + "LEX section", + "Sections found in LEX (sub-file course.lex)", + 0 }, + + { lex_feature_list, + FVT_UINT_BITS, + offsetof(szs_have_t,lex_feat), + "LEX feature", + "Special features found in LEX (sub-file course.lex)", + 0 }, + + {0,0,0,0,0} +}; + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +void InitializeFeaturesSZS ( features_szs_t * fs ) +{ + DASSERT(fs); + memset(fs,0,sizeof(*fs)); + fs->size_be = htons(sizeof(*fs)); +} + +/////////////////////////////////////////////////////////////////////////////// +#if CHECK_FEATURES + + static uint CheckUsageFeaturesSZS() + { + GetFeaturesModes(); + + static uint err_count = 0; + static bool done = false; + if (done) + return err_count; + done = true; + + features_szs_t fs; + InitializeFeaturesSZS(&fs); + u8 *fs_data = (u8*)&fs; + + ccp err_msg = "Invalid feature_var_t[]\n"; + + const feature_list_t *list; + for ( list = feature_lists; list->var; list++ ) + { + const feature_var_t *var; + for ( var = list->var; var->offset; var++ ) + { + uint offset = var->offset; + if ( offset < FIRST_FEATURE_SZS_OFFSET || offset > sizeof(features_szs_t) ) + { + if (!err_count++) + ERROR0(ERR_INVALID_DATA,err_msg,0); + fprintf(stderr,"!! * Offset %d out of range.\n",offset); + } + else + fs_data[offset]++; + } + } + + uint offset; + for ( offset = FIRST_FEATURE_SZS_OFFSET; offset < sizeof(features_szs_t); offset++ ) + { + const u8 count = fs_data[offset]; + if ( count != 1 ) + { + if (!err_count++) + ERROR0(ERR_INVALID_DATA,err_msg,0); + if (!count) + fprintf(stderr,"!! * Offset %d not used.\n",offset); + else + fprintf(stderr,"!! * Offset %d used %u times.\n",offset,count); + } + } + + ResetFeaturesSZS(&fs); + return err_count; + } + +#endif // CHECK_FEATURES +/////////////////////////////////////////////////////////////////////////////// + +void SetupFeaturesSZS ( features_szs_t *fs, const szs_have_t *have, bool is_lex ) +{ + #if CHECK_FEATURES + CheckUsageFeaturesSZS(); + #endif + + const feature_list_t *list; + const feature_var_t *var; + + for ( list = feature_lists; list->var; list++ ) + { + switch (list->var_type) + { + case FVT_BOOL_ARRAY: + { + const u8 *src = (u8*)have + list->offset; + for ( var = list->var; var->offset; var++ ) + ((u8*)fs)[var->offset] + = is_lex && var->no_lex + ? 1 + : src[var->index] > 0; + } + break; + + case FVT_BYTE_ARRAY: + { + const u8 *src = (u8*)have + list->offset; + for ( var = list->var; var->offset; var++ ) + ((u8*)fs)[var->offset] + = is_lex && var->no_lex + ? 1 + : src[var->index]; + } + break; + + case FVT_UINT_BITS: + { + const uint val = *(uint*)((u8*)have + list->offset); + for ( var = list->var; var->offset; var++ ) + ((u8*)fs)[var->offset] + = is_lex && var->no_lex + ? 1 + : ( val & 1 << var->index ) != 0; + } + break; + + default: + ASSERT(0); + } + } + + // ??? [[2do]] +} + +/////////////////////////////////////////////////////////////////////////////// + +void SetIsLexFeaturesSZS ( features_szs_t *fs ) +{ + DASSERT(fs); + + #if 1 + // short cut for code below + fs->f_lex = fs->lex_sect_fea0 = 1; + #else + // non optimized code + const feature_list_t *list; + for ( list = feature_lists; list->var; list++ ) + { + const feature_var_t *var; + for ( var = list->var; var->offset; var++ ) + if (var->no_lex) + ((u8*)fs)[var->offset] = 1; + } + #endif +} + +/////////////////////////////////////////////////////////////////////////////// + +int GetFeaturesStatusSZS ( const features_szs_t *fs ) +{ + // returns + // 0: all features set to null + // 1: all features except f_lex + lex_sect_fea0 are set to null + // 2: any features except f_lex + lex_sect_fea0 is not NULL + + DASSERT(fs); + + features_szs_t temp; + InitializeFeaturesSZS(&temp); + if (!memcmp(&temp,fs,sizeof(temp))) + return 0; + + temp.f_lex = fs->f_lex; + temp.lex_sect_fea0 = fs->lex_sect_fea0; + return memcmp(&temp,fs,sizeof(temp)) ? 2 : 1; +} + +/////////////////////////////////////////////////////////////////////////////// + +void PrintFeaturesSZS +( + PrintScript_t *ps, // valid output definition + const features_szs_t *fs, // valid source + bool is_lex, // TRUE: Create output for a LEX file + int comments, // >0: add extended comments + int print_modes, // >0: append ",MODES" + u8 include, // print only if all bits match + u8 exclude // exclude if any bit match +) +{ + DASSERT(ps); + DASSERT(fs); + + if ( ps->fform == PSFF_UNKNOWN && comments >= 0 ) + ps->fform = PSFF_ASSIGN; + + int head_mode = 0; + const u8 *modes = (u8*)GetFeaturesModes(); + const feature_list_t *list; + + for ( list = feature_lists; list->var; list++ ) + { + if ( comments >= 0 ) + head_mode = 2; + else if ( comments >= -1 ) + head_mode = 1; + + const feature_var_t *var; + for ( var = list->var; var->offset; var++ ) + { + if ( is_lex && var->no_lex ) + continue; + + const u8 mode = modes[var->offset]; + if ( ( mode & include ) != include || mode & exclude ) + continue; + + const u8 value = ((u8*)fs)[var->offset]; + if ( value || comments >= -2 ) + { + if ( head_mode == 1 ) + fputc('\n',ps->f); + else if ( head_mode == 2 ) + { + const int hlen1 = strlen(list->heading1); + const int hlen2 = list->heading2 ? strlen(list->heading2) : 0; + const int sep_len = ( hlen1 > hlen2 ? hlen1 : hlen2 ) + 2; + PrintScriptVars(ps,0,"\n#%.*s\n# %s\n", sep_len, Minus300, list->heading1 ); + if (list->heading2) + PrintScriptVars(ps,0,"# %s\n", list->heading2 ); + PrintScriptVars(ps,0,"#%.*s\n", sep_len, Minus300 ); + } + head_mode = 0; + + if ( comments >= 0 ) + { + fputc('\n',ps->f); + if ( comments >= 2 ) + PrintScriptVars(ps,0,"# %s #%u, feature offset %u, source index %u\n", + list->ref_prefix, (int)(var-list->var), + var->offset, var->index ); + PrintScriptVars(ps,0,"# %s\n",var->comment); + ccp effect = GetFeaturesEffects(mode); + if (effect) + PrintScriptVars(ps,0,"# %s\n",effect); + } + if ( print_modes > 0 ) + PrintScriptVars(ps,0,"%s=\"%u,%s\"\n", + var->name, value, GetFeaturesMode(mode) ); + else + PrintScriptVars(ps,0,"%s=%u\n",var->name,value); + } + } + } + + if ( comments >= -1 ) + fputc('\n',ps->f); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// features_szs_mode_t /////////////// +/////////////////////////////////////////////////////////////////////////////// + +const features_szs_t * GetFeaturesModes() +{ + static features_szs_t m = {0}; // keep name short! + + if (!m.size_be) + { + InitializeFeaturesSZS(&m); + + const u8 invalid = FZM_SECTION | FZM_BATTLE | FZM_TIMETRIAL; + memset((u8*)&m+sizeof(m.size_be),invalid,sizeof(m)-sizeof(m.size_be)); + + const u8 no_timetrial = FZM_OFFLINE | FZM_ONLINE; + + m.f_lex = FZM_VISUAL | FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE; + m.f_item_slot_table = FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE; + m.f_objflow = FZM_VISUAL | FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE; + m.f_ght_item = FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE; + m.f_ght_item_obj = FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE; + m.f_ght_kart = FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE; + m.f_ght_kart_obj = FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE; + m.f_minigame = FZM_GAMEPLAY | FZM_BATTLE | FZM_M_WHERE; + + m.kmp_woodbox_ht = FZM_GAMEPLAY | FZM_M_TYPE | no_timetrial; + m.kmp_mushroom_car = FZM_VISUAL | FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE; + m.kmp_penguin_pos = FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE; + m.kmp_second_ktpt = FZM_VISUAL | FZM_M_TYPE | FZM_M_WHERE; + m.kmp_extended_pflags = FZM_VISUAL | FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE; + m.kmp_xpf_cond_obj = FZM_VISUAL | FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE; + m.kmp_xpf_def_obj = FZM_VISUAL | FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE; + m.kmp_xpf_random = FZM_VISUAL | FZM_GAMEPLAY | FZM_M_TYPE | no_timetrial; + m.kmp_eprop_speed = FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE; + m.kmp_coob_riidefii = FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE; + m.kmp_coob_khacker = FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE; + m.kmp_uncond_oob = FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE; + + m.lex_sect_fea0 = FZM_SECTION; + m.lex_sect_test = FZM_VISUAL | FZM_GAMEPLAY | FZM_M_TYPE | no_timetrial | FZM_SECTION; + m.lex_sect_set1 = FZM_GAMEPLAY | FZM_M_TYPE | FZM_ONLINE | FZM_SECTION; + m.lex_sect_cann = FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE | FZM_SECTION; + m.lex_sect_hipt = FZM_VISUAL | FZM_M_TYPE | no_timetrial | FZM_SECTION; + + m.lex_test_active = FZM_VISUAL | FZM_GAMEPLAY | FZM_M_TYPE | no_timetrial; + m.lex_item_range = FZM_GAMEPLAY | FZM_M_TYPE | FZM_ONLINE; + m.lex_cannon = FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE; + m.lex_hide_pos = FZM_VISUAL | FZM_M_TYPE | no_timetrial; + + #if CHECK_FEATURES + uint err_count = 0; + const feature_list_t *list; + for ( list = feature_lists; list->var; list++ ) + { + const feature_var_t *var; + for ( var = list->var; var->offset; var++ ) + { + u8 value = ((u8*)&m)[var->offset]; + if ( value == invalid ) + { + if (!err_count++) + ERROR0(ERR_INVALID_DATA,"Invalid features modes\n"); + fprintf(stderr,"!! * Mode %s not set.\n",var->name); + } + } + } + #endif + } + return &m; +} + +/////////////////////////////////////////////////////////////////////////////// + +ccp GetFeaturesMode ( features_szs_mode_t mode ) +{ + char *buf = GetCircBuf(CHAR_BIT+1); + char *src = "SVGBRTLO", *dest = buf; + u8 mask; + for ( mask = 1; mask; mask <<= 1, src++ ) + if ( mode & mask ) + *dest++ = *src; + *dest = 0; + return buf; +} + +//----------------------------------------------------------------------------- + +ccp GetFeaturesEffects ( features_szs_mode_t mode ) +{ + struct tab_t { u8 not; u8 mode; ccp info; }; + static const struct tab_t *ptr, tab[] = + { + { 0,FZM_SECTION, "section" }, + + { 1,FZM_M_KIND, "no effects" }, + { 0,FZM_M_KIND, "visual and gameplay effects" }, + { 0,FZM_VISUAL, "visual effects only" }, + { 0,FZM_GAMEPLAY, "gameplay effects" }, + + { 0,FZM_M_TYPE, 0 }, + { 0,FZM_BATTLE, "battle only" }, + { 0,FZM_RACING, "racing only" }, + + { 0,FZM_M_WHERE, 0 }, + { 0,FZM_OFFLINE|FZM_ONLINE, "except time trial" }, + { 0,FZM_OFFLINE|FZM_TIMETRIAL, "offline incl. time trial" }, + { 0,FZM_ONLINE|FZM_TIMETRIAL, "time trial and online" }, + { 0,FZM_TIMETRIAL, "time trial only" }, + { 0,FZM_OFFLINE, "offline except time trial" }, + { 0,FZM_ONLINE, "online only" }, + + {0,0} + }; + + char buf[200], *dest = buf, *sep = ""; + for ( ptr = tab; ptr->mode; ptr++ ) + { + const u8 mode1 = ptr->not ? ~mode : mode; + if ( (mode1 & ptr->mode) == ptr->mode ) + { + if (ptr->info) + { + dest = StringCat2E(dest,buf+sizeof(buf),sep,ptr->info); + sep = ", "; + } + if (!ptr->not) + mode &= ~ptr->mode; + } + } + + return dest == buf ? 0 : CopyCircBuf0(buf,dest-buf); +} + +//----------------------------------------------------------------------------- + +ccp GetFeaturesEffectsByOffset ( uint offset ) +{ + if ( offset < 2 && offset >= sizeof(features_szs_t) ) + return 0; + + const features_szs_t *fs = GetFeaturesModes(); + return GetFeaturesEffects(((u8*)fs)[offset]); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// lecode extension LEX /////////////// +/////////////////////////////////////////////////////////////////////////////// + +enumError ScanLexFile + ( cvp data, uint data_size, lex_stream_func func, + cvp user_ptr, int user_int ) +{ + if ( !data || data_size < sizeof(lex_header_t) ) + return ERR_INVALID_DATA; + + const lex_header_t *hd = (lex_header_t*)data; + if (memcmp(hd->magic,LEX_BIN_MAGIC,4)) + return ERR_INVALID_DATA; + + if ( ntohs(hd->major_version) != LEX_MAJOR_VERSION ) + return ERR_INVALID_VERSION; + + const uint size = ntohl(hd->size); + const uint off = ntohl(hd->element_off); + if ( (size&3) || size > data_size || (off&3) || off + 4 > size ) + return ERR_INVALID_DATA; + + return ScanLexElements((u8*)data+off,size-off,func,user_ptr,user_int); +} + +/////////////////////////////////////////////////////////////////////////////// + +enumError ScanLexElements + ( cvp data, uint data_size, lex_stream_func func, + cvp user_ptr, int user_int ) +{ + if ( !data || !data_size || (data_size&3) ) + return ERR_INVALID_DATA; + + enumError max_err = ERR_OK; + + uint off = 0; + while ( off < data_size ) + { + const lex_element_t *s = (lex_element_t*)( (u8*)data + off ); + + const u32 magic = ntohl(s->magic); + if (!magic) + break; + + const uint size = ntohl(s->size); + off += sizeof(lex_element_t) + size; + if ( (size&3) || off > data_size ) + return ERR_INVALID_DATA; + + PRINT("LEX SECTION: %.4s, size:%x\n",PrintID(&s->magic,4,0),size); + if (func) + { + const int err = func(magic,s->data,size,user_ptr,user_int); + if (err<0) + return -err; + if ( max_err < err ) + max_err = err; + } + } + + return max_err; +} + +/////////////////////////////////////////////////////////////////////////////// + +lex_element_t * FindLexElement ( lex_header_t *head, uint data_size, u32 magic ) +{ + if ( !head || data_size <= sizeof(lex_header_t) || (data_size&3) ) + return 0; + + uint file_size = ntohl(head->size); + if ( file_size > data_size ) + return 0; + file_size -= sizeof(lex_element_t); + + uint offset = ntohl(head->element_off); + if ( offset > file_size ) + return 0; + + magic = htonl(magic); + for(;;) + { + lex_element_t *elem = (lex_element_t*)((u8*)head + offset); + offset += 8 + ntohl(elem->size); + if ( offset > file_size ) + return 0; + if ( elem->magic == magic ) + return elem; + } +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// fix lex items /////////////// +/////////////////////////////////////////////////////////////////////////////// + +typedef void (*FixElementFunc) ( lex_t * lex, lex_item_t * item ); + +/////////////////////////////////////////////////////////////////////////////// + +static void FixLEXElement_SET1 ( lex_set1_t *set1 ) +{ + DASSERT(set1); + + uint i; + for ( i = 0; i < 3; i++ ) + { + float f = bef4(set1->item_factor.v+i); + if ( !isnormal(f) || f < 1.0 ) + write_bef4(set1->item_factor.v+i,1.0); + } +} + +//----------------------------------------------------------------------------- + +static void FixLEXItem_SET1 +( + lex_t * lex, // LEX data structure + lex_item_t * item // item to fix +) +{ + DASSERT(lex); + DASSERT(item); + DASSERT( ntohl(item->elem.size) >= sizeof(lex_set1_t) ); + + lex_set1_t *set1 = (lex_set1_t*)item->elem.data; + FixLEXElement_SET1(set1); +} + +//----------------------------------------------------------------------------- +// [[+]] + +static void ClearLEXElement_SET1 ( lex_set1_t *set1 ) +{ + DASSERT(set1); + memset(set1,0,sizeof(*set1)); + FixLEXElement_SET1(set1); +} + +//----------------------------------------------------------------------------- +// [[+]] + +static bool IsActiveLEXElement_SET1 ( const lex_set1_t *set1 ) +{ + DASSERT(set1); + lex_set1_t empty, test = *set1; + ClearLEXElement_SET1(&empty); + FixLEXElement_SET1(&test); + return memcmp(&empty,&test,sizeof(empty)) != 0; +} + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[+]] + +static void FixLEXElement_TEST ( lex_test_t *lt ) +{ + DASSERT(lt); + + if ( lt->offline_online < LEX_OO_AUTO || lt->offline_online > LEX_OO_ONLINE ) + lt->offline_online = LEX_OO_AUTO; + + if ( lt->n_offline > 4 ) + lt->n_offline = 4; + + if ( lt->n_online > 99 ) + lt->n_online = 99; + + if ( lt->cond_bit < -1 || lt->cond_bit > 15 ) + lt->cond_bit = -1; + + if ( lt->game_mode >= LEX_GMODE__N ) + lt->game_mode = LEX_GMODE_AUTO; + + if ( lt->random > 8 ) + lt->random = 0; + + if ( lt->engine > ENGINE__N ) + lt->engine = 0; + + lt->padding = 0; +} + +//----------------------------------------------------------------------------- +// [[+]] + +static void FixLEXItem_TEST +( + lex_t * lex, // LEX data structure + lex_item_t * item // item to fix +) +{ + DASSERT(lex); + DASSERT(item); + DASSERT( ntohl(item->elem.size) >= sizeof(lex_test_t) ); + + lex_test_t *lt = (lex_test_t*)item->elem.data; + FixLEXElement_TEST(lt); +} + +//----------------------------------------------------------------------------- +// [[+]] + +static void ClearLEXElement_TEST ( lex_test_t *lt ) +{ + DASSERT(lt); + memcpy(lt,TestDataLEX,sizeof(*lt)); +} + +//----------------------------------------------------------------------------- +// [[+]] + +static bool IsActiveLEXElement_TEST ( const lex_test_t *lt ) +{ + DASSERT(lt); + lex_test_t empty, test = *lt; + ClearLEXElement_TEST(&empty); + FixLEXElement_TEST(&test); + return memcmp(&empty,&test,sizeof(empty)) != 0; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// lex_t helpers /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static lex_item_t * FindElementLEX +( + const lex_t * lex, // LEX data structure + u32 magic // magic +) +{ + magic = htonl(magic); + + uint i; + lex_item_t **ss; + for ( i = 0, ss = lex->item; i < lex->item_used; i++, ss++ ) + if ( (*ss)->elem.magic == magic ) + return *ss; + return 0; +} + +/////////////////////////////////////////////////////////////////////////////// + +static uint GetLexSortOrder ( u32 magic ) +{ + switch(magic) + { + case LEXS_FEA0: return 1; + case LEXS_SET1: return 2; + case LEXS_TEST: return 9; + default: return 5; + } +} + +/////////////////////////////////////////////////////////////////////////////// + +static void UpdateHaveLex ( lex_t *lex ) +{ + DASSERT(lex); + uint have_sect = 0; + uint have_feat = 0; + + uint i; + lex_item_t **ss; + for ( i = 0, ss = lex->item; i < lex->item_used; i++, ss++ ) + { + const u32 magic = ntohl((*ss)->elem.magic); + const uint size = ntohl((*ss)->elem.size); + uint j; + for ( j = 0; j < HAVELEXS__N; j++ ) + if ( magic == have_lex_sect_info[j].magic + && size >= have_lex_sect_info[j].min_size ) + { + have_sect |= 1 << j; + have_feat |= GetLexFeatures(&(*ss)->elem); + break; + } + } + + lex->have_sect = have_sect; + lex->have_feat = have_feat; +} + +/////////////////////////////////////////////////////////////////////////////// + +static lex_item_t * AppendElementLEX +( + lex_t * lex, // LEX data structure + u32 magic, // magic + const void * data, // data of section + uint size, // size of 'data' + bool overwrite // false: abort if exists and return 0 + // true: overwrite +) +{ + DASSERT(lex); + DASSERT( data || !size ); + PRINT("AppendElementLEX(%.4s) have=%02x,%02x, n=%u\n", + (ccp)&magic, lex->have_sect, lex->have_feat, lex->item_used); + + + //--- check if already exists + + lex_item_t **ss; + const u32 be_magic = htonl(magic); + uint i; + for ( i = 0, ss = lex->item; i < lex->item_used; i++, ss++ ) + if ( (*ss)->elem.magic == be_magic ) + { + if (!overwrite) + return 0; + break; + } + + + //--- grow item list if necessary + + if ( i == lex->item_size ) + { + lex->item_size = lex->item_size + 30; + lex->item = REALLOC( lex->item, lex->item_size * sizeof(*lex->item) ); + // 'ss' becomes invalid! + ss = lex->item + i; + } + + if ( i < lex->item_used ) + FREE(*ss); + else + lex->item_used++; + + + //--- fix item size + + uint size4 = ALIGN32(size,4); + FixElementFunc fix_func = 0; + + switch(magic) + { + case LEXS_FEA0: + if ( size4 < sizeof(features_szs_t) ) + size4 = ALIGN32(sizeof(features_szs_t),4); + break; + + case LEXS_SET1: + fix_func = FixLEXItem_SET1; + if ( size4 < sizeof(lex_set1_t) ) + size4 = ALIGN32(sizeof(lex_set1_t),4); + break; + + case LEXS_TEST: + if ( size4 < sizeof(lex_test_t) ) + size4 = ALIGN32(sizeof(lex_test_t),4); + break; + } + + + //--- setup item + + lex_item_t *s = MALLOC(sizeof(lex_item_t)+size4); + *ss = s; + s->sort_order = GetLexSortOrder(magic); + s->insert_order = i; + s->elem.magic = be_magic; + s->elem.size = htonl(size4); + memcpy(s->elem.data,data,size); + if ( size < size4 ) + memset(s->elem.data+size,0,size4-size); + + if (fix_func) + fix_func(lex,s); + + PRINT("AppendElementLEX(%.4s) have=%02x,%02x, n=%u\n", + (ccp)&magic, lex->have_sect, lex->have_feat, lex->item_used); + UpdateHaveLex(lex); + return s; +} + +/////////////////////////////////////////////////////////////////////////////// + +static bool RemoveElementLEX +( + lex_t *lex, // LEX data structure + const lex_item_t *li // element to remove (robust) +) +{ + if ( !li || !li->elem.magic ) + return 0; + + uint i; + lex_item_t **ss; + for ( i = 0, ss = lex->item; i < lex->item_used; i++, ss++ ) + if ( *ss == li ) + { + memmove(ss,ss+1,lex->item_used-i); + lex->item_used--; + FREE((lex_item_t*)li); + UpdateHaveLex(lex); + return true; + } + return false; +} + +//----------------------------------------------------------------------------- + +static uint RemoveElementByMagicLEX +( + lex_t *lex, // LEX data structure + u32 magic // magic +) +{ + if (!magic) + return 0; + + uint count = 0; + for(;;) + { + lex_item_t *li = FindElementLEX(lex,magic); + if (!li) + return count; + count += RemoveElementLEX(lex,li); + } +} + +/////////////////////////////////////////////////////////////////////////////// + +static int cmp_lex_item ( const lex_item_t ** pa, const lex_item_t ** pb ) +{ + const lex_item_t *a = *pa; + const lex_item_t *b = *pb; + noPRINT(">> SORT: %u.%u : %u.%u\n", + a->sort_order, a->insert_order, + b->sort_order, b->insert_order ); + + int res = (int)a->sort_order - (int)b->sort_order; + return res ? res : (int)a->insert_order - (int)b->insert_order; +} + +//----------------------------------------------------------------------------- + +static void SortItemsLEX +( + lex_t * lex // LEX data structure +) +{ + if ( lex->item_used > 1 ) + qsort( lex->item, lex->item_used, sizeof(*lex->item), + (qsort_func)cmp_lex_item ); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// LEX features /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static uint GetLexFeaturesSET1 ( const lex_element_t *elem ) +{ + uint have_feat = 0; + const uint size = ntohl(elem->size); + const lex_set1_t *set1 = (lex_set1_t*)elem->data; + + if ( size >= offsetof(lex_set1_t,item_factor) + sizeof(set1->item_factor) ) + { + if ( bef4(set1->item_factor.v+0) != 1.0 + || bef4(set1->item_factor.v+1) != 1.0 + || bef4(set1->item_factor.v+2) != 1.0 + ) + { + have_feat |= 1 << HAVELEXF_ITEM_RANGE; + } + } + return have_feat; +} + +//----------------------------------------------------------------------------- + +static uint GetLexFeaturesCANN ( const lex_element_t *elem ) +{ + return ntohl(elem->size) != sizeof(CannonDataLEX) + || memcmp(elem->data,CannonDataLEX,sizeof(CannonDataLEX)) + ? 1 << HAVELEXF_CANNON : 0; +} + +//----------------------------------------------------------------------------- + +static uint GetLexFeaturesHIPT ( const lex_element_t *elem ) +{ + return ntohl(elem->size) >= sizeof(lex_hipt_rule_t) + ? 1 << HAVELEXF_HIDE_POS : 0; +} + +//----------------------------------------------------------------------------- + +static uint GetLexFeaturesTEST ( const lex_element_t *elem ) +{ + DASSERT(elem); + return IsActiveLEXElement_TEST((lex_test_t*)elem->data) + ? 1 << HAVELEXF_TEST_ACTIVE : 0; +} + +//----------------------------------------------------------------------------- + +uint GetLexFeatures ( const lex_element_t *elem ) +{ + switch(ntohl(elem->magic)) + { + case LEXS_SET1: return GetLexFeaturesSET1(elem); + case LEXS_CANN: return GetLexFeaturesCANN(elem); + case LEXS_HIPT: return GetLexFeaturesHIPT(elem); + case LEXS_TEST: return GetLexFeaturesTEST(elem); + } + return 0; +} + +/////////////////////////////////////////////////////////////////////////////// + +const have_lex_info_t have_lex_feat_info[HAVELEXF__N] = +{ + { HAVELEXF_TEST_ACTIVE, "test", 0 }, + { HAVELEXF_ITEM_RANGE, "itempos", 0 }, + { HAVELEXF_CANNON, "cannon", 0 }, + { HAVELEXF_HIDE_POS, "hipt", 0 }, + //--- add new sections here (order is important) +}; + +/////////////////////////////////////////////////////////////////////////////// + +ccp CreateFeatureInfoLEX + ( have_lex_feat_t special, bool add_value, ccp return_if_empty ) +{ + static char buf[500]; + char *dest = buf; + + if (add_value) + dest = snprintfE( dest, buf+sizeof(buf), "%u=" , special ); + + uint i, mask; + ccp sep = ""; + for ( i = 0, mask = 1; i < HAVELEXF__N; i++, mask <<= 1 ) + if ( special & mask ) + { + dest = StringCat2E(dest,buf+sizeof(buf),sep,have_lex_feat_info[i].name); + sep = ","; + } + + return dest == buf ? return_if_empty : CopyCircBuf0(buf,dest-buf); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// have lex sections /////////////// +/////////////////////////////////////////////////////////////////////////////// +// order is important, compare have_lex_sect_t and ct.wiimm.de + +const have_lex_info_t have_lex_sect_info[HAVELEXS__N] = +{ + { LEXS_SET1, "set1", 1 }, // HAVELEXS_SET1 + { LEXS_CANN, "cannon", 0 }, // HAVELEXS_CANN + { LEXS_TEST, "test", 1 }, // HAVELEXS_TEST + { LEXS_HIPT, "hidepos", sizeof(lex_hipt_rule_t) }, // HAVELEXS_HIPT + { LEXS_FEA0, "features", 2 }, // HAVELEXS_FEA0 + //--- add new sections here (order is important) +}; + +/////////////////////////////////////////////////////////////////////////////// + +ccp CreateSectionInfoLEX + ( have_lex_sect_t special, bool add_value, ccp return_if_empty ) +{ + static char buf[500]; + char *dest = buf; + + if (add_value) + dest = snprintfE( dest, buf+sizeof(buf), "%u=" , special ); + + uint i, mask; + ccp sep = ""; + for ( i = 0, mask = 1; i < HAVELEXS__N; i++, mask <<= 1 ) + if ( special & mask ) + { + dest = StringCat2E(dest,buf+sizeof(buf),sep,have_lex_sect_info[i].name); + sep = ","; + } + + return dest == buf ? return_if_empty : CopyCircBuf0(buf,dest-buf); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// LEX setup /////////////// +/////////////////////////////////////////////////////////////////////////////// + +void InitializeLEX ( lex_t * lex ) +{ + DASSERT(lex); + memset(lex,0,sizeof(*lex)); + + lex->fname = EmptyString; +} + +/////////////////////////////////////////////////////////////////////////////// + +void ResetLEX ( lex_t * lex ) +{ + if (lex) + { + FreeString(lex->fname); + if (lex->raw_data) + FREE(lex->raw_data); + + if (lex->item) + { + uint i; + for ( i = 0; i < lex->item_used; i++ ) + if (lex->item[i]) + FREE(lex->item[i]); + FREE(lex->item); + } + InitializeLEX(lex); + } +} + +/////////////////////////////////////////////////////////////////////////////// + +void UpdateLEX ( lex_t * lex, bool add_missing, bool add_test ) +{ + DASSERT(lex); + + if ( add_missing && lex->develop ) + { + //--- FEA0 + AppendFea0LEX(lex,false,0); + } + + if (add_missing) + { + //--- SET1 + AppendSet1LEX(lex,false); + + //--- CANN + AppendCannLEX(lex,false); + + //--- HIPT + AppendHiptLEX(lex,false); + } + + if (add_test) //--- TEST + AppendTestLEX(lex,false); + + SortItemsLEX(lex); +} + +//----------------------------------------------------------------------------- + +lex_item_t * AppendFea0LEX + ( lex_t * lex, bool overwrite, const features_szs_t *src_fs ) +{ + features_szs_t fs; + if (src_fs) + fs = *src_fs; + else + InitializeFeaturesSZS(&fs); + SetIsLexFeaturesSZS(&fs); + + return AppendElementLEX(lex,LEXS_FEA0,&fs,sizeof(fs),overwrite); +} + +//----------------------------------------------------------------------------- + +lex_item_t * AppendSet1LEX ( lex_t * lex, bool overwrite ) +{ + lex_set1_t set1; + memset(&set1,0,sizeof(set1)); + // AppendElementLEX() does call FixLEXItem_SET1() + return AppendElementLEX(lex,LEXS_SET1,&set1,sizeof(set1),overwrite); +} + +//----------------------------------------------------------------------------- + +lex_item_t * AppendCannLEX ( lex_t * lex, bool overwrite ) +{ + return AppendElementLEX( lex, LEXS_CANN, CannonDataLEX, + sizeof(CannonDataLEX), overwrite); +} + +//----------------------------------------------------------------------------- + +lex_item_t * AppendHiptLEX ( lex_t * lex, bool overwrite ) +{ + return AppendElementLEX( lex, LEXS_HIPT, 0, 0, overwrite); +} + +//----------------------------------------------------------------------------- + +lex_item_t * AppendTestLEX ( lex_t * lex, bool overwrite ) +{ + return AppendElementLEX( lex, LEXS_TEST, TestDataLEX, + sizeof(TestDataLEX), overwrite); +} + +/////////////////////////////////////////////////////////////////////////////// + +void DumpElementsLEX ( FILE *f, lex_t *lex, bool hexdump ) +{ + DASSERT(f); + DASSERT(lex); + + fprintf(f,"LEX SECTIONS: %u/%u\n",lex->item_used,lex->item_size); + + uint i; + for ( i = 0; i < lex->item_used; i++ ) + { + lex_item_t *s = lex->item[i]; + const uint size = ntohl(s->elem.size); + fprintf(f," %-4.4s %08x, size: %5u = 0x%04x\n", + PrintID(&s->elem.magic,4,0), s->elem.magic, size, size ); + if ( size && hexdump ) + HexDump16(f,8,0,s->elem.data,size); + } +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// lex parser functions /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static enumError F_isLEX +( + struct Var_t * res, // store result here + struct Var_t * param, // parameters, modified + uint n_param, // number of parameters + struct ScanInfo_t * si, // not NULL: use for error messages + const FuncParam_t * fpar // pointer to user parameter +) +{ + DASSERT(res); + DASSERT(param); + + uint result = 0; + if ( si && si->lex ) + { + result = 1; + + if (si->lex->fname) + { + ccp fname = strrchr(si->lex->fname,'/'); + if (fname) + fname++; + else + fname = si->lex->fname; + + if ( !strcasecmp(fname,"course.lex") + || !strcasecmp(fname,"course.txt") + || !strcasecmp(fname,"course.txt.lex") ) + { + result = 2; + } + } + } + + res->i = result; + res->mode = VAR_INT; + return ERR_OK; +} + +/////////////////////////////////////////////////////////////////////////////// + +static const struct FuncTable_t lex_func_tab[] = +{ + { 0, 0, "ISLEX", F_isLEX, 0, // replace only function call + "int", "isLEX()", 0 }, // but not info + + {0,0,0,0,0,0,0,0} +}; + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// setup lex parser /////////////// +/////////////////////////////////////////////////////////////////////////////// + +const VarMap_t * SetupVarsLEX() +{ + static VarMap_t vm = {0}; + if (!vm.used) + { + DefineMkwVars(&vm); + DefineParserFuncTab(lex_func_tab,FF_LEX); + DefineParserVars(&vm); + } + + return &vm; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// ScanRawLEX() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +enumError DumpLEXFunc + ( u32 magic, const u8 *data, uint size, cvp user_ptr, int user_int ) +{ + u32 m = htonl(magic); + printf(" %s 0x%08x, %5u = 0x%04x bytes\n", + PrintID(&m,4,0), magic, size, size ); + if ( user_int < 0 || user_int >= 0x10 ) + { + if ( user_int > 0 && size > user_int ) + size = user_int; + HexDump16(stdout,5,0,data,size); + putchar('\n'); + } + return ERR_OK; +} + +//----------------------------------------------------------------------------- + +enumError ScanLEXFunc + ( u32 magic, const u8 *data, uint size, cvp user_ptr, int user_int ) +{ + #if HAVE_PRINT + u32 m = htonl(magic); + PRINT(">>>>> %-4.4s %08x : size: %u = 0x%x\n", + PrintID(&m,4,0), magic, size, size ); + #endif + + lex_t *lex = (lex_t*)user_ptr; + DASSERT(lex); + + switch (magic) + { + case LEXS_TERMINATE: + case LEXS_IGNORE: + // ignore + break; + + default: + AppendElementLEX(lex,magic,data,size,true); + #if HAVE_PRINT0 + if (logging>1) + DumpElementsLEX(stdout,lex,logging>2); + #endif + } + return ERR_OK; +} + +//----------------------------------------------------------------------------- + +enumError ScanRawLEX +( + lex_t * lex, // LEX data structure + bool init_lex, // true: initialize 'lex' first + const void * data, // data to scan + uint data_size, // size of 'data' + uint dump_mode // 0: add element to lex->item + // 1: dump scanned elements + // >=0x10: add hexdump of max # bytes +) +{ + DASSERT(lex); + if (init_lex) + InitializeLEX(lex); + + if ( IsValidLEX(data,data_size,data_size,lex->fname) >= VALID_ERROR ) + { + return ERROR0(ERR_INVALID_DATA, + "Invalid LEX file: %s\n" + "Add option --lex=force or --force to ignore some validity checks.", + lex->fname ? lex->fname : "?" ); + } + + lex->fform = FF_LEX; + enumError err = ScanLexFile( data, data_size, + dump_mode ? DumpLEXFunc : ScanLEXFunc, lex, dump_mode ); + if (err) + ERROR0(err,"Scanning of LEX file failed: %s\n",lex->fname); + else + UpdateLEX(lex,opt_complete,false); + + if (logging>0) + DumpElementsLEX(stdout,lex,logging>2); + return err; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// ScanTextLEX() /////////////// +/////////////////////////////////////////////////////////////////////////////// +// [[lex_section_id]] + +typedef enum lex_section_id +{ + LID_UNKNOWN, + LID_IGNORE, + LID_SETUP, + LID_HEXDUMP, + + LID_SETTINGS1, + LID_CANNON, + LID_HIDE_PT, + LID_TEST, +} +lex_section_id; + +/////////////////////////////////////////////////////////////////////////////// + +static const KeywordTab_t lex_section_name[] = +{ + //------------------------------------------------------------------------ + // ID NAME INFO unused + //------------------------------------------------------------------------ + + { LID_IGNORE, "END", "--", 0 }, + { LID_SETUP, "SETUP", "Setup", 0 }, + { LID_HEXDUMP, "HEXDUMP", "Hexdump of unknown section", 0 }, + + { LID_SETTINGS1, "SET1", "Basic settings", 0 }, + { LID_CANNON, "CANN", "Cannon settings", 0 }, + { LID_HIDE_PT, "HIPT", "Hide position tracker", 0 }, + { LID_TEST, "TEST", "Test case", 0 }, + + { 0,0,0,0 } +}; + +/////////////////////////////////////////////////////////////////////////////// + +static const KeywordTab_t lex_offline_online[] = +{ + { LEX_OO_AUTO, "AUTO", "0", 0 }, + { LEX_OO_OFFLINE, "OFFLINE", "1", 0 }, + { LEX_OO_OFFLINE, "NEVER", 0, 0 }, + { LEX_OO_ONLINE, "ONLINE", "2", 0 }, + { LEX_OO_ONLINE, "ALWAYS", 0, 0 }, + { -9, "OFF", "-1", -1 }, + { 0,0,0,0 } +}; + +/////////////////////////////////////////////////////////////////////////////// + +static const KeywordTab_t lex_game_mode[] = +{ + { LEX_GMODE_AUTO, "AUTO", "0", -1 }, + { LEX_GMODE_STD, "STANDARD", "1", KMP_GMODE_STD }, + { LEX_GMODE_STD, "STD", 0, KMP_GMODE_STD }, + { LEX_GMODE_BALLOON, "BALLOON", "2", KMP_GMODE_BALLOON }, + { LEX_GMODE_COIN, "COIN", "3", KMP_GMODE_COIN }, + { LEX_GMODE_VERSUS, "VERSUS", "4", KMP_GMODE_VERSUS }, + { LEX_GMODE_ITEMRAIN, "ITEMRAIN", "5", KMP_GMODE_ITEMRAIN }, + { -1, "OFF", "-1", -1 }, + { 0,0,0,0 } +}; + +/////////////////////////////////////////////////////////////////////////////// + +static const KeywordTab_t lex_engine[] = +{ + { LEX_ENGINE_AUTO, "AUTO", "0", -1 }, + { LEX_ENGINE_BATTLE, "BATTLE", 0, ENGINE_BATTLE }, + { LEX_ENGINE_50, "50CC", 0, ENGINE_50 }, + { LEX_ENGINE_100, "100CC", 0, ENGINE_100 }, + { LEX_ENGINE_150, "150CC", 0, ENGINE_150 }, + { LEX_ENGINE_200, "200CC", 0, ENGINE_200 }, + { LEX_ENGINE_150M, "150M", "150MIRROR", ENGINE_150M }, + { LEX_ENGINE_200M, "200M", "200MIRROR", ENGINE_200M }, + { -1, "OFF", "-1", -1 }, + { 0,0,0,0 } +}; + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +static enumError ScanLEXElementHexdump +( + lex_t * lex, // KMP data structure + ScanInfo_t * si // valid data +) +{ + DASSERT(lex); + DASSERT(si); + TRACE("ScanLEXElementHexdump()\n"); + + + //--- setup data + + u32 magic = LEXS_IGNORE; + ScanParam_t ptab[] = + { + { "MAGIC", SPM_U32, &magic, }, + {0} + }; + + char fb_buf[1000]; + FastBuf_t *fb = InitializeFastBuf(fb_buf,sizeof(fb_buf)); + + + //--- main loop + + for(;;) + { + char ch = NextCharSI(si,true); + if ( !ch || ch == '[' ) + break; + + if ( ch == '@' ) + ScanParamSI(si,ptab); + else + ScanHexlineSI(si,fb,true); + } + CheckLevelSI(si); + + if ( magic != LEXS_IGNORE && magic != LEXS_TERMINATE ) + AppendElementLEX(lex,magic,fb->buf,fb->ptr-fb->buf,true); + + ResetFastBuf(fb); + return ERR_OK; +} + +/////////////////////////////////////////////////////////////////////////////// + +static enumError ScanLEXElement_SET1 +( + lex_t * lex, // KMP data structure + ScanInfo_t * si // valid data +) +{ + DASSERT(lex); + DASSERT(si); + TRACE("ScanLEXElement_SET1()\n"); + + + //--- setup data + + lex_set1_t set1 = {0}; + + const ScanParam_t ptab[] = + { + { "ITEM-POS-FACTOR", SPM_FLOAT3_BE, &set1.item_factor }, + { "TEST1", SPM_U8, set1.test+0 }, + { "TEST2", SPM_U8, set1.test+1 }, + { "TEST3", SPM_U8, set1.test+2 }, + { "TEST4", SPM_U8, set1.test+3 }, + {0} + }; + + char fb_buf[1000]; + FastBuf_t *fb = InitializeFastBuf(fb_buf,sizeof(fb_buf)); + AppendFastBuf(fb,&set1,sizeof(set1)); + + + //--- main loop + + for(;;) + { + char ch = NextCharSI(si,true); + if ( !ch || ch == '[' ) + break; + + if ( ch == '@' ) + ScanParamSI(si,ptab); + else + ScanHexlineSI(si,fb,true); + } + CheckLevelSI(si); + + memcpy(fb->buf,&set1,sizeof(set1)); + HEXDUMP16(0,0,fb->buf,fb->ptr-fb->buf); + AppendElementLEX(lex,LEXS_SET1,fb->buf,fb->ptr-fb->buf,true); + + ResetFastBuf(fb); + return ERR_OK; +} + +/////////////////////////////////////////////////////////////////////////////// + +static enumError ScanLEXElement_CANN +( + lex_t * lex, // KMP data structure + ScanInfo_t * si // valid data +) +{ + DASSERT(lex); + DASSERT(si); + TRACE("ScanLEXElement_CANN()\n"); + + + //--- setup data + + ScanParam_t ptab[] = + { + {0} + }; + + char fb_buf[1000]; + FastBuf_t *fb = InitializeFastBuf(fb_buf,sizeof(fb_buf)); + AppendFastBuf(fb,EmptyString,4); + + + //--- main loop + + uint n_cannon = 0; + for(;;) + { + char ch = NextCharSI(si,true); + if ( !ch || ch == '[' ) + break; + + if ( ch == '@' ) + { + ScanParamSI(si,ptab); + continue; + } + + enumError err; + ScanIndexSI(si,&err,n_cannon,0,2); + if (err) + break; + + float f[4]; + ScanFloatSI(si,f,4); + + uint i; + u32 *fp = (u32*)f; + for ( i = 0; i < 4; i++, fp++ ) + *fp = htonl(*fp); + AppendFastBuf(fb,f,sizeof(f)); + n_cannon++; + CheckEolSI(si); + } + + if ( n_cannon > 0 ) + { + write_be32(fb->buf,n_cannon); + //HexDump16(stdout,0,0,fb->buf,fb->ptr-fb->buf); + AppendElementLEX(lex,LEXS_CANN,fb->buf,fb->ptr-fb->buf,true); + } + + ResetFastBuf(fb); + return ERR_OK; +} + +/////////////////////////////////////////////////////////////////////////////// + +static enumError ScanLEXElement_HIPT +( + lex_t * lex, // KMP data structure + ScanInfo_t * si // valid data +) +{ + DASSERT(lex); + DASSERT(si); + TRACE("ScanLEXElement_HIPT()\n"); + + + //--- setup data + + ScanParam_t ptab[] = + { + {0} + }; + + char fb_buf[1000]; + FastBuf_t *fb = InitializeFastBuf(fb_buf,sizeof(fb_buf)); + + + //--- main loop + + for(;;) + { + char ch = NextCharSI(si,true); + if ( !ch || ch == '[' ) + break; + + if ( ch == '@' ) + { + ScanParamSI(si,ptab); + continue; + } + + u8 num[sizeof(lex_hipt_rule_t)]; + ScanU8SI(si,num,sizeof(num),false); + AppendFastBuf(fb,num,sizeof(num)); + CheckEolSI(si); + } + + AppendElementLEX(lex,LEXS_HIPT,fb->buf,fb->ptr-fb->buf,true); + ResetFastBuf(fb); + + return ERR_OK; +} + +/////////////////////////////////////////////////////////////////////////////// + +static enumError ScanLEXElement_TEST +( + lex_t * lex, // KMP data structure + ScanInfo_t * si // valid data +) +{ + DASSERT(lex); + DASSERT(si); + TRACE("ScanLEXElement_TEST()\n"); + + + //--- setup data + + lex_test_t test; + memcpy(&test,TestDataLEX,sizeof(test)); + + const ScanParam_t ptab[] = + { + { "OFFLINE-ONLINE", SPM_U8, &test.offline_online }, + { "N-OFFLINE", SPM_U8, &test.n_offline }, + { "N-ONLINE", SPM_U8, &test.n_online }, + { "COND-BIT", SPM_S8, &test.cond_bit }, + { "GAME-MODE", SPM_U8, &test.game_mode }, + { "ENGINE", SPM_U8, &test.engine }, + { "RANDOM", SPM_U8, &test.random }, + {0} + }; + + char fb_buf[1000]; + FastBuf_t *fb = InitializeFastBuf(fb_buf,sizeof(fb_buf)); + AppendFastBuf(fb,&test,sizeof(test)); + + + //--- main loop + + for(;;) + { + char ch = NextCharSI(si,true); + if ( !ch || ch == '[' ) + break; + + if ( ch == '@' ) + ScanParamSI(si,ptab); + else + ScanHexlineSI(si,fb,true); + } + CheckLevelSI(si); + + memcpy(fb->buf,&test,sizeof(test)); + HEXDUMP16(0,0,fb->buf,fb->ptr-fb->buf); + AppendElementLEX(lex,LEXS_TEST,fb->buf,fb->ptr-fb->buf,true); + + ResetFastBuf(fb); + return ERR_OK; +} + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +enumError ScanTextLEX +( + lex_t * lex, // LEX data structure + bool init_lex, // true: initialize 'lex' first + const void * data, // data to scan + uint data_size // size of 'data' +) +{ + PRINT("ScanTextLEX(init=%d)\n",init_lex); + + DASSERT(lex); + if (init_lex) + InitializeLEX(lex); + + ScanInfo_t si; + InitializeSI(&si,data,data_size,lex->fname,lex->revision); + si.predef = SetupVarsLEX(); + + enumError max_err = ERR_OK; + lex->is_pass2 = false; + + for(;;) + { + PRINT("----- SCAN LEX SECTIONS, PASS%u ...\n",lex->is_pass2+1); + + max_err = ERR_OK; + si.lex = lex; + si.no_warn = !lex->is_pass2; + si.total_err = 0; + DefineIntVar(&si.gvar, "$PASS", lex->is_pass2+1 ); + + for(;;) + { + char ch = NextCharSI(&si,true); + if (!ch) + break; + + if ( ch != '[' ) + { + NextLineSI(&si,true,false); + continue; + } + ResetLocalVarsSI(&si,lex->revision); + + si.cur_file->ptr++; + char sect_name[20]; + ScanNameSI(&si,sect_name,sizeof(sect_name),true,true,0); + PRINT0("--> pass=%u: #%04u: %s\n",lex->is_pass2+1,si.cur_file->line,sect_name); + + int abbrev_count; + const KeywordTab_t *cmd = ScanKeyword(&abbrev_count,sect_name,lex_section_name); + if ( !cmd || abbrev_count ) + continue; + NextLineSI(&si,false,false); + PRINT0("--> %-6s #%-4u |%.3s|\n",cmd->name1,si.cur_file->line,si.cur_file->ptr); + + enumError err = ERR_OK; + switch (cmd->id) + { + case LID_IGNORE: + // ignore it without warning + break; + + case LID_SETUP: + // nothing to do at the moment + break; + + case LID_HEXDUMP: + err = ScanLEXElementHexdump(lex,&si); + break; + + case LID_SETTINGS1: + err = ScanLEXElement_SET1(lex,&si); + break; + + case LID_CANNON: + err = ScanLEXElement_CANN(lex,&si); + break; + + case LID_HIDE_PT: + err = ScanLEXElement_HIPT(lex,&si); + break; + + case LID_TEST: + err = ScanLEXElement_TEST(lex,&si); + break; + + default: + err = ERROR0(ERR_WARNING,"Unknown section (ignored): %s\n",sect_name); + break; + } + + if ( max_err < err ) + max_err = err; + } + + if (lex->is_pass2) + break; + + lex->is_pass2 = true; + RestartSI(&si); + } + + ResetSI(&si); + + UpdateLEX(lex,opt_complete,false); + return max_err; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// LEX: scan and load /////////////// +/////////////////////////////////////////////////////////////////////////////// + +enumError ScanLEX +( + lex_t * lex, // LEX data structure + bool init_lex, // true: initialize 'lex' first + const void * data, // data to scan + uint data_size // size of 'data' +) +{ + DASSERT(lex); + PRINT("ScanLEX() size=%u\n",data_size); + HEXDUMP16(0,0,data,16); + + enumError err; +// [[analyse-magic]] + switch (GetByMagicFF(data,data_size,data_size)) + { + case FF_LEX: + lex->fform = FF_LEX; + err = ScanRawLEX(lex,init_lex,data,data_size,0); + break; + + case FF_LEX_TXT: + lex->fform = FF_LEX_TXT; + err = ScanTextLEX(lex,init_lex,data,data_size); + break; + + default: + if (init_lex) + InitializeLEX(lex); + return ERROR0(ERR_INVALID_DATA, + "No LEX file: %s\n", lex->fname ? lex->fname : "?"); + } + + PatchLEX(lex,0); + return err; +} + +/////////////////////////////////////////////////////////////////////////////// + +enumError ScanRawDataLEX +( + lex_t * lex, // LEX data structure + bool init_lex, // true: initialize 'lex' first + struct raw_data_t * raw // valid raw data +) +{ + DASSERT(lex); + DASSERT(raw); + if (init_lex) + InitializeLEX(lex); + else + ResetLEX(lex); + + lex->fatt = raw->fatt; + lex->fname = raw->fname; + raw->fname = 0; + + return raw->is_0 ? ERR_OK : ScanLEX(lex,false,raw->data,raw->data_size); +} + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +enumError LoadLEX +( + lex_t * lex, // LEX data structure + bool init_lex, // true: initialize 'lex' first + ccp fname, // valid pointer to filenname + bool ignore_no_file // ignore if file does not exists + // and return warning ERR_NOT_EXISTS +) +{ + DASSERT(lex); + DASSERT(fname); + if (init_lex) + InitializeLEX(lex); + else + ResetLEX(lex); + + //--- load and scan data + + raw_data_t raw; + enumError err = LoadRawData(&raw,true,fname,0,ignore_no_file,0); + if (!err) + { + lex->fname = raw.fname; + raw.fname = 0; + err = ScanLEX(lex,false,raw.data,raw.data_size); + } + + ResetRawData(&raw); + return err; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// CreateRawLEX() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +enumError CreateRawLEX +( + lex_t * lex // pointer to valid LEX +) +{ + DASSERT(lex); + if (lex->raw_data) + FREE(lex->raw_data); + + uint total_size = sizeof(lex_header_t) + sizeof(lex_element_t); // final term! + + uint i; + for ( i = 0; i < lex->item_used; i++ ) + { + lex_item_t *s = lex->item[i]; + total_size += sizeof(lex_element_t) + ntohl(s->elem.size); + } + + lex->raw_data = MALLOC(total_size); + lex->raw_data_size = total_size; + + lex_header_t *hd = (lex_header_t*)lex->raw_data; + memcpy(hd->magic,LEX_BIN_MAGIC,sizeof(hd->magic)); + hd->major_version = htons(LEX_MAJOR_VERSION); + hd->minor_version = htons(LEX_MINOR_VERSION); + hd->size = htonl(total_size); + hd->element_off = htonl(sizeof(lex_header_t)); + + u8 *dest = lex->raw_data + sizeof(lex_header_t); + for ( i = 0; i < lex->item_used; i++ ) + { + lex_item_t *s = lex->item[i]; + const uint size = sizeof(lex_element_t) + ntohl(s->elem.size); + ASSERT ( dest + size < lex->raw_data + lex->raw_data_size ); + memcpy(dest,&s->elem,size); + dest += size; + } + ASSERT ( dest + sizeof(lex_element_t) == lex->raw_data + lex->raw_data_size ); + memset(dest,0,sizeof(lex_element_t)); + + return ERR_OK; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// SaveRawLEX() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +enumError SaveRawLEX +( + lex_t * lex, // pointer to valid LEX + ccp fname, // filename of destination + bool set_time // true: set time stamps +) +{ + DASSERT(lex); + DASSERT(fname); + PRINT("SaveRawLEX(%s,%d)\n",fname,set_time); + + //--- create raw data + + enumError err = CreateRawLEX(lex); + if (err) + return err; + DASSERT(lex->raw_data); + DASSERT(lex->raw_data_size); + + + //--- write to file + + File_t F; + err = CreateFileOpt(&F,true,fname,testmode,lex->fname); + if ( err > ERR_WARNING || !F.f ) + return err; + SetFileAttrib(&F.fatt,&lex->fatt,0); + + if ( fwrite(lex->raw_data,1,lex->raw_data_size,F.f) != lex->raw_data_size ) + FILEERROR1(&F,ERR_WRITE_FAILED,"Write failed: %s\n",fname); + return ResetFile(&F,set_time); +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// SaveTextLEX() /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static enumError SaveTextLEX_FEA0 +( + FILE * f, // file to write + const lex_t * lex, // pointer to valid LEX + lex_item_t * item // item to save +) +{ + DASSERT(f); + DASSERT(lex); + DASSERT(item); + + const uint size = ntohl(item->elem.size); + noPRINT("SaveTextLEX_SET1(), size=%u\n",size); + DASSERT( size >= sizeof(lex_set1_t) ); + if ( size < sizeof(features_szs_t)) + return ERR_OK; + + fprintf(f,text_lex_elem_feat_cr,item->sort_order); + const features_szs_t *fs = (features_szs_t*)item->elem.data; + + PrintScript_t ps; + InitializePrintScript(&ps); + ps.f = f; + ps.fform = PSFF_ASSIGN; + ps.force_case = LOUP_UPPER; + PrintFeaturesSZS(&ps,fs,true,1,0,0,0); + ResetPrintScript(&ps); + + uint data_size = ntohs(fs->size_be); + if ( data_size > size ) + data_size = size; + + if ( data_size > sizeof(features_szs_t) ) + { + u8 size = data_size - sizeof(features_szs_t); + u8 *ptr = item->elem.data + sizeof(features_szs_t); + if ( size >= 4 || !IsMemConst(ptr,size,0) ) + { + fputs("\n# Hex dump for unknown settings:\n",f); + HexDump(f,0,sizeof(features_szs_t),5,16,ptr,size); + } + } + + return ERR_OK; +} + +/////////////////////////////////////////////////////////////////////////////// + +static enumError SaveTextLEX_SET1 +( + FILE * f, // file to write + const lex_t * lex, // pointer to valid LEX + lex_item_t * item // item to save +) +{ + DASSERT(f); + DASSERT(lex); + DASSERT(item); + + const uint size = ntohl(item->elem.size); + noPRINT("SaveTextLEX_SET1(), size=%u\n",size); + DASSERT( size >= sizeof(lex_set1_t) ); + if ( size < sizeof(lex_set1_t)) + return ERR_OK; + + const u8 *data = item->elem.data; + const lex_set1_t *set1 = (lex_set1_t*)data; + + fprintf(f,text_lex_elem_set1_cr + ,item->sort_order + ,bef4(&set1->item_factor.x) + ,bef4(&set1->item_factor.y) + ,bef4(&set1->item_factor.z) + ); + + if (*(u32*)set1->test) + fprintf(f,text_lex_elem_set1_develop_cr + ,set1->test[0],set1->test[1],set1->test[2],set1->test[3] + ); + + if ( size > sizeof(lex_set1_t) ) + { + fputs("\n# Hex dump for unknown settings:\n",f); + HexDump(f,0,sizeof(lex_set1_t),5,16, + item->elem.data + sizeof(lex_set1_t), + size - sizeof(lex_set1_t) ); + } + + return ERR_OK; +} + +/////////////////////////////////////////////////////////////////////////////// + +static enumError SaveTextLEX_CANN +( + FILE * f, // file to write + const lex_t * lex, // pointer to valid LEX + lex_item_t * item // item to save +) +{ + DASSERT(f); + DASSERT(lex); + DASSERT(item); + + fprintf(f,text_lex_elem_cann_cr,item->sort_order); + if ( item->elem.size < 4 + 16 ) + return ERR_OK; + + const u8 *data = item->elem.data; + uint n = be32(data); + uint max = ( ntohl(item->elem.size) - 4 ) / 16; + if ( n > max ) + n = max; + + uint i, off = 4; + for ( i = 0; i < n; i++, off += 16 ) + fprintf(f,"%4u %10.3f %10.3f %10.3f %10.3f\r\n", + i, bef4(data+off), bef4(data+off+4), + bef4(data+off+8), bef4(data+off+12) ); + + return ERR_OK; +} + +/////////////////////////////////////////////////////////////////////////////// + +static enumError SaveTextLEX_HIPT +( + FILE * f, // file to write + const lex_t * lex, // pointer to valid LEX + lex_item_t * item // item to save +) +{ + DASSERT(f); + DASSERT(lex); + DASSERT(item); + + fprintf(f,text_lex_elem_hipt_cr,item->sort_order); + if ( item->elem.size < 4 + 16 ) + return ERR_OK; + + const lex_hipt_rule_t *rule = (lex_hipt_rule_t*)item->elem.data; + int n = ntohl(item->elem.size) / sizeof(*rule) ; + + int i, last_lap = 1000; + for ( i = 0; i < n; i++, rule++ ) + { + if ( last_lap != rule->lap ) + { + last_lap = rule->lap; + fputs("\r\n",f); + } + + fprintf(f,"%5u %4d %4u %4u %4u\r\n", + rule->cond, rule->lap, rule->from, rule->to, rule->mode ); + } + + return ERR_OK; +} + +/////////////////////////////////////////////////////////////////////////////// + +static enumError SaveTextLEX_TEST +( + FILE * f, // file to write + const lex_t * lex, // pointer to valid LEX + lex_item_t * item // item to save +) +{ + DASSERT(f); + DASSERT(lex); + DASSERT(item); + + const uint size = ntohl(item->elem.size); + PRINT("SaveTextLEX_TEST(), size=%u\n",size); + DASSERT( size >= sizeof(lex_test_t) ); + if ( size < sizeof(lex_test_t)) + return ERR_OK; + + const u8 *data = item->elem.data; + const lex_test_t *test = (lex_test_t*)data; + + const KeywordTab_t *off_on; + for ( off_on = lex_offline_online; off_on->name1; off_on++ ) + if ( off_on->id == test->offline_online && off_on->opt >= 0 ) + break; + + const KeywordTab_t *gmode; + for ( gmode = lex_game_mode; gmode->name1; gmode++ ) + if ( gmode->id == test->game_mode && gmode->opt >= 0 ) + break; + + const KeywordTab_t *engine; + for ( engine = lex_engine; engine->name1; engine++ ) + if ( engine->id == test->engine && engine->opt >= 0 ) + break; + + fprintf(f,text_lex_elem_test_cr + ,item->sort_order + ,off_on->name1 ? off_on->name1 : "AUTO" + ,test->n_offline + ,test->n_online + ,test->cond_bit + ,gmode->name1 ? gmode->name1 : "AUTO" + ,engine->name1 ? engine->name1 : "AUTO" + ,test->random + ); + + if ( size > sizeof(lex_test_t) ) + { + fputs("\n# Hex dump for unknown settings:\n",f); + HexDump(f,0,sizeof(lex_test_t),5,16, + item->elem.data + sizeof(lex_test_t), + size - sizeof(lex_test_t) ); + } + + return ERR_OK; +} + +/////////////////////////////////////////////////////////////////////////////// + +enumError SaveTextLEX +( + const lex_t * lex, // pointer to valid LEX + ccp fname, // filename of destination + bool set_time // true: set time stamps +) +{ + // use DOS/Windows line format -> unix can handle it ;) + + DASSERT(lex); + DASSERT(fname); + PRINT("SaveTextLEX(%s,%d)\n",fname,set_time); + + + //--- open file + + File_t F; + enumError err = CreateFileOpt(&F,true,fname,testmode,lex->fname); + if ( err > ERR_WARNING || !F.f ) + return err; + SetFileAttrib(&F.fatt,&lex->fatt,0); + + + //--- print header + syntax info + + if ( print_header && !brief_count && !export_count ) + fprintf(F.f,text_lex_head_cr); + else + fprintf(F.f, + "%s\r\n" + "# LEX syntax & semantics: https://szs.wiimm.de/info/lex-syntax.html\r\n" + ,LEX_TEXT_MAGIC); + + + //--- print info section & section counter alphabetically + + if ( brief_count || export_count ) + { + fprintf(F.f, + "%s[SETUP]\r\n\r\n" + "TOOL = %s\r\n" + "SYSTEM2 = %s\r\n" + "VERSION = %s\r\n" + "REVISION = %u\r\n" + "DATE = %s\r\n" + "\r\n", + section_sep, + tool_name, SYSTEM2, VERSION, REVISION_NUM, DATE ); + } + else + { + fprintf(F.f, text_lex_setup_cr, + tool_name, SYSTEM2, VERSION, REVISION_NUM, DATE ); + + uint i; + for ( i = 0; i < lex->item_used; i++ ) + { + lex_item_t *s = lex->item[i]; + const uint size = ntohl(s->elem.size); + fprintf(F.f,"# %-4.4s %08x, 0x%04x bytes\r\n", + PrintID(&s->elem.magic,4,0), s->elem.magic, size ); + } + } + + enumError max_err = ERR_OK; + + uint i; + for ( i = 0; i < lex->item_used; i++ ) + { + lex_item_t *s = lex->item[i]; + const uint size = ntohl(s->elem.size); + const u32 magic = ntohl(s->elem.magic); + enumError err = ERR_OK; + switch(magic) + { + case LEXS_FEA0: err = SaveTextLEX_FEA0(F.f,lex,s); break; + case LEXS_SET1: err = SaveTextLEX_SET1(F.f,lex,s); break; + case LEXS_CANN: err = SaveTextLEX_CANN(F.f,lex,s); break; + case LEXS_HIPT: err = SaveTextLEX_HIPT(F.f,lex,s); break; + case LEXS_TEST: err = SaveTextLEX_TEST(F.f,lex,s); break; + + default: + hexdump_eol = "\r\n"; + fprintf(F.f,text_lex_hexdump_cr, + s->sort_order, magic, PrintID(&s->elem.magic,4,0) ); + HexDump(F.f,0,0,5,16,s->elem.data,size); + break; + } + + if ( max_err < err ) + max_err = err; + } + + fputs(section_end,F.f); + ResetFile(&F,set_time); + return max_err; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// LEX options /////////////// +/////////////////////////////////////////////////////////////////////////////// + +bool opt_lex_features = false; +bool opt_lex_rm_features = false; +bool opt_lex_purge = false; +bool force_lex_test = false; +bool opt_lt_clear = false; +int opt_lt_online = -9; +int opt_lt_n_offline = -9; +int opt_lt_n_online = -9; +int opt_lt_cond_bit = -9; +int opt_lt_game_mode = -9; +int opt_lt_engine = -9; +int opt_lt_random = -9; + +//----------------------------------------------------------------------------- + +int ScanOptLtOnline ( ccp arg ) +{ + if ( !arg || !*arg ) + opt_lt_online = -9; + else + { + int abbrev; + const KeywordTab_t *key = ScanKeyword(&abbrev,arg,lex_offline_online); + if (!key) + { + PrintKeywordError(lex_offline_online,arg,abbrev,0, + "keyword for option --lt-online"); + return 1; + } + opt_lt_online = key->id; + } + return 0; +} + +//----------------------------------------------------------------------------- + +int ScanOptLtNPlayers ( ccp arg ) +{ + if ( !arg || !*arg ) + opt_lt_n_offline = opt_lt_n_online = -9; + else + { + ccp comma = strchr(arg,','); + if (comma) + { + opt_lt_n_offline = str2l(arg,0,10); + opt_lt_n_online = str2l(comma+1,0,10); + } + else + { + int n = str2l(arg,0,10); + if ( n > 4 ) + { + opt_lt_n_offline = -9; + opt_lt_n_online = n; + } + else + { + opt_lt_n_offline = n; + opt_lt_n_online = -9; + } + } + + if ( opt_lt_n_offline < 0 ) + opt_lt_n_offline = -9; + else if ( opt_lt_n_offline > 4 ) + opt_lt_n_offline = 4; + + if ( opt_lt_n_online < 0 ) + opt_lt_n_online = -9; + else if ( opt_lt_n_online > 99 ) + opt_lt_n_online = 99; + } + + return 0; +} + +//----------------------------------------------------------------------------- + +int ScanOptLtCondBit ( ccp arg ) +{ + if ( !arg || !*arg ) + opt_lt_cond_bit = -9; + else + { + int n = str2l(arg,0,10); + opt_lt_cond_bit = n < -1 || n >= 16 ? -9 : n; + } + return 0; +} + +//----------------------------------------------------------------------------- + +int ScanOptLtGameMode ( ccp arg ) +{ + if ( !arg || !*arg ) + opt_lt_game_mode = -1; + else + { + int abbrev; + const KeywordTab_t *key = ScanKeyword(&abbrev,arg,lex_game_mode); + if (!key) + { + PrintKeywordError(lex_game_mode,arg,abbrev,0, + "keyword for option --lt-game-mode"); + return 1; + } + opt_lt_game_mode = key->id; + } + return 0; +} + +//----------------------------------------------------------------------------- + +int ScanOptLtEngine ( ccp arg ) +{ + if ( !arg || !*arg ) + opt_lt_engine = -1; + else + { + int abbrev; + const KeywordTab_t *key = ScanKeyword(&abbrev,arg,lex_engine); + if (!key) + { + PrintKeywordError(lex_engine,arg,abbrev,0, + "keyword for option --lt-engine"); + return 1; + } + opt_lt_engine = key->id; + } + return 0; +} + +//----------------------------------------------------------------------------- + +int ScanOptLtRandom ( ccp arg ) +{ + if ( !arg || !*arg ) + opt_lt_random = -1; + else + { + int n = str2l(arg,0,10); + opt_lt_random = n < 0 || n > 6 ? -9 : n; + } + return 0; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// lex_info_t /////////////// +/////////////////////////////////////////////////////////////////////////////// + +void SetupLexInfo ( lex_info_t *info, const lex_t *lex ) +{ + DASSERT(info); + InitializeLexInfo(info); + + if (lex) + { + info->lex_found = true; + info->have_sect = lex->have_sect; + info->have_feat = lex->have_feat; + + lex_item_t *item; + item = FindElementLEX(lex,LEXS_SET1); + if (item) + { + info->set1_found = true; + memcpy(&info->set1,item->elem.data,sizeof(info->set1)); + bef4n(info->set1.item_factor.v,info->set1.item_factor.v,3); + } + + item = FindElementLEX(lex,LEXS_TEST); + if (item) + { + info->test_found = true; + memcpy(&info->test,item->elem.data,sizeof(info->test)); + } + } +} + +/////////////////////////////////////////////////////////////////////////////// + +enumError SetupLexInfoByData ( lex_info_t *info, cvp data, uint data_size ) +{ + lex_t lex; + const enumError err = ScanLEX(&lex,true,data,data_size); + if (!err) + SetupLexInfo(info,&lex); + else + InitializeLexInfo(info); + ResetLEX(&lex); + return err; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// LEX patching /////////////// +/////////////////////////////////////////////////////////////////////////////// + +// return TRUE if any option set +bool HavePatchTestLEX() +{ + return force_lex_test + || opt_lt_clear + || opt_lt_online >= 0 + || opt_lt_n_offline >= 0 + || opt_lt_n_online >= 0 + || opt_lt_game_mode >= 0 + || opt_lt_engine >= 0 + || opt_lt_random >= 0; +} + + +//----------------------------------------------------------------------------- + +// return TRUE if any option set and not default +bool HaveActivePatchTestLEX() +{ + return force_lex_test + || opt_lt_online > 0 + || opt_lt_n_offline > 0 + || opt_lt_n_online > 0 + || opt_lt_game_mode > LEX_GMODE_AUTO + || opt_lt_engine > LEX_ENGINE_AUTO + || opt_lt_random >= 0; +} + +//----------------------------------------------------------------------------- + +// return TRUE if modified / set optional 'empty' to true, if test section is empty +bool PatchTestLEX ( lex_test_t *lt, bool *empty ) +{ + DASSERT(lt); + PRINT0("--lt-*: clear=%d, online=%d, n=%d,%d, gm=%d, en=%d, rnd=%d\n", + opt_lt_clear, opt_lt_online, opt_lt_n_offline, opt_lt_n_online, + opt_lt_game_mode, opt_lt_engine, opt_lt_random ); + + lex_test_t temp; + memcpy( &temp, opt_lt_clear ? (lex_test_t*)&TestDataLEX : lt, sizeof(temp) ); + + if ( opt_lt_online >= LEX_OO_AUTO && opt_lt_online <= LEX_OO_ONLINE ) + temp.offline_online = opt_lt_online; + + if ( opt_lt_n_offline >= 0 ) + temp.n_offline = opt_lt_n_offline > 4 ? 4 : opt_lt_n_offline; + + if ( opt_lt_n_online >= 0 ) + temp.n_online = opt_lt_n_online > 99 ? 99 : opt_lt_n_online; + + if ( opt_lt_cond_bit >= -1 && opt_lt_cond_bit < 16 ) + temp.cond_bit = opt_lt_cond_bit; + + if ( opt_lt_game_mode >= 0 ) + temp.game_mode = opt_lt_game_mode; + + if ( opt_lt_engine >= 0 ) + temp.engine = opt_lt_engine; + + if ( opt_lt_random >= 0 ) + temp.random = opt_lt_random; + + if (empty) + *empty = !memcmp(&temp,&TestDataLEX,sizeof(temp)); + if (memcmp(lt,&temp,sizeof(*lt))) + { + memcpy(lt,&temp,sizeof(*lt)); + return true; + } + + return false; +} + +//----------------------------------------------------------------------------- +// return TRUE if modified / set optional 'empty' to true, if test section is empty + +bool PatchFeaturesLEX ( lex_t * lex, const szs_have_t *have, bool *empty ) +{ + DASSERT(lex); + DASSERT(have); + DASSERT(have->valid); + + features_szs_t fs; + SetupFeaturesSZS(&fs,have,true); + const bool need_features = GetFeaturesStatusSZS(&fs) > 1; + + lex_item_t *li = FindElementLEX(lex,LEXS_FEA0); + const bool have_features = li != 0; + + PRINT("--lex-features = %d, --lex-rm-features = %d : have=%d, need=%d\n", + opt_lex_features, opt_lex_rm_features, have_features, need_features ); + + bool modified = false; + if ( opt_lex_rm_features && RemoveElementByMagicLEX(lex,LEXS_FEAT) ) + modified = true; // FEA0 + + if ( have_features && !need_features ) + { + if (RemoveElementLEX(lex,li)) + modified = true; + } + else if ( opt_lex_features + && need_features + && ( !have_features || memcmp(&fs,li->elem.data,sizeof(fs)) )) + { + AppendFea0LEX(lex,true,&fs); + modified = true; + } + + ResetFeaturesSZS(&fs); + + if (empty) + *empty = !need_features; + if (modified) + lex->modified = true; + return modified; +} + +//----------------------------------------------------------------------------- + +bool PatchLEX ( lex_t * lex, const szs_have_t *have ) +{ + DASSERT(lex); + + bool modified = false; + + //--- section TEST + + if (HavePatchTestLEX()) + { + lex_item_t *li = FindElementLEX(lex,LEXS_TEST); + const bool had_test = li != 0; + if (!had_test) + { + if (!HaveActivePatchTestLEX()) + return 0; + li = AppendTestLEX(lex,false); + } + DASSERT(li); + lex_test_t orig; + memcpy(&orig,li->elem.data,sizeof(orig)); + + bool empty; + modified = PatchTestLEX((lex_test_t*)li->elem.data,&empty); + PRINT("PATCH+ LEX/TEST: had=%d, empty=%d, modified=%d => have_lex:%x,%x\n", + had_test, empty, modified, lex->have_sect, lex->have_feat ); + if ( empty && !force_lex_test ) + { + if ( RemoveElementLEX(lex,li) && had_test ) + modified = true; + } + else if (!had_test) + modified = true; + + PRINT("PATCH- LEX/TEST: had=%d, empty=%d, modified=%d => have_lex:%x,%x\n", + had_test, empty, modified, lex->have_sect, lex->have_feat ); + + } + + + //--- section FEA0 + + if ( HavePatchFeaturesLEX() && have && have->valid ) + { + szs_have_t temp = *have; + temp.lex_sect = lex->have_sect; + temp.lex_feat = lex->have_feat; + + if (PatchFeaturesLEX(lex,&temp,0)) + modified = true; + } + + + //--- terminate + + if (opt_lex_purge) + modified |= PurgeLEX(lex); + + if (modified) + lex->modified = true; + + return modified; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// LEX purging /////////////// +/////////////////////////////////////////////////////////////////////////////// + +bool PurgeLEX ( lex_t * lex ) +{ + DASSERT(lex); + + bool modified = false; + + uint i = 0; + while ( i < lex->item_used ) + { + lex_item_t **ss = lex->item+i; + const uint size = ntohl((*ss)->elem.size); + const u8 *data = (*ss)->elem.data; + + bool remove = false; + switch(ntohl((*ss)->elem.magic)) + { + case LEXS_FEA0: + remove = GetFeaturesStatusSZS((features_szs_t*)data) < 2; + break; + + case LEXS_SET1: + remove = !IsActiveLEXElement_SET1((lex_set1_t*)data); + break; + + case LEXS_CANN: + remove = size <= sizeof(CannonDataLEX) + && !memcmp(data,&CannonDataLEX,size); + break; + + case LEXS_HIPT: + remove = size < sizeof(lex_hipt_rule_t); + break; + + case LEXS_TEST: + remove = !IsActiveLEXElement_TEST((lex_test_t*)data); + break; + + default: + remove = true; + break; + } + + if (remove) + modified |= RemoveElementLEX(lex,*ss); + else + i++; + } + + if (modified) + UpdateHaveLex(lex); + + return modified; +} + +// +/////////////////////////////////////////////////////////////////////////////// +/////////////// END /////////////// +/////////////////////////////////////////////////////////////////////////////// + |