legacy-dotfiles/emacs.d/nxhtml/util/mumamo-fun.el

;;; 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 <?.

;; Actual use is in `mumamo-search-bw-exc-start-xml-pi'."
;;   (let ((exc-start (mumamo-chunk-start-bw-str (+ pos 2) min lt-chars))
;;         spec
;;         exc-mode
;;         hit)
;;     (when exc-start
;;       (goto-char exc-start)
;;       (when (and (not (looking-at "xml"))
;;                  (looking-at (rx (0+ (any "a-z")))))
;;         ;; (setq exc-start (match-end 0)) include it in sub chunk instead
;;         (setq exc-start (- exc-start 2))
;;         (setq spec (match-string-no-properties 0))
;;         (setq exc-mode (assoc spec mumamo-xml-pi-mode-alist))
;;         (when exc-mode (setq exc-mode (cdr exc-mode)))
;;         (setq hit t)
;;         )
;;       (when hit
;;         (unless exc-mode
;;           ;;(setq exc-mode 'fundamental-mode)
;;           ;; Fix-me: Better assume php-mode
;;           (setq exc-mode 'php-mode))
;;         (when (<= exc-start pos)
;;           ;;(cons exc-start exc-mode)
;;           (list exc-start exc-mode nil)
;;           )))))

;; (defun mumamo-search-bw-exc-start-xml-pi (pos min)
;;   "Helper for `mumamo-chunk-xml-pi'.
;; POS is where to start search and MIN is where to stop."
;;   (mumamo-search-bw-exc-start-xml-pi-1 pos min "<?"))

(defun mumamo-search-fw-exc-start-xml-pi-new (pos max)
  (let ((here (point))
        start
        spec
        exc-mode
        ret)
    (setq start (search-forward "<?" max t))
    (when (and start
               (looking-at (rx (0+ (any "a-z")))))
      (setq spec (match-string-no-properties 0))
      (unless (string= spec "xml")
        (when (= 0 (length spec))
          (setq spec "php"))
        (setq exc-mode (assoc spec mumamo-xml-pi-mode-alist))
        (if exc-mode
            (setq exc-mode (cdr exc-mode))
          (setq exc-mode 'mumamo-bad-mode))
        (setq ret (list (- start 2) exc-mode nil))))
    (goto-char here)
    ret))

(defun mumamo-xml-pi-end-is-xml-end (pos)
  "Return t if the ?> at pos is end of <?xml."
  (when (> 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 "<?"))

;; Add a find-borders-fun here so that for example src="<?php some
;; code ?>" can be handled.
;;
;; Fix-me: Maybe generalize for other values than <?php
(defun mumamo-find-borders-xml-pi (start end exc-mode)
  (let (start-border
        end-border
        (inc t)
        ;;(begin-mark "<?php")
        (begin-mark "<?")
        (end-mark "?>")
        (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))


;;;; <style ...>

(defconst mumamo-style-tag-start-regex
  (rx "<style"
      space
      (0+ (not (any ">")))
      "type"
      (0+ space)
      "="
      (0+ space)
      ?\"
      "text/css"
      ?\"
      (0+ (not (any ">")))
      ">"
      ;; FIX-ME: Commented out because of bug in Emacs
      ;;
      ;;(optional (0+ space) "<![CDATA[")
      ))

;; (defun mumamo-search-bw-exc-start-inlined-style (pos min)
;;   "Helper for `mumamo-chunk-inlined-style'.
;; POS is where to start search and MIN is where to stop."
;;   (goto-char (+ pos 6))
;;   (let ((marker-start (search-backward "<style" min t))
;;         exc-mode
;;         exc-start)
;;     (when marker-start
;;       (when (looking-at mumamo-style-tag-start-regex)
;;         (setq exc-start (match-end 0))
;;         (goto-char exc-start)
;;         (when (<= exc-start pos)
;;           ;;(cons (point) 'css-mode)
;;           ;;(list (point) 'css-mode '(nxml-mode))
;;           ;; Fix-me: Kubica looping problem
;;           (list (point) 'css-mode)
;;           )
;;         ))))

;; (defun mumamo-search-bw-exc-end-inlined-style (pos min)
;;   "Helper for `mumamo-chunk-inlined-style'.
;; POS is where to start search and MIN is where to stop."
;;   (mumamo-chunk-end-bw-str pos min "</style>"))

;; (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 <![CDATA[
;;   (when (and
;;          (eq ?< (char-before))
;;          (eq ?! (char-after))
;;          (not (bobp)))
;;     (backward-char)
;;     (skip-chars-backward "^<"))
;;   (unless (bobp)
;;     (backward-char 1))
;;   (let ((exc-start (search-forward "<style" max t))
;;         exc-mode)
;;     (when exc-start
;;       (goto-char (- exc-start 6))
;;       (when (looking-at mumamo-style-tag-start-regex)
;;         (goto-char (match-end 0))
;;         (point)
;;         ))))

(defun mumamo-search-fw-exc-end-inlined-style (pos max)
  "Helper for `mumamo-chunk-inlined-style'.
POS is where to start search and MAX is where to stop."
  (save-match-data
    (mumamo-chunk-end-fw-str pos max "</style>")))

;; (defun mumamo-chunk-inlined-style-old (pos min max)
;;   "Find <style>...</style>.  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 <![CDATA[
  (when (and
         (eq ?< (char-before))
         (eq ?! (char-after))
         (not (bobp)))
    (backward-char)
    (skip-chars-backward "^<"))
  (unless (bobp)
    (backward-char 1))
  (let ((exc-start (search-forward "<style" max t))
        exc-mode)
    (when exc-start
      (goto-char (- exc-start 6))
      (when (looking-at mumamo-style-tag-start-regex)
        (goto-char (match-end 0))
        (list (point) 'css-mode nil)
        ))))

(defun mumamo-chunk-inlined-style (pos min max)
  "Find <style>...</style>.  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))

;;;; <script ...>

(defconst mumamo-script-tag-start-regex
  (rx "<script"
      space
      (0+ (not (any ">")))
      "type"
      (0+ space)
      "="
      (0+ space)
      ?\"
      ;;(or "text" "application")
      ;;"/"
      ;;(or "javascript" "ecmascript")
      "text/javascript"
      ?\"
      (0+ (not (any ">")))
      ">"
      ;; FIX-ME: Commented out because of bug in Emacs
      ;;
      ;;(optional (0+ space) "<![CDATA[" )
      ))

;; (defun mumamo-search-bw-exc-start-inlined-script (pos min)
;;   "Helper for `mumamo-chunk-inlined-script'.
;; POS is where to start search and MIN is where to stop."
;;   (goto-char (+ pos 7))
;;   (let ((marker-start (when (< min (point)) (search-backward "<script" min t)))
;;         exc-mode
;;         exc-start)
;;     (when marker-start
;;       (when (looking-at mumamo-script-tag-start-regex)
;;         (setq exc-start (match-end 0))
;;         (goto-char exc-start)
;;         (when (<= exc-start pos)
;;           ;;(cons (point) 'javascript-mode)
;;           (list (point) 'javascript-mode '(nxml-mode))
;;           )
;;         ))))

;; (defun mumamo-search-bw-exc-end-inlined-script (pos min)
;;   "Helper for `mumamo-chunk-inlined-script'.
;; POS is where to start search and MIN is where to stop."
;;   (mumamo-chunk-end-bw-str pos min "</script>"))

;; (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 <![CDATA[
;;   (when (and
;;          (eq ?< (char-before))
;;          (eq ?! (char-after))
;;          (not (bobp)))
;;     (backward-char)
;;     (skip-chars-backward "^<"))
;;   (unless (bobp)
;;     (backward-char 1))
;;   (let ((exc-start (search-forward "<script" max t))
;;         exc-mode)
;;     (when exc-start
;;       (goto-char (- exc-start 7))
;;       (when (looking-at mumamo-script-tag-start-regex)
;;         (goto-char (match-end 0))
;;         (point)
;;         ))))

(defun mumamo-search-fw-exc-end-inlined-script (pos max)
  "Helper for `mumamo-chunk-inlined-script'.
POS is where to start search and MAX is where to stop."
  (save-match-data
    (mumamo-chunk-end-fw-str pos max "</script>")))

;; (defun mumamo-chunk-inlined-script-old (pos min max)
;;   "Find <script>...</script>.  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 <![CDATA[
  (when (and
         (eq ?< (char-before))
         (eq ?! (char-after))
         (not (bobp)))
    (backward-char)
    (skip-chars-backward "^<"))
  (unless (bobp)
    (backward-char 1))
  (let ((exc-start (search-forward "<script" max t))
        exc-mode)
    (when exc-start
      (goto-char (- exc-start 7))
      (when (looking-at mumamo-script-tag-start-regex)
        (goto-char (match-end 0))
        (list (point) 'javascript-mode '(nxml-mode))
        ))))

(defun mumamo-chunk-inlined-script (pos min max)
  "Find <script>...</script>.  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 '<?php' in buffer.
When turning on this mode <?php is replace with (?php in the buffer.
If you write the buffer to file (?php is however written as <?php.

When turning off this mode (?php is replace with <?php in the buffer.

The purpose of this minor mode is to work around problems with
using the `nxml-mode' parser in php files.  `nxml-mode' knows
damned well that you can not have the character < in strings and
I can't make it forget that.  For PHP programmers it is however
very convient to use <?php ... ?> 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 "<?php "
  (if mumamo-alt-php-tags-mode
      (progn
        ;;(unless mumamo-multi-major-mode (error "Only for mumamo multi major modes"))
        (unless (let ((major-mode (mumamo-main-major-mode)))
                  (derived-mode-p 'nxml-mode))
          ;;(error "Mumamo multi major mode must be based on nxml-mode")
          )
        (unless (memq 'mumamo-chunk-alt-php (caddr mumamo-current-chunk-family))
          (error "Mumamo multi major must have chunk function mumamo-chunk-alt-php"))

        ;; Be paranoid about the file/content write hooks
        (when (<= emacs-major-version 22)
          (with-no-warnings
            (when local-write-file-hooks ;; obsolete, but check!
              (error "Will not do this because local-write-file-hooks is non-nil"))))
        (remove-hook 'write-contents-functions 'mumamo-alt-php-write-contents t)
        (when write-contents-functions
          (error "Will not do this because write-contents-functions is non-nil"))
        (when (delq 'recentf-track-opened-file (copy-sequence write-file-functions))
          (error "Will not do this because write-file-functions is non-nil"))

        (add-hook 'write-contents-functions 'mumamo-alt-php-write-contents t t)
        (put 'write-contents-functions 'permanent-local t)
        (save-restriction
          (let ((here (point)))
            (widen)
            (goto-char (point-min))
            (while (search-forward "<?php" nil t)
              (replace-match "(?php"))
            (goto-char (point-min))
            (while (search-forward "<?=" nil t)
              (replace-match "(?="))
            (goto-char (point-min))
            (while (search-forward "?>" 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 "<?php"))
        (goto-char (point-min))
        (while (search-forward "(?=" nil t)
          (replace-match "<?="))
        (goto-char (point-min))
        (while (search-forward "?)" 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 <?php.

See `mumamo-find-possible-chunk' for POS, MIN and MAX."
  (when mumamo-alt-php-tags-mode
    (mumamo-quick-static-chunk pos min max "(?php" "?)" t 'php-mode t)))

(defun mumamo-chunk-alt-php= (pos min max)
  "Find (?= ... ?), return range and `php-mode'.
Workaround for the problem that I can not tame `nxml-mode' to recognize <?php.

See `mumamo-find-possible-chunk' for POS, MIN and MAX."
  (when mumamo-alt-php-tags-mode
    (mumamo-quick-static-chunk pos min max "(?=" "?)" t 'php-mode t)))

;;;###autoload
(define-mumamo-multi-major-mode html-mumamo-mode
  "Turn on multiple major modes for (X)HTML with main mode `html-mode'.
This covers inlined style and javascript and PHP."
  ("HTML Family" html-mode
   (mumamo-chunk-xml-pi
    mumamo-chunk-alt-php
    mumamo-chunk-alt-php=
    mumamo-chunk-inlined-style
    mumamo-chunk-inlined-script
    mumamo-chunk-style=
    mumamo-chunk-onjs=
    )))
(add-hook 'html-mumamo-mode-hook 'mumamo-define-html-file-wide-keys)
(mumamo-inherit-sub-chunk-family 'html-mumamo-mode)

;; (define-mumamo-multi-major-mode xml-pi-only-mumamo-mode
;;   "Test"
;;   ("HTML Family" html-mode
;;    (mumamo-chunk-xml-pi
;;     )))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; XHTML w nxml-mode

(defun mumamo-alt-php-write-contents ()
  "For `write-contents-functions' when `mumamo-chunk-alt-php' is used."
  (let ((here (point)))
    (save-match-data
      (save-restriction
        (widen)
        (condition-case nil
            (atomic-change-group
              (progn
                (goto-char (point-min))
                (while (search-forward "(?php" nil t)
                  (replace-match "<?php"))
                (goto-char (point-min))
                (while (search-forward "(?=" nil t)
                  (replace-match "<?="))
                (goto-char (point-min))
                (while (search-forward "?)" nil t)
                  (replace-match "?>"))
                (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>" "</%perl>" t 'perl-mode t))

(defun mumamo-chunk-mason-perl-init (pos min max)
  (mumamo-quick-static-chunk pos min max "<%init>" "</%init>" t 'perl-mode t))

(defun mumamo-chunk-mason-perl-once (pos min max)
  (mumamo-quick-static-chunk pos min max "<%once>" "</%once>" t 'perl-mode t))

(defun mumamo-chunk-mason-perl-cleanup (pos min max)
  (mumamo-quick-static-chunk pos min max "<%cleanup>" "</%cleanup>" t 'perl-mode t))

(defun mumamo-chunk-mason-perl-shared (pos min max)
  (mumamo-quick-static-chunk pos min max "<%shared>" "</%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>" "</%args>" t 'perl-mode t))

(defun mumamo-chunk-mason-doc (pos min max)
  (mumamo-quick-static-chunk pos min max "<%doc>" "</%doc>" t 'mumamo-comment-mode t))

(defun mumamo-chunk-mason-text (pos min max)
  (mumamo-quick-static-chunk pos min max "<%text>" "</%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-<! (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."
  ;; This is a bit tricky since [$var] etc must be avoided.
  (let* ((begin-mark "[$")
         (end-mark "$]")
         (good-chars '(32 ;space
                       10 ;line feed
                       9  ;tab
                       ))
         ;; (search-bw-exc-start (lambda (pos min)
         ;;                        (let ((not-found t)
         ;;                              (next-char nil)
         ;;                              (exc-start (mumamo-chunk-start-bw-str
         ;;                                          pos min begin-mark))
         ;;                              (here (point)))
         ;;                          (while (and not-found
         ;;                                      exc-start)
         ;;                            (setq next-char (char-after (+ (point) 2)))
         ;;                            (if (memq next-char good-chars)
         ;;                                (setq not-found nil)
         ;;                              (setq exc-start
         ;;                                    (search-backward begin-mark
         ;;                                                     min t))))
         ;;                          (when (and exc-start
         ;;                                     (<= exc-start pos))
         ;;                            (cons exc-start 'perl-mode)))))
         ;; (search-bw-exc-end (lambda (pos min)
         ;;                      (mumamo-chunk-end-bw-str pos min end-mark)))
         ;; (search-fw-exc-start-old (lambda (pos max)
         ;;                            (let ((not-found t)
         ;;                                  (next-char nil)
         ;;                                  (exc-start (mumamo-chunk-start-fw-str
         ;;                                              pos max begin-mark))
         ;;                                  (here (point)))
         ;;                              (while (and not-found
         ;;                                          exc-start)
         ;;                                (setq next-char (char-after))
         ;;                                (if (memq next-char good-chars)
         ;;                                    (setq not-found nil)
         ;;                                  (setq exc-start
         ;;                                    (search-forward begin-mark
         ;;                                                    max t))))
         ;;                              exc-start)))
         (search-fw-exc-start (lambda (pos max)
                                (let ((not-found t)
                                      (next-char nil)
                                      (exc-start (mumamo-chunk-start-fw-str
                                                  pos max begin-mark))
                                      (here (point)))
                                  (while (and not-found
                                              exc-start)
                                    (setq next-char (char-after))
                                    (if (memq next-char good-chars)
                                        (setq not-found nil)
                                      (setq exc-start
                                            (search-forward begin-mark
                                                            max t))))
                                  (list exc-start 'perl-mode))))
         (search-fw-exc-end (lambda (pos max)
                              (save-match-data
                                (mumamo-chunk-end-fw-str pos max end-mark))))
         )
    ;; (mumamo-find-possible-chunk pos min max
    ;;                             search-bw-exc-start
    ;;                             search-bw-exc-end
    ;;                             search-fw-exc-start-old
    ;;                             search-fw-exc-end)
    (mumamo-possible-chunk-forward pos max
                                search-fw-exc-start
                                search-fw-exc-end)
    ))

;;;###autoload
(define-mumamo-multi-major-mode embperl-html-mumamo-mode
  "Turn on multiple major modes for Embperl files with main mode `html-mode'.
This also covers inlined style and javascript."
    ("Embperl HTML Family" html-mode
     (mumamo-chunk-embperl-<-
      mumamo-chunk-embperl-<+
      mumamo-chunk-embperl-<!
      mumamo-chunk-embperl-<$
      mumamo-chunk-inlined-style
      mumamo-chunk-inlined-script
      mumamo-chunk-style=
      mumamo-chunk-onjs=
     )))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; django

(defun mumamo-chunk-django4(pos min max)
  "Find {% comment %}.  Return range and `django-mode'.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
  (mumamo-quick-static-chunk pos min max "{% comment %}" "{% endcomment %}" t 'mumamo-comment-mode t))

(defun mumamo-chunk-django3(pos min max)
  "Find {# ... #}.  Return range and `django-mode'.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
  (mumamo-quick-static-chunk pos min max "{#" "#}" t 'mumamo-comment-mode t))

(defun mumamo-chunk-django2(pos min max)
  "Find {{ ... }}.  Return range and `django-mode'.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
  (mumamo-quick-static-chunk pos min max "{{" "}}" t 'django-variable-mode t))

(defun mumamo-chunk-django (pos min max)
  "Find {% ... %}.  Return range and `django-mode'.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
  (let ((chunk (mumamo-quick-static-chunk pos min max "{%" "%}" t 'django-mode t)))
    (when chunk
      (setcdr (last chunk) '(mumamo-template-indentor))
      chunk)))

;; (defun mumamo-search-bw-exc-start-django (pos min)
;;   "Helper for `mumamo-chunk-django'.
;; POS is where to start search and MIN is where to stop."
;;   (let ((exc-start (mumamo-chunk-start-bw-str-inc pos min "{%")))
;;     (and exc-start
;;          (<= exc-start pos)
;;          (cons exc-start 'django-mode))))

;; (defun mumamo-search-bw-exc-start-django2(pos min)
;;   "Helper for `mumamo-chunk-django2'.
;; POS is where to start search and MIN is where to stop."
;;   (let ((exc-start (mumamo-chunk-start-bw-str-inc pos min "{{")))
;;     (and exc-start
;;          (<= exc-start pos)
;;          (cons exc-start 'django-mode))))

;; (defun mumamo-search-bw-exc-start-django3(pos min)
;;   "Helper for `mumamo-chunk-django3'.
;; POS is where to start search and MIN is where to stop."
;;   (let ((exc-start (mumamo-chunk-start-bw-str-inc pos min "{#")))
;;     (and exc-start
;;          (<= exc-start pos)
;;          (cons exc-start 'mumamo-comment-mode))))

;; (defun mumamo-search-bw-exc-start-django4(pos min)
;;   "Helper for `mumamo-chunk-django4'.
;; POS is where to start search and MIN is where to stop."
;;   (let ((exc-start (mumamo-chunk-start-bw-str-inc pos min
;;                                                        "{% comment %}")))
;;     (and exc-start
;;          (<= exc-start pos)
;;          (cons exc-start 'mumamo-comment-mode))))

;; (defun mumamo-search-bw-exc-end-django (pos min)
;;   "Helper for `mumamo-chunk-django'.
;; POS is where to start search and MIN is where to stop."
;;   (mumamo-chunk-end-bw-str-inc pos min "%}"))

;; (defun mumamo-search-bw-exc-end-django2(pos min)
;;   "Helper for `mumamo-chunk-django2'.
;; POS is where to start search and MIN is where to stop."
;;   (mumamo-chunk-end-bw-str-inc pos min "}}"))

;; (defun mumamo-search-bw-exc-end-django3(pos min)
;;   "Helper for `mumamo-chunk-django3'.
;; POS is where to start search and MIN is where to stop."
;;   (mumamo-chunk-end-bw-str-inc pos min "#}"))

;; (defun mumamo-search-bw-exc-end-django4(pos min)
;;   "Helper for `mumamo-chunk-django4'.
;; POS is where to start search and MIN is where to stop."
;;   (mumamo-chunk-end-bw-str-inc pos min "{% endcomment %}"))

(defun mumamo-search-fw-exc-start-django (pos max)
  "Helper for `mumamo-chunk-django'.
POS is where to start search and MAX is where to stop."
  (mumamo-chunk-start-fw-str-inc pos max "{%"))

(defun mumamo-search-fw-exc-start-django2(pos max)
  "Helper for `mumamo-chunk-django2'.
POS is where to start search and MAX is where to stop."
  (mumamo-chunk-start-fw-str-inc pos max "{{"))

(defun mumamo-search-fw-exc-start-django3(pos max)
  "Helper for `mumamo-chunk-django3'.
POS is where to start search and MAX is where to stop."
  (mumamo-chunk-start-fw-str-inc pos max "{#"))

(defun mumamo-search-fw-exc-start-django4(pos max)
  "Helper for `mumamo-chunk-django4'.
POS is where to start search and MAX is where to stop."
  (mumamo-chunk-start-fw-str-inc pos max "{% comment %}"))

(defun mumamo-search-fw-exc-end-django (pos max)
  "Helper for `mumamo-chunk-django'.
POS is where to start search and MAX is where to stop."
  (mumamo-chunk-end-fw-str-inc pos max "%}"))

(defun mumamo-search-fw-exc-end-django2(pos max)
  "Helper for `mumamo-chunk-django2'.
POS is where to start search and MAX is where to stop."
  (mumamo-chunk-end-fw-str-inc pos max "}}"))

(defun mumamo-search-fw-exc-end-django3(pos max)
  "Helper for `mumamo-chunk-django3'.
POS is where to start search and MAX is where to stop."
  (mumamo-chunk-end-fw-str-inc pos max "#}"))

(defun mumamo-search-fw-exc-end-django4(pos max)
  "Helper for `mumamo-chunk-django4'.
POS is where to start search and MAX is where to stop."
  (mumamo-chunk-end-fw-str-inc pos max "{% endcomment %}"))

;;;###autoload
(define-mumamo-multi-major-mode django-html-mumamo-mode
  "Turn on multiple major modes for Django with main mode `html-mode'.
This also covers inlined style and javascript."
  ("Django HTML Family" html-mode
   (mumamo-chunk-django4
    mumamo-chunk-django
    mumamo-chunk-django2
    mumamo-chunk-django3
    mumamo-chunk-inlined-style
    mumamo-chunk-inlined-script
    mumamo-chunk-style=
    mumamo-chunk-onjs=
    )))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Genshi / kid

;; {% python ... %}
(defun mumamo-chunk-genshi%(pos min max)
  "Find {% python ... %}.  Return range and `genshi-mode'.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
  (mumamo-quick-static-chunk pos min max "{% python" "%}" t 'python-mode t))

;; ${expr}
(defun mumamo-chunk-genshi$(pos min max)
  "Find ${ ... }, return range and `python-mode'.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
  (let ((chunk
         (mumamo-quick-static-chunk pos min max "${" "}" t 'python-mode t)))
    (when chunk
      ;; Test for clash with %}
      (let ((sub-mode (nth 2 chunk))
            (start (nth 0 chunk)))
        (if sub-mode
            chunk
          ;;(message "point.1=%s" (point))
          (when (and start
                     (eq ?% (char-before start)))
            ;;(message "point.2=%s" (point))
            ;;(message "clash with %%}, chunk=%s" chunk)
            ;;(setq chunk nil)
            (setcar chunk (1- start))
            )
          ;;(message "chunk.return=%s" chunk)
          chunk)))))

;; Fix-me: Because of the way chunks currently are searched for there
;; is an error when a python chunk is used. This is because mumamo
;; gets confused by the %} ending and the } ending.  This can be
;; solved by running a separate phase to get the chunks first and
;; during that phase match start and end of the chunk.


;; Note: You will currently get fontification errors if you use
;; python chunks

;;   {% python ... %}

;; The reason is that the chunk routines currently do not know when
;; to just look for the } or %} endings.  However this should not
;; affect your editing normally.

;;;###autoload
(define-mumamo-multi-major-mode genshi-html-mumamo-mode
  "Turn on multiple major modes for Genshi with main mode `html-mode'.
This also covers inlined style and javascript."
  ("Genshi HTML Family" html-mode
   (
    ;;mumamo-chunk-genshi%
    mumamo-chunk-genshi$
    mumamo-chunk-py:=
    mumamo-chunk-py:match
    mumamo-chunk-xml-pi
    mumamo-chunk-inlined-style
    mumamo-chunk-inlined-script
    mumamo-chunk-style=
    mumamo-chunk-onjs=
    )))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; MJT

;; ${expr}
(defun mumamo-chunk-mjt$(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))

;;;###autoload
(define-mumamo-multi-major-mode mjt-html-mumamo-mode
  "Turn on multiple major modes for MJT with main mode `html-mode'.
This also covers inlined style and javascript."
  ("MJT HTML Family" html-mode
   (
    mumamo-chunk-mjt$
    mumamo-chunk-xml-pi
    mumamo-chunk-inlined-style
    mumamo-chunk-inlined-script
    mumamo-chunk-style=
    mumamo-chunk-onjs=
    )))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; smarty

(defun mumamo-chunk-smarty-literal (pos min max)
  "Find {literal} ... {/literal}.  Return range and 'html-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
  (mumamo-quick-static-chunk pos min max "{literal}" "{/literal}" t 'html-mode t))

(defun mumamo-chunk-smarty-t (pos min max)
  "Find {t} ... {/t}.  Return range and 'html-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
  (mumamo-quick-static-chunk pos min max "{t}" "{/t}" t 'text-mode t))

(defun mumamo-chunk-smarty-comment (pos min max)
  "Find {* ... *}.  Return range and 'mumamo-comment-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
  (mumamo-quick-static-chunk pos min max "{*" "*}" t 'mumamo-comment-mode nil))

(defun mumamo-chunk-smarty (pos min max)
  "Find { ... }.  Return range and 'smarty-mode.
See `mumamo-find-possible-chunk' for POS, MIN and MAX."
  (mumamo-quick-static-chunk pos min max "{" "}" t 'smarty-mode nil))

;;;###autoload
(define-mumamo-multi-major-mode smarty-html-mumamo-mode
  "Turn on multiple major modes for Smarty with main mode `html-mode'.
This also covers inlined style and javascript."
  ("Smarty HTML Family" html-mode
   (mumamo-chunk-xml-pi
    mumamo-chunk-style=
    mumamo-chunk-onjs=
    ;;mumamo-chunk-inlined-style
    ;;mumamo-chunk-inlined-script
    mumamo-chunk-smarty-literal
    mumamo-chunk-smarty-t
    mumamo-chunk-smarty-comment
    mumamo-chunk-smarty
    )))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; ssjs - server side javascript

;; http://www.sitepoint.com/blogs/2009/03/10/server-side-javascript-will-be-as-common-as-php/
;;
;; It looks like there are different syntaxes, both
;;
;;  <script runat="server">...</script> 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 "<script"
      space
      (0+ (not (any ">")))
      "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) "<![CDATA[" )
      ))

;; (defun mumamo-search-bw-exc-start-inlined-ssjs (pos min)
;;   "Helper for `mumamo-chunk-inlined-ssjs'.
;; POS is where to start search and MIN is where to stop."
;;   (goto-char (+ pos 7))
;;   (let ((marker-start (when (< min (point)) (search-backward "<script" min t)))
;;         exc-mode
;;         exc-start)
;;     (when marker-start
;;       (when (looking-at mumamo-ssjs-tag-start-regex)
;;         (setq exc-start (match-end 0))
;;         (goto-char exc-start)
;;         (when (<= exc-start pos)
;;           ;;(cons (point) 'javascript-mode)
;;           (list (point) 'javascript-mode '(nxml-mode))
;;           )
;;         ))))

;; (defun mumamo-search-fw-exc-start-inlined-ssjs-old (pos max)
;;   "Helper for `mumamo-chunk-inlined-ssjs'.
;; POS is where to start search and MAX is where to stop."
;;   (goto-char (1+ pos))
;;   (skip-chars-backward "^<")
;;   ;; Handle <![CDATA[
;;   (when (and
;;          (eq ?< (char-before))
;;          (eq ?! (char-after))
;;          (not (bobp)))
;;     (backward-char)
;;     (skip-chars-backward "^<"))
;;   (unless (bobp)
;;     (backward-char 1))
;;   (let ((exc-start (search-forward "<script" max t))
;;         exc-mode)
;;     (when exc-start
;;       (goto-char (- exc-start 7))
;;       (when (looking-at mumamo-ssjs-tag-start-regex)
;;         (goto-char (match-end 0))
;;         (point)
;;         ))))

(defun mumamo-search-fw-exc-start-inlined-ssjs (pos max)
  "Helper for `mumamo-chunk-inlined-ssjs'.
POS is where to start search and MAX is where to stop."
  (goto-char (1+ pos))
  (skip-chars-backward "^<")
  ;; Handle <![CDATA[
  (when (and
         (eq ?< (char-before))
         (eq ?! (char-after))
         (not (bobp)))
    (backward-char)
    (skip-chars-backward "^<"))
  (unless (bobp)
    (backward-char 1))
  (let ((exc-start (search-forward "<script" max t))
        exc-mode)
    (when exc-start
      (goto-char (- exc-start 7))
      (when (looking-at mumamo-ssjs-tag-start-regex)
        (goto-char (match-end 0))
        (list (point) 'javascript-mode)
        ))))

(defun mumamo-chunk-inlined-ssjs (pos min max)
  "Find <script runat=...>...</script>.  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 "<method"
      (optional
       space
       (0+ (not (any ">"))))
      ">"
      ;; FIX-ME: Commented out because of bug in Emacs
      ;;
      ;;(optional (0+ space) "<![CDATA[" )
      ))

(defun mumamo-search-bw-exc-start-inlined-lzx-method (pos min)
  "Helper for `mumamo-chunk-inlined-lzx-method'.
POS is where to start search and MIN is where to stop."
  (goto-char (+ pos 7))
  (let ((marker-start (search-backward "<method" min t))
        exc-mode
        exc-start)
    (when marker-start
      (when (looking-at mumamo-lzx-method-tag-start-regex)
        (setq exc-start (match-end 0))
        (goto-char exc-start)
        (when (<= exc-start pos)
          (cons (point) 'javascript-mode))
        ))))

;; (defun mumamo-search-bw-exc-end-inlined-lzx-method (pos min)
;;   "Helper for `mumamo-chunk-inlined-lzx-method'.
;; POS is where to start search and MIN is where to stop."
;;   (mumamo-chunk-end-bw-str pos min "</method>"))

;; (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 <![CDATA[
;;   (when (and
;;          (eq ?< (char-before))
;;          (eq ?! (char-after))
;;          (not (bobp)))
;;     (backward-char)
;;     (skip-chars-backward "^<"))
;;   (unless (bobp)
;;     (backward-char 1))
;;   (let ((exc-start (search-forward "<method" max t))
;;         exc-mode)
;;     (when exc-start
;;       (goto-char (- exc-start 7))
;;       (when (looking-at mumamo-lzx-method-tag-start-regex)
;;         (goto-char (match-end 0))
;;         (point)
;;         ))))

(defun mumamo-search-fw-exc-start-inlined-lzx-method (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 <![CDATA[
  (when (and
         (eq ?< (char-before))
         (eq ?! (char-after))
         (not (bobp)))
    (backward-char)
    (skip-chars-backward "^<"))
  (unless (bobp)
    (backward-char 1))
  (let ((exc-start (search-forward "<method" max t))
        exc-mode)
    (when exc-start
      (goto-char (- exc-start 7))
      (when (looking-at mumamo-lzx-method-tag-start-regex)
        (goto-char (match-end 0))
        (list (point) 'javascript-mode)
        ))))

(defun mumamo-search-fw-exc-end-inlined-lzx-method (pos max)
  "Helper for `mumamo-chunk-inlined-lzx-method'.
POS is where to start search and MAX is where to stop."
  (save-match-data
    (mumamo-chunk-end-fw-str pos max "</method>")))

(defun mumamo-chunk-inlined-lzx-method (pos min max)
  "Find <method>...</method>.  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 "<handler"
      (optional
       space
       (0+ (not (any ">"))))
      ">"
      ;; FIX-ME: Commented out because of bug in Emacs
      ;;
      ;;(optional (0+ space) "<![CDATA[" )
      ))

;; (defun mumamo-search-bw-exc-start-inlined-lzx-handler (pos min)
;;   "Helper for `mumamo-chunk-inlined-lzx-handler'.
;; POS is where to start search and MIN is where to stop."
;;   (goto-char (+ pos 8))
;;   (let ((marker-start (search-backward "<handler" min t))
;;         exc-mode
;;         exc-start)
;;     (when marker-start
;;       (when (looking-at mumamo-lzx-handler-tag-start-regex)
;;         (setq exc-start (match-end 0))
;;         (goto-char exc-start)
;;         (when (<= exc-start pos)
;;           (cons (point) 'javascript-mode))
;;         ))))

;; (defun mumamo-search-bw-exc-end-inlined-lzx-handler (pos min)
;;   "Helper for `mumamo-chunk-inlined-lzx-handler'.
;; POS is where to start search and MIN is where to stop."
;;   (mumamo-chunk-end-bw-str pos min "</handler>"))

;; (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 <![CDATA[
;;   (when (and
;;          (eq ?< (char-before))
;;          (eq ?! (char-after))
;;          (not (bobp)))
;;     (backward-char)
;;     (skip-chars-backward "^<"))
;;   (unless (bobp)
;;     (backward-char 1))
;;   (let ((exc-start (search-forward "<handler" max t))
;;         exc-mode)
;;     (when exc-start
;;       (goto-char (- exc-start 8))
;;       (when (looking-at mumamo-lzx-handler-tag-start-regex)
;;         (goto-char (match-end 0))
;;         (point)
;;         ))))

(defun mumamo-search-fw-exc-start-inlined-lzx-handler (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 <![CDATA[
  (when (and
         (eq ?< (char-before))
         (eq ?! (char-after))
         (not (bobp)))
    (backward-char)
    (skip-chars-backward "^<"))
  (unless (bobp)
    (backward-char 1))
  (let ((exc-start (search-forward "<handler" max t))
        exc-mode)
    (when exc-start
      (goto-char (- exc-start 8))
      (when (looking-at mumamo-lzx-handler-tag-start-regex)
        (goto-char (match-end 0))
        (list (point) 'javascript-mode)
        ))))

(defun mumamo-search-fw-exc-end-inlined-lzx-handler (pos max)
  "Helper for `mumamo-chunk-inlined-lzx-handler'.
POS is where to start search and MAX is where to stop."
  (save-match-data
    (mumamo-chunk-end-fw-str pos max "</handler>")))

(defun mumamo-chunk-inlined-lzx-handler (pos min max)
  "Find <handler>...</handler>.  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 "<csinstruments>")))
;;     (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 "</csinstruments>"))

;; (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 "<csinstruments>"))

(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 "<csinstruments>")))
    (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 "</csinstruments>")))

(defun mumamo-chunk-csound-orc (pos min max)
  "Find <csinstruments>...</...>.  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 "<csscore>")))
;;     (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 "</csscore>"))

;; (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 "<csscore>"))

(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 "<csscore>")))
    (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 "</csscore>")))

(defun mumamo-chunk-csound-sco (pos min max)
  "Found <csscore>...</csscore>.  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 <script ...>

(defconst mumamo-asp-script-tag-start-regex
  (rx "<script"
      space
      (0+ (not (any ">")))
      "language"
      (0+ space)
      "="
      (0+ space)
      ?\"
      ;;(or "text" "application")
      ;;"/"
      ;;(or "javascript" "ecmascript")
      ;; "text/javascript"
      (submatch
       (or "javascript" "vbscript"))
      ?\"
      (0+ (not (any ">")))
      ">"
      ;; FIX-ME: Commented out because of bug in Emacs
      ;;
      ;;(optional (0+ space) "<![CDATA[" )
      ))

;; (defun mumamo-asp-search-bw-exc-start-inlined-script (pos min)
;;   "Helper function for `mumamo-asp-chunk-inlined-script'.
;; POS is where to start search and MIN is where to stop."
;;   (goto-char (+ pos 7))
;;   (let ((marker-start (search-backward "<script" min t))
;;         (exc-mode 'asp-vb-mode)
;;         exc-start
;;         lang)
;;     (when marker-start
;;       (when (looking-at mumamo-asp-script-tag-start-regex)
;;         (setq lang (downcase (match-string-no-properties 1)))
;;         (cond
;;          ((string= lang "javascript")
;;           (setq exc-mode 'asp-js-mode))
;;          ((string= lang "vbscript")
;;           (setq exc-mode 'asp-vb-mode))))
;;       (setq exc-start (match-end 0))
;;       (goto-char exc-start)
;;       (when (<= exc-start pos)
;;         (cons (point) exc-mode))
;;       )))

;; (defun mumamo-asp-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 <![CDATA[
;;   (when (and
;;          (eq ?< (char-before))
;;          (eq ?! (char-after))
;;          (not (bobp)))
;;     (backward-char)
;;     (skip-chars-backward "^<"))
;;   (unless (bobp)
;;     (backward-char 1))
;;   (let ((exc-start (search-forward "<script" max t))
;;         exc-mode)
;;     (when exc-start
;;       (goto-char (- exc-start 7))
;;       (when (looking-at mumamo-asp-script-tag-start-regex)
;;         (goto-char (match-end 0))
;;         (point)
;;         ))))

(defun mumamo-asp-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 <![CDATA[
  (when (and
         (eq ?< (char-before))
         (eq ?! (char-after))
         (not (bobp)))
    (backward-char)
    (skip-chars-backward "^<"))
  (unless (bobp)
    (backward-char 1))
  (let ((exc-start (search-forward "<script" max t))
        (exc-mode 'asp-vb-mode)
        (lang "vbscript"))
    (when exc-start
      (goto-char (- exc-start 7))
      (when (looking-at mumamo-asp-script-tag-start-regex)
        (goto-char (match-end 0))
        (setq lang (downcase (match-string-no-properties 1)))
        (cond
         ((string= lang "javascript")
          (setq exc-mode 'asp-js-mode))
         ((string= lang "vbscript")
          (setq exc-mode 'asp-vb-mode)))
        (list (point) exc-mode)
        ))))

(defun mumamo-asp-chunk-inlined-script (pos min max)
  "Find <script language=...  runat=...>...</script>.  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>" "</%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" "</%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