| |
| |
|
|
|
|
Fully Integrated within the IDE
|
|
|
Visual Xbase++ is shipped with a visual source-level debugger that is
fully integrated into the development environment. This means that all
debugger commands are available within VX and that you are free to use the IDE's
other tools within a debugging session. Breakpoints can be set directly
in the source code editor, the "Find" command can be used to locate code
sections for debugging or the IntelliHelp system can point out the
parameter profile of a function that you think might be called incorrectly.
Furthermore, erroneous code can be corrected on the spot, that is, without
having to exit the debugger.
|
|
| |
|
|
Full Variable Inspection
|
|
|
The Visual Debugger uses various views for displaying objects
within the context of the application being debugged. Variables
of simple types, such as NUMERIC or CHARACTER variables, can
be inspected sorted by type and/or name in the Variables view.
The values of variables that contain OBJECTs and ARRAYs are
displayed in the so-called Object Inspector, a special view
that allows for an easy inspection of array elements and object
members. Complex object relations, such as an Xbase PARTs
parent/child relationship, are instantly visible through Object
Inspector's hierarchical display.
|
|
| |
|
|
|
| |
|
|
Realtime Expression Evaluation
|
|
The VX debugger is fully integrated with the IDE's Command Window,
allowing you to perform various actions while debugging your application.
Furthermore, the Command Window can be used to execute expressions of
any complexity, including expressions which reference variables defined
in the context of an application running in the debugger.
Visual Xbase++ also incorporates an Expression Inspector for easy
expression manipulation. Last but not least, every expression present
in your Xbase++ source code can easily be evaluated, simply by selecting
it with the mouse in the source code editor. Likewise, the current value
of any variable can be made visible via the tooltip mechanism built
into the Visual Xbase++ IDE. The system can even be configured
to inspect a function's or method's return value, just by pointing at
it with the mouse!
|
|
| |
|
|
|
| |
|
|
Enhanced Breakpoint Management
|
|
|
Visual Xbase++ introduces a new level of breakpoint management
to the Xbase++ development platform. Every breakpoint set
in an application loaded into the VX debugger is not only within easy
reach through the intuitive Breakpoints view. All breakpoint information
is also transparently maintained in your application's project (.XPJ)
file! Just like other information pertaining to a debugging session,
your breakpoints will be automatically restored the next time you load
your project into Visual Xbase++.
|
|
| |
|
|
|
| |
|
|
The Visual Xbase++ debugger supports a host of breakpoint options,
such as arbitrary breakpoint expressions or options for logging occurances
of a breakpoint to a file. You can even set breakpoints while your
application is running!
|
|
| |
|
|
Watch View
|
|
|
All expressions that can be executed via the Command Window or the
IDE's Expression Inspector can also be made permanent in the Watch
view. This way, the value of the expression is evaluated each time
a debugger command is performed. This feature is invaluable, especially
when debugging functionality that is highly dynamic, such as focus
changes in your GUI triggered by your application's event loop.
|
|
| |
|
|
Debugging DLLs and WAA (Web Application Adaptor) Packages
|
|
|
With the introduction of the debugger integrated into Visual
Xbase++, finding problems in DLL-based code
became even easier! Just like the traditional Xbase++
debugger, VX does not impose restrictions for debugging across
module boundaries. Instead, every DLL loaded by an application
can be debugged just like any other Xbase++ code.
If the source code of a DLL is available, all editing
and browsing capabilities of the IDE can be used to work with
it, even when debugging.
|
|
| |
|
|
|
| |
|
|
The new debugger also makes the maintenance of DLL-based projects
or targets a whole lot easier, simply by introducing the concept of
a DLL host application. With this concept, an executable (.EXE), which
acts as host application during debugging, can be specified. This way,
your DLL can be automatically loaded for debugging. When developing WAA (Web
Application Adaptor) packages, this feature allows to debug a package
without having to load the WAA's executable into the debugger, for
example. Also, all persistent information pertaining to a debugging
session, such as breakpoint locations for example, is kept local for
the respective DLL. This way, each DLL defined within a project file
can be debugged with a completely different environment. |
|
|
|
