;;; mumamo-fun.el --- Multi major mode functions
;;
;; Author: Lennart Borgman (lennart O borgman A gmail O com)
;; Created: 2008-03-09T01:35:21+0100 Sun
;; Version: 0.51
;; Last-Updated: 2008-08-04T17:54:29+0200 Mon
;; URL:
;; Keywords:
;; Compatibility:
;;
;; Features that might be required by this library:
;;
;; `backquote', `bytecomp', `cl', `flyspell', `ispell', `mumamo',
;; `sgml-mode'.
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; 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, 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.
;;
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Commentary:
;;
;; Defines some "multi major modes" functions. See mumamo.el for more
;; information.
;;
;;;; Usage:
;;
;; See mumamo.el for how to use the multi major mode functions
;; defined here.
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Change log:
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Code:
(eval-when-compile (require 'cl))
(eval-when-compile (add-to-list 'load-path default-directory))
(eval-when-compile (require 'mumamo))
(eval-when-compile (require 'sgml-mode))
;;(mumamo-require)
;;;#autoload
;;(defun mumamo-fun-require ())
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; File wide key bindings
(defun mumamo-multi-mode-map ()
"Return mumamo multi mode keymap."
(symbol-value
(intern-soft (concat (symbol-name mumamo-multi-major-mode) "-map"))))
;; (defun mumamo-multi-mode-hook-symbol ()
;; "Return mumamo multi mode hook symbol."
;; (intern-soft (concat (symbol-name mumamo-multi-major-mode) "-hook")))
;;;###autoload
(defun mumamo-define-html-file-wide-keys ()
"Define keys in multi major mode keymap for html files."
(let ((map (mumamo-multi-mode-map)))
(define-key map [(control ?c) (control ?h) ?b] 'nxhtml-browse-file)
))
;; (defun mumamo-add-html-file-wide-keys (hook)
;; (add-hook hook 'mumamo-define-html-file-wide-keys)
;; )
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Chunk search routines for XHTML things
(defun mumamo-chunk-attr= (pos min max attr= attr=is-regex attr-regex submode)
"This should work similar to `mumamo-find-possible-chunk'.
See `mumamo-chunk-style=' for an example of use.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(mumamo-chunk-attr=-new pos max attr= attr=is-regex attr-regex submode))
(defun mumamo-chunk-attr=-new-fw-exc-fun (pos max)
;;(msgtrc "(mumamo-chunk-attr=-new-fw-exc-fun %s %s)" pos max)
(save-match-data
(let ((here (point))
first-dq
next-dq
(this-chunk (mumamo-get-existing-new-chunk-at pos)))
(if this-chunk
(goto-char (overlay-end this-chunk))
(goto-char (overlay-end mumamo-last-chunk)))
(setq first-dq (search-forward "\"" max t))
(unless (bobp)
(backward-char)
(condition-case err
(with-syntax-table (standard-syntax-table)
(setq next-dq (scan-sexps (point) 1)))
(error nil)))
(prog1
next-dq
(goto-char here)))))
(defun mumamo-chunk-attr=-new-find-borders-fun (start-border end-border dummy)
;;(setq borders (funcall find-borders-fun start-border end-border exc-mode))
(save-match-data
(let ((here (point))
(end2 (when end-border (1- end-border)))
start2)
(goto-char start-border)
(save-match-data
(setq start2 (search-forward "\"" (+ start-border 200) t)))
(goto-char here)
(list start2 end2))))
(defun mumamo-chunk-attr=-new (pos
;;min
max
attr=
attr=is-regex
attr-regex
submode)
;;(message "\n(mumamo-chunk-attr=-new %s %s %s %s %s %s)" pos max attr= attr=is-regex attr-regex submode)
;;(mumamo-condition-case err
(condition-case err
(save-match-data
(let ((here (point))
(next-attr= (progn
;; fix-me:
(if (not attr=is-regex)
(goto-char (+ pos (length attr=)))
(goto-char pos)
(skip-chars-forward "a-zA-Z="))
(goto-char pos)
(if attr=is-regex
(re-search-forward attr= max t)
(search-forward attr= max t))))
next-attr-sure
;;next-attr=
start start-border
end end-border
exc-mode
borders
exc-start-next
exc-end-next
exc-start-next
exc-end-next
(tries 0)
(min (1- pos))
look-max
)
;; make sure if we have find prev-attr= or not
(unless (eq (char-after) ?\")
(setq next-attr= nil))
(when next-attr=
(forward-char)
(skip-chars-forward "^\"")
(setq look-max (+ (point) 2)))
(while (and next-attr=
(< min (point))
(not next-attr-sure)
(< tries 5))
;;(msgtrc "attr=-new: min=%s, point=%s" min (point))
(setq tries (1+ tries))
;;(if (not (re-search-backward "<[^?]" (- min 300) t))
(if (not (re-search-backward "<[^?]\\|\?>" (- min 300) t))
(setq next-attr= nil)
;;(if (looking-at attr-regex)
(if (let ((here (point)))
(prog1
(re-search-forward attr-regex look-max t)
(goto-char here)))
;;(if (mumamo-end-in-code (point) next-attr= 'php-mode)
(setq next-attr-sure 'found)
(unless (bobp)
(backward-char)
;;(msgtrc "attr=-new 1: min=%s, point=%s" min (point))
(setq next-attr= (if attr=is-regex
(re-search-backward attr= (- min 300) t)
(search-backward attr= (- min 300) t)))))))
(unless next-attr-sure (setq next-attr= nil))
;; find prev change and if inside style= the next change
(when next-attr=
(setq exc-start-next (match-beginning 1))
(setq exc-end-next (match-end 2))
(when (>= exc-start-next pos)
(if (> pos exc-end-next)
(progn
(setq start (+ (match-end 2) 1))
;;(setq start-border (+ (match-end 2) 2))
)
(setq exc-mode submode)
(setq start (match-beginning 1))
(setq start-border (match-beginning 2))
(setq end (1+ (match-end 2)))
(setq end-border (1- end)))
))
;; find next change
(unless end
(if start
(goto-char start)
(goto-char pos)
(search-backward "<" min t))
;;(msgtrc "attr=-new 2: min=%s, point=%s" min (point))
(setq next-attr= (if attr=is-regex
(re-search-forward attr= max t)
(search-forward attr= max t)))
(when (and next-attr=
(search-backward "<" min t))
(when (looking-at attr-regex)
(setq end (match-beginning 1)))))
(when start (assert (>= start pos) t))
(when end (assert (<= pos end) t))
;;(message "start-border=%s end-border=%s" start-border end-border)
(when (or start-border end-border)
(setq borders (list start-border end-border nil)))
;; (message "mumamo-chunk-attr=-new: %s"
;; (list start
;; end
;; exc-mode
;; borders
;; nil ;; parseable-by
;; 'mumamo-chunk-attr=-new-fw-exc-fun ;; fw-exc-fun
;; 'mumamo-chunk-attr=-new-find-borders-fun ;; find-borders-fun
;; ))
(goto-char here)
(setq end nil)
(when (or start end)
(list start
end
exc-mode
borders
nil ;; parseable-by
'mumamo-chunk-attr=-new-fw-exc-fun ;; fw-exc-fun
'mumamo-chunk-attr=-new-find-borders-fun ;; find-borders-fun
))))
(error (mumamo-display-error 'mumamo-chunk-attr=-new "%s" (error-message-string err)))
))
;;;; xml pi
(defvar mumamo-xml-pi-mode-alist
'(("php" . php-mode)
("python" . python-mode))
"Alist used by `mumamo-chunk-xml-pi' to get exception mode." )
;; Fix-me: make it possible to make the borders part of the php chunk
;; so that parsing of them by nxml may be skipped. Or, rather if the
;; borders are not part of the chunk then assume nxml can not parse
;; the chunk and the borders.
;; (defun mumamo-search-bw-exc-start-xml-pi-1 (pos min lt-chars)
;; "Helper for `mumamo-chunk-xml-pi'.
;; POS is where to start search and MIN is where to stop.
;; LT-CHARS is just at pos is end of 1000 pos)
;;; (assert (and (= (char-after pos) ??)
;;; (= (char-after (1+ pos)) ?>)))
(save-excursion
(save-restriction
(widen)
(save-match-data
(when (search-backward "<" (- pos 150) t)
(when (looking-at (rx line-start "<\?xml" (1+ space)))
(mumamo-msgfntfy "mumamo-xml-pi-end-is-xml-end %s => t" pos)
t)))))))
;; (defun mumamo-search-bw-exc-end-xml-pi (pos min)
;; "Helper for `mumamo-chunk-xml-pi'.
;; POS is where to start search and MIN is where to stop."
;; ;; Fix me: merge xml header
;; (mumamo-msgfntfy "mumamo-search-bw-exc-end-xml-pi %s %s" pos min)
;; ;;(let ((end-pos (mumamo-chunk-end-bw-str pos min "?>")))
;; (let ((end-pos (mumamo-chunk-end-bw-str-inc pos min "?>")))
;; (mumamo-msgfntfy " end-pos=%s" end-pos)
;; (when end-pos
;; (unless (or (mumamo-xml-pi-end-is-xml-end end-pos)
;; (= (save-restriction
;; (widen)
;; (char-after (- end-pos 1)))
;; ?<))
;; (mumamo-msgfntfy " returning end-pos")
;; end-pos))))
(defun mumamo-search-fw-exc-end-xml-pi (pos max)
"Helper for `mumamo-chunk-xml-pi'.
POS is where to start search and MAX is where to stop."
;; Fix me: merge xml header
;;(let ((end-pos (mumamo-chunk-end-fw-str pos max "?>")))
(save-match-data
(let ((end-pos (mumamo-chunk-end-fw-str-inc pos max "?>")))
(when end-pos
(unless (mumamo-xml-pi-end-is-xml-end end-pos)
end-pos)))))
(defun mumamo-search-fw-exc-start-xml-pi-1 (pos max lt-chars)
"Helper for `mumamo-chunk-xml-pi'.
POS is where to start search and MAX is where to stop.
Used in `mumamo-search-fw-exc-start-xml-pi'. For an explanation
of LT-CHARS see `mumamo-search-bw-exc-start-xml-pi-1'."
(goto-char pos)
(skip-chars-backward "a-zA-Z")
;;(let ((end-out (mumamo-chunk-start-fw-str (point) max lt-chars)))
(let ((end-out (mumamo-chunk-start-fw-str-inc (point) max lt-chars))
spec
exc-mode
hit)
(when (looking-at "xml")
(if t ;(= 1 pos)
(setq end-out (mumamo-chunk-start-fw-str-inc (1+ (point)) max lt-chars))
(setq end-out nil)))
(when end-out
;; Get end-out:
(if (looking-at (rx (0+ (any "a-z"))))
(progn
;;(setq end-out (match-end 0))
(setq end-out (- (match-beginning 0) 2))
(setq spec (match-string-no-properties 0))
(setq exc-mode (assoc spec mumamo-xml-pi-mode-alist))
(if exc-mode
(setq exc-mode (cdr exc-mode))
(setq exc-mode 'php-mode))
(setq end-out (list end-out exc-mode nil))
)
(setq end-out nil))
end-out)))
(defun mumamo-search-fw-exc-start-xml-pi-old (pos max)
"Helper for `mumamo-chunk-xml-pi'.
POS is where to start search and MAX is where to stop."
(mumamo-search-fw-exc-start-xml-pi-1 pos max "" can be handled.
;;
;; Fix-me: Maybe generalize for other values than ")
(here (point)))
(if (and inc) ;; exc-mode)
(progn
(when start
;;(setq start-border (+ start (length begin-mark)))
(goto-char (+ start (length begin-mark)))
(skip-chars-forward "=a-zA-Z")
(setq start-border (point))
)
(when end
(setq end-border
(- end (length end-mark)))))
(if (and (not inc) (not exc-mode))
(progn
(when start
(setq start-border
(+ start (length end-mark))))
(when end
(setq end-border (- end (length begin-mark)))
;;(goto-char end)
;;(skip-chars-forward "=a-zA-Z")
;;(setq end-border (point))
))))
(goto-char here)
(when (or start-border end-border)
(list start-border end-border))))
(defun mumamo-chunk-xml-pi (pos min max)
"Find process instruction, . Return range and wanted mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
;; (mumamo-find-possible-chunk pos min max
;; 'mumamo-search-bw-exc-start-xml-pi
;; 'mumamo-search-bw-exc-end-xml-pi
;; 'mumamo-search-fw-exc-start-xml-pi-old
;; 'mumamo-search-fw-exc-end-xml-pi
;; 'mumamo-find-borders-xml-pi)
(mumamo-possible-chunk-forward pos max
'mumamo-search-fw-exc-start-xml-pi-new
'mumamo-search-fw-exc-end-xml-pi
'mumamo-find-borders-xml-pi))
;;;; "))
;; (defun mumamo-search-fw-exc-start-inlined-style-old (pos max)
;; "Helper for `mumamo-chunk-inlined-style'.
;; POS is where to start search and MAX is where to stop."
;; (goto-char (1+ pos))
;; (skip-chars-backward "^<")
;; ;; Handle ")))
;; (defun mumamo-chunk-inlined-style-old (pos min max)
;; "Find . Return range and 'css-mode.
;; See `mumamo-find-possible-chunk' for POS, MIN and MAX."
;; (mumamo-find-possible-chunk pos min max
;; 'mumamo-search-bw-exc-start-inlined-style
;; 'mumamo-search-bw-exc-end-inlined-style
;; 'mumamo-search-fw-exc-start-inlined-style-old
;; 'mumamo-search-fw-exc-end-inlined-style))
(defun mumamo-search-fw-exc-start-inlined-style (pos max)
"Helper for `mumamo-chunk-inlined-style'.
POS is where to start search and MAX is where to stop."
(goto-char (1+ pos))
(skip-chars-backward "^<")
;; Handle .... Return range and 'css-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(mumamo-possible-chunk-forward pos max
'mumamo-search-fw-exc-start-inlined-style
'mumamo-search-fw-exc-end-inlined-style))
;;;; "))
;; (defun mumamo-search-fw-exc-start-inlined-script-old (pos max)
;; "Helper for `mumamo-chunk-inlined-script'.
;; POS is where to start search and MAX is where to stop."
;; (goto-char (1+ pos))
;; (skip-chars-backward "^<")
;; ;; Handle ")))
;; (defun mumamo-chunk-inlined-script-old (pos min max)
;; "Find . Return range and 'javascript-mode.
;; See `mumamo-find-possible-chunk' for POS, MIN and MAX."
;; (mumamo-find-possible-chunk pos min max
;; 'mumamo-search-bw-exc-start-inlined-script
;; 'mumamo-search-bw-exc-end-inlined-script
;; 'mumamo-search-fw-exc-start-inlined-script-old
;; 'mumamo-search-fw-exc-end-inlined-script))
(defun mumamo-search-fw-exc-start-inlined-script (pos max)
"Helper for `mumamo-chunk-inlined-script'.
POS is where to start search and MAX is where to stop."
(goto-char (1+ pos))
(skip-chars-backward "^<")
;; Handle .... Return range and 'javascript-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(mumamo-possible-chunk-forward pos max
'mumamo-search-fw-exc-start-inlined-script
'mumamo-search-fw-exc-end-inlined-script))
;;;; on[a-z]+=\"javascript:"
(defconst mumamo-onjs=-attr=
(rx
;;"on[a-z]+="
(or "onclick" "ondblclick" "onmousedown" "onmousemove" "onmouseout" "onmouseover" "onmouseup" "onkeydown" "onkeypress" "onkeyup")
"="))
(defconst mumamo-onjs=-attr-regex
(rx point
(or "<" "?>")
(* (not (any ">")))
space
(submatch
;;"on" (1+ (any "a-za-z"))
(or "onclick" "ondblclick" "onmousedown" "onmousemove" "onmouseout" "onmouseover" "onmouseup" "onkeydown" "onkeypress" "onkeyup")
"=")
(0+ space)
?\"
(submatch
(opt "javascript:")
(0+
(not (any "\""))))
))
(defun mumamo-chunk-onjs=(pos min max)
"Find javascript on...=\"...\". Return range and 'javascript-mode."
(mumamo-chunk-attr= pos min max mumamo-onjs=-attr= t mumamo-onjs=-attr-regex
'javascript-mode))
;;;; py:somthing=\"python\"
(defconst mumamo-py:=-attr= "py:[a-z]+=")
(defconst mumamo-py:=-attr-regex
(rx point
(or "<" "?>")
(* (not (any ">")))
space
(submatch
"py:" (1+ (any "a-za-z"))
"=")
(0+ space)
?\"
(submatch
(0+
(not (any "\""))))
))
(defun mumamo-chunk-py:=(pos min max)
"Find python py:...=\"...\". Return range and 'python-mode."
(mumamo-chunk-attr= pos min max mumamo-py:=-attr= t mumamo-py:=-attr-regex
'python-mode))
(defun mumamo-chunk-py:match (pos min max)
(save-match-data
(let ((here (point))
(py:match (progn
(goto-char pos)
(re-search-forward (rx "py:match"
(1+ space)
(0+ (not (any ">")))
word-start
(submatch "path=")
(0+ space)
?\"
(submatch
(0+
(not (any "\"")))))
max t)))
start end borders
)
(when py:match
(setq start (match-beginning 1))
(setq end (match-end 2))
(setq borders (list (match-end 1) (1- end)))
)
(goto-char here)
(when start
(list start
end
'python-mode
borders
nil ;; parseable-by
'mumamo-chunk-attr=-new-fw-exc-fun ;; fw-exc-fun
'mumamo-chunk-attr=-new-find-borders-fun ;; find-borders-fun
)))))
;;;; style=
(defconst mumamo-style=start-regex
(rx "<"
(0+ (not (any ">")))
space
(submatch "style=")
(0+ space)
?\"
(submatch
(0+
(not (any "\""))))
))
(defun mumamo-chunk-style=(pos min max)
"Find style=\"...\". Return range and 'css-mode."
(mumamo-chunk-attr= pos min max "style=" nil mumamo-style=start-regex
'css-mode))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; HTML w html-mode
(put 'mumamo-alt-php-tags-mode 'permanent-local t)
(define-minor-mode mumamo-alt-php-tags-mode
"Minor mode for using '(?php' instead of ' in strings.
There is no reason to use this minor mode unless you want XML
validation and/or completion in your php file. If you do not
want that then you can simply use a multi major mode based on
`html-mode' instead of `nxml-mode'/`nxhtml-mode'. Or, of course,
just `php-mode' if there is no html code in the file."
:lighter "" nil t)
(replace-match "?)"))
(goto-char here))))
(save-restriction
(let ((here (point)))
(widen)
(goto-char (point-min))
(while (search-forward "(?php" nil t)
(replace-match ""))
(goto-char here)))
(remove-hook 'write-contents-functions 'mumamo-alt-php-write-contents t)))
(defun mumamo-chunk-alt-php (pos min max)
"Find (?php ... ?), return range and `php-mode'.
Workaround for the problem that I can not tame `nxml-mode' to recognize "))
(basic-save-buffer-1)
(signal 'mumamo-error-ind-0 nil)))
(mumamo-error-ind-0)))
(set-buffer-modified-p nil))
(goto-char here))
;; saved, return t
t)
;;;###autoload
(define-mumamo-multi-major-mode nxml-mumamo-mode
"Turn on multiple major modes for (X)HTML with main mode `nxml-mode'.
This covers inlined style and javascript and PHP.
See also `mumamo-alt-php-tags-mode'."
("nXml Family" nxml-mode
(mumamo-chunk-xml-pi
mumamo-chunk-alt-php
mumamo-chunk-inlined-style
mumamo-chunk-inlined-script
mumamo-chunk-style=
mumamo-chunk-onjs=
)))
(add-hook 'nxml-mumamo-mode-hook 'mumamo-define-html-file-wide-keys)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Mason (not ready)
;; http://www.masonhq.com/docs/manual/Devel.html#examples_and_recommended_usage
(defun mumamo-chunk-mason-perl-line (pos min max)
(mumamo-whole-line-chunk pos min max "%" 'perl-mode))
(defun mumamo-chunk-mason-perl-single (pos min max)
(mumamo-quick-static-chunk pos min max "<% " " %>" t 'perl-mode t))
(defun mumamo-chunk-mason-perl-block (pos min max)
(mumamo-quick-static-chunk pos min max "<%perl>" "" t 'perl-mode t))
(defun mumamo-chunk-mason-perl-init (pos min max)
(mumamo-quick-static-chunk pos min max "<%init>" "" t 'perl-mode t))
(defun mumamo-chunk-mason-perl-once (pos min max)
(mumamo-quick-static-chunk pos min max "<%once>" "" t 'perl-mode t))
(defun mumamo-chunk-mason-perl-cleanup (pos min max)
(mumamo-quick-static-chunk pos min max "<%cleanup>" "" t 'perl-mode t))
(defun mumamo-chunk-mason-perl-shared (pos min max)
(mumamo-quick-static-chunk pos min max "<%shared>" "" t 'perl-mode t))
(defun mumamo-chunk-mason-simple-comp (pos min max)
(mumamo-quick-static-chunk pos min max "<& " " &>" t 'text-mode t))
(defun mumamo-chunk-mason-args (pos min max)
;; Fix-me: perl-mode is maybe not the best here?
(mumamo-quick-static-chunk pos min max "<%args>" "" t 'perl-mode t))
(defun mumamo-chunk-mason-doc (pos min max)
(mumamo-quick-static-chunk pos min max "<%doc>" "" t 'mumamo-comment-mode t))
(defun mumamo-chunk-mason-text (pos min max)
(mumamo-quick-static-chunk pos min max "<%text>" "" t 'text-mode t))
;; component calls with content
;; (defun mumamo-chunk-mason-compcont-bw-exc-start-fun (pos min)
;; (let ((exc-start (mumamo-chunk-start-bw-str-inc pos min "<&| ")))
;; (and exc-start
;; (<= exc-start pos)
;; (cons exc-start 'html-mode))))
;; (defun mumamo-chunk-mason-compcont-fw-exc-start-fun-old (pos max)
;; (mumamo-chunk-start-fw-str-inc pos max "<&| "))
(defun mumamo-chunk-mason-compcont-fw-exc-end-fun (pos max)
(mumamo-chunk-end-fw-str-inc pos max ""))
(defun mumamo-chunk-mason-compcont-find-borders-fun (start end dummy)
(when dummy
(list
(when start
(save-match-data
(let ((here (point))
ret)
(goto-char start)
(when (re-search-forward "[^>]* &>" end t)
(setq ret (point))
(goto-char here)
ret))
))
(when end (- end 4))
dummy)))
;; (defun mumamo-chunk-mason-compcont-old (pos min max)
;; (mumamo-find-possible-chunk-new pos
;; max
;; 'mumamo-chunk-mason-compcont-bw-exc-start-fun
;; 'mumamo-chunk-mason-compcont-fw-exc-start-fun-old
;; 'mumamo-chunk-mason-compcont-fw-exc-end-fun
;; 'mumamo-chunk-mason-compcont-find-borders-fun))
(defun mumamo-chunk-mason-compcont-fw-exc-start-fun (pos max)
(let ((where (mumamo-chunk-start-fw-str-inc pos max "<&| ")))
(when where
(list where 'html-mode nil))))
(defun mumamo-chunk-mason-compcont (pos min max)
(mumamo-possible-chunk-forward pos max
'mumamo-chunk-mason-compcont-fw-exc-start-fun
'mumamo-chunk-mason-compcont-fw-exc-end-fun
'mumamo-chunk-mason-compcont-find-borders-fun))
;;;###autoload
(define-mumamo-multi-major-mode mason-html-mumamo-mode
"Turn on multiple major modes for Mason using main mode `html-mode'.
This covers inlined style and javascript."
("Mason html Family" html-mode
(
mumamo-chunk-mason-perl-line
mumamo-chunk-mason-perl-single
mumamo-chunk-mason-perl-block
mumamo-chunk-mason-perl-init
mumamo-chunk-mason-perl-once
mumamo-chunk-mason-perl-cleanup
mumamo-chunk-mason-perl-shared
mumamo-chunk-mason-simple-comp
mumamo-chunk-mason-compcont
mumamo-chunk-mason-args
mumamo-chunk-mason-doc
mumamo-chunk-mason-text
mumamo-chunk-inlined-style
mumamo-chunk-inlined-script
mumamo-chunk-style=
mumamo-chunk-onjs=
)))
(add-hook 'mason-html-mumamo-mode-hook 'mumamo-define-html-file-wide-keys)
(mumamo-inherit-sub-chunk-family-locally 'mason-html-mumamo-mode 'mason-html-mumamo-mode)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Embperl
(defun mumamo-chunk-embperl-<- (pos min max)
"Find [- ... -], return range and `perl-mode'.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(mumamo-quick-static-chunk pos min max "[-" "-]" t 'perl-mode t))
(defun mumamo-chunk-embperl-<+ (pos min max)
"Find [+ ... +], return range and `perl-mode'.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(mumamo-quick-static-chunk pos min max "[+" "+]" t 'perl-mode nil))
(defun mumamo-chunk-embperl-... and <% ... %>.
(defun mumamo-chunk-ssjs-% (pos min max)
"Find <% ... %>. Return range and 'javascript-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(mumamo-quick-static-chunk pos min max "<%" "%>" t 'javascript-mode t))
(defconst mumamo-ssjs-tag-start-regex
(rx "")))
"runat"
(0+ space)
"="
(0+ space)
?\"
;;(or "text" "application")
;;"/"
;;(or "javascript" "ecmascript")
(or "server" "both" "server-proxy")
?\"
(0+ (not (any ">")))
">"
;; FIX-ME: Commented out because of bug in Emacs
;;
;;(optional (0+ space) ".... Return range and 'javascript-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
;; (mumamo-find-possible-chunk pos min max
;; 'mumamo-search-bw-exc-start-inlined-ssjs
;; 'mumamo-search-bw-exc-end-inlined-script
;; 'mumamo-search-fw-exc-start-inlined-ssjs-old
;; 'mumamo-search-fw-exc-end-inlined-script)
(mumamo-possible-chunk-forward pos max
'mumamo-search-fw-exc-start-inlined-ssjs
'mumamo-search-fw-exc-end-inlined-script))
;;;###autoload
(define-mumamo-multi-major-mode ssjs-html-mumamo-mode
"Turn on multiple major modes for SSJS with main mode `html-mode'.
This covers inlined style and javascript."
("HTML Family" html-mode
(mumamo-chunk-inlined-style
mumamo-chunk-inlined-script
mumamo-chunk-inlined-ssjs
mumamo-chunk-ssjs-%
mumamo-chunk-style=
mumamo-chunk-onjs=
)))
(add-hook 'html-mumamo-mode-hook 'mumamo-define-html-file-wide-keys)
(mumamo-inherit-sub-chunk-family 'ssjs-html-mumamo-mode)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; gsp
(defun mumamo-chunk-gsp (pos min max)
"Find <% ... %>. Return range and 'groovy-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(mumamo-quick-static-chunk pos min max "<%" "%>" t 'groovy-mode t))
;;;###autoload
(define-mumamo-multi-major-mode gsp-html-mumamo-mode
"Turn on multiple major modes for GSP with main mode `html-mode'.
This also covers inlined style and javascript."
("GSP HTML Family" html-mode
(mumamo-chunk-gsp
mumamo-chunk-inlined-style
mumamo-chunk-inlined-script
mumamo-chunk-style=
mumamo-chunk-onjs=
)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; jsp - Java Server Pages
(defun mumamo-chunk-jsp (pos min max)
"Find <% ... %>. Return range and 'java-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(mumamo-quick-static-chunk pos min max "<%" "%>" t 'java-mode t))
;;;###autoload
(define-mumamo-multi-major-mode jsp-html-mumamo-mode
"Turn on multiple major modes for JSP with main mode `html-mode'.
This also covers inlined style and javascript."
("JSP HTML Family" html-mode
(mumamo-chunk-jsp
mumamo-chunk-inlined-style
mumamo-chunk-inlined-script
mumamo-chunk-style=
mumamo-chunk-onjs=
)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; eruby
;; Fix-me: Maybe take care of <%= and <%- and -%>, but first ask the
;; ruby people if this is worth doing.
;;
;; See also http://wiki.rubyonrails.org/rails/pages/UnderstandingViews
(defun mumamo-chunk-eruby (pos min max)
"Find <% ... %>. Return range and 'ruby-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(let ((chunk (mumamo-quick-static-chunk pos min max "<%" "%>" t 'ruby-mode t)))
(when chunk
;; Put indentation type on 'mumamo-next-indent on the chunk:
;; Fix-me: use this!
(setcdr (last chunk) '(mumamo-template-indentor))
chunk)))
(defun mumamo-chunk-eruby-quoted (pos min max)
"Find \"<%= ... %>\". Return range and 'ruby-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX.
This is a workaround for problems with strings."
(let ((chunk (mumamo-quick-static-chunk pos min max "\"<%=" "%>\"" t 'ruby-mode t)))
(when chunk
;; Put indentation type on 'mumamo-next-indent on the chunk:
;; Fix-me: use this!
(setcdr (last chunk) '(mumamo-template-indentor))
chunk)))
(defun mumamo-chunk-eruby-comment (pos min max)
"Find <%# ... %>. Return range and 'ruby-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX.
This is needed since otherwise the end marker is thought to be
part of a comment."
(mumamo-quick-static-chunk pos min max "<%#" "%>" t 'mumamo-comment-mode t))
;; (defun mumamo-search-bw-exc-start-ruby (pos min)
;; "Helper for `mumamo-chunk-ruby'.
;; POS is where to start search and MIN is where to stop."
;; (let ((exc-start (mumamo-chunk-start-bw-str pos min "<%")))
;; (when (and exc-start
;; (<= exc-start pos))
;; (cons exc-start 'ruby-mode))))
;;;###autoload
(define-mumamo-multi-major-mode eruby-mumamo-mode
"Turn on multiple major mode for eRuby with unspecified main mode.
Current major-mode will be used as the main major mode."
("eRuby Family" nil
(mumamo-chunk-eruby-comment
mumamo-chunk-eruby
)))
;;;###autoload
(define-mumamo-multi-major-mode eruby-html-mumamo-mode
"Turn on multiple major modes for eRuby with main mode `html-mode'.
This also covers inlined style and javascript."
("eRuby Html Family" html-mode
(
mumamo-chunk-eruby-comment
mumamo-chunk-eruby
mumamo-chunk-inlined-style
mumamo-chunk-inlined-script
mumamo-chunk-style=
mumamo-chunk-onjs=
)))
;;;###autoload
(define-mumamo-multi-major-mode eruby-javascript-mumamo-mode
"Turn on multiple major modes for eRuby with main mode `javascript-mode'."
("eRuby Html Family" javascript-mode
(
mumamo-chunk-eruby-comment
mumamo-chunk-eruby-quoted
mumamo-chunk-eruby
;;mumamo-chunk-inlined-style
;;mumamo-chunk-inlined-script
;;mumamo-chunk-style=
;;mumamo-chunk-onjs=
)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; heredoc
(defcustom mumamo-heredoc-modes
'(
("HTML" html-mode)
("CSS" css-mode)
("JAVASCRIPT" javascript-mode)
("JAVA" java-mode)
("GROOVY" groovy-mode)
("SQL" sql-mode)
)
"Matches for heredoc modes.
The entries in this list have the form
(REGEXP MAJOR-MODE-SPEC)
where REGEXP is a regular expression that should match the
heredoc marker line and MAJOR-MODE-SPEC is the major mode spec to
use in the heredoc part.
The major mode spec is translated to a major mode using
`mumamo-major-mode-from-modespec'."
:type '(repeat
(list
regexp
(function :tag "Major mode")))
:group 'mumamo-modes)
(defun mumamo-mode-for-heredoc (marker)
"Return major mode associated with MARKER.
Use first match in `mumamo-heredoc-modes'.
If no match use `text-mode'."
(let ((mode (catch 'mode
(save-match-data
(dolist (rec mumamo-heredoc-modes)
(let ((regexp (nth 0 rec))
(mode (nth 1 rec)))
(when (string-match regexp marker)
(throw 'mode mode))))))))
(if mode
(mumamo-major-mode-from-modespec mode)
'text-mode)))
(defun mumamo-chunk-heredoc (pos min max lang)
"This should work similar to `mumamo-find-possible-chunk'.
POS, MIN and MAX have the same meaning as there.
LANG is the programming language.
Supported values are 'perl."
;; Fix-me: LANG
;; Fix-me: use mumamo-end-in-code
(mumamo-condition-case err
(let ((old-point (point)))
(goto-char pos)
(beginning-of-line)
(let (next-<<
(want-<< t)
heredoc-mark
end-mark-len
heredoc-line
delimiter
skipped
(skip-b "")
start-inner
end
exc-mode
fw-exc-fun
border-fun
allow-code-after
start-outer
ps
)
(goto-char pos)
(beginning-of-line)
(case lang
('sh
(setq allow-code-after t)
(while want-<<
(setq next-<< (search-forward "<<" max t))
(if (not next-<<)
(setq want-<< nil) ;; give up
;; Check inside string or comment.
(setq ps (parse-partial-sexp (line-beginning-position) (point)))
(unless (or (nth 3 ps) (nth 4 ps))
(setq want-<< nil))))
(when next-<<
(setq start-outer (- (point) 2))
(when (= (char-after) ?-)
(setq skip-b "\t*")
(unless (eolp) (forward-char)))
;; fix-me: space
(setq skipped (skip-chars-forward " \t"))
(when (memq (char-after) '(?\" ?\'))
(setq delimiter (list (char-after))))
(if (and (> skipped 0) (not delimiter))
(setq heredoc-mark "")
(when (looking-at (rx-to-string
`(and (regexp ,(if delimiter
(concat delimiter "\\([^\n<>;]+\\)" delimiter)
"\\([^ \t\n<>;]+\\)"))
(or blank line-end))))
(setq heredoc-mark (buffer-substring-no-properties
(match-beginning 1)
(match-end 1)))))
(when heredoc-mark
(setq heredoc-line (buffer-substring-no-properties (point-at-bol) (point-at-eol)))
(setq start-inner (1+ (point-at-eol)))
(setq end-mark-len (length heredoc-mark))
)))
('w32-ps (error "No support for windows power shell yet"))
('php
(while want-<<
(setq next-<< (search-forward "<<<" max t))
;; Check inside string or comment.
(if (not next-<<)
(setq want-<< nil) ;; give up
(setq ps (parse-partial-sexp (line-beginning-position) (- (point) 0)))
(unless (or (nth 3 ps) (nth 4 ps))
(setq want-<< nil))))
(when next-<<
(setq start-outer (- (point) 3))
(skip-chars-forward " \t")
(when (looking-at (concat "\\([^\n;]*\\)[[:blank:]]*\n"))
(setq heredoc-mark (buffer-substring-no-properties
(match-beginning 1)
(match-end 1)))
(setq heredoc-line (buffer-substring-no-properties (point-at-bol) (point-at-eol)))
;; fix-me: nowdoc
(when (and (= ?\' (string-to-char heredoc-mark))
(= ?\' (string-to-char (substring heredoc-mark (1- (length heredoc-mark))))))
(setq heredoc-mark (substring heredoc-mark 1 (- (length heredoc-mark) 1))))
(setq end-mark-len (1+ (length heredoc-mark)))
(setq start-inner (match-end 0)))))
('perl
(setq allow-code-after t)
(while want-<<
(setq next-<< (search-forward "<<" max t))
(if (not next-<<)
(setq want-<< nil) ;; give up
;; Check inside string or comment.
(setq ps (parse-partial-sexp (line-beginning-position) (point)))
(unless (or (nth 3 ps) (nth 4 ps))
(setq want-<< nil))))
(when next-<<
(setq start-outer (- (point) 2))
;; fix-me: space
(setq skipped (skip-chars-forward " \t"))
(when (memq (char-after) '(?\" ?\'))
(setq delimiter (list (char-after))))
(if (and (> skipped 0) (not delimiter))
(setq heredoc-mark "") ;; blank line
(when (looking-at (rx-to-string
`(and (regexp ,(if delimiter
(concat delimiter "\\([^\n;]*\\)" delimiter)
"\\([^ \t\n<>;]+\\)"))
(or blank ";"))))
(setq heredoc-mark (buffer-substring-no-properties
(match-beginning 1)
(match-end 1)))))
(when heredoc-mark
(setq heredoc-line (buffer-substring-no-properties (point-at-bol) (point-at-eol)))
;;(setq start-inner (1+ (match-end 0)))
(setq start-inner (1+ (point-at-eol)))
(setq end-mark-len (length heredoc-mark))
)))
('python
(unless (eobp) (forward-char))
(while want-<<
(setq next-<< (re-search-forward "\"\"\"\\|'''" max t))
(setq start-outer (- (point) 3))
(if (not next-<<)
(setq want-<< nil) ;; give up
;; Check inside string or comment.
(setq ps (parse-partial-sexp (line-beginning-position) (- (point) 3)))
(unless (or (nth 3 ps) (nth 4 ps))
(setq want-<< nil)))))
('ruby
(while want-<<
(setq next-<< (search-forward "<<" max t))
(if (not next-<<)
(setq want-<< nil) ;; give up
;; Check inside string or comment.
(setq ps (parse-partial-sexp (line-beginning-position) (point)))
(unless (or (nth 3 ps) (nth 4 ps))
(setq want-<< nil))))
(when next-<<
(setq start-outer (- (point) 2))
(when (= (char-after) ?-)
(setq skip-b "[ \t]*")
(forward-char))
(when (looking-at (concat "[^\n[:blank:]]*"))
(setq heredoc-mark (buffer-substring-no-properties
(match-beginning 0)
(match-end 0)))
(setq end-mark-len (length heredoc-mark))
(setq heredoc-line (buffer-substring-no-properties (point-at-bol) (point-at-eol)))
(setq start-inner (match-end 0)))))
(t (error "next-<< not implemented for lang %s" lang)))
(when start-inner (assert (<= pos start-inner) t))
(goto-char old-point)
(when (or start-inner end)
(let ((endmark-regexp
(case lang
('sh (concat "^" skip-b heredoc-mark "$"))
('php (concat "^" heredoc-mark ";?$"))
('perl (concat "^" heredoc-mark "$"))
('python (concat "^" heredoc-mark "[[:space:]]*"))
('ruby (concat "^" skip-b heredoc-mark "$"))
(t (error "mark-regexp not implemented for %s" lang)))))
;; Fix-me: rename start-inner <=> start-outer...
(setq border-fun `(lambda (start end exc-mode)
;; Fix-me: use lengths...
(list
(if ,allow-code-after nil (+ start (- ,start-inner ,start-outer 1)))
(when end (- end ,end-mark-len)))))
(setq fw-exc-fun `(lambda (pos max)
(save-match-data
(let ((here (point)))
(goto-char pos)
(prog1
(when (re-search-forward ,endmark-regexp max t)
(- (point) 1 ,(length heredoc-mark))
(- (point) 0)
)
(goto-char here)))))))
(setq exc-mode (mumamo-mode-for-heredoc heredoc-line))
(list start-inner end exc-mode nil nil fw-exc-fun nil)
;; Fix me: Add overriding for inner chunks (see
;; http://www.emacswiki.org/emacs/NxhtmlMode#toc13). Maybe
;; make fw-exc-fun a list (or a cons, since overriding is
;; probably all that I want to add)? And make the
;; corresponding chunk property a list too?
;;(list start-outer end exc-mode (list start-inner end) nil fw-exc-fun border-fun 'heredoc)
(list (if allow-code-after start-inner start-outer)
end exc-mode (list start-inner end) nil fw-exc-fun border-fun 'heredoc)
)))
(error (mumamo-display-error 'mumamo-chunk-heredoc
"%s" (error-message-string err)))))
;;;; Unix style sh heredoc
(defun mumamo-chunk-sh-heredoc (pos min max)
"Find sh here docs.
See `mumamo-find-possible-chunk' for POS, MIN
and MAX."
(let ((r (mumamo-chunk-heredoc pos min max 'sh)))
r))
;;;###autoload
(define-mumamo-multi-major-mode sh-heredoc-mumamo-mode
"Turn on multiple major modes for sh heredoc document.
See `mumamo-heredoc-modes' for how to specify heredoc major modes."
("SH HereDoc" sh-mode
(mumamo-chunk-sh-heredoc
)))
(mumamo-inherit-sub-chunk-family 'sh-heredoc-mumamo-mode)
;;;; PHP heredoc
(defun mumamo-chunk-php-heredoc (pos min max)
"Find PHP here docs.
See `mumamo-find-possible-chunk' for POS, MIN
and MAX."
(let ((r (mumamo-chunk-heredoc pos min max 'php)))
r))
;;;###autoload
(define-mumamo-multi-major-mode php-heredoc-mumamo-mode
"Turn on multiple major modes for PHP heredoc document.
See `mumamo-heredoc-modes' for how to specify heredoc major modes."
("PHP HereDoc" php-mode
(mumamo-chunk-php-heredoc
)))
(mumamo-inherit-sub-chunk-family 'php-heredoc-mumamo-mode)
(mumamo-inherit-sub-chunk-family-locally 'php-heredoc-mumamo-mode 'html-mumamo-mode)
;;;; Perl heredoc
(defun mumamo-chunk-perl-heredoc (pos min max)
"Find perl here docs.
See `mumamo-find-possible-chunk' for POS, MIN
and MAX."
(let ((r (mumamo-chunk-heredoc pos min max 'perl)))
r))
;;;###autoload
(define-mumamo-multi-major-mode perl-heredoc-mumamo-mode
"Turn on multiple major modes for Perl heredoc document.
See `mumamo-heredoc-modes' for how to specify heredoc major modes."
("Perl HereDoc" perl-mode
(mumamo-chunk-perl-heredoc
)))
(mumamo-inherit-sub-chunk-family 'perl-heredoc-mumamo-mode)
;;;###autoload
(define-mumamo-multi-major-mode cperl-heredoc-mumamo-mode
"Turn on multiple major modes for Perl heredoc document.
See `mumamo-heredoc-modes' for how to specify heredoc major modes."
("Perl HereDoc" cperl-mode
(mumamo-chunk-perl-heredoc
)))
(mumamo-inherit-sub-chunk-family 'cperl-heredoc-mumamo-mode)
;;;; Python heredoc
(defun mumamo-chunk-python-heredoc (pos min max)
"Find python here docs.
See `mumamo-find-possible-chunk' for POS, MIN
and MAX."
(let ((r (mumamo-chunk-heredoc pos min max 'python)))
r))
;;;###autoload
(define-mumamo-multi-major-mode python-heredoc-mumamo-mode
"Turn on multiple major modes for Perl heredoc document.
See `mumamo-heredoc-modes' for how to specify heredoc major modes."
("Python HereDoc" python-mode
(mumamo-chunk-python-heredoc
)))
(mumamo-inherit-sub-chunk-family 'python-heredoc-mumamo-mode)
;;;; Ruby heredoc
(defun mumamo-chunk-ruby-heredoc (pos min max)
"Find Ruby here docs.
See `mumamo-find-possible-chunk' for POS, MIN
and MAX."
(let ((r (mumamo-chunk-heredoc pos min max 'ruby)))
r))
;;;###autoload
(define-mumamo-multi-major-mode ruby-heredoc-mumamo-mode
"Turn on multiple major modes for Ruby heredoc document.
See `mumamo-heredoc-modes' for how to specify heredoc major modes."
("Ruby HereDoc" ruby-mode
(mumamo-chunk-ruby-heredoc
)))
(mumamo-inherit-sub-chunk-family 'ruby-heredoc-mumamo-mode)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Tex meta
;; (defun mumamo-search-bw-textext-start (pos min)
;; "Helper for `mumamo-chunk-textext'.
;; POS is where to start search and MIN is where to stop."
;; (let ((exc-start (mumamo-chunk-start-bw-str pos min "textext(\""))
;; (exc-mode 'plain-tex-mode))
;; (when exc-start
;; (when (<= exc-start pos)
;; (cons exc-start exc-mode)))))
(defconst mumamo-textext-end-regex
(rx "textext("
(0+
(0+ (not (any "\"()")))
?\"
(0+ (not (any "\"")))
?\"
)
(0+ (not (any "\"()")))
")"))
(defun mumamo-textext-test-is-end (pos)
"Helper for `mumamo-chunk-textext'.
Return POS if POS is at the end of textext chunk."
(when pos
(let ((here (point))
hit)
(goto-char (+ 2 pos))
(when (looking-back mumamo-textext-end-regex)
(setq hit t))
(goto-char here)
(when hit pos))))
;; (defun mumamo-search-bw-textext-end (pos min)
;; "Helper for `mumamo-chunk-textext'.
;; POS is where to start search and MIN is where to stop."
;; (let ((end (mumamo-chunk-end-bw-str pos min "\")"))
;; res)
;; (while (and end
;; (not (setq res (mumamo-textext-test-is-end end))))
;; (setq end (mumamo-chunk-end-bw-str (1- end) min "\")")))
;; res))
;; (defun mumamo-search-fw-textext-start-old (pos max)
;; "Helper for `mumamo-chunk-textext'.
;; POS is where to start search and MAX is where to stop."
;; (mumamo-chunk-start-fw-str pos max "textext(\""))
(defun mumamo-search-fw-textext-start (pos max)
"Helper for `mumamo-chunk-textext'.
POS is where to start search and MAX is where to stop."
(let ((where (mumamo-chunk-start-fw-str pos max "textext(\"")))
(when where
(list where 'plain-tex-mode))))
(defun mumamo-search-fw-textext-end (pos max)
"Helper for `mumamo-chunk-textext'.
POS is where to start search and MAX is where to stop."
(save-match-data
(let ((end (mumamo-chunk-end-fw-str pos max "\")")))
(mumamo-textext-test-is-end end))))
(defun mumamo-chunk-textext (pos min max)
"Find textext or TEX chunks. Return range and 'plain-tex-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
;; (mumamo-find-possible-chunk pos min max
;; 'mumamo-search-bw-textext-start
;; 'mumamo-search-bw-textext-end
;; 'mumamo-search-fw-textext-start-old
;; 'mumamo-search-fw-textext-end)
(mumamo-possible-chunk-forward pos max
'mumamo-search-fw-textext-start
'mumamo-search-fw-textext-end))
;; (defun mumamo-search-bw-verbatimtex-start (pos min)
;; "Helper for `mumamo-chunk-verbatimtextext'.
;; POS is where to start search and MIN is where to stop."
;; (let ((exc-start (mumamo-chunk-start-bw-str pos min "\nverbatimtex"))
;; (exc-mode 'plain-tex-mode))
;; (when exc-start
;; (when (<= exc-start pos)
;; (cons exc-start exc-mode)))))
;; (defun mumamo-search-bw-verbatimtex-end (pos min)
;; "Helper for `mumamo-chunk-verbatimtextext'.
;; POS is where to start search and MIN is where to stop."
;; (mumamo-chunk-end-bw-str pos min "\netex"))
;; (defun mumamo-search-fw-verbatimtex-start-old (pos max)
;; "Helper for `mumamo-chunk-verbatimtextext'.
;; POS is where to start search and MAX is where to stop."
;; (mumamo-chunk-start-fw-str pos max "\nverbatimtex"))
(defun mumamo-search-fw-verbatimtex-start (pos max)
"Helper for `mumamo-chunk-verbatimtextext'.
POS is where to start search and MAX is where to stop."
(let ((where (mumamo-chunk-start-fw-str pos max "\nverbatimtex")))
(when where
(list where 'plain-tex-mode))))
(defun mumamo-search-fw-verbatimtex-end (pos max)
"Helper for `mumamo-chunk-verbatimtextext'.
POS is where to start search and MAX is where to stop."
(save-match-data
(mumamo-chunk-end-fw-str pos max "\netex")))
(defun mumamo-chunk-verbatimtex (pos min max)
"Find verbatimtex - etex chunks. Return range and 'plain-tex-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
;; (mumamo-find-possible-chunk pos min max
;; 'mumamo-search-bw-verbatimtex-start
;; 'mumamo-search-bw-verbatimtex-end
;; 'mumamo-search-fw-verbatimtex-start-old
;; 'mumamo-search-fw-verbatimtex-end)
(mumamo-possible-chunk-forward pos max
'mumamo-search-fw-verbatimtex-start
'mumamo-search-fw-verbatimtex-end))
;; (defun mumamo-search-bw-btex-start (pos min)
;; "Helper for `mumamo-chunk-btex'.
;; POS is where to start search and MIN is where to stop."
;; (let ((exc-start (mumamo-chunk-start-bw-str pos min "\nverbatimtex"))
;; (exc-mode 'plain-tex-mode))
;; (when exc-start
;; (when (<= exc-start pos)
;; (cons exc-start exc-mode)))))
;; (defun mumamo-search-bw-btex-end (pos min)
;; "Helper for `mumamo-chunk-btex'.
;; POS is where to start search and MIN is where to stop."
;; (mumamo-chunk-end-bw-str pos min "\netex"))
;; (defun mumamo-search-fw-btex-start-old (pos max)
;; "Helper for `mumamo-chunk-btex'.
;; POS is where to start search and MAX is where to stop."
;; (mumamo-chunk-start-fw-str pos max "\nverbatimtex"))
(defun mumamo-search-fw-btex-start (pos max)
"Helper for `mumamo-chunk-btex'.
POS is where to start search and MAX is where to stop."
(let ((where (mumamo-chunk-start-fw-str pos max "\nverbatimtex")))
(when where
(list where 'plain-tex-mode))))
(defun mumamo-search-fw-btex-end (pos max)
"Helper for `mumamo-chunk-btex'.
POS is where to start search and MAX is where to stop."
(save-match-data
(mumamo-chunk-end-fw-str pos max "\netex")))
(defun mumamo-chunk-btex (pos min max)
"Find btex - etex chunks.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
;; (mumamo-find-possible-chunk pos min max
;; 'mumamo-search-bw-btex-start
;; 'mumamo-search-bw-btex-end
;; 'mumamo-search-fw-btex-start-old
;; 'mumamo-search-fw-btex-end)
(mumamo-possible-chunk-forward pos max
'mumamo-search-fw-btex-start
'mumamo-search-fw-btex-end))
;;;###autoload
(define-mumamo-multi-major-mode metapost-mumamo-mode
"Turn on multiple major modes for MetaPost."
("MetaPost TeX Family" metapost-mode
(mumamo-chunk-textext
mumamo-chunk-verbatimtex
)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; OpenLaszlo
(defconst mumamo-lzx-method-tag-start-regex
(rx ""))))
">"
;; FIX-ME: Commented out because of bug in Emacs
;;
;;(optional (0+ space) ""))
;; (defun mumamo-search-fw-exc-start-inlined-lzx-method-old (pos max)
;; "Helper for `mumamo-chunk-inlined-lzx-method'.
;; POS is where to start search and MAX is where to stop."
;; (goto-char (1+ pos))
;; (skip-chars-backward "^<")
;; ;; Handle ")))
(defun mumamo-chunk-inlined-lzx-method (pos min max)
"Find .... Return range and 'javascript-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
;; (mumamo-find-possible-chunk pos min max
;; 'mumamo-search-bw-exc-start-inlined-lzx-method
;; 'mumamo-search-bw-exc-end-inlined-lzx-method
;; 'mumamo-search-fw-exc-start-inlined-lzx-method-old
;; 'mumamo-search-fw-exc-end-inlined-lzx-method)
(mumamo-possible-chunk-forward pos max
'mumamo-search-fw-exc-start-inlined-lzx-method
'mumamo-search-fw-exc-end-inlined-lzx-method))
(defconst mumamo-lzx-handler-tag-start-regex
(rx ""))))
">"
;; FIX-ME: Commented out because of bug in Emacs
;;
;;(optional (0+ space) ""))
;; (defun mumamo-search-fw-exc-start-inlined-lzx-handler-old (pos max)
;; "Helper for `mumamo-chunk-inlined-lzx-handler'.
;; POS is where to start search and MAX is where to stop."
;; (goto-char (1+ pos))
;; (skip-chars-backward "^<")
;; ;; Handle ")))
(defun mumamo-chunk-inlined-lzx-handler (pos min max)
"Find .... Return range and 'javascript-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
;; (mumamo-find-possible-chunk pos min max
;; 'mumamo-search-bw-exc-start-inlined-lzx-handler
;; 'mumamo-search-bw-exc-end-inlined-lzx-handler
;; 'mumamo-search-fw-exc-start-inlined-lzx-handler-old
;; 'mumamo-search-fw-exc-end-inlined-lzx-handler)
(mumamo-possible-chunk-forward pos max
'mumamo-search-fw-exc-start-inlined-lzx-handler
'mumamo-search-fw-exc-end-inlined-lzx-handler))
;;;###autoload
(define-mumamo-multi-major-mode laszlo-nxml-mumamo-mode
"Turn on multiple major modes for OpenLaszlo."
("OpenLaszlo Family" nxml-mode
(mumamo-chunk-inlined-script
mumamo-chunk-inlined-lzx-method
mumamo-chunk-inlined-lzx-handler
)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; csound
;; (defun mumamo-search-bw-exc-start-csound-orc (pos min)
;; "Helper for `mumamo-chunk-csound-orc'.
;; POS is where to start search and MIN is where to stop."
;; (let ((exc-start (mumamo-chunk-start-bw-str pos min "")))
;; (and exc-start
;; (<= exc-start pos)
;; (cons exc-start 'csound-orc-mode))))
;; (defun mumamo-search-bw-exc-end-csound-orc (pos min)
;; "Helper for `mumamo-chunk-csound-orc'.
;; POS is where to start search and MIN is where to stop."
;; (mumamo-chunk-end-bw-str pos min ""))
;; (defun mumamo-search-fw-exc-start-csound-orc-old (pos max)
;; "Helper for `mumamo-chunk-csound-orc'.
;; POS is where to start search and MAX is where to stop."
;; (mumamo-chunk-start-fw-str pos max ""))
(defun mumamo-search-fw-exc-start-csound-orc (pos max)
"Helper for `mumamo-chunk-csound-orc'.
POS is where to start search and MAX is where to stop."
(let ((where (mumamo-chunk-start-fw-str pos max "")))
(when where
(list where 'csound-orc-mode))))
(defun mumamo-search-fw-exc-end-csound-orc (pos max)
"Helper for `mumamo-chunk-csound-orc'.
POS is where to start search and MAX is where to stop."
(save-match-data
(mumamo-chunk-end-fw-str pos max "")))
(defun mumamo-chunk-csound-orc (pos min max)
"Find .... Return range and 'csound-orc-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
;; (mumamo-find-possible-chunk pos min max
;; 'mumamo-search-bw-exc-start-csound-orc
;; 'mumamo-search-bw-exc-end-csound-orc
;; 'mumamo-search-fw-exc-start-csound-orc-old
;; 'mumamo-search-fw-exc-end-csound-orc)
(mumamo-possible-chunk-forward pos max
'mumamo-search-fw-exc-start-csound-orc
'mumamo-search-fw-exc-end-csound-orc))
;; (defun mumamo-search-bw-exc-start-csound-sco (pos min)
;; "Helper for `mumamo-chunk-csound-sco'.
;; POS is where to start search and MIN is where to stop."
;; (let ((exc-start (mumamo-chunk-start-bw-str pos min "")))
;; (and exc-start
;; (<= exc-start pos)
;; (cons exc-start 'csound-sco-mode))))
;; (defun mumamo-search-bw-exc-end-csound-sco (pos min)
;; "Helper for `mumamo-chunk-csound-sco'.
;; POS is where to start search and MIN is where to stop."
;; (mumamo-chunk-end-bw-str pos min ""))
;; (defun mumamo-search-fw-exc-start-csound-sco-old (pos max)
;; "Helper for `mumamo-chunk-csound-sco'.
;; POS is where to start search and MAX is where to stop."
;; (mumamo-chunk-start-fw-str pos max ""))
(defun mumamo-search-fw-exc-start-csound-sco (pos max)
"Helper for `mumamo-chunk-csound-sco'.
POS is where to start search and MAX is where to stop."
(let ((where (mumamo-chunk-start-fw-str pos max "")))
(when where
(list where 'csound-sco-mode))))
(defun mumamo-search-fw-exc-end-csound-sco (pos max)
"Helper for `mumamo-chunk-csound-sco'.
POS is where to start search and MAX is where to stop."
(save-match-data
(mumamo-chunk-end-fw-str pos max "")))
(defun mumamo-chunk-csound-sco (pos min max)
"Found .... Return range and 'csound-sco-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
;; (mumamo-find-possible-chunk pos min max
;; 'mumamo-search-bw-exc-start-csound-sco
;; 'mumamo-search-bw-exc-end-csound-sco
;; 'mumamo-search-fw-exc-start-csound-sco-old
;; 'mumamo-search-fw-exc-end-csound-sco)
(mumamo-possible-chunk-forward pos max
'mumamo-search-fw-exc-start-csound-sco
'mumamo-search-fw-exc-end-csound-sco))
;;;###autoload
(define-mumamo-multi-major-mode csound-sgml-mumamo-mode
"Turn on mutiple major modes for CSound orc/sco Modes."
("CSound orc/sco Modes" sgml-mode
(mumamo-chunk-csound-sco
mumamo-chunk-csound-orc
)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; noweb
;;;###autoload
(defgroup mumamo-noweb2 nil
"Customization group for `noweb2-mumamo-mode'."
:group 'mumamo-modes)
(defcustom mumamo-noweb2-mode-from-ext
'(
("php" . php-mode)
("c" . c-mode)
)
"File extension regexp to major mode mapping.
Used by `noweb2-mumamo-mode'."
:type '(repeat
(cons regexp major-mode-function))
:group 'mumamo-noweb2)
(defvar mumamo-noweb2-found-mode-from-ext nil
"Major modes determined from file names. Internal use.")
(defun mumamo-noweb2-chunk-start-fw (pos max)
"Helper for `mumamo-noweb2-chunk'.
POS is where to start search and MAX is where to stop."
(let ((where (mumamo-chunk-start-fw-re pos max "^<<\\(.*?\\)>>="))
(exc-mode 'text-mode))
(when where
(let* ((file-name (match-string-no-properties 1))
(file-ext (when file-name (file-name-extension file-name))))
(when file-ext
(setq exc-mode (catch 'major
(dolist (rec mumamo-noweb2-mode-from-ext)
(when (string-match (car rec) file-ext)
(throw 'major (cdr rec))))
nil))))
(list where exc-mode))))
;; (defun mumamo-noweb2-chunk-start-bw (pos min)
;; "Helper for `mumamo-noweb2-chunk'.
;; POS is where to start search and MIN is where to stop."
;; (let ((exc-start (mumamo-chunk-start-bw-re pos min "^<<\\(.*?\\)>>="))
;; (exc-mode 'text-mode))
;; (when exc-start
;; (let* ((file-name (match-string 1))
;; (file-ext (when file-name (file-name-extension file-name))))
;; (when file-ext
;; (setq exc-mode (catch 'major
;; (dolist (rec mumamo-noweb2-mode-from-ext)
;; (when (string-match (car rec) file-ext)
;; (throw 'major (cdr rec))))
;; nil))
;; (unless exc-mode
;; (setq exc-mode
;; (cdr (assoc file-ext mumamo-noweb2-found-mode-from-ext)))
;; (unless exc-mode
;; ;; Get the major mode from file name
;; (with-temp-buffer
;; (setq buffer-file-name file-name)
;; (condition-case err
;; (normal-mode)
;; (error (message "error (normal-mode): %s"
;; (error-message-string err))))
;; (setq exc-mode (or major-mode
;; 'text-mode))
;; (add-to-list 'mumamo-noweb2-found-mode-from-ext
;; (cons file-ext exc-mode)))
;; ))))
;; (cons exc-start exc-mode))))
(defun mumamo-noweb2-chunk-end-fw (pos max)
"Helper for `mumamo-noweb2-chunk'.
POS is where to start search and MAX is where to stop."
(save-match-data
(mumamo-chunk-end-fw-re pos max "^@")))
;; (defun mumamo-noweb2-chunk-end-bw (pos min)
;; "Helper for `mumamo-noweb2-chunk'.
;; POS is where to start search and MIN is where to stop."
;; (mumamo-chunk-end-bw-re pos min "^@"))
(defun mumamo-noweb2-code-chunk (pos min max)
"Find noweb chunks. Return range and found mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(save-match-data
;; (mumamo-find-possible-chunk pos min max
;; 'mumamo-noweb2-chunk-start-bw
;; 'mumamo-noweb2-chunk-end-bw
;; 'mumamo-noweb2-chunk-start-fw-old
;; 'mumamo-noweb2-chunk-end-fw)
(mumamo-possible-chunk-forward pos max
'mumamo-noweb2-chunk-start-fw
'mumamo-noweb2-chunk-end-fw)))
;;;###autoload
(define-mumamo-multi-major-mode noweb2-mumamo-mode
"Multi major mode for noweb files."
("noweb Family" latex-mode
(mumamo-noweb2-code-chunk)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Template-Toolkit
;; (setq auto-mode-alist
;; (append '(("\\.tt2?$" . tt-mode)) auto-mode-alist ))
;;(require 'tt-mode)
(defun mumamo-chunk-tt (pos min max)
"Find [% ... %], return range and `tt-mode'.
See `mumamo-find-possible-chunk' for POS, MIN and MAX.
This is for Template Toolkit.
See URL `http://dave.org.uk/emacs/' for `tt-mode'."
(mumamo-quick-static-chunk pos min max "[%" "%]" t 'tt-mode nil))
(define-mumamo-multi-major-mode tt-html-mumamo-mode
"Turn on multiple major modes for TT files with main mode `nxhtml-mode'.
TT = Template-Toolkit.
This also covers inlined style and javascript."
("TT HTML Family" html-mode
(mumamo-chunk-tt
mumamo-chunk-inlined-style
mumamo-chunk-inlined-script
mumamo-chunk-style=
mumamo-chunk-onjs=
)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Asp
;;;; asp <%@language="javscript"%>
(defvar mumamo-asp-default-major 'asp-js-mode)
(make-variable-buffer-local 'mumamo-asp-default-major)
(put 'mumamo-asp-default-major 'permanent-local t)
(defconst mumamo-asp-lang-marker
(rx "<%@"
(0+ space)
"language"
(0+ space)
"="
(0+ space)
"\""
(submatch (1+ (not (any "\""))))
"\""
(0+ space)))
(defun mumamo-search-fw-exc-start-jsp (pos min max)
;; fix-me
)
(defun mumamo-chunk-asp (pos min max)
"Find <% ... %>. Return range and 'asp-js-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
;; Fix-me: this is broken!
;; (mumamo-find-possible-chunk pos min max
;; 'mumamo-search-bw-exc-start-asp
;; 'mumamo-search-bw-exc-end-jsp
;; 'mumamo-search-fw-exc-start-jsp-old
;; 'mumamo-search-fw-exc-end-jsp)
(mumamo-possible-chunk-forward pos max
'mumamo-search-fw-exc-start-asp
'mumamo-search-fw-exc-end-jsp))
;;;; asp <% ...>
(defun mumamo-chunk-asp% (pos min max)
"Find <% ... %>. Return range and 'asp-js-mode or 'asp-vb-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(let* ((chunk (mumamo-quick-static-chunk pos min max "<%" "%>" t 'java-mode t))
(beg (nth 0 chunk))
(here (point))
glang)
(when chunk
(goto-char beg)
(if (looking-at mumamo-asp-lang-marker)
(progn
(setq glang (downcase (match-string 1)))
(cond
((string= glang "javascript")
(setq mumamo-asp-default-major 'asp-js-mode))
((string= glang "vbscript")
(setq mumamo-asp-default-major 'asp-vb-mode))
)
(setcar (nthcdr 2 chunk) 'mumamo-comment-mode))
(setcar (nthcdr 2 chunk) mumamo-asp-default-major))
chunk)))
;;;; asp . Return 'asp-js-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
;; (mumamo-find-possible-chunk pos min max
;; 'mumamo-asp-search-bw-exc-start-inlined-script
;; 'mumamo-search-bw-exc-end-inlined-script
;; 'mumamo-asp-search-fw-exc-start-inlined-script-old
;; 'mumamo-search-fw-exc-end-inlined-script)
(mumamo-possible-chunk-forward pos max
'mumamo-asp-search-fw-exc-start-inlined-script
'mumamo-search-fw-exc-end-inlined-script))
;;;###autoload
(define-mumamo-multi-major-mode asp-html-mumamo-mode
"Turn on multiple major modes for ASP with main mode `html-mode'.
This also covers inlined style and javascript."
("ASP Html Family" html-mode
(mumamo-chunk-asp%
mumamo-asp-chunk-inlined-script
mumamo-chunk-inlined-script
mumamo-chunk-style=
mumamo-chunk-onjs=
)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Org-mode
(defcustom mumamo-org-submodes
'(
(emacs-lisp emacs-lisp-mode)
(ruby ruby-mode)
(python python-mode)
(sh sh-mode)
(R R-mode)
(ditaa picture-mode)
)
"Alist for conversion of org #+BEGIN_SRC specifier to major mode.
Works kind of like `mumamo-major-modes'.
This may be used for example for org-babel \(see URL
`http://orgmode.org/worg/org-contrib/babel/')."
:type '(alist
:key-type (symbol :tag "Symbol in #BEGIN_SRC specifier")
:value-type (repeat (choice
(command :tag "Major mode")
(symbol :tag "Major mode (not yet loaded)")))
)
:group 'mumamo-modes)
(defun mumamo-org-mode-from-spec (major-spec)
"Translate MAJOR-SPEC to a major mode.
Translate MAJOR-SPEC used in #BEGIN_SRC to a major mode.
See `mumamo-org-submodes' for an explanation."
(mumamo-major-mode-from-spec major-spec mumamo-org-submodes))
(defun mumamo-chunk-org-html (pos min max)
"Find #+BEGIN_HTML ... #+END_HTML, return range and `html-mode'.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(mumamo-quick-static-chunk pos min max "#+BEGIN_HTML" "#+END_HTML" nil 'html-mode nil))
;; (defun mumamo-search-bw-org-src-start (pos min)
;; "Helper for `mumamo-chunk-org-src'.
;; POS is where to start search and MIN is where to stop."
;; (let* ((exc-start (mumamo-chunk-start-bw-str pos min "#+BEGIN_SRC"))
;; (exc-mode (when exc-start
;; (let ((here (point)))
;; (goto-char exc-start)
;; (prog1
;; (read (current-buffer))
;; (goto-char here))))))
;; (setq exc-mode (mumamo-org-mode-from-spec exc-mode))
;; ;;(setq exc-mode (eval exc-mode))
;; ;;(setq exc-mode 'text-mode)
;; ;;(when exc-mode (setq exc-mode (quote exc-mode)))
;; ;;(assert (eq exc-mode 'emacs-lisp-mode) t)
;; (when exc-start
;; (when (<= exc-start pos)
;; (cons exc-start exc-mode)))))
;; (defun mumamo-search-bw-org-src-end (pos min)
;; "Helper for `mumamo-chunk-org-src'.
;; POS is where to start search and MIN is where to stop."
;; (mumamo-chunk-end-bw-str pos min "#+END_SRC"))
;; (defun mumamo-search-fw-org-src-start-old (pos max)
;; "Helper for `mumamo-chunk-org-src'.
;; POS is where to start search and MAX is where to stop."
;; (mumamo-chunk-start-fw-str pos max "#+BEGIN_SRC"))
(defun mumamo-search-fw-org-src-start (pos max)
"Helper for `mumamo-chunk-org-src'.
POS is where to start search and MAX is where to stop."
(let ((where (mumamo-chunk-start-fw-str pos max "#+BEGIN_SRC")))
(when where
(let ((exc-mode (let ((here (point)))
(goto-char where)
(prog1
(read (current-buffer))
(goto-char here)))))
(setq exc-mode (mumamo-org-mode-from-spec exc-mode))
(list where exc-mode)))))
(defun mumamo-search-fw-org-src-end (pos max)
"Helper for `mumamo-chunk-org-src'.
POS is where to start search and MAX is where to stop."
(save-match-data
(mumamo-chunk-end-fw-str pos max "#+END_SRC")))
(defun mumamo-chunk-org-src (pos min max)
"Find #+BEGIN_SRC ... #+END_SRC, return range and choosen major mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX.
See Info node `(org) Literal Examples' for how to specify major
mode."
;; (mumamo-find-possible-chunk pos min max
;; 'mumamo-search-bw-org-src-start
;; 'mumamo-search-bw-org-src-end
;; 'mumamo-search-fw-org-src-start-old
;; 'mumamo-search-fw-org-src-end)
(mumamo-possible-chunk-forward pos max
'mumamo-search-fw-org-src-start
'mumamo-search-fw-org-src-end))
;;;###autoload
(define-mumamo-multi-major-mode org-mumamo-mode
"Turn on multiple major modes for `org-mode' files with main mode `org-mode'.
** Note about HTML subchunks:
Unfortunately this only allows `html-mode' (not `nxhtml-mode') in
sub chunks."
("Org Mode + Html" org-mode
(mumamo-chunk-org-html
mumamo-chunk-org-src
)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Mako
;; See http://www.makotemplates.org/docs/syntax.html
;;; Comments mode
;; Fix-me: move to mumamo.el
(defconst mumamo-comment-font-lock-keywords
(list
(cons "\\(.*\\)" (list 1 font-lock-comment-face))
))
(defvar mumamo-comment-font-lock-defaults
'(mumamo-comment-font-lock-keywords t t))
(define-derived-mode mumamo-comment-mode nil "Comment chunk"
"For comment blocks."
(set (make-local-variable 'font-lock-defaults) mumamo-comment-font-lock-defaults))
(defun mumamo-chunk-mako-<% (pos min max)
"Find <% ... %> and <%! ... %>. Return range and `python-mode'.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
;; (mumamo-find-possible-chunk pos min max
;; 'mumamo-mako-<%-bw-start
;; 'mumamo-mako-<%-bw-end
;; 'mumamo-mako-<%-fw-start-old
;; 'mumamo-mako-<%-fw-end
;; 'mumamo-mako-<%-find-borders)
(let ((chunk (mumamo-possible-chunk-forward pos max
'mumamo-mako-<%-fw-start
'mumamo-mako-<%-fw-end
'mumamo-mako-<%-find-borders
)))
(when chunk
(setcdr (last chunk) '(mumamo-template-indentor))
chunk)))
(defun mumamo-mako-<%-find-borders (start end exc-mode)
(when exc-mode
(list
(when start
(+ start
(if (eq ?! (char-after (+ start 2)))
3
2)))
(when end (- end 2))
exc-mode)))
;; (defun mumamo-mako-<%-bw-start (pos min)
;; (let ((here (point))
;; start
;; ret
;; )
;; (goto-char (+ pos 3))
;; (setq start (re-search-backward "<%!?\\(?:[ \t]\\|$\\)" min t))
;; (when (and start (<= start pos))
;; (setq ret (list start 'python-mode)))
;; (goto-char here)
;; ret))
;; (defun mumamo-mako-<%-bw-end (pos min)
;; (mumamo-chunk-end-bw-str-inc pos min "%>")) ;; ok
;; (defun mumamo-mako-<%-fw-start-old (pos max)
;; (let ((here (point))
;; start
;; ret)
;; (goto-char pos)
;; (setq start
;; (re-search-forward "<%!?\\(?:[ \t]\\|$\\)" max t))
;; (when start
;; (setq ret (match-beginning 0)))
;; (goto-char here)
;; ret))
(defun mumamo-mako-<%-fw-start (pos max)
(let ((here (point))
start
ret)
(goto-char pos)
(setq start
(re-search-forward "<%!?\\(?:[ \t]\\|$\\)" max t))
(when start
(setq ret (match-beginning 0)))
(goto-char here)
(when ret
(list ret 'python-mode))))
(defun mumamo-mako-<%-fw-end (pos max)
(save-match-data
(mumamo-chunk-end-fw-str-inc pos max "%>"))) ;; ok
(defun mumamo-chunk-mako-% (pos min max)
"Find % python EOL. Return range and `python-mode'.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(let ((chunk (mumamo-whole-line-chunk pos min max "%" 'python-mode)))
(when chunk
(setcdr (last chunk) '(mumamo-template-indentor))
chunk)))
(defun mumamo-chunk-mako-one-line-comment (pos min max)
"Find ## comment EOL. Return range and `python-mode'.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(mumamo-whole-line-chunk pos min max "##" 'mumamo-comment-mode))
;; Fix-me: Move this to mumamo.el
;; Fix-me: does not work with new chunk div
(defun mumamo-whole-line-chunk-fw-exc-end-fun (pos max)
(let ((here (point)))
(goto-char pos)
(prog1
(line-end-position)
(goto-char here))))
(defun mumamo-whole-line-chunk (pos min max marker mode)
(let* ((here (point))
(len-marker (length marker))
(pattern (rx-to-string `(and bol (0+ blank) ,marker blank) t))
(whole-line-chunk-borders-fun
`(lambda (start end dummy)
(let ((start-border (+ start ,len-marker)))
(list start-border nil))))
beg
end
ret)
(goto-char pos)
(setq beg (re-search-forward pattern max t))
(when beg
(setq beg (- beg len-marker 1))
(setq end (line-end-position))
(setq ret (list beg
end
mode
(let ((start-border (+ beg len-marker)))
(list start-border nil))
nil
'mumamo-whole-line-chunk-fw-exc-end-fun
whole-line-chunk-borders-fun
)))
(goto-char here)
ret))
;; (defun mumamo-single-regexp-chunk (pos min max begin-mark end-mark mode)
;; "Not ready yet. `mumamo-quick-static-chunk'"
;; (let ((here (point))
;; (len-marker (length marker))
;; beg
;; end
;; ret)
;; (goto-char pos)
;; (setq beg (line-beginning-position))
;; (setq end (line-end-position))
;; (unless (or (when min (< beg min))
;; (when max (> end max))
;; (= pos end))
;; (goto-char beg)
;; (skip-chars-forward " \t")
;; (when (and
;; (string= marker (buffer-substring-no-properties (point) (+ (point) len-marker)))
;; (memq (char-after (+ (point) len-marker))
;; '(?\ ?\t ?\n))
;; (>= pos (point)))
;; (setq ret
;; (list (point)
;; end
;; mode
;; (let ((start-border (+ (point) len-marker)))
;; (list start-border nil))))))
;; (unless ret
;; (let ((range-regexp
;; (concat "^[ \t]*"
;; "\\("
;; (regexp-quote marker)
;; "[ \t\n].*\\)$")))
;; ;; Backward
;; (goto-char pos)
;; (unless (= pos (line-end-position))
;; (goto-char (line-beginning-position)))
;; (setq beg (re-search-backward range-regexp min t))
;; (when beg (setq beg (match-end 1)))
;; ;; Forward, take care of indentation part
;; (goto-char pos)
;; (unless (= pos (line-end-position))
;; (goto-char (line-beginning-position)))
;; (setq end (re-search-forward range-regexp max t))
;; (when end (setq end (match-beginning 1))))
;; (setq ret (list beg end)))
;; (goto-char here)
;; ;;(setq ret nil)
;; ret))
(defun mumamo-chunk-mako-<%doc (pos min max)
(mumamo-quick-static-chunk pos min max "<%doc>" "" t 'mumamo-comment-mode t))
(defun mumamo-chunk-mako-<%include (pos min max)
(mumamo-quick-static-chunk pos min max "<%include" "/>" t 'html-mode t))
(defun mumamo-chunk-mako-<%inherit (pos min max)
(mumamo-quick-static-chunk pos min max "<%inherit" "/>" t 'html-mode t))
(defun mumamo-chunk-mako-<%namespace (pos min max)
(mumamo-quick-static-chunk pos min max "<%namespace" "/>" t 'html-mode t))
(defun mumamo-chunk-mako-<%page (pos min max)
(mumamo-quick-static-chunk pos min max "<%page" "/>" t 'html-mode t))
;; Fix-me: this is not correct
(defun mumamo-chunk-mako-<%def (pos min max)
(mumamo-quick-static-chunk pos min max "<%def" "" t 'html-mode t))
(defun mumamo-chunk-mako$(pos min max)
"Find ${ ... }, return range and `python-mode'.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(mumamo-quick-static-chunk pos min max "${" "}" t 'python-mode t))
;;;###autoload
(define-mumamo-multi-major-mode mako-html-mumamo-mode
"Turn on multiple major modes for Mako with main mode `html-mode'.
This also covers inlined style and javascript."
;; Fix-me: test case
;;
;; Fix-me: Add chunks for the tags, but make sure these are made
;; invisible to nxml-mode parser.
;;
;; Fix-me: Maybe finally add that indentation support for one-line chunks?
("Mako HTML Family" html-mode
(
mumamo-chunk-mako-one-line-comment
mumamo-chunk-mako-<%doc
mumamo-chunk-mako-<%include
mumamo-chunk-mako-<%inherit
mumamo-chunk-mako-<%namespace
mumamo-chunk-mako-<%page
mumamo-chunk-mako-<%def
;;mumamo-chunk-mako-<%namesp:name
;;mumamo-chunk-mako-<%call
;;mumamo-chunk-mako-<%text
mumamo-chunk-mako-<%
mumamo-chunk-mako-%
mumamo-chunk-mako$
mumamo-chunk-xml-pi
mumamo-chunk-inlined-style
mumamo-chunk-inlined-script
mumamo-chunk-style=
mumamo-chunk-onjs=
)))
(mumamo-inherit-sub-chunk-family-locally 'mako-html-mumamo-mode 'mako-html-mumamo-mode)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; XSL
;;;###autoload
(define-mumamo-multi-major-mode xsl-nxml-mumamo-mode
"Turn on multi major mode for XSL with main mode `nxml-mode'.
This covers inlined style and javascript."
("XSL nXtml Family" nxml-mode
(
mumamo-chunk-inlined-style
mumamo-chunk-inlined-script
)))
;;;###autoload
(define-mumamo-multi-major-mode xsl-sgml-mumamo-mode
"Turn on multi major mode for XSL with main mode `sgml-mode'.
This covers inlined style and javascript."
("XSL SGML Family" sgml-mode
(
mumamo-chunk-inlined-style
mumamo-chunk-inlined-script
)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Markdown
(defun mumamo-chunk-markdown-html-1 (pos min max)
(save-restriction
(goto-char pos)
(narrow-to-region (or min (point)) (or max (point-max)))
(save-match-data
(let ((here (point)))
(when (re-search-forward (rx (* space)
(submatch "<")
(* (any "a-z"))
(or ">" (any " \t\n")))
nil t)
(let ((beg (match-beginning 1))
(end))
(goto-char beg)
(condition-case err
(progn
(while (not (sgml-skip-tag-forward 1)))
(setq end (point)))
(error (message "mumamo-chunk-markdown-html-1: %s" err)))
(goto-char here)
(when (and beg end)
(cons beg end))))))))
(defun mumamo-chunk-markdown-html-fw-exc-fun (pos max)
(let ((beg-end (mumamo-chunk-markdown-html-1 pos nil max)))
(cdr beg-end)))
(defun mumamo-chunk-markdown-html (pos min max)
"Find a chunk of html code in `markdown-mode'.
Return range and `html-mode'.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
(let ((beg-end (mumamo-chunk-markdown-html-1 pos nil max)))
(when beg-end
(let ((beg (car beg-end))
(end (cdr beg-end)))
(list beg end 'html-mode
nil ;; borders
nil ;; parseable y
'mumamo-chunk-markdown-html-fw-exc-fun
nil ;; find-borders fun
)))))
;;;###autoload
(define-mumamo-multi-major-mode markdown-html-mumamo-mode
"Turn on multi major markdown mode in buffer.
Main major mode will be `markdown-mode'.
Inlined html will be in `html-mode'.
You need `markdown-mode' which you can download from URL
`http://jblevins.org/projects/markdown-mode/'."
("Markdown HTML Family" markdown-mode
(
mumamo-chunk-markdown-html
)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Latex related
(defun mumamo-latex-closure-chunk (pos min max)
(mumamo-quick-static-chunk pos min max "\\begin{clojure}" "\\end{clojure}" t 'clojure-mode t))
;;;###autoload
(define-mumamo-multi-major-mode latex-clojure-mumamo-mode
"Turn on multi major mode latex+clojure.
Main major mode will be `latex-mode'.
Subchunks will be in `clojure-mode'.
You will need `clojure-mode' which you can download from URL
`http://github.com/jochu/clojure-mode/tree'."
("Latex+clojur Family" latex-mode
(
mumamo-latex-closure-chunk
)))
(add-to-list 'auto-mode-alist '("\\.lclj\\'" . latex-clojure-mumamo-mode))
(defun mumamo-latex-haskell-chunk (pos min max)
(mumamo-quick-static-chunk pos min max "\\begin{code}" "\\end{code}" t 'haskell-mode t))
;;;###autoload
(define-mumamo-multi-major-mode latex-haskell-mumamo-mode
"Turn on multi major mode latex+haskell.
Main major mode will be `latex-mode'.
Subchunks will be in `haskell-mode'.
You will need `haskell-mode' which you can download from URL
`http://projects.haskell.org/haskellmode-emacs/'."
("Latex+haskell Family" latex-mode
(
mumamo-latex-haskell-chunk
)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Python + ReST
;; From Martin Soto
(defun python-rst-long-string-chunk (pos min max)
"Find Python long strings. Return range and 'mumamo-comment-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
;;(mumamo-quick-static-chunk pos min max "\"\"\"((" "))\"\"\"" nil 'rst-mode nil))
(mumamo-quick-static-chunk pos min max "\"\"\"" "\"\"\"" t 'rst-mode t))
;;;###autoload
(define-mumamo-multi-major-mode python-rst-mumamo-mode
"Turn on multiple major modes for Python with RestructuredText docstrings."
("Python ReST Family" python-mode
(
python-rst-long-string-chunk
)))
(provide 'mumamo-fun)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; mumamo-fun.el ends here