"Face for parsing words."
:group 'factor-faces)
+(defface factor-font-lock-declaration (face-default-spec font-lock-keyword-face)
+ "Face for declaration words (inline, parsing ...)."
+ :group 'factor-faces)
+
(defface factor-font-lock-comment (face-default-spec font-lock-comment-face)
"Face for comments."
:group 'factor-faces)
"UNION:" "USE:" "USING:" "V{" "VAR:" "VARS:" "W{"))
(defconst factor--regex-parsing-words-ext
- (regexp-opt '("B" "call-next-method" "delimiter" "f" "flushable" "foldable"
- "initial:" "inline" "parsing" "read-only" "recursive")
+ (regexp-opt '("B" "call-next-method" "delimiter" "f" "initial:" "read-only")
'words))
+(defconst factor--declaration-words
+ '("flushable" "foldable" "inline" "parsing" "recursive"))
+
+(defconst factor--regex-declaration-words
+ (regexp-opt factor--declaration-words 'words))
+
(defsubst factor--regex-second-word (prefixes)
(format "^%s +\\([^ \r\n]+\\)" (regexp-opt prefixes t)))
'(2 'factor-font-lock-parsing-word)))
factor--parsing-words)
(,factor--regex-parsing-words-ext . 'factor-font-lock-parsing-word)
+ (,factor--regex-declaration-words 1 'factor-font-lock-declaration)
(,factor--regex-word-definition 2 'factor-font-lock-word-definition)
(,factor--regex-type-definition 2 'factor-font-lock-type-definition)
(,factor--regex-parent-type 1 'factor-font-lock-type-definition)
\f
;;; Factor mode syntax:
-(defconst factor--regexp-word-starters
+(defconst factor--regex-definition-starters
(regexp-opt '("TUPLE" "MACRO" "MACRO:" "M" ":" "")))
-(defconst factor--regexp-word-start
- (format "^\\(%s:\\) " factor--regexp-word-starters))
+(defconst factor--regex-definition-start
+ (format "^\\(%s:\\) " factor--regex-definition-starters))
+
+(defconst factor--regex-definition-end
+ (format "\\(;\\( +%s\\)?\\)" factor--regex-declaration-words))
(defconst factor--font-lock-syntactic-keywords
- `((,(format "^\\(%s\\)\\(:\\)" factor--regexp-word-starters)
- (1 "w") (2 "(;"))
- ("\\(;\\)" (1 "):"))
- ("\\(#!\\)" (1 "<"))
+ `(("\\(#!\\)" (1 "<"))
(" \\(!\\)" (1 "<"))
("^\\(!\\)" (1 "<"))
("\\(!(\\) .* \\()\\)" (1 "<") (2 ">"))))
(save-excursion
(beginning-of-buffer)
(while (not iw)
- (if (not (re-search-forward factor--regexp-word-start nil t))
+ (if (not (re-search-forward factor--regex-definition-start nil t))
(setq iw factor-default-indent-width)
(forward-line)
(when (looking-at word-cont)
(defsubst factor--ppss-brackets-start ()
(nth 1 (syntax-ppss)))
+(defun factor--ppss-brackets-end ()
+ (save-excursion
+ (goto-char (factor--ppss-brackets-start))
+ (forward-sexp)
+ (1- (point))))
+
(defsubst factor--indentation-at (pos)
(save-excursion (goto-char pos) (current-indentation)))
-(defconst factor--regex-closing-paren "[])}]")
-(defsubst factor--at-closing-paren-p ()
- (looking-at factor--regex-closing-paren))
-
(defsubst factor--at-first-char-p ()
(= (- (point) (line-beginning-position)) (current-indentation)))
"PRIVATE>" "<PRIVATE" "SYMBOL:" "USE:"))))
(defsubst factor--at-begin-of-def ()
- (looking-at factor--regexp-word-start))
+ (or (looking-at factor--regex-definition-start)
+ (looking-at factor--regex-single-liner)))
(defsubst factor--looking-at-emptiness ()
(looking-at "^[ \t]*$"))
-(defun factor--at-end-of-def ()
- (or (looking-at ".*;[ \t]*$")
+(defsubst factor--at-end-of-def ()
+ (or (looking-at factor--regex-definition-end)
(looking-at factor--regex-single-liner)))
(defun factor--at-setter-line ()
(defun factor--indent-in-brackets ()
(save-excursion
(beginning-of-line)
- (when (or (and (re-search-forward factor--regex-closing-paren
- (line-end-position) t)
- (not (backward-char)))
- (> (factor--ppss-brackets-depth) 0))
- (let ((op (factor--ppss-brackets-start)))
- (when (> (line-number-at-pos) (line-number-at-pos op))
- (if (factor--at-closing-paren-p)
+ (when (> (factor--ppss-brackets-depth) 0)
+ (let ((op (factor--ppss-brackets-start))
+ (cl (factor--ppss-brackets-end))
+ (ln (line-number-at-pos)))
+ (when (> ln (line-number-at-pos op))
+ (if (= ln (line-number-at-pos cl))
(factor--indentation-at op)
(factor--increased-indentation (factor--indentation-at op))))))))
(defvar factor-mode-map (make-sparse-keymap)
"Key map used by Factor mode.")
+(defsubst factor--beginning-of-defun (times)
+ (re-search-backward factor--regex-definition-start nil t times))
+
+(defsubst factor--end-of-defun ()
+ (re-search-forward factor--regex-definition-end nil t))
+
;;;###autoload
(defun factor-mode ()
"A mode for editing programs written in the Factor programming language.
(set-syntax-table factor-mode-syntax-table)
;; Defun navigation
- (setq defun-prompt-regexp "[^ :]+")
- (set (make-local-variable 'open-paren-in-column-0-is-defun-start) t)
+ (set (make-local-variable 'beginning-of-defun-function) 'factor--beginning-of-defun)
+ (set (make-local-variable 'end-of-defun-function) 'factor--end-of-defun)
+ (set (make-local-variable 'open-paren-in-column-0-is-defun-start) nil)
;; Indentation
(set (make-local-variable 'indent-line-function) 'factor--indent-line)
(setq factor-indent-width (factor--guess-indent-width))