--- /dev/null
+;; Haskell major mode
+;; (c) Copyright, Richard McPhee et al.
+;; University of Glasgow, February 1993
+
+
+
+;; if .hs is not recognised then put the extension in auto-mode-list
+
+(if (assoc "\\.hs" auto-mode-alist)
+ nil
+ (nconc auto-mode-alist '(("\\.hs". haskell-mode))))
+
+(if (assoc "\\.hi" auto-mode-alist)
+ nil
+ (nconc auto-mode-alist '(("\\.hi". haskell-mode))))
+
+(if (assoc "\\.gs" auto-mode-alist)
+ nil
+ (nconc auto-mode-alist '(("\\.gs". haskell-mode))))
+
+(defvar haskell-mode-syntax-table nil
+ "Syntax table for haskell-mode buffers.")
+
+(defvar haskell-mode-abbrev-table nil
+ "Abbrev table for haskell-mode buffers.")
+
+(defvar haskell-mode-map (make-sparse-keymap)
+ "Keymap for haskell-mode-buffers.")
+
+
+
+;;; Here are the keymaps used in haskell-mode
+
+(define-key haskell-mode-map "\M-;" 'haskell-insert-comment)
+(define-key haskell-mode-map "\C-c=" 'haskell-insert-concat)
+(define-key haskell-mode-map "\C-c;" 'set-haskell-comment-column)
+(define-key haskell-mode-map "\C-c+" 'set-haskell-concat-column)
+(define-key haskell-mode-map "\C-cn" 'set-haskell-indent-offset)
+(define-key haskell-mode-map "\C-cl" 'set-haskell-list-offset)
+(define-key haskell-mode-map "\C-ci" 'set-haskell-if-offset)
+(define-key haskell-mode-map "\C-ce" 'set-haskell-let-offset)
+(define-key haskell-mode-map "\C-cc" 'set-haskell-case-offset)
+(define-key haskell-mode-map "\C-ct" 'set-haskell-then-offset)
+(define-key haskell-mode-map "\C-co" 'set-haskell-comp-offset)
+(define-key haskell-mode-map "\C-cw" 'set-haskell-where-offset)
+(define-key haskell-mode-map "\C-cg" 'goto-line)
+(define-key haskell-mode-map "\C-j" 'haskell-reindent-then-newline-and-indent)
+(define-key haskell-mode-map "\t" 'haskell-indent-line)
+(define-key haskell-mode-map "}" 'electric-haskell-brace)
+(define-key haskell-mode-map "]" 'electric-haskell-brace)
+(define-key haskell-mode-map ")" 'haskell-insert-round-paren)
+(define-key haskell-mode-map "\C-cr" 'haskell-indent-region)
+(define-key haskell-mode-map "\C-cf" 'haskell-further-indent)
+(define-key haskell-mode-map "\C-cb" 'haskell-lesser-indent)
+(define-key haskell-mode-map "\177" 'backward-delete-char-untabify)
+(define-key haskell-mode-map "\M-\C-\177" 'delete-horizontal-space)
+
+(defun haskell-set-local-vars ()
+ "Set the local variables for haskell-mode."
+ (kill-all-local-variables)
+
+ (setq indent-line-function 'haskell-indent-line)
+
+ (make-local-variable 'haskell-std-list-indent)
+ ;;Non-nil means indent to the offset, 'haskell-list-offset' in a bracket rather than
+ ;; moving to the next word afer a function name
+ (setq haskell-std-list-indent t)
+
+ (make-local-variable 'haskell-nest-ifs)
+ ;;Non-nil means that 'if' statements are nested ie. lined up with `if' not `else'.
+ (setq haskell-nest-ifs nil)
+
+ (make-local-variable 'haskell-align-else-with-then)
+ ;;Non-nil means align an `else' under it's corresponding `then'
+ (setq haskell-align-else-with-then nil)
+
+
+ ;;The local vars for 'where' indentation
+
+ (make-local-variable 'haskell-align-where-with-eq)
+ ;;Non-nil means align a 'where' under it's corresponding equals sign
+ (setq haskell-align-where-with-eq t)
+
+ (make-local-variable 'haskell-align-where-after-eq)
+ ;;Non-nil means align a 'where' after it's corresponding equals sign
+ (setq haskell-align-where-after-eq nil)
+
+ (make-local-variable 'haskell-std-indent-where)
+ ;;put the 'where' the standard offset ie. 'haskell-indent-offset'
+ (setq haskell-std-indent-where nil)
+
+
+ (make-local-variable 'haskell-always-fixup-comment-space)
+ ;;Non-nil means always insert a (single) space after a comment, even
+ ;; if there is more or less than one.
+ (setq haskell-always-fixup-comment-space t)
+
+
+ (make-local-variable 'haskell-indent-offset)
+ ;;Extra indentation for a line continued after a keyword.
+ (setq haskell-indent-offset 4)
+
+ (make-local-variable 'haskell-list-offset)
+ ;;Extra indentation for continuing a list.
+ (setq haskell-list-offset 4)
+
+ (make-local-variable 'haskell-comp-offset)
+ ;;Extra indentation for a list comprehension.
+ (setq haskell-comp-offset 4)
+
+ (make-local-variable 'haskell-case-offset)
+ (setq haskell-case-offset 4)
+
+ (make-local-variable 'haskell-where-offset)
+ (setq haskell-where-offset 4)
+
+ (make-local-variable 'haskell-let-offset)
+ (setq haskell-let-offset 4)
+
+ (make-local-variable 'haskell-then-offset)
+ (setq haskell-then-offset 0)
+
+ (make-local-variable 'haskell-if-offset)
+ (setq haskell-if-offset 4)
+
+ (make-local-variable 'haskell-comment-column)
+ (setq haskell-comment-column 35)
+
+ (make-local-variable 'haskell-concat-column)
+ (setq haskell-concat-column 69)
+
+ (make-local-variable 'haskell-where-threshold)
+ (setq haskell-where-threshold 35)
+
+ (make-local-variable 'line-comment)
+ (setq line-comment "-- ")
+
+ (make-local-variable 'haskell-indent-style)
+ (setq haskell-indent-style "none"))
+
+
+(defun haskell-set-syntax-table ()
+ "Set the syntax table for Haskell-mode."
+ (setq haskell-mode-syntax-table (make-syntax-table))
+ (set-syntax-table haskell-mode-syntax-table)
+ (modify-syntax-entry ?\" "\"")
+ (modify-syntax-entry ?\\ "\\")
+ (modify-syntax-entry ?\' "w")
+ (modify-syntax-entry ?_ "w")
+ (modify-syntax-entry ?# "_")
+ (modify-syntax-entry ?$ "_")
+ (modify-syntax-entry ?% "_")
+ (modify-syntax-entry ?: "_")
+ (modify-syntax-entry ?? "_")
+ (modify-syntax-entry ?@ "_")
+ (modify-syntax-entry ?! "_")
+ (modify-syntax-entry ?^ "_")
+ (modify-syntax-entry ?~ "_")
+ (modify-syntax-entry ?- "_ 12")
+ (modify-syntax-entry ?\n ">")
+ (modify-syntax-entry ?{ "(}")
+ (modify-syntax-entry ?} "){")
+ (set-syntax-table haskell-mode-syntax-table))
+
+
+
+(defun haskell-mode ()
+ "Major mode for editing Haskell code.
+Linefeed reindents current line, takes newline and indents.
+Tab indents current line for Haskell code.
+Functions are seperated by blank lines.
+Delete converts tabs to spaces as it moves back.
+\\{haskell-mode-map}
+Variables controlling indentation style:
+ haskell-indent-offset
+ Standard extra indentation for continuing Haskell
+ code under the scope of an expression. The default is 4.
+
+ haskell-list-offset
+ Extra indentation for indenting in a list. Used if variable
+ haskell-std-list-indent is non-nil. The default is 4.
+
+ haskell-comp-offset
+ Extra indentation for continuing a list comprehension.
+ The default is 4.
+
+ haskell-case-offset
+ Standard extra indentation for continuing Haskell
+ code under the scope of an expression. The default is 4.
+
+ haskell-where-offset
+ Standard extra indentation for continuing Haskell
+ code under the scope of a `where'. The default is 4.
+
+ haskell-let-offset
+ Standard extra indentation for continuing Haskell
+ code under the scope of a `let'. The default is 4.
+
+ haskell-then-offset
+ Standard extra indentation for a `then' beyond
+ its corresponding `if'. The default is 0.
+
+ haskell-if-offset
+ Standard extra indentation for continuing Haskell
+ code under the scope of an `if'. The default is 4.
+
+ haskell-comment-column
+ Column to which line comments `--' will be inserted.
+ The default is 35.
+
+ haskell-concat-column
+ Column to which concatenation operator `++' will be inserted.
+ The default is 69.
+
+ haskell-where-threshold
+ Column beyond which a `where' will be indented to the
+ start of a line (to avoid spilling over lines).
+ The default is 35.
+
+ set-haskell-indent-offset (C-c i)
+ Changes the default value of the local variable,
+ haskell-indent-offset. May be a number from 0-10.
+
+ set-haskell-list-indent (C-c l)
+ Change the value of the local variable,
+ haskell-list-offset. May be a number from 0-100.
+
+ set-haskell-comment-column (C-x ;)
+ Changes the value of the local variable,
+ haskell-comment-column. May be any number from 0-100."
+
+ (interactive)
+ (haskell-set-local-vars)
+ (haskell-set-syntax-table)
+ (use-local-map haskell-mode-map)
+ (setq major-mode 'haskell-mode)
+ (setq mode-name "Haskell")
+ (define-abbrev-table 'haskell-mode-abbrev-table ()))
+
+
+
+
+;;; Returns the indentation column for a comment on this line.
+;;; The point is positioned at the last char of any code on the line.
+
+(defun haskell-comment-indent ()
+ "Returns the indentation for a comment on the given line.
+If the line has code on it or the point is not at the beginning of the line,
+then indent to indent-column.
+Otherwise, don't indent."
+ (cond ((or (haskell-code-on-linep)
+ (not (bolp)))
+ ;;There is code before the haskell-comment-column
+ ;; or not at the beginning of the line
+ ;;Return the largest of
+ ;; the current column +1 and the haskell-comment-column
+ (max (1+ (current-column))
+ haskell-comment-column))
+ (t
+ ;;Otherwise, return 0
+ 0)))
+
+
+
+;;; Returns whether a comment is on the current line
+;;; Search from bol, and beware of "--", {-- etc!
+;;; DOES NOT RECOGNISE {- COMMENTS YET or -- within a string
+
+(defun haskell-comment-on-linep ()
+ "Returns the truth value of whether there is a '--' comment on the current line."
+ (save-excursion
+ (beginning-of-line)
+ (looking-at ".*--")))
+
+
+;;; This doesn't account for comments '{-'. Test explicitly if you use this function!
+
+(defun haskell-code-on-linep ()
+ "Returns a truth value as to whether there is code on the current line."
+ (save-excursion
+ (beginning-of-line)
+ (not
+ ;; Code on line if not looking at a comment directly
+ ;; and the line is not blank
+ (or
+ (looking-at "^[ \t]*--")
+ (looking-at "^[ \t]*$")))))
+
+
+;;; Insert a Haskell "--" comment on the current line.
+;;; Move to the comment position if there's already a comment here.
+;;; Otherwise, the comment is inserted either at the comment column
+;;; or one column after the last non-space character, whichever is further
+;;; to the right.
+;;; This function is executed by M-;
+
+(defun haskell-insert-comment ()
+ "Inserts a '--' comment on the given line."
+ (interactive)
+ (cond ((haskell-comment-on-linep)
+ ;;There is a comment on the line
+ ;;Just reindent existing comment
+ (haskell-reindent-comment))
+ (t
+ (if (haskell-code-on-linep)
+ ;;There is code on the line
+ ;; and guarenteed that a comment
+ ;; does not already exist.
+ ;;Move to the last nonspace char
+ ;; (there may be spaces after the last char)
+ (progn
+ (end-of-line)
+ (skip-chars-backward " \t")))
+ ;;Indent to required level
+ ;; and insert the line comment '--'
+ (indent-to (haskell-comment-indent))
+ (insert line-comment))))
+
+
+;;; Reindents a comment.
+;;; The comment is indented according to the normal rules.
+;;; Skips over ---- and following spaces or tabs
+
+(defun haskell-reindent-comment ()
+ "Indents a comment on a line to keep it at haskell-comment-column,
+if possible.
+It is guaranteed that a comment exists on the current line."
+ (beginning-of-line)
+ ;;Go back to beginning of comment
+ (re-search-forward "--")
+ (forward-char -2)
+ ;;Delete all spaces and reindent to
+ ;; the correct location.
+ (delete-horizontal-space)
+ (indent-to (haskell-comment-indent))
+ ;;Move past the comment and insert
+ ;; only one space between it and the text.
+ ;;Leave point just after comment.
+ (skip-chars-forward "- \t")
+ (if haskell-always-fixup-comment-space
+ (progn
+ (fixup-whitespace)
+ (forward-char 1))))
+
+
+
+;;; Inserts a haskell concatenation operator, `++', at the
+;;; column dictated by haskell-concat-column
+
+(defun haskell-insert-concat()
+ "Inserts a `++' operator on the given line."
+ (interactive)
+ (end-of-line)
+ (skip-chars-backward " \t")
+ ;;Indent to required level
+ ;; and insert the concat operator `++'
+ (indent-to (haskell-concat-indent))
+ (insert "++"))
+
+
+
+;;; Returns the indentation column for a concatenation operator on this line.
+;;; The point is positioned at the last char of any code on the line.
+
+(defun haskell-concat-indent ()
+ "Returns the indentation for a concat operator on the given line."
+ (max (1+ (current-column))
+ haskell-concat-column))
+
+
+
+;;; Returns the indentation of the current line of haskell code.
+;;; A blank line has ZERO indentation
+
+(defun haskell-current-indentation ()
+ "Returns the indentation for the current haskell line. A blank line has
+indentation zero."
+ (save-excursion
+ (beginning-of-line)
+ (if (looking-at "^[ \t]*$")
+ ;;The line is empty
+ ;; so the indentation is zero
+ 0
+ ;;Otherwise find the normal value of indentation
+ (current-indentation))))
+
+
+
+;;; Returns the indentation of the previous line of haskell code.
+;;; A blank line has ZERO indentation
+
+(defun haskell-previous-indentation ()
+ "Returns the previous line's indentation as Haskell indentation."
+ (save-excursion
+ (if (not (bobp))
+ ;;Not at the start of the buffer
+ ;; so get the previous lines indentation
+ (progn
+ (forward-line -1)
+ (haskell-current-indentation))
+ ;;We are at the start of buffer
+ ;;There is no previous line; Indent is zero
+ 0)))
+
+
+
+;;; Move back to the last line which is aligned in the left column.
+;;; Ignores comments and blank lines.
+;;; The point is left at the beginning of the line.
+
+(defun haskell-back-to-zero-indent ()
+ "Moves point to last line which has zero as indentation."
+ ;;Not at the beginning of buffer.
+ ;;Continue to go to the previous line until
+ ;; we find a line whose indentation is non-zero.
+ ;;Blank lines and lines containing only comments
+ ;; are ignored.
+ (beginning-of-line)
+ (while (and
+ (or (not (zerop (haskell-current-indentation)))
+ (looking-at "^[ \t]*\\($\\|--\\)"))
+ (not (bobp)))
+ (haskell-backward-to-noncomment)
+ (beginning-of-line)))
+
+
+
+;;; Find the last symbol, usually an equality.
+
+;;; Note: we check for "=" as a complete WORD (and ignore
+;;; comments) when searching for this. Ie. an `=' may be
+;;; surrounded only by a letter, digit, or whitespace .
+;;; Strings are not considered.
+;;; Don't go beyond the first character in the (possibly narrowed) buffer.
+;;; From the beginning of the line,
+;;; find the comment position (or end-of-line)
+;;; search forward to this position, looking for a "where"
+;;; If one's found, then search forward for "\b=\b"
+;;; If there's no equality sign then
+;;; search forward from the start of the line for an equals
+;;; Otherwise we found it.
+;;; If there's no where then search forward for an equals, as above.
+
+(defun haskell-back-to-symbol (exp)
+ "Goes backward from point until a symbol, EXP, is found.
+The point is left at the first symbol matching the context
+of the haskell code."
+ (let* ((found nil)
+ (symbol (concat "[ \ta-z0-9A-Z]" exp "[ \t\na-z0-9A-Z]"))
+ eol-limit
+ bol-limit
+ (zero-indent (save-excursion
+ (haskell-back-to-zero-indent)
+ (point)))
+ (initial-depth (car (parse-partial-sexp
+ (point)
+ zero-indent))))
+
+ (while (and (not found)
+ (> (point) zero-indent))
+ ;;Not found and point > point min
+ ;;Record the limit of search for the beginning and
+ ;; end of the line.
+ (setq eol-limit (point))
+ (beginning-of-line)
+ (setq bol-limit (point))
+ (goto-char eol-limit)
+ (re-search-backward "\\bwhere\\b" bol-limit 't)
+ ;;Search back from the end of the line
+ ;; to find the most recent 'where'.
+
+ (cond ((and (re-search-backward symbol bol-limit 't)
+ (= initial-depth
+ (car (parse-partial-sexp
+ (point)
+ zero-indent))))
+ ;;Found a symbol sign surrounded by
+ ;; a letter, digit or space only, or at the
+ ;; beginning of the buffer and they are at
+ ;; the same depth level
+ (setq found 't))
+ ((and (re-search-backward symbol bol-limit 't)
+ (zerop
+ (car (parse-partial-sexp
+ (point)
+ zero-indent))))
+ ;; Found a symbol and it is not in any parens
+ (setq found 't))
+ ;;Otherwise, go back a line.
+ (t (haskell-backward-to-noncomment))))
+ (if found
+ (forward-char 1))))
+
+
+;;; Goes back to the last keyword. The point is left at the
+;;; beginning of the keyword.
+;;; The words recognised are:
+;;; `case',`of',`where',`let',`in',`if',`then',`else'
+
+(defun haskell-back-to-keyword ()
+ "Goes backward from point until a keyword is found.
+The point is left after the first keyword."
+ (let* ((found nil)
+ eol-limit
+ bol-limit
+ (zero-indent (save-excursion
+ (haskell-back-to-zero-indent)
+ (point)))
+ (initial-depth (car (parse-partial-sexp
+ (point)
+ zero-indent))))
+
+ (while (and (not found)
+ (>= (point) zero-indent))
+ ;;Not found and point > point min
+ ;;Go back past any comment.
+ ;;Record the limit of search for the beginning and
+ ;; end of the line.
+ (setq eol-limit (point))
+ (beginning-of-line)
+ (setq bol-limit (point))
+ (goto-char eol-limit)
+ (if (and (re-search-backward
+ "\\b\\(case\\|of\\|where\\|let\\|in\\|if\\|then\\|else\\)\\b"
+ bol-limit 't)
+ (= initial-depth
+ (car (parse-partial-sexp
+ (point)
+ zero-indent))))
+ ;;Found a keyword and it is at the same level as the initial position
+ (progn
+ (setq found 't)
+ (forward-word 1))
+ ;;Otherwise, go back a line.
+ (haskell-backward-to-noncomment)))))
+
+
+
+;;; Returns the end of line (point) of the current line, excluding any
+;;; line comments on it.
+
+(defun haskell-eol ()
+ "Returns the end (point) of the current line, excluding any line comments."
+ (save-excursion
+ (end-of-line)
+ (let ((eol-limit (point)))
+ (beginning-of-line)
+ (if (search-forward "--" eol-limit 'move-to-eol)
+ ;;Found a '--'
+ ;;So move to the beginning of the comment
+ ;;If fail then move to end of line
+ (forward-char -2)))
+ (point)))
+
+
+
+;;; Returns whether or not the current line contains an equality outwith a
+;;; comment. The equality may only be surrounded by a letter, digit or
+;;; whitespace.
+
+(defun haskell-looking-at-eqp ()
+ "Returns whether or not the current line contains an equality outwith a
+comment."
+ (save-excursion
+ (beginning-of-line)
+ (re-search-forward "[ \ta-z0-9A-Z]=[ \t\na-z0-9A-Z]" (1+ (haskell-eol)) 't)))
+
+
+;;; This function does not require all keywords, just those which
+;;; may have a bracket before them.
+(defun haskell-looking-at-keywordp ()
+ "Returns whether or not there is a keyword after the point outwith a
+comment."
+ (save-excursion
+ (re-search-forward
+ "\\(\\(=>\\|=\\|++\\|->\\|<-\\|::\\)\\|\\b\\(case\\|of\\|if\\|then\\|else\\|let\\|in\\)\\b\\)"
+ (haskell-eol) 't)))
+
+
+;;; This function returns whether or not there is a keyword contained in
+;;; the region START END. START < END.
+
+(defun haskell-keyword-in-regionp (start end)
+ "Returns whether or not there is a keyword between START and END."
+ (save-excursion
+ (goto-char start)
+ (let ((found nil)
+ (eol-limit (haskell-eol)))
+ (while (and (not found) (< (point) end))
+ (if (> eol-limit end)
+ (setq eol-limit end))
+ (if (re-search-forward
+ "\\b\\(case\\|of\\|if\\|then\\|else\\|let\\|in\\)\\b"
+ eol-limit 'move)
+ (setq found t)
+ ;;Otherwise, have not found a keyword. Now at haskell-eol.
+ (if (< (point) end)
+ ;;We still have an area to search
+ ;; so go forward one line
+ (progn
+ (beginning-of-line)
+ (forward-line 1)
+ (setq eol-limit (haskell-eol))))))
+ ;;found is `t' or point >= end
+ found)))
+
+
+;;; Goes back to the last line which is not entirely commented out.
+;;; The point is left just before the comment.
+
+(defun haskell-backward-to-noncomment ()
+ "Sets the point to the last char on the line of Haskell code before a comment."
+ (let ((comment 't)
+ (limit (point-min)))
+ (while (and comment (> (point) limit))
+ ;; comment is true and point > limit
+ (beginning-of-line)
+ (if (< (forward-line -1) 0)
+ ;;This was the first line in the buffer
+ (setq comment nil)
+ ;;Otherwise, this was not the first line
+ (if (not (looking-at "^[ \t]*\\($\\|--\\)"))
+ ;;There is not a comment at the beginning of the line
+ ;; and the line is not blank
+ (progn
+ ;;The line is either blank or has code on it.
+ (setq comment nil)
+ (goto-char (haskell-eol))))))
+
+ ;;return point
+ (point)))
+
+
+
+;;; Indents a region (by applying "tab" to each line).
+;;; The marker upper-marker is set to the end of the region.
+;;; We indent from the beginning of the region to this marker.
+;;; Implements C-c r.
+
+(defun haskell-indent-region ()
+ "Indents the region between the point and mark."
+ (interactive)
+ (let ((lower-limit (min (point) (mark)))
+ (upper-limit (max (point) (mark))))
+ (indent-region lower-limit upper-limit 'nil)))
+
+
+
+;;; Implements TAB.
+;;; This actually indents a line.
+;;; Eventually it will handle a line split at any point,
+
+(defun haskell-indent-line ()
+ "Indent current line as Haskell code.
+Keeps the point at the same position on the line unless the
+point is less then the current indentation, in which case the
+point is moved to the first char."
+ (interactive)
+ (save-excursion
+ (let ((indent (haskell-calculate-indentation)))
+ (beginning-of-line)
+ (delete-horizontal-space)
+ ;;Kill any spaces that may preceed the code
+ ;; and reindent to the correct level.
+ (indent-to indent)))
+ (if (< (current-column) (current-indentation))
+ ;;The point is in the indentation
+ ;; so move to the first char on the line
+ (move-to-column (current-indentation))))
+
+
+
+;;; This is the haskell version of the Emacs function
+;;; reindent-then-newline-and-indent. It was necessary
+;;; to write this because the Emacs version has the
+;;; terrible property of deleting whitespace BEFORE
+;;; reindenting the original line.
+
+(defun haskell-reindent-then-newline-and-indent ()
+ "Reidents the current line of Haskell code then takes a
+newline and indents this new line."
+ (interactive)
+ (skip-chars-backward " \t")
+ (haskell-indent-line)
+ (newline)
+ (delete-horizontal-space)
+ (haskell-indent-line))
+
+
+
+;;; Returns whether the first word of the last line with zero indentation
+;;; is the same as the first word of the current line.
+;;; This function is based on the (reasonable?) assumption that
+;;; a function definition occurs on the left hand margin.
+;;; This is not quit reasonable since recusive functions are not
+;;; recognised.
+
+(defun haskell-continued-fn-defp ()
+ "Returns whether the first word on the last line with zero indentation
+matches the first word on the current line."
+ (save-excursion
+ (beginning-of-line)
+ (skip-chars-forward " \t")
+ ;;Goto the first non space char
+ (haskell-word-eq (point)
+ (save-excursion
+ (forward-line -1)
+ (haskell-back-to-zero-indent)
+ (point)))))
+
+
+;;; Returns whether two words are the same.
+;;; The beginning of both words are given as their
+;;; respective points in the buffer.
+
+(defun haskell-word-eq (current-pos previous-pos)
+ (let ((OK 't))
+ (goto-char previous-pos)
+ ;;We shall compare the two words starting
+ ;; at previous-pos and current-pos.
+ (while (and OK (looking-at "\\S-"))
+ ;;OK and looking at a word constituent
+ (if (eq (char-after current-pos)
+ (char-after previous-pos))
+ ;;The two chars are the same
+ (progn
+ ;;Increment the two postions
+ ;; and update location of point
+ (setq current-pos (1+ current-pos))
+ (setq previous-pos (1+ previous-pos))
+ (goto-char previous-pos))
+ ;;The two chars are different
+ ;; so set OK to be false
+ (setq OK 'nil)))
+
+ ;;Return the value of OK
+ OK))
+
+
+
+
+;;; This function returns the column of the last unbalanced
+;;; expression.
+;;; It is called when an keyword is found. The point is
+;;; initially placed before the corresponding keyword.
+;;; The function looks at every word to see if it is a
+;;; `let' or `in'. Each word must be outwith a comment.
+
+(defun haskell-last-unbalanced-key-column (open close)
+ "Returns the column of the last unbalanced keyword, open."
+ (save-excursion
+ (let ((original-pos (point))
+ (bol-limit (save-excursion
+ (beginning-of-line)
+ (setq bol-limit (point))))
+ (depth 1))
+ (setq open (concat "\\b" open "\\b"))
+ (setq close (concat "\\b" close "\\b"))
+ (while (and
+ (> depth 0)
+ (> (point) (point-min)))
+ (forward-word -1)
+ (if (< (point) bol-limit)
+ ;;Moved past the beginning of line limit
+ ;; so go back to the previous line past
+ ;; any comments.
+ (progn
+ (goto-char original-pos)
+ (haskell-backward-to-noncomment)
+ (setq original-pos (point))
+ (setq bol-limit (save-excursion
+ (beginning-of-line)
+ (point))))
+ ;;Otherwise, still on the same line
+ (if (looking-at open)
+ ;;This word is an open keyword
+ (setq depth (1- depth))
+ ;;Otherwise,
+ (if (looking-at close)
+ ;;This word is a close keyword
+ (setq depth (1+ depth))))))
+
+ (if (string= open "\\bif\\b")
+ ;;The argument is `if'
+ (if (not (save-excursion (skip-chars-backward " \t") (bolp)))
+ ;;There is something before the `if'
+ (if (and (save-excursion
+ (forward-word -1)
+ (looking-at "\\belse\\b"))
+ (not haskell-nest-ifs))
+ ;;There is an `else' before the 'if'
+ (forward-word -1))))
+
+
+ (current-column))))
+
+
+
+;;; Return the indentation for a line given that we expect a `where'.
+;;; The point lies on the corresponding symbol
+;;; that the `where' scopes over.
+
+(defun haskell-indent-where ()
+ "Return the indentation for a line, given that we expect a `where'
+clause."
+ (let ((symbol (if (looking-at "=")
+ "="
+ "->")))
+
+ (cond ((or haskell-std-indent-where
+ (> (current-column) haskell-where-threshold))
+ ;;Set indentation as the sum of the previous
+ ;; line's layout column and the standard offset
+ ;; (ie. 'haskell-where-offset)
+ (save-excursion
+ (beginning-of-line)
+ (cond ((looking-at (concat "^[ \t]*" symbol))
+ ;;The line starts with the symbol
+ (setq indent (current-indentation)))
+ ((looking-at "^[ \t]*where\\b")
+ ;;The line starts with a 'where'
+ (forward-word 1)
+ (skip-chars-forward " \t")
+ (setq indent (+ (current-column) haskell-where-offset)))
+ (t
+ ;;The line begins on the layout column
+ (setq indent (+ (current-indentation)
+ haskell-indent-offset))))))
+ ((or haskell-align-where-with-eq
+ haskell-align-where-after-eq)
+ (if (looking-at (concat symbol "[ \t]*$"))
+ ;;The symbol is at the end of the line
+ (setq indent (+ (current-indentation)
+ haskell-where-offset))
+ (save-excursion
+ ;;Set the indentation as required
+ (if haskell-align-where-after-eq
+ (skip-chars-forward (concat symbol " \t")))
+ (setq indent (current-column))))))))
+
+
+
+;;; Calculates the indentation for the current line.
+;;; When we come here, we are in a line which we want to indent.
+;;; We should leave the point at the same relative position it
+;;; was in before we called the function, that is, if a line
+;;; is already correctly indented, nothing happens!
+
+;;; The main problems are handling "where" definitions
+;;; and the syntax of expressions when these are continued
+;;; over multiple lines (e.g. tuples, lists, or just plain
+;;; bracketed expressions). Watch out for let ... in, too!
+
+;;; For example, think about the following tricky cases:
+
+;;; f x = x + <NL>
+
+;;; f x = [ x + y, <NL>
+
+;;; f x = [ <NL>
+
+;;; f x = [ -- start of a large list
+;;; -- which I'm commenting in as I go
+;;; <TAB>
+
+(defun haskell-calculate-indentation ()
+ "Returns the indentation level for the current line of haskell code."
+ (save-excursion
+ (let ((indent 0)
+ (eol-position (point)))
+ (beginning-of-line)
+ (cond ((bobp)
+ ;;We are at the beginning of the buffer so do nothing at all
+ (setq indent 0))
+
+ ((looking-at "^[ \t]*--")
+ ;;There is a comment on the line by itself
+ ;;Leave it the way it is
+ (setq indent (current-indentation)))
+
+ ((looking-at "^[ \t]*\\(data\\|type\\|module\\|import\\|instance\\)\\b")
+ ;;There is a 'data', 'type', 'module' or 'import' at start of line
+ (setq indent 0))
+
+ ((haskell-continued-fn-defp)
+ ;;This is clearly same function
+ ;; so set indent to be 0
+ (setq indent 0))
+
+ ((looking-at "^[ \t]*[]}]")
+ ;;There is a "]" or "}" at the start of the line
+ (let ((state (parse-partial-sexp (match-end 0)
+ (save-excursion
+ (haskell-back-to-zero-indent)
+ (point)))))
+ (if (>= (car state) 0)
+ ;;Since the point is just after a parenthesis
+ ;; it has a match if the depth is >= 0
+ (save-excursion
+ (goto-char (nth 2 state))
+ ;;Move to the match.
+ (if (not
+ (save-excursion
+ (skip-chars-backward " \t")
+ (bolp)))
+ ;;There is something before the brace.
+ (progn
+ (let ((initial-pos (point)))
+ (forward-word -1)
+ (if (not (looking-at
+ "\\(let\\|where\\)"))
+ ;;The word is not `where' or `let'
+ ;; so go back.
+ (progn
+ (goto-char initial-pos)
+ (skip-chars-forward " \t"))))))
+ (setq indent (current-column)))
+ (setq indent 0))))
+
+ ((looking-at "^[ \t]*\\(->\\|=>\\)")
+ ;; '->' or '=>' at start of line
+ (save-excursion
+ (haskell-backward-to-noncomment)
+ ;;Go back to previous line
+ (let ((eol-limit (point)))
+ (beginning-of-line)
+ (if (re-search-forward "::" eol-limit 't)
+ ;;There is a '::' on this (previous) line
+ ;; set indent to be at the start of it
+ (setq indent (- (current-column) 2))
+ ;;Otherwise copy this (previous) line's indentation
+ (setq indent (current-indentation))))))
+
+ ((looking-at "^[ \t]*where\\b")
+ ;;There is a 'where' at the start of the line
+ ;;Look for the equality (which will not
+ ;; be on this line).
+ (haskell-backward-to-noncomment)
+ (goto-char (max (save-excursion
+ (haskell-back-to-symbol "=")
+ (point))
+ (save-excursion
+ (haskell-back-to-symbol "->")
+ (point))))
+ (setq indent (haskell-indent-where)))
+
+ ((looking-at "^[ \t]*then\\b")
+ ;;The first thing on the line is a `then'
+ (setq indent (+ (haskell-last-unbalanced-key-column "if" "then")
+ haskell-then-offset)))
+
+ ((looking-at "^[ \t]*else\\b")
+ ;;The first thing on the line is a `else'
+ (if haskell-align-else-with-then
+ (setq indent (haskell-last-unbalanced-key-column "then" "else"))
+ (setq indent (haskell-last-unbalanced-key-column "if" "else"))))
+
+ ((looking-at "^[ \t]*|")
+ ;;There is a `|' at beginning of line
+ (save-excursion
+ (let ((state
+ (parse-partial-sexp (save-excursion
+ (haskell-back-to-zero-indent)
+ (point))
+ (point))))
+ (if (not (or (nth 3 state) (nth 4 state)))
+ ;;Not in a comment or string
+ (if (> (car state) 0)
+ ;;In an unbalanced parenthesis.
+ (progn
+ (goto-char (nth 1 state))
+ ;;Move to the beginning of the unbalanced parentheses
+ (if (and (looking-at "\\[")
+ (search-forward "|" (haskell-eol) 't))
+ ;;It is a list comprehension
+ (setq indent (1- (current-column)))
+ (setq indent (+ (current-column)
+ haskell-comp-offset))))
+ ;;Otherwise, not in an unbalanced parenthesis
+ (setq indent (save-excursion
+ (haskell-back-to-symbol "=")
+ (cond ((not (looking-at "="))
+ ;;Did not find an equals
+ (+ (haskell-previous-indentation)
+ haskell-indent-offset))
+ ((save-excursion
+ (beginning-of-line)
+ (looking-at "^[ \t]*data\\b"))
+ ;;There is a `data' at beginning
+ (setq indent (current-column)))
+ ((save-excursion
+ (beginning-of-line)
+ (search-forward
+ "|" (haskell-eol) 't))
+ ;;There is a `|' on this line
+ ;; so set this to be the indent
+ (save-excursion
+ (goto-char (match-beginning 0))
+ (current-column)))
+ (t
+ ;;Otherwise, set `=' as indent
+ (current-column))))))))))
+
+ ((looking-at "^[ \t]*=")
+ ;;There is an equals at the start of the line
+ ;;Set the indentation to be the previous line's
+ ;; indentation plus the standard offset
+ (setq indent (+ haskell-indent-offset
+ (haskell-previous-indentation))))
+
+ ((looking-at "^[ \t]*in\\b")
+ ;;The line starts with 'in'
+ (beginning-of-line)
+ (setq indent (haskell-last-unbalanced-key-column "let" "in")))
+
+ ((looking-at "^[ \t]*of\\b")
+ ;;The line starts with `of'
+ (beginning-of-line)
+ (setq indent (haskell-last-unbalanced-key-column "case" "of")))
+
+ ((looking-at "^.*::")
+ ;;There is a '::' in the line
+ ;;There are several possibilities for indentation
+ (if (looking-at "[ \t]*::")
+ ;;The '::' is the first thing on the line
+ ;; so set indent to be the previous line's
+ ;; indentation plus the standard offset
+ (setq indent (+ (haskell-previous-indentation)
+ haskell-indent-offset))
+ (save-excursion
+ ;;Otherwise, the '::' is contained in the line somewhere
+ ;; so use contextual indentation
+ (setq indent (haskell-context-indent)))))
+
+ (t
+ ;;Do not recognise the first word on the line.
+ (setq indent (haskell-context-indent))))
+
+ indent))) ;return indent as indentation value
+
+
+
+;;; Returns the indentation for the current line by looking at the
+;;; previous line to give clues to the indentation.
+
+(defun haskell-context-indent ()
+ "Returns the indentation for the current line by looking at
+the previous line to dictate the indentation."
+ (save-excursion
+ (let ((original-position (point))
+ indent)
+ (beginning-of-line)
+ (if (bobp)
+ ;;At the beginning of the buffer
+ (setq indent 0)
+ ;;Otherwise, we are not at the beginning of the buffer
+ (haskell-backward-to-noncomment)
+ (let ((eol-limit (point))
+ ;;Record the (upper) limit for any search on this line
+ bol-limit
+ (paren-indent 'nil))
+ ;;`paren-indent' flags whether we are indenting a list or not
+ (beginning-of-line)
+ (setq bol-limit (point))
+ ;;Record the (lower) limit for any search on this line
+ (goto-char eol-limit) ;goto the end of the line
+ (flag)
+ (if (save-excursion
+ (goto-char eol-limit)
+ (and (re-search-backward
+ "[])][^][()]*" bol-limit 't)
+ (save-excursion
+ (goto-char (match-beginning 0))
+ (not (haskell-looking-at-keywordp)))))
+
+ ;;There is a close parenthesis at the end of the line
+ ;; followed by anything except "(", ")", "[", "]"
+ ;; or a keyword
+ (progn
+ ;;Search back for the close parenthesis
+ ;; and move to just after it.
+ (re-search-backward "[])]" bol-limit 't)
+ (forward-char 1)
+ (let ((state
+ (parse-partial-sexp (save-excursion
+ (haskell-back-to-zero-indent)
+ (point))
+ (point))))
+ (if (not (or (nth 3 state) (nth 4 state)))
+ ;;Not in a comment or string
+ (if (>= (car state) 0)
+ ;;The parenthesis has a match
+ (progn
+ (goto-char (nth 2 state))
+ ;;Move to the beginning of the parentheses
+ ;; as this new line will determine
+ ;; further indentation
+ (if (zerop (car state))
+ ;;This paren closes all unbalanced parens
+ ;; so move to
+ ;; the eol of last line with an equality.
+ (progn
+ (setq eol-limit (point))
+ (goto-char
+ (max (save-excursion
+ (haskell-back-to-symbol "=")
+ (point))
+ (save-excursion
+ (haskell-back-to-keyword)
+ (point))))
+ (goto-char eol-limit))
+ ;;esle just go to the end of the line
+ (goto-char (haskell-eol)))
+ (setq paren-indent 't)
+ ;;Set 'paren-indent' to true to indicate we
+ ;; are indenting a list.
+ (setq eol-limit (point))
+ (beginning-of-line)
+ (setq bol-limit (point))
+ ;;Reduce the scope of any later
+ ;; indentation to
+ ;; exclude the balanced parentheses
+ ;; by making this point
+ ;; be the eol-limit.
+ (goto-char eol-limit)))))))
+ (flag)
+ ;;This cond expression is structured, to an
+ ;; extent, such that the keywords with highest
+ ;; indentation precedence come first. Order is important.
+ ;;In each condition, the point of match is noted so
+ ;; that we can see if this point is in a string.
+ (let ((indent-point (point)))
+ (cond ((re-search-backward "\\bof\\b" bol-limit 't)
+ ;; `of' is contained in previous line
+ (setq indent-point (point))
+ (if (looking-at "of[ \t]*$")
+ ;;`of' at end of line
+ (setq indent (+ (haskell-last-unbalanced-key-column
+ "case" "of")
+ haskell-case-offset))
+ ;;Otherwise, `of' is in line
+ (forward-word 1)
+ (skip-chars-forward " \t")
+ (setq indent (current-column))
+ (setq indent (list indent))))
+
+ ((re-search-backward
+ "\\bthen[ \t]*$" bol-limit 't)
+ ;;There is a `then' at the end of the line.
+ (setq indent-point (point))
+ (if haskell-align-else-with-then
+ ;;We want to align the `else' (to follow) with the `then'
+ (setq indent (+ (current-column)
+ haskell-if-offset))
+ (setq indent (+ (haskell-last-unbalanced-key-column
+ "if" "then")
+ haskell-if-offset))))
+ ;; This was here but don't know why (setq indent (list indent))))
+
+ ((save-excursion
+ (and (re-search-backward "\\bif\\b" bol-limit 't)
+ (setq indent-point (point))
+ (not (re-search-forward "\\bthen\\b" eol-limit 't))))
+ ;;There is an `if' on the (previous) line and the line does
+ ;; not have a `then' on it.
+ (setq indent (+ (haskell-last-unbalanced-key-column
+ "if" "then")
+ haskell-then-offset)))
+
+ ((save-excursion
+ (and (re-search-backward "\\bif\\b" bol-limit 't)
+ (setq indent-point (point))
+ (not (re-search-forward "\\belse\\b" eol-limit 't))))
+ ;;There is an `if' on the (previous) line (the line may
+ ;; have a `then' on it) and does not have an else on it.
+ (if (re-search-backward "\\bthen\\b" bol-limit 't)
+ ;;There is a then on the line and it is followed by
+ ;; some code.
+ (progn
+ (forward-word 1)
+ (skip-chars-forward " \t")
+ (setq indent (current-column)))
+ (if haskell-align-else-with-then
+ ;;We want to align the `else' with the `then'
+ (setq indent (haskell-last-unbalanced-key-column
+ "then" "else"))
+ (setq indent (haskell-last-unbalanced-key-column
+ "if" "else")))))
+
+ ((re-search-backward "\\b\\(let\\|in\\)\\b" bol-limit 't)
+ ;; 'let' or 'in' is contained in the (previous) line
+ (setq indent-point (point))
+ (forward-word 1) ;skip past the word
+ (skip-chars-forward " \t{")
+ (if (looking-at "\\($\\|--\\)")
+ ;;looking-at eol or comment
+ (progn
+ (forward-word -1)
+ (setq indent (+ (current-column)
+ haskell-let-offset)))
+ (setq indent (current-column))))
+
+ ((re-search-backward
+ "\\belse[ \t]*$" bol-limit 't)
+ ;;There is a `else' at end of line
+ (setq indent-point (point))
+ (save-excursion
+ (goto-char eol-limit)
+ (forward-word -1)
+ (setq indent (+ (current-column)
+ haskell-if-offset))))
+
+ ((re-search-backward
+ "\\belse\\b" bol-limit 't)
+ ;;There is a `else' on the line with no if or then
+ (setq indent-point (point))
+ (save-excursion
+ (forward-word 1)
+ (skip-chars-forward " \t")
+ (setq indent (current-column))))
+
+ ((save-excursion
+ (beginning-of-line)
+ (looking-at
+ "^[ \t]*then\\b"))
+ ;;There is a 'then' at beginning of line
+ (setq indent-point (point))
+ (setq indent (current-indentation)))
+
+ ((save-excursion
+ (beginning-of-line)
+ (looking-at "^[ \t]*else[ \t]*if\\b"))
+ (setq indent-point (point))
+ ;;There is an 'else if' at start of (previous) line
+ (save-excursion
+ (beginning-of-line)
+ (if haskell-nest-ifs
+ (save-excursion
+ (forward-word 1)
+ (skip-chars-forward " \t")
+ (setq indent (current-column)))
+ (skip-chars-forward " \t")
+ (setq indent (current-column)))))
+
+ ((re-search-backward "\\bcase\\b" bol-limit 't)
+ ;;There is a 'case' on the previous line
+ ;; so copy this line's indentation and add on
+ ;; the offset unless there is not an of.
+ (setq indent-point (point))
+ (setq indent (+ (current-column)
+ haskell-case-offset)))
+
+ ((save-excursion
+ (beginning-of-line)
+ (looking-at "^\\(instance\\|class\\)\\b"))
+ ;;This (previous) line has an 'instance' or 'class' at start
+ ;; so just set indentation to be this line indentation
+ ;; plus the standard offset
+ (setq indent-point (point))
+ (setq indent (+ (current-indentation)
+ haskell-indent-offset)))
+
+ ((re-search-backward "where\\b" bol-limit 't)
+ ;;There is a 'where' on the (previous) line
+ (setq indent-point (point))
+ (if (looking-at "where[ \t]*$")
+ ;;There is nothing after the 'where'
+ ;; so set indent to be this column
+ ;; (ie. the column of the 'w')
+ ;; plus the standard offset
+ (if (save-excursion
+ (skip-chars-backward " \t")
+ (bolp))
+ ;;The 'where' is the only thing on the line.
+ (setq indent (+ (current-column)
+ haskell-where-offset))
+ ;;Otherwise, the 'where' is at the end
+ ;; of the line and there is code before it.
+ ;;Look before the 'where' for the symbol
+ ;; it scopes over.
+ (forward-word -1)
+ (goto-char (max (save-excursion
+ (haskell-back-to-symbol "=")
+ (point))
+ (save-excursion
+ (haskell-back-to-symbol "->")
+ (point))))
+ (setq indent (haskell-indent-where)))
+
+ ;;Otherwise, go past the 'where'
+ ;; and goto the last non space character.
+ ;;Set this column to be the indentation.
+ (forward-word 1)
+ (skip-chars-forward " \t")
+ (setq indent (current-column))))
+
+ ((re-search-backward
+ "[ \ta-z0-9A-Z]=[ \t]*$" bol-limit 't)
+ ;;There is an equals is at the end of line
+ ;; so make the indentation be this line's indentation
+ ;; plus the standard offset
+ (setq indent-point (point))
+ (setq indent (+ (current-indentation)
+ haskell-indent-offset)))
+
+ ((re-search-backward
+ "[ \ta-z0-9A-Z]\\+\\+[ \t]*$" bol-limit 't)
+ ;;There is a concat operator at the end of line
+ ;; so make the indentation be this line's indentation
+ (setq indent-point (point))
+ (setq indent (current-indentation)))
+
+ ((save-excursion
+ (beginning-of-line)
+ (looking-at
+ "^[ \t]*=[ \ta-z0-9A-Z]"))
+ ;;There is an equals is at the beginning of line
+ ;; so make the indentation be the previous line's
+ ;; indentation unless the previous line's
+ ;; indentation is zero.
+ (setq indent-point (point))
+ (save-excursion
+ (haskell-backward-to-noncomment)
+ (if (zerop (current-indentation))
+ (setq indent (+ (current-indentation)
+ haskell-indent-offset))
+ (setq indent (haskell-current-indentation)))))
+
+ ((re-search-backward "|" bol-limit 't)
+ ;;There is an `|' on this line.
+ (setq indent-point (point))
+ (if (save-excursion
+ (goto-char original-position)
+ (looking-at "^[ \t]*\\($\\|--\\||\\)"))
+ ;;The original line is empty or has a `|' at the
+ ;; start. So set indent to be first `|' on this line
+ (save-excursion
+ (goto-char bol-limit)
+ (re-search-forward "|" eol-limit 't)
+ (setq indent (1- (current-column))))
+ ;;Otherwise set indent to be this (previous) line's
+ (setq indent 0)))
+
+ ((re-search-backward "->" bol-limit 't)
+ ;;There is a `->' in the line.
+ ;;This may be from a `case' or a
+ ;; type declaration.
+ (setq indent-point (point))
+ (save-excursion
+ (if (re-search-backward "::" bol-limit 't)
+ ;;There is a '::' on this line
+ (if (looking-at ".*->[ \t]*$")
+ ;;The '->' is at the end of line.
+ ;;Move past the '::' and any spaces
+ ;; and set indent to be this column.
+ (progn
+ (skip-chars-forward ": \t")
+ (setq indent (current-column)))
+ ;;Otherwise, the '->' is not at end of line
+ ;; so copy the indentation
+ (setq indent (haskell-context-indent)))
+
+ ;;Otherwise, there is not a
+ ;; `::' on this line so copy this
+ ;; (previous) indentation.
+ (setq indent (haskell-context-indent)))))
+
+ ((re-search-backward "::" bol-limit 't)
+ ;;There is an '::' on this line.
+ ;;We know that the line does not end with '->'.
+ (setq indent-point (point))
+ (if (looking-at "::[ \t]*$")
+ ;;The '::' is at the end of the line
+ ;; so set indent to be this line's
+ ;; indentation plus the offset.
+ (setq indent (+ (current-indentation)
+ haskell-indent-offset))
+ ;;Otherwise the `::' is in the line
+ (setq indent (current-indentation))))
+
+ ((re-search-backward
+ "\\b\\(import\\|class\\)\\b"
+ bol-limit 't)
+ ;;There is an `import' or `class' on the line.
+ ;;Copy this indentation.
+ (setq indent-point (point))
+ (setq indent (current-indentation)))
+
+ ((or
+ (haskell-looking-at-eqp)
+ (save-excursion
+ (beginning-of-line)
+ (looking-at "^[ \t]*$")))
+ ;;There is an '=' on the line
+ ;; or it is blank
+ (setq indent-point (point))
+ (cond ((save-excursion
+ (beginning-of-line)
+ (looking-at "^[ \t]*data\\b"))
+ ;;`data' at start of line
+ ;; so expect a `|'
+ (haskell-back-to-symbol "=")
+ (setq indent (current-column)))
+ ((zerop (current-indentation))
+ ;;If the indentation is zero, we expect a `where'
+ (goto-char eol-limit)
+ (haskell-back-to-symbol "=")
+ (setq indent (haskell-indent-where)))
+ ((looking-at "^[ \t]*=[ \t\na-z0-9A-Z]")
+ ;;The equality is the first thing on the line
+ ;; so copy the last lines indentation
+ (save-excursion
+ (haskell-backward-to-noncomment)
+ (setq indent (current-indentation))))
+ (t
+ ;;Otherwise, copy the indentation
+ (setq indent (current-indentation)))))
+
+ ((save-excursion
+ (beginning-of-line)
+ (and (zerop (current-indentation))
+ (not (looking-at "^[ \t]*$"))))
+ ;;The line is not blank and its indentation is zero
+ ;;It is a function definition. We know that
+ ;; there is not an equals on the line
+ (goto-char eol-limit)
+ ;;We expect a keyword
+ ;; so set indent to be this line's indentation
+ ;; plus the offset
+ (setq indent-point (point))
+ (setq indent (+ (current-indentation)
+ haskell-indent-offset)))
+
+ ((bobp)
+ ;;At the beginning of buffer
+ (setq indent 0))
+
+ (paren-indent
+ ;;We are indenting a list and none
+ ;; of the above indentations are applicable
+ ;; so copy the indentation of this line
+ (setq indent (current-indentation)))
+
+ (t
+ (save-excursion
+ (setq indent (haskell-context-indent)))))
+
+ (if (nth 3 (parse-partial-sexp
+ (save-excursion
+ (goto-char indent-point)
+ (haskell-back-to-zero-indent)
+ (point))
+ (save-excursion
+ (goto-char indent-point))))
+ ;;The point we determined indentation at is in a
+ ;; string so go to this point and go back one line to
+ ;; find indentation.
+ (setq indent (haskell-context-indent))))
+
+
+ ;;HOWEVER, we may have to override any indentation if we are in
+ ;; an unbalanced parenthesis (on the original line).
+ (flag)
+ (save-excursion
+ (goto-char original-position)
+ (let* ((eq-point (save-excursion
+ (haskell-back-to-symbol "=")
+ (point)))
+ (state (parse-partial-sexp
+ eq-point
+ (point))))
+ (if (> (car state) 0)
+ ;;There is an unbalanced parenthesis between
+ ;; the function and here.
+ (if (not (or (nth 3 state) (nth 4 state)))
+ ;;We are not in a string or comment
+ ;; so goto the parenthesis
+ (progn
+ (goto-char (nth 1 state))
+ (if (not (haskell-keyword-in-regionp
+ (point)
+ original-position))
+ ;;There is not a keyword after the open
+ ;; bracket so we override the indentation
+ (progn
+ (if (not (looking-at "{"))
+ ;;The parenthesis is not a `{'
+ (if (or (looking-at "\\[")
+ (save-excursion
+ (goto-char (haskell-eol))
+ (skip-chars-backward " \t")
+ (and
+ (char-equal (preceding-char) ?,)
+ (= (car state)
+ (car (parse-partial-sexp
+ eq-point
+ (point)))))))
+ ;;The paren is a square one
+ ;; or it is a tuple.
+ ;;Don't ignore what is after it.
+ (setq indent (haskell-list-align (haskell-eol)))
+ ;;Otherwise, ignore what comes after it.
+ (setq indent (haskell-list-align (point))))))))))))
+ ))
+
+ indent)))
+
+
+;;; Inserts the close parenthesis and reindents the line.
+;;; We want to reindent the line if the parenthesis is
+;;; the first character on the line. The parenthesis
+;;; recognised by this function are `]', `}'.
+
+(defun electric-haskell-brace ()
+ "Inserts the character `]' or `}' and reindents the current line."
+ "Insert character and correct line's indentation."
+ (interactive)
+ (if (save-excursion
+ (skip-chars-backward " \t")
+ (bolp))
+ ;;The parenthesis is at the beginning of the line.
+ (progn
+ (insert last-command-char)
+ (haskell-indent-line))
+ ;;Otherwise it is not at the beginning of line.
+ (insert last-command-char))
+ ;; Match its beginning.
+ (haskell-blink-open))
+
+
+
+
+;;; This function returns the indentation for the next line given
+;;; that it is contained in a bracket or we are extending a functions
+;;; parameters over a line. For the case of being in an unbalanced
+;;; parenthesis list, the point lies on the unbalanced parenthesis.
+;;; The parameter eol-limit is used to delimit the end of the line.
+
+(defun haskell-list-align (eol-limit)
+ "Returns the indentation for the next line given that
+the point lies on an unbalanced open parenthesis."
+ (save-excursion
+ (let ((indent (1+ (current-column))))
+ ;;Set indent to be the next char (at least).
+
+ (cond ((not
+ (looking-at ".[ \t]*\\($\\|--\\)"))
+ ;;There is something after the parenthesis
+ ;;ie. the line is not empty and ignore comments
+ (cond ((save-excursion
+ (goto-char eol-limit)
+ (skip-chars-backward " \t")
+ (and (char-equal (preceding-char) ?,)
+ (save-excursion
+ (beginning-of-line)
+ (not (search-forward "|" eol-limit 't)))))
+ ;;This is a normal list since a `,' at end
+ ;; and there is no a `|' on the line.
+ (forward-char 1)
+ (skip-chars-forward " \t")
+ (setq indent (current-column)))
+
+ ((looking-at "\\[")
+ ;;It is a list comp we are looking at
+ ;;Goto the bar.
+ (forward-char 1)
+ (search-forward "|" eol-limit 't)
+ (skip-chars-forward " \t")
+ (setq indent (current-column)))
+
+ ((looking-at ".[ \t]*(")
+ ;;We are looking at an open parenthesis
+ ;; after this character.
+ ;;It must be balanced so
+ ;; move to the start of this paren
+ ;; and set indent to be here
+ (forward-char 1)
+ (skip-chars-forward " \t")
+ (setq indent (current-column)))
+
+ (t
+ (forward-word 1)
+ ;;We are not looking at another open
+ ;; parenthesis, so move forward past the
+ ;; (assumed) function name.
+ (if (or
+ haskell-std-list-indent
+ (looking-at"[ \t]*\\($\\|--\\)"))
+ ;;There is nothing after the name
+ ;; or haskell-std-list-offset is set
+ ;; so set indent to be its original
+ ;; value plus the offset minus 1
+ ;; since we added one on earlier.
+ (setq indent
+ (+ indent
+ (1- haskell-list-offset)))
+
+ ;;Otherwise there is something after the
+ ;; name, so skip to the first non space
+ ;; character.
+ (skip-chars-forward " \t")
+ (setq indent (current-column)))))))
+
+
+ indent)))
+
+
+
+(defun haskell-insert-round-paren ()
+ "Inserts a `(' and blinks to its matching parenthesis."
+ (interactive)
+ (insert last-command-char)
+ (haskell-blink-open))
+
+
+
+;;; This function is called when a close parenthesis
+;;; `)', `]', or `}' is typed.
+;;; Blinks the cursor on the corresponding open parnethesis.
+;;; The point lies just after the close parenthesis.
+
+(defun haskell-blink-open ()
+ "Blinks the cursor to the matching open parenthesis.
+The point lies just after a parenthesis."
+ (let ((state (parse-partial-sexp (point)
+ (save-excursion
+ (haskell-back-to-zero-indent)
+ (point)))))
+ (if (and
+ (>= (car state) 0)
+ (not (or (nth 3 state) (nth 4 state))))
+ ;;The parenthesis just inserted has a match
+ ;; and is not in a string or a comment
+ ;; so blink on its match
+ (save-excursion
+ (goto-char (nth 2 state))
+ (sit-for 1)))))
+
+
+
+;;; This function indents the line expecting the line to be a
+;;; continued function application.
+
+;;; foo a = bar a
+;;; b {haskell-further-indent applied to this line
+;;; indents the line as shown}
+
+;;; The line would look like this if only tab had been applied:
+;;; foo a = bar a
+;;; b
+
+(defun haskell-further-indent ()
+ "Indents the line more than the ordinary indentation in order to
+extend function arguments over multiple lines."
+ (interactive)
+ (let (indent
+ (new-point (max (save-excursion
+ (haskell-back-to-symbol "=")
+ (point))
+ (save-excursion
+ (haskell-back-to-keyword)
+ (point)))))
+ (save-excursion
+ ;;This may be a continuation of a function
+ ;; application so go back to the last '='
+ ;; and set indent as designated by the style chosen
+ (goto-char new-point)
+ (skip-chars-forward "= \t")
+ (setq indent (haskell-list-align (haskell-eol))))
+ ;;The argument to haskell-list-align is not important here.
+ (save-excursion
+ (beginning-of-line)
+ (delete-horizontal-space)
+ (indent-to indent))
+ (if (< (current-column) indent)
+ (move-to-column indent))))
+
+
+;;; This function indents the current line to the first previous
+;;; indentation value which is less than the current indentation.
+
+(defun haskell-lesser-indent ()
+ "Indents the current line to the first previous indentation
+value which is less than the current indentation."
+ (interactive)
+ (let ((original-indent
+ (current-indentation))
+ (indent (haskell-context-indent))
+ (done nil))
+ (save-excursion
+ (while (not done)
+ (while (and (not (bobp))
+ (not (zerop (current-indentation)))
+ (>= indent original-indent))
+ (haskell-backward-to-noncomment)
+ (setq indent (current-indentation)))
+ ;;bobp or indent < original-indent
+ (if (>= indent original-indent)
+ ;;indent is still greater than or equal to original indent
+ (progn
+ (setq indent 0)
+ (setq done t))
+ ;;Otherwise, indent is less than orignal indent.
+ (forward-line 1)
+ (setq indent (haskell-context-indent))
+ (if (< indent original-indent)
+ ;;The new indent is an improvement
+ (setq done t)
+ ;;Otherwise, indent is still >= original
+ ;; so go back to the line and keep typing.
+ (forward-line -1)))))
+ (save-excursion
+ (beginning-of-line)
+ (delete-horizontal-space)
+ (indent-to indent))
+ (if (< (current-column) indent)
+ (move-to-column indent))))
+
+
+
+;;; Here are the functions which change the local variables
+;;; to facilitate tailorability.
+
+(defun default-mode ()
+ "Calls the function haskell-mode."
+ (interactive)
+ (haskell-mode)
+ (message haskell-indent-style))
+
+(defun wadler-mode ()
+ "Sets defaults according to Dr. Philip L. Wadler's preferences.
+ - Aligns `where' clauses with the corresponding equality.
+ - Aligns `else' keyword with the corresponding `then'
+ - haskell-list-offset 2
+ - haskell-indent-offset 8
+ - haskell-if-indent 2
+ - haskell-comment-column 0
+ - haskell-case-offset 2
+ - haskell-let-offset 5."
+ ;;Preferences:
+ ;;'haskell-align-where-with-eq non-nil
+ ;;'haskell-list-offset 2
+ (interactive)
+ (haskell-mode)
+ (or haskell-align-where-with-eq
+ (progn
+ (setq haskell-align-where-with-eq t)
+ (setq haskell-std-indent-where nil)))
+ (setq haskell-align-else-with-then t)
+ (setq haskell-list-offset 2)
+ (setq haskell-indent-offset 8)
+ (setq haskell-if-offset 2)
+ (setq haskell-case-offset 2)
+ (setq haskell-let-offset 5)
+ (setq haskell-comment-column 0)
+ (setq haskell-indent-style "Wadler")
+ (message haskell-indent-style))
+
+
+(defun report-mode ()
+ "Sets defaults according to the style of the Haskell Report.
+ - Aligns `where' clauses after the corresponding equality.
+ - Aligns `else' with `then'.
+ - haskell-then-offset = 3
+ - haskell-where-offset = 0.
+ - haskell-case-offset = 5."
+ ;;Preferences:
+ ;; haskell-align-where-after-eq non-nil
+ ;; haskell-then-offset 3
+ ;; haskell-where-offset 0
+ ;; haskell-case-offset 5
+ (interactive)
+ (haskell-mode)
+ (haskell-align-where-after-eq)
+ (or haskell-align-else-with-then
+ (haskell-align-else-with-then))
+ (setq haskell-then-offset 3)
+ (setq haskell-where-offset 0)
+ (setq haskell-case-offset 5)
+ (setq haskell-indent-style "Report")
+ (message haskell-indent-style))
+
+
+(defun haskell-align-where-with-eq ()
+ "Sets indentation so that a 'where' clause lines up underneath
+its corresponding equals sign."
+ (interactive)
+ (or haskell-align-where-with-eq
+ (progn
+ (setq haskell-align-where-after-eq nil)
+ (setq haskell-std-indent-where nil)
+ (setq haskell-align-where-with-eq t)
+ haskell-align-where-with-eq)))
+
+
+
+(defun haskell-align-where-after-eq ()
+ "Sets indentation so that a 'where' clause lines up underneath
+the first nonspace character after its corresponding equals sign."
+ (interactive)
+ (or haskell-align-where-after-eq
+ (progn
+ (setq haskell-align-where-with-eq nil)
+ (setq haskell-std-indent-where nil)
+ (setq haskell-align-where-after-eq t)
+ haskell-align-where-after-eq)))
+
+
+(defun haskell-std-indent-where ()
+ "Sets indentation so that a `where' clause lines up underneath
+its corresponding equals sign."
+ (interactive)
+ (or haskell-std-indent-where
+ (progn
+ (setq haskell-align-where-after-eq nil)
+ (setq haskell-align-where-with-eq nil)
+ (setq haskell-std-indent-where t)
+ haskell-std-indent-where)))
+
+
+(defun haskell-align-else-with-then ()
+ "Sets indentation so that an `else' lines up underneath
+it's corresponding `then'."
+ (interactive)
+ (setq haskell-align-else-with-then
+ (not haskell-align-else-with-then))
+ (setq haskell-nest-ifs nil))
+
+(defun haskell-nest-ifs ()
+ "Sets indentation so that an `if' is lined up
+under an `if' in an `else ."
+ (interactive)
+ (setq haskell-nest-ifs
+ (not haskell-nest-ifs))
+ (setq haskell-align-else-with-then nil))
+
+
+(defun haskell-always-fixup-comment-space ()
+ "Non-nil means always position one space after a line comment `--',
+when reindenting or inserting a comment,
+whether or not one space exists."
+ (setq haskell-always-fixup-comment-space
+ (not haskell-always-fixup-comment-space))
+ haskell-always-fixup-comment-space)
+
+(defun haskell-indent-style ()
+ "Echos the chosen indentation style in the mini-buffer."
+ (interactive)
+ (message haskell-indent-style))
+
+(defun set-haskell-let-offset (offset)
+ "Changes the value of haskell-let-offset, the variable which
+determines extra indentation after a `let' and `in'."
+ (interactive "nSet haskell-let-offset to: ")
+ (if (and (>= offset 0) (<= offset 10))
+ (setq haskell-let-offset offset)))
+
+(defun set-haskell-if-offset (offset)
+ "Changes the value of haskell-let-offset, the variable which
+determines extra indentation after an `if', `then' and `else'."
+ (interactive "nSet haskell-if-offset to: ")
+ (if (and (>= offset 0) (<= offset 10))
+ (setq haskell-if-offset offset)))
+
+(defun set-haskell-case-offset (offset)
+ "Changes the value of haskell-case-offset, the variable which
+determines extra indentation after a `case' and `of'."
+ (interactive "nSet haskell-case-offset to: ")
+ (if (and (>= offset 0) (<= offset 10))
+ (setq haskell-case-offset offset)))
+
+
+(defun set-haskell-where-offset (offset)
+ "Changes the value of haskell-where-offset, the variable which
+determines extra indentation after a line of haskell code."
+ (interactive "nSet haskell-where-offset to: ")
+ (if (and (>= offset 0) (<= offset 10))
+ (setq haskell-where-offset offset)))
+
+
+(defun set-haskell-indent-offset (offset)
+ "Changes the value of haskell-indent-offset, the variable which
+determines extra indentation after a line of haskell code."
+ (interactive "nSet haskell-indent-offset to: ")
+ (if (and (>= offset 1) (<= offset 10))
+ (setq haskell-indent-offset offset)))
+
+
+(defun set-haskell-list-offset (offset)
+ "Changes the value of haskell-list-offset, the variable which
+determines extra indentation after a line of haskell code for a list."
+ (interactive "nSet haskell-list-offset to: ")
+ (if (and (>= offset 0) (<= offset 10))
+ (setq haskell-list-offset offset)))
+
+
+(defun set-haskell-comp-offset (offset)
+ "Changes the value of haskell-comp-offset, the variable which
+determines extra indentation after a list comprehension."
+ (interactive "nSet haskell-comp-offset to: ")
+ (if (and (>= offset 0) (<= offset 10))
+ (setq haskell-comp-offset offset)))
+
+
+(defun set-haskell-then-offset (offset)
+ "Changes the value of haskell-then-offset, the variable which
+determines extra indentation for a `then' keyword after an `if'."
+ (interactive "nSet haskell-then-offset to: ")
+ (if (and (>= offset 0) (<= offset 10))
+ (setq haskell-then-offset offset)))
+
+
+(defun set-haskell-comment-column (column)
+ "Changes the value of haskell-comment-column, the variable which
+determines where to postition a line comment `--'."
+ (interactive "nSet haskell-comment-column to: ")
+ (if (and (>= column 0) (<= column 100))
+ (setq haskell-comment-column column)))
+
+(defun set-haskell-concat-column (column)
+ "Changes the value of haskell-concat-column, the variable which
+determines where to postition a concatenation operator `++'."
+ (interactive "nSet haskell-concat-column to: ")
+ (if (and (>= column 0) (<= column 100))
+ (setq haskell-concat-column column)))
+
+(defun set-haskell-where-threshold (column)
+ "Changes the value of haskell-where-threshold, the variable which
+determines when to override positioning a `where' under or after
+its corresponding equality."
+ (interactive "nSet haskell-where-threshold to: ")
+ (if (and (>= column 0) (<= column 100))
+ (setq haskell-where-threshold column)))
+
+(defun flag ())
\ No newline at end of file
projects / ghc-hetmet.git / blobdiff