这是关于MuMaMo的问题。如果将nxhtml/util/mumamo-fun.el的末尾添加到以下代码的末尾：
(defun rst-bk-latex-directive-chunk (pos min max)
"Find math chunks. Return range and 'latex-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(mumamo-quick-static-chunk pos min max ".. math::\n\n" ".." nil 'latex-mode t))
;;;###autoload
(define-mumamo-multi-major-mode rst-bk-mumamo-mode
"Turn on multiple major modes for Python with RestructuredText docstrings."
("ReST" rst-mode
(
rst-bk-latex-directive-chunk
)))
(add-to-list 'auto-mode-alist '("\\.rst\\'" . rst-bk-mumamo-mode))
还
(load "~/.emacs.d/site-lisp/nxhtml/autostart.el")
(require 'mumamo)
(require 'mumamo-fun)
到~/.emacs
字符串.. math::\n\n和..之间的块是乳胶模式的。
我的问题是 - 如何在给定模式的两个给定正则表达式之间创建一个块？
修改：
我在mumamo-fun.el：
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; ReST + math + bash + python + cl
;; LaTeX:
(defun rst-bk-mumamo-math-regexp-chunk-start (pos max)
(let ((where (mumamo-chunk-start-fw-re pos max
"\\.\\. math::\\(.?\\|\n\\)*?\n\n"
)))
(when where
(list where 'latex-mode))))
(defun rst-bk-mumamo-math-regexp-chunk-end (pos max)
(save-match-data
(mumamo-chunk-end-fw-re pos max
"\\(^[[:blank:]]+$\\|\n\\)+[^[:blank:]\n]"
)))
(defun rst-bk-mumamo-math-quick-regexp-chunk (pos
min
max)
(save-match-data
(mumamo-possible-chunk-forward pos max 'rst-bk-mumamo-math-regexp-chunk-start
'rst-bk-mumamo-math-regexp-chunk-end)))
(defun rst-bk-mumamo-math-directive (pos min max)
"Find math chunks. Return range and 'math-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(rst-bk-mumamo-math-quick-regexp-chunk pos min max))
(defun rst-bk-mumamo-math-inline-chunk (pos min max)
"Find math chunks. Return range and 'math-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(mumamo-quick-static-chunk pos min max ":math:`" "`" nil 'math-mode t))
;; bash:
(defun rst-bk-mumamo-sh-regexp-chunk-start (pos max)
(let ((where (mumamo-chunk-start-fw-re pos max "\\.\\. code-block:: bash\\(.\\|\n\\)*?\n\n")))
(when where
(list where 'sh-mode))))
(defun rst-bk-mumamo-sh-regexp-chunk-end (pos max)
(save-match-data
(mumamo-chunk-end-fw-re pos max
"\\(^[[:blank:]]+$\\|\n\\)+[^[:blank:]\n]"
)))
(defun rst-bk-mumamo-sh-quick-regexp-chunk (pos
min
max)
(save-match-data
(mumamo-possible-chunk-forward pos max 'rst-bk-mumamo-sh-regexp-chunk-start
'rst-bk-mumamo-sh-regexp-chunk-end)))
(defun rst-bk-mumamo-sh-directive (pos min max)
"Find math chunks. Return range and 'sh-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(rst-bk-mumamo-sh-quick-regexp-chunk pos min max))
;; python:
(defun rst-bk-mumamo-py-regexp-chunk-start (pos max)
(let ((where (mumamo-chunk-start-fw-re pos max "\\.\\. code-block:: py\\(thon\\)?\\(.\\|\n\\)*?\n\n")))
(when where
(list where 'python-mode))))
(defun rst-bk-mumamo-py-regexp-chunk-end (pos max)
(save-match-data
(mumamo-chunk-end-fw-re pos max "\\(^[[:blank:]]+$\\|\n\\)+[^[:blank:]\n]")))
(defun rst-bk-mumamo-py-quick-regexp-chunk (pos
min
max)
(save-match-data
(mumamo-possible-chunk-forward pos max 'rst-bk-mumamo-py-regexp-chunk-start
'rst-bk-mumamo-py-regexp-chunk-end)))
(defun rst-bk-mumamo-py-directive (pos min max)
"Find math chunks. Return range and 'py-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(rst-bk-mumamo-py-quick-regexp-chunk pos min max))
;; cl:
(defun rst-bk-mumamo-cl-regexp-chunk-start (pos max)
(let ((where (mumamo-chunk-start-fw-re pos max "\\.\\. code-block:: cl\\(.\\|\n\\)*?\n\n")))
(when where
(list where 'emacs-lisp-mode))))
(defun rst-bk-mumamo-cl-regexp-chunk-end (pos max)
(save-match-data
(mumamo-chunk-end-fw-re pos max "\\(^[[:blank:]]+$\\|\n\\)+[^[:blank:]\n]")))
(defun rst-bk-mumamo-cl-quick-regexp-chunk (pos
min
max)
(save-match-data
(mumamo-possible-chunk-forward pos max 'rst-bk-mumamo-cl-regexp-chunk-start
'rst-bk-mumamo-cl-regexp-chunk-end)))
(defun rst-bk-mumamo-cl-directive (pos min max)
"Find math chunks. Return range and 'cl-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(rst-bk-mumamo-cl-quick-regexp-chunk pos min max))
;;;###autoload
(define-mumamo-multi-major-mode rst-bk-mumamo-mode
"Turn on multiple major modes for Python with RestructuredText docstrings."
("ReST" rst-mode (
rst-bk-mumamo-math-directive
rst-bk-mumamo-math-inline-chunk
rst-bk-mumamo-sh-directive
rst-bk-mumamo-py-directive
)))
在(provide 'mumamo-fun)之前。
然后在.emacs：
(load "~/.emacs.d/site-lisp/nxhtml/autostart.el")
;; Mumamo is making emacs 23.3 freak out:
(when (and (equal emacs-major-version 23)
(equal emacs-minor-version 3))
(eval-after-load "bytecomp"
'(add-to-list 'byte-compile-not-obsolete-vars
'font-lock-beginning-of-syntax-function))
;; tramp-compat.el clobbers this variable!
(eval-after-load "tramp-compat"
'(add-to-list 'byte-compile-not-obsolete-vars
'font-lock-beginning-of-syntax-function)))
(require 'mumamo)
(load "mumamo-fun")
(add-to-list 'auto-mode-alist '("\\.rst\\'" . rst-bk-mumamo-mode))
现在当我打开ReST文件时，我有：
math:`TEXT`
.. math:
TEXT
.. code-block: bash
TEXT
和
.. code-block: py
TEXT
的python-mode。
编辑2 ：
如果添加
("^ \\(.+\\)" 1 'font-latex-math-face)
之后
(dolist (item
'(("\\(^\\|[^\\]\\)\\(&+\\)" 2 'font-latex-warning-face)
("\\$\\$\\([^$]+\\)\\$\\$" 1 'font-latex-math-face)
;; HERE
...
到AUCTeX的font-latex-make-user-keywords中的font-latex.el，然后会在.. math::下获得数学模式。
答案 0 :(得分：2)
关键功能mumamo-possible-chunk-forward与mumamo-chunk-start-fw-re和mumamo-chunk-end-fw-re结合使用 - 后两者执行正则表达式匹配。
以下是诀窍：
(defun regexp-chunk-start (pos max)
(let ((where (mumamo-chunk-start-fw-re pos max "math:\n\n")))
(when where
(list where 'latex-mode))))
(defun regexp-chunk-end (pos max)
(save-match-data
(mumamo-chunk-end-fw-re pos max "\\.\\.")))
(defun mumamo-quick-regexp-chunk (pos
min
max)
(save-match-data
(mumamo-possible-chunk-forward pos max 'regexp-chunk-start
'regexp-chunk-end)))
(defun rst-bk-latex-directive (pos min max)
"Find math chunks. Return range and 'latex-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(mumamo-quick-regexp-chunk pos min max))
;;;###autoload
(define-mumamo-multi-major-mode rst-bk-mumamo-mode
"Turn on multiple major modes for Python with RestructuredText docstrings."
("ReST" rst-mode (rst-bk-latex-directive)))
(add-to-list 'auto-mode-alist '("\\.rst\\'" . rst-bk-mumamo-mode))
我复制了您提供的自动加载内容。坦率地说，我不明白应该如何加载MuMaMo主要模式。但是，我能够通过在ReST文件中手动调用mumamo-alias-rst-bk-latex-directive来测试该功能。
MuMaMo的API有点不幸。匹配缓冲区域的功能分散在三个独立的功能上，这使得重用变得困难。我希望您可能希望在模式匹配工作后定义许多正则表达式。
所以这是另一个版本，它包含了marco define-quick-regexp-chunk中的所有内容：
(defmacro define-quick-regexp-chunk (regexp-chunk-fun begin-mark end-mark mode)
(let ((regexp-chunk-start-fun (gensym))
(regexp-chunk-end-fun (gensym)))
`(progn
(defun ,regexp-chunk-start-fun (pos max)
(let ((where (mumamo-chunk-start-fw-re pos max ,begin-mark)))
(when where
(list where ,mode))))
(defun ,regexp-chunk-end-fun (pos max)
(save-match-data
(mumamo-chunk-end-fw-re pos max ,end-mark)))
(defun ,regexp-chunk-fun (pos
min
max)
(save-match-data
(mumamo-possible-chunk-forward pos max ',regexp-chunk-start-fun
',regexp-chunk-end-fun))))))
;; switch to latex-mode in between "math:\n\n" ".."
;; defines a function named "rst-bk-latex-directive" which should be called by MuMaMo
(define-quick-regexp-chunk rst-bk-latex-directive "math:\n\n" "\\.\\." 'latex-mode)
;;;###autoload
(define-mumamo-multi-major-mode rst-bk-mumamo-mode
"Turn on multiple major modes for Python with RestructuredText docstrings."
("ReST" rst-mode (rst-bk-latex-directive)))
(add-to-list 'auto-mode-alist '("\\.rst\\'" . rst-bk-mumamo-mode))
它完全相同，但现在我可以使用define-quick-regexp-chunk轻松定义许多正则表达式分隔的区域。请注意，您必须double escape the dots (.)。
查看nxHtml sources (in /util/mumamo-fun.el)中noweb2 chunk的定义，了解如何使用MuMaMo的regexp函数的更高级示例。