Moved from progmodes/cplus-md.el to obsolete/cplus-md.el.

1 files changed, 1080 insertions, 0 deletions

diff --git a/lisp/obsolete/cplus-md.el b/lisp/obsolete/cplus-md.el
new file mode 100644
index 00000000000..52228bca82e
--- /dev/null
+++ b/lisp/obsolete/cplus-md.el
@@ -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