Add FIXMEs for subsecond support

This adds FIXMEs to areas where Lisp code should support
subsecond information in broken-down timestamps.
It also fixes some unnecessary truncation of timestamps, and
ports the code to a hypothetical future Emacs version where
(decode-time) returns subsecond timestamps by default.
* lisp/calc/calc-forms.el (calc-time, math-iso-dt-to-date)
(calcFunc-now):
* lisp/calendar/icalendar.el (icalendar--add-decoded-times):
* lisp/calendar/iso8601.el (iso8601-parse-interval):
Truncate seconds to an integer, and add a FIXME about
subseconds support.
* lisp/calendar/icalendar.el (icalendar--decode-isodatetime)
(icalendar--decode-isoduration):
Add a FIXME about subseconds support.
* lisp/gnus/gnus-delay.el (gnus-delay-article):
Don’t truncate seconds to an integer, as there’s no need
to do that here.
* lisp/gnus/gnus-util.el (gnus-seconds-today)
(gnus-seconds-month, gnus-seconds-year):
* lisp/gnus/message.el (message-make-expires-date):
* lisp/org/org-timer.el (org-timer-show-remaining-time):
* lisp/vc/ediff-mult.el (ediff-format-date):
Truncate seconds to an integer, as that’s what’s wanted here.
* lisp/midnight.el (midnight-next):
Ceiling seconds to an integer, as that’s what wanted here.

diff --git a/lisp/calc/calc-forms.el b/lisp/calc/calc-forms.el
index c410ffe449c1d192de81db88a5b0752722766440..7e8a8dcc9d068007be29092d5de5b8d0360806b5 100644 (file)
--- a/lisp/calc/calc-forms.el
+++ b/lisp/calc/calc-forms.el
@@ -37,7 +37,7 @@
 (defun calc-time ()
   (interactive)
   (calc-wrapper
-   (let ((time (decode-time)))
+   (let ((time (decode-time nil nil 'integer))) ;; FIXME: Support subseconds.
      (calc-enter-result 0 "time"
                        (list 'mod
                              (list 'hms
@@ -499,7 +499,8 @@ in the Gregorian calendar and the remaining part determines the time."
        (math-add (math-float date)
                  (math-div (math-add (+ (* (nth 3 dt) 3600)
                                         (* (nth 4 dt) 60))
-                                     (nth 5 dt))
+                                     ;; FIXME: Support subseconds.
+                                     (time-convert (nth 5 dt) 'integer))
                            '(float 864 2)))
       date)))
 
@@ -1327,7 +1328,8 @@ as measured in the integer number of days before December 31, 1 BC (Gregorian)."
           (math-parse-iso-date-validate isoyear isoweek isoweekday hour minute second)))))
 
 (defun calcFunc-now (&optional zone)
-  (let ((date (let ((now (decode-time)))
+  ;; FIXME: Support subseconds.
+  (let ((date (let ((now (decode-time nil nil 'integer)))
                (list 'date (math-dt-to-date
                             (list (decoded-time-year now)
                                    (decoded-time-month now)

diff --git a/lisp/calendar/icalendar.el b/lisp/calendar/icalendar.el
index c2688705e3037c18a82017439d4661631b540fad..3c46982c7b018033a3221540423dfacd3fecf493 100644 (file)
--- a/lisp/calendar/icalendar.el
+++ b/lisp/calendar/icalendar.el
@@ -628,6 +628,7 @@ FIXME: multiple comma-separated values should be allowed!"
         (when (> (length isodatetimestring) 14)
           ;; seconds present
           (setq second (read (substring isodatetimestring 13 15))))
+       ;; FIXME: Support subseconds.
         (when (and (> (length isodatetimestring) 15)
                    ;; UTC specifier present
                    (char-equal ?Z (aref isodatetimestring 15)))
@@ -703,6 +704,7 @@ FIXME: multiple comma-separated values should be allowed!"
                 (setq minutes (read (substring isodurationstring
                                                (match-beginning 10)
                                                (match-end 10)))))
+           ;; FIXME: Support subseconds.
             (if (match-beginning 11)
                 (setq seconds (read (substring isodurationstring
                                                (match-beginning 12)
@@ -719,9 +721,12 @@ FIXME: multiple comma-separated values should be allowed!"
   "Add TIME1 to TIME2.
 Both times must be given in decoded form.  One of these times must be
 valid (year > 1900 or something)."
-  ;; FIXME: does this function exist already?
+  ;; FIXME: does this function exist already?  Can we use decoded-time-add?
   (decode-time (encode-time
-                (+ (decoded-time-second time1) (decoded-time-second time2))
+               ;; FIXME: Support subseconds.
+               (time-convert (time-add (decoded-time-second time1)
+                                       (decoded-time-second time2))
+                             'integer)
                 (+ (decoded-time-minute time1) (decoded-time-minute time2))
                 (+ (decoded-time-hour time1) (decoded-time-hour time2))
                 (+ (decoded-time-day time1) (decoded-time-day time2))

diff --git a/lisp/calendar/iso8601.el b/lisp/calendar/iso8601.el
index 30352c7e75ff163c79f7ff1595925194c2d51065..0f42c824e327f6d15a1344544deda6defc7d6c20 100644 (file)
--- a/lisp/calendar/iso8601.el
+++ b/lisp/calendar/iso8601.el
@@ -322,9 +322,10 @@ Return the number of minutes."
                                             duration))))
     (list start end
           (or duration
+             ;; FIXME: Support subseconds.
               (decode-time (time-subtract (iso8601--encode-time end)
                                           (iso8601--encode-time start))
-                           (or (decoded-time-zone end) 0))))))
+                          (or (decoded-time-zone end) 0) 'integer)))))
 
 (defun iso8601--match (regexp string)
   (string-match (concat "\\`" regexp "\\'") string))

diff --git a/lisp/gnus/gnus-delay.el b/lisp/gnus/gnus-delay.el
index aabf23924a05da07827d1b60278948dfaa4ee2e9..512011fa73ba9a19c2112b2982966d1e1057c40a 100644 (file)
--- a/lisp/gnus/gnus-delay.el
+++ b/lisp/gnus/gnus-delay.el
@@ -98,7 +98,7 @@ DELAY is a string, giving the length of the time.  Possible values are:
           (setq hour   (string-to-number (match-string 1 delay))
                 minute (string-to-number (match-string 2 delay)))
           ;; Use current time, except...
-          (setq deadline (decode-time))
+          (setq deadline (decode-time nil nil t))
           ;; ... for minute and hour.
           (setq deadline (apply #'encode-time (car deadline) minute hour
                                 (nthcdr 3 deadline)))

diff --git a/lisp/gnus/gnus-util.el b/lisp/gnus/gnus-util.el
index c6be59fd19f833ec5dc2d8a48fd39712123d77f1..f73af8e261cd33ec9f4063db4346ed6614ff2afb 100644 (file)
--- a/lisp/gnus/gnus-util.el
+++ b/lisp/gnus/gnus-util.el
@@ -357,24 +357,24 @@ Symbols are also allowed; their print names are used instead."
 ;; the full date if it's older)
 
 (defun gnus-seconds-today ()
-  "Return the number of seconds passed today."
-  (let ((now (decode-time)))
+  "Return the integer number of seconds passed today."
+  (let ((now (decode-time nil nil 'integer)))
     (+ (decoded-time-second now)
        (* (decoded-time-minute now) 60)
        (* (decoded-time-hour now) 3600))))
 
 (defun gnus-seconds-month ()
-  "Return the number of seconds passed this month."
-  (let ((now (decode-time)))
+  "Return the integer number of seconds passed this month."
+  (let ((now (decode-time nil nil 'integer)))
     (+ (decoded-time-second now)
        (* (decoded-time-minute now) 60)
        (* (decoded-time-hour now) 3600)
        (* (- (decoded-time-day now) 1) 3600 24))))
 
 (defun gnus-seconds-year ()
-  "Return the number of seconds passed this year."
+  "Return the integer number of seconds passed this year."
   (let* ((current (current-time))
-        (now (decode-time current))
+        (now (decode-time current nil 'integer))
         (days (format-time-string "%j" current)))
     (+ (decoded-time-second now)
        (* (decoded-time-minute now) 60)

diff --git a/lisp/gnus/message.el b/lisp/gnus/message.el
index 0a540a622144bdd0ec4e1b88ef41861902832283..48d79107ea826e992cb58aa9d8cdb91da34414d4 100644 (file)
--- a/lisp/gnus/message.el
+++ b/lisp/gnus/message.el
@@ -5508,7 +5508,7 @@ If NOW, use that time instead."
   "Make date string for the Expires header.  Expiry in DAYS days.
 
 In posting styles use `(\"Expires\" (make-expires-date 30))'."
-  (let* ((cur (decode-time))
+  (let* ((cur (decode-time nil nil 'integer))
         (nday (+ days (decoded-time-day cur))))
     (setf (decoded-time-day cur) nday)
     (message-make-date (encode-time cur))))

diff --git a/lisp/midnight.el b/lisp/midnight.el
index fa41d80a69e2cd8e81785d2de10f38cfe865bbc5..aad5236819d14f92b2c7b122110f9bb4019c361b 100644 (file)
--- a/lisp/midnight.el
+++ b/lisp/midnight.el
@@ -193,8 +193,8 @@ The default value is `clean-buffer-list'."
   :type 'hook)
 
 (defun midnight-next ()
-  "Return the number of seconds till the next midnight."
-  (pcase-let ((`(,sec ,min ,hrs) (decode-time)))
+  "Return the number of whole or partial seconds till the next midnight."
+  (pcase-let ((`(,sec ,min ,hrs) (decode-time nil nil 'integer)))
     (- (* 24 60 60) (* 60 60 hrs) (* 60 min) sec)))
 
 ;;;###autoload

diff --git a/lisp/org/org-timer.el b/lisp/org/org-timer.el
index 6529a8b0ddf7ee11be54d6b8ca59e92ea87e567f..20b33a1ef5f40ba60191798ec3f18e33d0803715 100644 (file)
--- a/lisp/org/org-timer.el
+++ b/lisp/org/org-timer.el
@@ -385,7 +385,8 @@ VALUE can be `on', `off', or `paused'."
       (message "No timer set")
     (let* ((rtime (decode-time
                   (time-subtract (timer--time org-timer-countdown-timer)
-                                 nil)))
+                                 nil)
+                  'integer))
           (rsecs (nth 0 rtime))
           (rmins (nth 1 rtime)))
       (message "%d minute(s) %d seconds left before next time out"

diff --git a/lisp/vc/ediff-mult.el b/lisp/vc/ediff-mult.el
index 1bdaca268e5e280ed67c4b1acac1ba8df23e83cc..66d14e6b06df3c0cf0cc4d9fd17488bf93f7edb8 100644 (file)
--- a/lisp/vc/ediff-mult.el
+++ b/lisp/vc/ediff-mult.el
@@ -1210,7 +1210,8 @@ behavior."
          (decoded-time-year time)
          (ediff-fill-leading-zero (decoded-time-hour time))
          (ediff-fill-leading-zero (decoded-time-minute time))
-         (ediff-fill-leading-zero (decoded-time-second time))))
+         (ediff-fill-leading-zero (time-convert (decoded-time-second time)
+                                                'integer))))
 
 ;; Draw the directories
 (defun ediff-insert-dirs-in-meta-buffer (meta-list)