mirror of
https://git.savannah.gnu.org/git/emacs.git
synced 2024-12-14 09:39:42 +00:00
1687 lines
68 KiB
EmacsLisp
1687 lines
68 KiB
EmacsLisp
;;; 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: bug-cc-mode@gnu.org
|
||
;; 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 insert a `real' tab character
|
||
\(see note\). If the symbol `other', then tab is inserted only within
|
||
literals -- defined as comments and strings -- and inside preprocessor
|
||
directives, 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)
|
||
|
||
|
||
;; Figure out what features this Emacs has
|
||
|
||
(cc-bytecomp-defvar open-paren-in-column-0-is-defun-start)
|
||
|
||
(defconst c-emacs-features
|
||
(let (list)
|
||
|
||
(if (boundp 'infodock-version)
|
||
;; I've no idea what this actually is, but it's legacy. /mast
|
||
(setq list (cons 'infodock list)))
|
||
|
||
;; XEmacs 19 and beyond use 8-bit modify-syntax-entry flags.
|
||
;; Emacs 19 uses a 1-bit flag. We will have to set up our
|
||
;; syntax tables differently to handle this.
|
||
(let ((table (copy-syntax-table))
|
||
entry)
|
||
(modify-syntax-entry ?a ". 12345678" table)
|
||
(cond
|
||
;; XEmacs 19, and beyond Emacs 19.34
|
||
((arrayp table)
|
||
(setq entry (aref table ?a))
|
||
;; In Emacs, table entries are cons cells
|
||
(if (consp entry) (setq entry (car entry))))
|
||
;; XEmacs 20
|
||
((fboundp 'get-char-table) (setq entry (get-char-table ?a table)))
|
||
;; before and including Emacs 19.34
|
||
((and (fboundp 'char-table-p)
|
||
(char-table-p table))
|
||
(setq entry (car (char-table-range table [?a]))))
|
||
;; incompatible
|
||
(t (error "CC Mode is incompatible with this version of Emacs")))
|
||
(setq list (cons (if (= (logand (lsh entry -16) 255) 255)
|
||
'8-bit
|
||
'1-bit)
|
||
list)))
|
||
|
||
(let ((buf (generate-new-buffer " test"))
|
||
parse-sexp-lookup-properties
|
||
parse-sexp-ignore-comments
|
||
lookup-syntax-properties)
|
||
(save-excursion
|
||
(set-buffer buf)
|
||
(set-syntax-table (make-syntax-table))
|
||
|
||
;; For some reason we have to set some of these after the
|
||
;; buffer has been made current. (Specifically,
|
||
;; `parse-sexp-ignore-comments' in Emacs 21.)
|
||
(setq parse-sexp-lookup-properties t
|
||
parse-sexp-ignore-comments t
|
||
lookup-syntax-properties t)
|
||
|
||
;; Find out if the `syntax-table' text property works.
|
||
(modify-syntax-entry ?< ".")
|
||
(modify-syntax-entry ?> ".")
|
||
(insert "<()>")
|
||
(c-mark-<-as-paren 1)
|
||
(c-mark->-as-paren 4)
|
||
(goto-char 1)
|
||
(c-forward-sexp)
|
||
(if (= (point) 5)
|
||
(setq list (cons 'syntax-properties list)))
|
||
|
||
;; Find out if generic comment delimiters work.
|
||
(c-safe
|
||
(modify-syntax-entry ?x "!")
|
||
(if (string-match "\\s!" "x")
|
||
(setq list (cons 'gen-comment-delim list))))
|
||
|
||
;; Find out if generic string delimiters work.
|
||
(c-safe
|
||
(modify-syntax-entry ?x "|")
|
||
(if (string-match "\\s|" "x")
|
||
(setq list (cons 'gen-string-delim list))))
|
||
|
||
;; See if `open-paren-in-column-0-is-defun-start' exists and
|
||
;; isn't buggy.
|
||
(when (boundp 'open-paren-in-column-0-is-defun-start)
|
||
(let ((open-paren-in-column-0-is-defun-start nil)
|
||
(parse-sexp-ignore-comments t))
|
||
(set-syntax-table (make-syntax-table))
|
||
(modify-syntax-entry ?\' "\"")
|
||
(cond
|
||
;; XEmacs. Afaik this is currently an Emacs-only
|
||
;; feature, but it's good to be prepared.
|
||
((memq '8-bit list)
|
||
(modify-syntax-entry ?/ ". 1456")
|
||
(modify-syntax-entry ?* ". 23"))
|
||
;; Emacs
|
||
((memq '1-bit list)
|
||
(modify-syntax-entry ?/ ". 124b")
|
||
(modify-syntax-entry ?* ". 23")))
|
||
(modify-syntax-entry ?\n "> b")
|
||
(insert "/* '\n () */")
|
||
(backward-sexp)
|
||
(if (bobp)
|
||
(setq list (cons 'col-0-paren list))))
|
||
(kill-buffer buf))
|
||
|
||
(set-buffer-modified-p nil))
|
||
(kill-buffer buf))
|
||
|
||
;; See if `parse-partial-sexp' returns the eighth element.
|
||
(when (c-safe (>= (length (save-excursion (parse-partial-sexp 1 1))) 10))
|
||
(setq list (cons 'pps-extended-state list)))
|
||
|
||
;; See if POSIX char classes work.
|
||
(when (string-match "[[:alpha:]]" "a")
|
||
(setq list (cons 'posix-char-classes list)))
|
||
|
||
list)
|
||
"A list of certain features in the (X)Emacs you are using.
|
||
There are many flavors of Emacs out there, each with different
|
||
features supporting those needed by CC Mode. The following values
|
||
might be present:
|
||
|
||
'8-bit 8 bit syntax entry flags (XEmacs style).
|
||
'1-bit 1 bit syntax entry flags (Emacs style).
|
||
'syntax-properties It works to override the syntax for specific characters
|
||
in the buffer with the 'syntax-table property.
|
||
'gen-comment-delim Generic comment delimiters work
|
||
(i.e. the syntax class `!').
|
||
'gen-string-delim Generic string delimiters work
|
||
(i.e. the syntax class `|').
|
||
'pps-extended-state `parse-partial-sexp' returns a list with at least 10
|
||
elements, i.e. it contains the position of the
|
||
start of the last comment or string.
|
||
'posix-char-classes The regexp engine understands POSIX character classes.
|
||
'col-0-paren It's possible to turn off the ad-hoc rule that a paren
|
||
in column zero is the start of a defun.
|
||
'infodock This is Infodock (based on XEmacs).
|
||
|
||
'8-bit and '1-bit are mutually exclusive.")
|
||
|
||
|
||
(cc-provide 'cc-vars)
|
||
|
||
;;; arch-tag: d62e9a55-c9fe-409b-b5b6-050b6aa202c9
|
||
;;; cc-vars.el ends here
|