4 files changed, 785 insertions, 1 deletions

diff --git a/etc/NEWS b/etc/NEWS
index bf861e21d28..078d45f7c93 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -1105,7 +1105,12 @@ the buffer, just like for the local files.
 
 ** New modes and packages
 
-*** THe new package hi-lock.el, text matching interactively entered
+*** The new package timeclock.el is a mode is for keeping track of time
+intervals.  You can use it for whatever purpose you like, but the
+typical scenario is to keep track of how much time you spend working
+on certain projects.
+
+*** The new package hi-lock.el, text matching interactively entered
 regexp's can be highlighted.  For example, 
 
   M-x highlight-regexp RET clearly RET RET 
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 2bd0fec2463..b38ea208a98 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,18 @@
+2000-08-14  Gerd Moellmann  <gerd@gnu.org>
+
+        * calendar/timeclock.el: New file.
+
+2000-08-14  David Ponce  <david@dponce.com>
+
+        * recentf.el (recent-dialog-mode-map): Bind down-mouse-1 to
+        `widget-button-click'. so that one can use left mouse button to
+        click on dialog buttons.
+
+2000-08-14  Emmanuel Briot  <briot@gnat.com>
+
+        * xml.el (xml-parse-tag, xml-parse-attlist): Do not downcase
+        identifiers, since XML is case sensitive
+        
 2000-08-12  Miles Bader  <miles@gnu.org>
         
         * comint.el (comint-output-filter): Don't bother frobbing
diff --git a/lisp/calendar/timeclock.el b/lisp/calendar/timeclock.el
new file mode 100644
index 00000000000..afab61a977c
--- /dev/null
+++ b/lisp/calendar/timeclock.el
@@ -0,0 +1,759 @@
+;;; timeclock.el --- mode for keeping track of how much you work
+
+;; Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+
+;; Author: John Wiegley <johnw@gnu.org>
+;; Created: 25 Mar 1999
+;; Version: 2.2
+;; Keywords: calendar data
+;; X-URL: http://www.emacs.org/~johnw/emacs.html
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Commentary:
+
+;; This mode is for keeping track of time intervals.  You can use it
+;; for whatever purpose you like, but the typical scenario is to keep
+;; track of how much time you spend working on certain projects.
+;;
+;; Use `timeclock-in' when you start on a project, and `timeclock-out'
+;; when you're done.  Once you've collected some data, you can use
+;; `timeclock-workday-remaining' to see how much time is left to be
+;; worked today (assuming a typical average of 8 hours a day), and
+;; `timeclock-when-to-leave' which will calculate when you're free.
+
+;; You'll probably want to bind the timeclock commands to some handy
+;; keystrokes.  At the moment, C-x t is unused in Emacs 20:
+;;
+;;   (require 'timeclock)
+;;
+;;   (define-key ctl-x-map "ti" 'timeclock-in)
+;;   (define-key ctl-x-map "to" 'timeclock-out)
+;;   (define-key ctl-x-map "tc" 'timeclock-change)
+;;   (define-key ctl-x-map "tr" 'timeclock-reread-log)
+;;   (define-key ctl-x-map "tu" 'timeclock-update-modeline)
+;;   (define-key ctl-x-map "tw" 'timeclock-when-to-leave-string)
+
+;; If you want Emacs to display the amount of time "left" to your
+;; workday in the modeline, you can either set the value of
+;; `timeclock-modeline-display' to t using M-x customize, or you
+;; can add this code to your .emacs file:
+;;
+;;   (require 'timeclock)
+;;   (timeclock-modeline-display)
+;;
+;; To cancel this modeline display at any time, just call
+;; `timeclock-modeline-display' again.
+
+;; You may also want Emacs to ask you before exiting, if you are
+;; current working on a project.  This can be done either by setting
+;; `timeclock-ask-before-exiting' to t using M-x customize (this is
+;; the default), or by adding the following to your .emacs file:
+;;
+;;   (add-hook 'kill-emacs-hook 'timeclock-query-out)
+
+;; NOTE: If you change your .timelog file without using timeclock's
+;; functions, or if you change the value of any of timeclock's
+;; customizable variables, you should run the command
+;; `timeclock-reread-log'.  This will recompute any discrepancies in
+;; your average working time, and will make sure that the various
+;; display functions return the correct value.
+
+;;; History:
+
+;;; Code:
+
+(defgroup timeclock nil
+  "Keeping track time of the time that gets spent."
+  :group 'data)
+
+;;; User Variables:
+
+(defcustom timeclock-file "~/.timelog"
+  "*The file used to store timeclock data in."
+  :type 'file
+  :group 'timeclock)
+
+(defcustom timeclock-workday (* 8 60 60)
+  "*The length of a work period."
+  :type 'integer
+  :group 'timeclock)
+
+(defcustom timeclock-relative t
+  "*When reporting time, make it relative to `timeclock-workday'?
+For example, if the length of a normal workday is eight hours, and you
+work four hours on Monday, then the amount of time \"remaining\" on
+Tuesday is twelve hours -- relative to an averaged work period of
+eight hours -- or eight hours, non-relative.  So relative time takes
+into account any discrepancy of time under-worked or overworked on
+previous days."
+  :type 'boolean
+  :group 'timeclock)
+
+(defcustom timeclock-get-project-function 'timeclock-ask-for-project
+  "*The function used to determine the name of the current project.
+When clocking in, and no project is specified, this function will be
+called to determine what the current project to be worked on is.
+If this variable is nil, no questions will be asked."
+  :type 'function
+  :group 'timeclock)
+
+(defcustom timeclock-get-reason-function 'timeclock-ask-for-reason
+  "*A function used to determine the reason for clocking out.
+When clocking out, and no reason is specified, this function will be
+called to determine what the reason is.
+If this variable is nil, no questions will be asked."
+  :type 'function
+  :group 'timeclock)
+
+(defcustom timeclock-get-workday-function nil
+  "*A function used to determine the length of today's workday.
+The first time that a user clocks in each day, this function will be
+called to determine what the length of the current workday is.  If
+nil, or equal to `timeclock-workday', nothing special will be done.
+If it is a quantity different from `timeclock-workday', however, a
+record will be output to the timelog file to note the fact that that
+day has a different length from the norm."
+  :type 'function
+  :group 'timeclock)
+
+(defcustom timeclock-ask-before-exiting t
+  "*If non-nil, ask if the user wants to clock out before exiting Emacs."
+  :set (lambda (symbol value)
+         (if value
+             (add-hook 'kill-emacs-hook 'timeclock-query-out)
+           (remove-hook 'kill-emacs-hook 'timeclock-query-out))
+         (setq timeclock-ask-before-exiting value))
+  :type 'boolean
+  :group 'timeclock)
+
+(defvar timeclock-update-timer nil
+  "The timer used to update `timeclock-mode-string'.")
+
+(defcustom timeclock-use-display-time t
+  "*If non-nil, use `display-time-hook' for doing modeline updates.
+The advantage to this is that it means one less timer has to be set
+running amok in Emacs' process space.  The disadvantage is that it
+requires you to have `display-time' running.  If you don't want to use
+`display-time', but still want the modeline to show how much time is
+left, set this variable to nil.  You will need to restart Emacs (or
+toggle the value of `timeclock-modeline-display') for the change to
+take effect."
+  :set (lambda (symbol value)
+         (let ((currently-displaying
+                (and (boundp 'timeclock-modeline-display)
+                     timeclock-modeline-display)))
+           ;; if we're changing to the state that
+           ;; `timeclock-modeline-display' is already using, don't
+           ;; bother toggling it.  This happens on the initial loading
+           ;; of timeclock.el.
+           (if (and currently-displaying
+                    (or (and value
+                             (boundp 'display-time-hook)
+                             (memq 'timeclock-update-modeline
+                                   display-time-hook))
+                        (and (not value)
+                             timeclock-update-timer)))
+               (setq currently-displaying nil))
+           (and currently-displaying
+                (set-variable timeclock-modeline-display nil))
+           (setq timeclock-use-display-time value)
+           (and currently-displaying
+                (set-variable timeclock-modeline-display t))
+           timeclock-use-display-time))
+  :type 'boolean
+  :group 'timeclock
+  :require 'time)
+
+(defcustom timeclock-first-in-hook nil
+  "*A hook run for the first \"in\" event each day.
+Note that this hook is run before recording any events.  Thus the
+value of `timeclock-hours-today', `timeclock-last-event' and the
+return value of function `timeclock-last-period' are relative previous
+to today."
+  :type 'hook
+  :group 'timeclock)
+
+(defcustom timeclock-load-hook nil
+  "*Hook that gets run after timeclock has been loaded."
+  :type 'hook
+  :group 'timeclock)
+
+(defcustom timeclock-in-hook nil
+  "*A hook run every time an \"in\" event is recorded."
+  :type 'hook
+  :group 'timeclock)
+
+(defcustom timeclock-day-over-hook nil
+  "*A hook that is run when the workday has been completed.
+This hook is only run if the current time remaining is being display
+in the modeline.  See the variable `timeclock-modeline-display'."
+  :type 'hook
+  :group 'timeclock)
+
+(defcustom timeclock-out-hook nil
+  "*A hook run every time an \"out\" event is recorded."
+  :type 'hook
+  :group 'timeclock)
+
+(defcustom timeclock-done-hook nil
+  "*A hook run every time a project is marked as completed."
+  :type 'hook
+  :group 'timeclock)
+
+(defcustom timeclock-event-hook nil
+  "*A hook run every time any event is recorded."
+  :type 'hook
+  :group 'timeclock)
+
+(defvar timeclock-last-event nil
+  "A list containing the last event that was recorded.
+The format of this list is (CODE TIME PROJECT).  PROJECT will be
+non-nil only if CODE is \"o\" or \"O\".")
+
+(defvar timeclock-last-event-workday nil
+  "The number of seconds in the workday of `timeclock-last-event'.")
+
+;;; Internal Variables:
+
+(defvar timeclock-discrepancy nil
+  "A variable containing the time discrepancy before the last event.
+Normally, timeclock assumes that you intend to work for
+`timeclock-workday' seconds every day.  Any days in which you work
+more or less than this amount is considered either a positive or
+negative discrepancy.  If you work in such a manner that the
+discrepancy is always brought back to zero, then you will by
+definition have worked an average amount equal to `timeclock-workday'
+each day.")
+
+(defvar timeclock-elapsed nil
+  "A variable containing the time elapsed for complete periods today.
+This value is not accurate enough to be useful by itself.  Rather,
+call `timeclock-workday-elapsed', to determine how much time has been
+worked so far today.  Also, if `timeclock-relative' is nil, this value
+will be the same as `timeclock-discrepancy'.")
+
+(defvar timeclock-last-period nil
+  "Integer representing the number of seconds in the last period.
+Note that you shouldn't access this value, but should use the function
+`timeclock-last-period' instead.")
+
+(defvar timeclock-mode-string nil
+  "The timeclock string (optionally) displayed in the modeline.")
+
+(defvar timeclock-day-over nil
+  "The date of the last day when notified \"day over\" for.")
+
+;;; User Functions:
+
+;;;###autoload
+(defun timeclock-modeline-display (&optional arg)
+  "Toggle display of the amount of time left today in the modeline.
+If `timeclock-use-display-time' is non-nil, the modeline will be
+updated whenever the time display is updated.  Otherwise, the
+timeclock will use its own sixty second timer to do its updating.
+With prefix ARG, turn modeline display on if and only if ARG is
+positive.  Returns the new status of timeclock modeline display
+\(non-nil means on)."
+  (interactive "P")
+  (let ((on-p (if arg
+                  (> (prefix-numeric-value arg) 0)
+                (not timeclock-modeline-display))))
+    (if on-p
+        (let ((list-entry (memq 'global-mode-string
+                                mode-line-format)))
+          (unless (memq 'timeclock-mode-string mode-line-format)
+            (setcdr list-entry
+                    (cons 'timeclock-mode-string
+                          (cdr list-entry))))
+          (unless (memq 'timeclock-update-modeline timeclock-event-hook)
+            (add-hook 'timeclock-event-hook 'timeclock-update-modeline))
+          (when timeclock-update-timer
+            (cancel-timer timeclock-update-timer)
+            (setq timeclock-update-timer nil))
+          (if (boundp 'display-time-hook)
+              (remove-hook 'display-time-hook 'timeclock-update-modeline))
+          (if timeclock-use-display-time
+              (add-hook 'display-time-hook 'timeclock-update-modeline)
+            (setq timeclock-update-timer
+                  (run-at-time nil 60 'timeclock-update-modeline))))
+      (setq mode-line-format
+            (delq 'timeclock-mode-string mode-line-format))
+      (remove-hook 'timeclock-event-hook 'timeclock-update-modeline)
+      (if (boundp 'display-time-hook)
+          (remove-hook 'display-time-hook
+                       'timeclock-update-modeline))
+      (when timeclock-update-timer
+        (cancel-timer timeclock-update-timer)
+        (setq timeclock-update-timer nil)))
+    (force-mode-line-update)
+    on-p))
+
+;; This has to be here so that the function definition of
+;; `timeclock-modeline-display' is known to the "set" function.
+(defcustom timeclock-modeline-display nil
+  "Toggle modeline display of time remaining.
+You must modify via \\[customize] for this variable to have an effect."
+  :set (lambda (symbol value)
+         (setq timeclock-modeline-display
+               (timeclock-modeline-display (or value 0))))
+  :type 'boolean
+  :group 'timeclock
+  :require 'timeclock)
+
+;;;###autoload
+(defun timeclock-in (&optional arg project find-project)
+  "Clock in, recording the current time moment in the timelog.
+With a numeric prefix ARG, record the fact that today has only that
+many hours in it to be worked.  If arg is a non-numeric prefix arg
+\(non-nil, but not a number), 0 is assumed (working on a holiday or
+weekend).  *If not called interactively, ARG should be the number of
+_seconds_ worked today*.  This feature only has effect the first time
+this function is called within a day.
+
+PROJECT as the project being clocked into.  If PROJECT is nil, and
+FIND-PROJECT is non-nil -- or the user calls `timeclock-in'
+interactively -- call the function `timeclock-get-project-function' to
+discover the name of the project."
+  (interactive
+   (list (and current-prefix-arg
+              (if (numberp current-prefix-arg)
+                  (* current-prefix-arg 60 60)
+                0))))
+  (if (equal (car timeclock-last-event) "i")
+      (error "You've already clocked in!")
+    (unless timeclock-last-event
+      (timeclock-reread-log))
+    (unless (equal (timeclock-time-to-date
+                    (cadr timeclock-last-event))
+                   (timeclock-time-to-date (current-time)))
+      (let ((workday (or (and (numberp arg) arg)
+                         (and arg 0)
+                         (and timeclock-get-workday-function
+                              (funcall timeclock-get-workday-function))
+                         timeclock-workday)))
+        (run-hooks 'timeclock-first-in-hook)
+        ;; settle the discrepancy for the new day
+        (setq timeclock-discrepancy
+              (- timeclock-discrepancy workday))
+        (if (not (= workday timeclock-workday))
+            (timeclock-log "h" (and (numberp arg)
+                                    (number-to-string arg))))))
+    (timeclock-log "i" (or project
+                           (and timeclock-get-project-function
+                                (or find-project (interactive-p))
+                                (funcall timeclock-get-project-function))))
+    (run-hooks 'timeclock-in-hook)))
+
+;;;###autoload
+(defun timeclock-out (&optional arg reason find-reason)
+  "Clock out, recording the current time moment in the timelog.
+If a prefix ARG is given, the user has completed the project that was
+begun during the last time segment.
+
+REASON is the user's reason for clocking out.  If REASON is nil, and
+FIND-REASON is non-nil -- or the user calls `timeclock-out'
+interactively -- call the function `timeclock-get-reason-function' to
+discover the reason."
+  (interactive "P")
+  (if (equal (downcase (car timeclock-last-event)) "o")
+      (error "You've already clocked out!")
+    (timeclock-log
+     (if arg "O" "o")
+     (or reason
+         (and timeclock-get-reason-function
+              (or find-reason (interactive-p))
+              (funcall timeclock-get-reason-function))))
+    (run-hooks 'timeclock-out-hook)
+    (if arg
+        (run-hooks 'timeclock-done-hook))))
+
+;;;###autoload
+(defun timeclock-status-string (&optional show-seconds today-only)
+  "Report the overall timeclock status at the present moment."
+  (interactive "P")
+  (let* ((remainder (timeclock-workday-remaining))
+         (last-in (equal (car timeclock-last-event) "i"))
+         status)
+    (setq status
+          (format "Currently %s since %s (%s), %s %s, leave at %s"
+                  (if last-in "IN" "OUT")
+                  (if show-seconds
+                      (format-time-string "%-I:%M:%S %p"
+                                          (nth 1 timeclock-last-event))
+                    (format-time-string "%-I:%M %p"
+                                        (nth 1 timeclock-last-event)))
+                  (or (nth 2 timeclock-last-event)
+                      (if last-in "**UNKNOWN**" "workday over"))
+                  (timeclock-seconds-to-string remainder show-seconds t)
+                  (if (> remainder 0)
+                      "remaining" "over")
+                  (timeclock-when-to-leave-string show-seconds today-only)))
+    (if (interactive-p)
+        (message status)
+      status)))
+
+;;;###autoload
+(defun timeclock-change (&optional arg project)
+  "Change to working on a different project, by clocking in then out.
+With a prefix ARG, consider the previous project as having been
+finished at the time of changeover.  PROJECT is the name of the last
+project you were working on."
+  (interactive "P")
+  (timeclock-out arg)
+  (timeclock-in nil project (interactive-p)))
+
+;;;###autoload
+(defun timeclock-query-out ()
+  "Ask the user before clocking out.
+This is a useful function for adding to `kill-emacs-hook'."
+  (if (and (equal (car timeclock-last-event) "i")
+           (y-or-n-p "You're currently clocking time, clock out? "))
+      (timeclock-out)))
+
+;;;###autoload
+(defun timeclock-reread-log ()
+  "Re-read the timeclock, to account for external changes.
+Returns the new value of `timeclock-discrepancy'."
+  (interactive)
+  (setq timeclock-discrepancy nil)
+  (timeclock-find-discrep)
+  (if timeclock-modeline-display
+      (timeclock-update-modeline))
+  timeclock-discrepancy)
+
+(defun timeclock-seconds-to-string (seconds &optional show-seconds
+                                            reverse-leader)
+  "Convert SECONDS into a compact time string.
+If SHOW-SECONDS is non-nil, make the resolution of the return string
+include the second count.  If REVERSE-LEADER is non-nil, it means to
+output a \"+\" if the time value is negative, rather than a \"-\".
+This is used when negative time values have an inverted meaning (such
+as with time remaining, where negative time really means overtime)."
+  (if show-seconds
+      (format "%s%d:%02d:%02d"
+              (if (< seconds 0) (if reverse-leader "+" "-") "")
+              (truncate (/ (abs seconds) 60 60))
+              (% (truncate (/ (abs seconds) 60)) 60)
+              (% (truncate (abs seconds)) 60))
+    (format "%s%d:%02d"
+            (if (< seconds 0) (if reverse-leader "+" "-") "")
+            (truncate (/ (abs seconds) 60 60))
+            (% (truncate (/ (abs seconds) 60)) 60))))
+
+(defun timeclock-workday-remaining (&optional today-only)
+  "Return a the number of seconds until the workday is complete.
+The amount returned is relative to the value of `timeclock-workday'.
+If TODAY-ONLY is non-nil, the value returned will be relative only to
+the time worked today, and not to past time.  This argument only makes
+a difference if `timeclock-relative' is non-nil."
+  (- (timeclock-find-discrep today-only)))
+
+(defun timeclock-currently-in-p ()
+  "Return non-nil if the user is currently clocked in."
+  (equal (car timeclock-last-event) "i"))
+
+;;;###autoload
+(defun timeclock-workday-remaining-string (&optional show-seconds
+                                                     today-only)
+  "Return a string representing the amount of time left today.
+Display second resolution if SHOW-SECONDS is non-nil.  If TODAY-ONLY
+is non-nil, the display will be relative only to time worked today.
+See `timeclock-relative' for more information about the meaning of
+\"relative to today\"."
+  (interactive)
+  (let ((string (timeclock-seconds-to-string
+                 (timeclock-workday-remaining today-only)
+                 show-seconds t)))
+    (if (interactive-p)
+        (message string)
+      string)))
+
+(defun timeclock-workday-elapsed (&optional relative)
+  "Return a the number of seconds worked so far today.
+If RELATIVE is non-nil, the amount returned will be relative to past
+time worked.  The default is to return only the time that has elapsed
+so far today."
+  (+ timeclock-workday
+     (timeclock-find-discrep (not relative))))
+
+;;;###autoload
+(defun timeclock-workday-elapsed-string (&optional show-seconds
+                                                   relative)
+  "Return a string representing the amount of time worked today.
+Display seconds resolution if SHOW-SECONDS is non-nil.  If RELATIVE is
+non-nil, the amount returned will be relative to past time worked."
+  (interactive)
+  (let ((string (timeclock-seconds-to-string
+                 (timeclock-workday-elapsed relative)
+                 show-seconds)))
+    (if (interactive-p)
+        (message string)
+      string)))
+
+(defun timeclock-when-to-leave (&optional today-only)
+  "Return a time value representing at when the workday ends today.
+If TODAY-ONLY is non-nil, the value returned will be relative only to
+the time worked today, and not to past time.  This argument only makes
+a difference if `timeclock-relative' is non-nil."
+  (timeclock-seconds-to-time
+   (- (timeclock-time-to-seconds (current-time))
+      (timeclock-find-discrep today-only))))
+
+;;;###autoload
+(defun timeclock-when-to-leave-string (&optional show-seconds
+                                                 today-only)
+  "Return a string representing at what time the workday ends today.
+This string is relative to the value of `timeclock-workday'.  If
+NO-MESSAGE is non-nil, no messages will be displayed in the
+minibuffer.  If SHOW-SECONDS is non-nil, the value printed/returned
+will include seconds.  If TODAY-ONLY is non-nil, the value returned
+will be relative only to the time worked today, and not to past time.
+This argument only makes a difference if `timeclock-relative' is
+non-nil."
+  (interactive)
+  (let* ((then (timeclock-when-to-leave today-only))
+         (string
+          (if show-seconds
+              (format-time-string "%-I:%M:%S %p" then)
+            (format-time-string "%-I:%M %p" then))))
+    (if (interactive-p)
+        (message string)
+      string)))
+
+;;; Internal Functions:
+
+(defvar timeclock-project-list nil)
+(defvar timeclock-last-project nil)
+
+(defun timeclock-ask-for-project ()
+  "Ask the user for the project they are clocking into."
+  (completing-read (format "Clock into which project (default \"%s\"): "
+                           (or timeclock-last-project
+                               (car timeclock-project-list)))
+                   (mapcar 'list timeclock-project-list)
+                   nil nil nil nil (or timeclock-last-project
+                                       (car timeclock-project-list))))
+
+(defvar timeclock-reason-list nil)
+
+(defun timeclock-ask-for-reason ()
+  "Ask the user for the reason they are clocking out."
+  (completing-read "Reason for clocking out: "
+                   (mapcar 'list timeclock-reason-list)))
+
+(defun timeclock-update-modeline ()
+  "Update the `timeclock-mode-string' displayed in the modeline."
+  (interactive)
+  (let* ((remainder (timeclock-workday-remaining))
+         (last-in (equal (car timeclock-last-event) "i")))
+    (when (and (< remainder 0)
+               (not (and timeclock-day-over
+                         (equal timeclock-day-over
+                                (timeclock-time-to-date
+                                 (current-time))))))
+      (setq timeclock-day-over
+            (timeclock-time-to-date (current-time)))
+      (run-hooks 'timeclock-day-over-hook))
+    (setq timeclock-mode-string
+          (format "   %c%s%c"
+                  (if last-in ?< ?[)
+                  (timeclock-seconds-to-string remainder nil t)
+                  (if last-in ?> ?])))))
+
+(defun timeclock-log (code &optional project)
+  "Log the event CODE to the timeclock log, at the time of call.
+If PROJECT is a string, it represents the project which the event is
+being logged for.  Normally only \"out\" events specify a project."
+  (save-excursion
+    (set-buffer (find-file-noselect timeclock-file))
+    (goto-char (point-max))
+    (if (not (bolp))
+        (insert "\n"))
+    (let ((now (current-time)))
+      (insert code " "
+              (format-time-string "%Y/%m/%d %H:%M:%S" now)
+              (or (and project
+                       (stringp project)
+                       (> (length project) 0)
+                       (concat " " project))
+                  "")
+              "\n")
+      (if (equal (downcase code) "o")
+          (setq timeclock-last-period
+                (- (timeclock-time-to-seconds now)
+                   (timeclock-time-to-seconds
+                    (cadr timeclock-last-event)))
+                timeclock-discrepancy
+                (+ timeclock-discrepancy
+                   timeclock-last-period)))
+      (setq timeclock-last-event (list code now project)))
+    (save-buffer)
+    (run-hooks 'timeclock-event-hook)))
+
+(defun timeclock-read-moment ()
+  "Read the moment under point from the timelog."
+  (save-excursion
+    (beginning-of-line)
+    (let ((eol (save-excursion (end-of-line) (point))))
+      (if (re-search-forward
+           (concat "^\\(.\\)\\s-+"
+                   "\\([0-9]+\\)/\\([0-9]+\\)/\\([0-9]+\\)\\s-+"
+                   "\\([0-9]+\\):\\([0-9]+\\):\\([0-9]+\\)\\s-*"
+                   "\\(.*\\)") eol t)
+          (let ((code (match-string 1))
+                (year (string-to-number (match-string 2)))
+                (mon  (string-to-number (match-string 3)))
+                (mday (string-to-number (match-string 4)))
+                (hour (string-to-number (match-string 5)))
+                (min  (string-to-number (match-string 6)))
+                (sec  (string-to-number (match-string 7)))
+                (project (match-string 8)))
+            (list code (encode-time sec min hour mday mon year)
+                  project))))))
+
+(defun timeclock-time-to-seconds (time)
+  "Convert TIME to a floating point number."
+  (+ (* (car time) 65536.0)
+     (cadr time)
+     (/ (or (car (cdr (cdr time))) 0) 1000000.0)))
+
+(defun timeclock-seconds-to-time (seconds)
+  "Convert SECONDS (a floating point number) to an Emacs time structure."
+  (list (floor seconds 65536)
+        (floor (mod seconds 65536))
+        (floor (* (- seconds (ffloor seconds)) 1000000))))
+
+(defun timeclock-time-to-date (time)
+  "Convert the TIME value to a textual date string."
+  (format-time-string "%Y/%m/%d" time))
+
+(defun timeclock-last-period (&optional moment)
+  "Return the value of the last event period.
+If the last event was a clock-in, the period will be open ended, and
+growing every second.  Otherwise, it is a fixed amount which has been
+recorded to disk.  If MOMENT is non-nil, use that as the current time.
+This is only provided for coherency when used by
+`timeclock-discrepancy'."
+  (if (equal (car timeclock-last-event) "i")
+      (- (timeclock-time-to-seconds (or moment (current-time)))
+         (timeclock-time-to-seconds
+          (cadr timeclock-last-event)))
+    timeclock-last-period))
+
+(defun timeclock-find-discrep (&optional today-only)
+  "Find overall discrepancy from `timeclock-workday' (in seconds).
+If TODAY-ONLY is non-nil, the discrepancy will be not be relative, and
+will correspond only to the amount of time elapsed today.  This is
+identical to what would be return if `timeclock-relative' were nil."
+  (let* ((now (current-time)) (first t)
+         (todays-date (timeclock-time-to-date now))
+         accum event beg last-date
+         last-date-limited last-date-seconds avg)
+    (unless timeclock-discrepancy
+      (setq timeclock-project-list nil
+            timeclock-last-project nil
+            timeclock-reason-list nil)
+      (save-excursion
+        (set-buffer (find-file-noselect timeclock-file))
+        (goto-char (point-min))
+        (setq accum 0)
+        (setq timeclock-elapsed 0)
+        (while (setq event (timeclock-read-moment))
+          (cond ((equal (car event) "h")
+                 (setq last-date-limited
+                       (timeclock-time-to-date (cadr event))
+                       last-date-seconds
+                       (string-to-number (nth 2 event))))
+                ((equal (car event) "i")
+                 (when (and (nth 2 event)
+                            (> (length (nth 2 event)) 0))
+                   (add-to-list 'timeclock-project-list (nth 2 event))
+                   (setq timeclock-last-project (nth 2 event)))
+                 (let ((date (timeclock-time-to-date (cadr event))))
+                   (if (and last-date
+                            timeclock-relative
+                            (not (equal date last-date)))
+                       (setq accum (- accum
+                                      (if last-date-limited
+                                          last-date-seconds
+                                        timeclock-workday)))
+                     (unless (or last-date (not first))
+                       (setq first nil
+                             accum (- accum
+                                      (if last-date-limited
+                                          last-date-seconds
+                                        timeclock-workday)))))
+                   (setq last-date date
+                         last-date-limited nil)
+                   (if beg
+                       (error "Error in format of timelog file!")
+                     (setq beg (timeclock-time-to-seconds (cadr event))))))
+                ((equal (downcase (car event)) "o")
+                 (if (and (nth 2 event)
+                          (> (length (nth 2 event)) 0))
+                     (add-to-list 'timeclock-reason-list (nth 2 event)))
+                 (if (or timeclock-relative
+                         (equal last-date todays-date))
+                     (if (not beg)
+                         (error "Error in format of timelog file!")
+                       (setq timeclock-last-period
+                             (- (timeclock-time-to-seconds (cadr event))
+                                beg)
+                             accum (+ timeclock-last-period accum)
+                             beg nil)))
+                 (if (equal last-date todays-date)
+                     (setq timeclock-elapsed
+                           (+ timeclock-last-period timeclock-elapsed)))))
+          (setq timeclock-last-event event
+                timeclock-last-event-workday
+                (if (equal (timeclock-time-to-date now)
+                           last-date-limited)
+                    last-date-seconds
+                  timeclock-workday))
+          (forward-line))
+        (setq timeclock-discrepancy accum)))
+    (setq accum (if today-only
+                    timeclock-elapsed
+                  timeclock-discrepancy))
+    (if timeclock-last-event
+        (if (equal (car timeclock-last-event) "i")
+            (setq accum (+ accum (timeclock-last-period now)))
+          (if (not (equal (timeclock-time-to-date
+                           (cadr timeclock-last-event))
+                          (timeclock-time-to-date now)))
+              (setq accum (- accum timeclock-last-event-workday)))))
+    (setq accum
+          (- accum
+             (if (and timeclock-last-event
+                      (equal (timeclock-time-to-date
+                              (cadr timeclock-last-event))
+                             (timeclock-time-to-date now)))
+                 timeclock-last-event-workday
+               timeclock-workday)))))
+
+(provide 'timeclock)
+
+(run-hooks 'timeclock-load-hook)
+
+;; make sure we know the list of reasons, projects, and have computed
+;; the last event and current discrepancy.
+(if (file-readable-p timeclock-file)
+    (timeclock-reread-log))
+
+;;; timeclock.el ends here
diff --git a/src/ChangeLog b/src/ChangeLog
index 5d6e8ba61e1..93f8c924f15 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,8 @@
+2000-08-14  Gerd Moellmann  <gerd@gnu.org>
+
+        * keymap.c (push_key_description): If C without modifiers is < 32, 
+        make sure to print `C-' before `M-', like in the manual.
+
 2000-08-11  Gerd Moellmann  <gerd@gnu.org>
 
         * fns.c (hashfn_eq, hashfn_eql): Don't handle strings specially