emacs-config/config-programming.org

• lsp
• c++
• Projectile
• Slime mode
• rust
• golang
• python
• web stuff
• line-numbers
• Comment keys
• Various common files
• Setup convenient headers

lsp

  (use-package lsp-mode
    :commands lsp
    :config
    (setq lsp-lens-enable nil)
    (setq read-process-output-max (* 1024 1024)))

  (use-package lsp-ui
    :after lsp-mode
    :bind (:map lsp-mode-map
                ("M-." . #'lsp-ui-peek-find-definitions)
                ("M-?" . #'lsp-ui-peek-find-references)
                ("M-p" . #'lsp-ui-peek-jump-forward))
    :hook (lsp-mode . lsp-ui-mode)
    :config
    (setq lsp-ui-flycheck-enable t)
    (setq lsp-ui-flycheck-live-reporting t)
    (setq lsp-ui-doc-show-with-cursor t))

  (use-package dap-mode
    :hook ((java-mode . dap-mode)
           (java-mode . dap-ui-mode))
    :bind (:map dap-mode-map
                ("C-c h" . #'dap-hydra)
                ("C-c b" . #'dap-breakpoint-toggle)
                ("C-c d r" . #'dap-java-debug)
                ("C-c d m" . #'dap-java-debug-test-class)
                ("C-c r t" . #'mvn-test)))

c++

  (use-package lsp-mode
    :hook
    ((c-mode c++-mode objc-mode) .
     (lambda () (let ((project-root (projectile-project-p)))
                  (when (and project-root
                             (file-readable-p (concat project-root "/compile_commands.json")))
                    (lsp)))))
    :config
    (with-eval-after-load 'lsp-clangd
      (add-to-list 'lsp-clients-clangd-args
                   "-j=16"))

    (add-to-list 'lsp-disabled-clients '(c++-mode . ccls))
    (add-to-list 'lsp-disabled-clients '(c-mode . ccls))
    (add-to-list 'lsp-disabled-clients '(objc-mode . ccls)))

  (use-package ccls
    :after lsp-mode
    :hook
    ((c-mode c++-mode objc-mode) .
     (lambda () (let ((project-root (projectile-project-p)))
                  (when (and project-root
                             (file-readable-p (concat project-root "/compile_commands.json")))
                    (lsp)))))
    :config
    (setq ccls-sem-highlight-method 'font-lock-mode)
    (setq ccls-initialization-options
          '(:index (:trackDependency 1 :threads 32)))

    (with-eval-after-load 'doom-modeline
      (advice-add #'lsp--progress-status
                  :filter-return
                  #'(lambda (result)
                      (when result
                        (concat (string-replace "%%" "%%%%" result) " ")))))

    (when my-ec/at-ti
      (add-to-list 'exec-path
                   "/db/sds/packagse2/ccls-master")
      (setq ccls-executable "/db/sds/packages2/ccls-master/ccls")))

Projectile

  (use-package projectile
    :init   (progn
              (setq projectile-enable-caching t)
              (setq projectile-git-submodule-command nil)
              (setq projectile-completion-system 'ivy)

              ;; (setq counsel-projectile-switch-project-action 'projectile-vc)
              (setq projectile-switch-project-action 'projectile-dired)
              (setq projectile-require-project-root t)
              (setq projectile-indexing-method 'hybrid)
              (setq projectile-auto-update-cache nil)
              (exwm-global-set-key (kbd (if (and (not (daemonp))
                                                 (null window-system))
                                            "C-c ."
                                          "C-c C-."))
                                   'projectile-command-map))
    :config
    (projectile-mode)
    (add-to-list 'projectile-globally-ignored-directories
                 ".ccls")

    (when (null window-system)
      (define-key c++-mode-map (kbd "C-c .") nil)
      (define-key c++-mode-map (kbd "C-c . .") #'c-set-style)
      (define-key org-mode-map (kbd "C-c .") nil)
      (define-key org-mode-map (kbd "C-c . .") #'org-time-stamp))

    ;; Provide my own projectile-compile-project which uses
    ;; cca/projectile-compilation-dir instead of projectile-compilation-dir.
    (defvar cca/projectile-compilation-hash (make-hash-table :test 'equal)
      "Has of project roots to compilation directories")

    (defun cca/projectile-get-compilation-dir (key_dir)
      "Get the compilation directory associated with the specified root directory"
      (gethash key_dir cca/projectile-compilation-hash))

    (defun cca/projectile-set-compilation-dir (key_dir value)
      "Set the compilation directory for the specified root directory"
      (puthash key_dir value cca/projectile-compilation-hash))

    (defun cca/projectile-compilation-dir()
      "Prompts the user for a directory relative to the project root
  and returns the absolute path. It also stores the relative path
  from the current project root into projectile-compilation-dir."
      (let* ((root (projectile-project-root))
             (base-compilation-dir (or (cca/projectile-get-compilation-dir root) root))
             (full-compilation-dir (expand-file-name
                                    (read-directory-name "Build directory: " base-compilation-dir))))
        (setq projectile-project-compilation-dir (file-relative-name full-compilation-dir root))
        (cca/projectile-set-compilation-dir root full-compilation-dir)))

    (defun projectile-compile-project (arg)
      "Run project compilation command.

  Normally you'll be prompted for a compilation command, unless
  variable `compilation-read-command'.  You can force the prompt
  with a prefix ARG."
      (interactive "P")
      (let ((command (projectile-compilation-command (cca/projectile-compilation-dir))))
        (projectile--run-project-cmd command projectile-compilation-cmd-map
                                     :show-prompt arg
                                     :prompt-prefix "Compile command: "
                                     :save-buffers t))))

Slime mode

  (use-package slime
    :commands slime slime-switch-lisps
    :hook ((inferior-lisp-mode . inferior-slime-mode))
    :config
    (setq inferior-lisp-program "/usr/bin/sbcl")

    (defun slime-switch-lisps (lisp)
      (interactive (list (completing-read "Which lisp? "
                                          '("sbcl" "ecl" "cmucl" "clozure-cl"))))
      (setq inferior-lisp-program lisp))

    (let ((clhs-file "~/quicklisp/clhs-use-local.el"))
      (if (file-exists-p clhs-file)
          (load-file clhs-file)
        (warn "clhs not installed. Please install"))))

  (use-package slime-company
    :after slime company
    :config
    (slime-setup '(slime-fancy slime-asdf slime-company)))

rust

  (use-package cargo)
  (use-package rust-mode)
  (use-package rustic)

golang

  (use-package go-mode
    :hook (go-mode . (lambda ()
                       (add-hook 'before-save-hook 'gofmt-before-save nil t)
                       (setq indent-tabs-mode nil)))
    :config
    ;; This is for lsp to work
    (add-to-list 'exec-path "~/go/bin/"))

python

  (use-package elpy)
  (elpy-enable)
  (use-package ein)
  (add-to-list 'exec-path
               "/home/benson/anaconda3/bin/" t)

web stuff

  (use-package web-mode
    :commands web-mode
    :init
    (add-to-list 'auto-mode-alist '("\\.phtml\\'" . web-mode))
    (add-to-list 'auto-mode-alist '("\\.tpl\\.php\\'" . web-mode))
    (add-to-list 'auto-mode-alist '("\\.[agj]sp\\'" . web-mode))
    (add-to-list 'auto-mode-alist '("\\.as[cp]x\\'" . web-mode))
    (add-to-list 'auto-mode-alist '("\\.erb\\'" . web-mode))
    (add-to-list 'auto-mode-alist '("\\.mustache\\'" . web-mode))
    (add-to-list 'auto-mode-alist '("\\.djhtml\\'" . web-mode))
    (add-to-list 'auto-mode-alist '("\\.cshtml\\'" . web-mode))
    (add-to-list 'auto-mode-alist '("\\.html?\\'" . web-mode))
    :config
    (setq web-mode-auto-close-style 2))

  (use-package js2-mode
    :commands js2-mode
    :init
    (add-to-list 'auto-mode-alist '("\\.js$" . js2-mode)))

line-numbers

  (defun toggle-line-numbers ()
    (interactive)
    (if (not display-line-numbers-mode)
        (display-line-numbers-mode 1)
      (display-line-numbers-mode -1)
      (setq display-line-numbers-type
            (if (eq display-line-numbers-type t)
                'relative
              t))
      (display-line-numbers-mode 1)))

Comment keys

  (define-prefix-command '*comment-map*)

  (define-key *comment-map* (kbd "/") #'comment-region)
  (define-key *comment-map* (kbd "\\") #'uncomment-region)

  (define-key *root-map* (kbd "/") '*comment-map*)

Various common files

  (use-package csv-mode
    :commands csv-mode
    :init
    (add-to-list 'auto-mode-alist
                 '("\\.csv$" . csv-mode)))

  (use-package yaml-mode
    :commands yaml-mode
    :init
    (add-to-list 'auto-mode-alist
                 '("\\.yaml$" . yaml-mode)
                 '("\\.yml$" . yaml-mode)))

Setup convenient headers

  (setq auto-insert-alist
        '(((emacs-lisp-mode . "Emacs lisp mode") nil
           ";;; " (file-name-nondirectory buffer-file-name) " --- " _ " -*- lexical-binding: t -*-\n\n"

           ";; Copyright (C) " (format-time-string "%Y") " Benson Chu\n\n"

           ";; Author: Benson Chu <bensonchu457@gmail.com>\n"
           ";; Created: " (format-time-string "[%Y-%m-%d %H:%M]") "\n\n"

           ";; This file is not part of GNU Emacs\n\n"

           ";; This program is free software: you can redistribute it and/or modify\n"
           ";; it under the terms of the GNU General Public License as published by\n"
           ";; the Free Software Foundation, either version 3 of the License, or\n"
           ";; (at your option) any later version.\n\n"

           ";; This program is distributed in the hope that it will be useful,\n"
           ";; but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
           ";; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
           ";; GNU General Public License for more details.\n\n"

           ";; You should have received a copy of the GNU General Public License\n"
           ";; along with this program.  If not, see <https://www.gnu.org/licenses/>.\n\n"

           ";;; Commentary:\n\n"

           ";;; Code:\n\n"

           "(provide '" (file-name-sans-extension (file-name-nondirectory buffer-file-name)) ")\n"
           ";;; " (file-name-nondirectory buffer-file-name) " ends here\n")
          ((lisp-mode . "Common Lisp") nil
           "(defpackage :" (file-name-sans-extension (file-name-nondirectory buffer-file-name)) "\n"
           "  (:use :cl :alexandria)\n"
           "  (:export))\n\n"

           "(in-package :" (file-name-sans-extension (file-name-nondirectory buffer-file-name)) ")")))

  (auto-insert-mode)