diff options
Diffstat (limited to 'project/src/lib-lecode.c')
| -rw-r--r-- | project/src/lib-lecode.c | 996 |
1 files changed, 768 insertions, 228 deletions
diff --git a/project/src/lib-lecode.c b/project/src/lib-lecode.c index 0222315..05d3c00 100644 --- a/project/src/lib-lecode.c +++ b/project/src/lib-lecode.c @@ -61,11 +61,8 @@ OffOn_t opt_200cc = OFFON_AUTO; OffOn_t opt_perfmon = OFFON_AUTO; OffOn_t opt_custom_tt = OFFON_AUTO; OffOn_t opt_xpflags = OFFON_AUTO; -OffOn_t opt_speedo = OFFON_AUTO; - -int opt_reserved_1b9 = -1; -int opt_reserved_1ba = -1; -int opt_reserved_1bb = -1; +int opt_speedo = OFFON_AUTO; +int opt_lecode_debug = OFFON_AUTO; bool opt_complete = false; @@ -154,11 +151,39 @@ int ScanOptXPFlags ( ccp arg ) } /////////////////////////////////////////////////////////////////////////////// +// [[speedo_mode_t]] [[copy-lecode]] copy changes to LE-CODE + +typedef enum speedo_mode_t +{ + SPEEDO_OFF = 0, + SPEEDO_ON, + SPEEDO_FRACTION1, + SPEEDO_FRACTION2, + SPEEDO_FRACTION3, + SPEEDO_MAX = SPEEDO_FRACTION3, // max allowed value +} +speedo_mode_t; + +//----------------------------------------------------------------------------- int ScanOptSpeedometer ( ccp arg ) { + const KeywordTab_t keytab[] = + { + { OFFON_OFF, "OFF", "-1", 0 }, + { OFFON_AUTO, "AUTO", 0, 0 }, + { SPEEDO_ON, "ON", 0, 0 }, + { SPEEDO_ON, "FORCE", 0, 0 }, // legacy, [[obsolete]], remove in 2022 + { SPEEDO_ON, "0DIGITS", "0", 0 }, + { SPEEDO_FRACTION1,"FRACTION", 0, 0 }, + { SPEEDO_FRACTION1,"1DIGITS", "1", 0 }, + { SPEEDO_FRACTION2,"2DIGITS", "2", 0 }, + { SPEEDO_FRACTION3,"3DIGITS", "3", 0 }, + { 0,0,0,0 } + }; + const int stat - = ScanKeywordOffAutoOn(arg,OFFON_ON,OFFON_ON,"Option --speedo"); + = ScanKeywordOffAutoOnEx(keytab,arg,OFFON_ON,0,"Option --speedo"); if ( stat == OFFON_ERROR ) return 1; @@ -167,28 +192,94 @@ int ScanOptSpeedometer ( ccp arg ) return 0; } +//----------------------------------------------------------------------------- + +ccp GetLecodeSpeedoName ( speedo_mode_t mode ) +{ + switch (mode) + { + case SPEEDO_OFF: break; + case SPEEDO_ON: return "0"; + case SPEEDO_FRACTION1: return "1"; + case SPEEDO_FRACTION2: return "2"; + case SPEEDO_FRACTION3: return "3"; + // no default! => compiler warnings for missed values + } + return "OFF"; +} + /////////////////////////////////////////////////////////////////////////////// -int ScanOptReserved_1b9 ( ccp arg ) +ccp GetLecodeDebugName ( le_debug_mode_t mode ) { - opt_reserved_1b9 = str2l(arg,0,10); - PRINT("RESERVED_1B9=%d\n",opt_reserved_1b9); - return 0; + switch (mode) + { + case DEBUGMD_OFF: + case DEBUGMD__N: break; + case DEBUGMD_ENABLED: return "ENABLED"; + case DEBUGMD_DEBUG1: + case DEBUGMD_DEBUG2: + case DEBUGMD_DEBUG3: + case DEBUGMD_DEBUG4: return PrintCircBuf("%u",mode-DEBUGMD_DEBUG1+1); + // no default! => compiler warnings for missed values + } + return "OFF"; } -int ScanOptReserved_1ba ( ccp arg ) +//----------------------------------------------------------------------------- + +ccp GetLecodeDebugInfo ( le_debug_mode_t mode ) { - opt_reserved_1ba = str2l(arg,0,10); - PRINT("RESERVED_1BA=%d\n",opt_reserved_1ba); + switch (mode) + { + case DEBUGMD_OFF: return "disabled"; + case DEBUGMD_ENABLED: return "enabled but hidden"; + case DEBUGMD_DEBUG1: + case DEBUGMD_DEBUG2: + case DEBUGMD_DEBUG3: + case DEBUGMD_DEBUG4: return PrintCircBuf("view DEBUG-%u",mode-DEBUGMD_DEBUG1+1); + case DEBUGMD__N: break; + // no default! => compiler warnings for missed values + } + return "?"; +} + +//----------------------------------------------------------------------------- + +int ScanOptDebug ( ccp arg ) +{ + const KeywordTab_t keytab[] = + { + { OFFON_OFF, "OFF", "-1", 0 }, + { OFFON_AUTO, "AUTO", "0", 0 }, + { DEBUGMD_ENABLED,"USER", "1", 0 }, + { DEBUGMD_DEBUG1, "DEBUG1", "D1", 0 }, + { DEBUGMD_DEBUG2, "DEBUG2", "D2", 0 }, + { DEBUGMD_DEBUG3, "DEBUG3", "D3", 0 }, + { DEBUGMD_DEBUG4, "DEBUG4", "D4", 0 }, + { 0,0,0,0 } + }; + + const int stat + = ScanKeywordOffAutoOnEx(keytab,arg,OFFON_ON,DEBUGMD__N-1,"Option --debug"); + if ( stat == OFFON_ERROR ) + return 1; + + opt_lecode_debug = stat; + PRINT("LE-DEBUG=%d (%s)\n",opt_lecode_debug,GetLecodeDebugInfo(opt_lecode_debug)); return 0; } +/////////////////////////////////////////////////////////////////////////////// + +#if 0 int ScanOptReserved_1bb ( ccp arg ) { opt_reserved_1bb = str2l(arg,0,10); - PRINT("RESERVED_1BB=%d\n",opt_reserved_1b9); + PRINT("RESERVED_1BB=%d\n",opt_reserved_1bb); return 0; } +#endif /////////////////////////////////////////////////////////////////////////////// @@ -287,12 +378,273 @@ const VarMap_t * SetupVarsLECODE() { static VarMap_t vm = {0}; if (!vm.used) + { DefineMkwVars(&vm); + //DefineParserFuncTab(lex_func_tab,FF_LPAR); + DefineParserVars(&vm); + + //--- setup integer variables + + struct inttab_t { ccp name; int val; }; + static const struct inttab_t inttab[] = + { + { "DEBUG$OFF", PREDEBUG_OFF }, + { "DEBUG$CLEAR", PREDEBUG_CLEAR }, + { "DEBUG$STANDARD", PREDEBUG_STANDARD }, + { "DEBUG$OPPONENT", PREDEBUG_OPPONENT }, + { "DEBUG$VERTICAL", PREDEBUG_VERTICAL }, + + { "DEBUG$ENABLED", DEBUGMD_ENABLED }, + { "DEBUG$0", DEBUGMD_ENABLED }, + { "DEBUG$1", DEBUGMD_DEBUG1 }, + { "DEBUG$2", DEBUGMD_DEBUG2 }, + { "DEBUG$3", DEBUGMD_DEBUG3 }, + { "DEBUG$4", DEBUGMD_DEBUG4 }, + + { "SPEEDO$OFF", SPEEDO_OFF }, + { "SPEEDO$0", SPEEDO_ON }, + { "SPEEDO$1", SPEEDO_FRACTION1 }, + { "SPEEDO$2", SPEEDO_FRACTION2 }, + { "SPEEDO$3", SPEEDO_FRACTION3 }, + + {0,0} + }; + + const struct inttab_t * ip; + for ( ip = inttab; ip->name; ip++ ) + DefineIntVar(&vm,ip->name,ip->val); + } return &vm; } // /////////////////////////////////////////////////////////////////////////////// +/////////////// LE-CODE Debug /////////////// +/////////////////////////////////////////////////////////////////////////////// + +ccp GetDebugModeSummary ( const lecode_debug_info_t *ldi ) +{ + DASSERT(ldi); + return PrintCircBuf("I=%d,%d, M:%02x,%02x, %s=%u", + ldi->index, ldi->filter_active, ldi->mode, ldi->relevant, + ldi->name ? ldi->name : "-", ldi->value ); +} + +/////////////////////////////////////////////////////////////////////////////// + +bool GetFirstDebugMode + ( lecode_debug_info_t *ldi, lecode_debug_t mode, bool filter_active ) +{ + DASSERT(ldi); + memset(ldi,0,sizeof(*ldi)); + ldi->mode = mode & LEDEB__ALL; + ldi->filter_active = filter_active; + + return GetNextDebugMode(ldi); +} + +/////////////////////////////////////////////////////////////////////////////// + +bool GetNextDebugMode ( lecode_debug_info_t *ldi ) +{ + struct tab_t + { + lecode_debug_t mode; + int shift; + const char name[12]; + }; + + static const struct tab_t tab[] = + { + { LEDEB_ENABLED, 0, "ENABLED" }, + { LEDEB_OPPONENT, 0, "OPPONENT" }, + { LEDEB_SPACE, 0, "SPACE" }, + { LEDEB_POSITION, 0, "POSITION" }, + { LEDEB_CHECK_POINT, LEDEB_S_CHECK_POINT, "CHECK-POINT" }, + { LEDEB_RESPAWN, 0, "RESPAWN" }, + { LEDEB_LAP_POS, 0, "LAP-POS" }, + }; + + while ( ldi->index >= 0 && ldi->index < sizeof(tab)/sizeof(*tab) ) + { + const struct tab_t *ptr = tab + ldi->index++; + if ( ldi->filter_active && !(ptr->mode&ldi->mode) ) + continue; + + ldi->relevant = ptr->mode; + ldi->name = ptr->name; + ldi->value = ldi->mode & ptr->mode; + if (ptr->shift) + ldi->value >>= ptr->shift; + else + ldi->value = ldi->value != 0; + return true; + } + + ldi->index = -1; + ldi->relevant = 0; + ldi->name = 0; + ldi->value = 0; + return false; +} + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +lecode_debug_t DecodeLecodeDebug ( lecode_debug_ex_t *lde, lecode_debug_t mode ) +{ + DASSERT(lde); + memset(lde,0,sizeof(*lde)); + + mode &= LEDEB__ALL; + lde->mode = mode; + lde->enabled = ( mode & LEDEB_ENABLED ) > 0; + lde->opponent = ( mode & LEDEB_OPPONENT ) > 0; + lde->space = ( mode & LEDEB_SPACE ) > 0; + lde->position = ( mode & LEDEB_POSITION ) > 0; + lde->check_point = mode >> LEDEB_S_CHECK_POINT & LEDEB_M_CHECK_POINT; + lde->respawn = ( mode & LEDEB_RESPAWN ) > 0; + lde->lap_pos = ( mode & LEDEB_LAP_POS ) > 0; + + lde->have_output = isDebugModeOutput(mode); + lde->is_active = isDebugModeActive(mode); + + return mode; +} + +/////////////////////////////////////////////////////////////////////////////// + +lecode_debug_t EncodeLecodeDebug ( lecode_debug_ex_t *lde ) +{ + DASSERT(lde); + + lecode_debug_t mode = ( lde->check_point & LEDEB_M_CHECK_POINT ) << LEDEB_S_CHECK_POINT; + if ( lde->enabled ) mode |= LEDEB_ENABLED; + if ( lde->opponent ) mode |= LEDEB_OPPONENT; + if ( lde->space ) mode |= LEDEB_SPACE; + if ( lde->position ) mode |= LEDEB_POSITION; + if ( lde->respawn ) mode |= LEDEB_RESPAWN; + if ( lde->lap_pos ) mode |= LEDEB_LAP_POS; + + return DecodeLecodeDebug(lde,mode); // normalize all settings +} + +/////////////////////////////////////////////////////////////////////////////// + +ccp GetPredefDebugName ( predef_debug_t pd_mode ) +{ + switch ( pd_mode ) + { + case PREDEBUG_OFF: break; + case PREDEBUG_CLEAR: return "CLEAR"; + case PREDEBUG_STANDARD: return "STANDARD"; + case PREDEBUG_OPPONENT: return "OPPONENT"; + case PREDEBUG_VERTICAL: return "VERTICAL"; + // no default! => compiler warnings for missed values + } + return "OFF"; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool SetupLecodeDebugLPAR +( + le_lpar_t *lpar, // LE-CODE parameters + uint config, // configuration index 0.. + uint setup_mode, // setup mode, one of PREDEBUG_* + int *hide_speedo // if not NULL: store new mode here +) +{ + DASSERT(lpar); + DASSERT( config >= 0 && config < DEBUGMD__N-DEBUGMD_DEBUG1 ); + + + //--- setup data table + + struct setup_t + { + u16 predef; + s16 line; + u32 mode; + }; + + static const struct setup_t setup_tab[] = + { + { PREDEBUG_CLEAR, 0, 0 }, + + { PREDEBUG_STANDARD, 1, LEDEB__STD }, + + { PREDEBUG_OPPONENT, 1, LEDEB__STD }, + { PREDEBUG_OPPONENT, 2, LEDEB__STD|LEDEB_OPPONENT }, + + { PREDEBUG_VERTICAL,-1, 0 }, // hide speedo + { PREDEBUG_VERTICAL, 1, LEDEB_CHECK_POINT }, + { PREDEBUG_VERTICAL, 2, LEDEB_RESPAWN }, + { PREDEBUG_VERTICAL, 3, LEDEB_LAP_POS }, + { PREDEBUG_VERTICAL, 4, LEDEB_POSITION }, + + {0,0,0} + }; + + const struct setup_t *ptr; + for ( ptr = setup_tab; ptr->predef; ptr++ ) + { + if ( ptr->predef == setup_mode ) + { + lpar->debug_predef[config] = setup_mode; + int my_hide_speedo = 0; + + u32 *debug_list = lpar->debug[config]; + for ( int line = 0; line < LEDEB__N_LINE; line++ ) + debug_list[line] = LEDEB_ENABLED; + + for ( ; ptr->predef == setup_mode; ptr++ ) + { + if ( ptr->line < 0 ) + my_hide_speedo++; + else + debug_list[ptr->line] = ptr->mode | LEDEB_ENABLED; + } + + if (hide_speedo) + *hide_speedo = my_hide_speedo; + + const u8 hide_mask = 1 << config; + if ( my_hide_speedo > 0 ) + lpar->no_speedo_if_debug |= hide_mask; + else + lpar->no_speedo_if_debug &= ~hide_mask; + + return true; + } + } + return false; +} + +/////////////////////////////////////////////////////////////////////////////// + +bool SetupLecodeDebugIfEmptyLPAR ( le_lpar_t *lpar ) +{ + DASSERT(lpar); + + for ( int config = 0; config < LEDEB__N_CONFIG; config++ ) + for ( int line = 0; line < LEDEB__N_LINE; line++ ) + if ( isDebugModeOutput(lpar->debug[config][line]) ) + return false; + + for ( int config = 0; config < LEDEB__N_CONFIG; config++ ) + for ( int line = 0; line < LEDEB__N_LINE; line++ ) + lpar->debug[config][line] = LEDEB_ENABLED; + + SetupLecodeDebugLPAR(lpar,0,PREDEBUG_STANDARD,0); + SetupLecodeDebugLPAR(lpar,1,PREDEBUG_OPPONENT,0); + SetupLecodeDebugLPAR(lpar,2,PREDEBUG_VERTICAL,0); + + return true; +} + +// +/////////////////////////////////////////////////////////////////////////////// /////////////// LPAR support /////////////// /////////////////////////////////////////////////////////////////////////////// @@ -306,11 +658,13 @@ lpar_mode_t CalcCurrentLparMode ( const le_lpar_t * lp, bool use_limit_param ) return temp > lp->limit_mode ? temp : lp->limit_mode; } - if ( lp->enable_perfmon > 1 || lp->enable_speedo > 1 ) + if ( lp->enable_perfmon > 1 ) return LPM_EXPERIMENTAL; - return lp->enable_perfmon || !lp->enable_xpflags - ? LPM_TESTING : LPM_PRODUCTIVE; + return lp->enable_perfmon + || !lp->enable_xpflags + || lp->enable_speedo > SPEEDO_FRACTION1 + ? LPM_TESTING : LPM_PRODUCTIVE; } //----------------------------------------------------------------------------- @@ -343,15 +697,13 @@ bool LimitToLparMode ( le_lpar_t * lp, lpar_mode_t lpmode ) { lp->enable_perfmon = 0; modified = true; } if (!lp->enable_xpflags) { lp->enable_xpflags = 1; modified = true; } - if ( lp->enable_speedo > 1 ) - { lp->enable_speedo = 1; modified = true; } + if ( lp->enable_speedo > SPEEDO_MAX ) + { lp->enable_speedo = SPEEDO_MAX; modified = true; } } else if ( lpmode == LPM_TESTING ) { if ( lp->enable_perfmon > 1 ) { lp->enable_perfmon = 1; modified = true; } - if ( lp->enable_speedo > 1 ) - { lp->enable_speedo = 1; modified = true; } } return modified; @@ -546,6 +898,8 @@ static void NormalizeLPAR ( le_lpar_t * lp ) { DASSERT(lp); + SetupLecodeDebugIfEmptyLPAR(lp); + int sum = lp->engine[0] + lp->engine[1] + lp->engine[2]; if ( sum != 0 && sum != 100 ) { @@ -562,9 +916,13 @@ static void NormalizeLPAR ( le_lpar_t * lp ) lp->enable_perfmon = lp->enable_perfmon < 2 ? lp->enable_perfmon : 2; lp->enable_custom_tt = lp->enable_custom_tt > 0; lp->enable_xpflags = lp->enable_xpflags > 0; - lp->enable_speedo = lp->enable_speedo < 2 ? lp->enable_speedo : 2; + lp->enable_speedo = lp->enable_speedo < SPEEDO_MAX ? lp->enable_speedo : SPEEDO_MAX; lp->block_track = lp->block_track < LE_MAX_BLOCK_TRACK ? lp->block_track : LE_MAX_BLOCK_TRACK; + + for ( int c = 0; c < LEDEB__N_CONFIG; c++ ) + for ( int l = 0; l < LEDEB__N_LINE; l++ ) + lp->debug[c][l] &= LEDEB__ALL; } /////////////////////////////////////////////////////////////////////////////// @@ -595,6 +953,21 @@ static void CopyLPAR2Data ( le_analyse_t * ana ) if ( offsetof(le_binpar_v1_t,enable_speedo) < ana->param_size ) h->enable_speedo = lp->enable_speedo; + if ( offsetof(le_binpar_v1_t,enable_speedo) < ana->param_size ) + h->no_speedo_if_debug = lp->no_speedo_if_debug; + + if ( offsetof(le_binpar_v1_t,debug_mode) < ana->param_size ) + h->debug_mode = lp->debug_mode; + + if ( offsetof(le_binpar_v1_t,item_cheat) < ana->param_size ) + h->item_cheat = lp->item_cheat; + + if ( offsetof(le_binpar_v1_t,debug_predef[LEDEB__N_CONFIG]) <= ana->param_size ) + memcpy( h->debug_predef,lp->debug_predef,sizeof(h->debug_predef)); + + if ( offsetof(le_binpar_v1_t,debug[LEDEB__N_CONFIG][0]) <= ana->param_size ) + write_be32n( h->debug[0], lp->debug[0], LEDEB__N_CONFIG*LEDEB__N_LINE ); + if ( offsetof(le_binpar_v1_t,block_track) < ana->param_size ) h->block_track = lp->block_track; @@ -603,15 +976,6 @@ static void CopyLPAR2Data ( le_analyse_t * ana ) if ( offsetof(le_binpar_v1_t,chat_mode_2) + sizeof(h->chat_mode_2) <= ana->param_size ) write_be16n(h->chat_mode_2,lp->chat_mode_2,BMG_N_CHAT); - - // reserved (for future extensions) - - if ( offsetof(le_binpar_v1_t,reserved_1b9) < ana->param_size ) - h->reserved_1b9 = lp->reserved_1b9; - if ( offsetof(le_binpar_v1_t,reserved_1ba) < ana->param_size ) - h->reserved_1ba = lp->reserved_1ba; - if ( offsetof(le_binpar_v1_t,reserved_1bb) < ana->param_size ) - h->reserved_1bb = lp->reserved_1bb; } // @@ -620,7 +984,7 @@ static void CopyLPAR2Data ( le_analyse_t * ana ) enumError SaveTextLPAR ( - const le_lpar_t *lpar, // LE-CODE parameters + le_lpar_t *lpar, // LE-CODE parameters ccp fname, // filename of destination bool set_time // true: set time stamps ) @@ -648,6 +1012,7 @@ enumError SaveTextLPAR //--- print section + SetupLecodeDebugIfEmptyLPAR(lpar); err = WriteSectionLPAR(F.f,lpar); @@ -703,9 +1068,6 @@ enumError WriteSectionLPAR fprintf(f,"\r\n#\f\r\n%.79s\r\n\r\n[LECODE-PARAMETERS]\r\n",Hash200); const bool verbose = print_header && !brief_count && !export_count; - const bool have_reserved = lpar->reserved_1b9 - || lpar->reserved_1ba - || lpar->reserved_1bb; if (verbose) { @@ -716,13 +1078,11 @@ enumError WriteSectionLPAR ,lpar->enable_perfmon ,lpar->enable_custom_tt ,lpar->enable_xpflags - ,lpar->enable_speedo - ,LE_MAX_BLOCK_TRACK - ,lpar->block_track + ,LE_MAX_BLOCK_TRACK,lpar->block_track + ,GetLecodeSpeedoName(lpar->enable_speedo) + ,GetLecodeDebugName(lpar->debug_mode) + ,lpar->item_cheat ); - - if (have_reserved) - fputs(text_lpar_sect_reserved_cr,f); } else { @@ -734,25 +1094,23 @@ enumError WriteSectionLPAR "PERF-MONITOR = %u\r\n" "CUSTOM-TT = %u\r\n" "XPFLAGS = %u\r\n" - "SPEEDOMETER = %u\r\n" "BLOCK-TRACK = %u\r\n" + "SPEEDOMETER = SPEEDO$%s\r\n" + "DEBUG = DEBUG$%s\r\n" + "ITEM-CHEATS = %u\r\n" ,GetLparModeName(CalcCurrentLparMode(lpar,true),export_count>0) ,lpar->engine[0],lpar->engine[1],lpar->engine[2] ,lpar->enable_200cc ,lpar->enable_perfmon ,lpar->enable_custom_tt ,lpar->enable_xpflags - ,lpar->enable_speedo ,lpar->block_track + ,GetLecodeSpeedoName(lpar->enable_speedo) + ,GetLecodeDebugName(lpar->debug_mode) + ,lpar->item_cheat ); - - if (have_reserved) - fputs("\r\n",f); } - if ( lpar->reserved_1b9 > 0 ) fprintf(f,"RESERVED-1B9\t= %u\r\n",lpar->reserved_1b9); - if ( lpar->reserved_1ba > 0 ) fprintf(f,"RESERVED-1BA\t= %u\r\n",lpar->reserved_1ba); - if ( lpar->reserved_1bb > 0 ) fprintf(f,"RESERVED-1BB\t= %u\r\n",lpar->reserved_1bb); //--- chat modes @@ -770,8 +1128,8 @@ enumError WriteSectionLPAR fputs(text_lpar_sect_chat_example_cr,f); } - int i, last_group = -1; - for ( i = 0; i < BMG_N_CHAT; i++ ) + int last_group = -1; + for ( int i = 0; i < BMG_N_CHAT; i++ ) { const u16 mode1 = lpar->chat_mode_1[i]; const u16 mode2 = lpar->chat_mode_2[i]; @@ -786,6 +1144,65 @@ enumError WriteSectionLPAR fprintf(f,"%s\n",PrintChatMode(i,mode1,mode2,export_count)); } } + + + //--- debug modes + + if (verbose) + fprintf(f,text_lpar_sect_debug_docu_cr, + LEDEB__N_LINE, LEDEB__N_LINE-1, LEDEB__N_LINE-1 ); + + for ( int conf = 0; conf < LEDEB__N_CONFIG; conf++ ) + { + fprintf(f,"\r\n#\f\r\n%.79s\r\n\r\n[DEBUG-%u]\r\n",Hash200,conf+1); + if (verbose) + fputs("# See section [DEBUG-DOCU] for details.\n",f); + + fprintf(f,"\r\n" + "SETUP\t\t= DEBUG$%s\n" + "HIDE-SPEEDO\t= %u\n", + GetPredefDebugName(lpar->debug_predef[conf]), + ( 1<<conf & lpar->no_speedo_if_debug ) != 0 ); + + int done = 0; + for ( int line = 0; line <= LEDEB__N_LINE; line++ ) + { + int idx; + lecode_debug_t mode; + + if ( line < LEDEB__N_LINE ) + { + mode = lpar->debug[conf][line]; + if (!isDebugModeOutput(mode)) + continue; + idx = line; + } + else + { + if (done) + break; + mode = 0; + idx = 1; + } + done++; + + bool line_printed = false; + lecode_debug_info_t ldi; + for ( GetFirstDebugMode(&ldi,mode,!verbose); ldi.name; GetNextDebugMode(&ldi) ) + { + if (!line_printed) + { + fprintf(f,"\nLINE\t\t= %u\r\n",idx); + line_printed = true; + } + fprintf(f,"%s%.*s= %u\r\n", + ldi.name, + (23-(int)strlen(ldi.name))/8, Tabs20, + ldi.value ); + } + } + } + return ERR_OK; } @@ -983,13 +1400,21 @@ enumError AnalyseLEBinary le_binpar_v1_1b8_t *p = (le_binpar_v1_1b8_t*)(data+off_param); be16n(ana->lpar.chat_mode_2,p->chat_mode_2,BMG_N_CHAT); } + if ( param_size >= sizeof(le_binpar_v1_1bc_t) ) { le_binpar_v1_1bc_t *p = (le_binpar_v1_1bc_t*)(data+off_param); ana->lpar.enable_speedo = p->enable_speedo; - ana->lpar.reserved_1b9 = p->reserved_1b9; - ana->lpar.reserved_1ba = p->reserved_1ba; - ana->lpar.reserved_1bb = p->reserved_1bb; + ana->lpar.no_speedo_if_debug= p->no_speedo_if_debug; + ana->lpar.debug_mode = p->debug_mode; + } + + if ( param_size >= sizeof(le_binpar_v1_260_t) ) + { + le_binpar_v1_260_t *p = (le_binpar_v1_260_t*)(data+off_param); + memcpy(ana->lpar.debug_predef,p->debug_predef,sizeof(ana->lpar.debug_predef)); + be32n(ana->lpar.debug[0],p->debug[0],LEDEB__N_CONFIG*LEDEB__N_LINE); + ana->lpar.item_cheat = p->item_cheat; } break; @@ -1834,23 +2259,42 @@ void DumpLEAnalyse ( FILE *f, uint indent, const le_analyse_t *ana ) if ( ana->param_size >= sizeof(le_binpar_v1_1bc_t) ) { + ccp comment; + char buf[50]; + if ( h->enable_speedo < SPEEDO_ON ) + comment = " = disabled"; + else if ( h->enable_speedo <= SPEEDO_MAX ) + { + snprintf(buf,sizeof(buf)," = format \"%.*f km/h\"", + h->enable_speedo - SPEEDO_ON, 123.12345 ); + comment = buf; + } + else + comment = ""; + fprintf(f, - "%*s" "Speedometer: %u = %s\n" - ,indent,"", h->enable_speedo, - h->enable_speedo > 1 ? "Wii(U)+Dolphin" - : h->enable_speedo ? "Wii(U) only" :"disabled" + "%*s" "Speedometer: %u%s\n", + indent,"", h->enable_speedo, comment ); + } + + if ( ana->param_size >= sizeof(le_binpar_v1_260_t) ) + { + fprintf(f, + "%*s" "Debug mode: %u = %s\n" + "%*s" "Item cheat: %u = %s\n" + ,indent,"", h->debug_mode, GetLecodeDebugInfo(h->debug_mode) + ,indent,"", h->item_cheat, h->item_cheat ? "enabled" : "disabled" ); + } - if (h->reserved_1b9) - fprintf(f,"%*s" "Reserved 1B9: %u\n", - indent,"", h->reserved_1b9 ); - if (h->reserved_1ba) - fprintf(f,"%*s" "Reserved 1BA: %u\n", - indent,"", h->reserved_1ba ); + #if 0 // for later use + if ( ana->param_size >= sizeof(le_binpar_v1_1bc_t) ) + { if (h->reserved_1bb) fprintf(f,"%*s" "Reserved 1BB: %u\n", indent,"", h->reserved_1bb ); } + #endif #if defined(DEBUG) && defined(TEST) && 0 const uint po = ana->param_offset; @@ -1870,7 +2314,6 @@ void DumpLEAnalyse ( FILE *f, uint indent, const le_analyse_t *ana ) ); #endif - const bool hard_coded = ana->param_size < sizeof(le_binpar_v1_f8_t); const u16 *chat_mode_1 = hard_coded ? chat_mode_legacy : ana->lpar.chat_mode_1; const u16 *chat_mode_2 = hard_coded ? chat_mode_legacy : ana->lpar.chat_mode_2; @@ -2328,11 +2771,11 @@ void PatchLPAR ( le_lpar_t * lp ) if ( opt_xpflags != OFFON_AUTO ) lp->enable_xpflags = opt_xpflags >= OFFON_ON; if ( opt_speedo != OFFON_AUTO ) - lp->enable_speedo = opt_speedo >= OFFON_FORCE ? 2 : opt_speedo >= OFFON_ON; - - if ( opt_reserved_1b9 >= 0 ) lp->reserved_1b9 = opt_reserved_1b9; - if ( opt_reserved_1ba >= 0 ) lp->reserved_1ba = opt_reserved_1ba; - if ( opt_reserved_1bb >= 0 ) lp->reserved_1bb = opt_reserved_1bb; + lp->enable_speedo = opt_speedo >= SPEEDO_MAX ? SPEEDO_MAX + : opt_speedo >= SPEEDO_ON ? opt_speedo : 0; + if ( opt_lecode_debug != OFFON_AUTO ) + lp->debug_mode = opt_lecode_debug >= DEBUGMD_ENABLED && opt_lecode_debug < DEBUGMD__N + ? opt_lecode_debug : DEBUGMD_OFF; } /////////////////////////////////////////////////////////////////////////////// @@ -2340,7 +2783,7 @@ void PatchLPAR ( le_lpar_t * lp ) void PatchLECODE ( le_analyse_t * ana ) { DASSERT(ana); - PRINT("PatchLECODE() opt_lpar=%s)\n",opt_lpar); + PRINT("PatchLECODE() opt_lpar=%s\n",opt_lpar); if (opt_lpar) LoadLPAR(&ana->lpar,false,0,false); @@ -2359,6 +2802,246 @@ void PatchLECODE ( le_analyse_t * ana ) // /////////////////////////////////////////////////////////////////////////////// +/////////////// ScanTextLPAR() helpers /////////////// +/////////////////////////////////////////////////////////////////////////////// + +static enumError ScanTextLPAR_PARAM +( + le_lpar_t *lpar, // LE-CODE parameters + ScanInfo_t *si, // valid data + bool is_pass2 // false: pass1; true: pass2 +) +{ + DASSERT(lpar); + DASSERT(si); + PRINT(">> ScanTextLPAR_PARAM(pass=%u)\n",is_pass2+1); + + + //--- setup data + + int limit_mode = -1; + const ScanParam_t ptab[] = + { + { "LIMIT-MODE", SPM_INT, &limit_mode }, + { "ENGINE", SPM_U8, lpar->engine, 3,3 }, + { "ENABLE-200CC", SPM_U8, &lpar->enable_200cc }, + { "PERF-MONITOR", SPM_U8, &lpar->enable_perfmon }, + { "CUSTOM-TT", SPM_S8, &lpar->enable_custom_tt }, + { "XPFLAGS", SPM_U8, &lpar->enable_xpflags }, + { "BLOCK-TRACK", SPM_U8, &lpar->block_track }, + { "SPEEDOMETER", SPM_U8, &lpar->enable_speedo }, + { "DEBUG", SPM_U8, &lpar->debug_mode }, + { "ITEM-CHEAT", SPM_U8, &lpar->item_cheat }, + {0} + }; + + + //--- main loop + + for(;;) + { + char ch = NextCharSI(si,true); + if ( !ch || ch == '[' ) + break; + + ScanParamSI(si,ptab); + } + CheckLevelSI(si); + + if ( limit_mode >= 0 ) + LimitToLparMode(lpar,limit_mode); + + return ERR_OK; +} + +/////////////////////////////////////////////////////////////////////////////// + +static enumError ScanTextLPAR_CHAT +( + le_lpar_t *lpar, // LE-CODE parameters + ScanInfo_t * si, // valid data + bool is_pass2 // false: pass1; true: pass2 +) +{ + PRINT(">> ScanTextLPAR_CHAT(pass=%u)\n",is_pass2+1); + // [[2do]] ??? + + + //--- setup data + + bool reset = true, legacy = false, mkwfun = false; + const ScanParam_t ptab[] = + { + { "RESET", SPM_BOOL, &reset }, + { "LEGACY", SPM_BOOL, &legacy }, + { "MKW-FUN", SPM_BOOL, &mkwfun }, + {0} + }; + + + //--- main loop + + for(;;) + { + char ch = NextCharSI(si,true); + if ( !ch || ch == '[' ) + break; + + if ( ch == '@' ) + { + ScanParamSI(si,ptab); + if (reset) + { + reset = false; + ClearLparChat(lpar); + } + + if ( legacy || mkwfun ) + { + const u16 *chat_mode = legacy ? chat_mode_legacy : chat_mode_mkwfun; + uint i; + for ( i = 0; i < BMG_N_CHAT; i++ ) + if (!lpar->chat_mode_1[i]) + lpar->chat_mode_1[i] = chat_mode[i]; + legacy = mkwfun = false; + } + continue; + } + + if (reset) + { + reset = false; + ClearLparChat(lpar); + } + + char name[20]; + ScanNameSI(si,name,sizeof(name),true,true,0); + if ( name[0] != 'M' ) + { + wrong_name:; + ScanFile_t *sf = si->cur_file; + sf->ptr = sf->prev_ptr; + WarnIgnoreSI(si,"Message name (M01..M96) expected: %s\n",name); + continue; + } + + char *end; + long num = strtol(name+1,&end,10); + if ( *end || num < 1 || num > BMG_N_CHAT ) + goto wrong_name; + + CheckWarnSI(si,'=',ERR_OK); + + DEFINE_VAR(var); + if (ScanExprSI(si,&var)) + continue; + lpar->chat_mode_1[num-1] = GetIntV(&var); + + if ( NextCharSI(si,false) == ',' ) + { + si->cur_file->ptr++; + if (!ScanExprSI(si,&var)) + lpar->chat_mode_2[num-1] = GetIntV(&var); + } + + FreeV(&var); + CheckEolSI(si); + } + CheckLevelSI(si); + + if (reset) + ClearLparChat(lpar); + + //HEXDUMP16(0,0,fb->buf,fb->ptr-fb->buf); + return ERR_OK; +} + +/////////////////////////////////////////////////////////////////////////////// + +static enumError ScanTextLPAR_DEBUG +( + le_lpar_t *lpar, // LE-CODE parameters + ScanInfo_t *si, // valid data + bool is_pass2, // false: pass1; true: pass2 + uint config // configuration index 0.. +) +{ + DASSERT(lpar); + DASSERT(si); + DASSERT( config < LEDEB__N_CONFIG ); + PRINT(">> ScanTextLPAR_PARAM(pass=%u)\n",is_pass2+1); + u32 *debug_list = lpar->debug[config]; + + + //--- setup data + + const int hide_mask = 1 << config; + int hide_speedo = hide_mask & lpar->no_speedo_if_debug; + int line = -1, next_line = -1, setup = PREDEBUG_OFF; + lecode_debug_ex_t debug; + DecodeLecodeDebug(&debug,0); + + const ScanParam_t ptab[] = + { + { "SETUP", SPM_INT, &setup }, + { "HIDE-SPEEDO", SPM_INT, &hide_speedo }, + { "LINE", SPM_INT, &next_line }, + { "ENABLED", SPM_U8, &debug.enabled }, + { "OPPONENT", SPM_U8, &debug.opponent }, + { "SPACE", SPM_U8, &debug.space }, + { "POSITION", SPM_U8, &debug.position }, + { "CHECK-POINT", SPM_U8, &debug.check_point }, + { "RESPAWN", SPM_U8, &debug.respawn }, + { "LAP-POS", SPM_U8, &debug.lap_pos }, + {0} + }; + + + //--- main loop + + for(;;) + { + char ch = NextCharSI(si,true); + if ( !ch || ch == '[' ) + break; + + ScanParamSI(si,ptab); + + if ( setup != PREDEBUG_OFF ) + { + if ( SetupLecodeDebugLPAR(lpar,config,setup,&hide_speedo) && line >= 0 ) + DecodeLecodeDebug(&debug,debug_list[line]); + setup = PREDEBUG_OFF; + } + + if ( line != next_line ) + { + if ( line >= 0 ) + debug_list[line] = EncodeLecodeDebug(&debug); + + if ( next_line < 0 || next_line >= LEDEB__N_LINE ) + next_line = -1; + else + DecodeLecodeDebug(&debug,debug_list[next_line]); + line = next_line; + } + } + + if ( line >= 0 ) + debug_list[line] = EncodeLecodeDebug(&debug); + + if ( hide_speedo > 0 ) + lpar->no_speedo_if_debug |= hide_mask; + else + lpar->no_speedo_if_debug &= ~hide_mask; + + CheckLevelSI(si); + + return ERR_OK; +} + +// +/////////////////////////////////////////////////////////////////////////////// /////////////// ScanTextLPAR() /////////////// /////////////////////////////////////////////////////////////////////////////// @@ -2420,18 +3103,23 @@ enumError ScanTextLPAR if (init_lpar) InitializeLPAR(lpar,false); - enum { C_PARAM, C_CHAT, C_END }; + enum { C_PARAM, C_CHAT, C_DEBUG1, C_DEBUG2, C_DEBUG3, C_DEBUG4, C_END }; static const KeywordTab_t section_name[] = { { C_PARAM, "LECODE-PARAMETERS", 0, 0 }, { C_CHAT, "CHAT-MESSAGE-MODES", 0, 0 }, + { C_END, "DEBUG-DOCU", 0, 0 }, + { C_DEBUG1, "DEBUG-1", 0, 0 }, + { C_DEBUG2, "DEBUG-2", 0, 0 }, + { C_DEBUG3, "DEBUG-3", 0, 0 }, + { C_DEBUG4, "DEBUG-4", 0, 0 }, { C_END, "END", 0, 0 }, {0,0,0,0} }; ScanInfo_t si; InitializeSI(&si,data,data_size,fname,0); - si.predef = SetupVarsLEX(); + si.predef = SetupVarsLECODE(); bool is_pass2 = false; enumError max_err = ERR_OK; @@ -2481,6 +3169,13 @@ enumError ScanTextLPAR err = ScanTextLPAR_CHAT(lpar,&si,is_pass2); break; + case C_DEBUG1: + case C_DEBUG2: + case C_DEBUG3: + case C_DEBUG4: + err = ScanTextLPAR_DEBUG(lpar,&si,is_pass2,cmd->id-C_DEBUG1); + break; + default: // ignore all other section without any warnings break; @@ -2511,161 +3206,6 @@ enumError ScanTextLPAR return max_err; } -/////////////////////////////////////////////////////////////////////////////// - -enumError ScanTextLPAR_PARAM -( - le_lpar_t *lpar, // LE-CODE parameters - ScanInfo_t *si, // valid data - bool is_pass2 // false: pass1; true: pass2 -) -{ - DASSERT(lpar); - DASSERT(si); - PRINT(">> ScanTextLPAR_PARAM(pass=%u)\n",is_pass2+1); - - - //--- setup data - - int limit_mode = -1; - const ScanParam_t ptab[] = - { - { "LIMIT-MODE", SPM_INT, &limit_mode }, - { "ENGINE", SPM_U8, lpar->engine, 3,3 }, - { "ENABLE-200CC", SPM_U8, &lpar->enable_200cc }, - { "PERF-MONITOR", SPM_U8, &lpar->enable_perfmon }, - { "CUSTOM-TT", SPM_S8, &lpar->enable_custom_tt }, - { "XPFLAGS", SPM_U8, &lpar->enable_xpflags }, - { "SPEEDOMETER", SPM_U8, &lpar->enable_speedo }, - { "BLOCK-TRACK", SPM_U8, &lpar->block_track }, - - { "RESERVED-1B9", SPM_U8, &lpar->reserved_1b9 }, - { "RESERVED-1BA", SPM_U8, &lpar->reserved_1ba }, - { "RESERVED-1BB", SPM_U8, &lpar->reserved_1bb }, - {0} - }; - - - //--- main loop - - for(;;) - { - char ch = NextCharSI(si,true); - if ( !ch || ch == '[' ) - break; - - ScanParamSI(si,ptab); - } - CheckLevelSI(si); - - if ( limit_mode >= 0 ) - LimitToLparMode(lpar,limit_mode); - - return ERR_OK; -} - -/////////////////////////////////////////////////////////////////////////////// - -enumError ScanTextLPAR_CHAT -( - le_lpar_t *lpar, // LE-CODE parameters - ScanInfo_t * si, // valid data - bool is_pass2 // false: pass1; true: pass2 -) -{ - PRINT(">> ScanTextLPAR_CHAT(pass=%u)\n",is_pass2+1); - // [[2do]] ??? - - - //--- setup data - - bool reset = true, legacy = false, mkwfun = false; - const ScanParam_t ptab[] = - { - { "RESET", SPM_BOOL, &reset }, - { "LEGACY", SPM_BOOL, &legacy }, - { "MKW-FUN", SPM_BOOL, &mkwfun }, - {0} - }; - - - //--- main loop - - for(;;) - { - char ch = NextCharSI(si,true); - if ( !ch || ch == '[' ) - break; - - if ( ch == '@' ) - { - ScanParamSI(si,ptab); - if (reset) - { - reset = false; - ClearLparChat(lpar); - } - - if ( legacy || mkwfun ) - { - const u16 *chat_mode = legacy ? chat_mode_legacy : chat_mode_mkwfun; - uint i; - for ( i = 0; i < BMG_N_CHAT; i++ ) - if (!lpar->chat_mode_1[i]) - lpar->chat_mode_1[i] = chat_mode[i]; - legacy = mkwfun = false; - } - continue; - } - - if (reset) - { - reset = false; - ClearLparChat(lpar); - } - - char name[20]; - ScanNameSI(si,name,sizeof(name),true,true,0); - if ( name[0] != 'M' ) - { - wrong_name:; - ScanFile_t *sf = si->cur_file; - sf->ptr = sf->prev_ptr; - WarnIgnoreSI(si,"Message name (M01..M96) expected: %s\n",name); - continue; - } - - char *end; - long num = strtol(name+1,&end,10); - if ( *end || num < 1 || num > BMG_N_CHAT ) - goto wrong_name; - - CheckWarnSI(si,'=',ERR_OK); - - DEFINE_VAR(var); - if (ScanExprSI(si,&var)) - continue; - lpar->chat_mode_1[num-1] = GetIntV(&var); - - if ( NextCharSI(si,false) == ',' ) - { - si->cur_file->ptr++; - if (!ScanExprSI(si,&var)) - lpar->chat_mode_2[num-1] = GetIntV(&var); - } - - FreeV(&var); - CheckEolSI(si); - } - CheckLevelSI(si); - - if (reset) - ClearLparChat(lpar); - - //HEXDUMP16(0,0,fb->buf,fb->ptr-fb->buf); - return ERR_OK; -} - // /////////////////////////////////////////////////////////////////////////////// /////////////// END /////////////// |