code.delx.au - gnu-emacs/blob - lisp/progmodes/cc-mode.el

   1 ;;; cc-mode.el --- major mode for editing C, C++, Objective-C, and Java code
   2
   3 ;; Copyright (C) 1985,1987,1992-2001 Free Software Foundation, Inc.
   4
   5 ;; Authors:    2000- Martin Stjernholm
   6 ;;             1998-1999 Barry A. Warsaw and Martin Stjernholm
   7 ;;             1992-1997 Barry A. Warsaw
   8 ;;             1987 Dave Detlefs and Stewart Clamen
   9 ;;             1985 Richard M. Stallman
  10 ;; Maintainer: bug-cc-mode@gnu.org
  11 ;; Created:    a long, long, time ago. adapted from the original c-mode.el
  12 ;; Keywords:   c languages oop
  13
  14 ;; This file is part of GNU Emacs.
  15
  16 ;; GNU Emacs is free software; you can redistribute it and/or modify
  17 ;; it under the terms of the GNU General Public License as published by
  18 ;; the Free Software Foundation; either version 2, or (at your option)
  19 ;; any later version.
  20
  21 ;; GNU Emacs is distributed in the hope that it will be useful,
  22 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  23 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24 ;; GNU General Public License for more details.
  25
  26 ;; You should have received a copy of the GNU General Public License
  27 ;; along with this program; see the file COPYING.  If not, write to
  28 ;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  29 ;; Boston, MA 02111-1307, USA.
  30
  31 (defconst c-version "5.28"
  32   "CC Mode version number.")
  33
  34 ;; NOTE: Read the commentary below for the right way to submit bug reports!
  35 ;; NOTE: See the accompanying texinfo manual for details on using this mode!
  36
  37 ;;; Commentary:
  38
  39 ;; This package provides GNU Emacs major modes for editing C, C++,
  40 ;; Objective-C, Java, IDL and Pike code.  As of the latest Emacs and
  41 ;; XEmacs releases, it is the default package for editing these
  42 ;; languages.  This package is called "CC Mode", and should be spelled
  43 ;; exactly this way.
  44
  45 ;; CC Mode supports K&R and ANSI C, ANSI C++, Objective-C, Java,
  46 ;; CORBA's IDL, and Pike with a consistent indentation model across
  47 ;; all modes.  This indentation model is intuitive and very flexible,
  48 ;; so that almost any desired style of indentation can be supported.
  49 ;; Installation, usage, and programming details are contained in an
  50 ;; accompanying texinfo manual.
  51
  52 ;; CC Mode's immediate ancestors were, c++-mode.el, cplus-md.el, and
  53 ;; cplus-md1.el..
  54
  55 ;; NOTE: This mode does not perform font-locking (a.k.a syntactic
  56 ;; coloring, keyword highlighting, etc.) for any of the supported
  57 ;; modes.  Typically this is done by a package called font-lock.el
  58 ;; which we do *not* maintain.  You should contact the Emacs or XEmacs
  59 ;; maintainers for questions about coloring or highlighting in any
  60 ;; language mode.
  61
  62 ;; To submit bug reports, type "C-c C-b".  These will be sent to
  63 ;; bug-gnu-emacs@gnu.org (mirrored as the Usenet newsgroup
  64 ;; gnu.emacs.bug) as well as bug-cc-mode@gnu.org, which directly
  65 ;; contacts the CC Mode maintainers.  Questions can sent to
  66 ;; help-gnu-emacs@gnu.org (mirrored as gnu.emacs.help) and/or
  67 ;; bug-cc-mode@gnu.org.  Please do not send bugs or questions to our
  68 ;; personal accounts; we reserve the right to ignore such email!
  69
  70 ;; Many, many thanks go out to all the folks on the beta test list.
  71 ;; Without their patience, testing, insight, code contributions, and
  72 ;; encouragement CC Mode would be a far inferior package.
  73
  74 ;; You can get the latest version of CC Mode, including PostScript
  75 ;; documentation and separate individual files from:
  76 ;;
  77 ;;     http://cc-mode.sourceforge.net/
  78 ;;
  79 ;; You can join a moderated CC Mode announcement-only mailing list by
  80 ;; visiting
  81 ;;
  82 ;;    http://lists.sourceforge.net/mailman/listinfo/cc-mode-announce
  83
  84 ;;; Code:
  85
  86 (eval-when-compile
  87   (let ((load-path
  88          (if (and (boundp 'byte-compile-dest-file)
  89                   (stringp byte-compile-dest-file))
  90              (cons (file-name-directory byte-compile-dest-file) load-path)
  91            load-path)))
  92     (require 'cc-bytecomp)))
  93
  94 (cc-require 'cc-defs)
  95 (cc-require 'cc-menus)
  96 (cc-require 'cc-vars)
  97 (cc-require 'cc-langs)
  98 (cc-require 'cc-styles)
  99 (cc-require 'cc-engine)
 100 (cc-require 'cc-cmds)
 101 (cc-require 'cc-align)
 102
 103 ;; Silence the compiler.
 104 (cc-bytecomp-defvar comment-line-break-function) ; (X)Emacs 20+
 105 (cc-bytecomp-defvar adaptive-fill-first-line-regexp) ; Emacs 20+
 106 (cc-bytecomp-defun set-keymap-parents)  ; XEmacs
 107
 108 ;; Menu support for both XEmacs and Emacs.  If you don't have easymenu
 109 ;; with your version of Emacs, you are incompatible!
 110 (require 'easymenu)
 111
 112 \f
 113 ;; Other modes and packages which depend on CC Mode should do the
 114 ;; following to make sure everything is loaded and available for their
 115 ;; use:
 116 ;;
 117 ;; (require 'cc-mode)
 118 ;; (c-initialize-cc-mode)
 119
 120 ;;;###autoload
 121 (defun c-initialize-cc-mode ()
 122   (setq c-buffer-is-cc-mode t)
 123   (let ((initprop 'cc-mode-is-initialized)
 124         c-initialization-ok)
 125     (unless (get 'c-initialize-cc-mode initprop)
 126       (unwind-protect
 127           (progn
 128             (put 'c-initialize-cc-mode initprop t)
 129             (c-initialize-builtin-style)
 130             (run-hooks 'c-initialization-hook)
 131             ;; Fix obsolete variables.
 132             (if (boundp 'c-comment-continuation-stars)
 133                 (setq c-block-comment-prefix c-comment-continuation-stars))
 134             (setq c-initialization-ok t))
 135         ;; Will try initialization hooks again if they failed.
 136         (put 'c-initialize-cc-mode initprop c-initialization-ok)))
 137     ))
 138
 139 \f
 140 ;; Common routines
 141 (defvar c-mode-base-map ()
 142   "Keymap shared by all CC Mode related modes.")
 143
 144 (defun c-make-inherited-keymap ()
 145   (let ((map (make-sparse-keymap)))
 146     (cond
 147      ;; XEmacs 19 & 20
 148      ((fboundp 'set-keymap-parents)
 149       (set-keymap-parents map c-mode-base-map))
 150      ;; Emacs 19
 151      ((fboundp 'set-keymap-parent)
 152       (set-keymap-parent map c-mode-base-map))
 153      ;; incompatible
 154      (t (error "CC Mode is incompatible with this version of Emacs")))
 155     map))
 156
 157 (if c-mode-base-map
 158     nil
 159   ;; TBD: should we even worry about naming this keymap. My vote: no,
 160   ;; because Emacs and XEmacs do it differently.
 161   (setq c-mode-base-map (make-sparse-keymap))
 162   ;; put standard keybindings into MAP
 163   ;; the following mappings correspond more or less directly to BOCM
 164   (define-key c-mode-base-map "{"         'c-electric-brace)
 165   (define-key c-mode-base-map "}"         'c-electric-brace)
 166   (define-key c-mode-base-map ";"         'c-electric-semi&comma)
 167   (define-key c-mode-base-map "#"         'c-electric-pound)
 168   (define-key c-mode-base-map ":"         'c-electric-colon)
 169   (define-key c-mode-base-map "("         'c-electric-paren)
 170   (define-key c-mode-base-map ")"         'c-electric-paren)
 171   ;; Separate M-BS from C-M-h.  The former should remain
 172   ;; backward-kill-word.
 173   (define-key c-mode-base-map [(control meta h)] 'c-mark-function)
 174   (define-key c-mode-base-map "\e\C-q"    'c-indent-exp)
 175   (substitute-key-definition 'backward-sentence
 176                              'c-beginning-of-statement
 177                              c-mode-base-map global-map)
 178   (substitute-key-definition 'forward-sentence
 179                              'c-end-of-statement
 180                              c-mode-base-map global-map)
 181   (substitute-key-definition 'indent-new-comment-line
 182                              'c-indent-new-comment-line
 183                              c-mode-base-map global-map)
 184   ;; RMS says don't make these the default.
 185 ;;  (define-key c-mode-base-map "\e\C-a"    'c-beginning-of-defun)
 186 ;;  (define-key c-mode-base-map "\e\C-e"    'c-end-of-defun)
 187   (define-key c-mode-base-map "\C-c\C-n"  'c-forward-conditional)
 188   (define-key c-mode-base-map "\C-c\C-p"  'c-backward-conditional)
 189   (define-key c-mode-base-map "\C-c\C-u"  'c-up-conditional)
 190   (substitute-key-definition 'indent-for-tab-command
 191                              'c-indent-command
 192                              c-mode-base-map global-map)
 193   ;; It doesn't suffice to put c-fill-paragraph on
 194   ;; fill-paragraph-function due to the way it works.
 195   (substitute-key-definition 'fill-paragraph 'c-fill-paragraph
 196                              c-mode-base-map global-map)
 197   ;; In XEmacs the default fill function is called
 198   ;; fill-paragraph-or-region.
 199   (substitute-key-definition 'fill-paragraph-or-region 'c-fill-paragraph
 200                              c-mode-base-map global-map)
 201   ;; Bind the electric deletion functions to C-d and DEL.  Emacs 21
 202   ;; automatically maps the [delete] and [backspace] keys to these two
 203   ;; depending on window system and user preferences.  (In earlier
 204   ;; versions it's possible to do the same by using `function-key-map'.)
 205   (define-key c-mode-base-map "\C-d" 'c-electric-delete-forward)
 206   (define-key c-mode-base-map "\177" 'c-electric-backspace)
 207   (when (boundp 'delete-key-deletes-forward)
 208     ;; In XEmacs 20 and later we fix the forward and backward deletion
 209     ;; behavior by binding the keysyms for the [delete] and
 210     ;; [backspace] keys directly, and use `delete-forward-p' or
 211     ;; `delete-key-deletes-forward' to decide what [delete] should do.
 212     (define-key c-mode-base-map [delete]    'c-electric-delete)
 213     (define-key c-mode-base-map [backspace] 'c-electric-backspace))
 214   ;; these are new keybindings, with no counterpart to BOCM
 215   (define-key c-mode-base-map ","         'c-electric-semi&comma)
 216   (define-key c-mode-base-map "*"         'c-electric-star)
 217   (define-key c-mode-base-map "/"         'c-electric-slash)
 218   (define-key c-mode-base-map "\C-c\C-q"  'c-indent-defun)
 219   (define-key c-mode-base-map "\C-c\C-\\" 'c-backslash-region)
 220   ;; TBD: where if anywhere, to put c-backward|forward-into-nomenclature
 221   (define-key c-mode-base-map "\C-c\C-a"  'c-toggle-auto-state)
 222   (define-key c-mode-base-map "\C-c\C-b"  'c-submit-bug-report)
 223   (define-key c-mode-base-map "\C-c\C-c"  'comment-region)
 224   (define-key c-mode-base-map "\C-c\C-d"  'c-toggle-hungry-state)
 225   (define-key c-mode-base-map "\C-c\C-o"  'c-set-offset)
 226   (define-key c-mode-base-map "\C-c\C-s"  'c-show-syntactic-information)
 227   (define-key c-mode-base-map "\C-c\C-t"  'c-toggle-auto-hungry-state)
 228   (define-key c-mode-base-map "\C-c."     'c-set-style)
 229   ;; conflicts with OOBR
 230   ;;(define-key c-mode-base-map "\C-c\C-v"  'c-version)
 231   )
 232
 233 (defvar c-c-menu nil)
 234 (defvar c-c++-menu nil)
 235 (defvar c-objc-menu nil)
 236 (defvar c-java-menu nil)
 237 (defvar c-pike-menu nil)
 238
 239 (defun c-mode-menu (modestr)
 240   (let ((m
 241          '(["Comment Out Region"     comment-region (c-fn-region-is-active-p)]
 242            ["Uncomment Region"
 243             (comment-region (region-beginning) (region-end) '(4))
 244             (c-fn-region-is-active-p)]
 245            ["Fill Comment Paragraph" c-fill-paragraph t]
 246            "---"
 247            ["Indent Expression"      c-indent-exp
 248             (memq (char-after) '(?\( ?\[ ?\{))]
 249            ["Indent Line or Region"  c-indent-line-or-region t]
 250            ["Up Conditional"         c-up-conditional t]
 251            ["Backward Conditional"   c-backward-conditional t]
 252            ["Forward Conditional"    c-forward-conditional t]
 253            ["Backward Statement"     c-beginning-of-statement t]
 254            ["Forward Statement"      c-end-of-statement t]
 255            "---"
 256            ["Macro Expand Region"    c-macro-expand (c-fn-region-is-active-p)]
 257            ["Backslashify"           c-backslash-region
 258             (c-fn-region-is-active-p)]
 259            )))
 260     (cons modestr m)))
 261
 262 ;; We don't require the outline package, but we configure it a bit anyway.
 263 (cc-bytecomp-defvar outline-level)
 264
 265 (defun c-common-init ()
 266   ;; Common initializations for all modes.
 267   ;; these variables should always be buffer local; they do not affect
 268   ;; indentation style.
 269   (make-local-variable 'require-final-newline)
 270   (make-local-variable 'parse-sexp-ignore-comments)
 271   (make-local-variable 'indent-line-function)
 272   (make-local-variable 'indent-region-function)
 273   (make-local-variable 'outline-regexp)
 274   (make-local-variable 'outline-level)
 275   (make-local-variable 'normal-auto-fill-function)
 276   (make-local-variable 'comment-start)
 277   (make-local-variable 'comment-end)
 278   (make-local-variable 'comment-column)
 279   (make-local-variable 'comment-start-skip)
 280   (make-local-variable 'comment-multi-line)
 281   (make-local-variable 'paragraph-start)
 282   (make-local-variable 'paragraph-separate)
 283   (make-local-variable 'paragraph-ignore-fill-prefix)
 284   (make-local-variable 'adaptive-fill-mode)
 285   (make-local-variable 'adaptive-fill-regexp)
 286   (make-local-variable 'imenu-generic-expression) ;set in the mode functions
 287   ;; X/Emacs 20 only
 288   (and (boundp 'comment-line-break-function)
 289        (progn
 290          (make-local-variable 'comment-line-break-function)
 291          (setq comment-line-break-function
 292                'c-indent-new-comment-line)))
 293   ;; now set their values
 294   (setq require-final-newline t
 295         parse-sexp-ignore-comments t
 296         indent-line-function 'c-indent-line
 297         indent-region-function 'c-indent-region
 298         outline-regexp "[^#\n\^M]"
 299         outline-level 'c-outline-level
 300         normal-auto-fill-function 'c-do-auto-fill
 301         comment-column 32
 302         comment-start-skip "/\\*+ *\\|//+ *"
 303         comment-multi-line t)
 304   ;; now set the mode style based on c-default-style
 305   (let ((style (if (stringp c-default-style)
 306                    c-default-style
 307                  (or (cdr (assq major-mode c-default-style))
 308                      (cdr (assq 'other c-default-style))
 309                      "gnu"))))
 310     ;; Override style variables if `c-old-style-variable-behavior' is
 311     ;; set.  Also override if we are using global style variables,
 312     ;; have already initialized a style once, and are switching to a
 313     ;; different style.  (It's doubtful whether this is desirable, but
 314     ;; the whole situation with nonlocal style variables is a bit
 315     ;; awkward.  It's at least the most compatible way with the old
 316     ;; style init procedure.)
 317     (c-set-style style (not (or c-old-style-variable-behavior
 318                                 (and (not c-style-variables-are-local-p)
 319                                      c-indentation-style
 320                                      (not (string-equal c-indentation-style
 321                                                         style)))))))
 322   ;; Fix things up for paragraph recognition and filling inside
 323   ;; comments by using c-current-comment-prefix in the relevant
 324   ;; places.  We use adaptive filling for this to make it possible to
 325   ;; use filladapt or some other fancy package.
 326   (setq c-current-comment-prefix
 327         (if (listp c-comment-prefix-regexp)
 328             (cdr-safe (or (assoc major-mode c-comment-prefix-regexp)
 329                           (assoc 'other c-comment-prefix-regexp)))
 330           c-comment-prefix-regexp))
 331   (let ((comment-line-prefix
 332          (concat "[ \t]*\\(" c-current-comment-prefix "\\)[ \t]*")))
 333     (setq paragraph-start (concat comment-line-prefix
 334                                   c-append-paragraph-start
 335                                   "\\|"
 336                                   page-delimiter)
 337           paragraph-separate (concat comment-line-prefix
 338                                      c-append-paragraph-separate
 339                                      "\\|"
 340                                      page-delimiter)
 341           paragraph-ignore-fill-prefix t
 342           adaptive-fill-mode t
 343           adaptive-fill-regexp
 344           (concat comment-line-prefix
 345                   (if adaptive-fill-regexp
 346                       (concat "\\(" adaptive-fill-regexp "\\)")
 347                     "")))
 348     (when (boundp 'adaptive-fill-first-line-regexp)
 349       ;; XEmacs (20.x) adaptive fill mode doesn't have this.
 350       (make-local-variable 'adaptive-fill-first-line-regexp)
 351       (setq adaptive-fill-first-line-regexp
 352             (concat "\\`" comment-line-prefix
 353                     ;; Maybe we should incorporate the old value here,
 354                     ;; but then we have to do all sorts of kludges to
 355                     ;; deal with the \` and \' it probably contains.
 356                     "\\'"))))
 357   ;; we have to do something special for c-offsets-alist so that the
 358   ;; buffer local value has its own alist structure.
 359   (setq c-offsets-alist (copy-alist c-offsets-alist))
 360   ;; setup the comment indent variable in a Emacs version portable way
 361   ;; ignore any byte compiler warnings you might get here
 362   (make-local-variable 'comment-indent-function)
 363   (setq comment-indent-function 'c-comment-indent)
 364   ;; add menus to menubar
 365   (easy-menu-add (c-mode-menu mode-name))
 366   ;; put auto-hungry designators onto minor-mode-alist, but only once
 367   (or (assq 'c-auto-hungry-string minor-mode-alist)
 368       (setq minor-mode-alist
 369             (cons '(c-auto-hungry-string c-auto-hungry-string)
 370                   minor-mode-alist)))
 371   )
 372
 373 (defun c-postprocess-file-styles ()
 374   "Function that post processes relevant file local variables.
 375 Currently, this function simply applies any style and offset settings
 376 found in the file's Local Variable list.  It first applies any style
 377 setting found in `c-file-style', then it applies any offset settings
 378 it finds in `c-file-offsets'.
 379
 380 Note that the style variables are always made local to the buffer."
 381   ;; apply file styles and offsets
 382   (if (or c-file-style c-file-offsets)
 383       (c-make-styles-buffer-local t))
 384   (and c-file-style
 385        (c-set-style c-file-style))
 386   (and c-file-offsets
 387        (mapcar
 388         (lambda (langentry)
 389           (let ((langelem (car langentry))
 390                 (offset (cdr langentry)))
 391             (c-set-offset langelem offset)))
 392         c-file-offsets)))
 393
 394 (add-hook 'hack-local-variables-hook 'c-postprocess-file-styles)
 395
 396 \f
 397 ;; Support for C
 398
 399 (defvar c-mode-abbrev-table nil
 400   "Abbreviation table used in c-mode buffers.")
 401 (define-abbrev-table 'c-mode-abbrev-table
 402   '(("else" "else" c-electric-continued-statement 0 t)
 403     ("while" "while" c-electric-continued-statement 0 t)))
 404
 405 (defvar c-mode-map ()
 406   "Keymap used in c-mode buffers.")
 407 (if c-mode-map
 408     nil
 409   (setq c-mode-map (c-make-inherited-keymap))
 410   ;; add bindings which are only useful for C
 411   (define-key c-mode-map "\C-c\C-e"  'c-macro-expand)
 412   )
 413
 414 (easy-menu-define c-c-menu c-mode-map "C Mode Commands"
 415                   (c-mode-menu "C"))
 416
 417 ;;;###autoload
 418 (defun c-mode ()
 419   "Major mode for editing K&R and ANSI C code.
 420 To submit a problem report, enter `\\[c-submit-bug-report]' from a
 421 c-mode buffer.  This automatically sets up a mail buffer with version
 422 information already added.  You just need to add a description of the
 423 problem, including a reproducible test case and send the message.
 424
 425 To see what version of CC Mode you are running, enter `\\[c-version]'.
 426
 427 The hook variable `c-mode-hook' is run with no args, if that value is
 428 bound and has a non-nil value.  Also the hook `c-mode-common-hook' is
 429 run first.
 430
 431 Key bindings:
 432 \\{c-mode-map}"
 433   (interactive)
 434   (c-initialize-cc-mode)
 435   (kill-all-local-variables)
 436   (set-syntax-table c-mode-syntax-table)
 437   (setq major-mode 'c-mode
 438         mode-name "C"
 439         local-abbrev-table c-mode-abbrev-table
 440         abbrev-mode t)
 441   (use-local-map c-mode-map)
 442   (c-common-init)
 443   (setq comment-start "/* "
 444         comment-end   " */"
 445         c-keywords (c-identifier-re c-C-keywords)
 446         c-conditional-key c-C-conditional-key
 447         c-class-key c-C-class-key
 448         c-baseclass-key nil
 449         c-comment-start-regexp c-C-comment-start-regexp
 450         c-bitfield-key c-C-bitfield-key
 451         )
 452   (cc-imenu-init cc-imenu-c-generic-expression)
 453   (run-hooks 'c-mode-common-hook)
 454   (run-hooks 'c-mode-hook)
 455   (c-update-modeline))
 456
 457 \f
 458 ;; Support for C++
 459
 460 (defvar c++-mode-abbrev-table nil
 461   "Abbreviation table used in c++-mode buffers.")
 462 (define-abbrev-table 'c++-mode-abbrev-table
 463   '(("else" "else" c-electric-continued-statement 0 t)
 464     ("while" "while" c-electric-continued-statement 0 t)
 465     ("catch" "catch" c-electric-continued-statement 0 t)))
 466
 467 (defvar c++-mode-map ()
 468   "Keymap used in c++-mode buffers.")
 469 (if c++-mode-map
 470     nil
 471   (setq c++-mode-map (c-make-inherited-keymap))
 472   ;; add bindings which are only useful for C++
 473   (define-key c++-mode-map "\C-c\C-e" 'c-macro-expand)
 474   (define-key c++-mode-map "\C-c:"    'c-scope-operator)
 475   (define-key c++-mode-map "<"        'c-electric-lt-gt)
 476   (define-key c++-mode-map ">"        'c-electric-lt-gt))
 477
 478 (easy-menu-define c-c++-menu c++-mode-map "C++ Mode Commands"
 479                   (c-mode-menu "C++"))
 480
 481 ;;;###autoload
 482 (defun c++-mode ()
 483   "Major mode for editing C++ code.
 484 To submit a problem report, enter `\\[c-submit-bug-report]' from a
 485 c++-mode buffer.  This automatically sets up a mail buffer with
 486 version information already added.  You just need to add a description
 487 of the problem, including a reproducible test case, and send the
 488 message.
 489
 490 To see what version of CC Mode you are running, enter `\\[c-version]'.
 491
 492 The hook variable `c++-mode-hook' is run with no args, if that
 493 variable is bound and has a non-nil value.  Also the hook
 494 `c-mode-common-hook' is run first.
 495
 496 Key bindings:
 497 \\{c++-mode-map}"
 498   (interactive)
 499   (c-initialize-cc-mode)
 500   (kill-all-local-variables)
 501   (set-syntax-table c++-mode-syntax-table)
 502   (setq major-mode 'c++-mode
 503         mode-name "C++"
 504         local-abbrev-table c++-mode-abbrev-table
 505         abbrev-mode t)
 506   (use-local-map c++-mode-map)
 507   (c-common-init)
 508   (setq comment-start "// "
 509         comment-end ""
 510         c-keywords (c-identifier-re c-C++-keywords)
 511         c-conditional-key c-C++-conditional-key
 512         c-comment-start-regexp c-C++-comment-start-regexp
 513         c-class-key c-C++-class-key
 514         c-extra-toplevel-key c-C++-extra-toplevel-key
 515         c-access-key c-C++-access-key
 516         c-recognize-knr-p nil
 517         c-bitfield-key c-C-bitfield-key
 518         )
 519   (cc-imenu-init cc-imenu-c++-generic-expression)
 520   (run-hooks 'c-mode-common-hook)
 521   (run-hooks 'c++-mode-hook)
 522   (c-update-modeline))
 523
 524 \f
 525 ;; Support for Objective-C
 526
 527 (defvar objc-mode-abbrev-table nil
 528   "Abbreviation table used in objc-mode buffers.")
 529 (define-abbrev-table 'objc-mode-abbrev-table
 530   '(("else" "else" c-electric-continued-statement 0 t)
 531     ("while" "while" c-electric-continued-statement 0 t)))
 532
 533 (defvar objc-mode-map ()
 534   "Keymap used in objc-mode buffers.")
 535 (if objc-mode-map
 536     nil
 537   (setq objc-mode-map (c-make-inherited-keymap))
 538   ;; add bindings which are only useful for Objective-C
 539   (define-key objc-mode-map "\C-c\C-e" 'c-macro-expand))
 540
 541 (easy-menu-define c-objc-menu objc-mode-map "ObjC Mode Commands"
 542                   (c-mode-menu "ObjC"))
 543
 544 ;;;###autoload
 545 (defun objc-mode ()
 546   "Major mode for editing Objective C code.
 547 To submit a problem report, enter `\\[c-submit-bug-report]' from an
 548 objc-mode buffer.  This automatically sets up a mail buffer with
 549 version information already added.  You just need to add a description
 550 of the problem, including a reproducible test case, and send the
 551 message.
 552
 553 To see what version of CC Mode you are running, enter `\\[c-version]'.
 554
 555 The hook variable `objc-mode-hook' is run with no args, if that value
 556 is bound and has a non-nil value.  Also the hook `c-mode-common-hook'
 557 is run first.
 558
 559 Key bindings:
 560 \\{objc-mode-map}"
 561   (interactive)
 562   (c-initialize-cc-mode)
 563   (kill-all-local-variables)
 564   (set-syntax-table objc-mode-syntax-table)
 565   (setq major-mode 'objc-mode
 566         mode-name "ObjC"
 567         local-abbrev-table objc-mode-abbrev-table
 568         abbrev-mode t)
 569   (use-local-map objc-mode-map)
 570   (c-common-init)
 571   (setq comment-start "// "
 572         comment-end   ""
 573         c-keywords (c-identifier-re c-ObjC-keywords)
 574         c-conditional-key c-ObjC-conditional-key
 575         c-comment-start-regexp c-ObjC-comment-start-regexp
 576         c-class-key c-ObjC-class-key
 577         c-baseclass-key nil
 578         c-access-key c-ObjC-access-key
 579         c-method-key c-ObjC-method-key
 580         )
 581   (cc-imenu-init cc-imenu-objc-generic-expression)
 582   (run-hooks 'c-mode-common-hook)
 583   (run-hooks 'objc-mode-hook)
 584   (c-update-modeline))
 585
 586 \f
 587 ;; Support for Java
 588
 589 (defvar java-mode-abbrev-table nil
 590   "Abbreviation table used in java-mode buffers.")
 591 (define-abbrev-table 'java-mode-abbrev-table
 592   '(("else" "else" c-electric-continued-statement 0 t)
 593     ("while" "while" c-electric-continued-statement 0 t)
 594     ("catch" "catch" c-electric-continued-statement 0 t)
 595     ("finally" "finally" c-electric-continued-statement 0 t)))
 596
 597 (defvar java-mode-map ()
 598   "Keymap used in java-mode buffers.")
 599 (if java-mode-map
 600     nil
 601   (setq java-mode-map (c-make-inherited-keymap))
 602   ;; add bindings which are only useful for Java
 603   )
 604
 605 (easy-menu-define c-java-menu java-mode-map "Java Mode Commands"
 606                   (c-mode-menu "Java"))
 607
 608 ;;;###autoload
 609 (defun java-mode ()
 610   "Major mode for editing Java code.
 611 To submit a problem report, enter `\\[c-submit-bug-report]' from a
 612 java-mode buffer.  This automatically sets up a mail buffer with
 613 version information already added.  You just need to add a description
 614 of the problem, including a reproducible test case and send the
 615 message.
 616
 617 To see what version of CC Mode you are running, enter `\\[c-version]'.
 618
 619 The hook variable `java-mode-hook' is run with no args, if that value
 620 is bound and has a non-nil value.  Also the common hook
 621 `c-mode-common-hook' is run first.  Note that this mode automatically
 622 sets the \"java\" style before calling any hooks so be careful if you
 623 set styles in `c-mode-common-hook'.
 624
 625 Key bindings:
 626 \\{java-mode-map}"
 627   (interactive)
 628   (c-initialize-cc-mode)
 629   (kill-all-local-variables)
 630   (set-syntax-table java-mode-syntax-table)
 631   (setq major-mode 'java-mode
 632         mode-name "Java"
 633         local-abbrev-table java-mode-abbrev-table
 634         abbrev-mode t
 635         c-append-paragraph-start c-Java-javadoc-paragraph-start)
 636   (use-local-map java-mode-map)
 637   (c-common-init)
 638   (setq comment-start "// "
 639         comment-end   ""
 640         c-keywords (c-identifier-re c-Java-keywords)
 641         c-conditional-key c-Java-conditional-key
 642         c-comment-start-regexp c-Java-comment-start-regexp
 643         c-class-key c-Java-class-key
 644         c-method-key nil
 645         c-baseclass-key nil
 646         c-recognize-knr-p nil
 647         c-inexpr-class-key c-Java-inexpr-class-key
 648         ;defun-prompt-regexp c-Java-defun-prompt-regexp
 649         )
 650   (cc-imenu-init cc-imenu-java-generic-expression)
 651   (run-hooks 'c-mode-common-hook)
 652   (run-hooks 'java-mode-hook)
 653   (c-update-modeline))
 654
 655 \f
 656 ;; Support for CORBA's IDL language
 657
 658 (defvar idl-mode-abbrev-table nil
 659   "Abbreviation table used in idl-mode buffers.")
 660 (define-abbrev-table 'idl-mode-abbrev-table ())
 661
 662 (defvar idl-mode-map ()
 663   "Keymap used in idl-mode buffers.")
 664 (if idl-mode-map
 665     nil
 666   (setq idl-mode-map (c-make-inherited-keymap))
 667   ;; add bindings which are only useful for IDL
 668   )
 669
 670 (easy-menu-define c-idl-menu idl-mode-map "IDL Mode Commands"
 671                   (c-mode-menu "IDL"))
 672
 673 ;;;###autoload
 674 (defun idl-mode ()
 675   "Major mode for editing CORBA's IDL code.
 676 To submit a problem report, enter `\\[c-submit-bug-report]' from an
 677 idl-mode buffer.  This automatically sets up a mail buffer with
 678 version information already added.  You just need to add a description
 679 of the problem, including a reproducible test case, and send the
 680 message.
 681
 682 To see what version of CC Mode you are running, enter `\\[c-version]'.
 683
 684 The hook variable `idl-mode-hook' is run with no args, if that
 685 variable is bound and has a non-nil value.  Also the hook
 686 `c-mode-common-hook' is run first.
 687
 688 Key bindings:
 689 \\{idl-mode-map}"
 690   (interactive)
 691   (c-initialize-cc-mode)
 692   (kill-all-local-variables)
 693   (set-syntax-table idl-mode-syntax-table)
 694   (setq major-mode 'idl-mode
 695         mode-name "IDL"
 696         local-abbrev-table idl-mode-abbrev-table)
 697   (use-local-map idl-mode-map)
 698   (c-common-init)
 699   (setq comment-start "// "
 700         comment-end ""
 701         c-keywords (c-identifier-re c-IDL-keywords)
 702         c-conditional-key c-IDL-conditional-key
 703         c-comment-start-regexp c-IDL-comment-start-regexp
 704         c-class-key c-IDL-class-key
 705         c-method-key nil
 706         c-baseclass-key nil
 707         c-extra-toplevel-key c-IDL-extra-toplevel-key
 708         c-recognize-knr-p nil
 709         )
 710   ;;(cc-imenu-init cc-imenu-idl-generic-expression) ;FIXME
 711   (run-hooks 'c-mode-common-hook)
 712   (run-hooks 'idl-mode-hook)
 713   (c-update-modeline))
 714
 715 \f
 716 ;; Support for Pike
 717
 718 (defvar pike-mode-abbrev-table nil
 719   "Abbreviation table used in pike-mode buffers.")
 720 (define-abbrev-table 'pike-mode-abbrev-table
 721   '(("else" "else" c-electric-continued-statement 0 t)
 722     ("while" "while" c-electric-continued-statement 0 t)))
 723
 724 (defvar pike-mode-map ()
 725   "Keymap used in pike-mode buffers.")
 726 (if pike-mode-map
 727     nil
 728   (setq pike-mode-map (c-make-inherited-keymap))
 729   ;; additional bindings
 730   (define-key pike-mode-map "\C-c\C-e" 'c-macro-expand))
 731
 732 (easy-menu-define c-pike-menu pike-mode-map "Pike Mode Commands"
 733                   (c-mode-menu "Pike"))
 734
 735 ;;;###autoload
 736 (defun pike-mode ()
 737   "Major mode for editing Pike code.
 738 To submit a problem report, enter `\\[c-submit-bug-report]' from an
 739 idl-mode buffer.  This automatically sets up a mail buffer with
 740 version information already added.  You just need to add a description
 741 of the problem, including a reproducible test case, and send the
 742 message.
 743
 744 To see what version of CC Mode you are running, enter `\\[c-version]'.
 745
 746 The hook variable `pike-mode-hook' is run with no args, if that value
 747 is bound and has a non-nil value.  Also the common hook
 748 `c-mode-common-hook' is run first.
 749
 750 Key bindings:
 751 \\{pike-mode-map}"
 752   (interactive)
 753   (c-initialize-cc-mode)
 754   (kill-all-local-variables)
 755   (set-syntax-table pike-mode-syntax-table)
 756   (setq major-mode 'pike-mode
 757         mode-name "Pike"
 758         local-abbrev-table pike-mode-abbrev-table
 759         abbrev-mode t
 760         c-append-paragraph-start c-Pike-pikedoc-paragraph-start
 761         c-append-paragraph-separate c-Pike-pikedoc-paragraph-separate)
 762   (use-local-map pike-mode-map)
 763   (c-common-init)
 764   (setq comment-start "// "
 765         comment-end   ""
 766         c-keywords (c-identifier-re c-Pike-keywords)
 767         c-conditional-key c-Pike-conditional-key
 768         c-comment-start-regexp c-Pike-comment-start-regexp
 769         c-class-key c-Pike-class-key
 770         c-method-key nil
 771         c-baseclass-key nil
 772         c-recognize-knr-p nil
 773         c-lambda-key c-Pike-lambda-key
 774         c-inexpr-block-key c-Pike-inexpr-block-key
 775         c-inexpr-class-key c-Pike-inexpr-class-key
 776         c-special-brace-lists c-Pike-special-brace-lists
 777         )
 778   ;;(cc-imenu-init cc-imenu-pike-generic-expression) ;FIXME
 779   (run-hooks 'c-mode-common-hook)
 780   (run-hooks 'pike-mode-hook)
 781   (c-update-modeline))
 782
 783 \f
 784 ;; Helper for setting up Filladapt mode.  It's not used by CC Mode itself.
 785
 786 (cc-bytecomp-defvar filladapt-token-table)
 787 (cc-bytecomp-defvar filladapt-token-match-table)
 788 (cc-bytecomp-defvar filladapt-token-conversion-table)
 789
 790 (defun c-setup-filladapt ()
 791   "Convenience function to configure Kyle E. Jones' Filladapt mode for
 792 CC Mode by making sure the proper entries are present on
 793 `filladapt-token-table', `filladapt-token-match-table', and
 794 `filladapt-token-conversion-table'.  This is intended to be used on
 795 `c-mode-common-hook' or similar."
 796   ;; This function is intended to be used explicitly by the end user
 797   ;; only.
 798   ;;
 799   ;; The default configuration already handles C++ comments, but we
 800   ;; need to add handling of C block comments.  A new filladapt token
 801   ;; `c-comment' is added for that.
 802   (let (p)
 803     (setq p filladapt-token-table)
 804     (while (and p (not (eq (car-safe (cdr-safe (car-safe p))) 'c-comment)))
 805       (setq p (cdr-safe p)))
 806     (if p
 807         (setcar (car p) c-current-comment-prefix)
 808       (setq filladapt-token-table
 809             (append (list (car filladapt-token-table)
 810                           (list c-current-comment-prefix 'c-comment))
 811                     (cdr filladapt-token-table)))))
 812   (unless (assq 'c-comment filladapt-token-match-table)
 813     (setq filladapt-token-match-table
 814           (append '((c-comment c-comment))
 815                   filladapt-token-match-table)))
 816   (unless (assq 'c-comment filladapt-token-conversion-table)
 817     (setq filladapt-token-conversion-table
 818           (append '((c-comment . exact))
 819                   filladapt-token-conversion-table))))
 820
 821 \f
 822 ;; bug reporting
 823
 824 (defconst c-mode-help-address
 825   "bug-gnu-emacs@gnu.org, bug-cc-mode@gnu.org"
 826   "Addresses for CC Mode bug reports.")
 827
 828 (defun c-version ()
 829   "Echo the current version of CC Mode in the minibuffer."
 830   (interactive)
 831   (message "Using CC Mode version %s" c-version)
 832   (c-keep-region-active))
 833
 834 (defvar c-prepare-bug-report-hooks nil)
 835
 836 ;; Dynamic variables used by reporter.
 837 (defvar reporter-prompt-for-summary-p)
 838 (defvar reporter-dont-compact-list)
 839
 840 (defun c-submit-bug-report ()
 841   "Submit via mail a bug report on CC Mode."
 842   (interactive)
 843   (require 'reporter)
 844   ;; load in reporter
 845   (let ((reporter-prompt-for-summary-p t)
 846         (reporter-dont-compact-list '(c-offsets-alist))
 847         (style c-indentation-style)
 848         (c-features c-emacs-features))
 849     (and
 850      (if (y-or-n-p "Do you want to submit a report on CC Mode? ")
 851          t (message "") nil)
 852      (require 'reporter)
 853      (reporter-submit-bug-report
 854       c-mode-help-address
 855       (concat "CC Mode " c-version " ("
 856               (cond ((eq major-mode 'c++-mode)  "C++")
 857                     ((eq major-mode 'c-mode)    "C")
 858                     ((eq major-mode 'objc-mode) "ObjC")
 859                     ((eq major-mode 'java-mode) "Java")
 860                     ((eq major-mode 'idl-mode)  "IDL")
 861                     ((eq major-mode 'pike-mode) "Pike")
 862                     )
 863               ")")
 864       (let ((vars (append
 865                    ;; report only the vars that affect indentation
 866                    c-style-variables
 867                    '(c-delete-function
 868                      c-electric-pound-behavior
 869                      c-indent-comments-syntactically-p
 870                      c-tab-always-indent
 871                      defun-prompt-regexp
 872                      tab-width
 873                      comment-column
 874                      parse-sexp-ignore-comments
 875                      ;; A brain-damaged XEmacs only variable that, if
 876                      ;; set to nil can cause all kinds of chaos.
 877                      signal-error-on-buffer-boundary
 878                      ;; Variables that affect line breaking and comments.
 879                      auto-fill-function
 880                      filladapt-mode
 881                      comment-multi-line
 882                      comment-start-skip
 883                      fill-prefix
 884                      paragraph-start
 885                      adaptive-fill-mode
 886                      adaptive-fill-regexp)
 887                    nil)))
 888         (delq 'c-special-indent-hook vars)
 889         (mapcar (lambda (var) (unless (boundp var) (delq var vars)))
 890                 '(signal-error-on-buffer-boundary
 891                   filladapt-mode
 892                   defun-prompt-regexp))
 893         vars)
 894       (lambda ()
 895         (run-hooks 'c-prepare-bug-report-hooks)
 896         (insert (format "Buffer Style: %s\n\nc-emacs-features: %s\n"
 897                         style c-features)))))))
 898
 899 \f
 900 (cc-provide 'cc-mode)
 901 ;;; cc-mode.el ends here