tdelta as an alias for (make-time-delta)

[8sync.git] / loopy.scm

diff --git a/loopy.scm b/loopy.scm
index 2f733c01d4fe32afa21641bc456c37efc4f0f171..3954fea34a853c82e49726eaf40329f2a4509ba7 100644 (file)
--- a/loopy.scm
+++ b/loopy.scm
@@ -18,7 +18,7 @@
             time-< time-= time-<= time-+
 
             <time-delta>
-            make-time-delta time-delta?
+            make-time-delta tdelta time-delta?
             time-delta-sec time-delta-usec
 
             <schedule>
@@ -141,6 +141,8 @@
 (define* (make-time-delta sec #:optional usec)
   (make-time-delta-intern sec (or usec 0)))
 
+(define tdelta make-time-delta)
+
 (define (time-+ time time-delta)
   (cons (+ (car time) (time-delta-sec time-delta))
         (+ (cdr time) (time-delta-usec time-delta))))
@@ -303,7 +305,7 @@
 
 (define* (start-agenda agenda #:optional stop-condition)
   (let loop ((agenda agenda))
-    (let ((new-agenda   
+    (let ((agenda   
            ;; @@: Hm, maybe here would be a great place to handle
            ;;   select'ing on ports.
            ;;   We could compose over agenda-run-once and agenda-read-ports
@@ -311,12 +313,18 @@
              (agenda-run-once agenda))))
       (if (and stop-condition (stop-condition agenda))
           'done
-          (let ((updated-agenda
-                 ;; Adjust the agenda's time just in time
-                 ;; We do this here rather than in agenda-run-once to make
-                 ;; agenda-run-once's behavior fairly predictable
-                 (set-field new-agenda (agenda-time) (gettimeofday))))
-            (loop updated-agenda))))))
+          (let* ((new-time (gettimeofday))
+                 (agenda
+                  ;; Adjust the agenda's time just in time
+                  ;; We do this here rather than in agenda-run-once to make
+                  ;; agenda-run-once's behavior fairly predictable
+                  (set-field agenda (agenda-time) new-time)))
+            ;; Update the agenda's current queue based on
+            ;; currently applicable time segments
+            (add-segments-contents-to-queue!
+             (schedule-extract-until! (agenda-schedule agenda) new-time)
+             (agenda-queue agenda))
+            (loop agenda))))))
 
 (define (agenda-run-once agenda)
   "Run once through the agenda, and produce a new agenda
@@ -343,12 +351,12 @@ based on the results"
                     ((? time-delta? time-delta)
                      (let ((time (time-+ (agenda-time agenda)
                                          time-delta)))
-                       (schedule-at! time (run-request-proc proc))))
+                       (schedule-at! time (run-request-proc run-request))))
                     ((? integer? sec)
                      (let ((time (cons sec 0)))
-                       (schedule-at! time (run-request-proc proc))))
+                       (schedule-at! time (run-request-proc run-request))))
                     (((? integer? sec) . (? integer? usec))
-                     (schedule-at! request-time (run-request-proc proc)))
+                     (schedule-at! request-time (run-request-proc run-request)))
                     (#f
                      (enq! next-queue (run-request-proc run-request))))))))
         ;; @@: We might support delay-wrapped procedures here