|
|
|
|
|
;;; clojure-mode.el --- Major mode for Clojure code -*- lexical-binding: t; -*-
|
|
|
|
|
|
|
|
|
|
|
|
;; Copyright © 2007-2015 Jeffrey Chu, Lennart Staflin, Phil Hagelberg
|
|
|
|
|
|
;; Copyright © 2013-2015 Bozhidar Batsov
|
|
|
|
|
|
;;
|
|
|
|
|
|
;; Authors: Jeffrey Chu <jochu0@gmail.com>
|
|
|
|
|
|
;; Lennart Staflin <lenst@lysator.liu.se>
|
|
|
|
|
|
;; Phil Hagelberg <technomancy@gmail.com>
|
|
|
|
|
|
;; Bozhidar Batsov <bozhidar@batsov.com>
|
|
|
|
|
|
;; URL: http://github.com/clojure-emacs/clojure-mode
|
|
|
|
|
|
;; Package-Version: 20151022.27
|
|
|
|
|
|
;; Keywords: languages clojure clojurescript lisp
|
|
|
|
|
|
;; Version: 5.0.0-cvs
|
|
|
|
|
|
;; Package-Requires: ((emacs "24.3"))
|
|
|
|
|
|
|
|
|
|
|
|
;; This file is not part of GNU Emacs.
|
|
|
|
|
|
|
|
|
|
|
|
;;; Commentary:
|
|
|
|
|
|
|
|
|
|
|
|
;; Provides font-lock, indentation, and navigation for the Clojure
|
|
|
|
|
|
;; programming language (http://clojure.org).
|
|
|
|
|
|
|
|
|
|
|
|
;; Using clojure-mode with paredit or smartparens is highly recommended.
|
|
|
|
|
|
|
|
|
|
|
|
;; Here are some example configurations:
|
|
|
|
|
|
|
|
|
|
|
|
;; ;; require or autoload paredit-mode
|
|
|
|
|
|
;; (add-hook 'clojure-mode-hook #'paredit-mode)
|
|
|
|
|
|
|
|
|
|
|
|
;; ;; require or autoload smartparens
|
|
|
|
|
|
;; (add-hook 'clojure-mode-hook #'smartparens-strict-mode)
|
|
|
|
|
|
|
|
|
|
|
|
;; See inf-clojure (http://github.com/clojure-emacs/inf-clojure) for
|
|
|
|
|
|
;; basic interaction with Clojure subprocesses.
|
|
|
|
|
|
|
|
|
|
|
|
;; See CIDER (http://github.com/clojure-emacs/cider) for
|
|
|
|
|
|
;; better interaction with subprocesses via nREPL.
|
|
|
|
|
|
|
|
|
|
|
|
;;; License:
|
|
|
|
|
|
|
|
|
|
|
|
;; This program is free software; you can redistribute it and/or
|
|
|
|
|
|
;; modify it under the terms of the GNU General Public License
|
|
|
|
|
|
;; as published by the Free Software Foundation; either version 3
|
|
|
|
|
|
;; of the License, or (at your option) any later version.
|
|
|
|
|
|
;;
|
|
|
|
|
|
;; This program is distributed in the hope that it will be useful,
|
|
|
|
|
|
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
|
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
|
;; GNU General Public License for more details.
|
|
|
|
|
|
;;
|
|
|
|
|
|
;; You should have received a copy of the GNU General Public License
|
|
|
|
|
|
;; along with GNU Emacs; see the file COPYING. If not, write to the
|
|
|
|
|
|
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
|
|
|
|
;; Boston, MA 02110-1301, USA.
|
|
|
|
|
|
|
|
|
|
|
|
;;; Code:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(eval-when-compile
|
|
|
|
|
|
(defvar calculate-lisp-indent-last-sexp)
|
|
|
|
|
|
(defvar font-lock-beg)
|
|
|
|
|
|
(defvar font-lock-end)
|
|
|
|
|
|
(defvar paredit-space-for-delimiter-predicates)
|
|
|
|
|
|
(defvar paredit-version)
|
|
|
|
|
|
(defvar paredit-mode))
|
|
|
|
|
|
|
|
|
|
|
|
(require 'cl-lib)
|
|
|
|
|
|
(require 'imenu)
|
|
|
|
|
|
(require 'newcomment)
|
|
|
|
|
|
|
|
|
|
|
|
(declare-function lisp-fill-paragraph "lisp-mode" (&optional justify))
|
|
|
|
|
|
|
|
|
|
|
|
(defgroup clojure nil
|
|
|
|
|
|
"Major mode for editing Clojure code."
|
|
|
|
|
|
:prefix "clojure-"
|
|
|
|
|
|
:group 'languages
|
|
|
|
|
|
:link '(url-link :tag "Github" "https://github.com/clojure-emacs/clojure-mode")
|
|
|
|
|
|
:link '(emacs-commentary-link :tag "Commentary" "clojure-mode"))
|
|
|
|
|
|
|
|
|
|
|
|
(defconst clojure-mode-version "5.0.0-snapshot"
|
|
|
|
|
|
"The current version of `clojure-mode'.")
|
|
|
|
|
|
|
|
|
|
|
|
(defface clojure-keyword-face
|
|
|
|
|
|
'((t (:inherit font-lock-constant-face)))
|
|
|
|
|
|
"Face used to font-lock Clojure keywords (:something)."
|
|
|
|
|
|
:group 'clojure
|
|
|
|
|
|
:package-version '(clojure-mode . "3.0.0"))
|
|
|
|
|
|
|
|
|
|
|
|
(defface clojure-character-face
|
|
|
|
|
|
'((t (:inherit font-lock-string-face)))
|
|
|
|
|
|
"Face used to font-lock Clojure character literals."
|
|
|
|
|
|
:group 'clojure
|
|
|
|
|
|
:package-version '(clojure-mode . "3.0.0"))
|
|
|
|
|
|
|
|
|
|
|
|
(defface clojure-interop-method-face
|
|
|
|
|
|
'((t (:inherit font-lock-preprocessor-face)))
|
|
|
|
|
|
"Face used to font-lock interop method names (camelCase)."
|
|
|
|
|
|
:group 'clojure
|
|
|
|
|
|
:package-version '(clojure-mode . "3.0.0"))
|
|
|
|
|
|
|
|
|
|
|
|
(defcustom clojure-defun-style-default-indent nil
|
|
|
|
|
|
"When non-nil, use default indenting for functions and macros.
|
|
|
|
|
|
Otherwise check `define-clojure-indent' and `put-clojure-indent'."
|
|
|
|
|
|
:type 'boolean
|
|
|
|
|
|
:group 'clojure
|
|
|
|
|
|
:safe 'booleanp)
|
|
|
|
|
|
|
|
|
|
|
|
(defcustom clojure-use-backtracking-indent t
|
|
|
|
|
|
"When non-nil, enable context sensitive indentation."
|
|
|
|
|
|
:type 'boolean
|
|
|
|
|
|
:group 'clojure
|
|
|
|
|
|
:safe 'booleanp)
|
|
|
|
|
|
|
|
|
|
|
|
(defcustom clojure-max-backtracking 3
|
|
|
|
|
|
"Maximum amount to backtrack up a list to check for context."
|
|
|
|
|
|
:type 'integer
|
|
|
|
|
|
:group 'clojure
|
|
|
|
|
|
:safe 'integerp)
|
|
|
|
|
|
|
|
|
|
|
|
(defcustom clojure-docstring-fill-column fill-column
|
|
|
|
|
|
"Value of `fill-column' to use when filling a docstring."
|
|
|
|
|
|
:type 'integer
|
|
|
|
|
|
:group 'clojure
|
|
|
|
|
|
:safe 'integerp)
|
|
|
|
|
|
|
|
|
|
|
|
(defcustom clojure-docstring-fill-prefix-width 2
|
|
|
|
|
|
"Width of `fill-prefix' when filling a docstring.
|
|
|
|
|
|
The default value conforms with the de facto convention for
|
|
|
|
|
|
Clojure docstrings, aligning the second line with the opening
|
|
|
|
|
|
double quotes on the third column."
|
|
|
|
|
|
:type 'integer
|
|
|
|
|
|
:group 'clojure
|
|
|
|
|
|
:safe 'integerp)
|
|
|
|
|
|
|
|
|
|
|
|
(defcustom clojure-omit-space-between-tag-and-delimiters '(?\[ ?\{)
|
|
|
|
|
|
"Allowed opening delimiter characters after a reader literal tag.
|
|
|
|
|
|
For example, \[ is allowed in :db/id[:db.part/user]."
|
|
|
|
|
|
:type '(set (const :tag "[" ?\[)
|
|
|
|
|
|
(const :tag "{" ?\{)
|
|
|
|
|
|
(const :tag "(" ?\()
|
|
|
|
|
|
(const :tag "\"" ?\"))
|
|
|
|
|
|
:group 'clojure
|
|
|
|
|
|
:safe (lambda (value)
|
|
|
|
|
|
(and (listp value)
|
|
|
|
|
|
(cl-every 'characterp value))))
|
|
|
|
|
|
|
|
|
|
|
|
(defvar clojure-mode-map
|
|
|
|
|
|
(let ((map (make-sparse-keymap)))
|
|
|
|
|
|
(define-key map (kbd "C-:") #'clojure-toggle-keyword-string)
|
|
|
|
|
|
(easy-menu-define clojure-mode-menu map "Clojure Mode Menu"
|
|
|
|
|
|
'("Clojure"
|
|
|
|
|
|
["Toggle between string & keyword" clojure-toggle-keyword-string]
|
|
|
|
|
|
"--"
|
|
|
|
|
|
["Insert ns form at point" clojure-insert-ns-form-at-point]
|
|
|
|
|
|
["Insert ns form at beginning" clojure-insert-ns-form]
|
|
|
|
|
|
["Update ns form" clojure-update-ns]
|
|
|
|
|
|
"--"
|
|
|
|
|
|
["Version" clojure-mode-display-version]))
|
|
|
|
|
|
map)
|
|
|
|
|
|
"Keymap for Clojure mode.")
|
|
|
|
|
|
|
|
|
|
|
|
(defvar clojure-mode-syntax-table
|
|
|
|
|
|
(let ((table (copy-syntax-table emacs-lisp-mode-syntax-table)))
|
|
|
|
|
|
(modify-syntax-entry ?~ "' " table)
|
|
|
|
|
|
(modify-syntax-entry ?\{ "(}" table)
|
|
|
|
|
|
(modify-syntax-entry ?\} "){" table)
|
|
|
|
|
|
(modify-syntax-entry ?\[ "(]" table)
|
|
|
|
|
|
(modify-syntax-entry ?\] ")[" table)
|
|
|
|
|
|
(modify-syntax-entry ?^ "'" table)
|
|
|
|
|
|
(modify-syntax-entry ?@ "'" table)
|
|
|
|
|
|
;; Make hash a usual word character
|
|
|
|
|
|
(modify-syntax-entry ?# "_ p" table)
|
|
|
|
|
|
table)
|
|
|
|
|
|
"Syntax table for Clojure mode.
|
|
|
|
|
|
Inherits from `emacs-lisp-mode-syntax-table'.")
|
|
|
|
|
|
|
|
|
|
|
|
(defconst clojure--prettify-symbols-alist
|
|
|
|
|
|
'(("fn" . ?λ)))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-mode-display-version ()
|
|
|
|
|
|
"Display the current `clojure-mode-version' in the minibuffer."
|
|
|
|
|
|
(interactive)
|
|
|
|
|
|
(message "clojure-mode (version %s)" clojure-mode-version))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-space-for-delimiter-p (endp delim)
|
|
|
|
|
|
"Prevent paredit from inserting useless spaces.
|
|
|
|
|
|
See `paredit-space-for-delimiter-predicates' for the meaning of
|
|
|
|
|
|
ENDP and DELIM."
|
|
|
|
|
|
(if (or (derived-mode-p 'clojure-mode)
|
|
|
|
|
|
(derived-mode-p 'cider-repl-mode))
|
|
|
|
|
|
(save-excursion
|
|
|
|
|
|
(backward-char)
|
|
|
|
|
|
(if (and (or (char-equal delim ?\()
|
|
|
|
|
|
(char-equal delim ?\")
|
|
|
|
|
|
(char-equal delim ?{))
|
|
|
|
|
|
(not endp))
|
|
|
|
|
|
(if (char-equal (char-after) ?#)
|
|
|
|
|
|
(and (not (bobp))
|
|
|
|
|
|
(or (char-equal ?w (char-syntax (char-before)))
|
|
|
|
|
|
(char-equal ?_ (char-syntax (char-before)))))
|
|
|
|
|
|
t)
|
|
|
|
|
|
t))
|
|
|
|
|
|
t))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-no-space-after-tag (endp delimiter)
|
|
|
|
|
|
"Prevent inserting a space after a reader-literal tag?
|
|
|
|
|
|
|
|
|
|
|
|
When a reader-literal tag is followed be an opening delimiter
|
|
|
|
|
|
listed in `clojure-omit-space-between-tag-and-delimiters', this
|
|
|
|
|
|
function returns t.
|
|
|
|
|
|
|
|
|
|
|
|
This allows you to write things like #db/id[:db.part/user]
|
|
|
|
|
|
without inserting a space between the tag and the opening
|
|
|
|
|
|
bracket.
|
|
|
|
|
|
|
|
|
|
|
|
See `paredit-space-for-delimiter-predicates' for the meaning of
|
|
|
|
|
|
ENDP and DELIMITER."
|
|
|
|
|
|
(if endp
|
|
|
|
|
|
t
|
|
|
|
|
|
(or (not (member delimiter clojure-omit-space-between-tag-and-delimiters))
|
|
|
|
|
|
(save-excursion
|
|
|
|
|
|
(let ((orig-point (point)))
|
|
|
|
|
|
(not (and (re-search-backward
|
|
|
|
|
|
"#\\([a-zA-Z0-9._-]+/\\)?[a-zA-Z0-9._-]+"
|
|
|
|
|
|
(line-beginning-position)
|
|
|
|
|
|
t)
|
|
|
|
|
|
(= orig-point (match-end 0)))))))))
|
|
|
|
|
|
|
|
|
|
|
|
(declare-function paredit-open-curly "ext:paredit")
|
|
|
|
|
|
(declare-function paredit-close-curly "ext:paredit")
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-paredit-setup ()
|
|
|
|
|
|
"Make \"paredit-mode\" play nice with `clojure-mode'."
|
|
|
|
|
|
(when (>= paredit-version 21)
|
|
|
|
|
|
(define-key clojure-mode-map "{" #'paredit-open-curly)
|
|
|
|
|
|
(define-key clojure-mode-map "}" #'paredit-close-curly)
|
|
|
|
|
|
(add-to-list 'paredit-space-for-delimiter-predicates
|
|
|
|
|
|
#'clojure-space-for-delimiter-p)
|
|
|
|
|
|
(add-to-list 'paredit-space-for-delimiter-predicates
|
|
|
|
|
|
#'clojure-no-space-after-tag)))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-mode-variables ()
|
|
|
|
|
|
"Set up initial buffer-local variables for Clojure mode."
|
|
|
|
|
|
(setq-local imenu-create-index-function
|
|
|
|
|
|
(lambda ()
|
|
|
|
|
|
(imenu--generic-function '((nil clojure-match-next-def 0)))))
|
|
|
|
|
|
(setq-local indent-tabs-mode nil)
|
|
|
|
|
|
(setq-local paragraph-ignore-fill-prefix t)
|
|
|
|
|
|
(setq-local outline-regexp ";;;\\(;* [^ \t\n]\\)\\|(")
|
|
|
|
|
|
(setq-local outline-level 'lisp-outline-level)
|
|
|
|
|
|
(setq-local comment-start ";")
|
|
|
|
|
|
(setq-local comment-start-skip ";+ *")
|
|
|
|
|
|
(setq-local comment-add 1) ; default to `;;' in comment-region
|
|
|
|
|
|
(setq-local comment-column 40)
|
|
|
|
|
|
(setq-local comment-use-syntax t)
|
|
|
|
|
|
(setq-local multibyte-syntax-as-symbol t)
|
|
|
|
|
|
(setq-local electric-pair-skip-whitespace 'chomp)
|
|
|
|
|
|
(setq-local electric-pair-open-newline-between-pairs nil)
|
|
|
|
|
|
(setq-local fill-paragraph-function #'clojure-fill-paragraph)
|
|
|
|
|
|
(setq-local adaptive-fill-function #'clojure-adaptive-fill-function)
|
|
|
|
|
|
(setq-local normal-auto-fill-function #'clojure-auto-fill-function)
|
|
|
|
|
|
(setq-local comment-start-skip
|
|
|
|
|
|
"\\(\\(^\\|[^\\\\\n]\\)\\(\\\\\\\\\\)*\\)\\(;+\\|#|\\) *")
|
|
|
|
|
|
(setq-local indent-line-function #'clojure-indent-line)
|
|
|
|
|
|
(setq-local lisp-indent-function #'clojure-indent-function)
|
|
|
|
|
|
(setq-local lisp-doc-string-elt-property 'clojure-doc-string-elt)
|
|
|
|
|
|
(setq-local parse-sexp-ignore-comments t)
|
|
|
|
|
|
(setq-local prettify-symbols-alist clojure--prettify-symbols-alist)
|
|
|
|
|
|
(setq-local open-paren-in-column-0-is-defun-start nil))
|
|
|
|
|
|
|
|
|
|
|
|
;;;###autoload
|
|
|
|
|
|
(define-derived-mode clojure-mode prog-mode "Clojure"
|
|
|
|
|
|
"Major mode for editing Clojure code.
|
|
|
|
|
|
|
|
|
|
|
|
\\{clojure-mode-map}"
|
|
|
|
|
|
(clojure-mode-variables)
|
|
|
|
|
|
(clojure-font-lock-setup)
|
|
|
|
|
|
(add-hook 'paredit-mode-hook #'clojure-paredit-setup))
|
|
|
|
|
|
|
|
|
|
|
|
(defsubst clojure-in-docstring-p ()
|
|
|
|
|
|
"Check whether point is in a docstring."
|
|
|
|
|
|
(eq (get-text-property (point) 'face) 'font-lock-doc-face))
|
|
|
|
|
|
|
|
|
|
|
|
(defsubst clojure-docstring-fill-prefix ()
|
|
|
|
|
|
"The prefix string used by `clojure-fill-paragraph'.
|
|
|
|
|
|
|
|
|
|
|
|
It is simply `clojure-docstring-fill-prefix-width' number of spaces."
|
|
|
|
|
|
(make-string clojure-docstring-fill-prefix-width ? ))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-adaptive-fill-function ()
|
|
|
|
|
|
"Clojure adaptive fill function.
|
|
|
|
|
|
This only takes care of filling docstring correctly."
|
|
|
|
|
|
(when (clojure-in-docstring-p)
|
|
|
|
|
|
(clojure-docstring-fill-prefix)))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-fill-paragraph (&optional justify)
|
|
|
|
|
|
"Like `fill-paragraph', but can handle Clojure docstrings.
|
|
|
|
|
|
|
|
|
|
|
|
If JUSTIFY is non-nil, justify as well as fill the paragraph."
|
|
|
|
|
|
(if (clojure-in-docstring-p)
|
|
|
|
|
|
(let ((paragraph-start
|
|
|
|
|
|
(concat paragraph-start
|
|
|
|
|
|
"\\|\\s-*\\([(;:\"[]\\|~@\\|`(\\|#'(\\)"))
|
|
|
|
|
|
(paragraph-separate
|
|
|
|
|
|
(concat paragraph-separate "\\|\\s-*\".*[,\\.]$"))
|
|
|
|
|
|
(fill-column (or clojure-docstring-fill-column fill-column))
|
|
|
|
|
|
(fill-prefix (clojure-docstring-fill-prefix)))
|
|
|
|
|
|
(fill-paragraph justify))
|
|
|
|
|
|
(let ((paragraph-start (concat paragraph-start
|
|
|
|
|
|
"\\|\\s-*\\([(;:\"[]\\|`(\\|#'(\\)"))
|
|
|
|
|
|
(paragraph-separate
|
|
|
|
|
|
(concat paragraph-separate "\\|\\s-*\".*[,\\.[]$")))
|
|
|
|
|
|
(or (fill-comment-paragraph justify)
|
|
|
|
|
|
(fill-paragraph justify))
|
|
|
|
|
|
;; Always return `t'
|
|
|
|
|
|
t)))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-auto-fill-function ()
|
|
|
|
|
|
"Clojure auto-fill function."
|
|
|
|
|
|
;; Check if auto-filling is meaningful.
|
|
|
|
|
|
(let ((fc (current-fill-column)))
|
|
|
|
|
|
(when (and fc (> (current-column) fc))
|
|
|
|
|
|
(let ((fill-column (if (clojure-in-docstring-p)
|
|
|
|
|
|
clojure-docstring-fill-column
|
|
|
|
|
|
fill-column))
|
|
|
|
|
|
(fill-prefix (clojure-adaptive-fill-function)))
|
|
|
|
|
|
(do-auto-fill)))))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-match-next-def ()
|
|
|
|
|
|
"Scans the buffer backwards for the next \"top-level\" definition.
|
|
|
|
|
|
Called by `imenu--generic-function'."
|
|
|
|
|
|
;; we have to take into account namespace-definition forms
|
|
|
|
|
|
;; e.g. s/defn
|
|
|
|
|
|
(when (re-search-backward "^(\\([a-z0-9.-]+/\\)?def\\sw*" nil t)
|
|
|
|
|
|
(save-excursion
|
|
|
|
|
|
(let (found?
|
|
|
|
|
|
(start (point)))
|
|
|
|
|
|
(down-list)
|
|
|
|
|
|
(forward-sexp)
|
|
|
|
|
|
(while (not found?)
|
|
|
|
|
|
(forward-sexp)
|
|
|
|
|
|
(or (if (char-equal ?[ (char-after (point)))
|
|
|
|
|
|
(backward-sexp))
|
|
|
|
|
|
(if (char-equal ?) (char-after (point)))
|
|
|
|
|
|
(backward-sexp)))
|
|
|
|
|
|
(cl-destructuring-bind (def-beg . def-end) (bounds-of-thing-at-point 'sexp)
|
|
|
|
|
|
(if (char-equal ?^ (char-after def-beg))
|
|
|
|
|
|
(progn (forward-sexp) (backward-sexp))
|
|
|
|
|
|
(setq found? t)
|
|
|
|
|
|
(set-match-data (list def-beg def-end)))))
|
|
|
|
|
|
(goto-char start)))))
|
|
|
|
|
|
|
|
|
|
|
|
(defconst clojure-font-lock-keywords
|
|
|
|
|
|
(eval-when-compile
|
|
|
|
|
|
`(;; Top-level variable definition
|
|
|
|
|
|
(,(concat "(\\(?:clojure.core/\\)?\\("
|
|
|
|
|
|
(regexp-opt '("def" "defonce"))
|
|
|
|
|
|
;; variable declarations
|
|
|
|
|
|
"\\)\\>"
|
|
|
|
|
|
;; Any whitespace
|
|
|
|
|
|
"[ \r\n\t]*"
|
|
|
|
|
|
;; Possibly type or metadata
|
|
|
|
|
|
"\\(?:#?^\\(?:{[^}]*}\\|\\sw+\\)[ \r\n\t]*\\)*"
|
|
|
|
|
|
"\\(\\sw+\\)?")
|
|
|
|
|
|
(1 font-lock-keyword-face)
|
|
|
|
|
|
(2 font-lock-variable-name-face nil t))
|
|
|
|
|
|
;; Type definition
|
|
|
|
|
|
(,(concat "(\\(?:clojure.core/\\)?\\("
|
|
|
|
|
|
(regexp-opt '("defstruct" "deftype" "defprotocol"
|
|
|
|
|
|
"defrecord"))
|
|
|
|
|
|
;; type declarations
|
|
|
|
|
|
"\\)\\>"
|
|
|
|
|
|
;; Any whitespace
|
|
|
|
|
|
"[ \r\n\t]*"
|
|
|
|
|
|
;; Possibly type or metadata
|
|
|
|
|
|
"\\(?:#?^\\(?:{[^}]*}\\|\\sw+\\)[ \r\n\t]*\\)*"
|
|
|
|
|
|
"\\(\\sw+\\)?")
|
|
|
|
|
|
(1 font-lock-keyword-face)
|
|
|
|
|
|
(2 font-lock-type-face nil t))
|
|
|
|
|
|
;; Function definition (anything that starts with def and is not
|
|
|
|
|
|
;; listed above)
|
|
|
|
|
|
(,(concat "(\\(?:[a-z\.-]+/\\)?\\(def[^ \r\n\t]*\\)"
|
|
|
|
|
|
;; Function declarations
|
|
|
|
|
|
"\\>"
|
|
|
|
|
|
;; Any whitespace
|
|
|
|
|
|
"[ \r\n\t]*"
|
|
|
|
|
|
;; Possibly type or metadata
|
|
|
|
|
|
"\\(?:#?^\\(?:{[^}]*}\\|\\sw+\\)[ \r\n\t]*\\)*"
|
|
|
|
|
|
"\\(\\sw+\\)?")
|
|
|
|
|
|
(1 font-lock-keyword-face)
|
|
|
|
|
|
(2 font-lock-function-name-face nil t))
|
|
|
|
|
|
;; (fn name? args ...)
|
|
|
|
|
|
(,(concat "(\\(?:clojure.core/\\)?\\(fn\\)[ \t]+"
|
|
|
|
|
|
;; Possibly type
|
|
|
|
|
|
"\\(?:#?^\\sw+[ \t]*\\)?"
|
|
|
|
|
|
;; Possibly name
|
|
|
|
|
|
"\\(t\\sw+\\)?" )
|
|
|
|
|
|
(1 font-lock-keyword-face)
|
|
|
|
|
|
(2 font-lock-function-name-face nil t))
|
|
|
|
|
|
;; lambda arguments - %, %1, %2, etc
|
|
|
|
|
|
("\\<%[1-9]?" (0 font-lock-variable-name-face))
|
|
|
|
|
|
;; Special forms
|
|
|
|
|
|
(,(concat
|
|
|
|
|
|
"("
|
|
|
|
|
|
(regexp-opt
|
|
|
|
|
|
'("def" "do" "if" "let" "var" "fn" "loop"
|
|
|
|
|
|
"recur" "throw" "try" "catch" "finally"
|
|
|
|
|
|
"set!" "new" "."
|
|
|
|
|
|
"monitor-enter" "monitor-exit" "quote") t)
|
|
|
|
|
|
"\\>")
|
|
|
|
|
|
1 font-lock-keyword-face)
|
|
|
|
|
|
;; Built-in binding and flow of control forms
|
|
|
|
|
|
(,(concat
|
|
|
|
|
|
"(\\(?:clojure.core/\\)?"
|
|
|
|
|
|
(regexp-opt
|
|
|
|
|
|
'("letfn" "case" "cond" "cond->" "cond->>" "condp"
|
|
|
|
|
|
"for" "when" "when-not" "when-let" "when-first" "when-some"
|
|
|
|
|
|
"if-let" "if-not" "if-some"
|
|
|
|
|
|
".." "->" "->>" "as->" "doto" "and" "or"
|
|
|
|
|
|
"dosync" "doseq" "dotimes" "dorun" "doall"
|
|
|
|
|
|
"ns" "in-ns"
|
|
|
|
|
|
"with-open" "with-local-vars" "binding"
|
|
|
|
|
|
"with-redefs" "with-redefs-fn"
|
|
|
|
|
|
"declare") t)
|
|
|
|
|
|
"\\>")
|
|
|
|
|
|
1 font-lock-keyword-face)
|
|
|
|
|
|
(,(concat
|
|
|
|
|
|
"\\<"
|
|
|
|
|
|
(regexp-opt
|
|
|
|
|
|
'("*1" "*2" "*3" "*agent*"
|
|
|
|
|
|
"*allow-unresolved-vars*" "*assert*" "*clojure-version*"
|
|
|
|
|
|
"*command-line-args*" "*compile-files*"
|
|
|
|
|
|
"*compile-path*" "*data-readers*" "*default-data-reader-fn*"
|
|
|
|
|
|
"*e" "*err*" "*file*" "*flush-on-newline*"
|
|
|
|
|
|
"*in*" "*macro-meta*" "*math-context*" "*ns*" "*out*"
|
|
|
|
|
|
"*print-dup*" "*print-length*" "*print-level*"
|
|
|
|
|
|
"*print-meta*" "*print-readably*"
|
|
|
|
|
|
"*read-eval*" "*source-path*"
|
|
|
|
|
|
"*unchecked-math*"
|
|
|
|
|
|
"*use-context-classloader*" "*warn-on-reflection*")
|
|
|
|
|
|
t)
|
|
|
|
|
|
"\\>")
|
|
|
|
|
|
0 font-lock-builtin-face)
|
|
|
|
|
|
;; Dynamic variables - *something* or @*something*
|
|
|
|
|
|
("\\(?:\\<\\|/\\)@?\\(\\*[a-z-]*\\*\\)\\>" 1 font-lock-variable-name-face)
|
|
|
|
|
|
;; Global constants - nil, true, false
|
|
|
|
|
|
(,(concat
|
|
|
|
|
|
"\\<"
|
|
|
|
|
|
(regexp-opt
|
|
|
|
|
|
'("true" "false" "nil") t)
|
|
|
|
|
|
"\\>")
|
|
|
|
|
|
0 font-lock-constant-face)
|
|
|
|
|
|
;; Character literals - \1, \a, \newline, \u0000
|
|
|
|
|
|
("\\\\\\([[:punct:]]\\|[a-z0-9]+\\>\\)" 0 'clojure-character-face)
|
|
|
|
|
|
;; foo/ Foo/ @Foo/ /FooBar
|
|
|
|
|
|
("\\(?:\\<:?\\|\\.\\)@?\\([a-zA-Z][.a-zA-Z0-9$_-]*\\)/" 1 font-lock-type-face)
|
|
|
|
|
|
;; Constant values (keywords), including as metadata e.g. ^:static
|
|
|
|
|
|
("\\<^?\\(:\\(\\sw\\|\\s_\\)+\\(\\>\\|\\_>\\)\\)" 1 'clojure-keyword-face append)
|
|
|
|
|
|
;; Java interop highlighting
|
|
|
|
|
|
;; CONST SOME_CONST (optionally prefixed by /)
|
|
|
|
|
|
("\\(?:\\<\\|/\\)\\([A-Z]+\\|\\([A-Z]+_[A-Z1-9_]+\\)\\)\\>" 1 font-lock-constant-face)
|
|
|
|
|
|
;; .foo .barBaz .qux01 .-flibble .-flibbleWobble
|
|
|
|
|
|
("\\<\\.-?[a-z][a-zA-Z0-9]*\\>" 0 'clojure-interop-method-face)
|
|
|
|
|
|
;; Foo Bar$Baz Qux_ World_OpenUDP Foo. Babylon15.
|
|
|
|
|
|
("\\(?:\\<\\|\\.\\|/\\|#?^\\)\\([A-Z][a-zA-Z0-9_]*[a-zA-Z0-9$_]+\\.?\\>\\)" 1 font-lock-type-face)
|
|
|
|
|
|
;; foo.bar.baz
|
|
|
|
|
|
("\\<^?\\([a-z][a-z0-9_-]+\\.\\([a-z][a-z0-9_-]*\\.?\\)+\\)" 1 font-lock-type-face)
|
|
|
|
|
|
;; (ns namespace) - special handling for single segment namespaces
|
|
|
|
|
|
(,(concat "(\\<ns\\>[ \r\n\t]*"
|
|
|
|
|
|
;; Possibly metadata
|
|
|
|
|
|
"\\(?:\\^?{[^}]+}[ \r\n\t]*\\)*"
|
|
|
|
|
|
;; namespace
|
|
|
|
|
|
"\\([a-z0-9-]+\\)")
|
|
|
|
|
|
(1 font-lock-type-face nil t))
|
|
|
|
|
|
;; fooBar
|
|
|
|
|
|
("\\(?:\\<\\|/\\)\\([a-z]+[A-Z]+[a-zA-Z0-9$]*\\>\\)" 1 'clojure-interop-method-face)
|
|
|
|
|
|
;; Highlight `code` marks, just like `elisp'.
|
|
|
|
|
|
(,(rx "`" (group-n 1 (+ (or (syntax symbol) (syntax word)))) "`")
|
|
|
|
|
|
(1 'font-lock-constant-face prepend))
|
|
|
|
|
|
;; Highlight grouping constructs in regular expressions
|
|
|
|
|
|
(clojure-font-lock-regexp-groups
|
|
|
|
|
|
(1 'font-lock-regexp-grouping-construct prepend))))
|
|
|
|
|
|
"Default expressions to highlight in Clojure mode.")
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-font-lock-syntactic-face-function (state)
|
|
|
|
|
|
"Find and highlight text with a Clojure-friendly syntax table.
|
|
|
|
|
|
|
|
|
|
|
|
This function is passed to `font-lock-syntactic-face-function',
|
|
|
|
|
|
which is called with a single parameter, STATE (which is, in
|
|
|
|
|
|
turn, returned by `parse-partial-sexp' at the beginning of the
|
|
|
|
|
|
highlighted region)."
|
|
|
|
|
|
(if (nth 3 state)
|
|
|
|
|
|
;; This might be a (doc)string or a |...| symbol.
|
|
|
|
|
|
(let ((startpos (nth 8 state)))
|
|
|
|
|
|
(if (eq (char-after startpos) ?|)
|
|
|
|
|
|
;; This is not a string, but a |...| symbol.
|
|
|
|
|
|
nil
|
|
|
|
|
|
(let* ((listbeg (nth 1 state))
|
|
|
|
|
|
(firstsym (and listbeg
|
|
|
|
|
|
(save-excursion
|
|
|
|
|
|
(goto-char listbeg)
|
|
|
|
|
|
(and (looking-at "([ \t\n]*\\(\\(\\sw\\|\\s_\\)+\\)")
|
|
|
|
|
|
(match-string 1)))))
|
|
|
|
|
|
(docelt (and firstsym
|
|
|
|
|
|
(function-get (intern-soft firstsym)
|
|
|
|
|
|
lisp-doc-string-elt-property))))
|
|
|
|
|
|
(if (and docelt
|
|
|
|
|
|
;; It's a string in a form that can have a docstring.
|
|
|
|
|
|
;; Check whether it's in docstring position.
|
|
|
|
|
|
(save-excursion
|
|
|
|
|
|
(when (functionp docelt)
|
|
|
|
|
|
(goto-char (match-end 1))
|
|
|
|
|
|
(setq docelt (funcall docelt)))
|
|
|
|
|
|
(goto-char listbeg)
|
|
|
|
|
|
(forward-char 1)
|
|
|
|
|
|
(condition-case nil
|
|
|
|
|
|
(while (and (> docelt 0) (< (point) startpos)
|
|
|
|
|
|
(progn (forward-sexp 1) t))
|
|
|
|
|
|
;; ignore metadata and type hints
|
|
|
|
|
|
(unless (looking-at "[ \n\t]*\\(\\^[A-Z:].+\\|\\^?{.+\\)")
|
|
|
|
|
|
(setq docelt (1- docelt))))
|
|
|
|
|
|
(error nil))
|
|
|
|
|
|
(and (zerop docelt) (<= (point) startpos)
|
|
|
|
|
|
(progn (forward-comment (point-max)) t)
|
|
|
|
|
|
(= (point) (nth 8 state)))))
|
|
|
|
|
|
font-lock-doc-face
|
|
|
|
|
|
font-lock-string-face))))
|
|
|
|
|
|
font-lock-comment-face))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-font-lock-setup ()
|
|
|
|
|
|
"Configures font-lock for editing Clojure code."
|
|
|
|
|
|
(setq-local font-lock-multiline t)
|
|
|
|
|
|
(add-to-list 'font-lock-extend-region-functions
|
|
|
|
|
|
#'clojure-font-lock-extend-region-def t)
|
|
|
|
|
|
(setq font-lock-defaults
|
|
|
|
|
|
'(clojure-font-lock-keywords ; keywords
|
|
|
|
|
|
nil nil
|
|
|
|
|
|
(("+-*/.<>=!?$%_&~^:@" . "w")) ; syntax alist
|
|
|
|
|
|
nil
|
|
|
|
|
|
(font-lock-mark-block-function . mark-defun)
|
|
|
|
|
|
(font-lock-syntactic-face-function
|
|
|
|
|
|
. clojure-font-lock-syntactic-face-function))))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-font-lock-def-at-point (point)
|
|
|
|
|
|
"Range between the top-most def* and the fourth element after POINT.
|
|
|
|
|
|
Note that this means that there is no guarantee of proper font
|
|
|
|
|
|
locking in def* forms that are not at top level."
|
|
|
|
|
|
(goto-char point)
|
|
|
|
|
|
(condition-case nil
|
|
|
|
|
|
(beginning-of-defun)
|
|
|
|
|
|
(error nil))
|
|
|
|
|
|
|
|
|
|
|
|
(let ((beg-def (point)))
|
|
|
|
|
|
(when (and (not (= point beg-def))
|
|
|
|
|
|
(looking-at "(def"))
|
|
|
|
|
|
(condition-case nil
|
|
|
|
|
|
(progn
|
|
|
|
|
|
;; move forward as much as possible until failure (or success)
|
|
|
|
|
|
(forward-char)
|
|
|
|
|
|
(dotimes (_ 4)
|
|
|
|
|
|
(forward-sexp)))
|
|
|
|
|
|
(error nil))
|
|
|
|
|
|
(cons beg-def (point)))))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-font-lock-extend-region-def ()
|
|
|
|
|
|
"Set region boundaries to include the first four elements of def* forms."
|
|
|
|
|
|
(let ((changed nil))
|
|
|
|
|
|
(let ((def (clojure-font-lock-def-at-point font-lock-beg)))
|
|
|
|
|
|
(when def
|
|
|
|
|
|
(cl-destructuring-bind (def-beg . def-end) def
|
|
|
|
|
|
(when (and (< def-beg font-lock-beg)
|
|
|
|
|
|
(< font-lock-beg def-end))
|
|
|
|
|
|
(setq font-lock-beg def-beg
|
|
|
|
|
|
changed t)))))
|
|
|
|
|
|
(let ((def (clojure-font-lock-def-at-point font-lock-end)))
|
|
|
|
|
|
(when def
|
|
|
|
|
|
(cl-destructuring-bind (def-beg . def-end) def
|
|
|
|
|
|
(when (and (< def-beg font-lock-end)
|
|
|
|
|
|
(< font-lock-end def-end))
|
|
|
|
|
|
(setq font-lock-end def-end
|
|
|
|
|
|
changed t)))))
|
|
|
|
|
|
changed))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-font-lock-regexp-groups (bound)
|
|
|
|
|
|
"Highlight grouping constructs in regular expression.
|
|
|
|
|
|
|
|
|
|
|
|
BOUND denotes the maximum number of characters (relative to the
|
|
|
|
|
|
point) to check."
|
|
|
|
|
|
(catch 'found
|
|
|
|
|
|
(while (re-search-forward (concat
|
|
|
|
|
|
;; A group may start using several alternatives:
|
|
|
|
|
|
"\\(\\(?:"
|
|
|
|
|
|
;; 1. (? special groups
|
|
|
|
|
|
"(\\?\\(?:"
|
|
|
|
|
|
;; a) non-capturing group (?:X)
|
|
|
|
|
|
;; b) independent non-capturing group (?>X)
|
|
|
|
|
|
;; c) zero-width positive lookahead (?=X)
|
|
|
|
|
|
;; d) zero-width negative lookahead (?!X)
|
|
|
|
|
|
"[:=!>]\\|"
|
|
|
|
|
|
;; e) zero-width positive lookbehind (?<=X)
|
|
|
|
|
|
;; f) zero-width negative lookbehind (?<!X)
|
|
|
|
|
|
"<[=!]\\|"
|
|
|
|
|
|
;; g) named capturing group (?<name>X)
|
|
|
|
|
|
"<[[:alnum:]]+>"
|
|
|
|
|
|
"\\)\\|" ;; end of special groups
|
|
|
|
|
|
;; 2. normal capturing groups (
|
|
|
|
|
|
;; 3. we also highlight alternative
|
|
|
|
|
|
;; separarators |, and closing parens )
|
|
|
|
|
|
"[|()]"
|
|
|
|
|
|
"\\)\\)")
|
|
|
|
|
|
bound t)
|
|
|
|
|
|
(let ((face (get-text-property (1- (point)) 'face)))
|
|
|
|
|
|
(when (and (or (and (listp face)
|
|
|
|
|
|
(memq 'font-lock-string-face face))
|
|
|
|
|
|
(eq 'font-lock-string-face face))
|
|
|
|
|
|
(clojure-string-start t))
|
|
|
|
|
|
(throw 'found t))))))
|
|
|
|
|
|
|
|
|
|
|
|
;; Docstring positions
|
|
|
|
|
|
(put 'ns 'clojure-doc-string-elt 2)
|
|
|
|
|
|
(put 'def 'clojure-doc-string-elt 2)
|
|
|
|
|
|
(put 'defn 'clojure-doc-string-elt 2)
|
|
|
|
|
|
(put 'defn- 'clojure-doc-string-elt 2)
|
|
|
|
|
|
(put 'defmulti 'clojure-doc-string-elt 2)
|
|
|
|
|
|
(put 'defmacro 'clojure-doc-string-elt 2)
|
|
|
|
|
|
(put 'definline 'clojure-doc-string-elt 2)
|
|
|
|
|
|
(put 'defprotocol 'clojure-doc-string-elt 2)
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-indent-line ()
|
|
|
|
|
|
"Indent current line as Clojure code."
|
|
|
|
|
|
(if (clojure-in-docstring-p)
|
|
|
|
|
|
(save-excursion
|
|
|
|
|
|
(beginning-of-line)
|
|
|
|
|
|
(when (and (looking-at "^\\s-*")
|
|
|
|
|
|
(<= (string-width (match-string-no-properties 0))
|
|
|
|
|
|
(string-width (clojure-docstring-fill-prefix))))
|
|
|
|
|
|
(replace-match (clojure-docstring-fill-prefix))))
|
|
|
|
|
|
(lisp-indent-line)))
|
|
|
|
|
|
|
|
|
|
|
|
(defvar clojure-get-indent-function nil
|
|
|
|
|
|
"Function to get the indent spec of a symbol.
|
|
|
|
|
|
This function should take one argument, the name of the symbol as
|
|
|
|
|
|
a string. This name will be exactly as it appears in the buffer,
|
|
|
|
|
|
so it might start with a namespace alias.
|
|
|
|
|
|
|
|
|
|
|
|
This function is analogous to the `clojure-indent-function'
|
|
|
|
|
|
symbol property, and its return value should match one of the
|
|
|
|
|
|
allowed values of this property. See `clojure-indent-function'
|
|
|
|
|
|
for more information.")
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure--get-indent-method (function-name)
|
|
|
|
|
|
"Return the indent spec for the symbol named FUNCTION-NAME.
|
|
|
|
|
|
FUNCTION-NAME is a string. If it contains a `/', also try only
|
|
|
|
|
|
the part after the `/'.
|
|
|
|
|
|
|
|
|
|
|
|
Look for a spec using `clojure-get-indent-function', then try the
|
|
|
|
|
|
`clojure-indent-function' and `clojure-backtracking-indent'
|
|
|
|
|
|
symbol properties."
|
|
|
|
|
|
(or (when (functionp clojure-get-indent-function)
|
|
|
|
|
|
(funcall clojure-get-indent-function function-name))
|
|
|
|
|
|
(get (intern-soft function-name) 'clojure-indent-function)
|
|
|
|
|
|
(get (intern-soft function-name) 'clojure-backtracking-indent)
|
|
|
|
|
|
(when (string-match "/\\([^/]+\\)\\'" function-name)
|
|
|
|
|
|
(or (get (intern-soft (match-string 1 function-name))
|
|
|
|
|
|
'clojure-indent-function)
|
|
|
|
|
|
(get (intern-soft (match-string 1 function-name))
|
|
|
|
|
|
'clojure-backtracking-indent)))))
|
|
|
|
|
|
|
|
|
|
|
|
(defvar clojure--current-backtracking-depth 0)
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure--find-indent-spec-backtracking ()
|
|
|
|
|
|
"Return the indent sexp that applies to the sexp at point.
|
|
|
|
|
|
Implementation function for `clojure--find-indent-spec'."
|
|
|
|
|
|
(when (and (>= clojure-max-backtracking clojure--current-backtracking-depth)
|
|
|
|
|
|
(not (looking-at "^")))
|
|
|
|
|
|
(let ((clojure--current-backtracking-depth (1+ clojure--current-backtracking-depth))
|
|
|
|
|
|
(pos 0))
|
|
|
|
|
|
;; Count how far we are from the start of the sexp.
|
|
|
|
|
|
(while (ignore-errors (clojure-backward-logical-sexp 1)
|
|
|
|
|
|
(not (or (bobp)
|
|
|
|
|
|
(eq (char-before) ?\n))))
|
|
|
|
|
|
(cl-incf pos))
|
|
|
|
|
|
(let* ((function (thing-at-point 'symbol))
|
|
|
|
|
|
(method (or (when function ;; Is there a spec here?
|
|
|
|
|
|
(clojure--get-indent-method function))
|
|
|
|
|
|
;; `up-list' errors on unbalanced sexps.
|
|
|
|
|
|
(ignore-errors
|
|
|
|
|
|
(up-list) ;; Otherwise look higher up.
|
|
|
|
|
|
(clojure-backward-logical-sexp 1)
|
|
|
|
|
|
(clojure--find-indent-spec-backtracking)))))
|
|
|
|
|
|
(when (numberp method)
|
|
|
|
|
|
(setq method (list method)))
|
|
|
|
|
|
(pcase method
|
|
|
|
|
|
((pred sequencep)
|
|
|
|
|
|
(pcase (length method)
|
|
|
|
|
|
(`0 nil)
|
|
|
|
|
|
(`1 (let ((head (elt method 0)))
|
|
|
|
|
|
(when (or (= pos 0) (sequencep head))
|
|
|
|
|
|
head)))
|
|
|
|
|
|
(l (if (>= pos l)
|
|
|
|
|
|
(elt method (1- l))
|
|
|
|
|
|
(elt method pos)))))
|
|
|
|
|
|
((or `defun `:defn)
|
|
|
|
|
|
(when (= pos 0)
|
|
|
|
|
|
:defn))
|
|
|
|
|
|
((pred functionp)
|
|
|
|
|
|
(when (= pos 0)
|
|
|
|
|
|
method))
|
|
|
|
|
|
(_
|
|
|
|
|
|
(message "Invalid indent spec for `%s': %s" function method)
|
|
|
|
|
|
nil))))))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure--find-indent-spec ()
|
|
|
|
|
|
"Return the indent spec that applies to current sexp.
|
|
|
|
|
|
If `clojure-use-backtracking-indent' is non-nil, also do
|
|
|
|
|
|
backtracking up to a higher-level sexp in order to find the
|
|
|
|
|
|
spec."
|
|
|
|
|
|
(if clojure-use-backtracking-indent
|
|
|
|
|
|
(save-excursion
|
|
|
|
|
|
(clojure--find-indent-spec-backtracking))
|
|
|
|
|
|
(let ((function (thing-at-point 'symbol)))
|
|
|
|
|
|
(clojure--get-indent-method function))))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure--normal-indent (last-sexp)
|
|
|
|
|
|
"Return the normal indentation column for a sexp.
|
|
|
|
|
|
LAST-SEXP is the start of the previous sexp."
|
|
|
|
|
|
(goto-char last-sexp)
|
|
|
|
|
|
(forward-sexp 1)
|
|
|
|
|
|
(clojure-backward-logical-sexp 1)
|
|
|
|
|
|
(let ((last-sexp-start nil))
|
|
|
|
|
|
(unless (ignore-errors
|
|
|
|
|
|
(while (string-match
|
|
|
|
|
|
"[^[:blank:]]"
|
|
|
|
|
|
(buffer-substring (line-beginning-position) (point)))
|
|
|
|
|
|
(setq last-sexp-start (prog1 (point)
|
|
|
|
|
|
(forward-sexp -1))))
|
|
|
|
|
|
t)
|
|
|
|
|
|
;; If the last sexp was on the same line.
|
|
|
|
|
|
(when (and last-sexp-start
|
|
|
|
|
|
(> (line-end-position) last-sexp-start))
|
|
|
|
|
|
(goto-char last-sexp-start)))
|
|
|
|
|
|
(current-column)))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure--not-function-form-p ()
|
|
|
|
|
|
"Non-nil if form at point doesn't represent a function call."
|
|
|
|
|
|
(or (member (char-after) '(?\[ ?\{))
|
|
|
|
|
|
(save-excursion ;; Catch #?@ (:cljs ...)
|
|
|
|
|
|
(skip-chars-backward "\r\n[:blank:]")
|
|
|
|
|
|
(when (eq (char-before) ?@)
|
|
|
|
|
|
(forward-char -1))
|
|
|
|
|
|
(and (eq (char-before) ?\?)
|
|
|
|
|
|
(eq (char-before (1- (point))) ?\#)))
|
|
|
|
|
|
;; Car of form is not a symbol.
|
|
|
|
|
|
(not (looking-at ".\\(?:\\sw\\|\\s_\\)"))))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-indent-function (indent-point state)
|
|
|
|
|
|
"When indenting a line within a function call, indent properly.
|
|
|
|
|
|
|
|
|
|
|
|
INDENT-POINT is the position where the user typed TAB, or equivalent.
|
|
|
|
|
|
Point is located at the point to indent under (for default indentation);
|
|
|
|
|
|
STATE is the `parse-partial-sexp' state for that position.
|
|
|
|
|
|
|
|
|
|
|
|
If the current line is in a call to a Clojure function with a
|
|
|
|
|
|
non-nil property `clojure-indent-function', that specifies how to do
|
|
|
|
|
|
the indentation.
|
|
|
|
|
|
|
|
|
|
|
|
The property value can be
|
|
|
|
|
|
|
|
|
|
|
|
- `defun', meaning indent `defun'-style;
|
|
|
|
|
|
- an integer N, meaning indent the first N arguments specially
|
|
|
|
|
|
like ordinary function arguments and then indent any further
|
|
|
|
|
|
arguments like a body;
|
|
|
|
|
|
- a function to call just as this function was called.
|
|
|
|
|
|
If that function returns nil, that means it doesn't specify
|
|
|
|
|
|
the indentation.
|
|
|
|
|
|
- a list, which is used by `clojure-backtracking-indent'.
|
|
|
|
|
|
|
|
|
|
|
|
This function also returns nil meaning don't specify the indentation."
|
|
|
|
|
|
;; Goto to the open-paren.
|
|
|
|
|
|
(goto-char (elt state 1))
|
|
|
|
|
|
;; Maps, sets, vectors and reader conditionals.
|
|
|
|
|
|
(if (clojure--not-function-form-p)
|
|
|
|
|
|
(1+ (current-column))
|
|
|
|
|
|
;; Function or macro call.
|
|
|
|
|
|
(forward-char 1)
|
|
|
|
|
|
(let ((method (clojure--find-indent-spec))
|
|
|
|
|
|
(containing-form-column (1- (current-column))))
|
|
|
|
|
|
(pcase method
|
|
|
|
|
|
((or (pred integerp) `(,method))
|
|
|
|
|
|
(let ((pos -1))
|
|
|
|
|
|
(condition-case nil
|
|
|
|
|
|
(while (and (<= (point) indent-point)
|
|
|
|
|
|
(not (eobp)))
|
|
|
|
|
|
(clojure-forward-logical-sexp 1)
|
|
|
|
|
|
(cl-incf pos))
|
|
|
|
|
|
;; If indent-point is _after_ the last sexp in the
|
|
|
|
|
|
;; current sexp, we detect that by catching the
|
|
|
|
|
|
;; `scan-error'. In that case, we should return the
|
|
|
|
|
|
;; indentation as if there were an extra sexp at point.
|
|
|
|
|
|
(scan-error (cl-incf pos)))
|
|
|
|
|
|
(cond
|
|
|
|
|
|
((= pos (1+ method))
|
|
|
|
|
|
(+ lisp-body-indent containing-form-column))
|
|
|
|
|
|
((> pos (1+ method))
|
|
|
|
|
|
(clojure--normal-indent calculate-lisp-indent-last-sexp))
|
|
|
|
|
|
(t
|
|
|
|
|
|
(+ (* 2 lisp-body-indent) containing-form-column)))))
|
|
|
|
|
|
(`:defn
|
|
|
|
|
|
(+ lisp-body-indent containing-form-column))
|
|
|
|
|
|
((pred functionp)
|
|
|
|
|
|
(funcall method indent-point state))
|
|
|
|
|
|
((and `nil
|
|
|
|
|
|
(guard (let ((function (thing-at-point 'sexp)))
|
|
|
|
|
|
(or (and clojure-defun-style-default-indent
|
|
|
|
|
|
;; largely to preserve useful alignment of :require, etc in ns
|
|
|
|
|
|
(not (string-match "^:" function)))
|
|
|
|
|
|
(string-match "\\`\\(?:\\S +/\\)?\\(def\\|with-\\)"
|
|
|
|
|
|
function)))))
|
|
|
|
|
|
(+ lisp-body-indent containing-form-column))
|
|
|
|
|
|
(_ (clojure--normal-indent calculate-lisp-indent-last-sexp))))))
|
|
|
|
|
|
|
|
|
|
|
|
;;; Setting indentation
|
|
|
|
|
|
(defun put-clojure-indent (sym indent)
|
|
|
|
|
|
"Instruct `clojure-indent-function' to indent the body of SYM by INDENT."
|
|
|
|
|
|
(put sym 'clojure-indent-function indent))
|
|
|
|
|
|
|
|
|
|
|
|
(defmacro define-clojure-indent (&rest kvs)
|
|
|
|
|
|
"Call `put-clojure-indent' on a series, KVS."
|
|
|
|
|
|
`(progn
|
|
|
|
|
|
,@(mapcar (lambda (x) `(put-clojure-indent
|
|
|
|
|
|
(quote ,(car x)) ,(cadr x)))
|
|
|
|
|
|
kvs)))
|
|
|
|
|
|
|
|
|
|
|
|
(defun add-custom-clojure-indents (name value)
|
|
|
|
|
|
"Allow `clojure-defun-indents' to indent user-specified macros.
|
|
|
|
|
|
|
|
|
|
|
|
Requires the macro's NAME and a VALUE."
|
|
|
|
|
|
(custom-set-default name value)
|
|
|
|
|
|
(mapcar (lambda (x)
|
|
|
|
|
|
(put-clojure-indent x 'defun))
|
|
|
|
|
|
value))
|
|
|
|
|
|
|
|
|
|
|
|
(defcustom clojure-defun-indents nil
|
|
|
|
|
|
"List of additional symbols with defun-style indentation in Clojure.
|
|
|
|
|
|
|
|
|
|
|
|
You can use this to let Emacs indent your own macros the same way
|
|
|
|
|
|
that it indents built-in macros like with-open. To manually set
|
|
|
|
|
|
it from Lisp code, use (put-clojure-indent 'some-symbol :defn)."
|
|
|
|
|
|
:type '(repeat symbol)
|
|
|
|
|
|
:group 'clojure
|
|
|
|
|
|
:set 'add-custom-clojure-indents)
|
|
|
|
|
|
|
|
|
|
|
|
(define-clojure-indent
|
|
|
|
|
|
;; built-ins
|
|
|
|
|
|
(ns 1)
|
|
|
|
|
|
(fn :defn)
|
|
|
|
|
|
(def :defn)
|
|
|
|
|
|
(defn :defn)
|
|
|
|
|
|
(bound-fn :defn)
|
|
|
|
|
|
(if 1)
|
|
|
|
|
|
(if-not 1)
|
|
|
|
|
|
(case 1)
|
|
|
|
|
|
(cond 0)
|
|
|
|
|
|
(condp 2)
|
|
|
|
|
|
(cond-> 1)
|
|
|
|
|
|
(cond->> 1)
|
|
|
|
|
|
(when 1)
|
|
|
|
|
|
(while 1)
|
|
|
|
|
|
(when-not 1)
|
|
|
|
|
|
(when-first 1)
|
|
|
|
|
|
(do 0)
|
|
|
|
|
|
(future 0)
|
|
|
|
|
|
(comment 0)
|
|
|
|
|
|
(doto 1)
|
|
|
|
|
|
(locking 1)
|
|
|
|
|
|
(proxy '(2 nil nil (1)))
|
|
|
|
|
|
(as-> 2)
|
|
|
|
|
|
|
|
|
|
|
|
(reify '(1 nil (1)))
|
|
|
|
|
|
(deftype '(2 nil nil (1)))
|
|
|
|
|
|
(defrecord '(2 nil nil (1)))
|
|
|
|
|
|
(defprotocol '(1))
|
|
|
|
|
|
(extend 1)
|
|
|
|
|
|
(extend-protocol '(1 (1)))
|
|
|
|
|
|
(extend-type '(1 (1)))
|
|
|
|
|
|
(specify '(1 (1)))
|
|
|
|
|
|
(specify! '(1 (1)))
|
|
|
|
|
|
(implement '(1 (1)))
|
|
|
|
|
|
(try 0)
|
|
|
|
|
|
(catch 2)
|
|
|
|
|
|
(finally 0)
|
|
|
|
|
|
|
|
|
|
|
|
;; binding forms
|
|
|
|
|
|
(let 1)
|
|
|
|
|
|
(letfn '(1 ((1)) nil))
|
|
|
|
|
|
(binding 1)
|
|
|
|
|
|
(loop 1)
|
|
|
|
|
|
(for 1)
|
|
|
|
|
|
(doseq 1)
|
|
|
|
|
|
(dotimes 1)
|
|
|
|
|
|
(when-let 1)
|
|
|
|
|
|
(if-let 1)
|
|
|
|
|
|
(when-some 1)
|
|
|
|
|
|
(if-some 1)
|
|
|
|
|
|
|
|
|
|
|
|
(defmethod :defn)
|
|
|
|
|
|
|
|
|
|
|
|
;; clojure.test
|
|
|
|
|
|
(testing 1)
|
|
|
|
|
|
(deftest :defn)
|
|
|
|
|
|
(are 2)
|
|
|
|
|
|
(use-fixtures :defn)
|
|
|
|
|
|
|
|
|
|
|
|
;; core.logic
|
|
|
|
|
|
(run :defn)
|
|
|
|
|
|
(run* :defn)
|
|
|
|
|
|
(fresh :defn)
|
|
|
|
|
|
|
|
|
|
|
|
;; core.async
|
|
|
|
|
|
(alt! 0)
|
|
|
|
|
|
(alt!! 0)
|
|
|
|
|
|
(go 0)
|
|
|
|
|
|
(go-loop 1)
|
|
|
|
|
|
(thread 0))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;;
|
|
|
|
|
|
;; Better docstring filling for clojure-mode
|
|
|
|
|
|
;;
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-string-start (&optional regex)
|
|
|
|
|
|
"Return the position of the \" that begins the string at point.
|
|
|
|
|
|
If REGEX is non-nil, return the position of the # that begins the
|
|
|
|
|
|
regex at point. If point is not inside a string or regex, return
|
|
|
|
|
|
nil."
|
|
|
|
|
|
(when (nth 3 (syntax-ppss)) ;; Are we really in a string?
|
|
|
|
|
|
(save-excursion
|
|
|
|
|
|
(save-match-data
|
|
|
|
|
|
;; Find a quote that appears immediately after whitespace,
|
|
|
|
|
|
;; beginning of line, hash, or an open paren, brace, or bracket
|
|
|
|
|
|
(re-search-backward "\\(\\s-\\|^\\|#\\|(\\|\\[\\|{\\)\\(\"\\)")
|
|
|
|
|
|
(let ((beg (match-beginning 2)))
|
|
|
|
|
|
(when beg
|
|
|
|
|
|
(if regex
|
|
|
|
|
|
(and (char-before beg) (char-equal ?# (char-before beg)) (1- beg))
|
|
|
|
|
|
(when (not (char-equal ?# (char-before beg)))
|
|
|
|
|
|
beg))))))))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-char-at-point ()
|
|
|
|
|
|
"Return the char at point or nil if at buffer end."
|
|
|
|
|
|
(when (not (= (point) (point-max)))
|
|
|
|
|
|
(buffer-substring-no-properties (point) (1+ (point)))))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-char-before-point ()
|
|
|
|
|
|
"Return the char before point or nil if at buffer beginning."
|
|
|
|
|
|
(when (not (= (point) (point-min)))
|
|
|
|
|
|
(buffer-substring-no-properties (point) (1- (point)))))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-toggle-keyword-string ()
|
|
|
|
|
|
"Convert the string or keyword at point to keyword or string."
|
|
|
|
|
|
(interactive)
|
|
|
|
|
|
(let ((original-point (point)))
|
|
|
|
|
|
(while (and (> (point) 1)
|
|
|
|
|
|
(not (equal "\"" (buffer-substring-no-properties (point) (+ 1 (point)))))
|
|
|
|
|
|
(not (equal ":" (buffer-substring-no-properties (point) (+ 1 (point))))))
|
|
|
|
|
|
(backward-char))
|
|
|
|
|
|
(cond
|
|
|
|
|
|
((equal 1 (point))
|
|
|
|
|
|
(error "Beginning of file reached, this was probably a mistake"))
|
|
|
|
|
|
((equal "\"" (buffer-substring-no-properties (point) (+ 1 (point))))
|
|
|
|
|
|
(insert ":" (substring (clojure-delete-and-extract-sexp) 1 -1)))
|
|
|
|
|
|
((equal ":" (buffer-substring-no-properties (point) (+ 1 (point))))
|
|
|
|
|
|
(insert "\"" (substring (clojure-delete-and-extract-sexp) 1) "\"")))
|
|
|
|
|
|
(goto-char original-point)))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-delete-and-extract-sexp ()
|
|
|
|
|
|
"Delete the sexp and return it."
|
|
|
|
|
|
(interactive)
|
|
|
|
|
|
(let ((begin (point)))
|
|
|
|
|
|
(forward-sexp)
|
|
|
|
|
|
(let ((result (buffer-substring-no-properties begin (point))))
|
|
|
|
|
|
(delete-region begin (point))
|
|
|
|
|
|
result)))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(defconst clojure-namespace-name-regex
|
|
|
|
|
|
(rx line-start
|
|
|
|
|
|
(zero-or-more whitespace)
|
|
|
|
|
|
"("
|
|
|
|
|
|
(zero-or-one (group (regexp "clojure.core/")))
|
|
|
|
|
|
(zero-or-one (submatch "in-"))
|
|
|
|
|
|
"ns"
|
|
|
|
|
|
(zero-or-one "+")
|
|
|
|
|
|
(one-or-more (any whitespace "\n"))
|
|
|
|
|
|
(zero-or-more (or (submatch (zero-or-one "#")
|
|
|
|
|
|
"^{"
|
|
|
|
|
|
(zero-or-more (not (any "}")))
|
|
|
|
|
|
"}")
|
|
|
|
|
|
(zero-or-more "^:"
|
|
|
|
|
|
(one-or-more (not (any whitespace)))))
|
|
|
|
|
|
(one-or-more (any whitespace "\n")))
|
|
|
|
|
|
;; why is this here? oh (in-ns 'foo) or (ns+ :user)
|
|
|
|
|
|
(zero-or-one (any ":'"))
|
|
|
|
|
|
(group (one-or-more (not (any "()\"" whitespace))) word-end)))
|
|
|
|
|
|
|
|
|
|
|
|
;; for testing clojure-namespace-name-regex, you can evaluate this code and make
|
|
|
|
|
|
;; sure foo (or whatever the namespace name is) shows up in results. some of
|
|
|
|
|
|
;; these currently fail.
|
|
|
|
|
|
;; (mapcar (lambda (s) (let ((n (string-match clojure-namespace-name-regex s)))
|
|
|
|
|
|
;; (if n (match-string 4 s))))
|
|
|
|
|
|
;; '("(ns foo)"
|
|
|
|
|
|
;; "(ns
|
|
|
|
|
|
;; foo)"
|
|
|
|
|
|
;; "(ns foo.baz)"
|
|
|
|
|
|
;; "(ns ^:bar foo)"
|
|
|
|
|
|
;; "(ns ^:bar ^:baz foo)"
|
|
|
|
|
|
;; "(ns ^{:bar true} foo)"
|
|
|
|
|
|
;; "(ns #^{:bar true} foo)"
|
|
|
|
|
|
;; "(ns #^{:fail {}} foo)"
|
|
|
|
|
|
;; "(ns ^{:fail2 {}} foo.baz)"
|
|
|
|
|
|
;; "(ns ^{} foo)"
|
|
|
|
|
|
;; "(ns ^{:skip-wiki true}
|
|
|
|
|
|
;; aleph.netty
|
|
|
|
|
|
;; "
|
|
|
|
|
|
;; "(ns
|
|
|
|
|
|
;; foo)"
|
|
|
|
|
|
;; "foo"))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-project-dir (&optional dir-name)
|
|
|
|
|
|
"Return the absolute path to the project's root directory.
|
|
|
|
|
|
|
|
|
|
|
|
Use `default-directory' if DIR-NAME is nil.
|
|
|
|
|
|
Return nil if not inside a project."
|
|
|
|
|
|
(let ((dir-name (or dir-name default-directory)))
|
|
|
|
|
|
(let ((lein-project-dir (locate-dominating-file dir-name "project.clj"))
|
|
|
|
|
|
(boot-project-dir (locate-dominating-file dir-name "build.boot")))
|
|
|
|
|
|
(when (or lein-project-dir boot-project-dir)
|
|
|
|
|
|
(file-truename
|
|
|
|
|
|
(cond ((not lein-project-dir) boot-project-dir)
|
|
|
|
|
|
((not boot-project-dir) lein-project-dir)
|
|
|
|
|
|
(t (if (file-in-directory-p lein-project-dir boot-project-dir)
|
|
|
|
|
|
lein-project-dir
|
|
|
|
|
|
boot-project-dir))))))))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-project-relative-path (path)
|
|
|
|
|
|
"Denormalize PATH by making it relative to the project root."
|
|
|
|
|
|
(file-relative-name path (clojure-project-dir)))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-expected-ns (&optional path)
|
|
|
|
|
|
"Return the namespace matching PATH.
|
|
|
|
|
|
|
|
|
|
|
|
PATH is expected to be an absolute file path.
|
|
|
|
|
|
|
|
|
|
|
|
If PATH is nil, use the path to the file backing the current buffer."
|
|
|
|
|
|
(let* ((path (or path (file-truename (buffer-file-name))))
|
|
|
|
|
|
(relative (clojure-project-relative-path path))
|
|
|
|
|
|
(sans-file-type (substring relative 0 (- (length (file-name-extension path t)))))
|
|
|
|
|
|
(sans-file-sep (mapconcat 'identity (cdr (split-string sans-file-type "/")) "."))
|
|
|
|
|
|
(sans-underscores (replace-regexp-in-string "_" "-" sans-file-sep)))
|
|
|
|
|
|
;; Drop prefix from ns for projects with structure src/{clj,cljs,cljc}
|
|
|
|
|
|
(replace-regexp-in-string "\\`clj[scx]?\\." "" sans-underscores)))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-insert-ns-form-at-point ()
|
|
|
|
|
|
"Insert a namespace form at point."
|
|
|
|
|
|
(interactive)
|
|
|
|
|
|
(insert (format "(ns %s)" (clojure-expected-ns))))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-insert-ns-form ()
|
|
|
|
|
|
"Insert a namespace form at the beginning of the buffer."
|
|
|
|
|
|
(interactive)
|
|
|
|
|
|
(widen)
|
|
|
|
|
|
(goto-char (point-min))
|
|
|
|
|
|
(clojure-insert-ns-form-at-point))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-update-ns ()
|
|
|
|
|
|
"Update the namespace of the current buffer.
|
|
|
|
|
|
Useful if a file has been renamed."
|
|
|
|
|
|
(interactive)
|
|
|
|
|
|
(let ((nsname (clojure-expected-ns)))
|
|
|
|
|
|
(when nsname
|
|
|
|
|
|
(save-excursion
|
|
|
|
|
|
(save-match-data
|
|
|
|
|
|
(if (clojure-find-ns)
|
|
|
|
|
|
(replace-match nsname nil nil nil 4)
|
|
|
|
|
|
(error "Namespace not found")))))))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-find-ns ()
|
|
|
|
|
|
"Find the namespace of the current Clojure buffer."
|
|
|
|
|
|
(let ((regexp clojure-namespace-name-regex))
|
|
|
|
|
|
(save-excursion
|
|
|
|
|
|
(save-restriction
|
|
|
|
|
|
(widen)
|
|
|
|
|
|
(goto-char (point-min))
|
|
|
|
|
|
(when (re-search-forward regexp nil t)
|
|
|
|
|
|
(match-string-no-properties 4))))))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-find-def ()
|
|
|
|
|
|
"Find the var declaration macro and symbol name of the current form.
|
|
|
|
|
|
Returns a list pair, e.g. (\"defn\" \"abc\") or (\"deftest\" \"some-test\")."
|
|
|
|
|
|
(let ((re (concat "(\\(?:\\(?:\\sw\\|\\s_\\)+/\\)?"
|
|
|
|
|
|
;; Declaration
|
|
|
|
|
|
"\\(def\\sw*\\)\\>"
|
|
|
|
|
|
;; Any whitespace
|
|
|
|
|
|
"[ \r\n\t]*"
|
|
|
|
|
|
;; Possibly type or metadata
|
|
|
|
|
|
"\\(?:#?^\\(?:{[^}]*}\\|\\(?:\\sw\\|\\s_\\)+\\)[ \r\n\t]*\\)*"
|
|
|
|
|
|
;; Symbol name
|
|
|
|
|
|
"\\(\\(?:\\sw\\|\\s_\\)+\\)")))
|
|
|
|
|
|
(save-excursion
|
|
|
|
|
|
(unless (looking-at re)
|
|
|
|
|
|
(beginning-of-defun))
|
|
|
|
|
|
(when (search-forward-regexp re nil t)
|
|
|
|
|
|
(list (match-string-no-properties 1)
|
|
|
|
|
|
(match-string-no-properties 2))))))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
;;; Sexp navigation
|
|
|
|
|
|
(defun clojure--looking-at-non-logical-sexp ()
|
|
|
|
|
|
"Return non-nil if sexp after point represents code.
|
|
|
|
|
|
Sexps that don't represent code are ^metadata or #reader.macros."
|
|
|
|
|
|
(comment-normalize-vars)
|
|
|
|
|
|
(comment-forward (point-max))
|
|
|
|
|
|
(looking-at-p "\\^\\|#[?[:alpha:]]"))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-forward-logical-sexp (&optional n)
|
|
|
|
|
|
"Move forward N logical sexps.
|
|
|
|
|
|
This will skip over sexps that don't represent objects, so that ^hints and
|
|
|
|
|
|
#reader.macros are considered part of the following sexp."
|
|
|
|
|
|
(interactive "p")
|
|
|
|
|
|
(if (< n 0)
|
|
|
|
|
|
(clojure-backward-logical-sexp (- n))
|
|
|
|
|
|
(let ((forward-sexp-function nil))
|
|
|
|
|
|
(while (> n 0)
|
|
|
|
|
|
(while (clojure--looking-at-non-logical-sexp)
|
|
|
|
|
|
(forward-sexp 1))
|
|
|
|
|
|
;; The actual sexp
|
|
|
|
|
|
(forward-sexp 1)
|
|
|
|
|
|
(setq n (1- n))))))
|
|
|
|
|
|
|
|
|
|
|
|
(defun clojure-backward-logical-sexp (&optional n)
|
|
|
|
|
|
"Move backward N logical sexps.
|
|
|
|
|
|
This will skip over sexps that don't represent objects, so that ^hints and
|
|
|
|
|
|
#reader.macros are considered part of the following sexp."
|
|
|
|
|
|
(interactive "p")
|
|
|
|
|
|
(if (< n 0)
|
|
|
|
|
|
(clojure-forward-logical-sexp (- n))
|
|
|
|
|
|
(let ((forward-sexp-function nil))
|
|
|
|
|
|
(while (> n 0)
|
|
|
|
|
|
;; The actual sexp
|
|
|
|
|
|
(backward-sexp 1)
|
|
|
|
|
|
;; Non-logical sexps.
|
|
|
|
|
|
(while (and (not (bobp))
|
|
|
|
|
|
(ignore-errors
|
|
|
|
|
|
(save-excursion
|
|
|
|
|
|
(backward-sexp 1)
|
|
|
|
|
|
(clojure--looking-at-non-logical-sexp))))
|
|
|
|
|
|
(backward-sexp 1))
|
|
|
|
|
|
(setq n (1- n))))))
|
|
|
|
|
|
|
|
|
|
|
|
(defconst clojurescript-font-lock-keywords
|
|
|
|
|
|
(eval-when-compile
|
|
|
|
|
|
`(;; ClojureScript built-ins
|
|
|
|
|
|
(,(concat "(\\(?:\.*/\\)?"
|
|
|
|
|
|
(regexp-opt '("js-obj" "js-delete" "clj->js" "js->clj"))
|
|
|
|
|
|
"\\>")
|
|
|
|
|
|
0 font-lock-builtin-face)))
|
|
|
|
|
|
"Additional font-locking for `clojurescrip-mode'.")
|
|
|
|
|
|
|
|
|
|
|
|
;;;###autoload
|
|
|
|
|
|
(define-derived-mode clojurescript-mode clojure-mode "ClojureScript"
|
|
|
|
|
|
"Major mode for editing ClojureScript code.
|
|
|
|
|
|
|
|
|
|
|
|
\\{clojurescript-mode-map}"
|
|
|
|
|
|
(font-lock-add-keywords nil clojurescript-font-lock-keywords))
|
|
|
|
|
|
|
|
|
|
|
|
;;;###autoload
|
|
|
|
|
|
(define-derived-mode clojurec-mode clojure-mode "ClojureC"
|
|
|
|
|
|
"Major mode for editing ClojureC code.
|
|
|
|
|
|
|
|
|
|
|
|
\\{clojurec-mode-map}")
|
|
|
|
|
|
|
|
|
|
|
|
(defconst clojurex-font-lock-keywords
|
|
|
|
|
|
;; cljx annotations (#+clj and #+cljs)
|
|
|
|
|
|
'(("#\\+cljs?\\>" 0 font-lock-preprocessor-face))
|
|
|
|
|
|
"Additional font-locking for `clojurex-mode'.")
|
|
|
|
|
|
|
|
|
|
|
|
;;;###autoload
|
|
|
|
|
|
(define-derived-mode clojurex-mode clojure-mode "ClojureX"
|
|
|
|
|
|
"Major mode for editing ClojureX code.
|
|
|
|
|
|
|
|
|
|
|
|
\\{clojurex-mode-map}"
|
|
|
|
|
|
(font-lock-add-keywords nil clojurex-font-lock-keywords))
|
|
|
|
|
|
|
|
|
|
|
|
;;;###autoload
|
|
|
|
|
|
(progn
|
|
|
|
|
|
(add-to-list 'auto-mode-alist
|
|
|
|
|
|
'("\\.\\(clj\\|dtm\\|edn\\)\\'" . clojure-mode))
|
|
|
|
|
|
(add-to-list 'auto-mode-alist '("\\.cljc\\'" . clojurec-mode))
|
|
|
|
|
|
(add-to-list 'auto-mode-alist '("\\.cljx\\'" . clojurex-mode))
|
|
|
|
|
|
(add-to-list 'auto-mode-alist '("\\.cljs\\'" . clojurescript-mode))
|
|
|
|
|
|
;; boot build scripts are Clojure source files
|
|
|
|
|
|
(add-to-list 'auto-mode-alist '("\\(?:build\\|profile\\)\\.boot\\'" . clojure-mode)))
|
|
|
|
|
|
|
|
|
|
|
|
(provide 'clojure-mode)
|
|
|
|
|
|
|
|
|
|
|
|
;; Local Variables:
|
|
|
|
|
|
;; coding: utf-8
|
|
|
|
|
|
;; indent-tabs-mode: nil
|
|
|
|
|
|
;; End:
|
|
|
|
|
|
|
|
|
|
|
|
;;; clojure-mode.el ends here
|
