+++ /dev/null
-;; haskell-mode.el. Major mode for editing Haskell.
-;; Copyright (C) 1989, Free Software Foundation, Inc., Lars Bo Nielsen
-;; and Lennart Augustsson
-;; modified by Peter Thiemann, March 1994
-
-;; This file is not officially part of GNU Emacs.
-
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY. No author or distributor
-;; accepts responsibility to anyone for the consequences of using it
-;; or for whether it serves any particular purpose or works at all,
-;; unless he says so in writing. Refer to the GNU Emacs General Public
-;; License for full details.
-
-;; Everyone is granted permission to copy, modify and redistribute
-;; GNU Emacs, but only under the conditions described in the
-;; GNU Emacs General Public License. A copy of this license is
-;; supposed to have been given to you along with GNU Emacs so you
-;; can know your rights and responsibilities. It should be in a
-;; file named COPYING. Among other things, the copyright notice
-;; and this notice must be preserved on all copies.
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;; Haskell Mode. A major mode for editing and running Haskell. (Version 0.0)
-;; =================================================================
-;;
-;; This is a mode for editing and running Haskell.
-;; It is very much based on the sml mode for GNU Emacs. It
-;; features:
-;;
-;; - Inferior shell running Haskell. No need to leave emacs, just
-;; keep right on editing while Haskell runs in another window.
-;;
-;; - Automatic "load file" in inferior shell. Send regions of code
-;; to the Haskell program.
-;;
-;;
-;; 1. HOW TO USE THE Haskell-MODE
-;; ==========================
-;;
-;; Here is a short introduction to the mode.
-;;
-;; 1.1 GETTING STARTED
-;; -------------------
-;;
-;; If you are an experienced user of Emacs, just skip this section.
-;;
-;; To use the haskell-mode, insert this in your "~/.emacs" file (Or ask your
-;; emacs-administrator to help you.):
-;;
-;; (setq auto-mode-alist (cons '("\\.hs$" . haskell-mode) (cons '("\\.lhs$" . haskell-mode)
-;; auto-mode-alist)))
-;; (autoload 'haskell-mode "haskell-mode" "Major mode for editing Haskell." t)
-;;
-;; Now every time a file with the extension `.hs' or `.lhs' is found, it is
-;; automatically started up in haskell-mode.
-;;
-;; You will also have to specify the path to this file, so you will have
-;; to add this as well:
-;;
-;; (setq load-path (cons "/usr/me/emacs" load-path))
-;;
-;; where "/usr/me/emacs" is the directory where this file is.
-;;
-;; You may also want to compile the this file (M-x byte-compile-file)
-;; for speed.
-;;
-;; You are now ready to start using haskell-mode. If you have tried other
-;; language modes (like lisp-mode or C-mode), you should have no
-;; problems. There are only a few extra functions in this mode.
-;;
-;; 1.2. EDITING COMMANDS.
-;; ----------------------
-;;
-;; The following editing and inferior-shell commands can ONLY be issued
-;; from within a buffer in haskell-mode.
-;;
-;; LFD (haskell-newline-and-indent).
-;; This is probably the function you will be using the most (press
-;; CTRL while you press Return, press C-j or press Newline). It
-;; makes a new line and performs indentation based on the last
-;; preceding non-comment line.
-;;
-;; M-; (indent-for-comment).
-;; Like in other language modes, this command will give you a comment
-;; at the of the current line. The column where the comment starts is
-;; determined by the variable comment-column (default: 40).
-;;
-;; C-c C-v (haskell-mode-version).
-;; Get the version of the haskell-mode.
-;;
-;;
-;; 1.3. COMMANDS RELATED TO THE INFERIOR SHELL
-;; -------------------------------------------
-;;
-;; C-c C-s (haskell-pop-to-shell).
-;; This command starts up an inferior shell running haskell. If the shell
-;; is running, it will just pop up the shell window.
-;;
-;; C-c C-u (haskell-save-buffer-use-file).
-;; This command will save the current buffer and send a "load file",
-;; where file is the file visited by the current buffer, to the
-;; inferior shell running haskell.
-;;
-;; C-c C-f (haskell-run-on-file).
-;; Will send a "load file" to the inferior shell running haskell,
-;; prompting you for the file name.
-;;
-;; C-c C-r (haskell-send-region).
-;; Will send region, from point to mark, to the inferior shell
-;; running haskell.
-;;
-;; C-c C-b (haskell-send-buffer).
-;; Will send whole buffer to inferior shell running haskell.
-;;
-;; 2. INDENTATION
-;; ================
-;;
-;; The first indentation command (using C-j or TAB) on a given line
-;; indents like the last preceding non-comment line. The next TAB
-;; indents to the indentation of the innermost enclosing scope. Further
-;; TABs get you to further enclosing scopes. After indentation has
-;; reached the first column, the process restarts using the indentation
-;; of the preceding non-comment line, again.
-;;
-;; 3. INFERIOR SHELL.
-;; ==================
-;;
-;; The mode for Standard ML also contains a mode for an inferior shell
-;; running haskell. The mode is the same as the shell-mode, with just one
-;; extra command.
-;;
-;; 3.1. INFERIOR SHELL COMMANDS
-;; ----------------------------
-;;
-;; C-c C-f (haskell-run-on-file). Send a `load file' to the process running
-;; haskell.
-;;
-;; 3.2. CONSTANTS CONTROLLING THE INFERIOR SHELL MODE
-;; --------------------------------------------------
-;;
-;; Because haskell is called differently on various machines, and the
-;; haskell-systems have their own command for reading in a file, a set of
-;; constants controls the behavior of the inferior shell running haskell (to
-;; change these constants: See CUSTOMIZING YOUR Haskell-MODE below).
-;;
-;; haskell-prog-name (default "hbi").
-;; This constant is a string, containing the command to invoke
-;; Standard ML on your system.
-;;
-;; haskell-use-right-delim (default "\"")
-;; haskell-use-left-delim (default "\"")
-;; The left and right delimiter used by your version of haskell, for
-;; `use file-name'.
-;;
-;; haskell-process-name (default "Haskell").
-;; The name of the process running haskell. (This will be the name
-;; appearing on the mode line of the buffer)
-;;
-;; NOTE: The haskell-mode functions: haskell-send-buffer, haskell-send-function and
-;; haskell-send-region, creates temporary files (I could not figure out how
-;; to send large amounts of data to a process). These files will be
-;; removed when you leave emacs.
-;;
-;; 4. FONTIFICATION
-;;
-;; There is support for Jamie Zawinski's font-lock-mode through the
-;; variable "haskell-font-lock-keywords".
-;;
-;; 5. CUSTOMIZING YOUR Haskell-MODE
-;; ============================
-;;
-;; If you have to change some of the constants, you will have to add a
-;; `hook' to the haskell-mode. Insert this in your "~/.emacs" file.
-;;
-;; (setq haskell-mode-hook 'my-haskell-constants)
-;;
-;; Your function "my-haskell-constants" will then be executed every time
-;; "haskell-mode" is invoked. Now you only have to write the emacs-lisp
-;; function "my-haskell-constants", and put it in your "~/.emacs" file.
-;;
-;; Say you are running a version of haskell that uses the syntax `load
-;; ["file"]', is invoked by the command "OurHaskell" and you don't want the
-;; indentation algorithm to indent according to open parenthesis, your
-;; function should look like this:
-;;
-;; (defun my-haskell-constants ()
-;; (setq haskell-prog-name "OurHaskell")
-;; (setq haskell-use-left-delim "[\"")
-;; (setq haskell-use-right-delim "\"]")
-;; (setq haskell-paren-lookback nil))
-;;
-;; The haskell-shell also runs a `hook' (haskell-shell-hook) when it is invoked.
-;;
-;;
-;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;;
-;; ORIGINAL AUTHOR
-;; Lars Bo Nielsen
-;; Aalborg University
-;; Computer Science Dept.
-;; 9000 Aalborg
-;; Denmark
-;;
-;; lbn@iesd.dk
-;; or: ...!mcvax!diku!iesd!lbn
-;; or: mcvax!diku!iesd!lbn@uunet.uu.net
-;;
-;; MODIFIED FOR Haskell BY
-;; Lennart Augustsson
-;; indentation stuff by Peter Thiemann
-;;
-;;
-;; Please let me know if you come up with any ideas, bugs, or fixes.
-;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defconst haskell-mode-version-string
- "HASKELL-MODE, Version 0.2, PJT indentation")
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;
-;;; CONSTANTS CONTROLLING THE MODE.
-;;;
-;;; These are the constants you might want to change
-;;;
-
-;; The command used to start up the haskell-program.
-(defconst haskell-prog-name "hbi" "*Name of program to run as haskell.")
-
-;; The left delimmitter for `load file'
-(defconst haskell-use-left-delim "\""
- "*The left delimiter for the filename when using \"load\".")
-
-;; The right delimmitter for `load file'
-(defconst haskell-use-right-delim "\""
- "*The right delimiter for the filename when using \"load\".")
-
-;; A regular expression matching the prompt pattern in the inferior
-;; shell
-(defconst haskell-shell-prompt-pattern "^> *"
- "*The prompt pattern for the inferion shell running haskell.")
-
-;; The template used for temporary files, created when a region is
-;; send to the inferior process running haskell.
-(defconst haskell-tmp-template "/tmp/haskell.tmp."
- "*Template for the temporary file, created by haskell-simulate-send-region.")
-
-;; The name of the process running haskell (This will also be the name of
-;; the buffer).
-(defconst haskell-process-name "Haskell" "*The name of the Haskell-process")
-
-;;;
-;;; END OF CONSTANTS CONTROLLING THE MODE.
-;;;
-;;; If you change anything below, you are on your own.
-;;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-
-(defvar haskell-mode-syntax-table nil "The syntax table used in haskell-mode.")
-
-(defvar haskell-mode-map nil "The mode map used in haskell-mode.")
-
-(defvar haskell-mode-abbrev-table nil "The abbrev-table used in haskell-mode.")
-
-(defvar haskell-old-kill-emacs-hook nil "Old value of kill-emacs-hook")
-
-(defun haskell-mode ()
- "Major mode for editing Haskell code.
-Tab indents for Haskell code.
-Comments are delimited with --
-Paragraphs are separated by blank lines only.
-Delete converts tabs to spaces as it moves back.
-
-Key bindings:
-=============
-
-\\[haskell-pop-to-shell]\t Pop to the haskell window.
-\\[haskell-save-buffer-use-file]\t Save the buffer, and send a \"load file\".
-\\[haskell-send-region]\t Send region (point and mark) to haskell.
-\\[haskell-run-on-file]\t Send a \"load file\" to haskell.
-\\[haskell-send-buffer]\t Send whole buffer to haskell.
-\\[haskell-mode-version]\t Get the version of haskell-mode.
-\\[haskell-evaluate-expression]\t Prompt for an expression and evalute it.
-
-
-Mode map
-========
-\\{haskell-mode-map}
-Runs haskell-mode-hook if non nil."
- (interactive)
- (kill-all-local-variables)
- (if haskell-mode-map
- ()
- (setq haskell-mode-map (make-sparse-keymap))
- (define-key haskell-mode-map "\C-c\C-v" 'haskell-mode-version)
- (define-key haskell-mode-map "\C-c\C-u" 'haskell-save-buffer-use-file)
- (define-key haskell-mode-map "\C-c\C-s" 'haskell-pop-to-shell)
- (define-key haskell-mode-map "\C-c\C-r" 'haskell-send-region)
- (define-key haskell-mode-map "\C-c\C-m" 'haskell-region)
- (define-key haskell-mode-map "\C-c\C-f" 'haskell-run-on-file)
- (define-key haskell-mode-map "\C-c\C-b" 'haskell-send-buffer)
- (define-key haskell-mode-map "\C-c\C-l" 'comment-line)
- (define-key haskell-mode-map "\C-ce" 'haskell-evaluate-expression)
-; (define-key haskell-mode-map "\C-j" 'haskell-newline-and-indent)
- (define-key haskell-mode-map [S-tab] 'tab-to-tab-stop)
- (define-key haskell-mode-map "\177" 'backward-delete-char-untabify))
- (use-local-map haskell-mode-map)
- (setq major-mode 'haskell-mode)
- (setq mode-name "Haskell")
- (define-abbrev-table 'haskell-mode-abbrev-table ())
- (setq local-abbrev-table haskell-mode-abbrev-table)
- (if haskell-mode-syntax-table
- ()
- (setq haskell-mode-syntax-table (make-syntax-table))
- (modify-syntax-entry ?{ "(}1" haskell-mode-syntax-table)
- (modify-syntax-entry ?} "){4" haskell-mode-syntax-table)
-; partain: out
-; (modify-syntax-entry ?- "_ 2356" haskell-mode-syntax-table)
-; (modify-syntax-entry ?\f "> b" haskell-mode-syntax-table)
-; (modify-syntax-entry ?\n "> b" haskell-mode-syntax-table)
-; partain: end out
-; partain: in
- (modify-syntax-entry ?- "_ 23" haskell-mode-syntax-table)
-; (modify-syntax-entry ?\f "> b" haskell-mode-syntax-table)
-; (modify-syntax-entry ?\n "> b" haskell-mode-syntax-table)
-; partain: end in
- (modify-syntax-entry ?\\ "\\" haskell-mode-syntax-table)
- (modify-syntax-entry ?* "_" haskell-mode-syntax-table)
- (modify-syntax-entry ?_ "_" haskell-mode-syntax-table)
- (modify-syntax-entry ?' "_" haskell-mode-syntax-table)
- (modify-syntax-entry ?: "_" haskell-mode-syntax-table)
- (modify-syntax-entry ?| "." haskell-mode-syntax-table)
- )
- (set-syntax-table haskell-mode-syntax-table)
- (make-local-variable 'require-final-newline) ; Always put a new-line
- (setq require-final-newline t) ; in the end of file
-; (make-local-variable 'change-major-mode-hook)
-; (setq change-major-mode-hook nil)
-; (make-local-variable 'indent-line-function)
-; (setq indent-line-function 'haskell-indent-line)
- (make-local-variable 'comment-start)
- (setq comment-start "-- ")
-; (setq comment-start "{- ")
- (make-local-variable 'comment-end)
- (setq comment-end "")
-; (setq comment-end " -}")
- (make-local-variable 'comment-column)
- (setq comment-column 60) ; Start of comment in this column
- (make-local-variable 'comment-start-skip)
- (setq comment-start-skip "{-+ *\\|--+ *") ; This matches a start of comment
- (make-local-variable 'comment-multi-line)
- (setq comment-multi-line nil)
-; (make-local-variable 'comment-indent-function)
-; (setq comment-indent-function 'haskell-comment-indent)
- ;;
- ;; Adding these will fool the matching of parens. I really don't
- ;; know why. It would be nice to have comments treated as
- ;; white-space
- ;;
- ;; (make-local-variable 'parse-sexp-ignore-comments)
- ;; (setq parse-sexp-ignore-comments t)
- ;;
- (run-hooks 'haskell-mode-hook)) ; Run the hook
-
-(defun haskell-mode-version ()
- (interactive)
- (message haskell-mode-version-string))
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;
-;;; INDENTATION
-;;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;;; some variables for later use
-
-(defvar haskell-open-comment "{-")
-(defvar haskell-close-comment "-}")
-(defvar haskell-indentation-counter 0
- "count repeated invocations of indent-for-tab-command")
-(defvar haskell-literate-flag nil
- "used to guide literate/illiterate behavior, set automagically")
-
-(defun haskell-newline-and-indent ()
- (interactive)
- (setq haskell-literate-flag
- (save-excursion
- (beginning-of-line)
- (= (following-char) ?>)))
- (newline)
- (if haskell-literate-flag (insert ">"))
- (haskell-indent-line))
-
-(defun haskell-indent-line ()
- "Indent current line of ordinary or literate Haskell code."
- (interactive)
- (let ((indent (haskell-calculate-indentation-pjt-2)))
- (if (/= (current-indentation) indent)
- (let ((beg (progn
- (beginning-of-line)
- (if (= (following-char) ?>) (forward-char 1)) ;LITERATE
- (point))))
- (skip-chars-forward "\t ")
- (delete-region beg (point))
- (indent-to indent))
- ;; If point is before indentation, move point to indentation
- (if (< (current-column) (current-indentation))
- (skip-chars-forward "\t ")))))
-
-(defun haskell-calculate-indentation ()
- (save-excursion
- (let ((col (current-column)))
- (while (and (not (bobp)) ;skip over empty and comment-only lines
- (= col (current-column)))
- (previous-line 1)
- (beginning-of-line) ; Go to first non whitespace
- (if (= (following-char) ?>) ;LITERATE
- (forward-char 1)
- (if haskell-literate-flag ;ignore illiterate lines
- (end-of-line)))
- (skip-chars-forward "\t ") ; on the line.
- (setq col (current-column))
- (search-forward-regexp (concat haskell-open-comment "\\|--\\|\n") nil 0)
- (goto-char (match-beginning 0)))
- (search-backward-regexp "\\b\\(where\\|let\\|of\\|in\\)\\b\\|\n" nil 0)
- (if (looking-at "\n")
- ()
- (setq col (current-column))
- (forward-word 1)
- (skip-chars-forward "\t ")
- (if (looking-at "\\w")
- (setq col (current-column))
- (setq col (+ 2 col))))
- col)))
-
-(defun haskell-calculate-indentation-pjt-2 ()
- "Calculate indentation for Haskell program code, versatile version"
- (save-excursion
- (if (eq last-command 'haskell-indentation)
- (setq haskell-indentation-counter (1+ haskell-indentation-counter))
- (setq haskell-indentation-counter -1))
- (setq this-command 'haskell-indentation)
- (let* ((simple-indent (haskell-calculate-indentation))
- (count haskell-indentation-counter)
- (min-indent simple-indent) ; minimum indentation found in a non-comment line
- (last-indent simple-indent) ; indentation of the following non-comment line
- (return-indent nil) ; computed indentation
- (comment-depth 0))
- (previous-line 1)
- (if (< haskell-indentation-counter 0) ; 1st tab gives simple indentation
- (setq return-indent simple-indent))
- (while (not return-indent)
- (if (search-backward-regexp "\\b\\(where\\|let\\|of\\)\\b\\|\n\\|{-\\|-}" nil t 1)
- (cond
- ((looking-at haskell-open-comment)
- (setq comment-depth (1- comment-depth)))
- ((looking-at haskell-close-comment)
- (setq comment-depth (1+ comment-depth)))
- ((= 0 comment-depth)
- (cond
- ((looking-at "\n")
- (save-excursion
- (forward-char 1)
- (if (= (following-char) ?>)
- (forward-char 1)
- (if haskell-literate-flag
- (end-of-line))) ;LITERATE: ignore lines w/o >
- (skip-chars-forward "\t ")
- (if (looking-at (concat haskell-open-comment "\\|--\\|\n"))
- ()
- (setq last-indent (current-column))
- (if (< last-indent min-indent)
- (setq min-indent last-indent)))))
- (t ; looking at a keyword
- (save-excursion
- (forward-word 1)
- (skip-chars-forward " \t")
- (if (and haskell-literate-flag ;LITERATE: ignore lines w/o >
- (save-excursion
- (beginning-of-line)
- (/= (following-char) ?>)))
- (end-of-line))
- (if (looking-at (concat haskell-open-comment "\\|--\\|\n"))
- ()
- (setq last-indent (current-column)))
- (if (<= last-indent min-indent)
- (if (> count 0)
- (setq count (1- count))
- (setq return-indent last-indent)))
- (if (< last-indent min-indent)
- (setq min-indent last-indent)))))))
- (setq return-indent simple-indent)
- (setq haskell-indentation-counter -1)))
- return-indent)))
-
-(defun haskell-skip-nested-comment ()
- ;; point looks at opening {-, move over closing -}
- ;; todo: specify what happens on failure, bounds check ...
- (forward-char 2)
- (let ((comment-depth 1))
- (while (> comment-depth 0)
- (search-forward-regexp "{-\\|-}")
- (goto-char (match-beginning 0))
- (setq comment-depth
- (if (= (following-char) 123) ; code for opening brace
- (1+ comment-depth)
- (1- comment-depth)))
- (goto-char (match-end 0)))))
-
-
-;;;seemingly obsolete functions
-(defun haskell-inside-of-inline-comment ()
- (let ((bolp (save-excursion
- (beginning-of-line)
- (point))))
- (search-backward comment-start bolp t 1)))
-
-(defun haskell-inside-of-nested-comment ()
- (save-excursion
- (let ((count 0))
- (while
- (search-backward-regexp "\\({-\\|-}\\)" 0 t 1)
- (if (haskell-inside-of-inline-comment)
- ()
- (if (looking-at haskell-open-comment)
- (setq count (1+ count))
- (setq count (1- count)))))
- (> count 0))))
-
-(defun haskell-inside-of-comment ()
- (or (haskell-inside-of-inline-comment)
- (haskell-inside-of-nested-comment)))
-
-;;;stolen from sml-mode.el
-(defun haskell-comment-indent ()
- "Compute indentation for Haskell comments"
- (if (looking-at "^--")
- 0
- (save-excursion
- (skip-chars-backward " \t")
- (max (1+ (current-column))
- comment-column))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;
-;;; INFERIOR SHELL
-;;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(defvar haskell-shell-map nil "The mode map for haskell-shell.")
-
-(defun haskell-shell ()
- "Inferior shell invoking Haskell.
-It is not possible to have more than one shell running Haskell.
-Like the shell mode with the additional command:
-
-\\[haskell-run-on-file]\t Runs haskell on the file.
-\\{haskell-shell-map}
-Variables controlling the mode:
-
-haskell-prog-name (default \"hbi\")
- The string used to invoke the haskell program.
-
-haskell-use-right-delim (default \"\\\"\")
-haskell-use-left-delim (default \"\\\"\")
- The left and right delimiter used by your version of haskell, for
- \"load file-name\".
-
-haskell-process-name (default \"Haskell\")
- The name of the process running haskell.
-
-haskell-shell-prompt-pattern (default \"^> *\")
- The prompt pattern.
-
-Runs haskell-shell-hook if not nil."
- (interactive)
- (if (not (process-status haskell-process-name))
- (save-excursion ; Process is not running
- (message "Starting Haskell...") ; start up a new process
- (require 'shell)
- (set-buffer (make-comint haskell-process-name haskell-prog-name))
- (erase-buffer) ; Erase the buffer if a previous
- (if haskell-shell-map ; process died in there
- ()
- (setq haskell-shell-map (copy-keymap shell-mode-map))
- (define-key haskell-shell-map "\C-c\C-f" 'haskell-run-on-file))
- (use-local-map haskell-shell-map)
- (make-local-variable 'shell-prompt-pattern)
- (setq shell-prompt-pattern haskell-shell-prompt-pattern)
- (setq major-mode 'haskell-shell)
- (setq mode-name "Haskell Shell")
- (setq mode-line-format
- "-----Emacs: %17b %M %[(%m: %s)%]----%3p--%-")
- (set-process-filter (get-process haskell-process-name) 'haskell-process-filter)
- (message "Starting Haskell...done.")
- (run-hooks 'haskell-shell-hook))))
-
-(defun haskell-process-filter (proc str)
- (let ((cur (current-buffer))
- (pop-up-windows t))
- (pop-to-buffer (concat "*" haskell-process-name "*"))
- (goto-char (point-max))
- (if (string= str "\b\b\b \b\b\b")
- (backward-delete-char 4)
- (insert str))
- (set-marker (process-mark proc) (point-max))
- (pop-to-buffer cur)))
-
-(defun haskell-pop-to-shell ()
- (interactive)
- (haskell-shell)
- (pop-to-buffer (concat "*" haskell-process-name "*")))
-
-(defun haskell-run-on-file (fil)
- (interactive "FRun Haskell on : ")
- (haskell-shell)
- (save-some-buffers)
- (process-send-string haskell-process-name
- (concat "load " haskell-use-left-delim (expand-file-name fil)
- haskell-use-right-delim ";\n")))
-
-(defun haskell-save-buffer-use-file ()
- "Save the buffer, and send a `use file' to the inferior shell
-running Haskell."
- (interactive)
- (let (file)
- (if (setq file (buffer-file-name)) ; Is the buffer associated
- (progn ; with file ?
- (save-buffer)
- (haskell-shell)
- (process-send-string haskell-process-name
- (concat "load " haskell-use-left-delim
- (expand-file-name file)
- haskell-use-right-delim ";\n")))
- (error "Buffer not associated with file."))))
-
-(defvar haskell-tmp-files-list nil
- "List of all temporary files created by haskell-simulate-send-region.
-Each element in the list is a list with the format:
-
- (\"tmp-filename\" buffer start-line)")
-
-(defvar haskell-simulate-send-region-called-p nil
- "Has haskell-simulate-send-region been called previously.")
-
-(defun haskell-make-temp-name (pre)
- (concat (make-temp-name pre) ".m"))
-
-(defun haskell-simulate-send-region (point1 point2)
- "Simulate send region. As send-region only can handle what ever the
-system sets as the default, we have to make a temporary file.
-Updates the list of temporary files (haskell-tmp-files-list)."
- (let ((file (expand-file-name (haskell-make-temp-name haskell-tmp-template))))
- ;; Remove temporary files when we leave emacs
- (if (not haskell-simulate-send-region-called-p)
- (progn
- (setq haskell-old-kill-emacs-hook kill-emacs-hook)
- (setq kill-emacs-hook 'haskell-remove-tmp-files)
- (setq haskell-simulate-send-region-called-p t)))
- (save-excursion
- (goto-char point1)
- (setq haskell-tmp-files-list
- (cons (list file
- (current-buffer)
- (save-excursion ; Calculate line no.
- (beginning-of-line)
- (1+ (count-lines 1 (point)))))
- haskell-tmp-files-list)))
- (write-region point1 point2 file nil 'dummy)
- (haskell-shell)
- (message "Using temporary file: %s" file)
- (process-send-string
- haskell-process-name
- ;; string to send: load file;
- (concat "load " haskell-use-left-delim file haskell-use-right-delim ";\n"))))
-
-(defun haskell-remove-tmp-files ()
- "Remove the temporary files, created by haskell-simulate-send-region, if
-they still exist. Only files recorded in haskell-tmp-files-list are removed."
- (message "Removing temporary files created by haskell-mode...")
- (while haskell-tmp-files-list
- (condition-case ()
- (delete-file (car (car haskell-tmp-files-list)))
- (error ()))
- (setq haskell-tmp-files-list (cdr haskell-tmp-files-list)))
- (message "Removing temporary files created by haskell-mode...done.")
- (run-hooks 'haskell-old-kill-emacs-hook))
-
-(defun haskell-send-region ()
- "Send region."
- (interactive)
- (let (start end)
- (save-excursion
- (setq end (point))
- (exchange-point-and-mark)
- (setq start (point)))
- (haskell-simulate-send-region start end)))
-
-(defun haskell-send-buffer ()
- "Send the buffer."
- (interactive)
- (haskell-simulate-send-region (point-min) (point-max)))
-
-(defun haskell-evaluate-expression (h-expr)
- "Prompt for and evaluate an expression"
- (interactive "sExpression: ")
- (let ((str (concat h-expr ";\n"))
- (buf (current-buffer)))
- (haskell-pop-to-shell)
- (insert str)
- (process-send-string haskell-process-name str)
- (pop-to-buffer buf)))
-
-
-;;
-;; font-lock-mode patterns, based on specs. in an earlier version
-;; of haskell-mode.el
-;; (these patterns have only been tested with 19.30)
-
-(defconst haskell-font-lock-keywords nil
- "Conservative highlighting of a Haskell buffer
-(using font-lock.)")
-
-(let ((haskell-id "[a-z_][a-zA-Z0-9_'#]+")
- (haskell-reserved-ids
- (concat "\\b\\("
- (mapconcat
- 'identity
- '("case" "class" "data"
- "default" "deriving" "else"
- "hiding" "if" "import" "in"
- "instance" "interface" "let"
- "module" "of" "renaming"
- "then" "to" "type" "where" "infix[rl]?")
- "\\|")
- "\\)[ \t\n:,]"))
- (haskell-basic-types
- (concat "\\b\\("
- (mapconcat 'identity
- '("Bool" "()" "String" "Char" "Int"
- "Integer" "Float" "Double" "Ratio"
- "Assoc" "Rational" "Array")
- "\\|")
- "\\)\\b"))
- (haskell-prelude-classes
- (concat "\\b\\("
- (mapconcat 'identity
- '("Eq" "Ord" "Text" "Num" "Real" "Fractional"
- "Integral" "RealFrac" "Floating" "RealFloat"
- "Complex" "Ix" "Enum"
- ;; ghc-isms
- "_CCallable" "_CReturnable")
- "\\|")
- "\\)\\b"))
- (haskell-reserved-ops
- (mapconcat 'identity
- '("\\.\\." "::"
- "=>" "/=" "@"
- "<-" "->")
- "\\|"))
- (glasgow-haskell-ops
- (concat "\\b\\("
- (mapconcat
- 'identity
- '(">>" ">>=" "thenPrimIO"
- "seqPrimIO" "returnPrimIO"
- "return" "_ccall_" "_casm_"
- "thenST" "seqST" "returnST"
- "thenStrictlyST" "seqStrictlyST" "returnStrictlyST"
- "unsafeInterleavePrimIO" "unsafePerformIO")
- "\\|")
- "\\)\\b"))
- (glasgow-haskell-types
- (concat "\\b\\("
- (mapconcat
- 'identity
- '("IO" "PrimIO" "_?ST"
- "_Word" "_Addr" "_?MVar"
- "_?IVar" "_RealWorld"
- "_?MutableByteArray"
- "_?ByteArray")
- "\\|")
- "\\)\\b")))
- (setq haskell-font-lock-keywords
- (list
- '("--.*$" . font-lock-comment-face)
- (list "[ \t\n]*\\([A-Za-z[(_][]A-Za-z0-9_$', ~@|:[)(#]*[ \t\n]*\\)=" 1 font-lock-function-name-face)
- (list (concat "^>?[ \t\n]*\\(" haskell-id "\\)[ \t]*::") 1 'font-lock-function-name-face)
- (list haskell-reserved-ids 0 'font-lock-function-name-face)
- (list glasgow-haskell-ops 0 'font-lock-function-name-face)
- (list glasgow-haskell-types 0 'font-lock-type-face)
- (list haskell-basic-types 0 'font-lock-type-face)
- (list haskell-prelude-classes 0 'font-lock-type-face)
- (list "^[ \t\n]*\\([A-Za-z[(_][]A-Za-z0-9_$', @:[)(#]*[ \t\n]*\\)->" 1 font-lock-variable-name-face)
- )))
-
-;;
-;; To enable font-lock-mode for Haskell buffers, add something
-;; like this to your ~/.emacs
-
-;(cond (window-system
-; (require 'font-lock)
-; (add-hook 'haskell-mode-hook
-; '(lambda () (make-local-variable 'font-lock-defaults)
-; (make-local-variable 'font-lock-mode-hook) ; don't affect other buffers
-; (setq font-lock-mode-hook nil)
-; (add-hook 'font-lock-mode-hook
-; '(lambda ()
-; (setq font-lock-keywords haskell-font-lock-keywords)))
-; (font-lock-mode 1))))
-
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;;
-;;;; END OF Haskell-MODE
-;;;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(provide 'haskell-mode)
projects / ghc-hetmet.git / blobdiff