Arguments to main()
-The main() function can accept two or more arguments (ISO C, §5.1.2.2.1) of the form:
-int main(int argc, char *argv[]) { /*...*/ }
-The values stored in the argc and argv arguments depend on Carbide C’s target platform.
- - - + + + + + +Arguments to main()
+The main() function can accept two or more arguments (ISO C, §5.1.2.2.1) of the form:
+int main(int argc, char *argv[]) { /*...*/ }
+The values stored in the argc and argv arguments depend on Carbide C’s target platform.
+ + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_char_sets.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_char_sets.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_char_sets.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,16 +1,16 @@ - - - - - -Character Sets
-Carbide generally supports the 8-bit character set of the host OS.
- - - - - + + + + + +Character Sets
+Carbide generally supports the 8-bit character set of the host OS.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_devices.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_devices.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_devices.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,17 +1,17 @@ - - - - - -Interactive Device
-An interactive device is that part of a computer that accepts input from and provides output to a human operator (ISO C, §5.1.2.3). Traditionally, the conventional interactive devices are consoles, keyboards, and character display terminals.
-For embedded systems that do not have a keyboard or display, Carbide provides console interaction through a serial or Ethernet connection between the target and host computers.
- - - - - + + + + + +Interactive Device
+An interactive device is that part of a computer that accepts input from and provides output to a human operator (ISO C, §5.1.2.3). Traditionally, the conventional interactive devices are consoles, keyboards, and character display terminals.
+For embedded systems that do not have a keyboard or display, Carbide provides console interaction through a serial or Ethernet connection between the target and host computers.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_diag_msgs.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_diag_msgs.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_diag_msgs.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,18 +1,18 @@ - - - - - -How to Identify Diagnostic Messages
-Diagnostics are error and warning messages the C compiler issues when it encounters improper program syntax (ISO C, §5.1.1.3).
-Within the Carbide IDE, the Carbide C compiler issues diagnostic messages in the Console view.
-From the command line, Carbide C issues diagnostic messages to the standard error file.
- - - - - + + + + + +How to Identify Diagnostic Messages
+Diagnostics are error and warning messages the C compiler issues when it encounters improper program syntax (ISO C, §5.1.1.3).
+Within the Carbide IDE, the Carbide C compiler issues diagnostic messages in the Console view.
+From the command line, Carbide C issues diagnostic messages to the standard error file.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_enums.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_enums.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_enums.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,16 +1,16 @@ - - - - - -Enumerations
-See Enumerated Types.
- - - - - + + + + + +Enumerations
+See Enumerated Types.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_identifiers.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_identifiers.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_identifiers.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,16 +1,16 @@ - - - - - -Identifiers
-(ISO C, §6.2.4.1) Carbide C recognizes the first 255 characters of identifiers, whether or not the identifiers have external linkage. In identifiers with external linkage, uppercase and lowercase characters are distinct.
- - - - - + + + + + +Identifiers
+(ISO C, §6.2.4.1) Carbide C recognizes the first 255 characters of identifiers, whether or not the identifiers have external linkage. In identifiers with external linkage, uppercase and lowercase characters are distinct.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_implementation.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_implementation.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_be_implementation.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,174 +1,174 @@ - - - - - -Implementation Quantities
-The C/C++ compiler has the implementation quantities listed in Table 1, based on the ISO C++ Standard. Although the values in the right-side column are the recommended minimums for each quantity, they do not determine the compliance of the quantity.
-NOTE The right-side column value “unlimited” means unlimited only up to and including memory and time limitations.
-Table 1. Implementation Quantities for the C/C++ Compiler
-| Quantity | -Minimum | -
|---|---|
| Nesting levels of compound statements, iteration control structures, and selection control structures [256] | -Unlimited | -
| Nesting levels of conditional inclusion [256] | -32 | -
| Pointer, array, and function declarators (in any combination) modifying an arithmetic, structure, union, or incomplete type in a declaration [256] | -Unlimited | -
| Nesting levels of parenthesized expressions within a full expression [256] | -Unlimited | -
| Number of initial characters in an internal identifier or macro name [1024] | -Unlimited - (255 significant in identifiers) |
-
| Number of initial characters in an external identifier [1024] | -Unlimited - (255 significant in identifiers) |
-
| External identifiers in one translation unit [65536] | -Unlimited | -
| Identifiers with block scope declared in one block [1024] | -Unlimited | -
| Macro identifiers simultaneously defined in one translation unit [65536] | -Unlimited | -
| Parameters in one function definition [256] | -Unlimited | -
| Arguments in one function call [256] | -Unlimited | -
| Parameters in one macro definition [256] | -128 | -
| Arguments in one macro invocation [256] | -128 | -
| Characters in one logical source line [65536] | -Unlimited | -
| Characters in a character string literal or wide string literal (after concatenation) [65536] | -Unlimited | -
| Size of an object [262144] | -2 GB | -
| Nesting levels for #include files [256] | -32 | -
| Case labels for a switch statement (excluding those for any nested switch statements) [16384] | -Unlimited | -
| Data members in a single class, structure, or union [16384] | -Unlimited | -
| Enumeration constants in a single enumeration [4096] | -Unlimited | -
| Levels of nested class, structure, or union definitions in a single struct-declaration-list [256] | -Unlimited | -
| Functions registered by atexit()[32] | -64 | -
| Direct and indirect base classes [16384] | -Unlimited | -
| Direct base classes for a single class [1024] | -Unlimited | -
| Members declared in a single class [4096] | -Unlimited | -
| Final overriding virtual functions in a class, accessible or not [16384] | -Unlimited | -
| Direct and indirect virtual bases of a class [1024] | -Unlimited | -
| Static members of a class [1024] | -Unlimited | -
| Friend declarations in a class [4096] | -Unlimited | -
| Access control declarations in a class [4096] | -Unlimited | -
| Member initializers in a constructor definition [6144] | -Unlimited | -
| Scope qualifications of one identifier [256] | -Unlimited | -
| Nested external specifications [1024] | -Unlimited | -
| Template arguments in a template declaration [1024] | -Unlimited | -
| Recursively nested template instantiations [17] | -Unlimited | -
| Handlers per try block [256] | -Unlimited | -
| Throw specifications on a single function declaration [256] | -Unlimited | -
Implementation Quantities
+The C/C++ compiler has the implementation quantities listed in Table 1, based on the ISO C++ Standard. Although the values in the right-side column are the recommended minimums for each quantity, they do not determine the compliance of the quantity.
+NOTE The right-side column value “unlimited” means unlimited only up to and including memory and time limitations.
+Table 1. Implementation Quantities for the C/C++ Compiler
+| Quantity | +Minimum | +
|---|---|
| Nesting levels of compound statements, iteration control structures, and selection control structures [256] | +Unlimited | +
| Nesting levels of conditional inclusion [256] | +32 | +
| Pointer, array, and function declarators (in any combination) modifying an arithmetic, structure, union, or incomplete type in a declaration [256] | +Unlimited | +
| Nesting levels of parenthesized expressions within a full expression [256] | +Unlimited | +
| Number of initial characters in an internal identifier or macro name [1024] | +Unlimited + (255 significant in identifiers) |
+
| Number of initial characters in an external identifier [1024] | +Unlimited + (255 significant in identifiers) |
+
| External identifiers in one translation unit [65536] | +Unlimited | +
| Identifiers with block scope declared in one block [1024] | +Unlimited | +
| Macro identifiers simultaneously defined in one translation unit [65536] | +Unlimited | +
| Parameters in one function definition [256] | +Unlimited | +
| Arguments in one function call [256] | +Unlimited | +
| Parameters in one macro definition [256] | +128 | +
| Arguments in one macro invocation [256] | +128 | +
| Characters in one logical source line [65536] | +Unlimited | +
| Characters in a character string literal or wide string literal (after concatenation) [65536] | +Unlimited | +
| Size of an object [262144] | +2 GB | +
| Nesting levels for #include files [256] | +32 | +
| Case labels for a switch statement (excluding those for any nested switch statements) [16384] | +Unlimited | +
| Data members in a single class, structure, or union [16384] | +Unlimited | +
| Enumeration constants in a single enumeration [4096] | +Unlimited | +
| Levels of nested class, structure, or union definitions in a single struct-declaration-list [256] | +Unlimited | +
| Functions registered by atexit()[32] | +64 | +
| Direct and indirect base classes [16384] | +Unlimited | +
| Direct base classes for a single class [1024] | +Unlimited | +
| Members declared in a single class [4096] | +Unlimited | +
| Final overriding virtual functions in a class, accessible or not [16384] | +Unlimited | +
| Direct and indirect virtual bases of a class [1024] | +Unlimited | +
| Static members of a class [1024] | +Unlimited | +
| Friend declarations in a class [4096] | +Unlimited | +
| Access control declarations in a class [4096] | +Unlimited | +
| Member initializers in a constructor definition [6144] | +Unlimited | +
| Scope qualifications of one identifier [256] | +Unlimited | +
| Nested external specifications [1024] | +Unlimited | +
| Template arguments in a template declaration [1024] | +Unlimited | +
| Recursively nested template instantiations [17] | +Unlimited | +
| Handlers per try block [256] | +Unlimited | +
| Throw specifications on a single function declaration [256] | +Unlimited | +
Library Behaviors
-This reference does not cover implementation-defined behaviors in the Metrowerks Standard Library for C (MSL C).
- - - - - + + + + + +Library Behaviors
+This reference does not cover implementation-defined behaviors in the Metrowerks Standard Library for C (MSL C).
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_behavior.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_behavior.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_behavior/c_behavior.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,28 +1,28 @@ - - - - - -C Implementation-Defined Behavior
-The ISO standard for C leaves many details about the form and translation of C programs up to the implementation of the C compiler. Section J.3 of the ISO C Standard lists the unique implementation-defined behaviors. Numbers in parentheses that begin with “§” indicate the ISO C standard section to which an implementation-defined behavior refers.
-This section refers to implementation-defined behaviors of the compiler itself. Topics include:
--
-
- How to Identify Diagnostic Messages -
- Arguments to main() -
- Interactive Devices -
- Identifiers -
- Character Sets -
- Enumerations -
- Implementation Quantities -
- Library Behaviors -
For information on implementation-defined behaviors of the Standard C Library, consult the MSL C Library Reference.
- - - - - + + + + + +C Implementation-Defined Behavior
+The ISO standard for C leaves many details about the form and translation of C programs up to the implementation of the C compiler. Section J.3 of the ISO C Standard lists the unique implementation-defined behaviors. Numbers in parentheses that begin with “§” indicate the ISO C standard section to which an implementation-defined behavior refers.
+This section refers to implementation-defined behaviors of the compiler itself. Topics include:
+-
+
- How to Identify Diagnostic Messages +
- Arguments to main() +
- Interactive Devices +
- Identifiers +
- Character Sets +
- Enumerations +
- Implementation Quantities +
- Library Behaviors +
For information on implementation-defined behaviors of the Standard C Library, consult the MSL C Library Reference.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_ansi_keywords.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_ansi_keywords.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_ansi_keywords.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,25 +1,25 @@ - - - - - -ANSI Keywords Only
-(ISO C, §6.4.1) The Carbide compiler can recognize several additional reserved keywords. If you enable this setting, the compiler generates an error if it encounters any of the additional keywords that it recognizes. If you must write source code that strictly adheres to the ISO standard, enable the ANSI Strict setting.
-If you disable this setting, the compiler recognizes the following non-standard keywords:
--
-
- far—Specifies how the compiler generates addressing modes and operations. It is not available for every target platform. -
- inline—Lets you declare a C function to be inline. For more information, see Inlining. -
- pascal—No longer used. -
The ANSI Keywords Only setting corresponds to the pragma only_std_keywords. To check this setting, use __option (only_std_keywords). By default, this setting is disabled.
-See also “only_std_keywords” and Checking Settings.
-
ANSI Keywords Only
+(ISO C, §6.4.1) The Carbide compiler can recognize several additional reserved keywords. If you enable this setting, the compiler generates an error if it encounters any of the additional keywords that it recognizes. If you must write source code that strictly adheres to the ISO standard, enable the ANSI Strict setting.
+If you disable this setting, the compiler recognizes the following non-standard keywords:
+-
+
- far—Specifies how the compiler generates addressing modes and operations. It is not available for every target platform. +
- inline—Lets you declare a C function to be inline. For more information, see Inlining. +
- pascal—No longer used. +
The ANSI Keywords Only setting corresponds to the pragma only_std_keywords. To check this setting, use __option (only_std_keywords). By default, this setting is disabled.
+See also “only_std_keywords” and Checking Settings.
+
Intrinsic Functions for Bit Rotation
-The Carbide C language has functions
-__rol(op, n)
- __ror(op, n)
that do left- or right-bit rotation, respectively.
-The op argument represents the item with the rotated bits. The n argument represents the number of times to rotate the op bits.
-The op argument is not promoted to a larger data type and can be of type char, short, int, long, or long long.
-These functions are intrinsic (“built-in”). That is, you do not have to provide function prototypes or link with special libraries to use these functions.
-NOTE Currently, these functions are limited to the Motorola 68K and Intel x86 versions of the Carbide C/C++ compiler. -
- - - - - + + + + + +Intrinsic Functions for Bit Rotation
+The Carbide C language has functions
+__rol(op, n)
+ __ror(op, n)
that do left- or right-bit rotation, respectively.
+The op argument represents the item with the rotated bits. The n argument represents the number of times to rotate the op bits.
+The op argument is not promoted to a larger data type and can be of type char, short, int, long, or long long.
+These functions are intrinsic (“built-in”). That is, you do not have to provide function prototypes or link with special libraries to use these functions.
+NOTE Currently, these functions are limited to the Motorola 68K and Intel x86 versions of the Carbide C/C++ compiler. +
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_char_const_as_int.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_char_const_as_int.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_char_const_as_int.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,46 +1,46 @@ - - - - - -Character Constants as Integer Values
-(ISO C, §6.4.4.4) The C compiler lets you use string literals containing 2 to 8 characters to denote 32-bit or 64-bit integer values. Table 2.2 shows examples.
-Table 2.2 Integer Values as Character String Constants
-| Character constant | -Equivalent hexadecimal integer value | -
|---|---|
| 'ABCDEFGH' | -0x4142434445464748 (64-bit value) | -
| 'ABCDE' | -0x0000000041424344 (64-bit value) | -
| 'ABCD' | -0x41424344 (32-bit value) | -
| 'ABC' | -0x00414243 (32-bit value) | -
| 'AB' | -0x00004142 (32-bit value) | -
You cannot disable this extension, and it has no corresponding pragma or setting in any panel.
-NOTE This feature differs from using multibyte character sets, where a single character requires a data type larger than 1 byte. See Multibyte and Unicode Support for information on using character sets with more than 256 characters (such as Kanji).
-
Character Constants as Integer Values
+(ISO C, §6.4.4.4) The C compiler lets you use string literals containing 2 to 8 characters to denote 32-bit or 64-bit integer values. Table 2.2 shows examples.
+Table 2.2 Integer Values as Character String Constants
+| Character constant | +Equivalent hexadecimal integer value | +
|---|---|
| 'ABCDEFGH' | +0x4142434445464748 (64-bit value) | +
| 'ABCDE' | +0x0000000041424344 (64-bit value) | +
| 'ABCD' | +0x41424344 (32-bit value) | +
| 'ABC' | +0x00414243 (32-bit value) | +
| 'AB' | +0x00004142 (32-bit value) | +
You cannot disable this extension, and it has no corresponding pragma or setting in any panel.
+NOTE This feature differs from using multibyte character sets, where a single character requires a data type larger than 1 byte. See Multibyte and Unicode Support for information on using character sets with more than 256 characters (such as Kanji).
+
C Compiler
-This section covers the following topics:
- -The information in this section applies to all target platforms for which the Carbide C compiler generates object code.
-This section does not cover C++ features. For more information on the Carbide.c++ language, see C++ Compiler.
-
C Compiler
+This section covers the following topics:
+ +The information in this section applies to all target platforms for which the Carbide C compiler generates object code.
+This section does not cover C++ features. For more information on the Carbide.c++ language, see C++ Compiler.
+
Converting Pointers to Types of the Same Size
-The C compiler allows the conversion of pointer types to integral data types of the same size in global initializations. Since this type of conversion does not conform to the ANSI C standard, it is only available if the ANSI Strict setting is disabled.
-Converting a Pointer to a Same-sized Integral Type
-char c;
- long arr = (long)&c; // accepted (not ISO C)
See Checking for Standard C and Standard C++ Conformity for more information on this setting.
- - - - - + + + + + +Converting Pointers to Types of the Same Size
+The C compiler allows the conversion of pointer types to integral data types of the same size in global initializations. Since this type of conversion does not conform to the ANSI C standard, it is only available if the ANSI Strict setting is disabled.
+Converting a Pointer to a Same-sized Integral Type
+char c;
+ long arr = (long)&c; // accepted (not ISO C)
See Checking for Standard C and Standard C++ Conformity for more information on this setting.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_cpp_comments.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_cpp_comments.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_cpp_comments.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,20 +1,20 @@ - - - - - -C++ Comments
-(ISO C, §6.4.9) The C compiler can accept C++ comments (//) in source code. C++ comments consist of anything that follows // on a line.
-a = b; // This is a C++ comment
-To use this feature, disable the ANSI Strict setting.
-See also Checking for Standard C and Standard C++ Conformity. -
- - - - - + + + + + +C++ Comments
+(ISO C, §6.4.9) The C compiler can accept C++ comments (//) in source code. C++ comments consist of anything that follows // on a line.
+a = b; // This is a C++ comment
+To use this feature, disable the ANSI Strict setting.
+See also Checking for Standard C and Standard C++ Conformity. +
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_d_constant_suffix.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_d_constant_suffix.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_d_constant_suffix.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,19 +1,19 @@ - - - - - -The “D” Constant Suffix
-When the compiler finds a “D” immediately after a floating point constant value, it treats that value as data of type double.
-When the pragma float_constants is enabled, floating point constants should end with a “D” so that the compiler does not treat them as values of type float.
-For related information, see “float_constants”. -
- - - - - + + + + + +The “D” Constant Suffix
+When the compiler finds a “D” immediately after a floating point constant value, it treats that value as data of type double.
+When the pragma float_constants is enabled, floating point constants should end with a “D” so that the compiler does not treat them as values of type float.
+For related information, see “float_constants”. +
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_declare_var_addr.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_declare_var_addr.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_declare_var_addr.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,19 +1,19 @@ - - - - - -Declaring Variables by Address
-(ISO C, §6.7.8) The C compiler lets you explicitly specify the address that contains the value of a variable. For example, this definition states that the variable MemErr contains the contents of the address 0x220:
-short MemErr:0x220;
- You cannot disable this extension, and it has no corresponding pragma or setting in a panel.
-
Declaring Variables by Address
+(ISO C, §6.7.8) The C compiler lets you explicitly specify the address that contains the value of a variable. For example, this definition states that the variable MemErr contains the contents of the address 0x220:
+short MemErr:0x220;
+ You cannot disable this extension, and it has no corresponding pragma or setting in a panel.
+
The __declspec Declarator
-The __declspec(arg) declarator is a convention adopted from Win32 compilers to extend the type system. All Carbide compilers recognize this declarator.
-The __declspec declarator must appear before the name of the object as shown below:
- __declspec(arg) int foo();
- class __declspec(arg) bar { ... };
The list of valid arguments are grouped by targets:
--
-
- All Targets -
- Non-Win32 Targets Only -
- Win32 Targets Only -
The __declspec Declarator
+The __declspec(arg) declarator is a convention adopted from Win32 compilers to extend the type system. All Carbide compilers recognize this declarator.
+The __declspec declarator must appear before the name of the object as shown below:
+ __declspec(arg) int foo();
+ class __declspec(arg) bar { ... };
The list of valid arguments are grouped by targets:
+-
+
- All Targets +
- Non-Win32 Targets Only +
- Win32 Targets Only +
Using an Identifier After #endif
-(ISO C, §6.10.1) The C compiler can accept identifier tokens after #endif and #else. This extension helps you match an #endif statement with its corresponding #if, #ifdef, or #ifndef statement, as shown here:
-#ifdef __MWERKS__
- # ifndef __cplusplus
- /*
- * . . .
- */
- # endif __cplusplus
-#endif __MWERKS__
To use this feature, disable the ANSI Strict setting.
-TIP If you enable the ANSI Strict setting (thereby disabling this extension), you can still match your #ifdef and #endif directives. Simply put the identifiers into comments, as sown in following example:
-
- #ifdef __MWERKS__
- # ifndef __cplusplus
- /*
- * . . .
- */
- # endif /* __cplusplus */
-#endif /* __MWERKS__ */
See also Checking for Standard C and Standard C++ Conformity.
- - - - - + + + + + +Using an Identifier After #endif
+(ISO C, §6.10.1) The C compiler can accept identifier tokens after #endif and #else. This extension helps you match an #endif statement with its corresponding #if, #ifdef, or #ifndef statement, as shown here:
+#ifdef __MWERKS__
+ # ifndef __cplusplus
+ /*
+ * . . .
+ */
+ # endif __cplusplus
+#endif __MWERKS__
To use this feature, disable the ANSI Strict setting.
+TIP If you enable the ANSI Strict setting (thereby disabling this extension), you can still match your #ifdef and #endif directives. Simply put the identifiers into comments, as sown in following example:
+
+ #ifdef __MWERKS__
+ # ifndef __cplusplus
+ /*
+ * . . .
+ */
+ # endif /* __cplusplus */
+#endif /* __MWERKS__ */
See also Checking for Standard C and Standard C++ Conformity.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_enum_types.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_enum_types.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_enum_types.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,63 +1,63 @@ - - - - - -Enumerated Types
-(ISO C, §6.2.5) The Carbide C compiler uses the Enums Always Int and ANSI Strict settings to choose which underlying integer type to use for an enumerated type.
-If you enable the Enums Always Int setting, the underlying type for enumerated data types is set to signed int. Enumerators cannot be larger than a signed int. If an enumerated constant is larger than an int, the compiler generates an error.
-If you disable the ANSI Strict setting, enumerators that can be represented as an unsigned int are implicitly converted to signed int.
-Listing 2.2 Example of Enumerations as Signed Integers
-#pragma enumsalwaysint on
- #pragma ANSI_strict on
- enum foo { a=0xFFFFFFFF }; // ERROR. a is 4,294,967,295:
- // too big for a signed int
- #pragma ANSI_strict off
- enum bar { b=0xFFFFFFFF }; // OK: b can be represented as an
- // unsigned int, but is implicitly
- // converted to a signed int (-1).
If you disable the Enums Always Int setting, the compiler chooses the integral data type that supports the largest enumerated constant. The type can be as small as a char or as large as a long int. It can even be a 64-bit long long value.
-If all enumerators are positive, the compiler chooses the smallest unsigned integral base type that is large enough to represent all enumerators. If at least one enumerator is negative, the compiler chooses the smallest signed integral base type large enough to represent all enumerators.
-Listing 2.3 Example of Enumeration Base Types
- #pragma enumsalwaysint off
- enum { a=0,b=1 }; // base type: unsigned char
- enum { c=0,d=-1 }; // base type: signed char
- enum { e=0,f=128,g=-1 }; // base type: signed short
The compiler uses long long data types only if you disable Enums Always Int and enable the longlong_enums pragma. (None of the settings corresponds to the longlong_enums pragma.)
-Listing 2.4 Example of Enumerations with Type long long
- #pragma enumsalwaysint off
- #pragma longlong_enums off
- enum { a=0x7FFFFFFFFFFFFFFF }; // ERROR: a is too large
- #pragma longlong_enums on
- enum { b=0x7FFFFFFFFFFFFFFF }; // OK: base type: signed long long
- enum { c=0x8000000000000000 }; // OK: base type: unsigned long long
- enum {þd=-1,e=0x80000000 }; // OK: base type: signed long long
When you disable the longlong_enums pragma and enable ANSI Strict, you cannot mix unsigned 32-bit enumerators greater than 0x7FFFFFFF and negative enumerators. If you disable both the longlong_enums pragma and the ANSI Strict setting, large unsigned 32-bit enumerators are implicitly converted to signed 32-bit types.
-Listing 2.5 Example of Enumerations with Type long
-#pragma enumsalwaysint off
- #pragma longlong_enums off
- #pragma ANSI_strict on
- enum { a=-1,b=0xFFFFFFFF }; // error
- #pragma ANSI_strict off
- enum { c=-1,d=0xFFFFFFFF }; // base type: signed int (b==-1)
The Enums Always Int setting corresponds to the pragma enumsalwaysint. To check this setting, use __option (enumsalwaysint).
-By default, this setting is disabled.
-See also “enumsalwaysint”, “longlong_enums”, and Checking Settings.
-
Enumerated Types
+(ISO C, §6.2.5) The Carbide C compiler uses the Enums Always Int and ANSI Strict settings to choose which underlying integer type to use for an enumerated type.
+If you enable the Enums Always Int setting, the underlying type for enumerated data types is set to signed int. Enumerators cannot be larger than a signed int. If an enumerated constant is larger than an int, the compiler generates an error.
+If you disable the ANSI Strict setting, enumerators that can be represented as an unsigned int are implicitly converted to signed int.
+Listing 2.2 Example of Enumerations as Signed Integers
+#pragma enumsalwaysint on
+ #pragma ANSI_strict on
+ enum foo { a=0xFFFFFFFF }; // ERROR. a is 4,294,967,295:
+ // too big for a signed int
+ #pragma ANSI_strict off
+ enum bar { b=0xFFFFFFFF }; // OK: b can be represented as an
+ // unsigned int, but is implicitly
+ // converted to a signed int (-1).
If you disable the Enums Always Int setting, the compiler chooses the integral data type that supports the largest enumerated constant. The type can be as small as a char or as large as a long int. It can even be a 64-bit long long value.
+If all enumerators are positive, the compiler chooses the smallest unsigned integral base type that is large enough to represent all enumerators. If at least one enumerator is negative, the compiler chooses the smallest signed integral base type large enough to represent all enumerators.
+Listing 2.3 Example of Enumeration Base Types
+ #pragma enumsalwaysint off
+ enum { a=0,b=1 }; // base type: unsigned char
+ enum { c=0,d=-1 }; // base type: signed char
+ enum { e=0,f=128,g=-1 }; // base type: signed short
The compiler uses long long data types only if you disable Enums Always Int and enable the longlong_enums pragma. (None of the settings corresponds to the longlong_enums pragma.)
+Listing 2.4 Example of Enumerations with Type long long
+ #pragma enumsalwaysint off
+ #pragma longlong_enums off
+ enum { a=0x7FFFFFFFFFFFFFFF }; // ERROR: a is too large
+ #pragma longlong_enums on
+ enum { b=0x7FFFFFFFFFFFFFFF }; // OK: base type: signed long long
+ enum { c=0x8000000000000000 }; // OK: base type: unsigned long long
+ enum {þd=-1,e=0x80000000 }; // OK: base type: signed long long
When you disable the longlong_enums pragma and enable ANSI Strict, you cannot mix unsigned 32-bit enumerators greater than 0x7FFFFFFF and negative enumerators. If you disable both the longlong_enums pragma and the ANSI Strict setting, large unsigned 32-bit enumerators are implicitly converted to signed 32-bit types.
+Listing 2.5 Example of Enumerations with Type long
+#pragma enumsalwaysint off
+ #pragma longlong_enums off
+ #pragma ANSI_strict on
+ enum { a=-1,b=0xFFFFFFFF }; // error
+ #pragma ANSI_strict off
+ enum { c=-1,d=0xFFFFFFFF }; // base type: signed int (b==-1)
The Enums Always Int setting corresponds to the pragma enumsalwaysint. To check this setting, use __option (enumsalwaysint).
+By default, this setting is disabled.
+See also “enumsalwaysint”, “longlong_enums”, and Checking Settings.
+
Expand Trigraphs
-(ISO C, §5.2.1.1) The C compiler normally ignores trigraph characters. Many common character constants look like trigraph sequences, and this extension lets you use them without including escape characters.
-If you must write source code that strictly adheres to the ISO standard, enable the Expand Trigraphs setting. When you enable this setting, be careful when initializing strings or multi-character constants that contain question marks.
-char c = '????'; // ERROR: Trigraph sequence expands to '??^
- char d = '\?\?\?\?'; // OK
The Expand Trigraphs setting corresponds to the pragma trigraphs, To check this setting, use __option (trigraphs). By default, this setting is disabled.
-See also “trigraphs” and Checking Settings. -
- - - - - + + + + + +Expand Trigraphs
+(ISO C, §5.2.1.1) The C compiler normally ignores trigraph characters. Many common character constants look like trigraph sequences, and this extension lets you use them without including escape characters.
+If you must write source code that strictly adheres to the ISO standard, enable the Expand Trigraphs setting. When you enable this setting, be careful when initializing strings or multi-character constants that contain question marks.
+char c = '????'; // ERROR: Trigraph sequence expands to '??^
+ char d = '\?\?\?\?'; // OK
The Expand Trigraphs setting corresponds to the pragma trigraphs, To check this setting, use __option (trigraphs). By default, this setting is disabled.
+See also “trigraphs” and Checking Settings. +
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_function_identifier.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_function_identifier.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_function_identifier.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,17 +1,17 @@ - - - - - -The __FUNCTION__ Predefined Identifier
-The __FUNCTION__ predefined identifier contains the name of the function currently being compiled. For related information, see “Predefined Symbols”. -
- - - - - + + + + + +The __FUNCTION__ Predefined Identifier
+The __FUNCTION__ predefined identifier contains the name of the function currently being compiled. For related information, see “Predefined Symbols”. +
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_gcc_ext_support.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_gcc_ext_support.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_gcc_ext_support.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,137 +1,137 @@ - - - - - -GCC Extension Support
-Use the GCC Extensions setting to enable the compiler to accept some GCC syntax and conventions. This option is the same as the previously-supported #pragma gcc_extensions.
-The following GCC compatibility enhancements have been added:
--
-
- Statements in expressions are allowed -
--({int a; a=myfunc(); a; })
-
-
-
- GCC-style inline assembly supported on some targets only -
--int count_leading_zero(int value)
-
- {
- asm ( "cntlzw %0, %1" : "=r" (bits) : "r" (value) );
- return bits;
- }
-
-
- GCC-style macro varargs supported -
--#define DEBUG(fmt,args...) printf(fmt, ## args)
-
- DEBUG("test");
- DEBUG("saw %d copies\n", n_copies);
-• The abbreviated “?:” operator is allowed
- x = y ?: z; // --> x = y ? y : z;
-
-
- Allow incomplete structs in array declarations -
--struct Incomplete arr[10];
-
-
-
- Allow Class::Member in a class declaration -
--class MyClass {
-
- ...
- int MyClass::getval();
- ...
- };
-
-
- Allow empty structs -
--struct empty { } x;
-
-
-
- Allow empty struct initialization -
--struct empty { } x = {};
-
-
-
- Struct initializer typecast support -
--typedef struct { int x, y, z; float q; } mystruct;
-
- void foo(mystruct s);
- foo( (mystruct) { 1,2,3,6e3 } );
-
-
- Limited support for “void *” and function pointer arithmetic -
--void *p;
-
- p = &data + 10; // point 10 bytes into "p"
- void foo();
- p = foo + 10; // point 10 bytes into "foo"
- At this time, the increment and decrement operators “++” don’t work with void/function pointers.
-
-
- sizeof(function) and sizeof(void) is 1 -
- Function pointers may be compared to “void *” -
- Allow null statement (no trailing semicolon) in “switch” -
--switch(x) {
-
- label:
- }
-
-
- Macro redefinitions with different values allowed -
--#define MAC 3
-
- #define MAC (3)
-
-
- “<?”, “>?” MIN/MAX operators supported for some targets -
- Arrays may be assigned -
--int a[10], b[10];
-
- a = b;
-
-
- Allow trailing comma in enumerations without warning -
--enum { A, B, C, };
-
-
-
- Allow empty array as final member of struct -
--typedef struct {
-
- int type;
- char data[];
- } Node;
-
-
- Designated initializer support -
--struct { int x, y, z; float q; } x = { q: 3.0,
-
- y:1, z:-4, x:-6 };
For related information, see the #pragma gcc_extensions.
- - - - - + + + + + +GCC Extension Support
+Use the GCC Extensions setting to enable the compiler to accept some GCC syntax and conventions. This option is the same as the previously-supported #pragma gcc_extensions.
+The following GCC compatibility enhancements have been added:
+-
+
- Statements in expressions are allowed +
++({int a; a=myfunc(); a; })
+
-
+
- GCC-style inline assembly supported on some targets only +
++int count_leading_zero(int value)
+
+ {
+ asm ( "cntlzw %0, %1" : "=r" (bits) : "r" (value) );
+ return bits;
+ }
-
+
- GCC-style macro varargs supported +
++#define DEBUG(fmt,args...) printf(fmt, ## args)
+
+ DEBUG("test");
+ DEBUG("saw %d copies\n", n_copies);
+• The abbreviated “?:” operator is allowed
+ x = y ?: z; // --> x = y ? y : z;
-
+
- Allow incomplete structs in array declarations +
++struct Incomplete arr[10];
+
-
+
- Allow Class::Member in a class declaration +
++class MyClass {
+
+ ...
+ int MyClass::getval();
+ ...
+ };
-
+
- Allow empty structs +
++struct empty { } x;
+
-
+
- Allow empty struct initialization +
++struct empty { } x = {};
+
-
+
- Struct initializer typecast support +
++typedef struct { int x, y, z; float q; } mystruct;
+
+ void foo(mystruct s);
+ foo( (mystruct) { 1,2,3,6e3 } );
-
+
- Limited support for “void *” and function pointer arithmetic +
++void *p;
+
+ p = &data + 10; // point 10 bytes into "p"
+ void foo();
+ p = foo + 10; // point 10 bytes into "foo"
+ At this time, the increment and decrement operators “++” don’t work with void/function pointers.
-
+
- sizeof(function) and sizeof(void) is 1 +
- Function pointers may be compared to “void *” +
- Allow null statement (no trailing semicolon) in “switch” +
++switch(x) {
+
+ label:
+ }
-
+
- Macro redefinitions with different values allowed +
++#define MAC 3
+
+ #define MAC (3)
-
+
- “<?”, “>?” MIN/MAX operators supported for some targets +
- Arrays may be assigned +
++int a[10], b[10];
+
+ a = b;
-
+
- Allow trailing comma in enumerations without warning +
++enum { A, B, C, };
+
-
+
- Allow empty array as final member of struct +
++typedef struct {
+
+ int type;
+ char data[];
+ } Node;
-
+
- Designated initializer support +
++struct { int x, y, z; float q; } x = { q: 3.0,
+
+ y:1, z:-4, x:-6 };
For related information, see the #pragma gcc_extensions.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_get_alignment_info.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_get_alignment_info.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_get_alignment_info.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,21 +1,21 @@ - - - - - -Getting Alignment and Type Information at Compile Time
-The C compiler has two built-in functions that return information about a data type’s byte alignment and its data type.
--
-
- The function call __builtin_align(typeID) returns the byte alignment used for the data type typeID. This value depends on the target platform for which the compiler is generating object code. -
- The function call __builtin_type(typeID) returns an integral value that describes the data type typeID. This value depends on the target platform for which the compiler is generating object code.
-
-
Getting Alignment and Type Information at Compile Time
+The C compiler has two built-in functions that return information about a data type’s byte alignment and its data type.
+-
+
- The function call __builtin_align(typeID) returns the byte alignment used for the data type typeID. This value depends on the target platform for which the compiler is generating object code. +
- The function call __builtin_type(typeID) returns an integral value that describes the data type typeID. This value depends on the target platform for which the compiler is generating object code.
+
+
Header Files
-(ISO C, §6.10.2) The Carbide C preprocessor lets you nest up to 256 levels of #include directives.
-You can use full path names in #include directives:
- -| System | -Directive | -
|---|---|
| Windows | -#include "c:\HD\Tools\my headers\macros.h" | -
| UNIX | -#include "/HD/Tools/my headers/macros.h" | -
The Carbide IDE lets you specify where the compiler looks for #include files through the Access Paths and Source Tree settings panels.
-See also Prefix Files.
-TIP If you are running the Carbide C compiler from the command line, you can specify where to find #include files with a command-line setting. For more information, see “Command-Line Tools”.
-
Header Files
+(ISO C, §6.10.2) The Carbide C preprocessor lets you nest up to 256 levels of #include directives.
+You can use full path names in #include directives:
+ +| System | +Directive | +
|---|---|
| Windows | +#include "c:\HD\Tools\my headers\macros.h" | +
| UNIX | +#include "/HD/Tools/my headers/macros.h" | +
The Carbide IDE lets you specify where the compiler looks for #include files through the Access Paths and Source Tree settings panels.
+See also Prefix Files.
+TIP If you are running the Carbide C compiler from the command line, you can specify where to find #include files with a command-line setting. For more information, see “Command-Line Tools”.
+
The Carbide Implementation of C
-This section describes how the Carbide C compiler implements the C programming language:
--
-
- Identifiers -
- Header Files -
- Precompiled Header Files -
- Prefix Files -
- Sizeof() Operator Data Type -
- Volatile Variables -
- Enumerated Types -
The Carbide Implementation of C
+This section describes how the Carbide C compiler implements the C programming language:
+-
+
- Identifiers +
- Header Files +
- Precompiled Header Files +
- Prefix Files +
- Sizeof() Operator Data Type +
- Volatile Variables +
- Enumerated Types +
Identifiers
-(ISO C, §6.4.2) The Carbide C language allows identifiers to have unlimited length. However, only the first 255 characters are significant for internal and external linkage.
- - - - - + + + + + +Identifiers
+(ISO C, §6.4.2) The Carbide C language allows identifiers to have unlimited length. However, only the first 255 characters are significant for internal and external linkage.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_init_local_arrays.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_init_local_arrays.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_init_local_arrays.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,25 +1,25 @@ - - - - - -Initialization of Local Arrays and Structures
-If you enable the pragma gcc_extensions, the compiler allows the initialization of local arrays and structs with non-constant values.
-
GNU C Extension for Initializing Arrays and Structures
-void myFunc( int i, double x )
- {
- int arr[2] = { i, i + 1 };
- struct myStruct = { i, x };
- }
Initialization of Local Arrays and Structures
+If you enable the pragma gcc_extensions, the compiler allows the initialization of local arrays and structs with non-constant values.
+
GNU C Extension for Initializing Arrays and Structures
+void myFunc( int i, double x )
+ {
+ int arr[2] = { i, i + 1 };
+ struct myStruct = { i, x };
+ }
Inlining
-Carbide supports inlining C/C++ functions that you define with the inline, __inline__, or __inline specifier keywords.
-The following functions are never inlined:
--
-
- Functions that return class objects that need destruction. -
- Functions with class arguments that need destruction. -
- Functions with variable argument lists. -
The compiler determines whether to inline a function based on the ANSI Strict, Inline Depth, Auto-inline, and Deferred Inlining settings.
-TIP When you call an inlined function, the compiler inserts the actual instructions of that function rather than a call to that function. Inlining functions makes your programs faster because you execute the function code immediately without the overhead of a function call and return. However, it can also make your program larger because the compiler may have to repeat the function code multiple times throughout your program.
-If you disable the ANSI Keywords Only setting, you can declare C functions to be inline.
-Table 1: Settings for the Inline Depth
-| This setting | -Does this… | -
|---|---|
| Don’t Inline | -Inlines no functions, not even C or C++ functions declared inline. | -
| Smart | -Inlines small functions to a depth of 2 to 4 inline functions deep. | -
| 1 to 8 | -Inlines to the depth specified by the numerical selection. | -
The Smart and 1 to 8 items in the Inline Depth dropdown menu correspond to the pragma inline_depth (inline_depth). To check this setting, use __option(inline_depth), described at Checking Settings.
-The Don’t Inline item corresponds to the pragma dont_inline. To check this setting, use __option (dont_inline). By default, this setting is disabled.
-The Auto-Inline setting lets the compiler choose which functions to inline. Also inlines C++ functions declared inline and member functions defined within a class declaration. This setting corresponds to the pragma auto_inline. To check this setting, use __option (auto_inline). By default, this setting is disabled.
-The Deferred Inlining setting tells the compiler to inline functions that are not yet defined. This setting corresponds to the pragma defer_codegen. To check this setting, use __option (defer_codegen).
-The Bottom-up Inlining settings tells the compiler to inline functions starting at the last function to the first function in a chain of function calls. This setting corresponds to the pragma inline_bottom_up. To check this setting, use __option (inline_bottom_up).
-You can also disable automatic inlining of specific functions within a source file using the __attribute__((never_inline)).
-Example __attribute__(never_inline)
-inline int f() __attribute__((never_inline))
- {
- return 10;
- }
int main()
- {
- return f(); // f() is never inlined
- }
NOTE For Intel x86 targets, the __decspec(noinline) is a compatible synonym.
- - - - - + + + + + +Inlining
+Carbide supports inlining C/C++ functions that you define with the inline, __inline__, or __inline specifier keywords.
+The following functions are never inlined:
+-
+
- Functions that return class objects that need destruction. +
- Functions with class arguments that need destruction. +
- Functions with variable argument lists. +
The compiler determines whether to inline a function based on the ANSI Strict, Inline Depth, Auto-inline, and Deferred Inlining settings.
+TIP When you call an inlined function, the compiler inserts the actual instructions of that function rather than a call to that function. Inlining functions makes your programs faster because you execute the function code immediately without the overhead of a function call and return. However, it can also make your program larger because the compiler may have to repeat the function code multiple times throughout your program.
+If you disable the ANSI Keywords Only setting, you can declare C functions to be inline.
+Table 1: Settings for the Inline Depth
+| This setting | +Does this… | +
|---|---|
| Don’t Inline | +Inlines no functions, not even C or C++ functions declared inline. | +
| Smart | +Inlines small functions to a depth of 2 to 4 inline functions deep. | +
| 1 to 8 | +Inlines to the depth specified by the numerical selection. | +
The Smart and 1 to 8 items in the Inline Depth dropdown menu correspond to the pragma inline_depth (inline_depth). To check this setting, use __option(inline_depth), described at Checking Settings.
+The Don’t Inline item corresponds to the pragma dont_inline. To check this setting, use __option (dont_inline). By default, this setting is disabled.
+The Auto-Inline setting lets the compiler choose which functions to inline. Also inlines C++ functions declared inline and member functions defined within a class declaration. This setting corresponds to the pragma auto_inline. To check this setting, use __option (auto_inline). By default, this setting is disabled.
+The Deferred Inlining setting tells the compiler to inline functions that are not yet defined. This setting corresponds to the pragma defer_codegen. To check this setting, use __option (defer_codegen).
+The Bottom-up Inlining settings tells the compiler to inline functions starting at the last function to the first function in a chain of function calls. This setting corresponds to the pragma inline_bottom_up. To check this setting, use __option (inline_bottom_up).
+You can also disable automatic inlining of specific functions within a source file using the __attribute__((never_inline)).
+Example __attribute__(never_inline)
+inline int f() __attribute__((never_inline))
+ {
+ return 10;
+ }
int main()
+ {
+ return f(); // f() is never inlined
+ }
NOTE For Intel x86 targets, the __decspec(noinline) is a compatible synonym.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_iso_extensions.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_iso_extensions.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_iso_extensions.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,49 +1,49 @@ - - - - - -Extensions to ISO C
-The Carbide C language optionally extends ISO C. In most cases, you can control these extensions using specific pragmas.
--
-
- Checking for Standard C and Standard C++ Conformity -
- C++ Comments -
- Unnamed Arguments in Function Definitions -
- A # Not Followed by a Macro Argument -
- Using an Identifier After #endif -
- Using Typecasted Pointers as lvalues -
- Declaring Variables by Address -
- ANSI Keywords Only -
- Expand Trigraphs -
- Character Constants as Integer Values -
- Inlining -
- Reusing Strings -
- Require Function Prototypes -
- Map Newlines to CR -
- Relaxed Pointer Type Rules -
- Use Unsigned Chars -
- Using long long Integers -
- Converting Pointers to Types of the Same Size -
- Getting Alignment and Type Information at Compile Time -
- Arrays of Zero Length in Structures -
- Intrinsic Functions for Bit Rotation -
- The “D” Constant Suffix -
- The short double Data Type -
- The __typeof__() and typeof() operators -
- Initialization of Local Arrays and Structures -
- Ranges in case statements -
- The __FUNCTION__ Predefined Identifier -
- GCC Extension Support -
- Multibyte and Unicode Support -
- The __declspec Declarator -
For information on target-specific extensions, refer to the Targeting manual for your particular target.
- - - - - + + + + + +Extensions to ISO C
+The Carbide C language optionally extends ISO C. In most cases, you can control these extensions using specific pragmas.
+-
+
- Checking for Standard C and Standard C++ Conformity +
- C++ Comments +
- Unnamed Arguments in Function Definitions +
- A # Not Followed by a Macro Argument +
- Using an Identifier After #endif +
- Using Typecasted Pointers as lvalues +
- Declaring Variables by Address +
- ANSI Keywords Only +
- Expand Trigraphs +
- Character Constants as Integer Values +
- Inlining +
- Reusing Strings +
- Require Function Prototypes +
- Map Newlines to CR +
- Relaxed Pointer Type Rules +
- Use Unsigned Chars +
- Using long long Integers +
- Converting Pointers to Types of the Same Size +
- Getting Alignment and Type Information at Compile Time +
- Arrays of Zero Length in Structures +
- Intrinsic Functions for Bit Rotation +
- The “D” Constant Suffix +
- The short double Data Type +
- The __typeof__() and typeof() operators +
- Initialization of Local Arrays and Structures +
- Ranges in case statements +
- The __FUNCTION__ Predefined Identifier +
- GCC Extension Support +
- Multibyte and Unicode Support +
- The __declspec Declarator +
For information on target-specific extensions, refer to the Targeting manual for your particular target.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_macro_args.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_macro_args.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_macro_args.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,25 +1,25 @@ - - - - - -A # Not Followed by a Macro Argument
-(ISO C, §6.10.3) The C compiler can accept # tokens that do not appear before arguments in macro definitions.
-Listing 1. Preprocessor Macros Using # Without an Argument
-#define add1(x) #x #1 // OK, but probably not what you wanted:
- // add1(abc) creates "abc"#1
- #define add2(x) #x "2" // OK: add2(abc) creates "abc2"
To use this feature, disable the ANSI Strict setting.
-See also “Checking for Standard C and Standard C++ Conformity”.
-
A # Not Followed by a Macro Argument
+(ISO C, §6.10.3) The C compiler can accept # tokens that do not appear before arguments in macro definitions.
+Listing 1. Preprocessor Macros Using # Without an Argument
+#define add1(x) #x #1 // OK, but probably not what you wanted:
+ // add1(abc) creates "abc"#1
+ #define add2(x) #x "2" // OK: add2(abc) creates "abc2"
To use this feature, disable the ANSI Strict setting.
+See also “Checking for Standard C and Standard C++ Conformity”.
+
Map Newlines to CR
-Use the #pragma mpwc_newline to set how the C compiler interprets the newline ('\n') and return ('\r') characters.
-Most compilers, including the Carbide C/C++ compilers, translate '\r' to 0x0D, the standard value for carriage return, and '\n' to 0x0A, the standard value for linefeed.
-However, a few C compilers translate '\r' to 0x0A and '\n' to 0x0D—the opposite of the typical behavior.
-If you enable this setting, the compiler uses these non-standard conventions for the '\n' and '\r' characters. Otherwise, the compiler uses the Carbide C/C++ language’s conventions for these characters.
-Also if you enable this setting, use ISO C/C++ libraries that were compiled when this setting was enabled. Otherwise, you cannot read and write '\n' and '\r' properly. For example, printing '\n' takes you to the beginning of the current line instead of inserting a new line.
-This setting corresponds to the pragma mpwc_newline. To check this setting, use __option (mpwc_newline). By default, this setting is disabled.
-See also “mpwc_newline”, and Checking Settings.
-
Map Newlines to CR
+Use the #pragma mpwc_newline to set how the C compiler interprets the newline ('\n') and return ('\r') characters.
+Most compilers, including the Carbide C/C++ compilers, translate '\r' to 0x0D, the standard value for carriage return, and '\n' to 0x0A, the standard value for linefeed.
+However, a few C compilers translate '\r' to 0x0A and '\n' to 0x0D—the opposite of the typical behavior.
+If you enable this setting, the compiler uses these non-standard conventions for the '\n' and '\r' characters. Otherwise, the compiler uses the Carbide C/C++ language’s conventions for these characters.
+Also if you enable this setting, use ISO C/C++ libraries that were compiled when this setting was enabled. Otherwise, you cannot read and write '\n' and '\r' properly. For example, printing '\n' takes you to the beginning of the current line instead of inserting a new line.
+This setting corresponds to the pragma mpwc_newline. To check this setting, use __option (mpwc_newline). By default, this setting is disabled.
+See also “mpwc_newline”, and Checking Settings.
+
Multibyte and Unicode Support
-The Carbide preprocessor fully supports the use of multibyte and Unicode-formatted source files.
-Source and header files may be encoded in any text encoding the operating system recognizes. (Unicode text decoding support is implemented using native OS services in Win32 and conv() on UNIX systems.)
-As per ISO C++98 and C99, universal characters may be used in any string or character literal, identifiers (macros, variables, functions, methods, etc.), and comments. These characters are derived either from multibyte sequences in the source text, by virtue of the source file being encoded in UCS-2 or UCS-4, or by use of the \uXXXX or \UXXXXXXXX escape sequences.
-Wide String Literals
-Wide string literals in the form L"xxx" and wide characters in the form L’xxx’ are interpreted in the context of the source text encoding.
-const wchar_t *str = L"Meine Katze ißt Mäuse nachts.";
-Multibyte character sequences that appear in strings are internally converted to their Unicode equivalents until the C/C++ token for the string is generated. At that time, if the string literal is a narrow string (i.e. using char), the original multibyte character sequence are emitted. If the string is a wide string (using wchar_t), the Unicode characters translated from the multibyte sequence are emitted. If wchar_t is 16 bits and a character is truncated to 16 bits, a warning is reported. (See ISO C99, §6.4.5.5 for the specification of this behavior.)
-In the event that you want translated – and usually truncated – Unicode characters in narrow string literals, enable #pragma multibyteaware_preserve_ literals off.
-Source Encoding
-The compiler uses the Source encoding option in to control how it detects the source file encoding. The compiler recognizes the following source encoding options:
--
-
- ASCII–no detection is done, the high-ASCII characters are not interpreted, and wide character strings are merely zero-extensions of the individual bytes in the string. -
- Autodetect–the compiler attempts to tell whether byte-encoded source is encoded in UTF-8, Shift-JIS, EUC-JP, ISO-2022-JP, or whichever encoding format the operating system considers the default. This option degrades compile speeds slightly due to the extra scanning. -
- System–the compiler uses the system locale without scanning the source. -
- UTF-8, Shift-JIS, EUC-JP, ISO-2022-JP– self-explanatory. -
NOTE Currently, the compiler ignores the mapping in some Japanese character sets of 0x5c (ASCII ‘\’) to Yen (\u00A5) because the C++98 and C99 standards say that the ASCII character set must be mapped one-to-one with any multibyte encoding. 0x5C is always interpreted as ‘\’ (except inside multibyte character sequences).
-NOTE The ISO-2022-JP and EUC-JP encoding currently only recognize characters defined by JIS X 0208-1990 (i.e., the escapes ESC $ @, ESC $ B for ISO-2022-JP and two-byte sequences in EUC-JP). The additional characters in JIS X 0212-1990 are not yet recognized.
-No matter what the Source encoding setting, the compiler always detects UTF-16{BE,LE} or UCS-4{BE,LE} source through a statistical character scan for NULs.
-NOTE Currently, only the command-line tools, not the IDE, can properly handle sources in Unicode format (UTF-16, UCS-2, UCS-4).
-Alternately, individual source files can identify which source text encoding is present using #pragma text_encoding. The format is:
- #pragma text_encoding("name" | unknown | reset [, global])
Where name is an IANA or MIME encoding name or an OS-specific string.
-The compiler recognizes these names and maps them to its internal decoders:
-system US-ASCII ASCII ANSI_X3.4-1968 ANSI_X3.4-1968
- ANSI_X3.4 UTF-8 UTF8 ISO-2022-JP CSISO2022JP ISO2022JP
- CSSHIFTJIS SHIFT-JIS SJIS EUC-JP EUCJP
- UCS-2 UCS-2BE UCS-2LE UCS2 UCS2BE UCS2LE UTF-16 U
- TF-16BE UTF-16LE UTF16 UTF16BE UTF16LE UCS-4 UCS-4BE
- UCS-4LE UCS4 UCS4BE UCS4LE 10646-1:1993 ISO-10646-1
- ISO-10646 unicode
NOTE UCS-2 is always interpreted as UTF-16; i.e. surrogate character pairs are used to select characters through plane 16.
-This #pragma may be used several times in one file (probably unlikely usage). The compiler expects the pragma to be encoded in the “current” text encoding, through the end of line.
-By default, #pragma text_encoding is only effective through the end of file. To affect the default text encoding assumed for the current and all subsequent files, supply the “global” modifier.
-
Other Support
-In addition, note the following:
--
-
- Specify Universal character names (i.e. Unicode code points) with the \uXXXX or \UXXXXXXXX escape sequences: -
--wchar_t florette = L’\u273f’;
-
- int \u30AD\u30B3\u30DE\u30A6 = soy_sauce();
-
-
- You can use \uXXXX or \UXXXXXXXX regardless of the actual size of wchar_t (use of the escape does not impose a character width on the literal). -
- Preprocessed text is always emitted in ASCII. Wide characters are emitted in the \uXXXX or \UXXXXXXXX format. -
--extern string *Wörter[];
-
- -->
- extern string *W\u00F6rter[];
-
-
- Identifiers using characters not representable in ASCII are emitted in object code with the \uXXXX or \UXXXXXXXX escape sequences. If an object format does not support the ‘\\’ character, the encoding may be modified on a target-specific basis. -
Also see “Character Constants as Integer Values” for information on creating a character constant consisting of more than one character (not to be confused with this topic).
-For more information on Unicode, see www.unicode.org.
- - - - - + + + + + +Multibyte and Unicode Support
+The Carbide preprocessor fully supports the use of multibyte and Unicode-formatted source files.
+Source and header files may be encoded in any text encoding the operating system recognizes. (Unicode text decoding support is implemented using native OS services in Win32 and conv() on UNIX systems.)
+As per ISO C++98 and C99, universal characters may be used in any string or character literal, identifiers (macros, variables, functions, methods, etc.), and comments. These characters are derived either from multibyte sequences in the source text, by virtue of the source file being encoded in UCS-2 or UCS-4, or by use of the \uXXXX or \UXXXXXXXX escape sequences.
+Wide String Literals
+Wide string literals in the form L"xxx" and wide characters in the form L’xxx’ are interpreted in the context of the source text encoding.
+const wchar_t *str = L"Meine Katze ißt Mäuse nachts.";
+Multibyte character sequences that appear in strings are internally converted to their Unicode equivalents until the C/C++ token for the string is generated. At that time, if the string literal is a narrow string (i.e. using char), the original multibyte character sequence are emitted. If the string is a wide string (using wchar_t), the Unicode characters translated from the multibyte sequence are emitted. If wchar_t is 16 bits and a character is truncated to 16 bits, a warning is reported. (See ISO C99, §6.4.5.5 for the specification of this behavior.)
+In the event that you want translated – and usually truncated – Unicode characters in narrow string literals, enable #pragma multibyteaware_preserve_ literals off.
+Source Encoding
+The compiler uses the Source encoding option in to control how it detects the source file encoding. The compiler recognizes the following source encoding options:
+-
+
- ASCII–no detection is done, the high-ASCII characters are not interpreted, and wide character strings are merely zero-extensions of the individual bytes in the string. +
- Autodetect–the compiler attempts to tell whether byte-encoded source is encoded in UTF-8, Shift-JIS, EUC-JP, ISO-2022-JP, or whichever encoding format the operating system considers the default. This option degrades compile speeds slightly due to the extra scanning. +
- System–the compiler uses the system locale without scanning the source. +
- UTF-8, Shift-JIS, EUC-JP, ISO-2022-JP– self-explanatory. +
NOTE Currently, the compiler ignores the mapping in some Japanese character sets of 0x5c (ASCII ‘\’) to Yen (\u00A5) because the C++98 and C99 standards say that the ASCII character set must be mapped one-to-one with any multibyte encoding. 0x5C is always interpreted as ‘\’ (except inside multibyte character sequences).
+NOTE The ISO-2022-JP and EUC-JP encoding currently only recognize characters defined by JIS X 0208-1990 (i.e., the escapes ESC $ @, ESC $ B for ISO-2022-JP and two-byte sequences in EUC-JP). The additional characters in JIS X 0212-1990 are not yet recognized.
+No matter what the Source encoding setting, the compiler always detects UTF-16{BE,LE} or UCS-4{BE,LE} source through a statistical character scan for NULs.
+NOTE Currently, only the command-line tools, not the IDE, can properly handle sources in Unicode format (UTF-16, UCS-2, UCS-4).
+Alternately, individual source files can identify which source text encoding is present using #pragma text_encoding. The format is:
+ #pragma text_encoding("name" | unknown | reset [, global])
Where name is an IANA or MIME encoding name or an OS-specific string.
+The compiler recognizes these names and maps them to its internal decoders:
+system US-ASCII ASCII ANSI_X3.4-1968 ANSI_X3.4-1968
+ ANSI_X3.4 UTF-8 UTF8 ISO-2022-JP CSISO2022JP ISO2022JP
+ CSSHIFTJIS SHIFT-JIS SJIS EUC-JP EUCJP
+ UCS-2 UCS-2BE UCS-2LE UCS2 UCS2BE UCS2LE UTF-16 U
+ TF-16BE UTF-16LE UTF16 UTF16BE UTF16LE UCS-4 UCS-4BE
+ UCS-4LE UCS4 UCS4BE UCS4LE 10646-1:1993 ISO-10646-1
+ ISO-10646 unicode
NOTE UCS-2 is always interpreted as UTF-16; i.e. surrogate character pairs are used to select characters through plane 16.
+This #pragma may be used several times in one file (probably unlikely usage). The compiler expects the pragma to be encoded in the “current” text encoding, through the end of line.
+By default, #pragma text_encoding is only effective through the end of file. To affect the default text encoding assumed for the current and all subsequent files, supply the “global” modifier.
+
Other Support
+In addition, note the following:
+-
+
- Specify Universal character names (i.e. Unicode code points) with the \uXXXX or \UXXXXXXXX escape sequences: +
++wchar_t florette = L’\u273f’;
+
+ int \u30AD\u30B3\u30DE\u30A6 = soy_sauce();
-
+
- You can use \uXXXX or \UXXXXXXXX regardless of the actual size of wchar_t (use of the escape does not impose a character width on the literal). +
- Preprocessed text is always emitted in ASCII. Wide characters are emitted in the \uXXXX or \UXXXXXXXX format. +
++extern string *Wörter[];
+
+ -->
+ extern string *W\u00F6rter[];
-
+
- Identifiers using characters not representable in ASCII are emitted in object code with the \uXXXX or \UXXXXXXXX escape sequences. If an object format does not support the ‘\\’ character, the encoding may be modified on a target-specific basis. +
Also see “Character Constants as Integer Values” for information on creating a character constant consisting of more than one character (not to be confused with this topic).
+For more information on Unicode, see www.unicode.org.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_pool_strings.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_pool_strings.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_pool_strings.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,26 +1,26 @@ - - - - - -Pool Strings
-The Pool Strings setting controls how the compiler stores string constants.
-NOTE In principle, this setting works for all targets. However, it is useful only for a Table of Contents based linking mechanism such as that used for MacOS Classic on the PowerPC processor.
-If you enable this setting, the compiler collects all string constants into a single data object so that your program needs only one TOC entry for all of them. While this decreases the number of TOC entries in your program, it also increases your program size because it uses a less efficient method to store the address of the string.
-If you disable this setting, the compiler creates a unique data object and TOC entry for each string constant.
-TIP You can change the size of the TOC with the Store Static Data in TOC setting in the PPC Processor panel.
-NOTE This option can be overridden in PPC targets by using the Linker Pool Strings or Linker Merges String Constants options.
-Enable this setting if your program is large and has many string constants.
-NOTE If you enable the Pool Strings setting, the compiler ignores the PC-Relative Strings setting. This is a 68K-only feature.
-The Pool Strings setting corresponds to the pragma pool_strings. To check this setting, use __option (pool_strings). By default, this setting is disabled.
-See also “pool_strings” and Checking Settings.
-
Pool Strings
+The Pool Strings setting controls how the compiler stores string constants.
+NOTE In principle, this setting works for all targets. However, it is useful only for a Table of Contents based linking mechanism such as that used for MacOS Classic on the PowerPC processor.
+If you enable this setting, the compiler collects all string constants into a single data object so that your program needs only one TOC entry for all of them. While this decreases the number of TOC entries in your program, it also increases your program size because it uses a less efficient method to store the address of the string.
+If you disable this setting, the compiler creates a unique data object and TOC entry for each string constant.
+TIP You can change the size of the TOC with the Store Static Data in TOC setting in the PPC Processor panel.
+NOTE This option can be overridden in PPC targets by using the Linker Pool Strings or Linker Merges String Constants options.
+Enable this setting if your program is large and has many string constants.
+NOTE If you enable the Pool Strings setting, the compiler ignores the PC-Relative Strings setting. This is a 68K-only feature.
+The Pool Strings setting corresponds to the pragma pool_strings. To check this setting, use __option (pool_strings). By default, this setting is disabled.
+See also “pool_strings” and Checking Settings.
+
Precompiled Header Files
-A precompiled header is an image of the compiler’s symbol table. Create a precompiled header file for commonly included files. You can also use a precompiled header file to temporarily change header files that do not normally change otherwise (for example, OS ABI headers or standard ANSI library header files). Then replace the original header files with the precompiled header file to significantly improve compile time.
-A precompiled header cannot do any of the following:
--
-
- Define non-inline functions -
- Define global data -
- Instantiate template data -
- Instantiate non-inline functions -
You must include precompiled headers before defining or declaring other objects. You can only use one precompiled header file in a translation unit.
-See also “precompile_target”.
- - - - - + + + + + +Precompiled Header Files
+A precompiled header is an image of the compiler’s symbol table. Create a precompiled header file for commonly included files. You can also use a precompiled header file to temporarily change header files that do not normally change otherwise (for example, OS ABI headers or standard ANSI library header files). Then replace the original header files with the precompiled header file to significantly improve compile time.
+A precompiled header cannot do any of the following:
+-
+
- Define non-inline functions +
- Define global data +
- Instantiate template data +
- Instantiate non-inline functions +
You must include precompiled headers before defining or declaring other objects. You can only use one precompiled header file in a translation unit.
+See also “precompile_target”.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_prefix_files.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_prefix_files.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_prefix_files.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,28 +1,28 @@ - - - - - -Prefix Files
-In previous Carbide compilers, the prefix file was a distinct setting that told the compiler to include a source code file at the beginning of each source code file in a project’s build target, or include a precompiled header file into the project.
-With this compiler release, the concept of prefixing files, #defines, and #pragmas has been extended.
-To specify a prefix file, add an #include directive to this field, for example:
-#include "Win32Headers.h"
-To specify #defines or #pragmas, enter them here as you would in source code:
-#define DEBUG_BUILD 1
- #pragma warn_illtokenpasting off
When building precompiled headers, note the Include prefix text in precompiled headers setting. When enabled, the contents of the Prefix Text are used to generate the precompiled header. If your project generates a precompiled header in the same target that uses it, follow the form:
-#if !__option(precompile)
- #include "MyHeaders.mch"
- #endif
to exclude the *.mch file when generating it.
-NOTE #pragmas may affect aspects of parsing and type declaration while building a precompiled header, but these settings are not retained in the body of the precompiled header. Thus the prefix text is used for every file in the target.
- - - - - + + + + + +Prefix Files
+In previous Carbide compilers, the prefix file was a distinct setting that told the compiler to include a source code file at the beginning of each source code file in a project’s build target, or include a precompiled header file into the project.
+With this compiler release, the concept of prefixing files, #defines, and #pragmas has been extended.
+To specify a prefix file, add an #include directive to this field, for example:
+#include "Win32Headers.h"
+To specify #defines or #pragmas, enter them here as you would in source code:
+#define DEBUG_BUILD 1
+ #pragma warn_illtokenpasting off
When building precompiled headers, note the Include prefix text in precompiled headers setting. When enabled, the contents of the Prefix Text are used to generate the precompiled header. If your project generates a precompiled header in the same target that uses it, follow the form:
+#if !__option(precompile)
+ #include "MyHeaders.mch"
+ #endif
to exclude the *.mch file when generating it.
+NOTE #pragmas may affect aspects of parsing and type declaration while building a precompiled header, but these settings are not retained in the body of the precompiled header. Thus the prefix text is used for every file in the target.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_ranged_cases.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_ranged_cases.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_ranged_cases.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,35 +1,35 @@ - - - - - -Ranges in case statements
-If you disable the ANSI Strict setting, the compiler allows ranges of values in a switch statement by using a special form of case statement. A case statement that uses a range is a shorter way of specifying consecutive case statements that span a range of values.
-The range form of a case statement is
-case low ... high : // note spaces around ellipsis character
-where low is a valid case expression that is less than high, which is also a valid case expression. A case statement that uses a range is applied when the expression of a switch statement is both greater than or equal to the low expression and less than or equal to the high expression.
-NOTE Make sure to separate the ellipsis (...) from the low and high expressions with spaces.
-Listing 1. Ranges in case Statements
-switch (i)
- {
- case 0 ... 2: /* Equivalent to case 0: case 1: case 2: */
- j = i * 2;
- break;
- case 3:
- j = i;
- break;
- default:
- j = 0;
- break;
- }
Ranges in case statements
+If you disable the ANSI Strict setting, the compiler allows ranges of values in a switch statement by using a special form of case statement. A case statement that uses a range is a shorter way of specifying consecutive case statements that span a range of values.
+The range form of a case statement is
+case low ... high : // note spaces around ellipsis character
+where low is a valid case expression that is less than high, which is also a valid case expression. A case statement that uses a range is applied when the expression of a switch statement is both greater than or equal to the low expression and less than or equal to the high expression.
+NOTE Make sure to separate the ellipsis (...) from the low and high expressions with spaces.
+Listing 1. Ranges in case Statements
+switch (i)
+ {
+ case 0 ... 2: /* Equivalent to case 0: case 1: case 2: */
+ j = i * 2;
+ break;
+ case 3:
+ j = i;
+ break;
+ default:
+ j = 0;
+ break;
+ }
Relaxed Pointer Type Rules
-Use the #pragma mpwc_relax to tell the compiler to treat all pointer types as the same type. While the compiler verifies the parameters of function prototypes for compatible pointer types, it allows direct pointer assignments.
-Use this setting if you are using code written before the ISO C standard. Old source code frequently uses these types interchangeably.
-This setting has no effect on C++. When compiling C++ source code, the compiler differentiates char* and unsigned char* data types even if the relaxed pointer setting is enabled.
- See also “mpwc_relax”, and Checking Settings.
-
Relaxed Pointer Type Rules
+Use the #pragma mpwc_relax to tell the compiler to treat all pointer types as the same type. While the compiler verifies the parameters of function prototypes for compatible pointer types, it allows direct pointer assignments.
+Use this setting if you are using code written before the ISO C standard. Old source code frequently uses these types interchangeably.
+This setting has no effect on C++. When compiling C++ source code, the compiler differentiates char* and unsigned char* data types even if the relaxed pointer setting is enabled.
+ See also “mpwc_relax”, and Checking Settings.
+
Require Function Prototypes
-(ISO C, §6.7.5.3, §6.9.1) The C compiler lets you choose how to enforce function prototypes. The Require Function Prototypes setting controls this behavior.
-If you enable the Require Function Prototypes setting, the compiler generates an error if you define a previously referenced function that does not have a prototype. If you define the function before it is referenced but do not give it a prototype, then enabling the Require Function Prototypes setting causes the compiler to issue a warning.
-This setting helps you prevent errors that happen when you call a function before you declare or define it. For example, without a function prototype, you might pass data of the wrong type. As a result, your code might not work as you expect even though it compiles without error.
-In Listing 1, PrintNum() is called with an integer argument but later defined to take a floating-point argument.
-Listing 1. Unnoticed Type-mismatch
-#include <stdio.h>
- void main(void)
- {
- PrintNum(1); // PrintNum() tries to interpret the
- integer as a float. Prints 0.000000.
- }
void PrintNum(float x)
- {
- printf("%f\n", x);
- }
When you run this program, you could get this result:
-0.000000
-Although the compiler does not complain about the type mismatch, the function does not work as you want. Since PrintNum() does not have a prototype, the compiler does not know to convert the integer to a floating-point number before calling the function. Instead, the function interprets the bits it received as a floating-point number and prints nonsense.
-If you prototype PrintNum() first, as in Listing 2, the compiler converts its argument to a floating-point number, and the function prints what you wanted.
-Listing 2. Using a Prototype to Avoid Type-mismatch
-#include <stdio.h>
- void PrintNum(float x); // Function prototype.
void main(void)
- {
- PrintNum(1); // Compiler converts int to float.
- } // Prints 1.000000.
void PrintNum(float x)
- {
- printf("%f\n", x);
- }
In the above example, the compiler automatically typecasts the passed value. In other situations where automatic typecasting is not available, the compiler generates an error if an argument does not match the data type required by a function prototype. Such a mismatched data type error is easy to locate at compile time. If you do not use prototypes, you do not get a compiler error.
-However, at runtime the code might produce an unexpected result whose cause can be extremely difficult to find.
-The Require Function Prototypes setting corresponds to the pragma require_prototypes. To check this setting, use __option (require_prototypes). By default, this setting is enabled.
-See also “require_prototypes”, and Checking Settings.
-
Require Function Prototypes
+(ISO C, §6.7.5.3, §6.9.1) The C compiler lets you choose how to enforce function prototypes. The Require Function Prototypes setting controls this behavior.
+If you enable the Require Function Prototypes setting, the compiler generates an error if you define a previously referenced function that does not have a prototype. If you define the function before it is referenced but do not give it a prototype, then enabling the Require Function Prototypes setting causes the compiler to issue a warning.
+This setting helps you prevent errors that happen when you call a function before you declare or define it. For example, without a function prototype, you might pass data of the wrong type. As a result, your code might not work as you expect even though it compiles without error.
+In Listing 1, PrintNum() is called with an integer argument but later defined to take a floating-point argument.
+Listing 1. Unnoticed Type-mismatch
+#include <stdio.h>
+ void main(void)
+ {
+ PrintNum(1); // PrintNum() tries to interpret the
+ integer as a float. Prints 0.000000.
+ }
void PrintNum(float x)
+ {
+ printf("%f\n", x);
+ }
When you run this program, you could get this result:
+0.000000
+Although the compiler does not complain about the type mismatch, the function does not work as you want. Since PrintNum() does not have a prototype, the compiler does not know to convert the integer to a floating-point number before calling the function. Instead, the function interprets the bits it received as a floating-point number and prints nonsense.
+If you prototype PrintNum() first, as in Listing 2, the compiler converts its argument to a floating-point number, and the function prints what you wanted.
+Listing 2. Using a Prototype to Avoid Type-mismatch
+#include <stdio.h>
+ void PrintNum(float x); // Function prototype.
void main(void)
+ {
+ PrintNum(1); // Compiler converts int to float.
+ } // Prints 1.000000.
void PrintNum(float x)
+ {
+ printf("%f\n", x);
+ }
In the above example, the compiler automatically typecasts the passed value. In other situations where automatic typecasting is not available, the compiler generates an error if an argument does not match the data type required by a function prototype. Such a mismatched data type error is easy to locate at compile time. If you do not use prototypes, you do not get a compiler error.
+However, at runtime the code might produce an unexpected result whose cause can be extremely difficult to find.
+The Require Function Prototypes setting corresponds to the pragma require_prototypes. To check this setting, use __option (require_prototypes). By default, this setting is enabled.
+See also “require_prototypes”, and Checking Settings.
+
Reusing Strings
-The Reuse Strings setting controls how the compiler stores string literals.
-If you enable this setting, the compiler stores each string literal separately. Otherwise, the compiler stores only one copy of identical string literals. This means if you change one of the strings, you change them all. For example, take this code snippet:
-char *str1="Hello";
- char *str2="Hello"; // two identical strings
- *str2 = 'Y';
This setting helps you save memory if your program contains identical string literals which you do not modify.
-If you enable the Reuse Strings setting, the strings are stored separately. After changing the first character, str1 is still "Hello", but str2 is "Yello".
-If you disable the Reuse Strings setting, the two strings are stored in one memory location because they are identical. After changing the first character, both str1 and str2 are "Yello", which is counterintuitive and can create bugs that are difficult to locate.
-The Reuse Strings setting corresponds to the pragma dont_reuse_strings. To check this setting, use __option (dont_reuse_strings). By default, this setting is enabled, so strings are not reused.
-See also dont_reuse_strings. and Checking Settings.
-
Reusing Strings
+The Reuse Strings setting controls how the compiler stores string literals.
+If you enable this setting, the compiler stores each string literal separately. Otherwise, the compiler stores only one copy of identical string literals. This means if you change one of the strings, you change them all. For example, take this code snippet:
+char *str1="Hello";
+ char *str2="Hello"; // two identical strings
+ *str2 = 'Y';
This setting helps you save memory if your program contains identical string literals which you do not modify.
+If you enable the Reuse Strings setting, the strings are stored separately. After changing the first character, str1 is still "Hello", but str2 is "Yello".
+If you disable the Reuse Strings setting, the two strings are stored in one memory location because they are identical. After changing the first character, both str1 and str2 are "Yello", which is counterintuitive and can create bugs that are difficult to locate.
+The Reuse Strings setting corresponds to the pragma dont_reuse_strings. To check this setting, use __option (dont_reuse_strings). By default, this setting is enabled, so strings are not reused.
+See also dont_reuse_strings. and Checking Settings.
+
The short double Data Type
-The short double data type is no longer supported for most targets. -
- - - - - + + + + + +The short double Data Type
+The short double data type is no longer supported for most targets. +
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_sizeof_type.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_sizeof_type.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_sizeof_type.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,19 +1,19 @@ - - - - - -Sizeof() Operator Data Type
-The sizeof() operator returns the size of a variable or type in bytes. The data type of this size is size_t, which the compiler declares in the file stddef.h. If your source code assumes that sizeof() returns a number of type int, it might not work correctly.
-NOTE The compiler evaluates the value returned by sizeof() only at compile time, not runtime.
-NOTE The sizeof() operator is not intended to work in preprocessor #if/#elif directives.
-
Sizeof() Operator Data Type
+The sizeof() operator returns the size of a variable or type in bytes. The data type of this size is size_t, which the compiler declares in the file stddef.h. If your source code assumes that sizeof() returns a number of type int, it might not work correctly.
+NOTE The compiler evaluates the value returned by sizeof() only at compile time, not runtime.
+NOTE The sizeof() operator is not intended to work in preprocessor #if/#elif directives.
+
Checking for Standard C and Standard C++ Conformity
-The ANSI Strict setting affects several C language extensions made by the Carbide C compiler:
--
-
- C++ Comments -
- Unnamed Arguments in Function Definitions -
- A # Not Followed by a Macro Argument -
- Using an Identifier After #endif -
- Using Typecasted Pointers as lvalues -
- Converting Pointers to Types of the Same Size -
- Arrays of Zero Length in Structures -
- The “D” Constant Suffix -
If you enable the ANSI Strict setting, the compiler disables all of the above ANSI C language extensions. You cannot enable individual extensions that are controlled by the ANSI Strict setting.
-This setting might affect how the compiler handles enumerated constants. See Enumerated Types for more information. It might also affect the declaration of the main() function for C++ programs. See “Implicit Return Statement for main()”.
-The ANSI Strict setting corresponds to the pragma ANSI_strict. To check this setting, use __option (ANSI_strict). See also “ANSI_strict” and Checking Settings. -
- - - - - + + + + + +Checking for Standard C and Standard C++ Conformity
+The ANSI Strict setting affects several C language extensions made by the Carbide C compiler:
+-
+
- C++ Comments +
- Unnamed Arguments in Function Definitions +
- A # Not Followed by a Macro Argument +
- Using an Identifier After #endif +
- Using Typecasted Pointers as lvalues +
- Converting Pointers to Types of the Same Size +
- Arrays of Zero Length in Structures +
- The “D” Constant Suffix +
If you enable the ANSI Strict setting, the compiler disables all of the above ANSI C language extensions. You cannot enable individual extensions that are controlled by the ANSI Strict setting.
+This setting might affect how the compiler handles enumerated constants. See Enumerated Types for more information. It might also affect the declaration of the main() function for C++ programs. See “Implicit Return Statement for main()”.
+The ANSI Strict setting corresponds to the pragma ANSI_strict. To check this setting, use __option (ANSI_strict). See also “ANSI_strict” and Checking Settings. +
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_typecast_ptrs.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_typecast_ptrs.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_typecast_ptrs.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,23 +1,23 @@ - - - - - -Using Typecasted Pointers as lvalues
-The C compiler can accept pointers that are typecasted to other pointer types as lvalues.
-Listing 1. Example of a Typecasted Pointer as an lvalue
-char *cp;
- ((long *) cp)++; /* OK if ANSI Strict is disabled. */
See also “Checking for Standard C and Standard C++ Conformity”.
-
Using Typecasted Pointers as lvalues
+The C compiler can accept pointers that are typecasted to other pointer types as lvalues.
+Listing 1. Example of a Typecasted Pointer as an lvalue
+char *cp;
+ ((long *) cp)++; /* OK if ANSI Strict is disabled. */
See also “Checking for Standard C and Standard C++ Conformity”.
+
The __typeof__() and typeof() operators
-With the __typeof__() operator, the compiler lets you specify the data type of an expression. Listing 1 shows an example.
-__typeof__(expression)
-where expression is any valid C expression or data type. Because the compiler translates a __typeof__() expression into a data type, you can use this expression wherever a normal type would be specified.
-Like the sizeof() operator, __typeof__() is only evaluated at compile time, not at runtime. For related information, see “Sizeof() Operator Data Type”.
-If you enable the gcc_extensions pragma, the typeof() operator is equivalent to the __typeof__() operator.
-Listing 1. Example of __typeof__() and typeof() Operators
-char *cp;
- int *ip;
- long *lp;
__typeof__(*ip) i; /* equivalent to "int i;" */
- __typeof__(*lp) l; /* equivalent to "long l;" */
#pragma gcc_extensions on
- typeof(*cp) c; /* equivalent to "char c;" */
-
The __typeof__() and typeof() operators
+With the __typeof__() operator, the compiler lets you specify the data type of an expression. Listing 1 shows an example.
+__typeof__(expression)
+where expression is any valid C expression or data type. Because the compiler translates a __typeof__() expression into a data type, you can use this expression wherever a normal type would be specified.
+Like the sizeof() operator, __typeof__() is only evaluated at compile time, not at runtime. For related information, see “Sizeof() Operator Data Type”.
+If you enable the gcc_extensions pragma, the typeof() operator is equivalent to the __typeof__() operator.
+Listing 1. Example of __typeof__() and typeof() Operators
+char *cp;
+ int *ip;
+ long *lp;
__typeof__(*ip) i; /* equivalent to "int i;" */
+ __typeof__(*lp) l; /* equivalent to "long l;" */
#pragma gcc_extensions on
+ typeof(*cp) c; /* equivalent to "char c;" */
+
Unnamed Arguments in Function Definitions
-(ISO C, §6.9.1) The C compiler can accept unnamed arguments in a function definition.
-Listing 1. Unnamed Function Arguments
-void f(int ) {} /* OK if ANSI Strict is disabled */
- void f(int i) {} /* ALWAYS OK */
See also: Checking for Standard C and Standard C++ Conformity.
-
Unnamed Arguments in Function Definitions
+(ISO C, §6.9.1) The C compiler can accept unnamed arguments in a function definition.
+Listing 1. Unnamed Function Arguments
+void f(int ) {} /* OK if ANSI Strict is disabled */
+ void f(int i) {} /* ALWAYS OK */
See also: Checking for Standard C and Standard C++ Conformity.
+
Use Unsigned Chars
-The C compiler treats a char declaration as an unsigned char declaration.
-The Use Unsigned Chars setting corresponds to the pragma unsigned_char. To check this setting, use __option (unsigned_char). By default, this setting is disabled.
-See also “unsigned_char” and Checking Settings. -
- - - - - + + + + + +Use Unsigned Chars
+The C compiler treats a char declaration as an unsigned char declaration.
+The Use Unsigned Chars setting corresponds to the pragma unsigned_char. To check this setting, use __option (unsigned_char). By default, this setting is disabled.
+See also “unsigned_char” and Checking Settings. +
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_use_longlong.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_use_longlong.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/c_compiler/c_use_longlong.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,22 +1,22 @@ - - - - - -Using long long Integers
-The C compiler allows the type specifier long long. The longlong pragma controls this behavior and has no corresponding item .
-If this setting is off, using long long causes a syntax error.
-In an enumerated type, you can use an enumerator large enough for a long long. For more information, see Enumerated Types.
-However, long long bitfields are not supported.
-You control the long long type with #pragma longlong. To check this setting, use __option (longlong). By default, this pragma is on.
-See also longlong and Checking Settings.
-
Using long long Integers
+The C compiler allows the type specifier long long. The longlong pragma controls this behavior and has no corresponding item .
+If this setting is off, using long long causes a syntax error.
+In an enumerated type, you can use an enumerator large enough for a long long. For more information, see Enumerated Types.
+However, long long bitfields are not supported.
+You control the long long type with #pragma longlong. To check this setting, use __option (longlong). By default, this pragma is on.
+See also longlong and Checking Settings.
+
Volatile Variables
-(ISO C, §6.7.3) When you declare a volatile variable, the Carbide C compiler takes the following precautions to respect the value of the variable:
--
-
- The compiler stores commonly used variables in processor registers to produce faster object code. However, the compiler never stores the value of a volatile variable in a processor register. -
- The compiler uses its common sub-expression optimization to compute the addresses of commonly used variables and the results of often-used expressions once at the beginning of a function to produce faster object code. However, every time an expression uses a volatile variable, the compiler computes both the address of the volatile variable and the results of the expression that uses it. -
Listing 1 shows an example of volatile variables.
-Listing 1. Volatile Variables
-void main(void)
- {
- int i[100];
- volatile int a, b; /* a and b are not cached in registers. */
a = 5;
- b = 20;
i[a + b] = 15; /* compiler calculates a + b */
- i[a + b] = 30; /* compiler recalculates a + b */
- }
The compiler does not place the value of a, b, or a+b in registers. But it does recalculate a+b in both assignment statements.
-
Volatile Variables
+(ISO C, §6.7.3) When you declare a volatile variable, the Carbide C compiler takes the following precautions to respect the value of the variable:
+-
+
- The compiler stores commonly used variables in processor registers to produce faster object code. However, the compiler never stores the value of a volatile variable in a processor register. +
- The compiler uses its common sub-expression optimization to compute the addresses of commonly used variables and the results of often-used expressions once at the beginning of a function to produce faster object code. However, every time an expression uses a volatile variable, the compiler computes both the address of the volatile variable and the results of the expression that uses it. +
Listing 1 shows an example of volatile variables.
+Listing 1. Volatile Variables
+void main(void)
+ {
+ int i[100];
+ volatile int a, b; /* a and b are not cached in registers. */
a = 5;
+ b = 20;
i[a + b] = 15; /* compiler calculates a + b */
+ i[a + b] = 30; /* compiler recalculates a + b */
+ }
The compiler does not place the value of a, b, or a+b in registers. But it does recalculate a+b in both assignment statements.
+
Arrays of Zero Length in Structures
-If you disable the ANSI Strict setting , the compiler lets you specify an array of no length as the last item in a structure. Listing 1 shows an example. You can define arrays with zero as the index value or with no index value.
-Listing 1. Using Zero-length Arrays
-struct listOfLongs {
- long listCount;
- long list[0]; // OK if ANSI Strict is disabled, [] is OK, too.
- }
-
Arrays of Zero Length in Structures
+If you disable the ANSI Strict setting , the compiler lets you specify an array of no length as the last item in a structure. Listing 1 shows an example. You can define arrays with zero as the index value or with no index value.
+Listing 1. Using Zero-length Arrays
+struct listOfLongs {
+ long listCount;
+ long list[0]; // OK if ANSI Strict is disabled, [] is OK, too.
+ }
+
Help and Administrative Options
-This section provides examples of how to retrieve general and help information from the command-line tools.
-For example, to obtain help information from a tool that has some compatibility options with Visual C++, type the following command:
-mwccsym2 -?
-To get more specific information from the same tool, type the following command:
-mwccsym2 -help [argument,...]
-where argument is a valid keyword such as usage, all, or this. For example, with the Windows® x86 C/C++ compiler, typing:
-mwccsym2 -help usage
-or
-mwccsym2 -help opt=help
-provides information about the help options available with the mwccsym2 x86 tool.
-
Help and Administrative Options
+This section provides examples of how to retrieve general and help information from the command-line tools.
+For example, to obtain help information from a tool that has some compatibility options with Visual C++, type the following command:
+mwccsym2 -?
+To get more specific information from the same tool, type the following command:
+mwccsym2 -help [argument,...]
+where argument is a valid keyword such as usage, all, or this. For example, with the Windows® x86 C/C++ compiler, typing:
+mwccsym2 -help usage
+or
+mwccsym2 -help opt=help
+provides information about the help options available with the mwccsym2 x86 tool.
+
Command-Line Settings Conventions
-In all cases, text in brackets ([]) is optional, although the brackets themselves never appear in the actual command. For example, the command -str[ings] pool can mean either:
--strings pool
-or
--str pool
-Where an option has several possible permutations, the possibilities are separated by the pipe (|) character. For example:
--sym on|off|full|fullpath
-means the -sym command can be followed by one or more of the following options: on, off, full, or fullpath. If you have more than one option, separate each option with a comma. So you might have -sym on, -sym off, -sym full, or -sym on, fullpath.
-The plus sign (+) means that the parameter to an option must not be separated from the option name by a space. For example,
--D+name[=value]
-means that you can have -DVAR or -DVAR=3, but not -D VAR.
-In cases where you provide a variable parameter such as a file name, that item is in italic text. For example, -precompile filename means you must provide a file name. The help text that corresponds to the compiler option explains what you must provide.
- - - - - + + + + + +Command-Line Settings Conventions
+In all cases, text in brackets ([]) is optional, although the brackets themselves never appear in the actual command. For example, the command -str[ings] pool can mean either:
+-strings pool
+or
+-str pool
+Where an option has several possible permutations, the possibilities are separated by the pipe (|) character. For example:
+-sym on|off|full|fullpath
+means the -sym command can be followed by one or more of the following options: on, off, full, or fullpath. If you have more than one option, separate each option with a comma. So you might have -sym on, -sym off, -sym full, or -sym on, fullpath.
+The plus sign (+) means that the parameter to an option must not be separated from the option name by a space. For example,
+-D+name[=value]
+means that you can have -DVAR or -DVAR=3, but not -D VAR.
+In cases where you provide a variable parameter such as a file name, that item is in italic text. For example, -precompile filename means you must provide a file name. The help text that corresponds to the compiler option explains what you must provide.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cmd_line/cmd_env_vars.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cmd_line/cmd_env_vars.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cmd_line/cmd_env_vars.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,38 +1,38 @@ - - - - - -Working with Environment Variables
-To use the command-line tools, you must change several environment variables. If you are using Carbide command-line tools with Microsoft® Windows®, you can assign environment variables through the Environment tab under the System control panel in Windows XP/2000/NT.
-CWFolder Environment Variable
-Use the following syntax when defining variables in batch files or on the command line:
-set CWFolder=C:\Program Files\Carbide
-In this example, CWFolder refers to the path where you installed Carbide. It is not necessary to include quotation marks when defining environment variables that include spaces. Because Windows does not strip out the quotes, this leads to unknown directory warnings.
-Setting the PATH Environment Variable
-The PATH variable should include the paths for the tools, as shown below. For other tools, the paths can vary. An example of setting PATH:
-%CWFolder%\Carbide
- %CWFolder%\Carbide\Carbide.c++
The first path contains the FlexLM license manager DLL, and the second path contains the tools. To run FlexLM, copy the following file into the directory containing the command-line tools:
-..\Carbide\license.dat
-Or, you can define the variable LM_LICENSE_FILE as:
-%CWFolder%\license.dat
-which points to the license information. It might point to alternate versions of this file, as needed.
-Getting Environmental Variables
-Use the predefined macro __env_var() to return host-specific environmental variables. An example of getting an environmental variable:
-// returns "username" environmental variable
- // (host-specific)
- char* username = __env_var(username);
Search Path Environment Variables
-Several environment variables are used at runtime to search for system include paths and libraries that can shorten command lines for many tasks. All of the variables mentioned here are lists that are separated by semicolons (;) in Windows and colons (:) in Solaris.
-For the linker, unless you specify -nodefaults or -disassemble, the linker searches the environment for a list of system access paths and library files to be added to the end of the search and link orders. For example, with Embedded PowerPC, the linkers searches for files, libraries, and command files, using the system library paths found within the variables MWEABIPPCLibraries and MWLibraries. Associated with these lists are MWEABIPPCLibraryFiles and MWLibraryFiles, which contain lists of libraries (or object files or command files) to add to the end of the link order. These files can be located in any of the cumulative access paths at runtime.
-If you are only building for one target, you can use MWCIncludes, MWAsmIncludes, MWLibraries, and MWLibraryFiles. Because the target-specific versions of these variables override the generic variables, they are useful when working with multiple targets. If the target-specific variable exists, then the generic variable is not used because you cannot combine the contents of the two variables.
- - - - - + + + + + +Working with Environment Variables
+To use the command-line tools, you must change several environment variables. If you are using Carbide command-line tools with Microsoft® Windows®, you can assign environment variables through the Environment tab under the System control panel in Windows XP/2000/NT.
+CWFolder Environment Variable
+Use the following syntax when defining variables in batch files or on the command line:
+set CWFolder=C:\Program Files\Carbide
+In this example, CWFolder refers to the path where you installed Carbide. It is not necessary to include quotation marks when defining environment variables that include spaces. Because Windows does not strip out the quotes, this leads to unknown directory warnings.
+Setting the PATH Environment Variable
+The PATH variable should include the paths for the tools, as shown below. For other tools, the paths can vary. An example of setting PATH:
+%CWFolder%\Carbide
+ %CWFolder%\Carbide\Carbide.c++
The first path contains the FlexLM license manager DLL, and the second path contains the tools. To run FlexLM, copy the following file into the directory containing the command-line tools:
+..\Carbide\license.dat
+Or, you can define the variable LM_LICENSE_FILE as:
+%CWFolder%\license.dat
+which points to the license information. It might point to alternate versions of this file, as needed.
+Getting Environmental Variables
+Use the predefined macro __env_var() to return host-specific environmental variables. An example of getting an environmental variable:
+// returns "username" environmental variable
+ // (host-specific)
+ char* username = __env_var(username);
Search Path Environment Variables
+Several environment variables are used at runtime to search for system include paths and libraries that can shorten command lines for many tasks. All of the variables mentioned here are lists that are separated by semicolons (;) in Windows and colons (:) in Solaris.
+For the linker, unless you specify -nodefaults or -disassemble, the linker searches the environment for a list of system access paths and library files to be added to the end of the search and link orders. For example, with Embedded PowerPC, the linkers searches for files, libraries, and command files, using the system library paths found within the variables MWEABIPPCLibraries and MWLibraries. Associated with these lists are MWEABIPPCLibraryFiles and MWLibraryFiles, which contain lists of libraries (or object files or command files) to add to the end of the link order. These files can be located in any of the cumulative access paths at runtime.
+If you are only building for one target, you can use MWCIncludes, MWAsmIncludes, MWLibraries, and MWLibraryFiles. Because the target-specific versions of these variables override the generic variables, they are useful when working with multiple targets. If the target-specific variable exists, then the generic variable is not used because you cannot combine the contents of the two variables.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cmd_line/cmd_extensions.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cmd_line/cmd_extensions.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cmd_line/cmd_extensions.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,17 +1,17 @@ - - - - - -File Extensions
-Files specified on the command line are identified by contents and file extension, as in the Carbide IDE.
-Although the command-line version of the Carbide C/C++ compiler accepts non-standard file extensions as source, it also emit a warning when this happens. By default, the compiler assumes that a file with any extensions other than .c, .h, or .pch is a C++ source file. The linker must be able to identify all files as object code, libraries, or command files. It ignores all other files.
- - - - - + + + + + +File Extensions
+Files specified on the command line are identified by contents and file extension, as in the Carbide IDE.
+Although the command-line version of the Carbide C/C++ compiler accepts non-standard file extensions as source, it also emit a warning when this happens. By default, the compiler assumes that a file with any extensions other than .c, .h, or .pch is a C++ source file. The linker must be able to identify all files as object code, libraries, or command files. It ignores all other files.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cmd_line/cmd_invoking.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cmd_line/cmd_invoking.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cmd_line/cmd_invoking.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,30 +1,30 @@ - - - - - -Invoking Command-Line Tools
-To compile, assemble, link, or perform some other programming task with the Carbide command-line tools, type a command at the command-line prompt. This command specifies what tool to run, what options to use while the tool runs, and on what files the tool should operate.
-The tool performs the operation on the files you specify. If the tool successfully finishes its operation, a new prompt appears on the command line. Otherwise, it reports any problems as text messages on the command line before a new prompt appears. The tools include:
--
-
- mwccsym2 — x86 C/C++ compiler -
- mwldsym2 — x86 linker -
- mwc++filt — x86 filter -
All of them can be found in \Nokia\Carbide.c++ <version>\x86Build\Symbian_Tools\Command_Line_Tools.
-You can also write scripts that automate the process to build your software. Scripts contain a list of command-line tools to invoke, one after another. For example, the make tool, a common software development tool, uses scripts to manage dependencies among source code files and invoke command-line compilers, assemblers, and linkers as needed, much like the Carbider IDE’s project manager.
-Commands follow this convention:
---tool [options] [files]
-
where tool is the name of the Carbide command-line tool to invoke, options is a list of zero or more options that tell the tool what operation it should perform and how to perform it, and files is a list of zero or more files on which the tool should operate. Which options and files you use depends on what operation you want the tool to perform.
-
Invoking Command-Line Tools
+To compile, assemble, link, or perform some other programming task with the Carbide command-line tools, type a command at the command-line prompt. This command specifies what tool to run, what options to use while the tool runs, and on what files the tool should operate.
+The tool performs the operation on the files you specify. If the tool successfully finishes its operation, a new prompt appears on the command line. Otherwise, it reports any problems as text messages on the command line before a new prompt appears. The tools include:
+-
+
- mwccsym2 — x86 C/C++ compiler +
- mwldsym2 — x86 linker +
- mwc++filt — x86 filter +
All of them can be found in \Nokia\Carbide.c++ <version>\x86Build\Symbian_Tools\Command_Line_Tools.
+You can also write scripts that automate the process to build your software. Scripts contain a list of command-line tools to invoke, one after another. For example, the make tool, a common software development tool, uses scripts to manage dependencies among source code files and invoke command-line compilers, assemblers, and linkers as needed, much like the Carbider IDE’s project manager.
+Commands follow this convention:
+++tool [options] [files]
+
where tool is the name of the Carbide command-line tool to invoke, options is a list of zero or more options that tell the tool what operation it should perform and how to perform it, and files is a list of zero or more files on which the tool should operate. Which options and files you use depends on what operation you want the tool to perform.
+
Command-Line Tools
-The Carbide IDE uses compilers and linkers to generate object code for x86 platforms. The IDE also provides command-line versions of these tools that also generate and combine object code files to produce executable files such as applications, dynamic link libraries (DLLs), code resources, or static libraries.
-NOTE The Carbide.c++ compiler is stored in \Nokia\Carbide.c++ <version>\x86Build\Symbian_Tools\Command_Line_Tools.
-You configure each command-line tool by specifying various options when you invoke the tool.
-This topic contains the following sections:
--
-
- Tool Naming Conventions -
- Working with Environment Variables -
- Invoking Command-Line Tools -
- File Extensions -
- Help and Administrative Options -
- Command-Line Settings Conventions -
TIP A command-line user interface interacts with you through a text-based console instead of GUI items such as windows, menus, and buttons.
-
Command-Line Tools
+The Carbide IDE uses compilers and linkers to generate object code for x86 platforms. The IDE also provides command-line versions of these tools that also generate and combine object code files to produce executable files such as applications, dynamic link libraries (DLLs), code resources, or static libraries.
+NOTE The Carbide.c++ compiler is stored in \Nokia\Carbide.c++ <version>\x86Build\Symbian_Tools\Command_Line_Tools.
+You configure each command-line tool by specifying various options when you invoke the tool.
+This topic contains the following sections:
+-
+
- Tool Naming Conventions +
- Working with Environment Variables +
- Invoking Command-Line Tools +
- File Extensions +
- Help and Administrative Options +
- Command-Line Settings Conventions +
TIP A command-line user interface interacts with you through a text-based console instead of GUI items such as windows, menus, and buttons.
+
Tool Naming Conventions
-The names of the Carbide command-line tools follow this convention:
-mw<tool><type>
-where:
--
-
- <tool> is cc/c++ for the C/C++ compiler, and ld for the linker -
- <type> is sym2 for the Symbian EKA2 compiler/linker, and filt for the filter -
Tools include:
--
-
- mwccsym2 — x86 C/C++ compiler -
- mwldsym2 — x86 linker -
- mwc++filt — x86 filter -
NOTE The prefix "mw" is an artifact of the pre-Carbide days when Metrowerks owned the x86 compiler technology used by Carbide.c++.
- - - - - + + + + + +Tool Naming Conventions
+The names of the Carbide command-line tools follow this convention:
+mw<tool><type>
+where:
+-
+
- <tool> is cc/c++ for the C/C++ compiler, and ld for the linker +
- <type> is sym2 for the Symbian EKA2 compiler/linker, and filt for the filter +
Tools include:
+-
+
- mwccsym2 — x86 C/C++ compiler +
- mwldsym2 — x86 linker +
- mwc++filt — x86 filter +
NOTE The prefix "mw" is an artifact of the pre-Carbide days when Metrowerks owned the x86 compiler technology used by Carbide.c++.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/compiler.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/compiler.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/compiler.htm Mon Jul 19 16:13:24 2010 -0500 @@ -7,6 +7,9 @@ @@ -18,14 +21,13 @@
-
-
Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
+
Copyright © 2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
License: http://www.eclipse.org/legal/epl-v10.html
x86 C/C++ Compiler Reference
-x86 Compiler 3.2.5 (Build 480); July, 2009
x86 C/C++ Compiler Reference
+x86 Compiler 3.2.5 (Build 489); Feb, 2010
diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_behavior/cpp_be_chars.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_behavior/cpp_be_chars.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_behavior/cpp_be_chars.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,18 +1,18 @@ - - - - - -
Character Literals
-(ISO C++, §2.13.2) The standard specifies that a multicharacter literal, two or more characters surrounded by single quotes, has an implementation-defined value. See Character Constants as Integer Values for information on how Carbide.c++ translates such values.
-A character literal that begins with the letter “L” (without the quotes) is a wide-character literal. Each target translates wide-character literals in its own way; most targets use either two or four-byte wide characters. An escape sequence that uses an octal or hexadecimal value outside the range of char or wchar_t results in an error.
-See your target documentation for more information on how your target handles wide-character literals.
- - - - - + + + + + +Character Literals
+(ISO C++, §2.13.2) The standard specifies that a multicharacter literal, two or more characters surrounded by single quotes, has an implementation-defined value. See Character Constants as Integer Values for information on how Carbide.c++ translates such values.
+A character literal that begins with the letter “L” (without the quotes) is a wide-character literal. Each target translates wide-character literals in its own way; most targets use either two or four-byte wide characters. An escape sequence that uses an octal or hexadecimal value outside the range of char or wchar_t results in an error.
+See your target documentation for more information on how your target handles wide-character literals.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_behavior/cpp_be_devices.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_behavior/cpp_be_devices.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_behavior/cpp_be_devices.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,17 +1,17 @@ - - - - - -Interactive Devices
-(ISO C++, §1.9) The standard specifies that an interactive device, the part of a computer that accepts input from and provides output to a human operator, is implementation-defined. The most common instance of an interactive device is a console; a keyboard and character display terminal.
-Some versions of Carbide.c++, typically for desktop platforms, provide libraries to emulate a character display device in a graphical window. For example, on Microsoft Windows Carbide.c++ uses the Command Prompt window. For embedded systems that do not have a keyboard or display, Carbide provides console interaction through a serial or Ethernet connection between the target and host computers.
- - - - - + + + + + +Interactive Devices
+(ISO C++, §1.9) The standard specifies that an interactive device, the part of a computer that accepts input from and provides output to a human operator, is implementation-defined. The most common instance of an interactive device is a console; a keyboard and character display terminal.
+Some versions of Carbide.c++, typically for desktop platforms, provide libraries to emulate a character display device in a graphical window. For example, on Microsoft Windows Carbide.c++ uses the Command Prompt window. For embedded systems that do not have a keyboard or display, Carbide provides console interaction through a serial or Ethernet connection between the target and host computers.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_behavior/cpp_be_hdr_access.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_behavior/cpp_be_hdr_access.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_behavior/cpp_be_hdr_access.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,18 +1,18 @@ - - - - - -Header File Access
-(ISO C++, §2.8) The standard requires implementations to specify how header names are mapped to actual files.
-The Carbide IDE manages the correspondence of header names to header files.
-If you use Carbide.c++ on the command line, see Command-Line Tools for information on specifying how Carbide.c++ should search for header files.
- - - - - + + + + + +Header File Access
+(ISO C++, §2.8) The standard requires implementations to specify how header names are mapped to actual files.
+The Carbide IDE manages the correspondence of header names to header files.
+If you use Carbide.c++ on the command line, see Command-Line Tools for information on specifying how Carbide.c++ should search for header files.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_behavior/cpp_be_size_of_bytes.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_behavior/cpp_be_size_of_bytes.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_behavior/cpp_be_size_of_bytes.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,16 +1,16 @@ - - - - - -Size of Bytes
-(ISO C++, §1.7) The standard specifies that the size of a byte is implementation-defined.
- - - - - + + + + + +Size of Bytes
+(ISO C++, §1.7) The standard specifies that the size of a byte is implementation-defined.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_behavior/cpp_be_src_handling.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_behavior/cpp_be_src_handling.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_behavior/cpp_be_src_handling.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,19 +1,19 @@ - - - - - -Source File Handling
-(ISO C++, §2.1) The standard specifies how source files are prepared for translation.
-If trigraph expansion is turned on, Carbide.c++ converts trigraph sequences with their single-character representations. Trigraph expansion is controlled by the #pragma trigraphs.
-At preprocessing-time, a sequence of two or more white-space characters, except new-line characters, is converted to a single space.
- New-line characters are left untouched, unless preceded by a backslash (“\”), in which case the proceeding line is appended.
Source File Handling
+(ISO C++, §2.1) The standard specifies how source files are prepared for translation.
+If trigraph expansion is turned on, Carbide.c++ converts trigraph sequences with their single-character representations. Trigraph expansion is controlled by the #pragma trigraphs.
+At preprocessing-time, a sequence of two or more white-space characters, except new-line characters, is converted to a single space.
+ New-line characters are left untouched, unless preceded by a backslash (“\”), in which case the proceeding line is appended.
C++ Implementation-Defined Behavior
-The ISO standard for C++ leaves many details about the form and translation of C++ programs up to the implementation of the C++ compiler. This section lists the parts of the of the C++ standard that are left to the implementation to define and how Carbide.c++ behaves in these situations. Numbers in parentheses that begin with “§” denote the section of the ISO C++ standard that an implementation-defined behavior refers to.
-This section refers to implementation-defined behaviors of the compiler itself. Topics include:
--
-
- Size of Bytes -
- Interactive Devices -
- Source File Handling -
- Header File Access -
- Character Literals -
For information of implementation-defined behaviors of the Standard C++ Library, consult the MSL C++ Library Reference.
- - - - - + + + + + +C++ Implementation-Defined Behavior
+The ISO standard for C++ leaves many details about the form and translation of C++ programs up to the implementation of the C++ compiler. This section lists the parts of the of the C++ standard that are left to the implementation to define and how Carbide.c++ behaves in these situations. Numbers in parentheses that begin with “§” denote the section of the ISO C++ standard that an implementation-defined behavior refers to.
+This section refers to implementation-defined behaviors of the compiler itself. Topics include:
+-
+
- Size of Bytes +
- Interactive Devices +
- Source File Handling +
- Header File Access +
- Character Literals +
For information of implementation-defined behaviors of the Standard C++ Library, consult the MSL C++ Library Reference.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_compiler.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_compiler.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_compiler.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,29 +1,29 @@ - - - - - -C++ Compiler
-This section discusses the Carbide.c++ compiler as it applies to all Carbide targets. Most information in this chapter applies to any operating system or processor.
-Other sections in this manual discuss other compiler features that apply to specific operating systems and processors. For a complete picture, you need to consider all the information relating to your particular target.
-The C compiler is also an integral part of the Carbide.c++ compiler. As a result, everything about the C compiler applies equally to C++. This discussion of the C++ compiler does not repeat information on the C compiler. See C Compiler for information on the C compiler.
-This section contains the following topics:
--
-
- Carbide Implementation of C++ -
- Forward Declarations of Arrays of Incomplete Type -
- Vendor Independent C++ ABI -
- Working with C++ Exceptions -
- Working with RTTI -
- Working with Templates -
For information on using Embedded C++ (EC++) and for strategies on developing smaller C++ programs, see Overview. -
- - - - - + + + + + +C++ Compiler
+This section discusses the Carbide.c++ compiler as it applies to all Carbide targets. Most information in this chapter applies to any operating system or processor.
+Other sections in this manual discuss other compiler features that apply to specific operating systems and processors. For a complete picture, you need to consider all the information relating to your particular target.
+The C compiler is also an integral part of the Carbide.c++ compiler. As a result, everything about the C compiler applies equally to C++. This discussion of the C++ compiler does not repeat information on the C compiler. See C Compiler for information on the C compiler.
+This section contains the following topics:
+-
+
- Carbide Implementation of C++ +
- Forward Declarations of Arrays of Incomplete Type +
- Vendor Independent C++ ABI +
- Working with C++ Exceptions +
- Working with RTTI +
- Working with Templates +
For information on using Embedded C++ (EC++) and for strategies on developing smaller C++ programs, see Overview. +
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_controlling.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_controlling.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_controlling.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,26 +1,26 @@ - - - - - -Controlling the C++ Compiler
-This section describes how to control compiler behavior by selecting settings .
-This section contains the following topics:
--
-
- Using the C++ Compiler Always -
- Controlling Variable Scope in for Statements -
- Controlling Exception Handling -
- Controlling RTTI -
- Using the bool Type -
- Controlling C++ Extensions
-
-
Controlling the C++ Compiler
+This section describes how to control compiler behavior by selecting settings .
+This section contains the following topics:
+-
+
- Using the C++ Compiler Always +
- Controlling Variable Scope in for Statements +
- Controlling Exception Handling +
- Controlling RTTI +
- Using the bool Type +
- Controlling C++ Extensions
+
+
Using the C++ Compiler Always
-If you enable the Force C++ Compilation setting, the compiler translates all C source files in your project as C++ code. Otherwise, the Carbide IDE uses the suffix of the file name to determine whether to use the C or C++ compiler. The entries in the Carbide IDE’s File Mappings panel describes the suffixes that the compiler seeks.
-This setting corresponds to the pragma cplusplus. To check this setting, use __option (cplusplus). By default, this setting is disabled.
-See Checking Option Settings for information on how to use this directive.
- - - - - + + + + + +Using the C++ Compiler Always
+If you enable the Force C++ Compilation setting, the compiler translates all C source files in your project as C++ code. Otherwise, the Carbide IDE uses the suffix of the file name to determine whether to use the C or C++ compiler. The entries in the Carbide IDE’s File Mappings panel describes the suffixes that the compiler seeks.
+This setting corresponds to the pragma cplusplus. To check this setting, use __option (cplusplus). By default, this setting is disabled.
+See Checking Option Settings for information on how to use this directive.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_ctrl_bool_type.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_ctrl_bool_type.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_ctrl_bool_type.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,21 +1,21 @@ - - - - - -Using the bool Type
-Enable the Enable bool Support setting to use the standard C++ bool type to represent true and false. Disable this setting if recognizing bool, true, or false as keywords causes problems in your program.
-Enabling the bool data type and its true and false values is not equivalent to defining them using typedef and #define. The C++ bool type is a distinct type defined by the ISO C++ Standard. Source code that does not treat it as a distinct type might not compile properly.
-For example, some compilers equate the bool type with the unsigned char data type. If you disable the Enable bool Support setting, the Carbide.c++ compiler equates the bool type with the unsigned char data type. Otherwise, using the Carbide C/C++ compiler on source code that involves this behavior might result in errors.
-This setting corresponds to the pragma bool. To check this setting, use __option (bool). By default, this setting is disabled.
-See Checking Option Settings for information on how to use this directive.
-
Using the bool Type
+Enable the Enable bool Support setting to use the standard C++ bool type to represent true and false. Disable this setting if recognizing bool, true, or false as keywords causes problems in your program.
+Enabling the bool data type and its true and false values is not equivalent to defining them using typedef and #define. The C++ bool type is a distinct type defined by the ISO C++ Standard. Source code that does not treat it as a distinct type might not compile properly.
+For example, some compilers equate the bool type with the unsigned char data type. If you disable the Enable bool Support setting, the Carbide.c++ compiler equates the bool type with the unsigned char data type. Otherwise, using the Carbide C/C++ compiler on source code that involves this behavior might result in errors.
+This setting corresponds to the pragma bool. To check this setting, use __option (bool). By default, this setting is disabled.
+See Checking Option Settings for information on how to use this directive.
+
Controlling Exception Handling
-Enable the Enable C++ Exceptions setting if you use the ISO-standard try and catch statements. Otherwise, disable this setting to generate smaller and faster code.
-For more information on how Carbide implements the ISO C++ exception handling mechanism, see Working with C++ Exceptions.
-This setting corresponds to the pragma exceptions. To check this setting, use __option (exceptions). By default, this setting is disabled.
-See Checking Option Settings for information on how to use this directive.
-
Controlling Exception Handling
+Enable the Enable C++ Exceptions setting if you use the ISO-standard try and catch statements. Otherwise, disable this setting to generate smaller and faster code.
+For more information on how Carbide implements the ISO C++ exception handling mechanism, see Working with C++ Exceptions.
+This setting corresponds to the pragma exceptions. To check this setting, use __option (exceptions). By default, this setting is disabled.
+See Checking Option Settings for information on how to use this directive.
+
Controlling C++ Extensions
-The C++ compiler has additional extensions that you can activate using the pragma cpp_extensions.
-If you enable this pragma, the compiler lets you use the following extensions to the ISO C++ standard:
--
-
- Anonymous struct objects (ISO C++, §9) -
--#pragma cpp_extensions on
-
- void foo()
- {
- union {
- long hilo;
- struct { short hi, lo; };
- // anonymous struct
- };
- hi=0x1234;
- lo=0x5678;
- // hilo==0x12345678
- }
-
-
- Unqualified pointer to a member function (ISO C++, §8.1) -
--#pragma cpp_extensions on
-
- struct Foo { void f(); }
- void Foo::f()
- {
- void (Foo::*ptmf1)() = &Foo::f;
- // ALWAYS OK
-
- void (Foo::*ptmf2)() = f;
- // OK if you enabled cpp_extensions.
- }
To check this setting, use the __option (cpp_extensions). By default, this setting is off.
-See Checking Option Settings for information on how to use this directive.
-
-
Controlling C++ Extensions
+The C++ compiler has additional extensions that you can activate using the pragma cpp_extensions.
+If you enable this pragma, the compiler lets you use the following extensions to the ISO C++ standard:
+-
+
- Anonymous struct objects (ISO C++, §9) +
++#pragma cpp_extensions on
+
+ void foo()
+ {
+ union {
+ long hilo;
+ struct { short hi, lo; };
+ // anonymous struct
+ };
+ hi=0x1234;
+ lo=0x5678;
+ // hilo==0x12345678
+ }
-
+
- Unqualified pointer to a member function (ISO C++, §8.1) +
++#pragma cpp_extensions on
+
+ struct Foo { void f(); }
+ void Foo::f()
+ {
+ void (Foo::*ptmf1)() = &Foo::f;
+ // ALWAYS OK
+
+ void (Foo::*ptmf2)() = f;
+ // OK if you enabled cpp_extensions.
+ }
To check this setting, use the __option (cpp_extensions). By default, this setting is off.
+See Checking Option Settings for information on how to use this directive.
+
+
Controlling RTTI
-The Carbide.c++ language supports runtime type information (RTTI), including the dynamic_cast and typeid operators. To use these operators, enable the Enable RTTI setting .
-For more information on how to use these two operators, see Working with RTTI.
- - - - - + + + + + +Controlling RTTI
+The Carbide.c++ language supports runtime type information (RTTI), including the dynamic_cast and typeid operators. To use these operators, enable the Enable RTTI setting .
+For more information on how to use these two operators, see Working with RTTI.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_ctrl_var_scope.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_ctrl_var_scope.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_ctrl_var_scope.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,25 +1,25 @@ - - - - - -Controlling Variable Scope in for Statements
-If you enable the Legacy for-scoping setting , the compiler generates an error when it encounters a variable scope issue that the ISO C++ standard disallows, but is allowed in the C++ language specified in The Annotated C++ Reference Manual.
-With this option off, the compiler allows variables defined in a for statement to have scope outside the for statement.
-Listing 1. Example of a Local Variable Outside a for Statement
-for(int i=1; i<1000; i++) { /* ... */ }
- return i; // OK in ARM, Error in Carbide.c++
This setting corresponds to the pragma ARM_conform. To check this setting, use __option (ARM_conform). By default, this setting is off.
-See Checking Option Settings for information on how to use this directive.
-
Controlling Variable Scope in for Statements
+If you enable the Legacy for-scoping setting , the compiler generates an error when it encounters a variable scope issue that the ISO C++ standard disallows, but is allowed in the C++ language specified in The Annotated C++ Reference Manual.
+With this option off, the compiler allows variables defined in a for statement to have scope outside the for statement.
+Listing 1. Example of a Local Variable Outside a for Statement
+for(int i=1; i<1000; i++) { /* ... */ }
+ return i; // OK in ARM, Error in Carbide.c++
This setting corresponds to the pragma ARM_conform. To check this setting, use __option (ARM_conform). By default, this setting is off.
+See Checking Option Settings for information on how to use this directive.
+
Working with C++ Exceptions
-If you enable the Enable C++ Exceptions setting , you can use the try and catch statements to perform exception handling. For more information on activating support for C++ exception handling, see “Controlling Exception Handling”.
-Enabling exceptions lets you throw them across any code compiled by the Carbide C/C++ compiler. However, you cannot throw exceptions across the following:
--
-
- Libraries compiled with exception support disabled -
- Libraries compiled with versions of the Carbide C/C++ compiler earlier than v3.4 -
If you throw an exception across one of these, the code calls terminate() and exits.
-If you throw an exception while allocating a class object or an array of class objects, the code automatically destructs the partially constructed objects and de-allocates the memory for them.
- - - - - + + + + + +Working with C++ Exceptions
+If you enable the Enable C++ Exceptions setting , you can use the try and catch statements to perform exception handling. For more information on activating support for C++ exception handling, see “Controlling Exception Handling”.
+Enabling exceptions lets you throw them across any code compiled by the Carbide C/C++ compiler. However, you cannot throw exceptions across the following:
+-
+
- Libraries compiled with exception support disabled +
- Libraries compiled with versions of the Carbide C/C++ compiler earlier than v3.4 +
If you throw an exception across one of these, the code calls terminate() and exits.
+If you throw an exception while allocating a class object or an array of class objects, the code automatically destructs the partially constructed objects and de-allocates the memory for them.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_extensions.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_extensions.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_extensions.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,20 +1,20 @@ - - - - - -Extensions to ISO Standard C++
-This section describes Carbide extensions to the C standard that apply to all targets. In most cases, you turn the extension on or off with a setting . See C/C++ Language Panel for information about this panel.
-The __PRETTY_FUNCTION__ Predefined Identifier
-The __PRETTY_FUNCTION__ predefined identifier represents the qualified (unmangled) C++ name of the function being compiled.
-For related information, see Predefined Symbols. -
- - - - - + + + + + +Extensions to ISO Standard C++
+This section describes Carbide extensions to the C standard that apply to all targets. In most cases, you turn the extension on or off with a setting . See C/C++ Language Panel for information about this panel.
+The __PRETTY_FUNCTION__ Predefined Identifier
+The __PRETTY_FUNCTION__ predefined identifier represents the qualified (unmangled) C++ name of the function being compiled.
+For related information, see Predefined Symbols. +
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_impl_additional_keywords.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_impl_additional_keywords.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_impl_additional_keywords.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,16 +1,16 @@ - - - - - -Additional Keywords
-(ISO C++, §2.8, §2.11) The Carbide.c++ language reserves symbols from these two sections as keywords.
- - - - - + + + + + +Additional Keywords
+(ISO C++, §2.8, §2.11) The Carbide.c++ language reserves symbols from these two sections as keywords.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_impl_default_args.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_impl_default_args.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_impl_default_args.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,22 +1,22 @@ - - - - - -Default Arguments in Member Functions
-(ISO C++, §8.3.6) The compiler does not bind default arguments in a member function at the end of the class declaration. Before the default argument appears, you must declare any value that you use in the default argument expression. An example using default arguments in member functions:
-class foo {
- enum A { AA };
- int f(A a = AA); // OK
- int f(B b = BB); // ERROR: BB is not declared yet
- enum B { BB };
- };
Default Arguments in Member Functions
+(ISO C++, §8.3.6) The compiler does not bind default arguments in a member function at the end of the class declaration. Before the default argument appears, you must declare any value that you use in the default argument expression. An example using default arguments in member functions:
+class foo {
+ enum A { AA };
+ int f(A a = AA); // OK
+ int f(B b = BB); // ERROR: BB is not declared yet
+ enum B { BB };
+ };
Forward Declarations of Arrays of Incomplete Type
-The Carbide.c++ compiler allows the forward declaration of arrays of incomplete type. An example of forward declaration of array of incomplete type:
-extern struct incomplete arr[10];
-struct incomplete {
- int a, b, c;
- };
struct incomplete arr[10]; -
-Forward Declarations of Arrays of Incomplete Type
+The Carbide.c++ compiler allows the forward declaration of arrays of incomplete type. An example of forward declaration of array of incomplete type:
+extern struct incomplete arr[10];
+struct incomplete {
+ int a, b, c;
+ };
struct incomplete arr[10]; +
+Implicit Return Statement for main()
-In C++, the compiler adds a
-return 0;
-statement to the main() function of a program if the function returns an int result and does not end with a user return statement.
-Examples:
-int main() { } // equivalent to:
- // int main() { return 0; }
-
- main() { } // equivalent to:
- // int main() { return 0; }
If you enable the ANSI Strict setting , the compiler enforces an external int main() function.
- - - - - + + + + + +Implicit Return Statement for main()
+In C++, the compiler adds a
+return 0;
+statement to the main() function of a program if the function returns an int result and does not end with a user return statement.
+Examples:
+int main() { } // equivalent to:
+ // int main() { return 0; }
+
+ main() { } // equivalent to:
+ // int main() { return 0; }
If you enable the ANSI Strict setting , the compiler enforces an external int main() function.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_impl_inherited_members.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_impl_inherited_members.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_impl_inherited_members.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,47 +1,47 @@ - - - - - -Calling an Inherited Member Function
-(ISO C++, §10.3) You can call an inherited virtual member function rather than its local override in two ways. The first method is recommended for referring to member functions defined in a base class or any other parent class. The second method, while more convenient, is not recommended if you are using your source code with other compilers.
-The standard method of calling inherited member functions
-This method adheres to the ISO C++ Standard and simply qualifies the member function with its base class.
-Assume you have two classes, MyBaseClass and MySubClass, each implementing a function named MyFunc().
-From within a function of MySubClass, you can call the base class version of MyFunc() this way:
-MyBaseClass::MyFunc();
-However, if you change the class hierarchy, this call might break. Assume you introduce an intermediate class, and your hierarchy is now MyBaseClass, MyMiddleClass, and MySubClass. Each has a version of MyFunc(). The code above still calls the original version of MyFunc() in the MyBaseClass, bypassing the additional behavior you implemented in MyMiddleClass. This kind of subtlety in the code can lead to unexpected results or bugs that are difficult to locate.
-Using inheritance to call inherited member functions
-The def_inherited pragma defines an implicit inherited member for a base class. Use this directive before using the inherited symbol:
-#pragma def_inherited on
-WARNING! The ISO C++ standard does not support the use of inherited.
-You can call the inherited version of MyFunc() this way:
-inherited::MyFunc();
-With the inherited symbol, the compiler identifies the base class at compile time. This line of code calls the immediate base class in both cases: where the base class is MyBaseClass, and where the immediate base class is MyMiddleClass.
-If your class hierarchy changes at a later date and your subclass inherits from a different base class, the immediate base class is still called, despite the change in hierarchy.
-The syntax is as follows:
-inherited::func-name(param-list);
-The statement calls the func-name in the class’s immediate base class. If the class has more than one immediate base class (because of multiple inheritance) and the compiler cannot decide which func-name to call, the compiler generates an error.
-This example creates a Q class that draws its objects by adding behavior to the O class.
-Listing 1. Using inherited to Call an Inherited Member Function
-#pragma def_inherited on
- struct O { virtual void draw(int,int); };
- struct Q : O { void draw(int,int); };
void Q::draw (int x,int y)
- {
- inherited::draw(x,y); // Perform behavior of base class
- ... // Perform added behavior
- }
For related information on this pragma see “def_inherited”. -
- - - - - + + + + + +Calling an Inherited Member Function
+(ISO C++, §10.3) You can call an inherited virtual member function rather than its local override in two ways. The first method is recommended for referring to member functions defined in a base class or any other parent class. The second method, while more convenient, is not recommended if you are using your source code with other compilers.
+The standard method of calling inherited member functions
+This method adheres to the ISO C++ Standard and simply qualifies the member function with its base class.
+Assume you have two classes, MyBaseClass and MySubClass, each implementing a function named MyFunc().
+From within a function of MySubClass, you can call the base class version of MyFunc() this way:
+MyBaseClass::MyFunc();
+However, if you change the class hierarchy, this call might break. Assume you introduce an intermediate class, and your hierarchy is now MyBaseClass, MyMiddleClass, and MySubClass. Each has a version of MyFunc(). The code above still calls the original version of MyFunc() in the MyBaseClass, bypassing the additional behavior you implemented in MyMiddleClass. This kind of subtlety in the code can lead to unexpected results or bugs that are difficult to locate.
+Using inheritance to call inherited member functions
+The def_inherited pragma defines an implicit inherited member for a base class. Use this directive before using the inherited symbol:
+#pragma def_inherited on
+WARNING! The ISO C++ standard does not support the use of inherited.
+You can call the inherited version of MyFunc() this way:
+inherited::MyFunc();
+With the inherited symbol, the compiler identifies the base class at compile time. This line of code calls the immediate base class in both cases: where the base class is MyBaseClass, and where the immediate base class is MyMiddleClass.
+If your class hierarchy changes at a later date and your subclass inherits from a different base class, the immediate base class is still called, despite the change in hierarchy.
+The syntax is as follows:
+inherited::func-name(param-list);
+The statement calls the func-name in the class’s immediate base class. If the class has more than one immediate base class (because of multiple inheritance) and the compiler cannot decide which func-name to call, the compiler generates an error.
+This example creates a Q class that draws its objects by adding behavior to the O class.
+Listing 1. Using inherited to Call an Inherited Member Function
+#pragma def_inherited on
+ struct O { virtual void draw(int,int); };
+ struct Q : O { void draw(int,int); };
void Q::draw (int x,int y)
+ {
+ inherited::draw(x,y); // Perform behavior of base class
+ ... // Perform added behavior
+ }
For related information on this pragma see “def_inherited”. +
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_impl_keyword_ordering.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_impl_keyword_ordering.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_impl_keyword_ordering.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,22 +1,22 @@ - - - - - -Keyword Ordering
-(ISO C++, §7.1.2, §11.4) If you use the friend keyword in a declaration, it must be the first word in the declaration. The virtual keyword does not have to be the first word in a declaration. An example using the virtual or friend Keywords:
-class foo {
- virtual int f0(); // OK
- int virtual f1(); // OK
- friend int f2(); // OK
- int friend f3(); // ERROR
- };
Keyword Ordering
+(ISO C++, §7.1.2, §11.4) If you use the friend keyword in a declaration, it must be the first word in the declaration. The virtual keyword does not have to be the first word in a declaration. An example using the virtual or friend Keywords:
+class foo {
+ virtual int f0(); // OK
+ int virtual f1(); // OK
+ friend int f2(); // OK
+ int friend f3(); // ERROR
+ };
Namespaces
-Carbide supports namespaces, which provide the scope for identifiers. Listing 3.1 provides an example of how you define items in a namespace.
-namespace NS
- {
- int foo();
- void bar();
- }
The above example defines an int variable named NS::foo and a function named NS::bar.
-You can nest namespaces. For example, you can define an identifier as A::B::C::D::E where A, B, and C are nested namespaces and D is either another namespace or a class. You cannot use namespaces within class definitions.
-You can rename namespaces for a module. For example:
-namespace ENA = ExampleNamespaceAlpha;
-creates a namespace alias called ENA for the original namespace ExampleNamespaceAlpha.
-You can import items from a namespace. For example:
-using namespace NS;
-makes anything in NS visible in the current namespace without a qualifier. To limit the scope of an import, specify a single identifier. For example:
-using NS::bar;
-only exposes NS::bar as bar in the current space. This form of using is considered a declaration. So, the following statements:
-using NS::foo;
- int foo;
are not allowed because foo is being redeclared in the current namespace, thereby masking the foo imported from NS.
- - - - - + + + + + +Namespaces
+Carbide supports namespaces, which provide the scope for identifiers. Listing 3.1 provides an example of how you define items in a namespace.
+namespace NS
+ {
+ int foo();
+ void bar();
+ }
The above example defines an int variable named NS::foo and a function named NS::bar.
+You can nest namespaces. For example, you can define an identifier as A::B::C::D::E where A, B, and C are nested namespaces and D is either another namespace or a class. You cannot use namespaces within class definitions.
+You can rename namespaces for a module. For example:
+namespace ENA = ExampleNamespaceAlpha;
+creates a namespace alias called ENA for the original namespace ExampleNamespaceAlpha.
+You can import items from a namespace. For example:
+using namespace NS;
+makes anything in NS visible in the current namespace without a qualifier. To limit the scope of an import, specify a single identifier. For example:
+using NS::bar;
+only exposes NS::bar as bar in the current space. This form of using is considered a declaration. So, the following statements:
+using NS::foo;
+ int foo;
are not allowed because foo is being redeclared in the current namespace, thereby masking the foo imported from NS.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_impl_vendor_abi.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_impl_vendor_abi.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_impl_vendor_abi.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,32 +1,32 @@ - - - - - -Vendor Independent C++ ABI
-The Carbide.c++ compiler currently supports these parts of the vendor independent C++ application binary interface (ABI):
--
-
- name mangling -
- class and vtable layout -
- constructor/destructor ABI -
- virtual and non-virtual member function calls -
- array construction/deconstruction ABI -
- one-time construction ABI -
- RTTI -
- pointer to members -
The following features work but do not conform to the ABI specification:
--
-
- exception handling -
NOTE This ABI only works with some compiler targets.
-For more information, see www.codesourcery.com/cxx-abi.
- - - - - + + + + + +Vendor Independent C++ ABI
+The Carbide.c++ compiler currently supports these parts of the vendor independent C++ application binary interface (ABI):
+-
+
- name mangling +
- class and vtable layout +
- constructor/destructor ABI +
- virtual and non-virtual member function calls +
- array construction/deconstruction ABI +
- one-time construction ABI +
- RTTI +
- pointer to members +
The following features work but do not conform to the ABI specification:
+-
+
- exception handling +
NOTE This ABI only works with some compiler targets.
+For more information, see www.codesourcery.com/cxx-abi.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_implementation.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_implementation.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_implementation.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,26 +1,26 @@ - - - - - -Carbide Implementation of C++
-This section describes how the Carbide.c++ compiler implements certain parts of the C++ standard, as described in The Annotated C++ Reference Manual (Addison-Wesley) by Ellis and Stroustrup. The topics discussed in this section are:
--
-
- Namespaces -
- Implicit Return Statement for main() -
- Keyword Ordering -
- Additional Keywords -
- Default Arguments in Member Functions -
- Calling an Inherited Member Function -
- Forward Declarations of Arrays of Incomplete Type -
- Vendor Independent C++ ABI -
Carbide Implementation of C++
+This section describes how the Carbide.c++ compiler implements certain parts of the C++ standard, as described in The Annotated C++ Reference Manual (Addison-Wesley) by Ellis and Stroustrup. The topics discussed in this section are:
+-
+
- Namespaces +
- Implicit Return Statement for main() +
- Keyword Ordering +
- Additional Keywords +
- Default Arguments in Member Functions +
- Calling an Inherited Member Function +
- Forward Declarations of Arrays of Incomplete Type +
- Vendor Independent C++ ABI +
Using the dynamic_cast Operator
-The dynamic_cast operator lets you safely convert a pointer of one type to a pointer of another type. Unlike an ordinary cast, dynamic_cast returns 0 if the conversion is not possible. An ordinary cast returns an unpredictable value that might crash your program if the conversion is not possible.
-The syntax for the dynamic_cast operator is as follows:
-dynamic_cast<Type*>(expr)
-The Type must be either void or a class with at least one virtual member function. If the object to which expr points (*expr) is of type Type or derived from type Type, this expression converts expr to a pointer of type Type* and returns it. Otherwise, it returns 0, the null pointer.
-For example, take these classes:
-class Person { virtual void func(void) { ; } };
- class Athlete : public Person { /* . . . */ };
-class Superman : public Athlete { /* . . . */ };
And these pointers:
-Person *lois = new Person;
- Person *arnold = new Athlete;
- Person *clark = new Superman;
-Athlete *a;
This is how dynamic_cast works with each pointer:
-a = dynamic_cast<Athlete*>(arnold);
- // a is arnold, since arnold is an Athlete.
- a = dynamic_cast<Athlete*>(lois);
- // a is 0, since lois is not an Athelete.
- a = dynamic_cast<Athlete*>(clark);
-// a is clark, since clark is both a Superman and an Athlete.
You can also use the dynamic_cast operator with reference types. However, since there is no equivalent to the null pointer for references, dynamic_cast throws an exception of type std::bad_cast if it cannot perform the conversion.
-This is an example of using dynamic_cast with a reference:
-#include <exception>
- using namespace std;
- Person &superref = *clark;
- try {
- Person &ref = dynamic_cast<Person&>(superref);
- }
- catch(bad_cast) {
- cout << "oops!" << endl;
- }
-
Using the dynamic_cast Operator
+The dynamic_cast operator lets you safely convert a pointer of one type to a pointer of another type. Unlike an ordinary cast, dynamic_cast returns 0 if the conversion is not possible. An ordinary cast returns an unpredictable value that might crash your program if the conversion is not possible.
+The syntax for the dynamic_cast operator is as follows:
+dynamic_cast<Type*>(expr)
+The Type must be either void or a class with at least one virtual member function. If the object to which expr points (*expr) is of type Type or derived from type Type, this expression converts expr to a pointer of type Type* and returns it. Otherwise, it returns 0, the null pointer.
+For example, take these classes:
+class Person { virtual void func(void) { ; } };
+ class Athlete : public Person { /* . . . */ };
+class Superman : public Athlete { /* . . . */ };
And these pointers:
+Person *lois = new Person;
+ Person *arnold = new Athlete;
+ Person *clark = new Superman;
+Athlete *a;
This is how dynamic_cast works with each pointer:
+a = dynamic_cast<Athlete*>(arnold);
+ // a is arnold, since arnold is an Athlete.
+ a = dynamic_cast<Athlete*>(lois);
+ // a is 0, since lois is not an Athelete.
+ a = dynamic_cast<Athlete*>(clark);
+// a is clark, since clark is both a Superman and an Athlete.
You can also use the dynamic_cast operator with reference types. However, since there is no equivalent to the null pointer for references, dynamic_cast throws an exception of type std::bad_cast if it cannot perform the conversion.
+This is an example of using dynamic_cast with a reference:
+#include <exception>
+ using namespace std;
+ Person &superref = *clark;
+ try {
+ Person &ref = dynamic_cast<Person&>(superref);
+ }
+ catch(bad_cast) {
+ cout << "oops!" << endl;
+ }
+
Using the typeid Operator
-The typeid operator lets you determine the type of an object. Like the sizeof operator, it takes two kinds of arguments:
--
-
- the name of a class -
- an expression that evaluates to an object -
NOTE Whenever you use typeid operator, you must #include the typeinfo header file.
-The typeid operator returns a reference to a std::type_info object that you can compare with the == and != operators. For example, if you have these classes and objects:
-class Person { /* . . . */ };
- class Athlete : public Person { /* . . . */ };
using namespace std;
-Person *lois = new Person;
- Athlete *arnold = new Athlete;
- Athlete *louganis = new Athlete;
All these expressions are true:
-#include <typeinfo>
- // . . .
- if (typeid(Athlete) == typeid(*arnold))
- // arnold is an Athlete, result is true
- if (typeid(*arnold) == typeid(*louganis))
- // arnold and louganis are both Athletes, result is true
- if (typeid(*lois) == typeid(*arnold)) // ...
- // lois and arnold are not the same type, result is false
You can access the name of a type with the name() member function in the std::type_info class. For example, these statements:
-#include <typeinfo>
- // . . .
- cout << "Lois is a(n) "
-<< typeid(*lois).name() << endl;
-cout << "Arnold is a(n) "
-<< typeid(*arnold).name() << endl;
Print this:
-Lois is a(n) Person
- Arnold is a(n) Athlete
-
Using the typeid Operator
+The typeid operator lets you determine the type of an object. Like the sizeof operator, it takes two kinds of arguments:
+-
+
- the name of a class +
- an expression that evaluates to an object +
NOTE Whenever you use typeid operator, you must #include the typeinfo header file.
+The typeid operator returns a reference to a std::type_info object that you can compare with the == and != operators. For example, if you have these classes and objects:
+class Person { /* . . . */ };
+ class Athlete : public Person { /* . . . */ };
using namespace std;
+Person *lois = new Person;
+ Athlete *arnold = new Athlete;
+ Athlete *louganis = new Athlete;
All these expressions are true:
+#include <typeinfo>
+ // . . .
+ if (typeid(Athlete) == typeid(*arnold))
+ // arnold is an Athlete, result is true
+ if (typeid(*arnold) == typeid(*louganis))
+ // arnold and louganis are both Athletes, result is true
+ if (typeid(*lois) == typeid(*arnold)) // ...
+ // lois and arnold are not the same type, result is false
You can access the name of a type with the name() member function in the std::type_info class. For example, these statements:
+#include <typeinfo>
+ // . . .
+ cout << "Lois is a(n) "
+<< typeid(*lois).name() << endl;
+cout << "Arnold is a(n) "
+<< typeid(*arnold).name() << endl;
Print this:
+Lois is a(n) Person
+ Arnold is a(n) Athlete
+
Working with RTTI
-This section describes how to work with runtime type information features of C++ supported by the Carbide.c++ compiler. RTTI lets you cast an object of one type as another type, get information about objects, and compare their types at runtime.
-The topics in this section are:
- - - - - - + + + + + +Working with RTTI
+This section describes how to work with runtime type information features of C++ supported by the Carbide.c++ compiler. RTTI lets you cast an object of one type as another type, get information about objects, and compare their types at runtime.
+The topics in this section are:
+ + + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_templates_conformance.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_templates_conformance.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/cpp_compiler/cpp_templates_conformance.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,99 +1,99 @@ - - - - - -Better Template Conformance
-Versions 2.5 and later of Carbide.c++ enforces the ISO C++ standard more closely when translating templates than previous versions of Carbide.c++. By default this new template translation is off. To ensure that template source code follows the ISO C++ standard more closely, turn on the ISO C++ Template Parser option .
-The compiler provides pragmas to help update your source code to the more conformant template features. The parse_func_templ pragma controls the new template features. The parse_mfunc_templ pragma controls the new template features for class member functions only. The pragma warn_no_typename warns for the missing use of the typename keyword required by the ISO C++ standard.
-When using the new template parsing features, the compiler enforces more careful use of the typename and template keywords, and follows different rules for resolving names during declaration and instantiation than before.
-A qualified name that refers to a type and that depends on a template parameter must begin with typename (ISO C++, §14.6). An example using the typename Keyword:
-template <typename T> void f()
- {
- T::name *ptr; // ERROR: an attempt to multiply T::name by ptr
- typename T::name *ptr; // OK
- }
The compiler requires the template keyword at the end of “.” and “->” operators, and for qualified identifiers that depend on a template parameter. An example using the template Keyword:
-template <typename T> void f(T* ptr)
- {
- ptr->f<int>(); // ERROR: f is less than int
- ptr->template f<int>(); // OK
- }
Names referred to inside a template declaration that are not dependent on the template declaration (that do not rely on template arguments) must be declared before the template’s declaration. These names are bound to the template declaration at the point where the template is defined. Bindings are not affected by definitions that are in scope at the point of instantiation. Listing 1 shows an example.
-Listing 1. Binding Non-dependent Identifiers
-void f(char);
-template <typename T> void tmpl_func()
- {
- f(1); // Uses f(char); f(int) is not defined yet.
- g(); // ERROR: g() is not defined yet.
- }
- void g();
- void f(int);
Names of template arguments that are dependent in base classes must be explicitly qualified (ISO C++, §14.6.2). See Listing 2.
-Listing 2. Qualifying Template Arguments in Base Classes
-template <typename T> struct Base
- {
- void f();
- }
- template <typename T> struct Derive: Base<T>
- {
- void g()
- {
- f(); // ERROR: Base<T>::f() is not visible.
- Base<T>::f(); // OK
- }
- }
When a template contains a function call in which at least one of the function’s arguments is type-dependent, the compiler uses the name of the function in the context of the template definition (ISO C++, §14.6.2.2) and the context of its instantiation (ISO C++, §14.6.4.2). Listing 3 shows an example.
-Listing 3. Function Call with Type-dependent Argument
-void f(char);
-template <typename T> void type_dep_func()
- {
- f(1); // Uses f(char), above; f(int) is not declared yet.
- f(T()); // f() called with a type-dependent argument.
- }
void f(int);
- struct A{};
- void f(A);
int main()
- {
- type_dep_func<int>(); // Calls f(char) twice.
- type_dep_func<A>(); // Calls f(char) and f(A);
- return 0;
- }
The compiler only uses external names to look up type-dependent arguments in function calls.
-static void f(int); // f() is internal.
- template <typename T> void type_dep_fun_ext()
- {
- f(T()); // f() called with a type-dependent argument.
-}
-
-int main()
- {
- type_dep_fun_ext<int>(); // ERROR: f(int) must be external.
-}
The compiler does not allow expressions in inline assembly statements that depend on template parameters.
-template <typename T> void asm_tmpl()
- {
- asm { move #sizeof(T), D0 ); // ERROR: Not yet supported.
- }
The compiler also supports the address of template-id rules.
-template <typename T> void foo(T) {}
- template <typename T> void bar(T) {}
- ...
- foo{ &bar<int> ); // now accepted
-
Better Template Conformance
+Versions 2.5 and later of Carbide.c++ enforces the ISO C++ standard more closely when translating templates than previous versions of Carbide.c++. By default this new template translation is off. To ensure that template source code follows the ISO C++ standard more closely, turn on the ISO C++ Template Parser option .
+The compiler provides pragmas to help update your source code to the more conformant template features. The parse_func_templ pragma controls the new template features. The parse_mfunc_templ pragma controls the new template features for class member functions only. The pragma warn_no_typename warns for the missing use of the typename keyword required by the ISO C++ standard.
+When using the new template parsing features, the compiler enforces more careful use of the typename and template keywords, and follows different rules for resolving names during declaration and instantiation than before.
+A qualified name that refers to a type and that depends on a template parameter must begin with typename (ISO C++, §14.6). An example using the typename Keyword:
+template <typename T> void f()
+ {
+ T::name *ptr; // ERROR: an attempt to multiply T::name by ptr
+ typename T::name *ptr; // OK
+ }
The compiler requires the template keyword at the end of “.” and “->” operators, and for qualified identifiers that depend on a template parameter. An example using the template Keyword:
+template <typename T> void f(T* ptr)
+ {
+ ptr->f<int>(); // ERROR: f is less than int
+ ptr->template f<int>(); // OK
+ }
Names referred to inside a template declaration that are not dependent on the template declaration (that do not rely on template arguments) must be declared before the template’s declaration. These names are bound to the template declaration at the point where the template is defined. Bindings are not affected by definitions that are in scope at the point of instantiation. Listing 1 shows an example.
+Listing 1. Binding Non-dependent Identifiers
+void f(char);
+template <typename T> void tmpl_func()
+ {
+ f(1); // Uses f(char); f(int) is not defined yet.
+ g(); // ERROR: g() is not defined yet.
+ }
+ void g();
+ void f(int);
Names of template arguments that are dependent in base classes must be explicitly qualified (ISO C++, §14.6.2). See Listing 2.
+Listing 2. Qualifying Template Arguments in Base Classes
+template <typename T> struct Base
+ {
+ void f();
+ }
+ template <typename T> struct Derive: Base<T>
+ {
+ void g()
+ {
+ f(); // ERROR: Base<T>::f() is not visible.
+ Base<T>::f(); // OK
+ }
+ }
When a template contains a function call in which at least one of the function’s arguments is type-dependent, the compiler uses the name of the function in the context of the template definition (ISO C++, §14.6.2.2) and the context of its instantiation (ISO C++, §14.6.4.2). Listing 3 shows an example.
+Listing 3. Function Call with Type-dependent Argument
+void f(char);
+template <typename T> void type_dep_func()
+ {
+ f(1); // Uses f(char), above; f(int) is not declared yet.
+ f(T()); // f() called with a type-dependent argument.
+ }
void f(int);
+ struct A{};
+ void f(A);
int main()
+ {
+ type_dep_func<int>(); // Calls f(char) twice.
+ type_dep_func<A>(); // Calls f(char) and f(A);
+ return 0;
+ }
The compiler only uses external names to look up type-dependent arguments in function calls.
+static void f(int); // f() is internal.
+ template <typename T> void type_dep_fun_ext()
+ {
+ f(T()); // f() called with a type-dependent argument.
+}
+
+int main()
+ {
+ type_dep_fun_ext<int>(); // ERROR: f(int) must be external.
+}
The compiler does not allow expressions in inline assembly statements that depend on template parameters.
+template <typename T> void asm_tmpl()
+ {
+ asm { move #sizeof(T), D0 ); // ERROR: Not yet supported.
+ }
The compiler also supports the address of template-id rules.
+template <typename T> void foo(T) {}
+ template <typename T> void bar(T) {}
+ ...
+ foo{ &bar<int> ); // now accepted
+
Providing declarations when declaring the template
-Carbide.c++ processes any declarations in a template when the template is declared, not when it is instantiated.
-Although the C++ compiler currently accepts declarations in templates that are not available when the template is declared, future versions of the compiler will not. Listing 1 shows some examples.
-Listing 1. Declarations in Template Declarations
-// You must define names in a class template declaration
-struct bar;
- template<typename T> struct foo {
- bar *member; // OK
- };
- struct bar { };
- foo<int> fi;
// Names in template argument dependent base classes:
-template<typename T> struct foo {
- typedef T *tptr;
- };
template<typename T> struct foo {
- typedef T *tptr;
- };
- template<typename T> struct bar : foo<T> {
- typename foo<T>::tptr member; // OK
- };
// The correct usage of typename in template argument
- // dependent qualified names in some contexts:
template<class T> struct X {
- typedef X *xptr;
- xptr f();
- };
- template<class T> X<T>::xptr X<T>::f() // 'typename' missing
- {
- return 0;
- }
// Workaround: Use 'typename':
-template<class T> typename X<T>::xptr X<T>::f() // OK
- {
- return 0;
- }
-
-
Providing declarations when declaring the template
+Carbide.c++ processes any declarations in a template when the template is declared, not when it is instantiated.
+Although the C++ compiler currently accepts declarations in templates that are not available when the template is declared, future versions of the compiler will not. Listing 1 shows some examples.
+Listing 1. Declarations in Template Declarations
+// You must define names in a class template declaration
+struct bar;
+ template<typename T> struct foo {
+ bar *member; // OK
+ };
+ struct bar { };
+ foo<int> fi;
// Names in template argument dependent base classes:
+template<typename T> struct foo {
+ typedef T *tptr;
+ };
template<typename T> struct foo {
+ typedef T *tptr;
+ };
+ template<typename T> struct bar : foo<T> {
+ typename foo<T>::tptr member; // OK
+ };
// The correct usage of typename in template argument
+ // dependent qualified names in some contexts:
template<class T> struct X {
+ typedef X *xptr;
+ xptr f();
+ };
+ template<class T> X<T>::xptr X<T>::f() // 'typename' missing
+ {
+ return 0;
+ }
// Workaround: Use 'typename':
+template<class T> typename X<T>::xptr X<T>::f() // OK
+ {
+ return 0;
+ }
+
+
Declaring and Defining Templates
-In a header file, declare your class functions and function templates, as shown in Listing 3.9.
-Listing 1. templ.h: A Template Declaration File
-template <class T>
- class Templ {
- T member;
- public:
- Templ(T x) { member=x; }
- T Get();
- };
-
- template <class T>
- T Max(T,T);
In a source file, include the header file, then define the function templates and the member functions of the class templates. Listing 3.10 shows you an example.
-This source file is a template definition file, which you include in any file that uses your templates. You do not need to add the template definition file to your project. Although this is technically a source file, you work with it as if it were a header file.
-The template definition file does not generate code. The compiler cannot generate code for a template until you specify what values it should substitute for the template arguments. Specifying these values is called instantiating the template. See Instantiating a Template.
-Listing 2. templ.cp: A Template Definition File
-#include "templ.h"
-
- template <class T>
- T Templ<T>::Get()
- {
- return member;
- }
-
- template <class T>
- T Max(T x, T y)
- {
- return ((x>y)?x:y);
- }
WARNING! Do not include the original template declaration file, which ends in .h, in your source file. Otherwise, the compiler generates an error saying that the function or class is undefined.
-Providing declarations when declaring the template
-Carbide.c++ processes any declarations in a template when the template is declared, not when it is instantiated.
-Although the C++ compiler currently accepts declarations in templates that are not available when the template is declared, future versions of the compiler will not. Listing 3.11 shows some examples.
-Listing 3.11 Declarations in Template Declarations
-// You must define names in a class template declaration
-struct bar;
- template<typename T> struct foo {
- bar *member; // OK
- };
- struct bar { };
- foo<int> fi;
// Names in template argument dependent base classes:
-template<typename T> struct foo {
- typedef T *tptr;
- };
template<typename T> struct foo {
- typedef T *tptr;
- };
- template<typename T> struct bar : foo<T> {
- typename foo<T>::tptr member; // OK
- };
// The correct usage of typename in template argument
- // dependent qualified names in some contexts:
template<class T> struct X {
- typedef X *xptr;
- xptr f();
- };
- template<class T> X<T>::xptr X<T>::f() // 'typename' missing
- {
- return 0;
- }
// Workaround: Use 'typename':
-template<class T> typename X<T>::xptr X<T>::f() // OK
- {
- return 0;
- }
-
-
Declaring and Defining Templates
+In a header file, declare your class functions and function templates, as shown in Listing 3.9.
+Listing 1. templ.h: A Template Declaration File
+template <class T>
+ class Templ {
+ T member;
+ public:
+ Templ(T x) { member=x; }
+ T Get();
+ };
+
+ template <class T>
+ T Max(T,T);
In a source file, include the header file, then define the function templates and the member functions of the class templates. Listing 3.10 shows you an example.
+This source file is a template definition file, which you include in any file that uses your templates. You do not need to add the template definition file to your project. Although this is technically a source file, you work with it as if it were a header file.
+The template definition file does not generate code. The compiler cannot generate code for a template until you specify what values it should substitute for the template arguments. Specifying these values is called instantiating the template. See Instantiating a Template.
+Listing 2. templ.cp: A Template Definition File
+#include "templ.h"
+
+ template <class T>
+ T Templ<T>::Get()
+ {
+ return member;
+ }
+
+ template <class T>
+ T Max(T x, T y)
+ {
+ return ((x>y)?x:y);
+ }
WARNING! Do not include the original template declaration file, which ends in .h, in your source file. Otherwise, the compiler generates an error saying that the function or class is undefined.
+Providing declarations when declaring the template
+Carbide.c++ processes any declarations in a template when the template is declared, not when it is instantiated.
+Although the C++ compiler currently accepts declarations in templates that are not available when the template is declared, future versions of the compiler will not. Listing 3.11 shows some examples.
+Listing 3.11 Declarations in Template Declarations
+// You must define names in a class template declaration
+struct bar;
+ template<typename T> struct foo {
+ bar *member; // OK
+ };
+ struct bar { };
+ foo<int> fi;
// Names in template argument dependent base classes:
+template<typename T> struct foo {
+ typedef T *tptr;
+ };
template<typename T> struct foo {
+ typedef T *tptr;
+ };
+ template<typename T> struct bar : foo<T> {
+ typename foo<T>::tptr member; // OK
+ };
// The correct usage of typename in template argument
+ // dependent qualified names in some contexts:
template<class T> struct X {
+ typedef X *xptr;
+ xptr f();
+ };
+ template<class T> X<T>::xptr X<T>::f() // 'typename' missing
+ {
+ return 0;
+ }
// Workaround: Use 'typename':
+template<class T> typename X<T>::xptr X<T>::f() // OK
+ {
+ return 0;
+ }
+
+
Automatic instantiation
-To instantiate templates automatically, include the template definition file in all source files that use the template, then use the template members like any other type or function. The compiler automatically generates code for a template instantiation whenever it sees a new one. Listing 1 shows how to automatically instantiate the templates for class Templ and class Max.
-Listing 1. myprog.cp: A Source File that Uses Templates
-#include <iostreams.h>
- #include "templ.cp" // includes templ.h as well
void main(void) {
- Templ<long> a = 1, b = 2;
- // The compiler instantiates Templ<long> here.
- cout << Max(a.Get(), b.Get());
- // The compiler instantiates Max<long>() here.
- };
If you use automatic instantiation, the compiler might take longer to translate your program because the compiler has to determine on its own which instantiations you need. It also scatters the object code for the template instantiations throughout your program.
-
Automatic instantiation
+To instantiate templates automatically, include the template definition file in all source files that use the template, then use the template members like any other type or function. The compiler automatically generates code for a template instantiation whenever it sees a new one. Listing 1 shows how to automatically instantiate the templates for class Templ and class Max.
+Listing 1. myprog.cp: A Source File that Uses Templates
+#include <iostreams.h>
+ #include "templ.cp" // includes templ.h as well
void main(void) {
+ Templ<long> a = 1, b = 2;
+ // The compiler instantiates Templ<long> here.
+ cout << Max(a.Get(), b.Get());
+ // The compiler instantiates Max<long>() here.
+ };
If you use automatic instantiation, the compiler might take longer to translate your program because the compiler has to determine on its own which instantiations you need. It also scatters the object code for the template instantiations throughout your program.
+
Explicit instantiation
-To instantiate templates explicitly, include the template definition file in a source file, and write a template instantiation statement for every instantiation. The syntax for a class template instantiation is as follows:
-template class class-name<templ-specs>;
-The syntax for a function template instantiation is as follows:
-template return-type func-name<templ-specs>(arg-specs);
-Listing 1 shows how to explicitly instantiate the templates in Listing 3.9 and Listing 3.10.
-Listing 1. myinst.cp: Explicitly Instantiating Templates
-#include "templ.cp"
-template class Templ<long>; // class instantiation
- template long Max<long>(long,long); // function instantiation
When you explicitly instantiate a function, you do not need to include in templ-specs any arguments that the compiler can deduce from arg-specs. For example, in Listing 1 you can instantiate Max<long>() like this:
-template long Max<>(long, long);
- // The compiler can tell from the arguments
-// that you are instantiating Max<long>()
Use explicit instantiation to make your program compile faster. Because the instantiations can be in one file with no other code, you can even put them in a separate library.
-The compiler also supports the explicit instantiation of non-template members. Listing 2 shows an example.
-Listing 2. Explicit Instantiation of Non-Template Members
-template <class T> struct X {
- static T i;
- };
template <class T> T X<T>::i = 1;
- template char X<char>::i;
NOTE Explicit instantiation is not in the ARM but is part of the ISO C++ standard.
-
Explicit instantiation
+To instantiate templates explicitly, include the template definition file in a source file, and write a template instantiation statement for every instantiation. The syntax for a class template instantiation is as follows:
+template class class-name<templ-specs>;
+The syntax for a function template instantiation is as follows:
+template return-type func-name<templ-specs>(arg-specs);
+Listing 1 shows how to explicitly instantiate the templates in Listing 3.9 and Listing 3.10.
+Listing 1. myinst.cp: Explicitly Instantiating Templates
+#include "templ.cp"
+template class Templ<long>; // class instantiation
+ template long Max<long>(long,long); // function instantiation
When you explicitly instantiate a function, you do not need to include in templ-specs any arguments that the compiler can deduce from arg-specs. For example, in Listing 1 you can instantiate Max<long>() like this:
+template long Max<>(long, long);
+ // The compiler can tell from the arguments
+// that you are instantiating Max<long>()
Use explicit instantiation to make your program compile faster. Because the instantiations can be in one file with no other code, you can even put them in a separate library.
+The compiler also supports the explicit instantiation of non-template members. Listing 2 shows an example.
+Listing 2. Explicit Instantiation of Non-Template Members
+template <class T> struct X {
+ static T i;
+ };
template <class T> T X<T>::i = 1;
+ template char X<char>::i;
NOTE Explicit instantiation is not in the ARM but is part of the ISO C++ standard.
+
Instantiating a Template
-The compiler cannot generate code for a template until you:
--
-
- declare the template class -
- provide a template definition -
- specify the data type(s) for the template -
For information on the first two requirements, see Declaring and Defining Templates.
-Specifying the data type(s) and other arguments for a template is called instantiating the template. Carbide.c++ gives you two ways to instantiate a template. You can let the compiler instantiate it automatically when you first use it, or you can explicitly create all the instantiations you expect to use.
-
Instantiating a Template
+The compiler cannot generate code for a template until you:
+-
+
- declare the template class +
- provide a template definition +
- specify the data type(s) for the template +
For information on the first two requirements, see Declaring and Defining Templates.
+Specifying the data type(s) and other arguments for a template is called instantiating the template. Carbide.c++ gives you two ways to instantiate a template. You can let the compiler instantiate it automatically when you first use it, or you can explicitly create all the instantiations you expect to use.
+
Working with Templates
-(ISO C++, §14) This section describes how to organize your template declarations and definitions in files. It also describes how to explicitly instantiate templates using a syntax that is not in the ARM but is part of the ISO C++ standard.
-This section includes the following topics:
- - - - - - + + + + + +Working with Templates
+(ISO C++, §14) This section describes how to organize your template declarations and definitions in files. It also describes how to explicitly instantiate templates using a syntax that is not in the ARM but is part of the ISO C++ standard.
+This section includes the following topics:
+ + + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_activating.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_activating.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_activating.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,18 +1,18 @@ - - - - - -Activating EC++
-To compile EC++ source code, enable the EC++ Compatibility Mode setting .
-To test for EC++ compatibility mode at compile time, use the __embedded_cplusplus predefined symbol. For more information, see “Predefined Symbols”. -
- - - - - + + + + + +Activating EC++
+To compile EC++ source code, enable the EC++ Compatibility Mode setting .
+To test for EC++ compatibility mode at compile time, use the __embedded_cplusplus predefined symbol. For more information, see “Predefined Symbols”. +
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_code_compiler.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_code_compiler.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_code_compiler.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,33 +1,33 @@ - - - - - -Compiler-related Strategies
-Compiler-related strategies rely on compiler features to reduce object code size.
--
-
- Size Optimizations—use the compiler size optimization settings -
- Inlining—control and limit effectiveness of inline directive -
Size Optimizations
-Carbide compilers include optimization settings for size or speed and various levels of optimization. Choose size as your desired outcome and the level of optimization to apply.
-Optimization settings for your target are controlled by settings in the Processor panel.
-When debugging, compile your code without any optimizations. Some optimizations disrupt the relationship between the source and object code required by the debugger. Optimize your code after you have finished debugging.
-See also C/C++ Language Panel.
-Inlining
-With Carbide, you can disable inlining, allow normal inlining, auto-inline, or set the maximum depth of inlining.
-Inlining can reduce or increase code size. There is no definite answer for this question. Inlining small functions can make a program smaller, especially if you have a class library with a lot of getter/setter member functions.
-However, MSL C++ defines many functions as inline, which is not good if you want minimal code size. For optimal code size when using MSL C++, disable inlining when building the library. If you are not using MSL C++, normal inlining and a common-sense use of the keyword inline might improve your code size.
-In Carbide, you control inlining as a language setting .
-When debugging your code, disable inlining to maintain a clear correspondence between source and object code. After debugging, set the inlining level that has the best effect on your object code.
-See also Inlining. -
- - - - - + + + + + +Compiler-related Strategies
+Compiler-related strategies rely on compiler features to reduce object code size.
+-
+
- Size Optimizations—use the compiler size optimization settings +
- Inlining—control and limit effectiveness of inline directive +
Size Optimizations
+Carbide compilers include optimization settings for size or speed and various levels of optimization. Choose size as your desired outcome and the level of optimization to apply.
+Optimization settings for your target are controlled by settings in the Processor panel.
+When debugging, compile your code without any optimizations. Some optimizations disrupt the relationship between the source and object code required by the debugger. Optimize your code after you have finished debugging.
+See also C/C++ Language Panel.
+Inlining
+With Carbide, you can disable inlining, allow normal inlining, auto-inline, or set the maximum depth of inlining.
+Inlining can reduce or increase code size. There is no definite answer for this question. Inlining small functions can make a program smaller, especially if you have a class library with a lot of getter/setter member functions.
+However, MSL C++ defines many functions as inline, which is not good if you want minimal code size. For optimal code size when using MSL C++, disable inlining when building the library. If you are not using MSL C++, normal inlining and a common-sense use of the keyword inline might improve your code size.
+In Carbide, you control inlining as a language setting .
+When debugging your code, disable inlining to maintain a clear correspondence between source and object code. After debugging, set the inlining level that has the best effect on your object code.
+See also Inlining. +
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_code_language.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_code_language.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_code_language.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,40 +1,40 @@ - - - - - -Language-related Strategies
-Language-related strategies limit or avoid the use of ISO C++ features. While these features can make software design and maintenance easier, they can also increase code size.
--
-
- Virtual Functions—Not using virtual functions reduces code size. -
- Runtime Type Identification—Extra data is not generated if program does not use Runtime Type Identification (RTTI). -
- Exception Handling—While the Carbide.c++ compiler provides zero-overhead exception handling to provide optimum execution speed, it still generates extra object code for exception support. -
- Operator New—Do not throw an exception within the new operator. -
- Multiple and Virtual Inheritance -
Virtual Functions
-For optimal code size, do not use virtual functions unless absolutely necessary. A virtual function is never dead-stripped, even if it is never called.
-Runtime Type Identification
-If code size is an issue, do not use RTTI because it generates a data table for every class. Disabling RTTI decreases the size of the data section.
-The EC++ proposal does not allow runtime type identification.
-See also “Controlling RTTI”.
-Exception Handling
-If you must handle exceptions, be careful when using C++ exception handling routines. Carbide has a zero runtime overhead error handling mechanism. However, using exceptions does increase code size, particularly the exception tables data.
-The EC++ proposal does not allow exception handling.
-NOTE The proposed ISO standard libraries and the use of the new operator require exception handling.
-Operator New
-The C++ new operator might throw an exception, depending on how the runtime library implements the new operator. To make the new operator throw exceptions, set __throws_bad_alloc to 1 in the prefix file for your target and rebuild your library. To prevent the new operator from throwing exceptions, set __throws_bad_alloc to 0 in the prefix file for your target and rebuild your library.
-See your release notes or Targeting manual for more information.
-Multiple and Virtual Inheritance
-Implementing multiple inheritance requires a modest amount of code and data overhead. The EC++ proposal does not allow multiple inheritance.
-For optimal code size, do not use virtual inheritance. Virtual base classes are often complex and add a lot of code to the constructor and destructor functions.
-The EC++ proposal does not allow virtual inheritance.
- - - - - + + + + + +Language-related Strategies
+Language-related strategies limit or avoid the use of ISO C++ features. While these features can make software design and maintenance easier, they can also increase code size.
+-
+
- Virtual Functions—Not using virtual functions reduces code size. +
- Runtime Type Identification—Extra data is not generated if program does not use Runtime Type Identification (RTTI). +
- Exception Handling—While the Carbide.c++ compiler provides zero-overhead exception handling to provide optimum execution speed, it still generates extra object code for exception support. +
- Operator New—Do not throw an exception within the new operator. +
- Multiple and Virtual Inheritance +
Virtual Functions
+For optimal code size, do not use virtual functions unless absolutely necessary. A virtual function is never dead-stripped, even if it is never called.
+Runtime Type Identification
+If code size is an issue, do not use RTTI because it generates a data table for every class. Disabling RTTI decreases the size of the data section.
+The EC++ proposal does not allow runtime type identification.
+See also “Controlling RTTI”.
+Exception Handling
+If you must handle exceptions, be careful when using C++ exception handling routines. Carbide has a zero runtime overhead error handling mechanism. However, using exceptions does increase code size, particularly the exception tables data.
+The EC++ proposal does not allow exception handling.
+NOTE The proposed ISO standard libraries and the use of the new operator require exception handling.
+Operator New
+The C++ new operator might throw an exception, depending on how the runtime library implements the new operator. To make the new operator throw exceptions, set __throws_bad_alloc to 1 in the prefix file for your target and rebuild your library. To prevent the new operator from throwing exceptions, set __throws_bad_alloc to 0 in the prefix file for your target and rebuild your library.
+See your release notes or Targeting manual for more information.
+Multiple and Virtual Inheritance
+Implementing multiple inheritance requires a modest amount of code and data overhead. The EC++ proposal does not allow multiple inheritance.
+For optimal code size, do not use virtual inheritance. Virtual base classes are often complex and add a lot of code to the constructor and destructor functions.
+The EC++ proposal does not allow virtual inheritance.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_code_library.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_code_library.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_code_library.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,28 +1,28 @@ - - - - - -Library-related strategies
-Library related strategies include:
--
-
- Stream-Based Classes—MSL classes comprise a lot of object code. -
- Alternative Class Libraries—Non-standard class libraries can provide a subset of the standard library’s functionality with less overhead. -
Stream-Based Classes
-MSL C++ stream-based classes initialize several instances of direct and indirect objects. When code size is critical, do not use stream-based classes, which include standard input (cin), standard output (cout), and standard error (cerr). There are also wide-character equivalents for the normal input and output routines. Use only standard C input and output functions unless stream-based classes are absolutely necessary.
-In addition to the standard C++ stream classes, avoid using string streams for in-core formatting because they generate heavy overhead. If size is critical, use C’s sprintf or sscanf functions instead.
-The EC++ proposal does not support templatized classes or functions. MSL adheres to the ISO proposed standards that are template-based.
-Alternative Class Libraries
-MSL C++ is based on the ISO proposed C++ standard, which is implemented using templates that have a large initial overhead for specialization.
-To avoid this overhead, consider devising your own commonly-used vector, string, or utility classes. You can also use other class libraries, such as the NIH's (National Institute of Health) Class Library. If you do use an alternative library, beware of potential problems with virtual inheritance, RTTI, or other causes of larger code size as described above. -
- - - - - + + + + + +Library-related strategies
+Library related strategies include:
+-
+
- Stream-Based Classes—MSL classes comprise a lot of object code. +
- Alternative Class Libraries—Non-standard class libraries can provide a subset of the standard library’s functionality with less overhead. +
Stream-Based Classes
+MSL C++ stream-based classes initialize several instances of direct and indirect objects. When code size is critical, do not use stream-based classes, which include standard input (cin), standard output (cout), and standard error (cerr). There are also wide-character equivalents for the normal input and output routines. Use only standard C input and output functions unless stream-based classes are absolutely necessary.
+In addition to the standard C++ stream classes, avoid using string streams for in-core formatting because they generate heavy overhead. If size is critical, use C’s sprintf or sscanf functions instead.
+The EC++ proposal does not support templatized classes or functions. MSL adheres to the ISO proposed standards that are template-based.
+Alternative Class Libraries
+MSL C++ is based on the ISO proposed C++ standard, which is implemented using templates that have a large initial overhead for specialization.
+To avoid this overhead, consider devising your own commonly-used vector, string, or utility classes. You can also use other class libraries, such as the NIH's (National Institute of Health) Class Library. If you do use an alternative library, beware of potential problems with virtual inheritance, RTTI, or other causes of larger code size as described above. +
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_differences.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_differences.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_differences.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,35 +1,35 @@ - - - - - -Differences Between ISO C++ and EC++
-The EC++ proposal does not support the following ISO C++ (ANSI C++) features.
-Templates
-ANSI C++ supports templates. The EC++ proposal does not include template support for class or functions.
-Libraries
-The EC++ proposal supports the <string>, <complex>, <ios>, <streambuf>, <istream>, and <ostream> classes, but only in a non-template form. The EC++ specifications do not support any other ANSI C++ libraries, including the STL-type algorithm libraries.
-File Operations
-The EC++ proposal does not support any file operations except simple console input and output file types.
-Localization
-The EC++ proposal does not contain localization libraries because of the excessive memory requirements.
-Exception Handling
-The EC++ proposal does not support exception handling.
-Unsupported Language Features
-The EC++ proposal does not support the following language features:
--
-
- mutable specified -
- RTTI -
- namespace -
- multiple inheritance -
- virtual inheritance -
Differences Between ISO C++ and EC++
+The EC++ proposal does not support the following ISO C++ (ANSI C++) features.
+Templates
+ANSI C++ supports templates. The EC++ proposal does not include template support for class or functions.
+Libraries
+The EC++ proposal supports the <string>, <complex>, <ios>, <streambuf>, <istream>, and <ostream> classes, but only in a non-template form. The EC++ specifications do not support any other ANSI C++ libraries, including the STL-type algorithm libraries.
+File Operations
+The EC++ proposal does not support any file operations except simple console input and output file types.
+Localization
+The EC++ proposal does not contain localization libraries because of the excessive memory requirements.
+Exception Handling
+The EC++ proposal does not support exception handling.
+Unsupported Language Features
+The EC++ proposal does not support the following language features:
+-
+
- mutable specified +
- RTTI +
- namespace +
- multiple inheritance +
- virtual inheritance +
Obtaining Smaller Code Size in C++
-Consider the following C++ programming strategies to ensure optimal code size:
--
-
- Compiler-related strategies -
- Language-related strategies -
- Library-related strategies -
NOTE In all strategies, reducing object code size can affect program performance.
-The EC++ proposal uses some of these strategies as part of its specification. Other strategies apply to C++ programming in general. Any C++ program can use these strategies, regardless of whether it follows the EC++ proposal or not. -
- - - - - + + + + + +Obtaining Smaller Code Size in C++
+Consider the following C++ programming strategies to ensure optimal code size:
+-
+
- Compiler-related strategies +
- Language-related strategies +
- Library-related strategies +
NOTE In all strategies, reducing object code size can affect program performance.
+The EC++ proposal uses some of these strategies as part of its specification. Other strategies apply to C++ programming in general. Any C++ program can use these strategies, regardless of whether it follows the EC++ proposal or not. +
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_specifications.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_specifications.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_specifications.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,27 +1,27 @@ - - - - - -EC++ Specifications
-This section describes how to design software that adhere to the EC++ proposal.
-Language Related Issues
-To make sure your source code complies with both ISO C++ and EC++ standards, follow these guidelines:
--
-
- Do not use RTTI (Run Time Type Identification). -
- Do not use exception handling, namespaces, or other unsupported features. -
- Do not use multiple or virtual inheritance. -
You can disable certain C++ features, such as RTTI and exceptions, using the compiler settings in the C++ Language panel, described in C/C++ Language Panel
-Library-Related Issues
-Do not refer to routines, data structures, and classes in the Metrowerks Standard Library (MSL) for C++. -
- - - - - + + + + + +EC++ Specifications
+This section describes how to design software that adhere to the EC++ proposal.
+Language Related Issues
+To make sure your source code complies with both ISO C++ and EC++ standards, follow these guidelines:
+-
+
- Do not use RTTI (Run Time Type Identification). +
- Do not use exception handling, namespaces, or other unsupported features. +
- Do not use multiple or virtual inheritance. +
You can disable certain C++ features, such as RTTI and exceptions, using the compiler settings in the C++ Language panel, described in C/C++ Language Panel
+Library-Related Issues
+Do not refer to routines, data structures, and classes in the Metrowerks Standard Library (MSL) for C++. +
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_systems.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_systems.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/emb_systems/emb_systems.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,23 +1,23 @@ - - - - - -C++ and Embedded Systems
-This section describes how to develop software for embedded systems using Carbide.c++ compilers. Embedded systems topics include:
--
-
- Activating EC++ -
- Differences Between ISO C++ and EC++ -
- EC++ Specifications -
- Obtaining Smaller Code Size in C++ -
NOTE This chapter discusses program design strategies for embedded systems and is not meant to be a definitive solution. Currently, you can use the Carbide.c++ compiler to develop embedded systems that are compatible with Embedded C++ (EC++).
- - - - - + + + + + +C++ and Embedded Systems
+This section describes how to develop software for embedded systems using Carbide.c++ compilers. Embedded systems topics include:
+-
+
- Activating EC++ +
- Differences Between ISO C++ and EC++ +
- EC++ Specifications +
- Obtaining Smaller Code Size in C++ +
NOTE This chapter discusses program design strategies for embedded systems and is not meant to be a definitive solution. Currently, you can use the Carbide.c++ compiler to develop embedded systems that are compatible with Embedded C++ (EC++).
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/errors/err_as_warnings.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/errors/err_as_warnings.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/errors/err_as_warnings.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,19 +1,19 @@ - - - - - -Warnings as Errors
-If you enable the Treat All Warnings as Errors setting, the compiler treats all warnings as though they were errors. It does not compile a file successfully until you resolve all warnings.
-The Treat All Warnings as Errors setting corresponds to the pragma warning_errors. To check this setting, use __option (warning_errors).
-See Checking Option Settings for information on how to use this directive.
-
Warnings as Errors
+If you enable the Treat All Warnings as Errors setting, the compiler treats all warnings as though they were errors. It does not compile a file successfully until you resolve all warnings.
+The Treat All Warnings as Errors setting corresponds to the pragma warning_errors. To check this setting, use __option (warning_errors).
+See Checking Option Settings for information on how to use this directive.
+
Bad Conversions of Pointer Values
-Use either of the following pragmas to detect bad pointer value conversions:
--
-
- Enable the pragma warn_ptr_int_conv to have the compiler issue a warning when an expression converts a pointer value to an integral value that is not large enough to hold a pointer value. -
- Enable the pragma warn_any_ptr_int_conv to have the compiler issue a warning when an expression converts a pointer value to an integral value that is not large enough to hold a pointer value or vice versa. -
Bad Conversions of Pointer Values
+Use either of the following pragmas to detect bad pointer value conversions:
+-
+
- Enable the pragma warn_ptr_int_conv to have the compiler issue a warning when an expression converts a pointer value to an integral value that is not large enough to hold a pointer value. +
- Enable the pragma warn_any_ptr_int_conv to have the compiler issue a warning when an expression converts a pointer value to an integral value that is not large enough to hold a pointer value or vice versa. +
Common Errors
-If you enable the Possible Errors setting, the compiler generates a warning if it encounters common errors such as the following:
--
-
- An assignment in either a logical expression or the conditional portion of an if, while, or for expression. This warning is useful if you use = when you mean to use ==. An example of confusing = and == in comparisons: -
--if (a=b) f(); // WARNING: a=b is an assignment
-
- if ((a=b)!=0) f(); // OK: (a=b)!=0 is a comparison, no warning
- if (a==b) f(); // OK: (a==b) is a comparison, no warning
-
-
- An equal comparison in a statement that contains a single expression. This check is useful if you use == when you meant to use =. An example of confusing = and == operators in assignments: -
--a == 0; // WARNING: This is a comparison.
-
- a = 0; // OK: This is an assignment, no warning
-
-
- A semicolon (;) directly after a while, if, or for statement. For example, the following statement generates a warning and is probably an unintended infinite loop: -
--while (i++); // WARNING: Unintended infinite loop
-If you intended to create an infinite loop, put white space or a comment between the while statement and the semicolon.
-These statements suppress the above errors or warnings.
-while (i++) ; // OK: White space separation, no warning
-
- while (i++) /*: Comment separation, no warning */ ;
The Possible Errors setting corresponds to the pragma warn_possunwant. To check this setting, use __option (warn_possunwant).
- See Checking Option Settings for information on how to use this directive.
-
Common Errors
+If you enable the Possible Errors setting, the compiler generates a warning if it encounters common errors such as the following:
+-
+
- An assignment in either a logical expression or the conditional portion of an if, while, or for expression. This warning is useful if you use = when you mean to use ==. An example of confusing = and == in comparisons: +
++if (a=b) f(); // WARNING: a=b is an assignment
+
+ if ((a=b)!=0) f(); // OK: (a=b)!=0 is a comparison, no warning
+ if (a==b) f(); // OK: (a==b) is a comparison, no warning
-
+
- An equal comparison in a statement that contains a single expression. This check is useful if you use == when you meant to use =. An example of confusing = and == operators in assignments: +
++a == 0; // WARNING: This is a comparison.
+
+ a = 0; // OK: This is an assignment, no warning
-
+
- A semicolon (;) directly after a while, if, or for statement. For example, the following statement generates a warning and is probably an unintended infinite loop: +
++while (i++); // WARNING: Unintended infinite loop
+If you intended to create an infinite loop, put white space or a comment between the while statement and the semicolon.
+These statements suppress the above errors or warnings.
+while (i++) ; // OK: White space separation, no warning
+
+ while (i++) /*: Comment separation, no warning */ ;
The Possible Errors setting corresponds to the pragma warn_possunwant. To check this setting, use __option (warn_possunwant).
+ See Checking Option Settings for information on how to use this directive.
+
Empty Declarations
- If you enable the Empty Declarations setting, the compiler issues a warning when it encounters a declaration with no variable name.
-For example:
int ; // WARNING
- int i; // OK
The Empty Declarations setting corresponds to the pragma warn_emptydecl. To check this setting, use __option (warn_emptydecl).
- See Checking Option Settings for information on how to use this directive.
-
Empty Declarations
+ If you enable the Empty Declarations setting, the compiler issues a warning when it encounters a declaration with no variable name.
+For example:
int ; // WARNING
+ int i; // OK
The Empty Declarations setting corresponds to the pragma warn_emptydecl. To check this setting, use __option (warn_emptydecl).
+ See Checking Option Settings for information on how to use this directive.
+
Extra Commas
-If you enable the Extra Commas setting, the compiler generates a warning when it encounters an extra comma. For example, this statement is legal in C but generates a warning when you enable this setting:
-int a[] = { 1, 2, 3, 4, }; // ^ WARNING: Extra comma after 4
-The Extra Commas setting corresponds to the pragma warn_extracomma. To check this setting, use __option (warn_extracomma).
- See Checking Option Settings for information on how to use this directive.
-
Extra Commas
+If you enable the Extra Commas setting, the compiler generates a warning when it encounters an extra comma. For example, this statement is legal in C but generates a warning when you enable this setting:
+int a[] = { 1, 2, 3, 4, }; // ^ WARNING: Extra comma after 4
+The Extra Commas setting corresponds to the pragma warn_extracomma. To check this setting, use __option (warn_extracomma).
+ See Checking Option Settings for information on how to use this directive.
+
Hidden Virtual Functions
-If you enable the Hidden virtual functions setting, the compiler generates a warning if you declare a non-virtual member function in a subclass that hides an inherited virtual function in a superclass. One function hides another if it has the same name but a different argument type. An example of hidden virtual functions:
-class A {
- public:
- virtual void f(int);
- virtual void g(int);
- };
class B: public A {
- public:
- void f(char); // WARNING: Hides A::f(int)
- virtual void g(int); // OK: Overrides A::g(int)
- };
The Hidden virtual functions setting corresponds to the pragma warn_hidevirtual. To check this setting, use __option (warn_hidevirtual).
-See Checking Option Settings for information on how to use this directive.
-
Hidden Virtual Functions
+If you enable the Hidden virtual functions setting, the compiler generates a warning if you declare a non-virtual member function in a subclass that hides an inherited virtual function in a superclass. One function hides another if it has the same name but a different argument type. An example of hidden virtual functions:
+class A {
+ public:
+ virtual void f(int);
+ virtual void g(int);
+ };
class B: public A {
+ public:
+ void f(char); // WARNING: Hides A::f(int)
+ virtual void g(int); // OK: Overrides A::g(int)
+ };
The Hidden virtual functions setting corresponds to the pragma warn_hidevirtual. To check this setting, use __option (warn_hidevirtual).
+See Checking Option Settings for information on how to use this directive.
+
Ignored Function Results
-If you enable the pragma warn_resultnotused, the compiler issues a warning when it encounters a statement that calls a function without using its result. To prevent this warning, cast the statement with (void). See Listing 6.13 for an example.
-Listing 6.13 Example of Pragma warn_resultnotused
-#pragma warn_resultnotused on
- void foo(int a,int b)
- {
- bar(); // warning: result of bar() is not used
- (void)bar(); // void cast suppresses warning
- }
-
Ignored Function Results
+If you enable the pragma warn_resultnotused, the compiler issues a warning when it encounters a statement that calls a function without using its result. To prevent this warning, cast the statement with (void). See Listing 6.13 for an example.
+Listing 6.13 Example of Pragma warn_resultnotused
+#pragma warn_resultnotused on
+ void foo(int a,int b)
+ {
+ bar(); // warning: result of bar() is not used
+ (void)bar(); // void cast suppresses warning
+ }
+
Illegal Pragmas
-If you enable the Illegal Pragmas setting, the compiler issues a warning when it encounters a pragma it does not recognize. For example, the pragma statements below generate warnings with the Illegal Pragmas setting enabled:
-#pragma near_data off // WARNING: near_data is not a pragma.
- #pragma far_data select // WARNING: select is not defined
-#pragma far_data on // OK
The Illegal Pragmas setting corresponds to the pragma warn_illpragma, described at warn_illpragma”. To check this setting, use __option (warn_illpragma).
-See Checking Option Settings for information on how to use this directive.
-
Illegal Pragmas
+If you enable the Illegal Pragmas setting, the compiler issues a warning when it encounters a pragma it does not recognize. For example, the pragma statements below generate warnings with the Illegal Pragmas setting enabled:
+#pragma near_data off // WARNING: near_data is not a pragma.
+ #pragma far_data select // WARNING: select is not defined
+#pragma far_data on // OK
The Illegal Pragmas setting corresponds to the pragma warn_illpragma, described at warn_illpragma”. To check this setting, use __option (warn_illpragma).
+See Checking Option Settings for information on how to use this directive.
+
Implicit Arithmetic Conversions
-The compiler converts values automatically from one type to another to perform some operations (ISO C, §3.2 and ISO C++, §4). These kinds of conversions are called “implicit conversions” because they are not explicitly stated in the source code.
-The rules the compiler follows for deciding when to apply implicit conversions sometimes gives results you do not expect. If you enable the Implicit Arithmetic Conversions setting, the compiler issues a warning when it applies implicit conversions:
--
-
- the destination of an operation is not large enough to hold all possible results -
- a signed value is implicitly converted to an unsigned value -
- an integer value is implicitly converted to a floating-point value -
- a floating-point value is implicitly converted to an integer value -
For example, assigning the value of a variable of type long to a variable of type char results in a warning if you enable this setting.
-The compiler also has pragmas that control specific of implicit conversions the compiler warns about (Table 6.1).
-Table 6.1 Implicit Arithmetic Conversion Pragmas
-| This pragma… | -Warns about this kind of conversion | -
|---|---|
| warn_illunionmembers | -a floating point value to an integer value | -
| warn_impl_i2f_conv | -an integer value to a floating-point value | -
| warn_impl_s2u_conv | -a signed value to an unsigned value | -
| warn_implicitconv | -all; this pragma is equivalent to the Implicit Arithmetic Conversions setting | -
Implicit Arithmetic Conversions
+The compiler converts values automatically from one type to another to perform some operations (ISO C, §3.2 and ISO C++, §4). These kinds of conversions are called “implicit conversions” because they are not explicitly stated in the source code.
+The rules the compiler follows for deciding when to apply implicit conversions sometimes gives results you do not expect. If you enable the Implicit Arithmetic Conversions setting, the compiler issues a warning when it applies implicit conversions:
+-
+
- the destination of an operation is not large enough to hold all possible results +
- a signed value is implicitly converted to an unsigned value +
- an integer value is implicitly converted to a floating-point value +
- a floating-point value is implicitly converted to an integer value +
For example, assigning the value of a variable of type long to a variable of type char results in a warning if you enable this setting.
+The compiler also has pragmas that control specific of implicit conversions the compiler warns about (Table 6.1).
+Table 6.1 Implicit Arithmetic Conversion Pragmas
+| This pragma… | +Warns about this kind of conversion | +
|---|---|
| warn_illunionmembers | +a floating point value to an integer value | +
| warn_impl_i2f_conv | +an integer value to a floating-point value | +
| warn_impl_s2u_conv | +a signed value to an unsigned value | +
| warn_implicitconv | +all; this pragma is equivalent to the Implicit Arithmetic Conversions setting | +
inline Functions That Are Not Inlined
-If you enable the Non-Inlined Functions setting, the compiler issues a warning when it cannot inline a function.
-This setting corresponds to pragma warn_notinlined. To check this setting, use __option (warn_notinlined).
-See Checking Option Settings for information on how to use this directive. -
- - - - - + + + + + +inline Functions That Are Not Inlined
+If you enable the Non-Inlined Functions setting, the compiler issues a warning when it cannot inline a function.
+This setting corresponds to pragma warn_notinlined. To check this setting, use __option (warn_notinlined).
+See Checking Option Settings for information on how to use this directive. +
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/errors/err_mixed_use.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/errors/err_mixed_use.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/errors/err_mixed_use.htm Mon Jul 19 16:13:24 2010 -0500 @@ -1,22 +1,22 @@ - - - - - -Mixed Use of ‘class’ and ‘struct’ Keywords
-If you enable the Inconsistent ‘class’ / ‘struct’ Usage setting, the compiler issues a warning if you use the class and struct keywords in the definition and declaration of the same identifier.
-class X;
- struct X { int a; }; // warning
Use this warning when using static or dynamic libraries to link with object code produced by another C++ compiler that distinguishes between class and structure variables in its name “mangling.”
-This setting corresponds to pragma warn_structclass. To check this setting, use __option (warn_structclass).
- See Checking Option Settings for information on how to use this directive.
-
Mixed Use of ‘class’ and ‘struct’ Keywords
+If you enable the Inconsistent ‘class’ / ‘struct’ Usage setting, the compiler issues a warning if you use the class and struct keywords in the definition and declaration of the same identifier.
+class X;
+ struct X { int a; }; // warning
Use this warning when using static or dynamic libraries to link with object code produced by another C++ compiler that distinguishes between class and structure variables in its name “mangling.”
+This setting corresponds to pragma warn_structclass. To check this setting, use __option (warn_structclass).
+ See Checking Option Settings for information on how to use this directive.
+
Realigned Data Structures
-If you enable the pragma warn_padding, the compiler warns about any bytes it adds to data structures to improve their memory alignment. Refer to the appropriate Targeting manual for more information on how the compiler pads data structures for a particular processor or operating system.
-This pragma reports warnings for C source code only. It does not report warnings for C++ source code.
-
Realigned Data Structures
+If you enable the pragma warn_padding, the compiler warns about any bytes it adds to data structures to improve their memory alignment. Refer to the appropriate Targeting manual for more information on how the compiler pads data structures for a particular processor or operating system.
+This pragma reports warnings for C source code only. It does not report warnings for C++ source code.
+
Redundant Statements
-If you enable the pragma warn_no_side_effect, the compiler issues a warning when it encounters a statement that produces no side effect. To prevent a statement with no side effects from signalling this warning, cast the statement with (void). See Listing 6.12 for an example.
-Listing 6.12 Example of Pragma warn_no_side_effect
-#pragma warn_no_side_effect on
- void foo(int a,int b)
- {
- a+b; // warning: expression has no side effect
- (void)(a+b); // void cast suppresses warning
- }
-
Redundant Statements
+If you enable the pragma warn_no_side_effect, the compiler issues a warning when it encounters a statement that produces no side effect. To prevent a statement with no side effects from signalling this warning, cast the statement with (void). See Listing 6.12 for an example.
+Listing 6.12 Example of Pragma warn_no_side_effect
+#pragma warn_no_side_effect on
+ void foo(int a,int b)
+ {
+ a+b; // warning: expression has no side effect
+ (void)(a+b); // void cast suppresses warning
+ }
+
Suspicious Assignments and Incorrect Function Returns
-If you enable the Extended Error Checking setting, the C compiler generates a warning if it encounters one of the following potential problems:
--
-
- A non-void function that does not contain a return statement. For example, the source code in Listing 1 generates a warning. -
----Listing 1. Non-void Function with no return Statement
-main() /* assumed to return int */
-
- {
- printf ("hello world\n");
- } /* WARNING: no return statement */
- Listing 6.8 does not generate a warning.
- Listing 6.8 Explicitly Specifying a Function’s void Return Type
- void main() /* function declared to return void */
- {
- printf ("hello world\n");
- }
-
-
-
- An integer or floating-point value assigned to an enum type. Listing 2 shows an example. - -
----Listing 2. Assigning to an Enumerated Type
-enum Day { Sunday, Monday, Tuesday, Wednesday,
-
- Thursday, Friday, Saturday } d;d = 5; /* WARNING */
-
- d = Monday; /* OK */
- d = (Day)3 ; /* OK */
-• An empty return statement in a function that is not declared void. For example, the following code results in a warning:
- int MyInit(void)
- {
- int err = GetMyResources();
- if (err!=0) return; /* ERROR: Empty return statement *//* ... */
-
- This is OK:
- int MyInit(void)
- {
- int err = GetMyResources();
- if (err!=0) return -1; /* OK *//* ... */
-
The Extended Error Checking setting corresponds to the pragma extended_errorcheck, described at extended_errorcheck. To check this setting, use __option (extended_errorcheck).
- See Checking Option Settings for information on how to use this directive.
-
Suspicious Assignments and Incorrect Function Returns
+If you enable the Extended Error Checking setting, the C compiler generates a warning if it encounters one of the following potential problems:
+-
+
- A non-void function that does not contain a return statement. For example, the source code in Listing 1 generates a warning. +
++++Listing 1. Non-void Function with no return Statement
+main() /* assumed to return int */
+
+ {
+ printf ("hello world\n");
+ } /* WARNING: no return statement */
+ Listing 6.8 does not generate a warning.
+ Listing 6.8 Explicitly Specifying a Function’s void Return Type
+ void main() /* function declared to return void */
+ {
+ printf ("hello world\n");
+ }
+
-
+
- An integer or floating-point value assigned to an enum type. Listing 2 shows an example. + +
++++Listing 2. Assigning to an Enumerated Type
+enum Day { Sunday, Monday, Tuesday, Wednesday,
+
+ Thursday, Friday, Saturday } d;d = 5; /* WARNING */
+
+ d = Monday; /* OK */
+ d = (Day)3 ; /* OK */
+• An empty return statement in a function that is not declared void. For example, the following code results in a warning:
+ int MyInit(void)
+ {
+ int err = GetMyResources();
+ if (err!=0) return; /* ERROR: Empty return statement *//* ... */
+
+ This is OK:
+ int MyInit(void)
+ {
+ int err = GetMyResources();
+ if (err!=0) return -1; /* OK *//* ... */
+
The Extended Error Checking setting corresponds to the pragma extended_errorcheck, described at extended_errorcheck. To check this setting, use __option (extended_errorcheck).
+ See Checking Option Settings for information on how to use this directive.
+
Unused Arguments
-If you enable the Unused Arguments setting, the compiler generates a warning when it encounters an argument you declare but do not use. This check helps you find arguments that you either misspelled or did not use in your program.
-void foo(int temp,int errer); // ERROR: errer is misspelled
- {
- error = do_something(); // WARNING: temp and error are
- // unused.
-}
You can declare an argument that you do not use in two ways without receiving this warning:
--
-
- Use the pragma unused, as in this example: -
--void foo(int temp, int error)
-
- {
- #pragma unused (temp)
- /* Compiler does not warn that temp is not used */
- error=do_something();
- }
-
-
- Disable the ANSI Strict setting and do not give the unused argument a name. (See Unnamed Arguments in Function Definitions.) An example of Unused, Unnamed Arguments: -
--void foo(int /* temp */, int error)
-
- {
- /* Compiler does not warn that "temp" is not used.
- error=do_something(); */
- }
The Unused Arguments setting corresponds to the pragma warn_unusedarg, described at warn_unusedarg. To check this setting, use __option (warn_unusedarg).
- See Checking Option Settings for information on how to use this directive.
-
Unused Arguments
+If you enable the Unused Arguments setting, the compiler generates a warning when it encounters an argument you declare but do not use. This check helps you find arguments that you either misspelled or did not use in your program.
+void foo(int temp,int errer); // ERROR: errer is misspelled
+ {
+ error = do_something(); // WARNING: temp and error are
+ // unused.
+}
You can declare an argument that you do not use in two ways without receiving this warning:
+-
+
- Use the pragma unused, as in this example: +
++void foo(int temp, int error)
+
+ {
+ #pragma unused (temp)
+ /* Compiler does not warn that temp is not used */
+ error=do_something();
+ }
-
+
- Disable the ANSI Strict setting and do not give the unused argument a name. (See Unnamed Arguments in Function Definitions.) An example of Unused, Unnamed Arguments: +
++void foo(int /* temp */, int error)
+
+ {
+ /* Compiler does not warn that "temp" is not used.
+ error=do_something(); */
+ }
The Unused Arguments setting corresponds to the pragma warn_unusedarg, described at warn_unusedarg. To check this setting, use __option (warn_unusedarg).
+ See Checking Option Settings for information on how to use this directive.
+
Unused Variables
-If you enable the Unused Variables setting, the compiler generates a warning when it encounters a local variable you declare but do not use. This check helps you find variables that you either misspelled or did not use in your program. Listing 1 shows an example.
-Listing 1. Unused Local Variables Example
-int error;
- void foo(void)
- {
- int temp, errer; // ERROR: errer is misspelled
- error = do_something()
- // WARNING: temp and error are unused.
- }
If you want to use this warning but need to declare a variable that you do not use, include the pragma unused, as in Listing 2.
-Listing 2. Suppressing Unused Variable Warnings
-void foo(void)
- {
- int i, temp, error;
#pragma unused (i, temp) /* Do not warn that i and temp */
- error=do_something(); /* are not used */
- }
The Unused Variables setting corresponds to the pragma warn_unusedvar, described at warn_unusedvar. To check this setting, use __option (warn_unusedvar).
- See Checking Option Settings for information on how to use this directive.
-
Unused Variables
+If you enable the Unused Variables setting, the compiler generates a warning when it encounters a local variable you declare but do not use. This check helps you find variables that you either misspelled or did not use in your program. Listing 1 shows an example.
+Listing 1. Unused Local Variables Example
+int error;
+ void foo(void)
+ {
+ int temp, errer; // ERROR: errer is misspelled
+ error = do_something()
+ // WARNING: temp and error are unused.
+ }
If you want to use this warning but need to declare a variable that you do not use, include the pragma unused, as in Listing 2.
+Listing 2. Suppressing Unused Variable Warnings
+void foo(void)
+ {
+ int i, temp, error;
#pragma unused (i, temp) /* Do not warn that i and temp */
+ error=do_something(); /* are not used */
+ }
The Unused Variables setting corresponds to the pragma warn_unusedvar, described at warn_unusedvar. To check this setting, use __option (warn_unusedvar).
+ See Checking Option Settings for information on how to use this directive.
+
Conventions Used in This Reference
-References to a chapter or section number in The C International Standard (ISO/IEC 9899:1999) appear as (ISO C, §number).
-References to a chapter or section number in The C++ International Standard (ISO/IEC: 14882) appear as (ISO C++, §number).
-This manual also uses syntax examples that describe the format of C source code statements:
-#pragma parameter [return-reg] func-name [param-regs]
-#pragma optimize_for_size on | off | reset
-Table 1. describes how to interpret these statements.
-Table 1. Understanding Syntax Examples
-| If the text looks like… | -Then… | -
|---|---|
| literal | -Include the text in your statement exactly as you see it. | -
| metasymbol | -Replace the symbol with an appropriate value. The text after the syntax example describes what the appropriate values are. | -
| a | b | c | -Use one of the symbols in the statement: either a, b, or c. | -
| [a] | -Include the symbol, a, only if necessary. The text after the syntax example describes when to include it. | -
Conventions Used in This Reference
+References to a chapter or section number in The C International Standard (ISO/IEC 9899:1999) appear as (ISO C, §number).
+References to a chapter or section number in The C++ International Standard (ISO/IEC: 14882) appear as (ISO C++, §number).
+This manual also uses syntax examples that describe the format of C source code statements:
+#pragma parameter [return-reg] func-name [param-regs]
+#pragma optimize_for_size on | off | reset
+Table 1. describes how to interpret these statements.
+Table 1. Understanding Syntax Examples
+| If the text looks like… | +Then… | +
|---|---|
| literal | +Include the text in your statement exactly as you see it. | +
| metasymbol | +Replace the symbol with an appropriate value. The text after the syntax example describes what the appropriate values are. | +
| a | b | c | +Use one of the symbols in the statement: either a, b, or c. | +
| [a] | +Include the symbol, a, only if necessary. The text after the syntax example describes when to include it. | +
Where to Look for Related Information
-Additional information on programming for the Symbian OS using Carbide.c++ and SDKs can be found at:
--
-
- Carbide.c++ -
- Symbian OS -
- S60 SDKs -
- UIQ SDKs -
For general information on using the Carbide IDE and debugger, see the Carbide.c++ User Guide.
- - - - - + + + + + +Where to Look for Related Information
+Additional information on programming for the Symbian OS using Carbide.c++ and SDKs can be found at:
+-
+
- Carbide.c++ +
- Symbian OS +
- S60 SDKs +
- Qt SDKs +
For general information on using the Carbide IDE and debugger, see the Carbide.c++ User Guide.
+ + + + + diff -r 4891d49809bb -r 2b3996fc09a1 core/com.nokia.carbide.cpp.compiler.doc.user/html/introduction/intro.htm --- a/core/com.nokia.carbide.cpp.compiler.doc.user/html/introduction/intro.htm Mon Jul 19 15:31:48 2010 -0500 +++ b/core/com.nokia.carbide.cpp.compiler.doc.user/html/introduction/intro.htm Mon Jul 19 16:13:24 2010 -0500 @@ -26,7 +26,7 @@