dld@f.gp.cs.cmu.edu (David Detlefs) (06/15/88)
Below is the latest (its not all that late, really) version of c++-mode.el we have here. There are three problems I'd like to fix, but haven't had much time: 1) Indenting an expression like this_is_a_long_function_name_so_I_want_to_start_the_args_next_line( <tab> goes all the way to--------------------------------------------------------> instead of having a "c++-first-func_arg-offset" (or something) variable that tells how far from the beginning of "this_..." to indent. I'd vote for a default of, say, 5. If I find time to put this in, I'll let a value of "nil" for this variable mean "maintain current behavior." 2) Beginning(end)-of-defun doesn't work very well -- neither does indent-defun (or whatever ^X^Q is called.) 3) Statements ending in operators, such as cout << "The value of x is " << x << ", and the value of y is " << y << ", and the value of z is " << z <<... Keep getting indented by (I think) "c-continued-statement-offset." I find this annoying, and would like to make it a little more intelligent. 4) I suppose people have noticed that if you have C -style comments in your file, it can mess up indentation. I really don't know what to do about this. So, if I have some time, I will try to work on these and post a revised version. If anyone else has any suggestions or gripes, I'd be happy to collect them. Of course, anyone is free to tackle any of these on their own. I'd be happy to receive any such improvements and incorporate them into a "semi-official" version, with due credit, of course (thanks, Glen Ditchfield, for your modifications.) I don't know how one goes about nominating anything for inclusion into the gnu-emacs distribution; if anyone does, feel free to put this forward. With all that said, here is what we have at the present: ----------------------------------- Cut here -------------------------------- ;; C++ code editing commands for Emacs ;; 1987 Dave Detlefs and Stewart Clamen. ;; Done by fairly faithful modification of: ;; c-mode.el, Copyright (C) 1985 Richard M. Stallman. ;; ;; August 1987: incorporated changes done by Glen Ditchfield of Waterloo. (defvar c++-mode-syntax-table nil "Syntax table in use in C++-mode buffers.") (defvar c++-mode-abbrev-table nil "Abbrev table in use in C++-mode buffers.") (defvar c++-mode-map (make-sparse-keymap) "Keymap used in C++ mode.") (define-key c++-mode-map "\C-j" 'reindent-then-newline-and-indent) (define-key c++-mode-map "{" 'electric-c++-brace) (define-key c++-mode-map "}" 'electric-c++-brace) (define-key c++-mode-map ";" 'electric-c++-semi) (define-key c++-mode-map ":" 'electric-c++-terminator) (define-key c++-mode-map "\e\C-h" 'mark-c-function) (define-key c++-mode-map "\e\C-q" 'indent-c++-exp) (define-key c++-mode-map "\177" 'backward-delete-char-untabify) (define-key c++-mode-map "\t" 'c++-indent-line) (define-key c++-mode-map "\C-c\C-i" 'c++-insert-header) (define-key c++-mode-map "\C-c\C-\\" 'c++-macroize-region) (defconst c++-friend-offset -4 "*Offset of C++ friend class declarations relative to member declarations.") (defun c++-mode () "Major mode for editing C++ code. Very much like editing C code. Expression and list commands understand all C++ brackets. Tab indents for C++ code. Comments are delimited with /* ... */ {or with // ... <newline>} Paragraphs are separated by blank lines only. Delete converts tabs to spaces as it moves back. \\{c++-mode-map} Variables controlling indentation style: c-auto-newline Non-nil means automatically newline before and after braces, and after colons and semicolons, inserted in C code. c-indent-level Indentation of C statements within surrounding block. The surrounding block's indentation is the indentation of the line on which the open-brace appears. c-continued-statement-offset Extra indentation given to a substatement, such as the then-clause of an if or body of a while. c-brace-offset Extra indentation for line if it starts with an open brace. c-brace-imaginary-offset An open brace following other text is treated as if it were this far to the right of the start of its line. c-argdecl-indent Indentation level of declarations of C function arguments. c-label-offset Extra indentation for line that is a label, or case or default. c++-friend-offset Offset of C++ friend class declarations relative to member declarations. Turning on C++ mode calls the value of the variable c++-mode-hook with no args,if that value is non-nil." (interactive) (kill-all-local-variables) (use-local-map c++-mode-map) (setq major-mode 'c++-mode) (setq mode-name "C++") (define-abbrev-table 'c++-mode-abbrev-table ()) (setq local-abbrev-table c++-mode-abbrev-table) (if (not c++-mode-syntax-table) (let ((i 0)) (setq c++-mode-syntax-table (make-syntax-table)) (set-syntax-table c++-mode-syntax-table) (modify-syntax-entry ?\\ "\\") (modify-syntax-entry ?/ ". 12") (modify-syntax-entry ?\n ">") (modify-syntax-entry ?+ ".") (modify-syntax-entry ?- ".") (modify-syntax-entry ?= ".") (modify-syntax-entry ?% ".") (modify-syntax-entry ?< ".") (modify-syntax-entry ?> ".") (modify-syntax-entry ?\' "\"")) (set-syntax-table c++-mode-syntax-table)) (make-local-variable 'paragraph-start) (setq paragraph-start (concat "^$\\|" page-delimiter)) (make-local-variable 'paragraph-separate) (setq paragraph-separate paragraph-start) (make-local-variable 'indent-line-function) (setq indent-line-function 'c++-indent-line) (make-local-variable 'require-final-newline) (setq require-final-newline t) (make-local-variable 'comment-start) (setq comment-start "// ") (make-local-variable 'comment-end) (setq comment-end "") (make-local-variable 'comment-column) (setq comment-column 32) (make-local-variable 'comment-start-skip) (setq comment-start-skip "/\\*+ *\\|// *") (make-local-variable 'comment-indent-hook) (setq comment-indent-hook 'c++-comment-indent) (make-local-variable 'parse-sexp-ignore-comments) (setq parse-sexp-ignore-comments nil) (run-hooks 'c++-mode-hook)) ;; This is used by indent-for-comment ;; to decide how much to indent a comment in C++ code ;; based on its context. (defun c++-comment-indent () (let (cur-col) (save-excursion (skip-chars-backward " \t") (setq cur-col (current-column)) (end-of-line 0) (if (re-search-backward comment-start-skip (save-excursion (beginning-of-line 1) (point)) t) (if (= (current-column) 0) 0 (max (1+ cur-col) (current-column))) ; Else indent at comment column, except leave at least one space. (max (1+ cur-col) comment-column))))) (defun electric-c++-brace (arg) "Insert character and correct line's indentation." (interactive "P") (let (insertpos) (if (and (not arg) (eolp) (or (save-excursion (skip-chars-backward " \t") (bolp)) (if c-auto-newline (progn (c++-indent-line) (newline) t) nil))) (progn (insert last-command-char) (c++-indent-line nil) (if c-auto-newline (progn (setq insertpos (1- (point))) (newline) (c++-indent-line nil))) (save-excursion (if insertpos (goto-char (1+ insertpos))) (delete-char -1)))) (if insertpos (save-excursion (goto-char insertpos) (self-insert-command (prefix-numeric-value arg))) (self-insert-command (prefix-numeric-value arg))))) (defun electric-c++-semi (arg) "Insert character and correct line's indentation." (interactive "P") (if c-auto-newline (electric-c++-terminator arg) (self-insert-command (prefix-numeric-value arg)))) (defun electric-c++-terminator (arg) "Insert character and correct line's indentation." (interactive "P") (let (insertpos (end (point))) (if (and (not arg) (eolp) (not (save-excursion (beginning-of-line) (skip-chars-forward " \t") (or (= (following-char) ?#) (let ((pps (parse-partial-sexp (point) end))) (or (nth 3 pps) (nth 4 pps) (nth 5 pps))))))) (progn (insert last-command-char) (c++-indent-line nil) (and c-auto-newline (not (c-inside-parens-p)) (progn (setq insertpos (1- (point))) (newline) (c++-indent-line nil))) (save-excursion (if insertpos (goto-char (1+ insertpos))) (delete-char -1)))) (if insertpos (save-excursion (goto-char insertpos) (self-insert-command (prefix-numeric-value arg))) (self-insert-command (prefix-numeric-value arg))))) (defun c-inside-parens-p () (condition-case () (save-excursion (save-restriction (narrow-to-region (point) (progn (beginning-of-defun) (point))) (goto-char (point-max)) (= (char-after (or (scan-lists (point) -1 1) (point-min))) ?\())) (error nil))) (defun c++-indent-line (&optional whole-exp) "Indent current line as C++ code. Argument means shift any additional lines of grouping rigidly with thls line." (interactive "P") (let ((indent (calculate-c++-indent nil)) beg end shift-amt (case-fold-search nil) (pos (- (point-max) (point)))) (beginning-of-line) (setq beg (point)) (cond ((eq indent nil) (setq indent (current-indentation))) ((eq indent t) (setq indent (calculate-c-indent-within-comment))) ((looking-at "[ \t]*#") (setq indent 0)) (t (skip-chars-forward " \t") (if (listp indent) (setq indent (car indent))) (cond ((looking-at "\\(public\\|private\\|protected\\):") (setq indent (+ indent c-label-offset))) ((or (looking-at "case\\b") (and (looking-at "[A-Za-z]") (save-excursion (forward-sexp 1) (looking-at ":[^:]")))) (setq indent (max 1 (+ indent c-label-offset)))) ((looking-at "else\\b") (setq indent (save-excursion (c-backward-to-start-of-if) (current-indentation)))) ((looking-at "friend\[ \t]class[ \t]") (setq indent (+ indent c++-friend-offset))) ((= (following-char) ?}) (setq indent (- indent c-indent-level))) ((= (following-char) ?{) (setq indent (+ indent c-brace-offset)))))) (skip-chars-forward " \t") (setq shift-amt (- indent (current-column))) (if (zerop shift-amt) (if (> (- (point-max) pos) (point)) (goto-char (- (point-max) pos))) (delete-region beg (point)) (indent-to indent) ;; If initial point was within line's indentation, ;; position after the indentation. Else stay at same point in text. (if (> (- (point-max) pos) (point)) (goto-char (- (point-max) pos))) ;; If desired, shift remaining lines of expression the same amount. (and whole-exp (save-excursion (goto-char beg) (forward-sexp 1) (setq end (point)) (goto-char beg) (forward-line 1) (setq beg (point)) (> end beg)) (indent-code-rigidly beg end shift-amt "#"))))) (defun calculate-c++-indent (&optional parse-start) "Return appropriate indentation for current line as C++ code. In usual case returns an integer: the column to indent to. Returns nil if line starts inside a string, t if in a comment." (save-excursion (beginning-of-line) (let ((indent-point (point)) (case-fold-search nil) state containing-sexp) (if parse-start (goto-char parse-start) (beginning-of-defun)) (while (< (point) indent-point) (setq parse-start (point)) (setq state (parse-partial-sexp (point) indent-point 0)) (setq containing-sexp (car (cdr state)))) (cond ((or (nth 3 state) (nth 4 state)) ;; return nil or t if should not change this line (nth 4 state)) ((null containing-sexp) ;; Line is at top level. May be data or function definition, ;; or may be function argument declaration. ;; Indent like the previous top level line ;; unless that ends in a closeparen without semicolon, ;; in which case this line is the first argument decl. (goto-char indent-point) (skip-chars-forward " \t") (if (= (following-char) ?{) 0 ; Unless it starts a function body (c++-backward-to-noncomment (or parse-start (point-min))) (if (= (preceding-char) ?\)) c-argdecl-indent (current-indentation)))) ((/= (char-after containing-sexp) ?{) ;; line is expression, not statement: ;; indent to just after the surrounding open. (goto-char (1+ containing-sexp)) (current-column)) (t ;; Statement. Find previous non-comment character. (goto-char indent-point) (c++-backward-to-noncomment containing-sexp) (if (not (memq (preceding-char) '(nil ?\, ?\; ?} ?: ?\{))) ;; This line is continuation of preceding line's statement; ;; indent c-continued-statement-offset more than the ;; previous line of the statement. (progn (c-backward-to-start-of-continued-exp containing-sexp) (+ c-continued-statement-offset (current-column))) ;; This line starts a new statement. ;; Position following last unclosed open. (goto-char containing-sexp) ;; Is line first statement after an open-brace? (or ;; If no, find that first statement and indent like it. (save-excursion (forward-char 1) (while (progn (skip-chars-forward " \t\n") (looking-at (concat "#\\|/\\*\\|//" "\\|case[ \t]" "\\|[a-zA-Z0-9_$]*:[^:]" "\\|friend[ \t]class[ \t]"))) ;; Skip over comments and labels following openbrace. (cond ((= (following-char) ?\#) (forward-line 1)) ((looking-at "/\\*") (search-forward "*/" nil 'move)) ((looking-at "//\\|friend[ \t]class[ \t]") (forward-line 1)) (t (re-search-forward ":[^:]" nil 'move)))) ;; The first following code counts ;; if it is before the line we want to indent. (and (< (point) indent-point) (current-column))) ;; If no previous statement, ;; indent it relative to line brace is on. ;; For open brace in column zero, don't let statement ;; start there too. If c-indent-offset is zero, ;; use c-brace-offset + c-continued-statement-offset instead. ;; For open-braces not the first thing in a line, ;; add in c-brace-imaginary-offset. (+ (if (and (bolp) (zerop c-indent-level)) (+ c-brace-offset c-continued-statement-offset) c-indent-level) (if (save-excursion (skip-chars-backward " \t") (bolp)) 0 c-brace-imaginary-offset) (current-indentation))))))))) (defun calculate-c-indent-within-comment () "Return the indentation amount for line, assuming that the current line is to be regarded as part of a block comment." (let (end star-start) (save-excursion (beginning-of-line) (skip-chars-forward " \t") (setq star-start (= (following-char) ?\*)) (skip-chars-backward " \t\n") (setq end (point)) (beginning-of-line) (skip-chars-forward " \t") (and (re-search-forward "/\\*[ \t]*" end t) star-start (goto-char (1+ (match-beginning 0)))) (current-column)))) (defun c++-backward-to-noncomment (lim) (let (opoint stop) (while (not stop) (skip-chars-backward " \t\n\r\f" lim) (setq opoint (point)) (cond ((and (>= (point) (+ 2 lim)) (save-excursion (forward-char -2) (looking-at "\\*/"))) (search-backward "/*" lim 'move)) ((and (search-backward "//" (max (point-bol) lim) 'move) (not (within-string-p (point) opoint)))) (t (beginning-of-line) (skip-chars-forward " \t") (if (looking-at "#") (setq stop (<= (point) lim)) (setq stop t) (goto-char opoint))))))) (defun c-backward-to-start-of-continued-exp (lim) (if (= (preceding-char) ?\)) (forward-sexp -1)) (beginning-of-line) (if (<= (point) lim) (goto-char (1+ lim))) (skip-chars-forward " \t")) (defun c-backward-to-start-of-if (&optional limit) "Move to the start of the last ``unbalanced'' if." (or limit (setq limit (save-excursion (beginning-of-defun) (point)))) (let ((if-level 1) (case-fold-search nil)) (while (not (zerop if-level)) (backward-sexp 1) (cond ((looking-at "else\\b") (setq if-level (1+ if-level))) ((looking-at "if\\b") (setq if-level (1- if-level))) ((< (point) limit) (setq if-level 0) (goto-char limit)))))) (defun indent-c++-exp () "Indent each line of the C++ grouping following point." (interactive) (let ((indent-stack (list nil)) (contain-stack (list (point))) (case-fold-search nil) restart outer-loop-done inner-loop-done state ostate this-indent last-sexp at-else (opoint (point)) (next-depth 0)) (save-excursion (forward-sexp 1)) (save-excursion (setq outer-loop-done nil) (while (and (not (eobp)) (not outer-loop-done)) (setq last-depth next-depth) ;; Compute how depth changes over this line ;; plus enough other lines to get to one that ;; does not end inside a comment or string. ;; Meanwhile, do appropriate indentation on comment lines. (setq innerloop-done nil) (while (and (not innerloop-done) (not (and (eobp) (setq outer-loop-done t)))) (setq ostate state) (setq state (parse-partial-sexp (point) (progn (end-of-line) (point)) nil nil state)) (setq next-depth (car state)) (if (and (car (cdr (cdr state))) (>= (car (cdr (cdr state))) 0)) (setq last-sexp (car (cdr (cdr state))))) (if (or (nth 4 ostate)) (c++-indent-line)) (if (or (nth 3 state)) (forward-line 1) (setq innerloop-done t))) (if (<= next-depth 0) (setq outer-loop-done t)) (if outer-loop-done nil (if (/= last-depth next-depth) (setq last-sexp nil)) (while (> last-depth next-depth) (setq indent-stack (cdr indent-stack) contain-stack (cdr contain-stack) last-depth (1- last-depth))) (while (< last-depth next-depth) (setq indent-stack (cons nil indent-stack) contain-stack (cons nil contain-stack) last-depth (1+ last-depth))) (if (null (car contain-stack)) (setcar contain-stack (or (car (cdr state)) (save-excursion (forward-sexp -1) (point))))) (forward-line 1) (skip-chars-forward " \t") (if (eolp) nil (if (and (car indent-stack) (>= (car indent-stack) 0)) ;; Line is on an existing nesting level. ;; Lines inside parens are handled specially. (if (/= (char-after (car contain-stack)) ?{) (setq this-indent (car indent-stack)) ;; Line is at statement level. ;; Is it a new statement? Is it an else? ;; Find last non-comment character before this line (save-excursion (setq at-else (looking-at "else\\W")) (c++-backward-to-noncomment opoint) (if (not (memq (preceding-char) '(nil ?\, ?\; ?} ?: ?{))) ;; Preceding line did not end in comma or semi; ;; indent this line c-continued-statement-offset ;; more than previous. (progn (c-backward-to-start-of-continued-exp (car contain-stack)) (setq this-indent (+ c-continued-statement-offset (current-column)))) ;; Preceding line ended in comma or semi; ;; use the standard indent for this level. (if at-else (progn (c-backward-to-start-of-if opoint) (setq this-indent (current-indentation))) (setq this-indent (car indent-stack)))))) ;; Just started a new nesting level. ;; Compute the standard indent for this level. (let ((val (calculate-c++-indent (if (car indent-stack) (- (car indent-stack)))))) (setcar indent-stack (setq this-indent val)))) ;; Adjust line indentation according to its contents (if (looking-at "\\(public\\|private\\|protected\\):") (setq this-indent (- this-indent c-indent-level))) (if (and (looking-at "[A-Za-z]") (save-excursion (forward-sexp 1) (looking-at ":[^:]"))) (setq this-indent (max 1 (+ this-indent c-label-offset)))) (if (looking-at "case[ \t]") (setq this-indent (- this-indent c-indent-level))) (if (looking-at "friend[ \t]class[ \t]") (setq this-indent (- this-indent c-indent-level))) (if (= (following-char) ?}) (setq this-indent (- this-indent c-indent-level))) (if (= (following-char) ?{) (setq this-indent (+ this-indent c-brace-offset))) ;; Put chosen indentation into effect. (or (= (current-column) this-indent) (= (following-char) ?\#) (progn (delete-region (point) (progn (beginning-of-line) (point))) (indent-to this-indent))) ;; Indent any comment following the text. (or (looking-at comment-start-skip) (if (re-search-forward comment-start-skip (save-excursion (end-of-line) (point)) t) (progn (indent-for-comment) (beginning-of-line)))))))))) (defun fill-C-comment () (interactive) (save-excursion (let ((save fill-prefix)) (beginning-of-line 1) (save-excursion (re-search-forward comment-start-skip (save-excursion (end-of-line) (point)) t) (goto-char (match-end 0)) (set-fill-prefix)) (while (looking-at fill-prefix) (previous-line 1)) (next-line 1) (insert-string "\n") (fill-paragraph nil) (delete-char -1) (setq fill-prefix save)))) (defun point-bol () "Returns the value of the point at the beginning of the current line." (save-excursion (beginning-of-line) (point))) (defun previous-line-starts-with (string) "Returns t if previous nonblank line begins with STRING" (save-excursion (beginning-of-line 0) (skip-chars-forward " \t") (if (eolp) (previous-line-starts-with string) (looking-at string)))) (defun c++-insert-header () "Insert header denoting C++ code at top of buffer." (interactive) (save-excursion (goto-char (point-min)) (insert "// " "This may look like C code, but it is really " "-*- C++ -*-" "\n\n"))) (defun within-string-p (point1 point2) "Returns true if number of double quotes between two points is odd." (let ((s (buffer-substring point1 point2))) (not (zerop (mod (count-char-in-string ?\" s) 2))))) (defun count-char-in-string (c s) (let ((count 0) (pos 0)) (while (< pos (length s)) (setq count (+ count (if (\= (aref s pos) c) 1 0))) (setq pos (1+ pos))) count)) ;;; This page covers "macroization;" making C++ parameterized types ;;; via macros. (defconst c++-default-macroize-column 78 "Place to insert backslashes.") (defun c++-macroize-region (from to arg) "Insert backslashes at end of every line in region. Useful for defining cpp macros. If called with negative argument, will remove trailing backslashes, so that indentation will work right." (interactive "r\np") (save-excursion (goto-char from) (beginning-of-line 1) (let ((line (count-lines (point-min) (point))) (to-line (save-excursion (goto-char to) (count-lines (point-min) (point))))) (while (< line to-line) (backslashify-current-line (> arg 0)) (next-line 1) (setq line (1+ line)))))) (defun backslashify-current-line (doit) (end-of-line 1) (cond (doit ;; Note that "\\\\" is needed to get one backslash. (if (not (save-excursion (forward-char -1) (looking-at "\\\\"))) (progn (if (>= (current-column) c++-default-macroize-column) (insert " \\") (while (<= (current-column) c++-default-macroize-column) (insert "\t") (end-of-line)) (delete-char -1) (while (< (current-column) c++-default-macroize-column) (insert " ") (end-of-line)) (insert "\\"))))) (t (forward-char -1) (if (looking-at "\\\\") (progn (skip-chars-backward " \t") (kill-line))))))