;;;; oml-mode.el --- o:XML Integrated Development Environment

;; oml-mode is a copy of xslide modified by Martin Klang to do o:XML 

;; Copyright (C) 1998, 1999, 2000 Tony Graham

;; Author: Tony Graham <tgraham@mulberrytech.com>
;; Contributors: Simon Brooke, Girard Milmeister, Norman Walsh,
;;               Moritz Maass, Lassi Tuura
;; Created: 21 August 1998
;; Version: $Revision: 1.15 $
;; Keywords: languages, oml, xml

;;; This file is not part of GNU Emacs.

;; 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 2
;; of the License, 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 this program; if not, write to the Free Software
;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.


;;;; Commentary:

;; Functions for editing o:XML programs

;; Requires oml-mode-font.el
;; Requires 'etags for `find-tag-default'
;; Requires 'imenu for "Goto" menu
;;

;;;; Code:
(provide 'oml-mode)

(require 'cl)
(require 'compile)
(require 'font-lock)
;; XEmacs users don't always have imenu.el installed, so use
;; condition-case to cope if oml-mode causes an error by requiring imenu.
(eval-and-compile
  (condition-case nil
	(require 'imenu)
    (error nil)))
;; Need etags for `find-tag-default'
(require 'etags)

(require 'oml-mode-data "oml-mode-data")
(require 'oml-mode-abbrev "oml-mode-abbrev")
(require 'oml-mode-font "oml-mode-font")
(require 'oml-mode-process "oml-mode-process")


;; Define core `oml' group.
(defgroup oml nil
  "Major mode for editing o:XML."
  :prefix "oml-"
  :group 'languages)

(defgroup oml-faces nil
  "Font faces used in o:XML mode."
  :group 'oml
  :group 'faces)

(defgroup oml-process nil
  "Running o:XML processors from o:XML mode."
  :group 'oml)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Version information

(defconst oml-mode-version "0.2b2"
  "Version number of oml-mode o:XML mode.")

(defun oml-mode-version ()
  "Returns the value of the variable oml-mode-version."
  oml-mode-version)

(defconst oml-mode-maintainer-address "bugs@o-xml.org")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Variables

(defvar oml-indent-tabs-mode nil
  "*Initial value of indent-tabs-mode on entering oml-mode")

(defvar oml-default-filespec "*.oml"
  "*Inital prompt value for `oml-etags''s FILESPEC argument.")

(defvar oml-filespec-history (list oml-default-filespec)
  "Minibuffer history list for `oml-etags' and `oml-grep''s FILESPEC argument.")

(defvar oml-grep-pattern-history nil
  "Minibuffer history list for `oml-grep''s PATTERN argument.")

(defvar oml-grep-case-sensitive-flag nil
  "*Non-nil disables case insensitive searches by `oml-grep'.")

(defvar oml-comment-start "<!--"
  "*Comment start character sequence")

(defvar oml-comment-end "-->"
  "*Comment end character sequence")

(defvar oml-comment-max-column 70
  "*Maximum column number for text in a comment")

(defcustom oml-initial-program-file (locate-library "oml-mode-initial.oml" t)
  "*File containing initial program inserted into empty o:XML buffers"
  :type '(choice (file :must-match t) (const :tag "No initial program" nil))
  :group 'oml)

(defcustom oml-initial-program-initial-point 0
  "*Initial position of point in initial program"
  :type '(integer)
  :group 'oml)

(defvar oml-indent-attributes nil
  "*Whether to indent attributes on lines following an open tag.
If non-nil, attributes will be aligned with the space after the
element name, otherwise by two spaces.")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; functions

(defun oml-read-from-minibuffer (prompt default history)
  "Read from minibuffer with default and command history."
(let ((value nil))
  (if (string-equal
       ""
       (setq value
	     (read-from-minibuffer (if default
				       (format
					"%s(default `%s') "
					prompt default)
				     (format "%s" prompt))
				   nil nil nil
				   history)))
	     default
	     value)))

;; o:XML IDE house style puts all comments starting on a favourite column
(defun oml-comment (comment)
  "Insert COMMENT starting at the usual column.

With a prefix argument, e.g. \\[universal-argument] \\[oml-comment], insert separator comment
lines above and below COMMENT in the manner of `oml-big-comment'."
  (interactive "sComment: ")
  (insert "\n")
  (backward-char)
  (oml-electric-tab)
  (let ((fill-column (1- oml-comment-max-column))
	(fill-prefix (make-string (1+ (length oml-comment-start)) ?\ ))
;;	(comment-start oml-init-comment-fill-prefix)
	(saved-auto-fill-function auto-fill-function))
    (auto-fill-mode 1)
    (insert oml-comment-start)
    (insert " ")
    (indent-to (length fill-prefix))
    (fill-region (point) (save-excursion
			   (insert comment)
			   (point))
		 nil
		 1
		 1)
    ;; The fill does the right thing, but it always ends with
    ;; an extra newline, so delete the newline.
    (delete-backward-char 1)
    (if (not saved-auto-fill-function)
	(auto-fill-mode 0))
    (insert " ")
    (insert oml-comment-end)
    (insert "\n")
    (if font-lock-mode
	(save-excursion
	  (font-lock-fontify-keywords-region
	   (oml-font-lock-region-point-min)
	   (oml-font-lock-region-point-max))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Mode map stuff

(defvar oml-mode-map nil
  "Keymap for o:XML mode.")

(if oml-mode-map
    ()
  (setq oml-mode-map (make-sparse-keymap))
  (define-key oml-mode-map [tab]	  'oml-electric-tab)
;;  (define-key oml-mode-map "\M-\t"	  'oml-complete)
  (define-key oml-mode-map [(meta tab)]	  'oml-complete)
;;  (define-key oml-mode-map "\""   	  'oml-electric-quote)
;;  (define-key oml-mode-map "'"   	  'oml-electric-apos)
  (define-key oml-mode-map "/"   	  'oml-electric-slash)
  (define-key oml-mode-map "<"   	  'oml-electric-less-than)
  (define-key oml-mode-map ">"            'oml-electric-greater-than)
;;  (define-key oml-mode-map "["   	  'oml-electric-lsqb)
;;  (define-key oml-mode-map "("   	  'oml-electric-lpar)
;;  (define-key oml-mode-map "{"   	  'oml-electric-lcub)
  (define-key oml-mode-map [(control c) (control c)]
				   	  'oml-comment)
  (define-key oml-mode-map [(control c) (control p)]
				   	  'oml-process)
  (define-key oml-mode-map "\C-c<"  	  'oml-insert-tag)
;;  (define-key oml-mode-map [(control m)]	  'oml-electric-return)
;;  (define-key oml-mode-map \10	  'oml-electric-return)
  (define-key oml-mode-map "\177"	  'backward-delete-char-untabify)
;;  (define-key oml-mode-map "\M-\C-e" 'oml-next-rule)
;;  (define-key oml-mode-map "\M-\C-a" 'oml-previous-rule)
;;  (define-key oml-mode-map "\M-\C-h" 'mark-oml-rule)
)

(defun oml-electric-greater-than ()
  (interactive)
  (insert ">")
  (if font-lock-mode
      (save-excursion
	(font-lock-fontify-region
	 (oml-font-lock-region-point-min)
	 (oml-font-lock-region-point-max)))))

(defun oml-electric-apos ()
  "Function called when \"'\" is pressed in o:XML mode"
  (interactive)
  (insert "'")
  (if (looking-at "\\([\"/})]\\|$\\)")
      (save-excursion
	(insert "'"))))

(defun oml-electric-quote ()
  "Function called when '\"' is pressed in o:XML mode"
  (interactive)
  (insert "\"")
  (if (looking-at "\\(['/})]\\|$\\)")
      (save-excursion
	(insert "\""))))

(defun oml-electric-lsqb ()
  "Function called when \"[\" is pressed in o:XML mode"
  (interactive)
  (insert "[")
  (if (looking-at "\\([\"'/})]\\|$\\)")
      (save-excursion
	(insert "]"))))

(defun oml-electric-lpar ()
  "Function called when \"(\" is pressed in o:XML mode"
  (interactive)
  (insert "(")
  (if (looking-at "\\([\]\"'/}]\\|$\\)")
      (save-excursion
	(insert ")"))))

(defun oml-electric-lcub ()
  "Function called when \"{\" is pressed in o:XML mode"
  (interactive)
  (insert "{")
  (if (looking-at "\\([\])\"'/}]\\|$\\)")
      (save-excursion
	(insert "}"))))

(defun oml-electric-less-than ()
  "Function called when \"<\" is pressed in o:XML mode"
  (interactive)
  (insert "<")
  (oml-electric-tab))

(defun oml-match-opening-tag (a)
  "Function called to match the next opening tag to a closing tag"
  (if (looking-at "</")
      (catch 'start-tag
        (while (re-search-backward
                (concat "\\(<\\|</\\)" a "[ \t\n\r>]") nil t)
          (cond
           ((looking-at (concat "</" a))
            (oml-match-opening-tag a))
           ((looking-at (concat "<" a))
            (throw 'start-tag a))
           )))
    nil)
)
(defun oml-electric-slash ()
  "Function called when \"/\" is pressed in o:XML mode"
  (interactive)
  (insert "/")
  (oml-electric-tab)
  (if (looking-at "$")
      (let ((element-name
	     (save-excursion
	       (backward-char 2)
	       (if (looking-at "</")
		   (catch 'start-tag
		     (while (re-search-backward "<" nil t)
		       (cond
			((looking-at "</\\([^/> \t]+\\)>")
;;			 (message "End tag: %s" (match-string 1))
; find matching tag:
                         (oml-match-opening-tag (match-string 1)))
;;original
;;                       (re-search-backward
;;                        (concat "<" (match-string 1) "[ \t\n\r>]") nil t))
			((looking-at "<\\(\\([^/>]\\|/[^>]\\)+\\)/>"))
;;			 (message "Empty tag: %s" (match-string 1)))
			((looking-at "<!--[^-]*\\(-[^-]+\\)*-->"))
			((looking-at "<\\([^/> \n\t]+\\)")
;;			 (message "Start tag: %s" (match-string 1))
			 (throw 'start-tag (match-string 1)))
			((bobp)
			 (throw 'start-tag nil)))))
		 nil))))
	(if element-name
	    (progn
	      (insert element-name)
	      (oml-electric-greater-than))))))


(defun oml-electric-return ()
  (interactive)
  (insert "\n")
  (oml-electric-tab))

(defun oml-electric-tab ()
  "Function called when TAB is pressed in o:XML mode."
  (interactive)
  (save-excursion
    (beginning-of-line)
    (delete-horizontal-space)
    (if (or
	 (looking-at "</")
	 (looking-at "<!"))
	(indent-to (max 0 (- (oml-calculate-indent) 2)))
      (indent-to (oml-calculate-indent))))
  (if (and
       (bolp)
       (looking-at "[ \t]+"))
      (goto-char (match-end 0)))
  (if font-lock-mode
      (save-excursion
	(font-lock-fontify-keywords-region
	 (oml-font-lock-region-point-min)
	 (oml-font-lock-region-point-max)))))


(defun oml-close-open-tab-p nil
  "Return 'T' if the current line contains more right than left angle-brackets"
  (save-excursion
    (beginning-of-line)
    (let ((open 0))
      (while (not (eolp))
	(let ((here (char-after (point))))
	  (cond
	   ((eq here '?\>) (setq open (1- open)))
	   ((eq here '?\<) (setq open (1+ open)))
	   )
	  )
	(forward-char)
	)
      (< open 0)			; true if we've counted more
					; closes than opens
      )
    )
  )

(defun oml-calculate-indent ()
  "Calculate what the indent should be for the current line"
  (interactive)
  (let* ((limit   (point))
 	 (name    "[^<>=\"' \t\n]+")
 	 (string  "\\(\"[^<>\"]*\"\\|'[^<>']*'\\)")
 	 (ostring "\\(\"[^<>\"]*\\|'[^<>']*\\)")
 	 (attval  (concat name "=" string))
 	 (oattval (concat name "=" ostring))
 	 (element (concat "<\\(" name "\\)"
 			  "\\([ \t\n]+" attval "\\)*"))
 	 (meta    (concat "<!\\(DOCTYPE\\|ENTITY\\)"
 			  "\\([ \t\n]+\\(" name "\\|" string "\\)\\)*")))
    (save-excursion
      (if (re-search-backward "^\\([ \t]*\\)<" nil t)
	  (goto-char (match-end 1))
	(beginning-of-line))
      (cond
       ;; closed comment => stay put
       ((save-excursion
 	  (re-search-forward "<!--[^-]*\\(-[^-]+\\)*-->" limit t))
 	(current-column))
       ;; open comment => indent by five
       ((looking-at "<!--")
 	(+ (current-column) 5))
       ;; end tag, closed empty tag, open tag immediately followed by
       ;; other tags/char data or a complete meta tag => stay put
       ((save-excursion
 	  (or (looking-at (concat "</" name ">"))
 	      (re-search-forward (concat element "/>") limit t)
 	      (re-search-forward (concat element ">[ \t]*[^\n]") limit t)
 	      (re-search-forward (concat meta ">[ \t]*\n") limit t)))
 	(current-column))
       ;; closed open tag followed by new line, or an opening meta tag
       ;; => indent by two
       ((save-excursion
 	  (or (re-search-forward (concat element ">[ \t]*\n") limit t)
 	      (re-search-forward (concat meta "\\[[ \t]*\n") limit t)))
 	(+ (current-column) 2))
       ;; incomplete open tag or open meta => indent after tag name
       ((save-excursion
 	  (and (or (re-search-forward (concat element "[ \t\n]*") limit t)
 		   (re-search-forward (concat meta "[ \t\n]*") limit t))
 	       (= (point) limit)))
 	(if oml-indent-attributes
 	    (progn (goto-char (match-end 1))
 		   (+ (current-column) 1))
 	  (+ (current-column) 2)))
       ;; incomplete attribute value => indent to string start
       ((save-excursion
 	  (and (or (re-search-forward (concat element "[ \t\n]+" oattval)
 				      limit t))
 	       (= (point) limit)))
 	(goto-char (match-beginning 4))
 	(+ (current-column) 1))
       ;; beginning of buffer => stay put (beginning of line)
       ((bobp)
 	(current-column))
       ;; otherwise => indent by two
       (t
 	(+ (current-column) 2))))))

(defun oml-complete ()
  "Complete the tag or attribute before point.
If it is a tag (starts with < or </) complete with allowed tags,
otherwise complete with allowed attributes."
  (interactive "*")
  (let ((tab				; The completion table
	 nil)
	(pattern nil)
	(c nil)
	(here (point)))
    (skip-chars-backward "^ \n\t</!&%")
    (setq pattern (buffer-substring (point) here))
    (setq c (char-after (1- (point))))
;;    (message "%s" c)
    (cond
     ;; entitiy
;;     ((eq c ?&)
;;      (sgml-need-dtd)
;;      (setq tab
;;	    (sgml-entity-completion-table
;;	     (sgml-dtd-entities (sgml-pstate-dtd sgml-buffer-parse-state)))))
     ;; start-tag
     ((eq c ?<)
;;      (save-excursion
;;	(backward-char 1)
;;	(sgml-parse-to-here)
	(setq tab oml-all-elements-alist))
     ;; end-tag
;;     ((eq c ?/)
;;      (save-excursion
;;	(backward-char 2)
;;	(sgml-parse-to-here)
;;	(setq tab (sgml-eltype-completion-table
;;		   (sgml-current-list-of-endable-eltypes)))))
     ;; markup declaration
;;     ((eq c ?!)
;;      (setq tab sgml-markup-declaration-table))
     ((eq c ? )
;;      (save-excursion
;;	(backward-char 1)
;;	(sgml-parse-to-here)
	(setq tab oml-all-attribute-alist))
     (t
      (goto-char here)
      (ispell-complete-word)))
    (when tab
      (let ((completion (try-completion pattern tab)))
	(cond ((null completion)
	       (goto-char here)
	       (message "Can't find completion for \"%s\"" pattern)
	       (ding))
	      ((eq completion t)
	       (goto-char here)
	       (message "[Complete]"))
	      ((not (string= pattern completion))
	       (delete-char (length pattern))
	       (insert completion))
	      (t
	       (goto-char here)
	       (message "Making completion list...")
	       (let ((list (all-completions pattern tab)))
		 (with-output-to-temp-buffer " *Completions*"
		   (display-completion-list list)))
	       (message "Making completion list...%s" "done")))))))

(defun oml-insert-tag (tag)
  "Insert a tag, reading tag name in minibuffer with completion."
  (interactive 
   (list
    (completing-read "Tag: " oml-all-elements-alist)))
  ;;  (oml-find-context-of (point))
  ;;  (assert (null oml-markup-type))
  ;; Fix white-space before tag
  ;;  (unless (oml-element-data-p (oml-parse-to-here))
  (skip-chars-backward " \t")
  (cond
   ((looking-at "^\\s-*$")
    (oml-electric-tab))
   ((looking-at "^\\s-*</")
    (save-excursion
      (insert "\n"))
    (oml-electric-tab))
   ((looking-at "$")
    (insert "\n")
    (oml-electric-tab)))
  (let ((tag-type (nth 1 (assoc tag oml-all-elements-alist))))
    (cond
     ((or
       (equal tag-type "block")
       (equal tag-type nil))
      (insert "<")
      (insert tag)
      (insert ">")
      (save-excursion
	(insert "\n")
	(oml-electric-tab)
	(insert "<")
	(if (looking-at "<")
	    (progn
	      (insert "\n")
	      (backward-char)))
	(oml-electric-slash)))
     ((equal tag-type "inline")
      (insert "<")
      (insert tag)
      (insert ">")
      (save-excursion
	(insert "</")
	(insert tag)
	(insert ">")))
     (t
      (insert "<")
      (insert tag)
      (save-excursion
	(insert "/>"))))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Syntax table stuff

(defvar oml-mode-syntax-table nil
  "Syntax table used while in o:XML mode.")

(if oml-mode-syntax-table
    ()
  (setq oml-mode-syntax-table (make-syntax-table))
  ;; set the non-alphanumeric characters in XML names to
  ;; 'symbol constituent' class
  (modify-syntax-entry ?: "_" oml-mode-syntax-table)
  (modify-syntax-entry ?_ "_" oml-mode-syntax-table)
  (modify-syntax-entry ?- "_ 1234" oml-mode-syntax-table)
  (modify-syntax-entry ?. "_" oml-mode-syntax-table)
  ;; "-" is a special case because it is the first and second characters
  ;; of the start- and end-comment sequences.
  (modify-syntax-entry ?- "_ 1234" oml-mode-syntax-table)
  ;; "%" does double duty in parameter entity declarations and references.
  ;; Not necessary to make "%" and ";" act like parentheses since the
  ;; font lock highlighting tells you when you've put the ";" on the
  ;; end of a parameter entity reference.
  (modify-syntax-entry ?% "_" oml-mode-syntax-table)
  (modify-syntax-entry ?\; "_" oml-mode-syntax-table)
  ;; "/" is just punctuation in o:XMLs, and really only has a role in
  ;; Formal Public Identifiers
  (modify-syntax-entry ?/ "." oml-mode-syntax-table)
  ;; Sometimes a string is more than just a string, Dr Freud.
  ;; Unfortunately, the syntax stuff isn't fussy about matching
  ;; on paired delimiters, and will happily match a single quote
  ;; with a double quote, and vice versa.  At least the font
  ;; lock stuff is more fussy and won't change colour if the
  ;; delimiters aren't paired.
  (modify-syntax-entry ?\" "$" oml-mode-syntax-table)
  (modify-syntax-entry ?\' "$" oml-mode-syntax-table)
  ;; The occurrence indicators and connectors are punctuation to us.
  (modify-syntax-entry ?| "." oml-mode-syntax-table)
  (modify-syntax-entry ?, "." oml-mode-syntax-table)
  (modify-syntax-entry ?& "." oml-mode-syntax-table)
  (modify-syntax-entry ?? "." oml-mode-syntax-table)
  (modify-syntax-entry ?+ "." oml-mode-syntax-table)
  (modify-syntax-entry ?* "." oml-mode-syntax-table)
  ;; `<' and `>' are also punctuation
  (modify-syntax-entry ?< "." oml-mode-syntax-table)
  (modify-syntax-entry ?> "." oml-mode-syntax-table)
  ;; "#" is syntax too
  (modify-syntax-entry ?# "_" oml-mode-syntax-table))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; imenu stuff

(defun oml-sort-alist (alist)
  "Sort an alist"
  (sort
   alist
   (lambda (a b) (string< (car a) (car b)))))

(defun oml-imenu-create-index-function ()
  "Create an alist of elements, etc. suitable for use with imenu."
  (interactive)
  (let ((template-alist '())
	(mode-alist '())
	(name-alist '()))
    (goto-char (point-min))
    (while
	(re-search-forward
	 "^\\s-*<oml:template\\(\\s-+\\)" nil t)
      ;; Go to the beginning of the whitespace after the element name
      (goto-char (match-beginning 1))
      ;; Match on either single-quoted or double-quoted attribute value.
      ;; The expression that doesn't match will have return nil for
      ;; `match-beginning' and `match-end'.
      ;; Don't move point because the 'mode' attribute may be before
      ;; the 'match' attribute.
      (if (save-excursion
	    (re-search-forward
	     "match\\s-*=\\s-*\\(\"\\([^\"]*\\)\"\\|'\\([^']*\\)'\\)"
	     (save-excursion
	       (save-match-data
		 (re-search-forward "<\\|>" nil t)))
	     t))
	  (let* ((pattern (buffer-substring-no-properties
			   ;; Rely on the pattern that didn't match
			   ;; returning nil and on `or' evaluating the
			   ;; second form when the first returns nil.
			   (or
			    (match-beginning 2)
			    (match-beginning 3))
			   (or
			    (match-end 2)
			    (match-end 3))))
		 (pattern-position (or
				    (match-beginning 2)
				    (match-beginning 3))))
	    ;; Test to see if there is a 'mode' attribute.
	    ;; Match on either single-quoted or double-quoted attribute value.
	    ;; The expression that doesn't match will have return nil for
	    ;; `match-beginning' and `match-end'.
	    (if (save-excursion
		  (re-search-forward
		   "mode\\s-*=\\s-*\\(\"\\([^\"]*\\)\"\\|'\\([^']*\\)'\\)"
		   (save-excursion
		     (save-match-data
		       (re-search-forward "<\\|>" nil t)))
		   t))
		(let* ((mode-name (buffer-substring-no-properties
				   ;; Rely on the pattern that didn't match
				   ;; returning nil and on `or' evaluating the
				   ;; second form when the first returns nil.
				   (or
				    (match-beginning 2)
				    (match-beginning 3))
				   (or
				    (match-end 2)
				    (match-end 3))))
		       (mode-name-alist (assoc mode-name mode-alist)))
		  (if mode-name-alist
		      (setcdr mode-name-alist
			      (list (car (cdr mode-name-alist))
				    (cons pattern pattern-position)))
		    (setq mode-alist
			  (cons
			   (list mode-name (cons pattern pattern-position))
			   mode-alist))))
	      (setq template-alist
		    (cons (cons pattern pattern-position)
			  template-alist)))))
      ;; When there's no "match" attribute, can still have "name"
      ;; attribute
      (if (save-excursion
	    (re-search-forward
	     "\\s-+name\\s-*=\\s-*\\(\"\\([^\"]*\\)\"\\|'\\([^']*\\)'\\)"
	     (save-excursion
	       (save-match-data
		 (re-search-forward "<\\|>" nil t)))
	     t))
	  (setq name-alist
		(cons
		 (cons (buffer-substring-no-properties
			;; Rely on the pattern that didn't match
			;; returning nil and on `or' evaluating the
			;; second form when the first returns nil.
			(or
			 (match-beginning 2)
			 (match-beginning 3))
			(or
			 (match-end 2)
			 (match-end 3)))
		       (or
			(match-beginning 2)
			(match-beginning 3)))
		 name-alist))))
    (append
     (if name-alist
	 (list (cons "name=" (oml-sort-alist name-alist))))
     (if mode-alist
	 ;; Sort the mode-alist members, format the mode names nicely,
	 ;; and sort the templates within each mode.
	 (append
	  (mapcar (lambda (x)
		    (cons (format "mode=\"%s\"" (car x))
			  (oml-sort-alist (cdr x))))
		  (oml-sort-alist mode-alist))))
     (oml-sort-alist template-alist))))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; grep stuff

;;;###autoload
(defun oml-grep (pattern filespec)
  "Grep for PATTERN in files matching FILESPEC.

Runs `grep' with PATTERN and FILESPEC as arguments.

PATTERN is the pattern on which `grep' is to match.  PATTERN is quoted
with single quotes in the `grep' command arguments to avoid
interpretation of characters in PATTERN.  `oml-grep' maintains a
history of PATTERNs so you can easily re-use a previous value.

FILESPEC is the names or regular expression for the files to be
scanned by grep.  Since `oml-grep' uses `grep', regular expressions
and multiple filenames are supported, and \"*.oml\" and \"*.o:XML
*.ent\" are both valid FILESPEC values.

When called interactively, the initial FILESPEC is taken from
oml-default-filespec, but `oml-grep' also maintains a history of
FILESPEC arguments so you can easily re-use a previous value.  The
history is shared with `oml-etags' so you can re-use the same FILESPEC
with both functions.
"
  (interactive
   (list
    (oml-read-from-minibuffer "Pattern: "
			      (find-tag-default)
			      'oml-grep-pattern-history)
    (oml-read-from-minibuffer "Files: "
			      (car oml-filespec-history)
			      'oml-filespec-history)))
  ;; Include "--" in the command in case the pattern starts with "-"
  (grep (format "grep -n %s -- '%s' %s"
		(if (not oml-grep-case-sensitive-flag)
		    "-i")
		pattern
		filespec)))


;;;###autoload
(defun oml-mode ()
  "Major mode for editing o:XML programs.

Special commands:
\\{oml-mode-map}
Turning on o:XML mode calls the value of the variable `oml-mode-hook',
if that value is non-nil.

Abbreviations:

o:XML mode includes a comprehensive set of o:XML-specific abbreviations
preloaded into the abbreviations table.

Font lock mode:

Turning on font lock mode causes various o:XML syntactic structures to be 
hightlighted. To turn this on whenever you visit an o:XML file, add
the following to your .emacs file:
  \(add-hook 'oml-mode-hook 'turn-on-font-lock\)
"
  (interactive)
  (kill-all-local-variables)
  (use-local-map oml-mode-map)
  (setq mode-name "o:XML")
  (setq major-mode 'oml-mode)
  (setq local-abbrev-table oml-mode-abbrev-table)
  ;; XEmacs users don't all have imenu
  (if (featurep 'imenu)
      (progn
	;; If you don't have imenu, you'll get a "free variable"
	;; warning for imenu-create-index-function when you
	;; byte-compile, but not having imenu won't cause problems
	;; when you use oml-mode
	(setq imenu-create-index-function 'oml-imenu-create-index-function)
	(setq imenu-extract-index-name-function 'oml-imenu-create-index-function)
	(imenu-add-to-menubar "Templates")))
  ;; comment stuff
;;  (make-local-variable 'comment-column)
;;  (setq comment-column 32)
;;  (make-local-variable 'comment-start)
;;  (setq comment-start "; ")
;;  (make-local-variable 'comment-end)
;;  (setq comment-end "\n")
;;  (make-local-variable 'comment-start-skip)
;;  (setq comment-start-skip ";;* *")
  ;;
  ;; later we should move this into the oml-mode-hook in
  ;; our local .emacs file
  ;; (abbrev-mode t)
  ;;
  ;; o:XML font-lock highlighting setup
;;  (oml-font-make-faces)
  (make-local-variable 'font-lock-defaults)
  (setq font-lock-defaults '(oml-font-lock-keywords t))
  (setq font-lock-mark-block-function 'oml-font-lock-mark-block-function)
;;  (make-local-variable 'font-lock-defaults)
;;  (setq font-lock-defaults 
;;	'(oml-font-lock-keywords nil t ((?- . "w")
;;					(?_ . "w")
;;					(?. . "w"))))
  ;; add an entry to compilation-error-regexp-alist for o:XML
  ;; compiler errors
;;  (setq compilation-error-regexp-alist
;;	(cons '("file:/c:/projects/oml-mode/test.oml:29:
;;o:XML Error on line \\([0-9]*\\) in file \\(.*\\):$" 2 1)
;;	      compilation-error-regexp-alist))

  (set-syntax-table oml-mode-syntax-table)
  ;; Maybe insert space characters when user hits "Tab" key
  (setq indent-tabs-mode oml-indent-tabs-mode)
  (if (and
       oml-initial-program-file
       (eq (point-min) (point-max)))
      (progn
	(insert-file-contents oml-initial-program-file)
	(goto-char oml-initial-program-initial-point)))
  (run-hooks 'oml-mode-hook))


;;;; Bug reporting

(eval-and-compile
  (autoload 'reporter-submit-bug-report "reporter"))

(defun oml-submit-bug-report ()
  "Submit via mail a bug report on o:XML oml-mode."
  (interactive)
  (and (y-or-n-p "Do you really want to submit a report on o:XML mode? ")
       (reporter-submit-bug-report
	oml-mode-maintainer-address
	(concat "oml-mode.el " oml-mode-version)
	(list 
	 )
	nil
	nil
     "Please change the Subject header to a concise bug description.\nRemember to cover the basics, that is, what you expected to\nhappen and what in fact did happen.  Please remove these\ninstructions from your message.")
    (save-excursion
      (goto-char (point-min))
      (mail-position-on-field "Subject")
      (beginning-of-line)
      (delete-region (point) (progn (forward-line) (point)))
      (insert
       "Subject: oml-mode version " oml-mode-version " is wonderful but...\n"))))


;;;; Last provisions
;;;(provide 'oml-mode)

;;; oml-mode.el ends here