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

comparison lisp/modes/cc-mode.el @ 110:fe104dbd9147 r20-1b7

Import from CVS: tag r20-1b7

author	cvs
date	Mon, 13 Aug 2007 09:19:45 +0200
parents	c7528f8e288d
children	8619ce7e4c50

comparison

equal deleted inserted replaced

-:e183fc049578
+:fe104dbd9147
 ;;; cc-mode.el --- major mode for editing C, C++, Objective-C, and Java code
-;; Copyright (C) 1985, 87, 92, 93, 94, 95, 96 Free Software Foundation, Inc.
+;; Copyright (C) 1985,87,92,93,94,95,96,97 Free Software Foundation, Inc.
-;; Authors: 1992-1996 Barry A. Warsaw
+;; Authors: 1992-1997 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.322
+;; Version:         4.379
-;; Last Modified:   1996/10/04 20:28:14
+;; Last Modified:   1997/03/10 00:59:10
 ;; 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 modes in GNU Emacs for editing C, C++,
 ;; Objective-C, and Java code. It is intended to be a replacement for
-;; c-mode.el (a.k.a. BOCM -- Boring Old C-Mode), and c++-mode.el
+;; c-mode.el (a.k.a. BOCM -- Boring Old C-Mode), c++-mode.el,
-;; (a.k.a cplus-md.el and cplus-md1.el), both of which are ancestors
+;; cplus-md.el, and cplus-md1.el, all of which are in some way
-;; of this file.  A number of important improvements have been made,
+;; ancestors of this file.  A number of important improvements have
-;; briefly: complete K&R C, ANSI C, `ARM' C++, Objective-C, and Java
+;; been made, briefly: complete K&R C, ANSI C, `ARM' C++, Objective-C,
-;; support with consistent indentation across all modes, more
+;; and Java support with consistent indentation across all modes, more
 ;; intuitive indentation controlling variables, compatibility across
 ;; all known Emacsen, nice new features, and tons of bug fixes.  This
-;; package is called "cc-mode" to distinguish it from its ancestors,
+;; package is called "CC Mode" to distinguish it from its ancestors,
-;; but there really is no top-level cc-mode.  Usage and programming
+;; but there is no cc-mode command.  Usage and programming details are
-;; details are contained in an accompanying texinfo manual.
+;; contained in an accompanying texinfo manual.
 ;; NOTE: This mode does not perform font-locking (a.k.a syntactic
-;; coloring, keyword highlighting, etc.).  Typically this is done by a
+;; coloring, keyword highlighting, etc.) for any of the supported
-;; package called font-lock.el which I do *not* maintain.  You should
+;; modes.  Typically this is done by a package called font-lock.el
-;; contact the Emacs maintainer for questions about coloring or
+;; which I do *not* maintain.  You should contact the Emacs
-;; highlighting in any language mode.
+;; maintainers for questions about coloring or highlighting in any
+;; 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) or
+;; help-gnu-emacs@prep.ai.mit.edu (mirrored as gnu.emacs.help) and/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 multi-Emacsen support.  Emacs 19 (from the FSF), XEmacs 19
+;; the cross-Emacsen support.  GNU Emacs 19 (from the FSF), GNU XEmacs
-;; (formerly Lucid Emacs), and GNU Emacs 18 all do things differently
+;; 19 (formerly Lucid Emacs), and GNU Emacs 18 all do things
-;; and there's no way to shut the byte-compiler up at the necessary
+;; differently and there's no way to shut the byte-compiler up at the
-;; granularity.  Let me say this again: YOU CAN IGNORE ALL
+;; necessary 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
+;; As of this writing (24-Feb-1997), CC Mode comes with the latest
-;; need to add the following to your .emacs file before any other
+;; Emacs and XEmacs distributions (19.34 and 19.14 respectively), but
-;; reference to c-mode or c++-mode:
+;; is no longer pre-loaded by default.  To use the latest version of
-;;
+;; CC Mode, you need only make sure that this copy of cc-mode.el is
-;; (fmakunbound 'c-mode)
+;; found first on your load-path.
-;; (makunbound 'c-mode-map)
-;; (fmakunbound 'c++-mode)
+;; If your Emacs is pre-loaded with any version of cc-mode.el,
-;; (makunbound 'c++-mode-map)
+;; c-mode.el, or c++-mode.el, you will need to consult the
-;; (makunbound 'c-style-alist)
+;; cc-mode.texinfo manual for details on upgrading your Emacs.
-;; 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.el would be a far inferior package.
+;; encouragement CC Mode 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'.")
-(defvar c-offsets-alist
+(defconst 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)
-(ansi-funcdecl-cont    . +)
+(func-decl-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
+an error is generated if `c-strict-syntax-p' is non-nil, otherwise the
-the element is ignored.
+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
-ansi-funcdecl-cont     -- the nether region between an ANSI function
+func-decl-cont         -- the nether region between a 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 within
+\(see note\).  If other than nil or t, then tab is inserted only
-literals -- defined as comments and strings -- and inside preprocessor
+within literals -- defined as comments and strings -- and inside
-directives, but line is always reindented.
+preprocessor 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 turned
+These clean ups only take place when the auto-newline feature is
-on, as evidenced by the `/a' or `/ah' appearing next to the mode name.
+turned on, as evidenced by the `/a' or `/ah' appearing next to the
-Valid symbols are:
+mode name.  Valid symbols are:
 brace-else-brace    -- cleans up `} else {' constructs by placing entire
-construct on a single line.  This clean up only
+construct on a single line.  This clean up
-takes place when there is nothing but white
+only takes place when there is nothing but
-space between the braces and the `else'.  Clean
+white space between the braces and the `else'.
-			up occurs when the open-brace after the `else'
+Clean up occurs when the open-brace after the
-			is typed.
+`else' 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
-"*If nil, `c-fill-paragraph' leaves C block comment enders on their own line.
+"*Controls what \\[fill-paragraph] does to C block comment enders.
-Default value is t, which inhibits leaving block comment ending string
+When set to nil, C block comment enders are left on their own line.
-`*/' on a line by itself.  This is BOCM's sole behavior.")
+When set to t, block comment enders will be placed at the end of the
+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.
 "*Minimum indentation for labels and case tags in `gnu' style.")
 (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         . 3)
+(substatement         . +)
 			 (substatement-open    . 0)
-			 (statement-case-intro . 0)
 (case-label           . +)
-(access-label         . -3)
+(access-label         . -)
-(inclass              . 6)
+(inclass              . ++)
 (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]
 )
-"XEmacs 19 menu for C/C++/ObjC/Java modes.")
+"Basic XEmacs 19 menu for C/C++/ObjC/Java modes.")
-;; Sadly we need this for a macro in Emacs 19.
-(eval-when-compile
+;; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-;; Imenu isn't used in XEmacs, so just ignore load errors.
+;; NO USER DEFINABLE VARIABLES BEYOND THIS POINT
-(condition-case ()
-(require 'imenu)
+;; imenu integration
-(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 pointer/ref sign or whitespace
+"\\([ \t]*[*&]+[ \t]*\\|[ \t]+\\)"     ; either ptr/ref sign or ws
-"\\)?"				; if there is a last type spec
+"\\)?"				      ; if there is a last type spec
-"\\("				; name; take that into the imenu entry
+"\\("				      ; name, take into the imenu entry
-"[a-zA-Z0-9_:~]+"		; member function, ctor or dtor...
+"[a-zA-Z0-9_:~]+"		      ; member func, ctor or dtor...
-					; (may not contain * because then
+					      ; (may not contain * because then
-					; "a::operator char*" would become "char*"!)
+					      ; "a::operator char*" would
+					      ; 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 a ; after
+"[ \t]*([^)]*)[ \t\n]*[^		;]"   ; require something other than
-					; the (...) to avoid prototypes.  Can't
+					      ; a `;' after the (...) to
-					; catch cases with () inside the parentheses
+					      ; avoid prototypes.  Can't
-					; surrounding the parameters
+					      ; catch cases with () inside
-					; (like "int foo(int a=bar()) {...}"
+					      ; the parentheses surrounding
+					      ; 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_]+\\)"		; this is the string we want to get
+	 "\\([a-zA-Z0-9_]+\\)"		      ; 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)
+	flavor comments infodock-p)
 ;; 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."))))
-(list major comments re-suite))
+(if infodock-p
+	(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.  FSF menus suck.  Don't add them for
+;; Add menu to a keymap, but don't add them for XEmacs.  This
-;; XEmacs. This feature test will fail on other than Emacs 19.
+;; 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)
 ;;
-;; Emacs 19 defines menus in the mode map. This call will return
+(if (and
-;; t on Emacs 19, otherwise no-op and return nil.
+;; Infodock has it's own menu
-(if (and (not (c-mode-fsf-menu "CC-Mode" c-mode-map))
+(not (memq 'infodock c-emacs-features))
-	   ;; in XEmacs 19, we want the menu to popup when the 3rd
+;; Emacs 19 defines menus in the mode map. This call will
-	   ;; button is hit.  In Lucid Emacs 19.10 and beyond this is
+;; return t on Emacs 19, otherwise no-op and return nil.
-	   ;; done automatically if we put the menu on mode-popup-menu
+(not (c-mode-fsf-menu "CC Mode" c-mode-map))
-	   ;; variable, see c-common-init. Emacs 19 uses C-Mouse-3 for
+;; In XEmacs 19, we want the menu to popup when the 3rd button
-	   ;; this, and it works with no special effort.
+;; is hit.  In Lucid Emacs 19.10 and beyond this is done
-	   (boundp 'current-menubar)
+;; automatically if we put the menu on mode-popup-menu
-	   (not (boundp 'mode-popup-menu)))
+;; variable, see c-common-init. Emacs 19 uses C-Mouse-3 for
+;; 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.")
 "\\(([^)]*)\\)?"			; 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
+(defconst c-Java-access-key nil
-(concat c-protection-key)
+"Regexp describing access labels for Java.")
-"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.
 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.
 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.
 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.
 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-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 "/\\*+ *\\|// *"
-	adaptive-fill-regexp nil)
+	;; For all but XEmacs 19.13, the default should be 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.
+;; this happens automatically for Emacs 19.  Skip it for Infodock.
-(if (and (boundp 'current-menubar)
+(if (and (not (memq 'infodock c-emacs-features))
+	   (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))
-	      (add-menu nil mode-name c-mode-menu)))))
+	      (if (fboundp 'add-submenu)
+		  (add-submenu nil (c-mode-menu))
+		(add-menu nil mode-name c-mode-menu)
+		)))))
 (if (boundp 'mode-popup-menu)
-(setq mode-popup-menu
+(setq mode-popup-menu (c-mode-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))))
 	(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))
-(force-mode-line-update)
+(if (boundp 'redraw-modeline)
+	  (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 (read-string prompt)
+(setq input (completing-read prompt obarray 'fboundp nil nil
+				   '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)
 		;; 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 "/\\*[ \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
+	maybe-labelp saved
 	(last-begin (point)))
-(while (not donep)
+;; first check for bare semicolon
-;; stop at beginning of buffer
+(if (and (progn (c-backward-syntactic-ws lim)
-(if (bobp) (setq donep t)
+		    (= (preceding-char) ?\;))
-	;; go backwards one balanced expression, but be careful of
+	     (c-safe (progn (forward-char -1)
-	;; unbalanced paren being reached
+			    (setq saved (point))
-	(if (not (c-safe (progn (backward-sexp 1) t)))
+			    t))
-	    (progn
+	     (progn (c-backward-syntactic-ws lim)
-	      (if firstp
+		    (memq (preceding-char) '(?\; ?{ ?} ?:)))
-		  (backward-up-list 1)
+	     )
-		(goto-char last-begin))
+	(setq last-begin saved)
-	      ;; skip over any unary operators, or other special
+(goto-char last-begin)
-	      ;; characters appearing at front of identifier
+(while (not donep)
-	      (save-excursion
+	;; stop at beginning of buffer
-		(c-backward-syntactic-ws lim)
+	(if (bobp) (setq donep t)
-		(skip-chars-backward "-+!*&:.~ \t\n")
+	  ;; go backwards one balanced expression, but be careful of
-		(if (= (preceding-char) ?\()
+	  ;; unbalanced paren being reached
-		    (setq last-begin (point))))
+	  (if (not (c-safe (progn (backward-sexp 1) t)))
-	      (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
-		(forward-sexp -1)
+		(if firstp
-		(c-backward-to-start-of-if lim)))
+		    (backward-up-list 1)
-	  ;; are we sitting at an else clause, that we are not a
+		  (goto-char last-begin))
-	  ;; substatement of?
+		;; skip over any unary operators, or other special
-	  (if (and (not substmt-p)
+		;; characters appearing at front of identifier
-		   (looking-at "\\<else\\>[^_]"))
+		(save-excursion
-	      (c-backward-to-start-of-if lim))
+		  (c-backward-syntactic-ws lim)
-	  ;; are we sitting at the while of a do-while?
+		  (skip-chars-backward "-+!*&:.~ \t\n")
-	  (if (and (looking-at "\\<while\\>[^_]")
+		  (if (= (preceding-char) ?\()
-		   (c-backward-to-start-of-do lim))
+		      (setq last-begin (point))))
-	      (setq substmt-p nil))
+		(goto-char last-begin)
-	  (setq last-begin (point)
+		(setq last-begin (point)
-		donep substmt-p))
+		      donep t)))
-	 ;; CASE 4: are we looking at a label?
-	 ((looking-at c-label-key))
+	  (setq maybe-labelp nil)
-	 ;; CASE 5: is this the first time we're checking?
+	  ;; see if we're in a literal. if not, then this bufpos may be
-	 (firstp (setq firstp nil
+	  ;; a candidate for stopping
-		       substmt-p (not (c-crosses-statement-barrier-p
+	  (cond
-				       (point) last-begin))
+	   ;; CASE 0: did we hit the error condition above?
-		       last-begin (point)))
+	   (donep)
-	 ;; CASE 6: have we crossed a statement barrier?
+	   ;; CASE 1: are we in a literal?
-	 ((c-crosses-statement-barrier-p (point) last-begin)
+	   ((eq (c-in-literal lim) 'pound)
-	  (setq donep t))
+	    (beginning-of-line))
-	 ;; CASE 7: ignore labels
+	   ;; CASE 2: some other kind of literal?
-	 ((and maybe-labelp
+	   ((c-in-literal lim))
-	       (or (and c-access-key (looking-at c-access-key))
+	   ;; CASE 3: are we looking at a conditional keyword?
-		   ;; with switch labels, we have to go back further
+	   ((or (looking-at c-conditional-key)
-		   ;; to try to pick up the case or default
+		(and (= (following-char) ?\()
-		   ;; keyword. Potential bogosity alert: we assume
+		     (save-excursion
-		   ;; `case' or `default' is first thing on line
+		       (forward-sexp 1)
-		   (let ((here (point)))
+		       (c-forward-syntactic-ws)
-		     (beginning-of-line)
+		       (/= (following-char) ?\;))
-		     (c-forward-syntactic-ws)
+		     (let ((here (point))
-		     (if (looking-at c-switch-label-key)
+			   (foundp (progn
-			 t
+				     (c-backward-syntactic-ws lim)
-		       (goto-char here)
+				     (forward-word -1)
-		       nil))
+				     (and lim
-		   (looking-at c-label-key))))
+					  (<= lim (point))
-	 ;; CASE 8: ObjC or Java method def
+					  (not (c-in-literal lim))
-	 ((and c-method-key
+					  (looking-at c-conditional-key)
-	       (setq last-begin (c-in-method-def-p)))
+					  ))))
-	  (setq donep t))
+		       ;; did we find a conditional?
-	 ;; CASE 9: nothing special
+		       (if (not foundp)
-	 (t (setq last-begin (point)))
+			   (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
+		  (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 ()
 	     (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 'bol)))
+	  (c-add-syntax literal (c-point 'boi)))
 	 ;; 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))
-		(setq placeholder (point))
+		(if (looking-at "typedef[^_]")
+		    (progn (forward-sexp 1)
+			   (c-forward-syntactic-ws indent-point)))
+		(setq placeholder (c-point 'bol))
 		(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++ func decl, which
+	     ;; CASE 5B.3: Nether region after a C++ or Java func
-	     ;; could include a `throw' declaration.
+	     ;; decl, which could include a `throws' declaration.
 	     (t
 	      (c-beginning-of-statement-1 lim)
-	      (c-add-syntax 'ansi-funcdecl-cont (c-point 'boi))
+	      (c-add-syntax 'func-decl-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 ?:)
-			 (= char-after-ip ?:))
+			 ;; watch out for scope operator
+			 (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))
+		)
 	    (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: a continued inheritance line
+	     ;; CASE 5C.3: in a Java implements/extends
+	     (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))
-	      (c-add-syntax 'statement (c-point 'boi))
+	      (if (and inswitch-p
+		       (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 ((stars (progn
+(let ((here (point))
-		   (beginning-of-line)
+	  (stars (progn (back-to-indentation)
-		   (skip-chars-forward " \t")
+			(skip-chars-forward "*")))
-		   (if (looking-at "\\*\\*?")
-		       (- (match-end 0) (match-beginning 0))
-		     0)))
 	  (cs-curcol (progn (goto-char (cdr langelem))
 			    (current-column))))
 (back-to-indentation)
-(if (re-search-forward "/\\*[ \t]*" (c-point 'eol) t)
+(if (not (re-search-forward "/[*]+" (c-point 'eol) t))
-	  (goto-char (+ (match-beginning 0)
+	  (progn
-			(cond
+	    (if (not (looking-at "[*]+"))
-			 (c-block-comments-indent-p 0)
+		(progn
-			 ((= stars 1) 1)
+		  ;; we now have to figure out where this comment begins.
-			 ((= stars 2) 0)
+		  (goto-char here)
-			 (t (- (match-end 0) (match-beginning 0)))))))
+		  (back-to-indentation)
-(- (current-column) cs-curcol))))
+		  (if (re-search-forward "[*]+/" (c-point 'eol) t)
+		      (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 labels and case tags.
+"Imposes a minimum indentation for lines inside a top-level construct.
 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.322"
+(defconst c-version "4.379"
-"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)))
 (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-tab-always-indent
 		   'c-recognize-knr-p
 		   'c-label-minimum-indentation
 		   'defun-prompt-regexp
 	    (delq 'defun-prompt-regexp vars)
 	  vars))
 (function
 (lambda ()
 	 (insert
+	  "Buffer Style: " c-indentation-style "\n\n"
 	  (if c-special-indent-hook
 	      (concat "\n@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"
 		      "c-special-indent-hook is set to '"
 		      (format "%s" c-special-indent-hook)
 		      ".\nPerhaps this is your problem?\n"
 "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 (cons (concat mode-name " Mode Commands") c-mode-menu))
+(popup-menu (c-mode-menu))
 (c-keep-region-active))
 ;; Emacs/XEmacs Compatibility
-;; XEmacs has these, Emacs (even 19.31) does not
+;; XEmacs has these, Emacs does not
-;; Lift XEmacs 19.13's functionp from subr.el
+(if (fboundp 'functionp)
-(defun c-functionp (obj)
+(defalias 'c-functionp 'functionp)
-"Returns t if OBJ is a function, nil otherwise."
+;; Lift XEmacs 19.13's functionp from subr.el
-(cond
+(defun c-functionp (obj)
-((symbolp obj) (fboundp obj))
+"Returns t if OBJ is a function, nil otherwise."
-((subrp obj))
+(cond
-((compiled-function-p obj))
+((symbolp obj) (fboundp obj))
-((consp obj)
+((subrp obj))
-(if (eq (car obj) 'lambda) (listp (car (cdr obj)))))
+((compiled-function-p obj))
-(t nil)))
+((consp obj)
+(if (eq (car obj) 'lambda) (listp (car (cdr obj)))))
-(defun c-copy-tree (tree)
+(t nil))))
+(if (fboundp 'copy-tree)
+(defalias 'c-copy-tree 'copy-tree)
 ;; Lift XEmacs 19.12's copy-tree
-(if (consp tree)
+(defun c-copy-tree (tree)
-(cons (c-copy-tree (car tree))
+(if (consp tree)
-	    (c-copy-tree (cdr tree)))
+	(cons (c-copy-tree (car tree))
-(if (vectorp tree)
+	      (c-copy-tree (cdr tree)))
-	(let* ((new (copy-sequence tree))
+(if (vectorp tree)
-	       (i (1- (length new))))
+	  (let* ((new (copy-sequence tree))
-	  (while (>= i 0)
+		 (i (1- (length new))))
-	    (aset new i (c-copy-tree (aref new i)))
+	    (while (>= i 0)
-	    (setq i (1- i)))
+	      (aset new i (c-copy-tree (aref new i)))
-	  new)
+	      (setq i (1- i)))
-tree)))
+	    new)
+	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 'c-mapcar-defun
+		   (mapcar
-			   '(c-backslash-column
+		    (function
-			     c-basic-offset
+		     (lambda (var)
-			     c-block-comments-indent-p
+		       (let ((val (symbol-value var)))
-			     c-cleanup-list
+			 (cons var (if (atom val) val
-			     c-comment-only-line-offset
+				     (c-copy-tree val)
-			     c-electric-pound-behavior
+				     ))
-			     c-hanging-braces-alist
+			 )))
-			     c-hanging-colons-alist
+		    '(c-backslash-column
-			     c-hanging-comment-ender-p
+		      c-basic-offset
-			     c-offsets-alist
+		      c-cleanup-list
-			     )))
+		      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)))
-;; style variables
+(if c-style-variables-are-local-p
-(make-variable-buffer-local 'c-offsets-alist)
+(progn
-(make-variable-buffer-local 'c-basic-offset)
+;; style variables
-(make-variable-buffer-local 'c-file-style)
+(make-variable-buffer-local 'c-offsets-alist)
-(make-variable-buffer-local 'c-file-offsets)
+(make-variable-buffer-local 'c-basic-offset)
-(make-variable-buffer-local 'c-comment-only-line-offset)
+(make-variable-buffer-local 'c-file-style)
-(make-variable-buffer-local 'c-block-comments-indent-p)
+(make-variable-buffer-local 'c-file-offsets)
-(make-variable-buffer-local 'c-cleanup-list)
+(make-variable-buffer-local 'c-comment-only-line-offset)
-(make-variable-buffer-local 'c-hanging-braces-alist)
+(make-variable-buffer-local 'c-cleanup-list)
-(make-variable-buffer-local 'c-hanging-colons-alist)
+(make-variable-buffer-local 'c-hanging-braces-alist)
-(make-variable-buffer-local 'c-hanging-comment-ender-p)
+(make-variable-buffer-local 'c-hanging-colons-alist)
-(make-variable-buffer-local 'c-backslash-column)
+(make-variable-buffer-local 'c-hanging-comment-starter-p)
-(make-variable-buffer-local 'c-label-minimum-indentation)
+(make-variable-buffer-local 'c-hanging-comment-ender-p)
-(make-variable-buffer-local 'c-special-indent-hook)
+(make-variable-buffer-local 'c-backslash-column)
+(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 'c-block-comments-indent-p)
+	      (cons 'c++-C-block-comments-indent-p na)
 	      (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 @ 110:fe104dbd9147 r20-1b7