diff options
Diffstat (limited to 'project/src/lib-lex.c')
| -rw-r--r-- | project/src/lib-lex.c | 345 |
1 files changed, 295 insertions, 50 deletions
diff --git a/project/src/lib-lex.c b/project/src/lib-lex.c index 0a37bfe..a786477 100644 --- a/project/src/lib-lex.c +++ b/project/src/lib-lex.c @@ -161,7 +161,9 @@ static const feature_var_t lex_section_list[] = 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" ), + DEF_VAR( 0,HAVELEXS_RITP, lex_sect_ritp, "LEX section RITP" ), + // [[new-lex-sect]] {0,0,0,0,0} }; @@ -174,6 +176,10 @@ static const feature_var_t lex_feature_list[] = 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" ), DEF_VAR( 0,HAVELEXF_START_ITEM, lex_start_item, "LEX: Player can get item before start of race." ), + DEF_VAR( 0,HAVELEXF_APPLY_OTL, lex_apply_otl, "LEX: Track applies alternative online time limit." ), + DEF_VAR( 0,HAVELEXF_RND_ITPH, lex_rnd_itph, "LEX: Random next links @KMP:ITPH." ), + + // [[new-lex-sect]] {0,0,0,0,0} }; @@ -566,12 +572,17 @@ const features_szs_t * GetFeaturesModes() 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_sect_ritp = FZM_GAMEPLAY | FZM_M_TYPE | no_timetrial | FZM_SECTION; + + // [[new-lex-sect]] 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; m.lex_start_item = FZM_GAMEPLAY | FZM_M_TYPE | FZM_ONLINE; + m.lex_apply_otl = FZM_GAMEPLAY | FZM_M_TYPE | FZM_ONLINE; + m.lex_rnd_itph = FZM_GAMEPLAY | FZM_M_TYPE | no_timetrial; #if CHECK_FEATURES uint err_count = 0; @@ -797,6 +808,7 @@ lex_element_t * FindLexElement ( lex_header_t *head, uint data_size, u32 magic ) typedef void (*FixElementFunc) ( lex_t * lex, lex_item_t * item ); /////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// static void FixLEXElement_SET1 ( lex_set1_t *set1 ) { @@ -811,6 +823,12 @@ static void FixLEXElement_SET1 ( lex_set1_t *set1 ) } set1->start_item = set1->start_item > 0; + +// [[time-limit]] + set1->apply_online_sec = htons(MINMAX0( ntohs(set1->apply_online_sec), + LE_MIN_ONLINE_SEC, LE_MAX_ONLINE_SEC )); + + // [[new-lex-set1]] } //----------------------------------------------------------------------------- @@ -830,7 +848,6 @@ static void FixLEXItem_SET1 } //----------------------------------------------------------------------------- -// [[+]] static void ClearLEXElement_SET1 ( lex_set1_t *set1 ) { @@ -840,7 +857,6 @@ static void ClearLEXElement_SET1 ( lex_set1_t *set1 ) } //----------------------------------------------------------------------------- -// [[+]] static bool IsActiveLEXElement_SET1 ( const lex_set1_t *set1 ) { @@ -853,7 +869,11 @@ static bool IsActiveLEXElement_SET1 ( const lex_set1_t *set1 ) /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// -// [[+]] + +// [[new-lex-sect]] upto 4 functions, see SET1 above + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// static void FixLEXElement_TEST ( lex_test_t *lt ) { @@ -884,7 +904,6 @@ static void FixLEXElement_TEST ( lex_test_t *lt ) } //----------------------------------------------------------------------------- -// [[+]] static void FixLEXItem_TEST ( @@ -901,7 +920,6 @@ static void FixLEXItem_TEST } //----------------------------------------------------------------------------- -// [[+]] static void ClearLEXElement_TEST ( lex_test_t *lt ) { @@ -910,7 +928,6 @@ static void ClearLEXElement_TEST ( lex_test_t *lt ) } //----------------------------------------------------------------------------- -// [[+]] static bool IsActiveLEXElement_TEST ( const lex_test_t *lt ) { @@ -951,6 +968,7 @@ static uint GetLexSortOrder ( u32 magic ) case LEXS_FEAT: return 1; case LEXS_SET1: return 2; case LEXS_TEST: return 9; + // [[new-lex-sect]] default: return 5; } } @@ -975,7 +993,7 @@ static void UpdateHaveLex ( lex_t *lex ) && size >= have_lex_sect_info[j].min_size ) { have_sect |= 1 << j; - have_feat |= GetLexFeatures(&(*ss)->elem); + have_feat |= GetLexFeatures(&(*ss)->elem,lex); break; } } @@ -1050,6 +1068,8 @@ static lex_item_t * AppendElementLEX size4 = ALIGN32(sizeof(lex_set1_t),4); break; + // [[new-lex-sect]] + case LEXS_TEST: if ( size4 < sizeof(lex_test_t) ) size4 = ALIGN32(sizeof(lex_test_t),4); @@ -1155,8 +1175,10 @@ static void SortItemsLEX /////////////// LEX features /////////////// /////////////////////////////////////////////////////////////////////////////// -static uint GetLexFeaturesSET1 ( const lex_element_t *elem ) +static uint GetLexFeaturesSET1 ( const lex_element_t *elem, lex_t *lex ) { + // if 'lex' not NULL: store additional data + uint have_feat = 0; const uint size = ntohl(elem->size); const lex_set1_t *set1 = (lex_set1_t*)elem->data; @@ -1175,6 +1197,20 @@ static uint GetLexFeaturesSET1 ( const lex_element_t *elem ) if ( size > offsetof(lex_set1_t,start_item) && set1->start_item ) have_feat |= 1 << HAVELEXF_START_ITEM; +// [[time-limit]] + if ( size > offsetof(lex_set1_t,apply_online_sec) ) + { + const uint apply_otl = ntohs(set1->apply_online_sec); + if (apply_otl) + { + have_feat |= 1 << HAVELEXF_APPLY_OTL; + if (lex) + lex->apply_otl = apply_otl; + } + } + + // [[new-lex-set1]] + return have_feat; } @@ -1197,6 +1233,14 @@ static uint GetLexFeaturesHIPT ( const lex_element_t *elem ) //----------------------------------------------------------------------------- +static uint GetLexFeaturesRITP ( const lex_element_t *elem ) +{ + return ntohl(elem->size) >= sizeof(lex_ritp_rule_t) + ? 1 << HAVELEXF_RND_ITPH : 0; +} + +//----------------------------------------------------------------------------- + static uint GetLexFeaturesTEST ( const lex_element_t *elem ) { DASSERT(elem); @@ -1206,14 +1250,18 @@ static uint GetLexFeaturesTEST ( const lex_element_t *elem ) //----------------------------------------------------------------------------- -uint GetLexFeatures ( const lex_element_t *elem ) +uint GetLexFeatures ( const lex_element_t *elem, lex_t *lex ) { + // if 'lex' not NULL: store additional data + switch(ntohl(elem->magic)) { - case LEXS_SET1: return GetLexFeaturesSET1(elem); + case LEXS_SET1: return GetLexFeaturesSET1(elem,lex); case LEXS_CANN: return GetLexFeaturesCANN(elem); case LEXS_HIPT: return GetLexFeaturesHIPT(elem); + case LEXS_RITP: return GetLexFeaturesRITP(elem); case LEXS_TEST: return GetLexFeaturesTEST(elem); + // [[new-lex-sect]] } return 0; } @@ -1227,7 +1275,9 @@ const have_lex_info_t have_lex_feat_info[HAVELEXF__N] = { HAVELEXF_CANNON, "cannon", 0 }, { HAVELEXF_HIDE_POS, "hipt", 0 }, { HAVELEXF_START_ITEM, "startitem", 0 }, - //--- add new sections here (order is important) + { HAVELEXF_APPLY_OTL, "apply-otl", 0 }, + { HAVELEXF_RND_ITPH, "rnd-itph", 0 }, + //--- add new elements here (order is important) }; /////////////////////////////////////////////////////////////////////////////// @@ -1266,7 +1316,9 @@ const have_lex_info_t have_lex_sect_info[HAVELEXS__N] = { LEXS_TEST, "test", 1 }, // HAVELEXS_TEST { LEXS_HIPT, "hidepos", sizeof(lex_hipt_rule_t) }, // HAVELEXS_HIPT { LEXS_FEAT, "features", 2 }, // HAVELEXS_FEAT + { LEXS_RITP, "rnditph", sizeof(lex_ritp_rule_t) }, // HAVELEXS_RITP //--- add new sections here (order is important) + // [[new-lex-sect]] }; /////////////////////////////////////////////////////////////////////////////// @@ -1349,6 +1401,9 @@ void UpdateLEX ( lex_t * lex, bool add_missing, bool add_test ) //--- HIPT AppendHiptLEX(lex,false); + + //--- RITP + AppendRitpLEX(lex,false); } if (add_test) //--- TEST @@ -1387,14 +1442,21 @@ lex_item_t * AppendSet1LEX ( lex_t * lex, bool overwrite ) lex_item_t * AppendCannLEX ( lex_t * lex, bool overwrite ) { return AppendElementLEX( lex, LEXS_CANN, CannonDataLEX, - sizeof(CannonDataLEX), overwrite); + sizeof(CannonDataLEX), overwrite ); } //----------------------------------------------------------------------------- lex_item_t * AppendHiptLEX ( lex_t * lex, bool overwrite ) { - return AppendElementLEX( lex, LEXS_HIPT, 0, 0, overwrite); + return AppendElementLEX( lex, LEXS_HIPT, 0, 0, overwrite ); +} + +//----------------------------------------------------------------------------- + +lex_item_t * AppendRitpLEX ( lex_t * lex, bool overwrite ) +{ + return AppendElementLEX( lex, LEXS_RITP, 0, 0, overwrite ); } //----------------------------------------------------------------------------- @@ -1402,9 +1464,11 @@ lex_item_t * AppendHiptLEX ( lex_t * lex, bool overwrite ) lex_item_t * AppendTestLEX ( lex_t * lex, bool overwrite ) { return AppendElementLEX( lex, LEXS_TEST, TestDataLEX, - sizeof(TestDataLEX), overwrite); + sizeof(TestDataLEX), overwrite ); } +// [[new-lex-sect]] + /////////////////////////////////////////////////////////////////////////////// void DumpElementsLEX ( FILE *f, lex_t *lex, bool hexdump ) @@ -1604,7 +1668,10 @@ typedef enum lex_section_id LID_SETTINGS1, LID_CANNON, LID_HIDE_PT, + LID_RND_ITPH, LID_TEST, + + // [[new-lex-sect]] } lex_section_id; @@ -1623,8 +1690,10 @@ static const KeywordTab_t lex_section_name[] = { LID_SETTINGS1, "SET1", "Basic settings", 0 }, { LID_CANNON, "CANN", "Cannon settings", 0 }, { LID_HIDE_PT, "HIPT", "Hide position tracker", 0 }, + { LID_RND_ITPH, "RITP", "Random next-links @KMP:ITPH", 0 }, { LID_TEST, "TEST", "Test case", 0 }, + // [[new-lex-sect]] { 0,0,0,0 } }; @@ -1743,15 +1812,10 @@ static enumError ScanLEXElement_SET1 { { "ITEM-POS-FACTOR", SPM_FLOAT3_BE, &set1.item_factor }, { "START-ITEM", SPM_U8, &set1.start_item }, - - // renamed at 2021-05-12 - { "TEST1", SPM_U8, &set1.start_item }, // [[obsolete]] 2022 - { "TEST2", SPM_U8, &set1.test_0d }, // [[obsolete]] 2022 - { "TEST_0D", SPM_U8, &set1.test_0d }, - { "TEST3", SPM_U8, &set1.test_0e }, // [[obsolete]] 2022 - { "TEST_0E", SPM_U8, &set1.test_0e }, - { "TEST4", SPM_U8, &set1.test_0f }, // [[obsolete]] 2022 - { "TEST_0F", SPM_U8, &set1.test_0f }, + { "PADDING-0D", SPM_U8, &set1.padding_0d }, +// [[time-limit]] + { "APPLY-ONLINE-SEC", SPM_U16_BE, &set1.apply_online_sec }, + // [[new-lex-set1]] {0} }; @@ -1903,6 +1967,60 @@ static enumError ScanLEXElement_HIPT /////////////////////////////////////////////////////////////////////////////// +static enumError ScanLEXElement_RITP +( + 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_ritp_rule_t)] = {0}; + ScanU8SI(si,num,sizeof(num)-1,false); + if (NextCharSI(si,false)) + ScanU8SI(si,num+sizeof(num)-1,1,false); + AppendFastBuf(fb,num,sizeof(num)); + CheckEolSI(si); + } + + AppendElementLEX(lex,LEXS_RITP,fb->buf,fb->ptr-fb->buf,true); + ResetFastBuf(fb); + + return ERR_OK; +} + +/////////////////////////////////////////////////////////////////////////////// +// [[new-lex-sect]] +/////////////////////////////////////////////////////////////////////////////// + static enumError ScanLEXElement_TEST ( lex_t * lex, // KMP data structure @@ -2045,11 +2163,17 @@ enumError ScanTextLEX err = ScanLEXElement_HIPT(lex,&si); break; + case LID_RND_ITPH: + err = ScanLEXElement_RITP(lex,&si); + break; + + // [[new-lex-sect]] + case LID_TEST: err = ScanLEXElement_TEST(lex,&si); break; - default: + default: err = ERROR0(ERR_WARNING,"Unknown section (ignored): %s\n",sect_name); break; } @@ -2273,7 +2397,7 @@ static enumError SaveTextLEX_FEAT DASSERT(item); const uint size = ntohl(item->elem.size); - noPRINT("SaveTextLEX_SET1(), size=%u\n",size); + noPRINT("SaveTextLEX_FEAT(), size=%u\n",size); DASSERT( size >= sizeof(lex_set1_t) ); if ( size < sizeof(features_szs_t)) return ERR_OK; @@ -2288,7 +2412,7 @@ static enumError SaveTextLEX_FEAT ps.force_case = LOUP_UPPER; int comments = -1; - if (!brief_count) + if ( !brief_count && !export_count ) { comments = 1; ps.ena_empty = true; @@ -2308,7 +2432,7 @@ static enumError SaveTextLEX_FEAT 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); + fputs("\r\n# Hex dump for unknown settings:\r\n",f); HexDump(f,0,sizeof(features_szs_t),5,16,ptr,size); } } @@ -2338,23 +2462,44 @@ static enumError SaveTextLEX_SET1 const u8 *data = item->elem.data; const lex_set1_t *set1 = (lex_set1_t*)data; - fprintf(f,text_lex_elem_set1_cr +// [[time-limit]] + const unsigned apply_online_sec = ntohs(set1->apply_online_sec); + if ( brief_count || export_count ) + fprintf(f, + "%s[SET1]\r\n\r\n" + "@ITEM-POS-FACTOR = v( %5.3f, %5.3f, %5.3f )\r\n" + "@START-ITEM = %u\r\n" + "@APPLY-ONLINE-SEC = %u%s\r\n" + "\r\n" + ,section_sep + ,bef4(&set1->item_factor.x) + ,bef4(&set1->item_factor.y) + ,bef4(&set1->item_factor.z) + ,set1->start_item + ,apply_online_sec ,PrintHMS(0,0,apply_online_sec,LE_VIEW_ONLINE_HMS," # ",0) + // [[new-lex-set1]] + ); + else + 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) ,set1->start_item + ,LE_MIN_ONLINE_SEC ,PrintHMS(0,0,LE_MIN_ONLINE_SEC,LE_VIEW_ONLINE_HMS," (",")") + ,LE_MAX_ONLINE_SEC ,PrintHMS(0,0,LE_MAX_ONLINE_SEC,LE_VIEW_ONLINE_HMS," (",")") + ,apply_online_sec ,PrintHMS(0,0,apply_online_sec,LE_VIEW_ONLINE_HMS," # ",0) + // [[new-lex-set1]] ); - if ( set1->test_0d || set1->test_0e || set1->test_0f ) + if ( set1->padding_0d ) fprintf(f,text_lex_elem_set1_develop_cr - ,set1->test_0d - ,set1->test_0e - ,set1->test_0f + ,set1->padding_0d ); + if ( size > sizeof(lex_set1_t) ) { - fputs("\n# Hex dump for unknown settings:\n",f); + fputs("\r\n# Hex dump for unknown settings:\r\n",f); HexDump(f,0,sizeof(lex_set1_t),5,16, item->elem.data + sizeof(lex_set1_t), size - sizeof(lex_set1_t) ); @@ -2415,8 +2560,8 @@ static enumError SaveTextLEX_HIPT 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++ ) + int last_lap = 1000; + for ( int i = 0; i < n; i++, rule++ ) { if ( last_lap != rule->lap ) { @@ -2424,7 +2569,7 @@ static enumError SaveTextLEX_HIPT fputs("\r\n",f); } - fprintf(f,"%5u %4d %4u %4u %4u\r\n", + fprintf(f,"%6u %5d %4u %4u %4u\r\n", rule->cond, rule->lap, rule->from, rule->to, rule->mode ); } @@ -2433,6 +2578,73 @@ static enumError SaveTextLEX_HIPT /////////////////////////////////////////////////////////////////////////////// +static enumError SaveTextLEX_RITP +( + 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); + + if ( brief_count || export_count ) + fprintf(f,"%s[RITP]\r\n\r\n",section_sep); + else + fprintf(f,text_lex_elem_ritp_cr,item->sort_order); + + const lex_ritp_rule_t *rule = (lex_ritp_rule_t*)item->elem.data; + int n = ntohl(item->elem.size) / sizeof(*rule) ; + if ( n <= 0 ) + return ERR_OK; + + fputs(text_lex_elem_ritp_tabhead_cr,f); + + + struct mode_t + { + u8 print_param; // 0:never, 1:if not null, 2:always + char name[7]; + }; + + static const struct mode_t mode_tab[] = + { + { 1, "OFF" }, + { 0, "START" }, + // [[new-ritp-mode]] + }; + _Static_assert( sizeof(mode_tab)/sizeof(*mode_tab) == RITP_MODE__N, "RITP_MODE__N" ); + + for ( int i = 0; i < n; i++, rule++ ) + { + bool print_param; + char name[20]; + if ( rule->mode < RITP_MODE__N ) + { + const struct mode_t *md = mode_tab + rule->mode; + print_param = md->print_param; + snprintf(name,sizeof(name),"RITP$%s",md->name); + } + else + { + print_param = 2; + snprintf(name,sizeof(name),"%4u",rule->mode); + } + + if ( print_param >= 2 || print_param == 1 && rule->param ) + fprintf(f,"%6u %3u %-9s %6u\r\n", + rule->index, rule->n_next, name, rule->param ); + else + fprintf(f,"%6u %3u %s\r\n", + rule->index, rule->n_next, name ); + } + + return ERR_OK; +} + +/////////////////////////////////////////////////////////////////////////////// + static enumError SaveTextLEX_TEST ( FILE * f, // file to write @@ -2481,7 +2693,7 @@ static enumError SaveTextLEX_TEST if ( size > sizeof(lex_test_t) ) { - fputs("\n# Hex dump for unknown settings:\n",f); + fputs("\r\n# Hex dump for unknown settings:\r\n",f); HexDump(f,0,sizeof(lex_test_t),5,16, item->elem.data + sizeof(lex_test_t), size - sizeof(lex_test_t) ); @@ -2492,6 +2704,33 @@ static enumError SaveTextLEX_TEST /////////////////////////////////////////////////////////////////////////////// +static enumError SaveTextLEX_HEXDUMP +( + 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 bool brief = brief_count || export_count; + const u32 magic = ntohl(item->elem.magic); + if (brief) + fprintf(f,"%s[HEXDUMP]\r\n@MAGIC = 0x%08x\r\n\r\n",section_sep,magic); + else + fprintf(f,text_lex_hexdump_cr, + item->sort_order, magic, PrintID(&item->elem.magic,4,0) ); + + HexDumpCRLF(f,0,0,5,16,item->elem.data,ntohl(item->elem.size)); + if (!brief) + fputs(text_lex_hexdump_sep_cr,f); + return ERR_OK; +} + +/////////////////////////////////////////////////////////////////////////////// + enumError SaveTextLEX ( const lex_t * lex, // pointer to valid LEX @@ -2533,7 +2772,7 @@ enumError SaveTextLEX fprintf(F.f, "%s[SETUP]\r\n\r\n" "TOOL = %s\r\n" - "SYSTEM2 = %s\r\n" + "SYSTEM = %s\r\n" "VERSION = %s\r\n" "REVISION = %u\r\n" "DATE = %s\r\n" @@ -2550,7 +2789,7 @@ enumError SaveTextLEX for ( i = 0; i < lex->item_used; i++ ) { lex_item_t *s = lex->item[i]; - const uint size = ntohl(s->elem.size); + const uint size = ntohl(s->elem.size) + 8; fprintf(F.f,"# %-4.4s %08x, 0x%04x bytes\r\n", PrintID(&s->elem.magic,4,0), s->elem.magic, size ); } @@ -2562,7 +2801,6 @@ enumError SaveTextLEX 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) @@ -2571,14 +2809,11 @@ enumError SaveTextLEX 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_RITP: err = SaveTextLEX_RITP(F.f,lex,s); break; case LEXS_TEST: err = SaveTextLEX_TEST(F.f,lex,s); break; + // [[new-lex-sect]] - 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; + default: err = SaveTextLEX_HEXDUMP(F.f,lex,s); break; } if ( max_err < err ) @@ -2765,7 +3000,7 @@ void SetupLexInfo ( lex_info_t *info, const lex_t *lex ) if (lex) { - info->lex_found = true; + info->lex_found = true; info->have_sect = lex->have_sect; info->have_feat = lex->have_feat; @@ -2774,9 +3009,10 @@ void SetupLexInfo ( lex_info_t *info, const lex_t *lex ) 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); - memcpy(&info->item_factor,&info->set1.item_factor,sizeof(info->item_factor)); + memcpy( &info->set1, item->elem.data, sizeof(info->set1) ); + // copy from info to info is correct, because of memcpy() above + bef4n( info->set1.item_factor.v, info->set1.item_factor.v, 3 ); + memcpy( &info->item_factor, &info->set1.item_factor, sizeof(info->item_factor) ); } item = FindElementLEX(lex,LEXS_TEST); @@ -2785,6 +3021,8 @@ void SetupLexInfo ( lex_info_t *info, const lex_t *lex ) info->test_found = true; memcpy(&info->test,item->elem.data,sizeof(info->test)); } + + // [[new-lex-sect]] } } @@ -2966,6 +3204,7 @@ bool PatchLEX ( lex_t * lex, const szs_have_t *have ) } + // [[new-lex-sect]] //--- section FEAT @@ -3029,6 +3268,12 @@ bool PurgeLEX ( lex_t * lex ) remove = size < sizeof(lex_hipt_rule_t); break; + case LEXS_RITP: + remove = size < sizeof(lex_ritp_rule_t); + break; + + // [[new-lex-sect]] + case LEXS_TEST: remove = !IsActiveLEXElement_TEST((lex_test_t*)data); break; |