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:

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. 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:

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.

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:

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:

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,

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:

You can also add a breakpoint in one of the following ways:

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 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:

See also:
User's Guide: Evaluating expressions