Mercurial > emacs
diff lisp/obsolete/cplus-md.el @ 36927:f6b815c4d2de
Moved from progmodes/cplus-md.el to obsolete/cplus-md.el.
| author | Stefan Monnier <monnier@iro.umontreal.ca> |
|---|---|
| date | Wed, 21 Mar 2001 15:48:55 +0000 |
| parents | |
| children | f403516f2134 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lisp/obsolete/cplus-md.el Wed Mar 21 15:48:55 2001 +0000 @@ -0,0 +1,1080 @@ +;;; cplus-md.el --- old C++ code editing mode for Emacs + +;; Copyright (C) 1985, 1992, 1994, 1995 Free Software Foundation, Inc. + +;; Maintainer: FSF +;; Keywords: c + +;; This file is part of GNU Emacs. + +;; GNU Emacs is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation; either version 2, or (at your option) +;; any later version. + +;; GNU Emacs is distributed in the hope that it will be useful, +;; but WITHOUT ANY WARRANTY; without even the implied warranty of +;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +;; 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, +;; Boston, MA 02111-1307, USA. + +;;; Commentary: + +;; 1987 Dave Detlefs <dld@cs.cmu.edu> +;; and Stewart Clamen <clamen@cs.cmu.edu>. +;; Done by fairly faithful modification of: + +;;; Change Log: + +;; Feb, 1990 (Dave Detlefs, dld@cs.cmu.edu) +;; Fixed electric-c++-terminator to handle double colons, at the +;; request of John Hagerman. +;; +;; Jan, 1990 (Doug Lea, dl@oswego.edu) +;; Replaced c++-comment-region and c++-uncomment-region with +;; versions from Igor Metz that avoid potential infinite loops. +;; +;; Oct, 1989 (Dave Detlefs, dld@cs.cmu.edu) +;; Added contribution from Igor Metz <metz@iam.unibe.ch>: +;; functions c++-comment-region and c++-uncomment-region and +;; corresponding key-binding. +;; Also fixed bug in indentation of second line after an empty +;; arglist with empty-arglist non-null. +;; +;; Sept, 1989 (Glen Ditchfield, gjditchfield@violet.uwaterloo.ca): +;; Textual changes to more closely imitate Emacs 18.55's c-mode. +;; Fixed handling of "default:", where ":" was the last character in the +;; buffer. Fixed indentation of comments starting in column 0, and when +;; previous line contained more than one comment start string. Fixed +;; handling of "friend". +;; +;; Aug 7, 1989; John Hagerman (hagerman@ece.cmu.edu): +;; Changed calculate-c++-indent to handle member initializations +;; more flexibly. Two new variables are used to control behavior: +;; c++-member-init-indent and c++-continued-member-init-offset. +;; Note the assumption that member initializations and argument +;; declarations are not mixed in one function definition. +;; +;; June 1989 (Dave Detlefs, dld@cs.cmu.edu) +;; Fixed calculate-c++-indent to handle continued lines ending in +;; {'s. (I wasn't following C-mode closely enough, or C-mode +;; changed.) Made ' a quote character, at the behest of someone +;; whose mail I apparently deleted (if they send me mail I'll credit +;; them here in a future revision.) +;; Dan Weinreb (dlw@odi.com) pointed out that 'c++-mode successively +;; bound c++-indent-exp and c++-indent-defun to ESC-^q. ESC-^q is +;; now bound to c++-indent-exp, while, c++-indent-defun is invoked +;; with ESC-^x. + +;; February 1989 (Dave Detlefs, dld@cs.cmu.edu) +;; Fixed some errors in c++-indent-defun, as pointed out by Sam +;; Haradhvala (odi!sam@talcott.harvard.edu). +;; October 1988 (Dave Detlefs, dld@cs.cmu.edu) +;; It turns out I had only *thought* I had made +;; beginning(end)-of-defun work. It should work better now -- you +;; can either attempt to match defun headers "strongly," using a +;; very complicated regexp, or "weakly," using a simple one. This +;; is settable by a variable; the default is the cheaper weak +;; method. (Stewart Clamen was intimately involved in this, too.) +;; +;; I made "'" *not* be a string delimiter, because that was causing +;; comments containing contractions to ("// don't") to mess up paren +;; balancing. +;; +;; I also incorporated another slight indentation fix from Glen +;; Ditchfield. +;; +;; We hope this is will make into version 19 of gnu-emacs. +;; +;; September 1988: incorporated changes from Fred Calm at Schlumberger. +;; Also, made beginning(end)-of-defun, indent-defun work. +;; +;; August 1987: incorporated changes done by Glen Ditchfield of Waterloo. + +;;; Code: + +(defgroup old-c++ nil + "Old C++ code editing mode for Emacs." + ;; This group should have no parent. + ;; We don't want it to be loaded except on explicit request. + :prefix "c-") + +(defvar c++-mode-abbrev-table nil + "Abbrev table used in C++ mode.") +(define-abbrev-table 'c++-mode-abbrev-table ()) + +(defvar c++-mode-map () + "Keymap used in C++ mode.") +(if c++-mode-map + () + (setq c++-mode-map (make-sparse-keymap)) + (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 "\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-command) +;; (define-key c++-mode-map "\C-c\C-i" 'c++-insert-header) + (define-key c++-mode-map "\C-c\C-\\" 'c-backslash-region)) +;; (define-key c++-mode-map "\e\C-a" 'c++-beginning-of-defun) +;; (define-key c++-mode-map "\e\C-e" 'c++-end-of-defun) +;; (define-key c++-mode-map "\e\C-x" 'c++-indent-defun)) + +(defvar c++-mode-syntax-table nil + "Syntax table used in C++ mode.") + +(if c++-mode-syntax-table + () + (setq c++-mode-syntax-table (make-syntax-table)) + (modify-syntax-entry ?\\ "\\" c++-mode-syntax-table) + (modify-syntax-entry ?/ ". 14" c++-mode-syntax-table) + (modify-syntax-entry ?* ". 23" c++-mode-syntax-table) + (modify-syntax-entry ?+ "." c++-mode-syntax-table) + (modify-syntax-entry ?- "." c++-mode-syntax-table) + (modify-syntax-entry ?= "." c++-mode-syntax-table) + (modify-syntax-entry ?% "." c++-mode-syntax-table) + (modify-syntax-entry ?< "." c++-mode-syntax-table) + (modify-syntax-entry ?> "." c++-mode-syntax-table) + (modify-syntax-entry ?& "." c++-mode-syntax-table) + (modify-syntax-entry ?| "." c++-mode-syntax-table) + (modify-syntax-entry ?\' "\"" c++-mode-syntax-table) + (modify-syntax-entry ?* ". 23b" c++-mode-syntax-table) + (modify-syntax-entry ?/ ". 124" c++-mode-syntax-table) + (modify-syntax-entry ?\n ">" c++-mode-syntax-table) + (modify-syntax-entry ?\^m ">" c++-mode-syntax-table)) + +(defcustom c++-continued-member-init-offset nil + "*Extra indent for continuation lines of member inits; +nil means to align with previous initializations rather than +with the colon on the first line." + :type '(choice (const nil) integer) + :group 'old-c++) +(defcustom c++-member-init-indent 0 + "*Indentation level of member initializations in function declarations." + :type 'integer + :group 'old-c++) +(defcustom c++-friend-offset -4 + "*Offset of C++ friend declarations relative to member declarations." + :type 'integer + :group 'old-c++) +(defcustom c++-electric-colon t + "*If t, colon is an electric terminator." + :type 'boolean + :group 'old-c++) +(defcustom c++-empty-arglist-indent nil + "*Indicates how far to indent an line following an empty argument +list. Nil indicates to just after the paren." + :type '(choice (const nil) integer) + :group 'old-c++) + +(defvar c++-imenu-generic-expression + (` + ((nil + (, + (concat + "^" ; beginning of line is required + "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a "template <...>" + "\\([a-zA-Z0-9_:]+[ \t]+\\)?" ; type specs; there can be no + "\\([a-zA-Z0-9_:]+[ \t]+\\)?" ; more than 3 tokens, right? + + "\\(" ; last type spec including */& + "[a-zA-Z0-9_:]+" + "\\([ \t]*[*&]+[ \t]*\\|[ \t]+\\)" ; either pointer/ref sign or whitespace + "\\)?" ; if there is a last type spec + "\\(" ; name; take that into the imenu entry + "[a-zA-Z0-9_:~]+" ; member function, ctor or dtor... + ; (may not contain * because then + ; "a::operator char*" would become "char*"!) + "\\|" + "\\([a-zA-Z0-9_:~]*::\\)?operator" + "[^a-zA-Z1-9_][^(]*" ; ...or operator + " \\)" + "[ \t]*([^)]*)[ \t\n]*[^ ;]" ; require something other than a ; after + ; the (...) to avoid prototypes. Can't + ; catch cases with () inside the parentheses + ; surrounding the parameters + ; (like "int foo(int a=bar()) {...}" + + )) 6) + ("Class" + (, (concat + "^" ; beginning of line is required + "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a "template <...>" + "class[ \t]+" + "\\([a-zA-Z0-9_]+\\)" ; this is the string we want to get + "[ \t]*[:{]" + )) 2) +;; Example of generic expression for finding prototypes, structs, unions, enums. +;; Uncomment if you want to find these too. It will be a bit slower gathering +;; the indexes. +; ("Prototypes" +; (, +; (concat +; "^" ; beginning of line is required +; "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a "template <...>" +; "\\([a-zA-Z0-9_:]+[ \t]+\\)?" ; type specs; there can be no +; "\\([a-zA-Z0-9_:]+[ \t]+\\)?" ; more than 3 tokens, right? + +; "\\(" ; last type spec including */& +; "[a-zA-Z0-9_:]+" +; "\\([ \t]*[*&]+[ \t]*\\|[ \t]+\\)" ; either pointer/ref sign or whitespace +; "\\)?" ; if there is a last type spec +; "\\(" ; name; take that into the imenu entry +; "[a-zA-Z0-9_:~]+" ; member function, ctor or dtor... +; ; (may not contain * because then +; ; "a::operator char*" would become "char*"!) +; "\\|" +; "\\([a-zA-Z0-9_:~]*::\\)?operator" +; "[^a-zA-Z1-9_][^(]*" ; ...or operator +; " \\)" +; "[ \t]*([^)]*)[ \t\n]*;" ; require ';' after +; ; the (...) Can't +; ; catch cases with () inside the parentheses +; ; surrounding the parameters +; ; (like "int foo(int a=bar());" +; )) 6) +; ("Struct" +; (, (concat +; "^" ; beginning of line is required +; "\\(static[ \t]+\\)?" ; there may be static or const. +; "\\(const[ \t]+\\)?" +; "struct[ \t]+" +; "\\([a-zA-Z0-9_]+\\)" ; this is the string we want to get +; "[ \t]*[{]" +; )) 3) +; ("Enum" +; (, (concat +; "^" ; beginning of line is required +; "\\(static[ \t]+\\)?" ; there may be static or const. +; "\\(const[ \t]+\\)?" +; "enum[ \t]+" +; "\\([a-zA-Z0-9_]+\\)" ; this is the string we want to get +; "[ \t]*[{]" +; )) 3) +; ("Union" +; (, (concat +; "^" ; beginning of line is required +; "\\(static[ \t]+\\)?" ; there may be static or const. +; "\\(const[ \t]+\\)?" +; "union[ \t]+" +; "\\([a-zA-Z0-9_]+\\)" ; this is the string we want to get +; "[ \t]*[{]" +; )) 3) + )) + "Imenu generic expression for C++ mode. See `imenu-generic-expression'.") + +(defun c++-mode () + "Major mode for editing C++ code. Very much like editing C code. +Expression and list commands understand all C++ brackets. +Tab at left margin 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-tab-always-indent + Non-nil means TAB in C mode should always reindent the current line, + regardless of where in the line point is when the TAB command is used. + Default is t. + 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-continued-brace-offset + Extra indentation given to a brace that starts a substatement. + This is in addition to c-continued-statement-offset. + 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:'', or + ``public:'' or ``private:'', or ``protected:''. + c++-electric-colon + If non-nil at invocation of c++-mode (t is the default) colon electrically + indents. + c++-empty-arglist-indent + If non-nil, a function declaration or invocation which ends a line with a + left paren is indented this many extra spaces, instead of flush with the + left paren. + c++-friend-offset + Offset of C++ friend declarations relative to member declarations. + c++-member-init-indent + Indentation level of member initializations in function declarations, + if they are on a separate line beginning with a colon. + c++-continued-member-init-offset + Extra indentation for continuation lines of member initializations; NIL + means to align with previous initializations rather than with the colon. + +Settings for K&R, BSD, and Stroustrup indentation styles are + c-indent-level 5 8 4 + c-continued-statement-offset 5 8 4 + c-continued-brace-offset 0 + c-brace-offset -5 -8 0 + c-brace-imaginary-offset 0 + c-argdecl-indent 0 8 4 + c-label-offset -5 -8 -4 + c++-empty-arglist-indent 4 + c++-friend-offset 0 + +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) + ;; This code depends on the old C mode. + (require 'c-mode) + (use-local-map c++-mode-map) + (set-syntax-table c++-mode-syntax-table) + (setq major-mode 'c++-mode + mode-name "C++" + comment-column 32 + local-abbrev-table c++-mode-abbrev-table) + (set (make-local-variable 'indent-line-function) 'c++-indent-line) + (set (make-local-variable 'comment-start) "// ") + (set (make-local-variable 'comment-end) "") + (set (make-local-variable 'comment-start-skip) "/\\*+ *\\|// *") + (set (make-local-variable 'comment-indent-function) 'c++-comment-indent) + (set (make-local-variable 'paragraph-start) (concat "$\\|" page-delimiter)) + (set (make-local-variable 'paragraph-separate) paragraph-start) + (set (make-local-variable 'paragraph-ignore-fill-prefix) t) + (set (make-local-variable 'require-final-newline) t) + (set (make-local-variable 'parse-sexp-ignore-comments) t) + (make-local-variable 'imenu-generic-expression) + (setq imenu-generic-expression c++-imenu-generic-expression) + (setq imenu-case-fold-search nil) + (run-hooks 'c++-mode-hook) + (if c++-electric-colon + (define-key c++-mode-map ":" 'electric-c++-terminator))) + +;; 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 () + (if (looking-at "^\\(/\\*\\|//\\)") + 0 ; Existing comment at bol stays there. + (save-excursion + (skip-chars-backward " \t") + (max + ;; Leave at least one space on non-empty lines. + (if (zerop (current-column)) 0 (1+ (current-column))) + (let ((cur-pt (point))) + (beginning-of-line 0) + ;; If previous line had a comment, use its indentation. + (if (re-search-forward comment-start-skip cur-pt t) + (progn + (goto-char (match-beginning 0)) + (current-column)) + comment-column)))))) ; otherwise indent at 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)))) + (progn + (insert last-command-char) + (c++-indent-line) + (if c-auto-newline + (progn + (newline) + ;; (newline) may have done auto-fill + (setq insertpos (- (point) 2)) + (c++-indent-line))) + (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) ?#) + ;; Colon is special only after a label, or + ;; case, or another colon. + ;; So quickly rule out most other uses of colon + ;; and do no indentation for them. + (and (eq last-command-char ?:) + (or (not (or (looking-at "case[ \t]") + (save-excursion + (forward-word 1) + (skip-chars-forward " \t") + (>= (point) end)))) + ;; Do re-indent double colons + (save-excursion + (end-of-line 1) + (looking-at ":")))) + (progn + (beginning-of-defun) + (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) + (and c-auto-newline + (not (c-inside-parens-p)) + (progn + ;; the new marker object, used to be just an integer + (setq insertpos (make-marker)) + ;; changed setq to set-marker + (set-marker insertpos (1- (point))) + ;; do this before the newline, since in auto fill can break + (newline) + (c-indent-line))) + (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++-indent-command (&optional whole-exp) + "Indent current line as C++ code, or in some cases insert a tab character. +If `c-tab-always-indent' is non-nil (the default), always indent current +line. Otherwise, indent the current line only if point is at the left +margin or in the line's indentation; otherwise insert a tab. + +A numeric argument, regardless of its value, means indent rigidly all 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." + (interactive "P") + (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)) + beg end) + (save-excursion + (if c-tab-always-indent + (beginning-of-line)) + (setq beg (point)) + (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 "#"))) + (if (and (not c-tab-always-indent) + (save-excursion + (skip-chars-backward " \t") + (not (bolp)))) + (insert-tab) + (c++-indent-line)))) + +(defun c++-indent-line () + "Indent current line as C++ code. +Return the amount the indentation changed by." + (let ((indent (calculate-c++-indent nil)) + beg 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 "\\(default\\|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)))) + ((and (looking-at "else\\b") + (not (looking-at "else\\s_"))) + (setq indent (save-excursion + (c-backward-to-start-of-if) + (current-indentation)))) + ((looking-at "friend\[ \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)))) + 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 or member initialization. + ;; Indent like the previous top level line unless + ;; (1) the previous line ends in a closeparen without semicolon, + ;; in which case this line is the first argument declaration or + ;; member initialization, or + ;; (2) the previous line begins with a colon, + ;; in which case this is the second line of member inits. + ;; It is assumed that arg decls and member inits are not mixed. + (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) ?\)) + (progn ; first arg decl or member init + (goto-char indent-point) + (skip-chars-forward " \t") + (if (= (following-char) ?:) + c++-member-init-indent + c-argdecl-indent)) + (if (= (preceding-char) ?\;) + (backward-char 1)) + (if (= (preceding-char) ?}) + 0 + (if (= (preceding-char) ?\)) + (forward-list -1)) + (beginning-of-line) ; continued arg decls or member inits + (skip-chars-forward " \t") + (if (= (following-char) ?:) + (if c++-continued-member-init-offset + (+ (current-indentation) + c++-continued-member-init-offset) + (progn + (forward-char 1) + (skip-chars-forward " \t") + (current-column))) + (current-indentation))) + ))) + ((/= (char-after containing-sexp) ?{) + ;; line is expression, not statement: + ;; indent to just after the surrounding open -- unless + ;; empty arg list, in which case we do what + ;; c++-empty-arglist-indent says to do. + (if (and c++-empty-arglist-indent + (or (null (nth 2 state)) ;; indicates empty arg + ;; list. + ;; Use a heuristic: if the first + ;; non-whitespace following left paren on + ;; same line is not a comment, + ;; is not an empty arglist. + (save-excursion + (goto-char (1+ containing-sexp)) + (not + (looking-at "\\( \\|\t\\)*[^/\n]"))))) + (progn + (goto-char containing-sexp) + (beginning-of-line) + (skip-chars-forward " \t") + (goto-char (min (+ (point) c++-empty-arglist-indent) + (1+ containing-sexp))) + (current-column)) + ;; In C-mode, we would always indent to one after the + ;; left paren. Here, though, we may have an + ;; empty-arglist, so we'll indent to the min of that + ;; and the beginning of the first argument. + (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 (and (not (memq (preceding-char) '(0 ?\, ?\; ?\} ?\{))) + ;; But don't treat a line with a close-brace + ;; as a continuation. It is probably the + ;; end of an enum type declaration. + (save-excursion + (goto-char indent-point) + (skip-chars-forward " \t") + (not (= (following-char) ?})))) + ;; 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) + (if (save-excursion (goto-char indent-point) + (skip-chars-forward " \t") + (eq (following-char) ?{)) + c-continued-brace-offset 0))) + ;; 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) + (let ((colon-line-end 0)) + (while (progn (skip-chars-forward " \t\n") + (looking-at + (concat + "#\\|/\\*\\|//" + "\\|case[ \t]" + "\\|[a-zA-Z0-9_$]*:[^:]" + "\\|friend[ \t]"))) + ;; Skip over comments and labels following openbrace. + (cond ((= (following-char) ?\#) + (forward-line 1)) + ((looking-at "/\\*") + (search-forward "*/" nil 'move)) + ((looking-at "//\\|friend[ \t]") + (forward-line 1)) + (t + (save-excursion (end-of-line) + (setq colon-line-end (point))) + (search-forward ":")))) + ;; The first following code counts + ;; if it is before the line we want to indent. + (and (< (point) indent-point) + (- + (if (> colon-line-end (point)) + (- (current-indentation) c-label-offset) + (current-column)) + ;; If prev stmt starts with open-brace, that + ;; open brace was offset by c-brace-offset. + ;; Compensate to get the column where + ;; an ordinary statement would start. + (if (= (following-char) ?\{) c-brace-offset 0))))) + ;; 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) + ;; Move back over whitespace before the openbrace. + ;; If openbrace is not first nonwhite thing on the line, + ;; add the c-brace-imaginary-offset. + (progn (skip-chars-backward " \t") + (if (bolp) 0 c-brace-imaginary-offset)) + ;; If the openbrace is preceded by a parenthesized exp, + ;; move to the beginning of that; + ;; possibly a different line + (progn + (if (eq (preceding-char) ?\)) + (forward-sexp -1)) + ;; Get initial indentation of the line we are on. + (current-indentation)))))))))) + +(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 (c++-point-bol) lim) 'move) + (not (c++-within-string-p (point) opoint)))) + ;; No comment to be found. + ;; If there's a # command on this line, + ;; move back to it. + (t (beginning-of-line) + (skip-chars-forward " \t") + ;; But don't get fooled if we are already before the #. + (if (and (looking-at "#") (< (point) opoint)) + (setq stop (<= (point) lim)) + (setq stop t) + (goto-char opoint))))))) + +(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 last-depth + at-else at-brace + (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 inner-loop-done nil) + (while (and (not inner-loop-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 inner-loop-done t))) + (if (<= next-depth 0) + (setq outer-loop-done t)) + (if outer-loop-done + nil + ;; If this line had ..))) (((.. in it, pop out of the levels + ;; that ended anywhere in this line, even if the final depth + ;; doesn't indicate that they ended. + (while (> last-depth (nth 6 state)) + (setq indent-stack (cdr indent-stack) + contain-stack (cdr contain-stack) + last-depth (1- last-depth))) + (if (/= last-depth next-depth) + (setq last-sexp nil)) + ;; Add levels for any parens that were started in this line. + (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. + nil + ;; Just started a new nesting level. + ;; Compute the standard indent for this level. + (let (val) + (if (= (char-after (car contain-stack)) ?{) + (save-excursion + (goto-char (car contain-stack)) + (setq val (calculate-c-indent-after-brace))) + (setq val (calculate-c++-indent + (if (car indent-stack) + (- (car indent-stack)))))) + (setcar indent-stack val))) + ;; Adjust line indentation according to its predecessor. + (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")) + (setq at-brace (= (following-char) ?\{)) + (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) + (if at-brace c-continued-brace-offset 0)))) + ;; 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)))))) + ;; Adjust line indentation according to its contents + (if (looking-at "\\(public\\|private\\|protected\\):") + (setq this-indent (- this-indent c-indent-level)) + (if (or (looking-at "case[ \t]") + (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 "friend[ \t]") + (setq this-indent (+ this-indent c++-friend-offset))) + (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 () + "Fill a comment contained in consecutive lines containing point. +The fill lines remain a 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 c++-point-bol () + "Returns the value of the point at the beginning of the current line." + (save-excursion + (beginning-of-line) + (point))) + +;; (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 c++-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 (% (c++-count-char-in-string ?\" s) 2))))) + +(defun c++-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)) + +;; rms: This page is creeping featurism, and not worth having. + +;;; Below are two regular expressions that attempt to match defuns +;;; "strongly" and "weakly." The strong one almost reconstructs the +;;; grammar of C++; the weak one just figures anything id or curly on +;;; the left begins a defun. The constant "c++-match-header-strongly" +;;; determines which to use; the default is the weak one. + +;; (defvar c++-match-header-strongly nil +;; "*If nil, use `c++-defun-header-weak' to identify beginning of definitions. +;; If non-nil, use `c++-defun-header-strong'.") +;; +;; (defvar c++-defun-header-strong-struct-equivs "\\(class\\|struct\\|enum\\)" +;; "Regexp to match names of structure declaration blocks in C++.") +;; +;; (defconst c++-defun-header-strong +;; (let* +;; (; valid identifiers +;; ;; There's a real weirdness here -- if I switch the below +;; (id "\\(\\w\\|_\\)+") +;; ;; to be +;; ;; (id "\\(_\\|\\w\\)+") +;; ;; things no longer work right. Try it and see! +;; +;; ; overloadable operators +;; (op-sym1 +;; "[-+*/%^&|~!=<>]\\|[-+*/%^&|<>=!]=\\|<<=?\\|>>=?") +;; (op-sym2 +;; "&&\\|||\\|\\+\\+\\|--\\|()\\|\\[\\]") +;; (op-sym (concat "\\(" op-sym1 "\\|" op-sym2 "\\)")) +;; ; whitespace +;; (middle "[^\\*]*\\(\\*+[^/\\*][^\\*]*\\)*") +;; (c-comment (concat "/\\*" middle "\\*+/")) +;; (wh (concat "\\(\\s \\|\n\\|//.*$\\|" c-comment "\\)")) +;; (wh-opt (concat wh "*")) +;; (wh-nec (concat wh "+")) +;; (oper (concat "\\(" "operator" "\\(" +;; wh-opt op-sym "\\|" wh-nec id "\\)" "\\)")) +;; (dcl-list "([^():]*)") +;; (func-name (concat "\\(" oper "\\|" id "::" id "\\|" id "\\)")) +;; (inits +;; (concat "\\(:" +;; "\\(" wh-opt id "(.*\\()" wh-opt "," "\\)\\)*" +;; wh-opt id "(.*)" wh-opt "{" +;; "\\|" wh-opt "{\\)")) +;; (type-name (concat +;; "\\(" c++-defun-header-strong-struct-equivs wh-nec "\\)?" +;; id)) +;; (type (concat "\\(const" wh-nec "\\)?" +;; "\\(" type-name "\\|" type-name wh-opt "\\*+" "\\|" +;; type-name wh-opt "&" "\\)")) +;; (modifier "\\(inline\\|virtual\\|overload\\|auto\\|static\\)") +;; (modifiers (concat "\\(" modifier wh-nec "\\)*")) +;; (func-header +;; ;; type arg-dcl +;; (concat modifiers type wh-nec func-name wh-opt dcl-list wh-opt inits)) +;; (inherit (concat "\\(:" wh-opt "\\(public\\|private\\)?" +;; wh-nec id "\\)")) +;; (cs-header (concat +;; c++-defun-header-strong-struct-equivs +;; wh-nec id wh-opt inherit "?" wh-opt "{"))) +;; (concat "^\\(" func-header "\\|" cs-header "\\)")) +;; "Strongly-defined regexp to match beginning of structure or function def.") +;; +;; +;; ;; This part has to do with recognizing defuns. +;; +;; ;; The weak convention we will use is that a defun begins any time +;; ;; there is a left curly brace, or some identifier on the left margin, +;; ;; followed by a left curly somewhere on the line. (This will also +;; ;; incorrectly match some continued strings, but this is after all +;; ;; just a weak heuristic.) Suggestions for improvement (short of the +;; ;; strong scheme shown above) are welcomed. +;; +;; (defconst c++-defun-header-weak "^{\\|^[_a-zA-Z].*{" +;; "Weakly-defined regexp to match beginning of structure or function def.") +;; +;; (defun c++-beginning-of-defun (arg) +;; (interactive "p") +;; (let ((c++-defun-header (if c++-match-header-strongly +;; c++-defun-header-strong +;; c++-defun-header-weak))) +;; (cond ((or (= arg 0) (and (> arg 0) (bobp))) nil) +;; ((and (not (looking-at c++-defun-header)) +;; (let ((curr-pos (point)) +;; (open-pos (if (search-forward "{" nil 'move) +;; (point))) +;; (beg-pos +;; (if (re-search-backward c++-defun-header nil 'move) +;; (match-beginning 0)))) +;; (if (and open-pos beg-pos +;; (< beg-pos curr-pos) +;; (> open-pos curr-pos)) +;; (progn +;; (goto-char beg-pos) +;; (if (= arg 1) t nil));; Are we done? +;; (goto-char curr-pos) +;; nil)))) +;; (t +;; (if (and (looking-at c++-defun-header) (not (bobp))) +;; (forward-char (if (< arg 0) 1 -1))) +;; (and (re-search-backward c++-defun-header nil 'move (or arg 1)) +;; (goto-char (match-beginning 0))))))) +;; +;; +;; (defun c++-end-of-defun (arg) +;; (interactive "p") +;; (let ((c++-defun-header (if c++-match-header-strongly +;; c++-defun-header-strong +;; c++-defun-header-weak))) +;; (if (and (eobp) (> arg 0)) +;; nil +;; (if (and (> arg 0) (looking-at c++-defun-header)) (forward-char 1)) +;; (let ((pos (point))) +;; (c++-beginning-of-defun +;; (if (< arg 0) +;; (- (- arg (if (eobp) 0 1))) +;; arg)) +;; (if (and (< arg 0) (bobp)) +;; t +;; (if (re-search-forward c++-defun-header nil 'move) +;; (progn (forward-char -1) +;; (forward-sexp) +;; (beginning-of-line 2))) +;; (if (and (= pos (point)) +;; (re-search-forward c++-defun-header nil 'move)) +;; (c++-end-of-defun 1)))) +;; t))) +;; +;; (defun c++-indent-defun () +;; "Indents the current function definition, struct or class declaration." +;; (interactive) +;; (let ((restore (point))) +;; (c++-end-of-defun 1) +;; (beginning-of-line 1) +;; (let ((end (point))) +;; (c++-beginning-of-defun 1) +;; (while (<= (point) end) +;; (c++-indent-line) +;; (next-line 1) +;; (beginning-of-line 1))) +;; (goto-char restore))) + +(provide 'cplus-md) + +;;; cplus-md.el ends here