Commits

cvs  committed 7e54bd7

Import from CVS: tag r19-15b103

  • Participants
  • Parent commits 06f2757
  • Tags r19-15b103

Comments (0)

Files changed (91)

File CHANGES-beta

 							-*- indented-text -*-
+to 19.15 beta103
+-- VM-6.21
+-- tm-7.106
+-- Garbage Collection patches courtesy of David Moore
+-- time.el update
+-- cc-mode.el-4.387
+-- EFS integration/bug fix patches courtesy of Michael Sperber
+-- safe char-before added
+-- minor build tweaks
+-- miscellaneous bug fixes
+
 to 19.15 beta102
 -- preceding-char, following-char are obsolete and broken, do not use them
 -- miscellaneous bug fixes
 # Build XEmacs and recompile out-of-date and missing .elc files along
 # the way.
 all-elc:	src/paths.h src/Emacs.ad.h lib-src lwlib dump-elcs src
-	sh ${srcdir}/lib-src/update-elc.sh
+	MAKE='$(MAKE)' sh ${srcdir}/lib-src/update-elc.sh
 
 # Sub-target for all-elc.
 dump-elcs:	FRC.dump-elcs
 		CC='${CC}' CFLAGS='${CFLAGS}' MAKE='${MAKE}'
 
 autoloads:	src
-	sh ${srcdir}/lib-src/update-autoloads.sh
+	MAKE='$(MAKE)' sh ${srcdir}/lib-src/update-autoloads.sh
 
 # We force the rebuilding of src/paths.h because the user might give
 # different values for the various directories.  Since we use

File etc/time/0.xpm

Old
Old image
New
New image

File etc/time/1.xpm

Old
Old image
New
New image

File etc/time/2.xpm

Old
Old image
New
New image

File etc/time/3.xpm

Old
Old image
New
New image

File etc/time/4.xpm

Old
Old image
New
New image

File etc/time/5.xpm

Old
Old image
New
New image

File etc/time/6.xpm

Old
Old image
New
New image

File etc/time/7.xpm

Old
Old image
New
New image

File etc/time/8.xpm

Old
Old image
New
New image

File etc/time/9.xpm

Old
Old image
New
New image

File etc/time/am.xpm

Old
Old image
New
New image

File etc/time/dp.xpm

Old
Old image
New
New image

File etc/time/l-0.0.xpm

Old
Old image
New
New image

File etc/time/l-0.5.xpm

Old
Old image
New
New image

File etc/time/l-1.0.xpm

Old
Old image
New
New image

File etc/time/l-1.5.xpm

Old
Old image
New
New image

File etc/time/l-2.0.xpm

Old
Old image
New
New image

File etc/time/l-2.5.xpm

Old
Old image
New
New image

File etc/time/l-3.0.xpm

Old
Old image
New
New image

File etc/time/l-jtl-0.0.xpm

Removed
Old image

File etc/time/l-jtl-0.5.xpm

Removed
Old image

File etc/time/l-jtl-1.0.xpm

Removed
Old image

File etc/time/l-jtl-1.5.xpm

Removed
Old image

File etc/time/l-jtl-2.0.xpm

Removed
Old image

File etc/time/l-jtl-2.5.xpm

Removed
Old image

File etc/time/l-jtl-3.0.xpm

Removed
Old image

File etc/time/pm.xpm

Old
Old image
New
New image

File lib-src/emacsserver.c

 
 #include <sys/types.h>
 #include <sys/file.h>
-#include <sys/socket.h>
 #include <sys/signal.h>
 #include <sys/stat.h> /* Needed for chmod, at least on Linux */
 #include <sys/un.h>
 #include <stdio.h>
 #include <errno.h>
 #include "../src/sysproc.h" /* Needed for select */
+#ifndef SOCK_STREAM
+/* this is normally included by src/sysproc.h.  might be safe to omit
+ * it entirely.  lousy ultrix's sys/socket.h chokes if it's included
+ * twice, so we can't include unconditionally.  */
+#include <sys/socket.h>
+#endif
 
 void
 main ()

File lisp/bytecomp/disass.el

 		)
 	  (insert "\n")))))
   nil)
+
+(provide 'disass)
+
+;;; disass.el ends here

File lisp/efs/Makefile

 #
 # File:         Makefile
 # Release:      $efs release: 1.15 $
-# Version:      $Revision: 1.3 $
+# Version:      $Revision: 1.4 $
 # RCS:
 # Description:  Makefile for byte-compiling efs and dired.
 # Author:       Andy Norman, HPLabs, Bristol, UK.
 COREOBJS = efs-defun.elc efs-ovwrt.elc efs-fnh.elc efs-cu.elc efs-netrc.elc \
            efs.elc efs-dired.elc efs-report.elc \
            efs-cp-p.elc
+CORESRC = efs-defun.el efs-ovwrt.el efs-fnh.el efs-cu.el efs-netrc.el \
+          efs.el efs-dired.el efs-report.el \
+          efs-cp-p.el \
+	  efs-dump.el
 DOBJS = default-dir.elc dired.elc dired-mob.elc dired-oas.elc \
         dired-rgxp.elc dired-shell.elc dired-vir.elc dired-xy.elc \
         dired-grep.elc dired-uu.elc \
         dired-cmpr.elc dired-diff.elc dired-help.elc dired-sex.elc
+DSRC = default-dir.el dired.el dired-mob.el dired-oas.el \
+       dired-rgxp.el dired-shell.el dired-vir.el dired-xy.el \
+       dired-grep.el dired-uu.el \
+       dired-cmpr.el dired-diff.el dired-help.el dired-sex.el
 EFSOBJS = $(COREOBJS) efs-auto.elc \
           efs-cms.elc efs-cms-knet.elc efs-dos-distinct.elc efs-nos-ve.elc \
           efs-gwp.elc efs-kerberos.elc efs-hell.elc efs-ka9q.elc \
           efs-pc.elc efs-ti-explorer.elc efs-ti-twenex.elc \
           efs-tops-20.elc efs-dl.elc efs-guardian.elc efs-coke.elc \
           efs-vms.elc efs-vos.elc efs-plan9.elc efs-ms-unix.elc
+EFSSRC = $(CORESRC) efs-auto.el \
+          efs-cms.el efs-cms-knet.el efs-dos-distinct.el efs-nos-ve.el \
+          efs-gwp.el efs-kerberos.el efs-hell.el efs-ka9q.el \
+          efs-mpe.el efs-mts.el efs-mvs.el efs-netware.el \
+          efs-pc.el efs-ti-explorer.el efs-ti-twenex.el \
+          efs-tops-20.el efs-dl.el efs-guardian.el efs-coke.el \
+          efs-vms.el efs-vos.el efs-plan9.el efs-ms-unix.el
 VMOBJS = efs-vm.elc
+VMSRC = efs-vm.el
 GEOBJS = dired-fsf.elc dired-mule.elc efs-dired-mule.elc \
 	 passwd.elc diff.elc auto-save.elc
+GESRC = dired-fsf.el dired-mule.el efs-dired-mule.el \
+	passwd.el diff.el auto-save.el
 XEOBJS = dired-faces.elc dired-xemacs.elc
+XESRC = dired-faces.el dired-xemacs.el
 OBJS = $(DOBJS) $(EFSOBJS) $(VMOBJS) $(GEOBJS) $(XEOBJS) \
        efs-18.elc efs-19.elc efs-19.23.elc \
        efs-l19.11.elc efs-x19.15.elc \
 # backward compatibility files
 fn-handler.elc: fn-handler.el
 emacs-19.elc: emacs-19.el
+# auto-save package
+auto-save.elc: auto-save.el
 
 # Core targets
 core: $(COREOBJS)
 efs: $(EFSOBJS)
 dired: $(DOBJS)
 all: $(OBJS)
+info: efs.info
 
 # Making for a specific emacs version
 18: emacs-19.elc fn-handler.elc efs dired efs-18.elc dired-mule.elc \
 	@echo "Installing in $(LISPDIR)..."
 	@ls -C `ls *.el 2>&1 | grep -v "fixup"` 2> /dev/null
 	cp `ls *.el | grep -v "fixup"` $(LISPDIR)
+install_xemacs:
+	@echo "Installing source in $(LISPDIR)..."
+	cp $(EFSSRC) $(DSRC) $(XESRC) efs-x19.15.el $(LISPDIR)
+	cp Makefile README fixup.el $(LISPDIR)
+diff_xemacs:
+	for f in $(EFSSRC) $(DSRC) $(XESRC) efs-x19.15.el \
+	         Makefile README fixup.el; do \
+		if [ -e $(LISPDIR)/$$f ]; \
+		then\
+		  diff -c $(LISPDIR)/$$f $$f; \
+		else \
+		  diff -c /dev/null $$f; \
+		fi \
+	done
 install_all: install_src install
 clean:
 	rm -f $(OBJS)

File lisp/efs/default-dir.el

 ;;
 ;; File:         default-dir.el
 ;; RCS:
-;; Version:      $Revision: 1.2 $
+;; Version:      $Revision: 1.5 $
 ;; Description:  Defines the function default-directory, for fancy handling
 ;;               of the initial contents in the minibuffer when reading
 ;;               file names.
 	((>= (string-to-int (substring emacs-version 0 2)) 19) 'fsf-19)
 	(t 'fsf-18)))
 
+(defconst default-dir-find-file-takes-coding-system
+  (and (eq default-dir-emacs-variant 'xemacs)
+       (>= (string-to-int (substring emacs-version 0 2)) 20)))
+
 ;;;###autoload
 (defvar default-directory-function nil
   "A function to call to compute the default-directory for the current buffer.
 
 ;;; Overloads
 
-(if (or (featurep 'mule)
-	(boundp 'MULE))
-    (progn
-      
-      (defun default-dir-find-file (file &optional coding-system)
-	"Documented as original"
-	(interactive   
-	 (list
-	  (expand-file-name
-	   (read-file-name "Find file: " (default-directory)))
-	  (and current-prefix-arg
-	       (read-coding-system "Coding-system: "))))
-	(default-dir-real-find-file file coding-system))
+(cond
+ ((or (featurep 'mule)
+      (boundp 'MULE))
 
-      (defun default-dir-find-file-other-window (file &optional coding-system)
-	"Documented as original"
-	(interactive
-	 (list
-	  (expand-file-name
-	   (read-file-name "Find file in other window: " (default-directory)))
-	  (and current-prefix-arg
-	       (read-coding-system "Coding-system: "))))
-	(default-dir-real-find-file-other-window file coding-system))
+  (defun default-dir-find-file (file &optional coding-system)
+    "Documented as original"
+    (interactive   
+     (list
+      (expand-file-name
+       (read-file-name "Find file: " (default-directory)))
+      (and current-prefix-arg
+	   (read-coding-system "Coding-system: "))))
+    (default-dir-real-find-file file coding-system))
 
-      (defun default-dir-find-file-read-only (file &optional coding-system)
-	"Documented as original"
-	(interactive
-	 (list
-	  (expand-file-name
-	   (read-file-name "Find file read-only: " (default-directory) nil t))
-	  (and current-prefix-arg
-	       (read-coding-system "Coding-system: "))))
-	(default-dir-real-find-file-read-only file coding-system))
+  (defun default-dir-find-file-other-window (file &optional coding-system)
+    "Documented as original"
+    (interactive
+     (list
+      (expand-file-name
+       (read-file-name "Find file in other window: " (default-directory)))
+      (and current-prefix-arg
+	   (read-coding-system "Coding-system: "))))
+    (default-dir-real-find-file-other-window file coding-system))
 
-      (if (fboundp 'find-file-read-only-other-window)
-	  (progn
-	    (defun default-dir-find-file-read-only-other-window
-	      (file &optional coding-system)
-	      "Documented as original"
-	      (interactive
-	       (list
-		(expand-file-name
-		 (read-file-name
-		  "Find file read-only in other window: "
-		  (default-directory) nil t))
-		(and current-prefix-arg
-		     (read-coding-system "Coding-system: "))))
-	      (default-dir-real-find-file-read-only-other-window file
-		coding-system))))
+  (defun default-dir-find-file-read-only (file &optional coding-system)
+    "Documented as original"
+    (interactive
+     (list
+      (expand-file-name
+       (read-file-name "Find file read-only: " (default-directory) nil t))
+      (and current-prefix-arg
+	   (read-coding-system "Coding-system: "))))
+    (default-dir-real-find-file-read-only file coding-system))
 
-      (if (fboundp 'find-file-other-frame)
-	  (progn
-	    (defun default-dir-find-file-other-frame
-	      (file &optional coding-system)
-	      "Documented as original"
-	      (interactive
-	       (list
-		(expand-file-name
-		 (read-file-name "Find file in other frame: "
-				 (default-directory)))
-		(and current-prefix-arg
-		     (read-coding-system "Coding-system: "))))
-	      (default-dir-real-find-file-other-frame file
-		coding-system))))
+  (if (fboundp 'find-file-read-only-other-window)
+      (progn
+	(defun default-dir-find-file-read-only-other-window
+	  (file &optional coding-system)
+	  "Documented as original"
+	  (interactive
+	   (list
+	    (expand-file-name
+	     (read-file-name
+	      "Find file read-only in other window: "
+	      (default-directory) nil t))
+	    (and current-prefix-arg
+		 (read-coding-system "Coding-system: "))))
+	  (default-dir-real-find-file-read-only-other-window file
+	    coding-system))))
+
+  (if (fboundp 'find-file-other-frame)
+      (progn
+	(defun default-dir-find-file-other-frame
+	  (file &optional coding-system)
+	  "Documented as original"
+	  (interactive
+	   (list
+	    (expand-file-name
+	     (read-file-name "Find file in other frame: "
+			     (default-directory)))
+	    (and current-prefix-arg
+		 (read-coding-system "Coding-system: "))))
+	  (default-dir-real-find-file-other-frame file
+	    coding-system))))
   
-      (if (fboundp 'find-file-read-only-other-frame)
-	  (progn
-	    (defun default-dir-find-file-read-only-other-frame
-	      (file &optional coding-system)
-	      "Documented as original"
-	      (interactive
-	       (list
-		(expand-file-name
-		 (read-file-name "Find file read-only in other frame: "
-				 (default-directory) nil t))
-		(and current-prefix-arg
-		     (read-coding-system "Coding-system: "))))
-	      (default-dir-real-find-file-read-only-other-frame file
-		coding-system)))))
+  (if (fboundp 'find-file-read-only-other-frame)
+      (progn
+	(defun default-dir-find-file-read-only-other-frame
+	  (file &optional coding-system)
+	  "Documented as original"
+	  (interactive
+	   (list
+	    (expand-file-name
+	     (read-file-name "Find file read-only in other frame: "
+			     (default-directory) nil t))
+	    (and current-prefix-arg
+		 (read-coding-system "Coding-system: "))))
+	  (default-dir-real-find-file-read-only-other-frame file
+	    coding-system)))))
 
+ (default-dir-find-file-takes-coding-system
+   ;; This lossage is due to the fact that XEmacs 20.x without mule
+   ;; still accepts an optional argument for find-file related
+   ;; functions.  Things like advice.el insist on passing nil for
+   ;; optional arguments, and the interaction screws things up.
+   ;; Therefore these functions accept an optional dummy coding-system
+   ;; argument.
+    
+   (defun default-dir-find-file (file &optional coding-system)
+     "Documented as original"
+     (interactive
+      (list
+       (expand-file-name
+	(read-file-name "Find file: " (default-directory)))))
+     (default-dir-real-find-file file))
+  
+   (defun default-dir-find-file-other-window (file &optional coding-system)
+     "Documented as original"
+     (interactive
+      (list
+       (expand-file-name
+	(read-file-name "Find file in other window: " (default-directory)))))
+     (default-dir-real-find-file-other-window file))
+
+   (defun default-dir-find-file-read-only (file  &optional coding-system)
+     "Documented as original"
+     (interactive
+      (list
+       (expand-file-name
+	(read-file-name "Find file read-only: " (default-directory) nil t))))
+     (default-dir-real-find-file-read-only file))
+  
+   (if (fboundp 'find-file-read-only-other-window)
+       (progn
+	 (defun default-dir-find-file-read-only-other-window
+	   (file  &optional coding-system)
+	   "Documented as original"
+	   (interactive
+	    (list
+	     (expand-file-name
+	      (read-file-name
+	       "Find file read-only in other window: "
+	       (default-directory) nil t))))
+	   (default-dir-real-find-file-read-only-other-window file))))
+
+   (if (fboundp 'find-file-other-frame)
+       (progn
+	 (defun default-dir-find-file-other-frame
+	   (file  &optional coding-system)
+	   "Documented as original"
+	   (interactive
+	    (list
+	     (expand-file-name
+	      (read-file-name "Find file in other frame: "
+			      (default-directory)))))
+	   (default-dir-real-find-file-other-frame file))))
+
+   (if (fboundp 'find-file-read-only-other-frame)
+       (progn
+	 (defun default-dir-find-file-read-only-other-frame
+	   (file &optional coding-system)
+	   "Documented as original"
+	   (interactive
+	    (list
+	     (expand-file-name
+	      (read-file-name "Find file read-only in other frame: "
+			      (default-directory) nil t))))
+	   (default-dir-real-find-file-read-only-other-frame file)))))
+
+ (t
+    
   (defun default-dir-find-file (file)
     "Documented as original"
     (interactive
 	    (expand-file-name
 	     (read-file-name "Find file read-only in other frame: "
 			     (default-directory) nil t))))
-	  (default-dir-real-find-file-read-only-other-frame file)))))
+	  (default-dir-real-find-file-read-only-other-frame file))))))
+
+ 
 
 (efs-overwrite-fn "default-dir" 'find-file 'default-dir-find-file)
 (efs-overwrite-fn "default-dir" 'find-file-other-window
 
 (efs-overwrite-fn "default-dir" 'shell-command 'default-dir-shell-command)
 
-;; Is advice about?
-(if (featurep 'advice)
-    (defadvice cd (before default-dir-cd activate compile)
-      (interactive
-       (list
-	(expand-file-name
-	 (read-file-name "Change default directory: " (default-directory))))))
-
-  (defun default-dir-cd (dir)
-    "Documented as original"
-    (interactive
-     (list
-      (expand-file-name
-       (read-file-name "Change default directory: " (default-directory)))))
-    (default-dir-real-cd dir))
+(defun default-dir-cd (dir)
+  "Documented as original"
+  (interactive
+   (list
+    (expand-file-name
+     (read-file-name "Change default directory: " (default-directory)))))
+  (default-dir-real-cd dir))
   
-  (efs-overwrite-fn "default-dir" 'cd 'default-dir-cd))
+(efs-overwrite-fn "default-dir" 'cd 'default-dir-cd)
 
 (defun default-dir-set-visited-file-name (filename)
   "Documented as original"

File lisp/efs/dired-cmpr.el

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:          dired-cmpr.el
-;; Dired Version: $Revision: 1.1 $
+;; Dired Version: $Revision: 7.9 $
 ;; RCS:
 ;; Description:   Commands for compressing marked files.
 ;;

File lisp/efs/dired-diff.el

 ;;
 ;; File:           dired-diff.el
 ;; RCS:
-;; Dired Version:  $Revision: 1.1 $
+;; Dired Version:  $Revision: 7.9 $
 ;; Description:    Support for diff and related commands.
 ;; Author:         Sandy Rutherford <sandy@ibm550.sissa.it>
 ;; Created:        Fri Jun 24 08:50:20 1994 by sandy on ibm550

File lisp/efs/dired-faces.el

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:          dired-faces.el
-;; Dired Version: $Revision: 1.1 $
+;; Dired Version: $Revision: 1.2 $
 ;; RCS:
 ;; Description:   rudimentary face customization support for dired
 ;; Author:        Mike Sperber <sperber@informatik.uni-tuebingen.de>
   "Face used for interactive permissions."
   :group 'dired)
 
-(defface dired-face-deleted '((((class color))
-			       (:foreground "yellow3"))
-			      (t (:reverse t)))
-  "Face used to indicate deleted files."
-  :group 'dired)
-
 (defface dired-face-socket '((((class color))
 			      (:foreground "magenta"))
 			     (t (:bold nil)))

File lisp/efs/dired-grep.el

 ;;
 ;; File:           dired-grep.el
 ;; RCS:
-;; Dired Version:  $Revision: 1.1 $
+;; Dired Version:  $Revision: 7.9 $
 ;; Description:    Support for running grep on marked files in a dired buffer.
 ;; Author:         Sandy Rutherford <sandy@ibm550.sissa.it>
 ;; Created:        Tue Jul 13 22:59:37 1993 by sandy on ibm550

File lisp/efs/dired-help.el

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:          dired-help.el
-;; Dired Version: $Revision: 1.1 $
+;; Dired Version: $Revision: 7.9 $
 ;; RCS:
 ;; Description:   Obtaining help for dired
 ;; Modified:      Sun Nov 20 21:10:47 1994 by sandy on gandalf

File lisp/efs/dired-mob.el

 ;;
 ;; File:           dired-mob.el
 ;; RCS:
-;; Dired Version:  $Revision: 1.1 $
+;; Dired Version:  $Revision: 7.9 $
 ;; Description:    Commands for marking files from another buffer.
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

File lisp/efs/dired-oas.el

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:          dired-oas.el
-;; Dired Version: $Revision: 1.1 $
+;; Dired Version: $Revision: 7.9 $
 ;; RCS:
 ;; Description:   dired odds and sods. Dired functions not usually needed.
 ;;                This file is not a reference to the Organization of

File lisp/efs/dired-rgxp.el

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:           dired-rgxp.el
-;; Dired Version: $Revision: 1.1 $
+;; Dired Version: $Revision: 7.9 $
 ;; RCS:
 ;; Description:   Commands for running commands on files whose names
 ;;                match a regular expression.

File lisp/efs/dired-sex.el

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:          dired-sex.el
-;; Dired Version: $Revision: 1.1 $
+;; Dired Version: $Revision: 7.9 $
 ;; RCS:
 ;; Description:   Marking files according to sexpressions.  Sorry.
 ;; Created:       Wed Sep 14 01:30:43 1994 by sandy on ibm550

File lisp/efs/dired-shell.el

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:          dired-shell.el
-;; Dired Version: $Revision: 1.1 $
+;; Dired Version: $Revision: 7.9 $
 ;; RCS:
 ;; Description:   Commands for running shell commands on marked files.
 ;;
 ;;; Variables
 
 (defvar dired-postscript-print-command
-  (concat
-   (if (boundp 'lpr-command)
-       lpr-command
-     (if (memq system-type
-	       '(usg-unix-v hpux silicon-graphics-unix))
-	 "lp"
-       "lpr"))
-   (if (and (boundp 'lpr-switches) lpr-switches)
-       (concat " "
-	       (mapconcat 'identity lpr-switches " ")
-	       " ")
-     " "))
-  "Command to print a postscript file.")
+  (condition-case nil
+      (progn
+	(require 'ps-print)
+	(concat ps-lpr-command
+		" "
+		(ps-flatten-list (mapcar 'ps-eval-switch ps-lpr-switches))))
+    (error
+     (concat
+      (if (boundp 'lpr-command)
+	  lpr-command
+	(if (memq system-type
+		  '(usg-unix-v hpux silicon-graphics-unix))
+	    "lp"
+	  "lpr"))
+      (if (and (boundp 'lpr-switches) lpr-switches)
+	  (concat " "
+		  (mapconcat 'identity lpr-switches " ")
+		  " ")
+	" "))))
+     "Command to print a postscript file.")
 
-(defvar dired-text-print-command (concat dired-postscript-print-command " -p")
+(defvar dired-text-print-command (concat dired-postscript-print-command "-p ")
   "Command to print a text file.")
 
 (defvar dired-print-program-alist

File lisp/efs/dired-uu.el

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:          dired-uu.el
-;; Dired Version: $Revision: 1.1 $
+;; Dired Version: $Revision: 7.9 $
 ;; RCS:
 ;; Description:   Commands for uuencoding/uudecoding marked files.
 ;; Author:        Sandy Rutherford <sandy@math.ubc.ca>

File lisp/efs/dired-vir.el

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:          dired-vir.el
-;; Dired Version: $Revision: 1.1 $
+;; Dired Version: $Revision: 7.9 $
 ;; RCS:
 ;; Description:   Virtual dired mode for browsing ls -lR listings.
 ;; Author:        Sebastian Kremer <sk@thp.uni-koeln.de>

File lisp/efs/dired-xemacs.el

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:          dired-xemacs.el
-;; Dired Version: $Revision: 1.1 $
+;; Dired Version: $Revision: 7.9 $
 ;; RCS:
 ;; Description:   dired functions for XEmacs
 ;; Author:        Mike Sperber <sperber@informatik.uni-tuebingen.de>
   "Installs the Dired menu at the menubar."
   (if (null dired-help-menu)
       (dired-setup-menus))
-  (if current-menubar
+  (if (and (featurep 'menubar) current-menubar)
       (progn
 	(let ((buffer-menubar (copy-sequence current-menubar)))
 	  (delete (assoc "Edit" buffer-menubar) buffer-menubar)

File lisp/efs/dired-xy.el

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; File:          dired-xy.el
-;; Dired Version: $Revision: 1.1 $
+;; Dired Version: $Revision: 7.9 $
 ;; RCS:
 ;; Description:   Commands for reading mail from dired.
 ;;

File lisp/efs/dired.el

    ((< ver 18)
     (error "dired does not work with emacs version %s" emacs-version))))
 
-;; Load default-dir last, because we want its interactive specs.
-(require 'default-dir)
-
+;; We duplicate default-dir stuff to avoid its overwrites unless
+;; they are explicitly requested.
+
+(defvar default-directory-function nil
+  "A function to call to compute the default-directory for the current buffer.
+If this is nil, the function default-directory will return the value of the
+variable default-directory.
+Buffer local.")
+(make-variable-buffer-local 'default-directory-function)
+
+(defun default-directory ()
+  " Returns the default-directory for the current buffer.
+Will use the variable default-directory-function if it non-nil."
+  (if default-directory-function
+      (funcall default-directory-function)
+    (if (string-match "Lucid" emacs-version)
+	(abbreviate-file-name default-directory t)
+      (abbreviate-file-name default-directory))))
 
 ;;;;----------------------------------------------------------------
 ;;;; Customizable variables
  
  For example:
  
-   \(setq dired-compresssion-method-alist
+   \(setq dired-compression-method-alist
          \(cons '\(frobnicate \".frob\" \(\"frob\"\) \(\"frob\" \"-d\"\) \"-f\"\)
                dired-compression-method-alist\)\)
    => \(\(frobnicate \".frob\" \(\"frob\"\) \(\"frob\" \"-d\"\)\) 
 ;;;###autoload
 (defvar dired-chown-program
   (if (memq system-type '(hpux dgux usg-unix-v)) "chown" "/etc/chown")
-  "*Name of chown command (usully `chown' or `/etc/chown').")
+  "*Name of chown command (usually `chown' or `/etc/chown').")
 
 ;;;###autoload
 (defvar dired-gnutar-program nil
 Optional CHAR indicates a marker character to use."
   (let (buffer-read-only)
     (if (memq (or char dired-marker-char) '(?\  ?\n ?\r))
-	(error "Invalid marker charcter %c" dired-marker-char))
+	(error "Invalid marker character %c" dired-marker-char))
     (or char (setq char dired-marker-char))
     (dired-repeat-over-lines
      arg

File lisp/efs/efs-auto.el

 ;;
 ;; File:         efs-auto.el
 ;; Release:      $efs release: 1.15 $
-;; Version:      $Revision: 1.1 $
+;; Version:      $Revision: 1.7 $
 ;; RCS:          
 ;; Description:  Simple way of autoloading efs
 ;; Author:       Andy Norman, Dawn
 ;;; (it's copylefted) and warrranty (there isn't one) information.
   
 ;;; Provides a way of autoloading efs. To use this, just put
-;;; (require 'efs-auto in your .emacs file.
+;;; (require 'efs-auto) in your .emacs file.
 ;;;
 ;;; The Bad News:
 ;;; 
 (defconst efs-auto-version
   (concat (substring "$efs release: 1.15 $" 14 -2)
 	  "/"
-	  (substring "$Revision: 1.1 $" 11 -2)))
+	  (substring "$Revision: 1.7 $" 11 -2)))
 
 ;;; Interactive functions that should be accessible from here.
 

File lisp/efs/efs-cms.el

 ;;
 ;; File:         efs-cms.el
 ;; Release:      $efs release: 1.15 $
-;; Version:      $Revision: 1.1 $
+;; Version:      $Revision: 1.9 $
 ;; RCS:          
 ;; Description:  CMS support for efs
 ;; Author:       Sandy Rutherford <sandy@ibm550.sissa.it>
 (defconst efs-cms-version
   (concat (substring "$efs release: 1.15 $" 14 -2)
 	  "/"
-	  (substring "$Revision: 1.1 $" 11 -2)))
+	  (substring "$Revision: 1.9 $" 11 -2)))
 
 ;;;; ------------------------------------------------------------
 ;;;; CMS support

File lisp/efs/efs-cu.el

 ;;;; Use configuration variables.
 ;;;; ------------------------------------------------------------
 
-(defvar efs-default-user nil
+(defvar efs-default-user "anonymous"
   "*User name to use when none is specied in a pathname.
 
 If a string, than this string is used as the default user name.
   (substring efs-path-user-at-host-format 3)
   "Format to return `host:' strings for completion in root directory.")
 
+;;;###autoload
 (defvar efs-path-root-regexp "^/[^/:]+:"
   "Regexp to match the `/user@host:' root of an efs full path.")
 
 (defun efs-code-string (string)
   ;; Encode a string, using `efs-passwd-seed'. This is nil-potent,
   ;; meaning applying it twice decodes.
-  (if (and (fboundp 'int-char) (fboundp 'char-int))
+  (if (and (fboundp 'int-to-char) (fboundp 'char-to-int))
       (mapconcat
        (function
 	(lambda (c)
 	  (char-to-string
-	   (int-char (logxor (efs-get-passwd-seed) (char-int c))))))
+	   (int-to-char (logxor (efs-get-passwd-seed) (char-to-int c))))))
        string "")
     (mapconcat
      (function

File lisp/efs/efs-dl.el

 ;;
 ;; File:         efs-dl.el
 ;; Release:      $efs release: 1.15 $
-;; Version:      $Revision: 1.1 $
+;; Version:      $Revision: 1.3 $
 ;; RCS:          
 ;; Description:  Unix descriptive listing support for efs
 ;; Author:       Sandy Rutherford <sandy@tsmi19.sissa.it>
 (defconst efs-dl-version
   (concat (substring "$efs release: 1.15 $" 14 -2)
 	  "/"
-	  (substring "$Revision: 1.1 $" 11 -2)))
+	  (substring "$Revision: 1.3 $" 11 -2)))
 
 ;;;-----------------------------------------------------------------
 ;;; Unix descriptive listing (dl) support for efs

File lisp/efs/efs-dump.el

+;; -*-Emacs-Lisp-*-
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; File:         efs-dump.el
+;; Release:      $efs release: 1.15 $
+;; Version:      $Revision: 1.1 $
+;; RCS:
+;; Description:  Install a bare-bones EFS hook into file-name-handler-alist
+;;               for dumping
+;; Author:       Mike Sperber <sperber@informatik.uni-tuebingen.de>
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;;###autoload
+(setq file-name-handler-alist
+      (cons
+       (cons efs-path-root-regexp 'efs-file-handler-function)
+       file-name-handler-alist))

File lisp/efs/efs-guardian.el

 ;;
 ;; File:         efs-guardian.el
 ;; Release:      $efs release: 1.15 $
-;; Version:      $Revision: 1.1 $
+;; Version:      $Revision: 1.7 $
 ;; RCS:          
 ;; Description:  Guardian support for efs
 ;; Author:       Sandy Rutherford <sandy@math.ubc.ca>
 (defconst efs-guardian-version
   (concat (substring "$efs release: 1.15 $" 14 -2)
 	  "/"
-	  (substring "$Revision: 1.1 $" 11 -2)))
+	  (substring "$Revision: 1.7 $" 11 -2)))
 
 (provide 'efs-guardian)
 (require 'efs)

File lisp/efs/efs-ka9q.el

 ;;
 ;; File:         efs-ka9q.el
 ;; Release:      $efs release: 1.15 $
-;; Version:      $Revision: 1.1 $
+;; Version:      $Revision: 1.2 $
 ;; RCS:          
 ;; Description:  KA9Q support for efs
 ;; Author:       Sandy Rutherford <sandy@tsmi19.sissa.it>
 (defconst efs-ka9q-version
   (concat (substring "$efs release: 1.15 $" 14 -2)
 	  "/"
-	  (substring "$Revision: 1.1 $" 11 -2)))
+	  (substring "$Revision: 1.2 $" 11 -2)))
 
 ;;;-----------------------------------------------------------------
 ;;; KA9Q support for efs

File lisp/efs/efs-mpe.el

 ;;
 ;; File:         efs-mpe.el
 ;; Release:      $efs release: 1.15 $
-;; Version:      $Revision: 1.1 $
+;; Version:      $Revision: 1.8 $
 ;; RCS:          
 ;; Description:  MPE (HP3000) support for efs.
 ;; Author:       (Corny de Souza) cdesouza@hpbbn.bbn.hp.com
 (defconst efs-mpe-version
   (concat (substring "$efs release: 1.15 $" 14 -2)
 	  "/"
-	  (substring "$Revision: 1.1 $" 11 -2)))
+	  (substring "$Revision: 1.8 $" 11 -2)))
 
 ;;; Support for build parameters
 

File lisp/efs/efs-mvs.el

 ;;
 ;; File:         efs-mvs.el
 ;; Release:      $efs release: 1.15 $
-;; Version:      $Revision: 1.1 $
+;; Version:      $Revision: 1.4 $
 ;; RCS:          
 ;; Description:  MVS support for efs
 ;; Author:       Sandy Rutherford <sandy@math.ubc.ca, sandy@itp.ethz.ch>
 (defconst efs-mvs-version
   (concat (substring "$efs release: 1.15 $" 14 -2)
 	  "/"
-	  (substring "$Revision: 1.1 $" 11 -2)))
+	  (substring "$Revision: 1.4 $" 11 -2)))
 
 ;; What's the MVS character set for valid partitioned data sets?
 ;; I'll guess [-A-Z0-9_$+]

File lisp/efs/efs-netrc.el

 ;;
 ;; File:         efs-netrc.el
 ;; Release:      $efs release: 1.15 $
-;; Version:      $Revision: 1.1 $
+;; Version:      $Revision: 1.2 $
 ;; RCS:          
 ;; Description:  Parses ~/.netrc file, and does completion in /.
 ;; Author:       Sandy Rutherford <sandy@ibm550.sissa.it>
 ;; Created:      Fri Jan 28 19:32:47 1994 by sandy on ibm550
-;; Modified:     Sun Nov 27 18:38:50 1994 by sandy on gandalf
 ;; Language:     Emacs-Lisp
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (defconst efs-netrc-version
   (concat (substring "$efs release: 1.15 $" 14 -2)
 	  "/"
-	  (substring "$Revision: 1.1 $" 11 -2)))
+	  (substring "$Revision: 1.2 $" 11 -2)))
 
 ;; Make the byte compiler happy.
 (defvar dired-directory)
 ;;;; Host / User / Account mapping support.
 ;;;; ------------------------------------------------------------
 
+;;;###autoload
 (defun efs-set-passwd (host user passwd)
   "For a given HOST and USER, set or change the associated PASSWORD."
   (interactive (list (read-string "Host: ")
 	  (list nil)
 	res))))
 
+;;;###autoload
 (defun efs-root-file-name-all-completions (file dir)
   ;; Generates all completions in the root directory.
   (let ((file-name-handler-alist (efs-file-name-handler-alist-sans-fn
 	   (file-name-all-completions file dir))))
 
 
+;;;###autoload
 (defun efs-root-file-name-completion (file dir)
   ;; Calculates completions in the root directory to include remote hosts.
   (let ((file-name-handler-alist (efs-file-name-handler-alist-sans-fn

File lisp/efs/efs-netware.el

 ;;
 ;; File:         efs-netware.el
 ;; Release:      $efs release: 1.15 $
-;; Version:      $Revision: 1.1 $
+;; Version:      $Revision: 1.5 $
 ;; RCS:          
 ;; Description:  efs support for the Novell Netware FTP server
 ;; Author:       Sandy Rutherford <sandy@math.ubc.ca>
 (defconst efs-netware-version
   (concat (substring "$efs release: 1.15 $" 14 -2)
 	  "/"
-	  (substring "$Revision: 1.1 $" 11 -2)))
+	  (substring "$Revision: 1.5 $" 11 -2)))
 
 ;;; Basic efs support
 

File lisp/efs/efs-nos-ve.el

 ;;
 ;; File:         efs-nos-ve.el
 ;; Release:      $efs release: 1.15 $
-;; Version:      $Revision: 1.1 $
+;; Version:      $Revision: 1.2 $
 ;; RCS:          
 ;; Description:  efs support for NOS/VE
 ;; Authors:      Sandy Rutherford <sandy@ibm550.sissa,it>
 (defconst efs-nos-ve-version
   (concat (substring "$efs release: 1.15 $" 14 -2)
 	  "/"
-	  (substring "$Revision: 1.1 $" 11 -2)))
+	  (substring "$Revision: 1.2 $" 11 -2)))
 
 ;;;;---------------------------------------------------------------
 ;;;; NOS/VE support for efs

File lisp/efs/efs-ovwrt.el

 ;;
 ;; File:         efs-ovwrt.el
 ;; Release:      $efs release: 1.15 $
-;; Version:      $Revision: 1.1 $
+;; Version:      $Revision: 1.2 $
 ;; RCS:
 ;; Description:  Utilities for overwriting functions with new definitions.
 ;; Author:       Andy Norman <ange@hplb.hpl.hp.com>
-;; Modified:     Sun Nov 27 18:40:20 1994 by sandy on gandalf
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (defconst efs-ovwrt-version
   (concat (substring "$efs release: 1.15 $" 14 -2)
 	  "/"
-	  (substring "$Revision: 1.1 $" 11 -2)))
+	  (substring "$Revision: 1.2 $" 11 -2)))
 
 (defvar efs-overwrite-fmt
   "Note: This function has been modified to work with %s.")
     ;; later after some other code has been loaded on top of our stuff.
     
     (or (fboundp saved)
-	(progn
+	(let ((advised-p (and (featurep 'advice)
+			      (ad-is-advised fun))))
+	  (if advised-p (ad-deactivate fun))
 	  (fset saved (symbol-function fun))
-	  (fset fun new)))
+	  (fset fun new)
+	  (if advised-p (ad-activate fun))))
     
     ;; Rewrite the doc string on the new function.  This should
     ;; be done every time the file is loaded (or a function is redefined),

File lisp/efs/efs-pc.el

 	;; Neither DOS nor OS/2 allows us to end the name of a directory
 	;; with an "\".
 	;; Adding *.* to the end also allows us to distinguish plain files from
-	;; directries.  All DOS servers seem to understand this except
+	;; directories.  All DOS servers seem to understand this except
 	;; Frontier Technologies' super-tcp server.
 	((string-match "/$" dir-path)
 	 (concat (efs-fix-pc-path dir-path) "*.*"))

File lisp/efs/efs-report.el

 ;;
 ;; File:         efs-report.el
 ;; Release:      $efs release: 1.15 $
-;; Version:      $Revision: 1.1 $
+;; Version:      $Revision: 1.9 $
 ;; RCS:          
 ;; Description:  Function to report efs bugs in a usable way.
 ;; Author:       Andy Norman, Dawn
 ;; Created:      Tue May 18 08:34:45 1993
-;; Modified:     Sun Nov 27 18:41:45 1994 by sandy on gandalf
 ;; Language:     Emacs-Lisp
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (defconst efs-report-version
   (concat (substring "$efs release: 1.15 $" 14 -2)
 	  "/"
-	  (substring "$Revision: 1.1 $" 11 -2)))
+	  (substring "$Revision: 1.9 $" 11 -2)))
 
 (defconst efs-report-salutations
   ["Dear bug team:"
 	   ?\n ?\ )
 	(insert subj)))))
 
+;;;###autoload
 (defun efs-report-bug (&optional default-host  default-user blurb no-confirm)
   "Submit a bug report for efs."
   (interactive)

File lisp/efs/efs-vms.el

 ;;
 ;; File:         efs-vms.el
 ;; Release:      $efs release: 1.15 $
-;; Version:      $Revision: 1.1 $
+;; Version:      $Revision: 1.13 $
 ;; RCS:          
 ;; Description:  VMS support for efs
 ;; Authors:      Andy Norman, Joe Wells, Sandy Rutherford <sandy@itp.ethz.ch>
 (defconst efs-vms-version
   (concat (substring "$efs release: 1.15 $" 14 -2)
 	  "/"
-	  (substring "$Revision: 1.1 $" 11 -2)))
+	  (substring "$Revision: 1.13 $" 11 -2)))
 
 ;;;; ------------------------------------------------------------
 ;;;; VMS support.

File lisp/efs/efs-x19.15.el

 ;;
 ;; File:         efs-x19.15.el
 ;; Release:      $efs release: 1.15 $
-;; Version:      $Revision: 1.1 $
+;; Version:      $Revision: 1.2 $
 ;; RCS:          
 ;; Description:  efs support for XEmacs, versions 19.15, and later.
 ;; Author:       Sandy Rutherford <sandy@ibm550.sissa.it>
 ;; Created:      Tue Aug  2 17:40:32 1994 by sandy on ibm550
-;; Modified:     by Mike Sperber
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (provide 'efs-x19\.15)
 (require 'efs-cu)
-(require 'default-dir)
 (require 'efs-ovwrt)
 
 (defconst efs-x19\.15-version
   (concat (substring "$efs release: 1.15 $" 14 -2)
 	  "/"
-	  (substring "$Revision: 1.1 $" 11 -2)))
+	  (substring "$Revision: 1.2 $" 11 -2)))
 
 ;;; Functions requiring special defs. for these XEmacs versions.
 

File lisp/efs/efs.el

 ;;; Documentation:
 ;;; --------------------------------------------------------------
 ;;;
-;;; Currently efs does not have a tex info file, and what you are
-;;; reading represents the only efs documentation. Please report any
-;;; errors or omissions in this documentation to the "bugs" address
-;;; below. Eventually, a tex info file should be written.  If you have
-;;; any problems with efs, please read this section *before*
-;;; submitting a bug report.
+;;; If you have any problems with efs, please read this section
+;;; *before* submitting a bug report.
 
 ;;; Installation:
 ;;;
 
 ;;; Gateways:
 ;;;
-;;; Sometimes it is neccessary for the FTP process to be run on a different
+;;; Sometimes it is necessary for the FTP process to be run on a different
 ;;; machine than the machine running GNU Emacs.  This can happen when the
 ;;; local machine has restrictions on what hosts it can access.
 ;;;
 ;;;;                      pretty much scrap metal.)
 ;;;; ---------------------------------------------------------------------
 
+;;;###autoload
 (defun efs-nslookup-host (host)
   "Attempt to resolve the given HOSTNAME using nslookup if possible."
   (interactive "sHost: ")
 ;;;; File name handlers
 ;;;; ------------------------------------------------------------
 
+;;;###autoload
 (defun efs-file-handler-function (operation &rest args)
   "Function to call special file handlers for remote files."
   (let ((handler (get operation 'efs)))

File lisp/mel/mel-u.el

-;;;
 ;;; mel-u.el: uuencode encoder/decoder for GNU Emacs
-;;;
-;;; Copyright (C) 1995 Free Software Foundation, Inc.
-;;; Copyright (C) 1995,1996 MORIOKA Tomohiko
-;;;
-;;; Author: MORIOKA Tomohiko <morioka@jaist.ac.jp>
-;;; Maintainer: MORIOKA Tomohiko <morioka@jaist.ac.jp>
-;;; Created: 1995/10/25
-;;; Version:
-;;;	$Id: mel-u.el,v 1.3 1996/12/29 00:14:57 steve Exp $
-;;; Keywords: uuencode
-;;;
-;;; This file is part of MEL (MIME Encoding Library).
-;;;
-;;; This program 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.
-;;;
-;;; This program 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 This program.  If not, write to the Free Software
-;;; Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-;;;
+
+;; Copyright (C) 1995,1996,1997 Free Software Foundation, Inc.
+
+;; Author: MORIOKA Tomohiko <morioka@jaist.ac.jp>
+;; Created: 1995/10/25
+;; Version: $Id: mel-u.el,v 1.4 1997/03/22 05:29:07 steve Exp $
+;; Keywords: uuencode
+
+;; This file is part of MEL (MIME Encoding Library).
+
+;; This program 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.
+
+;; This program 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.
+
 ;;; Code:
 
 (require 'emu)
+(require 'mel)
 
 
 ;;; @ variables
 ;;;
 
-(defvar mime/tmp-dir (or (getenv "TM_TMP_DIR") "/tmp/"))
-
 (defvar uuencode-external-encoder '("uuencode" "-")
   "*list of uuencode encoder program name and its arguments.")
 
 (defvar uuencode-external-decoder
-  (list "sh" "-c" (format "(cd %s; uudecode)" mime/tmp-dir))
+  (list "sh" "-c" (format "(cd %s; uudecode)" mime-temp-directory))
   "*list of uuencode decoder program name and its arguments.")
 
 
 ;;; @ uuencode encoder/decoder for region
 ;;;
 
-(defun uuencode-external-encode-region (beg end)
+(defun uuencode-external-encode-region (start end)
+  "Encode current region by unofficial uuencode format.
+This function uses external uuencode encoder which is specified by
+variable `uuencode-external-encoder'."
   (interactive "*r")
   (save-excursion
     (as-binary-process (apply (function call-process-region)
-			      beg end (car uuencode-external-encoder)
+			      start end (car uuencode-external-encoder)
 			      t t nil (cdr uuencode-external-encoder))
 		       )
     ;; for OS/2
       )
     ))
 
-(defun uuencode-external-decode-region (beg end)
+(defun uuencode-external-decode-region (start end)
+  "Decode current region by unofficial uuencode format.
+This function uses external uuencode decoder which is specified by
+variable `uuencode-external-decoder'."
   (interactive "*r")
   (save-excursion
     (let ((filename (save-excursion
 		      (save-restriction
-			(narrow-to-region beg end)
-			(goto-char beg)
+			(narrow-to-region start end)
+			(goto-char start)
 			(if (re-search-forward "^begin [0-9]+ " nil t)
 			    (if (looking-at ".+$")
 				(buffer-substring (match-beginning 0)
       (if filename
 	  (as-binary-process
 	   (apply (function call-process-region)
-		  beg end (car uuencode-external-decoder)
+		  start end (car uuencode-external-decoder)
 		  t nil nil (cdr uuencode-external-decoder))
-	   (setq filename (expand-file-name filename mime/tmp-dir))
-	   (let ((file-coding-system-for-read *noconv*) ; for Mule
-		 kanji-fileio-code		        ; for NEmacs
-		 (emx-binary-mode t)                    ; for OS/2
-		 jka-compr-compression-info-list        ; for jka-compr
-		 jam-zcat-filename-list                 ; for jam-zcat
-		 require-final-newline)
-	     (insert-file-contents filename)
-	     )
+	   (setq filename (expand-file-name filename mime-temp-directory))
+	   (as-binary-input-file (insert-file-contents filename))
 	   (delete-file filename)
 	   ))
       )))
 ;;;
 
 (defun uuencode-insert-encoded-file (filename)
+  "Insert file encoded by unofficial uuencode format.
+This function uses external uuencode encoder which is specified by
+variable `uuencode-external-encoder'."
   (interactive (list (read-file-name "Insert encoded file: ")))
   (call-process (car uuencode-external-encoder) filename t nil
 		(file-name-nondirectory filename))

File lisp/mel/mel.el

 ;;; mel.el : a MIME encoding/decoding library
 
-;; Copyright (C) 1995,1996 Free Software Foundation, Inc.
+;; Copyright (C) 1995,1996,1997 Free Software Foundation, Inc.
 
 ;; Author: MORIOKA Tomohiko <morioka@jaist.ac.jp>
 ;; modified by Shuhei KOBAYASHI <shuhei-k@jaist.ac.jp>
 ;; Created: 1995/6/25
-;; Version: $Id: mel.el,v 1.3 1996/12/29 00:14:58 steve Exp $
+;; Version: $Id: mel.el,v 1.4 1997/03/22 05:29:07 steve Exp $
 ;; Keywords: MIME, Base64, Quoted-Printable, uuencode, gzip64
 
 ;; This file is part of MEL (MIME Encoding Library).
 
 ;;; Code:
 
+;;; @ variable
+;;;
+
+(defvar mime-temp-directory (or (getenv "MIME_TMP_DIR")
+				(getenv "TM_TMP_DIR")
+				"/tmp/")
+  "*Directory for temporary files.")
+
+
 ;;; @ region
 ;;;
 
-(autoload 'base64-encode-region           "mel-b" nil t)
-(autoload 'quoted-printable-encode-region "mel-q" nil t)
-(autoload 'uuencode-encode-region         "mel-u" nil t)
-(autoload 'gzip64-encode-region           "mel-g" nil t)
+(autoload 'base64-encode-region
+  "mel-b" "Encode current region by base64." t)
+(autoload 'quoted-printable-encode-region
+  "mel-q" "Encode current region by Quoted-Printable." t)
+(autoload 'uuencode-encode-region
+  "mel-u" "Encode current region by unofficial uuencode format." t)
+(autoload 'gzip64-encode-region
+  "mel-g" "Encode current region by unofficial x-gzip64 format." t)
 
 (defvar mime-encoding-method-alist
   '(("base64"           . base64-encode-region)
   "Alist of encoding vs. corresponding method to encode region.
 Each element looks like (STRING . FUNCTION) or (STRING . nil).
 STRING is content-transfer-encoding.
-FUNCTION is region encoder and nil means not to encode. [mel.el]")
+FUNCTION is region encoder and nil means not to encode.")
 
 
-(autoload 'base64-decode-region           "mel-b" nil t)
-(autoload 'quoted-printable-decode-region "mel-q" nil t)
-(autoload 'uuencode-decode-region         "mel-u" nil t)
-(autoload 'gzip64-decode-region		  "mel-g" nil t)
+(autoload 'base64-decode-region
+  "mel-b" "Decode current region by base64." t)
+(autoload 'quoted-printable-decode-region
+  "mel-q" "Decode current region by Quoted-Printable." t)
+(autoload 'uuencode-decode-region
+  "mel-u" "Decode current region by unofficial uuencode format." t)
+(autoload 'gzip64-decode-region
+  "mel-g" "Decode current region by unofficial x-gzip64 format." t)
 
 (defvar mime-decoding-method-alist
   '(("base64"           . base64-decode-region)
   "Alist of encoding vs. corresponding method to decode region.
 Each element looks like (STRING . FUNCTION).
 STRING is content-transfer-encoding.
-FUNCTION is region decoder. [mel.el]")
+FUNCTION is region decoder.")
 
 
-(defun mime-encode-region (beg end encoding)
-  "Encode region BEG to END of current buffer using ENCODING. [mel.el]"
+(defun mime-encode-region (start end encoding)
+  "Encode region START to END of current buffer using ENCODING."
   (interactive
    (list (region-beginning) (region-end)
 	 (completing-read "encoding: "
    )
   (let ((f (cdr (assoc encoding mime-encoding-method-alist))))
     (if f
-	(funcall f beg end)
+	(funcall f start end)
       )))
 
-(defun mime-decode-region (beg end encoding)
-  "Decode region BEG to END of current buffer using ENCODING. [mel.el]"
+(defun mime-decode-region (start end encoding)
+  "Decode region START to END of current buffer using ENCODING."
   (interactive
    (list (region-beginning) (region-end)
 	 (completing-read "encoding: "
    )
   (let ((f (cdr (assoc encoding mime-decoding-method-alist))))
     (if f
-	(funcall f beg end)
+	(funcall f start end)
       )))
 
 
 ;;; @ file
 ;;;
 
-(autoload 'base64-insert-encoded-file           "mel-b" nil t)
-(autoload 'quoted-printable-insert-encoded-file "mel-q" nil t)
-(autoload 'uuencode-insert-encoded-file         "mel-u" nil t)
-(autoload 'gzip64-insert-encoded-file           "mel-g" nil t)
+(autoload 'base64-insert-encoded-file
+  "mel-b" "Insert file encoded by base64." t)
+(autoload 'quoted-printable-insert-encoded-file
+  "mel-q" "Insert file encoded by quoted-printable." t)
+(autoload 'uuencode-insert-encoded-file
+  "mel-u" "Insert file encoded by unofficial uuencode format." t)
+(autoload 'gzip64-insert-encoded-file
+  "mel-g" "Insert file encoded by unofficial gzip64 format." t)
 
 (defvar mime-file-encoding-method-alist
   '(("base64"           . base64-insert-encoded-file)
   "Alist of encoding vs. corresponding method to insert encoded file.
 Each element looks like (STRING . FUNCTION).
 STRING is content-transfer-encoding.
-FUNCTION is function to insert encoded file. [mel.el]")
-
+FUNCTION is function to insert encoded file.")
 
 (defun mime-insert-encoded-file (filename encoding)
-  "Encode region BEG to END of current buffer using ENCODING. [mel.el]"
+  "Insert file FILENAME encoded by ENCODING format."
   (interactive
    (list (read-file-name "Insert encoded file: ")
 	 (completing-read "encoding: "

File lisp/modes/cc-mode.el

 ;;          1987 Dave Detlefs and Stewart Clamen
 ;;          1985 Richard M. Stallman
 ;; Created: a long, long, time ago. adapted from the original c-mode.el
-;; Version:         4.381
-;; Last Modified:   1997/03/18 16:43:13
+;; Version:         4.387
+;; Last Modified:   1997/03/21 20:25:33
 ;; Keywords: c languages oop
 
 ;; NOTE: Read the commentary below for the right way to submit bug reports!
 
 ;;; Commentary:
 
-;; This package provides modes in GNU Emacs for editing C, C++,
-;; Objective-C, and Java code. It is intended to be a replacement for
-;; c-mode.el (a.k.a. BOCM -- Boring Old C-Mode), c++-mode.el,
-;; cplus-md.el, and cplus-md1.el, all of which are in some way
-;; ancestors of this file.  A number of important improvements have
-;; been made, briefly: complete K&R C, ANSI C, `ARM' C++, Objective-C,
-;; and Java support with consistent indentation across all modes, more
-;; intuitive indentation controlling variables, compatibility across
-;; all known Emacsen, nice new features, and tons of bug fixes.  This
-;; package is called "CC Mode" to distinguish it from its ancestors,
-;; but there is no cc-mode command.  Usage and programming details are
-;; contained in an accompanying texinfo manual.
+;; This package provides GNU Emacs major modes for editing C, C++,
+;; Objective-C, and Java code.  As of the latest Emacs and XEmacs
+;; releases, it is the default package for editing these languages.
+;; This package is called "CC Mode", and should be spelled exactly
+;; this way.  It supports K&R and ANSI C, ANSI C++, Objective-C, and
+;; Java, with a consistent indentation model across all modes.  This
+;; indentation model is intuitive and very flexible, so that almost
+;; any desired style of indentation can be supported.  Installation,
+;; usage, and programming details are contained in an accompanying
+;; texinfo manual.
+
+;; CC Mode's immediate ancestors were, c++-mode.el, cplus-md.el, and
+;; cplus-md1.el..
 
 ;; NOTE: This mode does not perform font-locking (a.k.a syntactic
 ;; coloring, keyword highlighting, etc.) for any of the supported
 ;; BYTE-COMPILER WARNINGS (you'd be surprised at how many people don't
 ;; follow this advice :-).
 
-;; As of this writing (24-Feb-1997), CC Mode comes with the latest
-;; Emacs and XEmacs distributions (19.34 and 19.14 respectively), but
-;; is no longer pre-loaded by default.  To use the latest version of
-;; CC Mode, you need only make sure that this copy of cc-mode.el is
-;; found first on your load-path.
-
-;; If your Emacs is pre-loaded with any version of cc-mode.el,
-;; c-mode.el, or c++-mode.el, you will need to consult the
-;; cc-mode.texinfo manual for details on upgrading your Emacs.
-
-;; There are four major mode entry points provided by this package,
-;; one for editing C++ code, one for editing C code (both K&R and
-;; ANSI), one for editing Objective-C code, and one for editing Java
-;; code.  The commands are M-x c-mode, M-x c++-mode, M-x objc-mode,
-;; and M-x java-mode.
-
 ;; Many, many thanks go out to all the folks on the beta test list.
 ;; Without their patience, testing, insight, code contributions, and
 ;; encouragement CC Mode would be a far inferior package.
 (defvar c-electric-pound-behavior nil
   "*List of behaviors for electric pound insertion.
 Only currently supported behavior is `alignleft'.")
+
 (defvar c-label-minimum-indentation 1
-  "*Minimum indentation for labels and case tags in `gnu' style.")
+  "*Minimum indentation for lines inside of top-level constructs.
+This variable typically only affects code using the `gnu' style, which
+mandates a minimum of one space in front of every line inside
+top-level constructs.  Specifically, the function
+`c-gnu-impose-minimum' on your `c-special-indent-hook' is what
+enforces this.")
 
 (defvar c-progress-interval 5
   "*Interval used to update progress status during long re-indentation.
 (defconst c-C++-friend-key
   "friend[ \t]+\\|template[ \t]*<.+>[ \t]*friend[ \t]+"
   "Regexp describing friend declarations in C++ classes.")
-(defconst c-C++-comment-start-regexp "/[/*]"
-  "Dual comment value for `c-comment-start-regexp'.")
-(defconst c-C-comment-start-regexp "/\\*"
-  "Single comment style value for `c-comment-start-regexp'.")
+
+;; comment starter definitions for various languages.  the language
+;; modes will set c-comment-start-regexp to this value.
+(defconst c-C++-comment-start-regexp "/[/*]")
+(defconst c-C-comment-start-regexp "/[*]")
+;; We need to match all 3 Java style comments
+;; 1) Traditional C block; 2) javadoc /** ...; 3) C++ style
+(defconst c-Java-comment-start-regexp "/\\(/\\|[*][*]?\\)")
 
 (defconst c-ObjC-method-key
   (concat
  	comment-end   ""
  	comment-multi-line nil
  	c-conditional-key c-Java-conditional-key
- 	c-comment-start-regexp c-C++-comment-start-regexp
+ 	c-comment-start-regexp c-Java-comment-start-regexp
   	c-class-key c-Java-class-key
 	c-method-key c-Java-method-key
 	c-double-slash-is-comments-p t
 
 
 ;; macros must be defined before first use
+(defmacro c-add-syntax (symbol &optional relpos)
+  ;; a simple macro to append the syntax in symbol to the syntax list.
+  ;; try to increase performance by using this macro
+  (` (setq syntax (cons (cons (, symbol) (, relpos)) syntax))))
+
 (defmacro c-point (position)
   ;; Returns the value of point at certain commonly referenced POSITIONs.
   ;; POSITION can be one of the following symbols:
 				      (goto-char comment-start-place)
 				    (search-backward "/*"))
 				  (if (and (not c-hanging-comment-starter-p)
-					   (looking-at "/\\*[ \t]*$"))
+					   (looking-at
+					    (concat c-comment-start-regexp
+						    "[ \t]*$")))
 				      (forward-line 1))
 				  ;; Protect text before the comment
 				  ;; start by excluding it.  Add
 
 ;; defuns for calculating the syntactic state and indenting a single
 ;; line of C/C++/ObjC code
-(defmacro c-add-syntax (symbol &optional relpos)
-  ;; a simple macro to append the syntax in symbol to the syntax list.
-  ;; try to increase performance by using this macro
-  (` (setq syntax (cons (cons (, symbol) (, relpos)) syntax))))
-
 (defun c-most-enclosing-brace (state)
   ;; return the bufpos of the most enclosing brace that hasn't been
   ;; narrowed out by any enclosing class, or nil if none was found
 		  ;; we now have to figure out where this comment begins.
 		  (goto-char here)
 		  (back-to-indentation)
-		  (if (re-search-forward "[*]+/" (c-point 'eol) t)
-		      (forward-comment -1)
+		  (if (looking-at "[*]+/")
+		      (progn (goto-char (match-end 0))
+			     (forward-comment -1))
 		    (goto-char (cdr langelem))
 		    (back-to-indentation))))
 	    (- (current-column) cs-curcol))
 
 ;; defuns for submitting bug reports
 
-(defconst c-version "4.381"
+(defconst c-version "4.387"
   "CC Mode version number.")
 (defconst c-mode-help-address
   "bug-gnu-emacs@prep.ai.mit.edu, cc-mode-help@python.org"
   (interactive)
   ;; load in reporter
   (let ((reporter-prompt-for-summary-p t)
-	(reporter-dont-compact-list '(c-offsets-alist)))
+	(reporter-dont-compact-list '(c-offsets-alist))
+	(style c-indentation-style)
+	(hook c-special-indent-hook)
+	(c-features c-emacs-features))
     (and
      (if (y-or-n-p "Do you want to submit a report on CC Mode? ")
 	 t (message "") nil)
 		   'c-hanging-colons-alist
 		   'c-hanging-comment-starter-p
 		   'c-hanging-comment-ender-p
+		   'c-indent-comments-syntactically-p
 		   'c-tab-always-indent
 		   'c-recognize-knr-p
 		   'c-label-minimum-indentation
       (function
        (lambda ()
 	 (insert
-	  "Buffer Style: " c-indentation-style "\n\n"
-	  (if c-special-indent-hook
+	  "Buffer Style: " style "\n\n"
+	  (if hook
 	      (concat "\n@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"
 		      "c-special-indent-hook is set to '"
-		      (format "%s" c-special-indent-hook)
+		      (format "%s" hook)
 		      ".\nPerhaps this is your problem?\n"
 		      "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n")
 	    "\n")
-	  (format "c-emacs-features: %s\n" c-emacs-features)
+	  (format "c-emacs-features: %s\n" c-features)
 	  )))
       nil
       "Dear Barry,"

File lisp/mu/mu-cite.el

 ;;         MINOURA Makoto <minoura@netlaputa.or.jp>
 ;;         Shuhei KOBAYASHI <shuhei-k@jaist.ac.jp>
 ;; Maintainer: Shuhei KOBAYASHI <shuhei-k@jaist.ac.jp>
-;; Version: $Revision: 1.6 $
+;; Version: $Revision: 1.7 $
 ;; Keywords: mail, news, citation
 
 ;; This file is part of MU (Message Utilities).
 ;;;
 
 (defconst mu-cite/RCS-ID
-  "$Id: mu-cite.el,v 1.6 1997/03/16 05:55:24 steve Exp $")
+  "$Id: mu-cite.el,v 1.7 1997/03/22 05:29:11 steve Exp $")
 (defconst mu-cite/version (get-version-string mu-cite/RCS-ID))
 
 
 ;;; @ field
 ;;;
 
-(defvar mu-cite/get-field-value-method-alist
-  (list (cons 'mh-letter-mode
-	      (function
-	       (lambda (name)
-		 (if (and (stringp mh-sent-from-folder)
-			  (numberp mh-sent-from-msg))
-		     (save-excursion
-		       (set-buffer mh-sent-from-folder)
-		       (set-buffer mh-show-buffer)
-		       (and (boundp 'mime::preview/article-buffer)
-			    (bufferp mime::preview/article-buffer)
-			    (set-buffer mime::preview/article-buffer))
-		       (std11-field-body name)
-		       ))
-		 )))))
+(defvar mu-cite/get-field-value-method-alist nil
+  "Alist major-mode vs. function to get field-body of header.")
 
 (defun mu-cite/get-field-value (name)
   (or (std11-field-body name)

File lisp/packages/time.el

 ;;;      the old mechanism for specifying what is to be displayed.
 ;;;      The starting variable to look at is `display-time-form-list'
 
+;;; Thanks to Mike Scheidler for the idea to make the time led's fore- and
+;;; background color customizable
+
 ;;; Code:
 
 (require 'itimer)
   (start-itimer "display-time" 'display-time-function
 		display-time-interval display-time-interval))
 
+(defun display-time-stop ()
+  (interactive)
+  (delete-itimer "display-time")
+  (setq display-time-string nil))
+
 (defcustom display-time-show-icons-maybe t
   "Use icons for time, load and mail status if possible
 and not specified different explicitely"
 :group 'display-time
 :type 'string)
 
-(defcustom display-time-display-pad t
-  "Wether the load indicator is displayed with a trapezoidal \"pad\"
-in the background"
+(defcustom display-time-display-pad  "grey35"
+  "How the load indicator's trapezoidal \"pad\" is to be displayed.
+This can be 'transparent or a string describing the color it should have"
   :group 'display-time
-  :type 'boolean)
+  :type '(choice :tag "Value"
+		 (const transparent)
+		 (string :tag "Color")))
+
+(defcustom display-time-display-time-foreground  "firebrick"
+  "How the time LEDs foreground is to be displayed.
+This can be 'modeline (foreground color of the Modeline)
+or a string describing the color it should have"
+  :group 'display-time
+  :type '(choice :tag "Value"
+		 (const modline)
+		 (string :tag "Color")))
+
+(defcustom display-time-display-time-background  'transparent
+  "How the time LEDs background is to be displayed.
+This can be 'transparent or a string describing the color it should have"
+  :group 'display-time
+  :type '(choice :tag "Value"