racc-mode.el

;; racc-mode.el
;; 
;; Copyright (c) 2001 sheepman
;; All rights reserved.
;;
;; Redistribution and use in source and binary forms, with or without
;; modification, are permitted provided that the following conditions
;; are met:
;; 1. Redistributions of source code must retain the above copyright
;;    notice, this list of conditions and the following disclaimer.
;; 2. Redistributions in binary form must reproduce the above copyright
;;    notice, this list of conditions and the following disclaimer in the
;;    documentation and/or other materials provided with the distribution.
;; 3. The name of the author may not be used to endorse or promote products
;;    derived from this software without specific prior written permission.
;;
;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
;; IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
;; OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
;; IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
;; INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
;; NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
;; THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;
;; write the following in your .emacs file
;; racc-mode
;; (autoload 'racc-mode "racc-mode" "alternate mode for editing racc files" t)
;; (setq auto-mode-alist (append '(("\\.ry$" . racc-mode)) auto-mode-alist))
;;


(require 'derived)

(define-derived-mode racc-mode ruby-mode "Racc"
  "Major mode for Racc editing."
  (interactive)
  (setq indent-line-function 'racc-indent-line)
  (define-key racc-mode-map "\t" 'racc-indent-command)
  (define-key racc-mode-map "\C-j" 'racc-reindent-newline-and-indent)
  (run-hooks 'racc-mode-hook))

(defun racc-indent-command ()
  (interactive)
  (racc-indent-line t))

(defun racc-reindent-newline-and-indent ()
  (interactive)
  (racc-indent-command)
  (newline)
  (racc-indent-command))

(defun racc-indent-line (&optional flag)
  (if (string-match "^[ \t]*rule[ \t]*$" (current-line))
      (racc-indent-to 0)
    (if (point-in-rule)
	(racc-indent-to (racc-calculate-indent))
      (if (point-before-rule)
	  (racc-indent-to (racc-calculate-indent-before-rule))
	(ruby-indent-line t)))))
  

(defun beginning-of-rule ()
  (beginning-of-buffer)
  (re-search-forward "^rule")
  (beginning-of-line))

(defun end-of-rule ()
  (beginning-of-buffer)
  (re-search-forward "^end")
  (end-of-line))

(defun point-in-rule ()
  (save-excursion
    (and (re-search-backward-without-moving-point "^rule")
	 (or (not (re-search-backward-without-moving-point "^end"))
	     (< (re-search-backward-without-moving-point "^end")
		(re-search-backward-without-moving-point "^rule"))))))

(defun point-before-rule ()
  (save-excursion
    (and (re-search-backward-without-moving-point "^class"))
	 (re-search-forward-without-moving-point "^rule")))

(defun point-in-prec ()
  (save-excursion
    (and (point-before-rule)
	 (or (and (re-search-backward-without-moving-point "^prechigh")
		  (re-search-forward-without-moving-point "^preclow"))
	     (and (re-search-forward-without-moving-point "^prechigh")
		  (re-search-backward-without-moving-point "^preclow"))
	     ))))

(defun point-in-convert ()
  (save-excursion
    (point-before-rule)
	 (and (re-search-backward-without-moving-point "^convert")
	      (re-search-forward-without-moving-point "^end"))))

(defun point-in-token-statement ()
  (save-excursion
    (defun match-token-line (str)
      (or (string-match "^[ \t]*|[ \t]*"
			str)
	  (string-match "^[ \t]*[^ \t\n]+[ \t]*:"
			str)))
    (and (point-in-rule)
	 (or (match-token-line (current-line))
	     (and (not (string-match "^[ \t]*[{}][ \t]*$" (current-line)))  
		  (save-excursion
		    (forward-line -1)
		    (match-token-line (current-line)))
		  (save-excursion
		    (forward-line 1)
		    (match-token-line (current-line))))))))

(defun point-in-action-statement ()
  (and (point-in-rule)
       (not (point-in-token-statement))))

(defun beginning-of-action ()
  (if (point-in-action-statement)
      (re-search-backward "^[ \t]*{" nil t)
    nil))

(defvar racc-indent-level 2)
(setq racc-token-length-max 11)

(defun racc-indent-to (x)
  (ruby-indent-to x))

(defun racc-calculate-indent ()
  (save-excursion
    (if (point-in-token-statement)
	(if (string-match "^[ \t]*|[ \t]*" (current-line))
	    (+ racc-indent-level 
	       racc-token-length-max)
	  (if (string-match "\\([^ \t\n]+[ \t]*\\):" (current-line)) 
	      (let ((strlen (string-length 
			     (match-string 1 (current-line))))
		    (ind (+ racc-indent-level 
			    racc-token-length-max)))
		(if (> strlen ind)
		    0
		  (- ind strlen)))
	    (+ racc-indent-level 
	       racc-token-length-max 
	       (* 2 racc-indent-level))))
      (if (string-match "^[ \t]*[{}][ \t]*$" (current-line))
	  (+ racc-indent-level 
	     racc-token-length-max 
	     (* 2 racc-indent-level))
	(ruby-calculate-indent (max (save-excursion
				      (ruby-beginning-of-indent)
				      (point))
				    (save-excursion
				      (beginning-of-action)
				      (point))))))))

(defun racc-calculate-indent-before-rule ()
  (cond ((or (string-match "^[ \t]*prechigh" (current-line))
	     (string-match "^[ \t]*preclow" (current-line)))
	 0)	   
	((point-in-prec)
	 racc-indent-level)	
	((string-match "^[ \t]*expect" (current-line))
	 0)
	((or (string-match "^[ \t]*convert" (current-line))
	     (string-match "^[ \t]*end" (current-line)))
	 0)
	((point-in-convert)
	 racc-indent-level)	
	((string-match "^[ \t]*token" (current-line))
	 0)
	((string-match "^[ \t]*start" (current-line))
	 0)
	(t 0)))


;;;;;;;;;;;;;;;;;;;;;;;;;
;; general functions
;;;;;;;;;;;;;;;;;;;;;;;;

(defun current-line ()
  (save-excursion
    (buffer-substring (save-excursion (beginning-of-line)
				      (point))
		      (save-excursion (end-of-line)
				      (1+ (point))))))
(defun string-length (str)
  (- (string-match "$" str) (string-match "^" str)))

(defun re-search-forward-without-moving-point (str)
  (save-excursion
    (re-search-forward str nil t)))

(defun re-search-backward-without-moving-point (str)
  (save-excursion
    (re-search-backward str nil t)))

(provide 'racc-mode)