[bpt/emacs.git] / lisp / textmodes / refer.el

;;; refer.el --- look up references in bibliography files

;; Copyright (C) 1992, 1996, 2001 Free Software Foundation, Inc.

;; Author: Ashwin Ram <ashwin@cc.gatech.edu>
;; Maintainer: Gernot Heiser <gernot@acm.org>
;; Adapted-By: ESR
;; Keywords: bib

;; 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
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.

;;; Commentary:

;; Functions to look up references in bibliography files given lists of
;; keywords, similar to refer(1).  I don't use tags since tags on .bib files
;; only picks up the cite key, where as refer-find-entry looks for occurrences
;; of keywords anywhere in the bibliography entry.
;;
;; To use:
;;      (autoload 'refer-find-entry "refer" nil t)
;; or   (require 'refer)
;;
;;      To look for an article by Knuth about semaphores:
;;          Invoke refer-find-entry, then in response to the Keywords: prompt,
;;          say: Knuth semaphores (a blank-separated list of keywords to be used
;;          as search strings).
;;
;;      To continue the previous search, i.e., to search for the next occurrence
;;      of the keywords, use refer-find-next-entry, or invoke refer-find-entry
;;      with a prefix argument.
;;
;;	Once you've found the entry you want to reference, invoke
;;	refer-yank-key to insert it at point in the current buffer
;;	(typically as the argument of a \cite{} command).
;;
;;	I use (define-key tex-mode-map    "\C-c\C-y"  'refer-yank-key)
;;	to bind this often-used function to a key in (la)tex-mode.
;;
;;      If the list of bibliography files changes, reinitialize the variable
;;      refer-bib-files.
;;
;; To customize:
;;      See variables refer-bib-files, refer-cache-bib-files and
;;      refer-bib-files-regexp.  By default, these are set up so that refer
;;      looks for the keywords you specify in all the .bib files in the current
;;      directory.
;;
;;      The only assumption I make about bib files is that they contain a bunch
;;      of entries, one to a paragraph.  refer-find-entry searches paragraph by
;;      paragraph, looking for a paragraph containing all the keywords
;;      specified.  So you should be able to use pretty much any bib file with
;;      this code.  If your bib file does not use paragraphs to separate
;;      entries, try setting the paragraph-start/separate variables, or changing
;;      the (forward-paragraph 1) call in refer-find-entry-in-file.

;;; Code:

(provide 'refer)

(defgroup refer nil
  "Look up references in bibliography files."
  :prefix "refer-"
  :group 'wp)

(defcustom refer-bib-directory nil
  "Directory, or list of directories, to search for \\.bib files. Can
be set to 'bibinputs or 'texinputs, in which case the environment
variable BIBINPUTS or TEXINPUTS, respectively, is used to obtain a
list of directories.  Useful only if refer-bib-files is set to 'dir or
a list of file names (without directory). A value of nil indicates the
current working directory.

If refer-bib-directory is 'bibinputs or 'texinputs, it is setq'd to
the appropriate list of directories when it is first used.

Note that an empty directory is interpreted by BibTeX as indicating
the default search path. Since Refer does not know that default path,
it cannot search it. Include that path explicitly in your BIBINPUTS
environment if you really want it searched (which is not likely to
happen anyway)."
  :type '(choice (repeat directory) (const bibinputs) (const texinputs))
  :group 'refer)

(defcustom refer-bib-files 'dir
  "*List of \\.bib files to search for references,
or one of the following special values:
nil  = prompt for \\.bib file (if visiting a \\.bib file, use it as default)
auto = read \\.bib file names from appropriate command in buffer (see
       refer-bib-files-regexp) unless the buffer's mode is bibtex-mode,
       in which case only the buffer is searched
dir  = use all \\.bib files in directories referenced by refer-bib-directory.

If a specified file doesn't exist and has no extension, a \\.bib extension
is automatically tried.

If refer-bib-files is nil, auto or dir, it is setq'd to the appropriate
list of files when it is first used if refer-cache-bib-files is t.  If
refer-cache-bib-files is nil, the list of \\.bib files to use is re-read
each time it is needed."
  :type '(choice (repeat file) (const nil) (const auto) (const dir))
  :group 'refer)

(defcustom refer-cache-bib-files t
  "*Variable determining whether the value of refer-bib-files should be cached.
If t, initialize the value of refer-bib-files the first time it is used.  If
nil, re-read the list of \\.bib files depending on the value of refer-bib-files
each time it is needed."
  :type 'boolean
  :group 'refer)

(defcustom refer-bib-files-regexp "\\\\bibliography"
  "*Regexp matching a bibliography file declaration.
The current buffer is expected to contain a line such as
\\bibliography{file1,file2,file3}
which is read to set up refer-bib-files.  The regexp must specify the command
(such as \\bibliography) that is used to specify the list of bib files.  The
command is expected to specify a file name, or a list of comma-separated file
names, within curly braces.
If a specified file doesn't exist and has no extension, a \\.bib extension
is automatically tried."
  :type 'regexp
  :group 'refer)

(make-variable-buffer-local 'refer-bib-files)
(make-variable-buffer-local 'refer-cache-bib-files)
(make-variable-buffer-local 'refer-bib-directory)

;;; Internal variables
(defvar refer-saved-state nil)
(defvar refer-previous-keywords nil)
(defvar refer-saved-pos nil)
(defvar refer-same-file nil)

(defun refer-find-entry (keywords &optional continue)
   "Find entry in refer-bib-files containing KEYWORDS.
If KEYWORDS is nil, prompt user for blank-separated list of keywords.
If CONTINUE is t, or if called interactively with a prefix arg, look for next
entry by continuing search from previous point."
   (interactive (list nil current-prefix-arg))
   (or keywords (setq keywords (if continue
                                   refer-previous-keywords
                                 (read-string "Keywords: "))))
   (setq refer-previous-keywords keywords)
   (refer-find-entry-internal keywords continue))

(defun refer-find-next-entry ()
   "Find next occurrence of entry in refer-bib-files.  See refer-find-entry."
   (interactive)
   (refer-find-entry-internal refer-previous-keywords t))

(defun refer-yank-key ()
  "Inserts at point in current buffer the \"key\" field of the entry
found on the last refer-find-entry or refer-find-next-entry."
  (interactive)
  (let ((old-point (point)))
    (insert
     (save-window-excursion
       (save-excursion
         (find-file (car refer-saved-state))
         (if (looking-at
              "[ \t\n]*@\\s-*[a-zA-Z][a-zA-Z0-9]*\\s-*{\\s-*\\([^ \t\n,]+\\)\\s-*,")
             (buffer-substring (match-beginning 1) (match-end 1))
           (error "Cannot find key for entry in file %s"
                  (car refer-saved-state))))))
    (if (not (= (point) old-point))
      (set-mark old-point))))

(defun refer-find-entry-internal (keywords continue)
   (let ((keywords-list (refer-convert-string-to-list-of-strings keywords))
         (old-buffer (current-buffer))
         (old-window (selected-window))
         (new-window (selected-window))
         (files (if continue
                    refer-saved-state
                  (setq refer-saved-pos nil)
                  (refer-get-bib-files)))
         (n 0)
         (found nil)
         (file nil))
     ;; find window in which to display bibliography file.
     ;; if a bibliography file is already displayed in a window, use
     ;; that one, otherwise use any window other than the current one
     (setq new-window
	   (get-window-with-predicate
	    (lambda (w)
	      (while (and (not (null (setq file (nth n files))))
			  (setq n (1+ n))
			  (not (string-equal file
					     (buffer-file-name
					      (window-buffer w))))))
	      file)))
     (unless new-window
       ;; didn't find bib file in any window:
       (when (one-window-p 'nomini)
	 (setq old-window (split-window)))
       (setq new-window (next-window old-window 'nomini)))
     (select-window (if refer-same-file
                        old-window
                      new-window))  ; the window in which to show the bib file
     (catch 'found
       (while files
         (let ((file (cond ((file-exists-p (car files)) (car files))
                           ((file-exists-p (concat (car files) ".bib"))
                            (concat (car files) ".bib")))))
           (setq refer-saved-state files)
           (if file
               (if (refer-find-entry-in-file keywords-list file refer-saved-pos)
                   (progn
                     (setq refer-saved-pos (point))
                     (recenter 0)
                     (throw 'found (find-file file)))
                 (setq refer-saved-pos nil
                       files (cdr files)))
             (progn (message "Scanning %s... No such file" (car files) (ding))
                    (sit-for 1)
                    (setq files (cdr files))))))
       (message "Keywords \"%s\" not found in any \.bib file" keywords (ding)))
     (select-window old-window)))

(defun refer-find-entry-in-file (keywords-list file &optional old-pos)
   (message "Scanning %s..." file)
   (expand-file-name file)
   (set-buffer (find-file-noselect file))
   (find-file file)
   (if (not old-pos)
       (goto-char (point-min))
     (goto-char old-pos)
     (forward-paragraph 1))
   (let ((begin (point))
         (end 0)
         (found nil))
     (while (and (not found)
                 (not (eobp)))
       (forward-paragraph 1)
       (setq end (point))
       (setq found
             (refer-every (function (lambda (keyword)
                                (goto-char begin)
                                (re-search-forward keyword end t)))
                    keywords-list))
       (if (not found)
           (progn
             (setq begin end)
             (goto-char begin))))
     (if found
         (progn (goto-char begin)
                (re-search-forward "\\W" nil t)
                (message "Scanning %s... found" file))
       (progn (message "Scanning %s... not found" file)
              nil))))

(defun refer-every (pred l)
  (cond ((null l) nil)
	((funcall pred (car l))
	 (or (null (cdr l))
	     (refer-every pred (cdr l))))))

(defun refer-convert-string-to-list-of-strings (s)
   (let ((current (current-buffer))
         (temp-buffer (get-buffer-create "*refer-temp*")))
      (set-buffer temp-buffer)
      (erase-buffer)
      (insert (regexp-quote s))
      (goto-char (point-min))
      (insert "(\"")
      (while (re-search-forward "[ \t]+" nil t)
         (replace-match "\" \"" t t))
      (goto-char (point-max))
      (insert "\")")
      (goto-char (point-min))
      (prog1 (read temp-buffer)
         (set-buffer current))))

(defun refer-expand-files (file-list dir-list)
  (let (file files dir dirs)
    (while (setq file (car file-list))
      (setq dirs (copy-alist dir-list))
      (while (setq dir (car dirs))
        (if (file-exists-p (expand-file-name file dir))
            (setq files (append files (list (expand-file-name file dir)))
                  dirs  nil)
          (if (file-exists-p (expand-file-name (concat file ".bib") dir))
              (setq files (append files (list (expand-file-name (concat file ".bib")
                                                                dir)))
                    dirs  nil)
            (setq dirs (cdr dirs)))))
      (setq file-list (cdr file-list)))
    files))

(defun refer-get-bib-files ()
  (let* ((dir-list
          (cond
           ((null refer-bib-directory)
            '("."))
           ((or (eq refer-bib-directory 'texinputs)
                (eq refer-bib-directory 'bibinputs))
            (let ((envvar (getenv (if (eq refer-bib-directory 'texinputs)
                                      "TEXINPUTS"
                                    "BIBINPUTS")))
                  (dirs nil))
              (if (null envvar)
                  (setq envvar "."))
              (while (string-match ":" envvar)
		(let ((dir (substring envvar 0 (match-beginning 0))))
		  (if (and (not (string-equal "" dir))
                           (file-directory-p dir))
		      (setq dirs (append (list (expand-file-name dir nil))
                                         dirs))))
                (setq envvar (substring envvar (match-end 0))))
	      (if (and (not (string-equal "" envvar))
                       (file-directory-p envvar))
		  (setq dirs (append (list envvar) dirs)))
              (setq dirs (nreverse dirs))))
	   ((listp refer-bib-directory)
	    refer-bib-directory)
           (t
            (list refer-bib-directory))))
         (files
           (cond
            ((null refer-bib-files)
             (list (expand-file-name
                    (if (eq major-mode 'bibtex-mode)
                        (read-file-name
                         (format ".bib file: (default %s) "
                                 (file-name-nondirectory
                                  (buffer-file-name)))
                         (file-name-directory (buffer-file-name))
                         (file-name-nondirectory (buffer-file-name))
                         t)
                      (read-file-name ".bib file: " nil nil t)))))
            ((eq refer-bib-files 'auto)
             (let ((files
                    (save-excursion
                      (if (setq refer-same-file (eq major-mode 'bibtex-mode))
                          (list buffer-file-name)
                        (if (progn
                              (goto-char (point-min))
                              (re-search-forward (concat refer-bib-files-regexp
                                                         "\\s-*\{") nil t))
                            (let ((files (list (buffer-substring
                                                (point)
                                                (progn
                                                  (re-search-forward "[,\}]"
                                                                     nil t)
                                                  (backward-char 1)
                                                  (point))))))
                              (while (not (looking-at "\}"))
                                (setq files (append files
                                                    (list (buffer-substring
                                                           (progn (forward-char 1)
                                                                  (point))
                                                           (progn (re-search-forward
                                                                   "[,\}]" nil t)
                                                                  (backward-char 1)
                                                                  (point)))))))
                              files)
                          (error (concat "No \\\\bibliography command in this "
                                         "buffer, can't read refer-bib-files")))))))
               (refer-expand-files files dir-list)))
            ((eq refer-bib-files 'dir)
             (let ((dirs (nreverse dir-list))
                   dir files)
               (while (setq dir (car dirs))
                 (setq files
                       (append (directory-files dir t "\\.bib$")
                               files))
                 (setq dirs (cdr dirs)))
               files))
            ((and (listp refer-bib-files)
                  (or (eq refer-bib-directory 'texinputs)
                      (eq refer-bib-directory 'bibinputs)))
             (refer-expand-files refer-bib-files dir-list))
            ((listp refer-bib-files) refer-bib-files)
            (t (error "Illegal value for refer-bib-files: %s"
                      refer-bib-files)))))
    (if (or (eq refer-bib-directory 'texinputs)
            (eq refer-bib-directory 'bibinputs))
        (setq refer-bib-directory dir-list))
    (if refer-cache-bib-files
        (setq refer-bib-files files))
    files))

;;; arch-tag: 151f641b-e79b-462b-9a29-a95c3793f300
;;; refer.el ends here
Commit	Line	Data
e8af40ee	1	;;; refer.el --- look up references in bibliography files
ee6f7c13	2
2baa3252	3	;; Copyright (C) 1992, 1996, 2001 Free Software Foundation, Inc.
ee6f7c13	4
b8a3aefa	5	;; Author: Ashwin Ram <ashwin@cc.gatech.edu>
7cf5c426	6	;; Maintainer: Gernot Heiser <gernot@acm.org>
ee6f7c13 RS	7	;; Adapted-By: ESR
	8	;; Keywords: bib
	9
	10	;; This file is part of GNU Emacs.
	11
	12	;; GNU Emacs is free software; you can redistribute it and/or modify
	13	;; it under the terms of the GNU General Public License as published by
	14	;; the Free Software Foundation; either version 2, or (at your option)
	15	;; any later version.
	16
	17	;; GNU Emacs is distributed in the hope that it will be useful,
	18	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	19	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	20	;; GNU General Public License for more details.
	21
	22	;; You should have received a copy of the GNU General Public License
b578f267 EN	23	;; along with GNU Emacs; see the file COPYING. If not, write to the
	24	;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	25	;; Boston, MA 02111-1307, USA.
ee6f7c13 RS	26
ee6f7c13 RS	27	;;; Commentary:
b578f267	28
ee6f7c13 RS	29	;; Functions to look up references in bibliography files given lists of
	30	;; keywords, similar to refer(1). I don't use tags since tags on .bib files
	31	;; only picks up the cite key, where as refer-find-entry looks for occurrences
	32	;; of keywords anywhere in the bibliography entry.
	33	;;
	34	;; To use:
	35	;; (autoload 'refer-find-entry "refer" nil t)
	36	;; or (require 'refer)
	37	;;
	38	;; To look for an article by Knuth about semaphores:
	39	;; Invoke refer-find-entry, then in response to the Keywords: prompt,
	40	;; say: Knuth semaphores (a blank-separated list of keywords to be used
	41	;; as search strings).
	42	;;
	43	;; To continue the previous search, i.e., to search for the next occurrence
	44	;; of the keywords, use refer-find-next-entry, or invoke refer-find-entry
	45	;; with a prefix argument.
	46	;;
b8a3aefa RS	47	;; Once you've found the entry you want to reference, invoke
	48	;; refer-yank-key to insert it at point in the current buffer
	49	;; (typically as the argument of a \cite{} command).
	50	;;
	51	;; I use (define-key tex-mode-map "\C-c\C-y" 'refer-yank-key)
	52	;; to bind this often-used function to a key in (la)tex-mode.
	53	;;
ee6f7c13 RS	54	;; If the list of bibliography files changes, reinitialize the variable
	55	;; refer-bib-files.
	56	;;
	57	;; To customize:
	58	;; See variables refer-bib-files, refer-cache-bib-files and
	59	;; refer-bib-files-regexp. By default, these are set up so that refer
	60	;; looks for the keywords you specify in all the .bib files in the current
	61	;; directory.
	62	;;
	63	;; The only assumption I make about bib files is that they contain a bunch
	64	;; of entries, one to a paragraph. refer-find-entry searches paragraph by
	65	;; paragraph, looking for a paragraph containing all the keywords
	66	;; specified. So you should be able to use pretty much any bib file with
	67	;; this code. If your bib file does not use paragraphs to separate
	68	;; entries, try setting the paragraph-start/separate variables, or changing
	69	;; the (forward-paragraph 1) call in refer-find-entry-in-file.
	70
ee6f7c13 RS	71	;;; Code:
	72
	73	(provide 'refer)
	74
d1ebc62e SE	75	(defgroup refer nil
	76	"Look up references in bibliography files."
	77	:prefix "refer-"
	78	:group 'wp)
	79
	80	(defcustom refer-bib-directory nil
b8a3aefa RS	81	"Directory, or list of directories, to search for \\.bib files. Can
	82	be set to 'bibinputs or 'texinputs, in which case the environment
	83	variable BIBINPUTS or TEXINPUTS, respectively, is used to obtain a
	84	list of directories. Useful only if refer-bib-files is set to 'dir or
	85	a list of file names (without directory). A value of nil indicates the
	86	current working directory.
	87
	88	If refer-bib-directory is 'bibinputs or 'texinputs, it is setq'd to
	89	the appropriate list of directories when it is first used.
	90
	91	Note that an empty directory is interpreted by BibTeX as indicating
	92	the default search path. Since Refer does not know that default path,
	93	it cannot search it. Include that path explicitly in your BIBINPUTS
	94	environment if you really want it searched (which is not likely to
d1ebc62e SE	95	happen anyway)."
	96	:type '(choice (repeat directory) (const bibinputs) (const texinputs))
	97	:group 'refer)
b8a3aefa	98
d1ebc62e SE	99	(defcustom refer-bib-files 'dir
d1ebc62e SE	100	"*List of \\.bib files to search for references,
ee6f7c13 RS	101	or one of the following special values:
ee6f7c13 RS	102	nil = prompt for \\.bib file (if visiting a \\.bib file, use it as default)
b8a3aefa RS	103	auto = read \\.bib file names from appropriate command in buffer (see
	104	refer-bib-files-regexp) unless the buffer's mode is bibtex-mode,
	105	in which case only the buffer is searched
	106	dir = use all \\.bib files in directories referenced by refer-bib-directory.
ee6f7c13 RS	107
	108	If a specified file doesn't exist and has no extension, a \\.bib extension
	109	is automatically tried.
	110
	111	If refer-bib-files is nil, auto or dir, it is setq'd to the appropriate
	112	list of files when it is first used if refer-cache-bib-files is t. If
	113	refer-cache-bib-files is nil, the list of \\.bib files to use is re-read
d1ebc62e SE	114	each time it is needed."
	115	:type '(choice (repeat file) (const nil) (const auto) (const dir))
	116	:group 'refer)
ee6f7c13	117
d1ebc62e SE	118	(defcustom refer-cache-bib-files t
d1ebc62e SE	119	"*Variable determining whether the value of refer-bib-files should be cached.
ee6f7c13 RS	120	If t, initialize the value of refer-bib-files the first time it is used. If
ee6f7c13 RS	121	nil, re-read the list of \\.bib files depending on the value of refer-bib-files
d1ebc62e SE	122	each time it is needed."
	123	:type 'boolean
	124	:group 'refer)
ee6f7c13	125
d1ebc62e SE	126	(defcustom refer-bib-files-regexp "\\\\bibliography"
d1ebc62e SE	127	"*Regexp matching a bibliography file declaration.
ee6f7c13 RS	128	The current buffer is expected to contain a line such as
	129	\\bibliography{file1,file2,file3}
	130	which is read to set up refer-bib-files. The regexp must specify the command
b8a3aefa	131	(such as \\bibliography) that is used to specify the list of bib files. The
ee6f7c13 RS	132	command is expected to specify a file name, or a list of comma-separated file
	133	names, within curly braces.
	134	If a specified file doesn't exist and has no extension, a \\.bib extension
d1ebc62e SE	135	is automatically tried."
	136	:type 'regexp
	137	:group 'refer)
ee6f7c13 RS	138
	139	(make-variable-buffer-local 'refer-bib-files)
	140	(make-variable-buffer-local 'refer-cache-bib-files)
b8a3aefa RS	141	(make-variable-buffer-local 'refer-bib-directory)
	142
	143	;;; Internal variables
	144	(defvar refer-saved-state nil)
	145	(defvar refer-previous-keywords nil)
	146	(defvar refer-saved-pos nil)
	147	(defvar refer-same-file nil)
ee6f7c13 RS	148
	149	(defun refer-find-entry (keywords &optional continue)
	150	"Find entry in refer-bib-files containing KEYWORDS.
	151	If KEYWORDS is nil, prompt user for blank-separated list of keywords.
	152	If CONTINUE is t, or if called interactively with a prefix arg, look for next
	153	entry by continuing search from previous point."
	154	(interactive (list nil current-prefix-arg))
	155	(or keywords (setq keywords (if continue
	156	refer-previous-keywords
b8a3aefa	157	(read-string "Keywords: "))))
ee6f7c13 RS	158	(setq refer-previous-keywords keywords)
	159	(refer-find-entry-internal keywords continue))
	160
	161	(defun refer-find-next-entry ()
	162	"Find next occurrence of entry in refer-bib-files. See refer-find-entry."
	163	(interactive)
	164	(refer-find-entry-internal refer-previous-keywords t))
	165
b8a3aefa RS	166	(defun refer-yank-key ()
	167	"Inserts at point in current buffer the \"key\" field of the entry
	168	found on the last refer-find-entry or refer-find-next-entry."
	169	(interactive)
	170	(let ((old-point (point)))
	171	(insert
	172	(save-window-excursion
	173	(save-excursion
	174	(find-file (car refer-saved-state))
	175	(if (looking-at
	176	"[ \t\n]@\\s-[a-zA-Z][a-zA-Z0-9]\\s-{\\s-\\([^ \t\n,]+\\)\\s-,")
	177	(buffer-substring (match-beginning 1) (match-end 1))
e8af40ee	178	(error "Cannot find key for entry in file %s"
b8a3aefa RS	179	(car refer-saved-state))))))
	180	(if (not (= (point) old-point))
	181	(set-mark old-point))))
	182
ee6f7c13	183	(defun refer-find-entry-internal (keywords continue)
f1f20cec	184	(let ((keywords-list (refer-convert-string-to-list-of-strings keywords))
b8a3aefa RS	185	(old-buffer (current-buffer))
	186	(old-window (selected-window))
	187	(new-window (selected-window))
ee6f7c13 RS	188	(files (if continue
ee6f7c13 RS	189	refer-saved-state
b8a3aefa RS	190	(setq refer-saved-pos nil)
	191	(refer-get-bib-files)))
	192	(n 0)
	193	(found nil)
	194	(file nil))
	195	;; find window in which to display bibliography file.
	196	;; if a bibliography file is already displayed in a window, use
	197	;; that one, otherwise use any window other than the current one
90601de9	198	(setq new-window
2baa3252 GM	199	(get-window-with-predicate
	200	(lambda (w)
	201	(while (and (not (null (setq file (nth n files))))
	202	(setq n (1+ n))
	203	(not (string-equal file
	204	(buffer-file-name
	205	(window-buffer w))))))
	206	file)))
90601de9 GM	207	(unless new-window
	208	;; didn't find bib file in any window:
	209	(when (one-window-p 'nomini)
	210	(setq old-window (split-window)))
	211	(setq new-window (next-window old-window 'nomini)))
b8a3aefa RS	212	(select-window (if refer-same-file
	213	old-window
	214	new-window)) ; the window in which to show the bib file
	215	(catch 'found
	216	(while files
	217	(let ((file (cond ((file-exists-p (car files)) (car files))
	218	((file-exists-p (concat (car files) ".bib"))
	219	(concat (car files) ".bib")))))
	220	(setq refer-saved-state files)
	221	(if file
	222	(if (refer-find-entry-in-file keywords-list file refer-saved-pos)
	223	(progn
	224	(setq refer-saved-pos (point))
	225	(recenter 0)
	226	(throw 'found (find-file file)))
	227	(setq refer-saved-pos nil
	228	files (cdr files)))
	229	(progn (message "Scanning %s... No such file" (car files) (ding))
	230	(sit-for 1)
	231	(setq files (cdr files))))))
	232	(message "Keywords \"%s\" not found in any \.bib file" keywords (ding)))
	233	(select-window old-window)))
	234
	235	(defun refer-find-entry-in-file (keywords-list file &optional old-pos)
	236	(message "Scanning %s..." file)
	237	(expand-file-name file)
ee6f7c13	238	(set-buffer (find-file-noselect file))
b8a3aefa RS	239	(find-file file)
	240	(if (not old-pos)
	241	(goto-char (point-min))
	242	(goto-char old-pos)
	243	(forward-paragraph 1))
ee6f7c13 RS	244	(let ((begin (point))
	245	(end 0)
	246	(found nil))
b8a3aefa RS	247	(while (and (not found)
	248	(not (eobp)))
	249	(forward-paragraph 1)
	250	(setq end (point))
	251	(setq found
	252	(refer-every (function (lambda (keyword)
	253	(goto-char begin)
	254	(re-search-forward keyword end t)))
	255	keywords-list))
	256	(if (not found)
	257	(progn
	258	(setq begin end)
	259	(goto-char begin))))
	260	(if found
	261	(progn (goto-char begin)
	262	(re-search-forward "\\W" nil t)
	263	(message "Scanning %s... found" file))
	264	(progn (message "Scanning %s... not found" file)
	265	nil))))
ee6f7c13	266
f1f20cec	267	(defun refer-every (pred l)
b8a3aefa RS	268	(cond ((null l) nil)
	269	((funcall pred (car l))
	270	(or (null (cdr l))
	271	(refer-every pred (cdr l))))))
ee6f7c13	272
f1f20cec	273	(defun refer-convert-string-to-list-of-strings (s)
ee6f7c13 RS	274	(let ((current (current-buffer))
	275	(temp-buffer (get-buffer-create "refer-temp")))
	276	(set-buffer temp-buffer)
	277	(erase-buffer)
	278	(insert (regexp-quote s))
	279	(goto-char (point-min))
	280	(insert "(\"")
	281	(while (re-search-forward "[ \t]+" nil t)
	282	(replace-match "\" \"" t t))
	283	(goto-char (point-max))
	284	(insert "\")")
	285	(goto-char (point-min))
	286	(prog1 (read temp-buffer)
	287	(set-buffer current))))
	288
b8a3aefa RS	289	(defun refer-expand-files (file-list dir-list)
	290	(let (file files dir dirs)
	291	(while (setq file (car file-list))
	292	(setq dirs (copy-alist dir-list))
	293	(while (setq dir (car dirs))
	294	(if (file-exists-p (expand-file-name file dir))
	295	(setq files (append files (list (expand-file-name file dir)))
	296	dirs nil)
	297	(if (file-exists-p (expand-file-name (concat file ".bib") dir))
	298	(setq files (append files (list (expand-file-name (concat file ".bib")
	299	dir)))
	300	dirs nil)
	301	(setq dirs (cdr dirs)))))
	302	(setq file-list (cdr file-list)))
	303	files))
	304
ee6f7c13	305	(defun refer-get-bib-files ()
b8a3aefa RS	306	(let* ((dir-list
	307	(cond
	308	((null refer-bib-directory)
	309	'("."))
	310	((or (eq refer-bib-directory 'texinputs)
	311	(eq refer-bib-directory 'bibinputs))
	312	(let ((envvar (getenv (if (eq refer-bib-directory 'texinputs)
	313	"TEXINPUTS"
	314	"BIBINPUTS")))
	315	(dirs nil))
	316	(if (null envvar)
	317	(setq envvar "."))
	318	(while (string-match ":" envvar)
	319	(let ((dir (substring envvar 0 (match-beginning 0))))
	320	(if (and (not (string-equal "" dir))
	321	(file-directory-p dir))
	322	(setq dirs (append (list (expand-file-name dir nil))
	323	dirs))))
	324	(setq envvar (substring envvar (match-end 0))))
	325	(if (and (not (string-equal "" envvar))
	326	(file-directory-p envvar))
	327	(setq dirs (append (list envvar) dirs)))
	328	(setq dirs (nreverse dirs))))
	329	((listp refer-bib-directory)
	330	refer-bib-directory)
	331	(t
	332	(list refer-bib-directory))))
	333	(files
	334	(cond
db95369b	335	((null refer-bib-files)
b8a3aefa RS	336	(list (expand-file-name
	337	(if (eq major-mode 'bibtex-mode)
	338	(read-file-name
	339	(format ".bib file: (default %s) "
	340	(file-name-nondirectory
	341	(buffer-file-name)))
	342	(file-name-directory (buffer-file-name))
	343	(file-name-nondirectory (buffer-file-name))
	344	t)
	345	(read-file-name ".bib file: " nil nil t)))))
	346	((eq refer-bib-files 'auto)
	347	(let ((files
	348	(save-excursion
	349	(if (setq refer-same-file (eq major-mode 'bibtex-mode))
	350	(list buffer-file-name)
	351	(if (progn
	352	(goto-char (point-min))
	353	(re-search-forward (concat refer-bib-files-regexp
	354	"\\s-*\{") nil t))
	355	(let ((files (list (buffer-substring
	356	(point)
	357	(progn
	358	(re-search-forward "[,\}]"
	359	nil t)
	360	(backward-char 1)
	361	(point))))))
	362	(while (not (looking-at "\}"))
	363	(setq files (append files
	364	(list (buffer-substring
	365	(progn (forward-char 1)
	366	(point))
	367	(progn (re-search-forward
	368	"[,\}]" nil t)
	369	(backward-char 1)
	370	(point)))))))
	371	files)
	372	(error (concat "No \\\\bibliography command in this "
	373	"buffer, can't read refer-bib-files")))))))
	374	(refer-expand-files files dir-list)))
	375	((eq refer-bib-files 'dir)
	376	(let ((dirs (nreverse dir-list))
	377	dir files)
	378	(while (setq dir (car dirs))
	379	(setq files
	380	(append (directory-files dir t "\\.bib$")
	381	files))
	382	(setq dirs (cdr dirs)))
	383	files))
	384	((and (listp refer-bib-files)
	385	(or (eq refer-bib-directory 'texinputs)
	386	(eq refer-bib-directory 'bibinputs)))
	387	(refer-expand-files refer-bib-files dir-list))
	388	((listp refer-bib-files) refer-bib-files)
	389	(t (error "Illegal value for refer-bib-files: %s"
	390	refer-bib-files)))))
	391	(if (or (eq refer-bib-directory 'texinputs)
	392	(eq refer-bib-directory 'bibinputs))
	393	(setq refer-bib-directory dir-list))
	394	(if refer-cache-bib-files
	395	(setq refer-bib-files files))
	396	files))
ee6f7c13	397
ab5796a9	398	;;; arch-tag: 151f641b-e79b-462b-9a29-a95c3793f300
ee6f7c13	399	;;; refer.el ends here