annotate lisp/progmodes/idlwave-shell.el @ 26995:85c7cda1975f

(CHAR_BYTES): Use ((1 << CHARACTERBITS) - 1) instead of GLYPH_MASK_CHAR.

;;; idlwave-shell.el --- Run IDL or WAVE as an inferior process of Emacs.
;; Copyright (c) 1994-1996 Chris Chase
;; Copyright (c) 1999 Carsten Dominik
;; Copyright (c) 1999 Free Software Foundation

;; Author: Chris Chase <[e-mail]>
;; Maintainer: Carsten Dominik <[e-mail]>
;; Version: 3.11
;; Date: $Date: 1999/12/06 08:13:16 $
;; Keywords: processes

;; 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 2, 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; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.

;;; Commentary:

;; This mode is for IDL version 4 or later.  It should work on Emacs
;; or XEmacs version 19 or later.

;; Runs IDL as an inferior process of Emacs, much like the emacs
;; `shell' or `telnet' commands.  Provides command history and
;; searching.  Provides debugging commands available in buffers
;; visiting IDL procedure files, e.g., breakpoint setting, stepping,
;; execution until a certain line, printing expressions under point,
;; visual line pointer for current execution line, etc.
;;
;; Documentation should be available online with `M-x idlwave-info'.

;; INSTALLATION:
;; =============
;; 
;; Follow the instructions in the INSTALL file of the distribution.
;; In short, put this file on your load path and add the following
;; lines to your .emacs file:
;;
;; (autoload 'idlwave-shell "idlwave-shell" "IDLWAVE Shell" t)
;;
;;
;; SOURCE
;; ======
;;
;;   The newest version of this file can be found on the maintainers
;;   web site.
;; 
;;     http://www.strw.leidenuniv.el/~dominik/Tools/idlwave
;; 
;; DOCUMENTATION
;; =============
;;
;; IDLWAVE is documented online in info format.
;; A printable version of the documentation is available from the
;; maintainers webpage (see under SOURCE)
;;
;;
;; KNOWN PROBLEMS
;; ==============
;;
;; The idlwave-shell buffer seems to occasionally lose output from the IDL
;; process.  I have not been able to consistently observe this.  I
;; do not know if it is a problem with idlwave-shell, comint, or Emacs
;; handling of subprocesses.
;; 
;; I don't plan on implementing directory tracking by watching the IDL
;; commands entered at the prompt, since too often an IDL procedure
;; will change the current directory. If you want the the idl process
;; buffer to match the IDL current working just execute `M-x
;; idlwave-shell-resync-dirs' (bound to "\C-c\C-d\C-w" by default.)
;;
;; The stack motion commands `idlwave-shell-stack-up' and
;; `idlwave-shell-stack-down' only display the calling frame but
;; cannot show the values of variables in higher frames correctly.  I
;; just don't know how to get these values from IDL.  Anyone knows the 
;; magic word to do this?
;; Also, the stack pointer stays at the level where is was and is not
;; reset correctly when you type executive commands in the shell buffer
;; yourself.  However, using the executive commands bound to key sequences
;; does the reset correctly.  As a workaround, just jump down when needed.
;; 
;; Under XEmacs the Debug menu in the shell does not display the
;; keybindings in the prefix map.  There bindings are available anyway - so
;; it is a bug in XEmacs.
;; The Debug menu in source buffers does display the bindings correctly.
;;
;; 
;; CUSTOMIZATION VARIABLES
;; =======================
;;
;; IDLWAVE has customize support - so if you want to learn about
;; the variables which control the behavior of the mode, use
;; `M-x idlwave-customize'.
;;
;;--------------------------------------------------------------------------
;;
;;

;;; Code:

(require 'comint)
(require 'idlwave)

(eval-when-compile (require 'cl))

(defvar idlwave-shell-have-new-custom nil)
(eval-and-compile
  ;; Kludge to allow `defcustom' for Emacs 19.
  (condition-case () (require 'custom) (error nil))
  (if (and (featurep 'custom)
	   (fboundp 'custom-declare-variable)
	   (fboundp 'defface))	   
      ;; We've got what we needed
      (setq idlwave-shell-have-new-custom t)
    ;; We have the old or no custom-library, hack around it!
    (defmacro defgroup (&rest args) nil)
    (defmacro defcustom (var value doc &rest args) 
      (` (defvar (, var) (, value) (, doc))))))

;;; Customizations: idlwave-shell group

(defgroup idlwave-shell-general-setup nil
  "Indentation options for IDL/WAVE mode."
  :prefix "idlwave"
  :group 'idlwave)

(defcustom idlwave-shell-prompt-pattern "^ ?IDL> "
  "*Regexp to match IDL prompt at beginning of a line. 
For example, \"^IDL> \" or \"^WAVE> \". 
The \"^\" means beginning of line.
This variable is used to initialise `comint-prompt-regexp' in the 
process buffer.

This is a fine thing to set in your `.emacs' file."
  :group 'idlwave-shell-general-setup
  :type 'regexp)

(defcustom idlwave-shell-process-name "idl"
  "*Name to be associated with the IDL process.  The buffer for the
process output is made by surrounding this name with `*'s."
  :group 'idlwave-shell-general-setup
  :type 'string)

(defcustom idlwave-shell-automatic-start nil
  "*If non-nil attempt invoke idlwave-shell if not already running.
This is checked when an attempt to send a command to an
IDL process is made."
  :group 'idlwave-shell-general-setup
  :type 'boolean)

(defcustom idlwave-shell-initial-commands "!more=0"
  "Initial commands, separated by newlines, to send to IDL.
This string is sent to the IDL process by `idlwave-shell-mode' which is
invoked by `idlwave-shell'."
  :group 'idlwave-shell-initial-commands
  :type 'string)

(defcustom idlwave-shell-use-dedicated-frame nil
  "*Non-nil means, IDLWAVE should use a special frame to display shell buffer."
  :group 'idlwave-shell-general-setup
  :type 'boolean)

(defcustom idlwave-shell-frame-parameters
  '((height . 30) (unsplittable . nil))
  "The frame parameters for a dedicated idlwave-shell frame.
See also `idlwave-shell-use-dedicated-frame'.
The default makes the frame splittable, so that completion works correctly."
  :group 'idlwave-shell-general-setup
  :type '(repeat
	  (cons symbol sexp)))

(defcustom idlwave-shell-use-toolbar t
  "Non-nil means, use the debugging toolbar in all IDL related buffers.
Available on XEmacs and on Emacs 21.x or later.
Needs to be set at load-time, so don't try to do this in the hook."
  :group 'idlwave-shell-general-setup
  :type 'boolean)

(defcustom idlwave-shell-temp-pro-prefix "/tmp/idltemp"
  "*The prefix for temporary IDL files used when compiling regions.
It should be an absolute pathname.
The full temporary file name is obtained by to using `make-temp-name'
so that the name will be unique among multiple Emacs processes."
  :group 'idlwave-shell-general-setup
  :type 'string)

(defvar idlwave-shell-fix-inserted-breaks nil
  "*OBSOLETE VARIABLE, is no longer used.

The documentation of this variable used to be:
If non-nil then run `idlwave-shell-remove-breaks' to clean up IDL messages.")

(defcustom idlwave-shell-prefix-key "\C-c\C-d"
  "*The prefix key for the debugging map `idlwave-shell-mode-prefix-map'.
This variable must already be set when idlwave-shell.el is loaded.
Seting it in the mode-hook is too late."
  :group 'idlwave-shell-general-setup
  :type 'string)

(defcustom idlwave-shell-activate-prefix-keybindings t
  "Non-nil means, the debug commands will be bound to the prefix key.
The prefix key itself is given in the option `idlwave-shell-prefix-key'.
So by default setting a breakpoint will be on C-c C-d C-b."
  :group 'idlwave-shell-general-setup
  :type 'boolean)

(defcustom idlwave-shell-activate-alt-keybindings nil
  "Non-nil means, the debug commands will be bound to alternate keys.
So for example setting a breakpoint will be on A-b."
  :group 'idlwave-shell-general-setup
  :type 'boolean)

(defcustom idlwave-shell-use-truename nil
  "*Non-nil means, use use `file-truename' when looking for buffers.
If this variable is non-nil, Emacs will use the function `file-truename' to
resolve symbolic links in the file paths printed by e.g., STOP commands.
This means, unvisited files will be loaded under their truename.
However, when a file is already visited under a deffernet name, IDLWAVE will
reuse that buffer.
This option was once introduced in order to avoid multiple buffers visiting
the same file.  However, IDLWAVE no longer makes this mistake, so it is safe
to set this option to nil."
  :group 'idlwave-shell-general-setup
  :type 'boolean)

(defcustom idlwave-shell-file-name-chars "~/A-Za-z0-9+@:_.$#%={}-"
  "The characters allowed in file names, as a string.
Used for file name completion. Must not contain `'', `,' and `\"'
because these are used as separators by IDL."
  :group 'idlwave-shell-general-setup
  :type 'string)

(defcustom idlwave-shell-mode-hook '()
  "*Hook for customising `idlwave-shell-mode'."
  :group 'idlwave-shell-general-setup
  :type 'hook)

;;; Breakpoint Overlays etc

(defgroup idlwave-shell-highlighting-and-faces nil
  "Indentation options for IDL/WAVE mode."
  :prefix "idlwave"
  :group 'idlwave)

(defcustom idlwave-shell-mark-stop-line t
  "*Non-nil means, mark the source code line where IDL is currently stopped.
Value decides about the method which is used to mark the line.  Legal values
are:

nil       Do not mark the line
'arrow    Use the overlay arrow
'face     Use `idlwave-shell-stop-line-face' to highlight the line.
t         Use what IDLWAVE things is best.  Will be a face where possible,
          otherwise the overlay arrow.
The overlay-arrow has the disadvantage to hide the first chars of a line.
Since many people do not have the main block of IDL programs indented,
a face highlighting may be better.
On Emacs 21, the overlay arrow is displayed in a special area and never
hides any code, so setting this to 'arrow on Emacs 21 sounds like a good idea."
  :group 'idlwave-shell-highlighting-and-faces
  :type '(choice
	  (const :tag "No marking" nil)
	  (const :tag "Use overlay arrow" arrow)
	  (const :tag "Highlight with face" face)
	  (const :tag "Face or arrow." t)))

(defcustom idlwave-shell-overlay-arrow ">"
  "*The overlay arrow to display at source lines where execution halts.
We use a single character by default, since the main block of IDL procedures
often has no indentation.  Where possible, IDLWAVE will use overlays to
display the stop-lines.  The arrow is only used on character-based terminals.
See also `idlwave-shell-use-overlay-arrow'."
  :group 'idlwave-shell-highlighting-and-faces
  :type 'string)

(defcustom idlwave-shell-stop-line-face 'highlight
  "*The face for `idlwave-shell-stop-line-overlay'.
Allows you to choose the font, color and other properties for
line where IDL is stopped.  See also `idlwave-shell-mark-stop-line'."
  :group 'idlwave-shell-highlighting-and-faces
  :type 'symbol)

(defcustom idlwave-shell-expression-face 'secondary-selection
  "*The face for `idlwave-shell-expression-overlay'.
Allows you to choose the font, color and other properties for
the expression printed by IDL."
  :group 'idlwave-shell-highlighting-and-faces
  :type 'symbol)

(defcustom idlwave-shell-mark-breakpoints t
  "*Non-nil means, mark breakpoints in the source files.
Legal values are:
nil        Do not mark breakpoints.
'face      Highlight line with `idlwave-shell-breakpoint-face'.
'glyph     Red dot at the beginning of line.  If the display does not
           support glyphs, will use 'face instead.
t          Glyph when possible, otherwise face (same effect as 'glyph)."
  :group 'idlwave-shell-highlighting-and-faces
  :type '(choice
	  (const :tag "No marking" nil)
	  (const :tag "Highlight with face" face)
	  (const :tag "Display glyph (red dot)" glyph)
	  (const :tag "Glyph or face." t)))

(defvar idlwave-shell-use-breakpoint-glyph t
  "Obsolete variable.   See `idlwave-shell-mark-breakpoints.")

(defcustom idlwave-shell-breakpoint-face 'idlwave-shell-bp-face
  "*The face for breakpoint lines in the source code.
Allows you to choose the font, color and other properties for
lines which have a breakpoint.  See also `idlwave-shell-mark-breakpoints'."
  :group 'idlwave-shell-highlighting-and-faces
  :type 'symbol)

(if idlwave-shell-have-new-custom
    ;; We have the new customize - use it to define a customizable face
    (defface idlwave-shell-bp-face
      '((((class color)) (:foreground "Black" :background "Pink"))
	(t (:underline t)))
      "Face for highlighting lines-with-breakpoints."
      :group 'idlwave-shell-highlighting-and-faces)
  ;; Just copy the underline face to be on the safe side.
  (copy-face 'underline 'idlwave-shell-bp-face))

;;; End user customization variables

;;; External variables
(defvar comint-last-input-start)
(defvar comint-last-input-end)

;; Other variables

(defvar idlwave-shell-temp-pro-file nil
  "Absolute pathname for temporary IDL file for compiling regions")

(defvar idlwave-shell-dirstack-query "printd"
  "Command used by `idlwave-shell-resync-dirs' to query IDL for 
the directory stack.")

(defvar idlwave-shell-default-directory nil
  "The default directory in the idlwave-shell buffer, of outside use.")

(defvar idlwave-shell-last-save-and-action-file nil
  "The last file which was compiled with `idlwave-shell-save-and-...'.")

;; Highlighting uses overlays.  When necessary, require the emulation.
(if (not (fboundp 'make-overlay))
    (condition-case nil
	(require 'overlay)
      (error nil)))

(defvar idlwave-shell-stop-line-overlay nil
  "The overlay for where IDL is currently stopped.")
(defvar idlwave-shell-expression-overlay nil
  "The overlay for where IDL is currently stopped.")
;; If these were already overlays, delete them.  This probably means that we
;; are reloading this file.
(if (overlayp idlwave-shell-stop-line-overlay)
    (delete-overlay idlwave-shell-stop-line-overlay))
(if (overlayp idlwave-shell-expression-overlay)
    (delete-overlay idlwave-shell-expression-overlay))
;; Set to nil initially
(setq idlwave-shell-stop-line-overlay nil
      idlwave-shell-expression-overlay nil)

;; Define the shell stop overlay.  When left nil, the arrow will be used.
(cond
 ((or (null idlwave-shell-mark-stop-line)
      (eq idlwave-shell-mark-stop-line 'arrow))
  ;; Leave the overlay nil
  nil)

 ((eq idlwave-shell-mark-stop-line 'face)
  ;; Try to use a face.  If not possible, arrow will be used anyway
  ;; So who can display faces?
  (when (or (featurep 'xemacs)            ; XEmacs can do also ttys
	    (fboundp 'tty-defined-colors) ; Emacs 21 as well
	    window-system)                ; Window systems always
    (progn
      (setq idlwave-shell-stop-line-overlay (make-overlay 1 1))
      (overlay-put idlwave-shell-stop-line-overlay 
		   'face idlwave-shell-stop-line-face))))

 (t
  ;; IDLWAVE may decide.  Will use a face on window systems, arrow elsewhere
  (if window-system
      (progn
	(setq idlwave-shell-stop-line-overlay (make-overlay 1 1))
	(overlay-put idlwave-shell-stop-line-overlay 
		     'face idlwave-shell-stop-line-face)))))

;; Now the expression overlay
(setq idlwave-shell-expression-overlay (make-overlay 1 1))
(overlay-put idlwave-shell-expression-overlay
	     'face idlwave-shell-expression-face)

(defvar idlwave-shell-bp-query "help,/breakpoints"
  "Command to obtain list of breakpoints")

(defvar idlwave-shell-command-output nil
  "String for accumulating current command output.")

(defvar idlwave-shell-post-command-hook nil
  "Lisp list expression or function to run when an IDL command is finished.
The current command is finished when the IDL prompt is displayed.
This is evaluated if it is a list or called with funcall.")

(defvar idlwave-shell-hide-output nil
  "If non-nil the process output is not inserted into the output
  buffer.")

(defvar idlwave-shell-accumulation nil
  "Accumulate last line of output.")

(defvar idlwave-shell-command-line-to-execute nil)
(defvar idlwave-shell-cleanup-hook nil
  "List of functions to do cleanup when the shell exits.")

(defvar idlwave-shell-pending-commands nil
  "List of commands to be sent to IDL.
Each element of the list is list of \(CMD PCMD HIDE\), where CMD is a
string to be sent to IDL and PCMD is a post-command to be placed on
`idlwave-shell-post-command-hook'. If HIDE is non-nil, hide the output
from command CMD. PCMD and HIDE are optional.")

(defun idlwave-shell-buffer ()
  "Name of buffer associated with IDL process.
The name of the buffer is made by surrounding `idlwave-shell-process-name
with `*'s."
  (concat "*" idlwave-shell-process-name "*"))

(defvar idlwave-shell-ready nil
  "If non-nil can send next command to IDL process.")

;;; The following are the types of messages we attempt to catch to
;;; resync our idea of where IDL execution currently is.
;;; 

(defvar idlwave-shell-halt-frame nil
  "The frame associated with halt/breakpoint messages.")

(defvar idlwave-shell-step-frame nil
  "The frame associated with step messages.")

(defvar idlwave-shell-trace-frame nil
  "The frame associated with trace messages.")

(defconst idlwave-shell-halt-messages
  '("^% Execution halted at"
    "^% Interrupted at:"
    "^% Stepped to:"
    "^% At "
    "^% Stop encountered:"
    )
  "*A list of regular expressions matching IDL messages.
These are the messages containing file and line information where
IDL is currently stopped.")

(defconst idlwave-shell-halt-messages-re
  (mapconcat 'identity idlwave-shell-halt-messages "\\|")
  "The regular expression computed from idlwave-shell-halt-messages")

(defconst idlwave-shell-trace-messages
  '("^% At "    ;; First line of a trace message
    )
  "*A list of regular expressions matching IDL trace messages.
These are the messages containing file and line information where
IDL will begin looking for the next statement to execute.")

(defconst idlwave-shell-step-messages
  '("^% Stepped to:"
    )
  "*A list of regular expressions matching stepped execution messages.
These are IDL messages containing file and line information where
IDL has currently stepped.")

(defvar idlwave-shell-break-message "^% Breakpoint at:"
  "*Regular expression matching an IDL breakpoint message line.")


(defvar idlwave-shell-bp-alist)
;(defvar idlwave-shell-post-command-output)
(defvar idlwave-shell-sources-alist)
(defvar idlwave-shell-menu-def)
(defvar idlwave-shell-mode-menu)
(defvar idlwave-shell-initial-commands)
(defvar idlwave-shell-syntax-error)
(defvar idlwave-shell-other-error)
(defvar idlwave-shell-error-buffer)
(defvar idlwave-shell-error-last)
(defvar idlwave-shell-bp-buffer)
(defvar idlwave-shell-sources-query)
(defvar idlwave-shell-mode-map)

(defun idlwave-shell-mode ()
  "Major mode for interacting with an inferior IDL process.

1. Shell Interaction
   -----------------
   RET after the end of the process' output sends the text from the
   end of process to the end of the current line.  RET before end of
   process output copies the current line (except for the prompt) to the
   end of the buffer.

   Command history, searching of previous commands, command line
   editing are available via the comint-mode key bindings, by default
   mostly on the key `C-c'.

2. Completion
   ----------

   TAB and M-TAB do completion of IDL routines and keywords - similar
   to M-TAB in `idlwave-mode'.  In executive commands and strings,
   it completes file names.

3. Routine Info
   ------------
   `\\[idlwave-routine-info]' displays information about an IDL routine near point,
   just like in `idlwave-mode'.  The module used is the one at point or
   the one whose argument list is being edited.
   To update IDLWAVE's knowledge about compiled or edited modules, use 
   \\[idlwave-update-routine-info].
   \\[idlwave-find-module] find the source of a module.
   \\[idlwave-resolve] tells IDL to compile an unresolved module.

4. Debugging
   ---------
   A complete set of commands for compiling and debugging IDL programs
   is available from the menu.  Also keybindings starting with a 
   `C-c C-d' prefix are available for most commands in the *idl* buffer
   and also in source buffers.  The best place to learn about the
   keybindings is again the menu.

   On Emacs versions where this is possible, a debugging toolbar is
   installed.

   When IDL is halted in the middle of a procedure, the corresponding
   line of that procedure file is displayed with an overlay in another
   window.  Breakpoints are also highlighted in the source.

   \\[idlwave-shell-resync-dirs] queries IDL in order to change Emacs current directory
   to correspond to the IDL process current directory.

5. Hooks
   -----
   Turning on `idlwave-shell-mode' runs `comint-mode-hook' and
   `idlwave-shell-mode-hook' (in that order).

6. Documentation and Customization
   -------------------------------
   Info documentation for this package is available.  Use \\[idlwave-info]
   to display (complain to your sysadmin if that does not work).
   For Postscript and HTML versions of the documentation, check IDLWAVE's
   homepage at `http://www.strw.leidenuniv.nl/~dominik/Tools/idlwave'.
   IDLWAVE has customize support - see the group `idlwave'.

7. Keybindings
   -----------
\\{idlwave-shell-mode-map}"

  (interactive)
  (setq comint-prompt-regexp idlwave-shell-prompt-pattern)
  (setq comint-process-echoes t)
  ;; Can not use history expansion because "!" is used for system variables.
  (setq comint-input-autoexpand nil)
  (setq comint-input-ring-size 64)
  (make-local-variable 'comint-completion-addsuffix)
  (set (make-local-variable 'completion-ignore-case) t)
  (setq comint-completion-addsuffix '("/" . ""))
  (setq comint-input-ignoredups t)
  (setq major-mode 'idlwave-shell-mode)
  (setq mode-name "IDL-Shell")
  ;; (make-local-variable 'idlwave-shell-bp-alist)
  (setq idlwave-shell-halt-frame nil
        idlwave-shell-trace-frame nil
        idlwave-shell-command-output nil
        idlwave-shell-step-frame nil)
  (idlwave-shell-display-line nil)
  ;; Make sure comint-last-input-end does not go to beginning of
  ;; buffer (in case there were other processes already in this buffer).
  (set-marker comint-last-input-end (point))
  (setq idlwave-shell-ready nil)
  (setq idlwave-shell-bp-alist nil)
  (idlwave-shell-update-bp-overlays) ; Throw away old overlays
  (setq idlwave-shell-sources-alist nil)
  (setq idlwave-shell-default-directory default-directory)
  ;; (make-local-variable 'idlwave-shell-temp-pro-file)
  (setq idlwave-shell-hide-output nil
        idlwave-shell-temp-pro-file
        (concat (make-temp-name idlwave-shell-temp-pro-prefix) ".pro"))
  (make-local-hook 'kill-buffer-hook)
  (add-hook 'kill-buffer-hook 'idlwave-shell-kill-shell-buffer-confirm
	    nil 'local)
  (use-local-map idlwave-shell-mode-map)
  (easy-menu-add idlwave-shell-mode-menu idlwave-shell-mode-map)
  (run-hooks 'idlwave-shell-mode-hook)
  (idlwave-shell-send-command idlwave-shell-initial-commands nil 'hide)
  )

(if (not (fboundp 'idl-shell))
    (fset 'idl-shell 'idlwave-shell))

(defvar idlwave-shell-idl-wframe nil
  "Frame for displaying the idl shell window.")
(defvar idlwave-shell-display-wframe nil
  "Frame for displaying the idl source files.")

(defvar idlwave-shell-last-calling-stack nil
  "Caches the last calling stack, so that we can compare.")
(defvar idlwave-shell-calling-stack-index 0)

(defun idlwave-shell-source-frame ()
  "Return the frame to be used for source display."
  (if idlwave-shell-use-dedicated-frame
      ;; We want separate frames for source and shell
      (if (frame-live-p idlwave-shell-display-wframe)
	  ;; The frame exists, so we use it.
	  idlwave-shell-display-wframe
	;; The frame does not exist.  We use the current frame.
	;; However, if the current is the shell frame, we make a new frame.
	(setq idlwave-shell-display-wframe
	      (if (eq (selected-frame) idlwave-shell-idl-wframe)
		  (make-frame)
		(selected-frame))))))

(defun idlwave-shell-shell-frame ()
  "Return the frame to be used for the shell buffer."
  (if idlwave-shell-use-dedicated-frame
      ;; We want a dedicated frame
      (if (frame-live-p idlwave-shell-idl-wframe)
	  ;; It does exist, so we use it.
	  idlwave-shell-idl-wframe
	;; It does not exist.  Check if we have a source frame.
	(if (not (frame-live-p idlwave-shell-display-wframe))
	    ;; We do not have a source frame, so we use this one.
	    (setq idlwave-shell-display-wframe (selected-frame)))
	;; Return a new frame
	(setq idlwave-shell-idl-wframe 
	      (make-frame idlwave-shell-frame-parameters)))))
  
;;;###autoload
(defun idlwave-shell (&optional arg)
  "Run an inferior IDL, with I/O through buffer `(idlwave-shell-buffer)'.
If buffer exists but shell process is not running, start new IDL.
If buffer exists and shell process is running, just switch to the buffer.

When called with a prefix ARG, or when `idlwave-shell-use-dedicated-frame'
is non-nil, the shell buffer and the source buffers will be in
separate frames.

The command to run comes from variable `idlwave-shell-explicit-file-name'.

The buffer is put in `idlwave-shell-mode', providing commands for sending
input and controlling the IDL job.  See help on `idlwave-shell-mode'.
See also the variable `idlwave-shell-prompt-pattern'.

\(Type \\[describe-mode] in the shell buffer for a list of commands.)"
  (interactive "P")

  ;; A non-nil arg means, we want a dedicated frame.  This will last
  ;; for the current editing session.
  (if arg (setq idlwave-shell-use-dedicated-frame t))
  (if (equal arg '(16)) (setq idlwave-shell-use-dedicated-frame nil))

  ;; Check if the process still exists.  If not, create it.
  (unless (comint-check-proc (idlwave-shell-buffer))
    (let* ((prg (or idlwave-shell-explicit-file-name "idl"))
	   (buf (apply 'make-comint
		       idlwave-shell-process-name prg nil
		       idlwave-shell-command-line-options))
	   ;; FIXME: the next line can go?
	   ;(buf (make-comint idlwave-shell-process-name prg))
	   (process (get-buffer-process buf)))
      (set-process-filter process 'idlwave-shell-filter)
      (set-process-sentinel process 'idlwave-shell-sentinel)
      (set-buffer buf)
      (idlwave-shell-mode)))
  (let ((window (idlwave-display-buffer (idlwave-shell-buffer) nil
					(idlwave-shell-shell-frame)))
	(current-window (selected-window)))
    (select-window window)
    (goto-char (point-max))
    (select-window current-window)    
    (raise-frame (window-frame window))
    (if (eq (selected-frame) (window-frame window))
	(select-window window))
    ))

(defun idlwave-shell-recenter-shell-window (&optional arg)
  "Run `idlwave-shell', but make sure the current window stays selected."
  (interactive "P")
  (let ((window (selected-window)))
    (idlwave-shell arg)
    (select-window window)))

(defun idlwave-shell-send-command (&optional cmd pcmd hide preempt)
  "Send a command to IDL process.

\(CMD PCMD HIDE\) are placed at the end of `idlwave-shell-pending-commands'.
If IDL is ready the first command, CMD, in
`idlwave-shell-pending-commands' is sent to the IDL process.  If optional
second argument PCMD is non-nil it will be placed on
`idlwave-shell-post-command-hook' when CMD is executed.  If the optional
third argument HIDE is non-nil, then hide output from CMD.
If optional fourth argument PREEMPT is non-nil CMD is put at front of
`idlwave-shell-pending-commands'.

IDL is considered ready if the prompt is present
and if `idlwave-shell-ready' is non-nil."

  ;(setq hide nil)  ;  FIXME: turn this on for debugging only
  (let (buf proc)
    ;; Get or make the buffer and its process
    (if (or (not (setq buf (get-buffer (idlwave-shell-buffer))))
	    (not (setq proc (get-buffer-process buf))))
	(if (not idlwave-shell-automatic-start)
	    (error
	     (substitute-command-keys
	      "You need to first start an IDL shell with \\[idlwave-shell]"))
	  (idlwave-shell-recenter-shell-window)
	  (setq buf (get-buffer (idlwave-shell-buffer)))
	  (if (or (not (setq buf (get-buffer (idlwave-shell-buffer))))
		  (not (setq proc (get-buffer-process buf))))
	      ;; Still nothing
	      (error "Problem with autostarting IDL shell"))))

    (save-excursion
      (set-buffer buf)
      (goto-char (process-mark proc))
      ;; To make this easy, always push CMD onto pending commands
      (if cmd
          (setq idlwave-shell-pending-commands
                (if preempt
                    ;; Put at front.
                    (append (list (list cmd pcmd hide))
                            idlwave-shell-pending-commands)
                  ;; Put at end.
                  (append idlwave-shell-pending-commands 
                          (list (list cmd pcmd hide))))))
      ;; Check if IDL ready
      (if (and idlwave-shell-ready
               ;; Check for IDL prompt
               (save-excursion
                 (beginning-of-line)
                 (looking-at idlwave-shell-prompt-pattern)))
          ;; IDL ready for command
          (if idlwave-shell-pending-commands
              ;; execute command
              (let* ((lcmd (car idlwave-shell-pending-commands))
		     (cmd (car lcmd))
                     (pcmd (nth 1 lcmd))
                     (hide (nth 2 lcmd)))
		;; If this is an executive command, reset the stack pointer
		(if (eq (string-to-char cmd) ?.)
		    (setq idlwave-shell-calling-stack-index 0))
                ;; Set post-command
                (setq idlwave-shell-post-command-hook pcmd)
                ;; Output hiding
;;; Debug code          
;;;             (setq idlwave-shell-hide-output nil)
                (setq idlwave-shell-hide-output hide)
                ;; Pop command
                (setq idlwave-shell-pending-commands
                      (cdr idlwave-shell-pending-commands))
                ;; Send command for execution
                (set-marker comint-last-input-start (point))
                (set-marker comint-last-input-end (point))
                (comint-simple-send proc cmd)
                (setq idlwave-shell-ready nil)))))))

;; There was a report that a newer version of comint.el changed the
;; name of comint-filter to comint-output-filter.  Unfortunately, we
;; have yet to upgrade.

(defun idlwave-shell-comint-filter (process string) nil)
(if (fboundp 'comint-output-filter)
    (fset 'idlwave-shell-comint-filter (symbol-function 'comint-output-filter))
  (fset 'idlwave-shell-comint-filter (symbol-function 'comint-filter)))

(defun idlwave-shell-is-running ()
  "Return t if the shell process is running."
  (eq (process-status idlwave-shell-process-name) 'run))

(defun idlwave-shell-filter (proc string)
  "Replace Carriage returns in output. Watch for prompt.
When the IDL prompt is received executes `idlwave-shell-post-command-hook'
and then calls `idlwave-shell-send-command' for any pending commands."
  ;; We no longer do the cleanup here - this is done by the process sentinel
  (when (eq (process-status idlwave-shell-process-name) 'run)
    ;; OK, process is still running, so we can use it.
    (let ((data (match-data)))
      (unwind-protect
          (progn
            ;; May change the original match data.
            (let (p)
              (while (setq p (string-match "\C-M" string))
                (aset string p ?  )))
;;; Test/Debug code
;;          (save-excursion (set-buffer (get-buffer-create "*test*"))
;;                          (goto-char (point-max))
;;                          (insert "%%%" string))
            ;;
            ;; Keep output

; Should not keep output because the concat is costly.  If hidden put
; the output in a hide-buffer.  Then when the output is needed in post
; processing can access either the hide buffer or the idlwave-shell
; buffer.  Then watching for the prompt is easier.  Furthermore, if it
; is hidden and there is no post command, could throw away output.
;           (setq idlwave-shell-command-output
;                 (concat idlwave-shell-command-output string))
            ;; Insert the string. Do this before getting the
            ;; state. 
            (if idlwave-shell-hide-output
                (save-excursion
                  (set-buffer
                   (get-buffer-create "*idlwave-shell-hidden-output*"))
                  (goto-char (point-max))
                  (insert string))
              (idlwave-shell-comint-filter proc string))
            ;; Watch for prompt - need to accumulate the current line
            ;; since it may not be sent all at once.
            (if (string-match "\n" string)
                (setq idlwave-shell-accumulation
                      (substring string 
                                 (progn (string-match "\\(.*\n\\)*" string)
                                        (match-end 0))))
              (setq idlwave-shell-accumulation
                    (concat idlwave-shell-accumulation string)))
            ;; Check for prompt in current line 
            (if (setq idlwave-shell-ready
                      (string-match idlwave-shell-prompt-pattern
                                    idlwave-shell-accumulation))
                (progn
                  (if idlwave-shell-hide-output
                      (save-excursion
                        (set-buffer "*idlwave-shell-hidden-output*")
                        (goto-char (point-min))
                        (re-search-forward idlwave-shell-prompt-pattern nil t)
                        (setq idlwave-shell-command-output
                              (buffer-substring (point-min) (point)))
                        (delete-region (point-min) (point)))
                    (setq idlwave-shell-command-output
                          (save-excursion
                            (set-buffer
                             (process-buffer proc))
                            (buffer-substring
                             (progn
                               (goto-char (process-mark proc))
                               (beginning-of-line nil)
                               (point))
                             comint-last-input-end))))
;;; Test/Debug code
;;                (save-excursion (set-buffer
;;                                 (get-buffer-create "*idlwave-shell-output*"))
;;                                (goto-char (point-max))
;;                                (insert "%%%" string))
                  ;; Scan for state and do post command - bracket them
                  ;; with idlwave-shell-ready=nil since they
                  ;; may call idlwave-shell-send-command.
                  (let ((idlwave-shell-ready nil))
                    (idlwave-shell-scan-for-state)
                    ;; Unset idlwave-shell-ready to prevent sending
                    ;; commands to IDL while running hook.
                    (if (listp idlwave-shell-post-command-hook)
                        (eval idlwave-shell-post-command-hook)
                      (funcall idlwave-shell-post-command-hook))
                    ;; Reset to default state for next command.
                    ;; Also we do not want to find this prompt again.
                    (setq idlwave-shell-accumulation nil
                          idlwave-shell-command-output nil
                          idlwave-shell-post-command-hook nil
                          idlwave-shell-hide-output nil))
                  ;; Done with post command. Do pending command if
                  ;; any.
                  (idlwave-shell-send-command))))
        (store-match-data data)))))

(defun idlwave-shell-sentinel (process event)
  "The sentinel function for the IDLWAVE shell process."
  (let* ((buf (idlwave-shell-buffer))
	 (win (get-buffer-window buf)))
    (when (get-buffer buf)
      (save-excursion
	(set-buffer (idlwave-shell-buffer))
	(goto-char (point-max))
	(insert (format "\n\n  Process %s %s" process event))))
    (when (and (> (length (frame-list)) 1)
	       (frame-live-p idlwave-shell-idl-wframe))
      (delete-frame idlwave-shell-idl-wframe)
      (setq idlwave-shell-idl-wframe nil
	    idlwave-shell-display-wframe nil))
    (when (window-live-p win)
      (delete-window win))
    (idlwave-shell-cleanup)))

(defun idlwave-shell-scan-for-state ()
  "Scan for state info.
Looks for messages in output from last IDL command indicating where
IDL has stopped. The types of messages we are interested in are
execution halted, stepped, breakpoint, interrupted at and trace
messages.  We ignore error messages otherwise.
For breakpoint messages process any attached count or command
parameters.
Update the windows if a message is found."
  (let (update)
    (cond
     ;; Make sure we have output
     ((not idlwave-shell-command-output))

     ;; Various types of HALT messages.
     ((string-match idlwave-shell-halt-messages-re
		    idlwave-shell-command-output)
      ;; Grab the file and line state info.
      (setq idlwave-shell-halt-frame
            (idlwave-shell-parse-line 
             (substring idlwave-shell-command-output (match-end 0)))
            update t))

     ;; Handle breakpoints separately
     ((string-match idlwave-shell-break-message
                    idlwave-shell-command-output)
      (setq idlwave-shell-halt-frame 
            (idlwave-shell-parse-line 
             (substring idlwave-shell-command-output (match-end 0)))
            update t)
      ;; We used to to counting hits on breakpoints
      ;; this is no longer supported since IDL breakpoints
      ;; have learned counting.
      ;; Do breakpoint command processing
      (let ((bp (assoc 
                 (list
                  (nth 0 idlwave-shell-halt-frame)
                  (nth 1 idlwave-shell-halt-frame))
                 idlwave-shell-bp-alist)))
        (if bp
            (let ((cmd (idlwave-shell-bp-get bp 'cmd)))
              (if cmd
                  ;; Execute command
                  (if (listp cmd)
                      (eval cmd)
                    (funcall cmd))))
          ;; A breakpoint that we did not know about - perhaps it was
          ;; set by the user or IDL isn't reporting breakpoints like
          ;; we expect.  Lets update our list.
          (idlwave-shell-bp-query)))))

    ;; Handle compilation errors in addition to the above
    (if (and idlwave-shell-command-output
             (or (string-match
                  idlwave-shell-syntax-error idlwave-shell-command-output)
                 (string-match
                  idlwave-shell-other-error idlwave-shell-command-output)))
	(progn
	  (save-excursion
	    (set-buffer
	     (get-buffer-create idlwave-shell-error-buffer))
	    (erase-buffer)
	    (insert idlwave-shell-command-output)
	    (goto-char (point-min))
	    (setq idlwave-shell-error-last (point)))
          (idlwave-shell-goto-next-error)))
    
    ;; Do update
    (when update
      (idlwave-shell-display-line (idlwave-shell-pc-frame)))))


(defvar idlwave-shell-error-buffer
  "*idlwave-shell-errors*"
  "Buffer containing syntax errors from IDL compilations.")

;; FIXME: the following two variables do not currently allow line breaks
;; in module and file names.  I am not sure if it will be necessary to
;; change this.  Currently it seems to work the way it is.
(defvar idlwave-shell-syntax-error
  "^% Syntax error.\\s-*\n\\s-*At:\\s-*\\(.*\\),\\s-*Line\\s-*\\(.*\\)"  
  "A regular expression to match an IDL syntax error.
The first \(..\) pair should match the file name.  The second pair
should match the line number.")

(defvar idlwave-shell-other-error
  "^% .*\n\\s-*At:\\s-*\\(.*\\),\\s-*Line\\s-*\\(.*\\)"
  "A regular expression to match any IDL error.
The first \(..\) pair should match the file name.  The second pair
should match the line number.")

(defvar idlwave-shell-file-line-message
  (concat 
   "\\("                                 ; program name group (1)
   "\\<[a-zA-Z][a-zA-Z0-9_$:]*"          ; start with a letter, followed by [..]
   "\\([ \t]*\n[ \t]*[a-zA-Z0-9_$:]+\\)*"; continuation lines program name (2)
   "\\)"                                 ; end program name group (1)
   "[ \t\n]+"                            ; white space
   "\\("                                 ; line number group (3)
   "[0-9]+"                              ; the line number (the fix point)
   "\\([ \t]*\n[ \t]*[0-9]+\\)*"         ; continuation lines number (4)
   "\\)"                                 ; end line number group (3)
   "[ \t\n]+"                            ; white space
   "\\("                                 ; file name group (5)
   "[^ \t\n]+"                           ; file names can contain any non-white
   "\\([ \t]*\n[ \t]*[^ \t\n]+\\)*"      ; continuation lines file name (6)
   "\\)"                                 ; end line number group (5)
   )
  "*A regular expression to parse out the file name and line number.
The 1st group should match the subroutine name.  
The 3rd group is the line number.
The 5th group is the file name.
All parts may contain linebreaks surrounded by spaces.  This is important
in IDL5 which inserts random linebreaks in long module and file names.")

(defun idlwave-shell-parse-line (string)
  "Parse IDL message for the subroutine, file name and line number.
We need to work hard here to remove the stupid line breaks inserted by
IDL5.  These line breaks can be right in the middle of procedure
or file names.
It is very difficult to come up with a robust solution.  This one seems
to be pretty good though.  

Here is in what ways it improves over the previous solution:

1. The procedure name can be split and will be restored.
2. The number can be split.  I have never seen this, but who knows.
3. We do not require the `.pro' extension for files.

This function can still break when the file name ends on a end line
and the message line contains an additional line with garbage.  Then
the first part of that garbage will be added to the file name.
However, the function checks the existence of the files with and
without this last part - thus the function only breaks if file name
plus garbage match an existing regular file.  This is hopefully very
unlikely."

  (let (number procedure file)
    (when (string-match idlwave-shell-file-line-message string)
      (setq procedure (match-string 1 string)
	    number (match-string 3 string)
	    file (match-string 5 string))
	
      ;; Repair the strings
      (setq procedure (idlwave-shell-repair-string procedure))
      (setq number (idlwave-shell-repair-string number))
      (setq file (idlwave-shell-repair-file-name file))

      ;; If we have a file, return the frame list
      (if file
	  (list (idlwave-shell-file-name file)
		(string-to-int number)
		procedure)
	;; No success finding a file
	nil))))

(defun idlwave-shell-repair-string (string)
  "Repair a string by taking out all linebreaks.  This is destructive!"
  (while (string-match "[ \t]*\n[ \t]*" string)
    (setq string (replace-match "" t t string)))
  string)

(defun idlwave-shell-repair-file-name (file)
  "Repair a file name string by taking out all linebreaks.
The last line of STRING may be garbage - we check which one makes a valid
file name."
  (let ((file1 "") (file2 "") (start 0))
    ;; We scan no further than to the next "^%" line
    (if (string-match "^%" file) 
	(setq file (substring file 0 (match-beginning 0))))
    ;; Take out the line breaks
    (while (string-match "[ \t]*\n[ \t]*" file start)
      (setq file1 (concat file1 (substring file start (match-beginning 0)))
	    start (match-end 0)))
    (setq file2 (concat file1 (substring file start)))
    (cond
     ((file-regular-p file2) file2)
     ((file-regular-p file1) file1)
     ;; If we cannot veryfy the existence of the file, we return the shorter
     ;; name.  The idea behind this is that this may be a relative file name
     ;; and our idea about the current working directory may be wrong.
     ;; If it is a relative file name, it hopefully is short.
     ((not (string= "" file1)) file1)
     ((not (string= "" file2)) file2)
     (t nil))))

(defun idlwave-shell-cleanup ()
  "Do necessary cleanup for a terminated IDL process."
  (setq idlwave-shell-step-frame nil
        idlwave-shell-halt-frame nil
        idlwave-shell-pending-commands nil
	idlwave-shell-command-line-to-execute nil
	idlwave-shell-bp-alist nil
	idlwave-shell-calling-stack-index 0)
  (idlwave-shell-display-line nil)
  (idlwave-shell-update-bp-overlays) ; kill old overlays
  (idlwave-shell-kill-buffer "*idlwave-shell-hidden-output*")
  (idlwave-shell-kill-buffer idlwave-shell-bp-buffer)
  (idlwave-shell-kill-buffer idlwave-shell-error-buffer)
  ;; (idlwave-shell-kill-buffer (idlwave-shell-buffer))
  (and (get-buffer (idlwave-shell-buffer))
       (bury-buffer (get-buffer (idlwave-shell-buffer))))
  (run-hooks 'idlwave-shell-cleanup-hook))

(defun idlwave-shell-kill-buffer (buf)
  "Kill buffer BUF if it exists."
  (if (setq buf (get-buffer buf))
      (kill-buffer buf)))

(defun idlwave-shell-kill-shell-buffer-confirm ()
  (when (idlwave-shell-is-running)
    (ding)
    (unless (y-or-n-p "IDL shell is running.  Are you sure you want to kill the buffer? ")
      (error "Abort"))
    (message "Killing buffer *idl* and the associated process")))

(defun idlwave-shell-resync-dirs ()
  "Resync the buffer's idea of the current directory stack.
This command queries IDL with the command bound to 
`idlwave-shell-dirstack-query' (default \"printd\"), reads the
output for the new directory stack."
  (interactive)
  (idlwave-shell-send-command idlwave-shell-dirstack-query
			      'idlwave-shell-filter-directory
			      'hide))

(defun idlwave-shell-retall (&optional arg)
  "Return from the entire calling stack."
  (interactive "P")
  (idlwave-shell-send-command "retall"))

(defun idlwave-shell-closeall (&optional arg)
  "Close all open files."
  (interactive "P")
  (idlwave-shell-send-command "close,/all"))

(defun idlwave-shell-quit (&optional arg)
  "Exit the idl process after confirmation.
With prefix ARG, exit without confirmation."
  (interactive "P")
  (if (not (idlwave-shell-is-running))
      (error "Shell is not running")
    (if (or arg (y-or-n-p "Exit the IDLWAVE Shell? "))
	(condition-case nil
	    (idlwave-shell-send-command "exit")
	  (error nil)))))

(defun idlwave-shell-reset (&optional visible)
  "Reset IDL.  Return to main level and destroy the leaftover variables.
This issues the following commands:  
RETALL
WIDGET_CONTROL,/RESET
CLOSE, /ALL
HEAP_GC, /VERBOSE"
  ;; OBJ_DESTROY, OBJ_VALID()  FIXME: should this be added?
  (interactive "P")
  (message "Resetting IDL")
  (idlwave-shell-send-command "retall" nil (not visible))
  (idlwave-shell-send-command "widget_control,/reset" nil (not visible))
  (idlwave-shell-send-command "close,/all" nil (not visible))
  ;; (idlwave-shell-send-command "obj_destroy, obj_valid()" nil (not visible))
  (idlwave-shell-send-command "heap_gc,/verbose" nil (not visible))
  (setq idlwave-shell-calling-stack-index 0))

(defun idlwave-shell-filter-directory ()
  "Get the current directory from `idlwave-shell-command-output'.
Change the default directory for the process buffer to concur."
  (save-excursion
    (set-buffer (idlwave-shell-buffer))
    (if (string-match "Current Directory: *\\(\\S-*\\) *$"
		      idlwave-shell-command-output)
	(let ((dir (substring idlwave-shell-command-output 
			      (match-beginning 1) (match-end 1))))
	  (message "Setting Emacs wd to %s" dir)
	  (setq idlwave-shell-default-directory dir)
	  (setq default-directory (file-name-as-directory dir))))))

(defun idlwave-shell-complete (&optional arg)
  "Do completion in the idlwave-shell buffer.
Calls `idlwave-shell-complete-filename' after some executive commands or
in strings.  Otherwise, calls `idlwave-complete' to complete modules and
keywords."
;;FIXME: batch files?
  (interactive "P")
  (let (cmd)
    (cond
     ((setq cmd (idlwave-shell-executive-command))
      ;; We are in a command line with an executive command
      (if (member (upcase cmd)
		  '(".R" ".RU" ".RUN" ".RN" ".RNE" ".RNEW"
		    ".COM" ".COMP" ".COMPI" ".COMPIL" ".COMPILE"))
	  ;; This command expects file names
	  (idlwave-shell-complete-filename)))
     ((idlwave-shell-filename-string)
      ;; In a string, could be a file name to here
      (idlwave-shell-complete-filename))
     (t
      ;; Default completion of modules and keywords
      (idlwave-complete)))))

(defun idlwave-shell-complete-filename (&optional arg)
  "Complete a file name at point if after a file name.
We assume that we are after a file name when completing one of the
args of an executive .run, .rnew or .compile.  Also, in a string
constant we complete file names.  Otherwise return nil, so that
other completion functions can do thier work."
  (let* ((comint-file-name-chars idlwave-shell-file-name-chars)
	 (completion-ignore-case (default-value 'completion-ignore-case)))
    (comint-dynamic-complete-filename)))

(defun idlwave-shell-executive-command ()
  "Return the name of the current executive command, if any."
  (save-excursion
    (idlwave-beginning-of-statement)
    (if (looking-at "[ \t]*\\([.][^ \t\n\r]*\\)")
	(match-string 1))))

(defun idlwave-shell-filename-string ()
  "Return t if in a string and after what could be a file name."
  (let ((limit (save-excursion (beginning-of-line) (point))))
    (save-excursion
      ;; Skip backwards over file name chars
      (skip-chars-backward idlwave-shell-file-name-chars limit)
      ;; Check of the next char is a string delimiter
      (memq (preceding-char) '(?\' ?\")))))

;;;
;;; This section contains code for debugging IDL programs. --------------------
;;;

(defun idlwave-shell-redisplay (&optional hide)
  "Tries to resync the display with where execution has stopped.
Issues a \"help,/trace\" command followed by a call to 
`idlwave-shell-display-line'.  Also updates the breakpoint
overlays."
  (interactive)
  (idlwave-shell-send-command
   "help,/trace"
   '(idlwave-shell-display-line
     (idlwave-shell-pc-frame))
   hide)
  (idlwave-shell-bp-query))

(defun idlwave-shell-display-level-in-calling-stack (&optional hide)
  (idlwave-shell-send-command 
   "help,/trace"
   'idlwave-shell-parse-stack-and-display
   hide))

(defun idlwave-shell-parse-stack-and-display ()
  (let* ((lines (delete "" (idlwave-split-string
			    idlwave-shell-command-output "^%")))
	 (stack (delq nil (mapcar 'idlwave-shell-parse-line lines)))
	 (nmax (1- (length stack)))
	 (nmin 0) message)
;    ;; Reset the stack to zero if it is a new stack.
;    (if (not (equal stack idlwave-shell-last-calling-stack))
;	(setq idlwave-shell-calling-stack-index 0))
;    (setq idlwave-shell-last-calling-stack stack)
    (cond
     ((< nmax nmin)
      (setq idlwave-shell-calling-stack-index 0)      
      (error "Problem with calling stack"))
     ((> idlwave-shell-calling-stack-index nmax)
      (setq idlwave-shell-calling-stack-index nmax
	    message (format "%d is the highest level on the calling stack"
			    nmax)))
     ((< idlwave-shell-calling-stack-index nmin)
      (setq idlwave-shell-calling-stack-index nmin
	    message (format "%d is the lowest level on the calling stack"
			    nmin))))    
    (idlwave-shell-display-line 
     (nth idlwave-shell-calling-stack-index stack))
    (message (or message 
		 (format "On stack level %d"
			 idlwave-shell-calling-stack-index)))))

(defun idlwave-shell-stack-up ()
  "Display the source code one step up the calling stack."
  (interactive)
  (incf idlwave-shell-calling-stack-index)
  (idlwave-shell-display-level-in-calling-stack 'hide))
(defun idlwave-shell-stack-down ()
  "Display the source code one step down the calling stack."
  (interactive)
  (decf idlwave-shell-calling-stack-index)
  (idlwave-shell-display-level-in-calling-stack 'hide))

(defun idlwave-shell-goto-frame (&optional frame)
  "Set buffer to FRAME with point at the frame line.
If the optional argument FRAME is nil then idlwave-shell-pc-frame is
used.  Does nothing if the resulting frame is nil."
  (if frame ()
    (setq frame (idlwave-shell-pc-frame)))
  (cond
   (frame
    (set-buffer (idlwave-find-file-noselect (car frame)))
    (widen)
    (goto-line (nth 1 frame)))))

(defun idlwave-shell-pc-frame ()
  "Returns the frame for IDL execution."
  (and idlwave-shell-halt-frame
       (list (nth 0 idlwave-shell-halt-frame) 
	     (nth 1 idlwave-shell-halt-frame))))

(defun idlwave-shell-valid-frame (frame)
  "Check that frame is for an existing file."
  (file-readable-p (car frame)))

(defun idlwave-shell-display-line (frame &optional col)
  "Display FRAME file in other window with overlay arrow.

FRAME is a list of file name, line number, and subroutine name.
If FRAME is nil then remove overlay."
  (if (not frame)
      ;; Remove stop-line overlay from old position
      (progn 
        (setq overlay-arrow-string nil)
        (if idlwave-shell-stop-line-overlay
            (delete-overlay idlwave-shell-stop-line-overlay)))
    (if (not (idlwave-shell-valid-frame frame))
        (error (concat "Invalid frame - unable to access file: " (car frame)))
;;;
;;; buffer : the buffer to display a line in.
;;; select-shell: current buffer is the shell.
;;; 
      (let* ((buffer (idlwave-find-file-noselect (car frame)))
             (select-shell (equal (buffer-name) (idlwave-shell-buffer)))
             window pos)

	;; First make sure the shell window is visible
	(idlwave-display-buffer (idlwave-shell-buffer)
				nil (idlwave-shell-shell-frame))

	;; Now display the buffer and remember which window it is.
	(setq window (idlwave-display-buffer buffer
					     nil (idlwave-shell-source-frame)))

	;; Enter the buffer and mark the line
        (save-excursion
          (set-buffer buffer)
          (save-restriction
            (widen)
            (goto-line (nth 1 frame))
            (setq pos (point))
            (if idlwave-shell-stop-line-overlay
                ;; Move overlay
		(move-overlay idlwave-shell-stop-line-overlay
			      (point) (save-excursion (end-of-line) (point))
			      (current-buffer))
	      ;; Use the arrow instead, but only if marking is wanted.
	      (if idlwave-shell-mark-stop-line
		  (setq overlay-arrow-string idlwave-shell-overlay-arrow))
              (or overlay-arrow-position  ; create the marker if necessary
                  (setq overlay-arrow-position (make-marker)))
              (set-marker overlay-arrow-position (point) buffer)))
	  
	  ;; If the point is outside the restriction, widen the buffer.
          (if (or (< pos (point-min)) (> pos (point-max)))
	      (progn
		(widen)
		(goto-char pos)))

	  ;; If we have the column of the error, move the cursor there.
          (if col (move-to-column col))
          (setq pos (point)))

	;; Make sure pos is really displayed in the window.
        (set-window-point window pos)

	;; FIXME: the following frame redraw was taken out because it
        ;; flashes.  I think it is not needed.  The code is left here in
	;; case we have to put it back in.
	;; (redraw-frame (window-frame window))

	;; If we came from the shell, go back there.  Otherwise select 
	;; the window where the error is displayed.
        (if (and (equal (buffer-name) (idlwave-shell-buffer)) 
		 (not select-shell))
            (select-window window))))))


(defun idlwave-shell-step (arg)
  "Step one source line. If given prefix argument ARG, step ARG source lines."
  (interactive "p")
  (or (not arg) (< arg 1)
      (setq arg 1))
  (idlwave-shell-send-command 
   (concat ".s " (if (integerp arg) (int-to-string arg) arg))))

(defun idlwave-shell-stepover (arg)
  "Stepover one source line.
If given prefix argument ARG, step ARG source lines. 
Uses IDL's stepover executive command which does not enter called functions."
  (interactive "p")
  (or (not arg) (< arg 1)
      (setq arg 1))
  (idlwave-shell-send-command 
   (concat ".so " (if (integerp arg) (int-to-string arg) arg))))

(defun idlwave-shell-break-here (&optional count cmd)
  "Set breakpoint at current line.  

If Count is nil then an ordinary breakpoint is set.  We treat a count
of 1 as a temporary breakpoint using the ONCE keyword.  Counts greater
than 1 use the IDL AFTER=count keyword to break only after reaching
the statement count times.

Optional argument CMD is a list or function to evaluate upon reaching 
the breakpoint."
  
  (interactive "P")
  (if (listp count)
      (setq count nil))
  (idlwave-shell-set-bp
   ;; Create breakpoint
   (idlwave-shell-bp (idlwave-shell-current-frame)
		     (list count cmd)
		     (idlwave-shell-current-module))))

(defun idlwave-shell-set-bp-check (bp)
  "Check for failure to set breakpoint.
This is run on `idlwave-shell-post-command-hook'.
Offers to recompile the procedure if we failed.  This usually fixes
the problem with not being able to set the breakpoint."
  ;; Scan for message
  (if (and idlwave-shell-command-output
           (string-match "% BREAKPOINT: *Unable to find code"
                         idlwave-shell-command-output))
      ;; Offer to recompile
      (progn
        (if (progn
              (beep)
              (y-or-n-p 
               (concat "Okay to recompile file "
                       (idlwave-shell-bp-get bp 'file) " ")))
            ;; Recompile
            (progn
              ;; Clean up before retrying
              (idlwave-shell-command-failure)
              (idlwave-shell-send-command
               (concat ".run " (idlwave-shell-bp-get bp 'file)) nil nil)
              ;; Try setting breakpoint again
              (idlwave-shell-set-bp bp))
          (beep)
          (message "Unable to set breakpoint.")
          (idlwave-shell-command-failure)
          )
        ;; return non-nil if no error found
        nil)
    'okay))

(defun idlwave-shell-command-failure ()
  "Do any necessary clean up when an IDL command fails.
Call this from a function attached to `idlwave-shell-post-command-hook'
that detects the failure of a command.
For example, this is called from `idlwave-shell-set-bp-check' when a
breakpoint can not be set."
  ;; Clear pending commands
  (setq idlwave-shell-pending-commands nil))

(defun idlwave-shell-cont ()
  "Continue executing."
  (interactive)
  (idlwave-shell-send-command ".c" '(idlwave-shell-redisplay 'hide)))

(defun idlwave-shell-go ()
  "Run .GO.  This starts the main program of the last compiled file."
  (interactive)
  (idlwave-shell-send-command ".go" '(idlwave-shell-redisplay 'hide)))

(defun idlwave-shell-return ()
  "Run .RETURN (continue to next return, but stay in subprogram)."
  (interactive)
  (idlwave-shell-send-command ".return" '(idlwave-shell-redisplay 'hide)))

(defun idlwave-shell-skip ()
  "Run .SKIP (skip one line, then step)."
  (interactive)
  (idlwave-shell-send-command ".skip" '(idlwave-shell-redisplay 'hide)))

(defun idlwave-shell-clear-bp (bp)
  "Clear breakpoint BP.
Clears in IDL and in `idlwave-shell-bp-alist'."
  (let ((index (idlwave-shell-bp-get bp)))
    (if index
        (progn
          (idlwave-shell-send-command
           (concat "breakpoint,/clear," 
		   (if (integerp index) (int-to-string index) index)))
	  (idlwave-shell-bp-query)))))

(defun idlwave-shell-current-frame ()
  "Return a list containing the current file name and line point is in.
If in the IDL shell buffer, returns `idlwave-shell-pc-frame'."
  (if (eq (current-buffer) (get-buffer (idlwave-shell-buffer)))
      ;; In IDL shell
      (idlwave-shell-pc-frame)
    ;; In source
    (list (idlwave-shell-file-name (buffer-file-name))
          (save-restriction
            (widen)
            (save-excursion
              (beginning-of-line)
              (1+ (count-lines 1 (point))))))))

(defun idlwave-shell-current-module ()
  "Return the name of the module for the current file.
Returns nil if unable to obtain a module name."
  (if (eq (current-buffer) (get-buffer (idlwave-shell-buffer)))
      ;; In IDL shell
      (nth 2 idlwave-shell-halt-frame)
    ;; In pro file
    (save-restriction
      (widen)
      (save-excursion
        (if (idlwave-prev-index-position)
            (upcase (idlwave-unit-name)))))))

(defun idlwave-shell-clear-current-bp ()
  "Remove breakpoint at current line.
This command can be called from the shell buffer if IDL is currently stopped
at a breakpoint."
  (interactive)
  (let ((bp (idlwave-shell-find-bp (idlwave-shell-current-frame))))
    (if bp (idlwave-shell-clear-bp bp)
      ;; Try moving to beginning of statement
      (save-excursion
        (idlwave-shell-goto-frame)
        (idlwave-beginning-of-statement)
        (setq bp (idlwave-shell-find-bp (idlwave-shell-current-frame)))
        (if bp (idlwave-shell-clear-bp bp)
          (beep)
          (message "Cannot identify breakpoint for this line"))))))

(defun idlwave-shell-to-here ()
  "Set a breakpoint with count 1 then continue."
  (interactive)
  (idlwave-shell-break-here 1)
  (idlwave-shell-cont))

(defun idlwave-shell-break-in (&optional module)
  "Look for a module name near point and set a break point for it.
The command looks for an identifier near point and sets a breakpoint
for the first line of the corresponding module."
  (interactive)
  ;; get the identifier
  (let (module)
    (save-excursion
      (skip-chars-backward "a-zA-Z0-9_$")
      (if (looking-at idlwave-identifier)
	  (setq module (match-string 0))
	(error "No identifier at point")))
    (idlwave-shell-send-command
     idlwave-shell-sources-query
     `(progn
	(idlwave-shell-sources-filter)
	(idlwave-shell-set-bp-in-module ,module))
     'hide)))

(defun idlwave-shell-set-bp-in-module (module)
  "Set breakpoint in module.  Assumes that `idlwave-shell-sources-alist'
contains an entry for that module."
  (let ((source-file (car-safe 
		      (cdr-safe
		       (assoc (upcase module)
			      idlwave-shell-sources-alist))))
	buf)
    (if (or (not source-file)
	    (not (file-regular-p source-file))
	    (not (setq buf
		       (or (idlwave-get-buffer-visiting source-file)
			   (find-file-noselect source-file)))))
	(progn
	  (message "The source file for module %s is probably not compiled"
		   module)
	  (beep))
      (save-excursion
	(set-buffer buf)
	(save-excursion
	  (goto-char (point-min))
	  (let ((case-fold-search t))
	    (if (re-search-forward 
		 (concat "^[ \t]*\\(pro\\|function\\)[ \t]+"
			 (downcase module)
			 "[ \t\n,]") nil t)
		(progn
		  (goto-char (match-beginning 1))
		  (message "Setting breakpoint for module %s" module)
		  (idlwave-shell-break-here))
	      (message "Cannot find module %s in file %s" module source-file)
	      (beep))))))))

(defun idlwave-shell-up ()
  "Run to end of current block.
Sets a breakpoint with count 1 at end of block, then continues."
  (interactive)
  (if (idlwave-shell-pc-frame)
      (save-excursion
        (idlwave-shell-goto-frame)
        ;; find end of subprogram
        (let ((eos (save-excursion
                     (idlwave-beginning-of-subprogram)
                     (idlwave-forward-block)
                     (point))))
          (idlwave-backward-up-block -1)
          ;; move beyond end block line - IDL will not break there.
          ;; That is, you can put a breakpoint there but when IDL does
          ;; break it will report that it is at the next line.
          (idlwave-next-statement)
          (idlwave-end-of-statement)
          ;; Make sure we are not beyond subprogram
          (if (< (point) eos)
              ;; okay
              ()
            ;; Move back inside subprogram
            (goto-char eos)
            (idlwave-previous-statement))
          (idlwave-shell-to-here)))))

(defun idlwave-shell-out ()
  "Attempt to run until this procedure exits.
Runs to the last statement and then steps 1 statement.  Use the .out command."
  (interactive)
  (idlwave-shell-send-command (concat ".o")))

(defun idlwave-shell-help-expression ()
  "Print help on current expression.  See `idlwave-shell-print'."
  (interactive)
  (idlwave-shell-print 'help))

(defun idlwave-shell-mouse-print (event)
  "Call `idlwave-shell-print' at the mouse position."
  (interactive "e")
  (mouse-set-point event)
  (idlwave-shell-print))

(defun idlwave-shell-mouse-help (event)
  "Call `idlwave-shell-print' at the mouse position."
  (interactive "e")
  (mouse-set-point event)
  (idlwave-shell-help-expression))

(defun idlwave-shell-print (&optional help special)
  "Print current expression.  With are HELP, show help on expression.
An expression is an identifier plus 1 pair of matched parentheses
directly following the identifier - an array or function
call.  Alternatively, an expression is the contents of any matched
parentheses when the open parentheses is not directly preceded by an
identifier. If point is at the beginning or within an expression
return the inner-most containing expression, otherwise, return the
preceding expression."
  (interactive "P")
  (save-excursion
    (let (beg end)
      ;; Move to beginning of current or previous expression
      (if (looking-at "\\<\\|(")
          ;; At beginning of expression, don't move backwards unless
          ;; this is at the end of an indentifier.
          (if (looking-at "\\>")
              (backward-sexp))
        (backward-sexp))
      (if (looking-at "\\>")
          ;; Move to beginning of identifier - must be an array or
          ;; function expression.
          (backward-sexp))
      ;; Move to end of expression
      (setq beg (point))
      (forward-sexp)
      (while (looking-at "\\>(\\|\\.")
        ;; an array
        (forward-sexp))
      (setq end (point))
      (when idlwave-shell-expression-overlay
	(move-overlay idlwave-shell-expression-overlay beg end)
	(add-hook 'pre-command-hook 'idlwave-shell-delete-expression-overlay))
      (if special
	  (idlwave-shell-send-command 
	   (concat (if help "help," "print,") (buffer-substring beg end))
	   `(idlwave-shell-process-print-output ,(buffer-substring beg end) 
						idlwave-shell-command-output
						,special)
	   'hide)
	(idlwave-shell-recenter-shell-window)
	(idlwave-shell-send-command 
	 (concat (if help "help," "print,") (buffer-substring beg end)))))))

(defun idlwave-shell-delete-expression-overlay ()
  (condition-case nil
      (if idlwave-shell-expression-overlay
	  (delete-overlay idlwave-shell-expression-overlay))
    (error nil))
  (remove-hook 'pre-command-hook 'idlwave-shell-delete-expression-overlay))

(defvar idlwave-shell-bp-alist nil
  "Alist of breakpoints.
A breakpoint is a cons cell \(\(file line\) . \(\(index module\) data\)\)

The car is the frame for the breakpoint:
file - full path file name.
line - line number of breakpoint - integer.

The first element of the cdr is a list of internal IDL data:
index - the index number of the breakpoint internal to IDL.
module - the module for breakpoint internal to IDL.

Remaining elements of the cdr:
data - Data associated with the breakpoint by idlwave-shell currently
contains two items:

count - number of times to execute breakpoint. When count reaches 0
the breakpoint is cleared and removed from the alist.
command - command to execute when breakpoint is reached, either a 
lisp function to be called with `funcall' with no arguments or a
list to be evaluated with `eval'.")

(defun idlwave-shell-run-region (beg end &optional n)
  "Compile and run the region using the IDL process.
Copies the region to a temporary file `idlwave-shell-temp-pro-file'
and issues the IDL .run command for the file.  Because the
region is compiled and run as a main program there is no
problem with begin-end blocks extending over multiple
lines - which would be a problem if `idlwave-shell-evaluate-region'
was used.  An END statement is appended to the region if necessary.

If there is a prefix argument, display IDL process."
  (interactive "r\nP")
  (let ((oldbuf (current-buffer)))
    (save-excursion
      (set-buffer (idlwave-find-file-noselect
		   idlwave-shell-temp-pro-file))
      (erase-buffer)
      (insert-buffer-substring oldbuf beg end)
      (if (not (save-excursion
                 (idlwave-previous-statement)
                 (idlwave-look-at "\\<end\\>")))
          (insert "\nend\n"))
      (save-buffer 0)))
  (idlwave-shell-send-command (concat ".run " idlwave-shell-temp-pro-file))
  (if n
      (idlwave-display-buffer (idlwave-shell-buffer) 
			      nil (idlwave-shell-shell-frame))))

(defun idlwave-shell-evaluate-region (beg end &optional n)
  "Send region to the IDL process.
If there is a prefix argument, display IDL process.
Does not work for a region with multiline blocks - use
`idlwave-shell-run-region' for this."
  (interactive "r\nP")
  (idlwave-shell-send-command (buffer-substring beg end))
  (if n
      (idlwave-display-buffer (idlwave-shell-buffer) 
			      nil (idlwave-shell-shell-frame))))

(defun idlwave-display-buffer (buf not-this-window-p &optional frame)
  (if (or (< emacs-major-version 20)
	  (and (= emacs-major-version 20)
	       (< emacs-minor-version 3)))
      ;; Only two args.
      (display-buffer buf not-this-window-p)
    ;; Three ares possible.
    (display-buffer buf not-this-window-p frame)))

(defvar idlwave-shell-bp-buffer "*idlwave-shell-bp*"
  "Scratch buffer for parsing IDL breakpoint lists and other stuff.")

(defun idlwave-shell-bp-query ()
  "Reconcile idlwave-shell's breakpoint list with IDL's.
Queries IDL using the string in `idlwave-shell-bp-query'."
  (interactive)
  (idlwave-shell-send-command idlwave-shell-bp-query
			      'idlwave-shell-filter-bp
			      'hide))

(defun idlwave-shell-bp-get (bp &optional item)
  "Get a value for a breakpoint.
BP has the form of elements in idlwave-shell-bp-alist.
Optional second arg ITEM is the particular value to retrieve.
ITEM can be 'file, 'line, 'index, 'module, 'count, 'cmd, or 'data.
'data returns a list of 'count and 'cmd.
Defaults to 'index."
  (cond
   ;; Frame
   ((eq item 'line) (nth 1 (car bp)))
   ((eq item 'file) (nth 0 (car bp)))
   ;; idlwave-shell breakpoint data
   ((eq item 'data) (cdr (cdr bp)))
   ((eq item 'count) (nth 0 (cdr (cdr bp))))
   ((eq item 'cmd) (nth 1 (cdr (cdr bp))))
   ;; IDL breakpoint info
   ((eq item 'module) (nth 1 (car (cdr bp))))
   ;;    index - default
   (t (nth 0 (car (cdr bp))))))

(defun idlwave-shell-filter-bp ()
  "Get the breakpoints from `idlwave-shell-command-output'.
Create `idlwave-shell-bp-alist' updating breakpoint count and command data
from previous breakpoint list."
  (save-excursion
    (set-buffer (get-buffer-create idlwave-shell-bp-buffer))
    (erase-buffer)
    (insert idlwave-shell-command-output)
    (goto-char (point-min))
    (let ((old-bp-alist idlwave-shell-bp-alist))
      (setq idlwave-shell-bp-alist (list nil))
      (if (re-search-forward "^\\s-*Index.*\n\\s-*-" nil t)
          (while (and
                  (not (progn (forward-line) (eobp)))
                  ;; Parse breakpoint line.
                  ;; Breakpoints have the form:
                  ;;  Index Module Line File
                  ;;  All seperated by whitespace.
                  ;;
                  ;;  Add the breakpoint info to the list
                  (re-search-forward
                   "\\s-*\\(\\S-+\\)\\s-+\\(\\S-+\\)\\s-+\\(\\S-+\\)\\s-+\\(\\S-+\\)" nil t))
            (nconc idlwave-shell-bp-alist
                   (list
                    (cons
                     (list
                      (save-match-data
                        (idlwave-shell-file-name
                         (buffer-substring ; file
                          (match-beginning 4) (match-end 4))))
                      (string-to-int    ; line
                       (buffer-substring
                        (match-beginning 3) (match-end 3))))
                     (list
                      (list
                       (buffer-substring ; index
                        (match-beginning 1) (match-end 1))
                       (buffer-substring ; module
                        (match-beginning 2) (match-end 2)))
                      ;; idlwave-shell data: count, command
                      nil nil))))))
      (setq idlwave-shell-bp-alist (cdr idlwave-shell-bp-alist))
      ;; Update count, commands of breakpoints
      (mapcar 'idlwave-shell-update-bp old-bp-alist)))
  ;; Update the breakpoint overlays
  (idlwave-shell-update-bp-overlays)
  ;; Return the new list
  idlwave-shell-bp-alist)

(defun idlwave-shell-update-bp (bp)
  "Update BP data in breakpoint list.
If BP frame is in `idlwave-shell-bp-alist' updates the breakpoint data."
  (let ((match (assoc (car bp) idlwave-shell-bp-alist)))
    (if match (setcdr (cdr match) (cdr (cdr bp))))))

(defun idlwave-shell-set-bp-data (bp data)
  "Set the data of BP to DATA."
  (setcdr (cdr bp) data))

(defun idlwave-shell-bp (frame &optional data module)
  "Create a breakpoint structure containing FRAME and DATA.  Second
and third args, DATA and MODULE, are optional.  Returns a breakpoint
of the format used in `idlwave-shell-bp-alist'.  Can be used in commands
attempting match a breakpoint in `idlwave-shell-bp-alist'."
  (cons frame (cons (list nil module) data)))

(defvar idlwave-shell-old-bp nil
  "List of breakpoints previous to setting a new breakpoint.")

(defun idlwave-shell-sources-bp (bp)
  "Check `idlwave-shell-sources-alist' for source of breakpoint using BP.
If an equivalency is found, return the IDL internal source name.
Otherwise return the filename in bp."
  (let*
      ((bp-file (idlwave-shell-bp-get bp 'file))
       (bp-module (idlwave-shell-bp-get bp 'module))
       (internal-file-list (cdr (assoc bp-module idlwave-shell-sources-alist))))
    (if (and internal-file-list
	     (equal bp-file (nth 0 internal-file-list)))
        (nth 1 internal-file-list)
      bp-file)))

(defun idlwave-shell-set-bp (bp)
  "Try to set a breakpoint BP.

The breakpoint will be placed at the beginning of the statement on the
line specified by BP or at the next IDL statement if that line is not
a statement.
Determines IDL's internal representation for the breakpoint which may
have occured at a different line then used with the breakpoint
command."
  
  ;; Get and save the old breakpoints
  (idlwave-shell-send-command 
   idlwave-shell-bp-query
   '(progn
      (idlwave-shell-filter-bp)
      (setq idlwave-shell-old-bp idlwave-shell-bp-alist))
   'hide)
  ;; Get sources for IDL compiled procedures followed by setting
  ;; breakpoint.
  (idlwave-shell-send-command
   idlwave-shell-sources-query
   (` (progn
	(idlwave-shell-sources-filter)
	(idlwave-shell-set-bp2 (quote (, bp)))))
   'hide))

(defun idlwave-shell-set-bp2 (bp)
  "Use results of breakpoint and sources query to set bp.
Use the count argument with IDLs breakpoint command.
We treat a count of 1 as a temporary breakpoint. 
Counts greater than 1 use the IDL AFTER=count keyword to break
only after reaching the statement count times."
  (let*
      ((arg (idlwave-shell-bp-get bp 'count))
       (key (cond
             ((not (and arg (numberp arg))) "")
             ((= arg 1)
              ",/once")
             ((> arg 1)
              (format ",after=%d" arg))))
       (line (idlwave-shell-bp-get bp 'line)))
    (idlwave-shell-send-command
     (concat "breakpoint,'" 
	     (idlwave-shell-sources-bp bp) "',"
	     (if (integerp line) (setq line (int-to-string line)))
	     key)
     ;; Check for failure and look for breakpoint in IDL's list
     (` (progn
          (if (idlwave-shell-set-bp-check (quote (, bp)))
              (idlwave-shell-set-bp3 (quote (, bp)))))
        )
     ;; do not hide output 
     nil
     'preempt)))

(defun idlwave-shell-set-bp3 (bp)
  "Find the breakpoint in IDL's internal list of breakpoints."
  (idlwave-shell-send-command idlwave-shell-bp-query
			      (` (progn
				   (idlwave-shell-filter-bp)
				   (idlwave-shell-new-bp (quote (, bp)))))
			      'hide
			      'preempt))

(defun idlwave-shell-find-bp (frame)
  "Return breakpoint from `idlwave-shell-bp-alist' for frame.
Returns nil if frame not found."
  (assoc frame idlwave-shell-bp-alist))

(defun idlwave-shell-new-bp (bp)
  "Find the new breakpoint in IDL's list and update with DATA.
The actual line number for a breakpoint in IDL may be different than
the line number used with the IDL breakpoint command.
Looks for a new breakpoint index number in the list.  This is
considered the new breakpoint if the file name of frame matches."
  (let ((obp-index (mapcar 'idlwave-shell-bp-get idlwave-shell-old-bp))
        (bpl idlwave-shell-bp-alist))
    (while (and (member (idlwave-shell-bp-get (car bpl)) obp-index)
                (setq bpl (cdr bpl))))
    (if (and
         (not bpl)
         ;; No additional breakpoint.
         ;; Need to check if we are just replacing a breakpoint.
         (setq bpl (assoc (car bp) idlwave-shell-bp-alist)))
        (setq bpl (list bpl)))
    (if (and bpl
             (equal (idlwave-shell-bp-get (setq bpl (car bpl)) 'file)
                    (idlwave-shell-bp-get bp 'file)))
        ;; Got the breakpoint - add count, command to it.
        ;; This updates `idlwave-shell-bp-alist' because a deep copy was
        ;; not done for bpl.
        (idlwave-shell-set-bp-data bpl (idlwave-shell-bp-get bp 'data))
      (beep)
      (message "Failed to identify breakpoint in IDL"))))

(defvar idlwave-shell-bp-overlays nil
  "List of overlays marking breakpoints")

(defun idlwave-shell-update-bp-overlays ()
  "Update the overlays which mark breakpoints in the source code.
Existing overlays are recycled, in order to minimize consumption."
  ;; FIXME: we could cache them all, but that would be more work.
  (when idlwave-shell-mark-breakpoints
    (let ((bp-list idlwave-shell-bp-alist)
	  (ov-list idlwave-shell-bp-overlays)
	  ov bp)
      ;; Delete the old overlays from their buffers
      (while (setq ov (pop ov-list))
	(delete-overlay ov))
      (setq ov-list idlwave-shell-bp-overlays
	    idlwave-shell-bp-overlays nil)
      (while (setq bp (pop bp-list))
	(save-excursion
	  (idlwave-shell-goto-frame (car bp))
	  (let* ((end (progn (end-of-line 1) (point)))
		 (beg (progn (beginning-of-line 1) (point)))
		 (ov (or (pop ov-list)
			 (idlwave-shell-make-new-bp-overlay))))
	    (move-overlay ov beg end)
	    (push ov idlwave-shell-bp-overlays)))))))

(defvar idlwave-shell-bp-glyph)
(defun idlwave-shell-make-new-bp-overlay ()
  "Make a new overlay for highlighting breakpoints.
This stuff is stringly dependant upon the version of Emacs."
  (let ((ov (make-overlay 1 1)))
    (if (featurep 'xemacs)
	;; This is XEmacs
	(progn
	  (cond 
	   ((eq (console-type) 'tty)
	    ;; tty's cannot display glyphs
	    (set-extent-property ov 'face 'idlwave-shell-bp-face))
	   ((and (memq idlwave-shell-mark-breakpoints '(t glyph))
		 idlwave-shell-bp-glyph)
	    ;; use the glyph
	    (set-extent-property ov 'begin-glyph idlwave-shell-bp-glyph))
	   (idlwave-shell-mark-breakpoints
	    ;; use the face
	    (set-extent-property ov 'face 'idlwave-shell-bp-face))
	   (t 
	    ;; no marking
	    nil))
	  (set-extent-priority ov -1))  ; make stop line face prevail
      ;; This is Emacs
      (cond
       (window-system
	(if (and (memq idlwave-shell-mark-breakpoints '(t glyph))
		 idlwave-shell-bp-glyph)   ; this var knows if glyph's possible
	    ;; use a glyph
	    (let ((string "@"))
	      (put-text-property 0 1
				 'display (cons nil idlwave-shell-bp-glyph)
				 string)
	      (overlay-put ov 'before-string string))
	  (overlay-put ov 'face 'idlwave-shell-bp-face)))
       (idlwave-shell-mark-breakpoints
	;; use a face
	(overlay-put ov 'face 'idlwave-shell-bp-face))
       (t 
	;; No marking
	nil)))
    ov))

(defun idlwave-shell-edit-default-command-line (arg)
  "Edit the current execute command."
  (interactive "P")
  (setq idlwave-shell-command-line-to-execute
	(read-string "IDL> " idlwave-shell-command-line-to-execute)))

(defun idlwave-shell-execute-default-command-line (arg)
  "Execute a command line.  On first use, ask for the command.
Also with prefix arg, ask for the command.  You can also uase the command
`idlwave-shell-edit-default-command-line' to edit the line."
  (interactive "P")
  (if (or (not idlwave-shell-command-line-to-execute)
	  arg)
      (setq idlwave-shell-command-line-to-execute 
	    (read-string "IDL> " idlwave-shell-command-line-to-execute)))
  (idlwave-shell-reset nil)
  (idlwave-shell-send-command idlwave-shell-command-line-to-execute
			      '(idlwave-shell-redisplay 'hide)))

(defun idlwave-shell-save-and-run ()
  "Save file and run it in IDL.
Runs `save-buffer' and sends a '.RUN' command for the associated file to IDL.
When called from the shell buffer, re-run the file which was last handled by
one of the save-and-.. commands."  
  (interactive)
  (idlwave-shell-save-and-action 'run))

(defun idlwave-shell-save-and-compile ()
  "Save file and run it in IDL.
Runs `save-buffer' and sends '.COMPILE' command for the associated file to IDL.
When called from the shell buffer, re-compile the file which was last handled by
one of the save-and-.. commands."
  (interactive)
  (idlwave-shell-save-and-action 'compile))

(defun idlwave-shell-save-and-batch ()
  "Save file and batch it in IDL.
Runs `save-buffer' and sends a '@file' command for the associated file to IDL.
When called from the shell buffer, re-batch the file which was last handled by
one of the save-and-.. commands."  
  (interactive)
  (idlwave-shell-save-and-action 'batch))

(defun idlwave-shell-save-and-action (action)
  "Save file and compile it in IDL.
Runs `save-buffer' and sends a '.RUN' command for the associated file to IDL.
When called from the shell buffer, re-compile the file which was last
handled by this command."
  ;; Remove the stop overlay.
  (if idlwave-shell-stop-line-overlay
      (delete-overlay idlwave-shell-stop-line-overlay))
  (setq overlay-arrow-string nil)
  (let (buf)
    (cond
     ((eq major-mode 'idlwave-mode)
      (save-buffer)
      (setq idlwave-shell-last-save-and-action-file (buffer-file-name)))
     (idlwave-shell-last-save-and-action-file
      (if (setq buf (idlwave-get-buffer-visiting
		     idlwave-shell-last-save-and-action-file))
	  (save-excursion
	    (set-buffer buf)
	    (save-buffer))))
     (t (setq idlwave-shell-last-save-and-action-file
	      (read-file-name "File: ")))))
  (if (file-regular-p idlwave-shell-last-save-and-action-file)
      (progn
	(idlwave-shell-send-command
	 (concat (cond ((eq action 'run)     ".run ")
		       ((eq action 'compile) ".compile ")
		       ((eq action 'batch)   "@")
		       (t (error "Unknown action %s" action)))
		 idlwave-shell-last-save-and-action-file)
	 nil nil)
	(idlwave-shell-bp-query))
    (let ((msg (format "No such file %s" 
		       idlwave-shell-last-save-and-action-file)))
      (setq idlwave-shell-last-save-and-action-file nil)
      (error msg))))

(defvar idlwave-shell-sources-query "help,/source"
  "IDL command to obtain source files for compiled procedures.")

(defvar idlwave-shell-sources-alist nil
  "Alist of IDL procedure names and compiled source files.
Elements of the alist have the form:

  (module name . (source-file-truename idlwave-internal-filename)).")

(defun idlwave-shell-sources-query ()
  "Determine source files for IDL compiled procedures.
Queries IDL using the string in `idlwave-shell-sources-query'."
  (interactive)
  (idlwave-shell-send-command idlwave-shell-sources-query
			      'idlwave-shell-sources-filter
			      'hide))

(defun idlwave-shell-sources-filter ()
  "Get source files from `idlwave-shell-sources-query' output.
Create `idlwave-shell-sources-alist' consisting of 
list elements of the form:
 (module name . (source-file-truename idlwave-internal-filename))."
  (save-excursion
    (set-buffer (get-buffer-create idlwave-shell-bp-buffer))
    (erase-buffer)
    (insert idlwave-shell-command-output)
    (goto-char (point-min))
    (let (cpro cfun)
      (if (re-search-forward "Compiled Procedures:" nil t)
          (progn
            (forward-line) ; Skip $MAIN$
            (setq cpro (point))))
      (if (re-search-forward "Compiled Functions:" nil t)
          (progn
            (setq cfun (point))
            (setq idlwave-shell-sources-alist
                  (append
                   ;; compiled procedures
                   (progn
                     (beginning-of-line)
                     (narrow-to-region cpro (point))
                     (goto-char (point-min))
                     (idlwave-shell-sources-grep))
                   ;; compiled functions
                   (progn
                     (widen)
                     (goto-char cfun)
                     (idlwave-shell-sources-grep)))))))))

(defun idlwave-shell-sources-grep ()
  (save-excursion
    (let ((al (list nil)))
      (while (and
              (not (progn (forward-line) (eobp)))
              (re-search-forward
               "\\s-*\\(\\S-+\\)\\s-+\\(\\S-+\\)" nil t))
        (nconc al
               (list
                (cons
                 (buffer-substring      ; name
                  (match-beginning 1) (match-end 1))
                 (let ((internal-filename
                        (buffer-substring       ; source
                         (match-beginning 2) (match-end 2))))
                   (list
                    (idlwave-shell-file-name internal-filename)
                    internal-filename))
		 ))))
      (cdr al))))


(defun idlwave-shell-clear-all-bp ()
  "Remove all breakpoints in IDL."
  (interactive)
  (idlwave-shell-send-command
   idlwave-shell-bp-query
   '(progn
      (idlwave-shell-filter-bp)
      (mapcar 'idlwave-shell-clear-bp idlwave-shell-bp-alist))
   'hide))

(defun idlwave-shell-list-all-bp ()
  "List all breakpoints in IDL."
  (interactive)
  (idlwave-shell-send-command
   idlwave-shell-bp-query))

(defvar idlwave-shell-error-last 0
  "Position of last syntax error in `idlwave-shell-error-buffer'.")

(defun idlwave-shell-goto-next-error ()
  "Move point to next IDL syntax error."
  (interactive)
  (let (frame col)
    (save-excursion
      (set-buffer idlwave-shell-error-buffer)
      (goto-char idlwave-shell-error-last)
      (if (or (re-search-forward idlwave-shell-syntax-error nil t)
              (re-search-forward idlwave-shell-other-error nil t))
          (progn
            (setq frame
                  (list
                   (save-match-data
                     (idlwave-shell-file-name
                      (buffer-substring (match-beginning 1) (match-end 1))))
                   (string-to-int
                    (buffer-substring (match-beginning 2)
                                      (match-end 2)))))
            ;; Try to find the column of the error
            (save-excursion
              (setq col
                    (if (re-search-backward "\\^" nil t)
                        (current-column)
                      0)))))
      (setq idlwave-shell-error-last (point)))
    (if frame
        (progn
          (idlwave-shell-display-line frame col))
      (beep)
      (message "No more errors."))))

(defun idlwave-shell-file-name (name)
  "If idlwave-shell-use-truename is non-nil, convert file name to true name.
Otherwise, just expand the file name."
  (let ((def-dir (if (eq major-mode 'idlwave-shell-mode)
		     default-directory
		   idlwave-shell-default-directory)))
    (if idlwave-shell-use-truename 
	(file-truename name def-dir) 
      (expand-file-name name def-dir))))


;; Keybindings --------------------------------------------------------------

(defvar idlwave-shell-mode-map (copy-keymap comint-mode-map)
  "Keymap for idlwave-mode.")
(defvar idlwave-shell-mode-prefix-map (make-sparse-keymap))
(fset 'idlwave-shell-mode-prefix-map idlwave-shell-mode-prefix-map)

;(define-key idlwave-shell-mode-map "\M-?" 'comint-dynamic-list-completions)
;(define-key idlwave-shell-mode-map "\t" 'comint-dynamic-complete)
(define-key idlwave-shell-mode-map "\t"       'idlwave-shell-complete)
(define-key idlwave-shell-mode-map "\M-\t"    'idlwave-shell-complete)
(define-key idlwave-shell-mode-map "\C-c\C-s" 'idlwave-shell)
(define-key idlwave-shell-mode-map "\C-c?"    'idlwave-routine-info)
(define-key idlwave-shell-mode-map "\C-c\C-i" 'idlwave-update-routine-info)
(define-key idlwave-shell-mode-map "\C-c="    'idlwave-resolve)
(define-key idlwave-shell-mode-map "\C-c\C-v" 'idlwave-find-module)
(define-key idlwave-shell-mode-map idlwave-shell-prefix-key
  'idlwave-shell-debug-map)

;; The following set of bindings is used to bind the debugging keys.
;; If `idlwave-shell-activate-prefix-keybindings' is non-nil, the first key
;; in the list gets bound the C-c C-d prefix map.
;; If `idlwave-shell-activate-alt-keybindings' is non-nil, the second key
;; in the list gets bound directly in both idlwave-mode-map and 
;; idlwave-shell-mode-map.

;; Used keys:   abcde  hi klmnopqrs u wxyz 
;; Unused keys:      fg  j         t v  
(let ((specs
 '(([(control ?b)]   [(alt ?b)]   idlwave-shell-break-here)
   ([(control ?i)]   [(alt ?i)]   idlwave-shell-break-in)
   ([(control ?d)]   [(alt ?d)]   idlwave-shell-clear-current-bp)
   ([(control ?a)]   [(alt ?a)]   idlwave-shell-clear-all-bp)
   ([(control ?s)]   [(alt ?s)]   idlwave-shell-step)
   ([(control ?n)]   [(alt ?n)]   idlwave-shell-stepover)
   ([(control ?k)]   [(alt ?k)]   idlwave-shell-skip)
   ([(control ?u)]   [(alt ?u)]   idlwave-shell-up)
   ([(control ?o)]   [(alt ?o)]   idlwave-shell-out)
   ([(control ?m)]   [(alt ?m)]   idlwave-shell-return)
   ([(control ?h)]   [(alt ?h)]   idlwave-shell-to-here)
   ([(control ?r)]   [(alt ?r)]   idlwave-shell-cont)
   ([(control ?y)]   [(alt ?y)]   idlwave-shell-execute-default-command-line)
   ([(control ?z)]   [(alt ?z)]   idlwave-shell-reset)
   ([(control ?q)]   [(alt ?q)]   idlwave-shell-quit)
   ([(control ?p)]   [(alt ?p)]   idlwave-shell-print)
   ([(??)]           [(alt ??)]   idlwave-shell-help-expression)
   ([(control ?c)]   [(alt ?c)]   idlwave-shell-save-and-run)
   ([(        ?@)]   [(alt ?@)]   idlwave-shell-save-and-batch)
   ([(control ?x)]   [(alt ?x)]   idlwave-shell-goto-next-error)
   ([(control ?e)]   [(alt ?e)]   idlwave-shell-run-region)
   ([(control ?w)]   [(alt ?w)]   idlwave-shell-resync-dirs)
   ([(control ?l)]   [(alt ?l)]   idlwave-shell-redisplay)
   ([(control ?t)]   [(alt ?t)]   idlwave-shell-toggle-toolbar)
   ([(control up)]   [(alt up)]   idlwave-shell-stack-up)
   ([(control down)] [(alt down)] idlwave-shell-stack-down)))   
      s k1 k2 cmd)
  (while (setq s (pop specs))
    (setq k1  (nth 0 s)
	  k2  (nth 1 s)
	  cmd (nth 2 s))
    (when idlwave-shell-activate-prefix-keybindings
      (and k1 (define-key idlwave-shell-mode-prefix-map k1 cmd)))
    (when idlwave-shell-activate-alt-keybindings
      (and k2 (define-key idlwave-mode-map       k2 cmd))
      (and k2 (define-key idlwave-shell-mode-map k2 cmd)))))

;; Enter the prefix map at the two places.
(fset 'idlwave-debug-map       idlwave-shell-mode-prefix-map)
(fset 'idlwave-shell-debug-map idlwave-shell-mode-prefix-map)

;; The Menus --------------------------------------------------------------

(defvar idlwave-shell-menu-def
  '("Debug"
    ["Save and .RUN" idlwave-shell-save-and-run
     (or (eq major-mode 'idlwave-mode)
	 idlwave-shell-last-save-and-action-file)]
    ["Save and .COMPILE" idlwave-shell-save-and-compile
     (or (eq major-mode 'idlwave-mode)
	 idlwave-shell-last-save-and-action-file)]
    ["Save and @Batch" idlwave-shell-save-and-batch
     (or (eq major-mode 'idlwave-mode)
	 idlwave-shell-last-save-and-action-file)]
    ["Goto Next Error" idlwave-shell-goto-next-error t]
    "--"
    ["Execute Default Cmd" idlwave-shell-execute-default-command-line t]
    ["Edit Default Cmd" idlwave-shell-edit-default-command-line t]
    "--"
    ["Set Breakpoint" idlwave-shell-break-here
     (eq major-mode 'idlwave-mode)]
    ["Break in Module" idlwave-shell-break-in t]
    ["Clear Breakpoint" idlwave-shell-clear-current-bp t]
    ["Clear All Breakpoints" idlwave-shell-clear-all-bp t]
    ["List  All Breakpoints" idlwave-shell-list-all-bp t]
    "--"
    ["Step (into)" idlwave-shell-step t]
    ["Step (over)" idlwave-shell-stepover t]
    ["Skip One Statement" idlwave-shell-skip t]
    ["Continue" idlwave-shell-cont t]
    ("Continue to"
     ["End of Block" idlwave-shell-up t]
     ["End of Subprog" idlwave-shell-return t]
     ["End of Subprog+1" idlwave-shell-out t]
     ["Here (Cursor Line)" idlwave-shell-to-here
      (eq major-mode 'idlwave-mode)])
    "--"
    ["Print expression" idlwave-shell-print t]
    ["Help on expression" idlwave-shell-help-expression t]
    ["Evaluate Region" idlwave-shell-evaluate-region 
     (eq major-mode 'idlwave-mode)]
    ["Run Region" idlwave-shell-run-region (eq major-mode 'idlwave-mode)]
    "--"
    ["Redisplay" idlwave-shell-redisplay t]
    ["Stack Up" idlwave-shell-stack-up t]
    ["Stack Down" idlwave-shell-stack-down t]
    "--"
    ["Update Working Dir" idlwave-shell-resync-dirs t]
    ["Reset IDL" idlwave-shell-reset t]
    "--"
    ["Toggle Toolbar" idlwave-shell-toggle-toolbar t]
    ["Exit IDL" idlwave-shell-quit t]))

(if (or (featurep 'easymenu) (load "easymenu" t))
    (progn
      (easy-menu-define
       idlwave-shell-mode-menu idlwave-shell-mode-map "IDL shell menus"
       idlwave-shell-menu-def)
      (easy-menu-define 
       idlwave-mode-debug-menu idlwave-mode-map "IDL debugging menus"
       idlwave-shell-menu-def)
      (save-excursion
	(mapcar (lambda (buf)
		  (set-buffer buf)
		  (if (eq major-mode 'idlwave-mode)
		      (progn
			(easy-menu-remove idlwave-mode-debug-menu)
			(easy-menu-add idlwave-mode-debug-menu))))
		(buffer-list)))))

;; The Breakpoint Glyph -------------------------------------------------------

(defvar idlwave-shell-bp-glyph nil
  "The glyph to mark breakpoint lines in the source code.")

(let ((image-string "/* XPM */
static char * file[] = {
\"14 12 3 1\",
\" 	c #FFFFFFFFFFFF s backgroundColor\",
\".	c #4B4B4B4B4B4B\",
\"R	c #FFFF00000000\",
\"              \",
\"              \",
\"    RRRR      \",
\"   RRRRRR     \",
\"  RRRRRRRR    \",
\"  RRRRRRRR    \",
\"  RRRRRRRR    \",
\"  RRRRRRRR    \",
\"   RRRRRR     \",
\"    RRRR      \",
\"              \",
\"              \"};"))
      
  (setq idlwave-shell-bp-glyph
	(cond ((and (featurep 'xemacs)
		    (featurep 'xpm))
	       (make-glyph image-string))
	      ((and (not (featurep 'xemacs))
		    (fboundp 'image-type-available-p)
		    (image-type-available-p 'xpm))
	       (list 'image :type 'xpm :data image-string))
	      (t nil))))

(provide 'idlwave-shell)

;;; Load the toolbar when wanted by the user.

(defun idlwave-shell-toggle-toolbar ()
  "Toggle the display of the debugging toolbar."
  (interactive)
  (if (featurep 'idlwave-toolbar)
      (idlwave-toolbar-toggle)
    (require 'idlwave-toolbar)
    (idlwave-toolbar-toggle)))


(when idlwave-shell-use-toolbar
  (or (load "idlwave-toolbar" t)
      (message
       "Tried to load file `idlwave-toolbar.el', but file does not exist")))

;;; idlwave-shell.el ends here