Merged in changes from CVS trunk.

Patches applied:

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

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-345
   Tweak source regexps so that building in place won't cause problems

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

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

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

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

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

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

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-352
   Update from CVS: lisp/flymake.el: New file.


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

38 files changed, 3282 insertions, 337 deletions

diff --git a/.arch-inventory b/.arch-inventory
new file mode 100644
index 00000000000..3733b7ed6e3
--- /dev/null
+++ b/.arch-inventory
@@ -0,0 +1,3 @@
+precious ^(config\.status)$
+
+# arch-tag: 6eeeaa4e-cc7e-4b22-b3d7-1089e155da14
diff --git a/Makefile.in b/Makefile.in
index 97d9a2a1079..7bfed3fd5ea 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -445,11 +445,9 @@ install-arch-indep: mkdir info
         if [ `(cd ./etc; /bin/pwd)` != `(cd ${docdir}; /bin/pwd)` ]; \
         then \
            echo "Copying etc/DOC-* to ${docdir} ..." ; \
-           (cd ./etc; tar -chf - DOC* compilation.txt) \
+           (cd ./etc; tar -chf - DOC*) \
              |(cd ${docdir}; umask 022; tar -xvf - && cat > /dev/null) || exit 1; \
-           (cd $(docdir); \
-            chown $${LOGNAME:-$$USERNAME} DOC* compilation.txt; \
-            chmod a+r DOC* compilation.txt; \
+           (cd $(docdir); chown $${LOGNAME:-$$USERNAME} DOC*; chmod a+r DOC*; \
             if test "`echo DOC-*`" != "DOC-*"; then rm DOC; fi); \
         else true; fi
         -unset CDPATH; \
diff --git a/etc/.arch-inventory b/etc/.arch-inventory
new file mode 100644
index 00000000000..2637a2d3d8e
--- /dev/null
+++ b/etc/.arch-inventory
@@ -0,0 +1,4 @@
+# Unlike most emacs dirs, etc has a simple non-autoconf-generated makefile
+source ^(Makefile)$
+
+# arch-tag: 5a1d62e0-593a-48cd-8743-8d45dc58dfae
diff --git a/etc/NEWS b/etc/NEWS
index b451fd07efd..bc0ddefdb9f 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -90,6 +90,9 @@ types any more.  Add -DUSE_LISP_UNION_TYPE if you want union types.
 
 * Changes in Emacs 21.4
 
+** A New package flymake.el does on-the-fly syntax checking of program
+source files.  See the Flymake's Info manual for more details.
+
 ** New input method chinese-sisheng for inputting Chinese Pinyin
 characters.
 
@@ -1045,6 +1048,12 @@ counter to the specified source line (the one where point is).
 
   Minor Improvements
 
+*** The STARTTLS elisp wrapper (starttls.el) can now use GNUTLS
+instead of the OpenSSL based "starttls" tool.  For backwards
+compatibility, it will prefer "starttls", but you can toggle
+`starttls-use-gnutls' to switch to GNUTLS (or simply remove the
+"starttls" tool).
+
 *** Do not allow debugger output history variable to grow without bounds.
 
 +++
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 9e5aad11082..28f6d394230 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,115 @@
+2004-05-29  Pavel Kobiakov  <pk_at_work@yahoo.com>
+
+        * flymake.el: New file.
+
+2004-05-28  Luc Teirlinck  <teirllm@auburn.edu>
+
+        * files.el (find-file-noselect-1): Do not bind
+        `inhibit-read-only' to t during execution of
+        `find-file-not-found-functions'.
+
+2004-05-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * vc-mcvs.el (vc-mcvs-print-log, vc-mcvs-diff):
+        * vc-arch.el (vc-arch-diff): Add optional `buffer' arg.
+
+2004-05-28  Juri Linkov  <juri@jurta.org>
+
+        * simple.el (eval-expression-print-format): New fun.
+
+        * simple.el (eval-expression):
+        * emacs-lisp/lisp-mode.el (eval-last-sexp-print-value):
+        * emacs-lisp/edebug.el (edebug-compute-previous-result)
+        (edebug-eval-expression): Print additionally the value returned by
+        `eval-expression-print-format'.
+
+        * emacs-lisp/lisp.el (insert-pair-alist): New var.
+        (insert-pair): Make arguments optional.  Find character pair
+        from `insert-pair-alist' according to the last input event.
+        (insert-parentheses): Make arguments optional.
+        (raise-sexp, delete-pair): New funs.
+
+        * emacs-lisp/lisp-mode.el (indent-pp-sexp): New fun.
+        (emacs-lisp-mode-map, lisp-interaction-mode-map):
+        Bind C-M-q to `indent-pp-sexp'.
+
+        * emacs-lisp/pp.el (pp-buffer): New fun created from the code in
+        `pp-to-string' modified to be able to format text with newlines.
+        (pp-to-string): Move the buffer-formatting part of the code to
+        `pp-buffer'.  Call `pp-buffer'.
+
+        * info.el (Info-desktop-buffer-misc-data): Don't save information
+        about virtual files.
+        (Info-restore-desktop-buffer): Restore Info buffers in prepared
+        buffers with names obtained from the desktop file instead of the
+        default *info* buffer.
+
+2004-05-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * subr.el (with-selected-window): Only save/restore the selected window.
+
+        * progmodes/compile.el (compilation-error-regexp-alist):
+        Use expand-file-name and data-directory.
+
+        * progmodes/grep.el (grep-tree): Rework previous fix.
+
+        * mouse.el (mouse-set-region-1): Use temporary transient-mark-mode
+        after the user marked text with the mouse.
+
+        * startup.el (command-line): Keep the first regexp of
+        auto-save-file-name-transforms intact.
+
+2004-05-28  Juanma Barranquero  <lektu@terra.es>
+
+        * cus-edit.el (customize-face, customize-face-other-window)
+        (custom-face-edit-delete): Make arguments match their use in docstring.
+        (custom-unloaded-symbol-p, custom-unloaded-widget-p): Docstring typo.
+
+        * cvs-status.el (cvs-tree-merge, cvs-tags->tree): Use `butlast',
+        not `cvs-butlast'.
+
+        * pcvs-util.el (cvs-butlast, cvs-nbutlast): Remove (`butlast' and
+        `nbutlast' are in subr.el).
+
+        * w32-fns.el (w32-using-nt, w32-shell-dos-semantics)
+        (set-w32-system-coding-system): Doc fixes.
+
+        * textmodes/artist.el (artist-last, artist-remove-nulls): Simplify.
+        (artist-draw-ellipse-general, artist-draw-ellipse-with-0-height):
+        Make arguments match their use in docstring.
+        (artist-draw-region-trim-line-endings)
+        (artist-mouse-choose-operation): Fix typo in docstring.
+        (artist-key-set-point-common): Doc fix.
+
+2004-05-28  Simon Josefsson  <jas@extundo.com>
+
+        * mail/smtpmail.el (smtpmail-open-stream):
+        Bind starttls-extra-arguments too, if starttls.el uses GNUTLS.
+
+2004-05-26  Simon Josefsson  <jas@extundo.com>
+
+        * starttls.el: Merge with my GNUTLS based starttls.el.
+        (starttls-gnutls-program, starttls-use-gnutls)
+        (starttls-extra-arguments, starttls-process-connection-type)
+        (starttls-connect, starttls-failure, starttls-success): New variables.
+        (starttls-program, starttls-extra-args): Doc fix.
+        (starttls-negotiate-gnutls, starttls-open-stream-gnutls): New funs.
+        (starttls-negotiate, starttls-open-stream): Check `starttls-use-gnutls'
+        and pass on to corresponding *-gnutls function if it is set.
+
+2004-05-27  Luc Teirlinck  <teirllm@auburn.edu>
+
+        * autorevert.el (auto-revert-handler): Disable auto-reverting of
+        remote files.
+
+2004-05-27  Michael Albinus  <michael.albinus@gmx.de>
+
+        * files.el (file-name-non-special): There are more operations
+        which need handling: `find-backup-file-name',
+        `insert-file-contents', `verify-visited-file-modtime',
+        `write-region'.  Rename t value of method to `add'.  Add new
+        methods `quote' and `unquote-then-quote' to file-arg-indices.
+
 2004-05-25  Juri Linkov  <juri@jurta.org>
 
         * info.el (Info-toc): Call Info-mode on intermediate buffer.
@@ -83,8 +195,7 @@
         * descr-text.el (describe-property-list): Add [show] button for
         `syntax-table' property with action to pp to a separate buffer.
         (describe-char): Replace search-forward by re-search-forward with
-        whitespace regexp after "character:" to not fail in too narrow
-        windows.
+        whitespace regexp after "character:" to not fail in too narrow windows.
 
         * simple.el (next-error-find-buffer): Add a rule to return
         next-error capable buffer if one window on the selected frame
@@ -96,11 +207,11 @@
         (gud-watch, gdb-send-item, gdb-breakpoints-mode, gdb-frames-mode)
         (gdb-locals-mode, gdb-send-item, gdb-toggle-breakpoint)
         (gdb-delete-breakpoint, gdb-frames-select, gdb-threads-buffer)
-        (gdb-registers-buffer, gdb-reset, gdb-assembler-buffer): Handle
-        new value for gud-minor-mode (gdbmi).
+        (gdb-registers-buffer, gdb-reset, gdb-assembler-buffer):
+        Handle new value for gud-minor-mode (gdbmi).
         (gdb-buffer-type, gdb-input-queue, gdb-prompting)
-        (gdb-output-sink, gdb-current-item, gdb-pending-triggers): Change
-        from local to global gdb variable set.
+        (gdb-output-sink, gdb-current-item, gdb-pending-triggers):
+        Change from local to global gdb variable set.
         (gdb-ann3): Initialise above gdb variable set.
         (gdb-var-update, gdb-var-update-handler, gdb-enqueue-input)
         (gdb-dequeue-input, gdb-source, gdb-pre-prompt, gdb-prompt)
@@ -185,8 +296,7 @@
 
 2004-05-21  Masatake YAMATO  <jet@gyve.org>
 
-        * progmodes/etags.el (tags-apropos, list-tags): Require
-        apropos.
+        * progmodes/etags.el (tags-apropos, list-tags): Require apropos.
         (etags-tags-completion-table): Show parsing progress.
 
 2004-05-20  Luc Teirlinck  <teirllm@auburn.edu>
diff --git a/lisp/autorevert.el b/lisp/autorevert.el
index 58bb6d29705..1ba48a54236 100644
--- a/lisp/autorevert.el
+++ b/lisp/autorevert.el
@@ -311,6 +311,7 @@ This is an internal function used by Auto-Revert Mode."
   (unless (buffer-modified-p)
     (let ((buffer (current-buffer)) revert eob eoblist)
       (or (and buffer-file-name
+               (not (file-remote-p buffer-file-name))
                (file-readable-p buffer-file-name)
                (not (verify-visited-file-modtime buffer))
                (setq revert t))
diff --git a/lisp/cus-edit.el b/lisp/cus-edit.el
index 11b91242cc2..d4b7aa6f518 100644
--- a/lisp/cus-edit.el
+++ b/lisp/cus-edit.el
@@ -1012,11 +1012,11 @@ version."
 
 ;;;###autoload
 (defun customize-face (&optional face)
-  "Customize SYMBOL, which should be a face name or nil.
-If SYMBOL is nil, customize all faces.
+  "Customize FACE, which should be a face name or nil.
+If FACE is nil, customize all faces.
 
 Interactively, when point is on text which has a face specified,
-suggest to customized that face, if it's customizable."
+suggest to customize that face, if it's customizable."
   (interactive
    (list (read-face-name "Customize face" "all faces" t)))
   (if (member face '(nil ""))
@@ -1038,10 +1038,10 @@ suggest to customized that face, if it's customizable."
 
 ;;;###autoload
 (defun customize-face-other-window (&optional face)
-  "Show customization buffer for face SYMBOL in other window.
+  "Show customization buffer for face FACE in other window.
 
 Interactively, when point is on text which has a face specified,
-suggest to customized that face, if it's customizable."
+suggest to customize that face, if it's customizable."
   (interactive
    (list (read-face-name "Customize face" "all faces" t)))
   (if (member face '(nil ""))
@@ -1093,7 +1093,7 @@ suggest to customized that face, if it's customizable."
                                 (get symbol 'standard-value))))
                   (when (and cval       ;Declared with defcustom.
                              (default-boundp symbol) ;Has a value.
-                             (not (equal (eval (car cval)) 
+                             (not (equal (eval (car cval))
                                          ;; Which does not match customize.
                                          (default-value symbol))))
                     (push (list symbol 'custom-variable) found)))))
@@ -1876,7 +1876,7 @@ and `face'."
   (custom-load-symbol (widget-value widget)))
 
 (defun custom-unloaded-symbol-p (symbol)
-  "Return non-nil if the dependencies of SYMBOL has not yet been loaded."
+  "Return non-nil if the dependencies of SYMBOL have not yet been loaded."
   (let ((found nil)
         (loads (get symbol 'custom-loads))
         load)
@@ -1894,7 +1894,7 @@ and `face'."
     found))
 
 (defun custom-unloaded-widget-p (widget)
-  "Return non-nil if the dependencies of WIDGET has not yet been loaded."
+  "Return non-nil if the dependencies of WIDGET have not yet been loaded."
   (custom-unloaded-symbol-p (widget-value widget)))
 
 (defun custom-toggle-hide (widget)
@@ -2646,7 +2646,7 @@ Also change :reverse-video to :inverse-video."
         (widget-setup)))))
 
 (defun custom-face-edit-delete (widget)
-  "Remove widget from the buffer."
+  "Remove WIDGET from the buffer."
   (let ((inactive (widget-get widget :inactive))
         (inhibit-read-only t)
         (inhibit-modification-hooks t))
diff --git a/lisp/cvs-status.el b/lisp/cvs-status.el
index 96b1f1eb066..b03182d87e4 100644
--- a/lisp/cvs-status.el
+++ b/lisp/cvs-status.el
@@ -277,10 +277,10 @@ BEWARE:  because of stability issues, this is not a symetric operation."
                (cvs-tree-merge (cdr tree1) (cdr tree2))))))
      ((> l1 l2)
       (cvs-tree-merge
-       (list (cons (cvs-tag-make (cvs-butlast vl1)) tree1)) tree2))
+       (list (cons (cvs-tag-make (butlast vl1)) tree1)) tree2))
      ((< l1 l2)
       (cvs-tree-merge
-       tree1 (list (cons (cvs-tag-make (cvs-butlast vl2)) tree2)))))))))
+       tree1 (list (cons (cvs-tag-make (butlast vl2)) tree2)))))))))
 
 (defun cvs-tag-make-tag (tag)
   (let ((vl (mapcar 'string-to-number (split-string (nth 2 tag) "\\."))))
@@ -293,7 +293,7 @@ BEWARE:  because of stability issues, this is not a symetric operation."
           (lambda (tag)
             (let ((tag (cvs-tag-make-tag tag)))
               (list (if (not (eq (cvs-tag->type tag) 'branch)) tag
-                      (list (cvs-tag-make (cvs-butlast (cvs-tag->vlist tag)))
+                      (list (cvs-tag-make (butlast (cvs-tag->vlist tag)))
                             tag)))))
           tags)))
     (while (cdr tags)
diff --git a/lisp/emacs-lisp/edebug.el b/lisp/emacs-lisp/edebug.el
index 8a924d045f7..3cebfd2435b 100644
--- a/lisp/emacs-lisp/edebug.el
+++ b/lisp/emacs-lisp/edebug.el
@@ -3692,8 +3692,7 @@ Return the result of the last expression."
   (setq edebug-previous-result
         (concat "Result: "
                 (edebug-safe-prin1-to-string edebug-previous-value)
-                (let ((name (prin1-char edebug-previous-value)))
-                  (if name (concat " = " name))))))
+                (eval-expression-print-format edebug-previous-value))))
 
 (defun edebug-previous-result ()
   "Print the previous result."
@@ -3712,7 +3711,8 @@ Print result in minibuffer."
   (princ
    (edebug-outside-excursion
     (setq values (cons (edebug-eval edebug-expr) values))
-    (edebug-safe-prin1-to-string (car values)))))
+    (concat (edebug-safe-prin1-to-string (car values))
+            (eval-expression-print-format (car values))))))
 
 (defun edebug-eval-last-sexp ()
   "Evaluate sexp before point in the outside environment; value in minibuffer."
diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index fcc6517b747..1f53d9e630f 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -239,6 +239,7 @@ All commands in `lisp-mode-shared-map' are inherited by this map.")
     (set-keymap-parent emacs-lisp-mode-map lisp-mode-shared-map)
     (define-key emacs-lisp-mode-map "\e\t" 'lisp-complete-symbol)
     (define-key emacs-lisp-mode-map "\e\C-x" 'eval-defun)
+    (define-key emacs-lisp-mode-map "\e\C-q" 'indent-pp-sexp)
     (define-key emacs-lisp-mode-map [menu-bar] (make-sparse-keymap))
     (define-key emacs-lisp-mode-map [menu-bar emacs-lisp]
       (cons "Emacs-Lisp" map))
@@ -377,6 +378,7 @@ if that value is non-nil."
   (let ((map (make-sparse-keymap)))
     (set-keymap-parent map lisp-mode-shared-map)
     (define-key map "\e\C-x" 'eval-defun)
+    (define-key map "\e\C-q" 'indent-pp-sexp)
     (define-key map "\e\t" 'lisp-complete-symbol)
     (define-key map "\n" 'eval-print-last-sexp)
     map)
@@ -532,13 +534,13 @@ With argument, print output into current buffer."
                          (prin1-to-string value)))
         (print-length eval-expression-print-length)
         (print-level eval-expression-print-level)
-        (char-string (prin1-char value))
         (beg (point))
         end)
     (prog1
         (prin1 value)
-      (if (and (eq standard-output t) char-string)
-          (princ (concat " = " char-string)))
+      (if (eq standard-output t)
+          (let ((str (eval-expression-print-format value)))
+            (if str (princ str))))
       (setq end (point))
       (when (and (bufferp standard-output)
                  (or (not (null print-length))
@@ -1092,6 +1094,19 @@ ENDPOS is encountered."
       (indent-sexp endmark)
       (set-marker endmark nil))))
 
+(defun indent-pp-sexp (&optional arg)
+  "Indent each line of the list or, with prefix ARG, pretty-printify the list."
+  (interactive "P")
+  (if arg
+      (save-excursion
+        (save-restriction
+          (narrow-to-region (point) (progn (forward-sexp 1) (point)))
+          (pp-buffer)
+          (goto-char (point-max))
+          (if (eq (char-before) ?\n)
+              (delete-char -1)))))
+  (indent-sexp))
+
 ;;;; Lisp paragraph filling commands.
 
 (defcustom emacs-lisp-docstring-fill-column 65
diff --git a/lisp/emacs-lisp/lisp.el b/lisp/emacs-lisp/lisp.el
index 53b9e7507ef..25fde86cd96 100644
--- a/lisp/emacs-lisp/lisp.el
+++ b/lisp/emacs-lisp/lisp.el
@@ -337,7 +337,15 @@ Optional ARG is ignored."
       (re-search-backward "^\n" (- (point) 1) t)
       (narrow-to-region beg end))))
 
-(defun insert-pair (arg &optional open close)
+(defvar insert-pair-alist
+  '((?\( ?\)) (?\[ ?\]) (?\{ ?\}) (?\< ?\>) (?\" ?\") (?\' ?\') (?\` ?\'))
+  "Alist of paired characters inserted by `insert-pair'.
+Each element looks like (OPEN-CHAR CLOSE-CHAR) or (COMMAND-CHAR
+OPEN-CHAR CLOSE-CHAR).  The characters OPEN-CHAR and CLOSE-CHAR
+of the pair whose key is equal to the last input character with
+or without modifiers, are inserted by `insert-pair'.")
+
+(defun insert-pair (&optional arg open close)
   "Enclose following ARG sexps in a pair of OPEN and CLOSE characters.
 Leave point after the first character.
 A negative ARG encloses the preceding ARG sexps instead.
@@ -345,32 +353,47 @@ No argument is equivalent to zero: just insert characters
 and leave point between.
 If `parens-require-spaces' is non-nil, this command also inserts a space
 before and after, depending on the surrounding characters.
-If region is active, insert enclosing characters at region boundaries."
+If region is active, insert enclosing characters at region boundaries.
+
+If arguments OPEN and CLOSE are nil, the character pair is found
+from the variable `insert-pair-alist' according to the last input
+character with or without modifiers.  If no character pair is
+found in the variable `insert-pair-alist', then the last input
+character is inserted ARG times."
   (interactive "P")
-  (if arg (setq arg (prefix-numeric-value arg))
-    (setq arg 0))
-  (or open  (setq open  ?\())
-  (or close (setq close ?\)))
-  (if (and transient-mark-mode mark-active)
-      (progn
-        (save-excursion (goto-char (region-end))       (insert close))
-        (save-excursion (goto-char (region-beginning)) (insert open)))
-    (cond ((> arg 0) (skip-chars-forward " \t"))
-          ((< arg 0) (forward-sexp arg) (setq arg (- arg))))
-    (and parens-require-spaces
-         (not (bobp))
-         (memq (char-syntax (preceding-char)) (list ?w ?_ (char-syntax close)))
-         (insert " "))
-    (insert open)
-    (save-excursion
-      (or (eq arg 0) (forward-sexp arg))
-      (insert close)
-      (and parens-require-spaces
-           (not (eobp))
-           (memq (char-syntax (following-char)) (list ?w ?_ (char-syntax open)))
-           (insert " ")))))
-
-(defun insert-parentheses (arg)
+  (if (not (and open close))
+      (let ((pair (or (assq last-command-char insert-pair-alist)
+                      (assq (event-basic-type last-command-event)
+                            insert-pair-alist))))
+        (if pair
+            (if (nth 2 pair)
+                (setq open (nth 1 pair) close (nth 2 pair))
+              (setq open (nth 0 pair) close (nth 1 pair))))))
+  (if (and open close)
+      (if (and transient-mark-mode mark-active)
+          (progn
+            (save-excursion (goto-char (region-end))       (insert close))
+            (save-excursion (goto-char (region-beginning)) (insert open)))
+        (if arg (setq arg (prefix-numeric-value arg))
+          (setq arg 0))
+        (cond ((> arg 0) (skip-chars-forward " \t"))
+              ((< arg 0) (forward-sexp arg) (setq arg (- arg))))
+        (and parens-require-spaces
+             (not (bobp))
+             (memq (char-syntax (preceding-char)) (list ?w ?_ (char-syntax close)))
+             (insert " "))
+        (insert open)
+        (save-excursion
+          (or (eq arg 0) (forward-sexp arg))
+          (insert close)
+          (and parens-require-spaces
+               (not (eobp))
+               (memq (char-syntax (following-char)) (list ?w ?_ (char-syntax open)))
+               (insert " "))))
+    (insert-char (event-basic-type last-command-event)
+                 (prefix-numeric-value arg))))
+
+(defun insert-parentheses (&optional arg)
   "Enclose following ARG sexps in parentheses.  Leave point after open-paren.
 A negative ARG encloses the preceding ARG sexps instead.
 No argument is equivalent to zero: just insert `()' and leave point between.
@@ -380,6 +403,24 @@ If region is active, insert enclosing characters at region boundaries."
   (interactive "P")
   (insert-pair arg ?\( ?\)))
 
+(defun delete-pair ()
+  "Delete a pair of characters enclosing the sexp that follows point."
+  (interactive)
+  (save-excursion (forward-sexp 1) (delete-char -1))
+  (delete-char 1))
+
+(defun raise-sexp (&optional arg)
+  "Raise ARG sexps higher up the tree."
+  (interactive "p")
+  (let ((s (if (and transient-mark-mode mark-active)
+               (buffer-substring (region-beginning) (region-end))
+             (buffer-substring
+              (point)
+              (save-excursion (forward-sexp arg) (point))))))
+    (backward-up-list 1)
+    (delete-region (point) (save-excursion (forward-sexp 1) (point)))
+    (save-excursion (insert s))))
+
 (defun move-past-close-and-reindent ()
   "Move past next `)', delete indentation before it, then indent after it."
   (interactive)
diff --git a/lisp/emacs-lisp/pp.el b/lisp/emacs-lisp/pp.el
index c93868859f0..61d31921e57 100644
--- a/lisp/emacs-lisp/pp.el
+++ b/lisp/emacs-lisp/pp.el
@@ -50,34 +50,40 @@ to make output that `read' can handle, whenever this is possible."
           (let ((print-escape-newlines pp-escape-newlines)
                 (print-quoted t))
             (prin1 object (current-buffer)))
-          (goto-char (point-min))
-          (while (not (eobp))
-            ;; (message "%06d" (- (point-max) (point)))
-            (cond
-             ((condition-case err-var
-                  (prog1 t (down-list 1))
-                (error nil))
-              (save-excursion
-                (backward-char 1)
-                (skip-chars-backward "'`#^")
-                (when (and (not (bobp)) (= ?\ (char-before)))
-                  (delete-char -1)
-                  (insert "\n"))))
-             ((condition-case err-var
-                  (prog1 t (up-list 1))
-                (error nil))
-              (while (looking-at "\\s)")
-                (forward-char 1))
-              (delete-region
-               (point)
-               (progn (skip-chars-forward " \t") (point)))
-              (insert ?\n))
-             (t (goto-char (point-max)))))
-          (goto-char (point-min))
-          (indent-sexp)
+          (pp-buffer)
           (buffer-string))
       (kill-buffer (current-buffer)))))
 
+(defun pp-buffer ()
+  "Prettify the current buffer with printed representation of a Lisp object."
+  (goto-char (point-min))
+  (while (not (eobp))
+    ;; (message "%06d" (- (point-max) (point)))
+    (cond
+     ((condition-case err-var
+          (prog1 t (down-list 1))
+        (error nil))
+      (save-excursion
+        (backward-char 1)
+        (skip-chars-backward "'`#^")
+        (when (and (not (bobp)) (memq (char-before) '(?\ ?\t ?\n)))
+          (delete-region
+           (point)
+           (progn (skip-chars-backward " \t\n") (point)))
+          (insert "\n"))))
+     ((condition-case err-var
+          (prog1 t (up-list 1))
+        (error nil))
+      (while (looking-at "\\s)")
+        (forward-char 1))
+      (delete-region
+       (point)
+       (progn (skip-chars-forward " \t\n") (point)))
+      (insert ?\n))
+     (t (goto-char (point-max)))))
+  (goto-char (point-min))
+  (indent-sexp))
+
 ;;;###autoload
 (defun pp (object &optional stream)
   "Output the pretty-printed representation of OBJECT, any Lisp object.
diff --git a/lisp/files.el b/lisp/files.el
index 06792a0d04e..27e0ded28e2 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -1365,33 +1365,35 @@ that are visiting the various files."
       (kill-local-variable 'buffer-file-coding-system)
       (kill-local-variable 'cursor-type)
       (let ((inhibit-read-only t))
-        (erase-buffer)
-        (and (default-value 'enable-multibyte-characters)
-             (not rawfile)
-             (set-buffer-multibyte t))
-        (if rawfile
-            (condition-case ()
-                (insert-file-contents-literally filename t)
-              (file-error
-               (when (and (file-exists-p filename)
-                          (not (file-readable-p filename)))
-                 (kill-buffer buf)
-                 (signal 'file-error (list "File is not readable"
-                                           filename)))
-               ;; Unconditionally set error
-               (setq error t)))
+        (erase-buffer))
+      (and (default-value 'enable-multibyte-characters)
+           (not rawfile)
+           (set-buffer-multibyte t))
+      (if rawfile
           (condition-case ()
-              (insert-file-contents filename t)
+              (let ((inhibit-read-only t))
+                (insert-file-contents-literally filename t))
             (file-error
              (when (and (file-exists-p filename)
                         (not (file-readable-p filename)))
                (kill-buffer buf)
                (signal 'file-error (list "File is not readable"
                                          filename)))
-             ;; Run find-file-not-found-hooks until one returns non-nil.
-             (or (run-hook-with-args-until-success 'find-file-not-found-functions)
-                 ;; If they fail too, set error.
-                 (setq error t))))))
+             ;; Unconditionally set error
+             (setq error t)))
+        (condition-case ()
+            (let ((inhibit-read-only t))
+              (insert-file-contents filename t))
+          (file-error
+           (when (and (file-exists-p filename)
+                      (not (file-readable-p filename)))
+             (kill-buffer buf)
+             (signal 'file-error (list "File is not readable"
+                                       filename)))
+           ;; Run find-file-not-found-hooks until one returns non-nil.
+           (or (run-hook-with-args-until-success 'find-file-not-found-functions)
+               ;; If they fail too, set error.
+               (setq error t)))))
       ;; Record the file's truename, and maybe use that as visited name.
       (if (equal filename buffer-file-name)
           (setq buffer-file-truename truename)
@@ -4481,7 +4483,7 @@ With prefix arg, silently save all file-visiting buffers, then kill."
         ;; Get a list of the indices of the args which are file names.
         (file-arg-indices
          (cdr (or (assq operation
-                        ;; The first five are special because they
+                        ;; The first six are special because they
                         ;; return a file name.  We want to include the /:
                         ;; in the return value.
                         ;; So just avoid stripping it in the first place.
@@ -4490,13 +4492,21 @@ With prefix arg, silently save all file-visiting buffers, then kill."
                           (file-name-as-directory . nil)
                           (directory-file-name . nil)
                           (file-name-sans-versions . nil)
+                          (find-backup-file-name . nil)
                           ;; `identity' means just return the first arg
                           ;; not stripped of its quoting.
                           (substitute-in-file-name identity)
+                          ;; `add' means add "/:" to the result.
+                          (file-truename add 0)
+                          ;; `quote' means add "/:" to buffer-file-name.
+                          (insert-file-contents quote 0)
+                          ;; `unquote-then-quote' means set buffer-file-name
+                          ;; temporarily to unquoted filename.
+                          (verify-visited-file-modtime unquote-then-quote)
+                          ;; List the arguments which are filenames.
                           (file-name-completion 1)
                           (file-name-all-completions 1)
-                          ;; t means add "/:" to the result.
-                          (file-truename t 0)
+                          (write-region 2 5)
                           (rename-file 0 1)
                           (copy-file 0 1)
                           (make-symbolic-link 0 1)
@@ -4522,8 +4532,17 @@ With prefix arg, silently save all file-visiting buffers, then kill."
         (setq file-arg-indices (cdr file-arg-indices))))
     (cond ((eq method 'identity)
            (car arguments))
-          (method
+          ((eq method 'add)
            (concat "/:" (apply operation arguments)))
+          ((eq method 'quote)
+           (prog1 (apply operation arguments)
+             (setq buffer-file-name (concat "/:" buffer-file-name))))
+          ((eq method 'unquote-then-quote)
+           (let (res)
+             (setq buffer-file-name (substring buffer-file-name 2))
+             (setq res (apply operation arguments))
+             (setq buffer-file-name (concat "/:" buffer-file-name))
+             res))
           (t
            (apply operation arguments)))))
 
diff --git a/lisp/gnus/starttls.el b/lisp/gnus/starttls.el
index 0fd14cead55..c172e88c515 100644
--- a/lisp/gnus/starttls.el
+++ b/lisp/gnus/starttls.el
@@ -1,10 +1,11 @@
 ;;; starttls.el --- STARTTLS functions
 
-;; Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+;; Copyright (C) 1999, 2000, 2003, 2004 Free Software Foundation, Inc.
 
 ;; Author: Daiki Ueno <ueno@unixuser.org>
+;; Author: Simon Josefsson <simon@josefsson.org>
 ;; Created: 1999/11/20
-;; Keywords: TLS, SSL, OpenSSL, mail, news
+;; Keywords: TLS, SSL, OpenSSL, GNUTLS, mail, news
 
 ;; This file is part of GNU Emacs.
 
@@ -30,6 +31,90 @@
 ;; [RFC 2595] "Using TLS with IMAP, POP3 and ACAP"
 ;;      by Chris Newman <chris.newman@innosoft.com> (1999/06)
 
+;; This file now contain a combination of the two previous
+;; implementations both called "starttls.el".  The first one is Daiki
+;; Ueno's starttls.el which uses his own "starttls" command line tool,
+;; and the second one is Simon Josefsson's starttls.el which uses
+;; "gnutls-cli" from GNUTLS.
+;;
+;; If "starttls" is available, it is prefered by the code over
+;; "gnutls-cli", for backwards compatibility.  Use
+;; `starttls-use-gnutls' to toggle between implementations if you have
+;; both tools installed.  It is recommended to use GNUTLS, though, as
+;; it performs more verification of the certificates.
+
+;; The GNUTLS support require GNUTLS 0.9.90 (released 2003-10-08) or
+;; later, from <http://www.gnu.org/software/gnutls/>, or "starttls"
+;; from <ftp://ftp.opaopa.org/pub/elisp/>.
+
+;; Usage is similar to `open-network-stream'.  For example:
+;;
+;; (when (setq tmp (starttls-open-stream
+;;                      "test" (current-buffer) "yxa.extundo.com" 25))
+;;   (accept-process-output tmp 15)
+;;   (process-send-string tmp "STARTTLS\n")
+;;   (accept-process-output tmp 15)
+;;   (message "STARTTLS output:\n%s" (starttls-negotiate tmp))
+;;   (process-send-string tmp "EHLO foo\n"))
+
+;; An example run yield the following output:
+;;
+;; 220 yxa.extundo.com ESMTP Sendmail 8.12.11/8.12.11/Debian-3; Wed, 26 May 2004 19:12:29 +0200; (No UCE/UBE) logging access from: c494102a.s-bi.bostream.se(OK)-c494102a.s-bi.bostream.se [217.215.27.65]
+;; 220 2.0.0 Ready to start TLS
+;; 250-yxa.extundo.com Hello c494102a.s-bi.bostream.se [217.215.27.65], pleased to meet you
+;; 250-ENHANCEDSTATUSCODES
+;; 250-PIPELINING
+;; 250-EXPN
+;; 250-VERB
+;; 250-8BITMIME
+;; 250-SIZE
+;; 250-DSN
+;; 250-ETRN
+;; 250-AUTH DIGEST-MD5 CRAM-MD5 PLAIN LOGIN
+;; 250-DELIVERBY
+;; 250 HELP
+;; nil
+;;
+;; With the message buffer containing:
+;;
+;; STARTTLS output:
+;; *** Starting TLS handshake
+;; - Server's trusted authorities:
+;;    [0]: C=SE,ST=Stockholm,L=Stockholm,O=YXA,OU=CA,CN=yxa.extundo.com,EMAIL=staff@yxa.extundo.com
+;; - Certificate type: X.509
+;;  - Got a certificate list of 2 certificates.
+;;
+;;  - Certificate[0] info:
+;;  # The hostname in the certificate matches 'yxa.extundo.com'.
+;;  # valid since: Wed May 26 12:16:00 CEST 2004
+;;  # expires at: Wed Jul 26 12:16:00 CEST 2023
+;;  # serial number: 04
+;;  # fingerprint: 7c 04 4b c1 fa 26 9b 5d 90 22 52 3c 65 3d 85 3a
+;;  # version: #1
+;;  # public key algorithm: RSA
+;;  #   Modulus: 1024 bits
+;;  # Subject's DN: C=SE,ST=Stockholm,L=Stockholm,O=YXA,OU=Mail server,CN=yxa.extundo.com,EMAIL=staff@yxa.extundo.com
+;;  # Issuer's DN: C=SE,ST=Stockholm,L=Stockholm,O=YXA,OU=CA,CN=yxa.extundo.com,EMAIL=staff@yxa.extundo.com
+;;
+;;  - Certificate[1] info:
+;;  # valid since: Sun May 23 11:35:00 CEST 2004
+;;  # expires at: Sun Jul 23 11:35:00 CEST 2023
+;;  # serial number: 00
+;;  # fingerprint: fc 76 d8 63 1a c9 0b 3b fa 40 fe ed 47 7a 58 ae
+;;  # version: #3
+;;  # public key algorithm: RSA
+;;  #   Modulus: 1024 bits
+;;  # Subject's DN: C=SE,ST=Stockholm,L=Stockholm,O=YXA,OU=CA,CN=yxa.extundo.com,EMAIL=staff@yxa.extundo.com
+;;  # Issuer's DN: C=SE,ST=Stockholm,L=Stockholm,O=YXA,OU=CA,CN=yxa.extundo.com,EMAIL=staff@yxa.extundo.com
+;;
+;; - Peer's certificate issuer is unknown
+;; - Peer's certificate is NOT trusted
+;; - Version: TLS 1.0
+;; - Key Exchange: RSA
+;; - Cipher: ARCFOUR 128
+;; - MAC: SHA
+;; - Compression: NULL
+
 ;;; Code:
 
 (defgroup starttls nil
@@ -37,18 +122,141 @@
   :version "21.1"
   :group 'mail)
 
+(defcustom starttls-gnutls-program "gnutls-cli"
+  "Name of GNUTLS command line tool.
+This program is used when GNUTLS is used, i.e. when
+`starttls-use-gnutls' is non-nil."
+  :type 'string
+  :group 'starttls)
+
 (defcustom starttls-program "starttls"
-  "The program to run in a subprocess to open an TLSv1 connection."
+  "The program to run in a subprocess to open an TLSv1 connection.
+This program is used when the `starttls' command is used,
+i.e. when `starttls-use-gnutls' is nil."
   :type 'string
   :group 'starttls)
 
+(defcustom starttls-use-gnutls (not (executable-find starttls-program))
+  "*Whether to use GNUTLS instead of the `starttls' command."
+  :type 'boolean
+  :group 'starttls)
+
 (defcustom starttls-extra-args nil
-  "Extra arguments to `starttls-program'."
+  "Extra arguments to `starttls-program'.
+This program is used when the `starttls' command is used,
+i.e. when `starttls-use-gnutls' is nil."
   :type '(repeat string)
   :group 'starttls)
 
+(defcustom starttls-extra-arguments nil
+  "Extra arguments to `starttls-program'.
+This program is used when GNUTLS is used, i.e. when
+`starttls-use-gnutls' is non-nil.
+
+For example, non-TLS compliant servers may require
+'(\"--protocols\" \"ssl3\").  Invoke \"gnutls-cli --help\" to
+find out which parameters are available."
+  :type '(repeat string)
+  :group 'starttls)
+
+(defcustom starttls-process-connection-type nil
+  "*Value for `process-connection-type' to use when starting STARTTLS process."
+  :type 'boolean
+  :group 'starttls)
+
+(defcustom starttls-connect "- Simple Client Mode:\n\n"
+  "*Regular expression indicating successful connection.
+The default is what GNUTLS's \"gnutls-cli\" outputs."
+  ;; GNUTLS cli.c:main() print this string when it is starting to run
+  ;; in the application read/write phase.  If the logic, or the string
+  ;; itself, is modified, this must be updated.
+  :type 'regexp
+  :group 'starttls)
+
+(defcustom starttls-failure "\\*\\*\\* Handshake has failed"
+  "*Regular expression indicating failed TLS handshake.
+The default is what GNUTLS's \"gnutls-cli\" outputs."
+  ;; GNUTLS cli.c:do_handshake() print this string on failure.  If the
+  ;; logic, or the string itself, is modified, this must be updated.
+  :type 'regexp
+  :group 'starttls)
+
+(defcustom starttls-success "- Compression: "
+  "*Regular expression indicating completed TLS handshakes.
+The default is what GNUTLS's \"gnutls-cli\" outputs."
+  ;; GNUTLS cli.c:do_handshake() calls, on success,
+  ;; common.c:print_info(), that unconditionally print this string
+  ;; last.  If that logic, or the string itself, is modified, this
+  ;; must be updated.
+  :type 'regexp
+  :group 'starttls)
+
+(defun starttls-negotiate-gnutls (process)
+  "Negotiate TLS on process opened by `open-starttls-stream'.
+This should typically only be done once.  It typically return a
+multi-line informational message with information about the
+handshake, or NIL on failure."
+  (let (buffer info old-max done-ok done-bad)
+    (if (null (setq buffer (process-buffer process)))
+        ;; XXX How to remove/extract the TLS negotiation junk?
+        (signal-process (process-id process) 'SIGALRM)
+      (with-current-buffer buffer
+        (save-excursion
+          (setq old-max (goto-char (point-max)))
+          (signal-process (process-id process) 'SIGALRM)
+          (while (and (processp process)
+                      (eq (process-status process) 'run)
+                      (save-excursion
+                        (goto-char old-max)
+                        (not (or (setq done-ok (re-search-forward
+                                                starttls-success nil t))
+                                 (setq done-bad (re-search-forward
+                                                 starttls-failure nil t))))))
+            (accept-process-output process 1 100)
+            (sit-for 0.1))
+          (setq info (buffer-substring-no-properties old-max (point-max)))
+          (delete-region old-max (point-max))
+          (if (or (and done-ok (not done-bad))
+                  ;; Prevent mitm that fake success msg after failure msg.
+                  (and done-ok done-bad (< done-ok done-bad)))
+              info
+            (message "STARTTLS negotiation failed: %s" info)
+            nil))))))
+
 (defun starttls-negotiate (process)
-  (signal-process (process-id process) 'SIGALRM))
+  (if starttls-use-gnutls
+      (starttls-negotiate-gnutls process)
+    (signal-process (process-id process) 'SIGALRM)))
+
+(defun starttls-open-stream-gnutls (name buffer host service)
+  (message "Opening STARTTLS connection to `%s'..." host)
+  (let* (done
+         (old-max (with-current-buffer buffer (point-max)))
+         (process-connection-type starttls-process-connection-type)
+         (process (apply #'start-process name buffer
+                         starttls-gnutls-program "-s" host
+                         "-p" (if (integerp service)
+                                  (int-to-string service)
+                                service)
+                         starttls-extra-arguments)))
+    (process-kill-without-query process)
+    (while (and (processp process)
+                (eq (process-status process) 'run)
+                (save-excursion
+                  (set-buffer buffer)
+                  (goto-char old-max)
+                  (not (setq done (re-search-forward
+                                   starttls-connect nil t)))))
+      (accept-process-output process 0 100)
+      (sit-for 0.1))
+    (if done
+        (with-current-buffer buffer
+          (delete-region old-max done))
+      (delete-process process)
+      (setq process nil))
+    (message "Opening STARTTLS connection to `%s'...%s"
+             host (if done "done" "failed"))
+    process))
 
 (defun starttls-open-stream (name buffer host service)
   "Open a TLS connection for a service to a host.
@@ -64,13 +272,15 @@ BUFFER is the buffer (or `buffer-name') to associate with the process.
 Third arg is name of the host to connect to, or its IP address.
 Fourth arg SERVICE is name of the service desired, or an integer
 specifying a port number to connect to."
-  (let* ((process-connection-type nil)
-         (process (apply #'start-process
-                         name buffer starttls-program
-                         host (format "%s" service)
-                         starttls-extra-args)))
-    (process-kill-without-query process)
-    process))
+  (if starttls-use-gnutls
+      (starttls-open-stream-gnutls name buffer host service)
+    (let* ((process-connection-type starttls-process-connection-type)
+           (process (apply #'start-process
+                           name buffer starttls-program
+                           host (format "%s" service)
+                           starttls-extra-args)))
+      (process-kill-without-query process)
+      process)))
 
 (provide 'starttls)
 
diff --git a/lisp/info.el b/lisp/info.el
index 84ee6ac5e79..14183383743 100644
--- a/lisp/info.el
+++ b/lisp/info.el
@@ -3871,7 +3871,8 @@ BUFFER is the buffer speedbar is requesting buttons for."
 
 (defun Info-desktop-buffer-misc-data (desktop-dirname)
   "Auxiliary information to be saved in desktop file."
-  (list Info-current-file Info-current-node))
+  (if (not (member Info-current-file '("apropos" "history" "toc")))
+      (list Info-current-file Info-current-node)))
 
 ;;;###autoload
 (defun Info-restore-desktop-buffer (desktop-buffer-file-name
@@ -3881,6 +3882,9 @@ BUFFER is the buffer speedbar is requesting buttons for."
   (let ((first (nth 0 desktop-buffer-misc))
         (second (nth 1 desktop-buffer-misc)))
   (when (and first second)
+    (when desktop-buffer-name
+      (set-buffer (get-buffer-create desktop-buffer-name))
+      (Info-mode))
     (Info-find-node first second)
     (current-buffer))))
 
diff --git a/lisp/mail/smtpmail.el b/lisp/mail/smtpmail.el
index 60831b259d8..84a61350145 100644
--- a/lisp/mail/smtpmail.el
+++ b/lisp/mail/smtpmail.el
@@ -483,7 +483,14 @@ This is relative to `smtpmail-queue-dir'.")
                           (setq cred-key (expand-file-name cred-key)))
                          (file-regular-p
                           (setq cred-cert (expand-file-name cred-cert))))
-                (list "--key-file" cred-key "--cert-file" cred-cert))))
+                (list "--key-file" cred-key "--cert-file" cred-cert)))
+             (starttls-extra-arguments
+              (when (and (stringp cred-key) (stringp cred-cert)
+                         (file-regular-p
+                          (setq cred-key (expand-file-name cred-key)))
+                         (file-regular-p
+                          (setq cred-cert (expand-file-name cred-cert))))
+                (list "--x509keyfile" cred-key "--x509certfile" cred-cert))))
         (starttls-open-stream "SMTP" process-buffer host port)))))
 
 (defun smtpmail-try-auth-methods (process supported-extensions host port)
diff --git a/lisp/mouse.el b/lisp/mouse.el
index 76098f45f1a..621b517e2fe 100644
--- a/lisp/mouse.el
+++ b/lisp/mouse.el
@@ -624,6 +624,8 @@ This should be bound to a mouse drag event."
     (mouse-set-region-1)))
 
 (defun mouse-set-region-1 ()
+  ;; Set transient-mark-mode for a little while.
+  (setq transient-mark-mode (or transient-mark-mode 'lambda))
   (setq mouse-last-region-beg (region-beginning))
   (setq mouse-last-region-end (region-end))
   (setq mouse-last-region-tick (buffer-modified-tick)))
diff --git a/lisp/pcvs-util.el b/lisp/pcvs-util.el
index 86fafea37ea..3380077c74a 100644
--- a/lisp/pcvs-util.el
+++ b/lisp/pcvs-util.el
@@ -1,6 +1,6 @@
 ;;; pcvs-util.el --- utility functions for PCL-CVS  -*- byte-compile-dynamic: t -*-
 
-;; Copyright (C) 1991,92,93,94,95,96,97,98,99,2000, 2001
+;; Copyright (C) 1991,92,93,94,95,96,97,98,99, 2000,01,04
 ;;  Free Software Foundation, Inc.
 
 ;; Author: Stefan Monnier <monnier@cs.yale.edu>
@@ -50,7 +50,6 @@
     (dolist (x xs zs)
       (unless (member x ys) (push x zs)))))
 
-
 (defun cvs-map (-cvs-map-f &rest -cvs-map-ls)
   (unless (cvs-every 'null -cvs-map-ls)
     (cons (apply -cvs-map-f (mapcar 'car -cvs-map-ls))
@@ -77,22 +76,6 @@ the other elements.  The ordering among elements is maintained."
       (if (funcall p x) (push x car) (push x cdr)))
     (cons (nreverse car) (nreverse cdr))))
 
-;; Copied from CL ;-(
-
-(defun cvs-butlast (x &optional n)
-  "Returns a copy of LIST with the last N elements removed."
-  (if (and n (<= n 0)) x
-    (cvs-nbutlast (copy-sequence x) n)))
-
-(defun cvs-nbutlast (x &optional n)
-  "Modifies LIST to remove the last N elements."
-  (let ((m (length x)))
-    (or n (setq n 1))
-    (and (< n m)
-         (progn
-           (if (> n 0) (setcdr (nthcdr (- (1- m) n) x) nil))
-           x))))
-
 ;;;
 ;;; frame, window, buffer handling
 ;;;
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index da43b7b7098..0a1ed9e7077 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -329,7 +329,7 @@ be added."
                           (list 'const (car elt)))
                         compilation-error-regexp-alist-alist))
   :link `(file-link :tag "example file"
-                    ,(concat doc-directory "compilation.txt"))
+                    ,(expand-file-name "compilation.txt" data-directory))
   :group 'compilation)
 
 (defvar compilation-directory nil
diff --git a/lisp/progmodes/flymake.el b/lisp/progmodes/flymake.el
new file mode 100644
index 00000000000..2cd62eeecee
--- /dev/null
+++ b/lisp/progmodes/flymake.el
@@ -0,0 +1,2504 @@
+;;; flymake.el -- a universal on-the-fly syntax checker
+
+;; Copyright (C) 2003 Free Software Foundation
+
+;; Author:  Pavel Kobiakov <pk_at_work@yahoo.com>
+;; Maintainer: Pavel Kobiakov <pk_at_work@yahoo.com>
+;; Version: 0.3
+;; Keywords: c languages tools
+
+;; 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:
+;;
+;; Flymake is a minor Emacs mode performing on-the-fly syntax
+;; checks using the external syntax check tool (for C/C++ this
+;; is usually the compiler)
+
+;;; Code:
+
+;;;_* Provide
+(provide 'flymake)
+
+;;;; [[ Overlay compatibility
+(autoload 'make-overlay            "overlay" "Overlay compatibility kit." t)
+(autoload 'overlayp                "overlay" "Overlay compatibility kit." t)
+(autoload 'overlays-in             "overlay" "Overlay compatibility kit." t)
+(autoload 'delete-overlay          "overlay" "Overlay compatibility kit." t)
+(autoload 'overlay-put             "overlay" "Overlay compatibility kit." t)
+(autoload 'overlay-get             "overlay" "Overlay compatibility kit." t)
+;;;; ]]
+
+;;;; [[ cross-emacs compatibility routines
+(defvar flymake-emacs
+    (cond
+        ((string-match "XEmacs" emacs-version)  'xemacs)
+        (t                                      'emacs)
+        )
+    "Currently used emacs flavor"
+)
+
+(defun flymake-makehash(&optional test)
+    (cond
+        ((equal flymake-emacs 'xemacs)  (if test (make-hash-table :test test) (make-hash-table)))
+        (t                              (makehash test))
+    )
+)
+
+(defun flymake-time-to-float(&optional tm)
+        "Convert `current-time` to a float number of seconds."
+        (multiple-value-bind (s0 s1 s2) (or tm (current-time))
+          (+ (* (float (ash 1 16)) s0) (float s1) (* 0.0000001 s2)))
+)
+(defun flymake-float-time()
+    (cond
+        ((equal flymake-emacs 'xemacs)  (flymake-time-to-float (current-time)))
+        (t                              (float-time))
+    )
+)
+
+(defun flymake-replace-regexp-in-string(regexp rep str)
+    (cond
+        ((equal flymake-emacs 'xemacs)  (replace-in-string str regexp rep))
+        (t                              (replace-regexp-in-string regexp rep str))
+        )
+)
+
+(defun flymake-split-string-remove-empty-edges(str pattern)
+    "split, then remove first and/or last in case it's empty"
+        (let* ((splitted (split-string str pattern)))
+            (if (and (> (length splitted) 0) (= 0 (length (elt splitted 0))))
+                        (setq splitted (cdr splitted))
+                )
+            (if (and (> (length splitted) 0) (= 0 (length (elt splitted (1- (length splitted))))))
+                        (setq splitted (reverse (cdr (reverse splitted))))
+                )
+                splitted
+    )
+)
+(defun flymake-split-string(str pattern)
+    (cond
+        ((equal flymake-emacs 'xemacs)  (flymake-split-string-remove-empty-edges str pattern))
+        (t                              (split-string str pattern))
+    )
+)
+
+(defun flymake-get-temp-dir()
+    (cond
+        ((equal flymake-emacs 'xemacs)  (temp-directory))
+        (t                              temporary-file-directory)
+    )
+)
+
+(defun flymake-line-beginning-position()
+    (save-excursion
+        (beginning-of-line)
+        (point)
+    )
+)
+
+(defun flymake-line-end-position()
+    (save-excursion
+        (end-of-line)
+        (point)
+    )
+)
+
+(defun flymake-popup-menu(pos menu-data)
+    (cond
+       ((equal flymake-emacs 'xemacs)
+            (let* ((x-pos       (nth 0 (nth 0 pos)))
+                   (y-pos       (nth 1 (nth 0 pos)))
+                   (fake-event-props  '(button 1 x 1 y 1)))
+                (setq fake-event-props (plist-put fake-event-props 'x x-pos))
+                (setq fake-event-props (plist-put fake-event-props 'y y-pos))
+                (popup-menu (flymake-make-xemacs-menu menu-data) (make-event 'button-press fake-event-props))
+            )
+       )
+       (t                              (x-popup-menu pos (flymake-make-emacs-menu menu-data)))
+    )
+)
+
+(defun flymake-make-emacs-menu(menu-data)
+    (let* ((menu-title     (nth 0 menu-data))
+                   (menu-items     (nth 1 menu-data))
+                   (menu-commands  nil))
+
+        (setq menu-commands (mapcar (lambda (foo)
+                                      (cons (nth 0 foo) (nth 1 foo)))
+                                    menu-items))
+                (list menu-title (cons "" menu-commands))
+    )
+)
+
+(defun flymake-nop()
+)
+
+(defun flymake-make-xemacs-menu(menu-data)
+    (let* ((menu-title     (nth 0 menu-data))
+           (menu-items     (nth 1 menu-data))
+           (menu-commands  nil))
+        (setq menu-commands (mapcar (lambda (foo)
+                                      (vector (nth 0 foo) (or (nth 1 foo) '(flymake-nop)) t))
+                                    menu-items))
+        (cons menu-title menu-commands)
+    )
+)
+
+(defun flymake-xemacs-window-edges(&optional window)
+    (let ((edges  (window-pixel-edges window))
+          tmp)
+        (setq tmp edges)
+        (setcar tmp (/ (car tmp) (face-width 'default)))
+        (setq tmp (cdr tmp))
+        (setcar tmp (/ (car tmp) (face-height 'default)))
+        (setq tmp (cdr tmp))
+        (setcar tmp (/ (car tmp) (face-width 'default)))
+        (setq tmp (cdr tmp))
+        (setcar tmp (/ (car tmp) (face-height 'default)))
+        edges
+    )
+)
+
+(defun flymake-current-row()
+    "return current row in current frame"
+    (cond
+       ((equal flymake-emacs 'xemacs)  (count-lines (window-start) (point)))
+       (t                              (+ (car (cdr (window-edges))) (count-lines (window-start) (point))))
+    )
+)
+
+(defun flymake-selected-frame()
+    (cond
+       ((equal flymake-emacs 'xemacs)  (selected-window))
+       (t                              (selected-frame))
+    )
+)
+
+;;;; ]]
+
+(defcustom flymake-log-level -1
+    "Logging level, only messages with level > flymake-log-level will not be logged
+-1 = NONE, 0 = ERROR, 1 = WARNING, 2 = INFO, 3 = DEBUG"
+    :group 'flymake
+    :type 'integer
+)
+
+(defun flymake-log(level text &rest args)
+    "Log a message with optional arguments"
+    (if (<= level flymake-log-level)
+        (let* ((msg (apply 'format text args)))
+            (message msg)
+            ;(with-temp-buffer
+            ;    (insert msg)
+            ;   (insert "\n")
+            ;   (flymake-save-buffer-in-file (current-buffer) "d:/flymake.log" t)  ; make log file name customizable
+            ;)
+        )
+    )
+)
+
+(defun flymake-ins-after(list pos val)
+    "insert val into list after position pos"
+    (let ((tmp (copy-sequence list))) ; (???)
+        (setcdr (nthcdr pos tmp) (cons val (nthcdr (1+ pos) tmp)))
+        tmp
+    )
+)
+
+(defun flymake-set-at(list pos val)
+    "set val at position pos in list"
+    (let ((tmp (copy-sequence list))) ; (???)
+        (setcar (nthcdr pos tmp) val)
+        tmp
+    )
+)
+
+(defvar flymake-pid-to-names(flymake-makehash)
+    "pid -> source buffer name, output file name mapping"
+)
+
+(defun flymake-reg-names(pid source-buffer-name)
+    "Save into in pid map"
+    (unless (stringp source-buffer-name)
+        (error "invalid buffer name")
+    )
+    (puthash pid (list source-buffer-name) flymake-pid-to-names)
+)
+
+(defun flymake-get-source-buffer-name(pid)
+    "Return buffer name stored in pid map"
+    (nth 0 (gethash pid flymake-pid-to-names))
+)
+
+(defun flymake-unreg-names(pid)
+    "Delete pid->buffer name mapping"
+    (remhash pid flymake-pid-to-names)
+)
+
+(defun flymake-get-buffer-var(buffer var-name)
+    "switch to buffer if necessary and return local variable var"
+    (unless (bufferp buffer)
+        (error "invalid buffer")
+    )
+
+    (if (eq buffer (current-buffer))
+        (symbol-value var-name)
+    ;else
+        (save-excursion
+            (set-buffer buffer)
+            (symbol-value var-name)
+        )
+    )
+)
+
+(defun flymake-set-buffer-var(buffer var-name var-value)
+    "switch to buffer if necessary and set local variable var-name to var-value"
+    (unless (bufferp buffer)
+        (error "invalid buffer")
+    )
+
+    (if (eq buffer (current-buffer))
+        (set var-name var-value)
+    ;else
+        (save-excursion
+            (set-buffer buffer)
+            (set var-name var-value)
+        )
+    )
+)
+
+(defvar flymake-buffer-data(flymake-makehash)
+    "data specific to syntax check tool, in name-value pairs"
+)
+(make-variable-buffer-local 'flymake-buffer-data)
+(defun flymake-get-buffer-data(buffer)
+    (flymake-get-buffer-var buffer 'flymake-buffer-data)
+)
+(defun flymake-set-buffer-data(buffer data)
+    (flymake-set-buffer-var buffer 'flymake-buffer-data data)
+)
+(defun flymake-get-buffer-value(buffer name)
+    (gethash name (flymake-get-buffer-data buffer))
+)
+(defun flymake-set-buffer-value(buffer name value)
+    (puthash name value (flymake-get-buffer-data buffer))
+)
+
+(defvar flymake-output-residual nil
+  ""
+)
+(make-variable-buffer-local 'flymake-output-residual)
+(defun flymake-get-buffer-output-residual(buffer)
+    (flymake-get-buffer-var buffer 'flymake-output-residual)
+)
+(defun flymake-set-buffer-output-residual(buffer residual)
+    (flymake-set-buffer-var buffer 'flymake-output-residual residual)
+)
+
+(defcustom flymake-allowed-file-name-masks '((".+\\.c$" flymake-simple-make-init flymake-simple-cleanup flymake-get-real-file-name)
+                                             (".+\\.cpp$" flymake-simple-make-init flymake-simple-cleanup flymake-get-real-file-name)
+                                             (".+\\.xml$" flymake-xml-init flymake-simple-cleanup flymake-get-real-file-name)
+                                             (".+\\.html?$" flymake-xml-init flymake-simple-cleanup flymake-get-real-file-name)
+                                             (".+\\.cs$" flymake-simple-make-init flymake-simple-cleanup flymake-get-real-file-name)
+                                             (".+\\.pl$" flymake-perl-init flymake-simple-cleanup flymake-get-real-file-name)
+                                             (".+\\.h$" flymake-master-make-header-init flymake-master-cleanup flymake-get-real-file-name)
+                                             (".+\\.java$" flymake-simple-make-java-init flymake-simple-java-cleanup flymake-get-real-file-name)
+                                             (".+[0-9]+\\.tex$" flymake-master-tex-init flymake-master-cleanup flymake-get-real-file-name)
+                                             (".+\\.tex$" flymake-simple-tex-init flymake-simple-cleanup flymake-get-real-file-name)
+                                             (".+\\.idl$" flymake-simple-make-init flymake-simple-cleanup flymake-get-real-file-name)
+;                                            (".+\\.cpp$" 1)
+;                                            (".+\\.java$" 3)
+;                                            (".+\\.h$" 2 (".+\\.cpp$" ".+\\.c$")
+;                                                ("[ \t]*#[ \t]*include[ \t]*\"\\([\w0-9/\\_\.]*[/\\]*\\)\\(%s\\)\"" 1 2))
+;                                            (".+\\.idl$" 1)
+;                                            (".+\\.odl$" 1)
+;                                            (".+[0-9]+\\.tex$" 2 (".+\\.tex$")
+;                                                ("[ \t]*\\input[ \t]*{\\(.*\\)\\(%s\\)}" 1 2 ))
+;                                            (".+\\.tex$" 1)
+                                             )
+    "*Files syntax checking is allowed for"
+    :group 'flymake
+    :type '(repeat (string symbol symbol symbol))
+)
+
+(defun flymake-get-file-name-mode-and-masks(file-name)
+    "return the corresponding entry from flymake-allowed-file-name-masks"
+    (unless (stringp file-name)
+        (error "invalid file-name")
+    )
+    (let ((count           (length flymake-allowed-file-name-masks))
+          (idx             0)
+          (mode-and-masks  nil))
+        (while (and (not mode-and-masks) (< idx count))
+            (if (string-match (nth 0 (nth idx flymake-allowed-file-name-masks)) file-name)
+                (setq mode-and-masks (cdr (nth idx flymake-allowed-file-name-masks)))
+            )
+            (setq idx (1+ idx))
+        )
+        (flymake-log 3 "file %s, init=%s" file-name (car mode-and-masks))
+        mode-and-masks
+    )
+)
+
+(defun flymake-can-syntax-check-file(file-name)
+    "Determine whether we can syntax check file-name: nil if cannot, non-nil if can"
+    (if (flymake-get-init-function file-name)
+        t
+    ;else
+        nil
+    )
+)
+
+(defun flymake-get-init-function(file-name)
+    "return init function to be used for the file"
+    (let* ((init-f  (nth 0 (flymake-get-file-name-mode-and-masks file-name))))
+        ;(flymake-log 0 "calling %s" init-f)
+        ;(funcall init-f (current-buffer))
+    )
+    (nth 0 (flymake-get-file-name-mode-and-masks file-name))
+)
+
+(defun flymake-get-cleanup-function(file-name)
+    "return cleanup function to be used for the file"
+    (nth 1 (flymake-get-file-name-mode-and-masks file-name))
+)
+
+(defun flymake-get-real-file-name-function(file-name)
+    ""
+    (or (nth 2 (flymake-get-file-name-mode-and-masks file-name)) 'flymake-get-real-file-name)
+)
+
+(defcustom flymake-buildfile-dirs '("." ".." "../.." "../../.." "../../../.." "../../../../.." "../../../../../.." "../../../../../../.." "../../../../../../../.." "../../../../../../../../.." "../../../../../../../../../.." "../../../../../../../../../../..")
+    "dirs to look for buildfile"
+    :group 'flymake
+    :type '(repeat (string))
+)
+
+(defvar flymake-find-buildfile-cache (flymake-makehash 'equal))
+(defun flymake-get-buildfile-from-cache(dir-name)
+    (gethash dir-name flymake-find-buildfile-cache)
+)
+(defun flymake-add-buildfile-to-cache(dir-name buildfile)
+    (puthash dir-name buildfile flymake-find-buildfile-cache)
+)
+(defun flymake-clear-buildfile-cache()
+    (clrhash flymake-find-buildfile-cache)
+)
+
+(defun flymake-find-buildfile(buildfile-name source-dir-name dirs)
+    "find buildfile (i.e. Makefile, build.xml, etc.) starting from current directory. Return its path or nil if not found"
+    (if (flymake-get-buildfile-from-cache source-dir-name)
+        (progn
+            (flymake-get-buildfile-from-cache source-dir-name)
+        )
+    ;else
+        (let* ((buildfile-dir          nil)
+               (buildfile              nil)
+               (dir-count              (length dirs))
+               (dir-idx                0)
+               (found                  nil))
+
+            (while (and (not found) (< dir-idx dir-count))
+
+                (setq buildfile-dir (concat source-dir-name (nth dir-idx dirs)))
+                (setq buildfile (concat buildfile-dir "/" buildfile-name))
+
+                (when (file-exists-p buildfile)
+                    (setq found t)
+                )
+
+                (setq dir-idx (1+ dir-idx))
+            )
+            (if found
+                (progn
+                    (flymake-log 3 "found buildfile at %s/%s" buildfile-dir buildfile-name)
+                    (flymake-add-buildfile-to-cache source-dir-name buildfile-dir)
+                    buildfile-dir
+                )
+            ;else
+                (progn
+                    (flymake-log 3 "buildfile for %s not found" source-dir-name)
+                    nil
+                )
+            )
+        )
+    )
+)
+
+(defun flymake-fix-path-name(name)
+    "replace all occurences of '\' with '/'"
+    (when name
+        (let* ((new-name (flymake-replace-regexp-in-string "[\\]" "/" (expand-file-name name)))
+               (last-char (elt new-name (1- (length new-name)))))
+            (setq new-name (flymake-replace-regexp-in-string "\\./" "" new-name))
+            (if (equal "/" (char-to-string last-char))
+                (setq new-name (substring new-name 0 (1- (length new-name))))
+            )
+            new-name
+        )
+    )
+)
+
+(defun flymake-same-files(file-name-one file-name-two)
+    "t if file-name-one and file-name-two actually point to the same file"
+    (equal (flymake-fix-path-name file-name-one) (flymake-fix-path-name file-name-two))
+)
+
+(defun flymake-ensure-ends-with-slash(path)
+    (if (not (= (elt path (1- (length path))) (string-to-char "/")))
+        (concat path "/")
+    ;else
+        path
+    )
+)
+
+(defun flymake-get-common-path-prefix(string-one string-two)
+    "return common prefix for two paths"
+    (when (and string-one string-two)
+        (let* ((slash-pos-one  -1)
+               (slash-pos-two  -1)
+               (done           nil)
+               (prefix         nil))
+
+            (setq string-one (flymake-ensure-ends-with-slash string-one))
+            (setq string-two (flymake-ensure-ends-with-slash string-two))
+
+            (while (not done)
+                (setq slash-pos-one (string-match "/" string-one (1+ slash-pos-one)))
+                (setq slash-pos-two (string-match "/" string-two (1+ slash-pos-two)))
+
+                (if (and slash-pos-one slash-pos-two
+                         (= slash-pos-one slash-pos-two)
+                         (string= (substring string-one 0 slash-pos-one) (substring string-two 0 slash-pos-two)))
+                    (progn
+                        (setq prefix (substring string-one 0 (1+ slash-pos-one)))
+                    )
+                ;else
+                    (setq done t)
+                )
+            )
+            prefix
+        )
+    )
+)
+
+(defun flymake-build-relative-path(from-dir to-dir)
+    "return rel: from-dir/rel == to-dir"
+    (if (not (equal (elt from-dir 0) (elt to-dir 0)))
+        (error "first chars in paths %s, %s must be equal (same drive)" from-dir to-dir)
+    ;else
+        (let* ((from        (flymake-ensure-ends-with-slash (flymake-fix-path-name from-dir)))
+               (to          (flymake-ensure-ends-with-slash (flymake-fix-path-name to-dir)))
+               (prefix      (flymake-get-common-path-prefix from to))
+               (from-suffix (substring from (length prefix)))
+               (up-count    (length (flymake-split-string from-suffix "[/]")))
+               (to-suffix   (substring to   (length prefix)))
+               (idx         0)
+               (rel         nil))
+
+                    (if (and (> (length to-suffix) 0) (equal "/" (char-to-string (elt to-suffix 0))))
+                (setq to-suffix (substring to-suffix 1))
+            )
+
+            (while (< idx up-count)
+                (if (> (length rel) 0)
+                    (setq rel (concat rel "/"))
+                )
+                (setq rel (concat rel ".."))
+                (setq idx (1+ idx))
+            )
+            (if (> (length rel) 0)
+                (setq rel (concat rel "/"))
+            )
+            (if (> (length to-suffix) 0)
+               (setq rel (concat rel to-suffix))
+            )
+
+            (or rel "./")
+        )
+    )
+)
+
+(defcustom flymake-master-file-dirs '("." "./src" "./UnitTest")
+    "dirs where to llok for master files"
+    :group 'flymake
+    :type '(repeat (string))
+)
+
+(defcustom flymake-master-file-count-limit 32
+    "max number of master files to check"
+    :group 'flymake
+    :type 'integer
+)
+
+(defun flymake-find-possible-master-files(file-name master-file-dirs masks)
+    "find (by name and location) all posible master files, which are .cpp and .c for and .h.
+Files are searched for starting from the .h directory and max max-level parent dirs.
+File contents are not checked."
+    (let* ((dir-idx    0)
+          (dir-count  (length master-file-dirs))
+          (files  nil)
+          (done   nil)
+          (masks-count (length masks)))
+
+        (while (and (not done) (< dir-idx dir-count))
+            (let* ((dir (concat (flymake-fix-path-name (file-name-directory file-name)) "/" (nth dir-idx master-file-dirs)))
+                   (masks-idx 0))
+                (while (and (file-exists-p dir) (not done) (< masks-idx masks-count))
+                    (let* ((mask        (nth masks-idx masks))
+                           (dir-files   (directory-files dir t mask))
+                           (file-count  (length dir-files))
+                           (file-idx    0))
+
+                        (flymake-log 3 "dir %s, %d file(s) for mask %s" dir file-count mask)
+                        (while (and (not done) (< file-idx file-count))
+                            (when (not (file-directory-p (nth file-idx dir-files)))
+                                (setq files (cons (nth file-idx dir-files) files))
+                                (when (>= (length files) flymake-master-file-count-limit)
+                                    (flymake-log 3 "master file count limit (%d) reached" flymake-master-file-count-limit)
+                                    (setq done t)
+                                )
+                            )
+                            (setq file-idx (1+ file-idx))
+                        )
+                    )
+                    (setq masks-idx (1+ masks-idx))
+                )
+            )
+            (setq dir-idx (1+ dir-idx))
+        )
+        (when files
+            (setq flymake-included-file-name (file-name-nondirectory file-name))
+            (setq files (sort files 'flymake-master-file-compare))
+            (setq flymake-included-file-name nil)
+        )
+        (flymake-log 3 "found %d possible master file(s)" (length files))
+        files
+    )
+)
+
+(defvar flymake-included-file-name nil ; this is used to pass a parameter to a sort predicate below
+    ""
+)
+
+(defun flymake-master-file-compare(file-one file-two)
+    "used in sort to move most possible file names to the beginning of the list (File.h -> File.cpp moved to top"
+    (and (equal (file-name-sans-extension flymake-included-file-name)
+                (file-name-sans-extension (file-name-nondirectory file-one)))
+         (not (equal file-one file-two))
+    )
+)
+
+(defcustom flymake-check-file-limit 8192
+    "max number of chars to look at when checking possible master file"
+    :group 'flymake
+    :type 'integer
+)
+
+(defun flymake-check-patch-master-file-buffer(master-file-temp-buffer
+                                            master-file-name patched-master-file-name
+                                            source-file-name patched-source-file-name
+                                            include-dirs regexp-list)
+    "check whether master-file-name is indeed a master file for source-file-name.
+For .cpp master file this means it includes source-file-name (.h).
+If yes, patch a copy of master-file-name to include patched-source-file-name instead of source-file-name.
+Whenether a buffer for master-file-name exists, use it as a source instead of reading master file from disk"
+    (let* ((found                     nil)
+           (regexp                    (format (nth 0 regexp-list) ; "[ \t]*#[ \t]*include[ \t]*\"\\([\w0-9/\\_\.]*[/\\]*\\)\\(%s\\)\""
+                                              (file-name-nondirectory source-file-name)))
+           (path-idx                  (nth 1 regexp-list))
+           (name-idx                  (nth 2 regexp-list))
+           (inc-path                  nil)
+           (inc-name                  nil)
+           (search-limit              flymake-check-file-limit))
+        (save-excursion
+            (unwind-protect
+                (progn
+                    (set-buffer master-file-temp-buffer)
+                    (when (> search-limit (point-max))
+                        (setq search-limit (point-max))
+                    )
+                    (flymake-log 3 "checking %s against regexp %s" master-file-name regexp)
+                    (goto-char (point-min))
+                    (while (and (< (point) search-limit) (re-search-forward regexp search-limit t))
+                                                (let* ((match-beg   (match-beginning name-idx))
+                                                           (match-end   (match-end name-idx)))
+
+                                                        (flymake-log 3 "found possible match for %s" (file-name-nondirectory source-file-name))
+                                                        (setq inc-path (match-string path-idx))
+                                                        (setq inc-name (match-string name-idx))
+                                                        (when (string= inc-name (file-name-nondirectory source-file-name))
+                                                                (flymake-log 3 "inc-path=%s inc-name=%s" inc-path inc-name)
+                                                                (when (flymake-check-include source-file-name inc-path inc-name include-dirs)
+                                                                        (setq found t)
+                                                                        ; replace-match is not used here as it fails in xemacs with
+                                                                        ; 'last match not a buffer' error as check-includes calls replace-in-string
+                                                                        (flymake-replace-region (current-buffer) match-beg match-end
+                                                                                                                        (file-name-nondirectory patched-source-file-name))
+                                                                )
+                                                        )
+                                                        (forward-line 1)
+                                                )
+                    )
+                    (when found
+                        (flymake-save-buffer-in-file (current-buffer) patched-master-file-name)
+                    )
+                )
+                ;+(flymake-log 3 "killing buffer %s" (buffer-name master-file-temp-buffer))
+                (kill-buffer master-file-temp-buffer)
+            )
+        )
+        ;+(flymake-log 3 "check-patch master file %s: %s" master-file-name found)
+        (when found
+            (flymake-log 2 "found master file %s" master-file-name)
+        )
+        found
+    )
+)
+
+(defun flymake-replace-region(buffer beg end rep)
+    "replace text in buffer in region (beg; end) with rep"
+    (save-excursion
+        (delete-region beg end)
+            (goto-char beg)
+        (insert rep)
+        )
+)
+
+(defun flymake-read-file-to-temp-buffer(file-name)
+    "isert contents of file-name into newly created temp buffer"
+    (let* ((temp-buffer (get-buffer-create (generate-new-buffer-name (concat "flymake:" (file-name-nondirectory file-name))))))
+        (save-excursion
+            (set-buffer temp-buffer)
+            (insert-file-contents file-name)
+        )
+        temp-buffer
+    )
+)
+
+(defun flymake-copy-buffer-to-temp-buffer(buffer)
+    "copy contents of buffer into newly created temp buffer"
+    (let ((contents     nil)
+          (temp-buffer  nil))
+        (save-excursion
+            (set-buffer buffer)
+            (setq contents (buffer-string))
+
+            (setq temp-buffer (get-buffer-create (generate-new-buffer-name (concat "flymake:" (buffer-name buffer)))))
+            (set-buffer temp-buffer)
+            (insert contents)
+        )
+        temp-buffer
+    )
+)
+
+(defun flymake-check-include(source-file-name inc-path inc-name include-dirs)
+    "t if source-file-name is the one found via include dirs using inc-path and inc-name"
+    (if (file-name-absolute-p inc-path)
+        (flymake-same-files source-file-name (concat inc-path "/" inc-name))
+    ;else
+        (let* ((count      (length include-dirs))
+               (idx        0)
+               (file-name  nil)
+               (found      nil))
+            (while (and (not found) (< idx count))
+                (setq file-name (concat (file-name-directory source-file-name) "/" (nth idx include-dirs)))
+                (if (> (length inc-path) 0)
+                    (setq file-name (concat file-name "/" inc-path))
+                )
+                (setq file-name (concat file-name "/" inc-name))
+                (when (flymake-same-files source-file-name file-name)
+                    (setq found t)
+                )
+                (setq idx (1+ idx))
+            )
+            found
+        )
+    )
+)
+
+(defun flymake-find-buffer-for-file(file-name)
+    "buffer if there exists a buffer visiting file-name, nil otherwise"
+    (let ((buffer-name (get-file-buffer file-name)))
+        (if buffer-name
+            (get-buffer buffer-name)
+        )
+    )
+)
+
+(defun flymake-create-master-file(source-file-name patched-source-file-name get-incl-dirs-f create-temp-f masks include-regexp-list)
+    "save source-file-name with a different name, find master file, patch it and save it to."
+    (let* ((possible-master-files     (flymake-find-possible-master-files source-file-name flymake-master-file-dirs masks))
+           (master-file-count         (length possible-master-files))
+           (idx                       0)
+           (temp-buffer               nil)
+           (master-file-name          nil)
+           (patched-master-file-name  nil)
+           (found                     nil))
+
+        (while (and (not found) (< idx master-file-count))
+            (setq master-file-name (nth idx possible-master-files))
+            (setq patched-master-file-name (funcall create-temp-f master-file-name "flymake_master"))
+            (if (flymake-find-buffer-for-file master-file-name)
+                (setq temp-buffer (flymake-copy-buffer-to-temp-buffer (flymake-find-buffer-for-file master-file-name)))
+            ;else
+                (setq temp-buffer (flymake-read-file-to-temp-buffer master-file-name))
+            )
+            (setq found
+                  (flymake-check-patch-master-file-buffer
+                       temp-buffer
+                       master-file-name
+                       patched-master-file-name
+                       source-file-name
+                       patched-source-file-name
+                       (funcall get-incl-dirs-f (file-name-directory master-file-name))
+                       include-regexp-list))
+            (setq idx (1+ idx))
+        )
+        (if found
+            (list master-file-name patched-master-file-name)
+        ;else
+            (progn
+                (flymake-log 3 "none of %d master file(s) checked includes %s" master-file-count
+                           (file-name-nondirectory source-file-name))
+                nil
+            )
+        )
+    )
+)
+
+(defun flymake-save-buffer-in-file(buffer file-name)
+    (or buffer
+        (error "invalid buffer")
+    )
+    (save-excursion
+        (save-restriction
+            (set-buffer buffer)
+            (widen)
+            (make-directory (file-name-directory file-name) 1)
+            (write-region (point-min) (point-max) file-name nil 566)
+        )
+    )
+    (flymake-log 3 "saved buffer %s in file %s" (buffer-name buffer) file-name)
+)
+
+(defun flymake-save-string-to-file(file-name data)
+    "save string data to file file-name"
+    (write-region data nil file-name nil 566)
+)
+
+(defun flymake-read-file-to-string(file-name)
+    "read file contents and return them as a string"
+    (with-temp-buffer
+        (insert-file-contents file-name)
+        (buffer-substring (point-min) (point-max))
+    )
+)
+
+(defun flymake-process-filter(process output)
+    "flymake process filter: parse output, highlight err lines"
+    (let* ((pid               (process-id process))
+           (source-buffer     (get-buffer (flymake-get-source-buffer-name pid))))
+
+        (flymake-log 3 "received %d byte(s) of output from process %d" (length output) pid)
+        (when source-buffer
+            (flymake-parse-output-and-residual source-buffer output)
+        )
+    )
+)
+
+(defun flymake-process-sentinel(process event)
+   "Sentinel for syntax check buffers"
+   (if (memq (process-status process) '(signal exit))
+       (let*((exit-status       (process-exit-status process))
+             (command           (process-command process))
+             (pid               (process-id process))
+             (source-buffer     (get-buffer (flymake-get-source-buffer-name pid)))
+             (cleanup-f         (flymake-get-cleanup-function (buffer-file-name source-buffer))))
+
+         (flymake-log 2 "process %d exited with code %d" pid exit-status)
+         (condition-case err
+             (progn
+                 (flymake-log 3 "cleaning up using %s" cleanup-f)
+                 (funcall cleanup-f source-buffer)
+
+                 (flymake-unreg-names pid)
+                 (delete-process process)
+
+                 (when source-buffer
+                     (save-excursion
+                         (set-buffer source-buffer)
+
+                         (flymake-parse-residual source-buffer)
+                         (flymake-post-syntax-check source-buffer)
+                         (flymake-set-buffer-is-running source-buffer nil)
+                   )
+                )
+            )
+           (error
+              (let ((err-str (format "Error in process sentinel for buffer %s: %s"
+                                    source-buffer (error-message-string err))))
+                  (flymake-log 0 err-str)
+                  (flymake-set-buffer-is-running source-buffer nil)
+               )
+           )
+         )
+      )
+   )
+)
+
+(defun flymake-post-syntax-check(source-buffer)
+    ""
+   (flymake-set-buffer-err-info source-buffer (flymake-get-buffer-new-err-info source-buffer))
+   (flymake-set-buffer-new-err-info source-buffer nil)
+
+   (flymake-set-buffer-err-info source-buffer (flymake-fix-line-numbers
+                                             (flymake-get-buffer-err-info source-buffer)
+                                             1
+                                             (flymake-count-lines source-buffer)))
+   (flymake-delete-own-overlays source-buffer)
+   (flymake-highlight-err-lines source-buffer (flymake-get-buffer-err-info source-buffer))
+
+   (let ((err-count   (flymake-get-err-count (flymake-get-buffer-err-info source-buffer) "e"))
+         (warn-count  (flymake-get-err-count (flymake-get-buffer-err-info source-buffer) "w")))
+
+       (flymake-log 2 "%s: %d error(s), %d warning(s) in %.2f second(s)"
+                  (buffer-name source-buffer) err-count warn-count
+                  (- (flymake-float-time) (flymake-get-buffer-check-start-time source-buffer)))
+       (flymake-set-buffer-check-start-time source-buffer nil)
+       (if (and (equal 0 err-count) (equal 0 warn-count))
+           (if (equal 0 exit-status)
+               (flymake-report-status source-buffer "" "") ; PASSED
+           ;else
+               (if (not (flymake-get-buffer-check-was-interrupted source-buffer))
+                   (flymake-report-fatal-status (current-buffer) "CFGERR"
+                       (format "Configuration error has occured while running %s" command))
+               ;else
+                   (flymake-report-status source-buffer nil "") ; "STOPPED"
+               )
+           )
+       ;else
+           (flymake-report-status source-buffer (format "%d/%d" err-count warn-count) "")
+       )
+   )
+)
+
+(defun flymake-parse-output-and-residual(source-buffer output)
+    "split output into lines, merge in residual if necessary"
+    (save-excursion
+        (set-buffer source-buffer)
+        (let* ((buffer-residual     (flymake-get-buffer-output-residual source-buffer))
+               (total-output        (if buffer-residual (concat buffer-residual output) output))
+               (lines-and-residual  (flymake-split-output total-output))
+               (lines               (nth 0 lines-and-residual))
+               (new-residual        (nth 1 lines-and-residual)))
+
+            (flymake-set-buffer-output-residual source-buffer new-residual)
+            (flymake-set-buffer-new-err-info source-buffer (flymake-parse-err-lines
+                                                            (flymake-get-buffer-new-err-info source-buffer)
+                                                            source-buffer lines))
+        )
+    )
+)
+
+(defun flymake-parse-residual(source-buffer)
+    "parse residual if it's non empty"
+    (save-excursion
+        (set-buffer source-buffer)
+        (when (flymake-get-buffer-output-residual source-buffer)
+            (flymake-set-buffer-new-err-info source-buffer (flymake-parse-err-lines
+                                                           (flymake-get-buffer-new-err-info source-buffer)
+                                                           source-buffer
+                                                           (list (flymake-get-buffer-output-residual source-buffer))))
+            (flymake-set-buffer-output-residual source-buffer nil)
+        )
+    )
+)
+
+(defvar flymake-err-info nil
+    "sorted list of line numbers and lists of err info in the form (file, err-text)."
+)
+(make-variable-buffer-local 'flymake-err-info)
+(defun flymake-get-buffer-err-info(buffer)
+    (flymake-get-buffer-var buffer 'flymake-err-info)
+)
+(defun flymake-set-buffer-err-info(buffer err-info)
+    (flymake-set-buffer-var buffer 'flymake-err-info err-info)
+)
+(defun flymake-er-make-er(line-no line-err-info-list)
+    (list line-no line-err-info-list)
+)
+(defun flymake-er-get-line(err-info)
+    (nth 0 err-info)
+)
+(defun flymake-er-get-line-err-info-list(err-info)
+    (nth 1 err-info)
+)
+
+(defvar flymake-new-err-info nil
+    "the same as flymake -err-info, effective when a syntax check is in progress"
+)
+(make-variable-buffer-local 'flymake-new-err-info)
+(defun flymake-get-buffer-new-err-info(buffer)
+    (flymake-get-buffer-var buffer 'flymake-new-err-info)
+)
+(defun flymake-set-buffer-new-err-info(buffer new-err-info)
+    (flymake-set-buffer-var buffer 'flymake-new-err-info new-err-info)
+)
+
+;; getters/setters for line-err-info: (file, line, type, text).
+(defun flymake-ler-make-ler(file line type text &optional full-file)
+    (list file line type text full-file)
+)
+(defun flymake-ler-get-file(line-err-info)
+    (nth 0 line-err-info)
+)
+(defun flymake-ler-get-line(line-err-info)
+    (nth 1 line-err-info)
+)
+(defun flymake-ler-get-type(line-err-info)
+    (nth 2 line-err-info)
+)
+(defun flymake-ler-get-text(line-err-info)
+    (nth 3 line-err-info)
+)
+(defun flymake-ler-get-full-file(line-err-info)
+    (nth 4 line-err-info)
+)
+(defun flymake-ler-set-file(line-err-info file)
+    (flymake-ler-make-ler file
+                        (flymake-ler-get-line line-err-info)
+                        (flymake-ler-get-type line-err-info)
+                        (flymake-ler-get-text line-err-info)
+                        (flymake-ler-get-full-file line-err-info))
+)
+(defun flymake-ler-set-full-file(line-err-info full-file)
+    (flymake-ler-make-ler (flymake-ler-get-file line-err-info)
+                        (flymake-ler-get-line line-err-info)
+                        (flymake-ler-get-type line-err-info)
+                        (flymake-ler-get-text line-err-info)
+                        full-file)
+)
+(defun flymake-ler-set-line(line-err-info line)
+    (flymake-ler-make-ler (flymake-ler-get-file line-err-info)
+                        line
+                        (flymake-ler-get-type line-err-info)
+                        (flymake-ler-get-text line-err-info)
+                        (flymake-ler-get-full-file line-err-info))
+)
+
+(defun flymake-get-line-err-count(line-err-info-list type)
+    "return number of errors of specified type - e or w"
+    (let* ((idx        0)
+           (count      (length line-err-info-list))
+           (err-count  0))
+
+        (while (< idx count)
+            (when (equal type (flymake-ler-get-type (nth idx line-err-info-list)))
+                (setq err-count (1+ err-count))
+            )
+            (setq idx (1+ idx))
+        )
+        err-count
+    )
+)
+
+(defun flymake-get-err-count(err-info-list type)
+    "return number of errors of specified type for the err-info-list"
+    (let* ((idx        0)
+           (count      (length err-info-list))
+           (err-count  0))
+        (while (< idx count)
+            (setq err-count (+ err-count (flymake-get-line-err-count (nth 1 (nth idx err-info-list)) type)))
+            (setq idx (1+ idx))
+        )
+        err-count
+    )
+)
+
+(defun flymake-fix-line-numbers(err-info-list min-line max-line)
+    "replace line-numbers < min-line with min-line and > max-line with max-line - as some compilers might report line number outside the file being compiled"
+    (let* ((count     (length err-info-list))
+           (err-info  nil)
+           (line      0))
+        (while (> count 0)
+            (setq err-info (nth (1- count) err-info-list))
+            (setq line (flymake-er-get-line err-info))
+            (when (or (< line min-line) (> line max-line))
+                (setq line (if (< line min-line) min-line max-line))
+                (setq err-info-list (flymake-set-at err-info-list (1- count)
+                                            (flymake-er-make-er line
+                                                              (flymake-er-get-line-err-info-list err-info))))
+            )
+            (setq count (1- count))
+        )
+    )
+    err-info-list
+)
+
+(defun flymake-highlight-err-lines(buffer err-info-list)
+    "highlight err-lines in buffer using info from err-info-list"
+    (save-excursion
+        (set-buffer buffer)
+        (let* ((idx    0)
+               (count  (length err-info-list)))
+            (while (< idx count)
+                (flymake-highlight-line (car (nth idx err-info-list)) (nth 1 (nth idx err-info-list)))
+                (setq idx (1+ idx))
+            )
+        )
+    )
+)
+
+(defun flymake-overlay-p(ov)
+     "Determine whether overlay was created by flymake"
+     (and (overlayp ov) (overlay-get ov 'flymake-overlay))
+)
+
+(defun flymake-make-overlay(beg end tooltip-text face mouse-face)
+    "Allocate a flymake overlay in range beg end"
+    (when (not (flymake-region-has-flymake-overlays beg end))
+        (let ((ov (make-overlay beg end nil t t)))
+            (overlay-put ov 'face           face)
+            (overlay-put ov 'mouse-face     mouse-face)
+            (overlay-put ov 'help-echo      tooltip-text)
+            (overlay-put ov 'flymake-overlay  t)
+            (overlay-put ov 'priority 100)
+            ;+(flymake-log 3 "created overlay %s" ov)
+            ov
+        )
+        (flymake-log 3 "created an overlay at (%d-%d)" beg end)
+    )
+)
+
+(defun flymake-delete-own-overlays(buffer)
+    "Delete all flymake overlays in buffer"
+    (save-excursion
+        (set-buffer buffer)
+        (let ((ov (overlays-in (point-min) (point-max))))
+            (while (consp ov)
+                (when (flymake-overlay-p (car ov))
+                    (delete-overlay (car ov))
+                    ;+(flymake-log 3 "deleted overlay %s" ov)
+                )
+                (setq ov (cdr ov))
+            )
+        )
+    )
+)
+
+(defun flymake-region-has-flymake-overlays(beg end)
+    "t if specified regions has at least one flymake overlay, nil otrherwise"
+    (let ((ov                  (overlays-in beg end))
+          (has-flymake-overlays  nil))
+        (while (consp ov)
+            (when (flymake-overlay-p (car ov))
+                (setq has-flymake-overlays t)
+            )
+            (setq ov (cdr ov))
+        )
+    )
+)
+
+(defface flymake-errline-face
+;+   '((((class color)) (:foreground "OrangeRed" :bold t :underline t))
+;+   '((((class color)) (:underline "OrangeRed"))
+   '((((class color)) (:background "LightPink"))
+     (t (:bold t)))
+   "Face used for marking error lines"
+    :group 'flymake
+)
+
+(defface flymake-warnline-face
+   '((((class color)) (:background "LightBlue2"))
+     (t (:bold t)))
+   "Face used for marking warning lines"
+    :group 'flymake
+)
+
+
+(defun flymake-highlight-line(line-no line-err-info-list)
+    "highlight line line-no in current buffer, perhaps use text from line-err-info-list to enhance highlighting"
+    (goto-line line-no)
+    (let* ((line-beg (flymake-line-beginning-position))
+           (line-end (flymake-line-end-position))
+           (beg      line-beg)
+           (end      line-end)
+           (tooltip-text (flymake-ler-get-text (nth 0 line-err-info-list)))
+           (face     nil))
+
+        (goto-char line-beg)
+        (while (looking-at "[ \t]")
+            (forward-char)
+        )
+
+        (setq beg (point))
+
+        (goto-char line-end)
+        (while (and (looking-at "[ \t\r\n]") (> (point) 1))
+            (backward-char)
+        )
+
+        (setq end (1+ (point)))
+
+        (when (<= end beg)
+            (setq beg line-beg)
+            (setq end line-end)
+        )
+        (when (= end beg)
+            (goto-char end)
+            (forward-line)
+            (setq end (point))
+        )
+        (if (> (flymake-get-line-err-count line-err-info-list "e") 0)
+            (setq face 'flymake-errline-face)
+        ;else
+            (setq face 'flymake-warnline-face)
+        )
+        (flymake-make-overlay beg end tooltip-text face nil)
+    )
+)
+
+(defun flymake-parse-err-lines(err-info-list source-buffer lines)
+    "parse err lines, store info in err-info-list"
+    (let* ((count              (length lines))
+           (idx                0)
+           (line-err-info      nil)
+           (real-file-name     nil)
+           (source-file-name   (buffer-file-name source-buffer))
+           (get-real-file-name-f (flymake-get-real-file-name-function source-file-name)))
+
+        (while (< idx count)
+            (setq line-err-info (flymake-parse-line (nth idx lines)))
+            (when line-err-info
+                (setq real-file-name (funcall get-real-file-name-f source-buffer (flymake-ler-get-file line-err-info)))
+                (setq line-err-info (flymake-ler-set-full-file line-err-info real-file-name))
+
+                (if (flymake-same-files real-file-name source-file-name)
+                    (setq line-err-info (flymake-ler-set-file line-err-info nil))
+                ;else
+                    (setq line-err-info (flymake-ler-set-file line-err-info (file-name-nondirectory real-file-name)))
+                )
+
+                (setq err-info-list (flymake-add-err-info err-info-list line-err-info))
+            )
+            (flymake-log 3 "parsed '%s', %s line-err-info" (nth idx lines) (if line-err-info "got" "no"))
+            (setq idx (1+ idx))
+        )
+        err-info-list
+    )
+)
+
+(defun flymake-split-output(output)
+    "split output into lines, return last one as residual if it does not end with newline char. Returns ((lines) residual)"
+    (when (and output (> (length output) 0))
+        (let* ((lines (flymake-split-string output "[\n\r]+"))
+               (complete (equal "\n" (char-to-string (aref output (1- (length output))))))
+               (residual nil))
+            (when (not complete)
+                (setq residual (car (last lines)))
+                (setq lines (butlast lines))
+            )
+            (list lines residual)
+        )
+    )
+)
+
+(eval-when-compile (require 'compile))
+(defvar flymake-err-line-patterns  ; regexp file-idx line-idx col-idx (optional) text-idx(optional), match-end to end of string is error text
+    (append
+     '(
+    ; MS Visual C++ 6.0
+       ("\\(\\([a-zA-Z]:\\)?[^:(\t\n]+\\)(\\([0-9]+\\)) \: \\(\\(error\\|warning\\|fatal error\\) \\(C[0-9]+\\):[ \t\n]*\\(.+\\)\\)"
+        1 3 nil 4)
+    ; jikes
+       ("\\(\\([a-zA-Z]:\\)?[^:(\t\n]+\\)\:\\([0-9]+\\)\:[0-9]+\:[0-9]+\:[0-9]+\: \\(\\(Error\\|Warning\\|Caution\\|Semantic Error\\):[ \t\n]*\\(.+\\)\\)"
+        1 3 nil 4)
+    ; MS midl
+       ("midl[ ]*:[ ]*\\(command line error .*\\)"
+        nil nil nil 1)
+    ; MS C#
+       ("\\(\\([a-zA-Z]:\\)?[^:(\t\n]+\\)(\\([0-9]+\\),[0-9]+)\: \\(\\(error\\|warning\\|fatal error\\) \\(CS[0-9]+\\):[ \t\n]*\\(.+\\)\\)"
+        1 3 nil 4)
+    ; perl
+       ("\\(.*\\) at \\([^ \n]+\\) line \\([0-9]+\\)[,.\n]" 2 3 nil 1)
+    ; LaTeX warnings (fileless) ("\\(LaTeX \\(Warning\\|Error\\): .*\\) on input line \\([0-9]+\\)" 20 3 nil 1)
+    ; ant/javac
+           (" *\\(\\[javac\\]\\)? *\\(\\([a-zA-Z]:\\)?[^:(\t\n]+\\)\:\\([0-9]+\\)\:[ \t\n]*\\(.+\\)"
+        2 4 nil 5)
+      )
+     compilation-error-regexp-alist)
+    "patterns for matching error/warning lines, (regexp file-idx line-idx err-text-idx)"
+)
+;(defcustom flymake-err-line-patterns
+;  '(
+;    ; MS Visual C++ 6.0
+;    ("\\(\\([a-zA-Z]:\\)?[^:(\t\n]+\\)(\\([0-9]+\\)) \: \\(\\(error\\|warning\\|fatal error\\) \\(C[0-9]+\\):[ \t\n]*\\(.+\\)\\)"
+;       1 3 4)
+;   ; jikes
+;   ("\\(\\([a-zA-Z]:\\)?[^:(\t\n]+\\)\:\\([0-9]+\\)\:[0-9]+\:[0-9]+\:[0-9]+\: \\(\\(Error\\|Warning\\|Caution\\):[ \t\n]*\\(.+\\)\\)"
+;       1 3 4))
+;    "patterns for matching error/warning lines, (regexp file-idx line-idx err-text-idx)"
+;   :group 'flymake
+;   :type '(repeat (string number number number))
+;)
+
+(defun flymake-parse-line(line)
+    "parse line to see whether it's an error of warning, return it's components or nil for no match"
+    (let ((raw-file-name nil)
+          (line-no 0)
+          (err-type "e")
+          (err-text nil)
+          (count (length flymake-err-line-patterns))
+          (idx   0)
+          (matched nil))
+        (while (and (< idx count) (not matched))
+            (when (string-match (car (nth idx flymake-err-line-patterns)) line)
+                (let* ((file-idx (nth 1 (nth idx flymake-err-line-patterns)))
+                       (line-idx (nth 2 (nth idx flymake-err-line-patterns))))
+
+                    (setq raw-file-name (if file-idx (match-string file-idx line) nil))
+                    (setq line-no       (if line-idx (string-to-int (match-string line-idx line)) 0))
+                    (setq err-text      (if (> (length (nth idx flymake-err-line-patterns)) 4)
+                                            (match-string (nth 4 (nth idx flymake-err-line-patterns)) line)
+                                          (flymake-patch-err-text (substring line (match-end 0)))))
+                    (or err-text (setq err-text "<no error text>"))
+                    (if (and err-text (string-match "^[wW]arning" err-text))
+                        (setq err-type "w")
+                    )
+                    (flymake-log 3 "parse line: file-idx=%s line-idx=%s file=%s line=%s text=%s" file-idx line-idx
+                                 raw-file-name line-no err-text)
+                    (setq matched t)
+                )
+            )
+            (setq idx (1+ idx))
+        )
+        (if matched
+           (flymake-ler-make-ler raw-file-name line-no err-type err-text)
+        ; else
+           ()
+        )
+    )
+)
+
+(defun flymake-find-err-info(err-info-list line-no)
+    "find (line-err-info-list pos) for specified line-no"
+    (if err-info-list
+        (let* ((line-err-info-list  nil)
+               (pos       0)
+               (count     (length err-info-list)))
+
+            (while (and (< pos count) (< (car (nth pos err-info-list)) line-no))
+                (setq pos (1+ pos))
+            )
+            (when (and (< pos count) (equal (car (nth pos err-info-list)) line-no))
+                (setq line-err-info-list (flymake-er-get-line-err-info-list (nth pos err-info-list)))
+            )
+            (list line-err-info-list pos)
+        )
+    ;else
+        '(nil 0)
+    )
+)
+
+(defun flymake-line-err-info-is-less-or-equal(line-one line-two)
+    (or (string< (flymake-ler-get-type line-one) (flymake-ler-get-type line-two))
+        (and (string= (flymake-ler-get-type line-one) (flymake-ler-get-type line-two))
+             (not (flymake-ler-get-file line-one)) (flymake-ler-get-file line-two)
+        )
+        (and (string= (flymake-ler-get-type line-one) (flymake-ler-get-type line-two))
+             (or (and      (flymake-ler-get-file line-one)       (flymake-ler-get-file line-two))
+                 (and (not (flymake-ler-get-file line-one)) (not (flymake-ler-get-file line-two)))
+             )
+        )
+    )
+)
+
+(defun flymake-add-line-err-info(line-err-info-list line-err-info)
+    "insert new err info favoring sorting: err-type e/w, filename nil/non-nill"
+    (if (not line-err-info-list)
+        (list line-err-info)
+    ;else
+        (let* ((count  (length line-err-info-list))
+               (idx    0))
+            (while (and (< idx count) (flymake-line-err-info-is-less-or-equal (nth idx line-err-info-list) line-err-info))
+                (setq idx (1+ idx))
+            )
+            (cond ((equal 0     idx)    (setq line-err-info-list (cons line-err-info line-err-info-list)))
+                  (t                    (setq line-err-info-list (flymake-ins-after line-err-info-list (1- idx) line-err-info)))
+            )
+            line-err-info-list
+        )
+    )
+)
+
+(defun flymake-add-err-info(err-info-list line-err-info)
+    "add error info (file line type text) to err info list preserving sort order"
+    (let* ((count               (length err-info-list))
+           (line-no             (if (flymake-ler-get-file line-err-info) 1 (flymake-ler-get-line line-err-info)))
+           (info-and-pos        (flymake-find-err-info err-info-list line-no))
+           (exists              (car info-and-pos))
+           (pos                 (nth 1 info-and-pos))
+           (line-err-info-list  nil)
+           (err-info            nil))
+
+        (if exists
+            (setq line-err-info-list (flymake-er-get-line-err-info-list (car (nthcdr pos err-info-list))))
+        )
+        (setq line-err-info-list (flymake-add-line-err-info line-err-info-list line-err-info))
+
+        (setq err-info (flymake-er-make-er line-no line-err-info-list))
+        (cond (exists             (setq err-info-list (flymake-set-at err-info-list pos err-info)))
+              ((equal 0 pos)      (setq err-info-list (cons err-info err-info-list)))
+              (t                  (setq err-info-list (flymake-ins-after err-info-list (1- pos) err-info)))
+        )
+        err-info-list
+    )
+)
+
+(defun flymake-get-project-include-dirs-imp(basedir)
+    "include dirs for the project current file belongs to"
+    (if (flymake-get-project-include-dirs-from-cache basedir)
+        (progn
+            (flymake-get-project-include-dirs-from-cache basedir)
+        )
+    ;else
+        (let* ((command-line  (concat "make -C\"" basedir "\" DUMPVARS=INCLUDE_DIRS dumpvars"))
+               (output        (shell-command-to-string command-line))
+               (lines         (flymake-split-string output "\n"))
+               (count         (length lines))
+               (idx           0)
+               (inc-dirs      nil))
+            (while (and (< idx count) (not (string-match "^INCLUDE_DIRS=.*" (nth idx lines))))
+               (setq idx (1+ idx))
+            )
+            (when (< idx count)
+                (let* ((inc-lines  (flymake-split-string (nth idx lines) " *-I"))
+                       (inc-count  (length inc-lines)))
+                    (while (> inc-count 0)
+                        (when (not (string-match "^INCLUDE_DIRS=.*" (nth (1- inc-count) inc-lines)))
+                            (setq inc-dirs (cons (flymake-replace-regexp-in-string "\"" "" (nth (1- inc-count) inc-lines)) inc-dirs))
+                        )
+                        (setq inc-count (1- inc-count))
+                    )
+                )
+            )
+            (flymake-add-project-include-dirs-to-cache basedir inc-dirs)
+            inc-dirs
+        )
+    )
+)
+
+(defcustom flymake-get-project-include-dirs-function 'flymake-get-project-include-dirs-imp
+    "function used to get project inc dirs, one paramater: basedir name"
+    :group 'flymake
+    :type 'function
+)
+
+(defun flymake-get-project-include-dirs(basedir)
+    (funcall flymake-get-project-include-dirs-function basedir)
+)
+
+(defun flymake-get-system-include-dirs()
+    "system include dirs - from the 'INCLUDE' env setting"
+    (let* ((includes (getenv "INCLUDE")))
+        (if includes (flymake-split-string includes path-separator) nil)
+    )
+)
+
+(defvar flymake-project-include-dirs-cache (flymake-makehash 'equal))
+(defun flymake-get-project-include-dirs-from-cache(base-dir)
+    (gethash base-dir flymake-project-include-dirs-cache)
+)
+(defun flymake-add-project-include-dirs-to-cache(base-dir include-dirs)
+    (puthash base-dir include-dirs flymake-project-include-dirs-cache)
+)
+(defun flymake-clear-project-include-dirs-cache()
+    (clrhash flymake-project-include-dirs-cache)
+)
+
+(defun flymake-get-include-dirs(base-dir)
+    "dirs to use when resolving local filenames"
+    (let* ((include-dirs (append '(".") (flymake-get-project-include-dirs base-dir) (flymake-get-system-include-dirs))))
+        include-dirs
+    )
+)
+
+(defun flymake-find-file(rel-file-name include-dirs)
+    "iterate through include-dirs, return first 'include-dir/rel-file-name' that exists, or just rel-file-name if not"
+    (let* ((count          (length include-dirs))
+           (idx            0)
+           (found          nil)
+           (full-file-name rel-file-name))
+
+        (while (and (not found) (< idx count))
+            (let* ((dir (nth idx include-dirs)))
+                (setq full-file-name  (concat dir "/" rel-file-name))
+                (when (file-exists-p full-file-name)
+                    (setq done t)
+                )
+            )
+            (setq idx (1+ idx))
+        )
+        (if found
+            full-file-name
+        ;else
+            rel-file-name
+        )
+    )
+)
+
+(defun flymake-restore-formatting(source-buffer)
+    "Remove any formatting made by flymake"
+)
+
+(defun flymake-get-program-dir(buffer)
+    "dir to start profram in"
+    (unless (bufferp buffer)
+        (error "invlid buffer")
+    )
+    (save-excursion
+        (set-buffer buffer)
+        default-directory
+    )
+)
+
+(defun flymake-safe-delete-file(file-name)
+    (when (and file-name (file-exists-p file-name))
+        (delete-file file-name)
+        (flymake-log 1 "deleted file %s" file-name)
+    )
+)
+
+(defun flymake-safe-delete-directory(dir-name)
+    (condition-case err
+        (progn
+            (delete-directory dir-name)
+            (flymake-log 1 "deleted dir %s" dir-name)
+        )
+        (error
+            (flymake-log 1 "failed to delete dir %s, error ignored" dir-name)
+        )
+    )
+)
+
+(defcustom flymake-compilation-prevents-syntax-check t
+    "if non-nil, syntax check won't be started in case compilation is running"
+    :group 'flymake
+    :type 'boolean
+)
+
+(defun flymake-start-syntax-check(buffer)
+    "start syntax checking for buffer"
+    (unless (bufferp buffer)
+        (error "expected a buffer")
+    )
+    (save-excursion
+        (set-buffer buffer)
+        (flymake-log 3 "flymake is running: %s" (flymake-get-buffer-is-running buffer))
+        (when (and (not (flymake-get-buffer-is-running buffer))
+                   (flymake-can-syntax-check-file (buffer-file-name buffer)))
+            (when (or (not flymake-compilation-prevents-syntax-check)
+                    (not (flymake-compilation-is-running))) ;+ (flymake-rep-ort-status buffer "COMP")
+                (flymake-clear-buildfile-cache)
+                (flymake-clear-project-include-dirs-cache)
+
+                (flymake-set-buffer-check-was-interrupted buffer nil)
+                (flymake-set-buffer-data buffer (flymake-makehash 'equal))
+
+                (let* ((source-file-name  (buffer-file-name buffer))
+                       (init-f (flymake-get-init-function source-file-name))
+                       (cleanup-f (flymake-get-cleanup-function source-file-name))
+                       (cmd-and-args (funcall init-f buffer))
+                       (cmd          (nth 0 cmd-and-args))
+                       (args         (nth 1 cmd-and-args))
+                                           (dir          (nth 2 cmd-and-args)))
+                    (if (not cmd-and-args)
+                        (progn
+                            (flymake-log 0 "init function %s for %s failed, cleaning up" init-f source-file-name)
+                            (funcall cleanup-f buffer)
+                        )
+                    ;else
+                        (progn
+                            (flymake-set-buffer-last-change-time buffer nil)
+                            (flymake-start-syntax-check-process buffer cmd args dir)
+                        )
+                    )
+                )
+            )
+        )
+    )
+)
+
+(defun flymake-start-syntax-check-process(buffer cmd args dir)
+    "start syntax check-process"
+
+    (let* ((process nil))
+        (condition-case err
+            (progn
+                            (when dir
+                                        (let ((default-directory dir))
+                                            (flymake-log 3 "starting process on dir %s" default-directory)
+                                        )
+                                )
+                                (setq process (get-process (apply 'start-process "flymake-proc" nil cmd args)))
+                (set-process-sentinel process 'flymake-process-sentinel)
+                (set-process-filter process 'flymake-process-filter)
+
+                (flymake-reg-names (process-id process) (buffer-name buffer))
+
+                (flymake-set-buffer-is-running buffer t)
+                (flymake-set-buffer-last-change-time buffer nil)
+                (flymake-set-buffer-check-start-time buffer (flymake-float-time))
+
+                (flymake-report-status buffer nil "*")
+                (flymake-log 2 "started process %d, command=%s, dir=%s"
+                           (process-id process) (process-command process) default-directory)
+                process
+            )
+            (error
+                (let ((err-str (format "Failed to launch syntax check process '%s' with args %s: %s"
+                             cmd args (error-message-string err)))
+                      (source-file-name (buffer-file-name buffer))
+                      (cleanup-f        (flymake-get-cleanup-function source-file-name)))
+                    (flymake-log 0 err-str)
+                    (funcall cleanup-f buffer)
+                    (flymake-report-fatal-status buffer "PROCERR" err-str)
+                )
+            )
+        )
+    )
+)
+
+(defun flymake-kill-process(pid &optional rest)
+    "kill process pid"
+    (signal-process pid 9)
+    (let* ((buffer-name (flymake-get-source-buffer-name pid)))
+        (when (and buffer-name (get-buffer buffer-name))
+            (flymake-set-buffer-check-was-interrupted (get-buffer buffer-name) t)
+        )
+    )
+    (flymake-log 1 "killed process %d" pid)
+)
+
+(defun flymake-stop-all-syntax-checks()
+    "kill all syntax check processes"
+    (interactive)
+    (let ((pids  (copy-hash-table flymake-pid-to-names)))
+        (maphash 'flymake-kill-process pids)
+    )
+)
+
+(defun flymake-compilation-is-running()
+   (and (boundp 'compilation-in-progress)
+        compilation-in-progress)
+)
+
+(defun flymake-compile()
+    "kill all flymake syntax checks, start compilation"
+    (interactive)
+    (flymake-stop-all-syntax-checks)
+    (call-interactively 'compile)
+)
+
+(defvar flymake-is-running nil
+  "t if flymake syntax check process is running for the current buffer"
+)
+(make-variable-buffer-local 'flymake-is-running)
+(defun flymake-get-buffer-is-running(buffer)
+    (flymake-get-buffer-var buffer 'flymake-is-running)
+)
+(defun flymake-set-buffer-is-running(buffer is-running)
+    (flymake-set-buffer-var buffer 'flymake-is-running is-running)
+)
+
+(defvar flymake-timer nil
+    "timer for starting syntax checks"
+)
+(make-variable-buffer-local 'flymake-timer)
+(defun flymake-get-buffer-timer(buffer)
+    (flymake-get-buffer-var buffer 'flymake-timer)
+)
+(defun flymake-set-buffer-timer(buffer timer)
+    (flymake-set-buffer-var buffer 'flymake-timer timer)
+)
+
+(defvar flymake-last-change-time nil
+    "time of last buffer change"
+)
+(make-variable-buffer-local 'flymake-last-change-time)
+(defun flymake-get-buffer-last-change-time(buffer)
+    (flymake-get-buffer-var buffer 'flymake-last-change-time)
+)
+(defun flymake-set-buffer-last-change-time(buffer change-time)
+    (flymake-set-buffer-var buffer 'flymake-last-change-time change-time)
+)
+
+(defvar flymake-check-start-time nil
+    "time at which syntax check was started")
+(make-variable-buffer-local 'flymake-check-start-time)
+(defun flymake-get-buffer-check-start-time(buffer)
+    (flymake-get-buffer-var buffer 'flymake-check-start-time)
+)
+(defun flymake-set-buffer-check-start-time(buffer check-start-time)
+    (flymake-set-buffer-var buffer 'flymake-check-start-time check-start-time)
+)
+
+(defvar flymake-check-was-interrupted nil
+    "t if syntax check was killed by flymake-compile"
+)
+(make-variable-buffer-local 'flymake-check-was-interrupted)
+(defun flymake-get-buffer-check-was-interrupted(buffer)
+    (flymake-get-buffer-var buffer 'flymake-check-was-interrupted)
+)
+(defun flymake-set-buffer-check-was-interrupted(buffer interrupted)
+    (flymake-set-buffer-var buffer 'flymake-check-was-interrupted interrupted)
+)
+
+(defcustom flymake-no-changes-timeout 0.5
+    "time to wait after last change before starting compilation"
+    :group 'flymake
+    :type 'number
+)
+
+(defun flymake-on-timer-event(buffer)
+    "start a syntax check for buffer if necessary"
+    ;+(flymake-log 3 "timer: running=%s, time=%s, cur-time=%s" (flymake-get-buffer-is-running buffer) (flymake-get-buffer-last-change-time buffer) (flymake-float-time))
+
+     (when (and (bufferp buffer) (not (flymake-get-buffer-is-running buffer)))
+        (save-excursion
+            (set-buffer buffer)
+            (when (and (flymake-get-buffer-last-change-time buffer)
+                       (> (flymake-float-time) (+ flymake-no-changes-timeout (flymake-get-buffer-last-change-time buffer))))
+                (flymake-set-buffer-last-change-time buffer nil)
+                (flymake-log 3 "starting syntax check as more than 1 second passed since last change")
+                (flymake-start-syntax-check buffer)
+            )
+        )
+    )
+)
+
+(defun flymake-start-syntax-check-for-current-buffer()
+    "run flymake-start-syntax-check for current buffer if it isn't already running"
+    (interactive)
+    (flymake-start-syntax-check (current-buffer))
+)
+
+(defun flymake-current-line-no()
+    "return number of current line in current buffer"
+    (interactive)
+    (let ((beg  (point-min))
+          (end  (if (= (point) (point-max)) (point) (1+ (point)))))
+        (count-lines beg end)
+    )
+)
+
+(defun flymake-get-line-count(buffer)
+    "return number of lines in buffer"
+    (unless (bufferp buffer)
+        (error "invalid buffer")
+    )
+    (save-excursion
+        (set-buffer buffer)
+        (count-lines (point-min) (point-max))
+    )
+)
+
+(defun flymake-count-lines(buffer)
+    "return number of lines in buffer"
+    (save-excursion
+        (set-buffer buffer)
+        (count-lines (point-min) (point-max))
+    )
+)
+
+(defun flymake-get-point-pixel-pos()
+    "return point position in pixels: (x, y)"
+    (let ((mouse-pos  (mouse-position))
+          (pixel-pos  nil)
+          (ret        nil))
+        (if (car (cdr mouse-pos))
+            (progn
+                (set-mouse-position (flymake-selected-frame) (current-column) (flymake-current-row))
+                (setq pixel-pos (mouse-pixel-position))
+                (set-mouse-position (car mouse-pos) (car (cdr mouse-pos)) (cdr (cdr mouse-pos)))
+                (setq ret (list (car (cdr pixel-pos)) (cdr (cdr pixel-pos))))
+             )
+        ;else
+            (progn
+                (setq ret '(0 0))
+            )
+        )
+        (flymake-log 3 "mouse pos is %s" ret)
+        ret
+    )
+)
+
+(defun flymake-display-err-menu-for-current-line()
+   "Display a menu with errors/warnings for current line if it has errors and/or warnings"
+   (interactive)
+   (let* ((line-no             (flymake-current-line-no))
+          (line-err-info-list  (nth 0 (flymake-find-err-info (flymake-get-buffer-err-info (current-buffer)) line-no)))
+          (menu-data           (flymake-make-err-menu-data line-no line-err-info-list))
+          (choice              nil)
+          (mouse-pos           (flymake-get-point-pixel-pos))
+          (moved-mouse-pos     (list (car mouse-pos) (+ 10 (car (cdr mouse-pos)))))
+          (menu-pos            (list (flymake-get-point-pixel-pos) (selected-window))))
+       (if menu-data
+           (progn
+               (setq choice (flymake-popup-menu menu-pos menu-data))
+                           (flymake-log 3 "choice=%s" choice)
+               (when choice
+                               (eval choice)
+                       )
+            )
+       ;else
+           (flymake-log 1 "no errors for line %d" line-no)
+       )
+   )
+)
+
+(defun flymake-make-err-menu-data(line-no line-err-info-list)
+   "Make a (menu-title (item-title item-action)*) list with errors/warnings from line-err-info"
+   (let* ((menu-items  nil))
+       (when line-err-info-list
+           (let* ((count           (length line-err-info-list))
+                  (menu-item-text  nil))
+               (while (> count 0)
+                    (setq menu-item-text (flymake-ler-get-text (nth (1- count) line-err-info-list)))
+                    (let* ((file       (flymake-ler-get-file (nth (1- count) line-err-info-list)))
+                           (full-file  (flymake-ler-get-full-file (nth (1- count) line-err-info-list)))
+                           (line       (flymake-ler-get-line (nth (1- count) line-err-info-list))))
+                        (if file
+                            (setq menu-item-text (concat menu-item-text " - " file "(" (format "%d" line) ")"))
+                        )
+                        (setq menu-items (cons (list menu-item-text
+                                                     (if file (list 'flymake-goto-file-and-line full-file line) nil))
+                                               menu-items))
+                    )
+                    (setq count (1- count))
+               )
+               (flymake-log 3 "created menu-items with %d item(s)" (length menu-items))
+           )
+       )
+       (if menu-items
+           (let* ((menu-title  (format "Line %d: %d error(s), %d warning(s)" line-no
+                                      (flymake-get-line-err-count line-err-info-list "e")
+                                      (flymake-get-line-err-count line-err-info-list "w"))))
+               (list menu-title menu-items)
+           )
+       ;else
+           nil
+       )
+   )
+)
+
+(defun flymake-goto-file-and-line(file line)
+    "try to get buffer for file and goto line line in it"
+    (if (not (file-exists-p file))
+        (flymake-log 1 "file %s does not exists" file)
+    ;else
+        (progn
+            (find-file file)
+            (goto-line line)
+        )
+    )
+)
+;; flymake minor mode declarations
+
+(defvar flymake-mode nil)
+(make-variable-buffer-local 'flymake-mode)
+
+(defvar flymake-mode-line nil
+    ""
+)
+(make-variable-buffer-local 'flymake-mode-line)
+(defun flymake-get-buffer-mode-line(buffer)
+    (flymake-get-buffer-var buffer 'flymake-mode-line)
+)
+(defun flymake-set-buffer-mode-line(buffer mode-line-string)
+    (flymake-set-buffer-var buffer 'flymake-mode-line mode-line-string)
+)
+
+(defvar flymake-mode-line-e-w nil)
+(make-variable-buffer-local 'flymake-mode-line-e-w)
+(defun flymake-get-buffer-mode-line-e-w(buffer)
+    (flymake-get-buffer-var buffer 'flymake-mode-line-e-w)
+)
+(defun flymake-set-buffer-mode-line-e-w(buffer e-w)
+    (flymake-set-buffer-var buffer 'flymake-mode-line-e-w e-w)
+)
+
+(defvar flymake-mode-line-status nil)
+(make-variable-buffer-local 'flymake-mode-line-status)
+(defun flymake-get-buffer-mode-line-status(buffer)
+    (flymake-get-buffer-var buffer 'flymake-mode-line-status)
+)
+(defun flymake-set-buffer-mode-line-status(buffer status)
+    (flymake-set-buffer-var buffer 'flymake-mode-line-status status)
+)
+
+(defun flymake-report-status(buffer e-w &optional status)
+    "show status in the mode line"
+    (when (bufferp buffer)
+        (save-excursion
+            (set-buffer buffer)
+            (when e-w
+                (flymake-set-buffer-mode-line-e-w buffer e-w)
+            )
+            (when status
+                (flymake-set-buffer-mode-line-status buffer status)
+            )
+            (let* ((mode-line " Flymake"))
+                (when (> (length (flymake-get-buffer-mode-line-e-w buffer)) 0)
+                    (setq mode-line (concat mode-line ":"  (flymake-get-buffer-mode-line-e-w buffer)))
+                )
+                (setq mode-line (concat mode-line (flymake-get-buffer-mode-line-status buffer)))
+                (flymake-set-buffer-mode-line buffer mode-line)
+                (force-mode-line-update)
+            )
+        )
+    )
+)
+
+(defun flymake-display-warning(warning)
+    "display a warning to the user"
+    (message-box warning)
+)
+
+(defcustom flymake-gui-warnings-enabled t
+    "enables/disables gui warnings"
+        :group 'flymake
+        :type 'boolean
+)
+
+(defun flymake-report-fatal-status(buffer status warning)
+    "display a warning and switch flymake mode OFF"
+        (when flymake-gui-warnings-enabled
+        (flymake-display-warning (format "Flymake: %s. Flymake will be switched OFF" warning))
+        )
+    (save-excursion
+        (set-buffer buffer)
+        (flymake-mode 0)
+        (flymake-log 0 "switched OFF Flymake mode for buffer %s due to fatal status %s, warning %s"
+                     (buffer-name buffer) status warning)
+    )
+)
+
+(defun flymake-mode(&optional arg)
+    "toggle flymake-mode"
+    (interactive)
+    (let ((old-flymake-mode flymake-mode))
+
+        (setq turn-on
+            (if (null arg)
+                (not flymake-mode)
+            ;else
+                (> (prefix-numeric-value arg) 0))
+        )
+
+        (if turn-on
+            (if (flymake-can-syntax-check-file (buffer-file-name))
+                (flymake-mode-on)
+            ;else
+                (flymake-log 2 "flymake cannot check syntax in buffer %s" (buffer-name))
+            )
+        ;else
+            (flymake-mode-off)
+        )
+        (force-mode-line-update)
+    )
+)
+
+;;;###autoload
+(unless (assq 'flymake-mode minor-mode-alist)
+    (setq minor-mode-alist (cons '(flymake-mode flymake-mode-line) minor-mode-alist))
+)
+
+;;;###autoload
+(defun flymake-mode-on()
+    "turn flymake mode on"
+    (when (not flymake-mode)
+        (make-local-variable 'after-change-functions)
+        (setq after-change-functions (cons 'flymake-after-change-function after-change-functions))
+        (add-hook 'after-save-hook 'flymake-after-save-hook)
+        (add-hook 'kill-buffer-hook 'flymake-kill-buffer-hook)
+        ;+(add-hook 'find-file-hooks 'flymake-find-file-hook)
+
+        (flymake-report-status (current-buffer) "" "")
+
+        (flymake-set-buffer-timer (current-buffer) (run-at-time nil 1 'flymake-on-timer-event (current-buffer)))
+
+        (setq flymake-mode t)
+        (flymake-log 1 "flymake mode turned ON for buffer %s" (buffer-name (current-buffer)))
+        (when flymake-start-syntax-check-on-find-file
+            (flymake-start-syntax-check-for-current-buffer) ; will be started by on-load hook
+        )
+    )
+)
+
+;;;###autoload
+(defun flymake-mode-off()
+    "turn flymake mode off"
+    (when flymake-mode
+        (setq after-change-functions (delq 'flymake-after-change-function  after-change-functions))
+        (remove-hook 'after-save-hook (function flymake-after-save-hook) t)
+        (remove-hook 'kill-buffer-hook (function flymake-kill-buffer-hook) t)
+        ;+(remove-hook 'find-file-hooks (function flymake-find-file-hook) t)
+
+        (flymake-delete-own-overlays (current-buffer))
+
+        (when (flymake-get-buffer-timer (current-buffer))
+            (cancel-timer (flymake-get-buffer-timer (current-buffer)))
+            (flymake-set-buffer-timer (current-buffer) nil)
+        )
+
+        (flymake-set-buffer-is-running (current-buffer) nil)
+
+        (setq flymake-mode nil)
+        (flymake-log 1 "flymake mode turned OFF for buffer %s" (buffer-name (current-buffer)))
+    )
+)
+
+(defcustom flymake-start-syntax-check-on-newline t
+    "start syntax check if newline char was added/removed from the buffer"
+    :group 'flymake
+    :type 'boolean
+)
+
+(defun flymake-after-change-function(start stop len)
+    "Start syntax check for current buffer if it isn't already running"
+    ;+(flymake-log 0 "setting change time to %s" (flymake-float-time))
+    (let((new-text (buffer-substring start stop)))
+        (when (and flymake-start-syntax-check-on-newline (equal new-text "\n"))
+            (flymake-log 3 "starting syntax check as new-line has been seen")
+            (flymake-start-syntax-check-for-current-buffer)
+        )
+        (flymake-set-buffer-last-change-time (current-buffer) (flymake-float-time))
+    )
+)
+
+(defun flymake-after-save-hook()
+    (if (local-variable-p 'flymake-mode (current-buffer)) ; (???) other way to determine whether flymake is active in buffer being saved?
+        (progn
+            (flymake-log 3 "starting syntax check as buffer was saved")
+            (flymake-start-syntax-check-for-current-buffer) ; no more mode 3. cannot start check if mode 3 (to temp copies) is active - (???)
+        )
+    )
+)
+
+(defun flymake-kill-buffer-hook()
+    (when (flymake-get-buffer-timer (current-buffer))
+        (cancel-timer (flymake-get-buffer-timer (current-buffer)))
+        (flymake-set-buffer-timer (current-buffer) nil)
+    )
+)
+
+(defcustom flymake-start-syntax-check-on-find-file t
+    "statr syntax check on find file"
+    :group 'flymake
+    :type 'boolean
+)
+
+(defun flymake-find-file-hook()
+    ;+(when flymake-start-syntax-check-on-find-file
+    ;+    (flymake-log 3 "starting syntax check on file open")
+    ;+    (flymake-start-syntax-check-for-current-buffer)
+    ;+)
+    (when (and (not (local-variable-p 'flymake-mode (current-buffer)))
+           (flymake-can-syntax-check-file (buffer-file-name (current-buffer))))
+        (flymake-mode)
+        (flymake-log 3 "automatically turned ON flymake mode")
+    )
+)
+
+(defun flymake-get-first-err-line-no(err-info-list)
+    "return first line-no with error"
+    (when err-info-list
+        (flymake-er-get-line (car err-info-list))
+    )
+)
+
+(defun flymake-get-last-err-line-no(err-info-list)
+    "return last line-no with error"
+    (when err-info-list
+        (flymake-er-get-line (nth (1- (length err-info-list)) err-info-list))
+    )
+)
+
+(defun flymake-get-next-err-line-no(err-info-list line-no)
+    "return next line with erroe"
+    (when err-info-list
+        (let* ((count  (length err-info-list))
+               (idx    0))
+            (while (and (< idx count) (>= line-no (flymake-er-get-line (nth idx err-info-list))))
+                (setq idx (1+ idx))
+            )
+            (if (< idx count)
+                (flymake-er-get-line (nth idx err-info-list))
+            )
+        )
+    )
+)
+
+(defun flymake-get-prev-err-line-no(err-info-list line-no)
+    "return prev line with error"
+    (when err-info-list
+        (let* ((count (length err-info-list)))
+            (while (and (> count 0) (<= line-no (flymake-er-get-line (nth (1- count) err-info-list))))
+                (setq count (1- count))
+            )
+            (if (> count 0)
+                (flymake-er-get-line (nth (1- count) err-info-list))
+            )
+        )
+    )
+)
+
+(defun flymake-skip-whitespace()
+    "move forward until nonwhitespace is reached"
+    (while (looking-at "[ \t]")
+        (forward-char)
+    )
+)
+
+(defun flymake-goto-line(line-no)
+    "goto-line, then skip whitespace"
+    (goto-line line-no)
+    (flymake-skip-whitespace)
+)
+
+(defun flymake-goto-next-error()
+    "go to next error in err ring"
+    (interactive)
+    (let ((line-no (flymake-get-next-err-line-no (flymake-get-buffer-err-info (current-buffer)) (flymake-current-line-no))))
+        (when (not line-no)
+            (setq line-no (flymake-get-first-err-line-no (flymake-get-buffer-err-info (current-buffer))))
+            (flymake-log 1 "passed end of file")
+        )
+        (if line-no
+            (flymake-goto-line line-no)
+        ;else
+            (flymake-log 1 "no errors in current buffer")
+        )
+    )
+)
+
+(defun flymake-goto-prev-error()
+    "go to prev error in err ring"
+    (interactive)
+    (let ((line-no (flymake-get-prev-err-line-no (flymake-get-buffer-err-info (current-buffer)) (flymake-current-line-no))))
+        (when (not line-no)
+            (setq line-no (flymake-get-last-err-line-no (flymake-get-buffer-err-info (current-buffer))))
+            (flymake-log 1 "passed beginning of file")
+        )
+        (if line-no
+            (flymake-goto-line line-no)
+        ;else
+            (flymake-log 1 "no errors in current buffer")
+        )
+    )
+)
+
+(defun flymake-patch-err-text(string)
+    (if (string-match "^[\n\t :0-9]*\\(.*\\)$" string)
+        (match-string 1 string)
+    ;else
+        string
+    )
+)
+
+;;;; general init-cleanup and helper routines
+
+(defun flymake-create-temp-inplace(file-name prefix)
+    (unless (stringp file-name)
+        (error "invalid file-name")
+    )
+    (or prefix
+        (setq prefix "flymake")
+    )
+    (let* ((temp-name   (concat (file-name-sans-extension file-name)
+                                "_" prefix
+                                (and (file-name-extension file-name)
+                                     (concat "." (file-name-extension file-name))))))
+        (flymake-log 3 "create-temp-inplace: file=%s temp=%s" file-name temp-name)
+        temp-name
+    )
+)
+
+(defun flymake-create-temp-with-folder-structure(file-name prefix)
+    (unless (stringp file-name)
+        (error "invalid file-name")
+    )
+
+    (let* ((dir       (file-name-directory file-name))
+                   (slash-pos (string-match "/" dir))
+                   (temp-dir  (concat (flymake-ensure-ends-with-slash (flymake-get-temp-dir)) (substring dir (1+ slash-pos)))))
+
+            (file-truename (concat (flymake-ensure-ends-with-slash temp-dir)
+                                (file-name-nondirectory file-name)))
+    )
+)
+
+(defun flymake-strrchr(str ch)
+    (let* ((count  (length str))
+           (pos    nil))
+        (while (and (not pos) (> count 0))
+            (if (= ch (elt str (1- count)))
+                (setq pos (1- count))
+            )
+            (setq count (1- count))
+        )
+        pos
+    )
+)
+
+(defun flymake-delete-temp-directory(dir-name)
+    "attempt to delete temp dir created by flymake-create-temp-with-folder-structure, do not fail on error"
+    (let* ((temp-dir    (flymake-get-temp-dir))
+           (suffix      (substring dir-name (1+ (length temp-dir))))
+           (slash-pos   nil))
+
+        (while (> (length suffix) 0)
+            ;+(flymake-log 0 "suffix=%s" suffix)
+                        (flymake-safe-delete-directory (file-truename (concat (flymake-ensure-ends-with-slash temp-dir) suffix)))
+            (setq slash-pos (flymake-strrchr suffix (string-to-char "/")))
+            (if slash-pos
+                (setq suffix (substring suffix 0 slash-pos))
+            ;else
+                (setq suffix "")
+            )
+        )
+    )
+)
+
+(defun flymake-init-create-temp-buffer-copy(buffer create-temp-f)
+    "make a temporary copy of the current buffer, save its name in buffer data and return the name"
+    (let*  ((source-file-name       (buffer-file-name buffer))
+            (temp-source-file-name  (funcall create-temp-f source-file-name "flymake")))
+
+        (flymake-save-buffer-in-file buffer temp-source-file-name)
+        (flymake-set-buffer-value buffer "temp-source-file-name" temp-source-file-name)
+
+        temp-source-file-name
+    )
+)
+
+(defun flymake-simple-cleanup(buffer)
+    "cleanup after flymake-init-create-temp-buffer-copy -- delete temp file"
+    (let* ((temp-source-file-name (flymake-get-buffer-value buffer "temp-source-file-name")))
+        (flymake-safe-delete-file temp-source-file-name)
+        (flymake-set-buffer-last-change-time buffer nil)
+    )
+)
+
+(defun flymake-get-real-file-name(buffer file-name-from-err-msg)
+    "Translate file name from error message to `real' file name. Return full-name. Names are real, not patched"
+    (let* ((real-name              nil)
+           (source-file-name       (buffer-file-name buffer))
+           (master-file-name       (flymake-get-buffer-value buffer "master-file-name"))
+           (temp-source-file-name  (flymake-get-buffer-value buffer "temp-source-file-name"))
+           (temp-master-file-name  (flymake-get-buffer-value buffer "temp-master-file-name"))
+           (base-dirs              (list (flymake-get-buffer-value buffer "base-dir")
+                                         (file-name-directory source-file-name)
+                                         (if master-file-name (file-name-directory master-file-name) nil)))
+           (files                  (list (list source-file-name       source-file-name)
+                                         (list temp-source-file-name  source-file-name)
+                                         (list master-file-name       master-file-name)
+                                         (list temp-master-file-name  master-file-name))))
+
+        (when (equal 0 (length file-name-from-err-msg))
+            (setq file-name-from-err-msg source-file-name)
+        )
+
+        (setq real-name (flymake-get-full-patched-file-name file-name-from-err-msg base-dirs files))
+        ; if real-name is nil, than file name from err msg is none of the files we've patched
+        (if (not real-name)
+            (setq real-name (flymake-get-full-nonpatched-file-name file-name-from-err-msg base-dirs))
+        )
+        (if (not real-name)
+            (setq real-name file-name-from-err-msg)
+        )
+        (setq real-name (flymake-fix-path-name real-name))
+        (flymake-log 3 "get-real-file-name: file-name=%s real-name=%s" file-name-from-err-msg real-name)
+        real-name
+    )
+)
+
+(defun flymake-get-full-patched-file-name(file-name-from-err-msg base-dirs files)
+    (let* ((base-dirs-count  (length base-dirs))
+           (file-count       (length files))
+           (real-name        nil))
+
+        (while (and (not real-name) (> base-dirs-count 0))
+            (setq file-count (length files))
+            (while (and (not real-name) (> file-count 0))
+                (let* ((this-dir        (nth (1- base-dirs-count) base-dirs))
+                       (this-file       (nth 0 (nth (1- file-count) files)))
+                       (this-real-name  (nth 1 (nth (1- file-count) files))))
+                    ;+(flymake-log 0 "this-dir=%s this-file=%s this-real=%s msg-file=%s" this-dir this-file this-real-name file-name-from-err-msg)
+                    (when (and this-dir this-file (flymake-same-files
+                                                   (flymake-get-absolute-file-name-basedir file-name-from-err-msg this-dir)
+                                                   this-file))
+                        (setq real-name this-real-name)
+                    )
+                )
+                (setq file-count (1- file-count))
+            )
+            (setq base-dirs-count (1- base-dirs-count))
+        )
+        real-name
+    )
+)
+
+(defun flymake-get-full-nonpatched-file-name(file-name-from-err-msg base-dirs)
+    (let* ((real-name  nil))
+        (if (file-name-absolute-p file-name-from-err-msg)
+            (setq real-name file-name-from-err-msg)
+        ;else
+            (let* ((base-dirs-count  (length base-dirs)))
+                (while (and (not real-name) (> base-dirs-count 0))
+                    (let* ((full-name (flymake-get-absolute-file-name-basedir file-name-from-err-msg
+                                                                              (nth (1- base-dirs-count) base-dirs))))
+                        (if (file-exists-p full-name)
+                            (setq real-name full-name)
+                        )
+                        (setq base-dirs-count (1- base-dirs-count))
+                    )
+                )
+            )
+        )
+        real-name
+    )
+)
+
+(defun flymake-get-absolute-file-name-basedir(file-name dir-name)
+    (if (file-name-absolute-p file-name)
+        file-name
+    ;else
+        (concat dir-name "/" file-name)
+    )
+)
+
+(defun flymake-init-find-buildfile-dir(buffer source-file-name buildfile-name)
+    "find buildfile, store its dir in buffer data and return its dir, if found"
+    (let* ((buildfile-dir  (flymake-find-buildfile buildfile-name
+                                                   (file-name-directory source-file-name)
+                                                   flymake-buildfile-dirs)))
+        (if (not buildfile-dir)
+            (progn
+                (flymake-log 1 "no buildfile (%s) for %s" buildfile-name source-file-name)
+                (flymake-report-fatal-status buffer "NOMK" (format "No buildfile (%s) found for %s" buildfile-name source-file-name))
+            )
+        ;else
+            (progn
+                (flymake-set-buffer-value buffer "base-dir" buildfile-dir)
+            )
+        )
+        buildfile-dir
+    )
+)
+
+(defun flymake-init-create-temp-source-and-master-buffer-copy(buffer get-incl-dirs-f create-temp-f master-file-masks include-regexp-list)
+    "find master file (or buffer), create it's copy along with a copy of the source file"
+    (let* ((source-file-name       (buffer-file-name buffer))
+           (temp-source-file-name  (flymake-init-create-temp-buffer-copy buffer create-temp-f))
+           (master-file-name       nil)
+           (temp-master-file-name  nil)
+           (master-and-temp-master (flymake-create-master-file
+                                    source-file-name temp-source-file-name
+                                    get-incl-dirs-f create-temp-f
+                                    master-file-masks include-regexp-list)))
+
+        (if (not master-and-temp-master)
+            (progn
+                (flymake-log 1 "cannot find master file for %s" source-file-name)
+                (flymake-report-status buffer "!" "") ; NOMASTER
+            )
+        ;else
+            (progn
+                (setq master-file-name       (nth 0 master-and-temp-master))
+                (setq temp-master-file-name  (nth 1 master-and-temp-master))
+                (flymake-set-buffer-value buffer "master-file-name"      master-file-name)
+                (flymake-set-buffer-value buffer "temp-master-file-name" temp-master-file-name)
+            )
+        )
+        temp-master-file-name
+    )
+)
+
+(defun flymake-master-cleanup(buffer)
+    (flymake-simple-cleanup buffer)
+    (flymake-safe-delete-file (flymake-get-buffer-value buffer "temp-master-file-name"))
+)
+
+;;;; make-specific init-cleanup routines
+
+(defun flymake-get-syntax-check-program-args(source-file-name base-dir use-relative-base-dir use-relative-source get-cmd-line-f)
+    "create a command line for the syntax check command, using get-cmd-line-f"
+    (let* ((my-base-dir  base-dir)
+           (my-source    source-file-name))
+
+        (when use-relative-base-dir
+            (setq my-base-dir (flymake-build-relative-path (file-name-directory source-file-name) base-dir))
+        )
+
+        (when use-relative-source
+            (setq my-source (concat (flymake-build-relative-path base-dir (file-name-directory source-file-name))
+                                    (file-name-nondirectory source-file-name)))
+        )
+
+        (funcall get-cmd-line-f my-source my-base-dir)
+    )
+)
+
+(defun flymake-get-make-cmdline(source base-dir)
+    (list "make"
+          (list "-s"
+                        "-C"
+                        base-dir
+                        (concat "CHK_SOURCES=" source)
+                        "SYNTAX_CHECK_MODE=1"
+                        "check-syntax"))
+)
+
+(defun flymake-get-ant-cmdline(source base-dir)
+    (list "ant"
+          (list "-buildfile"
+                (concat base-dir "/" "build.xml")
+                (concat "-DCHK_SOURCES=" source)
+                "check-syntax"))
+)
+
+(defun flymake-simple-make-init-impl(buffer create-temp-f use-relative-base-dir use-relative-source build-file-name get-cmdline-f)
+    "create syntax check command line for a directly checked source file, use create-temp-f for creating temp copy"
+    (let* ((args          nil)
+           (source-file-name   (buffer-file-name buffer))
+           (buildfile-dir      (flymake-init-find-buildfile-dir buffer source-file-name build-file-name)))
+        (if buildfile-dir
+            (let* ((temp-source-file-name  (flymake-init-create-temp-buffer-copy buffer create-temp-f)))
+                (setq args (flymake-get-syntax-check-program-args temp-source-file-name buildfile-dir
+                                                               use-relative-base-dir use-relative-source
+                                                               get-cmdline-f))
+            )
+        )
+
+        args
+    )
+)
+
+(defun flymake-simple-make-init(buffer)
+    (flymake-simple-make-init-impl buffer 'flymake-create-temp-inplace t t "Makefile" 'flymake-get-make-cmdline)
+)
+
+(defun flymake-master-make-init(buffer get-incl-dirs-f master-file-masks include-regexp-list)
+    "create make command line for a source file checked via master file compilation"
+    (let* ((make-args          nil)
+           (temp-master-file-name (flymake-init-create-temp-source-and-master-buffer-copy
+                                   buffer get-incl-dirs-f 'flymake-create-temp-inplace
+                                   master-file-masks include-regexp-list)))
+        (when temp-master-file-name
+            (let* ((buildfile-dir (flymake-init-find-buildfile-dir buffer temp-master-file-name "Makefile")))
+                (if  buildfile-dir
+                                    (setq make-args (flymake-get-syntax-check-program-args
+                                                                         temp-master-file-name buildfile-dir nil nil 'flymake-get-make-cmdline))
+                )
+            )
+        )
+
+                make-args
+    )
+)
+
+(defun flymake-find-make-buildfile(source-dir)
+    (flymake-find-buildfile "Makefile" source-dir flymake-buildfile-dirs)
+)
+
+;;;; .h/make specific
+(defun flymake-master-make-header-init(buffer)
+    (flymake-master-make-init buffer
+                              'flymake-get-include-dirs
+                              '(".+\\.cpp$" ".+\\.c$")
+                              '("[ \t]*#[ \t]*include[ \t]*\"\\([\w0-9/\\_\.]*[/\\]*\\)\\(%s\\)\"" 1 2))
+)
+
+;;;; .java/make specific
+(defun flymake-simple-make-java-init(buffer)
+    (flymake-simple-make-init-impl buffer 'flymake-create-temp-with-folder-structure nil nil "Makefile" 'flymake-get-make-cmdline)
+)
+
+(defun flymake-simple-ant-java-init(buffer)
+    (flymake-simple-make-init-impl buffer 'flymake-create-temp-with-folder-structure nil nil "build.xml" 'flymake-get-ant-cmdline)
+)
+
+(defun flymake-simple-java-cleanup(buffer)
+    "cleanup after flymake-simple-make-java-init -- delete temp file and dirs"
+    (let* ((temp-source-file-name (flymake-get-buffer-value buffer "temp-source-file-name")))
+        (flymake-safe-delete-file temp-source-file-name)
+        (when temp-source-file-name
+            (flymake-delete-temp-directory (file-name-directory temp-source-file-name))
+        )
+    )
+)
+
+;;;; perl-specific init-cleanup routines
+
+(defun flymake-perl-init(buffer)
+    (let* ((temp-file   (flymake-init-create-temp-buffer-copy buffer 'flymake-create-temp-inplace))
+                   (local-file  (concat (flymake-build-relative-path (file-name-directory (buffer-file-name (current-buffer)))
+                                                                                                                         (file-name-directory temp-file))
+                                                                (file-name-nondirectory temp-file))))
+        (list "perl" (list "-wc " local-file))
+        )
+)
+
+;;;; tex-specific init-cleanup routines
+
+(defun flymake-get-tex-args(file-name)
+    ;(list "latex" (list "-c-style-errors" file-name))
+    (list "texify" (list "--pdf" "--tex-option=-c-style-errors" file-name))
+)
+
+(defun flymake-simple-tex-init(buffer)
+    (flymake-get-tex-args (flymake-init-create-temp-buffer-copy buffer 'flymake-create-temp-inplace))
+)
+
+(defun flymake-master-tex-init(buffer)
+    (let* ((temp-master-file-name (flymake-init-create-temp-source-and-master-buffer-copy
+                                   buffer 'flymake-get-include-dirs-dot 'flymake-create-temp-inplace
+                                   '(".+\\.tex$")
+                                   '("[ \t]*\\input[ \t]*{\\(.*\\)\\(%s\\)}" 1 2))))
+        (when temp-master-file-name
+            (flymake-get-tex-args temp-master-file-name)
+        )
+    )
+)
+
+(defun flymake-get-include-dirs-dot(base-dir)
+    '(".")
+)
+
+;;;; xml-specific init-cleanup routines
+
+(defun flymake-xml-init(buffer)
+    (list "xml" (list "val" (flymake-init-create-temp-buffer-copy buffer 'flymake-create-temp-inplace)))
+)
+
+;;; arch-tag: 8f0d6090-061d-4cac-8862-7c151c4a02dd
+;;; flymake.el ends here
diff --git a/lisp/progmodes/grep.el b/lisp/progmodes/grep.el
index c5e322a657a..aa81f8aa770 100644
--- a/lisp/progmodes/grep.el
+++ b/lisp/progmodes/grep.el
@@ -533,8 +533,7 @@ those sub directories of DIR."
           (files
            (read-string (concat "Search for \"" regexp "\" in files (default "   grep-tree-last-files  "): ")))
           (dir
-           (file-name-as-directory
-            (read-directory-name "Base directory: " nil default-directory t))))
+           (read-directory-name "Base directory: " nil default-directory t)))
      (list regexp files dir)))
   (unless grep-tree-command
     (grep-compute-defaults))
@@ -556,7 +555,7 @@ those sub directories of DIR."
                          nil)  ;; we change default-directory to dir
                        (and grep-tree-ignore-CVS-directories "-path '*/CVS' -prune -o ")
                        grep-tree-ignore-case))
-        (default-directory dir)
+        (default-directory (file-name-as-directory (expand-file-name dir)))
         (null-device nil))              ; see grep
     (grep command-args regexp)))
 
diff --git a/lisp/simple.el b/lisp/simple.el
index 1a1d80bcd41..9187c0db484 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -785,6 +785,23 @@ If nil, don't change the value of `debug-on-error'."
   :type 'boolean
   :version "21.1")
 
+(defun eval-expression-print-format (value)
+  "Format VALUE as a result of evaluated expression.
+Return a formatted string which is displayed in the echo area
+in addition to the value printed by prin1 in functions which
+display the result of expression evaluation."
+  (if (and (integerp value)
+           (or (not (eq this-command 'eval-last-sexp))
+               (eq this-command last-command)
+               (and (boundp 'edebug-active) edebug-active)))
+      (let ((char-string
+             (if (or (and (boundp 'edebug-active) edebug-active)
+                     (eq this-command 'eval-last-sexp))
+                 (prin1-char value))))
+        (if char-string
+            (format " (0%o, 0x%x) = %s" value value char-string)
+          (format " (0%o, 0x%x)" value value)))))
+
 ;; We define this, rather than making `eval' interactive,
 ;; for the sake of completion of names like eval-region, eval-current-buffer.
 (defun eval-expression (eval-expression-arg
@@ -819,7 +836,10 @@ the echo area."
         (with-no-warnings
          (let ((standard-output (current-buffer)))
            (eval-last-sexp-print-value (car values))))
-      (prin1 (car values) t))))
+      (prog1
+          (prin1 (car values) t)
+        (let ((str (eval-expression-print-format (car values))))
+          (if str (princ str t)))))))
 
 (defun edit-and-eval-command (prompt command)
   "Prompting with PROMPT, let user edit COMMAND and eval result.
diff --git a/lisp/startup.el b/lisp/startup.el
index 2402d116734..2b103aee2ce 100644
--- a/lisp/startup.el
+++ b/lisp/startup.el
@@ -1,6 +1,6 @@
 ;;; startup.el --- process Emacs shell arguments
 
-;; Copyright (C) 1985, 86, 92, 94, 95, 96, 97, 98, 99, 2000, 2001, 2002
+;; Copyright (C) 1985, 86, 92, 94, 95, 96, 97, 98, 99, 2000, 01, 02, 2004
 ;;   Free Software Foundation, Inc.
 
 ;; Maintainer: FSF
@@ -578,7 +578,7 @@ opening the first frame (e.g. open a connection to the server).")
         (if (eq system-type 'ms-dos)
             (getenv "TMPDIR")))
   (setq auto-save-file-name-transforms
-        (list (list "\\`/[^/]*:\\(.+/\\)*\\(.*\\)"
+        (list (list (car (car auto-save-file-name-transforms))
                     ;; Don't put "\\2" inside expand-file-name, since
                     ;; it will be transformed to "/2" on DOS/Windows.
                     (concat temporary-file-directory "\\2") t)))
diff --git a/lisp/subr.el b/lisp/subr.el
index 8559de28746..59620d1bb7e 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -1796,20 +1796,11 @@ The value returned is the value of the last form in BODY.
 This does not alter the buffer list ordering.
 See also `with-temp-buffer'."
   (declare (indent 1) (debug t))
-  ;; Most of this code is a copy of save-selected-window.
-  `(let ((save-selected-window-window (selected-window))
-         (save-selected-window-alist
-          (mapcar (lambda (frame) (list frame (frame-selected-window frame)))
-                  (frame-list))))
+  `(let ((save-selected-window-window (selected-window)))
      (unwind-protect
          (progn (select-window ,window 'norecord)
                 ,@body)
-       (dolist (elt save-selected-window-alist)
-         (and (frame-live-p (car elt))
-              (window-live-p (cadr elt))
-              (set-frame-selected-window (car elt) (cadr elt))))
        (if (window-live-p save-selected-window-window)
-           ;; This is where the code differs from save-selected-window.
            (select-window save-selected-window-window 'norecord)))))
 
 (defmacro with-selected-frame (frame &rest body)
diff --git a/lisp/textmodes/artist.el b/lisp/textmodes/artist.el
index e4f143c3b87..9535d39b1d1 100644
--- a/lisp/textmodes/artist.el
+++ b/lisp/textmodes/artist.el
@@ -1,6 +1,6 @@
 ;;; artist.el --- draw ascii graphics with your mouse
 
-;; Copyright (C) 2000, 2001 Free Software Foundation, Inc.
+;; Copyright (C) 2000, 2001, 2004 Free Software Foundation, Inc.
 
 ;; Author:       Tomas Abrahamsson <tab@lysator.liu.se>
 ;; Maintainer:   Tomas Abrahamsson <tab@lysator.liu.se>
@@ -1698,19 +1698,14 @@ info-variant-part."
         (t (cons (car l) (artist-butlast (cdr l))))))
 
 
-(defun artist-last (seq &optional n)
-  "Return the last link in the list SEQ.
+(defun artist-last (l &optional n)
+  "Return the last link in the list L.
 With optional argument N, returns Nth-to-last link (default 1)."
-  (if (not n)
-      (setq n 1))
-  (let ((len (length seq)))
-    (elt seq (- len n))))
+  (nth (- (length l) (or n 1)) l))
 
 (defun artist-remove-nulls (l)
   "Remove nils in list L."
-  (cond ((null l) nil)
-        ((null (car l)) (artist-remove-nulls (cdr l)))
-        (t (cons (car l) (artist-remove-nulls (cdr l))))))
+  (remq nil l))
 
 (defun artist-uniq (l)
   "Remove consecutive duplicates in list L.  Comparison is done with `equal'."
@@ -3368,8 +3363,8 @@ The POINT-LIST is expected to cover the first quadrant."
     (append right-half left-half)))
 
 
-(defun artist-draw-ellipse-general (x y x-radius y-radius)
-  "Draw an ellipse with center at X, Y and X-RADIUS and Y-RADIUS.
+(defun artist-draw-ellipse-general (x1 y1 x-radius y-radius)
+  "Draw an ellipse with center at X1, Y1 and X-RADIUS and Y-RADIUS.
 
 Output is an ellipse, which is a list (END-POINT-1 END-POINT-2 SHAPE-INFO).
 
@@ -3379,15 +3374,15 @@ SHAPE-INFO is a two-element vector on the form [POINT-LIST FILL-INFO].
 POINT-LIST is a list of vectors on the form [X Y SAVED-CHAR NEW-CHAR].
 FILL-INFO is a list of vectors on the form [X Y ELLIPSE-WIDTH-ON-THIS-LINE].
 
-Ellipses with zero y-radius are not drawn correctly."
+Ellipses with zero Y-RADIUS are not drawn correctly."
   (let* ((point-list   (artist-ellipse-generate-quadrant x-radius y-radius))
          (fill-info    (artist-ellipse-compute-fill-info point-list))
          (shape-info   (make-vector 2 0)))
 
     (setq point-list (artist-calculate-new-chars point-list))
     (setq point-list (artist-ellipse-mirror-quadrant point-list))
-    (setq point-list (artist-ellipse-point-list-add-center x y point-list))
-    (setq fill-info (artist-ellipse-fill-info-add-center x y fill-info))
+    (setq point-list (artist-ellipse-point-list-add-center x1 y1 point-list))
+    (setq fill-info (artist-ellipse-fill-info-add-center x1 y1 fill-info))
 
     ;; Draw the ellipse
     (setq point-list
@@ -3404,12 +3399,12 @@ Ellipses with zero y-radius are not drawn correctly."
 
     (aset shape-info 0 point-list)
     (aset shape-info 1 fill-info)
-    (artist-make-2point-object (artist-make-endpoint x y)
+    (artist-make-2point-object (artist-make-endpoint x1 y1)
                                (artist-make-endpoint x-radius y-radius)
                                shape-info)))
 
-(defun artist-draw-ellipse-with-0-height (x y x-radius y-radius)
-  "Draw an ellipse with center at X, Y and X-RADIUS and Y-RADIUS.
+(defun artist-draw-ellipse-with-0-height (x1 y1 x-radius y-radius)
+  "Draw an ellipse with center at X1, Y1 and X-RADIUS and Y-RADIUS.
 
 Output is an ellipse, which is a list (END-POINT-1 END-POINT-2 SHAPE-INFO).
 
@@ -3419,10 +3414,10 @@ SHAPE-INFO is a two-element vector on the form [POINT-LIST FILL-INFO].
 POINT-LIST is a list of vectors on the form [X Y SAVED-CHAR NEW-CHAR].
 FILL-INFO is a list of vectors on the form [X Y ELLIPSE-WIDTH-ON-THIS-LINE].
 
-The Y-RADIUS must be 0, but the X-RADUIS must not be 0."
+The Y-RADIUS must be 0, but the X-RADIUS must not be 0."
   (let ((point-list nil)
         (width      (max (- (abs (* 2 x-radius)) 1)))
-        (left-edge  (1+ (- x (abs x-radius))))
+        (left-edge  (1+ (- x1 (abs x-radius))))
         (line-char  (if artist-line-char-set artist-line-char ?-))
         (i          0)
         (point-list nil)
@@ -3430,7 +3425,7 @@ The Y-RADIUS must be 0, but the X-RADUIS must not be 0."
         (shape-info (make-vector 2 0)))
     (while (< i width)
       (let* ((line-x (+ left-edge i))
-             (line-y y)
+             (line-y y1)
              (new-coord (artist-new-coord line-x line-y)))
         (artist-coord-add-saved-char new-coord
                                      (artist-get-char-at-xy line-x line-y))
@@ -3440,7 +3435,7 @@ The Y-RADIUS must be 0, but the X-RADUIS must not be 0."
         (setq i (1+ i))))
     (aset shape-info 0 point-list)
     (aset shape-info 1 fill-info)
-    (artist-make-2point-object (artist-make-endpoint x y)
+    (artist-make-2point-object (artist-make-endpoint x1 y1)
                                (artist-make-endpoint x-radius y-radius)
                                shape-info)))
 
@@ -3954,7 +3949,7 @@ The 2-point shape SHAPE is drawn from X1, Y1 to X2, Y2."
 
 (defun artist-draw-region-trim-line-endings (min-y max-y)
   "Trim lines in current draw-region from MIN-Y to MAX-Y.
-Trimming here means removing white space at end of a line"
+Trimming here means removing white space at end of a line."
   ;; Safetyc check: switch min-y and max-y if if max-y is smaller
   (if (< max-y min-y)
       (let ((tmp min-y))
@@ -4286,7 +4281,7 @@ If optional argument THIS-IS-LAST-POINT is non-nil, this point is the last."
 
 (defun artist-key-set-point-common (arg)
   "Common routine for setting point in current shape.
-With ARG set to t, set the last point."
+With non-nil ARG, set the last point."
   (let ((draw-how    (artist-go-get-draw-how-from-symbol artist-curr-go))
         (col         (artist-current-column))
         (row         (artist-current-line))
@@ -4793,7 +4788,7 @@ If optional argument STATE is positive, turn borders on."
 
 
 (defun artist-mouse-choose-operation (ev op)
-  "Choose operation for evenvt EV and operation OP."
+  "Choose operation for event EV and operation OP."
   (interactive
    (progn
      (select-window (posn-window (event-start last-input-event)))
diff --git a/lisp/vc-arch.el b/lisp/vc-arch.el
index c8efca02832..6c67581a5a8 100644
--- a/lisp/vc-arch.el
+++ b/lisp/vc-arch.el
@@ -375,7 +375,7 @@ Return non-nil if FILE is unchanged."
     (vc-arch-command nil 0 file "commit" "-s" summary "-L" comment "--"
                      (vc-switches 'Arch 'checkin))))
 
-(defun vc-arch-diff (file &optional oldvers newvers)
+(defun vc-arch-diff (file &optional oldvers newvers buffer)
   "Get a difference report using Arch between two versions of FILE."
   (if (and newvers
            (vc-up-to-date-p file)
@@ -390,7 +390,7 @@ Return non-nil if FILE is unchanged."
            (default-directory (vc-arch-root file))
            (status
             (vc-arch-command
-             "*vc-diff*"
+             (or buffer "*vc-diff*")
              (if async 'async 1)
              nil "file-diffs"
              ;; Arch does not support the typical flags.
diff --git a/lisp/vc-mcvs.el b/lisp/vc-mcvs.el
index 94beb7eb093..5c0bac48b3a 100644
--- a/lisp/vc-mcvs.el
+++ b/lisp/vc-mcvs.el
@@ -438,17 +438,17 @@ The changes are between FIRST-VERSION and SECOND-VERSION."
 ;;; History functions
 ;;;
 
-(defun vc-mcvs-print-log (file)
+(defun vc-mcvs-print-log (file &optional buffer)
   "Get change log associated with FILE."
   (let ((default-directory (vc-mcvs-root file)))
     ;; Run the command from the root dir so that `mcvs filt' returns
     ;; valid relative names.
     (vc-mcvs-command
-     nil
+     buffer
      (if (and (vc-stay-local-p file) (fboundp 'start-process)) 'async 0)
      file "log")))
 
-(defun vc-mcvs-diff (file &optional oldvers newvers)
+(defun vc-mcvs-diff (file &optional oldvers newvers buffer)
   "Get a difference report using Meta-CVS between two versions of FILE."
   (if (string= (vc-workfile-version file) "0")
       ;; This file is added but not yet committed; there is no master file.
@@ -457,7 +457,7 @@ The changes are between FIRST-VERSION and SECOND-VERSION."
         ;; We regard this as "changed".
         ;; Diff it against /dev/null.
         ;; Note: this is NOT a "mcvs diff".
-        (apply 'vc-do-command "*vc-diff*"
+        (apply 'vc-do-command (or buffer "*vc-diff*")
                1 "diff" file
                (append (vc-switches nil 'diff) '("/dev/null")))
         ;; Even if it's empty, it's locally modified.
@@ -467,7 +467,7 @@ The changes are between FIRST-VERSION and SECOND-VERSION."
            ;; valid relative names.
            (default-directory (vc-mcvs-root file))
            (status
-            (apply 'vc-mcvs-command "*vc-diff*"
+            (apply 'vc-mcvs-command (or buffer "*vc-diff*")
                    (if async 'async 1)
                    file "diff"
                    (and oldvers (concat "-r" oldvers))
diff --git a/lisp/w32-fns.el b/lisp/w32-fns.el
index 172af902cb9..4a485414d7a 100644
--- a/lisp/w32-fns.el
+++ b/lisp/w32-fns.el
@@ -1,6 +1,6 @@
 ;;; w32-fns.el --- Lisp routines for Windows NT
 
-;; Copyright (C) 1994, 2001 Free Software Foundation, Inc.
+;; Copyright (C) 1994, 2001, 2004 Free Software Foundation, Inc.
 
 ;; Author: Geoff Voelker <voelker@cs.washington.edu>
 ;; Keywords: internal
@@ -54,7 +54,8 @@ numbers, and the build number."
   (x-server-version))
 
 (defun w32-using-nt ()
-  "Return non-nil if literally running on Windows NT (i.e., not Windows 9X)."
+  "Return non-nil if running on a 32-bit Windows system.
+That includes all Windows systems except for 9X/Me."
   (and (eq system-type 'windows-nt) (getenv "SystemRoot")))
 
 (defun w32-shell-name ()
@@ -71,7 +72,7 @@ numbers, and the build number."
                w32-system-shells)))
 
 (defun w32-shell-dos-semantics ()
-  "Return t if the interactive shell being used expects msdos shell semantics."
+  "Return non-nil if the interactive shell being used expects MSDOS shell semantics."
   (or (w32-system-shell-p (w32-shell-name))
       (and (member (downcase (file-name-nondirectory (w32-shell-name)))
                    '("cmdproxy" "cmdproxy.exe"))
@@ -265,13 +266,13 @@ with a definition that really does change some file names."
   (get 'x-selections type))
 
 (defun set-w32-system-coding-system (coding-system)
-  "Set the coding system used by the Windows System to CODING-SYSTEM.
+  "Set the coding system used by the Windows system to CODING-SYSTEM.
 This is used for things like passing font names with non-ASCII
 characters in them to the system. For a list of possible values of
 CODING-SYSTEM, use \\[list-coding-systems].
 
 This function is provided for backward compatibility, since
-w32-system-coding-system is now an alias for `locale-coding-system'."
+`w32-system-coding-system' is now an alias for `locale-coding-system'."
   (interactive
    (list (let ((default locale-coding-system))
            (read-coding-system
diff --git a/man/ChangeLog b/man/ChangeLog
index 30247e10435..ffd8bae6a2e 100644
--- a/man/ChangeLog
+++ b/man/ChangeLog
@@ -1,3 +1,12 @@
+2004-05-28  Simon Josefsson  <jas@extundo.com>
+
+        * smtpmail.texi (Authentication): Improve STARTTLS discussion.
+
+2004-05-27  Luc Teirlinck  <teirllm@auburn.edu>
+
+        * dired.texi (Dired and Find): `find-ls-option' does not apply to
+        `M-x locate'.
+
 2004-05-16  Karl Berry  <karl@gnu.org>
 
         * emacs.texi (ack.texi) [@ifnottex]: Change condition; with @ifinfo,
diff --git a/man/dired.texi b/man/dired.texi
index 88e994ed027..fd269811b9f 100644
--- a/man/dired.texi
+++ b/man/dired.texi
@@ -1079,6 +1079,12 @@ minibuffer arguments, @var{directory} and @var{find-args}; it runs
 @code{find} what condition to test.  To use this command, you need to
 know how to use @code{find}.
 
+@vindex find-ls-option
+  The format of listing produced by these commands is controlled by the
+variable @code{find-ls-option}, whose default value specifies using
+options @samp{-ld} for @code{ls}.  If your listings are corrupted, you
+may need to change the value of this variable.
+
 @findex locate
 @findex locate-with-filter
 @cindex file database (locate)
@@ -1087,12 +1093,6 @@ know how to use @code{find}.
 program.  @kbd{M-x locate-with-filter} is similar, but keeps only lines
 matching a given regular expression.
 
-@vindex find-ls-option
-  The format of listing produced by these commands is controlled by the
-variable @code{find-ls-option}, whose default value specifies using
-options @samp{-ld} for @code{ls}.  If your listings are corrupted, you
-may need to change the value of this variable.
-
 @node Misc Dired Commands
 @section Other Dired Commands
 
diff --git a/man/smtpmail.texi b/man/smtpmail.texi
index 08ce87ac995..6efe6f71630 100644
--- a/man/smtpmail.texi
+++ b/man/smtpmail.texi
@@ -215,13 +215,30 @@ variables contains the authentication information needed for this.
 The first variable, @code{smtpmail-auth-credentials}, instructs the
 SMTP library to use a SASL authentication step, currently only the
 CRAM-MD5 and LOGIN mechanisms are supported and will be selected in
-that order if the server supports them.  The second variable,
-@code{smtpmail-starttls-credentials}, instructs the SMTP library to
-connect to the server using STARTTLS.  This means the protocol
-exchange can be integrity protected and confidential by using TLS, and
-optionally also authentication of the client.  It is common to use
-both these mechanisms, e.g., to use STARTTLS to achieve integrity and
-confidentiality and then use SASL for client authentication.
+that order if the server support both.
+
+The second variable, @code{smtpmail-starttls-credentials}, instructs
+the SMTP library to connect to the server using STARTTLS.  This means
+the protocol exchange may be integrity protected and confidential by
+using TLS, and optionally also authentication of the client.  This
+feature uses the elisp package @file{starttls.el} (see it for more
+information on customization), which in turn require that at least one
+of the following external tools are installed:
+
+@enumerate
+@item
+The GNUTLS command line tool @samp{gnutls-cli}, you can get it from
+@url{http://www.gnu.org/software/gnutls/}.  This is the recommended
+tool, mainly because it can verify the server certificates.
+
+@item
+The @samp{starttls} external program, you can get it from
+@file{starttls-*.tar.gz} from @uref{ftp://ftp.opaopa.org/pub/elisp/}.
+@end enumerate
+
+It is not uncommon to use both these mechanisms, e.g., to use STARTTLS
+to achieve integrity and confidentiality and then use SASL for client
+authentication.
 
 @table @code
 @item smtpmail-auth-credentials
@@ -231,11 +248,13 @@ hostname, port, username and password tuples.  When the SMTP library
 connects to a host on a certain port, this variable is searched to
 find a matching entry for that hostname and port.  If an entry is
 found, the authentication process is invoked and the credentials are
-used.  The hostname field follows the same format as
+used.
+
+The hostname field follows the same format as
 @code{smtpmail-smtp-server} (i.e., a string) and the port field the
 same format as @code{smtpmail-smtp-service} (i.e., a string or an
 integer).  The username and password fields, which either can be
-@code{nil} to indicate that the user is queried for the value
+@code{nil} to indicate that the user is prompted for the value
 interactively, should be strings with the username and password,
 respectively, information that is normally provided by system
 administrators.
@@ -246,10 +265,7 @@ administrators.
 tuples with hostname, port, name of file containing client key, and
 name of file containing client certificate.  The processing is similar
 to the previous variable.  The client key and certificate may be
-@code{nil} if you do not wish to use client authentication.  The use
-of this variable requires the @samp{starttls} external program to be
-installed, you can get @file{starttls-*.tar.gz} from
-@uref{ftp://ftp.opaopa.org/pub/elisp/}.
+@code{nil} if you do not wish to use client authentication.
 @end table
 
 The following example illustrates what you could put in
diff --git a/src/.arch-inventory b/src/.arch-inventory
new file mode 100644
index 00000000000..9f6d601a788
--- /dev/null
+++ b/src/.arch-inventory
@@ -0,0 +1,3 @@
+precious ^(config\.stamp|config\.h|epaths\.h)$
+
+# arch-tag: 277cc7ae-b3f5-44af-abf1-84c073164543
diff --git a/src/ChangeLog b/src/ChangeLog
index f15b1e582d9..df10f95e500 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,35 @@
+2004-05-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * alloc.c: Undo Kim's recent changes and fix the same bug differently.
+        (marker_blocks_pending_free): Remove.
+        (Fgarbage_collect): Sweep after cleaning up undo-lists.
+        Mark the undo lists after claning them up.
+        Don't free block in marker_blocks_pending_free.
+        (mark_buffer): Don't mark undo_list.
+        (gc_sweep): Sweep hash-tables and strings first.
+        Do free marker blocks that are empty.
+
+2004-05-28  Jim Blandy  <jimb@redhat.com>
+
+        * regex.c (print_partial_compiled_pattern): Add missing 'break'
+        after 'case wordend'.  For symbeg and symend, print to stderr,
+        like the other cases.
+
+2004-05-28  Noah Friedman  <friedman@splode.com>
+
+        * process.c (Fdelete_process): Do not call remove_process.
+
+2004-05-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * alloc.c (struct backtrace): Remove.
+        (Fgarbage_collect): Use the new mark_backtrace.
+
+        * eval.c (mark_backtrace): New function.
+
+        * minibuf.c (run_exit_minibuf_hook): New function.
+        (read_minibuf_unwind): Don't run exit-minibuffer-hook any more.
+        (read_minibuf): Use separate unwind handler to run exit-minibuf-hook.
+
 2004-05-27  Kim F. Storm  <storm@cua.dk>
 
         * xdisp.c (back_to_previous_visible_line_start): Skip backwards
@@ -15,8 +47,8 @@
 
 2004-05-23  K,Ba(Broly L,Bu(Brentey  <lorentey@elte.hu>  (tiny change)
 
-        * coding.c (Fset_safe_terminal_coding_system_internal): Set
-        suppress_error in safe_terminal_coding, not terminal_coding.
+        * coding.c (Fset_safe_terminal_coding_system_internal):
+        Set suppress_error in safe_terminal_coding, not terminal_coding.
 
 2004-05-22  Richard M. Stallman  <rms@gnu.org>
 
@@ -71,7 +103,7 @@
         (re_opcode_t): New opcodes `symbeg' and `symend'.
         (print_partial_compiled_pattern): Print the new opcodes properly.
         (regex_compile): Parse the new operators.
-        (analyse_first): Skip symbeg and symend (they match only the empty string).
+        (analyse_first): Skip sym(beg|end) (they match only the empty string).
         (mutually_exclusive_p): `symend' is mutually exclusive with \s_ and
         \sw; `symbeg' is mutually exclusive with \S_ and \Sw.
         (re_match_2_internal): Match symbeg and symend.
diff --git a/src/alloc.c b/src/alloc.c
index 1d50f19e921..adedb414aad 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -257,6 +257,7 @@ EMACS_INT gcs_done;		/* accumulated GCs  */
 static void mark_buffer P_ ((Lisp_Object));
 extern void mark_kboards P_ ((void));
 extern void mark_ttys P_ ((void));
+extern void mark_backtrace P_ ((void));
 static void gc_sweep P_ ((void));
 static void mark_glyph_matrix P_ ((struct glyph_matrix *));
 static void mark_face_cache P_ ((struct face_cache *));
@@ -2866,10 +2867,6 @@ int marker_block_index;
 
 union Lisp_Misc *marker_free_list;
 
-/* Marker blocks which should be freed at end of GC.  */
-
-struct marker_block *marker_blocks_pending_free;
-
 /* Total number of marker blocks now in use.  */
 
 int n_marker_blocks;
@@ -2880,7 +2877,6 @@ init_marker ()
   marker_block = NULL;
   marker_block_index = MARKER_BLOCK_SIZE;
   marker_free_list = 0;
-  marker_blocks_pending_free = 0;
   n_marker_blocks = 0;
 }
 
@@ -4283,20 +4279,6 @@ struct catchtag
     struct catchtag *next;
 };
 
-struct backtrace
-{
-  struct backtrace *next;
-  Lisp_Object *function;
-  Lisp_Object *args;    /* Points to vector of args.  */
-  int nargs;            /* Length of vector.  */
-  /* If nargs is UNEVALLED, args points to slot holding list of
-     unevalled args.  */
-  char evalargs;
-  /* Nonzero means call value of debugger when done with this operation. */
-  char debug_on_exit;
-};
-
-
 
 /***********************************************************************
                           Protection from GC
@@ -4331,7 +4313,6 @@ returns nil, because real GC can't be done.  */)
   register struct specbinding *bind;
   struct catchtag *catch;
   struct handler *handler;
-  register struct backtrace *backlist;
   char stack_top_variable;
   register int i;
   int message_p;
@@ -4460,17 +4441,7 @@ returns nil, because real GC can't be done.  */)
       mark_object (handler->handler);
       mark_object (handler->var);
     }
-  for (backlist = backtrace_list; backlist; backlist = backlist->next)
-    {
-      mark_object (*backlist->function);
-
-      if (backlist->nargs == UNEVALLED || backlist->nargs == MANY)
-        i = 0;
-      else
-        i = backlist->nargs - 1;
-      for (; i >= 0; i--)
-        mark_object (backlist->args[i]);
-    }
+  mark_backtrace ();
   mark_kboards ();
   mark_ttys ();
 
@@ -4485,42 +4456,36 @@ returns nil, because real GC can't be done.  */)
   }
 #endif
 
-  gc_sweep ();
-
-  /* Look thru every buffer's undo list for elements that used to
-     contain update markers that were changed to Lisp_Misc_Free
-     objects and delete them.  This may leave a few cons cells
-     unchained, but we will get those on the next sweep.  */
+  /* Everything is now marked, except for the things that require special
+     finalization, i.e. the undo_list.
+     Look thru every buffer's undo list
+     for elements that update markers that were not marked,
+     and delete them.  */
   {
     register struct buffer *nextb = all_buffers;
 
     while (nextb)
       {
         /* If a buffer's undo list is Qt, that means that undo is
-           turned off in that buffer.  */
+           turned off in that buffer.  Calling truncate_undo_list on
+           Qt tends to return NULL, which effectively turns undo back on.
+           So don't call truncate_undo_list if undo_list is Qt.  */
         if (! EQ (nextb->undo_list, Qt))
           {
-            Lisp_Object tail, prev, elt, car;
+            Lisp_Object tail, prev;
             tail = nextb->undo_list;
             prev = Qnil;
             while (CONSP (tail))
               {
-                if ((elt = XCAR (tail), GC_CONSP (elt))
-                    && (car = XCAR (elt), GC_MISCP (car))
-                    && XMISCTYPE (car) == Lisp_Misc_Free)
+                if (GC_CONSP (XCAR (tail))
+                    && GC_MARKERP (XCAR (XCAR (tail)))
+                    && !XMARKER (XCAR (XCAR (tail)))->gcmarkbit)
                   {
-                    Lisp_Object cdr = XCDR (tail);
-                    /* Do not use free_cons here, as we don't know if
-                       anybody else has a pointer to these conses.  */
-                    XSETCAR (elt, Qnil);
-                    XSETCDR (elt, Qnil);
-                    XSETCAR (tail, Qnil);
-                    XSETCDR (tail, Qnil);
                     if (NILP (prev))
-                      nextb->undo_list = tail = cdr;
+                      nextb->undo_list = tail = XCDR (tail);
                     else
                       {
-                        tail = cdr;
+                        tail = XCDR (tail);
                         XSETCDR (prev, tail);
                       }
                   }
@@ -4531,22 +4496,15 @@ returns nil, because real GC can't be done.  */)
                   }
               }
           }
+        /* Now that we have stripped the elements that need not be in the
+           undo_list any more, we can finally mark the list.  */
+        mark_object (nextb->undo_list);
 
         nextb = nextb->next;
       }
   }
 
-  /* Undo lists have been cleaned up, so we can free marker blocks now.  */
-
-  {
-    struct marker_block *mblk;
-
-    while ((mblk = marker_blocks_pending_free) != 0)
-      {
-        marker_blocks_pending_free = mblk->next;
-        lisp_free (mblk);
-      }
-  }
+  gc_sweep ();
 
   /* Clear the mark bits that we set in certain root slots.  */
 
@@ -5114,41 +5072,9 @@ mark_buffer (buf)
 
   MARK_INTERVAL_TREE (BUF_INTERVALS (buffer));
 
-  if (CONSP (buffer->undo_list))
-    {
-      Lisp_Object tail;
-      tail = buffer->undo_list;
-
-      /* We mark the undo list specially because
-         its pointers to markers should be weak.  */
-
-      while (CONSP (tail))
-        {
-          register struct Lisp_Cons *ptr = XCONS (tail);
-
-          if (CONS_MARKED_P (ptr))
-            break;
-          CONS_MARK (ptr);
-          if (GC_CONSP (ptr->car)
-              && !CONS_MARKED_P (XCONS (ptr->car))
-              && GC_MARKERP (XCAR (ptr->car)))
-            {
-              CONS_MARK (XCONS (ptr->car));
-              mark_object (XCDR (ptr->car));
-            }
-          else
-            mark_object (ptr->car);
-
-          if (CONSP (ptr->cdr))
-            tail = ptr->cdr;
-          else
-            break;
-        }
-
-      mark_object (XCDR (tail));
-    }
-  else
-    mark_object (buffer->undo_list);
+  /* For now, we just don't mark the undo_list.  It's done later in
+     a special way just before the sweep phase, and after stripping
+     some of its elements that are not needed any more.  */
 
   if (buffer->overlays_before)
     {
@@ -5228,6 +5154,16 @@ survives_gc_p (obj)
 static void
 gc_sweep ()
 {
+  /* Remove or mark entries in weak hash tables.
+     This must be done before any object is unmarked.  */
+  sweep_weak_hash_tables ();
+
+  sweep_strings ();
+#ifdef GC_CHECK_STRING_BYTES
+  if (!noninteractive)
+    check_string_bytes (1);
+#endif
+
   /* Put all unmarked conses on free list */
   {
     register struct cons_block *cblk;
@@ -5278,16 +5214,6 @@ gc_sweep ()
     total_free_conses = num_free;
   }
 
-  /* Remove or mark entries in weak hash tables.
-     This must be done before any object is unmarked.  */
-  sweep_weak_hash_tables ();
-
-  sweep_strings ();
-#ifdef GC_CHECK_STRING_BYTES
-  if (!noninteractive)
-    check_string_bytes (1);
-#endif
-
   /* Put all unmarked floats on free list */
   {
     register struct float_block *fblk;
@@ -5456,7 +5382,6 @@ gc_sweep ()
     register int num_free = 0, num_used = 0;
 
     marker_free_list = 0;
-    marker_blocks_pending_free = 0;
 
     for (mblk = marker_block; mblk; mblk = *mprev)
       {
@@ -5492,13 +5417,8 @@ gc_sweep ()
             *mprev = mblk->next;
             /* Unhook from the free list.  */
             marker_free_list = mblk->markers[0].u_free.chain;
+            lisp_free (mblk);
             n_marker_blocks--;
-
-            /* It is not safe to free the marker block at this stage,
-               since there may still be pointers to these markers from
-               a buffer's undo list.  KFS 2004-05-25.  */
-            mblk->next = marker_blocks_pending_free;
-            marker_blocks_pending_free = mblk;
           }
         else
           {
diff --git a/src/eval.c b/src/eval.c
index 0326a828a81..921a7533a60 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -3243,6 +3243,25 @@ If NFRAMES is more than the number of frames, the value is nil.  */)
 
 
 void
+mark_backtrace ()
+{
+  register struct backtrace *backlist;
+  register int i;
+
+  for (backlist = backtrace_list; backlist; backlist = backlist->next)
+    {
+      mark_object (*backlist->function);
+
+      if (backlist->nargs == UNEVALLED || backlist->nargs == MANY)
+        i = 0;
+      else
+        i = backlist->nargs - 1;
+      for (; i >= 0; i--)
+        mark_object (backlist->args[i]);
+    }
+}
+
+void
 syms_of_eval ()
 {
   DEFVAR_INT ("max-specpdl-size", &max_specpdl_size,
diff --git a/src/minibuf.c b/src/minibuf.c
index 1f5a114540d..8ed19516080 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -1,5 +1,5 @@
 /* Minibuffer input and completion.
-   Copyright (C) 1985,86,93,94,95,96,97,98,99,2000,01,03
+   Copyright (C) 1985,86,93,94,95,96,97,98,99,2000,01,03,04
              Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
@@ -210,6 +210,7 @@ without invoking the usual minibuffer commands.  */)
 /* Actual minibuffer invocation. */
 
 static Lisp_Object read_minibuf_unwind P_ ((Lisp_Object));
+static Lisp_Object run_exit_minibuf_hook P_ ((Lisp_Object));
 static Lisp_Object read_minibuf P_ ((Lisp_Object, Lisp_Object,
                                      Lisp_Object, Lisp_Object,
                                      int, Lisp_Object,
@@ -564,6 +565,12 @@ read_minibuf (map, initial, prompt, backup_n, expflag,
 
   record_unwind_protect (read_minibuf_unwind, Qnil);
   minibuf_level++;
+  /* We are exiting the minibuffer one way or the other, so run the hook.
+     It should be run before unwinding the minibuf settings.  Do it
+     separately from read_minibuf_unwind because we need to make sure that
+     read_minibuf_unwind is fully executed even if exit-minibuffer-hook
+     signals an error.  --Stef  */
+  record_unwind_protect (run_exit_minibuf_hook, Qnil);
 
   /* Now that we can restore all those variables, start changing them.  */
 
@@ -827,6 +834,17 @@ get_minibuffer (depth)
   return buf;
 }
 
+static Lisp_Object
+run_exit_minibuf_hook (data)
+     Lisp_Object data;
+{
+  if (!NILP (Vminibuffer_exit_hook) && !EQ (Vminibuffer_exit_hook, Qunbound)
+      && !NILP (Vrun_hooks))
+    safe_run_hooks (Qminibuffer_exit_hook);
+
+  return Qnil;
+}
+
 /* This function is called on exiting minibuffer, whether normally or
    not, and it restores the current window, buffer, etc. */
 
@@ -837,12 +855,6 @@ read_minibuf_unwind (data)
   Lisp_Object old_deactivate_mark;
   Lisp_Object window;
 
-  /* We are exiting the minibuffer one way or the other,
-     so run the hook.  */
-  if (!NILP (Vminibuffer_exit_hook) && !EQ (Vminibuffer_exit_hook, Qunbound)
-      && !NILP (Vrun_hooks))
-    safe_run_hooks (Qminibuffer_exit_hook);
-
   /* If this was a recursive minibuffer,
      tie the minibuffer window back to the outer level minibuffer buffer.  */
   minibuf_level--;
diff --git a/src/process.c b/src/process.c
index 9d76b5bd1f9..c05bcbf88d5 100644
--- a/src/process.c
+++ b/src/process.c
@@ -774,7 +774,18 @@ nil, indicating the current buffer's process.  */)
       XSETINT (XPROCESS (process)->tick, ++process_tick);
       status_notify ();
     }
-  remove_process (process);
+  /* Do not call remove_process here; either status_notify has already done
+     it, or will do so the next time emacs polls for input.  Thus network
+     processes are not immediately removed, and their sentinel will be
+     called.
+
+     Since Fdelete_process is called by kill_buffer_processes, this also
+     means that a network process sentinel will run after the buffer is
+     dead, which would not be the case if status_notify() were called
+     unconditionally here.  This way process sentinels observe consistent
+     behavior with regard to buffer-live-p.
+  */
+  /* remove_process (process); */
   return Qnil;
 }
 
diff --git a/src/regex.c b/src/regex.c
index 0c1343bf584..db69275c312 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -1096,13 +1096,14 @@ print_partial_compiled_pattern (start, end)
 
         case wordend:
           fprintf (stderr, "/wordend");
+          break;
 
         case symbeg:
-          printf ("/symbeg");
+          fprintf (stderr, "/symbeg");
           break;
 
         case symend:
-          printf ("/symend");
+          fprintf (stderr, "/symend");
           break;
 
         case syntaxspec: