emacs: lisp/textmodes/bibtex.el comparison

comparison lisp/textmodes/bibtex.el @ 89978:566253900690

Revision: miles@gnu.org--gnu-2004/emacs--unicode--0--patch-40 Merge from emacs--cvs-trunk--0 Patches applied: * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-535 Update from CVS * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-536 sync-tree with gnus--rel--5.10 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-537 - miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-538 Update from CVS * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-539 Merge from gnus--rel--5.10 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-540 Update from CVS * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-541 Merge from gnus--rel--5.10 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-542 - miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-545 Update from CVS * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-546 Merge from gnus--rel--5.10 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-547 - miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-548 Update from CVS * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-549 Use symbol-matching for generic-mode keywords * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-550 Update from CVS * miles@gnu.org--gnu-2004/gnus--devo--0--patch-2 Add {arch}/=cvs-sync-make-log * miles@gnu.org--gnu-2004/gnus--rel--5.8--base-0 Import from Gnus CVS branch V5-8 * miles@gnu.org--gnu-2004/gnus--rel--5.8--patch-1 {arch}/=tagging-method: Add CVS and autoconf grot to junk regexp * miles@gnu.org--gnu-2004/gnus--rel--5.8--patch-2 Use explicit tags for autoconf input files * miles@gnu.org--gnu-2004/gnus--rel--5.8--patch-3 Remove RCS keywords * miles@gnu.org--gnu-2004/gnus--rel--5.8--patch-4 Fix copied explicit id-tags * miles@gnu.org--gnu-2004/gnus--rel--5.8--patch-5 Add {arch}/=cvs-sync-make-log * miles@gnu.org--gnu-2004/gnus--rel--5.8--patch-6 configure.in: Use ifelse instead of m4_if for arch-tag: comment * miles@gnu.org--gnu-2004/gnus--rel--5.10--base-0 tag of miles@gnu.org--gnu-2004/gnus--rel--5.8--base-0 * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-1 Gnus 5.10, from CVS branch v5-10 * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-2 Merge from gnus--rel--5.8 * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-3 Use explicit tags for autoconf input files * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-4 sync-tree with gnus--rel--5.8 * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-5 Update from CVS * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-6 Merge from gnus--rel--5.8 * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-7 Remove RCS keywords * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-8 Merge from gnus--rel--5.8 * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-9 Update from CVS * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-10 Add {arch}/=cvs-sync-make-log * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-11 Merge from gnus--rel--5.8 * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-12 Update from CVS: make.bat: Fix line endings around arch-tag. * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-13 - miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-17 Update from CVS * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-21 Merge from emacs--cvs-trunk--0 * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-22 Update from CVS: lisp/nndb.el (require): Remove tcp and duplicate cl. * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-23 Update from CVS * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-24 lisp/nnimap.el (nnimap-open-connection): Remove extraneous end-paren * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-25 - miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-26 Update from CVS

author	Miles Bader <miles@gnu.org>
date	Wed, 15 Sep 2004 09:00:10 +0000
parents	4c90ffeb71c5 3d9707888790
children	e24e2e78deda

comparison

equal deleted inserted replaced

-:549fdd6f6856
+:566253900690
 ;;; bibtex.el --- BibTeX mode for GNU Emacs
-;; Copyright (C) 1992,94,95,96,97,98,1999,2003,2004
+;; Copyright (C) 1992, 1994, 1995, 1996, 1997, 1998, 1999, 2003, 2004
 ;;           Free Software Foundation, Inc.
 ;; Author: Stefan Schoef <schoef@offis.uni-oldenburg.de>
 ;;      Bengt Martensson <bengt@mathematik.uni-Bremen.de>
 ;;      Mark Shapiro <shapiro@corto.inria.fr>
 "List of functions to call on entry to BibTeX mode."
 :group 'bibtex
 :type 'hook)
 (defcustom bibtex-field-delimiters 'braces
-"*Type of field delimiters. Allowed values are `braces' or `double-quotes'."
+"*Type of field delimiters.  Allowed values are `braces' or `double-quotes'."
 :group 'bibtex
 :type '(choice (const braces)
 (const double-quotes)))
 (defcustom bibtex-entry-delimiters 'braces
-"*Type of entry delimiters. Allowed values are `braces' or `parentheses'."
+"*Type of entry delimiters.  Allowed values are `braces' or `parentheses'."
 :group 'bibtex
 :type '(choice (const braces)
 (const parentheses)))
 (defcustom bibtex-include-OPTcrossref '("InProceedings" "InCollection")
 (defcustom bibtex-maintain-sorted-entries nil
 "*If non-nil, BibTeX mode maintains all BibTeX entries in sorted order.
 Allowed non-nil values are:
 plain        All entries are sorted alphabetically.
 crossref     All entries are sorted alphabetically unless an entry has a
-crossref field. These crossrefed entries are placed in
+crossref field.  These crossrefed entries are placed in
 alphabetical order immediately preceding the main entry.
 entry-class  The entries are divided into classes according to their
-entry name, see `bibtex-sort-entry-class'. Within each class
+entry name, see `bibtex-sort-entry-class'.  Within each class
 the entries are sorted alphabetically.
 See also `bibtex-sort-ignore-string-entries'."
 :group 'bibtex
 :type '(choice (const nil)
 (const plain)
 '(("String")
 (catch-all)
 ("Book" "Proceedings"))
 "*List of classes of BibTeX entry names, used for sorting entries.
 If value of `bibtex-maintain-sorted-entries' is `entry-class'
-entries are ordered according to the classes they belong to. Each
+entries are ordered according to the classes they belong to.  Each
-class contains a list of entry names. An entry `catch-all' applies
+class contains a list of entry names.  An entry `catch-all' applies
 to all entries not explicitely mentioned.")
 (defcustom bibtex-sort-ignore-string-entries t
 "*If non-nil, BibTeX @String entries are not sort-significant.
 That means they are ignored when determining ordering of the buffer
 :group 'bibtex-autokey
 :type 'integer)
 (defcustom bibtex-autokey-titleword-ignore
 '("A" "An" "On" "The" "Eine?" "Der" "Die" "Das"
-"[^A-Z].*" ".*[^a-zA-Z0-9].*")
+"[^A-Z].*" ".*[^A-Z0-9].*")
 "*Determines words from the title that are not to be used in the key.
 Each item of the list is a regexp.  If a word of the title matchs a
 regexp from that list, it is not included in the title part of the key.
 See `bibtex-generate-autokey' for details."
 :group 'bibtex-autokey
 (defcustom bibtex-autofill-types '("Proceedings")
 "Automatically fill fields if possible for those BibTeX entry types."
 :type '(repeat string))
-(defcustom bibtex-complete-key-cleanup nil
+(defcustom bibtex-generate-url-list
-"*Function called by `bibtex-complete' after insertion of a key fragment."
+'((("url" . ".*:.*"))
-:group 'bibtex-autokey
+;; Example of a complex setup.
-:type '(choice (const :tag "None" nil)
+(("journal" . "\\<\\(PR[ABCDEL]?\\|RMP\\)\\>")
-(function :tag "Cleanup function")))
+"http://publish.aps.org/abstract/"
+("journal" ".*" downcase)
+"/v"
+("volume" ".*" 0)
+"/p"
+("pages" "\\`\\([0-9]+\\)" 1)))
+"List of schemes for generating the URL of a BibTeX entry.
+These schemes are used by `bibtex-url'.
+Each scheme is of the form ((FIELD . REGEXP) STEP...).
+FIELD is a field name as returned by `bibtex-parse-entry'.
+REGEXP is matched against the text of FIELD.  If the match succeed, then
+this scheme will be used.  If no STEPS are specified the matched text is used
+as the URL, otherwise the URL is built by concatenating the STEPS.
+A STEP can be a string or a list (FIELD REGEXP REPLACE) in which case
+the text of FIELD is matched against REGEXP, and is replaced with REPLACE.
+REPLACE can be a string, or a number (which selects the corresponding submatch)
+or a function called with the field's text as argument and with the
+`match-data' properly set.
+Case is always ignored.  Always remove the field delimiters."
+:group 'bibtex
+:type '(repeat
+(list :tag "Scheme"
+(cons :tag "Matcher" :extra-offset 4
+(string :tag "BibTeX field")
+		      (regexp :tag "Regexp"))
+(repeat :tag "Steps to generate URL" :inline t
+(choice
+(string :tag "Literal text")
+(list (string :tag "BibTeX field")
+			       (regexp :tag "Regexp")
+(choice (string :tag "Replacement")
+				       (integer :tag "Sub-match")
+				       (function :tag "Filter"))))))))
 ;; bibtex-font-lock-keywords is a user option as well, but since the
 ;; patterns used to define this variable are defined in a later
 ;; section of this file, it is defined later.
 (define-key km "\C-c\"" 'bibtex-remove-delimiters)
 (define-key km "\C-c{" 'bibtex-remove-delimiters)
 (define-key km "\C-c}" 'bibtex-remove-delimiters)
 (define-key km "\C-c\C-c" 'bibtex-clean-entry)
 (define-key km "\C-c\C-q" 'bibtex-fill-entry)
+(define-key km "\C-c\C-s" 'bibtex-find-entry)
 (define-key km "\C-c?" 'bibtex-print-help-message)
 (define-key km "\C-c\C-p" 'bibtex-pop-previous)
 (define-key km "\C-c\C-n" 'bibtex-pop-next)
 (define-key km "\C-c\C-k" 'bibtex-kill-field)
 (define-key km "\C-c\M-k" 'bibtex-copy-field-as-kill)
 (define-key km "\C-\M-l" 'bibtex-reposition-window)
 (define-key km "\C-\M-h" 'bibtex-mark-entry)
 (define-key km "\C-c\C-b" 'bibtex-entry)
 (define-key km "\C-c\C-rn" 'bibtex-narrow-to-entry)
 (define-key km "\C-c\C-rw" 'widen)
+(define-key km "\C-c\C-l" 'bibtex-url)
 (define-key km "\C-c\C-o" 'bibtex-remove-OPT-or-ALT)
 (define-key km "\C-c\C-e\C-i" 'bibtex-InProceedings)
 (define-key km "\C-c\C-ei" 'bibtex-InCollection)
 (define-key km "\C-c\C-eI" 'bibtex-InBook)
 (define-key km "\C-c\C-e\C-a" 'bibtex-Article)
 ["Beginning of Entry" bibtex-beginning-of-entry t]
 ["End of Entry" bibtex-end-of-entry t])
 ("Moving in BibTeX Buffer"
 ["Find Entry" bibtex-find-entry t]
 ["Find Crossref Entry" bibtex-find-crossref t])
-("Operating on Current Entry"
-["Fill Entry" bibtex-fill-entry t]
-["Clean Entry" bibtex-clean-entry t]
 "--"
-["Kill Entry" bibtex-kill-entry t]
-["Copy Entry to Kill Ring" bibtex-copy-entry-as-kill t]
-["Paste Most Recently Killed Entry" bibtex-yank t]
-["Paste Previously Killed Entry" bibtex-yank-pop t]
-"--"
-["Ispell Entry" bibtex-ispell-entry t]
-["Ispell Entry Abstract" bibtex-ispell-abstract t]
-["Narrow to Entry" bibtex-narrow-to-entry t]
-"--"
-["View Cite Locations (RefTeX)" reftex-view-crossref-from-bibtex
-(fboundp 'reftex-view-crossref-from-bibtex)])
 ("Operating on Current Field"
 ["Fill Field" fill-paragraph t]
 ["Remove Delimiters" bibtex-remove-delimiters t]
 ["Remove OPT or ALT Prefix" bibtex-remove-OPT-or-ALT t]
 ["Clear Field" bibtex-empty-field t]
 ["Snatch from Similar Preceding Field" bibtex-pop-previous t]
 "--"
 ["String or Key Complete" bibtex-complete t]
 "--"
 ["Help about Current Field" bibtex-print-help-message t])
+("Operating on Current Entry"
+["Fill Entry" bibtex-fill-entry t]
+["Clean Entry" bibtex-clean-entry t]
+["Update Entry" bibtex-entry-update t]
+"--"
+["Kill Entry" bibtex-kill-entry t]
+["Copy Entry to Kill Ring" bibtex-copy-entry-as-kill t]
+["Paste Most Recently Killed Entry" bibtex-yank t]
+["Paste Previously Killed Entry" bibtex-yank-pop t]
+"--"
+["Ispell Entry" bibtex-ispell-entry t]
+["Ispell Entry Abstract" bibtex-ispell-abstract t]
+["Narrow to Entry" bibtex-narrow-to-entry t]
+"--"
+["View Cite Locations (RefTeX)" reftex-view-crossref-from-bibtex
+(fboundp 'reftex-view-crossref-from-bibtex)])
 ("Operating on Buffer or Region"
 ["Validate Entries" bibtex-validate t]
 ["Sort Entries" bibtex-sort-buffer t]
 ["Reformat Entries" bibtex-reformat t]
-["Count Entries" bibtex-count-entries t])
+["Count Entries" bibtex-count-entries t]
-("Miscellaneous"
+"--"
 ["Convert Alien Buffer" bibtex-convert-alien t])))
 (easy-menu-define
 bibtex-entry-menu bibtex-mode-map "Entry-Types Menu in BibTeX mode"
 (list "Entry-Types"
 ["Unpublished" bibtex-Unpublished t]
 ["Miscellaneous" bibtex-Misc t]
 ["String" bibtex-String t]
 ["Preamble" bibtex-Preamble t]))
+(defvar bibtex-url-map
+(let ((km (make-sparse-keymap)))
+(define-key km [(mouse-2)] 'bibtex-url)
+km)
+"Local keymap for clickable URLs.")
+(fset 'bibtex-url-map bibtex-url-map)
 ;; Internal Variables
 (defvar bibtex-pop-previous-search-point nil
 "Next point where `bibtex-pop-previous' starts looking for a similar entry.")
 (lazy-completion-table bibtex-reference-keys bibtex-parse-keys nil nil t)
 "Completion table for BibTeX reference keys.")
 (make-variable-buffer-local 'bibtex-reference-keys)
 (defvar bibtex-buffer-last-parsed-tick nil
-"Last value returned by `buffer-modified-tick' when buffer
+"Value of `buffer-modified-tick' last time buffer was parsed for keys.")
-was parsed for keys the last time.")
 (defvar bibtex-parse-idle-timer nil
 "Stores if timer is already installed.")
 (defvar bibtex-progress-lastperc nil
 (defconst bibtex-empty-field-re "\"\"\\|{}"
 "Regexp matching an empty field.")
-(defconst bibtex-quoted-string-re
-(concat "\""
-"\\("
-"[^\"\\]"          ; anything but quote or backslash
-"\\|"
-"\\("
-"\\\\\\(.\\|\n\\)" ; any backslash quoted character
-"\\)"
-"\\)*"
-"\"")
-"Regexp matching a field string enclosed by quotes.")
 (defconst bibtex-font-lock-syntactic-keywords
 `((,(concat "^[ \t]*\\(" (substring bibtex-comment-start 0 1) "\\)"
 (substring bibtex-comment-start 1) "\\>")
 1 '(11))))
 (defvar bibtex-font-lock-keywords
-(list
+;; entry type and reference key
-;; entry type and reference key
+`((,bibtex-entry-maybe-empty-head
-(list bibtex-entry-maybe-empty-head
+(,bibtex-type-in-head font-lock-function-name-face)
-(list bibtex-type-in-head 'font-lock-function-name-face)
+(,bibtex-key-in-head font-lock-constant-face nil t))
-(list bibtex-key-in-head 'font-lock-constant-face nil t))
+;; optional field names (treated as comments)
-;; optional field names (treated as comments)
+(,(concat "^[ \t]*\\(OPT" bibtex-field-name "\\)[ \t]*=")
-(list
+1 font-lock-comment-face)
-(concat "^[ \t]*\\(OPT" bibtex-field-name "\\)[ \t]*=")
+;; field names
-1 'font-lock-comment-face)
+(,(concat "^[ \t]*\\(" bibtex-field-name "\\)[ \t]*=")
-;; field names
+1 font-lock-variable-name-face)
-(list (concat "^[ \t]*\\(" bibtex-field-name "\\)[ \t]*=")
+;; url
-1 'font-lock-variable-name-face))
+(bibtex-font-lock-url 0 '(face nil mouse-face highlight
+keymap bibtex-url-map)))
 "*Default expressions to highlight in BibTeX mode.")
+(defvar bibtex-font-lock-url-regexp
+(concat "\\<" (regexp-opt (mapcar 'caar bibtex-generate-url-list) t)
+"\\>[ \t]*=[ \t]*")
+"Regexp for `bibtex-font-lock-url'.")
 (defvar bibtex-field-name-for-parsing nil
-"Temporary variable storing the name string to be parsed by the callback
+"Regexp of field name to be parsed by function `bibtex-parse-field-name'.
-function `bibtex-parse-field-name'.")
+Passed by dynamic scoping.")
 (defvar bibtex-sort-entry-class-alist
 (let ((i -1) alist)
 (dolist (class bibtex-sort-entry-class alist)
 (setq i (1+ i))
 (dolist (entry class)
 ;; all entry names should be downcase (for ease of comparison)
 (push (cons (if (stringp entry) (downcase entry) entry) i) alist))))
-"Alist for the classes of the entry types if the value of
+"Alist mapping entry types to their sorting index.
-`bibtex-maintain-sorted-entries' is `entry-class'.")
+Auto-generated from `bibtex-sort-entry-class'.
+Used when `bibtex-maintain-sorted-entries' is `entry-class'.")
 ;; Special support taking care of variants
 (defvar zmacs-regions)
-(if (boundp 'mark-active)
+(defalias 'bibtex-mark-active
-(defun bibtex-mark-active ()
+(if (boundp 'mark-active)
 ;; In Emacs mark-active indicates if mark is active.
-mark-active)
+(lambda () mark-active)
-(defun bibtex-mark-active ()
 ;; In XEmacs (mark) returns nil when not active.
-(if zmacs-regions (mark) (mark t))))
+(lambda () (if zmacs-regions (mark) (mark t)))))
-(if (fboundp 'run-with-idle-timer)
+(defalias 'bibtex-run-with-idle-timer
-;; timer.el is distributed with Emacs
+(if (fboundp 'run-with-idle-timer)
-(fset 'bibtex-run-with-idle-timer 'run-with-idle-timer)
+;; timer.el is distributed with Emacs
-;; timer.el is not distributed with XEmacs
+'run-with-idle-timer
-;; Notice that this does not (yet) pass the arguments, but they
+;; timer.el is not distributed with XEmacs
-;; are not used (yet) in bibtex.el. Fix if needed.
+;; Notice that this does not (yet) pass the arguments, but they
-(defun bibtex-run-with-idle-timer (secs repeat function &rest args)
+;; are not used (yet) in bibtex.el. Fix if needed.
-(start-itimer "bibtex" function secs (if repeat secs nil) t)))
+(lambda (secs repeat function &rest args)
+(start-itimer "bibtex" function secs (if repeat secs nil) t))))
 ;; Support for hideshow minor mode
 (defun bibtex-hs-forward-sexp (arg)
-"Replacement for `forward-sexp' to be used by `hs-minor-mode'."
+"Replacement for `forward-sexp' to be used by `hs-minor-mode'.
-(if (< arg 0)
+ARG is ignored."
-(backward-sexp 1)
+(if (looking-at "@\\S(*\\s(")
-(if (looking-at "@\\S(*\\s(")
+(goto-char (1- (match-end 0))))
-(progn
+(forward-sexp 1))
-(goto-char (match-end 0))
-(forward-char -1)
-(forward-sexp 1))
-(forward-sexp 1))))
 (add-to-list
 'hs-special-modes-alist
 '(bibtex-mode "@\\S(*\\s(" "\\s)" nil bibtex-hs-forward-sexp nil))
 (defun bibtex-parse-field-name ()
 "Parse the field name stored in `bibtex-field-name-for-parsing'.
 If the field name is found, return a triple consisting of the position of the
 very first character of the match, the actual starting position of the name
-part and end position of the match. Move point to end of field name.
+part and end position of the match.  Move point to end of field name.
 If `bibtex-autoadd-commas' is non-nil add missing comma at end of preceeding
 BibTeX field as necessary."
 (cond ((looking-at ",[ \t\n]*")
 (let ((start (point)))
 (goto-char (match-end 0))
 (defun bibtex-parse-field-text ()
 "Parse the text part of a BibTeX field.
 The text part is either a string, or an empty string, or a constant followed
 by one or more <# (string|constant)> pairs.  If a syntactically correct text
 is found, a pair containing the start and end position of the text is
-returned, nil otherwise. Move point to end of field text."
+returned, nil otherwise.  Move point to end of field text."
 (let ((starting-point (point))
 end-point failure boundaries)
 (while (not (or end-point failure))
 (cond ((looking-at bibtex-field-const)
 (goto-char (match-end 0)))
 ((setq boundaries (bibtex-parse-field-string))
 (goto-char (cdr boundaries)))
 ((setq failure t)))
-(if (not (looking-at "[ \t\n]*#[ \t\n]*"))
+(if (looking-at "[ \t\n]*#[ \t\n]*")
-(setq end-point (point))
+(goto-char (match-end 0))
-(goto-char (match-end 0))))
+(setq end-point (point))))
 (if (and (not failure)
 end-point)
 (cons starting-point end-point))))
 (defun bibtex-parse-field (name)
 (defun bibtex-search-forward-field (name &optional bound)
 "Search forward to find a field of name NAME.
 If a syntactically correct field is found, a pair containing the boundaries of
 the name and text parts of the field is returned.  The search is limited by
-optional arg BOUND. If BOUND is t the search is limited by the end of the current
+optional arg BOUND.  If BOUND is t the search is limited by the end of the
-entry. Do not move point."
+current entry.  Do not move point."
 (save-match-data
 (save-excursion
 (unless (integer-or-marker-p bound)
 (setq bound (if bound
 (save-excursion (bibtex-end-of-entry))
 (defun bibtex-search-backward-field (name &optional bound)
 "Search backward to find a field of name NAME.
 If a syntactically correct field is found, a pair containing the boundaries of
 the name and text parts of the field is returned.  The search is limited by
-optional arg BOUND. If BOUND is t the search is limited by the beginning of the
+optional arg BOUND.  If BOUND is t the search is limited by the beginning of the
-current entry. Do not move point."
+current entry.  Do not move point."
 (save-match-data
 (save-excursion
 (unless (integer-or-marker-p bound)
 (setq bound (if bound
 (save-excursion (bibtex-beginning-of-entry))
 (defsubst bibtex-start-of-text-in-field (bounds)
 (cadr bounds))
 (defsubst bibtex-end-of-text-in-field (bounds)
 (cddr bounds))
-(defun bibtex-name-in-field (bounds)
+(defun bibtex-name-in-field (bounds &optional remove-opt-alt)
-"Get content of name in BibTeX field defined via BOUNDS."
+"Get content of name in BibTeX field defined via BOUNDS.
-(buffer-substring-no-properties (nth 1 (car bounds))
+If optional arg REMOVE-OPT-ALT is non-nil remove \"OPT\" and \"ALT\"."
-(nth 2 (car bounds))))
+(let ((name (buffer-substring-no-properties (nth 1 (car bounds))
+(nth 2 (car bounds)))))
+(if (and remove-opt-alt
+(string-match "\\`\\(OPT\\|ALT\\)" name))
+(substring name 3)
+name)))
 (defun bibtex-text-in-field-bounds (bounds &optional remove-delim)
 "Get content of text in BibTeX field defined via BOUNDS.
 If optional arg REMOVE-DELIM is non-nil remove enclosing field delimiters
 if present."
 (string-match "\\`[{\"]\\(.*\\)[}\"]\\'" content))
 (substring content (match-beginning 1) (match-end 1))
 content)))
 (defun bibtex-text-in-field (field &optional follow-crossref)
-"Get content of field FIELD of current BibTeX entry. Return nil if not found.
+"Get content of field FIELD of current BibTeX entry.  Return nil if not found.
 If optional arg FOLLOW-CROSSREF is non-nil, follow crossref."
 (save-excursion
 (save-restriction
 ;; We want to jump back and forth while searching FIELD
 (bibtex-narrow-to-entry)
 (defun bibtex-parse-string-postfix ()
 "Parse the postfix part of a BibTeX string entry, including the text.
 If the string postfix is found, return a triple consisting of the position of
 the actual starting and ending position of the text and the very last
-character of the string entry. Move point past BibTeX string entry."
+character of the string entry.  Move point past BibTeX string entry."
 (let* ((case-fold-search t)
 (bounds (bibtex-parse-field-text)))
 (when bounds
 (goto-char (cdr bounds))
 (when (looking-at "[ \t\n]*[})]")
 'bibtex-parse-string-postfix))
 (defun bibtex-search-forward-string ()
 "Search forward to find a BibTeX string entry.
 If a syntactically correct entry is found, a pair containing the boundaries of
-the reference key and text parts of the string is returned. Do not move point."
+the reference key and text parts of the string is returned.  Do not move point."
 (save-excursion
 (save-match-data
 (let ((case-fold-search t)
 boundaries)
 (while (and (not boundaries)
 boundaries))))
 (defun bibtex-search-backward-string ()
 "Search backward to find a BibTeX string entry.
 If a syntactically correct entry is found, a pair containing the boundaries of
-the reference key and text parts of the field is returned. Do not move point."
+the reference key and text parts of the field is returned.  Do not move point."
 (save-excursion
 (save-match-data
 (let ((case-fold-search t)
 boundaries)
 (while (and (not boundaries)
 ;;                              ignore @
 (buffer-substring-no-properties (1+ (match-beginning bibtex-type-in-head))
 (match-end bibtex-type-in-head)))
 (defun bibtex-key-in-head (&optional empty)
-"Extract BibTeX key in head. Return optional arg EMPTY if key is empty."
+"Extract BibTeX key in head.  Return optional arg EMPTY if key is empty."
 (if (match-beginning bibtex-key-in-head)
 (buffer-substring-no-properties (match-beginning bibtex-key-in-head)
 (match-end bibtex-key-in-head))
 empty))
 ;; Helper Functions
+(defsubst bibtex-string= (str1 str2)
+"Return t if STR1 and STR2 are equal, ignoring case."
+(eq t (compare-strings str1 0 nil str2 0 nil t)))
 (defun bibtex-delete-whitespace ()
 "Delete all whitespace starting at point."
 (if (looking-at "[ \t\n]+")
 (delete-region (point) (match-end 0))))
 (defun bibtex-current-line ()
 "Compute line number of point regardless whether the buffer is narrowed."
 (+ (count-lines 1 (point))
 (if (equal (current-column) 0) 1 0)))
-(defun bibtex-member-of-regexp (string list)
-"Return non-nil if STRING is exactly matched by an element of LIST.
-The value is actually the tail of LIST whose car matches STRING."
-(let (case-fold-search)
-(while (and list
-(not (string-match (concat "\\`\\(?:" (car list) "\\)\\'") string)))
-(setq list (cdr list)))
-list))
 (defun bibtex-skip-to-valid-entry (&optional backward)
-"Unless at beginning of a valid BibTeX entry, move point to beginning of the
+"Move point to beginning of the next valid BibTeX entry.
-next valid one. With optional argument BACKWARD non-nil, move backward to
+Do not move if we are already at beginning of a valid BibTeX entry.
-beginning of previous valid one. A valid entry is a syntactical correct one
+With optional argument BACKWARD non-nil, move backward to
+beginning of previous valid one.  A valid entry is a syntactical correct one
 with type contained in `bibtex-entry-field-alist' or, if
 `bibtex-sort-ignore-string-entries' is nil, a syntactical correct string
-entry. Return buffer position of beginning and ending of entry if a valid
+entry.  Return buffer position of beginning and ending of entry if a valid
 entry is found, nil otherwise."
 (interactive "P")
 (let ((case-fold-search t)
 found)
 (while (not (or found (if backward (bobp) (eobp))))
 (forward-char -1))))))
 found))
 (defun bibtex-map-entries (fun)
 "Call FUN for each BibTeX entry starting with the current.
-Do this to the end of the file. FUN is called with three arguments, the key of
+Do this to the end of the file.  FUN is called with three arguments, the key of
 the entry and the buffer positions (marker) of beginning and end of entry.
-Point is inside the entry. If `bibtex-sort-ignore-string-entries' is non-nil,
+Point is inside the entry.  If `bibtex-sort-ignore-string-entries' is non-nil,
 FUN will not be called for @String entries."
 (let ((case-fold-search t))
 (bibtex-beginning-of-entry)
 (while (re-search-forward bibtex-entry-head nil t)
 (let ((entry-type (bibtex-type-in-head))
 (key (bibtex-key-in-head ""))
 (beg (copy-marker (match-beginning 0)))
 (end (copy-marker (save-excursion (bibtex-end-of-entry)))))
 (save-excursion
 (if (or (and (not bibtex-sort-ignore-string-entries)
-(string-equal "string" (downcase entry-type)))
+(bibtex-string= entry-type "string"))
 (assoc-string entry-type bibtex-entry-field-alist t))
 (funcall fun key beg end)))
 (goto-char end)))))
 (defun bibtex-progress-message (&optional flag interval)
 "}"
 ")"))
 (defun bibtex-search-entry (empty-head &optional bound noerror backward)
 "Search for a BibTeX entry (maybe without reference key if EMPTY-HEAD is t).
-BOUND and NOERROR are exactly as in `re-search-forward'. If BACKWARD
+BOUND and NOERROR are exactly as in `re-search-forward'.  If BACKWARD
-is non-nil, search is done in reverse direction. Point is moved past the
+is non-nil, search is done in reverse direction.  Point is moved past the
 closing delimiter (at the beginning of entry if BACKWARD is non-nil).
 Return a cons pair with buffer positions of beginning and end of entry.
 After call to this function MATCH-BEGINNING and MATCH-END functions
 are defined, but only for the head part of the entry
 \(especially (match-end 0) just gives the end of the head part)."
 (re-search-backward entry-head-re bound noerror))
 (setq found (bibtex-search-entry empty-head pnt t)))
 (if found
 (progn (goto-char (match-beginning 0))
 found)
-(cond ((equal noerror nil)
+(cond ((not noerror)
 ;; yell
 (error "Backward search of BibTeX entry failed"))
 ((equal noerror t)
 ;; don't move
 (goto-char pnt)))
 (re-search-forward "^[ \t]*[@\n]" nil 'move)
 (backward-char 1)))
 (skip-chars-forward " \t\n")))
 (defun bibtex-beginning-of-first-entry ()
-"Go to the beginning of the first BibTeX entry in buffer. Return point."
+"Go to the beginning of the first BibTeX entry in buffer.  Return point."
 (goto-char (point-min))
 (if (re-search-forward "^[ \t]*@" nil 'move)
 (beginning-of-line))
 (point))
 (if (or (= (preceding-char) ?})
 (= (preceding-char) ?\"))
 (forward-char -1)))
 (defun bibtex-enclosing-field (&optional noerr)
-"Search for BibTeX field enclosing point. Point moves to end of field.
+"Search for BibTeX field enclosing point.
-Use `match-beginning' and `match-end' to parse the field. If NOERR is non-nil,
+Use `match-beginning' and `match-end' to parse the field.  If NOERR is non-nil,
-no error is signalled. In this case, bounds are returned on success,
+no error is signalled.  In this case, bounds are returned on success,
-nil otherwise."
+nil otherwise.  Does not move point."
 (let ((bounds (bibtex-search-backward-field bibtex-field-name t)))
 (if (and bounds
 (<= (bibtex-start-of-field bounds) (point))
 (>= (bibtex-end-of-field bounds) (point)))
 bounds
 (unless noerr
 (error "Can't find enclosing BibTeX field")))))
 (defun bibtex-enclosing-entry-maybe-empty-head ()
-"Search for BibTeX entry enclosing point. Move point to end of entry.
+"Search for BibTeX entry enclosing point.  Move point to end of entry.
 Beginning (but not end) of entry is given by (`match-beginning' 0)."
 (let ((case-fold-search t)
 (old-point (point)))
 (unless (re-search-backward bibtex-entry-maybe-empty-head nil t)
 (goto-char old-point)
 (forward-char)))
 (set-mark (point))
 (message "Mark set")
 (bibtex-make-field (list (elt current 1) nil (elt current 2)) t))
 ((equal bibtex-last-kill-command 'entry)
-(if (not (eobp))
+(unless (eobp) (bibtex-beginning-of-entry))
-(bibtex-beginning-of-entry))
 (set-mark (point))
 (message "Mark set")
 (insert (elt current 1)))
 (t
 (error "Unknown tag field: %s.  Please submit a bug report"
 bibtex-last-kill-command))))))
-(defun bibtex-assoc-regexp (regexp alist)
-"Return non-nil if REGEXP matches the car of an element of ALIST.
-The value is actually the element of ALIST matched by REGEXP.
-Case is ignored if `case-fold-search' is non-nil in the current buffer."
-(while (and alist
-(not (string-match regexp (caar alist))))
-(setq alist (cdr alist)))
-(car alist))
 (defun bibtex-format-entry ()
 "Helper function for `bibtex-clean-entry'.
 Formats current entry according to variable `bibtex-entry-format'."
 (save-excursion
 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-done field-list)
+entry-list req-field-list field-list)
 ;; identify entry type
 (goto-char (point-min))
 (re-search-forward bibtex-entry-type)
 (let ((beg-type (1+ (match-beginning 0)))
 ;; 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))
-(case-fold-search t)
+(field (assoc-string "crossref" fields-alist t)))
-(field (bibtex-assoc-regexp "\\`\\(OPT\\)?crossref\\'"
-fields-alist)))
 (setq crossref-key (and field
 (not (string-match bibtex-empty-field-re
 (cdr field)))
 (cdr field))
 req-field-list (if crossref-key
 (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 (bibtex-assoc-regexp
+field (assoc-string (car rfield) fields-alist t))
-(concat "\\`\\(ALT\\)?" (car rfield) "\\'")
-fields-alist))
 (if (and field
 (not (string-match bibtex-empty-field-re
 (cdr field))))
 (cond ((not non-empty-alternative)
 (setq non-empty-alternative t))
 (delete-char 1)
 (insert (bibtex-field-right-delimiter))))
 ;; update page dashes
 (if (and (memq 'page-dashes format)
-(string-match "\\`\\(OPT\\)?pages\\'" field-name)
+(bibtex-string= field-name "pages")
 (progn (goto-char beg-text)
 (looking-at
 "\\([\"{][0-9]+\\)[ \t\n]*--?[ \t\n]*\\([0-9]+[\"}]\\)")))
 (replace-match "\\1-\\2"))
 ;; use book title of crossref'd entry
 (if (and (memq 'inherit-booktitle format)
 empty-field
-(equal (downcase field-name) "booktitle")
+(bibtex-string= field-name "booktitle")
 crossref-key)
 (let ((title (save-restriction
 (widen)
 (if (bibtex-find-entry crossref-key)
 (bibtex-text-in-field "title")))))
 (goto-char (1+ beg-text))
 (insert title))))
 	      ;; Use booktitle to set a missing title.
 	      (if (and empty-field
-		       (equal (downcase field-name) "title"))
+		       (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))))
 (defun bibtex-autokey-abbrev (string len)
 "Return an abbreviation of STRING with at least LEN characters.
 If LEN is positive the abbreviation is terminated only after a consonant
-or at the word end. If LEN is negative the abbreviation is strictly
+or at the word end.  If LEN is negative the abbreviation is strictly
-enforced using abs (LEN) characters. If LEN is not a number, STRING
+enforced using abs (LEN) characters.  If LEN is not a number, STRING
 is returned unchanged."
 (cond ((or (not (numberp len))
 (<= (length string) (abs len)))
 string)
 ((equal len 0)
 (if abort-char
 (substring string 0 (1+ abort-char))
 string)))))
 (defun bibtex-autokey-get-field (field &optional change-list)
-"Get content of BibTeX field FIELD. Return empty string if not found.
+"Get content of BibTeX field FIELD.  Return empty string if not found.
 Optional arg CHANGE-LIST is a list of substitution patterns that is
-applied to the content of FIELD. It is an alist with pairs
+applied to the content of FIELD.  It is an alist with pairs
 \(OLD-REGEXP . NEW-STRING\)."
 (let ((content (bibtex-text-in-field field bibtex-autokey-use-crossref))
 case-fold-search)
 (unless content (setq content ""))
 (dolist (pattern change-list content)
 (defun bibtex-autokey-get-names ()
 "Get contents of the name field of the current entry.
 Do some modifications based on `bibtex-autokey-name-change-strings'
 and return results as a list."
-(let ((case-fold-search t))
+(let ((case-fold-search t)
-(mapcar 'bibtex-autokey-demangle-name
+(names (bibtex-autokey-get-field "author\\|editor"
-(split-string (bibtex-autokey-get-field
+bibtex-autokey-name-change-strings)))
-"author\\|editor"
+;; Some entries do not have a name field.
-bibtex-autokey-name-change-strings)
+(unless (string= "" names)
-"[ \t\n]+and[ \t\n]+"))))
+(mapcar 'bibtex-autokey-demangle-name
+(split-string names "[ \t\n]+and[ \t\n]+")))))
 (defun bibtex-autokey-demangle-name (fullname)
-"Get the last part from a well-formed name and perform abbreviations."
+"Get the last part from a well-formed FULLNAME and perform abbreviations."
 (let* (case-fold-search
 (name (cond ((string-match "\\([A-Z][^, ]*\\)[^,]*," fullname)
 ;; Name is of the form "von Last, First" or
 ;; "von Last, Jr, First"
 ;; --> Take the first capital part before the comma
 (funcall bibtex-autokey-name-case-convert name)
 bibtex-autokey-name-length)))
 (defun bibtex-autokey-get-title ()
 "Get title field contents up to a terminator."
-(let ((titlestring
+(let ((case-fold-search t)
+(titlestring
 (bibtex-autokey-get-field "title"
 bibtex-autokey-titleword-change-strings)))
 ;; ignore everything past a terminator
-(let ((case-fold-search t))
+(dolist (terminator bibtex-autokey-title-terminators)
-(dolist (terminator bibtex-autokey-title-terminators)
+(if (string-match terminator titlestring)
-(if (string-match terminator titlestring)
+(setq titlestring (substring titlestring 0 (match-beginning 0)))))
-(setq titlestring (substring titlestring 0 (match-beginning 0))))))
 ;; gather words from titlestring into a list. Ignore
 ;; specific words and use only a specific amount of words.
 (let ((counter 0)
-case-fold-search titlewords titlewords-extra titleword end-match)
+titlewords titlewords-extra titleword end-match)
 (while (and (or (not (numberp bibtex-autokey-titlewords))
 (< counter (+ bibtex-autokey-titlewords
 bibtex-autokey-titlewords-stretch)))
 (string-match "\\b\\w+" titlestring))
 (setq end-match (match-end 0)
 titleword (substring titlestring
 (match-beginning 0) end-match))
-(unless (bibtex-member-of-regexp titleword
+(unless (let ((lst bibtex-autokey-titleword-ignore))
-bibtex-autokey-titleword-ignore)
+(while (and lst
+(not (string-match (concat "\\`\\(?:" (car lst)
+"\\)\\'") titleword)))
+(setq lst (cdr lst)))
+lst)
 (setq titleword
 (funcall bibtex-autokey-titleword-case-convert titleword))
 (if (or (not (numberp bibtex-autokey-titlewords))
 (< counter bibtex-autokey-titlewords))
 (setq titlewords (append titlewords (list titleword)))
 (defun bibtex-autokey-demangle-title (titleword)
 "Do some abbreviations on TITLEWORD.
 The rules are defined in `bibtex-autokey-titleword-abbrevs'
 and `bibtex-autokey-titleword-length'."
-(let ((case-folde-search t)
+(let ((case-fold-search t)
 (alist bibtex-autokey-titleword-abbrevs))
 (while (and alist
 (not (string-match (concat "\\`\\(?:" (caar alist) "\\)\\'")
 titleword)))
 (setq alist (cdr alist)))
 use it as the name part of the key.
 3. Change any substring found in
 `bibtex-autokey-name-change-strings' to the corresponding new
 one (see documentation of this variable for further detail).
 4. For every of at least first `bibtex-autokey-names' names in
-the name field, determine the last name. If there are maximal
+the name field, determine the last name.  If there are maximal
 `bibtex-autokey-names' + `bibtex-autokey-names-stretch'
 names, all names are used.
 5. From every last name, take at least `bibtex-autokey-name-length'
 characters (abort only after a consonant or at a word end).
 6. Convert all last names according to the conversion function
 `bibtex-autokey-name-case-convert'.
 7. Build the name part of the key by concatenating all
 abbreviated last names with the string
-`bibtex-autokey-name-separator' between any two. If there are
+`bibtex-autokey-name-separator' between any two.  If there are
 more names than are used in the name part, prepend the string
 contained in `bibtex-autokey-additional-names'.
 8. Build the year part of the key by truncating the contents of
 the year field to the rightmost `bibtex-autokey-year-length'
-digits (useful values are 2 and 4). If the year field (or any
+digits (useful values are 2 and 4).  If the year field (or any
 other field required to generate the key) is absent, but the entry
 has a valid crossref field and the variable
 `bibtex-autokey-use-crossref' is non-nil, use the field of the
 crossreferenced entry instead.
 9. For the title part of the key change the contents of the
 the first occurrence of a regexp matched by the items of
 `bibtex-autokey-title-terminators' and delete those words which
 appear in `bibtex-autokey-titleword-ignore'.
 Build the title part of the key by using at least the first
 `bibtex-autokey-titlewords' words from this
-abbreviated title. If the abbreviated title ends after
+abbreviated title.  If the abbreviated title ends after
 maximal `bibtex-autokey-titlewords' +
 `bibtex-autokey-titlewords-stretch' words, all
 words from the abbreviated title are used.
 11. Convert all used titlewords according to the conversion function
 `bibtex-autokey-titleword-case-convert'.
 15. At least, to get the key, concatenate
 `bibtex-autokey-prefix-string', the name part, the year part
 and the title part with `bibtex-autokey-name-year-separator'
 between the name part and the year part if both are non-empty
 and `bibtex-autokey-year-title-separator' between the year
-part and the title part if both are non-empty. If the year
+part and the title part if both are non-empty.  If the year
 part is empty, but not the other two parts,
 `bibtex-autokey-year-title-separator' is used as well.
 16. If the value of `bibtex-autokey-before-presentation-function'
-is non-nil, it must be a function taking one argument. This
+is non-nil, it must be a function taking one argument.  This
 function is then called with the generated key as the
-argument. The return value of this function (a string) is
+argument.  The return value of this function (a string) is
 used as the key.
 17. If the value of `bibtex-autokey-edit-before-use' is non-nil,
 the key is then presented in the minibuffer to the user,
 where it can be edited.  The key given by the user is then
 used."
 (defun bibtex-parse-keys (&optional add abortable verbose)
 "Set `bibtex-reference-keys' to the keys used in the whole buffer.
 The buffer might possibly be restricted.
 Find both entry keys and crossref entries.
 If ADD is non-nil add the new keys to `bibtex-reference-keys' instead of
-simply resetting it. If ADD is an alist of keys, also add ADD to
+simply resetting it.  If ADD is an alist of keys, also add ADD to
-`bibtex-reference-keys'. If ABORTABLE is non-nil abort on user
+`bibtex-reference-keys'.  If ABORTABLE is non-nil abort on user
-input. If VERBOSE is non-nil gives messages about progress.
+input.  If VERBOSE is non-nil gives messages about progress.
 Return alist of keys if parsing was completed, `aborted' otherwise."
 (let ((reference-keys (if (and add
 (listp bibtex-reference-keys))
 bibtex-reference-keys)))
 (if (listp add)
 (defun bibtex-parse-strings (&optional add abortable)
 "Set `bibtex-strings' to the string definitions in the whole buffer.
 The buffer might possibly be restricted.
 If ADD is non-nil add the new strings to `bibtex-strings' instead of
-simply resetting it. If ADD is an alist of strings, also add ADD to
+simply resetting it.  If ADD is an alist of strings, also add ADD to
-`bibtex-strings'. If ABORTABLE is non-nil abort on user input.
+`bibtex-strings'.  If ABORTABLE is non-nil abort on user input.
 Return alist of strings if parsing was completed, `aborted' otherwise."
 (save-excursion
 (save-match-data
 (goto-char (point-min))
 (let ((strings (if (and add
 (listp bibtex-strings))
 bibtex-strings))
 bounds key)
 (if (listp add)
 (dolist (string add)
-(unless (assoc (car string) strings)
+(unless (assoc-string (car string) strings t)
 (push string strings))))
 (catch 'userkey
 (while (setq bounds (bibtex-search-forward-string))
 (if (and abortable
 (input-pending-p))
 ;; user has aborted by typing a key --> return `aborted'
 (throw 'userkey 'aborted))
 (setq key (bibtex-reference-key-in-string bounds))
-(if (not (assoc key strings))
+(unless (assoc-string key strings t)
 (push (cons key (bibtex-text-in-string bounds t))
 strings))
 (goto-char (bibtex-end-of-text-in-string bounds)))
 ;; successful operation --> return `bibtex-strings'
 (setq bibtex-strings strings))))))
 (defun bibtex-string-files-init ()
 (error "File %s not in paths defined via bibtex-string-file-path"
 filename))))
 (append bibtex-predefined-strings (nreverse compl)))))
 (defun bibtex-parse-buffers-stealthily ()
-"Called by `bibtex-run-with-idle-timer'. Whenever emacs has been idle
+"Parse buffer in the background during idle time.
+Called by `bibtex-run-with-idle-timer'.  Whenever Emacs has been idle
 for `bibtex-parse-keys-timeout' seconds, all BibTeX buffers (starting
 with the current) are parsed."
 (save-excursion
 (let ((buffers (buffer-list))
 (strings-init (bibtex-string-files-init)))
 ;; remember that parsing was successful
 (setq bibtex-buffer-last-parsed-tick (buffer-modified-tick)))))
 (setq buffers (cdr buffers))))))
 (defun bibtex-complete-internal (completions)
-"Complete word fragment before point to longest prefix of one
+"Complete word fragment before point to longest prefix of COMPLETIONS.
-string defined in list COMPLETIONS.  If point is not after the part
+COMPLETIONS should be a list of strings.  If point is not after the part
-of a word, all strings are listed. Return completion."
+of a word, all strings are listed.  Return completion."
 (let* ((case-fold-search t)
 (beg (save-excursion
 (re-search-backward "[ \t{\"]")
 (forward-char)
 (point)))
 completions)))
 (message "Making completion list...done")
 ;; return value is handled by choose-completion-string-functions
 nil))))
-(defun bibtex-complete-string-cleanup (str)
+(defun bibtex-complete-string-cleanup (str strings-alist)
 "Cleanup after inserting string STR.
-Remove enclosing field delimiters for string STR. Display message with
+Remove enclosing field delimiters for string STR.  Display message with
-expansion of STR."
+expansion of STR using expansion list STRINGS-ALIST."
-(let ((pair (assoc str bibtex-strings)))
+(let ((pair (if (stringp str)
+(assoc-string str strings-alist t))))
 (when pair
 (if (cdr pair)
 (message "Abbreviation for `%s'" (cdr pair)))
 (save-excursion
 (bibtex-inside-field)
 (let ((boundaries (bibtex-parse-field-string)))
 (if (and boundaries
 (equal (cdr boundaries)
 (bibtex-end-of-text-in-field bounds)))
 (bibtex-remove-delimiters))))))))
+(defun bibtex-complete-key-cleanup (key)
+"Display message on entry KEY after completion of a crossref key."
+(save-excursion
+;; Don't do anything if we completed the key of an entry.
+(let ((pnt (bibtex-beginning-of-entry)))
+(if (and (stringp key)
+(bibtex-find-entry key)
+(/= pnt (point)))
+(let* ((bibtex-autokey-name-case-convert 'identity)
+(bibtex-autokey-name-length 'infty)
+(nl (bibtex-autokey-get-names))
+(name (concat (nth 0 nl) (if (nth 1 nl) " etal")))
+(year (bibtex-autokey-get-field "year"))
+(bibtex-autokey-titlewords 5)
+(bibtex-autokey-titlewords-stretch 2)
+(bibtex-autokey-titleword-case-convert 'identity)
+(bibtex-autokey-titleword-length 5)
+(title (mapconcat 'identity
+(bibtex-autokey-get-title) " "))
+(journal (bibtex-autokey-get-field
+"journal" bibtex-autokey-transcriptions))
+(volume (bibtex-autokey-get-field "volume"))
+(pages (bibtex-autokey-get-field "pages" '(("-.*\\'" . "")))))
+(message "Ref:%s"
+(mapconcat (lambda (arg)
+(if (not (string= "" (cdr arg)))
+(concat (car arg) (cdr arg))))
+`((" " . ,name) (" " . ,year)
+(": " . ,title) (", " . ,journal)
+(" " . ,volume) (":" . ,pages))
+"")))))))
 (defun bibtex-choose-completion-string (choice buffer mini-p base-size)
 ;; Code borrowed from choose-completion-string:
 ;; We must duplicate the code from choose-completion-string
 ;; because it runs the hook choose-completion-string-functions
 ;; Update point in the window that BUFFER is showing in.
 (let ((window (get-buffer-window buffer t)))
 (set-window-point window (point))))
 (defun bibtex-pop (arg direction)
-"Generic function used by `bibtex-pop-previous' and `bibtex-pop-next'."
+"Fill current field from the ARG'th same field's text in DIRECTION.
+Generic function used by `bibtex-pop-previous' and `bibtex-pop-next'."
 (let (bibtex-help-message)
 (bibtex-find-text nil))
 (save-excursion
 ;; parse current field
 (bibtex-inside-field)
 (let* ((case-fold-search t)
 (bounds (bibtex-enclosing-field))
 (start-old-text (bibtex-start-of-text-in-field bounds))
 (stop-old-text (bibtex-end-of-text-in-field bounds))
-(start-name (bibtex-start-of-name-in-field bounds))
+(field-name (bibtex-name-in-field bounds t)))
-(stop-name (bibtex-end-of-name-in-field bounds))
-;; construct regexp for field with same name as this one,
-;; ignoring possible OPT's or ALT's
-(field-name (progn
-(goto-char start-name)
-(buffer-substring-no-properties
-(if (looking-at "\\(OPT\\)\\|\\(ALT\\)")
-(match-end 0)
-(point))
-stop-name))))
 ;; if executed several times in a row, start each search where
 ;; the last one was finished
 (unless (eq last-command 'bibtex-pop)
 (bibtex-enclosing-entry-maybe-empty-head)
 (setq bibtex-pop-previous-search-point (match-beginning 0)
 "Major mode for editing BibTeX files.
 General information on working with BibTeX mode:
 You should use commands such as \\[bibtex-Book] to get a template for a
-specific entry. You should then fill in all desired fields using
+specific entry.  You should then fill in all desired fields using
-\\[bibtex-next-field] to jump from field to field. After having filled
+\\[bibtex-next-field] to jump from field to field.  After having filled
 in all desired fields in the entry, you should clean the new entry
 with the command \\[bibtex-clean-entry].
 Some features of BibTeX mode are available only by setting the variable
-`bibtex-maintain-sorted-entries' to non-nil. However, then BibTeX mode will
+`bibtex-maintain-sorted-entries' to non-nil.  However, then BibTeX mode will
 work only with buffers containing valid (syntactical correct) entries
-and with entries being sorted. This is usually the case, if you have
+and with entries being sorted.  This is usually the case, if you have
 created a buffer completely with BibTeX mode and finished every new
 entry with \\[bibtex-clean-entry].
 For third party BibTeX files, call the function `bibtex-convert-alien'
 to fully take advantage of all features of BibTeX mode.
 ;; entries should be fontified in the same way as
 ;; brace-delimited ones
 )
 nil
 (font-lock-syntactic-keywords . bibtex-font-lock-syntactic-keywords)
+(font-lock-extra-managed-props . (mouse-face keymap))
 	 (font-lock-mark-block-function
 	  . (lambda ()
 (set-mark (bibtex-end-of-entry))
 	      (bibtex-beginning-of-entry)))))
 (setq imenu-generic-expression
 (list (list nil bibtex-entry-head bibtex-key-in-head)))
 (make-local-variable 'choose-completion-string-functions)
 (setq imenu-case-fold-search t)
 optional))
 (setq optional (append optional bibtex-user-optional-fields))
 (cons required optional)))
 (defun bibtex-entry (entry-type)
-"Insert a new BibTeX entry.
+"Insert a new BibTeX entry of type ENTRY-TYPE.
 After insertion it calls the functions in `bibtex-add-entry-hook'."
 (interactive (let* ((completion-ignore-case t)
 (e-t (completing-read
 "Entry Type: "
 bibtex-entry-field-alist
 (error "Entry with key `%s' already exists" key))
 (indent-to-column bibtex-entry-offset)
 (insert "@" entry-type (bibtex-entry-left-delimiter))
 (if key (insert key))
 (save-excursion
-(mapcar 'bibtex-make-field (car field-list))
+(mapc 'bibtex-make-field (car field-list))
-(mapcar 'bibtex-make-optional-field (cdr field-list))
+(mapc 'bibtex-make-optional-field (cdr field-list))
 (if bibtex-comma-after-last-field
 (insert ","))
 (insert "\n")
 (indent-to-column bibtex-entry-offset)
 (insert (bibtex-entry-right-delimiter) "\n\n"))
 ;; For inserting new fields, we use the fact that
 ;; bibtex-parse-entry moves point to the end of the last field.
 (let* ((fields-alist (bibtex-parse-entry))
 (field-list (bibtex-field-list
 (substring (cdr (assoc "=type=" fields-alist))
-1))) ; don't want @
+1)))) ; don't want @
-(case-fold-search t))
 (dolist (field (car field-list))
-(unless (bibtex-assoc-regexp (concat "\\`\\(ALT\\)?" (car field) "\\'")
+(unless (assoc-string (car field) fields-alist t)
-fields-alist)
 (bibtex-make-field field)))
 (dolist (field (cdr field-list))
-(unless (bibtex-assoc-regexp (concat "\\`\\(OPT\\)?" (car field) "\\'")
+(unless (assoc-string (car field) fields-alist t)
-fields-alist)
 (bibtex-make-optional-field field))))))
 (defun bibtex-parse-entry ()
 "Parse entry at point, return an alist.
 The alist elements have the form (FIELD . TEXT), where FIELD can also be
-the special strings \"=type=\" and \"=key=\". For the FIELD \"=key=\"
+the special strings \"=type=\" and \"=key=\".  For the FIELD \"=key=\"
-TEXT may be nil. Move point to the end of the last field."
+TEXT may be nil.  Remove \"OPT\" and \"ALT\" from FIELD.
+Move point to the end of the last field."
 (let (alist bounds)
 (when (looking-at bibtex-entry-maybe-empty-head)
 (push (cons "=type=" (match-string bibtex-type-in-head)) alist)
 (push (cons "=key=" (match-string bibtex-key-in-head)) alist)
 (goto-char (match-end 0))
 (while (setq bounds (bibtex-parse-field bibtex-field-name))
-	(push (cons (bibtex-name-in-field bounds)
+	(push (cons (bibtex-name-in-field bounds t)
 		    (bibtex-text-in-field-bounds bounds))
 	      alist)
 	(goto-char (bibtex-end-of-field bounds))))
 alist))
 (save-excursion
 	(goto-char (1- (match-beginning 0)))
 	(bibtex-beginning-of-entry)
 	(when (and
 	       (looking-at bibtex-entry-head)
-	       (equal type (match-string bibtex-type-in-head))
+	       (bibtex-string= type (match-string bibtex-type-in-head))
 	       ;; In case we found ourselves :-(
 	       (not (equal key (setq tmp (match-string bibtex-key-in-head)))))
 	  (setq other-key tmp)
 	  (setq other (point))))
 (save-excursion
 	(bibtex-end-of-entry)
 	(bibtex-skip-to-valid-entry)
 	(when (and
 	       (looking-at bibtex-entry-head)
-	       (equal type (match-string bibtex-type-in-head))
+	       (bibtex-string= type (match-string bibtex-type-in-head))
 	       ;; In case we found ourselves :-(
 	       (not (equal key (setq tmp (match-string bibtex-key-in-head))))
 	       (or (not other-key)
 		   ;; Check which is the best match.
 		   (< (length (try-completion "" (list key other-key)))
 ;; Then fill the new entry's fields with the chosen other entry.
 (when other
 	(setq other (save-excursion (goto-char other) (bibtex-parse-entry)))
 	(setq key-end (point))	    ;In case parse-entry changed the buffer.
 	(while (setq bounds (bibtex-parse-field bibtex-field-name))
-	  (goto-char (bibtex-start-of-name-in-field bounds))
+	  (let ((text (assoc-string (bibtex-name-in-field bounds t)
-	  (let* ((name (buffer-substring
+other t)))
-			(if (looking-at "ALT\\|OPT") (match-end 0) (point))
-			(bibtex-end-of-name-in-field bounds)))
-		 (text (assoc-string name other t)))
 	    (goto-char (bibtex-start-of-text-in-field bounds))
 	    (if (not (and (looking-at bibtex-empty-field-re) text))
 		(goto-char (bibtex-end-of-field bounds))
 	      (delete-region (point) (bibtex-end-of-text-in-field bounds))
 	      (insert (cdr text)))))
 (defun bibtex-print-help-message ()
 "Print helpful information about current field in current BibTeX entry."
 (interactive)
 (save-excursion
 (let* ((case-fold-search t)
-(bounds (bibtex-enclosing-field))
+(field-name (bibtex-name-in-field (bibtex-enclosing-field) t))
-(mb (bibtex-start-of-name-in-field bounds))
-(field-name (buffer-substring-no-properties
-(if (progn (goto-char mb)
-(looking-at "OPT\\|ALT"))
-(match-end 0) mb)
-(bibtex-end-of-name-in-field bounds)))
 (field-list (bibtex-field-list (progn (re-search-backward
 bibtex-entry-maybe-empty-head nil t)
 (bibtex-type-in-head))))
 (comment (assoc-string field-name
 				  (append (car field-list)
 (defun bibtex-make-field (field &optional called-by-yank)
 "Make a field named FIELD in current BibTeX entry.
 FIELD is either a string or a list of the form
 \(FIELD-NAME COMMENT-STRING INIT ALTERNATIVE-FLAG) as in
-`bibtex-entry-field-alist'."
+`bibtex-entry-field-alist'.
+If CALLED-BY-YANK is non-nil, don't insert delimiters."
 (interactive
 (list (let ((completion-ignore-case t)
 (field-list (bibtex-field-list
 (save-excursion
 (bibtex-enclosing-entry-maybe-empty-head)
 (insert (car field) " ")
 (if bibtex-align-at-equal-sign
 (indent-to-column (+ bibtex-entry-offset
 (- bibtex-text-indentation 2))))
 (insert "= ")
-(if (not bibtex-align-at-equal-sign)
+(unless bibtex-align-at-equal-sign
 (indent-to-column (+ bibtex-entry-offset
 bibtex-text-indentation)))
-(if (not called-by-yank) (insert (bibtex-field-left-delimiter)))
+(unless called-by-yank (insert (bibtex-field-left-delimiter)))
 (let ((init (nth 2 field)))
 (cond ((stringp init)
 (insert init))
 ((fboundp init)
 (insert (funcall init)))))
-(if (not called-by-yank) (insert (bibtex-field-right-delimiter)))
+(unless called-by-yank (insert (bibtex-field-right-delimiter)))
 (when (interactive-p)
 (forward-char -1)
 (bibtex-print-help-message)))
 (defun bibtex-beginning-of-entry ()
 "Move to beginning of BibTeX entry (beginning of line).
 If inside an entry, move to the beginning of it, otherwise move to the
-beginning of the previous entry. If point is ahead of all BibTeX entries
+beginning of the previous entry.  If point is ahead of all BibTeX entries
-move point to the beginning of buffer. Return the new location of point."
+move point to the beginning of buffer.  Return the new location of point."
 (interactive)
 (skip-chars-forward " \t")
 (if (looking-at "@")
 (forward-char))
 (re-search-backward "^[ \t]*@" nil 'move)
 (point))
 (defun bibtex-end-of-entry ()
 "Move to end of BibTeX entry (past the closing brace).
 If inside an entry, move to the end of it, otherwise move to the end
-of the previous entry. Do not move if ahead of first entry.
+of the previous entry.  Do not move if ahead of first entry.
 Return the new location of point."
 (interactive)
 (let ((case-fold-search t)
 (org (point))
 (pnt (bibtex-beginning-of-entry))
 (widen)
 (narrow-to-region (bibtex-beginning-of-entry)
 (bibtex-end-of-entry))))
 (defun bibtex-entry-index ()
-"Return the index of the BibTeX entry at point. Move point.
+"Return the index of the BibTeX entry at point.  Move point.
 The index is a list (KEY CROSSREF-KEY ENTRY-NAME) that is used for sorting
-the entries of the BibTeX buffer. Return nil if no entry found."
+the entries of the BibTeX buffer.  Return nil if no entry found."
 (let ((case-fold-search t))
 (if (re-search-forward bibtex-entry-maybe-empty-head nil t)
 (let ((key (bibtex-key-in-head))
 ;; all entry names should be downcase (for ease of comparison)
 (entry-name (downcase (bibtex-type-in-head))))
 (string-lessp (car index1) (car index2)))))
 (defun bibtex-sort-buffer ()
 "Sort BibTeX buffer alphabetically by key.
 The predicate for sorting is defined via `bibtex-maintain-sorted-entries'.
-If its value is nil use plain sorting. Text outside of BibTeX entries is not
+If its value is nil use plain sorting.  Text outside of BibTeX entries is not
-affected. If `bibtex-sort-ignore-string-entries' is non-nil, @String entries
+affected.  If `bibtex-sort-ignore-string-entries' is non-nil, @String entries
 will be ignored."
 (interactive)
 (save-restriction
 (narrow-to-region (bibtex-beginning-of-first-entry)
 (save-excursion (goto-char (point-max))
 (let ((pos (save-excursion (bibtex-find-entry crossref-key))))
 (if (and pos (> (point) pos))
 (error "This entry must not follow the crossrefed entry!"))
 (goto-char pos)))
-(defun bibtex-find-entry (key)
+(defun bibtex-find-entry (key &optional start)
 "Move point to the beginning of BibTeX entry named KEY.
-Return position of entry if KEY is found or nil if not found."
+Return position of entry if KEY is found or nil if not found.
-(interactive (list (bibtex-read-key "Find key: ")))
+Optional arg START is buffer position where the search starts.
+If it is nil, start search at beginning of buffer.
+With prefix arg, the value of START is position of point."
+(interactive (list (bibtex-read-key "Find key: ")
+(if current-prefix-arg (point))))
 (let* (case-fold-search
 (pnt (save-excursion
-(goto-char (point-min))
+(goto-char (or start (point-min)))
 (if (re-search-forward (concat "^[ \t]*\\("
 bibtex-entry-type
 "\\)[ \t]*[({][ \t\n]*\\("
 (regexp-quote key)
 "\\)[ \t\n]*[,=]")
 (defun bibtex-prepare-new-entry (index)
 "Prepare a new BibTeX entry with index INDEX.
 INDEX is a list (KEY CROSSREF-KEY ENTRY-NAME).
 Move point where the entry KEY should be placed.
 If `bibtex-maintain-sorted-entries' is non-nil, perform a binary
-search to look for place for KEY. This will fail if buffer is not in
+search to look for place for KEY.  This will fail if buffer is not in
 sorted order, see \\[bibtex-validate].)
 Return t if preparation was successful or nil if entry KEY already exists."
 (let ((key (nth 0 index))
 key-exist)
 (cond ((or (null key)
 (when (or (not actual-index)
 (bibtex-lessp actual-index index))
 ;; buffer contains no valid entries or
 ;; greater than last entry --> append
 (bibtex-end-of-entry)
-(if (not (bobp))
+(unless (bobp) (newline (forward-line 2)))
-(newline (forward-line 2)))
 (beginning-of-line)))))
 (unless key-exist t)))
 (defun bibtex-validate (&optional test-thoroughly)
 "Validate if buffer or region is syntactically correct.
 (when test-thoroughly
 (goto-char (point-min))
 (bibtex-progress-message
 "Checking required fields and month fields")
-(let ((bibtex-sort-ignore-string-entries t)
+(let ((bibtex-sort-ignore-string-entries t))
-(questionable-month
-(regexp-opt (mapcar 'car bibtex-predefined-month-strings))))
 (bibtex-map-entries
 (lambda (key beg end)
 (bibtex-progress-message)
 (let* ((entry-list (progn
 (goto-char beg)
 crossref-there bounds)
 (goto-char beg)
 (while (setq bounds (bibtex-search-forward-field
 bibtex-field-name end))
 (goto-char (bibtex-start-of-text-in-field bounds))
-(let ((field-name (downcase (bibtex-name-in-field bounds)))
+(let ((field-name (bibtex-name-in-field bounds)))
-case-fold-search)
+(if (and (bibtex-string= field-name "month")
-(if (and (equal field-name "month")
+(not (assoc-string (bibtex-text-in-field-bounds bounds)
-(not (string-match questionable-month
+bibtex-predefined-month-strings t)))
-(bibtex-text-in-field-bounds bounds))))
 (push (list (bibtex-current-line)
 "Questionable month field")
 error-list))
 (setq req (delete (assoc-string field-name req t) req)
 creq (delete (assoc-string field-name creq t) creq))
-(if (equal field-name "crossref")
+(if (bibtex-string= field-name "crossref")
 (setq crossref-there t))))
 (if crossref-there
 (setq req creq))
 (if (or (> (length req) 1)
 (and (= (length req) 1)
 "")
 "\n")
 (dolist (err error-list)
 (insert bufnam ":" (number-to-string (elt err 0))
 ": " (elt err 1) "\n"))
-(compilation-parse-errors nil nil)
-(setq compilation-old-error-list compilation-error-list)
-;; this is necessary to avoid reparsing of buffer if you
-;; switch to compilation buffer and enter `compile-goto-error'
 (set-buffer-modified-p nil)
 (toggle-read-only 1)
 (goto-char (point-min))
 (other-window -1)
 ;; return nil
 (defun bibtex-remove-delimiters ()
 "Remove \"\" or {} around string."
 (interactive)
 (save-excursion
 (bibtex-inside-field)
-(let ((bounds (bibtex-enclosing-field)))
+(let* ((bounds (bibtex-enclosing-field))
-(goto-char (bibtex-start-of-text-in-field bounds))
+	   (end (bibtex-end-of-text-in-field bounds))
-(delete-char 1)
+	   (start (bibtex-start-of-text-in-field bounds)))
-(goto-char (1- (bibtex-end-of-text-in-field bounds)))
+(if (memq (char-before end) '(?\} ?\"))
-(delete-backward-char 1))))
+	  (delete-region (1- end) end))
+(if (memq (char-after start) '(?\{ ?\"))
+	  (delete-region start (1+ start))))))
 (defun bibtex-kill-field (&optional copy-only)
 "Kill the entire enclosing BibTeX field.
 With prefix arg COPY-ONLY, copy the current field to `bibtex-field-kill-ring',
 but do not actually kill it."
 (unless copy-only
 (delete-region beg end))))
 (setq bibtex-last-kill-command 'entry))
 (defun bibtex-copy-entry-as-kill ()
+"Copy the entire enclosing BibTeX entry to `bibtex-entry-kill-ring'."
 (interactive)
 (bibtex-kill-entry t))
 (defun bibtex-yank (&optional n)
 "Reinsert the last BibTeX item.
 If N is negative, this is a more recent kill.
 The sequence of kills wraps around, so that after the oldest one
 comes the newest one."
 (interactive "*p")
-(if (not (eq last-command 'bibtex-yank))
+(unless (eq last-command 'bibtex-yank)
 (error "Previous command was not a BibTeX yank"))
 (setq this-command 'bibtex-yank)
 (let ((inhibit-read-only t))
 (delete-region (point) (mark t))
 (bibtex-insert-current-kill n)))
 (defun bibtex-clean-entry (&optional new-key called-by-reformat)
 "Finish editing the current BibTeX entry and clean it up.
 Check that no required fields are empty and formats entry dependent
 on the value of `bibtex-entry-format'.
 If the reference key of the entry is empty or a prefix argument is given,
-calculate a new reference key. (Note: this will only work if fields in entry
+calculate a new reference key.  (Note: this will only work if fields in entry
 begin on separate lines prior to calling `bibtex-clean-entry' or if
 'realign is contained in `bibtex-entry-format'.)
 Don't call `bibtex-clean-entry' on @Preamble entries.
 At end of the cleaning process, the functions in
 `bibtex-clean-entry-hook' are called with region narrowed to entry."
 (let ((case-fold-search t)
 entry-type key)
 (bibtex-beginning-of-entry)
 (save-excursion
 (when (re-search-forward bibtex-entry-maybe-empty-head nil t)
-(setq entry-type (downcase (bibtex-type-in-head)))
+(setq entry-type (bibtex-type-in-head))
 (setq key (bibtex-key-in-head))))
 ;; formatting
-(cond ((equal entry-type "preamble")
+(cond ((bibtex-string= entry-type "preamble")
 ;; (bibtex-format-preamble)
 (error "No clean up of @Preamble entries"))
-((equal entry-type "string"))
+((bibtex-string= entry-type "string"))
 ;; (bibtex-format-string)
 (t (bibtex-format-entry)))
 ;; set key
 (when (or new-key (not key))
 (setq key (bibtex-generate-autokey))
-(if bibtex-autokey-edit-before-use
+;; Sometimes bibtex-generate-autokey returns an empty string
+(if (or bibtex-autokey-edit-before-use (string= "" key))
 (setq key (bibtex-read-key "Key to use: " key)))
 (re-search-forward bibtex-entry-maybe-empty-head)
 (if (match-beginning bibtex-key-in-head)
 (delete-region (match-beginning bibtex-key-in-head)
 (match-end bibtex-key-in-head)))
 (goto-char (match-beginning 0)))
 (point)))
 (entry (buffer-substring start end))
 (index (progn (goto-char start)
 (bibtex-entry-index)))
-no-error)
+error)
 (if (and bibtex-maintain-sorted-entries
 (not (and bibtex-sort-ignore-string-entries
-(equal entry-type "string"))))
+(bibtex-string= entry-type "string"))))
 (progn
 (delete-region start end)
-(setq no-error (bibtex-prepare-new-entry index))
+(setq error (not (bibtex-prepare-new-entry index)))
 (insert entry)
 (forward-char -1)
 (bibtex-beginning-of-entry) ; moves backward
 (re-search-forward bibtex-entry-head))
-(setq no-error (bibtex-find-entry (car index))))
+(bibtex-find-entry key)
-(unless no-error
+(setq error (or (/= (point) start)
+(bibtex-find-entry key end))))
+(if error
 (error "New inserted entry yields duplicate key"))))
 ;; final clean up
 (unless called-by-reformat
 (save-excursion
 (save-restriction
 (bibtex-narrow-to-entry)
 ;; Only update the list of keys if it has been built already.
-(cond ((equal entry-type "string")
+(cond ((bibtex-string= entry-type "string")
 (if (listp bibtex-strings) (bibtex-parse-strings t)))
 ((listp bibtex-reference-keys) (bibtex-parse-keys t)))
 (run-hooks 'bibtex-clean-entry-hook))))))
 (defun bibtex-fill-field-bounds (bounds justify &optional move)
 (message "Buffer is now parsable. Please save it.")))
 (defun bibtex-complete ()
 "Complete word fragment before point according to context.
 If point is inside key or crossref field perform key completion based on
-`bibtex-reference-keys'. Inside any other field perform string
+`bibtex-reference-keys'.  Inside a month field perform key completion
-completion based on `bibtex-strings'. An error is signaled if point
+based on `bibtex-predefined-month-strings'.  Inside any other field
-is outside key or BibTeX field."
+perform string completion based on `bibtex-strings'.  An error is
+signaled if point is outside key or BibTeX field."
 (interactive)
-(let* ((pnt (point))
+(let ((pnt (point))
 (case-fold-search t)
-bounds compl)
+bounds name compl)
 (save-excursion
 (if (and (setq bounds (bibtex-enclosing-field t))
 (>= pnt (bibtex-start-of-text-in-field bounds))
 (<= pnt (bibtex-end-of-text-in-field bounds)))
-(progn
+(setq name (bibtex-name-in-field bounds t)
-(goto-char (bibtex-start-of-name-in-field bounds))
+compl (cond ((bibtex-string= name "crossref")
-(setq compl (if (string= "crossref"
+'key)
-(downcase
+((bibtex-string= name "month")
-(buffer-substring-no-properties
+bibtex-predefined-month-strings)
-(if (looking-at "\\(OPT\\)\\|\\(ALT\\)")
+(t (if (listp bibtex-strings)
-(match-end 0)
+bibtex-strings
-(point))
+;; so that bibtex-complete-string-cleanup
-(bibtex-end-of-name-in-field bounds))))
+;; can do its job
-'key
+(bibtex-parse-strings
-'str)))
+(bibtex-string-files-init))))))
 (bibtex-beginning-of-entry)
 (if (and (re-search-forward bibtex-entry-maybe-empty-head nil t)
 ;; point is inside a key
 (or (and (match-beginning bibtex-key-in-head)
 (>= pnt (match-beginning bibtex-key-in-head))
 (cond ((equal compl 'key)
 ;; key completion
 (setq choose-completion-string-functions
 (lambda (choice buffer mini-p base-size)
 (bibtex-choose-completion-string choice buffer mini-p base-size)
-(if bibtex-complete-key-cleanup
+(bibtex-complete-key-cleanup choice)
-(funcall bibtex-complete-key-cleanup choice))
 ;; return t (required by choose-completion-string-functions)
 t))
-(let ((choice (bibtex-complete-internal bibtex-reference-keys)))
+(bibtex-complete-key-cleanup (bibtex-complete-internal
-(if bibtex-complete-key-cleanup
+bibtex-reference-keys)))
-(funcall bibtex-complete-key-cleanup choice))))
+(compl
-((equal compl 'str)
 ;; string completion
 (setq choose-completion-string-functions
-(lambda (choice buffer mini-p base-size)
+`(lambda (choice buffer mini-p base-size)
 (bibtex-choose-completion-string choice buffer mini-p base-size)
-(bibtex-complete-string-cleanup choice)
+(bibtex-complete-string-cleanup choice ',compl)
 ;; return t (required by choose-completion-string-functions)
 t))
-(bibtex-complete-string-cleanup (bibtex-complete-internal bibtex-strings)))
+(bibtex-complete-string-cleanup (bibtex-complete-internal compl)
+compl))
 (t (error "Point outside key or BibTeX field")))))
 (defun bibtex-Article ()
 "Insert a new BibTeX @Article entry; see also `bibtex-entry'."
 (defun bibtex-String (&optional key)
 "Insert a new BibTeX @String entry with key KEY."
 (interactive (list (completing-read "String key: " bibtex-strings
 nil nil nil 'bibtex-key-history)))
 (let ((bibtex-maintain-sorted-entries
-(if (not bibtex-sort-ignore-string-entries)
+(unless bibtex-sort-ignore-string-entries
 bibtex-maintain-sorted-entries))
 endpos)
 (unless (bibtex-prepare-new-entry (list key nil "String"))
 (error "Entry with key `%s' already exists" key))
 (if (zerop (length key)) (setq key nil))
 (indent-to-column bibtex-entry-offset)
 (let ((endpos (point)))
 (insert (bibtex-entry-right-delimiter)
 "\n")
 (goto-char endpos)))
+(defun bibtex-url (&optional event)
+"Browse a URL for the BibTeX entry at position PNT.
+The URL is generated using the schemes defined in `bibtex-generate-url-list'
+\(see there\).  Then the URL is passed to `browse-url'."
+(interactive (list last-input-event))
+(save-excursion
+(if event (posn-set-point (event-end event)))
+(bibtex-beginning-of-entry)
+(let ((fields-alist (bibtex-parse-entry))
+(case-fold-search t)
+(lst bibtex-generate-url-list)
+field url scheme)
+(while (setq scheme (car lst))
+(when (and (setq field (cdr (assoc-string (caar scheme)
+						  fields-alist t)))
+		   (progn
+		     (if (string-match "\\`[{\"]\\(.*\\)[}\"]\\'" field)
+			 (setq field (match-string 1 field)))
+		     (string-match (cdar scheme) field)))
+	  (setq lst nil)
+	  (if (null (cdr scheme))
+	      (setq url (match-string 0 field)))
+(dolist (step (cdr scheme))
+	    (cond ((stringp step)
+		   (setq url (concat url step)))
+		  ((setq field (assoc-string (car step) fields-alist t))
+		   ;; always remove field delimiters
+		   (let* ((text (if (string-match "\\`[{\"]\\(.*\\)[}\"]\\'"
+						  (cdr field))
+				    (match-string 1 (cdr field))
+				  (cdr field)))
+			  (str (if (string-match (nth 1 step) text)
+				   (cond
+				    ((functionp (nth 2 step))
+				     (funcall (nth 2 step) text))
+				    ((numberp (nth 2 step))
+				     (match-string (nth 2 step) text))
+				    (t
+				     (replace-match (nth 2 step) nil nil text)))
+				 ;; If the scheme is set up correctly,
+				 ;; we should never reach this point
+				 (error "Match failed: %s" text))))
+(setq url (concat url str))))
+		  ;; If the scheme is set up correctly,
+		  ;; we should never reach this point
+		  (t (error "Step failed: %s" step))))
+	  (message "%s" url)
+(browse-url url))
+(setq lst (cdr lst)))
+(unless url (message "No URL known.")))))
+(defun bibtex-font-lock-url (bound)
+"Font-lock for URLs."
+(let ((case-fold-search t)
+(bounds (bibtex-enclosing-field t))
+(pnt (point))
+	found field)
+;; We use start-of-field as syntax-begin
+(goto-char (if bounds (bibtex-start-of-field bounds) pnt))
+(while (and (not found)
+		(prog1 (re-search-forward bibtex-font-lock-url-regexp bound t)
+		  (setq field (match-string-no-properties 1)))
+		(setq bounds (bibtex-parse-field-text))
+		(>= bound (car bounds))
+		(>= (car bounds) pnt))
+(let ((lst bibtex-generate-url-list) url)
+	(goto-char (car bounds))
+	(while (and (not found)
+		    (setq url (caar lst)))
+	  (when (bibtex-string= field (car url))
+	    (setq found (re-search-forward (cdr url) (cdr bounds) t)))
+	  (setq lst (cdr lst))))
+(goto-char (cdr bounds)))
+found))
 ;; Make BibTeX a Feature
 (provide 'bibtex)

Mercurial > emacs

comparison lisp/textmodes/bibtex.el @ 89978:566253900690