[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, 2009, 2010, 2011  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 of the License, 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.  If not, see <http://www.gnu.org/licenses/>.

;;; 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))

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