pipeevt_t* poll_event_from_pipes(void)
{
struct timeval to;
to.tv_sec=0; to.tv_usec=100000;
fd_set set;
memcpy(&set, &pipeset, sizeof(fd_set));
int nfds=select(fd_max+1, &set, NULL, NULL, &to);
pipeevt_t* ret=NULL;
if(nfds>0)
{
for(int i=0; i<=pipe_slot; ++i)
{
if(pipe_fds[i] != -1 && FD_ISSET(pipe_fds[i], &set))
{
int s;
ret=event_recv(pipe_fds[i], &s);
if(s==1)
{
pipe_remove(pipe_fds[i]);
continue;
}
return ret;
}
}
}
return ret;
}
static void substitute_deadend_goal(slice_index si, stip_moves_traversal *st)
{
optimisation_state * const state = st->param;
slice_index const save_optimisable_deadend = state->optimisable_deadend;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
stip_traverse_moves_children(si,st);
TraceValue("%u",state->optimisable_deadend);
TraceValue("%u",state->end_of_branch_goal);
TraceValue("%u\n",st->context);
if (state->optimisable_deadend!=no_slice
&& state->end_of_branch_goal!=no_slice
&& st->context!=stip_traversal_context_attack)
{
slice_index const prototype = alloc_pipe(STDeadEndGoal);
defense_branch_insert_slices(si,&prototype,1);
pipe_remove(state->optimisable_deadend);
}
state->optimisable_deadend = save_optimisable_deadend;
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
int send_event_to_pipes(pipeevt_t* e)
{
struct timeval to;
to.tv_sec=1; to.tv_usec=0;
fd_set set;
memcpy(&set, &pipeset, sizeof(fd_set));
int nfds=select(fd_max+1, NULL, &set, NULL, &to);
if(nfds>0)
{
for(int i=0; i<=pipe_slot; ++i)
{
if(pipe_fds[i] != -1)
{
if(FD_ISSET(pipe_fds[i], &set))
{
int s=event_send(e, pipe_fds[i]);
if(s<0)
{
//perror("Send");
pipe_remove(pipe_fds[i]);
continue;
}
#ifndef NDEBUG
else
{
printf("Sent %d bytes to pipe listener #%d\n", s, pipe_fds[i]);
}
#endif
}
}
}
}
return 0;
}
static void substitute_self_check_guard(slice_index si, stip_structure_traversal *st)
{
insertion_state_type * const state = st->param;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
if (state->are_we_counting_goal_reaching_moves)
{
state->are_we_counting_goal_reaching_moves = false;
stip_traverse_structure_children(si,st);
state->are_we_counting_goal_reaching_moves = true;
{
slice_index const guard = branch_find_slice(STSelfCheckGuard,SLICE_NEXT2(si),st->context);
if (guard!=no_slice)
{
slice_index const prototype = alloc_pipe(STExclusiveChessGoalReachingMoveCounterSelfCheckGuard);
goal_branch_insert_slices(SLICE_NEXT2(si),&prototype,1);
st->traversed[guard] = slice_not_traversed;
pipe_remove(guard);
}
}
}
else
stip_traverse_structure_children(si,st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
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();
}
/* Wrap the slices representing the initial moves of the solution with
* slices of appropriately equipped slice types
* @param adapter identifies the adapter slice at the beginning of the branch
* @param state address of structure holding state
*/
void battle_make_root(slice_index adapter, spin_off_state_type *state)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",adapter);
TraceFunctionParamListEnd();
battle_branch_make_root_slices(adapter,state);
branch_shorten_slices(adapter,STEndOfRoot,stip_traversal_context_intro);
pipe_remove(adapter);
TraceFunctionExit(__func__);
TraceFunctionParamListEnd();
}
static void remove_constraint_if_irrelevant(slice_index si, stip_structure_traversal *st)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
if (is_constraint_irrelevant(SLICE_NEXT2(si)))
{
stip_traverse_structure_children_pipe(si,st);
dealloc_slices(SLICE_NEXT2(si));
pipe_remove(si);
}
else
stip_traverse_structure_children(si,st);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Produce slices representing set play.
* @param adapter identifies the adapter slice at the beginning of the branch
* @param state address of structure holding state
*/
void help_branch_make_setplay(slice_index adapter, spin_off_state_type *state)
{
stip_length_type const length = SLICE_U(adapter).branch.length;
stip_length_type min_length = SLICE_U(adapter).branch.min_length;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",adapter);
TraceFunctionParamListEnd();
assert(SLICE_TYPE(adapter)==STHelpAdapter);
if (min_length==0)
min_length = 2;
if (length>1)
{
slice_index const next = SLICE_NEXT1(adapter);
slice_index const prototypes[] =
{
alloc_help_adapter_slice(length-1,min_length-1),
alloc_pipe(STEndOfRoot)
};
enum
{
nr_prototypes = sizeof prototypes / sizeof prototypes[0]
};
help_branch_insert_slices(next,prototypes,nr_prototypes);
{
slice_index const set_adapter = branch_find_slice(STHelpAdapter,
next,
stip_traversal_context_help);
assert(set_adapter!=no_slice);
help_branch_make_root_slices(set_adapter,state);
state->spun_off[adapter] = state->spun_off[set_adapter];
pipe_remove(set_adapter);
}
}
TraceValue("%u\n",state->spun_off[adapter]);
TraceFunctionExit(__func__);
TraceFunctionParamListEnd();
}
/* Wrap the slices representing the initial moves of the solution with
* slices of appropriately equipped slice types
* @param adapter identifies the adapter slice at the beginning of the branch
* @param state address of structure holding state
*/
void help_make_root(slice_index adapter, spin_off_state_type *state)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",adapter);
TraceFunctionParamListEnd();
assert(SLICE_TYPE(adapter)==STHelpAdapter);
{
slice_index const prototype = alloc_pipe(STEndOfRoot);
slice_insertion_insert(adapter,&prototype,1);
help_branch_make_root_slices(adapter,state);
branch_shorten_slices(adapter,STEndOfRoot,stip_traversal_context_intro);
pipe_remove(adapter);
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
static void remove_guard(slice_index si, stip_structure_traversal *st)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",si);
TraceFunctionParamListEnd();
stip_traverse_structure_children_pipe(si,st);
{
slice_index const guard = branch_find_slice(STSelfCheckGuard,
SLICE_NEXT2(si),
stip_traversal_context_intro);
assert(guard!=no_slice);
pipe_remove(guard);
}
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Shorten a help branch by 1 half move
* @param identifies entry slice of branch to be shortened
*/
void help_branch_shorten(slice_index adapter)
{
slice_index const next = SLICE_NEXT1(adapter);
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",adapter);
TraceFunctionParamListEnd();
assert(SLICE_TYPE(adapter)==STHelpAdapter);
{
/* find the new spot for adapter by inserting a copy */
slice_index const prototype = copy_slice(adapter);
help_branch_insert_slices(next,&prototype,1);
}
{
/* move adapter to its new spot */
slice_index const copy = branch_find_slice(STHelpAdapter,
next,
stip_traversal_context_help);
assert(copy!=no_slice);
pipe_link(SLICE_PREV(adapter),next);
pipe_append(copy,adapter);
pipe_remove(copy);
}
/* adjust the length and min_length members */
--SLICE_U(adapter).branch.length;
if (SLICE_U(adapter).branch.min_length<=0)
increase_min_length(adapter);
--SLICE_U(adapter).branch.min_length;
branch_shorten_slices(next,STHelpAdapter,stip_traversal_context_help);
TraceFunctionExit(__func__);
TraceFunctionResultEnd();
}
/* Make the postkey play representation of a non-postkey play representation
* @param adapter identifies adapter slice into battle branch
* @return identifier to adapter slice into postkey representation
*/
slice_index battle_branch_make_postkeyplay(slice_index adapter)
{
slice_index result;
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",adapter);
TraceFunctionParamListEnd();
TraceStipulation(adapter);
assert(SLICE_TYPE(adapter)==STAttackAdapter);
{
slice_index const notend = branch_find_slice(STNotEndOfBranchGoal,
adapter,
stip_traversal_context_intro);
stip_length_type const length = SLICE_U(adapter).branch.length;
stip_length_type const min_length = SLICE_U(adapter).branch.min_length;
slice_index const proto = alloc_defense_adapter_slice(length-1,
min_length-1);
assert(notend!=no_slice);
defense_branch_insert_slices(notend,&proto,1);
result = branch_find_slice(STDefenseAdapter,
notend,
stip_traversal_context_defense);
assert(result!=no_slice);
branch_shorten_slices(adapter,STDefenseAdapter,stip_traversal_context_intro);
pipe_remove(adapter);
}
TraceFunctionExit(__func__);
TraceFunctionParam("%u",result);
TraceFunctionParamListEnd();
return result;
}
/* Produce slices representing set play.
* @param adapter identifies the adapter slice at the beginning of the branch
* @param state address of structure holding state
*/
void series_branch_make_setplay(slice_index adapter, spin_off_state_type *state)
{
TraceFunctionEntry(__func__);
TraceFunctionParam("%u",adapter);
TraceFunctionParamListEnd();
{
slice_index const next = SLICE_NEXT1(adapter);
slice_index const prototypes[] =
{
alloc_help_adapter_slice(0,0),
alloc_pipe(STEndOfRoot)
};
enum { nr_prototypes = sizeof prototypes / sizeof prototypes[0] };
help_branch_insert_slices(next,prototypes,nr_prototypes);
{
slice_index const set_adapter = branch_find_slice(STHelpAdapter,
next,
stip_traversal_context_help);
assert(set_adapter!=no_slice);
if (SLICE_TYPE(SLICE_NEXT1(set_adapter))==STDeadEnd)
; /* set play not applicable */
else
help_branch_make_root_slices(set_adapter,state);
TraceValue("%u\n",state->spun_off[set_adapter]);
state->spun_off[adapter] = state->spun_off[set_adapter];
pipe_remove(set_adapter);
}
}
TraceValue("%u\n",state->spun_off[adapter]);
TraceFunctionExit(__func__);
TraceFunctionParamListEnd();
}
