ARM Registers

# Date 1281122918 18000 # Node ID 727385d8e2b36f091bd46138a9fb40e8a63ae7bb # Parent 245ab754d54bb80475610624f50dbf584c513b77 added new customize carbide section and some relinking done for deleted duplicate page diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/bugs_fixed.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/bugs_fixed.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/bugs_fixed.htm Fri Aug 06 14:28:38 2010 -0500 @@ -12,7 +12,7 @@ ul > li {font-weight: normal } - +

Carbide.c++ bugs fixed

This is a comprehensive list of bugs fixed by release:

ARM Registers

Registers are the register contents of the central processing unit (CPU) of the targeted device. When debugging projects on a device, only the target device registers are visible, for example the ARM registers. The ARM microprocessor has 16 general-purpose registers. THUMB has eight general-purpose registers, R0-R7, and access to the high registers, R8-R15. Note that registers R0 through R3 hold the first four words of incoming arguments. The microprocessor constructs remaining arguments in the calling function's argument build area, which does not provide space into which R0 through R3 can be spilled.

Three registers are best left for special uses. These are:

R13 for stack operations
R14 is the link register (it is used for storing return addresses in the construction of sub routines)
R15 is the program counter (PC)

In most cases, the contents of all the registers can be modified. However, when debugging applications on a target device with Application TRK, you cannot change the LR, SP, and CPSR registers.

NOTE When opening the Registers view, the list of available registers will vary depending upon the target devices being debugged.

Figure 1 - ARM Registers

Related concepts

Emulator Registers

Related tasks

Related references

View Registers

ARM Registers

Three registers are best left for special uses. These are:

R13 for stack operations
R14 is the link register (it is used for storing return addresses in the construction of sub routines)
R15 is the program counter (PC)

In most cases, the contents of all the registers can be modified. However, when debugging applications on a target device with Application TRK, you cannot change the LR, SP, and CPSR registers.

NOTE When opening the Registers view, the list of available registers will vary depending upon the target devices being debugged.

Figure 1 - ARM Registers

Related concepts

Emulator Registers

Related tasks

Related references

View Registers

Auto-Targeting of Executables

In run-mode the Carbide debugger now supports the auto-targeting of processes that are already running or are created during the execution of the debug session. Previously, the debugger forced users to explicitly attach to a running process. Now, the debugger attempts to target all the EXEs specified in the Executables tab of the launch configuration.

Breakpoints Overview

A breakpoint is a marker set on a specific line of source code and is designed to halt program execution when encountered by the debugger. After you set a breakpoint at a key point in the program, you can halt its execution, examine its current state, and check register and variable values. You can also change values and alter the flow of normal program execution. Setting breakpoints helps you debug your program and verify its efficiency.

A project can have multiple breakpoints set in the source code files. All breakpoints in a project are shown in the Breakpoints view. Breakpoints are enabled or disabled on the currently selected line within a source code editor by selecting the Run > Toggle Breakpoint menu option, right-clicking the marker bar in the editor and selecting Toggle Breakpoint, or by pressing CTRL-SHIFT-B.

Active Build Configuration

Use the Active Configuration option in the Carbide Build Configurations panel to specify the build target. Since a project can contain one or more build targets, the active configuration defines which build configuration to use when the project is run or debugged. A launch configuration consists of the following:

Build System Overview

The Carbide.c++ build system provides a wrapper around the standard Symbian OS build process utilizing component description files (bld.inf) and project definition files (.mmp files). Because the Carbide.++ build system provides a visual view into this system, it will be useful for new developers to the Symbian OS to become familiar with the basic Symbian OS build process. Further information on the Symbian OS build system can be found in the Symbian Developer Library under the Build Tools Guide and Build Tools Reference sections. If you are already familiar with the Symbian OS build system then you should feel right at home with the Carbide.c++ builder user interface.

In Carbide.c++, as in the Symbian OS, a project is described by a bld.inf file. Hence, all projects must start with a bld.inf file. Carbide.c++ supports either building all components of a project (including extension makefiles) or only building selected sub-components. This gives the developer the granularity to either build all of a project’s dependencies or, if you are working on very large projects, only building a small sub-component of a larger project.

Supported Target Types

Carbide.c++ supports a variety of build targets based upon the SDKs and which version of the Carbide tools used by the project. The table below identifies which build targets are possible for a specific SDK.

NOTE Check the SDK Preferences page to see if an SDK you have installed and whether its build configurations are supported.

Carbide.c++ Projects

Carbide.c++ can import .INF files to create projects. Once imported, those files are forgotten and all changes made to a Carbide.c++ project, like adding files or libraries, are handled by the IDE itself either using the File > New, File > Import, or the Properties for project window.

Carbide.c++ can not export changes back to an .INF file.

Related tasks

Carbide.c++ Projects

Carbide.c++ can not export changes back to an .INF file.

Related tasks

Common Debugging Actions

This section explains how to perform common debugging actions within the Debug perspective to correct source-code errors, control program execution, and observe memory behavior:

Concepts

This section of the User Guide provides an overview of the main concepts in Carbide to create and build programs for Symbian OS.

Context Menus

A context menu provides a shortcut to frequently used menu commands. The available menu commands change, based on the context of the selected item. For example, the Breakpoints view uses commands that differ from the Editor view.

Sample uses of the context menu for different tasks include:

Software Configuration Management

Software Configuration Management (SCM)

The Carbide.c++ tools are built on top of the Eclipse and CDT open source projects (eclipse.org). Carbide can use several popular software configuration management systems including:

Data Viewer Plug-ins

Data Viewers are plug-ins that include an user interface to show a custom view of data. These plug-ins are often platform specific. Data editors are data viewers that also let you modify and write data.

The IDE will keep a registry of plug-ins that can view particular types. The plug-ins will register themselves with the IDE and indicate which formats and platforms they support. When a variable or memory address is selected, you can choose the plugin from the Data menu.

About the Carbide Debugger

About the Carbide.c++ Debugger

A debugger controls program execution and shows the internal operation of a computer program. Use the debugger to find problems while the program executes. Also use the debugger to observe how a program uses memory to complete tasks.

The Carbide.c++ debugger provides these levels of control over a computer program:

Emulation Debugging

Symbian SDKs include an emulator that runs Symbian OS on a Microsoft Windows host computer. The emulator provides the full range of Symbian OS diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/concepts/ext_build_support.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/concepts/ext_build_support.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/concepts/ext_build_support.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ External Builds Support - +

External Builds Support

The Carbide IDE performs the following tasks on external makefiles:

FPU Registers

The FPU Registers are the register contents of the floating-point unit (FPU) of the host computer. The exact listing of these registers depends on the host FPU and current build target.

Related concepts

General Registers

The General Registers are the register contents of the central processing unit (CPU) of the host computer. The exact listing of these registers depends on the host CPU and current build target.

Related concepts

Host Registers

Host-specific Registers

The Registers view also lists additional register contents for registers specific to the host. The exact listing of these registers depends on the host computer and current build target.

Related concepts

Carbide Macros

Carbide.c++ supports the macro _CARBIDE_CPP_ during the preprocessing of .mmp and .inf files. Use this macro in those files to include Carbide specific files during the preprocessing stage that are never recognized outside of the Carbide.c++ IDE.

For example within your .mmp or .inf file:

MMP Files

Symbian projects are defined by an .mmp file which specifies the essential elements of the project. All details of the project lifecycle are handled by the IDE. There is no editable makefile the user can edit to modify the build behavior of the project.

Related reference

MMP Editor

- - -

MMP Files

Related reference

MMP Editor

+ + +

N-Gage Projects

Carbide.c++ supports the importing of N-Gage projects. However, there are some process issues that effect how you can debug game projects on devices. The following provides a high level overview of the process you should follow to successfully import, build, deploy, and debug an N-Gage game on a device.

Importing N-Gage projects

Precompiled Headers

Precompiled header support is available for Symbian OS projects that use the Nokia x86 compiler. Precompiled header files use the .pch++ extension and are only supported by emulator targets.

Registers

Registers are the register contents of the central processing unit (CPU) of the host computer or the targeted device. When debugging projects using the emulator, only the host computer x86 registers are visible in the Registers view. When debugging projects on a device, only the target device registers are visible.

In most cases, the contents of all the registers can be modified. However, when debugging applications on a target device with Application TRK, you cannot change the LR and SP registers.

Figure 1. Registers view with possible register types

The types of registers can include:

general — the register contents of the central processing unit (CPU) of the host computer
FPU — register contents of the floating-point unit (FPU) of the host computer
MMX — 64-bit MultiMedia eXtension (MMX) registers
SSE — 128-bit Streaming SIMD Extension registers
host-specific—additional register contents for registers specific to the host (for example ARM registers)

NOTE When opening the Registers view, the list of available registers will vary depending upon the target devices being debugged.

Other references

Registers

In most cases, the contents of all the registers can be modified. However, when debugging applications on a target device with Application TRK, you cannot change the LR and SP registers.

Figure 1. Registers view with possible register types

The types of registers can include:

general — the register contents of the central processing unit (CPU) of the host computer
FPU — register contents of the floating-point unit (FPU) of the host computer
MMX — 64-bit MultiMedia eXtension (MMX) registers
SSE — 128-bit Streaming SIMD Extension registers
host-specific—additional register contents for registers specific to the host (for example ARM registers)

NOTE When opening the Registers view, the list of available registers will vary depending upon the target devices being debugged.

Other references

Symbian Build System (SBSv2)

Carbide.c++ v3.x fully supports the Symbian Build System (SBSv2) for building Symbian executables. Codenamed RAPTOR, SBSv2 is also designed to overcome several limitations in GNU Make, including:

Symbol Hint

The symbol hint shows information about variable values. This information appears automatically while the debugger is active.
Select the Show variable values in the source code option in the Display Settings preference panel to use the symbol hint.

About Symbolics Files

A symbolics file contains debugging information that the IDE generates for a computer program. The debugger uses this information to control program execution. For example, the debugger uses the symbolics file to find the source code that corresponds to the executing object code of the computer program.

Symbolics files contain this information:

Symbols, .pkg

Carbide.c++ supports the following specific symbols in .pkg files:

Project Templates

Carbide.c++ provides many common templates to quickly create projects using specific SDKs or feature sets. Every template provides basic support for a specific type of project including sources, libraries, resources, etc. The type and number of templates available are controlled by the SDKs you have enabled.

Table 1. Available project templates

Setting a thread-specific conditional breakpoint

Setting a Thread-specific Conditional Breakpoint

Carbide's debugger supports thread-specific breakpoints. Depending on what the protocol supports, there are several different ways it's supported. You can setup a special condition on a breakpoint. Enter mwThreadID == threadID, where mwThreadID is a keyword recognized by the core debugger and threadID is the number that represents the ID of the thread that you want to stop.

TRK On-device Debugging

The on-device TRK remote agent (Application TRK or System TRK) is a program that enables on-device debugging of phone prototypes, reference boards, and retail phones. An on-device debug agent is a program that is installed on a phone or reference board. It communicates with the debugger using a serial-over-Bluetooth or serial-over-USB connection. Through this serial communication, the on-device debug agent acts as the interface between the Carbide.c++ debugger and the target device. An on-device debug agent provides:

Watchpoints Overview

A watchpoint is a marker set on a specific memory location which is designed to suspend program execution when the value at that location changes. Watchpoints are closely related to breakpoints and are shown in the Breakpoints view.

When a watchpoint is encountered during program execution, the debugger suspends execution and the Debug perspective appears so you can examine the executable's current state, check register and variable values, and use the stepping commands to walk line by line through the program to verify its operation. You can also change values and alter the flow of normal program execution. Setting watchpoints helps you debug your program and verify its efficiency.

Multi-core Debugging

The IDE allows simultaneous debugging of multiple projects. This feature provides multi-core debugging capability for some embedded processors. By configuring each project to operate on a single core, the IDE can debug multiple cores by debugging multiple projects.

Configuring multi-core debugging involves these tasks

Working with Debugger Data

This section explains how to work with data that the Carbide.c++ debugger generates. The following windows show various types of debugger data.

Console view —shows messages generated during the debugging session

Debugger Program Execution

This section explains how to work with the debugger in the Carbide IDE to control program execution. The main component of the debugger is the Debug perspective, which shows these items:

Working with Memory

This section explains how to work with memory in a debugging session. Topics include:

Controlling Program Execution

This section explains how to use breakpoints, breakpoint actions, and watchpoints to manipulate execution of your program in the Carbide™ IDE:

Working with Variables

This section explains how to work with variables in a Carbide™ IDE debugging session. The following windows show various types of information about variables.

Workspace Information

A workspace is the default place to store and create resources like projects, folders, and files. These are then presented to the user in a perspective which enables the presentation and manipulation of the stored resources.

When Carbide is launched it asks for a workspace to open (Figure 1). As you can have multiple workspaces, all independent from each other, choosing the workspace containing the projects to work on is important. Projects within a workspace are shown in the Carbide workbench within the Project Explorer and C/C++ Project views. When you create a new project it is automatically added to the currently open workspace. You can import existing projects into a workspace from INF files.

Breakpoints Overview

A breakpoint is a marker set on a specific line of source code and is designed to suspend program execution. Breakpoints are shown in the UI both with the associated source code in an editor view as well as a dedicated Breakpoints view.

When a breakpoint is encountered during program execution, the debugger suspends execution and the Debug perspective appears so you can examine the executable's current state, check register and variable values, and use the stepping commands to walk line by line through the program to verify its operation. You can also change values and alter the flow of normal program execution. Setting breakpoints helps you debug your program and verify its efficiency.

The following topics cover various breakpoint concepts and actions:

Viewing Breakpoints
Breakpoint status indicators
Enabling, Disabling and Removing Breakpoints
Breakpoint properties -
- Creating temporary breakpoints
- Creating conditional breakpoints
-
Exporting and importing breakpoints
Toggle hardware breakpoints

Other references

Debugging overview

Breakpoints Overview

The following topics cover various breakpoint concepts and actions:

Viewing Breakpoints
Breakpoint status indicators
Enabling, Disabling and Removing Breakpoints
Breakpoint properties +
- Creating temporary breakpoints
- Creating conditional breakpoints
+
Exporting and importing breakpoints
Toggle hardware breakpoints

Other references

Debugging overview

Creating Conditional Breakpoints

Use the Properties for Breakpoint > Common > Conditional option to create conditional breakpoints. Where regular breakpoints suspend execution each time they are hit, a condition breakpoint evaluates an expression to determine if it is true or not. If the expression evaluates true, then program execuation is suspended and the Debug perpective shown. If the expression evaluates to false, execution continues.

Exporting Breakpoints and Watchpoints

Use the Export Breakpoints command to export selected breakpoints and watchpoints to a file with a .bkpt extension. All the breakpoints set in the source files of the project and the watchpoints are listed in the Export Breakpoints dialog. Click the specific breakpoints and watchpoints to export or use Select All to include all of them. Specify the destination file name and folder, then click Finish.

Importing Breakpoints and Watchpoints

Use the Import Breakpoints command to import a .bkpt file containing breakpoint and watchpoint data and apply it to the current project. Right-click in the Breakpoints view and select Import Breakpoints... from the context menu. You have the options of updating all existing breakpoints with the stored data or simply creating a working set containing the imported data.

Breakpoints Properties

Use the Properties for Breakpoint window to examine and modify a specific breakpoints properties. By setting certain options its possible to create both conditional and temporary breakpoints.

The pages available include:

Breakpoint Status Indicators

Breakpoints must be located and resolved by the debugger before they can be hit. When a breakpoint is hit in the module, the debugger halts program execution and displays the state of the program in the Debug perspective.

To hit a breakpoint during a debug session, the debugger must first load the symbols for an executable module and then attempt to resolve the breakpoints within the loaded module. Any module listed into the Executables view is available for loading by a debug session. If a module is not present in the Executable view you'll need to import it before the debugger to load and resolve any breakpoints within that module.

Creating Temporary Breakpoints and Watchpoints

Use the Properties for Breakpoint > Common > Ignore Count option to create temporary breakpoints or watchpoints. Where regular breakpoints or watchpoints suspend execution each time they are hit, a temporary one is removed once it is hit. The default value is 0, which suspends program execution each time the breakpoint or watchpoint are hit.

To set a temporary breakpoint or watchpoint, change the value of Ignore count to 1. The first time the breakpoint or watchpoint is hit execution is suspended, while any subsequent hits are ignored.

Enabling, Disabling and Removing Breakpoints

Use the Toggle Breakpoint command (Ctrl+Shift+B) to set a regular breakpoint in an Editor or Disassembly view. Only a single breakpoint can exist on a source code line. A regular breakpoint suspends program execution when it is hit, or executed, during a debug session. The debugger executes the line of source code that contains the regular breakpoint, then opens the Debug perspective to allow examination and modification.

If a regular breakpoint already exists on the selected line, as indicated by the enabled breakpoint badge () in the marker bar, use Toggle Breakpoint to remove the breakpoint.

Viewing Breakpoints and Watchpoints

Use the Breakpoints view (Figure 1) to examine a project's breakpoints and watchpoints, toggle individual breakpoints between enabled and disabled, set conditional breakpoints, export and import breakpoints, or remove them from one or more build configurations.

The Breakpoints view is available in the Debug perspective by default. To open it in another perspective, use the Window > Show View > Breakpoints menu option. Once open you have control over breakpoint states and how they are shown. For example:

Debugging Overview

Other Useful Commands

The Debug view has a few other commands that are useful under some debugging situations:

Disconnecting from a process

Repositioning the Program Counter

Once you've suspended a program debug session, the Disassembly view provides commands for move or reposition the program counter (PC). These command include:

Suspending and Resuming a Debug Session

Once you've started a debug session, the Debug view provides controls to both suspend and resume program execution under debugger control. The following items describe the commands for:

Starting and Terminating a Debug Session

Once you've started a debug session, the Debug view provides controls to both terminate and restart the session. The following items describe the commands for:

Stepping Over, Into, and Out of Routines

Once you've suspended a program debug session, the Debug view provides controls to walk through program code, including commands for:

Debugging Overview

The Debug view provides an overview of the debug session as it relates to the executing program.

The following topics cover various breakpoint concepts and actions:

Debug view

The Debug view provides an overview of the debug session as it relates to the executing program. The target debugging information is shown in a tree hierarchy. The items that appear there include:

Adding and Removing Expressions

An expression is a snippet of code that is evaluated to produce a value. In Carbide they are defined using C/C++ expressions. Some expressions may need to be evaluated at a specific location in the program so that its variables can be referenced. Adding more expressions to the Expressions view list can slow down the automatic display as each must be evaluated to update its value. To manage large lists of expressions, use the Enable and Disable options in the context menu to control which expressions are automatically evaluated.

You add expressions in the Add Watch Expression dialog using a variety of views, including Expressions, Variables, and editor views. Right-click in the view and select the Add Watch Expression... command from the context menu.

Figure 1. Add Watch Expression dialog

You can enter any valid C/C++ expression, for example:

-
2 + 2
- myVariable + 8
- &myVariable
- myClass.myMemberVar
- etc.
-

are all valid expressions that the Expressions view can monitor and display. However, an expression cannot call a function or execute code. The following example will not work:

-
std:strlen("Hello");
-

Removing Expressions

Right-click the expression in the Expressions view and select the Remove menu option. This removes the selected expression from the Expression list.

Other references

Variables and Expressions Overview

Adding and Removing Expressions

Figure 1. Add Watch Expression dialog

You can enter any valid C/C++ expression, for example:

+
2 + 2
+ myVariable + 8
+ &myVariable
+ myClass.myMemberVar
+ etc.
+

are all valid expressions that the Expressions view can monitor and display. However, an expression cannot call a function or execute code. The following example will not work:

+
std:strlen("Hello");
+

Removing Expressions

Right-click the expression in the Expressions view and select the Remove menu option. This removes the selected expression from the Expression list.

Other references

Variables and Expressions Overview

Adding and Removing Global Variables

The Variables view can also display global variables used by the program. Right-click in the Variables view and select the Add Global Variables menu option to open the Global Variables dialog. There you can select one or more global variables to display in the Variables view, clickiing OK when done.

Global Variables window

Editing Expressions

Use the Edit Watch Expression dialog to change a previously defined expression. Right-click in the Expressions view and select the Edit Watch Expression... command from the context menu. When editing an expression, the same rules used to create it apply. Mainly, the edited expression must be a valid C/C++ expression that evaluates to a value and does not call a function nor execute code.

Use the Enable control to set whether this expression should be automatically evaluated during a debug session.

Figure 1. Edit Watch Expression dialog

You can enter any valid C/C++ expression, for example:

-
2 + 2
- myVariable + 8
- &myVariable
- myClass.myMemberVar
- etc.
-

are all valid expressions that the Expressions view can monitor and display. However, an expression cannot call a function or execute code. The following example will not work:

-
std:strlen("Hello");
-

Other references

Variables and Expressions Overview

Editing Expressions

Use the Enable control to set whether this expression should be automatically evaluated during a debug session.

Figure 1. Edit Watch Expression dialog

You can enter any valid C/C++ expression, for example:

+
2 + 2
+ myVariable + 8
+ &myVariable
+ myClass.myMemberVar
+ etc.
+

are all valid expressions that the Expressions view can monitor and display. However, an expression cannot call a function or execute code. The following example will not work:

+
std:strlen("Hello");
+

Other references

Variables and Expressions Overview

Variables and Expressions Overview

Variables are symbols used in programs to store values or expressions that can change during the life of the program. Being able to view a variable's value is helpful when debugging a program. Expressions are the result of one or more variables being combined to produce a result based on the variable values and the way they are calculated. Variables are shown in the Variables view while expressions are shown in the Expressions view.

The following cover various variable and expression concepts and actions:

Viewing Expressions

The Expressions view allows manipulation of expressions. An expression is a snippet of code that is evaluated to produce a value. In Carbide they are defined using C/C++ expressions. Some expressions may need to be evaluated at a specific location in the program so that its variables can be referenced.

The Expressions view displays these panes:

Viewing Variables

The Variables view allows manipulation of project variables and the variable hierarchy used in the source code. For example, you can change the variable format, change a variable value, add watch expressions, or add global variables.

Figure 1 shows the Variables view with Show Type Names option enabled. The default view shows the variables list and include the Name and Value for all the variables within scope. In addition, when you select a variable its value is also shown in a different pane within the view.

Setting and Removing Watchpoints

You create a watchpoint to monitor a value in a specified memory location. The debugger halts program execution on the line of source code that triggered the watchpoint. This is different than a breakpoint, which halts program execution prior to executing the line of source code on which the breakpoint is set.

Setting watchpoints

Watchpoint Status Indicators

Use watchpoints (sometimes referred to as access breakpoints) to halt program execution when a specific global location is accessed. After you set a watchpoint at a key point in memory, you can halt program execution whenever that point in memory is written to or read from. You can then examine the call chain, check register and variable values, and step through your code. You can also change values and alter the flow of normal program execution.

A watchpoint must be both enabled and resolved during a debug session in order to halt program execution. The Breakpoints view indicates the status of any watchpoint using a set of common icons and checkmark status badge. These include:

Enabling and Disabling Watchpoints

In the Breakpoints view use the checkboxes that appear next to a watchpoint to enable or disable that watchpoint. When enabled, if the value in the watchpoint location changes per the read/write condition, then program execution is suspended. If the watchpoint is disabled and the value changes, no action is taken by the debugger.

Enabling Watchpoints

Watchpoints Overview

Customizing Launch Configurations

Use the Debug dialog to customize launch configurations previously created in a project, or to create new launch configurations. Ideally, you should create new launch configurations using the New Launch Configuration Wizard. Doing this will ensure that the project's default launch configuration is valid and can successfully launch a debug session. However, not all default launch configurations satisfy all the needs of a project, so being able to modify a launch configuration's options can allow you to customize how the project is launched and debugged based on the needs of that project.

There are two methods for setting up a launch configuration, including:

Launch Configuration Filtering

Use the Launch Configurations preference panel to filter the launch configurations that appear in the configurations list in the Run or Debug dialog. This allows you to manage which configuration types are shown. For example, enable the Filter checked launch configuration types option and check the configuration types that you do not want to appear in the Run and Debug dialogs.

Carbide Connection page

Connection page

The Connection page specifies the method used to transfer files to the target device. Once a Serial Port type is chosen, the remaining options contain default values for the specific connection type. Users can change these remaining options to match the target device's communication specifications.

Carbide Debugger panes

Debugger panes

The options shown in the Debugger page differ based upon the type of launch configuration. Generally, the options fall into these choices:

Carbide x86 Exceptions page

x86 Exceptions page

Use the x86 Exceptions page in the Emulation launch configuration to set the x86 exceptions the debugger should catch. If you want the debugger to catch all the exceptions, enable all of the options in this page. However, if you prefer to handle only certain exceptions, enable only those options that reflect the exceptions you want to handle.

Carbide File Transfer page

File Transfer page

The File Transfer page displays an auto-populated list of files for System TRK that the IDE transfers to the target device at the start of each launch. For RnD device images, the target location for files is normally c:\sys\bin or another protected area. For production device images Application TRK does not support the transfer of files to c:\sys\bin or other protected areas.

Users can add, edit, or delete files in the list and sort by clicking on a column header. By default, any file added is automatically checked for downloading to the device. Users can uncheck a file to remove it from the download list without removing the file itself. System TRK users can use this panel to download any type of file, like bitmaps, HTML, sounds, and more, to the phone and applicable to Application TRK for transfering any files outside of the installation file.

Installation page

The Installation page specifies the .sis file to install on the target device when using Application TRK. This is required when using the TRK debug agent with 9.x based SDK’s.

Carbide Main page

Main page

The options shown in the Main page differ based upon the type of launch configuration. Generally, the options fall into these choices:

Carbide ROM Image page

ROM Image page

Use the ROM Image page in a System TRK launch configuration to define startup options and ROM image download information.

Carbide Configuration Pages

Configuration Pages

The pages in the Debug dialog used to set options for the various launch configurations include:

New Launch Configuration Wizard

The New Launch Configuration Wizard launches when no launch configuration exists for a project. Wherever possible the New Launch Configuration wizard gathers the information from the project and asks additional questions based on the type of launch configuration chosen. For example, a launch configuration using Application TRK requires different information than one targeted for System TRK.

Debug Configurations Window

The Debug Configurations or launch configuration window provides C/C++ debugger options. A launch configuration defines the settings used by the Carbide debugger to launch and debug programs. A project must have at least one debug launch configuration in order to debug a project and can have many more.

By default, Carbide creates a debug launch configuration the first time you launch the debugger based on current project settings. If additional information is required, like a port ID, the New Launch Configuration Wizard appears asking for the additional information.

DLL Projects Tutorial

In this example we show how to create a project for a DLL (Dynamic Linked Library) using one of the built-in Carbide templates, how to build it into an executable, and how to launch the debugger to verify program accuracy. The steps to do this include:

Building an executable based on the project sources
Debugging the DLL using the Carbide debugger

NOTE There must be at least one recognized SDK installed before you can create a project. See the SDK Preferences panel to determine if the installed SDKs are recognized by Carbide.c++ IDE. If the SDK you have installed is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list.

Other references

Emulator Application Projects

Creating DLL Projects Tutorial

In this example we show how to create a project for a DLL (Dynamically Linked Library) using one of the built-in Carbide templates, build it, then attach to another program for debugging. The steps to do this include:

Building the DLL object code based on the project sources
Debugging the DLL using the Carbide debugger

In this tutorial you'll create a simple DLL project using the New Symbian OS C++ Project wizard, attach it to the HelloWorld project created here, then debug it.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/projects/tutorials/new_proj_dll_example_02.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/projects/tutorials/new_proj_dll_example_02.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/projects/tutorials/new_proj_dll_example_02.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Building the DLL Project Tutorial - +

Building the DLL Project Tutorial

Debugging a DLL Project Tutorial

Emulator Application Projects Tutorial

In this example we show how to create a new project using one of the built-in Carbide templates, how to build it into an executable, and how to launch the debugger to verify program accuracy. The steps to do this include:

Defining a launch configuration for running or debugging the application
Controlling and debugging the running program using the Carbide debugger

Other references

DLL Projects
Remote Target Debugging (Run-mode)

Creating New Projects from Templates

Defining a launch configuration

Launching and debugging an executable

Remote Target Debugging (Run-mode) Tutorial

In this example we demonstrate how to debug applications on a remote device using the Application TRK remote debug agent. This enables you to test programs on the actual device it will operate on while observing its behavior using the Carbide debugger. The steps to do this include:

Connect target device to PC Tutorial

Connect target device to PC

Install TRK remote agent Tutorial

Install TRK remote agent

Configure project for debugging Tutorial

Configure project for debugging

Debug project on target device Tutorial

Debug project on target device

Qt Preference Panel

Creating Qt Projects

Use the Qt Project creation wizard to create new Qt-based projects based on Qt SDKs integrated into Symbian. The wizard walks you through the process of defining and creating a Qt project.

Qt Preference Panel

Creating Qt Projects

Use the Qt Project creation wizard to create new Qt-based projects based on Qt SDKs integrated into Symbian. The wizard walks you through the process of defining and creating a Qt project.

Qt Preference Panel

Creating Qt Projects

Use the Qt Project creation wizard to create new Qt-based projects based on Qt SDKs integrated into Symbian. The wizard walks you through the process of defining and creating a Qt project.

Qt Preference Panel

Creating Qt Projects

Use the Qt Project creation wizard to create new Qt-based projects based on Qt SDKs integrated into Symbian. The wizard walks you through the process of defining and creating a Qt project.

Qt Preference Panel

Creating Qt Projects

Use the Qt Project creation wizard to create new Qt-based projects based on Qt SDKs integrated into Symbian. The wizard walks you through the process of defining and creating a Qt project.

Qt Preference Panel

Creating Qt Projects

Use the Qt Project creation wizard to create new Qt-based projects based on Qt SDKs integrated into Symbian. The wizard walks you through the process of defining and creating a Qt project.

Importing Qt Projects

Use the Qt Project import wizard to import Qt-based projects based on Qt SDKs integrated into Symbian. The wizard walks you through the process of importing a Qt project, stored as a .pro file.

To import a Qt project:

Importing Qt Projects

Use the Qt Project import wizard to import Qt-based projects based on Qt SDKs integrated into Symbian. The wizard walks you through the process of importing a Qt project, stored as a .pro file.

To import a Qt project:

Importing Qt Projects

Use the Qt Project import wizard to import Qt-based projects based on Qt SDKs integrated into Symbian. The wizard walks you through the process of importing a Qt project, stored as a .pro file.

To import a Qt project:

Importing Qt Projects

Use the Qt Project import wizard to import Qt-based projects based on Qt SDKs integrated into Symbian. The wizard walks you through the process of importing a Qt project, stored as a .pro file.

To import a Qt project:

Qt Projects Overview

Carbide supports the creation, importing, development, and debugging of programs based upon Qt.

The following topics are covered for Qt:

Qt Projects Overview

Qt Perspective

The Qt C/C++ perspective defines a set of common views that make developing Qt programs faster and easier. It is essentially the same as the Carbide C/C++ perspective except that the Symbian Project Navigator view is removed, and the following views added:

Qt Preference Panel

The Qt preference panel provides global settings for Qt-based projects. Use it to add, edit, remove, and assign the default Qt version for projects.

Qt Project Properties

The Qt Properties panel provides project-level settings for Qt projects. Qmake will be invoked whenever the .pro file changes so that the bld.inf and .mmp file will always be in sync.

Qt Development Setup

There are some prerequisites to using Qt projects within the Carbide environment. This includes downloading the correct SDKs, building qmake to use the SDKs, and finally, building the libraries for your target environments.

You should have the Nokia Qt SDK 1.0 in order to develop Qt applications with Carbide. These steps include:

Arguments page

The Arguments pane allows you to add arguments to the bldmake and abld processes for the project. Carbide passes the arguments entered here to the command line tools during the build process. By default, the majority of arguments are left blank.

NOTE Always refer to the Symbian Developer Library to learn which arguments are supported by the project's SDK.

Environment Variables

The Environment Variables pane allows you to view the current User and System environment variables that will be used when any abld command is invoked. User variables are modified or added when a process is invoked. Read only system variables are listed. Variables and values in bold are items that have been modified from their default values.

Some variables have special meaning, including:

Paths and Symbols

The Paths and Symbols pane shows the paths and symbols used to the build the project index. This is a read-only list based on the setting of the Build configuration for the indexer option in the C/C++ General > Indexer panel. Carbide now caches the paths and symbols which persist between debug sessions. If any of the files like bld.inf, MMP, or any of their include files change, the list is automatically recalculated and CDT notified.

To change what appears in the list:

SBSv2 page

The SBSv2 pane allows you to define which build configuration variant to use when building a project. This tab is only visible for SBSv2 projects. The possible variants are listed in the variant_configs.xml file.

WARNING The project's MMP file must include the FEATUREVARIANT settings.

SIS Builder

The SIS Builder pane is used to specify one or more .PKG and .SIS file options to create application and patch .SIS files. These settings apply to the currently selected Configuration.

The SIS Builder list includes these columns:

PKG File Settings

Set PKG File for Build Configuration

The Set PKG File for Build Configuration dialog appears when an Application TRK build configuration does not include a PKG file. Use it to assign a PKG file to the project's current build configuration that will be used to create a project's SIS installation file. If you define a launch configuration used for on-device debugging with the TRK debug agent, you will need to specify a PKG file for the project. A PKG file primarily provides a list of program and resource files to install on the device.

Build Configurations

Use the Build Configurations panel to specify the project's active build configuration and its related build properties.

Macro Settings

The Macro Settings properties page allows you to specify a file containing macros that CDT uses to parse the source code.

Project Settings

Use the Project Settings window to specify whether all components or selected subcomponents listed in a build information file (bld.inf) should be built for the currently selected project. You can also specify whether to perform a clean or reallyclean command on the project before building a project.

SIS Properties

Use the SIS Properties dialog to specify SIS file creation and signing options for the selected SIS file included in the project.

Debugger Settings

The Carbide.c++ debugger settings include:

Launch Configuration Filtering

Use the Launch Configuration preference panel to filter the launch configurations that appear in the configurations list in the Run or Debug window. This allows you to manage which configuration types are shown. By default, all launch configurations are shown. To open click the Windows > Preferences > Run/Debug > Launching > Launch Configurations option.

To hide specific launch configurations, enable the Filter checked launch configuration types option and check the configuration types that should be hidden in the Run and Debug dialogs. As shown in Figure 1, all the configurations checked and won't appear in the configurations list, including Snapshot Albums.

Memory Rendering Options

You can configure the Memory Rendering pane to display data in the memory location in a variety of ways. The following options are visible on the context menu for the Memory Rendering pane.

Right-click to select an option shown in Table 1.

ABLD Actions

Use the ABLD menu option to invoke an specific abld command on the selected project or file. ABLD is available under Symbian Build > ABLD or by right-clicking a project or file in the Project Explorer, Symbian Project Navigator, and Disassembly views and choosing ABLD > command. When executed any arguments specified in the Carbide Build Configurations pane for the command are passed to the selected tool.

Build All Configurations

Select a project in the Project Explorer or Symbian Project Navigator view, then:

Build Package File

Build Package (.pkg) File

Select a .PKG file in a project′s /sis folder in the Project Explorer view and right-click to display the context menu. Select Symbian Build > Build PKG File to build the package file and create the .sis installation file. This option is also available from an editor view when the file is open. The makesis tool uses the package file and packs all the required resources together into a SIS installation file. The Console view displays the processing output. The .sis and .sisx files will appear in the project's /sis folder.

Build Symbian Component

Select a .mmp or .mk file in the Project Explorer or Symbian Project Navigator view, then right-click and select Symbian Build > Build Symbian Component (CTRL+ALT+P) to build the selected component file or makefile. You can also right-click the file in an editor view to use the same option.

Clean Symbian Component

You can select a MMP or MK file in the Project Explorer or Symbian Project Navigator view and right-click to select Symbian Build > Clean Symbian Component (CTRL+ALT+X) to clean the selected MMP project file or makefile. You can also right-click the file in an editor view to use the same option. The cleaning process removes the object and make files, and output files. The files that are removed by this command include all the intermediate files created during compilation and all the executables and import libraries created by the linker.

Compile

Select a .c, .cpp, or .cia source file in the Project Explorer or Symbian Project Navigator view, right-click the file and choose Symbian Build > Compile (CTRL+ALT+C) to compile it. This is also available from within a C/C++ editor view. You can use the shift or control key to select one or more of these file types across the same or different projects. The build progress is displayed in the Console view.

Compile source

Freeze Exports

Right-click a project in the Project Explorer or Symbian Project Navigator view, then choose Symbian Build > Freeze Exports. This command calls the appropriate abld command and a .def file is generated. This enables released versions of DLLs to freeze their exports, ensuring backward compatibility of a library.

Freeze Symbian Component

Right-click a Symbian OS MMP file in the Project Explorer, or Symbian Project Navigator view, then choose Symbian Build > Freeze Symbian Component (CTRL+ALT+F). You can also right-click the file in an editor view to use the same option. This command only freezes the selected MMP file and not the entire project.

Toggle HW Breakpoint

Use the Toggle HW Breakpoint command in stop-mode debugging to set or unset a hardware breakpoint on a device that supports hardware breakpoints. The debugger treats hardware breakpoints exactly like software breakpoints for purposes of debugging. If the device does not support hardware breakpoints, toggling the command will do nothing.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/reference/menus/menus.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/reference/menus/menus.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/reference/menus/menus.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Carbide Menu Items - +

Carbide Menus

Carbide has several menu options unique to developing Symbian OS applications and other shortcuts. Most project related commands are grouped under the Symbian Build option in context menus, while others appear under specific menus like Run or Project.

Open Command Window

Launches a Microsoft Windows Command Prompt window set to the chosen project or file's directory.

Other references

Show in Explorer

Launches a Microsoft Windows Explorer window that shows the chosen project or file directory and its location on the hard disk.

Other references

Preprocess

Right-click to select a .c, .cpp, or .cia source file in the Project Explorer or Symbian Project Navigator view, and choose Symbian Build > Preprocess to preprocess the file. You define the preprocess command in the Preprocess preference panel. This is also available from within a C/C++ editor view. You can use the shift or control key to select one or more of these file types across the same or different projects. The preprocess progress is displayed in the Console view.

Preprocess menu option

x86 Exceptions Pane

The Debug or launch configuration windows x86 Exceptions pane lists all the exceptions that the debugger is able to catch. If you want the debugger to catch all the exceptions, enable all of the options in this view. However, if you prefer to handle only certain exceptions, enable only those options that reflect the exceptions you prefer to handle.

Debug perspective

The Carbide.c++ Debug perspective is where you debug programs running on an emulator or a target device. The default views include:

Build preferences

The Carbide.c++ > Build page in the Preferences window provides global preferences to control general build options like clean, test components, dependency tracking, concurrent build jobs, build behavior, and emulator options.

Carbide.c++ preferences

The Carbide.c++ panel in the Preferences window provides an option to keep your projects updated when you add or create files. Figure 1 shows the Carbide.c++ preference panel.

Carbide.c++ Debugger preferences

The Debug > Carbide.c++ Debugger preference panel provides global debugger settings for the Carbide.c++ tools.

Diagnostic Logs preferences

The Diagnostic Logs page in the Preferences window provides the ability to activate and save debugger log files in the project. When activated, the debugger generates an XML file containing useful debugger event information that can facilitate the locating and erradication of bugs in a project.

NOTE When logging is activated the performance of the debugger will be reduced as the log information is generated.

Preprocess preferences

The Carbide.c++ > Preprocess page in the Preferences window provides global settings for the Carbide preprocessor.

Unsetting Built-in Environment

The Carbide.c++ > Build page in the Preferences window provides an option to use the local x86 build tools for each emulator build. A directory named x86Build at the root of the product installation contains the build tools, libraries, and env_update.exe file.

Uncheck the "Use built-in Nokia x86 environment variables for WINSCW builds" option if you do not want to use the built-in compiler.

Reference

This section provides reference information on the Carbide IDE including:

Debugger settings — shows the Carbide debugger setting panels used to control debug sessions
Expression views — shows how to work with expressions in a debugging session
Variable views — shows how to work with variables in a debugging session

Reference

This section provides reference information on the Carbide IDE including:

Debugger settings — shows the Carbide debugger setting panels used to control debug sessions
Expression views — shows how to work with expressions in a debugging session
Variable views — shows how to work with variables in a debugging session

System Search preferences

Use the System Search preference panel to control System Search behaviors. Choose Window > Preferences > System Search to open the System Search preference panel.

System Search view

The System Search view displays the results of a search based on the criteria used in the System Search page. This view (Figure 1) appears automatically when a directory search is performed. You can also open it using the Window > Show View > Other... option where it is found in the Show View dialog under the System Search category.

System Search

Use the System Search page of the Search window to perform a textual search of files by directory, on your hard drive. This enables you to search for files inside directories located outside of the project workspace. In addition, there are additional search choices including:

Exporting Remote Connections

You can export remote connection settings for sharing and import settings created by others using the Import/Export commands.

Importing Remote Connections

You can export remote connection settings for sharing and import settings created by others using the Import/Export commands.

Filter Preferences

Launch Configuration Filters

The Launch Configuration Filters Preference window provides additional options for filtering out the launch configurations that appear in the list of configurations.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/reference/trk/panel_trk_overview.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/reference/trk/panel_trk_overview.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/reference/trk/panel_trk_overview.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ TRK Panel Overview - +

TRK Pane Overview

When debugging a remote device using TRK, the following panes appear in the launch configuration window:

Remote Connections view

Use the Remote Connections view to monitor, create, edit, or remove common connection settings for remote agents. Remote agents provide support for debugging, profiling, trace, and more. The connection types currently supported include:

Install Remote Agents pane

Install Remote Agents

Use the Install remote agents pane to select the latest remote agent version to download and install to the device.

Figure 2 - New Connection wizard Install remote agents page

Table 1. Install Remote Agents pane

Item	Explanation
Install remote agents	A list of the most current versions of remote agents sorted by SDK and version. Select the version most compatable with the device. For example, a device running S60 5.0 needs a version of the TRK software compiled for that SDK, which in the image above is Application TRK 3.2.6. - Additional information about the selected entry is displayed to the right to help you choose the correct version of TRK for the target device.
Save	Click Save to store a local copy of the currently selected TRK to disk. You can then manually install the file to your devices using the method of your choice.
Install	Click Install to download and install the TRK selected in the Install remote agents list. A progress bar is shown if the install operation requires more than a few seconds to complete. - NOTE Drivers installed by PC Suite or Ovi Suite are required in order for Install to download a remote agent onto the target device. - NOTE The SIS and SISX file types must be associated with an installer application like Nokia PC Suite or Ovi Suite in order to install them onto the device. Use the Save command above to perform a manual install to the device if you don't have an installer application.

Item

Explanation

Install remote agents

A list of the most current versions of remote agents sorted by SDK and version. Select the version most compatable with the device. For example, a device running S60 5.0 needs a version of the TRK software compiled for that SDK, which in the image above is Application TRK 3.2.6.

Additional information about the selected entry is displayed to the right to help you choose the correct version of TRK for the target device.

Save

Click Save to store a local copy of the currently selected TRK to disk. You can then manually install the file to your devices using the method of your choice.

Install

Click Install to download and install the TRK selected in the Install remote agents list. A progress bar is shown if the install operation requires more than a few seconds to complete.

NOTE Drivers installed by PC Suite or Ovi Suite are required in order for Install to download a remote agent onto the target device.

NOTE The SIS and SISX file types must be associated with an installer application like Nokia PC Suite or Ovi Suite in order to install them onto the device. Use the Save command above to perform a manual install to the device if you don't have an installer application.

Related references

Install Remote Agents pane

Install Remote Agents

Use the Install remote agents pane to select the latest remote agent version to download and install to the device.

Figure 2 - New Connection wizard Install remote agents page

Table 1. Install Remote Agents pane

Item	Explanation
Install remote agents	A list of the most current versions of remote agents sorted by SDK and version. Select the version most compatable with the device. For example, a device running S60 5.0 needs a version of the TRK software compiled for that SDK, which in the image above is Application TRK 3.2.6. + Additional information about the selected entry is displayed to the right to help you choose the correct version of TRK for the target device.
Save	Click Save to store a local copy of the currently selected TRK to disk. You can then manually install the file to your devices using the method of your choice.
Install	Click Install to download and install the TRK selected in the Install remote agents list. A progress bar is shown if the install operation requires more than a few seconds to complete. + NOTE Drivers installed by PC Suite or Ovi Suite are required in order for Install to download a remote agent onto the target device. + NOTE The SIS and SISX file types must be associated with an installer application like Nokia PC Suite or Ovi Suite in order to install them onto the device. Use the Save command above to perform a manual install to the device if you don't have an installer application.

Item

Explanation

Install remote agents

Additional information about the selected entry is displayed to the right to help you choose the correct version of TRK for the target device.

Save

Click Save to store a local copy of the currently selected TRK to disk. You can then manually install the file to your devices using the method of your choice.

Install

Click Install to download and install the TRK selected in the Install remote agents list. A progress bar is shown if the install operation requires more than a few seconds to complete.

NOTE Drivers installed by PC Suite or Ovi Suite are required in order for Install to download a remote agent onto the target device.

Related references

Install Remote Agents pane

Use the Install Remote Agents pane to select the latest remote agent version to download and install to the device.

Adding, Editing, and Deleting Connections

Use the Remote Connections view to monitor, create, edit, or remove common remote connection settings.

Editing connections

Use the Remote Connections view to monitor, create, edit, or remove common remote connection settings.

Setup Connection

Use the Edit Connection page to assign a connection type, name, and connection settings to the new connection setup.

Figure 1 - New Connection wizard Setup Connection tab

Table 1. Setup Connection page - options

Item	Explanation
Connection Type	Select the type of connection and its supported services from the drop down list of options. The types of connections include: - - Bluetooth - serial port connection through Bluetooth - Serial - serial port connection through a COM serial port - USB - serial port connection through USB that supports TRK 3.x - - And the supported services may include: - - TRK - Tracing - and others -
Connection Name	Enter a name for the connection.
Connection Settings	Shows a list of services supported by the connection type chosen. - - Bluetooth - serial port connection through Bluetooth - Serial - serial port connection through a COM serial port - USB - serial port connection through USB that supports TRK 3.x -

Item

Explanation

Connection Type

Select the type of connection and its supported services from the drop down list of options. The types of connections include:

Bluetooth - serial port connection through Bluetooth
Serial - serial port connection through a COM serial port
USB - serial port connection through USB that supports TRK 3.x

And the supported services may include:

TRK
Tracing
and others

Connection Name

Enter a name for the connection.

Connection Settings

Shows a list of services supported by the connection type chosen.

Bluetooth - serial port connection through Bluetooth
Serial - serial port connection through a COM serial port
USB - serial port connection through USB that supports TRK 3.x

Related references

On-Device Connections
Test Connection
Install Remote Agents

Setup Connection

Use the Edit Connection page to assign a connection type, name, and connection settings to the new connection setup.

Figure 1 - New Connection wizard Setup Connection tab

Table 1. Setup Connection page - options

Item	Explanation
Connection Type	Select the type of connection and its supported services from the drop down list of options. The types of connections include: + + Bluetooth - serial port connection through Bluetooth + Serial - serial port connection through a COM serial port + USB - serial port connection through USB that supports TRK 3.x + + And the supported services may include: + + TRK + Tracing + and others +
Connection Name	Enter a name for the connection.
Connection Settings	Shows a list of services supported by the connection type chosen. + + Bluetooth - serial port connection through Bluetooth + Serial - serial port connection through a COM serial port + USB - serial port connection through USB that supports TRK 3.x +

Item

Explanation

Connection Type

Select the type of connection and its supported services from the drop down list of options. The types of connections include:

Bluetooth - serial port connection through Bluetooth
Serial - serial port connection through a COM serial port
USB - serial port connection through USB that supports TRK 3.x

And the supported services may include:

TRK
Tracing
and others

Connection Name

Enter a name for the connection.

Connection Settings

Shows a list of services supported by the connection type chosen.

Bluetooth - serial port connection through Bluetooth
Serial - serial port connection through a COM serial port
USB - serial port connection through USB that supports TRK 3.x

Related references

On-Device Connections
Test Connection
Install Remote Agents

Test Connection

Use the Set Connection Settings pane to compare the version of remote service installed on the device with the latest version available for Carbide. A remote service is any software on the device that can communicate with Carbide. This includes TRK, Trace, Performance Investigator, and other services. In this pane you can:

Set the device OS used by the device and supported by the remote service
Verify that Carbide can communicate with the remote service via the chosen connection setting
Verify that you have the latest version of the remote service installed on the device

Options presented may differ based on the type of connection setting chosen.

Figure 1 - Test Connection pane in the New Connection dialog

Table 1 Test Connection pane — items

Item	Explanation
Device OS	A dropdown list of device OSes that are supported by the TRK debug agent software. Select the OS used by the device before running a check.
Select a service to test	Select the remote service type to query on the remote device.
Initiate service testing	Click Initiate service testing to query the remote software on the device for its version number. It then compares the version number found with the latest version available for Carbide. A progress bar will appear when the operation requires more than a few seconds. - NOTE The PC must have an internet connection to perform a remote service version check. - Once the comparison is complete the Status text is updated with the result and further instructions as required. - - If a connection fails, the errors normally fall into these two categories: - - connection failure - this usually indicates the chosen COM port is not open. Try selecting a different COM port, specifically one with a name attached to it (COM4 - BthModem0) for the type of connection you are using (USB or Bluetooth). Repeat as necessary until you get a successful response. - Service not responding - this indicates that the COM port is open but the remote service is not responding. First, verify that remote service is up and running on the device. Second, the remote service may be listening on a different COM port, so choose another named COM port and try again. -

Item

Explanation

Device OS

A dropdown list of device OSes that are supported by the TRK debug agent software. Select the OS used by the device before running a check.

Select a service to test

Select the remote service type to query on the remote device.

Initiate service testing

Click Initiate service testing to query the remote software on the device for its version number. It then compares the version number found with the latest version available for Carbide. A progress bar will appear when the operation requires more than a few seconds.

NOTE The PC must have an internet connection to perform a remote service version check.

Once the comparison is complete the Status text is updated with the result and further instructions as required.

If a connection fails, the errors normally fall into these two categories:

connection failure - this usually indicates the chosen COM port is not open. Try selecting a different COM port, specifically one with a name attached to it (COM4 - BthModem0) for the type of connection you are using (USB or Bluetooth). Repeat as necessary until you get a successful response.
Service not responding - this indicates that the COM port is open but the remote service is not responding. First, verify that remote service is up and running on the device. Second, the remote service may be listening on a different COM port, so choose another named COM port and try again.

Related references

Test Connection

Set the device OS used by the device and supported by the remote service
Verify that Carbide can communicate with the remote service via the chosen connection setting
Verify that you have the latest version of the remote service installed on the device

Options presented may differ based on the type of connection setting chosen.

Figure 1 - Test Connection pane in the New Connection dialog

Table 1 Test Connection pane — items

Item	Explanation
Device OS	A dropdown list of device OSes that are supported by the TRK debug agent software. Select the OS used by the device before running a check.
Select a service to test	Select the remote service type to query on the remote device.
Initiate service testing	Click Initiate service testing to query the remote software on the device for its version number. It then compares the version number found with the latest version available for Carbide. A progress bar will appear when the operation requires more than a few seconds. + NOTE The PC must have an internet connection to perform a remote service version check. + Once the comparison is complete the Status text is updated with the result and further instructions as required. + + If a connection fails, the errors normally fall into these two categories: + + connection failure - this usually indicates the chosen COM port is not open. Try selecting a different COM port, specifically one with a name attached to it (COM4 - BthModem0) for the type of connection you are using (USB or Bluetooth). Repeat as necessary until you get a successful response. + Service not responding - this indicates that the COM port is open but the remote service is not responding. First, verify that remote service is up and running on the device. Second, the remote service may be listening on a different COM port, so choose another named COM port and try again. +

Item

Explanation

Device OS

A dropdown list of device OSes that are supported by the TRK debug agent software. Select the OS used by the device before running a check.

Select a service to test

Select the remote service type to query on the remote device.

Initiate service testing

NOTE The PC must have an internet connection to perform a remote service version check.

Once the comparison is complete the Status text is updated with the result and further instructions as required.

If a connection fails, the errors normally fall into these two categories:

connection failure - this usually indicates the chosen COM port is not open. Try selecting a different COM port, specifically one with a name attached to it (COM4 - BthModem0) for the type of connection you are using (USB or Bluetooth). Repeat as necessary until you get a successful response.
Service not responding - this indicates that the COM port is open but the remote service is not responding. First, verify that remote service is up and running on the device. Second, the remote service may be listening on a different COM port, so choose another named COM port and try again.

Related references

On-Device Connections

Use the New Connection wizard to verify and update Carbide software services on a device. Click the Help > On-Device Connections... menu option to open. Current services available include TRK, Tracing, and others. The following tabs are present:

Setup Connection - define connection type, name and settings
Test Connection - verify connection operates as intended
Install Remote Agents - download and install remote agents

Figure 1 - New Connection dialog

Related references

Setup Connection
Test Connection
Install Remote Agents

On-Device Connections

Setup Connection - define connection type, name and settings
Test Connection - verify connection operates as intended
Install Remote Agents - download and install remote agents

Figure 1 - New Connection dialog

Related references

Setup Connection
Test Connection
Install Remote Agents

Breakpoints View

Use the Breakpoints view to set, examine, enable, disable, and remove breakpoints and watchpoints in one or more build configurations. Table 1 explains items in the view.

Carbide Portal view

The Carbide Portal view provides a single point of information on Carbide news, new releases, additional extensions, and support. The Carbide Portal view is shown by clicking Help > Carbide Portal.

Console View

Console view

The Console view displays the output of a process and allows you to provide keyboard input to a process. There are numerous consoles available, see the Open Console dropdown list for those available to you. Most are enabled from various project panels in Carbide.

Disassembly View

When debugging your application, the Disassembly view shows the loaded program as assembler instructions. When you use the Disassembly view, you can do the following tasks:

Executables view

The Executables view provides a dynamic list of executables and their related source files. The Executables view makes it easy to:

Expressions Window

Expressions View

Use the Expressions view to monitor and manipulate:

Install Extensions view

The Install Extensions view enables the user to locate and install Carbide plug-ins into a core Carbide.c++ installation. The Install Extensions view links to an online site that lists available plug-ins for installation. Plug-ins are grouped by type for

The Install Extensions view appears as part of the C/C++ Perspective. It can be added to a perspective by clicking Window > Show View > Install Extensions.

Memory view

Use the Memory view to inspect and change process memory. You can address memory using expressions such as:

Modules View

The Modules view displays a list of modules loaded while debugging your program. The listed modules can be selected to show related information. You can open the Modules view in the Carbide C/C++ perspective by selecting Window > Show view > Other..., then expand the Debug folder and select Modules. In the Debug perspective select Window > Show view > Modules.

The Modules view is only loaded during a debug session and closes when the debug session ends. Select the running man icon to list the Type, Symbols, and Symbols file for the executable. Select the stack of books icon to list the Type, Symbols, Symbols file, and Base address for the shared library.

Project Explorer View

Project Explorer view

The Project Explorer view (Figure 1) displays relevant C/C++ projects located in the current workspace using a tree structure. Use this view to manage all the projects located in the current workspace. The view is customizable and takes advantage of working sets.

The content of a project is dependent upon how it was created in the workspace.

Registers View

The Registers view reveals a hierarchical view of general, FPU, and host-specific registers of the host computer or target device. You can use the Register view to perform these tasks:

expand the hierarchical items in the window and view their contents
select and modify register values
view documentation for individual registers (depending on the register)

Figure 1 shows a sample Registers view.

Figure 1 - Registers View

Table 1. Registers view—items

Item	Icons	Explanation
Show Type Names		Toggles the display of type names in the Registers view.
Show Logical Structure		Not available in C/C++ yet.
Collapse All		Collapses all expanded variables into the top level.

For more information, see the C/C++ Development User Guide > Reference > Debug View > Registers view.

To open a Registers view

Click Window > Show View > Registers

A Registers view appears.

Other references

Registers View

The Registers view reveals a hierarchical view of general, FPU, and host-specific registers of the host computer or target device. You can use the Register view to perform these tasks:

expand the hierarchical items in the window and view their contents
select and modify register values
view documentation for individual registers (depending on the register)

Figure 1 shows a sample Registers view.

Figure 1 - Registers View

Table 1. Registers view—items

Item	Icons	Explanation
Show Type Names		Toggles the display of type names in the Registers view.
Show Logical Structure		Not available in C/C++ yet.
Collapse All		Collapses all expanded variables into the top level.

For more information, see the C/C++ Development User Guide > Reference > Debug View > Registers view.

To open a Registers view

Click Window > Show View > Registers

A Registers view appears.

Other references

Signals view

The Signals view of the Debug perspective lets you view the signals defined on the selected debug target and how the debugger handles each one. Figure 1 shows the Signals view.

Symbian Project Navigator view

The Symbian Project Navigator view shows all files that belong to the current build configuration. This view lists the Symbian projects in your current workspace and their corresponding *.inf file (typically bld.inf). The *.inf file contains the related MMP project files, which are also listed in a tree structure. You can collapse or expand the list for each MMP to see which sources belong to each MMP.

Symbian OS Data view

The Symbian OS Data view displays the processes and threads for the suspended debug session based on the selection in the Debug view. Read-only data is displayed for ARM build configurations. To open the Symbian OS Data view select Window > Show View > Symbian OS Data when the Debug perspective is visible or select Window > Show View > Other..., then expand the Carbide.c++ folder and select Symbian OS Data when the Carbide C/C++ perspective is visible. Click Ok to display the Symbian OS Data window (Figure 1).

NOTE The Symbian OS Data view works with the debugger and will only display data during a live debug session. The Symbian OS Data view is not supported for emulator debugging, and will not show anything during emulator debug.

Variables View

The Variables view allows manipulation of the variables or variable hierarchy used in source code. For example, you can change the variable format, change a variables value, add watchpoints, and add global variables. In addition to the standard C/C++, Symbian, and the Qt data types: QString, QByteArray, QSet, QHash, QMap, QVector, QList, QLinkedList and Qvariant.

Figure 1 shows the Variables view with Show Type Names option enabled.

Working with Memory

This section explains how to work with variables in a Carbide.c++ debugging session. The following views show various types of information about variables:

Carbide Views

Here are all the views available within the Carbide IDE and debugging environments.

Carbide C/++ perspective views:

Carbide Debug dialog

Debug dialog

Use the Debug dialog to create, edit, and manage a project's launch configurations. A launch configuration defines the settings used by the Carbide debugger to launch (Run) or debug programs. A project must have at least one launch configuration in order to debug a project and can have many more. Projects that have no launch configuration invoke the New Launch Configuration Wizard when either the Run or Debug command is selected.

Select the Run > Debug Configuration... menu option to open the Debug dialog.

Import Bitmaps

Use the Import window to import bitmap resources from the file system.

Carbide.c++ Release Notes 3.0.0

The Carbide.c++ is a comprehensive development tool suite for Symbian OS that is based on the Eclipse framework. The C++ Development Toolkit (CDT), provides the foundation for project and build tools management, as well as the primary interface for the debugger to communicate with the IDE.

This is a collection of important information concerning last-minute diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/AddinganSDK.html --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/AddinganSDK.html Fri Aug 06 14:05:52 2010 -0500 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,45 +0,0 @@ - -Adding an SDK - - - -

Adding an SDK

- The Symbian OS plug-ins can usually detect when a SDK has been installed, - as described in SDK Support.

- To do this: -

-
- Click Window > Preferences to open the Preferences window, then select SDK Preferences in the Carbide.c++ group - to show the page for SDKs.
-

- -

- - -

Click Add New SDK to add a specific SDK or Rescan All SDKs to search the installed SDKs and add them to the Available Symbian OS SDKs list.
-
Click OK to save the settings.

Working with SDKs
SDK Properties

SDK Preferences

Removing Breakpoints

You can remove one or more breakpoints set for a debug session using the Breakpoints, Disassembly, or editor views.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_conditional.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_conditional.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_conditional.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Setting Conditional Breakpoints - +

Setting Conditional Breakpoints or Watchpoints

You create a conditional (temporary) breakpoint or watchpoint in the Properties for C/C++ breakpoint dialog. Right-click a breakpoint or watchpoint in the Breakpoints view, then select Properties from the context menu. A conditional breakpoint or watchpoint has an associated conditional expression. The debugger evaluates the expression to determine whether to halt program execution at that breakpoint.

A conditional breakpoint or watchpoint behaves in two different ways:

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_disable.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_disable.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_disable.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Disabling Breakpoints - +

Disabling Breakpoints

Disable a breakpoint to prevent it from affecting program execution. The disabled breakpoint remains at the source-code line at which you set it, so that you can enable it later. Disabling the breakpoint is easier than clearing it and re-creating it from scratch.

Figure 1 shows some source code and the selected line shows the breakpoint icon that appears in the marker bar when a breakpoint is disabled.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_enable.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_enable.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_enable.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Enabling Breakpoints - +

Enabling Breakpoints

Enable a breakpoint to have it halt program execution at the specific line in the source file. You can set a breakpoint using the Breakpoints, Disassembly, or editor views. An enabled breakpoint must still be resolved during a debug session before it can halt program execution. Enabling a breakpoint that you previously disabled is easier than clearing it and re-creating it from scratch.

Figure 1 shows some source code and the selected line shows the breakpoint icon that appears in the marker bar when a breakpoint is enabled. diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_exporting.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_exporting.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_exporting.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Exporting Breakpoints - +

Exporting Breakpoints

Use the Export Breakpoints command to export selected breakpoints to a breakpoints file with a .bkpt extension. All breakpoints set in the source files of all projects in your current workspace will be listed in the Export Breakpoints window.

The Export Breakpoints wizard shown in Figure 1 helps you to export breakpoints from your project's source files.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_importing.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_importing.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_importing.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Importing Breakpoints - +

Importing Breakpoints

Use the Import Breakpoints command to import breakpoints previously exported and saved to a breakpoints file (.bkpt). The Import Breakpoints wizard helps you to import breakpoints from a file.

Figure 1 shows the Import Breakpoints window.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_setting.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_setting.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_setting.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Setting Breakpoints - +

Setting Breakpoints

Use the Set Breakpoint command (Ctrl+Shift+B) to set a breakpoint. A regular breakpoint suspends program execution. The debugger executes the line of source code that contains the regular breakpoint.

TIP If you find that a breakpoint is not being hit, verify that the EXE or DLL is listed in the Executables view.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_temporary.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_temporary.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_temporary.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Setting a Temporary Breakpoint - +

Setting a Temporary Breakpoint

Use the Temporary Breakpoint command to set temporary breakpoints. Unlike a regular breakpoint that halts execution each time you debug a project, a temporary breakpoint halts execution only once. The debugger removes the temporary breakpoint after halting program execution.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_view_props.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_view_props.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_view_props.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Viewing Breakpoint Properties - +

Viewing Breakpoint Properties

After you set a breakpoint, you can view and modify its Actions, Common, and Filtering properties. Table 1 explains breakpoint properties for the Common panel.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/save_breakpoints_view.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/save_breakpoints_view.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/save_breakpoints_view.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Saving the Breakpoints View - +

Saving the Contents of Breakpoints View

You can save the contents of the Breakpoints view. This feature is useful for saving sets of breakpoint data, then later re-opening those sets.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/show_breakpoints_view.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/show_breakpoints_view.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/show_breakpoints_view.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Opening the Breakpoints View - +

Opening a Breakpoints View

Use the Breakpoints view to show a list of breakpoints currently set in your project.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/custom/carb_custom_menus.htm --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/custom/carb_custom_menus.htm Fri Aug 06 14:28:38 2010 -0500 @@ -0,0 +1,49 @@ + + + + + + +Customizing Carbide: Toolbars and Menus + + + + +

Customizing Carbide: Toolbars and Menus

You can customize which commands appear on toolbars and menus using the Customize Perspective dialog. For purposes of customizing Carbide there are two perspectives of interest, the Carbide C/C++ perspective where project management and editing occurs and the Debug perspective used for debugging a project.

Click Window > Customize Perspectve... to open the Customize Perspective dialog which allows you to customize the current perspective. There are four tabs enabling you to customize the Carbide commands in multiple ways. The tabs include:

Toolbar Visibility
Menu Visibility
Command Group Availability
Shortcuts

Its best to start with the Command Group Availability tab as it controls the command groups that appear in the Toolbar and Menu Visibility tabs. An unchecked group will not be editable in the other tabs.

NOTE You can reset to the perspectives default by clicking Window > Reset Perspective menu option. This removes ALL changes made to the perspective.

Toolbar Visibility

Use the Toolbar Visibility tab to control which commands appear on the perspective toolbar.

Customize Perspective dialog

Customize Perspective dialog (Toolbar Visibility tab)

Menu Visibility

Use the Menu Visibility tab to control which menu commands appear on the perspective menus.

Customize Perspective dialog

Customize Perspective dialog (Menu Visibility tab)

Command Group Availability

Use the Command Group Availablity tab to control which command groups to use in the perspective.

Customize Perspective dialog

Customize Perspective dialog (Command Group tab)

Shortcuts

Use the Shortcuts tab to control the shortcuts used in the perspective.

Customize Perspective dialog

Customize Perspective dialog (Shortcuts tab)

Other references

Customizing Carbide

+ + + + \ No newline at end of file diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/custom/carb_customizing.htm --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/custom/carb_customizing.htm Fri Aug 06 14:28:38 2010 -0500 @@ -0,0 +1,29 @@ + + + + + + +Customizing Carbide + + + +

Customizing Carbide

Carbide is very customizable. If the original setup doesn't work its easy to change to something more to your liking. Some of the features and UI you can change include:

Editor settings (fonts, colors, hover behaviors)
Shortcut keys
Toolbars and menus

In addition, its possible to change some default settings so that every new project you create inherits precisely the attributes you desire. These include:

SDKs

Finally, some teams like to have everyone using the same development setup for uniformity of code. That is fully supported in:

Sharing Carbide Setups

+ + + + \ No newline at end of file diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/custom/carb_export_setup.htm --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/custom/carb_export_setup.htm Fri Aug 06 14:28:38 2010 -0500 @@ -0,0 +1,20 @@ + + + + + + +Customizing Carbide: Sharing Carbide Setups + + + +

Customizing Carbide: Sharing Carbide Setups

Some teams like everyone to use identical development environments.

Other references

Customizing Carbide

+ + + + \ No newline at end of file diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug.htm Fri Aug 06 14:28:38 2010 -0500 @@ -1,36 +1,36 @@ - - - - - - -Run Mode Debugger Settings - - - -

Run Mode On-Device Debugging

Run mode on-device debugging enables you to download and launch a project on a phone or target device and debug it using the Carbide debugger. Before you can do that, some setup requirements are required. Once the setup is done, Carbide can then use plug-and-play (PnP) with USB to create a remote connection that connects with the TRK agent on the target device to download, launch, and debug the program.

Setup system and development requirements (below)
Install Application or System TRK v3.2.6 or later on the target device
Connect USB cable to phone or target device for PnP connectivity
Create or import a project in the Carbide C/C++ workspace
Build the project
Debug the project on a phone or target device

Setup system and development requirements

All of the following requirements are required to build, communicate, and control programs on a phone or target device.

Install PC Suite or Ovi Suite on your PC to ensure the correct drivers are installed for connecting to the phone or target device.
Install the correct version of Perl on your PC to support Symbian OS builds
Install a supported SDK and make sure its the default
Configure the environmental variables
(Optional) Setup a virtual drive to use Techview and Cust Kits

Once you've setup your environment, its time to verify that the TRK agent is on the phone or target device.

- - - - + + + + + + +Run Mode Debugger Settings + + + +

Run Mode On-Device Debugging

Setup system and development requirements (below)
Install Application or System TRK v3.2.6 or later on the target device
Connect USB cable to phone or target device for PnP connectivity
Create or import a project in the Carbide C/C++ workspace
Build the project
Debug the project on a phone or target device

Setup system and development requirements

All of the following requirements are required to build, communicate, and control programs on a phone or target device.

Install PC Suite or Ovi Suite on your PC to ensure the correct drivers are installed for connecting to the phone or target device.
Install the correct version of Perl on your PC to support Symbian OS builds
Install a supported SDK and make sure its the default
Configure the environmental variables
(Optional) Setup a virtual drive to use Techview and Cust Kits

Once you've setup your environment, its time to verify that the TRK agent is on the phone or target device.

+ + + + diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_01.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_01.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_01.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Installing Perl - +

Installing Perl

Perl is a high-level, general-purpose, interpreted, dynamic programming language which many Symbian OS build utilities and commands require.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_02.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_02.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_02.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Installing an SDK - +

Installing an SDK

To create projects an SDK must be installed. If more than one SDK is installed one must be specified as the default.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_03.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_03.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_03.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Configuring Environment Variables - +

Configuring Environment Variables

To implement run mode on-device debugging the following tasks need to be completed.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_04.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_04.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_04.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Setup a Virtual Drive - +

Setup a Virtual Drive (optional)

SDKs have kernel components, kernel extensions and device drivers that are typically built on a virtual drive. So if you want to debug them the debugger will need to load files from the virtual drive that the binaries were built on. If you do not know the virtual drive the kit was built on you should first pick a drive letter randomly.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_05.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_05.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_05.htm Fri Aug 06 14:28:38 2010 -0500 @@ -1,43 +1,43 @@ - - - - - - -Run Mode On-Device Debugging - - - -

Run Mode On-Device Debugging

To implement run mode on-device debugging the following tasks need to be completed.

Install device connection software
Install Perl
Install an SDK
Setup environment variables
Setup a virtual drive for Techview and Cust Kits
Set the default kit in Devices.xml
Install the SISX file on the target device
Configure TRK connection on the device
Create a launch configuration

Set the Default Kit in Devices.xml

The Symbian environment needs to know the kit you are using. This is needed since you may have multiple kits installed. You can specify the development kit by setting a default in the file called devices.xml located in the C:\Program Files\Common Files\Symbian folder.

From the command line

Set the default device devkit by typing on the command line:
-> devices –setdefault @device id: name

The device id and name can be found in the devices.xml file. For example, for a Techview 9.2 kit you might type
- > devices –setdefault @ SymbianOS_92_2006_wk40:com.symbian.techview

Now ensure the default device is set by entering:
-> devices
Make sure the correct default is set.

- - - - + + + + + + +Run Mode On-Device Debugging + + + +

Run Mode On-Device Debugging

To implement run mode on-device debugging the following tasks need to be completed.

Install device connection software
Install Perl
Install an SDK
Setup environment variables
Setup a virtual drive for Techview and Cust Kits
Set the default kit in Devices.xml
Install the SISX file on the target device
Configure TRK connection on the device
Create a launch configuration

Set the Default Kit in Devices.xml

From the command line

Set the default device devkit by typing on the command line:
+> devices –setdefault @device id: name

The device id and name can be found in the devices.xml file. For example, for a Techview 9.2 kit you might type
+ > devices –setdefault @ SymbianOS_92_2006_wk40:com.symbian.techview

Now ensure the default device is set by entering:
+> devices
Make sure the correct default is set.

+ + + + diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_06.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_06.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_06.htm Fri Aug 06 14:28:38 2010 -0500 @@ -1,70 +1,70 @@ - - - - - - -Run Mode On-Device Debugging - - - -

Run Mode On-Device Debugging

To implement run mode on-device debugging the following tasks need to be completed.

Install device connection software
Install Perl
Install an SDK
Setup environment variables
Setup a virtual drive for Techview and Cust Kits
Set the default kit in Devices.xml
Install the SISX file on the target device
Configure TRK connection on the device
Create a launch configuration

Install the SISX File on the Target Device

The on-device debug agent is delivered to the target device as a SISX file. There are two versions of TRK: Application TRK and System TRK.

Application TRK— supports application debugging only and available to developers creating applications for devices. Developers do not have access to system level routines, system ROM, and other user application code. User cannot modify the LR and SR registers, and must use a SIS file to debug an application.
System TRK— supports both application and limited ROM debugging; including application executables and limited ROM based components (no device drivers). Also available to original equipment manufacturers (OEMs) for device creation and customization.

The following SISX file is officially signed by Nokia: - s60_3_0_app_trk_2_6_nokia_signed.sisx

Installing using Bluetooth

Right click on the Bluetooth item on the system tray and select Quick Connect > File Transfer > Find Devices
Refresh the File Transfer window to allow the device to detect all the Bluetooth devices
From the list select your device and click Open
You should enable the My Bluetooth Places window popup option that creates a connection shortcut “MyDeviceOBEX File Transfer” in the My Bluetooth Places folder.
The Obex File Transfer window for your devices should open from within the My Bluetooth Folder
You will be prompted to enter a Bluetooth PIN code. Enter any number.
On the device you will be prompted to enter the same PIN code. Enter PIN code.
The device will then ask you to accept the connection request from the PC. Press OK.

The OBEX folder on the PC should now be available.

Drop the TRK SISX file into the folder
The device will prompt you to accept the connection request from the PC. Press OK.
The SISX file should then transfer from the PC to the device
Navigate to where the SISX file was placed

If you dropped it into the OBEX folder it will be in Applications > Messages > Inbox. If you dropped it into the C folder it will be in Applications > Utilities >FileBrowse > C.

Select the TRK SISX file on the device to install the TRK debug agent.

Installing using PC Suite

Place the SISX file on your PC
Connect the USB cable to the phone
On the device it will display USB mode:
- PC Suite
- File transfer
Select PC Suite and the device will connect to the PC
Open PC suite. In the bottom left a status display should indicate “Series 60 Device connected via USB”.
Double click “Install applications”. The Nokia Application Installer wizard will appear.
On the left you should see My Computer and on the right My Phone
From My Computer select the SISX file on your PC
From My Phone select the “Phone memory” drop down list an select where you want to install the file.
Select the green arrow pointing from My Computer to My Device. The SISX file should then be transferred to the device and installed.

- - - - + + + + + + +Run Mode On-Device Debugging + + + +

Run Mode On-Device Debugging

To implement run mode on-device debugging the following tasks need to be completed.

Install device connection software
Install Perl
Install an SDK
Setup environment variables
Setup a virtual drive for Techview and Cust Kits
Set the default kit in Devices.xml
Install the SISX file on the target device
Configure TRK connection on the device
Create a launch configuration

Install the SISX File on the Target Device

The on-device debug agent is delivered to the target device as a SISX file. There are two versions of TRK: Application TRK and System TRK.

Application TRK— supports application debugging only and available to developers creating applications for devices. Developers do not have access to system level routines, system ROM, and other user application code. User cannot modify the LR and SR registers, and must use a SIS file to debug an application.
System TRK— supports both application and limited ROM debugging; including application executables and limited ROM based components (no device drivers). Also available to original equipment manufacturers (OEMs) for device creation and customization.

The following SISX file is officially signed by Nokia: + s60_3_0_app_trk_2_6_nokia_signed.sisx

Installing using Bluetooth

Right click on the Bluetooth item on the system tray and select Quick Connect > File Transfer > Find Devices
Refresh the File Transfer window to allow the device to detect all the Bluetooth devices
From the list select your device and click Open
You should enable the My Bluetooth Places window popup option that creates a connection shortcut “MyDeviceOBEX File Transfer” in the My Bluetooth Places folder.
The Obex File Transfer window for your devices should open from within the My Bluetooth Folder
You will be prompted to enter a Bluetooth PIN code. Enter any number.
On the device you will be prompted to enter the same PIN code. Enter PIN code.
The device will then ask you to accept the connection request from the PC. Press OK.

The OBEX folder on the PC should now be available.

Drop the TRK SISX file into the folder
The device will prompt you to accept the connection request from the PC. Press OK.
The SISX file should then transfer from the PC to the device
Navigate to where the SISX file was placed

If you dropped it into the OBEX folder it will be in Applications > Messages > Inbox. If you dropped it into the C folder it will be in Applications > Utilities >FileBrowse > C.

Select the TRK SISX file on the device to install the TRK debug agent.

Installing using PC Suite

Place the SISX file on your PC
Connect the USB cable to the phone
On the device it will display USB mode:
+ PC Suite
+ File transfer
Select PC Suite and the device will connect to the PC
Open PC suite. In the bottom left a status display should indicate “Series 60 Device connected via USB”.
Double click “Install applications”. The Nokia Application Installer wizard will appear.
On the left you should see My Computer and on the right My Phone
From My Computer select the SISX file on your PC
From My Phone select the “Phone memory” drop down list an select where you want to install the file.
Select the green arrow pointing from My Computer to My Device. The SISX file should then be transferred to the device and installed.

+ + + + diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_07.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_07.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug_07.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Run Mode On-Device Debugging - +

Run Mode On-Device Debugging

To implement run mode on-device debugging the following tasks need to be completed.

Run Mode On-Device Debugging

To implement run mode on-device debugging the following tasks need to be completed.

Using Soft Attach for On-Device Debugging

NEEDS REWRITING

You can debug hardware via TCF using the soft attach option. This enables you to debug an image flashed to ROM or on a memory card. Soft attach includes all the capabilities fo Stop-mode debugging but can't debug any code loaded before the OS is booted.

Stopping Program Execution

Setting Symbian OS Data View Refresh Rate

A global preference option in the Preferences window of Carbide.c++ allows a user to change the time interval for auto-refreshing kernel data in the Symbian OS View.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/work_debug_act_debug.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/work_debug_act_debug.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/work_debug_act_debug.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Debugging a Program - +

Debugging a Program

Use the Debug command () to execute a program under debugger control using the current launch configuration settings.

If this is the first time the program is launched for debugging, a new debug launch configuration is automatically created for you based on current project settings and assigned a name. If a debug launch configuration is already available, the Debug command launches using the last debug launch configuration used with the project.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/eventpoints_disabling.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/eventpoints_disabling.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/eventpoints_disabling.htm Fri Aug 06 14:28:38 2010 -0500 @@ -1,28 +1,28 @@ - - - - - - -Disabling an Eventpoint - - - -

Disabling an Eventpoint

Disable an eventpoint to prevent it from performing its specified action. The disabled eventpoint remains at the source-code line at which you set it, so that you can enable it later. Disabling the eventpoint is easier than clearing it and re-creating it from scratch.

To disable an eventpoint

Select the eventpoint to disable

Select the eventpoint by name in the Breakpoints view, or click the cursor on the source-code line that contains the eventpoint.

Click Debug > Disable Eventpoint

The Disable Eventpoint menu appears.

From the menu, click the Disable Eventpoint command, where Eventpoint is the type of eventpoint that you want to disable

The enabled eventpoint icon changes to a disabled eventpoint icon (shown at left). The disabled eventpoint icon indicates that the eventpoint does not perform its specified action.
-

Disabling an Eventpoint

To disable an eventpoint

Select the eventpoint to disable

Select the eventpoint by name in the Breakpoints view, or click the cursor on the source-code line that contains the eventpoint.

Click Debug > Disable Eventpoint

The Disable Eventpoint menu appears.

From the menu, click the Disable Eventpoint command, where Eventpoint is the type of eventpoint that you want to disable

The enabled eventpoint icon changes to a disabled eventpoint icon (shown at left). The disabled eventpoint icon indicates that the eventpoint does not perform its specified action.
+

+ + + diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/eventpoints_enabling.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/eventpoints_enabling.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/eventpoints_enabling.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Enabling an Eventpoint - +

Enabling an Eventpoint

Enable an eventpoint to have it perform its specified action during program execution. Enabling an eventpoint that you previously disabled is easier than clearing it and re-creating it from scratch.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/eventpoints_setting.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/eventpoints_setting.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/eventpoints_setting.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Setting a Conditional Eventpoint - +

Setting a Conditional Eventpoint

Use the Condition column of the Breakpoints view to set a conditional eventpoint. A conditional eventpoint has an associated conditional expression. The debugger evaluates the expression to determine whether the eventpoint performs its specified action.

A conditional eventpoint behaves in two different ways:

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/eventpoints_viewing.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/eventpoints_viewing.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/eventpoints_viewing.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Viewing Eventpoint Properties - +

Viewing Eventpoint Properties

After you set an eventpoint, you can view and modify its properties.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/log_point_clear.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/log_point_clear.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/log_point_clear.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Log Point - +

Log Point

A Log Point logs or speaks a string or expression. A Log Point can also record messages to the Log window. You can configure the message that appears in the log window.

Related tasks

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/log_point_set.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/log_point_set.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/log_point_set.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Log Point - +

Log Point

A Log Point logs or speaks a string or expression. A Log Point can also record messages to the Log window. You can configure the message that appears in the log window.

Related tasks

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/pause_point_clear.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/pause_point_clear.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/pause_point_clear.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Pause Point - +

Pause Point

A Pause Point suspends program execution long enough to refresh debugger data. For example, without setting a pause point, you must wait for the debugger to halt program execution before it can refresh data. Setting a Pause Point, however, lets you pause the debugging session to give the debugger time to refresh the data.

Related tasks

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/pause_point_set.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/pause_point_set.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/pause_point_set.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Pause Point - +

Pause Point

Related tasks

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/trace_collection_clear.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/trace_collection_clear.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/trace_collection_clear.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Clearing a Trace Collection - +

Clearing a Trace Collection

Clear a Trace Collection eventpoint when you are finished collecting trace data.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/trace_collection_off.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/trace_collection_off.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/trace_collection_off.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Trace Collection Off - +

Trace Collection Off

A Trace Collection Off eventpoint stops the collection of trace data. This eventpoint is useful when you want trace collection to stop when program execution reaches a line of source code that you specify.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/trace_collection_on.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/trace_collection_on.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/trace_collection_on.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Trace Collection On - +

Trace Collection On

A Trace Collection On eventpoint starts the collection of trace data. This eventpoint is useful when you want trace collection to start when program execution reaches a line of source code that you specify.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/images/wnd_customize_perspective.png Binary file core/com.nokia.carbide.cpp.doc.user/html/tasks/images/wnd_customize_perspective.png has changed diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/images/wnd_customize_perspective_cmds.png Binary file core/com.nokia.carbide.cpp.doc.user/html/tasks/images/wnd_customize_perspective_cmds.png has changed diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/images/wnd_customize_perspective_menus.png Binary file core/com.nokia.carbide.cpp.doc.user/html/tasks/images/wnd_customize_perspective_menus.png has changed diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/images/wnd_customize_perspective_shortcuts.png Binary file core/com.nokia.carbide.cpp.doc.user/html/tasks/images/wnd_customize_perspective_shortcuts.png has changed diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/memory/memory_monitor_adding.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/memory/memory_monitor_adding.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/memory/memory_monitor_adding.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Adding a Memory Monitor - +

Adding a Memory Monitor

You can add one or more memory monitors to the Memory view. A memory monitor shows the contents of a different address or expression.

NOTE When using an emulator, the memory addresses are actually based on their location and formats dependent upon the host machine.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/memory/memory_monitor_removing.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/memory/memory_monitor_removing.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/memory/memory_monitor_removing.htm Fri Aug 06 14:28:38 2010 -0500 @@ -12,7 +12,7 @@ --> - +

Removing a Memory Monitor or Rendering

Remove a memory monitor or rendering when you have finished working with it.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/memory/memory_rendering_adding.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/memory/memory_rendering_adding.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/memory/memory_rendering_adding.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Adding a Memory Monitor - +

Adding a Memory Rendering

Add a memory rendering pane to display the memory monitor item in different formats. The formats available include:

Opening the Memory View

Opening a Memory View

Use the Memory view to examine a portion of memory starting at a specific address on the host machine.

NOTE When using an emulator, the memory addresses are actually based on their location and formats dependent upon the host machine.

Attaching to a Symbian OS Process

Use the Symbian OS Attach to Process launch configuration to attach the debugger to an already running Symbian OS process or thread on a target device. This is useful for debugging servers running in RAM in a client-server relationship where the client relies on the presence of the server process to operate as one example.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/processes/open_log_view.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/processes/open_log_view.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/processes/open_log_view.htm Fri Aug 06 14:28:38 2010 -0500 @@ -1,28 +1,28 @@ - - - - - - -Opening a Log View - - - -

Opening a Log View

Use the Debugger Settings preference panel to enable the message logging option. The Log view records these types of messages for a program during a debugging session:

the start of new tasks
routine entry and exit
Windows: DLL loading and unloading, and debug printf() messages

Select the Log System Messages option in the Debugger Settings target settings preference panel.

Select Project > Debug

The Log view appears. It allows you to select, copy, and save logged text to a file for later analysis.

- - - - + + + + + + +Opening a Log View + + + +

Opening a Log View

Use the Debugger Settings preference panel to enable the message logging option. The Log view records these types of messages for a program during a debugging session:

the start of new tasks
routine entry and exit
Windows: DLL loading and unloading, and debug printf() messages

Select the Log System Messages option in the Debugger Settings target settings preference panel.

Select Project > Debug

The Log view appears. It allows you to select, copy, and save logged text to a file for later analysis.

+ + + + diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/processes/opening_system_browser.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/processes/opening_system_browser.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/processes/opening_system_browser.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Opening the System Browser View - +

Opening the System Browser View

Use the System Views or System menu command to view and manipulate active processes on a selected machine. If multiple machines are available, select each machine from the System Views submenu to display multiple System Browser windows. If you choose a machine that is already open, the existing window will be brought to the front.

NOTE The System Browser view appears on platforms that support it.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_adding_symbian_class.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_adding_symbian_class.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_adding_symbian_class.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Adding Symbian OS Classes - +

Adding Symbian OS Classes

Use the New Symbian OS C++ Class wizard to add Symbian templated classes to a project.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_build.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_build.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_build.htm Fri Aug 06 14:28:38 2010 -0500 @@ -8,7 +8,7 @@ - +

Building Projects and Symbian Components

Building projects consists of a new abld-based build system that wraps build functionality around existing SDK build tools that invoke makmake commands (e.g. bldmake bldfiles and abld build).

The plug-ins provide extra functionality to set up suitable build configurations for Symbian OS C++ projects. The initial selection of a build configuration is done when you create a project, as described in Creating New Projects. You can later change the Active Build Configuration. The Build Configurations also provides a command (Project > Build All Configurations) to build all the selected build configurations in a batch.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_build_cmd_line.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_build_cmd_line.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_build_cmd_line.htm Fri Aug 06 14:28:38 2010 -0500 @@ -15,7 +15,7 @@ --> - +

Setting Environment for x86 Compiler

You can build files and projects using the Carbide.c++ command-line tools.

The command-line tools are located in the plugins\x86Build folder and include:

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_build_multi_projects.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_build_multi_projects.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_build_multi_projects.htm Fri Aug 06 14:28:38 2010 -0500 @@ -8,7 +8,7 @@ Building Multiple Projects - +

Importing Projects With Inter-Dependencies

If you are building a project that had external project dependencies, such as an import library from a DLL you must make sure the projects diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_clean.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_clean.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_clean.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Cleaning Projects - +

Cleaning Projects

In the Project Explorer or Symbian Project Navigator views you can select a project, right-click and select Clean Project (CTRL+SHIFT+-) to remove the object and make files, and output files. The files that are removed by this command include all the intermediate files created during compilation and all the executables and import libraries created by the linker.

If you select a project and select the menu option Project > Clean... the Clean dialog appears (Figure 1). You can clean all projects or select individual projects to clean within the workspace. This method of cleaning projects performs the same operations as the Clean Project context menu option. If the Start a build immediately option is selected, then the selected project(s) are rebuilt after the clean operation.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_creating_sis_file.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_creating_sis_file.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_creating_sis_file.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Working with PKG and SIS Files - +

Creating a .SIS File

Carbide.c++ attempts to build SIS files for all phone targets when a PKG file exists in a given build project. More than one SIS/PKG file can be included and built by a project, but only one can be downloaded to the device for debugging purposes.

There are three main tools involved in generating SIS files from PKG files.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_debug_config.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_debug_config.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_debug_config.htm Fri Aug 06 14:28:38 2010 -0500 @@ -8,7 +8,7 @@ Creating a Launch Configuration - +

Creating a Launch Configuration

To run or debug a project you need a launch configuration. A project must have at least one launch configuration, and can have as many as necessary. When run on an emulator project the wizard simply creates an emulator launch configuration and launches the emulator. When running a device project for the first time the New Launch Configuration Wizard seeks additional information required to create the launch configuration, then downloads the executable to the device and launches it. Once the emulator or device are loaded with the executable, the debug session can commence.

There are two methods for setting up a launch configuration, including:

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_debug_console.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_debug_console.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_debug_console.htm Fri Aug 06 14:28:38 2010 -0500 @@ -1,49 +1,49 @@ - - - - - - -Debugging Applications - - - -

Debugging Applications

You can debug one or more applications just as you would any other executable with full support of the Carbide debugger. There are two methods that one can use to debug an application:

For console applications, assign the Executable and leave the Emulator blank in the Debug window

In the Debug window or launch configuration, simply point the Executable option to the executable and clear the Emulator option as shown in Figure 1. This launches the application when you start a debug session from the project.

-
-
Figure 1 - Launch ConsoleTest executable to debug the ConsoleTest project
-

- -

For regular applications, assign the Executable and Remote process to launch in the Debug window

-
In the Debug window or launch configuration, simply point both the Executable and Remote process to launch options to the application. This launches the application when you start a debug session from the application project.
-
-
Figure 2 - Assign Executable and Remote Process
-

Related concepts

Projects
Project Resources

Related tasks

Related references

Project Directories

- - - - + + + + + + +Debugging Applications + + + +

Debugging Applications

You can debug one or more applications just as you would any other executable with full support of the Carbide debugger. There are two methods that one can use to debug an application:

For console applications, assign the Executable and leave the Emulator blank in the Debug window

+
+
Figure 1 - Launch ConsoleTest executable to debug the ConsoleTest project
+

+ +

For regular applications, assign the Executable and Remote process to launch in the Debug window

+
In the Debug window or launch configuration, simply point both the Executable and Remote process to launch options to the application. This launches the application when you start a debug session from the application project.
+
+
Figure 2 - Assign Executable and Remote Process
+

Related concepts

Projects
Project Resources

Related tasks

Related references

Project Directories

+ + + + \ No newline at end of file diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_debug_dlls.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_debug_dlls.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_debug_dlls.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Debugging DLLs - +

Debugging DLLs

A binary that you want to debug must be built with symbolic information (a .sym file). You can debug a DLL just as you would any other executable with full support of the Carbide debugger. Basically, the following situations can occur:

Debugging Multiple Projects

Use the import Symbian executable feature to import another project's executable into a main project to debug them both in a single debugging session. This works very well when every executable you import uses the same debug launch configuration, enabling you to switch between the various executables as necessary to debug each in turn or together. For example, you could debug an application project as well as the two DLL projects that it uses, in a single debug session.

NOTE You must have the executable's project in order to embed that executable into the main project for debugging.

Debugging in ROM

You will see symbolic information for other components when you are debugging in ROM using System TRK if those components were built with symbolic information and the ROM Log file is specified. If a function in the stack crawl is in a ROM module and the IDE is able to find a file containing symbolic information for that module, the IDE will load it automatically and display function names. The IDE will also allow source level debugging and let you set breakpoints in this module.

Some issues to pay attention to when debugging include:

Freezing DLL Projects

Use the Project > Freeze Exports menu command to freeze a entire project, normally a DLL, to ensure backward compatibility of a new release. The result is a .def file that can be imported into other projects. You cannot freeze a single file of the project, only the entire project. Also, once a project is frozen, only new exports can be added.

NOTE A .def file must be included in the project target to export a project. The IDE will not create one if it is missing.

Adding/Removing Build Configurations

Use the Properties for <project_name> window to manage the active or build configurations associated with a project. In the Active Configuration group you can select which build configuration is current active as well as choose which build configurations appear in the Build Configurations sub-menu as choices.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_preprocess.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_preprocess.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_preprocess.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Preprocessing Files - +

Preprocessing Files

In the Project Explorer or Symbian Project Navigator views you can preprocess source files (.c, .cpp, .cia), header files (.h), and resource files (.rss) by right-clicking the source file and then selecting the Preprocess command. Use the Preprocess preference panel to specify the preprocessor settings.

When preprocessing resource files that use more than one language, the Select Language dialog appears asking you to select the language to preprocess.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_set_build_tgt.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_set_build_tgt.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_set_build_tgt.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Setting an Active Configuration - +

Setting an Active Configuration

If you have more than one build configuration in a project, use the Manage configurations icon on the toolbar or the Build Configuration menu item to select the build target used to create executables. The active build target is indicated by a check mark.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/working_with_sis_pkg_files.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/working_with_sis_pkg_files.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/working_with_sis_pkg_files.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Working with PKG and SIS Files - +

Creating a PKG File

After creating a project for the application you are developing for a device, you will need to create a .pkg file if you are using Application TRK. A .pkg file contains all the files that will need to be downloaded to the device. Once a .pkg file is available, you can add it to a project, and the IDE will use it and additional information entered in the SIS Builder pane to create an application's .sis installation file. By default, when creating a project, the .pkg file is located in the project's sis folder.

A minimal .pkg file consists of the following lines:

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/registers/mem_reg_changing.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/registers/mem_reg_changing.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/registers/mem_reg_changing.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Changing Register Values - +

Changing Register Values

You can change register values in the Registers view during program execution in order to examine program behavior.

NOTE Changing a register value can cause unpredictable behavior in the running program.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/registers/mem_reg_data_views.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/registers/mem_reg_data_views.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/registers/mem_reg_data_views.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Changing Register Data Views - +

Changing Register Data Views

You can change the register data in the Registers view to see register contents in a different format. For example, you can change the view of a register from binary to hexadecimal format.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/registers/mem_reg_open_wnd.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/registers/mem_reg_open_wnd.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/registers/mem_reg_open_wnd.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Opening a Registers View - +

Opening a Registers View

Open the Registers view to inspect and modify various register contents.

NOTE When using an emulator, the registers shown are those of the x86 processor on the host machine, not that of the target device.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/registers/mem_reg_viewing.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/registers/mem_reg_viewing.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/registers/mem_reg_viewing.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Expanding Registers - +

Expanding Register Groups

You can expand register groups in the Registers view to inspect and modify their contents.

NOTE When using an emulator, the registers shown are those of the x86 processor on the host machine, not that of the target device.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/sdks/sdk_add.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/sdks/sdk_add.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/sdks/sdk_add.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,13 +7,13 @@ Adding SDKs - +

Adding SDKs

Use the Add New SDK window to provide the information Carbide.c++ requires to identify, locate and build a project with the specified SDK.

Figure 1. Add New SDK window

Table 1 Add New SDK window—items

- +

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/sdks/sdk_add_custkits.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/sdks/sdk_add_custkits.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/sdks/sdk_add_custkits.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Adding Symbian Custom Kits - +

Adding Symbian Custom Kits

The Carbide.c++ Developer Edition and higher level products includes functionality to work with Symbian CustKits or any arbitrary SDK source base. This enables you to work with evolving SDKs as they are released.

NOTE The features that enable build support with CustKits are only available for Carbide.c++ Developer Edition and higher level products.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/sdks/sdk_platform_filter.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/sdks/sdk_platform_filter.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/sdks/sdk_platform_filter.htm Fri Aug 06 14:28:38 2010 -0500 @@ -8,7 +8,7 @@ - +

Platform Filtering Preferences

Use the Platform Filtering Preferences tabs in the Preferences window to select which platforms are visible when creating new projects or build configurations.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/sdks/sdk_search.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/sdks/sdk_search.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/sdks/sdk_search.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Searching for SDKs - +

Searching for SDKs

Use the SDK Preferences panel to search for installed Symbian OS SDKs.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/sdks/sdk_view_properties.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/sdks/sdk_view_properties.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/sdks/sdk_view_properties.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Viewing SDK Properties - +

SDK Properties

Use the SDK Properties window to examine the properties associated with the currently selected SDK in the SDK Preferences panel. You can also use this window to map an unrecognized SDK to a known build configuration to use CustKits with a project.

NOTE The SDK Properties dialog box serves as a devices.xml editor for the OEM or Professional Developer edition of Carbide.c++.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_debugging.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_debugging.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_debugging.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Debugging a Symbian OS Program on the S60 Emulator - +

Debugging a Symbian OS Program

Use the Carbide.c++ debugger to debug a compiled Symbian OS program in an emulator or on-device. The same process works for other emulators and target devices as well.

NOTE This example uses the Symbian Emulator included with the Symbian^3 SDK. The steps are identical for on-device debugging, although a .sym file is not needed for emulator builds.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_deploying.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_deploying.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_deploying.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Deploying Programs - +

Deploying Programs to Devices

Once you have completed the program and tested it with the emulator, it’s possible to create a new build configuration for your device, build it, then create a .sis file and deploy it to a device.

To upload a valid .sis file to the target device you need software that communicates with the target device from your PC. Every Symbian phone ships with this connectivity software, which we will refer to generically as Symbian Connect. The actual name for the software is vendor dependent, so refer to your phone’s documentation for the name.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_example.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_example.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_example.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Application Emulator Debug Example using Templates - +

Application Emulator Debug Example using Templates

This example shows how to create, build, and debug a program for the emulator called HelloCarbide using Carbide project templates. Once debugged, you can create a new build compiled to run on a target device. If the Carbide.c++ edition you are using supports on-device debugging, then Carbide.c++ deploys the program to the target device automatically. The steps include:

Using a debugger to interactively control the program in the emulator

Follow the steps to successfully create the HelloCarbide program and debug it on the S60 Emulator.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_example_trk.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_example_trk.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_example_trk.htm Fri Aug 06 14:28:38 2010 -0500 @@ -8,7 +8,7 @@ - +

Run Mode Debug Example (Application TRK)

This example shows how to create and build an application and debug it on a device using the Application TRK on-device debug agent. The majority of steps are identical to the ones used to create a program and debug in an emulator, with some minor variations.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_help.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_help.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_help.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Carbide Help - +

Carbide Help

The Carbide IDE provides a wealth of help resources you can tap into to make learning and using Carbide easy. They include:

Carbide Overview

Carbide is an integrated development environment (IDE) designed to develop Symbian applications for mobile devices. Carbide is built using the open source Eclipse and C/C++ development toolkit (CDT) projects as its base with a wealth of additional tools that make it ideal for developing mobile applications. Carbide includes all the tools necessary to develop mobile applications including editors, GUI designers, project management tools, source code analysis tools, compilers, debuggers, profilers, on-device agents, revision control systems,and much more.

The basic structure of creating applications is easy to understand. You create a project, add some code, compile it into an executable file, then test it on an emulator, a simulator, or the actual device. If the application is compiled for debugging you can also control the program from within Carbide to ensure that the program behaves as expected using breakpoints, watchpoints, view variables, memory, stack traces, and other intimate details of the program as it runs.

Run Mode Overview

This example shows how to create and build an application and debug it on a device using the Application TRK on-device debug agent. Click this link to the HelloCarbide cheatsheet that provides links to detailed steps. The majority of steps are identical to the ones used to create a program and debug in an emulator, with some minor variations.

See the Run Mode Debug Example for a walkthrough of the following steps which include:

System Requirements

You use the Carbide.c++ IDE in conjunction with a recognized SDK to develop Symbian OS software.

In practice, whether you use an SDK, a developer kit (DevKit), or both depends on the edition of diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_updating.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_updating.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_updating.htm Fri Aug 06 14:28:38 2010 -0500 @@ -12,7 +12,7 @@ --> - +

Updating Carbide.c++

Updates to Carbide.c++ current features are available using the Install New Software feature. This feature now makes use of the P2 provisioning system released in Eclipse 3.4 which provides a more robust updating mechanism for currently installed features as well as the adding of new ones to the Carbide environment.

Carbide is a collection of difference software projects combined into a working environment for Symbian OS C/C++ development. At its base Carbide uses Eclipse and CDT projects from Eclipse.org. We then modify some of these base plug-ins to work with our Carbide plug-ins. This is important to know as any updates to those modified base plug-ins may cause Carbide not to work as intended.

Launch Configuration Setup

To communicate between the Carbide.c++ debugger and the on-device debug agent, using either Application TRK or System TRK, you must define a debug launch configuration that matches the installed debug agent. The two configurations available include:

Bluetooth Connectivity Setup

Bluetooth Connection Setup

The on-device debug agent software supports the use of Bluetooth to debug programs running on a target device. To enable communication with a Bluetooth device, a connection must be established between the PC and the device. The on-device debug agent requires a dedicated COM port in order to talk with the device. In some cases, other programs that use the same COM port number will interfere with the TRK debug agent, essentially "fighting" over control of the COM port. Follow the steps below to setup a Bluetooth connection with the Bluetooth enabled device.

NOTE Ensure that no other program has commandeered the Bluetooth connection. For example, some phone connectivity programs will not release a COM port unless specifically told to do so.

USB Connectivity Setup

USB Connection Setup

On-device debugging supports the use of USB to debug programs running on a target device. To enable communication with a USB device, a connection must be established between the PC and the device. Doing that requires one of the following USB connectivity cables to physically connect the PC to the device:

Installing On-device Debug Agents using Bluetooth

Use Bluetooth to install the on-device debug agent, either Application TRK or System TRK, as a SISX file, to enable on-target debugging. The installation location of the on-device debug agent will vary based on the phone. Application TRK is usable on both consumer and RnD versions of the device. System TRK is only usable on RnD devices.

On some phones it will be the Installed folder, on others it may be in My Own folder. Refer to the documentation that came with the phone to learn where installed programs are stored.

Installing On-device Debug Agents using USB

Installing On-device Debug Agents using PC Suite

Use the PC Suite software that came with your device (Nokia PC Suite is one example) to install the on-device debug agent, either Application TRK or System TRK, as a SISX file, to enable on-device debugging. Application TRK is usable on both consumer and RnD versions of the device. System TRK is only usable on RnD devices.

The installation location of the on-device debug agent software varies based on the phone. On some phones it will be the Installed folder, on others it may be in My Own folder. Refer to the documentation that came with the phone to learn where installed programs are stored.

Installing On-device Debug Agents using USB

An USB connection can be used to install the on-device debug agent, either Application TRK or System TRK, (SISX file), to enable on-target debugging. The installation location of the on-device debug agent will vary based on the phone. On some phones it will be the Installed folder, on others it may be in My Own folder. Refer to the documentation that came with the phone to learn where installed programs are stored.

NOTE You can use the connection software that came with your device to install the on-device debug agent SISX file. For example, all Nokia phones ship with the PC Suite software for installing programs. See your phone's operating manual for assistance on using it's software.

Installing an On-device Debug Agent

To use any version of the on-device debug agent on a target device it must be installed. We highly recommend using the On-Device Connections dialog to help connect and verify that the latest version of TRK (3.2.6+) is installed on the device, especially to support plug-and-play (PnP) connections.

Refer to the Bluetooth Connection Setup page for more information on using Bluetooth or the USB Connection Setup page if using USB.

TRK Overview

This section describes how to setup and use the on-device debug agent software to debug programs on S60 v3.x and UIQ 3rd edition devices. Topics include:

ODD Preconditions

Preconditions to On-Device Debugging

Before you can use on-device debugging to debug 3rd and 5th edition devices, the following preconditions must be met.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_start_sisx.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_start_sisx.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_start_sisx.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Bluetooth Connectivity Setup - +

Starting the On-Device TRK Debug Agent

The location of the TRK on-device debug agent will vary based on the phone. On some phones it will be the Installed folder, on others it may be in My Own folder. Refer to the documentation that came with the phone to learn where installed programs are stored.

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_start_sisx_usb.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_start_sisx_usb.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_start_sisx_usb.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ Bluetooth Connectivity Setup - +

Starting the On-Device Debug Agent Using USB

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_troubleshooting.htm --- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_troubleshooting.htm Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_troubleshooting.htm Fri Aug 06 14:28:38 2010 -0500 @@ -7,7 +7,7 @@ On-device Debugging Troubleshooting - +

On-device Debugging Troubleshooting

If you are having problems with on-device debugging, see if the following solutions can solve the problem.

Deploying SIS Files using Carbide (Application TRK)

diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/index.xml --- a/core/com.nokia.carbide.cpp.doc.user/index.xml Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/index.xml Fri Aug 06 14:28:38 2010 -0500 @@ -583,7 +583,7 @@ - + diff -r 245ab754d54b -r 727385d8e2b3 core/com.nokia.carbide.cpp.doc.user/tocCarbide.xml --- a/core/com.nokia.carbide.cpp.doc.user/tocCarbide.xml Fri Aug 06 14:05:52 2010 -0500 +++ b/core/com.nokia.carbide.cpp.doc.user/tocCarbide.xml Fri Aug 06 14:28:38 2010 -0500 @@ -120,7 +120,7 @@ - + @@ -354,6 +354,12 @@ + + + + + + + -

Item	Explanation