X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/a7c7b186ff3b8bd18929d84237899dbdda7c0912..de4c2de7611201b1debf700a8d4bd50701651bad:/lisp/progmodes/cc-cmds.el diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el index 1e5db01738..806fbade69 100644 --- a/lisp/progmodes/cc-cmds.el +++ b/lisp/progmodes/cc-cmds.el @@ -1,11 +1,12 @@ -;;; cc-cmds.el --- user level commands for CC Mode +;;; cc-cmds.el --- user level commands for CC Mode -;; Copyright (C) 1985,87,92,93,94,95,96,97 Free Software Foundation, Inc. +;; Copyright (C) 1985,1987,1992-2003 Free Software Foundation, Inc. -;; Authors: 1992-1997 Barry A. Warsaw +;; Authors: 1998- Martin Stjernholm +;; 1992-1999 Barry A. Warsaw ;; 1987 Dave Detlefs and Stewart Clamen ;; 1985 Richard M. Stallman -;; Maintainer: cc-mode-help@python.org +;; Maintainer: bug-cc-mode@gnu.org ;; Created: 22-Apr-1997 (split from cc-mode.el) ;; Version: See cc-mode.el ;; Keywords: c languages oop @@ -23,28 +24,249 @@ ;; GNU General Public License for more details. ;; You should have received a copy of the GNU General Public License -;; along with GNU Emacs; see the file COPYING. If not, write to the -;; Free Software Foundation, Inc., 59 Temple Place - Suite 330, +;; along with GNU Emacs; see the file COPYING. If not, write to +;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330, ;; Boston, MA 02111-1307, USA. +;;; Commentary: + +;;; Code: + (eval-when-compile - (require 'cc-defs)) + (let ((load-path + (if (and (boundp 'byte-compile-dest-file) + (stringp byte-compile-dest-file)) + (cons (file-name-directory byte-compile-dest-file) load-path) + load-path))) + (load "cc-bytecomp" nil t))) + +(cc-require 'cc-defs) +(cc-require 'cc-vars) +(cc-require 'cc-engine) + +;; Silence the compiler. +(cc-bytecomp-defvar delete-key-deletes-forward) ; XEmacs 20+ +(cc-bytecomp-defun delete-forward-p) ; XEmacs 21+ +(cc-bytecomp-obsolete-fun insert-and-inherit) ; Marked obsolete in XEmacs 19 +(cc-bytecomp-defvar filladapt-mode) ; c-fill-paragraph contains a kludge + ; which looks at this. + + +(defvar c-fix-backslashes t) + +(defun c-indent-line (&optional syntax quiet ignore-point-pos) + "Indent the current line according to the syntactic context, +if `c-syntactic-indentation' is non-nil. Optional SYNTAX is the +syntactic information for the current line. Be silent about syntactic +errors if the optional argument QUIET is non-nil, even if +`c-report-syntactic-errors' is non-nil. Normally the position of +point is used to decide where the old indentation is on a lines that +is otherwise empty \(ignoring any line continuation backslash), but +that's not done if IGNORE-POINT-POS is non-nil. Returns the amount of +indentation change \(in columns)." + ;; + ;; This function does not do any hidden buffer changes. + + (let ((line-cont-backslash (save-excursion + (end-of-line) + (eq (char-before) ?\\))) + (c-fix-backslashes c-fix-backslashes) + bs-col + shift-amt) + (when (and (not ignore-point-pos) + (save-excursion + (beginning-of-line) + (looking-at (if line-cont-backslash + "\\(\\s *\\)\\\\$" + "\\(\\s *\\)$"))) + (<= (point) (match-end 1))) + ;; Delete all whitespace after point if there's only whitespace + ;; on the line, so that any code that does back-to-indentation + ;; or similar gets the current column in this case. If this + ;; removes a line continuation backslash it'll be restored + ;; at the end. + (unless c-auto-align-backslashes + ;; Should try to keep the backslash alignment + ;; in this case. + (save-excursion + (goto-char (match-end 0)) + (setq bs-col (1- (current-column))))) + (delete-region (point) (match-end 0)) + (setq c-fix-backslashes t)) + (if c-syntactic-indentation + (setq c-parsing-error + (or (let ((c-parsing-error nil) + (c-syntactic-context + (or syntax + (and (boundp 'c-syntactic-context) + c-syntactic-context)))) + (c-save-buffer-state (indent) + (unless c-syntactic-context + (setq c-syntactic-context (c-guess-basic-syntax))) + (setq indent (c-get-syntactic-indentation + c-syntactic-context)) + (and (not (c-echo-parsing-error quiet)) + c-echo-syntactic-information-p + (message "syntax: %s, indent: %d" + c-syntactic-context indent)) + (setq shift-amt (- indent (current-indentation)))) + (c-shift-line-indentation shift-amt) + (run-hooks 'c-special-indent-hook) + c-parsing-error) + c-parsing-error)) + (let ((indent 0)) + (save-excursion + (while (and (= (forward-line -1) 0) + (if (looking-at "\\s *\\\\?$") + t + (setq indent (current-indentation)) + nil)))) + (setq shift-amt (- indent (current-indentation))) + (c-shift-line-indentation shift-amt))) + (when (and c-fix-backslashes line-cont-backslash) + (if bs-col + (save-excursion + (indent-to bs-col) + (insert ?\\)) + (when c-auto-align-backslashes + ;; Realign the line continuation backslash. + (c-backslash-region (point) (point) nil t)))) + shift-amt)) + +(defun c-newline-and-indent (&optional newline-arg) + "Inserts a newline and indents the new line. +This function fixes line continuation backslashes if inside a macro, +and takes care to set the indentation before calling +`indent-according-to-mode', so that lineup functions like +`c-lineup-dont-change' works better." + ;; + ;; This function does not do any hidden buffer changes. + + ;; TODO: Backslashes before eol in comments and literals aren't + ;; kept intact. + (let ((c-macro-start (c-query-macro-start)) + ;; Avoid calling c-backslash-region from c-indent-line if it's + ;; called during the newline call, which can happen due to + ;; c-electric-continued-statement, for example. We also don't + ;; want any backslash alignment from indent-according-to-mode. + (c-fix-backslashes nil) + has-backslash insert-backslash + start col) + (save-excursion + (beginning-of-line) + (setq start (point)) + (while (and (looking-at "[ \t]*\\\\?$") + (= (forward-line -1) 0))) + (setq col (current-indentation))) + (when c-macro-start + (if (and (eolp) (eq (char-before) ?\\)) + (setq insert-backslash t + has-backslash t) + (setq has-backslash (eq (char-before (c-point 'eol)) ?\\)))) + (newline newline-arg) + (indent-to col) + (when c-macro-start + (if insert-backslash + (progn + ;; The backslash stayed on the previous line. Insert one + ;; before calling c-backslash-region, so that + ;; bs-col-after-end in it works better. Fixup the + ;; backslashes on the newly inserted line. + (insert ?\\) + (backward-char) + (c-backslash-region (point) (point) nil t)) + ;; The backslash moved to the new line, if there was any. Let + ;; c-backslash-region fix a backslash on the previous line, + ;; and the one that might be on the new line. + ;; c-auto-align-backslashes is intentionally ignored here; + ;; maybe the moved backslash should be left alone if it's set, + ;; but we fix both lines on the grounds that the old backslash + ;; has been moved anyway and is now in a different context. + (c-backslash-region start (if has-backslash (point) start) nil t))) + (when c-syntactic-indentation + ;; Reindent syntactically. The indentation done above is not + ;; wasted, since c-indent-line might look at the current + ;; indentation. + (let ((c-syntactic-context (c-save-buffer-state nil + (c-guess-basic-syntax)))) + ;; We temporarily insert another line break, so that the + ;; lineup functions will see the line as empty. That makes + ;; e.g. c-lineup-cpp-define more intuitive since it then + ;; proceeds to the preceding line in this case. + (insert ?\n) + (delete-horizontal-space) + (setq start (- (point-max) (point))) + (unwind-protect + (progn + (backward-char) + (indent-according-to-mode)) + (goto-char (- (point-max) start)) + (delete-char -1))) + (when has-backslash + ;; Must align the backslash again after reindentation. The + ;; c-backslash-region call above can't be optimized to ignore + ;; this line, since it then won't align correctly with the + ;; lines below if the first line in the macro is broken. + (c-backslash-region (point) (point) nil t))))) + +(defun c-show-syntactic-information (arg) + "Show syntactic information for current line. +With universal argument, inserts the analysis as a comment on that line." + (interactive "P") + (let* ((c-parsing-error nil) + (syntax (if (boundp 'c-syntactic-context) + ;; Use `c-syntactic-context' in the same way as + ;; `c-indent-line', to be consistent. + c-syntactic-context + (c-save-buffer-state nil + (c-guess-basic-syntax))))) + (if (not (consp arg)) + (message "syntactic analysis: %s" syntax) + (indent-for-comment) + (insert-and-inherit (format "%s" syntax)) + )) + (c-keep-region-active)) + +(defun c-syntactic-information-on-region (from to) + "Inserts a comment with the syntactic analysis on every line in the region." + (interactive "*r") + (save-excursion + (save-restriction + (narrow-to-region from to) + (goto-char (point-min)) + (while (not (eobp)) + (c-show-syntactic-information '(0)) + (forward-line))))) -(defun c-calculate-state (arg prevstate) - ;; Calculate the new state of PREVSTATE, t or nil, based on arg. If - ;; arg is nil or zero, toggle the state. If arg is negative, turn - ;; the state off, and if arg is positive, turn the state on - (if (or (not arg) - (zerop (setq arg (prefix-numeric-value arg)))) - (not prevstate) - (> arg 0))) - -;; Auto-newline and hungry-delete -(defun c-toggle-auto-state (arg) +(defun c-toggle-syntactic-indentation (&optional arg) + "Toggle syntactic indentation. +Optional numeric ARG, if supplied, turns on syntactic indentation when +positive, turns it off when negative, and just toggles it when zero or +left out. + +When syntactic indentation is turned on (the default), the indentation +functions and the electric keys indent according to the syntactic +context keys, when applicable. + +When it's turned off, the electric keys does no reindentation, the +indentation functions indents every new line to the same level as the +previous nonempty line, and \\[c-indent-command] adjusts the +indentation in seps specified `c-basic-offset'. The indentation style +has no effect in this mode, nor any of the indentation associated +variables, e.g. `c-special-indent-hook'. + +This command sets the variable `c-syntactic-indentation'." + (interactive "P") + (setq c-syntactic-indentation + (c-calculate-state arg c-syntactic-indentation)) + (c-keep-region-active)) + +(defun c-toggle-auto-state (&optional arg) "Toggle auto-newline feature. -Optional numeric ARG, if supplied turns on auto-newline when positive, -turns it off when negative, and just toggles it when zero. +Optional numeric ARG, if supplied, turns on auto-newline when +positive, turns it off when negative, and just toggles it when zero or +left out. When the auto-newline feature is enabled (as evidenced by the `/a' or `/ah' on the modeline after the mode name) newlines are automatically @@ -55,10 +277,11 @@ and colon." (c-update-modeline) (c-keep-region-active)) -(defun c-toggle-hungry-state (arg) +(defun c-toggle-hungry-state (&optional arg) "Toggle hungry-delete-key feature. -Optional numeric ARG, if supplied turns on hungry-delete when positive, -turns it off when negative, and just toggles it when zero. +Optional numeric ARG, if supplied, turns on hungry-delete when +positive, turns it off when negative, and just toggles it when zero or +left out. When the hungry-delete-key feature is enabled (as evidenced by the `/h' or `/ah' on the modeline after the mode name) the delete key @@ -68,11 +291,11 @@ gobbles all preceding whitespace in one fell swoop." (c-update-modeline) (c-keep-region-active)) -(defun c-toggle-auto-hungry-state (arg) +(defun c-toggle-auto-hungry-state (&optional arg) "Toggle auto-newline and hungry-delete-key features. -Optional numeric ARG, if supplied turns on auto-newline and +Optional numeric ARG, if supplied, turns on auto-newline and hungry-delete when positive, turns them off when negative, and just -toggles them when zero. +toggles them when zero or left out. See `c-toggle-auto-state' and `c-toggle-hungry-state' for details." (interactive "P") @@ -84,74 +307,97 @@ See `c-toggle-auto-state' and `c-toggle-hungry-state' for details." ;; Electric keys -;; Note: In XEmacs 20.3 the Delete and BackSpace keysyms have been -;; separated and "\177" is no longer an alias for both keys. Also, -;; the variable delete-key-deletes-forward controls in which direction -;; the Delete keysym deletes characters. The functions -;; c-electric-delete and c-electric-backspace attempt to deal with -;; this new functionality. For Emacs 19 and XEmacs 19 backwards -;; compatibility, the old behavior has moved to c-electric-backspace -;; and c-backspace-function. - (defun c-electric-backspace (arg) - "Deletes preceding character or whitespace. + "Delete the preceding character or whitespace. If `c-hungry-delete-key' is non-nil, as evidenced by the \"/h\" or \"/ah\" string on the mode line, then all preceding whitespace is -consumed. If however an ARG is supplied, or `c-hungry-delete-key' is -nil, or point is inside a literal then the function in the variable -`c-backspace-function' is called. - -See also \\[c-electric-delete]." - (interactive "P") +consumed. If however a prefix argument is supplied, or +`c-hungry-delete-key' is nil, or point is inside a literal then the +function in the variable `c-backspace-function' is called." + (interactive "*P") (if (or (not c-hungry-delete-key) arg (c-in-literal)) (funcall c-backspace-function (prefix-numeric-value arg)) - (let ((here (point))) - (skip-chars-backward " \t\n") - (if (/= (point) here) - (delete-region (point) here) - (funcall c-backspace-function 1) - )))) + (c-hungry-backspace))) -(defun c-electric-delete (arg) - "Deletes preceding or following character or whitespace. - -The behavior of this function depends on the variable -`delete-key-deletes-forward'. If this variable is nil (or does not -exist, as in older Emacsen), then this function behaves identical to -\\[c-electric-backspace]. - -If `delete-key-deletes-forward' is non-nil, then deletion occurs in -the forward direction. So if `c-hungry-delete-key' is non-nil, as -evidenced by the \"/h\" or \"/ah\" string on the mode line, then all -following whitespace is consumed. If however an ARG is supplied, or +(defun c-hungry-backspace () + "Delete the preceding character or all preceding whitespace +back to the previous non-whitespace character. +See also \\[c-hungry-delete-forward]." + (interactive) + (let ((here (point))) + (c-skip-ws-backward) + (if (/= (point) here) + (delete-region (point) here) + (funcall c-backspace-function 1)))) + +(defun c-electric-delete-forward (arg) + "Delete the following character or whitespace. +If `c-hungry-delete-key' is non-nil, as evidenced by the \"/h\" or +\"/ah\" string on the mode line, then all following whitespace is +consumed. If however a prefix argument is supplied, or `c-hungry-delete-key' is nil, or point is inside a literal then the function in the variable `c-delete-function' is called." - (interactive "P") - (if (and (boundp 'delete-key-deletes-forward) - delete-key-deletes-forward) - (if (or (not c-hungry-delete-key) - arg - (c-in-literal)) - (funcall c-delete-function (prefix-numeric-value arg)) - (let ((here (point))) - (skip-chars-forward " \t\n") - (if (/= (point) here) - (delete-region (point) here) - (funcall c-delete-function 1)))) - ;; act just like c-electric-backspace + (interactive "*P") + (if (or (not c-hungry-delete-key) + arg + (c-in-literal)) + (funcall c-delete-function (prefix-numeric-value arg)) + (c-hungry-delete-forward))) + +(defun c-hungry-delete-forward () + "Delete the following character or all following whitespace +up to the next non-whitespace character. +See also \\[c-hungry-backspace]." + (interactive) + (let ((here (point))) + (c-skip-ws-forward) + (if (/= (point) here) + (delete-region (point) here) + (funcall c-delete-function 1)))) + +;; This function is only used in XEmacs. +(defun c-electric-delete (arg) + "Deletes preceding or following character or whitespace. +This function either deletes forward as `c-electric-delete-forward' or +backward as `c-electric-backspace', depending on the configuration: + +If the function `delete-forward-p' is defined (XEmacs 21) and returns +non-nil, it deletes forward. Else, if the variable +`delete-key-deletes-forward' is defined (XEmacs 20) and is set to +non-nil, it deletes forward. Otherwise it deletes backward. + +Note: This is the way in XEmacs 20 and later to choose the correct +action for the [delete] key, whichever key that means. In other +flavors this function isn't used, instead it's left to the user to +bind [delete] to either \\[c-electric-delete-forward] or \\[c-electric-backspace] as appropriate +\(the keymap `function-key-map' is useful for that). Emacs 21 handles +that automatically, though." + (interactive "*P") + (if (or (and (fboundp 'delete-forward-p) ;XEmacs 21 + (delete-forward-p)) + (and (boundp 'delete-key-deletes-forward) ;XEmacs 20 + delete-key-deletes-forward)) + (c-electric-delete-forward arg) (c-electric-backspace arg))) (defun c-electric-pound (arg) "Electric pound (`#') insertion. Inserts a `#' character specially depending on the variable `c-electric-pound-behavior'. If a numeric ARG is supplied, or if -point is inside a literal, nothing special happens." - (interactive "P") - (if (or (c-in-literal) - arg - (not (memq 'alignleft c-electric-pound-behavior))) +point is inside a literal or a macro, nothing special happens." + (interactive "*P") + (if (or arg + (not (memq 'alignleft c-electric-pound-behavior)) + (save-excursion + (skip-chars-backward " \t") + (not (bolp))) + (save-excursion + (and (= (forward-line -1) 0) + (progn (end-of-line) + (eq (char-before) ?\\)))) + (c-in-literal)) ;; do nothing special (self-insert-command (prefix-numeric-value arg)) ;; place the pound character at the left edge @@ -159,7 +405,7 @@ point is inside a literal, nothing special happens." (bolp (bolp))) (beginning-of-line) (delete-horizontal-space) - (insert-char last-command-char 1) + (insert last-command-char) (and (not bolp) (goto-char (- (point-max) pos))) ))) @@ -171,127 +417,176 @@ If the auto-newline feature is turned on, as evidenced by the \"/a\" or \"/ah\" string on the mode line, newlines are inserted before and after braces based on the value of `c-hanging-braces-alist'. -Also, the line is re-indented unless a numeric ARG is supplied, there -are non-whitespace characters present on the line after the brace, or -the brace is inserted inside a literal." - (interactive "P") - (let* ((c-state-cache (c-parse-state)) - (safepos (c-safe-position (point) c-state-cache)) - (literal (c-in-literal safepos))) - ;; if we're in a literal, or we're not at the end of the line, or - ;; a numeric arg is provided, or auto-newlining is turned off, - ;; then just insert the character. - (if (or literal arg -; (not c-auto-newline) - (not (looking-at "[ \t]*$"))) - (self-insert-command (prefix-numeric-value arg)) - (let* ((syms '(class-open class-close defun-open defun-close - inline-open inline-close brace-list-open brace-list-close - brace-list-intro brace-list-entry block-open block-close - substatement-open statement-case-open - extern-lang-open extern-lang-close)) - ;; we want to inhibit blinking the paren since this will - ;; be most disruptive. we'll blink it ourselves later on - (old-blink-paren blink-paren-function) - blink-paren-function - (insertion-point (point)) - delete-temp-newline - (preserve-p (and (not (bobp)) - (eq ?\ (char-syntax (char-before))))) - ;; shut this up too - (c-echo-syntactic-information-p nil) - (syntax (progn - ;; only insert a newline if there is - ;; non-whitespace behind us - (if (save-excursion - (skip-chars-backward " \t") - (not (bolp))) - (progn (newline) - (setq delete-temp-newline t))) - (self-insert-command (prefix-numeric-value arg)) - ;; state cache doesn't change - (c-guess-basic-syntax))) - (newlines (and - c-auto-newline - (or (c-lookup-lists syms syntax c-hanging-braces-alist) - '(ignore before after))))) - ;; If syntax is a function symbol, then call it using the - ;; defined semantics. - (if (and (not (consp (cdr newlines))) - (functionp (cdr newlines))) - (let ((c-syntactic-context syntax)) +Also, the line is re-indented unless a numeric ARG is supplied, the +brace is inserted inside a literal, or `c-syntactic-indentation' is +nil. + +This function does various newline cleanups based on the value of +`c-cleanup-list'." + (interactive "*P") + (let* ((safepos (c-safe-position (point) (c-parse-state))) + (literal (c-in-literal safepos)) + ;; We want to inhibit blinking the paren since this will be + ;; most disruptive. We'll blink it ourselves later on. + (old-blink-paren blink-paren-function) + blink-paren-function) + (cond + ((or literal arg) + (self-insert-command (prefix-numeric-value arg))) + ((not (looking-at "[ \t]*\\\\?$")) + (self-insert-command (prefix-numeric-value arg)) + (if c-syntactic-indentation + (indent-according-to-mode))) + (t + (let* ((syms + ;; 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 + inline-open inline-close + brace-list-open brace-list-close + brace-list-intro brace-entry-open + block-open block-close + substatement-open statement-case-open + extern-lang-open extern-lang-close + namespace-open namespace-close + module-open module-close + composition-open composition-close + inexpr-class-open inexpr-class-close + ;; `statement-cont' is here for the case with a brace + ;; list opener inside a statement. C.f. CASE B.2 in + ;; `c-guess-continued-construct'. + statement-cont)) + (insertion-point (point)) + (preserve-p (and (not (bobp)) + (eq ?\ (char-syntax (char-before))))) + ;; shut this up too + (c-echo-syntactic-information-p nil) + delete-temp-newline syntax newlines) + ;; only insert a newline if there is non-whitespace behind us + (when (save-excursion + (skip-chars-backward " \t") + (not (bolp))) + (c-newline-and-indent) + ;; Set markers around the newline and indention inserted + ;; above. We insert the start marker here and not before + ;; the call to kludge around a misfeature in expand-abbrev: + ;; If the line contains e.g. "else" then expand-abbrev will + ;; be called when c-newline-and-indent inserts the newline. + ;; That function first removes the abbrev "else" and then + ;; inserts the expansion, which is an identical "else" in + ;; this case. So the marker that we put after "else" would + ;; end up before it. + (setq delete-temp-newline + (cons (save-excursion + (end-of-line 0) + (if (eq (char-before) ?\\) + ;; Ignore a line continuation. + (backward-char)) + (skip-chars-backward " \t") + (copy-marker (point) t)) + (point-marker)))) + (unwind-protect + (progn + (if (eq last-command-char ?{) + (setq c-state-cache (cons (point) c-state-cache))) + (self-insert-command (prefix-numeric-value arg)) + (c-save-buffer-state ((c-syntactic-indentation-in-macros t) + (c-auto-newline-analysis t)) + ;; Turn on syntactic macro analysis to help with auto + ;; newlines only. + (setq syntax (c-guess-basic-syntax))) (setq newlines - (funcall (cdr newlines) (car newlines) insertion-point)))) - ;; does a newline go before the open brace? - (if (memq 'before newlines) - ;; we leave the newline we've put in there before, - ;; but we need to re-indent the line above - (let ((pos (- (point-max) (point))) - (here (point)) - (c-state-cache c-state-cache)) - (forward-line -1) - ;; we may need to update the cache. this should still be - ;; faster than recalculating the state in many cases - (save-excursion - (save-restriction - (narrow-to-region here (point)) - (if (and (c-safe (progn (backward-up-list -1) t)) - (memq (char-before) '(?\) ?})) - (progn (widen) - (c-safe (progn (forward-sexp -1) t)))) - (setq c-state-cache - (c-hack-state (point) 'open c-state-cache)) - (if (and (car c-state-cache) - (not (consp (car c-state-cache))) - (<= (point) (car c-state-cache))) - (setq c-state-cache (cdr c-state-cache)) - )))) - (let ((here (point)) - (shift (c-indent-line))) - (setq c-state-cache (c-adjust-state (c-point 'bol) here - (- shift) c-state-cache))) - (goto-char (- (point-max) pos)) - ;; if the buffer has changed due to the indentation, we - ;; need to recalculate syntax for the current line, but - ;; we won't need to update the state cache. - (if (/= (point) here) - (setq syntax (c-guess-basic-syntax)))) + (and + c-auto-newline + (or (c-lookup-lists + syms + ;; Substitute inexpr-class and class-open or + ;; class-close with inexpr-class-open or + ;; inexpr-class-close. + (if (assq 'inexpr-class syntax) + (cond ((assq 'class-open syntax) + '((inexpr-class-open))) + ((assq 'class-close syntax) + '((inexpr-class-close))) + (t syntax)) + syntax) + c-hanging-braces-alist) + '(ignore before after)))) + ;; Do not try to insert newlines around a special + ;; (Pike-style) brace list. + (if (and c-special-brace-lists + (save-excursion + (c-save-buffer-state nil + (c-safe (if (= (char-before) ?{) + (forward-char -1) + (c-forward-sexp -1)) + (c-looking-at-special-brace-list))))) + (setq newlines nil)) + ;; If syntax is a function symbol, then call it using the + ;; defined semantics. + (if (and (not (consp (cdr newlines))) + (functionp (cdr newlines))) + (let ((c-syntactic-context syntax)) + (setq newlines + (funcall (cdr newlines) + (car newlines) + insertion-point)))) + ;; does a newline go before the open brace? + (when (memq 'before newlines) + ;; we leave the newline we've put in there before, + ;; but we need to re-indent the line above + (when delete-temp-newline + (set-marker (car delete-temp-newline) nil) + (set-marker (cdr delete-temp-newline) nil) + (setq delete-temp-newline nil)) + (when c-syntactic-indentation + (let ((pos (- (point-max) (point))) + (here (point))) + (forward-line -1) + (indent-according-to-mode) + (goto-char (- (point-max) pos)) + ;; if the buffer has changed due to the + ;; indentation, we need to recalculate syntax for + ;; the current line. + (if (/= (point) here) + (c-save-buffer-state + ((c-syntactic-indentation-in-macros t) + (c-auto-newline-analysis t)) + ;; Turn on syntactic macro analysis to help + ;; with auto newlines only. + (setq syntax (c-guess-basic-syntax)))))))) ;; must remove the newline we just stuck in (if we really did it) - (and delete-temp-newline - (save-excursion - ;; if there is whitespace before point, then preserve - ;; at least one space. - (delete-indentation) - (just-one-space) - (if (not preserve-p) - (delete-char -1)))) - ;; since we're hanging the brace, we need to recalculate - ;; syntax. Update the state to accurately reflect the - ;; beginning of the line. We punt if we cross any open or - ;; closed parens because its just too hard to modify the - ;; known state. This limitation will be fixed in v5. - (save-excursion - (let ((bol (c-point 'bol))) - (if (zerop (car (parse-partial-sexp bol (1- (point))))) - (setq c-state-cache (c-whack-state bol c-state-cache) - syntax (c-guess-basic-syntax)) - ;; gotta punt. this requires some horrible kludgery - (beginning-of-line) - (makunbound 'c-state-cache) - (setq c-state-cache (c-parse-state) - syntax nil)))) - ) - ;; now adjust the line's indentation. don't update the state - ;; cache since c-guess-basic-syntax isn't called when the - ;; syntax is passed to c-indent-line - (let ((here (point)) - (shift (c-indent-line syntax))) - (setq c-state-cache (c-adjust-state (c-point 'bol) here - (- shift) c-state-cache))) + (when delete-temp-newline + (save-excursion + (delete-region (car delete-temp-newline) + (cdr delete-temp-newline)) + (goto-char (car delete-temp-newline)) + (set-marker (car delete-temp-newline) nil) + (set-marker (cdr delete-temp-newline) nil) + ;; if there is whitespace before point, then preserve + ;; at least one space. + (just-one-space) + (if (not preserve-p) + (delete-char -1))))) + (if (not (memq 'before newlines)) + ;; since we're hanging the brace, we need to recalculate + ;; syntax. + (c-save-buffer-state ((c-syntactic-indentation-in-macros t) + (c-auto-newline-analysis t)) + ;; Turn on syntactic macro analysis to help with auto + ;; newlines only. + (setq syntax (c-guess-basic-syntax)))) + (when c-syntactic-indentation + ;; Now adjust the line's indentation. Don't update the state + ;; cache since c-guess-basic-syntax isn't called when + ;; c-syntactic-context is set. + (let* ((c-syntactic-context syntax)) + (indent-according-to-mode))) ;; Do all appropriate clean ups (let ((here (point)) (pos (- (point-max) (point))) - mbeg mend) + mbeg mend tmp) ;; clean up empty defun braces (if (and c-auto-newline (memq 'empty-defun-braces c-cleanup-list) @@ -300,59 +595,67 @@ the brace is inserted inside a literal." syntax) (progn (forward-char -1) - (skip-chars-backward " \t\n") + (c-skip-ws-backward) (eq (char-before) ?\{)) ;; make sure matching open brace isn't in a comment (not (c-in-literal))) (delete-region (point) (1- here))) - ;; clean up brace-else-brace - (if (and c-auto-newline - (memq 'brace-else-brace c-cleanup-list) - (eq last-command-char ?\{) - (re-search-backward "}[ \t\n]*else[ \t\n]*{" nil t) + ;; clean up brace-else-brace and brace-elseif-brace + (when (and c-auto-newline + (eq last-command-char ?\{)) + (cond + ((and (memq 'brace-else-brace c-cleanup-list) + (re-search-backward + (concat "}" + "\\([ \t\n]\\|\\\\\n\\)*" + "else" + "\\([ \t\n]\\|\\\\\n\\)*" + "{") + nil t) (progn (setq mbeg (match-beginning 0) mend (match-end 0)) - (= mend here)) - (not (c-in-literal))) - (progn - (delete-region mbeg mend) - (insert "} else {"))) - ;; clean up brace-elseif-brace - (if (and c-auto-newline - (memq 'brace-elseif-brace c-cleanup-list) - (eq last-command-char ?\{) - (re-search-backward "}[ \t\n]*else[ \t\n]+if[ \t\n]*" nil t) - (save-excursion - (goto-char (match-end 0)) - (c-safe (forward-sexp 1)) - (skip-chars-forward " \t\n") - (setq mbeg (match-beginning 0) - mend (match-end 0)) - (= here (1+ (point)))) - (not (c-in-literal))) - (progn - (delete-region mbeg mend) - (insert "} else if "))) + (eq (match-end 0) here))) + (delete-region mbeg mend) + (insert-and-inherit "} else {")) + ((and (memq 'brace-elseif-brace c-cleanup-list) + (progn + (goto-char (1- here)) + (setq mend (point)) + (c-skip-ws-backward) + (setq mbeg (point)) + (eq (char-before) ?\))) + (zerop (c-save-buffer-state nil (c-backward-token-2 1 t))) + (eq (char-after) ?\() + (progn + (setq tmp (point)) + (re-search-backward + (concat "}" + "\\([ \t\n]\\|\\\\\n\\)*" + "else" + "\\([ \t\n]\\|\\\\\n\\)+" + "if" + "\\([ \t\n]\\|\\\\\n\\)*") + nil t)) + (eq (match-end 0) tmp)) + (delete-region mbeg mend) + (goto-char mbeg) + (insert ?\ )))) (goto-char (- (point-max) pos)) ) ;; does a newline go after the brace? (if (memq 'after newlines) - (progn - (newline) - ;; update on c-state-cache - (let* ((bufpos (- (point) 2)) - (which (if (eq (char-after bufpos) ?{) 'open 'close)) - (c-state-cache (c-hack-state bufpos which c-state-cache))) - (c-indent-line)))) - ;; blink the paren - (and (eq last-command-char ?\}) - old-blink-paren - (save-excursion - (c-backward-syntactic-ws safepos) - (funcall old-blink-paren))) - )))) - + (c-newline-and-indent)) + ))) + ;; blink the paren + (and (eq last-command-char ?\}) + (not executing-kbd-macro) + old-blink-paren + (save-excursion + (c-save-buffer-state nil + (c-backward-syntactic-ws safepos)) + (funcall old-blink-paren))))) + (defun c-electric-slash (arg) "Insert a slash character. @@ -364,35 +667,38 @@ Indent the line as a comment, if: 2. The slash is part of a `*/' token that closes a block oriented comment. -If numeric ARG is supplied or point is inside a literal, indentation -is inhibited." - (interactive "P") +If a numeric ARG is supplied, point is inside a literal, or +`c-syntactic-indentation' is nil, indentation is inhibited." + (interactive "*P") (let* ((ch (char-before)) - (indentp (and (not arg) + (literal (c-in-literal)) + (indentp (and c-syntactic-indentation + (not arg) (eq last-command-char ?/) (or (and (eq ch ?/) - (not (c-in-literal))) + (not literal)) (and (eq ch ?*) - (c-in-literal))) + literal)) )) ;; shut this up (c-echo-syntactic-information-p nil)) (self-insert-command (prefix-numeric-value arg)) (if indentp - (c-indent-line)))) + (indent-according-to-mode)))) (defun c-electric-star (arg) "Insert a star character. If the star is the second character of a C style comment introducing construct, and we are on a comment-only-line, indent line as comment. -If numeric ARG is supplied or point is inside a literal, indentation -is inhibited." - (interactive "P") +If a numeric ARG is supplied, point is inside a literal, or +`c-syntactic-indentation' is nil, indentation is inhibited." + (interactive "*P") (self-insert-command (prefix-numeric-value arg)) ;; if we are in a literal, or if arg is given do not re-indent the ;; current line, unless this star introduces a comment-only line. - (if (and (not arg) - (memq (c-in-literal) '(c)) + (if (and c-syntactic-indentation + (not arg) + (eq (c-in-literal) 'c) (eq (char-before) ?*) (save-excursion (forward-char -1) @@ -401,9 +707,8 @@ is inhibited." (forward-char -1)) (skip-chars-backward " \t") (bolp))) - ;; shut this up - (let (c-echo-syntactic-information-p) - (c-indent-line)) + (let (c-echo-syntactic-information-p) ; shut this up + (indent-according-to-mode)) )) (defun c-electric-semi&comma (arg) @@ -413,24 +718,28 @@ or \"/ah\" string on the mode line, a newline might be inserted. See the variable `c-hanging-semi&comma-criteria' for how newline insertion is determined. -When semicolon is inserted, the line is re-indented unless a numeric -arg is supplied, point is inside a literal, or there are -non-whitespace characters on the line following the semicolon." - (interactive "P") +When a semicolon is inserted, the line is re-indented unless a numeric +arg is supplied, point is inside a literal, or +`c-syntactic-indentation' is nil. + +Based on the value of `c-cleanup-list', this function cleans up commas +following brace lists and semicolons following defuns." + (interactive "*P") (let* ((lim (c-most-enclosing-brace (c-parse-state))) (literal (c-in-literal lim)) (here (point)) ;; shut this up (c-echo-syntactic-information-p nil)) - (if (or literal - arg - (not (looking-at "[ \t]*$"))) + (if (or literal arg) (self-insert-command (prefix-numeric-value arg)) ;; do some special stuff with the character (self-insert-command (prefix-numeric-value arg)) - ;; do all cleanups, reindentations, and newline insertions, but - ;; only if c-auto-newline is turned on - (if (not c-auto-newline) nil + ;; do all cleanups and newline insertions if c-auto-newline is + ;; turned on + (if (or (not c-auto-newline) + (not (looking-at "[ \t]*\\\\?$"))) + (if c-syntactic-indentation + (indent-according-to-mode)) ;; clean ups (let ((pos (- (point-max) (point)))) (if (and (or (and @@ -441,14 +750,15 @@ non-whitespace characters on the line following the semicolon." (memq 'defun-close-semi c-cleanup-list))) (progn (forward-char -1) - (skip-chars-backward " \t\n") + (c-skip-ws-backward) (eq (char-before) ?})) ;; make sure matching open brace isn't in a comment (not (c-in-literal lim))) (delete-region (point) here)) (goto-char (- (point-max) pos))) ;; re-indent line - (c-indent-line) + (if c-syntactic-indentation + (indent-according-to-mode)) ;; check to see if a newline should be added (let ((criteria c-hanging-semi&comma-criteria) answer add-newline-p) @@ -462,8 +772,7 @@ non-whitespace characters on the line following the semicolon." (setq add-newline-p (not (eq answer 'stop))) )) (if add-newline-p - (progn (newline) - (c-indent-line))) + (c-newline-and-indent)) ))))) (defun c-electric-colon (arg) @@ -473,22 +782,26 @@ If the auto-newline feature is turned on, as evidenced by the \"/a\" or \"/ah\" string on the mode line, newlines are inserted before and after colons based on the value of `c-hanging-colons-alist'. -Also, the line is re-indented unless a numeric ARG is supplied, there -are non-whitespace characters present on the line after the colon, or -the colon is inserted inside a literal. +Also, the line is re-indented unless a numeric ARG is supplied, the +colon is inserted inside a literal, or `c-syntactic-indentation' is +nil. This function cleans up double colon scope operators based on the value of `c-cleanup-list'." - (interactive "P") + (interactive "*P") (let* ((bod (c-point 'bod)) (literal (c-in-literal bod)) - syntax newlines + newlines is-scope-op ;; shut this up (c-echo-syntactic-information-p nil)) - (if (or literal - arg - (not (looking-at "[ \t]*$"))) - (self-insert-command (prefix-numeric-value arg)) + (cond + ((or literal arg) + (self-insert-command (prefix-numeric-value arg))) + ((not (looking-at "[ \t]*\\\\?$")) + (self-insert-command (prefix-numeric-value arg)) + (if c-syntactic-indentation + (indent-according-to-mode))) + (t ;; insert the colon, then do any specified cleanups (self-insert-command (prefix-numeric-value arg)) (let ((pos (- (point-max) (point))) @@ -498,82 +811,227 @@ value of `c-cleanup-list'." (eq (char-before) ?:) (progn (forward-char -1) - (skip-chars-backward " \t\n") + (c-skip-ws-backward) (eq (char-before) ?:)) (not (c-in-literal)) (not (eq (char-after (- (point) 2)) ?:))) - (delete-region (point) (1- here))) + (progn + (delete-region (point) (1- here)) + (setq is-scope-op t))) (goto-char (- (point-max) pos))) - ;; lets do some special stuff with the colon character - (setq syntax (c-guess-basic-syntax) - ;; some language elements can only be determined by - ;; checking the following line. Lets first look for ones - ;; that can be found when looking on the line with the - ;; colon - newlines - (and c-auto-newline - (or (c-lookup-lists '(case-label label access-label) - syntax c-hanging-colons-alist) - (c-lookup-lists '(member-init-intro inher-intro) - (prog2 - (insert "\n") - (c-guess-basic-syntax) - (delete-char -1)) - c-hanging-colons-alist)))) - ;; indent the current line - (c-indent-line syntax) + ;; indent the current line if it's done syntactically. + (if c-syntactic-indentation + ;; Cannot use the same syntax analysis as we find below, + ;; since that's made with c-syntactic-indentation-in-macros + ;; always set to t. + (indent-according-to-mode)) + (c-save-buffer-state + ((c-syntactic-indentation-in-macros t) + (c-auto-newline-analysis t) + ;; Turn on syntactic macro analysis to help with auto newlines + ;; only. + (syntax (c-guess-basic-syntax)) + (elem syntax)) + ;; Translate substatement-label to label for this operation. + (while elem + (if (eq (car (car elem)) 'substatement-label) + (setcar (car elem) 'label)) + (setq elem (cdr elem))) + ;; some language elements can only be determined by checking + ;; the following line. Lets first look for ones that can be + ;; found when looking on the line with the colon + (setq newlines + (and c-auto-newline + (or (c-lookup-lists '(case-label label access-label) + syntax c-hanging-colons-alist) + (c-lookup-lists '(member-init-intro inher-intro) + (progn + (insert ?\n) + (unwind-protect + (c-guess-basic-syntax) + (delete-char -1))) + c-hanging-colons-alist))))) ;; does a newline go before the colon? Watch out for already ;; non-hung colons. However, we don't unhang them because that ;; would be a cleanup (and anti-social). (if (and (memq 'before newlines) + (not is-scope-op) (save-excursion (skip-chars-backward ": \t") (not (bolp)))) (let ((pos (- (point-max) (point)))) (forward-char -1) - (newline) - (c-indent-line) + (c-newline-and-indent) (goto-char (- (point-max) pos)))) ;; does a newline go after the colon? - (if (memq 'after (cdr-safe newlines)) - (progn - (newline) - (c-indent-line))) - ))) + (if (and (memq 'after (cdr-safe newlines)) + (not is-scope-op)) + (c-newline-and-indent)) + )))) (defun c-electric-lt-gt (arg) "Insert a less-than, or greater-than character. -When the auto-newline feature is turned on, as evidenced by the \"/a\" -or \"/ah\" string on the mode line, the line will be re-indented if -the character inserted is the second of a C++ style stream operator -and the buffer is in C++ mode. - -The line will also not be re-indented if a numeric argument is -supplied, or point is inside a literal." - (interactive "P") - (let ((indentp (and (not arg) +The line will be re-indented if the character inserted is the second +of a C++ style stream operator and the buffer is in C++ mode. +Exceptions are when a numeric argument is supplied, point is inside a +literal, or `c-syntactic-indentation' is nil, in which case the line +will not be re-indented." + (interactive "*P") + (let ((indentp (and c-syntactic-indentation + (not arg) (eq (char-before) last-command-char) (not (c-in-literal)))) ;; shut this up (c-echo-syntactic-information-p nil)) (self-insert-command (prefix-numeric-value arg)) (if indentp - (c-indent-line)))) + (indent-according-to-mode)))) +(defun c-electric-paren (arg) + "Insert a parenthesis. + +Some newline cleanups are done if appropriate; see the variable +`c-cleanup-list'. + +Also, the line is re-indented unless a numeric ARG is supplied, the +parenthesis is inserted inside a literal, or `c-syntactic-indentation' +is nil." + (interactive "*P") + (let ((literal (c-in-literal (c-point 'bod))) + ;; shut this up + (c-echo-syntactic-information-p nil)) + (if (or arg literal) + (self-insert-command (prefix-numeric-value arg)) + ;; do some special stuff with the character + (let* (;; We want to inhibit blinking the paren since this will + ;; be most disruptive. We'll blink it ourselves + ;; afterwards. + (old-blink-paren blink-paren-function) + blink-paren-function) + (self-insert-command (prefix-numeric-value arg)) + (if c-syntactic-indentation + (indent-according-to-mode)) + (when (looking-at "[ \t]*\\\\?$") + (when c-auto-newline + ;; Do all appropriate clean ups + (let ((here (point)) + (pos (- (point-max) (point))) + mbeg mend) + ;; clean up brace-elseif-brace + (if (and (memq 'brace-elseif-brace c-cleanup-list) + (eq last-command-char ?\() + (re-search-backward + (concat "}" + "\\([ \t\n]\\|\\\\\n\\)*" + "else" + "\\([ \t\n]\\|\\\\\n\\)+" + "if" + "\\([ \t\n]\\|\\\\\n\\)*" + "(") + nil t) + (save-excursion + (setq mbeg (match-beginning 0) + mend (match-end 0)) + (= mend here)) + (not (c-in-literal))) + (progn + (delete-region mbeg mend) + (insert-and-inherit "} else if (")) + ;; clean up brace-catch-brace + (goto-char here) + (if (and (memq 'brace-catch-brace c-cleanup-list) + (eq last-command-char ?\() + (re-search-backward + (concat "}" + "\\([ \t\n]\\|\\\\\n\\)*" + "catch" + "\\([ \t\n]\\|\\\\\n\\)*" + "(") + nil t) + (save-excursion + (setq mbeg (match-beginning 0) + mend (match-end 0)) + (= mend here)) + (not (c-in-literal))) + (progn + (delete-region mbeg mend) + (insert-and-inherit "} catch (")))) + (goto-char (- (point-max) pos)) + ))) + (let (beg (end (1- (point)))) + (cond ((and (memq 'space-before-funcall c-cleanup-list) + (eq last-command-char ?\() + (save-excursion + (backward-char) + (skip-chars-backward " \t") + (setq beg (point)) + (c-on-identifier))) + (save-excursion + (delete-region beg end) + (goto-char beg) + (insert ?\ ))) + ((and (memq 'compact-empty-funcall c-cleanup-list) + (eq last-command-char ?\)) + (save-excursion + (c-safe (backward-char 2)) + (when (looking-at "()") + (setq end (point)) + (skip-chars-backward " \t") + (setq beg (point)) + (c-on-identifier)))) + (delete-region beg end)))) + (and (not executing-kbd-macro) + old-blink-paren + (funcall old-blink-paren)))))) + +(defun c-electric-continued-statement () + "Reindent the current line if appropriate. + +This function is used to reindent the line after a keyword which +continues an earlier statement is typed, e.g. an \"else\" or the +\"while\" in a do-while block. + +The line is reindented if there is nothing but whitespace before the +keyword on the line, the keyword is not inserted inside a literal, and +`c-syntactic-indentation' is non-nil." + (let (;; shut this up + (c-echo-syntactic-information-p nil)) + (when (and c-syntactic-indentation + (not (eq last-command-char ?_)) + (= (save-excursion + (skip-syntax-backward "w") + (point)) + (c-point 'boi)) + (not (c-in-literal (c-point 'bod)))) + ;; Have to temporarily insert a space so that + ;; c-guess-basic-syntax recognizes the keyword. Follow the + ;; space with a nonspace to avoid messing up any whitespace + ;; sensitive meddling that might be done, e.g. by + ;; `c-backslash-region'. + (insert-and-inherit " x") + (unwind-protect + (indent-according-to-mode) + (delete-char -2))))) ;; better movement routines for ThisStyleOfVariablesCommonInCPlusPlus ;; originally contributed by Terry_Glanfield.Southern@rxuk.xerox.com (defun c-forward-into-nomenclature (&optional arg) "Move forward to end of a nomenclature section or word. -With arg, to it arg times." +With arg, do it arg times." (interactive "p") (let ((case-fold-search nil)) (if (> arg 0) - (re-search-forward "\\W*\\([A-Z]*[a-z0-9]*\\)" (point-max) t arg) + (re-search-forward + (cc-eval-when-compile + (concat "\\W*\\([" c-upper "]*[" c-lower c-digit "]*\\)")) + (point-max) t arg) (while (and (< arg 0) (re-search-backward - "\\(\\(\\W\\|[a-z0-9]\\)[A-Z]+\\|\\W\\w+\\)" + (cc-eval-when-compile + (concat + "\\(\\(\\W\\|[" c-lower c-digit "]\\)[" c-upper "]+" + "\\|\\W\\w+\\)")) (point-min) 0)) (forward-char 1) (setq arg (1+ arg))))) @@ -590,67 +1048,662 @@ forward." (defun c-scope-operator () "Insert a double colon scope operator at point. No indentation or other \"electric\" behavior is performed." + (interactive "*") + (insert-and-inherit "::")) + +(defun c-beginning-of-defun (&optional arg) + "Move backward to the beginning of a defun. +Every top level declaration that contains a brace paren block is +considered to be a defun. + +With a positive argument, move backward that many defuns. A negative +argument -N means move forward to the Nth following beginning. Return +t unless search stops due to beginning or end of buffer. + +Unlike the built-in `beginning-of-defun' this tries to be smarter +about finding the char with open-parenthesis syntax that starts the +defun." + + (interactive "p") + (or arg (setq arg 1)) + + (if (< arg 0) + (when (c-end-of-defun (- arg)) + (c-save-buffer-state nil (c-forward-syntactic-ws)) + t) + + (c-save-buffer-state (paren-state lim pos) + (catch 'exit + (while (> arg 0) + ;; Note: Partial code duplication in `c-end-of-defun' and + ;; `c-declaration-limits'. + + (setq paren-state (c-parse-state)) + (unless (c-safe + (goto-char (c-least-enclosing-brace paren-state)) + ;; If we moved to the outermost enclosing paren + ;; then we can use c-safe-position to set the + ;; limit. Can't do that otherwise since the + ;; earlier paren pair on paren-state might very + ;; well be part of the declaration we should go + ;; to. + (setq lim (c-safe-position (point) paren-state)) + t) + ;; At top level. Make sure we aren't inside a literal. + (setq pos (c-literal-limits + (c-safe-position (point) paren-state))) + (if pos (goto-char (car pos)))) + + (while (let ((start (point))) + (c-beginning-of-decl-1 lim) + (if (= (point) start) + ;; Didn't move. Might be due to bob or unbalanced + ;; parens. Try to continue if it's the latter. + (unless (c-safe (goto-char + (c-down-list-backward (point)))) + ;; Didn't work, so it's bob then. + (goto-char (point-min)) + (throw 'exit nil))) + + (save-excursion + ;; Check if the declaration contains a brace + ;; block. If not, we try another one. + (setq pos (point)) + (not (and (c-syntactic-re-search-forward "[;{]" nil t t) + (or (eq (char-before) ?{) + (and c-recognize-knr-p + ;; Might have stopped on the + ;; ';' in a K&R argdecl. In + ;; that case the declaration + ;; should contain a block. + (c-in-knr-argdecl pos))))))) + (setq lim nil)) + + ;; Check if `c-beginning-of-decl-1' put us after the block + ;; in a declaration that doesn't end there. We're searching + ;; back and forth over the block here, which can be + ;; expensive. + (setq pos (point)) + (if (and c-opt-block-decls-with-vars-key + (progn + (c-backward-syntactic-ws) + (eq (char-before) ?})) + (eq (car (c-beginning-of-decl-1)) + 'previous) + (save-excursion + (c-end-of-decl-1) + (> (point) pos))) + nil + (goto-char pos)) + + (setq pos (point)) + ;; Try to be line oriented; position point at the closest + ;; preceding boi that isn't inside a comment, but if we hit + ;; the previous declaration then we use the current point + ;; instead. + (while (and (/= (point) (c-point 'boi)) + (c-backward-single-comment))) + (if (/= (point) (c-point 'boi)) + (goto-char pos)) + + (setq arg (1- arg))))) + (c-keep-region-active) + (= arg 0))) + +(defun c-end-of-defun (&optional arg) + "Move forward to the end of a top level declaration. +With argument, do it that many times. Negative argument -N means move +back to Nth preceding end. Returns t unless search stops due to +beginning or end of buffer. + +An end of a defun occurs right after the close-parenthesis that matches +the open-parenthesis that starts a defun; see `beginning-of-defun'." + + (interactive "p") + (or arg (setq arg 1)) + + (if (< arg 0) + (when (c-beginning-of-defun (- arg)) + (c-save-buffer-state nil (c-backward-syntactic-ws)) + t) + + (c-save-buffer-state (paren-state lim pos) + (catch 'exit + (while (> arg 0) + ;; Note: Partial code duplication in `c-beginning-of-defun' + ;; and `c-declaration-limits'. + + (setq paren-state (c-parse-state)) + (unless (c-safe + (goto-char (c-least-enclosing-brace paren-state)) + ;; If we moved to the outermost enclosing paren + ;; then we can use c-safe-position to set the + ;; limit. Can't do that otherwise since the + ;; earlier paren pair on paren-state might very + ;; well be part of the declaration we should go + ;; to. + (setq lim (c-safe-position (point) paren-state)) + t) + ;; At top level. Make sure we aren't inside a literal. + (setq pos (car-safe (c-literal-limits + (c-safe-position (point) paren-state)))) + (if pos (goto-char pos))) + + ;; Have to move to the start first so that `c-end-of-decl-1' + ;; has the correct start position. + (setq pos (point)) + (when (memq (car (c-beginning-of-decl-1 lim)) + '(previous macro)) + ;; We moved back over the previous defun or a macro. Move + ;; to the next token; it's the start of the next + ;; declaration. We can also be directly after the block + ;; in a `c-opt-block-decls-with-vars-key' declaration, but + ;; then we won't move significantly far here. + (goto-char pos) + (c-forward-token-2 0)) + + (while (let ((start (point))) + (c-end-of-decl-1) + (if (= (point) start) + ;; Didn't move. Might be due to eob or unbalanced + ;; parens. Try to continue if it's the latter. + (if (c-safe (goto-char (c-up-list-forward (point)))) + t + ;; Didn't work, so it's eob then. + (goto-char (point-max)) + (throw 'exit nil)) + + (save-excursion + ;; Check if the declaration contains a brace + ;; block. If not, we try another one. + (setq pos (point)) + (goto-char start) + (not (c-syntactic-re-search-forward "{" pos t t)))))) + + (setq pos (point)) + ;; Try to be line oriented; position point after the next + ;; newline that isn't inside a comment, but if we hit the + ;; next declaration then we use the current point instead. + (while (and (not (bolp)) + (not (looking-at "\\s *$")) + (c-forward-single-comment))) + (cond ((bolp)) + ((looking-at "\\s *$") + (forward-line 1)) + (t + (goto-char pos))) + + (setq arg (1- arg))))) + (c-keep-region-active) + (= arg 0))) + +(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 + ;; nil is returned, unless NEAR is non-nil in which case the closest + ;; following one is chosen instead (if there is any). The end + ;; position is at the next line, providing there is one before the + ;; declaration. + (save-excursion + + ;; Note: Some code duplication in `c-beginning-of-defun' and + ;; `c-end-of-defun'. + (catch 'exit + (let ((start (point)) + (paren-state (c-parse-state)) + lim pos end-pos) + (unless (c-safe + (goto-char (c-least-enclosing-brace paren-state)) + ;; If we moved to the outermost enclosing paren then we + ;; can use c-safe-position to set the limit. Can't do + ;; that otherwise since the earlier paren pair on + ;; paren-state might very well be part of the + ;; declaration we should go to. + (setq lim (c-safe-position (point) paren-state)) + t) + ;; At top level. Make sure we aren't inside a literal. + (setq pos (c-literal-limits + (c-safe-position (point) paren-state))) + (if pos (goto-char (car pos)))) + + (when (c-beginning-of-macro) + (throw 'exit + (cons (point) + (save-excursion + (c-end-of-macro) + (forward-line 1) + (point))))) + + (setq pos (point)) + (when (or (eq (car (c-beginning-of-decl-1 lim)) 'previous) + (= pos (point))) + ;; We moved back over the previous defun. Skip to the next + ;; one. Not using c-forward-syntactic-ws here since we + ;; should not skip a macro. We can also be directly after + ;; the block in a `c-opt-block-decls-with-vars-key' + ;; declaration, but then we won't move significantly far + ;; here. + (goto-char pos) + (c-forward-comments) + + (when (and near (c-beginning-of-macro)) + (throw 'exit + (cons (point) + (save-excursion + (c-end-of-macro) + (forward-line 1) + (point)))))) + + (if (eobp) (throw 'exit nil)) + + ;; Check if `c-beginning-of-decl-1' put us after the block in a + ;; declaration that doesn't end there. We're searching back and + ;; forth over the block here, which can be expensive. + (setq pos (point)) + (if (and c-opt-block-decls-with-vars-key + (progn + (c-backward-syntactic-ws) + (eq (char-before) ?})) + (eq (car (c-beginning-of-decl-1)) + 'previous) + (save-excursion + (c-end-of-decl-1) + (and (> (point) pos) + (setq end-pos (point))))) + nil + (goto-char pos)) + + (if (and (not near) (> (point) start)) + nil + + ;; Try to be line oriented; position the limits at the + ;; closest preceding boi, and after the next newline, that + ;; isn't inside a comment, but if we hit a neighboring + ;; declaration then we instead use the exact declaration + ;; limit in that direction. + (cons (progn + (setq pos (point)) + (while (and (/= (point) (c-point 'boi)) + (c-backward-single-comment))) + (if (/= (point) (c-point 'boi)) + pos + (point))) + (progn + (if end-pos + (goto-char end-pos) + (c-end-of-decl-1)) + (setq pos (point)) + (while (and (not (bolp)) + (not (looking-at "\\s *$")) + (c-forward-single-comment))) + (cond ((bolp) + (point)) + ((looking-at "\\s *$") + (forward-line 1) + (point)) + (t + pos))))) + )))) + +(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. + +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) - (insert "::")) + + (let (decl-limits) + (c-save-buffer-state nil + ;; We try to be line oriented, unless there are several + ;; declarations on the same line. + (if (looking-at c-syntactic-eol) + (c-backward-token-2 1 nil (c-point 'bol))) + (setq decl-limits (c-declaration-limits t))) + + (if (not decl-limits) + (error "Cannot find any declaration") + (goto-char (car decl-limits)) + (push-mark (cdr decl-limits) nil t)))) (defun c-beginning-of-statement (&optional count lim sentence-flag) "Go to the beginning of the innermost C statement. With prefix arg, go back N - 1 statements. If already at the -beginning of a statement then go to the beginning of the preceding -one. If within a string or comment, or next to a comment (only -whitespace between), move by sentences instead of statements. +beginning of a statement then go to the beginning of the closest +preceding one, moving into nested blocks if necessary (use +\\[backward-sexp] to skip over a block). If within or next to a +comment or multiline string, move by sentences instead of statements. When called from a program, this function takes 3 optional args: the repetition count, a buffer position limit which is the farthest back -to search, and a flag saying whether to do sentence motion when in a -comment." +to search for the syntactic context, and a flag saying whether to do +sentence motion in or near comments and multiline strings. + +Note that `c-beginning-of-statement-1' is usually better to use from +programs. It has much more well defined semantics than this one, +which is intended for interactive use and might therefore change to be +more \"DWIM:ey\"." (interactive (list (prefix-numeric-value current-prefix-arg) nil t)) - (let ((here (point)) - (count (or count 1)) - (lim (or lim (c-point 'bod))) - state) - (save-excursion - (goto-char lim) - (setq state (parse-partial-sexp (point) here nil nil))) - (if (and sentence-flag - (or (nth 3 state) - (nth 4 state) - ;; skipping forward into a comment? - (and (> 0 count) - (save-excursion - (skip-chars-forward " \t\n") - (or (eobp) - (looking-at comment-start-skip)))) - (and (< 0 count) - (save-excursion - (skip-chars-backward " \t\n") - (goto-char (- (point) 2)) - (looking-at "\\*/"))))) - (forward-sentence (- count)) - (while (> count 0) - (c-beginning-of-statement-1 lim) - (setq count (1- count))) - (while (< count 0) - (c-end-of-statement-1) - (setq count (1+ count)))) - ;; its possible we've been left up-buf of lim - (goto-char (max (point) lim)) - ) + (c-save-buffer-state + ((count (or count 1)) + here + (range (c-collect-line-comments (c-literal-limits lim)))) + (while (and (/= count 0) + (or (not lim) (> (point) lim))) + (setq here (point)) + (if (and (not range) sentence-flag) + (save-excursion + ;; Find the comment next to point if we're not in one. + (if (> count 0) + (if (c-backward-single-comment) + (setq range (cons (point) + (progn (c-forward-single-comment) + (point)))) + (c-skip-ws-backward) + (setq range (point)) + (setq range + (if (eq (char-before) ?\") + (c-safe (c-backward-sexp 1) + (cons (point) range))))) + (c-skip-ws-forward) + (if (eq (char-after) ?\") + (setq range (cons (point) + (progn + (c-forward-sexp 1) + (point)))) + (setq range (point)) + (setq range (if (c-forward-single-comment) + (cons range (point)) + nil)))) + (setq range (c-collect-line-comments range)))) + (if (and (< count 0) (= here (point-max))) + ;; Special case because eob might be in a literal. + (setq range nil)) + (if range + (if (and sentence-flag + (or (/= (char-syntax (char-after (car range))) ?\") + ;; Only visit a string if it spans more than one line. + (save-excursion + (goto-char (car range)) + (skip-chars-forward "^\n" (cdr range)) + (< (point) (cdr range))))) + (let* ((lit-type (c-literal-type range)) + (line-prefix (concat "[ \t]*\\(" + c-current-comment-prefix + "\\)[ \t]*")) + (beg (if (eq lit-type 'string) + (1+ (car range)) + (save-excursion + (goto-char (car range)) + (max (progn + (looking-at comment-start-skip) + (match-end 0)) + (progn + (looking-at line-prefix) + (match-end 0)))))) + (end (- (cdr range) (if (eq lit-type 'c) 2 1))) + (beg-of-para (if (eq lit-type 'string) + (lambda ()) + (lambda () + (beginning-of-line) + (if (looking-at line-prefix) + (goto-char (match-end 0))))))) + (save-restriction + ;; Move by sentence, but not past the limit of the + ;; literal, narrowed to the appropriate + ;; paragraph(s). + (narrow-to-region (save-excursion + (let ((pos (min here end))) + (goto-char pos) + (forward-paragraph -1) + (if (looking-at paragraph-separate) + (forward-line)) + (when (> (point) beg) + (funcall beg-of-para) + (when (>= (point) pos) + (forward-paragraph -2) + (funcall beg-of-para))) + (max (point) beg))) + end) + (c-safe (forward-sentence (if (< count 0) 1 -1))) + (if (and (memq lit-type '(c c++)) + ;; Check if we stopped due to a comment + ;; prefix and not a sentence end. + (/= (point) (point-min)) + (/= (point) (point-max)) + (save-excursion + (beginning-of-line) + (looking-at line-prefix)) + (>= (point) (match-beginning 0)) + (/= (match-beginning 1) (match-end 1)) + (or (< (point) (match-end 0)) + (and + (= (point) (match-end 0)) + ;; The comment prefix may contain + ;; characters that is regarded as end + ;; of sentence. + (or (eolp) + (and + (save-excursion + (forward-paragraph -1) + (< (point) (match-beginning 0))) + (save-excursion + (beginning-of-line) + (or (not (re-search-backward + (sentence-end) + (c-point 'bopl) + t)) + (< (match-end 0) + (c-point 'eol))))))))) + (setq count (+ count (if (< count 0) -1 1))) + (if (< count 0) + (progn + ;; In block comments, if there's only + ;; horizontal ws between the text and the + ;; comment ender, stop before it. Stop after + ;; the ender if there's either nothing or + ;; newlines between. + (when (and (eq lit-type 'c) + (eq (point) (point-max))) + (widen) + (when (or (= (skip-chars-backward " \t") 0) + (eq (point) (point-max)) + (bolp)) + (goto-char (cdr range))))) + (when (and (eq (point) (point-min)) + (looking-at "[ \t]*\\\\?$")) + ;; Stop before instead of after the comment + ;; starter if nothing follows it. + (widen) + (goto-char (car range)) + (if (and (eq lit-type 'string) (/= (point) here)) + (setq count (1+ count) + range nil)))))) + ;; See if we should escape the literal. + (if (> count 0) + (if (< (point) here) + (setq count (1- count)) + (goto-char (car range)) + (setq range nil)) + (if (> (point) here) + (setq count (1+ count)) + (goto-char (cdr range)) + (setq range nil)))) + (goto-char (if (> count 0) (car range) (cdr range))) + (setq range nil)) + (goto-char here) + (if (> count 0) + (condition-case nil + ;; Stop before `{' and after `;', `{', `}' and `};' + ;; when not followed by `}' or `)', but on the other + ;; side of the syntactic ws. Move by sexps and move + ;; into parens. Also stop before `#' when it's at boi + ;; on a line. + (let ((literal-pos (not sentence-flag)) + last last-below-line) + (catch 'done + (while t + (setq last (point)) + (when (and (or (eq (char-after) ?\{) + (and (eq (char-after) ?#) + (eq (point) (c-point 'boi))) + ) + (/= here last)) + (unless (and c-special-brace-lists + (eq (char-after) ?{) + (c-looking-at-special-brace-list)) + (if (and (eq (char-after) ?#) + (numberp last-below-line) + (not (eq last-below-line here))) + (goto-char last-below-line)) + (throw 'done t))) + ;; Don't know why I added the following, but it + ;; doesn't work when point is preceded by a line + ;; style comment. /mast + ;;(c-skip-ws-backward) + (if literal-pos + (c-backward-comments) + (when (c-backward-single-comment) + ;; Record position of first comment. + (save-excursion + (c-forward-single-comment) + (setq literal-pos (point))) + (c-backward-comments))) + (unless last-below-line + (if (save-excursion + (re-search-forward "\\(^\\|[^\\]\\)$" last t)) + (setq last-below-line last))) + (cond ((bobp) ; Must handle bob specially. + (if (= here last) + (throw 'done t) + (goto-char last) + (throw 'done t))) + ((progn (backward-char) + (looking-at "[;{}]")) + (if (and c-special-brace-lists + (eq (char-after) ?{) + (c-looking-at-special-brace-list)) + (skip-syntax-backward "w_") ; Speedup only. + (if (or (= here last) + (memq (char-after last) '(?\) ?}))) + (if (and (eq (char-before) ?}) + (eq (char-after) ?\;)) + (backward-char)) + (goto-char last) + (throw 'done t)))) + ((= (char-syntax (char-after)) ?\") + (let ((end (point))) + (forward-char) + (c-backward-sexp) + (save-excursion + (skip-chars-forward "^\n" end) + (when (< (point) end) + ;; Break at multiline string. + (setq literal-pos (1+ end)) + (throw 'done t))))) + (t (skip-syntax-backward "w_")) ; Speedup only. + ))) + (if (and (numberp literal-pos) + (< (point) literal-pos)) + ;; We jumped over a comment or string that + ;; should be investigated. + (goto-char literal-pos) + (setq count (1- count)))) + (error + (goto-char (point-min)) + (setq count 0))) + (condition-case nil + ;; Stop before `{', `}', and `#' when it's at boi on a + ;; line, but on the other side of the syntactic ws, and + ;; after `;', `}' and `};'. Only stop before `{' if at + ;; top level or inside braces, though. Move by sexps + ;; and move into parens. Also stop at eol of lines + ;; with `#' at the boi. + (let ((literal-pos (not sentence-flag)) + last) + (catch 'done + (while t + (setq last (point)) + (if literal-pos + (c-forward-comments) + (if (progn + (c-skip-ws-forward) + ;; Record position of first comment. + (setq literal-pos (point)) + (c-forward-single-comment)) + (c-forward-comments) + (setq literal-pos nil))) + (cond ((and (eq (char-after) ?{) + (not (and c-special-brace-lists + (c-looking-at-special-brace-list))) + (/= here last) + (save-excursion + (or (not (c-safe (up-list -1) t)) + (= (char-after) ?{)))) + (goto-char last) + (throw 'done t)) + ((and c-special-brace-lists + (eq (char-after) ?}) + (save-excursion + (and (c-safe (up-list -1) t) + (c-looking-at-special-brace-list)))) + (forward-char 1) + (skip-syntax-forward "w_")) ; Speedup only. + ((and (eq (char-after) ?}) + (/= here last)) + (goto-char last) + (throw 'done t)) +; ((and (eq (char-after) ?#) +; (= (point) (c-point 'boi))) +; (if (= here last) +; (or (re-search-forward "\\(^\\|[^\\]\\)$" nil t) +; (goto-char (point-max))) +; (goto-char last)) +; (throw 'done t)) + ((looking-at ";\\|};?") + (goto-char (match-end 0)) + (throw 'done t)) + ((= (char-syntax (char-after)) ?\") + (let ((beg (point))) + (c-forward-sexp) + (save-excursion + (skip-chars-backward "^\n" beg) + (when (> (point) beg) + ;; Break at multiline string. + (setq literal-pos beg) + (throw 'done t))))) + (t + (forward-char 1) + (skip-syntax-forward "w_")) ; Speedup only. + ))) + (if (and (numberp literal-pos) + (> (point) literal-pos)) + ;; We jumped over a comment that should be investigated. + (goto-char literal-pos) + (setq count (1+ count)))) + (error + (goto-char (point-max)) + (setq count 0))) + )) + ;; If we haven't moved we're near a buffer limit. + (when (and (not (zerop count)) (= (point) here)) + (goto-char (if (> count 0) (point-min) (point-max))) + (setq count 0)))) (c-keep-region-active)) (defun c-end-of-statement (&optional count lim sentence-flag) "Go to the end of the innermost C statement. - -With prefix arg, go forward N - 1 statements. Move forward to end of -the next statement if already at end. If within a string or comment, -move by sentences instead of statements. +With prefix arg, go forward N - 1 statements. Move forward to the end +of the next statement if already at end, and move into nested blocks +\(use \\[forward-sexp] to skip over a block). If within or next to a +comment or multiline string, move by sentences instead of statements. When called from a program, this function takes 3 optional args: the repetition count, a buffer position limit which is the farthest back -to search, and a flag saying whether to do sentence motion when in a -comment." +to search for the syntactic context, and a flag saying whether to do +sentence motion in or near comments and multiline strings." (interactive (list (prefix-numeric-value current-prefix-arg) nil t)) (c-beginning-of-statement (- (or count 1)) lim sentence-flag) @@ -671,43 +1724,82 @@ comment." c-electric-star c-electric-semi&comma c-electric-lt-gt - c-electric-colon)) + c-electric-colon + c-electric-paren)) (put 'c-electric-delete 'delete-selection 'supersede) ; delsel (put 'c-electric-delete 'pending-delete 'supersede) ; pending-del (put 'c-electric-backspace 'delete-selection 'supersede) ; delsel (put 'c-electric-backspace 'pending-delete 'supersede) ; pending-del +(put 'c-electric-delete-forward 'delete-selection 'supersede) ; delsel +(put 'c-electric-delete-forward 'pending-delete 'supersede) ; pending-del -;; This is used by indent-for-comment to decide how much to indent a -;; comment in C code based on its context. +(defun c-calc-comment-indent (entry) + (if (symbolp entry) + (setq entry (or (assq entry c-indent-comment-alist) + (assq 'other c-indent-comment-alist) + '(default . (column . nil))))) + (let ((action (car (cdr entry))) + (value (cdr (cdr entry))) + (col (current-column))) + (cond ((eq action 'space) + (+ col value)) + ((eq action 'column) + (unless value (setq value comment-column)) + (if (bolp) + ;; Do not pad with one space if we're at bol. + value + (max (1+ col) value))) + ((eq action 'align) + (or (save-excursion + (beginning-of-line) + (unless (bobp) + (backward-char) + (let ((lim (c-literal-limits (c-point 'bol) t))) + (when (consp lim) + (goto-char (car lim)) + (when (looking-at "/[/*]") + ;; Found comment to align with. + (if (bolp) + ;; Do not pad with one space if we're at bol. + 0 + (max (1+ col) (current-column)))))))) + ;; Recurse to handle value as a new spec. + (c-calc-comment-indent (cdr entry))))))) + (defun c-comment-indent () - (if (looking-at (concat "^\\(" c-comment-start-regexp "\\)")) - 0 ;Existing comment at bol stays there. - (let ((opoint (point)) - placeholder) - (save-excursion - (beginning-of-line) - (cond - ;; CASE 1: A comment following a solitary close-brace should - ;; have only one space. - ((looking-at (concat "[ \t]*}[ \t]*\\($\\|" - c-comment-start-regexp - "\\)")) - (search-forward "}") - (1+ (current-column))) - ;; CASE 2: 2 spaces after #endif - ((or (looking-at "^#[ \t]*endif[ \t]*") - (looking-at "^#[ \t]*else[ \t]*")) - 7) - ;; CASE 3: when comment-column is nil, calculate the offset - ;; according to c-offsets-alist. E.g. identical to hitting - ;; TAB. - ((and c-indent-comments-syntactically-p - (save-excursion - (skip-chars-forward " \t") - (or (looking-at comment-start) - (eolp)))) - (let ((syntax (c-guess-basic-syntax))) + "Used by `indent-for-comment' to create and indent comments. +See `c-indent-comment-alist' for a description." + (save-excursion + (end-of-line) + (c-save-buffer-state + ((eot (let ((lim (c-literal-limits (c-point 'bol) t))) + (or (when (consp lim) + (goto-char (car lim)) + (when (looking-at "/[/*]") + (skip-chars-backward " \t") + (point))) + (progn + (skip-chars-backward " \t") + (point))))) + (line-type + (cond ((looking-at "^/[/*]") + 'anchored-comment) + ((progn (beginning-of-line) + (eq (point) eot)) + 'empty-line) + ((progn (back-to-indentation) + (and (eq (char-after) ?}) + (eq (point) (1- eot)))) + 'end-block) + ((and (looking-at "#[ \t]*\\(endif\\|else\\)") + (eq (match-end 0) eot)) + 'cpp-end-block) + (t + 'other)))) + (if (and (memq line-type '(anchored-comment empty-line)) + c-indent-comments-syntactically-p) + (let ((c-syntactic-context (c-guess-basic-syntax))) ;; BOGOSITY ALERT: if we're looking at the eol, its ;; because indent-for-comment hasn't put the comment-start ;; in the buffer yet. this will screw up the syntactic @@ -715,129 +1807,103 @@ comment." ;; kludge is that if we're at the bol, then we really want ;; to ignore any anchoring as specified by ;; c-comment-only-line-offset since it doesn't apply here. - (if (save-excursion - (beginning-of-line) - (skip-chars-forward " \t") - (eolp)) + (if (eolp) (c-add-syntax 'comment-intro)) (let ((c-comment-only-line-offset (if (consp c-comment-only-line-offset) c-comment-only-line-offset (cons c-comment-only-line-offset c-comment-only-line-offset)))) - (apply '+ (mapcar 'c-get-offset syntax))))) - ;; CASE 4: use comment-column if previous line is a - ;; comment-only line indented to the left of comment-column - ((save-excursion - (beginning-of-line) - (and (not (bobp)) - (forward-line -1)) - (skip-chars-forward " \t") - (prog1 - (looking-at c-comment-start-regexp) - (setq placeholder (point)))) - (goto-char placeholder) - (if (< (current-column) comment-column) - comment-column - (current-column))) - ;; CASE 5: If comment-column is 0, and nothing but space - ;; before the comment, align it at 0 rather than 1. - ((progn - (goto-char opoint) - (skip-chars-backward " \t") - (and (= comment-column 0) (bolp))) - 0) - ;; CASE 6: indent at comment column except leave at least one - ;; space. - (t (max (1+ (current-column)) - comment-column)) - ))))) + (c-get-syntactic-indentation c-syntactic-context))) + (goto-char eot) + (c-calc-comment-indent line-type))))) -;; for proposed new variable comment-line-break-function -(defun c-comment-line-break-function (&optional soft) - ;; we currently don't do anything with soft line breaks - (let ((literal (c-in-literal)) - at-comment-col) - (cond - ((eq literal 'string)) - ((or (not c-comment-continuation-stars) - (not literal)) - (indent-new-comment-line soft)) - (t (let ((here (point)) - (leader c-comment-continuation-stars)) - (back-to-indentation) - ;; comment could be hanging - (if (not (c-in-literal)) - (progn - (forward-line 1) - (forward-comment -1) - (setq at-comment-col (= (current-column) comment-column)))) - ;; are we looking at a block or lines style comment? - (if (and (looking-at (concat "\\(" c-comment-start-regexp - "\\)[ \t]+")) - (string-equal (match-string 1) "//")) - ;; line style - (setq leader "// ")) - (goto-char here) - (delete-region (progn (skip-chars-backward " \t") (point)) - (progn (skip-chars-forward " \t") (point))) - (newline) - ;; to avoid having an anchored comment that c-indent-line will - ;; trip up on - (insert " " leader) - (if at-comment-col - (indent-for-comment)) - (c-indent-line)))))) - -;; advice for indent-new-comment-line for older Emacsen -(if (boundp 'comment-line-break-function) - nil - (require 'advice) - (defadvice indent-new-comment-line (around c-line-break-advice activate) - (if (or (not c-buffer-is-cc-mode) - (not (c-in-literal)) - (not c-comment-continuation-stars)) - ad-do-it - (c-comment-line-break-function (ad-get-arg 0))))) - ;; used by outline-minor-mode (defun c-outline-level () - (save-excursion - (skip-chars-forward "\t ") - (current-column))) + (let (buffer-invisibility-spec);; This so that `current-column' DTRT + ;; in otherwise-hidden text. + (save-excursion + (skip-chars-forward "\t ") + (current-column)))) (defun c-up-conditional (count) "Move back to the containing preprocessor conditional, leaving mark behind. A prefix argument acts as a repeat count. With a negative argument, move forward to the end of the containing preprocessor conditional. -When going backwards, `#elif' is treated like `#else' followed by -`#if'. When going forwards, `#elif' is ignored." + +`#elif' is treated like `#else' followed by `#if', so the function +stops at them when going backward, but not when going forward." (interactive "p") - (c-forward-conditional (- count) t) + (c-forward-conditional (- count) -1) + (c-keep-region-active)) + +(defun c-up-conditional-with-else (count) + "Move back to the containing preprocessor conditional, including `#else'. +Just like `c-up-conditional', except it also stops at `#else' +directives." + (interactive "p") + (c-forward-conditional (- count) -1 t) + (c-keep-region-active)) + +(defun c-down-conditional (count) + "Move forward into the next preprocessor conditional, leaving mark behind. +A prefix argument acts as a repeat count. With a negative argument, +move backward into the previous preprocessor conditional. + +`#elif' is treated like `#else' followed by `#if', so the function +stops at them when going forward, but not when going backward." + (interactive "p") + (c-forward-conditional count 1) (c-keep-region-active)) -(defun c-backward-conditional (count &optional up-flag) +(defun c-down-conditional-with-else (count) + "Move forward into the next preprocessor conditional, including `#else'. +Just like `c-down-conditional', except it also stops at `#else' +directives." + (interactive "p") + (c-forward-conditional count 1 t) + (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." (interactive "p") - (c-forward-conditional (- count) up-flag) + (c-forward-conditional (- count) target-depth with-else) (c-keep-region-active)) -(defun c-forward-conditional (count &optional up-flag) +(defun c-forward-conditional (count &optional target-depth with-else) "Move forward across a preprocessor conditional, leaving mark behind. A prefix argument acts as a repeat count. With a negative argument, -move backward across a preprocessor conditional." +move backward across a preprocessor conditional. + +`#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 +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)) + (unless (integerp target-depth) + (setq target-depth (if target-depth -1 0))) (save-excursion (while (/= count 0) - (let ((depth (if up-flag 0 -1)) found) + (let ((depth 0) + ;; subdepth is the depth in "uninteresting" subtrees, + ;; i.e. those that takes us farther from the target + ;; depth instead of closer. + (subdepth 0) + found) (save-excursion ;; Find the "next" significant line in the proper direction. (while (and (not found) @@ -848,36 +1914,50 @@ move backward across a preprocessor conditional." ;; precedes it. This is faster on account of ;; the fastmap feature of the regexp matcher. (funcall search-function - "#[ \t]*\\(if\\|elif\\|endif\\)" + "#[ \t]*\\(if\\|elif\\|endif\\|else\\)" nil t)) (beginning-of-line) ;; Now verify it is really a preproc line. - (if (looking-at "^[ \t]*#[ \t]*\\(if\\|elif\\|endif\\)") - (let ((prev depth)) - ;; Update depth according to what we found. - (beginning-of-line) - (cond ((looking-at "[ \t]*#[ \t]*endif") - (setq depth (+ depth increment))) - ((looking-at "[ \t]*#[ \t]*elif") - (if (and forward (= depth 0)) - (setq found (point)))) - (t (setq depth (- depth increment)))) - ;; If we are trying to move across, and we find an - ;; end before we find a beginning, get an error. - (if (and (< prev 0) (< depth prev)) - (error (if forward - "No following conditional at this level" - "No previous conditional at this level"))) + (if (looking-at "^[ \t]*#[ \t]*\\(if\\|elif\\|endif\\|else\\)") + (let (dchange (directive (match-string 1))) + (cond ((string= directive "if") + (setq dchange (- increment))) + ((string= directive "endif") + (setq dchange increment)) + ((= subdepth 0) + ;; When we're not in an "uninteresting" + ;; subtree, we might want to act on "elif" + ;; and "else" too. + (if (cond (with-else + ;; Always move toward the target depth. + (setq dchange + (if (> target-depth 0) 1 -1))) + ((string= directive "elif") + (setq dchange (- increment)))) + ;; Ignore the change if it'd take us + ;; into an "uninteresting" subtree. + (if (eq (> dchange 0) (<= target-depth 0)) + (setq dchange nil))))) + (when dchange + (when (or (/= subdepth 0) + (eq (> dchange 0) (<= target-depth 0))) + (setq subdepth (+ subdepth dchange))) + (setq depth (+ depth dchange)) + ;; If we are trying to move across, and we find an + ;; end before we find a beginning, get an error. + (if (and (< depth target-depth) (< dchange 0)) + (error (if forward + "No following conditional at this level" + "No previous conditional at this level")))) ;; When searching forward, start from next line so ;; that we don't find the same line again. (if forward (forward-line 1)) - ;; If this line exits a level of conditional, exit - ;; inner loop. - (if (< depth 0) + ;; We found something if we've arrived at the + ;; target depth. + (if (and dchange (= depth target-depth)) (setq found (point)))) ;; else - (if forward (forward-line 1)) - ))) + (if forward (forward-line 1))))) (or found (error "No containing preprocessor conditional")) (goto-char (setq new found))) @@ -888,20 +1968,25 @@ move backward across a preprocessor conditional." ;; commands to indent lines, regions, defuns, and expressions -(defun c-indent-command (&optional whole-exp) +(defun c-indent-command (&optional arg) "Indent current line as C code, and/or insert some whitespace. If `c-tab-always-indent' is t, always just indent the current line. If nil, indent the current line only if point is at the left margin or in the line's indentation; otherwise insert some whitespace[*]. If other than nil or t, then some whitespace[*] is inserted only within -literals (comments and strings) and inside preprocessor directives, -but the line is always reindented. +literals (comments and strings), but the line is always reindented. -A numeric argument, regardless of its value, means indent rigidly all -the lines of the expression starting after point so that this line -becomes properly indented. The relative indentation among the lines -of the expression are preserved. +If `c-syntactic-indentation' is t, indentation is done according to +the syntactic context. A numeric argument, regardless of its value, +means indent rigidly all the lines of the expression starting after +point so that this line becomes properly indented. The relative +indentation among the lines of the expression is preserved. + +If `c-syntactic-indentation' is nil, the line is just indented one +step according to `c-basic-offset'. In this mode, a numeric argument +indents a number of such steps, positive or negative, and an empty +prefix argument is equivalent to -1. [*] The amount and kind of whitespace inserted is controlled by the variable `c-insert-tab-function', which is called to do the actual @@ -909,26 +1994,49 @@ of the expression are preserved. just inserts a tab character, or the equivalent number of spaces, depending on the variable `indent-tabs-mode'." - (interactive "P") - (let ((bod (c-point 'bod))) - (if whole-exp - ;; If arg, always indent this line as C - ;; and shift remaining lines of expression the same amount. - (let ((shift-amt (c-indent-line)) + (interactive "p") + (let ((indent-function + (if c-syntactic-indentation + (symbol-function 'indent-according-to-mode) + (lambda () + (let ((c-macro-start c-macro-start) + (steps (cond ((not current-prefix-arg) 1) + ((equal current-prefix-arg '(4)) -1) + (t arg)))) + (c-shift-line-indentation (* steps c-basic-offset)) + (when (and c-auto-align-backslashes + (save-excursion + (end-of-line) + (eq (char-before) ?\\)) + (c-query-and-set-macro-start)) + ;; Realign the line continuation backslash if inside a macro. + (c-backslash-region (point) (point) nil t))) + )))) + (if (and c-syntactic-indentation current-prefix-arg) + ;; If c-syntactic-indentation and got arg, always indent this + ;; line as C and shift remaining lines of expression the same + ;; amount. + (let ((shift-amt (save-excursion + (back-to-indentation) + (current-column))) beg end) + (c-indent-line) + (setq shift-amt (- (save-excursion + (back-to-indentation) + (current-column)) + shift-amt)) (save-excursion (if (eq c-tab-always-indent t) (beginning-of-line)) (setq beg (point)) - (forward-sexp 1) + (c-forward-sexp 1) (setq end (point)) (goto-char beg) (forward-line 1) (setq beg (point))) (if (> end beg) - (indent-code-rigidly beg end (- shift-amt) "#"))) - ;; No arg supplied, use c-tab-always-indent to determine - ;; behavior + (indent-code-rigidly beg end shift-amt "#"))) + ;; Else use c-tab-always-indent to determine behavior. (cond ;; CASE 1: indent when at column zero or in lines indentation, ;; otherwise insert a tab @@ -937,218 +2045,166 @@ of the expression are preserved. (skip-chars-backward " \t") (not (bolp))) (funcall c-insert-tab-function) - (c-indent-line))) + (funcall indent-function))) ;; CASE 2: just indent the line ((eq c-tab-always-indent t) - (c-indent-line)) + (funcall indent-function)) ;; CASE 3: if in a literal, insert a tab, but always indent the ;; line (t - (if (c-in-literal bod) + (if (c-in-literal) (funcall c-insert-tab-function)) - (c-indent-line) + (funcall indent-function) ))))) (defun c-indent-exp (&optional shutup-p) - "Indent each line in balanced expression following point. -Optional SHUTUP-P if non-nil, inhibits message printing and error checking." - (interactive "P") - (let ((here (point)) - end progress-p) + "Indent each line in the balanced expression following point syntactically. +If optional SHUTUP-P is non-nil, no errors are signalled if no +balanced expression is found." + (interactive "*P") + (let ((here (point-marker)) + end) + (set-marker-insertion-type here t) (unwind-protect - (let ((c-echo-syntactic-information-p nil) ;keep quiet for speed - (start (progn - ;; try to be smarter about finding the range of - ;; lines to indent. skip all following - ;; whitespace. failing that, try to find any - ;; opening brace on the current line - (skip-chars-forward " \t\n") - (if (memq (char-after) '(?\( ?\[ ?\{)) - (point) - (let ((state (parse-partial-sexp (point) - (c-point 'eol)))) - (and (nth 1 state) - (goto-char (nth 1 state)) - (memq (char-after) '(?\( ?\[ ?\{)) - (point))))))) - ;; find balanced expression end - (setq end (and (c-safe (progn (forward-sexp 1) t)) - (point-marker))) + (let ((start (save-restriction + ;; Find the closest following open paren that + ;; ends on another line. + (narrow-to-region (point-min) (c-point 'eol)) + (let (beg (end (point))) + (while (and (setq beg (c-down-list-forward end)) + (setq end (c-up-list-forward beg)))) + (and beg + (eq (char-syntax (char-before beg)) ?\() + (1- beg)))))) ;; sanity check - (and (not start) - (not shutup-p) - (error "Cannot find start of balanced expression to indent.")) - (and (not end) - (not shutup-p) - (error "Cannot find end of balanced expression to indent.")) - (c-progress-init start end 'c-indent-exp) - (setq progress-p t) - (goto-char start) - (beginning-of-line) - (while (< (point) end) - (if (not (looking-at "[ \t]*$")) - (c-indent-line)) - (c-progress-update) - (forward-line 1))) - ;; make sure marker is deleted - (and end - (set-marker end nil)) - (and progress-p - (c-progress-fini 'c-indent-exp)) - (goto-char here)))) + (if (not start) + (unless shutup-p + (error "Cannot find start of balanced expression to indent")) + (goto-char start) + (setq end (c-safe (scan-sexps (point) 1))) + (if (not end) + (unless shutup-p + (error "Cannot find end of balanced expression to indent")) + (forward-line) + (if (< (point) end) + (c-indent-region (point) end))))) + (goto-char here) + (set-marker here nil)))) (defun c-indent-defun () - "Re-indents the current top-level function def, struct or class declaration." - (interactive) - (let ((here (point-marker)) - (c-echo-syntactic-information-p nil) - (brace (c-least-enclosing-brace (c-parse-state)))) - (if brace - (goto-char brace) - (beginning-of-defun)) - ;; if we're sitting at b-o-b, it might be because there was no - ;; least enclosing brace and we were sitting on the defun's open - ;; brace. - (if (and (bobp) (not (eq (char-after) ?\{))) - (goto-char here)) - ;; if defun-prompt-regexp is non-nil, b-o-d might not leave us at - ;; the open brace. I consider this an Emacs bug. - (and (boundp 'defun-prompt-regexp) - defun-prompt-regexp - (looking-at defun-prompt-regexp) - (goto-char (match-end 0))) - ;; catch all errors in c-indent-exp so we can 1. give more - ;; meaningful error message, and 2. restore point + "Indent the current top-level declaration or macro syntactically. +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) (unwind-protect - (c-indent-exp) + (progn + (c-save-buffer-state nil + ;; We try to be line oriented, unless there are several + ;; declarations on the same line. + (if (looking-at c-syntactic-eol) + (c-backward-token-2 1 nil (c-point 'bol)) + (c-forward-token-2 0 nil (c-point 'eol))) + (setq decl-limits (c-declaration-limits nil))) + (if decl-limits + (c-indent-region (car decl-limits) + (cdr decl-limits)))) (goto-char here) (set-marker here nil)))) -(defun c-indent-region (start end) - ;; Indent every line whose first char is between START and END inclusive. +(defun c-indent-region (start end &optional quiet) + "Indent syntactically every line whose first char is between START +and END inclusive. If the optional argument QUIET is non-nil then no +syntactic errors are reported, even if `c-report-syntactic-errors' is +non-nil." (save-excursion + (goto-char end) + (skip-chars-backward " \t\n\r\f\v") + (setq end (point)) (goto-char start) ;; Advance to first nonblank line. - (skip-chars-forward " \t\n") (beginning-of-line) - (let (endmark) - (unwind-protect - (let ((c-tab-always-indent t) - ;; shut up any echo msgs on indiv lines - (c-echo-syntactic-information-p nil) - fence) - (c-progress-init start end 'c-indent-region) - (setq endmark (copy-marker end)) - (while (and (bolp) - (not (eobp)) - (< (point) endmark)) - ;; update progress - (c-progress-update) - ;; Indent one line as with TAB. - (let (nextline sexpend sexpbeg) - ;; skip blank lines - (skip-chars-forward " \t\n") - (beginning-of-line) - ;; indent the current line - (c-indent-line) - (setq fence (point)) - (if (save-excursion - (beginning-of-line) - (looking-at "[ \t]*#")) - (forward-line 1) - (save-excursion - ;; Find beginning of following line. - (setq nextline (c-point 'bonl)) - ;; Find first beginning-of-sexp for sexp extending past - ;; this line. - (beginning-of-line) - (while (< (point) nextline) - (condition-case nil - (progn - (forward-sexp 1) - (setq sexpend (point))) - (error (setq sexpend nil) - (goto-char nextline))) - (c-forward-syntactic-ws)) - (if sexpend - (progn - ;; make sure the sexp we found really starts on the - ;; current line and extends past it - (goto-char sexpend) - (setq sexpend (point-marker)) - (c-safe (backward-sexp 1)) - (setq sexpbeg (point)))) - (if (and sexpbeg (< sexpbeg fence)) - (setq sexpbeg fence))) - ;; check to see if the next line starts a - ;; comment-only line - (save-excursion - (forward-line 1) - (skip-chars-forward " \t") - (if (looking-at c-comment-start-regexp) - (setq sexpbeg (c-point 'bol)))) - ;; If that sexp ends within the region, indent it all at - ;; once, fast. - (condition-case nil - (if (and sexpend - (> sexpend nextline) - (<= sexpend endmark)) - (progn - (goto-char sexpbeg) - (c-indent-exp 'shutup) - (c-progress-update) - (goto-char sexpend))) - (error - (goto-char sexpbeg) - (c-indent-line))) - ;; Move to following line and try again. - (and sexpend - (markerp sexpend) - (set-marker sexpend nil)) - (forward-line 1) - (setq fence (point)))))) - (set-marker endmark nil) - (c-progress-fini 'c-indent-region) - (c-echo-parsing-error) - )))) - -(defun c-mark-function () - "Put mark at end of a C, C++, or Objective-C defun, point at beginning." + (skip-chars-forward " \t\n\r\f\v") + (setq start (point)) + (beginning-of-line) + (setq c-parsing-error + (or (let ((endmark (copy-marker end)) + (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 + (save-excursion (c-beginning-of-macro)) + start)) + (c-fix-backslashes nil) + syntax) + (unwind-protect + (progn + (c-progress-init start end 'c-indent-region) + (while (and (bolp) + (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))) + (set-marker endmark nil) + (c-progress-fini 'c-indent-region)) + (c-echo-parsing-error quiet)) + c-parsing-error)))) + +(defun c-fn-region-is-active-p () + ;; Function version of the macro for use in places that aren't + ;; compiled, e.g. in the menus. + ;; + ;; This function does not do any hidden buffer changes. + (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) - (let ((here (point)) - ;; there should be a c-point position for 'eod - (eod (save-excursion (end-of-defun) (point))) - (state (c-parse-state)) - brace) - (while state - (setq brace (car state)) - (if (consp brace) - (goto-char (cdr brace)) - (goto-char brace)) - (setq state (cdr state))) - (if (eq (char-after) ?{) - (progn - (forward-line -1) - (while (not (or (bobp) - (looking-at "[ \t]*$"))) - (forward-line -1))) - (forward-line 1) - (skip-chars-forward " \t\n")) - (push-mark here) - (push-mark eod nil t))) + (if (c-region-is-active-p) + (c-indent-region (region-beginning) (region-end)) + (c-indent-line))) ;; for progress reporting (defvar c-progress-info nil) (defun c-progress-init (start end context) + ;; This function does not do any hidden buffer changes. (cond ;; Be silent ((not c-progress-interval)) ;; Start the progress update messages. If this Emacs doesn't have ;; a built-in timer, just be dumb about it. ((not (fboundp 'current-time)) - (message "indenting region... (this may take a while)")) + (message "Indenting region... (this may take a while)")) ;; If progress has already been initialized, do nothing. otherwise ;; initialize the counter with a vector of: ;; [start end lastsec context] @@ -1159,11 +2215,11 @@ Optional SHUTUP-P if non-nil, inhibits message printing and error checking." (point-marker)) (nth 1 (current-time)) context)) - (message "indenting region...")) + (message "Indenting region...")) )) (defun c-progress-update () - ;; update progress + ;; This function does not do any hidden buffer changes. (if (not (and c-progress-info c-progress-interval)) nil (let ((now (nth 1 (current-time))) @@ -1174,13 +2230,13 @@ Optional SHUTUP-P if non-nil, inhibits message printing and error checking." ;; what's the right value? (if (< c-progress-interval (- now lastsecs)) (progn - (message "indenting region... (%d%% complete)" + (message "Indenting region... (%d%% complete)" (/ (* 100 (- (point) start)) (- end start))) (aset c-progress-info 2 now))) ))) (defun c-progress-fini (context) - ;; finished + ;; This function does not do any hidden buffer changes. (if (not c-progress-interval) nil (if (or (eq context (aref c-progress-info 3)) @@ -1188,257 +2244,1249 @@ Optional SHUTUP-P if non-nil, inhibits message printing and error checking." (progn (set-marker (aref c-progress-info 1) nil) (setq c-progress-info nil) - (message "indenting region...done"))))) + (message "Indenting region... done"))))) ;;; This page handles insertion and removal of backslashes for C macros. -(defun c-backslash-region (from to delete-flag) +(defun c-backslash-region (from to delete-flag &optional line-mode) "Insert, align, or delete end-of-line backslashes on the lines in the region. With no argument, inserts backslashes and aligns existing backslashes. -With an argument, deletes the backslashes. +With an argument, deletes the backslashes. The backslash alignment is +done according to the settings in `c-backslash-column', +`c-backslash-max-column' and `c-auto-align-backslashes'. This function does not modify blank lines at the start of the region. -If the region ends at the start of a line, it always deletes the -backslash (if any) at the end of the previous line. - +If the region ends at the start of a line and the macro doesn't +continue below it, the backslash (if any) at the end of the previous +line is deleted. + You can put the region around an entire macro definition and use this command to conveniently insert and align the necessary backslashes." - (interactive "r\nP") - (save-excursion - (goto-char from) - (let ((column c-backslash-column) - (endmark (make-marker))) - (move-marker endmark to) - ;; Compute the smallest column number past the ends of all the lines. - (if (not delete-flag) - (while (< (point) to) - (end-of-line) - (if (eq (char-before) ?\\) - (progn (forward-char -1) - (skip-chars-backward " \t"))) - (setq column (max column (1+ (current-column)))) - (forward-line 1))) - ;; Adjust upward to a tab column, if that doesn't push past the margin. - (if (> (% column tab-width) 0) - (let ((adjusted (* (/ (+ column tab-width -1) tab-width) tab-width))) - (if (< adjusted (window-width)) - (setq column adjusted)))) - ;; Don't modify blank lines at start of region. - (goto-char from) - (while (and (< (point) endmark) (eolp)) - (forward-line 1)) - ;; Add or remove backslashes on all the lines. - (while (< (point) endmark) - (if (and (not delete-flag) - ;; Un-backslashify the last line - ;; if the region ends right at the start of the next line. - (save-excursion - (forward-line 1) - (< (point) endmark))) - (c-append-backslash column) - (c-delete-backslash)) - (forward-line 1)) - (move-marker endmark nil))) - (c-keep-region-active)) + (interactive "*r\nP") + (let ((endmark (make-marker)) + ;; Keep the backslash trimming functions from changing the + ;; whitespace around point, since in this case it's only the + ;; position of point that tells the indentation of the line. + (point-pos (if (save-excursion + (skip-chars-backward " \t") + (and (bolp) (looking-at "[ \t]*\\\\?$"))) + (point-marker) + (point-min))) + column longest-line-col bs-col-after-end) + (save-excursion + (goto-char to) + (if (and (not line-mode) (bobp)) + ;; Nothing to do if to is at bob, since we should back up + ;; and there's no line to back up to. + nil + (when (and (not line-mode) (bolp)) + ;; Do not back up the to line if line-mode is set, to make + ;; e.g. c-newline-and-indent consistent regardless whether + ;; the (newline) call leaves point at bol or not. + (backward-char) + (setq to (point))) + (if delete-flag + (progn + (set-marker endmark (point)) + (goto-char from) + (c-delete-backslashes-forward endmark point-pos)) + ;; Set bs-col-after-end to the column of any backslash + ;; following the region, or nil if there is none. + (setq bs-col-after-end + (and (progn (end-of-line) + (eq (char-before) ?\\)) + (= (forward-line 1) 0) + (progn (end-of-line) + (eq (char-before) ?\\)) + (1- (current-column)))) + (when line-mode + ;; Back up the to line if line-mode is set, since the line + ;; after the newly inserted line break should not be + ;; touched in c-newline-and-indent. + (setq to (max from (or (c-safe (c-point 'eopl)) from))) + (unless bs-col-after-end + ;; Set bs-col-after-end to non-nil in any case, since we + ;; do not want to delete the backslash at the last line. + (setq bs-col-after-end t))) + (if (and line-mode + (not c-auto-align-backslashes)) + (goto-char from) + ;; Compute the smallest column number past the ends of all + ;; the lines. + (setq longest-line-col 0) + (goto-char to) + (if bs-col-after-end + ;; Include one more line in the max column + ;; calculation, since the to line will be backslashed + ;; too. + (forward-line 1)) + (end-of-line) + (while (and (>= (point) from) + (progn + (if (eq (char-before) ?\\) + (forward-char -1)) + (skip-chars-backward " \t") + (setq longest-line-col (max longest-line-col + (1+ (current-column)))) + (beginning-of-line) + (not (bobp)))) + (backward-char)) + ;; Try to align with surrounding backslashes. + (goto-char from) + (beginning-of-line) + (if (and (not (bobp)) + (progn (backward-char) + (eq (char-before) ?\\))) + (progn + (setq column (1- (current-column))) + (if (numberp bs-col-after-end) + ;; Both a preceding and a following backslash. + ;; Choose the greatest of them. + (setq column (max column bs-col-after-end))) + (goto-char from)) + ;; No preceding backslash. Try to align with one + ;; following the region. Disregard the backslash at the + ;; to line since it's likely to be bogus (e.g. when + ;; called from c-newline-and-indent). + (if (numberp bs-col-after-end) + (setq column bs-col-after-end)) + ;; Don't modify blank lines at start of region. + (goto-char from) + (while (and (< (point) to) (bolp) (eolp)) + (forward-line 1))) + (if (and column (< column longest-line-col)) + ;; Don't try to align with surrounding backslashes if + ;; any line is too long. + (setq column nil)) + (unless column + ;; Impose minimum limit and tab width alignment only if + ;; we can't align with surrounding backslashes. + (if (> (% longest-line-col tab-width) 0) + (setq longest-line-col + (* (/ (+ longest-line-col tab-width -1) + tab-width) + tab-width))) + (setq column (max c-backslash-column + longest-line-col))) + ;; Always impose maximum limit. + (setq column (min column c-backslash-max-column))) + (if bs-col-after-end + ;; Add backslashes on all lines if the macro continues + ;; after the to line. + (progn + (set-marker endmark to) + (c-append-backslashes-forward endmark column point-pos)) + ;; Add backslashes on all lines except the last, and + ;; remove any on the last line. + (if (save-excursion + (goto-char to) + (beginning-of-line) + (if (not (bobp)) + (set-marker endmark (1- (point))))) + (progn + (c-append-backslashes-forward endmark column point-pos) + ;; The function above leaves point on the line + ;; following endmark. + (set-marker endmark (point))) + (set-marker endmark to)) + (c-delete-backslashes-forward endmark point-pos))))) + (set-marker endmark nil) + (if (markerp point-pos) + (set-marker point-pos nil)))) + +(defun c-append-backslashes-forward (to-mark column point-pos) + ;; This function does not do any hidden buffer changes. + (let ((state (parse-partial-sexp (c-point 'bol) (point)))) + (if column + (while + (and + (<= (point) to-mark) + + (let ((start (point)) (inserted nil) end col) + (end-of-line) + (unless (eq (char-before) ?\\) + (insert ?\\) + (setq inserted t)) + (setq state (parse-partial-sexp + start (point) nil nil state)) + (backward-char) + (setq col (current-column)) + + ;; Avoid unnecessary changes of the buffer. + (cond ((and (not inserted) (nth 3 state)) + ;; Don't realign backslashes in string literals + ;; since that would change them. + ) + + ((< col column) + (delete-region + (point) + (progn + (skip-chars-backward + " \t" (if (>= (point) point-pos) point-pos)) + (point))) + (indent-to column)) + + ((and (= col column) + (memq (char-before) '(?\ ?\t)))) + + ((progn + (setq end (point)) + (or (/= (skip-chars-backward + " \t" (if (>= (point) point-pos) point-pos)) + -1) + (/= (char-after) ?\ ))) + (delete-region (point) end) + (indent-to column 1))) + + (= (forward-line 1) 0)))) + + ;; Make sure there are backslashes with at least one space in + ;; front of them. + (while + (and + (<= (point) to-mark) + + (let ((start (point))) + (end-of-line) + (setq state (parse-partial-sexp + start (point) nil nil state)) + + (if (eq (char-before) ?\\) + (unless (nth 3 state) + (backward-char) + (unless (and (memq (char-before) '(?\ ?\t)) + (/= (point) point-pos)) + (insert ?\ ))) + + (if (and (memq (char-before) '(?\ ?\t)) + (/= (point) point-pos)) + (insert ?\\) + (insert ?\ ?\\))) + + (= (forward-line 1) 0))))))) + +(defun c-delete-backslashes-forward (to-mark point-pos) + ;; This function does not do any hidden buffer changes. + (while + (and (<= (point) to-mark) + (progn + (end-of-line) + (if (eq (char-before) ?\\) + (delete-region + (point) + (progn (backward-char) + (skip-chars-backward " \t" (if (>= (point) point-pos) + point-pos)) + (point)))) + (= (forward-line 1) 0))))) -(defun c-append-backslash (column) - (end-of-line) - (if (eq (char-before) ?\\) - (progn (forward-char -1) - (delete-horizontal-space) - (indent-to column)) - (indent-to column) - (insert "\\"))) - -(defun c-delete-backslash () - (end-of-line) - (or (bolp) - (progn - (forward-char -1) - (if (looking-at "\\\\") - (delete-region (1+ (point)) - (progn (skip-chars-backward " \t") (point))))))) -(defun c-fill-paragraph (&optional arg) - "Like \\[fill-paragraph] but handles C and C++ style comments. -If any of the current line is a comment or within a comment, -fill the comment or the paragraph of it that point is in, -preserving the comment indentation or line-starting decorations. +;;; Line breaking and paragraph filling. + +(defvar c-auto-fill-prefix t) +(defvar c-lit-limits nil) +(defvar c-lit-type nil) + +;; The filling code is based on a simple theory; leave the intricacies +;; of the text handling to the currently active mode for that +;; (e.g. adaptive-fill-mode or filladapt-mode) and do as little as +;; possible to make them work correctly wrt the comment and string +;; separators, one-line paragraphs etc. Unfortunately, when it comes +;; to it, there's quite a lot of special cases to handle which makes +;; the code anything but simple. The intention is that it will work +;; with any well-written text filling package that preserves a fill +;; prefix. +;; +;; We temporarily mask comment starters and enders as necessary for +;; the filling code to do its job on a seemingly normal text block. +;; We do _not_ mask the fill prefix, so it's up to the filling code to +;; preserve it correctly (especially important when filling C++ style +;; line comments). By default, we set up and use adaptive-fill-mode, +;; which is standard in all supported Emacs flavors. + +(defun c-guess-fill-prefix (lit-limits lit-type) + ;; Determine the appropriate comment fill prefix for a block or line + ;; comment. Return a cons of the prefix string and the column where + ;; it ends. If fill-prefix is set, it'll override. Note that this + ;; function also uses the value of point in some heuristics. + + (let* ((here (point)) + (prefix-regexp (concat "[ \t]*\\(" + c-current-comment-prefix + "\\)[ \t]*")) + (comment-start-regexp (if (eq lit-type 'c++) + prefix-regexp + comment-start-skip)) + prefix-line comment-prefix res comment-text-end) -Optional prefix ARG means justify paragraph as well." - (interactive "P") - (let* (comment-start-place - (first-line - ;; Check for obvious entry to comment. - (save-excursion - (beginning-of-line) - (skip-chars-forward " \t\n") - (and (looking-at comment-start-skip) - (setq comment-start-place (point))))) - (re1 "\\|[ \t]*/\\*[ \t]*$\\|[ \t]*\\*/[ \t]*$\\|[ \t/*]*$")) - (if (save-excursion - (beginning-of-line) - (looking-at ".*//")) - (let ((fill-prefix fill-prefix) - ;; Lines containing just a comment start or just an end - ;; should not be filled into paragraphs they are next - ;; to. - (paragraph-start (concat paragraph-start re1)) - (paragraph-separate (concat paragraph-separate re1))) - (save-excursion - (beginning-of-line) - ;; Move up to first line of this comment. - (while (and (not (bobp)) - (looking-at "[ \t]*//[ \t]*[^ \t\n]")) - (forward-line -1)) - (if (not (looking-at ".*//[ \t]*[^ \t\n]")) - (forward-line 1)) - ;; Find the comment start in this line. - (re-search-forward "[ \t]*//[ \t]*") - ;; Set the fill-prefix to be what all lines except the first - ;; should start with. But do not alter a user set fill-prefix. - (if (null fill-prefix) - (setq fill-prefix (buffer-substring (match-beginning 0) - (match-end 0)))) - (save-restriction - ;; Narrow down to just the lines of this comment. - (narrow-to-region (c-point 'bol) - (save-excursion - (forward-line 1) - (while (looking-at fill-prefix) - (forward-line 1)) - (point))) - (fill-paragraph arg) - t))) - ;; else C style comments - (if (or first-line - ;; t if we enter a comment between start of function and - ;; this line. - (eq (c-in-literal) 'c) - ;; t if this line contains a comment starter. - (setq first-line - (save-excursion - (beginning-of-line) - (prog1 - (re-search-forward comment-start-skip - (save-excursion (end-of-line) - (point)) - t) - (setq comment-start-place (point)))))) - ;; Inside a comment: fill one comment paragraph. - (let ((fill-prefix - ;; The prefix for each line of this paragraph - ;; is the appropriate part of the start of this line, - ;; up to the column at which text should be indented. - (save-excursion - (beginning-of-line) - (if (looking-at "[ \t]*/\\*.*\\*/") - (progn (re-search-forward comment-start-skip) - (make-string (current-column) ?\ )) - (if first-line (forward-line 1)) + (cond + (fill-prefix + (setq res (cons fill-prefix + ;; Ugly way of getting the column after the fill + ;; prefix; it'd be nice with a current-column + ;; that works on strings.. + (let ((start (point))) + (unwind-protect + (progn + (insert-and-inherit "\n" fill-prefix) + (current-column)) + (delete-region start (point))))))) - (let ((line-width (progn (end-of-line) (current-column)))) - (beginning-of-line) - (prog1 - (buffer-substring - (point) + ((eq lit-type 'c++) + (save-excursion + ;; Set fallback for comment-prefix if none is found. + (setq comment-prefix "// " + comment-text-end (cdr lit-limits)) + + (beginning-of-line) + (if (> (point) (car lit-limits)) + ;; The current line is not the comment starter, so the + ;; comment has more than one line, and it can therefore be + ;; used to find the comment fill prefix. + (setq prefix-line (point)) + + (goto-char (car lit-limits)) + (if (and (= (forward-line 1) 0) + (< (point) (cdr lit-limits))) + ;; The line after the comment starter is inside the + ;; comment, so we can use it. + (setq prefix-line (point)) + + ;; The comment is only one line. Take the comment prefix + ;; from it and keep the indentation. + (goto-char (car lit-limits)) + (if (looking-at prefix-regexp) + (goto-char (match-end 0)) + (forward-char 2) + (skip-chars-forward " \t")) + + (let (str col) + (if (eq (c-point 'boi) (car lit-limits)) + ;; There is only whitespace before the comment + ;; starter; take the prefix straight from this line. + (setq str (buffer-substring-no-properties + (c-point 'bol) (point)) + col (current-column)) + + ;; There is code before the comment starter, so we + ;; have to temporarily insert and indent a new line to + ;; get the right space/tab mix in the indentation. + (let ((prefix-len (- (point) (car lit-limits))) + tmp) + (unwind-protect + (progn + (goto-char (car lit-limits)) + (indent-to (prog1 (current-column) + (insert ?\n))) + (setq tmp (point)) + (forward-char prefix-len) + (setq str (buffer-substring-no-properties + (c-point 'bol) (point)) + col (current-column))) + (delete-region (car lit-limits) tmp)))) + + (setq res + (if (or (string-match "\\s \\'" str) (not (eolp))) + (cons str col) + ;; The prefix ends the line with no whitespace + ;; after it. Default to a single space. + (cons (concat str " ") (1+ col)))) + ))))) + + (t + (setq comment-text-end + (save-excursion + (goto-char (- (cdr lit-limits) 2)) + (if (looking-at "\\*/") (point) (cdr lit-limits)))) + + (save-excursion + (beginning-of-line) + (if (and (> (point) (car lit-limits)) + (not (and (looking-at "[ \t]*\\*/") + (eq (cdr lit-limits) (match-end 0))))) + ;; The current line is not the comment starter and + ;; contains more than just the ender, so it's good enough + ;; to be used for the comment fill prefix. + (setq prefix-line (point)) + (goto-char (car lit-limits)) + + (cond ((or (/= (forward-line 1) 0) + (>= (point) (cdr lit-limits)) + (and (looking-at "[ \t]*\\*/") + (eq (cdr lit-limits) (match-end 0))) + (and (looking-at prefix-regexp) + (<= (1- (cdr lit-limits)) (match-end 0)))) + ;; The comment is either one line or the next line contains + ;; just the comment ender. In this case we have no + ;; information about a suitable comment prefix, so we resort + ;; to c-block-comment-prefix. + (setq comment-prefix (or c-block-comment-prefix ""))) + + ((< here (point)) + ;; The point was on the comment opener line, so we might want + ;; to treat this as a not yet closed comment. + + (if (and (match-beginning 1) + (/= (match-beginning 1) (match-end 1))) + ;; Above `prefix-regexp' matched a nonempty prefix on the + ;; second line, so let's use it. Normally it should do + ;; to set `prefix-line' and let the code below pick up + ;; the whole prefix, but if there's no text after the + ;; match then it will probably fall back to no prefix at + ;; all if the comment isn't closed yet, so in that case + ;; it's better to force use of the prefix matched now. + (if (= (match-end 0) (c-point 'eol)) + (setq comment-prefix (match-string 1)) + (setq prefix-line (point))) + + ;; There's no nonempty prefix on the line after the + ;; comment opener. If the line is empty, or if the + ;; text on it has less or equal indentation than the + ;; comment starter we assume it's an unclosed + ;; comment starter, i.e. that + ;; `c-block-comment-prefix' should be used. + ;; Otherwise we assume it's a closed comment where + ;; the prefix really is the empty string. + ;; E.g. this is an unclosed comment: + ;; + ;; /* + ;; foo + ;; + ;; But this is not: + ;; + ;; /* + ;; foo + ;; */ + ;; + ;; (Looking for the presence of the comment closer + ;; rarely works since it's probably the closer of + ;; some comment further down when the comment + ;; really is unclosed.) + (if (<= (save-excursion (back-to-indentation) + (current-column)) + (save-excursion (goto-char (car lit-limits)) + (current-column))) + (setq comment-prefix (or c-block-comment-prefix "")) + (setq prefix-line (point))))) + + (t + ;; Otherwise the line after the comment starter is good + ;; enough to find the prefix in. + (setq prefix-line (point)))) + + (when comment-prefix + ;; Haven't got the comment prefix on any real line that we + ;; can take it from, so we have to temporarily insert + ;; `comment-prefix' on a line and indent it to find the + ;; correct column and the correct mix of tabs and spaces. + (setq res + (let (tmp-pre tmp-post) + (unwind-protect + (progn + + (goto-char (car lit-limits)) + (if (looking-at comment-start-regexp) + (goto-char (min (match-end 0) + comment-text-end)) + (forward-char 2) + (skip-chars-forward " \t")) + + (when (eq (char-syntax (char-before)) ?\ ) + ;; If there's ws on the current line, we'll use it + ;; instead of what's ending comment-prefix. + (setq comment-prefix + (concat (substring comment-prefix + 0 (string-match + "\\s *\\'" + comment-prefix)) + (buffer-substring-no-properties + (save-excursion + (skip-chars-backward " \t") + (point)) + (point))))) + + (setq tmp-pre (point-marker)) + + ;; We insert an extra non-whitespace character + ;; before the line break and after comment-prefix in + ;; case it's "" or ends with whitespace. + (insert-and-inherit "x\n" comment-prefix "x") + (setq tmp-post (point-marker)) + + (indent-according-to-mode) + + (goto-char (1- tmp-post)) + (cons (buffer-substring-no-properties + (c-point 'bol) (point)) + (current-column))) + + (when tmp-post + (delete-region tmp-pre tmp-post) + (set-marker tmp-pre nil) + (set-marker tmp-post nil)))))))))) + + (or res ; Found a good prefix above. + + (save-excursion + ;; prefix-line is the bol of a line on which we should try + ;; to find the prefix. + (let* (fb-string fb-endpos ; Contains any fallback prefix found. + (test-line + (lambda () + (when (and (looking-at prefix-regexp) + (<= (match-end 0) comment-text-end)) + (unless (eq (match-end 0) (c-point 'eol)) + ;; The match is fine if there's text after it. + (throw 'found (cons (buffer-substring-no-properties + (match-beginning 0) (match-end 0)) + (progn (goto-char (match-end 0)) + (current-column))))) + (unless fb-string + ;; This match is better than nothing, so let's + ;; remember it in case nothing better is found + ;; on another line. + (setq fb-string (buffer-substring-no-properties + (match-beginning 0) (match-end 0)) + fb-endpos (match-end 0))) + t)))) + + (or (catch 'found + ;; Search for a line which has text after the prefix + ;; so that we get the proper amount of whitespace + ;; after it. We start with the current line, then + ;; search backwards, then forwards. + + (goto-char prefix-line) + (when (and (funcall test-line) + (or (/= (match-end 1) (match-end 0)) + ;; The whitespace is sucked up by the + ;; first [ \t]* glob if the prefix is empty. + (and (= (match-beginning 1) (match-end 1)) + (/= (match-beginning 0) (match-end 0))))) + ;; If the current line doesn't have text but do + ;; have whitespace after the prefix, we'll use it. + (throw 'found (cons fb-string + (progn (goto-char fb-endpos) + (current-column))))) + + (if (eq lit-type 'c++) + ;; For line comments we can search up to and + ;; including the first line. + (while (and (zerop (forward-line -1)) + (>= (point) (car lit-limits))) + (funcall test-line)) + ;; For block comments we must stop before the + ;; block starter. + (while (and (zerop (forward-line -1)) + (> (point) (car lit-limits))) + (funcall test-line))) + + (goto-char prefix-line) + (while (and (zerop (forward-line 1)) + (< (point) (cdr lit-limits))) + (funcall test-line)) + + (goto-char prefix-line) + nil) + + (when fb-string + ;; A good line wasn't found, but at least we have a + ;; fallback that matches the comment prefix regexp. + (cond ((or (string-match "\\s \\'" fb-string) + (progn + (goto-char fb-endpos) + (not (eolp)))) + ;; There are ws or text after the prefix, so + ;; let's use it. + (cons fb-string (current-column))) + + ((progn + ;; Check if there's any whitespace padding + ;; on the comment start line that we can + ;; use after the prefix. + (goto-char (car lit-limits)) + (if (looking-at comment-start-regexp) + (goto-char (match-end 0)) + (forward-char 2) + (skip-chars-forward " \t")) + (or (not (eolp)) + (eq (char-syntax (char-before)) ?\ ))) + + (setq fb-string (buffer-substring-no-properties + (save-excursion + (skip-chars-backward " \t") + (point)) + (point))) + (goto-char fb-endpos) + (skip-chars-backward " \t") + + (let ((tmp (point))) + ;; Got to mess in the buffer once again to + ;; ensure the column gets correct. :P + (unwind-protect + (progn + (insert-and-inherit fb-string) + (cons (buffer-substring-no-properties + (c-point 'bol) + (point)) + (current-column))) + (delete-region tmp (point))))) + + (t + ;; Last resort: Just add a single space after + ;; the prefix. + (cons (concat fb-string " ") + (progn (goto-char fb-endpos) + (1+ (current-column))))))) + + ;; The line doesn't match the comment prefix regexp. + (if comment-prefix + ;; We have a fallback for line comments that we must use. + (cons (concat (buffer-substring-no-properties + prefix-line (c-point 'boi)) + comment-prefix) + (progn (back-to-indentation) + (+ (current-column) (length comment-prefix)))) + + ;; Assume we are dealing with a "free text" block + ;; comment where the lines doesn't have any comment + ;; prefix at all and we should just fill it as + ;; normal text. + '("" . 0)))))) + )) - ;; How shall we decide where the end of the - ;; fill-prefix is? +(defun c-mask-paragraph (fill-paragraph apply-outside-literal fun &rest args) + ;; Calls FUN with ARGS ar arguments while the current paragraph is + ;; masked to allow adaptive filling to work correctly. That + ;; includes narrowing the buffer and, if point is inside a comment, + ;; masking the comment starter and ender appropriately. + ;; + ;; FILL-PARAGRAPH is non-nil if called for whole paragraph filling. + ;; The position of point is then less significant when doing masking + ;; and narrowing. + ;; + ;; If APPLY-OUTSIDE-LITERAL is nil then the function will be called + ;; only if the point turns out to be inside a comment or a string. + ;; + ;; This function does not do any hidden buffer changes. + + (let (fill + ;; beg and end limits the region to narrow. end is a marker. + beg end + ;; tmp-pre and tmp-post mark strings that are temporarily + ;; inserted at the start and end of the region. tmp-pre is a + ;; cons of the positions of the prepended string. tmp-post is + ;; a marker pointing to the single character of the appended + ;; string. + tmp-pre tmp-post + ;; If hang-ender-stuck isn't nil, the comment ender is + ;; hanging. In that case it's set to the number of spaces + ;; that should be between the text and the ender. + hang-ender-stuck + (here (point)) + (c-lit-limits c-lit-limits) + (c-lit-type c-lit-type)) + + ;; Restore point on undo. It's necessary since we do a lot of + ;; hidden inserts and deletes below that should be as transparent + ;; as possible. + (if (and buffer-undo-list (not (eq buffer-undo-list t))) + (setq buffer-undo-list (cons (point) buffer-undo-list))) + + (save-restriction + ;; Widen to catch comment limits correctly. + (widen) + (unless c-lit-limits + (setq c-lit-limits (c-literal-limits nil fill-paragraph))) + (setq c-lit-limits (c-collect-line-comments c-lit-limits)) + (unless c-lit-type + (setq c-lit-type (c-literal-type c-lit-limits)))) + + (save-excursion + (unless (c-safe (backward-char) + (forward-paragraph) + (>= (point) here)) + (goto-char here) + (forward-paragraph)) + (setq end (point-marker))) + (save-excursion + (unless (c-safe (forward-char) + (backward-paragraph) + (<= (point) here)) + (goto-char here) + (backward-paragraph)) + (setq beg (point))) + + (unwind-protect + (progn + (cond + + ((eq c-lit-type 'c++) ; Line comment. + (save-excursion + ;; Limit to the comment or paragraph end, whichever + ;; comes first. + (set-marker end (min end (cdr c-lit-limits))) + + (when (<= beg (car c-lit-limits)) + ;; The region includes the comment starter, so we must + ;; check it. + (goto-char (car c-lit-limits)) + (back-to-indentation) + (if (eq (point) (car c-lit-limits)) + ;; Include the first line in the region. + (setq beg (c-point 'bol)) + ;; The first line contains code before the + ;; comment. We must fake a line that doesn't. + (setq tmp-pre t)))) + + (setq apply-outside-literal t)) + + ((eq c-lit-type 'c) ; Block comment. + (when (>= end (cdr c-lit-limits)) + ;; The region includes the comment ender which we might + ;; want to keep together with the last word. + (unless (save-excursion + (goto-char (cdr c-lit-limits)) + (beginning-of-line) + (and (looking-at (concat "[ \t]*\\(" + c-current-comment-prefix + "\\)\\*/")) + (eq (cdr c-lit-limits) (match-end 0)) + ;; The comment ender is on a line of its + ;; own. Keep it that way. + (set-marker end (point)))) + + (if fill-paragraph + ;; The comment ender should hang. Replace all + ;; cruft between it and the last word with one or + ;; two 'x' and include it in the region. We'll + ;; change them back to spaces afterwards. This + ;; isn't done when auto filling, since that'd + ;; effectively make it impossible to insert extra + ;; spaces before the comment ender. + (let* ((ender-start (save-excursion + (goto-char (cdr c-lit-limits)) + (skip-syntax-backward "^w ") + (point))) + (point-rel (- ender-start here)) + spaces) + + (save-excursion + (goto-char (cdr c-lit-limits)) + (setq tmp-post (point-marker)) + (insert ?\n) + (set-marker end (point)) + (forward-line -1) + (if (and (looking-at (concat "[ \t]*\\(\\(" + c-current-comment-prefix + "\\)[ \t]*\\)")) + (eq ender-start (match-end 0))) + ;; The comment ender is prefixed by nothing + ;; but a comment line prefix. Remove it + ;; along with surrounding ws. + (setq spaces (- (match-end 1) (match-end 2))) + (goto-char ender-start)) + (skip-chars-backward " \t\r\n") + + (if (/= (point) ender-start) (progn - (beginning-of-line) - (skip-chars-forward " \t*" (c-point 'eol)) - ;; kludge alert, watch out for */, in - ;; which case fill-prefix should *not* - ;; be "*"! - (if (and (eq (char-after) ?/) - (eq (char-before) ?*)) - (forward-char -1)) - (point))) - - ;; If the comment is only one line followed - ;; by a blank line, calling move-to-column - ;; above may have added some spaces and tabs - ;; to the end of the line; the fill-paragraph - ;; function will then delete it and the - ;; newline following it, so we'll lose a - ;; blank line when we shouldn't. So delete - ;; anything move-to-column added to the end - ;; of the line. We record the line width - ;; instead of the position of the old line - ;; end because move-to-column might break a - ;; tab into spaces, and the new characters - ;; introduced there shouldn't be deleted. - - ;; If you can see a better way to do this, - ;; please make the change. This seems very - ;; messy to me. - (delete-region (progn (move-to-column line-width) - (point)) - (progn (end-of-line) (point)))))))) - - ;; Lines containing just a comment start or just an end - ;; should not be filled into paragraphs they are next - ;; to. - (paragraph-start (concat paragraph-start re1)) - (paragraph-separate (concat paragraph-separate re1)) - (chars-to-delete 0) - ) - (save-restriction - ;; Don't fill the comment together with the code - ;; following it. So temporarily exclude everything - ;; before the comment start, and everything after the - ;; line where the comment ends. If comment-start-place - ;; is non-nil, the comment starter is there. Otherwise, - ;; point is inside the comment. - (narrow-to-region (save-excursion - (if comment-start-place - (goto-char comment-start-place) - (search-backward "/*")) - (if (and (not c-hanging-comment-starter-p) - (looking-at - (concat c-comment-start-regexp - "[ \t]*$"))) - (forward-line 1)) - ;; Protect text before the comment - ;; start by excluding it. Add - ;; spaces to bring back proper - ;; indentation of that point. - (let ((column (current-column))) - (prog1 (point) - (setq chars-to-delete column) - (insert-char ?\ column)))) - (save-excursion - (if comment-start-place - (goto-char (+ comment-start-place 2))) - (search-forward "*/" nil 'move) - (forward-line 1) - (point))) - (fill-paragraph arg) + (if (<= here (point)) + ;; Don't adjust point below if it's + ;; before the string we replace. + (setq point-rel -1)) + ;; Keep one or two spaces between the + ;; text and the ender, depending on how + ;; many there are now. + (unless spaces + (setq spaces (- ender-start (point)))) + (setq spaces + (max + (min spaces + (if sentence-end-double-space 2 1)) + 1)) + ;; Insert the filler first to keep marks right. + (insert-char ?x spaces t) + (delete-region (point) (+ ender-start spaces)) + (setq hang-ender-stuck spaces) + (setq point-rel + (and (>= point-rel 0) + (- (point) (min point-rel spaces))))) + (setq point-rel nil))) + + (if point-rel + ;; Point was in the middle of the string we + ;; replaced above, so put it back in the same + ;; relative position, counting from the end. + (goto-char point-rel))) + + ;; We're doing auto filling. Just move the marker + ;; to the comment end to ignore any code after the + ;; comment. + (move-marker end (cdr c-lit-limits))))) + + (when (<= beg (car c-lit-limits)) + ;; The region includes the comment starter. + (save-excursion + (goto-char (car c-lit-limits)) + (if (looking-at (concat "\\(" comment-start-skip "\\)$")) + ;; Begin with the next line. + (setq beg (c-point 'bonl)) + ;; Fake the fill prefix in the first line. + (setq tmp-pre t)))) + + (setq apply-outside-literal t)) + + ((eq c-lit-type 'string) ; String. + (save-excursion + (when (>= end (cdr c-lit-limits)) + (goto-char (1- (cdr c-lit-limits))) + (setq tmp-post (point-marker)) + (insert ?\n) + (set-marker end (point))) + (when (<= beg (car c-lit-limits)) + (goto-char (1+ (car c-lit-limits))) + (setq beg (if (looking-at "\\\\$") + ;; Leave the start line if it's + ;; nothing but an escaped newline. + (1+ (match-end 0)) + (point))))) + (setq apply-outside-literal t)) + + ((eq c-lit-type 'pound) ; Macro + ;; Narrow to the macro limits if they are nearer than the + ;; paragraph limits. Don't know if this is necessary but + ;; do it for completeness sake (doing auto filling at all + ;; inside macros is bogus to begin with since the line + ;; continuation backslashes aren't handled). + (save-excursion + (c-beginning-of-macro) + (beginning-of-line) + (if (> (point) beg) + (setq beg (point))) + (c-end-of-macro) + (forward-line) + (if (< (point) end) + (set-marker end (point))))) + + (t ; Other code. + ;; Try to avoid comments and macros in the paragraph to + ;; avoid that the adaptive fill mode gets the prefix from + ;; them. + (c-save-buffer-state nil (save-excursion - ;; Delete the chars we inserted to avoid clobbering - ;; the stuff before the comment start. - (goto-char (point-min)) - (if (> chars-to-delete 0) - (delete-region (point) (+ (point) chars-to-delete))) - ;; Find the comment ender (should be on last line of - ;; buffer, given the narrowing) and don't leave it on - ;; its own line, unless that's the style that's desired. - (goto-char (point-max)) - (forward-line -1) - (search-forward "*/" nil 'move) + (goto-char beg) + (c-forward-syntactic-ws end) (beginning-of-line) - (if (and c-hanging-comment-ender-p - (looking-at "[ \t]*\\*/")) - ;(delete-indentation))))) - (let ((fill-column (+ fill-column 9999))) - (forward-line -1) - (fill-region-as-paragraph (point) (point-max)))))) - t))))) + (setq beg (point)) + (goto-char end) + (c-backward-syntactic-ws beg) + (forward-line) + (set-marker end (point)))))) + + (when tmp-pre + ;; Temporarily insert the fill prefix after the comment + ;; starter so that the first line looks like any other + ;; comment line in the narrowed region. + (setq fill (c-save-buffer-state nil + (c-guess-fill-prefix c-lit-limits c-lit-type))) + (unless (string-match (concat "\\`[ \t]*\\(" + c-current-comment-prefix + "\\)[ \t]*\\'") + (car fill)) + ;; Oops, the prefix doesn't match the comment prefix + ;; regexp. This could produce very confusing + ;; results with adaptive fill packages together with + ;; the insert prefix magic below, since the prefix + ;; often doesn't appear at all. So let's warn about + ;; it. + (message "\ +Warning: Regexp from `c-comment-prefix-regexp' doesn't match the comment prefix %S" + (car fill))) + ;; Find the right spot on the line, break it, insert + ;; the fill prefix and make sure we're back in the + ;; same column by temporarily prefixing the first word + ;; with a number of 'x'. + (save-excursion + (goto-char (car c-lit-limits)) + (if (looking-at (if (eq c-lit-type 'c++) + c-current-comment-prefix + comment-start-skip)) + (goto-char (match-end 0)) + (forward-char 2) + (skip-chars-forward " \t")) + (while (and (< (current-column) (cdr fill)) + (not (eolp))) + (forward-char 1)) + (let ((col (current-column))) + (setq beg (1+ (point)) + tmp-pre (list (point))) + (unwind-protect + (progn + (insert-and-inherit "\n" (car fill)) + (insert-char ?x (- col (current-column)) t)) + (setcdr tmp-pre (point)))))) + + (when apply-outside-literal + ;; `apply-outside-literal' is always set to t here if + ;; we're inside a literal. + + (let ((fill-prefix + (or fill-prefix + ;; Kludge: If the function that adapts the fill prefix + ;; doesn't produce the required comment starter for + ;; line comments, then force it by setting fill-prefix. + (when (and (eq c-lit-type 'c++) + ;; Kludge the kludge: filladapt-mode doesn't + ;; have this problem, but it currently + ;; doesn't override fill-context-prefix + ;; (version 2.12). + (not (and (boundp 'filladapt-mode) + filladapt-mode)) + (not (string-match + "\\`[ \t]*//" + (or (fill-context-prefix beg end) + "")))) + (c-save-buffer-state nil + (car (or fill (c-guess-fill-prefix + c-lit-limits c-lit-type))))))) + + ;; Save the relative position of point if it's outside the + ;; region we're going to narrow. Want to restore it in that + ;; case, but otherwise it should be moved according to the + ;; called function. + (point-rel (cond ((< (point) beg) (- (point) beg)) + ((> (point) end) (- (point) end))))) + + ;; Preparations finally done! Now we can call the + ;; actual function. + (prog1 + (save-restriction + (narrow-to-region beg end) + (apply fun args)) + (if point-rel + ;; Restore point if it was outside the region. + (if (< point-rel 0) + (goto-char (+ beg point-rel)) + (goto-char (+ end point-rel)))))))) + + (when (consp tmp-pre) + (delete-region (car tmp-pre) (cdr tmp-pre))) + + (when tmp-post + (save-excursion + (goto-char tmp-post) + (delete-char 1)) + (when hang-ender-stuck + ;; Preserve point even if it's in the middle of the string + ;; we replace; save-excursion doesn't work in that case. + (setq here (point)) + (goto-char tmp-post) + (skip-syntax-backward "^w ") + (forward-char (- hang-ender-stuck)) + (insert-char ?\ hang-ender-stuck t) + (delete-char hang-ender-stuck) + (goto-char here)) + (set-marker tmp-post nil)) + + (set-marker end nil)))) + +(defun c-fill-paragraph (&optional arg) + "Like \\[fill-paragraph] but handles C and C++ style comments. +If any of the current line is a comment or within a comment, fill the +comment or the paragraph of it that point is in, preserving the +comment indentation or line-starting decorations (see the +`c-comment-prefix-regexp' and `c-block-comment-prefix' variables for +details). + +If point is inside multiline string literal, fill it. This currently +does not respect escaped newlines, except for the special case when it +is the very first thing in the string. The intended use for this rule +is in situations like the following: + +char description[] = \"\\ +A very long description of something that you want to fill to make +nicely formatted output.\"\; + +If point is in any other situation, i.e. in normal code, do nothing. + +Optional prefix ARG means justify paragraph as well." + (interactive "*P") + (let ((fill-paragraph-function + ;; Avoid infinite recursion. + (if (not (eq fill-paragraph-function 'c-fill-paragraph)) + 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. + t) + +(defun c-do-auto-fill () + ;; Do automatic filling if not inside a context where it should be + ;; ignored. + ;; + ;; This function does not do any hidden buffer changes. + (let ((c-auto-fill-prefix + ;; The decision whether the line should be broken is actually + ;; done in c-indent-new-comment-line, which do-auto-fill + ;; calls to break lines. We just set this special variable + ;; so that we'll know when we're called from there. It's + ;; also used to detect whether fill-prefix is user set or + ;; generated automatically by do-auto-fill. + fill-prefix)) + (c-mask-paragraph nil t 'do-auto-fill))) + +(defun c-indent-new-comment-line (&optional soft allow-auto-fill) + "Break line at point and indent, continuing comment or macro if within one. +If inside a comment and `comment-multi-line' is non-nil, the +indentation and line prefix are preserved (see the +`c-comment-prefix-regexp' and `c-block-comment-prefix' variables for +details). If inside a single line comment and `comment-multi-line' is +nil, a new comment of the same type is started on the next line and +indented as appropriate for comments. If inside a macro, a line +continuation backslash is inserted and aligned as appropriate, and the +new line is indented according to `c-syntactic-indentation'. + +If a fill prefix is specified, it overrides all the above." + ;; allow-auto-fill is used from c-context-line-break to allow auto + ;; filling to break the line more than once. Since this function is + ;; used from auto-fill itself, that's normally disabled to avoid + ;; unnecessary recursion. + (interactive) + (let ((fill-prefix fill-prefix) + (do-line-break + (lambda () + (delete-horizontal-space) + (if soft + (insert-and-inherit ?\n) + (newline (if allow-auto-fill nil 1))))) + ;; Already know the literal type and limits when called from + ;; c-context-line-break. + (c-lit-limits c-lit-limits) + (c-lit-type c-lit-type) + (c-macro-start c-macro-start)) + (when (not (eq c-auto-fill-prefix t)) + ;; Called from do-auto-fill. + (unless c-lit-limits + (setq c-lit-limits (c-literal-limits nil nil t))) + (unless c-lit-type + (setq c-lit-type (c-literal-type c-lit-limits))) + (if (memq (cond ((c-query-and-set-macro-start) 'cpp) + ((null c-lit-type) 'code) + (t c-lit-type)) + c-ignore-auto-fill) + (setq fill-prefix t) ; Used as flag in the cond. + (if (and (null c-auto-fill-prefix) + (eq c-lit-type 'c) + (<= (c-point 'bol) (car c-lit-limits))) + ;; The adaptive fill function has generated a prefix, but + ;; we're on the first line in a block comment so it'll be + ;; wrong. Ignore it to guess a better one below. + (setq fill-prefix nil) + (when (and (eq c-lit-type 'c++) + (not (string-match "\\`[ \t]*//" (or fill-prefix "")))) + ;; Kludge: If the function that adapted the fill prefix + ;; doesn't produce the required comment starter for line + ;; comments, then we ignore it. + (setq fill-prefix nil))) + )) + (cond ((eq fill-prefix t) + ;; A call from do-auto-fill which should be ignored. + ) + (fill-prefix + ;; A fill-prefix overrides anything. + (funcall do-line-break) + (insert-and-inherit fill-prefix)) + ((progn + (unless c-lit-limits + (setq c-lit-limits (c-literal-limits))) + (unless c-lit-type + (setq c-lit-type (c-literal-type c-lit-limits))) + (memq c-lit-type '(c c++))) + ;; Some sort of comment. + (if (or comment-multi-line + (save-excursion + (goto-char (car c-lit-limits)) + (end-of-line) + (< (point) (cdr c-lit-limits)))) + ;; Inside a comment that should be continued. + (let ((fill (c-save-buffer-state nil + (c-guess-fill-prefix + (setq c-lit-limits + (c-collect-line-comments c-lit-limits)) + c-lit-type))) + (pos (point)) + (comment-text-end + (or (and (eq c-lit-type 'c) + (save-excursion + (goto-char (- (cdr c-lit-limits) 2)) + (if (looking-at "\\*/") (point)))) + (cdr c-lit-limits)))) + ;; Skip forward past the fill prefix in case + ;; we're standing in it. + ;; + ;; FIXME: This doesn't work well in cases like + ;; + ;; /* Bla bla bla bla bla + ;; bla bla + ;; + ;; If point is on the 'B' then the line will be + ;; broken after "Bla b". + (while (and (< (current-column) (cdr fill)) + (not (eolp))) + (forward-char 1)) + (if (and (> (point) comment-text-end) + (> (c-point 'bol) (car c-lit-limits))) + (progn + ;; The skip takes us out of the (block) + ;; comment; insert the fill prefix at bol + ;; instead and keep the position. + (setq pos (copy-marker pos t)) + (beginning-of-line) + (insert-and-inherit (car fill)) + (if soft (insert-and-inherit ?\n) (newline 1)) + (goto-char pos) + (set-marker pos nil)) + ;; Don't break in the middle of a comment starter + ;; or ender. + (cond ((> (point) comment-text-end) + (goto-char comment-text-end)) + ((< (point) (+ (car c-lit-limits) 2)) + (goto-char (+ (car c-lit-limits) 2)))) + (funcall do-line-break) + (insert-and-inherit (car fill)))) + ;; Inside a comment that should be broken. + (let ((comment-start comment-start) + (comment-end comment-end) + col) + (if (eq c-lit-type 'c) + (unless (string-match "[ \t]*/\\*" comment-start) + (setq comment-start "/* " comment-end " */")) + (unless (string-match "[ \t]*//" comment-start) + (setq comment-start "// " comment-end ""))) + (setq col (save-excursion + (back-to-indentation) + (current-column))) + (funcall do-line-break) + (when (and comment-end (not (equal comment-end ""))) + (forward-char -1) + (insert-and-inherit comment-end) + (forward-char 1)) + ;; c-comment-indent may look at the current + ;; indentation, so let's start out with the same + ;; indentation as the previous one. + (indent-to col) + (insert-and-inherit comment-start) + (indent-for-comment)))) + ((c-query-and-set-macro-start) + ;; In a macro. + (unless (looking-at "[ \t]*\\\\$") + ;; Do not clobber the alignment of the line continuation + ;; slash; c-backslash-region might look at it. + (delete-horizontal-space)) + ;; Got an asymmetry here: In normal code this command + ;; doesn't indent the next line syntactically, and otoh a + ;; normal syntactically indenting newline doesn't continue + ;; the macro. + (c-newline-and-indent (if allow-auto-fill nil 1))) + (t + ;; Somewhere else in the code. + (let ((col (save-excursion + (beginning-of-line) + (while (and (looking-at "[ \t]*\\\\?$") + (= (forward-line -1) 0))) + (current-indentation)))) + (funcall do-line-break) + (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) + +;; advice for indent-new-comment-line for older Emacsen +(unless (boundp 'comment-line-break-function) + (defvar c-inside-line-break-advice nil) + (defadvice indent-new-comment-line (around c-line-break-advice + activate preactivate) + "Call `c-indent-new-comment-line' if in CC Mode." + (if (or c-inside-line-break-advice + (not c-buffer-is-cc-mode)) + ad-do-it + (let ((c-inside-line-break-advice t)) + (c-indent-new-comment-line (ad-get-arg 0)))))) + +(defun c-context-line-break () + "Do a line break suitable to the context. + +When point is outside a comment or macro, insert a newline and indent +according to the syntactic context, unless `c-syntactic-indentation' +is nil, in which case the new line is indented as the previous +non-empty line instead. + +When point is inside the content of a preprocessor directive, a line +continuation backslash is inserted before the line break and aligned +appropriately. The end of the cpp directive doesn't count as inside +it. + +When point is inside a comment, continue it with the appropriate +comment prefix (see the `c-comment-prefix-regexp' and +`c-block-comment-prefix' variables for details). The end of a +C++-style line comment doesn't count as inside it." + (interactive "*") + (let* ((c-lit-limits (c-literal-limits nil nil t)) + (c-lit-type (c-literal-type c-lit-limits)) + (c-macro-start c-macro-start)) + (if (or (eq c-lit-type 'c) + (and (eq c-lit-type 'c++) + (< (save-excursion + (skip-chars-forward " \t") + (point)) + (1- (cdr (setq c-lit-limits + (c-collect-line-comments c-lit-limits)))))) + (and (or (not (looking-at "\\s *$")) + (eq (char-before) ?\\)) + (c-query-and-set-macro-start) + (<= (save-excursion + (goto-char c-macro-start) + (if (looking-at c-opt-cpp-start) + (goto-char (match-end 0))) + (point)) + (point)))) + (let ((comment-multi-line t) + (fill-prefix nil)) + (c-indent-new-comment-line nil t)) + (delete-horizontal-space) + (newline) + ;; c-indent-line may look at the current indentation, so let's + ;; start out with the same indentation as the previous line. + (let ((col (save-excursion + (forward-line -1) + (while (and (looking-at "[ \t]*\\\\?$") + (= (forward-line -1) 0))) + (current-indentation)))) + (indent-to col)) + (indent-according-to-mode)))) + +(defun c-context-open-line () + "Insert a line break suitable to the context and leave point before it. +This is the `c-context-line-break' equivalent to `open-line', which is +normally bound to C-o. See `c-context-line-break' for the details." + (interactive "*") + (let ((here (point))) + (unwind-protect + (progn + ;; Temporarily insert a non-whitespace char to keep any + ;; preceding whitespace intact. + (insert ?x) + (c-context-line-break)) + (goto-char here) + (delete-char 1)))) -(provide 'cc-cmds) +(cc-provide 'cc-cmds) + +;;; arch-tag: bf0611dc-d1f4-449e-9e45-4ec7c6936677 ;;; cc-cmds.el ends here