;;; cc-cmds.el --- user level commands for CC Mode
-;; Copyright (C) 1985, 1987, 1992-2011 Free Software Foundation, Inc.
+;; Copyright (C) 1985, 1987, 1992-2013 Free Software Foundation, Inc.
;; Authors: 2003- Alan Mackenzie
;; 1998- Martin Stjernholm
(cc-require 'cc-engine)
;; Silence the compiler.
-(cc-bytecomp-defun delete-forward-p) ; XEmacs
(cc-bytecomp-defvar filladapt-mode) ; c-fill-paragraph contains a kludge
; which looks at this.
\f
Turning on auto-newline automatically enables electric indentation.
When the auto-newline feature is enabled (indicated by \"/la\" on the
-modeline after the mode name) newlines are automatically inserted
+mode line after the mode name) newlines are automatically inserted
after special characters such as brace, comma, semi-colon, and colon."
(interactive "P")
(setq c-auto-newline
left out.
When the hungry-delete-key feature is enabled (indicated by \"/h\" on
-the modeline after the mode name) the delete key gobbles all preceding
+the mode line after the mode name) the delete key gobbles all preceding
whitespace in one fell swoop."
(interactive "P")
(setq c-hungry-delete-key (c-calculate-state arg c-hungry-delete-key))
(bolp (bolp)))
(beginning-of-line)
(delete-horizontal-space)
- (insert last-command-event)
+ (insert (c-last-command-char))
(and (not bolp)
(goto-char (- (point-max) pos)))
)))
(insert-char ?\n 1)
;; In AWK (etc.) or in a macro, make sure this CR hasn't changed
;; the syntax. (There might already be an escaped NL there.)
- (when (or (c-at-vsemi-p (1- (point)))
- (let ((pt (point)))
- (save-excursion
- (backward-char)
- (and (c-beginning-of-macro)
- (progn (c-end-of-macro)
- (< (point) pt))))))
+ (when (or
+ (save-excursion
+ (c-skip-ws-backward (c-point 'bopl))
+ (c-at-vsemi-p))
+ (let ((pt (point)))
+ (save-excursion
+ (backward-char)
+ (and (c-beginning-of-macro)
+ (progn (c-end-of-macro)
+ (< (point) pt))))))
(backward-char)
(insert-char ?\\ 1)
(forward-char))
;; We want to inhibit blinking the paren since this would be
;; most disruptive. We'll blink it ourselves later on.
(old-blink-paren blink-paren-function)
- blink-paren-function)
+ blink-paren-function case-fold-search)
(c-save-buffer-state ()
(setq safepos (c-safe-position (point) (c-parse-state))
;; `}': clean up empty defun braces
(when (c-save-buffer-state ()
(and (memq 'empty-defun-braces c-cleanup-list)
- (eq last-command-event ?\})
+ (eq (c-last-command-char) ?\})
(c-intersect-lists '(defun-close class-close inline-close)
syntax)
(progn
;; `}': compact to a one-liner defun?
(save-match-data
(when
- (and (eq last-command-event ?\})
+ (and (eq (c-last-command-char) ?\})
(memq 'one-liner-defun c-cleanup-list)
(c-intersect-lists '(defun-close) syntax)
(c-try-one-liner))
(setq here (- (point-max) pos))))
;; `{': clean up brace-else-brace and brace-elseif-brace
- (when (eq last-command-event ?\{)
+ (when (eq (c-last-command-char) ?\{)
(cond
((and (memq 'brace-else-brace c-cleanup-list)
(re-search-backward
))))
;; blink the paren
- (and (eq last-command-event ?\})
+ (and (eq (c-last-command-char) ?\})
(not executing-kbd-macro)
old-blink-paren
(save-excursion
(when (and (not arg)
(eq literal 'c)
(memq 'comment-close-slash c-cleanup-list)
- (eq last-command-event ?/)
+ (eq (c-last-command-char) ?/)
(looking-at (concat "[ \t]*\\("
(regexp-quote comment-end) "\\)?$"))
; (eq c-block-comment-ender "*/") ; C-style comments ALWAYS end in */
(setq indentp (and (not arg)
c-syntactic-indentation
c-electric-flag
- (eq last-command-event ?/)
+ (eq (c-last-command-char) ?/)
(eq (char-before) (if literal ?* ?/))))
(self-insert-command (prefix-numeric-value arg))
(if indentp
(let ((pos (- (point-max) (point))))
(if (c-save-buffer-state ()
(and (or (and
- (eq last-command-event ?,)
+ (eq (c-last-command-char) ?,)
(memq 'list-close-comma c-cleanup-list))
(and
- (eq last-command-event ?\;)
+ (eq (c-last-command-char) ?\;)
(memq 'defun-close-semi c-cleanup-list)))
(progn
(forward-char -1)
(interactive "*P")
(let ((c-echo-syntactic-information-p nil)
- final-pos close-paren-inserted found-delim)
+ final-pos close-paren-inserted found-delim case-fold-search)
(self-insert-command (prefix-numeric-value arg))
(setq final-pos (point))
;; Indent the line if appropriate.
(when (and c-electric-flag c-syntactic-indentation c-recognize-<>-arglists)
(setq found-delim
- (if (eq last-command-event ?<)
+ (if (eq (c-last-command-char) ?<)
;; If a <, basically see if it's got "template" before it .....
(or (and (progn
(backward-char)
(interactive "*P")
(let ((literal (c-save-buffer-state () (c-in-literal)))
;; shut this up
- (c-echo-syntactic-information-p nil))
+ (c-echo-syntactic-information-p nil)
+ case-fold-search)
(self-insert-command (prefix-numeric-value arg))
(if (and (not arg) (not literal))
;; clean up brace-elseif-brace
(when
(and (memq 'brace-elseif-brace c-cleanup-list)
- (eq last-command-event ?\()
+ (eq (c-last-command-char) ?\()
(re-search-backward
(concat "}"
"\\([ \t\n]\\|\\\\\n\\)*"
;; clean up brace-catch-brace
(when
(and (memq 'brace-catch-brace c-cleanup-list)
- (eq last-command-event ?\()
+ (eq (c-last-command-char) ?\()
(re-search-backward
(concat "}"
"\\([ \t\n]\\|\\\\\n\\)*"
;; space-before-funcall clean-up?
((and (memq 'space-before-funcall c-cleanup-list)
- (eq last-command-event ?\()
+ (eq (c-last-command-char) ?\()
(save-excursion
(backward-char)
(skip-chars-backward " \t")
;; compact-empty-funcall clean-up?
((c-save-buffer-state ()
(and (memq 'compact-empty-funcall c-cleanup-list)
- (eq last-command-event ?\))
+ (eq (c-last-command-char) ?\))
(save-excursion
(c-safe (backward-char 2))
(when (looking-at "()")
(when (c-save-buffer-state ()
(and c-electric-flag
c-syntactic-indentation
- (not (eq last-command-event ?_))
+ (not (eq (c-last-command-char) ?_))
(= (save-excursion
(skip-syntax-backward "w")
(point))
;; Determine where we are with respect to functions (or other brace
;; constructs, included in the term "function" in the rest of this comment).
;; Point is assumed to be outside any macro or literal.
- ;; This is used by c-\(begining\|end\)-of-defun.
+ ;; This is used by c-\(beginning\|end\)-of-defun.
;;
;; Return one of these symbols:
;; at-header : we're at the start of a function's header.
; structure with other users of c-state-cache.
(orig-point-min (point-min)) (orig-point-max (point-max))
lim ; Position of { which has been widened to.
- where pos)
+ where pos case-fold-search)
(save-restriction
(if (eq c-defun-tactic 'go-outward)
; structure with other users of c-state-cache.
(orig-point-min (point-min)) (orig-point-max (point-max))
lim
- where pos)
+ where pos case-fold-search)
+
(save-restriction
(if (eq c-defun-tactic 'go-outward)
(setq lim (c-widen-to-enclosing-decl-scope ; e.g. class, namespace
(interactive)
(c-save-buffer-state
(beginning-of-defun-function end-of-defun-function
- where pos name-end)
-
+ where pos name-end case-fold-search)
+
(save-restriction
(widen)
(save-excursion
;; DEFFLAGSET(syslog_opt_flags,LOG_PID ...) ==> syslog_opt_flags
(match-string-no-properties 1))
+ ;; Objc selectors.
+ ((assq 'objc-method-intro (c-guess-basic-syntax))
+ (let ((bound (save-excursion (c-end-of-statement) (point)))
+ (kw-re (concat "\\(?:" c-symbol-key "\\)?:"))
+ (stretches))
+ (when (c-syntactic-re-search-forward c-symbol-key bound t t t)
+ (push (match-string-no-properties 0) stretches)
+ (while (c-syntactic-re-search-forward kw-re bound t t t)
+ (push (match-string-no-properties 0) stretches)))
+ (apply 'concat (nreverse stretches))))
+
(t
;; Normal function or initializer.
(when (c-syntactic-re-search-forward "[{(]" nil t)
(defun c-mark-function ()
"Put mark at end of the current top-level declaration or macro, point at beginning.
-If point is not inside any then the closest following one is chosen.
+If point is not inside any then the closest following one is
+chosen. Each successive call of this command extends the marked
+region by one function.
+
+A mark is left where the command started, unless the region is already active
+\(in Transient Mark mode).
As opposed to \\[c-beginning-of-defun] and \\[c-end-of-defun], this
function does not require the declaration to contain a brace block."
(interactive)
- (let (decl-limits)
+ (let (decl-limits case-fold-search)
(c-save-buffer-state nil
;; We try to be line oriented, unless there are several
;; declarations on the same line.
(if (not decl-limits)
(error "Cannot find any declaration")
- (goto-char (car decl-limits))
- (push-mark (cdr decl-limits) nil t))))
+ (let* ((extend-region-p
+ (and (eq this-command 'c-mark-function)
+ (eq last-command 'c-mark-function)))
+ (push-mark-p (and (eq this-command 'c-mark-function)
+ (not extend-region-p)
+ (not (and transient-mark-mode mark-active)))))
+ (if push-mark-p (push-mark (point)))
+ (if extend-region-p
+ (progn
+ (exchange-point-and-mark)
+ (setq decl-limits (c-declaration-limits t))
+ (when (not decl-limits)
+ (exchange-point-and-mark)
+ (error "Cannot find any declaration"))
+ (goto-char (cdr decl-limits))
+ (exchange-point-and-mark))
+ (goto-char (car decl-limits))
+ (push-mark (cdr decl-limits) nil t))))))
(defun c-cpp-define-name ()
"Return the name of the current CPP macro, or NIL if we're not in one."
(interactive)
- (save-excursion
- (and c-opt-cpp-macro-define-start
- (c-beginning-of-macro)
- (looking-at c-opt-cpp-macro-define-start)
- (match-string-no-properties 1))))
+ (let (case-fold-search)
+ (save-excursion
+ (and c-opt-cpp-macro-define-start
+ (c-beginning-of-macro)
+ (looking-at c-opt-cpp-macro-define-start)
+ (match-string-no-properties 1)))))
\f
;; Movement by statements.
(c-narrow-to-comment-innards range) ; This may move point back.
(let* ((here (point))
last
- (here-filler ; matches WS and comment-prefices at point.
+ (here-filler ; matches WS and comment-prefixes at point.
(concat "\\=\\(^[ \t]*\\(" c-current-comment-prefix "\\)"
"\\|[ \t\n\r\f]\\)*"))
(prefix-at-bol-here ; matches WS and prefix at BOL, just before point
;; Now seek successively earlier sentence ends between PAR-BEG and
;; HERE, until the "start of sentence" following it is earlier than
- ;; HERE, or we hit PAR-BEG. Beware of comment prefices!
+ ;; HERE, or we hit PAR-BEG. Beware of comment prefixes!
(while (and (re-search-backward (c-sentence-end) par-beg 'limit)
(setq last (point))
(goto-char (match-end 0)) ; tentative beginning of sentence
(defun c-after-statement-terminator-p () ; Should we pass in LIM here?
;; Does point immediately follow a statement "terminator"? A virtual
- ;; semicolon is regarded here as such. So is a an opening brace ;-)
+ ;; semicolon is regarded here as such. So is an opening brace ;-)
;;
;; This function might do hidden buffer changes.
(or (save-excursion
(eq (match-end 0) eot))
'cpp-end-block)
(t
- 'other))))
+ 'other)))
+ case-fold-search)
(if (and (memq line-type '(anchored-comment empty-line))
c-indent-comments-syntactically-p)
(let ((c-syntactic-context (c-guess-basic-syntax)))
(let* ((forward (> count 0))
(increment (if forward -1 1))
(search-function (if forward 're-search-forward 're-search-backward))
- new)
+ new case-fold-search)
(unless (integerp target-depth)
(setq target-depth (if target-depth -1 0)))
(save-excursion
In the macro case this also has the effect of realigning any line
continuation backslashes, unless `c-auto-align-backslashes' is nil."
(interactive "*")
- (let ((here (point-marker)) decl-limits)
+ (let ((here (point-marker)) decl-limits case-fold-search)
(unwind-protect
(progn
(c-save-buffer-state nil
(let ((fill-paragraph-function
;; Avoid infinite recursion.
(if (not (eq fill-paragraph-function 'c-fill-paragraph))
- fill-paragraph-function))
- (start-point (point-marker)))
- (c-mask-paragraph
- t nil (lambda () (fill-region-as-paragraph (point-min) (point-max) arg)))
- (goto-char start-point))
+ fill-paragraph-function)))
+ (c-mask-paragraph t nil 'fill-paragraph arg))
;; Always return t. This has the effect that if filling isn't done
;; above, it isn't done at all, and it's therefore effectively
;; disabled in normal code.
(interactive "*")
(let* (c-lit-limits c-lit-type
- (c-macro-start c-macro-start))
+ (c-macro-start c-macro-start)
+ case-fold-search)
(c-save-buffer-state ()
(setq c-lit-limits (c-literal-limits nil nil t)
HCoop / bpt / emacs.git / blobdiff