[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, 2011
;; 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.")

(define-derived-mode inferior-octave-mode comint-mode "Inferior Octave"
  "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'."
  (setq comint-prompt-regexp inferior-octave-prompt
	mode-line-process '(":%s")
	local-abbrev-table octave-abbrev-table)

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

  (set (make-local-variable '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))

;;;###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
5df4f04c	3	;; Copyright (C) 1997, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
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
175069ef	124	(define-derived-mode inferior-octave-mode comint-mode "Inferior Octave"
081bf30e RS	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'."
081bf30e	131	(setq comint-prompt-regexp inferior-octave-prompt
081bf30e RS	132	mode-line-process '(":%s")
081bf30e RS	133	local-abbrev-table octave-abbrev-table)
081bf30e	134
175069ef SM	135	(set (make-local-variable 'comment-start) octave-comment-start)
	136	(set (make-local-variable 'comment-end) "")
	137	(set (make-local-variable 'comment-column) 32)
	138	(set (make-local-variable 'comment-start-skip) octave-comment-start-skip)
081bf30e	139
175069ef SM	140	(set (make-local-variable 'font-lock-defaults)
175069ef SM	141	'(inferior-octave-font-lock-keywords nil nil))
081bf30e RS	142
	143	(setq comint-input-ring-file-name
	144	(or (getenv "OCTAVE_HISTFILE") "~/.octave_hist")
e9886e88	145	comint-input-ring-size (or (getenv "OCTAVE_HISTSIZE") 1024))
e2536e57 SM	146	(set (make-local-variable 'comint-dynamic-complete-functions)
e2536e57 SM	147	inferior-octave-dynamic-complete-functions)
e9886e88 FP	148	(add-hook 'comint-input-filter-functions
e9886e88 FP	149	'inferior-octave-directory-tracker nil t)
175069ef	150	(comint-read-input-ring t))
081bf30e RS	151
	152	;;;###autoload
	153	(defun inferior-octave (&optional arg)
	154	"Run an inferior Octave process, I/O via `inferior-octave-buffer'.
	155	This buffer is put in Inferior Octave mode. See `inferior-octave-mode'.
	156
	157	Unless ARG is non-nil, switches to this buffer.
	158
	159	The elements of the list `inferior-octave-startup-args' are sent as
	160	command line arguments to the inferior Octave process on startup.
	161
	162	Additional commands to be executed on startup can be provided either in
	163	the file specified by `inferior-octave-startup-file' or by the default
	164	startup file, `~/.emacs-octave'."
	165	(interactive "P")
	166	(let ((buffer inferior-octave-buffer))
	167	(get-buffer-create buffer)
	168	(if (comint-check-proc buffer)
	169	()
9a529312	170	(with-current-buffer buffer
081bf30e RS	171	(comint-mode)
	172	(inferior-octave-startup)
	173	(inferior-octave-mode)))
	174	(if (not arg)
	175	(pop-to-buffer buffer))))
	176
	177	;;;###autoload
	178	(defalias 'run-octave 'inferior-octave)
	179
	180	(defun inferior-octave-startup ()
	181	"Start an inferior Octave process."
	182	(let ((proc (comint-exec-1
	183	(substring inferior-octave-buffer 1 -1)
	184	inferior-octave-buffer
	185	inferior-octave-program
3a5a5d36 SE	186	(append (list "-i" "--no-line-editing")
3a5a5d36 SE	187	inferior-octave-startup-args))))
081bf30e RS	188	(set-process-filter proc 'inferior-octave-output-digest)
	189	(setq comint-ptyp process-connection-type
	190	inferior-octave-process proc
	191	inferior-octave-output-list nil
	192	inferior-octave-output-string nil
	193	inferior-octave-receive-in-progress t)
	194
	195	;; This may look complicated ... However, we need to make sure that
	196	;; we additional startup code only AFTER Octave is ready (otherwise,
	197	;; output may be mixed up). Hence, we need to digest the Octave
	198	;; output to see when it issues a prompt.
	199	(while inferior-octave-receive-in-progress
	200	(accept-process-output inferior-octave-process))
	201	(goto-char (point-max))
	202	(set-marker (process-mark proc) (point))
	203	(insert-before-markers
	204	(concat
	205	(if (not (bobp)) "\f\n")
	206	(if inferior-octave-output-list
	207	(concat (mapconcat
	208	'identity inferior-octave-output-list "\n")
	209	"\n"))))
107dd21b	210
d32f600d CY	211	;; Find out whether Octave has built-in variables.
	212	(inferior-octave-send-list-and-digest
	213	(list "exist \"LOADPATH\"\n"))
	214	(setq inferior-octave-has-built-in-variables
	215	(string-match "101$" (car inferior-octave-output-list)))
	216
107dd21b EZ	217	;; An empty secondary prompt, as e.g. obtained by '--braindead',
	218	;; means trouble.
	219	(inferior-octave-send-list-and-digest (list "PS2\n"))
d32f600d CY	220	(if (string-match "\\(PS2\\\|ans\\) = *$" (car inferior-octave-output-list))
	221	(inferior-octave-send-list-and-digest
	222	(list (if inferior-octave-has-built-in-variables
	223	"PS2 = \"> \"\n"
	224	"PS2 (\"> \");\n"))))
107dd21b	225
081bf30e RS	226	;; O.k., now we are ready for the Inferior Octave startup commands.
	227	(let* (commands
	228	(program (file-name-nondirectory inferior-octave-program))
	229	(file (or inferior-octave-startup-file
	230	(concat "~/.emacs-" program))))
	231	(setq commands
d32f600d	232	(list "more off;\n"
081bf30e	233	(if (not (string-equal
a1506d29	234	inferior-octave-output-string ">> "))
d32f600d CY	235	(if inferior-octave-has-built-in-variables
	236	"PS1=\"\\\\s> \";\n"
	237	"PS1 (\"\\\\s> \");\n"))
081bf30e RS	238	(if (file-exists-p file)
	239	(format "source (\"%s\");\n" file))))
	240	(inferior-octave-send-list-and-digest commands))
	241	(insert-before-markers
	242	(concat
	243	(if inferior-octave-output-list
	244	(concat (mapconcat
	245	'identity inferior-octave-output-list "\n")
	246	"\n"))
	247	inferior-octave-output-string))
	248	;; Next, we check whether Octave supports `completion_matches' ...
	249	(inferior-octave-send-list-and-digest
	250	(list "exist \"completion_matches\"\n"))
	251	(setq inferior-octave-complete-impossible
	252	(not (string-match "5$" (car inferior-octave-output-list))))
	253
	254	;; And finally, everything is back to normal.
	255	(set-process-filter proc 'inferior-octave-output-filter)
4ca7c468 EZ	256	(run-hooks 'inferior-octave-startup-hook)
	257	(run-hooks 'inferior-octave-startup-hook)
	258	;; Just in case, to be sure a cd in the startup file
	259	;; won't have detrimental effects.
	260	(inferior-octave-resync-dirs)))
081bf30e RS	261
	262	\f
	263	(defun inferior-octave-complete ()
	264	"Perform completion on the Octave symbol preceding point.
	265	This is implemented using the Octave command `completion_matches' which
	266	is NOT available with versions of Octave prior to 2.0."
	267	(interactive)
	268	(let* ((end (point))
502166d2 MB	269	(command
	270	(save-excursion
	271	(skip-syntax-backward "w_" (comint-line-beginning-position))
	272	(buffer-substring-no-properties (point) end)))
e2536e57	273	(proc (get-buffer-process inferior-octave-buffer)))
081bf30e RS	274	(cond (inferior-octave-complete-impossible
	275	(error (concat
	276	"Your Octave does not have `completion_matches'. "
	277	"Please upgrade to version 2.X.")))
	278	((string-equal command "")
	279	(message "Cannot complete an empty string"))
	280	(t
	281	(inferior-octave-send-list-and-digest
	282	(list (concat "completion_matches (\"" command "\");\n")))
	283	;; Sort the list
	284	(setq inferior-octave-output-list
	285	(sort inferior-octave-output-list 'string-lessp))
	286	;; Remove duplicates
	287	(let* ((x inferior-octave-output-list)
	288	(y (cdr x)))
	289	(while y
	290	(if (string-equal (car x) (car y))
	291	(setcdr x (setq y (cdr y)))
	292	(setq x y
	293	y (cdr y)))))
	294	;; And let comint handle the rest
	295	(comint-dynamic-simple-complete
	296	command inferior-octave-output-list)))))
	297
	298	(defun inferior-octave-dynamic-list-input-ring ()
e2536e57	299	"List the buffer's input history in a help buffer."
081bf30e RS	300	;; We cannot use `comint-dynamic-list-input-ring', because it replaces
	301	;; "completion" by "history reference" ...
	302	(interactive)
	303	(if (or (not (ring-p comint-input-ring))
	304	(ring-empty-p comint-input-ring))
	305	(message "No history")
	306	(let ((history nil)
	307	(history-buffer " Input History")
	308	(index (1- (ring-length comint-input-ring)))
	309	(conf (current-window-configuration)))
	310	;; We have to build up a list ourselves from the ring vector.
	311	(while (>= index 0)
	312	(setq history (cons (ring-ref comint-input-ring index) history)
	313	index (1- index)))
	314	;; Change "completion" to "history reference"
	315	;; to make the display accurate.
	316	(with-output-to-temp-buffer history-buffer
	317	(display-completion-list history)
	318	(set-buffer history-buffer))
	319	(message "Hit space to flush")
	320	(let ((ch (read-event)))
	321	(if (eq ch ?\ )
	322	(set-window-configuration conf)
	323	(setq unread-command-events (list ch)))))))
	324
	325	(defun inferior-octave-strip-ctrl-g (string)
	326	"Strip leading `^G' character.
	327	If STRING starts with a `^G', ring the bell and strip it."
	328	(if (string-match "^\a" string)
	329	(progn
	330	(ding)
	331	(setq string (substring string 1))))
	332	string)
	333
	334	(defun inferior-octave-output-filter (proc string)
	335	"Standard output filter for the inferior Octave process.
	336	Ring Emacs bell if process output starts with an ASCII bell, and pass
	337	the rest to `comint-output-filter'."
	338	(comint-output-filter proc (inferior-octave-strip-ctrl-g string)))
	339
	340	(defun inferior-octave-output-digest (proc string)
	341	"Special output filter for the inferior Octave process.
	342	Save all output between newlines into `inferior-octave-output-list', and
	343	the rest to `inferior-octave-output-string'."
	344	(setq string (concat inferior-octave-output-string string))
	345	(while (string-match "\n" string)
	346	(setq inferior-octave-output-list
	347	(append inferior-octave-output-list
	348	(list (substring string 0 (match-beginning 0))))
	349	string (substring string (match-end 0))))
	350	(if (string-match inferior-octave-prompt string)
	351	(setq inferior-octave-receive-in-progress nil))
	352	(setq inferior-octave-output-string string))
	353
	354	(defun inferior-octave-send-list-and-digest (list)
	355	"Send LIST to the inferior Octave process and digest the output.
	356	The elements of LIST have to be strings and are sent one by one. All
	357	output is passed to the filter `inferior-octave-output-digest'."
	358	(let* ((proc inferior-octave-process)
	359	(filter (process-filter proc))
	360	string)
	361	(set-process-filter proc 'inferior-octave-output-digest)
	362	(setq inferior-octave-output-list nil)
	363	(unwind-protect
364	(while (setq string (car list))
365	(setq inferior-octave-output-string nil
366	inferior-octave-receive-in-progress t)
367	(comint-send-string proc string)
368	(while inferior-octave-receive-in-progress
369	(accept-process-output proc))
370	(setq list (cdr list)))
371	(set-process-filter proc filter))))
372
373	(defun inferior-octave-directory-tracker (string)
374	"Tracks `cd' commands issued to the inferior Octave process.
375	Use \\[inferior-octave-resync-dirs] to resync if Emacs gets confused."
df287ddb SE	376	(cond
	377	((string-match "^[ \t]cd[ \t;]$" string)
	378	(cd "~"))
	379	((string-match "^[ \t]cd[ \t]+\\([^ \t\n;]\\)[ \t\n;]*" string)
	380	(cd (substring string (match-beginning 1) (match-end 1))))))
081bf30e RS	381
	382	(defun inferior-octave-resync-dirs ()
	383	"Resync the buffer's idea of the current directory.
	384	This command queries the inferior Octave process about its current
	385	directory and makes this the current buffer's default directory."
	386	(interactive)
d32f600d	387	(inferior-octave-send-list-and-digest '("disp (pwd ())\n"))
081bf30e RS	388	(cd (car inferior-octave-output-list)))
081bf30e RS	389
15c2d736 KH	390	;;; provide ourself
	391
	392	(provide 'octave-inf)
	393
e2536e57	394	;; arch-tag: bdce0395-24d1-4bb4-bfba-6fb1eeb1a660
e96a83c8	395	;;; octave-inf.el ends here