Improve time stamp handling, and be more consistent about it.

This implements a suggestion made in:
http://lists.gnu.org/archive/html/emacs-devel/2014-10/msg00587.html
Among other things, this means timer.el no longer needs to
autoload the time-date module.
* doc/lispref/os.texi (Time of Day, Time Conversion, Time Parsing)
(Processor Run Time, Time Calculations):
Document the new behavior, plus be clearer about the old behavior.
(Idle Timers): Take advantage of new functionality.
* etc/NEWS: Document the changes.
* lisp/allout-widgets.el (allout-elapsed-time-seconds): Doc fix.
* lisp/arc-mode.el (archive-ar-summarize):
* lisp/calendar/time-date.el (seconds-to-time, days-to-time, time-since):
* lisp/emacs-lisp/timer.el (timer-relative-time, timer-event-handler)
(run-at-time, with-timeout-suspend, with-timeout-unsuspend):
* lisp/net/tramp.el (tramp-time-less-p, tramp-time-subtract):
* lisp/proced.el (proced-time-lessp):
* lisp/timezone.el (timezone-time-from-absolute):
* lisp/type-break.el (type-break-schedule, type-break-time-sum):
Simplify by using new functionality.
* lisp/calendar/cal-dst.el (calendar-next-time-zone-transition):
Do not return time values in obsolete and undocumented (HI . LO)
format; use (HI LO) instead.
* lisp/calendar/time-date.el (with-decoded-time-value):
Treat 'nil' as current time.  This is mostly for XEmacs.
(encode-time-value, with-decoded-time-value): Obsolete.
(time-add, time-subtract, time-less-p): Use no-op autoloads, for
XEmacs.  Define only if XEmacs, as they're now C builtins in Emacs.
* lisp/ldefs-boot.el: Update to match new time-date.el
* lisp/proced.el: Do not require time-date.
* src/editfns.c (invalid_time): New function.
Use it instead of 'error ("Invalid time specification")'.
(time_add, time_subtract, time_arith, Ftime_add, Ftime_less_p)
(decode_float_time, lisp_to_timespec, lisp_time_struct):
New functions.
(make_time_tail, make_time): Remove.  All uses changed to use
new functions or plain list4i.
(disassemble_lisp_time): Return effective length if successful.
Check that LOW is an integer, if it's combined with other components.
(decode_time_components): Decode into struct lisp_time, not
struct timespec, so that we can support a wide set of times
regardless of whether time_t is signed.  Decode plain numbers
as seconds since the Epoch, and nil as the current time.
(lisp_time_argument, lisp_seconds_argument, Ffloat_time):
Reimplement in terms of new functions.
(Fencode_time): Just use list2i.
(syms_of_editfns): Add time-add, time-subtract, time-less-p.
* src/keyboard.c (decode_timer): Don't allow the new formats (floating
point or nil) in timers.
* src/systime.h (LO_TIME_BITS): New constant.  Use it everywhere in
place of the magic number '16'.
(struct lisp_time): New type.
(decode_time_components): Use it.
(lisp_to_timespec): New decl.

11 files changed, 129 insertions, 161 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 7659d3c2235..7e516b95c61 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,31 @@
+2014-11-17  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Improve time stamp handling, and be more consistent about it.
+        This implements a suggestion made in:
+        http://lists.gnu.org/archive/html/emacs-devel/2014-10/msg00587.html
+        Among other things, this means timer.el no longer needs to
+        autoload the time-date module.
+        * allout-widgets.el (allout-elapsed-time-seconds): Doc fix.
+        * arc-mode.el (archive-ar-summarize):
+        * calendar/time-date.el (seconds-to-time, days-to-time, time-since):
+        * emacs-lisp/timer.el (timer-relative-time, timer-event-handler)
+        (run-at-time, with-timeout-suspend, with-timeout-unsuspend):
+        * net/tramp.el (tramp-time-less-p, tramp-time-subtract):
+        * proced.el (proced-time-lessp):
+        * timezone.el (timezone-time-from-absolute):
+        * type-break.el (type-break-schedule, type-break-time-sum):
+        Simplify by using new functionality.
+        * calendar/cal-dst.el (calendar-next-time-zone-transition):
+        Do not return time values in obsolete and undocumented (HI . LO)
+        format; use (HI LO) instead.
+        * calendar/time-date.el (with-decoded-time-value):
+        Treat 'nil' as current time.  This is mostly for XEmacs.
+        (encode-time-value, with-decoded-time-value): Obsolete.
+        (time-add, time-subtract, time-less-p): Use no-op autoloads, for
+        XEmacs.  Define only if XEmacs, as they're now C builtins in Emacs.
+        * ldefs-boot.el: Update to match new time-date.el
+        * proced.el: Do not require time-date.
+
 2014-11-16  Lars Magne Ingebrigtsen  <larsi@gnus.org>
 
         * net/eww.el (eww-mode): Make the buffer read-only.
diff --git a/lisp/allout-widgets.el b/lisp/allout-widgets.el
index f2dcdb40425..25abf3f9252 100644
--- a/lisp/allout-widgets.el
+++ b/lisp/allout-widgets.el
@@ -2342,9 +2342,9 @@ We use a caching strategy, so the caller doesn't need to do so."
       got)))
 
 ;;;_ : Miscellaneous
-;;;_  > allout-elapsed-time-seconds (triple)
+;;;_  > allout-elapsed-time-seconds (time-value time-value)
 (defun allout-elapsed-time-seconds (end start)
-  "Return seconds between `current-time' style time START/END triples."
+  "Return seconds between START/END time values."
   (let ((elapsed (time-subtract end start)))
     (float-time elapsed)))
 ;;;_  > allout-frame-property (frame property)
diff --git a/lisp/arc-mode.el b/lisp/arc-mode.el
index ef155ee2b99..a9f0ec71b51 100644
--- a/lisp/arc-mode.el
+++ b/lisp/arc-mode.el
@@ -2181,11 +2181,7 @@ This doesn't recover lost files, it just undoes changes in the buffer itself."
             (size (string-to-number (match-string 6))))
         ;; Move to the beginning of the data.
         (goto-char (match-end 0))
-        (setq time
-              (format-time-string
-               "%Y-%m-%d %H:%M"
-               (let ((high (truncate (/ time 65536))))
-                 (list high (truncate (- time (* 65536.0 high)))))))
+        (setq time (format-time-string "%Y-%m-%d %H:%M" time))
         (setq extname
               (cond ((equal name "//              ")
                      (propertize ".<ExtNamesTable>." 'face 'italic))
diff --git a/lisp/calendar/cal-dst.el b/lisp/calendar/cal-dst.el
index e3cb690306e..2a9cdee301d 100644
--- a/lisp/calendar/cal-dst.el
+++ b/lisp/calendar/cal-dst.el
@@ -179,6 +179,7 @@ Return nil if no such transition can be found."
          (if (eq (car (current-time-zone probe)) hi-utc-diff)
              (setq hi probe)
            (setq lo probe)))
+       (setcdr hi (list (cdr hi)))
        hi))))
 
 (autoload 'calendar-persian-to-absolute "cal-persia")
diff --git a/lisp/calendar/time-date.el b/lisp/calendar/time-date.el
index 82bc05f299f..100e856469a 100644
--- a/lisp/calendar/time-date.el
+++ b/lisp/calendar/time-date.el
@@ -30,10 +30,9 @@
 ;; value equal to HIGH * 2^16 + LOW + USEC * 10^-6 + PSEC * 10^-12
 ;; seconds, where missing components are treated as zero.  HIGH can be
 ;; negative, either because the value is a time difference, or because
-;; the machine supports negative time stamps that fall before the epoch.
-;; The macro `with-decoded-time-value' and the function
-;; `encode-time-value' make it easier to deal with these formats.
-;; See `time-subtract' for an example of how to use them.
+;; it represents a time stamp before the epoch.  Typically, there are
+;; more time values than the underlying system time type supports,
+;; but the reverse can also be true.
 
 ;;; Code:
 
@@ -71,6 +70,7 @@ list (HIGH LOW MICRO PICO)."
                           ,low ,micro)
                         (when pico `(,pico))
                         (when type `(,type)))
+           (or ,gensym (setq ,gensym (current-time)))
            (if (consp ,gensym)
                (progn
                  (setq ,low (pop ,gensym))
@@ -108,6 +108,10 @@ it is assumed that PICO was omitted and should be treated as zero."
    ((eq type 3) (list high low micro pico))
    ((null type) (encode-time-value high low micro 0 pico))))
 
+(when (featurep 'emacs)
+  (make-obsolete 'encode-time-value nil "25.1")
+  (make-obsolete 'with-decoded-time-value nil "25.1"))
+
 (autoload 'parse-time-string "parse-time")
 (autoload 'timezone-make-date-arpa-standard "timezone")
 
@@ -158,47 +162,17 @@ TIME defaults to the current time."
 
 ;;;###autoload
 (defun seconds-to-time (seconds)
-  "Convert SECONDS (a floating point number) to a time value."
-  (let* ((usec (* 1000000 (mod seconds 1)))
-         (ps (round (* 1000000 (mod usec 1))))
-         (us (floor usec))
-         (lo (floor (mod seconds 65536)))
-         (hi (floor seconds 65536)))
-    (if (eq ps 1000000)
-        (progn
-          (setq ps 0)
-          (setq us (1+ us))
-          (if (eq us 1000000)
-              (progn
-                (setq us 0)
-                (setq lo (1+ lo))
-                (if (eq lo 65536)
-                    (progn
-                      (setq lo 0)
-                      (setq hi (1+ hi))))))))
-    (list hi lo us ps)))
-
-;;;###autoload
-(defun time-less-p (t1 t2)
-  "Return non-nil if time value T1 is earlier than time value T2."
-  (with-decoded-time-value ((high1 low1 micro1 pico1 type1 t1)
-                            (high2 low2 micro2 pico2 type2 t2))
-    (or (< high1 high2)
-        (and (= high1 high2)
-             (or (< low1 low2)
-                 (and (= low1 low2)
-                      (or (< micro1 micro2)
-                          (and (= micro1 micro2)
-                               (< pico1 pico2)))))))))
+  "Convert SECONDS to a time value."
+  (time-add 0 seconds))
 
 ;;;###autoload
 (defun days-to-time (days)
   "Convert DAYS into a time value."
-  (let* ((seconds (* 1.0 days 60 60 24))
-         (high (condition-case nil (floor (/ seconds 65536))
-                 (range-error most-positive-fixnum))))
-    (list high (condition-case nil (floor (- seconds (* 1.0 high 65536)))
-                 (range-error 65535)))))
+  (let ((time (condition-case nil (seconds-to-time (* 86400.0 days))
+                (range-error (list most-positive-fixnum 65535)))))
+    (if (integerp days)
+        (setcdr (cdr time) nil))
+    time))
 
 ;;;###autoload
 (defun time-since (time)
@@ -207,53 +181,71 @@ TIME should be either a time value or a date-time string."
   (when (stringp time)
     ;; Convert date strings to internal time.
     (setq time (date-to-time time)))
-  (time-subtract (current-time) time))
+  (time-subtract nil time))
 
 ;;;###autoload
 (defalias 'subtract-time 'time-subtract)
 
-;;;###autoload
-(defun time-subtract (t1 t2)
-  "Subtract two time values, T1 minus T2.
-Return the difference in the format of a time value."
-  (with-decoded-time-value ((high low micro pico type t1)
-                            (high2 low2 micro2 pico2 type2 t2))
-    (setq high (- high high2)
-          low (- low low2)
-          micro (- micro micro2)
-          pico (- pico pico2)
-          type (max type type2))
-    (when (< pico 0)
-      (setq micro (1- micro)
-            pico (+ pico 1000000)))
-    (when (< micro 0)
-      (setq low (1- low)
-            micro (+ micro 1000000)))
-    (when (< low 0)
-      (setq high (1- high)
-            low (+ low 65536)))
-    (encode-time-value high low micro pico type)))
+;; These autoloads do nothing in Emacs 25, where the functions are builtin.
+;;;###autoload(autoload 'time-add "time-date")
+;;;###autoload(autoload 'time-subtract "time-date")
+;;;###autoload(autoload 'time-less-p "time-date")
 
-;;;###autoload
-(defun time-add (t1 t2)
-  "Add two time values T1 and T2.  One should represent a time difference."
-  (with-decoded-time-value ((high low micro pico type t1)
-                            (high2 low2 micro2 pico2 type2 t2))
-    (setq high (+ high high2)
-          low (+ low low2)
-          micro (+ micro micro2)
-          pico (+ pico pico2)
-          type (max type type2))
-    (when (>= pico 1000000)
-      (setq micro (1+ micro)
-            pico (- pico 1000000)))
-    (when (>= micro 1000000)
-      (setq low (1+ low)
-            micro (- micro 1000000)))
-    (when (>= low 65536)
-      (setq high (1+ high)
-            low (- low 65536)))
-    (encode-time-value high low micro pico type)))
+(eval-when-compile
+  (when (not (featurep 'emacs))
+
+    (defun time-add (t1 t2)
+      "Add two time values T1 and T2.  One should represent a time difference."
+      (with-decoded-time-value ((high low micro pico type t1)
+                                (high2 low2 micro2 pico2 type2 t2))
+        (setq high (+ high high2)
+              low (+ low low2)
+              micro (+ micro micro2)
+              pico (+ pico pico2)
+              type (max type type2))
+        (when (>= pico 1000000)
+          (setq micro (1+ micro)
+                pico (- pico 1000000)))
+        (when (>= micro 1000000)
+          (setq low (1+ low)
+                micro (- micro 1000000)))
+        (when (>= low 65536)
+          (setq high (1+ high)
+                low (- low 65536)))
+        (encode-time-value high low micro pico type)))
+
+    (defun time-subtract (t1 t2)
+      "Subtract two time values, T1 minus T2.
+Return the difference in the format of a time value."
+      (with-decoded-time-value ((high low micro pico type t1)
+                                (high2 low2 micro2 pico2 type2 t2))
+        (setq high (- high high2)
+              low (- low low2)
+              micro (- micro micro2)
+              pico (- pico pico2)
+              type (max type type2))
+        (when (< pico 0)
+          (setq micro (1- micro)
+                pico (+ pico 1000000)))
+        (when (< micro 0)
+          (setq low (1- low)
+                micro (+ micro 1000000)))
+        (when (< low 0)
+          (setq high (1- high)
+                low (+ low 65536)))
+        (encode-time-value high low micro pico type)))
+
+    (defun time-less-p (t1 t2)
+      "Return non-nil if time value T1 is earlier than time value T2."
+      (with-decoded-time-value ((high1 low1 micro1 pico1 type1 t1)
+                                (high2 low2 micro2 pico2 type2 t2))
+        (or (< high1 high2)
+            (and (= high1 high2)
+                 (or (< low1 low2)
+                     (and (= low1 low2)
+                          (or (< micro1 micro2)
+                              (and (= micro1 micro2)
+                                   (< pico1 pico2)))))))))))
 
 ;;;###autoload
 (defun date-to-day (date)
diff --git a/lisp/emacs-lisp/timer.el b/lisp/emacs-lisp/timer.el
index 7fc6bf7b920..a189d242ac4 100644
--- a/lisp/emacs-lisp/timer.el
+++ b/lisp/emacs-lisp/timer.el
@@ -125,9 +125,7 @@ of SECS seconds since the epoch.  SECS may be a fraction."
   "Advance TIME by SECS seconds and optionally USECS microseconds
 and PSECS picoseconds.  SECS may be either an integer or a
 floating point number."
-  (let ((delta (if (floatp secs)
-                   (seconds-to-time secs)
-                 (list (floor secs 65536) (mod secs 65536)))))
+  (let ((delta secs))
     (if (or usecs psecs)
         (setq delta (time-add delta (list 0 0 (or usecs 0) (or psecs 0)))))
     (time-add time delta)))
@@ -307,8 +305,8 @@ This function is called, by name, directly by the C code."
               ;; perhaps because Emacs was suspended for a long time,
               ;; limit how many times things get repeated.
               (if (and (numberp timer-max-repeats)
-                       (< 0 (timer-until timer (current-time))))
-                  (let ((repeats (/ (timer-until timer (current-time))
+                       (< 0 (timer-until timer nil)))
+                  (let ((repeats (/ (timer-until timer nil)
                                     (timer--repeat-delay timer))))
                     (if (> repeats timer-max-repeats)
                         (timer-inc-time timer (* (timer--repeat-delay timer)
@@ -374,13 +372,13 @@ This function returns a timer object which you can use in `cancel-timer'."
 
   ;; Handle numbers as relative times in seconds.
   (if (numberp time)
-      (setq time (timer-relative-time (current-time) time)))
+      (setq time (timer-relative-time nil time)))
 
   ;; Handle relative times like "2 hours 35 minutes"
   (if (stringp time)
       (let ((secs (timer-duration time)))
         (if secs
-            (setq time (timer-relative-time (current-time) secs)))))
+            (setq time (timer-relative-time nil secs)))))
 
   ;; Handle "11:23pm" and the like.  Interpret it as meaning today
   ;; which admittedly is rather stupid if we have passed that time
@@ -486,7 +484,7 @@ The value is a list that the debugger can pass to `with-timeout-unsuspend'
 when it exits, to make these timers start counting again."
   (mapcar (lambda (timer)
             (cancel-timer timer)
-            (list timer (time-subtract (timer--time timer) (current-time))))
+            (list timer (time-subtract (timer--time timer) nil)))
           with-timeout-timers))
 
 (defun with-timeout-unsuspend (timer-spec-list)
@@ -495,7 +493,7 @@ The argument should be a value previously returned by `with-timeout-suspend'."
   (dolist (elt timer-spec-list)
     (let ((timer (car elt))
           (delay (cadr elt)))
-      (timer-set-time timer (time-add (current-time) delay))
+      (timer-set-time timer (time-add nil delay))
       (timer-activate timer))))
 
 (defun y-or-n-p-with-timeout (prompt seconds default-value)
diff --git a/lisp/ldefs-boot.el b/lisp/ldefs-boot.el
index b78c906b450..f60d6608f7e 100644
--- a/lisp/ldefs-boot.el
+++ b/lisp/ldefs-boot.el
@@ -27478,15 +27478,10 @@ If DATE lacks timezone information, GMT is assumed.
  (autoload 'time-to-seconds "time-date"))
 
 (autoload 'seconds-to-time "time-date" "\
-Convert SECONDS (a floating point number) to a time value.
+Convert SECONDS to a time value.
 
 \(fn SECONDS)" nil nil)
 
-(autoload 'time-less-p "time-date" "\
-Return non-nil if time value T1 is earlier than time value T2.
-
-\(fn T1 T2)" nil nil)
-
 (autoload 'days-to-time "time-date" "\
 Convert DAYS into a time value.
 
@@ -27499,17 +27494,9 @@ TIME should be either a time value or a date-time string.
 \(fn TIME)" nil nil)
 
 (defalias 'subtract-time 'time-subtract)
-
-(autoload 'time-subtract "time-date" "\
-Subtract two time values, T1 minus T2.
-Return the difference in the format of a time value.
-
-\(fn T1 T2)" nil nil)
-
-(autoload 'time-add "time-date" "\
-Add two time values T1 and T2.  One should represent a time difference.
-
-\(fn T1 T2)" nil nil)
+(autoload 'time-add "time-date")
+(autoload 'time-subtract "time-date")
+(autoload 'time-less-p "time-date")
 
 (autoload 'date-to-day "time-date" "\
 Return the number of days between year 1 and DATE.
diff --git a/lisp/net/tramp.el b/lisp/net/tramp.el
index 5889743e28b..01cd8191169 100644
--- a/lisp/net/tramp.el
+++ b/lisp/net/tramp.el
@@ -4236,25 +4236,15 @@ Invokes `password-read' if available, `read-passwd' else."
     ("oct" . 10) ("nov" . 11) ("dec" . 12))
   "Alist mapping month names to integers.")
 
-;; FIXME: Shouldn't this also look at any subseconds parts of T1 and T2?
 ;;;###tramp-autoload
 (defun tramp-time-less-p (t1 t2)
   "Say whether time value T1 is less than time value T2."
-  (unless t1 (setq t1 '(0 0)))
-  (unless t2 (setq t2 '(0 0)))
-  (or (< (car t1) (car t2))
-      (and (= (car t1) (car t2))
-           (< (nth 1 t1) (nth 1 t2)))))
+  (time-less-p (or t1 0) (or t2 0)))
 
-;; FIXME: Shouldn't this also look at any subseconds parts of T1 and T2?
 (defun tramp-time-subtract (t1 t2)
   "Subtract two time values.
 Return the difference in the format of a time value."
-  (unless t1 (setq t1 '(0 0)))
-  (unless t2 (setq t2 '(0 0)))
-  (let ((borrow (< (cadr t1) (cadr t2))))
-    (list (- (car t1) (car t2) (if borrow 1 0))
-          (- (+ (if borrow 65536 0) (cadr t1)) (cadr t2)))))
+  (time-subtract (or t1 0) (or t2 0)))
 
 ;;;###tramp-autoload
 (defun tramp-time-diff (t1 t2)
diff --git a/lisp/proced.el b/lisp/proced.el
index 592c0d066c7..188b8c354c6 100644
--- a/lisp/proced.el
+++ b/lisp/proced.el
@@ -49,8 +49,6 @@
 
 ;;; Code:
 
-(require 'time-date)                 ; for `with-decoded-time-value'
-
 (defgroup proced nil
   "Proced mode."
   :group 'processes
@@ -1186,17 +1184,8 @@ Return nil otherwise."
 (defun proced-time-lessp (t1 t2)
   "Return t if time value T1 is less than time value T2.
 Return `equal' if T1 equals T2.  Return nil otherwise."
-  (with-decoded-time-value ((high1 low1 micro1 pico1 type1 t1)
-                            (high2 low2 micro2 pico2 type2 t2))
-    (cond ((< high1 high2))
-          ((< high2 high1) nil)
-          ((< low1 low2))
-          ((< low2 low1) nil)
-          ((< micro1 micro2))
-          ((< micro2 micro1) nil)
-          ((< pico1 pico2))
-          ((< pico2 pico1) nil)
-          (t 'equal))))
+  (or (time-less-p t1 t2)
+      (if (not (time-less-p t2 t1)) 'equal)))
 
 ;;; Sorting
 
diff --git a/lisp/timezone.el b/lisp/timezone.el
index 1135092b039..8ff43966f69 100644
--- a/lisp/timezone.el
+++ b/lisp/timezone.el
@@ -295,13 +295,9 @@ Gregorian date Sunday, December 31, 1 BC."
             ;; (timezone-absolute-from-gregorian 1 1 1970)
          (days (- date current-time-origin))
          (seconds-per-day (float 86400))
-         (seconds (+ seconds (* days seconds-per-day)))
-         (current-time-arithmetic-base (float 65536))
-         (hi (floor (/ seconds current-time-arithmetic-base)))
-         (hibase (* hi current-time-arithmetic-base))
-         (lo (floor (- seconds hibase))))
-     (and (< (abs (- seconds (+ hibase lo))) 2) ;; Check for integer overflow.
-          (cons hi lo))))
+         (day-seconds (* days seconds-per-day)))
+    (condition-case nil (time-add day-seconds seconds)
+      (range-error))))
 
 (defun timezone-time-zone-from-absolute (date seconds)
   "Compute the local time zone for DATE at time SECONDS after midnight.
diff --git a/lisp/type-break.el b/lisp/type-break.el
index f954e5d1c26..a3af407bf17 100644
--- a/lisp/type-break.el
+++ b/lisp/type-break.el
@@ -604,8 +604,7 @@ INTERVAL is the full length of an interval (defaults to TIME)."
   (type-break-time-warning-schedule time 'reset)
   (type-break-run-at-time (max 1 time) nil 'type-break-alarm)
   (setq type-break-time-next-break
-        (type-break-time-sum (or start (current-time))
-                             (or interval time))))
+        (type-break-time-sum start (or interval time))))
 
 (defun type-break-cancel-schedule ()
   (type-break-cancel-time-warning-schedule)
@@ -961,19 +960,11 @@ FRAC should be the inverse of the fractional value; for example, a value of
 (defun type-break-time-difference (a b)
   (round (float-time (time-subtract b a))))
 
-;; Return (in a new list the same in structure to that returned by
-;; `current-time') the sum of the arguments.  Each argument may be a time
-;; list or a single integer, a number of seconds.
-;; This function keeps the high and low 16 bits of the seconds properly
-;; balanced so that the lower value never exceeds 16 bits.  Otherwise, when
-;; the result is passed to `current-time-string' it will toss some of the
-;; "low" bits and format the time incorrectly.
+;; Return a time value that is the sum of the time-value arguments.
 (defun type-break-time-sum (&rest tmlist)
-  (let ((sum '(0 0 0)))
+  (let ((sum '(0 0)))
     (dolist (tem tmlist)
-      (setq sum (time-add sum (if (integerp tem)
-                                  (list (floor tem 65536) (mod tem 65536))
-                                tem))))
+      (setq sum (time-add sum tem)))
     sum))
 
 (defun type-break-time-stamp (&optional when)