Doc fixes. Add to debug-ignored-errors. Don't quote keywords.

(cmpl-string-case-type): Use character classes.

1 files changed, 166 insertions, 301 deletions

diff --git a/lisp/completion.el b/lisp/completion.el
index 0b6d9626877..4dfb611f6b3 100644
--- a/lisp/completion.el
+++ b/lisp/completion.el
@@ -286,7 +286,7 @@
 
 (defcustom enable-completion t
   "*Non-nil means enable recording and saving of completions.
-If nil, no new words added to the database or saved to the init file."
+If nil, no new words are added to the database or saved to the init file."
   :type 'boolean
   :group 'completion)
 
@@ -413,21 +413,20 @@ Used to decide whether to save completions.")
 ;;-----------------------------------------------
 
 (defun cmpl-string-case-type (string)
-  "Returns :capitalized, :up, :down, :mixed, or :neither."
+  "Return :capitalized, :up, :down, :mixed, or :neither for case of STRING."
   (let ((case-fold-search nil))
-    (cond ((string-match "[a-z]" string)
-           (cond ((string-match "[A-Z]" string)
+    (cond ((string-match "[[:lower:]]" string)
+           (cond ((string-match "[[:upper:]]" string)
                   (cond ((and (> (length string) 1)
-                              (null (string-match "[A-Z]" string 1)))
-                         ':capitalized)
+                              (null (string-match "[[:upper:]]" string 1)))
+                         :capitalized)
                         (t
-                         ':mixed)))
-                 (t ':down)))
+                         :mixed)))
+                 (t :down)))
           (t
-           (cond ((string-match "[A-Z]" string)
-                  ':up)
-                 (t ':neither))))
-    ))
+           (cond ((string-match "[[:upper:]]" string)
+                  :up)
+                 (t :neither))))))
 
 ;; Tests -
 ;; (cmpl-string-case-type "123ABCDEF456") --> :up
@@ -437,29 +436,25 @@ Used to decide whether to save completions.")
 ;; (cmpl-string-case-type "Abcde123")     --> :capitalized
 
 (defun cmpl-coerce-string-case (string case-type)
-  (cond ((eq case-type ':down) (downcase string))
-        ((eq case-type ':up) (upcase string))
-        ((eq case-type ':capitalized)
+  (cond ((eq case-type :down) (downcase string))
+        ((eq case-type :up) (upcase string))
+        ((eq case-type :capitalized)
          (setq string (downcase string))
          (aset string 0 (logand ?\337 (aref string 0)))
          string)
-        (t string)
-        ))
+        (t string)))
 
 (defun cmpl-merge-string-cases (string-to-coerce given-string)
-  (let ((string-case-type (cmpl-string-case-type string-to-coerce))
-        )
+  (let ((string-case-type (cmpl-string-case-type string-to-coerce)))
     (cond ((memq string-case-type '(:down :up :capitalized))
            ;; Found string is in a standard case.  Coerce to a type based on
            ;; the given string
            (cmpl-coerce-string-case string-to-coerce
-                               (cmpl-string-case-type given-string))
-           )
+                               (cmpl-string-case-type given-string)))
           (t
            ;; If the found string is in some unusual case, just insert it
            ;; as is
-           string-to-coerce)
-          )))
+           string-to-coerce))))
 
 ;; Tests -
 ;; (cmpl-merge-string-cases "AbCdEf456" "abc")     --> AbCdEf456
@@ -546,38 +541,32 @@ Used to decide whether to save completions.")
       (setq i (1+ i)))
     ;; Other ones
     (let ((symbol-chars '(?@ ?/ ?\\ ?* ?+ ?~ ?$ ?< ?> ?%))
-          (symbol-chars-ignore '(?_ ?- ?: ?.))
-          )
+          (symbol-chars-ignore '(?_ ?- ?: ?.)))
       (dolist (char symbol-chars)
         (modify-syntax-entry char "_" table))
       (dolist (char symbol-chars-ignore)
-        (modify-syntax-entry char "w" table)
-        )
-      )
+        (modify-syntax-entry char "w" table)))
     table))
 
 (defconst cmpl-standard-syntax-table (cmpl-make-standard-completion-syntax-table))
 
 (defun cmpl-make-lisp-completion-syntax-table ()
   (let ((table (copy-syntax-table cmpl-standard-syntax-table))
-        (symbol-chars '(?! ?& ?? ?= ?^))
-        )
+        (symbol-chars '(?! ?& ?? ?= ?^)))
     (dolist (char symbol-chars)
       (modify-syntax-entry char "_" table))
     table))
            
 (defun cmpl-make-c-completion-syntax-table ()
   (let ((table (copy-syntax-table cmpl-standard-syntax-table))
-        (separator-chars '(?+ ?* ?/ ?: ?%))
-        )
+        (separator-chars '(?+ ?* ?/ ?: ?%)))
     (dolist (char separator-chars)
       (modify-syntax-entry char " " table))
     table))
 
 (defun cmpl-make-fortran-completion-syntax-table ()
   (let ((table (copy-syntax-table cmpl-standard-syntax-table))
-        (separator-chars '(?+ ?- ?* ?/ ?:))
-        )
+        (separator-chars '(?+ ?- ?* ?/ ?:)))
     (dolist (char separator-chars)
       (modify-syntax-entry char " " table))
     table))
@@ -620,15 +609,13 @@ But only if it is longer than `completion-min-length'."
                   (goto-char cmpl-symbol-start)
                   (forward-word 1)
                   (setq cmpl-symbol-start (point))
-                  (goto-char cmpl-saved-point)
-                  ))
+                  (goto-char cmpl-saved-point)))
            ;; Remove chars to ignore at the end.
            (cond ((= (char-syntax (char-after (1- cmpl-symbol-end))) ?w)
                   (goto-char cmpl-symbol-end)
                   (forward-word -1)
                   (setq cmpl-symbol-end (point))
-                  (goto-char cmpl-saved-point)
-                  ))
+                  (goto-char cmpl-saved-point)))
            ;; Return completion if the length is reasonable.
            (if (and (<= (cmpl-read-time-eval completion-min-length)
                         (- cmpl-symbol-end cmpl-symbol-start))
@@ -661,21 +648,18 @@ Returns nil if there isn't one longer than `completion-min-length'."
         (cond ((= (setq cmpl-preceding-syntax (char-syntax (preceding-char))) ?_)
                ;; Number of chars to ignore at end.
                (setq cmpl-symbol-end (point)
-                     cmpl-symbol-start (scan-sexps cmpl-symbol-end -1)
-                     )
+                     cmpl-symbol-start (scan-sexps cmpl-symbol-end -1))
                ;; Remove chars to ignore at the start.
                (cond ((= (char-syntax (char-after cmpl-symbol-start)) ?w)
                       (goto-char cmpl-symbol-start)
                       (forward-word 1)
                       (setq cmpl-symbol-start (point))
-                      (goto-char cmpl-symbol-end)
-                      ))
+                      (goto-char cmpl-symbol-end)))
                ;; Return value if long enough.
                (if (>= cmpl-symbol-end
                        (+ cmpl-symbol-start
                           (cmpl-read-time-eval completion-min-length)))
-                   (buffer-substring cmpl-symbol-start cmpl-symbol-end))
-               )
+                   (buffer-substring cmpl-symbol-start cmpl-symbol-end)))
               ((= cmpl-preceding-syntax ?w)
                ;; chars to ignore at end
                (setq cmpl-saved-point (point)
@@ -687,8 +671,7 @@ Returns nil if there isn't one longer than `completion-min-length'."
                (cond ((= (char-syntax (char-after cmpl-symbol-start)) ?w)
                       (goto-char cmpl-symbol-start)
                       (forward-word 1)
-                      (setq cmpl-symbol-start (point))
-                      ))
+                      (setq cmpl-symbol-start (point))))
                ;; Restore state.
                (goto-char cmpl-saved-point)
                ;; Return completion if the length is reasonable
@@ -743,15 +726,13 @@ Returns nil if there isn't one longer than `completion-min-length'."
         (cond ((memq (setq cmpl-preceding-syntax (char-syntax (preceding-char)))
                      '(?_ ?w))
                (setq cmpl-symbol-end (point)
-                     cmpl-symbol-start (scan-sexps cmpl-symbol-end -1)
-                     )
+                     cmpl-symbol-start (scan-sexps cmpl-symbol-end -1))
                ;; Remove chars to ignore at the start.
                (cond ((= (char-syntax (char-after cmpl-symbol-start)) ?w)
                       (goto-char cmpl-symbol-start)
                       (forward-word 1)
                       (setq cmpl-symbol-start (point))
-                      (goto-char cmpl-symbol-end)
-                      ))
+                      (goto-char cmpl-symbol-end)))
                ;; Return completion if the length is reasonable.
                (if (and (<= (cmpl-read-time-eval
                              completion-prefix-min-length)
@@ -857,25 +838,21 @@ INITIAL-COMPLETIONS-TRIED is a list of downcased strings to ignore
 during the search."
   (setq cdabbrev-abbrev-string abbrev-string
         cdabbrev-completions-tried
-        (cons (downcase abbrev-string) initial-completions-tried)
-        )
-  (reset-cdabbrev-window t)
-  )
+        (cons (downcase abbrev-string) initial-completions-tried))
+  (reset-cdabbrev-window t))
 
 (defun set-cdabbrev-buffer ()
   ;; cdabbrev-current-window must not be NIL
   (set-buffer (if (eq cdabbrev-current-window t)
                   (other-buffer)
-                  (window-buffer cdabbrev-current-window)))
-  )
+                  (window-buffer cdabbrev-current-window))))
 
 
 (defun reset-cdabbrev-window (&optional initializep)
   "Resets the cdabbrev search to search for abbrev-string."
   ;; Set the window
   (cond (initializep
-         (setq cdabbrev-current-window (selected-window))
-         )
+         (setq cdabbrev-current-window (selected-window)))
         ((eq cdabbrev-current-window t)
          ;; Everything has failed
          (setq cdabbrev-current-window nil))
@@ -883,8 +860,7 @@ during the search."
          (setq cdabbrev-current-window (next-window cdabbrev-current-window))
          (if (eq cdabbrev-current-window (selected-window))
              ;; No more windows, try other buffer.
-             (setq cdabbrev-current-window t)))
-        )
+             (setq cdabbrev-current-window t))))
   (if cdabbrev-current-window
       (save-excursion
         (set-cdabbrev-buffer)
@@ -895,8 +871,7 @@ during the search."
                   (max (point-min)
                        (- cdabbrev-start-point completion-search-distance))
                   (point-min))
-              cdabbrev-wrapped-p nil)
-        )))
+              cdabbrev-wrapped-p nil))))
 
 (defun next-cdabbrev ()
   "Return the next possible cdabbrev expansion or nil if there isn't one.
@@ -938,8 +913,7 @@ This is sensitive to `case-fold-search'."
                                     (forward-word -1)
                                     (prog1
                                       (= (char-syntax (preceding-char)) ? )
-                                      (goto-char saved-point-2)
-                                      ))))
+                                      (goto-char saved-point-2)))))
                          ;; is the symbol long enough ?
                          (setq expansion (symbol-under-point))
                          ;; have we not tried this one before
@@ -951,14 +925,12 @@ This is sensitive to `case-fold-search'."
                                        (not (string-equal downcase-expansion
                                                           (car tried-list))))
                              ;; Already tried, don't choose this one
-                             (setq tried-list (cdr tried-list))
-                             )
+                             (setq tried-list (cdr tried-list)))
                            ;; at this point tried-list will be nil if this
                            ;; expansion has not yet been tried
                            (if tried-list
                                (setq expansion nil)
-                               t)
-                           ))))
+                               t)))))
                       ;; search failed
                       (cdabbrev-wrapped-p
                        ;; If already wrapped, then we've failed completely
@@ -970,18 +942,15 @@ This is sensitive to `case-fold-search'."
                                             (min (point-max) (+ cdabbrev-start-point completion-search-distance))
                                             (point-max))))
 
-                       (setq cdabbrev-wrapped-p t))
-                      ))
+                       (setq cdabbrev-wrapped-p t))))
                 ;; end of while loop
                 (cond (expansion
                        ;; successful
                        (setq cdabbrev-completions-tried
                              (cons downcase-expansion cdabbrev-completions-tried)
-                             cdabbrev-current-point (point))))
-                )
+                             cdabbrev-current-point (point)))))
             (set-syntax-table saved-syntax)
-            (goto-char saved-point)
-            ))
+            (goto-char saved-point)))
         ;; If no expansion, go to next window
         (cond (expansion)
               (t (reset-cdabbrev-window)
@@ -1109,18 +1078,17 @@ Each symbol is bound to a single completion entry.")
 ;;-----------------------------------------------
 
 (defun clear-all-completions ()
-  "Initializes the completion storage.  All existing completions are lost."
+  "Initialize the completion storage.  All existing completions are lost."
   (interactive)
   (setq cmpl-prefix-obarray (make-vector cmpl-obarray-length 0))
   (setq cmpl-obarray (make-vector cmpl-obarray-length 0))
   (cmpl-statistics-block
-    (record-clear-all-completions))
-  )
+    (record-clear-all-completions)))
 
 (defvar completions-list-return-value)
 
 (defun list-all-completions ()
-  "Returns a list of all the known completion entries."
+  "Return a list of all the known completion entries."
   (let ((completions-list-return-value nil))
     (mapatoms 'list-all-completions-1 cmpl-prefix-obarray)
     completions-list-return-value))
@@ -1168,16 +1136,15 @@ Each symbol is bound to a single completion entry.")
 
 ;; READS
 (defun find-exact-completion (string)
-  "Returns the completion entry for string or nil.
+  "Return the completion entry for STRING or nil.
 Sets up `cmpl-db-downcase-string' and `cmpl-db-symbol'."
   (and (boundp (setq cmpl-db-symbol
                      (intern (setq cmpl-db-downcase-string (downcase string))
                              cmpl-obarray)))
-       (symbol-value cmpl-db-symbol)
-       ))
+       (symbol-value cmpl-db-symbol)))
 
 (defun find-cmpl-prefix-entry (prefix-string)
-  "Returns the prefix entry for string.
+  "Return the prefix entry for string.
 Sets `cmpl-db-prefix-symbol'.
 Prefix-string must be exactly `completion-prefix-min-length' long
 and downcased.  Sets up `cmpl-db-prefix-symbol'."
@@ -1189,20 +1156,18 @@ and downcased.  Sets up `cmpl-db-prefix-symbol'."
 ;; used to trap lossage in silent error correction
 
 (defun locate-completion-entry (completion-entry prefix-entry)
-  "Locates the completion entry.
+  "Locate the completion entry.
 Returns a pointer to the element before the completion entry or nil if
 the completion entry is at the head.
 Must be called after `find-exact-completion'."
   (let ((prefix-list (cmpl-prefix-entry-head prefix-entry))
-         next-prefix-list
-         )
+         next-prefix-list)
     (cond
       ((not (eq (car prefix-list) completion-entry))
        ;; not already at head
        (while (and prefix-list
                    (not (eq completion-entry
-                            (car (setq next-prefix-list (cdr prefix-list)))
-                            )))
+                            (car (setq next-prefix-list (cdr prefix-list))))))
          (setq prefix-list next-prefix-list))
        (cond (;; found
               prefix-list)
@@ -1218,8 +1183,7 @@ Must be called after `find-exact-completion'."
                ;; Patch out
                (set cmpl-db-symbol nil)
                ;; Retry
-               (locate-completion-entry-retry completion-entry)
-               ))))))
+               (locate-completion-entry-retry completion-entry)))))))
 
 (defun locate-completion-entry-retry (old-entry)
   (let ((inside-locate-completion-entry t))
@@ -1231,19 +1195,16 @@ Must be called after `find-exact-completion'."
             (if cmpl-entry
                 (find-cmpl-prefix-entry
                   (substring cmpl-db-downcase-string
-                             0 completion-prefix-min-length))))
-          )
+                             0 completion-prefix-min-length)))))
       (if (and cmpl-entry pref-entry)
           ;; try again
           (locate-completion-entry cmpl-entry pref-entry)
           ;; still losing
-          (locate-completion-db-error))
-      )))
+          (locate-completion-db-error)))))
 
 (defun locate-completion-db-error ()
   ;; recursive error: really scrod
-  (error "Completion database corrupted.  Try M-x clear-all-completions.  Send bug report.")
-  )
+  (error "Completion database corrupted.  Try M-x clear-all-completions.  Send bug report."))
 
 ;; WRITES
 (defun add-completion-to-tail-if-new (string)
@@ -1261,8 +1222,7 @@ Returns the completion entry."
             (prefix-entry (find-cmpl-prefix-entry
                             (substring cmpl-db-downcase-string 0
                                        (cmpl-read-time-eval
-                                        completion-prefix-min-length))))
-            )
+                                        completion-prefix-min-length)))))
         ;; The next two forms should happen as a unit (atomically) but
         ;; no fatal errors should result if that is not the case.
         (cond (prefix-entry
@@ -1271,14 +1231,12 @@ Returns the completion entry."
                (setcdr (cmpl-prefix-entry-tail prefix-entry) entry)
                (set-cmpl-prefix-entry-tail prefix-entry entry))
               (t
-               (set cmpl-db-prefix-symbol (make-cmpl-prefix-entry entry))
-               ))
+               (set cmpl-db-prefix-symbol (make-cmpl-prefix-entry entry))))
         ;; statistics
         (cmpl-statistics-block
           (note-added-completion))
         ;; set symbol
-        (set cmpl-db-symbol (car entry))
-        )))
+        (set cmpl-db-symbol (car entry)))))
 
 (defun add-completion-to-head (completion-string)
   "If COMPLETION-STRING is not in the database, add it to prefix list.
@@ -1298,8 +1256,7 @@ Returns the completion entry."
                                         (cmpl-read-time-eval
                                          completion-prefix-min-length))))
              (splice-ptr (locate-completion-entry cmpl-db-entry prefix-entry))
-             (cmpl-ptr (cdr splice-ptr))
-             )
+             (cmpl-ptr (cdr splice-ptr)))
         ;; update entry
         (set-completion-string cmpl-db-entry completion-string)
         ;; move to head (if necessary)
@@ -1312,8 +1269,7 @@ Returns the completion entry."
                    (set-cmpl-prefix-entry-tail prefix-entry splice-ptr))
                ;; splice in at head
                (setcdr cmpl-ptr (cmpl-prefix-entry-head prefix-entry))
-               (set-cmpl-prefix-entry-head prefix-entry cmpl-ptr)
-               ))
+               (set-cmpl-prefix-entry-head prefix-entry cmpl-ptr)))
         cmpl-db-entry)
     ;; not there
     (let (;; create an entry
@@ -1322,25 +1278,22 @@ Returns the completion entry."
           (prefix-entry (find-cmpl-prefix-entry
                           (substring cmpl-db-downcase-string 0
                                      (cmpl-read-time-eval
-                                      completion-prefix-min-length))))
-          )
+                                      completion-prefix-min-length)))))
       (cond (prefix-entry
              ;; Splice in at head
              (setcdr entry (cmpl-prefix-entry-head prefix-entry))
              (set-cmpl-prefix-entry-head prefix-entry entry))
             (t
              ;; Start new prefix entry
-             (set cmpl-db-prefix-symbol (make-cmpl-prefix-entry entry))
-             ))
+             (set cmpl-db-prefix-symbol (make-cmpl-prefix-entry entry))))
       ;; statistics
       (cmpl-statistics-block
         (note-added-completion))
       ;; Add it to the symbol
-      (set cmpl-db-symbol (car entry))
-      )))
+      (set cmpl-db-symbol (car entry)))))
       
 (defun delete-completion (completion-string)
-  "Deletes the completion from the database.
+  "Delete the completion from the database.
 String must be longer than `completion-prefix-min-length'."
   ;; Handle pending acceptance
   (if completion-to-accept (accept-completion))
@@ -1350,8 +1303,7 @@ String must be longer than `completion-prefix-min-length'."
                              (substring cmpl-db-downcase-string 0
                                         (cmpl-read-time-eval
                                          completion-prefix-min-length))))
-             (splice-ptr (locate-completion-entry cmpl-db-entry prefix-entry))
-             )
+             (splice-ptr (locate-completion-entry cmpl-db-entry prefix-entry)))
          ;; delete symbol reference
          (set cmpl-db-symbol nil)
          ;; remove from prefix list
@@ -1359,20 +1311,16 @@ String must be longer than `completion-prefix-min-length'."
                 ;; not at head
                 (or (setcdr splice-ptr (cdr (cdr splice-ptr)))
                     ;; fix up tail if necessary
-                    (set-cmpl-prefix-entry-tail prefix-entry splice-ptr))
-                )
+                    (set-cmpl-prefix-entry-tail prefix-entry splice-ptr)))
                (t
                 ;; at head
                 (or (set-cmpl-prefix-entry-head
                       prefix-entry (cdr (cmpl-prefix-entry-head prefix-entry)))
                     ;; List is now empty
-                    (set cmpl-db-prefix-symbol nil))
-                ))
+                    (set cmpl-db-prefix-symbol nil))))
          (cmpl-statistics-block
-           (note-completion-deleted))
-         )
-      (error "Unknown completion `%s'" completion-string)
-      ))
+           (note-completion-deleted)))
+      (error "Unknown completion `%s'" completion-string)))
 
 ;; Tests --
 ;;  - Add and Find -
@@ -1427,13 +1375,10 @@ String must be longer than `completion-prefix-min-length'."
          (new-prompt
           (if default
               (format "%s: (default: %s) " prompt default)
-              (format "%s: " prompt))
-           )
-         (read (completing-read new-prompt cmpl-obarray))
-         )
+              (format "%s: " prompt)))
+         (read (completing-read new-prompt cmpl-obarray)))
     (if (zerop (length read)) (setq read (or default "")))
-    (list read)
-    ))
+    (list read)))
 
 (defun check-completion-length (string)
   (if (< (length string) completion-min-length)
@@ -1454,8 +1399,7 @@ specified."
     
     (if num-uses (set-completion-num-uses entry num-uses))
     (if last-use-time
-        (set-completion-last-use-time entry last-use-time))
-    ))
+        (set-completion-last-use-time entry last-use-time))))
 
 (defun add-permanent-completion (string)
   "Add STRING if it isn't already listed, and mark it permanent."
@@ -1463,16 +1407,13 @@ specified."
     (interactive-completion-string-reader "Completion to add permanently"))
   (let ((current-completion-source (if (interactive-p)
                                        cmpl-source-interactive
-                                       current-completion-source))
-        )
-    (add-completion string nil t)
-    ))
+                                       current-completion-source)))
+    (add-completion string nil t)))
 
 (defun kill-completion (string)
   (interactive (interactive-completion-string-reader "Completion to kill"))
   (check-completion-length string)
-  (delete-completion string)
-  )
+  (delete-completion string))
 
 (defun accept-completion ()
   "Accepts the pending completion in `completion-to-accept'.
@@ -1481,13 +1422,11 @@ This bumps num-uses.  Called by `add-completion-to-head' and
   (let ((string completion-to-accept)
         ;; if this is added afresh here, then it must be a cdabbrev
         (current-completion-source cmpl-source-cdabbrev)
-        entry
-        )
+        entry)
     (setq completion-to-accept nil)
     (setq entry (add-completion-to-head string))
     (set-completion-num-uses entry (1+ (completion-num-uses entry)))
-    (setq cmpl-completions-accepted-p t)
-    ))
+    (setq cmpl-completions-accepted-p t)))
 
 (defun use-completion-under-point ()
   "Add the completion symbol underneath the point into the completion buffer."
@@ -1515,16 +1454,14 @@ Completions added this way will automatically be saved if
         (current-completion-source cmpl-source-separator)
         entry)
     (cmpl-statistics-block
-      (note-separator-character string)
-      )
+      (note-separator-character string))
     (cond (string
            (setq entry (add-completion-to-head string))
            (if (and completion-on-separator-character
                       (zerop (completion-num-uses entry)))
                (progn
                  (set-completion-num-uses entry 1)
-                 (setq cmpl-completions-accepted-p t)))))
-    ))
+                 (setq cmpl-completions-accepted-p t)))))))
 
 ;; Tests --
 ;;  - Add and Find -
@@ -1589,16 +1526,14 @@ STRING must be longer than `completion-prefix-min-length'."
            (downcase (substring string 0 completion-prefix-min-length))))
         cmpl-test-string string
         cmpl-test-regexp (concat (regexp-quote string) "."))
-  (completion-search-reset-1)
-  )
+  (completion-search-reset-1))
 
 (defun completion-search-reset-1 ()
   (setq cmpl-next-possibilities cmpl-starting-possibilities
         cmpl-next-possibility   nil
         cmpl-cdabbrev-reset-p nil
         cmpl-last-index -1
-        cmpl-tried-list nil
-        ))
+        cmpl-tried-list nil))
 
 (defun completion-search-next (index)
   "Return the next completion entry.
@@ -1615,8 +1550,7 @@ If there are no more entries, try cdabbrev and returns only a string."
      ;; do a "normal" search
      (while (and (completion-search-peek nil)
                  (< (setq index (1+ index)) 0))
-       (setq cmpl-next-possibility nil)
-       )
+       (setq cmpl-next-possibility nil))
      (cond ((not cmpl-next-possibilities))
             ;; If no more possibilities, leave it that way
            ((= -1 cmpl-last-index)
@@ -1628,8 +1562,7 @@ If there are no more entries, try cdabbrev and returns only a string."
             (setq cmpl-next-possibilities
                   (nthcdr (- (length cmpl-starting-possibilities)
                              (length cmpl-next-possibilities))
-                          cmpl-starting-possibilities))
-            )))
+                          cmpl-starting-possibilities)))))
     (t
      ;; non-negative index, reset and search
      ;;(prin1 'reset)
@@ -1637,13 +1570,10 @@ If there are no more entries, try cdabbrev and returns only a string."
      (setq cmpl-last-index index)
      (while (and (completion-search-peek t)
                  (not (< (setq index (1- index)) 0)))
-       (setq cmpl-next-possibility nil)
-       ))
-    )
+       (setq cmpl-next-possibility nil))))
   (prog1
       cmpl-next-possibility
-    (setq cmpl-next-possibility nil)
-    ))
+    (setq cmpl-next-possibility nil)))
       
 
 (defun completion-search-peek (use-cdabbrev)
@@ -1660,25 +1590,20 @@ If there are no more entries, try cdabbrev and then return only a string."
             (while
                 (and (not (eq 0 (string-match cmpl-test-regexp
                                               (completion-string (car cmpl-next-possibilities)))))
-                     (setq cmpl-next-possibilities (cdr cmpl-next-possibilities))
-                     ))
-            cmpl-next-possibilities
-            ))
+                     (setq cmpl-next-possibilities (cdr cmpl-next-possibilities))))
+            cmpl-next-possibilities))
      ;; successful match
      (setq cmpl-next-possibility (car cmpl-next-possibilities)
            cmpl-tried-list (cons (downcase (completion-string cmpl-next-possibility))
                                  cmpl-tried-list)
-           cmpl-next-possibilities (cdr cmpl-next-possibilities)
-           )
+           cmpl-next-possibilities (cdr cmpl-next-possibilities))
      cmpl-next-possibility)
     (use-cdabbrev
      ;; unsuccessful, use cdabbrev
      (cond ((not cmpl-cdabbrev-reset-p)
             (reset-cdabbrev cmpl-test-string cmpl-tried-list)
-            (setq cmpl-cdabbrev-reset-p t)
-            ))
-     (setq cmpl-next-possibility (next-cdabbrev))
-     )
+            (setq cmpl-cdabbrev-reset-p t)))
+     (setq cmpl-next-possibility (next-cdabbrev)))
     ;; Completely unsuccessful, return nil
     ))
 
@@ -1728,11 +1653,10 @@ If there are no more entries, try cdabbrev and then return only a string."
 ;;-----------------------------------------------
 
 (defun completion-mode ()
-  "Toggles whether or not to add new words to the completion database."
+  "Toggle whether or not to add new words to the completion database."
   (interactive)
   (setq enable-completion (not enable-completion))
-  (message "Completion mode is now %s." (if enable-completion "ON" "OFF"))
-  )
+  (message "Completion mode is now %s." (if enable-completion "ON" "OFF")))
         
 (defvar cmpl-current-index 0)
 (defvar cmpl-original-string nil)
@@ -1754,18 +1678,15 @@ Prefix args ::
          ;; Undo last one
          (delete-region cmpl-last-insert-location (point))
          ;; get next completion
-         (setq cmpl-current-index (+ cmpl-current-index (or arg 1)))
-         )
+         (setq cmpl-current-index (+ cmpl-current-index (or arg 1))))
         (t
          (if (not cmpl-initialized-p)
              (initialize-completions)) ;; make sure everything's loaded
          (cond ((consp current-prefix-arg) ;; control-u
                 (setq arg 0)
-                (setq cmpl-leave-point-at-start t)
-                )
+                (setq cmpl-leave-point-at-start t))
                (t
-                (setq cmpl-leave-point-at-start nil)
-                ))
+                (setq cmpl-leave-point-at-start nil)))
          ;; get string
          (setq cmpl-original-string (symbol-before-point-for-complete))
          (cond ((not cmpl-original-string)
@@ -1780,8 +1701,7 @@ Prefix args ::
          ;; reset database
          (completion-search-reset cmpl-original-string)
          ;; erase what we've got
-         (delete-region cmpl-symbol-start cmpl-symbol-end)
-         ))
+         (delete-region cmpl-symbol-start cmpl-symbol-end)))
 
   ;; point is at the point to insert the new symbol
   ;; Get the next completion
@@ -1790,8 +1710,7 @@ Prefix args ::
                (not (minibuffer-window-selected-p))))
          (insert-point (point))
          (entry (completion-search-next cmpl-current-index))
-         string
-         )
+         string)
     ;; entry is either a completion entry or a string (if cdabbrev)
 
     ;; If found, insert
@@ -1810,8 +1729,7 @@ Prefix args ::
                   (setq cmpl-last-insert-location (point))
                   (goto-char insert-point))
                  (t;; point at end,
-                  (setq cmpl-last-insert-location insert-point))
-                 )
+                  (setq cmpl-last-insert-location insert-point)))
            ;; statistics
            (cmpl-statistics-block
              (note-complete-inserted entry cmpl-current-index))
@@ -1829,9 +1747,7 @@ Prefix args ::
                                entry (completion-string entry)))
               (setq string (cmpl-merge-string-cases
                              string cmpl-original-string))
-              (message "Next completion: %s" string)
-              ))
-           )
+              (message "Next completion: %s" string))))
           (t;; none found, insert old 
            (insert cmpl-original-string)
            ;; Don't accept completions
@@ -1846,8 +1762,7 @@ Prefix args ::
            (cmpl-statistics-block
              (record-complete-failed cmpl-current-index))
            ;; Pretend that we were never here
-           (setq this-command 'failed-complete)
-           ))))
+           (setq this-command 'failed-complete)))))
 
 ;;---------------------------------------------------------------------------
 ;; Parsing definitions from files into the database
@@ -1859,20 +1774,18 @@ Prefix args ::
 
 ;; User interface
 (defun add-completions-from-file (file)
-  "Parse possible completions from a file and add them to data base."
+  "Parse possible completions from a FILE and add them to data base."
   (interactive "fFile: ")
   (setq file (expand-file-name file))
   (let* ((buffer (get-file-buffer file))
-         (buffer-already-there-p buffer)
-         )
+         (buffer-already-there-p buffer))
     (if (not buffer-already-there-p)
         (let ((completions-merging-modes nil))
           (setq buffer (find-file-noselect file))))
     (unwind-protect
          (save-excursion
            (set-buffer buffer)
-           (add-completions-from-buffer)
-           )
+           (add-completions-from-buffer))
       (if (not buffer-already-there-p)
           (kill-buffer buffer)))))
 
@@ -1882,40 +1795,31 @@ Prefix args ::
         (start-num
          (cmpl-statistics-block
           (aref completion-add-count-vector cmpl-source-file-parsing)))
-        mode
-        )
+        mode)
     (cond ((memq major-mode '(emacs-lisp-mode lisp-mode))
            (add-completions-from-lisp-buffer)
-           (setq mode 'lisp)
-           )
+           (setq mode 'lisp))
           ((memq major-mode '(c-mode))
            (add-completions-from-c-buffer)
-           (setq mode 'c)
-           )
+           (setq mode 'c))
           (t
            (error "Cannot parse completions in %s buffers"
-                  major-mode)
-           ))
+                  major-mode)))
     (cmpl-statistics-block
       (record-cmpl-parse-file
         mode (point-max)
         (- (aref completion-add-count-vector cmpl-source-file-parsing)
-           start-num)))
-    ))
+           start-num)))))
 
 ;; Find file hook
 (defun cmpl-find-file-hook ()
   (cond (enable-completion
          (cond ((and (memq major-mode '(emacs-lisp-mode lisp-mode))
-                     (memq 'lisp completions-merging-modes)
-                     )
+                     (memq 'lisp completions-merging-modes))
                 (add-completions-from-buffer))
                ((and (memq major-mode '(c-mode))
-                     (memq 'c completions-merging-modes)
-                     )
-                (add-completions-from-buffer)
-                )))
-        ))
+                     (memq 'c completions-merging-modes))
+                (add-completions-from-buffer))))))
 
 ;;-----------------------------------------------
 ;; Tags Table Completions
@@ -1935,10 +1839,8 @@ Prefix args ::
              (backward-char 3)
              (and (setq string (symbol-under-point))
                   (add-completion-to-tail-if-new string))
-             (forward-char 3)
-             )
-         (search-failed)
-         ))))
+             (forward-char 3))
+         (search-failed)))))
 
 
 ;;-----------------------------------------------
@@ -1952,8 +1854,7 @@ Prefix args ::
 ;;
 (defconst *lisp-def-regexp*
   "\n(\\(\\w*:\\)?def\\(\\w\\|\\s_\\)*\\s +(*"
-  "A regexp that searches for lisp definition form."
-  )
+  "A regexp that searches for Lisp definition form.")
 
 ;; Tests -
 ;;  (and (string-match *lisp-def-regexp* "\n(defun foo") (match-end 0)) -> 8
@@ -1973,10 +1874,8 @@ Prefix args ::
            (while t
              (re-search-forward *lisp-def-regexp*)
              (and (setq string (symbol-under-point))
-                  (add-completion-to-tail-if-new string))
-             )
-         (search-failed)
-         ))))
+                  (add-completion-to-tail-if-new string)))
+         (search-failed)))))
 
 
 ;;-----------------------------------------------
@@ -2000,8 +1899,7 @@ Prefix args ::
   (let ((table (make-syntax-table))
         (whitespace-chars '(?  ?\n ?\t ?\f  ?\v ?\r))
         ;; unfortunately the ?( causes the parens to appear unbalanced
-        (separator-chars '(?, ?* ?= ?\( ?\;
-                           ))
+        (separator-chars '(?, ?* ?= ?\( ?\;))
         i)
     ;; default syntax is whitespace
     (setq i 0)
@@ -2030,8 +1928,7 @@ Prefix args ::
   ;;"\n\\(\\(\\w\\|\\s_\\)+\\s *(\\|\\(\\(#define\\|auto\\|extern\\|register\\|static\\|int\\|long\\|short\\|unsigned\\|char\\|void\\|float\\|double\\|enum\\|struct\\|union\\|typedef\\)\\s +\\)+\\)"
   ;; this simple version picks up too much extraneous stuff
   ;; "\n\\(\\w\\|\\s_\\|#\\)\\B"
-  "A regexp that searches for a definition form."
-  )
+  "A regexp that searches for a definition form.")
 ;
 ;(defconst *c-cont-regexp*
 ;  "\\(\\w\\|\\s_\\)+\\b\\s *\\({\\|\\(\\[[0-9\t ]*\\]\\s *\\)*,\\(*\\|\\s \\)*\\b\\)"
@@ -2065,8 +1962,7 @@ Prefix args ::
   ;;  Sun 3/280-- 1250 lines/sec.
 
   (let (string next-point char
-        (saved-syntax (syntax-table))
-        )
+        (saved-syntax (syntax-table)))
     (save-excursion
       (goto-char (point-min))
       (catch 'finish-add-completions
@@ -2083,31 +1979,27 @@ Prefix args ::
                          ;; preprocessor macro, see if it's one we handle
                          (setq string (buffer-substring (point) (+ (point) 6)))
                          (cond ((or (string-equal string "define")
-                                    (string-equal string "ifdef ")
-                                    )
+                                    (string-equal string "ifdef "))
                                 ;; skip forward over definition symbol
                                 ;; and add it to database
                                 (and (forward-word 2)
                                      (setq string (symbol-before-point))
                                      ;;(push string foo)
-                                     (add-completion-to-tail-if-new string)
-                                     ))))
+                                     (add-completion-to-tail-if-new string)))))
                         (t
                          ;; C definition
                          (setq next-point (point))
                          (while (and
                                   next-point
                                   ;; scan to next separator char.
-                                  (setq next-point (scan-sexps next-point 1))
-                                  )
+                                  (setq next-point (scan-sexps next-point 1)))
                            ;; position the point on the word we want to add
                            (goto-char next-point)
                            (while (= (setq char (following-char)) ?*)
                              ;; handle pointer ref
                              ;; move to next separator char.
                              (goto-char
-                               (setq next-point (scan-sexps (point) 1)))
-                             )
+                               (setq next-point (scan-sexps (point) 1))))
                            (forward-word -1)
                            ;; add to database
                            (if (setq string (symbol-under-point))
@@ -2118,11 +2010,8 @@ Prefix args ::
                                         (progn
                                           (forward-word -1)
                                           (setq string
-                                                (symbol-under-point))
-                                          ))
-                                   (add-completion-to-tail-if-new string)
-                                   )
-                               )
+                                                (symbol-under-point))))
+                                   (add-completion-to-tail-if-new string)))
                            ;; go to next
                            (goto-char next-point)
                            ;; (push (format "%c" (following-char)) foo)
@@ -2130,16 +2019,12 @@ Prefix args ::
                                ;; if on an opening delimiter, go to end
                                (while (= (char-syntax char) ?\()
                                  (setq next-point (scan-sexps next-point 1)
-                                       char (char-after next-point))
-                                 )
+                                       char (char-after next-point)))
                                (or (= char ?,)
                                    ;; Current char is an end char.
-                                   (setq next-point nil)
-                                   ))
-                           ))))
+                                   (setq next-point nil)))))))
                   (search-failed ;;done
-                    (throw 'finish-add-completions t)
-                    )
+                    (throw 'finish-add-completions t))
                   (error
                     ;; Check for failure in scan-sexps
                     (if (or (string-equal (nth 1 e)
@@ -2149,11 +2034,8 @@ Prefix args ::
                         ;;(ding)
                         (forward-line 1)
                         (message "Error parsing C buffer for completions--please send bug report")
-                        (throw 'finish-add-completions t)
-                        ))
-                  ))
-          (set-syntax-table saved-syntax)
-          )))))
+                        (throw 'finish-add-completions t)))))
+          (set-syntax-table saved-syntax))))))
 
 
 ;;---------------------------------------------------------------------------
@@ -2206,8 +2088,7 @@ If file name is not specified, use `save-completions-file-name'."
                (total-in-db 0)
                (total-perm 0)
                (total-saved 0)
-               (backup-filename (completion-backup-filename filename))
-               )
+               (backup-filename (completion-backup-filename filename)))
     
           (save-excursion
             (get-buffer-create " *completion-save-buffer*")
@@ -2244,13 +2125,11 @@ If file name is not specified, use `save-completions-file-name'."
                              (or (not save-completions-retention-time)
                                  ;; or time since last use is < ...retention-time*
                                  (< (- current-time last-use-time)
-                                    save-completions-retention-time))
-                             )))
+                                    save-completions-retention-time)))))
                      ;; write to file
                      (setq total-saved (1+ total-saved))
                      (insert (prin1-to-string (cons (completion-string completion)
-                                                    last-use-time)) "\n")
-                     )))
+                                                    last-use-time)) "\n"))))
         
             ;; write the buffer
             (condition-case e
@@ -2275,14 +2154,11 @@ If file name is not specified, use `save-completions-file-name'."
                       (delete-file backup-filename)))
               (error
                (set-buffer-modified-p nil)
-               (message "Couldn't save completion file `%s'" filename)
-               ))
+               (message "Couldn't save completion file `%s'" filename)))
             ;; Reset accepted-p flag
-            (setq cmpl-completions-accepted-p nil) 
-            )
+            (setq cmpl-completions-accepted-p nil) )
           (cmpl-statistics-block
-           (record-save-completions total-in-db total-perm total-saved))
-          ))))
+           (record-save-completions total-in-db total-perm total-saved))))))
 
 ;;(defun auto-save-completions ()
 ;;  (if (and save-completions-flag enable-completion cmpl-initialized-p
@@ -2294,13 +2170,12 @@ If file name is not specified, use `save-completions-file-name'."
 ;;(add-hook 'cmpl-emacs-idle-time-hooks 'auto-save-completions)
 
 (defun load-completions-from-file (&optional filename no-message-p)
-  "Loads a completion init file FILENAME.
+  "Load a completion init file FILENAME.
 If file is not specified, then use `save-completions-file-name'."
   (interactive)
   (setq filename (expand-file-name (or filename save-completions-file-name)))
   (let* ((backup-filename (completion-backup-filename filename))
-         (backup-readable-p (file-readable-p backup-filename))
-         )
+         (backup-readable-p (file-readable-p backup-filename)))
     (if backup-readable-p (setq filename backup-filename))
     (if (file-readable-p filename)
         (progn
@@ -2324,8 +2199,7 @@ If file is not specified, then use `save-completions-file-name'."
                   (start-num
                    (cmpl-statistics-block
                     (aref completion-add-count-vector cmpl-source-file-parsing)))
-                  (total-in-file 0) (total-perm 0)
-                  )
+                  (total-in-file 0) (total-perm 0))
               ;; insert the file into a buffer
               (condition-case e
                   (progn (insert-file-contents filename t)
@@ -2353,61 +2227,50 @@ If file is not specified, then use `save-completions-file-name'."
                                    (setq last-use-time t))
                                   ((eq last-use-time t)
                                    (setq total-perm (1+ total-perm)))
-                                  ((integerp last-use-time))
-                                  ))
+                                  ((integerp last-use-time))))
                             ;; Valid entry
                             ;; add it in
                             (setq cmpl-last-use-time
                                   (completion-last-use-time
                                    (setq cmpl-entry
-                                         (add-completion-to-tail-if-new string))
-                                   ))
+                                         (add-completion-to-tail-if-new string))))
                             (if (or (eq last-use-time t) 
                                     (and (> last-use-time 1000);;backcompatibility
                                          (not (eq cmpl-last-use-time t))
                                          (or (not cmpl-last-use-time)
                                              ;; more recent
-                                             (> last-use-time  cmpl-last-use-time))
-                                         ))
+                                             (> last-use-time  cmpl-last-use-time))))
                                 ;; update last-use-time
-                                (set-completion-last-use-time cmpl-entry last-use-time)
-                              ))
+                                (set-completion-last-use-time cmpl-entry last-use-time)))
                            (t
                             ;; Bad format
                             (message "Error: invalid saved completion - %s"
                                      (prin1-to-string entry))
                             ;; try to get back in sync
-                            (search-forward "\n(")
-                            )))
+                            (search-forward "\n("))))
                       (search-failed
-                       (message "End of file while reading completions.")
-                       )
+                       (message "End of file while reading completions."))
                       (end-of-file
                        (if (= (point) (point-max))
                            (if (not no-message-p)
                                (message "Loading completions from file %s . . . Done."
                                         filename))
-                         (message "End of file while reading completions.")
-                         ))
-                      )))
+                         (message "End of file while reading completions."))))))
 
               (cmpl-statistics-block
                (record-load-completions
                 total-in-file total-perm
                 (- (aref completion-add-count-vector cmpl-source-init-file)
                    start-num)))
-
-              ))))))
+))))))
 
 (defun initialize-completions ()
   "Load the default completions file.
 Also sets up so that exiting emacs will automatically save the file."
   (interactive)
   (cond ((not cmpl-initialized-p)
-         (load-completions-from-file)
-         ))
-  (setq cmpl-initialized-p t)
-  )
+         (load-completions-from-file)))
+  (setq cmpl-initialized-p t))
 
 ;;-----------------------------------------------
 ;; Kill region patch
@@ -2454,16 +2317,14 @@ Patched to remove the most recent completion."
 (defun completion-separator-self-insert-command (arg)
   (interactive "p")
   (use-completion-before-separator)
-  (self-insert-command arg)
-  )
+  (self-insert-command arg))
 
 (defun completion-separator-self-insert-autofilling (arg)
   (interactive "p")
   (use-completion-before-separator)
   (self-insert-command arg)
   (and auto-fill-function
-       (funcall auto-fill-function))
-  )
+       (funcall auto-fill-function)))
 
 ;;-----------------------------------------------
 ;; Wrapping Macro
@@ -2475,25 +2336,25 @@ Patched to remove the most recent completion."
 (defmacro def-completion-wrapper (function-name type &optional new-name)
   "Add a call to update the completion database before function execution.
 TYPE is the type of the wrapper to be added.  Can be :before or :under."
-  (cond ((eq type ':separator)
+  (cond ((eq type :separator)
          (list 'put (list 'quote function-name) ''completion-function
                ''use-completion-before-separator))
-        ((eq type ':before)
+        ((eq type :before)
          (list 'put (list 'quote function-name) ''completion-function
                ''use-completion-before-point))
-        ((eq type ':backward-under)
+        ((eq type :backward-under)
          (list 'put (list 'quote function-name) ''completion-function
                ''use-completion-backward-under))
-        ((eq type ':backward)
+        ((eq type :backward)
          (list 'put (list 'quote function-name) ''completion-function
                ''use-completion-backward))
-        ((eq type ':under)
+        ((eq type :under)
          (list 'put (list 'quote function-name) ''completion-function
                ''use-completion-under-point))
-        ((eq type ':under-or-before)
+        ((eq type :under-or-before)
          (list 'put (list 'quote function-name) ''completion-function
                ''use-completion-under-or-before-point))
-        ((eq type ':minibuffer-separator)
+        ((eq type :minibuffer-separator)
          (list 'put (list 'quote function-name) ''completion-function
                ''use-completion-minibuffer-separator))))
 
@@ -2533,8 +2394,7 @@ TYPE is the type of the wrapper to be added.  Can be :before or :under."
   (define-key fortran-mode-map "+" 'completion-separator-self-insert-command)
   (define-key fortran-mode-map "-" 'completion-separator-self-insert-command)
   (define-key fortran-mode-map "*" 'completion-separator-self-insert-command)
-  (define-key fortran-mode-map "/" 'completion-separator-self-insert-command)
-  )
+  (define-key fortran-mode-map "/" 'completion-separator-self-insert-command))
 
 ;;; Enable completion mode.
   
@@ -2671,6 +2531,11 @@ TYPE is the type of the wrapper to be added.  Can be :before or :under."
 
   (initialize-completions))
 
+(mapc (lambda (x)
+        (add-to-list 'debug-ignored-errors x))
+      '("^To complete, the point must be after a symbol at least [0-9]* character long\\.$"
+        "^The string \".*\" is too short to be saved as a completion\\.$"))
+
 (provide 'completion)
 
 ;;; completion.el ends here