Debugging your applications

To begin a debugging session, you run the application launch configuration in the Flash Debug perspective.

You use breakpoints to suspend the execution of your application so you can inspect your code and use the Flash Builder debugging tools to explore options to fix errors. You add breakpoints in the code editor and then manage them in the Breakpoints view when you debug your applications.

You add breakpoints to executable lines of code. The debugger stops only at breakpoints set on lines that contain the following:

• MXML tags that contain an ActionScript event handler, such as <mx:Button click="dofunction()" ...>

• ActionScript lines such as those enclosed in an <mx:Script> tag or in an ActionScript file

• Any executable line of code in an ActionScript file

You can set breakpoints as you write code or while you debug.

You can specify conditions for breakpoints to stop the debugger from executing when specific conditions are met. When you set a conditional breakpoint, you specify an ActionScript expression that is evaluated during the debugging session. You configure the conditional breakpoint to halt execution for any of the following conditions:

• The expression evaluates to true.

• The value of the expression changes.

• A specified Hit Count has been reached.

In the Breakpoints view you manage breakpoints during a debugging session. You can remove, disable and enable, or skip them.

The following commands are available from the Breakpoints view toolbar (as shown left to right):

View full size graphic

The Debug view is the control center of the Flash Debug perspective. You use it to control the execution of the application, to suspend, resume, or terminate the application, or to step into or over code.

The Debug view provides the following debugging commands, which are available from the Debug view toolbar (as shown left to right):

View full size graphic

The Console view displays the output from trace statements placed in your ActionScript code and also feedback from the debugger itself (status, warnings, errors, and so on).

The Console view provides the following commands, which are available from the Console view toolbar (as shown left to right):

The Variables view displays the variables that the currently selected stack frame defines (in the Debug view). Simple variables (name and value) are displayed on a single line. The icons displayed with the variables provide visual cues about the type of variable.

Complex variables can be expanded to display their members. You use the Variables view to watch variables by adding them to the Expressions view and to modify the value of variables during the debugging session. You can also set watchpoints in the Variables view, as described in Using Watchpoints.

All superclass members are grouped in a separate tree node; by default you see only the members of the current class. This helps reduce excess numbers of variables that are visible at one time in Variables view.

The Variables view provides the following actions, which are available from the Variables view toolbar (as shown left to right):

View full size graphic

Use the Expressions view to watch variables you selected in the Variables view and to add and evaluate watch expressions while debugging your applications.

While debugging, you can inspect and modify the value of the variables that you selected to watch. You can also add watch expressions, which are code expressions that are evaluated whenever debugging is suspended. Watch expressions are useful for watching variables that may go out of scope when you step into a different function and are therefore not visible in the view.

The Expressions view provides the following commands, which are available from the Expressions view toolbar (as shown left to right):

You can also hover the mouse pointer over an expression or variable in the source editor to see the value of that expression or variable as a tooltip. You can add the expression to the Expressions view by right-clicking and selecting Watch from the menu.

When debugging an application, you can set watchpoints on specific instances of variables to halt execution when the watched variable changes value. Because watchpoints are set on a specific instance of a variable, you cannot set the watchpoint in the code editor. Instead, you set a watchpoint from the Variables view during a debugging session.

When setting watchpoints, keep in mind the following:

• When a debugging session ends, all watchpoints are removed.

• You cannot set watchpoints on getters, but you can set them on the field of a getter.

  For example, you cannot set a watchpoint on width, but you can set a watchpoint on _width.

• You cannot set watchpoints on local variables, but you can set watchpoints on members of local variables, as illustrated in the following code fragment.

  public class MyClass 
  { 
     // These are fields of a class, so you can set a watchpoint on 
     // 'memberInt', and on 'memberButton', and on 'memberButton._width': 
     private var memberInt:int = 0; 
     private var memberButton:Button = new Button(); 
   
     public function myFunction():void { 
        // You CANNOT set a watchpoint on 'i', because it is local: 
        var i:int = 0; 
   
        // You CANNOT set a watchpoint on 'someButton', because it is local; 
        // but you CAN set a watchpoint on 'someButton._width': 
        var someButton:Button = new Button(); 
   
  ... 
  }

• Execution halts for a watchpoint when the original value of an object instance changes.

  This differs from using an expression in a conditional breakpoint to halt execution whenever a variable changes value.

Setting watchpoints

 In a debugging session, there are two ways to set a watchpoint:

• In the Variables view, open the context menu for a variable, and select Toggle Watchpoint

• From the Flash Builder Run menu, select Add Watchpoint.

  From the Add Watchpoint dialog, select the variable you want to watch.

The Variables view displays a “pencil icon” to indicate that a watchpoint has been set on that variable.

Note: If you attempt to set a watchpoint on a getter, Flash Builder opens a dialog suggesting a valid variable for the watchpoint. If you delete the suggested variable, the dialog lists all valid variables for the object.

Flash Builder provides the Run to Line command to break out of a loop during a debugging session.

While debugging, you might find that your code is executing a loop that repeats many times. To break out of this loop, use the Run to Line command, available from the Run menu.