Run menu
The Run menu contains commands for running and debugging your program. Choose one of the following commands for more information.
Run|Debug
Runs your application in the Debugger using any startup parameters specified in the Run/Debug page of the Run|Parameters dialog box.
You must compile files before running them. This places symbolic debugging information into the file so the Debugger can operate.
When you select Debug, the AppBrowser switches into Debugger mode. In Debugger mode, you use the Content pane for viewing code and setting breakpoints. The Debugger mode also displays panes for viewing data watches and context information such as call stacks and threads.
Alternate ways to perform the Debug command are:
- On the toolbar, click Debug.
- Press F9.
See also:
User's Guide: Using the Debugger
User's Guide: Overview of the debugging process
User's Guide: Running your program
Run|Run
Runs your application without debugging it, using startup parameters you specified in the Parameters dialog box.
An alternate way to perform this command is to click Run on the tool bar.
Files must be compiled before they can run. When you choose Run|Run, JBuilder automatically compiles the file or project before running it.
Run|Parameters
Displays the Parameters dialog box where you specify startup parameters for the current debugging session.
See also:
User's Guide: Sending command-line arguments to your program
User's Guide: Setting environment variables
Run|Step Over
Runs your application or applet one line at a time.
- If you issue the Step Over command when the execution point is on a method call, the Debugger runs that method then positions the execution point on the statement that follows the method call.
- If you issue the Step Over command when the execution point is positioned on the end statement of a method call, the method returns from its call and the execution point is placed on the statement following the method call.
The Debugger treats multiple statements on one line of text as a single line of code; you cannot individually debug multiple statements contained on a single line of text. The Debugger also treats a single statement that spans several lines of text as a single line of code.
By default, when you initiate a debugging session with Run|Step Over, JBuilder moves the execution point to the first line of code that contains debugging information (this is normally a location that contains user-written code).
In addition to stepping over procedures, you can trace into them as well. Use Run|Trace Into to execute each line of a procedure.
Alternate ways to perform the Step Over command are:
- On the toolbar, click Step Over.
- Press F8.
See also:
User's Guide: Running your program
User's Guide: Step Over
Run|Trace Into
Runs your application or applet one line at a time, tracing into methods while following the execution of each line.
The Trace Into command executes the statement highlighted by the execution point and advances the execution point to the next statement.
- If you issue the Trace Into command when the execution point is located on a method call, the Debugger traces into the method, positioning the execution point on the method's first statement.
- If you issue the Trace Into command when the execution point is positioned on the end statement of a method call, the method returns from its call, and the execution point is placed on the statement following the method call.
- If the execution point is located on a method call that does not have debugging information, such as a library method, the Debugger runs that method at full speed, then positions the execution point on the statement following the method call.
By default, when you initiate a debugging session with Run|Trace Into, JBuilder moves the execution point to the first line of code that contains debugging information (this is normally a location that contains user-written code).
In addition to tracing into methods, you can use step over them, executing each method as a single element. See Run|Step Over.
Alternate ways to perform the Trace Into command are:
- On the toolbar, click Trace Into.
- Press F7.
See also:
User's Guide: Running your program
User's Guide: Trace Into
Run|Run to Cursor
Runs your application up to the location of the cursor in the source pane. When you run to the cursor, your application runs at full speed, then pauses and places the execution point on the line of code containing the cursor.
You can use Run To Cursor to run your application and pause before the location of a suspected problem. You can then use Run|Step Over or Run|Trace Into to control the execution of individual lines of code.
See also:
User's Guide: Running to the cursor location
Run|Run to End of Method
Runs your application at full speed until it reaches the end of the current method.
See also:
Run To Cursor
User's Guide: Running to the end of a method
Run|Show Execution Point
Positions the cursor at the execution point in the Content pane. If you close the window containing the execution point, JBuilder displays this execution point the next time you open the window.
See also:
User's Guide: Finding the execution point
Run|Program Pause
Temporarily pauses the execution of a running application.
The Debugger pauses and positions the execution point on the next line of code to run. You can examine the state of your application at this point, then continue debugging by running, stepping, or tracing.
If your application or applet assumes control and does not return to the Debugger--for example, if it is running in an infinite loop--you can press Ctrl+Alt+SysRq to stop your application. You might need to press this key combination several times before your program actually stops.
In addition to temporarily pausing an application or applet running in the Debugger, you can also stop it and release it from memory by choosing Run|Program Reset, or pressing Ctrl+F2.
See also:
User's Guide: Pausing the program
Run|Program Reset
Ends the current application run and releases it from memory.
Use Reset to restart an application from the beginning, such as when you make a change to the code and want to run again from the beginning, or if variables or data structures become corrupted with unwanted values.
When you reset an application, JBuilder performs the following actions:
- Closes all open program files
- Clears all variable settings
Resetting an application does not delete any breakpoints or watches you have set. This makes it easy to resume a debugging session.
Resetting JBuilder
If your system becomes unstable, through either multiple hardware or language exceptions, or through a loss of system resources as a result of resetting a program, exit and restart JBuilder before restarting the debugging session.
See also:
User's Guide: Restarting the program
Run|Add Watch
Opens the Add Watch dialog box, where you can add a watch and specify its properties. The Watch pane displays the watches and lets you add, edit, delete, enable, and disable watches from its context menu.
Alternate ways to perform the Add Watch command are,
- In the Content pane, right-click and choose Add Watch at Cursor.
- From the Watch List window, right-click and choose Add Watch or press Ctrl+F5.
See also:
User's Guide: Watching expressions: Add Watch
Run|Add Breakpoint
Opens the Breakpoint Options dialog box, where you can create and modify breakpoints.
A breakpoint is a place in your program where execution temporarily stops. When the Debugger reaches a breakpoint, it pauses your program. You can specify any number of breakpoints in your code.
When you set a breakpoint, the line on which the breakpoint is set becomes highlighted, and a stop-sign glyph appears in the left margin of the breakpoint line.
Each breakpoint listing shows the following in the Breakpoint List window:
- The file in which the breakpoint is set
- The line number of the breakpoint
- Any condition or pass count associated with the breakpoint
You can also add a breakpoint in one of the following ways:
- In the Content pane, select the line of code where you want to set the breakpoint, then do one of the following:
- Click in the left margin of the line where you want the breakpoint.
- Press F5.
- In the Breakpoint List window, right-click and choose Add Breakpoint.
To edit a breakpoint, in the Breakpoint List window, right-click an existing breakpoint and choose Edit Breakpoint.
See also:
User's Guide: Using breakpoints
User's Guide: Setting breakpoints
Run|Inspect
Opens the Inspect window, in which you can enter a Java expression to inspect. The expression and its result are shown in the Inspector window as you debug.
See also:
User's Guide: Inspecting data elements
Run|Evaluate/Modify
Opens the Evaluate/Modify dialog box, where you can evaluate or change the value of an existing expression or property. You can evaluate any valid language expression, except those that contain
- Local or static variables that are out of scope
- Method calls
The Evaluate/Modify dialog box lets you view and modify the values of object properties while running the program. However, to view a property, you need to explicitly specify the property name. For example, you can enter the following expression to evaluate the Caption property of Button1:
Button1.Caption
Alternate ways to perform an Evaluate|Modify command are:
- In the Content pane, right click and choose Evaluate/Modify.
- Press Ctrl+F7.
See also:
User's Guide: Evaluating expressions