* lisp/progmodes/bug-reference.el (bug-reference--overlay-bounds):
* lisp/progmodes/c-ts-common.el (c-ts-common-statement-offset):
* lisp/progmodes/compile.el (compilation--note-type):
* lisp/progmodes/ebrowse.el (ebrowse-files-table)
(ebrowse-fill-member-table, ebrowse-find-pattern)
(ebrowse-draw-member-short-fn, ebrowse-gather-statistics):
* lisp/progmodes/elixir-ts-mode.el
(elixir-ts--electric-pair-string-delimiter):
* lisp/progmodes/gdb-mi.el (gdb-thread-list-handler-custom):
* lisp/progmodes/grep.el (grep-filter):
* lisp/progmodes/hideif.el (hif-backward-comment, hif-__COUNTER__)
(hif-token-concatenation, hif-find-define):
* lisp/progmodes/js.el (js--pstate-is-toplevel-defun)
(js-beginning-of-defun, js-end-of-defun, js--pitems-to-imenu)
(js--imenu-to-flat, js-ts--syntax-propertize):
* lisp/progmodes/tcl.el (tcl--syntax-of-quote):
* lisp/progmodes/typescript-ts-mode.el
(tsx-ts--syntax-propertize-captures): Prefer incf to cl-incf.
(cherry picked from commit
d1d85e0f35d4cb22f2cdfda0672ca33f5bb87b21)
(or (< (match-beginning i) m-b1)
(> (match-end i) m-e1)))
(throw 'within-bounds nil))
- (cl-incf i))
+ (incf i))
t)))
;; All groups 2..10 are within bounds.
(cons m-b1 m-e1)
(let ((parent (treesit-node-parent node)))
;; Increment level for every bracket (with exception).
(when (c-ts-common--node-is node 'block)
- (cl-incf level)
+ (incf level)
(save-excursion
(goto-char (treesit-node-start node))
;; Add an extra level if the opening bracket is on its own
;; Add a level.
((looking-back (rx bol (* whitespace))
(line-beginning-position))
- (cl-incf level)))))
+ (incf level)))))
;; Fix bracketless statements.
(when (and (c-ts-common--node-is parent
'if 'do 'while 'for)
(not (c-ts-common--node-is node 'block)))
- (cl-incf level))
+ (incf level))
;; Flatten "else if" statements.
(when (and (c-ts-common--node-is node 'else)
(c-ts-common--node-is node 'if)
"Note that a new message with severity TYPE was seen.
This updates the appropriate variable used by the mode-line."
(cl-case type
- (0 (cl-incf compilation-num-infos-found))
- (1 (cl-incf compilation-num-warnings-found))
- (2 (cl-incf compilation-num-errors-found))))
+ (0 (incf compilation-num-infos-found))
+ (1 (incf compilation-num-warnings-found))
+ (2 (incf compilation-num-errors-found))))
(defun compilation-parse-errors (start end &rest rules)
"Parse errors between START and END.
(eq last-command-event ?\")
(let ((count 0))
(while (eq (char-before (- (point) count)) last-command-event)
- (cl-incf count))
+ (incf count))
(= count 3))
(eq (char-after) last-command-event))
(save-excursion
(add-to-list 'gdb-threads-list
(cons (gdb-mi--field thread 'id)
thread))
- (cl-incf (if running
- gdb-running-threads-count
- gdb-stopped-threads-count))
+ (incf (if running
+ gdb-running-threads-count
+ gdb-stopped-threads-count))
(gdb-table-add-row
table
(replace-match (propertize (match-string 1)
'face nil 'font-lock-face grep-match-face)
t t)
- (cl-incf grep-num-matches-found))
+ (incf grep-num-matches-found))
;; Delete all remaining escape sequences
(goto-char beg)
(while (re-search-forward "\033\\[[0-9;]*[mK]" end 1)
;; merge whites immediately ahead
(setq ce (if (and we (= (1- p) we)) ws p))
;; scan for end of line
- (while (and (< (cl-incf p) end)
+ (while (and (< (incf p) end)
(not (char-equal ?\n (char-after p)))
(not (char-equal ?\r (char-after p)))))
;; Merge with previous comment if immediately followed
(while (< (1+ p) end)
(if (not (and (char-equal ?* (char-after p))
(char-equal ?/ (char-after (1+ p)))))
- (cl-incf p)
+ (incf p)
;; found `*/', mark end pos
(push (cons cmt (1+ (setq p (1+ p)))) cmtlist)
(throw 'break nil)))
we p))
(setq ws nil
we nil)))
- (cl-incf p))
+ (incf p))
;; Goto beginning of the last comment, if we're within
(setq cmt (car cmtlist)) ;; last cmt
(setq cmt (if (and cmt
(defvar hif-__COUNTER__ 0)
(defun hif-__COUNTER__ ()
- (prog1 hif-__COUNTER__ (cl-incf hif-__COUNTER__)))
+ (prog1 hif-__COUNTER__ (incf hif-__COUNTER__)))
(defun hif-__cplusplus ()
(and (string-match
(push tk items) ; first item, in reverse order
(setq tk 'hif-token-concat))
(while (eq tk 'hif-token-concat)
- (cl-incf count)
+ (incf count)
;; 2+ item
(setq l (cdr l)
tk (car l))
(tokens
(and name
(prog1 t
- (cl-incf hif-verbose-define-count)
+ (incf hif-verbose-define-count)
;; only show 1/50 to not slow down to much
(if (and hide-ifdef-verbose
(= (% hif-verbose-define-count 50) 1))
with func-depth = 0
with func-pitem
if (eq 'function (js--pitem-type pitem))
- do (cl-incf func-depth)
+ do (incf func-depth)
and do (setq func-pitem pitem)
finally return (if (eq func-depth 1) func-pitem)))
(setq arg (or arg 1))
(let ((found))
(while (and (not (eobp)) (< arg 0))
- (cl-incf arg)
+ (incf arg)
(when (and (not js-flat-functions)
(or (eq (js-syntactic-context) 'function)
(js--function-prologue-beginning)))
"Value of `end-of-defun-function' for `js-mode'."
(setq arg (or arg 1))
(while (and (not (bobp)) (< arg 0))
- (cl-incf arg)
+ (incf arg)
(js-beginning-of-defun)
(js-beginning-of-defun)
(unless (bobp)
(setq pitem-name (js--pitem-strname pitem))
(when (eq pitem-name t)
(setq pitem-name (format "[unknown %s]"
- (cl-incf (car unknown-ctr)))))
+ (incf (car unknown-ctr)))))
(cond
((memq pitem-type '(function macro))
(ctr 0))
(while (gethash name2 symbols)
- (setq name2 (format "%s<%d>" name (cl-incf ctr))))
+ (setq name2 (format "%s<%d>" name (incf ctr))))
(puthash name2 (cdr item) symbols))))
(syntax (pcase-exhaustive name
('regexp
(decf ns)
- (cl-incf ne)
+ (incf ne)
(string-to-syntax "\"/"))
('jsx
(string-to-syntax "|")))))
(pcase (char-after (match-beginning 0))
(?\\ (forward-char 1))
(?\" (setq type 'matched))
- (?\{ (cl-incf depth))
+ (?\{ (incf depth))
(?\} (if (zerop depth) (setq type 'unmatched)
- (cl-incf depth)))))
+ (incf depth)))))
(when (> (line-beginning-position) pos)
;; The quote is not on the same line as the deciding
;; factor, so make sure we revisit this choice later.
('regexp
(let ((syntax (string-to-syntax "\"/")))
(decf ns)
- (cl-incf ne)
+ (incf ne)
(put-text-property ns (1+ ns) 'syntax-table syntax)
(put-text-property (1- ne) ne 'syntax-table syntax)))
;; We put punctuation syntax on all the balanced pair
projects / emacs.git / commitdiff