[Emacs-diffs] Changes to emacs/lisp/pgg.el,v

[Glenn Morris]

CVSROOT:        /sources/emacs
Module name:    emacs
Changes by:     Glenn Morris <gm>       07/11/27 04:20:20

Index: pgg.el
===================================================================
RCS file: /sources/emacs/emacs/lisp/pgg.el,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -b -r1.8 -r1.9
--- pgg.el      26 Jul 2007 05:26:31 -0000      1.8
+++ pgg.el      27 Nov 2007 04:20:20 -0000      1.9
@@ -40,6 +40,84 @@
 ;;; @ utility functions
 ;;;
 
+(eval-when-compile
+  (unless (featurep 'xemacs)
+    (defalias 'pgg-run-at-time 'run-at-time)
+    (defalias 'pgg-cancel-timer 'cancel-timer))
+
+  (when (featurep 'xemacs)
+    (defmacro pgg-run-at-time-1 (time repeat function args)
+      (if (condition-case nil
+             (let ((delete-itimer 'delete-itimer)
+                   (itimer-driver-start 'itimer-driver-start)
+                   (itimer-value 'itimer-value)
+                   (start-itimer 'start-itimer))
+               (unless (or (symbol-value 'itimer-process)
+                           (symbol-value 'itimer-timer))
+                 (funcall itimer-driver-start))
+               ;; Check whether there is a bug to which the difference of
+               ;; the present time and the time when the itimer driver was
+               ;; woken up is subtracted from the initial itimer value.
+               (let* ((inhibit-quit t)
+                      (ctime (current-time))
+                      (itimer-timer-last-wakeup
+                       (prog1
+                           ctime
+                         (setcar ctime (1- (car ctime)))))
+                      (itimer-list nil)
+                      (itimer (funcall start-itimer "pgg-run-at-time"
+                                       'ignore 5)))
+                 (sleep-for 0.1) ;; Accept the timeout interrupt.
+                 (prog1
+                     (> (funcall itimer-value itimer) 0)
+                   (funcall delete-itimer itimer))))
+           (error nil))
+         `(let ((time ,time))
+            (apply #'start-itimer "pgg-run-at-time"
+                   ,function (if time (max time 1e-9) 1e-9)
+                   ,repeat nil t ,args)))
+      `(let ((time ,time)
+            (itimers (list nil)))
+        (setcar
+         itimers
+         (apply #'start-itimer "pgg-run-at-time"
+                (lambda (itimers repeat function &rest args)
+                  (let ((itimer (car itimers)))
+                    (if repeat
+                        (progn
+                          (set-itimer-function
+                           itimer
+                           (lambda (itimer repeat function &rest args)
+                             (set-itimer-restart itimer repeat)
+                             (set-itimer-function itimer function)
+                             (set-itimer-function-arguments itimer args)
+                             (apply function args)))
+                          (set-itimer-function-arguments
+                           itimer
+                           (append (list itimer repeat function) args)))
+                      (set-itimer-function
+                       itimer
+                       (lambda (itimer function &rest args)
+                         (delete-itimer itimer)
+                         (apply function args)))
+                      (set-itimer-function-arguments
+                       itimer
+                       (append (list itimer function) args)))))
+                1e-9 (if time (max time 1e-9) 1e-9)
+                nil t itimers ,repeat ,function ,args))))
+
+    (defun pgg-run-at-time (time repeat function &rest args)
+      "Emulating function run as `run-at-time'.
+TIME should be nil meaning now, or a number of seconds from now.
+Return an itimer object which can be used in either `delete-itimer'
+or `cancel-timer'."
+      (pgg-run-at-time-1 time repeat function args))
+    (defun pgg-cancel-timer (timer)
+      "Emulate cancel-timer for xemacs."
+      (let ((delete-itimer 'delete-itimer))
+        (funcall delete-itimer timer)))
+    ))
+
 (defun pgg-invoke (func scheme &rest args)
   (progn
     (require (intern (format "pgg-%s" scheme)))
@@ -153,6 +231,8 @@
   (defun pgg-clear-string (string)
     (fillarray string ?_)))
 
+(declare-function pgg-clear-string "pgg" (string))
+
 (defun pgg-remove-passphrase-from-cache (key &optional notruncate)
   "Omit passphrase associated with KEY in time-limited passphrase cache.
 
@@ -177,85 +257,6 @@
       (pgg-cancel-timer old-timer)
       (unintern interned-timer-key pgg-pending-timers))))
 
-(eval-when-compile
-  (defmacro pgg-run-at-time-1 (time repeat function args)
-    (when (featurep 'xemacs)
-      (if (condition-case nil
-             (let ((delete-itimer 'delete-itimer)
-                   (itimer-driver-start 'itimer-driver-start)
-                   (itimer-value 'itimer-value)
-                   (start-itimer 'start-itimer))
-               (unless (or (symbol-value 'itimer-process)
-                           (symbol-value 'itimer-timer))
-                 (funcall itimer-driver-start))
-               ;; Check whether there is a bug to which the difference of
-               ;; the present time and the time when the itimer driver was
-               ;; woken up is subtracted from the initial itimer value.
-               (let* ((inhibit-quit t)
-                      (ctime (current-time))
-                      (itimer-timer-last-wakeup
-                       (prog1
-                           ctime
-                         (setcar ctime (1- (car ctime)))))
-                      (itimer-list nil)
-                      (itimer (funcall start-itimer "pgg-run-at-time"
-                                       'ignore 5)))
-                 (sleep-for 0.1) ;; Accept the timeout interrupt.
-                 (prog1
-                     (> (funcall itimer-value itimer) 0)
-                   (funcall delete-itimer itimer))))
-           (error nil))
-         `(let ((time ,time))
-            (apply #'start-itimer "pgg-run-at-time"
-                   ,function (if time (max time 1e-9) 1e-9)
-                   ,repeat nil t ,args)))
-      `(let ((time ,time)
-            (itimers (list nil)))
-        (setcar
-         itimers
-         (apply #'start-itimer "pgg-run-at-time"
-                (lambda (itimers repeat function &rest args)
-                  (let ((itimer (car itimers)))
-                    (if repeat
-                        (progn
-                          (set-itimer-function
-                           itimer
-                           (lambda (itimer repeat function &rest args)
-                             (set-itimer-restart itimer repeat)
-                             (set-itimer-function itimer function)
-                             (set-itimer-function-arguments itimer args)
-                             (apply function args)))
-                          (set-itimer-function-arguments
-                           itimer
-                           (append (list itimer repeat function) args)))
-                      (set-itimer-function
-                       itimer
-                       (lambda (itimer function &rest args)
-                         (delete-itimer itimer)
-                         (apply function args)))
-                      (set-itimer-function-arguments
-                       itimer
-                       (append (list itimer function) args)))))
-                1e-9 (if time (max time 1e-9) 1e-9)
-                nil t itimers ,repeat ,function ,args))))))
-
-(eval-and-compile
-  (if (featurep 'xemacs)
-      (progn
-        (defun pgg-run-at-time (time repeat function &rest args)
-          "Emulating function run as `run-at-time'.
-TIME should be nil meaning now, or a number of seconds from now.
-Return an itimer object which can be used in either `delete-itimer'
-or `cancel-timer'."
-          (pgg-run-at-time-1 time repeat function args))
-        (defun pgg-cancel-timer (timer)
-          "Emulate cancel-timer for xemacs."
-          (let ((delete-itimer 'delete-itimer))
-            (funcall delete-itimer timer)))
-        )
-    (defalias 'pgg-run-at-time 'run-at-time)
-    (defalias 'pgg-cancel-timer 'cancel-timer)))
-
 (defmacro pgg-convert-lbt-region (start end lbt)
   `(let ((pgg-conversion-end (set-marker (make-marker) ,end)))
      (goto-char ,start)