mirror of
https://git.savannah.gnu.org/git/emacs.git
synced 2024-12-13 09:32:47 +00:00
2456 lines
93 KiB
EmacsLisp
2456 lines
93 KiB
EmacsLisp
;;; idlw-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 <chase@att.com>
|
||
;; Maintainer: Carsten Dominik <dominik@strw.leidenuniv.nl>
|
||
;; Version: 3.11
|
||
;; Date: $Date: 2000/01/03 14:27:03 $
|
||
;; 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 "idlw-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 'idlw-shell)
|
||
(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 "idlw-toolbar" t)
|
||
(message
|
||
"Tried to load file `idlw-toolbar.el', but file does not exist")))
|
||
|
||
;;; idlw-shell.el ends here
|
||
|
||
|