;;; reftex-parse.el --- parser functions for RefTeX
-;; Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-;; 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+;; Copyright (C) 1997-2013 Free Software Foundation, Inc.
;; Author: Carsten Dominik <dominik@science.uva.nl>
;; Maintainer: auctex-devel@gnu.org
-;; Version: 4.31
-;; Package: reftex
;; This file is part of GNU Emacs.
;;; Code:
(eval-when-compile (require 'cl))
-(provide 'reftex-parse)
+
(require 'reftex)
(defmacro reftex-with-special-syntax (&rest body)
(unless (assq 'xr docstruct)
(let* ((allxr (reftex-all-assq 'xr-doc docstruct))
(alist (mapcar
- (lambda (x)
+ (lambda (x)
(if (setq tmp (reftex-locate-file (nth 2 x) "tex"
master-dir))
(cons (nth 1 x) tmp)
(alist (delq nil alist))
(allprefix (delq nil (mapcar 'car alist)))
(regexp (if allprefix
- (concat "\\`\\("
+ (concat "\\`\\("
(mapconcat 'identity allprefix "\\|")
"\\)")
"\\\\\\\\\\\\"))) ; this will never match
(push file file-list))
(nreverse file-list)))
+;; Bound in the caller, reftex-do-parse.
+(defvar index-tags)
+
(defun reftex-parse-from-file (file docstruct master-dir)
;; Scan the buffer for labels and save them in a list.
(let ((regexp (reftex-everything-regexp))
((match-end 3)
;; It is a section
- (setq bound (point))
+ ;; Use the beginning as bound and not the end
+ ;; (i.e. (point)) because the section command might
+ ;; be the start of the current environment to be
+ ;; found by `reftex-label-info'.
+ (setq bound (match-beginning 0))
+ ;; The section regexp matches a character at the end
+ ;; we are not interested in. Especially if it is the
+ ;; backslash of a following macro we want to find in
+ ;; the next parsing iteration.
+ (when (eq (char-before) ?\\) (backward-char))
;; Insert in List
- (setq toc-entry (reftex-section-info file))
+ (setq toc-entry (funcall reftex-section-info-function file))
(when toc-entry
;; It can happen that section info returns nil
(setq level (nth 5 toc-entry))
;; It's an include or input
(setq include-file (reftex-match-string 7))
;; Test if this file should be ignored
- (unless (delq nil (mapcar
+ (unless (delq nil (mapcar
(lambda (x) (string-match x include-file))
reftex-no-include-regexps))
;; Parse it
(push (cons 'bib tmp) docstruct))
(goto-char 1)
- (when (re-search-forward
+ (when (re-search-forward
"\\(\\`\\|[\n\r]\\)[ \t]*\\\\begin{thebibliography}" nil t)
(push (cons 'thebib file) docstruct))
-
+
;; Find external document specifications
(goto-char 1)
(while (re-search-forward "[\n\r][ \t]*\\\\externaldocument\\(\\[\\([^]]*\\)\\]\\)?{\\([^}]+\\)}" nil t)
(defun reftex-locate-bibliography-files (master-dir &optional files)
;; Scan buffer for bibliography macro and return file list.
-
+
(unless files
(save-excursion
(goto-char (point-min))
"\\(^\\)[^%\n\r]*\\\\\\("
(mapconcat 'identity reftex-bibliography-commands "\\|")
"\\){[ \t]*\\([^}]+\\)") nil t)
- (setq files
+ (setq files
(split-string (reftex-match-string 3)
"[ \t\n\r]*,[ \t\n\r]*")))))
(when files
- (setq files
+ (setq files
(mapcar
(lambda (x)
(if (or (member x reftex-bibfile-ignore-list)
(unnumbered (or star (< level 0)))
(level (abs level))
(section-number (reftex-section-number level unnumbered))
- (text1 (save-match-data
+ (text1 (save-match-data
(save-excursion
(reftex-context-substring prefix))))
(literal (buffer-substring-no-properties
(1- (match-beginning 3))
(min (point-max) (+ (match-end 0) (length text1) 1))))
- ;; Literal can be too short since text1 too short. No big problem.
+ ;; Literal can be too short since text1 too short. No big problem.
(text (reftex-nicify-text text1)))
;; Add section number and indentation
(defvar test-dummy)
(defun reftex-index-info (file)
;; Return an index entry for the current match.
- ;; Carefull: This function expects the match-data to be still in place!
+ ;; Careful: This function expects the match-data to be still in place!
(catch 'exit
(let* ((macro (reftex-match-string 10))
(bom (match-beginning 10))
(throw 'exit nil)))
(itag (nth 1 entry))
(prefix (nth 2 entry))
- (index-tag
+ (index-tag
(cond ((stringp itag) itag)
((integerp itag)
(progn (goto-char boa)
(key-end (if (string-match reftex-index-key-end-re arg)
(1+ (match-beginning 0))))
(rawkey (substring arg 0 key-end))
-
+
(key (if prefix (concat prefix rawkey) rawkey))
(sortkey (downcase key))
- (showkey (mapconcat 'identity
+ (showkey (mapconcat 'identity
(split-string key reftex-index-level-re)
" ! ")))
(goto-char end-of-args)
;; 0 1 2 3 4 5 6 7 8 9
(list 'index index-tag context file bom arg key showkey sortkey key-end))))
-
+
(defun reftex-short-context (env parse &optional bound derive)
;; Get about one line of useful context for the label definition at point.
((match-end 10)
;; Index entry
(when reftex-support-index
- (let* ((index-info (save-excursion
+ (let* ((index-info (save-excursion
(reftex-index-info-safe nil)))
(list (member (list 'bof (buffer-file-name))
docstruct))
;; Check all index entries with equal text
(while (and list (not (eq endelt (car list))))
(when (and (eq (car (car list)) 'index)
- (string= (nth 2 index-info)
+ (string= (nth 2 index-info)
(nth 2 (car list))))
(incf n)
(setq dist (abs (- (point) (nth 4 (car list)))))
level (nth 5 entry))
;; Insert the section info
(push entry (cdr tail))
-
+
;; We are done unless we use section numbers
(unless (nth 1 reftex-label-menu-flags) (throw 'exit nil))
context)
(when (and (not appendix)
(>= (string-to-char (match-string 2)) ?A))
- ;; Just entered the appendex. Get out.
+ ;; Just entered the appendix. Get out.
(throw 'exit nil))
;; Change the section number.
(setq entry (reftex-index-info-safe buffer-file-name))
;; FIXME: (add-to-list 'index-tags (nth 1 index-entry))
(push entry (cdr tail))))))))))
-
+
(error nil))
)
reftex-special-env-parsers))
specials rtn)
;; Call all functions
- (setq specials (mapcar
+ (setq specials (mapcar
(lambda (fun)
(save-excursion
(setq rtn (and fun (funcall fun bound)))
(setq specials (delq nil specials))
;; Sort
(setq specials (sort specials (lambda (a b) (> (cdr a) (cdr b)))))
- (if (eq which t)
+ (if (eq which t)
specials
(car specials))))))
;; Do the real thing.
(let ((cnt 1))
-
+
(when (reftex-move-to-next-arg)
-
+
(while (< cnt n)
(while (and (member cnt opt-args)
(eq (following-char) ?\{))
(condition-case nil
(while (memq (following-char) '(?\[ ?\{))
(forward-list 1))
- (error nil)))
+ (error nil)))
(defun reftex-context-substring (&optional to-end)
;; Return up to 150 chars from point
(error (point-max))))))
(t
;; no list - just grab 150 characters
- (buffer-substring-no-properties (point)
+ (buffer-substring-no-properties (point)
(min (+ (point) 150) (point-max))))))
;; Variable holding the vector with section numbers
;; not included in the numbering of other sectioning levels.
(when level
(when (and (> level -1) (not star))
- (aset reftex-section-numbers
+ (aset reftex-section-numbers
level (1+ (aref reftex-section-numbers level))))
(setq idx (1+ level))
(when (not star)
(setq string (replace-match "" nil nil string)))
(if (and appendix
(string-match "\\`[0-9]+" string))
- (setq string
+ (setq string
(concat
(char-to-string
(1- (+ ?A (string-to-number (match-string 0 string)))))
nrest (- nrest i))))
string))
+(provide 'reftex-parse)
+
;;; reftex-parse.el ends here