Commits

Anonymous committed 1a767b4

Import from CVS: tag r19-15b102

Comments (0)

Files changed (55)

 							-*- indented-text -*-
+to 19.15 beta102
+-- preceding-char, following-char are obsolete and broken, do not use them
+-- miscellaneous bug fixes
+-- W3-3.0.71
+-- Gnus-5.4.33
+-- corrections to lib-src script setup in --srcdir configuration
+-- corrections to stripping subwindows code
+
 to 19.15 beta101
 -- itimer.el-1.05
 -- hyperbole-4.023
       test -n "${ac_have_lib}" && with_xmu="yes"
       # end expansion of ac_have_library
     fi
+    # Sparc/Linux test - fp
+    if test "${with_xmu}" != "yes" -a  ${machine} = sparc -a ${opsys} = linux; then
+      # begin expansion of ac_have_library
+      ac_save_LIBS="${LIBS}"
+      LIBS="${LIBS} -lXmu -lXt -lXext -lX11 -lm -lICE -lSM"
+      ac_have_lib=""
+      cat > conftest.${ac_ext} <<EOF
+int main() { return 0; }
+EOF
+      if eval $ac_compile; then
+        rm -rf conftest*
+        ac_have_lib="1"
+      fi
+      rm -f conftest*
+      LIBS="${ac_save_LIBS}"
+      test -n "${ac_have_lib}" && with_xmu="yes"
+      # end expansion of ac_have_library
+    fi
     # On UnixWare 2.1 we must kludge harder to try to detect Xmu
     # Upgrade to autoconf 2 and use ac_check_lib - mrb
     if test "${with_xmu}" != "yes" && test -f "/.UpgradeVer2.1" ; then
       test -n "${ac_have_lib}" && with_xmu="yes"
       # end expansion of ac_have_library
     fi
+    # Sparc/Linux test - fp
+    if test "${with_xmu}" != "yes" -a  ${machine} = sparc -a ${opsys} = linux; then
+      # begin expansion of ac_have_library
+      ac_save_LIBS="${LIBS}"
+      LIBS="${LIBS} -lXmu -lXt -lXext -lX11 -lm -lICE -lSM"
+      ac_have_lib=""
+      cat > conftest.${ac_ext} <<EOF
+int main() { return 0; }
+EOF
+      if eval $ac_compile; then
+        rm -rf conftest*
+        ac_have_lib="1"
+      fi
+      rm -f conftest*
+      LIBS="${ac_save_LIBS}"
+      test -n "${ac_have_lib}" && with_xmu="yes"
+      # end expansion of ac_have_library
+    fi
     # On UnixWare 2.1 we must kludge harder to try to detect Xmu
     # Upgrade to autoconf 2 and use ac_check_lib - mrb
     if test "${with_xmu}" != "yes" && test -f "/.UpgradeVer2.1" ; then
 ** Please keep the entries in this file alphabetical **
 
 
+Altrasoft	<info@altrasoft.com>
+4880 Stevens Creek Blvd., Suite 205
+San Jose, CA  95129-1034
++1 408 243 3300
+http://www.altrasoft.com
+
+Altrasoft provides corporate-quality support, development and user
+documentation for GNU Emacs, XEmacs and InfoDock.  (InfoDock is a turnkey
+information management and software development toolset built atop emacs,
+written by one of our associates.)  Emacs distributions for a variety of
+platforms are also available, as is support for other emacs variants, such as
+those often found on PCs.
+
+Our unique focus on emacs-related work allows us to attract expert talent in
+this area to keep you on the leading edge of productivity, especially if you
+do software development work.  We do the porting, patching, coding,
+integrating, debugging, documenting and testing so that your people spend
+much more productive time on their mainline tasks.
+
+Standard support packages include help on all aspects of the packages
+supported, including all tools shipped as a standard part of the original
+package distribution.  In general, we want to give you an unbelievably strong
+level of support, so where we can, we will also answer questions concerning
+any add-on Lisp code that is used at your site.  Setup and customization
+help, bug fixes, and announcements of new releases are, of course, included.
+
+Support rates start at $1,000 USD, for single user support for one year.
+Discounts are available for group contracts.  We also offer Golden Support
+contracts for those who need the absolute best in mission-critical support;
+contact us for details.  Hourly development rates and fixed bid work are
+available.
+
+Updated 20-March-1997.
+
 Joseph Arceneaux        	<jla@ai.mit.edu>
 PO Box 460633			http://www.samsara.com/~jla
 San Francisco, CA  94146-0633

lib-src/Makefile.in.in

 /* Like UTILITIES, but they are not system-dependent, and should not be
    deleted by the distclean target. */
 TM_SCRIPTS=tm-au tm-file tm-html tm-image tm-mpeg tm-plain tm-ps tmdecode
-SCRIPTS= rcs2log vcdiff $(TM_SCRIPTS)
+SCRIPTS= rcs2log vcdiff gzip-el.sh $(TM_SCRIPTS)
 
 EXECUTABLES= ${UTILITIES} ${INSTALLABLES} ${SCRIPTS} ${INSTALLABLE_SCRIPTS}
 
 	${LN_S} ${srcdir}/$@ $@
 tmdecode :
 	${LN_S} ${srcdir}/$@ $@
+gzip-el.sh:
+	${LN_S} ${srcdir}/$@ $@
 
 force:
 #else /* ultrix */

lib-src/update-elc.sh

 # and gee w3 has its own makefile as well
 # (no especial need to use it, though)
 echo Compiling W3...
-( cd lisp/w3 ; ${MAKE:-make} EMACS=$REAL )
+( cd lisp/w3 ; ${MAKE:-make} EMACS=$REAL xemacs-w3 )
 echo W3 done.
 
 # Hyperbole has to be different as well.  What is it with these big packages?

lisp/comint/comint-xemacs.el

 
 ;;; Code:
 
-(defgroup 'comint nil
+(defgroup comint nil
   "General command interpreter in a window stuff."
   :group 'processes)
 

lisp/emulators/scroll-lock.el

+;; @(#) scroll-lock.el -- scroll-locking minor mode
+
+;; Authors:
+;;    Gary D. Foster <Gary.Foster@corp.sun.com>
+;; with contributions/suggestions/ideas from:
+;;    Rick Macdonald <rickm@vsl.com>
+;;    Anders Lindgren <andersl@csd.uu.se>
+;; $Revision: 1.1 $
+;; Keywords: scroll crisp brief lock
+
+;; 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 allows multiple buffers to be 'locked' so that scrolling
+;;    up or down lines in any buffer causes all the buffers to mirror
+;;    the scrolling.  It hooks into the post-command-hook to check for
+;;    potential scrolling commands and if we're locked, mirrors them in all
+;;    windows.	This allows us to grab line-at-a-time scrolling as well as
+;;    screen-at-a-time scrolling, and doesn't remap any of the keyboard
+;;    commands to do it.
+
+;; This minor mode is normally autoloaded from the scroll-lock package.
+;; You can disable autoloading of this package by placing
+;; (setq crisp-load-scroll-lock nil) in your .emacs before loading
+;; the crisp package.  If you want to use this package by itself,
+;; you can enable it by placing the following in your .emacs:
+
+;; (require 'scroll-lock)
+
+;; In the first (autoloaded) case, meta-f1 is bound to the command to
+;; toggle the scroll-lock mode.  In the second (non-autoloaded) case,
+;; you can enable and disable it with the 'scroll-lock-mode' command.
+
+(defvar scroll-lock-running-xemacs (string-match "XEmacs\\|Lucid" emacs-version))
+
+(defvar scroll-lock-modeline-string " *SL*"
+  "String to display in the modeline when Scroll Lock mode is enabled.")
+
+(defvar scroll-lock-is-locked nil
+  "Track status of scroll locking.")
+(if scroll-lock-running-xemacs
+    (add-minor-mode 'scroll-lock-is-locked scroll-lock-modeline-string)
+  (or (assq 'scroll-lock-is-locked minor-mode-alist)
+      (setq minor-mode-alist
+	    (cons '(scroll-lock-is-locked scroll-lock-modeline-string) minor-mode-alist))))
+
+(defun scroll-lock-scroll-down-all (arg)
+  "Scroll-down all visible windows."
+  (interactive "P")
+  (let ((num-windows (count-windows))
+	(count 1))
+    (if (> num-windows 1)
+	( progn (other-window 1)
+		(while (< count num-windows)
+		  (if (not (eq (point) (point-max)))
+		      (progn (call-interactively 'next-line)))
+		  (other-window 1)
+		  (setq count (1+ count)))))))
+
+(defun scroll-lock-scroll-up-all (arg)
+  "Scroll-up all visible windows."
+  (interactive "P")
+  (let ((num-windows (count-windows))
+	(count 1))
+    (if (> num-windows 1)
+	( progn (other-window 1)
+		(while (< count num-windows)
+		  (if (not (eq (point) (point-min)))
+		      (progn (call-interactively 'previous-line)))
+		  (other-window 1)
+		  (setq count (1+ count)))))))
+
+(defun scroll-lock-page-down-all (arg)
+  "Page-down all visible windows."
+  (interactive "P")
+  (let ((num-windows (count-windows))
+	(count 1))
+    (if (> num-windows 1)
+	(progn (other-window 1)
+	       (while (< count num-windows)
+		 (call-interactively 'fkey-scroll-up)
+		 (other-window 1)
+		 (setq count (1+ count)))))))
+
+(defun scroll-lock-page-up-all (arg)
+  "Page-up all visible windows."
+  (interactive "P")
+  (let ((num-windows (count-windows))
+	(count 1))
+    (if (> num-windows 1)
+	(progn (other-window 1)
+	       (while (< count num-windows)
+		 (call-interactively 'fkey-scroll-down)
+		 (other-window 1)
+		 (setq count (1+ count)))))))
+
+
+(defun scroll-lock-check-to-scroll ()
+  "Check last-command to see if a scroll was done."
+  (if (eq this-command 'next-line)
+      (call-interactively 'scroll-lock-scroll-down-all))
+  (if (eq this-command 'previous-line)
+      (call-interactively 'scroll-lock-scroll-up-all))
+  (if (eq this-command 'fkey-scroll-up)
+      (call-interactively 'scroll-lock-page-down-all))
+  (if (eq this-command 'fkey-scroll-down)
+      (call-interactively 'scroll-lock-page-up-all)))
+
+
+(defun scroll-lock-mode (arg)
+  "Toggle scroll-lock minor mode."
+  (interactive "P")
+  (setq scroll-lock-is-locked (not scroll-lock-is-locked))
+  (cond
+   ((eq scroll-lock-is-locked 't)
+    (add-hook 'post-command-hook 'scroll-lock-check-to-scroll))
+   ((eq scroll-lock-is-locked 'nil)
+    (remove-hook 'post-command-hook 'scroll-lock-check-to-scroll))))
+
+(provide 'scroll-lock)
+
+;;; scroll-lock.el ends here

lisp/gnus/ChangeLog

+Thu Mar 20 17:33:54 1997  Lars Magne Ingebrigtsen  <larsi@menja.ifi.uio.no>
+
+	* gnus.el: Gnus v5.4.33 is released.
+
+Thu Mar 20 16:01:38 1997  Lars Magne Ingebrigtsen  <larsi@ifi.uio.no>
+
+	* gnus-sum.el (gnus-build-get-header): Don't fold case.
+
+	* nnfolder.el (nnfolder-read-folder): Would always parse the
+	entire mbox.
+
+	* gnus-sum.el (gnus-summary-read-group-1): Return right value.
+
+	* gnus-start.el (gnus-slave-save-newsrc): Set file modes.
+
+	* nneething.el (nneething-open-server): New function.
+	(nneething-possibly-change-directory): Redefined.
+
+Wed Mar 19 21:16:48 1997  Lars Magne Ingebrigtsen  <larsi@menja.ifi.uio.no>
+
+	* gnus.el: Gnus v5.4.32 is released.
+
+Wed Mar 19 21:06:07 1997  Lars Magne Ingebrigtsen  <larsi@ifi.uio.no>
+
+	* nnmail.el (nnmail-cache-accepted-message-ids): Bogus.
+
+Wed Mar 19 20:53:34 1997  Lars Magne Ingebrigtsen  <larsi@menja.ifi.uio.no>
+
+	* gnus.el: Gnus v5.4.31 is released.
+
+Wed Mar 19 14:29:26 1997  Lars Magne Ingebrigtsen  <larsi@ifi.uio.no>
+
+	* nnmh.el (nnmh-request-accept-article): Ditto.
+
+	* nnbabyl.el (nnbabyl-request-accept-article): Ditto.
+
+	* nnmbox.el (nnmbox-request-accept-article): Ditto.
+
+	* nnfolder.el (nnfolder-request-accept-article): Ditto.
+
+	* nnml.el (nnml-request-accept-article): Cache or not.
+
+	* gnus-sum.el (gnus-summary-read-group): Don't recurse.
+	(gnus-summary-ignore-duplicates): New variable.
+	(gnus-get-newsgroup-headers): Use it.
+	(gnus-nov-parse-line): Ditto.
+
+	* message.el (message-reply): Remove excessive white space in
+	headers. 
+
+	* nnfolder.el (nnfolder-read-folder): Work when ignoring active
+	file. 
+
+	* nnmail.el (nnmail-process-unix-mail-format): Narrow to the right
+	portion.
+	(nnmail-process-mmdf-mail-format): Ditto.
+
+	* gnus.el (gnus-group-remove-parameter): New function.
+	(gnus-group-set-parameter): Use it.
+	(gnus-group-add-parameter): Ditto.
+
+	* gnus-msg.el (gnus-post-news): Check first whether
+	to-list/to-address exists before adding.
+
 Tue Mar 18 23:54:17 1997  Lars Magne Ingebrigtsen  <larsi@menja.ifi.uio.no>
 
 	* gnus.el: Gnus v5.4.30 is released.

lisp/gnus/gnus-msg.el

 		(message-mail (or to-address to-list))
 		;; Arrange for mail groups that have no `to-address' to
 		;; get that when the user sends off the mail.
-		(push (list 'gnus-inews-add-to-address pgroup)
-		      message-send-actions))
+		(when (and (not to-list)
+			   (not to-address))
+		  (push (list 'gnus-inews-add-to-address pgroup)
+			message-send-actions)))
 	    (set-buffer gnus-article-copy)
 	    (message-wide-reply to-address)))
 	(when yank

lisp/gnus/gnus-start.el

 	   gnus-active-hashtb)
 	  (when new-newsgroups
 	    (gnus-subscribe-hierarchical-interactive new-newsgroups))
-	  ;; Suggested by Per Abrahamsen <amanda@iesd.auc.dk>.
 	  (if (> groups 0)
 	      (gnus-message 5 "%d new newsgroup%s arrived."
 			    groups (if (> groups 1) "s have" " has"))
     (set-buffer gnus-dribble-buffer)
     (let ((slave-name
 	   (make-temp-name (concat gnus-current-startup-file "-slave-"))))
-      (gnus-write-buffer slave-name))))
+      (gnus-write-buffer slave-name)
+      (set-file-modes slave-name (file-modes gnus-current-startup-file)))))
 
 (defun gnus-master-read-slave-newsrc ()
   (let ((slave-files

lisp/gnus/gnus-sum.el

   :group 'gnus-article-headers
   :type 'boolean)
 
+(defcustom gnus-summary-ignore-duplicates nil
+  "*If non-nil, ignore articles with identical Message-ID headers."
+  :group 'gnus-summary
+  :type 'boolean)
+  
 (defcustom gnus-single-article-buffer t
   "*If non-nil, display all articles in the same buffer.
 If nil, each group will get its own article buffer."
   (let (result)
     (while (and group
 		(null (setq result
-			    (gnus-summary-read-group-1
-			     group show-all no-article
-			     kill-buffer no-display)))
+			    (let ((gnus-auto-select-next nil))
+			      (gnus-summary-read-group-1
+			       group show-all no-article
+			       kill-buffer no-display))))
 		(eq gnus-auto-select-next 'quietly))
       (set-buffer gnus-group-buffer)
       (if (not (equal group (gnus-group-group-name)))
 	    (select-window (get-buffer-window gnus-group-buffer t))
 	    (when (gnus-group-goto-group group)
 	      (recenter))
-	    (select-window owin))))
-      ;; Mark this buffer as "prepared".
-      (setq gnus-newsgroup-prepared t)
-      t))))
+	    (select-window owin)))
+	;; Mark this buffer as "prepared".
+	(setq gnus-newsgroup-prepared t)
+	t)))))
 
 (defun gnus-summary-prepare ()
   "Generate the summary buffer."
     (prog1
 	(save-excursion
 	  (set-buffer nntp-server-buffer)
-	  (goto-char (point-min))
-	  (while (and (not found) (search-forward id nil t))
-	    (beginning-of-line)
-	    (setq found (looking-at
-			 (format "^[^\t]*\t[^\t]*\t[^\t]*\t[^\t]*\t%s"
-				 (regexp-quote id))))
-	    (or found (beginning-of-line 2)))
-	  (when found
-	    (beginning-of-line)
-	    (and
-	     (setq header (gnus-nov-parse-line
-			   (read (current-buffer)) deps))
-	     (gnus-parent-id (mail-header-references header)))))
+	  (let ((case-fold-search nil))
+	    (goto-char (point-min))
+	    (while (and (not found)
+			(search-forward id nil t))
+	      (beginning-of-line)
+	      (setq found (looking-at
+			   (format "^[^\t]*\t[^\t]*\t[^\t]*\t[^\t]*\t%s"
+				   (regexp-quote id))))
+	      (or found (beginning-of-line 2)))
+	    (when found
+	      (beginning-of-line)
+	      (and
+	       (setq header (gnus-nov-parse-line
+			     (read (current-buffer)) deps))
+	       (gnus-parent-id (mail-header-references header))))))
       (when header
 	(let ((number (mail-header-number header)))
 	  (push number gnus-newsgroup-limit)
 	  (if (boundp (setq id-dep (intern id dependencies)))
 	      (if (and (car (symbol-value id-dep))
 		       (not force-new))
-		  ;; An article with this Message-ID has already been seen,
-		  ;; so we rename the Message-ID.
-		  (progn
+		  ;; An article with this Message-ID has already been seen.
+		  (if gnus-summary-ignore-duplicates
+		      ;; We ignore this one, except we add
+		      ;; any additional Xrefs (in case the two articles
+		      ;; came from different servers).
+		      (progn
+			(mail-header-set-xref
+			 (car (symbol-value id-dep))
+			 (concat (or (mail-header-xref
+				      (car (symbol-value id-dep)))
+				     "")
+				 (or (mail-header-xref header) "")))
+			(setq header nil))
+		    ;; We rename the Message-ID.
 		    (set
 		     (setq id-dep (intern (setq id (nnmail-message-id))
 					  dependencies))
     (if (boundp (setq id-dep (intern id dependencies)))
 	(if (and (car (symbol-value id-dep))
 		 (not force-new))
-	    ;; An article with this Message-ID has already been seen,
-	    ;; so we rename the Message-ID.
-	    (progn
+	    ;; An article with this Message-ID has already been seen.
+	    (if gnus-summary-ignore-duplicates
+		;; We ignore this one, except we add any additional
+		;; Xrefs (in case the two articles came from different
+		;; servers.
+		(progn
+		  (mail-header-set-xref
+		   (car (symbol-value id-dep))
+		   (concat (or (mail-header-xref
+				(car (symbol-value id-dep)))
+			       "")
+			   (or (mail-header-xref header) "")))
+		  (setq header nil))
+	      ;; We rename the Message-ID.
 	      (set
 	       (setq id-dep (intern (setq id (nnmail-message-id))
 				    dependencies))

lisp/gnus/gnus.el

   :link '(custom-manual "(gnus)Exiting Gnus")
   :group 'gnus)
 
-(defconst gnus-version-number "5.4.30"
+(defconst gnus-version-number "5.4.33"
   "Version number for this version of Gnus.")
 
 (defconst gnus-version (format "Gnus v%s" gnus-version-number)
 (defun gnus-group-add-parameter (group param)
   "Add parameter PARAM to GROUP."
   (let ((info (gnus-get-info group)))
-    (if (not info)
-	()				; This is a dead group.  We just ignore it.
+    (when info
+      (gnus-group-remove-parameter group (if (consp param) (car param) param))
       ;; Cons the new param to the old one and update.
       (gnus-group-set-info (cons param (gnus-info-params info))
 			   group 'params))))
 (defun gnus-group-set-parameter (group name value)
   "Set parameter NAME to VALUE in GROUP."
   (let ((info (gnus-get-info group)))
-    (if (not info)
-	()				; This is a dead group.  We just ignore it.
+    (when info
+      (gnus-group-remove-parameter group name)
       (let ((old-params (gnus-info-params info))
 	    (new-params (list (cons name value))))
 	(while old-params
 	  (setq old-params (cdr old-params)))
 	(gnus-group-set-info new-params group 'params)))))
 
+(defun gnus-group-remove-parameter (group name)
+  "Remove parameter NAME from GROUP."
+  (let ((info (gnus-get-info group)))
+    (when info
+      (let ((params (gnus-info-params info)))
+	(when params
+	  (setq params (delq name params))
+	  (while (assq name params)
+	    (setq params (delq (assq name params) params)))
+	  (gnus-info-set-params info params))))))
+
 (defun gnus-group-add-score (group &optional score)
   "Add SCORE to the GROUP score.
 If SCORE is nil, add 1 to the score of GROUP."
 ;; This is a direct translation into Emacs LISP of the reference C
 ;; implementation of the MD5 Message-Digest Algorithm written by RSA
 ;; Data Security, Inc.
-;;
+;; 
 ;; The algorithm takes a message (that is, a string of bytes) and
 ;; computes a 16-byte checksum or "digest" for the message.  This digest
 ;; is supposed to be cryptographically strong in the sense that if you
 ;; space of messages.  However, the robustness of the algorithm has not
 ;; been proven, and a similar algorithm (MD4) was shown to be unsound,
 ;; so treat with caution!
-;;
+;; 
 ;; The C algorithm uses 32-bit integers; because GNU Emacs
 ;; implementations provide 28-bit integers (with 24-bit integers on
 ;; versions prior to 19.29), the code represents a 32-bit integer as the
 
 ;; To compute the MD5 Message Digest for a message M (represented as a
 ;; string or as a vector of bytes), call
-;;
+;; 
 ;;   (md5-encode M)
-;;
+;; 
 ;; which returns the message digest as a vector of 16 bytes.  If you
 ;; need to supply the message in pieces M1, M2, ... Mn, then call
-;;
+;; 
 ;;   (md5-init)
 ;;   (md5-update M1)
 ;;   (md5-update M2)
 
 ;; Copyright (C) 1995 by Gareth Rees
 ;; Derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm
-;;
+;; 
 ;; md5.el 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.
-;;
+;; 
 ;; md5.el 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.
-;;
+;; 
 ;; The original copyright notice is given below, as required by the
 ;; licence for the original code.  This code is distributed under *both*
 ;; RSA's original licence and the GNU General Public Licence.  (There
 ;; for rounds 1, 2, 3 and 4 respectively.  Each function follows this
 ;; pattern of computation (where ROTATE(x,y) means rotate 32-bit value x
 ;; by y bits to the left):
-;;
+;; 
 ;;   FF(a,b,c,d,x,s,ac) = ROTATE(a + F(b,c,d) + x + ac,s) + b
-;;
+;; 
 ;; so we use the macro `md5-make-step' to construct each one.  The
 ;; helper functions F, G, H and I operate on 16-bit numbers; the full
 ;; operation splits its inputs, operates on the halves separately and
 (md5-make-step md5-II md5-I)
 
 (defun md5-init ()
-  "Initialize the state of the message-digest routines."
+  "Initialise the state of the message-digest routines."
   (aset md5-bits 0 0)
   (aset md5-bits 1 0)
   (aset md5-bits 2 0)
      c (md5-II c d a b (aref in  2) 15 '(10967 . 53947))
      b (md5-II b c d a (aref in  9) 21 '(60294 . 54161)))
 
-    (aset md5-buffer 0 (md5-add (aref md5-buffer 0) a))
-    (aset md5-buffer 1 (md5-add (aref md5-buffer 1) b))
-    (aset md5-buffer 2 (md5-add (aref md5-buffer 2) c))
-    (aset md5-buffer 3 (md5-add (aref md5-buffer 3) d))))
+     (aset md5-buffer 0 (md5-add (aref md5-buffer 0) a))
+     (aset md5-buffer 1 (md5-add (aref md5-buffer 1) b))
+     (aset md5-buffer 2 (md5-add (aref md5-buffer 2) c))
+     (aset md5-buffer 3 (md5-add (aref md5-buffer 3) d))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; Here begins the merger with the XEmacs API and the md5.el from the URL
 ;;; package.  Courtesy wmperry@spry.com
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(eval-and-compile
-  (unless (fboundp 'md5)
-    (defun md5 (object &optional start end)
-      "Return the MD5 (a secure message digest algorithm) of an object.
+(defun md5 (object &optional start end)
+  "Return the MD5 (a secure message digest algorithm) of an object.
 OBJECT is either a string or a buffer.
 Optional arguments START and END denote buffer positions for computing the
 hash of a portion of OBJECT."
-      (let ((buffer nil))
-	(unwind-protect
-	    (save-excursion
-	      (setq buffer (generate-new-buffer " *md5-work*"))
-	      (set-buffer buffer)
-	      (cond
-	       ((bufferp object)
-		(insert-buffer-substring object start end))
-	       ((stringp object)
-		(insert (if (or start end)
-			    (substring object start end)
-			  object)))
-	       (t nil))
-	      (prog1
-		  (if (<= (point-max) md5-maximum-internal-length)
-		      (mapconcat
-		       (function (lambda (node) (format "%02x" node)))
-		       (md5-encode (buffer-string))
-		       "")
-		    (call-process-region (point-min) (point-max)
-					 (or shell-file-name "/bin/sh")
-					 t buffer nil
-					 "-c" md5-program)
-		    ;; MD5 digest is 32 chars long
-		    ;; mddriver adds a newline to make neaten output for tty
-		    ;; viewing, make sure we leave it behind.
-		    (buffer-substring (point-min) (+ (point-min) 32)))
-		(kill-buffer buffer)))
-	  (and buffer (kill-buffer buffer) nil))))))
+ (let ((buffer nil))
+    (unwind-protect
+	(save-excursion
+	  (setq buffer (generate-new-buffer " *md5-work*"))
+	  (set-buffer buffer)
+	  (cond
+	   ((bufferp object)
+	    (insert-buffer-substring object start end))
+	   ((stringp object)
+	    (insert (if (or start end)
+			(substring object start end)
+		      object)))
+	   (t nil))
+	  (prog1
+	      (if (<= (point-max) md5-maximum-internal-length)
+		  (mapconcat
+		   (function (lambda (node) (format "%02x" node)))
+		   (md5-encode (buffer-string))
+		   "")
+		(call-process-region (point-min) (point-max)
+				     (or shell-file-name "/bin/sh")
+				     t buffer nil
+				     "-c" md5-program)
+		;; MD5 digest is 32 chars long
+		;; mddriver adds a newline to make neaten output for tty
+		;; viewing, make sure we leave it behind.
+		(buffer-substring (point-min) (+ (point-min) 32)))
+	    (kill-buffer buffer)))
+      (and buffer (kill-buffer buffer) nil))))
 
 (provide 'md5)
 

lisp/gnus/message.el

 	      (insert (if (bolp) "" ", ") (or to ""))
 	      (insert (if mct (concat (if (bolp) "" ", ") mct) ""))
 	      (insert (if cc (concat (if (bolp) "" ", ") cc) ""))
+	      (goto-char (point-min))
+	      (while (re-search-forward "[ \t]+" nil t)
+		(replace-match " " t t))
 	      ;; Remove addresses that match `rmail-dont-reply-to-names'.
 	      (insert (prog1 (rmail-dont-reply-to (buffer-string))
 			(erase-buffer)))

lisp/gnus/nnbabyl.el

        (save-excursion
 	 (while (re-search-backward "^X-Gnus-Newsgroup: " beg t)
 	   (delete-region (point) (progn (forward-line 1) (point)))))
+       (when nnmail-cache-accepted-message-ids
+	 (nnmail-cache-insert (nnmail-fetch-field "message-id")))
        (setq result (car (nnbabyl-save-mail
 			  (if (stringp group)
 			      (list (cons group (nnbabyl-active-number group)))
        (goto-char (match-end 0))
        (insert-buffer-substring buf)
        (when last
+	 (when nnmail-cache-accepted-message-ids
+	   (nnmail-cache-insert (nnmail-fetch-field "message-id")))
 	 (save-buffer)
 	 (nnmail-save-active nnbabyl-group-alist nnbabyl-active-file))
        result))))

lisp/gnus/nneething.el

   "Current news group directory.")
 
 (defvoo nneething-status-string "")
-(defvoo nneething-group-alist nil)
 
 (defvoo nneething-message-id-number 0)
 (defvoo nneething-work-buffer " *nneething work*")
   (setq nneething-current-directory nil)
   t)
 
+(deffoo nneething-open-server (server &optional defs)
+  (nnheader-init-server-buffer)
+  (if (nneething-server-opened server)
+      t
+    (unless (assq 'nneething-directory defs)
+      (setq defs (append defs (list (list 'nneething-directory server)))))
+    (nnoo-change-server 'nneething server defs)))
+
 
 ;;; Internal functions.
 
-(defun nneething-possibly-change-directory (group &optional dir)
-  (when group
-    (if (and nneething-group
-	     (string= group nneething-group))
-	t
-      (let (entry)
-	(if (setq entry (assoc group nneething-group-alist))
-	    (progn
-	      (setq nneething-group group)
-	      (setq nneething-directory (nth 1 entry))
-	      (setq nneething-map (nth 2 entry))
-	      (setq nneething-active (nth 3 entry)))
-	  (setq nneething-group group)
-	  (setq nneething-directory dir)
-	  (setq nneething-map nil)
-	  (setq nneething-active (cons 1 0))
-	  (nneething-create-mapping)
-	  (push (list group dir nneething-map nneething-active)
-		nneething-group-alist))))))
+(defun nneething-possibly-change-directory (group &optional server)
+  (when (and server
+	     (not (nneething-server-opened server)))
+    (nneething-open-server server))
+  (when (and group
+	     (not (equal nneething-group group)))
+    (setq nneething-group group)
+    (setq nneething-map nil)
+    (setq nneething-active (cons 1 0))
+    (nneething-create-mapping)))
 
 (defun nneething-map-file ()
   ;; We make sure that the .nneething directory exists.

lisp/gnus/nnfolder.el

        (forward-line -1)
        (while (re-search-backward (concat "^" nnfolder-article-marker) nil t)
 	 (delete-region (point) (progn (forward-line 1) (point))))
+       (when nnmail-cache-accepted-message-ids
+	 (nnmail-cache-insert (nnmail-fetch-field "message-id")))
        (setq result
 	     (car (nnfolder-save-mail
 		   (if (stringp group)
      (when last
        (save-excursion
 	 (nnfolder-possibly-change-folder (or (caar art-group) group))
-	 (nnfolder-save-buffer))))
+	 (nnfolder-save-buffer)
+	 (when nnmail-cache-accepted-message-ids
+	   (nnmail-cache-close)))))
     (nnmail-save-active nnfolder-group-alist nnfolder-active-file)
     (unless result
       (nnheader-report 'nnfolder "Couldn't store article"))
 	(let ((delim (concat "^" message-unix-mail-delimiter))
 	      (marker (concat "\n" nnfolder-article-marker))
 	      (number "[0-9]+")
-	      (active (cadr (assoc group nnfolder-group-alist)))
+	      (active (or (cadr (assoc group nnfolder-group-alist))
+			  (cons 1 0)))
 	      (scantime (assoc group nnfolder-scantime-alist))
 	      (minid (lsh -1 -1))
 	      maxid start end newscantime
 	  (when (not (or nnfolder-distrust-mbox
 			 (< maxid 2)))
 	    (goto-char (point-max))
-	    (if (not (re-search-backward marker nil t))
-		(goto-char (point-min))
-	      (when (not (nnmail-search-unix-mail-delim))
-		(goto-char (point-min)))))
+	    (unless (re-search-backward marker nil t)
+	      (goto-char (point-min))))
 
 	  ;; Keep track of the active number on our own, and insert it back
 	  ;; into the active list when we're done.  Also, prime the pump to

lisp/gnus/nnmail.el

   :type '(choice (const :tag "nnmail-expiry-wait" nil)
 		 (function :format "%v" nnmail-)))
 
+(defcustom nnmail-cache-accepted-message-ids nil
+  "If non-nil, put Message-IDs of Gcc'd articles into the duplicate cache."
+  :group 'nnmail
+  :type 'boolean)
+
 (defcustom nnmail-spool-file
   (or (getenv "MAIL")
       (concat "/usr/spool/mail/" (user-login-name)))
 	   ;; if there is no head-body delimiter, we search a bit manually.
 	   (while (and (looking-at "From \\|[^ \t]+:")
 		       (not (eobp)))
-	     (forward-line 1)
-	     (point))))
+	     (forward-line 1))
+	   (point)))
 	;; Find the Message-ID header.
 	(goto-char (point-min))
 	(if (re-search-forward "^Message-ID[ \t]*:[ \n\t]*\\(<[^>]+>\\)" nil t)
 	   ;; if there is no head-body delimiter, we search a bit manually.
 	   (while (and (looking-at "From \\|[^ \t]+:")
 		       (not (eobp)))
-	     (forward-line 1)
-	     (point))))
+	     (forward-line 1))
+	   (point)))
 	;; Find the Message-ID header.
 	(goto-char (point-min))
 	(if (re-search-forward "^Message-ID[ \t]*:[ \n\t]*\\(<[^>]+>\\)" nil t)

lisp/gnus/nnmbox.el

        (forward-line -1)
        (while (re-search-backward "^X-Gnus-Newsgroup: " nil t)
 	 (delete-region (point) (progn (forward-line 1) (point))))
+       (when nnmail-cache-accepted-message-ids
+	 (nnmail-cache-insert (nnmail-fetch-field "message-id")))
        (setq result (nnmbox-save-mail
 		     (if (stringp group)
 			 (list (cons group (nnmbox-active-number group)))
        (goto-char (point-max))
        (insert-buffer-substring buf)
        (when last
+	 (when nnmail-cache-accepted-message-ids
+	   (nnmail-cache-close))
 	 (nnmail-save-active nnmbox-group-alist nnmbox-active-file)
 	 (save-buffer))))
     (car result)))

lisp/gnus/nnmh.el

 (deffoo nnmh-request-accept-article (group &optional server last noinsert)
   (nnmh-possibly-change-directory group server)
   (nnmail-check-syntax)
-  (if (stringp group)
-      (and
-       (nnmail-activate 'nnmh)
-       (car (nnmh-save-mail
-	     (list (cons group (nnmh-active-number group)))
-	     noinsert)))
-    (and
-     (nnmail-activate 'nnmh)
-     (car (nnmh-save-mail (nnmail-article-group 'nnmh-active-number)
-			  noinsert)))))
+  (when nnmail-cache-accepted-message-ids
+    (nnmail-cache-insert (nnmail-fetch-field "message-id")))
+  (prog1
+      (if (stringp group)
+	  (and
+	   (nnmail-activate 'nnmh)
+	   (car (nnmh-save-mail
+		 (list (cons group (nnmh-active-number group)))
+		 noinsert)))
+	(and
+	 (nnmail-activate 'nnmh)
+	 (car (nnmh-save-mail (nnmail-article-group 'nnmh-active-number)
+			      noinsert))))
+    (when (and last nnmail-cache-accepted-message-ids)
+      (nnmail-cache-close))))
 
 (deffoo nnmh-request-replace-article (article group buffer)
   (nnmh-possibly-change-directory group)

lisp/gnus/nnml.el

   (nnml-possibly-change-directory group server)
   (nnmail-check-syntax)
   (let (result)
+    (when nnmail-cache-accepted-message-ids
+      (nnmail-cache-insert (nnmail-fetch-field "message-id")))
     (if (stringp group)
 	(and
 	 (nnmail-activate 'nnml)
 			  (nnmail-article-group 'nnml-active-number))))
        (when last
 	 (nnmail-save-active nnml-group-alist nnml-active-file)
+	 (when nnmail-cache-accepted-message-ids
+	   (nnmail-cache-close))
 	 (nnml-save-nov))))
     result))
 

lisp/gnus/pop3.el

 
 ;; Author: Richard L. Pieri <ratinox@peorth.gweep.net>
 ;; Keywords: mail, pop3
-;; Version: 1.3
+;; Version: 1.3c
 
 ;; This file is part of GNU Emacs.
 
 (require 'mail-utils)
 (provide 'pop3)
 
-(eval-and-compile
-  (if (not (fboundp 'md5)) (autoload 'md5 "md5")))
+(defconst pop3-version "1.3c")
 
 (defvar pop3-maildrop (or user-login-name (getenv "LOGNAME") (getenv "USER") nil)
   "*POP3 maildrop.")
   "*Password to use when connecting to POP server.")
 
 (defvar pop3-authentication-scheme 'pass
-  "*POP3 authentication scheme.  Defaults to 'pass, for the standard
-USER/PASS authentication.  Other valid values are 'apop.")
+  "*POP3 authentication scheme.
+Defaults to 'pass, for the standard USER/PASS authentication.  Other valid
+values are 'apop.")
 
 (defvar pop3-timestamp nil
   "Timestamp returned when initially connected to the POP server.
       (pop3-retr process n crashbuf)
       (save-excursion
 	(set-buffer crashbuf)
-	(append-to-file (point-min) (point-max) crashbox))
+	(append-to-file (point-min) (point-max) crashbox)
+	(set-buffer (process-buffer process))
+	(while (> (buffer-size) 5000)
+	  (goto-char (point-min))
+	  (forward-line 50)
+	  (delete-region (point-min) (point))))
       (pop3-dele process n)
-      (setq n (+ 1 n)))
+      (setq n (+ 1 n))
+      (if pop3-debug (sit-for 1) (sit-for 0.1))
+      )
     (pop3-quit process)
     (kill-buffer crashbuf)
     )
 ;; TRANSACTION STATE
 
 (defun pop3-stat (process)
-  "Return a list of the number of messages in the maildrop and the size
-of the maildrop."
+  "Return the number of messages in the maildrop and the maildrop's size."
   (pop3-send-command process "STAT")
   (let ((response (pop3-read-response process t)))
     (list (string-to-int (nth 1 (pop3-string-to-list response)))
 This function currently does nothing.")
 
 (defun pop3-retr (process msg crashbuf)
-  "Retrieve message-id MSG from the server and place the contents in
-buffer CRASHBUF."
+  "Retrieve message-id MSG to buffer CRASHBUF."
   (pop3-send-command process (format "RETR %s" msg))
   (pop3-read-response process)
   (let ((start pop3-read-point) end)
 	(goto-char start))
       (setq pop3-read-point (point-marker))
       (goto-char (match-beginning 0))
+      (backward-char 2)
+      (if (not (looking-at "\r\n"))
+	  (insert "\r\n"))
+      (re-search-forward "\\.\r\n")
+      (goto-char (match-beginning 0))
       (setq end (point-marker))
       (pop3-clean-region start end)
       (pop3-munge-message-separator start end)
 ;; UPDATE
 
 (defun pop3-quit (process)
-  "Tell server to remove all messages marked as deleted, unlock the
-maildrop, and close the connection."
+  "Close connection to POP3 server.
+Tell server to remove all messages marked as deleted, unlock the maildrop,
+and close the connection."
   (pop3-send-command process "QUIT")
   (pop3-read-response process t)
   (if process

lisp/hyperbole/hpath.el

 ;; ORG:          InfoDock Associates
 ;;
 ;; ORIG-DATE:     1-Nov-91 at 00:44:23
-;; LAST-MOD:      9-Mar-97 at 01:38:33 by Bob Weiner
+;; LAST-MOD:     20-Mar-97 at 11:52:51 by Bob Weiner
 
 ;;; ************************************************************************
 ;;; Public variables
   (if (looking-at "\\(URL:\\)?\\([a-zA-Z][a-zA-Z]+\\)://?\\([^@/: \t\n\^M]+@\\)?\\([^/:@ \t\n\^M\"`']+\\)\\(:[0-9]+\\)?\\([/~][^]@ \t\n\^M\"`'\)\}>]*\\)?")
       (save-excursion
 	(goto-char (match-end 0))
-	(skip-chars-backward ".?#!*()")
+	(skip-chars-backward ".,?#!*()")
 	(buffer-substring (match-beginning 2) (point)))))
 
 (defun hpath:url-p (obj)

lisp/hyperbole/hvm.el

 ;; KEYWORDS:     hypermedia, mail
 ;;
 ;; AUTHOR:       Bob Weiner
-;; ORG:          Brown U.
+;; ORG:          InfoDock Associates
 ;;
 ;; ORIG-DATE:    10-Oct-91 at 01:51:12
-;; LAST-MOD:     31-Oct-96 at 22:36:19 by Bob Weiner
+;; LAST-MOD:     20-Mar-97 at 14:52:54 by Bob Weiner
 ;;
 ;; This file is part of Hyperbole.
 ;; Available for use and distribution under the same terms as GNU Emacs.
 ;;; Overlay this function from "vm-folder.el" called whenever new mail is
 ;;; incorporated so that it will highlight Hyperbole buttons when possible.
 ;;  Returns non-nil if there were any new messages.
-(defun vm-assimilate-new-messages (&optional dont-read-attributes gobble-order)
+(defun vm-assimilate-new-messages (&optional
+				   dont-read-attributes
+				   gobble-order
+				   labels)
   (let ((tail-cons (vm-last vm-message-list))
 	b-list new-messages)
     (save-excursion
       (setq new-messages (if tail-cons (cdr tail-cons) vm-message-list))
       (vm-set-numbering-redo-start-point new-messages)
       (vm-set-summary-redo-start-point new-messages))
+    ;; copy the new-messages list because sorting might scramble
+    ;; it.  Also something the user does when
+    ;; vm-arrived-message-hook is run might affect it.
+    ;; vm-assimilate-new-messages returns this value so it must
+    ;; not be mangled.
+    (setq new-messages (copy-sequence new-messages))
+    ;; add the labels
+    (if (and labels (boundp 'vm-burst-digest-messages-inherit-labels)
+	     vm-burst-digest-messages-inherit-labels)
+	(let ((mp new-messages))
+	  (while mp
+	    (vm-set-labels-of (car mp) (copy-sequence labels))
+	    (setq mp (cdr mp)))))
     (if vm-summary-show-threads
 	(progn
 	  ;; get numbering and summary of new messages done now
 	  ;; so that the sort code only has to worry about the
 	  ;; changes it needs to make.
 	  (vm-update-summary-and-mode-line)
-	  ;; copy the new-messages list because sorting might
-	  ;; scramble it.  vm-assimilate-new-messages returns
-	  ;; this value.
-	  (setq new-messages (copy-sequence new-messages))
 	  (vm-sort-messages "thread")))
+    (if (and vm-arrived-message-hook
+	     new-messages
+	     ;; tail-cons == nil means vm-message-list was empty.
+	     ;; Thus new-messages == vm-message-list.  In this
+	     ;; case, run the hooks only if this is not the first
+	     ;; time vm-assimilate-new-messages has been called
+	     ;; in this folder.  gobble-order non-nil is a good
+	     ;; indicator that this is the first time because the
+	     ;; order is gobbled only once per visit and always
+	     ;; the first time vm-assimilate-new-messages is
+	     ;; called.
+	     (or tail-cons (null gobble-order)))
+	(let ((new-messages new-messages))
+	  ;; seems wise to do this so that if the user runs VM
+	  ;; command here they start with as much of a clean
+	  ;; slate as we can provide, given we're currently deep
+	  ;; in the guts of VM.
+	  (vm-update-summary-and-mode-line)
+	  (while new-messages
+	    (vm-run-message-hook (car new-messages) 'vm-arrived-message-hook)
+	    (setq new-messages (cdr new-messages)))))
+    (vm-update-summary-and-mode-line)
+    (run-hooks 'vm-arrived-messages-hook)
     (if (and new-messages vm-virtual-buffers)
 	(save-excursion
 	  (setq b-list vm-virtual-buffers)

lisp/modes/sendmail.el

   :group 'message
   :type 'boolean)
 
+;;;###autoload
 (defun user-mail-address ()
   "Query the user for his mail address, unless it is already known."
   (interactive)
-  (when query-user-mail-address
-    (setq user-mail-address
-	  (read-string "Your mail address? " (cons user-mail-address 0)))
-    (setq query-user-mail-address nil)
-    ;; TODO: Run sanity check from Gnus here.
-    (when (y-or-n-p "Save address for future sessions? ")
-      (put 'user-mail-address 'saved-value
-	   (list user-mail-address))
-      (put 'query-user-mail-address 'saved-value '(nil))
-      (custom-save-all)))
-  user-mail-address)
+  (when (and (not noninteractive) query-user-mail-address)
+    (let ((addr (or user-mail-address
+		    (concat (user-login-name) "@"
+				    (or mail-host-address
+					(system-name))))))
+      (setq user-mail-address
+	    (read-string "Your mail address? " (cons addr 0)))
+      (setq query-user-mail-address nil)
+      ;; TODO: Run sanity check from Gnus here.
+      (when (y-or-n-p "Save address for future sessions? ")
+	(put 'user-mail-address 'saved-value
+	     (list user-mail-address))
+	(put 'query-user-mail-address 'saved-value '(nil))
+	(custom-save-all)))
+    (if user-mail-address
+	user-mail-address
+      (setq user-mail-address (concat (user-login-name) "@"
+				      (or mail-host-address
+					  (system-name)))))))
 
 (defun mail-setup (to subject in-reply-to cc replybuffer actions)
   (or mail-default-reply-to

lisp/packages/font-lock.el

     (setq font-lock-old-extent nil)))
 
 (defun font-lock-pre-idle-hook ()
-  (if font-lock-old-extent
-      (font-lock-fontify-glumped-region)))
+  (condition-case nil
+      (if font-lock-old-extent
+	  (font-lock-fontify-glumped-region))
+    (error (warn "Error caught in `font-lock-pre-idle-hook'"))))
 
 (defvar font-lock-always-fontify-immediately nil
   "Set this to non-nil to disable font-lock deferral.")
 	       '(2 font-lock-reference-face)
 	       (list (concat
 		      "\\=\\.\\(" java-font-lock-identifier-regexp "\\)")
-		     nil nil '(1 (if (= (char-after (match-end 0)) ?.)
-				     'font-lock-reference-face
-				   'font-lock-type-face))))
+		     nil nil '(1 (let ((c (char-after (match-end 0))))
+				   (if (and (characterp c)
+					    (= c ?.))
+				       'font-lock-reference-face
+				     'font-lock-type-face)))))
 
 	 ;; Constructors:
 	 (list (concat

lisp/pcl-cvs/pcl-cvs.el

 ;;;
 ;;;#ident "@(#)OrigId: pcl-cvs.el,v 1.93 1993/05/31 22:44:00 ceder Exp "
 ;;;
-;;;#ident "@(#)cvs/contrib/pcl-cvs:$Name: r19-15b6 $:$Id: pcl-cvs.el,v 1.2 1996/12/29 00:15:02 steve Exp $"
+;;;#ident "@(#)cvs/contrib/pcl-cvs:$Name: r19-15b102 $:$Id: pcl-cvs.el,v 1.3 1997/03/21 03:43:23 steve Exp $"
 ;;;
 ;;; pcl-cvs.el -- A Front-end to CVS 1.3 or later.
-;;; Release 1.05-CVS-$Name: r19-15b6 $.
+;;; Release 1.05-CVS-$Name: r19-15b102 $.
 ;;; Copyright (C) 1991, 1992, 1993  Per Cederqvist
 
 ;;; This program is free software; you can redistribute it and/or modify
 ;;;	     END OF THINGS TO CHECK WHEN INSTALLING
 ;;; --------------------------------------------------------
 
-(defconst pcl-cvs-version "1.05-CVS-$Name: r19-15b6 $"
+(defconst pcl-cvs-version "1.05-CVS-$Name: r19-15b102 $"
   "A string denoting the current release version of pcl-cvs.")
 
 ;; You are NOT allowed to disable this message by default.  However, you
 
 (defconst cvs-startup-message
   (if cvs-inhibit-copyright-message
-      "PCL-CVS release 1.05-CVS-$Name: r19-15b6 $"
-    "PCL-CVS release 1.05 from CVS release $Name: r19-15b6 $.
+      "PCL-CVS release 1.05-CVS-$Name: r19-15b102 $"
+    "PCL-CVS release 1.05 from CVS release $Name: r19-15b102 $.
 Copyright (C) 1992, 1993 Per Cederqvist
 Pcl-cvs comes with absolutely no warranty; for details consult the manual.
 This is free software, and you are welcome to redistribute it under certain
 \\[cvs-mode-undo-local-changes]   Revert the last checked in version - discard your changes to the file.
 
 Entry to this mode runs cvs-mode-hook.
-This description is updated for release 1.05-CVS-$Name: r19-15b6 $ of pcl-cvs.
+This description is updated for release 1.05-CVS-$Name: r19-15b102 $ of pcl-cvs.
 
 All bindings:
 \\{cvs-mode-map}"
     (insert "Pcl-cvs Version: "
 	    "@(#)OrigId: pcl-cvs.el,v 1.93 1993/05/31 22:44:00 ceder Exp\n")
     (insert "CVS Version: "
-	    "@(#)lisp/pcl-cvs:$Name: r19-15b6 $:$Id: pcl-cvs.el,v 1.2 1996/12/29 00:15:02 steve Exp $\n\n")
+	    "@(#)lisp/pcl-cvs:$Name: r19-15b102 $:$Id: pcl-cvs.el,v 1.3 1997/03/21 03:43:23 steve Exp $\n\n")
     (insert (format "--- Contents of stdout buffer (%d chars) ---\n"
 		    (length stdout)))
     (insert stdout)
 		(setcdr head (list fileinfo))
 		(setq head (cdr head)))))))
 
+         ;; Patch failure message with CVS client.
+         ;; Ignore, since a failed patch implies that the file proper
+         ;; subsequently will be fetched from the server.
+	 ((looking-at
+	   "^[0-9]+ out of [0-9]+ hunks failed--saving rejects to ")
+	  (forward-line 1))
+
 	 ;; Error messages from CVS (incomplete)
 
 	 ((looking-at
 	(re-search-forward cvs-update-prog-output-skip-regexp)
 	(forward-line 1))
 
+       ;; Patch informational message with CVS client.
+       ;; Ignore, since this simply tells us that the patch in question
+       ;; already has been applied to the file.
+       ((looking-at
+	 "^.* already contains the differences between .* and ")
+        (forward-line 1))
+
        (t
 	(cvs-parse-error stdout-buffer stderr-buffer 'STDOUT (point)
 			 "cvs-parse-stdout"))))))

lisp/prim/about.el

 
 	 ((eq xref 'baw)
 	  (about-face "Barry Warsaw" 'bold)
-	  (insert " <bwarsaw@cnri.reston.va.us>
+	  (insert " <bwarsaw@python.org>
 
 	Author of cc-mode for C++, C, and Objective-C editing, and
 	Supercite for mail and news citing.  Also various and sundry other
 	Emacs utilities, fixes, enhancements and kludgery as whimsy,
 	boredom, and ToT dictate (but not necessarily in that order).
 
+	See \"http://www.python.org/~bwarsaw\".
 
 	Daddy
 	� 1994 Warsaw
 	  Contributor of many dispersed improvements in the core Lisp code,
 	  and back-seat contributor for several of it's major packages.
 
-	") (about-xref "Barry Warsaw" 'baw "Find out more about Barry Warsaw") (insert " <bwarsaw@cnri.reston.va.us>
+	") (about-xref "Barry Warsaw" 'baw "Find out more about Barry Warsaw") (insert " <bwarsaw@python.org>
 	  Author of cc-mode for C++, C, and Objective-C editing, and
 	  Supercite for mail and news citing.  Also various and sundry other
 	  Emacs utilities, fixes, enhancements and kludgery as whimsy,

lisp/prim/auto-autoloads.el

 ;;;### (autoloads (ksh-mode) "ksh-mode" "modes/ksh-mode.el")
 
 (autoload 'ksh-mode "ksh-mode" "\
-ksh-mode $Revision: 1.15 $ - Major mode for editing (Bourne, Korn or Bourne again)
+ksh-mode $Revision: 1.16 $ - Major mode for editing (Bourne, Korn or Bourne again)
 shell scripts.
 Special key bindings and commands:
 \\{ksh-mode-map}
 
 ;;;***
 
-;;;### (autoloads (mail-other-frame mail-other-window mail mail-mode) "sendmail" "modes/sendmail.el")
+;;;### (autoloads (mail-other-frame mail-other-window mail mail-mode user-mail-address) "sendmail" "modes/sendmail.el")
 
 (defvar mail-from-style 'angles "\
 *Specifies how \"From:\" fields look.
 *Text inserted at end of mail buffer when a message is initialized.
 If t, it means to insert the contents of the file `mail-signature-file'.")
 
+(autoload 'user-mail-address "sendmail" "\
+Query the user for his mail address, unless it is already known." t nil)
+
 (autoload 'mail-mode "sendmail" "\
 Major mode for editing mail to be sent.
 Like Text Mode but with these additional commands:
 
 (autoload 'vhdl-mode "vhdl-mode" "\
 Major mode for editing VHDL code.
-vhdl-mode $Revision: 1.15 $
+vhdl-mode $Revision: 1.16 $
 To submit a problem report, enter `\\[vhdl-submit-bug-report]' from a
 vhdl-mode buffer.  This automatically sets up a mail buffer with version
 information already added.  You just need to add a description of the

lisp/prim/custom-load.el

 (put 'gnus-summary-exit 'custom-loads '("gnus-sum"))
 (put 'gnus-article-saving 'custom-loads '("gnus-art"))
 (put 'gnus-extract-view 'custom-loads '("gnus-sum" "gnus-uu"))
+(put 'comint 'custom-loads '("comint-xemacs"))
 (put 'gnus-group-listing 'custom-loads '("gnus-group"))
 (put 'gnus-summary 'custom-loads '("gnus-sum" "gnus"))
 (put 'message-headers 'custom-loads '("message"))
 (put 'gnus-treading 'custom-loads '("gnus-sum"))
 (put 'nnmail 'custom-loads '("nnmail"))
 (put 'gnus-article-hiding 'custom-loads '("gnus-art" "gnus-sum"))
-(put 'customize 'custom-loads '("wid-edit" "custom" "cus-edit" "cus-face"))
+(put 'customize 'custom-loads '("wid-edit" "custom" "cus-face" "cus-edit"))
 (put 'w3-printing 'custom-loads '("w3-cus"))
 (put 'nnmail-duplicate 'custom-loads '("nnmail"))
 (put 'gnus-summary-visual 'custom-loads '("gnus-sum" "gnus"))
 (put 'gnus-various 'custom-loads '("gnus-sum"))
 (put 'gnus-article-highlight 'custom-loads '("gnus-art"))
 (put 'emacs 'custom-loads '("cus-edit" "dired-faces" "ssl"))
+(put 'processes 'custom-loads '("comint-xemacs"))
 (put 'news 'custom-loads '("gnus" "message"))
 (put 'w3-hooks 'custom-loads '("w3-cus"))
 (put 'message-insertion 'custom-loads '("message"))

lisp/prim/device.el

 
 (defalias 'valid-device-type-p 'valid-console-type-p)
 (defalias 'device-type-list 'console-type-list)
+(defalias 'device-pixel-depth 'device-bitplanes)
+
+;;; device.el ends here

lisp/prim/help.el

 (defun help-mode-quit ()
   "Exits from help mode, possibly restoring the previous window configuration."
   (interactive)
-  (cond ((local-variable-p 'help-window-config (current-buffer))
-         (let ((config help-window-config))
-	   (kill-local-variable 'help-window-config)
-	   (bury-buffer)
-	   (set-window-configuration config)))
+  (cond ((frame-property (selected-frame) 'help-window-config)
+	   (set-window-configuration
+	    (frame-property (selected-frame) 'help-window-config))
+	   (set-frame-property  (selected-frame) 'help-window-config nil))
         ((one-window-p)
 	 (bury-buffer))
         (t
 This just displays the buffer in another window, rather than selecting
 the window.")
 
-(defvar help-window-config nil)
 (defvar help-window-max-height .5
   "*Proportion of frame to use for help windows.")
 ;; Use this function for displaying help when C-h something is pressed
 ;;; requirement of caller to code a lambda form in THUNK -- mrb
 (defun with-displaying-help-buffer (thunk)
   (let ((winconfig (current-window-configuration))
-        (was-one-window (one-window-p)))
+        (was-one-window (one-window-p))
+	(help-not-visible
+	 (not (and (windows-of-buffer "*Help*") ;shortcut
+		   (member (selected-frame)
+			   (mapcar 'window-frame
+				   (windows-of-buffer "*Help*")))))))
     (prog1 (with-output-to-temp-buffer "*Help*"
              (prog1 (funcall thunk)
                (save-excursion
             (progn
               (save-excursion
                 (set-buffer (window-buffer helpwin))
-                (set (make-local-variable 'help-window-config) winconfig))
+		;;If the *Help* buffer is already displayed on this
+		;; frame, don't override the previous configuration
+		(if help-not-visible
+		    (set-frame-property (selected-frame)
+					'help-window-config winconfig)))
               (if help-selects-help-window
                   (select-window helpwin))
               (cond ((eq helpwin (selected-window))

lisp/prim/obsolete.el

   (color-instance-rgb-components (make-color-instance color)))
 (make-compatible 'x-color-values 'color-instance-rgb-components)
 
+;; Two loser functions which shouldn't be used.
+(make-obsolete 'following-char 'char-after)
+(make-obsolete 'preceding-char 'char-after)
+
 ;;; obsoloete.el ends here

lisp/prim/startup.el

   (setq init-file-loaded t)
 
   ;; Do this here in case the init file sets mail-host-address.
+  ;; Don't do this here unless noninteractive, it is frequently wrong. -sb
   (or user-mail-address
       (setq user-mail-address (concat (user-login-name) "@"
 				      (or mail-host-address

lisp/utils/mail-extr.el

   "*Whether to throw away information in UUCP addresses
 by translating things like \"foo!bar!baz@host\" into \"baz@bar.UUCP\".")
 
+(defvar mail-extr-mailbox-match-case-fold t
+  "*Non-nil if mailbox and name matching should ignore case.")
+
 ;;----------------------------------------------------------------------
 ;; what orderings are meaningful?????
 ;;(defvar mail-operator-precedence-list '(?! ?% ?@))
 					mbox-beg mbox-end)
 	       (while (and names-match-flag
 			   (< i buffer-length))
-		 (or (eq (downcase (char-after (+ i (point-min))))
+		 (or (eq (let ((c (char-after (+ i (point-min)))))
+			   (if mail-extr-mailbox-match-case-fold
+			       (downcase c)
+			     c))
 			 (downcase
 			  (char-after (+ i buffer-length (point-min)))))
 		     (setq names-match-flag nil))
 (defconst emacs-version "19.15" "\
 Version numbers of this version of Emacs.")
 
-(setq emacs-version (purecopy (concat emacs-version " XEmacs Lucid (beta101)")))
+(setq emacs-version (purecopy (concat emacs-version " XEmacs Lucid (beta102)")))
 
 (defconst emacs-major-version
   (progn (or (string-match "^[0-9]+" emacs-version)

lisp/w3/ChangeLog

+Thu Mar 20 06:22:29 1997  William M. Perry  <wmperry@aventail.com>
+
+* w3-parse.el:Added more transitions for error handling of raw 'td' or
+  'th' outside of a 'tr' in tablebody.
+
+* url.el (url-default-callback): asynch downloads should now be cached
+
+* w3-script.el (w3-do-scripting): Customized, turned off by default
+
+Wed Mar 19 20:53:23 1997  Steven L Baur  <steve@altair.xemacs.org>
+
+* Makefile (xemacs-w3): Special target for XEmacs Build.
+
+Wed Mar 19 05:56:56 1997  William M. Perry  <wmperry@aventail.com>
+
+* font.el (x-font-families-for-device): Just in case
+  font-default-family-for-device fails under Emacs/NT, return "monospace"
+  at the front of the list.
+
+* url-vars.el (url-privacy-level): Now defaults to not sending your email
+  address in HTTP requests.
+
+Tue Mar 18 13:09:13 1997  William M. Perry  <wmperry@aventail.com>
+
+* url-cookie.el (url-cookie-handle-set-cookie): Fixed variable typos -
+  doh.  Today just hasn't been my day.
+
+* Emacs-W3 3.0.70 released
+
+* We now pass all tests on the forms tester page
+  http://www.research.digital.com/nsl/formtest/home.html
+
+* w3-display.el (w3-display-node): Better handling of <select multiple>
+  and <select> in general.
+
+* w3-forms.el (w3-form-encode-xwfu): Encode : and / in xwfu, since the
+  form tester expects it.
+
+* url-cookie.el (url-cookie-trusted-urls): New variable - list of regexps
+  of URLs that you will accept cookies from without question.
+  (url-cookie-untrusted-urls): New variable - list of regexps of URLs that
+  you will _never_ accept cookies from.
+  (url-cookie-handle-set-cookie): Use them
+  (url-cookie-handle-set-cookie): When asking whether to allow a site to
+  set a cookie, show the cookies they are wanting to set.
+
+Tue Mar 18 06:47:46 1997  Thierry Emery <Thierry.Emery@aar.alcatel-alsthom.fr>
+
+* w3-display.el: Latest round of patches for <frames> support.
+
+* w3-cus.el (w3-display-frames): can now have 4 values.
+	nil		no frame display whatsoever (currently the default)
+	'as-links	display frame hyperlinks, but do not fetch them
+	'ask		display frame hyperlinks and ask whether to fetch them
+	t		display frame hyperlinks and fetch them
+
+Tue Mar 18 06:47:46 1997  William M. Perry  <wmperry@aventail.com>
+
+* w3-parse.el (w3-parse-buffer): Duh, don't do `=' comparison on results
+  of char-after, since it is nil at the end of the buffer.
+
 Mon Mar 17 08:44:46 1997  William M. Perry  <wmperry@aventail.com>
 
+* Emacs-W3 3.0.69 released
+
 * w3-sysdp.el (buffer-substring-no-properties): Added stub
 
 * url-gopher.el (url-gopher-retrieve): Ditto.
 w3:	check-custom docomp.el $(OBJECTS)
 	@echo Build of w3 complete...
 
+xemacs-w3:	docomp.el $(OBJECTS)
+	@echo Build of w3 complete...
+
+xemacs-w3: docomp.el $(OBJECTS)
+	@echo Build of w3 complete...
+
 all:	w3.info w3
 
 install: all
 ;;; font.el --- New font model
 ;; Author: wmperry
-;; Created: 1997/03/10 15:18:19
-;; Version: 1.36
+;; Created: 1997/03/19 18:28:10
+;; Version: 1.38
 ;; Keywords: faces
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (defconst font-window-system-mappings
   '((x        . (x-font-create-name x-font-create-object))
     (ns       . (ns-font-create-name ns-font-create-object))
-    (win32    . (x-font-create-name x-font-create-object)) ; Change? FIXME
+    (win32    . (x-font-create-name x-font-create-object))
     (pm       . (x-font-create-name x-font-create-object)) ; Change? FIXME
     (tty      . (tty-font-create-plist tty-font-create-object)))
   "An assoc list mapping device types to the function used to create
 		(normal (mapcar (function (lambda (x) (if x (aref x 0))))
 				(aref menu 1))))
 	    (sort (unique (nconc scaled normal)) 'string-lessp))))
-    (mapcar 'car font-family-mappings)))
+    (cons "monospace" (mapcar 'car font-family-mappings))))
 
 (defvar font-default-cache nil)
 
   ;; (if font-running-xemacs
   ;;    (format "%dpx" (face-height 'default device))
   (font-size (font-default-object-for-device device)))
-       
+
 (defun x-font-create-name (fontobj &optional device)
   (if (and (not (or (font-family fontobj)
 		    (font-weight fontobj)

lisp/w3/url-cookie.el

 ;;; url-cookie.el --- Netscape Cookie support
 ;; Author: wmperry
-;; Created: 1997/02/18 23:34:20
-;; Version: 1.11
+;; Created: 1997/03/19 00:42:23
+;; Version: 1.14
 ;; Keywords: comm, data, processes, hypermedia
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   "A regular expression of top-level domains that only require two matching
 '.'s in the domain name in order to set a cookie.")
 
+(defvar url-cookie-trusted-urls nil
+  "*A list of regular expressions matching URLs to always accept cookies from.")
+
+(defvar url-cookie-untrusted-urls nil
+  "*A list of regular expressions matching URLs to never accept cookies from.")
+
 (defun url-cookie-host-can-set-p (host domain)
   (let ((numdots 0)
 	(tmp domain)
 	 (domain (or (cdr-safe (assoc* "domain" args :test
 				       'url-header-comparison))
 		     (url-host url-current-object)))
+	 (current-url (url-view-url t))
+	 (trusted url-cookie-trusted-urls)
+	 (untrusted url-cookie-untrusted-urls)
 	 (expires (cdr-safe (assoc* "expires" args :test
 				    'url-header-comparison)))
 	 (path (or (cdr-safe (assoc* "path" args :test
 			      (url-match expires 3) " "
 			      (url-match expires 4) " ["
 			      (url-match expires 5) "]")))
+    (while (consp trusted)
+      (if (string-match (car trusted) current-url)
+	  (setq trusted (- (match-end 0) (match-beginning 0)))
+	(pop trusted)))
+    (while (consp untrusted)
+      (if (string-match (car untrusted) current-url)
+	  (setq untrusted (- (match-end 0) (match-beginning 0)))
+	(pop untrusted)))
+    (if (and trusted untrusted)
+	;; Choose the more specific match
+	(if (> trusted untrusted)
+	    (setq untrusted nil)
+	  (setq trusted nil)))
     (cond
+     (untrusted
+      ;; The site was explicity marked as untrusted by the user
+      nil)
      ((and (listp url-privacy-level) (memq 'cookies url-privacy-level))
       ;; user never wants cookies
       nil)
      ((and url-cookie-confirmation
-	   (not (funcall url-confirmation-func
-			 (format "Allow %s to set a cookie? "
-				 (url-host url-current-object)))))
+	   (not trusted)
+	   (save-window-excursion
+	     (with-output-to-temp-buffer "*Cookie Warning*"
+	       (mapcar
+		(function
+		 (lambda (x)
+		   (princ (format "%s - %s" (car x) (cdr x))))) rest))
+	     (prog1
+		 (not (funcall url-confirmation-func
+			       (format "Allow %s to set these cookies? "
+				       (url-host url-current-object))))
+	       (if (get-buffer "*Cookie Warning*")
+		   (kill-buffer "*Cookie Warning*")))))
       ;; user wants to be asked, and declined.
       nil)
      ((url-cookie-host-can-set-p (url-host url-current-object) domain)

lisp/w3/url-vars.el

 ;;; url-vars.el --- Variables for Uniform Resource Locator tool
 ;; Author: wmperry
-;; Created: 1997/03/18 01:10:34
-;; Version: 1.36
+;; Created: 1997/03/20 18:03:50
+;; Version: 1.39
 ;; Keywords: comm, data, processes, hypermedia
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; Boston, MA 02111-1307, USA.
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(defconst url-version (let ((x "p3.0.69"))
+(defconst url-version (let ((x "p3.0.71"))
 			(if (string-match "State: \\([^ \t\n]+\\)" x)
 			    (substring x (match-beginning 1) (match-end 1))
 			  x))
 exists, and is readable, then it will be viewed instead of
 automatically creating the directory listing.")
 
-(defvar url-privacy-level 'none
+(defvar url-privacy-level '(email)
   "*How private you want your requests to be.
 HTTP/1.0 has header fields for various information about the user, including
 operating system information, email addresses, the last page you visited, etc.
 ;;; url.el --- Uniform Resource Locator retrieval tool
 ;; Author: wmperry
-;; Created: 1997/03/18 01:08:13
-;; Version: 1.65
+;; Created: 1997/03/20 15:45:21
+;; Version: 1.66
 ;; Keywords: comm, data, processes, hypermedia
 
 ;;; LCD Archive Entry:
 ;;; url|William M. Perry|wmperry@cs.indiana.edu|
 ;;; Functions for retrieving/manipulating URLs|
-;;; 1997/03/18 01:08:13|1.65|Location Undetermined
+;;; 1997/03/20 15:45:21|1.66|Location Undetermined
 ;;;
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (defun url-default-callback (buf)
   (url-download-minor-mode nil)
-  (url-store-in-cache)
+  (url-store-in-cache buf)
   (cond
    ((save-excursion (set-buffer buf)
 		    (and url-current-callback-func

lisp/w3/w3-cus.el

 ;;; w3-cus.el --- Customization support for Emacs-W3
 ;; Author: wmperry
-;; Created: 1997/03/14 21:35:54
-;; Version: 1.4
+;; Created: 1997/03/18 20:30:34
+;; Version: 1.5
 ;; Keywords: comm, help, hypermedia
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;;; Display related variables
 (defcustom w3-display-frames nil
-  "*Fetch frames - not optimal."
+  "*Fetch frames - can be:
+nil		no frame display whatsoever
+'as-links	display frame hyperlinks, but do not fetch them
+'ask		display frame hyperlinks and ask whether to fetch them
+t		display frame hyperlinks and fetch them."
   :group 'w3-display
-  :type 'boolean)
+  :type '(choice (const :tag "Do not display frames" :value nil)
+		 (const :tag "Show hyperlinks" :value as-links)
+		 (const :tag "Show hyperlinks, ask whether to retrieve them" :value ask)
+		 (const :tag "Automatically retrieve frames" :value t)))
 
 (defcustom w3-do-incremental-display nil
   "*Whether to do incremental display of pages or not."

lisp/w3/w3-display.el

 ;;; w3-display.el --- display engine v99999
 ;; Author: wmperry
-;; Created: 1997/03/17 20:09:50
-;; Version: 1.148
+;; Created: 1997/03/18 23:20:40
+;; Version: 1.150
 ;; Keywords: faces, help, hypermedia
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 	    (frameset
 	     (if w3-display-frames
 		 (progn
-		   (push 'frameset w3-frameset-structure)
-		   (let ((cols (assq 'cols args))
-			 (rows (assq 'rows args)))
-		     (if rows
-			 (setq w3-frameset-dimensions (push rows w3-frameset-dimensions)))
-		     (if cols
-			 (setq w3-frameset-dimensions (push cols w3-frameset-dimensions))))
+		   (push (list 'frameset
+			       (or (assq 'cols args) (assq 'rows args)))
+			 w3-frameset-structure)
 		   (w3-handle-content node))
 	       (w3-handle-content node)))
 	    (frame
 				  (w3-get-attribute 'title)
 				  (w3-get-attribute 'alt)
 				  "Unknown frame name")))
-		   (push 'frame w3-frameset-structure)
+		   (push (list 'frame name href) w3-frameset-structure)
 		   (w3-handle-content
 		    (list tag args
 			  (list
 				  (list 'a
 					(cons (cons 'href href)
 					      args)
-					(list
-					 (car w3-frame-labels)
-					 name
-					 (cdr w3-frame-labels)))))))))
+					(list "Fetch frame: " name))))))))
 	       (w3-handle-empty-tag)))
 	    (noframes
 	     (if w3-display-frames
 			       (lambda (n)
 				 (setq tmp (w3-normalize-spaces
 					    (apply 'concat (nth 2 n)))
-				       tmp (cons tmp
-						 (or
-						  (cdr-safe
-						   (assq 'value (nth 1 n)))
-						  tmp)))
+				       tmp (vector tmp
+						   (or
+						    (cdr-safe
+						     (assq 'value (nth 1 n)))
+						    tmp)
+						   (assq 'selected (nth 1 n))))
 				 (if (assq 'selected (nth 1 n))
-				     (setq value (car tmp)))
+				     (setq value (aref tmp 0)))
 				 tmp))
 			      (nth 2 node))))
 	       (if (not value)
-		   (setq value (caar options)))
+		   (setq value (aref (car options) 0)))
 	       (setq plist (plist-put plist 'value value))
 	       (if multiple
 		   (progn
 				      (list 'input
 					    (list (cons 'name name)
 						  (cons 'type "checkbox")
-						  (cons 'value (car opt))))
-				      " " (car opt) (list 'br nil nil)))))
+						  (cons (if (aref opt 2)
+							    'checked
+							  '__bogus__) "yes")
+						  (cons 'value (aref opt 1))))
+				      " " (aref opt 0) (list 'br nil nil)))))
 			    options))
 		     (setq node (list 'p nil options))
 		     (w3-handle-content node))
+		 (setq options (mapcar (function
+					(lambda (x)
+					  (cons (aref x 0) (aref x 1))))
+				       options))
 		 (setq plist (plist-put plist 'type 'option)
 		       plist (plist-put plist 'options options))
 		 (w3-form-add-element plist w3-active-faces)
 	  (cl-puthash url (buffer-name) url-history-list)
 	  (if (fboundp 'w3-shuffle-history-menu)
 	      (w3-shuffle-history-menu)))))
-  )
+  (w3-maybe-fetch-frames))
+
+(defun w3-maybe-fetch-frames ()
+  (if w3-frameset-structure
+      (cond ((or (eq w3-display-frames t)
+		 (and (eq w3-display-frames 'ask)
+		      (y-or-n-p "Fetch frames? ")))
+	     (w3-frames)
+	     t))))
 
 (defun w3-frames (&optional new-frame)
   "Set up and fetch W3 frames. With optional prefix, do so in a new frame."
       (let ((w3-display-frames t))
 	(w3-refresh-buffer)))
   (let* ((old-asynch url-be-asynchronous)
-	 (structure (reverse w3-frameset-structure))
-	 (dims (or (reverse w3-frameset-dimensions)
-		   t)))
+	 (structure (reverse w3-frameset-structure)))
     (if new-frame
 	(select-frame (make-frame-command)))
-    (goto-char (point-min))
     (setq-default url-be-asynchronous nil)
     ;; set up frames
-    (while (and structure dims)
-      (let* ((current-dims (list (car dims)))
-	     (cols (cdr-safe (assq 'cols current-dims)))
-	     (rows (cdr-safe (assq 'rows current-dims))))
-	(if (eq (car structure) 'frameset)
-	    (pop structure))
-	;; columns ?
-	(if cols
-	    (setq cols (w3-decode-frameset-dimensions cols (window-width)))
-	  ;; rows ?
-	  (if rows
-	      (setq rows (w3-decode-frameset-dimensions rows (window-height)))
-	    ;; default: columns of equal width
-	    (let ((nb-windows 0))
-	      (save-excursion
-		(while (re-search-forward w3-frame-regexp nil t)
-		  (setq nb-windows (1+ nb-windows))))
-	      (let ((fwidth (/ (window-width) nb-windows)))
-		(while (> nb-windows 0)
-		  (push fwidth cols)
-		  (setq nb-windows (1- nb-windows)))))))
-	(while (eq (car structure) 'frame)
-	  (if (re-search-forward w3-frame-regexp nil t)
-	      (progn
-		(if (cdr cols)
-		    (split-window-horizontally (min (car cols)
-						    (- (window-width) 12)))
-		  (if (cdr rows)
-		      (split-window-vertically (min (car rows)
-						    (- (window-height) 12)))))
-		(pop cols)
-		(pop rows)
-		(goto-char (+ (match-beginning 0) 5))
-		(let ((name (buffer-substring-no-properties (match-beginning 1) (match-end 1)))
-		      (w3-notify 'semibully))
-		  (w3-widget-button-press)
-		  (setq w3-frame-name name
-			w3-target-window-distances nil))
-		(other-window 1)))
-	  (pop structure)))
-      (if (consp dims)
-	  (pop dims)
-	(setq dims nil)))
+    (while structure
+      (if (eq (car (car structure)) 'frameset)
+	  (let* ((current-dims (cdr (car structure)))
+		 (cols (cdr-safe (assq 'cols current-dims)))
+		 (rows (cdr-safe (assq 'rows current-dims))))
+	    (pop structure)
+	    ;; columns ?
+	    (if cols
+		(setq cols (w3-decode-frameset-dimensions cols (window-width) window-min-width))