|
Comprehensive Features List
Textual Debugger
- Textual
commands
- User can invoke many JSwat commands
from the command input field. The textual commands are
powerful because of the number of options they support. The
commands are also extensible via command
aliases.
- Command
history
- Commands are stored in a
"history chain" and can be invoked using the
!<prefix> and !! operators.
Earlier commands can be recalled using the up and down
cursor keys (or Ctrl-p and Ctrl-n keys) to move backward
and forward through the command history. (Note, this
feature is not available in console mode.)
- Aliases
- Commands can be aliased to other
names, offering users the ability to make their interface
more comfortable. A command and its parameters can be
aliased. The alias can be invoked by the alias name, and
may include additional parameters to the original
command.
- Scripts
- Commands can be stored in a plain
text file and executed using the
read command.
The script can contain any commands and aliases but cannot
use the ! or !!
operators.
Graphical Debugger
- Threads
display
- Table displays threads in the
debuggee VM, including the ID, name, and status of the
thread. Columns of the table can be resized and
reordered.
- Classes
tree
- Tree displays all classes in the
debuggee VM, including inner classes. Double-clicking on a
class will attempt to find and display the corresponding
source file.
- Local
variables
- A tree displays the local variables
by name, type and value. Variables are sorted by name in
alphabetical order. Object variables can be expanded to
show their field variables. Array variables can be expanded
to show the first five and last one of the array elements.
Double-clicking on the "..." entry of an array
will expand the list to show all array entries.
- Watchpoints
- Table that displays watched
variables and their values. The values are updated in
real-time as the debuggee VM is running. The watch panel
can watch any field variable of any object.
- Stack
frames
- Table that shows the list of stack
frames. Shows the frame number, the class and method
information, and the source file name and line number, if
known. Double-clicking on a row in the stack panel will set
the current stack frame and opens the source code and
scrolls to the appropriate line.
- Source code
viewer
- Source files (any files for that
matter) may be opened into a text area and viewed.
Breakpoints may be set and altered using the popup menu in
the source viewer (usually by right-clicking on the mouse).
Source code viewer shows line numbers in the left column,
shows where breakpoints are located, and indicates the
currently executing line of code when single-stepping. The
view is automatically refreshed when the session is
restarted.
- Breakpoints
display
- This panel displays breakpoints and
allows enabling, disabling, and deleting the breakpoints.
In addition buttons allow the user to create new
breakpoints and breakpoint groups. There are also buttons
to manage the breakpoint properties and display the source
code near the breakpoint.
- Capture Debugger
Messages
- During a debugging session, JSwat
outputs numerous messages, usually the output of debugger
commands. Normally this output is printed to a text area
within the JSwat window. In addition to this text area, it
is possible to capture the messages to either the JSwat
standard output stream (the console that started JSwat) or
to a named file.
- Keyboard
Shortcuts
- Several of the JSwat menu items have
keyboard shortcuts to provide another easy method of
invoking JSwat actions. For example, the single stepping
actions each have function key shortcuts. A single press of
the assigned function key and the single step action takes
place. On most systems the menu items will indicate the
assigned shortcut keys.
- Toolbar
- A toolbar provides one-click access
to several key features in JSwat, including
single-stepping, starting and stopping the debuggee VM, and
setting breakpoints.
- Look and
Feel
- Choose from the available look and
feel settings. Not all choices will be available on all
systems, especially the "Windows" and
"Macintosh" look and feels.
Common Features
- Starting
JSwat
- When invoking JSwat from the command
line, it is possible to execute an arbitrary command
immediately. JSwat reads the command and its arguments
given on command line and carries out the operation as soon
as JSwat has finished loading.
- Catch
exceptions
- Exceptions in the debuggee VM can be
caught by JSwat and displayed in the debugger. Exceptions
are handled just like breakpoints, and can have filters
applied to them.
- Thread/stack
viewing
- At any time the debuggee VM is
suspended, JSwat can display the stack trace of any thread.
Local variables in any stack frame in any thread can also
be displayed in the message window.
- User
Preferences
- Many of JSwat's optional or
otherwise configurable settings are managed by a
preferences dialog. This dialog provides a means for
setting options such as which keys activate certain
keyboard shortcuts. Changing any of the settings will take
effect immediately in JSwat. Some of the preferences can
also be managed with the '
options '
command, which is useful when running the program in
console mode.
- Start-up
Scripts
- JSwat supports the use of start-up
scripts, called "
.jswatrc ". These
files are simply command scripts (as described above, under
"Textual Debugger") that are executed by JSwat
when it is started. First, JSwat looks for a
jswatrc file in the .jswat
directory in the user's home directory. Next, JSwat
looks for additional .jswatrc files in the
current working directory and all parent directories. This
is useful for keeping user-specific settings in the home
directory, while keeping project-specific settings with the
project files.
|
|
|
|