static void insert_separator(slice_index si, stip_structure_traversal *st)
{
TraceFunctionEntry(__func__);
TraceValue("%u",si);
TraceFunctionParamListEnd();
stip_traverse_structure_children(si,st);
{
slice_index const proxy_standard = alloc_proxy_slice();
slice_index const standard = alloc_pipe(STMoveForPieceGeneratorStandardPath);
slice_index const proxy_alternative = alloc_proxy_slice();
slice_index const alternative = alloc_pipe(STMoveForPieceGeneratorAlternativePath);
slice_index const generator = alloc_binary_slice(STMoveForPieceGeneratorTwoPaths,
proxy_standard,
proxy_alternative);
pipe_link(SLICE_PREV(si),generator);
pipe_link(proxy_standard,standard);
pipe_link(standard,si);
pipe_link(proxy_alternative,alternative);
pipe_link(alternative,si);
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Instrument a help branch with a STIfThenElse slice
* @param adapter identifies adapter slice into the help branch
*/
void help_branch_insert_check_zigzag(slice_index adapter)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",adapter);
TraceFunctionParamListEnd();
{
slice_index const ready = help_branch_locate_ready(adapter);
slice_index const proxy1 = alloc_proxy_slice();
slice_index const proxy2 = alloc_proxy_slice();
slice_index const played = alloc_help_move_played_slice();
slice_index const condition = alloc_goal_check_reached_tester_slice(goal_applies_to_starter);
slice_index const jump = alloc_if_then_else_slice(proxy1,proxy2,condition);
slice_index const landing_proto = alloc_pipe(STCheckZigzagLanding);
assert(ready!=no_slice);
pipe_link(condition,alloc_true_slice());
help_branch_insert_slices(ready,&landing_proto,1);
pipe_link(proxy2,SLICE_NEXT1(ready));
pipe_link(proxy1,played);
pipe_link(ready,jump);
{
slice_index const landing = branch_find_slice(STCheckZigzagLanding,
ready,
stip_traversal_context_help);
assert(landing!=no_slice);
link_to_branch(played,landing);
}
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static void instrument_negated_tester(slice_index si,
stip_structure_traversal *st)
{
in_branch_insertion_state_type * const state = st->param;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
if (state->in_goal_tester!=no_goal)
{
/* make sure that not_slice doesn't convert previous_move_has_not_solved into
* previous_move_has_solved if the last move caused a self-check
*/
slice_index const proxy_not = alloc_proxy_slice();
slice_index const proxy_selfcheck = alloc_proxy_slice();
slice_index const guard = alloc_selfcheck_guard_slice();
slice_index const leaf_selfcheck = alloc_true_slice();
if (is_goal_move_oriented(SLICE_NEXT1(si),st))
pipe_link(SLICE_PREV(si),alloc_and_slice(proxy_not,proxy_selfcheck));
else
pipe_link(SLICE_PREV(si),alloc_and_slice(proxy_selfcheck,proxy_not));
pipe_link(proxy_not,si);
pipe_link(proxy_selfcheck,guard);
pipe_link(guard,leaf_selfcheck);
state->is_branch_instrumented = true;
}
else
stip_traverse_structure_children_pipe(si,st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static slice_index make_opponent_moves_counter_fork(Side side)
{
slice_index result;
TraceFunctionEntry(__func__);
TraceEnumerator(Side,side);
TraceFunctionParamListEnd();
if (is_countnropponentmoves_defense_move_optimisation_enabled(side))
{
slice_index const proxy = alloc_proxy_slice();
slice_index const prototypes[] =
{
alloc_opponent_moves_counter_slice(),
alloc_legal_attack_counter_slice()
};
enum { nr_prototypes = sizeof prototypes / sizeof prototypes[0] };
slice_index const attack = alloc_defense_branch(slack_length+2,slack_length+1);
slice_insertion_insert(attack,prototypes,nr_prototypes);
link_to_branch(proxy,attack);
result = alloc_conditional_pipe(STOpponentMovesCounterFork,proxy);
solving_impose_starter(result,side);
}
else
result = alloc_proxy_slice();
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
static slice_index make_cagecirce_noncapture_finder(Side side)
{
slice_index result;
if (circe_variant.determine_rebirth_square==circe_determine_rebirth_square_cage
|| anticirce_variant.determine_rebirth_square==circe_determine_rebirth_square_cage)
{
slice_index const proxy_branch = alloc_proxy_slice();
slice_index const help = alloc_help_branch(slack_length+1,slack_length+1);
slice_index const proxy_goal = alloc_proxy_slice();
slice_index const system = alloc_goal_capture_reached_tester_system();
link_to_branch(proxy_goal,system);
{
slice_index const tester = branch_find_slice(STGoalReachedTester,
proxy_goal,
stip_traversal_context_intro);
assert(tester!=no_slice);
pipe_append(SLICE_NEXT2(tester),alloc_not_slice());
SLICE_U(tester).goal_handler.goal.type = goal_negated;
help_branch_set_end_goal(help,proxy_goal,1);
link_to_branch(proxy_branch,help);
result = alloc_conditional_pipe(STCageCirceNonCapturingMoveFinder,proxy_branch);
solving_impose_starter(result,side);
}
}
else
result = alloc_proxy_slice();
return result;
}
static char *ParseReciEnd(char *tok, slice_index start, slice_index proxy)
{
slice_index op1;
slice_index op2;
TraceFunctionEntry(__func__);
TraceFunctionParam("%s",tok);
TraceFunctionParam("%u",start);
TraceFunctionParam("%u",proxy);
TraceFunctionParamListEnd();
op1 = alloc_proxy_slice();
op2 = alloc_proxy_slice();
tok = ParseReciGoal(tok,start,op1,op2);
if (SLICE_NEXT1(op1)!=no_slice && SLICE_NEXT1(op2)!=no_slice)
{
slice_index const reci = alloc_and_slice(op1,op2);
pipe_link(proxy,reci);
}
TraceFunctionExit(__func__);
TraceFunctionResult("%s",tok);
TraceFunctionResultEnd();
return tok;
}
static char *ParseReciGoal(char *tok,
slice_index start,
slice_index proxy_nonreci,
slice_index proxy_reci)
{
char *result = 0;
TraceFunctionEntry(__func__);
TraceFunctionParam("%s",tok);
TraceFunctionParamListEnd();
if (*tok=='(')
{
char const *closingParenPos = strchr(tok,')');
if (closingParenPos!=0)
{
slice_index const proxy_to_reci = alloc_proxy_slice();
tok = ParseGoal(tok+1,start,proxy_to_reci);
if (tok!=0)
{
if (tok==closingParenPos)
{
slice_index const proxy_to_nonreci = alloc_proxy_slice();
result = ParseGoal(tok+1,start,proxy_to_nonreci);
if (result!=NULL)
{
slice_index const nonreci = SLICE_NEXT1(proxy_to_nonreci);
SLICE_STARTER(nonreci) = Black;
alloc_reci_end(proxy_nonreci,proxy_reci,
proxy_to_nonreci,proxy_to_reci);
}
}
else
output_plaintext_input_error_message(UnrecStip, 0);
}
}
else
output_plaintext_input_error_message(UnrecStip, 0);
}
else
{
slice_index const proxy_to_nonreci = alloc_proxy_slice();
result = ParseGoal(tok,start,proxy_to_nonreci);
if (result!=NULL)
{
slice_index const nonreci_testing = SLICE_NEXT1(proxy_to_nonreci);
slice_index const nonreci_tester = SLICE_NEXT1(nonreci_testing);
slice_index const proxy_to_reci = stip_deep_copy(proxy_to_nonreci);
alloc_reci_end(proxy_nonreci,proxy_reci,
proxy_to_nonreci,proxy_to_reci);
SLICE_STARTER(nonreci_tester) = Black;
}
}
TraceFunctionExit(__func__);
TraceFunctionResult("%s",result);
TraceFunctionResultEnd();
return result;
}
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 slice_index make_ultra_mummer_length_measurer(Side side)
{
slice_index result;
slice_index const proxy_branch = alloc_proxy_slice();
slice_index const help = alloc_help_branch(slack_length+1,slack_length+1);
slice_index const proxy_goal = alloc_proxy_slice();
slice_index const system = alloc_goal_any_reached_tester_system();
link_to_branch(proxy_goal,system);
help_branch_set_end_goal(help,proxy_goal,1);
link_to_branch(proxy_branch,help);
result = alloc_conditional_pipe(STUltraMummerMeasurerFork,proxy_branch);
solving_impose_starter(result,side);
return result;
}
static slice_index make_castling_intermediate_move_legality_tester(Side side)
{
slice_index result;
slice_index const proxy_branch = alloc_proxy_slice();
slice_index const help = alloc_help_branch(slack_length+1,slack_length+1);
slice_index const proxy_goal = alloc_proxy_slice();
slice_index const system = alloc_goal_any_reached_tester_system();
link_to_branch(proxy_goal,system);
help_branch_set_end_goal(help,proxy_goal,1);
link_to_branch(proxy_branch,help);
result = alloc_conditional_pipe(STCastlingIntermediateMoveLegalityTester,proxy_branch);
solving_impose_starter(result,side);
return result;
}
char *ParseStip(char *tok, slice_index start)
{
slice_index const root_slice_hook = alloc_proxy_slice();
TraceFunctionEntry(__func__);
TraceFunctionParam("%s",tok);
TraceFunctionParam("%u",start);
TraceFunctionParamListEnd();
stipulation_reset();
if (ParsePlay(tok,start,root_slice_hook,play_length_minimum))
{
move_effect_journal_do_insert_stipulation(start,root_slice_hook);
tok = ReadNextTokStr();
}
else
dealloc_slices(root_slice_hook);
/* signal to our caller that the stipulation has changed */
SLICE_STARTER(root_slice_hook) = no_side;
TraceFunctionExit(__func__);
TraceFunctionResult("%s",tok);
TraceFunctionResultEnd();
return tok;
}
static void insert_maxthreatlength_guard(slice_index si,
stip_structure_traversal *st)
{
stip_length_type const length = SLICE_U(si).branch.length;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
stip_traverse_structure_children_pipe(si,st);
if (length>=2*max_len_threat+slack_length)
{
boolean * const inserted = st->param;
slice_index const threat_start = branch_find_slice(STMaxThreatLengthStart,
si,
st->context);
slice_index const proxy = alloc_proxy_slice();
slice_index const dummy = alloc_pipe(STDummyMove);
slice_index const played = alloc_defense_played_slice();
slice_index const prototype = alloc_maxthreatlength_guard(proxy);
assert(threat_start!=no_slice);
pipe_link(proxy,dummy);
pipe_link(dummy,played);
link_to_branch(played,threat_start);
defense_branch_insert_slices(si,&prototype,1);
*inserted = true;
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static void copy_end_of_branch_goal_if_necessary(slice_index si, stip_structure_traversal *st)
{
stip_deep_copies_type * const copies = st->param;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
{
slice_index const tester = branch_find_slice(STGoalReachedTester,SLICE_NEXT2(si),st->context);
if (tester==no_slice
/* avoid considering moves that lead to self-check illegal if they reach the goal: */
|| branch_find_slice(STSelfCheckGuard,SLICE_NEXT2(tester),st->context)==no_slice)
regular_deep_copy_end_of_branch_goal(si,st);
else
{
/* Rely on the tests in the goal reached tester: */
(*copies)[si] = alloc_proxy_slice();
stip_traverse_structure_children_pipe(si,st);
pipe_link((*copies)[si],(*copies)[SLICE_NEXT1(si)]);
}
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Parse a structured stipulation (keyword sstipulation)
* @param start index of entry into solving machinery
* @return remainder of input token; 0 if parsing failed
*/
char *ParseStructuredStip(char *tok, slice_index start)
{
slice_index const root_slice_hook = alloc_proxy_slice();
Side starter;
TraceFunctionEntry(__func__);
TraceFunctionParam("%s",tok);
TraceFunctionParam("%u",root_slice_hook);
TraceFunctionParamListEnd();
stipulation_reset();
starter = ParseStructuredStip_starter(tok);
if (starter!=no_side)
{
expression_type type;
tok = ReadNextTokStr();
tok = ParseStructuredStip_expression(tok,start,root_slice_hook,&type,0);
if (tok==0)
tok = ReadNextTokStr();
else if (SLICE_NEXT1(root_slice_hook)!=no_slice)
{
solving_impose_starter(root_slice_hook,starter);
move_effect_journal_do_insert_sstipulation(start,root_slice_hook);
}
}
/* signal to our caller that the stipulation has changed */
SLICE_STARTER(root_slice_hook) = no_side;
TraceFunctionExit(__func__);
TraceFunctionResult("%s",tok);
TraceFunctionResultEnd();
return tok;
}
/* Instrument a series branch with STEndOfBranchForced slices (typically for a
* hr stipulation)
* @param si entry slice of branch to be instrumented
* @param forced identifies branch forced on the defender
* @param parity indicates after which help move of the branch to insert
*/
void help_branch_set_end_forced(slice_index si,
slice_index forced,
unsigned int parity)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParam("%u",forced);
TraceFunctionParam("%u",parity);
TraceFunctionParamListEnd();
TraceStipulation(si);
TraceStipulation(forced);
{
slice_index const proxy = alloc_proxy_slice();
slice_index const fork = alloc_fork_slice(STEndOfBranchForced,proxy);
#if !defined(NDEBUG)
boolean const inserted =
#endif
help_branch_insert_end_of_branch(si,fork,parity);
assert(inserted);
pipe_link(proxy,forced);
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static slice_index make_brunner_check_defense_finder(Side side)
{
slice_index result;
slice_index const proxy_branch = alloc_proxy_slice();
slice_index const help = alloc_help_branch(slack_length+1,slack_length+1);
slice_index const proxy_goal = alloc_proxy_slice();
slice_index const system = alloc_goal_any_reached_tester_system();
slice_index const executing = alloc_pipe(STExecutingKingCapture);
link_to_branch(proxy_goal,system);
help_branch_set_end_goal(help,proxy_goal,1);
slice_insertion_insert(help,&executing,1);
link_to_branch(proxy_branch,help);
result = alloc_conditional_pipe(STBrunnerDefenderFinder,proxy_branch);
solving_impose_starter(result,side);
return result;
}
/* Instrument a battle branch with a STIfThenElse slice providing a
* shortcut for the defense moe
* @param adapter identifies adapter slice into the battle branch
*/
void battle_branch_insert_defense_check_zigzag(slice_index adapter)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",adapter);
TraceFunctionParamListEnd();
{
slice_index const ready = branch_find_slice(STReadyForDefense,
adapter,
stip_traversal_context_intro);
slice_index const deadend = branch_find_slice(STDeadEnd,
ready,
stip_traversal_context_defense);
slice_index const proxy1 = alloc_proxy_slice();
slice_index const proxy2 = alloc_proxy_slice();
slice_index const dummy = alloc_pipe(STDummyMove);
slice_index const played = alloc_defense_played_slice();
slice_index const condition = alloc_goal_check_reached_tester_slice(goal_applies_to_starter);
slice_index const jump = alloc_if_then_else_slice(proxy1,proxy2,condition);
slice_index const landing_proto = alloc_pipe(STCheckZigzagLanding);
assert(ready!=no_slice);
assert(deadend!=no_slice);
pipe_link(condition,alloc_true_slice());
defense_branch_insert_slices(ready,&landing_proto,1);
pipe_link(proxy2,SLICE_NEXT1(deadend));
/* the dummy move is needed to make sure that the killer move mechanism
* applies to the same play whether the attacker has delivered check or not
* TODO only insert the dummy move if the killer move optimisation is used
*/
pipe_link(proxy1,dummy);
pipe_link(dummy,played);
pipe_link(deadend,jump);
{
slice_index const landing = branch_find_slice(STCheckZigzagLanding,
deadend,
stip_traversal_context_defense);
assert(landing!=no_slice);
link_to_branch(played,landing);
}
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static slice_index make_exclusive_mating_move_counter_fork(Side side)
{
slice_index result;
slice_index const proxy_branch = alloc_proxy_slice();
slice_index const proxy_to_goal = alloc_proxy_slice();
Goal const goal = { goal_mate, initsquare };
slice_index const tester_system = alloc_goal_mate_reached_tester_system();
slice_index const tester_slice = alloc_goal_reached_tester_slice(goal,tester_system);
slice_index const attack = alloc_battle_branch(slack_length+1,slack_length+1);
slice_index const counter = alloc_pipe(STExclusiveChessGoalReachingMoveCounter);
link_to_branch(counter,tester_slice);
link_to_branch(proxy_to_goal,counter);
link_to_branch(proxy_branch,attack);
battle_branch_insert_direct_end_of_branch_goal(attack,proxy_to_goal);
result = alloc_conditional_pipe(STExclusiveChessMatingMoveCounterFork,proxy_branch);
solving_impose_starter(result,side);
return result;
}
static slice_index make_suffocation_by_paralysis_detector(Side side)
{
slice_index const proxy = alloc_proxy_slice();
slice_index const result = alloc_conditional_pipe(STPiecesParalysingSuffocationFinderFork,proxy);
slice_index const attack = alloc_battle_branch(slack_length+1,slack_length+1);
slice_index const prototype = alloc_pipe(STPiecesParalysingSuffocationFinder);
slice_insertion_insert(attack,&prototype,1);
link_to_branch(proxy,attack);
solving_impose_starter(result,side);
return result;
}
static void insert_null_move_handler(slice_index si, stip_structure_traversal *st)
{
slice_index const * const landing = st->param;
slice_index const proxy = alloc_proxy_slice();
slice_index const prototype = alloc_null_move_player_slice(proxy);
assert(*landing!=no_slice);
link_to_branch(proxy,*landing);
move_insert_slices(si,st->context,&prototype,1);
}
static slice_index make_move_generator(Side side)
{
slice_index const proxy = alloc_proxy_slice();
slice_index const result = alloc_conditional_pipe(STMoveGeneratorFork,proxy);
slice_index const generating = alloc_pipe(STGeneratingMovesForPiece);
slice_index const ortho = alloc_pipe(STMovesForPieceBasedOnWalkGenerator);
slice_index const generated = create_slice(STGeneratedMovesForPiece);
pipe_append(proxy,generating);
pipe_append(generating,ortho);
pipe_link(ortho,generated);
solving_impose_starter(result,side);
return result;
}
static void insert_avoid_unsolvable(slice_index si, stip_structure_traversal *st)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
stip_traverse_structure_children(si,st);
if (st->context==stip_traversal_context_attack
|| st->context==stip_traversal_context_defense)
{
slice_index const proxy1 = alloc_proxy_slice();
slice_index const proxy2 = alloc_proxy_slice();
slice_index const fork = alloc_avoid_unsolvable_slice(proxy1,proxy2);
pipe_link(SLICE_PREV(si),fork);
pipe_append(si,proxy2);
pipe_link(proxy1,si);
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static slice_index make_observation_geometry_validator(Side side)
{
slice_index const proxy = alloc_proxy_slice();
slice_index const result = alloc_conditional_pipe(STValidatingObservationGeometryFork,proxy);
slice_index const enforce_walk = alloc_pipe(STEnforceObserverWalk);
slice_index const testing = alloc_pipe(STValidatingObservationGeometry);
pipe_link(proxy,testing);
pipe_link(testing,enforce_walk);
pipe_link(enforce_walk,alloc_true_slice());
solving_impose_starter(result,side);
return result;
}
static slice_index make_circe_take_make_rebirth_squares_finder(Side side)
{
slice_index result;
slice_index const proxy_branch = alloc_proxy_slice();
slice_index const help = alloc_help_branch(slack_length+1,slack_length+1);
slice_index const prototype = alloc_pipe(STTakeMakeCirceCollectRebirthSquares);
slice_index const executing = alloc_pipe(STExecutingKingCapture);
link_to_branch(proxy_branch,help);
help_branch_insert_slices(help,&prototype,1);
slice_insertion_insert(help,&executing,1);
result = alloc_conditional_pipe(STTakeMakeCirceCollectRebirthSquaresFork,proxy_branch);
solving_impose_starter(result,side);
return result;
}
static slice_index make_back_home_finder(Side side)
{
slice_index const proxy = alloc_proxy_slice();
slice_index const result = alloc_conditional_pipe(STBackHomeFinderFork,proxy);
slice_index const defense = alloc_defense_branch(slack_length+1,slack_length+1);
slice_index const prototypes[] =
{
alloc_pipe(STBackHomeMovesOnly),
alloc_legal_defense_counter_slice()
};
slice_insertion_insert(defense,prototypes,2);
link_to_branch(proxy,defense);
solving_impose_starter(result,side);
return result;
}
static void skip_copying(slice_index si, stip_structure_traversal *st)
{
stip_deep_copies_type * const copies = st->param;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
(*copies)[si] = alloc_proxy_slice();
stip_traverse_structure_children_pipe(si,st);
pipe_link((*copies)[si],(*copies)[SLICE_NEXT1(si)]);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static slice_index make_check_tester(void)
{
slice_index const proxy = alloc_proxy_slice();
slice_index const result = alloc_conditional_pipe(STCheckTesterFork,proxy);
slice_index const testing = alloc_pipe(STTestingCheck);
slice_index const initialiser = alloc_pipe(STKingSquareObservationTesterPlyInitialiser);
slice_index const king_square_observation_tester = alloc_pipe(STKingSquareObservationTester);
slice_index const tested = create_slice(STTestedCheck);
link_to_branch(proxy,testing);
pipe_append(testing,initialiser);
pipe_append(initialiser,king_square_observation_tester);
pipe_link(king_square_observation_tester,tested);
solving_impose_starter(result,Black);
return result;
}
/* 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 slice_index make_mate_tester_fork(Side side)
{
slice_index result;
if (CondFlag[exclusive] || CondFlag[republican])
{
Goal const mate_goal = { goal_mate, initsquare };
slice_index const mate_tester = alloc_goal_mate_reached_tester_system();
result = alloc_goal_reached_tester_slice(mate_goal,mate_tester);
dealloc_slice(SLICE_NEXT1(result));
solving_impose_starter(result,side);
}
else
result = alloc_proxy_slice();
return result;
}
static slice_index make_check_validator(Side side)
{
slice_index const proxy = alloc_proxy_slice();
slice_index const result = alloc_conditional_pipe(STValidatingCheckFork,proxy);
slice_index const check = alloc_pipe(STValidatingCheck);
slice_index const enforce_walk = alloc_pipe(STEnforceObserverWalk);
slice_index const observer = alloc_pipe(STValidatingObserver);
slice_index const geometry = alloc_pipe(STValidatingObservationGeometry);
pipe_link(proxy,check);
pipe_link(check,enforce_walk);
pipe_link(enforce_walk,observer);
pipe_link(observer,geometry);
pipe_link(geometry,alloc_true_slice());
solving_impose_starter(result,side);
return result;
}
