;;; Code:
-(eval-when-compile (require 'cl))
+(eval-when-compile (require 'cl-lib))
(require 'reftex)
;;; Code:
-(eval-when-compile (require 'cl))
+(eval-when-compile (require 'cl-lib))
(require 'reftex)
(if (> arg 1)
(progn
(skip-chars-backward "}")
- (decf arg)
+ (cl-decf arg)
(reftex-do-citation arg))
(forward-char 1)))
;; check for crossref entries
(let* ((attr-list (reftex-parse-bibtex-entry nil beg end))
(xref-key (cdr (assoc "crossref" attr-list))))
- (if xref-key (pushnew xref-key keys)))
+ (if xref-key (cl-pushnew xref-key keys)))
;; check for string references
(let* ((raw-fields (reftex-parse-bibtex-entry nil beg end t))
(string-fields (reftex-get-string-refs raw-fields)))
;;; Code:
-(eval-when-compile (require 'cl))
+(eval-when-compile (require 'cl-lib))
(declare-function bibtex-beginning-of-entry "bibtex" ())
(if match
(progn
(put 'reftex-view-regexp-match :props newprop)
- (put 'reftex-view-regexp-match :cnt (incf cnt))
+ (put 'reftex-view-regexp-match :cnt (cl-incf cnt))
(reftex-highlight 0 (match-beginning highlight-group)
(match-end highlight-group))
(add-hook 'pre-command-hook 'reftex-highlight-shall-die)
;;; Code:
-(eval-when-compile (require 'cl))
+(eval-when-compile (require 'cl-lib))
(provide 'reftex-global)
(require 'reftex)
;;;
(while dlist
(when (and (car (car dlist))
(cdr (car dlist)))
- (incf cnt)
+ (cl-incf cnt)
(insert (mapconcat 'identity (car dlist) "\n ") "\n"))
(pop dlist))
(goto-char (point-min))
(if (assoc label translate-alist)
(error "Duplicate label %s" label))
(setq new-label (concat (match-string 1 (car entry))
- (int-to-string (incf (cdr nr-cell)))))
+ (int-to-string (cl-incf (cdr nr-cell)))))
(push (cons label new-label) translate-alist)
(or (string= label new-label) (setq changed-sequence t))))
(error "Abort")))
(reftex-unhighlight 1)))
((and test cell)
- (incf n))
+ (cl-incf n))
((and (not test) cell)
;; Replace
(goto-char (match-beginning 1))
;;; Code:
-(eval-when-compile (require 'cl))
+(eval-when-compile (require 'cl-lib))
(declare-function texmathp "ext:texmathp" ())
(require 'reftex)
;; Insert the macro and ask for any additional args
(insert macro)
- (loop for i from 1 to nargs do
+ (cl-loop for i from 1 to nargs do
(setq opt (member i opt-args)
value (cond ((= nindex i) key)
((equal ntag i) tag1)
i -1
val nil)
(catch 'exit
- (while (and (< (incf i) len) (null val))
+ (while (and (< (cl-incf i) len) (null val))
(unless (assq (aref tag i) tag-alist)
(push (list (aref tag i)
tag
(concat (substring tag 0 i)
- "[" (substring tag i (incf i)) "]"
+ "[" (substring tag i (cl-incf i)) "]"
(substring tag i)))
tag-alist)
(throw 'exit t)))
- (push (list (+ ?0 (incf cnt)) tag
+ (push (list (+ ?0 (cl-incf cnt)) tag
(concat "[" (int-to-string cnt) "]:" tag))
tag-alist)))
(setq tag-alist (nreverse tag-alist))
(define-key map "c" 'reftex-index-toggle-context)
;; The capital letters and the exclamation mark
- (loop for key across (concat "!" reftex-index-section-letters) do
- (define-key map (vector (list key))
- (list 'lambda '() '(interactive)
- (list 'reftex-index-goto-letter key))))
+ (cl-loop for key across (concat "!" reftex-index-section-letters) do
+ (define-key map (vector (list key))
+ (list 'lambda '() '(interactive)
+ (list 'reftex-index-goto-letter key))))
(easy-menu-define reftex-index-menu map
"Menu for Index buffer"
(interactive "p")
(reftex-index-phrases-parse-header t)
(while (> arg 0)
- (decf arg)
+ (cl-decf arg)
(end-of-line)
(if (re-search-forward reftex-index-phrases-phrase-regexp12 nil t)
(progn
(widen)
(goto-char (point-min))
(while (re-search-forward re1 nil t)
- (incf ntimes1))
+ (cl-incf ntimes1))
(goto-char (point-min))
(while (re-search-forward re2 nil t)
(push (cons (count-lines 1 (point)) (match-string 1)) superphrases)
- (incf ntimes2))))
+ (cl-incf ntimes2))))
(save-current-buffer
(while (setq file (pop files))
(setq buf (reftex-get-file-buffer-force file))
(let ((case-fold-search reftex-index-phrases-case-fold-search))
(while (re-search-forward re nil t)
(or (reftex-in-comment)
- (incf nmatches)))))))))
+ (cl-incf nmatches)))))))))
(with-output-to-temp-buffer "*Help*"
(princ (format " Phrase: %s\n" phrase))
(princ (format " Macro key: %s\n" char))
(index-key
(let ((iks index-keys) (cnt 0) ik)
(while (setq ik (pop iks))
- (princ (format "Index entry %d: %s\n" (incf cnt) ik)))))
+ (princ (format "Index entry %d: %s\n" (cl-incf cnt) ik)))))
(repeat
(princ (format " Index entry: %s\n" phrase)))
(t
(cond ((member char '(?y ?Y ?\ ))
;; Yes!
(replace-match rpl t t)
- (incf replace-count)
+ (cl-incf replace-count)
;; See if we should insert newlines to shorten lines
(and reftex-index-phrases-wrap-long-lines
(reftex-index-phrases-fixup-line beg end))
;;; Code:
-(eval-when-compile (require 'cl))
+(eval-when-compile (require 'cl-lib))
(require 'reftex)
(when reftex-support-index
(setq index-entry (reftex-index-info file))
(when index-entry
- (add-to-list 'reftex--index-tags (nth 1 index-entry))
+ (cl-pushnew (nth 1 index-entry) reftex--index-tags :test #'equal)
(push index-entry docstruct))))
((match-end 11)
found)
(save-excursion
(while (not rtn)
- (incf cnt)
+ (cl-incf cnt)
(setq found (re-search-backward (reftex-everything-regexp) nil t))
(setq rtn
(cond
(when (and (eq (car (car list)) 'index)
(string= (nth 2 index-info)
(nth 2 (car list))))
- (incf n)
+ (cl-incf n)
(setq dist (abs (- (point) (nth 4 (car list)))))
(if (or (not last-dist) (< dist last-dist))
(setq last-dist dist last (car list))))
(let ((forward-sexp-function nil))
(backward-sexp) t)
(error nil)))
- (if (eq (following-char) ?\[) (incf cnt-opt))
- (incf cnt))
+ (if (eq (following-char) ?\[) (cl-incf cnt-opt))
+ (cl-incf cnt))
(setq pos (point))
(when (and (or (= (following-char) ?\[)
(= (following-char) ?\{))
(while (< cnt n)
(while (and (member cnt opt-args)
(eq (following-char) ?\{))
- (incf cnt))
+ (cl-incf cnt))
(when (< cnt n)
(unless (and (condition-case nil
(or (forward-list 1) t)
(error nil))
(reftex-move-to-next-arg)
- (incf cnt))
+ (cl-incf cnt))
(setq cnt 1000))))
(while (and (memq cnt opt-args)
(eq (following-char) ?\{))
- (incf cnt)))
+ (cl-incf cnt)))
(if (and (= n cnt)
(> (skip-chars-forward "{\\[") 0))
(reftex-context-substring)
(- (string-to-char number-string) ?A -1))
(aset reftex-section-numbers i (string-to-number number-string)))
(pop numbers))
- (decf i)))
+ (cl-decf i)))
(put 'reftex-section-numbers 'appendix appendix))
;;;###autoload
(if (or (not partspecial)
(not (= idx 1)))
(aset reftex-section-numbers idx 0))
- (incf idx))))
+ (cl-incf idx))))
(if partspecial
(setq string (concat "Part " (reftex-roman-number
(aref reftex-section-numbers 0))))
(if (not (and partspecial (not (equal string ""))))
(setq string (concat string (if (not (string= string "")) "." "")
(int-to-string n))))
- (incf idx))
+ (cl-incf idx))
(save-match-data
(if (string-match "\\`\\([@0]\\.\\)+" string)
(setq string (replace-match "" nil nil string)))
;;; Code:
-(eval-when-compile (require 'cl))
+(eval-when-compile (require 'cl-lib))
(require 'reftex)
(require 'reftex-parse)
(sep (or separator "")))
(while (assoc (concat label sep (int-to-string num))
(symbol-value reftex-docstruct-symbol))
- (incf num))
+ (cl-incf num))
(setcdr cell num)
(concat label sep (int-to-string num))))))
(reftex-erase-buffer))
(unless (eq major-mode 'reftex-select-label-mode)
(reftex-select-label-mode))
- (add-to-list 'selection-buffers (current-buffer))
+ (cl-pushnew (current-buffer) selection-buffers)
(setq truncate-lines t)
(setq mode-line-format
(list "---- " 'mode-line-buffer-identification
;;; Code:
-(eval-when-compile (require 'cl))
+(eval-when-compile (require 'cl-lib))
(require 'reftex)
;; and reftex-select-bib-mode-map.
(defvar reftex-select-shared-map
(let ((map (make-sparse-keymap)))
+ (set-keymap-parent map special-mode-map)
(substitute-key-definition
'next-line 'reftex-select-next map global-map)
(substitute-key-definition
(substitute-key-definition
'newline 'reftex-select-accept map global-map)
- (loop for x in
- '((" " . reftex-select-callback)
- ("n" . reftex-select-next)
- ([(down)] . reftex-select-next)
- ("p" . reftex-select-previous)
- ([(up)] . reftex-select-previous)
- ("f" . reftex-select-toggle-follow)
- ("\C-m" . reftex-select-accept)
- ([(return)] . reftex-select-accept)
- ("q" . reftex-select-quit)
- ("." . reftex-select-show-insertion-point)
- ("?" . reftex-select-help))
- do (define-key map (car x) (cdr x)))
+ (define-key map " " 'reftex-select-callback)
+ (define-key map "n" 'reftex-select-next)
+ (define-key map [(down)] 'reftex-select-next)
+ (define-key map "p" 'reftex-select-previous)
+ (define-key map [(up)] 'reftex-select-previous)
+ (define-key map "f" 'reftex-select-toggle-follow)
+ (define-key map "\C-m" 'reftex-select-accept)
+ (define-key map [(return)] 'reftex-select-accept)
+ (define-key map "q" 'reftex-select-quit)
+ (define-key map "." 'reftex-select-show-insertion-point)
+ (define-key map "?" 'reftex-select-help)
;; The mouse-2 binding
(if (featurep 'xemacs)
(define-key map [(button2)] 'reftex-select-mouse-accept)
(define-key map [(mouse-2)] 'reftex-select-mouse-accept)
(define-key map [follow-link] 'mouse-face))
-
-
- ;; Digit arguments
- (loop for key across "0123456789" do
- (define-key map (vector (list key)) 'digit-argument))
- (define-key map "-" 'negative-argument)
map))
(define-obsolete-variable-alias
(let ((map (make-sparse-keymap)))
(set-keymap-parent map reftex-select-shared-map)
- (loop for key across "aAcgFlrRstx#%" do
- (define-key map (vector (list key))
- (list 'lambda '()
- "Press `?' during selection to find out about this key."
- '(interactive) (list 'throw '(quote myexit) key))))
-
- (loop for x in
- '(("b" . reftex-select-jump-to-previous)
- ("z" . reftex-select-jump)
- ("v" . reftex-select-cycle-ref-style-forward)
- ("V" . reftex-select-cycle-ref-style-backward)
- ("m" . reftex-select-mark)
- ("u" . reftex-select-unmark)
- ("," . reftex-select-mark-comma)
- ("-" . reftex-select-mark-to)
- ("+" . reftex-select-mark-and)
- ([(tab)] . reftex-select-read-label)
- ("\C-i" . reftex-select-read-label)
- ("\C-c\C-n" . reftex-select-next-heading)
- ("\C-c\C-p" . reftex-select-previous-heading))
- do
- (define-key map (car x) (cdr x)))
+ (cl-loop for key across "aAcgFlrRstx#%" do
+ (define-key map (vector (list key))
+ (list 'lambda '()
+ "Press `?' during selection to find out about this key."
+ '(interactive) (list 'throw '(quote myexit) key))))
+
+ (define-key map "b" 'reftex-select-jump-to-previous)
+ (define-key map "z" 'reftex-select-jump)
+ (define-key map "v" 'reftex-select-cycle-ref-style-forward)
+ (define-key map "V" 'reftex-select-cycle-ref-style-backward)
+ (define-key map "m" 'reftex-select-mark)
+ (define-key map "u" 'reftex-select-unmark)
+ (define-key map "," 'reftex-select-mark-comma)
+ (define-key map "-" 'reftex-select-mark-to)
+ (define-key map "+" 'reftex-select-mark-and)
+ (define-key map [(tab)] 'reftex-select-read-label)
+ (define-key map "\C-i" 'reftex-select-read-label)
+ (define-key map "\C-c\C-n" 'reftex-select-next-heading)
+ (define-key map "\C-c\C-p" 'reftex-select-previous-heading)
map)
"Keymap used for *RefTeX Select* buffer, when selecting a label.
(let ((map (make-sparse-keymap)))
(set-keymap-parent map reftex-select-shared-map)
- (loop for key across "grRaAeE" do
- (define-key map (vector (list key))
- (list 'lambda '()
- "Press `?' during selection to find out about this key."
- '(interactive) (list 'throw '(quote myexit) key))))
+ (cl-loop for key across "grRaAeE" do
+ (define-key map (vector (list key))
+ (list 'lambda '()
+ "Press `?' during selection to find out about this key."
+ '(interactive) (list 'throw '(quote myexit) key))))
- (loop for x in
- '(("\C-i" . reftex-select-read-cite)
- ([(tab)] . reftex-select-read-cite)
- ("m" . reftex-select-mark)
- ("u" . reftex-select-unmark))
- do (define-key map (car x) (cdr x)))
+ (define-key map "\C-i" 'reftex-select-read-cite)
+ (define-key map [(tab)] 'reftex-select-read-cite)
+ (define-key map "m" 'reftex-select-mark)
+ (define-key map "u" 'reftex-select-unmark)
map)
"Keymap used for *RefTeX Select* buffer, when selecting a BibTeX entry.
;; Walk the docstruct and insert the appropriate stuff
(while (setq cell (pop all))
- (incf index)
+ (cl-incf index)
(setq from (point))
(cond
(or show-commented (null comment)))
;; Yes we want this one
- (incf cnt)
+ (cl-incf cnt)
(setq prev-inserted cell)
; (if (eq offset 'attention) (setq offset cell))
(setq sep (nth 2 c))
(reftex-overlay-put (nth 1 c) 'before-string
(if sep
- (format "*%c%d* " sep (decf cnt))
- (format "*%d* " (decf cnt)))))
+ (format "*%c%d* " sep (cl-decf cnt))
+ (format "*%d* " (cl-decf cnt)))))
reftex-select-marked)
(message "Entry no longer marked")))
;;; Code:
(defvar reftex-tables-dirty)
-(eval-when-compile (require 'cl))
+(eval-when-compile (require 'cl-lib))
(eval-and-compile
(defun reftex-set-dirty (symbol value)
(setq reftex-tables-dirty t)
;; Compatibility with obsolete variables.
(when reftex-vref-is-default
- (add-to-list 'reftex-ref-style-default-list "Varioref"))
+ (cl-pushnew "Varioref" reftex-ref-style-default-list :test #'equal))
(when reftex-fref-is-default
- (add-to-list 'reftex-ref-style-default-list "Fancyref"))
+ (cl-pushnew "Fancyref" reftex-ref-style-default-list :test #'equal))
(defcustom reftex-level-indent 2
"Number of spaces to be used for indentation per section level."
;;; Code:
-(eval-when-compile (require 'cl))
+(eval-when-compile (require 'cl-lib))
;; Stuff that needs to be there when we use defcustom
(require 'custom)
(defun reftex-next-multifile-index ()
;; Return the next free index for multifile symbols.
- (incf reftex-multifile-index))
+ (cl-incf reftex-multifile-index))
(defun reftex-tie-multifile-symbols ()
"Tie the buffer-local symbols to globals connected with the master file.
(unless (member style list)
(setq reftex-tables-dirty t
changed t)
- (add-to-list 'list style t)))
+ (setq list (append list (list style)))))
((eq action 'deactivate)
(when (member style list)
(setq reftex-tables-dirty t
(t
(if (member style list)
(delete style list)
- (add-to-list 'list style t))
+ (setq list (append list (list style))))
(setq reftex-tables-dirty t
changed t)))
(when changed
reffmt (nth 1 fmt))
;; Note a new typekey
(if typekey
- (add-to-list 'reftex-typekey-list typekey))
+ (cl-pushnew typekey reftex-typekey-list :test #'equal))
(if (and typekey prefix
(not (assoc prefix reftex-prefix-to-typekey-alist)))
- (add-to-list 'reftex-prefix-to-typekey-alist
- (cons prefix typekey)))
+ (cl-pushnew (cons prefix typekey) reftex-prefix-to-typekey-alist
+ :test #'equal))
(if (and typekey prefix
(not (assoc typekey reftex-typekey-to-prefix-alist)))
- (add-to-list 'reftex-typekey-to-prefix-alist
- (cons typekey prefix)))
+ (cl-pushnew (cons typekey prefix) reftex-typekey-to-prefix-alist
+ :test #'equal))
;; Check if this is a macro or environment
(cond
((symbolp env-or-mac)
(message "Warning: %s does not seem to be a valid function"
env-or-mac))
(setq nargs nil nlabel nil opt-args nil)
- (add-to-list 'reftex-special-env-parsers env-or-mac)
+ (cl-pushnew env-or-mac reftex-special-env-parsers)
(setq env-or-mac (symbol-name env-or-mac)))
((string-match "\\`\\\\" env-or-mac)
;; It's a macro
(let ((result (reftex-parse-args env-or-mac)))
- (setq env-or-mac (or (first result) env-or-mac)
- nargs (second result)
- nlabel (third result)
- opt-args (fourth result))
- (if nlabel (add-to-list 'macros-with-labels env-or-mac)))
- (if typekey (add-to-list 'reftex-label-mac-list env-or-mac)))
+ (setq env-or-mac (or (cl-first result) env-or-mac)
+ nargs (cl-second result)
+ nlabel (cl-third result)
+ opt-args (cl-fourth result))
+ (if nlabel (cl-pushnew env-or-mac macros-with-labels :test #'equal)))
+ (if typekey (cl-pushnew env-or-mac reftex-label-mac-list :test #'equal)))
(t
;; It's an environment
(setq nargs nil nlabel nil opt-args nil)
((string= env-or-mac ""))
((string= env-or-mac "section"))
(t
- (add-to-list 'reftex-label-env-list env-or-mac)
+ (cl-pushnew env-or-mac reftex-label-env-list :test #'equal)
(if toc-level
(let ((string (format "begin{%s}" env-or-mac)))
(or (assoc string toc-levels)
(not (member (aref fmt i) '(?%))))
(setq word (concat word "\\|" (regexp-quote
(substring fmt 0 (1+ i)))))
- (incf i))
+ (cl-incf i))
(cons (concat word "\\)\\=") typekey))
(nreverse reftex-words-to-typekey-alist)))
(t t))
all-index (cdr all-index))
(let ((result (reftex-parse-args macro)))
- (setq macro (or (first result) macro)
- nargs (second result)
- nindex (third result)
- opt-args (fourth result))
+ (setq macro (or (cl-first result) macro)
+ nargs (cl-second result)
+ nindex (cl-third result)
+ opt-args (cl-fourth result))
(unless (member macro reftex-macros-with-index)
;; 0 1 2 3 4 5 6 7
(push (list macro tag prefix verify nargs nindex opt-args repeat)
(mapconcat
(lambda(x)
(format "[%c] %-20.20s%s" (car x) (nth 1 x)
- (if (= 0 (mod (incf i) 3)) "\n" "")))
+ (if (= 0 (mod (cl-incf i) 3)) "\n" "")))
reftex-key-to-index-macro-alist "")))
;; Make the full list of section levels
(args (substring macro (match-beginning 0)))
opt-list nlabel (cnt 0))
(while (string-match "\\`[[{]\\(\\*\\)?[]}]" args)
- (incf cnt)
+ (cl-incf cnt)
(when (eq ?\[ (string-to-char args))
(push cnt opt-list))
(when (and (match-end 1)
(defun reftex-silence-toc-markers (list n)
;; Set all toc markers in the first N entries in list to nil
- (while (and list (> (decf n) -1))
+ (while (and list (> (cl-decf n) -1))
(and (eq (car (car list)) 'toc)
(markerp (nth 4 (car list)))
(set-marker (nth 4 (car list)) nil))
"SELECT EXTERNAL DOCUMENT\n------------------------\n"
(mapconcat
(lambda (x)
- (format fmt (incf n) (or (car x) "")
+ (format fmt (cl-incf n) (or (car x) "")
(abbreviate-file-name (cdr x))))
xr-alist ""))
nil t))
;; with limited Magic
;; The magic goes away
- (letf ((format-alist nil)
- (auto-mode-alist (reftex-auto-mode-alist))
- ((default-value 'major-mode) 'fundamental-mode)
- (enable-local-variables nil)
- (after-insert-file-functions nil))
+ (cl-letf ((format-alist nil)
+ (auto-mode-alist (reftex-auto-mode-alist))
+ ((default-value 'major-mode) 'fundamental-mode)
+ (enable-local-variables nil)
+ (after-insert-file-functions nil))
(setq buf (find-file-noselect file)))
;; Is there a hook to run?
;; Let's see if we got a license to kill :-|
(and mark-to-kill
- (add-to-list 'reftex-buffers-to-kill buf))
+ (cl-pushnew buf reftex-buffers-to-kill))
;; Return the new buffer
buf)
:style 'toggle
:selected `(member ,elt (reftex-ref-style-list))))
(unless (member item list)
- (add-to-list 'list item t)))
+ (setq list (append list (list item)))))
list))
("Citation Style"
,@(mapcar
projects / emacs.git / commitdiff