static void substitute_king_first(slice_index si, stip_structure_traversal *st)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
assert(SLICE_STARTER(si)!=no_side);
stip_traverse_structure_children_pipe(si,st);
/* this optimisation doesn't work if an ultra-mummer condition applies
* to the side to be immobilised */
if (mummer_strictness[SLICE_STARTER(si)]<=mummer_strictness_regular)
{
slice_index const proxy1 = alloc_proxy_slice();
slice_index const proxy2 = alloc_proxy_slice();
slice_index const king_branch = SLICE_NEXT1(si);
slice_index const nonking_branch = stip_deep_copy(king_branch);
slice_index const king_move_tester = alloc_pipe(STImmobilityTester);
slice_index const nonking_move_tester = alloc_pipe(STImmobilityTester);
pipe_link(si,alloc_and_slice(proxy1,proxy2));
pipe_link(proxy1,king_move_tester);
link_to_branch(king_move_tester,king_branch);
{
slice_index const generator = branch_find_slice(STMoveGenerator,
king_branch,
stip_traversal_context_intro);
assert(generator!=no_slice);
pipe_substitute(generator,alloc_king_move_generator_slice());
}
pipe_link(proxy2,nonking_move_tester);
link_to_branch(nonking_move_tester,nonking_branch);
{
slice_index const generator = branch_find_slice(STMoveGenerator,
nonking_branch,
stip_traversal_context_intro);
assert(generator!=no_slice);
pipe_substitute(generator,alloc_non_king_move_generator_slice());
}
pipe_remove(si);
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static void degenerate_tree_inserter_attack(slice_index si,
stip_structure_traversal *st)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
if (st->activity==stip_traversal_activity_testing
&& SLICE_U(si).branch.length>=slack_length+2)
{
slice_index const finder = branch_find_slice(STFindShortest,
si,
stip_traversal_context_attack);
if (finder!=no_slice) /* slice may already have been replaced */
{
stip_length_type const length = SLICE_U(finder).branch.length;
stip_length_type const min_length = SLICE_U(finder).branch.min_length;
pipe_substitute(finder,alloc_degenerate_tree_guard_slice(length,min_length));
}
}
else
stip_traverse_structure_children_pipe(si,st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static void optimise_stop(slice_index stop, stip_structure_traversal *st)
{
slice_index const immobility_tester = SLICE_NEXT2(stop);
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",stop);
TraceFunctionParamListEnd();
TraceValue("%u",fate[stop]);
TraceEOL();
TraceValue("%u",immobility_tester);
TraceValue("%u",fate[immobility_tester]);
TraceEOL();
switch (fate[stop])
{
case fate_stop_to_be_optimised:
if (fate[immobility_tester]==fate_immobility_tester_obsolete)
dealloc_slices(immobility_tester);
if (SLICE_TESTER(stop)!=no_slice && fate[SLICE_TESTER(stop)]==fate_dont_know)
/* substitute unreachable tester slice */
pipe_substitute(SLICE_TESTER(stop),alloc_pipe(STOhneschachStopIfCheck));
pipe_substitute(stop,alloc_pipe(STOhneschachStopIfCheck));
break;
case fate_stop_not_to_be_optimised:
assert(fate[immobility_tester]!=fate_immobility_tester_obsolete);
break;
default:
assert(0);
break;
}
fate[stop] = fate_dont_know;
fate[immobility_tester] = fate_dont_know;
stip_traverse_structure_children_pipe(stop,st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static void do_substitute(slice_index si,
stip_structure_traversal *st)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
pipe_substitute(si,alloc_single_piece_move_generator_slice());
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static void substitute_enforce_annanised_walk(slice_index si,
stip_structure_traversal *st)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
stip_traverse_structure_children(si,st);
pipe_substitute(si,alloc_pipe(STAnnanEnforceObserverWalk));
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static void substitute_enforce_confronted_walk(slice_index si,
stip_structure_traversal *st)
{
slice_type const * const enforcer = st->param;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
stip_traverse_structure_children(si,st);
pipe_substitute(si,alloc_pipe(*enforcer));
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* End copying on the visited slice, by moving it to the copy and linking it
* to a proxy slice that takes its original place
* @param si visited slice
* @param st structure representing the copying traversal
*/
static void move_and_stop_copying(slice_index si, stip_structure_traversal *st)
{
stip_deep_copies_type * const copies = st->param;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
assert((*copies)[si]==no_slice);
(*copies)[si] = copy_slice(si);
pipe_substitute(si,alloc_proxy_slice());
link_to_branch((*copies)[si],si);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static void substitute_avoid_promotion_moving(slice_index si,
stip_structure_traversal *st)
{
boolean const (* const enabled)[nr_sides] = st->param;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
stip_traverse_structure_children(si,st);
if ((*enabled)[SLICE_STARTER(si)])
pipe_substitute(si,alloc_pipe(STNoPromotionsRemovePromotionMoving));
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* test all attacked pieces, not just the king */
static void substitute_all_pieces_observation_tester(slice_index si, stip_structure_traversal*st)
{
stip_traverse_structure_children(si,st);
pipe_substitute(si,alloc_pipe(STCirceAssassinAllPieceObservationTester));
}
/* test for extinction rather than king capture */
static void substitute_extinction_tester(slice_index si, stip_structure_traversal*st)
{
stip_traverse_structure_children(si,st);
pipe_substitute(si,alloc_pipe(STExtinctionExtinctedTester));
}
static void substitute(slice_index si, stip_structure_traversal*st)
{
slice_type const *type = st->param;
stip_traverse_structure_children(si,st);
pipe_substitute(si,alloc_pipe(*type));
}
