# HG changeset patch
# User timkelly
# Date 1281545550 18000
# Node ID 1d57e533b09e5a954cb166271dd6930e30e9aaa2
# Parent c13983cc56300b8e360df78970d5527c146f17ca# Parent 1c8169798acdf0d5906f526222da336ba5698dba
merge from default
diff -r c13983cc5630 -r 1d57e533b09e connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/interfaces/AbstractConnectedService2.java
--- a/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/interfaces/AbstractConnectedService2.java Wed Aug 11 11:18:20 2010 -0500
+++ b/connectivity/com.nokia.carbide.remoteConnections/src/com/nokia/carbide/remoteconnections/interfaces/AbstractConnectedService2.java Wed Aug 11 11:52:30 2010 -0500
@@ -225,4 +225,9 @@
public void setDeviceOS(String familyName, Version version) {
// @deprecated
}
+
+
+ public void setDeviceOS(String familyName, String version) {
+ // empty implementation
+ }
}
\ No newline at end of file
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.compiler.doc.user/html/images/mwccsym2_version.png
Binary file core/com.nokia.carbide.cpp.compiler.doc.user/html/images/mwccsym2_version.png has changed
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.compiler.doc.user/html/introduction/new_features.htm
--- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/introduction/new_features.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/introduction/new_features.htm Wed Aug 11 11:52:30 2010 -0500
@@ -15,6 +15,11 @@
New Features & Bug Fixes
A list of bug fixes for the compiler and linker can be found in the Symbian_x86_BuildTools_Notes.txt file located in the <Carbide_Install_Dir>\x86Build\Release_Notes directory. The latest build information is always available on the Symbian Foundation Wiki under WINSCW (build version information).
This reference has new and updated topics:
+
3.2.5 Build 490
+
+
Fixed an ordering issue when spilling byte instructions and only the EBX and EDI registers are available.
+
+
3.2.5 Build 489
Corrected an issue that prevented compiling of files with different case handling across different OS systems.
To determine what version of the Carbide.c++ compiler you are using, follow the steps below.
NOTE The Carbide.c++ compiler is stored in <Carbide_Install_Dir>\x86Build\Symbian_Tools\Command_Line_Tools.
-
+
Figure 1. Getting compiler version using Command Prompt.
From the Carbide IDE
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/META-INF/MANIFEST.MF
--- a/core/com.nokia.carbide.cpp.doc.user/META-INF/MANIFEST.MF Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/META-INF/MANIFEST.MF Wed Aug 11 11:52:30 2010 -0500
@@ -5,4 +5,5 @@
Bundle-Version: 1.4.0.qualifier
Bundle-Vendor: Nokia
Bundle-Localization: plugin
-Require-Bundle: org.eclipse.help
+Require-Bundle: org.eclipse.help,
+ org.eclipse.ui.cheatsheets
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/book.css
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/bugs_fixed.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/bugs_fixed.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/bugs_fixed.htm Wed Aug 11 11:52:30 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:
@@ -21,9 +21,12 @@
Bugs Fixed in v3.0.0
+
10755 - The News Reader has transformed into the Carbide Portal which no longer causes any slowdowns until its accessed.
+
10833 - Fixed an ordering issue when spilling byte instructions and only the EBX and EDI registers are available.
+
11239 - Fixed an issue that caused variables to display incorrectly during a debug session.
11563 - The Build Project dialog now also shows the project name.
-
v2.7.0
+
v2.7.0
11222 - You can now disable device discovery in the Remote Connection view to avoid conflicts between different connection protocols within Carbide.
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/cheatsheets/getStarted_cs.xml
--- a/core/com.nokia.carbide.cpp.doc.user/html/cheatsheets/getStarted_cs.xml Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/cheatsheets/getStarted_cs.xml Wed Aug 11 11:52:30 2010 -0500
@@ -1,9 +1,7 @@
-
+
-
- Follow these steps to create a Symbian OS project and debug it using the S60 EPOC Emulator.
-
+ Follow these steps to create and debug a Symbian project and using an emulator. using the S60 EPOC Emulator.
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/cheatsheets/how_to_customize_cmd_group.xml
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/com.nokia.carbide.cpp.doc.user/html/cheatsheets/how_to_customize_cmd_group.xml Wed Aug 11 11:52:30 2010 -0500
@@ -0,0 +1,17 @@
+
+
+
+`
+ Intro text
+
+
+
+ one
+
+
+
+
+
+
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/cheatsheets/how_to_customize_code_styles.xml
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/com.nokia.carbide.cpp.doc.user/html/cheatsheets/how_to_customize_code_styles.xml Wed Aug 11 11:52:30 2010 -0500
@@ -0,0 +1,16 @@
+
+
+
+`
+ Intro text
+
+
+
+ one
+
+
+
+
+
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/cheatsheets/how_to_customize_editors.xml
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/com.nokia.carbide.cpp.doc.user/html/cheatsheets/how_to_customize_editors.xml Wed Aug 11 11:52:30 2010 -0500
@@ -0,0 +1,16 @@
+
+
+
+`
+ Intro text
+
+
+
+ one
+
+
+
+
+
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/cheatsheets/how_to_customize_export_settings.xml
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/com.nokia.carbide.cpp.doc.user/html/cheatsheets/how_to_customize_export_settings.xml Wed Aug 11 11:52:30 2010 -0500
@@ -0,0 +1,17 @@
+
+
+
+`
+ Intro text
+
+
+
+ one
+
+
+
+
+
+
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/cheatsheets/how_to_customize_key_commands.xml
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/com.nokia.carbide.cpp.doc.user/html/cheatsheets/how_to_customize_key_commands.xml Wed Aug 11 11:52:30 2010 -0500
@@ -0,0 +1,16 @@
+
+
+
+`
+ Intro text
+
+
+
+ one
+
+
+
+
+
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/concepts/arm_registers.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/concepts/arm_registers.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/concepts/arm_registers.htm Wed Aug 11 11:52:30 2010 -0500
@@ -1,39 +1,39 @@
-
-
-
-
-
-
-ARM Registers
-
-
-
-
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.
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.
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.
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.
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:
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.
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.
+
NOTE Check the SDK Preferences page to see if an SDK you have installed and whether its build configurations are supported.
Table 1. Supported target types for all versions of Carbide.c++
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.
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.
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:
+
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:
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:
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 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.
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/concepts/debugger_about.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/concepts/debugger_about.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/concepts/debugger_about.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
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:
Symbian SDKs include an emulator that runs Symbian OS on a
- Microsoft Windows host computer. The emulator provides the full range of Symbian OS
- functionality, letting you do most development tasks on a single desktop computer. The
- emulator and the software you build for it with the Carbide.c++ software run natively on the Intel x86 family of processors.
-
In many cases, you can build and debug a complete application using the emulator, then test the application on the actual device. There are cases however, where you cannot use
- the emulator, such as when developing device drivers that access hardware on a device.
-
For more information about the emulator, please see the documentation that came with
- your SDK under: Developer Library > Tools and Utilities > Emulator.
-
You will find an emulator to use with Carbide.c++ in:
where Symbian is the path containing the subdirectories and version number of the Symbian OS SDK.
-
NOTE The first time you launch an emulator it may take some time to appear. Remember that it is implementing the operating system on the target device and that some setup time is required.
Symbian SDKs include an emulator that runs Symbian OS on a
+ Microsoft Windows host computer. The emulator provides the full range of Symbian OS
+ functionality, letting you do most development tasks on a single desktop computer. The
+ emulator and the software you build for it with the Carbide.c++ software run natively on the Intel x86 family of processors.
+
In many cases, you can build and debug a complete application using the emulator, then test the application on the actual device. There are cases however, where you cannot use
+ the emulator, such as when developing device drivers that access hardware on a device.
+
For more information about the emulator, please see the documentation that came with
+ your SDK under: Developer Library > Tools and Utilities > Emulator.
+
You will find an emulator to use with Carbide.c++ in:
where Symbian is the path containing the subdirectories and version number of the Symbian OS SDK.
+
NOTE The first time you launch an emulator it may take some time to appear. Remember that it is implementing the operating system on the target device and that some setup time is required.
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
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/concepts/general_registers.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/concepts/general_registers.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/concepts/general_registers.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
General Registers
-
+
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.
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.
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.
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.
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.
+
\ No newline at end of file
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/concepts/ngage_projects.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/concepts/ngage_projects.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/concepts/ngage_projects.htm Wed Aug 11 11:52:30 2010 -0500
@@ -6,9 +6,9 @@
N-Gage Projects
-
+
-
+
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.
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 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.
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.
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:
+
+
modularity and code re-use
+
separation of interface and implementation
+
extensibility
+
testability
+
+
In addition, SBSv2:
+
+
is supported on the Windows and Linux operating systems
+
is more scalable than previous systems
+
supports incremental and parallel builds
+
offers more flexibility in build configurations
+
offers an overall 20% speed improvement
+
+
SBSv2 also supports the use of build variants. A variant is basically something which modifies a build. For example, a variant could be the standard ARMv5 build with Demand Paging functions enabled. Already defined variants are found in the Build > SBSv2 preference panel.
+
NOTE Carbide no longer supports the ABLD system. Use Carbide.c++ v2.7 instead if you require SBSv1 support.
+
Preferences for configuring SBSv2 is found by clicking Window > Preferences > Carbide.c++:
+
+
Build > SBSv2 – control general build options like clean, test components, dependency tracking, concurrent build jobs, build behavior, and emulator options
+
Build Configuration Filtering – controls which platforms are visible when creating new projects or build configurations.
+
Symbian SDKs – control which installed SDKs are available to projects during project creation or importing.
+
+
Every project also has a set of SBSv2 properties to customize:
+
+
+
+
\ No newline at end of file
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/concepts/symbol_hints.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/concepts/symbol_hints.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/concepts/symbol_hints.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Symbol Hint
-
+
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.
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.
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.
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.
The on-device debug 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:
+
+
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:
Debug agent running on Symbian OS
Provides a stable & integrated interface to Symbian OS
Used to debug applications on actual devices
Can be built-in to the OS image or installed as a .sis file
-
Using the on-device debug agent, one can use the Carbide.c++ IDE to debug programs running on phone hardware, making the debugging process much easier. The on-device debug agent works on all S60 3rd Edition devices, UIQ 3rd Edition devices, and Symbian TechView devkits.
Using the on-device remote agent, one can use the Carbide.c++ IDE to debug programs running on phone hardware, making the debugging process much easier. The on-device debug agent works on all Nokia Qt SDK, Symbian^3, and Symbian TechView devkits.
Some of the key benefits to using an on-device debug agent include:
Easy debugging via serial interface (Bluetooth, USB, IrDA, etc)
@@ -30,7 +30,6 @@
System TRK—
supports both application and limited ROM debugging (includes application executables and limited ROM based components (i.e. no device drivers) and available to original equipment manufacturers (OEM) for device creation and customization
-
NOTE The type of on-device debug agent you have is based upon which Carbide.c++ product you have licensed. System TRK is only available with the Professional or OEM version of the product.
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.
+
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.
The following topics cover various breakpoint concepts and actions:
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
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/concepts/working_with_data.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/concepts/working_with_data.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/concepts/working_with_data.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Working with Debugger Data
-
+
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
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:
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/concepts/working_with_memory.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/concepts/working_with_memory.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/concepts/working_with_memory.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Working with Memory
-
+
Working with Memory
This section explains how to work with memory in a debugging session. Topics include:
This section explains how to work with variables in a Carbide™ IDE debugging session. The following windows show various types of information about variables.
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.
+
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.
Figure 1. Workspace Launcher dialog
WARNING Bld.inf imported projects are not copied, so do not delete the contents when deleting the project.
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/context_help/carbide_ide_dialogs_help.xml
--- a/core/com.nokia.carbide.cpp.doc.user/html/context_help/carbide_ide_dialogs_help.xml Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/context_help/carbide_ide_dialogs_help.xml Wed Aug 11 11:52:30 2010 -0500
@@ -377,8 +377,8 @@
- Use the SDK Preferences page to Add or remove SDKs, or edit SDK properties
-
+ Use the Symbian SDKs page to Add or remove SDKs, or edit SDK properties
+
@@ -390,13 +390,14 @@
Use the SDK Add dialog to Add SDKs to current project
+ Use the SDK Properties window to examine the properties associated with the currently selected SDK in the SDK Preferences panel.
-
+
@@ -404,7 +405,7 @@
Use the SDK Platform Filter window to show only platforms related to selected SDK.
-
+
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/context_help/eclipse_dialogs_help.xml
--- a/core/com.nokia.carbide.cpp.doc.user/html/context_help/eclipse_dialogs_help.xml Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/context_help/eclipse_dialogs_help.xml Wed Aug 11 11:52:30 2010 -0500
@@ -122,12 +122,6 @@
-
- Specify Trace32 configuration information.
-
-
-
-
Specify TRK connection information.
@@ -333,6 +327,17 @@
+
+
+
+
+
+
+
+
+
+
+
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/debugger/breakpoints/breakpoints.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/debugger/breakpoints/breakpoints.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/debugger/breakpoints/breakpoints.htm Wed Aug 11 11:52:30 2010 -0500
@@ -1,34 +1,34 @@
-
-
-
-
-
-
-Breakpoints Overview
-
-
-
-
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:
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:
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.
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.
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.
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:
-
Actions - define one or more specific breakpoint actions like playing a sound or showing an alert message to this breakpoint
+
Actions - define one or more specific breakpoint actions like playing a sound or showing an alert message to this breakpoint
Common - shows common information including the class, breakpoint type, file location, and other attributes associated with the breakpoint.
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.
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.
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.
+
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.
Enabling and Disabling breakpoints
Once a source line is selected in an editor or Disassembly view, the methods of toggling breakpoints to be enabled of disabled include:
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:
Once you've suspended a program debug session, the Disassembly view provides commands for move or reposition the program counter (PC). These command include:
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/debugger/debug/cmds_resuming.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/debugger/debug/cmds_resuming.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/debugger/debug/cmds_resuming.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Suspending and Resuming a Debug Session
-
+
Suspending and Resuming a Debug Session
Once you've started a debug session, the Debugview provides controls to both suspend and resume program execution under debugger control. The following items describe the commands for:
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/debugger/debug/cmds_starting.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/debugger/debug/cmds_starting.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/debugger/debug/cmds_starting.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Starting and Terminating a Debug Session
-
+
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:
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/debugger/debug/cmds_stepping.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/debugger/debug/cmds_stepping.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/debugger/debug/cmds_stepping.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Stepping Over, Into, and Out of Routines
-
+
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:
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:
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:
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.
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:
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.
+
+
+
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/debugger/variables/adding_variables.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/debugger/variables/adding_variables.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/debugger/variables/adding_variables.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Adding and Removing Global Variables
-
+
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.
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:
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:
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:
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:
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:
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 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.
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
@@ -37,8 +37,8 @@
Check the appropriate access type to trigger the watchpoint for the specified memory location. This setting is shown as a unique icon in the Breakpoints view next to the listed watchpoint. The following list shows the resolved version of the icons used to indicate the type of watchpoint set:
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:
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.
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:
+
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:
An enabled watchpoint has a non-gray icon () indicating that program execution halts when encountered.
A disabled watchpoint displays a gray icon () indicating that program execution will not stop when encountered.
@@ -40,8 +40,8 @@
In addition, you can use these types of watchpoints:
conditional watchpoints—halt program execution after meeting a condition that you specify (same as for breakpoints)
A watchpoint is equivalent to a memory breakpoint.
Unlike a breakpoint, a watchpoint can detect when any part of your program affects memory. For example, if a write or write/read watchpoint is set, when the program writes a new value to the address or area of memory that has the watchpoint, the debugger suspends program execution.
@@ -95,21 +95,21 @@
A project can have a different maximum number of watchpoints, depending on the build target. The IDE generally limits the acceptable range for watchpoints to memory that it can write-protect. This range also depends on the host and on the application.
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:
Symbian OS System TRK — used to run or debug applications or ROM code on a target device using the System TRK on-device debug agent. System TRK is an application that runs on reference boards and prototype phones and allows you to debug your executables. The debugger will download files to the phone prior to launching.
-
Symbian OS Trace32 — is an external debugger that the Carbide debugger communicates with, to debug any Symbian OS module on a target using a JTAG connection.
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.
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.
The Symbian OS Emulation launch configurations the Debugger page to specify entry point breaks and which logs to output to the Console view.
@@ -88,7 +88,7 @@
Stop-mode Debugger page
-
In stop-mode launch configurations like System TRK, Trace32,and Attach to Process, use the Startup Options to attach to a target and debug or run from the specified start address. Then use Target Options to specify the target's processor type, and set which initialization and memory configuration files to use in the debug session.
+
In stop-mode launch configurations like System TRK,and Attach to Process, use the Startup Options to attach to a target and debug or run from the specified start address. Then use Target Options to specify the target's processor type, and set which initialization and memory configuration files to use in the debug session.
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.
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.
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.
The Symbian OS Emulation launch configuration uses the Main page to define the process to be launched by the emulator.
@@ -88,9 +88,9 @@
Stop-mode Main page
-
The Symbian OS System TRK and Trace32 launch configurations uses the Main page to defines the project and the executable to launch on the target device.
+
The Symbian OS System TRK launch configurations uses the Main page to defines the project and the executable to launch on the target device.
Select the Symbian OS System TRK launch configuration provides C/C++ stop-mode debug options that use a JTAG interface when a Symbian OS Trace32 launch configuration is created. The settings included in these launch configuration are a combination of Carbide, CDT, and Eclipse options.
+
Select the Symbian OS System TRK launch configuration provides C/C++ stop-mode debug options that use a JTAG interface when a Symbian OS launch configuration is created. The settings included in these launch configuration are a combination of Carbide, CDT, and Eclipse options.
If the New Launch Configuration Wizard was used to create the System TRK launch configuration no changes are usually needed. To modify the launch configuration settings, select the Run > Debug As menu option to open the Debug dialog. Select the System TRK configuration and click a tab to set specific options. Click Apply to save any option modifications. Click Debug to launch a debugging session using the new settings.
Figure 1. System TRK launch configuration in the Debug dialog
Select the Symbian OS Trace32 launch configuration to debug any Symbian OS module on a target using a JTAG connection. The external Trace32 debugger communicates with the Carbide debugger and enables stop mode debugging of the target device.
-
If the New Launch Configuration Wizard was used to create a Trace32 launch configuration no changes are usually needed. To modify the launch configuration settings, select the Run > Debug As menu option to open the Debug dialog. Select the Trace32 configuration and click a tab to set specific options. Click Apply to save any option modifications. Click Debug to launch a debugging session using the new settings.
-
-
Figure 1. Trace32 launch configuration in the Debug dialog
-
The Trace32 launch configuration panes include:
-
-
The Main tab defines the project to be launched. Enter the name of the project in the Project field, and the executable name in the Executable field.
The Debugger tab defines debug configurations, such as entry point to begin debugging and target options.
-
The ROM Image tab allows you to define startup options and ROM image download information.
-
The Executables tab allows you to specify which executables that you want to debug that are part of the project.
-
The Source tab (standard CDT page) defines the location of source files used to display source when debugging an application. By default, these settings are derived from the associated project's build path. You may override these settings here.
-
The Common tab (standard CDT page) defines general information about the launch configuration. You may choose to store the launch configuration in a specific file.
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.
If you checkmark Advanced settings, the Debug dialog appears instead of launching the project. This enables you to make additional changes to the new launch configuration before starting the debug session. By design and intent, this should seldom be required for the initial launch.
Figure 8 - New Launch Configuration page
-
Trace32 Initialization Settings
-
Use the Trace32 Initialization Settings page to specify the initialization script and target processor of the target device.Enter the Trace32 Initialization Script and choose the Target Processor, then click Next.
-
This page only appears when creating a Trace32 launch configuration.
-
-
Figure 9 - Trace32 Initialization Settings page
-
Symbian ROM Image Settings
-
Use the Symbian ROM Image Settings page to specify the method of debugging, the start address, and the ROM Image and Log File locations.
-
This page appears when creating a Trace32 launch configuration.
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.
+
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.
The tabs in the window vary depending upon the currently selected launch configuration.
-
+
Figure 1 - Debug or launch configuration window (Symbian OS emulation view)
Table 1. Debug Configuration window — common items
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:
@@ -15,7 +15,7 @@
Building an executable based on the project sources
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.
+
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.
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:
@@ -15,7 +15,7 @@
Building the DLL object code based on the project sources
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.
+
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.
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 c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/projects/tutorials/new_proj_dll_example_02.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Building the DLL Project Tutorial
-
+
Building the DLL Project 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:
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:
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:
@@ -16,7 +16,7 @@
Defining a launch configuration for running or debugging the application
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.
+
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.
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/projects/tutorials/new_proj_from_template_01.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/projects/tutorials/new_proj_from_template_01.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/projects/tutorials/new_proj_from_template_01.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Creating New Projects from Templates
-
+
Creating New Projects from Templates
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:
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:
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/projects/tutorials/new_proj_from_template_04.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/projects/tutorials/new_proj_from_template_04.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/projects/tutorials/new_proj_from_template_04.htm Wed Aug 11 11:52:30 2010 -0500
@@ -6,7 +6,7 @@
Launching and debugging an executable
-
+
Launching and debugging an executable
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:
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:
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/projects/tutorials/run_mode_debug_example_01.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/projects/tutorials/run_mode_debug_example_01.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/projects/tutorials/run_mode_debug_example_01.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Connect target device to PC Tutorial
-
+
Connect target device to PC
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:
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:
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:
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:
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.
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 is not recognized, you may still be able to it to the Discovered Symbian OS SDK list.
+
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 is not recognized, you may still be able to it to the Discovered Symbian OS SDK list.
Launch the New Qt Project Wizard
Select the File > New > New Qt Project menu item to open the New Qt Symbian OS C++ Project dialog.
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.
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 is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list.
+
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 is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list.
Select type of Qt project
Use the Select a type of project page in the New Qt Project Wizard to choose a Qt project template that will be used to generate the new project, then click Next. Note that the templates shown are filtered to
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.
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 is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list.
+
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 is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list.
Enter project name and location
Use the New Qt Symbian OS C++ Project page in the Qt Project Wizard to define the projects name and where it should be saved, then click Next. In Qt projects, the name of the project folder must match the project name.
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.
NOTE If everything is built correctly, the QtCore.lib should be in your SDK's <platform> <target> UDEB directory. If this library is missing, then the SDK will not show up as a supported SDK-target in the build configurations.
-
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 is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list.
+
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 is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list.
Select SDKs for build targets
Use the Build Targets page of the Qt Project Wizard to select one or more Qt SDKs to include in the project, then click Next.
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.
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 is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list.
+
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 is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list.
Select Qt modules to include in project
Use the Qt Modules page to select one or more Qt modules to include with the project, then click Next.
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.
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 is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list.
+
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 is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list.
Set application UID
Use the Basic Settings page of the Qt Project Wizard to define an Application UID to the executable. Click Random to generate a unique UID for program testing purposes. Click Finish when ready to create the project.
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.
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.
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.
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:
@@ -18,7 +18,7 @@
Choose build targets
NOTE If everything is built correctly, the QtCore.lib should be in your SDK's <platform> <target> UDEB directory. If this library is missing, then the SDK will not show up as a supported SDK-target in the build configurations.
-
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 is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list.
+
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 is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list.
Select .pro file to import
Use the Build Targets page in the File Import Wizard to select which SDKs and build configurations to associate with the project, then click Finish. The .pro file is imported and a new project created in the Project Explorer view.
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:
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.
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:
- The INF Editor allows you to view and modify Symbian project files and export files to be included in building your application. The settings displayed are those active for the active build configuration. However, changes made in the INF editor can be applied globally to all build configurations. Changes made in the INF editor are automatically written to the project's .INF file. You can view the .inf file by selecting the bld.inf tab located along the bottom of the INF editor.
+ The INF Editor allows you to view and modify Symbian project files and export files to be included in building your application. The settings displayed are those active for the active build configuration. However, changes made in the INF editor can be applied globally to all build configurations. Changes made in the INF editor are automatically written to the project's .INF file. You can view the .INF file by selecting the bld.inf tab located along the bottom of the INF editor.
The INF Editor is shown when an INF file is
opened from the Project Explorer view or Symbian Project Navigator view by double-clicking on the file. The INF Editor is shown in Figure 1.
-
+
Figure 1 - INF Editor
Add components such as MMP and make files to be part of the normal build process.
-
Create New MMP File - creates a new MMP file at the bottom of the Component list.
-
Add Existing MMP File - imports a MMP file at the bottom of the Component list.
-
Add Existing Makefile - adds a make file to the bottom of the Component list.
-
Edit - Select a component and click Edit to apply the Tidy attribute or specify the Build as ARM option.
-
Open - Select a component and click Open to open the component in an editor window.
-
Up - Select a component and click Up to move the component up in the list.
-
Down - Select a component and click Down to move the component down in the list.
-
Remove - Select a component and click Remove to remove the component from the build process.
+
Create New MMP File - creates a new MMP file at the bottom of the Component list.
Edit - Select a component and click Edit to apply the Tidy attribute or specify the Build as ARM option.
+
Open - Select a component and click Open to open the component in an editor window.
+
Up - Select a component and click Up to move the component up in the list.
+
Down - Select a component and click Down to move the component down in the list.
+
Remove - Select a component and click Remove to remove the component from the build process.
Test Components
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/reference/INF_Editor_addedit_make.html
--- a/core/com.nokia.carbide.cpp.doc.user/html/reference/INF_Editor_addedit_make.html Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/reference/INF_Editor_addedit_make.html Wed Aug 11 11:52:30 2010 -0500
@@ -1,47 +1,47 @@
-
-
-INF Editor - Create/Edit Make
-
-
-
-
INF Editor - Create / Edit Makefile Entry
-
-
The Add Makefile entry dialog (figure 1) is used to add a makefile to the build process. Enter or browse to the make file in the File path field and, if desired, apply the Tidy attribute or specify the Build as ARM option to the make file.
-
-
Figure 1 - Add/Edit makefile entry
-
Table 1. Add/Edit Makefile entry — items
-
-
-
Name
-
Function
-
-
-
File path
-
Type the path and filename for the makefile to create or click Browse to set a path.
-
-
-
Tidy
-
Specify the tidy attribute if the release that an .mmp file defines is internal to your component and not required by other components or for your component to execute.
-
-
-
Build as ARM
-
Specifies the build_as_arm statement, which instructs an ARMV5 build to build the project for the ARM instruction set and not the THUMB instruction set.
The Add Makefile entry dialog (figure 1) is used to add a makefile to the build process. Enter or browse to the make file in the File path field and, if desired, apply the Tidy attribute or specify the Build as ARM option to the make file.
+
+
Figure 1 - Add/Edit makefile entry
+
Table 1. Add/Edit Makefile entry — items
+
+
+
Name
+
Function
+
+
+
File path
+
Type the path and filename for the makefile to create or click Browse to set a path.
+
+
+
Tidy
+
Specify the tidy attribute if the release that an .mmp file defines is internal to your component and not required by other components or for your component to execute.
+
+
+
Build as ARM
+
Specifies the build_as_arm statement, which instructs an ARMV5 or later build to build the project for the ARM instruction set and not the THUMB instruction set.
+
+
+
+
+
+
\ No newline at end of file
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/reference/INF_Editor_addedit_mmp.html
--- a/core/com.nokia.carbide.cpp.doc.user/html/reference/INF_Editor_addedit_mmp.html Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/reference/INF_Editor_addedit_mmp.html Wed Aug 11 11:52:30 2010 -0500
@@ -1,43 +1,47 @@
-
-
-INF Editor - Add/Edit MMP
-
-
-
-
INF Editor - Add / Edit MMP File Entry
-
- The Add MMP file entry dialog (figure 1) is used to add a mmp file and, if desired, apply the Tidy attribute or specify the Build as ARM option to the mmp file.
-
-
Figure 1 - Add MMP File Entry
-
Table 1. Add MMP file entry — items
-
-
-
Name
-
Function
-
-
-
File path
-
Type the path and filename for the MMP file to create or click Browse to set a path.
-
-
-
Tidy
-
Specify the tidy attribute if the release that an .mmp file defines is internal to your component and not required by other components or for your component to execute.
-
-
-
Build as ARM
-
Specifies the build_as_arm statement, which instructs an ARMV5 build to build the project for the ARM instruction set and not the THUMB instruction set.
+
+ The Add MMP File Entry dialog (figure 1) is used to add a mmp file and apply the Tidy, Manual, and Support attributes.
+
+
Figure 1 - Add MMP File Entry
+
Table 1. Add MMP file entry — items
+
+
+
Name
+
Function
+
+
+
File path
+
Type the path and filename for the MMP file to create or click Browse to set a path.
+
+
+
Tidy
+
Specify the tidy attribute if the release that an .mmp file defines is internal to your component and not required by other components or for your component to execute.
+
+
+
Manual
+
Checkmark to indicate a test that requires manual interaction to complete.
+
+
+
Support
+
Checkmark to not include the test in a batch file.
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.
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.
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.
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.
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 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
@@ -101,8 +101,8 @@
Clean level
Select the level of clean when cleaning a project.
-
abld clean erases all files created by a corresponding abld target command (all intermediate files created during compilation and all executables and import libraries created by the linker)
-
abld reallyclean does what abld clean does, and also removes files exported by abld export and makefiles generated by abld makefile, or the abld test equivalents
+
sbs clean erases all files created by a corresponding sbs target command (all intermediate files created during compilation and all executables and import libraries created by the linker)
+
sbs reallyclean does what sbs clean does, and also removes files exported by sbs export and makefiles generated by sbs makefile, or the sbs test equivalents
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.
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.
+Use the
+SDK Preferences page in the Preferences window to control which installed SDKs are available to projects during an import. To
+ access SDK preferences preference panel, select Window > Preferences > Carbide.c++ > SDK Preferences.
+
NOTE There must be at least one recognized SDK installed before you can create a project. If the SDK you have installed is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list. See Carbide.c++ Requirements for a list of supported SDKs.
+
NOTE This panel serves as a devices.xml file editor. The devices.xml file stores information about the installed SDKs used for Symbian OS development.
+
+
+
+
Figure 1. SDK Preferences preference panel
+
+
+
Name
Function
+
+
Available Symbian OS SDK's
+
Lists all the installed and recognized SDKs supported by the IDE. Only SDKs supported by the IDE are included in the list.
+
Checked SDKs indicate build configurations available for creating projects. Unchecked SDKs are not displayed when creating new projects.
+
SDKs shown in red indicate a problem, usually no EPOCROOT or missing build configurations.
+
Click on a SDK name to see its EPOCROOT location and build configuration status in the SDK Information area.
+
+
+
Remove SDK
+
Click to remove the selected SDK from the Available Symbian OS SDK's list.
+
+
+
Add New SDK
+
Click to add an SDK to the Available Symbian OS SDKs list.
+
+
+
SDK Properties
+
Click to view and edit the properties of the currently selected SDK in the Available Symbian OS SDKs list.
+
+
+
Listen for devices.xml changes outside of Carbide
+
Enable of have Carbide issue an alert prompting you to rescan your SDKs when changes to the devices.xml file are made outside of Carbide. When disabled the devices.xml file is not scanned for changes.
+
+
+
Rescan All SDKs
+
Click to rescan the drive for newly installed SDKs. The devices.xml file is scanned for SDKs and the list of available SDKs is updated if the devices.xml file has changed.
+
NOTE Carbide.c++ scans for available SDKs each time it is started.
+
+
+
+
+
\ No newline at end of file
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/reference/pref_carb_sdk_preferencea.html
--- a/core/com.nokia.carbide.cpp.doc.user/html/reference/pref_carb_sdk_preferencea.html Wed Aug 11 11:18:20 2010 -0500
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,73 +0,0 @@
-
-
-SDK Preferences
-
-
-
-
-
-
-
SDK Preferences
-
-Use the
-SDK Preferences page in the Preferences window to control which installed SDKs are available to projects during an import. To
- access SDK preferences preference panel, select Window > Preferences > Carbide.c++ > SDK Preferences.
-
NOTE There must be at least one recognized SDK installed before you can create a project. If the SDK you have installed is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list. See Carbide.c++ Requirements for a list of supported SDKs.
-
NOTE This panel serves as a devices.xml file editor. The devices.xml file stores information about the installed SDKs used for Symbian OS development.
-
-
-
-
Figure 1. SDK Preferences preference panel
-
-
-
Name
Function
-
-
Available Symbian OS SDK's
-
Lists all the installed and recognized SDKs supported by the IDE. Only SDKs supported by the IDE are included in the list.
-
Checked SDKs indicate build configurations available for creating projects. Unchecked SDKs are not displayed when creating new projects.
-
SDKs shown in red indicate a problem, usually no EPOCROOT or missing build configurations.
-
Click on a SDK name to see its EPOCROOT location and build configuration status in the SDK Information area.
-
-
-
Remove SDK
-
Click to remove the selected SDK from the Available Symbian OS SDK's list.
-
-
-
Add New SDK
-
Click to add an SDK to the Available Symbian OS SDKs list.
-
-
-
SDK Properties
-
Click to view and edit the properties of the currently selected SDK in the Available Symbian OS SDKs list.
-
-
-
Listen for devices.xml changes outside of Carbide
-
Enable of have Carbide issue an alert prompting you to rescan your SDKs when changes to the devices.xml file are made outside of Carbide. When disabled the devices.xml file is not scanned for changes.
-
-
-
Rescan All SDKs
-
Click to rescan the drive for newly installed SDKs. The devices.xml file is scanned for SDKs and the list of available SDKs is updated if the devices.xml file has changed.
-
NOTE Carbide.c++ scans for available SDKs each time it is started.
-
-
-
-
-
\ No newline at end of file
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/reference/pref_carb_symbian_sdk.htm
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/com.nokia.carbide.cpp.doc.user/html/reference/pref_carb_symbian_sdk.htm Wed Aug 11 11:52:30 2010 -0500
@@ -0,0 +1,64 @@
+
+
+Symbian SDK
+
+
+
+
+
+
Symbian SDKs
+Use the
+Symbian SDK page in the Preferences window to control which installed SDKs are available to projects during an import. To
+ access SDK preferences preference panel, select Window > Preferences > Carbide.c++ > Symbian SDKs.
+
NOTE There must be at least one recognized SDK installed before you can create a project. If the SDK you have installed is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list. See Carbide.c++ Requirements for a list of supported SDKs.
+
NOTE This panel serves as a devices.xml file editor. The devices.xml file stores information about the installed SDKs used for Symbian OS development.
+
+
+
Figure 1. Symbian SDKs preference panel
+
+
Name
Function
+
+
Symbian SDK's
+
Lists all the installed and recognized SDKs supported by the IDE. Only SDKs supported by the IDE are included in the list.
+
Checked SDKs indicate build configurations available for creating projects. Unchecked SDKs are not displayed when creating new projects.
+
SDKs shown in red indicate a problem, usually no EPOCROOT or missing build configurations.
+
Click on a SDK name to see its EPOCROOT location and build configuration status in the SDK Information area.
+
+
+
Add
+
Click to add an SDK to the Available Symbian OS SDKs list.
+
+
+
Delete
+
Click to remove the selected SDK from the Available Symbian OS SDK's list.
+
+
+
Properties
+
Click to view and edit the properties of the currently selected SDK in the Available Symbian OS SDKs list.
+
+
+
Rescan All SDKs
+
Click to rescan the drive for newly installed SDKs. The devices.xml file is scanned for SDKs and the list of available SDKs is updated if the devices.xml file has changed.
+
NOTE Carbide.c++ scans for available SDKs each time it is started.
+
+
+
+
+
\ No newline at end of file
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/reference/pref_carb_x86_exceptions.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/reference/pref_carb_x86_exceptions.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/reference/pref_carb_x86_exceptions.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Unsetting Built-in Environment
-
+
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.
Use the System Search preference panel to control System Search behaviors. Choose Window > Preferences > System Search to open the System Search preference panel.
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.
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/reference/search/wnd_system_search.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/reference/search/wnd_system_search.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/reference/search/wnd_system_search.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
System Search
-
+
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:
The Launch Configuration Filters Preference window provides additional options for filtering out the launch configurations that appear in the list of configurations.
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:
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.
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.
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.
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.
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:
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:
The Carbide Portal view provides a single point of information on Carbide news, new releases, additional extensions, and support. The Carbide Portalview is shown by clicking Help > Carbide Portal.
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.
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:
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.
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.
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.
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
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
+
+
+
\ No newline at end of file
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/reference/view_signals.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/reference/view_signals.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/reference/view_signals.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Signals view
-
+
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.
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.
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.
@@ -55,7 +55,7 @@
Debug process or thread
-
Click the Debug button to attach to the process and debug the selected process or thread. Or right-click an item and choose Debug. This applies to both TRK (run mode) and Trace32 (stop mode).
+
Click the Debug button to attach to the process and debug the selected process or thread. Or right-click an item and choose Debug. This applies to both TRK (run mode) and TCF (stop mode).
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.
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/reference/views.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/reference/views.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/reference/views.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Working with Memory
-
+
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:
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.
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
@@ -19,7 +19,6 @@
issues.
-
-
-
-
-
\ No newline at end of file
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/tasks/CreatingNewProjects.html
--- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/CreatingNewProjects.html Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/CreatingNewProjects.html Wed Aug 11 11:52:30 2010 -0500
@@ -8,7 +8,7 @@
Creating New Symbian OS C++ Projects
New projects are created using the New Project Wizard. Carbide includes a number of templates that make creating projects for different SDKs and executables quick and easy.
-
NOTE You must have 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 is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list.
+
NOTE You must have 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 is not recognized, you may still be able to add it to the Discovered Symbian OS SDK list.
NOTE When creating or importing projects the sources and SDK must be on the same drive. This is due to many of the internal SDK tools using an implicit working drive to calculate paths (e.g. \epoc32\tools). Avoid spaces in SDK paths since this will also cause problems.
Creating New Symbian OS C++ Projects
@@ -18,7 +18,7 @@
The New Symbian OS C++ Project wizard appears. Select a template related to an installed SDK.
A project template provides the initial source files and project settings appropriate for the chosen project type. A brief description of each template appears below the list. The project type determines the type of program that you are writing.
NOTE If the selected template requires user input, additional wizard pages will collect data from the user before creating the project.
-
Checkmark the Filter templates based on enabled SDKs option to only list SDKs enabled in the SDK Preferences panel. Uncheck this option to list SDKs that can be used with Carbide. Click Next.
+
Checkmark the Filter templates based on enabled SDKs option to only list SDKs enabled in the SDK Preferences panel. Uncheck this option to list SDKs that can be used with Carbide. Click Next.
Enter a name for your project.
Checkmark the Use default location option to save the project in the current workspace by default or uncheck it to save to another location. Enter the path in the Location field or click Browse button to locate the directory. Click Next.
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/tasks/WorkingwithSDKs.html
--- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/WorkingwithSDKs.html Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/WorkingwithSDKs.html Wed Aug 11 11:52:30 2010 -0500
@@ -8,13 +8,13 @@
which of the installed SDKs to work with. From the chosen SDK, Symbian OS
plug-ins pick-up information such as header files, import libraries,
documentation and other SDK specific information.
-
You can add and manage SDKs in the SDK Preferences panel. The SDK Preferences panel lists all
+
You can add and manage SDKs in the SDK Preferences panel. The SDK Preferences panel lists all
available SDKs and allows you to rescan the drive for newly installed and supported SDKs or remove an existing SDK.
The changes in SDK Preferences are applicable to all projects under that
workspace.
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:
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.
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 c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/breakpoints/pgm_bp_exporting.htm Wed Aug 11 11:52:30 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.
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.
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.
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.
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.
+
+
+
+
\ No newline at end of file
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/tasks/custom/carb_custom_keys.htm
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/custom/carb_custom_keys.htm Wed Aug 11 11:52:30 2010 -0500
@@ -0,0 +1,31 @@
+
+
+
+
+
+
+Customizing Carbide: Shortcut Keys
+
+
+
+
+
Customizing Carbide: Shortcut Keys
+
The following key binding sets are available for customizing the shortcut keys used to invoke commands in Carbide. Use the Keys preference panel to select a shortcut set or modify the current set for your convenience. The Default set is extended by the other key bindings for commands not covered in the Default set or where the new set uses different key bindings for a command.
+
The options include:
+
+
Carbide.c++ (default) – Carbide + Default standard set
In addition, you can modify any of the assigned key bindings to use different keys to better suit your work style. See the Workbench User Guide > Reference > Preferences >Keys preference panel page for more information.
+
+
+
+
\ No newline at end of file
diff -r c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:52:30 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:
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.
+
+
+
+
\ No newline at end of file
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/tasks/custom/carb_custom_styles.htm
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/custom/carb_custom_styles.htm Wed Aug 11 11:52:30 2010 -0500
@@ -0,0 +1,35 @@
+
+
+
+
+
+
+Customizing Carbide: Code Styles
+
+
+
+
+
Customizing Carbide: Code Styles
+
You can customize how your source files are automatically formatted by using code styles. Code styles include items like indentation, use of braces or bracketts, whitespace, tab usages, and much more. In addition to supporting a variety of predefined code styles you can also create your own.
+
The change or customize a code style, open the Code Style preference panel.
+
+
The predefined code styles include:
+
+
BSD/Allman (Eclipse) – Based on the code style used for the ANSI C standard.
+
GNU (Eclipse) – Based on the code style used in for the GNU Coding Standards used by the GNU project.
+
K&R (Eclipse) – Based on the code style used in The C Programming Language by Kernighan and Ritchie.
+
S60 – Based on the code style used in Nokia S60 source code examples.
+
Symbian OS (default) – Based on the code style used in Symbian source code examples.
+
Qt – Based on the code style used in the Qt source code examples.
+
Whitesmiths (Eclipse) – Based on the code style used in documentation for the first commercial C compiler, the Whitesmith's Compiler.
+
+
+
+
\ No newline at end of file
diff -r c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:52:30 2010 -0500
@@ -0,0 +1,30 @@
+
+
+
+
+
+
+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:
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:
+
+
+
+
\ No newline at end of file
diff -r c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/run_mode_debug.htm Wed Aug 11 11:52:30 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
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
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.
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
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
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.
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.
To implement run mode on-device debugging the following tasks need to be completed.
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/soft_attach_debug.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/soft_attach_debug.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/soft_attach_debug.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,13 +7,14 @@
Using Soft Attach for On-Device Debugging
-
+
Using Soft Attach for On-Device Debugging
-
You can debug hardware via Trace32 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.
+
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.
There are several components that must be provided to the debugger so that it can communicate with the attached hardware device. They are:
Config_carbide.t32 - a required configuration file used to configure Carbide for soft attach debugging
-
.cmm file - you must select the correct .cmm script file for the hardware otherwise it will not initialize properly and the debugger will be unable to communicate. The .cmm script files are located in the <Carbide>\plugins\com.nokia.carbide.cpp.support_2.0.x.xxx\Symbian_Support\Trace32\cmm_scripts directory.
+
.cmm file - you must select the correct .cmm script file for the hardware otherwise it will not initialize properly and the debugger will be unable to communicate. The .cmm script files are located in the <Carbide>\plugins\com.nokia.carbide.cpp.support_3.0.x.xxx\Symbian_Support\TCF\cmm_scripts directory.
Also, if there is a specific .cmm file for the device, like H2 or H4, especially if it includes _attach in the name, choose that version over the others to do soft attach on the hardware.
.log file - you must have a valid .log file for the ROM image in order to debug the image
The project to associate with this debug launch configuration. Click Browse to select a different project.
-
Executable
+
Executable
This is the name of the executable that is linked to the project. Click Browse to select a different executable.
@@ -69,13 +75,17 @@
Explanation
-
-
Trace32 Executable
+
+
+
+
Trace32 Executable
Specify the path to the Trace32 executable. The default path assumes that the Trace32 executable is installed in the default location: C:\T32\T32marm.exe.
-
-
Trace32 Configuration File
+
+
+
+
Trace32 Configuration File
Specify the path to the config.t32 file or other custom configuration file. The default path assumes that the Trace32 configuration file is installed in the default location: C:\T32\config.t32.
For arm11 processors copy the trace32 configuration file for non-ARM11 processor (config_arm11.t32) to your C:\T32 folder and specify it in the edit box.
You can modify the config.t32 file to support UDP (User Datagram Protocol) connections by adding the following lines:
@@ -85,17 +95,21 @@
PORT=20000
-
-
+
- Trace32 Initialization Script
+
+
+
+ Trace32 Initialization Script
Specify the path to the initialization cmm file. This script will be run in T32 after connecting to T32. You can specify your own scripts for the targets used.
-
-
+
- View messages between Carbide and Trace32
+
+
+
+ View messages between Carbide and Trace32
Enable to log communications with Trace32 to the console window.
@@ -110,40 +124,40 @@
Explanation
-
Break at entry point
+
Break at entry point
When checked, break at the specified entry point entered in the text field. For .EXE targets, the default entry point is set to E32Main. By default, the Break at entry point option is unchecked for all other target types.
-
Target Processor
+
Target Processor
A drop down with a list of all supported processors. The process selection should help in determining the memory model. This will in turn help determine the base address and the offsets for the Symbian OS kernel aware information.
-
+
-
Target Initialization File
+
Target Initialization File
Check this box to have the debugger run an initialization script when the debug session starts. For example, if a target device requires initialization for the debugger to be able to read and write memory or registers, you can specify an initialization script here. Click Browse to select a script file using a standard file selection dialog box.
When using T32, most of the initialization is done in the CMM script file. With other debug protocols you specify the initialization file, which can be run after connecting to the target.
-
+
-
Memory Configuration File
+
Memory Configuration File
Controls whether the debugger uses a memory configuration file when a debug session starts. The Carbide debugger uses this configuration file to know which memory is accessible, readable, and writable on the target.
-
+
-
Reset target at the start of each debug session
+
Reset target at the start of each debug session
Forces the Carbide IDE to reset the target at the start of each debug session. This ensures that the debugging session uses the most up-to-date program code.
-
Default Instructon Set
+
Default Instructon Set
Specifies the default instruction set to use if the debugger cannot determine the processor mode in order to set breakpoints and to disassemble code. This can happen at addresses for which we have no symbolic information. The debugger uses the mode when setting breakpoints and disassembling code. The options are:
Auto (examine code at current PC location)
@@ -164,106 +178,106 @@
Explanation
-
+
-
-
- Start Address
+
+
+ Start Address
Enter the physical address in memory where the Symbian OS start code begins execution. This address is target-specific. The address should be in hexadecimal format with the 0x prefix. For example, 0x8000000 is a valid entry.
NOTE The address entered in this field must match the start address specified in the source code used to build the Symbian OS ROM image to be debugged. The Start address must match the Download address.
-
+
-
-
- Debug from Start address
+
+
+ Debug from Start address
Select this option to have the debugger halt the program at the address specified in Start Address once the target initialization is done and the OS is downloaded; if the user has chosen to download the OS. You can then step through start-up code or run the target in bare-board mode.
-
+
-
+
- Run from start address
+ Run from start address
Select this option to have the debugger start the code at the address specified in Start Address once the target initialization is done. If you have breakpoints set, the debugger stops at the first breakpoint encountered. You can click the Break button to halt the device.
-
+
-
+
-
- Symbian ROM Log file
+
+ Symbian ROM Log file
Check the Parse ROM Log File option and specify the information that the debugger needs in order to show detailed stack information, set breakpoints, and show source level debugging information for ROM images. In the first text field, browse to or enter the full path and name of the log file that corresponds to the ROM image on the target device. This log file is generated by default when the ROM image is built.
-
+
-
+
- Symbian OS Kit EPOC32 Directory
+ Symbian OS Kit EPOC32 Directory
Specifies the epoc32 directory in which the ROM image and log files are stored. Since the log file may not contain full paths to the ROM components on the host PC, you need to enter this epoc32 directory.
NOTE Always include the epoc32 folder in this path.
-
+
-
+
-
- Log unresolved modules
+
+ Log unresolved modules
Check this box to have the debugger output a list of components from the specified ROMBUILD log file that do not have debugger symbolic information. The list is displayed in the debugger console window at the beginning of the debug session.
NOTE You cannot perform source-level debugging on components that do not include symbolic information.
-
+
-
+
-
+
- Debug non-XIP Executables
+ Debug non-XIP Executables
Check this box to debug a project, or a dynamically loaded module, that is loaded from NAND-Flash or other removable media (MMC, memory stick, etc.) at run time and executed in RAM. Use this option to debug modules that work fine when executed in place as part of the ROM image, but sometimes fail when placed in NAND-Flash or other removable media.
NOTE Selecting this option will affect debugging performance. When the debugger needs to load a module (DLL, EXE, etc.) it will stop the target, read information from it, then restart it.
-
+
-
+
-
-
- Symbian ROM Image
+
+
+ Symbian ROM Image
Controls the logging of communication with Trace32. Enable to log communications with Trace32 to the console window.
-
+
-
Download Address (hex)
+
Download Address (hex)
Enter the physical address in memory at which the debugger should place the ROM image. This address is target-specific. The address should be in hexadecimal format with the 0x prefix. For example, 0x000FFF00 is a valid entry.
NOTE The address entered in this field must match the download address specified in the source code used to build the Symbian OS ROM image to be debugged. If you leave this field blank, the debugger does not download the ROM image to the device at the beginning of the debug session. The Download address must match the Start address.
-
+
-
Ask for download at the start of each debug session
+
Ask for download at the start of each debug session
Check this box to have the debugger display a dialog box at the beginning of every debug session that lets you choose whether or not you want the debugger to download the ROM image to the device.
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 c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/debugger/work_debug_act_debug.htm Wed Aug 11 11:52:30 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.
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.
-
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.
+
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.
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:
After you set an eventpoint, you can view and modify its properties.
diff -r c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/log_point_clear.htm Wed Aug 11 11:52:30 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 c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/log_point_set.htm Wed Aug 11 11:52:30 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 c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/pause_point_clear.htm Wed Aug 11 11:52:30 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 c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/eventpoints/pause_point_set.htm Wed Aug 11 11:52:30 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.
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.
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.
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.
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/tasks/processes/attach_debugger_to_process.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/processes/attach_debugger_to_process.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/processes/attach_debugger_to_process.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Attaching to a Symbian OS Process
-
+
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.
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 c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/processes/opening_system_browser.htm Wed Aug 11 11:52:30 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.
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.
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 c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_clean.htm Wed Aug 11 11:52:30 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 c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_creating_sis_file.htm Wed Aug 11 11:52:30 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.
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:
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.
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.
+
+
+
+
\ No newline at end of file
diff -r c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_debug_dlls.htm Wed Aug 11 11:52:30 2010 -0500
@@ -4,10 +4,10 @@
-Importing Executables for Debugging
+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:
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.
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_debug_rom.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_debug_rom.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_debug_rom.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Debugging in ROM
-
+
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:
@@ -17,13 +17,8 @@
NOTE You cannot debug ROM DLLs using Application TRK.
-
-
In Trace32 you must specify the ROM log file in the ROM Image tab of the Trace32 launch configuration
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.
Use the File > Import > Symbian OS Executable feature to import an executable into the Executables view and debug it. This is useful when the binary is not part of any project in the workspace. An example of this may be a library that is called from an mmp file. The binary must be built with the same build configuration as the current build configuration that is being used (compiler must be the same).
-
NOTE You also need the symbolics (.sym) file for debugging ARM build configurations.
-
NOTE Binaries built by the project can be debugged by selecting executables to debug in the Executable tab of the launch configuration Debug window.
-
-
To import a Symbian Executable
-
-
Select the File > Import... menu item
-
The Import window appears (Figure 1).
-
-
Figure 1 - Import window
-
Expand Symbian OS and select Symbian OS Executable in the list, then click Next
-
The Import Executable window appears (Figure 2).
-
Enter the executable name in the Select Executable field or click Browse to locate the executable
-
Use the Select executable field to choose a single executable or Search directory field to select one or more Symbian executables to import from the specified directory.
-
-
Figure 2 - Import Executable window
-
Click Finish
-
The IDE imports the Symbian executable and displays it in the Executables view (figure 3).
-
-
Figure 3 - Executables view showing executable and source files
-
The new project is listed under the Project Explorer view, as shown in Figure 4.
-
-
-
-
-
\ No newline at end of file
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_new_build_config.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_new_build_config.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_new_build_config.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Adding/Removing Build Configurations
-
+
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.
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 c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/prj_set_build_tgt.htm Wed Aug 11 11:52:30 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 c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/projects/working_with_sis_pkg_files.htm Wed Aug 11 11:52:30 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:
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.
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.
Use the
Platform Filtering Preferences tabs in the Preferences window to select which platforms are visible when creating new projects or build configurations.
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.
+
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++.
The SDK Properties window (Figure 1) appears. You can now review an SDKs properties and make modifications if your Carbide.c++ edition supports SDK modification.
NOTE Changes are directly applied to the devices.xml file.
diff -r c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_debugging.htm Wed Aug 11 11:52:30 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.
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 c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_example.htm Wed Aug 11 11:52:30 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:
@@ -17,7 +17,7 @@
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.
-
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.
+
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.
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 c13983cc5630 -r 1d57e533b09e 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 Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/start/carbide_help.htm Wed Aug 11 11:52:30 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 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.
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.
Updates to Carbide.c++ current features are available using the Install New Softwarefeature. 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.
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:
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.
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:
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_install_bluetooth.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_install_bluetooth.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_install_bluetooth.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Installing On-device Debug Agents using Bluetooth
-
+
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.
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_install_pcsuite.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_install_pcsuite.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_install_pcsuite.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
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.
diff -r c13983cc5630 -r 1d57e533b09e core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_install_usb.htm
--- a/core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_install_usb.htm Wed Aug 11 11:18:20 2010 -0500
+++ b/core/com.nokia.carbide.cpp.doc.user/html/tasks/trk/trk_install_usb.htm Wed Aug 11 11:52:30 2010 -0500
@@ -7,7 +7,7 @@
Installing On-device Debug Agents using USB
-
+
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.
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.
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:
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.
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.
- Hover Help lets developers who work with
- Symbian OS C++ in the Carbide IDE access Symbian OS
- API documentation in a pop-up window when hovering over an API item, such as a class name. The Hover Help plug-in is included with Carbide.c++ as part of the development tools package.
-
- This guide describes how to set up and configure Hover Help.
-
This section describes the Hover Help preferences panel that can configure and change the Developer Library version used by Hover Help.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+ Hover Help Guide
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Hover Help Guide
+
+ Hover Help lets developers who work with
+ Symbian OS C++ in the Carbide IDE access Symbian OS
+ API documentation in a pop-up window when hovering over an API item, such as a class name. The Hover Help plug-in is included with Carbide.c++ as part of the development tools package.
+
+ This guide describes how to set up and configure Hover Help.
+
- This section describes the preferences panel that you can use to configure
- and change the Developer Library plug-ins used by Hover Help.
- Select Window > Preferences > Carbide.c++ > Hover Help to open the Hover Help preference panel.
-
- With the preferences panel, you can:
-
-
- Let Hover Help automatically choose the right Developer Library.
-
-
- Select a Developer Library using the drop-down box.
-
- When you check the "Automatically select latest Developer
- Library" checkbox, the Developer Library is automatically selected for you.
- The name of the selected library is displayed in the grayed field.
- If you want to select a particular Developer Library, follow these
- steps.
-
- The right Developer Library is chosen using these heuristics:
-
-
- Choose by audience and license of the Developer Library.
- Platform development has precedence over public development.
-
-
- For example: "Developer Library rel1 (Platform) (date1)" will be chosen rather
- than "Developer Library rel2 (Public) (date2)".
-
-
-
-
-
-
- Then choose by latest publication date of the Developer Library.
- For example: "Developer Library rel1 (Platform) (21/03/2009)" will be chosen
- rather than "Developer Library rel1 (Platform) (20/02/2009)".
-
-
-
-
-
-
Developer Libraries Drop-Down Box
- The selected Developer Library is shown in the drop-down box.
-
- To change the Developer Library, first uncheck the "Automatically select latest Developer Library" checkbox.
- Then select a Developer Library from the drop-down box list.
- To add a new Developer Library, follow these steps.
-
-
-
Deactivate Hovering Checkbox
- Checking the Deactivate Hovering checkbox disables Hover Help,
- and unchecking the checkbox reactivates Hover Help.
-
+ This section describes the preferences panel that you can use to configure
+ and change the Developer Library plug-ins used by Hover Help.
+ Select Window > Preferences > Carbide.c++ > Hover Help to open the Hover Help preference panel.
+
+ With the preferences panel, you can:
+
+
+ Let Hover Help automatically choose the right Developer Library.
+
+
+ Select a Developer Library using the drop-down box.
+
+ When you check the "Automatically select latest Developer
+ Library" checkbox, the Developer Library is automatically selected for you.
+ The name of the selected library is displayed in the grayed field.
+ If you want to select a particular Developer Library, follow these
+ steps.
+
+ The right Developer Library is chosen using these heuristics:
+
+
+ Choose by audience and license of the Developer Library.
+ Platform development has precedence over public development.
+
+
+ For example: "Developer Library rel1 (Platform) (date1)" will be chosen rather
+ than "Developer Library rel2 (Public) (date2)".
+
+
+
+
+
+
+ Then choose by latest publication date of the Developer Library.
+ For example: "Developer Library rel1 (Platform) (21/03/2009)" will be chosen
+ rather than "Developer Library rel1 (Platform) (20/02/2009)".
+
+
+
+
+
+
Developer Libraries Drop-Down Box
+ The selected Developer Library is shown in the drop-down box.
+
+ To change the Developer Library, first uncheck the "Automatically select latest Developer Library" checkbox.
+ Then select a Developer Library from the drop-down box list.
+ To add a new Developer Library, follow these steps.
+
+
+
Deactivate Hovering Checkbox
+ Checking the Deactivate Hovering checkbox disables Hover Help,
+ and unchecking the checkbox reactivates Hover Help.
+