upstream

6 files changed, 302 insertions, 156 deletions

diff --git a/lisp/progmodes/antlr-mode.el b/lisp/progmodes/antlr-mode.el
index 634570cf3e4..9c9a8e09d49 100644
--- a/lisp/progmodes/antlr-mode.el
+++ b/lisp/progmodes/antlr-mode.el
@@ -1,6 +1,6 @@
 ;;; antlr-mode.el --- major mode for ANTLR grammar files
 
-;; Copyright (C) 1999-2012  Free Software Foundation, Inc.
+;; Copyright (C) 1999-2012 Free Software Foundation, Inc.
 
 ;; Author: Christoph.Wedler@sap.com
 ;; Keywords: languages, ANTLR, code generator
@@ -961,7 +961,7 @@ group.  The string matched by the first group is highlighted with
          (antlr-re-search-forward
           "^\\(private\\|public\\|protected\\)\\>[ \t]*\\(\\(\\sw+[ \t]*\\(:\\)?\\)\\)?"
           limit))
-     (1 font-lock-type-face)            ; not XEmacs' java level-3 fruit salad
+     (1 font-lock-type-face)            ; not XEmacs's java level-3 fruit salad
      (3 (if (antlr-upcase-p (char-after (match-beginning 3)))
             antlr-tokendef-face
           antlr-ruledef-face) nil t)
@@ -1030,7 +1030,7 @@ not to confuse their context_cache.")
 (define-abbrev-table 'antlr-mode-abbrev-table ())
 
 (defvar antlr-slow-cache-enabling-symbol 'loudly
-;; Emacs' font-lock changes buffer's tick counter, therefore this value should
+;; Emacs's font-lock changes buffer's tick counter, therefore this value should
 ;; be a parameter of a font-lock function, but not any other variable of
 ;; functions which call `antlr-slow-syntactic-context'.
   "If value is a bound symbol, cache will be used even with text changes.
@@ -1113,7 +1113,7 @@ WARNING: this may alter `match-data'."
   (or (buffer-syntactic-context) (buffer-syntactic-context-depth))
   :EMACS
   (let ((orig (point)) diff state
-        ;; Arg, Emacs' (buffer-modified-tick) changes with font-lock.  Use
+        ;; Arg, Emacs's (buffer-modified-tick) changes with font-lock.  Use
         ;; hack that `loudly' is bound during font-locking => cache use will
         ;; increase from 7% to 99.99% during font-locking.
         (tick (or (boundp antlr-slow-cache-enabling-symbol)
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 95b43e763d5..3b33ac894f2 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -219,6 +219,38 @@
                (point))))
     c-macro-start))
 
+;; One element macro cache to cope with continual movement within very large
+;; CPP macros.
+(defvar c-macro-cache nil)
+(make-variable-buffer-local 'c-macro-cache)
+;; Nil or cons of the bounds of the most recent CPP form probed by
+;; `c-beginning-of-macro', `c-end-of-macro' or `c-syntactic-end-of-macro'.
+;; The cdr will be nil if we know only the start of the CPP form.
+(defvar c-macro-cache-start-pos nil)
+(make-variable-buffer-local 'c-macro-cache-start-pos)
+;; The starting position from where we determined `c-macro-cache'.
+(defvar c-macro-cache-syntactic nil)
+(make-variable-buffer-local 'c-macro-cache-syntactic)
+;; non-nil iff `c-macro-cache' has both elements set AND the cdr is at a
+;; syntactic end of macro, not merely an apparent one.
+
+(defun c-invalidate-macro-cache (beg end)
+  ;; Called from a before-change function.  If the change region is before or
+  ;; in the macro characterised by `c-macro-cache' etc., nullify it
+  ;; appropriately.  BEG and END are the standard before-change-functions
+  ;; parameters.  END isn't used.
+  (cond
+   ((null c-macro-cache))
+   ((< beg (car c-macro-cache))
+    (setq c-macro-cache nil
+          c-macro-cache-start-pos nil
+          c-macro-cache-syntactic nil))
+   ((and (cdr c-macro-cache)
+         (< beg (cdr c-macro-cache)))
+    (setcdr c-macro-cache nil)
+    (setq c-macro-cache-start-pos beg
+          c-macro-cache-syntactic nil))))
+
 (defun c-beginning-of-macro (&optional lim)
   "Go to the beginning of a preprocessor directive.
 Leave point at the beginning of the directive and return t if in one,
@@ -226,19 +258,36 @@ otherwise return nil and leave point unchanged.
 
 Note that this function might do hidden buffer changes.  See the
 comment at the start of cc-engine.el for more info."
-  (when c-opt-cpp-prefix
-    (let ((here (point)))
-      (save-restriction
-        (if lim (narrow-to-region lim (point-max)))
-        (beginning-of-line)
-        (while (eq (char-before (1- (point))) ?\\)
-          (forward-line -1))
-        (back-to-indentation)
-        (if (and (<= (point) here)
-                 (looking-at c-opt-cpp-start))
-            t
-          (goto-char here)
-          nil)))))
+  (let ((here (point)))
+    (when c-opt-cpp-prefix
+      (if (and (car c-macro-cache)
+               (>= (point) (car c-macro-cache))
+               (or (and (cdr c-macro-cache)
+                        (<= (point) (cdr c-macro-cache)))
+                   (<= (point) c-macro-cache-start-pos)))
+          (unless (< (car c-macro-cache) (or lim (point-min)))
+            (progn (goto-char (max (or lim (point-min)) (car c-macro-cache)))
+                   (setq c-macro-cache-start-pos
+                         (max c-macro-cache-start-pos here))
+                   t))
+        (setq c-macro-cache nil
+              c-macro-cache-start-pos nil
+              c-macro-cache-syntactic nil)
+
+        (save-restriction
+          (if lim (narrow-to-region lim (point-max)))
+          (beginning-of-line)
+          (while (eq (char-before (1- (point))) ?\\)
+            (forward-line -1))
+          (back-to-indentation)
+          (if (and (<= (point) here)
+                   (looking-at c-opt-cpp-start))
+              (progn
+                (setq c-macro-cache (cons (point) nil)
+                      c-macro-cache-start-pos here)
+                t)
+            (goto-char here)
+            nil))))))
 
 (defun c-end-of-macro ()
   "Go to the end of a preprocessor directive.
@@ -248,12 +297,24 @@ done that the point is inside a cpp directive to begin with.
 
 Note that this function might do hidden buffer changes.  See the
 comment at the start of cc-engine.el for more info."
-  (while (progn
-           (end-of-line)
-           (when (and (eq (char-before) ?\\)
-                      (not (eobp)))
-             (forward-char)
-             t))))
+   (if (and (cdr c-macro-cache)
+            (<= (point) (cdr c-macro-cache))
+            (>= (point) (car c-macro-cache)))
+       (goto-char (cdr c-macro-cache))
+     (unless (and (car c-macro-cache)
+                  (<= (point) c-macro-cache-start-pos)
+                  (>= (point) (car c-macro-cache)))
+       (setq c-macro-cache nil
+             c-macro-cache-start-pos nil
+             c-macro-cache-syntactic nil))
+     (while (progn
+              (end-of-line)
+              (when (and (eq (char-before) ?\\)
+                         (not (eobp)))
+                (forward-char)
+                t)))
+     (when (car c-macro-cache)
+       (setcdr c-macro-cache (point)))))
 
 (defun c-syntactic-end-of-macro ()
   ;; Go to the end of a CPP directive, or a "safe" pos just before.
@@ -268,12 +329,15 @@ comment at the start of cc-engine.el for more info."
   ;; at the start of cc-engine.el for more info.
   (let* ((here (point))
          (there (progn (c-end-of-macro) (point)))
-         (s (parse-partial-sexp here there)))
-    (while (and (or (nth 3 s)    ; in a string
-                    (nth 4 s))   ; in a comment (maybe at end of line comment)
-                (> there here))  ; No infinite loops, please.
-      (setq there (1- (nth 8 s)))
-      (setq s (parse-partial-sexp here there)))
+         s)
+    (unless c-macro-cache-syntactic
+      (setq s (parse-partial-sexp here there))
+      (while (and (or (nth 3 s)  ; in a string
+                      (nth 4 s)) ; in a comment (maybe at end of line comment)
+                  (> there here))       ; No infinite loops, please.
+        (setq there (1- (nth 8 s)))
+        (setq s (parse-partial-sexp here there)))
+      (setq c-macro-cache-syntactic (car c-macro-cache)))
     (point)))
 
 (defun c-forward-over-cpp-define-id ()
@@ -2089,6 +2153,18 @@ comment at the start of cc-engine.el for more info."
 ;; reduced by buffer changes, and increased by invocations of
 ;; `c-state-literal-at'.
 
+(defvar c-state-semi-nonlit-pos-cache nil)
+(make-variable-buffer-local 'c-state-semi-nonlit-pos-cache)
+;; A list of buffer positions which are known not to be in a literal.  This is
+;; ordered with higher positions at the front of the list.  Only those which
+;; are less than `c-state-semi-nonlit-pos-cache-limit' are valid.
+
+(defvar c-state-semi-nonlit-pos-cache-limit 1)
+(make-variable-buffer-local 'c-state-semi-nonlit-pos-cache-limit)
+;; An upper limit on valid entries in `c-state-semi-nonlit-pos-cache'.  This is
+;; reduced by buffer changes, and increased by invocations of
+;; `c-state-literal-at'.  FIMXE!!!
+
 (defsubst c-state-pp-to-literal (from to)
   ;; Do a parse-partial-sexp from FROM to TO, returning either
   ;;     (STATE TYPE (BEG . END))     if TO is in a literal; or
@@ -2129,48 +2205,93 @@ comment at the start of cc-engine.el for more info."
     (widen)
     (save-excursion
       (let ((c c-state-nonlit-pos-cache)
-            pos npos lit macro-beg macro-end)
+            pos npos high-pos lit macro-beg macro-end)
         ;; Trim the cache to take account of buffer changes.
         (while (and c (> (car c) c-state-nonlit-pos-cache-limit))
           (setq c (cdr c)))
         (setq c-state-nonlit-pos-cache c)
 
         (while (and c (> (car c) here))
+          (setq high-pos (car c))
           (setq c (cdr c)))
         (setq pos (or (car c) (point-min)))
 
-        (while
-            ;; Add an element to `c-state-nonlit-pos-cache' each iteration.
-            (and
-             (<= (setq npos (+ pos c-state-nonlit-pos-interval)) here)
+        (unless high-pos
+          (while
+              ;; Add an element to `c-state-nonlit-pos-cache' each iteration.
+              (and
+               (<= (setq npos (+ pos c-state-nonlit-pos-interval)) here)
 
-             ;; Test for being in a literal.
-             (progn
-               (setq lit (car (cddr (c-state-pp-to-literal pos npos))))
-               (or (null lit)
-                   (prog1 (<= (cdr lit) here)
-                     (setq npos (cdr lit)))))
+               ;; Test for being in a literal.  If so, go to after it.
+               (progn
+                 (setq lit (car (cddr (c-state-pp-to-literal pos npos))))
+                 (or (null lit)
+                     (prog1 (<= (cdr lit) here)
+                       (setq npos (cdr lit)))))
 
-             ;; Test for being in a macro.
-             (progn
-               (goto-char npos)
-               (setq macro-beg
-                     (and (c-beginning-of-macro) (/= (point) npos) (point)))
-               (when macro-beg
-                 (c-syntactic-end-of-macro)
-                 (or (eobp) (forward-char))
-                 (setq macro-end (point)))
-               (or (null macro-beg)
-                   (prog1 (<= macro-end here)
-                     (setq npos macro-end)))))
-
-          (setq pos npos)
-          (setq c-state-nonlit-pos-cache (cons pos c-state-nonlit-pos-cache)))
+               ;; Test for being in a macro.  If so, go to after it.
+               (progn
+                 (goto-char npos)
+                 (setq macro-beg
+                       (and (c-beginning-of-macro) (/= (point) npos) (point)))
+                 (when macro-beg
+                   (c-syntactic-end-of-macro)
+                   (or (eobp) (forward-char))
+                   (setq macro-end (point)))
+                 (or (null macro-beg)
+                     (prog1 (<= macro-end here)
+                       (setq npos macro-end)))))
+
+            (setq pos npos)
+            (setq c-state-nonlit-pos-cache (cons pos c-state-nonlit-pos-cache)))
+          ;; Add one extra element above HERE so as to to avoid the previous
+          ;; expensive calculation when the next call is close to the current
+          ;; one.  This is especially useful when inside a large macro.
+          (setq c-state-nonlit-pos-cache (cons npos c-state-nonlit-pos-cache)))
 
         (if (> pos c-state-nonlit-pos-cache-limit)
             (setq c-state-nonlit-pos-cache-limit pos))
         pos))))
 
+(defun c-state-semi-safe-place (here)
+  ;; Return a buffer position before HERE which is "safe", i.e. outside any
+  ;; string or comment.  It may be in a macro.
+  (save-restriction
+    (widen)
+    (save-excursion
+      (let ((c c-state-semi-nonlit-pos-cache)
+            pos npos high-pos lit macro-beg macro-end)
+        ;; Trim the cache to take account of buffer changes.
+        (while (and c (> (car c) c-state-semi-nonlit-pos-cache-limit))
+          (setq c (cdr c)))
+        (setq c-state-semi-nonlit-pos-cache c)
+        
+        (while (and c (> (car c) here))
+          (setq high-pos (car c))
+          (setq c (cdr c)))
+        (setq pos (or (car c) (point-min)))
+        
+        (unless high-pos
+          (while
+              ;; Add an element to `c-state-semi-nonlit-pos-cache' each iteration.
+              (and
+               (<= (setq npos (+ pos c-state-nonlit-pos-interval)) here)
+               
+               ;; Test for being in a literal.  If so, go to after it.
+               (progn
+                 (setq lit (car (cddr (c-state-pp-to-literal pos npos))))
+                 (or (null lit)
+                     (prog1 (<= (cdr lit) here)
+                       (setq npos (cdr lit))))))
+               
+            (setq pos npos)
+            (setq c-state-semi-nonlit-pos-cache
+                  (cons pos c-state-semi-nonlit-pos-cache))))
+
+        (if (> pos c-state-semi-nonlit-pos-cache-limit)
+            (setq c-state-semi-nonlit-pos-cache-limit pos))
+        pos))))
+
 (defun c-state-literal-at (here)
   ;; If position HERE is inside a literal, return (START . END), the
   ;; boundaries of the literal (which may be outside the accessible bit of the
@@ -2985,9 +3106,11 @@ comment at the start of cc-engine.el for more info."
   ;;
   ;; This function is called from c-after-change.
 
-  ;; The cache of non-literals:
+  ;; The caches of non-literals:
   (if (< here c-state-nonlit-pos-cache-limit)
       (setq c-state-nonlit-pos-cache-limit here))
+  (if (< here c-state-semi-nonlit-pos-cache-limit)
+      (setq c-state-semi-nonlit-pos-cache-limit here))
 
   ;; `c-state-cache':
   ;; Case 1: if `here' is in a literal containing point-min, everything
@@ -4230,7 +4353,7 @@ Note that this function might do hidden buffer changes.  See the
 comment at the start of cc-engine.el for more info."
   (save-restriction
     (widen)
-    (let* ((safe-place (c-state-safe-place (point)))
+    (let* ((safe-place (c-state-semi-safe-place (point)))
            (lit (c-state-pp-to-literal safe-place (point))))
       (or (cadr lit)
           (and detect-cpp
@@ -4254,7 +4377,7 @@ comment at the start of cc-engine.el for more info."
 
   (save-excursion
     (let* ((pos (point))
-           (lim (or lim (c-state-safe-place pos)))
+           (lim (or lim (c-state-semi-safe-place pos)))
            (pp-to-lit (save-restriction
                         (widen)
                         (c-state-pp-to-literal lim pos)))
@@ -4372,7 +4495,7 @@ comment at the start of cc-engine.el for more info."
   ;; Get a "safe place" approximately TRY-SIZE characters before START.
   ;; This doesn't preserve point.
   (let* ((pos (max (- start try-size) (point-min)))
-         (base (c-state-safe-place pos))
+         (base (c-state-semi-safe-place pos))
          (s (parse-partial-sexp base pos)))
     (if (or (nth 4 s) (nth 3 s))        ; comment or string
         (nth 8 s)
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index fafbfb70552..493f3db0961 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -459,8 +459,10 @@ so that all identifiers are recognized as words.")
   ;; For documentation see the following c-lang-defvar of the same name.
   ;; The value here may be a list of functions or a single function.
   t nil
-  c++ '(c-extend-region-for-CPP c-before-change-check-<>-operators)
-  (c objc) 'c-extend-region-for-CPP
+  c++ '(c-extend-region-for-CPP
+        c-before-change-check-<>-operators
+        c-invalidate-macro-cache)
+  (c objc) '(c-extend-region-for-CPP c-invalidate-macro-cache)
   ;; java 'c-before-change-check-<>-operators
   awk 'c-awk-record-region-clear-NL)
 (c-lang-defvar c-get-state-before-change-functions
diff --git a/lisp/progmodes/gdb-mi.el b/lisp/progmodes/gdb-mi.el
index 301714ec55f..0c45c3f5e5d 100644
--- a/lisp/progmodes/gdb-mi.el
+++ b/lisp/progmodes/gdb-mi.el
@@ -1672,8 +1672,6 @@ static char *magick[] = {
   (if (not (string= "" string))
       (setq gdb-last-command string)
     (if gdb-last-command (setq string gdb-last-command)))
-  (if gdb-enable-debug
-      (push (cons 'mi-send (concat string "\n")) gdb-debug-log))
   (if (string-match "^-" string)
       ;; MI command
       (progn
@@ -1683,10 +1681,22 @@ static char *magick[] = {
     (if (string-match "\\\\$" string)
         (setq gdb-continuation (concat gdb-continuation string "\n"))
       (setq gdb-first-done-or-error t)
-      (process-send-string proc (concat "-interpreter-exec console \""
-                                        gdb-continuation string "\"\n"))
+      (let ((to-send (concat "-interpreter-exec console "
+                             (gdb-mi-quote string)
+                             "\n")))
+        (if gdb-enable-debug
+            (push (cons 'mi-send to-send) gdb-debug-log))
+        (process-send-string proc to-send))
       (setq gdb-continuation nil))))
 
+(defun gdb-mi-quote (string)
+  "Return STRING quoted properly as an MI argument.
+The string is enclosed in double quotes.
+All embedded quotes, newlines, and backslashes are preceded with a backslash."
+  (setq string (replace-regexp-in-string "\\([\"\\]\\)" "\\\\\\&" string))
+  (setq string (replace-regexp-in-string "\n" "\\n" string t t))
+  (concat "\"" string "\""))
+
 (defun gdb-input (command handler-function)
   "Send COMMAND to GDB via the MI interface.
 Run the function HANDLER-FUNCTION, with no arguments, once the command is
diff --git a/lisp/progmodes/sql.el b/lisp/progmodes/sql.el
index f5bfe526aae..56f42e31cf1 100644
--- a/lisp/progmodes/sql.el
+++ b/lisp/progmodes/sql.el
@@ -2853,9 +2853,12 @@ appended to the SQLi buffer without disturbing your SQL buffer."
   "Read a password using PROMPT.  Optional DEFAULT is password to start with."
   (read-passwd prompt nil default))
 
-(defun sql-get-login-ext (prompt last-value history-var plist)
+(defun sql-get-login-ext (symbol prompt history-var plist)
   "Prompt user with extended login parameters.
 
+The global value of SYMBOL is the last value and the global value 
+of the SYMBOL is set based on the user's input.
+
 If PLIST is nil, then the user is simply prompted for a string
 value.
 
@@ -2868,38 +2871,41 @@ regexp pattern specified in its value.
 The `:completion' property prompts for a string specified by its
 value.  (The property value is used as the PREDICATE argument to
 `completing-read'.)"
-  (let* ((default (plist-get plist :default))
-         (prompt-def
-          (if default
-              (if (string-match "\\(\\):[ \t]*\\'" prompt)
-                  (replace-match (format " (default \"%s\")" default) t t prompt 1)
-                (replace-regexp-in-string "[ \t]*\\'"
-                                          (format " (default \"%s\") " default)
-                                          prompt t t))
-            prompt))
-         (use-dialog-box nil))
-    (cond
-     ((plist-member plist :file)
-      (expand-file-name
-       (read-file-name prompt
-                       (file-name-directory last-value) default t
-                       (file-name-nondirectory last-value)
-                       (when (plist-get plist :file)
-                         `(lambda (f)
-                            (string-match
-                             (concat "\\<" ,(plist-get plist :file) "\\>")
-                             (file-name-nondirectory f)))))))
-
-     ((plist-member plist :completion)
-      (completing-read prompt-def (plist-get plist :completion) nil t
-                       last-value history-var default))
-
-     ((plist-get plist :number)
-      (read-number prompt (or default last-value 0)))
-
-     (t
-      (let ((r (read-from-minibuffer prompt-def last-value nil nil history-var nil)))
-        (if (string= "" r) (or default "") r))))))
+  (set-default 
+   symbol
+   (let* ((default (plist-get plist :default))
+          (last-value (default-value symbol))
+          (prompt-def
+           (if default
+               (if (string-match "\\(\\):[ \t]*\\'" prompt)
+                   (replace-match (format " (default \"%s\")" default) t t prompt 1)
+                 (replace-regexp-in-string "[ \t]*\\'"
+                                           (format " (default \"%s\") " default)
+                                           prompt t t))
+             prompt))
+          (use-dialog-box nil))
+     (cond
+      ((plist-member plist :file)
+       (expand-file-name
+        (read-file-name prompt
+                        (file-name-directory last-value) default t
+                        (file-name-nondirectory last-value)
+                        (when (plist-get plist :file)
+                          `(lambda (f)
+                             (string-match
+                              (concat "\\<" ,(plist-get plist :file) "\\>")
+                              (file-name-nondirectory f)))))))
+
+      ((plist-member plist :completion)
+       (completing-read prompt-def (plist-get plist :completion) nil t
+                        last-value history-var default))
+
+      ((plist-get plist :number)
+       (read-number prompt (or default last-value 0)))
+
+      (t
+       (let ((r (read-from-minibuffer prompt-def last-value nil nil history-var nil)))
+         (if (string= "" r) (or default "") r)))))))
 
 (defun sql-get-login (&rest what)
   "Get username, password and database from the user.
@@ -2937,28 +2943,20 @@ function like this: (sql-get-login 'user 'password 'database)."
 
      (cond
       ((eq token 'user)         ; user
-       (setq sql-user
-             (sql-get-login-ext "User: " sql-user
-                                'sql-user-history plist)))
+       (sql-get-login-ext 'sql-user "User: " 'sql-user-history plist))
 
-      ((eq token 'password)             ; password
-       (setq sql-password
-             (sql-read-passwd "Password: " sql-password)))
+      ((eq token 'password)     ; password
+       (setq-default sql-password
+                     (sql-read-passwd "Password: " sql-password)))
 
-      ((eq token 'server)               ; server
-       (setq sql-server
-             (sql-get-login-ext "Server: " sql-server
-                                'sql-server-history plist)))
+      ((eq token 'server)       ; server
+       (sql-get-login-ext 'sql-server "Server: " 'sql-server-history plist))
 
-      ((eq token 'database)             ; database
-       (setq sql-database
-             (sql-get-login-ext "Database: " sql-database
-                                'sql-database-history plist)))
+      ((eq token 'database)     ; database
+       (sql-get-login-ext 'sql-database "Database: " 'sql-database-history plist))
 
       ((eq token 'port)         ; port
-       (setq sql-port
-             (sql-get-login-ext "Port: " sql-port
-                                nil (append '(:number t) plist)))))))
+       (sql-get-login-ext 'sql-port "Port: " nil (append '(:number t) plist))))))
    what))
 
 (defun sql-find-sqli-buffer (&optional product connection)
@@ -3841,6 +3839,7 @@ you entered, right above the output it created.
   (set (make-local-variable 'sql-server)     sql-server)
   (set (make-local-variable 'sql-port)       sql-port)
   (set (make-local-variable 'sql-connection) sql-connection)
+  (setq-default sql-connection nil)
   ;; Contains the name of database objects
   (set (make-local-variable 'sql-contains-names) t)
   ;; Keep track of existing object names
@@ -3935,43 +3934,50 @@ is specified in the connection settings."
           ;; Settings are defined
           (if connect-set
               ;; Set the desired parameters
-              (eval `(let*
-                         (,@(cdr connect-set)
-                          ;; :sqli-login params variable
-                          (param-var    (sql-get-product-feature sql-product
-                                                                 :sqli-login nil t))
-                          ;; :sqli-login params value
-                          (login-params (sql-get-product-feature sql-product
-                                                                 :sqli-login))
-                          ;; which params are in the connection
-                          (set-params   (mapcar
-                                         (lambda (v)
-                                           (cond
-                                            ((eq (car v) 'sql-user)     'user)
-                                            ((eq (car v) 'sql-password) 'password)
-                                            ((eq (car v) 'sql-server)   'server)
-                                            ((eq (car v) 'sql-database) 'database)
-                                            ((eq (car v) 'sql-port)     'port)
-                                            (t                          (car v))))
-                                         (cdr connect-set)))
-                          ;; the remaining params (w/o the connection params)
-                          (rem-params   (sql-for-each-login
-                                         login-params
-                                         (lambda (token plist)
-                                           (unless (member token set-params)
-                                                    (if plist
-                                                        (cons token plist)
-                                                      token))))))
-
-                       ;; Set the remaining parameters and start the
-                       ;; interactive session
-                       (eval `(let ((sql-connection ,connection)
-                                     (,param-var ',rem-params))
-                                (sql-product-interactive sql-product
-                                                         new-name)))))
+              (let (param-var login-params set-params rem-params)
+
+                ;; :sqli-login params variable
+                (setq param-var
+                      (sql-get-product-feature sql-product :sqli-login nil t))
+
+                ;; :sqli-login params value
+                (setq login-params
+                      (sql-get-product-feature sql-product :sqli-login))
+
+                ;; Params in the connection
+                (setq set-params
+                      (mapcar
+                       (lambda (v)
+                         (cond
+                          ((eq (car v) 'sql-user)     'user)
+                          ((eq (car v) 'sql-password) 'password)
+                          ((eq (car v) 'sql-server)   'server)
+                          ((eq (car v) 'sql-database) 'database)
+                          ((eq (car v) 'sql-port)     'port)
+                          (t                          (car v))))
+                       (cdr connect-set)))
+
+                ;; the remaining params (w/o the connection params)
+                (setq rem-params
+                      (sql-for-each-login login-params
+                       (lambda (token plist)
+                         (unless (member token set-params)
+                           (if plist (cons token plist) token)))))
+
+                ;; Set the parameters and start the interactive session
+                (mapc
+                 (lambda (vv)
+                   (set-default (car vv) (eval (cadr vv))))
+                 (cdr connect-set))
+                (setq-default sql-connection connection)
+
+                ;; Start the SQLi session with revised list of login parameters
+                (eval `(let ((,param-var ',rem-params))
+                         (sql-product-interactive sql-product new-name))))
 
             (message "SQL Connection <%s> does not exist" connection)
             nil)))
+
     (message "No SQL Connections defined")
     nil))
 
@@ -4101,9 +4107,14 @@ the call to \\[sql-product-interactive] with
 
               ;; Connect to database.
               (message "Login...")
-              (funcall (sql-get-product-feature product :sqli-comint-func)
-                       product
-                       (sql-get-product-feature product :sqli-options))
+              (let ((sql-user       (default-value 'sql-user))
+                    (sql-password   (default-value 'sql-password))
+                    (sql-server     (default-value 'sql-server))
+                    (sql-database   (default-value 'sql-database))
+                    (sql-port       (default-value 'sql-port)))
+                (funcall (sql-get-product-feature product :sqli-comint-func)
+                         product
+                         (sql-get-product-feature product :sqli-options)))
 
               ;; Set SQLi mode.
               (let ((sql-interactive-product product))
@@ -4113,7 +4124,7 @@ the call to \\[sql-product-interactive] with
               (setq new-sqli-buffer (current-buffer))
               (when new-name
                 (sql-rename-buffer new-name))
-              (set (make-local-variable 'sql-buffer) 
+              (set (make-local-variable 'sql-buffer)
                    (buffer-name new-sqli-buffer))
 
               ;; Set `sql-buffer' in the start buffer
diff --git a/lisp/progmodes/vhdl-mode.el b/lisp/progmodes/vhdl-mode.el
index d765a960470..c9bf638bb59 100644
--- a/lisp/progmodes/vhdl-mode.el
+++ b/lisp/progmodes/vhdl-mode.el
@@ -1,6 +1,6 @@
 ;;; vhdl-mode.el --- major mode for editing VHDL code
 
-;; Copyright (C) 1992-2012  Free Software Foundation, Inc.
+;; Copyright (C) 1992-2012 Free Software Foundation, Inc.
 
 ;; Authors:     Reto Zimmermann <reto@gnu.org>
 ;;              Rodney J. Whitby <software.vhdl-mode@rwhitby.net>
@@ -2040,7 +2040,7 @@ Ignore byte-compiler warnings you might see."
 ;; `wildcard-to-regexp' is included only in XEmacs 21
 (unless (fboundp 'wildcard-to-regexp)
   (defun wildcard-to-regexp (wildcard)
-    "Simplified version of `wildcard-to-regexp' from Emacs' `files.el'."
+    "Simplified version of `wildcard-to-regexp' from Emacs's `files.el'."
     (let* ((i (string-match "[*?]" wildcard))
            (result (substring wildcard 0 i))
            (len (length wildcard)))
@@ -2087,7 +2087,7 @@ Ignore byte-compiler warnings you might see."
 ;; `file-expand-wildcards' undefined (XEmacs)
 (unless (fboundp 'file-expand-wildcards)
   (defun file-expand-wildcards (pattern &optional full)
-    "Taken from Emacs' `files.el'."
+    "Taken from Emacs's `files.el'."
     (let* ((nondir (file-name-nondirectory pattern))
            (dirpart (file-name-directory pattern))
            (dirs (if (and dirpart (string-match "[[*?]" dirpart))