;;; cc-mode.el --- major mode for editing C and similar languages
-;; Copyright (C) 1985, 1987, 1992-2011 Free Software Foundation, Inc.
+;; Copyright (C) 1985, 1987, 1992-2014 Free Software Foundation, Inc.
;; Authors: 2003- Alan Mackenzie
;; 1998- Martin Stjernholm
(load "cc-bytecomp" nil t)))
(cc-require 'cc-defs)
-(cc-require-when-compile 'cc-langs)
(cc-require 'cc-vars)
+(cc-require-when-compile 'cc-langs)
(cc-require 'cc-engine)
(cc-require 'cc-styles)
(cc-require 'cc-cmds)
(cc-require 'cc-align)
(cc-require 'cc-menus)
+(cc-require 'cc-guess)
;; Silence the compiler.
(cc-bytecomp-defvar adaptive-fill-first-line-regexp) ; Emacs
-(cc-bytecomp-defun set-keymap-parents) ; XEmacs
(cc-bytecomp-defun run-mode-hooks) ; Emacs 21.1
;; We set these variables during mode init, yet we don't require
; '
(require 'cc-fonts) ;)
-;; cc-langs isn't loaded when we're byte compiled, so add autoload
-;; directives for the interface functions.
-(autoload 'c-make-init-lang-vars-fun "cc-langs")
-(autoload 'c-init-language-vars "cc-langs" nil nil 'macro)
-
\f
;; Other modes and packages which depend on CC Mode should do the
;; following to make sure everything is loaded and available for their
((cc-bytecomp-fboundp 'set-keymap-parent)
(set-keymap-parent map c-mode-base-map))
;; XEmacs
- ((cc-bytecomp-fboundp 'set-keymap-parents)
+ ((fboundp 'set-keymap-parents)
(set-keymap-parents map c-mode-base-map))
;; incompatible
(t (error "CC Mode is incompatible with this version of Emacs")))
map))
-(defun c-define-abbrev-table (name defs)
+(defun c-define-abbrev-table (name defs &optional doc)
;; Compatibility wrapper for `define-abbrev' which passes a non-nil
;; sixth argument for SYSTEM-FLAG in emacsen that support it
;; (currently only Emacs >= 21.2).
- (let ((table (or (symbol-value name)
- (progn (define-abbrev-table name nil)
+ (let ((table (or (and (boundp name) (symbol-value name))
+ (progn (condition-case nil
+ (define-abbrev-table name nil doc)
+ (wrong-number-of-arguments ;E.g. Emacs<23.
+ (eval `(defvar ,name nil ,doc))
+ (define-abbrev-table name nil)))
(symbol-value name)))))
(while defs
(condition-case nil
;; replaces `fill-paragraph' and does the adaption before calling
;; `fill-paragraph-function', and we have to mask comments etc
;; before that. Also, `c-fill-paragraph' chains on to
- ;; `fill-paragraph' and the value on `fill-parapgraph-function' to
+ ;; `fill-paragraph' and the value on `fill-paragraph-function' to
;; do the actual filling work.
(substitute-key-definition 'fill-paragraph 'c-fill-paragraph
c-mode-base-map global-map)
(make-local-variable 'comment-start)
(make-local-variable 'comment-end)
(make-local-variable 'comment-start-skip)
-
+
(make-local-variable 'paragraph-start)
(make-local-variable 'paragraph-separate)
(make-local-variable 'paragraph-ignore-fill-prefix)
(make-local-variable 'adaptive-fill-mode)
(make-local-variable 'adaptive-fill-regexp)
+ (make-local-variable 'fill-paragraph-handle-comment)
;; now set their values
(set (make-local-variable 'parse-sexp-ignore-comments) t)
(set (make-local-variable 'comment-line-break-function)
'c-indent-new-comment-line)
+ ;; For the benefit of adaptive file, which otherwise mis-fills.
+ (setq fill-paragraph-handle-comment nil)
+
;; Install `c-fill-paragraph' on `fill-paragraph-function' so that a
;; direct call to `fill-paragraph' behaves better. This still
;; doesn't work with filladapt but it's better than nothing.
(set (make-local-variable 'fill-paragraph-function) 'c-fill-paragraph)
- ;; Initialise the cache of brace pairs, and opening braces/brackets/parens.
+ ;; Initialize the cache of brace pairs, and opening braces/brackets/parens.
(c-state-cache-init)
(when (or c-recognize-<>-arglists
(c-clear-found-types)
;; now set the mode style based on default-style
- (let ((style (if (stringp default-style)
- default-style
- (or (cdr (assq mode default-style))
- (cdr (assq 'other default-style))
- "gnu"))))
+ (let ((style (cc-choose-style-for-mode mode default-style)))
;; Override style variables if `c-old-style-variable-behavior' is
;; set. Also override if we are using global style variables,
;; have already initialized a style once, and are switching to a
(add-hook 'after-change-functions 'c-after-change nil t)
(set (make-local-variable 'font-lock-extend-after-change-region-function)
'c-extend-after-change-region)) ; Currently (2009-05) used by all
- ; lanaguages with #define (C, C++,; ObjC), and by AWK.
+ ; languages with #define (C, C++,; ObjC), and by AWK.
(defun c-setup-doc-comment-style ()
"Initialize the variables that depend on the value of `c-doc-comment-style'."
;; Buffer local variables defining the region to be fontified by a font lock
;; after-change function. They are set in c-after-change to
-;; after-change-function's BEG and END, and may be modified by a
-;; `c-before-font-lock-function'.
+;; after-change-functions' BEG and END, and may be modified by functions in
+;; `c-before-font-lock-functions'.
(defvar c-new-BEG 0)
(make-variable-buffer-local 'c-new-BEG)
(defvar c-new-END 0)
(setq c-new-BEG (point-min))
(setq c-new-END (point-max))
(save-excursion
- (if c-get-state-before-change-functions
- (mapc (lambda (fn)
- (funcall fn (point-min) (point-max)))
- c-get-state-before-change-functions))
- (if c-before-font-lock-function
- (funcall c-before-font-lock-function (point-min) (point-max)
- (- (point-max) (point-min))))))
+ (mapc (lambda (fn)
+ (funcall fn (point-min) (point-max)))
+ c-get-state-before-change-functions)
+ (mapc (lambda (fn)
+ (funcall fn (point-min) (point-max)
+ (- (point-max) (point-min))))
+ c-before-font-lock-functions)))
(set (make-local-variable 'outline-regexp) "[^#\n\^M]")
(set (make-local-variable 'outline-level) 'c-outline-level)
-
+ (set (make-local-variable 'add-log-current-defun-function)
+ (lambda ()
+ (or (c-cpp-define-name) (c-defun-name))))
(let ((rfn (assq mode c-require-final-newline)))
(when rfn
(and (cdr rfn)
(when (eq (car elt) 'c-file-style)
(setq cownt (1+ cownt))))
cownt))
-
+
(defun c-before-hack-hook ()
"Set the CC Mode style and \"offsets\" when in the buffer's local variables.
They are set only when, respectively, the pseudo variables
(c-count-cfss file-local-variables-alist))
(cfs-in-dir-count (c-count-cfss dir-local-variables-alist)))
(c-set-style stile
- (= cfs-in-file-and-dir-count cfs-in-dir-count)))
+ (and (= cfs-in-file-and-dir-count cfs-in-dir-count)
+ 'keep-defaults)))
(c-set-style stile)))
(when offsets
(mapc
; with a c-cpp-delimiter category property
(setq c-old-EOM (point)))
+(defun c-extend-font-lock-region-for-macros (begg endd &optional old-len)
+ ;; Extend the region (BEGG ENDD) to cover all (possibly changed)
+ ;; preprocessor macros; return the cons (new-BEG . new-END). OLD-LEN should
+ ;; be either the old length parameter when called from an
+ ;; after-change-function, or nil otherwise. This defun uses the variables
+ ;; c-old-BOM, c-new-BOM.
+ ;;
+ ;; Point is undefined on both entry and exit to this function. The buffer
+ ;; will have been widened on entry.
+ (let (limits new-beg new-end)
+ (goto-char c-old-BOM) ; already set to old start of macro or begg.
+ (setq new-beg
+ (min begg
+ (if (setq limits (c-state-literal-at (point)))
+ (cdr limits) ; go forward out of any string or comment.
+ (point))))
+
+ (goto-char endd)
+ (if (setq limits (c-state-literal-at (point)))
+ (goto-char (car limits))) ; go backward out of any string or comment.
+ (if (c-beginning-of-macro)
+ (c-end-of-macro))
+ (setq new-end (max endd
+ (if old-len
+ (+ (- c-old-EOM old-len) (- endd begg))
+ c-old-EOM)
+ (point)))
+ (cons new-beg new-end)))
+
(defun c-neutralize-CPP-line (beg end)
;; BEG and END bound a region, typically a preprocessor line. Put a
;; "punctuation" syntax-table property on syntactically obtrusive
;; (i) Extend the font lock region to cover all changed preprocessor
;; regions; it does this by setting the variables `c-new-BEG' and
;; `c-new-END' to the new boundaries.
- ;;
+ ;;
;; (ii) "Neutralize" every preprocessor line wholly or partially in the
;; extended changed region. "Restore" lines which were CPP lines before the
;; change and are no longer so; these can be located from the Buffer local
;; Point is undefined both before and after this function call, the buffer
;; has been widened, and match-data saved. The return value is ignored.
;;
- ;; This function is the C/C++/ObjC value of `c-before-font-lock-function'.
+ ;; This function is in the C/C++/ObjC value of `c-before-font-lock-functions'.
;;
;; Note: SPEED _MATTERS_ IN THIS FUNCTION!!!
;;
;; This function might make hidden buffer changes.
- (c-save-buffer-state (limits)
+ (c-save-buffer-state (new-bounds)
;; First determine the region, (c-new-BEG c-new-END), which will get font
;; locked. It might need "neutralizing". This region may not start
;; inside a string, comment, or macro.
- (goto-char c-old-BOM) ; already set to old start of macro or begg.
- (setq c-new-BEG
- (min c-new-BEG
- (if (setq limits (c-state-literal-at (point)))
- (cdr limits) ; go forward out of any string or comment.
- (point))))
-
- (goto-char endd)
- (if (setq limits (c-state-literal-at (point)))
- (goto-char (car limits))) ; go backward out of any string or comment.
- (if (c-beginning-of-macro)
- (c-end-of-macro))
- (setq c-new-END (max c-new-END
- (+ (- c-old-EOM old-len) (- endd begg))
- (point)))
-
+ (setq new-bounds (c-extend-font-lock-region-for-macros
+ c-new-BEG c-new-END old-len))
+ (setq c-new-BEG (max (car new-bounds) (c-determine-limit 500 begg))
+ c-new-END (min (cdr new-bounds) (c-determine-+ve-limit 500 endd)))
;; Clear all old relevant properties.
(c-clear-char-property-with-value c-new-BEG c-new-END 'syntax-table '(1))
(c-clear-char-property-with-value c-new-BEG c-new-END 'category 'c-cpp-delimiter)
;; Add needed properties to each CPP construct in the region.
(goto-char c-new-BEG)
- (let ((pps-position c-new-BEG) pps-state mbeg)
+ (skip-chars-backward " \t")
+ (let ((pps-position (point)) pps-state mbeg)
(while (and (< (point) c-new-END)
(search-forward-regexp c-anchored-cpp-prefix c-new-END t))
;; If we've found a "#" inside a string/comment, ignore it.
pps-position (point))
(unless (or (nth 3 pps-state) ; in a string?
(nth 4 pps-state)) ; in a comment?
- (goto-char (match-beginning 0))
+ (goto-char (match-beginning 1))
(setq mbeg (point))
(if (> (c-syntactic-end-of-macro) mbeg)
(progn
(c-neutralize-CPP-line mbeg (point))
- (c-set-cpp-delimiters mbeg (point))
- ;(setq pps-position (point))
- )
+ (c-set-cpp-delimiters mbeg (point)))
(forward-line)) ; no infinite loop with, e.g., "#//"
)))))
;; Note that this function must be FAST rather than accurate. Note
;; also that it only has any effect when font locking is enabled.
;; We exploit this by checking for font-lock-*-face instead of doing
- ;; rigourous syntactic analysis.
+ ;; rigorous syntactic analysis.
;; If either change boundary is wholly inside an identifier, delete
;; it/them from the cache. Don't worry about being inside a string
(list type marked-id
type-pos term-pos
(buffer-substring-no-properties type-pos term-pos)
- (buffer-substring-no-properties beg end)))))))
-
- (if c-get-state-before-change-functions
- (mapc (lambda (fn)
- (funcall fn beg end))
- c-get-state-before-change-functions))
- ))))
+ (buffer-substring-no-properties beg end)))))))
+
+ (if c-get-state-before-change-functions
+ (let (open-paren-in-column-0-is-defun-start)
+ (mapc (lambda (fn)
+ (funcall fn beg end))
+ c-get-state-before-change-functions)))
+ )))
+ ;; The following must be done here rather than in `c-after-change' because
+ ;; newly inserted parens would foul up the invalidation algorithm.
+ (c-invalidate-state-cache beg))
+
+(defvar c-in-after-change-fontification nil)
+(make-variable-buffer-local 'c-in-after-change-fontification)
+;; A flag to prevent region expanding stuff being done twice for after-change
+;; fontification.
(defun c-after-change (beg end old-len)
;; Function put on `after-change-functions' to adjust various caches
;; these caches from inside them, and we must thus be sure that this
;; has already been executed.
;;
- ;; This calls the language variable c-before-font-lock-function, if non nil.
+ ;; This calls the language variable c-before-font-lock-functions, if non nil.
;; This typically sets `syntax-table' properties.
- (c-save-buffer-state ()
+ (c-save-buffer-state (case-fold-search open-paren-in-column-0-is-defun-start)
;; When `combine-after-change-calls' is used we might get calls
;; with regions outside the current narrowing. This has been
;; observed in Emacs 20.7.
(setq beg end)))
;; C-y is capable of spuriously converting category properties
- ;; c-</>-as-paren-syntax into hard syntax-table properties. Remove
- ;; these when it happens.
+ ;; c-</>-as-paren-syntax and c-cpp-delimiter into hard syntax-table
+ ;; properties. Remove these when it happens.
(c-clear-char-property-with-value beg end 'syntax-table
c-<-as-paren-syntax)
(c-clear-char-property-with-value beg end 'syntax-table
c->-as-paren-syntax)
+ (c-clear-char-property-with-value beg end 'syntax-table nil)
(c-trim-found-types beg end old-len) ; maybe we don't need all of these.
(c-invalidate-sws-region-after beg end)
- (c-invalidate-state-cache beg)
+ ;; (c-invalidate-state-cache beg) ; moved to `c-before-change'.
(c-invalidate-find-decl-cache beg)
(when c-recognize-<>-arglists
;; larger than (beg end).
(setq c-new-BEG beg
c-new-END end)
- (if c-before-font-lock-function
- (save-excursion
- (funcall c-before-font-lock-function beg end old-len)))))))
+ (setq c-in-after-change-fontification t)
+ (save-excursion
+ (mapc (lambda (fn)
+ (funcall fn beg end old-len))
+ c-before-font-lock-functions))))))
+
+(defun c-set-fl-decl-start (pos)
+ ;; If the beginning of the line containing POS is in the middle of a "local"
+ ;; declaration (i.e. one which does not start outside of braces enclosing
+ ;; POS, such as a struct), return the beginning of that declaration.
+ ;; Otherwise return POS. Note that declarations, in this sense, can be
+ ;; nested.
+ ;;
+ ;; This function is called indirectly from font locking stuff - either from
+ ;; c-after-change (to prepare for after-change font-locking) or from font
+ ;; lock context (etc.) fontification.
+ (let ((lit-limits (c-literal-limits))
+ (new-pos pos)
+ bod-lim bo-decl)
+ (goto-char (c-point 'bol new-pos))
+ (when lit-limits ; Comment or string.
+ (goto-char (car lit-limits)))
+ (setq bod-lim (c-determine-limit 500))
+
+ (while
+ ;; Go to a less nested declaration each time round this loop.
+ (and
+ (eq (car (c-beginning-of-decl-1 bod-lim)) 'same)
+ (progn (setq bo-decl (point))
+ ;; Are we looking at a keyword such as "template" or
+ ;; "typedef" which can decorate a type, or the type itself?
+ (when (or (looking-at c-prefix-spec-kwds-re)
+ (c-forward-type t))
+ ;; We've found another candidate position.
+ (setq new-pos (min new-pos bo-decl))
+ (goto-char bo-decl))
+ t)
+ ;; Try and go out a level to search again.
+ (progn
+ (c-backward-syntactic-ws bod-lim)
+ (and (> (point) bod-lim)
+ (or (memq (char-before) '(?\( ?\[))
+ (and (eq (char-before) ?\<)
+ (eq (c-get-char-property
+ (1- (point)) 'syntax-table)
+ c-<-as-paren-syntax)))))
+ (not (bobp)))
+ (backward-char))
+ new-pos)) ; back over (, [, <.
+
+(defun c-change-set-fl-decl-start (beg end old-len)
+ ;; Set c-new-BEG to the beginning of a "local" declaration if it('s BOL) is
+ ;; inside one. This is called from an after-change-function, but the
+ ;; parameters BEG END and OLD-LEN are ignored. See `c-set-fl-decl-start'
+ ;; for the detailed functionality.
+ (if font-lock-mode
+ (setq c-new-BEG (c-set-fl-decl-start c-new-BEG))))
+
+(defun c-context-set-fl-decl-start (beg end)
+ ;; Return a cons (NEW-BEG . END), where NEW-BEG is the beginning of a
+ ;; "local" declaration (BOL at) NEW is inside or BEG. See
+ ;; `c-set-fl-decl-start' for the detailed functionality.
+ (cons (c-set-fl-decl-start beg) end))
+
+(defun c-font-lock-fontify-region (beg end &optional verbose)
+ ;; Effectively advice around `font-lock-fontify-region' which extends the
+ ;; region (BEG END), for example, to avoid context fontification chopping
+ ;; off the start of the context. Do not do anything if it's already been
+ ;; done (i.e. from an after-change fontification. An example (C++) where
+ ;; this used to happen is this:
+ ;;
+ ;; template <typename T>
+ ;;
+ ;;
+ ;; void myfunc(T* p) {}
+ ;;
+ ;; Type a space in the first blank line, and the fontification of the next
+ ;; line was fouled up by context fontification.
+ (let ((new-beg beg) (new-end end) new-region case-fold-search
+ open-paren-in-column-0-is-defun-start)
+ (if c-in-after-change-fontification
+ (setq c-in-after-change-fontification nil)
+ (save-restriction
+ (widen)
+ (save-excursion
+ (mapc (lambda (fn)
+ (setq new-region (funcall fn new-beg new-end))
+ (setq new-beg (car new-region) new-end (cdr new-region)))
+ c-before-context-fontification-functions))))
+ (funcall (default-value 'font-lock-fontify-region-function)
+ new-beg new-end verbose)))
(defun c-after-font-lock-init ()
- ;; Put on `font-lock-mode-hook'.
+ ;; Put on `font-lock-mode-hook'. This function ensures our after-change
+ ;; function will get executed before the font-lock one.
(remove-hook 'after-change-functions 'c-after-change t)
(add-hook 'after-change-functions 'c-after-change nil t))
(defun c-font-lock-init ()
"Set up the font-lock variables for using the font-lock support in CC Mode.
This does not load the font-lock package. Use after
-`c-basic-common-init' and after cc-fonts has been loaded."
+`c-basic-common-init' and after cc-fonts has been loaded.
+This function is called from `c-common-init', once per mode initialization."
(set (make-local-variable 'font-lock-defaults)
`(,(if (c-major-mode-is 'awk-mode)
c-beginning-of-syntax
(font-lock-mark-block-function
. c-mark-function)))
+
+ (make-local-variable 'font-lock-fontify-region-function)
+ (setq font-lock-fontify-region-function 'c-font-lock-fontify-region)
+
(if (featurep 'xemacs)
(make-local-hook 'font-lock-mode-hook))
(add-hook 'font-lock-mode-hook 'c-after-font-lock-init nil t))
\f
;; Support for C
-;;;###autoload
-(defvar c-mode-syntax-table nil
+(defvar c-mode-syntax-table
+ (funcall (c-lang-const c-make-mode-syntax-table c))
"Syntax table used in c-mode buffers.")
-(or c-mode-syntax-table
- (setq c-mode-syntax-table
- (funcall (c-lang-const c-make-mode-syntax-table c))))
-(defvar c-mode-abbrev-table nil
- "Abbreviation table used in c-mode buffers.")
(c-define-abbrev-table 'c-mode-abbrev-table
'(("else" "else" c-electric-continued-statement 0)
- ("while" "while" c-electric-continued-statement 0)))
+ ("while" "while" c-electric-continued-statement 0))
+ "Abbreviation table used in c-mode buffers.")
-(defvar c-mode-map ()
+(defvar c-mode-map
+ (let ((map (c-make-inherited-keymap)))
+ ;; Add bindings which are only useful for C.
+ (define-key map "\C-c\C-e" 'c-macro-expand)
+ map)
"Keymap used in c-mode buffers.")
-(if c-mode-map
- nil
- (setq c-mode-map (c-make-inherited-keymap))
- ;; add bindings which are only useful for C
- (define-key c-mode-map "\C-c\C-e" 'c-macro-expand)
- )
+
(easy-menu-define c-c-menu c-mode-map "C Mode Commands"
(cons "C" (c-lang-const c-mode-menu c)))
;;;###autoload
-(defun c-mode ()
+(define-derived-mode c-mode prog-mode "C"
"Major mode for editing K&R and ANSI C code.
To submit a problem report, enter `\\[c-submit-bug-report]' from a
c-mode buffer. This automatically sets up a mail buffer with version
Key bindings:
\\{c-mode-map}"
- (interactive)
- (kill-all-local-variables)
(c-initialize-cc-mode t)
(set-syntax-table c-mode-syntax-table)
- (setq major-mode 'c-mode ; FIXME: Use define-derived-mode.
- mode-name "C"
- local-abbrev-table c-mode-abbrev-table
+ (setq local-abbrev-table c-mode-abbrev-table
abbrev-mode t)
(use-local-map c-mode-map)
(c-init-language-vars-for 'c-mode)
+ (c-make-macro-with-semi-re) ; matches macro names whose expansion ends with ;
(c-common-init 'c-mode)
(easy-menu-add c-c-menu)
(cc-imenu-init cc-imenu-c-generic-expression)
\f
;; Support for C++
-;;;###autoload
-(defvar c++-mode-syntax-table nil
+(defvar c++-mode-syntax-table
+ (funcall (c-lang-const c-make-mode-syntax-table c++))
"Syntax table used in c++-mode buffers.")
-(or c++-mode-syntax-table
- (setq c++-mode-syntax-table
- (funcall (c-lang-const c-make-mode-syntax-table c++))))
-(defvar c++-mode-abbrev-table nil
- "Abbreviation table used in c++-mode buffers.")
(c-define-abbrev-table 'c++-mode-abbrev-table
'(("else" "else" c-electric-continued-statement 0)
("while" "while" c-electric-continued-statement 0)
- ("catch" "catch" c-electric-continued-statement 0)))
+ ("catch" "catch" c-electric-continued-statement 0))
+ "Abbreviation table used in c++-mode buffers.")
-(defvar c++-mode-map ()
+(defvar c++-mode-map
+ (let ((map (c-make-inherited-keymap)))
+ ;; Add bindings which are only useful for C++.
+ (define-key map "\C-c\C-e" 'c-macro-expand)
+ (define-key map "\C-c:" 'c-scope-operator)
+ (define-key map "<" 'c-electric-lt-gt)
+ (define-key map ">" 'c-electric-lt-gt)
+ map)
"Keymap used in c++-mode buffers.")
-(if c++-mode-map
- nil
- (setq c++-mode-map (c-make-inherited-keymap))
- ;; add bindings which are only useful for C++
- (define-key c++-mode-map "\C-c\C-e" 'c-macro-expand)
- (define-key c++-mode-map "\C-c:" 'c-scope-operator)
- (define-key c++-mode-map "<" 'c-electric-lt-gt)
- (define-key c++-mode-map ">" 'c-electric-lt-gt))
(easy-menu-define c-c++-menu c++-mode-map "C++ Mode Commands"
(cons "C++" (c-lang-const c-mode-menu c++)))
;;;###autoload
-(defun c++-mode ()
+(define-derived-mode c++-mode prog-mode "C++"
"Major mode for editing C++ code.
To submit a problem report, enter `\\[c-submit-bug-report]' from a
c++-mode buffer. This automatically sets up a mail buffer with
Key bindings:
\\{c++-mode-map}"
- (interactive)
- (kill-all-local-variables)
(c-initialize-cc-mode t)
(set-syntax-table c++-mode-syntax-table)
- (setq major-mode 'c++-mode ; FIXME: Use define-derived-mode.
- mode-name "C++"
- local-abbrev-table c++-mode-abbrev-table
+ (setq local-abbrev-table c++-mode-abbrev-table
abbrev-mode t)
(use-local-map c++-mode-map)
(c-init-language-vars-for 'c++-mode)
+ (c-make-macro-with-semi-re) ; matches macro names whose expansion ends with ;
(c-common-init 'c++-mode)
(easy-menu-add c-c++-menu)
(cc-imenu-init cc-imenu-c++-generic-expression)
\f
;; Support for Objective-C
-;;;###autoload
-(defvar objc-mode-syntax-table nil
+(defvar objc-mode-syntax-table
+ (funcall (c-lang-const c-make-mode-syntax-table objc))
"Syntax table used in objc-mode buffers.")
-(or objc-mode-syntax-table
- (setq objc-mode-syntax-table
- (funcall (c-lang-const c-make-mode-syntax-table objc))))
-(defvar objc-mode-abbrev-table nil
- "Abbreviation table used in objc-mode buffers.")
(c-define-abbrev-table 'objc-mode-abbrev-table
'(("else" "else" c-electric-continued-statement 0)
- ("while" "while" c-electric-continued-statement 0)))
+ ("while" "while" c-electric-continued-statement 0))
+ "Abbreviation table used in objc-mode buffers.")
-(defvar objc-mode-map ()
+(defvar objc-mode-map
+ (let ((map (c-make-inherited-keymap)))
+ ;; Add bindings which are only useful for Objective-C.
+ (define-key map "\C-c\C-e" 'c-macro-expand)
+ map)
"Keymap used in objc-mode buffers.")
-(if objc-mode-map
- nil
- (setq objc-mode-map (c-make-inherited-keymap))
- ;; add bindings which are only useful for Objective-C
- (define-key objc-mode-map "\C-c\C-e" 'c-macro-expand))
(easy-menu-define c-objc-menu objc-mode-map "ObjC Mode Commands"
(cons "ObjC" (c-lang-const c-mode-menu objc)))
;;;###autoload (add-to-list 'auto-mode-alist '("\\.m\\'" . objc-mode))
;;;###autoload
-(defun objc-mode ()
+(define-derived-mode objc-mode prog-mode "ObjC"
"Major mode for editing Objective C code.
To submit a problem report, enter `\\[c-submit-bug-report]' from an
objc-mode buffer. This automatically sets up a mail buffer with
Key bindings:
\\{objc-mode-map}"
- (interactive)
- (kill-all-local-variables)
(c-initialize-cc-mode t)
(set-syntax-table objc-mode-syntax-table)
- (setq major-mode 'objc-mode ; FIXME: Use define-derived-mode.
- mode-name "ObjC"
- local-abbrev-table objc-mode-abbrev-table
+ (setq local-abbrev-table objc-mode-abbrev-table
abbrev-mode t)
(use-local-map objc-mode-map)
(c-init-language-vars-for 'objc-mode)
+ (c-make-macro-with-semi-re) ; matches macro names whose expansion ends with ;
(c-common-init 'objc-mode)
(easy-menu-add c-objc-menu)
(cc-imenu-init nil 'cc-imenu-objc-function)
\f
;; Support for Java
-;;;###autoload
-(defvar java-mode-syntax-table nil
+(defvar java-mode-syntax-table
+ (funcall (c-lang-const c-make-mode-syntax-table java))
"Syntax table used in java-mode buffers.")
-(or java-mode-syntax-table
- (setq java-mode-syntax-table
- (funcall (c-lang-const c-make-mode-syntax-table java))))
-(defvar java-mode-abbrev-table nil
- "Abbreviation table used in java-mode buffers.")
(c-define-abbrev-table 'java-mode-abbrev-table
'(("else" "else" c-electric-continued-statement 0)
("while" "while" c-electric-continued-statement 0)
("catch" "catch" c-electric-continued-statement 0)
- ("finally" "finally" c-electric-continued-statement 0)))
+ ("finally" "finally" c-electric-continued-statement 0))
+ "Abbreviation table used in java-mode buffers.")
-(defvar java-mode-map ()
+(defvar java-mode-map
+ (let ((map (c-make-inherited-keymap)))
+ ;; Add bindings which are only useful for Java.
+ map)
"Keymap used in java-mode buffers.")
-(if java-mode-map
- nil
- (setq java-mode-map (c-make-inherited-keymap))
- ;; add bindings which are only useful for Java
- )
;; Regexp trying to describe the beginning of a Java top-level
;; definition. This is not used by CC Mode, nor is it maintained
;;;###autoload (add-to-list 'auto-mode-alist '("\\.java\\'" . java-mode))
;;;###autoload
-(defun java-mode ()
+(define-derived-mode java-mode prog-mode "Java"
"Major mode for editing Java code.
To submit a problem report, enter `\\[c-submit-bug-report]' from a
java-mode buffer. This automatically sets up a mail buffer with
Key bindings:
\\{java-mode-map}"
- (interactive)
- (kill-all-local-variables)
(c-initialize-cc-mode t)
(set-syntax-table java-mode-syntax-table)
- (setq major-mode 'java-mode ; FIXME: Use define-derived-mode.
- mode-name "Java"
- local-abbrev-table java-mode-abbrev-table
+ (setq local-abbrev-table java-mode-abbrev-table
abbrev-mode t)
(use-local-map java-mode-map)
(c-init-language-vars-for 'java-mode)
\f
;; Support for CORBA's IDL language
-;;;###autoload
-(defvar idl-mode-syntax-table nil
+(defvar idl-mode-syntax-table
+ (funcall (c-lang-const c-make-mode-syntax-table idl))
"Syntax table used in idl-mode buffers.")
-(or idl-mode-syntax-table
- (setq idl-mode-syntax-table
- (funcall (c-lang-const c-make-mode-syntax-table idl))))
-(defvar idl-mode-abbrev-table nil
+(c-define-abbrev-table 'idl-mode-abbrev-table nil
"Abbreviation table used in idl-mode buffers.")
-(c-define-abbrev-table 'idl-mode-abbrev-table nil)
-(defvar idl-mode-map ()
+(defvar idl-mode-map
+ (let ((map (c-make-inherited-keymap)))
+ ;; Add bindings which are only useful for IDL.
+ map)
"Keymap used in idl-mode buffers.")
-(if idl-mode-map
- nil
- (setq idl-mode-map (c-make-inherited-keymap))
- ;; add bindings which are only useful for IDL
- )
(easy-menu-define c-idl-menu idl-mode-map "IDL Mode Commands"
(cons "IDL" (c-lang-const c-mode-menu idl)))
;;;###autoload (add-to-list 'auto-mode-alist '("\\.idl\\'" . idl-mode))
;;;###autoload
-(defun idl-mode ()
+(define-derived-mode idl-mode prog-mode "IDL"
"Major mode for editing CORBA's IDL, PSDL and CIDL code.
To submit a problem report, enter `\\[c-submit-bug-report]' from an
idl-mode buffer. This automatically sets up a mail buffer with
Key bindings:
\\{idl-mode-map}"
- (interactive)
- (kill-all-local-variables)
(c-initialize-cc-mode t)
(set-syntax-table idl-mode-syntax-table)
- (setq major-mode 'idl-mode ; FIXME: Use define-derived-mode.
- mode-name "IDL"
- local-abbrev-table idl-mode-abbrev-table)
+ (setq local-abbrev-table idl-mode-abbrev-table)
(use-local-map idl-mode-map)
(c-init-language-vars-for 'idl-mode)
(c-common-init 'idl-mode)
\f
;; Support for Pike
-;;;###autoload
-(defvar pike-mode-syntax-table nil
+(defvar pike-mode-syntax-table
+ (funcall (c-lang-const c-make-mode-syntax-table pike))
"Syntax table used in pike-mode buffers.")
-(or pike-mode-syntax-table
- (setq pike-mode-syntax-table
- (funcall (c-lang-const c-make-mode-syntax-table pike))))
-(defvar pike-mode-abbrev-table nil
- "Abbreviation table used in pike-mode buffers.")
(c-define-abbrev-table 'pike-mode-abbrev-table
'(("else" "else" c-electric-continued-statement 0)
- ("while" "while" c-electric-continued-statement 0)))
+ ("while" "while" c-electric-continued-statement 0))
+ "Abbreviation table used in pike-mode buffers.")
-(defvar pike-mode-map ()
+(defvar pike-mode-map
+ (let ((map (c-make-inherited-keymap)))
+ ;; Additional bindings.
+ (define-key map "\C-c\C-e" 'c-macro-expand)
+ map)
"Keymap used in pike-mode buffers.")
-(if pike-mode-map
- nil
- (setq pike-mode-map (c-make-inherited-keymap))
- ;; additional bindings
- (define-key pike-mode-map "\C-c\C-e" 'c-macro-expand))
(easy-menu-define c-pike-menu pike-mode-map "Pike Mode Commands"
(cons "Pike" (c-lang-const c-mode-menu pike)))
-;;;###autoload (add-to-list 'auto-mode-alist '("\\.\\(u?lpc\\|pike\\|pmod\\(.in\\)?\\)\\'" . pike-mode))
+;;;###autoload (add-to-list 'auto-mode-alist '("\\.\\(u?lpc\\|pike\\|pmod\\(\\.in\\)?\\)\\'" . pike-mode))
;;;###autoload (add-to-list 'interpreter-mode-alist '("pike" . pike-mode))
;;;###autoload
-(defun pike-mode ()
+(define-derived-mode pike-mode prog-mode "Pike"
"Major mode for editing Pike code.
To submit a problem report, enter `\\[c-submit-bug-report]' from a
pike-mode buffer. This automatically sets up a mail buffer with
Key bindings:
\\{pike-mode-map}"
- (interactive)
- (kill-all-local-variables)
(c-initialize-cc-mode t)
(set-syntax-table pike-mode-syntax-table)
- (setq major-mode 'pike-mode ; FIXME: Use define-derived-mode.
- mode-name "Pike"
- local-abbrev-table pike-mode-abbrev-table
+ (setq local-abbrev-table pike-mode-abbrev-table
abbrev-mode t)
(use-local-map pike-mode-map)
(c-init-language-vars-for 'pike-mode)
;;;###autoload (add-to-list 'interpreter-mode-alist '("nawk" . awk-mode))
;;;###autoload (add-to-list 'interpreter-mode-alist '("gawk" . awk-mode))
-;;; Autoload directives must be on the top level, so we construct an
-;;; autoload form instead.
-;;;###autoload (autoload 'awk-mode "cc-mode" "Major mode for editing AWK code." t)
-
-(defvar awk-mode-abbrev-table nil
- "Abbreviation table used in awk-mode buffers.")
(c-define-abbrev-table 'awk-mode-abbrev-table
'(("else" "else" c-electric-continued-statement 0)
- ("while" "while" c-electric-continued-statement 0)))
+ ("while" "while" c-electric-continued-statement 0))
+ "Abbreviation table used in awk-mode buffers.")
-(defvar awk-mode-map ()
+(defvar awk-mode-map
+ (let ((map (c-make-inherited-keymap)))
+ ;; Add bindings which are only useful for awk.
+ (define-key map "#" 'self-insert-command)
+ (define-key map "/" 'self-insert-command)
+ (define-key map "*" 'self-insert-command)
+ (define-key map "\C-c\C-n" 'undefined) ; #if doesn't exist in awk.
+ (define-key map "\C-c\C-p" 'undefined)
+ (define-key map "\C-c\C-u" 'undefined)
+ (define-key map "\M-a" 'c-beginning-of-statement) ; 2003/10/7
+ (define-key map "\M-e" 'c-end-of-statement) ; 2003/10/7
+ (define-key map "\C-\M-a" 'c-awk-beginning-of-defun)
+ (define-key map "\C-\M-e" 'c-awk-end-of-defun)
+ map)
"Keymap used in awk-mode buffers.")
-(if awk-mode-map
- nil
- (setq awk-mode-map (c-make-inherited-keymap))
- ;; add bindings which are only useful for awk.
- (define-key awk-mode-map "#" 'self-insert-command)
- (define-key awk-mode-map "/" 'self-insert-command)
- (define-key awk-mode-map "*" 'self-insert-command)
- (define-key awk-mode-map "\C-c\C-n" 'undefined) ; #if doesn't exist in awk.
- (define-key awk-mode-map "\C-c\C-p" 'undefined)
- (define-key awk-mode-map "\C-c\C-u" 'undefined)
- (define-key awk-mode-map "\M-a" 'c-beginning-of-statement) ; 2003/10/7
- (define-key awk-mode-map "\M-e" 'c-end-of-statement) ; 2003/10/7
- (define-key awk-mode-map "\C-\M-a" 'c-awk-beginning-of-defun)
- (define-key awk-mode-map "\C-\M-e" 'c-awk-end-of-defun))
(easy-menu-define c-awk-menu awk-mode-map "AWK Mode Commands"
(cons "AWK" (c-lang-const c-mode-menu awk)))
(defvar awk-mode-syntax-table)
(declare-function c-awk-unstick-NL-prop "cc-awk" ())
-(defun awk-mode ()
+;;;###autoload
+(define-derived-mode awk-mode prog-mode "AWK"
"Major mode for editing AWK code.
To submit a problem report, enter `\\[c-submit-bug-report]' from an
awk-mode buffer. This automatically sets up a mail buffer with version
Key bindings:
\\{awk-mode-map}"
- (interactive)
+ ;; We need the next line to stop the macro defining
+ ;; `awk-mode-syntax-table'. This would mask the real table which is
+ ;; declared in cc-awk.el and hasn't yet been loaded.
+ :syntax-table nil
(require 'cc-awk) ; Added 2003/6/10.
- (kill-all-local-variables)
(c-initialize-cc-mode t)
(set-syntax-table awk-mode-syntax-table)
- (setq major-mode 'awk-mode ; FIXME: Use define-derived-mode.
- mode-name "AWK"
- local-abbrev-table awk-mode-abbrev-table
+ (setq local-abbrev-table awk-mode-abbrev-table
abbrev-mode t)
(use-local-map awk-mode-map)
(c-init-language-vars-for 'awk-mode)
(c-common-init 'awk-mode)
(c-awk-unstick-NL-prop)
- ;; Prevent Xemacs's buffer-syntactic-context being used. See the comment
- ;; in cc-engine.el, just before (defun c-fast-in-literal ...
- (defalias 'c-in-literal 'c-slow-in-literal)
-
(c-run-mode-hooks 'c-mode-common-hook 'awk-mode-hook)
(c-update-modeline))
(message "Using CC Mode version %s" c-version)
(c-keep-region-active))
-(defvar c-prepare-bug-report-hooks nil)
+(define-obsolete-variable-alias 'c-prepare-bug-report-hooks
+ 'c-prepare-bug-report-hook "24.3")
+(defvar c-prepare-bug-report-hook nil)
;; Dynamic variables used by reporter.
(defvar reporter-prompt-for-summary-p)
lookup-syntax-properties))
vars)
(lambda ()
- (run-hooks 'c-prepare-bug-report-hooks)
+ (run-hooks 'c-prepare-bug-report-hook)
(insert (format "Buffer Style: %s\nc-emacs-features: %s\n"
style c-features)))))))
HCoop / bpt / emacs.git / blobdiff