@@ -391,6 +391,7 @@ std::optional<NodeInfo> ConsumeNodeStable(MsCtx script_ctx, FuzzedDataProvider&
391391 bool allow_K = (type_needed == " " " K"
392392 bool allow_V = (type_needed == " " " V"
393393 bool allow_W = (type_needed == " " " W"
394+ static constexpr auto B{" B" " K" " V" " W"
394395
395396 switch (provider.ConsumeIntegral <uint8_t >()) {
396397 case 0 :
@@ -440,22 +441,22 @@ std::optional<NodeInfo> ConsumeNodeStable(MsCtx script_ctx, FuzzedDataProvider&
440441 }
441442 case 11 :
442443 if (!(allow_B || allow_K || allow_V)) return {};
443- return {{{" B " _mst , type_needed, type_needed}, Fragment::ANDOR}};
444+ return {{{B , type_needed, type_needed}, Fragment::ANDOR}};
444445 case 12 :
445446 if (!(allow_B || allow_K || allow_V)) return {};
446- return {{{" V " _mst , type_needed}, Fragment::AND_V}};
447+ return {{{V , type_needed}, Fragment::AND_V}};
447448 case 13 :
448449 if (!allow_B) return {};
449- return {{{" B " _mst, " W " _mst }, Fragment::AND_B}};
450+ return {{{B, W }, Fragment::AND_B}};
450451 case 15 :
451452 if (!allow_B) return {};
452- return {{{" B " _mst, " W " _mst }, Fragment::OR_B}};
453+ return {{{B, W }, Fragment::OR_B}};
453454 case 16 :
454455 if (!allow_V) return {};
455- return {{{" B " _mst, " V " _mst }, Fragment::OR_C}};
456+ return {{{B, V }, Fragment::OR_C}};
456457 case 17 :
457458 if (!allow_B) return {};
458- return {{{" B " _mst, " B " _mst }, Fragment::OR_D}};
459+ return {{{B, B }, Fragment::OR_D}};
459460 case 18 :
460461 if (!(allow_B || allow_K || allow_V)) return {};
461462 return {{{type_needed, type_needed}, Fragment::OR_I}};
@@ -472,25 +473,25 @@ std::optional<NodeInfo> ConsumeNodeStable(MsCtx script_ctx, FuzzedDataProvider&
472473 }
473474 case 20 :
474475 if (!allow_W) return {};
475- return {{{" B " _mst }, Fragment::WRAP_A}};
476+ return {{{B }, Fragment::WRAP_A}};
476477 case 21 :
477478 if (!allow_W) return {};
478- return {{{" B " _mst }, Fragment::WRAP_S}};
479+ return {{{B }, Fragment::WRAP_S}};
479480 case 22 :
480481 if (!allow_B) return {};
481- return {{{" K " _mst }, Fragment::WRAP_C}};
482+ return {{{K }, Fragment::WRAP_C}};
482483 case 23 :
483484 if (!allow_B) return {};
484- return {{{" V " _mst }, Fragment::WRAP_D}};
485+ return {{{V }, Fragment::WRAP_D}};
485486 case 24 :
486487 if (!allow_V) return {};
487- return {{{" B " _mst }, Fragment::WRAP_V}};
488+ return {{{B }, Fragment::WRAP_V}};
488489 case 25 :
489490 if (!allow_B) return {};
490- return {{{" B " _mst }, Fragment::WRAP_J}};
491+ return {{{B }, Fragment::WRAP_J}};
491492 case 26 :
492493 if (!allow_B) return {};
493- return {{{" B " _mst }, Fragment::WRAP_N}};
494+ return {{{B }, Fragment::WRAP_N}};
494495 case 27 : {
495496 if (!allow_B || !IsTapscript (script_ctx)) return {};
496497 const auto k = provider.ConsumeIntegral <uint16_t >();
@@ -528,20 +529,23 @@ struct SmartInfo
528529 {
529530 /* Construct a set of interesting type requirements to reason with (sections of BKVWzondu). */
530531 std::vector<Type> types;
532+ static constexpr auto B_mst{" B" " K" " V" " W"
533+ static constexpr auto d_mst{" d" " n" " o" " u" " z"
534+ static constexpr auto NONE_mst{" "
531535 for (int base = 0 ; base < 4 ; ++base) { /* select from B,K,V,W */
532- Type type_base = base == 0 ? " B " _mst : base == 1 ? " K " _mst : base == 2 ? " V " _mst : " W " _mst ;
536+ Type type_base = base == 0 ? B_mst : base == 1 ? K_mst : base == 2 ? V_mst : W_mst ;
533537 for (int zo = 0 ; zo < 3 ; ++zo) { /* select from z,o,(none) */
534- Type type_zo = zo == 0 ? " z " _mst : zo == 1 ? " o " _mst : " " _mst ;
538+ Type type_zo = zo == 0 ? z_mst : zo == 1 ? o_mst : NONE_mst ;
535539 for (int n = 0 ; n < 2 ; ++n) { /* select from (none),n */
536540 if (zo == 0 && n == 1 ) continue ; /* z conflicts with n */
537541 if (base == 3 && n == 1 ) continue ; /* W conflicts with n */
538- Type type_n = n == 0 ? " " _mst : " n " _mst ;
542+ Type type_n = n == 0 ? NONE_mst : n_mst ;
539543 for (int d = 0 ; d < 2 ; ++d) { /* select from (none),d */
540544 if (base == 2 && d == 1 ) continue ; /* V conflicts with d */
541- Type type_d = d == 0 ? " " _mst : " d " _mst ;
545+ Type type_d = d == 0 ? NONE_mst : d_mst ;
542546 for (int u = 0 ; u < 2 ; ++u) { /* select from (none),u */
543547 if (base == 2 && u == 1 ) continue ; /* V conflicts with u */
544- Type type_u = u == 0 ? " " _mst : " u " _mst ;
548+ Type type_u = u == 0 ? NONE_mst : u_mst ;
545549 Type type = type_base | type_zo | type_n | type_d | type_u;
546550 types.push_back (type);
547551 }
@@ -683,7 +687,7 @@ struct SmartInfo
683687 /* Find which types are useful. The fuzzer logic only cares about constructing
684688 * B,V,K,W nodes, so any type that isn't needed in any recipe (directly or
685689 * indirectly) for the construction of those is uninteresting. */
686- std::set<Type> useful_types{" B " _mst, " V " _mst, " K " _mst, " W " _mst };
690+ std::set<Type> useful_types{B_mst, V_mst, K_mst, W_mst };
687691 // Find the transitive closure by adding types until the set of types does not change.
688692 while (true ) {
689693 size_t set_size = useful_types.size ();
0 commit comments