[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] Changes to emacs/lisp/progmodes/cc-vars.el [gnus-5_10-bran
From: |
Miles Bader |
Subject: |
[Emacs-diffs] Changes to emacs/lisp/progmodes/cc-vars.el [gnus-5_10-branch] |
Date: |
Sat, 04 Sep 2004 08:29:37 -0400 |
Index: emacs/lisp/progmodes/cc-vars.el
diff -c /dev/null emacs/lisp/progmodes/cc-vars.el:1.35.2.1
*** /dev/null Sat Sep 4 12:02:14 2004
--- emacs/lisp/progmodes/cc-vars.el Sat Sep 4 12:01:11 2004
***************
*** 0 ****
--- 1,1552 ----
+ ;;; cc-vars.el --- user customization variables for CC Mode
+
+ ;; Copyright (C) 1985,1987,1992-2003 Free Software Foundation, Inc.
+
+ ;; Authors: 1998- Martin Stjernholm
+ ;; 1992-1999 Barry A. Warsaw
+ ;; 1987 Dave Detlefs and Stewart Clamen
+ ;; 1985 Richard M. Stallman
+ ;; Maintainer: address@hidden
+ ;; Created: 22-Apr-1997 (split from cc-mode.el)
+ ;; Version: See cc-mode.el
+ ;; Keywords: c languages oop
+
+ ;; This file is part of GNU Emacs.
+
+ ;; GNU Emacs is free software; you can redistribute it and/or modify
+ ;; it under the terms of the GNU General Public License as published by
+ ;; the Free Software Foundation; either version 2, or (at your option)
+ ;; any later version.
+
+ ;; GNU Emacs is distributed in the hope that it will be useful,
+ ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ ;; GNU General Public License for more details.
+
+ ;; You should have received a copy of the GNU General Public License
+ ;; along with GNU Emacs; see the file COPYING. If not, write to
+ ;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ ;; Boston, MA 02111-1307, USA.
+
+ ;;; Commentary:
+
+ ;;; Code:
+
+ (eval-when-compile
+ (let ((load-path
+ (if (and (boundp 'byte-compile-dest-file)
+ (stringp byte-compile-dest-file))
+ (cons (file-name-directory byte-compile-dest-file) load-path)
+ load-path)))
+ (load "cc-bytecomp" nil t)))
+
+ (cc-require 'cc-defs)
+
+ ;; Silence the compiler.
+ (cc-bytecomp-defun get-char-table) ; XEmacs 20+
+ (cc-bytecomp-defun char-table-range) ; Emacs 19+
+ (cc-bytecomp-defun char-table-p) ; Emacs 19+, XEmacs 20+
+
+ ;; Pull in custom if it exists and is recent enough (the one in Emacs
+ ;; 19.34 isn't).
+ (eval
+ (cc-eval-when-compile
+ (condition-case nil
+ (progn
+ (require 'custom)
+ (or (fboundp 'defcustom) (error ""))
+ (require 'widget)
+ '(progn ; Compile in the require's.
+ (require 'custom)
+ (require 'widget)))
+ (error
+ (message "Warning: Compiling without Customize support \
+ since a (good enough) custom library wasn't found")
+ (cc-bytecomp-defmacro define-widget (name class doc &rest args))
+ (cc-bytecomp-defmacro defgroup (symbol members doc &rest args))
+ (cc-bytecomp-defmacro defcustom (symbol value doc &rest args)
+ `(defvar ,symbol ,value ,doc))
+ (cc-bytecomp-defmacro custom-declare-variable (symbol value doc
+ &rest args)
+ `(defvar ,(eval symbol) ,(eval value) ,doc))
+ nil))))
+
+ (cc-eval-when-compile
+ ;; Need the function form of `backquote', which isn't standardized
+ ;; between Emacsen. It's called `bq-process' in XEmacs, and
+ ;; `backquote-process' in Emacs. `backquote-process' returns a
+ ;; slightly more convoluted form, so let `bq-process' be the norm.
+ (if (fboundp 'backquote-process)
+ (cc-bytecomp-defmacro bq-process (form)
+ `(cdr (backquote-process ,form)))))
+
+
+ ;;; Helpers
+
+ ;; This widget exists in newer versions of the Custom library
+ (or (get 'other 'widget-type)
+ (define-widget 'other 'sexp
+ "Matches everything, but doesn't let the user edit the value.
+ Useful as last item in a `choice' widget."
+ :tag "Other"
+ :format "%t%n"
+ :value 'other))
+
+ (define-widget 'c-const-symbol 'item
+ "An uneditable lisp symbol."
+ :value nil
+ :tag "Symbol"
+ :format "%t: %v\n%d"
+ :match (lambda (widget value) (symbolp value))
+ :value-to-internal
+ (lambda (widget value)
+ (let ((s (if (symbolp value)
+ (symbol-name value)
+ value))
+ (l (widget-get widget :size)))
+ (if l
+ (setq s (concat s (make-string (- l (length s)) ?\ ))))
+ s))
+ :value-to-external
+ (lambda (widget value)
+ (if (stringp value)
+ (intern (progn
+ (string-match "\\`[^ ]*" value)
+ (match-string 0 value)))
+ value)))
+
+ (define-widget 'c-integer-or-nil 'sexp
+ "An integer or the value nil."
+ :value nil
+ :tag "Optional integer"
+ :match (lambda (widget value) (or (integerp value) (null value))))
+
+ (define-widget 'c-symbol-list 'sexp
+ "A single symbol or a list of symbols."
+ :tag "Symbols separated by spaces"
+ :validate 'widget-field-validate
+ :match
+ (lambda (widget value)
+ (or (symbolp value)
+ (catch 'ok
+ (while (listp value)
+ (unless (symbolp (car value))
+ (throw 'ok nil))
+ (setq value (cdr value)))
+ (null value))))
+ :value-to-internal
+ (lambda (widget value)
+ (cond ((null value)
+ "")
+ ((symbolp value)
+ (symbol-name value))
+ ((consp value)
+ (mapconcat (lambda (symbol)
+ (symbol-name symbol))
+ value
+ " "))
+ (t
+ value)))
+ :value-to-external
+ (lambda (widget value)
+ (if (stringp value)
+ (let (list end)
+ (while (string-match "\\S +" value end)
+ (setq list (cons (intern (match-string 0 value)) list)
+ end (match-end 0)))
+ (if (and list (not (cdr list)))
+ (car list)
+ (nreverse list)))
+ value)))
+
+ (defvar c-style-variables
+ '(c-basic-offset c-comment-only-line-offset c-indent-comment-alist
+ c-indent-comments-syntactically-p c-block-comment-prefix
+ c-comment-prefix-regexp c-doc-comment-style c-cleanup-list
+ c-hanging-braces-alist c-hanging-colons-alist
+ c-hanging-semi&comma-criteria c-backslash-column c-backslash-max-column
+ c-special-indent-hook c-label-minimum-indentation c-offsets-alist)
+ "List of the style variables.")
+
+ (defvar c-fallback-style nil)
+
+ (defsubst c-set-stylevar-fallback (name val)
+ (put name 'c-stylevar-fallback val)
+ (setq c-fallback-style (cons (cons name val) c-fallback-style)))
+
+ (defmacro defcustom-c-stylevar (name val doc &rest args)
+ "Defines a style variable."
+ `(let ((-value- ,val))
+ (c-set-stylevar-fallback ',name -value-)
+ (custom-declare-variable
+ ',name ''set-from-style
+ ,(concat doc "
+
+ This is a style variable. Apart from the valid values described
+ above, it can be set to the symbol `set-from-style'. In that case, it
+ takes its value from the style system (see `c-default-style' and
+ `c-style-alist') when a CC Mode buffer is initialized. Otherwise,
+ the value set here overrides the style system (there is a variable
+ `c-old-style-variable-behavior' that changes this, though).")
+ ,@(plist-put
+ args ':type
+ `(` (radio
+ (const :tag "Use style settings"
+ set-from-style)
+ ,(, (let ((type (eval (plist-get args ':type))))
+ (unless (consp type)
+ (setq type (list type)))
+ (unless (c-safe (plist-get (cdr type) ':value))
+ (setcdr type (append '(:value (, -value-))
+ (cdr type))))
+ (unless (c-safe (plist-get (cdr type) ':tag))
+ (setcdr type (append '(:tag "Override style settings")
+ (cdr type))))
+ (bq-process type)))))))))
+
+ (defun c-valid-offset (offset)
+ "Return non-nil iff OFFSET is a valid offset for a syntactic symbol.
+ See `c-offsets-alist'."
+ ;; This function does not do any hidden buffer changes.
+ (or (eq offset '+)
+ (eq offset '-)
+ (eq offset '++)
+ (eq offset '--)
+ (eq offset '*)
+ (eq offset '/)
+ (integerp offset)
+ (functionp offset)
+ (and (symbolp offset)
+ (or (boundp offset)
+ (fboundp offset)))
+ (and (vectorp offset)
+ (= (length offset) 1)
+ (integerp (elt offset 0)))
+ (progn
+ (while (and (consp offset)
+ (c-valid-offset (car offset)))
+ (setq offset (cdr offset)))
+ (null offset))))
+
+
+
+ ;;; User variables
+
+ (defcustom c-strict-syntax-p nil
+ "*If non-nil, all syntactic symbols must be found in `c-offsets-alist'.
+ If the syntactic symbol for a particular line does not match a symbol
+ in the offsets alist, or if no non-nil offset value can be determined
+ for a symbol, an error is generated, otherwise no error is reported
+ and the syntactic symbol is ignored.
+
+ This variable is considered obsolete; it doesn't work well with lineup
+ functions that return nil to support the feature of using lists on
+ syntactic symbols in `c-offsets-alist'. Please keep it set to nil."
+ :type 'boolean
+ :group 'c)
+
+ (defcustom c-echo-syntactic-information-p nil
+ "*If non-nil, syntactic info is echoed when the line is indented."
+ :type 'boolean
+ :group 'c)
+
+ (defcustom c-report-syntactic-errors nil
+ "*If non-nil, certain syntactic errors are reported with a ding
+ and a message, for example when an \"else\" is indented for which
+ there's no corresponding \"if\".
+
+ Note however that CC Mode doesn't make any special effort to check for
+ syntactic errors; that's the job of the compiler. The reason it can
+ report cases like the one above is that it can't find the correct
+ anchoring position to indent the line in that case."
+ :type 'boolean
+ :group 'c)
+
+ (defcustom-c-stylevar c-basic-offset 4
+ "*Amount of basic offset used by + and - symbols in `c-offsets-alist'.
+ Also used as the indentation step when `c-syntactic-indentation' is
+ nil."
+ :type 'integer
+ :group 'c)
+
+ (defcustom 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 inserts a `real' tab character \(see
+ note\). If some other value (not nil or t), then tab is inserted only
+ within literals \(comments and strings), but the line is always
+ reindented.
+
+ Note: The value of `indent-tabs-mode' will determine whether a real
+ tab character will be inserted, or the equivalent number of spaces.
+ 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."
+ :type '(radio
+ (const :tag "TAB key always indents, never inserts TAB" t)
+ (const :tag "TAB key indents in left margin, otherwise inserts TAB"
nil)
+ (other :tag "TAB key inserts TAB in literals, otherwise indents"
other))
+ :group 'c)
+
+ (defcustom c-insert-tab-function 'insert-tab
+ "*Function used when inserting a tab for \\[c-indent-command].
+ Only used when `c-tab-always-indent' indicates a `real' tab character
+ should be inserted. Value must be a function taking no arguments."
+ :type 'function
+ :group 'c)
+
+ (defcustom c-syntactic-indentation t
+ "*Whether the indentation should be controlled by the syntactic context.
+
+ If t, the indentation functions indent according to the syntactic
+ context, using the style settings specified by `c-offsets-alist'.
+
+ If nil, every line is just indented to the same level as the previous
+ one, and the \\[c-indent-command] command adjusts the indentation in
+ steps specified by `c-basic-offset'. The indentation style has no
+ effect in this mode, nor any of the indentation associated variables,
+ e.g. `c-special-indent-hook'."
+ :type 'boolean
+ :group 'c)
+
+ (defcustom c-syntactic-indentation-in-macros t
+ "*Enable syntactic analysis inside macros.
+ If this is nil, all lines inside macro definitions are analyzed as
+ `cpp-macro-cont'. Otherwise they are analyzed syntactically, just
+ like normal code, and `cpp-define-intro' is used to create the
+ additional indentation of the bodies of \"#define\" macros.
+
+ Having this enabled simplifies editing of large multiline macros, but
+ it might complicate editing if CC Mode doesn't recognize the context
+ of the macro content. The default context inside the macro is the
+ same as the top level, so if it contains \"bare\" statements they
+ might be indented wrongly, although there are special cases that
+ handle this in most cases. If this problem occurs, it's usually
+ countered easily by surrounding the statements by a block \(or even
+ better with the \"do { ... } while \(0)\" trick)."
+ :type 'boolean
+ :group 'c)
+
+ (defcustom-c-stylevar 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:
+
+ (NON-ANCHORED-OFFSET . ANCHORED-OFFSET)
+
+ Where NON-ANCHORED-OFFSET is the amount of offset given to
+ non-column-zero anchored comment-only lines, and ANCHORED-OFFSET is
+ the amount of offset to give column-zero anchored comment-only lines.
+ Just an integer as value is equivalent to (<val> . -1000).
+
+ Note that this variable only has effect when the `c-lineup-comment'
+ lineup function is used on the `comment-intro' syntactic symbol (the
+ default)."
+ :type '(choice (integer :tag "Non-anchored offset" 0)
+ (cons :tag "Non-anchored & anchored offset"
+ :value (0 . 0)
+ (integer :tag "Non-anchored offset")
+ (integer :tag "Anchored offset")))
+ :group 'c)
+
+ (defcustom-c-stylevar c-indent-comment-alist
+ '((anchored-comment . (column . 0))
+ (end-block . (space . 1))
+ (cpp-end-block . (space . 2)))
+ "*Specifies how \\[indent-for-comment] calculates the comment start column.
+ This is an association list that contains entries of the form:
+
+ (LINE-TYPE . INDENT-SPEC)
+
+ LINE-TYPE specifies a type of line as described below, and INDENT-SPEC
+ says what \\[indent-for-comment] should do when used on that type of line.
+
+ The recognized values for LINE-TYPE are:
+
+ empty-line -- The line is empty.
+ anchored-comment -- The line contains a comment that starts in column 0.
+ end-block -- The line contains a solitary block closing brace.
+ cpp-end-block -- The line contains a preprocessor directive that
+ closes a block, i.e. either \"#endif\" or \"#else\".
+ other -- The line does not match any other entry
+ currently on the list.
+
+ An INDENT-SPEC is a cons cell of the form:
+
+ (ACTION . VALUE)
+
+ ACTION says how \\[indent-for-comment] should align the comment, and
+ VALUE is interpreted depending on ACTION. ACTION can be any of the
+ following:
+
+ space -- Put VALUE spaces between the end of the line and the start
+ of the comment.
+ column -- Start the comment at the column VALUE. If the line is
+ longer than that, the comment is preceded by a single
+ space. If VALUE is nil, `comment-column' is used.
+ align -- Align the comment with one on the previous line, if there
+ is any. If the line is too long, the comment is preceded
+ by a single space. If there isn't a comment start on the
+ previous line, the behavior is specified by VALUE, which
+ in turn is interpreted as an INDENT-SPEC.
+
+ If a LINE-TYPE is missing, then \\[indent-for-comment] indents the comment
+ according to `comment-column'.
+
+ Note that a non-nil value on `c-indent-comments-syntactically-p'
+ overrides this variable, so empty lines are indentented syntactically
+ in that case, i.e. as if \\[c-indent-command] was used instead."
+ :type
+ (let ((space '(cons :tag "space"
+ :format "%v"
+ :value (space . 1)
+ (const :format "space " space)
+ (integer :format "%v")))
+ (column '(cons :tag "column"
+ :format "%v"
+ (const :format "column " column)
+ (c-integer-or-nil :format "%v"))))
+ `(set ,@(mapcar
+ (lambda (elt)
+ `(cons :format "%v"
+ (c-const-symbol :format "%v: "
+ :size 20
+ :value ,elt)
+ (choice
+ :format "%[Choice%] %v"
+ :value (column . nil)
+ ,space
+ ,column
+ (cons :tag "align"
+ :format "%v"
+ (const :format "align " align)
+ (choice
+ :format "%[Choice%] %v"
+ :value (column . nil)
+ ,space
+ ,column)))))
+ '(empty-line anchored-comment end-block cpp-end-block other))))
+ :group 'c)
+
+ (defcustom-c-stylevar c-indent-comments-syntactically-p nil
+ "*Specifies how \\[indent-for-comment] should handle comment-only lines.
+ When this variable is non-nil, comment-only lines are indented
+ according to syntactic analysis via `c-offsets-alist'. Otherwise, the
+ comment is indented as if it was preceded by code. Note that this
+ variable does not affect how the normal line indentation treats
+ comment-only lines."
+ :type 'boolean
+ :group 'c)
+
+ (make-obsolete-variable 'c-comment-continuation-stars
+ 'c-block-comment-prefix)
+
+ ;; Although c-comment-continuation-stars is obsolete, we look at it in
+ ;; some places in CC Mode anyway, so make the compiler ignore it
+ ;; during our compilation.
+ (cc-bytecomp-obsolete-var c-comment-continuation-stars)
+ (cc-bytecomp-defvar c-comment-continuation-stars)
+
+ (defcustom-c-stylevar c-block-comment-prefix
+ (if (boundp 'c-comment-continuation-stars)
+ c-comment-continuation-stars
+ "* ")
+ "*Specifies the line prefix of continued C-style block comments.
+ You should set this variable to the literal string that gets inserted
+ at the front of continued block style comment lines. This should
+ either be the empty string, or some characters without preceding
+ spaces. To adjust the alignment under the comment starter, put an
+ appropriate value on the `c' syntactic symbol (see the
+ `c-offsets-alist' variable).
+
+ It's only used when a one-line block comment is broken into two or
+ more lines for the first time; otherwise the appropriate prefix is
+ adapted from the comment. This variable is not used for C++ line
+ style comments."
+ :type 'string
+ :group 'c)
+
+ (defcustom-c-stylevar c-comment-prefix-regexp
+ '((pike-mode . "//+!?\\|\\**")
+ (other . "//+\\|\\**"))
+ "*Regexp to match the line prefix inside comments.
+ This regexp is used to recognize the fill prefix inside comments for
+ correct paragraph filling and other things.
+
+ If this variable is a string, it will be used in all CC Mode major
+ modes. It can also be an association list, to associate specific
+ regexps to specific major modes. The symbol for the major mode is
+ looked up in the association list, and its value is used as the line
+ prefix regexp. If it's not found, then the symbol `other' is looked
+ up and its value is used instead.
+
+ The regexp should match the prefix used in both C++ style line
+ comments and C style block comments, but it does not need to match a
+ block comment starter. In other words, it should at least match
+ \"//\" for line comments and the string in `c-block-comment-prefix',
+ which is sometimes inserted by CC Mode inside block comments. It
+ should not match any surrounding whitespace.
+
+ Note that CC Mode uses this variable to set many other variables that
+ handle the paragraph filling. That's done at mode initialization or
+ when you switch to a style which sets this variable. Thus, if you
+ change it in some other way, e.g. interactively in a CC Mode buffer,
+ you will need to do \\[c-setup-paragraph-variables] afterwards so that
+ the other variables are updated with the new value.
+
+ Note also that when CC Mode starts up, all variables are initialized
+ before the mode hooks are run. It's therefore necessary to make a
+ call to `c-setup-paragraph-variables' explicitly if you change this
+ variable in a mode hook."
+ :type '(radio
+ (regexp :tag "Regexp for all modes")
+ (list
+ :tag "Mode-specific regexps"
+ (set
+ :inline t :format "%v"
+ (cons :format "%v"
+ (const :format "C " c-mode) (regexp :format "%v"))
+ (cons :format "%v"
+ (const :format "C++ " c++-mode) (regexp :format "%v"))
+ (cons :format "%v"
+ (const :format "ObjC " objc-mode) (regexp :format "%v"))
+ (cons :format "%v"
+ (const :format "Java " java-mode) (regexp :format "%v"))
+ (cons :format "%v"
+ (const :format "IDL " idl-mode) (regexp :format "%v"))
+ (cons :format "%v"
+ (const :format "Pike " pike-mode) (regexp :format "%v")))
+ (cons :format " %v"
+ (const :format "Other " other) (regexp :format "%v"))))
+ :group 'c)
+
+ (defcustom-c-stylevar c-doc-comment-style
+ '((java-mode . javadoc)
+ (pike-mode . autodoc))
+ "*Specifies documentation comment style(s) to recognize.
+ This is primarily used to fontify doc comments and the markup within
+ them, e.g. Javadoc comments.
+
+ The value can be any of the following symbols for various known doc
+ comment styles:
+
+ javadoc -- Javadoc style for \"/** ... */\" comments (default in Java mode).
+ autodoc -- Pike autodoc style for \"//! ...\" comments (default in Pike
mode).
+
+ The value may also be a list of doc comment styles, in which case all
+ of them are recognized simultaneously (presumably with markup cues
+ that don't conflict).
+
+ The value may also be an association list to specify different doc
+ comment styles for different languages. The symbol for the major mode
+ is then looked up in the alist, and the value of that element is
+ interpreted as above if found. If it isn't found then the symbol
+ `other' is looked up and its value is used instead.
+
+ Note that CC Mode uses this variable to set other variables that
+ handle fontification etc. That's done at mode initialization or when
+ you switch to a style which sets this variable. Thus, if you change
+ it in some other way, e.g. interactively in a CC Mode buffer, you will
+ need to do \\[java-mode] (or whatever mode you're currently using) to
+ reinitialize.
+
+ Note also that when CC Mode starts up, the other variables are
+ modified before the mode hooks are run. If you change this variable
+ in a mode hook, you have to call `c-setup-doc-comment-style'
+ afterwards to redo that work."
+ ;; Symbols other than those documented above may be used on this
+ ;; variable. If a variable exists that has that name with
+ ;; "-font-lock-keywords" appended, it's value is prepended to the
+ ;; font lock keywords list. If it's a function then it's called and
+ ;; the result is prepended.
+ :type '(radio
+ (c-symbol-list :tag "Doc style(s) in all modes")
+ (list
+ :tag "Mode-specific doc styles"
+ (set
+ :inline t :format "%v"
+ (cons :format "%v"
+ (const :format "C " c-mode)
+ (c-symbol-list :format "%v"))
+ (cons :format "%v"
+ (const :format "C++ " c++-mode)
+ (c-symbol-list :format "%v"))
+ (cons :format "%v"
+ (const :format "ObjC " objc-mode)
+ (c-symbol-list :format "%v"))
+ (cons :format "%v"
+ (const :format "Java " java-mode)
+ (c-symbol-list :format "%v"))
+ (cons :format "%v"
+ (const :format "IDL " idl-mode)
+ (c-symbol-list :format "%v"))
+ (cons :format "%v"
+ (const :format "Pike " pike-mode)
+ (c-symbol-list :format "%v"))
+ (cons :format "%v"
+ (const :format "Other " other)
+ (c-symbol-list :format "%v")))))
+ :group 'c)
+
+ (defcustom c-ignore-auto-fill '(string cpp code)
+ "*List of contexts in which automatic filling never occurs.
+ If Auto Fill mode is active, it will be temporarily disabled if point
+ is in any context on this list. It's e.g. useful to enable Auto Fill
+ in comments only, but not in strings or normal code. The valid
+ contexts are:
+
+ string -- inside a string or character literal
+ c -- inside a C style block comment
+ c++ -- inside a C++ style line comment
+ cpp -- inside a preprocessor directive
+ code -- anywhere else, i.e. in normal code"
+ :type '(set
+ (const :tag "String literals" string)
+ (const :tag "C style block comments" c)
+ (const :tag "C++ style line comments" c++)
+ (const :tag "Preprocessor directives" cpp)
+ (const :tag "Normal code" code))
+ :group 'c)
+
+ (defcustom-c-stylevar c-cleanup-list '(scope-operator)
+ "*List of various C/C++/ObjC constructs to \"clean up\".
+ The following clean ups only take place when the auto-newline feature
+ is turned on, as evidenced by the `/a' or `/ah' appearing next to the
+ mode name:
+
+ brace-else-brace -- Clean up \"} else {\" constructs by placing
+ entire construct on a single line. This clean
+ up only takes place when there is nothing but
+ white space between the braces and the `else'.
+ Clean up occurs when the open brace after the
+ `else' is typed.
+ brace-elseif-brace -- Similar to brace-else-brace, but clean up
+ \"} else if (...) {\" constructs. Clean up
+ occurs after the open parenthesis and the open
+ brace.
+ brace-catch-brace -- Similar to brace-elseif-brace, but clean up
+ \"} catch (...) {\" constructs.
+ empty-defun-braces -- Clean up empty defun braces by placing the
+ braces on the same line. Clean up occurs when
+ the defun closing brace is typed.
+ defun-close-semi -- Clean up the terminating semi-colon on defuns
+ by placing the semi-colon on the same line as
+ the closing brace. Clean up occurs when the
+ semi-colon is typed.
+ list-close-comma -- Clean up commas following braces in array
+ and aggregate initializers. Clean up occurs
+ when the comma is typed.
+ scope-operator -- Clean up double colons which may designate
+ a C++ scope operator split across multiple
+ lines. Note that certain C++ constructs can
+ generate ambiguous situations. This clean up
+ only takes place when there is nothing but
+ whitespace between colons. Clean up occurs
+ when the second colon is typed.
+
+ The following clean ups always take place when they are on this list,
+ regardless of the auto-newline feature, since they typically don't
+ involve auto-newline inserted newlines:
+
+ space-before-funcall -- Insert exactly one space before the opening
+ parenthesis of a function call. Clean up
+ occurs when the opening parenthesis is typed.
+ compact-empty-funcall -- Clean up any space before the function call
+ opening parenthesis if and only if the
+ argument list is empty. This is typically
+ useful together with `space-before-funcall' to
+ get the style \"foo (bar)\" and \"foo()\".
+ Clean up occurs when the closing parenthesis
+ is typed."
+ :type '(set
+ (const :tag "Put \"} else {\" on one line"
+ brace-else-brace)
+ (const :tag "Put \"} else if (...) {\" on one line"
+ brace-elseif-brace)
+ (const :tag "Put \"} catch (...) {\" on one line"
+ brace-catch-brace)
+ (const :tag "Put empty defun braces on one line"
+ empty-defun-braces)
+ (const :tag "Put \"};\" ending defuns on one line"
+ defun-close-semi)
+ (const :tag "Put \"},\" in aggregates on one line"
+ list-close-comma)
+ (const :tag "Put C++ style \"::\" on one line"
+ scope-operator)
+ (const :tag "Put a space before funcall parens, e.g. \"foo (bar)\""
+ space-before-funcall)
+ (const :tag "Remove space before empty funcalls, e.g. \"foo()\""
+ compact-empty-funcall))
+ :group 'c)
+
+ (defcustom-c-stylevar c-hanging-braces-alist '((brace-list-open)
+ (brace-entry-open)
+ (statement-cont)
+ (substatement-open after)
+ (block-close . c-snug-do-while)
+ (extern-lang-open after)
+ (namespace-open after)
+ (module-open after)
+ (composition-open after)
+ (inexpr-class-open after)
+ (inexpr-class-close before))
+ "*Controls the insertion of newlines before and after braces
+ when the auto-newline feature is active. 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
+ context it defines is looked up in this list, and if found, the
+ associated ACTION is used to determine where newlines are inserted.
+ If the context is not found, the default is to insert a newline both
+ before and after the brace.
+
+ SYNTACTIC-SYMBOL can be statement-cont, brace-list-intro,
+ inexpr-class-open, inexpr-class-close, and any of the *-open and
+ *-close symbols. See `c-offsets-alist' for details, except for
+ inexpr-class-open and inexpr-class-close, which doesn't have any
+ corresponding symbols there. Those two symbols are used for the
+ opening and closing braces, respectively, of anonymous inner classes
+ in Java.
+
+ 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.
+
+ When ACTION is a function symbol, the function is called with a two
+ arguments: the syntactic symbol for the brace and the buffer position
+ at which the brace was inserted. The function must return a list as
+ described in the preceding paragraph. Note that during the call to
+ the function, the variable `c-syntactic-context' is set to the entire
+ syntactic context for the brace line."
+ :type
+ `(set ,@(mapcar
+ (lambda (elt)
+ `(cons :format "%v"
+ (c-const-symbol :format "%v: "
+ :size 20
+ :value ,elt)
+ (choice :format "%[Choice%] %v"
+ :value (before after)
+ (set :menu-tag "Before/after"
+ :format "Newline %v brace\n"
+ (const :format "%v, " before)
+ (const :format "%v" after))
+ (function :menu-tag "Function"
+ :format "Run function: %v"
+ :value c-))))
+ '(defun-open defun-close
+ class-open class-close
+ inline-open inline-close
+ block-open block-close
+ statement-cont substatement-open statement-case-open
+ brace-list-open brace-list-close
+ brace-list-intro brace-entry-open
+ extern-lang-open extern-lang-close
+ namespace-open namespace-close
+ module-open module-close
+ composition-open composition-close
+ inexpr-class-open inexpr-class-close)))
+ :group 'c)
+
+ (defcustom-c-stylevar c-hanging-colons-alist nil
+ "*Controls the insertion of newlines before and after certain colons.
+ This variable contains an association list with elements of the
+ following form: (SYNTACTIC-SYMBOL . ACTION).
+
+ SYNTACTIC-SYMBOL can be any of: case-label, label, access-label,
+ member-init-intro, or inher-intro.
+
+ See the variable `c-hanging-braces-alist' for the semantics of this
+ variable. Note however that making ACTION a function symbol is
+ currently not supported for this variable."
+ :type
+ `(set ,@(mapcar
+ (lambda (elt)
+ `(cons :format "%v"
+ (c-const-symbol :format "%v: "
+ :size 20
+ :value ,elt)
+ (set :format "Newline %v brace\n"
+ (const :format "%v, " before)
+ (const :format "%v" after))))
+ '(case-label label access-label member-init-intro inher-intro)))
+ :group 'c)
+
+ (defcustom-c-stylevar c-hanging-semi&comma-criteria
+ '(c-semi&comma-inside-parenlist)
+ "*List of functions that decide whether to insert a newline or not.
+ The functions in this list are called, in order, whenever the
+ auto-newline minor mode is activated (as evidenced by a `/a' or `/ah'
+ string in the mode line), and a semicolon or comma is typed (see
+ `c-electric-semi&comma'). Each function in this list is called with
+ no arguments, and should return one of the following values:
+
+ nil -- no determination made, continue checking
+ 'stop -- do not insert a newline, and stop checking
+ (anything else) -- insert a newline, and stop checking
+
+ If every function in the list is called with no determination made,
+ then no newline is inserted."
+ :type '(repeat function)
+ :group 'c)
+
+ (defcustom-c-stylevar c-backslash-column 48
+ "*Minimum alignment column for line continuation backslashes.
+ This is used by the functions that automatically insert or align the
+ line continuation backslashes in multiline macros. If any line in the
+ macro exceeds this column then the next tab stop from that line is
+ used as alignment column instead."
+ :type 'integer
+ :group 'c)
+
+ (defcustom-c-stylevar c-backslash-max-column 72
+ "*Maximum alignment column for line continuation backslashes.
+ This is used by the functions that automatically insert or align the
+ line continuation backslashes in multiline macros. If any line in the
+ macro exceeds this column then the backslashes for the other lines
+ will be aligned at this column."
+ :type 'integer
+ :group 'c)
+
+ (defcustom c-auto-align-backslashes t
+ "*Align automatically inserted line continuation backslashes.
+ When line continuation backslashes are inserted automatically for line
+ breaks in multiline macros, e.g. by \\[c-context-line-break], they are
+ aligned with the other backslashes in the same macro if this flag is
+ set. Otherwise the inserted backslashes are preceded by a single
+ space."
+ :type 'boolean
+ :group 'c)
+
+ (defcustom c-backspace-function 'backward-delete-char-untabify
+ "*Function called by `c-electric-backspace' when deleting backwards."
+ :type 'function
+ :group 'c)
+
+ (defcustom c-delete-function 'delete-char
+ "*Function called by `c-electric-delete-forward' when deleting forwards."
+ :type 'function
+ :group 'c)
+
+ (defcustom c-require-final-newline
+ ;; C and C++ mandates that all nonempty files should end with a
+ ;; newline. Objective-C refers to C for all things it doesn't
+ ;; specify, so the same holds there. The other languages does not
+ ;; require it (at least not explicitly in a normative text).
+ '((c-mode . t)
+ (c++-mode . t)
+ (objc-mode . t))
+ "*Controls whether a final newline is ensured when the file is saved.
+ The value is an association list that for each language mode specifies
+ the value to give to `require-final-newline' at mode initialization;
+ see that variable for details about the value. If a language isn't
+ present on the association list, CC Mode won't set
+ `require-final-newline' in buffers for that language."
+ :type `(set (cons :format "%v"
+ (const :format "C " c-mode)
+ (symbol :format "%v" :value ,require-final-newline))
+ (cons :format "%v"
+ (const :format "C++ " c++-mode)
+ (symbol :format "%v" :value ,require-final-newline))
+ (cons :format "%v"
+ (const :format "ObjC " objc-mode)
+ (symbol :format "%v" :value ,require-final-newline))
+ (cons :format "%v"
+ (const :format "Java " java-mode)
+ (symbol :format "%v" :value ,require-final-newline))
+ (cons :format "%v"
+ (const :format "IDL " idl-mode)
+ (symbol :format "%v" :value ,require-final-newline))
+ (cons :format "%v"
+ (const :format "Pike " pike-mode)
+ (symbol :format "%v" :value ,require-final-newline)))
+ :group 'c)
+
+ (defcustom c-electric-pound-behavior nil
+ "*List of behaviors for electric pound insertion.
+ Only currently supported behavior is `alignleft'."
+ :type '(set (const alignleft))
+ :group 'c)
+
+ (defcustom c-special-indent-hook nil
+ "*Hook for user defined special indentation adjustments.
+ This hook gets called after a line is indented by the mode."
+ :type 'hook
+ :group 'c)
+
+ (defcustom-c-stylevar c-label-minimum-indentation 1
+ "*Minimum indentation for lines inside code blocks.
+ This variable typically only affects code using the `gnu' style, which
+ mandates a minimum of one space in front of every line inside code
+ blocks. Specifically, the function `c-gnu-impose-minimum' on your
+ `c-special-indent-hook' is what enforces this."
+ :type 'integer
+ :group 'c)
+
+ (defcustom 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. To inhibit all messages during indentation, set
+ this variable to nil."
+ :type 'integer
+ :group 'c)
+
+ (defcustom c-default-style '((java-mode . "java") (other . "gnu"))
+ "*Style which gets installed by default when a file is visited.
+
+ The value of this variable can be any style defined in
+ `c-style-alist', including styles you add. The value can also be an
+ association list of major mode symbols to style names.
+
+ When the value is a string, all CC Mode major modes will install this
+ style by default.
+
+ When the value is an alist, the major mode symbol is looked up in it
+ and the associated style is installed. If the major mode is not
+ listed in the alist, then the symbol `other' is looked up in it, and
+ if found, the style in that entry is used. If `other' is not found in
+ the alist, then \"gnu\" style is used.
+
+ The default style gets installed before your mode hooks run, so you
+ can always override the use of `c-default-style' by making calls to
+ `c-set-style' in the appropriate mode hook."
+ :type '(radio
+ (string :tag "Style in all modes")
+ (set :tag "Mode-specific styles"
+ (cons :format "%v"
+ (const :format "C " c-mode) (string :format "%v"))
+ (cons :format "%v"
+ (const :format "C++ " c++-mode) (string :format "%v"))
+ (cons :format "%v"
+ (const :format "ObjC " objc-mode) (string :format "%v"))
+ (cons :format "%v"
+ (const :format "Java " java-mode) (string :format "%v"))
+ (cons :format "%v"
+ (const :format "IDL " idl-mode) (string :format "%v"))
+ (cons :format "%v"
+ (const :format "Pike " pike-mode) (string :format "%v"))
+ (cons :format "%v"
+ (const :format "Other " other) (string :format "%v"))))
+ :group 'c)
+
+ ;; *) At the start of a statement or declaration means in more detail:
+ ;; At the closest preceding statement/declaration that starts at boi
+ ;; and doesn't have a label or comment at that position. If there's
+ ;; no such statement within the same block, then back up to the
+ ;; surrounding block or statement, add the appropriate
+ ;; statement-block-intro, defun-block-intro or substatement syntax
+ ;; symbol and continue searching.
+ (c-set-stylevar-fallback 'c-offsets-alist
+ '((string . c-lineup-dont-change)
+ ;; Relpos: Beg of previous line.
+ (c . c-lineup-C-comments)
+ ;; Relpos: Beg of the comment.
+ (defun-open . 0)
+ ;; Relpos: When inside a class: Boi at the func decl start.
+ ;; When at top level: Bol at the func decl start. When inside
+ ;; a code block (only possible in Pike): At the func decl
+ ;; start(*).
+ (defun-close . 0)
+ ;; Relpos: At the defun block open if it's at boi, otherwise
+ ;; boi at the func decl start.
+ (defun-block-intro . +)
+ ;; Relpos: At the block open(*).
+ (class-open . 0)
+ ;; Relpos: Boi at the class decl start.
+ (class-close . 0)
+ ;; Relpos: Boi at the class decl start.
+ (inline-open . +)
+ ;; Relpos: None for functions (inclass got the relpos then),
+ ;; boi at the lambda start for lambdas.
+ (inline-close . 0)
+ ;; Relpos: Inexpr functions: At the lambda block open if it's
+ ;; at boi, else at the statement(*) at boi of the start of the
+ ;; lambda construct. Otherwise: At the inline block open if
+ ;; it's at boi, otherwise boi at the func decl start.
+ (func-decl-cont . +)
+ ;; Relpos: Boi at the func decl start.
+ (knr-argdecl-intro . +)
+ ;; Relpos: Boi at the topmost intro line.
+ (knr-argdecl . 0)
+ ;; Relpos: At the beginning of the first K&R argdecl.
+ (topmost-intro . 0)
+ ;; Relpos: Bol at the last line of previous construct.
+ (topmost-intro-cont . c-lineup-topmost-intro-cont)
+ ;; Relpos: Boi at the topmost intro line.
+ (member-init-intro . +)
+ ;; Relpos: Boi at the func decl arglist open.
+ (member-init-cont . c-lineup-multi-inher)
+ ;; Relpos: Beg of the first member init.
+ (inher-intro . +)
+ ;; Relpos: Boi at the class decl start.
+ (inher-cont . c-lineup-multi-inher)
+ ;; Relpos: Java: At the implements/extends keyword start.
+ ;; Otherwise: At the inher start colon, or boi at the class
+ ;; decl start if the first inherit clause hangs and it's not a
+ ;; func-local inherit clause (when does that occur?).
+ (block-open . 0)
+ ;; Relpos: Inexpr statement: At the statement(*) at boi of the
+ ;; start of the inexpr construct. Otherwise: None.
+ (block-close . 0)
+ ;; Relpos: Inexpr statement: At the inexpr block open if it's
+ ;; at boi, else at the statement(*) at boi of the start of the
+ ;; inexpr construct. Block hanging on a case/default label: At
+ ;; the closest preceding label that starts at boi. Otherwise:
+ ;; At the block open(*).
+ (brace-list-open . 0)
+ ;; Relpos: Boi at the brace list decl start, but a starting
+ ;; "typedef" token is ignored.
+ (brace-list-close . 0)
+ ;; Relpos: At the brace list decl start(*).
+ (brace-list-intro . +)
+ ;; Relpos: At the brace list decl start(*).
+ (brace-list-entry . 0)
+ ;; Relpos: At the first non-ws char after the open paren if the
+ ;; first token is on the same line, otherwise boi at that
+ ;; token.
+ (brace-entry-open . 0)
+ ;; Relpos: Same as brace-list-entry.
+ (statement . 0)
+ ;; Relpos: After a `;' in the condition clause of a for
+ ;; statement: At the first token after the starting paren.
+ ;; Otherwise: At the preceding statement(*).
+ (statement-cont . +)
+ ;; Relpos: After the first token in the condition clause of a
+ ;; for statement: At the first token after the starting paren.
+ ;; Otherwise: At the containing statement(*).
+ (statement-block-intro . +)
+ ;; Relpos: In inexpr statement block: At the inexpr block open
+ ;; if it's at boi, else at the statement(*) at boi of the start
+ ;; of the inexpr construct. In a block hanging on a
+ ;; case/default label: At the closest preceding label that
+ ;; starts at boi. Otherwise: At the start of the containing
+ ;; block(*).
+ (statement-case-intro . +)
+ ;; Relpos: At the case/default label(*).
+ (statement-case-open . 0)
+ ;; Relpos: At the case/default label(*).
+ (substatement . +)
+ ;; Relpos: At the containing statement(*).
+ (substatement-open . +)
+ ;; Relpos: At the containing statement(*).
+ (substatement-label . 2)
+ ;; Relpos: At the containing statement(*).
+ (case-label . 0)
+ ;; Relpos: At the start of the switch block(*).
+ (access-label . -)
+ ;; Relpos: Same as inclass.
+ (label . 2)
+ ;; Relpos: At the start of the containing block(*).
+ (do-while-closure . 0)
+ ;; Relpos: At the corresponding while statement(*).
+ (else-clause . 0)
+ ;; Relpos: At the corresponding if statement(*).
+ (catch-clause . 0)
+ ;; Relpos: At the previous try or catch statement clause(*).
+ (comment-intro . (c-lineup-knr-region-comment
c-lineup-comment))
+ ;; Relpos: None.
+ (arglist-intro . +)
+ ;; Relpos: Boi at the open paren, or at the first non-ws after
+ ;; the open paren of the surrounding sexp, whichever is later.
+ (arglist-cont . (c-lineup-gcc-asm-reg 0))
+ ;; Relpos: At the first token after the open paren.
+ (arglist-cont-nonempty . (c-lineup-gcc-asm-reg c-lineup-arglist))
+ ;; Relpos: At the containing statement(*).
+ ;; 2nd pos: At the open paren.
+ (arglist-close . +)
+ ;; Relpos: At the containing statement(*).
+ ;; 2nd pos: At the open paren.
+ (stream-op . c-lineup-streamop)
+ ;; Relpos: Boi at the first stream op in the statement.
+ (inclass . +)
+ ;; Relpos: At the class open brace if it's at boi, otherwise
+ ;; boi at the class decl start.
+ (cpp-macro . [0])
+ ;; Relpos: None.
+ (cpp-macro-cont . +)
+ ;; Relpos: At the macro start (always at boi).
+ (cpp-define-intro . (c-lineup-cpp-define +))
+ ;; Relpos: None.
+ (friend . 0)
+ ;; Relpos: None.
+ (objc-method-intro . [0])
+ ;; Relpos: Boi.
+ (objc-method-args-cont . c-lineup-ObjC-method-args)
+ ;; Relpos: At the method start (always at boi).
+ (objc-method-call-cont . c-lineup-ObjC-method-call)
+ ;; Relpos: At the open bracket.
+ (extern-lang-open . 0)
+ (namespace-open . 0)
+ (module-open . 0)
+ (composition-open . 0)
+ ;; Relpos: Boi at the extern/namespace/etc keyword.
+ (extern-lang-close . 0)
+ (namespace-close . 0)
+ (module-close . 0)
+ (composition-close . 0)
+ ;; Relpos: Boi at the corresponding extern/namespace/etc keyword.
+ (inextern-lang . +)
+ (innamespace . +)
+ (inmodule . +)
+ (incomposition . +)
+ ;; Relpos: At the extern/namespace/etc block open brace if it's
+ ;; at boi, otherwise boi at the keyword.
+ (template-args-cont . (c-lineup-template-args +))
+ ;; Relpos: Boi at the decl start. This might be changed; the
+ ;; logical position is clearly the opening '<'.
+ (inlambda . c-lineup-inexpr-block)
+ ;; Relpos: None.
+ (lambda-intro-cont . +)
+ ;; Relpos: Boi at the lambda start.
+ (inexpr-statement . +)
+ ;; Relpos: None.
+ (inexpr-class . +)
+ ;; Relpos: None.
+ ))
+ (defcustom c-offsets-alist nil
+ "Association list of syntactic element symbols and indentation offsets.
+ As described below, each cons cell in this list has the form:
+
+ (SYNTACTIC-SYMBOL . OFFSET)
+
+ When a line is indented, CC Mode first determines the syntactic
+ context of it by generating a list of symbols called syntactic
+ elements. This list can contain more than one syntactic element and
+ the global variable `c-syntactic-context' contains the context list
+ for the line being indented. Each element in this list is actually a
+ cons cell of the syntactic symbol and a buffer position. This buffer
+ position is called the relative indent point for the line. Some
+ syntactic symbols may not have a relative indent point associated with
+ them.
+
+ After the syntactic context list for a line is generated, CC Mode
+ calculates the absolute indentation for the line by looking at each
+ syntactic element in the list. It compares the syntactic element
+ against the SYNTACTIC-SYMBOL's in `c-offsets-alist'. When it finds a
+ match, it adds the OFFSET to the column of the relative indent point.
+ The sum of this calculation for each element in the syntactic list is
+ the absolute offset for line being indented.
+
+ If the syntactic element does not match any in the `c-offsets-alist',
+ the element is ignored.
+
+ If OFFSET is nil, the syntactic element is ignored in the offset
+ calculation.
+
+ If OFFSET is an integer, it's added to the relative indent.
+
+ If OFFSET is one of the symbols `+', `-', `++', `--', `*', or `/', a
+ positive or negative multiple of `c-basic-offset' is added; 1, -1, 2,
+ -2, 0.5, and -0.5, respectively.
+
+ If OFFSET is a vector, it's first element, which must be an integer,
+ is used as an absolute indentation column. This overrides all
+ relative offsets. If there are several syntactic elements which
+ evaluates to absolute indentation columns, the first one takes
+ precedence. You can see in which order CC Mode combines the syntactic
+ elements in a certain context by using \\[c-show-syntactic-information] on
the line.
+
+ If OFFSET is a function, it's called with a single argument
+ containing the cons of the syntactic element symbol and the relative
+ indent point. The return value from the function is then
+ reinterpreted as an OFFSET value.
+
+ If OFFSET is a list, it's recursively evaluated using the semantics
+ described above. The first element of the list to return a non-nil
+ value succeeds. If none of the elements returns a non-nil value, the
+ syntactic element is ignored.
+
+ `c-offsets-alist' is a style variable. This means that the offsets on
+ this variable are normally taken from the style system in CC Mode
+ \(see `c-default-style' and `c-style-alist'). However, any offsets
+ put explicitly on this list will override the style system when a CC
+ Mode buffer is initialized \(there is a variable
+ `c-old-style-variable-behavior' that changes this, though).
+
+ Here is the current list of valid syntactic element symbols:
+
+ string -- Inside multi-line string.
+ c -- Inside a multi-line C style block comment.
+ defun-open -- Brace that opens a function definition.
+ defun-close -- Brace that closes a function definition.
+ defun-block-intro -- The first line in a top-level defun.
+ class-open -- Brace that opens a class definition.
+ class-close -- Brace that closes a class definition.
+ inline-open -- Brace that opens an in-class inline method.
+ inline-close -- Brace that closes an in-class inline method.
+ func-decl-cont -- The region between a function definition's
+ argument list and the function opening brace
+ (excluding K&R argument declarations). In C, you
+ cannot put anything but whitespace and comments
+ between them; in C++ and Java, throws declarations
+ and other things can appear in this context.
+ knr-argdecl-intro -- First line of a K&R C argument declaration.
+ knr-argdecl -- Subsequent lines in a K&R C argument declaration.
+ topmost-intro -- The first line in a topmost construct definition.
+ topmost-intro-cont -- Topmost definition continuation lines.
+ member-init-intro -- First line in a member initialization list.
+ member-init-cont -- Subsequent member initialization list lines.
+ inher-intro -- First line of a multiple inheritance list.
+ inher-cont -- Subsequent multiple inheritance lines.
+ block-open -- Statement block open brace.
+ 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.
+ brace-entry-open -- Subsequent lines in an enum or static array
+ list that start with an open brace.
+ statement -- A C (or like) 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.
+ substatement-label -- Labelled line after an if/while/for/do/else.
+ case-label -- A \"case\" or \"default\" label.
+ access-label -- C++ private/protected/public access label.
+ label -- Any ordinary label.
+ do-while-closure -- The \"while\" that ends a do/while construct.
+ else-clause -- The \"else\" of an if/else construct.
+ catch-clause -- The \"catch\" or \"finally\" of a try/catch
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
+ 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.
+ inclass -- The construct is nested inside a class definition.
+ Used together with e.g. `topmost-intro'.
+ cpp-macro -- The start of a C preprocessor macro definition.
+ cpp-macro-cont -- Inside a multi-line C preprocessor macro
definition.
+ 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 \"extern\" block.
+ extern-lang-close -- Brace that closes an \"extern\" block.
+ inextern-lang -- Analogous to the `inclass' syntactic symbol,
+ but used inside \"extern\" blocks.
+ namespace-open, namespace-close, innamespace
+ -- Similar to the three `extern-lang' symbols, but for
+ C++ \"namespace\" blocks.
+ module-open, module-close, inmodule
+ -- Similar to the three `extern-lang' symbols, but for
+ CORBA IDL \"module\" blocks.
+ composition-open, composition-close, incomposition
+ -- Similar to the three `extern-lang' symbols, but for
+ CORBA CIDL \"composition\" blocks.
+ template-args-cont -- C++ template argument list continuations.
+ inlambda -- In the header or body of a lambda function.
+ lambda-intro-cont -- Continuation of the header of a lambda function.
+ inexpr-statement -- The statement is inside an expression.
+ inexpr-class -- The class is inside an expression. Used e.g. for
+ Java anonymous classes."
+ :type
+ `(set :format "%{%t%}:
+ Override style setting
+ | Syntax Offset
+ %v"
+ ,@(mapcar
+ (lambda (elt)
+ `(cons :format "%v"
+ :value ,elt
+ (c-const-symbol :format "%v: "
+ :size 25)
+ (sexp :format "%v"
+ :validate
+ (lambda (widget)
+ (unless (c-valid-offset (widget-value widget))
+ (widget-put widget :error "Invalid offset")
+ widget)))))
+ (get 'c-offsets-alist 'c-stylevar-fallback)))
+ :group 'c)
+
+ ;; The syntactic symbols that can occur inside code blocks. Used by
+ ;; `c-gnu-impose-minimum'.
+ (defconst c-inside-block-syms
+ '(defun-block-intro block-open block-close statement statement-cont
+ statement-block-intro statement-case-intro statement-case-open
+ substatement substatement-open substatement-label case-label label
+ do-while-closure else-clause catch-clause inlambda))
+
+ (defcustom c-style-variables-are-local-p t
+ "*Whether style variables should be buffer local by default.
+ If non-nil, then all indentation style related variables will be made
+ buffer local by default. If nil, they will remain global. Variables
+ are made buffer local when this file is loaded, and once buffer
+ localized, they cannot be made global again.
+
+ This variable must be set appropriately before CC Mode is loaded.
+
+ The list of variables to buffer localize are:
+ c-basic-offset
+ c-comment-only-line-offset
+ c-indent-comment-alist
+ c-indent-comments-syntactically-p
+ c-block-comment-prefix
+ c-comment-prefix-regexp
+ c-doc-comment-style
+ c-cleanup-list
+ c-hanging-braces-alist
+ c-hanging-colons-alist
+ c-hanging-semi&comma-criteria
+ c-backslash-column
+ c-backslash-max-column
+ c-label-minimum-indentation
+ c-offsets-alist
+ c-special-indent-hook
+ c-indentation-style"
+ :type 'boolean
+ :group 'c)
+
+ (defcustom c-mode-hook nil
+ "*Hook called by `c-mode'."
+ :type 'hook
+ :group 'c)
+
+ (defcustom c++-mode-hook nil
+ "*Hook called by `c++-mode'."
+ :type 'hook
+ :group 'c)
+
+ (defcustom objc-mode-hook nil
+ "*Hook called by `objc-mode'."
+ :type 'hook
+ :group 'c)
+
+ (defcustom java-mode-hook nil
+ "*Hook called by `java-mode'."
+ :type 'hook
+ :group 'c)
+
+ (defcustom idl-mode-hook nil
+ "*Hook called by `idl-mode'."
+ :type 'hook
+ :group 'c)
+
+ (defcustom pike-mode-hook nil
+ "*Hook called by `pike-mode'."
+ :type 'hook
+ :group 'c)
+
+ (defcustom c-mode-common-hook nil
+ "*Hook called by all CC Mode modes for common initializations."
+ :type 'hook
+ :group 'c)
+
+ (defcustom c-initialization-hook nil
+ "*Hook called when the CC Mode package gets initialized.
+ This hook is only run once per Emacs session and can be used as a
+ `load-hook' or in place of using `eval-after-load'."
+ :type 'hook
+ :group 'c)
+
+ (defcustom c-enable-xemacs-performance-kludge-p nil
+ "*Enables a XEmacs only hack that may improve speed for some coding styles.
+ For styles that hang top-level opening braces (as is common with JDK
+ Java coding styles) this can improve performance between 3 and 60
+ times for core indentation functions (e.g. `c-parse-state'). For
+ styles that conform to the Emacs recommendation of putting these
+ braces in column zero, this can degrade performance about as much.
+ This variable only has effect in XEmacs."
+ :type 'boolean
+ :group 'c)
+
+ (defvar c-old-style-variable-behavior nil
+ "*Enables the old style variable behavior when non-nil.
+
+ Normally the values of the style variables will override the style
+ settings specified by the variables `c-default-style' and
+ `c-style-alist'. However, in CC Mode 5.25 and earlier, it was the
+ other way around, meaning that changes made to the style variables
+ from e.g. Customize would not take effect unless special precautions
+ were taken. That was confusing, especially for novice users.
+
+ It's believed that despite this change, the new behavior will still
+ produce the same results for most old CC Mode configurations, since
+ all style variables are per default set in a special non-override
+ state. Set this variable only if your configuration has stopped
+ working due to this change.")
+
+ (define-widget 'c-extra-types-widget 'radio
+ "Internal CC Mode widget for the `*-font-lock-extra-types' variables."
+ :args '((const :tag "none" nil)
+ (repeat :tag "types" regexp)))
+
+ (eval-and-compile
+ ;; XEmacs 19 evaluates this at compile time below, while most other
+ ;; versions delays the evaluation until the package is loaded.
+ (defun c-make-font-lock-extra-types-blurb (mode1 mode2 example)
+ (concat "\
+ *List of extra types (aside from the type keywords) to recognize in "
+ mode1 " mode.
+ Each list item should be a regexp matching a single identifier.
+ " example "
+
+ On decoration level 3 (and higher, where applicable), a method is used
+ that finds most types and declarations by syntax alone. This variable
+ is still used as a first step, but other types are recognized
+ correctly anyway in most cases. Therefore this variable should be
+ fairly restrictive and not contain patterns that are uncertain.
+
+ Note that this variable is only consulted when the major mode is
+ initialized. If you change it later you have to reinitialize CC Mode
+ by doing \\[" mode2 "].
+
+ Despite the name, this variable is not only used for font locking but
+ also elsewhere in CC Mode to tell types from other identifiers.")))
+
+ ;; Note: Most of the variables below are also defined in font-lock.el
+ ;; in older versions in Emacs, so depending on the load order we might
+ ;; not install the values below. There's no kludge to cope with this
+ ;; (as opposed to the *-font-lock-keywords-* variables) since the old
+ ;; values work fairly well anyway.
+
+ (defcustom c-font-lock-extra-types
+ '("FILE" "\\sw+_t"
+ "bool" "complex" "imaginary" ; Defined in C99.
+ ;; I do not appreciate the following very Emacs-specific luggage
+ ;; in the default value, but otoh it can hardly get in the way for
+ ;; other users, and removing it would cause unnecessary grief for
+ ;; the old timers that are used to it. /mast
+ "Lisp_Object")
+ (c-make-font-lock-extra-types-blurb "C" "c-mode"
+ "For example, a value of (\"FILE\" \"\\\\sw+_t\") means the word FILE
+ and words ending in _t are treated as type names.")
+ :type 'c-extra-types-widget
+ :group 'c)
+
+ (defcustom c++-font-lock-extra-types
+ '("\\sw+_t"
+ "\\([iof]\\|str\\)+stream\\(buf\\)?" "ios"
+ "string" "rope"
+ "list" "slist"
+ "deque" "vector" "bit_vector"
+ "set" "multiset"
+ "map" "multimap"
+ "hash\\(_\\(m\\(ap\\|ulti\\(map\\|set\\)\\)\\|set\\)\\)?"
+ "stack" "queue" "priority_queue"
+ "type_info"
+ "iterator" "const_iterator" "reverse_iterator" "const_reverse_iterator"
+ "reference" "const_reference")
+ (c-make-font-lock-extra-types-blurb "C++" "c++-mode"
+ "For example, a value of (\"string\") means the word string is treated
+ as a type name.")
+ :type 'c-extra-types-widget
+ :group 'c)
+
+ (defcustom objc-font-lock-extra-types
+ (list (concat "[" c-upper "]\\sw*[" c-lower "]\\sw*"))
+ (c-make-font-lock-extra-types-blurb "ObjC" "objc-mode" (concat
+ "For example, a value of (\"[" c-upper "]\\\\sw*[" c-lower "]\\\\sw*\") means
+ capitalized words are treated as type names (the requirement for a
+ lower case char is to avoid recognizing all-caps macro and constant
+ names)."))
+ :type 'c-extra-types-widget
+ :group 'c)
+
+ (defcustom java-font-lock-extra-types
+ (list (concat "[" c-upper "]\\sw*[" c-lower "]\\sw*"))
+ (c-make-font-lock-extra-types-blurb "Java" "java-mode" (concat
+ "For example, a value of (\"[" c-upper "]\\\\sw*[" c-lower "]\\\\sw*\") means
+ capitalized words are treated as type names (the requirement for a
+ lower case char is to avoid recognizing all-caps constant names)."))
+ :type 'c-extra-types-widget
+ :group 'c)
+
+ (defcustom idl-font-lock-extra-types nil
+ (c-make-font-lock-extra-types-blurb "IDL" "idl-mode" "")
+ :type 'c-extra-types-widget
+ :group 'c)
+
+ (defcustom pike-font-lock-extra-types
+ (list (concat "[" c-upper "]\\sw*[" c-lower "]\\sw*"))
+ (c-make-font-lock-extra-types-blurb "Pike" "pike-mode" (concat
+ "For example, a value of (\"[" c-upper "]\\\\sw*[" c-lower "]\\\\sw*\") means
+ capitalized words are treated as type names (the requirement for a
+ lower case char is to avoid recognizing all-caps macro and constant
+ names)."))
+ :type 'c-extra-types-widget
+ :group 'c)
+
+
+ ;; Non-customizable variables, still part of the interface to CC Mode
+ (defvar c-file-style nil
+ "Variable interface for setting style via File Local Variables.
+ In a file's Local Variable section, you can set this variable to a
+ string suitable for `c-set-style'. When the file is visited, CC Mode
+ will set the style of the file to this value automatically.
+
+ Note that file style settings are applied before file offset settings
+ as designated in the variable `c-file-offsets'.")
+ (make-variable-buffer-local 'c-file-style)
+
+ (defvar c-file-offsets nil
+ "Variable interface for setting offsets via File Local Variables.
+ In a file's Local Variable section, you can set this variable to an
+ association list similar to the values allowed in `c-offsets-alist'.
+ When the file is visited, CC Mode will institute these offset settings
+ automatically.
+
+ Note that file offset settings are applied after file style settings
+ as designated in the variable `c-file-style'.")
+ (make-variable-buffer-local 'c-file-offsets)
+
+ ;; It isn't possible to specify a docstring without specifying an
+ ;; initial value with `defvar', so the following two variables have
+ ;; only doc comments even though they are part of the API. It's
+ ;; really good not to have an initial value for variables like these
+ ;; that always should be dynamically bound, so it's worth the
+ ;; inconvenience.
+
+ (cc-bytecomp-defvar c-syntactic-context)
+ (defvar c-syntactic-context)
+ ;; Variable containing the syntactic analysis list during indentation.
+ ;; It is a list with one element for each found syntactic symbol. See
+ ;; `c-syntactic-element' for further info.
+ ;;
+ ;; This is always bound dynamically. It should never be set
+ ;; statically (e.g. with `setq').
+
+ (cc-bytecomp-defvar c-syntactic-element)
+ (defvar c-syntactic-element)
+ ;; Variable containing the info regarding the current syntactic
+ ;; element during calls to the lineup functions. The value is one of
+ ;; the elements in the list in `c-syntactic-context' and is a list
+ ;; with the symbol name in the first position, followed by zero or
+ ;; more elements containing any additional info associated with the
+ ;; syntactic symbol. There are accessor functions `c-langelem-sym',
+ ;; `c-langelem-pos', `c-langelem-col', and `c-langelem-2nd-pos' to
+ ;; access the list.
+ ;;
+ ;; Specifically, the element returned by `c-langelem-pos' is the
+ ;; relpos (a.k.a. anchor position), or nil if there isn't any. See
+ ;; the comments in the `c-offsets-alist' variable for more detailed
+ ;; info about the data each syntactic symbol provides.
+ ;;
+ ;; This is always bound dynamically. It should never be set
+ ;; statically (e.g. with `setq').
+
+ (defvar c-indentation-style nil
+ "Name of the currently installed style.
+ Don't change this directly; call `c-set-style' instead.")
+
+ (defvar c-current-comment-prefix nil
+ "The current comment prefix regexp.
+ Set from `c-comment-prefix-regexp' at mode initialization.")
+ (make-variable-buffer-local 'c-current-comment-prefix)
+
+
+ (cc-provide 'cc-vars)
+
+ ;;; arch-tag: d62e9a55-c9fe-409b-b5b6-050b6aa202c9
+ ;;; cc-vars.el ends here
[Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Emacs-diffs] Changes to emacs/lisp/progmodes/cc-vars.el [gnus-5_10-branch],
Miles Bader <=