8 files changed, 197 insertions, 74 deletions

diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 92c402dbad4..63c6aad3aa1 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -395,11 +395,6 @@ that requires a literal mode spec at compile time."
   (make-local-variable 'comment-end)
   (make-local-variable 'comment-start-skip)
   (make-local-variable 'comment-multi-line)
-  (make-local-variable 'paragraph-start)
-  (make-local-variable 'paragraph-separate)
-  (make-local-variable 'paragraph-ignore-fill-prefix)
-  (make-local-variable 'adaptive-fill-mode)
-  (make-local-variable 'adaptive-fill-regexp)
 
   ;; now set their values
   (setq parse-sexp-ignore-comments t
@@ -1180,5 +1175,5 @@ Key bindings:
 
 (cc-provide 'cc-mode)
 
-;;; arch-tag: 7825e5c4-fd09-439f-a04d-4c13208ba3d7
+;; arch-tag: 7825e5c4-fd09-439f-a04d-4c13208ba3d7
 ;;; cc-mode.el ends here
diff --git a/lisp/progmodes/cc-styles.el b/lisp/progmodes/cc-styles.el
index f0a7a2c4b7c..f20eb8e57de 100644
--- a/lisp/progmodes/cc-styles.el
+++ b/lisp/progmodes/cc-styles.el
@@ -498,33 +498,34 @@ variables."
   (let ((comment-line-prefix
          (concat "[ \t]*\\(" c-current-comment-prefix "\\)[ \t]*")))
 
-    (setq paragraph-start (concat comment-line-prefix
-                                  c-paragraph-start
-                                  "\\|"
-                                  page-delimiter)
-          paragraph-separate (concat comment-line-prefix
-                                     c-paragraph-separate
-                                     "\\|"
-                                     page-delimiter)
-          paragraph-ignore-fill-prefix t
-          adaptive-fill-mode t
-          adaptive-fill-regexp
-          (concat comment-line-prefix
-                  (if (default-value 'adaptive-fill-regexp)
-                      (concat "\\("
-                              (default-value 'adaptive-fill-regexp)
-                              "\\)")
-                    "")))
+    (set (make-local-variable 'paragraph-start)
+         (concat comment-line-prefix
+                 c-paragraph-start
+                 "\\|"
+                 page-delimiter))
+    (set (make-local-variable 'paragraph-separate)
+         (concat comment-line-prefix
+                 c-paragraph-separate
+                 "\\|"
+                 page-delimiter))
+    (set (make-local-variable 'paragraph-ignore-fill-prefix) t)
+    (set (make-local-variable 'adaptive-fill-mode) t)
+    (set (make-local-variable 'adaptive-fill-regexp)
+         (concat comment-line-prefix
+                 (if (default-value 'adaptive-fill-regexp)
+                     (concat "\\("
+                             (default-value 'adaptive-fill-regexp)
+                             "\\)")
+                   "")))
 
     (when (boundp 'adaptive-fill-first-line-regexp)
       ;; XEmacs (20.x) adaptive fill mode doesn't have this.
-      (make-local-variable 'adaptive-fill-first-line-regexp)
-      (setq adaptive-fill-first-line-regexp
-            (concat "\\`" comment-line-prefix
-                    ;; Maybe we should incorporate the old value here,
-                    ;; but then we have to do all sorts of kludges to
-                    ;; deal with the \` and \' it probably contains.
-                    "\\'")))))
+      (set (make-local-variable 'adaptive-fill-first-line-regexp)
+           (concat "\\`" comment-line-prefix
+                   ;; Maybe we should incorporate the old value here,
+                   ;; but then we have to do all sorts of kludges to
+                   ;; deal with the \` and \' it probably contains.
+                   "\\'")))))
 
 
 ;; Helper for setting up Filladapt mode.  It's not used by CC Mode itself.
@@ -626,5 +627,5 @@ any reason to call this function directly."
 
 (cc-provide 'cc-styles)
 
-;;; arch-tag: c764f61a-96ba-484a-a68f-101c0e9d5d2c
+;; arch-tag: c764f61a-96ba-484a-a68f-101c0e9d5d2c
 ;;; cc-styles.el ends here
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index 1655aa33dcb..269fbeaf137 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -899,19 +899,20 @@ visible rather than the beginning."
   :group 'compilation)
 
 
-(defun compilation-buffer-name (mode-name name-function)
+(defun compilation-buffer-name (mode-name mode-command name-function)
   "Return the name of a compilation buffer to use.
 If NAME-FUNCTION is non-nil, call it with one argument MODE-NAME
 to determine the buffer name.
 Likewise if `compilation-buffer-name-function' is non-nil.
-If current buffer is in Compilation mode for the same mode name
+If current buffer is the mode MODE-COMMAND,
 return the name of the current buffer, so that it gets reused.
 Otherwise, construct a buffer name from MODE-NAME."
   (cond (name-function
          (funcall name-function mode-name))
         (compilation-buffer-name-function
          (funcall compilation-buffer-name-function mode-name))
-        ((eq major-mode (nth 1 compilation-arguments))
+        ((and (eq mode-command major-mode)
+              (eq major-mode (nth 1 compilation-arguments)))
          (buffer-name))
         (t
          (concat "*" (downcase mode-name) "*"))))
@@ -960,7 +961,7 @@ Returns the compilation buffer created."
     (with-current-buffer
         (setq outbuf
               (get-buffer-create
-               (compilation-buffer-name name-of-mode name-function)))
+               (compilation-buffer-name name-of-mode mode name-function)))
       (let ((comp-proc (get-buffer-process (current-buffer))))
         (if comp-proc
             (if (or (not (eq (process-status comp-proc) 'run))
@@ -1552,7 +1553,7 @@ Use this command in a compilation log buffer.  Sets the mark at point there."
       (dired-other-window (car (get-text-property (point) 'directory)))
     (push-mark)
     (setq compilation-current-error (point))
-    (next-error 0)))
+    (next-error-internal)))
 
 ;; Return a compilation buffer.
 ;; If the current buffer is a compilation buffer, return it.
diff --git a/lisp/progmodes/ebnf2ps.el b/lisp/progmodes/ebnf2ps.el
index 887e856ba1f..18d88c92699 100644
--- a/lisp/progmodes/ebnf2ps.el
+++ b/lisp/progmodes/ebnf2ps.el
@@ -4261,7 +4261,7 @@ end
               ebnf-eps-max-height prod-height))
        )
       (setq ebnf-eps-prod-width prod-width)
-      (insert-buffer eps-buffer))
+      (insert-buffer-substring eps-buffer))
     (setq prod-list (cdr prod-list))))
 
 
diff --git a/lisp/progmodes/gdb-ui.el b/lisp/progmodes/gdb-ui.el
index 6c960c4c5d5..fe05119d2cd 100644
--- a/lisp/progmodes/gdb-ui.el
+++ b/lisp/progmodes/gdb-ui.el
@@ -103,6 +103,7 @@ and #define directives otherwise.")
 (defvar gdb-error "Non-nil when GDB is reporting an error.")
 (defvar gdb-macro-info nil
   "Non-nil if GDB knows that the inferior includes preprocessor macro info.")
+(defvar gdb-buffer-fringe-width nil)
 
 (defvar gdb-buffer-type nil
   "One of the symbols bound in `gdb-buffer-rules'.")
@@ -377,7 +378,8 @@ Also display the main routine in the disassembly buffer if present."
         gdb-location-alist nil
         gdb-find-file-unhook nil
         gdb-error nil
-        gdb-macro-info nil)
+        gdb-macro-info nil
+        gdb-buffer-fringe-width (car (window-fringes)))
   ;;
   (setq gdb-buffer-type 'gdba)
   ;;
@@ -1337,8 +1339,11 @@ static char *magick[] = {
                 (setq bptno (match-string 1))
                 (setq flag (char-after (match-beginning 2)))
                 (beginning-of-line)
-                (if (re-search-forward " in .* at\\s-+" nil t)
+                (if (re-search-forward " in \\(.*\\) at\\s-+" nil t)
                     (progn
+                      (let ((buffer-read-only nil))
+                        (add-text-properties (match-beginning 1) (match-end 1)
+                                             '(face font-lock-function-name-face)))
                       (looking-at "\\(\\S-+\\):\\([0-9]+\\)")
                       (let ((line (match-string 2)) (buffer-read-only nil)
                             (file (match-string 1)))
@@ -1531,17 +1536,34 @@ static char *magick[] = {
 (defun gdb-info-frames-custom ()
   (with-current-buffer (gdb-get-buffer 'gdb-stack-buffer)
     (save-excursion
-      (let ((buffer-read-only nil))
+      (let ((buffer-read-only nil)
+            bl el)
         (goto-char (point-min))
         (while (< (point) (point-max))
-          (add-text-properties (line-beginning-position) (line-end-position)
+          (setq bl (line-beginning-position)
+                el (line-end-position))
+          (add-text-properties bl el
                              '(mouse-face highlight
                                help-echo "mouse-2, RET: Select frame"))
-          (beginning-of-line)
-          (when (and (looking-at "^#\\([0-9]+\\)")
-                     (equal (match-string 1) gdb-frame-number))
-            (put-text-property (line-beginning-position) (line-end-position)
-                               'face '(:inverse-video t)))
+          (goto-char bl)
+          (when (looking-at "^#\\([0-9]+\\)")
+            (when (string-equal (match-string 1) gdb-frame-number)
+                (put-text-property bl (+ bl 4)
+                                   'face '(:inverse-video t)))
+            (when (re-search-forward
+                   (concat
+                    (if (string-equal (match-string 1) "0") "" " in ")
+                    "\\([^ ]+\\) (") el t)
+              (put-text-property (match-beginning 1) (match-end 1)
+                                 'face font-lock-function-name-face)
+              (setq bl (match-end 0))
+              (while (re-search-forward "<\\([^>]+\\)>" el t)
+                (put-text-property (match-beginning 1) (match-end 1)
+                                     'face font-lock-function-name-face))
+              (goto-char bl)
+              (while (re-search-forward "\\(\\(\\sw\\|[_.]\\)+\\)=" el t)
+                (put-text-property (match-beginning 1) (match-end 1)
+                                   'face font-lock-variable-name-face))))
           (forward-line 1))))))
 
 (defun gdb-stack-buffer-name ()
@@ -1587,6 +1609,7 @@ static char *magick[] = {
 
 (defun gdb-get-frame-number ()
   (save-excursion
+    (end-of-line)
     (let* ((pos (re-search-backward "^#*\\([0-9]*\\)" nil t))
            (n (or (and pos (match-string-no-properties 1)) "0")))
       n)))
@@ -1648,6 +1671,14 @@ static char *magick[] = {
     (define-key map [mouse-2] 'gdb-threads-select)
     map))
 
+(defvar gdb-threads-font-lock-keywords
+  '(
+    (") +\\([^ ]+\\) ("  (1 font-lock-function-name-face))
+    ("in \\([^ ]+\\) ("  (1 font-lock-function-name-face))
+    ("\\(\\(\\sw\\|[_.]\\)+\\)="  (1 font-lock-variable-name-face))
+    )
+  "Font lock keywords used in `gdb-threads-mode'.")
+
 (defun gdb-threads-mode ()
   "Major mode for gdb frames.
 
@@ -1657,6 +1688,8 @@ static char *magick[] = {
   (setq mode-name "Threads")
   (setq buffer-read-only t)
   (use-local-map gdb-threads-mode-map)
+  (set (make-local-variable 'font-lock-defaults)
+       '(gdb-threads-font-lock-keywords))
   (run-mode-hooks 'gdb-threads-mode-hook)
   'gdb-invalidate-threads)
 
@@ -1702,6 +1735,12 @@ static char *magick[] = {
     (define-key map "q" 'kill-this-buffer)
      map))
 
+(defvar gdb-registers-font-lock-keywords
+  '(
+    ("^[^ ]+" . font-lock-variable-name-face)
+    )
+  "Font lock keywords used in `gdb-registers-mode'.")
+
 (defun gdb-registers-mode ()
   "Major mode for gdb registers.
 
@@ -1711,6 +1750,8 @@ static char *magick[] = {
   (setq mode-name "Registers:")
   (setq buffer-read-only t)
   (use-local-map gdb-registers-mode-map)
+  (set (make-local-variable 'font-lock-defaults)
+       '(gdb-registers-font-lock-keywords))
   (run-mode-hooks 'gdb-registers-mode-hook)
   (if (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdba))
       'gdb-invalidate-registers
@@ -1955,6 +1996,12 @@ corresponding to the mode line clicked."
     (define-key map (vector 'header-line 'down-mouse-1) 'ignore)
     map))
 
+(defvar gdb-memory-font-lock-keywords
+  '(;; <__function.name+n>
+    ("<\\(\\(\\sw\\|[_.]\\)+\\)\\(\\+[0-9]+\\)?>" (1 font-lock-function-name-face))
+    )
+  "Font lock keywords used in `gdb-memory-mode'.")
+
 (defun gdb-memory-mode ()
   "Major mode for examining memory.
 
@@ -2026,6 +2073,8 @@ corresponding to the mode line clicked."
                        'help-echo "mouse-3: Select unit size"
                        'mouse-face 'mode-line-highlight
                        'local-map gdb-memory-unit-keymap))))
+  (set (make-local-variable 'font-lock-defaults)
+       '(gdb-memory-font-lock-keywords))
   (run-mode-hooks 'gdb-memory-mode-hook)
   'gdb-invalidate-memory)
 
@@ -2094,6 +2143,23 @@ corresponding to the mode line clicked."
     (define-key map "q" 'kill-this-buffer)
      map))
 
+(defvar gdb-local-font-lock-keywords
+  '(
+    ;; var = (struct struct_tag) value
+    ( "\\(^\\(\\sw\\|[_.]\\)+\\) += +(\\(struct\\) \\(\\(\\sw\\|[_.]\\)+\\)"
+      (1 font-lock-variable-name-face)
+      (3 font-lock-keyword-face)
+      (4 font-lock-type-face))
+    ;; var = (type) value
+    ( "\\(^\\(\\sw\\|[_.]\\)+\\) += +(\\(\\(\\sw\\|[_.]\\)+\\)"
+      (1 font-lock-variable-name-face)
+      (3 font-lock-type-face))
+    ;; var = val
+    ( "\\(^\\(\\sw\\|[_.]\\)+\\) += +[^(]"
+      (1 font-lock-variable-name-face))
+    )
+  "Font lock keywords used in `gdb-local-mode'.")
+
 (defun gdb-locals-mode ()
   "Major mode for gdb locals.
 
@@ -2103,6 +2169,8 @@ corresponding to the mode line clicked."
   (setq mode-name (concat "Locals:" gdb-selected-frame))
   (setq buffer-read-only t)
   (use-local-map gdb-locals-mode-map)
+  (set (make-local-variable 'font-lock-defaults)
+       '(gdb-local-font-lock-keywords))
   (run-mode-hooks 'gdb-locals-mode-hook)
   (if (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdba))
       'gdb-invalidate-locals
@@ -2408,7 +2476,8 @@ BUFFER nil or omitted means use the current buffer."
 (defun gdb-put-breakpoint-icon (enabled bptno)
   (let ((start (- (line-beginning-position) 1))
         (end (+ (line-end-position) 1))
-        (putstring (if enabled "B" "b")))
+        (putstring (if enabled "B" "b"))
+        (source-window (get-buffer-window (current-buffer) 0)))
     (add-text-properties
      0 1 '(help-echo "mouse-1: set/clear bkpt, mouse-3: enable/disable bkpt")
      putstring)
@@ -2418,7 +2487,9 @@ BUFFER nil or omitted means use the current buffer."
        0 1 `(gdb-bptno ,bptno gdb-enabled nil) putstring))
     (gdb-remove-breakpoint-icons start end)
     (if (display-images-p)
-        (if (>= (car (window-fringes)) 8)
+        (if (>= (or left-fringe-width
+                   (if source-window (car (window-fringes source-window)))
+                   gdb-buffer-fringe-width) 8)
             (gdb-put-string
              nil (1+ start)
              `(left-fringe breakpoint
@@ -2428,9 +2499,9 @@ BUFFER nil or omitted means use the current buffer."
           (when (< left-margin-width 2)
             (save-current-buffer
               (setq left-margin-width 2)
-              (if (get-buffer-window (current-buffer) 0)
+              (if source-window
                   (set-window-margins
-                   (get-buffer-window (current-buffer) 0)
+                   source-window
                    left-margin-width right-margin-width))))
           (put-image
            (if enabled
diff --git a/lisp/progmodes/gud.el b/lisp/progmodes/gud.el
index 47d74f00aec..12c7e1c0ba0 100644
--- a/lisp/progmodes/gud.el
+++ b/lisp/progmodes/gud.el
@@ -137,11 +137,15 @@ Used to grey out relevant togolbar icons.")
                   :enable (and (not gud-running)
                                (memq gud-minor-mode '(gdbmi gdba gdb perldb))))
     ([remove]   menu-item "Remove Breakpoint" gud-remove
-                  :enable (not gud-running))
+                  :enable (not gud-running)
+                  :visible (not (and (memq gud-minor-mode '(gdbmi gdba))
+                                     (window-fringes))))
     ([tbreak]   menu-item "Temporary Breakpoint" gud-tbreak
                   :enable (memq gud-minor-mode '(gdbmi gdba gdb sdb xdb bashdb)))
     ([break]    menu-item "Set Breakpoint" gud-break
-                  :enable (not gud-running))
+                  :enable (not gud-running)
+                  :visible (not (and (memq gud-minor-mode '(gdbmi gdba))
+                                     (window-fringes))))
     ([up]       menu-item "Up Stack" gud-up
                   :enable (and (not gud-running)
                                (memq gud-minor-mode
diff --git a/lisp/progmodes/scheme.el b/lisp/progmodes/scheme.el
index aa50a013585..15ab8edaadc 100644
--- a/lisp/progmodes/scheme.el
+++ b/lisp/progmodes/scheme.el
@@ -90,20 +90,26 @@
     (modify-syntax-entry ?\] ")[  " st)
     (modify-syntax-entry ?{ "(}  " st)
     (modify-syntax-entry ?} "){  " st)
-    (modify-syntax-entry ?\| "\" 23b" st)
+    (modify-syntax-entry ?\| "\" 23bn" st)
+    ;; Guile allows #! ... !# comments.
+    ;; But SRFI-22 defines the comment as #!...\n instead.
+    ;; Also Guile says that the !# should be on a line of its own.
+    ;; It's too difficult to get it right, for too little benefit.
+    ;; (modify-syntax-entry ?! "_ 2" st)
 
     ;; Other atom delimiters
     (modify-syntax-entry ?\( "()  " st)
     (modify-syntax-entry ?\) ")(  " st)
-    (modify-syntax-entry ?\; "<   " st)
-    (modify-syntax-entry ?\" "\"    " st)
+    ;; It's used for single-line comments as well as for #;(...) sexp-comments.
+    (modify-syntax-entry ?\; "< 2 " st)
+    (modify-syntax-entry ?\" "\"   " st)
     (modify-syntax-entry ?' "'   " st)
     (modify-syntax-entry ?` "'   " st)
 
     ;; Special characters
     (modify-syntax-entry ?, "'   " st)
     (modify-syntax-entry ?@ "'   " st)
-    (modify-syntax-entry ?# "' 14bn" st)
+    (modify-syntax-entry ?# "' 14b" st)
     (modify-syntax-entry ?\\ "\\   " st)
     st))
 
@@ -163,13 +169,18 @@
   (setq imenu-generic-expression scheme-imenu-generic-expression)
   (set (make-local-variable 'imenu-syntax-alist)
         '(("+-*/.<>=?!$%_&~^:" . "w")))
-  (make-local-variable 'font-lock-defaults)
-  (setq font-lock-defaults
-        '((scheme-font-lock-keywords
-           scheme-font-lock-keywords-1 scheme-font-lock-keywords-2)
-          nil t (("+-*/.<>=!?$%_&~^:#" . "w")) beginning-of-defun
-          (font-lock-mark-block-function . mark-defun)
-          (font-lock-syntactic-face-function . lisp-font-lock-syntactic-face-function))))
+  (set (make-local-variable 'font-lock-defaults)
+       '((scheme-font-lock-keywords
+          scheme-font-lock-keywords-1 scheme-font-lock-keywords-2)
+         nil t (("+-*/.<>=!?$%_&~^:" . "w") (?#. "w 14"))
+         beginning-of-defun
+         (font-lock-mark-block-function . mark-defun)
+         (font-lock-syntactic-face-function
+          . scheme-font-lock-syntactic-face-function)
+         (parse-sexp-lookup-properties . t)
+         (font-lock-extra-managed-props syntax-table)))
+  (set (make-local-variable 'lisp-doc-string-elt-property)
+       'scheme-doc-string-elt))
 
 (defvar scheme-mode-line-process "")
 
@@ -345,6 +356,44 @@ See `run-hooks'."
 (defvar scheme-font-lock-keywords scheme-font-lock-keywords-1
   "Default expressions to highlight in Scheme modes.")
 
+(defconst scheme-sexp-comment-syntax-table
+  (let ((st (make-syntax-table scheme-mode-syntax-table)))
+    (modify-syntax-entry ?\; "." st)
+    (modify-syntax-entry ?\n " " st)
+    (modify-syntax-entry ?#  "'" st)
+    st))
+
+(put 'lambda 'scheme-doc-string-elt 2)
+;; Docstring's pos in a `define' depends on whether it's a var or fun def.
+(put 'define 'scheme-doc-string-elt
+     (lambda ()
+       ;; The function is called with point right after "define".
+       (forward-comment (point-max))
+       (if (eq (char-after) ?\() 2 0)))
+
+(defun scheme-font-lock-syntactic-face-function (state)
+  (when (and (null (nth 3 state))
+             (eq (char-after (nth 8 state)) ?#)
+             (eq (char-after (1+ (nth 8 state))) ?\;))
+    ;; It's a sexp-comment.  Tell parse-partial-sexp where it ends.
+    (save-excursion
+      (let ((pos (point))
+            (end
+             (condition-case err
+                 (let ((parse-sexp-lookup-properties nil))
+                   (goto-char (+ 2 (nth 8 state)))
+                   ;; FIXME: this doesn't handle the case where the sexp
+                   ;; itself contains a #; comment.
+                   (forward-sexp 1)
+                   (point))
+               (scan-error (nth 2 err)))))
+        (when (< pos (- end 2))
+          (put-text-property pos (- end 2)
+                             'syntax-table scheme-sexp-comment-syntax-table))
+        (put-text-property (- end 1) end 'syntax-table '(12)))))
+  ;; Choose the face to use.
+  (lisp-font-lock-syntactic-face-function state))
+
 ;;;###autoload
 (define-derived-mode dsssl-mode scheme-mode "DSSSL"
   "Major mode for editing DSSSL code.
diff --git a/lisp/progmodes/vhdl-mode.el b/lisp/progmodes/vhdl-mode.el
index 1986148e8d5..ed64de4c89c 100644
--- a/lisp/progmodes/vhdl-mode.el
+++ b/lisp/progmodes/vhdl-mode.el
@@ -142,6 +142,8 @@
 (defvar lazy-lock-defer-contextually)
 (defvar lazy-lock-defer-on-scrolling)
 (defvar lazy-lock-defer-on-the-fly)
+(defvar speedbar-attached-frame)
+
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; Variables
@@ -13988,11 +13990,11 @@ if required."
     (speedbar-add-mode-functions-list
      '("vhdl directory"
        (speedbar-item-info . vhdl-speedbar-item-info)
-       (speedbar-line-path . speedbar-files-line-path)))
+       (speedbar-line-directory . speedbar-files-line-path)))
     (speedbar-add-mode-functions-list
      '("vhdl project"
        (speedbar-item-info . vhdl-speedbar-item-info)
-       (speedbar-line-path . vhdl-speedbar-line-project)))
+       (speedbar-line-directory . vhdl-speedbar-line-project)))
     ;; keymap
     (unless vhdl-speedbar-key-map
       (setq vhdl-speedbar-key-map (speedbar-make-specialized-keymap))
@@ -14257,9 +14259,9 @@ otherwise use cached data."
      ((save-excursion (beginning-of-line) (looking-at "[^0-9]"))
       (re-search-forward "[0-9]+:" nil t)
       (vhdl-scan-directory-contents
-       (abbreviate-file-name (speedbar-line-path))))
+       (abbreviate-file-name (speedbar-line-directory))))
      ;; current directory
-     (t (setq path (speedbar-line-path))
+     (t (setq path (speedbar-line-directory))
         (string-match "^\\(.+[/\\]\\)" path)
         (vhdl-scan-directory-contents
          (abbreviate-file-name (match-string 1 path)))))
@@ -14977,7 +14979,7 @@ NO-POSITION non-nil means do not re-position cursor."
   (cond ((string-match "+" text)        ; we have to expand this dir
          (setq speedbar-shown-directories
                (cons (expand-file-name
-                      (concat (speedbar-line-path indent) token "/"))
+                      (concat (speedbar-line-directory indent) token "/"))
                      speedbar-shown-directories))
          (speedbar-change-expand-button-char ?-)
          (speedbar-reset-scanners)
@@ -14986,12 +14988,12 @@ NO-POSITION non-nil means do not re-position cursor."
              (end-of-line) (forward-char 1)
              (vhdl-speedbar-insert-dirs
               (speedbar-file-lists
-               (concat (speedbar-line-path indent) token "/"))
+               (concat (speedbar-line-directory indent) token "/"))
               (1+ indent))
              (speedbar-reset-scanners)
              (vhdl-speedbar-insert-dir-hierarchy
               (abbreviate-file-name
-               (concat (speedbar-line-path indent) token "/"))
+               (concat (speedbar-line-directory indent) token "/"))
               (1+ indent) speedbar-power-click)))
          (vhdl-speedbar-update-current-unit t t))
         ((string-match "-" text)        ; we have to contract this node
@@ -14999,7 +15001,7 @@ NO-POSITION non-nil means do not re-position cursor."
          (let ((oldl speedbar-shown-directories)
                (newl nil)
                (td (expand-file-name
-                    (concat (speedbar-line-path indent) token))))
+                    (concat (speedbar-line-directory indent) token))))
            (while oldl
              (if (not (string-match (concat "^" (regexp-quote td)) (car oldl)))
                  (setq newl (cons (car oldl) newl)))
@@ -15085,7 +15087,7 @@ NO-POSITION non-nil means do not re-position cursor."
   (if vhdl-speedbar-show-projects
       (vhdl-speedbar-line-project)
     (abbreviate-file-name
-     (file-name-as-directory (speedbar-line-path indent)))))
+     (file-name-as-directory (speedbar-line-directory indent)))))
 
 (defun vhdl-speedbar-line-project (&optional indent)
   "Get currently displayed project name."
@@ -15236,7 +15238,7 @@ is already shown in a buffer."
           (unit-name (vhdl-speedbar-line-text))
           (vhdl-project (vhdl-speedbar-line-project))
           (directory (file-name-as-directory
-                      (or (speedbar-line-file) (speedbar-line-path)))))
+                      (or (speedbar-line-file) (speedbar-line-directory)))))
       (if (fboundp 'speedbar-select-attached-frame)
           (speedbar-select-attached-frame)
         (select-frame speedbar-attached-frame))
@@ -15248,7 +15250,7 @@ is already shown in a buffer."
   (interactive)
   (let ((vhdl-project (vhdl-speedbar-line-project))
         (default-directory (file-name-as-directory
-                            (or (speedbar-line-file) (speedbar-line-path)))))
+                            (or (speedbar-line-file) (speedbar-line-directory)))))
     (vhdl-generate-makefile)))
 
 (defun vhdl-speedbar-check-unit (design-unit)