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; }