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

comparison lisp/modes/cc-mode.el @ 2:ac2d302a0011 r19-15b2

Import from CVS: tag r19-15b2

author	cvs
date	Mon, 13 Aug 2007 08:46:35 +0200
parents	376386a54a3c
children	b82b59fe008d

comparison

equal deleted inserted replaced

-:c0c6a60d29db
+:ac2d302a0011
-;;; cc-mode.el --- major mode for editing C, C++, and Objective-C code
+;;; 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.
 ;; 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.282
+;; Version:         4.315
-;; Last Modified:   1996/02/09 23:15:14
+;; Last Modified:   1996/08/20 21:08:13
 ;; 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!
 ;; all known Emacsen, nice new features, and tons of bug fixes.  This
 ;; package is called "cc-mode" to distinguish it from its ancestors,
 ;; but there really is no top-level cc-mode.  Usage and programming
 ;; details are 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
+;; package called font-lock.el which I do *not* maintain.  You should
+;; contact the Emacs maintainer 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 and I'll read about them there (this
+;; bug-gnu-emacs@prep.ai.mit.edu as well as cc-mode-help@python.org,
-;; is mirrored as the Usenet newsgroup gnu.emacs.bug).  Questions can
+;; and I'll read about them there (the former is mirrored as the
-;; sent to help-gnu-emacs@prep.ai.mit.edu (mirrored as
+;; Usenet newsgroup gnu.emacs.bug).  Questions can sent to
-;; gnu.emacs.help).  Please do not send bugs or questions to my
+;; help-gnu-emacs@prep.ai.mit.edu (mirrored as gnu.emacs.help) or
-;; personal account.
+;; 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
 ;; (formerly Lucid Emacs), and GNU Emacs 18 all do things differently
 ;; and there's no way to shut the byte-compiler up at the necessary
 ;; (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 18-Jan-1996,
+;; If your Emacs comes with cc-mode already (and as of 5-Jul-1996
-;; XEmacs 19.13 and Emacs 19.30 both do), you only need to add the
+;; 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.
 ;; 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.
-;; Anonymous ftp URL:
+;; You can get the latest version of cc-mode, including PostScript
+;; documentation and separate individual files from:
 ;;
-;;    ftp://ftp.python.org/pub/emacs/cc-mode.tar.gz
+;;     http://www.python.org/ftp/emacs/
+;; Or if you don't have access to the World Wide Web, through
+;; anonymous ftp from:
+;;
+;;    ftp://ftp.python.org/pub/emacs
 ;;; Code:
 ;; user definable variables
 (cpp-macro             . -1000)
 (friend                . 0)
 (objc-method-intro     . -1000)
 (objc-method-args-cont . c-lineup-ObjC-method-args)
 (objc-method-call-cont . c-lineup-ObjC-method-call)
+(extern-lang-open      . 0)
+(extern-lang-close     . 0)
+(inextern-lang         . +)
 )
 "*Association list of syntactic element symbols and indentation offsets.
 As described below, each cons cell in this list has the form:
 (SYNTACTIC-SYMBOL . OFFSET)
 block-close            -- statement block close brace
 brace-list-open        -- open brace of an enum or static array list
 brace-list-close       -- close brace of an enum or static array list
 brace-list-intro       -- first line in an enum or static array list
 brace-list-entry       -- subsequent lines in an enum or static array list
-statement              -- a C/C++/ObjC statement
+statement              -- a C (or like) statement
-statement-cont         -- a continuation of a C/C++/ObjC statement
+statement-cont         -- a continuation of a C (or like) statement
 statement-block-intro  -- the first line in a new statement block
 statement-case-intro   -- the first line in a case `block'
 statement-case-open    -- the first line in a case block starting with brace
 substatement           -- the first line after an if/while/for/do/else
 substatement-open      -- the brace that opens a substatement block
 case-label             -- a case or default label
 access-label           -- C++ private/protected/public access label
-label                  -- any non-special C/C++/ObjC label
+label                  -- any non-special C (or like) label
 do-while-closure       -- the `while' that ends a do/while construct
 else-clause            -- the `else' of an if/else construct
 comment-intro          -- a line containing only a comment introduction
 arglist-intro          -- the first line in an argument list
 arglist-cont           -- subsequent argument list lines when no
 arguments follow on the same line as the
-the arglist opening paren
+arglist opening paren
 arglist-cont-nonempty  -- subsequent argument list lines when at
 least one argument follows on the same
 line as the arglist opening paren
 arglist-close          -- the solo close paren of an argument list
 stream-op              -- lines continuing a stream operator construct
 cpp-macro              -- the start of a cpp macro
 friend                 -- a C++ friend declaration
 objc-method-intro      -- the first line of an Objective-C method definition
 objc-method-args-cont  -- lines continuing an Objective-C method definition
 objc-method-call-cont  -- lines continuing an Objective-C method call
+extern-lang-open       -- brace that opens an external language block
+extern-lang-close      -- brace that closes an external language block
+inextern-lang          -- analogous to `inclass' syntactic symbol
 ")
 (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.
+in the line's indentation, otherwise it insert a `real' tab character
-If other than nil or t, then tab is inserted only within literals
+\(see note\).  If other than nil or t, then tab is inserted only within
--- defined as comments and strings -- and inside preprocessor
+literals -- defined as comments and strings -- and inside preprocessor
 directives, but line is always reindented.
-Note that indentation of lines containing only comments is also
+Note: The value of `indent-tabs-mode' will determine whether a real
-controlled by the `c-comment-only-line-offset' variable.")
+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.
+Note: indentation of lines containing only comments is also controlled
+by the `c-comment-only-line-offset' variable.")
+(defvar c-insert-tab-function 'insert-tab
+"*Function used when inserting a tab for \\[TAB].
+Only used when `c-tab-always-indent' indicates a `real' tab character
+should be inserted.  Value must be a function taking no arguments.")
 (defvar c-comment-only-line-offset 0
 "*Extra offset for line which contains only the start of a comment.
 Can contain an integer or a cons cell of the form:
 			whitespace between colons. Clean up occurs
 			when the second colon is typed.")
 (defvar c-hanging-braces-alist '((brace-list-open)
 				 (substatement-open after)
-				 (block-close . c-snug-do-while))
+				 (block-close . c-snug-do-while)
+				 (extern-lang-open after)
+				 )
 "*Controls the insertion of newlines before and after braces.
 This variable contains an association list with elements of the
 following form: (SYNTACTIC-SYMBOL . ACTION).
 When a brace (either opening or closing) is inserted, the syntactic
 If the context is not found, the default is to insert a newline both
 before and after the brace.
 SYNTACTIC-SYMBOL can be any of: defun-open, defun-close, class-open,
 class-close, inline-open, inline-close, block-open, block-close,
-substatement-open, statement-case-open, brace-list-open,
+substatement-open, statement-case-open, extern-lang-open,
-brace-list-close, brace-list-intro, or brace-list-entry. See
+extern-lang-close, brace-list-open, brace-list-close,
-`c-offsets-alist' for details.
+brace-list-intro, or brace-list-entry. See `c-offsets-alist' for
+details.
 ACTION can be either a function symbol or a list containing any
 combination of the symbols `before' or `after'.  If the list is empty,
 no newlines are inserted either before or after the brace.
 (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
-(defvar c-recognize-knr-p nil		; Emacs version uses t
+"*Minimum indentation for labels and case tags in `gnu' style.")
-"*If non-nil, `c-mode' and `objc-mode' will recognize K&R constructs.
-This variable is needed because of ambiguities in C syntax that make
-fast recognition of K&R constructs problematic, and slow.  If you are
-coding with ANSI prototypes, set this variable to nil to speed up
-recognition of certain constructs.  By setting this variable to nil, I
-have seen an increase of 20 times under some circumstance.")
 (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
 useful for Emacs 19.")
-(defvar c-style-alist
+(defconst c-style-alist
 '(("gnu"
 (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)
 			 ))
+(c-special-indent-hook . c-gnu-impose-minimum)
 )
 ("k&r"
 (c-basic-offset . 5)
 (c-comment-only-line-offset . 0)
 (c-offsets-alist . ((statement-block-intro . +)
 "*Hook called by `objc-mode'.")
 (defvar java-mode-hook nil
 "*Hook called by `java-mode'.")
 (defvar c-mode-common-hook nil
-"*Hook called by `c-mode', `c++-mode', and 'objc-mode' during common init.")
+"*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)]
 ((= 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)))
+((= 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...
-(if (and (eq major 'v19)
+(if (or (eq major 'v20)
-	     (or (and (eq flavor 'XEmacs) (>= minor 14))
+	    (and (eq major 'v19)
-		 (and (eq flavor 'FSF) (>= minor 30))))
+		 (or (and (eq flavor 'XEmacs) (>= minor 14))
+		     (and (eq flavor 'FSF) (>= minor 30)))))
 	(setq re-suite 'new-re))
 ;; XEmacs 19 uses 8-bit modify-syntax-entry flags, as do all
 ;; patched Emacs 19, Emacs 18, Epoch 4's.  Only Emacs 19 uses a
 ;; 1-bit flag.  Let's be as smart as we can about figuring this
 ;; out.
-(if (eq major 'v19)
+(if (or (eq major 'v20) (eq major 'v19))
 	(let ((table (copy-syntax-table)))
 	  (modify-syntax-entry ?a ". 12345678" table)
 	  (cond
 	   ;; XEmacs pre 20 and Emacs pre 19.30 use vectors for syntax tables.
 	   ((vectorp table)
 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.")
 ;; Lucid Emacs 19.9 defined these two, the second of which was
 ;; commented out...
 ;; (define-key c-mode-map "\e{" 'c-insert-braces)
 ;; Commented out electric square brackets because nobody likes them.
 ;; (define-key c-mode-map "[" 'c-insert-brackets)
-(define-key c-mode-map "\e\C-h"    'c-mark-function)
+(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.
 (defvar c++-mode-map ()
 "Keymap used in c++-mode buffers.")
 (if c++-mode-map
 ()
 ;; In Emacs 19, it makes more sense to inherit c-mode-map
-(if (memq 'v19 c-emacs-features)
+(if (or
+(memq 'v19 c-emacs-features)
+(memq 'v20 c-emacs-features))
 ;; XEmacs and Emacs 19 do this differently
 (cond
 ;; XEmacs 19.13
 ((fboundp 'set-keymap-parents)
 	(setq c++-mode-map (make-sparse-keymap))
 (defvar objc-mode-map ()
 "Keymap used in objc-mode buffers.")
 (if objc-mode-map
 ()
 ;; In Emacs 19, it makes more sense to inherit c-mode-map
-(if (memq 'v19 c-emacs-features)
+(if (or (memq 'v19 c-emacs-features) (memq 'v20 c-emacs-features))
 ;; XEmacs and Emacs 19 do this differently
 (cond
 ;; XEmacs 19.13
 ((fboundp 'set-keymap-parents)
 	(setq objc-mode-map (make-sparse-keymap))
 (defvar java-mode-map ()
 "Keymap used in java-mode buffers.")
 (if java-mode-map
 ()
 ;; In Emacs 19, it makes more sense to inherit c-mode-map
-(if (memq 'v19 c-emacs-features)
+(if (or (memq 'v19 c-emacs-features) (memq 'v20 c-emacs-features))
 ;; XEmacs and Emacs 19 do this differently
 (cond
 ;; XEmacs 19.13
 ((fboundp 'set-keymap-parents)
 	(setq java-mode-map (make-sparse-keymap))
 (concat
 ":?[ \t]*\\(virtual[ \t]+\\)?\\("
 c-protection-key "[ \t]+\\)" c-symbol-key)
 "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.")
 ;; 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
 "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
-(concat c-protection-key ":")
+(concat c-protection-key "[ \t]*:")
 "Regexp describing C++ access specification keywords.")
 (defconst c-label-key
 (concat c-symbol-key ":\\([^:]\\|$\\)")
 "Regexp describing any label.")
+(defconst c-C-conditionals '("for" "if" "do" "else" "while" "switch")
+"Shared conditional keywords for C-like languages.")
 (defconst c-C-conditional-key
-"\\b\\(for\\|if\\|do\\|else\\|while\\|switch\\)\\b[^_]"
+(concat "\\b\\("
-"Regexp describing a conditional control.")
+	  (mapconcat 'identity c-C-conditionals "\\|")
+	  "\\)\\b[^_]")
+"Regexp describing a conditional control for C.")
 (defconst c-C++-conditional-key
-"\\b\\(for\\|if\\|do\\|else\\|while\\|switch\\|try\\|catch\\)\\b[^_]"
+(concat "\\b\\(" (mapconcat 'identity
+			      (append '("try" "catch") c-C-conditionals) "\\|")
+	  "\\)\\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 "//\\|/\\*"
 "\\(\\s *:\\s *" c-symbol-key "\\)?"	;maybe followed by the superclass
 "\\(\\s *<[^>]+>\\)?"		;and maybe the adopted protocols list
 )
 "Regexp describing a class or protocol declaration for Objective-C.")
-(defconst c-Java-conditional-key
-"\\b\\(for\\|if\\|do\\|else\\|while\\|switch\\|try\\|catch\\|finally\\|synchronized\\)\\b[^_]"
-"Regexp describing a conditional control for Java.")
 (defconst c-Java-method-key
 (concat
 "^\\s *[+-]\\s *"
 "\\(([^)]*)\\)?"			; return type
 ;; \\s- in java syntax table does not include \n
 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-conditional-key
+(concat "\\b\\("
+	  (mapconcat 'identity
+		     (append '("try" "catch" "finally" "synchronized")
+			     c-C-conditionals) "\\|")
+	  "\\)\\b[^_]")
+"Regexp describing a conditional control for Java.")
 ;; 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.
 	c-conditional-key c-C++-conditional-key
 	c-comment-start-regexp c-C++-comment-start-regexp
 	c-class-key c-C++-class-key
 	c-access-key c-C++-access-key
 	c-double-slash-is-comments-p t
+	c-recognize-knr-p nil
 	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))
 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.
+`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
+set styles in `c-mode-common-hook'.
 Key bindings:
 \\{java-mode-map}"
 (interactive)
 (kill-all-local-variables)
 	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-set-style "Java")
+(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))
+(defun c-use-java-style ()
+"Institutes `java' indentation style.
+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
 (make-local-variable 'paragraph-start)
 (setq c-auto-hungry-string
 	(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 (memq 'v19 c-emacs-features)
+(if (or (memq 'v19 c-emacs-features) (memq 'v20 c-emacs-features))
 (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
 	    (not (looking-at "[ \t]*$")))
 	(c-insert-special-chars arg)
 (let* ((syms '(class-open class-close defun-open defun-close
 		     inline-open inline-close brace-list-open brace-list-close
 		     brace-list-intro brace-list-entry block-open block-close
-		     substatement-open statement-case-open))
+		     substatement-open statement-case-open
+		     extern-lang-open extern-lang-close))
 	    ;; we want to inhibit blinking the paren since this will
 	    ;; be most disruptive. we'll blink it ourselves later on
 	    (old-blink-paren (if (boundp 'blink-paren-function)
 				 blink-paren-function
 			       blink-paren-hook))
 		       (or (c-lookup-lists syms syntax c-hanging-braces-alist)
 			   '(ignore before after)))))
 	;; If syntax is a function symbol, then call it using the
 	;; defined semantics.
 	(if (and (not (consp (cdr newlines)))
-		 (fboundp (cdr newlines)))
+		 (c-functionp (cdr newlines)))
 	    (let ((c-syntactic-context syntax))
 	      (setq newlines
 		    (funcall (cdr newlines) (car newlines) insertion-point))))
 	;; does a newline go before the open brace?
 	(if (memq 'before newlines)
 	 (defstr (format "(default %s): " oldoff))
 	 (errmsg (concat "Offset must be int, func, var, "
 			 "or in [+,-,++,--,*,/] "
 			 defstr))
 	 (prompt (concat "Offset " defstr))
-	 offset input interned)
+	 offset input interned raw)
 (while (not offset)
 (setq input (read-string prompt)
 	    offset (cond ((string-equal "" input) oldoff)  ; default
 			 ((string-equal "+" input) '+)
 			 ((string-equal "-" input) '-)
 			 ((string-equal "--" input) '--)
 			 ((string-equal "*" input) '*)
 			 ((string-equal "/" input) '/)
 			 ((string-match "^-?[0-9]+$" input)
 			  (string-to-int input))
+			 ;; a symbol with a function binding
 			 ((fboundp (setq interned (intern input)))
 			  interned)
+			 ;; a lambda function
+			 ((condition-case nil
+			      (c-functionp (setq raw (read input)))
+			    (error nil))
+			  raw)
+			 ;; a symbol with variable binding
 			 ((boundp interned) interned)
 			 ;; error, but don't signal one, keep trying
 			 ;; to read an input value
 			 (t (ding)
 			    (setq prompt errmsg)
 		    ;; on the syntactic analysis list for the current
 		    ;; line
 		    (let* ((syntax (c-guess-basic-syntax))
 			   (len (length syntax))
 			   (ic (format "%s" (car (nth (1- len) syntax)))))
-		      (if (memq 'v19 c-emacs-features)
+		      (if (or (memq 'v19 c-emacs-features)
+			      (memq 'v20 c-emacs-features))
 			  (cons ic 0)
 			ic))
 		    )))
 	  (offset (c-read-offset langelem)))
 (list langelem offset current-prefix-arg)))
 (eq offset '++)
 (eq offset '--)
 (eq offset '*)
 (eq offset '/)
 (integerp offset)
-(fboundp offset)
+(c-functionp offset)
 (boundp offset)
 (error "Offset must be int, func, var, or in [+,-,++,--,*,/]: %s"
 	     offset))
 (let ((entry (assq symbol c-offsets-alist)))
 (if entry
 (mapcar
 (function
 (lambda (conscell)
 (let ((attr (car conscell))
 	    (val  (cdr conscell)))
-	;; KLUDGE ALERT: special case for c-offsets-alist
+	(cond
-	(if (not (eq attr 'c-offsets-alist))
+	 ((eq attr 'c-offsets-alist)
-	    (set attr val)
 	  (mapcar
 	   (function
 	    (lambda (langentry)
 	      (let ((langelem (car langentry))
 		    (offset (cdr langentry)))
 		(c-set-offset langelem offset)
 		)))
 	   val))
+	 ((eq attr 'c-special-indent-hook)
+	  (if (listp val)
+	      (while val
+		(add-hook 'c-special-indent-hook (car val))
+		(setq val (cdr val)))
+	    (add-hook 'c-special-indent-hook val)))
+	 (t (set attr val)))
 	)))
 stylevars))
 (defun c-set-style (stylename)
 "Set cc-mode variables to use one of several different indentation styles.
 (interactive (list (let ((completion-ignore-case t)
 			   (prompt (format "Which %s indentation style? "
 					   mode-name)))
 		       (completing-read prompt c-style-alist nil t))))
 (let ((vars (cdr (or (assoc (downcase stylename) c-style-alist)
-		       ;; backwards compatibility
 		       (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
 	      (paragraph-separate (concat paragraph-separate re1)))
 	  (save-excursion
 	    (beginning-of-line)
 	    ;; Move up to first line of this comment.
 	    (while (and (not (bobp))
-			(looking-at "[ \t]*//"))
+			(looking-at "[ \t]*//[ \t]*[^ \t\n]"))
 	      (forward-line -1))
-	    (if (not (looking-at ".*//"))
+	    (if (not (looking-at ".*//[ \t]*[^ \t\n]"))
 		(forward-line 1))
 	    ;; Find the comment start in this line.
 	    (re-search-forward "[ \t]*//[ \t]*")
 	    ;; Set the fill-prefix to be what all lines except the first
 	    ;; should start with.
 		    (let ((fill-column (+ fill-column 9999)))
 		      (forward-line -1)
 		      (fill-region-as-paragraph (point) (point-max))))))
 	    t)))))
 ;; better movement routines for ThisStyleOfVariablesCommonInCPlusPlus
 ;; originally contributed by Terry_Glanfield.Southern@rxuk.xerox.com
 (defun c-forward-into-nomenclature (&optional arg)
 "Move forward to end of a nomenclature section or word.
 With arg, to it arg times."
 (interactive (list (prefix-numeric-value current-prefix-arg)
 		     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.
+;; 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)
 	(substmt-p t)
 ;; otherwise insert a tab
 ((not c-tab-always-indent)
 	(if (save-excursion
 	      (skip-chars-backward " \t")
 	      (not (bolp)))
-	    (insert-tab)
+	    (funcall c-insert-tab-function)
 	  (c-indent-line)))
 ;; CASE 2: just indent the line
 ((eq c-tab-always-indent t)
 	(c-indent-line))
 ;; CASE 3: if in a literal, insert a tab, but always indent the
 ;; line
 (t
 	(if (c-in-literal bod)
-	    (insert-tab))
+	    (funcall c-insert-tab-function))
 	(c-indent-line)
 	)))))
 (defun c-indent-exp (&optional shutup-p)
 "Indent each line in balanced expression following point.
 t)))
 (defun c-skip-conditional ()
 ;; skip forward over conditional at point, including any predicate
 ;; statements in parentheses. No error checking is performed.
-(forward-sexp
+(forward-sexp (cond
-;; else if()
+		 ;; else if()
-(if (looking-at "\\<else\\>[ \t]+\\<if\\>")
+		 ((looking-at "\\<else\\>[ \t]+\\<if\\>") 3)
-3
+		 ;; do, else, try, finally
-;; do and else aren't followed by parens
+		 ((looking-at "\\<\\(do\\|else\\|try\\|finally\\)\\>") 1)
-(if (looking-at "\\<\\(do\\|else\\)\\>")
+		 ;; for, if, while, switch, catch, synchronized
-	 1 2))))
+		 (t 2))))
 (defun c-skip-case-statement-forward (state &optional lim)
 ;; skip forward over case/default bodies, with optional maximal
 ;; limit. if no next case body is found, nil is returned and point
 ;; is not moved
 	;; search-end and see if we can find a class key.  watch for
 	;; class like strings in literals
 	(save-excursion
 	  (save-restriction
 	    (goto-char search-start)
-	    (let (foundp class match-end)
+	    (let ((search-key (concat c-class-key "\\|extern[^_]"))
+		  foundp class match-end)
 	      (while (and (not foundp)
 			  (progn
 			    (c-forward-syntactic-ws)
 			    (> search-end (point)))
-			  (re-search-forward c-class-key search-end t))
+			  (re-search-forward search-key search-end t))
 		(setq class (match-beginning 0)
 		      match-end (match-end 0))
 		(if (c-in-literal search-start)
 		    nil			; its in a comment or string, ignore
 		  (goto-char class)
 	     (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
-	     ;; narrow out any enclosing class
+	     ;; 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
+				  (widen)
+				  (goto-char (aref inclass-p 0))
+				  (looking-at "extern[^_]")))))
 	     )
 	;; get the buffer position of the most nested opening brace,
 	;; if there is one, and it hasn't been narrowed out
 	(save-excursion
 	  (cond
 	   ;; CASE 5A: we are looking at a defun, class, or
 	   ;; inline-inclass method opening brace
 	   ((= char-after-ip ?{)
 	    (cond
-	     ;; CASE 5A.1: we are looking at a class opening brace
+	     ;; CASE 5A.1: extern declaration
+	     ((save-excursion
+		(goto-char indent-point)
+		(skip-chars-forward " \t")
+		(and (c-safe (progn (backward-sexp 2) t))
+		     (looking-at "extern[^_]")
+		     (progn
+		       (setq placeholder (point))
+		       (forward-sexp 1)
+		       (c-forward-syntactic-ws)
+		       (= (following-char) ?\"))))
+	      (goto-char placeholder)
+	      (c-add-syntax 'extern-lang-open (c-point 'boi)))
+	     ;; CASE 5A.2: we are looking at a class opening brace
 	     ((save-excursion
 		(goto-char indent-point)
 		(skip-chars-forward " \t{")
 		;; TBD: watch out! there could be a bogus
 		;; c-state-cache in place when we get here.  we have
 			 )))
 		  (and decl
 		       (setq placeholder (aref decl 0)))
 		  ))
 	      (c-add-syntax 'class-open placeholder))
-	     ;; CASE 5A.2: brace list open
+	     ;; CASE 5A.3: brace list open
 	     ((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))
 		     (save-excursion
 		       (skip-chars-forward "^;(" indent-point)
 		       (not (memq (following-char) '(?\; ?\()))
 		       )))
 	      (c-add-syntax 'brace-list-open placeholder))
-	     ;; CASE 5A.3: inline defun open
+	     ;; CASE 5A.4: inline defun open
-	     (inclass-p
+	     ((and inclass-p (not inextern-p))
-	      (c-add-syntax 'inline-open (aref inclass-p 0)))
+	      (c-add-syntax 'inline-open)
-	     ;; CASE 5A.4: ordinary defun open
+	      (c-add-syntax 'inclass (aref inclass-p 0)))
+	     ;; CASE 5A.5: ordinary defun open
 	     (t
 	      (goto-char placeholder)
 	      (c-add-syntax 'defun-open (c-point 'bol))
 	      )))
 	   ;; CASE 5B: first K&R arg decl or member init
 	   ((and inclass-p
 		 c-access-key
 		 (looking-at c-access-key))
 	    (c-add-syntax 'access-label (c-point 'bonl))
 	    (c-add-syntax 'inclass (aref inclass-p 0)))
-	   ;; CASE 5F: we are looking at the brace which closes the
+	   ;; CASE 5F: extern-lang-close?
+	   ((and inextern-p
+		 (= char-after-ip ?}))
+	    (c-add-syntax 'extern-lang-close (aref inclass-p 1)))
+	   ;; CASE 5G: we are looking at the brace which closes the
 	   ;; enclosing nested class decl
 	   ((and inclass-p
 		 (= char-after-ip ?})
 		 (save-excursion
 		   (save-restriction
 		      ))))
 	    (save-restriction
 	      (widen)
 	      (goto-char (aref inclass-p 0))
 	      (c-add-syntax 'class-close (c-point 'boi))))
-	   ;; CASE 5G: we could be looking at subsequent knr-argdecls
+	   ;; CASE 5H: we could be looking at subsequent knr-argdecls
 	   ((and c-recognize-knr-p
-		 (save-excursion
+		 ;; here we essentially use the hack that is used in
-		   (c-backward-syntactic-ws lim)
+		 ;; Emacs' c-mode.el to limit how far back we should
-		   (while (memq (preceding-char) '(?\; ?,))
+		 ;; look.  The assumption is made that argdecls are
-		     (beginning-of-line)
+		 ;; indented at least one space and that function
-		     (setq placeholder (point))
+		 ;; headers are not indented.
-		     (c-backward-syntactic-ws lim))
+		 (let ((limit (save-excursion
-		   (and (= (preceding-char) ?\))
+				(re-search-backward "^[^ \^L\t\n#]" nil 'move)
-			(or (not c-method-key)
+				(point))))
-			    (progn
+		   (save-excursion
-			      (forward-sexp -1)
+		     (c-backward-syntactic-ws limit)
-			      (forward-char -1)
+		     (while (and (memq (preceding-char) '(?\; ?,))
-			      (c-backward-syntactic-ws)
+				 (> (point) limit))
-			      (not (or (= (preceding-char) ?-)
+		       (beginning-of-line)
-				       (= (preceding-char) ?+)
+		       (setq placeholder (point))
-				       ;; or a class category
+		       (c-backward-syntactic-ws limit))
-				       (progn
+		     (and (= (preceding-char) ?\))
-					 (forward-sexp -2)
+			  (or (not c-method-key)
-					 (looking-at c-class-key))
+			      (progn
-				       )))))
+				(forward-sexp -1)
-		   )
+				(forward-char -1)
+				(c-backward-syntactic-ws)
+				(not (or (= (preceding-char) ?-)
+					 (= (preceding-char) ?+)
+					 ;; or a class category
+					 (progn
+					   (forward-sexp -2)
+					   (looking-at c-class-key))
+					 )))))
+		     ))
 		 (save-excursion
 		   (c-beginning-of-statement-1)
 		   (not (looking-at "typedef[ \t\n]+"))))
 	    (goto-char placeholder)
 	    (c-add-syntax 'knr-argdecl (c-point 'boi)))
-	   ;; CASE 5H: we are at the topmost level, make sure we skip
+	   ;; CASE 5I: we are at the topmost level, make sure we skip
 	   ;; back past any access specifiers
 	   ((progn
 	      (c-backward-syntactic-ws lim)
 	      (while (and inclass-p
 			  c-access-key
 	      (widen)
 	      (c-add-syntax 'topmost-intro (c-point 'bol))
 	      (if inclass-p
 		  (progn
 		    (goto-char (aref inclass-p 1))
-		    (c-add-syntax 'inclass (c-point 'boi))))))
+		    (if inextern-p
-	   ;; CASE 5I: we are at an ObjC or Java method definition
+			(c-add-syntax 'inextern-lang)
+		      (c-add-syntax 'inclass (c-point 'boi)))))
+		))
+	   ;; CASE 5J: we are at an ObjC or Java method definition
 	   ;; continuation line.
 	   ((and c-method-key
 		 (progn
 		   (c-beginning-of-statement-1 lim)
 		   (beginning-of-line)
 		   (looking-at c-method-key)))
 	    (c-add-syntax 'objc-method-args-cont (point)))
-	   ;; CASE 5J: we are at a topmost continuation line
+	   ;; CASE 5K: we are at a topmost continuation line
 	   (t
 	    (c-beginning-of-statement-1 lim)
 	    (c-forward-syntactic-ws)
 	    (c-add-syntax 'topmost-intro-cont (c-point 'boi)))
 	   ))				; end CASE 5
 			   (if (/= (point) (c-point 'boi))
 			       (c-beginning-of-statement-1 lim))
 			   (c-point 'boi))))
 	    (cond
 	     ;; CASE 14A: does this close an inline?
-	     ((progn
+	     ((let ((inclass-p (progn
-		(goto-char containing-sexp)
+				 (goto-char containing-sexp)
-		(c-search-uplist-for-classkey state))
+				 (c-search-uplist-for-classkey state))))
+		;; inextern-p in higher level let*
+		(setq inextern-p (and inclass-p
+				      (progn
+					(goto-char (aref inclass-p 0))
+					(looking-at "extern[^_]"))))
+		(and inclass-p (not inextern-p)))
 	      (c-add-syntax 'inline-close relpos))
 	     ;; CASE 14B: if there an enclosing brace that hasn't
 	     ;; been narrowed out by a class, then this is a
 	     ;; block-close
-	     ((c-most-enclosing-brace state)
+	     ((and (not inextern-p)
+		   (c-most-enclosing-brace state))
 	      (c-add-syntax 'block-close relpos))
 	     ;; CASE 14C: find out whether we're closing a top-level
 	     ;; class or a defun
 	     (t
 	      (save-restriction
 ((not match)
 (if c-strict-syntax-p
 	  (error "don't know how to indent a %s" symbol)
 	(setq offset 0
 	      relpos 0)))
-((eq offset '+)  (setq offset c-basic-offset))
+((eq offset '+)         (setq offset c-basic-offset))
-((eq offset '-)  (setq offset (- c-basic-offset)))
+((eq offset '-)         (setq offset (- c-basic-offset)))
-((eq offset '++) (setq offset (* 2 c-basic-offset)))
+((eq offset '++)        (setq offset (* 2 c-basic-offset)))
-((eq offset '--) (setq offset (* 2 (- c-basic-offset))))
+((eq offset '--)        (setq offset (* 2 (- c-basic-offset))))
-((eq offset '*)  (setq offset (/ c-basic-offset 2)))
+((eq offset '*)         (setq offset (/ c-basic-offset 2)))
-((eq offset '/)  (setq offset (/ (- c-basic-offset) 2)))
+((eq offset '/)         (setq offset (/ (- c-basic-offset) 2)))
-((and (not (numberp offset))
+((c-functionp offset)   (setq offset (funcall offset langelem)))
-	   (fboundp offset))
+((not (numberp offset)) (setq offset (symbol-value offset)))
-(setq offset (funcall offset langelem)))
-((not (numberp offset))
-(setq offset (eval offset)))
 )
 (+ (if (and relpos
 		(< relpos (c-point 'bol)))
 	   (save-excursion
 	     (goto-char relpos)
 	  (goto-char (- (point-max) pos)))
 )
 (run-hooks 'c-special-indent-hook)
 shift-amt))
-(defun c-show-syntactic-information ()
+(defun c-show-syntactic-information (arg)
-"Show syntactic information for current line."
+"Show syntactic information for current line.
-(interactive)
+With universal argument, inserts the analysis as a comment on that line."
-(message "syntactic analysis: %s" (c-guess-basic-syntax))
+(interactive "P")
+(let ((syntax (c-guess-basic-syntax)))
+(if (not (consp arg))
+	(message "syntactic analysis: %s" (c-guess-basic-syntax))
+(indent-for-comment)
+(insert (format "%s" syntax))
+))
 (c-keep-region-active))
 ;; Standard indentation line-ups
 (defun c-lineup-arglist (langelem)
 		       (backward-up-list 1)
 		       (skip-chars-forward " \t" (c-point 'eol))
 		       (current-column))))
 (- ce-curcol cs-curcol -1))))
+(defun c-lineup-arglist-close-under-paren (langelem)
+;; lineup an arglist-intro line to just after the open paren
+(save-excursion
+(let ((cs-curcol (save-excursion
+		       (goto-char (cdr langelem))
+		       (current-column)))
+	  (ce-curcol (save-excursion
+		       (beginning-of-line)
+		       (backward-up-list 1)
+		       (current-column))))
+(- ce-curcol cs-curcol))))
 (defun c-lineup-streamop (langelem)
 ;; lineup stream operators
 (save-excursion
 (let* ((relpos (cdr langelem))
 	   (curcol (progn (goto-char relpos)
 ;; support old behavior for comment indentation. we look at
 ;; c-comment-only-line-offset to decide how to indent comment
 ;; only-lines
 (save-excursion
 (back-to-indentation)
-;; indent as specified by c-comment-only-line-offset
+;; this highly kludgiforous flag prevents the mapcar over
-(if (not (bolp))
+;; c-syntactic-context from entering an infinite loop
+(let ((recurse-prevention-flag (boundp 'recurse-prevention-flag)))
+(cond
+;; CASE 1: preserve comment-column
+(recurse-prevention-flag 0)
+((= (current-column) comment-column)
+	;; we have to subtract out all other indentation
+	(- comment-column (apply '+ (mapcar 'c-get-offset
+					    c-syntactic-context))))
+;; indent as specified by c-comment-only-line-offset
+((not (bolp))
 	(or (car-safe c-comment-only-line-offset)
-	    c-comment-only-line-offset)
+	    c-comment-only-line-offset))
-(or (cdr-safe c-comment-only-line-offset)
+(t
-	  (car-safe c-comment-only-line-offset)
+	(or (cdr-safe c-comment-only-line-offset)
-	  -1000				;jam it against the left side
+	    (car-safe c-comment-only-line-offset)
-	  ))))
+	    -1000))			;jam it against the left side
+))))
 (defun c-lineup-runin-statements (langelem)
 ;; line up statements in coding standards which place the first
 ;; statement on the same line as the block opening brace.
 (if (= (char-after (cdr langelem)) ?{)
 		      (if (= (following-char) ?{)
 			  (c-safe (forward-sexp -1)))
 		      (looking-at "\\<do\\>[^_]")))
 	  '(before)
 	'(before after)))))
+(defun c-gnu-impose-minimum ()
+"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
+			   case-label label do-while-closure else-clause
+			   ))
+	(syntax c-syntactic-context)
+	langelem)
+(while syntax
+(setq langelem (car (car syntax))
+	    syntax (cdr syntax))
+;; don't adjust comment-only lines
+(cond ((eq langelem 'comment-intro)
+	     (setq syntax nil))
+	    ((memq langelem non-top-levels)
+	     (save-excursion
+	       (setq syntax nil)
+	       (back-to-indentation)
+	       (if (zerop (current-column))
+		   (insert (make-string c-label-minimum-indentation 32)))
+	       ))
+	    ))))
 ;;; This page handles insertion and removal of backslashes for C macros.
 (defun c-backslash-region (from to delete-flag)
 (defun c-delete-backslash ()
 (end-of-line)
 (or (bolp)
 (progn
 	(forward-char -1)
 	(if (looking-at "\\\\")
 	    (delete-region (1+ (point))
 			   (progn (skip-chars-backward " \t") (point)))))))
 ;; defuns for submitting bug reports
-(defconst c-version "4.282"
+(defconst c-version "4.315"
 "cc-mode version number.")
-(defconst c-mode-help-address "bug-gnu-emacs@prep.ai.mit.edu"
+(defconst c-mode-help-address
+"bug-gnu-emacs@prep.ai.mit.edu, cc-mode-help@python.org"
 "Address for cc-mode bug reports.")
 (defun c-version ()
 "Echo the current version of cc-mode in the minibuffer."
 (interactive)
 		   'c-hanging-braces-alist
 		   'c-hanging-colons-alist
 		   'c-hanging-comment-ender-p
 		   'c-tab-always-indent
 		   'c-recognize-knr-p
+		   'c-label-minimum-indentation
 		   'defun-prompt-regexp
 		   'tab-width
 		   )))
 	(if (not (boundp 'defun-prompt-regexp))
 	    (delq 'defun-prompt-regexp vars)
 (interactive "@e")
 (popup-menu (cons (concat mode-name " Mode Commands") c-mode-menu))
 (c-keep-region-active))
+;; Emacs/XEmacs Compatibility
+;; XEmacs has these, Emacs (even 19.31) does not
+;; Lift XEmacs 19.13's functionp from subr.el
+(defun c-functionp (obj)
+"Returns t if OBJ is a function, nil otherwise."
+(cond
+((symbolp obj) (fboundp obj))
+((subrp obj))
+((compiled-function-p obj))
+((consp obj)
+(if (eq (car obj) 'lambda) (listp (car (cdr obj)))))
+(t nil)))
 (defun c-copy-tree (tree)
 ;; Lift XEmacs 19.12's copy-tree
 (if (consp tree)
 (cons (c-copy-tree (car tree))
 	    (c-copy-tree (cdr tree)))
 		  ;; 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)
 			     c-electric-pound-behavior
 			     c-hanging-braces-alist
 			     c-hanging-colons-alist
 			     c-hanging-comment-ender-p
 			     c-offsets-alist
-			     c-recognize-knr-p
 			     c-strict-syntax-p
 			     c-tab-always-indent
 			     c-inhibit-startup-warnings-p
 			     )))
 ;; the default style is now GNU.  This can be overridden in
-;; c-mode-common-hook or {c,c++,objc}-mode-hook.
+;; c-mode-common-hook or {c,c++,objc,java}-mode-hook.
 (c-set-style c-site-default-style)))
 ;; style variables
 (make-variable-buffer-local 'c-offsets-alist)
 (make-variable-buffer-local 'c-basic-offset)
 (make-variable-buffer-local 'c-cleanup-list)
 (make-variable-buffer-local 'c-hanging-braces-alist)
 (make-variable-buffer-local 'c-hanging-colons-alist)
 (make-variable-buffer-local 'c-hanging-comment-ender-p)
 (make-variable-buffer-local 'c-backslash-column)
+(make-variable-buffer-local 'c-label-minimum-indentation)
+(make-variable-buffer-local 'c-special-indent-hook)
 ;; fsets for compatibility with BOCM
 (fset 'electric-c-brace      'c-electric-brace)
 (fset 'electric-c-semi       'c-electric-semi&comma)
 (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
 ;; to flag
-(and (memq 'v19 c-emacs-features)
+(and (or (memq 'v19 c-emacs-features) (memq 'v20 c-emacs-features))
 (let* ((na "Nothing appropriate.")
 	    (vars
 	     (list
 	      (cons 'c++-c-mode-syntax-table 'c-mode-syntax-table)
 	      (cons 'c++-tab-always-indent 'c-tab-always-indent)

Mercurial > hg > xemacs-beta

comparison lisp/modes/cc-mode.el @ 2:ac2d302a0011 r19-15b2