Merged in changes from CVS HEAD

Patches applied:

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-177
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-178
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-179
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-180
   Update from CVS


git-archimport-id: lorentey@elte.hu--2004/emacs--multi-tty--0--patch-131

24 files changed, 1168 insertions, 310 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 3bb9e41cd2c..6e693be77c2 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,134 @@
+2004-04-03  Juri Linkov  <juri@jurta.org>
+
+        * descr-text.el (describe-property-list): Add `font-lock-face'.
+
+        * dired.el (dired-font-lock-keywords): Fix permission regexps.
+
+2004-04-02  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
+
+        * x-dnd.el (x-dnd-handle-moz-url, x-dnd-insert-utf16-text): Use
+        utf-16le on little endian machines and utf-16be otherwise.
+
+2004-04-02  David Kastrup  <dak@gnu.org>
+
+        * net/browse-url.el (browse-url-generic): Use call-process
+        instead of start-process to allow browsers that fork and detach.
+
+2004-04-01  Daniel Pfeiffer  <occitan@esperanto.org>
+
+        * compile.el (compilation-current-error): New var.
+        (compilation-setup, compile-mouse-goto-error)
+        (compile-goto-error, next-error): Use it.
+        (compilation-skip-to-next-location): Default to t, which gives
+        contiguous skipping like old compile (where this was redundant).
+        (compilation-next-error): Prevent previous-* commands from moving
+        back to message at or just before point.
+
+2004-04-01  Nick Roberts  <nick@nick.uklinux.net>
+
+        * progmodes/gdb-ui.el (gdb-view-source-function, gdb-view-assembler)
+        (gdb-source-info): Don't display source at startup, if required.
+        (gdb-show-main): New option.
+        (gdba): Update documentation.
+        (gdb-source): Cover case of auto-display output.
+
+2004-03-31  Luc Teirlinck  <teirllm@auburn.edu>
+
+        * autorevert.el: Delete obsolete autoload's and defvar's.
+        (auto-revert-check-vc-info): New user option.
+        (auto-revert-vc-cvs-file-version, auto-revert-vc-buffer-p)
+        (auto-revert-handler-vc): Delete.
+        (auto-revert-handler): Treat return value `fast' of
+        buffer-stale-function specially.  Check `auto-revert-check-vc-info'.
+
+        * buff-menu.el (Buffer-menu-mode): Make the buffer-stale-function
+        return `fast'.
+
+        * files.el (buffer-stale-function): Doc change.
+
+2004-03-31  Vinicius Jose Latorre  <viniciusjl@ig.com.br>
+
+        * printing.el: New tip on Tips section.
+        (pr-version): New version number (6.7.4).
+        (pr-shell-file-name): Initialization fix.
+
+2004-03-31  Juri Linkov  <juri@jurta.org>
+
+        * dired.el: Add autoload for `dired-do-touch'.
+        (dired-touch-program): New var.
+        (dired-mode-map): Bind `dired-do-touch' to T and add menu-item.
+        (dired-no-confirm): Add `touch' to docstring.
+
+        * dired-aux.el (dired-do-touch): New fun.
+        (dired-do-chxxx): Add argument -t for touch operation.
+
+        * dired-x.el (dired-mark-sexp): Replace hard-coded month names by
+        `dired-move-to-filename-regexp'.
+
+2004-03-31  H,Ae(Bkan Granath  <hakan.granath@kau.se>  (tiny change)
+
+        * dired.el (dired-move-to-filename-regexp): Add . to HH:MM.
+
+2004-03-30  Vinicius Jose Latorre  <viniciusjl@ig.com.br>
+
+        * progmodes/ebnf2ps.el (ebnf-eps-finish-and-write): Write a buffer if
+        and only if the buffer was modified.
+
+2004-03-30  Kenichi Handa  <handa@m17n.org>
+
+        * international/characters.el: Delete pairs for U+2308..U+230B.
+
+2004-03-29  Nick Roberts  <nick@nick.uklinux.net>
+
+        * progmodes/gud.el (gud-gdb-marker-filter): Include "\n" in regexp
+        to detect the beginning of a level 2 or 3 annotation.
+
+2004-03-29  Kenichi Handa  <handa@m17n.org>
+
+        * international/ucs-tables.el (ucs-insert): Fix the error message.
+
+2004-03-29  Kenichi Handa  <handa@m17n.org>
+
+        * international/mule-util.el (char-displayable-p): Fix generation
+        of XLFD file name.
+
+        * Makefile.in (setwins, setwins_almost): Change directory to $wd
+        before finding directories by `find'.
+
+2004-03-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * subr.el (interactive-form): Delete.  Now implemented in C.
+
+        * pcvs.el (cvs-parse-process): Workaround for Darwin.
+
+        * vc.el (vc-version-diff, vc-default-diff-tree): Change `rel' -> `rev'.
+        (vc-diff-label): New fun.
+        (vc-diff-internal): Use it.
+
+        * progmodes/gdb-ui.el (gdb-post-prompt): Fix test.
+
+2004-03-28  Vinicius Jose Latorre  <viniciusjl@ig.com.br>
+
+        * progmodes/ebnf-abn.el (ebnf-abn-parser): Handle initial comments.
+
+        * progmodes/ebnf-ebx.el: New file, implement a parser for EBNF used to
+        specify XML (EBNFX).
+
+        * progmodes/ebnf2ps.el: Doc fix.
+        (ebnf-version): New version number (4.1).
+        (ebnf-syntax): Adjust customization.
+        (ebnf-style-database): Add ebnfx entry.
+        (ebnf-syntax-alist): Add ebnfx initialization.
+        (ebnf-ebx-parser, ebnf-ebx-initialize): Autoloaded funs from ebnf-ebx.
+
+        * printing.el: Doc fix.
+        (pr-version): New version number (6.7.3).
+        (pr-menu-position): Adjust X and Y positions when mouse-pixel-position
+        returns nil for mouse position.  Reported by Drew Adams
+        <drew.adams@oracle.com>.
+        (pr-update-menus): Modify interactive declaration.  Reported by Drew
+        Adams <drew.adams@oracle.com>.
+
 2004-03-28  Nick Roberts  <nick@nick.uklinux.net>
 
         * progmodes/gdb-ui.el (gdb-ann3, gdb-send-item)
@@ -286,12 +417,14 @@
         functions.
         (auto-revert-buffers): Delete call to auto-revert-buffer-p.
 
-        * dired.el (dired-directory-changed-p, dired-buffer-stale-p): New funs.
+        * dired.el (dired-directory-changed-p): New fun, extracted from
+        dired-internal-noselect.
+        (dired-buffer-stale-p): New fun.
         (dired-internal-noselect): Use dired-directory-changed-p.
         Eliminate revert messages.
         (dired-mode): Set buffer-stale-function to dired-buffer-stale-p.
 
-2004-03-23  Kenichi Handa  <handa@etlken2>
+2004-03-23  Kenichi Handa  <handa@m17n.org>
 
         * international/characters.el: Setup syntaxes for more parentheses
         Unicode characters.
@@ -940,12 +1073,12 @@
 
 2004-02-28  Vinicius Jose Latorre  <viniciusjl@ig.com.br>
 
-        * ebnf-abn.el: Doc fix.
+        * progmodes/ebnf-abn.el: Doc fix.
 
-        * ebnf-bnf.el: Doc fix.
+        * progmodes/ebnf-bnf.el: Doc fix.
         (ebnf-repeat): Code fix.
 
-        * ebnf2ps.el: Doc fix.
+        * progmodes/ebnf2ps.el: Doc fix.
         (ebnf-syntax-directory, ebnf-syntax-file): New funs.
 
 2004-02-28  Juri Linkov  <juri@jurta.org>
@@ -1011,8 +1144,8 @@
 
 2004-02-25  Vinicius Jose Latorre  <viniciusjl@ig.com.br>
 
-        * ebnf2ps.el: Doc fix.  For compatibility with Emacs 20, define
-        assq-delete-all if it's not defined.
+        * progmodes/ebnf2ps.el: Doc fix.  For compatibility with Emacs 20,
+        define assq-delete-all if it's not defined.
         (ebnf-generate-region): Code fix.
 
         * printing.el: Doc fix.
@@ -1021,12 +1154,13 @@
 
 2004-02-24  Vinicius Jose Latorre  <viniciusjl@ig.com.br>
 
-        * ebnf-abn.el: New file, implements an ABNF parser.
+        * progmodes/ebnf-abn.el: New file, implements an ABNF parser.
 
-        * ebnf2ps.el: Doc fix.  Accept ABNF (Augmented BNF).  New arrow shapes:
-        semi-up-hollow, semi-up-full, semi-down-hollow and semi-down-full.
-        Fix a bug on productions like test = {"test"}* | ( "tt" ["test"] ).
-        Reported by Markus Dreyer <mdreyer@ix.urz.uni-heidelberg.de>.
+        * progmodes/ebnf2ps.el: Doc fix.  Accept ABNF (Augmented BNF).  New
+        arrow shapes: semi-up-hollow, semi-up-full, semi-down-hollow and
+        semi-down-full.  Fix a bug on productions like test = {"test"}* | (
+        "tt" ["test"] ).  Reported by Markus Dreyer
+        <mdreyer@ix.urz.uni-heidelberg.de>.
         (ebnf-version): New version number (4.0).
         (ebnf-print-directory, ebnf-print-file, ebnf-spool-directory)
         (ebnf-spool-file, ebnf-eps-directory, ebnf-eps-file)
@@ -1046,18 +1180,19 @@
         (ebnf-make-terminal1, ebnf-make-or-more1, ebnf-make-repeat)
         (ebnf-token-repeat): Code fix.
 
-        * ebnf-yac.el: Doc fix.  Handle Bison pragmas %nonassoc, %right, %left
-        and %prec.  Suggested by Matthew K. Junker <junker@alum.mit.edu>.
+        * progmodes/ebnf-yac.el: Doc fix.  Handle Bison pragmas %nonassoc,
+        %right, %left and %prec.  Suggested by Matthew K. Junker
+        <junker@alum.mit.edu>.
         (ebnf-yac-definitions, ebnf-yac-lex): Code fix.
 
-        * ebnf-iso.el: Doc fix.
+        * progmodes/ebnf-iso.el: Doc fix.
         (ebnf-iso-token-table, ebnf-iso-non-terminal-chars): Adjust vars.
         (ebnf-iso-lex): Code fix.
 
-        * ebnf-bnf.el: Doc fix.
+        * progmodes/ebnf-bnf.el: Doc fix.
         (ebnf-bnf-lex): Code fix.
 
-        * ebnf-otz.el: Doc fix.
+        * progmodes/ebnf-otz.el: Doc fix.
 
 2004-02-23  Luc Teirlinck  <teirllm@auburn.edu>
 
diff --git a/lisp/Makefile.in b/lisp/Makefile.in
index e1c6b779db2..9efd587a199 100644
--- a/lisp/Makefile.in
+++ b/lisp/Makefile.in
@@ -136,17 +136,17 @@ emacs = EMACSLOADPATH=$(lisp) $(EMACS) $(EMACSOPT)
 
 # Common command to find subdirectories
 
-setwins=subdirs=`find $$wd -type d -print`; \
+setwins=subdirs=`(cd $$wd; find . -type d -print)`; \
         for file in $$subdirs; do \
            case $$file in */Old | */RCS | */CVS | */CVS/* | */.* | */.*/* | */=* ) ;; \
-                *) wins="$$wins $$file" ;; \
+                *) wins="$$wins $$wd/$$file" ;; \
            esac; \
         done
 
-setwins_almost=subdirs=`find $$wd -type d -print`; \
+setwins_almost=subdirs=`(cd $$wd; find . -type d -print)`; \
         for file in $$subdirs; do \
            case $$file in */Old | */RCS | */CVS | */CVS/* | */.* | */.*/* | */=* | */obsolete | */term ) ;; \
-                *) wins="$$wins $$file" ;; \
+                *) wins="$$wins $$wd/$$file" ;; \
            esac; \
         done
 
diff --git a/lisp/autorevert.el b/lisp/autorevert.el
index 165c6b8b24f..6e74a96eff5 100644
--- a/lisp/autorevert.el
+++ b/lisp/autorevert.el
@@ -70,14 +70,8 @@
 ;; Dependencies:
 
 (require 'timer)
-(autoload 'dired-get-filename "dired")
-(autoload 'vc-workfile-version "vc-hooks")
-(autoload 'vc-mode-line        "vc-hooks")
 
-(eval-when-compile
-  (defvar dired-directory)
-  (defvar vc-mode)
-  (require 'cl))
+(eval-when-compile (require 'cl))
 
 
 ;; Custom Group:
@@ -191,6 +185,27 @@ not necessarily make manual updates useless for non-file buffers."
   :group 'auto-revert
   :type 'hook)
 
+(defcustom auto-revert-check-vc-info nil
+  "If non-nil Auto Revert Mode reliably updates version control info.
+Auto Revert Mode updates version control info whenever the buffer
+needs reverting, regardless of the value of this variable.
+However, the version control state can change without changes to
+the work file.  If the change is made from the current Emacs
+session, all info is updated.  But if, for instance, a new
+version is checked in from outside the current Emacs session, the
+version control number in the mode line, as well as other version
+control related information, may not be properly updated.  If you
+are worried about this, set this variable to a non-nil value.
+
+This currently works by automatically updating the version
+control info every `auto-revert-interval' seconds.  Nevertheless,
+it should not cause excessive CPU usage on a reasonably fast
+machine, if it does not apply to too many version controlled
+buffers.  CPU usage depends on the version control system"
+  :group 'auto-revert
+  :type 'boolean
+  :version "21.4")
+
 (defvar global-auto-revert-ignore-buffer nil
   "*When non-nil, Global Auto-Revert Mode will not revert this buffer.
 
@@ -279,87 +294,29 @@ will use an up-to-date value of `auto-revert-interval'"
        (not (memq major-mode
                   global-auto-revert-ignore-modes)))))
 
-(defun auto-revert-vc-cvs-file-version (file)
-  "Get version of FILE by reading control file on disk."
-  (let* ((control "CVS/Entries")
-         (name    (file-name-nondirectory file))
-         (path    (format "%s/%s"
-                          (file-name-directory file)
-                          control)))
-    (when (file-exists-p path)
-      (with-temp-buffer
-        (insert-file-contents-literally path)
-        (goto-char (point-min))
-        (when (re-search-forward
-               ;; /file.txt/1.3/Mon Sep 15 18:43:20 2003//
-               (format "%s/\\([.0-9]+\\)" (regexp-quote name))
-               nil t)
-          (match-string 1))))))
-
-(defun auto-revert-vc-buffer-p ()
-  "Check if buffer is version controlled."
-  (and (boundp 'vc-mode)
-       (string-match "[0-9]" (or vc-mode ""))))
-
-(defun auto-revert-handler-vc ()
-  "Check if version controlled buffer needs revert."
-  ;; [Emacs 1]
-  ;; 1. File is saved     (*)
-  ;; 2. checkin is done 1.1 -> 1.2
-  ;; 3. VC reverts, so that updated version number is shown in mode line
-  ;;
-  ;; Suppose the same file has been opened in another Emacs and
-  ;; autorevert.el is on.
-  ;;
-  ;; [Emacs 2]
-  ;; 1. Step (1) is detected and buffer is reverted.
-  ;; 2. But check in does not always change the file in dis, but possibly only
-  ;;    control files like CVS/Entries
-  ;; 3. The buffer is not reverted to update VC version line.
-  ;;    Incorrect version number 1.1 is shown in this Emacs
-  ;;
-  (when (featurep 'vc)
-    (let* ((file           (buffer-file-name))
-           (backend        (vc-backend (buffer-file-name)))
-           (version-buffer (vc-workfile-version file)))
-      (when (stringp version-buffer)
-        (cond
-         ((eq backend 'CVS)
-          (let ((version-file
-                 (auto-revert-vc-cvs-file-version (buffer-file-name))))
-            (and (stringp version-file)
-                 (not (string-match version-file version-buffer)))))
-         ((eq backend 'RCS)
-          ;; TODO:
-          ))))))
-
 (defun auto-revert-handler ()
   "Revert current buffer, if appropriate.
 This is an internal function used by Auto-Revert Mode."
   (unless (buffer-modified-p)
     (let (revert)
-      (cond
-       ((auto-revert-vc-buffer-p)
-        (when (auto-revert-handler-vc)
-          (setq revert 'vc)))
-       ((or (and (buffer-file-name)
-                 (file-readable-p (buffer-file-name))
-                 (not (verify-visited-file-modtime (current-buffer))))
-            (and (or auto-revert-mode global-auto-revert-non-file-buffers)
-                 revert-buffer-function
-                 (boundp 'buffer-stale-function)
-                 (functionp buffer-stale-function)
-                 (funcall buffer-stale-function t)))
-        (setq revert t)))
+      (or (and (buffer-file-name)
+               (file-readable-p (buffer-file-name))
+               (not (verify-visited-file-modtime (current-buffer)))
+               (setq revert t))
+          (and (or auto-revert-mode global-auto-revert-non-file-buffers)
+               revert-buffer-function
+               (boundp 'buffer-stale-function)
+               (functionp buffer-stale-function)
+               (setq revert (funcall buffer-stale-function t))))
       (when revert
-        (when auto-revert-verbose
+        (when (and auto-revert-verbose
+                   (not (eq revert 'fast)))
           (message "Reverting buffer `%s'." (buffer-name)))
-        (revert-buffer 'ignore-auto 'dont-ask 'preserve-modes)
-        ;; `preserve-modes' avoids changing the (minor) modes.  But we
-        ;; do want to reset the mode for VC, so we do it explicitly.
-        (vc-find-file-hook)
-        (if (eq revert 'vc)
-            (vc-mode-line buffer-file-name))))))
+        (revert-buffer 'ignore-auto 'dont-ask 'preserve-modes))
+      ;; `preserve-modes' avoids changing the (minor) modes.  But we
+      ;; do want to reset the mode for VC, so we do it manually.
+      (when (or revert auto-revert-check-vc-info)
+        (vc-find-file-hook)))))
 
 (defun auto-revert-buffers ()
   "Revert buffers as specified by Auto-Revert and Global Auto-Revert Mode.
diff --git a/lisp/buff-menu.el b/lisp/buff-menu.el
index a1b0f4093c7..da1c8ed586e 100644
--- a/lisp/buff-menu.el
+++ b/lisp/buff-menu.el
@@ -185,7 +185,7 @@ Letters do not insert themselves; instead, they are commands.
   (set (make-local-variable 'revert-buffer-function)
        'Buffer-menu-revert-function)
   (set (make-local-variable 'buffer-stale-function)
-       #'(lambda (&optional noconfirm) t))
+       #'(lambda (&optional noconfirm) 'fast))
   (setq truncate-lines t)
   (setq buffer-read-only t)
   (run-hooks 'buffer-menu-mode-hook))
diff --git a/lisp/descr-text.el b/lisp/descr-text.el
index abc0d588a14..30ef3dcf05e 100644
--- a/lisp/descr-text.el
+++ b/lisp/descr-text.el
@@ -99,8 +99,9 @@ if that value is non-nil."
 (defun describe-property-list (properties)
   "Insert a description of PROPERTIES in the current buffer.
 PROPERTIES should be a list of overlay or text properties.
-The `category' and `face' properties are made into widget buttons
-that call `describe-text-category' or `describe-face' when pushed."
+The `category', `face' and `font-lock-face' properties are made
+into widget buttons that call `describe-text-category' or
+`describe-face' when pushed."
   ;; Sort the properties by the size of their value.
   (dolist (elt (sort (let ((ret nil)
                            (key nil)
@@ -110,7 +111,7 @@ that call `describe-text-category' or `describe-face' when pushed."
                          (setq key (pop properties)
                                val (pop properties)
                                len 0)
-                         (unless (or (memq key '(category face))
+                         (unless (or (memq key '(category face font-lock-face))
                                      (widgetp val))
                            (setq val (pp-to-string val)
                                  len (length val)))
@@ -128,7 +129,7 @@ that call `describe-text-category' or `describe-face' when pushed."
                             :notify `(lambda (&rest ignore)
                                        (describe-text-category ',value))
                             (format "%S" value)))
-            ((eq key 'face)
+            ((memq key '(face font-lock-face))
              (widget-create 'link
                             :notify `(lambda (&rest ignore)
                                        (describe-face ',value))
diff --git a/lisp/dired-aux.el b/lisp/dired-aux.el
index 1fc8e0e805a..0709e0cfe1c 100644
--- a/lisp/dired-aux.el
+++ b/lisp/dired-aux.el
@@ -186,7 +186,7 @@ List has a form of (file-name full-file-name (attribute-list))"
    (directory-files dir)))
 
 (defun dired-do-chxxx (attribute-name program op-symbol arg)
-  ;; Change file attributes (mode, group, owner) of marked files and
+  ;; Change file attributes (mode, group, owner, timestamp) of marked files and
   ;; refresh their file lines.
   ;; ATTRIBUTE-NAME is a string describing the attribute to the user.
   ;; PROGRAM is the program used to change the attribute.
@@ -203,7 +203,10 @@ List has a form of (file-name full-file-name (attribute-list))"
           (dired-bunch-files 10000
                              (function dired-check-process)
                              (append
-                              (list operation program new-attribute)
+                              (list operation program)
+                              (if (eq op-symbol 'touch)
+                                  '("-t") nil)
+                              (list new-attribute)
                               (if (string-match "gnu" system-configuration)
                                   '("--") nil))
                              files))
@@ -236,6 +239,12 @@ This calls chmod, thus symbolic modes like `g+w' are allowed."
       (error "chown not supported on this system"))
   (dired-do-chxxx "Owner" dired-chown-program 'chown arg))
 
+(defun dired-do-touch (&optional arg)
+  "Change the timestamp of the marked (or next ARG) files.
+This calls touch."
+  (interactive "P")
+  (dired-do-chxxx "Timestamp" dired-touch-program 'touch arg))
+
 ;; Process all the files in FILES in batches of a convenient size,
 ;; by means of (FUNCALL FUNCTION ARGS... SOME-FILES...).
 ;; Batches are chosen to need less than MAX chars for the file names,
diff --git a/lisp/dired-x.el b/lisp/dired-x.el
index fc30428e562..21fe4902e58 100644
--- a/lisp/dired-x.el
+++ b/lisp/dired-x.el
@@ -1517,8 +1517,7 @@ to mark all zero length files."
               ;; Karsten Wenger <kw@cis.uni-muenchen.de> fixed uid.
               (setq uid (buffer-substring (+ (point) 1)
                                           (progn (forward-word 1) (point))))
-              (re-search-forward "\\(Jan\\|Feb\\|Mar\\|Apr\\|May\\|Jun\\|\
-Jul\\|Aug\\|Sep\\|Oct\\|Nov\\|Dec\\)")
+              (re-search-forward dired-move-to-filename-regexp)
               (goto-char (match-beginning 1))
               (forward-char -1)
               (setq size (string-to-int (buffer-substring (save-excursion
diff --git a/lisp/dired.el b/lisp/dired.el
index cfdb57d614c..fd51f7158fa 100644
--- a/lisp/dired.el
+++ b/lisp/dired.el
@@ -79,6 +79,9 @@ some of the `ls' switches are not supported; see the doc string of
 (defvar dired-chmod-program "chmod"
   "Name of chmod command (usually `chmod').")
 
+(defvar dired-touch-program "touch"
+  "Name of touch command (usually `touch').")
+
 ;;;###autoload
 (defcustom dired-ls-F-marks-symlinks nil
   "*Informs dired about how `ls -lF' marks symbolic links.
@@ -315,10 +318,10 @@ Subexpression 2 must end right before the \\n or \\r.")
    ;; Fixme: we could also put text properties on the permission
    ;; fields with keymaps to frob the permissions, somewhat a la XEmacs.
    (list (concat dired-re-maybe-mark dired-re-inode-size
-                 "[-d]....\\(w\\)..\\(w\\).")   ; group writable
-         '(1 font-lock-warning-face))
+                 "[-d]....\\(w\\)....") ; group writable
+         '(1 font-lock-comment-face))
    (list (concat dired-re-maybe-mark dired-re-inode-size
-                 "[-d]....\\(w\\)....") ; world writable
+                 "[-d].......\\(w\\).") ; world writable
          '(1 font-lock-comment-face))
    ;;
    ;; Subdirectories.
@@ -919,6 +922,7 @@ Do so according to the former subdir alist OLD-SUBDIR-ALIST."
     (define-key map "Q" 'dired-do-query-replace-regexp)
     (define-key map "R" 'dired-do-rename)
     (define-key map "S" 'dired-do-symlink)
+    (define-key map "T" 'dired-do-touch)
     (define-key map "X" 'dired-do-shell-command)
     (define-key map "Z" 'dired-do-compress)
     (define-key map "!" 'dired-do-shell-command)
@@ -1189,6 +1193,9 @@ Do so according to the former subdir alist OLD-SUBDIR-ALIST."
     (define-key map [menu-bar operate chmod]
       '(menu-item "Change Mode..." dired-do-chmod
                   :help "Change mode (attributes) of marked files"))
+    (define-key map [menu-bar operate touch]
+      '(menu-item "Change Timestamp..." dired-do-touch
+                  :help "Change timestamp of marked files"))
     (define-key map [menu-bar operate load]
       '(menu-item "Load" dired-do-load
                   :help "Load marked Emacs Lisp files"))
@@ -1630,7 +1637,7 @@ DIR must be a directory name, not a file name."
          (s " ")
          (yyyy "[0-9][0-9][0-9][0-9]")
          (dd "[ 0-3][0-9]")
-         (HH:MM "[ 0-2][0-9]:[0-5][0-9]")
+         (HH:MM "[ 0-2][0-9][:.][0-5][0-9]")
          (seconds "[0-6][0-9]\\([.,][0-9]+\\)?")
          (zone "[-+][0-2][0-9][0-5][0-9]")
          (iso-mm-dd "[01][0-9]-[0-3][0-9]")
@@ -2333,8 +2340,8 @@ if there are no flagged files."
 (defvar dired-no-confirm nil
   "A list of symbols for commands dired should not confirm.
 Command symbols are `byte-compile', `chgrp', `chmod', `chown', `compress',
-`copy', `delete', `hardlink', `load', `move', `print', `shell', `symlink' and
-`uncompress'.")
+`copy', `delete', `hardlink', `load', `move', `print', `shell', `symlink',
+`touch' and `uncompress'.")
 
 (defun dired-mark-pop-up (bufname op-symbol files function &rest args)
   "Return FUNCTION's result on ARGS after showing which files are marked.
@@ -2977,6 +2984,10 @@ This calls chmod, thus symbolic modes like `g+w' are allowed."
   "Change the owner of the marked (or next ARG) files."
   t)
 
+(autoload 'dired-do-touch "dired-aux"
+  "Change the timestamp of the marked (or next ARG) files."
+  t)
+
 (autoload 'dired-do-print "dired-aux"
   "Print the marked (or next ARG) files.
 Uses the shell command coming from variables `lpr-command' and
diff --git a/lisp/files.el b/lisp/files.el
index 706c6856775..be40a0b595e 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -3458,8 +3458,10 @@ The function you specify is responsible for updating (or preserving) point.")
   "Function to check whether a non-file buffer needs reverting.
 This should be a function with one optional argument NOCONFIRM.
 Auto Revert Mode sets NOCONFIRM to t.  The function should return
-non-nil if the buffer should be reverted.  The buffer is current
-when this function is called.
+non-nil if the buffer should be reverted.  A return value of
+`fast' means that the need for reverting was not checked, but
+that reverting the buffer is fast.  The buffer is current when
+this function is called.
 
 The idea behind the NOCONFIRM argument is that it should be
 non-nil if the buffer is going to be reverted without asking the
diff --git a/lisp/international/characters.el b/lisp/international/characters.el
index 301d8ea5454..7af456d1878 100644
--- a/lisp/international/characters.el
+++ b/lisp/international/characters.el
@@ -1129,8 +1129,6 @@
        '("$,1sEsF(B"                          ; U+2045 U+2046
          "$,1s}s~(B"                          ; U+207D U+207E
          "$,1t-t.(B"                          ; U+208D U+208E
-         "$,1zhzi(B"                          ; U+2308 U+2309
-         "$,1zjzk(B"                          ; U+230A U+230B
          "$,1{){*(B"                          ; U+2329 U+232A
          "$,1|T|U(B"                          ; U+23B4 U+23B5
          "$,2&H&I(B"                          ; U+2768 U+2769
diff --git a/lisp/international/mule-util.el b/lisp/international/mule-util.el
index b667ec9227a..3a3539359ec 100644
--- a/lisp/international/mule-util.el
+++ b/lisp/international/mule-util.el
@@ -384,10 +384,15 @@ basis, this may not be accurate."
                  ;; Now FONT-PATTERN is a string or a cons of family
                  ;; field pattern and registry field pattern.
                  (or (stringp font-pattern)
-                     (setq font-pattern (concat "-"
-                                                (or (car font-pattern) "*")
-                                                "-*-"
-                                                (cdr font-pattern))))
+                     (let ((family (or (car font-pattern) "*"))
+                           (registry (or (cdr font-pattern) "*")))
+                       (or (string-match "-" family)
+                           (setq family (concat "*-" family)))
+                       (or (string-match "-" registry)
+                           (setq registry (concat registry "-*")))
+                       (setq font-pattern
+                             (format "-%s-*-*-*-*-*-*-*-*-*-*-%s"
+                                     family registry))))
                  (x-list-fonts font-pattern 'default (selected-frame) 1)))))
         (t
          (let ((coding (terminal-coding-system)))
diff --git a/lisp/international/ucs-tables.el b/lisp/international/ucs-tables.el
index 476c8dfc191..5574cf3d954 100644
--- a/lisp/international/ucs-tables.el
+++ b/lisp/international/ucs-tables.el
@@ -1247,12 +1247,14 @@ unification on input operations."
   "Insert the Emacs character representation of the given Unicode.
 Interactively, prompts for a hex string giving the code."
   (interactive "sUnicode (hex): ")
-  (let ((c (decode-char 'ucs (if (integerp arg)
-                                 arg
-                               (string-to-number arg 16)))))
+  (or (integerp arg)
+      (setq arg (string-to-number arg 16)))
+  (let ((c (decode-char 'ucs arg)))
     (if c
         (insert c)
-      (error "Character can't be decoded to UCS"))))
+      (if (or (< arg 0) (> arg #x10FFFF))
+          (error "Not a Unicode character code: 0x%X" arg)
+        (error "Character U+%04X is not yet supported" arg)))))
 
 ;;; Dealing with non-8859 character sets.
 
diff --git a/lisp/net/browse-url.el b/lisp/net/browse-url.el
index fa0d7ea7914..a70e08028d2 100644
--- a/lisp/net/browse-url.el
+++ b/lisp/net/browse-url.el
@@ -1,6 +1,6 @@
 ;;; browse-url.el --- pass a URL to a WWW browser
 
-;; Copyright (C) 1995, 96, 97, 98, 99, 2000, 2001
+;; Copyright (C) 1995, 96, 97, 98, 99, 2000, 2001, 2004
 ;;   Free Software Foundation, Inc.
 
 ;; Author: Denis Howe <dbh@doc.ic.ac.uk>
@@ -1352,8 +1352,8 @@ don't offer a form of remote control."
   (interactive (browse-url-interactive-arg "URL: "))
   (if (not browse-url-generic-program)
     (error "No browser defined (`browse-url-generic-program')"))
-  (apply 'start-process (concat browse-url-generic-program url) nil
-         browse-url-generic-program
+  (apply 'call-process browse-url-generic-program nil
+         0 nil
          (append browse-url-generic-args (list url))))
 
 ;;;###autoload
diff --git a/lisp/pcvs.el b/lisp/pcvs.el
index a7683ce371e..cc72d02f64a 100644
--- a/lisp/pcvs.el
+++ b/lisp/pcvs.el
@@ -1,6 +1,6 @@
 ;;; pcvs.el --- a front-end to CVS
 
-;; Copyright (C) 1991,92,93,94,95,95,97,98,99,2000,02,2003
+;; Copyright (C) 1991,92,93,94,95,95,97,98,99,2000,02,03,2004
 ;;               Free Software Foundation, Inc.
 
 ;; Author: (The PCL-CVS Trust) pcl-cvs@cyclic.com
@@ -12,7 +12,7 @@
 ;;      (Stefan Monnier) monnier@cs.yale.edu
 ;;      (Greg Klanderman) greg@alphatech.com
 ;;      (Jari Aalto+mail.emacs) jari.aalto@poboxes.com
-;; Maintainer: (Stefan Monnier) monnier+lists/cvs/pcl@flint.cs.yale.edu
+;; Maintainer: (Stefan Monnier) monnier@gnu.org
 ;; Keywords: CVS, version control, release management
 
 ;; This file is part of GNU Emacs.
@@ -669,6 +669,14 @@ DCD is the `dont-change-disc' flag to use when parsing that output.
 SUBDIR is the subdirectory (if any) where this command was run.
 OLD-FIS is the list of fileinfos on which the cvs command was applied and
   which should be considered up-to-date if they are missing from the output."
+  (when (eq system-type 'darwin)
+    ;; Fixup the ^D^H^H inserted at beginning of buffer sometimes on MacOSX
+    ;; because of the call to `process-send-eof'.
+    (save-excursion
+      (goto-char (point-min))
+      (while (re-search-forward "^\\^D+" nil t)
+        (let ((inhibit-read-only t))
+          (delete-region (match-beginning 0) (match-end 0))))))
   (let* ((fileinfos (cvs-parse-buffer 'cvs-parse-table dcd subdir))
          last)
     (with-current-buffer cvs-buffer
diff --git a/lisp/printing.el b/lisp/printing.el
index 377e1fc4538..1e65fdba4ea 100644
--- a/lisp/printing.el
+++ b/lisp/printing.el
@@ -5,13 +5,13 @@
 
 ;; Author: Vinicius Jose Latorre <vinicius@cpqd.com.br>
 ;; Maintainer: Vinicius Jose Latorre <vinicius@cpqd.com.br>
-;; Time-stamp: <2004/03/10 20:37:21 vinicius>
+;; Time-stamp: <2004/03/31 23:14:47 vinicius>
 ;; Keywords: wp, print, PostScript
-;; Version: 6.7.2
+;; Version: 6.7.4
 ;; X-URL: http://www.cpqd.com.br/~vinicius/emacs/
 
-(defconst pr-version "6.7.2"
-  "printing.el, v 6.7.2 <2004/02/29 vinicius>
+(defconst pr-version "6.7.4"
+  "printing.el, v 6.7.4 <2004/03/31 vinicius>
 
 Please send all bug fixes and enhancements to
         Vinicius Jose Latorre <vinicius@cpqd.com.br>
@@ -187,6 +187,10 @@ Please send all bug fixes and enhancements to
 ;;    another buffer and, then, print the file or the new static buffer.
 ;;    An example of dynamic buffer is the *Messages* buffer.
 ;;
+;; 4. When running Emacs on Windows with cygwin, check if the
+;;    `pr-shell-file-name' variable is set to the proper shell.  This shell
+;;    will execute the commands to preview/print the buffer, file or directory.
+;;
 ;;
 ;; Using `printing'
 ;; ----------------
@@ -2304,7 +2308,8 @@ It's used by `pr-interface'."
 
 
 (defcustom pr-shell-file-name
-  (if (eq pr-path-style 'windows)
+  (if (and (not pr-cygwin-system)
+           ps-windows-system)
       "cmdproxy.exe"
     shell-file-name)
   "*Specify file name to load inferior shells from."
@@ -4572,8 +4577,8 @@ See `pr-visible-entry-alist'.")
     (defun pr-menu-position (entry index horizontal)
       (let ((pos (cdr (pr-e-mouse-pixel-position))))
         (list
-         (list (car pos)                ; X
-               (- (cdr pos)             ; Y
+         (list (or (car pos) 0)         ; X
+               (- (or (cdr pos) 0)      ; Y
                   (* (pr-menu-index entry index) pr-menu-char-height)))
          (selected-frame))))            ; frame
     )
@@ -4582,9 +4587,9 @@ See `pr-visible-entry-alist'.")
     (defun pr-menu-position (entry index horizontal)
       (let ((pos (cdr (pr-e-mouse-pixel-position))))
         (list
-         (list (- (car pos)             ; X
+         (list (- (or (car pos) 0)      ; X
                   (* horizontal pr-menu-char-width))
-               (- (cdr pos)             ; Y
+               (- (or (cdr pos) 0)      ; Y
                   (* (pr-menu-index entry index) pr-menu-char-height)))
          (selected-frame))))            ; frame
     ))
@@ -4656,7 +4661,7 @@ otherwise, update PostScript printer menu iff `pr-ps-printer-menu-modified' is
 non-nil, update text printer menu iff `pr-txt-printer-menu-modified' is
 non-nil, and update PostScript File menus iff `pr-ps-utility-menu-modified' is
 non-nil."
-  (interactive)
+  (interactive "P")
   (pr-update-var 'pr-ps-name pr-ps-printer-alist)
   (pr-update-var 'pr-txt-name pr-txt-printer-alist)
   (pr-update-var 'pr-ps-utility pr-ps-utility-alist)
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index 8415fd2050e..05fb8ee059d 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -227,7 +227,7 @@ of[ \t]+\"?\\([a-zA-Z]?:?[^\":\n]+\\)\"?:" 3 2 nil (1))
      ("`\\(\\(\\S +?\\)\\(?::\\([0-9]+\\)\\)?\\)'" nil nil
       (2 compilation-info-face)
       (3 compilation-line-face nil t)
-      (1 (compilation-error-properties 2 3 nil nil nil 2 nil)
+      (1 (compilation-error-properties 2 3 nil nil nil 0 nil)
          append)))
 
     (mips-1
@@ -1076,11 +1076,17 @@ variable exists."
     (if (or noconfirm (yes-or-no-p (format "Restart compilation? ")))
         (apply 'compilation-start compilation-arguments))))
 
+;; This points to the location from where the next error will be found.
+;; The global commands next/previous/first-error... as well as
+;; (mouse-)goto-error use this.
+(defvar compilation-current-error nil)
+
 ;; A function name can't be a hook, must be something with a value.
 (defconst compilation-turn-on-font-lock 'turn-on-font-lock)
 
 (defun compilation-setup (&optional minor)
   "Prepare the buffer for the compilation parsing commands to work."
+  (make-local-variable 'compilation-current-error)
   (make-local-variable 'compilation-error-screen-columns)
   (setq compilation-last-buffer (current-buffer))
   (if minor
@@ -1233,7 +1239,7 @@ Just inserts the text, but uses `insert-before-markers'."
           ;; count this message only if none of the above are true
           (setq n (,1+ n)))))
 
-(defun compilation-next-error (n &optional different-file)
+(defun compilation-next-error (n &optional different-file pt)
   "Move point to the next error in the compilation buffer.
 Prefix arg N says how many error messages to move forwards (or
 backwards, if negative).
@@ -1241,11 +1247,11 @@ Does NOT find the source line like \\[next-error]."
   (interactive "p")
   (or (compilation-buffer-p (current-buffer))
       (error "Not in a compilation buffer"))
+  (or pt (setq pt (point)))
   (setq compilation-last-buffer (current-buffer))
-  (let* ((pt (point))
-        (msg (get-text-property pt 'message))
-        (loc (car msg))
-        last)
+  (let* ((msg (get-text-property pt 'message))
+         (loc (car msg))
+         last)
     (if (zerop n)
         (unless (or msg                 ; find message near here
                     (setq msg (get-text-property (max (1- pt) 1) 'message)))
@@ -1263,13 +1269,15 @@ Does NOT find the source line like \\[next-error]."
                 (setq msg (get-text-property pt 'message))
               (setq pt (point)))))
       (setq last (nth 2 (car msg)))
-      ;; These loops search only either forwards or backwards
-      (compilation-loop > next-single-property-change 1-
-                        (if (get-buffer-process (current-buffer))
-                            "No more %ss yet"
-                          "Moved past last %s"))
-      (compilation-loop < previous-single-property-change 1+
-                        "Moved back before first %s"))
+      (if (>= n 0)
+          (compilation-loop > next-single-property-change 1-
+                            (if (get-buffer-process (current-buffer))
+                                "No more %ss yet"
+                              "Moved past last %s"))
+        ;; don't move "back" to message at or before point
+        (setq pt (previous-single-property-change pt 'message))
+        (compilation-loop < previous-single-property-change 1+
+                          "Moved back before first %s")))
     (goto-char pt)
     (or msg
         (error "No %s here" compilation-error))))
@@ -1327,6 +1335,7 @@ Prefix arg N says how many files to move backwards (or forwards, if negative)."
   (mouse-set-point event)
   (if (get-text-property (point) 'directory)
       (dired-other-window (car (get-text-property (point) 'directory)))
+    (setq compilation-current-error (point))
     (next-error 0)))
 
 (defun compile-goto-error ()
@@ -1338,6 +1347,7 @@ Use this command in a compilation log buffer.  Sets the mark at point there."
   (if (get-text-property (point) 'directory)
       (dired-other-window (car (get-text-property (point) 'directory)))
     (push-mark)
+    (setq compilation-current-error (point))
     (next-error 0)))
 
 ;; Return a compilation buffer.
@@ -1393,10 +1403,12 @@ See variable `compilation-error-regexp-alist' for customization ideas."
   (set-buffer (setq compilation-last-buffer (compilation-find-buffer)))
   (let* ((columns compilation-error-screen-columns) ; buffer's local value
          (last 1)
-         (loc (compilation-next-error (or n 1)))
+         (loc (compilation-next-error (or n 1) nil
+                                      (or compilation-current-error (point-min))))
          (end-loc (nth 2 loc))
          (marker (point-marker)))
-    (setq loc (car loc))
+    (setq compilation-current-error (point-marker)
+          loc (car loc))
     ;; If loc contains no marker, no error in that file has been visited.  If
     ;; the marker is invalid the buffer has been killed.  So, recalculate all
     ;; markers for that file.
@@ -1448,10 +1460,10 @@ With prefix arg N, visit the source code of the Nth error.
 This operates on the output from the \\[compile] command."
   (interactive "p")
   (set-buffer (setq compilation-last-buffer (compilation-find-buffer)))
-  (goto-char (point-min))
+  (setq compilation-current-error (point-min))
   (next-error n))
 
-(defvar compilation-skip-to-next-location nil
+(defvar compilation-skip-to-next-location t
   "*If non-nil, skip multiple error messages for the same source location.")
 
 (defcustom compilation-skip-threshold 1
diff --git a/lisp/progmodes/ebnf-abn.el b/lisp/progmodes/ebnf-abn.el
index 9c341c5181c..e41d27d0c1f 100644
--- a/lisp/progmodes/ebnf-abn.el
+++ b/lisp/progmodes/ebnf-abn.el
@@ -4,7 +4,7 @@
 
 ;; Author: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 ;; Maintainer: Vinicius Jose Latorre <viniciusjl@ig.com.br>
-;; Time-stamp: <2004/02/28 17:40:41 vinicius>
+;; Time-stamp: <2004/03/18 23:49:58 vinicius>
 ;; Keywords: wp, ebnf, PostScript
 ;; Version: 1.0
 
@@ -233,6 +233,8 @@
     (setq token (ebnf-abn-lex))
     (and (eq token 'end-of-input)
          (error "Invalid ABNF file format"))
+    (and (eq token 'end-of-rule)
+         (setq token (ebnf-abn-lex)))
     (while (not (eq token 'end-of-input))
       (ebnf-message-float
        "Parsing...%s%%"
diff --git a/lisp/progmodes/ebnf-ebx.el b/lisp/progmodes/ebnf-ebx.el
new file mode 100644
index 00000000000..4e9fc24ade1
--- /dev/null
+++ b/lisp/progmodes/ebnf-ebx.el
@@ -0,0 +1,672 @@
+;;; ebnf-ebx.el --- parser for EBNF used to specify XML (EBNFX)
+
+;; Copyright (C) 2004 Free Sofware Foundation, Inc.
+
+;; Author: Vinicius Jose Latorre <viniciusjl@ig.com.br>
+;; Maintainer: Vinicius Jose Latorre <viniciusjl@ig.com.br>
+;; Time-stamp: <2004/03/22 08:53:21 vinicius>
+;; Keywords: wp, ebnf, PostScript
+;; Version: 1.0
+
+;; 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 is part of ebnf2ps package.
+;;
+;; This package defines a parser for EBNF used to specify XML (EBNFX).
+;;
+;; See ebnf2ps.el for documentation.
+;;
+;;
+;; EBNFX Syntax
+;; ------------
+;;
+;;      See the URL:
+;;      `http://www.w3.org/TR/2004/REC-xml-20040204/#sec-notation'
+;;      (Extensible Markup Language (XML) 1.0 (Third Edition))
+;;
+;;
+;; rule ::= symbol '::=' expression
+;; /* rules are separated by at least one blank line. */
+;;
+;; expression ::= concatenation ('|' concatenation)*
+;;
+;; concatenation ::= exception*
+;;
+;; exception ::= term ('-' term)?
+;;
+;; term ::= factor ('*' | '+' | '?')?
+;;
+;; factor ::= hex-char+
+;;          | '[' '^'? ( char ( '-' char )? )+ ']'
+;;          | '"' 'string' '"'
+;;          | "'" "string" "'"
+;;          | '(' expression ')'
+;;          | symbol
+;;
+;; symbol ::= 'upper or lower case letter'
+;;            ('upper or lower case letter' | '-' | '_')*
+;; /* upper and lower 8-bit accentuated characters are included */
+;;
+;; hex-char ::= '#x' [0-9A-Fa-f]+
+;;
+;; char ::= hex-char | 'any character except control characters'
+;; /* 8-bit accentuated characters are included */
+;;
+;; any-char ::= char | 'newline' | 'tab'
+;;
+;; ignore ::= '[' ('wfc' | 'WFC' | 'vc' | 'VC') ':' ( any-char - ']' )* ']'
+;;
+;; comment ::= '/*' ( any-char - '*/' ) '*/'
+;;
+;;
+;; Below is the Notation section extracted from the URL cited above.
+;;
+;; 6 Notation
+;;
+;; The formal grammar of XML is given in this specification using a simple
+;; Extended Backus-Naur Form (EBNF) notation.  Each rule in the grammar defines
+;; one symbol, in the form
+;;
+;; symbol ::= expression
+;;
+;; Symbols are written with an initial capital letter if they are the start
+;; symbol of a regular language, otherwise with an initial lowercase letter.
+;; Literal strings are quoted.
+;;
+;; Within the expression on the right-hand side of a rule, the following
+;; expressions are used to match strings of one or more characters:
+;;
+;; #xN
+;;
+;;     where N is a hexadecimal integer, the expression matches the character
+;;     whose number (code point) in ISO/IEC 10646 is N.  The number of leading
+;;     zeros in the #xN form is insignificant.
+;;
+;; [a-zA-Z], [#xN-#xN]
+;;
+;;     matches any Char with a value in the range(s) indicated (inclusive).
+;;
+;; [abc], [#xN#xN#xN]
+;;
+;;     matches any Char with a value among the characters enumerated.
+;;     Enumerations and ranges can be mixed in one set of brackets.
+;;
+;; [^a-z], [^#xN-#xN]
+;;
+;;     matches any Char with a value outside the range indicated.
+;;
+;; [^abc], [^#xN#xN#xN]
+;;
+;;     matches any Char with a value not among the characters given.
+;;     Enumerations and ranges of forbidden values can be mixed in one set of
+;;     brackets.
+;;
+;; "string"
+;;
+;;     matches a literal string matching that given inside the double quotes.
+;;
+;; 'string'
+;;
+;;     matches a literal string matching that given inside the single quotes.
+;;
+;; These symbols may be combined to match more complex patterns as follows,
+;; where A and B represent simple expressions:
+;;
+;; (expression)
+;;
+;;     expression is treated as a unit and may be combined as described in this
+;;     list.
+;;
+;; A?
+;;
+;;     matches A or nothing; optional A.
+;;
+;; A B
+;;
+;;     matches A followed by B.  This operator has higher precedence than
+;;     alternation; thus A B | C D is identical to (A B) | (C D).
+;;
+;; A | B
+;;
+;;     matches A or B.
+;;
+;; A - B
+;;
+;;     matches any string that matches A but does not match B.
+;;
+;; A+
+;;
+;;     matches one or more occurrences of A.  Concatenation has higher
+;;     precedence than alternation; thus A+ | B+ is identical to (A+) | (B+).
+;;
+;; A*
+;;
+;;     matches zero or more occurrences of A.  Concatenation has higher
+;;     precedence than alternation; thus A* | B* is identical to (A*) | (B*).
+;;
+;; Other notations used in the productions are:
+;;
+;; /* ... */
+;;
+;;     comment.
+;;
+;; [ wfc: ... ]
+;;
+;;     well-formedness constraint; this identifies by name a constraint on
+;;     well-formed documents associated with a production.
+;;
+;; [ vc: ... ]
+;;
+;;     validity constraint; this identifies by name a constraint on valid
+;;     documents associated with a production.
+;;
+;;
+;; Differences Between EBNFX And ebnf2ps EBNFX
+;; -------------------------------------------
+;;
+;; Besides the characters that EBNFX accepts, ebnf2ps EBNFX accepts also the
+;; underscore (_) and minus (-) for rule name and european 8-bit accentuated
+;; characters (from \240 to \377) for rule name, string and comment.  Also
+;; rule name can start with upper case letter.
+;;
+;;
+;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Code:
+
+
+(require 'ebnf-otz)
+
+
+(defvar ebnf-ebx-lex nil
+  "Value returned by `ebnf-ebx-lex' function.")
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Syntactic analyzer
+
+
+;;; rulelist ::=  rule+
+
+(defun ebnf-ebx-parser (start)
+  "EBNFX parser."
+  (let ((total (+ (- ebnf-limit start) 1))
+        (bias (1- start))
+        (origin (point))
+        rule-list token rule)
+    (goto-char start)
+    (setq token (ebnf-ebx-lex))
+    (and (eq token 'end-of-input)
+         (error "Invalid EBNFX file format"))
+    (and (eq token 'end-of-rule)
+         (setq token (ebnf-ebx-lex)))
+    (while (not (eq token 'end-of-input))
+      (ebnf-message-float
+       "Parsing...%s%%"
+       (/ (* (- (point) bias) 100.0) total))
+      (setq token (ebnf-ebx-rule token)
+            rule  (cdr token)
+            token (car token))
+      (or (ebnf-add-empty-rule-list rule)
+          (setq rule-list (cons rule rule-list))))
+    (goto-char origin)
+    rule-list))
+
+
+;;; rule ::= symbol '::=' expression
+
+
+(defun ebnf-ebx-rule (token)
+  (let ((name ebnf-ebx-lex)
+        (action ebnf-action)
+        elements)
+    (setq ebnf-action nil)
+    (or (eq token 'non-terminal)
+        (error "Invalid rule name"))
+    (setq token (ebnf-ebx-lex))
+    (or (eq token 'production)
+        (error "Invalid rule: missing `::='"))
+    (setq elements (ebnf-ebx-expression))
+    (or (memq (car elements) '(end-of-rule end-of-input))
+        (error "Invalid rule: there is no end of rule"))
+    (setq elements (cdr elements))
+    (ebnf-eps-add-production name)
+    (cons (ebnf-ebx-lex)
+          (ebnf-make-production name elements action))))
+
+
+;; expression ::= concatenation ('|' concatenation)*
+
+
+(defun ebnf-ebx-expression ()
+  (let (body concatenation)
+    (while (eq (car (setq concatenation
+                          (ebnf-ebx-concatenation (ebnf-ebx-lex))))
+               'alternative)
+      (setq body (cons (cdr concatenation) body)))
+    (ebnf-token-alternative body concatenation)))
+
+
+;; concatenation ::= exception*
+
+
+(defun ebnf-ebx-concatenation (token)
+  (let ((term (ebnf-ebx-exception token))
+        seq)
+    (or (setq token (car term)
+              term  (cdr term))
+        (error "Empty element"))
+    (setq seq (cons term seq))
+    (while (setq term  (ebnf-ebx-exception token)
+                 token (car term)
+                 term  (cdr term))
+      (setq seq (cons term seq)))
+    (cons token
+          (if (= (length seq) 1)
+              ;; sequence with only one element
+              (car seq)
+            ;; a real sequence
+            (ebnf-make-sequence (nreverse seq))))))
+
+
+;;; exception ::= term ('-' term)?
+
+
+(defun ebnf-ebx-exception (token)
+  (let ((term (ebnf-ebx-term token)))
+    (if (eq (car term) 'exception)
+        (let ((except (ebnf-ebx-term (ebnf-ebx-lex))))
+          (cons (car except)
+                (ebnf-make-except (cdr term) (cdr except))))
+      term)))
+          
+
+
+;;; term ::= factor ('*' | '+' | '?')?
+
+
+(defun ebnf-ebx-term (token)
+  (let ((factor (ebnf-ebx-factor token)))
+    (when factor
+      (setq token (ebnf-ebx-lex))
+      (cond ((eq token 'zero-or-more)
+             (setq factor (ebnf-make-zero-or-more factor)
+                   token  (ebnf-ebx-lex)))
+            ((eq token 'one-or-more)
+             (setq factor (ebnf-make-one-or-more factor)
+                   token  (ebnf-ebx-lex)))
+            ((eq token 'optional)
+             (setq factor (ebnf-token-optional factor)
+                   token  (ebnf-ebx-lex)))))
+      (cons token factor)))
+
+
+;;; factor ::= hex-char+
+;;;          | '[' '^'? ( char ( '-' char )? )+ ']'
+;;;          | '"' 'string' '"'
+;;;          | "'" "string" "'"
+;;;          | '(' expression ')'
+;;;          | symbol
+;;;
+;;; symbol ::= 'upper or lower case letter'
+;;;            ('upper or lower case letter' | '-' | '_')*
+;;; /* upper and lower 8-bit accentuated characters are included */
+;;;
+;;; hex-char ::= '#x' [0-9A-Fa-f]+
+;;;
+;;; char ::= hex-char | 'any character except control characters'
+;;; /* 8-bit accentuated characters are included */
+;;;
+;;; any-char ::= char | 'newline' | 'tab'
+
+
+(defun ebnf-ebx-factor (token)
+  (cond
+   ;; terminal
+   ((eq token 'terminal)
+    (ebnf-make-terminal ebnf-ebx-lex))
+   ;; non-terminal
+   ((eq token 'non-terminal)
+    (ebnf-make-non-terminal ebnf-ebx-lex))
+   ;; group
+   ((eq token 'begin-group)
+    (let ((body (ebnf-ebx-expression)))
+      (or (eq (car body) 'end-group)
+          (error "Missing `)'"))
+      (cdr body)))
+   ;; no element
+   (t
+    nil)
+   ))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Lexical analyzer
+
+
+(defconst ebnf-ebx-token-table (make-vector 256 'error)
+  "Vector used to map characters to a lexical token.")
+
+
+(defun ebnf-ebx-initialize ()
+  "Initialize EBNFX token table."
+  ;; control character & control 8-bit character are set to `error'
+  (let ((char ?\101))
+    ;; printable character: A-Z
+    (while (< char ?\133)
+      (aset ebnf-ebx-token-table char 'non-terminal)
+      (setq char (1+ char)))
+    ;; printable character: a-z
+    (setq char ?\141)
+    (while (< char ?\173)
+      (aset ebnf-ebx-token-table char 'non-terminal)
+      (setq char (1+ char)))
+    ;; European 8-bit accentuated characters:
+    (setq char ?\240)
+    (while (< char ?\400)
+      (aset ebnf-ebx-token-table char 'non-terminal)
+      (setq char (1+ char)))
+    ;; Override end of line characters:
+    (aset ebnf-ebx-token-table ?\n 'end-of-rule) ; [NL] linefeed
+    (aset ebnf-ebx-token-table ?\r 'end-of-rule) ; [CR] carriage return
+    ;; Override space characters:
+    (aset ebnf-ebx-token-table ?\013 'space) ; [VT] vertical tab
+    (aset ebnf-ebx-token-table ?\t   'space) ; [HT] horizontal tab
+    (aset ebnf-ebx-token-table ?\    'space) ; [SP] space
+    ;; Override form feed character:
+    (aset ebnf-ebx-token-table ?\f 'form-feed) ; [FF] form feed
+    ;; Override other lexical characters:
+    (aset ebnf-ebx-token-table ?#  'hash)
+    (aset ebnf-ebx-token-table ?\" 'double-quote)
+    (aset ebnf-ebx-token-table ?\' 'single-quote)
+    (aset ebnf-ebx-token-table ?\( 'begin-group)
+    (aset ebnf-ebx-token-table ?\) 'end-group)
+    (aset ebnf-ebx-token-table ?-  'exception)
+    (aset ebnf-ebx-token-table ?:  'colon)
+    (aset ebnf-ebx-token-table ?\[ 'begin-square)
+    (aset ebnf-ebx-token-table ?|  'alternative)
+    (aset ebnf-ebx-token-table ?*  'zero-or-more)
+    (aset ebnf-ebx-token-table ?+  'one-or-more)
+    (aset ebnf-ebx-token-table ?\? 'optional)
+    ;; Override comment character:
+    (aset ebnf-ebx-token-table ?/  'comment)))
+
+
+;; replace the range "\240-\377" (see `ebnf-range-regexp').
+(defconst ebnf-ebx-non-terminal-chars
+  (ebnf-range-regexp "-_A-Za-z" ?\240 ?\377))
+(defconst ebnf-ebx-non-terminal-letter-chars
+  (ebnf-range-regexp "A-Za-z" ?\240 ?\377))
+
+
+(defun ebnf-ebx-lex ()
+  "Lexical analyser for EBNFX.
+
+Return a lexical token.
+
+See documentation for variable `ebnf-ebx-lex'."
+  (if (>= (point) ebnf-limit)
+      'end-of-input
+    (let (token)
+      ;; skip spaces and comments
+      (while (if (> (following-char) 255)
+                 (progn
+                   (setq token 'error)
+                   nil)
+               (setq token (aref ebnf-ebx-token-table (following-char)))
+               (cond
+                ((eq token 'space)
+                 (skip-chars-forward " \013\t" ebnf-limit)
+                 (< (point) ebnf-limit))
+                ((eq token 'comment)
+                 (ebnf-ebx-skip-comment))
+                ((eq token 'form-feed)
+                 (forward-char)
+                 (setq ebnf-action 'form-feed))
+                ((eq token 'end-of-rule)
+                 (ebnf-ebx-skip-end-of-rule))
+                ((and (eq token 'begin-square)
+                      (let ((case-fold-search  t))
+                        (looking-at "\\[\\(wfc\\|vc\\):")))
+                 (ebnf-ebx-skip-constraint))
+                (t nil)
+                )))
+      (cond
+       ;; end of input
+       ((>= (point) ebnf-limit)
+        'end-of-input)
+       ;; error
+       ((eq token 'error)
+        (error "Illegal character"))
+       ;; end of rule
+       ((eq token 'end-of-rule)
+        'end-of-rule)
+       ;; terminal: #x [0-9A-Fa-f]+
+       ((eq token 'hash)
+        (setq ebnf-ebx-lex (ebnf-ebx-character))
+        'terminal)
+       ;; terminal: "string"
+       ((eq token 'double-quote)
+        (setq ebnf-ebx-lex (ebnf-ebx-string ?\"))
+        'terminal)
+       ;; terminal: 'string'
+       ((eq token 'single-quote)
+        (setq ebnf-ebx-lex (ebnf-ebx-string ?\'))
+        'terminal)
+       ;; terminal: [ ^? ( char ( - char )? )+ ]
+       ((eq token 'begin-square)
+        (setq ebnf-ebx-lex (ebnf-ebx-range))
+        'terminal)
+       ;; non-terminal: NAME
+       ((eq token 'non-terminal)
+        (setq ebnf-ebx-lex
+              (ebnf-buffer-substring ebnf-ebx-non-terminal-chars))
+        'non-terminal)
+       ;; colon: ::=
+       ((eq token 'colon)
+        (or (looking-at "::=")
+            (error "Missing `::=' token"))
+        (forward-char 3)
+        'production)
+       ;; miscellaneous: (, ), *, +, ?, |, -
+       (t
+        (forward-char)
+        token)
+       ))))
+
+
+;; replace the range "\177-\237" (see `ebnf-range-regexp').
+(defconst ebnf-ebx-constraint-chars
+  (ebnf-range-regexp "^\000-\010\016-\037]" ?\177 ?\237))
+
+
+(defun ebnf-ebx-skip-constraint ()
+  (or (> (skip-chars-forward ebnf-ebx-constraint-chars ebnf-limit) 0)
+      (error "Invalid character"))
+  (or (= (following-char) ?\])
+      (error "Missing end of constraint `]'"))
+  (forward-char)
+  t)
+  
+
+
+(defun ebnf-ebx-skip-end-of-rule ()
+  (let (eor-p)
+    (while (progn
+             ;; end of rule ==> 2 or more consecutive end of lines
+             (setq eor-p (or (> (skip-chars-forward "\r\n" ebnf-limit) 1)
+                             eor-p))
+             ;; skip spaces
+             (skip-chars-forward " \013\t" ebnf-limit)
+             ;; skip comments
+             (and (= (following-char) ?/)
+                  (ebnf-ebx-skip-comment))))
+    (not eor-p)))
+
+
+;; replace the range "\177-\237" (see `ebnf-range-regexp').
+(defconst ebnf-ebx-comment-chars
+  (ebnf-range-regexp "^\000-\010\016-\037\\*" ?\177 ?\237))
+(defconst ebnf-ebx-filename-chars
+  (ebnf-range-regexp "^\000-\037\\*" ?\177 ?\237))
+
+
+(defun ebnf-ebx-skip-comment ()
+  (forward-char)
+  (or (= (following-char) ?*)
+      (error "Invalid beginning of comment"))
+  (forward-char)
+  (cond
+   ;; open EPS file
+   ((and ebnf-eps-executing (= (following-char) ?\[))
+    (ebnf-eps-add-context (ebnf-ebx-eps-filename)))
+   ;; close EPS file
+   ((and ebnf-eps-executing (= (following-char) ?\]))
+    (ebnf-eps-remove-context (ebnf-ebx-eps-filename)))
+   ;; any other action in comment
+   (t
+    (setq ebnf-action (aref ebnf-comment-table (following-char))))
+   )
+  (while (progn
+           (skip-chars-forward ebnf-ebx-comment-chars ebnf-limit)
+           (or (= (following-char) ?*)
+               (error "Missing end of comment"))
+           (forward-char)
+           (and (/= (following-char) ?/)
+                (< (point) ebnf-limit))))
+  ;; check for a valid end of comment
+  (and (>= (point) ebnf-limit)
+       (error "Missing end of comment"))
+  (forward-char)
+  t)
+
+
+(defun ebnf-ebx-eps-filename ()
+  (forward-char)
+  (let (fname nchar)
+    (while (progn
+             (setq fname
+                   (concat fname
+                           (ebnf-buffer-substring ebnf-ebx-filename-chars)))
+             (and (< (point) ebnf-limit)
+                  (> (setq nchar (skip-chars-forward "*" ebnf-limit)) 0)
+                  (< (point) ebnf-limit)
+                  (/= (following-char) ?/)))
+      (setq fname (concat fname (make-string nchar ?*))
+            nchar nil))
+    (if (or (not nchar) (= nchar 0))
+        fname
+      (and (< (point) ebnf-limit)
+           (= (following-char) ?/)
+           (setq nchar (1- nchar)))
+      (concat fname (make-string nchar ?*)))))
+
+
+;; replace the range "\240-\377" (see `ebnf-range-regexp').
+(defconst ebnf-ebx-double-string-chars
+  (ebnf-range-regexp "\t -!#-~" ?\240 ?\377))
+(defconst ebnf-ebx-single-string-chars
+  (ebnf-range-regexp "\t -&(-~" ?\240 ?\377))
+
+
+(defun ebnf-ebx-string (delim)
+  (buffer-substring-no-properties
+   (progn
+     (forward-char)
+     (point))
+   (progn
+     (skip-chars-forward (if (= delim ?\")
+                             ebnf-ebx-double-string-chars
+                           ebnf-ebx-single-string-chars)
+                         ebnf-limit)
+     (or (= (following-char) delim)
+         (error "Missing string delimiter `%c'" delim))
+     (prog1
+         (point)
+       (forward-char)))))
+
+
+(defun ebnf-ebx-character ()
+  ;; #x [0-9A-Fa-f]+
+  (buffer-substring-no-properties
+   (point)
+   (progn
+     (ebnf-ebx-hex-character)
+     (point))))
+
+
+(defun ebnf-ebx-range ()
+  ;; [ ^? ( char ( - char )? )+ ]
+  (buffer-substring-no-properties
+   (point)
+   (progn
+     (forward-char)
+     (and (= (following-char) ?^)
+          (forward-char))
+     (and (= (following-char) ?-)
+          (forward-char))
+     (while (progn
+              (ebnf-ebx-any-character)
+              (when (= (following-char) ?-)
+                (forward-char)
+                (ebnf-ebx-any-character))
+              (and (/= (following-char) ?\])
+                   (< (point) ebnf-limit))))
+     (and (>= (point) ebnf-limit)
+          (error "Missing end of character range `]'"))
+     (forward-char)
+     (point))))
+
+
+(defun ebnf-ebx-any-character ()
+  (let ((char (following-char)))
+    (cond ((= char ?#)
+           (ebnf-ebx-hex-character t))
+          ((or (and (<= ?\    char) (<= char ?\")) ; #
+               (and (<= ?$    char) (<= char ?,))  ; -
+               (and (<= ?.    char) (<= char ?\\)) ; ]
+               (and (<= ?^    char) (<= char ?~))
+               (and (<= ?\240 char) (<= char ?\377)))
+           (forward-char))
+          (t
+           (error "Invalid character `%c'" char)))))
+
+
+(defun ebnf-ebx-hex-character (&optional no-error)
+  ;; #x [0-9A-Fa-f]+
+  (forward-char)
+  (if (/= (following-char) ?x)
+      (or no-error
+          (error "Invalid hexadecimal character"))
+    (forward-char)
+    (or (> (skip-chars-forward "0-9A-Fa-f" ebnf-limit) 0)
+        (error "Invalid hexadecimal character"))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(provide 'ebnf-ebx)
+
+;;; arch-tag: bfe2f95b-66bc-4dc6-8b7e-b7831e68f5fb
+;;; ebnf-ebx.el ends here
diff --git a/lisp/progmodes/ebnf2ps.el b/lisp/progmodes/ebnf2ps.el
index 96ec53ac501..56125cbea5a 100644
--- a/lisp/progmodes/ebnf2ps.el
+++ b/lisp/progmodes/ebnf2ps.el
@@ -5,9 +5,9 @@
 
 ;; Author: Vinicius Jose Latorre <viniciusjl@ig.com.br>
 ;; Maintainer: Vinicius Jose Latorre <viniciusjl@ig.com.br>
-;; Time-stamp: <2004/02/29 14:06:59 vinicius>
+;; Time-stamp: <2004/03/30 21:49:21 vinicius>
 ;; Keywords: wp, ebnf, PostScript
-;; Version: 4.0
+;; Version: 4.1
 ;; X-URL: http://www.cpqd.com.br/~vinicius/emacs/
 
 ;; This file is part of GNU Emacs.
@@ -27,8 +27,8 @@
 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 ;; Boston, MA 02111-1307, USA.
 
-(defconst ebnf-version "4.0"
-  "ebnf2ps.el, v 4.0 <2004/02/28 vinicius>
+(defconst ebnf-version "4.1"
+  "ebnf2ps.el, v 4.1 <2004/03/18 vinicius>
 
 Vinicius's last change version.  When reporting bugs, please also
 report the version of Emacs, if any, that ebnf2ps was running with.
@@ -320,6 +320,10 @@ Please send all bug fixes and enhancements to
 ;;                      setting:
 ;;                      `ebnf-yac-ignore-error-recovery'.
 ;;
+;;    `ebnfx'           ebnf2ps recognizes the syntax described in the URL:
+;;                   `http://www.w3.org/TR/2004/REC-xml-20040204/#sec-notation'
+;;                   ("Extensible Markup Language (XML) 1.0 (Third Edition)")
+;;
 ;; Any other value is treated as `ebnf'.
 ;;
 ;; The default value is `ebnf'.
@@ -1679,9 +1683,14 @@ Valid values are:
                 setting:
                 `ebnf-yac-ignore-error-recovery'.
 
+   `ebnfx'      ebnf2ps recognizes the syntax described in the URL:
+                `http://www.w3.org/TR/2004/REC-xml-20040204/#sec-notation'
+                (\"Extensible Markup Language (XML) 1.0 (Third Edition)\")
+
 Any other value is treated as `ebnf'."
   :type '(radio :tag "Syntax"
-                (const ebnf) (const abnf) (const iso-ebnf) (const yacc))
+                (const ebnf) (const abnf)  (const iso-ebnf)
+                (const yacc) (const ebnfx))
   :group 'ebnf-syntactic)
 
 
@@ -2393,6 +2402,10 @@ See also `ebnf-syntax-buffer'."
     (yacc
      default
      (ebnf-syntax                      . 'yacc))
+    ;; ebnfx default
+    (ebnfx
+     default
+     (ebnf-syntax                      . 'ebnfx))
     )
   "Style database.
 
@@ -4650,7 +4663,8 @@ killed after process termination."
   '((iso-ebnf  ebnf-iso-parser  ebnf-iso-initialize)
     (yacc      ebnf-yac-parser  ebnf-yac-initialize)
     (abnf      ebnf-abn-parser  ebnf-abn-initialize)
-    (ebnf      ebnf-bnf-parser  ebnf-bnf-initialize))
+    (ebnf      ebnf-bnf-parser  ebnf-bnf-initialize)
+    (ebnfx     ebnf-ebx-parser  ebnf-ebx-initialize))
   "Alist associating ebnf syntax with a parser and a initializer.")
 
 
@@ -4748,52 +4762,53 @@ killed after process termination."
 
 
 (defun ebnf-eps-finish-and-write (buffer filename)
-  (save-excursion
-    (set-buffer buffer)
-    (setq ebnf-eps-upper-x (max ebnf-eps-upper-x ebnf-eps-max-width)
-          ebnf-eps-upper-y (if (zerop ebnf-eps-upper-y)
-                               ebnf-eps-max-height
-                             (+ ebnf-eps-upper-y
-                                ebnf-production-vertical-space
-                                ebnf-eps-max-height)))
-    ;; prologue
-    (goto-char (point-min))
-    (insert
-     "%!PS-Adobe-3.0 EPSF-3.0"
-     "\n%%BoundingBox: 0 0 "
-     (format "%d %d" (1+ ebnf-eps-upper-x) (1+ ebnf-eps-upper-y))
-     "\n%%Title: " filename
-     "\n%%CreationDate: " (format-time-string "%T %b %d %Y")
-     "\n%%Creator: " (user-full-name) " (using ebnf2ps v" ebnf-version ")"
-     "\n%%DocumentNeededResources: font "
-     (or ebnf-fonts-required
-         (setq ebnf-fonts-required
-               (mapconcat 'identity
-                          (ps-remove-duplicates
-                           (mapcar 'ebnf-font-name-select
-                                   (list ebnf-production-font
-                                         ebnf-terminal-font
-                                         ebnf-non-terminal-font
-                                         ebnf-special-font
-                                         ebnf-except-font
-                                         ebnf-repeat-font)))
-                          "\n%%+ font ")))
-     "\n%%Pages: 0\n%%EndComments\n\n%%BeginProlog\n"
-     ebnf-eps-prologue)
-    (ebnf-insert-ebnf-prologue)
-    (insert ebnf-eps-begin
-            "\n0 " (ebnf-format-float
-                    (- ebnf-eps-upper-y (* ebnf-font-height-P 0.7)))
-            " #ebnf2ps#begin\n")
-    ;; epilogue
-    (goto-char (point-max))
-    (insert ebnf-eps-end)
-    ;; write file
-    (message "Saving...")
-    (setq filename (expand-file-name filename))
-    (let ((coding-system-for-write 'raw-text-unix))
-      (write-region (point-min) (point-max) filename))
-    (message "Wrote %s" filename)))
+  (when (buffer-modified-p buffer)
+    (save-excursion
+      (set-buffer buffer)
+      (setq ebnf-eps-upper-x (max ebnf-eps-upper-x ebnf-eps-max-width)
+            ebnf-eps-upper-y (if (zerop ebnf-eps-upper-y)
+                                 ebnf-eps-max-height
+                               (+ ebnf-eps-upper-y
+                                  ebnf-production-vertical-space
+                                  ebnf-eps-max-height)))
+      ;; prologue
+      (goto-char (point-min))
+      (insert
+       "%!PS-Adobe-3.0 EPSF-3.0"
+       "\n%%BoundingBox: 0 0 "
+       (format "%d %d" (1+ ebnf-eps-upper-x) (1+ ebnf-eps-upper-y))
+       "\n%%Title: " filename
+       "\n%%CreationDate: " (format-time-string "%T %b %d %Y")
+       "\n%%Creator: " (user-full-name) " (using ebnf2ps v" ebnf-version ")"
+       "\n%%DocumentNeededResources: font "
+       (or ebnf-fonts-required
+           (setq ebnf-fonts-required
+                 (mapconcat 'identity
+                            (ps-remove-duplicates
+                             (mapcar 'ebnf-font-name-select
+                                     (list ebnf-production-font
+                                           ebnf-terminal-font
+                                           ebnf-non-terminal-font
+                                           ebnf-special-font
+                                           ebnf-except-font
+                                           ebnf-repeat-font)))
+                            "\n%%+ font ")))
+       "\n%%Pages: 0\n%%EndComments\n\n%%BeginProlog\n"
+       ebnf-eps-prologue)
+      (ebnf-insert-ebnf-prologue)
+      (insert ebnf-eps-begin
+              "\n0 " (ebnf-format-float
+                      (- ebnf-eps-upper-y (* ebnf-font-height-P 0.7)))
+              " #ebnf2ps#begin\n")
+      ;; epilogue
+      (goto-char (point-max))
+      (insert ebnf-eps-end)
+      ;; write file
+      (message "Saving...")
+      (setq filename (expand-file-name filename))
+      (let ((coding-system-for-write 'raw-text-unix))
+        (write-region (point-min) (point-max) filename))
+      (message "Wrote %s" filename))))
 
 
 (defun ebnf-insert-ebnf-prologue ()
@@ -5688,6 +5703,12 @@ killed after process termination."
 (autoload 'ebnf-yac-initialize        "ebnf-yac"
   "Initializations for Yacc/Bison parser.")
 
+(autoload 'ebnf-ebx-parser            "ebnf-ebx"
+  "EBNFX parser.")
+
+(autoload 'ebnf-ebx-initialize        "ebnf-ebx"
+  "Initializations for EBNFX parser.")
+
 (autoload 'ebnf-eliminate-empty-rules "ebnf-otz"
   "Eliminate empty rules.")
 
diff --git a/lisp/progmodes/gdb-ui.el b/lisp/progmodes/gdb-ui.el
index 08a5a2ccbd3..6fccd500af2 100644
--- a/lisp/progmodes/gdb-ui.el
+++ b/lisp/progmodes/gdb-ui.el
@@ -69,9 +69,14 @@
 The directory containing FILE becomes the initial working directory
 and source-file directory for your debugger.
 
-If `gdb-many-windows' is nil (the default value) then gdb starts with
-just two windows : the GUD and the source buffer. If it is t the
-following layout will appear (keybindings given in relevant buffer) :
+If `gdb-many-windows' is nil (the default value) then gdb just
+pops up the GUD buffer unless `gdb-show-main' is t. In this case
+it starts with two windows: one displaying the GUD buffer and the
+other with the source file with the main routine of the debugee.
+
+If `gdb-many-windows' is t the layout below will appear
+regardless of the value of `gdb-show-main'. Keybindings are given
+in relevant buffer.
 
 ---------------------------------------------------------------------
                                GDB Toolbar
@@ -81,7 +86,7 @@ GUD buffer (I/O of GDB)           | Locals buffer
                                   |
                                   |
 ---------------------------------------------------------------------
-Source buffer                     | Input/Output (of debuggee) buffer
+Source buffer                     | Input/Output (of debugee) buffer
                                   | (comint-mode)
                                   |
                                   |
@@ -309,7 +314,7 @@ speedbar."
         (let ((varnum (match-string 1)))
           (gdb-enqueue-input
            (list (concat "server interpreter mi \"-var-evaluate-expression "
-                         varnum "\"\n") 
+                         varnum "\"\n")
                      `(lambda () (gdb-var-evaluate-expression-handler
                                   ,varnum t)))))))
   (gdb-set-pending-triggers
@@ -672,7 +677,10 @@ This filter may simply queue output for a later time."
          (match-string 1 args)
          (string-to-int (match-string 2 args))))
   (setq gdb-current-address (match-string 3 args))
-  (setq gdb-view-source t))
+  (setq gdb-view-source t)
+;; cover for auto-display output which comes *before*
+;; stopped annotation
+    (if (eq (gdb-get-output-sink) 'inferior) (gdb-set-output-sink 'user)))
 
 (defun gdb-send-item (item)
   (if gdb-enable-debug-log (push (cons 'send item) gdb-debug-log))
@@ -778,7 +786,8 @@ output from the current command if that happens to be appropriate."
         (gdb-invalidate-registers)
         (gdb-invalidate-locals)
         (gdb-invalidate-threads)
-        (unless (eq window-system 'mac)
+        (unless (eq system-type 'darwin) ;Breaks on Darwin's GDB-5.3.
+          ;; FIXME: with GDB-6 on Darwin, this might very well work.
           (dolist (frame (frame-list))
             (when (string-equal (frame-parameter frame 'name) "Speedbar")
               (setq gdb-var-changed t)    ; force update
@@ -1596,24 +1605,38 @@ the source buffer."
 (defun gdb-view-source-function ()
   (interactive)
   (if gdb-view-source
-      (if gud-last-last-frame
-          (set-window-buffer gdb-source-window
-                             (gud-find-file (car gud-last-last-frame)))
-        (set-window-buffer gdb-source-window (gud-find-file gdb-main-file))))
+      (if (window-live-p gdb-source-window)
+              (set-window-buffer gdb-source-window
+                     (if gud-last-last-frame
+                         (gud-find-file (car gud-last-last-frame))
+                       (gud-find-file gdb-main-file)))
+        (setq gdb-source-window
+              (display-buffer
+               (if gud-last-last-frame
+                   (gud-find-file (car gud-last-last-frame))
+                 (gud-find-file gdb-main-file))))))
   (setq gdb-selected-view 'source))
 
 (defun gdb-view-assembler()
   (interactive)
-  (set-window-buffer gdb-source-window
-                     (gdb-get-create-buffer 'gdb-assembler-buffer))
+  (if (window-live-p gdb-source-window)
+      (set-window-buffer gdb-source-window
+                         (gdb-get-create-buffer 'gdb-assembler-buffer))
+    (setq gdb-source-window 
+          (display-buffer (gdb-get-create-buffer 'gdb-assembler-buffer))))
   (setq gdb-selected-view 'assembler))
 
 ;(defun gdb-view-both()
 ;(interactive)
 ;(setq gdb-selected-view 'both))
 
-;; layout for all the windows
+(defcustom gdb-show-main nil
+  "Nil means don't display source file containing the main routine."
+  :type 'boolean
+  :group 'gud)
+
 (defun gdb-setup-windows ()
+  "Layout the window pattern for gdb-many-windows."
   (gdb-display-locals-buffer)
   (gdb-display-stack-buffer)
   (delete-other-windows)
@@ -1714,20 +1737,20 @@ buffers."
       (if (looking-at "\\S-*")
           (setq gdb-main-file (match-string 0)))
     (setq gdb-view-source nil))
-  (delete-other-windows)
-  (switch-to-buffer gud-comint-buffer)
   (if gdb-many-windows
       (gdb-setup-windows)
-    (gdb-display-breakpoints-buffer)
-    (delete-other-windows)
-    (split-window)
-    (other-window 1)
-    (switch-to-buffer
-     (if gdb-view-source
-         (gud-find-file gdb-main-file)
-       (gdb-get-create-buffer 'gdb-assembler-buffer)))
-    (setq gdb-source-window (get-buffer-window (current-buffer)))
-    (other-window 1)))
+    (gdb-get-create-buffer 'gdb-breakpoints-buffer)
+    (when gdb-show-main
+      (switch-to-buffer gud-comint-buffer)
+      (delete-other-windows)
+      (split-window)
+      (other-window 1)
+      (switch-to-buffer
+       (if gdb-view-source
+           (gud-find-file gdb-main-file)
+         (gdb-get-create-buffer 'gdb-assembler-buffer)))
+      (setq gdb-source-window (get-buffer-window (current-buffer)))
+      (other-window 1))))
 
 ;;from put-image
 (defun gdb-put-string (putstring pos &optional dprop)
@@ -1764,9 +1787,9 @@ BUFFER nil or omitted means use the current buffer."
     (gdb-remove-breakpoint-icons start end)
     (if (display-images-p)
         (if (>= (car (window-fringes)) 8)
-            (gdb-put-string 
+            (gdb-put-string
              nil (1+ start)
-             `(left-fringe 
+             `(left-fringe
                ,(or breakpoint-bitmap
                     (setq breakpoint-bitmap
                           (define-fringe-bitmap
@@ -1786,7 +1809,7 @@ BUFFER nil or omitted means use the current buffer."
            (if enabled
                (or breakpoint-enabled-icon
                    (setq breakpoint-enabled-icon
-                         (find-image `((:type xpm :data 
+                         (find-image `((:type xpm :data
                                               ,breakpoint-xpm-data
                                               :ascent 100 :pointer hand)
                                        (:type pbm :data
diff --git a/lisp/progmodes/gud.el b/lisp/progmodes/gud.el
index ff04c05edff..a34b0bb2d48 100644
--- a/lisp/progmodes/gud.el
+++ b/lisp/progmodes/gud.el
@@ -477,7 +477,7 @@ off the specialized speedbar mode."
     ;; gud-marker-acc until we receive the rest of it.  Since we
     ;; know the full marker regexp above failed, it's pretty simple to
     ;; test for marker starts.
-    (if (string-match "\032.*\\'" gud-marker-acc)
+    (if (string-match "\n\\(\032.*\\)?\\'" gud-marker-acc)
         (progn
           ;; Everything before the potential marker start can be output.
           (setq output (concat output (substring gud-marker-acc
diff --git a/lisp/subr.el b/lisp/subr.el
index 2c39a8447cf..74809c678eb 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -2274,28 +2274,6 @@ macros."
       (subrp object) (byte-code-function-p object)
       (eq (car-safe object) 'lambda)))
 
-(defun interactive-form (function)
-  "Return the interactive form of FUNCTION.
-If function is a command (see `commandp'), value is a list of the form
-\(interactive SPEC).  If function is not a command, return nil."
-  (setq function (indirect-function function))
-  (when (commandp function)
-    (cond ((byte-code-function-p function)
-           (when (> (length function) 5)
-             (let ((spec (aref function 5)))
-               (if spec
-                   (list 'interactive spec)
-                 (list 'interactive)))))
-          ((subrp function)
-           (subr-interactive-form function))
-          ((eq (car-safe function) 'lambda)
-           (setq function (cddr function))
-           (when (stringp (car function))
-             (setq function (cdr function)))
-           (let ((form (car function)))
-             (when (eq (car-safe form) 'interactive)
-               (copy-sequence form)))))))
-
 (defun assq-delete-all (key alist)
   "Delete from ALIST all elements whose car is KEY.
 Return the modified alist.
diff --git a/lisp/vc.el b/lisp/vc.el
index 7cceab6779c..9e1f36f93ce 100644
--- a/lisp/vc.el
+++ b/lisp/vc.el
@@ -7,7 +7,7 @@
 ;; Maintainer: Andre Spiegel <spiegel@gnu.org>
 ;; Keywords: tools
 
-;; $Id: vc.el,v 1.373 2004/03/26 16:17:12 monnier Exp $
+;; $Id: vc.el,v 1.374 2004/03/28 22:00:19 monnier Exp $
 
 ;; This file is part of GNU Emacs.
 
@@ -1677,10 +1677,10 @@ saving the buffer."
           (message "No changes to %s since latest version" file)
         (vc-version-diff file nil nil)))))
 
-(defun vc-version-diff (file rel1 rel2)
-  "List the differences between FILE's versions REL1 and REL2.
-If REL1 is empty or nil it means to use the current workfile version;
-REL2 empty or nil means the current file contents.  FILE may also be
+(defun vc-version-diff (file rev1 rev2)
+  "List the differences between FILE's versions REV1 and REV2.
+If REV1 is empty or nil it means to use the current workfile version;
+REV2 empty or nil means the current file contents.  FILE may also be
 a directory, in that case, generate diffs between the correponding
 versions of all registered files in or below it."
   (interactive
@@ -1689,7 +1689,7 @@ versions of all registered files in or below it."
                                     "File or dir to diff: (default visited file) "
                                   "File or dir to diff: ")
                                 default-directory buffer-file-name t)))
-         (rel1-default nil) (rel2-default nil))
+         (rev1-default nil) (rev2-default nil))
      ;; compute default versions based on the file state
      (cond
       ;; if it's a directory, don't supply any version default
@@ -1697,54 +1697,54 @@ versions of all registered files in or below it."
        nil)
       ;; if the file is not up-to-date, use current version as older version
       ((not (vc-up-to-date-p file))
-       (setq rel1-default (vc-workfile-version file)))
+       (setq rev1-default (vc-workfile-version file)))
       ;; if the file is not locked, use last and previous version as default
       (t
-       (setq rel1-default (vc-call previous-version file
+       (setq rev1-default (vc-call previous-version file
                                    (vc-workfile-version file)))
-       (if (string= rel1-default "") (setq rel1-default nil))
-       (setq rel2-default (vc-workfile-version file))))
+       (if (string= rev1-default "") (setq rev1-default nil))
+       (setq rev2-default (vc-workfile-version file))))
      ;; construct argument list
      (list file
-           (read-string (if rel1-default
+           (read-string (if rev1-default
                             (concat "Older version: (default "
-                                    rel1-default ") ")
+                                    rev1-default ") ")
                           "Older version: ")
-                        nil nil rel1-default)
-           (read-string (if rel2-default
+                        nil nil rev1-default)
+           (read-string (if rev2-default
                             (concat "Newer version: (default "
-                                    rel2-default ") ")
+                                    rev2-default ") ")
                           "Newer version (default: current source): ")
-                        nil nil rel2-default))))
+                        nil nil rev2-default))))
   (if (file-directory-p file)
       ;; recursive directory diff
       (progn
         (vc-setup-buffer "*vc-diff*")
-        (if (string-equal rel1 "") (setq rel1 nil))
-        (if (string-equal rel2 "") (setq rel2 nil))
+        (if (string-equal rev1 "") (setq rev1 nil))
+        (if (string-equal rev2 "") (setq rev2 nil))
         (let ((inhibit-read-only t))
           (insert "Diffs between "
-                  (or rel1 "last version checked in")
+                  (or rev1 "last version checked in")
                   " and "
-                  (or rel2 "current workfile(s)")
+                  (or rev2 "current workfile(s)")
                   ":\n\n"))
         (let ((dir (file-name-as-directory file)))
           (vc-call-backend (vc-responsible-backend dir)
-                           'diff-tree dir rel1 rel2))
+                           'diff-tree dir rev1 rev2))
         (vc-exec-after `(let ((inhibit-read-only t))
                           (insert "\nEnd of diffs.\n"))))
     ;; Single file diff.  It is important that the vc-controlled buffer
     ;; is still current at this time, because any local settings in that
     ;; buffer should affect the diff command.
-    (vc-diff-internal file rel1 rel2))
+    (vc-diff-internal file rev1 rev2))
   (set-buffer "*vc-diff*")
   (if (and (zerop (buffer-size))
            (not (get-buffer-process (current-buffer))))
       (progn
-        (if rel1
-            (if rel2
-                (message "No changes to %s between %s and %s" file rel1 rel2)
-              (message "No changes to %s since %s" file rel1))
+        (if rev1
+            (if rev2
+                (message "No changes to %s between %s and %s" file rev1 rev2)
+              (message "No changes to %s since %s" file rev1))
           (message "No changes to %s since latest version" file))
         nil)
     (pop-to-buffer (current-buffer))
@@ -1758,29 +1758,40 @@ versions of all registered files in or below it."
                       (shrink-window-if-larger-than-buffer)))
     t))
 
-(defun vc-diff-internal (file rel1 rel2)
-  "Run diff to compare FILE's revisions REL1 and REL2.
+(defun vc-diff-label (file file-rev rev)
+  (concat (file-relative-name file)
+          (format-time-string "\t%d %b %Y %T %z\t"
+                              (nth 5 (file-attributes file-rev)))
+          rev))
+
+(defun vc-diff-internal (file rev1 rev2)
+  "Run diff to compare FILE's revisions REV1 and REV2.
 Diff output goes to the *vc-diff* buffer.  The exit status of the diff
 command is returned.
 
 This function takes care to set up a proper coding system for diff output.
 If both revisions are available as local files, then it also does not
 actually call the backend, but performs a local diff."
-  (if (or (not rel1) (string-equal rel1 ""))
-      (setq rel1 (vc-workfile-version file)))
-  (if (string-equal rel2 "")
-      (setq rel2 nil))
-  (let ((file-rel1 (vc-version-backup-file file rel1))
-        (file-rel2 (if (not rel2)
+  (if (or (not rev1) (string-equal rev1 ""))
+      (setq rev1 (vc-workfile-version file)))
+  (if (string-equal rev2 "")
+      (setq rev2 nil))
+  (let ((file-rev1 (vc-version-backup-file file rev1))
+        (file-rev2 (if (not rev2)
                        file
-                     (vc-version-backup-file file rel2)))
+                     (vc-version-backup-file file rev2)))
         (coding-system-for-read (vc-coding-system-for-diff file)))
-    (if (and file-rel1 file-rel2)
+    (if (and file-rev1 file-rev2)
         (apply 'vc-do-command "*vc-diff*" 1 "diff" nil
                (append (vc-switches nil 'diff)
-                       (list (file-relative-name file-rel1)
-                             (file-relative-name file-rel2))))
-      (vc-call diff file rel1 rel2))))
+                       ;; Provide explicit labels like RCS or CVS would do
+                       ;; so diff-mode refers to `file' rather than to
+                       ;; `file-rev1' when trying to find/apply/undo hunks.
+                       (list "-L" (vc-diff-label file file-rev1 rev1)
+                             "-L" (vc-diff-label file file-rev2 rev2)
+                             (file-relative-name file-rev1)
+                             (file-relative-name file-rev2))))
+      (vc-call diff file rev1 rev2))))
 
 
 (defun vc-switches (backend op)
@@ -1804,9 +1815,9 @@ actually call the backend, but performs a local diff."
 (defmacro vc-diff-switches-list (backend) `(vc-switches ',backend 'diff))
 (make-obsolete 'vc-diff-switches-list 'vc-switches "21.4")
 
-(defun vc-default-diff-tree (backend dir rel1 rel2)
+(defun vc-default-diff-tree (backend dir rev1 rev2)
   "List differences for all registered files at and below DIR.
-The meaning of REL1 and REL2 is the same as for `vc-version-diff'."
+The meaning of REV1 and REV2 is the same as for `vc-version-diff'."
   ;; This implementation does an explicit tree walk, and calls
   ;; vc-BACKEND-diff directly for each file.  An optimization
   ;; would be to use `vc-diff-internal', so that diffs can be local,
@@ -1821,7 +1832,7 @@ The meaning of REL1 and REL2 is the same as for `vc-version-diff'."
       `(let ((coding-system-for-read (vc-coding-system-for-diff ',f)))
          (message "Looking at %s" ',f)
          (vc-call-backend ',(vc-backend f)
-                          'diff ',f ',rel1 ',rel2))))))
+                          'diff ',f ',rev1 ',rev2))))))
 
 (defun vc-coding-system-for-diff (file)
   "Return the coding system for reading diff output for FILE."
diff --git a/lisp/x-dnd.el b/lisp/x-dnd.el
index 32645bd6012..41e9e3e78b2 100644
--- a/lisp/x-dnd.el
+++ b/lisp/x-dnd.el
@@ -337,7 +337,12 @@ WINDOW is the window where the drop happened.  ACTION is ignored.
 DATA is the moz-url, which is formatted as two strings separated by \r\n.
 The first string is the URL, the second string is the title of that URL.
 DATA is encoded in utf-16.  Decode the URL and call `x-dnd-handle-uri-list'."
-  (let* ((string (decode-coding-string data 'utf-16le))  ;; ALWAYS LE???
+  ;; Mozilla and applications based on it (Galeon for example) uses
+  ;; text/unicode, but it is impossible to tell if it is le or be.  Use what
+  ;; the machine Emacs runs on use.  This looses if dropping between machines
+  ;; with different endian, but it is the best we can do.
+  (let* ((coding (if (eq (byteorder) ?B) 'utf-16be 'utf-16le))
+         (string (decode-coding-string data coding))
          (strings (split-string string "[\r\n]" t))
          ;; Can one drop more than one moz-url ??  Assume not.
          (url (car strings))
@@ -352,7 +357,9 @@ TEXT is the text as a string, WINDOW is the window where the drop happened."
 (defun x-dnd-insert-utf16-text (window action text)
   "Decode the UTF-16 text and insert it at point.
 TEXT is the text as a string, WINDOW is the window where the drop happened."
-  (x-dnd-insert-text window action (decode-coding-string text 'utf-16le)))
+  ;; See comment in x-dnd-handle-moz-url about coding.
+  (let ((coding (if (eq (byteorder) ?B) 'utf-16be 'utf-16le)))
+    (x-dnd-insert-text window action (decode-coding-string text coding))))
 
 (defun x-dnd-insert-ctext (window action text)
   "Decode the compound text and insert it at point.