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

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

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