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 MakeReflexBranch(slice_index proxy_to_semi)
{
slice_index result;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",proxy_to_semi);
TraceFunctionParamListEnd();
result = stip_deep_copy(proxy_to_semi);
pipe_append(result,alloc_not_slice());
TraceFunctionExit(__func__);
TraceFunctionResult("%u",result);
TraceFunctionResultEnd();
return result;
}
/* Spin a STContraintSolver slice off a STContraintTester sliceto add it to the
* root or set play branch
* @param si identifies (non-root) slice
* @param st address of structure representing traversal
*/
void constraint_tester_make_root(slice_index si, stip_structure_traversal *st)
{
spin_off_state_type * const state = st->param;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
stip_traverse_structure_children_pipe(si,st);
if (state->spun_off[SLICE_NEXT1(si)]!=no_slice)
{
state->spun_off[si] = alloc_constraint_solver_slice(stip_deep_copy(SLICE_NEXT2(si)));
link_to_branch(state->spun_off[si],state->spun_off[SLICE_NEXT1(si)]);
}
TraceValue("%u\n",state->spun_off[si]);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
