Highlighting template parameters have been one thing that have never worked consistently for me in emacs. I tried installing modern-cpp-font-lock, but I'm still getting the following hightlighting:

The template paramters Features and Model are not hightlighted, but above State is.

Any ideas for how to fix this?

The regexs here seem to work once you apply the correction from the comments, so something like:

(font-lock-add-keywords
 nil 
 '(
       ("\\(\\<[uU8]*R\"[^\\s-\\\\()]\\{0,16\\}(\\)" 1 font-lock-keyword-face t) ; start delimiter
       (   "\\<[uU8]*R\"[^\\s-\\\\()]\\{0,16\\}(\\([[:ascii:][:nonascii:]]*?\\))[^\\s-\\\\()]\\{0,16\\}\"" 1 font-lock-string-face t)  ; actual string
       (   "\\<[uU8]*R\"[^\\s-\\\\()]\\{0,16\\}([[:ascii:][:nonascii:]]*?\\()[^\\s-\\\\()]\\{0,16\\}\"\\)" 1 font-lock-keyword-face t) ; end delimiter
   ))

First off, I should say, this has been a really helpful package. Really nice to have the improved highlighting. Makes editing that much easier!

When there are numerical characters in a function name or variable name, if they follow an underscore, start with zero, and have at least one additional digit then they are highlighted as a literal.

You can see that it doesn't happen without the underscore. Also, if it is just a zero or if there is no zero then it is also okay.

I am opening this issue after seeing the reddit post below. https://www.reddit.com/r/emacs/comments/94j39z/modern_c_font_lock_in_emacs/

Could you make the effort and email the emacs mailing list for your plugin to be included in the Emacs core?

The function declarations below highlight ABC as a function variable instead of a type void foo(std::string&, ABC); void foo(string s, ABC abc) However void foo(string&, ABC); and void foo(std::string, ABC); correctly hightlight ABC as a type.

My modern-cpp-font-lock version is 0.1.3 installed from Melpa, emacs version is 24.5.1 the system is emacs Would you please investigate this problem? Thank you!

Thank you for this package.

Using c++-mode and modern-c++-font-lock-mode the following code

struct b : public a
{
  void foo() override;
  void foo() const override;
};

is font-locked as

as if the second override was not detected as a keyword.

Would that be easy to fix?

It can be reproduced using the following init.el with emacs -Q -l init.el.

(require 'package)
(setq package-archives
      '(("gnu"   . "http://mirrors.tuna.tsinghua.edu.cn/elpa/gnu/")
        ("melpa" . "http://mirrors.tuna.tsinghua.edu.cn/elpa/melpa/")))

(package-initialize)

;; Bootstrap `use-package'
(unless (package-installed-p 'use-package)
  (package-refresh-contents)
  (package-install 'use-package))
(eval-when-compile
  (require 'use-package))

(use-package modern-cpp-font-lock
  :ensure t
  :hook (c++-mode . modern-c++-font-lock-mode))

(provide 'init)

emacs --version

GNU Emacs 28.0.50
Copyright (C) 2020 Free Software Foundation, Inc.
GNU Emacs comes with ABSOLUTELY NO WARRANTY.
You may redistribute copies of GNU Emacs
under the terms of the GNU General Public License.
For more information about these matters, see the file named COPYING.

cc-mode version

;; Version: 5.33.1

After reading the source, it seems like a feature but a bug.

https://github.com/ludwigpacifici/modern-cpp-font-lock/blob/master/modern-cpp-font-lock.el#L186

Example code: void f() { aut s = R"EOF("a)EOF"; } If I set fundamental-mode and enable modern-c++-font-lock-mode then the raw string is highlighted perfectly so the modern fontifying is working. However if I set c++-mode then modern-c++-font-lock-mode then it is highlighted the old C++ way - it looks like the built-in c++ fontification is over-riding the modern rules.

To reduce uncertainty I ran this with emacs --no-init so no other ealpa packages are loaded: (load-library "~/.emacs.d/elpa/modern-cpp-font-lock-0.1.3/modern-cpp-font-lock.el") Using CC Mode version 5.32.99 GNU Emacs 25.3.1 (x86_64-redhat-linux-gnu, GTK+ Version 3.22.26) of 2018-01-12

I can try to debug this but I'd like some hints where to look. I'm familar with elisp programming but not the font-lock stuff specifically.

I'm having some issues with the interger literal when using the single quote. I grabbed the examples from your test file.

Here is what I get with modern cpp mode enabled.

Here is what I get with modern cpp mode disabled.

    std::string empty = R"EOF({                                                                                                                                                                                                                                                   
    "test1": {},                                                                                                                                                                                                                                                                  
    "test2": [],                                                                                                                                                                                                                                                                  
    "test3": [],                                                                                                                                                                                                                                                                  
    "test4": []                                                                                                                                                                                                                                                                   
}                                                                                                                                                                                                                                                                                 
)EOF";

The line above did not appear correctly. Installed version: 20180110.1231

The documentation suggests that raw strings should be properly highlighted, but this does not seem to work. To reproduce this, I started from a completely clean .emacs file and then ran:

(package-initialize)
(add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/"))
(package-refresh-contents)
(package-install 'modern-cpp-font-lock)
(modern-c++-font-lock-global-mode t)

I then opened a new C++ file, verified that modern-c++-string-literal was indeed t, but unfortunately still do not get proper highlighting:

It can be reproduced using the following code:

struct foo {
  bool isPragmaLexer() const {
    return Is_PragmaLexer;
  }

  bool Is_PragmaLexer;
};

     constexpr auto operator""m(unsigned long long l) { return quantity<metre, std::int64_t>(l); }                                                                                                                                                                                                                                                                  

which is trying to define a UDL in this library

https://github.com/mpusz/units

When I give a function an attribute, the function name is no longer fontified. When I write a function: int myfunction() { /*...*/ } it is fontified correctly. But if I add any attribute: [[nodiscard]] int myfunction() { /*...*/ } the function name myfunction is now just the default text color. This happens with multiple

I'm using stock Ubuntu 18.04. I creates a simple setup without any of my init, and I cannot get the color of this small c++ program to work correctly.

#include <string>
std::string a = R"raw(Hi there I'm a Qoute " guy)raw";
int main(){}

Everything after the end double quote on line 2 is colored as if it were inside a string. It does not seem to recognize the double quote before guy as being inside the string.

I'm running emacs like this:

emacs -q --load testinit.el

the contents of my init file (testinit.el) are:

(add-to-list 'load-path "/home/mat/tmp/cppfl/modern-cpp-font-lock")
(require 'modern-cpp-font-lock)
(modern-c++-font-lock-global-mode t)

I've cloned a copy or your repo here, at revision 02f104701b. The test directory, /home/mat/tmp/cppfl, looks like:

a.out
modern-cpp-font-lock/
t.cpp
t.cpp~
testinit.el

I'm on emacs 25.2.2.