View source for Ide/Debugger

From wiki.visual-prolog.com
You do not have permission to edit this page, for the following reasons:
The action you have requested is limited to users in the group: emailconfirmed.
You must confirm your email address before editing pages. Please set and validate your email address through your user preferences.
You can view and copy the source of this page.
{{ideNavbar|Debugger}}
== Visual Prolog Debugger ==

Visual Prolog Debugger is a powerful tool for finding errors in programs. Sometimes correcting errors in programs takes about 90% of the total development time. This proves that good tools for debugging are very important.

Visual Prolog Debugger can debug MS Windows 32/64-bit Graphical User Interface and Console applications and DLLs.

Visual Prolog Debugger provides ability to trace program execution. In the debugger one can set breakpoints, step through the source code (with viewing traced code both on Prolog and disassembler levels). The debugger allows inspecting variables used in the currently traced clause, viewing and retracting facts, viewing memory dumps, viewing the stack of predicate calls, viewing breakpoints inserted into the program, viewing registers, etc.

Visual Prolog Debugger is the IDE tool, which can be run with the '''Debug | Run''' menu command, with the '''F5''' hot key, or with the [[Image:Ide_db_Run.png]] toolbar button.

== Generation of Debugging Information ==

Generation of the information for Visual Prolog Debugger is controlled by copmiler's option [..\Command_Line_Tools\Command_Line_.htm#DEBug /debug:full]. By default, the Visual Prolog IDE always generates debugging information while compiling project modules.

== Starting Visual Prolog Debugger ==

When you start Visual Prolog Debugger (with the '''Debug | Run''' menu command, or with the '''F5''' hot key, or with the [[Image:Ide_db_Run.png]] toolbar button), then the IDE builds (if it is needed) the project, runs the target executable under the debugger, and breaks the program execution at the entry point of the goal section:

[[Image:Ide_db_Start.png]]

If in the '''Run Arguments''' edit control (in the '''Build Options''' tab of the '''Project Settings''' dialog) you have specified a string with command line arguments, then this string is passed to the program.

== Debug Menu Commands ==

The '''Debug''' menu is used to control execution of the program being debugged.

[[Image:Ide_db_DebugMenu.png|center|frame|'''The Debug Menu''']]

*'''Run (F5)'''
*:This command continues running the application. Issuing this command, when the IDE does not debug an application, builds (if needed) the application and starts its execution under the debugger. This command is often used in conjunction with setting of breakpoints.
*'''Run Skipping Soft Breakpoints (Ctrl+Shift+F10)'''
*:This command continues running the application without breaks at ''Soft Breakpoint'' (see [Breakpoints_Window.htm Breakpoints Window] for more details).

*'''Stop Debugging (Shift+F5)'''
*:This command stops the program execution. The IDE becomes active in the ordinary mode.

*'''Break Program'''
*:When a program is executed (the program instructions are executed and the debugger is waiting till the program stops and returns control to the debugger), then with this command it is possible to break the program execution and to return control to the debugger. Then it is possible to inspect the call stack to see what the program is actually doing or to set a breakpoint where to catch the execution. Notice that this command is disabled while the debugger is active (when the program instructions are not executed).

*'''Restart'''
*:This command restarts the application execution under the debugger.

*'''Attach process...'''
*:It commands the debugger to attach to a process.

*'''Step Over (F10)'''
*:It instructs the debugger to execute the next line of code. If the line contains a predicate call, '''Step Over''' executes the entire predicate, then halts at the first line outside the predicate.
*:<br/>If this command is used, then when you reach a predicate call, the predicate is executed without stepping through the predicate clauses (without entering into source code of the predicate).
*:<br/>Use '''Step Over''' if you want to avoid stepping into predicates.

*'''Step Into (F11)'''
*:'''Step Into''' and '''Step Over''' differ in only one aspect — how they handle predicate calls.
*:'''Step Into''' instructs the debugger to execute the next line of code.
*:If the line contains a predicate call, '''Step Into''' executes only the call itself, then halts at the first line of code inside the predicate.
*:<br/> '''Step Into''' if you want entering into clauses of each called predicate.

*'''Step out of (Shift+F11)'''
*:This command accomplishes execution of clauses of the currently executing predicate and calls the next predicate.

*'''Run to Cursor (CTRL+F10)'''
*:It commands the debugger to run the application until it reaches the location where the cursor is set. This location can be both in Visual Prolog source code or in Disassembly window.
*:<br/>Place the cursor on a line and activate this command; the application will start execution until the line pointed by the cursor (if it can come to this predicate call). The ''Instruction Pointer'' will point to this line.

*'''Go to Executing Predicate Source (Ctrl+E)'''
*:If you have moved in the program source windows and have lost the ''Instruction Pointer'', then you may execute this command. It sets the cursor to the line containing the currently executing predicate (pointed by the ''Instruction Pointer'').

*'''Break on Exception'''
*:When this option is checked ON and if an exception occurs, then execution of program is stopped. Then you will be able to use the '''Run Stack''' window to locate your predicate in which the exception occurs. See how to {{ide|Debugger#How to Use Break on Exception|Use Break on Exception}} for more information.

*'''Toggle Breakpoint (F9)'''
*:Using this command you can set a breakpoint to any executable line in program source files.

*'''Remove All Breakpoints'''
*:This command removes all previously set breakpoints.

== How to Use Break on Exception ==

Some times, it is difficult to locate which your source code predicate generates an exception. In such situation the '''Break on Exception''' option can be helpful.

Start to debug your program. When its execution will be close to the expected exception, turn ON the '''Break on Exception''' option. (It can be inconvenient to turn the '''Break on Exception''' option from the begin of the debugger execution since this can bother you with some otherwise masked exceptions.)

When an exception occurs, Debugger catches it and execution of a debugged program is stopped.

Then you will be able to use the '''Run Stack''' window to locate the predicate in which the exception occurs and to inspect the sequence of calls which lead the exception. The topmost in the '''Run Stack''' window line corresponds to the last executed predicate. You can double click a line in this window to inspect a clause of the correspondent predicate. If there are no available sources for the '''Run Stack''' window entry, the Debugger will show the machine instructions in the '''Disassembler''' window.

== Debugger Views ==

Several debugger windows can be opened from the '''View''' menu:

[[Image:Ide_db_ViewWndows.png|center|frame|'''The View Sub-menu''']]

The windows, which can be used in the debugger (debugger views), are:

*{{ide|Debugger#Run Stack Window|Run Stack}} ('''CTRL+Alt+C''')
*{{ide|Debugger#Variables Window|Variables for Current Clause}} ('''CTRL+Alt+V''')
*{{ide|Debugger#Facts Window|Facts}} ('''CTRL+Alt+F''')
*{{ide|Debugger#Breakpoints Window|BreakPoints}} ('''CTRL+Alt+B''')
*{{ide|Debugger#Threads Window|Threads}} ('''CTRL+Alt+H''')]
*{{ide|Debugger#Modules Window|Modules}}
*{{ide|Debugger#Disassembly Window|Disassembly}} ('''CTRL+Alt+D''')]
*{{ide|Debugger#Registers Window|Registers}} ('''CTRL+Alt+G''')]
*{{ide|Debugger#Memory Dump Window|Memory Dump}} ('''CTRL+Alt+M''')]

Also the following two windows, which are not only debugger windows (debugger views), can also be used while debugging:

*{{ide|Debugger#Project Tree|Project Tree}} 
*{{ide|Debugger#Source Code Windows|Source Code Windows}} 

=== Project Tree ===
----
When the debugger is started, you can click the '''View | Project Window''' to display the Project Files Tree (the {{ide|Project Tree|Project window}}) and the structure of the project files can be examined by exploring the project tree.

[[Image:Ide_db_ProjectWin.png|center|frame|'''The Project Tree View''']]

In this view, it is possible to double-click files (the project consists of) and double-click individual predicates. The result will be that a source code editor opens up with the caret pointing to the clicked item.

=== Source Code Windows ===
----
When the IDE starts debugging a project, it automatically runs the target executable under the debugger, and breaks the program execution at the <vp>goal</vp> section entry point. The debugger opens the correspondent (containing the <vp>goal</vp> section) Visual Prolog source file in the IDE text editor.

[[Image:Ide_db_StartDebugging.png|center|frame|'''The Source Code View''']]

Notice the blue arrow [[Image:Ide_db_ArrowBlue.png]] pointing to the executing predicate:

<vip>mainExe::run(main::run).</vip>

This arrow is the ''Instruction Pointer'', which always points to the currently executing predicate in source code windows. That is, you can follow the ''Instruction Pointer'' moving to trace execution of the program.

The debugger changes the color of the ''Instruction Pointer'' arrow when it executes a predicate, which fails or which raises an exception.

If you have moved in the program source windows and have lost the ''Instruction Pointer'', then you can easy find it with the menu command '''Debug | Go to Executing Predicate Source (Ctrl+E)'''. It sets the cursor to the line containing the currently executing predicate (to the line pointed by the ''Instruction Pointer'').

{{:ide/Debugger/Debugger Views}}
Templates used on this page:
Return to Ide/Debugger.
Retrieved from "https://wiki.visual-prolog.com/index.php?title=Ide/Debugger"
View source for Ide/Debugger

Search

Navigation

external links

collaboration

Personal tools

Views
