[bpt/emacs.git] / lisp / progmodes / octave-inf.el

;;; octave-inf.el --- running Octave as an inferior Emacs process

;; Copyright (C) 1997, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
;; Free Software Foundation, Inc.

;; Author: Kurt Hornik <Kurt.Hornik@wu-wien.ac.at>
;; Author: John Eaton <jwe@bevo.che.wisc.edu>
;; Maintainer: Kurt Hornik <Kurt.Hornik@wu-wien.ac.at>
;; Keywords: languages
;; Package: octave-mod

;; This file is part of GNU Emacs.

;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.

;;; Commentary:

;;; Code:

(require 'octave-mod)
(require 'comint)

(defgroup octave-inferior nil
  "Running Octave as an inferior Emacs process."
  :group 'octave)

(defcustom inferior-octave-program "octave"
  "Program invoked by `inferior-octave'."
  :type 'string
  :group 'octave-inferior)

(defcustom inferior-octave-prompt
  "\\(^octave\\(\\|.bin\\|.exe\\)\\(-[.0-9]+\\)?\\(:[0-9]+\\)?\\|^debug\\|^\\)>+ "
  "Regexp to match prompts for the inferior Octave process."
  :type 'regexp
  :group 'octave-inferior)

(defcustom inferior-octave-startup-file nil
  "Name of the inferior Octave startup file.
The contents of this file are sent to the inferior Octave process on
startup."
  :type '(choice (const :tag "None" nil)
		 file)
  :group 'octave-inferior)

(defcustom inferior-octave-startup-args nil
  "List of command line arguments for the inferior Octave process.
For example, for suppressing the startup message and using `traditional'
mode, set this to (\"-q\" \"--traditional\")."
  :type '(repeat string)
  :group 'octave-inferior)

(defvar inferior-octave-mode-map
  (let ((map (make-sparse-keymap)))
    (set-keymap-parent map comint-mode-map)
    (define-key map "\t" 'comint-dynamic-complete)
    (define-key map "\M-?" 'comint-dynamic-list-filename-completions)
    (define-key map "\C-c\C-l" 'inferior-octave-dynamic-list-input-ring)
    (define-key map [menu-bar inout list-history]
      '("List Input History" . inferior-octave-dynamic-list-input-ring))
    (define-key map "\C-c\C-h" 'octave-help)
    map)
  "Keymap used in Inferior Octave mode.")

(defvar inferior-octave-mode-syntax-table
  (let ((table (make-syntax-table)))
    (modify-syntax-entry ?\` "w" table)
    (modify-syntax-entry ?\# "<" table)
    (modify-syntax-entry ?\n ">" table)
    table)
  "Syntax table in use in inferior-octave-mode buffers.")

(defcustom inferior-octave-mode-hook nil
  "*Hook to be run when Inferior Octave mode is started."
  :type 'hook
  :group 'octave-inferior)

(defvar inferior-octave-font-lock-keywords
  (list
   (cons inferior-octave-prompt 'font-lock-type-face))
  ;; Could certainly do more font locking in inferior Octave ...
  "Additional expressions to highlight in Inferior Octave mode.")


;;; Compatibility functions
(if (not (fboundp 'comint-line-beginning-position))
    ;; comint-line-beginning-position is defined in Emacs 21
    (defun comint-line-beginning-position ()
      "Returns the buffer position of the beginning of the line, after any prompt.
The prompt is assumed to be any text at the beginning of the line matching
the regular expression `comint-prompt-regexp', a buffer local variable."
      (save-excursion (comint-bol nil) (point))))


(defvar inferior-octave-output-list nil)
(defvar inferior-octave-output-string nil)
(defvar inferior-octave-receive-in-progress nil)

(defvar inferior-octave-startup-hook nil)

(defvar inferior-octave-complete-impossible nil
  "Non-nil means that `inferior-octave-complete' is impossible.")

(defvar inferior-octave-has-built-in-variables nil
  "Non-nil means that Octave has built-in variables.")

(defvar inferior-octave-dynamic-complete-functions
  '(inferior-octave-complete comint-dynamic-complete-filename)
  "List of functions called to perform completion for inferior Octave.
This variable is used to initialize `comint-dynamic-complete-functions'
in the Inferior Octave buffer.")

(defun inferior-octave-mode ()
  "Major mode for interacting with an inferior Octave process.
Runs Octave as a subprocess of Emacs, with Octave I/O through an Emacs
buffer.

Entry to this mode successively runs the hooks `comint-mode-hook' and
`inferior-octave-mode-hook'."
  (interactive)
  (delay-mode-hooks (comint-mode))
  (setq comint-prompt-regexp inferior-octave-prompt
	major-mode 'inferior-octave-mode
	mode-name "Inferior Octave"
	mode-line-process '(":%s")
	local-abbrev-table octave-abbrev-table)
  (use-local-map inferior-octave-mode-map)
  (set-syntax-table inferior-octave-mode-syntax-table)

  (make-local-variable 'comment-start)
  (setq comment-start octave-comment-start)
  (make-local-variable 'comment-end)
  (setq comment-end "")
  (make-local-variable 'comment-column)
  (setq comment-column 32)
  (make-local-variable 'comment-start-skip)
  (setq comment-start-skip octave-comment-start-skip)

  (make-local-variable 'font-lock-defaults)
  (setq font-lock-defaults '(inferior-octave-font-lock-keywords nil nil))

  (setq comint-input-ring-file-name
	(or (getenv "OCTAVE_HISTFILE") "~/.octave_hist")
	comint-input-ring-size (or (getenv "OCTAVE_HISTSIZE") 1024))
  (set (make-local-variable 'comint-dynamic-complete-functions)
       inferior-octave-dynamic-complete-functions)
  (add-hook 'comint-input-filter-functions
	'inferior-octave-directory-tracker nil t)
  (comint-read-input-ring t)

  (run-mode-hooks 'inferior-octave-mode-hook))

;;;###autoload
(defun inferior-octave (&optional arg)
  "Run an inferior Octave process, I/O via `inferior-octave-buffer'.
This buffer is put in Inferior Octave mode.  See `inferior-octave-mode'.

Unless ARG is non-nil, switches to this buffer.

The elements of the list `inferior-octave-startup-args' are sent as
command line arguments to the inferior Octave process on startup.

Additional commands to be executed on startup can be provided either in
the file specified by `inferior-octave-startup-file' or by the default
startup file, `~/.emacs-octave'."
  (interactive "P")
  (let ((buffer inferior-octave-buffer))
    (get-buffer-create buffer)
    (if (comint-check-proc buffer)
	()
      (with-current-buffer buffer
	(comint-mode)
	(inferior-octave-startup)
	(inferior-octave-mode)))
    (if (not arg)
	(pop-to-buffer buffer))))

;;;###autoload
(defalias 'run-octave 'inferior-octave)

(defun inferior-octave-startup ()
  "Start an inferior Octave process."
  (let ((proc (comint-exec-1
	       (substring inferior-octave-buffer 1 -1)
	       inferior-octave-buffer
	       inferior-octave-program
	       (append (list "-i" "--no-line-editing")
		       inferior-octave-startup-args))))
    (set-process-filter proc 'inferior-octave-output-digest)
    (setq comint-ptyp process-connection-type
	  inferior-octave-process proc
	  inferior-octave-output-list nil
	  inferior-octave-output-string nil
	  inferior-octave-receive-in-progress t)

    ;; This may look complicated ... However, we need to make sure that
    ;; we additional startup code only AFTER Octave is ready (otherwise,
    ;; output may be mixed up).  Hence, we need to digest the Octave
    ;; output to see when it issues a prompt.
    (while inferior-octave-receive-in-progress
      (accept-process-output inferior-octave-process))
    (goto-char (point-max))
    (set-marker (process-mark proc) (point))
    (insert-before-markers
     (concat
      (if (not (bobp)) "\f\n")
      (if inferior-octave-output-list
	  (concat (mapconcat
		   'identity inferior-octave-output-list "\n")
		  "\n"))))

     ;; Find out whether Octave has built-in variables.
     (inferior-octave-send-list-and-digest
      (list "exist \"LOADPATH\"\n"))
     (setq inferior-octave-has-built-in-variables
 	  (string-match "101$" (car inferior-octave-output-list)))

    ;; An empty secondary prompt, as e.g. obtained by '--braindead',
    ;; means trouble.
    (inferior-octave-send-list-and-digest (list "PS2\n"))
    (if (string-match "\\(PS2\\|ans\\) = *$" (car inferior-octave-output-list))
 	(inferior-octave-send-list-and-digest
 	 (list (if inferior-octave-has-built-in-variables
 		   "PS2 = \"> \"\n"
 		 "PS2 (\"> \");\n"))))

    ;; O.k., now we are ready for the Inferior Octave startup commands.
    (let* (commands
	   (program (file-name-nondirectory inferior-octave-program))
	   (file (or inferior-octave-startup-file
			  (concat "~/.emacs-" program))))
      (setq commands
	    (list "more off;\n"
		  (if (not (string-equal
			    inferior-octave-output-string ">> "))
		      (if inferior-octave-has-built-in-variables
			  "PS1=\"\\\\s> \";\n"
			"PS1 (\"\\\\s> \");\n"))
		  (if (file-exists-p file)
		      (format "source (\"%s\");\n" file))))
      (inferior-octave-send-list-and-digest commands))
    (insert-before-markers
     (concat
      (if inferior-octave-output-list
	  (concat (mapconcat
		   'identity inferior-octave-output-list "\n")
		  "\n"))
      inferior-octave-output-string))
    ;; Next, we check whether Octave supports `completion_matches' ...
    (inferior-octave-send-list-and-digest
     (list "exist \"completion_matches\"\n"))
    (setq inferior-octave-complete-impossible
	  (not (string-match "5$" (car inferior-octave-output-list))))

    ;; And finally, everything is back to normal.
    (set-process-filter proc 'inferior-octave-output-filter)
    (run-hooks 'inferior-octave-startup-hook)
    (run-hooks 'inferior-octave-startup-hook)
    ;; Just in case, to be sure a cd in the startup file
    ;; won't have detrimental effects.
    (inferior-octave-resync-dirs)))

\f
(defun inferior-octave-complete ()
  "Perform completion on the Octave symbol preceding point.
This is implemented using the Octave command `completion_matches' which
is NOT available with versions of Octave prior to 2.0."
  (interactive)
  (let* ((end (point))
	 (command
	  (save-excursion
	    (skip-syntax-backward "w_" (comint-line-beginning-position))
	    (buffer-substring-no-properties (point) end)))
	 (proc (get-buffer-process inferior-octave-buffer)))
    (cond (inferior-octave-complete-impossible
	   (error (concat
		   "Your Octave does not have `completion_matches'.  "
		   "Please upgrade to version 2.X.")))
	  ((string-equal command "")
	   (message "Cannot complete an empty string"))
	  (t
	   (inferior-octave-send-list-and-digest
	    (list (concat "completion_matches (\"" command "\");\n")))
	   ;; Sort the list
	   (setq inferior-octave-output-list
		 (sort inferior-octave-output-list 'string-lessp))
	   ;; Remove duplicates
	   (let* ((x inferior-octave-output-list)
		  (y (cdr x)))
	     (while y
	       (if (string-equal (car x) (car y))
		   (setcdr x (setq y (cdr y)))
		 (setq x y
		       y (cdr y)))))
	   ;; And let comint handle the rest
	   (comint-dynamic-simple-complete
	    command inferior-octave-output-list)))))

(defun inferior-octave-dynamic-list-input-ring ()
  "List the buffer's input history in a help buffer."
  ;; We cannot use `comint-dynamic-list-input-ring', because it replaces
  ;; "completion" by "history reference" ...
  (interactive)
  (if (or (not (ring-p comint-input-ring))
          (ring-empty-p comint-input-ring))
      (message "No history")
    (let ((history nil)
          (history-buffer " *Input History*")
          (index (1- (ring-length comint-input-ring)))
          (conf (current-window-configuration)))
      ;; We have to build up a list ourselves from the ring vector.
      (while (>= index 0)
        (setq history (cons (ring-ref comint-input-ring index) history)
              index (1- index)))
      ;; Change "completion" to "history reference"
      ;; to make the display accurate.
      (with-output-to-temp-buffer history-buffer
        (display-completion-list history)
        (set-buffer history-buffer))
      (message "Hit space to flush")
      (let ((ch (read-event)))
        (if (eq ch ?\ )
            (set-window-configuration conf)
          (setq unread-command-events (list ch)))))))

(defun inferior-octave-strip-ctrl-g (string)
  "Strip leading `^G' character.
If STRING starts with a `^G', ring the bell and strip it."
  (if (string-match "^\a" string)
      (progn
        (ding)
        (setq string (substring string 1))))
  string)

(defun inferior-octave-output-filter (proc string)
  "Standard output filter for the inferior Octave process.
Ring Emacs bell if process output starts with an ASCII bell, and pass
the rest to `comint-output-filter'."
  (comint-output-filter proc (inferior-octave-strip-ctrl-g string)))

(defun inferior-octave-output-digest (proc string)
  "Special output filter for the inferior Octave process.
Save all output between newlines into `inferior-octave-output-list', and
the rest to `inferior-octave-output-string'."
  (setq string (concat inferior-octave-output-string string))
  (while (string-match "\n" string)
    (setq inferior-octave-output-list
	  (append inferior-octave-output-list
		  (list (substring string 0 (match-beginning 0))))
	  string (substring string (match-end 0))))
  (if (string-match inferior-octave-prompt string)
      (setq inferior-octave-receive-in-progress nil))
  (setq inferior-octave-output-string string))

(defun inferior-octave-send-list-and-digest (list)
  "Send LIST to the inferior Octave process and digest the output.
The elements of LIST have to be strings and are sent one by one.  All
output is passed to the filter `inferior-octave-output-digest'."
  (let* ((proc inferior-octave-process)
	 (filter (process-filter proc))
	 string)
    (set-process-filter proc 'inferior-octave-output-digest)
    (setq inferior-octave-output-list nil)
    (unwind-protect
	(while (setq string (car list))
	  (setq inferior-octave-output-string nil
		inferior-octave-receive-in-progress t)
	  (comint-send-string proc string)
	  (while inferior-octave-receive-in-progress
	    (accept-process-output proc))
	  (setq list (cdr list)))
      (set-process-filter proc filter))))

(defun inferior-octave-directory-tracker (string)
  "Tracks `cd' commands issued to the inferior Octave process.
Use \\[inferior-octave-resync-dirs] to resync if Emacs gets confused."
  (cond
   ((string-match "^[ \t]*cd[ \t;]*$" string)
    (cd "~"))
   ((string-match "^[ \t]*cd[ \t]+\\([^ \t\n;]*\\)[ \t\n;]*" string)
    (cd (substring string (match-beginning 1) (match-end 1))))))

(defun inferior-octave-resync-dirs ()
  "Resync the buffer's idea of the current directory.
This command queries the inferior Octave process about its current
directory and makes this the current buffer's default directory."
  (interactive)
  (inferior-octave-send-list-and-digest '("disp (pwd ())\n"))
  (cd (car inferior-octave-output-list)))

;;; provide ourself

(provide 'octave-inf)

;; arch-tag: bdce0395-24d1-4bb4-bfba-6fb1eeb1a660
;;; octave-inf.el ends here
Commit	Line	Data
092af6d8	1	;;; octave-inf.el --- running Octave as an inferior Emacs process
081bf30e	2
114f9c96	3	;; Copyright (C) 1997, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
034babe1	4	;; Free Software Foundation, Inc.
081bf30e	5
d0943d40	6	;; Author: Kurt Hornik <Kurt.Hornik@wu-wien.ac.at>
081bf30e	7	;; Author: John Eaton <jwe@bevo.che.wisc.edu>
d0943d40	8	;; Maintainer: Kurt Hornik <Kurt.Hornik@wu-wien.ac.at>
081bf30e	9	;; Keywords: languages
aad4679e	10	;; Package: octave-mod
081bf30e RS	11
	12	;; This file is part of GNU Emacs.
	13
b1fc2b50	14	;; GNU Emacs is free software: you can redistribute it and/or modify
081bf30e	15	;; it under the terms of the GNU General Public License as published by
b1fc2b50 GM	16	;; the Free Software Foundation, either version 3 of the License, or
b1fc2b50 GM	17	;; (at your option) any later version.
081bf30e RS	18
	19	;; GNU Emacs is distributed in the hope that it will be useful,
	20	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	;; GNU General Public License for more details.
	23
	24	;; You should have received a copy of the GNU General Public License
b1fc2b50	25	;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
081bf30e	26
e8af40ee PJ	27	;;; Commentary:
e8af40ee PJ	28
081bf30e RS	29	;;; Code:
081bf30e RS	30
f7bbab75	31	(require 'octave-mod)
081bf30e RS	32	(require 'comint)
081bf30e RS	33
28d16ed3 AS	34	(defgroup octave-inferior nil
	35	"Running Octave as an inferior Emacs process."
	36	:group 'octave)
081bf30e	37
28d16ed3	38	(defcustom inferior-octave-program "octave"
e2536e57	39	"Program invoked by `inferior-octave'."
28d16ed3 AS	40	:type 'string
	41	:group 'octave-inferior)
	42
	43	(defcustom inferior-octave-prompt
6145f7fd	44	"\\(^octave\\(\\\|.bin\\\|.exe\\)\\(-[.0-9]+\\)?\\(:[0-9]+\\)?\\\|^debug\\\|^\\)>+ "
e2536e57	45	"Regexp to match prompts for the inferior Octave process."
28d16ed3 AS	46	:type 'regexp
28d16ed3 AS	47	:group 'octave-inferior)
081bf30e	48
28d16ed3	49	(defcustom inferior-octave-startup-file nil
e2536e57	50	"Name of the inferior Octave startup file.
081bf30e	51	The contents of this file are sent to the inferior Octave process on
28d16ed3 AS	52	startup."
	53	:type '(choice (const :tag "None" nil)
	54	file)
	55	:group 'octave-inferior)
081bf30e	56
3a5a5d36	57	(defcustom inferior-octave-startup-args nil
e2536e57	58	"List of command line arguments for the inferior Octave process.
081bf30e	59	For example, for suppressing the startup message and using `traditional'
28d16ed3 AS	60	mode, set this to (\"-q\" \"--traditional\")."
	61	:type '(repeat string)
	62	:group 'octave-inferior)
081bf30e	63
e2536e57 SM	64	(defvar inferior-octave-mode-map
	65	(let ((map (make-sparse-keymap)))
	66	(set-keymap-parent map comint-mode-map)
081bf30e RS	67	(define-key map "\t" 'comint-dynamic-complete)
	68	(define-key map "\M-?" 'comint-dynamic-list-filename-completions)
	69	(define-key map "\C-c\C-l" 'inferior-octave-dynamic-list-input-ring)
	70	(define-key map [menu-bar inout list-history]
	71	'("List Input History" . inferior-octave-dynamic-list-input-ring))
	72	(define-key map "\C-c\C-h" 'octave-help)
e2536e57 SM	73	map)
e2536e57 SM	74	"Keymap used in Inferior Octave mode.")
081bf30e	75
e2536e57	76	(defvar inferior-octave-mode-syntax-table
081bf30e RS	77	(let ((table (make-syntax-table)))
	78	(modify-syntax-entry ?\` "w" table)
	79	(modify-syntax-entry ?\# "<" table)
	80	(modify-syntax-entry ?\n ">" table)
e2536e57 SM	81	table)
e2536e57 SM	82	"Syntax table in use in inferior-octave-mode buffers.")
081bf30e	83
28d16ed3 AS	84	(defcustom inferior-octave-mode-hook nil
	85	"*Hook to be run when Inferior Octave mode is started."
	86	:type 'hook
	87	:group 'octave-inferior)
081bf30e RS	88
	89	(defvar inferior-octave-font-lock-keywords
	90	(list
	91	(cons inferior-octave-prompt 'font-lock-type-face))
	92	;; Could certainly do more font locking in inferior Octave ...
	93	"Additional expressions to highlight in Inferior Octave mode.")
	94
9d245da5 MB	95
	96	;;; Compatibility functions
	97	(if (not (fboundp 'comint-line-beginning-position))
	98	;; comint-line-beginning-position is defined in Emacs 21
	99	(defun comint-line-beginning-position ()
	100	"Returns the buffer position of the beginning of the line, after any prompt.
	101	The prompt is assumed to be any text at the beginning of the line matching
	102	the regular expression `comint-prompt-regexp', a buffer local variable."
	103	(save-excursion (comint-bol nil) (point))))
	104
	105
081bf30e RS	106	(defvar inferior-octave-output-list nil)
	107	(defvar inferior-octave-output-string nil)
	108	(defvar inferior-octave-receive-in-progress nil)
	109
	110	(defvar inferior-octave-startup-hook nil)
	111
	112	(defvar inferior-octave-complete-impossible nil
	113	"Non-nil means that `inferior-octave-complete' is impossible.")
	114
d32f600d CY	115	(defvar inferior-octave-has-built-in-variables nil
	116	"Non-nil means that Octave has built-in variables.")
	117
081bf30e	118	(defvar inferior-octave-dynamic-complete-functions
a1506d29	119	'(inferior-octave-complete comint-dynamic-complete-filename)
081bf30e RS	120	"List of functions called to perform completion for inferior Octave.
	121	This variable is used to initialize `comint-dynamic-complete-functions'
	122	in the Inferior Octave buffer.")
	123
	124	(defun inferior-octave-mode ()
	125	"Major mode for interacting with an inferior Octave process.
	126	Runs Octave as a subprocess of Emacs, with Octave I/O through an Emacs
	127	buffer.
	128
	129	Entry to this mode successively runs the hooks `comint-mode-hook' and
	130	`inferior-octave-mode-hook'."
	131	(interactive)
cb1b44b0	132	(delay-mode-hooks (comint-mode))
081bf30e RS	133	(setq comint-prompt-regexp inferior-octave-prompt
	134	major-mode 'inferior-octave-mode
	135	mode-name "Inferior Octave"
	136	mode-line-process '(":%s")
	137	local-abbrev-table octave-abbrev-table)
	138	(use-local-map inferior-octave-mode-map)
	139	(set-syntax-table inferior-octave-mode-syntax-table)
	140
a1506d29	141	(make-local-variable 'comment-start)
081bf30e RS	142	(setq comment-start octave-comment-start)
	143	(make-local-variable 'comment-end)
	144	(setq comment-end "")
	145	(make-local-variable 'comment-column)
a1506d29	146	(setq comment-column 32)
081bf30e RS	147	(make-local-variable 'comment-start-skip)
	148	(setq comment-start-skip octave-comment-start-skip)
	149
	150	(make-local-variable 'font-lock-defaults)
	151	(setq font-lock-defaults '(inferior-octave-font-lock-keywords nil nil))
	152
	153	(setq comint-input-ring-file-name
	154	(or (getenv "OCTAVE_HISTFILE") "~/.octave_hist")
e9886e88	155	comint-input-ring-size (or (getenv "OCTAVE_HISTSIZE") 1024))
e2536e57 SM	156	(set (make-local-variable 'comint-dynamic-complete-functions)
e2536e57 SM	157	inferior-octave-dynamic-complete-functions)
e9886e88 FP	158	(add-hook 'comint-input-filter-functions
e9886e88 FP	159	'inferior-octave-directory-tracker nil t)
081bf30e RS	160	(comint-read-input-ring t)
081bf30e RS	161
9a969196	162	(run-mode-hooks 'inferior-octave-mode-hook))
081bf30e RS	163
	164	;;;###autoload
	165	(defun inferior-octave (&optional arg)
	166	"Run an inferior Octave process, I/O via `inferior-octave-buffer'.
	167	This buffer is put in Inferior Octave mode. See `inferior-octave-mode'.
	168
	169	Unless ARG is non-nil, switches to this buffer.
	170
	171	The elements of the list `inferior-octave-startup-args' are sent as
	172	command line arguments to the inferior Octave process on startup.
	173
	174	Additional commands to be executed on startup can be provided either in
	175	the file specified by `inferior-octave-startup-file' or by the default
	176	startup file, `~/.emacs-octave'."
	177	(interactive "P")
	178	(let ((buffer inferior-octave-buffer))
	179	(get-buffer-create buffer)
	180	(if (comint-check-proc buffer)
	181	()
9a529312	182	(with-current-buffer buffer
081bf30e RS	183	(comint-mode)
	184	(inferior-octave-startup)
	185	(inferior-octave-mode)))
	186	(if (not arg)
	187	(pop-to-buffer buffer))))
	188
	189	;;;###autoload
	190	(defalias 'run-octave 'inferior-octave)
	191
	192	(defun inferior-octave-startup ()
	193	"Start an inferior Octave process."
	194	(let ((proc (comint-exec-1
	195	(substring inferior-octave-buffer 1 -1)
	196	inferior-octave-buffer
	197	inferior-octave-program
3a5a5d36 SE	198	(append (list "-i" "--no-line-editing")
3a5a5d36 SE	199	inferior-octave-startup-args))))
081bf30e RS	200	(set-process-filter proc 'inferior-octave-output-digest)
	201	(setq comint-ptyp process-connection-type
	202	inferior-octave-process proc
	203	inferior-octave-output-list nil
	204	inferior-octave-output-string nil
	205	inferior-octave-receive-in-progress t)
	206
	207	;; This may look complicated ... However, we need to make sure that
	208	;; we additional startup code only AFTER Octave is ready (otherwise,
	209	;; output may be mixed up). Hence, we need to digest the Octave
	210	;; output to see when it issues a prompt.
	211	(while inferior-octave-receive-in-progress
	212	(accept-process-output inferior-octave-process))
	213	(goto-char (point-max))
	214	(set-marker (process-mark proc) (point))
	215	(insert-before-markers
	216	(concat
	217	(if (not (bobp)) "\f\n")
	218	(if inferior-octave-output-list
	219	(concat (mapconcat
	220	'identity inferior-octave-output-list "\n")
	221	"\n"))))
107dd21b	222
d32f600d CY	223	;; Find out whether Octave has built-in variables.
	224	(inferior-octave-send-list-and-digest
	225	(list "exist \"LOADPATH\"\n"))
	226	(setq inferior-octave-has-built-in-variables
	227	(string-match "101$" (car inferior-octave-output-list)))
	228
107dd21b EZ	229	;; An empty secondary prompt, as e.g. obtained by '--braindead',
	230	;; means trouble.
	231	(inferior-octave-send-list-and-digest (list "PS2\n"))
d32f600d CY	232	(if (string-match "\\(PS2\\\|ans\\) = *$" (car inferior-octave-output-list))
	233	(inferior-octave-send-list-and-digest
	234	(list (if inferior-octave-has-built-in-variables
	235	"PS2 = \"> \"\n"
	236	"PS2 (\"> \");\n"))))
107dd21b	237
081bf30e RS	238	;; O.k., now we are ready for the Inferior Octave startup commands.
	239	(let* (commands
	240	(program (file-name-nondirectory inferior-octave-program))
	241	(file (or inferior-octave-startup-file
	242	(concat "~/.emacs-" program))))
	243	(setq commands
d32f600d	244	(list "more off;\n"
081bf30e	245	(if (not (string-equal
a1506d29	246	inferior-octave-output-string ">> "))
d32f600d CY	247	(if inferior-octave-has-built-in-variables
	248	"PS1=\"\\\\s> \";\n"
	249	"PS1 (\"\\\\s> \");\n"))
081bf30e RS	250	(if (file-exists-p file)
	251	(format "source (\"%s\");\n" file))))
	252	(inferior-octave-send-list-and-digest commands))
	253	(insert-before-markers
	254	(concat
	255	(if inferior-octave-output-list
	256	(concat (mapconcat
	257	'identity inferior-octave-output-list "\n")
	258	"\n"))
	259	inferior-octave-output-string))
	260	;; Next, we check whether Octave supports `completion_matches' ...
	261	(inferior-octave-send-list-and-digest
	262	(list "exist \"completion_matches\"\n"))
	263	(setq inferior-octave-complete-impossible
	264	(not (string-match "5$" (car inferior-octave-output-list))))
	265
	266	;; And finally, everything is back to normal.
	267	(set-process-filter proc 'inferior-octave-output-filter)
4ca7c468 EZ	268	(run-hooks 'inferior-octave-startup-hook)
	269	(run-hooks 'inferior-octave-startup-hook)
	270	;; Just in case, to be sure a cd in the startup file
	271	;; won't have detrimental effects.
	272	(inferior-octave-resync-dirs)))
081bf30e RS	273
	274	\f
	275	(defun inferior-octave-complete ()
	276	"Perform completion on the Octave symbol preceding point.
	277	This is implemented using the Octave command `completion_matches' which
	278	is NOT available with versions of Octave prior to 2.0."
	279	(interactive)
	280	(let* ((end (point))
502166d2 MB	281	(command
	282	(save-excursion
	283	(skip-syntax-backward "w_" (comint-line-beginning-position))
	284	(buffer-substring-no-properties (point) end)))
e2536e57	285	(proc (get-buffer-process inferior-octave-buffer)))
081bf30e RS	286	(cond (inferior-octave-complete-impossible
	287	(error (concat
	288	"Your Octave does not have `completion_matches'. "
	289	"Please upgrade to version 2.X.")))
	290	((string-equal command "")
	291	(message "Cannot complete an empty string"))
	292	(t
	293	(inferior-octave-send-list-and-digest
	294	(list (concat "completion_matches (\"" command "\");\n")))
	295	;; Sort the list
	296	(setq inferior-octave-output-list
	297	(sort inferior-octave-output-list 'string-lessp))
	298	;; Remove duplicates
	299	(let* ((x inferior-octave-output-list)
	300	(y (cdr x)))
	301	(while y
	302	(if (string-equal (car x) (car y))
	303	(setcdr x (setq y (cdr y)))
	304	(setq x y
	305	y (cdr y)))))
	306	;; And let comint handle the rest
	307	(comint-dynamic-simple-complete
	308	command inferior-octave-output-list)))))
	309
	310	(defun inferior-octave-dynamic-list-input-ring ()
e2536e57	311	"List the buffer's input history in a help buffer."
081bf30e RS	312	;; We cannot use `comint-dynamic-list-input-ring', because it replaces
	313	;; "completion" by "history reference" ...
	314	(interactive)
	315	(if (or (not (ring-p comint-input-ring))
	316	(ring-empty-p comint-input-ring))
	317	(message "No history")
	318	(let ((history nil)
	319	(history-buffer " Input History")
	320	(index (1- (ring-length comint-input-ring)))
	321	(conf (current-window-configuration)))
	322	;; We have to build up a list ourselves from the ring vector.
	323	(while (>= index 0)
	324	(setq history (cons (ring-ref comint-input-ring index) history)
	325	index (1- index)))
	326	;; Change "completion" to "history reference"
	327	;; to make the display accurate.
	328	(with-output-to-temp-buffer history-buffer
	329	(display-completion-list history)
	330	(set-buffer history-buffer))
	331	(message "Hit space to flush")
	332	(let ((ch (read-event)))
	333	(if (eq ch ?\ )
	334	(set-window-configuration conf)
	335	(setq unread-command-events (list ch)))))))
	336
	337	(defun inferior-octave-strip-ctrl-g (string)
	338	"Strip leading `^G' character.
	339	If STRING starts with a `^G', ring the bell and strip it."
	340	(if (string-match "^\a" string)
	341	(progn
	342	(ding)
	343	(setq string (substring string 1))))
	344	string)
	345
	346	(defun inferior-octave-output-filter (proc string)
	347	"Standard output filter for the inferior Octave process.
	348	Ring Emacs bell if process output starts with an ASCII bell, and pass
	349	the rest to `comint-output-filter'."
	350	(comint-output-filter proc (inferior-octave-strip-ctrl-g string)))
	351
	352	(defun inferior-octave-output-digest (proc string)
	353	"Special output filter for the inferior Octave process.
	354	Save all output between newlines into `inferior-octave-output-list', and
	355	the rest to `inferior-octave-output-string'."
	356	(setq string (concat inferior-octave-output-string string))
	357	(while (string-match "\n" string)
	358	(setq inferior-octave-output-list
	359	(append inferior-octave-output-list
	360	(list (substring string 0 (match-beginning 0))))
	361	string (substring string (match-end 0))))
	362	(if (string-match inferior-octave-prompt string)
	363	(setq inferior-octave-receive-in-progress nil))
	364	(setq inferior-octave-output-string string))
	365
	366	(defun inferior-octave-send-list-and-digest (list)
	367	"Send LIST to the inferior Octave process and digest the output.
	368	The elements of LIST have to be strings and are sent one by one. All
	369	output is passed to the filter `inferior-octave-output-digest'."
	370	(let* ((proc inferior-octave-process)
	371	(filter (process-filter proc))
	372	string)
	373	(set-process-filter proc 'inferior-octave-output-digest)
	374	(setq inferior-octave-output-list nil)
	375	(unwind-protect
376	(while (setq string (car list))
377	(setq inferior-octave-output-string nil
378	inferior-octave-receive-in-progress t)
379	(comint-send-string proc string)
380	(while inferior-octave-receive-in-progress
381	(accept-process-output proc))
382	(setq list (cdr list)))
383	(set-process-filter proc filter))))
384
385	(defun inferior-octave-directory-tracker (string)
386	"Tracks `cd' commands issued to the inferior Octave process.
387	Use \\[inferior-octave-resync-dirs] to resync if Emacs gets confused."
df287ddb SE	388	(cond
	389	((string-match "^[ \t]cd[ \t;]$" string)
	390	(cd "~"))
	391	((string-match "^[ \t]cd[ \t]+\\([^ \t\n;]\\)[ \t\n;]*" string)
	392	(cd (substring string (match-beginning 1) (match-end 1))))))
081bf30e RS	393
	394	(defun inferior-octave-resync-dirs ()
	395	"Resync the buffer's idea of the current directory.
	396	This command queries the inferior Octave process about its current
	397	directory and makes this the current buffer's default directory."
	398	(interactive)
d32f600d	399	(inferior-octave-send-list-and-digest '("disp (pwd ())\n"))
081bf30e RS	400	(cd (car inferior-octave-output-list)))
081bf30e RS	401
15c2d736 KH	402	;;; provide ourself
	403
	404	(provide 'octave-inf)
	405
e2536e57	406	;; arch-tag: bdce0395-24d1-4bb4-bfba-6fb1eeb1a660
e96a83c8	407	;;; octave-inf.el ends here