(require 'comint)
(require 'idlwave)
(eval-when-compile (require 'cl))
(defvar idlwave-shell-have-new-custom nil)
(eval-and-compile
(condition-case () (require 'custom) (error nil))
(if (and (featurep 'custom)
(fboundp 'custom-declare-variable)
(fboundp 'defface))
(setq idlwave-shell-have-new-custom t)
(defmacro defgroup (&rest args) nil)
(defmacro defcustom (var value doc &rest args)
`(defvar ,var ,value ,doc))))
(defgroup idlwave-shell-general-setup nil
"General setup of the Shell interaction for IDLWAVE/Shell."
:prefix "idlwave-shell"
:group 'idlwave)
(defcustom idlwave-shell-prompt-pattern "^\r? ?IDL> "
"*Regexp to match IDL prompt at beginning of a line.
For example, \"^\r?IDL> \" or \"^\r?WAVE> \".
The \"^\r?\" is needed, to indicate the beginning of the line, with
optional return character (which IDL seems to output randomly).
This variable is used to initialize `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-use-dedicated-window nil
"*Non-nil means, never replace the shell frame with another buffer."
:group 'idlwave-shell-general-setup
:type 'boolean)
(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-raise-frame t
"*Non-nil means, `idlwave-shell' raises the frame showing the shell window."
:group 'idlwave-shell-general-setup
:type 'boolean)
(defcustom idlwave-shell-arrows-do-history t
"*Non-nil means UP and DOWN arrows move through command history.
This variable can have 3 values:
nil Arrows just move the cursor
t Arrows force the cursor back to the current command line and
walk the history
'cmdline When the cursor is in the current command line, arrows walk the
history. Everywhere else in the buffer, arrows move the cursor."
:group 'idlwave-shell-general-setup
:type '(choice
(const :tag "never" nil)
(const :tag "everywhere" t)
(const :tag "in command line only" cmdline)))
(defcustom idlwave-shell-use-toolbar t
"*Non-nil means, use the debugging toolbar in all IDL related buffers.
Starting the shell will then add the toolbar to all idlwave-mode buffers.
Exiting the shell will removed everywhere.
Available on XEmacs and on Emacs 21.x or later.
At any time you can toggle the display of the toolbar with
`C-c C-d C-t' (`idlwave-shell-toggle-toolbar')."
: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 using `make-temp-file'
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.
Setting 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-automatic-electric-debug 'breakpoint
"Enter the electric-debug minor mode automatically.
This occurs at a breakpoint or any other halt. The mode is exited
upon return to the main level. Can be set to 'breakpoint to enter
electric debug mode only when breakpoints are tripped."
:group 'idlwave-shell-general-setup
:type '(choice
(const :tag "never" nil)
(const :tag "always" t)
(const :tag "for breakpoints only" breakpoint)))
(defcustom idlwave-shell-electric-zap-to-file t
"When entering electric debug mode, select the window displaying the
file at which point is stopped. This takes point away from the shell
window, but is useful for stepping, etc."
:group 'idlwave-shell-general-setup
:type 'boolean)
(defvar idlwave-shell-activate-alt-keybindings nil
"Obsolete variable. See `idlwave-shell-debug-modifiers'.")
(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 different 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)
(defcustom idlwave-shell-graphics-window-size '(500 400)
"Size of IDL graphics windows popped up by special IDLWAVE command.
The command is `C-c C-d C-f' and accepts as a prefix the window nr.
A command like `WINDOW,N,xsize=XX,ysize=YY' is sent to IDL."
:group 'idlwave-shell-general-setup
:type '(list
(integer :tag "x size")
(integer :tag "y size")))
(defgroup idlwave-shell-command-setup nil
"Setup for command parameters of the Shell interaction for IDLWAVE."
:prefix "idlwave-shell"
:group 'idlwave)
(defcustom idlwave-shell-initial-commands "!more=0 & defsysv,'!ERROR_STATE',EXISTS=__e & if __e then begin & !ERROR_STATE.MSG_PREFIX=\"% \" & delvar,__e & endif"
"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-command-setup
:type 'string)
(defcustom idlwave-shell-save-command-history t
"Non-nil means preserve command history between sessions.
The file `idlwave-shell-command-history-file' is used to save and restore
the history."
:group 'idlwave-shell-command-setup
:type 'boolean)
(defcustom idlwave-shell-command-history-file "idlwhist"
"The file in which the command history of the idlwave shell is saved.
In order to change the size of the history, see the variable
`comint-input-ring-size'.
The history is only saved if the variable `idlwave-shell-save-command-history'
is non-nil."
:group 'idlwave-shell-command-setup
:type 'file)
(defcustom idlwave-shell-show-commands
'(run misc breakpoint)
"*A list of command types to show output from in the shell.
Possibilities are 'run, 'debug, 'breakpoint, and 'misc. Unselected
types are not displayed in the shell. The type 'everything causes all
the copious shell traffic to be displayed."
:group 'idlwave-shell-command-setup
:type '(choice
(const everything)
(set :tag "Checklist" :greedy t
(const :tag "All .run and .compile commands" run)
(const :tag "All breakpoint commands" breakpoint)
(const :tag "All debug and stepping commands" debug)
(const :tag "Close, window, retall, etc. commands" misc))))
(defcustom idlwave-shell-max-print-length 200
"Maximum number of array elements to print when examining."
:group 'idlwave-shell-command-setup
:type 'integer)
(defcustom idlwave-shell-examine-alist
`(("Print" . ,(concat "idlwave_print_safe,___,"
(number-to-string
idlwave-shell-max-print-length)))
("Help" . "help,___")
("Structure Help" . "help,___,/STRUCTURE")
("Dimensions" . "print,size(___,/DIMENSIONS)")
("Type" . "print,size(___,/TNAME)")
("N_Elements" . "print,n_elements(___)")
("All Size Info" . "help,(__IWsz__=size(___,/STRUCTURE)),/STRUCTURE & print,__IWsz__.DIMENSIONS")
("Ptr Valid" . "print,ptr_valid(___)")
("Arg Present" . "print,arg_present(___)")
("Widget Valid" . "print,widget_info(___,/VALID)")
("Widget Geometry" . "help,widget_info(___,/GEOMETRY)"))
"Alist of special examine commands for popup selection.
The keys are used in the selection popup created by
`idlwave-shell-examine-select', and the corresponding value is sent as
a command to the shell, with special sequence `___' replaced by the
expression being examined."
:group 'idlwave-shell-command-setup
:type '(repeat
(cons
(string :tag "Label ")
(string :tag "Command"))))
(defvar idlwave-shell-print-expression-function nil
"*OBSOLETE VARIABLE, is no longer used.")
(defcustom idlwave-shell-separate-examine-output t
"*Non-nil mean, put output of examine commands in their own buffer."
:group 'idlwave-shell-command-setup
:type 'boolean)
(defcustom idlwave-shell-comint-settings
'((comint-scroll-to-bottom-on-input . t)
(comint-scroll-to-bottom-on-output . t)
(comint-scroll-show-maximum-output . nil)
(comint-prompt-read-only . t))
"Alist of special settings for the comint variables in the IDLWAVE Shell.
Each entry is a cons cell with the name of a variable and a value.
The function `idlwave-shell-mode' will make local variables out of each entry.
Changes to this variable will only be active when the shell buffer is
newly created."
:group 'idlwave-shell-command-setup
:type '(repeat
(cons variable sexp)))
(defcustom idlwave-shell-query-for-class t
"*Non-nil means query the shell for object class on object completions."
:group 'idlwave-shell-command-setup
:type 'boolean)
(defcustom idlwave-shell-use-input-mode-magic nil
"*Non-nil means, IDLWAVE should check for input mode spells in output.
The spells are strings printed by your IDL program and matched
by the regular expressions in `idlwave-shell-input-mode-spells'.
When these expressions match, IDLWAVE switches to character input mode and
back, respectively. See `idlwave-shell-input-mode-spells' for details."
:group 'idlwave-shell-command-setup
:type 'boolean)
(defcustom idlwave-shell-input-mode-spells
'("^<onechar>$" "^<chars>$" "^</chars>$")
"The three regular expressions which match the magic spells for input modes.
When the first regexp matches in the output stream of IDL, IDLWAVE
prompts for a single character and sends it immediately to IDL, similar
to the command \\[idlwave-shell-send-char].
When the second regexp matches, IDLWAVE switches to a blocking
single-character input mode. This is the same mode which can be entered
manually with \\[idlwave-shell-char-mode-loop].
This input mode exits when the third regexp matches in the output,
or when the IDL prompt is encountered.
The variable `idlwave-shell-use-input-mode-magic' must be non-nil to enable
scanning for these expressions. If the IDL program produces lots of
output, shell operation may be slowed down.
This mechanism is useful for correct interaction with the IDL function
GET_KBRD, because in normal operation IDLWAVE only sends \\n terminated
strings. Here is some example code which makes use of the default spells.
print,'<chars>' ; Make IDLWAVE switch to character mode
REPEAT BEGIN
A = GET_KBRD(1)
PRINT, BYTE(A)
ENDREP UNTIL A EQ 'q'
print,'</chars>' ; Make IDLWAVE switch back to line mode
print,'Quit the program, y or n?'
print,'<onechar>' ; Ask IDLWAVE to send one character
answer = GET_KBRD(1)
Since the IDLWAVE shell defines the system variable `!IDLWAVE_VERSION',
you could actually check if you are running under Emacs before printing
the magic strings. Here is a procedure which uses this.
Usage:
======
idlwave_char_input ; Make IDLWAVE send one character
idlwave_char_input,/on ; Start the loop to send characters
idlwave_char_input,/off ; End the loop to send characters
pro idlwave_char_input,on=on,off=off
;; Test if we are running under Emacs
defsysv,'!idlwave_version',exists=running_emacs
if running_emacs then begin
if keyword_set(on) then print,'<chars>' $
else if keyword_set(off) then print,'</chars>' $
else print,'<onechar>'
endif
end"
:group 'idlwave-shell-command-setup
:type '(list
(regexp :tag "One-char regexp")
(regexp :tag "Char-mode regexp")
(regexp :tag "Line-mode regexp")))
(defcustom idlwave-shell-breakpoint-popup-menu t
"*If non-nil, provide a menu on mouse-3 on breakpoint lines, and
popup help text on the line."
:group 'idlwave-shell-command-setup
:type 'boolean)
(defcustom idlwave-shell-reset-no-prompt nil
"If non-nil, skip the yes/no prompt when resetting the IDL session."
:group 'idlwave-shell-command-setup
:type 'boolean)
(defgroup idlwave-shell-highlighting-and-faces nil
"Highlighting and Faces used by the IDLWAVE Shell mode."
:prefix "idlwave-shell"
: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. Valid 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 thinks 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.
In 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-electric-stop-color "Violet"
"*The color for the default face or overlay arrow when stopped."
:group 'idlwave-shell-highlighting-and-faces
:type 'string)
(defcustom idlwave-shell-electric-stop-line-face
(prog1
(copy-face 'modeline 'idlwave-shell-electric-stop-line)
(set-face-background 'idlwave-shell-electric-stop-line
idlwave-shell-electric-stop-color)
(condition-case nil
(set-face-foreground 'idlwave-shell-electric-stop-line nil)
(error nil)))
"*The face for `idlwave-shell-stop-line-overlay' when in electric debug mode.
Allows you to choose the font, color and other properties for the line
where IDL is stopped, when in Electric Debug Mode."
:group 'idlwave-shell-highlighting-and-faces
:type 'symbol)
(defcustom idlwave-shell-mark-breakpoints t
"*Non-nil means, mark breakpoints in the source files.
Valid 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
"*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 (not idlwave-shell-have-new-custom)
(copy-face 'underline 'idlwave-shell-bp)
(defface idlwave-shell-bp
'((((class color)) (:foreground "Black" :background "Pink"))
(t (:underline t)))
"Face for highlighting lines with breakpoints."
:group 'idlwave-shell-highlighting-and-faces))
(defcustom idlwave-shell-disabled-breakpoint-face
'idlwave-shell-disabled-bp
"*The face for disabled 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 (not idlwave-shell-have-new-custom)
(copy-face 'underline 'idlwave-shell-disabled-bp)
(defface idlwave-shell-disabled-bp
'((((class color)) (:foreground "Black" :background "gray"))
(t (:underline t)))
"Face for highlighting lines with breakpoints."
:group 'idlwave-shell-highlighting-and-faces))
(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-output-face 'secondary-selection
"*The face for `idlwave-shell-output-overlay'.
Allows you to choose the font, color and other properties for
the expression output by IDL."
:group 'idlwave-shell-highlighting-and-faces
:type 'symbol)
(defvar comint-last-input-start)
(defvar comint-last-input-end)
(defvar idlwave-shell-temp-pro-file nil
"Absolute pathname for temporary IDL file for compiling regions")
(defvar idlwave-shell-temp-rinfo-save-file nil
"Absolute pathname for temporary IDL file save file for routine_info.
This is used to speed up the reloading of the routine info procedure
before use by the shell.")
(defun idlwave-shell-temp-file (type)
"Return a temp file, creating it if necessary.
TYPE is either 'pro' or 'rinfo', and `idlwave-shell-temp-pro-file' or
`idlwave-shell-temp-rinfo-save-file' is set (respectively)."
(cond
((eq type 'rinfo)
(or idlwave-shell-temp-rinfo-save-file
(setq idlwave-shell-temp-rinfo-save-file
(idlwave-shell-make-temp-file idlwave-shell-temp-pro-prefix))))
((eq type 'pro)
(or idlwave-shell-temp-pro-file
(setq idlwave-shell-temp-pro-file
(idlwave-shell-make-temp-file idlwave-shell-temp-pro-prefix))))
(t (error "Wrong argument (idlwave-shell-temp-file): %s"
(symbol-name type)))))
(defun idlwave-shell-make-temp-file (prefix)
"Create a temporary file."
(if (fboundp 'make-temp-file)
(make-temp-file prefix)
(let (file
(temp-file-dir (if (boundp 'temporary-file-directory)
temporary-file-directory
"/tmp")))
(while (condition-case ()
(progn
(setq file
(make-temp-name
(expand-file-name prefix temp-file-dir)))
(if (featurep 'xemacs)
(write-region "" nil file nil 'silent nil)
(write-region "" nil file nil 'silent nil 'excl))
nil)
(file-already-exists t))
nil)
file)))
(defvar idlwave-shell-dirstack-query "cd,current=___cur & print,___cur"
"Command used by `idlwave-shell-resync-dirs' to query IDL for
the directory stack.")
(defvar idlwave-shell-path-query "print,'PATH:<'+transpose(expand_path(!PATH,/ARRAY))+'>' & print,'SYSDIR:<'+!dir+'>'"
"The command which gets !PATH and !DIR info from the shell.")
(defvar idlwave-shell-mode-line-info nil
"Additional info displayed in the mode line")
(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-...'.")
(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-is-stopped nil)
(defvar idlwave-shell-expression-overlay nil
"The overlay for the examined expression.")
(defvar idlwave-shell-output-overlay nil
"The overlay for the last IDL output.")
(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))
(if (overlayp idlwave-shell-output-overlay)
(delete-overlay idlwave-shell-output-overlay))
(setq idlwave-shell-stop-line-overlay nil
idlwave-shell-expression-overlay nil
idlwave-shell-output-overlay nil)
(cond
((or (null idlwave-shell-mark-stop-line)
(eq idlwave-shell-mark-stop-line 'arrow))
nil)
((eq idlwave-shell-mark-stop-line 'face)
(when (or (featurep 'xemacs) (fboundp 'tty-defined-colors) 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))))
(t
(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)))))
(setq idlwave-shell-expression-overlay (make-overlay 1 1))
(overlay-put idlwave-shell-expression-overlay
'face idlwave-shell-expression-face)
(overlay-put idlwave-shell-expression-overlay
'priority 1)
(setq idlwave-shell-output-overlay (make-overlay 1 1))
(overlay-put idlwave-shell-output-overlay
'face idlwave-shell-output-face)
(copy-face idlwave-shell-stop-line-face
'idlwave-shell-pending-stop)
(copy-face idlwave-shell-electric-stop-line-face
'idlwave-shell-pending-electric-stop)
(set-face-background 'idlwave-shell-pending-stop "gray70")
(set-face-background 'idlwave-shell-pending-electric-stop "gray70")
(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-sentinel-hook nil
"Hook run when the idl process exits.")
(defvar idlwave-shell-hide-output nil
"If non-nil the process output is not inserted into the output
buffer.")
(defvar idlwave-shell-show-if-error nil
"If non-nil the process output is inserted into the output buffer if
it contains an error message, even if hide-output is non-nil.")
(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.")
(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
'("^% Interrupted at:"
"^% Stepped to:"
"^% Skipped to:"
"^% 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-message-re
"^% At " "*A regular expression matching IDL trace messages. These are the
messages containing file and line information of a current
traceback.")
(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.")
(defconst idlwave-shell-electric-debug-help
" ==> IDLWAVE Electric Debug Mode Help <==
Break Point Setting and Clearing:
b Set breakpoint ([C-u b] for conditional, [C-n b] nth hit, etc.).
d Clear nearby breakpoint.
a Clear all breakpoints.
i Set breakpoint in routine named here.
j Set breakpoint at beginning of containing routine.
\\ Toggle breakpoint disable
] Go to next breakpoint in file.
[ Go to previous breakpoint in file.
Stepping, Continuing, and the Stack:
s or SPACE Step, into function calls.
n Step, over function calls.
k Skip one statement.
m Continue to end of function.
o Continue past end of function.
u Continue to end of block.
h Continue to line at cursor position.
r Continue execution to next breakpoint, if any.
+ or = Show higher level in calling stack.
- or _ Show lower level in calling stack.
Examining Expressions (with prefix for examining the region):
p Print expression near point or in region ([C-u p]).
? Help on expression near point or in region ([C-u ?]).
x Examine expression near point or in region ([C-u x]) with
letter completion of the examine type.
e Prompt for an expression to print.
Miscellaneous:
q Quit - end debugging session and return to the Shell's main level.
v Turn Electric Debugging Mode off (C-c C-d C-v to return).
t Print a calling-level traceback in the shell.
z Reset IDL.
C-? Show this help menu.")
(defvar idlwave-shell-bp-alist)
(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)
(defvar idlwave-shell-calling-stack-index)
(defvar idlwave-shell-only-prompt-pattern nil)
(defvar tool-bar-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'. Command history is also available with
the arrow keys UP and DOWN.
2. Completion
----------
TAB and M-TAB do completion of IDL routines, classes and keywords -
similar to M-TAB in `idlwave-mode'. In executive commands and
strings, it completes file names. Abbreviations are also expanded
like in `idlwave-mode'.
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.
\\[idlwave-context-help] shows the online help on the item at
point, if online help has been installed.
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. Expression Examination
----------------------
Expressions near point can be examined with print,
\\[idlwave-shell-print] or \\[idlwave-shell-mouse-print] with the
mouse, help, \\[idlwave-shell-help-expression] or
\\[idlwave-shell-mouse-help] with the mouse, or with a
configureable set of custom examine commands using
\\[idlwave-shell-examine-select]. The mouse examine commands can
also work by click and drag, to select an expression for
examination.
6. Hooks
-----
Turning on `idlwave-shell-mode' runs `comint-mode-hook' and
`idlwave-shell-mode-hook' (in that order).
7. 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://idlwave.org'.
IDLWAVE has customize support - see the group `idlwave'.
8. Keybindings
-----------
\\{idlwave-shell-mode-map}"
(interactive)
(idlwave-setup) (unless (file-name-absolute-p idlwave-shell-command-history-file)
(setq idlwave-shell-command-history-file
(expand-file-name idlwave-shell-command-history-file
idlwave-config-directory)))
(setq comint-prompt-regexp idlwave-shell-prompt-pattern)
(setq comint-process-echoes t)
(setq comint-input-autoexpand nil)
(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")
(setq idlwave-shell-mode-line-info nil)
(setq mode-line-format
'(""
mode-line-modified
mode-line-buffer-identification
" "
global-mode-string
" %[("
mode-name
mode-line-process
minor-mode-alist
"%n"
")%]-"
idlwave-shell-mode-line-info
"---"
(line-number-mode "L%l--")
(column-number-mode "C%c--")
(-3 . "%p")
"-%-"))
(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)
(setq idlwave-shell-calling-stack-index 0)
(setq idlwave-shell-only-prompt-pattern
(concat "\\`[ \t\n]*"
(substring idlwave-shell-prompt-pattern 1)
"[ \t\n]*\\'"))
(when idlwave-shell-query-for-class
(add-to-list (make-local-variable 'idlwave-determine-class-special)
'idlwave-shell-get-object-class)
(setq idlwave-store-inquired-class t))
(set-marker comint-last-input-end (point))
(setq idlwave-idlwave_routine_info-compiled nil)
(setq idlwave-shell-ready nil)
(setq idlwave-shell-bp-alist nil)
(idlwave-shell-update-bp-overlays) (setq idlwave-shell-post-command-hook nil idlwave-shell-sources-alist nil)
(setq idlwave-shell-default-directory default-directory)
(setq idlwave-shell-hide-output nil)
(add-hook 'kill-buffer-hook 'idlwave-shell-kill-shell-buffer-confirm
nil 'local)
(add-hook 'kill-buffer-hook 'idlwave-shell-delete-temp-files nil 'local)
(add-hook 'kill-emacs-hook 'idlwave-shell-delete-temp-files)
(use-local-map idlwave-shell-mode-map)
(easy-menu-add idlwave-shell-mode-menu idlwave-shell-mode-map)
(when idlwave-shell-comint-settings
(let ((list idlwave-shell-comint-settings) entry)
(while (setq entry (pop list))
(set (make-local-variable (car entry)) (cdr entry)))))
(unless (memq 'comint-carriage-motion
(default-value 'comint-output-filter-functions))
(add-hook 'comint-output-filter-functions
(lambda (string)
(when (string-match "\r" string)
(let ((pmark (process-mark (get-buffer-process
(current-buffer)))))
(save-excursion
(goto-char comint-last-output-start)
(while (search-forward "\r" pmark t)
(delete-region (point) (line-beginning-position)))))))
'append 'local)
(add-hook 'comint-output-filter-functions 'comint-strip-ctrl-m nil 'local))
(remove-hook 'comint-output-filter-functions 'py-pdbtrack-track-stack-file)
(setq local-abbrev-table idlwave-mode-abbrev-table)
(set-syntax-table idlwave-mode-syntax-table)
(set (make-local-variable 'comment-start) ";")
(setq abbrev-mode t)
(add-hook 'post-command-hook 'idlwave-command-hook nil t)
(when (and idlwave-shell-save-command-history
(stringp idlwave-shell-command-history-file))
(set (make-local-variable 'comint-input-ring-file-name)
idlwave-shell-command-history-file)
(if (file-regular-p idlwave-shell-command-history-file)
(comint-read-input-ring)))
(set (make-local-variable 'tool-bar-map) nil)
(run-mode-hooks 'idlwave-shell-mode-hook)
(idlwave-shell-send-command idlwave-shell-initial-commands nil 'hide)
(idlwave-shell-send-command
(format "defsysv,'!idlwave_version','%s',1" idlwave-mode-version)
nil 'hide)
(idlwave-shell-send-command idlwave-shell-path-query
'idlwave-shell-get-path-info
'hide))
(defvar idlwave-system-directory)
(defun idlwave-shell-get-path-info (&optional no-write)
"Get the path lists, writing to file unless NO-WRITE is set."
(let* ((rpl (idlwave-shell-path-filter))
(sysdir (car rpl))
(dirs (cdr rpl))
(old-path-alist idlwave-path-alist)
(old-sys-dir idlwave-system-directory)
path-changed sysdir-changed)
(when sysdir
(setq idlwave-system-directory sysdir)
(if (setq sysdir-changed
(not (string= idlwave-system-directory old-sys-dir)))
(put 'idlwave-system-directory 'from-shell t)))
(setq idlwave-path-alist
(mapcar (lambda (x)
(let ((old-entry (assoc x old-path-alist)))
(if old-entry
(cons x (cdr old-entry))
(list x))))
dirs))
(if (setq path-changed (not (equal idlwave-path-alist old-path-alist)))
(put 'idlwave-path-alist 'from-shell t))
(if idlwave-path-alist
(if (and (not no-write)
idlwave-auto-write-paths
(or sysdir-changed path-changed)
(not idlwave-library-path))
(idlwave-write-paths))
(setq idlwave-path-alist old-path-alist))))
(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-calling-stack-index 0)
(defvar idlwave-shell-calling-stack-routine nil)
(defun idlwave-shell-source-frame ()
"Return the frame to be used for source display."
(if idlwave-shell-use-dedicated-frame
(if (frame-live-p idlwave-shell-display-wframe)
idlwave-shell-display-wframe
(setq idlwave-shell-display-wframe
(if (eq (selected-frame) idlwave-shell-idl-wframe)
(or
(let ((flist (visible-frame-list))
(frame (selected-frame)))
(catch 'exit
(while flist
(if (not (eq (car flist)
idlwave-shell-idl-wframe))
(throw 'exit (car flist))
(setq flist (cdr flist))))))
(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
(if (frame-live-p idlwave-shell-idl-wframe)
idlwave-shell-idl-wframe
(if (not (frame-live-p idlwave-shell-display-wframe))
(setq idlwave-shell-display-wframe (selected-frame)))
(setq idlwave-shell-idl-wframe
(make-frame idlwave-shell-frame-parameters)))))
(defun idlwave-shell (&optional arg quick)
"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',
with options taken from `idlwave-shell-command-line-options'.
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")
(if (eq arg 'quick)
(progn
(let ((idlwave-shell-use-dedicated-frame nil))
(idlwave-shell nil)
(delete-other-windows))
(and idlwave-shell-use-dedicated-frame
(setq idlwave-shell-idl-wframe (selected-frame)))
(add-hook 'idlwave-shell-sentinel-hook
'save-buffers-kill-emacs t))
(if arg (setq idlwave-shell-use-dedicated-frame t))
(if (equal arg '(16)) (setq idlwave-shell-use-dedicated-frame nil))
(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
(if (stringp idlwave-shell-command-line-options)
(idlwave-split-string
idlwave-shell-command-line-options)
idlwave-shell-command-line-options)))
(process (get-buffer-process buf)))
(setq idlwave-idlwave_routine_info-compiled nil)
(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))
(if idlwave-shell-use-dedicated-window
(set-window-dedicated-p window t))
(select-window current-window)
(if idlwave-shell-ready
(raise-frame (window-frame window)))
(if (eq (selected-frame) (window-frame window))
(select-window window))))
(add-hook 'idlwave-shell-sentinel-hook
(lambda ()
(if (and
idlwave-auto-write-paths
idlwave-path-alist
(not idlwave-library-path)
(get 'idlwave-path-alist 'from-shell))
(idlwave-write-paths)))))
(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-hide-p (type &optional list)
"Whether to hide this type of command.
Return either nil or 'hide."
(let ((list (or list idlwave-shell-show-commands)))
(if (listp list)
(if (not (memq type list)) 'hide))))
(defun idlwave-shell-add-or-remove-show (type)
"Add or remove a show command from the list."
(if (listp idlwave-shell-show-commands)
(setq idlwave-shell-show-commands
(if (memq type idlwave-shell-show-commands)
(delq type idlwave-shell-show-commands)
(add-to-list'idlwave-shell-show-commands type)))
(setq idlwave-shell-show-commands (list type))))
(defun idlwave-shell-send-command (&optional cmd pcmd hide preempt
show-if-error)
"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, unless it is the symbol 'mostly, in which case only output
beginning with \"%\" is hidden, and all other output (i.e., the
results of a PRINT command), is shown. This helps with, e.g.,
stepping through code with output.
If optional fourth argument PREEMPT is non-nil CMD is put at front of
`idlwave-shell-pending-commands'. If PREEMPT is 'wait, wait for all
output to complete and the next prompt to arrive before returning
\(useful if you need an answer now\). IDL is considered ready if the
prompt is present and if `idlwave-shell-ready' is non-nil.
If SHOW-IF-ERROR is non-nil, show the output if it contains an error
message, independent of what HIDE is set to."
(if (and (symbolp idlwave-shell-show-commands)
(eq idlwave-shell-show-commands 'everything))
(setq hide nil))
(let ((save-buffer (current-buffer))
buf proc)
(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))))
(error "Problem with autostarting IDL shell"))))
(when (or cmd idlwave-shell-pending-commands)
(set-buffer buf)
(if cmd
(setq idlwave-shell-pending-commands
(if preempt
(append (list (list cmd pcmd hide show-if-error))
idlwave-shell-pending-commands)
(append idlwave-shell-pending-commands
(list (list cmd pcmd hide show-if-error))))))
(let ((save-point (point-marker)))
(goto-char (process-mark proc))
(if (and idlwave-shell-ready
(prog2
(forward-line 0)
(looking-at idlwave-shell-prompt-pattern)
(goto-char (process-mark proc))))
(let* ((lcmd (car idlwave-shell-pending-commands))
(cmd (car lcmd))
(pcmd (nth 1 lcmd))
(hide (nth 2 lcmd))
(show-if-error (nth 3 lcmd)))
(if (eq (string-to-char cmd) ?.)
(setq idlwave-shell-calling-stack-index 0))
(setq idlwave-shell-post-command-hook pcmd)
(setq idlwave-shell-hide-output hide)
(setq idlwave-shell-show-if-error show-if-error)
(setq idlwave-shell-pending-commands
(cdr idlwave-shell-pending-commands))
(set-marker comint-last-input-start (point))
(set-marker comint-last-input-end (point))
(comint-simple-send proc cmd)
(setq idlwave-shell-ready nil)
(if (equal preempt 'wait) (while (not idlwave-shell-ready)
(when (not (accept-process-output proc 6)) (setq idlwave-shell-pending-commands nil)
(error "Process timed out"))))))
(goto-char save-point))
(set-buffer save-buffer))))
(defun idlwave-shell-send-char (c &optional error)
"Send one character to the shell, without a newline."
(interactive "cChar to send to IDL: \np")
(let ((errf (if error 'error 'message))
buf proc)
(if (or (not (setq buf (get-buffer (idlwave-shell-buffer))))
(not (setq proc (get-buffer-process buf))))
(funcall errf "Shell is not running"))
(if (equal c ?\C-g)
(funcall errf "Abort")
(comint-send-string proc (char-to-string c)))))
(defvar idlwave-shell-char-mode-active)
(defun idlwave-shell-input-mode-magic (string)
"Check STRING for magic words and toggle character input mode.
See also the variable `idlwave-shell-input-mode-spells'."
(cond
((string-match (car idlwave-shell-input-mode-spells) string)
(call-interactively 'idlwave-shell-send-char))
((and (boundp 'idlwave-shell-char-mode-active)
(string-match (nth 2 idlwave-shell-input-mode-spells) string))
(setq idlwave-shell-char-mode-active 'exit))
((string-match (nth 1 idlwave-shell-input-mode-spells) string)
(if (fboundp 'start-itimer)
(start-itimer "IDLWAVE Char Mode" 'idlwave-shell-char-mode-loop 0.5
nil nil t 'no-error)
(run-at-time 0.5 nil 'idlwave-shell-char-mode-loop 'no-error)))))
(defvar keyboard-quit)
(defun idlwave-shell-char-mode-loop (&optional no-error)
"Enter a loop which accepts single characters and sends them to IDL.
Characters are sent one by one, without newlines. The loop is blocking
and intercepts all input events to Emacs. You can use this command
to interact with the IDL command GET_KBRD.
The loop can be aborted by typing `C-g'. The loop also exits automatically
when the IDL prompt gets displayed again after the current IDL command."
(interactive)
(let ((idlwave-shell-char-mode-active t)
(errf (if no-error 'message 'error))
buf proc c)
(if (or (not (setq buf (get-buffer (idlwave-shell-buffer))))
(not (setq proc (get-buffer-process buf))))
(funcall errf "Shell is not running"))
(if idlwave-shell-ready
(funcall errf "No IDL program seems to be waiting for input"))
(message "Character mode on: Sending single chars (`C-g' to exit)")
(message
(catch 'exit
(while t
(let ((inhibit-quit t))
(while (sit-for 0.3)
(and idlwave-shell-ready
(throw 'exit "Character mode off (prompt displayed)"))
(and (eq idlwave-shell-char-mode-active 'exit)
(throw 'exit "Character mode off (closing spell incantation)")))
(condition-case nil
(setq c (read-char))
(error (ding) (throw 'exit "Character mode off")))
(cond
((null c) (ding))
((equal c ?\C-g) (setq keyboard-quit nil)
(ding)
(throw 'exit "Character mode off (keyboard quit)"))
(t (comint-send-string proc (char-to-string c))))
(and (eq idlwave-shell-char-mode-active 'exit)
(throw 'exit "Single char loop exited"))))))))
(defun idlwave-shell-move-or-history (up &optional arg)
"When in last line of process buffer, do `comint-previous-input'.
Otherwise just move the line. Move down unless UP is non-nil."
(let* ((proc-pos (marker-position
(process-mark (get-buffer-process (current-buffer)))))
(arg (or arg 1))
(arg (if up arg (- arg))))
(if (eq t idlwave-shell-arrows-do-history) (goto-char proc-pos))
(if (and idlwave-shell-arrows-do-history
(>= (1+ (save-excursion (end-of-line) (point))) proc-pos))
(comint-previous-input arg)
(previous-line arg))))
(defun idlwave-shell-up-or-history (&optional arg)
"When in last line of process buffer, move to previous input.
Otherwise just go up one line."
(interactive "p")
(idlwave-shell-move-or-history t arg))
(defun idlwave-shell-down-or-history (&optional arg)
"When in last line of process buffer, move to next input.
Otherwise just go down one line."
(interactive "p")
(idlwave-shell-move-or-history nil arg))
(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-hidden-output (output)
"Filter hidden output, leaving the good stuff.
Remove everything to the first newline, and all lines with % in front
of them, with optional follow-on lines starting with two spaces. This
works well enough, since any print output typically arrives before
error messages, etc."
(setq output (substring output (string-match "\n" output)))
(while (string-match "\\(\n\\|\\`\\)%.*\\(\n .*\\)*" output)
(setq output (replace-match "" nil t output)))
(unless
(string-match idlwave-shell-only-prompt-pattern output)
output))
(defvar idlwave-shell-hidden-output-buffer " *idlwave-shell-hidden-output*"
"Buffer containing hidden output from IDL commands.")
(defvar idlwave-shell-current-state nil)
(defun idlwave-shell-filter (proc string)
"Watch for IDL prompt and filter incoming text.
When the IDL prompt is received executes `idlwave-shell-post-command-hook'
and then calls `idlwave-shell-send-command' for any pending commands."
(if (eq (process-status idlwave-shell-process-name) 'run)
(let ((data (match-data)) p full-output)
(unwind-protect
(progn
(while (setq p (string-match "\C-G" string))
(ding)
(aset string p ?\C-j ))
(if idlwave-shell-hide-output
(save-excursion
(while (setq p (string-match "\C-M" string))
(aset string p ?\ ))
(set-buffer
(get-buffer-create idlwave-shell-hidden-output-buffer))
(goto-char (point-max))
(insert string))
(idlwave-shell-comint-filter proc string))
(if (string-match "\n" string)
(progn
(if idlwave-shell-use-input-mode-magic
(idlwave-shell-input-mode-magic
(concat idlwave-shell-accumulation string)))
(setq idlwave-shell-accumulation
(substring string
(progn (string-match "\\(.*[\n\r]+\\)*"
string)
(match-end 0)))))
(setq idlwave-shell-accumulation
(concat idlwave-shell-accumulation string)))
(when (setq idlwave-shell-ready
(string-match idlwave-shell-prompt-pattern
idlwave-shell-accumulation))
(if idlwave-shell-hide-output
(save-excursion
(set-buffer idlwave-shell-hidden-output-buffer)
(setq full-output (buffer-string))
(goto-char (point-max))
(re-search-backward idlwave-shell-prompt-pattern nil t)
(goto-char (match-end 0))
(setq idlwave-shell-command-output
(buffer-substring-no-properties
(point-min) (point)))
(delete-region (point-min) (point)))
(setq idlwave-shell-command-output
(with-current-buffer (process-buffer proc)
(buffer-substring-no-properties
(save-excursion
(goto-char (process-mark proc))
(forward-line 0) (point))
comint-last-input-end))))
(let ((idlwave-shell-ready nil))
(idlwave-shell-scan-for-state)
(if idlwave-shell-hide-output
(if (and idlwave-shell-show-if-error
(eq idlwave-shell-current-state 'error))
(idlwave-shell-comint-filter proc full-output)
(if (eq idlwave-shell-hide-output 'mostly)
(let ((filtered
(idlwave-shell-filter-hidden-output
full-output)))
(if filtered
(idlwave-shell-comint-filter
proc filtered))))))
(if (listp idlwave-shell-post-command-hook)
(progn
(eval idlwave-shell-post-command-hook))
(funcall idlwave-shell-post-command-hook))
(setq idlwave-shell-accumulation nil
idlwave-shell-command-output nil
idlwave-shell-post-command-hook nil
idlwave-shell-hide-output nil
idlwave-shell-show-if-error nil))
(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))
(if (and idlwave-shell-save-command-history
(stringp idlwave-shell-command-history-file))
(condition-case nil
(comint-write-input-ring)
(error nil)))))
(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 (and (window-live-p win)
(not (one-window-p 'nomini)))
(delete-window win))
(idlwave-shell-cleanup)
(if (get-buffer buf)
(save-excursion
(set-buffer buf)
(run-hooks 'idlwave-shell-sentinel-hook))
(run-hooks 'idlwave-shell-sentinel-hook))))
(defvar idlwave-shell-error-buffer " *idlwave-shell-errors*"
"Buffer containing syntax errors from IDL compilations.")
(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 1st pair matches the file name, the second pair matches the line
number.")
(defvar idlwave-shell-other-error
"^% .*\n\\s-*At:\\s-*\\(.*\\),\\s-*Line\\s-*\\(.*\\)"
"A regular expression to match any IDL error.")
(defvar idlwave-shell-halting-error
"^% .*\n\\([^%].*\n\\)*% Execution halted at:\\(\\s-*\\S-+\\s-*[0-9]+\\s-*.*\\)\n"
"A regular expression to match errors which halt execution.")
(defvar idlwave-shell-cant-continue-error
"^% Can't continue from this point.\n"
"A regular expression to match errors stepping errors.")
(defvar idlwave-shell-file-line-message
(concat
"\\(" "\\$MAIN\\$\\|" "\\<[a-zA-Z][a-zA-Z0-9_$:]*" "\\([ \t]*\n[ \t]*[a-zA-Z0-9_$:]+\\)*" "\\)" "[ \t\n]+" "\\(" "[0-9]+" "\\([ \t]*\n[ \t]*[0-9]+\\)*" "\\)" "[ \t\n]+" "\\(" "[^ \t\n]+" "\\([ \t]*\n[ \t]*[^ \t\n]+\\)*" "\\)" )
"*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.")
(defvar idlwave-shell-electric-debug-mode)
(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. For breakpoint messages process any attached
count or command parameters. Update the stop line if a message is
found. The variable `idlwave-shell-current-state' is set to 'error,
'halt, or 'breakpoint, which describes the status, or nil for none of
the above."
(let (trace)
(cond
((not 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))
(with-current-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)))
(setq idlwave-shell-current-state 'error)
(idlwave-shell-goto-next-error))
((string-match idlwave-shell-halting-error
idlwave-shell-command-output)
(setq idlwave-shell-calling-stack-index 0)
(setq idlwave-shell-halt-frame
(idlwave-shell-parse-line
(substring idlwave-shell-command-output
(match-beginning 2)))
idlwave-shell-current-state 'error)
(idlwave-shell-display-line (idlwave-shell-pc-frame)))
((or (setq trace (string-match idlwave-shell-trace-message-re
idlwave-shell-command-output))
(string-match idlwave-shell-halt-messages-re
idlwave-shell-command-output))
(setq idlwave-shell-calling-stack-index 0)
(setq idlwave-shell-halt-frame
(idlwave-shell-parse-line
(substring idlwave-shell-command-output (match-end 0))))
(setq idlwave-shell-current-state 'halt)
(idlwave-shell-display-line
(idlwave-shell-pc-frame) nil
(if trace 'disable
(if idlwave-shell-electric-debug-mode 'force))))
((string-match idlwave-shell-break-message
idlwave-shell-command-output)
(setq idlwave-shell-calling-stack-index 0)
(setq idlwave-shell-halt-frame
(idlwave-shell-parse-line
(substring idlwave-shell-command-output (match-end 0))))
(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 (if (listp cmd) (eval cmd) (funcall cmd))))
(idlwave-shell-bp-query)))
(setq idlwave-shell-current-state 'breakpoint)
(idlwave-shell-display-line (idlwave-shell-pc-frame)))
((string-match idlwave-shell-cant-continue-error
idlwave-shell-command-output)
(setq idlwave-shell-current-state 'breakpoint))
(t (setq idlwave-shell-current-state nil)))))
(defun idlwave-shell-parse-line (string &optional skip-main)
"Parse IDL message for the subroutine, file name and line number."
(let (number procedure file)
(when (and (not (if skip-main (string-match ":\\s-*\\$MAIN" string)))
(string-match idlwave-shell-file-line-message string))
(setq procedure (match-string 1 string)
number (match-string 3 string)
file (match-string 5 string))
(setq procedure (idlwave-shell-repair-string procedure))
(setq number (idlwave-shell-repair-string number))
(setq file (idlwave-shell-repair-file-name file))
(if file
(list (idlwave-shell-file-name file)
(string-to-number number)
procedure)
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))
(if (string-match "^%" file)
(setq file (substring file 0 (match-beginning 0))))
(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)
((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-idlwave_routine_info-compiled nil)
(idlwave-shell-delete-temp-files)
(idlwave-shell-display-line nil)
(idlwave-shell-update-bp-overlays) (idlwave-shell-kill-buffer idlwave-shell-hidden-output-buffer)
(idlwave-shell-kill-buffer idlwave-shell-bp-buffer)
(idlwave-shell-kill-buffer idlwave-shell-error-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-window (n)
"Issue a `window,N' command to IDL, with special window size.
The size is given by `idlwave-shell-graphics-window-size'."
(interactive "P")
(let ((n (if n (prefix-numeric-value n) 0)))
(idlwave-shell-send-command
(apply 'format "window,%d,xs=%d,ys=%d"
n idlwave-shell-graphics-window-size)
nil (idlwave-shell-hide-p 'misc) nil t)))
(defun idlwave-shell-resync-dirs ()
"Resync the buffer's idea of the current directory.
This command queries IDL with the command bound to
`idlwave-shell-dirstack-query', reads the output for the new
directory."
(interactive)
(idlwave-shell-send-command idlwave-shell-dirstack-query
'idlwave-shell-filter-directory
'hide 'wait))
(defun idlwave-shell-retall (&optional arg)
"Return from the entire calling stack.
Also get rid of widget events in the queue."
(interactive "P")
(save-selected-window
(idlwave-shell-send-command "retall" nil
(if (idlwave-shell-hide-p 'misc) 'mostly)
nil t)
(idlwave-shell-display-line nil)))
(defun idlwave-shell-closeall (&optional arg)
"Close all open files."
(interactive "P")
(idlwave-shell-send-command "close,/all" nil
(idlwave-shell-hide-p 'misc) nil t))
(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 hidden)
"Reset IDL. Return to main level and destroy the leftover variables.
This issues the following commands:
RETALL
WIDGET_CONTROL,/RESET
CLOSE, /ALL
HEAP_GC, /VERBOSE"
(interactive "P")
(when (or idlwave-shell-reset-no-prompt
(yes-or-no-p "Really Reset IDL and discard current session? "))
(message "Resetting IDL")
(setq idlwave-shell-calling-stack-index 0)
(idlwave-shell-send-command "retall" nil hidden)
(idlwave-shell-send-command "widget_control,/reset" nil hidden)
(idlwave-shell-send-command "close,/all" nil hidden)
(idlwave-shell-send-command "heap_gc,/verbose" nil hidden)
(idlwave-shell-display-line nil)))
(defun idlwave-shell-path-filter ()
(let ((path-string idlwave-shell-command-output)
(case-fold-search t)
(start 0)
dirs sysdir)
(while (string-match "^PATH:[ \t]*<\\(.*\\)>[ \t]*\n" path-string start)
(push (match-string 1 path-string) dirs)
(setq start (match-end 0)))
(setq dirs (mapcar 'file-name-as-directory dirs))
(if (string-match "^SYSDIR:[ \t]*<\\(.*\\)>[ \t]*\n" path-string)
(setq sysdir (file-name-as-directory
(match-string 1 path-string))))
(cons sysdir (nreverse dirs))))
(defun idlwave-shell-routine-info-filter ()
"Function which parses the special output from idlwave_routine_info.pro."
(let ((text idlwave-shell-command-output)
(start 0)
sep sep-re file type spec specs name cs key keys class entry)
(setq idlwave-compiled-routines nil
idlwave-unresolved-routines nil)
(if (string-match
"^>>>BEGIN OF IDLWAVE ROUTINE INFO (\"\\(.+\\)\" IS THE SEPARATOR.*"
text)
(setq sep (match-string 1 text)
sep-re (concat (regexp-quote sep) " *")
text (substring text (match-end 0)))
(setq sep "@" sep-re "@ *" text "")
(if idlwave-idlwave_routine_info-compiled
(message
"Routine Info warning: No match for BEGIN line in \n>>>\n%s\n<<<\n"
idlwave-shell-command-output)))
(if (string-match "^>>>END OF IDLWAVE ROUTINE INFO.*" text)
(setq text (substring text 0 (match-beginning 0)))
(if idlwave-idlwave_routine_info-compiled
(message
"Routine Info warning: No match for END line in \n>>>\n%s\n<<<\n"
idlwave-shell-command-output)))
(while (string-match "^IDLWAVE-\\(PRO\\|FUN\\): \\(.*\\)" text start)
(setq start (match-end 0))
(setq type (match-string 1 text)
spec (match-string 2 text)
specs (idlwave-split-string spec sep-re)
name (nth 0 specs)
class (if (equal (nth 1 specs) "") nil (nth 1 specs))
file (nth 2 specs)
cs (nth 3 specs)
key (nth 4 specs)
keys (if (and (stringp key)
(not (string-match "\\` *\\'" key)))
(mapcar 'list
(delete "" (idlwave-split-string key " +")))))
(setq name (idlwave-sintern-routine-or-method name class t)
class (idlwave-sintern-class class t)
file (if (equal file "") nil file)
keys (mapcar (lambda (x)
(list (idlwave-sintern-keyword (car x) t))) keys))
(cond ((string= name "$MAIN$")) ((and (string= type "PRO")
(or t (null file)
(not (idlwave-rinfo-assq name 'pro class
idlwave-buffer-routines)))
)
(setq entry (list name 'pro class
(cons 'compiled
(if file
(list
(file-name-nondirectory file)
(idlwave-sintern-dir
(file-name-directory file)))))
cs (cons nil keys)))
(if file
(push entry idlwave-compiled-routines)
(push entry idlwave-unresolved-routines)))
((and (string= type "FUN")
(or t (not file)
(not (idlwave-rinfo-assq name 'fun class
idlwave-buffer-routines)))
)
(setq entry (list name 'fun class
(cons 'compiled
(if file
(list
(file-name-nondirectory file)
(idlwave-sintern-dir
(file-name-directory file)))))
cs (cons nil keys)))
(if file
(push entry idlwave-compiled-routines)
(push entry idlwave-unresolved-routines))))))
(setq idlwave-compiled-routines (nreverse idlwave-compiled-routines)
idlwave-unresolved-routines (nreverse idlwave-unresolved-routines)))
(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 ",___cur[\n\r ]+\\([^\n\r]+\\)[\n\r]"
idlwave-shell-command-output)
(let ((dir (substring idlwave-shell-command-output
(match-beginning 1) (match-end 1))))
(setq idlwave-shell-default-directory dir)
(setq default-directory (file-name-as-directory dir))))))
(defvar idlwave-shell-get-object-class nil)
(defun idlwave-shell-get-object-class (apos)
"Query the shell for the class of the object before point."
(let ((bos (save-excursion (idlwave-start-of-substatement 'pre) (point)))
(bol (save-excursion (forward-line 0) (point)))
expression)
(save-excursion
(goto-char apos)
(setq expression (buffer-substring
(catch 'exit
(while t
(if (not (re-search-backward
"[^][.A-Za-z0-9_() ]" bos t))
(throw 'exit bos)) (if (not (idlwave-is-pointer-dereference bol))
(throw 'exit (1+ (point))))))
apos)))
(when (not (string= expression ""))
(setq idlwave-shell-get-object-class nil)
(idlwave-shell-send-command
(concat "if obj_valid(" expression ") then print,obj_class("
expression ")")
'idlwave-shell-parse-object-class
'hide 'wait)
(if (and idlwave-shell-get-object-class
(not (assoc-string idlwave-shell-get-object-class
(idlwave-class-alist) t)))
(idlwave-shell-maybe-update-routine-info))
idlwave-shell-get-object-class)))
(defun idlwave-shell-parse-object-class ()
"Parse the output of the obj_class command."
(let ((match "obj_class([^\n\r]+[\n\r ]"))
(if (string-match (concat match "\\([A-Za-z_0-9]+\\) *[\n\r]\\("
idlwave-shell-prompt-pattern "\\)")
idlwave-shell-command-output)
(setq idlwave-shell-get-object-class
(match-string 1 idlwave-shell-command-output)))))
(defvar idlwave-sint-sysvars nil)
(idlwave-new-sintern-type 'execcomm)
(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."
(interactive "P")
(let (exec-cmd)
(cond
((and
(setq exec-cmd (idlwave-shell-executive-command))
(cdr exec-cmd)
(member (upcase (cdr exec-cmd))
'(".R" ".RU" ".RUN" ".RN" ".RNE" ".RNEW"
".COM" ".COMP" ".COMPI" ".COMPIL" ".COMPILE")))
(idlwave-shell-complete-filename))
((car-safe exec-cmd)
(setq idlwave-completion-help-info
'(idlwave-shell-complete-execcomm-help))
(idlwave-complete-in-buffer 'execcomm 'execcomm
idlwave-executive-commands-alist nil
"Select an executive command"
"system variable"))
((idlwave-shell-batch-command)
(idlwave-shell-complete-filename))
((idlwave-shell-shell-command)
(idlwave-shell-complete-filename))
((and (idlwave-shell-filename-string)
(save-excursion
(beginning-of-line)
(let ((case-fold-search t))
(not (looking-at ".*obj_new")))))
(idlwave-shell-complete-filename))
(t
(idlwave-complete arg)))))
(defvar link) (defun idlwave-shell-complete-execcomm-help (mode word)
(let ((word (or (nth 1 idlwave-completion-help-info) word))
(entry (assoc-string word idlwave-executive-commands-alist t)))
(cond
((eq mode 'test)
(and (stringp word) entry (cdr entry)))
((eq mode 'set)
(if entry (setq link (cdr entry)))) (t (error "This should not happen")))))
(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."
(idlwave-shell-resync-dirs)
(let ((comint-file-name-chars idlwave-shell-file-name-chars))
(comint-dynamic-complete-as-filename)))
(defun idlwave-shell-executive-command ()
"Return the name of the current executive command, if any."
(save-excursion
(idlwave-beginning-of-statement)
(cons (looking-at "[ \t]*\\.")
(if (looking-at "[ \t]*[.]\\([^ \t\n\r]+\\)[ \t]")
(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-chars-backward idlwave-shell-file-name-chars limit)
(memq (preceding-char) '(?\' ?\")))))
(defun idlwave-shell-batch-command ()
"Returns t if we're in a batch command statement like @foo"
(let ((limit (save-excursion (beginning-of-line) (point))))
(save-excursion
;; Skip backwards over filename
(skip-chars-backward idlwave-shell-file-name-chars limit)
(skip-chars-backward " \t" limit)
(and (eq (preceding-char) ?@) (not (idlwave-in-quote))))))
(defun idlwave-shell-shell-command ()
"Returns t if we're in a shell command statement like $ls"
(save-excursion
(idlwave-beginning-of-statement)
(looking-at "\\$")))
;; Debugging Commands ------------------------------------------------------
(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)
(setq idlwave-shell-calling-stack-index 0)
(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"
`(progn
(setq idlwave-shell-calling-stack-index
,idlwave-shell-calling-stack-index)
(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)
(cond
((< nmax nmin)
(setq idlwave-shell-calling-stack-index 0)
(ding)
(message "Problem with calling stack"))
((> idlwave-shell-calling-stack-index nmax)
(ding)
(setq idlwave-shell-calling-stack-index nmax
message (format "%d is the highest calling stack level - can't go further up"
(- nmax))))
((< idlwave-shell-calling-stack-index nmin)
(ding)
(setq idlwave-shell-calling-stack-index nmin
message (format "%d is the current calling stack level - can't go further down"
(- nmin)))))
(setq idlwave-shell-calling-stack-routine
(nth 2 (nth idlwave-shell-calling-stack-index stack)))
(idlwave-shell-display-line
(nth idlwave-shell-calling-stack-index stack) nil
(if idlwave-shell-electric-debug-mode 'force))
(message "%s" (or message
(format "In routine %s (stack level %d)"
idlwave-shell-calling-stack-routine
(- 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) 'shell))
(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)
(nth 2 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-stop-line-pending ()
(if idlwave-shell-stop-line-overlay
(overlay-put idlwave-shell-stop-line-overlay 'face
(if idlwave-shell-electric-debug-mode
'idlwave-shell-pending-electric-stop
'idlwave-shell-pending-stop))))
(defvar idlwave-shell-suppress-electric-debug nil)
(defun idlwave-shell-display-line (frame &optional col debug)
"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 col is set, move point to that
column in the line. if debug is non-nil, enable the electric debug
mode. if it is 'disable, do not enable no matter what the setting of
'idlwave-shell-automatic-electric-debug'. if it is 'force, enable no
matter what the settings of that variable."
(if (not frame)
(progn
(setq overlay-arrow-string nil)
(setq idlwave-shell-mode-line-info nil)
(setq idlwave-shell-is-stopped nil)
(if idlwave-shell-stop-line-overlay
(delete-overlay idlwave-shell-stop-line-overlay))
(idlwave-shell-electric-debug-all-off))
(if (not (idlwave-shell-valid-frame frame))
(error (concat "invalid frame - unable to access file: " (car frame)))
(setq idlwave-shell-mode-line-info
(if (nth 2 frame)
(format "[%d:%s]"
(- idlwave-shell-calling-stack-index)
(nth 2 frame))))
(let* ((buffer (idlwave-find-file-noselect (car frame) 'shell))
(select-shell (equal (buffer-name) (idlwave-shell-buffer)))
window pos electric)
(idlwave-display-buffer (idlwave-shell-buffer)
nil (idlwave-shell-shell-frame))
(setq window (idlwave-display-buffer buffer
nil (idlwave-shell-source-frame)))
(save-excursion
(set-buffer buffer)
(save-restriction
(widen)
(goto-line (nth 1 frame))
(forward-line 0)
(setq pos (point))
(setq idlwave-shell-is-stopped t)
(if idlwave-shell-stop-line-overlay
(progn
(overlay-put idlwave-shell-stop-line-overlay 'face
(if idlwave-shell-electric-debug-mode
idlwave-shell-electric-stop-line-face
idlwave-shell-stop-line-face))
(move-overlay idlwave-shell-stop-line-overlay
(point) (save-excursion (end-of-line) (point))
(current-buffer)))
(if idlwave-shell-mark-stop-line
(setq overlay-arrow-string idlwave-shell-overlay-arrow))
(or overlay-arrow-position (setq overlay-arrow-position (make-marker)))
(set-marker overlay-arrow-position (point) buffer)))
(if (or (< pos (point-min)) (> pos (point-max)))
(progn
(widen)
(goto-char pos)))
(if col (move-to-column col))
(setq pos (point))
(when (and (not idlwave-shell-electric-debug-mode)
(or (eq debug 'force)
(and
(not (eq debug 'disable)) (or
(eq idlwave-shell-automatic-electric-debug t)
(and
(eq idlwave-shell-automatic-electric-debug
'breakpoint)
(not (eq idlwave-shell-current-state 'error))))
(not idlwave-shell-suppress-electric-debug))))
(idlwave-shell-electric-debug-mode t))
(setq electric idlwave-shell-electric-debug-mode))
(set-window-point window pos)
(if (or (and idlwave-shell-electric-zap-to-file electric)
(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-stop-line-pending)
(idlwave-shell-send-command
(concat ".s " (if (integerp arg) (int-to-string arg) arg))
nil (if (idlwave-shell-hide-p 'debug) 'mostly) nil t))
(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-stop-line-pending)
(idlwave-shell-send-command
(concat ".so " (if (integerp arg) (int-to-string arg) arg))
nil (if (idlwave-shell-hide-p 'debug) 'mostly) nil t))
(defun idlwave-shell-break-here (&optional count cmd condition disabled
no-show)
"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. CONDITION is a break condition, and DISABLED, if
non-nil disables the breakpoint"
(interactive "P")
(when (listp count)
(if (equal (car count) 4)
(setq condition (read-string "Break Condition: ")))
(setq count nil))
(idlwave-shell-set-bp
(idlwave-shell-bp (idlwave-shell-current-frame)
(list count cmd condition disabled)
(idlwave-shell-current-module))
no-show))
(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."
(if idlwave-shell-command-output
(cond
((string-match "% BREAKPOINT: *Unable to find code"
idlwave-shell-command-output)
(if (progn
(beep)
(y-or-n-p
(concat "Okay to recompile file "
(idlwave-shell-bp-get bp 'file) "?")))
(progn
(idlwave-shell-command-failure)
(idlwave-shell-send-command
(concat ".run \"" (idlwave-shell-bp-get bp 'file) "\"") nil
(if (idlwave-shell-hide-p 'run) 'mostly) nil t)
(idlwave-shell-set-bp bp))
(beep)
(message "Unable to set breakpoint.")
(idlwave-shell-command-failure))
nil)
((string-match "% Syntax error" idlwave-shell-command-output)
(message "Syntax error in condition.")
(idlwave-shell-command-failure)
nil)
(t '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."
(setq idlwave-shell-pending-commands nil))
(defun idlwave-shell-cont (&optional no-show)
"Continue executing."
(interactive)
(idlwave-shell-stop-line-pending)
(idlwave-shell-send-command ".c" (unless no-show
'(idlwave-shell-redisplay 'hide))
(if (idlwave-shell-hide-p 'debug) 'mostly)
nil t))
(defun idlwave-shell-go ()
"Run .GO. This starts the main program of the last compiled file."
(interactive)
(idlwave-shell-stop-line-pending)
(idlwave-shell-send-command ".go" '(idlwave-shell-redisplay 'hide)
(if (idlwave-shell-hide-p 'debug) 'mostly)
nil t))
(defun idlwave-shell-return ()
"Run .RETURN (continue to next return, but stay in subprogram)."
(interactive)
(idlwave-shell-stop-line-pending)
(idlwave-shell-send-command ".return" '(idlwave-shell-redisplay 'hide)
(if (idlwave-shell-hide-p 'debug) 'mostly)
nil t))
(defun idlwave-shell-skip ()
"Run .SKIP (skip one line, then step)."
(interactive)
(idlwave-shell-stop-line-pending)
(idlwave-shell-send-command ".skip" '(idlwave-shell-redisplay 'hide)
(if (idlwave-shell-hide-p 'debug) 'mostly)
nil t))
(defun idlwave-shell-clear-bp (bp &optional no-query)
"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," (int-to-string index))
nil (idlwave-shell-hide-p 'breakpoint) nil t)
(unless no-query (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)))
(idlwave-shell-pc-frame)
(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)))
(nth 2 idlwave-shell-halt-frame)
(save-restriction
(widen)
(save-excursion
(if (idlwave-prev-index-position)
(let* ((module (idlwave-what-module))
(name (idlwave-make-full-name (nth 2 module) (car module)))
(type (nth 1 module)))
(list (upcase name) type)))))))
(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-current-bp)))
(if bp (idlwave-shell-clear-bp bp))))
(defun idlwave-shell-toggle-enable-current-bp (&optional bp force
no-update)
"Disable or enable current breakpoint or a breakpoint passed in BP.
If FORCE is 'disable or 'enable, for that condition instead of
toggling. If NO-UPDATE is non-nil, don't update the breakpoint
list after toggling."
(interactive)
(let* ((bp (or bp (idlwave-shell-find-current-bp)))
(disabled (idlwave-shell-bp-get bp 'disabled)))
(cond ((eq force 'disable) (setq disabled nil))
((eq force 'enable) (setq disabled t)))
(when bp
(setf (nth 3 (cdr (cdr bp))) (not disabled))
(idlwave-shell-send-command
(concat "breakpoint,"
(if disabled "/enable," "/disable,")
(int-to-string (idlwave-shell-bp-get bp)))
nil (idlwave-shell-hide-p 'breakpoint) nil t)
(unless no-update (idlwave-shell-bp-query)))))
(defun idlwave-shell-enable-all-bp (&optional enable no-update bpl)
"Disable all breakpoints we know about which need disabling.
If ENABLE is non-nil, enable them instead."
(let ((bpl (or bpl idlwave-shell-bp-alist)) disabled modified)
(while bpl
(setq disabled (idlwave-shell-bp-get (car bpl) 'disabled))
(when (idlwave-xor (not disabled) (eq enable 'enable))
(idlwave-shell-toggle-enable-current-bp
(car bpl) (if (eq enable 'enable) 'enable 'disable) no-update)
(push (car bpl) modified))
(setq bpl (cdr bpl)))
(unless no-update (idlwave-shell-bp-query))
modified))
(defun idlwave-shell-to-here ()
"Set a breakpoint with count 1 then continue."
(interactive)
(let ((disabled (idlwave-shell-enable-all-bp 'disable 'no-update)))
(idlwave-shell-break-here 1 nil nil nil 'no-show)
(idlwave-shell-cont 'no-show)
(idlwave-shell-enable-all-bp 'enable 'no-update disabled))
(idlwave-shell-redisplay))
(defun idlwave-shell-break-this-module (&optional arg)
(interactive "P")
(save-excursion
(idlwave-beginning-of-subprogram)
(idlwave-shell-break-here arg)))
(defun idlwave-shell-break-in ()
"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. If MODULE is `t', set
in the current routine."
(interactive)
(let* ((module (idlwave-fix-module-if-obj_new (idlwave-what-module)))
(type (nth 1 module))
(name (car module))
(class (nth 2 module)))
(if module
(progn
(setq module (idlwave-make-full-name class name))
(idlwave-shell-module-source-query module type)
(idlwave-shell-set-bp-in-module name type class))
(error "No identifier at point"))))
(defun idlwave-shell-set-bp-in-module (name type class)
"Set breakpoint in module. Assumes that `idlwave-shell-sources-alist'
contains an entry for that module."
(let* ((module (idlwave-make-full-name class name))
(source-file
(car-safe (cdr-safe
(or
(assoc (upcase module)
idlwave-shell-sources-alist)
(nth 3 (idlwave-best-rinfo-assoc name type class
(idlwave-routines)))))))
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)
(let ((eos (save-excursion
(idlwave-beginning-of-subprogram)
(idlwave-forward-block)
(point))))
(idlwave-backward-up-block -1)
(idlwave-next-statement)
(idlwave-end-of-statement)
(if (< (point) eos)
()
(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 ".o" nil
(if (idlwave-shell-hide-p 'debug) 'mostly)
nil t))
(defun idlwave-shell-goto-previous-bp ()
"Move to the previous breakpoint in the buffer."
(interactive)
(idlwave-shell-move-to-bp -1))
(defun idlwave-shell-goto-next-bp ()
"Move to the next breakpoint in the buffer."
(interactive)
(idlwave-shell-move-to-bp 1))
(defun idlwave-shell-move-to-bp (dir)
"Move to the next or previous breakpoint, depending on direction DIR."
(let* ((frame (idlwave-shell-current-frame))
(file (car frame))
(orig-bp-line (nth 1 frame))
(bp-alist idlwave-shell-bp-alist)
(orig-func (if (> dir 0) '> '<))
(closer-func (if (> dir 0) '< '>))
bp got-bp bp-line cur-line)
(while (setq bp (pop bp-alist))
(when (string= file (car (car bp)))
(setq got-bp 1)
(setq cur-line (nth 1 (car bp)))
(if (and
(funcall orig-func cur-line orig-bp-line)
(or (not bp-line) (funcall closer-func cur-line bp-line)))
(setq bp-line cur-line))))
(unless bp-line (error "No further breakpoints"))
(goto-line bp-line)))
(defun idlwave-shell-help-expression (arg)
"Print help on current expression. See `idlwave-shell-print'."
(interactive "P")
(idlwave-shell-print arg 'help))
(defmacro idlwave-shell-mouse-examine (help &optional ev)
"Create a function for generic examination of expressions."
`(lambda (event)
"Expansion function for expression examination."
(interactive "e")
(let* ((drag-track (fboundp 'mouse-drag-track))
(transient-mark-mode t)
(zmacs-regions t)
(tracker (if (featurep 'xemacs)
(if (fboundp
'default-mouse-track-event-is-with-button)
'idlwave-xemacs-hack-mouse-track
'mouse-track)
(if drag-track 'mouse-drag-track 'mouse-drag-region))))
(funcall tracker event)
(idlwave-shell-print (if (idlwave-region-active-p) '(4) nil)
,help ,ev))))
(defun idlwave-default-mouse-track-event-is-with-button (event n)
t)
(defun idlwave-xemacs-hack-mouse-track (event)
(if (featurep 'xemacs)
(let ((oldfunc (symbol-function
'default-mouse-track-event-is-with-button)))
(unwind-protect
(progn
(fset 'default-mouse-track-event-is-with-button
'idlwave-default-mouse-track-event-is-with-button)
(mouse-track event))
(fset 'default-mouse-track-event-is-with-button oldfunc)))))
(defun idlwave-shell-mouse-print (event)
"Print value of variable at the mouse position, with `help'"
(interactive "e")
(funcall (idlwave-shell-mouse-examine nil) event))
(defun idlwave-shell-mouse-help (event)
"Print value of variable at the mouse position, with `print'."
(interactive "e")
(funcall (idlwave-shell-mouse-examine 'help) event))
(defun idlwave-shell-examine-select (event)
"Pop-up a list to select from for examining the expression"
(interactive "e")
(funcall (idlwave-shell-mouse-examine nil event) event))
(defmacro idlwave-shell-examine (help)
"Create a function for key-driven expression examination."
`(lambda ()
(interactive)
(idlwave-shell-print nil ,help)))
(defvar idlwave-shell-examine-label nil
"Label to include with examine text if in a separate buffer.")
(defvar idlwave-shell-examine-completion-list nil)
(defun idlwave-shell-print (arg &optional help ev complete-help-type)
"Print current expression.
With HELP non-nil, show help on expression. If HELP is a string,
the expression will be put in place of ___, e.g.:
print,size(___,/DIMENSIONS)
HELP can also be a cons cell ( NAME . STRING ) in which case NAME will
be used to label the help print-out.
Otherwise, print is called on the 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 parenthesis 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.
With prefix arg, or if transient mode set and the region is defined,
use the current region as the expression.
With double prefix arg ARG prompt for an expression.
If EV is a valid event passed, pop-up a list from
idlw-shell-examine-alist from which to select the help command text.
If instead COMPLETE-HELP-TYPE is non-nil, choose from
idlw-shell-examine-alist via mini-buffer shortcut key."
(interactive "P")
(unless idlwave-idlwave_routine_info-compiled
(idlwave-shell-compile-helper-routines))
(save-excursion
(let* ((process (get-buffer-process (current-buffer)))
(process-mark (if process (process-mark process)))
(stack-label
(if (and (integerp idlwave-shell-calling-stack-index)
(> idlwave-shell-calling-stack-index 0))
(format " [-%d:%s]"
idlwave-shell-calling-stack-index
idlwave-shell-calling-stack-routine)))
expr beg end cmd)
(cond
((equal arg '(16))
(setq expr (read-string "Expression: ")))
((and (or arg (idlwave-region-active-p))
(< (- (region-end) (region-beginning)) 2000))
(setq beg (region-beginning)
end (region-end)))
(t
(idlwave-with-special-syntax
(if (looking-at "\\<\\|(")
(if (looking-at "\\>")
(backward-sexp))
(backward-sexp))
(if (looking-at "\\>")
(backward-sexp))
(setq beg (point))
(forward-sexp)
(while (looking-at "\\>[[(]\\|\\.")
(forward-sexp))
(setq end (point)))))
(when (and beg end)
(if (and process-mark (> process-mark beg) (< process-mark end))
(setq beg (marker-position process-mark)))
(setq expr (buffer-substring beg end)))
(when (and beg end idlwave-shell-expression-overlay)
(move-overlay idlwave-shell-expression-overlay beg end
(current-buffer))
(add-hook 'pre-command-hook
'idlwave-shell-delete-expression-overlay))
(add-hook 'pre-command-hook
'idlwave-shell-delete-output-overlay)
(while (string-match "\n[ \t]*\\(;.*\\)?\r*\n" expr)
(setq expr (replace-match "\n" t t expr)))
(while (string-match "[ \t]*\\$[ \t]*\\(;.*\\)?\\(\n[ \t]*\\|$\\)" expr)
(setq expr (replace-match "" t t expr)))
(if (string-match "\n[ \t\r]*\\'" expr)
(setq expr (replace-match "" t t expr)))
(catch 'exit
(if (or
complete-help-type
(and ev idlwave-shell-examine-alist)
(consp help))
(let ((help-cons
(if (consp help) help
(assoc
(if complete-help-type
(idlwave-one-key-select 'idlwave-shell-examine-alist
"Examine with: " 1.5)
(idlwave-popup-select
ev
(mapcar 'car idlwave-shell-examine-alist)
"Examine with"))
idlwave-shell-examine-alist))))
(setq help (cdr help-cons))
(if (null help) (throw 'exit nil))
(if idlwave-shell-separate-examine-output
(setq idlwave-shell-examine-label
(concat
(format "==>%s<==\n%s:" expr (car help-cons))
stack-label "\n"))))
(setq idlwave-shell-examine-label
(concat
(format "==>%s<==\n%s:" expr
(cond ((null help) "print")
((stringp help) help)
(t (symbol-name help))))
stack-label "\n")))
(if stack-label
(setq expr (idlwave-retrieve-expression-from-level
expr
idlwave-shell-calling-stack-index)))
(setq cmd (idlwave-shell-help-statement help expr))
(idlwave-shell-send-command
cmd
'idlwave-shell-check-compiled-and-display
(if idlwave-shell-separate-examine-output 'hide))))))
(defvar idlwave-shell-examine-window-alist nil
"Variable to hold the win/height pairs for all *Examine* windows.")
(defvar idlwave-shell-examine-map (make-sparse-keymap))
(define-key idlwave-shell-examine-map "q" 'idlwave-shell-examine-display-quit)
(define-key idlwave-shell-examine-map "c" 'idlwave-shell-examine-display-clear)
(defun idlwave-shell-check-compiled-and-display ()
"Check examine output for warning about undefined procedure/function."
(if (string-match "% Attempt to call undefined" idlwave-shell-command-output)
(idlwave-shell-compile-helper-routines))
(if idlwave-shell-separate-examine-output
(idlwave-shell-examine-display)
(idlwave-shell-examine-highlight)))
(defun idlwave-shell-examine-display ()
"View the examine command output in a separate buffer."
(let (win cur-beg cur-end)
(save-excursion
(set-buffer (get-buffer-create "*Examine*"))
(use-local-map idlwave-shell-examine-map)
(setq buffer-read-only nil)
(goto-char (point-max))
(save-restriction
(narrow-to-region (point) (point))
(if (string-match "^% Syntax error." idlwave-shell-command-output)
(insert "% Syntax error.\n")
(insert idlwave-shell-command-output)
(let* ((end (or
(re-search-backward idlwave-shell-prompt-pattern nil t)
(point-max)))
(beg (progn
(goto-char
(or (progn (if (re-search-backward
idlwave-shell-prompt-pattern nil t)
(match-end 0)))
(point-min)))
(re-search-forward "\n")))
(str (buffer-substring beg end)))
(delete-region (point-min) (point-max))
(insert str)
(if idlwave-shell-examine-label
(progn (goto-char (point-min))
(insert idlwave-shell-examine-label)
(setq idlwave-shell-examine-label nil)))))
(setq cur-beg (point-min)
cur-end (point-max))
(setq buffer-read-only t)
(move-overlay idlwave-shell-output-overlay cur-beg cur-end
(current-buffer))
(let* ((winlist (get-buffer-window-list "*Examine*" nil 'visible)))
(setq win (idlwave-display-buffer
"*Examine*"
nil
(let ((list winlist) thiswin)
(catch 'exit
(save-selected-window
(while (setq thiswin (pop list))
(select-window thiswin)
(if (one-window-p)
(throw 'exit (window-frame thiswin)))))))))
(set-window-start win (point-min)) (save-selected-window
(select-window win)
(let ((elt (assoc win idlwave-shell-examine-window-alist)))
(when (and (not (one-window-p))
(or (not (memq win winlist)) (eq (window-height) (cdr elt))))
(enlarge-window (- (/ (frame-height) 2)
(window-height)))
(shrink-window-if-larger-than-buffer)
(setq idlwave-shell-examine-window-alist
(delq nil
(mapcar (lambda (x) (if (window-live-p (car x)) x))
idlwave-shell-examine-window-alist)))
(if (setq elt (assoc win idlwave-shell-examine-window-alist))
(setcdr elt (window-height))
(add-to-list 'idlwave-shell-examine-window-alist
(cons win (window-height)))))))))
(save-selected-window
(select-window win)
(goto-char (point-max))
(skip-chars-backward "\n")
(recenter -1)))))
(defun idlwave-shell-examine-display-quit ()
(interactive)
(let ((win (selected-window)))
(if (one-window-p)
(delete-frame (window-frame win))
(delete-window win))))
(defun idlwave-shell-examine-display-clear ()
(interactive)
(save-excursion
(let ((buf (get-buffer "*Examine*")))
(when (bufferp buf)
(set-buffer buf)
(setq buffer-read-only nil)
(erase-buffer)
(setq buffer-read-only t)))))
(defun idlwave-retrieve-expression-from-level (expr level)
"Return IDL command to print the expression EXPR from stack level LEVEL.
It does not seem possible to evaluate an expression on a different
level than the current. Therefore, this function retrieves variables
by reference from other levels, and then includes that variable in
place of the chosen one.
Since this function depends upon the undocumented IDL routine
routine_names, there is no guarantee that this will work with future
versions of IDL."
(let ((fetch (- 0 level))
(start 0)
var fetch-start fetch-end pre post)
(while (string-match
"\\(\\`\\|[^a-zA-Z0-9$_][ \t]*\\)\\([a-zA-Z][a-zA-Z0-9$_]*\\)\\([ \t]*[^a-zA-Z0-9$_]\\|\\'\\)" expr start)
(setq var (match-string 2 expr)
start (match-end 2)
pre (substring expr 0 (match-beginning 2))
post (substring expr (match-end 2)))
(cond
((or
(string-match ",[ \t$\n]*/\\'" pre) (and (string-match "[,(][ \t\n]*\\'" pre)
(string-match "\\`[ \t]*=" post)) (string-match "\\`(" post) (string-match "->[ \t]*\\'" pre) (string-match "\\.\\'" pre)))
((and (string-match "\\([\"\']\\)[^\1]*$" pre)
(string-match (concat "^[^" (match-string 1 pre) "]*"
(match-string 1 pre)) post))
(setq start (+ start (match-end 0))))
(t
(put-text-property start (- start (length var)) 'fetch t expr))))
(setq start 0)
(while (setq fetch-start
(next-single-property-change start 'fetch expr))
(if (get-text-property start 'fetch expr) (setq fetch-end fetch-start fetch-start start)
(setq fetch-end (next-single-property-change fetch-start 'fetch expr)))
(unless fetch-end (setq fetch-end (length expr)))
(remove-text-properties fetch-start fetch-end '(fetch) expr)
(setq expr (concat (substring expr 0 fetch-start)
(format "(routine_names('%s',fetch=%d))"
(substring expr fetch-start fetch-end)
fetch)
(substring expr fetch-end)))
(setq start fetch-end))
(if (get-text-property 0 'fetch expr) (setq expr (format "(routine_names('%s',fetch=%d))" expr fetch)))
expr))
(defun idlwave-shell-help-statement (help expr)
"Construct a help statement for printing expression EXPR.
HELP can be non-nil for `help,', nil for 'print,' or any string into which
to insert expression in place of the marker ___, e.g.: print,
size(___,/DIMENSIONS)"
(cond
((null help)
(concat "idlwave_print_safe, " expr ","
(number-to-string idlwave-shell-max-print-length)))
((stringp help)
(if (string-match "\\(^\\|[^_]\\)\\(___\\)\\([^_]\\|$\\)" help)
(concat (substring help 0 (match-beginning 2))
expr
(substring help (match-end 2)))))
(t
(concat "help, " expr))))
(defun idlwave-shell-examine-highlight ()
"Highlight the most recent IDL output."
(let* ((buffer (get-buffer (idlwave-shell-buffer)))
(process (get-buffer-process buffer))
(process-mark (if process (process-mark process)))
output-begin output-end)
(save-excursion
(set-buffer buffer)
(goto-char process-mark)
(beginning-of-line)
(setq output-end (point))
(re-search-backward idlwave-shell-prompt-pattern nil t)
(beginning-of-line 2)
(setq output-begin (point)))
(idlwave-display-buffer (idlwave-shell-buffer)
nil (idlwave-shell-shell-frame))
(if (and idlwave-shell-output-overlay process-mark)
(move-overlay idlwave-shell-output-overlay
output-begin output-end buffer))))
(defun idlwave-shell-delete-output-overlay ()
(unless (or (eq this-command 'idlwave-shell-mouse-nop)
(eq this-command 'handle-switch-frame))
(condition-case nil
(if idlwave-shell-output-overlay
(delete-overlay idlwave-shell-output-overlay))
(error nil))
(remove-hook 'pre-command-hook 'idlwave-shell-delete-output-overlay)))
(defun idlwave-shell-delete-expression-overlay ()
(unless (or (eq this-command 'idlwave-shell-mouse-nop)
(eq this-command 'handle-switch-frame))
(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 four 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'.
condition - any condition to apply to the breakpoint.
disabled - whether the bp is disabled")
(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-file 'pro) 'tmp))
(set (make-local-variable 'comment-start-skip) ";+[ \t]*")
(set (make-local-variable 'comment-start) ";")
(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 "\"")
nil
(if (idlwave-shell-hide-p 'run) 'mostly)
nil t)
(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-shell-delete-temp-files ()
"Delete the temporary files and kill associated buffers."
(if (stringp idlwave-shell-temp-pro-file)
(condition-case nil
(let ((buf (idlwave-get-buffer-visiting
idlwave-shell-temp-pro-file)))
(if (buffer-live-p buf)
(kill-buffer buf))
(delete-file idlwave-shell-temp-pro-file))
(error nil)))
(if (stringp idlwave-shell-temp-rinfo-save-file)
(condition-case nil
(delete-file idlwave-shell-temp-rinfo-save-file)
(error nil))))
(defun idlwave-display-buffer (buf not-this-window-p &optional frame)
(if (featurep 'xemacs)
(display-buffer buf not-this-window-p frame)
(let ((this-frame (selected-frame)))
(save-excursion (if (frame-live-p frame)
(select-frame frame))
(if (eq this-frame (selected-frame))
(display-buffer buf)
(if (one-window-p)
(progn
(switch-to-buffer buf)
(selected-window)) (display-buffer buf not-this-window-p)))))))
(defvar idlwave-shell-bp-buffer " *idlwave-shell-bp*"
"Scratch buffer for parsing IDL breakpoint lists and other stuff.")
(defun idlwave-shell-bp-query (&optional no-show)
"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
`(progn
(idlwave-shell-filter-bp (quote ,no-show)))
'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, 'condition, 'disabled, 'type, or
'data. 'data returns a list of 'count, 'cmd and 'condition.
Defaults to 'index."
(cond
((eq item 'line) (nth 1 (car bp)))
((eq item 'file) (nth 0 (car bp)))
((eq item 'data) (cdr (cdr bp)))
((eq item 'count) (nth 0 (cdr (cdr bp))))
((eq item 'cmd) (nth 1 (cdr (cdr bp))))
((eq item 'condition) (nth 2 (cdr (cdr bp))))
((eq item 'disabled) (nth 3 (cdr (cdr bp))))
((eq item 'module)
(let ((module (nth 1 (car (cdr bp)))))
(if (listp module) (car module) module)))
((eq item 'type)
(let ((module (nth 1 (car (cdr bp)))))
(if (listp module) (nth 1 module))))
(t (nth 0 (car (cdr bp))))))
(defun idlwave-shell-filter-bp (&optional no-show)
"Get the breakpoints from `idlwave-shell-command-output'. Create
`idlwave-shell-bp-alist' updating breakpoint count and command data
from previous breakpoint list. If NO-SHOW is set, don't update the
breakpoint overlays."
(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)
(bp-re54 "^[ \t]*\\([0-9]+\\)[ \t]+\\(\\S-+\\)?[ \t]+\\([0-9]+\\)[ \t]+\\(\\S-+\\)")
(bp-re55
(concat
"^\\s-*\\([0-9]+\\)" "\\s-+\\([0-9]+\\)" "\\s-+\\(Uncompiled\\|" "\\(\\(Func=\\|Pro=\\)\\(\\$?[a-zA-Z][a-zA-Z0-9$_:]*\\$?\\)\\)\\)"
"\\(\\s-*,\\s-*After=[0-9]+/\\([0-9]+\\)?\\)?" "\\(\\s-*,\\s-*\\(BreakOnce\\)\\)?" "\\(\\s-*,\\s-*\\(Condition='\\(.*\\)'\\)\n?\\)?" "\\(\\s-*,\\s-*\\(Disabled\\)\n?\\)?" "\\s-+\\(\\S-+\\)")) file line index module
count condition disabled
bp-re indmap)
(setq idlwave-shell-bp-alist (list nil))
(when (or
(if (re-search-forward "^\\s-*Index.*\n\\s-*-" nil t)
(setq bp-re bp-re54 indmap '(1 2 3 4))) (if (re-search-forward
"^\\s-*Index\\s-*Line\\s-*Attributes\\s-*File" nil t)
(setq bp-re bp-re55 indmap '(1 6 2 16)))) (while (re-search-forward bp-re nil t)
(setq index (string-to-number (match-string (nth 0 indmap)))
module (match-string (nth 1 indmap))
line (string-to-number (match-string (nth 2 indmap)))
file (idlwave-shell-file-name (match-string (nth 3 indmap))))
(if (eq bp-re bp-re55)
(setq count (if (match-string 10) 1
(if (match-string 8)
(string-to-number (match-string 8))))
condition (match-string 13)
disabled (not (null (match-string 15)))))
(nconc idlwave-shell-bp-alist
(list (cons (list file line)
(list
(list index module)
count nil condition disabled))))))
(setq idlwave-shell-bp-alist (cdr idlwave-shell-bp-alist))
(if (eq bp-re bp-re54)
(mapcar 'idlwave-shell-update-bp old-bp-alist)
(mapcar 'idlwave-shell-update-bp-command-only old-bp-alist))))
(unless no-show (idlwave-shell-update-bp-overlays))
idlwave-shell-bp-alist)
(defun idlwave-shell-update-bp-command-only (bp)
(idlwave-shell-update-bp bp t))
(defun idlwave-shell-update-bp (bp &optional command-only)
"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
(if command-only
(setf (nth 1 (cdr (cdr match))) (nth 1 (cdr (cdr 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
(if bp-module
(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 &optional no-show)
"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 occurred at a different line than
specified. If NO-SHOW is non-nil, don't do any updating."
(idlwave-shell-send-command
idlwave-shell-bp-query
`(progn
(idlwave-shell-filter-bp (quote ,no-show))
(setq idlwave-shell-old-bp idlwave-shell-bp-alist))
'hide)
(idlwave-shell-module-source-query (idlwave-shell-bp-get bp 'module)
(idlwave-shell-bp-get bp 'type))
(let*
((count (idlwave-shell-bp-get bp 'count))
(condition (idlwave-shell-bp-get bp 'condition))
(disabled (idlwave-shell-bp-get bp 'disabled))
(key (concat (if (and count (numberp count))
(cond
((= count 1) ",/once")
((> count 1) (format ",after=%d" count))))
(if condition (concat ",CONDITION=\"" condition "\""))
(if (and disabled (not condition) (not count))
",/DISABLE")))
(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)
`(progn
(if (idlwave-shell-set-bp-check (quote ,bp))
(idlwave-shell-set-bp-adjust (quote ,bp) (quote ,no-show))))
(idlwave-shell-hide-p 'breakpoint)
'preempt t)))
(defun idlwave-shell-set-bp-adjust (bp &optional no-show)
"Find the breakpoint in IDL's internal list of breakpoints."
(idlwave-shell-send-command
idlwave-shell-bp-query
`(progn
(idlwave-shell-filter-bp 'no-show)
(idlwave-shell-new-bp (quote ,bp))
(unless (quote ,no-show)
(idlwave-shell-update-bp-overlays)))
'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-find-current-bp ()
"Find breakpoint here, or at halt location."
(let ((bp (idlwave-shell-find-bp (idlwave-shell-current-frame))))
(when (not bp)
(save-excursion
(idlwave-shell-goto-frame)
(idlwave-beginning-of-statement)
(setq bp (idlwave-shell-find-bp (idlwave-shell-current-frame))))
(unless bp
(beep)
(message "Cannot identify breakpoint for this line")))
bp))
(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)
(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)))
(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
"Alist of overlays marking breakpoints")
(defvar idlwave-shell-bp-glyph)
(defvar idlwave-shell-debug-line-map (make-sparse-keymap))
(define-key idlwave-shell-debug-line-map
(if (featurep 'xemacs) [button3] [mouse-3])
'idlwave-shell-mouse-active-bp)
(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."
(when idlwave-shell-mark-breakpoints
(let ((ov-alist (copy-alist idlwave-shell-bp-overlays))
(bp-list idlwave-shell-bp-alist)
(use-glyph (and (memq idlwave-shell-mark-breakpoints '(t glyph))
idlwave-shell-bp-glyph))
ov ov-list bp buf old-buffers win)
(if ov-alist
(while (setq ov-list (pop ov-alist))
(while (setq ov (pop (cdr ov-list)))
(add-to-list 'old-buffers (overlay-buffer ov))
(delete-overlay ov))))
(setq ov-alist idlwave-shell-bp-overlays
idlwave-shell-bp-overlays
(if idlwave-shell-bp-glyph
(mapcar 'list (mapcar 'car idlwave-shell-bp-glyph))
(list (list 'bp))))
(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)))
(condition (idlwave-shell-bp-get bp 'condition))
(count (idlwave-shell-bp-get bp 'count))
(disabled (idlwave-shell-bp-get bp 'disabled))
(type (if idlwave-shell-bp-glyph
(cond
(condition 'bp-cond )
(count
(cond
((<= count 0) 'bp)
((<= count 4)
(intern
(concat "bp-" (number-to-string count))))
(t 'bp-n)))
(t 'bp))
'bp))
(help-list
(delq nil
(list
(if count
(concat "after:" (int-to-string count)))
(if condition
(concat "condition:" condition))
(if disabled "disabled"))))
(help-text (concat
"BP "
(int-to-string (idlwave-shell-bp-get bp))
(if help-list
(concat
" - "
(mapconcat 'identity help-list ", ")))
(if (and (not count) (not condition))
" (use mouse-3 for breakpoint actions)")))
(full-type (if disabled
(intern (concat (symbol-name type)
"-disabled"))
type))
(ov-existing (assq full-type ov-alist))
(ov (or (and (cdr ov-existing)
(pop (cdr ov-existing)))
(idlwave-shell-make-new-bp-overlay type disabled)))
match)
(if idlwave-shell-breakpoint-popup-menu
(overlay-put ov 'help-echo help-text))
(move-overlay ov beg end)
(if (setq match (assq full-type idlwave-shell-bp-overlays))
(push ov (cdr match))
(nconc idlwave-shell-bp-overlays
(list (list full-type ov)))))
(when use-glyph
(if old-buffers
(setq old-buffers (delq (current-buffer) old-buffers)))
(if (fboundp 'set-specifier) (set-specifier left-margin-width (cons (current-buffer) 2))
(if (< left-margin-width 2)
(setq left-margin-width 2)))
(let ((window (get-buffer-window (current-buffer) 0)))
(if window
(set-window-margins
window left-margin-width right-margin-width))))))
(if use-glyph
(while (setq buf (pop old-buffers))
(with-current-buffer buf
(if (fboundp 'set-specifier) (set-specifier left-margin-width (cons (current-buffer) 0))
(setq left-margin-width 0))
(let ((window (get-buffer-window buf 0)))
(if window
(set-window-margins
window left-margin-width right-margin-width)))))))))
(defun idlwave-shell-make-new-bp-overlay (&optional type disabled)
"Make a new overlay for highlighting breakpoints.
This stuff is strongly dependant upon the version of Emacs. If TYPE
is passed, make an overlay of that type ('bp or 'bp-cond, currently
only for glyphs)."
(let ((ov (make-overlay 1 1))
(use-glyph (and (memq idlwave-shell-mark-breakpoints '(t glyph))
idlwave-shell-bp-glyph))
(type (or type 'bp))
(face (if disabled
idlwave-shell-disabled-breakpoint-face
idlwave-shell-breakpoint-face)))
(if (featurep 'xemacs)
(progn
(when idlwave-shell-breakpoint-popup-menu
(set-extent-property ov 'mouse-face 'highlight)
(set-extent-property ov 'keymap idlwave-shell-debug-line-map))
(cond
((eq (console-type) 'tty)
(set-extent-property ov 'face face))
(use-glyph
(let ((glyph (cdr (assq type idlwave-shell-bp-glyph))))
(if disabled (setq glyph (car glyph)) (setq glyph (nth 1 glyph)))
(set-extent-property ov 'begin-glyph glyph)
(set-extent-property ov 'begin-glyph-layout 'outside-margin)))
(idlwave-shell-mark-breakpoints
(set-extent-property ov 'face face))
(t nil))
(set-extent-priority ov -1)) (when idlwave-shell-breakpoint-popup-menu
(overlay-put ov 'mouse-face 'highlight)
(overlay-put ov 'keymap idlwave-shell-debug-line-map))
(cond
(window-system
(if use-glyph
(let ((image-props (cdr (assq type idlwave-shell-bp-glyph)))
string)
(if disabled (setq image-props
(append image-props
(list :conversion 'disabled))))
(setq string
(propertize "@"
'display
(list (list 'margin 'left-margin)
image-props)))
(overlay-put ov 'before-string string))
(overlay-put ov 'face face)))
(idlwave-shell-mark-breakpoints
(overlay-put ov 'face face))
(t nil)))
ov))
(defun idlwave-shell-mouse-active-bp (ev)
"Does right-click mouse action on breakpoint lines."
(interactive "e")
(if ev (mouse-set-point ev))
(let ((bp (idlwave-shell-find-bp (idlwave-shell-current-frame)))
index condition count select cmd disabled)
(unless bp
(error "Breakpoint not found"))
(setq index (int-to-string (idlwave-shell-bp-get bp))
condition (idlwave-shell-bp-get bp 'condition)
cmd (idlwave-shell-bp-get bp 'cmd)
count (idlwave-shell-bp-get bp 'count)
disabled (idlwave-shell-bp-get bp 'disabled))
(setq select (idlwave-popup-select
ev
(delq nil
(list (if disabled "Enable" "Disable")
"Clear"
"Clear All"
(if condition "Remove Condition" "Add Condition")
(if condition "Change Condition")
(if count "Remove Repeat Count"
"Add Repeat Count")
(if count "Change Repeat Count")))
(concat "BreakPoint " index)))
(if select
(cond
((string-equal select "Clear All")
(idlwave-shell-clear-all-bp))
((string-equal select "Clear")
(idlwave-shell-clear-current-bp))
((string-match "Condition" select)
(idlwave-shell-break-here count cmd
(if (or (not condition)
(string-match "Change" select))
(read-string "Break Condition: "))
disabled))
((string-match "Count" select)
(idlwave-shell-break-here (if (or (not count)
(string-match "Change" select))
(string-to-number
(read-string "Break After Count: ")))
cmd condition disabled))
((string-match "able$" select)
(idlwave-shell-toggle-enable-current-bp))
(t
(message "Unimplemented: %s" select))))))
(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 use the command
`idlwave-shell-edit-default-command-line' to edit the line."
(interactive "P")
(cond
((equal arg '(16))
(setq idlwave-shell-command-line-to-execute nil))
((equal arg '(4))
(setq idlwave-shell-command-line-to-execute
(read-string "IDL> " idlwave-shell-command-line-to-execute))))
(idlwave-shell-reset 'hidden)
(idlwave-shell-send-command
(or idlwave-shell-command-line-to-execute
(with-current-buffer (idlwave-shell-buffer)
(ring-ref comint-input-ring 0)))
'(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."
(if idlwave-shell-stop-line-overlay
(delete-overlay idlwave-shell-stop-line-overlay))
(if idlwave-shell-is-stopped
(idlwave-shell-electric-debug-all-off))
(setq idlwave-shell-is-stopped nil)
(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
"\"")
`(idlwave-shell-maybe-update-routine-info nil
,idlwave-shell-last-save-and-action-file)
(if (idlwave-shell-hide-p 'run) 'mostly) nil t)
(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))))
(defun idlwave-shell-maybe-update-routine-info (&optional wait file)
"Update the routine info if the shell is not stopped at an error."
(if (and (not idlwave-shell-is-stopped)
(or (eq t idlwave-auto-routine-info-updates)
(memq 'compile-buffer idlwave-auto-routine-info-updates))
idlwave-query-shell-for-routine-info
idlwave-routines)
(idlwave-shell-update-routine-info t nil wait file)))
(defvar idlwave-shell-sources-query "help,/source,/full"
"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-module-source-query (module &optional type)
"Determine the source file for a given module.
Query as a function if TYPE set to something beside 'pro."
(if module
(idlwave-shell-send-command
(format "print,(routine_info('%s',/SOURCE%s)).PATH" module
(if (eq type 'pro) "" ",/FUNCTIONS"))
`(idlwave-shell-module-source-filter ,module)
'hide 'wait)))
(defun idlwave-shell-module-source-filter (module)
"Get module source, and update idlwave-shell-sources-alist."
(let ((old (assoc (upcase module) idlwave-shell-sources-alist))
filename)
(when (string-match "\.PATH *[\n\r]\\([^%][^\r\n]+\\)[\n\r]"
idlwave-shell-command-output)
(setq filename (substring idlwave-shell-command-output
(match-beginning 1) (match-end 1)))
(if old
(setcdr old (list (idlwave-shell-file-name filename) filename))
(setq idlwave-shell-sources-alist
(append idlwave-shell-sources-alist
(list (cons (upcase module)
(list (idlwave-shell-file-name filename)
filename)))))))))
(defun idlwave-shell-sources-query ()
"Determine source files for all 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) (setq cpro (point))))
(if (re-search-forward "Compiled Functions:" nil t)
(progn
(setq cfun (point))
(setq idlwave-shell-sources-alist
(append
(progn
(beginning-of-line)
(narrow-to-region cpro (point))
(goto-char (point-min))
(idlwave-shell-sources-grep))
(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 (match-beginning 1) (match-end 1))
(let ((internal-filename
(buffer-substring (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 (lambda (x) (idlwave-shell-clear-bp x 'no-query))
idlwave-shell-bp-alist)
(idlwave-shell-bp-query))
'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-number
(buffer-substring (match-beginning 2)
(match-end 2)))))
(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 'disable))
(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))))
(defvar idlwave-shell-mode-map (copy-keymap comint-mode-map)
"Keymap for idlwave-mode.")
(defvar idlwave-shell-electric-debug-mode-map (make-sparse-keymap))
(defvar idlwave-shell-mode-prefix-map (make-sparse-keymap))
(fset 'idlwave-shell-mode-prefix-map idlwave-shell-mode-prefix-map)
(defvar idlwave-mode-prefix-map (make-sparse-keymap))
(fset 'idlwave-mode-prefix-map idlwave-mode-prefix-map)
(defun idlwave-shell-define-key-both (key hook)
"Define a key in both the shell and buffer mode maps."
(define-key idlwave-mode-map key hook)
(define-key idlwave-shell-mode-map key hook))
(define-key idlwave-shell-mode-map "\C-w" 'comint-kill-region)
(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-g" 'idlwave-keyboard-quit)
(define-key idlwave-shell-mode-map "\M-?" 'idlwave-context-help)
(define-key idlwave-shell-mode-map [(control meta ?\?)]
'idlwave-help-assistant-help-with-topic)
(define-key idlwave-shell-mode-map "\C-c\C-i" 'idlwave-update-routine-info)
(define-key idlwave-shell-mode-map "\C-c\C-y" 'idlwave-shell-char-mode-loop)
(define-key idlwave-shell-mode-map "\C-c\C-x" 'idlwave-shell-send-char)
(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 "\C-c\C-k" 'idlwave-kill-autoloaded-buffers)
(define-key idlwave-shell-mode-map idlwave-shell-prefix-key
'idlwave-shell-debug-map)
(define-key idlwave-shell-mode-map [(up)] 'idlwave-shell-up-or-history)
(define-key idlwave-shell-mode-map [(down)] 'idlwave-shell-down-or-history)
(define-key idlwave-mode-map "\C-c\C-y" 'idlwave-shell-char-mode-loop)
(define-key idlwave-mode-map "\C-c\C-x" 'idlwave-shell-send-char)
(idlwave-shell-define-key-both
(if (featurep 'xemacs)
[(shift button2)]
[(shift down-mouse-2)])
'idlwave-shell-mouse-print)
(idlwave-shell-define-key-both
(if (featurep 'xemacs)
[(control meta button2)]
[(control meta down-mouse-2)])
'idlwave-shell-mouse-help)
(idlwave-shell-define-key-both
(if (featurep 'xemacs)
[(control shift button2)]
[(control shift down-mouse-2)])
'idlwave-shell-examine-select)
(define-key idlwave-shell-mode-map
(if (featurep 'xemacs)
[(shift button3)]
[(shift mouse-3)])
'idlwave-mouse-context-help)
(defun idlwave-shell-mouse-nop (event)
(interactive "e"))
(unless (featurep 'xemacs)
(idlwave-shell-define-key-both
[(shift mouse-2)] 'idlwave-shell-mouse-nop)
(idlwave-shell-define-key-both
[(shift control mouse-2)] 'idlwave-shell-mouse-nop)
(idlwave-shell-define-key-both
[(control meta mouse-2)] 'idlwave-shell-mouse-nop))
(let* ((specs
'(([(control ?b)] ?b idlwave-shell-break-here t t)
([(control ?i)] ?i idlwave-shell-break-in t t)
([(control ?j)] ?j idlwave-shell-break-this-module t t)
([(control ?d)] ?d idlwave-shell-clear-current-bp t)
([(control ?a)] ?a idlwave-shell-clear-all-bp t)
([(control ?\\)] ?\\ idlwave-shell-toggle-enable-current-bp t)
([(control ?s)] ?s idlwave-shell-step t)
([(control ?n)] ?n idlwave-shell-stepover t)
([(control ?k)] ?k idlwave-shell-skip t)
([(control ?u)] ?u idlwave-shell-up t)
([(control ?o)] ?o idlwave-shell-out t)
([(control ?m)] ?m idlwave-shell-return t)
([(control ?h)] ?h idlwave-shell-to-here t t)
([(control ?r)] ?r idlwave-shell-cont t)
([(control ?y)] ?y idlwave-shell-execute-default-command-line)
([(control ?z)] ?z idlwave-shell-reset t)
([(control ?q)] ?q idlwave-shell-quit)
([(control ?p)] ?p idlwave-shell-print t)
([( ??)] ?? idlwave-shell-help-expression t)
([(control ?v)] ?v idlwave-shell-toggle-electric-debug-mode t t)
([(control ?x)] ?x idlwave-shell-goto-next-error)
([(control ?c)] ?c idlwave-shell-save-and-run t)
([( ?@)] ?@ idlwave-shell-save-and-batch)
([(control ?e)] ?e idlwave-shell-run-region)
([(control ?w)] ?w idlwave-shell-resync-dirs)
([(control ?l)] ?l idlwave-shell-redisplay t)
([(control ?t)] ?t idlwave-shell-toggle-toolbar)
([(control up)] up idlwave-shell-stack-up)
([(control down)] down idlwave-shell-stack-down)
([( ?[)] ?[ idlwave-shell-goto-previous-bp t t)
([( ?])] ?] idlwave-shell-goto-next-bp t t)
([(control ?f)] ?f idlwave-shell-window)))
(mod (cond ((and idlwave-shell-debug-modifiers
(listp idlwave-shell-debug-modifiers)
(not (equal '() idlwave-shell-debug-modifiers)))
idlwave-shell-debug-modifiers)
(idlwave-shell-activate-alt-keybindings
'(alt))))
(shift (memq 'shift mod))
(mod-noshift (delete 'shift (copy-sequence mod)))
s k1 c2 k2 cmd electric only-buffer cannotshift)
(while (setq s (pop specs))
(setq k1 (nth 0 s)
c2 (nth 1 s)
cmd (nth 2 s)
electric (nth 3 s)
only-buffer (nth 4 s)
cannotshift (and shift (char-valid-p c2) (eq c2 (upcase c2))))
(when (and idlwave-shell-activate-prefix-keybindings k1)
(unless only-buffer
(define-key idlwave-shell-mode-prefix-map k1 cmd))
(define-key idlwave-mode-prefix-map k1 cmd))
(when (and mod window-system)
(if (char-or-string-p c2)
(setq k2 (vector (append mod-noshift
(list (if shift (upcase c2) c2)))))
(setq k2 (vector (append mod (list c2)))))
(unless cannotshift
(define-key idlwave-mode-map k2 cmd)
(unless only-buffer (define-key idlwave-shell-mode-map k2 cmd))))
(if (and electric (char-or-string-p c2))
(define-key idlwave-shell-electric-debug-mode-map (char-to-string c2)
cmd))))
(define-key idlwave-shell-electric-debug-mode-map " " 'idlwave-shell-step)
(define-key idlwave-shell-electric-debug-mode-map "+" 'idlwave-shell-stack-up)
(define-key idlwave-shell-electric-debug-mode-map "=" 'idlwave-shell-stack-up)
(define-key idlwave-shell-electric-debug-mode-map "-"
'idlwave-shell-stack-down)
(define-key idlwave-shell-electric-debug-mode-map "_"
'idlwave-shell-stack-down)
(define-key idlwave-shell-electric-debug-mode-map "e"
'(lambda () (interactive) (idlwave-shell-print '(16))))
(define-key idlwave-shell-electric-debug-mode-map "q" 'idlwave-shell-retall)
(define-key idlwave-shell-electric-debug-mode-map "t"
'(lambda () (interactive) (idlwave-shell-send-command "help,/TRACE")))
(define-key idlwave-shell-electric-debug-mode-map [(control ??)]
'idlwave-shell-electric-debug-help)
(define-key idlwave-shell-electric-debug-mode-map "x"
'(lambda (arg) (interactive "P")
(idlwave-shell-print arg nil nil t)))
(fset 'idlwave-debug-map idlwave-mode-prefix-map)
(fset 'idlwave-shell-debug-map idlwave-shell-mode-prefix-map)
(defun idlwave-shell-toggle-electric-debug-mode ()
"Toggle electric-debug-mode, suppressing re-entry into mode if turned off."
(interactive)
(if idlwave-shell-electric-debug-mode
(progn (setq idlwave-shell-suppress-electric-debug t)
(idlwave-shell-electric-debug-mode 0))
(setq idlwave-shell-suppress-electric-debug nil)
(idlwave-shell-electric-debug-mode t)))
(defvar idlwave-shell-electric-debug-read-only)
(defvar idlwave-shell-electric-debug-buffers nil)
(define-minor-mode idlwave-shell-electric-debug-mode
"Toggle Electric Debug mode.
With no argument, this command toggles the mode.
Non-null prefix argument turns on the mode.
Null prefix argument turns off the mode.
When Electric Debug mode is enabled, the many debugging commands are
available as single key sequences."
nil
" *Debugging*"
idlwave-shell-electric-debug-mode-map)
(add-hook
'idlwave-shell-electric-debug-mode-on-hook
(lambda ()
(set (make-local-variable 'idlwave-shell-electric-debug-read-only)
buffer-read-only)
(setq buffer-read-only t)
(add-to-list 'idlwave-shell-electric-debug-buffers (current-buffer))
(if idlwave-shell-stop-line-overlay
(overlay-put idlwave-shell-stop-line-overlay 'face
idlwave-shell-electric-stop-line-face))
(if (facep 'fringe)
(set-face-foreground 'fringe idlwave-shell-electric-stop-color
(selected-frame)))))
(add-hook
'idlwave-shell-electric-debug-mode-off-hook
(lambda ()
(setq buffer-read-only (if (boundp 'idlwave-shell-electric-debug-read-only)
idlwave-shell-electric-debug-read-only))
(setq idlwave-shell-electric-debug-buffers
(delq (current-buffer) idlwave-shell-electric-debug-buffers))
(if idlwave-shell-stop-line-overlay
(overlay-put idlwave-shell-stop-line-overlay 'face
idlwave-shell-stop-line-face)
(if (facep 'fringe)
(set-face-foreground 'fringe (face-foreground 'default))))))
(defadvice idlwave-shell-electric-debug-mode (after print-enter activate)
"Print out an entrance message"
(when idlwave-shell-electric-debug-mode
(message
"Electric Debugging mode entered. Press [C-?] for help, [q] to quit"))
(force-mode-line-update))
(defvar idlwave-shell-electric-debug-buffers nil)
(defun idlwave-shell-electric-debug-all-off ()
(setq idlwave-shell-suppress-electric-debug nil)
(let ((buffers idlwave-shell-electric-debug-buffers)
buf)
(save-excursion
(while (setq buf (pop buffers))
(when (buffer-live-p buf)
(set-buffer buf)
(when (and (eq major-mode 'idlwave-mode)
buffer-file-name
idlwave-shell-electric-debug-mode)
(idlwave-shell-electric-debug-mode 0))))))
(setq idlwave-shell-electric-debug-buffers nil))
(defun idlwave-shell-electric-debug-help ()
(interactive)
(with-output-to-temp-buffer "*IDLWAVE Electric Debug Help*"
(princ idlwave-shell-electric-debug-help))
(let* ((current-window (selected-window))
(window (get-buffer-window "*IDLWAVE Electric Debug Help*"))
(window-lines (window-height window)))
(select-window window)
(enlarge-window (1+ (- (count-lines 1 (point-max)) window-lines)))
(select-window current-window)))
(defvar idlwave-shell-menu-def
`("Debug"
["Electric Debug Mode"
idlwave-shell-electric-debug-mode
:style toggle :selected idlwave-shell-electric-debug-mode
:included (eq major-mode 'idlwave-mode) :keys "C-c C-d C-v"]
"--"
("Compile & Run"
["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]
"--"
["Compile and Run Region" idlwave-shell-run-region
(eq major-mode 'idlwave-mode)]
["Evaluate Region" idlwave-shell-evaluate-region
(eq major-mode 'idlwave-mode)]
"--"
["Execute Default Cmd" idlwave-shell-execute-default-command-line t]
["Edit Default Cmd" idlwave-shell-edit-default-command-line t])
("Breakpoints"
["Set Breakpoint" idlwave-shell-break-here
:keys "C-c C-d C-b" :active (eq major-mode 'idlwave-mode)]
("Set Special Breakpoint"
["Set After Count Breakpoint"
(progn
(let ((count (string-to-number (read-string "Break after count: "))))
(if (integerp count) (idlwave-shell-break-here count))))
:active (eq major-mode 'idlwave-mode)]
["Set Condition Breakpoint"
(idlwave-shell-break-here '(4))
:active (eq major-mode 'idlwave-mode)])
["Break in Module" idlwave-shell-break-in
:keys "C-c C-d C-i" :active (eq major-mode 'idlwave-mode)]
["Break in this Module" idlwave-shell-break-this-module
:keys "C-c C-d C-j" :active (eq major-mode 'idlwave-mode)]
["Clear Breakpoint" idlwave-shell-clear-current-bp t]
["Clear All Breakpoints" idlwave-shell-clear-all-bp t]
["Disable/Enable Breakpoint" idlwave-shell-toggle-enable-current-bp t]
["Goto Previous Breakpoint" idlwave-shell-goto-previous-bp
:keys "C-c C-d [" :active (eq major-mode 'idlwave-mode)]
["Goto Next Breakpoint" idlwave-shell-goto-next-bp
:keys "C-c C-d ]" :active (eq major-mode 'idlwave-mode)]
["List All Breakpoints" idlwave-shell-list-all-bp t]
["Resync Breakpoints" idlwave-shell-bp-query t])
("Continue/Step"
["Step (into)" idlwave-shell-step t]
["Step (over)" idlwave-shell-stepover t]
["Skip One Statement" idlwave-shell-skip t]
["Continue" idlwave-shell-cont t]
["... to End of Block" idlwave-shell-up t]
["... to End of Subprog" idlwave-shell-return t]
["... to End of Subprog+1" idlwave-shell-out t]
["... to Here (Cursor Line)" idlwave-shell-to-here
:keys "C-c C-d C-h" :active (eq major-mode 'idlwave-mode)])
("Examine Expressions"
["Print expression" idlwave-shell-print t]
["Help on expression" idlwave-shell-help-expression t]
("Examine nearby expression with"
,@(mapcar (lambda(x)
`[ ,(car x) (idlwave-shell-print nil ',x) t ])
idlwave-shell-examine-alist))
("Examine region with"
,@(mapcar (lambda(x)
`[ ,(car x) (idlwave-shell-print '(4) ',x) t ])
idlwave-shell-examine-alist)))
("Call Stack"
["Stack Up" idlwave-shell-stack-up t]
["Stack Down" idlwave-shell-stack-down t]
"--"
["Redisplay and Sync" idlwave-shell-redisplay t])
("Show Commands"
["Everything" (if (eq idlwave-shell-show-commands 'everything)
(progn
(setq idlwave-shell-show-commands
(get 'idlwave-shell-show-commands 'last-val))
(put 'idlwave-shell-show-commands 'last-val nil))
(put 'idlwave-shell-show-commands 'last-val
idlwave-shell-show-commands)
(setq idlwave-shell-show-commands 'everything))
:style toggle :selected (and (not (listp idlwave-shell-show-commands))
(eq idlwave-shell-show-commands
'everything))]
"--"
["Compiling Commands" (idlwave-shell-add-or-remove-show 'run)
:style toggle
:selected (not (idlwave-shell-hide-p
'run
(get 'idlwave-shell-show-commands 'last-val)))
:active (not (eq idlwave-shell-show-commands 'everything))]
["Breakpoint Commands" (idlwave-shell-add-or-remove-show 'breakpoint)
:style toggle
:selected (not (idlwave-shell-hide-p
'breakpoint
(get 'idlwave-shell-show-commands 'last-val)))
:active (not (eq idlwave-shell-show-commands 'everything))]
["Debug Commands" (idlwave-shell-add-or-remove-show 'debug)
:style toggle
:selected (not (idlwave-shell-hide-p
'debug
(get 'idlwave-shell-show-commands 'last-val)))
:active (not (eq idlwave-shell-show-commands 'everything))]
["Miscellaneous Commands" (idlwave-shell-add-or-remove-show 'misc)
:style toggle
:selected (not (idlwave-shell-hide-p
'misc
(get 'idlwave-shell-show-commands 'last-val)))
:active (not (eq idlwave-shell-show-commands 'everything))])
("Input Mode"
["Send one char" idlwave-shell-send-char t]
["Temporary Character Mode" idlwave-shell-char-mode-loop t]
"--"
["Use Input Mode Magic"
(setq idlwave-shell-use-input-mode-magic
(not idlwave-shell-use-input-mode-magic))
:style toggle :selected idlwave-shell-use-input-mode-magic])
"--"
["Update Working Dir" idlwave-shell-resync-dirs t]
["Save Path Info"
(idlwave-shell-send-command idlwave-shell-path-query
'idlwave-shell-get-path-info
'hide)
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-mode-debug-menu idlwave-mode-map "IDL debugging menus"
idlwave-shell-menu-def)
(easy-menu-define
idlwave-shell-mode-menu idlwave-shell-mode-map "IDL shell 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)))))
(defvar idlwave-shell-bp-glyph nil
"The glyphs to mark breakpoint lines in the source code.")
(let ((image-alist
'((bp . "/* XPM */
static char * file[] = {
\"14 12 3 1\",
\" c None s backgroundColor\",
\". c #4B4B4B4B4B4B\",
\"R c #FFFF00000000\",
\" \",
\" .... \",
\" .RRRR. \",
\" .RRRRRR. \",
\" .RRRRRRRR. \",
\" .RRRRRRRR. \",
\" .RRRRRRRR. \",
\" .RRRRRRRR. \",
\" .RRRRRR. \",
\" .RRRR. \",
\" .... \",
\" \"};")
(bp-cond . "/* XPM */
static char * file[] = {
\"14 12 4 1\",
\" c None s backgroundColor\",
\". c #4B4B4B4B4B4B\",
\"R c #FFFF00000000\",
\"B c #000000000000\",
\" \",
\" .... \",
\" .RRRR. \",
\" .RRRRRR. \",
\" .RRRRRRRR. \",
\" .RRBBBBRR. \",
\" .RRRRRRRR. \",
\" .RRBBBBRR. \",
\" .RRRRRR. \",
\" .RRRR. \",
\" .... \",
\" \"};")
(bp-1 . "/* XPM */
static char * file[] = {
\"14 12 4 1\",
\" c None s backgroundColor\",
\". c #4B4B4B4B4B4B\",
\"X c #FFFF00000000\",
\"o c #000000000000\",
\" \",
\" .... \",
\" .XXXX. \",
\" .XXooXX. \",
\" .XXoooXXX. \",
\" .XXXooXXX. \",
\" .XXXooXXX. \",
\" .XXooooXX. \",
\" .XooooX. \",
\" .XXXX. \",
\" .... \",
\" \"};")
(bp-2 . "/* XPM */
static char * file[] = {
\"14 12 4 1\",
\" c None s backgroundColor\",
\". c #4B4B4B4B4B4B\",
\"X c #FFFF00000000\",
\"o c #000000000000\",
\" \",
\" .... \",
\" .XXXX. \",
\" .XoooXX. \",
\" .XXoXooXX. \",
\" .XXXXooXX. \",
\" .XXXooXXX. \",
\" .XXooXXXX. \",
\" .XooooX. \",
\" .XXXX. \",
\" .... \",
\" \"};")
(bp-3 . "/* XPM */
static char * file[] = {
\"14 12 4 1\",
\" c None s backgroundColor\",
\". c #4B4B4B4B4B4B\",
\"X c #FFFF00000000\",
\"o c #000000000000\",
\" \",
\" .... \",
\" .XXXX. \",
\" .XoooXX. \",
\" .XXXXooXX. \",
\" .XXXooXXX. \",
\" .XXXXooXX. \",
\" .XXoXooXX. \",
\" .XoooXX. \",
\" .XXXX. \",
\" .... \",
\" \"};")
(bp-4 . "/* XPM */
static char * file[] = {
\"14 12 4 1\",
\" c None s backgroundColor\",
\". c #4B4B4B4B4B4B\",
\"X c #FFFF00000000\",
\"o c #000000000000\",
\" \",
\" .... \",
\" .XXXX. \",
\" .XoXXoX. \",
\" .XXoXXoXX. \",
\" .XXooooXX. \",
\" .XXXXooXX. \",
\" .XXXXooXX. \",
\" .XXXooX. \",
\" .XXXX. \",
\" .... \",
\" \"};")
(bp-n . "/* XPM */
static char * file[] = {
\"14 12 4 1\",
\" c None s backgroundColor\",
\". c #4B4B4B4B4B4B\",
\"X c #FFFF00000000\",
\"o c #000000000000\",
\" \",
\" .... \",
\" .XXXX. \",
\" .XXXXXX. \",
\" .XXoXoXXX. \",
\" .XXooXoXX. \",
\" .XXoXXoXX. \",
\" .XXoXXoXX. \",
\" .XoXXoX. \",
\" .XXXX. \",
\" .... \",
\" \"};"))) im-cons im)
(while (setq im-cons (pop image-alist))
(setq im (cond ((and (featurep 'xemacs)
(featurep 'xpm))
(list
(let ((data (cdr im-cons)))
(string-match "#FFFF00000000" data)
(setq data (replace-match "#8F8F8F8F8F8F" t t data))
(make-glyph data))
(make-glyph (cdr im-cons))))
((and (not (featurep 'xemacs))
(fboundp 'image-type-available-p)
(image-type-available-p 'xpm))
(list 'image :type 'xpm :data (cdr im-cons)
:ascent 'center))
(t nil)))
(if im (push (cons (car im-cons) im) idlwave-shell-bp-glyph))))
(provide 'idlw-shell)
(provide 'idlwave-shell)
(autoload 'idlwave-toolbar-toggle "idlw-toolbar"
"Toggle the IDLWAVE toolbar")
(autoload 'idlwave-toolbar-add-everywhere "idlw-toolbar"
"Add IDLWAVE toolbar")
(defun idlwave-shell-toggle-toolbar ()
"Toggle the display of the debugging toolbar."
(interactive)
(idlwave-toolbar-toggle))
(if idlwave-shell-use-toolbar
(add-hook 'idlwave-shell-mode-hook 'idlwave-toolbar-add-everywhere))