2 * Handling of points and other moveable features.
7 /*========== declarations ==========*/
14 typedef struct Method Method;
16 /* Kind-independent code is responsible for determining
17 * the method, doing a bit of cleanup, and adjusting the flow
18 * slightly. Per-kind code does the actual work and is mostly in
19 * charge - it is also responsible for updating seg->moving and ->motion.
21 /* The following states exist for each MovPosChange
22 * at points when control flow passes between kind and indep:
23 * U Unallocated no memory allocated (MovPosChange does not exist)
24 * A Allocated memory allocation done
25 * R Reserved reservation was successful
26 * C Confirmed motion queued and will occur
27 * D Done motion is complete and callback just needs to be made
28 * E Erroneous indep must call destroy straight away
29 * seg->moving and ->motion is in one of the states UC
32 typedef struct MovPosChange { /* valid in: filled in by and when: */
33 Method *meth; /* ARCDE indep after allocate() */
34 Segment *move; /* ARCDE indep after allocate() */
35 MovPosComb actual; /* CD see below */
36 MovPosComb intent; /* RCD indep after allocate() */
37 /* kind-specific data follows */ /* varies kind-specific code, varies */
39 /* `actual' contains the kind's public opinion about the physical
40 * state. It is initialised by indep (just before confirm) from
41 * move->motion->actual or move->movposcomb as the case may be. It
42 * should be updated by the kind, since it is used by indep for
43 * calculating the number and identities of the features which may
44 * need to change when a new move request is intended to replace an
45 * existing one - ie, the contents of the motions[] provided to a
46 * subsequent confirm(). So while a change is Confirmed, the
47 * physical state is recorded only in the relevant change, and not
48 * in the segment's movposcomb. Once a change goes to Confirmed,
49 * the indep code never untangles it so the kind can manage the
50 * proper transition. */
55 Change *(*allocate)(Method *m, int alloc_motions); /* U->A (never err) */
56 ErrorCode (*reserve)(Method *m, Change*, Segment*, /* A->R */
57 int ms); /* error: A->E */
58 ErrorCode (*confirm)(Method *m, Change*, Segment*, /* [AR]->C */
59 int n_motions, const Motion*, int ms); /* err:[AR]->E */
60 void (*destroy)(Method *m, Change*); /* [ARCE]->U */
61 void (*all_abandon)(Method *m);
62 /* indep guarantees that
63 * alloc_motions >= move->i->n_motions on reserve
64 * alloc_motions >= n_motions on confirm
65 * and that if on entry to reserve move->motion is non-0,
66 * it move->motion is non-0 and of the same kind
70 const char *movpos_pname(Segment *move, MovPosComb poscomb) {
71 return poscomb<0 ? "?" : move->i->poscombs[poscomb].pname;
74 static void ouposn_moving(Change *chg) {
75 Segment *move= chg->move;
76 ouprintf("movpos %s position %s moving\n",
77 move->i->pname, movpos_pname(move, chg->actual));
80 static void motion_done(Segment *move, MovPosComb actual) {
83 move->movposcomb= actual;
84 ouprintf("movpos %s position %s stable\n",
85 move->i->pname, movpos_pname(move, move->movposcomb));
88 static void ignore_all_abandon(Method *m) { }
90 /*========== points and other fixed timeslot movfeats ==========*/
93 * We maintain two queues, one for reserved one for actually confirmed
94 * requests where we know what we're doing.
96 * We divide time into discrete slots, numbered with clock arithmetic.
98 * cslot cslot+1 cslot+2
100 * currently next in after
103 * We increment cslot when we consider the movfeat to move;
104 * for points and relays this is when we issue the command to the PIC.
105 * In a request, the deadline represents the latest allowable value
106 * of cslot just before that increment.
109 typedef unsigned FsqSlot;
110 typedef int FsqSlotSigned;
112 /* We think there are three states: Allocated, Reserved and Confirmed.
113 * (plus of course Unallocated where we don't have a request at all).
114 * These correspond to the indep code as follows:
116 * indep state pt state queues checked and plan viable
117 * Unallocated n/a yes
118 * Allocated Allocated yes
119 * Reserved Reserved yes
120 * Confirmed Confirmed yes
123 * Erroneous exists only after a failed reserve() or confirm() so it's
124 * not that confusing to have this slightly malleable terminology.
127 #define FSQDN (~(FsqSlot)0)
129 typedef struct { /* Allocated Reserved Confirmed */
130 /* in queue? absent reserved confirmed */
132 FsqSlot deadline; /* ~0==FSQDN relative absolute <- */
133 MovPosComb actual; /* undef undef see below */
134 int n_motions; /* alloc'd alloc'd undone */
135 Motion motions[]; /* [0].i: 0 0 non-0 <- */
136 /* [..].i: undef undef non-0 */
137 /* .posn: undef undef defined */
139 /* We can determine the the state by looking at the two
140 * `statedet' fields, marked <- above.
141 * There are also intermediate states where the req's
142 * statedet fields do not agree with the queue it's on.
143 * We write these as, for example,
144 * AR to mean statedet says Allocated, but queued on fsq_reserved
145 * A? to mean statedet says Allocated, but may be queued
146 * etc. They are only allowed while we are in a fsq_... method function.
148 /* FsqReq.actual is subtly differnet to MovPosChange.actual,
150 * in MovPosChange in FsqReq
151 * Position unknown -1 0
152 * Position partly known -1 unknown feats are 0
153 * Position completely known exact exact
155 * The partial knowledge positions can only occur in requests that
156 * are confirmed with as many motions as features, so we know that
157 * if we complete a request we know that we can copy actual out
160 * If we abandon a half-done change to a multi-feat segment
161 * we lose the partial knowledge.
164 #define FSQ_MAX_QUEUE 15
168 FsqReq *l[FSQ_MAX_QUEUE];
171 typedef struct FsqMethod FsqMethod;
174 /* set by fsq's client before fsq_init */
176 void (*move)(FsqMethod *m, const MovFeatInfo *mfi, int movfeatposn);
178 int ready; /* >0 means ready; set to 0 by fsq just before move */
179 /* fsq's client must arrange that these start out at all-bits-zero */
181 FsqQueue confirmed, reserved;
187 /* client may put things here */
190 static void fsq_check_action(FsqMethod *m);
191 static ErrorCode fsq_check_plan(FsqMethod *m);
193 static FsqSlotSigned fsq_maxdelay_reldeadline(FsqMethod *m,
194 int maxdelay_ms, int n_motions) {
195 if (maxdelay_ms==-1) return FSQ_MAX_QUEUE*16;
196 return (maxdelay_ms - m->f.lag_ms) / m->f.slot_ms - n_motions;
199 static void fsq_queue_remove_index(FsqQueue *q, int index) {
201 memmove(&q->l[index], &q->l[index+1], sizeof(q->l[0]) * (q->n - index));
204 static int fsq_req_compar_approx(const void *av, const void *bv) {
205 FsqReq *const *a= av;
206 FsqReq *const *b= av;
207 FsqSlotSigned dldiff= (*b)->deadline - (*a)->deadline;
211 static void fsq_queue_remove_item(FsqQueue *q, FsqReq *r) {
214 entry= bsearch(r, q->l, q->n, sizeof(q->l[0]), fsq_req_compar_approx);
217 #define SEARCH_CHECK do{ \
218 if (q->l[i] == r) goto found; \
219 if (q->l[i]->deadline != r->deadline) break; \
221 for(i= entry - q->l; i >= 0; i--) SEARCH_CHECK;
222 for(i= entry - q->l + 1; i < q->n; i++) SEARCH_CHECK;
226 fsq_queue_remove_index(q, i);
229 static void fsq_dequeue(FsqMethod *m, FsqReq *r) { /* X->XA */
230 if (r->motions[0].i) {
231 fsq_queue_remove_item(&m->f.confirmed, r);
232 } else if (r->deadline!=FSQDN) {
233 fsq_queue_remove_item(&m->f.reserved, r);
240 static void fsq_mark_as_allocated(FsqReq *r) { /* AX->X */
241 /* Sets statedet fields for Allocated */
248 whichwhen= wh##when, \
251 static ErrorCode fsq_check_plan(FsqMethod *m) {
252 /* Checks whether we can meet the currently queued commitments */
253 int future, conf, resv, whichwhen, DP;
259 DPRINTF1(movpos,fsq, "%s plan", m->m.pname);
261 /* If CDU is charged we can't do one right away */
268 FsqReq *confr= conf < m->f.confirmed.n ? m->f.confirmed.l[conf] : 0;
269 FsqReq *resvr= resv < m->f.reserved .n ? m->f.reserved .l[resv] : 0;
270 if (!confr && !resvr) break;
271 DPRINTF2(" %d:",future);
272 int confwhen= confr ? confr->deadline - m->f.cslot : INT_MAX;
273 int resvwhen= resvr ? resvr->deadline : INT_MAX;
274 if (future && resvwhen < confwhen) {
275 WHICH(resv); DPRINTF2("~");
279 future++; DPRINTF2("-");
282 DPRINTF2("%s/%s[%d@t+%d]", whichr->h.move->i->pname,
283 movpos_pname(whichr->h.move, whichr->h.intent),
284 whichr->n_motions, whichwhen);
285 if (future > whichwhen) {
286 DPRINTF2("!...bad\n");
287 return EC_MovFeatTooLate;
289 future += whichr->n_motions;
297 static ErrorCode fsq_enqueue(FsqMethod *m, FsqQueue *q, /* XA -> X */
298 FsqReq *r) { /* or on error, XA -> A */
299 int insat; /* ... where X is R or C and corresponds to q */
301 if (q->n == FSQ_MAX_QUEUE)
302 return EC_BufferFull;
305 insat>0 && (FsqSlotSigned)(r->deadline - q->l[insat-1]->deadline) < 0;
307 q->l[insat]= q->l[insat-1];
311 return fsq_check_plan(m);
312 /* if this fails, indep machinery calls fsq_destroy which dequeues */
315 /*---------- method entrypoints ----------*/
317 static Change *fsq_allocate(Method *mm, int alloc_motions) {
321 /* we need at least one motion in the table so we can tell
322 * the difference between the states by looking at motions[0].i */
325 r= mmalloc(sizeof(*r) + alloc_motions * sizeof(r->motions[0]));
327 r->n_motions= alloc_motions;
332 static ErrorCode fsq_reserve(Method *mm, Change *chg,
333 Segment *move, int maxdelay_ms) {
334 FsqMethod *m= (void*)mm;
335 FsqReq *r= (FsqReq*)chg;
336 FsqSlotSigned reldeadline;
338 reldeadline= fsq_maxdelay_reldeadline(m, maxdelay_ms, r->n_motions);
339 if (reldeadline <= 0) { fsq_mark_as_allocated(r); return EC_MovFeatTooLate; }
340 r->deadline= reldeadline;
341 return fsq_enqueue(m, &m->f.reserved, r);
344 static ErrorCode fsq_confirm(Method *mm, Change *chg, Segment *move,
345 int n_motions, const Motion *motions,
347 FsqMethod *m= (void*)mm;
348 FsqReq *r= (FsqReq*)chg;
349 FsqSlotSigned reldeadline;
350 int allow_failure, DP;
353 DPRINTF1(movpos,fsq, "%s confirm %s n=%d maxdelay=%dms",
354 m->m.pname, move->i->pname, n_motions, maxdelay_ms);
356 assert(!r->motions[0].i); /* no confirming things already confirmed */
357 if (r->deadline==FSQDN)
358 DPRINTF2(" (alloc'd: %d)\n", r->n_motions);
360 DPRINTF2(" (res: %s/%s[%d@t+%d])\n",
361 r->h.move->i->pname, movpos_pname(r->h.move, r->h.intent),
362 r->n_motions, r->deadline);
364 /* If the segment is moving, these motions are already based on the
365 * actual physical position which is stored in the existing request.
366 * So we try removing the existing request from the queue and put
367 * it back if it doesn't work.
370 if (n_motions > r->n_motions)
371 return EC_MovFeatReservationInapplicable;
372 assert(n_motions <= r->n_motions);
373 if (maxdelay_ms == -1) {
374 reldeadline= r->deadline;
375 if (reldeadline==FSQDN)
376 reldeadline= fsq_maxdelay_reldeadline(m, -1, n_motions);
378 reldeadline= fsq_maxdelay_reldeadline(m, maxdelay_ms, n_motions);
380 allow_failure= reldeadline < (FsqSlotSigned)r->deadline;
381 DPRINTF(movpos,fsq, "%s reldeadline=[%d@t+%d] allow_failure=%d\n",
382 m->m.pname, n_motions, reldeadline, allow_failure);
386 /* states of existing: */
388 move->moving ? (FsqReq*)move->motion : 0; /* U or C */
391 "%s existing %s n=%d deadline=t+%d\n",
393 existing->h.move->i->pname,
395 existing->deadline - m->f.cslot);
396 fsq_dequeue(m, existing); /* U or CA */
400 memcpy(r->motions, motions, sizeof(r->motions[0])*n_motions);
401 if (!n_motions) r->motions[0].i= move->i->movfeats;
402 assert(r->motions[0].i);
403 r->n_motions= n_motions;
404 r->deadline= reldeadline + m->f.cslot;
406 if (n_motions == move->i->n_movfeats)
409 r->actual= chg->actual;
410 assert(r->actual >= 0);
413 ec= fsq_enqueue(m, &m->f.confirmed, r);
414 DPRINTF(movpos,fsq, "%s fsq_enqueue=%s\n", m->m.pname, ec2str(ec));
415 assert(allow_failure || !ec);
417 if (existing) { /* CA */
418 if (ec) { /* state C but bad */
419 fsq_dequeue(m,r); /* state CA */
420 fsq_mark_as_allocated(r); /* state A */
421 ErrorCode ec_putback= fsq_enqueue(m,&m->f.confirmed, existing);
422 assert(!ec_putback); /* C */
423 } else { /* state C and good */
424 free(existing); /* U */
427 /* either ec=0 state C U
429 * or ec!=0 state C but bad C
436 move->movposcomb= -1;
442 static void fsq_destroy(Method *mm, Change *chg) { /* X->XA and then freed */
443 FsqMethod *m= (void*)mm;
444 FsqReq *r= (FsqReq*)chg;
449 /*---------- something to do ? ----------*/
451 static void fsq_check_action(FsqMethod *m) {
452 /* client should call this after it sets ready */
455 if (!m->f.confirmed.n) {
456 if (sta_state == Sta_Finalising) resolve_motioncheck();
460 FsqReq *r= m->f.confirmed.l[0];
462 if (r->n_motions && m->f.ready>0) {
463 /* look for something to move */
464 Motion *mo= &r->motions[--r->n_motions];
465 assert(mo->posn < mo->i->posns);
467 m->f.move(m, mo->i, mo->posn);
468 ouprintf("movpos %s feat %s %d %s\n", r->h.move->i->pname,
469 mo->i->pname, mo->posn, m->m.pname);
472 MovPosComb above_weight= mo->i->weight * mo->i->posns;
473 MovPosComb above= r->actual / above_weight;
474 MovPosComb below= r->actual % mo->i->weight;
475 r->actual= above*above_weight + mo->posn*mo->i->weight + below;
476 if (r->h.actual >= 0 || !r->n_motions)
477 r->h.actual= r->actual;
478 ouposn_moving(&r->h);
482 /* look for something to report
483 * we can get things here other than from the above
484 * eg if we are asked to move the
486 Segment *move= r->h.move;
487 assert(move->moving && move->motion == (Change*)r);
488 fsq_queue_remove_index(&m->f.confirmed,0);
489 fsq_mark_as_allocated(r); /* now state A aka Done */
490 motion_done(move,r->h.actual);
492 ec= fsq_check_plan(m); assert(!ec);
497 /*---------- entrypoints from rest of program ----------*/
499 static void fsq_all_abandon(Method *mm) {
500 FsqMethod *m= (void*)mm;
503 assert(!m->f.reserved.n);
505 for (i=0; i<m->f.confirmed.n; i++) {
506 FsqReq *r= m->f.confirmed.l[i];
507 Segment *move= r->h.move;
508 assert(move->motion == (Change*)r);
509 motion_done(move,r->h.actual);
515 /*========== points ==========*/
518 * CDU and point queue states:
521 * ____________ conf'd
522 * / points_ \ ready .n
526 * |from INACTIVE -1 0
527 * |any <=Sta_Settling
530 * ___________ |turning
541 * | |fsq_check_action
542 * | | calls point_move which fires a point
547 #define CDU_RECHARGE 350 /*ms*/
548 #define POINT_MOVEMENT 50 /*ms*/
550 static Change *point_allocate(Method *mm, int alloc_motions) {
551 FsqMethod *m= (void*)mm;
552 assert(m->f.ready>=0);
553 return fsq_allocate(mm, alloc_motions);
556 static void point_move(FsqMethod *m, const MovFeatInfo *mfi, int posn) {
557 /* actually firing points, yay! */
559 enco_pic_point(&piob, mfi->boob[posn]);
560 serial_transmit(&piob);
563 static void points_all_abandon(Method *mm) {
564 FsqMethod *m= (void*)mm;
569 static FsqMethod points_method;
571 void points_turning_on(void) {
572 FsqMethod *m= &points_method;
575 void on_pic_charged(const PicInsnInfo *pii, const PicInsn *pi, int objnum) {
576 FsqMethod *m= &points_method;
577 if (m->f.ready<0) return;
582 static FsqMethod points_method= {
583 { "point", mfk_point,
584 point_allocate, fsq_reserve, fsq_confirm,
585 fsq_destroy, points_all_abandon },
586 { .lag_ms= POINT_MOVEMENT, .slot_ms= CDU_RECHARGE, .move= point_move }
589 /*========== relays ==========*/
594 * ____________ conf'd
595 * / wagglers_ \ ready .n
600 * |any <=Sta_Settling
603 * ___________ |turning
614 * | |fsq_check_action
615 * | | calls point_move which fires a point
620 static FsqMethod waggle;
622 static Change *waggle_allocate(Method *mm, int alloc_motions) {
623 FsqMethod *m= (void*)mm;
624 assert(m->f.ready>=0);
625 return fsq_allocate(mm, alloc_motions);
628 static void waggle_do(FsqMethod *m, const MovFeatInfo *mfi, int posn) {
629 /* actually firing points, yay! */
631 enco_pic_waggle(&piob, mfi->boob[0], posn);
632 serial_transmit(&piob);
635 static SegmentNum waggle_settle_seg;
636 static int waggle_settle_feat;
638 static void waggle_settle_check(void) {
640 if (waggle_settle_seg >= info_nsegments) return;
642 Segment *seg= &segments[waggle_settle_seg];
643 if (waggle_settle_feat >= seg->i->n_movfeats) {
644 waggle_settle_seg++; waggle_settle_feat=0; continue;
647 const MovFeatInfo *feati= &seg->i->movfeats[waggle_settle_feat];
648 if (feati->kind != mfk_relay) {
649 waggle_settle_feat++; continue;
653 waggle_do(&waggle, feati, (seg->movposcomb / feati->weight) & 1);
654 waggle_settle_feat++;
658 void waggle_startup_manual(void) {
662 void waggle_settle(void) {
663 waggle_settle_seg= 0;
664 waggle_settle_feat= 0;
666 waggle_settle_check();
669 void on_pic_waggled(const PicInsnInfo *pii, const PicInsn *pi, int objnum) {
670 if (sta_state == Sta_Settling) {
672 waggle_settle_check();
673 } else if (sta_state >= Sta_Resolving || sta_state == Sta_Manual) {
675 fsq_check_action(&waggle);
680 static FsqMethod waggle= {
681 { "relay", mfk_relay,
682 waggle_allocate, fsq_reserve, fsq_confirm,
683 fsq_destroy, fsq_all_abandon },
684 { .lag_ms= 5, .slot_ms= 50, .move= waggle_do }
687 /*========== dummy `nomove' kind ==========*/
689 static Change *nomove_allocate(Method *m, int alloc_motions) {
690 DPRINTF(movpos,nomove, "allocate %d\n",alloc_motions);
691 return mmalloc(sizeof(Change));
693 static ErrorCode nomove_reserve(Method *m, Change *c, Segment *move, int ms) {
694 DPRINTF(movpos,nomove, "reserve\n");
697 static void nomove_destroy(Method *m, Change *c) { free(c); }
698 static ErrorCode nomove_confirm(Method *m, Change *c, Segment *move, int n,
699 const Motion *motions, int ms) {
700 DPRINTF(movpos,nomove, "confirm\n");
705 static Method nomove_method= {
706 "nomove", mfk_none, nomove_allocate, nomove_reserve, nomove_confirm,
707 nomove_destroy, ignore_all_abandon
710 /*========== method-independent machinery ==========*/
712 static Method *methods[]= {
714 (Method*)&points_method,
719 static Change *mp_allocate(Method *meth, Segment *move,
720 int alloc_motions, MovPosComb target) {
721 assert(sta_state >= Sta_Resolving || sta_state == Sta_Manual);
722 Change *chg= meth->allocate(meth, alloc_motions);
729 static int change_needed(const MovFeatInfo *feati,
730 MovPosComb startpoint, MovPosComb target) {
733 (target - startpoint) / feati->weight % feati->posns;
734 DPRINTF(movpos,changeneeded, "%s:%s(%d*%d) %d..%d => %d\n",
735 methods[feati->kind]->pname, feati->pname,
736 feati->posns, feati->weight,
737 startpoint, target, r);
741 static int evaluate_target(Segment *move, MovPosComb target,
742 MovPosComb startpoint, MovFeatKind *kind_r) {
743 /* returns number of features which have to change to reach target,
744 * or -1 for mixed kinds. kind_r may be 0. */
745 const SegmentInfo *movei= move->i;
747 const MovFeatInfo *feati;
750 DPRINTF(movpos,eval, "%s/%s <-%s\n", move->i->pname,
751 movpos_pname(move,target), movpos_pname(move,startpoint));
754 startpoint= movpos_poscomb_actual(move);
755 DPRINTF(movpos,eval, " actual <-%s\n",
756 movpos_pname(move,startpoint));
759 for (feat=0, feati=movei->movfeats, tchanges=0, kind= mfk_none;
760 feat<movei->n_movfeats;
762 if (!change_needed(feati,startpoint,target)) continue;
764 if (kind && feati->kind != kind) return -1;
768 if (kind_r) *kind_r= kind;
769 DPRINTF(movpos,eval, "changes=%d kind=%s\n",
770 tchanges, methods[kind]->pname);
774 ErrorCode movpos_findcomb_bysegs(Segment *back, Segment *move, Segment *fwd,
775 MovPosComb startpoint, MovPosComb *chosen_r) {
776 const SegmentInfo *movei= move->i;
777 MovPosComb tcomb, bestcomb=-1;
778 int tchanges, bestchanges=INT_MAX;
779 const SegPosCombInfo *pci;
781 for (tcomb=0, pci=movei->poscombs;
782 tcomb<movei->n_poscombs;
784 Segment *tback= &segments[pci->link[1].next];
785 Segment *tfwd= &segments[pci->link[0].next];
786 if (back && !(back==tback || back==tfwd)) continue;
787 if (fwd && !(fwd ==tback || fwd ==tfwd)) continue;
789 /* we have to search for the one which is least effort */
790 tchanges= evaluate_target(move,tcomb,startpoint,0);
796 if (tchanges >= bestchanges) /* prefer low-numbered movposcombs */
800 bestchanges= tchanges;
802 if (chosen_r) *chosen_r= bestcomb;
804 bestchanges==INT_MAX ? EC_MovFeatRouteNotFound :
805 bestchanges==INT_MAX-1 ? EC_MovFeatKindsCombination :
809 ErrorCode movpos_change(Segment *move, MovPosComb target,
810 int maxdelay_ms, MovPosChange *chg) {
811 const SegmentInfo *movei= move->i;
812 const MovFeatInfo *feati;
816 MovFeatKind kind= mfk_none;
819 actual= move->movposcomb;
820 assert(!move->motion);
822 kind= move->motion->meth->kind;
823 actual= move->motion->actual;
826 DPRINTF(movpos,change, "%s/%s maxdelay=%dms actual=%s\n",
827 move->i->pname, movpos_pname(move,target),
828 maxdelay_ms, movpos_pname(move, actual));
829 if (chg) DPRINTF(movpos,change, " chg=%s:%s/%s\n",
830 chg->meth->pname, chg->move->i->pname,
831 movpos_pname(chg->move, chg->intent));
833 { /* provide horizon for visibility of motions[] */
835 Motion motions[movei->n_movfeats];
837 for (feat=0, feati=movei->movfeats;
838 feat<movei->n_movfeats;
840 if (!change_needed(feati,actual,target))
842 MovPosComb posn= target / feati->weight % feati->posns;
844 if (feati->kind != kind) { ec= EC_MovFeatKindsCombination; goto x; }
848 motions[n_motions].i= feati;
849 motions[n_motions].posn= posn;
853 Method *meth= methods[kind];
856 if (chg->meth != meth ||
858 chg->intent != target)
859 return EC_MovFeatReservationInapplicable;
861 chg= mp_allocate(meth,move,n_motions,target);
865 DPRINTF(movpos,change, "confirm %s:%d...\n",
866 meth->pname, n_motions);
867 ec= meth->confirm(meth, chg, move, n_motions, motions, maxdelay_ms);
868 DPRINTF(movpos,change, "confirm => %s\n",errorcodelist[ec]);
874 movpos_unreserve(chg);
879 movpos_reserve(Segment *move, int maxdelay_ms, MovPosChange **res_r,
880 MovPosComb target, MovPosComb startpoint /*as for findcomb*/) {
881 MovFeatKind kind= mfk_none;
885 DPRINTF(movpos,reserve, "%s/%s maxdelay=%dms startpoint=%s\n",
886 move->i->pname, movpos_pname(move,target),
887 maxdelay_ms, movpos_pname(move,startpoint));
889 nchanges= evaluate_target(move,target,startpoint,&kind);
890 if (nchanges==-1) return EC_MovFeatKindsCombination;
892 Method *meth= methods[kind];
893 DPRINTF(movpos,reserve, "allocate %s:%d...\n",
894 meth->pname, nchanges);
895 Change *chg= mp_allocate(meth, move, nchanges, target);
896 ec= meth->reserve(meth, chg, move, maxdelay_ms);
897 DPRINTF(movpos,reserve, "reserve => %s\n",errorcodelist[ec]);
904 movpos_unreserve(chg);
908 void movpos_unreserve(MovPosChange *res) {
910 DPRINTF(movpos,unreserve, "%s:%s/%s\n",
911 res->meth->pname, res->move->i->pname,
912 movpos_pname(res->move, res->intent));
913 res->meth->destroy(res->meth, res);
916 MovPosComb movpos_poscomb_actual(Segment *seg) {
917 return seg->moving ? seg->motion->actual : seg->movposcomb;
920 MovPosComb movpos_change_intent(MovPosChange *chg) {
924 void motions_all_abandon(void) {
926 for (meth=methods; *meth; meth++)
927 (*meth)->all_abandon(*meth);