[emacs] remove bbdb — using ebdb now

1 files changed, 0 insertions, 4733 deletions

diff --git a/lisp/bbdb/bbdb.el b/lisp/bbdb/bbdb.el
deleted file mode 100644
index e38ac17..0000000
--- a/lisp/bbdb/bbdb.el
+++ /dev/null
@@ -1,4733 +0,0 @@
-;;; bbdb.el --- core of BBDB -*- lexical-binding: t -*-
-
-;; Copyright (C) 2010-2017  Free Software Foundation, Inc.
-
-;; Version: 3.2
-;; Package-Requires: ((emacs "24"))
-
-;; This file is part of the Insidious Big Brother Database (aka BBDB),
-
-;; BBDB is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; BBDB is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with BBDB.  If not, see <http://www.gnu.org/licenses/>.
-
-;;; Commentary:
-
-;; This file is the core of the Insidious Big Brother Database (aka BBDB),
-;; See the BBDB info manual for documentation.
-;;
-;;  -----------------------------------------------------------------------
-;; |  There is a mailing list for discussion of BBDB:                      |
-;; |         bbdb-user@nongnu.org                                          |
-;; |  To join, go to https://lists.nongnu.org/mailman/listinfo/bbdb-user   |
-;; |                                                                       |
-;; |  When joining this list or reporting bugs, please mention which       |
-;; |  version of BBDB you have.                                            |
-;;  -----------------------------------------------------------------------
-
-;;; Code:
-
-(require 'timezone)
-(require 'bbdb-site)
-
-;; When running BBDB, we have (require 'bbdb-autoloads)
-(declare-function widget-group-match "wid-edit")
-(declare-function bbdb-migrate "bbdb-migrate")
-(declare-function bbdb-do-records "bbdb-com")
-(declare-function bbdb-append-display-p "bbdb-com")
-(declare-function bbdb-toggle-records-layout "bbdb-com")
-(declare-function bbdb-dwim-mail "bbdb-com")
-(declare-function bbdb-layout-prefix "bbdb-com")
-(declare-function bbdb-completing-read-records "bbdb-com")
-(declare-function bbdb-merge-records "bbdb-com")
-(declare-function mail-position-on-field "sendmail")
-(declare-function vm-select-folder-buffer "vm-folder")
-
-;; cannot use autoload for variables...
-(defvar message-mode-map) ;; message.el
-(defvar mail-mode-map) ;; sendmail.el
-(defvar gnus-article-buffer) ;; gnus-art.el
-
-;; Custom groups
-
-(defgroup bbdb nil
-  "The Insidious Big Brother Database."
-  :group 'news
-  :group 'mail)
-
-(defgroup bbdb-record-display nil
-  "Variables that affect the display of BBDB records"
-  :group 'bbdb)
-
-(defgroup bbdb-record-edit nil
-  "Variables that affect the editing of BBDB records"
-  :group 'bbdb)
-
-(defgroup bbdb-sendmail nil
-  "Variables that affect sending mail."
-  :group 'bbdb)
-
-(defgroup bbdb-mua nil
-  "Variables that specify the BBDB-MUA interface"
-  :group 'bbdb)
-
-(defgroup bbdb-mua-gnus nil
-  "Gnus-specific BBDB customizations"
-  :group 'bbdb-mua)
-(put 'bbdb-mua-gnus 'custom-loads '(bbdb-gnus))
-
-(defgroup bbdb-mua-gnus-scoring nil
-  "Gnus-specific scoring BBDB customizations"
-  :group 'bbdb-mua-gnus)
-(put 'bbdb-mua-gnus-scoring 'custom-loads '(bbdb-gnus))
-
-(defgroup bbdb-mua-gnus-splitting nil
-  "Gnus-specific splitting BBDB customizations"
-  :group 'bbdb-mua-gnus)
-(put 'bbdb-mua-gnus-splitting 'custom-loads '(bbdb-gnus))
-
-(defgroup bbdb-mua-vm nil
-  "VM-specific BBDB customizations"
-  :group 'bbdb-mua)
-(put 'bbdb-mua-vm 'custom-loads '(bbdb-vm))
-
-(defgroup bbdb-mua-message nil
-  "Message-specific BBDB customizations"
-  :group 'bbdb-mua)
-(put 'bbdb-mua-message 'custom-loads '(bbdb-message))
-
-(defgroup bbdb-utilities nil
-  "Customizations for BBDB Utilities"
-  :group 'bbdb)
-
-(defgroup bbdb-utilities-dialing nil
-  "BBDB Customizations for phone number dialing"
-  :group 'bbdb)
-
-(defgroup bbdb-utilities-tex nil
-  "Customizations for TeXing BBDB."
-  :group 'bbdb)
-(put 'bbdb-utilities-tex 'custom-loads '(bbdb-tex))
-
-(defgroup bbdb-utilities-anniv nil
-  "Customizations for BBDB Anniversaries"
-  :group 'bbdb-utilities)
-(put 'bbdb-utilities-anniv 'custom-loads '(bbdb-anniv))
-
-(defgroup bbdb-utilities-ispell nil
-  "Customizations for BBDB ispell interface"
-  :group 'bbdb-utilities)
-(put 'bbdb-utilities-ispell 'custom-loads '(bbdb-ispell))
-
-(defgroup bbdb-utilities-snarf nil
-  "Customizations for BBDB snarf"
-  :group 'bbdb-utilities)
-(put 'bbdb-utilities-snarf 'custom-loads '(bbdb-snarf))
-
-(defgroup bbdb-utilities-pgp nil
-  "Customizations for BBDB pgp"
-  :group 'bbdb-utilities)
-(put 'bbdb-utilities-pgp 'custom-loads '(bbdb-pgp))
-
-(defgroup bbdb-utilities-sc nil
-  "Customizations for using Supercite with the BBDB."
-  :group 'bbdb-utilities
-  :prefix "bbdb-sc")
-(put 'bbdb-utilities-sc 'custom-loads '(bbdb-sc))
-
-;;; Customizable variables
-(defcustom bbdb-file (locate-user-emacs-file "bbdb" ".bbdb")
-  "The name of the Insidious Big Brother Database file."
-  :group 'bbdb
-  :type 'file)
-
-;; This should be removed, and the following put in place:
-;; a hierarchical structure of bbdb files, some perhaps read-only,
-;; perhaps caching in the local bbdb. This way one could have, e.g. an
-;; organization address book, with each person having access to it, and
-;; then a local address book with personal stuff in it.
-(defcustom bbdb-file-remote nil
-  "The remote file to save the BBDB database to.
-When this is non-nil, it should be a file name.
-When BBDB reads `bbdb-file', it also checks this file,
-and if it is newer than `bbdb-file', it loads this file.
-When BBDB writes `bbdb-file', it also writes this file.
-
-This feature allows one to keep the database in one place while using
-different computers, thus reducing the need for merging different files."
-  :group 'bbdb
-  :type '(choice (const :tag "none" nil)
-                 (file :tag "remote file name")))
-
-(defcustom bbdb-file-remote-save-always t
-  "If t `bbdb-file-remote' is saved automatically when `bbdb-file' is saved.
-When nil, ask."
-  :group 'bbdb
-  :type 'boolean)
-
-(defcustom bbdb-read-only nil
-  "If t then BBDB will not modify `bbdb-file'.
-If you have more than one Emacs running at the same time, you might want
-to set this to t in all but one of them."
-  :group 'bbdb
-  :type '(choice (const :tag "Database is read-only" t)
-                 (const :tag "Database is writable" nil)))
-
-(defcustom bbdb-auto-revert nil
-  "If t revert unchanged database without querying.
-If t and `bbdb-file' has changed on disk, while the database
-has not been modified inside Emacs, revert the database automatically.
-If nil or the database has been changed inside Emacs, always query
-before reverting."
-  :group 'bbdb
-  :type '(choice (const :tag "Revert unchanged database without querying" t)
-                 (const :tag "Ask before reverting database" nil)))
-
-(defcustom bbdb-check-auto-save-file nil
-  "If t BBDB will check its auto-save file.
-If this file is newer than `bbdb-file', BBDB will offer to revert."
-  :group 'bbdb
-  :type '(choice (const :tag "Check auto-save file" t)
-                 (const :tag "Do not check auto-save file" nil)))
-
-(defcustom bbdb-before-save-hook nil
-  "Hook run before saving `bbdb-file'."
-  :group 'bbdb
-  :type 'hook)
-
-(defcustom bbdb-after-save-hook nil
-  "Hook run after saving `bbdb-file'."
-  :group 'bbdb
-  :type 'hook)
-
-(defcustom bbdb-create-hook nil
-  "*Hook run each time a new BBDB record is created.
-Run with one argument, the new record.  This is called before the record is
-added to the database, followed by a call of `bbdb-change-hook'.
-
-If a record has been created by analyzing a mail message, hook functions
-can use the variable `bbdb-update-records-address' to determine the header
-and class of the mail address according to `bbdb-message-headers'."
-  :group 'bbdb
-  :type 'hook)
-
-(defcustom bbdb-change-hook nil
-  "*Hook run each time a BBDB record is changed.
-Run with one argument, the record.  This is called before the database
-is modified.  If a new bbdb record is created, `bbdb-create-hook' is called
-first, followed by a call of this hook."
-  :group 'bbdb
-  :type 'hook)
-
-(defcustom bbdb-merge-records-function nil
-  "If non-nil, a function for merging two records.
-This function is called when loading a record into BBDB that has the same uuid
-as an exisiting record.  If nil use `bbdb-merge-records'.
-This function should take two arguments RECORD1 and RECORD2, with RECORD2
-being the already existing record.  It should merge RECORD1 into RECORD2,
-and return RECORD2."
-  :group 'bbdb
-  :type 'function)
-
-(defcustom bbdb-time-stamp-format "%Y-%m-%d %T %z"
-  "The BBDB time stamp format.  See `format-time-string'.
-This function is called with arg UNIVERSAL being non-nil."
-  :group 'bbdb
-  :type 'string)
-
-(defcustom bbdb-after-change-hook nil
-  "Hook run each time a BBDB record is changed.
-Run with one argument, the record.  This is called after the database
-is modified.  So if you want to modify a record when it is created or changed,
-use instead `bbdb-create-hook' and / or `bbdb-change-hook'."
-  :group 'bbdb
-  :type 'hook)
-
-(defcustom bbdb-after-read-db-hook nil
-  "Hook run (with no arguments) after `bbdb-file' is read.
-Note that this can be called more than once if the BBDB is reverted."
-  :group 'bbdb
-  :type 'hook)
-
-(defcustom bbdb-initialize-hook nil
-  "Normal hook run after the BBDB initialization function `bbdb-initialize'."
-  :group 'bbdb
-  :type 'hook)
-
-(defcustom bbdb-mode-hook nil
-  "Normal hook run when the *BBDB* buffer is created."
-  :group 'bbdb
-  :type 'hook)
-
-(defcustom bbdb-silent nil
-  "If t, BBDB suppresses all its informational messages and queries.
-Be very very certain you want to set this to t, because it will suppress
-queries to alter record names, assign names to addresses, etc.
-Lisp Hackers: See also `bbdb-silent-internal'."
-  :group 'bbdb
-  :type '(choice (const :tag "Run silently" t)
-                 (const :tag "Disable silent running" nil)))
-
-(defcustom bbdb-info-file nil
-  "Location of the bbdb info file, if it's not in the standard place."
-  :group 'bbdb
-  :type '(choice (const :tag "Standard location" nil)
-                 (file :tag "Nonstandard location")))
-
-
-;;; Record display
-
-(defcustom bbdb-pop-up-window-size 0.5
-  "Vertical size of BBDB window (vertical split).
-If it is an integer number, it is the number of lines used by BBDB.
-If it is a fraction between 0.0 and 1.0 (inclusive), it is the fraction
-of the tallest existing window that BBDB will take over.
-If it is t use `display-buffer'/`pop-to-buffer' to create the BBDB window.
-See also `bbdb-mua-pop-up-window-size'."
-  :group 'bbdb-record-display
-  :type '(choice (number :tag "BBDB window size")
-                 (const :tag "Use `pop-to-buffer'" t)))
-
-(defcustom bbdb-dedicated-window nil
-  "Make *BBDB* window a dedicated window.
-Allowed values include nil (not dedicated) 'bbdb (weakly dedicated)
-and t (strongly dedicated)."
-  :group 'bbdb-record-display
-  :type '(choice (const :tag "BBDB window not dedicated" nil)
-                 (const :tag "BBDB window weakly dedicated" bbdb)
-                 (const :tag "BBDB window strongly dedicated" t)))
-
-(defcustom bbdb-layout-alist
-  '((one-line           (order     . (phone mail-alias mail notes))
-                        (name-end  . 24)
-                        (toggle    . t))
-    (multi-line         (omit      . (uuid creation-date timestamp
-                                           name-format name-face))
-                        (toggle    . t)
-                        (indentation . 21))
-    (pop-up-multi-line  (omit      . (uuid creation-date timestamp
-                                           name-format name-face))
-                        (indentation . 21))
-    (full-multi-line    (indentation . 21)))
-  "Alist describing each display layout.
-The format of an element is (LAYOUT-NAME OPTION-ALIST).
-
-By default there are four different layout types used by BBDB, which are
-`one-line', `multi-line', `pop-up-multi-line' (used for pop-ups) and
-`full-multi-line' (showing all fields of a record).
-
-OPTION-ALIST specifies the options for the layout.  Valid options are:
-
-                           ------- Availability --------
-    Format                  one-line        multi-line        default if unset
-------------------------------------------------------------------------------
- (toggle . BOOL)                 +               +              nil
- (order . FIELD-LIST)            +               +              '(phone ...)
- (omit . FIELD-LIST)             +               +              nil
- (name-end . INTEGER)            +               -              40
- (indentation . INTEGER)         -               +              21
- (primary . BOOL)                -               +              nil
- (display-p . FUNCTION)          +               +              nil
-
-- toggle: controls if this layout is included when toggeling the layout
-- order: defines a user specific order for the fields, where t is a place
-  holder for all remaining fields
-- omit: is a list of xfields which should not be displayed
-  or t to exclude all xfields except those listed in the order option
-- name-end: sets the column where the name should end in one-line layout.
-- indentation: sets the level of indentation for multi-line display.
-- primary: controls whether only the primary mail is shown or all are shown.
-- display-p: a function controlling whether the record is to be displayed.
-
-When you add a new layout FOO, you can write a corresponding layout
-function `bbdb-display-record-layout-FOO'.  If you do not write your own
-layout function, the multi-line layout will be used."
-  :group 'bbdb-record-display
-  :type
-  `(repeat
-    (cons :tag "Layout Definition"
-          (choice :tag "Layout type"
-                  (const one-line)
-                  (const multi-line)
-                  (const pop-up-multi-line)
-                  (const full-multi-line)
-                  (symbol))
-          (set :tag "Properties"
-               (cons :tag "Order"
-                     (const :tag "List of fields to order by" order)
-                     (repeat (choice (const phone)
-                                     (const address)
-                                     (const mail)
-                                     (const AKA)
-                                     (const notes)
-                                     (symbol :tag "other")
-                                     (const :tag "Remaining fields" t))))
-               (choice :tag "Omit"
-                       :value (omit . nil)
-                       (cons :tag "List of fields to omit"
-                             (const :tag "Fields not to display" omit)
-                             (repeat (choice (const phone)
-                                             (const address)
-                                             (const mail)
-                                             (const AKA)
-                                             (const notes)
-                                             (symbol :tag "other"))))
-                       (const :tag "Exclude all fields except those listed in the order note" t))
-               (cons :tag "Indentation"
-                     :value (indentation . 14)
-                     (const :tag "Level of indentation for multi-line layout"
-                            indentation)
-                     (number :tag "Column"))
-               (cons :tag "End of name field"
-                     :value (name-end . 24)
-                     (const :tag "The column where the name should end in one-line layout"
-                            name-end)
-                     (number :tag "Column"))
-               (cons :tag "Toggle"
-                     (const :tag "The layout is included when toggling layout" toggle)
-                     boolean)
-               (cons :tag "Primary Mail Only"
-                     (const :tag "Only the primary mail address is included" primary)
-                     boolean)
-               (cons :tag "Display-p"
-                     (const :tag "Show only records passing this test" display-p)
-                     (choice (const :tag "No test" nil)
-                             (function :tag "Predicate")))))))
-
-(defcustom bbdb-layout 'multi-line
-  "Default display layout."
-  :group 'bbdb-record-display
-  :type '(choice (const one-line)
-                 (const multi-line)
-                 (const full-multi-line)
-                 (symbol)))
-
-(defcustom bbdb-pop-up-layout 'pop-up-multi-line
-  "Default layout for pop-up BBDB buffers (mail, news, etc.)."
-  :group 'bbdb-record-display
-  :type '(choice (const one-line)
-                 (const multi-line)
-                 (const full-multi-line)
-                 (symbol)))
-
-(defcustom bbdb-wrap-column nil
-  "Wrap column for multi-line display.  If nil do not wrap lines."
-  :group 'bbdb-record-display
-  :type '(choice (const :tag "No line wrapping" nil)
-                 (number :tag "Wrap column")))
-
-(defcustom bbdb-case-fold-search (default-value 'case-fold-search)
-  "Value of `case-fold-search' used by BBDB and friends.
-This variable lets the case-sensitivity of the BBDB commands
-be different from standard commands like command `isearch-forward'."
-  :group 'bbdb-record-display
-  :type 'boolean)
-
-(defcustom bbdb-name-format 'first-last
-  "Format for displaying names.
-If first-last names are displayed as \"Firstname Lastname\".
-If last-first names are displayed as \"Lastname, Firstname\".
-This can be overriden per record via the xfield name-format,
-which should take the same values.
-See also `bbdb-read-name-format'."
-  :group 'bbdb-record-display
-  :type '(choice (const :tag "Firstname Lastname" first-last)
-                 (const :tag "Lastname, Firstname" last-first)))
-
-;; See http://en.wikipedia.org/wiki/Postal_address
-;; http://www.upu.int/en/activities/addressing/postal-addressing-systems-in-member-countries.html
-(defcustom bbdb-address-format-list
-  '((("Argentina") "spcSC" "@%s\n@%p, @%c@, %S@\n%C@" "@%c@")
-    (("Australia") "scSpC" "@%s\n@%c@ %S@ %p@\n%C@" "@%c@")
-    (("Austria" "Germany" "Spain" "Switzerland")
-     "spcSC" "@%s\n@%p @%c@ (%S)@\n%C@" "@%c@")
-    (("Canada") "scSCp" "@%s\n@%c@, %S@\n%C@ %p@" "@%c@")
-    (("China") "scpSC" "@%s\n@%c@\n%p@ %S@\n%C@" "@%c@") ; English format
-    ; (("China") "CpScs" "@%C @%p\n@%S @%c@ %s@" "@%c@") ; Chinese format
-    (("India") "scpSC" "@%s\n@%c@ %p@ (%S)@\n%C@" "@%c@")
-    (("USA") "scSpC" "@%s\n@%c@, %S@ %p@\n%C@" "@%c@")
-    (t bbdb-edit-address-default bbdb-format-address-default "@%c@"))
-  "List of address editing and formatting rules for BBDB.
-Each rule is a list (IDENTIFIER EDIT FORMAT FORMAT).
-The first rule for which IDENTIFIER matches an address is used for editing
-and formatting the address.
-
-IDENTIFIER may be a list of countries.
-IDENTIFIER may also be a function that is called with one arg, the address
-to be used.  The rule applies if the function returns non-nil.
-See `bbdb-address-continental-p' for an example.
-If IDENTIFIER is t, this rule always applies.  Usually, this should be
-the last rule that becomes a fall-back (default).
-
-EDIT may be a function that is called with one argument, the address.
-See `bbdb-edit-address-default' for an example.
-
-EDIT may also be an editting format string.  It is a string containing
-the five letters s, c, p, S, and C that specify the order for editing
-the five elements of an address:
-
-s  streets
-c  city
-p  postcode
-S  state
-C  country
-
-The first FORMAT of each rule is used for multi-line layout, the second FORMAT
-is used for one-line layout.
-
-FORMAT may be a function that is called with one argument, the address.
-See `bbdb-format-address-default' for an example.
-
-FORMAT may also be a format string.  It consists of formatting elements
-separated by a delimiter defined via the first (and last) character of FORMAT.
-Each formatting element may contain one of the following format specifiers:
-
-%s  streets (used repeatedly for each street part)
-%c  city
-%p  postcode
-%S  state
-%C  country
-
-A formatting element will be applied only if the corresponding part
-of the address is a non-empty string.
-
-See also `bbdb-tex-address-format-list'."
-  :group 'bbdb-record-display
-  :type '(repeat (list (choice (const :tag "Default" t)
-                               (function :tag "Function")
-                               (repeat (string)))
-                       (choice (string)
-                               (function :tag "Function"))
-                       (choice (string)
-                               (function :tag "Function"))
-                       (choice (string)
-                               (function :tag "Function")))))
-
-(defcustom bbdb-continental-postcode-regexp
-  "^\\s *[A-Z][A-Z]?\\s *-\\s *[0-9][0-9][0-9]"
-  "Regexp matching continental postcodes.
-Used by address format identifier `bbdb-address-continental-p'.
-The regexp should match postcodes of the form CH-8052, NL-2300RA,
-and SE-132 54."
-  :group 'bbdb-record-display
-  :type 'regexp)
-
-(defcustom bbdb-default-separator '("[,;]" ", ")
-  "The default field separator.  It is a list (SPLIT-RE JOIN).
-This is used for fields which do not have an entry in `bbdb-separator-alist'.
-Whitespace surrounding SPLIT-RE is ignored."
-  :group 'bbdb-record-display
-  :type '(list regexp string))
-
-(defcustom bbdb-separator-alist
-  '((record "\n\n" "\n\n") ; used by `bbdb-copy-fields-as-kill'
-    (name-first-last "[ ,;]" " ") (name-last-first "[ ,;]" ", ")
-    (name-field ":\n" ":\n") ; used by `bbdb-copy-fields-as-kill'
-    (phone "[,;]" ", ") (address ";\n" ";\n") ; ditto
-    (organization "[,;]" ", ") (affix "[,;]"  ", ") (aka "[,;]" ", ")
-    (mail "[,;]" ", ") (mail-alias "[,;]" ", ") (vm-folder "[,;]" ", ")
-    (birthday "\n" "\n") (wedding "\n" "\n") (anniversary "\n" "\n")
-    (notes "\n" "\n") (tex-name "#" " # "))
-  "Alist of field separators.
-Each element is of the form (FIELD SPLIT-RE JOIN).
-Whitespace surrounding SPLIT-RE is ignored.
-For fields lacking an entry here `bbdb-default-separator' is used instead."
-  :group 'bbdb-record-display
-  :type '(repeat (list symbol regexp string)))
-
-(defcustom bbdb-user-menu-commands nil
-  "User defined menu entries which should be appended to the BBDB menu.
-This should be a list of menu entries.
-When set to a function, it is called with two arguments RECORD and FIELD
-and it should either return nil or a list of menu entries.
-Used by `bbdb-mouse-menu'."
-  :group 'bbdb-record-display
-  :type 'sexp)
-
-(defcustom bbdb-display-hook nil
-  "Hook run after the *BBDB* is filled in."
-  :group 'bbdb-record-display
-  :type 'hook)
-
-(defcustom bbdb-multiple-buffers nil
-  "When non-nil we create a new buffer of every buffer causing pop-ups.
-You can also set this to a function returning a buffer name.
-Here a value may be the predefined function `bbdb-multiple-buffers-default'."
-  :group 'bbdb-record-display
-  :type '(choice (const :tag "Disabled" nil)
-                 (function :tag "Enabled" bbdb-multiple-buffers-default)
-                 (function :tag "User defined function")))
-
-(defcustom bbdb-image nil
-  "If non-nil display records with an image.
-If a symbol this should be an xfield holding the name of the image file
-associated with the record.  If it is `name' or `fl-name', the first and last
-name of the record are used as file name.  If it is `lf-name', the last and
-first name of the record are used as file name.
-If a function it is called with one arg, the record, and it should return
-the name of the image file.
-The file is searched in the directories in `bbdb-image-path'.
-File name suffixes are appended according to `bbdb-image-suffixes'.
-See `locate-file'."
-  :group 'bbdb-record-display
-  :type '(choice (const :tag "Disabled" nil)
-                 (function :tag "User defined function")
-                 (symbol :tag "Record field")))
-
-(defcustom bbdb-image-path nil
-  "List of directories to search for `bbdb-image'."
-  :group 'bbdb-record-display
-  :type '(repeat (directory)))
-
-(defcustom bbdb-image-suffixes '(".png" ".jpg" ".gif" ".xpm")
-  "List of file name suffixes searched for `bbdb-image'."
-  :group 'bbdb-record-display
-  :type '(repeat (string :tag "File suffix")))
-
-(defcustom bbdb-read-name-format 'fullname
-  "Default format for reading names via `bbdb-read-name'.
-If it is 'first-last read first and last name separately.
-If it is 'last-first read last and first name separately.
-With any other value read full name at once.
-See also `bbdb-name-format'."
-  :group 'bbdb-record-display
-  :type '(choice (const :tag "Firstname Lastname" first-last)
-                 (const :tag "Lastname, Firstname" last-first)
-                 (const :tag "Full name" fullname)))
-
-
-;;; Record editing
-(defcustom bbdb-lastname-prefixes
- '("von" "de" "di")
-  "List of lastname prefixes recognized in name fields.
-Used to enhance dividing name strings into firstname and lastname parts.
-Case is ignored."
-  :group 'bbdb-record-edit
-  :type '(repeat string))
-
-(defcustom bbdb-lastname-re
-  (concat "[- \t]*\\(\\(?:\\<"
-          (regexp-opt bbdb-lastname-prefixes)
-          ;; multiple last names concatenated by `-'
-          "\\>[- \t]+\\)?\\(?:\\w+[ \t]*-[ \t]*\\)*\\w+\\)\\'")
-  "Regexp matching the last name of a full name.
-Its first parenthetical subexpression becomes the last name."
-  :group 'bbdb-record-edit
-  :type 'regexp)
-
-(defcustom bbdb-lastname-suffixes
- '("Jr" "Sr" "II" "III")
-  "List of lastname suffixes recognized in name fields.
-Used to dividing name strings into firstname and lastname parts.
-All suffixes are complemented by optional `.'.  Case is ignored."
-  :group 'bbdb-record-edit
-  :type '(repeat string))
-
-(defcustom bbdb-lastname-suffix-re
-  (concat "[-,. \t/\\]+\\("
-          (regexp-opt bbdb-lastname-suffixes)
-          ;; suffices are complemented by optional `.'.
-          "\\.?\\)\\W*\\'")
-  "Regexp matching the suffix of a last name.
-Its first parenthetical subexpression becomes the suffix."
-  :group 'bbdb-record-edit
-  :type 'regexp)
-
-(defcustom bbdb-default-domain nil
-  "Default domain to append when reading a new mail address.
-If a mail address does not contain `[@%!]', append @`bbdb-default-domain' to it.
-
-The address is not altered if `bbdb-default-domain' is nil
-or if a prefix argument is given to the command `bbdb-insert-field'."
-  :group 'bbdb-record-edit
-  :type '(choice (const :tag "none" nil)
-                 (string :tag "Default Domain")))
-
-(defcustom bbdb-phone-style 'nanp
-  "Phone numbering plan assumed by BBDB.
-The value 'nanp refers to the North American Numbering Plan.
-The value nil refers to a free-style numbering plan.
-
-You can have both styles of phone number in your database by providing a
-prefix argument to the command `bbdb-insert-field'."
-  :group 'bbdb-record-edit
-  :type '(choice (const :tag "NANP" nanp)
-                 (const :tag "none" nil)))
-
-(defcustom bbdb-default-area-code nil
-  "Default area code to use when reading a new phone number.
-This variable also affects dialing."
-  :group 'bbdb-record-edit
-  :type '(choice (const :tag "none" nil)
-                 (integer :tag "Default Area Code"))
-  :set (lambda( symb val )
-         (if (or (and (stringp val)
-                      (string-match "^[0-9]+$" val))
-                 (integerp val)
-                 (null val))
-             (set symb val)
-           (error "%s must contain digits only." symb))))
-
-(defcustom bbdb-allow-duplicates nil
-  "When non-nil BBDB allows records with duplicate names and email addresses.
-In rare cases, this may lead to confusion with BBDB's MUA interface."
-  :group 'bbdb-record-edit
-  :type 'boolean)
-
-(defcustom bbdb-default-label-list '("home" "work" "other")
-  "Default list of labels for Address and Phone fields."
-  :group 'bbdb-record-edit
-  :type '(repeat string))
-
-(defcustom bbdb-address-label-list bbdb-default-label-list
-  "List of labels for Address field."
-  :group 'bbdb-record-edit
-  :type '(repeat string))
-
-(defcustom bbdb-phone-label-list '("home" "work" "cell" "other")
-  "List of labels for Phone field."
-  :group 'bbdb-record-edit
-  :type '(repeat string))
-
-(defcustom bbdb-default-country "Emacs";; what do you mean, it's not a country?
-  "Default country to use if none is specified."
-  :group 'bbdb-record-edit
-  :type '(choice (const :tag "None" nil)
-                 (string :tag "Default Country")))
-
-(defcustom bbdb-check-postcode t
-  "If non-nil, require legal postcodes when entering an address.
-The format of legal postcodes is determined by the variable
-`bbdb-legal-postcodes'."
-  :group 'bbdb-record-edit
-  :type 'boolean)
-
-(defcustom bbdb-legal-postcodes
-  '(;; empty string
-    "^$"
-    ;; Matches 1 to 6 digits.
-    "^[ \t\n]*[0-9][0-9]?[0-9]?[0-9]?[0-9]?[0-9]?[ \t\n]*$"
-    ;; Matches 5 digits and 3 or 4 digits.
-    "^[ \t\n]*\\([0-9][0-9][0-9][0-9][0-9]\\)[ \t\n]*-?[ \t\n]*\\([0-9][0-9][0-9][0-9]?\\)[ \t\n]*$"
-    ;; Match postcodes for Canada, UK, etc. (result is ("LL47" "U4B")).
-    "^[ \t\n]*\\([A-Za-z0-9]+\\)[ \t\n]+\\([A-Za-z0-9]+\\)[ \t\n]*$"
-    ;; Match postcodes for continental Europe.  Examples "CH-8057"
-    ;; or "F - 83320" (result is ("CH" "8057") or ("F" "83320")).
-    ;; Support for "NL-2300RA" added at request from Carsten Dominik
-    ;; <dominik@astro.uva.nl>
-    "^[ \t\n]*\\([A-Z]+\\)[ \t\n]*-?[ \t\n]*\\([0-9]+ ?[A-Z]*\\)[ \t\n]*$"
-    ;; Match postcodes from Sweden where the five digits are grouped 3+2
-    ;; at the request from Mats Lofdahl <MLofdahl@solar.stanford.edu>.
-    ;; (result is ("SE" (133 36)))
-    "^[ \t\n]*\\([A-Z]+\\)[ \t\n]*-?[ \t\n]*\\([0-9]+\\)[ \t\n]+\\([0-9]+\\)[ \t\n]*$")
-  "List of regexps that match legal postcodes.
-Whether this is used at all depends on the variable `bbdb-check-postcode'."
-  :group 'bbdb-record-edit
-  :type '(repeat regexp))
-
-(defcustom bbdb-default-xfield 'notes
-  "Default xfield when editing BBDB records."
-  :group 'bbdb-record-edit
-  :type '(symbol :tag "Xfield"))
-
-(defcustom bbdb-edit-foo (cons bbdb-default-xfield 'current-fields)
-  "Fields to edit with command `bbdb-edit-foo'.
-This is a cons pair (WITHOUT-PREFIX . WITH-PREFIX).
-The car is used if the command is called without a prefix.
-The cdr is used if the command is called with a prefix.
-
-WITHOUT-PREFIX and WITH-PREFIX may take the values:
- name            The full name
- affix           The list of affixes
- organization    The list of organizations
- aka             the list of AKAs
- mail            the list of email addresses
- phone           the list of phone numbers
- address         the list of addresses
- current-fields  Read the field to edit using a completion table
-                   that includes all fields of the current record.
- all-fields      Read the field to edit using a completion table
-                   that includes all fields currently known to BBDB.
-
-Any other symbol is interpreted as the label of an xfield."
-  :group 'bbdb-record-edit
-  :type '(cons (symbol :tag "Field without prefix")
-               (symbol :tag "Field with prefix")))
-
-
-;;; MUA interface
-
-(defcustom bbdb-annotate-field bbdb-default-xfield
-  "Field to annotate via `bbdb-annotate-record' and friends.
-This may take the values:
- affix           The list of affixes
- organization    The list of organizations
- aka             the list of AKAs
- mail            the list of email addresses
- all-fields      Read the field to edit using a completion table
-                   that includes all fields currently known to BBDB.
-
-Any other symbol is interpreted as the label of an xfield."
-  :group 'bbdb-mua
-  :type '(symbol :tag "Field to annotate"))
-
-(defcustom bbdb-mua-edit-field bbdb-default-xfield
-  "Field to edit with command `bbdb-mua-edit-field' and friends.
-This may take the values:
- name            The full name
- affix           The list of affixes
- organization    The list of organizations
- aka             the list of AKAs
- mail            the list of email addresses
- all-fields      Read the field to edit using a completion table
-                   that includes all fields currently known to BBDB.
-
-Any other symbol is interpreted as the label of an xfield."
-  :group 'bbdb-mua
-  :type '(symbol :tag "Field to edit"))
-
-(defcustom bbdb-mua-update-interactive-p '(search . query)
-  "How BBDB's interactive MUA commands update BBDB records.
-This is a cons pair (WITHOUT-PREFIX . WITH-PREFIX).
-The car is used if the command is called without a prefix.
-The cdr is used if the command is called with a prefix (and if the prefix
-        is not used for another purpose).
-
-WITHOUT-PREFIX and WITH-PREFIX may take the values
-\(here ADDRESS is an email address found in a message):
- nil          Do nothing.
- search       Search for existing records matching ADDRESS.
- update       Search for existing records matching ADDRESS;
-                update name and mail field if necessary.
- query        Search for existing records matching ADDRESS;
-                query for creation of a new record if the record does not exist.
- create or t  Search for existing records matching ADDRESS;
-                create a new record if it does not yet exist.
- a function   This functions will be called with no arguments.
-                It should return one of the above values.
- read         Read the value interactively."
-  :group 'bbdb-mua
-  :type '(cons (choice (const :tag "do nothing" nil)
-                       (const :tag "search for existing records" search)
-                       (const :tag "update existing records" update)
-                       (const :tag "query annotation of all messages" query)
-                       (const :tag "annotate all messages" create)
-                       (function :tag "User-defined function")
-                       (const :tag "read arg interactively" read))
-               (choice (const :tag "do nothing" nil)
-                       (const :tag "search for existing records" search)
-                       (const :tag "update existing records" update)
-                       (const :tag "query annotation of all messages" query)
-                       (const :tag "annotate all messages" create)
-                       (function :tag "User-defined function")
-                       (const :tag "read arg interactively" read))))
-
-(defcustom bbdb-mua-auto-update-p 'bbdb-select-message
-  "How `bbdb-mua-auto-update' updates BBDB records automatically.
-
-Allowed values are (here ADDRESS is an email address found in a message):
- nil          Do nothing.
- search       Search for existing records matching ADDRESS.
- update       Search for existing records matching ADDRESS;
-                update name and mail field if necessary.
- query        Search for existing records matching ADDRESS;
-                query for creation of a new record if the record does not exist.
- create or t  Search for existing records matching ADDRESS;
-                create a new record if it does not yet exist.
- a function   This functions will be called with no arguments.
-                It should return one of the above values.
-                For an example, see `bbdb-select-message' with
-                `bbdb-mua-update-records-p', `bbdb-accept-message-alist'
-                and `bbdb-ignore-message-alist'.
-
-To initiate auto-updating of BBDB records, call `bbdb-mua-auto-update-init'
-for the respective MUAs in your init file."
-  :group 'bbdb-mua
-  :type '(choice (const :tag "do nothing" nil)
-                 (const :tag "search for existing records" search)
-                 (const :tag "update existing records" update)
-                 (const :tag "query annotation of all messages" query)
-                 (const :tag "annotate all messages" create)
-                 (function :tag "User-defined function")))
-
-(defcustom bbdb-update-records-p 'search
-  "Return value for `bbdb-select-message' and friends.
-These functions can select messages for further processing by BBDB,
-The amount of subsequent processing is determined by `bbdb-update-records-p'.
-
-Allowed values are (here ADDRESS is an email address selected
-by `bbdb-select-message'):
- nil          Do nothing.
- search       Search for existing records matching ADDRESS.
- update       Search for existing records matching ADDRESS;
-                update name and mail field if necessary.
- query        Search for existing records matching ADDRESS;
-                query for creation of a new record if the record does not exist.
- create or t  Search for existing records matching ADDRESS;
-                create a new record if it does not yet exist.
- a function   This functions will be called with no arguments.
-                It should return one of the above values."
-  ;; Also: Used for communication between `bbdb-update-records'
-  ;; and `bbdb-query-create'.
-  :group 'bbdb-mua
-  :type '(choice (const :tag "do nothing" nil)
-                 (const :tag "search for existing records" search)
-                 (const :tag "update existing records" update)
-                 (const :tag "query annotation of all messages" query)
-                 (const :tag "annotate all messages" create)
-                 (function :tag "User-defined function")))
-
-(defcustom bbdb-message-headers
-  '((sender     "From" "Resent-From" "Reply-To" "Sender")
-    (recipients "Resent-To" "Resent-CC" "To" "CC" "BCC"))
-  "Alist of headers to search for sender and recipients mail addresses.
-Each element is of the form
-
-  (CLASS HEADER ...)
-
-The symbol CLASS defines a class of headers.
-The strings HEADER belong to CLASS."
-  :group 'bbdb-mua
-  :type 'list)
-
-(defcustom bbdb-message-all-addresses nil
-  "If t `bbdb-update-records' returns all mail addresses of a message.
-Otherwise this function returns only the first mail address of each message."
-  :group 'bbdb-mua
-  :type 'boolean)
-
-(defcustom bbdb-message-try-all-headers nil
-  "If t try all message headers to extract an email address from a message.
-Several BBDB commands extract either the sender or the recipients' email
-addresses from a message according to `bbdb-message-headers'.  If BBDB does not
-find any email address in this subset of message headers (for example, because
-an email address is excluded because of `bbdb-user-mail-address-re')
-but `bbdb-message-try-all-headers' is t, then these commands will also consider
-the email addresses in the remaining headers."
-  :group 'bbdb-mua
-  :type 'boolean)
-
-(defcustom bbdb-accept-message-alist t
-  "Alist describing which messages to automatically create BBDB records for.
-The format of this alist is
-   ((HEADER-NAME . REGEXP) ...)
-For example, if
-   ((\"From\" . \"@.*\\.maximegalon\\.edu\")
-    (\"Subject\" . \"time travel\"))
-BBDB records are only created for messages sent by people at Maximegalon U.,
-or people posting about time travel.
-If t accept all messages.  If nil do not accept any messages.
-
-See also `bbdb-ignore-message-alist', which has the opposite effect."
-  :group 'bbdb-mua
-  :type '(repeat (cons
-                  (string :tag "Header name")
-                  (regexp :tag "Regexp to match on header value"))))
-
-(defcustom bbdb-ignore-message-alist nil
-  "Alist describing which messages not to automatically create BBDB records for.
-The format of this alist is
-   ((HEADER-NAME . REGEXP) ... )
-For example, if
-   ((\"From\" . \"mailer-daemon\")
-    ((\"To\" \"CC\") . \"mailing-list-1\\\\|mailing-list-2\"))
-no BBDB records are created for messages from any mailer daemon,
-or messages sent to or CCed to either of two mailing lists.
-If t ignore all messages.  If nil do not ignore any messages.
-
-See also `bbdb-accept-message-alist', which has the opposite effect."
-  :group 'bbdb-mua
-  :type '(repeat (cons
-                  (string :tag "Header name")
-                  (regexp :tag "Regexp to match on header value"))))
-
-(defcustom bbdb-user-mail-address-re
-  (and (stringp user-mail-address)
-       (string-match "\\`\\([^@]*\\)\\(@\\|\\'\\)" user-mail-address)
-       (concat "\\<" (regexp-quote (match-string 1 user-mail-address)) "\\>"))
-  "A regular expression matching your mail addresses.
-Several BBDB commands extract either the sender or the recipients' email
-addresses from a message according to `bbdb-message-headers'.  Yet an email
-address will be ignored if it matches `bbdb-user-mail-address-re'.  This way
-the commands will not operate on your own record.
-See also `bbdb-message-try-all-headers'."
-  :group 'bbdb-mua
-  :type '(regexp :tag "Regexp matching your mail addresses"))
-
-(defcustom bbdb-add-name 'query
-  "How to handle new names for existing BBDB records.
-This handles messages where the real name differs from the name
-in a BBDB record with the same mail address, as in \"John Smith <jqs@frob.com>\"
-versus \"John Q. Smith <jqs@frob.com>\".
-Allowed values are:
- t           Automatically change the name to the new value.
- query       Query whether to use the new name.
- nil         Ignore the new name.
- a number    Number of seconds BBDB displays the name mismatch.
-               (without further action).
- a function  This is called with two args, the record and the new name.
-               It should return one of the above values.
- a regexp    If the new name matches this regexp ignore it.
-               Otherwise query to add it.
-See also `bbdb-add-aka'."
-  :group 'bbdb-mua
-  :type '(choice (const :tag "Automatically use the new name" t)
-                 (const :tag "Query for name changes" query)
-                 (const :tag "Ignore the new name" nil)
-                 (integer :tag "Number of seconds to display name mismatch")
-                 (function :tag "Function for analyzing name handling")
-                 (regexp :tag "If the new name matches this regexp ignore it.")))
-
-(defcustom bbdb-add-aka 'query
-  "How to handle alternate names for existing BBDB records.
-Allowed values are:
- t           Automatically store alternate names as AKA.
- query       Query whether to store alternate names as an AKA.
- nil         Ignore alternate names.
- a function  This is called with two args, the record and the new name.
-               It should return one of the above values.
- a regexp    If the alternate name matches this regexp ignore it.
-               Otherwise query to add it.
-See also `bbdb-add-name'."
-  :group 'bbdb-mua
-  :type '(choice (const :tag "Automatically store alternate names as AKA" t)
-                 (const :tag "Query for alternate names" query)
-                 (const :tag "Ignore alternate names" nil)
-                 (function :tag "Function for alternate name handling")
-                 (regexp :tag "If the alternate name matches this regexp ignore it.")))
-
-(defcustom bbdb-add-mails 'query
-  "How to handle new mail addresses for existing BBDB records.
-This handles messages where the mail address differs from the mail addresses
-in a BBDB record with the same name as in \"John Q. Smith <jqs@foo.com>\"
-versus \"John Q. Smith <jqs@bar.com>\".
-Allowed values are:
- t           Automatically add new mail addresses to the list of mail addresses.
- query       Query whether to add it.
- nil         Ignore new mail addresses.
- a number    Number of seconds BBDB displays the new address
-               (without further action).
- a function  This is called with two args, the record and the new mail address.
-               It should return one of the above values.
- a regexp    If the new mail address matches this regexp ignore the new address.
-               Otherwise query to add it.
-See also `bbdb-new-mails-primary' and `bbdb-ignore-redundant-mails'."
-  :group 'bbdb-mua
-  :type '(choice (const :tag "Automatically add new mail addresses" t)
-                 (const :tag "Query before adding new mail addresses" query)
-                 (const :tag "Never add new mail addresses" nil)
-                 (number :tag "Number of seconds to display new addresses")
-                 (function :tag "Function for analyzing name handling")
-                 (regexp :tag "If the new address matches this regexp ignore it.")))
-
-(defcustom bbdb-new-mails-primary 'query
-  "Where to put new mail addresses for existing BBDB records.
-A new mail address may either become the new primary mail address,
-when it is put at the beginning of the list of mail addresses.
-Or the new mail address is added at the end of the list of mail addresses.
-Allowed values are:
- t           Make a new address automatically the primary address.
- query       Query whether to make it the primary address.
- nil         Add the new address to the end of the list.
- a function  This is called with two args, the record and the new mail address.
-               It should return one of the above values.
- a regexp    If the new mail address matches this regexp put it at the end.
-               Otherwise query to make it the primary address.
-See also `bbdb-add-mails'."
-  :group 'bbdb-mua
-  :type '(choice (const :tag "New address automatically made primary" t)
-                 (const :tag "Query before making a new address primary" query)
-                 (const :tag "Do not make new address primary" nil)
-                 (function :tag "Function for analyzing primary handling")
-                 (regexp :tag "If the new mail address matches this regexp put it at the end.")))
-
-(defcustom bbdb-canonicalize-mail-function nil
-  "If non-nil, it should be a function of one arg: a mail address string.
-When BBDB \"notices\" a message, the corresponding mail addresses are passed
-to this function first.  It acts as a kind of \"filter\" to transform
-the mail addresses before they are compared against or added to the database.
-See `bbdb-canonicalize-mail-1' for a more complete example.
-If this function returns nil, BBDB assumes that there is no mail address.
-
-See also `bbdb-ignore-redundant-mails'."
-  :group 'bbdb-mua
-  :type 'function)
-
-(defcustom bbdb-ignore-redundant-mails 'query
-  "How to handle redundant mail addresses for existing BBDB records.
-For example, \"foo@bar.baz.com\" is redundant w.r.t. \"foo@baz.com\".
-This affects two things, whether a new redundant mail address is added
-to BBDB and whether an old mail address, which has become redundant
-because of a newly added mail address, is removed from BBDB.
-
-Allowed values are:
- t           Automatically ignore redundant mail addresses.
- query       Query whether to ignore them.
- nil         Do not ignore redundant mail addresses.
- a number    Number of seconds BBDB displays redundant mail addresses
-               (without further action).
- a function  This is called with two args, the record and the new mail address.
-               It should return one of the above values.
- a regexp    If the new mail address matches this regexp never ignore
-               this mail address.  Otherwise query to ignore it.
-See also `bbdb-add-mails' and `bbdb-canonicalize-mail-function'."
-  :group 'bbdb-mua
-  :type '(choice (const :tag "Automatically ignore redundant mail addresses" t)
-                 (const :tag "Query whether to ignore them" query)
-                 (const :tag "Do not ignore redundant mail addresses" nil)
-                 (number :tag "Number of seconds to display redundant addresses")
-                 (function :tag "Function for handling redundant mail addresses")
-                 (regexp :tag "If the new address matches this regexp never ignore it.")))
-(define-obsolete-variable-alias 'bbdb-canonicalize-redundant-mails
-  'bbdb-ignore-redundant-mails "3.0")
-
-(defcustom bbdb-message-clean-name-function 'bbdb-message-clean-name-default
-  "Function to clean up the name in the header of a message.
-It takes one argument, the name as extracted by
-`mail-extract-address-components'."
-  :group 'bbdb-mua
-  :type 'function)
-
-(defcustom bbdb-message-mail-as-name t
-  "If non-nil use mail address of message as fallback for name of new records."
-  :group 'bbdb-mua
-  :type 'boolean)
-
-(defcustom bbdb-notice-mail-hook nil
-  "Hook run each time a mail address of a record is \"noticed\" in a message.
-This means that the mail address in a message belongs to an existing BBDB record
-or to a record BBDB has created for the mail address.
-
-Run with one argument, the record.  It is up to the hook function
-to determine which MUA is used and to act appropriately.
-Hook functions can use the variable `bbdb-update-records-address'
-to determine the header and class of the mail address according
-to `bbdb-message-headers'.  See `bbdb-auto-notes' for how to annotate records
-using `bbdb-update-records-address' and the headers of a mail message.
-
-If a message contains multiple mail addresses belonging to one BBDB record,
-this hook is run for each mail address.  Use `bbdb-notice-record-hook'
-if you want to notice each record only once per message."
-  :group 'bbdb-mua
-  :type 'hook)
-
-(defcustom bbdb-notice-record-hook nil
-  "Hook run each time a BBDB record is \"noticed\" in a message.
-This means that one of the mail addresses in a message belongs to an existing
-record or it is a record BBDB has created for the mail address.  If a message
-contains multiple mail addresses belonging to one BBDB record, this hook
-is nonetheless run only once.  Use `bbdb-notice-mail-hook' if you want to run
-a hook function for each mail address in a message.
-
-Hook is run with one argument, the record."
-  :group 'bbdb-mua
-  :type 'hook)
-
-(define-widget 'bbdb-alist-with-header 'group
-  "My group"
-  :match 'bbdb-alist-with-header-match
-  :value-to-internal (lambda (_widget value)
-                       (if value (list (car value) (cdr value))))
-  :value-to-external (lambda (_widget value)
-                       (if value (append (list (car value)) (cadr value)))))
-
-(defun bbdb-alist-with-header-match (widget value)
-  (widget-group-match widget
-                      (widget-apply widget :value-to-internal value)))
-
-(defvar bbdb-auto-notes-rules-expanded nil
-  "Expanded `bbdb-auto-notes-rules'.") ; Internal variable
-
-(defcustom bbdb-auto-notes-rules nil
-  "List of rules for adding notes to records of mail addresses of messages.
-This automatically annotates the BBDB record of the sender or recipient
-of a message based on the value of a header such as the Subject header.
-This requires that `bbdb-notice-mail-hook' contains `bbdb-auto-notes'
-and that the record already exists or `bbdb-update-records-p' returns such that
-the record will be created.  Messages matching `bbdb-auto-notes-ignore-messages'
-are ignored.
-
-The elements of this list are
-
-   (MUA FROM-TO HEADER ANNOTATE ...)
-   (FROM-TO HEADER ANNOTATE ...)
-   (HEADER ANNOTATE ...)
-
-MUA is the active MUA or a list of MUAs (see `bbdb-mua').
-If MUA is missing or t, use this rule for all MUAs.
-
-FROM-TO is a list of headers and/or header classes as in `bbdb-message-headers'.
-The record corresponding to a mail address of a message is considered for
-annotation if this mail address was found in a header matching FROM-TO.
-If FROM-TO is missing or t, records for each mail address are considered
-irrespective of where the mail address was found in a message.
-
-HEADER is a message header that is considered for generating the annotation.
-
-ANNOTATE may take the following values:
-
-  (REGEXP . STRING)       [this is equivalent to (REGEXP notes STRING)]
-  (REGEXP FIELD STRING)
-  (REGEXP FIELD STRING REPLACE)
-
-REGEXP must match the value of HEADER for generating an annotation.
-However, if the value of HEADER also matches an element of
-`bbdb-auto-notes-ignore-headers' no annotation is generated.
-
-The annotation will be added to FIELD of the respective record.
-FIELD defaults to `bbdb-default-xfield'.
-
-STRING defines a replacement for the match of REGEXP in the value of HEADER.
-It may contain \\& or \\N specials used by `replace-match'.
-The resulting string becomes the annotation.
-If STRING is an integer N, the Nth matching subexpression is used.
-If STRING is a function, it will be called with one arg, the value of HEADER.
-The return value (which must be a string) is then used.
-
-If REPLACE is t, the resulting string replaces the old contents of FIELD.
-If it is nil, the string is appended to the contents of FIELD (unless the
-annotation is already part of the content of field).
-
-For example,
-
-   ((\"To\" (\"-vm@\" . \"VM mailing list\"))
-    (\"Subject\" (\"sprocket\" . \"mail about sprockets\")
-               (\"you bonehead\" . \"called me a bonehead\")))
-
-will cause the text \"VM mailing list\" to be added to the notes field
-of the records corresponding to anyone you get mail from via one of the VM
-mailing lists.
-
-If multiple clauses match the message, all of the corresponding strings
-will be added.
-
-See also variables `bbdb-auto-notes-ignore-messages' and
-`bbdb-auto-notes-ignore-headers'.
-
-For speed-up, the function `bbdb-auto-notes' actually use expanded rules
-stored in the internal variable `bbdb-auto-notes-rules-expanded'.
-If you change the value of `bbdb-auto-notes-rules' outside of customize,
-set `bbdb-auto-notes-rules-expanded' to nil, so that the expanded rules
-will be re-evaluated."
-  :group 'bbdb-mua
-  :set (lambda (symbol value)
-         (set-default symbol value)
-         (setq bbdb-auto-notes-rules-expanded nil))
-  :type '(repeat
-          (bbdb-alist-with-header
-           (repeat (choice
-                    (const sender)
-                    (const recipients)))
-           (string :tag "Header name")
-           (repeat (choice
-                    (cons :tag "Value Pair"
-                          (regexp :tag "Regexp to match on header value")
-                          (string :tag "String for notes if regexp matches"))
-                    (list :tag "Replacement list"
-                          (regexp :tag "Regexp to match on header value")
-                          (choice :tag "Record field"
-                                  (const notes :tag "xfields")
-                                  (const organization :tag "Organization")
-                                  (symbol :tag "Other"))
-                          (choice :tag "Regexp match"
-                                  (string :tag "Replacement string")
-                                  (integer :tag "Subexpression match")
-                                  (function :tag "Callback Function"))
-                          (choice :tag "Replace previous contents"
-                                  (const :tag "No" nil)
-                                  (const :tag "Yes" t))))))))
-
-(defcustom bbdb-auto-notes-ignore-messages nil
-  "List of rules for ignoring entire messages in `bbdb-auto-notes'.
-The elements may have the following values:
-  a function  This function is called with one arg, the record
-              that would be annotated.
-              Ignore this message if the function returns non-nil.
-              This function may use `bbdb-update-records-address'.
-  MUA         Ignore messages from MUA (see `bbdb-mua').
-  (HEADER . REGEXP)  Ignore messages where HEADER matches REGEXP.
-              For example,  (\"From\" . bbdb-user-mail-address-re)
-              disables any recording of notes for mail addresses
-              found in messages coming from yourself, see
-              `bbdb-user-mail-address-re'.
-  (MUA HEADER REGEXP)  Ignore messages from MUA where HEADER
-              matches REGEXP.
-See also `bbdb-auto-notes-ignore-headers'."
-  :group 'bbdb-mua
-  :type '(repeat (cons
-                  (string :tag "Header name")
-                  (regexp :tag "Regexp to match on header value"))))
-
-(defcustom bbdb-auto-notes-ignore-headers nil
-  "Alist of headers and regexps to ignore in `bbdb-auto-notes'.
-Each element is of the form
-
-    (HEADER . REGEXP)
-
-For example,
-
-    (\"Organization\" . \"^Gatewayed from\\\\\|^Source only\")
-
-will exclude the phony `Organization:' headers in GNU mailing-lists
-gatewayed to gnu.* newsgroups.
-See also `bbdb-auto-notes-ignore-messages'."
-  :group 'bbdb-mua
-  :type '(repeat (cons
-                  (string :tag "Header name")
-                  (regexp :tag "Regexp to match on header value"))))
-
-(defcustom bbdb-mua-pop-up t
-  "If non-nil, display an auto-updated BBDB window while using a MUA.
-If 'horiz, stack the window horizontally if there is room.
-If this is nil, BBDB is updated silently.
-
-See also `bbdb-mua-pop-up-window-size' and `bbdb-horiz-pop-up-window-size'."
-  :group 'bbdb-mua
-  :type '(choice (const :tag "MUA BBDB window stacked vertically" t)
-                 (const :tag "MUA BBDB window stacked horizontally" horiz)
-                 (const :tag "No MUA BBDB window" nil)))
-(define-obsolete-variable-alias 'bbdb-message-pop-up 'bbdb-mua-pop-up "3.0")
-
-(defcustom bbdb-mua-pop-up-window-size bbdb-pop-up-window-size
-  "Vertical size of MUA pop-up BBDB window (vertical split).
-If it is an integer number, it is the number of lines used by BBDB.
-If it is a fraction between 0.0 and 1.0 (inclusive), it is the fraction
-of the tallest existing window that BBDB will take over.
-If it is t use `pop-to-buffer' to create the BBDB window.
-See also `bbdb-pop-up-window-size'."
-  :group 'bbdb-mua
-  :type '(choice (number :tag "BBDB window size")
-                 (const :tag "Use `pop-to-buffer'" t)))
-
-(defcustom bbdb-horiz-pop-up-window-size '(112 . 0.3)
-  "Horizontal size of a MUA pop-up BBDB window (horizontal split).
-It is a cons pair (TOTAL . BBDB-SIZE).
-The window that will be considered for horizontal splitting must have
-at least TOTAL columns. BBDB-SIZE is the horizontal size of the BBDB window.
-If it is an integer number, it is the number of columns used by BBDB.
-If it is a fraction between 0 and 1, it is the fraction of the
-window width that BBDB will take over."
-  :group 'bbdb-mua
-  :type '(cons (number :tag "Total number of columns")
-               (number :tag "Horizontal size of BBDB window")))
-
-
-;;; xfields processing
-(defcustom bbdb-xfields-sort-order
-  '((notes . 0) (url . 1) (ftp . 2) (gopher . 3) (telnet . 4) (mail-alias . 5)
-    (mail-folder . 6) (lpr . 7))
-  "The order for sorting the xfields.
-If an xfield is not in the alist, it is assigned weight 100, so all xfields
-with weights less then 100 will be in the beginning, and all xfields with
-weights more than 100 will be in the end."
-  :group 'bbdb-mua
-  :type '(repeat (cons
-                  (symbol :tag "xfield")
-                  (number :tag "Weight"))))
-(define-obsolete-variable-alias 'bbdb-notes-sort-order 'bbdb-xfields-sort-order "3.0")
-
-(defcustom bbdb-merge-xfield-function-alist nil
-  "Alist defining merging functions for particular xfields.
-Each element is of the form (LABEL . MERGE-FUN).
-For merging xfield LABEL, this will use MERGE-FUN."
-  :group 'bbdb-mua
-  :type '(repeat (cons
-                  (symbol :tag "xfield")
-                  (function :tag "merge function"))))
-(define-obsolete-variable-alias 'bbdb-merge-notes-function-alist
-  'bbdb-merge-xfield-function-alist "3.0")
-
-(defcustom bbdb-mua-summary-unification-list
-  '(name mail message-name message-mail message-address)
-  "List of FIELDs considered by `bbdb-mua-summary-unify'.
-For the RECORD matching the address of a message, `bbdb-mua-summary-unify'
-returns the first non-empty field value matching an element FIELD from this list.
-Each element FIELD may be a valid argument of `bbdb-record-field' for RECORD.
-In addition, this list may also include the following elements:
-  message-name     The name in the address of the message
-  message-mail     The mail in the address of the message
-  message-address  The complete address of the message
-These provide a fallback if a message does not have a matching RECORD
-or if some FIELD of RECORD is empty."
-  :group 'bbdb-mua
-  :type '(repeat (symbol :tag "Field")))
-
-(defcustom bbdb-mua-summary-mark-field 'mark-char
-  "BBDB xfield whose value is used to mark message addresses known to BBDB.
-This may also be a function, called with one arg, the record, which should
-return the mark.  See `bbdb-mua-summary-mark' and `bbdb-mua-summary-unify'.
-See also `bbdb-mua-summary-mark'."
-  :group 'bbdb-mua-gnus
-  :type 'symbol)
-
-(defcustom bbdb-mua-summary-mark "+"
-  "Default mark for message addresses known to BBDB.
-If nil do not mark message addresses known to BBDB.
-See `bbdb-mua-summary-mark' and `bbdb-mua-summary-unify'.
-See also `bbdb-mua-summary-mark-field'."
-  :group 'bbdb-mua
-  :type '(choice (string :tag "Mark used")
-                 (const :tag "Do not mark known posters" nil)))
-
-(defcustom bbdb-mua-summary-unify-format-letter "B"
-  "Letter required for `bbdb-mua-summary-unify' in the MUA Summary format string.
-For Gnus, combine it with the %u specifier in `gnus-summary-line-format'
-\(see there), for example use \"%U%R%z%I%(%[%4L: %-23,23uB%]%) %s\\n\".
-For VM, combine it with the %U specifier in `vm-summary-format' (see there),
-for example, use \"%n %*%a %-17.17UB %-3.3m %2d %4l/%-5c %I\\\"%s\\\"\\n\".
-This customization of `gnus-summary-line-format' / `vm-summary-format'
-is required to use `bbdb-mua-summary-unify'.
-Currently no other MUAs support this BBDB feature."
-  :group 'bbdb-mua
-  :type 'string)
-
-(defcustom bbdb-mua-summary-mark-format-letter "b"
-  "Letter required for `bbdb-mua-summary-mark' in the MUA Summary format string.
-For Gnus, combine it with the %u specifier in `gnus-summary-line-format'
-\(see there), for example, use \"%U%R%z%I%(%[%4L: %ub%-23,23f%]%) %s\\n\".
-For VM, combine it with the %U specifier in `vm-summary-format' (see there),
-for example, use \"%n %*%a %Ub%-17.17F %-3.3m %2d %4l/%-5c %I\\\"%s\\\"\\n\".
-This customization of `gnus-summary-line-format' / `vm-summary-format'
-is required to use `bbdb-mua-summary-mark'.
-Currently no other MUAs support this BBDB feature."
-  :group 'bbdb-mua
-  :type 'string)
-
-
-;;; Sending mail
-(defcustom bbdb-mail-user-agent mail-user-agent
-  "Mail user agent used by BBDB.
-Allowed values are those allowed for `mail-user-agent'."
-  :group 'bbdb-sendmail
-  :type '(radio (function-item :tag "Message package"
-                               :format "%t\n"
-                               message-user-agent)
-                (function-item :tag "Mail package"
-                               :format "%t\n"
-                               sendmail-user-agent)
-                (function-item :tag "Emacs interface to MH"
-                               :format "%t\n"
-                               mh-e-user-agent)
-                (function-item :tag "Message with full Gnus features"
-                               :format "%t\n"
-                               gnus-user-agent)
-                (function-item :tag "VM"
-                               :format "%t\n"
-                               vm-user-agent)
-                (function :tag "Other")
-                (const :tag "Default" nil)))
-
-(defcustom bbdb-mail-name-format 'first-last
-  "Format for names when sending mail.
-If first-last format names as \"Firstname Lastname\".
-If last-first format names as \"Lastname, Firstname\".
-If `bbdb-mail-name' returns the full name as a single string, this takes
-precedence over `bbdb-mail-name-format'.  Likewise, if the mail address itself
-includes a name, this is not reformatted."
-  :group 'bbdb-sendmail
-  :type '(choice (const :tag "Firstname Lastname" first-last)
-                 (const :tag "Lastname, Firstname" last-first)))
-
-(defcustom bbdb-mail-name 'mail-name
-  "Xfield holding the full name for a record when sending mail.
-This may also be a function taking one argument, a record.
-If it returns the full mail name as a single string, this is used \"as is\".
-If it returns a cons pair (FIRST . LAST) with the first and last name
-for this record, these are formatted obeying `bbdb-mail-name-format'."
-  :group 'bbdb-sendmail
-  :type '(choice (symbol :tag "xfield")
-                 (function :tag "mail name function")))
-
-(defcustom bbdb-mail-alias-field 'mail-alias
-  "Xfield holding the mail alias for a record.
-Used by `bbdb-mail-aliases'.  See also `bbdb-mail-alias'."
-  :group 'bbdb-sendmail
-  :type 'symbol)
-
-(defcustom bbdb-mail-alias 'first
-  "Defines which mail aliases are generated for a BBDB record.
-first: Generate one alias \"<alias>\" that expands to the first mail address
-       of a record.
-star:  Generate a second alias \"<alias>*\" that expands to all mail addresses
-       of a record.
-all:   Generate the aliases \"<alias>\" and \"<alias>*\" (as for 'star)
-       and aliases \"<alias>n\" for each mail address, where n is the position
-       of the mail address of a record."
-  :group 'bbdb-sendmail
-  :type '(choice (symbol :tag "Only first" first)
-                 (symbol :tag "<alias>* for all mails" star)
-                 (symbol :tag "All aliases" all)))
-
-(defcustom bbdb-mail-avoid-redundancy nil
-  "Mail address to use for BBDB records when sending mail.
-If non-nil do not use full name in mail address when same as mail.
-If value is mail-only never use full name."
-  :group 'bbdb-sendmail
-  :type '(choice (const :tag "Allow redundancy" nil)
-                 (const :tag "Never use full name" mail-only)
-                 (const :tag "Avoid redundancy" t)))
-
-(defcustom bbdb-complete-mail t
-  "If t MUA insinuation provides key binding for command `bbdb-complete-mail'."
-  :group 'bbdb-sendmail
-  :type 'boolean)
-
-(defcustom bbdb-completion-list t
-  "Controls the behaviour of `bbdb-complete-mail'.
-If a list of symbols, it specifies which fields to complete.  Symbols include
-  fl-name (= first and last name)
-  lf-name (= last and first name)
-  organization
-  aka
-  mail (= all email addresses of each record)
-  primary (= first email address of each record)
-If t, completion is done for all of the above.
-If nil, no completion is offered."
-  ;; These symbols match the fields for which BBDB provides entries in
-  ;; `bbdb-hashtable'.
-  :group 'bbdb-sendmail
-  :type '(choice (const :tag "No Completion" nil)
-                 (const :tag "Complete across all fields" t)
-                 (repeat :tag "Field"
-                         (choice (const fl-name)
-                                 (const lf-name)
-                                 (const aka)
-                                 (const organization)
-                                 (const primary)
-                                 (const mail)))))
-
-(defcustom bbdb-complete-mail-allow-cycling nil
-  "If non-nil cycle mail addresses when calling `bbdb-complete-mail'."
-  :group 'bbdb-sendmail
-  :type 'boolean)
-
-(defcustom bbdb-complete-mail-hook nil
-  "List of functions called after a sucessful completion."
-  :group 'bbdb-sendmail
-  :type 'hook)
-
-(defcustom bbdb-mail-abbrev-expand-hook nil
-  ;; Replacement for function `mail-abbrev-expand-hook'.
-  "Function (not hook) run each time an alias is expanded.
-The function is called with two args the alias and the list
-of corresponding mail addresses."
-  :group 'bbdb-sendmail
-  :type 'function)
-
-(defcustom bbdb-completion-display-record t
-  "If non-nil `bbdb-complete-mail' displays the BBDB record after completion."
-  :group 'bbdb-sendmail
-  :type '(choice (const :tag "Update the BBDB buffer" t)
-                 (const :tag "Do not update the BBDB buffer" nil)))
-
-
-;;;Dialing
-(defcustom bbdb-dial-local-prefix-alist
-  '(((if (integerp bbdb-default-area-code)
-         (format "(%03d)" bbdb-default-area-code)
-       (or bbdb-default-area-code ""))
-     . ""))
-  "Mapping to remove local prefixes from numbers.
-If this is non-nil, it should be an alist of
-\(PREFIX . REPLACEMENT) elements. The first part of a phone number
-matching the regexp returned by evaluating PREFIX will be replaced by
-the corresponding REPLACEMENT when dialing."
-  :group 'bbdb-utilities-dialing
-  :type 'sexp)
-
-(defcustom bbdb-dial-local-prefix nil
-  "Local prefix digits.
-If this is non-nil, it should be a string of digits which your phone
-system requires before making local calls (for example, if your phone system
-requires you to dial 9 before making outside calls.) In BBDB's
-opinion, you're dialing a local number if it starts with a 0 after
-processing `bbdb-dial-local-prefix-alist'."
-  :group 'bbdb-utilities-dialing
-  :type '(choice (const :tag "No digits required" nil)
-                 (string :tag "Dial this first" "9")))
-
-(defcustom bbdb-dial-long-distance-prefix nil
-  "Long distance prefix digits.
-If this is non-nil, it should be a string of digits which your phone
-system requires before making a long distance call (one not in your local
-area code).  For example, in some areas you must dial 1 before an area
-code. Note that this is used to replace the + sign in phone numbers
-when dialling (international dialing prefix.)"
-  :group 'bbdb-utilities-dialing
-  :type '(choice (const :tag "No digits required" nil)
-                 (string :tag "Dial this first" "1")))
-
-(defcustom bbdb-dial-function nil
-  "If non-nil this should be a function used for dialing phone numbers.
-This function is used by `bbdb-dial-number'.  It requires one
-argument which is a string for the number that is dialed.
-If nil then `bbdb-dial-number' uses the tel URI syntax passed to `browse-url'
-to make the call."
-  :group 'bbdb-utilities-dialing
-  :type 'function)
-
-
-;; Faces for font-lock
-(defgroup bbdb-faces nil
-  "Faces used by BBDB."
-  :group 'bbdb
-  :group 'faces)
-
-(defface bbdb-name
-  '((t (:inherit font-lock-function-name-face)))
-  "Face used for BBDB names."
-  :group 'bbdb-faces)
-
-;; KEY needs to match the value of the xfield name-face, which is a string.
-;; To avoid confusion, we make KEY a string, too, though symbols might be
-;; faster.
-(defcustom bbdb-name-face-alist nil
-  "Alist used for font-locking the name of a record.
-Each element should be a cons cell (KEY . FACE) with string KEY and face FACE.
-To use FACE for font-locking the name of a record,
-the xfield name-face of this record should have the value KEY.
-The value of name-face may also be a face which is then used directly.
-If none of these schemes succeeds, the face `bbdb-name' is used."
-  :group 'bbdb-faces
-  :type '(repeat (cons (symbol :tag "Key") (face :tag "Face"))))
-
-(defface bbdb-organization
-  '((t (:inherit font-lock-comment-face)))
-  "Face used for BBDB names."
-  :group 'bbdb-faces)
-
-(defface bbdb-field-name
-  '((t (:inherit font-lock-variable-name-face)))
-  "Face used for BBDB names."
-  :group 'bbdb-faces)
-
-;;; Internal variables
-(eval-and-compile
-  (defvar bbdb-debug t
-    "Enable debugging if non-nil during compile time.
-You really should not disable debugging.  But it will speed things up."))
-
-(defconst bbdb-file-format 9
-  "BBDB file format.")
-
-(defconst bbdb-record-type
-  '(vector (or string (const nil)) ; first name
-           (or string (const nil)) ; last name
-           (repeat string) ; affix
-           (repeat string) ; aka
-           (repeat string) ; organization
-           (repeat (or (vector string string)
-                       (vector string integer integer integer integer))) ; phone
-           (repeat (vector string (repeat string) string string
-                           string string)) ; address
-           (repeat string) ; mail
-           (repeat (cons symbol sexp)) ; xfields
-           (cons symbol string) ; uuid
-           (cons symbol string) ; creation-date
-           (cons symbol string) ; timestamp
-           sexp) ; cache
-  "Pseudo-code for the structure of a record.  Used by `bbdb-check-type'.")
-
-(defconst bbdb-file-coding-system 'utf-8
-  "Coding system used for reading and writing `bbdb-file'.")
-
-(defvar bbdb-mail-aliases-need-rebuilt nil
-  "Non-nil if mail aliases need to be rebuilt.")
-
-(defvar bbdb-buffer nil "Buffer visiting `bbdb-file'.")
-
-(defvar bbdb-buffer-name "*BBDB*" "Name of the BBDB buffer.")
-
-(defvar bbdb-silent-internal nil
-  "Bind this to t to quiet things down - do not set it.
-See also `bbdb-silent'.")
-
-(defvar bbdb-init-forms
-  '((gnus                       ; gnus 3.15 or newer
-     (add-hook 'gnus-startup-hook 'bbdb-insinuate-gnus))
-    (mh-e                       ; MH-E
-     (add-hook 'mh-folder-mode-hook 'bbdb-insinuate-mh))
-    (rmail                      ; RMAIL
-     (add-hook 'rmail-mode-hook 'bbdb-insinuate-rmail))
-    (vm                        ; newer versions of vm do not have `vm-load-hook'
-     (eval-after-load "vm" '(bbdb-insinuate-vm)))
-    (mail                       ; the standard mail user agent
-     (add-hook 'mail-setup-hook 'bbdb-insinuate-mail))
-    (sendmail
-     (progn (message "BBDB: sendmail insinuation deprecated. Use mail.")
-            (add-hook 'mail-setup-hook 'bbdb-insinuate-mail)))
-    (message                    ; the gnus mail user agent
-     (add-hook 'message-setup-hook 'bbdb-insinuate-message))
-    (mu4e                       ; the mu4e user agent
-     (add-hook 'mu4e-main-mode-hook 'bbdb-insinuate-mu4e))
-
-    (sc                         ; supercite
-     (add-hook 'sc-load-hook 'bbdb-insinuate-sc))
-    (anniv                      ; anniversaries
-     (add-hook 'diary-list-entries-hook 'bbdb-anniv-diary-entries))
-    (pgp                        ; pgp-mail
-     (progn
-       (add-hook 'message-send-hook 'bbdb-pgp)
-       (add-hook 'mail-send-hook 'bbdb-pgp)))
-    (wl
-     (add-hook 'wl-init-hook 'bbdb-insinuate-wl)))
-  "Alist mapping features to insinuation forms.")
-
-(defvar bbdb-search-invert nil
-  "Bind this variable to t in order to invert the result of `bbdb-search'.")
-
-(defvar bbdb-do-all-records nil
-  "Controls the behavior of the command `bbdb-do-all-records'.")
-
-(defvar bbdb-append-display nil
-  "Controls the behavior of the command `bbdb-append-display'.")
-
-(defvar bbdb-offer-to-create nil
-  "For communication between `bbdb-update-records' and `bbdb-query-create'.")
-
-(defvar bbdb-update-records-address nil
-  "For communication between `bbdb-update-records' and `bbdb-query-create'.
-It is a list with elements (NAME MAIL HEADER HEADER-CLASS MUA).")
-
-;;; Buffer-local variables for the database.
-(defvar bbdb-records nil
-  "BBDB records list.
-In buffer `bbdb-file' this list includes all records.
-In the *BBDB* buffers it includes the records that are actually displayed
-and its elements are (RECORD DISPLAY-FORMAT MARKER-POS).")
-(make-variable-buffer-local 'bbdb-records)
-
-(defvar bbdb-changed-records nil
-  "List of records that has been changed since BBDB was last saved.
-Use `bbdb-search-changed' to display these records.")
-
-(defvar bbdb-end-marker nil
-  "Marker holding the buffer position of the end of the last record.")
-
-(defvar bbdb-hashtable (make-hash-table :test 'equal)
-  "Hash table for BBDB records.
-Hashes the fields first-last-name, last-first-name, organization, aka, and mail.")
-
-(defvar bbdb-uuid-table (make-hash-table :test 'equal)
-  "Hash table for uuid's of BBDB records.")
-
-(defvar bbdb-xfield-label-list nil
-  "List of labels for xfields.")
-
-(defvar bbdb-organization-list nil
-  "List of organizations known to BBDB.")
-
-(defvar bbdb-street-list nil
-  "List of streets known to BBDB.")
-
-(defvar bbdb-city-list nil
-  "List of cities known to BBDB.")
-
-(defvar bbdb-state-list nil
-  "List of states known to BBDB.")
-
-(defvar bbdb-postcode-list nil
-  "List of post codes known to BBDB.")
-
-(defvar bbdb-country-list nil
-  "List of countries known to BBDB.")
-
-(defvar bbdb-modeline-info (make-vector 6 nil)
-  "Precalculated mode line info for BBDB commands.
-This is a vector [APPEND-M APPEND INVERT-M INVERT ALL-M ALL].
-APPEND-M is the mode line info if `bbdb-append-display' is non-nil.
-INVERT-M is the mode line info if `bbdb-search-invert' is non-nil.
-ALL-M is the mode line info if `bbdb-do-all-records' is non-nil.
-APPEND, INVERT, and ALL appear in the message area.")
-
-(defvar bbdb-update-unchanged-records nil
-  "If non-nil update unchanged records in the database.
-Normally calls of `bbdb-change-hook' and updating of a record are suppressed,
-if an editing command did not really change the record.  Bind this to t
-if you want to call `bbdb-change-hook' and update the record unconditionally.")
-
-;;; Keymap
-(defvar bbdb-mode-map
-  (let ((km (make-sparse-keymap)))
-    (define-key km "*"          'bbdb-do-all-records)
-    (define-key km "+"          'bbdb-append-display)
-    (define-key km "!"          'bbdb-search-invert)
-    (define-key km "a"          'bbdb-add-mail-alias)
-    (define-key km "A"          'bbdb-mail-aliases)
-    (define-key km "c"          'bbdb-create)
-    (define-key km "e"          'bbdb-edit-field)
-    (define-key km ";"          'bbdb-edit-foo)
-    (define-key km "n"          'bbdb-next-record)
-    (define-key km "p"          'bbdb-prev-record)
-    (define-key km "N"          'bbdb-next-field)
-    (define-key km "\t"         'bbdb-next-field) ; TAB
-    (define-key km "P"          'bbdb-prev-field)
-    (define-key km "\d"         'bbdb-prev-field) ; DEL
-    (define-key km "d"          'bbdb-delete-field-or-record)
-    (define-key km "\C-k"       'bbdb-delete-field-or-record)
-    (define-key km "i"          'bbdb-insert-field)
-    (define-key km "s"          'bbdb-save)
-    (define-key km "\C-x\C-s"   'bbdb-save)
-    (define-key km "t"          'bbdb-toggle-records-layout)
-    (define-key km "T"          'bbdb-display-records-completely)
-    (define-key km "o"          'bbdb-omit-record)
-    (define-key km "m"          'bbdb-mail)
-    (define-key km "M"          'bbdb-mail-address)
-    (define-key km "\M-d"       'bbdb-dial)
-    (define-key km "h"          'bbdb-info)
-    (define-key km "?"          'bbdb-help)
-    ;; (define-key km "q"       'quit-window) ; part of `special-mode' bindings
-    (define-key km "\C-x\C-t"   'bbdb-transpose-fields)
-    (define-key km "Cr"         'bbdb-copy-records-as-kill)
-    (define-key km "Cf"         'bbdb-copy-fields-as-kill)
-    (define-key km "u"          'bbdb-browse-url)
-    (define-key km "\C-c\C-t"   'bbdb-tex)
-    (define-key km "="          'delete-other-windows)
-
-    ;; Search keys
-    (define-key km "b"          'bbdb)
-    (define-key km "/1"         'bbdb-display-records)
-    (define-key km "/n"         'bbdb-search-name)
-    (define-key km "/o"         'bbdb-search-organization)
-    (define-key km "/p"         'bbdb-search-phone)
-    (define-key km "/a"         'bbdb-search-address)
-    (define-key km "/m"         'bbdb-search-mail)
-    (define-key km "/N"         'bbdb-search-xfields)
-    (define-key km "/x"         'bbdb-search-xfields)
-    (define-key km "/c"         'bbdb-search-changed)
-    (define-key km "/d"         'bbdb-search-duplicates)
-    (define-key km "\C-xnw"     'bbdb-display-all-records)
-    (define-key km "\C-xnd"     'bbdb-display-current-record)
-
-    (define-key km [delete]     'scroll-down) ; 24.1: part of `special-mode'
-    (define-key km " "          'scroll-up)   ; 24.1: part of `special-mode'
-
-    (define-key km [mouse-3]    'bbdb-mouse-menu)
-    (define-key km [mouse-2]    (lambda (event)
-                                  ;; Toggle record layout
-                                  (interactive "e")
-                                  (save-excursion
-                                    (posn-set-point (event-end event))
-                                    (bbdb-toggle-records-layout
-                                     (bbdb-do-records t) current-prefix-arg))))
-    km)
-  "Keymap for Insidious Big Brother Database.
-This is a child of `special-mode-map'.")
-
-(easy-menu-define
-  bbdb-menu bbdb-mode-map "BBDB Menu"
-  '("BBDB"
-    ("Display"
-     ["Previous field" bbdb-prev-field t]
-     ["Next field" bbdb-next-field t]
-     ["Previous record" bbdb-prev-record t]
-     ["Next record" bbdb-next-record t]
-     "--"
-     ["Show all records" bbdb-display-all-records t]
-     ["Show current record" bbdb-display-current-record t]
-     ["Omit record" bbdb-omit-record t]
-     "--"
-     ["Toggle layout" bbdb-toggle-records-layout t]
-     ["Show all fields" bbdb-display-records-completely t])
-    ("Searching"
-     ["General search" bbdb t]
-     ["Search one record" bbdb-display-records t]
-     ["Search name" bbdb-search-name t]
-     ["Search organization" bbdb-search-organization t]
-     ["Search phone" bbdb-search-phone t]
-     ["Search address" bbdb-search-address t]
-     ["Search mail" bbdb-search-mail t]
-     ["Search xfields" bbdb-search-xfields t]
-     ["Search changed records" bbdb-search-changed t]
-     ["Search duplicates" bbdb-search-duplicates t]
-     "--"
-     ["Old time stamps" bbdb-timestamp-older t]
-     ["New time stamps" bbdb-timestamp-newer t]
-     ["Old creation date" bbdb-creation-older t]
-     ["New creation date" bbdb-creation-newer t]
-     ["Creation date = time stamp" bbdb-creation-no-change t]
-     "--"
-     ["Append search" bbdb-append-display t]
-     ["Invert search" bbdb-search-invert t])
-    ("Mail"
-     ["Send mail" bbdb-mail t]
-     ["Save mail address" bbdb-mail-address t]
-     "--"
-     ["Add mail alias" bbdb-add-mail-alias t]
-     ["(Re-)Build mail aliases" bbdb-mail-aliases t])
-    ("Use database"
-     ["Prefix: do all records" bbdb-do-all-records t]
-     "--"
-     ["Send mail" bbdb-mail t]
-     ["Dial phone number" bbdb-dial t]
-     ["Browse URL" bbdb-browse-url t]
-     ["Copy records as kill" bbdb-copy-records-as-kill t]
-     ["Copy fields as kill" bbdb-copy-fields-as-kill t]
-     "--"
-     ["TeX records" bbdb-tex t])
-    ("Manipulate database"
-     ["Prefix: do all records" bbdb-do-all-records t]
-     "--"
-     ["Create new record" bbdb-create t]
-     ["Edit current field" bbdb-edit-field t]
-     ["Insert new field" bbdb-insert-field t]
-     ["Edit some field" bbdb-edit-foo t]
-     ["Transpose fields" bbdb-transpose-fields t]
-     ["Delete record or field" bbdb-delete-field-or-record t]
-     "--"
-     ["Sort addresses" bbdb-sort-addresses t]
-     ["Sort phones" bbdb-sort-phones t]
-     ["Sort xfields" bbdb-sort-xfields t]
-     ["Merge records" bbdb-merge-records t]
-     ["Sort database" bbdb-sort-records t]
-     ["Delete duplicate mails" bbdb-delete-redundant-mails t]
-     "--"
-     ["Save BBDB" bbdb-save t]
-     ["Revert BBDB" revert-buffer t])
-    ("Help"
-     ["Brief help" bbdb-help t]
-     ["BBDB Manual" bbdb-info t])
-    "--"
-    ["Quit" quit-window t]))
-
-(defvar bbdb-completing-read-mails-map
-  (let ((map (copy-keymap minibuffer-local-completion-map)))
-    (define-key map " " 'self-insert-command)
-    (define-key map "\t" 'bbdb-complete-mail)
-    (define-key map "\M-\t" 'bbdb-complete-mail)
-    map)
-  "Keymap used by `bbdb-completing-read-mails'.")
-
-
-
-;;; Helper functions
-
-(defun bbdb-warn (&rest args)
-  "Display a message at the bottom of the screen.
-ARGS are passed to `message'."
-  (ding t)
-  (apply 'message args))
-
-(defun bbdb-string-trim (string &optional null)
-  "Remove leading and trailing whitespace and all properties from STRING.
-If STRING is nil return an empty string unless NULL is non-nil."
-  (if (null string)
-      (unless null "")
-    (setq string (substring-no-properties string))
-    (if (string-match "\\`[ \t\n]+" string)
-        (setq string (substring-no-properties string (match-end 0))))
-    (if (string-match "[ \t\n]+\\'" string)
-        (setq string (substring-no-properties string 0 (match-beginning 0))))
-    (unless (and null (string= "" string))
-      string)))
-
-(defsubst bbdb-string= (str1 str2)
-  "Return t if strings STR1 and STR2 are equal, ignoring case."
-  (and (stringp str1) (stringp str2)
-       (eq t (compare-strings str1 0 nil str2 0 nil t))))
-
-(defun bbdb-split (separator string)
-  "Split STRING into list of substrings bounded by matches for SEPARATORS.
-SEPARATOR may be a regexp.  SEPARATOR may also be a symbol
-\(a field name).  Then look up the value in `bbdb-separator-alist'
-or use `bbdb-default-separator'.
-Whitespace around SEPARATOR is ignored unless SEPARATOR matches
-the string \" \\t\\n\".
-Almost the inverse function of `bbdb-concat'."
-  (if (symbolp separator)
-      (setq separator (car (or (cdr (assq separator bbdb-separator-alist))
-                               bbdb-default-separator))))
-  (if (<= 24.4 (string-to-number emacs-version))
-      ;; `split-string' applied to an empty STRING gives nil.
-      (split-string string separator t
-                    (unless (string-match separator " \t\n") "[ \t\n]*"))
-    (unless (string-match separator " \t\n")
-      (setq separator (concat "[ \t\n]*" separator "[ \t\n]*")))
-    (split-string (bbdb-string-trim string) separator t)))
-
-(defun bbdb-concat (separator &rest strings)
-  "Concatenate STRINGS to a string sticking in SEPARATOR.
-STRINGS may be strings or lists of strings.  Empty strings are ignored.
-SEPARATOR may be a string.
-SEPARATOR may also be a symbol (a field name).  Then look up the value
-of SEPARATOR in `bbdb-separator-alist' or use `bbdb-default-separator'.
-The inverse function of `bbdb-split'."
-  (if (symbolp separator)
-      (setq separator (nth 1 (or (cdr (assq separator bbdb-separator-alist))
-                                 bbdb-default-separator))))
-  (mapconcat 'identity
-             (delete "" (apply 'append (mapcar (lambda (x) (if (stringp x)
-                                                               (list x) x))
-                                               strings))) separator))
-
-(defun bbdb-list-strings (list)
-  "Remove all elements from LIST which are not non-empty strings."
-  (let (new-list)
-    (dolist (elt list)
-      (if (and (stringp elt) (not (string= "" elt)))
-          (push elt new-list)))
-    (nreverse new-list)))
-
-;; A call of `indent-region' swallows any indentation
-;; that might be part of the field itself.  So we indent manually.
-(defsubst bbdb-indent-string (string column)
-  "Indent nonempty lines in STRING to COLUMN (except first line).
-This happens in addition to any pre-defined indentation of STRING."
-  (replace-regexp-in-string "\n\\([^\n]\\)"
-                            (concat "\n" (make-string column ?\s) "\\1")
-                            string))
-
-(defun bbdb-read-string (prompt &optional init collection require-match)
-  "Read a string, trimming whitespace and text properties.
-PROMPT is a string to prompt with.
-INIT appears as initial input which is useful for editing existing records.
-COLLECTION and REQUIRE-MATCH have the same meaning as in `completing-read'."
-  (bbdb-string-trim
-   (if collection
-       ;; Hack: In `minibuffer-local-completion-map' remove
-       ;; the binding of SPC to `minibuffer-complete-word'
-       ;; and of ? to `minibuffer-completion-help'.
-       (minibuffer-with-setup-hook
-           (lambda ()
-             (use-local-map
-              (let ((map (make-sparse-keymap)))
-                (set-keymap-parent map (current-local-map))
-                (define-key map " " nil)
-                (define-key map "?" nil)
-                map)))
-         (completing-read prompt collection nil require-match init))
-     (read-string prompt init))))
-
-;; The following macros implement variants of `pushnew' (till emacs 24.2)
-;; or `cl-pushnew' (since emacs 24.3).  To be compatible with older and newer
-;; versions of emacs we use our own macros.  We call these macros often.
-;; So we keep them simple.  Nothing fancy is needed here.
-(defmacro bbdb-pushnew (element listname)
-  "Add ELEMENT to the value of LISTNAME if it isn't there yet.
-The test for presence of ELEMENT is done with `equal'.
-The return value is the new value of LISTNAME."
-  `(let ((elt ,element))
-     (if (member elt ,listname)
-         ,listname
-       (setq ,listname (cons elt ,listname)))))
-
-(defmacro bbdb-pushnewq (element listname)
-  "Add ELEMENT to the value of LISTNAME if it isn't there yet.
-The test for presence of ELEMENT is done with `eq'.
-The return value is the new value of LISTNAME."
-  `(let ((elt ,element))
-     (if (memq elt ,listname)
-         ,listname
-       (setq ,listname (cons elt ,listname)))))
-
-(defmacro bbdb-pushnewt (element listname)
-  "Add ELEMENT to the value of LISTNAME if it isn't there yet and non-nil.
-The test for presence of ELEMENT is done with `equal'.
-The return value is the new value of LISTNAME."
-  `(let ((elt ,element))
-     (if (or (not elt)
-             (member elt ,listname))
-         ,listname
-       (setq ,listname (cons elt ,listname)))))
-
-(defun bbdb-current-record (&optional full)
-  "Return the record point is at.
-If FULL is non-nil record includes the display information."
-  (unless (eq major-mode 'bbdb-mode)
-    (error "This only works while in BBDB buffers."))
-  (let ((num (get-text-property (if (and (not (bobp)) (eobp))
-                                    (1- (point)) (point))
-                                'bbdb-record-number))
-        record)
-    (unless num (error "Not a BBDB record"))
-    (setq record (nth num bbdb-records))
-    (if full record (car record))))
-
-(defun bbdb-current-field ()
-  "Return current field point is on."
-  (unless (bbdb-current-record) (error "Not a BBDB record"))
-  (get-text-property (point) 'bbdb-field))
-
-(defmacro bbdb-debug (&rest body)
-  "Excecute BODY just like `progn' with debugging capability.
-Debugging is enabled if variable `bbdb-debug' is non-nil during compile.
-You really should not disable debugging.  But it will speed things up."
-  (declare (indent 0))
-  (if bbdb-debug ; compile-time switch
-      `(let ((debug-on-error t))
-         ,@body)))
-
-;; inspired by `gnus-bind-print-variables'
-(defmacro bbdb-with-print-loadably (&rest body)
-  "Bind print-* variables for BBDB and evaluate BODY.
-This macro is used with `prin1', `prin1-to-string', etc. in order to ensure
-printed Lisp objects are loadable by BBDB."
-  (declare (indent 0))
-  `(let ((print-escape-newlines t) ;; BBDB needs this!
-         print-escape-nonascii print-escape-multibyte
-         print-quoted print-length print-level)
-         ;; print-circle print-gensym
-         ;; print-continuous-numbering
-         ;; print-number-table
-         ;; float-output-format
-     ,@body))
-
-(defun bbdb-timestamp (_record)
-  ""
-  (unless (get 'bbdb-timestamp 'bbdb-obsolete)
-    (put 'bbdb-timestamp 'bbdb-obsolete t)
-    (message "Function `bbdb-timestamp' is obsolete.  Remove it from any hooks.")
-    (sit-for 2)))
-(make-obsolete 'bbdb-timestamp nil "2017-08-09")
-
-(defun bbdb-creation-date (_record)
-  ""
-  (unless (get 'bbdb-creation-date 'bbdb-obsolete)
-    (put 'bbdb-creation-date 'bbdb-obsolete t)
-    (message "Function `bbdb-creation-date' is obsolete.  Remove it from any hooks.")
-    (sit-for 2)))
-(make-obsolete 'bbdb-creation-date nil "2017-08-09")
-
-;; Copied from org-id.el
-(defun bbdb-uuid ()
-  "Return string with random (version 4) UUID."
-  (let ((rnd (md5 (format "%s%s%s%s%s%s%s"
-			  (random)
-			  (current-time)
-			  (user-uid)
-			  (emacs-pid)
-			  (user-full-name)
-			  user-mail-address
-			  (recent-keys)))))
-    (format "%s-%s-4%s-%s%s-%s"
-	    (substring rnd 0 8)
-	    (substring rnd 8 12)
-	    (substring rnd 13 16)
-	    (format "%x"
-		    (logior
-		     #b10000000
-		     (logand
-		      #b10111111
-		      (string-to-number
-		       (substring rnd 16 18) 16))))
-	    (substring rnd 18 20)
-	    (substring rnd 20 32))))
-
-(defun bbdb-multiple-buffers-default ()
-  "Default function for guessing a name for new *BBDB* buffers.
-May be used as value of variable `bbdb-multiple-buffers'."
-  (save-current-buffer
-    (cond ((memq major-mode '(vm-mode vm-summary-mode vm-presentation-mode
-                                      vm-virtual-mode))
-           (vm-select-folder-buffer)
-           (buffer-name))
-          ((memq major-mode '(gnus-summary-mode gnus-group-mode))
-           (set-buffer gnus-article-buffer)
-           (buffer-name))
-          ((memq major-mode '(mail-mode vm-mail-mode message-mode))
-           "message composition"))))
-
-(defsubst bbdb-add-job (spec record string)
-  "Internal function: Evaluate SPEC for RECORD and STRING.
-If SPEC is a function call it with args RECORD and STRING.  Return value.
-If SPEC is a regexp, return 'query unless SPEC matches STRING.
-Otherwise return SPEC.
-Used with variable `bbdb-add-name' and friends."
-  (cond ((functionp spec)
-         (funcall spec record string))
-        ((stringp spec)
-         (unless (string-match spec string) 'query)) ; be least aggressive
-        (spec)))
-
-(defsubst bbdb-eval-spec (spec prompt)
-  "Internal function: Evaluate SPEC using PROMPT.
-Return t if either SPEC equals t, or SPEC equals 'query and `bbdb-silent'
-is non-nil or `y-or-no-p' returns t using PROMPT.
-Used with return values of `bbdb-add-job'."
-  (or (eq spec t)
-      (and (eq spec 'query)
-           (or bbdb-silent (y-or-n-p prompt)))))
-
-(defun bbdb-clean-address-components (components)
-  "Clean mail address COMPONENTS.
-COMPONENTS is a list (FULL-NAME CANONICAL-ADDRESS) as returned
-by `mail-extract-address-components'.
-Pass FULL-NAME through `bbdb-message-clean-name-function'
-and CANONICAL-ADDRESS through `bbdb-canonicalize-mail-function'."
-  (list (if (car components)
-            (if bbdb-message-clean-name-function
-                (funcall bbdb-message-clean-name-function (car components))
-              (car components)))
-        (if (cadr components)
-            (if bbdb-canonicalize-mail-function
-                (funcall bbdb-canonicalize-mail-function (cadr components))
-              ;; Minimalistic clean-up
-              (bbdb-string-trim (cadr components))))))
-
-(defun bbdb-extract-address-components (address &optional all)
-  "Given an RFC-822 address ADDRESS, extract full name and canonical address.
-This function behaves like `mail-extract-address-components', but it passes
-its return value through `bbdb-clean-address-components'.
-See also `bbdb-decompose-bbdb-address'."
-  (if all
-      (mapcar 'bbdb-clean-address-components
-              (mail-extract-address-components address t))
-    (bbdb-clean-address-components (mail-extract-address-components address))))
-
-;; Inspired by `gnus-extract-address-components' from gnus-utils.
-(defun bbdb-decompose-bbdb-address (mail)
-  "Given an RFC-822 address MAIL, extract full name and canonical address.
-In general, this function behaves like the more sophisticated function
-`mail-extract-address-components'.  Yet for an address `<Joe_Smith@foo.com>'
-lacking a real name the latter function returns the name \"Joe Smith\".
-This is useful when analyzing the headers of email messages we receive
-from the outside world.  Yet when analyzing the mail addresses stored
-in BBDB, this pollutes the mail-aka space.  So we define here
-an intentionally much simpler function for decomposing the names
-and canonical addresses in the mail field of BBDB records."
-  (let (name address)
-    ;; First find the address - the thing with the @ in it.
-    (cond (;; Check `<foo@bar>' first in order to handle the quite common
-	   ;; form `"abc@xyz" <foo@bar>' (i.e. `@' as part of a comment)
-	   ;; correctly.
-	   (string-match "<\\([^@ \t<>]+[!@][^@ \t<>]+\\)>" mail)
-	   (setq address (match-string 1 mail)))
-	  ((string-match "\\b[^@ \t<>]+[!@][^@ \t<>]+\\b" mail)
-	   (setq address (match-string 0 mail))))
-    ;; Then check whether the `name <address>' format is used.
-    (and address
-	 ;; Linear white space is not required.
-	 (string-match (concat "[ \t]*<" (regexp-quote address) ">") mail)
-	 (setq name (substring mail 0 (match-beginning 0)))
-         ;; Strip any quotes mail the name.
-         (string-match "^\".*\"$" name)
-         (setq name (substring name 1 (1- (match-end 0)))))
-    ;; If not, then check whether the `address (name)' format is used.
-    (or name
-	(and (string-match "(\\([^)]+\\))" mail)
-	     (setq name (match-string 1 mail))))
-    (list (if (equal name "") nil name) (or address mail))))
-
-;;; Massage of mail addresses
-
-(defcustom bbdb-canonical-hosts
-  ;; Example
-  (regexp-opt '("cs.cmu.edu" "ri.cmu.edu"))
-  "Regexp matching the canonical part of the domain part of a mail address.
-If the domain part of a mail address matches this regexp, the domain
-is replaced by the substring that actually matched this address.
-
-Used by  `bbdb-canonicalize-mail-1'.  See also `bbdb-ignore-redundant-mails'."
-  :group 'bbdb-mua
-  :type '(regexp :tag "Regexp matching sites"))
-
-(defun bbdb-canonicalize-mail-1 (address)
-  "Example of `bbdb-canonicalize-mail-function'.
-However, this function is too specific to be useful for the general user.
-Take it as a source of inspiration for what can be done."
-  (setq address (bbdb-string-trim address))
-  (cond
-   ;; Rewrite mail-drop hosts.
-   ;; RW: The following is now also handled by `bbdb-ignore-redundant-mails'
-   ((string-match
-     (concat "\\`\\([^@%!]+@\\).*\\.\\(" bbdb-canonical-hosts "\\)\\'")
-     address)
-    (concat (match-string 1 address) (match-string 2 address)))
-   ;;
-   ;; Here at Lucid, our workstation names sometimes get into our mail
-   ;; addresses in the form "jwz%thalidomide@lucid.com" (instead of simply
-   ;; "jwz@lucid.com").  This removes the workstation name.
-   ((string-match "\\`\\([^@%!]+\\)%[^@%!.]+@\\(lucid\\.com\\)\\'" address)
-    (concat (match-string 1 address) "@" (match-string 2 address)))
-   ;;
-   ;; Another way that our local mailer is misconfigured: sometimes addresses
-   ;; which should look like "user@some.outside.host" end up looking like
-   ;; "user%some.outside.host" or even "user%some.outside.host@lucid.com"
-   ;; instead.  This rule rewrites it into the original form.
-   ((string-match "\\`\\([^@%]+\\)%\\([^@%!]+\\)\\(@lucid\\.com\\)?\\'" address)
-    (concat (match-string 1 address) "@" (match-string 2 address)))
-   ;;
-   ;; Sometimes I see addresses like "foobar.com!user@foobar.com".
-   ;; That's totally redundant, so this rewrites it as "user@foobar.com".
-   ((string-match "\\`\\([^@%!]+\\)!\\([^@%!]+[@%]\\1\\)\\'" address)
-    (match-string 2 address))
-   ;;
-   ;; Sometimes I see addresses like "foobar.com!user".  Turn it around.
-   ((string-match "\\`\\([^@%!.]+\\.[^@%!]+\\)!\\([^@%]+\\)\\'" address)
-    (concat (match-string 2 address) "@" (match-string 1 address)))
-   ;;
-   ;; The mailer at hplb.hpl.hp.com tends to puke all over addresses which
-   ;; pass through mailing lists which are maintained there: it turns normal
-   ;; addresses like "user@foo.com" into "user%foo.com@hplb.hpl.hp.com".
-   ;; This reverses it.  (I actually could have combined this rule with
-   ;; the similar lucid.com rule above, but then the regexp would have been
-   ;; more than 80 characters long...)
-   ((string-match "\\`\\([^@!]+\\)%\\([^@%!]+\\)@hplb\\.hpl\\.hp\\.com\\'"
-          address)
-    (concat (match-string 1 address) "@" (match-string 2 address)))
-   ;;
-   ;; Another local mail-configuration botch: sometimes mail shows up
-   ;; with addresses like "user@workstation", where "workstation" is a
-   ;; local machine name.  That should really be "user" or "user@netscape.com".
-   ;; (I'm told this one is due to a bug in SunOS 4.1.1 sendmail.)
-   ((string-match "\\`\\([^@%!]+\\)[@%][^@%!.]+\\'" address)
-    (match-string 1 address))
-   ;;
-   ;; Sometimes I see addresses like "foo%somewhere%uunet.uu.net@somewhere.else".
-   ;; This is silly, because I know that I can send mail to uunet directly.
-   ((string-match ".%uunet\\.uu\\.net@[^@%!]+\\'" address)
-    (concat (substring address 0 (+ (match-beginning 0) 1)) "@UUNET.UU.NET"))
-   ;;
-   ;; Otherwise, leave it as it is.
-   (t address)))
-
-(defun bbdb-message-clean-name-default (name)
-  "Default function for `bbdb-message-clean-name-function'.
-This strips garbage from the user full NAME string."
-  ;; Remove leading non-alpha chars
-  (if (string-match "\\`[^[:alpha:]]+" name)
-      (setq name (substring name (match-end 0))))
-
-  (if (string-match "^\\([^@]+\\)@" name)
-      ;; The name is really a mail address and we use the part preceeding "@".
-      ;; Everything following "@" is ignored.
-      (setq name (match-string 1 name)))
-
-  ;; Replace "firstname.surname" by "firstname surname".
-  ;; Do not replace ". " with " " because that could be an initial.
-  (setq name (replace-regexp-in-string "\\.\\([^ ]\\)" " \\1" name))
-
-  ;; Replace tabs, spaces, and underscores with a single space.
-  (setq name (replace-regexp-in-string "[ \t\n_]+" " " name))
-
-  ;; Remove trailing comments separated by "(" or " [-#]"
-  ;; This does not work all the time because some of our friends in
-  ;; northern europe have brackets in their names...
-  (if (string-match "[^ \t]\\([ \t]*\\((\\| [-#]\\)\\)" name)
-      (setq name (substring name 0 (match-beginning 1))))
-
-  ;; Remove phone extensions (like "x1234" and "ext. 1234")
-  (let ((case-fold-search t))
-    (setq name (replace-regexp-in-string
-                "\\W+\\(x\\|ext\\.?\\)\\W*[-0-9]+" "" name)))
-
-  ;; Remove trailing non-alpha chars
-  (if (string-match "[^[:alpha:]]+\\'" name)
-      (setq name (substring name 0 (match-beginning 0))))
-
-  ;; Remove text properties
-  (substring-no-properties name))
-
-;; BBDB data structure
-(defmacro bbdb-defstruct (name &rest elts)
-  "Define two functions to operate on vector NAME for each symbol ELT in ELTS.
-The function bbdb-NAME-ELT returns the element ELT in vector NAME.
-The function bbdb-NAME-set-ELT sets ELT.
-Also define a constant bbdb-NAME-length that holds the number of ELTS
-in vector NAME."
-  (declare (indent 1))
-  (let* ((count 0)
-         (sname (symbol-name name))
-         (uname (upcase sname))
-         (cname (concat "bbdb-" sname "-"))
-         body)
-    (dolist (elt elts)
-      (let* ((selt (symbol-name elt))
-             (setname  (intern (concat cname "set-" selt))))
-        (push (list 'defsubst (intern (concat cname selt)) `(,name)
-                    (format "For BBDB %s read element %i `%s'."
-                            uname count selt)
-                    ;; Use `elt' instead of `aref' so that these functions
-                    ;; also work for the `bbdb-record-type' pseudo-code.
-                    `(elt ,name ,count)) body)
-        (push (list 'defsubst setname `(,name value)
-                    (format "For BBDB %s set element %i `%s' to VALUE.  \
-Return VALUE.
-Do not call this function directly.  Call instead `bbdb-record-set-field'
-which ensures the integrity of the database.  Also, this makes your code
-more robust with respect to possible future changes of BBDB's innermost
-internals."
-                            uname count selt)
-                    `(aset ,name ,count value)) body))
-      (setq count (1+ count)))
-    (push (list 'defconst (intern (concat cname "length")) count
-                (concat "Length of BBDB `" sname "'.")) body)
-    (cons 'progn body)))
-
-;; Define RECORD:
-(bbdb-defstruct record
-  firstname lastname affix aka organization phone address mail xfields
-  uuid creation-date timestamp cache)
-
-;; Define PHONE:
-(bbdb-defstruct phone
-  label area exchange suffix extension)
-
-;; Define ADDRESS:
-(bbdb-defstruct address
-  label streets city state postcode country)
-
-;; Define record CACHE:
-;; - fl-name (first and last name of the person referred to by the record),
-;; - lf-name (last and first name of the person referred to by the record),
-;; - mail-aka (list of names associated with mail addresses)
-;; - mail-canon (list of canonical mail addresses)
-;; - sortkey (the concatenation of the elements used for sorting the record),
-;; - marker  (position of beginning of record in `bbdb-file')
-(bbdb-defstruct cache
-  fl-name lf-name mail-aka mail-canon sortkey marker)
-
-(defsubst bbdb-record-mail-aka (record)
-  "Record cache function: Return mail-aka for RECORD."
-  (bbdb-cache-mail-aka (bbdb-record-cache record)))
-
-(defsubst bbdb-record-mail-canon (record)
-  "Record cache function: Return mail-canon for RECORD."
-  (bbdb-cache-mail-canon (bbdb-record-cache record)))
-
-(defun bbdb-empty-record ()
-  "Return a new empty record structure with a cache.
-It is the caller's responsibility to make the new record known to BBDB."
-  (let ((record (make-vector bbdb-record-length nil)))
-    (bbdb-record-set-cache record (make-vector bbdb-cache-length nil))
-    record))
-
-;; `bbdb-hashtable' associates with each KEY a list of matching records.
-;; KEY includes fl-name, lf-name, organizations, AKAs and email addresses.
-;; When loading the database the hash table is initialized by calling
-;; `bbdb-hash-record' for each record.  This function is also called
-;; when new records are added to the database.
-;; `bbdb-delete-record-internal' with arg REMHASH non-nil removes a record
-;; from the hash table (besides deleting the record from the database).
-;; When an existing record is modified, the code that modifies the record
-;; needs to update the hash table, too.  This includes removing the outdated
-;; associations between KEYs and record as well as adding the new associations.
-;; This is one reason to modify records by calling `bbdb-record-set-field'
-;; which properly updates the hash table.
-;; The hash table can be accessed via `bbdb-gethash'
-;; and via functions like `completing-read'.
-
-(defun bbdb-puthash (key record)
-  "Associate RECORD with KEY in `bbdb-hashtable'.
-KEY must be a string or nil.  Empty strings and nil are ignored."
-  (if (and key (not (string= "" key))) ; do not hash empty strings
-      (let* ((key (downcase key))
-             (records (gethash key bbdb-hashtable)))
-        (puthash key (if records (bbdb-pushnewq record records)
-                       (list record))
-                 bbdb-hashtable))))
-
-(defun bbdb-gethash (key &optional predicate)
-  "Return list of records associated with KEY in `bbdb-hashtable'.
-KEY must be a string or nil.  Empty strings and nil are ignored.
-PREDICATE may take the same values as `bbdb-completion-list'."
-  (when (and key (not (string= "" key)))
-    (let* ((key (downcase key))
-           (all-records (gethash key bbdb-hashtable))
-           records)
-      (if (or (not predicate) (eq t predicate))
-          all-records
-        (dolist (record all-records)
-          (if (catch 'bbdb-hash-ok
-                (bbdb-hash-p key record predicate))
-              (push record records)))
-        records))))
-
-(defun bbdb-hash-p (key record predicate)
-  "Throw `bbdb-hash-ok' non-nil if KEY matches RECORD acording to PREDICATE.
-PREDICATE may take the same values as the elements of `bbdb-completion-list'."
-  (if (and (memq 'fl-name predicate)
-           (bbdb-string= key (or (bbdb-record-name record) "")))
-      (throw 'bbdb-hash-ok 'fl-name))
-  (if (and (memq 'lf-name predicate)
-           (bbdb-string= key (or (bbdb-record-name-lf record) "")))
-      (throw 'bbdb-hash-ok 'lf-name))
-  (if (memq 'organization predicate)
-      (mapc (lambda (organization) (if (bbdb-string= key organization)
-                                       (throw 'bbdb-hash-ok 'organization)))
-            (bbdb-record-organization record)))
-  (if (memq 'aka predicate)
-      (mapc (lambda (aka) (if (bbdb-string= key aka)
-                              (throw 'bbdb-hash-ok 'aka)))
-            (bbdb-record-field record 'aka-all)))
-  (if (and (memq 'primary predicate)
-           (bbdb-string= key (car (bbdb-record-mail-canon record))))
-      (throw 'bbdb-hash-ok 'primary))
-  (if (memq 'mail predicate)
-      (mapc (lambda (mail) (if (bbdb-string= key mail)
-                               (throw 'bbdb-hash-ok 'mail)))
-            (bbdb-record-mail-canon record)))
-  nil)
-
-(defun bbdb-remhash (key record)
-  "Remove RECORD from list of records associated with KEY.
-KEY must be a string or nil.  Empty strings and nil are ignored."
-  (if (and key (not (string= "" key)))
-      (let* ((key (downcase key))
-             (records (gethash key bbdb-hashtable)))
-        (when records
-          (setq records (delq record records))
-          (if records
-              (puthash key records bbdb-hashtable)
-            (remhash key bbdb-hashtable))))))
-
-(defun bbdb-hash-record (record)
-  "Insert RECORD in `bbdb-hashtable'.
-This performs all initializations required for a new record.
-Do not call this for existing records that require updating."
-  (bbdb-puthash (bbdb-record-name record) record)
-  (bbdb-puthash (bbdb-record-name-lf record) record)
-  (dolist (organization (bbdb-record-organization record))
-    (bbdb-puthash organization record))
-  (dolist (aka (bbdb-record-aka record))
-    (bbdb-puthash aka record))
-  (bbdb-puthash-mail record)
-  (puthash (bbdb-record-uuid record) record bbdb-uuid-table))
-
-(defun bbdb-puthash-mail (record)
-  "For RECORD put mail into `bbdb-hashtable'."
-  (let (mail-aka mail-canon address)
-    (dolist (mail (bbdb-record-mail record))
-      (setq address (bbdb-decompose-bbdb-address mail))
-      (when (car address)
-        (push (car address) mail-aka)
-        (bbdb-puthash (car address) record))
-      (push (nth 1 address) mail-canon)
-      (bbdb-puthash (nth 1 address) record))
-    (bbdb-cache-set-mail-aka (bbdb-record-cache record)
-                             (nreverse mail-aka))
-    (bbdb-cache-set-mail-canon (bbdb-record-cache record)
-                               (nreverse mail-canon))))
-
-(defun bbdb-hash-update (record old new)
-  "Update hash for RECORD.  Remove OLD, insert NEW.
-Both OLD and NEW are lists of values."
-  (dolist (elt old)
-    (bbdb-remhash elt record))
-  (dolist (elt new)
-    (bbdb-puthash elt record)))
-
-(defun bbdb-check-name (first last &optional record)
-  "Check whether the name FIRST LAST is a valid name.
-This throws an error if the name is already used by another record
-and `bbdb-allow-duplicates' is nil.  If RECORD is non-nil, FIRST and LAST
-may correspond to RECORD without raising an error."
-  ;; Are there more useful checks for names beyond checking for duplicates?
-  (unless bbdb-allow-duplicates
-    (let* ((name (bbdb-concat 'name-first-last first last))
-           (records (bbdb-gethash name '(fl-name lf-name aka))))
-      (if (or (and (not record) records)
-              (remq record records))
-          (error "%s is already in BBDB" name)))))
-
-(defun bbdb-record-name (record)
-  "Record cache function: Return the full name FIRST_LAST of RECORD.
-Return empty string if both the first and last name are nil.
-If the name is not available in the name cache, the name cache value
-is generated and stored."
-  (or (bbdb-cache-fl-name (bbdb-record-cache record))
-      ;; Build the name cache for a record.
-      (bbdb-record-set-name record t t)))
-
-(defun bbdb-record-name-lf (record)
-  "Record cache function: Return the full name LAST_FIRST of RECORD.
-If the name is not available in the name cache, the name cache value
-is generated and stored."
-  (or (bbdb-cache-lf-name (bbdb-record-cache record))
-      ;; Build the name cache for a record.
-      (progn (bbdb-record-set-name record t t)
-             (bbdb-cache-lf-name (bbdb-record-cache record)))))
-
-(defun bbdb-record-set-name (record first last)
-  "Record cache function: For RECORD set full name based on FIRST and LAST.
-If FIRST or LAST are t use respective existing entries of RECORD.
-Set full name in cache and hash.  Return first-last name."
-  (let* ((cache (bbdb-record-cache record))
-         (fl-name (bbdb-cache-fl-name cache))
-         (lf-name (bbdb-cache-lf-name cache)))
-    (if fl-name (bbdb-remhash fl-name record))
-    (if lf-name (bbdb-remhash lf-name record)))
-  (if (eq t first)
-      (setq first (bbdb-record-firstname record))
-    (bbdb-record-set-firstname record first))
-  (if (eq t last)
-      (setq last (bbdb-record-lastname record))
-    (bbdb-record-set-lastname record last))
-  (let ((fl-name (bbdb-concat 'name-first-last first last))
-        (lf-name (bbdb-concat 'name-last-first last first))
-        (cache (bbdb-record-cache record)))
-    ;; Set cache of RECORD
-    (bbdb-cache-set-fl-name cache fl-name)
-    (bbdb-cache-set-lf-name cache lf-name)
-    ;; Set hash.  For convenience, the hash contains the full name
-    ;; as first-last and last-fist.
-    (bbdb-puthash fl-name record)
-    (bbdb-puthash lf-name record)
-    fl-name))
-
-(defun bbdb-record-sortkey (record)
-  "Record cache function: Return the sortkey for RECORD.
-Set and store it if necessary."
-  (or (bbdb-cache-sortkey (bbdb-record-cache record))
-      (bbdb-record-set-sortkey record)))
-
-(defun bbdb-record-set-sortkey (record)
-  "Record cache function: Set and return RECORD's sortkey."
-  (bbdb-cache-set-sortkey
-   (bbdb-record-cache record)
-   (downcase
-    (bbdb-concat "" (bbdb-record-lastname record)
-                 (bbdb-record-firstname record)
-                 (bbdb-record-organization record)))))
-
-(defsubst bbdb-record-marker (record)
-  "Record cache function: Return the marker for RECORD."
-  (bbdb-cache-marker (bbdb-record-cache record)))
-
-(defsubst bbdb-record-set-marker (record marker)
-  "Record cache function: Set and return RECORD's MARKER."
-  (bbdb-cache-set-marker (bbdb-record-cache record) marker))
-
-(defsubst bbdb-record-xfield (record label)
-  "For RECORD return value of xfield LABEL.
-Return nil if xfield LABEL is undefined."
-  (cdr (assq label (bbdb-record-xfields record))))
-
-;; The values of xfields are normally strings.  The following function
-;; comes handy if we want to treat these values as symbols.
-(defun bbdb-record-xfield-intern (record label)
-  "For RECORD return interned value of xfield LABEL.
-Return nil if xfield LABEL does not exist."
-  (let ((value (bbdb-record-xfield record label)))
-    ;; If VALUE is not a string, return whatever it is.
-    (if (stringp value) (intern value) value)))
-
-(defun bbdb-record-xfield-string (record label)
-  "For RECORD return value of xfield LABEL as string.
-Return nil if xfield LABEL does not exist."
-  (let ((value (bbdb-record-xfield record label)))
-    (if (string-or-null-p value)
-        value
-      (let ((print-escape-newlines t))
-        (prin1-to-string value)))))
-
-(defsubst bbdb-record-xfield-split (record label)
-  "For RECORD return value of xfield LABEL split as a list.
-Splitting is based on `bbdb-separator-alist'."
-  (let ((val (bbdb-record-xfield record label)))
-    (cond ((stringp val) (bbdb-split label val))
-          (val (error "Cannot split `%s'" val)))))
-
-(defun bbdb-record-set-xfield (record label value)
-  "For RECORD set xfield LABEL to VALUE.
-If VALUE is nil or an empty string, remove xfield LABEL from RECORD.
-Return VALUE."
-  ;; In principle we can also have xfield labels `name' or `mail', etc.
-  ;; Yet the actual code would get rather confused.  So we throw an error.
-  (if (memq label '(name firstname lastname affix organization
-                         mail aka phone address xfields))
-      (error "xfield label `%s' illegal" label))
-  (if (eq label 'mail-alias)
-      (setq bbdb-mail-aliases-need-rebuilt 'edit))
-  (if (stringp value) (setq value (bbdb-string-trim value t)))
-  (let ((old-xfield (assq label (bbdb-record-xfields record))))
-    ;; Do nothing if both OLD-XFIELD and VALUE are nil.
-    (cond ((and old-xfield value) ; update
-           (setcdr old-xfield value))
-          (value ; new xfield
-           (bbdb-pushnewq label bbdb-xfield-label-list)
-           (bbdb-record-set-xfields record
-                                    (append (bbdb-record-xfields record)
-                                            (list (cons label value)))))
-          (old-xfield ; remove
-           (bbdb-record-set-xfields record
-                                    (delq old-xfield
-                                          (bbdb-record-xfields record))))))
-  value)
-
-(defun bbdb-check-type (object type &optional abort extended)
-  "Return non-nil if OBJECT is of type TYPE.
-TYPE is a pseudo-code as in `bbdb-record-type'.
-If ABORT is non-nil, abort with error message if type checking fails.
-If EXTENDED is non-nil, consider extended atomic types which may include
-symbols, numbers, markers, and strings."
-  (let (tmp)
-    ;; Add more predicates?  Compare info node `(elisp.info)Type Predicates'.
-    (or (cond ((eq type 'symbol) (symbolp object))
-              ((eq type 'integer) (integerp object))
-              ((eq type 'marker) (markerp object))
-              ((eq type 'number) (numberp object))
-              ((eq type 'string) (stringp object))
-              ((eq type 'sexp) t) ; matches always
-              ((eq type 'face) (facep object))
-              ;; not quite a type
-              ((eq type 'bound) (and (symbolp object) (boundp object)))
-              ((eq type 'function) (functionp object))
-              ((eq type 'vector) (vectorp object))
-              ((and extended
-                    (cond ((symbolp type) (setq tmp (eq type object)) t)
-                          ((or (numberp type) (markerp type))
-                           (setq tmp (= type object)) t)
-                          ((stringp type)
-                           (setq tmp (and (stringp object)
-                                          (string= type object))) t)))
-               tmp)
-              ((not (consp type))
-               (error "Atomic type `%s' undefined" type))
-              ((eq 'const (setq tmp (car type)))
-               (equal (nth 1 type) object))
-              ((eq tmp 'cons)
-               (and (consp object)
-                    (bbdb-check-type (car object) (nth 1 type) abort extended)
-                    (bbdb-check-type (cdr object) (nth 2 type) abort extended)))
-              ((eq tmp 'list)
-               (and (listp object)
-                    (eq (length (cdr type)) (length object))
-                    (let ((type (cdr type)) (object object) (ok t))
-                      (while type
-                        (unless (bbdb-check-type (pop object) (pop type)
-                                                 abort extended)
-                          (setq ok nil type nil)))
-                      ok)))
-              ((eq tmp 'repeat)
-               (and (listp object)
-                    (let ((tp (nth 1 type)) (object object) (ok t))
-                      (while object
-                        (unless (bbdb-check-type (pop object) tp abort extended)
-                          (setq ok nil object nil)))
-                      ok)))
-              ((eq tmp 'vector)
-               (and (vectorp object)
-                    (let* ((i 0) (type (cdr type))
-                           (ok (eq (length object) (length type))))
-                      (when ok
-                        (while type
-                          (if (bbdb-check-type (aref object i) (pop type)
-                                               abort extended)
-                              (setq i (1+ i))
-                            (setq ok nil type nil)))
-                        ok))))
-              ((eq tmp 'or) ; like customize `choice' type
-               (let ((type (cdr type)) ok)
-                 (while type
-                   (if (bbdb-check-type object (pop type) nil extended)
-                       (setq ok t type nil)))
-                 ok))
-              ;; User-defined predicate
-              ((eq tmp 'user-p) (funcall (nth 1 type) object))
-              (t (error "Compound type `%s' undefined" tmp)))
-        (and abort
-             (error "Type mismatch: expect %s, got `%s'" type object)))))
-
-;; (bbdb-check-type 'bar 'symbol)
-;; (bbdb-check-type 'bar 'bar)
-;; (bbdb-check-type "foo" 'symbol t)
-;; (bbdb-check-type "foo" '(or symbol string))
-;; (bbdb-check-type nil '(const nil))
-;; (bbdb-check-type '(bar . "foo") '(cons symbol string))
-;; (bbdb-check-type '(bar "foo") '(list symbol string))
-;; (bbdb-check-type '("bar" "foo") '(repeat string))
-;; (bbdb-check-type (vector 'bar "foo") '(vector symbol string))
-;; (bbdb-check-type (vector 'bar "foo") 'vector)
-;; (bbdb-check-type '(bar (bar . "foo")) '(list symbol (cons symbol string)))
-;; (bbdb-check-type '("aa" . "bb") '(or (const nil) (cons string string)) t)
-;; (bbdb-check-type nil '(or nil (cons string string)) t t)
-;; (bbdb-check-type "foo" '(user-p (lambda (a) (stringp a))))
-;; (bbdb-check-type 'set 'function)
-
-(defun bbdb-record-field (record field)
-  "For RECORD return the value of FIELD.
-
-FIELD may take the following values
- firstname     Return the first name of RECORD
- lastname      Return the last name of RECORD
- name          Return the full name of RECORD (first name first)
- name-lf       Return the full name of RECORD (last name first)
- affix         Return the list of affixes
- organization  Return the list of organizations
- aka           Return the list of AKAs
- aka-all       Return the list of AKAs plus mail-akas.
- mail          Return the list of email addresses
- mail-aka      Return the list of name parts in mail addresses
- mail-canon    Return the list of canonical mail addresses.
- phone         Return the list of phone numbers
- address       Return the list of addresses
- uuid          Return the uuid of RECORD
- creation-date Return the creation-date
- timestamp     Return the timestamp
- xfields       Return the list of all xfields
-
-Any other symbol is interpreted as the label for an xfield.
-Then return the value of this xfield.
-
-See also `bbdb-record-set-field'."
-  (cond ((eq field 'firstname) (bbdb-record-firstname record))
-        ((eq field 'lastname) (bbdb-record-lastname record))
-        ((eq field 'name)     (bbdb-record-name record))
-        ((eq field 'name-lf)  (bbdb-record-name-lf record))
-        ((eq field 'affix)    (bbdb-record-affix record))
-        ((eq field 'organization)  (bbdb-record-organization record))
-        ((eq field 'mail)     (bbdb-record-mail record))
-        ((eq field 'mail-canon) (bbdb-record-mail-canon record)) ; derived (cached) field
-        ((eq field 'mail-aka) (bbdb-record-mail-aka record)) ; derived (cached) field
-        ((eq field 'aka)      (bbdb-record-aka record))
-        ((eq field 'aka-all)  (append (bbdb-record-aka record) ; derived field
-                                      (bbdb-record-mail-aka record)))
-        ((eq field 'phone)    (bbdb-record-phone record))
-        ((eq field 'address)  (bbdb-record-address record))
-        ((eq field 'uuid)     (bbdb-record-uuid record))
-        ((eq field 'creation-date) (bbdb-record-creation-date record))
-        ((eq field 'timestamp) (bbdb-record-timestamp record))
-        ;; Return all xfields
-        ((eq field 'xfields)  (bbdb-record-xfields record))
-        ;; Return xfield FIELD (e.g., `notes') or nil if FIELD is not defined.
-        ((symbolp field) (bbdb-record-xfield record field))
-        (t (error "Unknown field type `%s'" field))))
-(define-obsolete-function-alias 'bbdb-record-get-field 'bbdb-record-field "3.0")
-
-(defun bbdb-record-set-field (record field value &optional merge check)
-  "For RECORD set FIELD to VALUE.  Return VALUE.
-If MERGE is non-nil, merge VALUE with the current value of FIELD.
-If CHECK is non-nil, check syntactically whether FIELD may take VALUE.
-This function also updates the hash table.  However, it does not update
-RECORD in the database.  Use `bbdb-change-record' for that.
-
-FIELD may take the following values
- firstname     VALUE is the first name of RECORD
- lastname      VALUE is the last name of RECORD
- name          VALUE is the full name of RECORD either as one string
-                 or as a cons pair (FIRST . LAST)
- affix         VALUE is the list of affixes
- organization  VALUE is the list of organizations
- aka           VALUE is the list of AKAs
- mail          VALUE is the list of email addresses
- phone         VALUE is the list of phone numbers
- address       VALUE is the list of addresses
- uuid          VALUE is the uuid of RECORD
- creation-date VALUE is the creation-date
- timestamp     VALUE is the timestamp
- xfields       VALUE is the list of all xfields
-
-Any other symbol is interpreted as the label for an xfield.
-Then VALUE is the value of this xfield.
-
-See also `bbdb-record-field'."
-  (bbdb-editable)
-  (if (memq field '(name-lf mail-aka mail-canon aka-all))
-      (error "`%s' is not allowed as the name of a field" field))
-  (let ((record-type (cdr bbdb-record-type)))
-    (cond ((eq field 'firstname) ; First name
-           (if merge (error "Does not merge names"))
-           (if check (bbdb-check-type value (bbdb-record-firstname record-type) t))
-           (bbdb-check-name value (bbdb-record-lastname record) record)
-           (bbdb-record-set-name record value t))
-
-          ;; Last name
-          ((eq field 'lastname)
-           (if merge (error "Does not merge names"))
-           (if check (bbdb-check-type value (bbdb-record-lastname record-type) t))
-           (bbdb-check-name (bbdb-record-firstname record) value record)
-           (bbdb-record-set-name record t value))
-
-          ;; Name
-          ((eq field 'name)
-           (if merge (error "Does not merge names"))
-           (if (stringp value)
-               (setq value (bbdb-divide-name value))
-             (if check (bbdb-check-type value '(cons string string) t)))
-           (let ((fn (car value)) (ln (cdr value)))
-             (bbdb-check-name fn ln record)
-             (bbdb-record-set-name record fn ln)))
-
-          ;; Affix
-          ((eq field 'affix)
-           (if merge (setq value (bbdb-merge-lists (bbdb-record-affix record)
-                                                   value 'bbdb-string=)))
-           (if check (bbdb-check-type value (bbdb-record-affix record-type) t))
-           (setq value (bbdb-list-strings value))
-           (bbdb-record-set-affix record value))
-
-          ;; Organization
-          ((eq field 'organization)
-           (if merge (setq value (bbdb-merge-lists (bbdb-record-organization record)
-                                                   value 'bbdb-string=)))
-           (if check (bbdb-check-type value (bbdb-record-organization record-type) t))
-           (setq value (bbdb-list-strings value))
-           (bbdb-hash-update record (bbdb-record-organization record) value)
-           (dolist (organization value)
-             (bbdb-pushnew organization bbdb-organization-list))
-           (bbdb-record-set-organization record value))
-
-          ;; AKA
-          ((eq field 'aka)
-           (if merge (setq value (bbdb-merge-lists (bbdb-record-aka record)
-                                                   value 'bbdb-string=)))
-           (if check (bbdb-check-type value (bbdb-record-aka record-type) t))
-           (setq value (bbdb-list-strings value))
-           (unless bbdb-allow-duplicates
-             (dolist (aka value)
-               (let ((old (remq record (bbdb-gethash aka '(fl-name lf-name aka)))))
-                 (if old (error "Alternate name address \"%s\" is used by \"%s\""
-                                aka (mapconcat 'bbdb-record-name old ", "))))))
-           (bbdb-hash-update record (bbdb-record-aka record) value)
-           (bbdb-record-set-aka record value))
-
-          ;; Mail
-          ((eq field 'mail)
-           (if merge (setq value (bbdb-merge-lists (bbdb-record-mail record)
-                                                   value 'bbdb-string=)))
-           (if check (bbdb-check-type value (bbdb-record-mail record-type) t))
-           (setq value (bbdb-list-strings value))
-           (unless bbdb-allow-duplicates
-             (dolist (mail value)
-               (let ((old (remq record (bbdb-gethash mail '(mail)))))
-                 (if old (error "Mail address \"%s\" is used by \"%s\""
-                                mail (mapconcat 'bbdb-record-name old ", "))))))
-           (dolist (aka (bbdb-record-mail-aka record))
-             (bbdb-remhash aka record))
-           (dolist (mail (bbdb-record-mail-canon record))
-             (bbdb-remhash mail record))
-           (bbdb-record-set-mail record value)
-           (bbdb-puthash-mail record))
-
-          ;; Phone
-          ((eq field 'phone)
-           (if merge (setq value (bbdb-merge-lists (bbdb-record-phone record)
-                                                   value 'equal)))
-           (if check (bbdb-check-type value (bbdb-record-phone record-type) t))
-           (dolist (phone value)
-             (bbdb-pushnew (bbdb-phone-label phone) bbdb-phone-label-list))
-           (bbdb-record-set-phone record value))
-
-          ;; Address
-          ((eq field 'address)
-           (if merge (setq value (bbdb-merge-lists (bbdb-record-address record)
-                                                   value 'equal)))
-           (if check (bbdb-check-type value (bbdb-record-address record-type) t))
-           (dolist (address value)
-             (bbdb-pushnew (bbdb-address-label address) bbdb-address-label-list)
-             (mapc (lambda (street) (bbdb-pushnewt street bbdb-street-list))
-                   (bbdb-address-streets address))
-             (bbdb-pushnewt (bbdb-address-city address) bbdb-city-list)
-             (bbdb-pushnewt (bbdb-address-state address) bbdb-state-list)
-             (bbdb-pushnewt (bbdb-address-postcode address) bbdb-postcode-list)
-             (bbdb-pushnewt (bbdb-address-country address) bbdb-country-list))
-           (bbdb-record-set-address record value))
-
-          ;; uuid
-          ((eq field 'uuid)
-           ;; MERGE not meaningful
-           (if check (bbdb-check-type value (bbdb-record-uuid record-type) t))
-           (let ((old-uuid (bbdb-record-uuid record)))
-             (unless (string= old-uuid value)
-               (remhash old-uuid bbdb-uuid-table)
-               (bbdb-record-set-uuid record value)
-               (puthash value record bbdb-uuid-table))))
-
-          ;; creation-date
-          ((eq field 'creation-date)
-           ;; MERGE not meaningful
-           (if check (bbdb-check-type value (bbdb-record-creation-date record-type) t))
-           (bbdb-record-set-creation-date record value))
-
-          ;; timestamp
-          ((eq field 'timestamp)
-           ;; MERGE not meaningful
-           (if check (bbdb-check-type value (bbdb-record-timestamp record-type) t))
-           (bbdb-record-set-timestamp record value))
-
-          ;; all xfields
-          ((eq field 'xfields)
-           (if merge
-               (let ((xfields (bbdb-record-xfields record))
-                     xfield)
-                 (dolist (nv value)
-                   (if (setq xfield (assq (car nv) xfields))
-                       (setcdr xfield (bbdb-merge-xfield
-                                       (car nv) (cdr xfield) (cdr nv)))
-                     (setq xfields (append xfields (list nv)))))
-                 (setq value xfields)))
-           (if check (bbdb-check-type value (bbdb-record-xfields record-type) t))
-           (let (new-xfields)
-             (dolist (xfield value)
-               ;; Ignore junk
-               (when (and (cdr xfield) (not (equal "" (cdr xfield))))
-                 (push xfield new-xfields)
-                 (bbdb-pushnewq (car xfield) bbdb-xfield-label-list)))
-             (bbdb-record-set-xfields record (nreverse new-xfields))))
-
-          ;; Single xfield
-          ((symbolp field)
-           (if merge
-               (setq value (bbdb-merge-xfield field (bbdb-record-xfield record field)
-                                              value)))
-           ;; The following test always succeeds
-           ;; (if check (bbdb-check-type value 'sexp t))
-           ;; This removes xfield FIELD if its value is nil.
-           (bbdb-record-set-xfield record field value))
-
-          (t (error "Unknown field type `%s'" field)))))
-
-;; Currently unused (but possible entry for `bbdb-merge-xfield-function-alist')
-(defun bbdb-merge-concat (string1 string2 &optional separator)
-  "Return the concatenation of STRING1 and STRING2.
-SEPARATOR defaults to \"\\n\"."
-  (concat string1 (or separator "\n") string2))
-
-;; Currently unused (but possible entry for `bbdb-merge-xfield-function-alist')
-(defun bbdb-merge-concat-remove-duplicates (string1 string2)
-  "Concatenate STRING1 and STRING2, but remove duplicate lines."
-  (let ((lines (split-string string1 "\n")))
-    (dolist (line (split-string string2 "\n"))
-      (bbdb-pushnew line lines))
-    (bbdb-concat "\n" lines)))
-
-(defun bbdb-merge-string-least (string1 string2)
-  "Return the string out of STRING1 and STRING2 that is `string-lessp'."
-  (if (string-lessp string1 string2)
-      string1
-    string2))
-
-(defun bbdb-merge-string-most (string1 string2)
-  "Return the string out of STRING1 and STRING2 that is not `string-lessp'."
-  (if (string-lessp string1 string2)
-      string2
-    string1))
-
-(defun bbdb-merge-lists (l1 l2 cmp)
-  "Merge two lists L1 and L2 based on comparison CMP.
-An element from L2 is added to L1 if CMP returns nil for all elements of L1.
-If L1 or L2 are not lists, they are replaced by (list L1) and (list L2)."
-  (let (merge)
-    (unless (listp l1) (setq l1 (list l1)))
-    (dolist (e2 (if (listp l2) l2 (list l2)))
-      (let ((ll1 l1) e1 fail)
-        (while (setq e1 (pop ll1))
-          (if (funcall cmp e1 e2)
-              (setq ll1 nil
-                    fail t)))
-        (unless fail (push e2 merge))))
-    (append l1 (nreverse merge))))
-
-(defun bbdb-merge-xfield (label value1 value2)
-  "For LABEL merge VALUE1 with VALUE2.
-If LABEL has an entry in `bbdb-merge-xfield-function-alist', use it.
-If VALUE1 or VALUE2 is a substring of the other, return the longer one.
-Otherwise use `bbdb-concat'.  Return nil if we have nothing to merge."
-  (if (stringp value1) (setq value1 (bbdb-string-trim value1 t)))
-  (if (stringp value2) (setq value2 (bbdb-string-trim value2 t)))
-  (cond ((and value1 value2)
-         (let ((fun (cdr (assq label bbdb-merge-xfield-function-alist))))
-           (cond (fun (funcall fun value1 value2))
-                 ((not (and (stringp value1) (stringp value2)))
-                  (cons value1 value2)) ; concatenate lists
-                 ((string-match (regexp-quote value1) value2) value2)
-                 ((string-match (regexp-quote value2) value1) value1)
-                 (t (bbdb-concat label value1 value2)))))
-        (value1)
-        (value2)))
-
-;;; Parsing other things
-
-(defun bbdb-divide-name (string)
-  "Divide STRING into a first name and a last name.
-Case is ignored.  Return name as (FIRST . LAST).
-LAST is always a string (possibly empty).  FIRST may be nil."
-  (let ((case-fold-search t)
-        first suffix)
-    ;; Separate a suffix.
-    (if (string-match bbdb-lastname-suffix-re string)
-        (setq suffix (concat " " (match-string 1 string))
-              string (substring string 0 (match-beginning 0))))
-    (cond ((string-match "\\`\\(.+\\),[ \t\n]*\\(.+\\)\\'" string)
-           ;; If STRING contains a comma, this probably means that STRING
-           ;; is of the form "Last, First".
-           (setq first (match-string 2 string)
-                 string (match-string 1 string)))
-          ((string-match bbdb-lastname-re string)
-           (setq first (and (not (zerop (match-beginning 0)))
-                            (substring string 0 (match-beginning 0)))
-                 string (match-string 1 string))))
-    (cons (and first (bbdb-string-trim first))
-          (bbdb-string-trim (concat string suffix)))))
-
-(defun bbdb-parse-postcode (string)
-  "Check whether STRING is a legal postcode.
-Do this only if `bbdb-check-postcode' is non-nil."
-  (if bbdb-check-postcode
-      (let ((postcodes bbdb-legal-postcodes) re done)
-        (while (setq re (pop postcodes))
-          (if (string-match re string)
-              (setq done t postcodes nil)))
-        (if done string
-          (error "not a valid postcode.")))
-    string))
-
-(defun bbdb-phone-string (phone)
-  "Massage string PHONE into a standard format."
-  ;; Phone numbers should come in two forms:
-  (if (= 2 (length phone))
-      ;; (1) ["where" "the number"]
-      (if (stringp (aref phone 1))
-          (aref phone 1)
-        (error "Not a valid phone number: %s" (aref phone 1)))
-    ;; (2) ["where" 415 555 1212 99]
-    (unless (and (integerp (aref phone 2))
-                 (integerp (aref phone 3)))
-      (error "Not an NANP number: %s %s" (aref phone 2) (aref phone 3)))
-    (concat (if (/= 0 (bbdb-phone-area phone))
-                (format "(%03d) " (bbdb-phone-area phone))
-                "")
-            (if (/= 0 (bbdb-phone-exchange phone))
-                (format "%03d-%04d"
-                        (bbdb-phone-exchange phone) (bbdb-phone-suffix phone))
-                "")
-            (if (and (bbdb-phone-extension phone)
-                     (/= 0 (bbdb-phone-extension phone)))
-                (format " x%d" (bbdb-phone-extension phone))
-                ""))))
-
-(defsubst bbdb-record-lessp (record1 record2)
-  (string< (bbdb-record-sortkey record1)
-           (bbdb-record-sortkey record2)))
-
-(defmacro bbdb-error-retry (&rest body)
-  "Repeatedly execute BODY ignoring errors till no error occurs."
-  `(catch '--bbdb-error-retry--
-     (while t
-       (condition-case --c--
-           (throw '--bbdb-error-retry-- (progn ,@body))
-         (error (ding)
-                (message "Error: %s" (nth 1 --c--))
-                (sit-for 2))))))
-
-
-;;; Reading and Writing the BBDB
-
-(defun bbdb-buffer ()
-  "Return buffer that visits the BBDB file `bbdb-file'.
-Ensure that this buffer is in sync with `bbdb-file'.
-Revert the buffer if necessary.
-If `bbdb-file-remote' is non-nil and it is newer than `bbdb-file',
-copy it to `bbdb-file'."
-  (unless (buffer-live-p bbdb-buffer)
-    (if (and bbdb-file-remote
-             (file-newer-than-file-p bbdb-file-remote bbdb-file))
-        (copy-file bbdb-file-remote bbdb-file t t))
-
-    (with-current-buffer (setq bbdb-buffer (find-file-noselect bbdb-file))
-
-      ;; Check whether auto-save file is newer than `bbdb-file'
-      ;; Do this only when reading `bbdb-file'.
-      (let ((auto-save-file (make-auto-save-file-name)))
-        (when (and bbdb-check-auto-save-file
-                   (file-newer-than-file-p auto-save-file buffer-file-name))
-          (recover-file buffer-file-name) ; this queries
-          (bury-buffer) ; `recover-file' selects `bbdb-buffer'
-          (auto-save-mode 1) ; turn auto-save back on
-          ;; Delete auto-save file even if the user rejected to recover it,
-          ;; so we do not keep asking.
-          (condition-case nil
-              (delete-file auto-save-file)
-            (file-error nil))))))
-
-  ;; Make sure `bbdb-buffer' is not out of sync with disk.
-  (with-current-buffer bbdb-buffer
-    (cond ((verify-visited-file-modtime))
-          ((bbdb-revert-buffer))
-          ;; This is the case where `bbdb-file' has changed; the buffer
-          ;; has changed as well; and the user has answered "no" to the
-          ;; "flush your changes and revert" question.  The only other
-          ;; alternative is to save the file right now.  If they answer
-          ;; no to the following question, they will be asked the
-          ;; preceeding question again and again some large (but finite)
-          ;; number of times.  `bbdb-buffer' is called a lot, you see...
-          ((buffer-modified-p)
-           ;; this queries
-           (bbdb-save t t))
-          (t ; Buffer and file are inconsistent, but we let them stay that way
-           (message "Continuing with inconsistent BBDB buffers")))
-
-    ;; `bbdb-revert-buffer' kills all local variables.
-    (unless (assq 'bbdb-records (buffer-local-variables))
-      ;; We are reading / reverting `bbdb-buffer'.
-      (set (make-local-variable 'revert-buffer-function)
-           'bbdb-revert-buffer)
-
-      (setq buffer-file-coding-system bbdb-file-coding-system
-            buffer-read-only bbdb-read-only
-            bbdb-mail-aliases-need-rebuilt 'parse
-            bbdb-changed-records nil)
-
-      ;; `bbdb-before-save-hook' and `bbdb-after-save-hook' are user variables.
-      ;; To avoid confusion, we hide the hook functions `bbdb-before-save'
-      ;; and `bbdb-after-save' from the user as these are essential for BBDB.
-      (dolist (hook (cons 'bbdb-before-save bbdb-before-save-hook))
-        (add-hook 'before-save-hook hook nil t))
-      (dolist (hook (cons 'bbdb-after-save bbdb-after-save-hook))
-        (add-hook 'after-save-hook hook nil t))
-
-      (clrhash bbdb-hashtable)
-      (clrhash bbdb-uuid-table)
-
-      (if (/= (point-min) (point-max))
-          (bbdb-parse-records) ; normal case: nonempty db
-        ;; Empty db: the following does not require `insert-before-markers'
-        ;; because there are no db-markers in this buffer.
-        (insert (format (concat ";; -*- mode: Emacs-Lisp; coding: %s; -*-"
-                                "\n;;; file-format: %d\n")
-                        bbdb-file-coding-system bbdb-file-format))
-        ;; We pretend that `bbdb-buffer' is still unmodified,
-        ;; so that we will (auto-)save it only if we also add records to it.
-        (set-buffer-modified-p nil)
-        (setq bbdb-end-marker (point-marker)
-              ;; Setting `bbdb-records' makes it buffer-local,
-              ;; so that we can use it as a test whether we have
-              ;; initialized BBDB.
-              bbdb-records nil))
-
-      (run-hooks 'bbdb-after-read-db-hook)))
-
-  ;; return `bbdb-buffer'
-  bbdb-buffer)
-
-(defmacro bbdb-with-db-buffer (&rest body)
-  "Execute the forms in BODY with `bbdb-buffer' temporarily current.
-If `bbdb-debug' was non-nil at compile-time, and `bbdb-buffer' is visible
-in a window, temporarilly switch to that window.  So when we come out,
-that window has been scrolled to the record we have just modified."
-  (declare (indent 0))
-  (if bbdb-debug
-      `(let* ((buffer (bbdb-buffer))
-              (window (get-buffer-window buffer)))
-         (if window
-             (with-selected-window window
-               ,@body)
-           (with-current-buffer buffer
-             ,@body)))
-    `(with-current-buffer (bbdb-buffer)
-       ,@body)))
-
-(defun bbdb-editable ()
-  "Ensure that BBDB is editable, otherwise throw an error.
-If BBDB is out of sync try to revert.
-BBDB is not editable if it is read-only."
-  (if bbdb-read-only (error "BBDB is read-only"))
-  (let ((buffer (bbdb-buffer))) ; this reverts if necessary / possible
-    ;; Is the following possible?  Superfluous tests do not hurt.
-    ;; It is relevant only for editing commands in a BBDB buffer,
-    ;; but not for MUA-related editing functions.
-    (if (and (eq major-mode 'bbdb-mode)
-             bbdb-records
-             (not (memq (caar bbdb-records)
-                        (with-current-buffer buffer bbdb-records))))
-        (error "BBDB is out of sync")))
-  t)
-
-;;;###autoload
-(defsubst bbdb-records ()
-  "Return a list of all BBDB records; read in and parse the db if necessary.
-This function also notices if the corresponding file on disk has been modified."
-  (with-current-buffer (bbdb-buffer)
-    bbdb-records))
-
-(defun bbdb-revert-buffer (&optional ignore-auto noconfirm)
-  "The `revert-buffer-function' for `bbdb-buffer' visiting `bbdb-file'.
-IGNORE-AUTO and NOCONFIRM have same meaning as in `revert-buffer'.
-See also variable `bbdb-auto-revert'.
-Return t if the reversion was successful (or not needed).
-Return nil otherwise."
-  (interactive (list (not current-prefix-arg))) ; as in `revert-buffer'
-  (unless (buffer-live-p bbdb-buffer)
-    (error "No live BBDB buffer to revert"))
-  (with-current-buffer bbdb-buffer
-    (cond ((not buffer-file-number)
-           ;; We have not yet created `bbdb-file'
-           (when (or noconfirm
-                     (yes-or-no-p "Flush your changes? "))
-             (erase-buffer)
-             (kill-all-local-variables)  ; clear database
-             (bbdb-buffer)               ; re-initialize
-             (set-buffer-modified-p nil)
-             (bbdb-undisplay-records t)))
-          ;; If nothing has changed do nothing, return t.
-          ((and (verify-visited-file-modtime)
-                (not (buffer-modified-p))))
-          ((or (and (not (verify-visited-file-modtime bbdb-buffer))
-                    ;; File changed on disk
-                    (or noconfirm
-                        (and bbdb-auto-revert
-                             (not (buffer-modified-p)))
-                        (yes-or-no-p
-                         (if (buffer-modified-p)
-                             "BBDB changed on disk; flush your changes and revert? "
-                           "BBDB changed on disk; revert? "))))
-               (and (verify-visited-file-modtime bbdb-buffer)
-                    ;; File not changed on disk, but buffer modified
-                    (buffer-modified-p)
-                    (or noconfirm
-                        (yes-or-no-p "Flush your changes and revert BBDB? "))))
-           (unless (file-exists-p bbdb-file)
-             (error "BBDB: file %s no longer exists" bbdb-file))
-           (kill-all-local-variables)  ; clear database
-           ;; `revert-buffer-function' has the permanent-local property
-           ;; So to avoid looping, we need to bind it to nil explicitly.
-           (let (revert-buffer-function)
-             (revert-buffer ignore-auto t))
-           (bbdb-buffer)                      ; re-initialize
-           (bbdb-undisplay-records t)
-           t)))) ; return nil if the user rejected to revert
-
-(defun bbdb-goto-first-record ()
-  "Go to where first record begins,  Move to end of file if no records."
-  (goto-char (point-min))
-  (if (search-forward "\n[" nil 'move)
-      (forward-char -1)))
-
-(defun bbdb-parse-records ()
-  "Parse BBDB records and initialize various internal variables.
-If `bbdb-file' uses an outdated format, migrate to `bbdb-file-format'."
-  (save-excursion
-    (save-restriction
-      (widen)
-      (bbdb-goto-first-record)
-      (let* ((file (abbreviate-file-name buffer-file-name))
-             (file-format (save-excursion
-                            (if (re-search-backward
-                                 "^;+[ \t]*file-\\(format\\|version\\):[ \t]*\\([0-9]+\\)[ \t]*$" nil t)
-                                (string-to-number (match-string 2))
-                              ;; No file-format line.
-                              (error "BBDB corrupted: no file-format line"))))
-             (migrate (< file-format bbdb-file-format))
-             records)
-        (if (> file-format bbdb-file-format)
-            (error "%s understands file format %s but not %s."
-                   (bbdb-version) bbdb-file-format file-format))
-
-        (if (and migrate
-                 (not (yes-or-no-p
-                       (format (concat "Migrate `%s' to BBDB file format %s "
-                                       "(back-up recommended)? ")
-                               file bbdb-file-format))))
-            (progn
-              (message "Abort loading %s" file)
-              (sleep-for 2)
-              (setq bbdb-records nil
-                    ;; Avoid unexpected surprises
-                    buffer-read-only t)
-              'abort)
-
-          (or (eobp) (looking-at "\\[")
-              (error "BBDB corrupted: no following bracket"))
-
-          (unless bbdb-silent (message "Parsing BBDB file `%s'..." file))
-
-          ;; narrow the buffer to skip over the rubbish before the first record.
-          (narrow-to-region (point) (point-max))
-          (let ((modp (buffer-modified-p))
-                ;; Make sure those parens get cleaned up.
-                ;; This code had better stay simple!
-                (inhibit-quit t)
-                (buffer-undo-list t)
-                buffer-read-only)
-            (goto-char (point-min)) (insert "(\n")
-            (goto-char (point-max)) (insert "\n)")
-            (goto-char (point-min))
-            (unwind-protect
-                (setq records (read (current-buffer)))
-              (goto-char (point-min)) (delete-char 2)
-              (goto-char (point-max)) (delete-char -2)
-              (set-buffer-modified-p modp)))
-          (widen)
-
-          ;; Migrate if `bbdb-file' is outdated.
-          (if migrate (setq records (bbdb-migrate records file-format)))
-
-          ;; We could first set `bbdb-phone-label-list' and
-          ;; `bbdb-address-label-list' to their customized values.  Bother?
-          (setq bbdb-records records
-                bbdb-xfield-label-list nil
-                bbdb-organization-list nil
-                bbdb-street-list nil
-                bbdb-city-list nil
-                bbdb-state-list nil
-                bbdb-postcode-list nil
-                bbdb-country-list nil)
-
-          (bbdb-goto-first-record)
-          (dolist (record records)
-            ;; We assume that the markers for each record need to go at each
-            ;; newline.  If this is not the case, things can go *very* wrong.
-            (bbdb-debug
-              (unless (looking-at "\\[")
-                (error "BBDB corrupted: junk between records at %s" (point))))
-
-            (bbdb-cache-set-marker
-             (bbdb-record-set-cache record (make-vector bbdb-cache-length nil))
-             (point-marker))
-            (forward-line 1)
-
-            ;; Every record must have a unique uuid in `bbdb-uuid-table'.
-            (if (gethash (bbdb-record-uuid record) bbdb-uuid-table)
-                ;; Is there a more useful action than throwing an error?
-                ;; We are just loading BBDB, so we are not yet ready
-                ;; for sophisticated solutions.
-                (error "Duplicate UUID %s" (bbdb-record-uuid record)))
-
-            ;; Set the completion lists
-            (dolist (phone (bbdb-record-phone record))
-              (bbdb-pushnew (bbdb-phone-label phone) bbdb-phone-label-list))
-            (dolist (address (bbdb-record-address record))
-              (bbdb-pushnew (bbdb-address-label address) bbdb-address-label-list)
-              (mapc (lambda (street) (bbdb-pushnewt street bbdb-street-list))
-                    (bbdb-address-streets address))
-              (bbdb-pushnewt (bbdb-address-city address) bbdb-city-list)
-              (bbdb-pushnewt (bbdb-address-state address) bbdb-state-list)
-              (bbdb-pushnewt (bbdb-address-postcode address) bbdb-postcode-list)
-              (bbdb-pushnewt (bbdb-address-country address) bbdb-country-list))
-            (dolist (xfield (bbdb-record-xfields record))
-              (bbdb-pushnewq (car xfield) bbdb-xfield-label-list))
-            (dolist (organization (bbdb-record-organization record))
-              (bbdb-pushnew organization bbdb-organization-list))
-
-            (let ((name (bbdb-concat 'name-first-last
-                                     (bbdb-record-firstname record)
-                                     (bbdb-record-lastname record))))
-              (when (and (not bbdb-allow-duplicates)
-                         (bbdb-gethash name '(fl-name aka)))
-                ;; This does not check for duplicate mail fields.
-                ;; Yet under normal circumstances, this should really
-                ;; not be necessary each time BBDB is loaded as BBDB checks
-                ;; whether creating a new record or modifying an existing one
-                ;; results in duplicates.
-                ;; Alternatively, you can use `bbdb-search-duplicates'.
-                (message "Duplicate BBDB record encountered: %s" name)
-                (sit-for 1)))
-
-            ;; If `bbdb-allow-duplicates' is non-nil, we allow that two records
-            ;; (with different uuids) refer to the same person (same name etc.).
-            ;; Such duplicate records are always hashed.
-            ;; Otherwise, an unhashed record would not be available for things
-            ;; like completion (and we would not know which record to keeep
-            ;; and which one to hide).  We trust the user she knows what
-            ;; she wants if she keeps duplicate records in the database though
-            ;; `bbdb-allow-duplicates' is nil.
-            (bbdb-hash-record record))
-
-          ;; Note that `bbdb-xfield-label-list' serves two purposes:
-          ;;  - check whether an xfield is new to BBDB
-          ;;  - list of known xfields for minibuffer completion
-          ;; Only in the latter case, we might want to exclude
-          ;; those xfields that are handled automatically.
-          ;; So the following is not a satisfactory solution.
-
-          ;; (dolist (label (bbdb-layout-get-option 'multi-line 'omit))
-          ;;   (setq bbdb-xfield-label-list (delq label bbdb-xfield-label-list)))
-
-          ;; `bbdb-end-marker' allows to put comments at the end of `bbdb-file'
-          ;; that are ignored.
-          (setq bbdb-end-marker (point-marker))
-
-          (when migrate
-            (dolist (record bbdb-records)
-              (bbdb-overwrite-record-internal record))
-            ;; update file format
-            (goto-char (point-min))
-            (if (re-search-forward (format "^;;; file-\\(version\\|format\\): %d$"
-                                           file-format)
-                                   nil t)
-                (replace-match (format ";;; file-format: %d" bbdb-file-format))))
-
-          (unless bbdb-silent (message "Parsing BBDB file `%s'...done" file))
-          bbdb-records)))))
-
-(defun bbdb-before-save ()
-  "Run before saving `bbdb-file' as buffer-local part of `before-save-hook'."
-  (when (and bbdb-file-remote
-             (or bbdb-file-remote-save-always
-                 (y-or-n-p (format "Save the remote BBDB file %s too? "
-                                   bbdb-file-remote))))
-    ;; Write the current buffer `bbdb-file' into `bbdb-file-remote'.
-    (let ((coding-system-for-write bbdb-file-coding-system))
-      (write-region (point-min) (point-max) bbdb-file-remote))))
-
-(defun bbdb-after-save ()
-  "Run after saving `bbdb-file' as buffer-local part of `after-save-hook'."
-  (setq bbdb-changed-records nil)
-  (dolist (buffer (buffer-list))
-    (with-current-buffer buffer
-      (if (eq major-mode 'bbdb-mode)
-          (set-buffer-modified-p nil)))))
-
-(defun bbdb-change-record (record &rest ignored)
-  "Update the database after a change of RECORD.
-Return RECORD if RECORD got changed compared with the database,
-return nil otherwise.
-Hash RECORD if it is new.  If RECORD is not new, it is the the caller's
-responsibility to update the hashtables for RECORD.  (Up-to-date hashtables are
-ensured if the fields are modified by calling `bbdb-record-set-field'.)
-Redisplay RECORD if it is not new.
-
-Args IGNORED are ignored and their use is discouraged.
-They are present only for backward compatibility."
-  (when (and ignored (get 'bbdb-change-record 'bbdb-outdated))
-    (put 'bbdb-change-record 'bbdb-outdated t)
-    (message "Outdated usage of `bbdb-change-record'")
-    (sit-for 2))
-
-  (if bbdb-read-only
-      (error "The Insidious Big Brother Database is read-only."))
-  ;; The call of `bbdb-records' checks file synchronization.
-  ;; If RECORD refers to an existing record that has been changed,
-  ;; yet in the meanwhile we reverted the BBDB file, then RECORD
-  ;; no longer refers to a record in `bbdb-records'.  RECORD will then
-  ;; be treated as new, when we try to merge it with the known record.
-  (let ((tail (memq record (bbdb-records))))
-    (if tail ; RECORD is not new
-        ;; If the string we currently have for RECORD in `bbdb-buffer'
-        ;; is `equal' to the string we would write to `bbdb-buffer',
-        ;; we really did not change RECORD at all.  So we don't update RECORD
-        ;; unless `bbdb-update-unchanged-records' tells us to do so anyway.
-        ;; Also, we only call `bbdb-change-hook' and `bbdb-after-change-hook'
-        ;; if RECORD got changed.
-        (when (or bbdb-update-unchanged-records
-                  (not (string= (bbdb-with-db-buffer
-                                  (buffer-substring-no-properties
-                                   (bbdb-record-marker record)
-                                   (1- (if (cdr tail)
-                                           (bbdb-record-marker (cadr tail))
-                                         bbdb-end-marker))))
-                                (let ((cache (bbdb-record-cache record))
-                                      (inhibit-quit t))
-                                  (bbdb-record-set-cache record nil)
-                                  (prog1 (bbdb-with-print-loadably
-                                           (prin1-to-string record))
-                                    (bbdb-record-set-cache record cache))))))
-          (bbdb-record-set-timestamp
-           record (format-time-string bbdb-time-stamp-format nil t))
-          (run-hook-with-args 'bbdb-change-hook record)
-          (let ((sort (not (equal (bbdb-cache-sortkey (bbdb-record-cache record))
-                                  (bbdb-record-set-sortkey record)))))
-            (if (not sort) ;; If we do not need to sort, overwrite RECORD.
-                (bbdb-overwrite-record-internal record)
-              ;; Since we need to sort, delete then insert RECORD.
-              ;; Do not mess with the hash tables here.
-              ;; We assume they got updated by the caller.
-              (bbdb-delete-record-internal record)
-              (bbdb-insert-record-internal record))
-            (bbdb-pushnewq record bbdb-changed-records)
-            (run-hook-with-args 'bbdb-after-change-hook record)
-            (bbdb-redisplay-record-globally record sort))
-          record)
-
-      ;; Record is new and not yet in BBDB.
-      (unless (bbdb-record-cache record)
-        (bbdb-record-set-cache record (make-vector bbdb-cache-length nil)))
-      (unless (bbdb-record-uuid record)
-        (bbdb-record-set-uuid record (bbdb-uuid)))
-      (unless (bbdb-record-creation-date record)
-        (bbdb-record-set-creation-date
-         record (format-time-string bbdb-time-stamp-format nil t))
-        (run-hook-with-args 'bbdb-create-hook record))
-
-      (let ((old-record (gethash (bbdb-record-uuid record) bbdb-uuid-table)))
-        (if old-record
-            ;; RECORD is really OLD-RECORD.  Merge and return OLD-RECORD.
-            (if bbdb-merge-records-function
-                (funcall bbdb-merge-records-function record old-record)
-              (bbdb-merge-records record old-record))
-
-          ;; RECORD is really new.
-          (bbdb-record-set-timestamp
-           record (format-time-string bbdb-time-stamp-format nil t))
-          (run-hook-with-args 'bbdb-change-hook record)
-          (bbdb-insert-record-internal record)
-          (bbdb-hash-record record)
-          (bbdb-pushnewq record bbdb-changed-records)
-          (run-hook-with-args 'bbdb-after-change-hook record)
-          record)))))
-
-(defun bbdb-delete-record-internal (record &optional completely)
-  "Delete RECORD in the database file.
-With COMPLETELY non-nil, also undisplay RECORD and remove it
-from the hash table."
-  (unless (bbdb-record-marker record) (error "BBDB: marker absent"))
-  (if completely (bbdb-redisplay-record-globally record nil t))
-  (bbdb-with-db-buffer
-    (barf-if-buffer-read-only)
-    (let ((tail (memq record bbdb-records))
-          (inhibit-quit t))
-      (unless tail (error "BBDB record absent: %s" record))
-      (delete-region (bbdb-record-marker record)
-                     (if (cdr tail)
-                         (bbdb-record-marker (car (cdr tail)))
-                       bbdb-end-marker))
-      (setq bbdb-records (delq record bbdb-records))
-      (when completely
-        (bbdb-remhash (bbdb-record-name record) record)
-        (bbdb-remhash (bbdb-record-name-lf record) record)
-        (dolist (organization (bbdb-record-organization record))
-          (bbdb-remhash organization record))
-        (dolist (mail (bbdb-record-mail-canon record))
-          (bbdb-remhash mail record))
-        (dolist (aka (bbdb-record-field record 'aka-all))
-          (bbdb-remhash aka record))))))
-
-(defun bbdb-insert-record-internal (record)
-  "Insert RECORD into the database file.  Return RECORD.
-Do not call this function directly, call instead `bbdb-change-record'
-that calls the hooks, too."
-  (unless (bbdb-record-marker record)
-    (bbdb-record-set-marker record (make-marker)))
-  (bbdb-with-db-buffer
-    (barf-if-buffer-read-only)
-    ;; splice record into `bbdb-records'
-    (bbdb-debug (if (memq record bbdb-records)
-                    (error "BBDB record not unique: - %s" record)))
-    (if (or (not bbdb-records) ; first record in new database
-            (bbdb-record-lessp record (car bbdb-records)))
-        (push record bbdb-records)
-      (let ((records bbdb-records))
-        (while (and (cdr records)
-                    (bbdb-record-lessp (nth 1 records) record))
-          (setq records (cdr records)))
-        (setcdr records (cons record (cdr records)))))
-
-    (let ((next (car (cdr (memq record bbdb-records)))))
-      (goto-char (if next
-                     (bbdb-record-marker next)
-                   bbdb-end-marker)))
-    ;; Before writing the record, remove the cache (we do not want that
-    ;; written to the file.)  After writing, put the cache back and update
-    ;; the cache's marker.
-    (let ((cache (bbdb-record-cache record))
-          (point (point))
-          (inhibit-quit t))
-      (bbdb-debug
-        (if (= point (point-min))
-            (error "Inserting at point-min (%s)" point))
-        (if (and (/= point bbdb-end-marker)
-                 (not (looking-at "^\\[")))
-            (error "Not inserting before a record (%s)" point)))
-      (bbdb-record-set-cache record nil)
-      (insert-before-markers
-       (bbdb-with-print-loadably (prin1-to-string record)) "\n")
-      (set-marker (bbdb-cache-marker cache) point)
-      (bbdb-record-set-cache record cache))
-    record))
-
-(defun bbdb-overwrite-record-internal (record)
-  "Overwrite RECORD in the database file.  Return RECORD.
-Do not call this function directly, call instead `bbdb-change-record'
-that calls the hooks, too."
-  (bbdb-with-db-buffer
-    (barf-if-buffer-read-only)
-    (let* ((tail (memq record bbdb-records))
-           (_ (unless tail (error "BBDB record absent: %s" record)))
-           (cache (bbdb-record-cache record))
-           (inhibit-quit t))
-      (bbdb-debug
-        (if (<= (bbdb-cache-marker cache) (point-min))
-            (error "Cache marker is %s" (bbdb-cache-marker cache))))
-      (goto-char (bbdb-cache-marker cache))
-      (bbdb-debug
-        (if (and (/= (point) bbdb-end-marker)
-                 (not (looking-at "\\[")))
-            (error "Not inserting before a record (%s)" (point))))
-
-      (bbdb-record-set-cache record nil)
-      (insert (bbdb-with-print-loadably (prin1-to-string record)) "\n")
-      (delete-region (point)
-                     (if (cdr tail)
-                         (bbdb-record-marker (car (cdr tail)))
-                       bbdb-end-marker))
-      (bbdb-record-set-cache record cache)
-
-      (bbdb-debug
-        (if (<= (if (cdr tail)
-                    (bbdb-record-marker (car (cdr tail)))
-                  bbdb-end-marker)
-                (bbdb-record-marker record))
-            (error "Overwrite failed")))
-
-      record)))
-
-;; Record formatting:
-;; This does not insert anything into the *BBDB* buffer,
-;; which is handled in a second step by the display functions.
-
-(defun bbdb-layout-get-option (layout option)
-  "For LAYOUT return value of OPTION according to `bbdb-layout-alist'."
-  (let ((layout-spec (if (listp layout)
-                         layout
-                       (assq layout bbdb-layout-alist)))
-        option-value)
-    (and layout-spec
-         (setq option-value (assq option layout-spec))
-         (cdr option-value))))
-
-(defun bbdb-address-continental-p (address)
-  "Return non-nil if ADDRESS is a continental address.
-This is done by comparing the postcode to `bbdb-continental-postcode-regexp'.
-
-This is a possible identifying function for
-`bbdb-address-format-list' and `bbdb-tex-address-format-list'."
-  (string-match bbdb-continental-postcode-regexp
-                (bbdb-address-postcode address)))
-
-;; This function can provide some guidance for writing
-;; your own address formatting function
-(defun bbdb-format-address-default (address)
-  "Return formatted ADDRESS as a string.
-This is the default format; it is used in the US, for example.
-The result looks like this:
-       label: street
-              street
-              ...
-              city, state postcode
-              country.
-
-This function is a possible formatting function for
-`bbdb-address-format-list'."
-  (let ((country (bbdb-address-country address))
-        (streets (bbdb-address-streets address)))
-    (concat (if streets
-                (concat (mapconcat 'identity streets "\n") "\n"))
-            (bbdb-concat ", " (bbdb-address-city address)
-                         (bbdb-concat " " (bbdb-address-state address)
-                                      (bbdb-address-postcode address)))
-            (unless (or (not country) (string= "" country))
-              (concat "\n" country)))))
-
-(defun bbdb-format-address (address layout)
-  "Format ADDRESS using LAYOUT.  Return result as a string.
-The formatting rules are defined in `bbdb-address-format-list'."
-  (let ((list bbdb-address-format-list)
-        (country (bbdb-address-country address))
-        elt string)
-    (while (and (not string) (setq elt (pop list)))
-      (let ((identifier (car elt))
-            (format (nth layout elt))
-            ;; recognize case for format identifiers
-            case-fold-search str)
-        (when (or (eq t identifier) ; default
-                  (and (functionp identifier)
-                       (funcall identifier address))
-                  (and country
-                       (listp identifier)
-                       ;; ignore case for countries
-                       (member-ignore-case country identifier)))
-          (cond ((functionp format)
-                 (setq string (funcall format address)))
-                ((stringp format)
-                 (setq string "")
-                 (dolist (form (split-string (substring format 1 -1)
-                                             (substring format 0 1) t))
-                   (cond ((string-match "%s" form) ; street
-                          (mapc (lambda (s) (setq string (concat string (format form s))))
-                                (bbdb-address-streets address)))
-                         ((string-match "%c" form) ; city
-                          (unless (or (not (setq str (bbdb-address-city address))) (string= "" str))
-                            (setq string (concat string (format (replace-regexp-in-string "%c" "%s" form) str)))))
-                         ((string-match "%p" form) ; postcode
-                          (unless (or (not (setq str (bbdb-address-postcode address))) (string= "" str))
-                            (setq string (concat string (format (replace-regexp-in-string "%p" "%s" form) str)))))
-                         ((string-match "%S" form) ; state
-                          (unless (or (not (setq str (bbdb-address-state address))) (string= "" str))
-                            (setq string (concat string (format (replace-regexp-in-string "%S" "%s" form t) str)))))
-                         ((string-match "%C" form) ; country
-                          (unless (or (not country) (string= ""  country))
-                            (setq string (concat string (format (replace-regexp-in-string "%C" "%s" form t) country)))))
-                         (t (error "Malformed address format element %s" form)))))
-                (t (error "Malformed address format %s" format))))))
-    (unless string
-      (error "No match of `bbdb-address-format-list'"))
-    string))
-
-;;; Record display:
-;; This inserts formatted (pieces of) records into the BBDB buffer.
-
-(defsubst bbdb-field-property (start field)
-  "Set text property bbdb-field of text between START and point to FIELD."
-  (put-text-property start (point) 'bbdb-field field))
-
-(defsubst bbdb-display-text (text field &optional face)
-  "Insert TEXT at point.  Set its text property bbdb-field to FIELD.
-If FACE is non-nil, also add face FACE."
-  (let ((start (point)))
-    (insert text)
-    (bbdb-field-property start field)
-    (if face (put-text-property start (point) 'face face))))
-
-(defun bbdb-display-list (list field &optional terminator face indent)
-  "Insert elements of LIST at point.
-For inserted text, set text property bbdb-field to FIELD.
-If TERMINATOR is non-nil use it to terminate the inserted text.
-If FACE is non-nil use it as FACE for inserted text.
-If INDENT and `bbdb-wrap-column' are integers, insert line breaks in between
-elements of LIST if otherwise inserted text exceeds `bbdb-wrap-column'."
-  ;; `truncate-lines' is fine for one-line layout.  But it is annyoing
-  ;; for records that are displayed with multi-line layout.
-  ;; Non-nil `word-wrap' would be much nicer.  How can we switch between
-  ;; non-nil `truncate-lines' and non-nil `word-wrap' on a per-record basis?
-  ;; The following code is an alternative solution using `bbdb-wrap-column'.
-  (let* ((separator (nth 1 (or (cdr (assq field bbdb-separator-alist))
-                               bbdb-default-separator)))
-         (indent-flag (and (integerp bbdb-wrap-column)
-                           (integerp indent)))
-         (prefix (if indent-flag
-                     (concat separator "\n" (make-string indent ?\s))))
-        elt)
-    (while (setq elt (pop list))
-      (bbdb-display-text elt (list field elt) face)
-      (cond ((and list indent-flag
-                  (> (+ (current-column) (length (car list)))
-                     bbdb-wrap-column))
-             (bbdb-display-text prefix (list field) face))
-            (list
-             (bbdb-display-text separator (list field) face))
-            (terminator
-             (bbdb-display-text terminator (list field) face))))))
-
-(defun bbdb-display-name-organization (record)
-  "Insert name, affix, and organization of RECORD.
-If RECORD has an xfield name-face, its value is used for font-locking name.
-The value of name-face may be a face that is used directly.
-The value may also be a key in `bbdb-name-face-alist'.  Then the
-corresponding cdr is used.  If none of these schemes succeeds the face
-`bbdb-face' is used."
-  ;; Should this be further customizable?  We could build the following
-  ;; from a customizable list containing function calls and strings.
-  ;; Name
-  (let ((name (if (eq 'last-first
-                      (or (bbdb-record-xfield-intern record 'name-format)
-                          bbdb-name-format))
-                  (bbdb-record-name-lf record)
-                ;; default: Firstname Lastname
-                (bbdb-record-name record)))
-        (name-face (bbdb-record-xfield record 'name-face)))
-    (if (string= "" name) (setq name "???"))
-    (bbdb-display-text name (list 'name name)
-                       (if name-face
-                           (cond ((facep name-face) name-face)
-                                 ((cdr (assoc name-face bbdb-name-face-alist)))
-                                 (t 'bbdb-name))
-                         'bbdb-name)))
-  ;; Affix
-  (let ((affix (bbdb-record-affix record)))
-    (when affix
-      (insert ", ")
-      (bbdb-display-list affix 'affix)))
-  ;; Organization
-  (let ((organization (bbdb-record-organization record)))
-    (when organization
-      (insert " - ")
-      (bbdb-display-list organization 'organization nil
-                         'bbdb-organization)))
-  ;; Image
-  (if (and bbdb-image (display-images-p))
-      (let ((image (cond ((functionp bbdb-image)
-                          (funcall bbdb-image record))
-                         ((memq bbdb-image '(name fl-name))
-                          (bbdb-record-name record))
-                         ((eq bbdb-image 'lf-name)
-                          (bbdb-record-name-lf record))
-                         (t
-                          (bbdb-record-xfield record bbdb-image)))))
-        (when (and image
-                   (setq image (locate-file image bbdb-image-path
-                                            bbdb-image-suffixes))
-                   (setq image (create-image image)))
-          (insert " ")
-          (insert-image image)))))
-
-(defun bbdb-display-record-one-line (record layout field-list)
-  "Format RECORD for the one-line FORMAT using LAYOUT.
-See `bbdb-layout-alist' for more info on layouts.
-FIELD-LIST is the list of actually displayed FIELDS."
-  ;; Name, affix, and organizations
-  (bbdb-display-name-organization record)
-  (let ((name-end (or (bbdb-layout-get-option layout 'name-end)
-                      40))
-        (start (line-beginning-position)))
-    (when (> (- (point) start -1) name-end)
-      (put-text-property (+ start name-end -4) (point) 'invisible t)
-      (insert "..."))
-    (indent-to name-end))
-  ;; rest of the fields
-  (let (formatfun start)
-    (dolist (field field-list)
-      (cond (;; customized formatting
-             (setq formatfun (intern-soft (format "bbdb-display-%s-one-line" field)))
-             (funcall formatfun record))
-            ;; phone
-            ((eq field 'phone)
-             (let ((phones (bbdb-record-phone record)) phone)
-               (if phones
-                   (while (setq phone (pop phones))
-                     (bbdb-display-text (format "%s " (aref phone 0))
-                                        `(phone ,phone field-label)
-                                        'bbdb-field-name)
-                     (bbdb-display-text (format "%s%s" (aref phone 1)
-                                                (if phones " " "; "))
-                                        `(phone ,phone))))))
-            ;; address
-            ((eq field 'address)
-             (dolist (address (bbdb-record-address record))
-               (setq start (point))
-               (insert (bbdb-format-address address 3))
-               (bbdb-field-property start `(address ,address))
-               (insert "; ")))
-            ;; mail
-            ((eq field 'mail)
-             (let ((mail (bbdb-record-mail record)))
-               (if mail
-                   (bbdb-display-list (if (bbdb-layout-get-option layout 'primary)
-                                          (list (car mail)) mail)
-                                      'mail "; "))))
-            ;; AKA
-            ((eq field 'aka)
-             (let ((aka (bbdb-record-aka record)))
-               (if aka
-                   (bbdb-display-list aka 'aka "; "))))
-            ;; uuid
-            ((eq field 'uuid)
-             (let ((uuid (bbdb-record-uuid record)))
-               (bbdb-display-text (format "%s; " uuid) `(uuid ,uuid))))
-            ;; creation-date
-            ((eq field 'creation-date)
-             (let ((creation-date (bbdb-record-creation-date record)))
-               (bbdb-display-text (format "%s; " creation-date) `(creation-date ,creation-date))))
-            ;; timestamp
-            ((eq field 'timestamp)
-             (let ((timestamp (bbdb-record-timestamp record)))
-               (bbdb-display-text (format "%s; " timestamp) `(timestamp ,timestamp))))
-            ;; xfields
-            (t
-             (let* ((xfield (assq field (bbdb-record-xfields record)))
-                    (value (cdr xfield)))
-               (if value
-                   (bbdb-display-text
-                    (concat (if (stringp value)
-                                (replace-regexp-in-string
-                                 "\n" "; " value)
-                              ;; value of xfield is a sexp
-                              (let ((print-escape-newlines t))
-                                (prin1-to-string value)))
-                            "; ")
-                    `(xfields ,xfield)))))))
-    ;; delete the trailing "; "
-    (if (looking-back "; " nil)
-        (backward-delete-char 2))
-    (insert "\n")))
-
-(defun bbdb-display-record-multi-line (record layout field-list)
-  "Format RECORD for the multi-line FORMAT using LAYOUT.
-See `bbdb-layout-alist' for more info on layouts.
-FIELD-LIST is the list of actually displayed FIELDS."
-  (bbdb-display-name-organization record)
-  (insert "\n")
-  (let* ((indent (or (bbdb-layout-get-option layout 'indentation) 21))
-         ;; The format string FMT adds three extra characters.
-         ;; So we subtract those from the value of INDENT.
-         (fmt (format " %%%ds: " (- indent 3)))
-         start formatfun)
-    (dolist (field field-list)
-      (setq start (point))
-      (cond (;; customized formatting
-             (setq formatfun (intern-soft (format "bbdb-display-%s-multi-line" field)))
-             (funcall formatfun record indent))
-            ;; phone
-            ((eq field 'phone)
-             (dolist (phone (bbdb-record-phone record))
-               (bbdb-display-text (format fmt (concat "phone ("
-                                                      (bbdb-phone-label phone)
-                                                      ")"))
-                                  `(phone ,phone field-label)
-                                  'bbdb-field-name)
-               (bbdb-display-text (concat (bbdb-phone-string phone) "\n")
-                                  `(phone ,phone))))
-            ;; address
-            ((eq field 'address)
-             (dolist (address (bbdb-record-address record))
-               (bbdb-display-text (format fmt (concat "address ("
-                                                      (bbdb-address-label address)
-                                                      ")"))
-                                  `(address ,address field-label)
-                                  'bbdb-field-name)
-               (setq start (point))
-               (insert (bbdb-indent-string (bbdb-format-address address 2) indent)
-                       "\n")
-               (bbdb-field-property start `(address ,address))))
-            ;; mail
-            ((eq field 'mail)
-             (let ((mail (bbdb-record-mail record)))
-               (when mail
-                 (bbdb-display-text (format fmt "mail") '(mail nil field-label)
-                                    'bbdb-field-name)
-                 (bbdb-display-list (if (bbdb-layout-get-option layout 'primary)
-                                        (list (car mail)) mail)
-                                    'mail "\n" nil indent))))
-            ;; AKA
-            ((eq field 'aka)
-             (let ((aka (bbdb-record-aka record)))
-               (when aka
-                 (bbdb-display-text (format fmt "AKA") '(aka nil field-label)
-                                    'bbdb-field-name)
-                 (bbdb-display-list aka 'aka "\n"))))
-            ;; uuid
-            ((eq field 'uuid)
-             (let ((uuid (bbdb-record-uuid record)))
-               (bbdb-display-text (format fmt "uuid") `(uuid ,uuid field-label)
-                                  'bbdb-field-name)
-               (bbdb-display-text (format "%s\n" uuid) `(uuid ,uuid))))
-            ;; creation-date
-            ((eq field 'creation-date)
-             (let ((creation-date (bbdb-record-creation-date record)))
-               (bbdb-display-text (format fmt "creation-date") `(creation-date ,creation-date field-label)
-                                  'bbdb-field-name)
-               (bbdb-display-text (format "%s\n" creation-date) `(creation-date ,creation-date))))
-            ;; timestamp
-            ((eq field 'timestamp)
-             (let ((timestamp (bbdb-record-timestamp record)))
-               (bbdb-display-text (format fmt "timestamp") `(timestamp ,timestamp field-label)
-                                  'bbdb-field-name)
-               (bbdb-display-text (format "%s\n" timestamp) `(timestamp ,timestamp))))
-            ;; xfields
-            (t
-             (let* ((xfield (assq field (bbdb-record-xfields record)))
-                    (value (cdr xfield)))
-               (when value
-                 (bbdb-display-text (format fmt field)
-                                    `(xfields ,xfield field-label)
-                                    'bbdb-field-name)
-                 (setq start (point))
-                 (insert (bbdb-indent-string
-                          (if (stringp value)
-                              value
-                            ;; value of xfield is a sexp
-                            (let ((string (pp-to-string value)))
-                              (if (string-match "[ \t\n]+\\'" string)
-                                  (substring-no-properties
-                                   string 0 (match-beginning 0))
-                                string)))
-                          indent) "\n")
-                 (bbdb-field-property start `(xfields ,xfield)))))))
-    (insert "\n")))
-
-(defalias 'bbdb-display-record-full-multi-line
-  'bbdb-display-record-multi-line)
-
-(defalias 'bbdb-display-record-pop-up-multi-line
-  'bbdb-display-record-multi-line)
-
-(defun bbdb-display-record (record layout number)
-  "Insert a formatted RECORD into the current buffer at point.
-LAYOUT can be a symbol describing a layout in `bbdb-layout-alist'.
-If it is nil, use `bbdb-layout'.
-NUMBER is the number of RECORD among the displayed records.
-Move point to the end of the inserted record."
-  (unless layout (setq layout bbdb-layout))
-  (unless (assq layout bbdb-layout-alist)
-    (error "Unknown layout `%s'" layout))
-  (let ((display-p  (bbdb-layout-get-option layout 'display-p))
-        (omit-list  (bbdb-layout-get-option layout 'omit)) ; omitted fields
-        (order-list (bbdb-layout-get-option layout 'order)); requested field order
-        (all-fields (append '(phone address mail aka) ; default field order
-                            (mapcar 'car (bbdb-record-xfields record))
-                            '(uuid creation-date timestamp)))
-        (beg (point))
-        format-function field-list)
-    (when (or (not display-p)
-              (and display-p
-                   (funcall display-p)))
-      (if (functionp omit-list)
-          (setq omit-list (funcall omit-list record layout)))
-      (if (functionp order-list)
-          (setq order-list (funcall order-list record layout)))
-      ;; first omit unwanted fields
-      (when (and omit-list (or (not order-list) (memq t order-list)))
-        (if (listp omit-list)
-            ;; show all fields except those listed here
-            (dolist (omit omit-list)
-              (setq all-fields (delq omit all-fields)))
-          (setq all-fields nil))) ; show nothing
-      ;; then order them
-      (cond ((not order-list)
-             (setq field-list all-fields))
-            ((not (memq t order-list))
-             (setq field-list order-list))
-            (t
-             (setq order-list (reverse order-list)
-                   all-fields (delq nil (mapcar (lambda (f)
-                                                  (unless (memq f order-list)
-                                                    f))
-                                                all-fields)))
-             (dolist (order order-list)
-               (if (eq t order)
-                   (setq field-list (append all-fields field-list))
-                 (push order field-list)))))
-      ;; call the actual format function
-      (setq format-function
-            (intern-soft (format "bbdb-display-record-%s" layout)))
-      (if (functionp format-function)
-          (funcall format-function record layout field-list)
-        (bbdb-display-record-multi-line record layout field-list))
-      (put-text-property beg (point) 'bbdb-record-number number))))
-
-(defun bbdb-display-records (records &optional layout append
-                                     select horiz-p)
-  "Display RECORDS using LAYOUT.
-If APPEND is non-nil append RECORDS to the already displayed records.
-Otherwise RECORDS overwrite the displayed records.
-SELECT and HORIZ-P have the same meaning as in `bbdb-pop-up-window'."
-  (interactive (list (bbdb-completing-read-records "Display records: ")
-                     (bbdb-layout-prefix)))
-  (if (bbdb-append-display-p) (setq append t))
-  ;; `bbdb-redisplay-record' calls `bbdb-display-records'
-  ;; with display information already amended to RECORDS.
-  (unless (or (null records)
-              (consp (car records)))
-    ;; add layout and a marker to the local list of records
-    (setq layout (or layout bbdb-layout)
-          records (mapcar (lambda (record)
-                            (list record layout (make-marker)))
-                          records)))
-
-  (let ((first-new (caar records)) ; first new record
-        new-name)
-
-    ;; If `bbdb-multiple-buffers' is non-nil we create a new BBDB buffer
-    ;; when not already within one.  The new buffer name starts with a space,
-    ;; i.e. it does not clutter the buffer list.
-    (when (and bbdb-multiple-buffers
-               (not (assq 'bbdb-buffer-name (buffer-local-variables))))
-      (setq new-name (concat " *BBDB " (if (functionp bbdb-multiple-buffers)
-                                           (funcall bbdb-multiple-buffers)
-                                         (buffer-name))
-                              "*"))
-      ;; `bbdb-buffer-name' becomes buffer-local in the current buffer
-      ;; as well as in the buffer `bbdb-buffer-name'
-      (set (make-local-variable 'bbdb-buffer-name) new-name))
-
-    (with-current-buffer (get-buffer-create bbdb-buffer-name) ; *BBDB*
-      ;; If we are appending RECORDS to the ones already displayed,
-      ;; then first remove any duplicates, and then sort them.
-      (if append
-          (let ((old-rec (mapcar 'car bbdb-records)))
-            (dolist (record records)
-              (unless (memq (car record) old-rec)
-                (push record bbdb-records)))
-            (setq records
-                  (sort bbdb-records
-                        (lambda (x y) (bbdb-record-lessp (car x) (car y)))))))
-
-      (bbdb-mode)
-      ;; Normally `bbdb-records' is the only BBDB-specific buffer-local variable
-      ;; in the *BBDB* buffer.  It is intentionally not permanent-local.
-      ;; A value of nil indicates that we need to (re)process the records.
-      (setq bbdb-records records)
-      (if new-name
-          (set (make-local-variable 'bbdb-buffer-name) new-name))
-
-      (unless (or bbdb-silent-internal bbdb-silent)
-        (message "Formatting BBDB..."))
-      (let ((record-number 0)
-            buffer-read-only all-records)
-        (erase-buffer)
-        (bbdb-debug (setq all-records (bbdb-records)))
-        (dolist (record records)
-          (bbdb-debug (unless (memq (car record) all-records)
-                        (error "Record %s does not exist" (car record))))
-          (set-marker (nth 2 record) (point))
-          (bbdb-display-record (nth 0 record) (nth 1 record) record-number)
-          (setq record-number (1+ record-number)))
-
-        (run-hooks 'bbdb-display-hook))
-
-      (unless (or bbdb-silent-internal bbdb-silent)
-        (message "Formatting BBDB...done."))
-      (set-buffer-modified-p nil)
-
-      (bbdb-pop-up-window select horiz-p)
-      (if (not first-new)
-          (goto-char (point-min))
-        ;; Put point on first new record in *BBDB* buffer.
-        (goto-char (nth 2 (assq first-new bbdb-records)))
-        (set-window-start (get-buffer-window (current-buffer)) (point))))))
-
-(defun bbdb-undisplay-records (&optional all-buffers)
-  "Undisplay records in *BBDB* buffer, leaving this buffer empty.
-If ALL-BUFFERS is non-nil undisplay records in all BBDB buffers."
-  (dolist (buffer (cond (all-buffers (buffer-list))
-                        ((let ((buffer (get-buffer bbdb-buffer-name)))
-                           (and (buffer-live-p buffer) (list buffer))))))
-    (with-current-buffer buffer
-      (when (eq major-mode 'bbdb-mode)
-        (let (buffer-read-only)
-          (erase-buffer))
-        (setq bbdb-records nil)
-        (set-buffer-modified-p nil)))))
-
-(defun bbdb-redisplay-record (record &optional sort delete-p)
-  "Redisplay RECORD in current BBDB buffer.
-If SORT is t, usually because RECORD has a new sortkey, re-sort
-the displayed records.
-If DELETE-P is non-nil RECORD is removed from the BBDB buffer."
-  ;; For deletion in the *BBDB* buffer we use the full information
-  ;; about the record in the database. Therefore, we need to delete
-  ;; the record in the *BBDB* buffer before deleting the record in
-  ;; the database.
-  ;; FIXME: If point is initially inside RECORD, `bbdb-redisplay-record'
-  ;; puts point at the beginning of the redisplayed RECORD.
-  ;; Ideally, `bbdb-redisplay-record' should put point such that it
-  ;; matches the previous value `bbdb-ident-point'.
-  (let ((full-record (assq record bbdb-records)))
-    (unless full-record
-      (error "Record `%s' not displayed" (bbdb-record-name record)))
-    (if (and sort (not delete-p))
-        ;; FIXME: For records requiring re-sorting it may be more efficient
-        ;; to insert these records in their proper location instead of
-        ;; re-displaying all records.
-        (bbdb-display-records (list record) nil t)
-      (let ((marker (nth 2 full-record))
-            (end-marker (nth 2 (car (cdr (memq full-record bbdb-records)))))
-            buffer-read-only record-number)
-        ;; If point is inside record, put it at the beginning of the record.
-        (if (and (<= marker (point))
-                 (< (point) (or end-marker (point-max))))
-            (goto-char marker))
-        (save-excursion
-          (goto-char marker)
-          (setq record-number (get-text-property (point) 'bbdb-record-number))
-          (unless delete-p
-            ;; First insert the reformatted record, then delete the old one,
-            ;; so that the marker of this record cannot collapse with the
-            ;; marker of the subsequent record
-            (bbdb-display-record (car full-record) (nth 1 full-record)
-                                 record-number))
-          (delete-region (point) (or end-marker (point-max)))
-          ;; If we deleted a record we need to update the subsequent
-          ;; record numbers.
-          (when delete-p
-            (let* ((markers (append (mapcar (lambda (x) (nth 2 x))
-                                            (cdr (memq full-record bbdb-records)))
-                                    (list (point-max))))
-                   (start (pop markers)))
-              (dolist (end markers)
-                (put-text-property start end
-                                   'bbdb-record-number record-number)
-                (setq start end
-                      record-number (1+ record-number))))
-            (setq bbdb-records (delq full-record bbdb-records)))
-          (run-hooks 'bbdb-display-hook))))))
-
-(defun bbdb-redisplay-record-globally (record &optional sort delete-p)
-  "Redisplay RECORD in all BBDB buffers.
-If SORT is t, usually because RECORD has a new sortkey, re-sort
-the displayed records.
-If DELETE-P is non-nil RECORD is removed from the BBDB buffers."
-  (dolist (buffer (buffer-list))
-    (with-current-buffer buffer
-      (if (and (eq major-mode 'bbdb-mode)
-               (memq record (mapcar 'car bbdb-records)))
-          (let ((window (get-buffer-window bbdb-buffer-name)))
-            (if window
-                (with-selected-window window
-                  (bbdb-redisplay-record record sort delete-p))
-              (bbdb-redisplay-record record sort delete-p)))))))
-(define-obsolete-function-alias 'bbdb-maybe-update-display
-  'bbdb-redisplay-record-globally "3.0")
-
-
-;;; window configuration hackery
-(defun bbdb-pop-up-window (&optional select horiz-p)
-  "Display *BBDB* buffer by popping up a new window.
-Finds the largest window on the screen, splits it, displaying the
-*BBDB* buffer in the bottom `bbdb-pop-up-window-size' lines (unless
-the *BBDB* buffer is already visible, in which case do nothing.)
-Select this window if SELECT is non-nil.
-
-If `bbdb-mua-pop-up' is 'horiz, and the first window matching
-the predicate HORIZ-P is wider than the car of `bbdb-horiz-pop-up-window-size'
-then the window will be split horizontally rather than vertically."
-  (let ((buffer (get-buffer bbdb-buffer-name)))
-    (unless buffer
-      (error "No %s buffer to display" bbdb-buffer-name))
-    (cond ((let ((window (get-buffer-window buffer t)))
-             ;; We already have a BBDB window so that at most we select it
-             (and window
-                  (or (not select) (select-window window)))))
-
-          ;; try horizontal split
-          ((and (eq bbdb-mua-pop-up 'horiz)
-                horiz-p
-                (>= (frame-width) (car bbdb-horiz-pop-up-window-size))
-                (let ((window-list (window-list))
-                      (b-width (cdr bbdb-horiz-pop-up-window-size))
-                      (search t) s-window)
-                  (while (and (setq s-window (pop window-list))
-                              (setq search (not (funcall horiz-p s-window)))))
-                  (unless (or search (<= (window-width s-window)
-                                         (car bbdb-horiz-pop-up-window-size)))
-                    (condition-case nil ; `split-window' might fail
-                        (let ((window (split-window
-                                       s-window
-                                       (if (integerp b-width)
-                                           (- (window-width s-window) b-width)
-                                         (round (* (- 1 b-width) (window-width s-window))))
-                                       t))) ; horizontal split
-                          (set-window-buffer window buffer)
-                          (cond (bbdb-dedicated-window
-                                 (set-window-dedicated-p window bbdb-dedicated-window))
-                                ((fboundp 'display-buffer-record-window) ; GNU Emacs >= 24.1
-                                 (set-window-prev-buffers window nil)
-                                 (display-buffer-record-window 'window window buffer)))
-                          (if select (select-window window))
-                          t)
-                      (error nil))))))
-
-          ((eq t bbdb-pop-up-window-size)
-           (bbdb-pop-up-window-simple buffer select))
-
-          (t ;; vertical split
-           (let* ((window (selected-window))
-                  (window-height (window-height window)))
-             ;; find the tallest window...
-             (mapc (lambda (w)
-                     (let ((w-height (window-height w)))
-                       (if (> w-height window-height)
-                           (setq window w window-height w-height))))
-                   (window-list))
-             (condition-case nil
-                 (progn
-                   (unless (eql bbdb-pop-up-window-size 1.0)
-                     (setq window (split-window ; might fail
-                                   window
-                                   (if (integerp bbdb-pop-up-window-size)
-                                       (- window-height 1 ; for mode line
-                                          (max window-min-height bbdb-pop-up-window-size))
-                                     (round (* (- 1 bbdb-pop-up-window-size)
-                                               window-height))))))
-                   (set-window-buffer window buffer) ; might fail
-                   (cond (bbdb-dedicated-window
-                          (set-window-dedicated-p window bbdb-dedicated-window))
-                         ((and (fboundp 'display-buffer-record-window) ; GNU Emacs >= 24.1
-                               (not (eql bbdb-pop-up-window-size 1.0)))
-                          (set-window-prev-buffers window nil)
-                          (display-buffer-record-window 'window window buffer)))
-                   (if select (select-window window)))
-               (error (bbdb-pop-up-window-simple buffer select))))))))
-
-(defun bbdb-pop-up-window-simple (buffer select)
-  "Display BUFFER in some window, selecting it if SELECT is non-nil.
-If `bbdb-dedicated-window' is non-nil, mark the window as dedicated."
-  (let ((window (if select
-                    (progn (pop-to-buffer buffer)
-                           (get-buffer-window))
-                  (display-buffer buffer))))
-    (if bbdb-dedicated-window
-        (set-window-dedicated-p window bbdb-dedicated-window))))
-
-
-;;; BBDB mode
-
-;;;###autoload
-(define-derived-mode bbdb-mode special-mode "BBDB"
-  "Major mode for viewing and editing the Insidious Big Brother Database.
-Letters no longer insert themselves.  Numbers are prefix arguments.
-You can move around using the usual cursor motion commands.
-\\<bbdb-mode-map>
-\\[bbdb-add-mail-alias]\t Add new mail alias to visible records or \
-remove it.
-\\[bbdb-edit-field]\t Edit the field on the current line.
-\\[bbdb-delete-field-or-record]\t Delete the field on the \
-current line.  If the current line is the\n\t first line of a record, then \
-delete the entire record.
-\\[bbdb-insert-field]\t Insert a new field into the current record.  \
-Note that this\n\t will let you add new fields of your own as well.
-\\[bbdb-transpose-fields]\t Swap the field on the current line with the \
-previous field.
-\\[bbdb-dial]\t Dial the current phone field.
-\\[bbdb-next-record], \\[bbdb-prev-record]\t Move to the next or the previous \
-displayed record, respectively.
-\\[bbdb-create]\t Create a new record.
-\\[bbdb-toggle-records-layout]\t Toggle whether the current record is displayed in a \
-one-line\n\t listing, or a full multi-line listing.
-\\[bbdb-do-all-records]\\[bbdb-toggle-records-layout]\t Do that \
-for all displayed records.
-\\[bbdb-merge-records]\t Merge the contents of the current record with \
-some other, and then\n\t delete the current record.
-\\[bbdb-omit-record]\t Remove the current record from the display without \
-deleting it from\n\t the database.  This is often a useful thing to do \
-before using one\n\t of the `*' commands.
-\\[bbdb]\t Search for records in the database (on all fields).
-\\[bbdb-search-mail]\t Search for records by mail address.
-\\[bbdb-search-organization]\t Search for records by organization.
-\\[bbdb-search-xfields]\t Search for records by xfields.
-\\[bbdb-search-name]\t Search for records by name.
-\\[bbdb-search-changed]\t Display records that have changed since the database \
-was saved.
-\\[bbdb-mail]\t Compose mail to the person represented by the \
-current record.
-\\[bbdb-do-all-records]\\[bbdb-mail]\t Compose mail \
-to everyone whose record is displayed.
-\\[bbdb-save]\t Save the BBDB file to disk.
-\\[bbdb-tex]\t Create a TeX listing of the current record.
-\\[bbdb-do-all-records]\\[bbdb-tex]\t Do that for all \
-displayed record.
-\\[other-window]\t Move to another window.
-\\[bbdb-info]\t Read the Info documentation for BBDB.
-\\[bbdb-help]\t Display a one line command summary in the echo area.
-\\[bbdb-browse-url]\t Visit Web sites listed in the `url' field(s) of the current \
-record.
-
-For address completion using the names and mail addresses in the database:
-\t in Mail mode, type \\<mail-mode-map>\\[bbdb-complete-mail].
-\t in Message mode, type \\<message-mode-map>\\[bbdb-complete-mail].
-
-Important variables:
-\t `bbdb-auto-revert'
-\t `bbdb-ignore-redundant-mails'
-\t `bbdb-case-fold-search'
-\t `bbdb-completion-list'
-\t `bbdb-default-area-code'
-\t `bbdb-default-domain'
-\t `bbdb-layout'
-\t `bbdb-file'
-\t `bbdb-phone-style'
-\t `bbdb-check-auto-save-file'
-\t `bbdb-pop-up-layout'
-\t `bbdb-pop-up-window-size'
-\t `bbdb-add-name'
-\t `bbdb-add-aka'
-\t `bbdb-add-mails'
-\t `bbdb-new-mails-primary'
-\t `bbdb-read-only'
-\t `bbdb-mua-pop-up'
-\t `bbdb-user-mail-address-re'
-
-There are numerous hooks.  M-x apropos ^bbdb.*hook RET
-
-\\{bbdb-mode-map}"
-  (setq truncate-lines t
-        default-directory (file-name-directory bbdb-file)
-        mode-line-buffer-identification
-        (list 24 (buffer-name) "  "
-              '(:eval (format "%d/%d/%d"
-                              (1+ (or (get-text-property
-                                       (point) 'bbdb-record-number) -1))
-                              (length bbdb-records)
-                              ;; This code gets called a lot.
-                              ;; So we keep it as simple as possible.
-                              (with-current-buffer bbdb-buffer
-                                (length bbdb-records))))
-              '(:eval (concat "  "
-                              (bbdb-concat " " (elt bbdb-modeline-info 0)
-                                           (elt bbdb-modeline-info 2)
-                                           (elt bbdb-modeline-info 4)))))
-        mode-line-modified
-        ;; For the mode-line we want to be fast. So we skip the checks
-        ;; performed by `bbdb-with-db-buffer'.
-        '(:eval (if (buffer-modified-p bbdb-buffer)
-                    (if bbdb-read-only "%*" "**")
-                  (if bbdb-read-only "%%" "--"))))
-  ;; `bbdb-revert-buffer' acts on `bbdb-buffer'.  Yet this command is usually
-  ;; called from the *BBDB* buffer.
-  (set (make-local-variable 'revert-buffer-function)
-       'bbdb-revert-buffer)
-  (add-hook 'post-command-hook 'force-mode-line-update nil t))
-
-
-
-(defun bbdb-sendmail-menu (record)
-  "Menu items for email addresses of RECORD."
-  (let ((mails (bbdb-record-mail record)))
-    (list
-     (if (cdr mails)
-         ;; Submenu for multiple mail addresses
-         (cons "Send mail to..."
-               (mapcar (lambda (address)
-                         (vector address `(bbdb-compose-mail
-                                           ,(bbdb-dwim-mail record address))
-                                 t))
-                       mails))
-       ;; Single entry for single mail address
-       (vector (concat "Send mail to " (car mails))
-               `(bbdb-compose-mail ,(bbdb-dwim-mail record (car mails)))
-               t)))))
-
-(defun bbdb-field-menu (record field)
-  "Menu items specifically for FIELD of RECORD."
-  (let ((type (car field)))
-    (append
-     (list
-      (format "Commands for %s Field:"
-              (cond ((eq type 'xfields)
-                     (format "\"%s\"" (symbol-name (car (nth 1 field)))))
-                    ((eq type 'name) "Name")
-                    ((eq type 'affix) "Affix")
-                    ((eq type 'organization) "Organization")
-                    ((eq type 'aka) "Alternate Names")
-                    ((eq type 'mail) "Mail Addresses")
-                    ((memq type '(address phone))
-                     (format "\"%s\" %s" (aref (nth 1 field) 0)
-                             (capitalize (symbol-name type)))))))
-     (cond ((eq type 'phone)
-            (list (vector (concat "Dial " (bbdb-phone-string (nth 1 field)))
-                          `(bbdb-dial ',field nil) t)))
-           ((eq type 'xfields)
-            (let* ((field (cadr field))
-                   (type (car field)))
-              (cond ((eq type 'url )
-                     (list (vector (format "Browse \"%s\"" (cdr field))
-                                   `(bbdb-browse-url ,record) t)))))))
-     '(["Edit Field" bbdb-edit-field t])
-     (unless (eq type 'name)
-       '(["Delete Field" bbdb-delete-field-or-record t])))))
-
-(defun bbdb-insert-field-menu (record)
-  "Submenu for inserting a new field for RECORD."
-  (cons "Insert New Field..."
-        (mapcar
-         (lambda (field)
-           (if (stringp field) field
-             (vector (symbol-name field)
-                     `(bbdb-insert-field
-                       ,record ',field (bbdb-read-field ,record ',field
-                                                        ,current-prefix-arg))
-                     (not (or (and (eq field 'affix) (bbdb-record-affix record))
-                              (and (eq field 'organization)
-                                   (bbdb-record-organization record))
-                              (and (eq field 'mail) (bbdb-record-mail record))
-                              (and (eq field 'aka) (bbdb-record-aka record))
-                              (assq field (bbdb-record-xfields record)))))))
-         (append '(affix organization aka phone address mail)
-                 '("--") bbdb-xfield-label-list))))
-
-(defun bbdb-mouse-menu (event)
-  "BBDB mouse menu for EVENT,"
-  (interactive "e")
-  (mouse-set-point event)
-  (let* ((record (bbdb-current-record))
-         (field  (bbdb-current-field))
-         (menu (if (and record field (functionp bbdb-user-menu-commands))
-                   (funcall bbdb-user-menu-commands record field)
-                 bbdb-user-menu-commands)))
-    (if record
-        (popup-menu
-         (append
-          (list
-           (format "Commands for record \"%s\":" (bbdb-record-name record))
-           ["Delete Record" bbdb-delete-records t]
-           ["Toggle Record Display Layout" bbdb-toggle-records-layout t]
-           (if (and (not (eq 'full-multi-line
-                             (nth 1 (assq record bbdb-records))))
-                    (bbdb-layout-get-option 'multi-line 'omit))
-               ["Fully Display Record" bbdb-display-records-completely t])
-           ["Omit Record" bbdb-omit-record t]
-           ["Merge Record" bbdb-merge-records t])
-          (if (bbdb-record-mail record)
-              (bbdb-sendmail-menu record))
-          (list "--" (bbdb-insert-field-menu record))
-          (if field
-              (cons "--" (bbdb-field-menu record field)))
-          (if menu
-              (append '("--" "User Defined Commands") menu)))))))
-
-
-
-(defun bbdb-scan-property (property predicate n)
-  "Scan for change of PROPERTY matching PREDICATE for N times.
-Return position of beginning of matching interval."
-  (let ((fun (if (< 0 n) 'next-single-property-change
-               'previous-single-property-change))
-        (limit (if (< 0 n) (point-max) (point-min)))
-        (nn (abs n))
-        (i 0)
-        (opoint (point))
-        npoint)
-    ;; For backward search, move point to beginning of interval with PROPERTY.
-    (if (and (<= n 0)
-             (< (point-min) opoint)
-             (let ((prop (get-text-property opoint property)))
-               (and (eq prop (get-text-property (1- opoint) property))
-                    (funcall predicate prop))))
-        (setq opoint (previous-single-property-change opoint property nil limit)))
-    (if (zerop n)
-        opoint ; Return beginning of interval point is in
-      (while (and (< i nn)
-                  (let (done)
-                    (while (and (not done)
-                                (setq npoint (funcall fun opoint property nil limit)))
-                      (cond ((and (/= opoint npoint)
-                                  (funcall predicate (get-text-property
-                                                      npoint property)))
-                             (setq opoint npoint done t))
-                            ((= opoint npoint)
-                             ;; Search reached beg or end of buffer: abort.
-                             (setq done t i nn npoint nil))
-                            (t (setq opoint npoint))))
-                    done))
-        (setq i (1+ i)))
-      npoint)))
-
-(defun bbdb-next-record (n)
-  "Move point to the beginning of the next BBDB record.
-With prefix N move forward N records."
-  (interactive "p")
-  (let ((npoint (bbdb-scan-property 'bbdb-record-number 'integerp n)))
-    (if npoint (goto-char npoint)
-      (error "No %s record" (if (< 0 n) "next" "previous")))))
-
-(defun bbdb-prev-record (n)
-  "Move point to the beginning of the previous BBDB record.
-With prefix N move backwards N records."
-  (interactive "p")
-  (bbdb-next-record (- n)))
-
-(defun bbdb-next-field (n)
-  "Move point to next (sub)field.
-With prefix N move forward N (sub)fields."
-  (interactive "p")
-  (let ((npoint (bbdb-scan-property
-                 'bbdb-field
-                 (lambda (p) (and (nth 1 p)
-                                  (not (eq (nth 2 p) 'field-label))))
-                 n)))
-    (if npoint (goto-char npoint)
-      (error "No %s field" (if (< 0 n) "next" "previous")))))
-
-(defun bbdb-prev-field (n)
-  "Move point to previous (sub)field.
-With prefix N move backwards N (sub)fields."
-  (interactive "p")
-  (bbdb-next-field (- n)))
-
-(defun bbdb-save (&optional prompt noisy)
-  "Save the BBDB if it is modified.
-If PROMPT is non-nil prompt before saving.
-If NOISY is non-nil as in interactive calls issue status messages."
-  (interactive (list nil t))
-  (bbdb-with-db-buffer
-    (if (buffer-modified-p)
-        (if (or (not prompt)
-                (y-or-n-p
-                 (if bbdb-read-only
-                     "Save the BBDB, even though it is supposedly read-only? "
-                   "Save the BBDB now? ")))
-            (save-buffer))
-      (if noisy (message "(No BBDB changes need to be saved)")))))
-
-;;;###autoload
-(defun bbdb-version (&optional arg)
-  "Return string describing the version of BBDB.
-With prefix ARG, insert string at point."
-  (interactive (list (or (and current-prefix-arg 1) t)))
-  (let* ((version
-          (if (string-match "\\`[ \t\n]*[1-9]" bbdb-version)
-              bbdb-version
-            (let ((source (find-function-noselect 'bbdb-version)))
-              (if source
-                  (with-current-buffer (car source)
-                    (prog1 (save-excursion
-                             (goto-char (point-min))
-                             (when (re-search-forward
-                                    "^;;+ *Version: \\(.*\\)" nil t)
-                               (match-string-no-properties 1)))
-                      (unless (get-buffer-window nil t)
-                        (kill-buffer (current-buffer)))))))))
-         (version-string (format "BBDB version %s" (or version "<unknown>"))))
-    (cond ((numberp arg) (insert (message version-string)))
-          ((eq t arg) (message version-string))
-          (t version-string))))
-
-
-
-(defun bbdb-sort-records ()
-  "Sort BBDB database.
-This is not needed when using BBDB itself.  It might be necessary,
-however, after having used other programs to add records to the BBDB."
-  (interactive)
-  (let* ((records (copy-sequence (bbdb-records))))
-    (bbdb-with-db-buffer
-      (setq bbdb-records (sort bbdb-records 'bbdb-record-lessp))
-      (if (equal records bbdb-records)
-          (message "BBDB already sorted properly")
-        (message "BBDB was mis-sorted; fixing...")
-        (bbdb-goto-first-record)
-        (delete-region (point) bbdb-end-marker)
-        (let ((buf (current-buffer))
-              (inhibit-quit t) ; really, don't mess with this
-              cache)
-          (dolist (record bbdb-records)
-            ;; Before printing the record, remove cache (we do not want that
-            ;; written to the file.)  Ater writing, put the cache back
-            ;; and update the cache's marker.
-            (setq cache (bbdb-record-cache record))
-            (set-marker (bbdb-cache-marker cache) (point))
-            (bbdb-record-set-cache record nil)
-            (bbdb-with-print-loadably (prin1 record buf))
-            (bbdb-record-set-cache record cache)
-            (insert ?\n)))
-        (dolist (buffer (buffer-list))
-          (with-current-buffer buffer
-            (if (eq major-mode 'bbdb-mode)
-                ; Redisplay all records
-                (bbdb-display-records nil nil t))))
-        (message "BBDB was mis-sorted; fixing...done")))))
-
-
-
-;;;###autoload
-(defun bbdb-initialize (&rest muas)
-  "Initialize BBDB for MUAS and miscellaneous packages.
-List MUAS may include the following symbols to initialize the respective
-mail/news readers, composers, and miscellaneous packages:
-  gnus       Gnus mail/news reader.
-  mh-e       MH-E mail reader.
-  mu4e       Mu4e mail reader.
-  rmail      Rmail mail reader.
-  vm         VM mail reader.
-  mail       Mail (M-x mail).
-  message    Message mode.
-  wl         Wanderlust mail reader.
-
-  anniv      Anniversaries in Emacs diary.
-
-  sc         Supercite.  However, this is not the full story.
-               See bbdb-sc.el for how to fully hook BBDB into Supercite.
-
-  pgp        PGP support:  this adds `bbdb-pgp' to `message-send-hook'
-               and `mail-send-hook' so that `bbdb-pgp' runs automatically
-               when a message is sent.
-               Yet see info node `(message)Signing and encryption'
-               why you might not want to rely for encryption on a hook
-               function which runs just before the message is sent,
-               that is, you might want to call the command `bbdb-pgp' manually,
-               then call `mml-preview'.
-
-See also `bbdb-mua-auto-update-init'.  The latter is a separate function
-as this allows one to initialize the auto update feature for some MUAs only,
-for example only for outgoing messages."
-  (dolist (mua muas)
-    (let ((init (assq mua bbdb-init-forms)))
-      (if init
-          ;; Should we make sure that each insinuation happens only once?
-          (eval (cadr init))
-        (bbdb-warn "Do not know how to insinuate `%s'" mua))))
-  (run-hooks 'bbdb-initialize-hook))
-
-
-(provide 'bbdb)
-
-;;; bbdb.el ends here