CodeWarrior® C Compilers Reference Because of last-minute changes to CodeWarrior, some of the information in this manual may be inaccurate. Please read the Release Notes on the CodeWarrior CD for the latest up-to-date information. Revised: 99/01/24 map Metrowerks CodeWarrior copyright ©1993–1999 by Metrowerks Inc. and its licensors. All rights reserved. Documentation stored on the compact disk(s) may be printed by licensee for personal use. Except for the foregoing, no part of this documentation may be reproduced or trans- mitted in any form by any means, electronic or mechanical, including photocopying, recording, or any information storage and retrieval system, without permission in writing from Metrowerks Inc. Metrowerks, the Metrowerks logo, CodeWarrior, and Software at Work are registered trademarks of Metrowerks Inc. PowerPlant and PowerPlant Constructor are trademarks of Metrowerks Inc. All other trademarks and registered trademarks are the property of their respective owners. ALL SOFTWARE AND DOCUMENTATION ON THE COMPACT DISK(S) ARE SUB- JECT TO THE LICENSE AGREEMENT IN THE CD BOOKLET. How to Contact Metrowerks: U.S.A. and international Metrowerks Corporation 9801 Metric, Suite 100 Austin, TX 78758 U.S.A. Canada Metrowerks Inc. 1500 du College, Suite 300 Ville St-Laurent, QC Canada H4L 5G6 Ordering Voice: (800) 377–5416 Fax: (512) 873–4901 World Wide Web http://www.metrowerks.com Registration information register@metrowerks.com Technical support cw_support@metrowerks.com Sales, marketing, & licensing sales@metrowerks.com CompuServe Go: Metrowerks Table of Contents 1 Introduction 11 What’s in this Reference? . . . . . . . . . . . . . . . . . 11 Read the Release Notes! . . . . . . . . . . . . . . . . . . 12 What’s New . . . . . . . . . . . . . . . . . . . . . . . 12 CodeWarrior Year 2000 Compliance . . . . . . . . . . . . . 13 Conventions Used in This Reference . . . . . . . . . . . . 14 2 Setting C/C++ Compiler Options 15 Setting C Compiler Options Overview. . . . . . . . . . . . 15 C/C++ Language Panel . . . . . . . . . . . . . . . . . . 15 C/C++ Warnings Panel . . . . . . . . . . . . . . . . . . 18 Treat All Warnings as Errors . . . . . . . . . . . . . . . 20 Illegal Pragmas . . . . . . . . . . . . . . . . . . . . 20 Empty Declarations. . . . . . . . . . . . . . . . . . . 20 Possible Errors . . . . . . . . . . . . . . . . . . . . . 21 Unused Variables. . . . . . . . . . . . . . . . . . . . 22 Unused Arguments . . . . . . . . . . . . . . . . . . . 23 Extra Commas . . . . . . . . . . . . . . . . . . . . . 24 Extended Error Checking . . . . . . . . . . . . . . . . 24 Hidden Virtual Functions . . . . . . . . . . . . . . . . 26 Implicit Arithmetic Conversions . . . . . . . . . . . . . 26 Non-Inlined Functions . . . . . . . . . . . . . . . . . 27 Inconsistent Use of ‘class’ and ‘struct’ Keywords . . . . . . 27 3 C Compiler 29 C Compiler Overview . . . . . . . . . . . . . . . . . . . 29 The CodeWarrior Implementation of C . . . . . . . . . . . 30 Identifiers . . . . . . . . . . . . . . . . . . . . . . . 30 Include Files . . . . . . . . . . . . . . . . . . . . . . 30 Prefix Files . . . . . . . . . . . . . . . . . . . . . . 32 Sizeof() Operator . . . . . . . . . . . . . . . . . . . . 32 Volatile Variables . . . . . . . . . . . . . . . . . . . . 33 Enumerated Types . . . . . . . . . . . . . . . . . . . 33 Extensions to ANSI/ISO C . . . . . . . . . . . . . . . . . 36 C Compilers Reference CCR–3 ANSI Strict . . . . . . . . . . . . . . . . . . . . . . 37 Using the wchar_t Type . . . . . . . . . . . . . . . . . 38 C++ Style Comments . . . . . . . . . . . . . . . . . . 38 Unnamed Arguments in Function Definitions . . . . . . . 38 A # not Followed by Argument in a Macro. . . . . . . . . 38 Using an Identifier After #endif . . . . . . . . . . . . . 39 Using Typecasted Pointers as lvalues . . . . . . . . . . . 40 Declaring Variables By Address . . . . . . . . . . . . . 40 ANSI Keywords Only. . . . . . . . . . . . . . . . . . 41 Expand Trigraphs . . . . . . . . . . . . . . . . . . . 42 Character Constants as Integer Values. . . . . . . . . . . 42 Inlining . . . . . . . . . . . . . . . . . . . . . . . . 43 Multibyte Strings and Comments. . . . . . . . . . . . . 44 Pool Strings . . . . . . . . . . . . . . . . . . . . . . 45 Reusing Strings . . . . . . . . . . . . . . . . . . . . 46 Require Function Prototypes . . . . . . . . . . . . . . . 47 Map Newlines to CR . . . . . . . . . . . . . . . . . . 49 Relaxed Pointer Type Rules . . . . . . . . . . . . . . . 50 Use Unsigned Chars . . . . . . . . . . . . . . . . . . 50 Using 64-bit Integers . . . . . . . . . . . . . . . . . . 51 Converting Pointers to Types of the Same Size . . . . . . . 51 Getting Alignment and Type Information at Compile-Time . 52 Arrays of Zero Length in Structures. . . . . . . . . . . . 52 Intrinsic Functions for Bit Rotation . . . . . . . . . . . . 53 The “D” Constant Suffix. . . . . . . . . . . . . . . . . 53 4 C++ Compiler 55 C++ Compiler Overview . . . . . . . . . . . . . . . . . 55 CodeWarrior Implementation of C++ . . . . . . . . . . . . 56 Implicit Return Statement for main() . . . . . . . . . . . 57 Keyword Ordering . . . . . . . . . . . . . . . . . . . 57 Additional Keywords . . . . . . . . . . . . . . . . . . 58 Conversions in the Conditional Operator . . . . . . . . . 58 Default Arguments in Member Functions . . . . . . . . . 58 Local Class Declarations with Inline Functions . . . . . . . 59 CCR–4 C Compilers Reference Copying and Constructing Class Objects . . . . . . . . . 59 Checking for Resources To Initialize Static Data . . . . . . 60 Calling an Inherited Member Function . . . . . . . . . . 61 Unsupported Extensions. . . . . . . . . . . . . . . . . . 64 Controlling the C++ Compiler . . . . . . . . . . . . . . . 64 Using the C++ Compiler Always . . . . . . . . . . . . . 64 Controlling ARM Conformance . . . . . . . . . . . . . 65 Controlling Exception Handling . . . . . . . . . . . . . 66 Controlling RTTI . . . . . . . . . . . . . . . . . . . . 66 Using the bool Type . . . . . . . . . . . . . . . . . . 67 Controlling C++ Extensions . . . . . . . . . . . . . . . 67 Working With C++ Exceptions . . . . . . . . . . . . . . . 68 Working With RTTI . . . . . . . . . . . . . . . . . . . . 69 Using the dynamic_cast Operator . . . . . . . . . . . . 69 Using the typeid Operator . . . . . . . . . . . . . . . . 71 Working With Templates. . . . . . . . . . . . . . . . . . 72 Declaring and Defining Templates . . . . . . . . . . . . 73 Instantiating a Template. . . . . . . . . . . . . . . . . 76 5 C++ and Embedded Systems 79 C++ and Embedded Systems Overview . . . . . . . . . . . 79 Activating EC++ . . . . . . . . . . . . . . . . . . . . . 79 Differences Between ANSI/ISO C++ and EC++ . . . . . . . . 80 Templates . . . . . . . . . . . . . . . . . . . . . . . 80 Libraries . . . . . . . . . . . . . . . . . . . . . . . 80 File Operations. . . . . . . . . . . . . . . . . . . . . 80 Localization . . . . . . . . . . . . . . . . . . . . . . 80 Exception Handling . . . . . . . . . . . . . . . . . . 81 Other Language Features . . . . . . . . . . . . . . . . 81 Meeting EC++ Specifications With CodeWarrior . . . . . . . 81 Language Related Issues . . . . . . . . . . . . . . . . 81 Library Related Issues . . . . . . . . . . . . . . . . . 82 Strategies for Smaller Code Size in C++ . . . . . . . . . . . 82 Size Optimizations . . . . . . . . . . . . . . . . . . . 83 Inlining . . . . . . . . . . . . . . . . . . . . . . . . 84 C Compilers Reference CCR–5 Virtual Functions . . . . . . . . . . . . . . . . . . . . 84 Runtime Type Identification . . . . . . . . . . . . . . . 85 Exception Handling . . . . . . . . . . . . . . . . . . 85 Operator New . . . . . . . . . . . . . . . . . . . . . 85 Multiple Inheritance . . . . . . . . . . . . . . . . . . 86 Virtual Inheritance . . . . . . . . . . . . . . . . . . . 86 Stream-Based Classes . . . . . . . . . . . . . . . . . . 86 Alternative Class Libraries. . . . . . . . . . . . . . . . 87 6 Pragmas and Symbols 89 Pragmas and Symbols Overview . . . . . . . . . . . . . . 89 Pragmas . . . . . . . . . . . . . . . . . . . . . . . . . 90 Pragma Syntax. . . . . . . . . . . . . . . . . . . . . 90 Pragma Scope . . . . . . . . . . . . . . . . . . . . . 91 a6frames . . . . . . . . . . . . . . . . . . . . . . . 92 align . . . . . . . . . . . . . . . . . . . . . . . . . 93 align_array_members . . . . . . . . . . . . . . . . . . 94 always_inline . . . . . . . . . . . . . . . . . . . . . 95 ANSI_strict . . . . . . . . . . . . . . . . . . . . . . 96 arg_dep_lookup . . . . . . . . . . . . . . . . . . . . 97 ARM_conform . . . . . . . . . . . . . . . . . . . . . 97 auto_inline . . . . . . . . . . . . . . . . . . . . . . 98 bool . . . . . . . . . . . . . . . . . . . . . . . . . 99 check_header_flags . . . . . . . . . . . . . . . . . . . 100 code_seg . . . . . . . . . . . . . . . . . . . . . . . 100 code68020 . . . . . . . . . . . . . . . . . . . . . . . 101 code68881 . . . . . . . . . . . . . . . . . . . . . . . 102 cplusplus . . . . . . . . . . . . . . . . . . . . . . . 103 cpp_extensions. . . . . . . . . . . . . . . . . . . . . 103 d0_pointers . . . . . . . . . . . . . . . . . . . . . . 104 data_seg . . . . . . . . . . . . . . . . . . . . . . . 106 def_inherited . . . . . . . . . . . . . . . . . . . . . 106 defer_codegen . . . . . . . . . . . . . . . . . . . . . 107 define_section . . . . . . . . . . . . . . . . . . . . . 108 direct_destruction . . . . . . . . . . . . . . . . . . . 112 CCR–6 C Compilers Reference direct_to_som . . . . . . . . . . . . . . . . . . . . . 112 disable_registers . . . . . . . . . . . . . . . . . . . . 113 dollar_identifiers . . . . . . . . . . . . . . . . . . . . 114 dont_inline . . . . . . . . . . . . . . . . . . . . . . 115 dont_reuse_strings . . . . . . . . . . . . . . . . . . . 115 ecplusplus. . . . . . . . . . . . . . . . . . . . . . . 116 EIPC_EIPSW . . . . . . . . . . . . . . . . . . . . . 117 enumsalwaysint . . . . . . . . . . . . . . . . . . . . 117 exceptions . . . . . . . . . . . . . . . . . . . . . . . 118 export . . . . . . . . . . . . . . . . . . . . . . . . 119 extended_errorcheck . . . . . . . . . . . . . . . . . . 121 far_code, near_code, smart_code . . . . . . . . . . . . . 122 far_data . . . . . . . . . . . . . . . . . . . . . . . . 123 far_strings. . . . . . . . . . . . . . . . . . . . . . . 124 far_vtables . . . . . . . . . . . . . . . . . . . . . . 124 faster_pch_gen. . . . . . . . . . . . . . . . . . . . . 125 float_constants . . . . . . . . . . . . . . . . . . . . . 125 force_active . . . . . . . . . . . . . . . . . . . . . . 126 fourbyteints . . . . . . . . . . . . . . . . . . . . . . 126 fp_contract . . . . . . . . . . . . . . . . . . . . . . 127 fp_pilot_traps . . . . . . . . . . . . . . . . . . . . . 128 function. . . . . . . . . . . . . . . . . . . . . . . . 129 global_optimizer, optimization_level . . . . . . . . . . . 129 IEEEdoubles . . . . . . . . . . . . . . . . . . . . . . 130 ignore_oldstyle . . . . . . . . . . . . . . . . . . . . 131 import . . . . . . . . . . . . . . . . . . . . . . . . 132 init_seg . . . . . . . . . . . . . . . . . . . . . . . . 133 inline_depth . . . . . . . . . . . . . . . . . . . . . . 134 inline_intrinsics . . . . . . . . . . . . . . . . . . . . 134 internal . . . . . . . . . . . . . . . . . . . . . . . . 135 interrupt . . . . . . . . . . . . . . . . . . . . . . . 136 k63d . . . . . . . . . . . . . . . . . . . . . . . . . 136 k63d_calls . . . . . . . . . . . . . . . . . . . . . . . 137 lib_export . . . . . . . . . . . . . . . . . . . . . . . 138 longlong . . . . . . . . . . . . . . . . . . . . . . . 138 C Compilers Reference CCR–7 longlong_enums . . . . . . . . . . . . . . . . . . . . 139 longlong_prepval . . . . . . . . . . . . . . . . . . . 139 macsbug, oldstyle_symbols . . . . . . . . . . . . . . . 140 mark . . . . . . . . . . . . . . . . . . . . . . . . . 141 message. . . . . . . . . . . . . . . . . . . . . . . . 142 microsoft_exceptions . . . . . . . . . . . . . . . . . . 142 microsoft_RTTI . . . . . . . . . . . . . . . . . . . . 142 mmx . . . . . . . . . . . . . . . . . . . . . . . . . 143 mmx_call . . . . . . . . . . . . . . . . . . . . . . . 143 mpwc. . . . . . . . . . . . . . . . . . . . . . . . . 144 mpwc_newline. . . . . . . . . . . . . . . . . . . . . 145 mpwc_relax . . . . . . . . . . . . . . . . . . . . . . 146 no_register_coloring . . . . . . . . . . . . . . . . . . 147 no_static_dtors. . . . . . . . . . . . . . . . . . . . . 148 once . . . . . . . . . . . . . . . . . . . . . . . . . 149 only_std_keywords. . . . . . . . . . . . . . . . . . . 149 opt_common_subs . . . . . . . . . . . . . . . . . . . 150 opt_dead_assignments . . . . . . . . . . . . . . . . . 150 opt_dead_code. . . . . . . . . . . . . . . . . . . . . 151 opt_lifetimes. . . . . . . . . . . . . . . . . . . . . . 151 opt_loop_invariants . . . . . . . . . . . . . . . . . . 152 opt_propagation . . . . . . . . . . . . . . . . . . . . 152 opt_strength_reduction . . . . . . . . . . . . . . . . . 153 opt_unroll_loops . . . . . . . . . . . . . . . . . . . . 153 opt_vectorize_loops . . . . . . . . . . . . . . . . . . 154 optimization_level . . . . . . . . . . . . . . . . . . . 154 optimize_for_size . . . . . . . . . . . . . . . . . . . 154 oldstyle_symbols. . . . . . . . . . . . . . . . . . . . 155 pack . . . . . . . . . . . . . . . . . . . . . . . . . 155 parameter . . . . . . . . . . . . . . . . . . . . . . . 156 pcrelstrings . . . . . . . . . . . . . . . . . . . . . . 157 peephole . . . . . . . . . . . . . . . . . . . . . . . 158 pointers_in_A0, pointers_in_D0 . . . . . . . . . . . . . 159 pool_data . . . . . . . . . . . . . . . . . . . . . . . 160 pool_strings . . . . . . . . . . . . . . . . . . . . . . 161 CCR–8 C Compilers Reference pop, push . . . . . . . . . . . . . . . . . . . . . . . 161 precompile_target . . . . . . . . . . . . . . . . . . . 162 profile . . . . . . . . . . . . . . . . . . . . . . . . 163 readonly_strings . . . . . . . . . . . . . . . . . . . . 164 register_coloring . . . . . . . . . . . . . . . . . . . . 165 require_prototypes . . . . . . . . . . . . . . . . . . . 165 RTTI . . . . . . . . . . . . . . . . . . . . . . . . . 166 scheduling . . . . . . . . . . . . . . . . . . . . . . 166 section . . . . . . . . . . . . . . . . . . . . . . . . 167 segment. . . . . . . . . . . . . . . . . . . . . . . . 174 side_effects . . . . . . . . . . . . . . . . . . . . . . 175 simple_prepdump . . . . . . . . . . . . . . . . . . . 176 SOMCallOptimization . . . . . . . . . . . . . . . . . 176 SOMCallStyle . . . . . . . . . . . . . . . . . . . . . 177 SOMCheckEnvironment . . . . . . . . . . . . . . . . 177 SOMClassVersion . . . . . . . . . . . . . . . . . . . 179 SOMMetaClass . . . . . . . . . . . . . . . . . . . . 180 SOMReleaseOrder . . . . . . . . . . . . . . . . . . . 180 stack_cleanup . . . . . . . . . . . . . . . . . . . . . 181 static_inlines. . . . . . . . . . . . . . . . . . . . . . 182 suppress_init_code . . . . . . . . . . . . . . . . . . . 182 sym . . . . . . . . . . . . . . . . . . . . . . . . . 183 syspath_once . . . . . . . . . . . . . . . . . . . . . 184 toc_data. . . . . . . . . . . . . . . . . . . . . . . . 184 trigraphs . . . . . . . . . . . . . . . . . . . . . . . 185 traceback . . . . . . . . . . . . . . . . . . . . . . . 185 unsigned_char . . . . . . . . . . . . . . . . . . . . . 186 unused . . . . . . . . . . . . . . . . . . . . . . . . 187 use_fp_instructions . . . . . . . . . . . . . . . . . . . 187 use_frame . . . . . . . . . . . . . . . . . . . . . . . 188 use_mask_registers . . . . . . . . . . . . . . . . . . . 188 warn_emptydecl . . . . . . . . . . . . . . . . . . . . 189 warning_errors . . . . . . . . . . . . . . . . . . . . 189 warn_extracomma . . . . . . . . . . . . . . . . . . . 190 warn_hidevirtual. . . . . . . . . . . . . . . . . . . . 190 C Compilers Reference CCR–9 warn_illpragma . . . . . . . . . . . . . . . . . . . . 191 warn_implicitconv . . . . . . . . . . . . . . . . . . . 192 warn_notinlined . . . . . . . . . . . . . . . . . . . . 193 warn_padding . . . . . . . . . . . . . . . . . . . . . 193 warn_possunwant . . . . . . . . . . . . . . . . . . . 194 warn_structclass . . . . . . . . . . . . . . . . . . . . 195 warn_unusedarg . . . . . . . . . . . . . . . . . . . . 196 warn_unusedvar . . . . . . . . . . . . . . . . . . . . 196 warning. . . . . . . . . . . . . . . . . . . . . . . . 197 wchar_type . . . . . . . . . . . . . . . . . . . . . . 198 Predefined Symbols . . . . . . . . . . . . . . . . . . . . 198 ANSI Predefined Symbols . . . . . . . . . . . . . . . . 198 Metrowerks Predefined Symbols . . . . . . . . . . . . . 200 Checking Options . . . . . . . . . . . . . . . . . . . . 202 Index 211 CCR–10 C Compilers Reference 1 Introduction This manual describes the CodeWarrior C and C++ compilers, and how to use them to generate code for all CodeWarrior targets. There are chapters that cover information about the C/C++ compiler that applies to all targets. Information that is specific to a particular tar- get operating system or processor appears in separate chapters, one per target. The sections in this introduction are: • What’s in this Reference? • Read the Release Notes! • What’s New • CodeWarrior Year 2000 Compliance • Conventions Used in This Reference What’s in this Reference? The manual is organized into these principle sections: • Interface—how to set compiler options • Language—generic information on the compilers as they apply to all CW targets • Pragmas—information on all pragmas for all targets Each chapter begins with an overview section. Table 1.1 lists each of these and describes what each chapter in this manual covers. C Compilers Reference CCR–11 Introduction Read the Release Notes! Table 1.1 What’s in this reference Read the Release Notes! Because of last-minute changes to the CodeWarrior C/C++ com- piler, some of the information may be inaccurate. Please read the Release Notes on the CodeWarrior CD for the latest up-to-date in- formation. What’s New This reference has been updated to cover CodeWarrior C/C++ ver- sion 2.3 and later. New and changed topics in this reference are: • “Introduction” on page 11—this chapter has been updated to follow the organization followed by other CodeWarrior lan- guage references • “ANSI Strict” on page 37—updated to cover the “D” constant suffix • “ANSI Keywords Only” on page 41—updated to note that far is no longer a keyword in some versions of CodeWarrior C/C++ This chapter… Describes… Setting C Compiler Op- tions Overview where to find information on the C/C++ Language and C/ C++ Warnings settings panels. C Compiler Overview how the CodeWarrior C/C++ compiler implements C C++ Compiler Overview how the CodeWarrior C/C++ compiler implements C++ features that are not shared by C. C++ and Embedded Sys- tems Overview how to use CodeWarrior C++ for embedded systems de- velopment and how to design programs to anticipate the proposed EC++ (Embedded C++) standard. Pragmas and Symbols Overview the pragmas and predefined symbols available with CodeWarrior C/C++ compiler CCR–12 C Compilers Reference Introduction CodeWarrior Year 2000 Compliance • “Character Constants as Integer Values” on page 42—up- dated to distinguish integer values denoted with character string constants from multi-byte character sets • “Intrinsic Functions for Bit Rotation” on page 53—describes new “built-in” functions • “The “D” Constant Suffix” on page 53—describes how to ex- plicitly specify floating point constant values of type double • “Using the bool Type” on page 67—updated to distinguish between the ANS/ISO C++ Standard’s definition of the bool type and its non-standard implementations • “Declaring and Defining Templates” on page 73—new infor- mation on improved conformance with the ANS/ISO C++ Standard for template declarations • “direct_destruction” on page 112—this pragma is obsolete and is no longer available • “float_constants” on page 125—a new pragma to treat float- ing point constants as values of type float by default • “longlong_prepval” on page 139—a new pragma to allow the preprocessor to handle expressions of type long long • “message” on page 142—a new pragma for issuing messages to the user • “no_static_dtors” on page 148—a new pragma for control- ling the generation of C++ static destructors • “warn_padding” on page 193—a new pragma for controlling warnings for data structure alignment CodeWarrior Year 2000 Compliance The Products provided by Metrowerks under the License agree- ment process dates only to the extent that the Products use date data provided by the host or target operating system for date representa- tions used in internal processes, such as file modifications. Any Year 2000 Compliance issues resulting from the operation of the Products are therefore necessarily subject to the Year 2000 Compliance of the relevant host or target operating system. Metrowerks directs you to the relevant statements of Microsoft Corporation, Sun Microsys- tems, Inc., Apple Computer, Inc., and other host or target operating C Compilers Reference CCR–13 Introduction Conventions Used in This Reference systems relating to the Year 2000 Compliance of their operating sys- tems. Except as expressly described above, the Products, in them- selves, do not process date data and therefore do not implicate Year 2000 Compliance issues. For additional information, visit: http://www.metrowerks.com/ about/y2k.html. Conventions Used in This Reference This manual includes syntax examples that describe how to use cer- tain statements, such as the following: #pragma parameter [return-reg] func-name [param-regs] #pragma optimize_for_size on | off | reset Table 1.2 describes how to interpret these statements. Table 1.2 Understanding Syntax Examples If the text looks like… Then… literal Include it in your statement exactly as it’s printed. 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 and only one of the symbols in the statement: either a, b, or c. [a] Include this symbol only if necessary. The text after the syntax ex- ample describes when to include it. CCR–14 C Compilers Reference 2 Setting C/C++ Compiler Options This chapter describes where to find information on the C/C++ Compiler and C/C++ Warnings settings panels. Setting C Compiler Options Overview This section contains the following sections: • “C/C++ Language Panel” on page 15, illustrates each option available to you, and tells you where that option is explained fully. • “C/C++ Warnings Panel” on page 18, illustrates each com- piler warning available to you, and tells you where that warning is explained fully. The C/C++ Compiler settings panel, where you set compiler op- tions, is also known as the C/C++ Language settings panel. C/C++ Language Panel You may configure how the C/C++ compiler works by setting a va- riety of options. You set these options in the C/C++ Compiler set- tings panel, shown in Figure 2.1. For information on how to display a particular settings panel, see the IDE User Guide. TIP: Another way to set these options is to use pragma direc- tives in your source code. See “Pragmas and Symbols” on page 89 for more information. C Compilers Reference CCR–15 Setting C/C++ Compiler Options C/C++ Language Panel Each compiler option has a corresponding pragma that you can use in source code to turn that particular option on or off, regardless of the settings in the C/C++ Compiler panel. In addition, there are some pragmas that do not have a corresponding setting in the C/ C++ Compiler panel. See “Pragmas and Symbols Overview” on page 89 for details on each available pragma. You may also use a special preprocessor directive in your code to determine the current setting of each option. See “Checking Op- tions” on page 202 for information on how to use this directive. Some of the options shown in Figure 2.1 may not appear for some targets. For example, the Direct to SOM item appears for Mac OS. Figure 2.1 The C/C++ Compiler Settings Panel CCR–16 C Compilers Reference Setting C/C++ Compiler Options C/C++ Language Panel Most of the items in this panel are discussed elsewhere in this man- ual, because they are closely related to how the compiler imple- ments standard C and C++. Other items This table lists where to find information about the other items in this panel. This item… Is described here… Activate C++ Compiler “Using the C++ Compiler Always” on page 64. ARM Conformance “Controlling ARM Conformance” on page 65 Enable C++ Exceptions “Controlling C++ Extensions” on page 67 Enable RTTI “Controlling RTTI” on page 66 Inline Depth Auto-inline “Inlining” on page 43 Pool Strings “Pool Strings” on page 45 Don’t Reuse Strings “Reusing Strings” on page 46 Require Function Prototypes “Require Function Prototypes” on page 47 Enable bool Support “Using the bool Type” on page 67 Enable wchar_t Support “Using the wchar_t Type” on page 38 ANSI Strict “ANSI Strict” on page 37 ANSI Keywords Only “ANSI Keywords Only” on page 41 Expand Trigraphs “Expand Trigraphs” on page 42 Multi-Byte Aware “Multibyte Strings and Comments” on page 44 Direct to SOM Targeting Mac OS manual Map Newlines to CR “Map Newlines to CR” on page 49 Relaxed Pointer Type Rules “Relaxed Pointer Type Rules” on page 50 Enums Always Int “Enumerated Types” on page 33 C Compilers Reference CCR–17 Setting C/C++ Compiler Options C/C++ Warnings Panel C/C++ Warnings Panel The C/C++ compiler generates errors when it cannot understand your code as a result of improper syntax. In addition to errors, the compiler can generate a series of helpful warnings that alert you to legal but usually unintentional syntax. These mistakes are legal C and C++ code, but the code might not do what you expect. When the compiler finds one of these possible mistakes, it can gen- erate a warning. Warnings are not fatal. Unless you choose to treat these warnings as errors, your code will still compile (although it may not run correctly). This section describes the items in the C/C++ Warnings panel. You determine which warnings you receive by setting options in the panel. Figure 2.2 illustrates this panel. Each warning also has a corresponding pragma that you can use in source code to turn that particular warning on or off for a limited piece of code. See “Pragmas and Symbols Overview” on page 89 for details on each available pragma. You may also use a special preprocessor directive in your code to determine the current setting of each option. See “Checking Op- tions” on page 202 for information on how to use this directive. For information on how to display a particular settings panel, see the IDE User Guide. Use Unsigned Chars “Use Unsigned Chars” on page 50 Prefix File “Prefix Files” on page 32 EC++ Compatibility Mode “Activating EC++” on page 79 Enable Objective C Targeting Rhapsody manual This item… Is described here… CCR–18 C Compilers Reference Setting C/C++ Compiler Options C/C++ Warnings Panel Figure 2.2 The C/C++ Warnings Settings Panel The items in this panel are: • “Treat All Warnings as Errors” on page 20 • “Illegal Pragmas” on page 20 • “Empty Declarations” on page 20 • “Possible Errors” on page 21 • “Unused Variables” on page 22 • “Unused Arguments” on page 23 • “Extra Commas” on page 24 • “Extended Error Checking” on page 24 • “Hidden Virtual Functions” on page 26 • “Implicit Arithmetic Conversions” on page 26 C Compilers Reference CCR–19 Setting C/C++ Compiler Options C/C++ Warnings Panel • “Non-Inlined Functions” on page 27 • “Inconsistent Use of ‘class’ and ‘struct’ Keywords” on page 27 Treat All Warnings as Errors When the Treat All Warnings as Errors option is on, the compiler treats all warnings as though they were errors. It will not compile a file until all warnings are resolved. The Treat All Warnings as Errors option corresponds to the pragma warning_errors, described at“warning_errors” on page 189. To check whether this option is on, use __option (warning_errors).See “Checking Options” on page 202 for in- formation on how to use this directive. Illegal Pragmas If the Illegal Pragmas option is on, the compiler displays a warning when it encounters an illegal pragma. For example, these pragma statements generate warnings: #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 option corresponds to the pragma warn_illpragma, described at “warn_illpragma” on page 191. To check whether this option is on, use __option (warn_illpragma).See “Checking Options” on page 202 for in- formation on how to use this directive. Empty Declarations If the Empty Declarations option is on, the compiler displays a warning when it encounters a declaration with no variable name. For example: CCR–20 C Compilers Reference Setting C/C++ Compiler Options C/C++ Warnings Panel int ; // WARNING int i; // OK The Empty Declarations option corresponds to the pragma warn_emptydecl, described at “warn_emptydecl” on page 189. To check whether this option is on, use __option (warn_emptydecl). See “Checking Options” on page 202 for in- formation on how to use this directive. Possible Errors If the Possible Errors option is on, the compiler checks for some common typographical mistakes that are legal C syntax but that may have unwanted side effects, such as putting in unintended semicolons or confusing = and ==. The compiler generates a warn- ing if it encounters one of these: • An assignment in a logical expression or the condition in an if, while, or for expression. This check is useful if you fre- quently use = when you meant to use ==. For example: if (a=b) f(); // WARNING: a=b is an assignment if ((a=b)!=0) f(); // OK: (a=b)!=0 is a comparison if (a==b) f(); // OK: (a==b) is a comparison • An equal comparison in a statement that contains a single ex- pression. This check is useful if you frequently use == when you meant to use =. For example: a == 0; // WARNING: This is a comparison. a = 0; // OK: This is an assignment • A semicolon (;) directly after a while, if, or for statement. For example, the statement generates a warning and is prob- ably an unintended infinite loop: C Compilers Reference CCR–21 Setting C/C++ Compiler Options C/C++ Warnings Panel while (i++); // WARNING: Unintended infinite loop If you intended to create an infinite loop, put white space or a com- ment between the while statement and the semicolon. For example, these statements do not generate errors or warnings, and ensure that you will win the hearts of everyone using your software when the code is executed. while (i++) ; // OK: White space separation while (i++) /*: Comment separation */ ; The Possible Errors option corresponds to the pragma warn_possunwant, described at “warn_possunwant” on page 194. To check whether this option is on, use __option (warn_possunwant). See “Checking Options” on page 202 for in- formation on how to use this directive. Unused Variables If the Unused Variables option is on, the compiler generates a warning when it encounters a variable that you declare but do not use. This check helps you find misspelled variable names and vari- ables you have written out of your program. For example: 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 don’t use, use the pragma unused, as in this example: void foo(void) { int i, temp, error; #pragma unused (i, temp) /* Compiler won’t warn that i and temp CCR–22 C Compilers Reference Setting C/C++ Compiler Options C/C++ Warnings Panel error=do_something(); /* are not used */ } The Unused Variables option corresponds to the pragma warn_unusedvar, described at “warn_unusedvar” on page 196. To check whether this option is on, use __option (warn_unusedvar). See “Checking Options” on page 202 for in- formation on how to use this directive. Unused Arguments If the Unused Arguments option is on, the compiler generates a warning when it encounters an argument you declare but do not use. This check helps you find misspelled argument names and ar- guments you have written out of your program. void foo(int temp,int errer); // ERROR: errer is misspelled { error = do_something(); // WARNING: temp and error are unused. } If you need to declare an argument that you don’t use, there are two ways to avoid this warning. You can use the pragma unused, as in this example: void foo(int temp, int error) { #pragma unused (temp) /* Compiler won’t warn that temp is not used */ error=do_something(); } You can also turn off the ANSI Strict option, and not give the un- used argument a name. (See “Unnamed Arguments in Function Definitions” on page 38.) For example: C Compilers Reference CCR–23 Setting C/C++ Compiler Options C/C++ Warnings Panel void foo(int /* temp */, int error) { /* Compiler won’t warn that temp is not used, it’s not named error=do_something(); */ } The Unused Arguments option corresponds to the pragma warn_unusedarg, described at “warn_unusedarg” on page 196. To check whether this option is on, use __option (warn_unusedarg). See “Checking Options” on page 202 for in- formation on how to use this directive. Extra Commas If the Extra Commas option is on, the compiler generates a warning when it encounters an extra comma. For example, this statement is legal in C, but it causes a warning when this option is on: int a[] = { 1, 2, 3, 4, }; // ^ WARNING: Extra comma after 4 The Extra Commas option corresponds to the pragma warn_extracomma, described at “warn_extracomma” on page 190. To check whether this option is on, use __option (warn_extracomma). See “Checking Options” on page 202 for in- formation on how to use this directive. Extended Error Checking If the Extended Error Checking option is on, the C compiler gener- ates a warning (not an error) if it encounters one of these syntax problems: • A non-void function that does not contain a return state- ment. For example, this would generate a warning: main() /* assumed to return int */ { CCR–24 C Compilers Reference Setting C/C++ Compiler Options C/C++ Warnings Panel printf ("hello world\n"); } /* WARNING: no return statement */ This would be OK: void main() /* function declared to return void */ { printf ("hello world\n"); } • Assigning an integer or floating-point value to an enum type. For example: enum Day { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday } d; d = 5; /* WARNING */ d = Monday; /* OK */ d = (Day)3 ; /* OK */ • An empty return statement (return;) in a function that is not declared void. For example, this code would generate a warning: int MyInit(void) { int err = GetMyResources(); if (err !=0) return; /* ERROR: Empty return statement */ /* ... */ This would be OK: int MyInit(void) { int err = GetMyResources(); if (err!=0) return -1; /* OK */ /* ... */ C Compilers Reference CCR–25 Setting C/C++ Compiler Options C/C++ Warnings Panel The Extended Error Checking option corresponds to the pragma extended_errorcheck, described at “extended_errorcheck” on page 121. To check whether this option is on, use __option (extended_errorcheck). See “Checking Options” on page 202 for information on how to use this directive. Hidden Virtual Functions If the Hidden virtual functions option is on, the compiler generates a warning if you declare a non-virtual member function in a sub- class that hides an inherited virtual function in a superclass. One function hides another if it has the same name but a different argu- ment types. For example: 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 option corresponds to the pragma warn_hidevirtual, described at “warn_hidevirtual” on page 190. To check whether this option is on, use __option (warn_hidevirtual). See “Checking Options” on page 202 for information on how to use this directive. Implicit Arithmetic Conversions If the Implicit Arithmetic Conversions option is on, the compiler is- sues a warning if the destination of an operation isn’t large enough to hold all possible results. For example, assigning the value of a variable of type long to a variable of type char will result in a warning if this option is on. CCR–26 C Compilers Reference Setting C/C++ Compiler Options C/C++ Warnings Panel Non-Inlined Functions If the Non-Inlined Functions option is on, the compiler issues a warning when it is unable to inline a function. This option corresponds to pragma warn_notinlined. To check whether this option is on, use __option (warn_notinlined). See “Checking Options” on page 202 for information on how to use this directive. Inconsistent Use of ‘class’ and ‘struct’ Keywords If the Inconsistent Use of ‘class’ and ‘struct’ Keywords option is on, the compiler issues a warning if the class and struct key- words are used in the definition and declaration of the same identi- fier. class X; struct X { int a; }; // warning Use this warning when linking (with static or dynamic libraries) with object code produced from another C++ compiler that makes a distinction between class and struct variables in its name “man- gling.” This option corresponds to pragma warn_structclass. To check whether this option is on, use __option (warn_structclass). See “Checking Options” on page 202 for information on how to use this directive. C Compilers Reference CCR–27 Setting C/C++ Compiler Options C/C++ Warnings Panel CCR–28 C Compilers Reference 3 C Compiler This chapter describes how the CodeWarrior C compiler imple- ments the C language. C Compiler Overview This chapter discusses the CodeWarrior C compiler as it applies to all CodeWarrior targets. For the most part, the information in this chapter is equally applicable to any operating system or processor. Other chapters in this manual discuss other features of the compiler that are specific to particular operating systems and processors. For a complete picture, you need to consider all the information relating your target of interest. This chapter does not cover C++ features. For more information on the C++ language, see “C++ Compiler Overview” on page 55. This chapter contains the following sections: • “The CodeWarrior Implementation of C” on page 30 explains how the CodeWarrior compiler implements certain parts of the standard C language. • “Extensions to ANSI/ISO C” on page 36 describe some of CodeWarrior C’s extensions to the C standards. You’ll find frequent references to K&R §A, which is Appendix A, “Reference Manual,” of The C Programming Language, Second Edition (Prentice Hall) by Kernighan and Ritchie. These references show you where to look for more information on the topics discussed in the corresponding section. C Compilers Reference CCR–29 C Compiler The CodeWarrior Implementation of C The CodeWarrior Implementation of C This section describes how CodeWarrior implements many parts of the C programming language. For information on the parts of the C++ language that are specific to C++, see “C++ Compiler Over- view” on page 55. This section discusses the following topics: • Identifiers • Include Files • Prefix Files • Sizeof() Operator • Volatile Variables • Enumerated Types Identifiers (K&R, §A2.3) The C compiler lets let you create identifiers of any size. However, only the first 255 characters are significant for inter- nal and external linkage. Include Files (K&R, §A12.4) The C compiler can nest #include files up to 32 times. An include file is nested if another #include file uses it in an #include statement. For example, if Main.c includes the file MyFunctions.h, which includes the file MyUtilities.h, the file MyUtilities.h is nested once. You can use full path names in #include directives, as in this ex- ample for Mac OS: #include "HD:Tools:my headers:macros.h" The CodeWarrior IDE lets you specify where the compiler looks for #include files with the Access Paths settings panel, shown in Fig- ure 3.1. It contains two lists of folders: the User list and the System list. By default, each list contains one folder. The User list contains {Project ƒ}, which is the folder that the project file is in and all CCR–30 C Compilers Reference C Compiler The CodeWarrior Implementation of C the folders it contains. The System list contains {Compiler ƒ}, which is the folder that CodeWarrior is in, and all the folders it con- tains. Figure 3.1 The Access Paths settings panel The compiler searches for a #include file in either the System list or both the User and System lists, depending on which characters enclose the file. If you enclose the file in brackets (#include <stdio.h>), the compiler looks for the file in the System list. If you enclose the file in quotes (#include "myfuncs.h"), the compiler looks for the file in the User list first, and then in the System list. In general, use brackets for include files that are for a large variety of projects and use quotes for include files that are for a specific project. C Compilers Reference CCR–31 C Compiler The CodeWarrior Implementation of C If the Always Search User Paths option is selected, the compiler also uses the User access paths for include files enclosed in brackets (#include <file>). For information on how to modify the Access Paths settings panel, see the CodeWarrior IDE User Guide. See also: “Prefix Files” on page 32. TIP: If you’re using the compiler under Apple Computer’s MPW programming environment, you can specify where to find #include files with the -i compiler option and the {CIncludes} variable, described in Command-Line Tools Manual and MPW Command Reference. Prefix Files If you have a single file you wish to include in every source file in a project, you can use the Prefix File item in the C/C++ Language Panel. Enter the name of the file in the Prefix File edit field in this panel. The compiler automatically includes this file (and any files that it, in turn, includes) in every source file in the project’s current target. This is an excellent way to include a precompiled header file in a project. This field is also used as an alternative to the -d option commonly issued to compilers that operate at the command line. See also: “Include Files” on page 30. Sizeof() Operator The sizeof() operator returns a number of type size_t, which the compiler declares to be of type unsigned long int (in the file stddef.h). If your code assumes that sizeof() returns a number of type int, it may not work correctly. CCR–32 C Compilers Reference C Compiler The CodeWarrior Implementation of C Volatile Variables (K&R, §A4.4) When you declare a variable to be volatile the C com- piler takes the following precautions: • It does not store the variable in a register. • It computes the variable’s address every time a piece of code references the variable. Listing 3.1 shows an example of volatile variables. Listing 3.1 volatile variables void main(void) { int i[100]; volatile int a, b; a = 5; b = 20; i[a + b] = 15; i[a + b] = 30; } The compiler does not place the value of a, b, or a+b in registers. Also, the compiler recalculates a+b in both assignment statements. Enumerated Types (K&R, §A8.4) This section describes how the C compiler selects the underlying integer data type for an enumerated type. The compiler behavior is controlled primarily by the Enums Always Int option in the C/C++ Language Panel. The compiler uses one of two different strategies, depending on the setting of the Enums Always Int option. If Enums Always Int is on, the underlying type is always signed int. All enumerators must be no larger than a signed int. If an C Compilers Reference CCR–33 C Compiler The CodeWarrior Implementation of C enumerated constant is larger than an int, the compiler generates an error. However, if the ANSI Strict option is off, enumerators that can be represented as an unsigned int are implicitly converted to signed int. For example: #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). See “ANSI Strict” on page 37 for additional features of that setting. If Enums Always Int is off, the compiler chooses the integral data type that supports the largest enumerated constant. The type could be as small as a char or as large as a long int. It could even be a 64-bit long long value. To be more precise, if Enums Always Int is off, the compiler picks one of the following: • If all enumerators are positive, it picks the smallest unsigned integral base type that is large enough to represent all enu- merators • If at least one enumerator is negative, it picks the smallest signed integral base type large enough to represent all enu- merators. For example: #pragma enumsalwaysint off enum { a=0,b=1 }; // base type: unsigned char CCR–34 C Compilers Reference C Compiler The CodeWarrior Implementation of C enum { c=0,d=-1 }; // base type: signed char enum { e=0,f=128,g=-1 }; // base type: signed short The compiler will use long long data types only if Enums Always Int is off and the longlong_enums pragma is on. (There is no set- tings panel option corresponding to the longlong_enums pragma.) For example: #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 the longlong_enums pragma is off and ANSI Strict is on, you cannot mix unsigned 32-bit enumerators greater than 0x7FFFFFFF and negative enumerators. If both the longlong_enums pragma and the ANSI Strict option are off, huge unsigned 32-bit enumerators are implicitly converted to signed 32- bit types. For example: #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 option corresponds to the pragma enum- salwaysint. To check whether this option is on, use __option (enumsalwaysint). By default, this option is off. See also “enumsalwaysint” on page 117, “longlong_enums” on page 139, and “Checking Options” on page 202. C Compilers Reference CCR–35 C Compiler Extensions to ANSI/ISO C Extensions to ANSI/ISO C This section describes CodeWarrior extensions to the C standard that apply to all targets. In most cases you turn the extension on or off with an option in the C/C++ Language Panel. See “C/C++ Lan- guage Panel” on page 15 for information about that panel. The topics in this section are: • “ANSI Strict” on page 37 • “C++ Style Comments” on page 38 • “Unnamed Arguments in Function Definitions” on page 38 • “A # not Followed by Argument in a Macro” on page 38 • “Using an Identifier After #endif” on page 39 • “Using Typecasted Pointers as lvalues” on page 40 • “Declaring Variables By Address” on page 40 • “ANSI Keywords Only” on page 41 • “Expand Trigraphs” on page 42 • “Character Constants as Integer Values” on page 42 • “Inlining” on page 43 • “Multibyte Strings and Comments” on page 44 • “Reusing Strings” on page 46 • “Require Function Prototypes” on page 47 • “Map Newlines to CR” on page 49 • “Relaxed Pointer Type Rules” on page 50 • “Use Unsigned Chars” on page 50 • “Using 64-bit Integers” on page 51 • “Converting Pointers to Types of the Same Size” on page 51 • “Getting Alignment and Type Information at Compile-Time” on page 52 • “Arrays of Zero Length in Structures” on page 52 • “Intrinsic Functions for Bit Rotation” on page 53 • “The “D” Constant Suffix” on page 53 CCR–36 C Compilers Reference C Compiler Extensions to ANSI/ISO C For information on target-specific extensions, you should refer to the Target manual for the particular target in which you are inter- ested. ANSI Strict The ANSI Strict option in the C/C++ Language Panel affects several extensions to the C language supported by the CodeWarrior com- piler. The extensions are: • C++ Style Comments • Unnamed Arguments in Function Definitions • A # not Followed by Argument in a Macro • 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 In each case the extension is only available if the ANSI Strict setting is off. If the ANSI Strict setting is on, then these extensions to the ANSI C standard are disabled. You cannot turn on the extensions controlled by the ANSI Strict set- ting individually. They are all on or off depending upon the setting. This setting may affect how the compiler handles enumerated con- stants. See “Enumerated Types” on page 33 for more information. This setting may also affects the main() function for C++ pro- grams. See “Implicit Return Statement for main()” on page 57.. The ANSI Strict option corresponds to the pragma ANSI_strict. To check whether this option is on, use __option (ANSI_strict). See also “ANSI_strict” on page 96. and “Checking Options” on page 202. C Compilers Reference CCR–37 C Compiler Extensions to ANSI/ISO C Using the wchar_t Type Turn on the Enable wchar_t Support option if you want to use the standard C++ wchar_t type to represent wide characters. Turn this option off to use the regular character type, char. C++ Style Comments (K&R, §A2.2) The C compiler can accept C++ comments in source code. In a C++ comment, anything that follows // on a line is con- sidered a comment. For example: a = b; // This is a C++ comment To turn this feature on, turn off the ANSI Strict setting in the C/C++ Language Panel. If the ANSI Strict setting is on, then this extension to standard C is disabled. See also: “ANSI Strict” on page 37. Unnamed Arguments in Function Definitions (K&R, §A10.1) The C compiler can accept an unnamed argument in a function definition. For example: void f(int ) {} /* OK, if ANSI Strict is off */ void f(int i) {} /* ALWAYS OK */ To turn this feature on, turn off the ANSI Strict setting in the C/C++ Language Panel. If the ANSI Strict setting is on, then this extension to standard C is disabled. See also: “ANSI Strict” on page 37. A # not Followed by Argument in a Macro (K&R, §A12.3) The C compiler can accept a # token not followed by an argument in a macro definition. For example: CCR–38 C Compilers Reference C Compiler Extensions to ANSI/ISO C #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 turn this feature on, turn off the ANSI Strict setting in the C/C++ Language Panel. If the ANSI Strict setting is on, then this extension to standard C is disabled. See also: “ANSI Strict” on page 37. Using an Identifier After #endif (K&R, §A12.5) The C compiler can accept an identifier token after #endif and #else. This extension helps you match an #endif statement with its corresponding #if, #ifdef, or #ifndef state- ment, as shown here: #ifdef __MWERKS__ # ifndef __cplusplus /* * . . . */ # endif __cplusplus #endif __MWERKS__ To turn this feature on, turn off the ANSI Strict setting in the C/C++ Language Panel. If the ANSI Strict setting is on, then this extension to standard C is disabled. See also: “ANSI Strict” on page 37. TIP: If you turn on the ANSI Strict option (disabling the exten- sion), you can still use the same idea to help you match your #if- def and #endif directives. Simply put the identifiers into com- ments, as in the following example. C Compilers Reference CCR–39 C Compiler Extensions to ANSI/ISO C #ifdef __MWERKS__ # ifndef __cplusplus /* * . . . */ # endif /* __cplusplus */ #endif /* __MWERKS__ */ Using Typecasted Pointers as lvalues The C compiler can accept a pointer that you typecast to another pointer type as an lvalue. For example: char *cp; ((long *) cp)++; /* OK if ANSI Strict is off. */ To turn this feature on, turn off the ANSI Strict setting in the C/C++ Language Panel. If the ANSI Strict setting is on, then this extension to standard C is disabled. See also: “ANSI Strict” on page 37. Declaring Variables By Address (K&R, §A8.7) The C compiler lets you specify the address that a variable refers to. For example, this definition defines MemErr to contain whatever is at the address 0x0220: short MemErr:0x220; The variable MemErr contains whatever is at the address 0x220. WARNING! For Mac OS programming, avoid using this exten- sion to refer to low-memory globals. To ensure that your programs CCR–40 C Compilers Reference C Compiler Extensions to ANSI/ISO C are compatible with future versions of the Mac OS, use the func- tions defined in the LowMem.h header file. This extension cannot be turned off. There is no corresponding pragma or setting in the C/C++ Language Panel. ANSI Keywords Only (K&R, §A2.4) The C compiler can recognize several additional re- served keywords. The ANSI Keywords Only option in the C/C++ Language Panel controls whether the compiler recognizes these keywords. If this option is on, the compiler generates an error if it encounters any of the CodeWarrior C additional keywords. If you’re writing code that must follow the ANSI/ISO standard strictly, turn on the ANSI Keywords Only option in the settings panel. When this option is off, these additional keywords are available to you: • asm This keyword lets you use the compiler’s built-in inline as- sembler. (K&R, §A10.1) For more information on the inline assemblers, consult: • far The CodeWarrior C/C++ compiler for Motorola 68K proces- sors treats far as a keyword. Other versions of CodeWarrior C/C++ do not recognize far as a keyword. • inline Lets you declare a C function to be inline. For more informa- tion, see “Inlining” on page 43. • pascal This keyword is used in Mac OS programming. • __stdcall This keyword is used in Microsoft Win32 programming. C Compilers Reference CCR–41 C Compiler Extensions to ANSI/ISO C The ANSI Keywords Only option corresponds to the pragma only_std_keywords.To check whether this option is on, use __option (only_std_keywords). By default, this option is off. See also “only_std_keywords” on page 149 and “Checking Options” on page 202. Expand Trigraphs (K&R, §A12.1) The C compiler lets you ignore trigraph characters. Many common character constants (especially on Mac OS) look like trigraph sequences, and this extension lets you use them without in- cluding escape characters. If you’re writing code that must follow the ANSI/ISO standard strictly, turn on the Expand Trigraphs option in the C/C++ Lan- guage Panel. If this option is on, be careful when you initialize strings or multi-character constants that contain question marks. char c = '????'; // ERROR: Trigraph sequence expands to '??^ char d = '\?\?\?\?'; // OK The Expand Trigraphs option corresponds to the pragma tri- graphs, To check whether this option is on, use __option (tri- graphs). By default, this option is off. See also “trigraphs” on page 185 and “Checking Options” on page 202. Character Constants as Integer Values (K&R, §A2.5.2) The C compiler lets you use character string con- stants that contain 2 to 4 characters to denote a 32-bit integer values. Here are some examples: CCR–42 C Compilers Reference C Compiler Extensions to ANSI/ISO C Table 3.1 Integer values as character string constants This extension cannot be turned off. There is no corresponding pragma or setting in the C/C++ Language Panel. NOTE: This feature is different from using multibyte character sets, where a single character is represented by a data type larger than 1 byte. See “Multibyte Strings and Comments” on page 44 for a discus- sion of a different extension relating to using character sets with more than 256 characters (such as Kanji). Inlining The compiler determines whether to inline a function based on the settings of the ANSI Keywords Only item and the Inline Depth and Auto-inline items in the C/C++ Language Panel. For beginners: When you call an inline function, the compiler in- serts the function’s code instead instructions to call that function. Inlining functions makes your programs faster (because you exe- cute the function’s code immediately without a function call), but possibly larger (because the function’s code may be repeated in several different places). If you turn off the ANSI Keywords Only option, you can declare C functions to be inline. The inlining items in the C/C++ Language Panel let you choose to inline no functions, only functions declared inline, or all small functions as shown in Table 3.2. Character constant Equivalent hexadecimal ’ABCD' 0x41424344 ’ABC' 0x00414243 ’AB' 0x00004142 C Compilers Reference CCR–43 C Compiler Extensions to ANSI/ISO C Table 3.2 Options for the Inline Depth pop-up menu The Smart item and items 1 to 8 in the Inline Depth pop-up menu correspond to the pragma inline_depth (“C/C++ Language Panel” on page 15). To check whether this option is on, use __option(inline_depth), described at “Checking Options” on page 202. The Don’t Inline item in the Inline Depth pop-up menu corre- sponds to the pragma dont_inline, described at “dont_inline” on page 115. To check whether this option is on, use __option (dont_inline), described at “dont_inline” on page 204. By de- fault, this option is off. The Auto-Inline option lets the compiler choose which functions to inline. Also inlines C++ functions declared inline and member functions defined within a class declaration. This option corre- sponds to the pragma auto_inline, described at “auto_inline” on page 98. To check whether this option is on, use __option (auto_inline), described at “auto_inline” on page 203. By de- fault, this option is off. Multibyte Strings and Comments The C compiler supports languages that use more than one byte to represent a character, such as Unicode and Japanese Kanji. This fea- ture is controlled by the Multi-Byte Aware item in the C/C++ Lan- guage Panel. This option Does this… Don’t Inline Inlines no functions, not even C or C++ func- tions declared inline. Smart Inlines small functions to a depth of 2 to 4 inline functions deep. 1 to 8 Always inlines to the depth specified by the nu- merical selection. Always Inline Always inlines functions, no matter the depth. CCR–44 C Compilers Reference C Compiler Extensions to ANSI/ISO C To use multibyte strings or comments, turn on the Multi-Byte Aware option. If you don’t need multibyte strings or comments, turn this option off, because it slows down the compiler. See “Character Constants as Integer Values” on page 42 for a discus- sion of creating a character constant consisting of more than one character (a completely different subject with a similar sounding name). Pool Strings The Pool Strings option in the C/C++ Language Panel affects how the compiler stores string constants NOTE: In principle this option works for all targets. However, it is useful only for a Table of Contents based (TOC-based) linking mechanism such as that used for Mac OS on the PowerPC pro- cessor, or with Code Fragment Manager support on the 68K pro- cessor. If this option is on, the compiler collects all string constants into a single data object so your program needs one TOC entry for all of them. Turning this option on decreases the number of TOC entries in your program but increases your program’s size, because it uses a less efficient method to store the string’s address. If this option is off, 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 option in the PPC Processor settings panel. For more information, see the Targeting Mac OS manual. Turning this option on is especially useful if your program is large and has many string constants. C Compilers Reference CCR–45 C Compiler Extensions to ANSI/ISO C NOTE: If you turn the Pool Strings option on, the compiler ig- nores the setting of the PC-Relative Strings option. This is a 68K- only feature. The Pool Strings option corresponds to the pragma pool_strings. To check whether this option is on, use __option (pool_strings). By default, this option is off. See also “pool_strings” on page 161 and “Checking Options” on page 202. Reusing Strings The Don’t Reuse Strings option in the C/C++ Language Panel af- fects how the compiler stores string literals. If this option is on, the compiler stores each string literal separately. If this option is off, the compiler stores only one copy of identical string literals. This option helps you save memory if your program contains identical string literals which you do not modify. If this option is off (meaning that string storage is reused for identi- cal strings) and 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'; If the Don’t Reuse Strings option is on. the strings are stored sepa- rately. After changing the first character, str1 is still "Hello" but str2 is "Yello". If the Don’t Reuse Strings option is off, the two strings are stored in one memory location (i.e. the same memory location is reused), be- cause they are both identical. After changing the first character, both str1 and str2 are "Yello". This is counter-intuitive, and can lead to difficult-to locate bugs. CCR–46 C Compilers Reference C Compiler Extensions to ANSI/ISO C The Don’t Reuse Strings option corresponds to the pragma dont_reuse_strings. To check whether this option is on, use __option (dont_reuse_strings). By default, this option is on. (Strings are not reused.) See also “dont_reuse_strings” on page 115. and “Checking Options” on page 202. Require Function Prototypes (K&R, §A8.6.3, §A10.1) The C compiler lets you choose how to en- force function prototypes. This behavior is controlled by the Re- quire Function Prototypes item in the C/C++ Language Panel. When the Require Function Prototypes option is on, the compiler generates an error if you use a function that is defined after it is ref- erenced and does not have a prototype. If the function is implicitly defined, that is, is defined before it is referenced, and does not have a prototype, then the compiler will issue a warning if Require Func- tion Prototypes is on. This option helps you prevent errors that happen when you call a function before you declare or define it. For example, without a function prototype, you may pass data if the wrong type. As a re- sult, your code may not work as you expect even though it compiles without error. In Listing 3.2, PrintNum() is called with an integer argument but is later defined to take a floating-point argument. Listing 3.2 Unnoticed type-mismatch #include <stdio.h> void main(void) { PrintNum(1); // PrintNum() tries to interpret the integer as a float. Prints 0.000000. } C Compilers Reference CCR–47 C Compiler Extensions to ANSI/ISO C void PrintNum(float x) { printf("%f\n", x); } When you run this code, 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() is not prototyped, the compiler does not know it needs to convert the inte- ger 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 3.3, the compiler converts its argument to a floating-point number, and the function prints what you wanted. Listing 3.3 Using a prototype to avoid type-mismatch #include <stdio.h> void PrintNum(float x); // Function prototype. void main(void) { PrintNum(1); // Compiler knows to convert int to float. } // Prints 1.000000. void PrintNum(float x) { printf("%f\n", x); } In the above example, the compiler automatically typecast the passed value. In other situations where automatic typecasting is not available, the compiler will generate an error if an argument does not match the data type required by a function prototype. Such a CCR–48 C Compilers Reference C Compiler Extensions to ANSI/ISO C mismatched data type error is easy to locate at compile time. If you do not use prototypes, you get no compiler error. However, at runt- ime the code may behave strangely, and the cause of the resulting unintentional behavior can be extremely difficult to track down. The Require Function Prototypes option corresponds to the pragma require_prototypes. To check whether this option is on, use __option (require_prototypes). By default, this option is on. See also “require_prototypes” on page 165, and “Checking Op- tions” on page 202. Map Newlines to CR The C compiler lets you choose how to interpret the newline ('\n' ) and return ('\r') characters. This behavior is controlled by the Map Newlines to CR item in the C/C++ Language Panel. In most compilers, including CodeWarrior C/C++, '\r' is trans- lated to the value 0x0D, the standard value for carriage return, and '\n' is translated to the value 0x0A, the standard value for line- feed. However, the C compiler in the Macintosh Programmers Work- shop, known as MPW C, '\r' is translated to 0x0A and '\n' is translated to 0x0D—the opposite of the typical behavior. If you turn this option on, the compiler uses the MPW conventions for the '\n' and '\r' characters. If this option is off, the compiler uses the CodeWarrior C and C++ conventions for these characters. If you turn this option on, be sure you use ANSI/ISO C and C++ li- braries that were compiled with this option on. If you turn this op- tion on and use libraries built with this option off, you won’t be able to read and write '\n' and '\r' properly. For example, printing ‘\n’ would bring you to the beginning of the current line instead of inserting a new line. C Compilers Reference CCR–49 C Compiler Extensions to ANSI/ISO C This option corresponds to the pragma mpwc_newline. To check whether this option is on, use __option (mpwc_newline). By de- fault, this option is off. See also “mpwc_newline” on page 145, and “Checking Options” on page 202. For more information on issues relating to compatibility with MPW in Mac OS programming, see Targeting Mac OS. Relaxed Pointer Type Rules When you turn on the Relaxed Pointer Type Rules option in the C/ C++ Language Panel, the compiler treats char* and unsigned char* as the same type. While prototypes are checked for compati- ble pointer types, direct pointer assignments will be allowed. This option is especially useful if you’re using code written before the ANSI/ISO C standard. Old source code frequently uses these types interchangeably. This option has no effect on C++. When compiling C++ source code, the compiler differentiates char* and unsigned char* data types even if the relaxed pointer option is on. The Relaxed Pointer Type Rules option corresponds to the pragma mpwc_relax. To check whether this option is on, use __option (mpwc_relax). See also “mpwc_relax” on page 146, and “Checking Options” on page 202. Use Unsigned Chars The C compiler can automatically treat a char declarations as un- signed char. This behavior is controlled by the Use Unsigned Chars setting in the C/C++ Language Panel. When the Use Unsigned Chars option is on, the C compiler treats a char declaration as if it were an unsigned char declaration. CCR–50 C Compilers Reference C Compiler Extensions to ANSI/ISO C NOTE: If you turn this option on, your code may not be compati- ble with libraries that were compiled with this option turned off. The Use Unsigned Chars option corresponds to the pragma unsigned_char. To check whether this option is on, use __option (unsigned_char). By default, this option is off. See also “unsigned_char” on page 186 and “Checking Options” on page 202. Using 64-bit Integers The C compiler lets you define a 64-bit integer with the type speci- fier long long. This behavior is controlled by the longlong pragma. There is no item in the C/C++ Language Panel to control this option. If this option is on, you may declare a long long integer. A long long can hold values from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. An unsigned long long can hold values from 0 to 18,446,744,073,709,551,615. If this option 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” on page 33. However, long long bitfields are not supported. You control the long long type with pragma longlong.To check whether this option is on, use __option (longlong). By default, this pragma is on. See also “longlong” on page 138 and “Checking Options” on page 202. 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 doesn’t conform to the ANSI C standard, it is only avail- C Compilers Reference CCR–51 C Compiler Extensions to ANSI/ISO C able if the ANSI Strict option is off in the C/C++ Language settings panel. See “ANSI Strict” on page 37 for more information on this option. Listing 3.4 Converting a pointer to a same-sized integral type char c; long arr = (long)&c; // accepted (not ANSI/ISO C) 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. The function call __builtin_type(typeID) returns an integral value that describes what kind of data type typeID is. If typeID is an integral or an enumerated type, __builtin_type(typeID) returns 0. If typeID is a floating point type, __builtin_type(typeID) re- turns 1. If typeID is any other kind of data type, __builtin_type(typeID) returns 2. Arrays of Zero Length in Structures If the ANSI Strict option is off in the C/C++ Language Panel, the compiler allows arrays of no length as the last item in a structure. Listing 3.5 shows an example. Arrays may be defined with a zero as the index value or with no index value between brackets. Listing 3.5 Using zero-length arrays struct listOfLongs { long listCount; long list[0]; // OK if ANSI Strict is off, [] is OK, too. } CCR–52 C Compilers Reference C Compiler Extensions to ANSI/ISO C Intrinsic Functions for Bit Rotation CodeWarrior C has functions __rol(op, n) __ror(op, n) that do left or right bit rotation respectively. The op argument represents the item to have its bits rotated. The n argument represents the number of times to rotate op bits. The op ar- gument is not promoted to a larger data type, and may be of type char, short, int, long or long long. These functions are intrinsic (“built-in”). That is, to use the func- tions you do not first have to provide function prototypes for them. Also, you do not need to link with any special libraries. NOTE: Currently, these functions are limited to the Motorola 68K and Intel x86 versions of the CodeWarrior C/C++ compiler. The “D” Constant Suffix When CodeWarrior C finds a “D” immediately after a floating point constant value, it treats that value as data of type double. When the float_constants pragma is on, floating point constants should end with a “D” so that they are not treated as values of type float. For related information, see “float_constants” on page 125. C Compilers Reference CCR–53 C Compiler Extensions to ANSI/ISO C CCR–54 C Compilers Reference 4 C++ Compiler This chapter describes how the CodeWarrior C++ compiler imple- ments the C++ language. C++ Compiler Overview This chapter discusses the CodeWarrior C++ compiler as it applies to all CodeWarrior targets. For the most part, the information in this chapter is equally applicable to any operating system or processor. Other chapters in this manual discuss other features of the compiler that are specific to particular operating systems and processors. For a complete picture, you need to consider all the information relating your target of interest. In addition, the C compiler is an integral part of the CodeWarrior 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 Overview” on page 29 for information on the C compiler. This chapter covers all the features of the compiler that exist in sup- port of the C++ language. In addition to describing those features and how to control them, this chapter also has sections on working with advanced features of C++ such as RTTI, exceptions, and tem- plates. This chapter contains the following sections: • “CodeWarrior Implementation of C++” on page 56 describes how CodeWarrior C++ implements certain sections of the C++ standard. • “Unsupported Extensions” on page 64 describes some addi- tions to the ANSI/ISO C++ standard that CodeWarrior C++ does not support C Compilers Reference CCR–55 C++ Compiler CodeWarrior Implementation of C++ • “Controlling the C++ Compiler” on page 64 describes how to change the compiler’s behavior by setting options in the C/ C++ Language Panel. • “Working With C++ Exceptions” on page 68 describes how to use the try and catch statements to perform exception handling. • “Working With RTTI” on page 69 describes how to use run- time type information support in your code. • “Working With Templates” on page 72 describes the best way set up the files that define and declare your templates. It also documents an addition to the C++ standard which lets you explicitly instantiate templates. For information on using Embedded C++ (EC++) and for strategies on developing smaller C++ programs, see “C++ and Embedded Systems Overview” on page 79. Many topics contain references to ARM, which is The Annotated C++ Reference Manual (Addison-Wesley) by Ellis and Stroustrup. These references show you where to look for more information on the in- formation discussed in that topic. CodeWarrior Implementation of C++ This section describes how CodeWarrior C++ implements certain parts of the C++ standard, as described in The Annotated C++ Refer- ence Manual (Addison-Wesley) by Ellis and Stroustrup. The topics discussed in this section are: • Implicit Return Statement for main() • Keyword Ordering • Additional Keywords • Conversions in the Conditional Operator • Default Arguments in Member Functions • Local Class Declarations with Inline Functions • Copying and Constructing Class Objects • Checking for Resources To Initialize Static Data CCR–56 C Compilers Reference C++ Compiler CodeWarrior Implementation of C++ • Calling an Inherited Member Function Implicit Return Statement for main() The compiler adds a return 0; statement in C++ a program’s main() function if the function re- turns an int result and doesn’t end with a user return statement. Examples: int main() { } // equivalent to: // int main() { return 0; } main() { } // equivalent to: // int main() { return 0; } The compiler will also enforce an external int main() function if ANSI Strict is on in the C/C++ Language Panel. Keyword Ordering (ARM §7.1.2, §11.4) If you use either the virtual or the friend keyword in a declaration, it must be the first word in the declara- tion. For example: Listing 4.1 Using the virtual or friend keywords class foo { virtual int f0(); // OK int virtual f1(); // ERROR friend int f2(); // OK int friend f3(); // ERROR } C Compilers Reference CCR–57 C++ Compiler CodeWarrior Implementation of C++ Additional Keywords (ARM §2.4, ANSI §2.8) In addition to reserving the symbols in §2.4 of the ARM as keywords, CodeWarrior C++ reserves these symbols from §2.8 of the ANSI C++ Standard as keywords: Conversions in the Conditional Operator (ARM §5.16) The compiler does not apply reference conversions to the second and third expressions of the conditional operator. In other words, unless the second and third expressions are numeric types, they must be the same type. Listing 4.2 A conversion in a conditional operator class base { }; class derived : public base { }; static void foo(derived i) { base &a = i; derived &b = i, c; c = (sizeof(0) ? a:b); // ERROR: b is not converted to (base &) c = (sizeof(0) ? a:(base &)b) // OK, typecast } Default Arguments in Member Functions (ARM, §8.2.6) The compiler does not bind default arguments in a member function at the end of the class declaration. Before the de- fault argument appears, you must declare any value that you use in the default argument expression. For example: bool const_cast dynamic_cast explicit false mutable namespace reinterpret_cast static_cast true typeid using CCR–58 C Compilers Reference C++ Compiler CodeWarrior Implementation of C++ Listing 4.3 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 }; }; Local Class Declarations with Inline Functions (ARM, §9.8) If you’re declaring a class within a function, the class’s inline functions cannot access the outer function’s local types or variables. In other words, the compiler inserts the class’s inline functions on global scope level. For example: Listing 4.4 Using local class declarations with inline functions int x; void foo() { static int s; class local { int f1() { return s; } // ERROR: cannot access 's' int f2() { return local::f1(); } // ERROR: cannot access local int f3() { return x; } // OK }; } Copying and Constructing Class Objects (ARM, §12.1, §12.8) The compiler does not generate a copy construc- tor or a default operator= for a simple class. A simple class is a class that: • Is a base class or is derived only from simple classes C Compilers Reference CCR–59 C++ Compiler CodeWarrior Implementation of C++ • Has no class members or has only simple class members • Has no virtual member functions • Has no virtual base classes • Has no constructor or destructor Listing 4.5 Constructors class Simple { int f; }; void simpleFunc (Simple s1) { Simple s2 = Simple(s1); // ERROR: An explicit copy constructor // call. The compiler generates no // default copy constructor. Simple s3 = s1; // OK: The compiler performs a bitwise copy } The compiler does not guarantee that generated assignment or copy constructors will assign or initialize objects representing virtual base classes only once. Checking for Resources To Initialize Static Data Sometimes you create static C++ objects that require certain re- sources, such as a floating-point unit (FPU). You can check for these resources by creating a function called __PreInit__() which the compiler calls before it initializes static data. You cannot check for these resources in your main() routine, because the compiler ini- tializes static data before it calls main(). You must declare the __PreInit__() function like this: extern "C" void __PreInit__(void); CCR–60 C Compilers Reference C++ Compiler CodeWarrior Implementation of C++ NOTE: This function is not supported when generating code for PowerPC. For example, this stub checks for a floating-point unit. In this case you would also have to define the functions HasFPU() and Dis- playNoFPU() yourself. Listing 4.6 Checking for an FPU before initializing static data #include <Types.h> #include <stdlib.h> extern "C" void __PreInit__(void); void __PreInit__(void) { if(!HasFPU()) { DisplayNoFPU(); // Display "No FPU" Alert abort(); // Abort program exection } } Calling an Inherited Member Function (ARM, §10.2) If you want to call an inherited virtual member func- tion, rather than the local override of that function, you can do so in two ways. The first way is the recommended method for referring to member functions defined in a base class, or any other parent class. The second way, while more convenient, is not recommended if you intend to use your source code with other compilers. The standard way to call inherited member functions The first way is supported by the ANSI/ISO C++ Standard and sim- ply qualifies the member function with its base class. Assume you have two classes, MyBaseClass and MySubClass, each implementing a function named MyFunc(). C Compilers Reference CCR–61 C++ Compiler CodeWarrior Implementation of C++ 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 code may 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 behav- ior you implemented in MyMiddleClass. In all likelihood, this is not what you intend, and this kind of subtlety in the code can lead to unexpected results and bugs that are very hard to locate. Using inherited keyword to call inherited member functions NOTE: The inherited keyword is not supported by the ANSI/ ISO C++ standard and is only implemented for single inheritance with CodeWarrior C++. You may call the inherited version of MyFunc() this way: inherited::MyFunc(); With the inherited keyword, the compiler identifies the base class at compile time. This line of code would call 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 in- herits from a different base class, the immediate base class is still called, despite the change in hierarchy. The syntax is the following: inherited::func-name(param-list); CCR–62 C Compilers Reference C++ Compiler CodeWarrior Implementation of C++ The statement calls the func-name in the class’s immediate base class. If class has more than one immediate base class (because of multiple inheritance) and the compiler can’t decide which func-name to call, the compiler generates an error. This example creates a Q class that draws its objects by adding be- havior to the O class. Listing 4.7 Using inherited to call an inherited member function class O { virtual void draw(Point); } class Q : O { void draw(Point); } void O::draw (Point p) { Rect r = { p.x-5, p.y-5, p.x+5, p.y+5 }; FrameOval(r); // Draw an O. } void Q::draw (Point p) { inherited::draw(p); // Perform behavior of base class MoveTo(p.x, p.y); // Perform added behavior Line(5, 5); } Make sure to insert this directive before using the inherited key- word: #pragma def_inherited on For related information on this pragma see “def_inherited” on page 106. C Compilers Reference CCR–63 C++ Compiler Unsupported Extensions Unsupported Extensions The C++ compiler does not support this extension to the C++ stan- dard as described in The Annotated C++ Reference Manual (Addison- Wesley) by Ellis and Stroustrup: • Overloading methods operator new[] and operator delete[] to allocate and deallocate the memory for a whole array of objects at once. Instead overload operator new() and operator delete(), which are the functions that op- erator new[] and operator delete[] call (ARM, §5.3.3, §5.3.4). Controlling the C++ Compiler This section describes how to change the behavior of CodeWarrior C++ by setting some options in the C/C++ Language Panel. For in- formation on this panel and all its options, see “C/C++ Language Panel” on page 15. This section contains the following: • Using the C++ Compiler Always • Controlling ARM Conformance • Controlling Exception Handling • Controlling RTTI • Using the bool Type • Controlling C++ Extensions For more information on Direct to SOM, see Targeting Mac OS. Using the C++ Compiler Always If you turn on the Activate C++ Compiler option in the C/C++ Lan- guage Panel, the compiler compiles all the C source files in your project as C++ code. If you turn this option off, the CodeWarrior IDE looks at a file name’s suffix to determine whether to use the C or C++ compiler. The the suffixes it looks for are described by the entries in the CodeWarrior IDE’s File Mappings settings panel. See CCR–64 C Compilers Reference C++ Compiler Controlling the C++ Compiler the IDE User Guide for more information on configuring this settings panel. This option corresponds to the pragma cplusplus. To check whether this option is on, use __option (cplusplus). By de- fault, this option is off. See also “cplusplus” on page 103 and “Checking Options” on page 202. Controlling ARM Conformance When the ARM Conformance option in the C/C++ Language Panel is on, CodeWarrior C++ generates an error when it encounters cer- tain ANSI/ISO C++ features that conflict with the C++ specification in The Annotated C++ Reference Manual. Use this option only if you must make sure that your code strictly follows the specification in The Annotated C++ Reference Manual. Turning on this option prevents you from doing the following • Using protected base classes (ARM, §11.2). For example: class X {}; class Y : protected X {}; // OK in CodeWarrior C++. Error in ARM. • Changing the syntax of the conditional operator to let you use assignment expressions without parentheses in the sec- ond and third expressions (K&R, §A7.16). For example: i ? x=y : y=z // OK in CodeWarrior C++. Error in ARM. i ? (x=y):(y=z) // OK in ARM and CodeWarrior C++ • Declaring variables in the conditions of if, while and switch statements (K&R, §A9.4, §A9.5). For example: while (int i=x+y) { /* ... */ } // OK in CodeWarrior C++. Error in ARM. Turning on this option allows you to do the following: C Compilers Reference CCR–65 C++ Compiler Controlling the C++ Compiler • Using variables declared in the condition of a for statement after the for statement (K&R, §9.5). For example: for(int i=1; i<1000; i++) { /* ... */ } return i; // OK in ARM, Error in CodeWarrior C++ This option corresponds to the pragma ARM_conform. To check whether this option is on, use __option (ARM_conform). By de- fault, this option is off. See also “ARM_conform” on page 97 and “Checking Options” on page 202. Controlling Exception Handling Turn on the Enable C++ Exceptions option in the C/C++ Language Panel if you use the ANSI/ISO-standard try and catch state- ments. Otherwise, turn off this option to generate smaller and faster code. TIP: If you use PowerPlant for Mac OS programming, make sure this option is turned on. PowerPlant uses C++ exceptions. For more information on CodeWarrior implements ANSI/ISO C++ exception handling mechanism, see “Working With C++ Excep- tions” on page 68. This option corresponds to the pragma exceptions. To check whether this option is on, use __option (exceptions). By de- fault, this option is off. See also “exceptions” on page 118 and “Checking Options” on page 202. Controlling RTTI CodeWarrior C++ supports run-time type information (RTTI), in- cluding the dynamic_cast and typeid operators. To use these op- CCR–66 C Compilers Reference C++ Compiler Controlling the C++ Compiler erators, turn on the Enable RTTI option in the C/C++ Language Panel. For more information on how to use these two operators, see “Working With RTTI” on page 69. Using the bool Type Turn on the Enable bool Support option if you want to use the stan- dard C++ bool type to represent true and false. Turn this option off if recognizing bool, true, or false as keywords would cause 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 ANSI/ISO C++ Stan- dard. Source code that does not treat it as a distinct type might not compile properly. For example, some compilers other than treat CodeWarrior C++ treat the bool type as equivalent to the unsigned char data type. Source code that compiles successfully on such a compiler might not compile without errors with CodeWarrior C++ unless the En- able bool Support option is off. This option corresponds to the pragma bool. To check whether this option is on, use __option (bool). By default, this option is off. See also “bool” on page 99 and “Checking Options” on page 202. Controlling C++ Extensions The C++ compiler has additional extensions that you can activate. There is no item in the C/C++ Language Panel to activate these ex- tensions. You must turn on the pragma cpp_extensions. If this pragma is on, the compiler lets you use these extensions to the ANSI/ISO C++ standard: • Anonymous structs (ARM, §9). For example: C Compilers Reference CCR–67 C++ Compiler Working With C++ Exceptions #pragma cpp_extensions on void foo() { union { long hilo; struct { short hi, lo; }; // annonymous struct }; hi=0x1234; lo=0x5678; // hilo==0x12345678 } • Unqualified pointer to a member function (ARM, §8.1c). For example: #pragma cpp_extensions on struct Foo { void f(); } void Foo::f() { void (Foo::*ptmf1)() = &Foo::f; // ALWAYS OK void (Foo::*ptmf2)() = f; // OK, if cpp_exptensions is on. } To check whether this option is on, use the __option (cpp_extensions). By default, this option is off. See also “cpp_extensions” on page 103 and “Checking Options” on page 202. Working With C++ Exceptions If you turn on the Enable C++ Exceptions options in the C/C++ Language Panel, you may use the try and catch statements to per- form exception handling. For more information on activating sup- CCR–68 C Compilers Reference