X-Git-Url: http://cgit.sxemacs.org/?p=gnus;a=blobdiff_plain;f=lisp%2Fparse-time.el;h=42b499130f3bae23e5b393c926b9db6de957c0cb;hp=036f32f46f224ecb8a0b7db08bdfd0e4e494889b;hb=f0bddc315ea0e052416bdd68b1b3166a9e1e9d22;hpb=0154604e83354abf8adf59d35cc5c41482ca8105

diff --git a/lisp/parse-time.el b/lisp/parse-time.el
index 036f32f46..42b499130 100644
--- a/lisp/parse-time.el
+++ b/lisp/parse-time.el
@@ -1,17 +1,16 @@
 ;;; 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-2014 Free Software Foundation, Inc.
 
 ;; Author: Erik Naggum <erik@naggum.no>
 ;; Keywords: util
 
 ;; This file is part of GNU Emacs.
 
-;; GNU Emacs is free software; you can redistribute it and/or modify
+;; 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 3, or (at your option)
-;; any later version.
+;; the Free Software Foundation, either version 3 of the License, 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
@@ -19,9 +18,7 @@
 ;; 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., 51 Franklin Street, Fifth Floor,
-;; Boston, MA 02110-1301, USA.
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
 
 ;;; Commentary:
 
@@ -39,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
@@ -50,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")
@@ -102,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)
@@ -118,9 +128,18 @@
 (defvar parse-time-months '(("jan" . 1) ("feb" . 2) ("mar" . 3)
 			    ("apr" . 4) ("may" . 5) ("jun" . 6)
 			    ("jul" . 7) ("aug" . 8) ("sep" . 9)
-			    ("oct" . 10) ("nov" . 11) ("dec" . 12)))
+			    ("oct" . 10) ("nov" . 11) ("dec" . 12)
+			    ("january" . 1) ("february" . 2)
+			    ("march" . 3) ("april" . 4) ("june" . 6)
+			    ("july" . 7) ("august" . 8)
+			    ("september" . 9) ("october" . 10)
+			    ("november" . 11) ("december" . 12)))
 (defvar parse-time-weekdays '(("sun" . 0) ("mon" . 1) ("tue" . 2)
-			      ("wed" . 3) ("thu" . 4) ("fri" . 5) ("sat" . 6)))
+			      ("wed" . 3) ("thu" . 4) ("fri" . 5)
+			      ("sat" . 6) ("sunday" . 0) ("monday" . 1)
+			      ("tuesday" . 2) ("wednesday" . 3)
+			      ("thursday" . 4) ("friday" . 5)
+			      ("saturday" . 6)))
 (defvar parse-time-zoneinfo `(("z" 0) ("ut" 0) ("gmt" 0)
 			      ("pst" ,(* -8 3600)) ("pdt" ,(* -7 3600) t)
 			      ("mst" ,(* -7 3600)) ("mdt" ,(* -6 3600) t)
@@ -175,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)
@@ -187,37 +207,99 @@ unknown are returned as nil."
       (let ((parse-time-elt (pop temp))
 	    (rules parse-time-rules)
 	    (exit nil))
-	(while (and (not (null rules)) (not exit))
+	(while (and rules (not exit))
 	  (let* ((rule (pop rules))
 		 (slots (pop rule))
 		 (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))
 
+(defconst parse-time-iso8601-regexp
+  (let* ((dash "-?")
+	 (colon ":?")
+	 (4digit "\\([0-9][0-9][0-9][0-9]\\)")
+	 (2digit "\\([0-9][0-9]\\)")
+	 (date-fullyear 4digit)
+	 (date-month 2digit)
+	 (date-mday 2digit)
+	 (time-hour 2digit)
+	 (time-minute 2digit)
+	 (time-second 2digit)
+	 (time-secfrac "\\(\\.[0-9]+\\)?")
+	 (time-numoffset (concat "[-+]\\(" time-hour "\\):" time-minute))
+	 (time-offset (concat "Z" time-numoffset))
+	 (partial-time (concat time-hour colon time-minute colon time-second
+			       time-secfrac))
+	 (full-date (concat date-fullyear dash date-month dash date-mday))
+	 (full-time (concat partial-time time-offset))
+	 (date-time (concat full-date "T" full-time)))
+    (list (concat "^" full-date)
+	  (concat "T" partial-time)
+	  (concat "Z" time-numoffset)))
+  "List of regular expressions matching ISO 8601 dates.
+1st regular expression matches the date.
+2nd regular expression matches the time.
+3rd regular expression matches the (optional) timezone specification.")
+
+(defun parse-iso8601-time-string (date-string)
+  (let* ((date-re (nth 0 parse-time-iso8601-regexp))
+	 (time-re (nth 1 parse-time-iso8601-regexp))
+	 (tz-re (nth 2 parse-time-iso8601-regexp))
+	 re-start
+	 time seconds minute hour fractional-seconds
+	 day month year day-of-week dst tz)
+    ;; We need to populate 'time' with
+    ;; (SEC MIN HOUR DAY MON YEAR DOW DST TZ)
+
+    ;; Nobody else handles iso8601 correctly, let's do it ourselves.
+    (when (string-match date-re date-string re-start)
+      (setq year (string-to-number (match-string 1 date-string))
+	    month (string-to-number (match-string 2 date-string))
+	    day (string-to-number (match-string 3 date-string))
+	    re-start (match-end 0))
+      (when (string-match time-re date-string re-start)
+	(setq hour (string-to-number (match-string 1 date-string))
+	      minute (string-to-number (match-string 2 date-string))
+	      seconds (string-to-number (match-string 3 date-string))
+	      fractional-seconds (string-to-number (or
+                                                    (match-string 4 date-string)
+                                                    "0"))
+	      re-start (match-end 0))
+	(when (string-match tz-re date-string re-start)
+	  (setq tz (match-string 1 date-string)))
+	(setq time (list seconds minute hour day month year day-of-week dst tz))))
+
+    ;; Fall back to having Gnus do fancy things for us.
+    (when (not time)
+      (setq time (parse-time-string date-string)))
+
+    (and time
+	 (apply 'encode-time time))))
+
 (provide 'parse-time)
 
-;;; arch-tag: 07066094-45a8-4c68-b307-86195e2c1103
 ;;; parse-time.el ends here