comparison lisp/textmodes/bibtex.el @ 91367:c70e45a7acfd

Merge from emacs--devo--0 Revision: [e-mail]/emacs--unicode--0--patch-324

91366:86f3a8f0a3a6

                      field is empty, set the booktitle field to the content
                      of the title field of the crossreferenced entry.
realign             Realign entries, so that field texts and perhaps equal
                      signs (depending on the value of
                      `bibtex-align-at-equal-sign') begin in the same column.
last-comma          Add or delete comma on end of last field in entry,
                      according to value of `bibtex-comma-after-last-field'.
delimiters          Change delimiters according to variables
                      `bibtex-field-delimiters' and `bibtex-entry-delimiters'.
unify-case          Change case of entry and field names.

     ["Reformat Entries" bibtex-reformat t]
     ["Count Entries" bibtex-count-entries t]
     "--"
     ["Convert Alien Buffer" bibtex-convert-alien t])
    ("Operating on Multiple Buffers"
     ["Validate Entries" bibtex-validate-globally t])))

(easy-menu-define
  bibtex-entry-menu bibtex-mode-map "Entry-Types Menu in BibTeX mode"
  (list "Entry-Types"

  (if (eq bibtex-entry-delimiters 'braces)
      "}"
    ")"))

(defun bibtex-flash-head (prompt)
  "Flash at BibTeX entry head before point, if exists."
  (let ((case-fold-search t)
        (pnt (point)))
    (save-excursion
      (bibtex-beginning-of-entry)
      (when (and (looking-at bibtex-any-entry-maybe-empty-head)
                 (< (point) pnt))
        (goto-char (match-beginning bibtex-type-in-head))
        (if (pos-visible-in-window-p (point))
            (sit-for blink-matching-delay)
          (message "%s%s" prompt (buffer-substring-no-properties
                                  (point) (match-end bibtex-key-in-head))))))))

(defun bibtex-make-optional-field (field)

                       bibtex-entry-kill-ring)))))

(defun bibtex-format-entry ()
  "Helper function for `bibtex-clean-entry'.
Formats current entry according to variable `bibtex-entry-format'."
  (save-excursion
    (save-restriction
      (bibtex-narrow-to-entry)
      (let ((case-fold-search t)
            (format (if (eq bibtex-entry-format t)
                        '(realign opts-or-alts required-fields
                                  numerical-fields
                                  last-comma page-dashes delimiters
                                  unify-case inherit-booktitle)
                      bibtex-entry-format))
            crossref-key bounds alternatives-there non-empty-alternative
            entry-list req-field-list field-list)

        ;; Initialize `bibtex-field-braces-opt' and `bibtex-field-strings-opt'
        ;; if necessary.
        (unless bibtex-field-braces-opt
          (setq bibtex-field-braces-opt
                (bibtex-field-re-init bibtex-field-braces-alist 'braces)))
        (unless bibtex-field-strings-opt
          (setq bibtex-field-strings-opt
                (bibtex-field-re-init bibtex-field-strings-alist 'strings)))

        ;; identify entry type
        (goto-char (point-min))
        (or (re-search-forward bibtex-entry-type nil t)
            (error "Not inside a BibTeX entry"))
        (let ((beg-type (1+ (match-beginning 0)))
              (end-type (match-end 0)))
          (setq entry-list (assoc-string (buffer-substring-no-properties
					  beg-type end-type)
					 bibtex-entry-field-alist
					 t))

          ;; unify case of entry name
          (when (memq 'unify-case format)
            (delete-region beg-type end-type)
            (insert (car entry-list)))

          ;; update left entry delimiter
          (when (memq 'delimiters format)
            (goto-char end-type)
            (skip-chars-forward " \t\n")
            (delete-char 1)
            (insert (bibtex-entry-left-delimiter))))

        ;; determine if entry has crossref field and if at least
        ;; one alternative is non-empty
        (goto-char (point-min))
        (let* ((fields-alist (bibtex-parse-entry t))
               (field (assoc-string "crossref" fields-alist t)))
          (setq crossref-key (and field
                                  (not (equal "" (cdr field)))
                                  (cdr field))
                req-field-list (if crossref-key
                                   (nth 0 (nth 2 entry-list)) ; crossref part
                                 (nth 0 (nth 1 entry-list)))) ; required part

          (dolist (rfield req-field-list)
            (when (nth 3 rfield) ; we should have an alternative
              (setq alternatives-there t
                    field (assoc-string (car rfield) fields-alist t))
              (if (and field
                       (not (equal "" (cdr field))))
                  (cond ((not non-empty-alternative)
                         (setq non-empty-alternative t))
                        ((memq 'required-fields format)
                         (error "More than one non-empty alternative")))))))

        (if (and alternatives-there
                 (not non-empty-alternative)
                 (memq 'required-fields format))
            (error "All alternatives are empty"))

        ;; process all fields
        (bibtex-beginning-first-field (point-min))
        (while (setq bounds (bibtex-parse-field))
          (let* ((beg-field (copy-marker (bibtex-start-of-field bounds)))

                 (field-name (buffer-substring-no-properties
                              (if opt-alt (+ beg-name 3) beg-name) end-name))
                 (empty-field (equal "" (bibtex-text-in-field-bounds bounds t)))
                 deleted)

            ;; We have more elegant high-level functions for several
            ;; tasks done by `bibtex-format-entry'.  However, they contain
            ;; quite some redundancy compared with what we need to do
            ;; anyway.  So for speed-up we avoid using them.

            (if (memq 'opts-or-alts format)
                (cond ((and empty-field
                            (or opt-alt
                                (let ((field (assoc-string
                                              field-name req-field-list t)))
                                  (or (not field)       ; OPT field
                                      (nth 3 field))))) ; ALT field
                       ;; Either it is an empty ALT field.  Then we have checked
                       ;; already that we have one non-empty alternative.  Or it
                       ;; is an empty OPT field that we do not miss anyway.
                       ;; So we can safely delete this field.
                       (delete-region beg-field end-field)
                       (setq deleted t))
                      ;; otherwise: not empty, delete "OPT" or "ALT"
                      (opt-alt
                       (goto-char beg-name)
                       (delete-char 3))))

            (unless deleted

                    (when title
                      (setq empty-field nil)
                      (goto-char (1+ beg-text))
                      (insert title))))

	      ;; Use booktitle to set a missing title.
	      (if (and empty-field
		       (bibtex-string= field-name "title"))
		  (let ((booktitle (bibtex-text-in-field "booktitle")))
		    (when booktitle
		      (setq empty-field nil)
		      (goto-char (1+ beg-text))
		      (insert booktitle))))

              ;; if empty field, complain
              (if (and empty-field
                       (memq 'required-fields format)
                       (assoc-string field-name req-field-list t))
                  (error "Mandatory field `%s' is empty" field-name))

              ;; unify case of field name
              (if (memq 'unify-case format)
                  (let ((fname (car (assoc-string
                                     field-name
				     (append (nth 0 (nth 1 entry-list))
					     (nth 1 (nth 1 entry-list))
					     bibtex-user-optional-fields)
				     t))))
                    (if fname
                        (progn
                          (delete-region beg-name end-name)
                          (goto-char beg-name)
                          (insert fname))

              ;; update point
              (goto-char end-field))))

        ;; check whether all required fields are present
        (if (memq 'required-fields format)
            (let ((found 0) altlist)
              (dolist (fname req-field-list)
                (if (nth 3 fname)
                    (push (car fname) altlist))
                (unless (or (member (car fname) field-list)
                            (nth 3 fname))
                  (error "Mandatory field `%s' is missing" (car fname))))
              (when altlist
                (dolist (fname altlist)
                  (if (member fname field-list)
                      (setq found (1+ found))))
                (cond ((= found 0)
                       (error "Alternative mandatory field `%s' is missing"
                              altlist))
                      ((> found 1)
                       (error "Alternative fields `%s' are defined %s times"
                              altlist found))))))

        ;; update comma after last field
        (if (memq 'last-comma format)
            (cond ((and bibtex-comma-after-last-field
                        (not (looking-at ",")))

        (when (memq 'delimiters format)
          (skip-chars-forward " \t\n")
          (delete-char 1)
          (insert (bibtex-entry-right-delimiter)))

        ;; fill entry
        (if (memq 'realign format)
            (bibtex-fill-entry))))))

(defun bibtex-field-re-init (regexp-alist type)
  "Calculate optimized value for bibtex-regexp-TYPE-opt.

  "Return global key alist based on `bibtex-files'."
  (if bibtex-files
      (apply 'append
             (mapcar (lambda (buf)
                       (with-current-buffer buf bibtex-reference-keys))
                     (bibtex-files-expand t)))
    bibtex-reference-keys))

(defun bibtex-read-key (prompt &optional key global)
  "Read BibTeX key from minibuffer using PROMPT and default KEY.
If optional arg GLOBAL is non-nil, completion is based on the keys in

                  ;; remember that parsing was successful
                  (setq bibtex-buffer-last-parsed-tick (buffer-modified-tick)))))
        (setq buffers (cdr buffers))))))

(defun bibtex-files-expand (&optional current force)
  "Return an expanded list of BibTeX buffers based on `bibtex-files'.
Initialize in these buffers `bibtex-reference-keys' if not yet set.
List of BibTeX buffers includes current buffer if CURRENT is non-nil.
If FORCE is non-nil, (re)initialize `bibtex-reference-keys' even if
already set."
  (let ((file-path (split-string (or bibtex-file-path default-directory) ":+"))
        file-list dir-list buffer-list)
    (dolist (file bibtex-files)
      (cond ((eq file 'bibtex-file-path)
             (setq dir-list (append dir-list file-path)))
            ((file-accessible-directory-p file)
             (push file dir-list))
            ((progn (unless (string-match "\\.bib\\'" file)
                      (setq file (concat file ".bib")))
                    (file-name-absolute-p file))
             (push file file-list))
            (t
             (let (fullfilename found)
               (dolist (dir file-path)
                 (when (file-readable-p
                        (setq fullfilename (expand-file-name file dir)))
                   (push fullfilename file-list)
                   (setq found t)))
               (unless found
                 (error "File %s not in paths defined via bibtex-file-path"
                        file))))))
    (dolist (file file-list)
      (unless (file-readable-p file)
        (error "BibTeX file %s not found" file)))
    ;; expand dir-list
    (dolist (dir dir-list)
      (setq file-list
            (append file-list (directory-files dir t "\\.bib\\'" t))))
    (delete-dups file-list)
    (dolist (file file-list)
      (when (file-readable-p file)
        (push (find-file-noselect file) buffer-list)
        (with-current-buffer (car buffer-list)
          (if (or force (not (listp bibtex-reference-keys)))
            (bibtex-parse-keys)))))
    (cond ((and current (not (memq (current-buffer) buffer-list)))
           (push (current-buffer) buffer-list)
           (if force (bibtex-parse-keys)))
          ((and (not current) (memq (current-buffer) buffer-list))
           (setq buffer-list (delq (current-buffer) buffer-list))))
    buffer-list))

(defun bibtex-complete-internal (completions)
  "Complete word fragment before point to longest prefix of COMPLETIONS.
COMPLETIONS is an alist of strings.  If point is not after the part

entry.  For all empty fields of the current entry insert the corresponding
field contents of the neighboring entry.  Finally try to update the text
based on the difference between the keys of the neighboring and the current
entry (for example, the year parts of the keys)."
  (interactive)
  (undo-boundary)	;So you can easily undo it, if it didn't work right.
  (bibtex-beginning-of-entry)
  (when (looking-at bibtex-entry-head)
    (let ((type (bibtex-type-in-head))
	  (key (bibtex-key-in-head))
	  (key-end (match-end bibtex-key-in-head))

The predicate depends on the variable `bibtex-maintain-sorted-entries'.
If its value is nil use plain sorting."
  (cond ((not index1) (not index2)) ; indices can be nil
        ((not index2) nil)
        ((eq bibtex-maintain-sorted-entries 'crossref)
         (if (nth 1 index1)
             (if (nth 1 index2)
                 (or (string-lessp (nth 1 index1) (nth 1 index2))
                     (and (string-equal (nth 1 index1) (nth 1 index2))
                          (string-lessp (nth 0 index1) (nth 0 index2))))
               (not (string-lessp (nth 0 index2) (nth 1 index1))))
           (if (nth 1 index2)
               (string-lessp (nth 0 index1) (nth 1 index2))
             (string-lessp (nth 0 index1) (nth 0 index2)))))
        ((eq bibtex-maintain-sorted-entries 'entry-class)
         (let ((n1 (cdr (or (assoc (nth 2 index1) bibtex-sort-entry-class-alist)
                            (assoc 'catch-all bibtex-sort-entry-class-alist)

affected.  If `bibtex-sort-ignore-string-entries' is non-nil, @String entries
are ignored."
  (interactive)
  (bibtex-beginning-of-first-entry)     ; Needed by `sort-subr'
  (bibtex-init-sort-entry-class-alist)  ; Needed by `bibtex-lessp'.
  (sort-subr nil
             'bibtex-skip-to-valid-entry   ; NEXTREC function
             'bibtex-end-of-entry          ; ENDREC function
             'bibtex-entry-index           ; STARTKEY function
             nil                           ; ENDKEY function

If DISPLAY is non-nil, display the buffer containing KEY.
Otherwise, use `set-buffer'.  DISPLAY is t when called interactively."
  (interactive (list (bibtex-read-key "Find key: " nil current-prefix-arg)
                     current-prefix-arg nil t))
  (if (and global bibtex-files)
      (let ((buffer-list (bibtex-files-expand t))
            buffer found)
        (while (and (not found)
                    (setq buffer (pop buffer-list)))
          (with-current-buffer buffer
            (if (cdr (assoc-string key bibtex-reference-keys))

If `bibtex-maintain-sorted-entries' is non-nil, perform a binary
search to look for place for KEY.  This requires that buffer is sorted,
see `bibtex-validate'.
Return t if preparation was successful or nil if entry KEY already exists."
  (bibtex-init-sort-entry-class-alist)  ; Needed by `bibtex-lessp'.
  (let ((key (nth 0 index))
        key-exist)
    (cond ((or (null key)
               (and (stringp key)
                    (string-equal key ""))

        (if error-list
            ;; Continue only if there were no syntax errors.
            (setq syntax-error t)

          ;; Check for duplicate keys and correct sort order
          (let (previous current key-list)
            (bibtex-progress-message "Checking for duplicate keys")
            (bibtex-map-entries
             (lambda (key beg end)
               (bibtex-progress-message)

               (push key key-list)
               (setq previous current)))
            (bibtex-progress-message 'done))

          ;; Check for duplicate keys in `bibtex-files'.
          (bibtex-parse-keys)
          ;; We don't want to be fooled by outdated `bibtex-reference-keys'.
          (dolist (buffer (bibtex-files-expand nil t))
            (dolist (key (with-current-buffer buffer bibtex-reference-keys))
              (when (and (cdr key)
                         (cdr (assoc-string (car key) bibtex-reference-keys)))
                (bibtex-find-entry (car key))
                (push (cons (bibtex-current-line)

(defun bibtex-validate-globally (&optional strings)
  "Check for duplicate keys in `bibtex-files'.
With optional prefix arg STRINGS, check for duplicate strings, too.
Return t if test was successful, nil otherwise."
  (interactive "P")
  (let ((buffer-list (bibtex-files-expand t))
        buffer-key-list current-buf current-keys error-list)
    ;; Check for duplicate keys within BibTeX buffer
    (dolist (buffer buffer-list)
      (save-excursion
        (set-buffer buffer)

        (start (bibtex-beginning-of-entry))
        (_ (or (looking-at bibtex-any-entry-maybe-empty-head)
	       (error "Not inside a BibTeX entry")))
        (entry-type (bibtex-type-in-head))
        (key (bibtex-key-in-head)))
    ;; formatting
    (cond ((bibtex-string= entry-type "preamble")
           ;; (bibtex-format-preamble)
           (error "No clean up of @Preamble entries"))
          ((bibtex-string= entry-type "string")
           (setq entry-type 'string))
          ;; (bibtex-format-string)
          (t (bibtex-format-entry)))
    ;; set key
    (when (or new-key (not key))
      (setq key (bibtex-generate-autokey))
      ;; Sometimes `bibtex-generate-autokey' returns an empty string
      (if (or bibtex-autokey-edit-before-use (string= "" key))

          (bibtex-find-entry key)
          (setq error (or (/= (point) start)
                          (bibtex-find-entry key nil end))))
        (if error
            (error "New inserted entry yields duplicate key"))
        (dolist (buffer (bibtex-files-expand))
          (with-current-buffer buffer
            (if (cdr (assoc-string key bibtex-reference-keys))
                (error "Duplicate key in %s" (buffer-file-name)))))

        ;; Only update the list of keys if it has been built already.

91367:c70e45a7acfd

                      field is empty, set the booktitle field to the content
                      of the title field of the crossreferenced entry.
realign             Realign entries, so that field texts and perhaps equal
                      signs (depending on the value of
                      `bibtex-align-at-equal-sign') begin in the same column.
                      Also fill fields.
last-comma          Add or delete comma on end of last field in entry,
                      according to value of `bibtex-comma-after-last-field'.
delimiters          Change delimiters according to variables
                      `bibtex-field-delimiters' and `bibtex-entry-delimiters'.
unify-case          Change case of entry and field names.

     ["Reformat Entries" bibtex-reformat t]
     ["Count Entries" bibtex-count-entries t]
     "--"
     ["Convert Alien Buffer" bibtex-convert-alien t])
    ("Operating on Multiple Buffers"
     ["(Re)Initialize BibTeX Buffers" bibtex-initialize t]
     ["Validate Entries" bibtex-validate-globally t])))

(easy-menu-define
  bibtex-entry-menu bibtex-mode-map "Entry-Types Menu in BibTeX mode"
  (list "Entry-Types"

  (if (eq bibtex-entry-delimiters 'braces)
      "}"
    ")"))

(defun bibtex-flash-head (prompt)
  "Flash at BibTeX entry head before point, if it exists."
  (let ((case-fold-search t)
        (pnt (point)))
    (save-excursion
      (bibtex-beginning-of-entry)
      (when (and (looking-at bibtex-any-entry-maybe-empty-head)
                 (< (point) pnt))
        (goto-char (match-beginning bibtex-type-in-head))
        (if (and (< 0 blink-matching-delay)
                 (pos-visible-in-window-p (point)))
            (sit-for blink-matching-delay)
          (message "%s%s" prompt (buffer-substring-no-properties
                                  (point) (match-end bibtex-key-in-head))))))))

(defun bibtex-make-optional-field (field)

                       bibtex-entry-kill-ring)))))

(defun bibtex-format-entry ()
  "Helper function for `bibtex-clean-entry'.
Formats current entry according to variable `bibtex-entry-format'."
  ;; initialize `bibtex-field-braces-opt' if necessary
  (if (and bibtex-field-braces-alist (not bibtex-field-braces-opt))
      (setq bibtex-field-braces-opt
            (bibtex-field-re-init bibtex-field-braces-alist 'braces)))
  ;; initialize `bibtex-field-strings-opt' if necessary
  (if (and bibtex-field-strings-alist (not bibtex-field-strings-opt))
      (setq bibtex-field-strings-opt
            (bibtex-field-re-init bibtex-field-strings-alist 'strings)))

  (save-excursion
    (save-restriction
      (bibtex-narrow-to-entry)
      (let ((case-fold-search t)
            (format (if (eq bibtex-entry-format t)
                        '(realign opts-or-alts required-fields numerical-fields
                                  page-dashes whitespace inherit-booktitle
                                  last-comma delimiters unify-case braces
                                  strings)
                      bibtex-entry-format))
            bounds crossref-key req-field-list default-field-list field-list)

        ;; There are more elegant high-level functions for several tasks
        ;; done by `bibtex-format-entry'.  However, they contain some
        ;; redundancy compared with what we need to do anyway.
        ;; So for speed-up we avoid using them.
        ;; (`bibtex-format-entry' is called many times by `bibtex-reformat'.)

        ;; identify entry type
        (goto-char (point-min))
        (or (re-search-forward bibtex-entry-type nil t)
            (error "Not inside a BibTeX entry"))
        (let* ((beg-type (1+ (match-beginning 0)))
               (end-type (match-end 0))
               (entry-list (assoc-string (buffer-substring-no-properties
					  beg-type end-type)
					 bibtex-entry-field-alist t)))

          ;; unify case of entry name
          (when (memq 'unify-case format)
            (delete-region beg-type end-type)
            (insert (car entry-list)))

          ;; update left entry delimiter
          (when (memq 'delimiters format)
            (goto-char end-type)
            (skip-chars-forward " \t\n")
            (delete-char 1)
            (insert (bibtex-entry-left-delimiter)))

          ;; Do we have a crossref key?
          (goto-char (point-min))
          (if (setq bounds (bibtex-search-forward-field "crossref"))
              (let ((text (bibtex-text-in-field-bounds bounds t)))
                (unless (equal "" text)
                  (setq crossref-key text))))

          ;; list of required fields appropriate for an entry with
          ;; or without crossref key.
          (setq req-field-list (if (and crossref-key (nth 2 entry-list))
                                   (car (nth 2 entry-list))
                                 (car (nth 1 entry-list)))
                ;; default list of fields that may appear in this entry
                default-field-list (append (nth 0 (nth 1 entry-list))
                                           (nth 1 (nth 1 entry-list))
                                           bibtex-user-optional-fields)))

        ;; process all fields
        (bibtex-beginning-first-field (point-min))
        (while (setq bounds (bibtex-parse-field))
          (let* ((beg-field (copy-marker (bibtex-start-of-field bounds)))

                 (field-name (buffer-substring-no-properties
                              (if opt-alt (+ beg-name 3) beg-name) end-name))
                 (empty-field (equal "" (bibtex-text-in-field-bounds bounds t)))
                 deleted)

            (if (memq 'opts-or-alts format)
                ;; delete empty optional and alternative fields
                ;; (but keep empty required fields)
                (cond ((and empty-field
                            (or opt-alt
                                (let ((field (assoc-string
                                              field-name req-field-list t)))
                                  (or (not field)       ; OPT field
                                      (nth 3 field))))) ; ALT field
                       (delete-region beg-field end-field)
                       (setq deleted t))
                      ;; otherwise nonempty field: delete "OPT" or "ALT"
                      (opt-alt
                       (goto-char beg-name)
                       (delete-char 3))))

            (unless deleted

                    (when title
                      (setq empty-field nil)
                      (goto-char (1+ beg-text))
                      (insert title))))

              ;; if empty field is a required field, complain
              (if (and empty-field
                       (memq 'required-fields format)
                       (assoc-string field-name req-field-list t))
                  (error "Mandatory field `%s' is empty" field-name))

              ;; unify case of field name
              (if (memq 'unify-case format)
                  (let ((fname (car (assoc-string field-name
                                                  default-field-list t))))
                    (if fname
                        (progn
                          (delete-region beg-name end-name)
                          (goto-char beg-name)
                          (insert fname))

              ;; update point
              (goto-char end-field))))

        ;; check whether all required fields are present
        (if (memq 'required-fields format)
            (let ((found 0) alt-list)
              (dolist (fname req-field-list)
                (cond ((nth 3 fname) ; t if field has alternative flag
                       (push (car fname) alt-list)
                       (if (member-ignore-case (car fname) field-list)
                           (setq found (1+ found))))
                      ((not (member-ignore-case (car fname) field-list))
                       (error "Mandatory field `%s' is missing" (car fname)))))
              (if alt-list
                  (cond ((= found 0)
                         (error "Alternative mandatory field `%s' is missing"
                                alt-list))
                        ((> found 1)
                         (error "Alternative fields `%s' are defined %s times"
                                alt-list found))))))

        ;; update comma after last field
        (if (memq 'last-comma format)
            (cond ((and bibtex-comma-after-last-field
                        (not (looking-at ",")))

        (when (memq 'delimiters format)
          (skip-chars-forward " \t\n")
          (delete-char 1)
          (insert (bibtex-entry-right-delimiter)))

        ;; realign and fill entry
        (if (memq 'realign format)
            (bibtex-fill-entry))))))

(defun bibtex-field-re-init (regexp-alist type)
  "Calculate optimized value for bibtex-regexp-TYPE-opt.

  "Return global key alist based on `bibtex-files'."
  (if bibtex-files
      (apply 'append
             (mapcar (lambda (buf)
                       (with-current-buffer buf bibtex-reference-keys))
                     (bibtex-initialize t)))
    bibtex-reference-keys))

(defun bibtex-read-key (prompt &optional key global)
  "Read BibTeX key from minibuffer using PROMPT and default KEY.
If optional arg GLOBAL is non-nil, completion is based on the keys in

                  ;; remember that parsing was successful
                  (setq bibtex-buffer-last-parsed-tick (buffer-modified-tick)))))
        (setq buffers (cdr buffers))))))

;;;###autoload
(defun bibtex-initialize (&optional current force select)
  "(Re)Initialize BibTeX buffers.
Visit the BibTeX files defined by `bibtex-files' and return a list
of corresponding buffers.
Initialize in these buffers `bibtex-reference-keys' if not yet set.
List of BibTeX buffers includes current buffer if CURRENT is non-nil.
If FORCE is non-nil, (re)initialize `bibtex-reference-keys' even if
already set.  If SELECT is non-nil interactively select a BibTeX buffer.
When called interactively, FORCE is t, CURRENT is t if current buffer uses
`bibtex-mode', and SELECT is t if current buffer does not use `bibtex-mode',"
  (interactive (list (eq major-mode 'bibtex-mode) t
                     (not (eq major-mode 'bibtex-mode))))
  (let ((file-path (split-string (or bibtex-file-path default-directory) ":+"))
        file-list dir-list buffer-list)
    ;; generate list of BibTeX files
    (dolist (file bibtex-files)
      (cond ((eq file 'bibtex-file-path)
             (setq dir-list (append dir-list file-path)))
            ((file-accessible-directory-p file)
             (push file dir-list))
            ((progn (unless (string-match "\\.bib\\'" file)
                      (setq file (concat file ".bib")))
                    (file-name-absolute-p file))
             (push file file-list))
            (t
             (let (expanded-file-name found)
               (dolist (dir file-path)
                 (when (file-readable-p
                        (setq expanded-file-name (expand-file-name file dir)))
                   (push expanded-file-name file-list)
                   (setq found t)))
               (unless found
                 (error "File `%s' not in paths defined via bibtex-file-path"
                        file))))))
    (dolist (file file-list)
      (unless (file-readable-p file)
        (error "BibTeX file `%s' not found" file)))
    ;; expand dir-list
    (dolist (dir dir-list)
      (setq file-list
            (append file-list (directory-files dir t "\\.bib\\'" t))))
    (delete-dups file-list)
    ;; visit files in FILE-LIST
    (dolist (file file-list)
      (if (file-readable-p file)
        (push (find-file-noselect file) buffer-list)))
    ;; include current buffer iff we want it
    (cond ((and current (not (memq (current-buffer) buffer-list)))
           (push (current-buffer) buffer-list))
          ((and (not current) (memq (current-buffer) buffer-list))
           (setq buffer-list (delq (current-buffer) buffer-list))))
    ;; parse keys
    (dolist (buffer buffer-list)
      (with-current-buffer buffer
        (if (or force (nlistp bibtex-reference-keys))
            (bibtex-parse-keys))))
    ;; select BibTeX buffer
    (if select
        (if buffer-list
            (switch-to-buffer
             (completing-read "Switch to BibTeX buffer: "
                              (mapcar 'buffer-name buffer-list)
                              nil t
                              (if current (buffer-name (current-buffer)))))
          (message "No BibTeX buffers defined")))
    buffer-list))

(defun bibtex-complete-internal (completions)
  "Complete word fragment before point to longest prefix of COMPLETIONS.
COMPLETIONS is an alist of strings.  If point is not after the part

entry.  For all empty fields of the current entry insert the corresponding
field contents of the neighboring entry.  Finally try to update the text
based on the difference between the keys of the neighboring and the current
entry (for example, the year parts of the keys)."
  (interactive)
  (bibtex-beginning-of-entry)
  (when (looking-at bibtex-entry-head)
    (let ((type (bibtex-type-in-head))
	  (key (bibtex-key-in-head))
	  (key-end (match-end bibtex-key-in-head))

The predicate depends on the variable `bibtex-maintain-sorted-entries'.
If its value is nil use plain sorting."
  (cond ((not index1) (not index2)) ; indices can be nil
        ((not index2) nil)
        ((eq bibtex-maintain-sorted-entries 'crossref)
         ;; CROSSREF-KEY may be nil or it can point to an entry
         ;; in another BibTeX file.  In both cases we ignore CROSSREF-KEY.
         (if (and (nth 1 index1)
                  (cdr (assoc-string (nth 1 index1) bibtex-reference-keys)))
             (if (and (nth 1 index2)
                      (cdr (assoc-string (nth 1 index2) bibtex-reference-keys)))
                 (or (string-lessp (nth 1 index1) (nth 1 index2))
                     (and (string-equal (nth 1 index1) (nth 1 index2))
                          (string-lessp (nth 0 index1) (nth 0 index2))))
               (not (string-lessp (nth 0 index2) (nth 1 index1))))
           (if (and (nth 1 index2)
                    (cdr (assoc-string (nth 1 index2) bibtex-reference-keys)))
               (string-lessp (nth 0 index1) (nth 1 index2))
             (string-lessp (nth 0 index1) (nth 0 index2)))))
        ((eq bibtex-maintain-sorted-entries 'entry-class)
         (let ((n1 (cdr (or (assoc (nth 2 index1) bibtex-sort-entry-class-alist)
                            (assoc 'catch-all bibtex-sort-entry-class-alist)

affected.  If `bibtex-sort-ignore-string-entries' is non-nil, @String entries
are ignored."
  (interactive)
  (bibtex-beginning-of-first-entry)     ; Needed by `sort-subr'
  (bibtex-init-sort-entry-class-alist)  ; Needed by `bibtex-lessp'.
  (if (and (eq bibtex-maintain-sorted-entries 'crossref)
           (nlistp bibtex-reference-keys))
      (bibtex-parse-keys))              ; Needed by `bibtex-lessp'.
  (sort-subr nil
             'bibtex-skip-to-valid-entry   ; NEXTREC function
             'bibtex-end-of-entry          ; ENDREC function
             'bibtex-entry-index           ; STARTKEY function
             nil                           ; ENDKEY function

If DISPLAY is non-nil, display the buffer containing KEY.
Otherwise, use `set-buffer'.  DISPLAY is t when called interactively."
  (interactive (list (bibtex-read-key "Find key: " nil current-prefix-arg)
                     current-prefix-arg nil t))
  (if (and global bibtex-files)
      (let ((buffer-list (bibtex-initialize t))
            buffer found)
        (while (and (not found)
                    (setq buffer (pop buffer-list)))
          (with-current-buffer buffer
            (if (cdr (assoc-string key bibtex-reference-keys))

If `bibtex-maintain-sorted-entries' is non-nil, perform a binary
search to look for place for KEY.  This requires that buffer is sorted,
see `bibtex-validate'.
Return t if preparation was successful or nil if entry KEY already exists."
  (bibtex-init-sort-entry-class-alist)  ; Needed by `bibtex-lessp'.
  (if (and (eq bibtex-maintain-sorted-entries 'crossref)
           (nlistp bibtex-reference-keys))
      (bibtex-parse-keys))              ; Needed by `bibtex-lessp'.
  (let ((key (nth 0 index))
        key-exist)
    (cond ((or (null key)
               (and (stringp key)
                    (string-equal key ""))

        (if error-list
            ;; Continue only if there were no syntax errors.
            (setq syntax-error t)

          ;; Check for duplicate keys and correct sort order
          (bibtex-init-sort-entry-class-alist)  ; Needed by `bibtex-lessp'.
          (bibtex-parse-keys) ; Possibly needed by `bibtex-lessp'.
                              ; Always needed by subsequent global key check.
          (let (previous current key-list)
            (bibtex-progress-message "Checking for duplicate keys")
            (bibtex-map-entries
             (lambda (key beg end)
               (bibtex-progress-message)

               (push key key-list)
               (setq previous current)))
            (bibtex-progress-message 'done))

          ;; Check for duplicate keys in `bibtex-files'.
          ;; `bibtex-validate' only compares keys in current buffer with keys
          ;; in `bibtex-files'. `bibtex-validate-globally' compares keys for
          ;; each file in `bibtex-files' with keys of all other files in
          ;; `bibtex-files'.
          ;; We don't want to be fooled by outdated `bibtex-reference-keys'.
          (dolist (buffer (bibtex-initialize nil t))
            (dolist (key (with-current-buffer buffer bibtex-reference-keys))
              (when (and (cdr key)
                         (cdr (assoc-string (car key) bibtex-reference-keys)))
                (bibtex-find-entry (car key))
                (push (cons (bibtex-current-line)

(defun bibtex-validate-globally (&optional strings)
  "Check for duplicate keys in `bibtex-files'.
With optional prefix arg STRINGS, check for duplicate strings, too.
Return t if test was successful, nil otherwise."
  (interactive "P")
  (let ((buffer-list (bibtex-initialize t))
        buffer-key-list current-buf current-keys error-list)
    ;; Check for duplicate keys within BibTeX buffer
    (dolist (buffer buffer-list)
      (save-excursion
        (set-buffer buffer)

        (start (bibtex-beginning-of-entry))
        (_ (or (looking-at bibtex-any-entry-maybe-empty-head)
	       (error "Not inside a BibTeX entry")))
        (entry-type (bibtex-type-in-head))
        (key (bibtex-key-in-head)))
    ;; formatting (undone if error occurs)
    (atomic-change-group
      (cond ((bibtex-string= entry-type "preamble")
             ;; (bibtex-format-preamble)
             (error "No clean up of @Preamble entries"))
            ((bibtex-string= entry-type "string")
             (setq entry-type 'string))
             ;; (bibtex-format-string)
            (t (bibtex-format-entry))))
    ;; set key
    (when (or new-key (not key))
      (setq key (bibtex-generate-autokey))
      ;; Sometimes `bibtex-generate-autokey' returns an empty string
      (if (or bibtex-autokey-edit-before-use (string= "" key))

          (bibtex-find-entry key)
          (setq error (or (/= (point) start)
                          (bibtex-find-entry key nil end))))
        (if error
            (error "New inserted entry yields duplicate key"))
        (dolist (buffer (bibtex-initialize))
          (with-current-buffer buffer
            (if (cdr (assoc-string key bibtex-reference-keys))
                (error "Duplicate key in %s" (buffer-file-name)))))

        ;; Only update the list of keys if it has been built already.