gnus-notifications: add actions support

[gnus] / lisp / parse-time.el

diff --git a/lisp/parse-time.el b/lisp/parse-time.el
index 59530dc..9c97696 100644 (file)
--- a/lisp/parse-time.el
+++ b/lisp/parse-time.el
@@ -1,7 +1,6 @@
 ;;; parse-time.el --- parsing time strings
 
-;; Copyright (C) 1996, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
-;;   2008  Free Software Foundation, Inc.
+;; Copyright (C) 1996, 2000-2012  Free Software Foundation, Inc.
 
 ;; Author: Erik Naggum <erik@naggum.no>
 ;; Keywords: util
@@ -37,7 +36,9 @@
 
 (eval-when-compile (require 'cl))      ;and ah ain't kiddin' 'bout it
 
-(defvar parse-time-syntax (make-vector 256 nil))
+(eval-and-compile
+  (when (featurep 'xemacs)
+    (defvar parse-time-syntax (make-vector 256 nil))))
 (defvar parse-time-digits (make-vector 256 nil))
 
 ;; Byte-compiler warnings
@@ -48,24 +49,35 @@
   (loop for i from ?0 to ?9
     do (aset parse-time-digits i (- i ?0))))
 
-(unless (aref parse-time-syntax ?0)
-  (loop for i from ?0 to ?9
-    do (aset parse-time-syntax i ?0))
-  (loop for i from ?A to ?Z
-    do (aset parse-time-syntax i ?A))
-  (loop for i from ?a to ?z
-    do (aset parse-time-syntax i ?a))
-  (aset parse-time-syntax ?+ 1)
-  (aset parse-time-syntax ?- -1)
-  (aset parse-time-syntax ?: ?d)
-  )
+(when (featurep 'xemacs)
+  (unless (aref parse-time-syntax ?0)
+    (loop for i from ?0 to ?9
+         do (aset parse-time-syntax i ?0))
+    (loop for i from ?A to ?Z
+         do (aset parse-time-syntax i ?A))
+    (loop for i from ?a to ?z
+         do (aset parse-time-syntax i ?a))
+    (aset parse-time-syntax ?+ 1)
+    (aset parse-time-syntax ?- -1)
+    (aset parse-time-syntax ?: ?d)))
 
 (defsubst digit-char-p (char)
   (aref parse-time-digits char))
 
-(defsubst parse-time-string-chars (char)
-  (and (< char (length parse-time-syntax))
-       (aref parse-time-syntax char)))
+(eval-and-compile
+  (if (featurep 'xemacs)
+      (defsubst parse-time-string-chars (char)
+       (and (< char (length parse-time-syntax))
+            (aref parse-time-syntax char)))
+    (defsubst parse-time-string-chars (char)
+      (save-match-data
+       (let (case-fold-search str)
+         (cond ((eq char ?+) 1)
+               ((eq char ?-) -1)
+               ((eq char ?:) ?d)
+               ((string-match "[[:upper:]]" (setq str (string char))) ?A)
+               ((string-match "[[:lower:]]" str) ?a)
+               ((string-match "[[:digit:]]" str) ?0)))))))
 
 (put 'parse-error 'error-conditions '(parse-error error))
 (put 'parse-error 'error-message "Parsing error")
@@ -100,11 +112,11 @@
        (index 0)
        (c nil))
     (while (< index end)
-      (while (and (< index end)                ;skip invalid characters
+      (while (and (< index end)                ;Skip invalid characters.
                  (not (setq c (parse-time-string-chars (aref string index)))))
        (incf index))
       (setq start index all-digits (eq c ?0))
-      (while (and (< (incf index) end) ;scan valid characters
+      (while (and (< (incf index) end) ;Scan valid characters.
                  (setq c (parse-time-string-chars (aref string index))))
        (setq all-digits (and all-digits (eq c ?0))))
       (if (<= index end)
@@ -182,6 +194,7 @@
     ((5) (50 110) ,#'(lambda () (+ 1900 parse-time-elt)))
     ((5) (0 49) ,#'(lambda () (+ 2000 parse-time-elt))))
   "(slots predicate extractor...)")
+;;;###autoload(put 'parse-time-rules 'risky-local-variable t)
 
 ;;;###autoload
 (defun parse-time-string (string)
@@ -200,31 +213,31 @@ unknown are returned as nil."
                 (predicate (pop rule))
                 (parse-time-val))
            (when (and (not (nth (car slots) time)) ;not already set
-                      (setq parse-time-val (cond ((and (consp predicate)
-                                            (not (eq (car predicate)
-                                                     'lambda)))
-                                       (and (numberp parse-time-elt)
-                                            (<= (car predicate) parse-time-elt)
-                                            (<= parse-time-elt (cadr predicate))
-                                            parse-time-elt))
-                                      ((symbolp predicate)
-                                       (cdr (assoc parse-time-elt
-                                                   (symbol-value predicate))))
-                                      ((funcall predicate)))))
+                      (setq parse-time-val
+                            (cond ((and (consp predicate)
+                                        (not (eq (car predicate)
+                                                 'lambda)))
+                                   (and (numberp parse-time-elt)
+                                        (<= (car predicate) parse-time-elt)
+                                        (<= parse-time-elt (cadr predicate))
+                                        parse-time-elt))
+                                  ((symbolp predicate)
+                                   (cdr (assoc parse-time-elt
+                                               (symbol-value predicate))))
+                                  ((funcall predicate)))))
              (setq exit t)
              (while slots
-               (let ((new-val (and rule
-                                   (let ((this (pop rule)))
-                                     (if (vectorp this)
-                                         (parse-integer
-                                          parse-time-elt
-                                          (aref this 0) (aref this 1))
-                                       (funcall this))))))
-                 (rplaca (nthcdr (pop slots) time)
-                         (or new-val parse-time-val)))))))))
+               (let ((new-val (if rule
+                                  (let ((this (pop rule)))
+                                    (if (vectorp this)
+                                        (parse-integer
+                                         parse-time-elt
+                                         (aref this 0) (aref this 1))
+                                      (funcall this)))
+                                parse-time-val)))
+                 (rplaca (nthcdr (pop slots) time) new-val))))))))
     time))
 
 (provide 'parse-time)
 
-;; arch-tag: 07066094-45a8-4c68-b307-86195e2c1103
 ;;; parse-time.el ends here