This fixes bug #60769. The two classes of "type" are foo and bar in
"foo d(bar () ...)", where the d could be a mistyped C-M-d.
* list/progmodes/cc-engine.el (c-forward-decl-or-cast-1): New local variable
got-arglist. Refactor a sequence of enclosed `if' forms into a `cond' form.
Set got-arglist when needed. In CASE 2, set unsafe-maybe to inhibit foo
being entered into c-found-types. In CASE 19, likewise set unsafe-maybe, to
inhibit bar entering c-found-types.
For this purpose, record the type names declared by typedef in a text
property, c-typedef, on the typedef. On any change to that "typedef" or a
type, remove the old identifier(s) from c-found-types.
This should fix bug #59671.
* lisp/progmodes/cc-defs.el (c-search-forward-non-nil-char-property): New
macro.
* lisp/progmodes/cc-engine.el (c-forward-decl-or-cast-1): Move the scope of
identifier-start from the "inner" let form to the outer one. Amend the
return value such that the middle element of the second element is now the
position of the "typedef", not merely non-nil.
* lisp/progmodes/cc-fonts.el (c-font-lock-declarators): Disregard the LIMIT
parameter when fontifying the declarators of a typedef construct. Also in
this case, set the c-typedef text property on the "typedef" to the list of
declared types. Amend this list when these declared types change.
(c-font-lock-single-decl): Massage the `types' argument given to
c-font-lock-declarators.
(c-font-lock-cut-off-declarators): Amend to work when the starting point of
the fontification is inside a brace block.
* lisp/progmodes/cc-mode.el (c-before-change-de-typedef)
(c-after-change-de-typedef): New functions.
(c-update-new-id): Replace the erroneous c-end-of-current-token with a clause
containing c-forward-token-2.
(c-before-change): Call c-before-change-de-typedef.
(c-after-change): Call c-after-change-de-typedef.
This should fix bug #60765. In the scenario type an identifier in front of
foo (bar, baz), as when started a new statement. This temporarily makes the
function call a declarator, and bar and baz types. Don't enter bar and baz
into c-found-types.
* lisp/progmodes/cc-engine.el (c-forward-decl-or-cast-1) (CASE 6): When a
'maybe type triggers this case, set `unsafe-maybe' to non-nil.
This fixes bug #59051.
* lisp/progmodes/cc-engine.el (c-forward-decl-or-cast-1): In the test for the
last invocation of c-fdoc-shift-type-backward before CASE 1, additionally
test CONTEXT not being an arglist or BACKUP-AT-TYPE being non-nil.
This fixes bug #59427. We now handle correctly the case when a parenthesis
follows the * which is ambiguously a multiplication or indirection operator.
Also, we don't recognise a type thus found as a found type - the evidence is
too weak.
* lisp/progmodes/cc-engine.el (c-forward-decl-or-cast-1): Fix CASE 17.5 as
above.
* lisp/progmodes/cc-engine.el (c-forward-over-token): New LIMIT parameter
* lisp/progmodes/cc-langs.el (c-anchored-hash-define-no-parens): Replace
ill-formed regular expression (which mixed \\sw and character alternative)
with simpler efficient regexp.
* lisp/progmodes/cc-mode.el (c-fl-decl-end): New forward limit LIM+ used in
c-forward-declarator and c-forward-over-token.
This fixes bug #59267. It applies to C Mode only, and refers to constructs
like "register count;" which are implicitly of int type.
* lisp/progmodes/cc-engine.el (c-forward-type): Use the new regexp
c-maybe-typeless-specifier-re in place of c-opt-type-modifier-prefix-key. Add
an extra arm to the main cond form to handle the construct, and another to
handle "extern "C" foo_t my_foo;".
(c-forward-decl-or-cast-1): Adapt to handle the result no-id from
c-forward-type.
* lisp/progmodes/cc-langs.el (c-maybe-typeless-specifier-re): New lang
const/var.
This fixes bug #59233. It occurred in the C source code fragment
open_replies = alloca (nproviders )
, where typing a * before the closing parenthesis caused nproviders to be
prematurely recognized as a type.
* lisp/progmodes/cc-engine.el (c-forward-decl-or-cast-1): CASE 18 - set
unsafe-maybe to t, when needed.
* lisp/progmodes/cc-engine.el (c-forward-decl-or-cast-1): When we've got two
identifiers followed by a colon, additionally check for a number (or
identifier) followed by a semicolon or comma before concluding we have a
bitfield.
This fixes bug #58883.
* lisp/progmodes/cc-engine.el (c-forward-decl-or-cast-1): New variable
unsafe-maybe. Set it in CASE 10 rather than setting c-record-type-identifiers
to nil. Near the end of the function, when unsafe-maybe is set, bind
c-promote-possible-types to 'just-one rather than t around the call to
c-forward-type.
This fixes bug #59038. The infinite loop occurred with a buffer containing
Base-64 encoded text rather than appropriate C Mode text.
* lisp/progmodes/cc-engine.el (c-update-brace-stack): Don't execute
c-beginning-of-current-token unless the previous c-syntactic-re-search-forward
has succeeded at least once.
* lisp/progmodes/cc-engine.el (c-forward-type): Test for the special new
value `just-one' of c-promote-possible-types, and if found, fontify the type,
but don't add it to c-found-types.
(c-forward-decl-or-cast-1): Add the new &optional parameter inside-macro.
Whilst checking for a cast construct, analyze the text following the closing
paren more rigorously.
Check for, and allow, the closing paren of a macro arglist before the putative
cast construct.
* lisp/progmodes/cc-fonts.el (c-font-lock-declarations): In the lambda
function, pass the parameter inside-macro to c-forward-decl-or-cast-1.
* lisp/progmodes/cc-langs.el (c-primary-expr-regexp-details): New
c-lang-defvar which calculates `c-primary-expr-regexp' and three match
numbers for various sub-expressions in the regexp.
(c-primary-expr-regexp): Now extracted from `c-primary-expr-regexp-details'.
(c-per-++---match, c-per-&*+--match, c-per-\(-match): New
c-lang-defconsts/vars extracted from `c-primary-expr-regexp-details'.
The old arbitrary limit led to errors thrown whilst fontifying large areas of
syntactic whitespace containing "#undef", as in src/comp.c.
* lisp/progmodes/cc-engine.el (c-find-decl-spots): Replace the limit argument
to two calls of c-forward-syntactic-ws by the parameter `cfd-limit'.
This fixes bug #58537 and bug #58539.
* lisp/progmodes/cc-engine.el (c-forward-type): Remove trailing whitespace
from an identifier before passing it to c-add-type.
(c-forward-decl-or-cast-1): CASE 3: Do not recognize two consecutive
identifiers as type + variable/function unless certain conditions are met.
CASE 10: Do not recognize the "type" as a found type unless certain condtions
are met. (Near end): Do not recognize the identifier in a cast as a type
unless certain conditions are met.
* lisp/progmodes/cc-fonts.el (c-get-fontification-context): Recognize being
in declaration parens when there is a syntactially wrong "foo ((bar))"
preceding the match position.
* lisp/progmodes/cc-mode.el (c-update-new-id): Set c-new-id-is-type
unconditionally to nil to prevent a second identifier being wrongly marked as
a type.
This fixes bug #58534.
* lisp/progmodes/cc-engine.el (c-forward-type): Only regard "struct" keywords
which create self contained types (e.g. C++'s "typename") as creating found
types.
* lisp/progmodes/cc-langs.el (c-self-contained-typename-kwds
(c-self-contained-typename-key): New language consts and variable.
Give both the "" and _tag font-lock-function-name-face. Also correct the
fontification of an inherited class name when there is an attribute between
the class name being declared and the colon introducing the inheritance.
* lisp/progmodes/cc-engine.el (c-forward-over-colon-type-list): New function.
(c-forward-keyword-clause): Use the above new function instead of a
looking-at.
(c-forward-name, c-forward-declarator): Accept both the "" and the tag as part
of the name.
* lisp/progmodes/cc-fonts.el (c-font-lock-declarators): Fontify the "" (which
already has font-lock-string-face) and the tag with
font-lock-function-name-face.
* lisp/progmodes/cc-langs.el (c-overloadable-operators): Add "" to this list.
(c-sub-colon-type-list-re): New lang-const and lang-var.
Also tidy up several inaccuracies in the code.
* lisp/progmodes/cc-engine.el (c-forward-decl-arglist): Move point for modes
other than C++ Mode.
(c-forward-declarator): Move over a suffix following arglist parens
(e.g. const). Set the ARGLIST element of the return value to non-nil on
encountering an unbalanced open parenthesis. Don't move forward out of
enclosing parens.
* lisp/progmodes/cc-mode.el (c-fl-decl-end): Handle being in a multi-line
string. Move forward over token after declarator.
c-forward-declarator now moves over a complete declarator, including any
arglist expression, but possibly not including certain C++20 constructs.
* lisp/progmodes/cc-engine.el (c-forward-decl-arglist): New function,
extracted from c-do-declarators.
(c-forward-declarator): Extend the result list by one element, denoting
whether the function parsed an argument list. Insert special handling for a
C++ operator<op> construct. If there is a parenthesis expression, and it is
an argument list, move forward over it.
(c-do-declarators): Append an optional parameter, cdd-anon-accepted
instructing the function to handle declarators without identifiers. Extract
c-forward-decl-arglist.
* lisp/progmodes/cc-fonts.el (c-font-lock-declarators): New &optional
parameter accept-anon, as above. Analyze and use the identifier location
returned by c-do-declarators, rather than using c-last-identifier-range.
(c-font-lock-single-decl): Determine accept-anon from the context, passing it
as argument to c-font-lock-declarators.
* lisp/progmodes/cc-langs.el (c-opt-identifier-prefix-key): Make a
c-lang-defvar out of this existing c-lang-defconst.
* lisp/progmodes/cc-mode.el (c-fl-decl-end): Adapt for the new
c-forward-declarator which now moves over arglists. Amend better to handle
certain syntactically invalid constructs in C++.
* lisp/progmodes/cc-align.el (c-lineup-topmost-intro-cont): Amend so as not to
indent lines following a requires line.
* lisp/progmodes/cc-engine.el (c-forward-primary-expression)
(c-forward-c++-requires-clause): New functions.
(c-forward-declarator): Skip forward over any trailing requires clause.
(c-forward-decl-or-cast-1): Skip requires clauses before and after the type.
Amend the second element of the return list to include information on two
consecutive identifiers in <...>.
(c-looking-at-or-maybe-in-bracelist): Don't recognize braces in requires
expressions as brace lists.
(c-guess-basic-syntax): CASE 5D.7: New case to handle the continuation of a
"concept foo = " line.
* lisp/progmodes/cc-fonts.el (c-basic-matchers-before): Add a new clause to
handle the declaration of a concept.
(c-get-fontification-context): Treat the arglist of a requires construct as a
declaration arglist.
* lisp/progmodes/cc-langs.el (c-equals-nontype-decl-kwds/key)
(c-fun-name-substitute-kwds/key, c-pre-concept-<>-kwds/key): New
c-lang-consts/vars.
(c-constant-key): New c-lang-var.
(c-type-decl-suffix-key): Include "requires" in the keywords matched.
* lisp/progmodes/cc-mode.el (c-fl-decl-start): Fix an off by one error. Use
equal rather than eq to compare two syntax contexts.
* lisp/progmodes/cc-engine.el (c-before-after-change-check-c++-modules): New
function.
(c-forward-<>-arglist): Add special handling for "import <...>".
* lisp/progmodes/cc-fonts.el (c-preprocessor-face-name): Add extra "fallback"
face after font-lock-reference-face, namely font-lock-constant-face.
(c-cpp-matchers): Don't fontify the <> delimiters for XEmacs in #include <..>.
(c-basic-matchers-before): Add c-font-lock-c++-modules to the C++ value.
(c-forward-c++-module-name, c-forward-c++-module-partition-name)
(c-font-lock-c++-modules): New functions.
* lisp/progmodes/cc-langs.el (c-get-state-before-change-functions)
(c-before-font-lock-functions): Include
c-before-after-change-check-c++-modules in the C++ value of these variables.
(c-module-name-re): New c-lang-const/var.
(c-other-decl-kwds): Add a C++ value "export".
(c-<>-sexp-kwds): Add a new component c-import-<>-kwds.
(c-import-<>-kwds, c-module-kwds): New c-lang-consts.
(c-module-key): New c-lang-const/var.
This fixes bug #57318.
Also apply an optimization which marks generic expressions as already
analyzed, thus avoiding repeating this analysis when not needed. This
optimization prevents the fix slowing down scrolling when the C++ source has
lots of template structures.
* lisp/progmodes/cc-engine.el (top-level) Near the beginning of the file, add
a comment describing the new text property c-<>-c-types-set.
(c-update-brace-stack): Bind c-restricted-<>-arglists to nil rather than t
around the call to c-forward-<>-arglist.
(c-forward-<>-arglist-recur): Allow the abbreviated analysis of a generic
expression also when the opening < is marked with a c-<>-c-types-set text
property. Set this property at the same time as the c-type properties are set
on the commas inside the template structure.
* lisp/progmodes/cc-fonts.el (c-font-lock-complex-decl-prepare): Clear the
c-<>-c-types-set text property, along with c-type, from the region being
fontified.
This fixes a regression introduced in the fix for bug #56841 on 2022-08-24.
* lisp/progmodes/cc-engine (c-forward-declarator): Allow point to be at EOB
after the call to c-forward-name, rather than rejecting it as an invalid
declarator. Also reindent a section of this function.
This fixes bug #49787.
* lisp/progmodes/cc-engine.el (c-forward-decl-or-cast-1): (In `if' form just
before CASE 8) Remove the (not ...) around the (looking-at
c-after-suffixed-type-maybe-decl-key).
* lisp/progmodes/cc-fonts.el (c-font-lock-complex-decl-prepare): Add
`c-not-decl' to the values of c-type which are erased at the start of a
fontification.
This fixes bug #56841.
* lisp/progmodes/cc-engine.el (c-forward-declarator): Fix an off-by-one
comparing the position after a c-forward-name with a limit.
* lisp/progmodes/cc-mode.el (c-fl-decl-end): Handle correctly point starting
inside a literal. Insert a missing c-backward-syntactic-ws in the handling of
C++ attributes. Correctly handle an unmatched (. Better handle point
starting inside a [ or (. Tidy up the handling of syntactic whitespace at the
end of the buffer.
This is needed to handle the idiosyncratic meaning of backslash in comments in
the C and C++ standards.
* lisp/progmodes/cc-engine.el: Correct a spelling error.
* lisp/progmodes/cc-mode.el (c-before-change-fix-comment-escapes)
(c-after-change-fix-comment-escapes): New functions.
* lisp/progmodes/cc-langs.el (c-get-state-before-change-functions): Add
c-before-change-fix-comment-escapes to the C/Objc and C++ values.
(c-before-font-lock-functions): Add c-after-change-fix-comment-escapes to the
C/Objc and C++ values.
This fixes bug #55771. Also fix an inaccuracy in c-defun-name-1 with the same
cause.
* lisp/progmodes/cc-cmds.el (c-defun-name-1)
* lisp/progmodes/cc-engine.el (c-forward-noise-clause): Check the return
value of c-forward-token-2 and act upon it when not zero.
* lisp/progmodes/cc-engine.el (c-append-lower-brace-pair-to-state-cache): Do
not record a position in a macro as the starting position in
c-state-brace-pair-desert. Instead record the position at the beginning of
that macro.
* lisp/progmodes/cc-engine.el (c-state-cache-lower-good-pos): When in a
literal, return the start of that literal as a "good pos", not the parameter
POS.
This happens when the enclosing function's return type is a struct, etc. This
fixes bug #54743;
* lisp/progmodes/cc-engine.el (c-update-brace-stack): Replace "(" by ")" in a
`member' call.
This fixes bug #52863.
* lisp/progmodes/cc-engine.el (c-forward-decl-or-cast-1): When a new type is
found, postpone entering it into c-found-types (and thus triggering the
fontification of that type throughout the buffer) until the end of the
function, when we're sure that the "type" found actually is a type.
06545bc0cc CC Mode: c-update-brace-stack: After struct foo *, do not ...
f11779f01b Improve documentation of 'M-X' and related features
# Conflicts:
# etc/NEWS
This fixes bug #52796.
* lisp/progmodes/cc-engine.el (c-update-brace-stack): Handle a "*" like a
semicolon, cancelling the expectation of a brace.
* lisp/progmodes/cc-langs.el (c-brace-stack-thing-key): Add a "*" into the
sets of significant characters.
This fixes bug #52157.
* lisp/progmodes/cc-engine.el (c-forward-decl-or-cast-1): If such a construct
is parsed, set the flag at-type-decl which is part of the function's return
value.
Where c-record-found-types gets "bound" to itself, we postpone the calling of
c-fontify-new-type on possible new found types until these are confirmed by
the return from the function tentatively finding these types, for exmaple
c-forward-<>-arglist. We check this "binding" by testing the value of
c-record-found-types.
Correct the background fontification algorithm.
* lisp/progmodes/cc-engine.el (c-record-found-types): Move the definition to
earlier in the file.
(c-add-type-1): Check additionally c-record-found-types is nil before calling
c-fontify-new-found-type.
(c-forward-<>-arglist, c-forward-type): On return from a function which
collects found types in c-record-found-types, call c-fontify-new-found-types
for each such type.
* lisp/progmodes/c-fonts.el (c-force-redisplay): Actually fontify the new
found type.
(c-fontify-new-found-type): Test for font-lock-mode being enabled. Remove the
spurious condition on the `fontified' text property being nil before causing
c-force-redisplay to get called.
* lisp/progmodes/cc-engine.el (c-laomib-loop): Check for a virtual semicolon
as well as a ;.
(c-guess-basic-syntax): CASE 5D - Use c-crosses-statement-barrier-p to check
whether we've gone back past a virtual semicolon.
