C and C++

(c-add-style "llvm"
             '("stroustrup"
               (c-basic-offset . 2)
               (c-offsets-alist . ((arglist-intro . ++)
                                   (member-init-intro . ++)
                                   (statement-cont . (c-lineup-assignments ++))
                                   (innamespace . 0)
                                   (inextern-lang . 0)))
               (fill-column . 80)
               (indent-tabs-mode . nil)))
(setq c-default-style "llvm")

(defvar do.cpp/clang-format-executable "clang-format"
      "Path to the clang-format executable")

(use-package clang-format
  :ensure t
  :init
  (setq-default clang-format-style "{BasedOnStyle: llvm}")
  (defun do.cpp.clang-format/enable ()
    (make-variable-buffer-local 'before-save-hook)
    (add-hook 'before-save-hook 'clang-format-buffer))
  (add-hook 'c++-mode-hook 'do.cpp.clang-format/enable)
  (add-hook 'c-mode-hook 'do.cpp.clang-format/enable)
  (defun do.cpp.clang-format/disable ()
    (interactive)
    (remove-hook 'before-save-hook 'clang-format-buffer))
  (defalias 'disable-clang-format 'do.cpp.clang-format/disable)
  :config
  (setq clang-format-executable do.cpp/clang-format-executable))

(use-package gdb-mi
  :demand
  :bind
  <<do.cpp.gdb/keys>>
  :init
  <<do.cpp.gdb/settings>>
  <<do.cpp.gdb/alt-layout>>
  <<do.cpp.gdb/disassembly-layout>>
  <<do.cpp.gdb/switch-layout>>)

(defun do.cpp/c-hooks ()
  (setq comment-start "//"
        comment-end   ""))
(add-hook 'c-mode-hook #'do.cpp/c-hooks)

(use-package preproc-font-lock
  :ensure t
  :init
  (preproc-font-lock-global-mode 1)
  :config
  (make-face 'do.cpp/preproc-macro-face)
  (cond
   ((eq do.theme/enabled-theme 'dark)
    (set-face-attribute 'do.cpp/preproc-macro-face nil
                        :background (face-attribute 'default :background)
                        :foreground (face-attribute 'font-lock-constant-face :foreground)
                        :underline nil
                        :slant (if (display-graphic-p) 'italic 'normal)
                        :weight 'bold))
   ((eq do.theme/enabled-theme 'light)
    (set-face-attribute 'do.cpp/preproc-macro-face nil
                        :background (face-attribute 'default :background)
                        :foreground (face-attribute 'font-lock-constant-face :foreground)
                        :underline nil
                        :slant (if (display-graphic-p) 'italic 'normal)
                        :weight 'bold)))
  (setq preproc-font-lock-preprocessor-background-face 'do.cpp/preproc-macro-face))

(use-package modern-cpp-font-lock
  :ensure t
  :diminish modern-c++-font-lock-mode
  :init
  (modern-c++-font-lock-global-mode t))

(use-package cmake-font-lock
  :ensure t
  :commands cmake-font-lock-activate)

(use-package cmake-mode
  :ensure t
  :mode ("CMakeLists\\.txt\\'" "\\.cmake\\'")
  :init
  (add-hook 'cmake-mode-hook 'cmake-font-lock-activate))

(use-package lsp-clangd
  :after lsp-mode
  :demand t)

(defvar do.cpp.lsp/clangd-executable nil
  "path to the clangd executable")

(defun do.cpp.lsp/start-lsp ()
  "Start LSP in C++ and C mode. Have to hack this a little bit."
  (when (or (equal major-mode 'c++-mode) (equal major-mode 'c-mode))
    ;; only start LSP when clangd is installed. otherwise LSP will ask to
    ;; download clangd and we do not want that!
    (if (not do.cpp.lsp/clangd-executable)
        ;; only start LSP when the executable is set
        (display-warning :warning "`do.cpp.lsp/clangd-executable' is not set. not starting LSP.")
      ;; it is not clear to me why I have to do this here. this seems
      ;; to be the only place that this works. we make a few copies
      ;; of clangd so we can run multiple instances of it. to force
      ;; a particular project to use e.g. clangd-3, we do the
      ;; equivalent of the following in .dir-locals.el:
      ;;
      ;; (setq lsp-enabled-clients '(clangd-3))
      (unless (gethash 'clangd-1 lsp-clients)
        (dolist (id '(clangd-1 clangd-2 clangd-3 clangd-4 clangd-5 clangd-6))
          (let ((c (copy-lsp--client (gethash 'clangd lsp-clients))))
            (setf (lsp--client-server-id c) id)
            (setf (lsp--client-priority c) -5)
            (lsp-register-client c))))
      ;; point clangd to the compile commands file and the query driver
      (setq lsp-clients-clangd-executable do.cpp.lsp/clangd-executable)
      (setq lsp-clients-clangd-args `(;; compile-commands.json needs to be in `do-cpp-build-dir'.
                                      ,@(if (boundp 'do-cpp-build-dir)
                                            (list "--compile-commands-dir" do-cpp-build-dir)
                                          (message (concat "`do-cpp-build-dir' not defined." " "
                                                           "calling clangd without --compile-commands-dir argument."))
                                          nil)
                                      ;; query-driver is especially important when the compiler
                                      ;; is NOT from the same distribution as the clangd executable
                                      ,@(when (boundp 'do-cpp-clangd-query-driver)
                                          (list "--query-driver" do-cpp-clangd-query-driver))
                                      ;; we allow to use more or less threads, default is 4.
                                      ,@(if (boundp 'do-cpp-clangd-threads)
                                            (list (format "-j=%d" do-cpp-clangd-threads))
                                          '("-j=4"))
                                      "-background-index"))
      ;; start lsp-mode
      (lsp))))

(defun do.cpp/add-compile-bindings ()
  (local-set-key (kbd "C-c c") #'do.cpp/try-compile)
  (local-set-key (kbd "C-c t") #'do.cpp/try-test))

;; call this sometime directly from init.el
(defun do.cpp.lsp/setup ()
  ;; we need to hook in after the local variables are set. This affects every
  ;; buffer open, but should be ok
  (add-hook 'hack-local-variables-hook #'do.cpp.lsp/start-lsp)
  ;; bind the compile commands to the major mode
  (add-hook 'c++-mode-hook #'do.cpp/add-compile-bindings)
  (add-hook 'c-mode-hook #'do.cpp/add-compile-bindings))

(do.cpp.lsp/setup)

;; try-compile
(defun do.cpp/is-cmake-build-dir (dir)
  (file-exists-p (expand-file-name "CMakeCache.txt" dir)))

(defun do.cpp/is-makefile-build-dir (dir)
  (or (file-exists-p (expand-file-name "Makefile" dir))
(file-exists-p (expand-file-name "makefile" dir))
(file-exists-p (expand-file-name "GNUmakefile" dir))))

(defun do.cpp/is-ninja-build-dir (dir)
  (file-exists-p (expand-file-name "build.ninja" dir)))

(defun do.cpp/get-cmake-compile-command (dir)
  (cond ((do.cpp/is-ninja-build-dir dir) (concat (executable-find "ninja") " -C " (shell-quote-argument dir)))
  ((do.cpp/is-makefile-build-dir dir)
   (let* ((nprocbin (executable-find "nproc"))
    (nprocs (if nprocbin (replace-regexp-in-string "\n$" "" (shell-command-to-string nprocbin)) "1")))
     (concat (executable-find "make") " -j " nprocs " -C " (shell-quote-argument dir))))
  (t nil)))

;; get-build-dir
(defun do.cpp/get-build-dir ()
  "Get the location of the build directory."
  (expand-file-name
   (if (boundp 'do-cpp-build-dir) do-cpp-build-dir
     ;; TODO: find a way to silently save this dir-local variable.
     ;; check the code of "add-dir-local-variable"
     (read-directory-name "Couldn't find build directory. Select: "))))

(defun do.cpp/try-compile-command (command)
  (let ((build-dir (do.cpp/get-build-dir))
        (compilation-read-command nil)
        (compilation-scroll-output t)
        (cmd (or command "")))
    (cond
     ;; custom compile command
     ((bound-and-true-p do-cpp-build-cmd) (compile do-cpp-build-cmd))
     ;; CMake build
     ((do.cpp/is-cmake-build-dir build-dir)
      (let ((compile-cmd (do.cpp/get-cmake-compile-command build-dir)))
        (compile (concat compile-cmd " " cmd))))
     ;; Makefile build
     ((do.cpp/is-makefile-build-dir build-dir)
      (let* ((nprocbin (executable-find "nproc"))
             (nprocs (if nprocbin (replace-regexp-in-string "\n$" "" (shell-command-to-string nprocbin)) "1")))
        (compile (concat (executable-find "make") " -j " nprocs " -C " (shell-quote-argument build-dir) " " cmd))))
     ;; we give up
     (t (error "Could not find compile command")))))

(defun do.cpp/try-compile () (interactive) (do.cpp/try-compile-command nil))
(defun do.cpp/try-test () () (interactive) (do.cpp/try-compile-command "test"))