;;; cc-cmds.el --- user level commands for CC Mode
;; Copyright (C) 1985, 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-;; 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+;; 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
;; Free Software Foundation, Inc.
;; Authors: 2003- Alan Mackenzie
;; 1998- Martin Stjernholm
;; 1992-1999 Barry A. Warsaw
-;; 1987 Dave Detlefs and Stewart Clamen
+;; 1987 Dave Detlefs
+;; 1987 Stewart Clamen
;; 1985 Richard M. Stallman
;; Maintainer: bug-cc-mode@gnu.org
;; Created: 22-Apr-1997 (split from cc-mode.el)
;; This file is part of GNU Emacs.
-;; GNU Emacs is free software; you can redistribute it and/or modify
+;; 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, or (at your option)
-;; any later version.
+;; 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
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
-;; along with this program; see the file COPYING. If not, write to
-;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-;; Boston, MA 02110-1301, USA.
+;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
(cc-bytecomp-defun delete-forward-p) ; XEmacs
(cc-bytecomp-defvar filladapt-mode) ; c-fill-paragraph contains a kludge
; which looks at this.
-(cc-bytecomp-defun c-forward-subword)
-(cc-bytecomp-defun c-backward-subword)
\f
;; Indentation / Display syntax functions
(defvar c-fix-backslashes t)
"a" "")
(if c-hungry-delete-key "h" "")
(if (and
- ;; cc-subword might not be loaded.
- (boundp 'c-subword-mode)
- (symbol-value 'c-subword-mode))
+ ;; subword might not be loaded.
+ (boundp 'subword-mode)
+ (symbol-value 'subword-mode))
"w"
"")))
(bare-mode-name (if (string-match "\\(^[^/]*\\)/" mode-name)
(c-keep-region-active))
(defalias 'c-toggle-auto-state 'c-toggle-auto-newline)
-(make-obsolete 'c-toggle-auto-state 'c-toggle-auto-newline)
+(make-obsolete 'c-toggle-auto-state 'c-toggle-auto-newline "22.1")
(defun c-toggle-hungry-state (&optional arg)
"Toggle hungry-delete-key feature.
(bolp (bolp)))
(beginning-of-line)
(delete-horizontal-space)
- (insert last-command-char)
+ (insert last-command-event)
(and (not bolp)
(goto-char (- (point-max) pos)))
)))
;; This is the list of brace syntactic symbols that can hang.
;; If any new ones are added to c-offsets-alist, they should be
;; added here as well.
- '(class-open class-close defun-open defun-close
+ ;;
+ ;; The order of this list is important; if SYNTAX has several
+ ;; elements, the element that "wins" is the earliest in SYMS.
+ '(arglist-cont-nonempty ; e.g. an array literal.
+ class-open class-close defun-open defun-close
inline-open inline-close
brace-list-open brace-list-close
brace-list-intro brace-entry-open
;; `}': clean up empty defun braces
(when (c-save-buffer-state ()
(and (memq 'empty-defun-braces c-cleanup-list)
- (eq last-command-char ?\})
+ (eq last-command-event ?\})
(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-char ?\})
+ (and (eq last-command-event ?\})
(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-char ?\{)
+ (when (eq last-command-event ?\{)
(cond
((and (memq 'brace-else-brace c-cleanup-list)
(re-search-backward
))))
;; blink the paren
- (and (eq last-command-char ?\})
+ (and (eq last-command-event ?\})
(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-char ?/)
+ (eq last-command-event ?/)
(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-char ?/)
+ (eq last-command-event ?/)
(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-char ?,)
+ (eq last-command-event ?,)
(memq 'list-close-comma c-cleanup-list))
(and
- (eq last-command-char ?\;)
+ (eq last-command-event ?\;)
(memq 'defun-close-semi c-cleanup-list)))
(progn
(forward-char -1)
<-pos)
(when c-recognize-<>-arglists
- (if (eq last-command-char ?<)
+ (if (eq last-command-event ?<)
(when (and (progn
(backward-char)
(= (point)
;; clean up brace-elseif-brace
(when
(and (memq 'brace-elseif-brace c-cleanup-list)
- (eq last-command-char ?\()
+ (eq last-command-event ?\()
(re-search-backward
(concat "}"
"\\([ \t\n]\\|\\\\\n\\)*"
;; clean up brace-catch-brace
(when
(and (memq 'brace-catch-brace c-cleanup-list)
- (eq last-command-char ?\()
+ (eq last-command-event ?\()
(re-search-backward
(concat "}"
"\\([ \t\n]\\|\\\\\n\\)*"
;; space-before-funcall clean-up?
((and (memq 'space-before-funcall c-cleanup-list)
- (eq last-command-char ?\()
+ (eq last-command-event ?\()
(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-char ?\))
+ (eq last-command-event ?\))
(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-char ?_))
+ (not (eq last-command-event ?_))
(= (save-excursion
(skip-syntax-backward "w")
(point))
(delete-char -2)))))
\f
+
+(declare-function subword-forward "subword" (&optional arg))
+(declare-function subword-backward "subword" (&optional arg))
+
;; "nomenclature" functions + c-scope-operator.
(defun c-forward-into-nomenclature (&optional arg)
"Compatibility alias for `c-forward-subword'."
(interactive "p")
- (require 'cc-subword)
- (c-forward-subword arg))
-(make-obsolete 'c-forward-into-nomenclature 'c-forward-subword)
+ (require 'subword)
+ (subword-forward arg))
+(make-obsolete 'c-forward-into-nomenclature 'subword-forward "23.2")
(defun c-backward-into-nomenclature (&optional arg)
"Compatibility alias for `c-backward-subword'."
(interactive "p")
- (require 'cc-subword)
- (c-backward-subword arg))
-(make-obsolete 'c-backward-into-nomenclature 'c-backward-subword)
+ (require 'subword)
+ (subword-backward arg))
+(make-obsolete 'c-backward-into-nomenclature 'subword-backward "23.2")
(defun c-scope-operator ()
"Insert a double colon scope operator at point.
(c-keep-region-active)
(= arg 0)))
+(defun c-defun-name ()
+ "Return the name of the current defun, or NIL if there isn't one.
+\"Defun\" here means a function, or other top level construct
+with a brace block."
+ (interactive)
+ (c-save-buffer-state
+ (beginning-of-defun-function end-of-defun-function
+ where pos name-end)
+
+ (save-restriction
+ (widen)
+ (save-excursion
+ ;; Move back out of any macro/comment/string we happen to be in.
+ (c-beginning-of-macro)
+ (setq pos (c-literal-limits))
+ (if pos (goto-char (car pos)))
+
+ (setq where (c-where-wrt-brace-construct))
+
+ ;; Move to the beginning of the current defun, if any, if we're not
+ ;; already there.
+ (if (eq where 'outwith-function)
+ nil
+ (unless (eq where 'at-header)
+ (c-backward-to-nth-BOF-{ 1 where)
+ (c-beginning-of-decl-1))
+
+ ;; Pick out the defun name, according to the type of defun.
+ (cond
+ ;; struct, union, enum, or similar:
+ ((and (looking-at c-type-prefix-key)
+ (progn (c-forward-token-2 2) ; over "struct foo "
+ (or (eq (char-after) ?\{)
+ (looking-at c-symbol-key)))) ; "struct foo bar ..."
+ (save-match-data (c-forward-token-2))
+ (when (eq (char-after) ?\{)
+ (c-backward-token-2)
+ (looking-at c-symbol-key))
+ (match-string-no-properties 0))
+
+ ((looking-at "DEFUN\\_>")
+ ;; DEFUN ("file-name-directory", Ffile_name_directory, Sfile_name_directory, ...) ==> Ffile_name_directory
+ ;; DEFUN(POSIX::STREAM-LOCK, stream lockp &key BLOCK SHARED START LENGTH) ==> POSIX::STREAM-LOCK
+ (down-list 1)
+ (c-forward-syntactic-ws)
+ (when (eq (char-after) ?\")
+ (forward-sexp 1)
+ (c-forward-token-2)) ; over the comma and following WS.
+ (buffer-substring-no-properties
+ (point)
+ (progn
+ (c-forward-token-2)
+ (when (looking-at ":") ; CLISP: DEFUN(PACKAGE:LISP-SYMBOL,...)
+ (skip-chars-forward "^,"))
+ (c-backward-syntactic-ws)
+ (point))))
+
+ ((looking-at "DEF[a-zA-Z0-9_]* *( *\\([^, ]*\\) *,")
+ ;; DEFCHECKER(sysconf_arg,prefix=_SC,default=, ...) ==> sysconf_arg
+ ;; DEFFLAGSET(syslog_opt_flags,LOG_PID ...) ==> syslog_opt_flags
+ (match-string-no-properties 1))
+
+ (t
+ ;; Normal function or initializer.
+ (when (c-syntactic-re-search-forward "[{(]" nil t)
+ (backward-char)
+ (c-backward-syntactic-ws)
+ (when (eq (char-before) ?\=) ; struct foo bar = {0, 0} ;
+ (c-backward-token-2)
+ (c-backward-syntactic-ws))
+ (setq name-end (point))
+ (c-backward-token-2)
+ (buffer-substring-no-properties (point) name-end)))))))))
+
(defun c-declaration-limits (near)
;; Return a cons of the beginning and end positions of the current
;; top level declaration or macro. If point is not inside any then
(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))))
+
\f
;; Movement by statements.
(defun c-in-comment-line-prefix-p ()
function stops at them when going backward, but not when going
forward."
(interactive "p")
- (c-forward-conditional (- count) -1)
+ (let ((new-point (c-scan-conditionals (- count) -1)))
+ (push-mark)
+ (goto-char new-point))
(c-keep-region-active))
(defun c-up-conditional-with-else (count)
Just like `c-up-conditional', except it also stops at \"#else\"
directives."
(interactive "p")
- (c-forward-conditional (- count) -1 t)
+ (let ((new-point (c-scan-conditionals (- count) -1 t)))
+ (push-mark)
+ (goto-char new-point))
(c-keep-region-active))
(defun c-down-conditional (count)
function stops at them when going forward, but not when going
backward."
(interactive "p")
- (c-forward-conditional count 1)
+ (let ((new-point (c-scan-conditionals count 1)))
+ (push-mark)
+ (goto-char new-point))
(c-keep-region-active))
(defun c-down-conditional-with-else (count)
Just like `c-down-conditional', except it also stops at \"#else\"
directives."
(interactive "p")
- (c-forward-conditional count 1 t)
+ (let ((new-point (c-scan-conditionals count 1 t)))
+ (push-mark)
+ (goto-char new-point))
(c-keep-region-active))
(defun c-backward-conditional (count &optional target-depth with-else)
"Move back across a preprocessor conditional, leaving mark behind.
A prefix argument acts as a repeat count. With a negative argument,
-move forward across a preprocessor conditional."
+move forward across a preprocessor conditional.
+
+The optional arguments TARGET-DEPTH and WITH-ELSE are historical,
+and have the same meanings as in `c-scan-conditionals'. If you
+are calling c-forward-conditional from a program, you might want
+to call `c-scan-conditionals' directly instead."
(interactive "p")
- (c-forward-conditional (- count) target-depth with-else)
+ (let ((new-point (c-scan-conditionals (- count) target-depth with-else)))
+ (push-mark)
+ (goto-char new-point))
(c-keep-region-active))
(defun c-forward-conditional (count &optional target-depth with-else)
A prefix argument acts as a repeat count. With a negative argument,
move backward across a preprocessor conditional.
+If there aren't enough conditionals after \(or before) point, an
+error is signalled.
+
+\"#elif\" is treated like \"#else\" followed by \"#if\", except that
+the nesting level isn't changed when tracking subconditionals.
+
+The optional arguments TARGET-DEPTH and WITH-ELSE are historical,
+and have the same meanings as in `c-scan-conditionals'. If you
+are calling c-forward-conditional from a program, you might want
+to call `c-scan-conditionals' directly instead."
+ (interactive "p")
+ (let ((new-point (c-scan-conditionals count target-depth with-else)))
+ (push-mark)
+ (goto-char new-point)))
+
+(defun c-scan-conditionals (count &optional target-depth with-else)
+ "Scan forward across COUNT preprocessor conditionals.
+With a negative argument, scan backward across preprocessor
+conditionals. Return the end position. Point is not moved.
+
+If there aren't enough preprocessor conditionals, throw an error.
+
\"#elif\" is treated like \"#else\" followed by \"#if\", except that
the nesting level isn't changed when tracking subconditionals.
The optional argument TARGET-DEPTH specifies the wanted nesting depth
-after each scan. I.e. if TARGET-DEPTH is -1, the function will move
-out of the enclosing conditional. A non-integer non-nil TARGET-DEPTH
+after each scan. E.g. if TARGET-DEPTH is -1, the end position will be
+outside the enclosing conditional. A non-integer non-nil TARGET-DEPTH
counts as -1.
If the optional argument WITH-ELSE is non-nil, \"#else\" directives
are treated as conditional clause limits. Normally they are ignored."
- (interactive "p")
(let* ((forward (> count 0))
(increment (if forward -1 1))
(search-function (if forward 're-search-forward 're-search-backward))
- (new))
+ new)
(unless (integerp target-depth)
(setq target-depth (if target-depth -1 0)))
(save-excursion
(error "No containing preprocessor conditional"))
(goto-char (setq new found)))
(setq count (+ count increment))))
- (push-mark)
- (goto-char new))
- (c-keep-region-active))
+ (c-keep-region-active)
+ new))
\f
;; commands to indent lines, regions, defuns, and expressions
(c-parsing-error nil)
;; shut up any echo msgs on indiv lines
(c-echo-syntactic-information-p nil)
- (in-macro (and c-auto-align-backslashes
- (c-save-buffer-state ()
- (save-excursion (c-beginning-of-macro)))
- start))
+ (ml-macro-start ; Start pos of multi-line macro.
+ (and (c-save-buffer-state ()
+ (save-excursion (c-beginning-of-macro)))
+ (eq (char-before (c-point 'eol)) ?\\)
+ start))
(c-fix-backslashes nil)
syntax)
(unwind-protect
(progn
(c-progress-init start end 'c-indent-region)
- (while (and (bolp)
+
+ (while (and (bolp) ;; One line each time round the loop.
(not (eobp))
(< (point) endmark))
;; update progress
(c-progress-update)
;; skip empty lines
- (skip-chars-forward " \t\n")
- (beginning-of-line)
- ;; Get syntax and indent.
- (c-save-buffer-state nil
- (setq syntax (c-guess-basic-syntax)))
- (if (and c-auto-align-backslashes
- (assq 'cpp-macro syntax))
- ;; Record macro start.
- (setq in-macro (point)))
- (if in-macro
- (if (looking-at "\\s *\\\\$")
- (forward-line)
- (c-indent-line syntax t t)
- (if (progn (end-of-line)
- (not (eq (char-before) ?\\)))
- (progn
- ;; Fixup macro backslashes.
- (forward-line)
- (c-backslash-region in-macro (point) nil)
- (setq in-macro nil))
- (forward-line)))
- (c-indent-line syntax t t)
- (forward-line)))
- (if in-macro
- (c-backslash-region in-macro (c-point 'bopl) nil t)))
+ (unless (or (looking-at "\\s *$")
+ (and ml-macro-start (looking-at "\\s *\\\\$")))
+ ;; Get syntax and indent.
+ (c-save-buffer-state nil
+ (setq syntax (c-guess-basic-syntax)))
+ (c-indent-line syntax t t))
+
+ (if ml-macro-start
+ ;; End of current multi-line macro?
+ (when (and c-auto-align-backslashes
+ (not (eq (char-before (c-point 'eol)) ?\\)))
+ ;; Fixup macro backslashes.
+ (c-backslash-region ml-macro-start (c-point 'bonl) nil)
+ (setq ml-macro-start nil))
+ ;; New multi-line macro?
+ (if (and (assq 'cpp-macro syntax)
+ (eq (char-before (c-point 'eol)) ?\\))
+ (setq ml-macro-start (point))))
+
+ (forward-line))
+
+ (if (and ml-macro-start c-auto-align-backslashes)
+ (c-backslash-region ml-macro-start (c-point 'bopl) nil t)))
(set-marker endmark nil)
(c-progress-fini 'c-indent-region))
(c-echo-parsing-error quiet))
;; compiled, e.g. in the menus.
(c-region-is-active-p))
-(defun c-indent-line-or-region ()
- "When the region is active, indent it syntactically. Otherwise
-indent the current line syntactically."
- ;; Emacs has a variable called mark-active, XEmacs uses region-active-p
- (interactive)
- (if (and transient-mark-mode mark-active
- (not (eq (region-beginning) (region-end))))
+(defun c-indent-line-or-region (&optional arg region)
+ "Indent active region, current line, or block starting on this line.
+In Transient Mark mode, when the region is active, reindent the region.
+Otherwise, with a prefix argument, rigidly reindent the expression
+starting on the current line.
+Otherwise reindent just the current line."
+ (interactive
+ (list current-prefix-arg (use-region-p)))
+ (if region
(c-indent-region (region-beginning) (region-end))
- (c-indent-line)))
-
+ (c-indent-command arg)))
\f
;; for progress reporting
(defvar c-progress-info nil)
(save-excursion
(goto-char (cdr c-lit-limits))
(beginning-of-line)
- (and (search-forward-regexp
+ ;; The following conjunct was added to avoid an
+ ;; "Invalid search bound (wrong side of point)"
+ ;; error in the subsequent re-search. Maybe
+ ;; another fix would be needed (2007-12-08).
+ (and (> (- (cdr c-lit-limits) 2) (point))
+ (search-forward-regexp
(concat "\\=[ \t]*\\(" c-current-comment-prefix "\\)")
(- (cdr c-lit-limits) 2) t)
(not (search-forward-regexp
(forward-char (- hang-ender-stuck))
(if (or fill-paragraph (not auto-fill-spaces))
(insert-char ?\ hang-ender-stuck t)
- (insert auto-fill-spaces)
- (setq here (- here (- hang-ender-stuck (length auto-fill-spaces)))))
+ (insert auto-fill-spaces))
(delete-char hang-ender-stuck)
(goto-char here))
(set-marker tmp-post nil))
(indent-to col))))))
(defalias 'c-comment-line-break-function 'c-indent-new-comment-line)
-(make-obsolete 'c-comment-line-break-function 'c-indent-new-comment-line)
+(make-obsolete 'c-comment-line-break-function 'c-indent-new-comment-line "21.1")
;; advice for indent-new-comment-line for older Emacsen
(unless (boundp 'comment-line-break-function)
\f
(cc-provide 'cc-cmds)
-;;; arch-tag: bf0611dc-d1f4-449e-9e45-4ec7c6936677
+;; arch-tag: bf0611dc-d1f4-449e-9e45-4ec7c6936677
;;; cc-cmds.el ends here