Function: syntax-propertize-rules
syntax-propertize-rules is a macro defined in syntax.el.gz.
Signature
(syntax-propertize-rules &rest RULES)
Documentation
Make a function that applies RULES for use in syntax-propertize-function.
The function will scan the buffer, applying the rules where they match. The buffer is scanned a single time, like "lex" would, rather than once per rule.
Each RULE can be a symbol, in which case that symbol's value should be,
at macro-expansion time, a precompiled set of rules, as returned
by syntax-propertize-precompile-rules.
Otherwise, RULE should have the form (REGEXP HIGHLIGHT1 ... HIGHLIGHTn), where
REGEXP is an expression (evaluated at time of macro-expansion) that returns
a regexp, and where HIGHLIGHTs have the form (NUMBER SYNTAX) which means to
apply the property SYNTAX to the chars matched by the subgroup NUMBER
of the regular expression, if NUMBER did match.
SYNTAX is an expression that returns a value to apply as syntax-table
property. Some expressions are handled specially:
- if SYNTAX is a string, then it is converted with string-to-syntax;
- if SYNTAX has the form (prog1 EXP . EXPS) then the value returned by EXP
will be applied to the buffer before running EXPS and if EXP is a string it
is also converted with string-to-syntax.
The SYNTAX expression is responsible to save the match-data if needed
for subsequent HIGHLIGHTs.
Also SYNTAX is free to move point, in which case RULES may not be applied to
some parts of the text or may be applied several times to other parts.
Note: There may be at most nine back-references in the REGEXPs of all RULES in total.
Probably introduced at or before Emacs version 24.1.
Source Code
;; Defined in /usr/src/emacs/lisp/emacs-lisp/syntax.el.gz
(defmacro syntax-propertize-rules (&rest rules)
"Make a function that applies RULES for use in `syntax-propertize-function'.
The function will scan the buffer, applying the rules where they match.
The buffer is scanned a single time, like \"lex\" would, rather than once
per rule.
Each RULE can be a symbol, in which case that symbol's value should be,
at macro-expansion time, a precompiled set of rules, as returned
by `syntax-propertize-precompile-rules'.
Otherwise, RULE should have the form (REGEXP HIGHLIGHT1 ... HIGHLIGHTn), where
REGEXP is an expression (evaluated at time of macro-expansion) that returns
a regexp, and where HIGHLIGHTs have the form (NUMBER SYNTAX) which means to
apply the property SYNTAX to the chars matched by the subgroup NUMBER
of the regular expression, if NUMBER did match.
SYNTAX is an expression that returns a value to apply as `syntax-table'
property. Some expressions are handled specially:
- if SYNTAX is a string, then it is converted with `string-to-syntax';
- if SYNTAX has the form (prog1 EXP . EXPS) then the value returned by EXP
will be applied to the buffer before running EXPS and if EXP is a string it
is also converted with `string-to-syntax'.
The SYNTAX expression is responsible to save the `match-data' if needed
for subsequent HIGHLIGHTs.
Also SYNTAX is free to move point, in which case RULES may not be applied to
some parts of the text or may be applied several times to other parts.
Note: There may be at most nine back-references in the REGEXPs of
all RULES in total."
(declare
(debug (&rest &or symbolp ;FIXME: edebug this eval step.
(def-form ;; `def-' needed to debug during macroexpansion.
&rest (numberp
[&or stringp ;FIXME: Use &wrap
;; `def-' because this is the body of a function.
("prog1" [&or stringp def-form] def-body)
def-form])))))
(let ((newrules nil))
(while rules
(if (symbolp (car rules))
(setq rules (append (symbol-value (pop rules)) rules))
(push (pop rules) newrules)))
(setq rules (nreverse newrules)))
(let* ((offset 0)
(branches '())
;; We'd like to use a real DFA-based lexer, usually, but since Emacs
;; doesn't have one yet, we fallback on building one large regexp
;; and use groups to determine which branch of the regexp matched.
(re
(mapconcat
(lambda (rule)
(let* ((orig-re (eval (car rule) t))
(re orig-re))
(when (and (assq 0 rule) (cdr rules))
;; If there's more than 1 rule, and the rule want to apply
;; highlight to match 0, create an extra group to be able to
;; tell when *this* match 0 has succeeded.
(incf offset)
(setq re (concat "\\(" re "\\)")))
(setq re (syntax-propertize--shift-groups-and-backrefs re offset))
(let ((code '())
(condition
(cond
((assq 0 rule) (if (zerop offset) t
`(match-beginning ,offset)))
((and (cdr rule) (null (cddr rule)))
`(match-beginning ,(+ offset (car (cadr rule)))))
(t
`(or ,@(mapcar
(lambda (case)
`(match-beginning ,(+ offset (car case))))
(cdr rule))))))
(nocode t)
(offset offset))
;; If some of the subgroup rules include Elisp code, then we
;; need to set the match-data so it's consistent with what the
;; code expects. If not, then we can simply use shifted
;; offset in our own code.
(unless (zerop offset)
(dolist (case (cdr rule))
(unless (stringp (cadr case))
(setq nocode nil)))
(unless nocode
(push `(let ((md (match-data 'ints)))
;; Keep match 0 as is, but shift everything else.
(setcdr (cdr md) (nthcdr ,(* (1+ offset) 2) md))
(set-match-data md))
code)
(setq offset 0)))
;; Now construct the code for each subgroup rules.
(dolist (case (cdr rule))
(cl-assert (null (cddr case)))
(let* ((gn (+ offset (car case)))
(action (nth 1 case))
(thiscode
(cond
((stringp action)
`((put-text-property
(match-beginning ,gn) (match-end ,gn)
'syntax-table
',(string-to-syntax action))))
((eq (car-safe action) 'ignore)
(cdr action))
((eq (car-safe action) 'prog1)
(if (stringp (nth 1 action))
`((put-text-property
(match-beginning ,gn) (match-end ,gn)
'syntax-table
',(string-to-syntax (nth 1 action)))
,@(nthcdr 2 action))
`((let ((mb (match-beginning ,gn))
(me (match-end ,gn)))
,(macroexp-let2 nil syntax (nth 1 action)
`(progn
(if ,syntax
(put-text-property
mb me 'syntax-table ,syntax))
,@(nthcdr 2 action)))))))
(t
`((let ((mb (match-beginning ,gn))
(me (match-end ,gn))
(syntax ,action))
(if syntax
(put-text-property
mb me 'syntax-table syntax))))))))
(if (or (not (cddr rule)) (zerop gn))
(setq code (nconc (nreverse thiscode) code))
(push `(if (match-beginning ,gn)
;; Try and generate clean code with no
;; extraneous progn.
,(if (null (cdr thiscode))
(car thiscode)
`(progn ,@thiscode)))
code))))
(push (cons condition (nreverse code))
branches))
(incf offset (regexp-opt-depth orig-re))
re))
rules
"\\|")))
`(lambda (start end)
(goto-char start)
(while (and (< (point) end)
(re-search-forward ,re end t))
(cond ,@(nreverse branches))))))