Commit 51c9af45 authored by Alan Mackenzie's avatar Alan Mackenzie
Browse files

Update CC Mode to version 5.31.4. The detailed changes are those

recorded in the ChangeLog for 2007-01-01.
parent d8a4fc44
......@@ -90,6 +90,29 @@ Works with: topmost-intro-cont."
(c-after-special-operator-id))))
c-basic-offset)))
(defun c-lineup-gnu-DEFUN-intro-cont (langelem)
"Line up the continuation lines of a DEFUN macro in the Emacs C source.
These lines are indented as though they were `knr-argdecl-intro' lines.
Return nil when we're not in such a construct.
This function is for historical compatibility with how previous CC Modes (5.28
and earlier) indented such lines.
Here is an example:
DEFUN (\"forward-char\", Fforward_char, Sforward_char, 0, 1, \"p\",
doc: /* Move point right N characters (left if N is negative).
On reaching end of buffer, stop and signal error. */)
(n) <- c-lineup-gnu-DEFUN-into-cont
Lisp_Object n; <- c-lineup-gnu-DEFUN-into-cont
Works with: topmost-intro-cont."
(save-excursion
(let (case-fold-search)
(goto-char (c-langelem-pos langelem))
(if (looking-at "\\<DEFUN\\>")
(c-calc-offset '(knr-argdecl-intro))))))
(defun c-block-in-arglist-dwim (arglist-start)
;; This function implements the DWIM to avoid far indentation of
;; brace block constructs in arguments in `c-lineup-arglist' etc.
......
......@@ -720,7 +720,7 @@
(not (search-forward-regexp c-awk-regexp-sign-re (1+ /point) t))
(search-forward-regexp c-awk-div-sign-re (1+ /point) t))
;; A division sign.
(progn (goto-char (1+ /point)) nil)
(progn (goto-char (1+ /point)) nil)
;; A regexp opener
;; Jump over the regexp innards, setting the match data.
(goto-char /point)
......
This diff is collapsed.
......@@ -95,7 +95,7 @@
;;; Variables also used at compile time.
(defconst c-version "5.31.3"
(defconst c-version "5.31.4"
"CC Mode version number.")
(defconst c-version-sym (intern c-version))
......@@ -764,7 +764,7 @@ be after it."
;; call `c-beginning-of-statement-1'.
;;
;; The macro `c-vsemi-status-unknown-p' will typically check the cacheing
;; scheme used by the `c-at-vsemp-p-fn', hence the name - the status is
;; scheme used by the `c-at-vsemi-p-fn', hence the name - the status is
;; "unknown" if there is no cache entry current for the line.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
......@@ -1620,7 +1620,7 @@ itself is evaluated."
(defmacro c-lang-defconst (name &rest args)
"Set the language specific values of the language constant NAME.
The second argument can be an optional docstring. The rest of the
The second argument can optionally be a docstring. The rest of the
arguments are one or more repetitions of LANG VAL where LANG specifies
the language(s) that VAL applies to. LANG is the name of the
language, i.e. the mode name without the \"-mode\" suffix, or a list
......@@ -1717,7 +1717,7 @@ constant. A file is identified by its base name."
;; Emacs has a weird bug where it seems to fail to read
;; backquote lists from byte compiled files correctly (,@
;; forms, to be specific), so make sure the bindings in the
;; expansion below doesn't contain any backquote stuff.
;; expansion below don't contain any backquote stuff.
;; (XEmacs handles it correctly and doesn't need this for that
;; reason, but we also use this expansion handle
;; `c-lang-defconst-eval-immediately' and to register
......
......@@ -255,6 +255,18 @@ comment at the start of cc-engine.el for more info."
(forward-char)
t))))
(defun c-forward-over-cpp-define-id ()
;; Assuming point is at the "#" that introduces a preprocessor
;; directive, it's moved forward to the end of the identifier which is
;; "#define"d (or whatever c-opt-cpp-macro-define specifies). Non-nil
;; is returned in this case, in all other cases nil is returned and
;; point isn't moved.
;;
;; This function might do hidden buffer changes.
(when (and c-opt-cpp-macro-define-id
(looking-at c-opt-cpp-macro-define-id))
(goto-char (match-end 0))))
(defun c-forward-to-cpp-define-body ()
;; Assuming point is at the "#" that introduces a preprocessor
;; directive, it's moved forward to the start of the definition body
......@@ -2442,14 +2454,14 @@ comment at the start of cc-engine.el for more info."
(= (c-backward-token-2 0) 0))
(cond ((and (looking-at c-overloadable-operators-regexp)
(or (not c-opt-op-identitier-prefix)
(or (not c-opt-op-identifier-prefix)
(and (= (c-backward-token-2 1) 0)
(looking-at c-opt-op-identitier-prefix))))
(looking-at c-opt-op-identifier-prefix))))
(point))
((save-excursion
(and c-opt-op-identitier-prefix
(looking-at c-opt-op-identitier-prefix)
(and c-opt-op-identifier-prefix
(looking-at c-opt-op-identifier-prefix)
(= (c-forward-token-2 1) 0)
(looking-at c-overloadable-operators-regexp)))
(point))))
......@@ -3843,7 +3855,7 @@ comment at the start of cc-engine.el for more info."
;; good start position for the search, so do it.
(c-find-decl-prefix-search)))
;; Now loop. We already got the first match.
;; Now loop. Round what? (ACM, 2006/7/5). We already got the first match.
(while (progn
(while (and
......@@ -4534,41 +4546,42 @@ comment at the start of cc-engine.el for more info."
(goto-char start)
nil)
(while (and
(while (progn
(c-syntactic-skip-backward "^<;{}" limit t)
(if (eq (char-before) ?<)
t
;; Stopped at bob or a char that isn't allowed in an
;; arglist, so we've failed.
(goto-char start)
nil)
(and
(if (eq (char-before) ?<)
t
;; Stopped at bob or a char that isn't allowed in an
;; arglist, so we've failed.
(goto-char start)
nil)
(if (> (point)
(progn (c-beginning-of-current-token)
(point)))
;; If we moved then the "<" was part of some
;; multicharacter token.
t
(if (> (point)
(progn (c-beginning-of-current-token)
(point)))
;; If we moved then the "<" was part of some
;; multicharacter token.
t
(backward-char)
(let ((beg-pos (point)))
(if (c-forward-<>-arglist all-types)
(cond ((= (point) start)
;; Matched the arglist. Break the while.
(goto-char beg-pos)
nil)
((> (point) start)
;; We started from a non-paren ">" inside an
;; arglist.
(goto-char start)
nil)
(t
;; Matched a shorter arglist. Can be a nested
;; one so continue looking.
(goto-char beg-pos)
t))
t)))))
(backward-char)
(let ((beg-pos (point)))
(if (c-forward-<>-arglist all-types)
(cond ((= (point) start)
;; Matched the arglist. Break the while.
(goto-char beg-pos)
nil)
((> (point) start)
;; We started from a non-paren ">" inside an
;; arglist.
(goto-char start)
nil)
(t
;; Matched a shorter arglist. Can be a nested
;; one so continue looking.
(goto-char beg-pos)
t))
t))))))
(/= (point) start))))
......@@ -5793,17 +5806,32 @@ y ;; True if there's a suffix match outside the outermost
nil))))
(defun c-forward-label (&optional assume-markup preceding-token-end limit)
;; Assuming the point is at the beginning of a token, check if it
;; starts a label and if so move over it and return t, otherwise
;; don't move and return nil. The end of the label is taken to be
;; the end of the first submatch in `c-opt-extra-label-key' if it
;; matched, otherwise it's the colon. The point is directly after
;; the end on return. The terminating char is marked with
;; `c-decl-end' to improve recognition of the following declaration
;; or statement.
;; Assuming that point is at the beginning of a token, check if it starts a
;; label and if so move over it and return t, otherwise don't move and
;; return nil. "Label" here means "most things with a colon".
;;
;; More precisely, a "label" is regarded as one of:
;; (i) a goto target like "foo:";
;; (ii) A case label - either the entire construct "case FOO:" or just the
;; bare "case", should the colon be missing;
;; (iii) a keyword which needs a colon, like "default:" or "private:";
;; (iv) One of QT's "extended" C++ variants of
;; "private:"/"protected:"/"public:"/"more:" looking like "public slots:".
;; (v) One of the keywords matched by `c-opt-extra-label-key' (without any
;; colon). Currently (2006-03), this applies only to Objective C's
;; keywords "@private", "@protected", and "@public".
;;
;; One of the things which will NOT be recognised as a label is a bit-field
;; element of a struct, something like "int foo:5".
;;
;; The end of the label is taken to be just after the colon, or the end of
;; the first submatch in `c-opt-extra-label-key'. The point is directly
;; after the end on return. The terminating char gets marked with
;; `c-decl-end' to improve recognition of the following declaration or
;; statement.
;;
;; If ASSUME-MARKUP is non-nil, it's assumed that the preceding
;; label, if any, has been marked up like that.
;; label, if any, has already been marked up like that.
;;
;; If PRECEDING-TOKEN-END is given, it should be the first position
;; after the preceding token, i.e. on the other side of the
......@@ -5819,8 +5847,11 @@ y ;; True if there's a suffix match outside the outermost
;;
;; This function might do hidden buffer changes.
(let ((start (point)))
(let ((start (point))
qt-symbol-idx
macro-start) ; if we're in one.
(cond
;; "case" or "default" (Doesn't apply to AWK).
((looking-at c-label-kwds-regexp)
(let ((kwd-end (match-end 1)))
;; Record only the keyword itself for fontification, since in
......@@ -5840,7 +5871,7 @@ y ;; True if there's a suffix match outside the outermost
(match-beginning 2))
(progn
(goto-char (match-beginning 2))
(goto-char (match-beginning 2)) ; just after the :
(c-put-c-type-property (1- (point)) 'c-decl-end)
t)
......@@ -5851,6 +5882,7 @@ y ;; True if there's a suffix match outside the outermost
(goto-char kwd-end)
t)))
;; @private, @protected, @public, in Objective C, or similar.
((and c-opt-extra-label-key
(looking-at c-opt-extra-label-key))
;; For a `c-opt-extra-label-key' match, we record the whole
......@@ -5862,7 +5894,8 @@ y ;; True if there's a suffix match outside the outermost
(c-put-c-type-property (1- (point)) 'c-decl-end)
t)
((and c-recognize-colon-labels
;; All other cases of labels.
((and c-recognize-colon-labels ; nil for AWK and IDL, otherwise t.
;; A colon label must have something before the colon.
(not (eq (char-after) ?:))
......@@ -5890,7 +5923,8 @@ y ;; True if there's a suffix match outside the outermost
(save-excursion
(goto-char (1- preceding-token-end))
(c-beginning-of-current-token)
(looking-at c-label-prefix-re))
(or (looking-at c-label-prefix-re)
(looking-at c-block-stmt-1-key)))
(and (eq (char-before preceding-token-end) ?\))
(c-after-conditional)))
......@@ -5899,7 +5933,8 @@ y ;; True if there's a suffix match outside the outermost
(save-excursion
(goto-char (1- preceding-token-end))
(c-beginning-of-current-token)
(looking-at c-label-prefix-re))
(or (looking-at c-label-prefix-re)
(looking-at c-block-stmt-1-key)))
(cond
((eq (char-before preceding-token-end) ?\))
......@@ -5907,26 +5942,52 @@ y ;; True if there's a suffix match outside the outermost
((eq (char-before preceding-token-end) ?:)
;; Might be after another label, so check it recursively.
(save-excursion
(goto-char (1- preceding-token-end))
;; Essentially the same as the
;; `c-syntactic-re-search-forward' regexp below.
(c-syntactic-skip-backward "^-]:?;}=*/%&|,<>!@+" nil t)
(let ((pte (point))
;; If the caller turned on recording for us,
;; it shouldn't apply when we check the
;; preceding label.
c-record-type-identifiers)
(c-forward-syntactic-ws)
(c-forward-label nil pte start))))))))
;; Check that the next nonsymbol token is ":". Allow '('
;; for the sake of macro arguments. FIXME: Should build
;; this regexp from the language constants.
(c-syntactic-re-search-forward
"[[:?;{=*/%&|,<>!@+-]" limit t t)
(eq (char-before) ?:)
(not (eq (char-after) ?:)))
(save-restriction
(save-excursion
(goto-char (1- preceding-token-end))
;; Essentially the same as the
;; `c-syntactic-re-search-forward' regexp below.
(setq macro-start
(save-excursion (and (c-beginning-of-macro)
(point))))
(if macro-start (narrow-to-region macro-start (point-max)))
(c-syntactic-skip-backward "^-]:?;}=*/%&|,<>!@+" nil t)
;; Note: the following should work instead of the
;; narrow-to-region above. Investigate why not,
;; sometime. ACM, 2006-03-31.
;; (c-syntactic-skip-backward "^-]:?;}=*/%&|,<>!@+"
;; macro-start t)
(let ((pte (point))
;; If the caller turned on recording for us,
;; it shouldn't apply when we check the
;; preceding label.
c-record-type-identifiers)
;; A label can't start at a cpp directive. Check for
;; this, since c-forward-syntactic-ws would foul up on it.
(unless (and c-opt-cpp-prefix (looking-at c-opt-cpp-prefix))
(c-forward-syntactic-ws)
(c-forward-label nil pte start))))))))))
;; Check that the next nonsymbol token is ":", or that we're in one
;; of QT's "slots" declarations. Allow '(' for the sake of macro
;; arguments. FIXME: Should build this regexp from the language
;; constants.
(when (c-syntactic-re-search-forward
"[ \t[:?;{=*/%&|,<>!@+-]" limit t t) ; not at EOB
(backward-char)
(setq qt-symbol-idx
(and (c-major-mode-is 'c++-mode)
(string-match
"\\(p\\(r\\(ivate\\|otected\\)\\|ublic\\)\\|more\\)\\>"
(buffer-substring start (point)))))
(c-forward-syntactic-ws limit)
(when (or (looking-at ":\\([^:]\\|\\'\\)") ; A single colon.
(and qt-symbol-idx
(search-forward-regexp "\\=slots\\>" limit t)
(progn (c-forward-syntactic-ws limit)
(looking-at ":\\([^:]\\|\\'\\)")))) ; A single colon
(forward-char) ; to after the colon.
t)))
(save-restriction
(narrow-to-region start (point))
......@@ -6145,8 +6206,8 @@ comment at the start of cc-engine.el for more info."
;; so that we don't get stuck on that instead of the
;; function arglist.
(c-forward-sexp))
((and c-opt-op-identitier-prefix
(looking-at c-opt-op-identitier-prefix))
((and c-opt-op-identifier-prefix
(looking-at c-opt-op-identifier-prefix))
;; Don't trip up on "operator ()".
(c-forward-token-2 2 t)))
(and (< (point) beg)
......@@ -6263,10 +6324,10 @@ comment at the start of cc-engine.el for more info."
(and c-overloadable-operators-regexp
(zerop (c-backward-token-2 1 nil lim))
(looking-at c-overloadable-operators-regexp)
(or (not c-opt-op-identitier-prefix)
(or (not c-opt-op-identifier-prefix)
(and
(zerop (c-backward-token-2 1 nil lim))
(looking-at c-opt-op-identitier-prefix)))
(looking-at c-opt-op-identifier-prefix)))
(point))))
(defsubst c-backward-to-block-anchor (&optional lim)
......@@ -6314,7 +6375,7 @@ comment at the start of cc-engine.el for more info."
;; operator token preceded by "operator".
(save-excursion
(and (c-safe (c-backward-sexp) t)
(looking-at c-opt-op-identitier-prefix)))
(looking-at c-opt-op-identifier-prefix)))
(and (eq (char-before) ?<)
(c-with-syntax-table c++-template-syntax-table
(if (c-safe (goto-char (c-up-list-forward (point))))
......@@ -6354,6 +6415,10 @@ comment at the start of cc-engine.el for more info."
;; construct, i.e. if it isn't preceded by ';', '}', ':', bob,
;; or an open paren.
(let ((beg (point)) tentative-move)
;; Go back one "statement" each time round the loop until we're just
;; after a ;, }, or :, or at BOB or the start of a macro or start of
;; an ObjC method. This will move over a multiple declaration whose
;; components are comma separated.
(while (and
;; Must check with c-opt-method-key in ObjC mode.
(not (and c-opt-method-key
......@@ -6397,25 +6462,39 @@ comment at the start of cc-engine.el for more info."
knr-argdecl-start))
(goto-char fallback-pos))))
;; `c-beginning-of-statement-1' counts each brace block as a
;; separate statement, so the result will be 'previous if we've
;; moved over any. If they were brace list initializers we might
;; not have moved over a declaration boundary though, so change it
;; to 'same if we've moved past a '=' before '{', but not ';'.
;; (This ought to be integrated into `c-beginning-of-statement-1',
;; so we avoid this extra pass which potentially can search over a
;; large amount of text.)
;; `c-beginning-of-statement-1' counts each brace block as a separate
;; statement, so the result will be 'previous if we've moved over any.
;; So change our result back to 'same if necessary.
;;
;; If they were brace list initializers we might not have moved over a
;; declaration boundary though, so change it to 'same if we've moved
;; past a '=' before '{', but not ';'. (This ought to be integrated
;; into `c-beginning-of-statement-1', so we avoid this extra pass which
;; potentially can search over a large amount of text.). Take special
;; pains not to get mislead by C++'s "operator=", and the like.
(if (and (eq move 'previous)
(c-with-syntax-table (if (c-major-mode-is 'c++-mode)
c++-template-syntax-table
(syntax-table))
(save-excursion
(and (c-syntactic-re-search-forward "[;={]" start t t t)
(eq (char-before) ?=)
(c-syntactic-re-search-forward "[;{]" start t t)
(eq (char-before) ?{)
(c-safe (goto-char (c-up-list-forward (point))) t)
(not (c-syntactic-re-search-forward ";" start t t))))))
(and
(progn
(while ; keep going back to "[;={"s until we either find
; no more, or get to one which isn't an "operator ="
(and (c-syntactic-re-search-forward "[;={]" start t t t)
(eq (char-before) ?=)
c-overloadable-operators-regexp
c-opt-op-identifier-prefix
(save-excursion
(eq (c-backward-token-2) 0)
(looking-at c-overloadable-operators-regexp)
(eq (c-backward-token-2) 0)
(looking-at c-opt-op-identifier-prefix))))
(eq (char-before) ?=))
(c-syntactic-re-search-forward "[;{]" start t t)
(eq (char-before) ?{)
(c-safe (goto-char (c-up-list-forward (point))) t)
(not (c-syntactic-re-search-forward ";" start t t))))))
(cons 'same nil)
(cons move nil)))))
......@@ -6725,8 +6804,8 @@ comment at the start of cc-engine.el for more info."
(setq braceassignp
(cond
;; Check for operator =
((and c-opt-op-identitier-prefix
(looking-at c-opt-op-identitier-prefix))
((and c-opt-op-identifier-prefix
(looking-at c-opt-op-identifier-prefix))
nil)
;; Check for `<opchar>= in Pike.
((and (c-major-mode-is 'pike-mode)
......@@ -7000,6 +7079,11 @@ comment at the start of cc-engine.el for more info."
stop-at-boi-only
containing-sexp
paren-state)
;; Add the indicated SYNTAX-SYMBOL to `c-syntactic-context', extending it as
;; needed with further syntax elements of the types `substatement',
;; `inexpr-statement', `arglist-cont-nonempty', `statement-block-intro', and
;; `defun-block-intro'.
;;
;; Do the generic processing to anchor the given syntax symbol on
;; the preceding statement: Skip over any labels and containing
;; statements on the same line, and then search backward until we
......@@ -8085,7 +8169,9 @@ comment at the start of cc-engine.el for more info."
(and (eq (char-before) ?})
(save-excursion
(let ((start (point)))
(if c-state-cache
(if (and c-state-cache
(consp (car c-state-cache))
(eq (cdar c-state-cache) (point)))
;; Speed up the backward search a bit.
(goto-char (caar c-state-cache)))
(c-beginning-of-decl-1 containing-sexp)
......@@ -8103,26 +8189,30 @@ comment at the start of cc-engine.el for more info."
;; CASE 5J: we are at the topmost level, make
;; sure we skip back past any access specifiers
((save-excursion
(setq placeholder (point))
(or (memq char-before-ip '(?\; ?{ ?} nil))
(c-at-vsemi-p before-ws-ip)
(when (and (eq char-before-ip ?:)
(eq (c-beginning-of-statement-1 lim)
'label))
(c-backward-syntactic-ws lim)
(setq placeholder (point)))
(and (c-major-mode-is 'objc-mode)
(catch 'not-in-directive
(c-beginning-of-statement-1 lim)
(setq placeholder (point))
(while (and (c-forward-objc-directive)
(< (point) indent-point))
(c-forward-syntactic-ws)
(if (>= (point) indent-point)
(throw 'not-in-directive t))
(setq placeholder (point)))
nil))))
((and
;; A macro continuation line is never at top level.
(not (and macro-start
(> indent-point macro-start)))
(save-excursion
(setq placeholder (point))
(or (memq char-before-ip '(?\; ?{ ?} nil))
(c-at-vsemi-p before-ws-ip)
(when (and (eq char-before-ip ?:)
(eq (c-beginning-of-statement-1 lim)
'label))
(c-backward-syntactic-ws lim)
(setq placeholder (point)))
(and (c-major-mode-is 'objc-mode)
(catch 'not-in-directive
(c-beginning-of-statement-1 lim)
(setq placeholder (point))
(while (and (c-forward-objc-directive)
(< (point) indent-point))
(c-forward-syntactic-ws)
(if (>= (point) indent-point)
(throw 'not-in-directive t))
(setq placeholder (point)))
nil)))))
;; For historic reasons we anchor at bol of the last
;; line of the previous declaration. That's clearly
;; highly bogus and useless, and it makes our lives hard
......@@ -8177,6 +8267,11 @@ comment at the start of cc-engine.el for more info."
(c-beginning-of-statement-1 (c-safe-position (point) paren-state))
(c-add-syntax 'template-args-cont (c-point 'boi)))
;; CASE 5Q: we are at a statement within a macro.
(macro-start
(c-beginning-of-statement-1 containing-sexp)
(c-add-stmt-syntax 'statement nil t containing-sexp paren-state))
;; CASE 5M: we are at a topmost continuation line
(t
(c-beginning-of-statement-1 (c-safe-position (point) paren-state))
......
......@@ -685,6 +685,16 @@ definition, or nil if the language doesn't have any."
(c-lang-defvar c-opt-cpp-macro-define-start
(c-lang-const c-opt-cpp-macro-define-start))
(c-lang-defconst c-opt-cpp-macro-define-id
;; Regexp matching everything up to the end of the identifier defined
;; by a cpp define.
t (if (c-lang-const c-opt-cpp-macro-define)
(concat (c-lang-const c-opt-cpp-prefix) ; #
(c-lang-const c-opt-cpp-macro-define) ; define
"[ \t]+\\(\\sw\\|_\\)+")))
(c-lang-defvar c-opt-cpp-macro-define-id
(c-lang-const c-opt-cpp-macro-define-id))
(c-lang-defconst c-cpp-expr-directives
"List if cpp directives (without the prefix) that are followed by an
expression."
......@@ -882,7 +892,7 @@ since CC Mode treats every identifier as an expression."
(c-lang-defconst c-overloadable-operators
"List of the operators that are overloadable, in their \"identifier
form\". See also `c-op-identitier-prefix'."
form\". See also `c-op-identifier-prefix'."
t nil
c++ '("new" "delete" ;; Can be followed by "[]" but we ignore that.
"+" "-" "*" "/" "%"
......@@ -905,7 +915,7 @@ form\". See also `c-op-identitier-prefix'."
(c-lang-defvar c-overloadable-operators-regexp
(c-lang-const c-overloadable-operators-regexp))
(c-lang-defconst c-opt-op-identitier-prefix
(c-lang-defconst c-opt-op-identifier-prefix
"Regexp matching the token before the ones in
`c-overloadable-operators' when operators are specified in their
\"identifier form\". This typically matches \"operator\" in C++ where
......@@ -916,8 +926,15 @@ identifier is listed in `c-overloadable-operators'.
This regexp is assumed to not match any non-operator identifier."
t nil
c++ (c-make-keywords-re t '("operator")))
(c-lang-defvar c-opt-op-identitier-prefix
(c-lang-const c-opt-op-identitier-prefix))
(c-lang-defvar c-opt-op-identifier-prefix
(c-lang-const c-opt-op-identifier-prefix))
;; Note: the following alias is an old name which was a mis-spelling. It has
;; been corrected above and throughout cc-engine.el. It will be removed at
;; some release very shortly in the future. ACM, 2006-04-14.
(defalias 'c-opt-op-identitier-prefix 'c-opt-op-identifier-prefix)
(make-obsolete-variable 'c-opt-op-identitier-prefix 'c-opt-op-identifier-prefix
"CC Mode 5.31.4, 2006-04-14")
(c-lang-defconst c-other-op-syntax-tokens
"List of the tokens made up of characters in the punctuation or
......
......@@ -288,8 +288,9 @@ control). See \"cc-mode.el\" for more info."
c-mode-base-map global-map))
;; RMS says don't make these the default.
;; (define-key c-mode-base-map "\e\C-a" 'c-beginning-of-defun)
;; (define-key c-mode-base-map "\e\C-e" 'c-end-of-defun)
;; (April 2006): RMS has now approved these commands as defaults.
(define-key c-mode-base-map "\e\C-a" 'c-beginning-of-defun)
(define-key c-mode-base-map "\e\C-e" 'c-end-of-defun)
(define-key c-mode-base-map "\C-c\C-n" 'c-forward-conditional)
(define-key c-mode-base-map "\C-c\C-p" 'c-backward-conditional)
......@@ -728,8 +729,8 @@ Note that the style variables are always made local to the buffer."
;; We prevent this by temporarily removing `mode' from the Local Variables
;; section.
(if (or c-file-style c-file-offsets)
(c-tentative-buffer-changes
(let ((hack-local-variables-hook nil))
(let ((hack-local-variables-hook nil) (inhibit-read-only t))
(c-tentative-buffer-changes
(c-remove-any-local-eval-or-mode-variables)
(hack-local-variables))
nil))))
......
......@@ -68,7 +68,10 @@
(arglist-intro . c-lineup-arglist-intro-after-paren)
(arglist-close . c-lineup-arglist)
(inline-open . 0)
(brace-list-open . +)))
(brace-list-open . +)
(topmost-intro-cont