xemacs-beta: lisp/modes/cc-mode.el comparison

comparison lisp/modes/cc-mode.el @ 70:131b0175ea99 r20-0b30

Import from CVS: tag r20-0b30

author	cvs
date	Mon, 13 Aug 2007 09:02:59 +0200
parents	05472e90ae02
children	54cc21c15cbb

comparison

equal deleted inserted replaced

-:804d1389bcd6
+:131b0175ea99
 ;;; cc-mode.el --- major mode for editing C, C++, Objective-C, and Java code
-;; Copyright (C) 1985,87,92,93,94,95,96,97 Free Software Foundation, Inc.
+;; Copyright (C) 1985, 87, 92, 93, 94, 95, 96 Free Software Foundation, Inc.
-;; Authors: 1992-1997 Barry A. Warsaw
+;; Authors: 1992-1996 Barry A. Warsaw
 ;;          1987 Dave Detlefs and Stewart Clamen
 ;;          1985 Richard M. Stallman
 ;; Created: a long, long, time ago. adapted from the original c-mode.el
-;; Version:         4.389
+;; Version:         4.322
-;; Last Modified:   1997/03/28 16:48:31
+;; Last Modified:   1996/10/04 20:28:14
 ;; Keywords: c languages oop
 ;; NOTE: Read the commentary below for the right way to submit bug reports!
 ;; NOTE: See the accompanying texinfo manual for details on using this mode!
 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 ;; Boston, MA 02111-1307, USA.
 ;;; Commentary:
-;; This package provides GNU Emacs major modes for editing C, C++,
+;; This package provides modes in GNU Emacs for editing C, C++,
-;; Objective-C, and Java code.  As of the latest Emacs and XEmacs
+;; Objective-C, and Java code. It is intended to be a replacement for
-;; releases, it is the default package for editing these languages.
+;; c-mode.el (a.k.a. BOCM -- Boring Old C-Mode), and c++-mode.el
-;; This package is called "CC Mode", and should be spelled exactly
+;; (a.k.a cplus-md.el and cplus-md1.el), both of which are ancestors
-;; this way.  It supports K&R and ANSI C, ANSI C++, Objective-C, and
+;; of this file.  A number of important improvements have been made,
-;; Java, with a consistent indentation model across all modes.  This
+;; briefly: complete K&R C, ANSI C, `ARM' C++, Objective-C, and Java
-;; indentation model is intuitive and very flexible, so that almost
+;; support with consistent indentation across all modes, more
-;; any desired style of indentation can be supported.  Installation,
+;; intuitive indentation controlling variables, compatibility across
-;; usage, and programming details are contained in an accompanying
+;; all known Emacsen, nice new features, and tons of bug fixes.  This
-;; texinfo manual.
+;; package is called "cc-mode" to distinguish it from its ancestors,
+;; but there really is no top-level cc-mode.  Usage and programming
-;; CC Mode's immediate ancestors were, c++-mode.el, cplus-md.el, and
+;; details are contained in an accompanying texinfo manual.
-;; cplus-md1.el..
 ;; NOTE: This mode does not perform font-locking (a.k.a syntactic
-;; coloring, keyword highlighting, etc.) for any of the supported
+;; coloring, keyword highlighting, etc.).  Typically this is done by a
-;; modes.  Typically this is done by a package called font-lock.el
+;; package called font-lock.el which I do *not* maintain.  You should
-;; which I do *not* maintain.  You should contact the Emacs
+;; contact the Emacs maintainer for questions about coloring or
-;; maintainers for questions about coloring or highlighting in any
+;; highlighting in any language mode.
-;; language mode.
 ;; To submit bug reports, type "C-c C-b".  These will be sent to
 ;; bug-gnu-emacs@prep.ai.mit.edu as well as cc-mode-help@python.org,
 ;; and I'll read about them there (the former is mirrored as the
 ;; Usenet newsgroup gnu.emacs.bug).  Questions can sent to
-;; help-gnu-emacs@prep.ai.mit.edu (mirrored as gnu.emacs.help) and/or
+;; help-gnu-emacs@prep.ai.mit.edu (mirrored as gnu.emacs.help) or
 ;; cc-mode-help@python.org.  Please do not send bugs or questions to
 ;; my personal account.
 ;; YOU CAN IGNORE ALL BYTE-COMPILER WARNINGS. They are the result of
-;; the cross-Emacsen support.  GNU Emacs 19 (from the FSF), GNU XEmacs
+;; the multi-Emacsen support.  Emacs 19 (from the FSF), XEmacs 19
-;; 19 (formerly Lucid Emacs), and GNU Emacs 18 all do things
+;; (formerly Lucid Emacs), and GNU Emacs 18 all do things differently
-;; differently and there's no way to shut the byte-compiler up at the
+;; and there's no way to shut the byte-compiler up at the necessary
-;; necessary granularity.  Let me say this again: YOU CAN IGNORE ALL
+;; granularity.  Let me say this again: YOU CAN IGNORE ALL
 ;; BYTE-COMPILER WARNINGS (you'd be surprised at how many people don't
 ;; follow this advice :-).
+;; If your Emacs is dumped with c-mode.el and/or c++-mode.el, you will
+;; need to add the following to your .emacs file before any other
+;; reference to c-mode or c++-mode:
+;;
+;; (fmakunbound 'c-mode)
+;; (makunbound 'c-mode-map)
+;; (fmakunbound 'c++-mode)
+;; (makunbound 'c++-mode-map)
+;; (makunbound 'c-style-alist)
+;; If your Emacs comes with cc-mode already (and as of 5-Jul-1996
+;; XEmacs 19.14 and Emacs 19.31 both do), you only need to add the
+;; following to use the latest version of cc-mode:
+;;
+;; (load "cc-mode")
+;;
+;; Make sure the new version is earlier on your load-path.
+;; There are four major mode entry points provided by this package,
+;; one for editing C++ code, one for editing C code (both K&R and
+;; ANSI), one for editing Objective-C code, and one for editing Java
+;; code.  The commands are M-x c-mode, M-x c++-mode, M-x objc-mode,
+;; and M-x java-mode.
+;; If you are using an old version of Emacs which does not come
+;; with cc-mode.el, you will need to do these things
+;; to use it:
+;;
+;; (autoload 'c++-mode  "cc-mode" "C++ Editing Mode" t)
+;; (autoload 'c-mode    "cc-mode" "C Editing Mode" t)
+;; (autoload 'objc-mode "cc-mode" "Objective-C Editing Mode" t)
+;; (autoload 'java-mode "cc-mode" "Java Editing Mode" t)
+;; (setq auto-mode-alist
+;;   (append '(("\\.C$"    . c++-mode)
+;;             ("\\.cc$"   . c++-mode)
+;;             ("\\.c$"    . c-mode)
+;;             ("\\.h$"    . c-mode)
+;;             ("\\.m$"    . objc-mode)
+;;             ("\\.java$" . java-mode)
+;;            ) auto-mode-alist))
+;;
+;; You do not need these changes in Emacs versions that come with cc-mode.
 ;; Many, many thanks go out to all the folks on the beta test list.
 ;; Without their patience, testing, insight, code contributions, and
-;; encouragement CC Mode would be a far inferior package.
+;; encouragement cc-mode.el would be a far inferior package.
-;; You can get the latest version of CC Mode, including PostScript
+;; You can get the latest version of cc-mode, including PostScript
 ;; documentation and separate individual files from:
 ;;
 ;;     http://www.python.org/ftp/emacs/
 ;; Or if you don't have access to the World Wide Web, through
 (defvar c-echo-syntactic-information-p nil
 "*If non-nil, syntactic info is echoed when the line is indented.")
 (defvar c-basic-offset 4
 "*Amount of basic offset used by + and - symbols in `c-offsets-alist'.")
-(defconst c-offsets-alist
+(defvar c-offsets-alist
 '((string                . -1000)
 (c                     . c-lineup-C-comments)
 (defun-open            . 0)
 (defun-close           . 0)
 (defun-block-intro     . +)
 (class-open            . 0)
 (class-close           . 0)
 (inline-open           . +)
 (inline-close          . 0)
-(func-decl-cont        . +)
+(ansi-funcdecl-cont    . +)
 (knr-argdecl-intro     . +)
 (knr-argdecl           . 0)
 (topmost-intro         . 0)
 (topmost-intro-cont    . 0)
 (member-init-intro     . +)
 "*Association list of syntactic element symbols and indentation offsets.
 As described below, each cons cell in this list has the form:
 (SYNTACTIC-SYMBOL . OFFSET)
-When a line is indented, CC Mode first determines the syntactic
+When a line is indented, cc-mode first determines the syntactic
 context of the line by generating a list of symbols called syntactic
 elements.  This list can contain more than one syntactic element and
 the global variable `c-syntactic-context' contains the context list
 for the line being indented.  Each element in this list is actually a
 cons cell of the syntactic symbol and a buffer position.  This buffer
 position is called the relative indent point for the line.  Some
 syntactic symbols may not have a relative indent point associated with
 them.
-After the syntactic context list for a line is generated, CC Mode
+After the syntactic context list for a line is generated, cc-mode
 calculates the absolute indentation for the line by looking at each
 syntactic element in the list.  First, it compares the syntactic
 element against the SYNTACTIC-SYMBOL's in `c-offsets-alist'.  When it
 finds a match, it adds the OFFSET to the column of the relative indent
 point.  The sum of this calculation for each element in the syntactic
 list is the absolute offset for line being indented.
 If the syntactic element does not match any in the `c-offsets-alist',
-an error is generated if `c-strict-syntax-p' is non-nil, otherwise the
+an error is generated if `c-strict-syntax-p' is non-nil, otherwise
-element is ignored.
+the element is ignored.
 Actually, OFFSET can be an integer, a function, a variable, or one of
 the following symbols: `+', `-', `++', `--', `*', or `/'.  These
 latter designate positive or negative multiples of `c-basic-offset',
 respectively: *1, *-1, *2, *-2, *0.5, and *-0.5. If OFFSET is a
 defun-block-intro      -- the first line in a top-level defun
 class-open             -- brace that opens a class definition
 class-close            -- brace that closes a class definition
 inline-open            -- brace that opens an in-class inline method
 inline-close           -- brace that closes an in-class inline method
-func-decl-cont         -- the nether region between a function
+ansi-funcdecl-cont     -- the nether region between an ANSI function
-declaration and the defun opening brace.
+declaration and the defun opening brace
-In C++ and Java, this can include `throws'
-declarations
 knr-argdecl-intro      -- first line of a K&R C argument declaration
 knr-argdecl            -- subsequent lines in a K&R C argument declaration
 topmost-intro          -- the first line in a topmost construct definition
 topmost-intro-cont     -- topmost definition continuation lines
 member-init-intro      -- first line in a member initialization list
 (defvar c-tab-always-indent t
 "*Controls the operation of the TAB key.
 If t, hitting TAB always just indents the current line.  If nil,
 hitting TAB indents the current line if point is at the left margin or
 in the line's indentation, otherwise it insert a `real' tab character
-\(see note\).  If other than nil or t, then tab is inserted only
+\(see note\).  If other than nil or t, then tab is inserted only within
-within literals -- defined as comments and strings -- and inside
+literals -- defined as comments and strings -- and inside preprocessor
-preprocessor directives, but line is always reindented.
+directives, but line is always reindented.
 Note: The value of `indent-tabs-mode' will determine whether a real
 tab character will be inserted, or the equivalent number of space.
 When inserting a tab, actually the function stored in the variable
 `c-insert-tab-function' is called.
 "*Specifies how comment-only lines should be indented.
 When this variable is non-nil, comment-only lines are indented
 according to syntactic analysis via `c-offsets-alist', even when
 \\[indent-for-comment] is used.")
+(defvar c-block-comments-indent-p nil
+"*Specifies how to re-indent C style block comments.
+Examples of the supported styles of C block comment indentation are
+shown below.  When this variable is nil, block comments are indented
+as shown in styles 1 through 4.  If this variable is non-nil, block
+comments are indented as shown in style 5.
+Note that cc-mode does not automatically insert any stars or block
+comment delimiters.  You must type these in manually.  This variable
+only controls how the lines within the block comment are indented when
+you hit ``\\[c-indent-command]''.
+style 1:    style 2 (GNU):    style 3:     style 4:     style 5:
+/*          /* Blah           /*           /*           /*
+blah        blah.  */       * blah      ** blah      blah
+blah                        * blah      ** blah      blah
+*/                          */          */           */")
 (defvar c-cleanup-list '(scope-operator)
 "*List of various C/C++/ObjC constructs to \"clean up\".
-These clean ups only take place when the auto-newline feature is
+These clean ups only take place when the auto-newline feature is turned
-turned on, as evidenced by the `/a' or `/ah' appearing next to the
+on, as evidenced by the `/a' or `/ah' appearing next to the mode name.
-mode name.  Valid symbols are:
+Valid symbols are:
 brace-else-brace    -- cleans up `} else {' constructs by placing entire
-construct on a single line.  This clean up
+construct on a single line.  This clean up only
-only takes place when there is nothing but
+takes place when there is nothing but white
-white space between the braces and the `else'.
+space between the braces and the `else'.  Clean
-Clean up occurs when the open-brace after the
+			up occurs when the open-brace after the `else'
-`else' is typed.
+			is typed.
-brace-elseif-brace  -- similar to brace-else-brace, but cleans up
-`} else if {' constructs.
 empty-defun-braces  -- cleans up empty defun braces by placing the
 braces on the same line.  Clean up occurs when
 			the defun closing brace is typed.
 defun-close-semi    -- cleans up the terminating semi-colon on defuns
 			by placing the semi-colon on the same line as
 If every function in the list is called with no determination made,
 then no newline is inserted.")
 (defvar c-hanging-comment-ender-p t
-"*Controls what \\[fill-paragraph] does to C block comment enders.
+"*If nil, `c-fill-paragraph' leaves C block comment enders on their own line.
-When set to nil, C block comment enders are left on their own line.
+Default value is t, which inhibits leaving block comment ending string
-When set to t, block comment enders will be placed at the end of the
+`*/' on a line by itself.  This is BOCM's sole behavior.")
-previous line (i.e. they `hang' on that line).")
-(defvar c-hanging-comment-starter-p t
-"*Controls what \\[fill-paragraph] does to C block comment starters.
-When set to nil, C block comment starters are left on their own line.
-When set to t, text that follows a block comment starter will be
-placed on the same line as the block comment starter (i.e. the text
-`hangs' on that line).")
 (defvar c-backslash-column 48
 "*Column to insert backslashes when macroizing a region.")
 (defvar c-special-indent-hook nil
 "*Hook for user defined special indentation adjustments.
 (defvar c-delete-function 'backward-delete-char-untabify
 "*Function called by `c-electric-delete' when deleting characters.")
 (defvar c-electric-pound-behavior nil
 "*List of behaviors for electric pound insertion.
 Only currently supported behavior is `alignleft'.")
 (defvar c-label-minimum-indentation 1
-"*Minimum indentation for lines inside of top-level constructs.
+"*Minimum indentation for labels and case tags in `gnu' style.")
-This variable typically only affects code using the `gnu' style, which
-mandates a minimum of one space in front of every line inside
-top-level constructs.  Specifically, the function
-`c-gnu-impose-minimum' on your `c-special-indent-hook' is what
-enforces this.")
 (defvar c-progress-interval 5
 "*Interval used to update progress status during long re-indentation.
 If a number, percentage complete gets updated after each interval of
-that many seconds.  Set to nil to inhibit updating.  This is only
+that many seconds.   Set to nil to inhibit updating.  This is only
 useful for Emacs 19.")
 (defconst c-style-alist
 '(("gnu"
 (c-basic-offset . 2)
 (c-basic-offset . 3)
 (c-comment-only-line-offset . 0)
 (c-hanging-braces-alist     . ((substatement-open before after)))
 (c-offsets-alist . ((topmost-intro        . 0)
 (topmost-intro-cont   . 0)
-(substatement         . +)
+(substatement         . 3)
 			 (substatement-open    . 0)
+			 (statement-case-intro . 0)
 (case-label           . +)
-(access-label         . -)
+(access-label         . -3)
-(inclass              . ++)
+(inclass              . 6)
 (inline-open          . 0)
 ))
 )
 ("linux"
 (c-basic-offset  . 8)
 			 (substatement-open     . 0)
 			 (label                 . 0)
 			 (statement-cont        . +)
 			 ))
 )
-("python"
-(indent-tabs-mode . t)
-(c-basic-offset   . 8)
-(c-offsets-alist  . ((substatement-open . 0)
-			  ))
-(c-hanging-braces-alist . ((brace-list-open)
-				(brace-list-intro)
-				(brace-list-close)
-				(substatement-open after)
-				(block-close . c-snug-do-while)
-				))
-)
 ("java"
 (c-basic-offset . 2)
 (c-comment-only-line-offset . (0 . 0))
 (c-offsets-alist . ((statement-block-intro . +)
 			 (knr-argdecl-intro     . 5)
 			 (statement-case-open   . +)
 			 (statement-cont        . +)
 			 (arglist-intro . c-lineup-arglist-intro-after-paren)
 			 (arglist-close . c-lineup-arglist)
 			 (access-label  . 0)
-			 (inher-cont    . c-lineup-java-inher)
 			 ))
 )
 )
 "Styles of Indentation.
 Elements of this alist are of the form:
 (STYLE-STRING (VARIABLE . VALUE) [(VARIABLE . VALUE) ...])
 where STYLE-STRING is a short descriptive string used to select a
-style, VARIABLE is any CC Mode variable, and VALUE is the intended
+style, VARIABLE is any cc-mode variable, and VALUE is the intended
 value for that variable when using the selected style.
 There is one special case when VARIABLE is `c-offsets-alist'.  In this
 case, the VALUE is a list containing elements of the form:
 computed at the time the mode is loaded.")
 (defvar c-file-style nil
 "*Variable interface for setting style via File Local Variables.
 In a file's Local Variable section, you can set this variable to a
-string suitable for `c-set-style'.  When the file is visited, CC Mode
+string suitable for `c-set-style'.  When the file is visited, cc-mode
 will set the style of the file to this value automatically.
 Note that file style settings are applied before file offset settings
 as designated in the variable `c-file-offsets'.")
 (defvar c-file-offsets nil
 "*Variable interface for setting offsets via File Local Variables.
 In a file's Local Variable section, you can set this variable to an
 association list similar to the values allowed in `c-offsets-alist'.
-When the file is visited, CC Mode will institute these offset settings
+When the file is visited, cc-mode will institute these offset settings
 automatically.
 Note that file offset settings are applied after file style settings
 as designated in the variable `c-file-style'.")
 (defvar c-site-default-style "gnu"
 "Default style for your site.
 To change the default style at your site, you can set this variable to
-any style defined in `c-style-alist'.  However, if CC Mode is usually
+any style defined in `c-style-alist'.  However, if cc-mode is usually
 loaded into your Emacs at compile time, you will need to set this
-variable in the `site-init.el' file before CC Mode is loaded, then
+variable in the `site-init.el' file before cc-mode is loaded, then
 re-dump Emacs.")
-(defvar c-style-variables-are-local-p t
-"*Whether style variables should be buffer local by default.
-If non-nil, then all indentation style related variables will be made
-buffer local by default.  If nil, they will remain global.  Variables
-are made buffer local when this file is loaded, and once buffer
-localized, they cannot be made global again.
-The list of variables to buffer localize are:
-c-offsets-alist
-c-basic-offset
-c-file-style
-c-file-offsets
-c-comment-only-line-offset
-c-cleanup-list
-c-hanging-braces-alist
-c-hanging-colons-alist
-c-hanging-comment-starter-p
-c-hanging-comment-ender-p
-c-backslash-column
-c-label-minimum-indentation
-c-special-indent-hook
-c-indentation-style")
 (defvar c-mode-hook nil
 "*Hook called by `c-mode'.")
 (defvar c++-mode-hook nil
 "*Hook called by `c++-mode'.")
 (defvar objc-mode-hook nil
 "*Hook called by `objc-mode'.")
 (defvar java-mode-hook nil
 "*Hook called by `java-mode'.")
 (defvar c-mode-common-hook nil
-"*Hook called by all CC Mode modes for common initializations.")
+"*Hook called by all cc-mode modes for common initializations.")
 (defvar c-mode-menu
 '(["Comment Out Region"     comment-region (mark)]
 ["Macro Expand Region"    c-macro-expand (mark)]
 ["Backslashify"           c-backslash-region (mark)]
 ["Backward Conditional"   c-backward-conditional t]
 ["Forward Conditional"    c-forward-conditional t]
 ["Backward Statement"     c-beginning-of-statement t]
 ["Forward Statement"      c-end-of-statement t]
 )
-"Basic XEmacs 19 menu for C/C++/ObjC/Java modes.")
+"XEmacs 19 menu for C/C++/ObjC/Java modes.")
+;; Sadly we need this for a macro in Emacs 19.
-;; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+(eval-when-compile
-;; NO USER DEFINABLE VARIABLES BEYOND THIS POINT
+;; Imenu isn't used in XEmacs, so just ignore load errors.
+(condition-case ()
-;; imenu integration
+(require 'imenu)
+(error nil)))
 (defvar cc-imenu-c++-generic-expression
 (`
 ((nil
 (,
 (concat
-"^"				      ; beginning of line is required
+"^"				; beginning of line is required
-"\\(template[ \t]*<[^>]+>[ \t]*\\)?"   ; there may be a "template <...>"
+"\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a "template <...>"
-"\\([a-zA-Z0-9_:]+[ \t]+\\)?"	      ; type specs; there can be no
+"\\([a-zA-Z0-9_:]+[ \t]+\\)?"	; type specs; there can be no
-"\\([a-zA-Z0-9_:]+[ \t]+\\)?"	      ; more than 3 tokens, right?
+"\\([a-zA-Z0-9_:]+[ \t]+\\)?"	; more than 3 tokens, right?
-"\\("				      ; last type spec including */&
+"\\("				; last type spec including */&
 "[a-zA-Z0-9_:]+"
-"\\([ \t]*[*&]+[ \t]*\\|[ \t]+\\)"     ; either ptr/ref sign or ws
+"\\([ \t]*[*&]+[ \t]*\\|[ \t]+\\)" ; either pointer/ref sign or whitespace
-"\\)?"				      ; if there is a last type spec
+"\\)?"				; if there is a last type spec
-"\\("				      ; name, take into the imenu entry
+"\\("				; name; take that into the imenu entry
-"[a-zA-Z0-9_:~]+"		      ; member func, ctor or dtor...
+"[a-zA-Z0-9_:~]+"		; member function, ctor or dtor...
-					      ; (may not contain * because then
+					; (may not contain * because then
-					      ; "a::operator char*" would
+					; "a::operator char*" would become "char*"!)
-					      ; become "char*"!)
 "\\|"
 "\\([a-zA-Z0-9_:~]*::\\)?operator"
-"[^a-zA-Z1-9_][^(]*"		      ; ...or operator
+"[^a-zA-Z1-9_][^(]*"		; ...or operator
 " \\)"
-"[ \t]*([^)]*)[ \t\n]*[^		;]"   ; require something other than
+"[ \t]*([^)]*)[ \t\n]*[^		;]" ; require something other than a ; after
-					      ; a `;' after the (...) to
+					; the (...) to avoid prototypes.  Can't
-					      ; avoid prototypes.  Can't
+					; catch cases with () inside the parentheses
-					      ; catch cases with () inside
+					; surrounding the parameters
-					      ; the parentheses surrounding
+					; (like "int foo(int a=bar()) {...}"
-					      ; the parameters.  e.g.:
-					      ; "int foo(int a=bar()) {...}"
 )) 6)
 ("Class"
 (, (concat
-	 "^"				      ; beginning of line is required
+	 "^"				; beginning of line is required
 	 "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a "template <...>"
 	 "class[ \t]+"
-	 "\\([a-zA-Z0-9_]+\\)"		      ; the string we want to get
+	 "\\([a-zA-Z0-9_]+\\)"		; this is the string we want to get
 	 "[ \t]*[:{]"
 	 )) 2)))
 "Imenu generic expression for C++ mode.  See `imenu-generic-expression'.")
 (defvar cc-imenu-c-generic-expression
 cc-imenu-c++-generic-expression
 "Imenu generic expression for C mode.  See `imenu-generic-expression'.")
-;(defvar cc-imenu-objc-generic-expression
-;  ())
-; Please contribute one!
-(defvar cc-imenu-java-generic-expression
-(`
-((nil
-(,
-(concat
-"^\\([ \t]\\)*"
-"\\([A-Za-z0-9_-]+[ \t]+\\)?"	      ; type specs; there can be
-"\\([A-Za-z0-9_-]+[ \t]+\\)?"	      ; more than 3 tokens, right?
-"\\([A-Za-z0-9_-]+[ \t]*[[]?[]]?\\)"
-"\\([ \t]\\)"
-"\\([A-Za-z0-9_-]+\\)"		      ; the string we want to get
-"\\([ \t]*\\)+("
-"\\([a-zA-Z,_1-9\n \t]*[[]?[]]?\\)*"   ; arguments
-")[ \t]*"
-"[^;(]"
-"[,a-zA-Z_1-9\n \t]*{"
-)) 6)))
-"Imenu generic expression for Java mode.  See `imenu-generic-expression'.")
+;; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+;; NO USER DEFINABLE VARIABLES BEYOND THIS POINT
 ;; Shut the byte-compiler up. Requires Emacs 19 or JWZ's improved
 ;; byte-compiler. Otherwise, comment this line out and ignore
 ;; any warnings.
 ;;(byte-compiler-options (warnings nil))
 (let ((major (and (boundp 'emacs-major-version)
 		    emacs-major-version))
 	(minor (and (boundp 'emacs-minor-version)
 		    emacs-minor-version))
 	(re-suite 'old-re)
-	flavor comments infodock-p)
+	flavor comments)
 ;; figure out version numbers if not already discovered
 (and (or (not major) (not minor))
 	 (string-match "\\([0-9]+\\).\\([0-9]+\\)" emacs-version)
 	 (setq major (string-to-int (substring emacs-version
 					       (match-beginning 1)
 ((= major 18) (setq major 'v18))	;Emacs 18
 ((= major 4)  (setq major 'v18))	;Epoch 4
 ((= major 19) (setq major 'v19	;Emacs 19
 			 flavor (if (or (string-match "Lucid" emacs-version)
 					(string-match "XEmacs" emacs-version))
-				    'XEmacs 'FSF)
+				    'XEmacs 'FSF)))
-			 infodock-p (boundp 'infodock-version)))
 ((= major 20) (setq major 'v20	;XEmacs 20
 			 flavor 'XEmacs))
 ;; I don't know
 (t (error "Cannot recognize major version number: %s" major)))
 ;; Regular expression suites...
 	     (not c-inhibit-startup-warnings-p))
 	(with-output-to-temp-buffer "*cc-mode warnings*"
 	  (print (format
 "The version of Emacs that you are running, %s,
 has known bugs in its syntax.c parsing routines which will affect the
-performance of CC Mode. You should strongly consider upgrading to the
+performance of cc-mode. You should strongly consider upgrading to the
-latest available version.  CC Mode may continue to work, after a
+latest available version.  cc-mode may continue to work, after a
 fashion, but strange indentation errors could be encountered."
 		     emacs-version))))
 ;; Emacs 18, with no patch is not too good
 (if (and (eq major 'v18) (eq comments 'no-dual-comments)
 	     (not c-inhibit-startup-warnings-p))
 if you are doing much C++ editing, you should strongly consider
 upgrading to one of the latest Emacs 19's.  In Emacs 18, you may also
 experience performance degradations. Emacs 19 has some new built-in
 routines which will speed things up for you.
-Because of these inherent problems, CC Mode is no longer being
+Because of these inherent problems, cc-mode is no longer being
 actively maintained for Emacs 18, however, until you can upgrade to
-Emacs 19, you may want to look at cc-mode-18.el in the CC Mode
+Emacs 19, you may want to look at cc-mode-18.el in the cc-mode
 distribution.  THIS FILE IS COMPLETELY UNSUPPORTED!  If you use it,
 you are on your own, although patch contributions will be folded into
 the main release."
 			    emacs-version))))
 ;; Emacs 18 with the syntax patches are no longer supported
 	(with-output-to-temp-buffer "*cc-mode warnings*"
 	  (print (format
 "You are running a syntax patched Emacs 18 variant.  While this should
 work for you, you may want to consider upgrading to Emacs 19.  The
 syntax patches are no longer supported either for syntax.c or
-CC Mode."))))
+cc-mode."))))
-(if infodock-p
+(list major comments re-suite))
-	(list major comments re-suite 'infodock)
-(list major comments re-suite)))
 "A list of features extant in the Emacs you are using.
 There are many flavors of Emacs out there, each with different
-features supporting those needed by CC Mode.  Here's the current
+features supporting those needed by cc-mode.  Here's the current
 supported list, along with the values for this variable:
 Emacs 18/Epoch 4:           (v18 no-dual-comments RS)
 Emacs 18/Epoch 4 (patch2):  (v18 8-bit RS)
 XEmacs 19:                  (v19 8-bit RS)
 XEmacs 20:                  (v20 8-bit RS)
 Emacs 19:                   (v19 1-bit RS)
 RS is the regular expression suite to use.  XEmacs versions after
 19.13, and Emacs versions after 19.29 use the `new-re' regex suite.
-All other Emacsen use the `old-re' suite.
+All other Emacsen use the `old-re' suite.")
-Infodock (based on XEmacs) has an additional symbol on this list:
-'infodock")
 (defvar c++-mode-abbrev-table nil
 "Abbrev table in use in c++-mode buffers.")
 (define-abbrev-table 'c++-mode-abbrev-table ())
 (defvar java-mode-abbrev-table nil
 "Abbrev table in use in java-mode buffers.")
 (define-abbrev-table 'java-mode-abbrev-table ())
 (defun c-mode-fsf-menu (name map)
-;; Add menu to a keymap, but don't add them for XEmacs.  This
+;; Add menu to a keymap.  FSF menus suck.  Don't add them for
-;; feature test will fail on other than Emacs 19.
+;; XEmacs. This feature test will fail on other than Emacs 19.
 (condition-case nil
 (progn
 	(define-key map [menu-bar] (make-sparse-keymap))
 	(define-key map [menu-bar c] (cons name (make-sparse-keymap name)))
 	  '("Indent Expression" . c-indent-exp))
 	(define-key map [menu-bar c indent-line]
 	  '("Indent Line" . c-indent-command))
 	(define-key map [menu-bar c fill]
 	  '("Fill Comment Paragraph" . c-fill-paragraph))
-	(define-key map [menu-bar c separator2]
-	  '("----"))
 	(define-key map [menu-bar c up]
 	  '("Up Conditional" . c-up-conditional))
 	(define-key map [menu-bar c backward]
 	  '("Backward Conditional" . c-backward-conditional))
 	(define-key map [menu-bar c forward]
 (define-key c-mode-map "\C-c\C-m"  'c-mark-function)
 (define-key c-mode-map "\e\C-q"    'c-indent-exp)
 (define-key c-mode-map "\ea"       'c-beginning-of-statement)
 (define-key c-mode-map "\ee"       'c-end-of-statement)
 ;; Emacs 19.30 introduces fill-paragraph-function, but it's not in
-;; every version of Emacs CC Mode supports.
+;; every version of Emacs cc-mode supports.
 (if (not (boundp 'fill-paragraph-function))
 ;; I'd rather use an adaptive fill program instead of this.
 (define-key c-mode-map "\eq"   'c-fill-paragraph))
 (define-key c-mode-map "\C-c\C-n"  'c-forward-conditional)
 (define-key c-mode-map "\C-c\C-p"  'c-backward-conditional)
 (define-key c-mode-map "\C-c\C-d"  'c-toggle-hungry-state)
 (define-key c-mode-map "\C-c\C-e"  'c-macro-expand)
 (define-key c-mode-map "\C-c\C-o"  'c-set-offset)
 (define-key c-mode-map "\C-c\C-s"  'c-show-syntactic-information)
 (define-key c-mode-map "\C-c\C-t"  'c-toggle-auto-hungry-state)
-(define-key c-mode-map "\C-c."     'c-set-style)
 ;; conflicts with OOBR
 ;;(define-key c-mode-map "\C-c\C-v"  'c-version)
 ;;
-(if (and
+;; Emacs 19 defines menus in the mode map. This call will return
-;; Infodock has it's own menu
+;; t on Emacs 19, otherwise no-op and return nil.
-(not (memq 'infodock c-emacs-features))
+(if (and (not (c-mode-fsf-menu "CC-Mode" c-mode-map))
-;; Emacs 19 defines menus in the mode map. This call will
+	   ;; in XEmacs 19, we want the menu to popup when the 3rd
-;; return t on Emacs 19, otherwise no-op and return nil.
+	   ;; button is hit.  In Lucid Emacs 19.10 and beyond this is
-(not (c-mode-fsf-menu "CC Mode" c-mode-map))
+	   ;; done automatically if we put the menu on mode-popup-menu
-;; In XEmacs 19, we want the menu to popup when the 3rd button
+	   ;; variable, see c-common-init. Emacs 19 uses C-Mouse-3 for
-;; is hit.  In Lucid Emacs 19.10 and beyond this is done
+	   ;; this, and it works with no special effort.
-;; automatically if we put the menu on mode-popup-menu
+	   (boundp 'current-menubar)
-;; variable, see c-common-init. Emacs 19 uses C-Mouse-3 for
+	   (not (boundp 'mode-popup-menu)))
-;; this, and it works with no special effort.
-(boundp 'current-menubar)
-(not (boundp 'mode-popup-menu)))
 (define-key c-mode-map 'button3 'c-popup-menu)))
 (defvar c++-mode-map ()
 "Keymap used in c++-mode buffers.")
 (if c++-mode-map
 "Regexp describing C++ base classes in a derived class definition.")
 ;; defconst'd instead of defvar'd to override any old pre-loaded versions
 (defconst c-recognize-knr-p t
 "Non-nil means K&R style argument declarations are valid.")
-(defvar c-indentation-style c-site-default-style
-"Name of style installed in the current buffer.")
-;; these variables should always be buffer local.  they do not affect
-;; indentation styles.
-;;
 ;; minor mode variables
 (make-variable-buffer-local 'c-auto-newline)
 (make-variable-buffer-local 'c-hungry-delete-key)
 (make-variable-buffer-local 'c-auto-hungry-string)
 ;; language differences
 ;; style variables are made buffer local at tail end of this file.
 ;; cmacexp is lame because it uses no preprocessor symbols.
 ;; It isn't very extensible either -- hardcodes /lib/cpp.
 ;; [I add it here only because c-mode has it -- BAW]
-(autoload 'c-macro-expand "cmacexp"
+;(autoload 'c-macro-expand "cmacexp"
-"Display the result of expanding all C macros occurring in the region.
+;  "Display the result of expanding all C macros occurring in the region.
-The expansion is entirely correct because it uses the C preprocessor."
+;The expansion is entirely correct because it uses the C preprocessor."
-t)
+;  t)
 ;; constant regular expressions for looking at various constructs
 (defconst c-C++-class-key "\\(class\\|struct\\|union\\)"
 "Regexp describing a C++ class declaration, including templates.")
 (defconst c-C-class-key "\\(struct\\|union\\)"
 "Regexp describing a C struct declaration.")
 (defconst c-inher-key
 (concat "\\(\\<static\\>\\s +\\)?"
 	  c-C++-class-key "[ \t]+" c-symbol-key
-	  "\\([ \t]*:[ \t]*\\)\\s *[^;]")
+	  "\\([ \t]*:[ \t]*\\)?\\s *[^;]")
 "Regexp describing a class inheritance declaration.")
 (defconst c-switch-label-key
 "\\(\\(case[( \t]+\\S .*\\)\\|default[ \t]*\\):"
 "Regexp describing a switch's case or default label")
 (defconst c-C++-access-key
 	  "\\)\\b[^_]")
 "Regexp describing a conditional control for C++.")
 (defconst c-C++-friend-key
 "friend[ \t]+\\|template[ \t]*<.+>[ \t]*friend[ \t]+"
 "Regexp describing friend declarations in C++ classes.")
+(defconst c-C++-comment-start-regexp "//\\|/\\*"
-;; comment starter definitions for various languages.  the language
+"Dual comment value for `c-comment-start-regexp'.")
-;; modes will set c-comment-start-regexp to this value.
+(defconst c-C-comment-start-regexp "/\\*"
-(defconst c-C++-comment-start-regexp "/[/*]")
+"Single comment style value for `c-comment-start-regexp'.")
-(defconst c-C-comment-start-regexp "/[*]")
-;; We need to match all 3 Java style comments
-;; 1) Traditional C block; 2) javadoc /** ...; 3) C++ style
-(defconst c-Java-comment-start-regexp "/\\(/\\|[*][*]?\\)")
 (defconst c-ObjC-method-key
 (concat
 "^\\s *[+-]\\s *"
 "\\(([^)]*)\\)?"			; return type
 "\\(([^)]*)\\)?"			; return type
 ;; \\s- in java syntax table does not include \n
 ;; since it is considered the end of //-comments.
 "[ \t\n]*" c-symbol-key)
 "Regexp describing a Java method intro.")
-(defconst c-Java-access-key nil
+(defconst c-Java-access-key
-"Regexp describing access labels for Java.")
+(concat c-protection-key)
+"Regexp describing access specification keywords for Java.")
 (defconst c-Java-class-key
 (concat
-"\\(" c-protection-key "\\s +\\)?"
 "\\(interface\\|class\\)\\s +"
 c-symbol-key				;name of the class
 "\\(\\s *extends\\s *" c-symbol-key "\\)?" ;maybe followed by superclass
 ;;"\\(\\s *implements *[^{]+{\\)?"	;and maybe the adopted protocols list
 )
 "Regexp describing a class or protocol declaration for Java.")
-(defconst c-Java-special-key "\\(implements\\|extends\\|throws\\)[^_]"
-"Regexp describing Java inheritance and throws clauses.")
 (defconst c-Java-conditional-key
 (concat "\\b\\("
 	  (mapconcat 'identity
 		     (append '("try" "catch" "finally" "synchronized")
 			     c-C-conditionals) "\\|")
 	  "\\)\\b[^_]")
 "Regexp describing a conditional control for Java.")
-(defconst c-Java-defun-prompt-regexp
-"^[ \t]*\\(\\(\\(public\\|protected\\|private\\|const\\|abstract\\|synchronized\\|final\\|static\\|threadsafe\\|transient\\|native\\|volatile\\)\\s-+\\)*\\(\\(\\([[a-zA-Z][][_$.a-zA-Z0-9]*[][_$.a-zA-Z0-9]+\\|[[a-zA-Z]\\)\\s-*\\)\\s-+\\)\\)?\\(\\([[a-zA-Z][][_$.a-zA-Z0-9]*\\s-+\\)\\s-*\\)?\\([_a-zA-Z][^][ \t:;.,{}()=]*\\|\\([_$a-zA-Z][_$.a-zA-Z0-9]*\\)\\)\\s-*\\(([^);{}]*)\\)?\\([] \t]*\\)\\(\\s-*\\<throws\\>\\s-*\\(\\([_$a-zA-Z][_$.a-zA-Z0-9]*\\)[, \t\n\r\f]*\\)+\\)?\\s-*"
-"Regexp describing the beginning of a Java top-level definition.")
 ;; KLUDGE ALERT.  We default these variables to their `C' values so
 ;; that non-cc-mode-ized modes that depend on c-mode will still work
 ;; out of the box.  The most glaring example is awk-mode.  There ought
 ;; to be a better way.
 ;; main entry points for the modes
 (defconst c-list-of-mode-names nil)
-;;;###autoload
 (defun c-mode ()
 "Major mode for editing K&R and ANSI C code.
 To submit a problem report, enter `\\[c-submit-bug-report]' from a
 c-mode buffer.  This automatically sets up a mail buffer with version
 information already added.  You just need to add a description of the
 problem, including a reproducible test case and send the message.
-To see what version of CC Mode you are running, enter `\\[c-version]'.
+To see what version of cc-mode you are running, enter `\\[c-version]'.
 The hook variable `c-mode-hook' is run with no args, if that value is
 bound and has a non-nil value.  Also the hook `c-mode-common-hook' is
 run first.
 	imenu-generic-expression cc-imenu-c-generic-expression)
 (run-hooks 'c-mode-common-hook)
 (run-hooks 'c-mode-hook))
 (setq c-list-of-mode-names (cons "C" c-list-of-mode-names))
-;;;###autoload
 (defun c++-mode ()
 "Major mode for editing C++ code.
 To submit a problem report, enter `\\[c-submit-bug-report]' from a
 c++-mode buffer.  This automatically sets up a mail buffer with
 version information already added.  You just need to add a description
 of the problem, including a reproducible test case, and send the
 message.
-To see what version of CC Mode you are running, enter `\\[c-version]'.
+To see what version of cc-mode you are running, enter `\\[c-version]'.
 The hook variable `c++-mode-hook' is run with no args, if that
 variable is bound and has a non-nil value.  Also the hook
 `c-mode-common-hook' is run first.
 	imenu-generic-expression cc-imenu-c++-generic-expression)
 (run-hooks 'c-mode-common-hook)
 (run-hooks 'c++-mode-hook))
 (setq c-list-of-mode-names (cons "C++" c-list-of-mode-names))
-;;;###autoload
 (defun objc-mode ()
 "Major mode for editing Objective C code.
 To submit a problem report, enter `\\[c-submit-bug-report]' from an
 objc-mode buffer.  This automatically sets up a mail buffer with
 version information already added.  You just need to add a description
 of the problem, including a reproducible test case, and send the
 message.
-To see what version of CC Mode you are running, enter `\\[c-version]'.
+To see what version of cc-mode you are running, enter `\\[c-version]'.
 The hook variable `objc-mode-hook' is run with no args, if that value
 is bound and has a non-nil value.  Also the hook `c-mode-common-hook'
 is run first.
 	c-method-key c-ObjC-method-key)
 (run-hooks 'c-mode-common-hook)
 (run-hooks 'objc-mode-hook))
 (setq c-list-of-mode-names (cons "ObjC" c-list-of-mode-names))
-;;;###autoload
 (defun java-mode ()
 "Major mode for editing Java code.
 To submit a problem report, enter `\\[c-submit-bug-report]' from an
 java-mode buffer.  This automatically sets up a mail buffer with
 version information already added.  You just need to add a description
 of the problem, including a reproducible test case and send the
 message.
-To see what version of CC Mode you are running, enter `\\[c-version]'.
+To see what version of cc-mode you are running, enter `\\[c-version]'.
 The hook variable `java-mode-hook' is run with no args, if that value
 is bound and has a non-nil value.  Also the common hook
 `c-mode-common-hook' is run first.  Note that this mode automatically
 sets the \"java\" style before calling any hooks so be careful if you
 (c-common-init)
 (setq comment-start "// "
 	comment-end   ""
 	comment-multi-line nil
 	c-conditional-key c-Java-conditional-key
-	c-comment-start-regexp c-Java-comment-start-regexp
+	c-comment-start-regexp c-C++-comment-start-regexp
 	c-class-key c-Java-class-key
 	c-method-key c-Java-method-key
 	c-double-slash-is-comments-p t
 	c-baseclass-key nil
 	c-recognize-knr-p nil
-	c-access-key c-Java-access-key
+	c-access-key c-Java-access-key)
-	;defun-prompt-regexp c-Java-defun-prompt-regexp
-	imenu-generic-expression cc-imenu-java-generic-expression
-	)
 (c-set-style "java")
 (run-hooks 'c-mode-common-hook)
 (run-hooks 'java-mode-hook))
 (setq c-list-of-mode-names (cons "Java" c-list-of-mode-names))
 For use with the variable `java-mode-hook'."
 (c-set-style "java"))
 (defun c-common-init ()
 ;; Common initializations for c++-mode and c-mode.
-;;
+;; make local variables
-;; these variables should always be buffer local; they do not affect
-;; indentation style.
 (make-local-variable 'paragraph-start)
 (make-local-variable 'paragraph-separate)
 (make-local-variable 'paragraph-ignore-fill-prefix)
 (make-local-variable 'require-final-newline)
 (make-local-variable 'parse-sexp-ignore-comments)
 	indent-region-function 'c-indent-region
 	outline-regexp "[^#\n\^M]"
 	outline-level 'c-outline-level
 	comment-column 32
 	comment-start-skip "/\\*+ *\\|// *"
-	;; For all but XEmacs 19.13, the default should be nil
+	adaptive-fill-regexp nil)
-	adaptive-fill-regexp (and (memq 'v19 c-emacs-features)
-				  (= emacs-minor-version 13)
-				  "[ \t]*\\([#;>*]+ +\\)?")
-	)
 ;; we have to do something special for c-offsets-alist so that the
 ;; buffer local value has its own alist structure.
 (setq c-offsets-alist (copy-alist c-offsets-alist))
 ;; setup the comment indent variable in a Emacs version portable way
 ;; ignore any byte compiler warnings you might get here
 	   (make-local-variable 'comment-indent-function)
 	   (setq comment-indent-function 'c-comment-indent))
 (make-local-variable 'comment-indent-hook)
 (setq comment-indent-hook 'c-comment-indent))
 ;; Put C menu into menubar and on popup menu for XEmacs 19. I think
-;; this happens automatically for Emacs 19.  Skip it for Infodock.
+;; this happens automatically for Emacs 19.
-(if (and (not (memq 'infodock c-emacs-features))
+(if (and (boundp 'current-menubar)
-	   (boundp 'current-menubar)
 	   current-menubar
 	   (not (assoc mode-name current-menubar)))
 ;; its possible that this buffer has changed modes from one of
-;; the other CC Mode modes.  In that case, only the menubar
+;; the other cc-mode modes.  In that case, only the menubar
 ;; title of the menu changes.
 (let ((modes (copy-sequence c-list-of-mode-names))
 	    changed-p)
 	(setq modes (delete major-mode modes))
 	(while modes
 	    (setq modes nil
 		  changed-p t)))
 	(if (not changed-p)
 	    (progn
 	      (set-buffer-menubar (copy-sequence current-menubar))
-	      (if (fboundp 'add-submenu)
+	      (add-menu nil mode-name c-mode-menu)))))
-		  (add-submenu nil (c-mode-menu))
-		(add-menu nil mode-name c-mode-menu)
-		)))))
 (if (boundp 'mode-popup-menu)
-(setq mode-popup-menu (c-mode-menu)))
+(setq mode-popup-menu
+	    (cons (concat mode-name " Mode Commands") c-mode-menu)))
 ;; put auto-hungry designators onto minor-mode-alist, but only once
 (or (assq 'c-auto-hungry-string minor-mode-alist)
 (setq minor-mode-alist
 	    (cons '(c-auto-hungry-string c-auto-hungry-string)
 		  minor-mode-alist))))
 (c-setup-dual-comments c-mode-syntax-table)
 (setq-default c-C-comment-start-regexp c-C++-comment-start-regexp))
 ;; macros must be defined before first use
-(defmacro c-add-syntax (symbol &optional relpos)
-;; a simple macro to append the syntax in symbol to the syntax list.
-;; try to increase performance by using this macro
-(` (setq syntax (cons (cons (, symbol) (, relpos)) syntax))))
 (defmacro c-point (position)
 ;; Returns the value of point at certain commonly referenced POSITIONs.
 ;; POSITION can be one of the following symbols:
 ;;
 ;; bol  -- beginning of line
 	(if c-auto-newline
 	    (if c-hungry-delete-key "/ah" "/a")
 	  (if c-hungry-delete-key "/h" nil)))
 ;; updates the modeline for all Emacsen
 (if (or (memq 'v19 c-emacs-features) (memq 'v20 c-emacs-features))
-(if (boundp 'redraw-modeline)
+(force-mode-line-update)
-	  (redraw-modeline)
-	(force-mode-line-update))
 (set-buffer-modified-p (buffer-modified-p))))
 (defun c-calculate-state (arg prevstate)
 ;; Calculate the new state of PREVSTATE, t or nil, based on arg. If
 ;; arg is nil or zero, toggle the state. If arg is negative, turn
 		     (= mend here))
 		   (not (c-in-literal)))
 	      (progn
 		(delete-region mbeg mend)
 		(insert "} else {")))
-	  ;; clean up brace-elseif-brace
-	  (if (and c-auto-newline
-		   (memq 'brace-elseif-brace c-cleanup-list)
-		   (= last-command-char ?\{)
-		   (re-search-backward "}[ \t\n]*else[ \t\n]+if[ \t\n]*" nil t)
-		   (save-excursion
-		     (goto-char (match-end 0))
-		     (c-safe (forward-sexp 1))
-		     (skip-chars-forward " \t\n")
-		     (setq mbeg (match-beginning 0)
-			   mend (match-end 0))
-		     (= here (1+ (point))))
-		   (not (c-in-literal)))
-	      (progn
-		(delete-region mbeg mend)
-		(insert "} else if ")))
 	  (goto-char (- (point-max) pos))
 	  )
 	;; does a newline go after the brace?
 	(if (memq 'after newlines)
 	    (progn
 (put 'c-electric-delete 'delete-selection 'supersede) ; delsel
 (put 'c-electric-delete 'pending-delete   'supersede) ; pending-del
-(defvar c-read-offset-history nil)
 (defun c-read-offset (langelem)
 ;; read new offset value for LANGELEM from minibuffer. return a
 ;; legal value only
 (let* ((oldoff (cdr-safe (assq langelem c-offsets-alist)))
 	 (defstr (format "(default %s): " oldoff))
 			 "or in [+,-,++,--,*,/] "
 			 defstr))
 	 (prompt (concat "Offset " defstr))
 	 offset input interned raw)
 (while (not offset)
-(setq input (completing-read prompt obarray 'fboundp nil nil
+(setq input (read-string prompt)
-				   'c-read-offset-history)
 	    offset (cond ((string-equal "" input) oldoff)  ; default
 			 ((string-equal "+" input) '+)
 			 ((string-equal "-" input) '-)
 			 ((string-equal "++" input) '++)
 			 ((string-equal "--" input) '--)
 	    (add-hook 'c-special-indent-hook val)))
 	 (t (set attr val)))
 	)))
 stylevars))
-(defvar c-set-style-history nil)
-;;;###autoload
 (defun c-set-style (stylename)
-"Set CC Mode variables to use one of several different indentation styles.
+"Set cc-mode variables to use one of several different indentation styles.
 STYLENAME is a string representing the desired style from the list of
 styles described in the variable `c-style-alist'.  See that variable
-for details of setting up styles.
+for details of setting up styles."
-The variable `c-indentation-style' always contains the buffer's current
-style name."
 (interactive (list (let ((completion-ignore-case t)
 			   (prompt (format "Which %s indentation style? "
 					   mode-name)))
-		       (completing-read prompt c-style-alist nil t
+		       (completing-read prompt c-style-alist nil t))))
-					(cons c-indentation-style 0)
-					'c-set-style-history))))
 (let ((vars (cdr (or (assoc (downcase stylename) c-style-alist)
 		       (assoc (upcase stylename) c-style-alist)
 		       (assoc stylename c-style-alist)
 		       )))
 	(default (cdr (assoc "cc-mode" c-style-alist))))
 (or vars (error "Invalid indentation style `%s'" stylename))
 (or default (error "No `cc-mode' style found!"))
 ;; first reset the style to `cc-mode' to give every style a common
 ;; base. Then institute the new style.
 (c-set-style-1 default)
-(setq c-indentation-style stylename)
 (if (not (string= stylename "cc-mode"))
 	(c-set-style-1 vars)))
 (c-keep-region-active))
 (defun c-add-style (style descrip &optional set-p)
 			    ;; How shall we decide where the end of the
 			    ;; fill-prefix is?
 			    (progn
 			      (beginning-of-line)
 			      (skip-chars-forward " \t*" (c-point 'eol))
-			      ;; kludge alert, watch out for */, in
-			      ;; which case fill-prefix should *not*
-			      ;; be "*"!
-			      (if (and (= (following-char) ?/)
-				       (= (preceding-char) ?*))
-				  (forward-char -1))
 			      (point)))
 			 ;; If the comment is only one line followed
 			 ;; by a blank line, calling move-to-column
 			 ;; above may have added some spaces and tabs
 		;; Lines containing just a comment start or just an end
 		;; should not be filled into paragraphs they are next
 		;; to.
 		(paragraph-start (concat paragraph-start re1))
 		(paragraph-separate (concat paragraph-separate re1))
-		(chars-to-delete 0)
+		(chars-to-delete 0))
-		)
 	    (save-restriction
 	      ;; Don't fill the comment together with the code
 	      ;; following it.  So temporarily exclude everything
 	      ;; before the comment start, and everything after the
 	      ;; line where the comment ends.  If comment-start-place
 	      ;; point is inside the comment.
 	      (narrow-to-region (save-excursion
 				  (if comment-start-place
 				      (goto-char comment-start-place)
 				    (search-backward "/*"))
-				  (if (and (not c-hanging-comment-starter-p)
-					   (looking-at
-					    (concat c-comment-start-regexp
-						    "[ \t]*$")))
-				      (forward-line 1))
 				  ;; Protect text before the comment
 				  ;; start by excluding it.  Add
 				  ;; spaces to bring back proper
 				  ;; indentation of that point.
 				  (let ((column (current-column)))
 (goto-char lim)
 (setq state (parse-partial-sexp (point) here nil nil)))
 (if (and sentence-flag
 	     (or (nth 3 state)
 		 (nth 4 state)
-;		 (looking-at (concat "[ \t]*" comment-start-skip))
+		 (looking-at (concat "[ \t]*" comment-start-skip))
 		 (save-excursion
 		   (skip-chars-backward " \t")
 		   (goto-char (- (point) 2))
 		   (looking-at "\\*/"))))
 	(forward-sentence (- count))
 		     nil t))
 (c-beginning-of-statement (- (or count 1)) lim sentence-flag)
 (c-keep-region-active))
 ;; WARNING: Be *exceptionally* careful about modifications to this
-;; function!  Much of CC Mode depends on this Doing The Right Thing.
+;; function!  Much of cc-mode depends on this Doing The Right Thing.
 ;; If you break it you will be sorry.
 (defun c-beginning-of-statement-1 (&optional lim)
 ;; move to the start of the current statement, or the previous
 ;; statement if already at the beginning of one.
 (let ((firstp t)
 	donep c-in-literal-cache
 	;; KLUDGE ALERT: maybe-labelp is used to pass information
 	;; between c-crosses-statement-barrier-p and
 	;; c-beginning-of-statement-1.  A better way should be
 	;; implemented.
-	maybe-labelp saved
+	maybe-labelp
 	(last-begin (point)))
-;; first check for bare semicolon
+(while (not donep)
-(if (and (progn (c-backward-syntactic-ws lim)
+;; stop at beginning of buffer
-		    (= (preceding-char) ?\;))
+(if (bobp) (setq donep t)
-	     (c-safe (progn (forward-char -1)
+	;; go backwards one balanced expression, but be careful of
-			    (setq saved (point))
+	;; unbalanced paren being reached
-			    t))
+	(if (not (c-safe (progn (backward-sexp 1) t)))
-	     (progn (c-backward-syntactic-ws lim)
+	    (progn
-		    (memq (preceding-char) '(?\; ?{ ?} ?:)))
+	      (if firstp
-	     )
+		  (backward-up-list 1)
-	(setq last-begin saved)
+		(goto-char last-begin))
-(goto-char last-begin)
+	      ;; skip over any unary operators, or other special
-(while (not donep)
+	      ;; characters appearing at front of identifier
-	;; stop at beginning of buffer
+	      (save-excursion
-	(if (bobp) (setq donep t)
+		(c-backward-syntactic-ws lim)
-	  ;; go backwards one balanced expression, but be careful of
+		(skip-chars-backward "-+!*&:.~ \t\n")
-	  ;; unbalanced paren being reached
+		(if (= (preceding-char) ?\()
-	  (if (not (c-safe (progn (backward-sexp 1) t)))
+		    (setq last-begin (point))))
+	      (goto-char last-begin)
+	      (setq last-begin (point)
+		    donep t)))
+	(setq maybe-labelp nil)
+	;; see if we're in a literal. if not, then this bufpos may be
+	;; a candidate for stopping
+	(cond
+	 ;; CASE 0: did we hit the error condition above?
+	 (donep)
+	 ;; CASE 1: are we in a literal?
+	 ((eq (c-in-literal lim) 'pound)
+	  (beginning-of-line))
+	 ;; CASE 2: some other kind of literal?
+	 ((c-in-literal lim))
+	 ;; CASE 3: are we looking at a conditional keyword?
+	 ((or (looking-at c-conditional-key)
+	      (and (= (following-char) ?\()
+		   (save-excursion
+		     (forward-sexp 1)
+		     (c-forward-syntactic-ws)
+		     (/= (following-char) ?\;))
+		   (let ((here (point))
+			 (foundp (progn
+				   (c-backward-syntactic-ws lim)
+				   (forward-word -1)
+				   (and lim
+					(<= lim (point))
+					(not (c-in-literal lim))
+					(looking-at c-conditional-key)
+					))))
+		     ;; did we find a conditional?
+		     (if (not foundp)
+			 (goto-char here))
+		     foundp)))
+	  ;; are we in the middle of an else-if clause?
+	  (if (save-excursion
+		(and (not substmt-p)
+		     (c-safe (progn (forward-sexp -1) t))
+		     (looking-at "\\<else\\>[ \t\n]+\\<if\\>")
+		     (not (c-in-literal lim))))
 	      (progn
-		(if firstp
+		(forward-sexp -1)
-		    (backward-up-list 1)
+		(c-backward-to-start-of-if lim)))
-		  (goto-char last-begin))
+	  ;; are we sitting at an else clause, that we are not a
-		;; skip over any unary operators, or other special
+	  ;; substatement of?
-		;; characters appearing at front of identifier
+	  (if (and (not substmt-p)
-		(save-excursion
+		   (looking-at "\\<else\\>[^_]"))
-		  (c-backward-syntactic-ws lim)
+	      (c-backward-to-start-of-if lim))
-		  (skip-chars-backward "-+!*&:.~ \t\n")
+	  ;; are we sitting at the while of a do-while?
-		  (if (= (preceding-char) ?\()
+	  (if (and (looking-at "\\<while\\>[^_]")
-		      (setq last-begin (point))))
+		   (c-backward-to-start-of-do lim))
-		(goto-char last-begin)
+	      (setq substmt-p nil))
-		(setq last-begin (point)
+	  (setq last-begin (point)
-		      donep t)))
+		donep substmt-p))
+	 ;; CASE 4: are we looking at a label?
-	  (setq maybe-labelp nil)
+	 ((looking-at c-label-key))
-	  ;; see if we're in a literal. if not, then this bufpos may be
+	 ;; CASE 5: is this the first time we're checking?
-	  ;; a candidate for stopping
+	 (firstp (setq firstp nil
-	  (cond
+		       substmt-p (not (c-crosses-statement-barrier-p
-	   ;; CASE 0: did we hit the error condition above?
+				       (point) last-begin))
-	   (donep)
+		       last-begin (point)))
-	   ;; CASE 1: are we in a literal?
+	 ;; CASE 6: have we crossed a statement barrier?
-	   ((eq (c-in-literal lim) 'pound)
+	 ((c-crosses-statement-barrier-p (point) last-begin)
-	    (beginning-of-line))
+	  (setq donep t))
-	   ;; CASE 2: some other kind of literal?
+	 ;; CASE 7: ignore labels
-	   ((c-in-literal lim))
+	 ((and maybe-labelp
-	   ;; CASE 3: are we looking at a conditional keyword?
+	       (or (and c-access-key (looking-at c-access-key))
-	   ((or (looking-at c-conditional-key)
+		   ;; with switch labels, we have to go back further
-		(and (= (following-char) ?\()
+		   ;; to try to pick up the case or default
-		     (save-excursion
+		   ;; keyword. Potential bogosity alert: we assume
-		       (forward-sexp 1)
+		   ;; `case' or `default' is first thing on line
-		       (c-forward-syntactic-ws)
+		   (let ((here (point)))
-		       (/= (following-char) ?\;))
+		     (beginning-of-line)
-		     (let ((here (point))
+		     (c-forward-syntactic-ws)
-			   (foundp (progn
+		     (if (looking-at c-switch-label-key)
-				     (c-backward-syntactic-ws lim)
+			 t
-				     (forward-word -1)
+		       (goto-char here)
-				     (and lim
+		       nil))
-					  (<= lim (point))
+		   (looking-at c-label-key))))
-					  (not (c-in-literal lim))
+	 ;; CASE 8: ObjC or Java method def
-					  (looking-at c-conditional-key)
+	 ((and c-method-key
-					  ))))
+	       (setq last-begin (c-in-method-def-p)))
-		       ;; did we find a conditional?
+	  (setq donep t))
-		       (if (not foundp)
+	 ;; CASE 9: nothing special
-			   (goto-char here))
+	 (t (setq last-begin (point)))
-		       foundp)))
+	 )))
-	    ;; are we in the middle of an else-if clause?
-	    (if (save-excursion
-		  (and (not substmt-p)
-		       (c-safe (progn (forward-sexp -1) t))
-		       (looking-at "\\<else\\>[ \t\n]+\\<if\\>")
-		       (not (c-in-literal lim))))
-		(progn
-		  (forward-sexp -1)
-		  (c-backward-to-start-of-if lim)))
-	    ;; are we sitting at an else clause, that we are not a
-	    ;; substatement of?
-	    (if (and (not substmt-p)
-		     (looking-at "\\<else\\>[^_]"))
-		(c-backward-to-start-of-if lim))
-	    ;; are we sitting at the while of a do-while?
-	    (if (and (looking-at "\\<while\\>[^_]")
-		     (c-backward-to-start-of-do lim))
-		(setq substmt-p nil))
-	    (setq last-begin (point)
-		  donep substmt-p))
-	   ;; CASE 4: are we looking at a label?
-	   ((looking-at c-label-key))
-	   ;; CASE 5: is this the first time we're checking?
-	   (firstp (setq firstp nil
-			 substmt-p (not (c-crosses-statement-barrier-p
-					 (point) last-begin))
-			 last-begin (point)))
-	   ;; CASE 6: have we crossed a statement barrier?
-	   ((c-crosses-statement-barrier-p (point) last-begin)
-	    (setq donep t))
-	   ;; CASE 7: ignore labels
-	   ((and maybe-labelp
-		 (or (and c-access-key (looking-at c-access-key))
-		     ;; with switch labels, we have to go back further
-		     ;; to try to pick up the case or default
-		     ;; keyword. Potential bogosity alert: we assume
-		     ;; `case' or `default' is first thing on line
-		     (let ((here (point)))
-		       (beginning-of-line)
-		       (c-forward-syntactic-ws)
-		       (if (looking-at c-switch-label-key)
-			   t
-			 (goto-char here)
-			 nil))
-		     (looking-at c-label-key))))
-	   ;; CASE 8: ObjC or Java method def
-	   ((and c-method-key
-		 (setq last-begin (c-in-method-def-p)))
-	    (setq donep t))
-	   ;; CASE 9: nothing special
-	   (t (setq last-begin (point)))
-	   ))))
 (goto-char last-begin)
 ;; we always do want to skip over non-whitespace modifier
 ;; characters that didn't get skipped above
 (skip-chars-backward "-+!*&:.~" (c-point 'boi))))
 (beginning-of-line)
 (let (endmark)
 (unwind-protect
 	  (let ((c-tab-always-indent t)
 		;; shut up any echo msgs on indiv lines
-		(c-echo-syntactic-information-p nil)
+		(c-echo-syntactic-information-p nil))
-		fence)
 	    (c-progress-init start end 'c-indent-region)
 	    (setq endmark (copy-marker end))
 	    (while (and (bolp)
 			(not (eobp))
 			(< (point) endmark))
 		;; skip blank lines
 		(skip-chars-forward " \t\n")
 		(beginning-of-line)
 		;; indent the current line
 		(c-indent-line)
-		(setq fence (point))
 		(if (save-excursion
 		      (beginning-of-line)
 		      (looking-at "[ \t]*#"))
 		    (forward-line 1)
 		  (save-excursion
 			  ;; make sure the sexp we found really starts on the
 			  ;; current line and extends past it
 			  (goto-char sexpend)
 			  (setq sexpend (point-marker))
 			  (c-safe (backward-sexp 1))
-			  (setq sexpbeg (point))))
+			  (setq sexpbeg (point)))))
-		    (if (and sexpbeg (< sexpbeg fence))
-			(setq sexpbeg fence)))
 		  ;; check to see if the next line starts a
 		  ;; comment-only line
 		  (save-excursion
 		    (forward-line 1)
 		    (skip-chars-forward " \t")
 		     (c-indent-line)))
 		  ;; Move to following line and try again.
 		  (and sexpend
 		       (markerp sexpend)
 		       (set-marker sexpend nil))
-		  (forward-line 1)
+		  (forward-line 1)))))
-		  (setq fence (point))))))
 	(set-marker endmark nil)
 	(c-progress-fini 'c-indent-region)
 	))))
 (defun c-mark-function ()
 ))
 ;; defuns for calculating the syntactic state and indenting a single
 ;; line of C/C++/ObjC code
+(defmacro c-add-syntax (symbol &optional relpos)
+;; a simple macro to append the syntax in symbol to the syntax list.
+;; try to increase performance by using this macro
+(` (setq syntax (cons (cons (, symbol) (, relpos)) syntax))))
 (defun c-most-enclosing-brace (state)
 ;; return the bufpos of the most enclosing brace that hasn't been
 ;; narrowed out by any enclosing class, or nil if none was found
 (let (enclosingp)
 (while (and state (not enclosingp))
 	     (state fullstate)
 	     (in-method-intro-p (and c-method-key
 				     (looking-at c-method-key)))
 	     literal containing-sexp char-before-ip char-after-ip lim
 	     syntax placeholder c-in-literal-cache inswitch-p
-	     injava-inher
 	     ;; narrow out any enclosing class or extern "C" block
 	     (inclass-p (c-narrow-out-enclosing-class state indent-point))
 	     (inextern-p (and inclass-p
 			      (save-excursion
 				(save-restriction
 	 ;; CASE 2: in a C or C++ style comment.
 	 ((memq literal '(c c++))
 	  ;; we need to catch multi-paragraph C comments
 	  (while (and (zerop (forward-line -1))
 		      (looking-at "^[ \t]*$")))
-	  (c-add-syntax literal (c-point 'boi)))
+	  (c-add-syntax literal (c-point 'bol)))
 	 ;; CASE 3: in a cpp preprocessor
 	 ((eq literal 'pound)
 	  (c-beginning-of-macro lim)
 	  (c-add-syntax 'cpp-macro (c-point 'boi)))
 	 ;; CASE 4: in an objective-c method intro
 	     ((save-excursion
 		(c-beginning-of-statement-1 lim)
 		;; c-b-o-s could have left us at point-min
 		(and (bobp)
 		     (c-forward-syntactic-ws indent-point))
-		(if (looking-at "typedef[^_]")
+		(setq placeholder (point))
-		    (progn (forward-sexp 1)
-			   (c-forward-syntactic-ws indent-point)))
-		(setq placeholder (c-point 'boi))
 		(and (or (looking-at "enum[ \t\n]+")
 			 (= char-before-ip ?=))
 		     (save-excursion
 		       (skip-chars-forward "^;(" indent-point)
 		       (not (memq (following-char) '(?\; ?\()))
 	      (if (= (preceding-char) ?:)
 		  (progn (forward-char -1)
 			 (c-backward-syntactic-ws lim)))
 	      (if (= (preceding-char) ?\))
 		  (backward-sexp 1))
-	      (setq placeholder (point))
-	      (save-excursion
-		(and (c-safe (backward-sexp 1) t)
-		     (looking-at "throw[^_]")
-		     (c-safe (backward-sexp 1) t)
-		     (setq placeholder (point))))
-	      (goto-char placeholder)
 	      (c-add-syntax 'member-init-intro (c-point 'boi))
 	      ;; we don't need to add any class offset since this
 	      ;; should be relative to the ctor's indentation
 	      )
 	     ;; CASE 5B.2: K&R arg decl intro
 	     (c-recognize-knr-p
 	      (c-add-syntax 'knr-argdecl-intro (c-point 'boi))
 	      (and inclass-p (c-add-syntax 'inclass (aref inclass-p 0))))
-	     ;; CASE 5B.3: Nether region after a C++ or Java func
+	     ;; CASE 5B.3: Nether region after a C++ func decl, which
-	     ;; decl, which could include a `throws' declaration.
+	     ;; could include a `throw' declaration.
 	     (t
 	      (c-beginning-of-statement-1 lim)
-	      (c-add-syntax 'func-decl-cont (c-point 'boi))
+	      (c-add-syntax 'ansi-funcdecl-cont (c-point 'boi))
 	      )))
 	   ;; CASE 5C: inheritance line. could be first inheritance
 	   ;; line, or continuation of a multiple inheritance
 	   ((or (and c-baseclass-key (looking-at c-baseclass-key))
 		(and (or (= char-before-ip ?:)
-			 ;; watch out for scope operator
+			 (= char-after-ip ?:))
-			 (save-excursion
-			   (and (= char-after-ip ?:)
-				(c-safe (progn (forward-char 1) t))
-				(/= (following-char) ?:)
-				)))
 		     (save-excursion
 		       (c-backward-syntactic-ws lim)
 		       (if (= char-before-ip ?:)
 			   (progn
 			     (forward-char -1)
 			     (c-backward-syntactic-ws lim)))
 		       (back-to-indentation)
-		       (looking-at c-class-key)))
+		       (looking-at c-class-key))))
-		;; for Java
-		(and (eq major-mode 'java-mode)
-		     (let ((fence (save-excursion
-				    (c-beginning-of-statement-1 lim)
-				    (point)))
-			   cont done)
-		       (save-excursion
-			 (while (not done)
-			   (cond ((looking-at c-Java-special-key)
-				  (setq injava-inher (cons cont (point))
-					done t))
-				 ((or (not (c-safe (forward-sexp -1) t))
-				      (<= (point) fence))
-				  (setq done t))
-				 )
-			   (setq cont t)))
-		       injava-inher)
-		     (not (c-crosses-statement-barrier-p (cdr injava-inher)
-							 (point)))
-		     ))
 	    (cond
 	     ;; CASE 5C.1: non-hanging colon on an inher intro
 	     ((= char-after-ip ?:)
 	      (c-backward-syntactic-ws lim)
 	      (c-add-syntax 'inher-intro (c-point 'boi))
 	      )
 	     ;; CASE 5C.2: hanging colon on an inher intro
 	     ((= char-before-ip ?:)
 	      (c-add-syntax 'inher-intro (c-point 'boi))
 	      (and inclass-p (c-add-syntax 'inclass (aref inclass-p 0))))
-	     ;; CASE 5C.3: in a Java implements/extends
+	     ;; CASE 5C.3: a continued inheritance line
-	     (injava-inher
-	      (let ((where (cdr injava-inher))
-		    (cont (car injava-inher))
-		    (here (point)))
-		(goto-char where)
-		(cond ((looking-at "throws[^_]")
-		       (c-add-syntax 'func-decl-cont
-				     (progn (c-beginning-of-statement-1 lim)
-					    (c-point 'boi))))
-		      (cont (c-add-syntax 'inher-cont where))
-		      (t (c-add-syntax 'inher-intro
-				       (progn (goto-char (cdr injava-inher))
-					      (c-beginning-of-statement-1 lim)
-					      (point))))
-		      )))
-	     ;; CASE 5C.4: a continued inheritance line
 	     (t
 	      (c-beginning-of-inheritance-list lim)
 	      (c-add-syntax 'inher-cont (point))
 	      ;; don't add inclass symbol since relative point already
 	      ;; contains any class offset
 		 (let ((limit (save-excursion
 				(re-search-backward "^[^ \^L\t\n#]" nil 'move)
 				(point))))
 		   (save-excursion
 		     (c-backward-syntactic-ws limit)
-		     (setq placeholder (point))
 		     (while (and (memq (preceding-char) '(?\; ?,))
 				 (> (point) limit))
 		       (beginning-of-line)
 		       (setq placeholder (point))
 		       (c-backward-syntactic-ws limit))
 		       ;; watch out for scope operator
 		       (not (looking-at "::")))))
 	    (c-add-syntax 'statement-cont (c-point 'boi)))
 	   ;; CASE 15D: any old statement
 	   ((< (point) indent-point)
-	    (let ((safepos (c-most-enclosing-brace fullstate))
+	    (let ((safepos (c-most-enclosing-brace fullstate)))
-		  relpos done)
 	      (goto-char indent-point)
 	      (c-beginning-of-statement-1 safepos)
 	      ;; It is possible we're on the brace that opens a nested
 	      ;; function.
 	      (if (and (= (following-char) ?{)
 		       (save-excursion
 			 (c-backward-syntactic-ws safepos)
 			 (/= (preceding-char) ?\;)))
 		  (c-beginning-of-statement-1 safepos))
-	      (if (and inswitch-p
+	      (c-add-syntax 'statement (c-point 'boi))
-		       (looking-at c-switch-label-key))
-		  (progn
-		    (goto-char placeholder)
-		    (end-of-line)
-		    (forward-sexp -1)))
-	      (setq relpos (c-point 'boi))
-	      (while (and (not done)
-			  (<= safepos (point))
-			  (/= relpos (point)))
-		(c-beginning-of-statement-1 safepos)
-		(if (= relpos (c-point 'boi))
-		    (setq done t))
-		(setq relpos (c-point 'boi)))
-	      (c-add-syntax 'statement relpos)
 	      (if (= char-after-ip ?{)
 		  (c-add-syntax 'block-open))))
 	   ;; CASE 15E: first statement in an inline, or first
 	   ;; statement in a top-level defun. we can tell this is it
 	   ;; if there are no enclosing braces that haven't been
 	      (looking-at c-comment-start-regexp))
 	  (c-forward-syntactic-ws here))
 (- (current-column) cs-curcol)
 )))
-(defun c-lineup-java-inher (langelem)
-;; line up Java implements and extends continuations
-(save-excursion
-(let ((cs-curcol (progn (goto-char (cdr langelem))
-			    (current-column))))
-(forward-word 1)
-(if (looking-at "[ \t]*$")
-	  cs-curcol
-	(c-forward-syntactic-ws)
-	(- (current-column) cs-curcol)))))
 (defun c-lineup-C-comments (langelem)
 ;; line up C block comment continuation lines
 (save-excursion
-(let ((here (point))
+(let ((stars (progn
-	  (stars (progn (back-to-indentation)
+		   (beginning-of-line)
-			(skip-chars-forward "*")))
+		   (skip-chars-forward " \t")
+		   (if (looking-at "\\*\\*?")
+		       (- (match-end 0) (match-beginning 0))
+		     0)))
 	  (cs-curcol (progn (goto-char (cdr langelem))
 			    (current-column))))
 (back-to-indentation)
-(if (not (re-search-forward "/[*]+" (c-point 'eol) t))
+(if (re-search-forward "/\\*[ \t]*" (c-point 'eol) t)
-	  (progn
+	  (goto-char (+ (match-beginning 0)
-	    (if (not (looking-at "[*]+"))
+			(cond
-		(progn
+			 (c-block-comments-indent-p 0)
-		  ;; we now have to figure out where this comment begins.
+			 ((= stars 1) 1)
-		  (goto-char here)
+			 ((= stars 2) 0)
-		  (back-to-indentation)
+			 (t (- (match-end 0) (match-beginning 0)))))))
-		  (if (looking-at "[*]+/")
+(- (current-column) cs-curcol))))
-		      (progn (goto-char (match-end 0))
-			     (forward-comment -1))
-		    (goto-char (cdr langelem))
-		    (back-to-indentation))))
-	    (- (current-column) cs-curcol))
-	(if (zerop stars)
-	    (skip-chars-forward " \t"))
-	(- (current-column) stars cs-curcol))
-)))
 (defun c-lineup-comment (langelem)
 ;; support old behavior for comment indentation. we look at
 ;; c-comment-only-line-offset to decide how to indent comment
 ;; only-lines
 		      (looking-at "\\<do\\>[^_]")))
 	  '(before)
 	'(before after)))))
 (defun c-gnu-impose-minimum ()
-"Imposes a minimum indentation for lines inside a top-level construct.
+"Imposes a minimum indentation for labels and case tags.
 The variable `c-label-minimum-indentation' specifies the minimum
 indentation amount."
 (let ((non-top-levels '(defun-block-intro statement statement-cont
 			   statement-block-intro statement-case-intro
 			   statement-case-open substatement substatement-open
 			   (progn (skip-chars-backward " \t") (point)))))))
 ;; defuns for submitting bug reports
-(defconst c-version "4.389"
+(defconst c-version "4.322"
-"CC Mode version number.")
+"cc-mode version number.")
 (defconst c-mode-help-address
 "bug-gnu-emacs@prep.ai.mit.edu, cc-mode-help@python.org"
-"Address for CC Mode bug reports.")
+"Address for cc-mode bug reports.")
 (defun c-version ()
-"Echo the current version of CC Mode in the minibuffer."
+"Echo the current version of cc-mode in the minibuffer."
 (interactive)
-(message "Using CC Mode version %s" c-version)
+(message "Using cc-mode version %s" c-version)
 (c-keep-region-active))
 ;; get reporter-submit-bug-report when byte-compiling
 (eval-when-compile
 (require 'reporter))
 (defun c-submit-bug-report ()
-"Submit via mail a bug report on CC Mode."
+"Submit via mail a bug report on cc-mode."
 (interactive)
 ;; load in reporter
 (let ((reporter-prompt-for-summary-p t)
-	(reporter-dont-compact-list '(c-offsets-alist))
+	(reporter-dont-compact-list '(c-offsets-alist)))
-	(style c-indentation-style)
-	(hook c-special-indent-hook)
-	(c-features c-emacs-features))
 (and
-(if (y-or-n-p "Do you want to submit a report on CC Mode? ")
+(if (y-or-n-p "Do you want to submit a report on cc-mode? ")
 	 t (message "") nil)
 (require 'reporter)
 (reporter-submit-bug-report
 c-mode-help-address
-(concat "CC Mode " c-version " ("
+(concat "cc-mode " c-version " ("
 	      (cond ((eq major-mode 'c++-mode)  "C++")
 		    ((eq major-mode 'c-mode)    "C")
 		    ((eq major-mode 'objc-mode) "ObjC")
 		    ((eq major-mode 'java-mode) "Java")
 		    )
 	      ")")
 (let ((vars (list
 		   ;; report only the vars that affect indentation
 		   'c-basic-offset
 		   'c-offsets-alist
+		   'c-block-comments-indent-p
 		   'c-cleanup-list
 		   'c-comment-only-line-offset
 		   'c-backslash-column
 		   'c-delete-function
 		   'c-electric-pound-behavior
 		   'c-hanging-braces-alist
 		   'c-hanging-colons-alist
-		   'c-hanging-comment-starter-p
 		   'c-hanging-comment-ender-p
-		   'c-indent-comments-syntactically-p
 		   'c-tab-always-indent
 		   'c-recognize-knr-p
 		   'c-label-minimum-indentation
 		   'defun-prompt-regexp
 		   'tab-width
 	    (delq 'defun-prompt-regexp vars)
 	  vars))
 (function
 (lambda ()
 	 (insert
-	  "Buffer Style: " style "\n\n"
+	  (if c-special-indent-hook
-	  (if hook
 	      (concat "\n@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"
 		      "c-special-indent-hook is set to '"
-		      (format "%s" hook)
+		      (format "%s" c-special-indent-hook)
 		      ".\nPerhaps this is your problem?\n"
 		      "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n")
 	    "\n")
-	  (format "c-emacs-features: %s\n" c-features)
+	  (format "c-emacs-features: %s\n" c-emacs-features)
 	  )))
 nil
 "Dear Barry,"
 ))))
 ;; menus for XEmacs 19
-(defun c-mode-menu ()
-(cons (concat mode-name " Mode Commands") c-mode-menu))
 (defun c-popup-menu (e)
 "Pops up the C/C++/ObjC menu."
 (interactive "@e")
-(popup-menu (c-mode-menu))
+(popup-menu (cons (concat mode-name " Mode Commands") c-mode-menu))
 (c-keep-region-active))
 ;; Emacs/XEmacs Compatibility
-;; XEmacs has these, Emacs does not
+;; XEmacs has these, Emacs (even 19.31) does not
-(if (fboundp 'functionp)
+;; Lift XEmacs 19.13's functionp from subr.el
-(defalias 'c-functionp 'functionp)
+(defun c-functionp (obj)
-;; Lift XEmacs 19.13's functionp from subr.el
+"Returns t if OBJ is a function, nil otherwise."
-(defun c-functionp (obj)
+(cond
-"Returns t if OBJ is a function, nil otherwise."
+((symbolp obj) (fboundp obj))
-(cond
+((subrp obj))
-((symbolp obj) (fboundp obj))
+((compiled-function-p obj))
-((subrp obj))
+((consp obj)
-((compiled-function-p obj))
+(if (eq (car obj) 'lambda) (listp (car (cdr obj)))))
-((consp obj)
+(t nil)))
-(if (eq (car obj) 'lambda) (listp (car (cdr obj)))))
-(t nil))))
+(defun c-copy-tree (tree)
-(if (fboundp 'copy-tree)
-(defalias 'c-copy-tree 'copy-tree)
 ;; Lift XEmacs 19.12's copy-tree
-(defun c-copy-tree (tree)
+(if (consp tree)
-(if (consp tree)
+(cons (c-copy-tree (car tree))
-	(cons (c-copy-tree (car tree))
+	    (c-copy-tree (cdr tree)))
-	      (c-copy-tree (cdr tree)))
+(if (vectorp tree)
-(if (vectorp tree)
+	(let* ((new (copy-sequence tree))
-	  (let* ((new (copy-sequence tree))
+	       (i (1- (length new))))
-		 (i (1- (length new))))
+	  (while (>= i 0)
-	    (while (>= i 0)
+	    (aset new i (c-copy-tree (aref new i)))
-	      (aset new i (c-copy-tree (aref new i)))
+	    (setq i (1- i)))
-	      (setq i (1- i)))
+	  new)
-	    new)
+tree)))
-	tree))))
+(defun c-mapcar-defun (var)
+(let ((val (symbol-value var)))
+(cons var (if (atom val) val
+		;; XEmacs 19.12 and Emacs 19 + lucid.el have this
+		(if (fboundp 'copy-tree)
+		    (copy-tree val)
+		  ;; Emacs 19 and Emacs 18
+		  (c-copy-tree val)
+		  )))
+))
 ;; Dynamically append the default value of most variables. This is
 ;; crucial because future c-set-style calls will always reset the
 ;; variables first to the `cc-mode' style before instituting the new
 ;; style.  Only do this once!
 (or (assoc "cc-mode" c-style-alist)
 (progn
 (c-add-style "cc-mode"
-		   (mapcar
+		   (mapcar 'c-mapcar-defun
-		    (function
+			   '(c-backslash-column
-		     (lambda (var)
+			     c-basic-offset
-		       (let ((val (symbol-value var)))
+			     c-block-comments-indent-p
-			 (cons var (if (atom val) val
+			     c-cleanup-list
-				     (c-copy-tree val)
+			     c-comment-only-line-offset
-				     ))
+			     c-electric-pound-behavior
-			 )))
+			     c-hanging-braces-alist
-		    '(c-backslash-column
+			     c-hanging-colons-alist
-		      c-basic-offset
+			     c-hanging-comment-ender-p
-		      c-cleanup-list
+			     c-offsets-alist
-		      c-comment-only-line-offset
+			     )))
-		      c-electric-pound-behavior
-		      c-hanging-braces-alist
-		      c-hanging-colons-alist
-		      c-hanging-comment-starter-p
-		      c-hanging-comment-ender-p
-		      c-offsets-alist
-		      )))
 ;; the default style is now GNU.  This can be overridden in
 ;; c-mode-common-hook or {c,c++,objc,java}-mode-hook.
 (c-set-style c-site-default-style)))
-(if c-style-variables-are-local-p
+;; style variables
-(progn
+(make-variable-buffer-local 'c-offsets-alist)
-;; style variables
+(make-variable-buffer-local 'c-basic-offset)
-(make-variable-buffer-local 'c-offsets-alist)
+(make-variable-buffer-local 'c-file-style)
-(make-variable-buffer-local 'c-basic-offset)
+(make-variable-buffer-local 'c-file-offsets)
-(make-variable-buffer-local 'c-file-style)
+(make-variable-buffer-local 'c-comment-only-line-offset)
-(make-variable-buffer-local 'c-file-offsets)
+(make-variable-buffer-local 'c-block-comments-indent-p)
-(make-variable-buffer-local 'c-comment-only-line-offset)
+(make-variable-buffer-local 'c-cleanup-list)
-(make-variable-buffer-local 'c-cleanup-list)
+(make-variable-buffer-local 'c-hanging-braces-alist)
-(make-variable-buffer-local 'c-hanging-braces-alist)
+(make-variable-buffer-local 'c-hanging-colons-alist)
-(make-variable-buffer-local 'c-hanging-colons-alist)
+(make-variable-buffer-local 'c-hanging-comment-ender-p)
-(make-variable-buffer-local 'c-hanging-comment-starter-p)
+(make-variable-buffer-local 'c-backslash-column)
-(make-variable-buffer-local 'c-hanging-comment-ender-p)
+(make-variable-buffer-local 'c-label-minimum-indentation)
-(make-variable-buffer-local 'c-backslash-column)
+(make-variable-buffer-local 'c-special-indent-hook)
-(make-variable-buffer-local 'c-label-minimum-indentation)
-(make-variable-buffer-local 'c-special-indent-hook)
-(make-variable-buffer-local 'c-indentation-style)))
 ;; fsets for compatibility with BOCM
 (fset 'electric-c-brace      'c-electric-brace)
 (fset 'electric-c-semi       'c-electric-semi&comma)
 (fset 'electric-c-sharp-sign 'c-electric-pound)
-;; there is no CC Mode equivalent for electric-c-terminator
+;; there is no cc-mode equivalent for electric-c-terminator
 (fset 'mark-c-function       'c-mark-function)
 (fset 'indent-c-exp          'c-indent-exp)
 ;;;###autoload (fset 'set-c-style           'c-set-style)
-;; Lucid Emacs 19.9 + font-lock + CC Mode - c++-mode lossage
+;; Lucid Emacs 19.9 + font-lock + cc-mode - c++-mode lossage
 (fset 'c++-beginning-of-defun 'beginning-of-defun)
 (fset 'c++-end-of-defun 'end-of-defun)
 ;; set up bc warnings for obsolete variables, but for now lets not
 ;; worry about obsolete functions.  maybe later some will be important
 	      (cons 'c++-member-init-indent 'c-offsets-alist)
 	      (cons 'c++-friend-offset na)
 	      (cons 'c++-access-specifier-offset 'c-offsets-alist)
 	      (cons 'c++-empty-arglist-indent 'c-offsets-alist)
 	      (cons 'c++-comment-only-line-offset 'c-comment-only-line-offset)
-	      (cons 'c++-C-block-comments-indent-p na)
+	      (cons 'c++-C-block-comments-indent-p 'c-block-comments-indent-p)
 	      (cons 'c++-cleanup-list 'c-cleanup-list)
 	      (cons 'c++-hanging-braces 'c-hanging-braces-alist)
 	      (cons 'c++-hanging-member-init-colon 'c-hanging-colons-alist)
 	      (cons 'c++-auto-hungry-initial-state
 		    "Use `c-auto-newline' and `c-hungry-delete-key' instead.")
 	      (cons 'c-label-offset 'c-offsets-alist)
 	      (cons 'c-continued-statement-offset 'c-offsets-alist)
 	      (cons 'c-continued-brace-offset 'c-offsets-alist)
 	      (cons 'c-default-macroize-column 'c-backslash-column)
 	      (cons 'c++-default-macroize-column 'c-backslash-column)
-	      (cons 'c-block-comments-indent-p na)
 	      )))
 (mapcar
 	(function
 	 (lambda (elt)
 	   (make-obsolete-variable (car elt) (cdr elt))))

Mercurial > hg > xemacs-beta

comparison lisp/modes/cc-mode.el @ 70:131b0175ea99 r20-0b30