Mercurial > emacs
changeset 49967:4d32fa2a523d
Deleted. (Requires removed c-mode.el.)
| author | Dave Love <fx@gnu.org> |
|---|---|
| date | Mon, 24 Feb 2003 22:49:24 +0000 |
| parents | 4a0a4a66f5b1 |
| children | 80ed3e75ba10 |
| files | lisp/obsolete/cplus-md.el |
| diffstat | 1 files changed, 0 insertions(+), 1078 deletions(-) [+] |
line wrap: on
line diff
--- a/lisp/obsolete/cplus-md.el Mon Feb 24 17:29:49 2003 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1078 +0,0 @@ -;;; 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 a 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 "\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