emacs: lisp/textmodes/reftex-cite.el comparison

comparison lisp/textmodes/reftex-cite.el @ 52170:27340819ef07

Updated to version 4.21

author	Carsten Dominik <dominik@science.uva.nl>
date	Mon, 11 Aug 2003 12:27:02 +0000
parents	4b3ce62d56f2
children	695cf19ef79e

comparison

equal deleted inserted replaced

-:b97eb548bcaa
+:27340819ef07
 ;;; reftex-cite.el --- creating citations with RefTeX
-;; Copyright (c) 1997, 1998, 1999, 2000, 2003  Free Software Foundation, Inc.
+;; Copyright (c) 1997, 1998, 1999, 2000, 2003 Free Software Foundation, Inc.
 ;; Author: Carsten Dominik <dominik@science.uva.nl>
-;; Version: 4.18
+;; Version: 4.21
 ;; This file is part of GNU Emacs.
 ;; GNU Emacs is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
 (defmacro reftex-with-special-syntax-for-bib (&rest body)
 `(let ((saved-syntax (syntax-table)))
 (unwind-protect
-	 (progn
+(progn
-	   (set-syntax-table reftex-syntax-table-for-bib)
+(set-syntax-table reftex-syntax-table-for-bib)
-	   ,@body)
+,@body)
 (set-syntax-table saved-syntax))))
 (defun reftex-default-bibliography ()
 ;; Return the expanded value of `reftex-default-bibliography'.
 ;; The expanded value is cached.
 (unless (eq (get 'reftex-default-bibliography :reftex-raw)
-	      reftex-default-bibliography)
+reftex-default-bibliography)
 (put 'reftex-default-bibliography :reftex-expanded
-	 (reftex-locate-bibliography-files
+(reftex-locate-bibliography-files
-	  default-directory reftex-default-bibliography))
+default-directory reftex-default-bibliography))
 (put 'reftex-default-bibliography :reftex-raw
-	 reftex-default-bibliography))
+reftex-default-bibliography))
 (get 'reftex-default-bibliography :reftex-expanded))
 (defun reftex-bib-or-thebib ()
 ;; Tests if BibTeX or \begin{tehbibliography} should be used for the
 ;; citation
 ;; Find the bof of the current file
 (let* ((docstruct (symbol-value reftex-docstruct-symbol))
-	 (rest (or (member (list 'bof (buffer-file-name)) docstruct)
+(rest (or (member (list 'bof (buffer-file-name)) docstruct)
-		   docstruct))
+docstruct))
-	 (bib (assq 'bib rest))
+(bib (assq 'bib rest))
-	 (thebib (assq 'thebib rest))
+(thebib (assq 'thebib rest))
-	 (bibmem (memq bib rest))
+(bibmem (memq bib rest))
-	 (thebibmem (memq thebib rest)))
+(thebibmem (memq thebib rest)))
 (when (not (or thebib bib))
 (setq bib (assq 'bib docstruct)
-	    thebib (assq 'thebib docstruct)
+thebib (assq 'thebib docstruct)
-	    bibmem (memq bib docstruct)
+bibmem (memq bib docstruct)
-	    thebibmem (memq thebib docstruct)))
+thebibmem (memq thebib docstruct)))
 (if (> (length bibmem) (length thebibmem))
-	(if bib 'bib nil)
+(if bib 'bib nil)
 (if thebib 'thebib nil))))
 (defun reftex-get-bibfile-list ()
 ;; Return list of bibfiles for current document.
 ;; When using the chapterbib or bibunits package you should either
 (error "\\bibliography statement missing or .bib files not found")))
 ;; Find a certain reference in any of the BibTeX files.
 (defun reftex-pop-to-bibtex-entry (key file-list &optional mark-to-kill
-				       highlight item return)
+highlight item return)
 ;; Find BibTeX KEY in any file in FILE-LIST in another window.
 ;; If MARK-TO-KILL is non-nil, mark new buffer to kill.
 ;; If HIGHLIGHT is non-nil, highlight the match.
 ;; If ITEM in non-nil, search for bibitem instead of database entry.
 ;; If RETURN is non-nil, just return the entry.
 (let* ((re
-	  (if item
+(if item
-	      (concat "\\\\bibitem\\(\\[[^]]*\\]\\)?{" (regexp-quote key) "}")
+(concat "\\\\bibitem\\(\\[[^]]*\\]\\)?{" (regexp-quote key) "}")
-	    (concat "@[a-zA-Z]+[ \t\n\r]*[{(][ \t\n\r]*" (regexp-quote key)
+(concat "@[a-zA-Z]+[ \t\n\r]*[{(][ \t\n\r]*" (regexp-quote key)
-		    "[, \t\r\n}]")))
+"[, \t\r\n}]")))
-	 (buffer-conf (current-buffer))
+(buffer-conf (current-buffer))
 file buf pos)
 (catch 'exit
 (while file-list
 (setq file (car file-list)
 (set-buffer buf)
 (widen)
 (goto-char (point-min))
 (when (re-search-forward re nil t)
 (goto-char (match-beginning 0))
-	  (setq pos (point))
+(setq pos (point))
-	  (when return
+(when return
-	    ;; Just return the relevant entry
+;; Just return the relevant entry
-	    (if item (goto-char (match-end 0)))
+(if item (goto-char (match-end 0)))
-	    (setq return (buffer-substring
+(setq return (buffer-substring
-			  (point) (reftex-end-of-bib-entry item)))
+(point) (reftex-end-of-bib-entry item)))
-	    (set-buffer buffer-conf)
+(set-buffer buffer-conf)
-	    (throw 'exit return))
+(throw 'exit return))
-	  (switch-to-buffer-other-window buf)
+(switch-to-buffer-other-window buf)
-	  (goto-char pos)
+(goto-char pos)
 (recenter 0)
 (if highlight
 (reftex-highlight 0 (match-beginning 0) (match-end 0)))
 (throw 'exit (selected-window))))
 (set-buffer buffer-conf)
 (if item
-	  (error "No \\bibitem with citation key %s" key)
+(error "No \\bibitem with citation key %s" key)
-	(error "No BibTeX entry with citation key %s" key)))))
+(error "No BibTeX entry with citation key %s" key)))))
 (defun reftex-end-of-bib-entry (item)
 (save-excursion
 (condition-case nil
-	(if item
+(if item
-	    (progn (end-of-line)
+(progn (end-of-line)
-		   (re-search-forward
+(re-search-forward
-		    "\\\\bibitem\\|\\end{thebibliography}")
+"\\\\bibitem\\|\\end{thebibliography}")
-		   (1- (match-beginning 0)))
+(1- (match-beginning 0)))
-	  (progn (forward-list 1) (point)))
+(progn (forward-list 1) (point)))
 (error (min (point-max) (+ 300 (point)))))))
 ;; Parse bibtex buffers
-(defun reftex-extract-bib-entries (buffers re-list)
+(defun reftex-extract-bib-entries (buffers)
 ;; Extract bib entries which match regexps from BUFFERS.
 ;; BUFFERS is a list of buffers or file names.
 ;; Return list with entries."
-(let* ((buffer-list (if (listp buffers) buffers (list buffers)))
+(let* (re-list first-re rest-re
-	 (first-re (car re-list))   ; We'll use the first re to find things,
+(buffer-list (if (listp buffers) buffers (list buffers)))
-	 (rest-re (cdr re-list))    ; the others to narrow down.
+found-list entry buffer1 buffer alist
-	 found-list entry buffer1 buffer alist
+key-point start-point end-point default)
-	 key-point start-point end-point default)
+;; Read a regexp, completing on known citation keys.
+(setq default (regexp-quote (reftex-get-bibkey-default)))
+(setq re-list
+(split-string
+(completing-read
+(concat
+"Regex { && Regex...}: "
+"[" default "]: ")
+(if reftex-mode
+(if (fboundp 'LaTeX-bibitem-list)
+(LaTeX-bibitem-list)
+(cdr (assoc 'bibview-cache
+(symbol-value reftex-docstruct-symbol))))
+nil)
+nil nil nil 'reftex-cite-regexp-hist)
+"[ \t]*&&[ \t]*"))
+(if (or (null re-list ) (equal re-list '("")))
+(setq re-list (list default)))
+(setq first-re (car re-list)    ; We'll use the first re to find things,
+rest-re  (cdr re-list))   ; the others to narrow down.
+(if (string-match "\\`[ \t]*\\'" (or first-re ""))
+(error "Empty regular expression"))
 (save-excursion
 (save-window-excursion
 ;; Walk through all bibtex files
 (if (not buffer1)
 (message "No such BibTeX file %s (ignored)" buffer)
 (message "Scanning bibliography database %s" buffer1))
 (set-buffer buffer1)
-	  (reftex-with-special-syntax-for-bib
+(reftex-with-special-syntax-for-bib
-	   (save-excursion
+(save-excursion
-	     (goto-char (point-min))
+(goto-char (point-min))
-	     (while (re-search-forward first-re nil t)
+(while (re-search-forward first-re nil t)
-	       (catch 'search-again
+(catch 'search-again
-		 (setq key-point (point))
+(setq key-point (point))
-		 (unless (re-search-backward
+(unless (re-search-backward
-			  "^[ \t]*@\\([a-zA-Z]+\\)[ \t\n\r]*[{(]" nil t)
+"\\(\\`\\|[\n\r]\\)[ \t]*@\\([a-zA-Z]+\\)[ \t\n\r]*[{(]" nil t)
-		   (throw 'search-again nil))
+(throw 'search-again nil))
-		 (setq start-point (point))
+(setq start-point (point))
-		 (goto-char (match-end 0))
+(goto-char (match-end 0))
-		 (condition-case nil
+(condition-case nil
-		     (up-list 1)
+(up-list 1)
-		   (error (goto-char key-point)
+(error (goto-char key-point)
 (throw 'search-again nil)))
-		 (setq end-point (point))
+(setq end-point (point))
-		 ;; Ignore @string, @comment and @c entries or things
+;; Ignore @string, @comment and @c entries or things
-		 ;; outside entries
+;; outside entries
-		 (when (or (member-ignore-case (match-string 1)
+(when (or (string= (downcase (match-string 2)) "string")
-					       '("string" "comment" "c"))
+(string= (downcase (match-string 2)) "comment")
-			   (< (point) key-point)) ; this means match not in {}
+(string= (downcase (match-string 2)) "c")
-		   (goto-char key-point)
+(< (point) key-point)) ; this means match not in {}
-		   (throw 'search-again nil))
+(goto-char key-point)
+(throw 'search-again nil))
-		 ;; Well, we have got a match
-		 (setq entry (buffer-substring start-point (point)))
+;; Well, we have got a match
+;;(setq entry (concat
-		 ;; Check if other regexp match as well
+;;             (buffer-substring start-point (point)) "\n"))
-		 (setq re-list rest-re)
+(setq entry (buffer-substring start-point (point)))
-		 (while re-list
-		   (unless (string-match (car re-list) entry)
+;; Check if other regexp match as well
-		     ;; nope - move on
+(setq re-list rest-re)
-		     (throw 'search-again nil))
+(while re-list
-		   (pop re-list))
+(unless (string-match (car re-list) entry)
+;; nope - move on
-		 (setq alist (reftex-parse-bibtex-entry
+(throw 'search-again nil))
-			      nil start-point end-point))
+(pop re-list))
-		 (push (cons "&entry" entry) alist)
+(setq alist (reftex-parse-bibtex-entry
-		 ;; check for crossref entries
+nil start-point end-point))
-		 (if (assoc "crossref" alist)
+(push (cons "&entry" entry) alist)
-		     (setq alist
-			   (append
+;; check for crossref entries
-			    alist (reftex-get-crossref-alist alist))))
+(if (assoc "crossref" alist)
+(setq alist
-		 ;; format the entry
+(append
-		 (push (cons "&formatted" (reftex-format-bib-entry alist))
+alist (reftex-get-crossref-alist alist))))
-		       alist)
+;; format the entry
-		 ;; make key the first element
+(push (cons "&formatted" (reftex-format-bib-entry alist))
-		 (push (reftex-get-bib-field "&key" alist) alist)
+alist)
-		 ;; add it to the list
+;; make key the first element
-		 (push alist found-list)))))
+(push (reftex-get-bib-field "&key" alist) alist)
-	  (reftex-kill-temporary-buffers))))
+;; add it to the list
+(push alist found-list)))))
+(reftex-kill-temporary-buffers))))
 (setq found-list (nreverse found-list))
 ;; Sorting
 (cond
 ((eq 'author reftex-sort-bibtex-matches)
 (error nil))
 (reftex-parse-bibtex-entry nil start (point)))
 nil)))))
 ;; Parse the bibliography environment
-(defun reftex-extract-bib-entries-from-thebibliography (files re-list)
+(defun reftex-extract-bib-entries-from-thebibliography (files)
 ;; Extract bib-entries from the \begin{thebibliography} environment.
 ;; Parsing is not as good as for the BibTeX database stuff.
 ;; The environment should be located in file FILE.
-(let* (start end buf entries re file default)
+(let* (start end buf entries re re-list file default)
 (unless files
 (error "Need file name to find thebibliography environment"))
 (while (setq file (pop files))
 (setq buf (reftex-get-file-buffer-force
-		 file (not reftex-keep-temporary-buffers)))
+file (not reftex-keep-temporary-buffers)))
 (unless buf
-	(error "No such file %s" file))
+(error "No such file %s" file))
 (message "Scanning thebibliography environment in %s" file)
 (save-excursion
-	(set-buffer buf)
+(set-buffer buf)
-	(save-restriction
+(save-restriction
-	  (widen)
+(widen)
-	  (goto-char (point-min))
+(goto-char (point-min))
-	  (while (re-search-forward
+(while (re-search-forward
-		  "\\(\\`\\|[\n\r]\\)[ \t]*\\\\begin{thebibliography}" nil t)
+"\\(\\`\\|[\n\r]\\)[ \t]*\\\\begin{thebibliography}" nil t)
-	    (beginning-of-line 2)
+(beginning-of-line 2)
-	    (setq start (point))
+(setq start (point))
-	    (if (re-search-forward
+(if (re-search-forward
-		 "\\(\\`\\|[\n\r]\\)[ \t]*\\\\end{thebibliography}" nil t)
+"\\(\\`\\|[\n\r]\\)[ \t]*\\\\end{thebibliography}" nil t)
-		(progn
+(progn
-		  (beginning-of-line 1)
+(beginning-of-line 1)
-		  (setq end (point))))
+(setq end (point))))
-	    (when (and start end)
+(when (and start end)
-	      (setq entries
+(setq entries
-		    (append entries
+(append entries
 (mapcar 'reftex-parse-bibitem
-			(delete ""
+(delete ""
-				(split-string
+(split-string
-				 (buffer-substring-no-properties start end)
+(buffer-substring-no-properties start end)
-				 "[ \t\n\r]*\\\\bibitem\\(\\[[^]]*]\\)*"))))))
+"[ \t\n\r]*\\\\bibitem\\(\\[[^]]*]\\)*"))))))
-	    (goto-char end)))))
+(goto-char end)))))
 (unless entries
 (error "No bibitems found"))
+;; Read a regexp, completing on known citation keys.
+(setq default (regexp-quote (reftex-get-bibkey-default)))
+(setq re-list
+(split-string
+(completing-read
+(concat
+"Regex { && Regex...}: "
+"[" default "]: ")
+(if reftex-mode
+(if (fboundp 'LaTeX-bibitem-list)
+(LaTeX-bibitem-list)
+(cdr (assoc 'bibview-cache
+(symbol-value reftex-docstruct-symbol))))
+nil)
+nil nil nil 'reftex-cite-regexp-hist)
+"[ \t]*&&[ \t]*"))
+(if (or (null re-list ) (equal re-list '("")))
+(setq re-list (list default)))
+(if (string-match "\\`[ \t]*\\'" (car re-list))
+(error "Empty regular expression"))
 (while (and (setq re (pop re-list)) entries)
 (setq entries
-	    (delq nil (mapcar
+(delq nil (mapcar
-		       (lambda (x)
+(lambda (x)
-			 (if (string-match re (cdr (assoc "&entry" x)))
+(if (string-match re (cdr (assoc "&entry" x)))
-			     x nil))
+x nil))
-		       entries))))
+entries))))
 (setq entries
-	  (mapcar
+(mapcar
-	    (lambda (x)
+(lambda (x)
-	      (push (cons "&formatted" (reftex-format-bibitem x)) x)
+(push (cons "&formatted" (reftex-format-bibitem x)) x)
-	      (push (reftex-get-bib-field "&key" x) x)
+(push (reftex-get-bib-field "&key" x) x)
-	      x)
+x)
-	   entries))
+entries))
 entries))
 (defun reftex-get-bibkey-default ()
 ;; Return the word before the cursor.  If the cursor is in a
 ;; citation macro, return the word before the macro.
 (let* ((macro (reftex-what-macro 1)))
 (save-excursion
 (if (and macro (string-match "cite" (car macro)))
-	  (goto-char (cdr macro)))
+(goto-char (cdr macro)))
 (skip-chars-backward "^a-zA-Z0-9")
 (reftex-this-word))))
 ;; Parse and format individual entries
 (save-restriction
 (if entry
 (progn
 (set-buffer (get-buffer-create " *RefTeX-scratch*"))
 (fundamental-mode)
-	      (set-syntax-table reftex-syntax-table-for-bib)
+(set-syntax-table reftex-syntax-table-for-bib)
 (erase-buffer)
 (insert entry))
 (widen)
 (narrow-to-region from to))
 (goto-char (point-min))
 (defun reftex-get-bib-field (fieldname entry &optional format)
 ;; Extract the field FIELDNAME from an ENTRY
 (let ((cell (assoc fieldname entry)))
 (if cell
-	(if format
+(if format
-	    (format format (cdr cell))
+(format format (cdr cell))
-	  (cdr cell))
+(cdr cell))
 "")))
 (defun reftex-format-bib-entry (entry)
 ;; Format a BibTeX ENTRY so that it is nice to look at
 (let*
 (reftex-get-bib-field "booktitle" entry "in: %s"))
 (t ""))))
 (setq authors (reftex-truncate authors 30 t t))
 (when (reftex-use-fonts)
 (put-text-property 0 (length key)     'face
-			 (reftex-verified-face reftex-label-face
+(reftex-verified-face reftex-label-face
-					       'font-lock-constant-face
+'font-lock-constant-face
-					       'font-lock-reference-face)
+'font-lock-reference-face)
 key)
 (put-text-property 0 (length authors) 'face reftex-bib-author-face
 authors)
 (put-text-property 0 (length year)    'face reftex-bib-year-face
 year)
 (defun reftex-parse-bibitem (item)
 ;; Parse a \bibitem entry
 (let ((key "") (text ""))
 (when (string-match "\\`{\\([^}]+\\)}\\([^\000]*\\)" item)
 (setq key (match-string 1 item)
-	    text (match-string 2 item)))
+text (match-string 2 item)))
 ;; Clean up the text a little bit
 (while (string-match "[\n\r\t]\\|[ \t][ \t]+" text)
 (setq text (replace-match " " nil t text)))
 (if (string-match "\\`[ \t]+" text)
-	(setq text (replace-match "" nil t text)))
+(setq text (replace-match "" nil t text)))
 (list
 (cons "&key" key)
 (cons "&text" text)
 (cons "&entry" (concat key " " text)))))
 (defun reftex-format-bibitem (item)
 ;; Format a \bibitem entry so that it is (relatively) nice to look at.
 (let ((text (reftex-get-bib-field "&text" item))
-	(key  (reftex-get-bib-field "&key" item))
+(key  (reftex-get-bib-field "&key" item))
-	(lines nil))
+(lines nil))
 ;; Wrap the text into several lines.
 (while (and (> (length text) 70)
-		(string-match " " (substring text 60)))
+(string-match " " (substring text 60)))
-	(push (substring text 0 (+ 60 (match-beginning 0))) lines)
+(push (substring text 0 (+ 60 (match-beginning 0))) lines)
-	(setq text (substring text (+ 61 (match-beginning 0)))))
+(setq text (substring text (+ 61 (match-beginning 0)))))
 (push text lines)
 (setq text (mapconcat 'identity (nreverse lines) "\n     "))
 (when (reftex-use-fonts)
 (put-text-property 0 (length text) 'face reftex-bib-author-face text))
 (defun reftex-do-citation (&optional arg no-insert format-key)
 ;; This really does the work of reftex-citation.
 (let* ((format (reftex-figure-out-cite-format arg no-insert format-key))
-	 (docstruct-symbol reftex-docstruct-symbol)
+(docstruct-symbol reftex-docstruct-symbol)
-	 (selected-entries (reftex-offer-bib-menu))
+(selected-entries (reftex-offer-bib-menu))
-	 (insert-entries selected-entries)
+(insert-entries selected-entries)
-	 entry string cite-view)
+entry string cite-view)
 (unless selected-entries (error "Quit"))
 (if (stringp selected-entries)
-	;; Nonexistent entry
+;; Nonexistent entry
-	(setq selected-entries nil
+(setq selected-entries nil
-	      insert-entries (list (list selected-entries
+insert-entries (list (list selected-entries
-					 (cons "&key" selected-entries))))
+(cons "&key" selected-entries))))
 ;; It makes sense to compute the cite-view strings.
 (setq cite-view t))
 (when (eq (car selected-entries) 'concat)
 ;; All keys go into a single command - we need to trick a little
 (pop selected-entries)
 (let ((concat-keys (mapconcat 'car selected-entries ",")))
-	(setq insert-entries
+(setq insert-entries
-	      (list (list concat-keys (cons "&key" concat-keys))))))
+(list (list concat-keys (cons "&key" concat-keys))))))
 (unless no-insert
 ;; We shall insert this into the buffer...
 (message "Formatting...")
 (while (setq entry (pop insert-entries))
-	;; Format the citation and insert it
+;; Format the citation and insert it
-	(setq string (if reftex-format-cite-function
+(setq string (if reftex-format-cite-function
-			 (funcall reftex-format-cite-function
+(funcall reftex-format-cite-function
-				  (reftex-get-bib-field "&key" entry)
+(reftex-get-bib-field "&key" entry)
-				  format)
+format)
-		       (reftex-format-citation entry format)))
+(reftex-format-citation entry format)))
-	(insert string))
+(insert string))
 ;; Reposition cursor?
 (when (string-match "\\?" string)
-	(search-backward "?")
+(search-backward "?")
-	(delete-char 1))
+(delete-char 1))
 ;; Tell AUCTeX
 (when (and reftex-mode
-		 (fboundp 'LaTeX-add-bibitems)
+(fboundp 'LaTeX-add-bibitems)
-		 reftex-plug-into-AUCTeX)
+reftex-plug-into-AUCTeX)
-	(apply 'LaTeX-add-bibitems (mapcar 'car selected-entries)))
+(apply 'LaTeX-add-bibitems (mapcar 'car selected-entries)))
 ;; Produce the cite-view strings
 (when (and reftex-mode reftex-cache-cite-echo cite-view)
-	(mapcar (lambda (entry)
+(mapcar (lambda (entry)
-		  (reftex-make-cite-echo-string entry docstruct-symbol))
+(reftex-make-cite-echo-string entry docstruct-symbol))
-		selected-entries))
+selected-entries))
 (message ""))
 (set-marker reftex-select-return-marker nil)
 (reftex-kill-buffer "*RefTeX Select*")
 ;; Check if the prefix arg was numeric, and call recursively
 (when (integerp arg)
 (if (> arg 1)
-	  (progn
+(progn
-	    (skip-chars-backward "}")
+(skip-chars-backward "}")
-	    (decf arg)
+(decf arg)
-	    (reftex-do-citation arg))
+(reftex-do-citation arg))
-	(forward-char 1)))
+(forward-char 1)))
 ;; Return the citation key
 (car (car selected-entries))))
 (defun reftex-figure-out-cite-format (arg &optional no-insert format-key)
 ;; Check if there is already a cite command at point and change cite format
 ;; in order to only add another reference in the same cite command.
 (let ((macro (car (reftex-what-macro 1)))
-	(cite-format-value (reftex-get-cite-format))
+(cite-format-value (reftex-get-cite-format))
-	key format)
+key format)
 (cond
 (no-insert
 ;; Format does not really matter because nothing will be inserted.
 (setq format "%l"))
 ((and (stringp macro)
-	   (string-match "\\`\\\\cite\\|cite\\'" macro))
+(string-match "\\`\\\\cite\\|cite\\'" macro))
 ;; We are already inside a cite macro
 (if (or (not arg) (not (listp arg)))
-	  (setq format
+(setq format
-		(concat
+(concat
-		 (if (member (preceding-char) '(?\{ ?,)) "" ",")
+(if (member (preceding-char) '(?\{ ?,)) "" ",")
-		 "%l"
+"%l"
-		 (if (member (following-char) '(?\} ?,)) "" ",")))
+(if (member (following-char) '(?\} ?,)) "" ",")))
-	(setq format "%l")))
+(setq format "%l")))
 (t
 ;; Figure out the correct format
 (setq format
 (if (and (symbolp cite-format-value)
-		     (assq cite-format-value reftex-cite-format-builtin))
+(assq cite-format-value reftex-cite-format-builtin))
-		(nth 2 (assq cite-format-value reftex-cite-format-builtin))
+(nth 2 (assq cite-format-value reftex-cite-format-builtin))
-	      cite-format-value))
+cite-format-value))
 (when (listp format)
-	(setq key
+(setq key
-	      (or format-key
+(or format-key
-		  (reftex-select-with-char
+(reftex-select-with-char
-		   "" (concat "SELECT A CITATION FORMAT\n\n"
+"" (concat "SELECT A CITATION FORMAT\n\n"
-			      (mapconcat
+(mapconcat
-			       (lambda (x)
+(lambda (x)
-				 (format "[%c] %s  %s" (car x)
+(format "[%c] %s  %s" (car x)
-					 (if (> (car x) 31) " " "")
+(if (> (car x) 31) " " "")
-					 (cdr x)))
+(cdr x)))
-			       format "\n")))))
+format "\n")))))
-	(if (assq key format)
+(if (assq key format)
-	    (setq format (cdr (assq key format)))
+(setq format (cdr (assq key format)))
-	  (error "No citation format associated with key `%c'" key)))))
+(error "No citation format associated with key `%c'" key)))))
 format))
 (defun reftex-citep ()
 "Call `reftex-citation' with a format selector `?p'."
 (interactive)
 (defvar reftex-select-bib-map)
 (defun reftex-offer-bib-menu ()
 ;; Offer bib menu and return list of selected items
 (let ((bibtype (reftex-bib-or-thebib))
-	found-list rtn key data selected-entries re-list)
+found-list rtn key data selected-entries)
 (while
-	(not
+(not
-	 (catch 'done
+(catch 'done
-	   ;; Get the search regexps, completing on known citation keys.
+;; Scan bibtex files
-	   (setq re-list
+(setq found-list
-		 (let ((default (regexp-quote (reftex-get-bibkey-default))))
+(cond
-		   (split-string
+((eq bibtype 'bib)
-		    (completing-read
+;              ((assq 'bib (symbol-value reftex-docstruct-symbol))
-		     (concat
+;; using BibTeX database files.
-		      "Regex { && Regex...}: "
+(reftex-extract-bib-entries (reftex-get-bibfile-list)))
-		      "[" default "]: ")
+((eq bibtype 'thebib)
-		     (if reftex-mode
+;              ((assq 'thebib (symbol-value reftex-docstruct-symbol))
-			 (if (fboundp 'LaTeX-bibitem-list)
+;; using thebibliography environment.
-			     (LaTeX-bibitem-list)
+(reftex-extract-bib-entries-from-thebibliography
-			   (cdr (assoc 'bibview-cache
+(reftex-uniquify
-				       (symbol-value reftex-docstruct-symbol))))
+(mapcar 'cdr
-		       nil)
+(reftex-all-assq
-		     nil nil nil 'reftex-cite-regexp-hist default)
+'thebib (symbol-value reftex-docstruct-symbol))))))
-		    "[ \t]*&&[ \t]*")))
+(reftex-default-bibliography
+(message "Using default bibliography")
-	   (if (string-match "\\`[ \t]*\\'" (car re-list))
+(reftex-extract-bib-entries (reftex-default-bibliography)))
-	       (error "Empty regular expression"))
+(t (error "No valid bibliography in this document, and no default available"))))
-	   ;; Scan bibtex files
+(unless found-list
-	   (setq found-list
+(error "Sorry, no matches found"))
-	      (cond
-	       ((eq bibtype 'bib)
+;; Remember where we came from
-;	       ((assq 'bib (symbol-value reftex-docstruct-symbol))
+(setq reftex-call-back-to-this-buffer (current-buffer))
-		;; using BibTeX database files.
+(set-marker reftex-select-return-marker (point))
-		(reftex-extract-bib-entries (reftex-get-bibfile-list) re-list))
-	       ((eq bibtype 'thebib)
+;; Offer selection
-;	       ((assq 'thebib (symbol-value reftex-docstruct-symbol))
+(save-window-excursion
-		;; using thebibliography environment.
+(delete-other-windows)
-		(reftex-extract-bib-entries-from-thebibliography
+(let ((default-major-mode 'reftex-select-bib-mode))
-		 (reftex-uniquify
+(reftex-kill-buffer "*RefTeX Select*")
-		  (mapcar 'cdr
+(switch-to-buffer-other-window "*RefTeX Select*")
-			  (reftex-all-assq
+(unless (eq major-mode 'reftex-select-bib-mode)
-			   'thebib (symbol-value reftex-docstruct-symbol))))
+(reftex-select-bib-mode))
-		 re-list))
+(let ((buffer-read-only nil))
-	       (reftex-default-bibliography
+(erase-buffer)
-		(message "Using default bibliography")
+(reftex-insert-bib-matches found-list)))
-		(reftex-extract-bib-entries (reftex-default-bibliography)
+(setq buffer-read-only t)
-					    re-list))
+(if (= 0 (buffer-size))
-	       (t (error "No valid bibliography in this document, and no default available"))))
+(error "No matches found"))
+(setq truncate-lines t)
-	   (unless found-list
+(goto-char 1)
-	     (error "Sorry, no matches found"))
+(while t
+(setq rtn
-	  ;; Remember where we came from
+(reftex-select-item
-	  (setq reftex-call-back-to-this-buffer (current-buffer))
+reftex-citation-prompt
-	  (set-marker reftex-select-return-marker (point))
+reftex-citation-help
+reftex-select-bib-map
-	  ;; Offer selection
+nil
-	  (save-window-excursion
+'reftex-bibtex-selection-callback nil))
-	    (delete-other-windows)
+(setq key (car rtn)
-	    (let ((default-major-mode 'reftex-select-bib-mode))
+data (nth 1 rtn))
-	      (reftex-kill-buffer "*RefTeX Select*")
+(unless key (throw 'done t))
-	      (switch-to-buffer-other-window "*RefTeX Select*")
+(cond
-	      (unless (eq major-mode 'reftex-select-bib-mode)
+((eq key ?g)
-		(reftex-select-bib-mode))
+;; Start over
-	      (let ((buffer-read-only nil))
+(throw 'done nil))
-		(erase-buffer)
+((eq key ?r)
-		(reftex-insert-bib-matches found-list)))
+;; Restrict with new regular expression
-	    (setq buffer-read-only t)
+(setq found-list (reftex-restrict-bib-matches found-list))
-	    (if (= 0 (buffer-size))
+(let ((buffer-read-only nil))
-		(error "No matches found"))
+(erase-buffer)
-	    (setq truncate-lines t)
+(reftex-insert-bib-matches found-list))
-	    (goto-char 1)
+(goto-char 1))
-	    (while t
+((eq key ?A)
-	      (setq rtn
+;; Take all (marked)
-		    (reftex-select-item
+(setq selected-entries
-		     reftex-citation-prompt
+(if reftex-select-marked
-		     reftex-citation-help
+(mapcar 'car (nreverse reftex-select-marked))
-		     reftex-select-bib-map
+found-list))
-		     nil
+(throw 'done t))
-		     'reftex-bibtex-selection-callback nil))
+((eq key ?a)
-	      (setq key (car rtn)
+;; Take all (marked), and push the symbol 'concat
-		    data (nth 1 rtn))
+(setq selected-entries
-	      (unless key (throw 'done t))
+(cons 'concat
-	      (cond
+(if reftex-select-marked
-	       ((eq key ?g)
+(mapcar 'car (nreverse reftex-select-marked))
-		;; Start over
+found-list)))
-		(throw 'done nil))
+(throw 'done t))
-	       ((eq key ?r)
+((or (eq key ?\C-m)
-		;; Restrict with new regular expression
+(eq key 'return))
-		(setq found-list (reftex-restrict-bib-matches found-list))
+;; Take selected
-		(let ((buffer-read-only nil))
+(setq selected-entries
-		  (erase-buffer)
+(if reftex-select-marked
-		  (reftex-insert-bib-matches found-list))
+(cons 'concat
-		(goto-char 1))
+(mapcar 'car (nreverse reftex-select-marked)))
-	       ((eq key ?A)
+(if data (list data) nil)))
-		;; Take all (marked)
+(throw 'done t))
-		(setq selected-entries
+((stringp key)
-		      (if reftex-select-marked
+;; Got this one with completion
-			  (mapcar 'car (nreverse reftex-select-marked))
+(setq selected-entries key)
-			found-list))
+(throw 'done t))
-		(throw 'done t))
+(t
-	       ((eq key ?a)
+(ding))))))))
-		;; Take all (marked), and push the symbol 'concat
-		(setq selected-entries
-		      (cons 'concat
-			    (if reftex-select-marked
-				(mapcar 'car (nreverse reftex-select-marked))
-			      found-list)))
-		(throw 'done t))
-	       ((or (eq key ?\C-m)
-		    (eq key 'return))
-		;; Take selected
-		(setq selected-entries
-		      (if reftex-select-marked
-			  (cons 'concat
-				(mapcar 'car (nreverse reftex-select-marked)))
-			(if data (list data) nil)))
-		(throw 'done t))
-	       ((stringp key)
-		;; Got this one with completion
-		(setq selected-entries key)
-		(throw 'done t))
-	       (t
-		(ding))))))))
 selected-entries))
 (defun reftex-restrict-bib-matches (found-list)
 ;; Limit FOUND-LIST with more regular expressions
 (let ((re-list (split-string (read-string
-				"RegExp [ && RegExp...]: "
+"RegExp [ && RegExp...]: "
-				nil 'reftex-cite-regexp-hist)
+nil 'reftex-cite-regexp-hist)
-			       "[ \t]*&&[ \t]*"))
+"[ \t]*&&[ \t]*"))
-	(found-list-r found-list)
+(found-list-r found-list)
-	re)
+re)
 (while (setq re (pop re-list))
 (setq found-list-r
-	    (delq nil
+(delq nil
-		  (mapcar
+(mapcar
-		   (lambda (x)
+(lambda (x)
-		     (if (string-match
+(if (string-match
-			  re (cdr (assoc "&entry" x)))
+re (cdr (assoc "&entry" x)))
-			 x
+x
-		       nil))
+nil))
-		   found-list-r))))
+found-list-r))))
 (if found-list-r
-	found-list-r
+found-list-r
 (ding)
 found-list)))
 (defun reftex-insert-bib-matches (list)
 ;; Insert the bib matches and number them correctly
 (let ((mouse-face
-	 (if (memq reftex-highlight-selection '(mouse both))
+(if (memq reftex-highlight-selection '(mouse both))
-	     reftex-mouse-selected-face
+reftex-mouse-selected-face
-	   nil))
+nil))
-	tmp len)
+tmp len)
 (mapcar
 (lambda (x)
 (setq tmp (cdr (assoc "&formatted" x))
-	     len (length tmp))
+len (length tmp))
 (put-text-property 0 len :data x tmp)
 (put-text-property 0 (1- len) 'mouse-face mouse-face tmp)
 (insert tmp))
 list))
 (run-hooks 'reftex-display-copied-context-hook))
 (reftex-get-bib-names "author" entry)
 (or n 2)))
 ((= l ?A) (car (reftex-get-bib-names "author" entry)))
 ((= l ?b) (reftex-get-bib-field "booktitle" entry "in: %s"))
 ((= l ?B) (reftex-abbreviate-title
-			  (reftex-get-bib-field "booktitle" entry "in: %s")))
+(reftex-get-bib-field "booktitle" entry "in: %s")))
 ((= l ?c) (reftex-get-bib-field "chapter" entry))
 ((= l ?d) (reftex-get-bib-field "edition" entry))
 ((= l ?e) (reftex-format-names
 (reftex-get-bib-names "editor" entry)
 (or n 2)))
 ((= l ?s) (reftex-get-bib-field "school" entry))
 ((= l ?u) (reftex-get-bib-field "publisher" entry))
 ((= l ?r) (reftex-get-bib-field "address" entry))
 ((= l ?t) (reftex-get-bib-field "title" entry))
 ((= l ?T) (reftex-abbreviate-title
-			  (reftex-get-bib-field "title" entry)))
+(reftex-get-bib-field "title" entry)))
 ((= l ?v) (reftex-get-bib-field "volume" entry))
 ((= l ?y) (reftex-get-bib-field "year" entry)))))
 (if (string= rpl "")
 (setq b (match-beginning 2) e (match-end 2))
 format)
 (defun reftex-make-cite-echo-string (entry docstruct-symbol)
 ;; Format a bibtex entry for the echo area and cache the result.
 (let* ((key (reftex-get-bib-field "&key" entry))
-	 (string
+(string
-	  (let* ((reftex-cite-punctuation '(" " " & " " etal.")))
+(let* ((reftex-cite-punctuation '(" " " & " " etal.")))
-	    (reftex-format-citation entry reftex-cite-view-format)))
+(reftex-format-citation entry reftex-cite-view-format)))
-	 (cache (assq 'bibview-cache (symbol-value docstruct-symbol)))
+(cache (assq 'bibview-cache (symbol-value docstruct-symbol)))
-	 (cache-entry (assoc key (cdr cache))))
+(cache-entry (assoc key (cdr cache))))
 (unless cache
 ;; This docstruct has no cache - make one.
 (set docstruct-symbol (cons (cons 'bibview-cache nil)
-				  (symbol-value docstruct-symbol))))
+(symbol-value docstruct-symbol))))
 (when reftex-cache-cite-echo
 (setq key (copy-sequence key))
 (set-text-properties 0 (length key) nil key)
 (set-text-properties 0 (length string) nil string)
 (if cache-entry
-	  (unless (string= (cdr cache-entry) string)
+(unless (string= (cdr cache-entry) string)
-	    (setcdr cache-entry string)
+(setcdr cache-entry string)
-	    (put reftex-docstruct-symbol 'modified t))
+(put reftex-docstruct-symbol 'modified t))
-	(push (cons key string) (cdr cache))
+(push (cons key string) (cdr cache))
-	(put reftex-docstruct-symbol 'modified t)))
+(put reftex-docstruct-symbol 'modified t)))
 string))
 (defun reftex-bibtex-selection-callback (data ignore no-revisit)
 ;; Callback function to be called from the BibTeX selection, in
 ;; order to display context.  This function is relatively slow and not
 (key (reftex-get-bib-field "&key" data))
 bibfile-list item bibtype)
 (catch 'exit
 (save-excursion
-	(set-buffer reftex-call-back-to-this-buffer)
+(set-buffer reftex-call-back-to-this-buffer)
-	(setq bibtype (reftex-bib-or-thebib))
+(setq bibtype (reftex-bib-or-thebib))
-	(cond
+(cond
-	 ((eq bibtype 'bib)
+((eq bibtype 'bib)
-;	 ((assq 'bib (symbol-value reftex-docstruct-symbol))
+;        ((assq 'bib (symbol-value reftex-docstruct-symbol))
-	  (setq bibfile-list (reftex-get-bibfile-list)))
+(setq bibfile-list (reftex-get-bibfile-list)))
-	 ((eq bibtype 'thebib)
+((eq bibtype 'thebib)
-;	 ((assq 'thebib (symbol-value reftex-docstruct-symbol))
+;        ((assq 'thebib (symbol-value reftex-docstruct-symbol))
-	  (setq bibfile-list
+(setq bibfile-list
-		(reftex-uniquify
+(reftex-uniquify
-		 (mapcar 'cdr
+(mapcar 'cdr
-			 (reftex-all-assq
+(reftex-all-assq
-			  'thebib (symbol-value reftex-docstruct-symbol))))
+'thebib (symbol-value reftex-docstruct-symbol))))
-		item t))
+item t))
-	 (reftex-default-bibliography
+(reftex-default-bibliography
-	  (setq bibfile-list (reftex-default-bibliography)))
+(setq bibfile-list (reftex-default-bibliography)))
-	 (t (ding) (throw 'exit nil))))
+(t (ding) (throw 'exit nil))))
 (when no-revisit
-	(setq bibfile-list (reftex-visited-files bibfile-list)))
+(setq bibfile-list (reftex-visited-files bibfile-list)))
 (condition-case nil
-	  (reftex-pop-to-bibtex-entry
+(reftex-pop-to-bibtex-entry
-	   key bibfile-list (not reftex-keep-temporary-buffers) t item)
+key bibfile-list (not reftex-keep-temporary-buffers) t item)
-	(error (ding))))
+(error (ding))))
 (select-window win)))
 ;;; reftex-cite.el ends here

Mercurial > emacs

comparison lisp/textmodes/reftex-cite.el @ 52170:27340819ef07