home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cset21v1.zip / IBMCPP / HELP / DDE4LRM.INF (.txt) < prev    next >
OS/2 Help File  |  1993-10-04  |  837KB  |  33,167 lines
  1.  
  2. ΓòÉΓòÉΓòÉ 1. How to Use the Online Language Reference ΓòÉΓòÉΓòÉ
  3.  
  4. The C/C++ Tools Online Language Reference is a language reference guide for C 
  5. and C++ programmers.  It provides information about the C/C++ Tools 
  6. implementation of both the C and C++ languages, including code examples, to 
  7. enable you to write C and C++ programs. 
  8.  
  9. This document is a reference rather than a tutorial.  It assumes you are 
  10. already familiar with C and C++ programming concepts. 
  11.  
  12. With the exception of the separate introductory sections for each language and 
  13. the additional C++-specific topics (such as templates and exception handling), 
  14. information applies to both the C and C++ languages.  Differences between the 
  15. two languages in the implementation of a construct or concept are indicated. 
  16.  
  17. Before you begin to use this information, it would be helpful to understand how 
  18. you can: 
  19.  
  20. o Expand the Contents to see all available topics 
  21. o Obtain additional information for a highlighted word or phrase 
  22. o Use action bar choices 
  23.  
  24. How to Use the Contents 
  25.  
  26. When the Contents window first appears, some topics have a plus (+) sign beside 
  27. them. The plus sign indicates that additional topics are available. 
  28.  
  29. To expand the Contents if you are using a mouse, click on the plus sign.  If 
  30. you are using the keyboard, use the Up or Down Arrow key to highlight the 
  31. topic, and press the plus (+) key.  For example, Preprocessor Directives has a 
  32. plus sign beside it.  To see additional topics for that heading, click on the 
  33. plus sign or highlight that topic and press the plus (+) key. 
  34.  
  35. To view a topic, double-click on the topic (or press the Up or Down Arrow key 
  36. to highlight the topic, and then press the Enter key). 
  37.  
  38. How to Obtain Additional Information 
  39.  
  40. After you select a topic, the information for that topic appears in a window. 
  41. Highlighted words or phrases indicate that additional information is available. 
  42. You will notice that certain words and phrases are highlighted in green 
  43. letters, or in white letters on a black background. These are called hypertext 
  44. terms.  If you are using a mouse, double-click on the highlighted word.  If you 
  45. are using a keyboard, press the Tab key to move to the highlighted word, and 
  46. then press the Enter key.  Additional information then appears in a window. 
  47.  
  48. How to Use Action Bar Choices 
  49.  
  50. Several choices are available for managing information presented in the 
  51. C/C++Tools Online Language Reference. There are three pull-down menus on the 
  52. action bar:  the Services menu, the Options menu, and the Help menu. 
  53.  
  54. The actions that are selectable from the Services menu operate on the active 
  55. window currently displayed on the screen. These actions include the following: 
  56.  
  57. Bookmark 
  58.   Allows you to set a placeholder so you can retrieve information of interest 
  59.   to you. 
  60.  
  61.   When you place a bookmark on a topic, it is added to a list of bookmarks you 
  62.   have previously set.  You can view the list, and you can remove one or all 
  63.   bookmarks from the list.  If you have not set any bookmarks, the list is 
  64.   empty. 
  65.  
  66.   To set a bookmark, do the following: 
  67.  
  68.     1. Select a topic from the Contents. 
  69.     2. When that topic appears, choose the Bookmark option from the Services 
  70.        pull-down. 
  71.     3. If you want to change the name used for the bookmark, type the new name 
  72.        in the field. 
  73.     4. Click on the Place radio button (or press the Up or Down Arrow key to 
  74.        select it). 
  75.     5. Click on OK (or select it and press Enter). The bookmark is then added 
  76.        to the bookmark list. 
  77. Search 
  78.   Allows you to find occurrences of a word or phrase in the current topic, 
  79.   selected topics, or all topics. 
  80.  
  81.   You can specify a word or phrase to be searched.  You can also limit the 
  82.   search to a set of topics by first marking the topics in the Contents list. 
  83.  
  84.   To search for a word or phrase in all topics, do the following: 
  85.  
  86.     1. Choose the Search option from the Services pull-down. 
  87.     2. Type the word or words to be searched for. 
  88.     3. Click on All sections (or press the 
  89.  
  90.                Up or Down Arrow keys to select it).
  91.  
  92.     4. Click on Search (or select it and press Enter) to begin the search. 
  93.     5. The list of topics where the word or phrase appears is displayed. 
  94. Print 
  95.   Allows you to print one or more topics. You can also print a set of topics by 
  96.   first marking the topics in the Contents list. 
  97.  
  98.   To print the document Contents list, do the following: 
  99.  
  100.     1. Choose Print from the Services pull-down. 
  101.     2. Click on Contents (or press the Up or Down Arrow key to select it). 
  102.     3. Click on Print (or select it and press Enter). 
  103.     4. The Contents list is printed on your printer. 
  104. Copy 
  105.   Allows you to copy a topic that you are viewing to the System Clipboard or to 
  106.   a file that you can edit. This is particularly useful for copying syntax 
  107.   definitions and program samples into the application that you are developing. 
  108.  
  109.   You can copy a topic that you are viewing in two ways: 
  110.  
  111.    o Copy copies the topic that you are viewing into the System Clipboard.  If 
  112.      you are using a Presentation Manager* (PM) editor (for example, the 
  113.      Enhanced Editor) that copies or cuts (or both) to the System Clipboard, 
  114.      and pastes to the System Clipboard, you can easily add the copied 
  115.      information to your program source module. 
  116.  
  117.    o Copy to file copies the topic that you are viewing into a temporary file 
  118.      named TEXT.TMP.  You can later edit that file by using any editor. 
  119.      TEXT.TMP is placed in the directory where your viewable document resides. 
  120.  
  121.   To copy a topic, do the following: 
  122.  
  123.     1. Expand the Contents list and select a topic. 
  124.     2. When the topic appears, choose Copy to file from the Services pull-down. 
  125.     3. The system puts the text pertaining to that topic into the temporary 
  126.        file TEXT.TMP. 
  127.  
  128. For information on any of the choices in the Services pull-down, highlight the 
  129. choice and press the F1 key. 
  130.  
  131. The actions that are selectable from the Options menu allow you to change the 
  132. way your Contents list is displayed. To expand the Contents and show all levels 
  133. for all topics, choose Expand all from the Options pull-down. You can also 
  134. press the Ctrl and * keys together. 
  135.  
  136. For information on any of the choices in the Options pull-down, highlight the 
  137. choice and press the F1 key. 
  138.  
  139. The actions that are selectable from the Help menu allow you to select 
  140. different types of help information. You can also press the F1 key for help 
  141. information about the Information Presentation Facility (IPF). 
  142.  
  143.  
  144. ΓòÉΓòÉΓòÉ <hidden> Related Information ΓòÉΓòÉΓòÉ
  145.  
  146. o Copyright 
  147. o Edition Notice 
  148. o Notices 
  149. o Trademarks and Service Marks 
  150.  
  151.  
  152. ΓòÉΓòÉΓòÉ 1.1. Copyright ΓòÉΓòÉΓòÉ
  153.  
  154. Copyright International Business Machines Corporation, 1993. All rights 
  155. reserved. 
  156.  
  157. Note to U.S. Government Users - Documentation related to restricted rights - 
  158. Use, duplication, or disclosure is subject to restrictions set forth in GSA ADP 
  159. Schedule Contract with IBM* Corp. 
  160.  
  161.  
  162. ΓòÉΓòÉΓòÉ 1.2. Edition Notice ΓòÉΓòÉΓòÉ
  163.  
  164. Second Edition, November 1993. 
  165.  
  166. This edition applies to Version 2.01 of IBM C/C++ Tools (82G3733, 82G3735, 
  167. 82G3736) and to all subsequent releases and modifications until otherwise 
  168. indicated in new editions.  This publication could include technical 
  169. inaccuracies or typographical errors.  Changes are periodically made to the 
  170. information herein; any such changes will be reported in subsequent revisions. 
  171.  
  172. Requests for publications and for technical information about IBM* products 
  173. should be made to your IBM Authorized Dealer or your IBM Marketing 
  174. Representative. 
  175.  
  176. When you send information to IBM, you grant IBM a nonexclusive right to use or 
  177. distribute the information in any ways it believes appropriate without 
  178. incurring any obligation to you. 
  179.  
  180.  
  181. ΓòÉΓòÉΓòÉ 1.3. Notices ΓòÉΓòÉΓòÉ
  182.  
  183. References in this publication to IBM* products, programs, or services do not 
  184. imply that IBM intends to make these available in all countries in which IBM 
  185. operates. Any reference to an IBM product, program, or service is not intended 
  186. to state or imply that only IBM's product, program, or service may be used. Any 
  187. functionally equivalent product, program, or service that does not infringe any 
  188. of IBM's intellectual property rights may be used instead of the IBM product, 
  189. program, or service. Evaluation and verification of operation in conjunction 
  190. with other products, programs, or services, except those expressly designated 
  191. by IBM, are the user's responsibility. 
  192.  
  193. IBM may have patents or pending patent applications covering subject matter in 
  194. this document.  The furnishing of this document does not give you any license 
  195. to these patents.  You can send license inquiries, in writing, to the IBM 
  196. Director of Commercial Relations, IBM Corporation, Purchase, NY 10577. 
  197.  
  198.  
  199. ΓòÉΓòÉΓòÉ 1.4. Trademarks and Service Marks ΓòÉΓòÉΓòÉ
  200.  
  201. The following terms, denoted by an asterisk (*) in this publication, are 
  202. trademarks or service marks of IBM Corporation in the United States or other 
  203. countries: 
  204.  
  205. C/2 
  206. C Set/2 
  207. Common User Access 
  208. CUA 
  209. IBM 
  210. Operating System/2 
  211. OS/2 
  212. Personal System/2 
  213. Presentation Manager 
  214. PS/2 
  215. SAA 
  216. Systems Application Architecture 
  217. WorkFrame/2 
  218.  
  219. The following terms, denoted by a double asterisk (**) in this publication, are 
  220. trademarks of another county as follows: 
  221.  
  222. AT&T      AT&T Corporation 
  223. Microsoft Microsoft Corporation 
  224. Pentium   Intel Corporation 
  225.  
  226.  
  227. ΓòÉΓòÉΓòÉ <hidden> IBM Trademark ΓòÉΓòÉΓòÉ
  228.  
  229. Trademark of the IBM Corporation. 
  230.  
  231.  
  232. ΓòÉΓòÉΓòÉ <hidden> Non-IBM Trademarks ΓòÉΓòÉΓòÉ
  233.  
  234. AT&T is a trademark of AT&T Corporation. 
  235. Microsoft is a trademark of Microsoft Corporation. 
  236. Pentium is a trademark of the Intel Corporation. 
  237.  
  238.  
  239. ΓòÉΓòÉΓòÉ <hidden> signed/unsigned types ΓòÉΓòÉΓòÉ
  240.  
  241. The signed and unsigned types can be used with either a character (char) or an 
  242. integer (int, short, long). The unsigned prefix indicates that the value of the 
  243. object is be a nonnegative value. 
  244.  
  245. For more information on conversions between signed and unsigned types, see 
  246. Conversion from Signed Integer Types and Conversion from Unsigned Integer Types 
  247.  
  248.  
  249. ΓòÉΓòÉΓòÉ <hidden> \ Character ΓòÉΓòÉΓòÉ
  250.  
  251. The backslash can appear in string literals or comments as a punctuator.  A 
  252. backslash followed by a single character in C code indicates an escape 
  253. sequence. A backslash by itself at the end of a line of C code is a 
  254. continuation character. 
  255.  
  256. Escape Sequences provides help on escape sequences and the continuation 
  257. character. 
  258.  
  259.  
  260. ΓòÉΓòÉΓòÉ <hidden> ( ) ΓòÉΓòÉΓòÉ
  261.  
  262. Parentheses are used to group expressions to force a particular order of 
  263. evaluation. A parenthesized expression usually contains one or more operators 
  264. and operands (variables or constants), and is often part of an assignment 
  265. expression. For example, ((x + y) * g) is a parenthesized expression. 
  266.  
  267. Parentheses are also used in function calls to group the argument list for the 
  268. function. The opening parenthesis appears directly after the function name, and 
  269. may be followed by any number of arguments (or no arguments), followed by the 
  270. closing parenthesis and a semicolon. For example, fgets(line, 100, stream); is 
  271. a function call. 
  272.  
  273. For help on parenthesized expressions, see Parenthesized Expression ( ). 
  274.  
  275. For help on function calls, see Function Call ( ). 
  276.  
  277.  
  278. ΓòÉΓòÉΓòÉ <hidden> + ΓòÉΓòÉΓòÉ
  279.  
  280. The plus (+) sign can be used as a unary operator to maintain the value of an 
  281. operand, for example, +quality.  The unary plus sign is the opposite of the 
  282. unary minus (-) sign, which negates the value of an operand, for example, 
  283. -quality. 
  284.  
  285. The plus sign can also be used as a binary operator in an arithmetic expression 
  286. to represent the addition operation. For example, x + y indicates that the 
  287. variables x and y are to be added together. 
  288.  
  289. For more information on the unary plus operator, see Unary Plus  +. 
  290.  
  291. For more information on the addition operator, see Addition  +. 
  292.  
  293.  
  294. ΓòÉΓòÉΓòÉ <hidden> - ΓòÉΓòÉΓòÉ
  295.  
  296. The minus (-) sign can be used as a unary operator to negate the value of an 
  297. operand, for example -quality. 
  298.  
  299. It can also be used as a binary operator in an arithmetic expression to 
  300. represent the subtraction operation. For example, x - y indicates that the 
  301. variable y is to be subtracted from the variable x. 
  302.  
  303. For more information on the unary minus operator, see Unary Minus  -. 
  304.  
  305. For more information on the subtraction operator, see Subtraction  -. 
  306.  
  307.  
  308. ΓòÉΓòÉΓòÉ <hidden> & ΓòÉΓòÉΓòÉ
  309.  
  310. The ampersand (&) sign can be used as a unary operator to indicate the address 
  311. of its operand. For example, &anyvar represents the address of the variable 
  312. anyvar. 
  313.  
  314. The ampersand can also be used as a binary operator to represent the bitwise 
  315. AND operation. For example, in the expression x & y, the corresponding bits of 
  316. the x and y values are compared to see if the bits are both 1. 
  317.  
  318. A double ampersand (&&) is the logical AND operator. which indicate For 
  319. example, in the expression x && y, the values of x and y are checked to see if 
  320. both are nonzero values. 
  321.  
  322. For more information on the address operator, see Address  &. 
  323.  
  324. For more information on the bitwise AND operator, see Bitwise AND  &. 
  325.  
  326. For more information on the logical AND operator, see Logical AND  &&. 
  327.  
  328.  
  329. ΓòÉΓòÉΓòÉ <hidden> * ΓòÉΓòÉΓòÉ
  330.  
  331. The asterisk (*) can be used as a unary operator to indicate indirection. For 
  332. example, int *anyvar; declares anyvar as a pointer to int, that points to the 
  333. value of *anyvar. 
  334.  
  335. The asterisk can also be used as a binary operator in an arithmetic expression 
  336. to represent the multiplication operation. For example, x * y indicates that 
  337. the variable x is to be multiplied by y. 
  338.  
  339. For more information on the indirection operator, see Indirection  *. 
  340.  
  341. For more information on the multiplication operator, see Multiplication  *. 
  342.  
  343.  
  344. ΓòÉΓòÉΓòÉ <hidden> % ΓòÉΓòÉΓòÉ
  345.  
  346. The percent (%) sign can be used simply to indicate percentage in a string 
  347. literal.  For example, "More than 50% agree". 
  348.  
  349. The percent sign is also used as part of the format specifier for the printf 
  350. and scanf functions.  For example, in the statement printf("The value is %d", 
  351. anyint); the integer value of anyint is printed in the place of the %d 
  352. specifier. 
  353.  
  354. The percent sign can also be used as a binary operator to represent the modulus 
  355. (or remainder) operation. For example, the expression x % y indicates that x is 
  356. divided by y, and the result of the expression is the remainder of the 
  357. division. 
  358.  
  359. For more information on string literals, see Strings. 
  360.  
  361. For more information on format specifiers, see -- Reference printf not found -- 
  362. or -- Reference scanf not found --.. 
  363.  
  364. For more information on the remainder operator, see Remainder  %. 
  365.  
  366.  
  367. ΓòÉΓòÉΓòÉ <hidden> : ΓòÉΓòÉΓòÉ
  368.  
  369. The colon (:) is used to indicate the end of a label and separate it from the 
  370. following statement. For example, in the expression anylabl: x = y;, anylabl is 
  371. a label that could be part of a switch statement or the target of a goto 
  372. statement. 
  373.  
  374. The colon is also used in bit-field declarations to separate the identifier of 
  375. the bit field and the storage it is given. For example, in the structure 
  376.  
  377. struct {
  378.         unsigned x : 4
  379.         unsigned y : 1
  380.        }
  381. the bit fields x and y are assigned 4 bits and 1 bit of storage, respectively. 
  382.  
  383. The colon can also be used as part of the compound conditional expression (?:) 
  384. to separate the two action expressions. For example, in the expression x = (y < 
  385. z) ? y : z;, if y is less than z, the value of y is assigned to x; if y is not 
  386. less than z, the value of z is assigned to x. 
  387.  
  388. For more information on labels, see Labels. 
  389.  
  390. For more information on bit fields, see the section Declaring and Using Bit 
  391. Fields under Structures. 
  392.  
  393. For more information on the compound conditional expression, see Conditional 
  394. Expression  ? :. 
  395.  
  396.  
  397. ΓòÉΓòÉΓòÉ <hidden> ? ΓòÉΓòÉΓòÉ
  398.  
  399. The question mark (?) is used for both trigraphs (three characters starting 
  400. with ??) and as the first part of the operator for the conditional expression. 
  401.  
  402. For more information on the compound conditional expression, see Conditional 
  403. Expression  ? :. 
  404.  
  405.  
  406. ΓòÉΓòÉΓòÉ <hidden> , ΓòÉΓòÉΓòÉ
  407.  
  408. The comma (,) can be used to separate items such as parameters in a function 
  409. call. 
  410.  
  411. The comma is also used in the comma expression to separate two operands.  For 
  412. example, in the expression x = (y++, z * 4);, the left operand is evaluated 
  413. then discarded, and the value of the right operand is assigned to x. 
  414.  
  415. For more information on the comma expression, see Comma Expression  ,. 
  416.  
  417.  
  418. ΓòÉΓòÉΓòÉ <hidden> ; ΓòÉΓòÉΓòÉ
  419.  
  420. The semicolon (;) is used to indicate the end of a C expression, for example, 
  421. int x = 4;. 
  422.  
  423. The semicolon can also be used by itself as a null statement to show a 
  424. nonexistent action. 
  425.  
  426. For more information on expressions, see Expression. 
  427.  
  428. For more information on null statements, see Null Statement. 
  429.  
  430.  
  431. ΓòÉΓòÉΓòÉ 2. Introduction to C ΓòÉΓòÉΓòÉ
  432.  
  433. This section introduces you to the C programming language and shows you how to 
  434. structure C language source programs. 
  435.  
  436. Implementation-defined behavior is any action that is not defined by the 
  437. standards but by the implementing compiler and library. Appendix A in the IBM 
  438. C/C++ Tools: Programming Guide for a description of the C/C++ Tools 
  439. implementation-defined behavior. 
  440.  
  441. Undefined behavior is any action, by the compiler and library on an erroneous 
  442. program, that does not result in any expected manner. You should not write any 
  443. programs to rely on such behavior. 
  444.  
  445. Unspecified behavior is any other action by the compiler and library that is 
  446. not defined. 
  447.  
  448. This section includes the following topics: 
  449.  
  450. o Overview of the C Language 
  451. o C Source Programs 
  452. o C Source Files 
  453. o Program Execution 
  454. o Scope in C 
  455. o Program Linkage 
  456. o Storage Duration 
  457. o Name Spaces 
  458.  
  459. Related Information 
  460.  
  461. o Introduction to C++ 
  462.  
  463.  
  464. ΓòÉΓòÉΓòÉ 2.1. Overview of the C Language ΓòÉΓòÉΓòÉ
  465.  
  466. C is a programming language designed for a wide variety of programming tasks. 
  467. It is used for system-level code, text processing, graphics, and in many other 
  468. application areas. 
  469.  
  470. The C language contains a concise set of statements, with functionality added 
  471. through its library. This division enables C to be both flexible and efficient. 
  472. An additional benefit is that the language is highly consistent across 
  473. different systems. 
  474.  
  475. The C library contains functions for input and output, mathematics, exception 
  476. handling, string and character manipulation, dynamic memory management, as well 
  477. as date and time manipulation.  Use of this library helps to maintain program 
  478. portability, because the underlying implementation details for the various 
  479. operations need not concern the programmer. 
  480.  
  481. C supports numerous data types, including characters, integers, floating-point 
  482. numbers and pointers - each in a variety of forms.  In addition, C also 
  483. supports arrays, structures (records), unions, and enumerations. 
  484.  
  485. Related Information 
  486.  
  487. o C and C++ Language Elements 
  488. o Functions 
  489. o Types 
  490. o Introduction to C++ 
  491.  
  492.  
  493. ΓòÉΓòÉΓòÉ 2.2. C Source Programs ΓòÉΓòÉΓòÉ
  494.  
  495. A C source program is a collection of one or more directives, declarations, and 
  496. statements contained in one or more source files. 
  497.  
  498. Statements      specify the action to be performed. 
  499. Directives      instruct the C preprocessor to act on the text of the program. 
  500. Declarations    establish names and define characteristics such as scope, data 
  501.                 type and linkage. 
  502. Definitions     are declarations that allocate storage for data objects or 
  503.                 define a body for functions.  An object definition allocates 
  504.                 storage and may optionally initialize the object. 
  505.  
  506. A function definition precedes the function body. The function body is a 
  507. compound statement that can contain declarations and statements that define 
  508. what the function does. The function definition declares the function name, its 
  509. parameters, and the data type of the value it returns. 
  510.  
  511. The order and scope of declarations affect how you can use variables and 
  512. functions in statements. In particular, an identifier can be used only after it 
  513. is declared. 
  514.  
  515. A program must contain at least one function definition.  If the program 
  516. contains only one function definition, the function must be called main. If the 
  517. program contains more than one function definition, only one of the functions 
  518. can be called main.  The main function is the first function called when a 
  519. program is run. 
  520.  
  521. Source for a Simple C Program 
  522.  
  523. Related Information 
  524.  
  525. o C Source Files 
  526. o Overview of the C Language 
  527. o C++ Programs 
  528.  
  529.  
  530. ΓòÉΓòÉΓòÉ <hidden> Source for a Simple C Program ΓòÉΓòÉΓòÉ
  531.  
  532. /************************************************************************
  533. *
  534.  
  535. This is the source code of a simple C program: 
  536.  
  537.                                                                         *
  538. ************************************************************************/
  539.  
  540. #include <stdio.h>              /* standard library header which
  541.                                    contains I/O function declarations
  542.                                    such as printf used below          */
  543.  
  544. #include <math.h>               /* standard library header which
  545.                                    contains math function declarations
  546.                                    such as cos used below             */
  547.  
  548. #define NUM 46.0                /* Preprocessor directive             */
  549.  
  550. double x = 45.0;                /* External variable
  551.                                            definitions                */
  552.  
  553. double y = NUM;
  554.  
  555.  
  556. int main(void)                  /* Function definition
  557.                                    for main function                  */
  558. {
  559.    double z;                    /* Internal variable                  */
  560.    double w;                    /*   definitions                      */
  561.  
  562.    z = cos(x);                  /* cos is declared in math.h as
  563.                                          double cos(double arg)       */
  564.    w = cos(y);
  565.    printf ("cosine of x is %lf\n", z);  /* Print cosine of x          */
  566.    printf ("cosine of y is %lf\n", w);  /* Print cosine of y          */
  567. }
  568.  
  569. /************************************************************************
  570. *
  571.  
  572. This source program defines main and declares a reference to the function cos. 
  573. The program defines the global variables x and y, initializes them, and 
  574. declares two local variables z and w. 
  575.  
  576.                                                                         *
  577. ************************************************************************/
  578.  
  579.  
  580. ΓòÉΓòÉΓòÉ 2.3. C Source Files ΓòÉΓòÉΓòÉ
  581.  
  582. A C source file is the collection of text files that contains all of a C source 
  583. program. It can include any of the functions that the program needs. To create 
  584. an executable object module, you compile the separate source files individually 
  585. and then link them as one program. With the #include directive, you can combine 
  586. source files into larger source files. 
  587.  
  588. A source file contains any combination of directives, declarations, and 
  589. definitions. You can split items such as function definitions and large data 
  590. structures between text files, but you cannot split them between compiled 
  591. files. Before the source file is compiled, the preprocessor filters out 
  592. preprocessor directives that may change the files. As a result of the 
  593. preprocessing stage, preprocessor directives are completed, macros are 
  594. expanded, and a source file is created containing C statements, completed 
  595. directives, declarations, and definitions. 
  596.  
  597. It is sometimes useful to place variable definitions in one source file and 
  598. declare references to those variables in any source files that use them.  This 
  599. procedure makes definitions easy to find and change, if necessary. You can also 
  600. organize constants and macros into separate files and include them into source 
  601. files as required. 
  602.  
  603. Directives in a source file apply to that source file and its included files 
  604. only. Each directive applies only to the part of the file following the 
  605. directive. 
  606.  
  607. Example of C Source Files 
  608.  
  609. Related Information 
  610.  
  611. o C Source Programs 
  612. o Overview of the C Language 
  613. o Declarations and Definitions 
  614. o Language Statements 
  615. o Functions 
  616. o Preprocessor Directives 
  617. o C++ Programs 
  618.  
  619.  
  620. ΓòÉΓòÉΓòÉ <hidden> Example of C Source Files ΓòÉΓòÉΓòÉ
  621.  
  622. /************************************************************************
  623. *
  624.  
  625. The following example is a C program in two source files. The main and max 
  626. functions are in separate files. The execution of the program begins with the 
  627. main function. 
  628.  
  629. Source file 1 
  630.  
  631.                                                                         *
  632. ************************************************************************/
  633.  
  634. /************************************************************************
  635. *  Source file 1 - main function                                        *
  636. ************************************************************************/
  637.  
  638. #define ONE     1
  639. #define TWO     2
  640. #define THREE   3
  641.  
  642. extern int max(int, int);              /* Function declaration */
  643.  
  644. int main(int argc, char * argv[])      /* Function definition  */
  645. {
  646.    int u, w, x, y, z;
  647.  
  648.    u = 5;
  649.    z = 2;
  650.    w = max(u, ONE);
  651.    x = max(w,TWO);
  652.    y = max(x,THREE);
  653.    z = max(y,z);
  654. }
  655.  
  656. /************************************************************************
  657. *
  658.  
  659. Source file 2 
  660.  
  661.                                                                         *
  662. ************************************************************************/
  663.  
  664. /************************************************************************
  665. *  Source file 2 - max function                                         *
  666. ************************************************************************/
  667. int max (int a,int b)                 /* Function  definition          */
  668.  
  669. {
  670.    if ( a > b )
  671.        return (a);
  672.    else
  673.        return (b);
  674. }
  675.  
  676. /************************************************************************
  677. *
  678.  
  679. The first source file declares the function max, but does not define it. This 
  680. is a forward declaration, a reference to the function in source file 2. Four 
  681. statements in main are function calls of max. 
  682.  
  683. The lines beginning with a number sign (#) are preprocessor directives that 
  684. direct the preprocessor to replace the identifiers ONE, TWO, and THREE with the 
  685. digits 1, 2, and 3. The directives do not apply to the second source file. 
  686.  
  687. The second source file contains the function definition for max, which is 
  688. called four times in main. After you compile the source files, you can link and 
  689. run them as a single program. 
  690.  
  691. /************************************************************************
  692. *
  693.  
  694.  
  695. ΓòÉΓòÉΓòÉ 2.4. Program Execution ΓòÉΓòÉΓòÉ
  696.  
  697. Every program must have a function called main and usually contains other 
  698. functions. 
  699.  
  700. The main function is the starting point for running a program. The statements 
  701. within the main function are executed sequentially.  There may be calls to 
  702. other functions. A program usually stops running at the end of the main 
  703. function, although it can stop at other points in the program. 
  704.  
  705. You can make your program more modular by creating separate functions to 
  706. perform a specific task or set of tasks. The main function calls these 
  707. functions to perform the tasks. Whenever a function call is made, the 
  708. statements are executed sequentially starting with the first statement in the 
  709. function. The function returns control to the calling function at the return 
  710. statement or at the end of the function. 
  711.  
  712. You can declare any function to have parameters. When functions are called, 
  713. they receive values for their parameters from the arguments passed by the 
  714. calling functions. You can declare parameters for the main function so you can 
  715. pass values to main from the command line. The command line that starts the 
  716. program can pass such values as described in main. 
  717.  
  718. Related Information 
  719.  
  720. o Functions 
  721. o main 
  722. o Calling Functions and Passing Arguments 
  723. o C Source Files 
  724. o Overview of the C Language 
  725. o C++ Programs 
  726.  
  727.  
  728. ΓòÉΓòÉΓòÉ 2.5. Scope in C ΓòÉΓòÉΓòÉ
  729.  
  730. An identifier becomes visible with its declaration. 
  731.  
  732. The region where an identifier is visible is referred to as the identifier's 
  733. scope.  The four kinds of scope are: 
  734.  
  735. o Block 
  736. o Function 
  737. o File 
  738. o Function prototype 
  739.  
  740. The scope of an identifier is determined by where the identifier is declared. 
  741. See Identifiers for more information on identifiers. 
  742.  
  743. In the following example, the variable x, which is defined on line 1, is 
  744. different from the x defined on line 2. The variable defined on line 2 has 
  745. function prototype scope and is visible only up to the closing parenthesis of 
  746. the prototype declaration. Visibility of the variable x defined on line 2 
  747. resumes after the end of the prototype declaration. 
  748.  
  749. 1   int x = 4;             /* variable x defined with file scope */
  750. 2   long myfunc(int x, long y); /* variable x has function       */
  751. 3                               /* prototype scope               */
  752. 4   int main(void)
  753. 5   {
  754. 6      /* . . . */
  755. 7   }
  756.  
  757. Functions with static storage class are visible only in the source file in 
  758. which they are defined.  All other functions can be globally visible. 
  759.  
  760. Example of Scope 
  761.  
  762. Related Information 
  763.  
  764. o Block 
  765. o Labels 
  766. o goto 
  767. o Functions 
  768. o static Storage Class Specifier 
  769. o C Source Files 
  770. o Scope in C++ 
  771.  
  772.  
  773. ΓòÉΓòÉΓòÉ <hidden> Block Scope ΓòÉΓòÉΓòÉ
  774.  
  775. The identifier's declaration is located inside a block. A block starts with an 
  776. opening brace ({) and ends with a closing brace (}). An identifier with block 
  777. scope is visible from the point where it is declared to the closing brace that 
  778. ends the block. 
  779.  
  780. You can nest block visibility. A block nested inside a block can contain 
  781. declarations that redeclare variables declared in the outer block. The new 
  782. declaration of the variable applies to the inner block. The original 
  783. declaration is restored when program control returns to the outer block. A 
  784. variable from the outer block is visible inside inner blocks that do not 
  785. redefine the variable. 
  786.  
  787.  
  788. ΓòÉΓòÉΓòÉ <hidden> Function Scope ΓòÉΓòÉΓòÉ
  789.  
  790. The only identifier with function scope is a label name. A label is implicitly 
  791. declared by its appearance in the program text. A goto statement transfers 
  792. control to the label specified on the goto statement. The label is visible to 
  793. any goto statement that appears in the same function as the label. 
  794.  
  795.  
  796. ΓòÉΓòÉΓòÉ <hidden> File Scope ΓòÉΓòÉΓòÉ
  797.  
  798. The identifier's declaration appears outside of any block. It is visible from 
  799. the point where it is declared to the end of the source file. If source files 
  800. are included by #include preprocessor directives, those files are considered to 
  801. be part of the source and the identifier will be visible to all included files 
  802. that appear after the declaration of the identifier. The identifier can be 
  803. declared again as a block scope variable. The new declaration replaces the 
  804. file-scope declaration until the end of the block. 
  805.  
  806.  
  807. ΓòÉΓòÉΓòÉ <hidden> Function Prototype Scope ΓòÉΓòÉΓòÉ
  808.  
  809. The identifier's declaration appears within the list of parameters in a 
  810. function prototype. It is visible from the point where it is declared to the 
  811. closing parenthesis of the prototype declaration. 
  812.  
  813.  
  814. ΓòÉΓòÉΓòÉ <hidden> Example of Scope ΓòÉΓòÉΓòÉ
  815.  
  816. /************************************************************************
  817. *
  818.  
  819. The following program illustrates blocks, nesting, and scope. The example shows 
  820. two kinds of scope: file and block. Assuming that you defined the function 
  821. printf elsewhere, the main function prints the values 1, 2, 3, 0, 3, 2, 1 on 
  822. separate lines. Each instance of i represents a different variable. 
  823.  
  824.                                                                         *
  825. ************************************************************************/
  826.  
  827.      int i = 1;             /* i defined at file scope */
  828.  
  829.      int main(int argc, char * argv[])
  830.  ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ  {
  831.  Γöé
  832.  Γöé      printf("%d\n", i);        /* Prints 1 */
  833.  Γöé
  834.  Γöé ΓöîΓöÇΓöÇΓöÇΓöÇ   {
  835.  Γöé Γöé       int i = 2, j = 3;       /* i and j defined at
  836.  Γöé Γöé                       block scope */
  837.  Γöé Γöé       printf("%d\n%d\n", i, j);   /* Prints 2, 3 */
  838.  Γöé Γöé
  839.  Γöé Γöé ΓöîΓöÇΓöÇ     {
  840.  Γöé Γöé Γöé       int i = 0;         /* i is redefined in a nested block   */
  841.  Γöé Γöé Γöé                    /* previous definitions of i are hidden */
  842.  Γöé Γöé Γöé       printf("%d\n%d\n", i, j); /* Prints 0, 3 */
  843.  Γöé Γöé ΓööΓöÇΓöÇ     }
  844.  Γöé Γöé
  845.  Γöé Γöé       printf("%d\n", i);      /* Prints 2 */
  846.  Γöé Γöé
  847.  Γöé ΓööΓöÇΓöÇΓöÇΓöÇ   }
  848.  Γöé
  849.  Γöé      printf("%d\n", i);        /* Prints 1 */
  850.  Γöé
  851.  ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ  }
  852.  
  853.  
  854. ΓòÉΓòÉΓòÉ 2.6. Program Linkage ΓòÉΓòÉΓòÉ
  855.  
  856. The association, or lack of association, between two identical identifiers is 
  857. known as linkage. The kind of linkage that an identifier has depends on the way 
  858. that it is declared. 
  859.  
  860. A file scope identifier has one of the following kinds of linkage: 
  861.  
  862. Internal        Identical identifiers within a single source file refer to the 
  863.                 same data object. 
  864. External        Identical identifiers in separately compiled files refer to the 
  865.                 same data object. 
  866. No linkage      Each identical identifier refers to a unique object. 
  867.  
  868. Note:  Program linkage is not the same as a function calling convention, which 
  869. is also commonly referred to as linkage. While it is related to program 
  870. linkage, a calling convention concerns itself with linkage specifications and 
  871. the use of certain keywords. This section discusses only program linkage. 
  872. Function calling conventions are described in the IBM C/C++ Tools: Programming 
  873. Guide. 
  874.  
  875. Special C++ Considerations: 
  876.  
  877. o Linkage specifications are used to link to non-C++ declarations. 
  878.  
  879. o When the C++ compiler compiles a program, it encodes all function names and 
  880.   certain other identifiers to include type and scope information. This 
  881.   encoding process is called mangling, and the mangled names are used in the 
  882.   object files and final executable file. Tools that use these files must use 
  883.   the mangled names and not the original names used in the source code. 
  884.  
  885.   C/C++ Tools provides two methods of converting mangled names to the original 
  886.   source code names, demangling functions and the CPPFILT utility. The 
  887.   demangling functions are described in the appendix on Mapping in the IBM 
  888.   C/C++ Tools: Programming Guide and in the <demangle.h> header file. The 
  889.   CPPFILT utility is described in the online C/C++ Tools Compiler Utilities 
  890.   Reference. 
  891.  
  892. Related Information 
  893.  
  894. o Internal Linkage 
  895. o External Linkage 
  896. o No Linkage 
  897. o Scope in C 
  898. o Declarations and Definitions 
  899.  
  900.  
  901. ΓòÉΓòÉΓòÉ 2.6.1. Internal Linkage ΓòÉΓòÉΓòÉ
  902.  
  903. The following kinds of identifiers have internal linkage: 
  904.  
  905. o Identifiers with file or block scope that have the keyword static in their 
  906.   declarations. Functions with static storage class are visible only in the 
  907.   source file in which you define them. 
  908. o Inline functions. 
  909. o Identifiers declared at file scope with the specifier const and not 
  910.   explicitly declared extern. 
  911.  
  912. A variable that has static storage class can be defined within a block or 
  913. outside of a function. If the definition occurs within a block, the variable 
  914. has internal linkage and is only visible within the block after its declaration 
  915. is seen. If the definition occurs outside of a function, the variable has 
  916. internal linkage and is available from the point where it is defined to the end 
  917. of the current source file. 
  918.  
  919. A class name that has no static members or noninline member functions, and that 
  920. has not been used in the declaration of an object or function or class is local 
  921. to its translation unit. 
  922.  
  923. If the declaration of an identifier has the keyword extern and if a previous 
  924. declaration of the identifier is visible at file scope, the identifier has the 
  925. same linkage as the first declaration. 
  926.  
  927. Related Information 
  928.  
  929. o Program Linkage 
  930. o External Linkage 
  931. o No Linkage 
  932. o Inline Functions 
  933. o Storage Class Specifiers 
  934.  
  935.  
  936. ΓòÉΓòÉΓòÉ 2.6.2. External Linkage ΓòÉΓòÉΓòÉ
  937.  
  938. The following kinds of identifiers have external linkage: 
  939.  
  940. o Identifiers with file or block scope that have the keyword extern in their 
  941.   declarations. 
  942.  
  943.   If a previous declaration of the identifier is visible at file scope, the 
  944.   identifier has the same linkage as the first declaration. For example, a 
  945.   variable or function that is first declared with the keyword static and later 
  946.   declared with the keyword extern has internal linkage. 
  947. o Function identifiers declared without storage-class specifiers. 
  948. o Object identifiers that have file scope declared without a storage-class 
  949.   specified.  Storage is allocated for such object identifiers. 
  950. o Static class members and noninline member functions. 
  951.  
  952. Identifiers declared with the keyword extern can be defined in other 
  953. translation units. 
  954.  
  955. Related Information 
  956.  
  957. o Program Linkage 
  958. o Internal Linkage 
  959. o No Linkage 
  960. o Storage Class Specifiers 
  961.  
  962.  
  963. ΓòÉΓòÉΓòÉ 2.6.3. No Linkage ΓòÉΓòÉΓòÉ
  964.  
  965. The following kinds of identifiers have no linkage: 
  966.  
  967. o Identifiers that do not represent an object or a function, including labels, 
  968.   enumerators, typedef names, type names, and template names 
  969. o Identifiers that represent a function argument 
  970. o Identifiers declared inside a block without the keyword extern 
  971.  
  972. Related Information 
  973.  
  974. o Program Linkage 
  975. o Internal Linkage 
  976. o External Linkage 
  977. o extern Storage Class Specifier 
  978. o Identifiers 
  979.  
  980.  
  981. ΓòÉΓòÉΓòÉ 2.7. Storage Duration ΓòÉΓòÉΓòÉ
  982.  
  983. Storage duration determines how long storage for an object exists. An object 
  984. has either static storage duration or automatic storage class depending on its 
  985. declaration. 
  986.  
  987. An object with static storage duration has storage allocated for it at 
  988. initialization which remains available until program termination. All objects 
  989. with file scope have static storage duration. An object has static storage 
  990. duration if it has internal or external linkage or if it contains the keyword 
  991. static. All other objects have automatic storage. 
  992.  
  993. Storage for an object with automatic storage class is allocated and removed 
  994. according to the scope of the identifier. For example, storage for an object 
  995. declared at block scope is allocated when the identifier is declared and 
  996. removed when the closing brace of the block is reached. An object has automatic 
  997. storage duration if it is declared with no linkage and does not have the static 
  998. storage class specifier. 
  999.  
  1000. Related Information 
  1001.  
  1002. o Storage Class Specifiers 
  1003. o Scope in C 
  1004. o Program Linkage 
  1005.  
  1006.  
  1007. ΓòÉΓòÉΓòÉ 2.8. Name Spaces ΓòÉΓòÉΓòÉ
  1008.  
  1009. In any C program, identifiers refer to functions, data objects, labels, tags, 
  1010. parameters, macros, and typedefs. C allows the same identifier to be used for 
  1011. more than one class of identifier, as long as you follow the rules outlined in 
  1012. this section. 
  1013.  
  1014. Name spaces are categories used to group similar types of identifiers. 
  1015.  
  1016. You must assign unique names within each name space to avoid conflict. The same 
  1017. identifier can be used to declare different objects as long as each identifier 
  1018. is unique within its name space. The context of an identifier within a program 
  1019. lets the compiler resolve its name space without ambiguity. 
  1020.  
  1021. Identifiers in the same name space can be redefined within enclosed program 
  1022. blocks as described in Scope in C. 
  1023.  
  1024. Within each of the following four name spaces, the identifiers must be unique. 
  1025.  
  1026. o These identifiers must be unique within a single scope: 
  1027.  
  1028.    - Function names 
  1029.    - Variable names 
  1030.    - Names of function parameters 
  1031.    - Enumeration constants 
  1032.    - typedef names 
  1033.  
  1034. o Tags of these types must be unique within a single scope: 
  1035.  
  1036.    - Enumerations 
  1037.    - Structures 
  1038.    - Unions 
  1039.  
  1040. o Members of structures and unions must be unique within a single structure or 
  1041.   union. 
  1042.  
  1043. o Statement labels have function scope and must be unique within a function. 
  1044.  
  1045. Structure tags, structure members, and variable names are in three different 
  1046. name spaces; no conflict occurs among the three items named student in the 
  1047. following example: 
  1048.  
  1049. struct student        /*  structure tag       */
  1050. {
  1051.    char student[20];  /*  structure member    */
  1052.    int class;
  1053.    int id;
  1054. } student;            /*  structure variable  */
  1055.  
  1056. Each occurrence of student is interpreted by its context in the program. For 
  1057. example, when student appears after the keyword struct, it is a structure tag. 
  1058. When student appears after either of the member selection operators . or ->, 
  1059. the name refers to the structure member. (See Expressions and Operators to find 
  1060. out how to refer to members of union or structure variables.) In other 
  1061. contexts, the identifier student refers to the structure variable. 
  1062.  
  1063. Related Information 
  1064.  
  1065. o Types 
  1066. o Expressions and Operators 
  1067. o Scope in C 
  1068. o Identifiers 
  1069.  
  1070.  
  1071. ΓòÉΓòÉΓòÉ 3. Introduction to C++ ΓòÉΓòÉΓòÉ
  1072.  
  1073. This section describes the C++ language implemented by the &prods., briefly 
  1074. summarizes the differences between C and C++, and discusses the principles of 
  1075. object-oriented programming. 
  1076.  
  1077. C++ is an object-oriented language based on the C programming language. It can 
  1078. be viewed as a superset of C. Almost all of the features and constructs 
  1079. available in C are also available in C++. However, C++ is more than just an 
  1080. extension of C. Its additional features support the programming style known as 
  1081. object-oriented programming. Several features that are already available in C, 
  1082. such as input and output may be implemented differently in C++.  In C++ you may 
  1083. use the conventional C input and output routines or you may use object oriented 
  1084. input and output by using the I/O Stream class library. 
  1085.  
  1086. C++ was developed by Bjarne Stroustrup of AT&T** It was originally based on the 
  1087. definition of the C language stated in The C Programming Language by Brian W. 
  1088. Kernighan and Dennis M. Ritchie. This C language definition is commonly called 
  1089. K&R C. Since the introduction of C++, the American National Standard for 
  1090. Information Systems Standard C language definition (commonly called ANSI C) has 
  1091. been developed. The ANSI C definition specifies many of the features that K&R 
  1092. left unspecified. Features of ANSI C have been incorporated into the current 
  1093. definition of C++, and some parts of the ANSI C definition have been motivated 
  1094. by C++. 
  1095.  
  1096. While there is currently no C++ standard comparable to the ANSI C definition, 
  1097. an ANSI committee is working on such a definition. The current draft of the 
  1098. Working Paper for Draft Proposed American National Standard for Information 
  1099. Systems - Programming Language C++ (X3J16/92-00091, September 17, 1992) is the 
  1100. base document for the ongoing  standardization of C++. The C++ compiler adheres 
  1101. to this version of the ANSI working paper. 
  1102.  
  1103. The following topics are discussed in this section: 
  1104.  
  1105. o C++ Support for Object-Oriented Programming 
  1106. o C++ Programs 
  1107. o Scope in C++ 
  1108. o Simple C++ Input and Output 
  1109. o Linkage Specifications - Linking to non-C++ Programs 
  1110.  
  1111. Related Information 
  1112.  
  1113. o Introduction to C 
  1114.  
  1115.  
  1116. ΓòÉΓòÉΓòÉ 3.1. C++ Support for Object-Oriented Programming ΓòÉΓòÉΓòÉ
  1117.  
  1118. Object-oriented programming is based on the concepts of data abstraction, 
  1119. inheritance, and polymorphism. Unlike procedural programming, it concentrates 
  1120. on the data objects that are involved in a problem and how they are 
  1121. manipulated, not on how something is accomplished. Based on the foundation of 
  1122. data abstraction, object-oriented programming allows you to reuse existing code 
  1123. more efficiently and increase your productivity. 
  1124.  
  1125. o Data Abstraction 
  1126. o Encapsulation 
  1127. o Inheritance 
  1128. o Dynamic Binding and Polymorphism 
  1129. o Other Features of C++ 
  1130.  
  1131. Related Information 
  1132.  
  1133. o C++ Classes 
  1134. o Member Access 
  1135. o Inheritance Overview 
  1136. o Derivation 
  1137. o Introduction to C++ 
  1138.  
  1139.  
  1140. ΓòÉΓòÉΓòÉ <hidden> Data Abstraction ΓòÉΓòÉΓòÉ
  1141.  
  1142. Data abstraction provides the foundation for object-oriented programming. In 
  1143. addition to providing fundamental data types, object-oriented programming 
  1144. languages allow users to define their own data types, called user-defined or 
  1145. abstract data types. In the C programming language, related data items can be 
  1146. organized into structures. These structures can then be manipulated as units of 
  1147. data. In addition to providing this type of data structure, object-oriented 
  1148. programming languages allow you to implement a set of operations that can be 
  1149. applied to the data elements. The data elements and the set of operations 
  1150. applicable to the data elements together form the abstract data type. 
  1151.  
  1152. To support data abstraction, a programming language must provide a construct 
  1153. that can be used to encapsulate the data elements and operations that make up 
  1154. an abstract data type. In C++, this construct is called a class. An instance of 
  1155. a class is called an object. Classes are composed of data elements called data 
  1156. members and member functions that define the operations that can be carried out 
  1157. on the data members. 
  1158.  
  1159.  
  1160. ΓòÉΓòÉΓòÉ <hidden> Encapsulation ΓòÉΓòÉΓòÉ
  1161.  
  1162. Another key feature of object-oriented programming is encapsulation. 
  1163. Encapsulation means a class can hide the details of: 
  1164.  
  1165. o The representation of its data members 
  1166. o The implementation of the operations that can be performed on these data 
  1167.   members 
  1168.  
  1169. Application programs manipulate objects of a class using a clearly defined 
  1170. interface.  As long as this interface does not change, you can change the 
  1171. implementation of a class without having to change the application programs 
  1172. that use the class. Encapsulation provides the following advantages: 
  1173.  
  1174. o Users of a class do not have to deal with unnecessary implementation details. 
  1175. o Programs are easier to debug and maintain. 
  1176. o Permitted alterations are clearly specified. 
  1177.  
  1178. In C++, encapsulation is accomplished by specifying the level of access for 
  1179. each member of a class. Both the data members and member functions of a class 
  1180. can be declared public, protected, or private depending on the kind of access 
  1181. required. 
  1182.  
  1183. Note:  C++ encapsulation is not a true security mechanism. The implementation 
  1184. does not guard against undesired or unauthorized modifications of a class 
  1185. declaration intended to increase access to restricted class members. 
  1186.  
  1187.  
  1188. ΓòÉΓòÉΓòÉ <hidden> Inheritance ΓòÉΓòÉΓòÉ
  1189.  
  1190. Inheritance lets you reuse existing code and data structures in new 
  1191. applications.  In C++, inheritance is implemented through class derivation. You 
  1192. can extend a library of existing classes by adding data elements and operations 
  1193. to existing classes to form derived classes. A derived class has all the 
  1194. members of its parent or base class, as well as extensions that can provide 
  1195. additional features. When you  create a new derived class, you only have to 
  1196. write the code for the additional features. The existing features of the base 
  1197. class are already available. 
  1198.  
  1199. A base class can have more than one class derived from it. In addition, a 
  1200. derived class can serve as a base class for other derived classes in a 
  1201. hierarchy. Typically, a derived class is more specialized than its base class. 
  1202.  
  1203. A derived class can inherit data members and member functions from more than 
  1204. one base class. Inheritance from more than one base class is called multiple 
  1205. inheritance. 
  1206.  
  1207.  
  1208. ΓòÉΓòÉΓòÉ <hidden> Dynamic Binding and Polymorphism ΓòÉΓòÉΓòÉ
  1209.  
  1210. Another key concept that allows you to write generic programs is dynamic or 
  1211. late binding. Dynamic binding affects the derivation process and allows each 
  1212. user-defined class in an inheritance hierarchy to have a different 
  1213. implementation of a particular function. Application programs can then apply 
  1214. that function to an object without needing to know the specifics of the class 
  1215. that the object belongs to. 
  1216.  
  1217. In C++, dynamic binding hides the differences between a group of classes in an 
  1218. inheritance hierarchy from the application program. At run time, the system 
  1219. determines the specific class of the object and invokes the appropriate 
  1220. function implementation for that class. 
  1221.  
  1222.  
  1223. ΓòÉΓòÉΓòÉ <hidden> Other Features of C++ ΓòÉΓòÉΓòÉ
  1224.  
  1225. C++ provides several other powerful extensions to the C programming language. 
  1226. Among these are: 
  1227.  
  1228. o Constructors and destructors, which are used to create, initialize and 
  1229.   destroy class objects 
  1230. o Overloaded functions and operators, which provide static or compile-time 
  1231.   binding of function calls 
  1232. o Inline functions, which make programs more efficient 
  1233. o Pass-by-reference calls, which allow a function to modify its arguments in 
  1234.   the calling function 
  1235. o Template functions and classes, which allow user-defined families of classes 
  1236.   and compile-time binding of functions 
  1237. o Exception handling, which provides transfer of control and recovery from 
  1238.   errors and other exceptional circumstances 
  1239.  
  1240.  
  1241. ΓòÉΓòÉΓòÉ 3.2. C++ Programs ΓòÉΓòÉΓòÉ
  1242.  
  1243. C++ programs contain many of the same programming statements and constructs as 
  1244. C programs: 
  1245.  
  1246. o C++ has the same fundamental types (built-in data types) as C. 
  1247. o Like ANSI C, C++ allows you to declare new type names by using the typedef 
  1248.   construct. These new type names are not new types. 
  1249. o In general, the scope and storage class rules for C also apply in C++. 
  1250. o C and C++ have the same set of arithmetic and logical operators. 
  1251.  
  1252. A C++ name can identify any of the following: 
  1253.  
  1254. o an object 
  1255. o a function 
  1256. o a set of functions 
  1257. o an enumerator 
  1258. o a type 
  1259. o a class member 
  1260. o a template 
  1261. o a value 
  1262. o a label 
  1263. A declaration introduces a name into a program and can define an area of 
  1264. storage associated with that name. 
  1265.  
  1266. An expression performs some computational action and is composed of operations 
  1267. and operands. An expression ending with a ; (semicolon) is called a statement. 
  1268. A statement is the smallest independent computational unit. Functions are 
  1269. composed of groups of one or more statements. 
  1270.  
  1271. A C++ program is composed of one or more functions. These functions can all 
  1272. reside in a single file or can be placed in different files that are linked to 
  1273. each other. In C++, a program must have one and only one function called 
  1274. main(). 
  1275.  
  1276. Source for a Simple C++ Program 
  1277.  
  1278. Related Information 
  1279.  
  1280. o C++ Support for Object-Oriented Programming 
  1281. o Introduction to C 
  1282. o C Source Files 
  1283. o C Source Programs 
  1284.  
  1285.  
  1286. ΓòÉΓòÉΓòÉ <hidden> Source for a Simple C++ Program ΓòÉΓòÉΓòÉ
  1287.  
  1288. /************************************************************************
  1289. *
  1290.  
  1291. The following is a simple C++ program containing declarations, expressions, 
  1292. statements, and two functions: 
  1293.  
  1294.                                                                         *
  1295. ************************************************************************/
  1296.  
  1297. #include <math.h>                         // contains definition of abs()
  1298. extern double multiplier, common_ratio;   // variable declarations
  1299. double geo_series(double a, double r)     // function definition
  1300. {
  1301.       if (r == 1)                         // if statement
  1302.             return -1.0;                  // return statement
  1303.       else if (abs(r) < 1.0)              // else if statement
  1304.             return (a / (1 - r));         // statement containing
  1305.                                           // expression
  1306.       else return -2.0;
  1307. }
  1308. void main()        // program execution begins here
  1309. {
  1310.       double sum;  // variable definition
  1311.       sum = geo_series(multiplier, common_ratio); // function call
  1312.       // ..
  1313. }
  1314.  
  1315.  
  1316. ΓòÉΓòÉΓòÉ 3.3. Scope in C++ ΓòÉΓòÉΓòÉ
  1317.  
  1318. The area of the code where an identifier is visible is referred to as the scope 
  1319. of the identifier. The four kinds of scope are: 
  1320.  
  1321. o Local 
  1322. o Function 
  1323. o File 
  1324. o Class 
  1325.  
  1326. The scope of a name is determined by the location of the name's declaration. 
  1327.  
  1328. A type name first declared in a function return type has file scope. A type 
  1329. name first declared in a function argument list has local scope. 
  1330.  
  1331. A function name that is first declared as a friend of a class is in the first 
  1332. nonclass scope that encloses the class. 
  1333.  
  1334. If the friend function is a member of another class, it has the scope of that 
  1335. class. The scope of a class name first declared as a friend of a class is the 
  1336. first nonclass enclosing scope. 
  1337.  
  1338. Related Information 
  1339.  
  1340. o Scope in C 
  1341. o Friend Scope 
  1342. o Scope of Class Names 
  1343. o Member Scope 
  1344.  
  1345.  
  1346. ΓòÉΓòÉΓòÉ <hidden> Local Scope ΓòÉΓòÉΓòÉ
  1347.  
  1348. A name has local scope if it is declared in a block. A name with local scope 
  1349. can be used in that block and in blocks enclosed within that block, but the 
  1350. name must be declared before it is used. When the block is exited, the names 
  1351. declared in the block are no longer available. 
  1352.  
  1353. Formal argument names for a function have the scope of the outermost block of 
  1354. that function. 
  1355.  
  1356. If a local variable is a class object with a destructor, the destructor is 
  1357. called when control passes out of the block in which the class object was 
  1358. constructed. 
  1359.  
  1360. When one block is nested inside another, the variables from the outer block are 
  1361. usually visible in the nested block. However, if an outer block variable is 
  1362. redefined in a nested block, the new declaration is in effect in the inner 
  1363. block. The original declaration is restored when program control returns to the 
  1364. outer block. This is called block visibility. 
  1365.  
  1366.  
  1367. ΓòÉΓòÉΓòÉ <hidden> Function Scope ΓòÉΓòÉΓòÉ
  1368.  
  1369. The only type of identifier with function scope is a label name. A label is 
  1370. implicitly declared by its appearance in the program text and is visible 
  1371. throughout the function that declares it. 
  1372.  
  1373.  
  1374. ΓòÉΓòÉΓòÉ <hidden> File Scope ΓòÉΓòÉΓòÉ
  1375.  
  1376. A name has file scope if its declaration appears outside of all blocks and 
  1377. classes. A name with file scope is visible from the point where it is declared 
  1378. to the end of the source file. The name is also made accessible for the 
  1379. initialization of global variables. If a name is declared extern, it is also 
  1380. visible, at linkage time, in all object files being linked. Global names are 
  1381. names declared with file scope. 
  1382.  
  1383.  
  1384. ΓòÉΓòÉΓòÉ <hidden> Class Scope ΓòÉΓòÉΓòÉ
  1385.  
  1386. The name of a class member has class scope and can only be used in the 
  1387. following cases: 
  1388.  
  1389. o In a  member function of that class 
  1390. o In a member function of a class derived from that class 
  1391. o After the . (dot) operator applied to an instance of that class 
  1392. o After the . (dot) operator applied to an instance of a class derived from 
  1393.   that class 
  1394. o After the -> (arrow) operator applied to a pointer to an instance of that 
  1395.   class 
  1396. o After the -> (arrow) operator applied to a pointer to an instance of a class 
  1397.   derived from that class 
  1398. o After the :: (scope resolution) operator applied to the name of a class 
  1399. o After the :: (scope resolution) operator applied to a class derived from that 
  1400.   class. 
  1401.  
  1402. For more information on class scope, see Scope of Class Names 
  1403.  
  1404.  
  1405. ΓòÉΓòÉΓòÉ 3.4. Simple C++ Input and Output ΓòÉΓòÉΓòÉ
  1406.  
  1407. Like C, the C++ language has no built-in input and output facilities. Instead, 
  1408. input and output facilities for C++ are provided by the I/O Stream Library. For 
  1409. compatibility with C, C++ also supports the standard I/O functions of C. The 
  1410. I/O Stream Library supports a set of I/O operations, written in the C++ 
  1411. language, for the built-in types. You can extend these facilities to provide 
  1412. input and output functions for user-defined data types. 
  1413.  
  1414. For a complete description of the I/O Stream Library, see the Standard Class 
  1415. Library Guide. 
  1416.  
  1417. There are four standard predefined I/O stream objects that you can use to 
  1418. perform standard I/O: 
  1419.  
  1420. o cout 
  1421. o cin 
  1422. o cerr 
  1423. o clog 
  1424.  
  1425. You can use these in conjunction with the overloaded << (insertion or output) 
  1426. and >> (extraction or input) operators. To use these streams and operators, you 
  1427. must include the header file iostream.h. The following example prints Hello 
  1428. World! to standard output: 
  1429.  
  1430. #include <iostream.h>
  1431. void main()
  1432. {
  1433.       cout << "Hello World!" << endl;
  1434. }
  1435.  
  1436. The manipulator endl acts as a newline character, causing any output following 
  1437. it to be directed to the next line. Because it also causes any buffered output 
  1438. to be flushed, endl is preferred over \n to end lines. 
  1439.  
  1440. Related Information 
  1441.  
  1442. o Introduction to C++ 
  1443. o Introduction to C 
  1444. o Overloading Operators 
  1445.  
  1446.  
  1447. ΓòÉΓòÉΓòÉ <hidden> cout ΓòÉΓòÉΓòÉ
  1448.  
  1449. The cout stream is associated with standard output. You can use the output 
  1450. operator in conjunction with cout to direct a value to standard output. 
  1451. Successive output operators are concatenated when applied to cout. The 
  1452. following example prints out three strings in a row and produces the same 
  1453. result as the previous example, printing Hello World! to standard output. 
  1454.  
  1455. #include <iostream.h>
  1456. void main()
  1457. {
  1458.       cout << "Hello "
  1459.            << "World"
  1460.            << "!"
  1461.            << endl;
  1462. }
  1463.  
  1464. The output operator is defined to accept arguments of any of the fundamental 
  1465. data types, as well as pointers, references, and array types. You can also 
  1466. overload the output operator to define output for your own class types. 
  1467.  
  1468.  
  1469. ΓòÉΓòÉΓòÉ <hidden> cerr and clog ΓòÉΓòÉΓòÉ
  1470.  
  1471. The cerr and clog streams direct output to standard error. cerr provides 
  1472. unbuffered output, while clog provides buffered output. The following example 
  1473. checks for a division by zero condition. If one occurs, a message is sent to 
  1474. standard error. 
  1475.  
  1476. #include <iostream.h>
  1477. void main(void)
  1478. {
  1479.       double val1, val2;
  1480.       cout << "Divide Two Values" << endl;
  1481.       cout << "Enter two numeric values: " << endl;
  1482.       cin >> val1 >> val2;
  1483.       if (val2 == 0 )
  1484.       {
  1485.              cerr << "The second value must be non-zero" << endl;
  1486.       } else
  1487.              cout << "The answer is " << val1 / val2 << endl;
  1488. }
  1489.  
  1490.  
  1491. ΓòÉΓòÉΓòÉ <hidden> cin ΓòÉΓòÉΓòÉ
  1492.  
  1493. The cin class object is associated with standard input. You can use the input 
  1494. operator in conjunction with cin to read a value from standard input. White 
  1495. space (including blanks, tabs, and new lines) is disregarded by the input 
  1496. operator. For example: 
  1497.  
  1498. #include <iostream.h>
  1499. main()
  1500. {
  1501.       double val1, val2;
  1502.       cout << "Enter two numeric values:" << endl;
  1503.       cin >> val1 >> val2;
  1504.       cout   << "The first value entered is " << val1
  1505.              << " and the second value is "
  1506.              << val2 << "." << endl;
  1507. }
  1508.  
  1509. If the values 1.2 and 3.4 are entered through standard input, the above program 
  1510. prints the following to standard output: 
  1511.  
  1512. Enter two numeric values:
  1513. 1.2
  1514. 3.4
  1515. The first value entered is 1.2 and the second value is 3.4.
  1516.  
  1517. Any white space entered between the two numeric values is disregarded by the 
  1518. input operator. 
  1519.  
  1520. The input operator is defined to accept arguments of any of the fundamental 
  1521. data types, as well as pointers, references and array types. You can also 
  1522. overload the input operator to define input for your own class types. 
  1523.  
  1524.  
  1525. ΓòÉΓòÉΓòÉ 3.5. Linkage Specifications - Linking to non-C++ Programs ΓòÉΓòÉΓòÉ
  1526.  
  1527. You can link C++ code to code produced by other compilers by using a linkage 
  1528. specification. The syntax is: 
  1529.  
  1530. >>ΓöÇΓöÇexternΓöÇΓöÇstring-literalΓöÇΓöÇΓö¼ΓöÇdeclarationΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ><
  1531.               Γöé   ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ   Γöé
  1532.               Γöé           Γöé   Γöé
  1533.               ΓööΓöÇ{ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇΓöÇ}ΓöÇΓöÿ
  1534.                  ΓööΓöÇdeclarationΓöÇΓöÿ
  1535.  
  1536. The string-literal is used to specify the linkage associated with a particular 
  1537. function. For example: 
  1538.  
  1539. extern "C" int printf(const char*,...);
  1540. void main()
  1541. {
  1542.       printf("hello\n");
  1543. }
  1544.  
  1545. Here the string-literal, "C", tells the compiler that the routine 
  1546. printf(char*,...) has C linkage. Note that string literals used in linkage 
  1547. specifications are not case sensitive. 
  1548.  
  1549. The valid values for string-literal include: 
  1550.  
  1551. "C++"     Default 
  1552. "C"       C type linkage 
  1553.  
  1554. If the value of string-literal is not recognized, C type linkage is used. For 
  1555. more information on linkage specifications, see Chapter 13, "Calling 
  1556. Conventions" in the IBM C/C++ Tools: Programming Guide. 
  1557.  
  1558. Related Information 
  1559.  
  1560. o Introduction to C++ 
  1561. o Introduction to C 
  1562.  
  1563.  
  1564. ΓòÉΓòÉΓòÉ 4. C and C++ Language Elements ΓòÉΓòÉΓòÉ
  1565.  
  1566. This section describes the following basic elements of the C and C++ 
  1567. programming languages. 
  1568.  
  1569. o Character Set 
  1570. o Trigraphs 
  1571. o Escape Sequences 
  1572. o Comments 
  1573. o Identifiers 
  1574. o Keywords 
  1575. o Constants 
  1576.  
  1577.  
  1578. ΓòÉΓòÉΓòÉ 4.1. Character Set ΓòÉΓòÉΓòÉ
  1579.  
  1580. The following lists the basic character set that must be available at both 
  1581. compile and run time: 
  1582.  
  1583. o The uppercase and lowercase letters of the English alphabet 
  1584. o The decimal digits 0 through 9 
  1585. o The following graphic characters: 
  1586.  
  1587.        ! " # % & ' ( ) * + , - . / :
  1588.        ; < = > ? [ \ ] _ { } ~
  1589.  
  1590. o The caret (^) character 
  1591. o The split vertical bar (|) character 
  1592. o The space character 
  1593. o The control characters representing horizontal tab, vertical tab, form feed, 
  1594.   and end of string. 
  1595.  
  1596. When the language level is set to extended or compatible (with the /Se or /Sc 
  1597. option), the C++ character set also allows the dollar ($) character to be used 
  1598. in identifiers. 
  1599.  
  1600. Uppercase and lowercase letters are treated as distinct characters. 
  1601.  
  1602. For the keyboards that do not support the entire character set, you can use 
  1603. trigraphs as alternative symbols to represent some characters. 
  1604.  
  1605. Related Information 
  1606.  
  1607. o Trigraphs 
  1608. o Source Code Options 
  1609.  
  1610.  
  1611. ΓòÉΓòÉΓòÉ 4.2. Trigraphs ΓòÉΓòÉΓòÉ
  1612.  
  1613. Some characters from the C character set are not available in all environments. 
  1614. You can enter these characters into a C source program using a sequence of 
  1615. three characters called a trigraph.  The trigraph sequences are: 
  1616.  
  1617. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  1618. Γöé "??="   Γöé "#"      Γöé
  1619. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1620. Γöé "??("   Γöé "["      Γöé
  1621. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1622. Γöé "??)"   Γöé "]"      Γöé
  1623. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1624. Γöé "??<"   Γöé "{"      Γöé
  1625. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1626. Γöé "??>"   Γöé "}"      Γöé
  1627. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1628. Γöé "??/"   Γöé "\"      Γöé
  1629. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1630. Γöé "??'"   Γöé "^"      Γöé
  1631. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1632. Γöé "??!"   Γöé "|"      Γöé
  1633. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1634. Γöé "??-"   Γöé "~"      Γöé
  1635. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  1636.  
  1637. The preprocessor replaces trigraph sequences with the corresponding 
  1638. single-character representation. 
  1639.  
  1640. Related Information 
  1641.  
  1642. o Character Set 
  1643.  
  1644.  
  1645. ΓòÉΓòÉΓòÉ 4.3. Escape Sequences ΓòÉΓòÉΓòÉ
  1646.  
  1647. An escape sequence contains a backslash (\) symbol followed by one of the 
  1648. escape sequence characters or \ or followed by an octal or hexadecimal number. 
  1649. A hexadecimal escape sequence contains an x followed by one or more hexadecimal 
  1650. digits (0-9, A-F, a-f). An octal escape sequence contains one or more octal 
  1651. digits (0-7). 
  1652.  
  1653. The C language escape sequences and the characters they represent are: 
  1654.  
  1655. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  1656. Γöé ESCAPE   Γöé CHARACTER REPRES-   Γöé
  1657. Γöé SEQUENCE  Γöé ENTED         Γöé
  1658. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1659. Γöé "\a"    Γöé Alert (bell)     Γöé
  1660. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1661. Γöé "\b"    Γöé Backspace       Γöé
  1662. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1663. Γöé "\f"    Γöé Form feed (new page) Γöé
  1664. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1665. Γöé "\n"    Γöé New-line       Γöé
  1666. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1667. Γöé "\r"    Γöé Carriage return    Γöé
  1668. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1669. Γöé "\t"    Γöé Horizontal tab    Γöé
  1670. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1671. Γöé "\v"    Γöé Vertical tab     Γöé
  1672. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1673. Γöé "\'"    Γöé Single quotation   Γöé
  1674. Γöé       Γöé mark         Γöé
  1675. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1676. Γöé "\""    Γöé Double quotation   Γöé
  1677. Γöé       Γöé mark         Γöé
  1678. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1679. Γöé "\?"    Γöé Question mark     Γöé
  1680. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1681. Γöé "\\"    Γöé Backslash       Γöé
  1682. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1683. Γöé NOTE:  "\" - The line continua-  Γöé
  1684. Γöé tion sequence (\ followed by a   Γöé
  1685. Γöé new-line character) which is used Γöé
  1686. Γöé in C language character strings  Γöé
  1687. Γöé to indicate that the current line Γöé
  1688. Γöé continues on the next line, is   Γöé
  1689. Γöé not an escape sequence.      Γöé
  1690. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  1691.  
  1692. The value of an escape sequence represents the member of the character set used 
  1693. at run time. For example, on a system that uses the ASCII character codes, the 
  1694. letter V is represented by the escape sequence \x56. 
  1695.  
  1696. You can place an escape sequence in a character constant or in a string 
  1697. constant. If an escape sequence is not recognized, the compiler uses the 
  1698. character following the backslash and a message is issued. Note that this 
  1699. behavior is implementation-defined. 
  1700.  
  1701. In string and character sequences, when you want the backslash to represent 
  1702. itself (rather than the beginning of an escape sequence), you must use a \\ 
  1703. backslash escape sequence. 
  1704.  
  1705. Related Information 
  1706.  
  1707. o Character Constants 
  1708. o Strings 
  1709.  
  1710.  
  1711. ΓòÉΓòÉΓòÉ 4.4. Comments ΓòÉΓòÉΓòÉ
  1712.  
  1713. Comments begin with the /* characters, end with the */ characters, and may span 
  1714. more than one line. You can place comments anywhere the language allows white 
  1715. space. White space includes space, tab, form feed, and new-line characters. 
  1716.  
  1717. If the /Ss compiler option is in effect when you compile your program, double 
  1718. slashes (//) will also specify the beginning of a comment. The comment ends at 
  1719. the next new line character. C++ also permits double-slash comments as part of 
  1720. the language definition. 
  1721.  
  1722. Note:  The /* or */ characters found in a character constant or string literal 
  1723. do not start or end comments. 
  1724.  
  1725. You cannot nest comments.  Each comment ends at the first occurrence of */. 
  1726.  
  1727. Multibyte characters can also be included within a comment. 
  1728.  
  1729. Related Information 
  1730.  
  1731. o /Ss 
  1732.  
  1733.  
  1734. ΓòÉΓòÉΓòÉ 4.5. Identifiers ΓòÉΓòÉΓòÉ
  1735.  
  1736. Identifiers provide names for functions, data objects, labels, tags, 
  1737. parameters, macros, and typedefs. There is no limit for the number of 
  1738. characters in an identifier.  However, only the first several characters of 
  1739. identifiers may be significant. The following table shows the character lengths 
  1740. of identifiers that are recognized by the C/C++ Tools compiler. For SAA* C 
  1741. compilers, the minimal length of identifiers is 100 characters. Some compilers 
  1742. may allow longer identifiers. 
  1743.  
  1744. Identifier                  Minimum Number of Significant Characters 
  1745. Static data objects         255 characters 
  1746. Static function names       255 characters 
  1747. External data objects       255 characters 
  1748. External function names     255 characters 
  1749.  
  1750. For identifiers, uppercase and lowercase letters are viewed as different 
  1751. symbols.  Thus, PROFIT and profit represent different data objects. At the 
  1752. extended and compatible language levels, C++ identifiers can contain the $ 
  1753. character. 
  1754.  
  1755. Note:  By default, the LINK386 linker is not case sensitive. To preserve case 
  1756. sensitivity, use the /NOI linker option. If you use icc to invoke the linker, 
  1757. this option is specified for you. For complete portability, never use different 
  1758. case representations to refer to the same object. 
  1759.  
  1760. Avoid creating identifiers that begin with an underscore (_) for function names 
  1761. and variable names. Identifiers beginning with an underscore, are reserved. 
  1762. Identifiers used for C library functions that begin with two underscores or an 
  1763. underscore followed by a capital letter, are reserved. 
  1764.  
  1765. Although the names of system calls and library functions are not reserved words 
  1766. if you do not include the appropriate header files, avoid using them as 
  1767. identifiers.  Duplication of a predefined name can lead to confusion for the 
  1768. maintainers of your code and can cause errors at link time or run time. If you 
  1769. include a library in a program, be aware of the function names in that library 
  1770. to avoid name duplications. 
  1771.  
  1772. You should always include the appropriate header files when using standard 
  1773. library functions. 
  1774.  
  1775. Related Information 
  1776.  
  1777. o Name Spaces 
  1778. o Introduction to C 
  1779. o #include 
  1780.  
  1781.  
  1782. ΓòÉΓòÉΓòÉ 4.6. Keywords ΓòÉΓòÉΓòÉ
  1783.  
  1784. The C language reserves some identifiers, known as keywords, for special use. 
  1785. You cannot use these words as identifiers. Although you can use them for macro 
  1786. names, it is not recommended that you do so. Only the exact spellings of the 
  1787. words as specified below are reserved.  For example, auto is reserved but AUTO 
  1788. is not. The following table lists the keywords common to both the C and C++ 
  1789. languages.  These keywords are also included in the ANSI C language definition: 
  1790.  
  1791. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  1792. Γöé      Keywords Common to C and C++                     Γöé
  1793. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1794. Γöé auto        Γöé double       Γöé int        Γöé struct      Γöé
  1795. Γöé break       Γöé else        Γöé long        Γöé switch      Γöé
  1796. Γöé case        Γöé enum        Γöé register      Γöé typedef      Γöé
  1797. Γöé char        Γöé extern       Γöé return       Γöé union       Γöé
  1798. Γöé const       Γöé float       Γöé short       Γöé unsigned     Γöé
  1799. Γöé continue      Γöé for        Γöé signed       Γöé void       Γöé
  1800. Γöé default      Γöé goto        Γöé sizeof       Γöé volatile     Γöé
  1801. Γöé do         Γöé if         Γöé static       Γöé while       Γöé
  1802. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  1803.  
  1804. The keyword _Packed is also reserved for C programs. _Packed is an extension to 
  1805. the ANSI C standard, and is not supported by C++. 
  1806.  
  1807. The C++ language also reserves the following keywords: 
  1808.  
  1809. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  1810. Γöé      C++ Keywords                             Γöé
  1811. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1812. Γöé asm        Γöé friend       Γöé private      Γöé this       Γöé
  1813. Γöé catch       Γöé inline       Γöé protected     Γöé throw       Γöé
  1814. Γöé class       Γöé new        Γöé public       Γöé try        Γöé
  1815. Γöé delete       Γöé operator      Γöé template      Γöé virtual      Γöé
  1816. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  1817.  
  1818. The C/C++ Tools compiler also reserves the following keywords. They are 
  1819. considered to be C/C++ Tools extensions to the existing language standards. 
  1820. Except for the keywords _Far32 and _Inline, the following keywords are 
  1821. supported in both C and C++. 
  1822.  
  1823. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  1824. Γöé      Additional C/C++ Tools Keywords                   Γöé
  1825. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1826. Γöé _Cdecl       Γöé _Far32       Γöé _Inline      Γöé _Pascal      Γöé
  1827. Γöé _Export      Γöé _Fastcall     Γöé _Optlink      Γöé _Seg16      Γöé
  1828. Γöé _Far16       Γöé          Γöé          Γöé _System      Γöé
  1829. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  1830.  
  1831.  
  1832. ΓòÉΓòÉΓòÉ 4.7. Constants ΓòÉΓòÉΓòÉ
  1833.  
  1834. The C language contains the following types of constants: 
  1835.  
  1836. o Integer Constants 
  1837. o Floating-Point Constants 
  1838. o Character Constants 
  1839. o Strings 
  1840. o Enumeration Constants 
  1841.  
  1842. A constant is data with a value that does not change during the execution of a 
  1843. program. The value of any constant must be in the range of representable values 
  1844. for its type. 
  1845.  
  1846. For more information on data types, see Types. 
  1847.  
  1848.  
  1849. ΓòÉΓòÉΓòÉ 4.7.1. Integer Constants ΓòÉΓòÉΓòÉ
  1850.  
  1851. Integer constants can be either decimal, octal, or hexadecimal values. The 
  1852. following diagram lists these forms: 
  1853.  
  1854. >>ΓöÇΓöÇΓö¼ΓöÇdecimal_constantΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ><
  1855.   Γö£ΓöÇoctal_constantΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ  Γö£ΓöÇΓö¼ΓöÇlΓöÇΓö¼ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöñ
  1856.   ΓööΓöÇhexadecimal_constantΓöÇΓöÿ  Γöé ΓööΓöÇLΓöÇΓöÿ  Γö£ΓöÇuΓöÇΓöñ Γöé
  1857.                Γöé     ΓööΓöÇUΓöÇΓöÿ Γöé
  1858.                ΓööΓöÇΓö¼ΓöÇuΓöÇΓö¼ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÿ
  1859.                 ΓööΓöÇUΓöÇΓöÿ  Γö£ΓöÇlΓöÇΓöñ
  1860.                     ΓööΓöÇLΓöÇΓöÿ
  1861. The data type of an integer constant is determined by the constant's value. The 
  1862. following table describes the integer constant and a list of possible data 
  1863. types for that constant. The smallest data type in the list that can contain 
  1864. the constant value will be associated with the constant. 
  1865.  
  1866. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  1867. Γöé      Data Types for Integer Constants                   Γöé
  1868. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1869. Γöé CONSTANT        Γöé DATA TYPE                      Γöé
  1870. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1871. Γöé unsuffixed decimal   Γöé "int, long int, unsigned long int"          Γöé
  1872. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1873. Γöé unsuffixed octal    Γöé "int, unsigned int, long int, unsigned long int"   Γöé
  1874. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1875. Γöé unsuffixed hexadecimal Γöé "int, unsigned int, long int, unsigned long int"   Γöé
  1876. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1877. Γöé suffixed by "u" or "U" Γöé "unsigned int, unsigned long int"          Γöé
  1878. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1879. Γöé suffixed by "l" or "L" Γöé "long int, unsigned long int"            Γöé
  1880. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1881. Γöé suffixed by both "u"  Γöé "unsigned long int"                 Γöé
  1882. Γöé or "U",         Γöé                           Γöé
  1883. Γöé and "l" or "L"     Γöé                           Γöé
  1884. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  1885.  
  1886. A plus (+) or minus (-) symbol can precede the constant. It is treated as a 
  1887. unary operator rather than as part of the constant value. 
  1888.  
  1889. Related Information 
  1890.  
  1891. o Decimal Constants 
  1892. o Octal Constants 
  1893. o Hexadecimal Constants 
  1894. o Integers 
  1895.  
  1896.  
  1897. ΓòÉΓòÉΓòÉ 4.7.2. Decimal Constants ΓòÉΓòÉΓòÉ
  1898.  
  1899. A decimal constant contains any of the digits 0 through 9.  The first digit 
  1900. cannot be 0. Integer constants beginning with the digit 0 are interpreted as an 
  1901. octal constant, rather than as a decimal constant. 
  1902.  
  1903. The following are examples of decimal constants: 
  1904.  
  1905. 485976
  1906. 433132211
  1907. 20
  1908. 5
  1909.  
  1910. Related Information 
  1911.  
  1912. o Integer Constants 
  1913. o Octal Constants 
  1914. o Hexadecimal Constants 
  1915. o Integers 
  1916.  
  1917.  
  1918. ΓòÉΓòÉΓòÉ 4.7.3. Hexadecimal Constants ΓòÉΓòÉΓòÉ
  1919.  
  1920. A hexadecimal constant begins with the 0 digit followed by either an x or X. 
  1921. After the 0x, you can place any combination of the digits 0 through 9 and the 
  1922. letters a through f or A through F.  When used to represent a hexadecimal 
  1923. constant, the lowercase letters are equivalent to their corresponding uppercase 
  1924. letters. 
  1925.  
  1926. The following are examples of hexadecimal constants: 
  1927.  
  1928. 0x3b24
  1929. 0XF96
  1930. 0x21
  1931. 0x3AA
  1932. 0X29b
  1933. 0X4bD
  1934.  
  1935. Related Information 
  1936.  
  1937. o Integer Constants 
  1938. o Decimal Constants 
  1939. o Octal Constants 
  1940. o Integers 
  1941.  
  1942.  
  1943. ΓòÉΓòÉΓòÉ 4.7.4. Octal Constants ΓòÉΓòÉΓòÉ
  1944.  
  1945. An octal constant begins with the digit 0 and contains any of the digits 0 
  1946. through 7. 
  1947.  
  1948. 0
  1949. 0125
  1950. 034673
  1951. 03245
  1952.  
  1953. Related Information 
  1954.  
  1955. o Integer Constants 
  1956. o Decimal Constants 
  1957. o Hexadecimal Constants 
  1958. o Integers 
  1959.  
  1960.  
  1961. ΓòÉΓòÉΓòÉ 4.7.5. Floating-Point Constants ΓòÉΓòÉΓòÉ
  1962.  
  1963. A floating-point constant consists of an integral part, a decimal point, a 
  1964. fractional part, an exponent part, and an optional suffix.  Both the integral 
  1965. and fractional parts are made up of decimal digits.  You can omit either the 
  1966. integral part or the fractional part, but not both.  You can omit either the 
  1967. decimal point or the exponent part (but not both). 
  1968.  
  1969. The exponent part consists of e or E, followed optionally by a sign and a 
  1970. decimal number. 
  1971.  
  1972. The floating-point constant 8.45e+3 evaluates as follows: 
  1973.  
  1974. 8.45 * (10 ** 3) = 8450.0
  1975.  
  1976. The representation of a floating-point number on a system is unspecified. If a 
  1977. floating-point constant is too large or too small, the result is undefined. 
  1978.  
  1979. The suffix f or F indicates a type of float, and the suffix l or L indicates a 
  1980. type of long double.  If a suffix is not specified, the floating-point constant 
  1981. has a type double. 
  1982.  
  1983. A plus (+) or minus (-) symbol can precede a floating-point constant.  However, 
  1984. it is not part of the constant;  it is interpreted as a unary operator. 
  1985.  
  1986. The following are examples of floating-point constants: 
  1987.  
  1988. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  1989. Γöé FLOATING-POINT CON-   Γöé VALUE          Γöé
  1990. Γöé STANT          Γöé             Γöé
  1991. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1992. Γöé "5.3876e4"       Γöé "53,876"        Γöé
  1993. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1994. Γöé "4e-11"         Γöé "0.00000000004"     Γöé
  1995. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1996. Γöé "1e+5"         Γöé "100,000"        Γöé
  1997. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  1998. Γöé "7.321E-3"       Γöé "0.007321"       Γöé
  1999. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  2000. Γöé "3.2E+4"        Γöé "32,000"        Γöé
  2001. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  2002. Γöé "0.5e-6"        Γöé "0.0000005"       Γöé
  2003. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  2004. Γöé "0.45"         Γöé "0.45"         Γöé
  2005. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  2006. Γöé "6.e10"         Γöé "60,000,000,000"    Γöé
  2007. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  2008.  
  2009. Related Information 
  2010.  
  2011. o Floating-Point Variables 
  2012.  
  2013.  
  2014. ΓòÉΓòÉΓòÉ 4.7.6. Character Constants ΓòÉΓòÉΓòÉ
  2015.  
  2016. A character constant contains a sequence of characters or escape sequences 
  2017. enclosed in single quotation mark symbols. 
  2018.  
  2019. At least one character or escape sequence must appear in the character 
  2020. constant. It can contain any character from the C character set, excluding the 
  2021. single quotation mark, backslash and new-line symbols. The prefix L indicates a 
  2022. wide character constant.  A character constant must appear on a single source 
  2023. line. 
  2024.  
  2025. The value of a character constant containing a single character is the numeric 
  2026. representation of the character in the character set used at run time.  The 
  2027. value of a wide character constant containing a single multibyte character is 
  2028. the code for that character, as defined by the mbtowc function.  If the 
  2029. character constant contains more than one character, the last 4 bytes represent 
  2030. the character constant. 
  2031.  
  2032. A character constant has type int.  A wide character constant is represented by 
  2033. a double-byte character of type wchar_t, as defined in the <stddef.h> include 
  2034. file.  Multibyte characters represent character sets that go beyond the single 
  2035. byte character set.  Each multibyte character can contain up to 4 bytes. 
  2036.  
  2037. Restrictions 
  2038. To represent the single quotation symbol, backslash, and new-line characters, 
  2039. you must use the respective escape sequence. For more information on escape 
  2040. sequences, see Escape Sequences. 
  2041.  
  2042. The following are examples of character constants: 
  2043.  
  2044. 'a'    '\'' 
  2045. '0'    '(' 
  2046. 'x'    '\n' 
  2047. '7'    '\117' 
  2048. 'C' 
  2049.  
  2050. Related Information 
  2051.  
  2052. o Strings 
  2053. o Escape Sequences 
  2054. o Integers 
  2055.  
  2056.  
  2057. ΓòÉΓòÉΓòÉ 4.7.7. Strings ΓòÉΓòÉΓòÉ
  2058.  
  2059. A string constant or literal contains a sequence of characters or escape 
  2060. sequences enclosed in double quotation mark symbols. 
  2061.  
  2062. A null (\0) character is appended to each string.  For a wide character string 
  2063. (a string prefixed by the letter L), the value 0 of type wchar_t is appended. 
  2064. By convention, programs recognize the end of a string by finding the null 
  2065. character. 
  2066.  
  2067. If you want to continue a string on the next line, use the line continuation 
  2068. sequence (\ symbol immediately followed by a new-line character). 
  2069.  
  2070. Another way to continue a string is to have two or more consecutive strings. 
  2071. Adjacent string literals are concatenated to produce a single string.  (The 
  2072. null character of the first string will no longer exist after the 
  2073. concatenation.) You cannot concatenate a wide string constant with a character 
  2074. string constant. 
  2075.  
  2076. Multiple spaces contained within a string constant are retained. 
  2077.  
  2078. A character string constant has type array of char and static storage duration. 
  2079. A wide character constant has type array of wchar_t and static storage 
  2080. duration. 
  2081.  
  2082. You can use the escape sequence \n to represent a new-line character as part of 
  2083. the string. You can use the escape sequence \\ to represent a backslash 
  2084. character as part of the string. You can represent the single quotation mark 
  2085. symbol by itself ', but you use the escape sequence \" to represent the double 
  2086. quotation mark symbol. 
  2087.  
  2088. You should be careful when modifying string literals because the resulting 
  2089. behavior depends on whether your strings are stored in writable static. See 
  2090. #pragma for more information on #pragma strings that can be used to specify 
  2091. whether your string literals are readonly or writable. String literals are 
  2092. writable by default. 
  2093.  
  2094. The following are examples of string literals: 
  2095.  
  2096. char titles[ ] = "Bach's \"Jesu, Joy of Man's Desiring\"";
  2097. char *mail_addr = "Last Name    First Name    MI   Street Address   \
  2098.    City     Province   Postal code ";
  2099. char *temp_string = "abc" "def" "ghi";  /* *temp = "abcdefghi\0" */
  2100.  
  2101. Related Information 
  2102.  
  2103. o Character Constants 
  2104. o Escape Sequences 
  2105. o Characters 
  2106. o Arrays 
  2107. o #pragma 
  2108. o #pragma strings 
  2109.  
  2110.  
  2111. ΓòÉΓòÉΓòÉ 4.7.8. Enumeration Constants ΓòÉΓòÉΓòÉ
  2112.  
  2113. When you define an enumeration data type, you specify a set of identifiers that 
  2114. the data type represents. Each identifier in this set is an enumeration 
  2115. constant. 
  2116.  
  2117. In C, each enumeration constant has an integer value. In C++, each enumeration 
  2118. constant has a value that can be promoted to a signed or unsigned integer 
  2119. value. You can use an enumeration constant anywhere an integer constant is 
  2120. allowed, or for C++, anywhere a value of the enumeration type is allowed. The 
  2121. value of the constant is determined in the following way: 
  2122.  
  2123.  1. An equal sign (=) and a constant expression after the enumeration constant 
  2124.     gives an explicit value to the constant. The identifier represents the 
  2125.     value of the constant expression. 
  2126.  
  2127.  2. If no explicit value is assigned, the leftmost constant in the list 
  2128.     receives the value zero (0). 
  2129.  
  2130.  3. Identifiers with no explicitly assigned values receive the integer value 
  2131.     that is one greater than the value represented by the previous identifier. 
  2132.  
  2133. In C, an enumeration constant has type int. In C++, an enumeration constant has 
  2134. a distinct type that does not have to be integral.  Enumeration constants can 
  2135. be promoted to a signed or unsigned integral constant when used in an 
  2136. expression. 
  2137.  
  2138. The following data type declarations list oats, wheat, barley, corn, and rice 
  2139. as enumeration constants.  The number under each constant shows the integer 
  2140. value. 
  2141.  
  2142. enum grain { oats, wheat, barley, corn, rice };
  2143.    /*         0      1      2      3     4         */
  2144.  
  2145. enum grain { oats=1, wheat, barley, corn, rice };
  2146.    /*         1        2      3      4     5       */
  2147.  
  2148. enum grain { oats, wheat=10, barley, corn=20, rice };
  2149.    /*          0     10        11     20       21  */
  2150.  
  2151. It is possible to associate the same integer with two different enumeration 
  2152. constants. For example, the following definition is valid. The identifiers 
  2153. suspend and hold have the same integer value. 
  2154.  
  2155. enum status { run, delete=5, suspend, resume, hold=6 };
  2156.  
  2157. Related Information 
  2158.  
  2159. o Enumerations 
  2160. o Integers 
  2161.  
  2162.  
  2163. ΓòÉΓòÉΓòÉ 5. Declarations and Definitions ΓòÉΓòÉΓòÉ
  2164.  
  2165. A declaration establishes the names and characteristics of data objects and 
  2166. functions used in a program. A definition is a declaration that allocates 
  2167. storage for data objects or specifies the body for a function. 
  2168.  
  2169. The following table shows examples of declarations and definitions. 
  2170.  
  2171. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  2172. Γöé      Examples of Declarations and Definitions               Γöé
  2173. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  2174. Γöé DECLARATIONS          Γöé DECLARATIONS AND DEFINITIONS         Γöé
  2175. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  2176. Γöé "extern double pi;"      Γöé "double pi = 3.14159265;"           Γöé
  2177. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  2178. Γöé "float square(float x);"    Γöé "float square(float x) { return x*x; }"    Γöé
  2179. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  2180. Γöé "struct payroll;"       Γöé  struct payroll {              Γöé
  2181. Γöé                Γöé           char *name;        Γöé
  2182. Γöé                Γöé           float salary;       Γöé
  2183. Γöé                Γöé          } employee;         Γöé
  2184. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  2185.  
  2186. The declaration for a data object can include the following components: 
  2187.  
  2188. o Storage class, described in Storage Class Specifiers 
  2189. o Type, described in Types 
  2190. o Qualifier and Declarator, described in Declarators 
  2191. o Initializer, described in Initializers. 
  2192.  
  2193. Function declarations are described in Functions. 
  2194.  
  2195. Declarations determine the following properties of data objects and their 
  2196. identifiers: 
  2197.  
  2198. o Scope, which describes the visibility of an identifier in a block or source 
  2199.   file. For a complete description of scope, see Scope in C. 
  2200. o Storage duration, which describes when the system allocates and frees storage 
  2201.   for a data object. 
  2202. o Linkage, which describes the association between two identical identifiers. 
  2203.   See Program Linkage for more information. 
  2204. o Type, which describes the kind of data the object is to represent. 
  2205.  
  2206. Syntax of a Data Declaration 
  2207.  
  2208. Related Information 
  2209.  
  2210. o Block Scope Data Declarations 
  2211. o File Scope Data Declarations 
  2212. o Storage Class Specifiers 
  2213. o Types 
  2214. o Declarators 
  2215. o Initializers 
  2216.  
  2217.  
  2218. ΓòÉΓòÉΓòÉ <hidden> Syntax of a Data Declaration ΓòÉΓòÉΓòÉ
  2219.  
  2220. All data declarations have the form: 
  2221.  
  2222.                    ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  2223.                                  Γöé
  2224. ΓöÇΓö¼ΓöÇtype_specifierΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇdeclaratorΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇΓöÇ;ΓöÇΓöÇ
  2225.   Γöé                Γöé        Γöé       Γöé
  2226.   Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ        ΓööΓöÇinitializerΓöÿ
  2227.   Γöé       Γöé  Γöé        Γöé
  2228.   Γööstorage_classΓöÿ  Γöötype_specifierΓöÿ
  2229.  
  2230.  
  2231. ΓòÉΓòÉΓòÉ 5.1. Block Scope Data Declarations ΓòÉΓòÉΓòÉ
  2232.  
  2233. A block scope data declaration can only be placed at the beginning of a block. 
  2234. It describes a variable and makes that variable accessible to the current 
  2235. block. All block scope declarations that do not have the extern storage class 
  2236. specifier are definitions and allocate storage for that object. 
  2237.  
  2238. You can define a data object with block scope with any of the storage class 
  2239. specifiers described in Storage Class Specifiers. If you do not specify a 
  2240. storage class specifier in a block-scope data declaration, the default storage 
  2241. class specifier auto is used.  If you specify a storage class specifier, you 
  2242. can omit the type specifier.  If you omit the type specifier, all variables 
  2243. declared in that declaration will have the type int. 
  2244.  
  2245. Initialization 
  2246. You cannot initialize a variable that is declared in a block scope data 
  2247. declaration and has the extern storage class specifier. 
  2248.  
  2249. The types of variables you can initialize and the values that uninitialized 
  2250. variables receive vary for each storage class specifier. 
  2251.  
  2252. Storage 
  2253. Declarations with the auto or register storage class specifier result in 
  2254. automatic storage duration. Declarations with the extern or static storage 
  2255. class specifier result in static storage duration. 
  2256.  
  2257. Related Information 
  2258.  
  2259. o auto Storage Class Specifier 
  2260. o register Storage Class Specifier 
  2261. o extern Storage Class Specifier 
  2262. o static Storage Class Specifier 
  2263. o Declarations and Definitions 
  2264. o Declarators 
  2265. o Initializers 
  2266. o Types 
  2267.  
  2268.  
  2269. ΓòÉΓòÉΓòÉ 5.2. File Scope Data Declarations ΓòÉΓòÉΓòÉ
  2270.  
  2271. A file scope data declaration appears outside any block. It describes a 
  2272. variable and makes that variable accessible to all functions that are in the 
  2273. same file and whose definitions appear after the declaration. 
  2274.  
  2275. A file scope data definition is a data declaration at file scope that also 
  2276. causes the system to allocate storage for that variable.  All objects whose 
  2277. identifiers are declared at file scope have static storage duration. 
  2278.  
  2279. You can use a file scope data declaration to declare variables that you want 
  2280. several functions to access. 
  2281.  
  2282. The only storage class specifiers you can place in a file scope data 
  2283. declaration are static and extern. If you specify static, all variables defined 
  2284. in it have internal linkage. If you do not specify static, all variables 
  2285. defined in it have external linkage. If you specify the storage class static or 
  2286. extern, you can omit the type specifier.  If you omit the type specifier, all 
  2287. variables defined in that declaration receive the type int. 
  2288.  
  2289. Initialization 
  2290. You can initialize any object with file scope.  If you do not initialize a file 
  2291. scope variable, its initial value is zero of the appropriate type.  If you do 
  2292. initialize it, the initializer must be described by a constant expression, or 
  2293. it must reduce to the address of a previously declared variable at file scope, 
  2294. possibly modified by a constant expression.  Initialization of all variables at 
  2295. file scope takes place before the main function begins execution. 
  2296.  
  2297. Storage 
  2298. All objects with file scope data declarations have static storage duration. The 
  2299. system allocates memory for all file scope variables when the program begins 
  2300. execution and frees it when the program is finished executing. 
  2301.  
  2302. Related Information 
  2303.  
  2304. o extern Storage Class Specifier 
  2305. o static Storage Class Specifier 
  2306. o Declarations and Definitions 
  2307. o Declarators 
  2308. o Initializers 
  2309. o Types 
  2310.  
  2311.  
  2312. ΓòÉΓòÉΓòÉ 5.3. Objects ΓòÉΓòÉΓòÉ
  2313.  
  2314. An object is a region of storage that contains a value or group of values. Each 
  2315. value can be accessed using its identifier or a more complex expression that 
  2316. refers to the object. In addition, each object has a unique data type. Both the 
  2317. identifier and data type of an object are established in the object 
  2318. declaration. 
  2319.  
  2320. The data type of an object determines the initial storage allocation for that 
  2321. object and the interpretation of the values during subsequent access. It is 
  2322. also used in any type-checking operations. 
  2323.  
  2324. C++ has built-in, or standard, data types and user-defined data types. Standard 
  2325. data types include signed and unsigned integers, floating-point numbers, and 
  2326. characters. User-defined types include enumerations, structures, unions, and 
  2327. classes. 
  2328.  
  2329. An instance of a class type is commonly called a class object. The individual 
  2330. class members are also called objects. The set of all member objects comprises 
  2331. a class object. 
  2332.  
  2333. Related Information 
  2334.  
  2335. o Types 
  2336. o C++ Classes 
  2337. o Declarations and Definitions 
  2338.  
  2339.  
  2340. ΓòÉΓòÉΓòÉ 5.4. Storage Class Specifiers ΓòÉΓòÉΓòÉ
  2341.  
  2342. The storage class specifier used within the declaration determines the 
  2343. following: 
  2344.  
  2345. o Whether the object has internal, external, or no linkage. 
  2346.  
  2347. o Whether the object has static class (storage for the object is maintained 
  2348.   throughout program execution) or automatic class (storage for the object is 
  2349.   maintained only during the execution of the block in which the identifier of 
  2350.   the object is defined) storage duration. 
  2351.  
  2352. o Whether the object is to be stored in memory or in a register, if available. 
  2353.  
  2354. o Whether the object receives the default initial value 0 or an indeterminate 
  2355.   default initial value. 
  2356.  
  2357. For a function, the storage class specifier determines the function's linkage. 
  2358.  
  2359. The C/C++ Tools compiler implements an additional storage class specifier for 
  2360. functions, inline. The _Inline and inline specifiers determine whether the 
  2361. function code will be inlined or called.  Note that _Inline and inline are 
  2362. ignored if the /Oi- compiler option is specified. 
  2363.  
  2364. The following sections describe the storage class specifiers: 
  2365.  
  2366. o auto Storage Class Specifier 
  2367. o register Storage Class Specifier 
  2368. o extern Storage Class Specifier 
  2369. o static Storage Class Specifier 
  2370. o Inline Specifiers 
  2371.  
  2372. Related Information 
  2373.  
  2374. o Program Linkage 
  2375. o Inline Functions 
  2376. o Declarations and Definitions 
  2377. o Inline Specifiers 
  2378. o /Oi option 
  2379.  
  2380.  
  2381. ΓòÉΓòÉΓòÉ 5.4.1. auto Storage Class Specifier ΓòÉΓòÉΓòÉ
  2382.  
  2383. The auto storage class specifier enables you to define a variable with 
  2384. automatic storage;  its use and storage is restricted to the current block. 
  2385. The storage class keyword auto is optional in a data declaration and forbidden 
  2386. in a parameter declaration.  A variable having the auto storage class specifier 
  2387. must be declared within a block. It cannot be used for file scope declarations. 
  2388.  
  2389. You can initialize any auto variable except parameters. If you do not 
  2390. initialize an automatic object, its value is undefined. If you provide an 
  2391. initial value, the expression representing the initial value can be any valid C 
  2392. or C++ expression. For aggregates or unions, the initial value must be a valid 
  2393. constant expression. The object is then set to that initial value each time the 
  2394. program block that contains the object's definition is entered. 
  2395.  
  2396. Note:  If you use the goto statement to jump into the middle of a block, 
  2397. automatic variables within that block are not initialized. 
  2398.  
  2399. Objects with the auto storage class specifier have automatic storage duration. 
  2400. Each time a block is entered, storage for auto objects defined in that block is 
  2401. made available.  When the block is exited, the objects are no longer available 
  2402. for use. 
  2403.  
  2404. If an auto object is defined within a function that is recursively invoked, 
  2405. memory is allocated for the object at each invocation of the block. 
  2406.  
  2407. Declaring variables with the auto storage class specifier can decrease the 
  2408. amount of memory required for program execution, because auto variables require 
  2409. storage only while they actually are needed.  Generally, it is not a good idea 
  2410. to use automatic storage for large objects because of the time needed by the 
  2411. operating system to allocate or deallocate large amounts of storage. 
  2412.  
  2413. Examples of auto Storage Class 
  2414.  
  2415. Related Information 
  2416.  
  2417. o Storage Class Specifiers 
  2418. o register Storage Class Specifier 
  2419. o Block Scope Data Declarations 
  2420. o Function Declarator 
  2421. o Address  & 
  2422.  
  2423.  
  2424. ΓòÉΓòÉΓòÉ <hidden> Examples of auto Storage Class ΓòÉΓòÉΓòÉ
  2425.  
  2426. /************************************************************************
  2427. *
  2428.  
  2429. The following program shows the scope and initialization of auto variables. 
  2430. The function main defines two variables, each named auto_var. The first 
  2431. definition occurs on line 8. The second definition occurs in a nested block on 
  2432. line 11. While the nested block is executed, only the auto_var created by the 
  2433. second definition is available.  During the rest of the program, only the 
  2434. auto_var created by the first definition is available. 
  2435.  
  2436.                                                                         *
  2437. ************************************************************************/
  2438.  
  2439.  1                             /* program to illustrate auto variables */
  2440.  2
  2441.  3   #include <stdio.h>
  2442.  4
  2443.  5   int main(void)
  2444.  6   {
  2445.  7      void call_func(int passed_var);
  2446.  8      auto int auto_var = 1;  /* first definition of auto_var  */
  2447.  9
  2448. 10      {
  2449. 11         int auto_var = 2;    /* second definition of auto_var */
  2450. 12         printf("inner auto_var = %d\n", auto_var);
  2451. 13      }
  2452. 14      call_func(auto_var);
  2453. 15      printf("outer auto_var = %d\n", auto_var);
  2454. 16   }
  2455. 17
  2456. 18   void call_func(int passed_var)
  2457. 19   {
  2458. 20      printf("passed_var = %d\n", passed_var);
  2459. 21      passed_var = 3;
  2460. 22      printf("passed_var = %d\n", passed_var);
  2461. 23   }
  2462.  
  2463. /************************************************************************
  2464. *
  2465. This program produces the following output: 
  2466.  
  2467. inner auto_var = 2
  2468. passed_var = 1
  2469. passed_var = 3
  2470. outer auto_var = 1
  2471.  
  2472. The following example uses an array that has the storage class auto to pass a 
  2473. character string to the function sort.  The C language views an array name that 
  2474. appears without subscripts (for example, string, instead of string[0]) as a 
  2475. pointer.  Thus, sort receives the address of the character string, rather than 
  2476. the contents of the array.  The address enables sort to change the values of 
  2477. the elements in the array. 
  2478.  
  2479.                                                                         *
  2480. ************************************************************************/
  2481.  
  2482. /* Sorted string program */
  2483.  
  2484. #include <stdio.h>
  2485.  
  2486. int main(void)
  2487. {
  2488.    void sort(char *array, int n);
  2489.    char string[75];
  2490.    int length;
  2491.  
  2492.    printf("Enter letters:\n");
  2493.    scanf("%74s", string);
  2494.    length = strlen(string);
  2495.    sort(string,length);
  2496.    printf("The sorted string is: %s\n", string);
  2497. }
  2498.  
  2499. void sort(char *array, int n)
  2500. {
  2501.    int gap, i, j, temp;
  2502.  
  2503.    for (gap = n / 2; gap > 0; gap /= 2)
  2504.       for (i = gap; i < n; i++)
  2505.          for (j = i - gap; j >= 0 && array[j] > array[j + gap];
  2506.             j -= gap)
  2507.          {
  2508.             temp = array[j];
  2509.             array[j] = array[j + gap];
  2510.             array[j + gap] = temp;
  2511.          }
  2512. }
  2513.  
  2514. /**********************************************************************************
  2515. *
  2516.  
  2517. When the program is run, interaction with the program could produce: 
  2518.  
  2519. Output 
  2520.           Enter letters: 
  2521. Input 
  2522.           zyfab 
  2523. Output 
  2524.           The sorted string is:  abfyz 
  2525.  
  2526.                                                                         *
  2527. ************************************************************************/
  2528.  
  2529.  
  2530. ΓòÉΓòÉΓòÉ 5.4.2. extern Storage Class Specifier ΓòÉΓòÉΓòÉ
  2531.  
  2532. The extern storage class specifier enables you to declare objects and functions 
  2533. that several source files can use.  All object declarations that occur outside 
  2534. a function and that do not contain a storage class specifier declare 
  2535. identifiers with external linkage. All function definitions that do not specify 
  2536. a storage class define functions with external linkage. 
  2537.  
  2538. You can distinguish an extern declaration from an extern definition by the 
  2539. presence of the keyword extern and the absence of an initial value. If the 
  2540. keyword extern is absent or if there is an initial value, the declaration is 
  2541. also a definition; otherwise, it is just a declaration. An extern definition 
  2542. can appear only outside a function definition. Only one declaration of the 
  2543. variable without the keyword extern can be used, and that declaration is the 
  2544. definition of the storage for the variable. 
  2545.  
  2546. If a declaration for an identifier already exists at file scope, any extern 
  2547. declaration of the same identifier found within a block refers to that same 
  2548. object. If no other declaration for the identifier exists at file scope, the 
  2549. identifier has external linkage. 
  2550.  
  2551. An extern declaration cannot appear in class scope. 
  2552.  
  2553. An extern declaration can appear outside a function or at the beginning of a 
  2554. block. If the declaration describes a function or appears outside a function 
  2555. and describes an object with external linkage, the keyword extern is optional. 
  2556.  
  2557. You can initialize any object with the extern storage class specifier at file 
  2558. scope. You can initialize an extern object with an initializer that must 
  2559. either: 
  2560.  
  2561. o Appear as part of the definition and the initial value must be described by a 
  2562.   constant expression. 
  2563. o Reduce to the address of a previously declared object with static storage 
  2564.   duration. This object may be modified by a constant expression. 
  2565.  
  2566. If you do not initialize an extern variable, its initial value is zero of the 
  2567. appropriate type. Initialization of an extern object is completed by the start 
  2568. of program execution. 
  2569.  
  2570. extern objects have static storage duration. Memory is allocated for extern 
  2571. objects before the main function begins execution.  When the program finishes 
  2572. executing, the storage is freed. 
  2573.  
  2574. Examples of extern Storage Class 
  2575.  
  2576. Related Information 
  2577.  
  2578. o Storage Class Specifiers 
  2579. o File Scope Data Declarations 
  2580. o Function Definition 
  2581. o Function Declarator 
  2582. o Constant Expression 
  2583.  
  2584.  
  2585. ΓòÉΓòÉΓòÉ <hidden> Examples of extern Storage Class ΓòÉΓòÉΓòÉ
  2586.  
  2587. /************************************************************************
  2588. *
  2589.  
  2590. The following program shows the linkage of extern objects and functions.  The 
  2591. extern object total is declared on line 12 of File 1 and on line 11 of File 2. 
  2592. The definition of the external object total appears in File 3. The extern 
  2593. function tally is defined in File 2.  The function tally can be placed in the 
  2594. same file as main or in a different file.  Because main precedes these 
  2595. definitions and main uses both total and tally, main declares tally on line 11 
  2596. and total on line 12. 
  2597.  
  2598. File 1 
  2599.  
  2600.  
  2601. ************************************************************************/
  2602.  
  2603.  1       /**************************************************************
  2604.  2       ** This program receives the price of an item, adds the      **
  2605.  3       ** tax, and prints the total cost of the item.               **
  2606.  5       **************************************************************/
  2607.  6
  2608.  7   #include <stdio.h>
  2609.  8
  2610.  9   int main(void)
  2611. 10   {                                             /* begin main */
  2612. 11      void tally(void);            /* declaration of function tally */
  2613. 12      extern float total;          /* first declaration of total    */
  2614. 13
  2615. 14      printf("Enter the purchase amount: \n");
  2616. 15      tally();
  2617. 16      printf("\nWith tax, the total is:  %.2f\n", total);
  2618. 17   }   /* end main */
  2619.  
  2620. /************************************************************************
  2621. *
  2622.  
  2623. File 2 
  2624.  
  2625.                                                                         *
  2626. ************************************************************************/
  2627.  
  2628.  1       /**************************************************************
  2629.  2       ** This file defines the function tally                      **
  2630.  3       **************************************************************/
  2631.  4   #include <stdio.h>
  2632.  5
  2633.  6   #define  tax_rate  0.05
  2634.  7
  2635.  8   void tally(void)
  2636.  9   {                                           /* begin tally */
  2637. 10      float tax;
  2638. 11      extern float total;     /* second declaration of total       */
  2639. 12
  2640. 13      scanf("%f", &total);
  2641. 14      tax = tax_rate * total;
  2642. 15      total += tax;
  2643. 16   }                                            /* end tally */
  2644.  
  2645. /************************************************************************
  2646. *
  2647.  
  2648. File 3 
  2649.  
  2650.                                                                         *
  2651. ************************************************************************/
  2652.  
  2653.  1   float total;
  2654.  
  2655. /************************************************************************
  2656. *
  2657.  
  2658. The following program shows extern variables used by two functions.  Because 
  2659. both functions main and sort can access and change the values of the extern 
  2660. variables string and length, main does not have to pass parameters to sort. 
  2661.  
  2662.                                                                         *
  2663. ************************************************************************/
  2664.  
  2665. /* Sorted string program */
  2666.  
  2667. #include <stdio.h>
  2668.  
  2669. char string[75];
  2670. int length;
  2671.  
  2672. int main(void)
  2673. {
  2674.    void sort(void);
  2675.  
  2676.    printf("Enter letters:\n");
  2677.    scanf("%s", string);
  2678.    length = strlen(string);
  2679.    sort();
  2680.    printf("The sorted string is: %s\n", string);
  2681. }
  2682.  
  2683. void sort(void)
  2684. {
  2685.    int gap, i, j, temp;
  2686.  
  2687.    for (gap = length / 2; gap > 0; gap /= 2)
  2688.       for (i = gap; i < length; i++)
  2689.          for (j = i - gap;
  2690.               j >= 0 && string[j] > string[j + gap];
  2691.               j -= gap)
  2692.          {
  2693.             temp = string[j];
  2694.             string[j] = string[j + gap];
  2695.             string[j + gap] = temp;
  2696.          }
  2697. }
  2698.  
  2699. /************************************************************************
  2700. *
  2701. When this program is run, interaction with the previous program could produce: 
  2702.  
  2703. Output 
  2704.           Enter letters: 
  2705. Input 
  2706.           zyfab 
  2707. Output 
  2708.           The sorted string is:  abfyz 
  2709.  
  2710. The following program shows a static variable var1 which is defined at file 
  2711. scope and then declared with the storage class specifier extern. The second 
  2712. declaration refers to the first definition of var1 and so it has internal 
  2713. linkage. 
  2714.  
  2715. static int var1;
  2716.    .
  2717.    .
  2718.    .
  2719. extern int var1;
  2720.  
  2721.                                                                         *
  2722. ************************************************************************/
  2723.  
  2724.  
  2725. ΓòÉΓòÉΓòÉ 5.4.3. register Storage Class Specifier ΓòÉΓòÉΓòÉ
  2726.  
  2727. The register storage class specifier indicates to the compiler within a file 
  2728. scope data definition or a parameter declaration that the object being 
  2729. described will be heavily used (such as a loop control variable). 
  2730.  
  2731. Note:  Because the C/C++ Tools compiler optimizes register use, it does not 
  2732. respect the register keyword. The storage class keyword register is required in 
  2733. a data definition and in a parameter declaration that describes an object 
  2734. having the register storage class.  An object having the register storage class 
  2735. specifier must be defined within a block or declared as a parameter to a 
  2736. function. 
  2737.  
  2738. You can initialize any register object except parameters. If you do not 
  2739. initialize an automatic object, its value is undefined. If you provide an 
  2740. initial value, the expression representing the initial value can be any valid C 
  2741. or C++ expression. For aggregates or unions, the initial value must be a valid 
  2742. constant expression. The variable is then set to that initial value each time 
  2743. the program block that contains the object's definition is entered. 
  2744.  
  2745. Objects with the register storage class specifier have automatic storage 
  2746. duration. Each time a block is entered, storage for register objects defined in 
  2747. that block are made available.  When the block is exited, the objects are no 
  2748. longer available for use. 
  2749.  
  2750. If a register object is defined within a function that is recursively invoked, 
  2751. the system allocates memory for the variable at each invocation of the block. 
  2752.  
  2753. The register storage class specifier indicates that the object is heavily used 
  2754. and indicates to the compiler that the value of the object should reside in a 
  2755. machine register.  Not all register variables are actually placed in registers. 
  2756.  
  2757. If the compiler does not allocate a machine register for a register object, the 
  2758. object is treated as having the storage class specifier auto.  Because of the 
  2759. limited size and number of registers available on most systems, few variables 
  2760. can be stored in registers at the same time. Using register definitions for 
  2761. variables that are heavily used may make your object files smaller and make 
  2762. them run faster. In object code, a reference to a register can require less 
  2763. code and time than a reference to memory. 
  2764.  
  2765. Restrictions 
  2766.  
  2767. o In C programs, you cannot apply the & (address) operator to register 
  2768.   variables.  However, C++ allows you to take the address of an object with the 
  2769.   register storage class.  For example: 
  2770.  
  2771.        register i;
  2772.        int* b = &i;      // valid in C++, but not in C
  2773.  
  2774. o You cannot use the register storage class specifier on file scope data 
  2775.   declarations. 
  2776.  
  2777. Related Information 
  2778.  
  2779. o Storage Class Specifiers 
  2780. o auto Storage Class Specifier 
  2781. o Block Scope Data Declarations 
  2782. o Address  & 
  2783.  
  2784.  
  2785. ΓòÉΓòÉΓòÉ 5.4.4. static Storage Class Specifier ΓòÉΓòÉΓòÉ
  2786.  
  2787. The static storage class specifier enables you to define objects with static 
  2788. storage duration and internal linkage, or to define functions with internal 
  2789. linkage. 
  2790.  
  2791. An object having the static storage class specifier can be defined within a 
  2792. block or at file scope. If the definition occurs within a block, the object has 
  2793. no linkage. If the definition occurs at file scope, the object has internal 
  2794. linkage. 
  2795.  
  2796. You can initialize any static object.  If you do not provide an initial value, 
  2797. the object receives the value of zeros of the appropriate type.  If you 
  2798. initialize a static object, the initializer must be described by a constant 
  2799. expression or must reduce to the address of a previously declared extern or 
  2800. static object, possibly modified by a constant expression. 
  2801.  
  2802. Objects with the static storage class specifier have static storage duration. 
  2803. The storage for a static variable is made available when the program begins 
  2804. execution.  When the program finishes executing, the memory is freed. 
  2805.  
  2806. You cannot declare a static function at block scope. 
  2807.  
  2808. You can use static variables when you need an object that retains its value 
  2809. from one execution of a block to the next execution of that block.  Using the 
  2810. static storage class specifier keeps the system from reinitializing the object 
  2811. each time the block in which the object is defined is executed. 
  2812.  
  2813. C++ Consideration:  If a local static variable is a class object with 
  2814. constructors and destructors, the object will be constructed when control 
  2815. passes through its definition for the first time. If a local class object is 
  2816. created by a constructor, its destructor is called immediately before or as 
  2817. part of the calls of the atexit function. 
  2818.  
  2819. Examples of static Storage Class 
  2820.  
  2821. Related Information 
  2822.  
  2823. o Storage Class Specifiers 
  2824. o Block Scope Data Declarations 
  2825. o File Scope Data Declarations 
  2826. o Function Definition 
  2827. o Function Declarator 
  2828.  
  2829.  
  2830. ΓòÉΓòÉΓòÉ <hidden> Examples of static Storage Class ΓòÉΓòÉΓòÉ
  2831.  
  2832. /************************************************************************
  2833. *
  2834.  
  2835. The following program shows the linkage of static identifiers at file scope. 
  2836. This program uses two different external static identifiers named stat_var. 
  2837. The first definition occurs in file 1.  The second definition occurs in file 2. 
  2838. The main function references the object defined in file 1.  The var_print 
  2839. function references the object defined in file 2: 
  2840.  
  2841. File 1 
  2842.  
  2843.                                                                         *
  2844. ************************************************************************/
  2845.  
  2846. /************************************************************************
  2847. ** Program to illustrate file scope static variables                   **
  2848. ************************************************************************/
  2849. #include <stdio.h>
  2850.  
  2851. extern void var_print(void);
  2852. static stat_var = 1;
  2853.  
  2854. int main(void)
  2855. {
  2856.    printf("file1 stat_var = %d\n", stat_var);
  2857.    var_print();
  2858.    printf("FILE1 stat_var = %d\n", stat_var);
  2859. }
  2860.  
  2861. /************************************************************************
  2862. *
  2863. File 2 
  2864.  
  2865.                                                                         *
  2866. ************************************************************************/
  2867.  
  2868. #include <stdio.h>
  2869.  
  2870. static int stat_var = 2;
  2871.  
  2872. void var_print(void)
  2873. {
  2874.     printf("file2 stat_var = %d\n", stat_var);
  2875. }
  2876.  
  2877. /************************************************************************
  2878. *
  2879.  
  2880. The preceding program produces the following output: 
  2881.  
  2882. file1 stat_var = 1
  2883. file2 stat_var = 2
  2884. FILE1 stat_var = 1
  2885.  
  2886. The following program shows the linkage of static identifiers with block scope. 
  2887. The function test defines the static variable stat_var. stat_var retains its 
  2888. storage throughout the program, even though test is the only function that can 
  2889. reference stat_var. 
  2890.  
  2891.                                                                         *
  2892. ************************************************************************/
  2893.  
  2894. /************************************************************************
  2895. ** Program to illustrate block scope static variables                  **
  2896. ************************************************************************/
  2897. #include <stdio.h>
  2898.  
  2899. int main(void)
  2900. {
  2901.    void test(void);
  2902.    int counter;
  2903.    for (counter = 1; counter <= 4; ++counter)
  2904.       test();
  2905. }
  2906.  
  2907. void test(void)
  2908. {
  2909.    static int stat_var = 0;
  2910.    auto int auto_var = 0;
  2911.    stat_var++;
  2912.    auto_var++;
  2913.    printf("stat_var = %d auto_var = %d\n", stat_var, auto_var);
  2914. }
  2915.  
  2916. /************************************************************************
  2917. *
  2918.  
  2919. The preceding program produces the following output: 
  2920.  
  2921. stat_var = 1 auto_var = 1
  2922. stat_var = 2 auto_var = 1
  2923. stat_var = 3 auto_var = 1
  2924. stat_var = 4 auto_var = 1
  2925.  
  2926.                                                                         *
  2927. ************************************************************************/
  2928.  
  2929.  
  2930. ΓòÉΓòÉΓòÉ 5.4.5. Inline Specifiers ΓòÉΓòÉΓòÉ
  2931.  
  2932. C/C++ Tools provides two keywords, _Inline for C programs and inline for C++ 
  2933. programs, that you can use to specify the user functions you want the compiler 
  2934. to inline. For example: 
  2935.  
  2936.    _Inline int catherine(int a);
  2937.  
  2938. causes catherine to be inlined, meaning that code is generated for the 
  2939. function, rather than a function call. The inline keywords also implicitly 
  2940. declare the function as static. 
  2941.  
  2942. By default, function inlining is turned off, and functions qualified with 
  2943. _Inline or inline are treated simply as static functions. To turn on function 
  2944. inlining, specify the /Oi+ option. If you turn optimization on (/O+), /Oi+ 
  2945. becomes the default. 
  2946.  
  2947. Recursive functions (functions that call themselves) are inlined for the first 
  2948. occurrence only. The call to the function from within itself will not be 
  2949. inlined. 
  2950.  
  2951. You can also use the /Oivalue option to automatically inline all functions 
  2952. smaller than value abstract code units as well as those qualified with _Inline 
  2953. or inline.  For best performance, use the inline keywords to choose the 
  2954. functions you want to inline rather than using automatic inlining. 
  2955.  
  2956. When inlining is turned on, the following functions are also considered 
  2957. candidates to be inlined: 
  2958.  
  2959. o C++ member functions that are defined in class declarations. 
  2960. o For C programs only, small functions of static storage class that are called 
  2961.   only once. 
  2962.  
  2963. Note:  If you plan to debug your code (specifying /Ti+), you should turn 
  2964. inlining off. You should also be aware that profiling hooks are not generated 
  2965. for inlined functions. 
  2966.  
  2967. For more information on function inlining, see the Programming Guide. 
  2968.  
  2969. Related Information 
  2970.  
  2971. o static Storage Class Specifier 
  2972. o Storage Class Specifiers 
  2973. o Inline Functions 
  2974. o Inline Member Functions 
  2975. o /Oi 
  2976.  
  2977.  
  2978. ΓòÉΓòÉΓòÉ 5.5. Declarators ΓòÉΓòÉΓòÉ
  2979.  
  2980. A declarator designates a data object or function.  Declarators appear in all 
  2981. data definitions and declarations and in some type definitions. 
  2982.  
  2983. In a declarator, you can specify the type of an object to be an array, a 
  2984. pointer, or a reference.  You can specify that the return type of a function is 
  2985. a pointer or a reference.  You can also perform initialization in a declarator. 
  2986.  
  2987. Syntax of a Declarator 
  2988.  
  2989. You cannot declare or define a volatile or const function. 
  2990.  
  2991. A simple declarator consists of an identifier, which names a data object. For 
  2992. example, the following block scope data declaration uses initial as the 
  2993. declarator: 
  2994.  
  2995. auto char initial;
  2996.  
  2997. The data object initial has the storage class auto and the data type char. 
  2998.  
  2999. You can define or declare an aggregate by using a declarator that contains an 
  3000. identifier, which names the data object, and some combination of symbols and 
  3001. identifiers, which describes the type of data that the object represents. An 
  3002. aggregate is a structure, union, or array. The following declaration uses 
  3003. compute[5] as the declarator: 
  3004.  
  3005. extern long int compute[5];
  3006.  
  3007. Examples of Declarators 
  3008.  
  3009. Related Information 
  3010.  
  3011. o volatile and const Qualifiers 
  3012. o _Packed Qualifier 
  3013. o _Seg16 Type Qualifier 
  3014. o _Export Qualifier 
  3015. o Declarations and Definitions 
  3016. o Arrays 
  3017. o Enumerations 
  3018. o Pointers 
  3019. o Structures 
  3020. o Unions 
  3021.  
  3022.  
  3023. ΓòÉΓòÉΓòÉ <hidden> Syntax of a Declarator ΓòÉΓòÉΓòÉ
  3024.  
  3025. A declarator has the form: 
  3026.  
  3027. ΓöÇΓö¼ΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇidentifierΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓö¼ΓöÇ
  3028.   Γöé ΓöéΓöîΓöÇΓöÇΓöÇΓöÉΓöé Γöé           Γöé  Γöé              Γöé  Γöé
  3029.   Γöé Γöé  ΓöéΓöé ΓööΓöÇΓöÇ(ΓöÇΓöÇdeclaratorΓöÇΓöÇ)ΓöÇΓöÇΓöÿ  Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ(ΓöÇΓöÇ)ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ  Γöé
  3030.   Γöé ΓööΓöÇΓöÇ*ΓöÇΓö┤Γöÿ             Γöé ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ Γöé  Γöé
  3031.   Γöé                 Γöé             Γöé Γöé  Γöé
  3032.   Γöé                 ΓööΓöÇΓöÇΓöÇsubscript_declaratorΓöÇΓö┤ΓöÇΓöÿ  Γöé
  3033.   Γöé                                Γöé
  3034.   Γöé                                Γöé
  3035.   Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓö¼ΓöÇΓöÇidentifierΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  3036.   Γöé      Γöé ΓöéΓöîΓöÇΓöÇΓöÇΓöÉΓöé Γöé         Γöé Γöé            Γöé
  3037.   ΓööΓöÇqualifierΓöÿ Γöé  ΓöéΓöé Γöö(ΓöÇsubdeclaratorΓöÇ)Γöÿ ΓööΓöÇsubscript_declaratorΓöÇΓöÿ
  3038.         ΓööΓöÇΓöÇ*ΓöÇΓö┤Γöÿ
  3039.  
  3040. A qualifier is one of:  const, volatile or _Packed. The C/C++ Tools compiler 
  3041. also implements the _Seg16 _Export, and _Inline qualifiers. 
  3042.  
  3043. Note:  C++ does not support the _Packed keyword. 
  3044.  
  3045. A declarator can contain a subdeclarator. A subdeclarator has the form: 
  3046.  
  3047. ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇidentifierΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ
  3048.   Γöé ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ Γöé  Γöé            Γöé
  3049.   Γöé           Γöé Γöé  ΓööΓöÇΓöÇ(ΓöÇΓöÇsubdeclaratorΓöÇΓöÇ)ΓöÇΓöÇΓöÿ
  3050.   ΓööΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ*ΓöÇΓö┤ΓöÇΓöÿ
  3051.     Γöé       Γöé
  3052.     Γö£ΓöÇΓöÇvolatileΓöÇΓöÇΓöñ
  3053.     Γöé       Γöé
  3054.     ΓööΓöÇΓöÇΓöÇconstΓöÇΓöÇΓöÇΓöÇΓöÿ
  3055.  
  3056.  
  3057. ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ
  3058.   Γöé             Γöé
  3059.   ΓööΓöÇ subscript_declaratorΓöÇΓöÇΓöÿ
  3060.  
  3061. A subscript declarator describes the number of dimensions in an array and the 
  3062. number of elements in each dimension. A subscript declarator has the form: 
  3063.  
  3064. ΓöÇΓöÇ[ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ]ΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇ
  3065.     Γöé            Γöé   Γöé ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ Γöé
  3066.     ΓööΓöÇΓöÇconstant_expressionΓöÇΓöÇΓöÿ   Γöé               Γöé Γöé
  3067.                   ΓööΓöÇΓöÇΓöÇ[ΓöÇΓöÇconstant_expressionΓöÇΓöÇ]ΓöÇΓö┤ΓöÇΓöÿ
  3068.  
  3069.  
  3070. ΓòÉΓòÉΓòÉ 5.5.1. volatile and const Qualifiers ΓòÉΓòÉΓòÉ
  3071.  
  3072. The volatile qualifier maintains the intent of the original expression with 
  3073. respect to stores and fetches of volatile objects.  The volatile qualifier is 
  3074. useful for data objects having values that may be changed in ways unknown to 
  3075. your program (such as the system clock). Objects referenced by multiple threads 
  3076. or by signal handlers should also be qualified as volatile. Portions of an 
  3077. expression that reference volatile objects are not to be changed or removed. 
  3078.  
  3079. The const qualifier explicitly declares a data object as a data item that 
  3080. cannot be changed.  Its value is set at initialization.  You cannot use const 
  3081. data objects in expressions requiring a modifiable lvalue.  For example, a 
  3082. const data object cannot appear on the left-hand side of an assignment 
  3083. statement. 
  3084.  
  3085. For a volatile or const pointer, you must place the keyword between the * and 
  3086. the identifier.  For example: 
  3087.  
  3088. int * volatile x;        /* x is a volatile pointer to an int */
  3089. int * const y = &z;      /* y is a const pointer to the int variable z */
  3090.  
  3091. For a pointer to a volatile or const data object, you must place the keyword 
  3092. before the type specifier. For example: 
  3093.  
  3094. volatile int *x;         /* x is a pointer to a volatile int  */
  3095. const int *y;            /* y is a pointer to a const int  */
  3096.  
  3097. You can assign a value to the int * const y but not to const int * y. 
  3098.  
  3099. For other types of volatile and const variables, the position of the keyword 
  3100. within the definition (or declaration) is less important.  For example: 
  3101.  
  3102. volatile struct omega {
  3103.                          int limit;
  3104.                          char code;
  3105.                       } group;
  3106.  
  3107. provides the same storage as: 
  3108.  
  3109. struct omega {
  3110.                 int limit;
  3111.                 char code;
  3112.              } volatile group;
  3113.  
  3114. In both examples, only the structure variable group receives the volatile 
  3115. qualifier. Similarly, if you specified the const keyword instead of volatile, 
  3116. only the structure variable group receives the const qualifier. The const and 
  3117. volatile qualifiers when applied to a structure, union, or class also apply to 
  3118. the members of the structure, union, or class. 
  3119.  
  3120. Although enumeration, structure, and union variables can receive the volatile 
  3121. or const qualifier, enumeration, structure, and union tags do not carry the 
  3122. volatile or const qualifier. For example, the blue structure does not carry the 
  3123. volatile qualifier: 
  3124.  
  3125. volatile struct whale {
  3126.                            int weight;
  3127.                            char name[8];
  3128.                       } killer;
  3129. struct whale blue;
  3130.  
  3131. The keyword volatile or const cannot separate the keywords enum, struct, and 
  3132. union from their tags. 
  3133.  
  3134. You can declare or define a volatile or const function only if it is a member 
  3135. function.  You can define or declare any function to return a pointer to a 
  3136. volatile or const function. 
  3137.  
  3138. You can place more than one qualifier on a declaration but you cannot specify 
  3139. the same qualifier more than once on a declaration. 
  3140.  
  3141. These type qualifiers are only meaningful on expressions that are lvalues. 
  3142.  
  3143. Related Information 
  3144.  
  3145. o Declarators 
  3146. o _Packed Qualifier 
  3147. o _Seg16 Type Qualifier 
  3148. o _Export Qualifier 
  3149. o Types 
  3150. o Structures 
  3151. o Unions 
  3152. o Enumerations 
  3153. o Pointers 
  3154. o Lvalue 
  3155.  
  3156.  
  3157. ΓòÉΓòÉΓòÉ 5.5.2. _Packed Qualifier ΓòÉΓòÉΓòÉ
  3158.  
  3159. The _Packed qualifier removes padding between members of structures and unions, 
  3160. whenever possible. However, the storage saved using packed structures and 
  3161. unions may come at the expense of runtime performance.  Most machines access 
  3162. data more efficiently if it is aligned on appropriate boundaries.  With packed 
  3163. structures and unions, members are generally not aligned on natural boundaries, 
  3164. and the result is that member-accessing operations (using the . and -> 
  3165. operators) are slower. 
  3166.  
  3167. _Packed can only be used with structs or unions. If you use _Packed with other 
  3168. types, an error message is generated and the qualifier has no effect on the 
  3169. declarator it qualifies.  Packed and nonpacked structures and unions have 
  3170. different storage layouts.  However, a packed structure or union can be 
  3171. assigned to a nonpacked structure or union of the same type, and nonpacked 
  3172. structure or union can be assigned to a packed structure or union. Comparisons 
  3173. between packed and nonpacked structures or unions of the same type are 
  3174. prohibited. 
  3175.  
  3176. If you specify the _Packed qualifier on a structure or union that contains a 
  3177. structure or union as a member, the qualifier is not passed on to the contained 
  3178. structure or union. 
  3179.  
  3180. The C/C++ Tools compiler also lets you pack structures using the #pragma pack 
  3181. directive or the /Sp option. See #pragma for more information on #pragma pack. 
  3182.  
  3183. Note:  C++ does not support the _Packed keyword.  Use the #pragma directive or 
  3184. compiler option to control the alignment of structures and unions. 
  3185.  
  3186. Related Information 
  3187.  
  3188. o pack 
  3189. o /Sp option 
  3190. o Declarators 
  3191. o volatile and const Qualifiers 
  3192. o _Seg16 Type Qualifier 
  3193. o _Export Qualifier 
  3194. o Types 
  3195. o Structures 
  3196. o Unions 
  3197.  
  3198.  
  3199. ΓòÉΓòÉΓòÉ <hidden> Examples of Declarators ΓòÉΓòÉΓòÉ
  3200.  
  3201. The following table describes some declarators: 
  3202.  
  3203. Example         Description 
  3204. int owner       owner is an int data object. 
  3205. int *node       node is a pointer to an int data object. 
  3206. int names[126]  names is an array of 126 int elements. 
  3207. int *action( )  action is a function returning a pointer to an int. 
  3208. volatile int min min is a int that has the volatile 
  3209. int * volatile volume volume is a volatile pointer to an int. 
  3210. volatile int * next next is a pointer to a volatile int 
  3211. volatile int * sequence[5] sequence is an array of five pointers to volatile 
  3212.                 int objects. 
  3213. extern const volatile int op_system_clock op_system_clock is an extern int that 
  3214.                 has the volatile attribute. 
  3215.  
  3216.  
  3217. ΓòÉΓòÉΓòÉ 5.5.3. _Seg16 Type Qualifier ΓòÉΓòÉΓòÉ
  3218.  
  3219. Because pointers are interpreted differently in 16-bit programs than in 32-bit 
  3220. programs, they cannot be shared between the two types of program.  Use the 
  3221. _Seg16 type qualifier when calling 16-bit code to ensure correct mapping of 
  3222. pointers between the different types of code. For example: 
  3223.  
  3224.    char * _Seg16 p16;
  3225.  
  3226. declares p16 to be a segmented pointer that can be addressed by a 16-bit 
  3227. program. The pointer can also be used in a 32-bit program, because the compiler 
  3228. converts it to 32-bit form. The _Seg16 qualifier can only be used with 
  3229. pointers. Note that _Seg16 comes after the asterisk in the declaration, as 
  3230. required by ANSI syntax rules. All pointers shared between 32-bit and 16-bit 
  3231. code must be qualified with _Seg16. These include pointers passed indirectly to 
  3232. 16-bit code, such as pointers in structures and pointers that are referenced by 
  3233. pointers passed directly to 16-bit code. 
  3234.  
  3235. While it is possible to write a program where all the pointers are qualified 
  3236. with _Seg16, it is not recommended. Every time a segmented pointer is used in a 
  3237. 32-bit program, it must be converted to a 32-bit pointer and then back to 
  3238. segmented pointer to be stored. This process will cause a noticeable 
  3239. performance degradation in your program. Pointers that are not shared with 
  3240. 16-bit code and those that are passed by value to 16-bit code (that is, as a 
  3241. parameter to a function) do not need to be qualified with _Seg16. 
  3242.  
  3243. For more information on using _Seg16 and calling 16-bit programs from 32-bit 
  3244. code, see the Programming Guide. 
  3245.  
  3246. Related Information 
  3247.  
  3248. o Pointers 
  3249. o #pragma seg16 
  3250. o Declarators 
  3251. o volatile and const Qualifiers 
  3252. o _Packed Qualifier 
  3253. o _Export Qualifier 
  3254.  
  3255.  
  3256. ΓòÉΓòÉΓòÉ 5.5.4. _Export Qualifier ΓòÉΓòÉΓòÉ
  3257.  
  3258. Use the _Export keyword with a function name to declare that the function is to 
  3259. be exported, that is, made available to other modules. For example: 
  3260.  
  3261.    int _Export anthony(float);
  3262.  
  3263. causes the function anthony to be exported. 
  3264.  
  3265. You can use _Export at any language level. If you also use linkage keywords, 
  3266. you can place _Export either before or after a linkage keyword. For example, 
  3267. both of the following declarations are valid: 
  3268.  
  3269.    int _Export _Optlink brian(int);
  3270.    int _Optlink _Export brian(int);
  3271.  
  3272. The _Export keyword is an alternative to the #pragma export directive.  Note 
  3273. that #pragma export allows you to specify both a name and an ordinal number by 
  3274. which the function can be called. If you use _Export, other modules must call 
  3275. the function using its original name. 
  3276.  
  3277. If you use _Export to export your function, you may still need to provide an 
  3278. EXPORTS entry for that function in your module definition (.DEF) file. If your 
  3279. function has any of the following default characteristics 
  3280.  
  3281. o Has shared data 
  3282. o Has no I/O privileges 
  3283. o Is not resident 
  3284.  
  3285. it does not require an EXPORTS entry. If your function has characteristics 
  3286. other than the defaults, the only way you can specify them is with an EXPORTS 
  3287. entry in your .DEF file. 
  3288.  
  3289. Note:  To create an import library for the DLL, you must either create it from 
  3290. the DLL itself or provide a .DEF file with an EXPORTS entry for every function, 
  3291. regardless of whether _Export is used. 
  3292.  
  3293. For more information on DLLs and .DEF files, see the Programming Guide. 
  3294.  
  3295. Related Information 
  3296.  
  3297. o #pragma export 
  3298. o Declarators 
  3299. o volatile and const Qualifiers 
  3300. o _Packed Qualifier 
  3301. o _Seg16 Type Qualifier 
  3302.  
  3303.  
  3304. ΓòÉΓòÉΓòÉ 5.6. Initializers ΓòÉΓòÉΓòÉ
  3305.  
  3306. An initializer is an optional part of a data declaration that specifies an 
  3307. initial value of a data object. 
  3308.  
  3309. Syntax of an Initializer 
  3310.  
  3311. The initializer consists of the = symbol followed by an initial expression or a 
  3312. braced list of initial expressions separated by commas. The number of 
  3313. initializers should not be more than the number of elements to be initialized. 
  3314. The initial expression evaluates to the first value of the data object. 
  3315.  
  3316. An initializer of the form (expression_list) can be used to initialize C++ 
  3317. classes.  For more information on initializing classes, see Initialization by 
  3318. Constructor. 
  3319.  
  3320. To assign a value to a scalar object, use the simple initializer: 
  3321. = expression. For example, the following data definition uses the initializer 
  3322. =3 to set the initial value of group to 3: 
  3323.  
  3324. int group = 3;
  3325.  
  3326. In C++, you can also use the (expression_list) form to initialize fundamental 
  3327. types. For example, the following two initializations are identical: 
  3328.  
  3329. int group = 3;
  3330. int group(3);
  3331.  
  3332. For unions, structures, and aggregate classes (classes with no constructors, 
  3333. base classes, virtual functions, or private or protected members), the set of 
  3334. initial expressions must be enclosed in { } (braces) unless the initializer is 
  3335. a string literal. If the initializer of a character string is a string literal, 
  3336. the { } are optional.  Individual expressions must be separated by commas, and 
  3337. groups of expressions can be enclosed in braces and separated by commas.  The 
  3338. number of initializers must be less than or equal to the number of objects 
  3339. being initialized.  In the following example, only the first eight elements of 
  3340. the array grid are explicitly initialized.  The remaining four elements that 
  3341. are not explicitly initialized are initialized as if you explicitly initialized 
  3342. them to zero. 
  3343.  
  3344. static short grid[3] [4] = {0, 0, 0, 1, 0, 0, 1, 1};
  3345.  
  3346. The initial values of grid are: 
  3347.  
  3348. Element               Value 
  3349. grid[0][0]            0 
  3350. grid[0][1]            0 
  3351. grid[0][2]            0 
  3352. grid[0][3]            1 
  3353. grid[1][0]            0 
  3354. grid[1][1]            0 
  3355. grid[1][2]            1 
  3356. grid[1][3]            1 
  3357. grid[2][0]            0 
  3358. grid[2][1]            0 
  3359. grid[2][2]            0 
  3360. grid[2][3]            0 
  3361.  
  3362. C++ Considerations: 
  3363.  
  3364. o You can initialize variables at file scope with nonconstant expressions. 
  3365.   This is not allowed in ANSI C. 
  3366. o If your code jumps over declarations that contain initializations, the 
  3367.   compiler generates an error.  For example, the following code is not valid in 
  3368.   C++: 
  3369.  
  3370.     goto skiplabel;    // error - jumped over declaration
  3371.     int i = 3;         //   and initialization of i
  3372.  
  3373.     skiplabel: i = 4;
  3374.  
  3375. o You can initialize classes in external, static, and automatic definitions. 
  3376.   The initializer contains an = (equal sign) followed by a brace-enclosed, 
  3377.   comma-separated list of values.  You do not need to initialize all members of 
  3378.   a class. 
  3379.  
  3380. Initialization considerations for each data type are described in the section 
  3381. for that data type. 
  3382.  
  3383. Related Information 
  3384.  
  3385. o Block Scope Data Declarations 
  3386. o File Scope Data Declarations 
  3387. o Arrays 
  3388. o Characters 
  3389. o Enumerations 
  3390. o Floating-Point Variables 
  3391. o Integers 
  3392. o Pointers 
  3393. o Structures 
  3394. o Unions 
  3395.  
  3396.  
  3397. ΓòÉΓòÉΓòÉ <hidden> Syntax of an Initializer ΓòÉΓòÉΓòÉ
  3398.  
  3399. An initializer has the form: 
  3400.  
  3401.     ΓöîΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  3402.            Γöé
  3403. >>ΓöÇΓöÇΓö¼ΓöÇ(ΓöÇΓöÇΓöÇexpressionΓöÇΓö┤ΓöÇ)ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ><
  3404.   ΓööΓöÇ=ΓöÇΓöÇΓö¼ΓöÇexpressionΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÿ
  3405.      Γöé    ΓöîΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ         Γöé
  3406.      Γöé           Γöé         Γöé
  3407.      ΓööΓöÇ{ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇexpressionΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ}ΓöÇΓöÿ
  3408.        Γöé ΓöîΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ Γöé
  3409.        Γöé Γöé   ΓöîΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ   Γöé Γöé
  3410.        Γöé           Γöé   Γöé Γöé
  3411.        ΓööΓöÇΓöÇΓöÇ{ΓöÇΓöÇΓöÇΓöÇexpressionΓöÇΓö┤ΓöÇΓöÇ}ΓöÇΓö┤ΓöÇΓöÿ
  3412.  
  3413. The form (expression) is allowed in C++ only. 
  3414.  
  3415.  
  3416. ΓòÉΓòÉΓòÉ 5.7. Types ΓòÉΓòÉΓòÉ
  3417.  
  3418. The fundamental data types for C and C++ are: 
  3419.  
  3420. o Characters 
  3421. o Floating-Point Variables 
  3422. o Integers 
  3423. o void Type 
  3424. o Enumerations 
  3425.  
  3426. From these types, you can derive the following: 
  3427.  
  3428. o Arrays 
  3429. o Pointers 
  3430. o References (C++ only) 
  3431. o Structures 
  3432. o Unions 
  3433. o Functions 
  3434. o Classes (C++ only) 
  3435. o Pointers to Members (C++ only) 
  3436.  
  3437.  
  3438. ΓòÉΓòÉΓòÉ 5.7.1. Characters ΓòÉΓòÉΓòÉ
  3439.  
  3440. There are three character data types: char, signed char, and unsigned char. 
  3441. These data types provide enough storage to hold any member of the character set 
  3442. used at run time. For the C/C++ Tools compiler, the size of a char is 8 bits. 
  3443.  
  3444. The default type of char is unsigned char. You can change this default using 
  3445. #pragma chars or the /J compiler option. If it does not matter whether a char 
  3446. data object is signed or unsigned, you can declare the object as having the 
  3447. data type char;  otherwise, explicitly declare signed char or unsigned char. 
  3448.  
  3449. C++ Consideration:  For the purposes of distinguishing overloaded functions, 
  3450. char in C++ is a distinct type from signed char and unsigned char. When a char 
  3451. (signed or unsigned) is widened to an int, its value is preserved. 
  3452.  
  3453. To declare a data object having a character data type, place a char specifier 
  3454. in the type specifier position of the declaration. 
  3455.  
  3456. The declarator for a simple character declaration is an identifier.  You can 
  3457. initialize a simple character with a character constant or with an expression 
  3458. that evaluates to an integer. 
  3459.  
  3460. You can use the char specifier in variable definitions to define such variables 
  3461. as:  arrays of characters, pointers to characters, and arrays of pointers to 
  3462. characters. 
  3463.  
  3464. Examples of Character Data Types 
  3465.  
  3466. Related Information 
  3467.  
  3468. o Arrays 
  3469. o Pointers 
  3470. o Character Constants 
  3471. o Assignment Expression 
  3472. o Declarators 
  3473. o Initializers 
  3474.  
  3475.  
  3476. ΓòÉΓòÉΓòÉ <hidden> Examples of Character Data Types ΓòÉΓòÉΓòÉ
  3477.  
  3478. The following example defines the identifier end_of_string as a constant object 
  3479. of type char having the initial value \0 (the null character): 
  3480.  
  3481. const char end_of_string = '\0';
  3482.  
  3483. The following example defines the unsigned char variable switches as having the 
  3484. initial value 3: 
  3485.  
  3486. unsigned char switches = 3;
  3487.  
  3488. The following example defines string_pointer as a pointer to a character: 
  3489.  
  3490. char *string_pointer;
  3491.  
  3492. The following example defines name as a pointer to a character.  After 
  3493. initialization, name points to the first letter in the character string 
  3494. "Johnny": 
  3495.  
  3496. char *name = "Johnny";
  3497.  
  3498. The following example defines a one-dimensional array of pointers to 
  3499. characters.  The array has three elements.  Initially they are a pointer to the 
  3500. string "Venus", a pointer to "Jupiter", and a pointer to "Saturn": 
  3501.  
  3502. static char *planets[ ] = { "Venus", "Jupiter", "Saturn" };
  3503.  
  3504.  
  3505. ΓòÉΓòÉΓòÉ 5.7.2. Floating-Point Variables ΓòÉΓòÉΓòÉ
  3506.  
  3507. There are three types of floating-point variables:  float, double, and long 
  3508. double. 
  3509.  
  3510. The storage size of a float variable is less than or equal to the storage size 
  3511. of a double variable. The storage size of a double variable is less than or 
  3512. equal to the storage size of a long double variable.  Thus, the following 
  3513. expression always evaluates to 1 (true): 
  3514.  
  3515. sizeof(float) <= sizeof(double) && sizeof(double) <= sizeof(long double)
  3516.  
  3517. For the C/C++ Tools compiler,  the size of a float is 4 bytes, a double is 8 
  3518. bytes, and a long double is 16 bytes. 
  3519.  
  3520. To declare a data object having a floating-point type, use the float specifier. 
  3521.  
  3522. The declarator for a simple floating-point declaration is an identifier.  You 
  3523. can initialize a simple floating-point variable with a float constant or with a 
  3524. variable or expression that evaluates to an integer or floating-point number. 
  3525. (The storage class of a variable determines how you can initialize the 
  3526. variable.) 
  3527.  
  3528. Examples of Floating-Point Data Types 
  3529.  
  3530. Related Information 
  3531.  
  3532. o Floating-Point Constants 
  3533. o <float.h> 
  3534. o Assignment Expression 
  3535. o Integers 
  3536. o Declarators 
  3537. o Initializers 
  3538.  
  3539.  
  3540. ΓòÉΓòÉΓòÉ <hidden> Examples of Floating-Point Data Types ΓòÉΓòÉΓòÉ
  3541.  
  3542. The following example defines the identifier pi for an object of type double: 
  3543.  
  3544. double pi;
  3545.  
  3546. The following example defines the float variable real_number with the initial 
  3547. value 100.55: 
  3548.  
  3549. static float real_number = 100.55;
  3550.  
  3551. The following example defines the float variable float_var with the initial 
  3552. value 0.0143: 
  3553.  
  3554. float float_var = 1.43e-2;
  3555.  
  3556. The following example declares the long double variable maximum: 
  3557.  
  3558. extern long double maximum;
  3559.  
  3560. The following example defines the array table with 20 elements of type double: 
  3561.  
  3562. double table[20];
  3563.  
  3564.  
  3565. ΓòÉΓòÉΓòÉ 5.7.3. Integers ΓòÉΓòÉΓòÉ
  3566.  
  3567. There are six types of integer variables: 
  3568.  
  3569. o short int, short, signed short, or signed short int 
  3570. o signed int or int (In some cases, no type specifier is needed;  see Block 
  3571.   Scope Data Declarations and File Scope Data Declarations.) 
  3572. o long int, long, signed long, or signed long int 
  3573. o unsigned short int or unsigned short 
  3574. o unsigned or unsigned int 
  3575. o unsigned long int or unsigned long. 
  3576.  
  3577. C++ Considerations:  When the arguments in overloaded functions and overloaded 
  3578. operators are integer types, two integer types that both come from the same 
  3579. group are not treated as distinct types.  For example, you cannot overload an 
  3580. int argument against a signed int argument.  Overloading and argument matching 
  3581. is described in C++ Overloading. 
  3582.  
  3583. The default integer type for a bit field is unsigned. 
  3584.  
  3585. The storage size of a short type is less than or equal to the storage size of 
  3586. an int variable and the storage size of an int variable is less than or equal 
  3587. to the storage size of a long variable.  Thus, the following expression always 
  3588. evaluates to 1 (true): 
  3589.  
  3590. sizeof(short) <= sizeof(int) && sizeof(int) <= sizeof(long)
  3591.  
  3592. Two sizes for integer data types are provided.  Objects having type short are 2 
  3593. bytes of storage long.  Objects having type long are 4 bytes of storage long. 
  3594. An int represents the most efficient data storage size on the system (the 
  3595. word-size of the machine) and receives 4 bytes of storage. 
  3596.  
  3597. The unsigned prefix indicates that the value of the object is a nonnegative 
  3598. integer.  Each unsigned type provides the same size storage as its signed 
  3599. equivalent.  For example, int reserves the same storage as unsigned int. 
  3600. Because a signed type reserves a sign bit, an unsigned type can hold a larger 
  3601. positive integer than the equivalent signed type. 
  3602.  
  3603. To declare a data object having an integer data type, place an int specifier in 
  3604. the type specifier position of the declaration. 
  3605.  
  3606. The declarator for a simple integer definition or declaration is an identifier. 
  3607. You can initialize a simple integer definition with an integer constant or with 
  3608. an expression that evaluates to a value that can be assigned to an integer. 
  3609. (The storage class of a variable determines how you can initialize the 
  3610. variable.) 
  3611.  
  3612. Examples of Integer Data Types 
  3613.  
  3614. Related Information 
  3615.  
  3616. o Integer Constants 
  3617. o Decimal Constants 
  3618. o Octal Constants 
  3619. o Hexadecimal Constants 
  3620. o Declarators 
  3621. o Initializers 
  3622.  
  3623.  
  3624. ΓòÉΓòÉΓòÉ <hidden> Examples of Integer Data Types ΓòÉΓòÉΓòÉ
  3625.  
  3626. The following example defines the short int variable flag: 
  3627.  
  3628. short int flag;
  3629.  
  3630. The following example defines the int variable result: 
  3631.  
  3632. int result;
  3633.  
  3634. The following example defines the unsigned long int variable ss_number as 
  3635. having the initial value 438888834: 
  3636.  
  3637. unsigned long ss_number = 438888834ul;
  3638.  
  3639. The following example defines the identifier sum for an object of type int. 
  3640. The initial value of sum is the result of the expression a + b: 
  3641.  
  3642. extern int a, b;
  3643. auto sum  = a + b;
  3644.  
  3645.  
  3646. ΓòÉΓòÉΓòÉ 5.7.4. void Type ΓòÉΓòÉΓòÉ
  3647.  
  3648. void is a data type that always represents an empty set of values.  The keyword 
  3649. for this type is void.  When a function does not return a value, you should use 
  3650. void as the type specifier in the function definition and declaration. An 
  3651. argument list for a function taking no arguments is void. The only object that 
  3652. can be declared with the type specifier void is a pointer. You cannot declare a 
  3653. variable of type void. 
  3654.  
  3655. You can explicitly convert any expression to type void, but the resulting 
  3656. expression can only be used as one of the following: 
  3657.  
  3658. o An expression statement 
  3659. o The left operand of a comma expression 
  3660. o The second or third operand in a conditional expression. 
  3661.  
  3662. Example of void Type 
  3663.  
  3664. Related Information 
  3665.  
  3666. o Cast Expressions 
  3667. o Types 
  3668. o Expressions and Operators 
  3669.  
  3670.  
  3671. ΓòÉΓòÉΓòÉ <hidden> Example of void Type ΓòÉΓòÉΓòÉ
  3672.  
  3673. /************************************************************************
  3674. *
  3675.  
  3676. On line 3 of the following example, the function find_max is declared as having 
  3677. type void.  Lines 12 through 23 contain the complete definition of find_max. 
  3678.  
  3679. Note that the use of the sizeof operator in line 9 is a standard method of 
  3680. determining the number of elements in an array. 
  3681.  
  3682.                                                                         *
  3683. ************************************************************************/
  3684.  
  3685.  1   #include <stdio.h>
  3686.  2
  3687.  3   /* declaration of function find_max */
  3688.  4   extern void find_max(int x[ ], int j);
  3689.  5
  3690.  6   int main(void)
  3691.  7   {
  3692.  8      static int numbers[ ] = { 99, 54, -102, 89 };
  3693.  9
  3694. 10      find_max(numbers, (sizeof(numbers) / sizeof(numbers[0])));
  3695. 11   }
  3696. 12   void find_max(int x[ ], int j)
  3697. 13
  3698. 14   { /* begin definition of function find_max */
  3699. 15      int i, temp = x[0];
  3700. 16
  3701. 17      for (i = 1; i < j; i++)
  3702. 18      {
  3703. 19          if (x[i] > temp)
  3704. 20             temp = x[i];
  3705. 21      }
  3706. 22      printf("max number = %d\n", temp);
  3707. 23   } /* end definition of function find_max  */
  3708.  
  3709.  
  3710. ΓòÉΓòÉΓòÉ 5.7.5. Enumerations ΓòÉΓòÉΓòÉ
  3711.  
  3712. An enumeration data type represents a set of values that you declare.  You can 
  3713. define an enumeration data type and all variables that have that enumeration 
  3714. type in one statement, or you can separate the declaration of the enumeration 
  3715. data type from all variable definitions.  The identifier associated with the 
  3716. data type (not an object) is a tag. 
  3717.  
  3718. Note:  In C, an enumeration must be of type int. This restriction does not 
  3719. apply to C++.  In C++, an enumeration has a distinct type that does not have to 
  3720. be integral. Enumeration constants can be promoted to a signed or unsigned 
  3721. integral constant when used in an expression. 
  3722.  
  3723. An enumeration type declaration contains the enum keyword followed by an 
  3724. identifier (the enumeration tag) and a brace-enclosed list of enumerators. Each 
  3725. enumerator is separated by a comma. 
  3726.  
  3727. Syntax of an Enumeration 
  3728.  
  3729. The keyword enum, followed by the identifier, names the data type (like the tag 
  3730. on a struct data type).  The list of enumerators provides the data type with a 
  3731. set of values. In C, each enumerator represents an integer value. In C++, each 
  3732. enumerator represents a value that can be converted to an integral value. To 
  3733. conserve space, enumerations may be stored in spaces smaller than that of an 
  3734. int. By default, the type of the enum variable is the size of the smallest 
  3735. integral type that can contain all enumerator values.  You can change the 
  3736. default using the /Su option. 
  3737.  
  3738. The identifier in an enumerator is called an enumeration constant. You can use 
  3739. an enumeration constant anywhere a value of the enumeration type can be used. 
  3740. When an enumeration constant is used in an expression, the C/C++ Tools compiler 
  3741. can promote it to a signed or unsigned integral constant to determine its 
  3742. value. The value of an enumeration constant is determined by the following 
  3743. rules: 
  3744.  
  3745.  1. If an = (equal sign) and a constant expression follow the identifier, the 
  3746.     identifier represents the value of the constant expression. 
  3747.  
  3748.  2. If the enumerator is the leftmost value in the list, the identifier 
  3749.     represents the value 0. 
  3750.  
  3751.  3. Otherwise, the identifier represents the integer value that is one greater 
  3752.     than the value represented by the preceding enumerator. 
  3753.  
  3754. Each enumeration constant must be unique within the block or the file where the 
  3755. enumeration data type is defined. In the following example, the declarations of 
  3756. average on line 4 and of poor on line 5 cause compiler error messages: 
  3757.  
  3758.  1   func()
  3759.  2   {
  3760.  3      enum score { poor, average, good };
  3761.  4      enum rating { below, average, above };
  3762.  5      int poor;
  3763.  6   }
  3764.  
  3765. Additional information is provided on: 
  3766.  
  3767. o Defining Enumeration Variables 
  3768. o Defining Enumeration Types and Objects 
  3769. o Example Program Using Enumeration Types 
  3770.  
  3771. Examples of Enumeration Types 
  3772.  
  3773. Related Information 
  3774.  
  3775. o Enumeration Constants 
  3776. o Constant Expression 
  3777. o Identifiers 
  3778. o Declarators 
  3779. o Initializers 
  3780.  
  3781.  
  3782. ΓòÉΓòÉΓòÉ <hidden> Syntax of an Enumeration ΓòÉΓòÉΓòÉ
  3783.  
  3784. An enumeration type declaration has the form: 
  3785.  
  3786.                  ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  3787.                         Γöé
  3788. ΓöÇΓöÇenumΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ{ΓöÇΓöÇΓöÇenumeratorΓöÇΓö┤ΓöÇ}ΓöÇΓöÇΓöÇΓöÇ
  3789.        Γöé        Γöé
  3790.        ΓööΓöÇΓöÇidentifierΓöÇΓöÇΓöÿ
  3791.  
  3792. An enumerator has the form: 
  3793.  
  3794. ΓöÇΓöÇidentifierΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ
  3795.         Γöé               Γöé
  3796.         ΓööΓöÇΓöÇ=ΓöÇΓöÇΓöÇΓöÇconstant_expressionΓöÇΓöÇΓöÇΓöÿ
  3797.  
  3798.  
  3799. ΓòÉΓòÉΓòÉ <hidden> Examples of Enumeration Types ΓòÉΓòÉΓòÉ
  3800.  
  3801. The following example declares the enumeration tag status: 
  3802.  
  3803. enum status { run, create, delete=5, suspend };
  3804.  
  3805. The data type status represents the following values: 
  3806.  
  3807. Enumeration         Integer 
  3808. Constant            Representation 
  3809. run                 0 
  3810. create              1 
  3811. delete              5 
  3812. suspend             6 
  3813.  
  3814.  
  3815. ΓòÉΓòÉΓòÉ 5.7.5.1. Defining Enumeration Variables ΓòÉΓòÉΓòÉ
  3816.  
  3817. An enumeration variable definition contains a storage class specifier 
  3818. (optional), a type specifier, a declarator, and an initializer (optional).  The 
  3819. type specifier contains the keyword enum followed by the name of the 
  3820. enumeration data type. You must declare the enumeration data type before you 
  3821. can define a variable having that type. 
  3822.  
  3823. The first line of the following example declares the enumeration tag grain. 
  3824. The second line defines the variable g_food and gives g_food the initial value 
  3825. of barley (2). The type specifier enum grain indicates that the value of g_food 
  3826. is a member of the enumerated data type grain: In C++, the value of g_food has 
  3827. the enumerated data type grain. 
  3828.  
  3829. enum grain { oats, wheat, barley, corn, rice };
  3830. enum grain g_food = barley;
  3831.  
  3832. The initializer for an enumeration variable contains the = symbol followed by 
  3833. an expression. In C, the expression must evaluate to an int value. In C++, the 
  3834. expression must be have the same type as the associated enumeration type. 
  3835.  
  3836. C++ also makes the enum keyword optional in an initialization expression like 
  3837. the one in the second line of the preceding example.  For example, both of the 
  3838. following statements are valid C++ code: 
  3839.  
  3840. enum grain g_food = barley;
  3841.      grain cob_food = corn;
  3842.  
  3843.  
  3844. ΓòÉΓòÉΓòÉ 5.7.5.2. Defining Enumeration Types and Objects ΓòÉΓòÉΓòÉ
  3845.  
  3846. You can place a type definition and a variable definition in one statement by 
  3847. placing a declarator and an optional initializer after the type definition.  If 
  3848. you want to specify a storage class specifier for the variable, you must place 
  3849. the storage class specifier at the beginning of the declaration.  For example: 
  3850.  
  3851. register enum score { poor=1, average, good } rating = good;
  3852.  
  3853. C++ also allows you to place the storage class immediately before the 
  3854. declarator.  For example: 
  3855.  
  3856. enum score { poor=1, average, good } register rating = good;
  3857.  
  3858. Either of these examples is equivalent to the following two declarations: 
  3859.  
  3860. enum score { poor=1, average, good };
  3861. register enum score rating = good;
  3862.  
  3863. Both examples define the enumeration data type score and the variable rating. 
  3864. rating has the storage class specifier register, the data type enum score, and 
  3865. the initial value good. 
  3866.  
  3867. If you combine a data type definition with the definitions of all variables 
  3868. having that data type, you can leave the data type unnamed.  For example: 
  3869.  
  3870. enum { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday,
  3871.       Saturday } weekday;
  3872.  
  3873. This example defines the variable weekday, which can be assigned any of the 
  3874. specified enumeration constants. 
  3875.  
  3876.  
  3877. ΓòÉΓòÉΓòÉ 5.7.5.3. Example Program Using Enumerations ΓòÉΓòÉΓòÉ
  3878.  
  3879. /**********************************************************************************
  3880. *
  3881.  
  3882. The following program receives an integer as input.  The output is a sentence 
  3883. that gives the French name for the weekday that is associated with the integer. 
  3884. If the integer is not associated with a weekday, the program prints "C'est le 
  3885. mauvais jour." 
  3886.  
  3887.                                                                         *
  3888. ************************************************************************/
  3889.  
  3890. #include <stdio.h>
  3891.  
  3892. enum days {
  3893.             Monday=1, Tuesday, Wednesday,
  3894.             Thursday, Friday, Saturday, Sunday
  3895.           } weekday;
  3896.  
  3897. void french(enum days);
  3898.  
  3899. int main(void)
  3900. {
  3901.    int num;
  3902.  
  3903.    printf("Enter an integer for the day of the week.  "
  3904.           "Mon=1,...,Sun=7\n");
  3905.    scanf("%d", &num);
  3906.    weekday=num;
  3907.    french(weekday);
  3908. }
  3909.  
  3910. void french(enum days weekday);
  3911. {
  3912.    switch (weekday)
  3913.    {
  3914.       case Monday:
  3915.          printf("Le jour de la semaine est lundi.\n");
  3916.          break;
  3917.       case Tuesday:
  3918.          printf("Le jour de la semaine est mardi.\n");
  3919.          break;
  3920.       case Wednesday:
  3921.          printf("Le jour de la semaine est mercredi.\n");
  3922.          break;
  3923.       case Thursday:
  3924.          printf("Le jour de la semaine est jeudi.\n");
  3925.          break;
  3926.       case Friday:
  3927.          printf("Le jour de la semaine est vendredi.\n");
  3928.          break;
  3929.       case Saturday:
  3930.          printf("Le jour de la semaine est samedi.\n");
  3931.          break;
  3932.       case Sunday:
  3933.          printf("Le jour de la semaine est dimanche.\n");
  3934.          break;
  3935.       default:
  3936.          printf("C'est le mauvais jour.\n");
  3937.    }
  3938. }
  3939.  
  3940.  
  3941. ΓòÉΓòÉΓòÉ 5.7.6. Arrays ΓòÉΓòÉΓòÉ
  3942.  
  3943. An array is an ordered group of data objects.  Each object is called an 
  3944. element.  All elements within an array have the same data type. 
  3945.  
  3946. You can use any type specifier in an array definition or declaration. Thus, 
  3947. array elements can be of any data type, except function or reference. (You can, 
  3948. however, declare an array of pointers to functions.) 
  3949.  
  3950. The declarator contains an identifier followed by a subscript declarator.  The 
  3951. identifier can be preceded by an * (asterisk), making the variable an array of 
  3952. pointers. 
  3953.  
  3954. The subscript declarator describes the number of dimensions in the array and 
  3955. the number of elements in each dimension. 
  3956.  
  3957. Syntax of a Subscript Declarator 
  3958.  
  3959. Each bracketed expression, or subscript, describes a different dimension and 
  3960. must be a constant expression. The constant expression must have an integral 
  3961. value. The value of the constant expression determines the number of elements 
  3962. in that dimension. The following example defines a one-dimensional array that 
  3963. contains four elements having type char: 
  3964.  
  3965. char list[4];
  3966.  
  3967. The first subscript of each dimension is 0.  Thus, the array list contains the 
  3968. elements: 
  3969.  
  3970. list[0]
  3971. list[1]
  3972. list[2]
  3973. list[3]
  3974.  
  3975. The following example defines a two-dimensional array that contains six 
  3976. elements of type int: 
  3977.  
  3978. int roster[3][2];
  3979.  
  3980. Multidimensional arrays are stored in row-major order; when elements are 
  3981. referenced in order of increasing storage location, the last subscript varies 
  3982. the fastest. For example, the elements of array roster are stored in the order: 
  3983.  
  3984. roster[0][0]
  3985. roster[0][1]
  3986. roster[1][0]
  3987. roster[1][1]
  3988. roster[2][0]
  3989. roster[2][1]
  3990.  
  3991. In storage, the elements of roster would be stored as: 
  3992.  
  3993.  
  3994.  Γöé                Γöé                Γöé
  3995.  Γöö ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ ΓöÇΓöÇΓöÇΓöÇΓöÇ Γö┤ ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ ΓöÇΓöÇΓöÇΓöÇΓöÇ Γö┤ ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ ΓöÇΓöÇΓöÇΓöÇΓöÇ
  3996.                                  
  3997.  Γöé                Γöé                Γöé
  3998.  roster [ 0 ] [ 0 ]     roster [ 0 ] [ 1 ]     roster [ 1 ] [ 0 ]
  3999.  
  4000. You can leave the first (and only the first) set of subscript brackets empty in 
  4001.  
  4002. o Array definitions that contain initializations 
  4003. o extern declarations 
  4004. o Parameter declarations. 
  4005.  
  4006. In array definitions that leave the first set of subscript brackets empty, the 
  4007. compiler uses the initializer to determine the number of elements in the first 
  4008. dimension.  In a one-dimensional array, the number of initialized elements 
  4009. becomes the total number of elements.  In a multidimensional array, the 
  4010. compiler compares the initializer to the subscript declarator to determine the 
  4011. number of elements in the first dimension. 
  4012.  
  4013. An unsubscripted array name (for example, region instead of region[4]) 
  4014. represents a pointer whose value is the address of the first element of the 
  4015. array.  For more information, see Primary Expression. 
  4016.  
  4017. Whenever an array is used in a context (such as a parameter) where it cannot be 
  4018. used as an array, the identifier is treated as a pointer. The two exceptions 
  4019. are when an array is used as an operand of the sizeof or the address (&) 
  4020. operator. 
  4021.  
  4022. Additional information is provided on: 
  4023.  
  4024. o Initializing Arrays 
  4025. o Example Programs Using Arrays 
  4026.  
  4027. Related Information 
  4028.  
  4029. o Pointers 
  4030. o Array Subscript  [ ] 
  4031. o Strings 
  4032. o Declarators 
  4033. o Initializers 
  4034. o Conversions 
  4035.  
  4036.  
  4037. ΓòÉΓòÉΓòÉ <hidden> Syntax of a Subscript Declarator ΓòÉΓòÉΓòÉ
  4038.  
  4039. A subscript declarator has the form: 
  4040.  
  4041. ΓöÇΓöÇ[ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ]ΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇ
  4042.     Γöé            Γöé   Γöé ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ Γöé
  4043.     ΓööΓöÇΓöÇconstant_expressionΓöÇΓöÇΓöÿ   Γöé               Γöé Γöé
  4044.                   ΓööΓöÇΓöÇΓöÇ[ΓöÇΓöÇconstant_expressionΓöÇΓöÇ]ΓöÇΓö┤ΓöÇΓöÿ
  4045.  
  4046.  
  4047. ΓòÉΓòÉΓòÉ 5.7.6.1. Initializing Arrays ΓòÉΓòÉΓòÉ
  4048.  
  4049. The initializer contains the = symbol followed by a brace-enclosed 
  4050. comma-separated list of constant expressions. You do not need to initialize all 
  4051. elements in an array. Elements that are not initialized (in extern and static 
  4052. definitions only) receive the value 0. 
  4053.  
  4054. You can initialize a one-dimensional character array by specifying: 
  4055.  
  4056. o A brace-enclosed comma-separated list of constants, each of which can be 
  4057.   contained in a character 
  4058. o A string constant.  (Braces surrounding the constant are optional.) 
  4059.  
  4060. If you specify a string constant, the null character (\0) is placed at the end 
  4061. of the string if there is room or if the array dimensions are not specified. 
  4062.  
  4063. Examples of Initialized Arrays 
  4064.  
  4065. Note that the following definition would result in the null character being 
  4066. lost: 
  4067.  
  4068.    static char name[3]="Jan";
  4069.  
  4070. You can initialize a multidimensional array by: 
  4071.  
  4072. o Listing the values of all elements you want to initialize, in the order that 
  4073.   the compiler assigns the values.  The compiler assigns values by increasing 
  4074.   the subscript of the last dimension fastest.  This form of a multidimensional 
  4075.   array initialization looks like a one-dimensional array initialization.  The 
  4076.   following definition completely initializes the array month_days: 
  4077.  
  4078.        static month_days[2][12] =
  4079.        {
  4080.         31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
  4081.         31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  4082.        };
  4083.  
  4084. o Using braces to group the values of the elements you want initialized.  You 
  4085.   can place braces around each element, or around any nesting level of 
  4086.   elements.  The following definition contains two elements in the first 
  4087.   dimension.  (You can consider these elements as rows.)  The initialization 
  4088.   contains braces around each of these two elements: 
  4089.  
  4090.        static int month_days[2][12] =
  4091.        {
  4092.         { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
  4093.         { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
  4094.        };
  4095.  
  4096. You can use nested braces to initialize dimensions and elements in a dimension 
  4097. selectively. 
  4098.  
  4099. Note:  When using braces, you should place braces around each dimension (fully 
  4100. braced), or only use one set of braces to enclose the entire set of 
  4101. initializers (unbraced).  Avoid putting braces around some elements and not 
  4102. others. 
  4103.  
  4104. You cannot have more initializers than the number of elements in the array. 
  4105.  
  4106.  
  4107. ΓòÉΓòÉΓòÉ <hidden> Examples of Initialized Arrays ΓòÉΓòÉΓòÉ
  4108.  
  4109. The following definition shows a completely initialized one-dimensional array: 
  4110.  
  4111. static int number[3] = { 5, 7, 2 };
  4112.  
  4113. The array number contains the following values: 
  4114.  
  4115. Element        Value 
  4116. number[0]      5 
  4117. number[1]      7 
  4118. number[2]      2 
  4119.  
  4120. The following definition shows a partially initialized one-dimensional array: 
  4121.  
  4122. static int number1[3] = { 5, 7 };
  4123.  
  4124. The values of number1 are: 
  4125.  
  4126. Element        Value 
  4127. number1[0]     5 
  4128. number1[1]     7 
  4129. number1[2]     0 
  4130.  
  4131. Instead of an expression in the subscript declarator defining the number of 
  4132. elements, the following one-dimensional array definition defines one element 
  4133. for each initializer specified: 
  4134.  
  4135. static int item[ ] = { 1, 2, 3, 4, 5 };
  4136.  
  4137. The compiler gives item the five initialized elements: 
  4138.  
  4139. Element        Value 
  4140. item[0]        1 
  4141. item[1]        2 
  4142. item[2]        3 
  4143. item[3]        4 
  4144. item[4]        5 
  4145.  
  4146. The following definitions show character array initializations: 
  4147.  
  4148.    static char name1[ ] = { 'J', 'a', 'n' };
  4149.    static char name2[ ] = { "Jan" };
  4150.    static char name3[4] = "Jan";
  4151.  
  4152. These definitions create the following elements: 
  4153.  
  4154. Element             Value 
  4155. name1[0]            J 
  4156. name1[1]            a 
  4157. name1[2]            n 
  4158. name2[0]            J 
  4159. name2[1]            a 
  4160. name2[2]            n 
  4161. name2[3]            \0 
  4162. name3[0]            J 
  4163. name3[1]            a 
  4164. name3[2]            n 
  4165.  
  4166. The following definition explicitly initializes six elements in a 12-element 
  4167. array: 
  4168.  
  4169. static int matrix[3][4] =
  4170.    {
  4171.      {1, 2},
  4172.      {3, 4},
  4173.      {5, 6}
  4174.    };
  4175.  
  4176. The initial values of matrix are: 
  4177.  
  4178. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  4179. Γöé ELEMENT      Γöé VALUE       Γöé ELEMENT      Γöé VALUE       Γöé
  4180. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  4181. Γöé "matrix[0][0]"   Γöé "1"        Γöé "matrix[1][2]"   Γöé "0"        Γöé
  4182. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  4183. Γöé "matrix[0][1]"   Γöé "2"        Γöé "matrix[1][3]"   Γöé "0"        Γöé
  4184. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  4185. Γöé "matrix[0][2]"   Γöé "0"        Γöé "matrix[2][0]"   Γöé "5"        Γöé
  4186. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  4187. Γöé "matrix[0][3]"   Γöé "0"        Γöé "matrix[2][1]"   Γöé "6"        Γöé
  4188. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  4189. Γöé "matrix[1][0]"   Γöé "3"        Γöé "matrix[2][2]"   Γöé "0"        Γöé
  4190. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  4191. Γöé "matrix[1][1]"   Γöé "4"        Γöé "matrix[2][3]"   Γöé "0"        Γöé
  4192. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  4193.  
  4194.  
  4195. ΓòÉΓòÉΓòÉ 5.7.6.2. Example Programs Using Arrays ΓòÉΓòÉΓòÉ
  4196.  
  4197. /************************************************************************
  4198. *
  4199.  
  4200. The following program defines a floating-point array called prices. 
  4201.  
  4202. The first for statement prints the values of the elements of prices. The second 
  4203. for statement adds five percent to the value of each element of prices, and 
  4204. assigns the result to total, and prints the value of total. 
  4205.  
  4206.                                                                         *
  4207. ************************************************************************/
  4208.  
  4209. /* Example of one-dimensional arrays. */
  4210.  
  4211. #include <stdio.h>
  4212.  
  4213. #define  ARR_SIZE  5
  4214.  
  4215. int main(void)
  4216. {
  4217.   static float const prices[ARR_SIZE] = { 1.41, 1.50, 3.75, 5.00, .86 };
  4218.   auto float total;
  4219.   int i;
  4220.  
  4221.   for (i = 0; i < ARR_SIZE; i++)
  4222.   {
  4223.     printf("price = $%.2f\n", prices[i]);
  4224.   }
  4225.  
  4226.   printf("\n");
  4227.  
  4228.   for (i = 0; i < ARR_SIZE; i++)
  4229.   {
  4230.     total = prices[i] * 1.05;
  4231.  
  4232.     printf("total = $%.2f\n", total);
  4233.   }
  4234. }
  4235.  
  4236. /************************************************************************
  4237. *
  4238.  
  4239. The preceding program produces the following output: 
  4240.  
  4241. price = $1.41
  4242. price = $1.50
  4243. price = $3.75
  4244. price = $5.00
  4245. price = $0.86
  4246.  
  4247. total = $1.48
  4248. total = $1.57
  4249. total = $3.94
  4250. total = $5.25
  4251. total = $0.90
  4252.  
  4253. The following program defines the multidimensional array salary_tbl.  A for 
  4254. loop prints the values of salary_tbl. 
  4255.  
  4256.                                                                         *
  4257. ************************************************************************/
  4258.  
  4259. /* example of a multidimensional array */
  4260.  
  4261. #include <stdio.h>
  4262.  
  4263. #define  NUM_ROW     3
  4264. #define  NUM_COLUMN  5
  4265.  
  4266. int main(void)
  4267. {
  4268.   static int salary_tbl[NUM_ROW][NUM_COLUMN] =
  4269.   {
  4270.     {  500,  550,  600,  650,  700   },
  4271.     {  600,  670,  740,  810,  880   },
  4272.     {  740,  840,  940, 1040, 1140   }
  4273.   };
  4274.   int grade , step;
  4275.  
  4276.   for (grade = 0; grade < NUM_ROW; ++grade)
  4277.    for (step = 0; step < NUM_COLUMN; ++step)
  4278.    {
  4279.      printf("salary_tbl[%d] [%d] = %d\n", grade, step,
  4280.                                         salary_tbl[grade] [step]);
  4281.    }
  4282. }
  4283.  
  4284. /************************************************************************
  4285. *
  4286.  
  4287. The preceding program produces the following output: 
  4288.  
  4289. salary_tbl[0] [0] = 500
  4290. salary_tbl[0] [1] = 550
  4291. salary_tbl[0] [2] = 600
  4292. salary_tbl[0] [3] = 650
  4293. salary_tbl[0] [4] = 700
  4294. salary_tbl[1] [0] = 600
  4295. salary_tbl[1] [1] = 670
  4296. salary_tbl[1] [2] = 740
  4297. salary_tbl[1] [3] = 810
  4298. salary_tbl[1] [4] = 880
  4299. salary_tbl[2] [0] = 740
  4300. salary_tbl[2] [1] = 840
  4301. salary_tbl[2] [2] = 940
  4302. salary_tbl[2] [3] = 1040
  4303. salary_tbl[2] [4] = 1140
  4304.  
  4305.                                                                         *
  4306. ************************************************************************/
  4307.  
  4308.  
  4309. ΓòÉΓòÉΓòÉ 5.7.7. Pointers ΓòÉΓòÉΓòÉ
  4310.  
  4311. A pointer type variable holds the address of a data object or a function. A 
  4312. pointer can refer to an object of any one data type except to a bit field or a 
  4313. reference.  Additionally, in C, a pointer cannot point to an object with the 
  4314. register storage class. Some common uses for pointers are: 
  4315.  
  4316. o To pass the address of a variable to a function. (You can also use a 
  4317.   reference to do this.) By referencing a variable through its address, a 
  4318.   function can change the contents of that variable. See Calling Functions and 
  4319.   Passing Arguments. 
  4320. o To access dynamic data structures such as linked lists, trees, and queues. 
  4321. o To access elements of an array or members of a structure or class. 
  4322. o To access an array of characters as a string. 
  4323.  
  4324. The following example declares pcoat as a pointer to an object having type 
  4325. long: 
  4326.  
  4327. extern long *pcoat;
  4328.  
  4329. If the keyword volatile appears before the *, the declarator describes a 
  4330. pointer to a volatile object.  If the keyword volatile comes between the * and 
  4331. the identifier, the declarator describes a volatile pointer. The keyword const 
  4332. operates in the same manner as the volatile keyword. 
  4333.  
  4334. Examples of Pointer Declarations 
  4335.  
  4336. Additional information is provided on: 
  4337.  
  4338. o Initializing Pointers 
  4339. o Restrictions 
  4340. o Using Pointers 
  4341. o Pointer Arithmetic 
  4342. o Example Program Using Pointers 
  4343.  
  4344. Related Information 
  4345.  
  4346. o Address  & 
  4347. o Indirection  * 
  4348. o _Seg16 Type Qualifier 
  4349. o References 
  4350. o Declarators 
  4351. o volatile and const Qualifiers 
  4352. o Initializers 
  4353.  
  4354.  
  4355. ΓòÉΓòÉΓòÉ <hidden> Examples of Pointer Declarations ΓòÉΓòÉΓòÉ
  4356.  
  4357. In the following example, pvolt is a constant pointer to an object having type 
  4358. short: 
  4359.  
  4360. short * const pvolt;
  4361.  
  4362. The following example declares pnut as a pointer to an int object having the 
  4363. volatile qualifier: 
  4364.  
  4365. extern int volatile *pnut;
  4366.  
  4367. The following example defines psoup as a volatile pointer to an object having 
  4368. type float: 
  4369.  
  4370. float * volatile psoup;
  4371.  
  4372. The following example defines pfowl as a pointer to an enumeration object of 
  4373. type bird: 
  4374.  
  4375. enum bird *pfowl;
  4376.  
  4377. The next example declares x as a pointer to a function that returns a char 
  4378. object: 
  4379.  
  4380. char (*x)(void);
  4381.  
  4382.  
  4383. ΓòÉΓòÉΓòÉ 5.7.7.1. Initializing Pointers ΓòÉΓòÉΓòÉ
  4384.  
  4385. When you use pointers in an assignment operation, you must ensure that the 
  4386. types of the pointers in the operation are compatible. 
  4387.  
  4388. The following example shows compatible declarations for the assignment 
  4389. operation: 
  4390.  
  4391.    float subtotal;
  4392.    float * sub_ptr;
  4393.          .
  4394.          .
  4395.          .
  4396.    sub_ptr = &subtotal;
  4397.    printf("The subtotal is %f\n", *sub_ptr);
  4398.  
  4399. The next example shows incompatible declarations for the assignment operation: 
  4400.  
  4401.    double league;
  4402.    int * minor;
  4403.          .
  4404.          .
  4405.          .
  4406.    minor = &league;     /* error */
  4407.  
  4408. The initializer is an = (equal sign) followed by the expression that represents 
  4409. the address that the pointer is to contain.  The following example defines the 
  4410. variables time and speed as having type double and amount as having type 
  4411. pointer to a double.  The pointer amount is initialized to point to total: 
  4412.  
  4413. double total, speed, *amount = &total;
  4414.  
  4415. The compiler converts an unsubscripted array name to a pointer to the first 
  4416. element in the array.  You can assign the address of the first element of an 
  4417. array to a pointer by specifying the name of the array.  The following two sets 
  4418. of definitions are equivalent.  Both define the pointer student and initialize 
  4419. student to the address of the first element in class: 
  4420.  
  4421. int class[80];
  4422. int *student = class;
  4423.  
  4424. is equivalent to: 
  4425.  
  4426. int class[80];
  4427. int *student = &class[0];
  4428.  
  4429. You can assign the address of the first character in a string constant to a 
  4430. pointer by specifying the string constant in the initializer. The following 
  4431. example defines the pointer variable string and the string constant "abcd". 
  4432. The pointer string is initialized to point to the character a in the string 
  4433. "abcd". 
  4434.  
  4435. char *string = "abcd";
  4436.  
  4437. The following example defines weekdays as an array of pointers to string 
  4438. constants.  Each element points to a different string.  The object weekdays[2], 
  4439. for example, points to the string "Tuesday". 
  4440.  
  4441. static char *weekdays[ ] =
  4442.             {
  4443.               "Sunday", "Monday", "Tuesday", "Wednesday",
  4444.               "Thursday", "Friday", "Saturday"
  4445.             };
  4446.  
  4447. A pointer can also be initialized to the integer constant 0. Such a pointer is 
  4448. a NULL pointer that does not point to any object. 
  4449.  
  4450.  
  4451. ΓòÉΓòÉΓòÉ 5.7.7.2. Restrictions ΓòÉΓòÉΓòÉ
  4452.  
  4453. You cannot use pointers to reference bit fields or objects having the register 
  4454. storage class specifier. 
  4455.  
  4456. A pointer to a packed structure or union is incompatible with a pointer to a 
  4457. corresponding nonpacked structure or union because packed and nonpacked objects 
  4458. have different memory layouts. As a result, comparisons and assignments between 
  4459. pointers to packed and nonpacked objects are not valid. 
  4460.  
  4461. You can, however, perform these assignments and comparisons with type casts. 
  4462. Consider the following example: 
  4463.  
  4464. int main(void)
  4465. {
  4466.    _Packed struct ss *ps1;
  4467.    struct ss         *ps2;
  4468.       .
  4469.       .
  4470.       .
  4471.    ps1 = (_Packed struct ss *)ps2;
  4472.       .
  4473.       .
  4474.       .
  4475. }
  4476.  
  4477. In the preceding example, the cast operation allows you to compare the two 
  4478. pointers, but you must be aware that ps1 still points to a nonpacked object. 
  4479. For the C/C++ Tools compiler, all pointers that are shared between 32-bit and 
  4480. 16-bit code must be declared with the _Seg16 type qualifier.  This includes 
  4481. pointers that are indirectly passed to 16-bit code, such as pointers in 
  4482. structures and pointers that are referenced by pointers directly passed to 
  4483. 16-bit code. For more information, see _Seg16 Type Qualifier and the chapter on 
  4484. "Calling Between 32-Bit adnd 16-Bit Code" in the Programming Guide. 
  4485.  
  4486.  
  4487. ΓòÉΓòÉΓòÉ 5.7.7.3. Using Pointers ΓòÉΓòÉΓòÉ
  4488.  
  4489. Two operators are commonly used in working with pointers, the & (address) 
  4490. operator and the * (indirection) operator. You can use the & operator to 
  4491. reference the address of an object. For example, the following statement 
  4492. assigns the address of x to the variable p_to_x.  The variable p_to_x has been 
  4493. defined as a pointer. 
  4494.  
  4495. int x, *p_to_x;
  4496.  
  4497. p_to_x = &x;
  4498.  
  4499. The * (indirection) operator enables you to access the value of the object to 
  4500. which a pointer refers. The following statement assigns to y the value of the 
  4501. object to which  p_to_x points: 
  4502.  
  4503. float y, *p_to_x;
  4504.   .
  4505.   .
  4506.   .
  4507. y = *p_to_x;
  4508.  
  4509. The following statement assigns the value of y to the variable that *p_to_x 
  4510. references: 
  4511.  
  4512. char y ,
  4513.      *p_to_x,
  4514.   .
  4515.   .
  4516.   .
  4517. *p_to_x = y;
  4518.  
  4519.  
  4520. ΓòÉΓòÉΓòÉ 5.7.7.4. Pointer Arithmetic ΓòÉΓòÉΓòÉ
  4521.  
  4522. You can perform a limited number of arithmetic operations on pointers.  These 
  4523. operations are: These operations are: 
  4524.  
  4525. o Increment and decrement 
  4526. o Addition and subtraction 
  4527. o Comparison 
  4528. o Assignment. 
  4529.  
  4530. The ++ (increment) operator increases the value of a pointer by the size of the 
  4531. data object to which the pointer refers.  For example, if the pointer refers to 
  4532. the second element in an array, the ++ makes the pointer refer to the third 
  4533. element in the array. 
  4534.  
  4535. The -- (decrement) operator decreases the value of a pointer by the size of the 
  4536. data object to which the pointer refers.  For example, if the pointer refers to 
  4537. the second element in an array, the -- makes the pointer refer to the first 
  4538. element in the array. 
  4539.  
  4540. If the pointer p points to the first element in an array, the following 
  4541. expression causes the pointer to point to the third element in the same array: 
  4542.  
  4543. p = p + 2;
  4544.  
  4545. If you have two pointers that point to the same array, you can subtract one 
  4546. pointer from the other.  This operation yields the number of elements in the 
  4547. array that separate the two addresses to which the pointers refer. 
  4548.  
  4549. You can compare two pointers with the following operators:  ==, !=, <, >, <=, 
  4550. and >=. See Expressions and Operators for more information on these operators. 
  4551.  
  4552. Pointer comparisons are defined only when the pointers point to elements of the 
  4553. same array. 
  4554.  
  4555. You can assign to a pointer the address of a data object, the value of another 
  4556. compatible pointer or the NULL pointer. 
  4557.  
  4558.  
  4559. ΓòÉΓòÉΓòÉ 5.7.7.5. Example Program Using Pointers ΓòÉΓòÉΓòÉ
  4560.  
  4561. /************************************************************************
  4562. *
  4563.  
  4564. The following program contains pointer arrays: 
  4565.  
  4566.                                                                         *
  4567. ************************************************************************/
  4568.  
  4569. /********************************************************************
  4570. **   Program to search for the first occurrence of a specified     **
  4571. **   character string in an array of character strings.            **
  4572. ********************************************************************/
  4573.  
  4574. #include <stdio.h>
  4575.  
  4576. #define  SIZE  20
  4577.  
  4578. int main(void)
  4579. {
  4580.    static char *names[ ] = { "Jim", "Amy", "Mark", "Sue", NULL };
  4581.    char * find_name(char **, char *);
  4582.    char new_name[SIZE], *name_pointer;
  4583.  
  4584.    printf("Enter name to be searched.\n");
  4585.    scanf("%s", new_name);
  4586.    name_pointer = find_name(names, new_name);
  4587.    printf("name %s%sfound\n", new_name,
  4588.           (name_pointer == NULL) ? " not " : " ");
  4589.    exit(EXIT_FAILURE);
  4590. } /* End of main */
  4591.  
  4592. /********************************************************************
  4593. **     Function find_name.  This function searches an array of     **
  4594. **     names to see if a given name already exists in the array.   **
  4595. **     It returns a pointer to the name or NULL if the name is     **
  4596. **     not found.                                                  **
  4597. ********************************************************************/
  4598.  
  4599. /* char **arry is a pointer to arrays of pointers (existing names) */
  4600. /* char *strng is a pointer to character array entered (new name)  */
  4601.  
  4602. char * find_name(char **arry, char *strng)
  4603. {
  4604.    for (; *arry != NULL; arry++)         /* for each name          */
  4605.    {
  4606.       if (strcmp(*arry, strng) == 0)     /* if strings match       */
  4607.          return(*arry);                  /* found it!              */
  4608.    }
  4609.    return(*arry);                        /* return the pointer     */
  4610. } /* End of find_name */
  4611.  
  4612. /************************************************************************
  4613. *
  4614. Interaction with the preceding program could produce the following sessions: 
  4615.  
  4616. Output 
  4617.           Enter name to be searched. 
  4618. Input 
  4619.           Mark 
  4620. Output 
  4621.           name Mark found 
  4622.  
  4623. or: 
  4624.  
  4625. Output 
  4626.           Enter name to be searched. 
  4627. Input 
  4628.           Bob 
  4629. Output 
  4630.           name Bob not found 
  4631.  
  4632.                                                                         *
  4633. ************************************************************************/
  4634.  
  4635.  
  4636. ΓòÉΓòÉΓòÉ 5.7.8. References ΓòÉΓòÉΓòÉ
  4637.  
  4638. A reference is an alias or an alternative name for an object. All operations 
  4639. applied to a reference act on the object to which the reference refers. The 
  4640. address of a reference is the address of the aliased object. 
  4641.  
  4642. A reference type is defined by placing the & after the type specifier. You must 
  4643. initialize a reference when it is defined. 
  4644.  
  4645. Because arguments are passed by value, a function call does not modify the 
  4646. actual values of the arguments. If a function needs to modify the actual value 
  4647. of an argument, the argument must be passed by reference (as opposed to being 
  4648. passed by value). Passing arguments by reference can be done using either 
  4649. references or pointers. In C++, this is accomplished transparently. Unlike C, 
  4650. C++ does not force you to use pointers if you want to pass arguments by 
  4651. reference. For example: 
  4652.  
  4653. int f(int&);
  4654. void main()
  4655. {
  4656.       extern int i;
  4657.       f(i);
  4658. }
  4659.  
  4660. You cannot tell from the function call f(i) that the argument is being passed 
  4661. by reference. 
  4662.  
  4663. NULL references are not allowed. 
  4664.  
  4665. Additional information is provided on Initializing References. 
  4666.  
  4667. Related Information 
  4668.  
  4669. o Passing Arguments by Reference 
  4670. o Pointers 
  4671. o Declarators 
  4672. o Initializers 
  4673.  
  4674.  
  4675. ΓòÉΓòÉΓòÉ 5.7.8.1. Initializing References ΓòÉΓòÉΓòÉ
  4676.  
  4677. The object that you use to initialize a reference must be of the same type as 
  4678. the reference, or it must be of a type that is convertible to the reference 
  4679. type. If you initialize a constant reference using an object that requires 
  4680. conversion, a temporary object is created. In the following example, a 
  4681. temporary object of type float is created: 
  4682.  
  4683. int i;
  4684. const float& f = i;
  4685.  
  4686. Attempting to initialize a nonconstant reference with an object that requires a 
  4687. conversion is an error. 
  4688.  
  4689. Once a reference has been initialized, it cannot be modified to refer to 
  4690. another object. For example: 
  4691.  
  4692. int num1 = 10;
  4693. int num2 = 20;
  4694.  
  4695. int &RefOne = num1;         // valid
  4696. int &RefOne = num2;         // error, two definitions of RefOne
  4697. RefOne = num2;              // assign num2 to num1
  4698. int &RefTwo;                // error, uninitialized reference
  4699. int &RefTwo = num2;         // valid
  4700.  
  4701. Note that the initialization of a reference is not the same as an assignment to 
  4702. a reference. Initialization operates on the actual reference by initializing 
  4703. the reference with the object it is an alias for. Assignment operates through 
  4704. the reference on the object referred to. 
  4705.  
  4706. A reference can be declared without an initializer: 
  4707.  
  4708. o When it is used in an argument declaration 
  4709. o In the declaration of a return type for a function call 
  4710. o In the declaration of class member within its class declaration 
  4711. o When the extern specifier is explicitly used 
  4712.  
  4713. You cannot have references to references, references to bit fields, arrays of 
  4714. references, or pointers to references. 
  4715.  
  4716.  
  4717. ΓòÉΓòÉΓòÉ 5.7.9. Structures ΓòÉΓòÉΓòÉ
  4718.  
  4719. A structure contains an ordered group of data objects.  Unlike the elements of 
  4720. an array, the data objects within a structure can have varied data types.  Each 
  4721. data object in a structure is a member or field. 
  4722.  
  4723. You can use structures to group logically related objects. For example, if you 
  4724. want to allocate storage for the components of one address, you can define a 
  4725. number of variables for the street name and number, the city, and so on. If you 
  4726. want to allocate storage for more than one address, however, you can group the 
  4727. components of each address by defining a structure data type and defining 
  4728. several variables having the structure data type: 
  4729.  
  4730.     1   struct address {
  4731.     2                    int street_no;
  4732.     3                    char *street_name;
  4733.     4                    char *city;
  4734.     5                    char *prov;
  4735.     6                    char *postal_code;
  4736.     7                  };
  4737.     8   struct address perm_address;
  4738.     9   struct address temp_address;
  4739.    10   struct address *p_perm_address = &perm_address;
  4740.  
  4741. Lines 1 through 7 declare the structure tag address.  Line 8 defines the 
  4742. variable perm_address, and line 9 defines the variable temp_address, both of 
  4743. which are instances of the structure address.  Both perm_address and 
  4744. temp_address contain the members described in lines 2 through 6. Line 10 
  4745. defines a pointer p_perm_address, which points to a structure of address. 
  4746. p_perm_address is initialized to point to perm_address. 
  4747.  
  4748. You can reference a member of a structure by specifying the structure variable 
  4749. name with the . (dot operator) or a pointer with the -> (arrow operator) and 
  4750. the member name.  For example, both of the following: 
  4751.  
  4752.  perm_address.prov = "Ontario";
  4753.  p_perm_address -> prov = "Ontario";
  4754.  
  4755. assign a pointer to the string "Ontario" to the pointer prov that is in the 
  4756. structure perm_address. 
  4757.  
  4758. All references to structures must be fully qualified.  Therefore, in the 
  4759. preceding example, you cannot reference the fourth field by prov alone.  You 
  4760. must reference this field by perm_address.prov. 
  4761.  
  4762. You cannot declare a structure with members of incomplete types. 
  4763.  
  4764. A structure type declaration does not allocate storage.  It describes the 
  4765. members that are part of the structure. 
  4766.  
  4767. A structure type declaration contains the struct keyword followed by an 
  4768. optional identifier (the structure tag) and a brace-enclosed list of members. 
  4769.  
  4770. Syntax of a Structure 
  4771.  
  4772. The keyword struct followed by the identifier (tag) names the data type.  If 
  4773. you do not provide a tag, you must place all variable definitions that refer to 
  4774. that data type within the statement that defines the data type. 
  4775.  
  4776. The list of members provides the data type with a description of the values 
  4777. that can be stored in the structure. 
  4778.  
  4779. A member that does not represent a bit field can be of any data type and can 
  4780. have the volatile or const qualifier. If a : (colon) and a constant expression 
  4781. follow the declarator, the member represents a bit field. 
  4782.  
  4783. Identifiers used as aggregate or member names can be redefined to represent 
  4784. different objects in the same scope without conflicting.  You cannot use the 
  4785. name of a member more than once in a structure type, but you can use the same 
  4786. member name in another structure type that is defined within the same scope. 
  4787.  
  4788. You cannot declare a structure type that contains itself as a member but you 
  4789. can declare a structure type that contains a pointer to itself as a member. 
  4790.  
  4791. A structure variable definition contains an optional storage class keyword, the 
  4792. struct keyword, a structure tag, a declarator, and an optional identifier.  The 
  4793. structure tag indicates the data type of the structure variable. 
  4794.  
  4795. You can declare structures having any storage class. 
  4796.  
  4797. Additional information is provided on: 
  4798.  
  4799. o Declaring Structure Types and Variables 
  4800. o Initializing Structures 
  4801. o Declaring and Using Bit Fields in Structures 
  4802. o Declaring a Packed Structure 
  4803. o Example Program Using Structures 
  4804.  
  4805. Related Information 
  4806.  
  4807. o Dot Operator 
  4808. o Arrow Operator 
  4809. o _Packed Qualifier 
  4810. o Declarators 
  4811. o Initializers 
  4812.  
  4813.  
  4814. ΓòÉΓòÉΓòÉ <hidden> Syntax of a Structure ΓòÉΓòÉΓòÉ
  4815.  
  4816. A structure declaration has the form: 
  4817.  
  4818. Γö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇstructΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇidentifierΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ
  4819.  Γöé      Γöé      Γöé          ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ   Γöé
  4820.  ΓööΓöÇΓöÇ_PackedΓöÇΓöÇΓöÿ      Γöé                Γöé   Γöé
  4821.              Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ{ΓöÇΓöÇΓöÇmemberΓöÇ;ΓöÇΓöÇΓö┤ΓöÇ}ΓöÇΓöÇΓöÿ
  4822.              Γöé        Γöé
  4823.              ΓööΓöÇΓöÇidentifierΓöÇΓöÇΓöÿ
  4824.  
  4825. A structure member has the form: 
  4826.  
  4827.           ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  4828.                                 Γöé
  4829. ΓöÇΓöÇtype_specifierΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇdeclaratorΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇ
  4830.           Γöé                     Γöé
  4831.           Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ:ΓöÇΓöÇconstant_expressionΓöÇΓöÿ
  4832.           Γöé        Γöé
  4833.           ΓööΓöÇΓöÇdeclaratorΓöÇΓöÇΓöÿ
  4834.  
  4835.  
  4836. ΓòÉΓòÉΓòÉ 5.7.9.1. Initializing Structures ΓòÉΓòÉΓòÉ
  4837.  
  4838. The initializer contains an = (equal sign) followed by a brace-enclosed 
  4839. comma-separated list of values.  You do not have to initialize all members of a 
  4840. structure. 
  4841.  
  4842. The following definition shows a completely initialized structure: 
  4843.  
  4844. struct address {
  4845.                  int street_no;
  4846.                  char *street_name;
  4847.                  char *city;
  4848.                  char *prov;
  4849.                  char *postal_code;
  4850.                };
  4851. static struct address perm_address =
  4852.                { 9876, "Goto St.", "Cville", "Ontario", "X9X 1A1"};
  4853.  
  4854. The values of perm_address are: 
  4855.  
  4856. Member              Value 
  4857. perm_address.street_no 9876 
  4858. perm_address.street_name address of string "Goto St." 
  4859. perm_address.city   address of string "Cville" 
  4860. perm_address.prov   address of string "Ontario" 
  4861. perm_address.postal_code address of string "X9X 1A1" 
  4862.  
  4863. The following definition shows a partially initialized structure: 
  4864.  
  4865. struct address {
  4866.                  int street_no;
  4867.                  char *street_name;
  4868.                  char *city;
  4869.                  char *prov;
  4870.                  char *postal_code;
  4871.                };
  4872. struct address temp_address =
  4873.                { 321, "Aggregate Ave.", "Structown", "Ontario" };
  4874.  
  4875. The values of temp_address are: 
  4876.  
  4877. Member                                  Value 
  4878. temp_address.street_no                  321 
  4879. temp_address.street_name                address of string "Aggregate Ave." 
  4880. temp_address.city                       address of string "Structown" 
  4881. temp_address.prov                       address of string "Ontario" 
  4882. temp_address.postal_code                value depends on the storage class. 
  4883.  
  4884. Note:  The initial value of uninitialized structure members like 
  4885. temp_address.postal_code depends on the storage class associated with the 
  4886. member.  See Storage Class Specifiers for details on the initialization of 
  4887. different storage classes. 
  4888.  
  4889.  
  4890. ΓòÉΓòÉΓòÉ 5.7.9.2. Declaring Structure Types and Variables ΓòÉΓòÉΓòÉ
  4891.  
  4892. You can place a type definition and a variable declaration in one statement by 
  4893. placing a declarator and an initializer (optional) after the type definition. 
  4894. If you want to specify a storage class specifier for the variable, you must 
  4895. place the storage class specifier at the beginning of the statement.  For 
  4896. example: 
  4897.  
  4898. static struct {
  4899.                  int street_no;
  4900.                  char *street_name;
  4901.                  char *city;
  4902.                  char *prov;
  4903.                  char *postal_code;
  4904.               } perm_address, temp_address;
  4905.  
  4906. The preceding example does not name the structure data type.  Thus, 
  4907. perm_address and temp_address are the only structure variables that will have 
  4908. this data type.  If an identifier is placed after struct, additional variable 
  4909. definitions of this data type can be made later in the program. 
  4910.  
  4911. The structure type (or tag) cannot have the volatile qualifier, but a member or 
  4912. a structure variable can be defined as having the volatile qualifier. For 
  4913. example: 
  4914.  
  4915. static struct class1 {
  4916.                         char descript[20];
  4917.                         volatile long code;
  4918.                         short complete;
  4919.                      } volatile file1, file2;
  4920. struct class1 subfile;
  4921.  
  4922. This example gives the volatile qualifier to the structures file1 and file2, 
  4923. and to the structure member subfile.code. 
  4924.  
  4925.  
  4926. ΓòÉΓòÉΓòÉ 5.7.9.3. Declaring and Using Bit Fields ΓòÉΓòÉΓòÉ
  4927.  
  4928. A structure can contain bit fields that allow you to access individual bits. 
  4929. You can use bit fields for data that requires just a few bits of storage.  A 
  4930. bit field declaration contains a type specifier followed by an optional 
  4931. declarator, a colon, a constant expression, and a semicolon.  The constant 
  4932. expression specifies how many bits the field reserves.  A bit field that is 
  4933. declared as having a length of 0 causes the next field to be aligned on the 
  4934. next integer boundary. For a _Packed structure, a bit field of length 0 causes 
  4935. the next field to be aligned on the next byte boundary. Bit fields with a 
  4936. length of 0 must be unnamed. 
  4937.  
  4938. For portability, do not use bit fields greater than 32 bits in size. 
  4939.  
  4940. You cannot define an array of bit fields, or take the address of a bit field. 
  4941. You can declare a bit field as type int, signed int, or unsigned int.  Bit 
  4942. fields of the type int are equivalent to those of type unsigned int. 
  4943.  
  4944. If a series of bit fields does not add up to the size of an int, padding can 
  4945. take place. The amount of padding is determined by the alignment 
  4946. characteristics of the members of the structure.  In some instances, bit fields 
  4947. can cross word boundaries. 
  4948.  
  4949. The following example declares the identifier kitchen to be of type struct 
  4950. on_off: 
  4951.  
  4952. struct on_off {
  4953.                   unsigned light : 1;
  4954.                   unsigned toaster : 1;
  4955.                   int count;
  4956.                   unsigned ac : 4;
  4957.                   unsigned : 4;
  4958.                   unsigned clock : 1;
  4959.                   unsigned : 0;
  4960.                   unsigned flag : 1;
  4961.                  } kitchen ;
  4962.  
  4963. The structure kitchen contains eight members.  The following table describes 
  4964. the storage that each member occupies: 
  4965.  
  4966. Member Name              Storage Occupied 
  4967. light                    1 bit 
  4968. toaster                  1 bit, and padding to next int boundary (unnamed 
  4969.                          field) 
  4970. count                    The size of an int 
  4971. ac                       4 bits 
  4972.                          4 bits (unnamed field) 
  4973. clock                    1 bit padding to next int boundary (unnamed field) 
  4974. flag                     1 bit 
  4975.  
  4976. All references to structure fields must be fully qualified. Therefore, you 
  4977. cannot reference the second field by toaster.  You must reference this field by 
  4978. kitchen.toaster. 
  4979.  
  4980. The following expression sets the light field to 1: 
  4981.  
  4982. kitchen.light = 1;
  4983.  
  4984. When you assign to a bit field a value that is out of its range, the bit 
  4985. pattern is preserved and the appropriate bits are assigned. The following 
  4986. expression sets the toaster field of the kitchen structure to 0 because only 
  4987. the least significant bit is assigned to the toaster field: 
  4988.  
  4989. kitchen.toaster = 2;
  4990.  
  4991.  
  4992. ΓòÉΓòÉΓòÉ 5.7.9.4. Declaring a Packed Structure ΓòÉΓòÉΓòÉ
  4993.  
  4994. Data elements of a structure are stored in memory on an address boundary 
  4995. specific for that data type.  For example, a double value is stored in memory 
  4996. on a doubleword (8-byte) boundary. Gaps may be left in memory between elements 
  4997. of a structure to align elements on their natural boundaries.  You can reduce 
  4998. the padding of bytes within a structure by using the _Packed qualifier on the 
  4999. structure declaration. 
  5000.  
  5001. C++ Consideration:  C++ does not support the _Packed qualifier.  To change the 
  5002. alignment of structures, use the #pragma pack directive or the /Sp compiler 
  5003. option.  Both of these methods are also supported by C. 
  5004.  
  5005.  
  5006. ΓòÉΓòÉΓòÉ 5.7.9.5. Example Program Using Structures ΓòÉΓòÉΓòÉ
  5007.  
  5008. /************************************************************************
  5009. *
  5010.  
  5011. The following program finds the sum of the integer numbers in a linked list: 
  5012.  
  5013.                                                                         *
  5014. ************************************************************************/
  5015.  
  5016. /* program to illustrate linked lists */
  5017. #include <stdio.h>
  5018.  
  5019. struct record {
  5020.                 int number;
  5021.                 struct record *next_num;
  5022.               };
  5023.  
  5024. int main(void)
  5025. {
  5026.    struct  record name1, name2, name3;
  5027.    struct  record *recd_pointer = &name1;
  5028.    int sum = 0;
  5029.  
  5030.    name1.number = 144;
  5031.    name2.number = 203;
  5032.    name3.number = 488;
  5033.  
  5034.    name1.next_num = &name2;
  5035.    name2.next_num = &name3;
  5036.    name3.next_num = NULL;
  5037.  
  5038.    while (recd_pointer != NULL)
  5039.    {
  5040.       sum += recd_pointer->number;
  5041.       recd_pointer = recd_pointer->next_num;
  5042.    }
  5043.    printf("Sum = %d\n", sum);
  5044. }
  5045.  
  5046. /************************************************************************
  5047. *
  5048.  
  5049. The structure type record contains two members:  number (an integer) and 
  5050. next_num (a pointer to a structure variable of type record). 
  5051.  
  5052. The record type variables name1, name2, and name3 are assigned the following 
  5053. values: 
  5054.  
  5055. Member Name                   Value 
  5056. name1.number                  144 
  5057. name1.next_num                The address of name2 
  5058.  
  5059. name2.number                  203 
  5060. name2.next_num                The address of name3 
  5061.  
  5062. name3.number                  488 
  5063. name3.next_num                NULL (Indicating the end of the linked list.) 
  5064.  
  5065. The variable recd_pointer is a pointer to a structure of type record. 
  5066. recd_pointer is initialized to the address of name1 (the beginning of the 
  5067. linked list). 
  5068.  
  5069. The while loop causes the linked list to be scanned until recd_pointer equals 
  5070. NULL.  The statement: 
  5071.  
  5072. recd_pointer = recd_pointer->next_num;
  5073.  
  5074. advances the pointer to the next object in the list. 
  5075.  
  5076.                                                                                   *
  5077. ***********************************************************************************/
  5078.  
  5079.  
  5080. ΓòÉΓòÉΓòÉ 5.7.10. Unions ΓòÉΓòÉΓòÉ
  5081.  
  5082. A union is an object that can hold any one of a set of named members. The 
  5083. members of the named set can be of any data type. Members are overlaid in 
  5084. storage. 
  5085.  
  5086. The storage allocated for a union is the storage required for the largest 
  5087. member of the union (plus any padding that is required so that the union will 
  5088. end at a natural boundary of its strictest member). 
  5089.  
  5090. A union type declaration contains the union keyword followed by an identifier 
  5091. (optional) and a brace-enclosed list of members. 
  5092.  
  5093. Syntax of a Union 
  5094.  
  5095. The identifier is a tag given to the union specified by the member list.  If 
  5096. you specify a tag, any subsequent declaration of the union (in the same scope) 
  5097. can be made by declaring the tag and omitting the member list.  If you do not 
  5098. specify a tag, you must place all variable definitions that refer to that union 
  5099. within the statement that defines the data type. 
  5100.  
  5101. The list of members provides the data type with a description of the objects 
  5102. that can be stored in the union. 
  5103.  
  5104. A union can have member functions, including constructors and destructors, but 
  5105. not virtual member functions. A union cannot be used as a base class and cannot 
  5106. be derived from a base class. 
  5107.  
  5108. A union member cannot be a class object that has a constructor, destructor, or 
  5109. overloaded copy assignment operator. In C++, a member of a union cannot be 
  5110. declared with the keyword static. 
  5111.  
  5112. You can reference one of the possible members of a union as you reference a 
  5113. member of a structure.  For example: 
  5114.  
  5115. union {
  5116.       char birthday[9];
  5117.       int sex:1;  /*  0 = male; 1 = female  */
  5118.       float weight;
  5119.       } people;
  5120.  
  5121. people.birthday[0] = '\n';
  5122.  
  5123. assigns '\n' to the first element in the character array birthday, a member of 
  5124. the union people.  At any given time, a union can represent only one of its 
  5125. members.  In the preceding example, the union people will contain either sex, 
  5126. birthday, or weight but never more than one of these. For example, the 
  5127. following is not allowed: 
  5128.  
  5129. 1  people.birthday = "25/10/67";
  5130. 2  people.sex = 1;
  5131. 3  printf("%d\n", people.weight);
  5132.  
  5133. Both lines 2 and 3 are not allowed because in line 1, people.birthday is 
  5134. assigned a value. 
  5135.  
  5136. Examples of Unions 
  5137.  
  5138. Additional information is provided on: 
  5139.  
  5140. o Defining a Union Variable 
  5141. o Defining a Packed Union 
  5142. o Anonymous Unions in C 
  5143. o Anonymous Unions in C++ 
  5144.  
  5145. Related Information 
  5146.  
  5147. o Dot Operator 
  5148. o Arrow Operator 
  5149. o _Packed Qualifier 
  5150. o Declarators 
  5151. o Initializers 
  5152.  
  5153.  
  5154. ΓòÉΓòÉΓòÉ <hidden> Syntax of a Union ΓòÉΓòÉΓòÉ
  5155.  
  5156. The following diagram shows the form of a union type declaration: 
  5157.  
  5158.                        ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  5159.                               Γöé
  5160. >>ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇunionΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ{ΓöÇΓöÇΓöÇΓöÇmemberΓöÇΓöÇ???ΓöÇΓö┤ΓöÇΓöÇ}ΓöÇΓöÇ><
  5161.   ΓööΓöÇqualifierΓöÇΓöÿ     ΓööΓöÇidentifierΓöÇΓöÿ
  5162.  
  5163. A member has the form: 
  5164.  
  5165.           ΓöîΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  5166.                                  Γöé
  5167. >>ΓöÇΓöÇtype_specifierΓöÇΓöÇΓöÇΓö¼ΓöÇdeclaratorΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇΓöÇ><
  5168.            ΓööΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ???ΓöÇΓöÇconstant_expressionΓöÇΓöÿ
  5169.             ΓööΓöÇdeclaratorΓöÇΓöÿ
  5170.  
  5171.  
  5172. ΓòÉΓòÉΓòÉ 5.7.10.1. Defining a Union Variable ΓòÉΓòÉΓòÉ
  5173.  
  5174. A union variable definition contains an optional storage class keyword, the 
  5175. union keyword, a union tag, and a declarator.  The union tag indicates the data 
  5176. type of the union variable. 
  5177.  
  5178. The type specifier contains the keyword union followed by the name of the union 
  5179. type.  You must declare the union data type before you can define a union 
  5180. having that type. 
  5181.  
  5182. You can define a union data type and a union of that type in the same statement 
  5183. by placing the variable declarator after the data type definition. 
  5184.  
  5185. The declarator is an identifier, possibly with the volatile or const qualifier. 
  5186.  
  5187. You can only initialize the first member of a union. 
  5188.  
  5189. The following example shows how you would initialize the first union member 
  5190. birthday of the union variable people: 
  5191.  
  5192. union {
  5193.       char birthday[9];
  5194.       int age;
  5195.       float weight;
  5196.       } people = {"04/06/57"};
  5197.  
  5198. You can place a type definition and a variable definition in one statement by 
  5199. placing a declarator after the type definition.  If you want to specify a 
  5200. storage class specifier for the variable, you must place the storage class 
  5201. specifier at the beginning of the statement. 
  5202.  
  5203.  
  5204. ΓòÉΓòÉΓòÉ 5.7.10.2. Defining a Packed Union ΓòÉΓòÉΓòÉ
  5205.  
  5206. You can use _Packed to qualify a union.  However, the memory layout of the 
  5207. union members is not affected.  Each member starts at offset zero.  The _Packed 
  5208. qualifier does affect the total alignment restriction of the whole union. 
  5209.  
  5210. C++ Consideration:  C++ does not support the _Packed qualifier. To change the 
  5211. alignment of unions, use the #pragma pack directive or the /Sp compiler option. 
  5212. Both of these methods are also supported by C. 
  5213.  
  5214. Consider the following example: 
  5215.  
  5216.           union uu {
  5217.             short    a;
  5218.             struct {
  5219.               char x;
  5220.               char y;
  5221.               char z;
  5222.             } b;
  5223.           };
  5224.  
  5225.           union uu           n_array[2];
  5226.           _Packed union uu   p_array[2];
  5227.  
  5228. Each of the elements in the nonpacked n_array is of type union uu.  Because it 
  5229. is nonpacked, each element has an alignment restriction of 2 bytes (the largest 
  5230. alignment requirement among the union members is that of short a), and there is 
  5231. 1 byte of padding at the end of each element to enforce this requirement. 
  5232.  
  5233. Now consider the packed array p_array.  Because each of its elements is of type 
  5234. _Packed union uu, the alignment restriction of every element is the byte 
  5235. boundary.  Therefore, each element has a length of only 3 bytes, instead of the 
  5236. 4 bytes in the previous example. 
  5237.  
  5238.  
  5239. ΓòÉΓòÉΓòÉ 5.7.10.3. Anonymous Unions in C ΓòÉΓòÉΓòÉ
  5240.  
  5241. The C/C++ Tools compiler allows unions to be declared without declarators if 
  5242. they are members of another structure or union. Unions without declarators are 
  5243. called anonymous unions. 
  5244.  
  5245. Members of an anonymous union can be accessed as if they were declared directly 
  5246. in the containing structure or union. For example, given the following 
  5247. structure: 
  5248.  
  5249.    struct s {
  5250.       int a;
  5251.       union {
  5252.         int b;
  5253.         float c;
  5254.       };        /* no declarator */
  5255.    } kurt;
  5256. you can make the following statements: 
  5257.  
  5258.    kurt.a = 5;
  5259.    kurt.b = 36;
  5260.  
  5261. You can also declare an anonymous union: 
  5262.  
  5263.  1. By creating a typedef and using the typedef name without a declarator: 
  5264.  
  5265.            typedef union {
  5266.               int a;
  5267.               int b;
  5268.            }  UNION_T;
  5269.  
  5270.            struct s1 {
  5271.               UNION_T;
  5272.               int c;
  5273.            } dave;
  5274.  
  5275.  2. By using an existing union tag without a declarator: 
  5276.  
  5277.            union u1 {
  5278.               int a;
  5279.               int b;
  5280.            };
  5281.  
  5282.            struct s1 {
  5283.               union u1;
  5284.               int c;
  5285.            } dave;
  5286.  
  5287. In both of the preceding examples, the members can be accessed as dave.a, 
  5288. dave.b, and dave.c. 
  5289.  
  5290. An anonymous union must be a member of, or nested within another anonymous 
  5291. union that is a member of, a named structure or union. If a union is declared 
  5292. at file scope without a declarator, its members are not available to the 
  5293. surrounding scope. For example, the following union only declares the union tag 
  5294. tom: 
  5295.  
  5296.    union tom {
  5297.       int b;
  5298.       float c;
  5299.    };
  5300. The variables b and c from this union cannot be used at file scope, and the 
  5301. following statements will generate errors: 
  5302.  
  5303.    b = 5;
  5304.    c = 2.5;
  5305.  
  5306. C++ Consideration:  Anonymous unions are treated differently in C++. See 
  5307. Anonymous Unions in C++ for more information. 
  5308.  
  5309.  
  5310. ΓòÉΓòÉΓòÉ 5.7.10.4. Anonymous Unions in C++ ΓòÉΓòÉΓòÉ
  5311.  
  5312. An anonymous union is a union without a class name. It cannot be followed by a 
  5313. declarator. An anonymous union is not a type; it defines an unnamed object and 
  5314. it cannot have member functions. 
  5315.  
  5316. The member names of an anonymous union must be distinct from other names within 
  5317. the scope in which the union is declared. You can use member names directly in 
  5318. the union scope without any additional member access syntax. For example, in 
  5319. the following code fragment, you can access the data members i and cptr 
  5320. directly because they are in the scope containing the anonymous union. Because 
  5321. i and cptr are union members and have the same address, you should only use one 
  5322. of them at a time. The assignment to the member cptr will change the value of 
  5323. the member i. 
  5324.  
  5325. void f()
  5326. {
  5327. union { int i; char* cptr ; };
  5328. //      .
  5329. //      .
  5330. //      .
  5331. i = 5;
  5332. cptr = "string_in_union"; // overrides i
  5333. }
  5334.  
  5335. An anonymous union cannot have protected or private members. A global anonymous 
  5336. union must be declared with the keyword static. 
  5337.  
  5338.  
  5339. ΓòÉΓòÉΓòÉ <hidden> Examples of Unions ΓòÉΓòÉΓòÉ
  5340.  
  5341. The following example defines a union data type (not named) and a union 
  5342. variable (named length).  The member of length can be a long int, a float, or a 
  5343. double. 
  5344.  
  5345. union {
  5346.         float meters;
  5347.         double centimeters;
  5348.         long inches;
  5349.       } length;
  5350.  
  5351. The following example defines the union type data as containing one member. 
  5352. The member can be named charctr, whole, or real.  The second statement defines 
  5353. two data type variables:  input and output. 
  5354.  
  5355. union data {
  5356.              char charctr;
  5357.              int whole;
  5358.              float real;
  5359.            };
  5360. union data input, output;
  5361.  
  5362. The following statement assigns a character to input: 
  5363.  
  5364. input.charctr = 'h';
  5365.  
  5366. The following statement assigns a floating-point number to member output: 
  5367.  
  5368. output.real = 9.2;
  5369.  
  5370. The following example defines an array of structures named records.  Each 
  5371. element of records contains three members:  the integer id_num, the integer 
  5372. type_of_input, and the union variable input.  input has the union data type 
  5373. defined in the previous example. 
  5374.  
  5375. struct {
  5376.          int id_num;
  5377.          int type_of_input;
  5378.          union data input;
  5379.        } records[10];
  5380.  
  5381. The following statement assigns a character to the structure member input of 
  5382. the first element of records: 
  5383.  
  5384. records[0].input.charctr = 'g';
  5385.  
  5386.  
  5387. ΓòÉΓòÉΓòÉ 5.7.11. typedef ΓòÉΓòÉΓòÉ
  5388.  
  5389. typedef declarations allow you to define your own identifiers that can be used 
  5390. in place of type specifiers such as int, float, and double. The data types you 
  5391. define using typedef are not new data types.  The identifiers you define are 
  5392. synonyms for the primary data types used by the C language or data types 
  5393. derived by combining the primary data types. 
  5394.  
  5395. Syntax of a typedef Declaration 
  5396.  
  5397. A typedef declaration does not reserve storage. 
  5398.  
  5399. When an object is defined using a typedef identifier, the properties of the 
  5400. defined object are exactly the same as if the object were defined by explicitly 
  5401. listing the data type associated with the identifier. 
  5402.  
  5403. The following statements declare LENGTH as a synonym for int and then use this 
  5404. typedef to declare length, width, and height as integral variables: 
  5405.  
  5406. typedef int LENGTH;
  5407. LENGTH length, width, height;
  5408.  
  5409. The preceding lines are equivalent to the following: 
  5410.  
  5411. int length, width, height;
  5412.  
  5413. Similarly, typedef can be used to define a class type (class, structure, or 
  5414. union). For example: 
  5415.  
  5416. typedef struct {
  5417.                 int kilos;
  5418.                 int grams;
  5419.                } WEIGHT;
  5420.  
  5421. The structure WEIGHT can then be used in the following declarations: 
  5422.  
  5423. WEIGHT  chicken, cow, horse, whale;
  5424.  
  5425. A class defined in a typedef without being names is given a dummy name and the 
  5426. typedef name for linkage.  Such a class cannot have constructors or 
  5427. destructors.  For example: 
  5428.  
  5429. typedef class {
  5430.                Trees();
  5431.               } Trees;
  5432.  
  5433. Here the function Trees() is an ordinary member function of a class whose type 
  5434. name is unspecified.  In the above example, Trees is an alias for the unnamed 
  5435. class, not the class type name itself, so Trees() cannot be a constructor for 
  5436. that class. 
  5437.  
  5438. Related Information 
  5439.  
  5440. o Characters 
  5441. o Floating-Point Variables 
  5442. o Integers 
  5443. o void Type 
  5444. o Arrays 
  5445. o Enumerations 
  5446. o Pointers 
  5447. o Structures 
  5448. o Unions 
  5449. o C++ Classes 
  5450. o Constructors and Destructors Overview 
  5451.  
  5452.  
  5453. ΓòÉΓòÉΓòÉ <hidden> Syntax of a typedef Declaration ΓòÉΓòÉΓòÉ
  5454.  
  5455. The syntax of a typedef declaration is: 
  5456.  
  5457. >>ΓöÇΓöÇtypedefΓöÇΓöÇtype_specifierΓöÇΓöÇidentifierΓöÇΓöÇ???ΓöÇΓöÇ><
  5458.  
  5459.  
  5460. ΓòÉΓòÉΓòÉ 6. Functions ΓòÉΓòÉΓòÉ
  5461.  
  5462. Functions specify the logical structure of a program and define how particular 
  5463. operations are to be implemented. A function declaration consists of a return 
  5464. type, a name, and an argument list. It is used to declare the format and 
  5465. existence of a function prior to its use. 
  5466.  
  5467. Both C++ and ANSI C use the style of declaration called prototyping. C++ 
  5468. functions in particular must have a prototype. A prototype refers to the return 
  5469. type, name, and argument list components of a function. It is used by the 
  5470. compiler for argument type checking and argument conversions. Prototypes can 
  5471. appear several times in a program, provided the declarations are compatible. A 
  5472. function definition contains a function declaration and the body of the 
  5473. function. A function can only have one definition. Function prototypes are 
  5474. usually placed in header files, while function definitions appear in source 
  5475. files. This section describes the structure and usage of functions. 
  5476.  
  5477. o C++ Enhancements to C Functions 
  5478. o main 
  5479. o Function Definition 
  5480. o Function Declarations 
  5481. o Calling Functions and Passing Arguments 
  5482. o Default Arguments 
  5483. o Inline Functions 
  5484.  
  5485.  
  5486. ΓòÉΓòÉΓòÉ 6.1. C++ Enhancements to C Functions ΓòÉΓòÉΓòÉ
  5487.  
  5488. The C++ language provides many enhancements to C functions. These are: 
  5489.  
  5490. o Reference arguments 
  5491. o Default arguments 
  5492. o Reference return types 
  5493. o Member functions 
  5494. o Overloaded functions 
  5495. o Operator functions 
  5496. o Constructor and destructor functions 
  5497. o Conversion functions 
  5498. o Virtual functions 
  5499. o Function templates 
  5500.  
  5501.  
  5502. ΓòÉΓòÉΓòÉ 6.2. main ΓòÉΓòÉΓòÉ
  5503.  
  5504. When you begin the execution of a program, the system automatically calls the 
  5505. function main.  Every program must have one function named main, with the name 
  5506. main written in lowercase letters. 
  5507.  
  5508. Syntax of the main Function 
  5509.  
  5510. By default, main has the storage class extern and a return type of int.  It can 
  5511. also be declared to return void. 
  5512.  
  5513. You cannot use the inline or static specifiers when declaring main.  You cannot 
  5514. call main from within a program or take the address of main. 
  5515.  
  5516. The function main can declare either none or two parameters. The C/C++ Tools 
  5517. compiler also supports an optional third parameter. Although any name can be 
  5518. given to these parameters, they are usually referred to as argc and argv. The 
  5519. third parameter is referred to as envp. The first parameter, argc (argument 
  5520. count), has type int and indicates how many arguments were entered on the 
  5521. command line.  The second parameter, argv (argument vector), has type array of 
  5522. pointers to char array objects.  char array objects are null-terminated 
  5523. strings. 
  5524.  
  5525. The third parameter, envp, is a pointer to an array of char pointers to the 
  5526. environment strings.  A NULL pointer terminates the array.  You can use the 
  5527. pointer to the array to access the value of the environment settings. The envp 
  5528. parameter is optional, but to declare it, you must also declare the first two 
  5529. parameters. 
  5530.  
  5531. Note:  The envp parameter is not available when you are using the subsystem 
  5532. libraries. 
  5533.  
  5534. The value of argc indicates the number of pointers in the array argv.  If a 
  5535. program name is available, the first element in argv points to a character 
  5536. array that contains the program name or the invocation name of the program that 
  5537. is being executed.  If the name cannot be determined, the first element in argv 
  5538. points to a null character.  This name is counted as one of the arguments to 
  5539. the function main.  For example, if only the program name is entered on the 
  5540. command line, argc has a value of 1 and argv[0] points to the program name. 
  5541.  
  5542. Regardless of the number of arguments entered on the command line, argv[argc] 
  5543. always contains NULL. 
  5544.  
  5545. Example of Arguments to main 
  5546.  
  5547. Related Information 
  5548.  
  5549. o Function Definition 
  5550. o Calling Functions and Passing Arguments 
  5551. o Types 
  5552. o Identifiers 
  5553. o Block 
  5554.  
  5555.  
  5556. ΓòÉΓòÉΓòÉ <hidden> Syntax of the main Function ΓòÉΓòÉΓòÉ
  5557.  
  5558. The main function has the form: 
  5559.  
  5560. >>ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇmainΓöÇΓöÇ(ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ>
  5561.   ΓööΓöÇintΓöÇΓöÿ      Γö£ΓöÇvoidΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  5562.            ΓööΓöÇintΓöÇΓöÇargcΓöÇΓöÇ,ΓöÇΓöÇchar *ΓöÇΓöÇargv[]ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÿ
  5563.                            ΓööΓöÇchar *ΓöÇΓöÇenvp[]ΓöÇΓöÿ
  5564. >ΓöÇΓöÇ)ΓöÇΓöÇblock_statementΓöÇΓöÇ><
  5565.  
  5566.  
  5567. ΓòÉΓòÉΓòÉ <hidden> Example of Arguments to main ΓòÉΓòÉΓòÉ
  5568.  
  5569. /************************************************************************
  5570. *
  5571.  
  5572. The following program backward prints the arguments entered on a command line 
  5573. such that the last argument is printed first: 
  5574.  
  5575.                                                                         *
  5576. ************************************************************************/
  5577.  
  5578. #include <stdio.h>
  5579. int main(int argc, char *argv[])
  5580. {
  5581.   while (--argc > 0)
  5582.     printf("%s ", argv[argc]);
  5583. }
  5584.  
  5585. /************************************************************************
  5586. *
  5587.  
  5588. If you invoke this program from a command line with the following: 
  5589.  
  5590.    backward string1 string2
  5591.  
  5592. The output generated is: 
  5593.  
  5594.    string2 string1
  5595.  
  5596. The arguments argc and argv would contain the following values: 
  5597.  
  5598. Object              Value 
  5599. argc                3 
  5600. argv[0]             pointer to string "backward" 
  5601. argv[1]             pointer to string "string1" 
  5602. argv[2]             pointer to string "string2" 
  5603. argv[3]             NULL 
  5604.  
  5605.                                                                         *
  5606. ************************************************************************/
  5607.  
  5608.  
  5609. ΓòÉΓòÉΓòÉ 6.3. Function Declarations ΓòÉΓòÉΓòÉ
  5610.  
  5611. A function declaration establishes the name and the parameters of the function. 
  5612.  
  5613. Syntax of a Function Declaration 
  5614.  
  5615. A function is declared implicitly by its appearance in an expression if it has 
  5616. not been defined or declared previously;  the implicit declaration is 
  5617. equivalent to a declaration of extern int func_name(). 
  5618.  
  5619. If the called function returns a value that has a type other than int, you must 
  5620. declare the function before the function call.  Even if a called function 
  5621. returns a type int, explicitly declaring the function prior to its call is good 
  5622. programming practice. 
  5623.  
  5624. In C++, you can specify the qualifiers volatile and const in member function 
  5625. declarations. You can also specify exception specifications in function 
  5626. declarations. Functions must be declared before they can be called. 
  5627.  
  5628. Types cannot be defined in return or argument types. For example, the following 
  5629. declarations are not valid in C++: 
  5630.  
  5631. void print(struct X { int i; } x);           //error
  5632. enum count{one, two, three} counter();       //error
  5633.  
  5634. This example attempts to declare a function print() that takes an object x of 
  5635. class X as its argument. However, the class definition is not allowed within 
  5636. the argument list. In the attempt to declare counter(), the enumeration type 
  5637. definition cannot appear in the return type of the function declaration. The 
  5638. two function declarations and their corresponding type definitions can be 
  5639. rewritten as follows: 
  5640.  
  5641. struct X { int i; };
  5642. void print(X x);
  5643. enum count {one, two, three};
  5644. count counter();
  5645.  
  5646. An ellipsis at the end of an argument declaration indicates that the number of 
  5647. arguments is equal to, or greater than, the number of specified argument types. 
  5648. Where it is permitted, an ellipsis preceded by a comma is equivalent to a 
  5649. simple ellipsis. 
  5650.  
  5651. An empty argument declaration list or the argument declaration list of (void) 
  5652. indicates a function that takes no arguments. void cannot be used as an 
  5653. argument type, although types derived from void (such as pointers to void) can 
  5654. be used. 
  5655.  
  5656. All function declarations for a particular function must have the same number 
  5657. and type of arguments, and must have the same return type and the same linkage 
  5658. keywords. These return and argument types are part of the function type, 
  5659. although the default arguments are not. For the purposes of argument matching, 
  5660. ellipsis and linkage keywords are considered a part of the function type. They 
  5661. must be used consistently in all declarations of a function. If the only 
  5662. difference between the argument types in two declarations is in the use of 
  5663. typedef names or unspecified argument array bounds, the declarations are the 
  5664. same. A const or volatile specifier is also part of the function type, but can 
  5665. only be part of a declaration or definition of a nonstatic member function. 
  5666.  
  5667. Declaring two functions differing only in return type is not valid function 
  5668. overloading, and is flagged as an error. For example: 
  5669.  
  5670. void f();
  5671. int f();      // error, two definitions differ only in
  5672.               // return type
  5673. int g()
  5674. {
  5675.    return f();
  5676. }
  5677.  
  5678. Some declarations do not have parameter lists; the declarations simply specify 
  5679. the types of parameters and the return values, such as in the following 
  5680. example: 
  5681.  
  5682.    int func(int,long);
  5683.  
  5684. You can supply argument names in a function declaration, but the compiler 
  5685. ignores them except in the following two situations: 
  5686.  
  5687.  1. If two argument names have the same name within a single declaration. This 
  5688.     is an error. 
  5689.  
  5690.  2. If an argument name is the same as a name outside the function. In this 
  5691.     case the name outside the function is hidden and cannot be used in the 
  5692.     argument declaration. 
  5693.  
  5694. In the following example, the third argument intersects is meant to have 
  5695. enumeration type subway_line, but this name is hidden by the name of the first 
  5696. argument. The declaration of the function subway() causes a compile-time error 
  5697. because subway_line is not a valid type name in the context of the argument 
  5698. declarations. 
  5699.  
  5700. enum subway_line {yonge, university, spadina, bloor};
  5701. int subway(char * subway_line, int stations,
  5702.                   subway_line intersects);
  5703.  
  5704. Examples of Function Declarations 
  5705.  
  5706. Examples of Function Declarations and Definitions 
  5707.  
  5708. Related Information 
  5709.  
  5710. o Function Declarator 
  5711. o Function Definition 
  5712. o Calling Functions and Passing Arguments 
  5713. o extern Storage Class Specifier 
  5714.  
  5715.  
  5716. ΓòÉΓòÉΓòÉ <hidden> Syntax of a Function Declaration ΓòÉΓòÉΓòÉ
  5717.  
  5718. A function declaration has the form: 
  5719.  
  5720.                               ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  5721.                                      Γöé
  5722. >>ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇfunction_declaratorΓöÇΓöÇ(ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇΓöÇ>
  5723.   Γö£ΓöÇexternΓöÇΓöñ  ΓööΓöÇtype_specifierΓöÇΓöÿ              ΓööΓöÇparameterΓöÇΓöÿ
  5724.   ΓööΓöÇstaticΓöÇΓöÿ
  5725. >ΓöÇΓöÇ)ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ><
  5726.    Γö£ΓöÇconstΓöÇΓöÇΓöÇΓöÇΓöñ
  5727.    ΓööΓöÇvolatileΓöÇΓöÿ
  5728.  
  5729. The use of the const and volatile specifiers is only supported by C++. 
  5730.  
  5731.  
  5732. ΓòÉΓòÉΓòÉ <hidden> Examples of Function Declarations and Definitions ΓòÉΓòÉΓòÉ
  5733.  
  5734. /************************************************************************
  5735. *
  5736.  
  5737. The following example defines the function absolute with the return type 
  5738. double. Because this is a noninteger return type, absolute is declared prior to 
  5739. the function call. 
  5740.  
  5741.                                                                         *
  5742. ************************************************************************/
  5743.  
  5744. #include <stdio.h>
  5745.  
  5746. double absolute(double);
  5747.  
  5748. int main(void)
  5749. {
  5750.    double f = -3.0;
  5751.  
  5752.    printf("absolute number = %lf\n", absolute(f));
  5753. }
  5754.  
  5755. double absolute(double number)
  5756. {
  5757.    if (number < 0.0)
  5758.       number = -number;
  5759.  
  5760.    return (number);
  5761. }
  5762.  
  5763. /************************************************************************
  5764. *
  5765.  
  5766. Specifying a return type of void on a function declaration indicates that the 
  5767. function does not return a value. The following example defines the function 
  5768. absolute with the return type void.  Within the function main, absolute is 
  5769. declared with the return type void. 
  5770.  
  5771.                                                                         *
  5772. ************************************************************************/
  5773.  
  5774. #include <stdio.h>
  5775.  
  5776. int main(void)
  5777. {
  5778.   void absolute(float);
  5779.   float f = -8.7;
  5780.  
  5781.   absolute(f);
  5782. }
  5783.  
  5784. void absolute(float number)
  5785. {
  5786.   if (number < 0.0)
  5787.     number = -number;
  5788.  
  5789.   printf("absolute number = %f\n", number);
  5790. }
  5791.  
  5792.  
  5793. ΓòÉΓòÉΓòÉ <hidden> Examples of Function Declarations ΓòÉΓòÉΓòÉ
  5794.  
  5795. You can declare a function with no arguments in two ways: 
  5796.  
  5797.       int f(void);      // ANSI C Standard
  5798.  
  5799.       int f();          // C++ enhancement
  5800.                         // Note: In ANSI C, this declaration means that
  5801.                         // f may take any number or type or parameters
  5802.  
  5803. A function can also be declared with a variable number of arguments. To declare 
  5804. this type of function, use an ellipsis in the argument list in the function 
  5805. declaration as shown in the following example: 
  5806.  
  5807.       int f(int,...);
  5808.  
  5809. Note:  The comma before the ellipsis in the above declaration is optional. 
  5810.  
  5811. No type checking is performed on the variable arguments. 
  5812.  
  5813. The following code fragments show several function declarations. The first 
  5814. declares a function f that takes two integer arguments and has a return type of 
  5815. void: 
  5816.  
  5817.       void f(int, int);
  5818.  
  5819. The following code fragment declares a function f1 that takes an integer 
  5820. argument, and returns a pointer to a function that takes an integer argument 
  5821. and returns an integer: 
  5822.  
  5823.       int (*f1(int))(int);
  5824.  
  5825. Alternatively, a typedef can be used for the complicated return type of 
  5826. function f1: 
  5827.  
  5828.       typedef int pf1(int);
  5829.       pf1* f1(int);
  5830.  
  5831. The following code fragment declares a pointer p1 to a function that takes a 
  5832. pointer to a constant character and returns an integer: 
  5833.  
  5834.       int (*p1) (const char*);
  5835.  
  5836. The following declaration is of an external function f2 that takes a constant 
  5837. integer as its first argument, can have a variable number and variable types of 
  5838. other arguments, and returns type int. 
  5839.  
  5840.       int extern f2(const int ...);
  5841.  
  5842. Function f3 takes an int argument with a default value that is the value 
  5843. returned from function f2, and that has a return type of int: 
  5844.  
  5845.       const int j = 5;
  5846.       int f3( int x = f2(j) );
  5847.  
  5848. Function f6 is a constant class member function of class X with no arguments, 
  5849. and with an int return type: 
  5850.  
  5851. class X
  5852. {
  5853. public:
  5854.       int f6() const;
  5855. };
  5856.  
  5857. Function f4 takes no arguments, has return type void, and can throw class 
  5858. objects of types X and Y. 
  5859.  
  5860. class X;
  5861. class Y;
  5862. //      .
  5863. //      .
  5864. //      .
  5865. void f4() throw(X,Y);
  5866.  
  5867. Function f5 takes no arguments, has return type void, and cannot throw an 
  5868. exception. 
  5869.  
  5870. void f5() throw();
  5871.  
  5872.  
  5873. ΓòÉΓòÉΓòÉ 6.4. Function Definition ΓòÉΓòÉΓòÉ
  5874.  
  5875. A function definition specifies the name, formal parameters, and body of a 
  5876. function.  You can also specify the function's return type and storage class. 
  5877.  
  5878. Syntax of a Function Definition 
  5879.  
  5880. There are two ways to define a function:  prototype and nonprototype. You 
  5881. should use the prototype method because of the parameter type checking that can 
  5882. be performed. 
  5883.  
  5884. Note:  C++ functions must use prototypes. Nonprototype functions are allowed in 
  5885. C only. 
  5886.  
  5887. A function definition (either prototype or nonprototype) contains the 
  5888. following: 
  5889.  
  5890. o The optional storage class specifier extern or static, which determines the 
  5891.   scope of the function.  If a storage class specifier is not given, the 
  5892.   function has external linkage. 
  5893. o An optional linkage keyword, which determines the calling convention used to 
  5894.   call the function.  The keywords are a C/C++ Tools extension to the SAA C 
  5895.   definition. The default calling convention is _Optlink. 
  5896. o An optional type specifier, which determines the type of value that the 
  5897.   function returns.  If a type specifier is not given, the function has type 
  5898.   int. 
  5899. o A function declarator, which provides the function with a name, can further 
  5900.   describe the type of the value that the function returns, and can list any 
  5901.   parameters (and their types) that the function expects. The parameters that 
  5902.   the function is expecting are enclosed in parentheses. 
  5903. o A block statement, which contains data definitions and code. 
  5904.  
  5905. In addition, the nonprototype function definition may also have parameter 
  5906. declarations, which describe the types of parameters that the function 
  5907. receives. In nonprototype functions, parameters that are not declared have type 
  5908. int. 
  5909.  
  5910. A function can be called by itself or by other functions. Unless a function 
  5911. definition has the storage class specifier static, the function also can be 
  5912. called by functions that appear in other files. If the function has a storage 
  5913. class specifier of static, it can only be directly invoked from within the same 
  5914. source file. If a function has the storage class specifier static or a return 
  5915. type other than int, the function definition or a declaration for the function 
  5916. must appear before, and in the same file as, a call to the function. If a 
  5917. function definition has external linkage and a return type of int, calls to the 
  5918. function can be made before it is visible because an implicit declaration of 
  5919. extern int func(); is assumed. 
  5920.  
  5921. All declarations for a given function must be compatible; that is, the return 
  5922. type is the same and the parameters have the same type. 
  5923.  
  5924. The default type for the return value and parameters of a function is int, and 
  5925. the default storage class specifier is extern. If the function does not return 
  5926. a value or it is not passed any parameters, use the keyword void as the type 
  5927. specifier. 
  5928.  
  5929. You can include ellipses (...) at the end of your parameter list to indicate 
  5930. that a variable number of arguments will be passed to the function.  Parameter 
  5931. promotions are performed, and no type checking is done. 
  5932.  
  5933. In C, you cannot declare a function as a struct or union member. (This 
  5934. restriction does not apply to C++.) 
  5935.  
  5936. A function cannot have a return type of function or array.  In C, a function 
  5937. cannot return any type having the volatile or const qualifier. (This 
  5938. restriction does not apply to C++.) A function can return a pointer or 
  5939. reference to a function, array, or to an object with a volatile or const type. 
  5940.  
  5941. You cannot define an array of functions.  You can, however, define an array of 
  5942. pointers to functions. 
  5943.  
  5944. Examples of Function Definitions 
  5945.  
  5946. Related Information 
  5947.  
  5948. o Storage Class Specifiers 
  5949. o Linkage Keywords 
  5950. o Types 
  5951. o Function Declarator 
  5952. o Block 
  5953. o volatile and const Qualifiers 
  5954. o Function Declarations 
  5955.  
  5956.  
  5957. ΓòÉΓòÉΓòÉ <hidden> Syntax of a Function Definition ΓòÉΓòÉΓòÉ
  5958.  
  5959. A function definition has the form: 
  5960.  
  5961. >>ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ>
  5962.   Γö£ΓöÇexternΓöÇΓöñ  ΓööΓöÇlinkage_specifierΓöÇΓöÿ  ΓööΓöÇtype_specifierΓöÇΓöÿ
  5963.   ΓööΓöÇstaticΓöÇΓöÿ
  5964.             ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  5965.                          Γöé
  5966. >ΓöÇΓöÇfunction_declaratorΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇΓöÇblock_statementΓöÇΓöÇ><
  5967.              ΓööΓöÇparameter_declarationΓöÇΓöÿ
  5968.  
  5969.  
  5970. ΓòÉΓòÉΓòÉ <hidden> Examples of Function Definitions ΓòÉΓòÉΓòÉ
  5971.  
  5972. /************************************************************************
  5973. *
  5974.  
  5975. In the following, ary is an array of two function pointers.  Type casting is 
  5976. performed to the values assigned to ary for compatibility: 
  5977.  
  5978.                                                                         *
  5979. ************************************************************************/
  5980.  
  5981. #include <stdio.h>
  5982.  
  5983. int func1(void);
  5984. void func2(double a);
  5985.  
  5986. int main(void)
  5987. {
  5988.    double num;
  5989.    void (*ary[2]) ();
  5990.    ary[0] = ((void(*)())func1);
  5991.    ary[1] = ((void(*)())func2);
  5992.  
  5993.    ((int (*)())ary[0])();             /*  calls func1  */
  5994.    ((void (*)(double))ary[1])(num);   /*  calls func2  */
  5995. }
  5996.  
  5997. /************************************************************************
  5998. *
  5999.  
  6000. The following example is a complete definition of the function sum: 
  6001.  
  6002. int sum(int x,int y)
  6003. {
  6004.    return(x + y);
  6005. }
  6006.  
  6007. The function sum has external linkage, returns an object that has type int, and 
  6008. has two parameters of type int declared as x and y.  The function body contains 
  6009. a single statement that returns the sum of x and y. 
  6010.  
  6011.                                                                         *
  6012. ************************************************************************/
  6013.  
  6014.  
  6015. ΓòÉΓòÉΓòÉ 6.4.1. Linkage Keywords ΓòÉΓòÉΓòÉ
  6016.  
  6017. Linkage keywords are an alternative to the #pragma linkage directive for 
  6018. setting linkage conventions for function calls. Because C++ does not support 
  6019. #pragma linkage, linkage keywords are the only method for setting the calling 
  6020. conventions for C++ functions. Each linkage convention has a corresponding 
  6021. keyword that you can use with a function name to set the convention for that 
  6022. function. The keywords are: 
  6023.  
  6024. _Optlink                        C/C++ Tools default linkage 
  6025. _System                         OS/2 system linkage 
  6026. _Pascal                         32-bit _Pascal linkage 
  6027. _Far32 _Pascal                  32-bit far _Pascal linkage 
  6028. _Far16 _Cdecl                   16-bit _Cdecl linkage 
  6029. _Far16 _Pascal                  16-bit _Pascal linkage 
  6030. _Far16 _Fastcall                16-bit _Fastcall linkage 
  6031.  
  6032. Note: 
  6033.  
  6034.  1. You must specify the _Far16 keyword to use a 16-bit calling convention. If 
  6035.     you specify only _Far16, the _Far16 _Cdecl linkage is used. 
  6036.  
  6037.  2. Do not confuse the 32-bit _Pascal linkage with the 16-bit _Far16 _Pascal 
  6038.     linkage. If you specify only the _Pascal keyword, the 32-bit convention is 
  6039.     used. 
  6040.  
  6041.  3. _Far32 _Pascal linkage is only available when the /Gr+ option is specified. 
  6042.  
  6043. You can use the linkage keywords at any language level. Using a keyword is 
  6044. generally quicker and easier than using a #pragma linkage directive. 
  6045.  
  6046. To set the calling convention for a function, place the linkage keyword 
  6047. immediately before the function name. For example, 
  6048.  
  6049.    int _System deborah(int);
  6050.    char (* _Far16 _Cdecl donna)(int);
  6051.  
  6052. These two statements are equivalent to using the following #pragma linkage 
  6053. directives and declarations in C: 
  6054.  
  6055.    #pragma linkage(deborah, system)
  6056.    int deborah(int);
  6057.  
  6058.    #pragma linkage(donnatype, far16 cdecl)
  6059.    typedef char donnatype(int);
  6060.    donnatype donna;
  6061.  
  6062. Like the #pragma linkage directive, the linkage keywords take precedence over 
  6063. the compiler options that set calling conventions (/Mp and /Ms). If you specify 
  6064. conflicting linkage types for a function using both a #pragma linkage directive 
  6065. and a keyword, an error message is generated and your program will not compile. 
  6066.  
  6067. For more information on the different calling conventions and how they work, 
  6068. see the Programming Guide. 
  6069.  
  6070. Related Information 
  6071.  
  6072. o #pragma linkage 
  6073. o /Mp and /Ms options 
  6074. o Function Declarations 
  6075. o Function Definition 
  6076.  
  6077.  
  6078. ΓòÉΓòÉΓòÉ 6.4.2. Function Declarator ΓòÉΓòÉΓòÉ
  6079.  
  6080. The function declarator names the function and lists the function parameters. A 
  6081. function declarator contains an identifier that names the function and a list 
  6082. of the function parameters. There are two types of function declarators: 
  6083. prototype and nonprototype. It is recommended you always use prototype function 
  6084. declarators because of the parameter checking that can be performed. C++ 
  6085. functions must have prototype function declarators. 
  6086.  
  6087. Syntax of a Function Declarator 
  6088.  
  6089. For prototype function declarators, each parameter should be declared within 
  6090. the function declarator. Any calls to the function must pass the same number of 
  6091. arguments as there are parameters in the declaration. 
  6092.  
  6093. To indicate that a function does not receive any values, use the keyword void 
  6094. in place of the parameter. For example: 
  6095.  
  6096. int stop(void)
  6097. {
  6098. }
  6099.  
  6100. Examples of Prototype Function Declarators 
  6101.  
  6102. For nonprototype function declarators, each parameter should be declared in a 
  6103. parameter declaration list following the declarator. If a parameter is not 
  6104. declared, it has type int. 
  6105.  
  6106. char and short parameters are widened to int, and float to double. No type 
  6107. checking between the argument type and the parameter type is done for 
  6108. nonprototyped functions.  As well, there are no checks to ensure that the 
  6109. number of arguments matches the number of parameters. 
  6110.  
  6111. Each value that a function receives should be declared in a parameter 
  6112. declaration list for nonprototype function definitions that follows the 
  6113. declarator. 
  6114.  
  6115. A parameter declaration determines the storage class specifier and the data 
  6116. type of the value. 
  6117.  
  6118. The only storage class specifier allowed is the register storage class 
  6119. specifier. Any type specifier for a parameter is allowed. If you do not specify 
  6120. the register storage class specifier, the parameter will have the auto storage 
  6121. class specifier. If you omit the type specifier and you are not using the 
  6122. prototype form to define the function, the parameter will have type int. 
  6123.  
  6124.     int func(i,j)
  6125.     {
  6126.        /*  i and j have type int  */
  6127.     }
  6128.  
  6129. You cannot declare a parameter in the parameter declaration list if it is not 
  6130. listed within the declarator. 
  6131.  
  6132. Related Information 
  6133.  
  6134. o Function Declarations 
  6135. o Function Definition 
  6136. o Function Body 
  6137. o Functions 
  6138. o Declarations and Definitions 
  6139.  
  6140.  
  6141. ΓòÉΓòÉΓòÉ <hidden> Syntax of a Function Declarator ΓòÉΓòÉΓòÉ
  6142.  
  6143. A prototype function declarator has the form: 
  6144.  
  6145.           ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  6146.                           Γöé
  6147.  ΓöÇΓöÇidentifierΓöÇΓöÇ(ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤Γö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ)ΓöÇΓöÇΓöÇ
  6148.            Γöé               Γöé Γöé   Γöé
  6149.            ΓööΓöÇtype_specifierΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ ΓööΓöÇ...ΓöÇΓöÿ
  6150.                     Γöé      Γöé
  6151.                     ΓööΓöÇparameterΓöÇΓöÿ
  6152.  
  6153. A nonprototype function declarator has the form: 
  6154.  
  6155.           ΓöîΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  6156.                  Γöé
  6157. >>ΓöÇΓöÇidentifierΓöÇΓöÇ(ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇΓöÇ)ΓöÇΓöÇ><
  6158.           ΓööΓöÇparameterΓöÇΓöÿ
  6159.  
  6160. A parameter list has the form: 
  6161.  
  6162.                    ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  6163.                           Γöé
  6164. ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇdeclaratorΓöÇΓö┤ΓöÇ;ΓöÇΓöÇ
  6165.   Γöé                Γöé
  6166.   Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇtype_specifierΓöÇΓöÇΓöÿ
  6167.   Γöé       Γöé
  6168.   ΓööΓöÇΓöÇregisterΓöÇΓöÇΓöÿ
  6169.  
  6170.  
  6171. ΓòÉΓòÉΓòÉ <hidden> Examples of Prototype Function Declarators ΓòÉΓòÉΓòÉ
  6172.  
  6173. The example below contains a function declarator sort with table declared as a 
  6174. pointer to int and length declared as type int. Note that arrays as parameters 
  6175. are implicitly converted to a pointer to the type. 
  6176.  
  6177. void sort(int table[ ], int length)
  6178. {
  6179.   int i, j, temp;
  6180.  
  6181.   for (i = 0; i < length -1; i++)
  6182.     for (j = i + 1; j < length; j++)
  6183.       if (table[i] > table[j])
  6184.       {
  6185.         temp = table[i];
  6186.         table[i] = table[j];
  6187.         table[j] = temp;
  6188.       }
  6189. }
  6190.  
  6191. The following examples contain prototype function declarators: 
  6192.  
  6193. double square(float x);
  6194. int area(int x,int y);
  6195. static char *search(char);
  6196.  
  6197. The example below illustrates how a typedef identifier can be used in a 
  6198. function declarator: 
  6199.  
  6200. typedef struct tm_fmt { int minutes;
  6201.                       int hours;
  6202.                       char am_pm;
  6203.                     } struct_t;
  6204. long time_seconds(struct_t arrival)
  6205.  
  6206. The following function set_date declares a pointer to a structure of type date 
  6207. as a parameter.  date_ptr has the storage class specifier register. 
  6208.  
  6209. set_date(register struct date *date_ptr)
  6210. {
  6211.   date_ptr->mon = 12;
  6212.   date_ptr->day = 25;
  6213.   date_ptr->year = 87;
  6214. }
  6215.  
  6216.  
  6217. ΓòÉΓòÉΓòÉ 6.4.3. Function Body ΓòÉΓòÉΓòÉ
  6218.  
  6219. The body of a function is a block statement. (For more information on block 
  6220. statements, see Block.) The following function has an empty body: 
  6221.  
  6222. void stub1(void)
  6223. {
  6224. }
  6225.  
  6226. The following function body contains a definition for the integer variable 
  6227. big_num, an if-else control statement, and a call to the function printf: 
  6228.  
  6229. void largest(int num1, int num2)
  6230. {
  6231.    int big_num;
  6232.  
  6233.    if (num1 >= num2)
  6234.       big_num = num1;
  6235.    else
  6236.       big_num = num2;
  6237.  
  6238.    printf("big_num = %d\n", big_num);
  6239. }
  6240.  
  6241. Related Information 
  6242.  
  6243. o Block 
  6244. o Function Definition 
  6245. o Function Declarations 
  6246.  
  6247.  
  6248. ΓòÉΓòÉΓòÉ 6.5. Calling Functions and Passing Arguments ΓòÉΓòÉΓòÉ
  6249.  
  6250. A function call specifies a function name and a list of arguments.  The calling 
  6251. function passes the value of each argument to the specified function.  The 
  6252. argument list is surrounded by parentheses, and each argument is separated by a 
  6253. comma. The argument list can be empty. 
  6254.  
  6255. The arguments to a function are evaluated before the function is called.  When 
  6256. an argument is passed in a function call, the function receives a copy of the 
  6257. argument value. If the value of the argument is an address, the called function 
  6258. can use indirection to change the contents pointed to by the address. If a 
  6259. function or array is passed as an argument, the argument is converted to a 
  6260. pointer that points to the function or array. If a nonstatic member function is 
  6261. passed as an argument, the argument is converted to a pointer to member. 
  6262.  
  6263. Arguments passed to parameters in prototype declarations will be converted to 
  6264. the declared parameter type. For nonprototype function declarations, char and 
  6265. short parameters are promoted to int, and float to double. 
  6266.  
  6267. You can pass a packed structure argument to a function expecting a nonpacked 
  6268. structure of the same type and vice versa. (The same applies to packed and 
  6269. nonpacked unions.) 
  6270.  
  6271. Note:  If you do not use a function prototype and you send a packed structure 
  6272. when a nonpacked structure is expected, a runtime error may occur. 
  6273.  
  6274. It is an error when a function argument is a class and all of the following 
  6275. properties hold: 
  6276.  
  6277. o The class needs a copy constructor. 
  6278. o The class does not have a user defined copy constructor. 
  6279. o A copy constructor cannot be generated for that class. 
  6280.  
  6281. The order in which arguments are evaluated and passed to the function is 
  6282. implementation-defined. For example, the following sequence of statements calls 
  6283. the function tester: 
  6284.  
  6285. int x;
  6286. x = 1;
  6287. tester(x++, x);
  6288.  
  6289. The call to tester in the preceding example may produce different results on 
  6290. different compilers.  Depending on the implementation, x++ may be evaluated 
  6291. first or x may be evaluated first.  To avoid ambiguity, if you want x++ to be 
  6292. evaluated first, you can replace the preceding sequence of statements with the 
  6293. following: 
  6294.  
  6295. int x, y;
  6296. x = 1;
  6297. y = x++;
  6298. tester(y, x);
  6299.  
  6300. Examples of Calling Functions and Passing Arguments 
  6301.  
  6302. Related Information 
  6303.  
  6304. o Passing Arguments by Reference 
  6305. o -- Reference cplr376 not found -- 
  6306. o Member Functions 
  6307. o Function Declarator 
  6308. o Function Declarations 
  6309. o Function Definition 
  6310. o Types 
  6311.  
  6312.  
  6313. ΓòÉΓòÉΓòÉ <hidden> Examples of Calling Functions ΓòÉΓòÉΓòÉ
  6314.  
  6315. /************************************************************************
  6316. *
  6317.  
  6318. The following statement calls the function startup and passes no parameters: 
  6319.  
  6320. startup();
  6321.  
  6322. The following function call causes copies of a and b to be stored in a local 
  6323. area for the function sum.  The function sum is executed using the copies of a 
  6324. and b. 
  6325.  
  6326. sum(a, b);
  6327.  
  6328. The following function call passes the value 2 and the value of the expression 
  6329. a +b to sum: 
  6330.  
  6331. sum(2, a + b);
  6332.  
  6333. The following statement calls the functions printf and sum.  sum receives the 
  6334. values of a and b. printf receives a character string and the return value of 
  6335. the function sum: 
  6336.  
  6337. printf("sum = %d\n", sum(a,b));
  6338.  
  6339. The following program passes the value of count to the function increment. 
  6340. increment increases the value of the parameter x by 1. 
  6341.  
  6342.                                                                         *
  6343. ************************************************************************/
  6344.  
  6345. #include <stdio.h>
  6346.  
  6347. void increment(int);
  6348.  
  6349. int main(void)
  6350. {
  6351.   int count = 5;
  6352.  
  6353.   /* value of count is passed to the function */
  6354.   increment(count);
  6355.   printf("count = %d\n", count);
  6356. }
  6357.  
  6358. void increment(int x)
  6359. {
  6360.   ++x;
  6361.   printf("x = %d\n", x);
  6362. }
  6363.  
  6364. /************************************************************************
  6365. *
  6366.  
  6367. The output illustrates that the value of count in main remains unchanged: 
  6368.  
  6369. x = 6
  6370. count = 5
  6371.  
  6372. In the following program, main passes the address of count to increment. The 
  6373. function increment was changed to handle the pointer. The parameter x is 
  6374. declared as a pointer. The contents to which x points are then incremented. 
  6375.  
  6376.                                                                         *
  6377. ************************************************************************/
  6378.  
  6379. #include <stdio.h>
  6380.  
  6381. int main(void)
  6382. {
  6383.   void increment(int *x);
  6384.   int count = 5;
  6385.  
  6386.   /* address of count is passed to the function */
  6387.   increment(&count);
  6388.   printf("count = %d\n", count);
  6389. }
  6390.  
  6391. void increment(int *x)
  6392. {
  6393.   ++*x;
  6394.   printf("*x = %d\n", *x);
  6395. }
  6396.  
  6397. /************************************************************************
  6398. *
  6399.  
  6400. The output shows that the variable count is increased: 
  6401.  
  6402. *x = 6
  6403. count = 6
  6404.  
  6405.                                                                         *
  6406. ************************************************************************/
  6407.  
  6408.  
  6409. ΓòÉΓòÉΓòÉ 6.5.1. Passing Arguments by Reference ΓòÉΓòÉΓòÉ
  6410.  
  6411. If you use a reference type as a formal argument, you can make a 
  6412. pass-by-reference call to a function. In a pass-by-reference call, the values 
  6413. of arguments in the calling function can be modified in the called function. In 
  6414. pass-by-value calls, only copies of the arguments are passed to the function. 
  6415.  
  6416. Note:  The term pass by reference describes a general method of passing 
  6417. arguments from a calling routine to a called routine. The term reference in the 
  6418. context of C++ refers to a specific way of declaring objects and functions. 
  6419.  
  6420. Example of Passing Arguments by Reference 
  6421.  
  6422. Arguments by reference in the following two cases causes the compiler to issue 
  6423. a warning: 
  6424.  
  6425. o Ellipsis arguments cannot be passed as references. 
  6426.  
  6427. o If the last argument specified in the function declaration before the 
  6428.   ellipsis is a reference argument, arguments passed using an ellipsis 
  6429.   (variable arguments) are not accessible using the mechanism from the 
  6430.   <stdarg.h> standard header file. 
  6431.  
  6432. In addition, when the actual argument cannot be referenced directly by the 
  6433. formal argument, the compiler creates a temporary variable that is referenced 
  6434. by the formal argument and initialized using the value of the actual argument. 
  6435. In this case, the formal argument must be a .const reference. 
  6436.  
  6437. Reference arguments declared const can be used to pass large objects 
  6438. efficiently to functions without making a temporary copy of the object that is 
  6439. passed to the function. Because the reference is declared const, the actual 
  6440. arguments cannot be changed by the function. For example: 
  6441.  
  6442. void printbig (const bigvar&); // Function prototype
  6443.  
  6444. When a function printbig is called, it cannot modify the object of type bigvar 
  6445. because the object was passed by constant reference. 
  6446.  
  6447. Related Information 
  6448.  
  6449. o Calling Functions and Passing Arguments 
  6450. o References 
  6451. o volatile and const Qualifiers 
  6452.  
  6453.  
  6454. ΓòÉΓòÉΓòÉ <hidden> Example of Passing Arguments by Reference ΓòÉΓòÉΓòÉ
  6455.  
  6456. /************************************************************************
  6457. *
  6458.  
  6459. The following example shows how arguments are passed by reference. Note that 
  6460. reference formal arguments are initialized with the actual arguments when the 
  6461. function is called. 
  6462.  
  6463.                                                                         *
  6464. ************************************************************************/
  6465.  
  6466. #include <iostream.h>
  6467. void swapnum(int &i, int &j)
  6468. {
  6469.       int temp = i;
  6470.       i = j;
  6471.       j = temp;
  6472. }
  6473. //    .
  6474. //    .
  6475. //    .
  6476. main()
  6477. {
  6478.       int   a = 10,   // a is 10
  6479.             b = 20;   // b is 20
  6480.       swapnum(a,b);    // now a is 20 and b is 10
  6481.       cout << "A is : " << a
  6482.            << " and B is : " << b << endl;
  6483. }
  6484.  
  6485. /************************************************************************
  6486. *
  6487.  
  6488. When the function swapnum() is called, the actual values of the variables a and 
  6489. b are exchanged because they are passed by reference. The output is: 
  6490.  
  6491. A is : 20 and B is : 10
  6492.  
  6493. You must define the formal arguments of swapnum() as references if you want the 
  6494. values of the actual arguments to be modified by the function swapnum(). 
  6495.  
  6496.                                                                         *
  6497. ************************************************************************/
  6498.  
  6499.  
  6500. ΓòÉΓòÉΓòÉ 6.6. Default Arguments ΓòÉΓòÉΓòÉ
  6501.  
  6502. In C++, you can provide default values for function arguments. All default 
  6503. argument names of a function are bound when the function is declared. All 
  6504. functions have their types checked at declaration, and are evaluated at each 
  6505. point of call. For example: 
  6506.  
  6507. #include <iostream.h>
  6508. int a = 1;
  6509. int f(int a) {return a;}
  6510. int g(int x = f(a)) {return f(a);}
  6511.  
  6512. int h()
  6513. {
  6514.      a=2;
  6515.      {
  6516.             int a = 3;
  6517.             return g();
  6518.      }
  6519. }
  6520.  
  6521. main()
  6522. {
  6523.      cout << h() << endl;
  6524. }
  6525.  
  6526. This example prints "2" to standard output, because the a referred to in the 
  6527. declaration of g() is the one at file scope, which has the value 2 when g() is 
  6528. called. The value of a is determined after entry into function h() but before 
  6529. the call to g() is resolved. 
  6530.  
  6531. A default argument can have any type. 
  6532.  
  6533. A pointer to a function must have the same type as the function. Attempts to 
  6534. take the address of a function by reference without specifying the type of the 
  6535. function produce an error. The type of a function is not affected by arguments 
  6536. with default values. 
  6537.  
  6538. The following example shows that the fact that a function has default arguments 
  6539. does not change its type. The default argument allows you to call a function 
  6540. without specifying all of the arguments, it does not allow you to create a 
  6541. pointer to the function that does not specify the types of all the arguments. 
  6542. Thus, f can be called without an explicit argument, but the pointer badpointer 
  6543. cannot be defined without specifying the type of the argument. 
  6544.  
  6545. int f(int = 0);
  6546. void g()
  6547. {
  6548.    int a = f(1);                // ok
  6549.    int b = f();                 // ok, default argument used
  6550. }
  6551. int (*pointer)(int) = &f;       // ok, type of f() specified (int)
  6552. int (*badpointer)() = &f;       // error, badpointer and f have
  6553.                                 // different types. badpointer must
  6554.                                 // be initialized with a pointer to
  6555.                                 // a function taking no arguments.
  6556.  
  6557. Additional information is provided on: 
  6558.  
  6559. o Restrictions on Default Arguments 
  6560. o Evaluating Default Arguments 
  6561.  
  6562. Related Information 
  6563.  
  6564. o Calling Functions and Passing Arguments 
  6565. o Functions 
  6566.  
  6567.  
  6568. ΓòÉΓòÉΓòÉ 6.6.1. Restrictions on Default Arguments ΓòÉΓòÉΓòÉ
  6569.  
  6570. Of the operators, only the function call operator and the operator new can have 
  6571. default arguments when they are overloaded. 
  6572.  
  6573. Arguments with default values must be the trailing arguments in the function 
  6574. declaration argument list. For example: 
  6575.  
  6576. void f(int a, int b = 2, int c = 3);  // trailing defaults
  6577. void g(int a = 1, int b = 2, int c);  // error, leading defaults
  6578. void h(int a, int b = 3, int c);      // error, default in middle
  6579.  
  6580. Once a default argument has been given in a declaration or definition, you 
  6581. cannot redefine that argument, even to the same value. However, you can add 
  6582. default arguments not given in previous declarations. For example, the last 
  6583. declaration below attempts to redefine the default values for a and b: 
  6584.  
  6585. void f(int a, int b, int c=1);     // valid
  6586. void f(int a, int b=1, int c);     // valid, add another default
  6587. void f(int a=1, int b, int c);     // valid, add another default
  6588. void f(int a=1, int b=1, int c=1); // error, redefined defaults
  6589.  
  6590. You can supply any default argument values in the function declaration or in 
  6591. the definition. All subsequent arguments must have default arguments supplied 
  6592. in this or a previous declaration of the function. 
  6593.  
  6594. You cannot use local variables in default argument expressions. For example, 
  6595. the compiler generates errors for both function g() and function h() below: 
  6596.  
  6597. void f(int a)
  6598. {
  6599.       int b=4;
  6600.       void g(int c=a); // Local variable "a" inaccessible
  6601.       void h(int d=b); // Local variable "b" inaccessible
  6602. }
  6603.  
  6604.  
  6605. ΓòÉΓòÉΓòÉ 6.6.2. Evaluating Default Arguments ΓòÉΓòÉΓòÉ
  6606.  
  6607. When a function defined with default arguments is called with trailing 
  6608. arguments missing, the default expressions are evaluated. For example: 
  6609.  
  6610. void f(int a, int b = 2, int c = 3); // declaration
  6611. // ...
  6612. int a = 1;
  6613. f(a);            // same as call f(a,2,3)
  6614. f(a,10);         // same as call f(a,10,3)
  6615. f(a,10,20);      // no default arguments
  6616.  
  6617. Default arguments are checked against the function declaration and evaluated 
  6618. when the function is called. The order of evaluation of default arguments is 
  6619. undefined. Default argument expressions cannot use formal arguments of a 
  6620. function. For example: 
  6621.  
  6622. int f(int q = 3, int r = q); // error
  6623.  
  6624. The argument r cannot be initialized with the value of the argument q because 
  6625. the value of q may not be known when it is assigned to r. If the above function 
  6626. declaration is rewritten: 
  6627.  
  6628. int q=5;
  6629. int f(int q = 3, int r = q); // error
  6630.  
  6631. the value of r in the function declaration still produces an error because the 
  6632. variable q defined outside of the function is hidden by the argument q declared 
  6633. for the function. Similarly: 
  6634.  
  6635. typedef double D;
  6636. int f(int D, int z = D(5.3) ); // error
  6637.  
  6638. Here the type D is interpreted within the function declaration as the name of 
  6639. an integer. The type D is hidden by the argument D. The cast D(5.3) is 
  6640. therefore not interpreted as a cast because D is the name of the argument not a 
  6641. type. 
  6642.  
  6643. In the following example, the nonstatic member a cannot be used as an 
  6644. initializer because a does not exist until an object of class X is constructed. 
  6645. You can use the static member b as an initializer because b is created 
  6646. independently of any objects of class X. You can declare the member b after its 
  6647. use as a default argument because the default values are not analyzed until 
  6648. after the final bracket } of the class declaration. 
  6649.  
  6650. class X
  6651. {
  6652.    int a;
  6653.     f(int z = a) ; // error
  6654.     g(int z = b) ; // valid
  6655.     static int b;
  6656. };
  6657. You must put parentheses around default argument expressions that contain 
  6658. template references. In the following example: 
  6659.  
  6660. class C {
  6661.    void f(int i = X<int,5>&cs.y);
  6662. };
  6663. the compiler cannot tell that the < represents the start of a template argument 
  6664. list and not the less than operator because the default argument X<int,5>&cs.y 
  6665. cannot be processed until the end of the class. 
  6666.  
  6667. To avoid error messages, put parentheses around the expression containing the 
  6668. default argumement list: 
  6669.  
  6670. class C {
  6671.    void f( int i = (X<int,5>&cs.y) );
  6672. };
  6673.  
  6674.  
  6675. ΓòÉΓòÉΓòÉ 6.7. Return Values ΓòÉΓòÉΓòÉ
  6676.  
  6677. A value must be returned from a function unless the function has a return type 
  6678. of void. The return value is specified in a return statement. The following 
  6679. code fragment shows a function definition, including the return statement: 
  6680.  
  6681. int add(int i, int j)
  6682. {
  6683.   return i + j; // return statement
  6684. }
  6685.  
  6686. The function add() can be called as shown in the following code fragment: 
  6687.  
  6688. int a = 10,
  6689.     b = 20;
  6690. int answer = add(a, b); // answer is 30
  6691.  
  6692. In this example, the return statement initializes a variable of the returned 
  6693. type. The variable answer is initialized with the int value 30. The type of the 
  6694. returned expression is checked against the returned type. All standard and 
  6695. user-defined conversions are performed as necessary. 
  6696.  
  6697. The following return statements show different ways of returning values to a 
  6698. caller: 
  6699.  
  6700. return;                    // Returns no value
  6701. return result;             // Returns the value of result
  6702. return 1;                  // Returns the value 1
  6703. return (x * x);            // Returns the value of x * x
  6704.  
  6705. Other than main(), if a function that does not have type void returns without a 
  6706. value (as in the first return statement shown in the example above) the 
  6707. compiler issues a warning message, and the result returned is undefined. 
  6708.  
  6709. Each time a function is called, new copies of its local variables are created. 
  6710. Because the storage for a local variable may be reused after the function has 
  6711. terminated, a pointer to a local variable or a reference to a local variable 
  6712. should not be returned. 
  6713.  
  6714. If a class object is returned, a temporary object may be created if the class 
  6715. has copy constructors or a destructor. 
  6716.  
  6717. References can also be used as return types for functions. The reference 
  6718. returns the lvalue of the object to which it refers. This allows you to place 
  6719. function calls on the left side of assignment statements. Referenced return 
  6720. values are used when assignment operators and subscripting operators are 
  6721. overloaded so that the results of the overloaded operators can be used as 
  6722. actual values. 
  6723.  
  6724. Related Information 
  6725.  
  6726. o return 
  6727. o Calling Functions and Passing Arguments 
  6728. o main 
  6729. o Temporary Objects 
  6730. o Special Overloaded Operators 
  6731.  
  6732.  
  6733. ΓòÉΓòÉΓòÉ 6.8. Inline Functions ΓòÉΓòÉΓòÉ
  6734.  
  6735. Inline functions are used to reduce the overhead of a normal function call. A 
  6736. function is declared inline by using the specifier inline for C++ functions or 
  6737. _Inline for C functions. The inline specifier is a suggestion to the compiler 
  6738. that an inline expansion can be performed. Instead of transferring control to 
  6739. and from the function code segment, a modified copy of the function body may be 
  6740. substituted directly for the function call. 
  6741.  
  6742. An inline function can be declared and defined simultaneously. If it is 
  6743. declared with the keyword inline or _Inline, it can be declared without a 
  6744. definition. The following code fragment shows an inline function definition. 
  6745. Note that the definition includes both the declaration and body of the inline 
  6746. function. 
  6747.  
  6748. inline int add(int i, int j) { return i + j; }
  6749.  
  6750. Both member and nonmember functions can be inline, and both have internal 
  6751. linkage. 
  6752.  
  6753. The use of the inline specifier does not change the meaning of the function. 
  6754. The inline expansion of a function may not preserve the order of evaluation of 
  6755. the actual arguments. 
  6756.  
  6757. For more information on inlining, see the Programming Guide. 
  6758.  
  6759. Related Information 
  6760.  
  6761. o Inline Specifiers 
  6762. o Inline Member Functions 
  6763. o Functions 
  6764.  
  6765.  
  6766. ΓòÉΓòÉΓòÉ 6.9. Resolving Ambiguous Statements ΓòÉΓòÉΓòÉ
  6767.  
  6768. There are situations where a statement can be parsed as both a declaration and 
  6769. as an expression. Specifically, a function declaration can look like a function 
  6770. call in certain cases. The compiler resolves these ambiguities by applying the 
  6771. following rules: 
  6772.  
  6773. o If the statement can be parsed as a declaration but there are no declaration 
  6774.   specifiers in the declaration and the statement is inside the body of a 
  6775.   function, the statement is assumed to be an expression. The following 
  6776.   statement, for example, is a declaration at file scope of the function f() 
  6777.   that returns type int. There is no declaration specifier and int is the 
  6778.   default, but at function scope this is a call to f(): 
  6779.  
  6780.      f();
  6781.  
  6782. o If the statement can be parsed as a declaration up to the end of the first 
  6783.   declarator, it is assumed to be a declaration even if subsequent parsing 
  6784.   reveals that the statement is only valid as an expression. The following 
  6785.   statement, for example, looks like a declaration with a syntax error at ++. 
  6786.   Because it is a valid declaration for the first declarator (x), this 
  6787.   statement is parsed as a declaration even though it could be parsed as a 
  6788.   valid expression: 
  6789.  
  6790.      int (x), y++;
  6791.  
  6792. o In every other case, if the statement can be parsed as a declaration, it is 
  6793.   assumed to be a declaration. The following statement, for example, is a 
  6794.   declaration of x with redundant parentheses around the declarator, not a 
  6795.   function-style cast of x to type int: 
  6796.  
  6797.      int (x);
  6798.  
  6799. In some cases, the C++ grammar does not disambiguate between expression 
  6800. statements and declaration statements. The ambiguity arises when an expression 
  6801. statement has a function-style cast as its leftmost subexpression. (Note that, 
  6802. because C does not support function-style casts, this ambiguity does not occur 
  6803. in C programs.) In some cases, the ambiguity can be resolved by examining the 
  6804. entire statement containing the expression or declaration. If the statement can 
  6805. be interpreted both as a declaration and as an expression, the statement is 
  6806. interpreted as a declaration statement. 
  6807.  
  6808. The following expressions disambiguate into expression statements because the 
  6809. ambiguous subexpression is followed by an assignment or an operator. T in the 
  6810. expressions can be any type specifier: 
  6811.  
  6812. T(i)++;
  6813. T(i,3)<<d;
  6814. T(i)->l=24;
  6815.  
  6816. In the following examples, the ambiguity cannot be resolved so the statements 
  6817. are interpreted as declarations. T is any type specifier: 
  6818.  
  6819. T(*i)(int);
  6820. T(j)[5];
  6821. T(*k) (float(3));
  6822.  
  6823. The last statement above causes a compile-time error because you cannot 
  6824. initialize a pointer with a float value. 
  6825.  
  6826. Any statement whose ambiguity is not resolved by the above rules is by default 
  6827. a declaration statement. All of the following are declaration statements: 
  6828.  
  6829. T(a);
  6830. T(*b)();
  6831. T(c)=23;
  6832. T(d),e,f,g=0;
  6833. T(h)(e,3);
  6834.  
  6835. The ambiguity is resolved only on a syntactic level. The disambiguation does 
  6836. not use the meaning of the names, except to assess whether or not they are type 
  6837. names. 
  6838.  
  6839. Another C++ ambiguity between expression statements and declaration statements 
  6840. is resolved by requiring a type name for function declarations within a block: 
  6841.  
  6842. a();         // declaration of a function returning int
  6843.              // and taking no arguments
  6844. void func()
  6845. {
  6846.    int a();  // declaration of a function
  6847.    int b;    // declaration of a variable
  6848.    a();      // expression-statement calling function a()
  6849.    b;        // expression-statement referring to a variable
  6850. }
  6851.  
  6852. The last statement above does not produce any action. It is semantically 
  6853. equivalent to a null statement. However, it is a valid C++ statement. 
  6854.  
  6855. Related Information 
  6856.  
  6857. o Function Declarations 
  6858. o Cast Expressions 
  6859.  
  6860.  
  6861. ΓòÉΓòÉΓòÉ 7. Expressions and Operators ΓòÉΓòÉΓòÉ
  6862.  
  6863. This section describes C and C++ language expressions. Expressions are 
  6864. sequences of operators, operands, and punctuators that specify a computation. 
  6865. The evaluation of expressions is based on the operators that the expressions 
  6866. contain and the context in which they are used: 
  6867.  
  6868. o Primary Expression 
  6869. o Unary Expression 
  6870. o Binary Expression 
  6871. o Conditional Expression  ? : 
  6872. o Assignment Expression 
  6873. o Comma Expression  , 
  6874. o Lvalue 
  6875. o Constant Expression 
  6876.  
  6877. An expression can result in an lvalue, rvalue, or no value, and can produce 
  6878. side effects in each case. 
  6879.  
  6880. Note:  C++ operators can be defined to behave differently when applied to 
  6881. operands of class type.  This is called operator overloading.  See Overloading 
  6882. Operators for more details.  This section describes the behavior of operators 
  6883. that are not overloaded.  The C language does not permit overloading. 
  6884.  
  6885. Operator Precedence shows the order of evaluation of the expressions and 
  6886. operators. 
  6887.  
  6888. Most expressions can contain several different, but related, types of operands. 
  6889. The following type classes describe related types of operands: 
  6890.  
  6891. Integral    Character objects and constants, objects having an enumeration 
  6892.             type, and objects having the type short, int, long, unsigned short, 
  6893.             unsigned int, or unsigned long. 
  6894. Arithmetic  Integral objects and objects having the type float, double, and 
  6895.             long double. 
  6896. Scalar      Arithmetic objects and pointers to objects of any type. Also C++ 
  6897.             references. 
  6898. Aggregate   Arrays, structures, and unions. Also C++ classes. 
  6899.  
  6900. Many operators cause conversions from one data type to another.  Conversions 
  6901. are discussed in Conversions. 
  6902.  
  6903.  
  6904. ΓòÉΓòÉΓòÉ 7.1. Operator Precedence ΓòÉΓòÉΓòÉ
  6905.  
  6906. Two operator characteristics determine how operands group with operators: 
  6907. precedence and associativity.  Precedence provides a priority system for 
  6908. grouping different types of operators with their operands.  Associativity 
  6909. provides a left-to-right or right-to-left order for grouping operands to 
  6910. operators that have the same precedence. For example, in the following 
  6911. statements, the value of 5 is assigned to both a and b because of the 
  6912. right-to-left associativity of the = operator. The value of c is assigned to b 
  6913. first, and then the value of b is assigned to a. 
  6914.  
  6915. b = 9;
  6916. c = 5;
  6917. a = b = c;
  6918.  
  6919. Because the order of expression evaluation is not specified, you can explicitly 
  6920. force the grouping of operands with operators by using parentheses. 
  6921.  
  6922. In the expression a + b * c / d, the * and / operations are performed before + 
  6923. because of precedence.  b is multiplied by c before it is divided by d because 
  6924. of associativity. 
  6925.  
  6926. The primary operators have the highest precedence. Table of Operator Precedence 
  6927. and Associativity lists the C and C++ language operators in order of precedence 
  6928. and shows the direction of associativity for each operator. In C++, the primary 
  6929. scope operator has the highest precedence, followed by the other primary 
  6930. operators. In C, because there is no scope operator, the other primary 
  6931. operators have the highest precedence. The comma operator has the lowest 
  6932. precedence. Operators that appear in the same group have the same precedence. 
  6933.  
  6934. The order of evaluation for function call arguments or for the operands of 
  6935. binary operators is not specified. Avoid writing such ambiguous expressions as: 
  6936.  
  6937. z = (x * ++y) / func1(y);
  6938. func2(++i, x[i]);
  6939.  
  6940. In the example above, the order of evaluation of ++y and func1(y) is not 
  6941. defined. If y had the value of 1 before the first statement, it is not known 
  6942. whether or not the value of 1 or 2 is passed to func1().  In the second 
  6943. statement, if i had the value of 1, it is not known whether the first or second 
  6944. array element of x[ ] is passed as the second argument to func2(). Do not write 
  6945. code that depends on a particular order of evaluation of operators with the 
  6946. same precedence. 
  6947.  
  6948. The order of grouping operands with operators in an expression containing more 
  6949. than one instance of an operator with both associative and commutative 
  6950. properties is not specified. The operators that have the same associative and 
  6951. commutative properties are:  *, +, &, |, and ^ (or ╨║).  The grouping of 
  6952. operands can be forced by grouping the expression in parentheses. 
  6953.  
  6954. Examples of Expressions and Precedence 
  6955.  
  6956. Related Information 
  6957.  
  6958. o Parenthesized Expression ( ) 
  6959. o Expressions and Operators 
  6960. o Table of Operator Precedence and Associativity 
  6961.  
  6962.  
  6963. ΓòÉΓòÉΓòÉ <hidden> Examples of Expressions and Precedence ΓòÉΓòÉΓòÉ
  6964.  
  6965. The parentheses in the following expressions explicitly show how the C language 
  6966. groups operands and operators.  If parentheses did not appear in these 
  6967. expressions, the operands and operators would be grouped in the same manner as 
  6968. indicated by the parentheses. 
  6969.  
  6970. total = (4 + (5 * 3));
  6971. total = (((8 * 5) / 10) / 3);
  6972. total = (10 + (5/3));
  6973.  
  6974. The following expression contains operators that are both associative and 
  6975. commutative: 
  6976.  
  6977. total = price + prov_tax + city_tax;
  6978.  
  6979. Because the C language does not specify the order of grouping operands with 
  6980. operators that are both associative and commutative, the operands and operators 
  6981. could be grouped in the following ways (as indicated by parentheses): 
  6982.  
  6983. total = (price + (prov_tax + city_tax));
  6984. total = ((price + prov_tax) + city_tax);
  6985. total = ((price + city_tax) + prov_tax);
  6986.  
  6987. However, the grouping of operands and operators could affect the result.  In 
  6988. the following expression, each function call may be modifying the same global 
  6989. variables. These side effects may result in different values for the expression 
  6990. depending on the order in which the functions are called: 
  6991.  
  6992. a = b() + c() + d();
  6993.  
  6994. If the expression contains operators that are both associative and commutative 
  6995. and the order of grouping operands with operators can affect the result of the 
  6996. expression, separate the expression into several expressions.  For example, the 
  6997. following expressions could replace the previous expression if the called 
  6998. functions do not produce any side effects that affect the variable a. 
  6999.  
  7000. a = b();
  7001. a += c();
  7002. a += d();
  7003.  
  7004.  
  7005. ΓòÉΓòÉΓòÉ 7.1.1. Table of Operator Precedence and Associativity ΓòÉΓòÉΓòÉ
  7006.  
  7007. Operator Name           Operators 
  7008. Primary scope           :: 
  7009.                            Associativity:  left to right 
  7010. Primary                 ()  [ ]  .  -> 
  7011.                            Associativity:  left to right 
  7012. Unary                   ++  --  -  +  !  ~  &  *  sizeof  new  delete 
  7013.                         (typename) (C cast) 
  7014.                            Associativity:  right to left 
  7015. C++ Cast                (typename) 
  7016.                            Associativity:  left to right 
  7017. C++ Pointer to Member   .*  ->* 
  7018.                            Associativity:  left to right 
  7019. Multiplicative          *  /  % 
  7020.                            Associativity:  left to right 
  7021. Additive                +  - 
  7022.                            Associativity:  left to right 
  7023. Bitwise Shift           <<  >> 
  7024.                            Associativity:  left to right 
  7025. Relational              <  >  <=  >= 
  7026.                            Associativity:  left to right 
  7027. Equality                ==  != 
  7028.                            Associativity:  left to right 
  7029. Bitwise Logical AND     & 
  7030.                            Associativity:  left to right 
  7031. Bitwise Exclusive OR    ^  or  ╨║ 
  7032.                            Associativity:  left to right 
  7033. Bitwise Inclusive OR    | 
  7034.                            Associativity:  left to right 
  7035. Logical AND             && 
  7036.                            Associativity:  left to right 
  7037. Logical OR              || 
  7038.                            Associativity:  left to right 
  7039. Conditional             ?  : 
  7040.                            Associativity:  right to left 
  7041. Assignment              =  +=  -=  *=  /=  <<=  >>=  %=  &=  ^=  |= 
  7042.                            Associativity:  right to left 
  7043. Comma                   , 
  7044.                            Associativity:  left to right 
  7045.  
  7046.  
  7047. ΓòÉΓòÉΓòÉ 7.2. Lvalue ΓòÉΓòÉΓòÉ
  7048.  
  7049. An lvalue is an expression that represents an object. A modifiable lvalue is an 
  7050. expression representing an object that can be changed. A modifiable lvalue is 
  7051. the left operand in an assignment expression. However, arrays and const objects 
  7052. are not modifiable lvalues. 
  7053.  
  7054. All assignment operators evaluate their right operand and assign that value to 
  7055. their left operand.  The left operand must evaluate to a reference to an 
  7056. object. 
  7057.  
  7058. The assignment operators are not the only operators that require an operand to 
  7059. be an lvalue.  The address operator requires an lvalue as an operand while the 
  7060. increment and the decrement operators require a modifiable lvalue as an 
  7061. operand. 
  7062.  
  7063. Examples of Lvalues 
  7064.  
  7065. Related Information 
  7066.  
  7067. o Assignment Expression 
  7068. o Address  & 
  7069. o Dot Operator 
  7070. o Arrow Operator 
  7071.  
  7072.  
  7073. ΓòÉΓòÉΓòÉ <hidden> Examples of Lvalues ΓòÉΓòÉΓòÉ
  7074.  
  7075. Expression               Lvalue 
  7076. x = 42;                  x 
  7077. *ptr = newvalue;         *ptr 
  7078. a++                      a 
  7079.  
  7080.  
  7081. ΓòÉΓòÉΓòÉ 7.3. Constant Expression ΓòÉΓòÉΓòÉ
  7082.  
  7083. A constant expression is an expression with a value that is determined during 
  7084. compilation and cannot be changed during execution.  It can only be evaluated. 
  7085. Constant expressions can be composed of integer constants, character constants, 
  7086. floating-point constants, and enumeration constants. The C and C++ languages 
  7087. require constant expressions in the following places: 
  7088.  
  7089. o In the subscript declarator, as the description of an array bound 
  7090. o After the keyword case in a switch statement 
  7091. o In an enumerator, as the numeric value of an enum constant 
  7092. o In a bit-field width specifier 
  7093. o In the preprocessor if statement 
  7094. o In the initializer of a file scope data definition. 
  7095.  
  7096. In all the cases above, except for an initializer of a file scope data 
  7097. definition, the constant expression can contain integer, character, and 
  7098. enumeration constants, casts to integral types, and sizeof expressions. 
  7099.  
  7100. In a file scope data definition, the initializer must evaluate to a constant or 
  7101. to the address of a static storage (extern or static) object (plus or minus an 
  7102. integer constant) that is defined or declared earlier in the file.  Thus, the 
  7103. constant expression in the initializer can contain integer, character, 
  7104. enumeration, and float constants, casts to any type, sizeof expressions, and 
  7105. addresses (possibly modified by constants) of static objects. 
  7106.  
  7107. Functions, class objects, pointers, and references are not allowed unless they 
  7108. occur in sizeof expressions.  Comma operators and assignment operators cannot 
  7109. appear in constant expressions. 
  7110.  
  7111. Examples of Constant Expressions 
  7112.  
  7113. Related Information 
  7114.  
  7115. o Arrays 
  7116. o Initializers 
  7117. o File Scope Data Declarations 
  7118. o switch 
  7119. o Enumerations 
  7120. o Structures 
  7121. o Conditional Compilation 
  7122. o sizeof (Size of an Object) 
  7123.  
  7124.  
  7125. ΓòÉΓòÉΓòÉ <hidden> Examples of Constant Expressions ΓòÉΓòÉΓòÉ
  7126.  
  7127. The following examples show constants used in expressions. 
  7128.  
  7129. Expression                         Constant 
  7130. x = 42;                            42 
  7131. extern int cost = 1000;            1000 
  7132. y = 3 * 29;                        3 * 29 
  7133.  
  7134.  
  7135. ΓòÉΓòÉΓòÉ 7.4. Primary Expression ΓòÉΓòÉΓòÉ
  7136.  
  7137. A primary expression can be: 
  7138.  
  7139. o Identifiers 
  7140. o Strings 
  7141. o Scope Resolution Operator 
  7142. o Parenthesized Expression ( ) 
  7143. o Constant Expression 
  7144. o Function Call ( ) 
  7145. o Array Subscript  [ ] 
  7146. o Dot Operator 
  7147. o Arrow Operator 
  7148.  
  7149. All primary operators have the same precedence and have left-to-right 
  7150. associativity. 
  7151.  
  7152. Related Information 
  7153.  
  7154. o Expressions and Operators 
  7155. o Operator Precedence 
  7156.  
  7157.  
  7158. ΓòÉΓòÉΓòÉ 7.4.1. Scope Resolution Operator ΓòÉΓòÉΓòÉ
  7159.  
  7160. The :: (scope resolution) operator is used to qualify hidden names so that you 
  7161. can still use them. You can use the unary scope operator if a file scope name 
  7162. is hidden by an explicit declaration of the same name in a block or class. For 
  7163. example: 
  7164.  
  7165. int i = 10;
  7166. int f(int i)
  7167. {
  7168.       return i ? i : :: i; // return global i if local i is zero
  7169. }
  7170.  
  7171. You can also use the class scope operator to qualify class names or class 
  7172. member names. If a class member name is hidden, you can use it by qualifying it 
  7173. with its class name and the class scope operator. Whenever a name is followed 
  7174. by a :: operator, the name is interpreted as a class name. In the following 
  7175. example, the declaration of the variable X hides the class type X, but you can 
  7176. still use the static class member count by qualifying it with the class type X 
  7177. and the scope resolution operator. 
  7178.  
  7179. #include <iostream.h>
  7180. class X
  7181. {
  7182. public:
  7183.       static int count;
  7184. };
  7185. int X::count = 10;                // define static data member
  7186. void main ()
  7187. {
  7188.       int X = 0;                  // hides class type X
  7189.       cout << X::count << endl;   // use static member of class X
  7190. }
  7191.  
  7192. The scope resolution operator is also discussed in Class Names and in Scope of 
  7193. Class Names. 
  7194.  
  7195. Related Information 
  7196.  
  7197. o Class Names 
  7198. o Scope of Class Names 
  7199. o Expressions and Operators 
  7200.  
  7201.  
  7202. ΓòÉΓòÉΓòÉ 7.4.2. Parenthesized Expression ( ) ΓòÉΓòÉΓòÉ
  7203.  
  7204. You can use parentheses to explicitly force the order of expression evaluation. 
  7205. The following expression does not contain any parentheses used for grouping 
  7206. operands and operators.  The parentheses surrounding weight, zipcode are used 
  7207. to form a function call.  Notice how the operands and operators are grouped in 
  7208. this expression according to the rules for operator precedence and 
  7209. associativity: 
  7210.  
  7211.  
  7212. -discount * item + handling(weight, zipcode) < .10 * item
  7213. Γöé    Γöé    Γöé  Γöé            Γöé  Γöé     Γöé
  7214. ΓööΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÿ    Γöé  ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ  ΓööΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÿ
  7215.   ΓööΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ        Γöé           Γöé
  7216.      ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ           Γöé
  7217.           ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  7218.  
  7219. The following expression is similar to the previous expression.  This 
  7220. expression, however, contains parentheses that change how the operands and 
  7221. operators group: 
  7222.  
  7223.  
  7224. (-discount * (item + handling(weight, zipcode) ) ) < (.10 * item)
  7225.  Γöé    Γöé   Γöé    Γöé            Γöé    Γöé      Γöé
  7226.  ΓööΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÿ   Γöé    ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ    ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÿ
  7227.    Γöé     ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ              Γöé
  7228.    ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ                  Γöé
  7229.        ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  7230.  
  7231. In an expression that contains both associative and commutative operators, you 
  7232. can use parentheses to specify the grouping of operands with operators.  The 
  7233. parentheses in the following expression guarantee the order of grouping 
  7234. operands with the operators: 
  7235.  
  7236. x = f + (g + h);
  7237.  
  7238. Related Information 
  7239.  
  7240. o Operator Precedence 
  7241. o Function Call ( ) 
  7242. o Expressions and Operators 
  7243.  
  7244.  
  7245. ΓòÉΓòÉΓòÉ 7.4.3. Function Call ( ) ΓòÉΓòÉΓòÉ
  7246.  
  7247. A function call is a primary expression containing a parenthesized argument 
  7248. list.  The argument list can contain any number of expressions separated by 
  7249. commas.  For example: 
  7250.  
  7251. stub()
  7252. overdue(account, date, amount)
  7253. notify(name, date + 5)
  7254. report(error, time, date, ++num)
  7255.  
  7256. The arguments are evaluated, and each parameter is assigned the value of the 
  7257. corresponding argument.  Assigning a value to a parameter within the function 
  7258. body changes the value of the parameter within the function, but has no effect 
  7259. on the argument. 
  7260.  
  7261. When you define a function as returning a certain type, for example type int, 
  7262. the result of the function call has that type. 
  7263.  
  7264. If you want a function to change the value of a variable, pass a pointer to the 
  7265. variable you want changed. When a pointer is passed as a parameter, the pointer 
  7266. is copied;  the object pointed to is not copied.  (See Pointers.) 
  7267.  
  7268. All arrays and functions are converted to pointers when passed as function 
  7269. arguments. Arguments passed to nonprototyped functions undergo conversions: 
  7270. type short or char parameters will be converted to int, and float parameters to 
  7271. double. Use a cast expression for other conversions. (See Cast Expressions.) 
  7272.  
  7273. If the function has not been previously declared, an implicit declaration of 
  7274. extern int func(); is assumed. 
  7275.  
  7276. The compiler compares the data types provided by the calling function with the 
  7277. data types that the called function expects. The compiler may also perform type 
  7278. conversions if the declaration of the function is in function prototype format 
  7279. and the parameters differ from the prototype or visible at the point where the 
  7280. function is called. 
  7281.  
  7282. The order in which parameters are evaluated is not specified.  Avoid such calls 
  7283. as: 
  7284.  
  7285. method(samp1, bat.proc--, bat.proc);
  7286.  
  7287. In the preceding example, bat.proc-- may be evaluated last, causing the last 
  7288. two arguments to be passed with the same value. 
  7289.  
  7290. A function can call itself. 
  7291.  
  7292. Example of a Function Call 
  7293.  
  7294. Related Information 
  7295.  
  7296. o Functions 
  7297. o Pointers 
  7298. o Cast Expressions 
  7299. o Primary Expression 
  7300.  
  7301.  
  7302. ΓòÉΓòÉΓòÉ <hidden> Example of a Function Call ΓòÉΓòÉΓòÉ
  7303.  
  7304. /************************************************************************
  7305. *
  7306.  
  7307. In the following example, main passes func two values:  5 and 7.  The function 
  7308. func receives copies of these values and accesses them by the identifiers:  a 
  7309. and b.  The function func changes the value of a.  When control passes back to 
  7310. main, the actual values of x and y are not changed.  The called function func 
  7311. only receives copies of x and y, not the values themselves. 
  7312.  
  7313.                                                                         *
  7314. ************************************************************************/
  7315.  
  7316. #include <stdio.h>
  7317.  
  7318. int main(void)
  7319. {
  7320.    int x = 5, y = 7;
  7321.  
  7322.    func(x, y);
  7323.    printf("In main, x = %d    y = %d\n", x, y);
  7324. }
  7325.  
  7326. void func (int a, int b)
  7327. {
  7328.    a += b;
  7329.    printf("In func, a = %d    b = %d\n", a, b);
  7330. }
  7331.  
  7332. /************************************************************************
  7333. *
  7334.  
  7335. The preceding program produces the following output: 
  7336.  
  7337. In func, a = 12   b = 7
  7338. In main, x = 5    y = 7
  7339.  
  7340.                                                                         *
  7341. ************************************************************************/
  7342.  
  7343.  
  7344. ΓòÉΓòÉΓòÉ 7.4.4. Array Subscript  [ ] ΓòÉΓòÉΓòÉ
  7345.  
  7346. A primary expression followed by an expression in [ ] (square brackets) 
  7347. specifies an element of an array. The expression within the square brackets is 
  7348. referred to as a subscript. 
  7349.  
  7350. The primary expression must have a pointer type, and the subscript must have 
  7351. integral type.  The result of an array subscript is an lvalue. 
  7352.  
  7353. The first element of each array has the subscript 0. Thus, the expression 
  7354. contract[35] refers to the 36th element in the array contract. 
  7355.  
  7356. In a multidimensional array, you can reference each element (in the order of 
  7357. increasing storage locations) by incrementing the rightmost subscript most 
  7358. frequently.  For example, the following statement gives the value 100 to each 
  7359. element in the array code[4][3][6]: 
  7360.  
  7361. for (first = 0; first <= 3; ++first)
  7362.    for (second = 0; second <= 2; ++second)
  7363.       for (third = 0; third <= 5; ++third)
  7364.          code[first][second][third] = 100;
  7365.  
  7366. Related Information 
  7367.  
  7368. o Arrays 
  7369. o Lvalue 
  7370. o Primary Expression 
  7371.  
  7372.  
  7373. ΓòÉΓòÉΓòÉ 7.4.5. Dot Operator ΓòÉΓòÉΓòÉ
  7374.  
  7375. The . (dot) operator is a class access member operator that is used to access 
  7376. class members using a class object. A primary expression, followed by a . (dot) 
  7377. operator, followed by a name, designates a member of a class object. For 
  7378. example: 
  7379.  
  7380.    roster[num].name
  7381.    roster[num].name[1]
  7382.  
  7383. The primary expression must be a class object. Note that class objects can be 
  7384. of type class, struct, or union. The name must be a member of that class 
  7385. object. 
  7386.  
  7387. The value of the expression is the value of the selected member. If the primary 
  7388. expression and the name are lvalues, the expression value is also an lvalue. 
  7389.  
  7390. For more information on class members, see C++ Class Members and Friends. 
  7391.  
  7392. Related Information 
  7393.  
  7394. o Arrow Operator 
  7395. o C++ Class Members and Friends 
  7396. o Unions 
  7397. o Structures 
  7398. o Lvalue 
  7399. o Primary Expression 
  7400.  
  7401.  
  7402. ΓòÉΓòÉΓòÉ 7.4.6. Arrow Operator ΓòÉΓòÉΓòÉ
  7403.  
  7404. The -> (arrow) operator is a class access member operator that is used to 
  7405. access class members using a pointer. A primary expression, followed by an -> 
  7406. (arrow) operator, followed by a name, designates a member of the object to 
  7407. which the pointer points. For example: 
  7408.  
  7409.    roster -> name
  7410.  
  7411. The primary expression must be a pointer to a class object. Note that class 
  7412. objects can be of type class, struct, or union. The name must be a member of 
  7413. that class object. 
  7414.  
  7415. The value of the expression is the value of the selected member. If the name is 
  7416. an lvalue, the expression value is also an lvalue. 
  7417.  
  7418. For more information on class members, see C++ Class Members and Friends. 
  7419.  
  7420. Related Information 
  7421.  
  7422. o Dot Operator 
  7423. o C++ Class Members and Friends 
  7424. o Unions 
  7425. o Structures 
  7426. o Lvalue 
  7427. o Pointers 
  7428. o Primary Expression 
  7429.  
  7430.  
  7431. ΓòÉΓòÉΓòÉ 7.5. Unary Expression ΓòÉΓòÉΓòÉ
  7432.  
  7433. A unary expression contains one operand and a unary operator.  All unary 
  7434. operators have the same precedence and have right-to-left associativity. 
  7435.  
  7436. o Increment  ++ 
  7437. o Decrement  - - 
  7438. o Unary Plus  + 
  7439. o Unary Minus  - 
  7440. o Logical Negation  ! 
  7441. o Bitwise Negation  ~ 
  7442. o Address  & 
  7443. o Indirection  * 
  7444. o Cast Expressions 
  7445. o sizeof (Size of an Object) 
  7446. o new Operator 
  7447. o delete Operator 
  7448. o throw Expressions 
  7449.  
  7450. Related Information 
  7451.  
  7452. o Binary Expression 
  7453. o Expressions and Operators 
  7454. o Operator Precedence 
  7455.  
  7456.  
  7457. ΓòÉΓòÉΓòÉ 7.5.1. Increment  ++ ΓòÉΓòÉΓòÉ
  7458.  
  7459. The ++ (increment) operator adds 1 to the value of the scalar operand, or if 
  7460. the operand is a pointer, increments the operand by the size of the object to 
  7461. which it points. The operand receives the result of the increment operation. 
  7462. Thus, the operand must be a modifiable lvalue. 
  7463.  
  7464. You can place the ++ before or after the operand.  If it appears before the 
  7465. operand, the operand is incremented.  Then the incremented value is used in the 
  7466. expression.  If you place the ++ after the operand, the current value of the 
  7467. operand is used in the expression.  Then the operand is incremented.  For 
  7468. example: 
  7469.  
  7470. play = ++play1 + play2++;
  7471.  
  7472. is equivalent to the following three expressions: 
  7473.  
  7474. play1 = play1 + 1;
  7475. play  = play1 + play2;
  7476. play2 = play2 + 1;
  7477.  
  7478. The type of the increment expression is the same type as that of the operand. 
  7479.  
  7480. Related Information 
  7481.  
  7482. o Decrement  - - 
  7483. o Addition  + 
  7484. o Pointer Arithmetic 
  7485. o Unary Expression 
  7486. o Usual Arithmetic Conversions 
  7487.  
  7488.  
  7489. ΓòÉΓòÉΓòÉ 7.5.2. Decrement  - - ΓòÉΓòÉΓòÉ
  7490.  
  7491. The -- (decrement) operator subtracts 1 from the value of the scalar operand, 
  7492. or if the operand is a pointer, decreases the operand by the size of the object 
  7493. to which it points.  The operand receives the result of the decrement 
  7494. operation.  Thus, the operand must be a modifiable lvalue. 
  7495.  
  7496. You can place the -- before or after the operand.  If it appears before the 
  7497. operand, the operand is decremented, and the decremented value is used in the 
  7498. expression.  If the -- appears after the operand, the current value of the 
  7499. operand is used in the expression and the operand is decremented. 
  7500.  
  7501. For example: 
  7502.  
  7503. play = --play1 + play2--;
  7504.  
  7505. is equivalent to the following three expressions: 
  7506.  
  7507. play1 = play1 - 1;
  7508. play = play1 + play2;
  7509. play2 = play2 - 1;
  7510.  
  7511. The type of the decrement expression is the same type as that of the operand. 
  7512.  
  7513. Related Information 
  7514.  
  7515. o Increment  ++ 
  7516. o Subtraction  - 
  7517. o Pointer Arithmetic 
  7518. o Unary Expression 
  7519. o Usual Arithmetic Conversions 
  7520.  
  7521.  
  7522. ΓòÉΓòÉΓòÉ 7.5.3. Unary Plus  + ΓòÉΓòÉΓòÉ
  7523.  
  7524. The + (unary plus) operator maintains the value of the operand.  The operand 
  7525. can have any arithmetic type. The result is not an lvalue. 
  7526.  
  7527. The result of the unary plus expression has the same type as the operand after 
  7528. any integral promotions (for example, char to int). 
  7529.  
  7530. Note:  Any plus sign preceding a constant is not part of the constant. 
  7531.  
  7532. Related Information 
  7533.  
  7534. o Unary Minus  - 
  7535. o Unary Expression 
  7536. o Usual Arithmetic Conversions 
  7537.  
  7538.  
  7539. ΓòÉΓòÉΓòÉ 7.5.4. Unary Minus  - ΓòÉΓòÉΓòÉ
  7540.  
  7541. The - (unary minus) operator negates the value of the operand.  The operand can 
  7542. have any arithmetic type.  The result is not an lvalue. 
  7543.  
  7544. For example, if quality has the value 100, -quality has the value -100. 
  7545.  
  7546. The result of the unary minus expression has the same type as the operand after 
  7547. any integral promotions (for example, char to int). 
  7548.  
  7549. Note:  Any minus sign preceding a constant is not part of the constant. 
  7550.  
  7551. Related Information 
  7552.  
  7553. o Unary Plus  + 
  7554. o Unary Expression 
  7555. o Usual Arithmetic Conversions 
  7556.  
  7557.  
  7558. ΓòÉΓòÉΓòÉ 7.5.5. Logical Negation  ! ΓòÉΓòÉΓòÉ
  7559.  
  7560. The ! (logical negation) operator determines whether the operand evaluates to 0 
  7561. (false) or nonzero (true). The expression yields the value 1 (true) if the 
  7562. operand evaluates to 0, and yields the value 0 (false) if the operand evaluates 
  7563. to a nonzero value. The operand must have a scalar data type, but the result of 
  7564. the operation has always type int and is not an lvalue. 
  7565.  
  7566. The following two expressions are equivalent: 
  7567.  
  7568. !right;
  7569. right == 0;
  7570.  
  7571. Related Information 
  7572.  
  7573. o Equality  ==  != 
  7574. o Relational  <  >  <=  >= 
  7575. o Unary Expression 
  7576. o Usual Arithmetic Conversions 
  7577.  
  7578.  
  7579. ΓòÉΓòÉΓòÉ 7.5.6. Bitwise Negation  ~ ΓòÉΓòÉΓòÉ
  7580.  
  7581. The ~ (bitwise negation) operator yields the bitwise complement of the operand. 
  7582. In the binary representation of the result, every bit has the opposite value of 
  7583. the same bit in the binary representation of the operand.  The operand must 
  7584. have an integral type.  The result has the same type as the operand but is not 
  7585. an lvalue. 
  7586.  
  7587. Suppose x represents the decimal value 5.  The  16-bit binary representation of 
  7588. x is: 
  7589.  
  7590. 0000000000000101
  7591.  
  7592. The expression ~x yields the following result (represented here as a 16-bit 
  7593. binary number): 
  7594.  
  7595. 1111111111111010
  7596.  
  7597. Note that the ~ character can be represented by the trigraph ??-. 
  7598.  
  7599. The 16-bit binary representation of ~0 is: 
  7600.  
  7601. 1111111111111111
  7602.  
  7603. Related Information 
  7604.  
  7605. o Bitwise Left and Right Shift  <<  >> 
  7606. o Bitwise AND  & 
  7607. o Bitwise Exclusive OR  ^ 
  7608. o Bitwise Inclusive OR  | 
  7609. o Unary Expression 
  7610. o Usual Arithmetic Conversions 
  7611.  
  7612.  
  7613. ΓòÉΓòÉΓòÉ 7.5.7. Address  & ΓòÉΓòÉΓòÉ
  7614.  
  7615. The & (address) operator yields a pointer to its operand. The operand must be 
  7616. an lvalue, a function designator, or a qualified name. It cannot be a bit 
  7617. field, nor can it have the storage class specifier register. 
  7618.  
  7619. If the operand is an lvalue or function, the resulting type is a pointer to the 
  7620. expression type. For example, if the expression has type int, the result is a 
  7621. pointer to an object having type int.  If the operand is a qualified name and 
  7622. the member is not static, the result is a pointer to a member of class and has 
  7623. the same type as the member. The result is not an lvalue. 
  7624.  
  7625. If p_to_y is defined as a pointer to an int and y as an int, the following 
  7626. expression assigns the address of the variable y to the pointer p_to_y: 
  7627.  
  7628. p_to_y = &y;
  7629.  
  7630. You can use the & operator with overloaded functions only in an initialization 
  7631. or assignment where the left side uniquely determines which version of the 
  7632. overloaded function is used.  For more information, see Overloading Functions. 
  7633.  
  7634. Related Information 
  7635.  
  7636. o Pointers 
  7637. o Lvalue 
  7638. o register Storage Class Specifier 
  7639. o Overloading Functions 
  7640. o Unary Expression 
  7641.  
  7642.  
  7643. ΓòÉΓòÉΓòÉ 7.5.8. Indirection  * ΓòÉΓòÉΓòÉ
  7644.  
  7645. The * (indirection) operator determines the value referred to by the 
  7646. pointer-type operand. The operand cannot be a pointer to void. The operation 
  7647. yields an lvalue or a function designator if the operand points to a function. 
  7648. Arrays and functions are converted to pointers. 
  7649.  
  7650. The type of the operand determines the type of the result.  Thus, if the 
  7651. operand is a pointer to an int, the result has type int. 
  7652.  
  7653. Do not apply the indirection operator to any pointer that contains an address 
  7654. that is not valid, such as NULL.  The result of applying an indirection 
  7655. operator to such a pointer is not defined. 
  7656.  
  7657. If p_to_y is defined as a pointer to an int and y as an int, the expressions: 
  7658.  
  7659. p_to_y = &y;
  7660. *p_to_y = 3;
  7661.  
  7662. cause the variable y to receive the value 3. 
  7663.  
  7664. Related Information 
  7665.  
  7666. o Pointers 
  7667. o Lvalue 
  7668. o Functions 
  7669. o Unary Expression 
  7670.  
  7671.  
  7672. ΓòÉΓòÉΓòÉ 7.5.9. Cast Expressions ΓòÉΓòÉΓòÉ
  7673.  
  7674. The cast operator is used for explicit type conversions. The () (cast) operator 
  7675. converts the value of the operand to a specified data type and performs the 
  7676. necessary conversions to the operand for the type. For C, the operand must be 
  7677. scalar and the type must be either scalar or void. For C++, the operand can 
  7678. have class type. If the operand has class type, it can be cast to any type for 
  7679. which the class has a user-defined conversion function. User-defined conversion 
  7680. functions are described in Conversion Functions. 
  7681.  
  7682. The result of a cast is not an lvalue unless the cast is to a reference type. 
  7683. When you cast to a reference type, no user-defined conversions are performed 
  7684. and the result is an lvalue. 
  7685.  
  7686. There are two types of casts that take one argument: 
  7687.  
  7688. o C-style casts, with the format (X)a. These are the only casts allowed in C. 
  7689. o function-style casts with one argument, such as X(a) These are allowed in C++ 
  7690.   only. 
  7691.  
  7692. Both types of casts convert the argument a to the type X. They can invoke a 
  7693. constructor, if the target type is a class, or they can invoke a conversion 
  7694. function, if the source type is a class. They can be ambiguous if both 
  7695. conditions hold. 
  7696.  
  7697. A function-style cast with no arguments, such as X(), creates a temporary 
  7698. object of type X. If X is a class with constructors, the default constructor 
  7699. X::X() is called. 
  7700.  
  7701. A function-style cast with more than one argument, such as X(a,b), creates a 
  7702. temporary object of type X. This object must be a class with a constructor that 
  7703. takes two arguments of types compatible with the types of a and b. The 
  7704. constructor is called with a and b as arguments. 
  7705.  
  7706. Related Information 
  7707.  
  7708. o Conversions 
  7709. o Conversion by Constructor 
  7710. o Conversion Functions 
  7711. o Types 
  7712.  
  7713.  
  7714. ΓòÉΓòÉΓòÉ 7.5.10. sizeof (Size of an Object) ΓòÉΓòÉΓòÉ
  7715.  
  7716. The sizeof operator yields the size in bytes of the operand. The sizeof 
  7717. operation cannot be performed on a bit field, a function, an undefined class, 
  7718. an array with unspecified dimensions, or an incomplete type such as void. The 
  7719. operand may be the parenthesized name of a type. 
  7720.  
  7721. The compiler must be able to evaluate the size at compile time. The expression 
  7722. is not evaluated;  there are no side effects. For example, the value of b is 5 
  7723. from initialization to program termination: 
  7724.  
  7725. #include <stdio.h>
  7726.  
  7727. int main(void){
  7728.   int b = 5;
  7729.   sizeof(b++);
  7730. }
  7731.  
  7732. The size of a char object is the size of a byte.  Given that the variable x has 
  7733. type char, the expression sizeof(x) always evaluates to 1. 
  7734.  
  7735. The result of a sizeof operation has type size_t.  size_t is an unsigned 
  7736. integral type defined in the <stddef.h> header. 
  7737.  
  7738. The compiler determines the size of an object on the basis of its definition. 
  7739. The sizeof operator does not perform any conversions.  However, if the operand 
  7740. contains operators that perform conversions, the compiler takes these 
  7741. conversions into consideration.  The following expression causes the usual 
  7742. arithmetic conversions to be performed. The result of the expression x + 1 has 
  7743. type int (if x has type char, short, or int or any enumeration type) and is 
  7744. equivalent to sizeof(int): 
  7745.  
  7746. sizeof (x + 1)
  7747.  
  7748. When you perform the sizeof operation on an array, the result is the total 
  7749. number of bytes in the array.  The compiler does not convert the array to a 
  7750. pointer before evaluating the expression. 
  7751.  
  7752. When you perform the sizeof operation on a class, the result is always nonzero 
  7753. and is equal to the number of bytes in an object of that class including any 
  7754. padding required for placing class objects in an array. 
  7755.  
  7756. When you perform the sizeof operation on a reference, the result is the size of 
  7757. the referenced object. 
  7758.  
  7759. You can use a sizeof expression wherever a constant or unsigned constant is 
  7760. required.  One of the most common uses for the sizeof operator is to determine 
  7761. the size of objects that are being communicated to or from storage allocation, 
  7762. input, and output functions. 
  7763.  
  7764. For portability of code, you should use the sizeof operator to determine the 
  7765. size that a data type represents.  In this instance, the name of the data type 
  7766. must be placed in parentheses after the sizeof operator.  For example: 
  7767.  
  7768. sizeof(int)
  7769.  
  7770. Related Information 
  7771.  
  7772. o Constant Expression 
  7773. o Conversions 
  7774. o Types 
  7775. o Unary Expression 
  7776.  
  7777.  
  7778. ΓòÉΓòÉΓòÉ 7.5.11. new Operator ΓòÉΓòÉΓòÉ
  7779.  
  7780. The new operator provides dynamic storage allocation. The syntax for an 
  7781. allocation expression containing the new operator is: 
  7782.  
  7783. >>ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇnewΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓö¼ΓöÇ(type)ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ>
  7784.   ΓööΓöÇ::ΓöÇΓöÿ    ΓööΓöÇ(argument_list)ΓöÇΓöÿ  ΓööΓöÇnew_typeΓöÇΓöÿ
  7785. >ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ><
  7786.   ΓööΓöÇ(ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ)ΓöÇΓöÿ
  7787.     ΓööΓöÇinitial_valueΓöÇΓöÿ
  7788.  
  7789. If you prefix new with ::, the global operator new() is used. If you specify an 
  7790. argument_list, the overloaded new operator that corresponds to that 
  7791. argument_list is used. The type is an existing built-in or user-defined type. A 
  7792. new_type is a type that has not already been defined and can include type 
  7793. specifiers and declarators. 
  7794.  
  7795. An allocation expression containing the new operator is used to find storage in 
  7796. free store for the object being created. The new-expression returns a pointer 
  7797. to the object created and can be used to initialize the object. If the object 
  7798. is an array, a pointer to the initial element is returned. 
  7799.  
  7800. You can use the routine set_new_handler to change the default behavior of new. 
  7801. You can also use the /Tm option to enable the debug version of new, as 
  7802. described in Debug Versions of new and delete. 
  7803.  
  7804. You cannot use the new operator to allocate function types, void, or incomplete 
  7805. class types because these are not object types. However, you can allocate 
  7806. pointers to functions with the new operator. You cannot create a reference with 
  7807. the new operator. 
  7808.  
  7809. When the object being created is an array, only the first dimension can be a 
  7810. general expression. All subsequent dimensions must be constant integral 
  7811. expressions. The first dimension can be a general expression even when an 
  7812. existing type is used. You can create an array with zero bounds with the new 
  7813. operator. For example: 
  7814.  
  7815. char * c = new char[0];
  7816. In this case, a pointer to a unique object is returned. 
  7817.  
  7818. An object created with operator new() or operator new[]() exists until the 
  7819. operator delete() is called to deallocate the object's memory, or until program 
  7820. ends. 
  7821.  
  7822. If parentheses are used within a new_type, parentheses should also surround the 
  7823. new_type to prevent syntax errors. 
  7824.  
  7825. Example of Allocating Storage with new() 
  7826.  
  7827. The type of the object being created cannot include class declarations, 
  7828. enumeration declarations, or const or volatile types. It can include pointers 
  7829. to const or volatile objects. For example, const char* is allowed, but char* 
  7830. const is not. 
  7831.  
  7832. Additional arguments can be supplied to new by using the argument_list, also 
  7833. called the placement syntax. If placement arguments are used, a declaration of 
  7834. operator new() with these arguments must exist. For example: 
  7835.  
  7836. #include <stddef.h>
  7837. class X
  7838. {
  7839. public:
  7840.       void* operator new(size_t,int, int){ /* ... */ }
  7841. };
  7842. void main ()
  7843. {
  7844.       X* ptr = new(1,2) X;
  7845. }
  7846.  
  7847. Additional information is provided on: 
  7848.  
  7849. o Member Functions and the Global operator new() 
  7850. o Initializing Objects Created with the new Operator 
  7851.  
  7852. Related Information 
  7853.  
  7854. o set_new_handler - Set Behavior for new Failure 
  7855. o Overloaded new and delete 
  7856. o Debug Versions of new and delete 
  7857. o Constructors and Destructors Overview 
  7858. o Free Store 
  7859. o delete Operator 
  7860. o Unary Expression 
  7861.  
  7862.  
  7863. ΓòÉΓòÉΓòÉ <hidden> Member Functions and the Global operator new() ΓòÉΓòÉΓòÉ
  7864.  
  7865. When an object of a class type is created with the new operator, the member 
  7866. operator new() function is implicitly called. The first argument is the amount 
  7867. of space requested. 
  7868.  
  7869. The following rules determine which storage allocation function is used: 
  7870.  
  7871.  1. If your own operator new() exists, and the :: operator is not used, your 
  7872.     operator new() is used. 
  7873.  
  7874.  2. If you have not defined an operator new() function, the global ::operator 
  7875.     new() function defined in <new.h> is used. The allocation expression of the 
  7876.     form ::operator new() ensures that the global new operator is called, 
  7877.     rather than your class member operator. 
  7878.  
  7879.  
  7880. ΓòÉΓòÉΓòÉ <hidden> Initializing Objects Created with the new Operator ΓòÉΓòÉΓòÉ
  7881.  
  7882. You can initialize objects created with the new operator in several ways. For 
  7883. nonclass objects, or for class objects without constructors, a new-initializer 
  7884. expression can be provided in a new-expression by specifying ( expression ) or 
  7885. (). For example: 
  7886.  
  7887. double* pi = new double(3.1415926);
  7888. int* score = new int(89);
  7889. float* unknown = new float();
  7890.  
  7891. If a class has a constructor, the new-initializer must be provided when any 
  7892. object of that class is allocated. The arguments of the new-initializer must 
  7893. match the arguments of a class constructor, unless the class has a default 
  7894. constructor. 
  7895.  
  7896. You cannot specify an initializer for arrays. You can initialize an array of 
  7897. class objects only if the class has a default constructor. The constructor is 
  7898. called to initialize each array element (class object). 
  7899.  
  7900. Initialization using the new-initializer is performed only if new successfully 
  7901. allocates storage. 
  7902.  
  7903.  
  7904. ΓòÉΓòÉΓòÉ <hidden> Example of Allocating Storage with new() ΓòÉΓòÉΓòÉ
  7905.  
  7906. /***********************************************************************
  7907. *
  7908.  
  7909. In the following example, storage is allocated for an array of pointers to 
  7910. functions: 
  7911.  
  7912.                                                                         *
  7913. ************************************************************************/
  7914.  
  7915. void f();
  7916. void g();
  7917. void main()
  7918. {
  7919.       void (**p)(), (**q)();
  7920.       // declare p and q as pointers to pointers to void functions
  7921.       p = new (void (*[3])());
  7922.       // p now points to an array of pointers to functions
  7923.       q = new void(*[3])(); // error
  7924.       // error - bound as 'q = (new void) (*[3])();'
  7925.       p[0] = f;  // p[0] to point to function f
  7926.       q[2] = g;  // q[2] to point to function g
  7927.       p[0]();    // call f()
  7928.       q[2]();    // call g()
  7929. }
  7930.  
  7931. /************************************************************************
  7932. *
  7933.  
  7934. However, the second use of new causes an erroneous binding of q = (new void) 
  7935. (*[3])(). 
  7936.  
  7937.                                                                         *
  7938. ************************************************************************/
  7939.  
  7940.  
  7941. ΓòÉΓòÉΓòÉ 7.5.11.1. set_new_handler - Set Behavior for new Failure ΓòÉΓòÉΓòÉ
  7942.  
  7943. When the new operator creates a new object, it calls the operator new() 
  7944. function to obtain the needed storage. 
  7945.  
  7946. When new cannot allocate storage, it calls a new-handler function if one has 
  7947. been installed by a call to set_new_handler(). You can use the set_new_handler 
  7948. function, defined in <new.h>, to call the default new-handler or one of your 
  7949. own. 
  7950.  
  7951. The set_new_handler function has the prototype: 
  7952.  
  7953.    int set_new_handler(*function);
  7954.  
  7955. If you do not specify your own set_new_handler function, new returns the NULL 
  7956. pointer. 
  7957.  
  7958. Example of set_new_handler 
  7959.  
  7960. Related Information 
  7961.  
  7962. o new Operator 
  7963. o Member Function and the Global operator new() 
  7964. o Initializing Objects Created with the new Operator 
  7965. o Overloaded new and delete 
  7966. o Constructors and Destructors Overview 
  7967. o Free Store 
  7968.  
  7969.  
  7970. ΓòÉΓòÉΓòÉ <hidden> Example of set_new_handler ΓòÉΓòÉΓòÉ
  7971.  
  7972. The following program segment shows how you could use set_new_handler to return 
  7973. a message if the new operator cannot allocate storage: 
  7974.  
  7975. #include <stream.h>
  7976. #include <new.h>
  7977. void no_storage()
  7978. {
  7979.     cerr << "Operator new failed: no storage is available.\n";
  7980.       exit(1);
  7981. }
  7982. main()
  7983. {
  7984.      set_new_handler(&no_storage);
  7985.    // Rest of program ...
  7986. }
  7987.  
  7988. If the program fails because new cannot allocate storage, the program exits 
  7989. with the message: 
  7990.  
  7991.  Operator new failed: no storage is available.
  7992.  
  7993.  
  7994. ΓòÉΓòÉΓòÉ 7.5.12. delete Operator ΓòÉΓòÉΓòÉ
  7995.  
  7996. The delete operator destroys the object created with new by deallocating the 
  7997. memory associated with the object. 
  7998.  
  7999. The delete operator has a void return type. It has the syntax: 
  8000.  
  8001. >>ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇdeleteΓöÇΓöÇobject_pointerΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ><
  8002.   ΓööΓöÇ::ΓöÇΓöÿ
  8003.  
  8004. For example:   delete myobj; 
  8005.  
  8006. The operand of delete must be a pointer returned by new, and cannot be a 
  8007. pointer to constant. If an attempt to create an object with new fails, the 
  8008. pointer returned by new will have a zero value, but it can still be used with 
  8009. delete. Deleting a null pointer has no effect. 
  8010.  
  8011. The delete[] operator frees storage allocated for array objects created with 
  8012. new.. The delete frees storage allocated for individual objects created with 
  8013. new. It has the syntax: 
  8014.  
  8015. >>ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇdeleteΓöÇΓöÇ[ΓöÇΓöÇ]ΓöÇΓöÇarrayΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ><
  8016.   ΓööΓöÇ::ΓöÇΓöÿ
  8017.  
  8018. For example:   delete [] myarray; 
  8019.  
  8020. The result of deleting an array object with delete is undefined, as is deleting 
  8021. an individual object with delete[]. The array dimensions do not need to be 
  8022. specified with delete[]. 
  8023.  
  8024. The results of attempting to access a deleted object are undefined because the 
  8025. deletion of an object can change its value. 
  8026.  
  8027. If a destructor has been defined for a class, delete invokes that destructor. 
  8028. Whether a destructor exists or not, delete frees the storage pointed to by 
  8029. calling the function operator delete() of the class if one exists. 
  8030.  
  8031. The global ::operator delete() is used if: 
  8032.  
  8033. o The class has no operator delete(). 
  8034. o The object is of a nonclass type. 
  8035. o The object is deleted with the ::delete expression. For example:   ::delete 
  8036.   p; 
  8037.  
  8038. The default global operator delete() only frees storage allocated by the 
  8039. default global operator new(). The default global operator delete[]() only 
  8040. frees storage allocated for arrays by the default global operator new(). 
  8041.  
  8042. You can also use the /Tm compiler option to enable a debug version of the 
  8043. delete operator, as described in Debug Versions of new and delete. 
  8044.  
  8045. Related Information 
  8046.  
  8047. o Overloaded new and delete 
  8048. o Debug Versions of new and delete 
  8049. o Constructors and Destructors Overview 
  8050. o Free Store 
  8051. o new Operator 
  8052. o Unary Expression 
  8053.  
  8054.  
  8055. ΓòÉΓòÉΓòÉ 7.5.13. throw Expressions ΓòÉΓòÉΓòÉ
  8056.  
  8057. A throw expression is used to throw exceptions to C++ exception handlers. It 
  8058. causes control to be passed out of the block enclosing the throw statement to 
  8059. the first C++ exception handler whose catch argument matches the throw 
  8060. expression. A throw expression is a unary expression of type void. 
  8061.  
  8062. For more information on the throw expression, see Exception Handling. 
  8063.  
  8064. Related Information 
  8065.  
  8066. o Exception Handling 
  8067. o Unary Expression 
  8068.  
  8069.  
  8070. ΓòÉΓòÉΓòÉ 7.6. Binary Expression ΓòÉΓòÉΓòÉ
  8071.  
  8072. A binary expression contains two operands separated by one operator. 
  8073.  
  8074. Not all binary operators have the same precedence. The table in the section 
  8075. Operator Precedence shows the order of precedence among operators.  All binary 
  8076. operators have left-to-right associativity. 
  8077.  
  8078. The order in which the operands of most binary operators are evaluated is not 
  8079. specified. Therefore, to ensure correct results, avoid creating binary 
  8080. expressions that depend on the order in which the compiler evaluates the 
  8081. operands. 
  8082.  
  8083. o Pointer to Member Operators  .*  ->* 
  8084. o Multiplication  * 
  8085. o Division  / 
  8086. o Remainder  % 
  8087. o Addition  + 
  8088. o Subtraction  - 
  8089. o Bitwise Left and Right Shift  <<  >> 
  8090. o Relational  <  >  <=  >= 
  8091. o Equality  ==  != 
  8092. o Bitwise AND  & 
  8093. o Bitwise Exclusive OR  ^ 
  8094. o Bitwise Inclusive OR  | 
  8095. o Logical AND  && 
  8096. o Logical OR  || 
  8097.  
  8098. Related Information 
  8099.  
  8100. o Unary Expression 
  8101. o Expressions and Operators 
  8102. o Operator Precedence 
  8103.  
  8104.  
  8105. ΓòÉΓòÉΓòÉ 7.6.1. Pointer to Member Operators  .*  ->* ΓòÉΓòÉΓòÉ
  8106.  
  8107. The .* operator is used to dereference pointers to class members. The first 
  8108. operand must be a class type. If the type of the first operand is class type T, 
  8109. or is a class that has been derived from class type T, the second operand must 
  8110. be a pointer to a member of a class type T. 
  8111.  
  8112. The ->* operator is also used to dereference pointers to class members. The 
  8113. first operand must be a pointer to a class type. If the type of the first 
  8114. operand is a pointer to class type T, or is a pointer to a class derived from 
  8115. class type T, the second operand must be a pointer to a member of class type T. 
  8116.  
  8117. The .* and ->* operators bind the second operand to the first, resulting in an 
  8118. object or function of the type specified by the second operand. 
  8119.  
  8120. If the result of.* or ->* is a function, you can only use the result as the 
  8121. operand for the ( ) (function call) operator. If the second operand is an 
  8122. lvalue, the result of .* or ->* is an lvalue. 
  8123.  
  8124. For more information on pointer to member operators, see Pointers to Members. 
  8125.  
  8126. Related Information 
  8127.  
  8128. o Pointers to Members 
  8129. o Pointers 
  8130. o C++ Classes 
  8131. o Binary Expression 
  8132.  
  8133.  
  8134. ΓòÉΓòÉΓòÉ 7.6.2. Multiplication  * ΓòÉΓòÉΓòÉ
  8135.  
  8136. The * (multiplication) operator yields the product of its operands.  The 
  8137. operands must have an arithmetic type.  The result is not an lvalue. 
  8138.  
  8139. Because the multiplication operator has both associative and commutative 
  8140. properties, the compiler may rearrange the operands in an expression that 
  8141. contains more than one multiplication operator. For example, the expression: 
  8142.  
  8143. sites * number * cost
  8144.  
  8145. can be interpreted in any of the following ways: 
  8146.  
  8147. (sites * number) * cost
  8148. sites * (number * cost)
  8149. (cost * sites) * number
  8150.  
  8151. Related Information 
  8152.  
  8153. o Division  / 
  8154. o Remainder  % 
  8155. o Binary Expression 
  8156. o Usual Arithmetic Conversions 
  8157.  
  8158.  
  8159. ΓòÉΓòÉΓòÉ 7.6.3. Division  / ΓòÉΓòÉΓòÉ
  8160.  
  8161. The / (division) operator yields the quotient of its operands.  The operands 
  8162. must have an arithmetic type. The result is not an lvalue. 
  8163.  
  8164. If both operands are positive integers and the operation produces a remainder, 
  8165. the remainder is ignored. Thus, the expression 7 / 4 yields the value 1 (rather 
  8166. than 1.75 or 2). 
  8167.  
  8168. For SAA-compliant compilers, including the C/C++ Tools compiler, the result of 
  8169. -7 /4 is -1 with a remainder of -3, assuming both -7 and 4 are signed.  If 4 is 
  8170. unsigned, -7 is converted to unsigned. 
  8171.  
  8172. The result is undefined if the second operand evaluates to 0. 
  8173.  
  8174. Related Information 
  8175.  
  8176. o Multiplication  * 
  8177. o Remainder  % 
  8178. o Binary Expression 
  8179. o Usual Arithmetic Conversions 
  8180.  
  8181.  
  8182. ΓòÉΓòÉΓòÉ 7.6.4. Remainder  % ΓòÉΓòÉΓòÉ
  8183.  
  8184. The % (remainder) operator yields the remainder from the division of the left 
  8185. operand by the right operand.  For example, the expression 5 % 3 yields 2.  The 
  8186. result is not an lvalue. 
  8187.  
  8188. Both operands must have an integral type.  If the right operand evaluates to 0, 
  8189. the result is undefined.  If either operand has a negative value, the result is 
  8190. such that the following expression always yields the value of a if b is not 0 
  8191. and a/b is representable: 
  8192.  
  8193.    ( a / b ) * b + a % b;
  8194.  
  8195. Related Information 
  8196.  
  8197. o Multiplication  * 
  8198. o Division  / 
  8199. o Binary Expression 
  8200. o Usual Arithmetic Conversions 
  8201.  
  8202.  
  8203. ΓòÉΓòÉΓòÉ 7.6.5. Addition  + ΓòÉΓòÉΓòÉ
  8204.  
  8205. The + (addition) operator yields the sum of its operands.  Both operands must 
  8206. have an arithmetic type, or the first operand must be a pointer to an object 
  8207. type and the other operand must have an integral type. 
  8208.  
  8209. When both operands have an arithmetic type, the usual arithmetic conversions on 
  8210. the operands are performed. The result has the type produced by the conversions 
  8211. on the operands and is not an lvalue. 
  8212.  
  8213. When one of the operands is a pointer, the compiler converts the other operand 
  8214. to an address offset. The result is a pointer of the same type as the pointer 
  8215. operand. 
  8216.  
  8217. Related Information 
  8218.  
  8219. o Pointers 
  8220. o Unary Plus  + 
  8221. o Subtraction  - 
  8222. o Binary Expression 
  8223. o Usual Arithmetic Conversions 
  8224.  
  8225.  
  8226. ΓòÉΓòÉΓòÉ 7.6.6. Subtraction  - ΓòÉΓòÉΓòÉ
  8227.  
  8228. The - (subtraction) operator yields the difference of its operands.  Both 
  8229. operands must have an arithmetic type, or the left operand must have a pointer 
  8230. type and the right operand must have the same pointer type or an integral type. 
  8231.  
  8232. When both operands have an arithmetic type, the usual arithmetic conversions on 
  8233. the operands are performed. The result has the type produced by the conversions 
  8234. on the operands and is not an lvalue. 
  8235.  
  8236. When the left operand is a pointer and the right operand has an integral type, 
  8237. the compiler converts the value of the right to an address offset. The result 
  8238. is a pointer of the same type as the pointer operand. 
  8239.  
  8240. If both operands are pointers to the same type, the compiler converts the 
  8241. result to an integral type that represents the number of objects separating the 
  8242. two addresses. Behavior is undefined if the pointers do not refer to objects in 
  8243. the same array. 
  8244.  
  8245. Related Information 
  8246.  
  8247. o Pointers 
  8248. o Unary Minus  - 
  8249. o Addition  + 
  8250. o Binary Expression 
  8251. o Usual Arithmetic Conversions 
  8252.  
  8253.  
  8254. ΓòÉΓòÉΓòÉ 7.6.7. Bitwise Left and Right Shift  <<  >> ΓòÉΓòÉΓòÉ
  8255.  
  8256. The bitwise shift operators move the bit values of a binary object.  The left 
  8257. operand specifies the value to be shifted.  The right operand specifies the 
  8258. number of positions that the bits in the value are to be shifted.  The result 
  8259. is not an lvalue. 
  8260.  
  8261. The << (bitwise left shift) operator indicates the bits are to be shifted to 
  8262. the left.  The >> (bitwise right shift) operator indicates the bits are to be 
  8263. shifted to the right. 
  8264.  
  8265. Each operand must have an integral type.  The compiler performs integral 
  8266. promotions on the operands.  Then the right operand is converted to type int. 
  8267. The result has the same type as the left operand (after the arithmetic 
  8268. conversions). 
  8269.  
  8270. If the right operand has a negative value or a value that is greater than or 
  8271. equal to the width in bits of the expression being shifted, the result is 
  8272. undefined. 
  8273.  
  8274. If the right operand has the value 0, the result is the value of the left 
  8275. operand (after the usual arithmetic conversions). 
  8276.  
  8277. The << operator fills vacated bits with zeros.  For example, if l_op has the 
  8278. value 4019, the bit pattern (in 16-bit format) of l_op is: 
  8279.  
  8280. 0000111110110011
  8281.  
  8282. The expression l_op << 3 yields: 
  8283.  
  8284. 0111110110011000
  8285.  
  8286. If the left operand has an unsigned type, the >> operator fills vacated bits 
  8287. with zeros.  Otherwise, the compiler will fill the vacated bits of a signed 
  8288. value with a copy of the value's sign bit. For example, if l_op has the value 
  8289. -25, the bit pattern (in 16-bit format) of l_op is: 
  8290.  
  8291. 1111111111100111
  8292.  
  8293. The expression l_op >> 3 yields: 
  8294.  
  8295. 1111111111111100
  8296.  
  8297. Related Information 
  8298.  
  8299. o Bitwise Negation  ~ 
  8300. o Bitwise AND  & 
  8301. o Bitwise Exclusive OR  ^ 
  8302. o Bitwise Inclusive OR  | 
  8303. o Binary Expression 
  8304. o Usual Arithmetic Conversions 
  8305.  
  8306.  
  8307. ΓòÉΓòÉΓòÉ 7.6.8. Relational  <  >  <=  >= ΓòÉΓòÉΓòÉ
  8308.  
  8309. The relational operators compare two operands and determine the validity of a 
  8310. relationship.  If the relationship stated by the operator is true, the value of 
  8311. the result is 1.  Otherwise, the value of the result is 0. 
  8312.  
  8313. The following table describes the relational operators: 
  8314.  
  8315. Operator   Usage 
  8316. <          Indicates whether the value of the left operand is less than the 
  8317.            value of the right operand. 
  8318. >          Indicates whether the value of the left operand is greater than the 
  8319.            value of the right operand. 
  8320. <=         Indicates whether the value of the left operand is less than or 
  8321.            equal to the value of the right operand. 
  8322. >=         Indicates whether the value of the left operand is greater than or 
  8323.            equal to the value of the right operand. 
  8324.  
  8325. Both operands must have arithmetic types or be pointers to the same type. The 
  8326. result has type int. If the operands have arithmetic types, the usual 
  8327. arithmetic conversions on the operands are performed. 
  8328.  
  8329. When the operands are pointers, the result is determined by the locations of 
  8330. the objects to which the pointers refer.  If the pointers do not refer to 
  8331. objects in the same array, the result is not defined. 
  8332.  
  8333. A pointer can be compared to a constant expression that evaluates to 0.  You 
  8334. can also compare a pointer to a pointer of type void*. The pointer is converted 
  8335. to a  pointer of type void*. 
  8336.  
  8337. If two pointers refer to the same object, they are considered equal.  If two 
  8338. pointers refer to nonstatic members of the same object, the pointer to the 
  8339. object declared later has the higher address value.  If two pointers refer to 
  8340. data members of the same union, they have the same address value. 
  8341.  
  8342. If two pointers refer to elements of the same array, or to the first element 
  8343. beyond the last element of an array, the pointer to the element with the higher 
  8344. subscript value has the higher address value. 
  8345.  
  8346. You can only compare members of the same object with relational operators. 
  8347.  
  8348. Relational operators have left-to-right associativity.  Therefore, the 
  8349. expression: 
  8350.  
  8351. a < b <= c
  8352.  
  8353. is interpreted as: 
  8354.  
  8355. (a < b) <= c
  8356.  
  8357. If the value of a is less than the value of b, the first relationship is true 
  8358. and yields the value 1.  The compiler then compares the value 1 with the value 
  8359. of c. 
  8360.  
  8361. Related Information 
  8362.  
  8363. o Equality  ==  != 
  8364. o Logical Negation  ! 
  8365. o Pointers 
  8366. o Binary Expression 
  8367. o Usual Arithmetic Conversions 
  8368.  
  8369.  
  8370. ΓòÉΓòÉΓòÉ 7.6.9. Equality  ==  != ΓòÉΓòÉΓòÉ
  8371.  
  8372. The equality operators, like the relational operators, compare two operands for 
  8373. the validity of a relationship.  The equality operators, however, have a lower 
  8374. precedence than the relational operators.  If the relationship stated by an 
  8375. equality operator is true, the value of the result is 1.  Otherwise, the value 
  8376. of the result is 0. 
  8377.  
  8378. The following table describes the equality operators: 
  8379.  
  8380. Operator   Usage 
  8381. ==         Indicates whether the value of the left operand is equal to the 
  8382.            value of the right operand. 
  8383. !=         Indicates whether the value of the left operand is not equal to the 
  8384.            value of the right operand. 
  8385.  
  8386. Both operands must have arithmetic types or be pointers to the same type, or 
  8387. one operand must have a pointer type and the other operand must be a pointer to 
  8388. void or NULL.  The result has type int. 
  8389.  
  8390. If the operands have arithmetic types, the usual arithmetic conversions on the 
  8391. operands are performed. If the operands are pointers, the result is determined 
  8392. by the locations of the objects to which the pointers refer. 
  8393.  
  8394. If one operand is a pointer and the other operand is an integer having the 
  8395. value 0, the expression is true only if the pointer operand evaluates to NULL. 
  8396.  
  8397. You can also use the equality operators to compare pointers to members that are 
  8398. of the same type but do not belong to the same object. 
  8399.  
  8400. Note:  The equality operator (==) should not be confused with the assignment 
  8401. operator (=). For example, 
  8402.  
  8403. if(x == 3)    evaluates to 1 if x is equal to three 
  8404.  
  8405.               while 
  8406. if(x = 3)     is taken to be true because (x = 3) evaluates to a non-zero value 
  8407.               (3). The expression also assigns the value 3 to x. 
  8408.  
  8409. Related Information 
  8410.  
  8411. o Relational  <  >  <=  >= 
  8412. o Logical Negation  ! 
  8413. o Pointers 
  8414. o Binary Expression 
  8415. o Usual Arithmetic Conversions 
  8416.  
  8417.  
  8418. ΓòÉΓòÉΓòÉ 7.6.10. Bitwise AND  & ΓòÉΓòÉΓòÉ
  8419.  
  8420. The & (bitwise AND) operator compares each bit of its first operand to the 
  8421. corresponding bit of the second operand.  If both bits are 1's, the 
  8422. corresponding bit of the result is set to 1. Otherwise, it sets the 
  8423. corresponding result bit to 0. 
  8424.  
  8425. Both operands must have an integral type.  The usual arithmetic conversions on 
  8426. each operand are performed. The result has the same type as the converted 
  8427. operands. 
  8428.  
  8429. Because the bitwise AND operator has both associative and commutative 
  8430. properties, the compiler may rearrange the operands in an expression that 
  8431. contains more than one bitwise AND operator. 
  8432.  
  8433. The following example shows the values of a, b, and the result of a & b 
  8434. represented as 16-bit binary numbers: 
  8435.  
  8436. bit pattern of a              0000000001011100 
  8437. bit pattern of b              0000000000101110 
  8438. bit pattern of a & b          0000000000001100 
  8439.  
  8440. Note:  The bitwise AND (&) should not be confused with the logical AND (&&) 
  8441. operator.  For example, 
  8442.  
  8443.   1 & 4 evaluates to 0
  8444. while
  8445.   1 && 4 evaluates to 1
  8446.  
  8447. Related Information 
  8448.  
  8449. o Bitwise Exclusive OR  ^ 
  8450. o Bitwise Inclusive OR  | 
  8451. o Logical AND  && 
  8452. o Binary Expression 
  8453. o Usual Arithmetic Conversions 
  8454.  
  8455.  
  8456. ΓòÉΓòÉΓòÉ 7.6.11. Bitwise Exclusive OR  ^ ΓòÉΓòÉΓòÉ
  8457.  
  8458. The bitwise exclusive OR operator (in EBCDIC, the ^ symbol is represented by 
  8459. the ╨║ symbol) compares each bit of its first operand to the corresponding bit 
  8460. of the second operand.  If both bits are 1's or both bits are 0's, the 
  8461. corresponding bit of the result is set to 0. Otherwise, it sets the 
  8462. corresponding result bit to 1. 
  8463.  
  8464. Both operands must have an integral type.  The usual arithmetic conversions on 
  8465. each operand are performed. The result has the same type as the converted 
  8466. operands and is not an lvalue. 
  8467.  
  8468. Because the bitwise exclusive OR operator has both associative and commutative 
  8469. properties, the compiler may rearrange the operands in an expression that 
  8470. contains more than one bitwise exclusive OR operator. Note that the ^ character 
  8471. can be represented by the trigraph ??'. 
  8472.  
  8473. The following example shows the values of a, b, and the result of a ^ b 
  8474. represented as 16-bit binary numbers: 
  8475.  
  8476. bit pattern of a              0000000001011100 
  8477. bit pattern of b              0000000000101110 
  8478. bit pattern of a ^ b          0000000001110010 
  8479.  
  8480. Related Information 
  8481.  
  8482. o Bitwise Inclusive OR  | 
  8483. o Bitwise AND  & 
  8484. o Logical OR  || 
  8485. o Binary Expression 
  8486. o Usual Arithmetic Conversions 
  8487.  
  8488.  
  8489. ΓòÉΓòÉΓòÉ 7.6.12. Bitwise Inclusive OR  | ΓòÉΓòÉΓòÉ
  8490.  
  8491. The | (bitwise inclusive OR) operator compares the values (in binary format) of 
  8492. each operand and yields a value whose bit pattern shows which bits in either of 
  8493. the operands has the value 1. If both of the bits are 0, the result of that bit 
  8494. is 0;  otherwise, the result is 1. 
  8495.  
  8496. Both operands must have an integral type.  The usual arithmetic conversions on 
  8497. each operand are performed. The result has the same type as the converted 
  8498. operands and is not an lvalue. 
  8499.  
  8500. Because the bitwise inclusive OR operator has both associative and commutative 
  8501. properties, the compiler may rearrange the operands in an expression that 
  8502. contains more than one bitwise inclusive OR operator. Note that the | character 
  8503. can be represented by the trigraph ??!. 
  8504.  
  8505. The following example shows the values of a, b, and the result of a | b 
  8506. represented as 16-bit binary numbers: 
  8507.  
  8508. bit pattern of a              0000000001011100 
  8509. bit pattern of b              0000000000101110 
  8510. bit pattern of a | b          0000000001111110 
  8511.  
  8512. Note:  The bitwise OR (|) should not be confused with the logical OR (||) 
  8513. operator.  For example, 
  8514.  
  8515.   1 | 4 evaluates to 5
  8516. while
  8517.   1 || 4 evaluates to 1
  8518.  
  8519. Related Information 
  8520.  
  8521. o Bitwise Exclusive OR  ^ 
  8522. o Bitwise AND  & 
  8523. o Logical OR  || 
  8524. o Binary Expression 
  8525. o Usual Arithmetic Conversions 
  8526.  
  8527.  
  8528. ΓòÉΓòÉΓòÉ 7.6.13. Logical AND  && ΓòÉΓòÉΓòÉ
  8529.  
  8530. The && (logical AND) operator indicates whether both operands have a nonzero 
  8531. value.  If both operands have nonzero values, the result has the value 1. 
  8532. Otherwise, the result has the value 0. 
  8533.  
  8534. Both operands must have a scalar type.  The usual arithmetic conversions on 
  8535. each operand are performed. The result has type int and is not an lvalue. 
  8536.  
  8537. The logical AND operator guarantees left-to-right evaluation of the operands. 
  8538. If the left operand evaluates to 0, the right operand is not evaluated. 
  8539.  
  8540. The following examples show how the expressions that contain the logical AND 
  8541. operator are evaluated: 
  8542.  
  8543. Expression          Result 
  8544. 1 && 0              0 
  8545. 1 && 4              1 
  8546. 0 && 0              0 
  8547.  
  8548. The following example uses the logical AND operator to avoid a divide-by-zero 
  8549. situation: 
  8550.  
  8551. y && (x / y)
  8552.  
  8553. The expression x / y is not evaluated when y is 0. 
  8554.  
  8555. Note:  The logical AND (&&) should not be confused with the bitwise AND (&) 
  8556. operator.  For example: 
  8557.  
  8558.   1 && 4 evaluates to 1
  8559. while
  8560.   1 & 4 evaluates to 0
  8561.  
  8562. Related Information 
  8563.  
  8564. o Logical OR  || 
  8565. o Bitwise AND  & 
  8566. o Binary Expression 
  8567. o Usual Arithmetic Conversions 
  8568.  
  8569.  
  8570. ΓòÉΓòÉΓòÉ 7.6.14. Logical OR  || ΓòÉΓòÉΓòÉ
  8571.  
  8572. The || (logical OR) operator indicates whether either operand has a nonzero 
  8573. value.  If either operand has a nonzero value, the result has the value 1. 
  8574. Otherwise, the result has the value 0. 
  8575.  
  8576. Both operands must have a scalar type.  The usual arithmetic conversions on 
  8577. each operand are performed. The result has type int and is not an lvalue. 
  8578.  
  8579. The logical OR operator guarantees left-to-right evaluation of the operands. 
  8580. If the left operand has a nonzero value, the right operand is not evaluated. 
  8581.  
  8582. The following examples show how expressions that contain the logical OR 
  8583. operator are evaluated: 
  8584.  
  8585. Expression          Result 
  8586. 1 || 0              1 
  8587. 1 || 4              1 
  8588. 0 || 0              0 
  8589.  
  8590. The following example uses the logical OR operator to conditionally increment 
  8591. y: 
  8592.  
  8593. ++x || ++y;
  8594.  
  8595. The expression ++y is not evaluated when the expression ++x evaluates to a 
  8596. nonzero quantity. 
  8597.  
  8598. Note:  The logical OR (||) should not be confused with the bitwise OR (|) 
  8599. operator.  For example: 
  8600.  
  8601.   1 || 4 evaluates to 1
  8602. while
  8603.   1 | 4 evaluates to 5
  8604.  
  8605. Related Information 
  8606.  
  8607. o Logical AND  && 
  8608. o Bitwise Inclusive OR  | 
  8609. o Binary Expression 
  8610. o Usual Arithmetic Conversions 
  8611.  
  8612.  
  8613. ΓòÉΓòÉΓòÉ 7.7. Conditional Expression  ? : ΓòÉΓòÉΓòÉ
  8614.  
  8615. A conditional expression is a compound expression that contains a condition 
  8616. (the first expression), an expression to be evaluated if the condition has a 
  8617. nonzero value (the second expression), and an expression to be evaluated if the 
  8618. condition has the value 0. 
  8619.  
  8620. The conditional expression contains one two-part operator.  The ? symbol 
  8621. follows the condition, and the : symbol appears between the two action 
  8622. expressions. All expressions that occur between the ? and : are treated as one 
  8623. expression. 
  8624.  
  8625. The first operand must have a scalar type.  The second and third operands must 
  8626. have arithmetic types, compatible structure type, compatible union type, or 
  8627. compatible pointer type.  A type is compatible when it has the same type but 
  8628. not necessarily the same qualifiers (volatile, const, or _Packed). Also, the 
  8629. second and third operands may be a pointer and a NULL pointer constant, or a 
  8630. pointer to an object and a pointer to void. 
  8631.  
  8632. The first expression is evaluated first. If the first expression has a nonzero 
  8633. value, the second expression is evaluated and the third operand is not 
  8634. evaluated. Its result is converted to the result type. If the expression is an 
  8635. arithmetic type, the usual arithmetic conversions on the second expression are 
  8636. performed. If the first expression has a zero value, the third expression is 
  8637. evaluated with the usual arithmetic conversions performed on it if it has an 
  8638. arithmetic type. The types of the second and third operands determine the type 
  8639. of the result as shown in the following table. 
  8640.  
  8641. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  8642. Γöé TYPE OF ONE OPERAND   Γöé TYPE OF OTHER OPERAND   Γöé TYPE OF RESULT      Γöé
  8643. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  8644. Γöé Arithmetic        Γöé Arithmetic        Γöé Arithmetic after usual  Γöé
  8645. Γöé             Γöé              Γöé arithmetic conversions  Γöé
  8646. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  8647. Γöé "struct/union" type   Γöé Compatible        Γöé "struct/union" type   Γöé
  8648. Γöé             Γöé "struct/union" type    Γöé with all the qualifiers Γöé
  8649. Γöé             Γöé              Γöé on both operands     Γöé
  8650. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  8651. Γöé "void"          Γöé "void"          Γöé "void"          Γöé
  8652. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  8653. Γöé Pointer to compatible  Γöé Pointer to compatible   Γöé Pointer to type with   Γöé
  8654. Γöé type           Γöé type           Γöé all the qualifiers    Γöé
  8655. Γöé             Γöé              Γöé specified for the type  Γöé
  8656. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  8657. Γöé Pointer to type     Γöé "NULL" pointer      Γöé Pointer to type     Γöé
  8658. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  8659. Γöé Pointer to object or   Γöé Pointer to "void"     Γöé Pointer to "void" with  Γöé
  8660. Γöé incomplete type     Γöé              Γöé all the qualifiers    Γöé
  8661. Γöé             Γöé              Γöé specified for the type  Γöé
  8662. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  8663. Γöé Reference to type    Γöé Reference to type     Γöé Reference after usual  Γöé
  8664. Γöé             Γöé              Γöé reference conversions  Γöé
  8665. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  8666. Γöé Class "T"        Γöé Class "T"         Γöé Class "T"        Γöé
  8667. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  8668. Γöé Class "T"        Γöé Class "X"         Γöé Class type for which a  Γöé
  8669. Γöé             Γöé              Γöé conversion exists.  If  Γöé
  8670. Γöé             Γöé              Γöé more than one possible  Γöé
  8671. Γöé             Γöé              Γöé conversion exists, the  Γöé
  8672. Γöé             Γöé              Γöé result is ambiguous.   Γöé
  8673. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  8674. Γöé "throw" expression    Γöé Other (type, pointer,   Γöé Type of the expression  Γöé
  8675. Γöé             Γöé reference)        Γöé that is not a "throw"  Γöé
  8676. Γöé             Γöé              Γöé expression        Γöé
  8677. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  8678. Table 6. Type of the Conditional Expression
  8679.  
  8680. Conditional expressions have right-to-left associativity. 
  8681.  
  8682. Examples of Conditional Expressions 
  8683.  
  8684. Related Information 
  8685.  
  8686. o Types 
  8687. o Declarators 
  8688. o Expressions and Operators 
  8689. o Usual Arithmetic Conversions 
  8690. o Operator Precedence 
  8691.  
  8692.  
  8693. ΓòÉΓòÉΓòÉ <hidden> Examples of Conditional Expressions ΓòÉΓòÉΓòÉ
  8694.  
  8695. The following expression determines which variable has the greater value, y or 
  8696. z, and assigns the greater value to the variable x: 
  8697.  
  8698. x = (y > z) ? y : z;
  8699.  
  8700. The preceding expression is equivalent to the following statement: 
  8701.  
  8702. if (y > z)
  8703.    x = y;
  8704. else
  8705.    x = z;
  8706.  
  8707. The following expression calls the function printf, which receives the value of 
  8708. the variable c, if c evaluates to a digit. Otherwise, printf receives the 
  8709. character constant 'x'. 
  8710.  
  8711. printf(" c = %c\n", isdigit(c) ? c : 'x');
  8712.  
  8713.  
  8714. ΓòÉΓòÉΓòÉ 7.8. Assignment Expression ΓòÉΓòÉΓòÉ
  8715.  
  8716. An assignment expression stores a value in the object designated by the left 
  8717. operand. 
  8718.  
  8719. The left operand in all assignment expressions must be a modifiable lvalue. 
  8720. The type of the expression is the type of the left operand.  The value of the 
  8721. expression is the value of the left operand after the assignment has completed. 
  8722. The result of an assignment expression is not an lvalue. 
  8723.  
  8724. All assignment operators have the same precedence and have right-to-left 
  8725. associativity. 
  8726.  
  8727. There are two types of assignment operators: simple assignment and compound 
  8728. assignment.  The following sections describe these operators. 
  8729.  
  8730. o Simple Assignment  = 
  8731. o Compound Assignment 
  8732.  
  8733. Related Information 
  8734.  
  8735. o Expressions and Operators 
  8736. o Operator Precedence 
  8737.  
  8738.  
  8739. ΓòÉΓòÉΓòÉ 7.8.1. Simple Assignment  = ΓòÉΓòÉΓòÉ
  8740.  
  8741. The simple assignment operator stores the value of the right operand in the 
  8742. object designated by the left operand. 
  8743.  
  8744. Both operands must have arithmetic types, the same structure type, or the same 
  8745. union type.  Otherwise, both operands must be pointers to the same type, or the 
  8746. left operand must be a pointer and the right operand must be the constant 0 or 
  8747. NULL. 
  8748.  
  8749. If both operands have arithmetic types, the system converts the type of the 
  8750. right operand to the type of the left operand before the assignment. 
  8751.  
  8752. If the right operand is a pointer to a type, the left operand can be a pointer 
  8753. to a const of the same type.  If the right operand is a pointer to a const 
  8754. type, the left operand must also be a pointer to a const type. 
  8755.  
  8756. If the right operand is a pointer to a type, the left operand can be a pointer 
  8757. to a volatile of the same type. If the right operand is a pointer to a volatile 
  8758. type, the left operand must also be a pointer to a volatile type. 
  8759.  
  8760. If the left operand is a pointer to a member, the right operand must be a 
  8761. pointer to a member or a constant expression that evaluates to zero.  The right 
  8762. operand is converted to the type of the left operand before assignment. 
  8763.  
  8764. If the left operand is an object of reference type, the assignment is to the 
  8765. object denoted by the reference. 
  8766.  
  8767. If the left operand is a pointer and the right operand is the constant 0, the 
  8768. result is NULL. 
  8769.  
  8770. Pointers to void can appear on either side of the simple assignment operator. 
  8771.  
  8772. A packed structure or union can be assigned to a nonpacked structure or union 
  8773. of the same type, and a nonpacked structure or union can be assigned to a 
  8774. packed structure or union of the same type. 
  8775.  
  8776. If one operand is packed and the other is not, the layout of the right operand 
  8777. is remapped to match the layout of the left.  This remapping of structures may 
  8778. degrade performance.  For efficiency, when you perform assignment operations 
  8779. with structures or unions, you should ensure that both operands are either 
  8780. packed or nonpacked. 
  8781.  
  8782. Note:  If you assign pointers to structures or unions, the objects they point 
  8783. to must both be either packed or nonpacked.  See Pointers for more information 
  8784. on assignments with pointers. 
  8785.  
  8786. You can assign values to operands with the type qualifier volatile. You cannot 
  8787. assign a pointer of an object with the type qualifier const to a pointer of an 
  8788. object without the const type qualifier such as in the following example: 
  8789.  
  8790. const int *p1;
  8791. int *p2;
  8792. p2 = p1;  /* is not allowed */
  8793.  
  8794. p1 = p2;  /* note that this is allowed */
  8795.  
  8796. Examples of Simple Assignments 
  8797.  
  8798. Note:  The assignment (=) operator should not be confused with the equality 
  8799. comparison (==) operator. For example: 
  8800.  
  8801. if(x == 3)  evaluates to 1 if x is equal to three 
  8802.  
  8803.             while 
  8804. if(x = 3)   is taken to be true because (x = 3) evaluates to a non-zero value 
  8805.             (3). The expression also assigns the value 3 to x. 
  8806.  
  8807. Related Information 
  8808.  
  8809. o Compound Assignment 
  8810. o Equality  ==  != 
  8811. o Pointers 
  8812. o volatile and const Qualifiers 
  8813. o Types 
  8814. o Usual Arithmetic Conversions 
  8815.  
  8816.  
  8817. ΓòÉΓòÉΓòÉ <hidden> Examples of Simple Assignments ΓòÉΓòÉΓòÉ
  8818.  
  8819. The following example assigns the value of number to the member employee of the 
  8820. structure payroll: 
  8821.  
  8822. payroll.employee = number;
  8823.  
  8824. The following example assigns in order the value 0 to d, the value of d to c, 
  8825. the value of c to b, and the value of b to a: 
  8826.  
  8827. a = b = c = d = 0;
  8828.  
  8829.  
  8830. ΓòÉΓòÉΓòÉ 7.8.2. Compound Assignment ΓòÉΓòÉΓòÉ
  8831.  
  8832. The compound assignment operators consist of a binary operator and the simple 
  8833. assignment operator. They perform the operation of the binary operator on both 
  8834. operands and give the result of that operation to the left operand. 
  8835.  
  8836. If the left operand of the += and -= operators is a pointer, the right operand 
  8837. must have an integral type;  otherwise, both operands must have an arithmetic 
  8838. type. 
  8839.  
  8840. Both operands of the *=, /=, and %= operators must have an arithmetic type. 
  8841.  
  8842. Both operands of the <<=, >>=, &=, ^=, and |= operators must have an integral 
  8843. type. 
  8844.  
  8845. Note that the expression a *= b + c is equivalent to a = a * (b + c), and not 
  8846. a = a * b + c. 
  8847.  
  8848. The following table lists the compound assignment operators and shows an 
  8849. expression using each operator: 
  8850.  
  8851. Operator    Example 
  8852. +=          index += 2 
  8853.                Equivalent expression:  index = index + 2 
  8854. -=          *(pointer++) -= 1 
  8855.                Equivalent expression:  *pointer = *(pointer++) - 1 
  8856. *=          bonus *= increase 
  8857.                Equivalent expression:  bonus = bonus * increase 
  8858. /=          time /= hours 
  8859.                Equivalent expression:  time = time / hours 
  8860. %=          allowance %= 1000 
  8861.                Equivalent expression:  allowance = allowance % 1000 
  8862. <<=         result <<= num 
  8863.                Equivalent expression:  result = result << num 
  8864. >>=         form >>= 1 
  8865.                Equivalent expression:  form = form >> 1 
  8866. &=          mask &= 2 
  8867.                Equivalent expression:  mask = mask & 2 
  8868. ^=          test ^= pre_test 
  8869.                Equivalent expression:  test = test ^ pre_test 
  8870. |=          flag |= ON 
  8871.                Equivalent expression:  flag = flag | ON 
  8872.  
  8873. Although the equivalent expression column shows the left operands (from the 
  8874. example column) evaluated twice, the left operand is evaluated only once. 
  8875.  
  8876. Related Information 
  8877.  
  8878. o Simple Assignment  = 
  8879. o Binary Expression 
  8880.  
  8881.  
  8882. ΓòÉΓòÉΓòÉ 7.9. Comma Expression  , ΓòÉΓòÉΓòÉ
  8883.  
  8884. A comma expression contains two operands separated by a comma.  Although the 
  8885. compiler evaluates both operands, the value of the right operand is the value 
  8886. of the expression.  The left operand is evaluated, possibly producing side 
  8887. effects, and the value is discarded.  The result of a comma expression is not 
  8888. an lvalue. 
  8889.  
  8890. Both operands of a comma expression can have any type.  All comma expressions 
  8891. have left-to-right associativity. The left operand is fully evaluated before 
  8892. the right operand. 
  8893.  
  8894. If omega had the value 11, the following example would increment y and assign 
  8895. the value 3 to alpha: 
  8896.  
  8897. alpha = (y++, omega % 4);
  8898.  
  8899. Any number of expressions separated by commas can form a single expression. 
  8900. The compiler evaluates the leftmost expression first.  The value of the 
  8901. rightmost expression becomes the value of the entire expression.  For example, 
  8902. the value of the following expression is rotate(direction): 
  8903.  
  8904. intensity++, shade * increment, rotate(direction);
  8905.  
  8906. Restrictions 
  8907. You can place comma expressions within lists that contain commas (for example, 
  8908. argument lists and initializer lists).  However, because the comma has a 
  8909. special meaning, you must place parentheses around comma expressions in these 
  8910. lists.  The comma expression t = 3, t + 2 is in the following function call: 
  8911.  
  8912. f(a, (t = 3, t + 2), c);
  8913.  
  8914. The arguments to the function f are:  the value of a, the value 5, and the 
  8915. value of c. 
  8916.  
  8917. Related Information 
  8918.  
  8919. o Expressions and Operators 
  8920. o Operator Precedence 
  8921.  
  8922.  
  8923. ΓòÉΓòÉΓòÉ 7.10. Conversions ΓòÉΓòÉΓòÉ
  8924.  
  8925. Many C and C++ operators cause conversions. A conversion changes the form of a 
  8926. value and its type. For example, when you add values having different data 
  8927. types, the compiler converts the types of the objects to the same type before 
  8928. adding the values.  Addition of a short int value and an int value causes the 
  8929. compiler to convert the short int value to the int type. 
  8930.  
  8931. Conversions may occur, for example, when: 
  8932.  
  8933. o A cast operation is performed. 
  8934. o An operand is prepared for an arithmetic or logical operation. 
  8935. o An assignment is made to an lvalue that has different type from the assigned 
  8936.   value. 
  8937. o A prototyped function is given an argument that has a different type from the 
  8938.   parameter. 
  8939. o The type of the expression specified on a function's return statement has a 
  8940.   different type from the defined return type for the function. 
  8941.  
  8942. Although the C and C++ languages contain some guidelines for conversions, many 
  8943. conversions have implementation-specific aspects. These implementation specific 
  8944. aspects occur because: 
  8945.  
  8946. o The sizes of the data types vary. 
  8947. o The manner of handling signed data varies. 
  8948. o The data formats vary. 
  8949.  
  8950. The following sections describe conversions: 
  8951.  
  8952. o Usual Arithmetic Conversions 
  8953. o Type Conversions 
  8954.  
  8955. Related Information 
  8956.  
  8957. o Expressions and Operators 
  8958. o Types 
  8959. o Cast Expressions 
  8960. o Functions 
  8961.  
  8962.  
  8963. ΓòÉΓòÉΓòÉ 7.10.1. Usual Arithmetic Conversions ΓòÉΓòÉΓòÉ
  8964.  
  8965. Most C and C++ operators perform type conversions to bring the operands of an 
  8966. expression to a common type or to extend short values to the integer size used 
  8967. in machine operations.  The conversions performed by the operators depend on 
  8968. the specific operator and the type of the operand or operands. However, many 
  8969. operators perform similar conversions on operands of integer and floating-point 
  8970. types.  These conversions are known as standard arithmetic conversions because 
  8971. they apply to the types of values ordinarily used in arithmetic. 
  8972.  
  8973. Integer promotions are performed when you use a char, short int, int, bit 
  8974. field, or an enumeration type wherever an int or unsigned int is expected. If 
  8975. an int can hold the value, the value is converted to an int; otherwise, it is 
  8976. converted to an unsigned int. All other arithmetic types are unchanged by 
  8977. integer promotions. 
  8978.  
  8979. Type Conversions outlines the path of each type of conversion. 
  8980.  
  8981. Arithmetic conversion proceeds in the following order: 
  8982.  
  8983.  1. If one operand has long double type, the other operand is converted to long 
  8984.     double type. 
  8985.  
  8986.  2. If one operand has double type, the other operand is converted to double. 
  8987.  
  8988.  3. If one operand has float type, the other operand is converted to float. 
  8989.  
  8990.  4. If one operand has unsigned long int type, the other operand is converted 
  8991.     to unsigned long int. 
  8992.  
  8993.  5. If one operand has unsigned int type and the other operand has long int 
  8994.     type and the value of the unsigned int can be represented in a long int, 
  8995.     the operand with unsigned int type is converted to long int. 
  8996.  
  8997.  6. If one operand has unsigned int type and the other operand has long int 
  8998.     type and the value of the unsigned int cannot be represented in a long int, 
  8999.     both operands are converted to unsigned long int. 
  9000.  
  9001.  7. If one operand has long int type, the other operand is converted to long 
  9002.     int. 
  9003.  
  9004.  8. If one operand has unsigned int type, the other operand is converted to 
  9005.     unsigned int. 
  9006.  
  9007.  9. Both operands have int type, and the result is type int. 
  9008.  
  9009. Related Information 
  9010.  
  9011. o Type Conversions 
  9012. o Types 
  9013. o Expressions and Operators 
  9014.  
  9015.  
  9016. ΓòÉΓòÉΓòÉ 7.10.2. Type Conversions ΓòÉΓòÉΓòÉ
  9017.  
  9018. Type conversions are the assignment of a value to a variable of a different 
  9019. data type, when: 
  9020.  
  9021. o A value is explicitly cast to another type. 
  9022. o An operator converts the type of its operand or operands before performing an 
  9023.   operation. 
  9024. o A value is passed as an argument to a function. 
  9025.  
  9026. The following sections outline the rules governing each kind of conversion. 
  9027.  
  9028. Assignment Conversions 
  9029.  
  9030. In assignment operations, the type of the value being assigned is converted to 
  9031. the type of the variable receiving the assignment. C and C++ allow conversions 
  9032. by assignment between integer and floating-point types, even when the 
  9033. conversion entails loss of information. 
  9034.  
  9035. On IBM C compilers, int types are handled in the same manner as long types. 
  9036.  
  9037. The methods of carrying out the conversions depend upon the type: 
  9038.  
  9039. o Conversion from Signed Integer Types 
  9040. o Conversion from Unsigned Integer Types 
  9041. o Conversion from Floating-Point Types 
  9042. o Conversion to and from Pointer Types 
  9043. o Conversion from Other Types 
  9044.  
  9045. Related Information 
  9046.  
  9047. o Types 
  9048. o Expressions and Operators 
  9049. o Cast Expressions 
  9050. o Usual Arithmetic Conversions 
  9051.  
  9052.  
  9053. ΓòÉΓòÉΓòÉ 7.10.2.1. Conversion from Signed Integer Types ΓòÉΓòÉΓòÉ
  9054.  
  9055. C and C++ convert a signed integer to a shorter signed integer by truncating 
  9056. the high-order bits and converting it to a longer signed integer by 
  9057. sign-extension. Conversion of signed integers to floating-point values takes 
  9058. place without loss of information, except that some precision can be lost when 
  9059. a long value is converted to a float.  To convert a signed integer to an 
  9060. unsigned integer, you must convert the signed integer to the size of the 
  9061. unsigned integer.  The result is interpreted as an unsigned value. 
  9062.  
  9063. The following chart summarizes conversions from signed integer types: 
  9064.  
  9065. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  9066. Γöé FROM     Γöé TO      Γöé METHOD                     Γöé
  9067. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9068. Γöé "signed    Γöé "short"    Γöé Sign-extend.                  Γöé
  9069. Γöé char"     Γöé        Γöé                         Γöé
  9070. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9071. Γöé        Γöé "int"     Γöé Sign-extend.                  Γöé
  9072. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9073. Γöé        Γöé "long"    Γöé Sign-extend.                  Γöé
  9074. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9075. Γöé        Γöé "unsigned   Γöé Preserve pattern; high-order bit loses func-  Γöé
  9076. Γöé        Γöé char"     Γöé tion as sign bit.                Γöé
  9077. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9078. Γöé        Γöé "unsigned   Γöé Sign-extend to "short"; convert "short" to   Γöé
  9079. Γöé        Γöé short"    Γöé "unsigned short".                Γöé
  9080. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9081. Γöé        Γöé "unsigned   Γöé Sign-extend to "long"; convert "long" to    Γöé
  9082. Γöé        Γöé long"     Γöé "unsigned long".                Γöé
  9083. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9084. Γöé        Γöé "float"    Γöé Sign-extend to "long"; convert "long" to    Γöé
  9085. Γöé        Γöé        Γöé "float".                    Γöé
  9086. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9087. Γöé        Γöé "double"   Γöé Sign-extend to "long"; convert "long" to    Γöé
  9088. Γöé        Γöé        Γöé "double".                    Γöé
  9089. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9090. Γöé        Γöé "long     Γöé Sign-extend to "long"; convert "long" to "long Γöé
  9091. Γöé        Γöé double"    Γöé double".                    Γöé
  9092. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9093. Γöé "short"    Γöé "signed    Γöé Preserve low-order byte.            Γöé
  9094. Γöé        Γöé char"     Γöé                         Γöé
  9095. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9096. Γöé        Γöé "int"     Γöé Sign-extend.                  Γöé
  9097. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9098. Γöé        Γöé "long"    Γöé Sign-extend.                  Γöé
  9099. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9100. Γöé        Γöé "unsigned   Γöé Preserve low-order byte.            Γöé
  9101. Γöé        Γöé char"     Γöé                         Γöé
  9102. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9103. Γöé        Γöé "unsigned   Γöé Preserve bit pattern; high-order bit loses   Γöé
  9104. Γöé        Γöé short"    Γöé function as sign bit.              Γöé
  9105. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9106. Γöé        Γöé "unsigned   Γöé Sign-extend to "long"; convert "long" to    Γöé
  9107. Γöé        Γöé long"     Γöé "unsigned long".                Γöé
  9108. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9109. Γöé        Γöé "float"    Γöé Sign-extend to "long"; convert "long" to    Γöé
  9110. Γöé        Γöé        Γöé "float".                    Γöé
  9111. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9112. Γöé        Γöé "double"   Γöé Sign-extend to "long"; convert "long" to    Γöé
  9113. Γöé        Γöé        Γöé "double".                    Γöé
  9114. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9115. Γöé        Γöé "long     Γöé Sign-extend to "long"; convert "long" to "long Γöé
  9116. Γöé        Γöé double"    Γöé double".                    Γöé
  9117. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9118. Γöé "int"     Γöé "signed    Γöé Preserve low-order byte.            Γöé
  9119. Γöé        Γöé char"     Γöé                         Γöé
  9120. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9121. Γöé        Γöé "short"    Γöé Preserve low-order bytes.            Γöé
  9122. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9123. Γöé        Γöé "unsigned   Γöé Preserve low-order byte.            Γöé
  9124. Γöé        Γöé char"     Γöé                         Γöé
  9125. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9126. Γöé        Γöé "unsigned   Γöé Preserve low-order bytes.            Γöé
  9127. Γöé        Γöé short"    Γöé                         Γöé
  9128. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9129. Γöé        Γöé "unsigned   Γöé Preserve bit pattern; high-order bit loses   Γöé
  9130. Γöé        Γöé long"     Γöé function as sign bit.              Γöé
  9131. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9132. Γöé        Γöé "float"    Γöé Represent as a "float"; if the "long" cannot  Γöé
  9133. Γöé        Γöé        Γöé be represented exactly, some loss of precision Γöé
  9134. Γöé        Γöé        Γöé occurs.                     Γöé
  9135. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9136. Γöé        Γöé "double"   Γöé Represent as a "double"; if the "long" cannot  Γöé
  9137. Γöé        Γöé        Γöé be represented exactly, some loss of precision Γöé
  9138. Γöé        Γöé        Γöé occurs.                     Γöé
  9139. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9140. Γöé        Γöé "long     Γöé Represent as a "long double"; if the "long"   Γöé
  9141. Γöé        Γöé double"    Γöé cannot be represented exactly, some loss of   Γöé
  9142. Γöé        Γöé        Γöé precision occurs.                Γöé
  9143. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  9144. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  9145. Γöé FROM     Γöé TO      Γöé METHOD                     Γöé
  9146. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9147. Γöé "long"    Γöé "signed    Γöé Preserve low-order byte.            Γöé
  9148. Γöé        Γöé char"     Γöé                         Γöé
  9149. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9150. Γöé        Γöé "short"    Γöé Preserve low-order bytes.            Γöé
  9151. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9152. Γöé        Γöé "unsigned   Γöé Preserve low-order byte.            Γöé
  9153. Γöé        Γöé char"     Γöé                         Γöé
  9154. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9155. Γöé        Γöé "unsigned   Γöé Preserve low-order bytes.            Γöé
  9156. Γöé        Γöé short"    Γöé                         Γöé
  9157. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9158. Γöé        Γöé "unsigned   Γöé Preserve bit pattern; high-order bit loses   Γöé
  9159. Γöé        Γöé long"     Γöé function as sign bit.              Γöé
  9160. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9161. Γöé        Γöé "float"    Γöé Represent as a "float"; if the "long" cannot  Γöé
  9162. Γöé        Γöé        Γöé be represented exactly, some loss of precision Γöé
  9163. Γöé        Γöé        Γöé occurs.                     Γöé
  9164. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9165. Γöé        Γöé "double"   Γöé Represent as a "double"; if the "long" cannot  Γöé
  9166. Γöé        Γöé        Γöé be represented exactly, some loss of precision Γöé
  9167. Γöé        Γöé        Γöé occurs.                     Γöé
  9168. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9169. Γöé        Γöé "long     Γöé Represent as a "long double"; if the "long"   Γöé
  9170. Γöé        Γöé double"    Γöé cannot be represented exactly, some loss of   Γöé
  9171. Γöé        Γöé        Γöé precision occurs.                Γöé
  9172. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  9173.  
  9174. Related Information 
  9175.  
  9176. o Conversion from Unsigned Integer Types 
  9177. o Conversion from Floating-Point Types 
  9178. o Conversion to and from Pointer Types 
  9179. o Conversion from Other Types 
  9180. o Integers 
  9181. o Types 
  9182. o Type Conversions 
  9183. o Usual Arithmetic Conversions 
  9184.  
  9185.  
  9186. ΓòÉΓòÉΓòÉ 7.10.2.2. Conversion from Unsigned Integer Types ΓòÉΓòÉΓòÉ
  9187.  
  9188. An unsigned integer is converted to a shorter unsigned or signed integer by 
  9189. truncating the high-order bits.  An unsigned integer is converted to a longer 
  9190. unsigned or signed integer by setting the high-order bits to 0. Unsigned values 
  9191. are converted to floating-point values by first converting to a signed integer 
  9192. of the same size, and then converting that signed value to a floating-point 
  9193. value. 
  9194.  
  9195. When an unsigned integer is converted to a signed integer of the same size, no 
  9196. change in the bit pattern occurs.  However, the value changes if the sign bit 
  9197. is set. 
  9198.  
  9199. The following chart summarizes conversions from unsigned integer types: 
  9200.  
  9201. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  9202. Γöé FROM     Γöé TO      Γöé METHOD                     Γöé
  9203. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9204. Γöé "unsigned   Γöé "signed    Γöé Preserve bit pattern; high-order bit becomes  Γöé
  9205. Γöé char"     Γöé char"     Γöé sign bit.                    Γöé
  9206. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9207. Γöé        Γöé "short"    Γöé Zero-extend; preserve the bit pattern.     Γöé
  9208. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9209. Γöé        Γöé "int"     Γöé Zero-extend; preserve the bit pattern.     Γöé
  9210. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9211. Γöé        Γöé "long"    Γöé Zero-extend; preserve the bit pattern.     Γöé
  9212. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9213. Γöé        Γöé "unsigned   Γöé Zero-extend; preserve the bit pattern.     Γöé
  9214. Γöé        Γöé short"    Γöé                         Γöé
  9215. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9216. Γöé        Γöé "unsigned   Γöé Zero-extend; preserve the bit pattern.     Γöé
  9217. Γöé        Γöé int"     Γöé                         Γöé
  9218. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9219. Γöé        Γöé "unsigned   Γöé Zero-extend; preserve the bit pattern.     Γöé
  9220. Γöé        Γöé long"     Γöé                         Γöé
  9221. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9222. Γöé        Γöé "float"    Γöé Convert to "long"; convert "long" to "float".  Γöé
  9223. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9224. Γöé        Γöé "double"   Γöé Convert to "long"; convert "long" to "double". Γöé
  9225. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9226. Γöé        Γöé "long     Γöé Convert to "long"; convert "long" to "long   Γöé
  9227. Γöé        Γöé double"    Γöé double".                    Γöé
  9228. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9229. Γöé "unsigned   Γöé "signed    Γöé Preserve low-order byte.            Γöé
  9230. Γöé short"    Γöé char"     Γöé                         Γöé
  9231. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9232. Γöé        Γöé "short"    Γöé Preserve bit pattern; high-order bit becomes  Γöé
  9233. Γöé        Γöé        Γöé sign bit.                    Γöé
  9234. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9235. Γöé        Γöé "int"     Γöé Zero-extend;  preserve the bit pattern.     Γöé
  9236. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9237. Γöé        Γöé "long"    Γöé Zero-extend;  preserve the bit pattern.     Γöé
  9238. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9239. Γöé        Γöé "unsigned   Γöé Preserve low-order byte.            Γöé
  9240. Γöé        Γöé char"     Γöé                         Γöé
  9241. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9242. Γöé        Γöé "unsigned   Γöé Zero-extend.                  Γöé
  9243. Γöé        Γöé int"     Γöé                         Γöé
  9244. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9245. Γöé        Γöé "unsigned   Γöé Zero-extend.                  Γöé
  9246. Γöé        Γöé long"     Γöé                         Γöé
  9247. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9248. Γöé        Γöé "float"    Γöé Convert to "long"; convert "long" to "float".  Γöé
  9249. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9250. Γöé        Γöé "double"   Γöé Convert to "long"; convert "long" to "double". Γöé
  9251. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9252. Γöé        Γöé "long     Γöé Convert to "long"; convert "long" to "long   Γöé
  9253. Γöé        Γöé double"    Γöé double".                    Γöé
  9254. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9255. Γöé "unsigned   Γöé "signed    Γöé Preserve low-order byte.            Γöé
  9256. Γöé int"     Γöé char"     Γöé                         Γöé
  9257. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9258. Γöé        Γöé "short"    Γöé Preserve low-order bytes.            Γöé
  9259. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9260. Γöé        Γöé "int"     Γöé Preserve bit pattern; high-order bit becomes  Γöé
  9261. Γöé        Γöé        Γöé sign.                      Γöé
  9262. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9263. Γöé        Γöé "long"    Γöé Preserve bit pattern; high-order bit becomes  Γöé
  9264. Γöé        Γöé        Γöé sign.                      Γöé
  9265. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9266. Γöé        Γöé "unsigned   Γöé Preserve low-order byte.            Γöé
  9267. Γöé        Γöé char"     Γöé                         Γöé
  9268. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9269. Γöé        Γöé "unsigned   Γöé Preserve low-order bytes.            Γöé
  9270. Γöé        Γöé short"    Γöé                         Γöé
  9271. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9272. Γöé        Γöé "float"    Γöé Convert "int" to "float".            Γöé
  9273. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9274. Γöé        Γöé "double"   Γöé Convert "int" to "double".           Γöé
  9275. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9276. Γöé        Γöé "long     Γöé Convert "int" to "long double".         Γöé
  9277. Γöé        Γöé double"    Γöé                         Γöé
  9278. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  9279. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  9280. Γöé FROM     Γöé TO      Γöé METHOD                     Γöé
  9281. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9282. Γöé "unsigned   Γöé "signed    Γöé Preserve low-order byte.            Γöé
  9283. Γöé long"     Γöé char"     Γöé                         Γöé
  9284. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9285. Γöé        Γöé "short"    Γöé Preserve low-order bytes.            Γöé
  9286. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9287. Γöé        Γöé "int"     Γöé Preserve bit pattern; high-order bit becomes  Γöé
  9288. Γöé        Γöé        Γöé sign.                      Γöé
  9289. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9290. Γöé        Γöé "long"    Γöé Preserve bit pattern; high-order bit becomes  Γöé
  9291. Γöé        Γöé        Γöé sign.                      Γöé
  9292. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9293. Γöé        Γöé "unsigned   Γöé Preserve low-order byte.            Γöé
  9294. Γöé        Γöé char"     Γöé                         Γöé
  9295. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9296. Γöé        Γöé "unsigned   Γöé Preserve low-order bytes.            Γöé
  9297. Γöé        Γöé short"    Γöé                         Γöé
  9298. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9299. Γöé        Γöé "float"    Γöé Convert "long" to "float".           Γöé
  9300. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9301. Γöé        Γöé "double"   Γöé Convert "long" to "double".           Γöé
  9302. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9303. Γöé        Γöé "long     Γöé Convert "long" to "long double".        Γöé
  9304. Γöé        Γöé double"    Γöé                         Γöé
  9305. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  9306.  
  9307. Related Information 
  9308.  
  9309. o Conversion from Signed Integer Types 
  9310. o Conversion from Floating-Point Types 
  9311. o Conversion to and from Pointer Types 
  9312. o Conversion from Other Types 
  9313. o Integers 
  9314. o Types 
  9315. o Type Conversions 
  9316. o Usual Arithmetic Conversions 
  9317.  
  9318.  
  9319. ΓòÉΓòÉΓòÉ 7.10.2.3. Conversion from Floating-Point Types ΓòÉΓòÉΓòÉ
  9320.  
  9321. A float value converted to a double undergoes no change in value.  A double 
  9322. converted to a float is represented exactly, if possible.  If C cannot exactly 
  9323. represent the double value as a float, the number loses precision.  If the 
  9324. value is too large to fit into a float, the number is undefined. 
  9325.  
  9326. A floating-point value is converted to an integer value by converting to an 
  9327. unsigned long.  The decimal fraction portion of the floating-point value is 
  9328. discarded in the conversion.  If the result is still too large to fit, the 
  9329. result of the conversion is undefined. 
  9330.  
  9331. The following chart summarizes conversions from floating-point types: 
  9332.  
  9333. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  9334. Γöé FROM     Γöé TO      Γöé METHOD                     Γöé
  9335. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9336. Γöé "float"    Γöé "signed    Γöé Convert to "long"; convert "long" to "signed  Γöé
  9337. Γöé        Γöé char"     Γöé char".                     Γöé
  9338. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9339. Γöé        Γöé "short"    Γöé Convert to "long"; convert "long" to "short".  Γöé
  9340. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9341. Γöé        Γöé "int"     Γöé Truncate at decimal point; if result is too   Γöé
  9342. Γöé        Γöé        Γöé large to be represented as a "int", result is  Γöé
  9343. Γöé        Γöé        Γöé undefined.                   Γöé
  9344. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9345. Γöé        Γöé "long"    Γöé Truncate at decimal point; if result is too   Γöé
  9346. Γöé        Γöé        Γöé large to be represented as a "long", result is Γöé
  9347. Γöé        Γöé        Γöé undefined.                   Γöé
  9348. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9349. Γöé        Γöé "unsigned   Γöé Convert to "unsigned long"; convert "unsigned  Γöé
  9350. Γöé        Γöé short"    Γöé long" to "unsigned short".           Γöé
  9351. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9352. Γöé        Γöé "unsigned   Γöé Truncate at decimal point; if result is too   Γöé
  9353. Γöé        Γöé int"     Γöé large to be represented as an "unsigned int",  Γöé
  9354. Γöé        Γöé        Γöé result is undefined.              Γöé
  9355. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9356. Γöé        Γöé "unsigned   Γöé Truncate at decimal point; if result is too   Γöé
  9357. Γöé        Γöé long"     Γöé large to be represented as an "unsigned long", Γöé
  9358. Γöé        Γöé        Γöé result is undefined.              Γöé
  9359. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9360. Γöé        Γöé "double"   Γöé Represent as a "double".            Γöé
  9361. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9362. Γöé "double"   Γöé "signed    Γöé Convert to "float"; convert "float" to "char". Γöé
  9363. Γöé        Γöé char"     Γöé                         Γöé
  9364. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9365. Γöé        Γöé "short"    Γöé Convert to "float"; convert "float" to     Γöé
  9366. Γöé        Γöé        Γöé "short".                    Γöé
  9367. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9368. Γöé        Γöé "int"     Γöé Truncate at decimal point; if result is too   Γöé
  9369. Γöé        Γöé        Γöé large to be represented as a "long", result is Γöé
  9370. Γöé        Γöé        Γöé undefined.                   Γöé
  9371. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9372. Γöé        Γöé "long"    Γöé Truncate at decimal point; if result is too   Γöé
  9373. Γöé        Γöé        Γöé large to be represented as a "long", result is Γöé
  9374. Γöé        Γöé        Γöé undefined.                   Γöé
  9375. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9376. Γöé        Γöé "unsigned   Γöé Convert to "unsigned long"; convert "unsigned  Γöé
  9377. Γöé        Γöé short"    Γöé long" to "unsigned short".           Γöé
  9378. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9379. Γöé        Γöé "unsigned   Γöé Truncate at decimal point; if result is too   Γöé
  9380. Γöé        Γöé int"     Γöé large to be represented as an "unsigned int",  Γöé
  9381. Γöé        Γöé        Γöé result is undefined.              Γöé
  9382. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9383. Γöé        Γöé "unsigned   Γöé Truncate at decimal point; if result is too   Γöé
  9384. Γöé        Γöé long"     Γöé large to be represented as a "long", result is Γöé
  9385. Γöé        Γöé        Γöé undefined.                   Γöé
  9386. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9387. Γöé        Γöé "float"    Γöé Represent as a float; if the "double" value   Γöé
  9388. Γöé        Γöé        Γöé cannot be represented exactly as a "float",   Γöé
  9389. Γöé        Γöé        Γöé loss of precision occurs; if the value is too  Γöé
  9390. Γöé        Γöé        Γöé large to be represented in a "float", the    Γöé
  9391. Γöé        Γöé        Γöé result is undefined.              Γöé
  9392. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9393. Γöé        Γöé "long     Γöé Represent as a "long double".          Γöé
  9394. Γöé        Γöé double"    Γöé                         Γöé
  9395. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  9396. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  9397. Γöé FROM     Γöé TO      Γöé METHOD                     Γöé
  9398. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9399. Γöé "long     Γöé "signed    Γöé Convert to "double"; convert "double" to    Γöé
  9400. Γöé double"    Γöé char"     Γöé "float"; convert "float" to "char".       Γöé
  9401. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9402. Γöé        Γöé "short"    Γöé Convert to "double"; convert "double" to    Γöé
  9403. Γöé        Γöé        Γöé "float"; convert "float" to "short".      Γöé
  9404. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9405. Γöé        Γöé "int"     Γöé Truncate at decimal point; if result is too   Γöé
  9406. Γöé        Γöé        Γöé large to be represented as a "int", result is  Γöé
  9407. Γöé        Γöé        Γöé undefined.                   Γöé
  9408. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9409. Γöé        Γöé "long"    Γöé Truncate at decimal point; if result is too   Γöé
  9410. Γöé        Γöé        Γöé large to be represented as a "long", result is Γöé
  9411. Γöé        Γöé        Γöé undefined.                   Γöé
  9412. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9413. Γöé        Γöé "unsigned   Γöé Convert to "double"; convert "double" to    Γöé
  9414. Γöé        Γöé short"    Γöé "unsigned long"; convert "unsigned long" to   Γöé
  9415. Γöé        Γöé        Γöé "unsigned short".                Γöé
  9416. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9417. Γöé        Γöé "unsigned   Γöé Truncate at decimal point; if result is too   Γöé
  9418. Γöé        Γöé int"     Γöé large to be represented as an "unsigned int",  Γöé
  9419. Γöé        Γöé        Γöé result is undefined.              Γöé
  9420. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9421. Γöé        Γöé "unsigned   Γöé Truncate at decimal point; if result is too   Γöé
  9422. Γöé        Γöé long"     Γöé large to be represented as an "unsigned long", Γöé
  9423. Γöé        Γöé        Γöé result is undefined.              Γöé
  9424. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9425. Γöé        Γöé "float"    Γöé Convert to "double"; represent as a "float";  Γöé
  9426. Γöé        Γöé        Γöé if the "long double" value cannot be repres-  Γöé
  9427. Γöé        Γöé        Γöé ented exactly as a "float", loss of precision  Γöé
  9428. Γöé        Γöé        Γöé occurs; if the value is too large to be     Γöé
  9429. Γöé        Γöé        Γöé represented in a "float", the result is unde-  Γöé
  9430. Γöé        Γöé        Γöé fined.                     Γöé
  9431. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9432. Γöé        Γöé "double"   Γöé Represent as a "double"; If the result is too  Γöé
  9433. Γöé        Γöé        Γöé large to be represented as a "double", result  Γöé
  9434. Γöé        Γöé        Γöé is undefined.                  Γöé
  9435. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  9436.  
  9437. Related Information 
  9438.  
  9439. o Conversion from Signed Integer Types 
  9440. o Conversion from Unsigned Integer Types 
  9441. o Conversion to and from Pointer Types 
  9442. o Conversion from Other Types 
  9443. o Floating-Point Variables 
  9444. o Types 
  9445. o Type Conversions 
  9446. o Usual Arithmetic Conversions 
  9447.  
  9448.  
  9449. ΓòÉΓòÉΓòÉ 7.10.2.4. Conversion to and from Pointer Types ΓòÉΓòÉΓòÉ
  9450.  
  9451. You can convert a pointer to one type of value to a pointer to a different 
  9452. type. 
  9453.  
  9454. You can convert a pointer value to an integral value.  The path of the 
  9455. conversion depends on the size of the pointer and the size of the integral 
  9456. type. 
  9457.  
  9458. The conversion of an integer value to an address offset (in an expression with 
  9459. an integral type operand and a pointer type operand) is system dependent. 
  9460.  
  9461. A pointer to a constant or a volatile object should never be assigned to a 
  9462. nonconstant or nonvolatile object. 
  9463.  
  9464. A pointer to void can be converted to or from a pointer to any incomplete or 
  9465. object type. 
  9466.  
  9467. Related Information 
  9468.  
  9469. o Conversion from Signed Integer Types 
  9470. o Conversion from Unsigned Integer Types 
  9471. o Conversion from Floating-Point Types 
  9472. o Conversion from Other Types 
  9473. o Pointers 
  9474. o volatile and const Qualifiers 
  9475. o Types 
  9476. o Type Conversions 
  9477. o Usual Arithmetic Conversions 
  9478.  
  9479.  
  9480. ΓòÉΓòÉΓòÉ 7.10.2.5. Conversion from Other Types ΓòÉΓòÉΓòÉ
  9481.  
  9482. When you define a value using the enum type specifier, the value is treated as 
  9483. an int.  Conversions to and from an enum value proceed as for the int type. 
  9484.  
  9485. When a packed structure or union is assigned to a nonpacked structure or union 
  9486. of the same type or an nonpacked structure is assigned to, a packed structure 
  9487. or union of the same type, the layout of the right operand is remapped to match 
  9488. the layout of the left. 
  9489.  
  9490. No other conversions between structure or union types are allowed. 
  9491.  
  9492. The void type has no value, by definition.  Therefore, it cannot be converted 
  9493. to any other type, nor can any value be converted to void by assignment. 
  9494. However, a value can be explicitly cast to void. 
  9495.  
  9496. Related Information 
  9497.  
  9498. o Conversion from Signed Integer Types 
  9499. o Conversion from Unsigned Integer Types 
  9500. o Conversion from Floating-Point Types 
  9501. o Conversion to and from Pointer Types 
  9502. o Enumerations 
  9503. o Integers 
  9504. o Structures 
  9505. o Unions 
  9506. o _Packed Qualifier 
  9507. o void Type 
  9508. o Cast Expressions 
  9509. o Type Conversions 
  9510. o Usual Arithmetic Conversions 
  9511.  
  9512.  
  9513. ΓòÉΓòÉΓòÉ 8. Language Statements ΓòÉΓòÉΓòÉ
  9514.  
  9515. This section describes the following C and C++ language statements: 
  9516.  
  9517. o Labels 
  9518. o Block 
  9519. o break 
  9520. o continue 
  9521. o do 
  9522. o Expression 
  9523. o for 
  9524. o goto 
  9525. o if 
  9526. o Null Statement 
  9527. o return 
  9528. o switch 
  9529. o while 
  9530.  
  9531.  
  9532. ΓòÉΓòÉΓòÉ 8.1. Labels ΓòÉΓòÉΓòÉ
  9533.  
  9534. A label is an identifier that allows your program to transfer control to other 
  9535. statements within the same function. A label is the only type of identifier 
  9536. that has function scope. (See Scope in C.) Control is transferred to the 
  9537. statement following the label by means of the goto or switch statements. A 
  9538. label has the form: 
  9539.  
  9540. >>ΓöÇΓöÇidentifierΓöÇΓöÇ:ΓöÇΓöÇstatementΓöÇΓöÇ><
  9541.  
  9542. For example, the following are labels: 
  9543.  
  9544.  comment_complete: ;             /* Example of null statement label */
  9545.  test_for_null: if (NULL == ptr) /* Example of statement label     */
  9546.  
  9547. The case and default labels have a specific use and are described under switch. 
  9548.  
  9549. Related Information 
  9550.  
  9551. o goto 
  9552. o switch 
  9553.  
  9554.  
  9555. ΓòÉΓòÉΓòÉ 8.2. Block ΓòÉΓòÉΓòÉ
  9556.  
  9557. A block statement enables you to group any number of data definitions, 
  9558. declarations, and statements into one statement.  When you enclose definitions, 
  9559. declarations, and statements within a single set of braces, everything within 
  9560. the braces is treated as a single statement. You can place a block wherever a 
  9561. statement is allowed. 
  9562.  
  9563. Syntax of a Block Statement 
  9564.  
  9565. All definitions and declarations occur at the beginning of a block before 
  9566. statements. Statements must follow the definitions and declarations. A block is 
  9567. considered a single statement. 
  9568.  
  9569. If you redefine a data object inside a nested block, the inner object hides the 
  9570. outer object while the inner block is executed.  Defining several variables 
  9571. that have the same identifier can make a program difficult to understand and 
  9572. maintain.  Therefore, you should limit such redefinitions of identifiers within 
  9573. nested blocks. 
  9574.  
  9575. If a data object is usable within a block, all nested blocks can use that data 
  9576. object (unless that data object identifier is redefined). 
  9577.  
  9578. Initialization of an auto or register variable occurs each time the block is 
  9579. executed from the beginning.  If you transfer control from one block to the 
  9580. middle of another block, initializations are not always performed.  You cannot 
  9581. initialize an extern variable within a block. 
  9582.  
  9583. A static local object is initialized only once, when control passes through its 
  9584. declaration for the first time.  A static variables initialized with an 
  9585. expression other than a constant expression is initialized to 0 before its 
  9586. block is first entered. 
  9587.  
  9588. Note:  Unlike ANSI C, in C++ it is an error to jump over a declaration or 
  9589. definition containing an initializer. 
  9590.  
  9591. When control exits from a block, all objects with destructors that are defined 
  9592. in the block are destroyed. The destructor for a static local object is called 
  9593. only if the object was constructed.  The destructor must be called before or as 
  9594. part of the atexit function. 
  9595.  
  9596. Local variables declared in a block are also destroyed on exit. Automatic 
  9597. variables defined in a loop are destroyed at each iteration. 
  9598.  
  9599. Examples of Block Statements 
  9600.  
  9601. Related Information 
  9602.  
  9603. o Block Scope Data Declarations 
  9604. o Function Body 
  9605. o auto Storage Class Specifier 
  9606. o register Storage Class Specifier 
  9607. o static Storage Class Specifier 
  9608. o extern Storage Class Specifier 
  9609. o atexit - Record Program Termination Function 
  9610.  
  9611.  
  9612. ΓòÉΓòÉΓòÉ <hidden> Syntax of a Block Statement ΓòÉΓòÉΓòÉ
  9613.  
  9614. The block statement has the form: 
  9615.  
  9616.    ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ  ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  9617.                   Γöé          Γöé
  9618. ΓöÇΓöÇ{ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇ}ΓöÇΓöÇ
  9619.     Γöé              Γöé   Γöé       Γöé
  9620.     Γö£ΓöÇΓöÇtype_definitionΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ   ΓööΓöÇΓöÇstatementΓöÇΓöÇΓöÿ
  9621.     Γöé              Γöé
  9622.     Γö£ΓöÇΓöÇextern_declarationΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  9623.     Γöé              Γöé
  9624.     ΓööΓöÇΓöÇinternal_data_definitionΓöÇΓöÿ
  9625.  
  9626.  
  9627. ΓòÉΓòÉΓòÉ <hidden> Examples of Block Statements ΓòÉΓòÉΓòÉ
  9628.  
  9629. /************************************************************************
  9630. *
  9631.  
  9632. The following example shows how the values of data objects change in nested 
  9633. blocks: 
  9634.  
  9635.                                                                         *
  9636. ************************************************************************/
  9637.  
  9638.  1   #include <stdio.h>
  9639.  2
  9640.  3   int main(void)
  9641.  4   {
  9642.  5      int x = 1;                     /* Initialize x to 1  */
  9643.  6      int y = 3;
  9644.  7
  9645.  8      if (y > 0)
  9646.  9      {
  9647. 10         int x = 2;                  /* Initialize x to 2  */
  9648. 11         printf("second x = %4d\n", x);
  9649. 12      }
  9650. 13      printf("first  x = %4d\n", x);
  9651. 14   }
  9652.  
  9653. /************************************************************************
  9654. *
  9655. The preceding example produces the following output: 
  9656.  
  9657. second x =    2
  9658. first  x =    1
  9659.  
  9660. Two variables named x are defined in main.  The definition of x on line 5 
  9661. retains storage throughout the execution of main.  However, because the 
  9662. definition of x on line 10 occurs within a nested block, line 11 recognizes x 
  9663. as the variable defined on line 10.  Line 13 is not part of the nested block. 
  9664. Thus, line 13 recognizes x as the variable defined on line 5. 
  9665.  
  9666.                                                                         *
  9667. ************************************************************************/
  9668.  
  9669.  
  9670. ΓòÉΓòÉΓòÉ 8.3. break ΓòÉΓòÉΓòÉ
  9671.  
  9672. A break statement enables you to terminate and exit from a loop or switch 
  9673. statement from any point within the loop or switch other than the logical end. 
  9674. A break statement has the form: 
  9675.  
  9676. >>ΓöÇΓöÇbreakΓöÇΓöÇ;ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ><
  9677.  
  9678. In a looping statement (do, for, or while), the break statement ends the loop 
  9679. and moves control to the next statement outside the loop.  Within nested 
  9680. statements, the break statement ends only the smallest enclosing do, for, 
  9681. switch, or while statement. 
  9682.  
  9683. In a switch body, the break statement ends the execution of the switch body and 
  9684. gives control to the next statement outside the switch body. 
  9685.  
  9686. You can place a break statement only in the body of a looping statement (do, 
  9687. for or while) or in the body of a switch statement. 
  9688.  
  9689. Examples of break Statements 
  9690.  
  9691. Related Information 
  9692.  
  9693. o do 
  9694. o for 
  9695. o switch 
  9696. o while 
  9697.  
  9698.  
  9699. ΓòÉΓòÉΓòÉ <hidden> Examples of break Statements ΓòÉΓòÉΓòÉ
  9700.  
  9701. /************************************************************************
  9702. *
  9703.  
  9704. The following example shows a break statement in the action part of a for 
  9705. statement.  If the ith element of the array string is equal to '\0', the break 
  9706. statement causes the for statement to end. 
  9707.  
  9708. for (i = 0; i < 5; i++)
  9709. {
  9710.    if (string[i] == '\0')
  9711.       break;
  9712.    length++;
  9713. }
  9714.  
  9715. The preceding for statement is equivalent to the following for statement, if 
  9716. string does not contain any embedded null characters: 
  9717.  
  9718. for (i = 0; i < 5; i++)
  9719. {
  9720.    if (string[i] != '\0')
  9721.       length++;
  9722. }
  9723.  
  9724. The following example shows a break statement in a nested looping statement. 
  9725. The outer loop sequences an array of pointers to strings.  The inner loop 
  9726. examines each character of the string.  When the break statement is executed, 
  9727. the inner loop ends and control returns to the outer loop. 
  9728.  
  9729.                                                                         *
  9730. ************************************************************************/
  9731.  
  9732. /*
  9733. ** This program counts the characters in the strings that are
  9734. ** part of an array of pointers to characters.  The count stops
  9735. ** when one of the digits 0 through 9 is encountered
  9736. ** and resumes at the beginning of the next string.
  9737. */
  9738.  
  9739. #include <stdio&per.h>
  9740.  
  9741. #define  SIZE  3
  9742.  
  9743. int main(void)
  9744. {
  9745.    static char *strings[SIZE] = { "ab", "c5d", "e5" };
  9746.    int i;
  9747.    int letter_count = 0;
  9748.    char *pointer;
  9749.  
  9750.    for (i = 0; i < SIZE; i++)        /* for each string    */
  9751.                                      /* for each character */
  9752.       for (pointer = strings[i]; *pointer != '\0'; ++pointer)
  9753.       {                              /* if a number        */
  9754.          if (*pointer >= '0' && *pointer <= '9')
  9755.             break;
  9756.          letter_count++;
  9757.       }
  9758.    printf("letter count = %d\n", letter_count);
  9759. }
  9760.  
  9761. /************************************************************************
  9762. *
  9763.  
  9764. The preceding program produces the following output: 
  9765.  
  9766. letter count = 4
  9767.  
  9768. The following example is a switch statement that contains several break 
  9769. statements.  Each break statement indicates the end of a specific clause and 
  9770. ends the execution of the switch statement. 
  9771.  
  9772. enum {morning, afternoon, evening} timeofday;
  9773.  
  9774. switch (timeofday)
  9775. {
  9776.    case (morning):
  9777.       printf("Good Morning\n");
  9778.       break;
  9779.  
  9780.    case (evening):
  9781.       printf("Good Evening\n");
  9782.       break;
  9783.  
  9784.    default:
  9785.       printf("Good Day, eh\n");
  9786.       break;
  9787. }
  9788.  
  9789.                                                                         *
  9790. ************************************************************************/
  9791.  
  9792.  
  9793. ΓòÉΓòÉΓòÉ 8.4. continue ΓòÉΓòÉΓòÉ
  9794.  
  9795. A continue statement enables you to terminate the current iteration of a loop. 
  9796. Program control is passed from the location in the body of the loop in which 
  9797. the continue statement is found to the end of the loop body. A continue 
  9798. statement has the form: 
  9799.  
  9800. ΓöÇΓöÇcontinueΓöÇΓöÇ;ΓöÇΓöÇ
  9801.  
  9802. The continue statement ends the execution of the action part of a do, for, or 
  9803. while statement and moves control to the condition part of the statement.  If 
  9804. the looping statement is a for statement, control moves to the third expression 
  9805. in the condition part of the statement, and then to the second expression (the 
  9806. test) in the condition part of the statement. 
  9807.  
  9808. Within nested statements, the continue statement ends only the current 
  9809. iteration of the do, for, or while statement immediately enclosing it. 
  9810.  
  9811. You can place a continue statement only within the body of a looping statement 
  9812. (do, for or while). 
  9813.  
  9814. Examples of continue Statements 
  9815.  
  9816. Related Information 
  9817.  
  9818. o do 
  9819. o for 
  9820. o while 
  9821.  
  9822.  
  9823. ΓòÉΓòÉΓòÉ <hidden> Examples of continue Statements ΓòÉΓòÉΓòÉ
  9824.  
  9825. /************************************************************************
  9826. *
  9827.  
  9828. The following example shows a continue statement in a for statement.  The 
  9829. continue statement causes the system to skip over those elements of the array 
  9830. rates that have values less than or equal to 1. 
  9831.  
  9832.                                                                         *
  9833. ************************************************************************/
  9834.  
  9835. #include <stdio.h>
  9836.  
  9837. #define  SIZE  5
  9838.  
  9839. int main(void)
  9840. {
  9841.    int i;
  9842.    static float rates[SIZE] = { 1.45, 0.05, 1.88, 2.00, 0.75 };
  9843.  
  9844.    printf("Rates over 1.00\n");
  9845.    for (i = 0; i < SIZE; i++)
  9846.    {
  9847.       if (rates[i] <= 1.00)  /*  skip rates <= 1.00  */
  9848.          continue;
  9849.       printf("rate = %.2f\n", rates[i]);
  9850.    }
  9851. }
  9852.  
  9853. /************************************************************************
  9854. *
  9855.  
  9856. The preceding program produces the following output: 
  9857.  
  9858. Rates over 1.00
  9859. rate = 1.45
  9860. rate = 1.88
  9861. rate = 2.00
  9862.  
  9863. The following example shows a continue statement in a nested loop.  When the 
  9864. inner loop encounters a number in the array strings, that iteration of the loop 
  9865. is terminated. Execution continues with the third expression of the inner loop 
  9866. (See for).  The inner loop is terminated when the '\0' escape sequence is 
  9867. encountered. 
  9868.  
  9869.                                                                         *
  9870. ************************************************************************/
  9871.  
  9872. /************************************************************************
  9873. **     This program counts the characters in strings that are part     **
  9874. **     of an array of pointers to characters.  The count excludes      **
  9875. **     the digits 0 through 9.                                         **
  9876. *************************************************************************/
  9877.  
  9878. #include <stdio.h>
  9879.  
  9880. #define  SIZE  3
  9881.  
  9882. int main(void)
  9883. {
  9884.    static char *strings[SIZE] = { "ab", "c5d", "e5" };
  9885.    int i;
  9886.    int letter_count = 0;
  9887.    char *pointer;
  9888.    for (i = 0; i < SIZE; i++)            /* for each string         */
  9889.                                          /* for each each character */
  9890.       for (pointer = strings[i]; *pointer != '\0'; ++pointer)
  9891.       {                                  /* if a number              */
  9892.          if (*pointer >= '0' && *pointer <= '9')
  9893.             continue;
  9894.          letter_count++;
  9895.       }
  9896.    printf("letter count = %d\n", letter_count);
  9897. }
  9898.  
  9899. /************************************************************************
  9900. *
  9901.  
  9902. The preceding program produces the following output: 
  9903.  
  9904. letter count = 5
  9905.  
  9906.                                                                         *
  9907. ************************************************************************/
  9908.  
  9909.  
  9910. ΓòÉΓòÉΓòÉ 8.5. do ΓòÉΓòÉΓòÉ
  9911.  
  9912. A do statement repeatedly executes a statement until the test expression 
  9913. evaluates to 0.  Because of the order of execution, the statement is executed 
  9914. at least once. A do statement has the form: 
  9915.  
  9916. ΓöÇΓöÇdoΓöÇΓöÇstatementΓöÇΓöÇwhileΓöÇΓöÇ(ΓöÇΓöÇexpressionΓöÇΓöÇ)ΓöÇΓöÇ;ΓöÇΓöÇ
  9917.  
  9918. The body of the loop is executed before the while clause (the controlling 
  9919. expression) is evaluated.  Further execution of the do statement depends on the 
  9920. value of the while clause.  If the while clause does not evaluate to 0, the 
  9921. statement is executed again.  Otherwise, execution of the statement ends. 
  9922.  
  9923. The controlling expression must be of scalar type. 
  9924.  
  9925. A break, return, or goto statement can cause the execution of a do statement to 
  9926. end, even when the while clause does not evaluate to 0. 
  9927.  
  9928. Example of a do Statement 
  9929.  
  9930. Related Information 
  9931.  
  9932. o break 
  9933. o continue 
  9934. o for 
  9935. o goto 
  9936. o return 
  9937. o while 
  9938.  
  9939.  
  9940. ΓòÉΓòÉΓòÉ <hidden> Example of a do Statement ΓòÉΓòÉΓòÉ
  9941.  
  9942. /************************************************************************
  9943. *
  9944.  
  9945. The following statement prompts the user to enter a 1.  If the user enters a 1, 
  9946. the statement ends execution.  Otherwise, the statement displays another 
  9947. prompt. 
  9948.  
  9949.                                                                         *
  9950. ************************************************************************/
  9951.  
  9952. #include <stdio.h>
  9953.  
  9954. int main (void)
  9955. {
  9956.    int reply1;
  9957.  
  9958.    do
  9959.    {
  9960.       printf("Enter a 1\n");
  9961.       scanf("%d", &reply1);
  9962.    } while (reply1 != 1);
  9963. }
  9964.  
  9965.  
  9966. ΓòÉΓòÉΓòÉ 8.6. Expression ΓòÉΓòÉΓòÉ
  9967.  
  9968. An expression statement contains an expression.  Expressions are described in 
  9969. Expressions and Operators.  An expression statement has the form: 
  9970.  
  9971. ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ;ΓöÇΓöÇ
  9972.   Γöé        Γöé
  9973.   ΓööΓöÇΓöÇexpressionΓöÇΓöÇΓöÿ
  9974.  
  9975. An expression statement evaluates the given expression.  An expression 
  9976. statement is used to assign the value of the expression to a variable or to 
  9977. call a function. 
  9978.  
  9979. The following are examples of expressions: 
  9980.  
  9981. printf("Account Number: \n");             /* A call to printf          */
  9982. marks = dollars * exch_rate;                        /* An assignment to marks    */
  9983. (difference < 0) ? ++losses : ++gain;            /* A conditional increment   */
  9984. switches = flags | BIT_MASK;              /* An assignment to switches */
  9985.  
  9986. Related Information 
  9987.  
  9988. o Expressions and Operators 
  9989. o Resolving Ambiguous Statements 
  9990.  
  9991.  
  9992. ΓòÉΓòÉΓòÉ 8.7. for ΓòÉΓòÉΓòÉ
  9993.  
  9994. A for statement enables you to do the following: 
  9995.  
  9996. o Evaluate an expression prior to the first iteration of the statement 
  9997.   ("initialization") 
  9998. o Specify an expression to determine whether or not the statement should be 
  9999.   executed ("controlling part") 
  10000. o Evaluate an expression after each iteration of the statement 
  10001.  
  10002. A for statement has the form: 
  10003.  
  10004. ΓöÇΓöÇforΓöÇΓöÇ(ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ;ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ;ΓöÇΓöÇ
  10005.       Γöé        Γöé   Γöé        Γöé
  10006.       ΓööΓöÇΓöÇexpression1ΓöÇΓöÇΓöÿ   ΓööΓöÇΓöÇexpression2ΓöÇΓöÇΓöÿ
  10007.  
  10008.  
  10009. ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ)ΓöÇΓöÇstatementΓöÇΓöÇ
  10010.   Γöé        Γöé
  10011.   ΓööΓöÇΓöÇexpression3ΓöÇΓöÇΓöÿ
  10012.  
  10013. The compiler evaluates expression1 only once; before the statement is executed 
  10014. for the first time.  You can use this expression to initialize a variable.  If 
  10015. you do not want to evaluate an expression prior to the first iteration of the 
  10016. statement, you can omit this expression. In C++ programs, you can also use 
  10017. expression1 to declare a variable as well as initialize it.  If you declare a 
  10018. variable in this expression, the variable has the same scope as the for 
  10019. statement and is not local to the for statement. 
  10020.  
  10021. The compiler evaluates expression2 before each execution of the statement. 
  10022. expression2 must evaluate to a scalar type. If this expression evaluates to 0, 
  10023. the for statement is terminated and control moves to the statement following 
  10024. the for statement.  Otherwise, the statement is executed.  If you omit 
  10025. expression2, it will be as if the expression had been replaced by a nonzero 
  10026. constant and the for statement will not be terminated by failure of this 
  10027. condition. 
  10028.  
  10029. The compiler evaluates expression3 after each execution of the statement.  You 
  10030. can use this expression to increase, decrease, or reinitialize a variable.  If 
  10031. you do not want to evaluate an expression after each iteration of the 
  10032. statement, you can omit this expression. 
  10033.  
  10034. A break, return, or goto statement can cause the execution of a for statement 
  10035. to end, even when the second expression does not evaluate to 0.  If you omit 
  10036. expression2, you must use a break, return, or goto statement to stop the 
  10037. execution of the for statement. 
  10038.  
  10039. Examples of for Statements 
  10040.  
  10041. Related Information 
  10042.  
  10043. o break 
  10044. o continue 
  10045. o do 
  10046. o return 
  10047. o goto 
  10048. o while 
  10049. o Expressions and Operators 
  10050.  
  10051.  
  10052. ΓòÉΓòÉΓòÉ <hidden> Examples of for Statements ΓòÉΓòÉΓòÉ
  10053.  
  10054. The following for statement prints the value of count 20 times.  The for 
  10055. statement initially sets the value of count to 1.  After each execution of the 
  10056. statement, count is incremented. 
  10057.  
  10058. for (count = 1; count <= 20; count++)
  10059.    printf("count = %d\n", count);
  10060.  
  10061. For comparison purposes, the preceding example can be written using the 
  10062. following sequence of statements to accomplish the same task.  Note the use of 
  10063. the while statement instead of the for statement. 
  10064.  
  10065. count = 1;
  10066. while (count <= 20)
  10067. {
  10068.    printf("count = %d\n", count);
  10069.    count++;
  10070. }
  10071.  
  10072. The following for statement does not contain an initialization expression: 
  10073.  
  10074. for (; index > 10; --index)
  10075. {
  10076.    list[index] = var1 + var2;
  10077.    printf("list[%d] = %d\n", index, list[index]);
  10078. }
  10079.  
  10080. The following for statement will continue executing until scanf receives the 
  10081. letter e: 
  10082.  
  10083. for (;;)
  10084. {
  10085.    scanf("%c", &letter);
  10086.    if (letter == '\n')
  10087.       continue;
  10088.    if (letter == 'e')
  10089.       break;
  10090.    printf("You entered the letter %c\n", letter);
  10091. }
  10092.  
  10093. The following for statement contains multiple initializations and increments. 
  10094. The comma operator makes this construction possible. The first comma in the for 
  10095. expression is a punctuator for a declaration; that is, it declares and 
  10096. initializes two integers, i and j.  The second comma, a comma operator, allows 
  10097. both i and j to be incremented at each step through the loop. 
  10098.  
  10099. for (int i = 0, j = 50; i < 10; ++i, j += 50)
  10100. {
  10101.    cout << "i = " << i << "and j = " << j << endl;
  10102. }
  10103.  
  10104. The following example shows a nested for statement.  The outer statement is 
  10105. executed as long as the value of row is less than 5.  Each time the outer for 
  10106. statement is executed, the inner for statement sets the initial value of column 
  10107. to zero and the statement of the inner for statement is executed 3 times.  The 
  10108. inner statement is executed as long as the value of column is less than 3. 
  10109. This example prints the values of an array having the dimensions [5][3]: 
  10110.  
  10111. for (row = 0; row < 5; row++)
  10112.    for (column = 0; column < 3; column++)
  10113.       printf("%d\n", table[row][column]);
  10114.  
  10115.  
  10116. ΓòÉΓòÉΓòÉ 8.8. goto ΓòÉΓòÉΓòÉ
  10117.  
  10118. A goto statement causes your program to unconditionally transfer control to the 
  10119. statement associated with the label specified on the goto statement.  A goto 
  10120. statement has the form: 
  10121.  
  10122. ΓöÇΓöÇgotoΓöÇΓöÇidentifierΓöÇΓöÇ;ΓöÇΓöÇ
  10123.  
  10124. The goto statement transfers control to the statement indicated by the 
  10125. identifier. 
  10126.  
  10127. Use the goto statement sparingly.  Because the goto statement can interfere 
  10128. with the normal top-to-bottom sequence of execution, it makes a program more 
  10129. difficult to read and maintain.  Often, a break statement, a continue 
  10130. statement, or a function call can eliminate the need for a goto statement. 
  10131.  
  10132. If you use a goto statement to transfer control to a statement inside of a loop 
  10133. or block, initializations of automatic storage for the loop do not take place 
  10134. and the result is undefined.  The label must appear in the same function as the 
  10135. goto. 
  10136.  
  10137. If an active block is exited using a goto statement, any local variables are 
  10138. destroyed when control is transferred from that block. 
  10139.  
  10140. Example of a goto Statement 
  10141.  
  10142. Related Information 
  10143.  
  10144. o Labels 
  10145. o break 
  10146. o continue 
  10147. o Functions 
  10148.  
  10149.  
  10150. ΓòÉΓòÉΓòÉ <hidden> Example of a goto Statement ΓòÉΓòÉΓòÉ
  10151.  
  10152. The following example shows a goto statement that is used to jump out of a 
  10153. nested loop.  This function could be written without using a goto statement. 
  10154.  
  10155. void display(int matrix[3][3])
  10156. {
  10157.    int i, j;
  10158.  
  10159.    for (i = 0; i < 3; i++)
  10160.       for (j = 0; j < 3; j++)
  10161.       {
  10162.          if ( (matrix[i][j] < 1) || (matrix[i][j] > 6) )
  10163.             goto out_of_bounds;
  10164.          printf("matrix[%d][%d] = %d\n", i, j, matrix[i][j]);
  10165.       }
  10166.    return;
  10167.    out_of_bounds: printf("number must be 1 through 6\n");
  10168. }
  10169.  
  10170.  
  10171. ΓòÉΓòÉΓòÉ 8.9. if ΓòÉΓòÉΓòÉ
  10172.  
  10173. An if statement allows you to conditionally execute a statement when the 
  10174. specified test expression evaluates to a nonzero value.  The expression must 
  10175. have a scalar type.  You may optionally specify an else clause on the if 
  10176. statement.  If the test expression evaluates to 0 and an else clause exists, 
  10177. the statement associated with the else clause is executed.  An if statement has 
  10178. the form: 
  10179.  
  10180. ΓöÇΓöÇifΓöÇΓöÇ(ΓöÇΓöÇexpressionΓöÇΓöÇ)ΓöÇΓöÇstatementΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ
  10181.                    Γöé          Γöé
  10182.                    ΓööΓöÇΓöÇelseΓöÇΓöÇstatementΓöÇΓöÇΓöÿ
  10183.  
  10184. When if statements are nested and else clauses are present, a given else is 
  10185. associated with the closest preceding if statement within the same block. 
  10186.  
  10187. Examples of if Statements 
  10188.  
  10189. Related Information 
  10190.  
  10191. o Conditional Compilation 
  10192. o switch 
  10193.  
  10194.  
  10195. ΓòÉΓòÉΓòÉ <hidden> Examples of if Statements ΓòÉΓòÉΓòÉ
  10196.  
  10197. The following example causes grade to receive the value A if the value of score 
  10198. is greater than or equal to 90. 
  10199.  
  10200. if (score >= 90)
  10201.    grade = 'A';
  10202.  
  10203. The following example displays number is positive if the value of number is 
  10204. greater than or equal to 0. Otherwise, the example displays number is negative. 
  10205.  
  10206. if (number >= 0)
  10207.    printf("number is positive\n");
  10208. else
  10209.    printf("number is negative\n");
  10210.  
  10211. The following example shows a nested if statement: 
  10212.  
  10213. if (paygrade == 7)
  10214.    if (level >= 0 && level <= 8)
  10215.       salary *= 1.05;
  10216.    else
  10217.       salary *= 1.04;
  10218. else
  10219.    salary *= 1.06;
  10220. cout << "salary is " << salary << endl;
  10221.  
  10222. The following example shows an if statement that does not have an else clause. 
  10223. Because an else clause always associates with the closest if statement, braces 
  10224. may be necessary to force a particular else clause to associate with the 
  10225. correct if statement.  In this example, omitting the braces would cause the 
  10226. else clause to associate with the nested if statement. 
  10227.  
  10228. if (gallons > 0) {
  10229.    if (miles > gallons)
  10230.       mpg = miles/gallons;
  10231. }
  10232. else
  10233.    mpg = 0;
  10234.  
  10235. The following example shows an if statement nested within an else clause.  This 
  10236. example tests multiple conditions.  The tests are made in order of their 
  10237. appearance.  If one test evaluates to a nonzero value, a statement executes and 
  10238. the entire if statement ends. 
  10239.  
  10240. if (value > 0)
  10241.    ++increase;
  10242. else if (value == 0)
  10243.    ++break_even;
  10244. else
  10245.    ++decrease;
  10246.  
  10247.  
  10248. ΓòÉΓòÉΓòÉ 8.10. Null Statement ΓòÉΓòÉΓòÉ
  10249.  
  10250. The null statement performs no operation and has the form: 
  10251.  
  10252. ΓöÇΓöÇ;ΓöÇΓöÇ
  10253.  
  10254. You can use a null statement in a looping statement to show a nonexistent 
  10255. action or in a labeled statement to hold the label. 
  10256.  
  10257. The following example initializes the elements of the array price. Because the 
  10258. initializations occur within the for expressions, a statement is only needed to 
  10259. finish the for syntax;  no operations are required. 
  10260.  
  10261. for (i = 0; i < 3; price[i++] = 0)
  10262.    ;
  10263.  
  10264. Related Information 
  10265.  
  10266. o # (Null Directive) 
  10267. o Labels 
  10268.  
  10269.  
  10270. ΓòÉΓòÉΓòÉ 8.11. return ΓòÉΓòÉΓòÉ
  10271.  
  10272. A return statement terminates the execution of the current function and returns 
  10273. control to the caller of the function. A return statement has the form: 
  10274.  
  10275. ΓöÇΓöÇreturnΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ;ΓöÇΓöÇ
  10276.       Γöé        Γöé
  10277.       ΓööΓöÇΓöÇexpressionΓöÇΓöÇΓöÿ
  10278.  
  10279. A return statement ends the execution of the current function. 
  10280.  
  10281. A return statement is optional.  If the system reaches the end of a function 
  10282. without encountering a return statement, control is passed to the caller as if 
  10283. a return statement without an expression were encountered. 
  10284.  
  10285. A function can contain multiple return statements. 
  10286.  
  10287. If an expression is present on a return statement, the value of the expression 
  10288. is returned to the caller.  If the data type of the expression is different 
  10289. from the data type of the function, conversion of the return value takes place 
  10290. as if the value of the expression were assigned to an object with the same data 
  10291. type as the function. 
  10292.  
  10293. If an expression is not present on a return statement, the value of the return 
  10294. statement is not defined. If an expression is not given on a return statement 
  10295. and the calling function is expecting a value to be returned, the resulting 
  10296. behavior is undefined. 
  10297.  
  10298. You cannot use a return statement with an expression when the function is 
  10299. declared as returning type void. 
  10300.  
  10301. If a function returns a class object with constructors, a temporary class 
  10302. object may be constructed.  The temporary object is not in the scope of the 
  10303. function returning the temporary object but is local to the caller of the 
  10304. function. 
  10305.  
  10306. When a function returns, all temporary local variables are destroyed. If local 
  10307. class objects with destructors exist, destructors are called.  For more 
  10308. details, see Temporary Objects. 
  10309.  
  10310. You can use the /Wret compiler option to generate diagnostic messages about the 
  10311. use of return statements in your functions. 
  10312.  
  10313. Examples of return Statements 
  10314.  
  10315. Related Information 
  10316.  
  10317. o Functions 
  10318. o Using the /Wgrp Diagnostic Options 
  10319. o Temporary Objects 
  10320. o Expression 
  10321.  
  10322.  
  10323. ΓòÉΓòÉΓòÉ <hidden> Examples of return Statements ΓòÉΓòÉΓòÉ
  10324.  
  10325. The following are examples of return statements: 
  10326.  
  10327. return;            /* Returns no value            */
  10328. return result;     /* Returns the value of result */
  10329. return 1;          /* Returns the value 1         */
  10330. return (x * x);    /* Returns the value of x * x  */
  10331.  
  10332. The following function searches through an array of integers to determine if a 
  10333. match exists for the variable number.  If a match exists, the function match 
  10334. returns the value of i.  If a match does not exist, the function match returns 
  10335. the value -1 (negative one). 
  10336.  
  10337. int match(int number, int array[ ], int n)
  10338. {
  10339.    int i;
  10340.  
  10341.    for (i = 0; i < n; i++)
  10342.       if (number == array[i])
  10343.          return (i);
  10344.    return(-1);
  10345. }
  10346.  
  10347.  
  10348. ΓòÉΓòÉΓòÉ 8.12. switch ΓòÉΓòÉΓòÉ
  10349.  
  10350. A switch statement enables you to transfer control to different statements 
  10351. within the switch body depending on the value of the switch expression.  The 
  10352. switch expression must have an integral type. Within the body of the switch 
  10353. statement, there are case labels that consist of a label, a case expression 
  10354. (that evaluates to an integral value), and statements, plus an optional default 
  10355. label. If the value of the switch expression equals the value of one of the 
  10356. case expressions, the statements following that case expression are executed. 
  10357. Otherwise, the default label statements, if any, are executed. A switch 
  10358. statement has the form: 
  10359.  
  10360. ΓöÇΓöÇswitchΓöÇΓöÇ(ΓöÇΓöÇexpressionΓöÇΓöÇ)ΓöÇΓöÇswitch_bodyΓöÇΓöÇ
  10361.  
  10362. A switch body can have a simple or complex form.  The simple form contains any 
  10363. number of case labels mixed with an optional default label.  The simple form 
  10364. ends with a single statement.  Because only the final case or default label can 
  10365. be followed by a statement, the simple form of the switch body is rarely used 
  10366. in C language programs.  An if statement usually can replace a switch statement 
  10367. that has a simple switch body. 
  10368.  
  10369. The complex form of a switch body is enclosed in braces and can contain 
  10370. definitions, declarations, case clauses, and a default clause.  Each case and 
  10371. default clause can contain statements. 
  10372.  
  10373. Syntax of a switch Body 
  10374.  
  10375. A case clause contains a case label followed by any number of statements. A 
  10376. case label contains the word case followed by a constant expression and a 
  10377. colon.  Anywhere you can place one case label, you can place multiple case 
  10378. labels. A default clause contains a default label followed by one or more 
  10379. statements.  You can place a case label on either side of the default label. A 
  10380. default_label contains the word default and a colon.  A switch statement can 
  10381. have only one default label. 
  10382.  
  10383. The switch statement passes control to the statement following one of the 
  10384. labels or to the statement following the switch body.  The value of the 
  10385. expression that precedes the switch body determines which statement receives 
  10386. control. This expression is called the switch expression. 
  10387.  
  10388. The value of the switch expression is compared with the value of the expression 
  10389. in each case label.  If a matching value is found, control is passed to the 
  10390. statement following the case label that contains the matching value. If the 
  10391. system does not find a matching value and a default label appears anywhere in 
  10392. the switch body, control passes to the default labelled statement.  Otherwise, 
  10393. no part of the switch body is executed. 
  10394.  
  10395. If control passes to a statement in the switch body, control does not pass from 
  10396. the switch body until a break statement is encountered or the last statement in 
  10397. the switch body is executed. 
  10398.  
  10399. An integral promotion is performed on the controlling expression, if necessary, 
  10400. and all expressions in the case statements are converted to the same type as 
  10401. the controlling expression. 
  10402.  
  10403. Restrictions 
  10404. The switch expression and the case expressions must have an integral type.  The 
  10405. value of each case expression must represent a different value and must be a 
  10406. constant expression. 
  10407.  
  10408. Only one default label can occur in each switch statement. 
  10409.  
  10410. You can place data definitions at the beginning of the switch body.  However, 
  10411. the compiler does not initialize auto and register variables at the beginning 
  10412. of a switch body. 
  10413.  
  10414. C++ Consideration:  You can have declarations in the body of the switch 
  10415. statement.  In C++, you cannot transfer control over a declaration containing 
  10416. an initializer unless the declaration is located in an inner block that is 
  10417. completely bypassed by the transfer of control. All declarations within the 
  10418. body of a switch statement that contain initializers must be contained in an 
  10419. inner block. 
  10420.  
  10421. Examples of switch Statements 
  10422.  
  10423. Related Information 
  10424.  
  10425. o break 
  10426. o if 
  10427. o Labels 
  10428. o Expression 
  10429. o Types 
  10430. o Storage Class Specifiers 
  10431.  
  10432.  
  10433. ΓòÉΓòÉΓòÉ <hidden> Syntax of a switch Body ΓòÉΓòÉΓòÉ
  10434.  
  10435. The simple form of a switch body is shown below: 
  10436.  
  10437. ΓöÇΓöÇΓö¼ΓöÇΓöÇcase_labelΓöÇΓöÇstatementΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ
  10438.   Γöé                                Γöé
  10439.   ΓööΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇdefault_labelΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇstatementΓöÇΓöÇΓöÿ
  10440.    Γöé        Γöé         Γöé        Γöé
  10441.    ΓööΓöÇΓöÇcase_labelΓöÇΓöÇΓöÿ         ΓööΓöÇΓöÇcase_labelΓöÇΓöÇΓöÿ
  10442.  
  10443. The complex form of a switch body is shown below: 
  10444.  
  10445.    ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  10446.                    Γöé          Γöé
  10447. ΓöÇΓöÇ{ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇ
  10448.     Γöé               Γöé  Γöé        Γöé
  10449.     Γö£ΓöÇΓöÇtype_definitionΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ  ΓööΓöÇΓöÇcase_clauseΓöÇΓöÇΓöÿ
  10450.     Γöé               Γöé
  10451.     Γö£ΓöÇΓöÇextern_declarationΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  10452.     Γöé               Γöé
  10453.     ΓööΓöÇΓöÇinternal_data_definitionΓöÇΓöÇΓöÿ
  10454.  
  10455.             ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  10456.                      Γöé
  10457. ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇ}ΓöÇΓöÇ
  10458.   Γöé          Γöé  Γöé        Γöé
  10459.   ΓööΓöÇΓöÇdefault_clauseΓöÇΓöÇΓöÿ  ΓööΓöÇΓöÇcase_clauseΓöÇΓöÇΓöÿ
  10460.  
  10461. A case clause has the form: 
  10462.  
  10463.         ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  10464.               Γöé
  10465. ΓöÇΓöÇcase_labelΓöÇΓöÇΓöÇstatementΓöÇΓö┤ΓöÇΓöÇ
  10466.  
  10467. A case label has the form: 
  10468.  
  10469.   ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  10470.                   Γöé
  10471. ΓöÇΓöÇΓöÇcaseΓöÇΓöÇconstant_expressionΓöÇΓöÇ:ΓöÇΓö┤ΓöÇ
  10472.  
  10473. A default clause has the form: 
  10474.  
  10475.                            ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  10476.                                  Γöé
  10477. ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇdefault_labelΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇstatementΓöÇΓö┤ΓöÇ
  10478.   Γöé        Γöé         Γöé        Γöé
  10479.   ΓööΓöÇΓöÇcase_labelΓöÇΓöÇΓöÿ         ΓööΓöÇΓöÇcase_labelΓöÇΓöÇΓöÿ
  10480.  
  10481. A default label has the form: 
  10482.  
  10483. ΓöÇΓöÇdefaultΓöÇΓöÇ:ΓöÇΓöÇ
  10484.  
  10485.  
  10486. ΓòÉΓòÉΓòÉ <hidden> Examples of switch Statements ΓòÉΓòÉΓòÉ
  10487.  
  10488. The following switch statement contains several case clauses and one default 
  10489. clause.  Each clause contains a function call and a break statement. The break 
  10490. statements prevent control from passing down through each statement in the 
  10491. switch body. 
  10492.  
  10493. If the switch expression evaluated to '/', the switch statement would call the 
  10494. function divide.  Control would then pass to the statement following the switch 
  10495. body. 
  10496.  
  10497. char key;
  10498.  
  10499. cout << "Enter an arithmetic operator\n");
  10500. cin >> key;
  10501.  
  10502. switch (key)
  10503. {
  10504.    case '+':
  10505.       add();
  10506.       break;
  10507.  
  10508.    case '-':
  10509.       subtract();
  10510.       break;
  10511.  
  10512.    case '*':
  10513.       multiply();
  10514.       break;
  10515.  
  10516.    case '/':
  10517.       divide();
  10518.       break;
  10519.  
  10520.    default:
  10521.       cout << "The key you pressed is not valid\n";
  10522.       break;
  10523. }
  10524.  
  10525. If the switch expression matches a case expression, the statements following 
  10526. the case expression are executed until a break statement is encountered or the 
  10527. end of the switch body is reached.  In the following example, break statements 
  10528. are not present.  If the value of text[i] is equal to 'A', all three counters 
  10529. are incremented.  If the value of text[i] is equal to 'a', lettera and total 
  10530. are increased.  Only total is increased if text[i] is not equal to 'A' or 'a'. 
  10531.  
  10532. char text[100];
  10533. int capa, lettera, total;
  10534.  
  10535. for (i=0; i<sizeof(text); i++) {
  10536.  
  10537.     switch (text[i])
  10538.     {
  10539.        case 'A':
  10540.          capa++;
  10541.        case 'a':
  10542.          lettera++;
  10543.        default:
  10544.          total++;
  10545.     }
  10546. }
  10547.  
  10548. The following switch statement performs the same statements for more than one 
  10549. case label: 
  10550.  
  10551. int month;
  10552. switch (month)
  10553. {
  10554.    case 12:
  10555.    case 1:
  10556.    case 2:
  10557.       printf("month %d is a winter month\n", month);
  10558.       break;
  10559.  
  10560.    case 3:
  10561.    case 4:
  10562.    case 5:
  10563.       printf("month %d is a spring month\n", month);
  10564.       break;
  10565.  
  10566.    case 6:
  10567.    case 7:
  10568.    case 8:
  10569.       printf("month %d is a summer month\n", month);
  10570.       break;
  10571.  
  10572.    case 9:
  10573.    case 10:
  10574.    case 11:
  10575.       printf("month %d is a fall month\n", month);
  10576.       break;
  10577.  
  10578.    default:
  10579.       printf("not a valid month\n");
  10580.       break;
  10581. }
  10582.  
  10583. If the expression month had the value 3, control would be passed to the 
  10584. statement: 
  10585.  
  10586. printf("month %d is a spring month\n", month);
  10587.  
  10588. The break statement would pass control to the statement following the switch 
  10589. body. 
  10590.  
  10591.  
  10592. ΓòÉΓòÉΓòÉ 8.13. while ΓòÉΓòÉΓòÉ
  10593.  
  10594. A while statement enables you to repeatedly execute the body of a loop until 
  10595. the controlling expression evaluates to 0. A while statement has the form: 
  10596.  
  10597. ΓöÇΓöÇwhileΓöÇΓöÇ(ΓöÇΓöÇexpressionΓöÇΓöÇ)ΓöÇΓöÇstatementΓöÇΓöÇ
  10598.  
  10599. The expression is evaluated to determine whether or not the body of the loop 
  10600. should be executed. The expression must be a scalar type.  If the expression 
  10601. evaluates to 0, the statement terminates and the body of the loop is never 
  10602. executed.  Otherwise, the body is executed.  After the body has been executed, 
  10603. control is given once again to the expression.  Further execution of the action 
  10604. depends on the value of the condition. 
  10605.  
  10606. A break, return, or goto statement can cause the execution of a while statement 
  10607. to end, even when the condition does not evaluate to 0. 
  10608.  
  10609. Example of a while Statement 
  10610.  
  10611. Related Information 
  10612.  
  10613. o break 
  10614. o continue 
  10615. o do 
  10616. o for 
  10617. o goto 
  10618. o return 
  10619.  
  10620.  
  10621. ΓòÉΓòÉΓòÉ <hidden> Example fo a while Statement ΓòÉΓòÉΓòÉ
  10622.  
  10623. /************************************************************************
  10624. *
  10625.  
  10626. In the following program, item[index] triples each time the value of the 
  10627. expression ++index is less than MAX_INDEX.  When ++index evaluates to 
  10628. MAX_INDEX, the while statement ends. 
  10629.  
  10630.                                                                         *
  10631. ************************************************************************/
  10632.  
  10633. #define MAX_INDEX  (sizeof(item) / sizeof(item[0]))
  10634.  
  10635. #include <stdio.h>
  10636.  
  10637. int main(void)
  10638. {
  10639.    static int item[ ] = { 12, 55, 62, 85, 102 };
  10640.    int index = 0;
  10641.  
  10642.    while (index < MAX_INDEX)
  10643.    {
  10644.       item[index] *= 3;
  10645.       printf("item[%d] = %d\n", index, item[index]);
  10646.       ++index;
  10647.    }
  10648. }
  10649.  
  10650.  
  10651. ΓòÉΓòÉΓòÉ 9. Preprocessor Directives ΓòÉΓòÉΓòÉ
  10652.  
  10653. This section describes the preprocessor directives. Preprocessing is a step in 
  10654. the compilation process that enables you to: 
  10655.  
  10656. o Replace tokens in the current file with specified replacement tokens.  A 
  10657.   token is a series of characters delimited by white space. The only white 
  10658.   space allowed on a preprocessor directive is the space, horizontal tab, and 
  10659.   comments. 
  10660. o Imbed files within the current file 
  10661. o Conditionally compile sections of the current file 
  10662. o Change the line number of the next line of source and change the file name of 
  10663.   the current file 
  10664. o Generate diagnostic messages. 
  10665.  
  10666. The preprocessor recognizes the following directives: 
  10667.  
  10668. o #define 
  10669. o #undef 
  10670. o #error 
  10671. o #include 
  10672. o #if, #elif 
  10673. o #ifdef 
  10674. o #ifndef 
  10675. o #else 
  10676. o #endif 
  10677. o #line 
  10678. o #pragma 
  10679.  
  10680. This section also describes: 
  10681.  
  10682. o The # operator 
  10683. o Macro concatenation with the ## operator 
  10684. o The null directive (#) 
  10685. o Predefined macros. 
  10686.  
  10687. The format of a preprocessor directive is described in Preprocessor Directive 
  10688. Format. 
  10689.  
  10690. Related Information 
  10691.  
  10692. o Preprocessor Options 
  10693.  
  10694.  
  10695. ΓòÉΓòÉΓòÉ 9.1. Preprocessor Directive Format ΓòÉΓòÉΓòÉ
  10696.  
  10697. Preprocessor directives begin with the # token followed by a preprocessor 
  10698. keyword.  The # token must appear as the first character that is not white 
  10699. space on a line. 
  10700.  
  10701. A preprocessor directive ends at the new-line character unless the last 
  10702. character of the line is the \ (backslash) character.  If the \ character 
  10703. appears as the last character in the preprocessor line, the preprocessor 
  10704. interprets the \ and the new-line character as a continuation marker and 
  10705. interprets the following line as a continuation of the current preprocessor 
  10706. line. 
  10707.  
  10708. Preprocessor directives can appear anywhere in a program. 
  10709.  
  10710. Related Information 
  10711.  
  10712. o Preprocessor Directives 
  10713.  
  10714.  
  10715. ΓòÉΓòÉΓòÉ 9.2. #define ΓòÉΓòÉΓòÉ
  10716.  
  10717. A preprocessor define directive directs the preprocessor to replace all 
  10718. subsequent occurrences of a macro with specified replacement tokens.  A 
  10719. preprocessor #define directive has the form: 
  10720.  
  10721.                              ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  10722.                                     Γöé
  10723. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇdefineΓöÇΓöÇidentifierΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇΓöÇ><
  10724.                Γöé   ΓöîΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ   Γöé  Γö£ΓöÇidentiferΓöÇΓöñ
  10725.                Γöé           Γöé   Γöé  Γöé      Γöé
  10726.                ΓööΓöÇ(ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇΓöÇ)ΓöÇΓöÿ  ΓööΓöÇcharacterΓöÇΓöÿ
  10727.                   ΓööΓöÇidentifierΓöÇΓöÿ
  10728.  
  10729. The #define directive can contain an object-like definition or a function-like 
  10730. definition 
  10731.  
  10732. A macro invocation must have the same number of arguments as the corresponding 
  10733. macro definition has parameters. 
  10734.  
  10735. In the macro invocation argument list, commas that appear as character 
  10736. constants, in string constants or surrounded by parentheses, do not separate 
  10737. arguments. 
  10738.  
  10739. The scope of a macro definition begins at the definition and does not end until 
  10740. a corresponding #undef directive is encountered.  If there is no corresponding 
  10741. #undef directive, the scope of the macro definition lasts until the end of the 
  10742. compilation is reached. 
  10743.  
  10744. A recursive macro is not fully expanded.  For example, the definition 
  10745.  
  10746.    #define x(a,b) x(a+1,b+1) + 4
  10747.  
  10748. would expand   x(20,10)   to   x(20+1,10+1) + 4   rather than trying to expand 
  10749. the macro x over and over within itself. 
  10750.  
  10751. A definition is not required to specify replacement tokens.  The following 
  10752. definition removes all instances of the token static from subsequent lines in 
  10753. the current file: 
  10754.  
  10755. #define static
  10756.  
  10757. You can change the definition of a defined identifier or macro with a second 
  10758. preprocessor #define directive only if the second preprocessor #define 
  10759. directive is preceded by a preprocessor #undef directive.  See #undef. The 
  10760. #undef directive nullifies the first definition so that the same identifier can 
  10761. be used in a redefinition. 
  10762.  
  10763. You can also use the /D compiler option to define macros on the command line. 
  10764. Macros defined on the command line override macros defined in the source code. 
  10765.  
  10766. Within the text of the program, the preprocessor does not scan character 
  10767. constants or string constants for macro invocations. 
  10768.  
  10769. Examples of #define Directives 
  10770.  
  10771. Related Information 
  10772.  
  10773. o Object-Like Macro Definition 
  10774. o Function-Like Macro Definition 
  10775. o #undef 
  10776. o /D option 
  10777. o # Operator 
  10778. o ## Operator 
  10779.  
  10780.  
  10781. ΓòÉΓòÉΓòÉ 9.2.1. Object-Like Macro Definition ΓòÉΓòÉΓòÉ
  10782.  
  10783. An object-like macro definition replaces a single identifier with the specified 
  10784. replacement tokens.  The following object-like definition causes the 
  10785. preprocessor to replace all subsequent instances of the identifier COUNT with 
  10786. the constant 1000: 
  10787.  
  10788. #define COUNT 1000
  10789.  
  10790. This definition would cause the preprocessor to change the following statement 
  10791. (if the statement appears after the previous definition): 
  10792.  
  10793. int arry[COUNT];
  10794.  
  10795. In the output of the preprocessor, the preceding statement would appear as: 
  10796.  
  10797. int arry[1000];
  10798.  
  10799. The following definition references the previously defined identifier COUNT: 
  10800.  
  10801. #define MAX_COUNT COUNT + 100
  10802.  
  10803. The preprocessor replaces each subsequent occurrence of MAX_COUNT with 
  10804. COUNT + 100, which the preprocessor then replaces with 1000 + 100. 
  10805.  
  10806.  
  10807. ΓòÉΓòÉΓòÉ 9.2.2. Function-Like Macro Definition ΓòÉΓòÉΓòÉ
  10808.  
  10809. Function-like macro definition: 
  10810.      An identifier followed by a parenthesized parameter list and the 
  10811.      replacement tokens.  White space cannot separate the identifier (which is 
  10812.      the name of the macro) and the left parenthesis of the parameter list.  A 
  10813.      comma must separate each parameter.  For portability, you should not have 
  10814.      more than 31 parameters for a macro. 
  10815. Function-like macro invocation: 
  10816.      An identifier followed by a parenthesized list of arguments.  A comma must 
  10817.      separate each argument. Once the preprocessor identifies a function-like 
  10818.      macro invocation, argument substitution takes place.  A parameter in the 
  10819.      replacement code is replaced by the corresponding argument. Any macro 
  10820.      invocations contained in the argument itself are completely replaced 
  10821.      before the argument replaces its corresponding parameter in the 
  10822.      replacement code. 
  10823.  
  10824. The following line defines the macro SUM as having two parameters a and b and 
  10825. the replacement tokens (a + b): 
  10826.  
  10827. #define SUM(a,b) (a + b)
  10828.  
  10829. This definition would cause the preprocessor to change the following statements 
  10830. (if the statements appear after the previous definition): 
  10831.  
  10832. c = SUM(x,y);
  10833. c = d * SUM(x,y);
  10834.  
  10835. In the output of the preprocessor, the preceding statements would appear as: 
  10836.  
  10837. c = (x + y);
  10838. c = d * (x + y);
  10839.  
  10840.  
  10841. ΓòÉΓòÉΓòÉ <hidden> Examples of #define Directives ΓòÉΓòÉΓòÉ
  10842.  
  10843. /************************************************************************
  10844. *
  10845.  
  10846. The following program contains two macro definitions and a macro invocation 
  10847. that references both of the defined macros: 
  10848.  
  10849.                                                                         *
  10850. ************************************************************************/
  10851.  
  10852. #include <stdio.h>
  10853.  
  10854. #define SQR(s)  ((s) * (s))
  10855. #define PRNT(a,b) \
  10856.   printf("value 1 = %d\n", a); \
  10857.   printf("value 2 = %d\n", b) ;
  10858.  
  10859. int main(void)
  10860. {
  10861.   int x = 2;
  10862.   int y = 3;
  10863.  
  10864.   PRNT(SQR(x),y);
  10865. }
  10866.  
  10867. /************************************************************************
  10868. *
  10869.  
  10870. After being interpreted by the preprocessor, the preceding program is replaced 
  10871. by code equivalent to the following: 
  10872.  
  10873.                                                                         *
  10874. ************************************************************************/
  10875.  
  10876. int main(void)
  10877. {
  10878.   int x = 2;
  10879.   int y = 3;
  10880.  
  10881.   {
  10882.      printf("value 1 = %d\n", ( (x) * (x) ) );
  10883.      printf("value 2 = %d\n", y);
  10884.   }
  10885. }
  10886.  
  10887. /************************************************************************
  10888. *
  10889. Execution of this program produces the following output: 
  10890.  
  10891. value 1 = 4
  10892. value 2 = 3
  10893.  
  10894.                                                                         *
  10895. ************************************************************************/
  10896.  
  10897.  
  10898. ΓòÉΓòÉΓòÉ 9.3. #undef ΓòÉΓòÉΓòÉ
  10899.  
  10900. A preprocessor undef directive causes the preprocessor to end the scope of a 
  10901. preprocessor definition.  A preprocessor #undef directive has the form: 
  10902.  
  10903. ΓöÇΓöÇ#ΓöÇΓöÇundefΓöÇΓöÇidentifierΓöÇΓöÇ
  10904.  
  10905. #undef is ignored if the identifier is not currently defined as a macro. 
  10906.  
  10907. Once defined, a preprocessor identifier remains defined and in scope 
  10908. (independent of the scoping rules of the language) until the end of a 
  10909. translation unit or until it is undefined by an #undef preprocessor directive. 
  10910.  
  10911. You can also use the /U compiler option to undefine macros.  The /U option does 
  10912. not undefine macros defined in source code. 
  10913.  
  10914. Examples of #undef Directives 
  10915.  
  10916. Related Information 
  10917.  
  10918. o #define 
  10919. o Predefined Macros 
  10920. o /U option 
  10921. o Preprocessor Directives 
  10922.  
  10923.  
  10924. ΓòÉΓòÉΓòÉ <hidden> Examples of #undef Directives ΓòÉΓòÉΓòÉ
  10925.  
  10926. The following directives define BUFFER and SQR: 
  10927.  
  10928. #define BUFFER 512
  10929. #define SQR(x) ((x) * (x))
  10930.  
  10931. The following directives nullify the preceding definitions: 
  10932.  
  10933. #undef BUFFER
  10934. #undef SQR
  10935.  
  10936. Any occurrences of the identifiers BUFFER and SQR that follow these #undef 
  10937. directives are not replaced with any replacement tokens. Once the definition of 
  10938. a macro has been removed by an #undef directive, the identifier can be used in 
  10939. a new #define directive. 
  10940.  
  10941.  
  10942. ΓòÉΓòÉΓòÉ 9.4. Predefined Macros ΓòÉΓòÉΓòÉ
  10943.  
  10944. Both C and C++ provide the following predefined macro names as specified in the 
  10945. ANSI language standard: 
  10946.  
  10947. __LINE__ 
  10948.     An integer representing the current source line number. 
  10949. __FILE__ 
  10950.     A character string literal containing the name of the source file. 
  10951. __DATE__ 
  10952.     A character string literal containing the date when the source file was 
  10953.     compiled.  The date will be in the form: 
  10954.  
  10955.            "Mmm dd yyyy"
  10956.  
  10957.     where: 
  10958.  
  10959.     Mmm represents the month in an abbreviated form (Jan, Feb, Mar, Apr, May, 
  10960.     Jun, Jul, Aug, Sep, Oct, Nov, or Dec). 
  10961.  
  10962.     dd represents the day.  If the day is less than 10, the first d will be a 
  10963.     blank character. 
  10964.  
  10965.     yyyy represents the year. 
  10966. __TIME__ 
  10967.     A character string literal containing the time when the source file was 
  10968.     compiled.  The time will be in the form: 
  10969.  
  10970.            "hh:mm:ss"
  10971.  
  10972.     where: 
  10973.  
  10974.     hh represents the hour. 
  10975.  
  10976.     mm represents the minutes. 
  10977.  
  10978.     ss represents the seconds. 
  10979. __STDC__ 
  10980.     The integer 1. 
  10981.  
  10982.     Note:  This macro is undefined if the language level is set to anything 
  10983.     other than ANSI. 
  10984.  
  10985. The SAA C standard reserves the following predefined macro names. The 
  10986. C/C++Tools implementation of the C++ language also provides these predefined 
  10987. macros: 
  10988.  
  10989. __TIMESTAMP__ 
  10990.     A character string literal containing the date and time when the source 
  10991.     file was last modified. 
  10992.  
  10993.     The date and time will be in the form: 
  10994.  
  10995.            "Day Mmm dd hh:mm:ss yyyy"
  10996.  
  10997.     where: 
  10998.  
  10999.     Day represents the day of the week (Mon, Tue, Wed, Thu, Fri, Sat, or Sun). 
  11000.  
  11001.     Mmm represents the month in an abbreviated form (Jan, Feb, Mar, Apr, May, 
  11002.     Jun, Jul, Aug, Sep, Oct, Nov, or Dec). 
  11003.  
  11004.     dd represents the day.  If the day is less than 10, the first d will be a 
  11005.     blank character. 
  11006.  
  11007.     hh represents the hour. 
  11008.  
  11009.     mm represents the minutes. 
  11010.  
  11011.     ss represents the seconds. 
  11012.  
  11013.     yyyy represents the year. 
  11014. __ANSI__ 
  11015.     Allows only language constructs that conform to ANSI C standards. Defined 
  11016.     using the #pragma langlvl directive or /Sa option. 
  11017. __SAA__ 
  11018.     Allows only language constructs that conform to the most recent level of 
  11019.     SAA C standards. Defined using the #pragma langlvl directive or /S2 option. 
  11020.     This macro is not supported for C++. 
  11021. __SAAL2__ 
  11022.     Allows only language constructs that conform to SAA Level 2 C standards. 
  11023.     Defined using the #pragma langlvldirective or /S2 option. This macro is not 
  11024.     supported for C++. 
  11025. __EXTENDED__ 
  11026.     Allows additional language constructs provided by the implementation. 
  11027.     Defined using the #pragma langlvl directive or /S2 option. 
  11028.  
  11029. The C/C++ Tools compiler provides several other predefined macros, described in 
  11030. Additional C/C++ Tools Predefined Macros. 
  11031.  
  11032. The value of __LINE__ will change during compilation as the compiler processes 
  11033. subsequent lines of your source program.  Also, the value of __FILE__, and 
  11034. __TIMESTAMP__ will change as the compiler processes any #include files that are 
  11035. part of your source program. 
  11036.  
  11037. Predefined macro names cannot be the subject of a #define or #undef 
  11038. preprocessor directive. However, they can be undefined on the command line 
  11039. using the /U option, with the exception of the __DATE__, __FUNCTION__, 
  11040. __LINE__, __TIME__, and __TIMESTAMP__ macros. 
  11041.  
  11042. Examples of Predefined Macros 
  11043.  
  11044. Related Information 
  11045.  
  11046. o Additional C/C++ Tools Predefined Macros 
  11047. o #pragma langlvl 
  11048. o #define 
  11049. o #undef 
  11050. o /S2 option 
  11051. o Using Compiler Options 
  11052.  
  11053.  
  11054. ΓòÉΓòÉΓòÉ 9.4.1. Additional C/C++ Tools Predefined Macros ΓòÉΓòÉΓòÉ
  11055.  
  11056. The macros identified in this section are provided to allow customers to write 
  11057. programs that use C/C++ Tools services. Only those macros identified in this 
  11058. section should be used to request or receive C/C++ Tools services. 
  11059.  
  11060. The additional macros offered by the C/C++ Tools compiler are: 
  11061.  
  11062. _CHAR_UNSIGNED 
  11063.     Indicates default character type is unsigned. Defined using the #pragma 
  11064.     chars directive or /J compiler option. 
  11065. _CHAR_SIGNED 
  11066.     Indicates default character type is signed. Defined using the #pragma chars 
  11067.     directive or /J compiler option. 
  11068. __COMPAT__ 
  11069.     Indicates language constructs compatible with earlier versions of the C++ 
  11070.     language are allowed. Defined using the #pragma langlvl(compat) directive 
  11071.     or /Sc compiler option. This macro is valid for C++ programs only. 
  11072. __cplusplus 
  11073.     Set to the integer 1.  Indicates the product is a C++ compiler. This macro 
  11074.     is valid for C++ programs only. 
  11075. __DBCS__ 
  11076.     Indicates DBCS support is enabled. Defined using the /Sn compiler option. 
  11077. __DDNAMES__ 
  11078.     Indicates ddnames are supported. Defined using the /Sh compiler option. 
  11079. __DLL__ 
  11080.     Indicates code for a DLL is being compiled. Defined using the /Ge- compiler 
  11081.     option. 
  11082. __FUNCTION__ 
  11083.     Indicates the name of the function currently being compiled. For C++ 
  11084.     programs, expands to the actual function prototype. 
  11085. __IBMC__ 
  11086.     Indicates the version number of the C/C++ Tools C compiler. 
  11087. __IBMCPP__ 
  11088.     Indicates the version number of the C/C++ Tools C++ compiler. 
  11089. _M_I386 
  11090.     Indicates code is being compiled for a 386 chip or higher. 
  11091. __MULTI__ 
  11092.     Indicates multithread code is being generated. Defined using the /Gm 
  11093.     compiler option. 
  11094. __OS2__ 
  11095.     Set to the integer 1.  Indicates the product is an OS/2 compiler. 
  11096. __SPC__ 
  11097.     Indicates the subsystem libraries are being used. Defined using the /Rn 
  11098.     compiler option. 
  11099. __TEMPINC__ 
  11100.     Indicates the template-implementation file method of resolving template 
  11101.     functions is being used.  Defined using the /Ft compiler option. 
  11102. __TILED__ 
  11103.     Indicates tiled memory is being used. Defined using the /Gt compiler 
  11104.     option. 
  11105. __32BIT__ 
  11106.     Set to the integer 1.  Indicates the product is a 32-bit compiler. 
  11107.  
  11108. The value of the __IBMC__ and __IBMCPP__ macros is 200; these two macros are 
  11109. always defined. The macros __OS2__, _M_I386, and __32BIT__ are always defined 
  11110. also. The remaining macros, with the exception of __FUNCTION__, are defined 
  11111. when the corresponding #pragma directive or compiler option is used. 
  11112.  
  11113. Related Information 
  11114.  
  11115. o Predefined Macros 
  11116. o #pragma chars 
  11117. o #pragma langlvl 
  11118. o Code Generation Options 
  11119. o Source Code Options 
  11120. o Other Options 
  11121. o Using Compiler Options 
  11122.  
  11123.  
  11124. ΓòÉΓòÉΓòÉ <hidden> Example of Predefined Macros ΓòÉΓòÉΓòÉ
  11125.  
  11126. /************************************************************************
  11127. *
  11128. The following printf statements will display the values of the predefined 
  11129. macros __LINE__, __FILE__, __TIME__, and __DATE__ and will print a message 
  11130. indicating the program's conformance to ANSI standards based on __STDC__: 
  11131.  
  11132.                                                                         *
  11133. ************************************************************************/
  11134.  
  11135. #pragma langlvl(ANSI)
  11136. #include <stdio.h>
  11137.  
  11138. #ifdef __STDC__
  11139. #   define CONFORM    "conforms"
  11140. #else
  11141. #   define CONFORM    "does not conform"
  11142. #endif
  11143.  
  11144. int main(void)
  11145. {
  11146.   printf("Line %d of file %s has been executed\n", __LINE__, __FILE__);
  11147.   printf("This file was compiled at %s on %s\n", __TIME__, __DATE__);
  11148.   printf("This program %s to ANSI standards\n", CONFORM);
  11149. }
  11150.  
  11151.  
  11152. ΓòÉΓòÉΓòÉ 9.5. # Operator ΓòÉΓòÉΓòÉ
  11153.  
  11154. The # (single number sign) operator is used to convert a parameter of a 
  11155. function-like macro (see Function-Like Macro Definition) into a character 
  11156. string literal.  If macro ABC is defined using the following directive: 
  11157.  
  11158.    #define ABC(x)   #x
  11159.  
  11160. all subsequent invocations of the macro ABC would be expanded into a character 
  11161. string literal containing the argument passed to ABC. For example: 
  11162.  
  11163. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  11164. Γöé INVOCATION      Γöé RESULT OF MACRO EXPANSION Γöé
  11165. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11166. Γöé "ABC(1)"       Γöé "1"            Γöé
  11167. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11168. Γöé "ABC(Hello there)"  Γöé "Hello there"       Γöé
  11169. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  11170.  
  11171. The # operator should not be confused with the null directive. 
  11172.  
  11173. When you use the # operator in a function-like macro definition, the following 
  11174. rules apply: 
  11175.  
  11176.  1. A parameter in a function-like macro that is preceded by the # operator 
  11177.     will be converted into a character string literal containing the argument 
  11178.     passed to the macro. 
  11179.  
  11180.  2. White-space characters that appear before or after the argument passed to 
  11181.     the macro will be deleted. 
  11182.  
  11183.  3. Multiple white-space characters imbedded within the argument passed to the 
  11184.     macro will be replaced by a single space character. 
  11185.  
  11186.  4. If the argument passed to the macro contains a string literal and if a \ 
  11187.     (backslash) character appears within the literal, a second \ character will 
  11188.     be inserted before the original \ when the macro is expanded. 
  11189.  
  11190.  5. If the argument passed to the macro contains a " (double quotation mark) 
  11191.     character, a \ character will be inserted before the " when the macro is 
  11192.     expanded. 
  11193.  
  11194.  6. The conversion of an argument into a string literal occurs before macro 
  11195.     expansion on that argument. 
  11196.  
  11197.  7. If more than one ## operator or # operator appears in the replacement list 
  11198.     of a macro definition, the order of evaluation of the operators is not 
  11199.     defined. 
  11200.  
  11201.  8. If the result of the replacement is not a valid character string literal, 
  11202.     the behavior is undefined. 
  11203.  
  11204. Examples of the # Operator 
  11205.  
  11206. Related Information 
  11207.  
  11208. o #define 
  11209. o #undef 
  11210. o ## Operator 
  11211. o Function-Like Macro Definition 
  11212. o Preprocessor Directives 
  11213.  
  11214.  
  11215. ΓòÉΓòÉΓòÉ <hidden> Examples of the # Operator ΓòÉΓòÉΓòÉ
  11216.  
  11217. The following examples demonstrate the rules given in the preceding paragraph. 
  11218.  
  11219.    #define STR(x)        #x
  11220.    #define XSTR(x)       STR(x)
  11221.    #define ONE           1
  11222.  
  11223. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  11224. Γöé INVOCATION      Γöé RESULT OF MACRO EXPANSION Γöé
  11225. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11226. Γöé "STR(\n "\n" '\n')"  Γöé ""\n \"\\n\" '\\n'""    Γöé
  11227. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11228. Γöé "STR(ONE)"      Γöé "ONE"           Γöé
  11229. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11230. Γöé "XSTR(ONE)"      Γöé "1"            Γöé
  11231. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11232. Γöé "XSTR("hello")"    Γöé "\"hello\""        Γöé
  11233. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  11234.  
  11235.  
  11236. ΓòÉΓòÉΓòÉ 9.6. ## Operator ΓòÉΓòÉΓòÉ
  11237.  
  11238. The ## (double number sign) operator is used to concatenate two tokens in a 
  11239. macro invocation (text and/or arguments) given in a macro definition.  If a 
  11240. macro XY was defined using the following directive: 
  11241.  
  11242.    #define XY(x,y)    x##y
  11243.  
  11244. the last token of the argument for x will be concatenated with the first token 
  11245. of the argument for y. 
  11246.  
  11247. For example, 
  11248.  
  11249. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  11250. Γöé INVOCATION    Γöé RESULT OF MACRO EXPANSION Γöé
  11251. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11252. Γöé "XY(1, 2)"    Γöé "12"            Γöé
  11253. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11254. Γöé "XY(Green,    Γöé "Greenhouse"        Γöé
  11255. Γöé house)"     Γöé              Γöé
  11256. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  11257.  
  11258. When you use the ## operator, the following rules apply: 
  11259.  
  11260.  1. The ## operator cannot be the very first or very last item in the 
  11261.     replacement list of a macro definition. 
  11262.  
  11263.  2. The last token of the item preceding the ## operator is concatenated with 
  11264.     first token of the item following the ## operator. 
  11265.  
  11266.  3. Concatenation takes place before any macros in arguments are expanded. 
  11267.  
  11268.  4. If the result of a concatenation is a valid macro name, it is available for 
  11269.     further replacement even if it appears in a context in which it would not 
  11270.     normally be available. 
  11271.  
  11272.  5. If more than one ## operator and/or # operator appears in the replacement 
  11273.     list of a macro definition, the order of evaluation of the operators is not 
  11274.     defined. 
  11275.  
  11276. Examples of the ## Operator 
  11277.  
  11278. Related Information 
  11279.  
  11280. o #define 
  11281. o #undef 
  11282. o # Operator 
  11283. o Preprocessor Directives 
  11284.  
  11285.  
  11286. ΓòÉΓòÉΓòÉ <hidden> Examples of the ## Operator ΓòÉΓòÉΓòÉ
  11287.  
  11288. The following examples demonstrate the rules for the ## operator: 
  11289.  
  11290. #define ArgArg(x, y)          x##y
  11291. #define ArgText(x)            x##TEXT
  11292. #define TextArg(x)            TEXT##x
  11293. #define TextText              TEXT##text
  11294. #define Jitter                1
  11295. #define bug                   2
  11296. #define Jitterbug             3
  11297.  
  11298. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  11299. Γöé INVOCATION      Γöé RESULT OF MACRO EXPANSION Γöé
  11300. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11301. Γöé "ArgArg(var, 1)"   Γöé ""var1""          Γöé
  11302. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11303. Γöé "ArgText(var)"    Γöé ""varTEXT""        Γöé
  11304. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11305. Γöé "TextArg(var)"    Γöé ""TEXTvar""        Γöé
  11306. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11307. Γöé "TextText"      Γöé ""TEXTtext""        Γöé
  11308. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11309. Γöé "ArgArg(Jitter,    Γöé "3"            Γöé
  11310. Γöé bug)"         Γöé              Γöé
  11311. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  11312.  
  11313.  
  11314. ΓòÉΓòÉΓòÉ 9.7. #error ΓòÉΓòÉΓòÉ
  11315.  
  11316. A preprocessor error directive causes the preprocessor to generate an error 
  11317. message and causes the compilation to fail. #error directive has the form: 
  11318.  
  11319.         ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  11320.               Γöé
  11321. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇerrorΓöÇΓöÇΓöÇΓöÇcharacterΓöÇΓö┤ΓöÇΓöÇ><
  11322.  
  11323. The following directive generates the error message, Error in TESTPGM1 - This 
  11324. section should not be compiled: 
  11325.  
  11326. #error Error in TESTPGM1 - This section should not be compiled
  11327.  
  11328. You can use the #error directive as a safety check during compilation.  For 
  11329. example, if your program uses preprocessor conditional compilation directives 
  11330. (see Conditional Compilation), you can place #error directives in the source 
  11331. file to make the compilation fail if a section of the program is reached that 
  11332. should be bypassed. 
  11333.  
  11334.  
  11335. ΓòÉΓòÉΓòÉ 9.8. #include ΓòÉΓòÉΓòÉ
  11336.  
  11337. A preprocessor include directive causes the preprocessor to replace the 
  11338. directive with the contents of the specified file.  A preprocessor #include 
  11339. directive has the form: 
  11340.  
  11341. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇincludeΓöÇΓöÇΓö¼ΓöÇ"file_name"ΓöÇΓö¼ΓöÇΓöÇ><
  11342.          Γö£ΓöÇΓöÉfile_name>ΓöÇΓöñ
  11343.          ΓööΓöÇcharactersΓöÇΓöÇΓöÿ
  11344.  
  11345. If the file name is enclosed in double quotation marks, for example:  #include 
  11346. "payroll.h"  the preprocessor treats it as a user-defined file, and searches 
  11347. for the file in the following places in the order given: 
  11348.  
  11349.  1. The directory where the original .c source file resides. 
  11350.  
  11351.  2. Any directories specified using the /I compiler option (that have not been 
  11352.     removed by the /Xc option).  Directories specified in the ICC environment 
  11353.     variable are searched before those specified on the command line. 
  11354.  
  11355.  3. Any directories specified using the INCLUDE environment variable, provided 
  11356.     the /Xi option is not in effect. 
  11357.  
  11358. If the file name is enclosed in angle brackets, for example:  #include 
  11359. <stdio.h>  it is treated as a system-defined file, and the preprocessor 
  11360. searches the following places in the order given: 
  11361.  
  11362.  1. Any directories specified using the /I compiler option (that have not been 
  11363.     removed by the /Xc option).  Directories specified in the ICC environment 
  11364.     variable are searched before those specified on the command line. 
  11365.  
  11366.  2. Any directories specified using the INCLUDE environment variable, provided 
  11367.     the /Xi option is not in effect. 
  11368.  
  11369. Note:  If the file name is fully qualified, the preprocessor searches only the 
  11370. directory specified by the name. 
  11371.  
  11372. The preprocessor resolves macros on a #include directive.  After macro 
  11373. replacement, the resulting token sequence must consist of a file name enclosed 
  11374. in either double quotation marks or the characters < and >.  For example: 
  11375.  
  11376. #define MONTH <july.h>
  11377. #include MONTH
  11378.  
  11379. If there are a number of declarations used by several files, you can place all 
  11380. these definitions in one file and #include that file in each file that uses the 
  11381. definitions.  For example, the following file defs.h contains several 
  11382. definitions and an inclusion of an additional file of declarations: 
  11383.  
  11384. /* defs.h */
  11385. #define TRUE 1
  11386. #define FALSE 0
  11387. #define BUFFERSIZE 512
  11388. #define MAX_ROW 66
  11389. #define MAX_COLUMN 80
  11390. int hour;
  11391. int min;
  11392. int sec;
  11393. #include "mydefs.h"
  11394.  
  11395. You can embed the definitions that appear in defs.h with the following 
  11396. directive: 
  11397.  
  11398. #include "defs.h"
  11399.  
  11400. One of the ways you can combine the use of preprocessor directives is 
  11401. demonstrated in the following example.  A #define is used to define a macro 
  11402. that represents the name of the C standard I/O header file.  A #include is then 
  11403. used to make the header file available to the C program. 
  11404.  
  11405. #define  IO_HEADER   <stdio.h>
  11406.       .
  11407.       .
  11408.       .
  11409. #include IO_HEADER   /* equivalent to specifying #include <stdio.h> */
  11410.       .
  11411.       .
  11412.       .
  11413.  
  11414. Note:  The new-line and > characters cannot appear in a file name delimited by 
  11415. < and >. The new-line and " (double quotation marks) character cannot appear in 
  11416. a file name delimited by " and ", although > can. 
  11417.  
  11418. Related Information 
  11419.  
  11420. o #define 
  11421. o Preprocessor Directives 
  11422. o Include Files 
  11423.  
  11424.  
  11425. ΓòÉΓòÉΓòÉ 9.9. Conditional Compilation ΓòÉΓòÉΓòÉ
  11426.  
  11427. A preprocessor conditional compilation directive causes the preprocessor to 
  11428. conditionally suppress the compilation of portions of source code.  Such 
  11429. directives test a constant expression or an identifier to determine which 
  11430. tokens the preprocessor should pass on to the compiler and which tokens should 
  11431. be ignored.  The directives are: 
  11432.  
  11433. o #if 
  11434. o #ifdef 
  11435. o #ifndef 
  11436. o #else 
  11437. o #elif 
  11438. o #endif 
  11439.  
  11440. The preprocessor conditional compilation directive spans several lines: 
  11441.  
  11442. o The condition specification line 
  11443. o Lines containing code that the preprocessor passes on to the compiler if the 
  11444.   condition evaluates to a nonzero value (optional) 
  11445. o The #else line (optional) 
  11446. o Lines containing code that the preprocessor passes on to the compiler if the 
  11447.   condition evaluates to zero (optional) 
  11448. o The preprocessor #endif directive 
  11449.  
  11450. For each #if, #ifdef, and #ifndef directive, there are zero or more #elif 
  11451. directives, zero or one #else directive, and one matching #endif directive. All 
  11452. the matching directives are considered to be at the same nesting level. 
  11453.  
  11454. You can have nested conditional compilation directives. So if you have the 
  11455. following directives, the first #else will be matched with the #if directive. 
  11456.  
  11457. #ifdef MACNAME
  11458.             /*  tokens added if MACNAME is defined */
  11459. #   if TEST <=10
  11460.                  /* tokens added if MACNAME is defined and TEST <= 10 */
  11461. #   else
  11462.                  /* tokens added if MACNAME is defined and TEST >  10 */
  11463. #   endif
  11464. #else
  11465.             /*  tokens added if MACNAME is not defined */
  11466. #endif
  11467.  
  11468. Each directive controls the block immediately following it.  A block consists 
  11469. of all the tokens starting on the line following the directive and ending at 
  11470. the next conditional compilation directive at the same nesting level. 
  11471.  
  11472. Each directive is processed in the order in which it is encountered.  If an 
  11473. expression evaluates to zero, the block following the directive is ignored. 
  11474.  
  11475. When a block following a preprocessor directive is to be ignored, the tokens 
  11476. are examined only to identify preprocessor directives within that block so that 
  11477. the conditional nesting level can be determined. All tokens other than the name 
  11478. of the directive are ignored. 
  11479.  
  11480. Only the first block whose expression is nonzero is processed. The remaining 
  11481. blocks at that nesting level are ignored. If none of the blocks at that nesting 
  11482. level has been processed and there is a #else directive, the block following 
  11483. the #else directive is processed. If none of the blocks at that nesting level 
  11484. has been processed and there is no #else directive, the entire nesting level is 
  11485. ignored. 
  11486.  
  11487. Examples of Conditional Compilation 
  11488.  
  11489. Related Information 
  11490.  
  11491. o #if 
  11492. o #ifdef 
  11493. o #ifndef 
  11494. o #elif 
  11495. o #else 
  11496. o #endif 
  11497. o Preprocessor Directives 
  11498.  
  11499.  
  11500. ΓòÉΓòÉΓòÉ 9.9.1. #if, #elif ΓòÉΓòÉΓòÉ
  11501.  
  11502. The #if and #elif directives compare the value of the expression to zero.  All 
  11503. macros are expanded, any defined() expressions are processed and all remaining 
  11504. identifiers are replaced with the token 0. 
  11505.  
  11506. The preprocessor #if directive has the following form: 
  11507.  
  11508.                  ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  11509.                        Γöé
  11510. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇifΓöÇΓöÇconstant_expressionΓöÇΓöÇΓöÇΓöÇstatementΓöÇΓö┤ΓöÇΓöÇ><
  11511.  
  11512. The preprocessor #elif directive has the following form: 
  11513.  
  11514.                   ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  11515.                         Γöé
  11516. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇelifΓöÇΓöÇconstant_expressionΓöÇΓöÇΓöÇΓöÇstatementΓöÇΓö┤ΓöÇΓöÇ><
  11517.  
  11518. The expressions that are tested must be integer constant expressions that 
  11519. follow these rules: 
  11520.  
  11521. o No casts are performed. 
  11522. o The expression can contain the defined unary operator. The constant 
  11523.   expression can contain the unary operator defined.  This operator can be used 
  11524.   only with the preprocessor keyword #if.  The following expressions evaluate 
  11525.   to 1 if the identifier is defined in the preprocessor, otherwise to 0: 
  11526.  
  11527.     defined identifier
  11528.     defined(identifier)
  11529.  
  11530. o The expression can contain defined macros. If a macro is not defined, a value 
  11531.   of 0 is assigned to it. 
  11532. o Any arithmetic is performed using long ints. 
  11533.  
  11534. If the constant expression evaluates to a nonzero value, the tokens that 
  11535. immediately follow the condition are passed on to the compiler. 
  11536.  
  11537. Example of #if and #elif Directives 
  11538.  
  11539. Related Information 
  11540.  
  11541. o Conditional Compilation 
  11542. o #ifdef 
  11543. o #ifndef 
  11544. o #endif 
  11545. o Preprocessor Directives 
  11546. o if 
  11547.  
  11548.  
  11549. ΓòÉΓòÉΓòÉ <hidden> Examples of #if and #elif Directives ΓòÉΓòÉΓòÉ
  11550.  
  11551. /************************************************************************
  11552. *
  11553.  
  11554. The following example uses the #if and #elif directives to assign values to an 
  11555. array. 
  11556.  
  11557.                                                                         *
  11558. ************************************************************************/
  11559.  
  11560. #include <stdio.h>
  11561.  
  11562. int main(void)
  11563. {
  11564.    int i;
  11565.    char *arrayname = "realarray";
  11566.    int realarray[] = { 1, 2, 3 };
  11567.    int array1[] = { 4, 5, 6 };
  11568.    int array2[] = { 7, 8, 9 };
  11569.  
  11570. #if ( (defined(LEVEL1)) && (TEST > 1) )
  11571.    for (i = 0; i < 3; i++)
  11572.       realarray[i] = array1[i];
  11573.       arrayname = "array1";
  11574. #elif (defined(LEVEL2))
  11575.    for (i = 0; i < 3; i++)
  11576.       realarray[i] = array2[i];
  11577.       arrayname = "array2";
  11578. #endif
  11579.  
  11580.    printf("realarray[] now has the contents of %s[]\n", arrayname);
  11581.  
  11582.    /* Assuming only LEVEL2 is defined, the expected output is:
  11583.  
  11584.       realarray[] now has the contents of array2[] */
  11585.  
  11586. }
  11587.  
  11588.  
  11589. ΓòÉΓòÉΓòÉ 9.9.2. #ifdef ΓòÉΓòÉΓòÉ
  11590.  
  11591. The #ifdef directive checks for the existence of macro definitions. 
  11592.  
  11593. If the identifier specified is defined as a macro, the tokens that immediately 
  11594. follow the condition are passed on to the compiler. 
  11595.  
  11596. The preprocessor #ifdef directive has the following form: 
  11597.  
  11598.               ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  11599.                     Γöé
  11600. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇifdefΓöÇΓöÇidentifierΓöÇΓöÇΓöÇΓöÇstatementΓöÇΓö┤ΓöÇΓöÇ><
  11601.  
  11602. The following example defines MAX_LEN to be 75 if EXTENDED is defined for the 
  11603. preprocessor.  Otherwise, MAX_LEN is defined to be 50. 
  11604.  
  11605. #ifdef EXTENDED
  11606. #   define MAX_LEN 75
  11607. #else
  11608. #   define MAX_LEN 50
  11609. #endif
  11610.  
  11611. Related Information 
  11612.  
  11613. o Conditional Compilation 
  11614. o #ifndef 
  11615. o #if, #elif 
  11616. o #else 
  11617. o #endif 
  11618. o #define 
  11619. o #undef 
  11620. o Preprocessor Directives 
  11621.  
  11622.  
  11623. ΓòÉΓòÉΓòÉ 9.9.3. #ifndef ΓòÉΓòÉΓòÉ
  11624.  
  11625. The #ifndef directive checks for the existence of macro definitions. 
  11626.  
  11627. If the identifier specified is not defined as a macro, the tokens that 
  11628. immediately follow the condition are passed on to the compiler. 
  11629.  
  11630. The preprocessor #ifndef directive has the following form: 
  11631.  
  11632.                ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  11633.                      Γöé
  11634. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇifndefΓöÇΓöÇidentifierΓöÇΓöÇΓöÇΓöÇstatementΓöÇΓö┤ΓöÇΓöÇ><
  11635.  
  11636. The following example defines MAX_LEN to be 50 if EXTENDED is not defined for 
  11637. the preprocessor.  Otherwise, MAX_LEN is defined to be 75. 
  11638.  
  11639. #ifndef EXTENDED
  11640. #   define MAX_LEN 50
  11641. #else
  11642. #   define MAX_LEN 75
  11643. #endif
  11644.  
  11645. Related Information 
  11646.  
  11647. o Conditional Compilation 
  11648. o #ifdef 
  11649. o #if, #elif 
  11650. o #else 
  11651. o #endif 
  11652. o #define 
  11653. o #undef 
  11654. o Preprocessor Directives 
  11655.  
  11656.  
  11657. ΓòÉΓòÉΓòÉ 9.9.4. #else ΓòÉΓòÉΓòÉ
  11658.  
  11659. If the condition specified in the #if, #ifdef, or #ifndef directive evaluates 
  11660. to 0, and the conditional compilation directive contains a preprocessor #else 
  11661. directive, the source text located between the preprocessor #else directive and 
  11662. the preprocessor #endif directive is selected by the preprocessor to be passed 
  11663. on to the compiler. 
  11664.  
  11665. The preprocessor #else directive has the form: 
  11666.  
  11667.         ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  11668.               Γöé
  11669. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇelseΓöÇΓöÇΓöÇΓöÇstatementΓöÇΓö┤ΓöÇΓöÇ><
  11670.  
  11671. The following example defines MAX_LEN to be 50 if EXTENDED is not defined for 
  11672. the preprocessor.  Otherwise, MAX_LEN is defined to be 75. 
  11673.  
  11674. #ifndef EXTENDED
  11675. #   define MAX_LEN 50
  11676. #else
  11677. #   define MAX_LEN 75
  11678. #endif
  11679.  
  11680. Related Information 
  11681.  
  11682. o Conditional Compilation 
  11683. o #if, #elif 
  11684. o #ifdef 
  11685. o #ifndef 
  11686. o #endif 
  11687. o #define 
  11688. o Preprocessor Directives 
  11689.  
  11690.  
  11691. ΓòÉΓòÉΓòÉ 9.9.5. #endif ΓòÉΓòÉΓòÉ
  11692.  
  11693. The preprocessor #endif directive ends the conditional compilation directive. 
  11694. The preprocessor #endif directive has the form: 
  11695.  
  11696.          ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  11697.                     Γöé
  11698. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇΓöÇΓöÇcharacter_sequenceΓöÇΓö┤ΓöÇΓöÇ><
  11699.  
  11700. The following example shows preprocessor conditional compilation directives 
  11701. ended by the #endif directive. 
  11702.  
  11703. #if defined(LEVEL1)
  11704. #   define SIZEOF_INT 16
  11705. #   ifdef PHASE2
  11706. #     define MAX_PHASE 2
  11707. #   else
  11708. #     define MAX_PHASE 8
  11709. #   endif
  11710. #elif defined(LEVEL2)
  11711. #   define SIZEOF_INT 32
  11712. #   define MAX_PHASE 16
  11713. #endif
  11714.  
  11715. Related Information 
  11716.  
  11717. o Conditional Compilation 
  11718. o #if, #elif 
  11719. o #ifdef 
  11720. o #ifndef 
  11721. o #else 
  11722. o Preprocessor Directives 
  11723.  
  11724.  
  11725. ΓòÉΓòÉΓòÉ <hidden> Examples ΓòÉΓòÉΓòÉ
  11726.  
  11727. /************************************************************************
  11728. *
  11729.  
  11730. The following example shows how you can nest preprocessor conditional 
  11731. compilation directives: 
  11732.  
  11733. #if defined(TARGET1)
  11734. #   define SIZEOF_INT 16
  11735. #   ifdef PHASE2
  11736. #      define MAX_PHASE 2
  11737. #   else
  11738. #      define MAX_PHASE 8
  11739. #   endif
  11740. #elif defined(TARGET2)
  11741. #   define SIZEOF_INT 32
  11742. #   define MAX_PHASE 16
  11743. #else
  11744. #   define SIZEOF_INT 32
  11745. #   define MAX_PHASE 32
  11746. #endif
  11747.  
  11748. The following program contains preprocessor conditional compilation directives: 
  11749.  
  11750.                                                                         *
  11751. ************************************************************************/
  11752.  
  11753. #include <stdio.h>
  11754.  
  11755. int main(void)
  11756. {
  11757.    static int array[ ] = { 1, 2, 3, 4, 5 };
  11758.    int i;
  11759.  
  11760.    for (i = 0; i <= 4; i++)
  11761.    {
  11762.       array[i] *= 2;
  11763.  
  11764. #if TEST >= 1
  11765.    printf("i = %d\n", i);
  11766.    printf("array[i] = %d\n", array[i]);
  11767. #endif
  11768.  
  11769.    }
  11770. }
  11771.  
  11772.  
  11773. ΓòÉΓòÉΓòÉ 9.10. #line ΓòÉΓòÉΓòÉ
  11774.  
  11775. A preprocessor line control directive causes the compiler to view the line 
  11776. number of the next source line as the specified number.  A preprocessor #line 
  11777. directive has the form: 
  11778.  
  11779. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇlineΓöÇΓöÇΓö¼ΓöÇdecimal_constantΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓö¼ΓöÇΓöÇ><
  11780.         Γöé          ΓööΓöÇ"file_name"ΓöÇΓöÿ Γöé
  11781.         ΓööΓöÇcharactersΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  11782.  
  11783. A file name specification enclosed in double quotation marks can follow the 
  11784. line number.  If you specify a file name, the compiler views the next line as 
  11785. part of the specified file.  If you do not specify a file name, the compiler 
  11786. views the next line as part of the current source file. 
  11787.  
  11788. The token sequence on a #line directive is subject to macro replacement.  After 
  11789. macro replacement, the resulting character sequence must consist of a decimal 
  11790. constant, optionally followed by a file name enclosed in double quotation 
  11791. marks. 
  11792.  
  11793. You can use #line control directives to make the compiler provide more 
  11794. meaningful error messages. 
  11795.  
  11796. Example of #line Directives 
  11797.  
  11798. Related Information 
  11799.  
  11800. o Preprocessor Directives 
  11801. o Decimal Constants 
  11802.  
  11803.  
  11804. ΓòÉΓòÉΓòÉ <hidden> Example of #line Directives ΓòÉΓòÉΓòÉ
  11805.  
  11806. /************************************************************************
  11807. *
  11808.  
  11809. The following program uses #line control directives to give each function an 
  11810. easily recognizable line number: 
  11811.  
  11812.                                                                         *
  11813. ************************************************************************/
  11814.  
  11815. #include <stdio.h>
  11816. #define LINE200 200
  11817.  
  11818. int main(void)
  11819. {
  11820.    func_1();
  11821.    func_2();
  11822. }
  11823.  
  11824. #line 100
  11825. func_1()
  11826. {
  11827.    printf("Func_1 - the current line number is %d\n",_ _LINE_ _);
  11828. }
  11829.  
  11830. #line LINE200
  11831. func_2()
  11832. {
  11833.    printf("Func_2 - the current line number is %d\n",_ _LINE_ _);
  11834. }
  11835.  
  11836. /************************************************************************
  11837. *
  11838.  
  11839. The preceding program produces the following output: 
  11840.  
  11841. Func_1 - the current line number is 102
  11842. Func_2 - the current line number is 202
  11843.  
  11844.                                                                         *
  11845. ************************************************************************/
  11846.  
  11847.  
  11848. ΓòÉΓòÉΓòÉ 9.11. # (Null Directive) ΓòÉΓòÉΓòÉ
  11849.  
  11850. The null directive performs no action.  The null directive consists of a single 
  11851. # on a line of its own. 
  11852.  
  11853. The null directive should not be confused with the # operator or the character 
  11854. that starts a preprocessor directive. 
  11855.  
  11856. In the following example, if MINVAL is a defined macro name, no action is 
  11857. performed.  If MINVAL is not a defined identifier, it is defined 1. 
  11858.  
  11859. #ifdef MINVAL
  11860.   #
  11861. #else
  11862.   #define MINVAL 1
  11863. #endif
  11864.  
  11865. Related Information 
  11866.  
  11867. o Preprocessor Directives 
  11868. o Null Statement 
  11869.  
  11870.  
  11871. ΓòÉΓòÉΓòÉ 9.12. #pragma ΓòÉΓòÉΓòÉ
  11872.  
  11873. A pragma is an implementation-defined instruction to the compiler.  It has the 
  11874. general form given below, where character sequence is a series of characters 
  11875. giving a specific compiler instruction and arguments, if any. 
  11876.  
  11877.         ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  11878.                     Γöé
  11879. ΓöÇΓöÇ#ΓöÇΓöÇpragmaΓöÇΓöÇΓöÇΓöÇΓöÇcharacter_sequenceΓöÇΓöÇΓö┤ΓöÇΓöÇ
  11880.  
  11881. The character sequence on a pragma is not subject to macro substitutions.  More 
  11882. than one pragma construct can be specified on a single #pragma directive. 
  11883.  
  11884. The following pragmas are available: 
  11885.  
  11886. o alloc_text 
  11887. o chars 
  11888. o checkout 
  11889. o comment 
  11890. o data_seg 
  11891. o define 
  11892. o entry 
  11893. o export 
  11894. o handler 
  11895. o implementation 
  11896. o import 
  11897. o info 
  11898. o langlvl 
  11899. o linkage 
  11900. o map 
  11901. o margins 
  11902. o pack 
  11903. o page 
  11904. o pagesize 
  11905. o priority 
  11906. o seg16 
  11907. o sequence 
  11908. o skip 
  11909. o sourcedir 
  11910. o stack16 
  11911. o strings 
  11912. o subtitle 
  11913. o title 
  11914. o undeclared 
  11915.  
  11916. Examples of #pragma directives 
  11917.  
  11918. Related Information 
  11919.  
  11920. o #pragma Restrictions 
  11921. o Preprocessor Directives 
  11922.  
  11923.  
  11924. ΓòÉΓòÉΓòÉ 9.12.1. #pragma Restrictions ΓòÉΓòÉΓòÉ
  11925.  
  11926. Some #pragma directives must appear in a certain place in your source, or can 
  11927. appear a limited number of times. The following table lists the restrictions 
  11928. for #pragma directives. 
  11929.  
  11930. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  11931. Γöé      #pragma Restrictions                         Γöé
  11932. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11933. Γöé #PRAGMA  Γöé RESTRICTION OF PLACE-  Γöé RESTRICTION ON NUMBER OF OCCURRENCES   Γöé
  11934. Γöé      Γöé MENT          Γöé                      Γöé
  11935. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11936. Γöé chars   Γöé On the first #pragma  Γöé Once                   Γöé
  11937. Γöé      Γöé directive, and before  Γöé                      Γöé
  11938. Γöé      Γöé any code or directive  Γöé                      Γöé
  11939. Γöé      Γöé (except "#line")    Γöé                      Γöé
  11940. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11941. Γöé comment  Γöé "copyright" directive  Γöé "compiler" and "timestamp" directives   Γöé
  11942. Γöé      Γöé must appear before any Γöé can appear only once           Γöé
  11943. Γöé      Γöé code          Γöé                      Γöé
  11944. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11945. Γöé entry   Γöé No restriction     Γöé Once                   Γöé
  11946. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11947. Γöé langlvl  Γöé On the first #pragma  Γöé Once                   Γöé
  11948. Γöé      Γöé directive, and before  Γöé                      Γöé
  11949. Γöé      Γöé any code or directive  Γöé                      Γöé
  11950. Γöé      Γöé (except "#line")    Γöé                      Γöé
  11951. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11952. Γöé linkage  Γöé Before any declaration Γöé Once for each function          Γöé
  11953. Γöé      Γöé of or call to the    Γöé                      Γöé
  11954. Γöé      Γöé function        Γöé                      Γöé
  11955. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  11956. Γöé strings  Γöé Before any code     Γöé Once                   Γöé
  11957. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  11958.  
  11959. Related Information 
  11960.  
  11961. o #pragma chars 
  11962. o #pragma comment 
  11963. o #pragma entry 
  11964. o #pragma langlvl 
  11965. o #pragma linkage 
  11966. o #pragma strings 
  11967. o #line 
  11968. o #pragma 
  11969.  
  11970.  
  11971. ΓòÉΓòÉΓòÉ 9.12.2. alloc_text ΓòÉΓòÉΓòÉ
  11972.  
  11973. The #pragma alloc_text directive lets you group functions into different 32-bit 
  11974. code segments. 
  11975.  
  11976.                       ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  11977.                              Γöé
  11978. >>ΓöÇΓöÇ#ΓöÇΓöÇpragmaΓöÇΓöÇalloc_textΓöÇΓöÇ(ΓöÇΓöÇcodesegmentΓöÇΓöÇΓöÇΓöÇ,ΓöÇΓöÇfunctionΓöÇΓö┤ΓöÇΓöÇ)ΓöÇΓöÇ><
  11979.  
  11980. The codesegment is the name of the code segment where you want to place 
  11981. function. You can specify any number of functions to be included in the named 
  11982. codesegment. 
  11983.  
  11984. Functions that are not grouped in a code segment by #pragma alloc_text are 
  11985. placed in the default 32-bit code segment CODE32. You can also use #pragma 
  11986. alloc_text to explicitly place functions in CODE32 by specifying it as the 
  11987. codesegment. 
  11988.  
  11989. Defining your own code segments allows you to organize functions in memory so 
  11990. that the working set requires fewer pages of memory. You can also specify 
  11991. attributes for each segment, such as execute-only or preload. You specify 
  11992. attributes for code segments in a module definition (.DEF) file. 
  11993.  
  11994. For example, to create two code segments, one load on call, the other preload: 
  11995.  
  11996.     #pragma alloc_text(pl_seg, func1)
  11997.     #pragma alloc_text(loc_seg, func2)
  11998.  
  11999. and use the following statement in the .DEF file for the program: 
  12000.  
  12001.     SEGMENTS
  12002.  
  12003.       pl_seg PRELOAD
  12004.  
  12005. For more information on attributes and how to specify them in a .DEF file, see 
  12006. the Toolkit documentation for the LINK386 program. 
  12007.  
  12008. Related Information 
  12009.  
  12010. o #pragma data_seg 
  12011. o #pragma 
  12012. o Preprocessor Directives 
  12013.  
  12014.  
  12015. ΓòÉΓòÉΓòÉ 9.12.3. chars ΓòÉΓòÉΓòÉ
  12016.  
  12017. Specifies that the compiler is to treat all char objects as signed or unsigned. 
  12018. This pragma must appear before any statements in a file. 
  12019.  
  12020. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇcharsΓöÇΓöÇ(ΓöÇΓöÇΓö¼ΓöÇsignedΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ)ΓöÇΓöÇ><
  12021.               ΓööΓöÇunsignedΓöÇΓöÿ
  12022.  
  12023. Related Information 
  12024.  
  12025. o Characters 
  12026. o #pragma 
  12027. o Preprocessor Directives 
  12028.  
  12029.  
  12030. ΓòÉΓòÉΓòÉ 9.12.4. checkout ΓòÉΓòÉΓòÉ
  12031.  
  12032. The #pragma checkout directive controls the diagnostic messages generated by 
  12033. the /Kn compiler options. 
  12034.  
  12035. Note:  This #pragma directive is valid for C code only. 
  12036.  
  12037. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇcheckoutΓöÇΓöÇ(ΓöÇΓöÇΓö¼ΓöÇresumeΓöÇΓöÇΓö¼ΓöÇΓöÇ)ΓöÇΓöÇ><
  12038.                ΓööΓöÇsuspendΓöÇΓöÿ
  12039.  
  12040. Use #pragma checkout to suspend the diagnostics performed by the /Kn options 
  12041. during specific portions of your program, and then resume the same level of 
  12042. diagnostics at some later point in the file. 
  12043.  
  12044. Note:  The /Wgrp options have been added to provide greater control over 
  12045.        diagnostic messages.  The C/C++ Tools C compiler maps the /Kn options to 
  12046.        the appropriate /Wgrp option. It also maps #pragma checkout to #pragma 
  12047.        info. The C/C++ Tools C++ compiler maps the /Kn options, but ignores 
  12048.        #pragma checkout directives. 
  12049.  
  12050. Because support for the /Kn options and #pragma checkout will eventually be 
  12051. removed from C/C++ Tools, you should avoid using them in any new code. 
  12052.  
  12053. Nested #pragma checkout directives are allowed and behave as follows: 
  12054.  
  12055. /*  Assume /Kpx has been specified  */
  12056. #pragma checkout(suspend)  /*  No diagnostics are performed */
  12057.    .
  12058.    .
  12059.    .
  12060. #pragma checkout(suspend)  /*  No effect  */
  12061.    .
  12062.    .
  12063.    .
  12064. #pragma checkout(resume)   /*  No effect  */
  12065.    .
  12066.    .
  12067.    .
  12068. #pragma checkout(resume)   /*  Diagnostics continue  */
  12069.  
  12070. The #pragma checkout directive affects all /Kn options specified. 
  12071.  
  12072. Related Information 
  12073.  
  12074. o /Kn Options 
  12075. o Using the /Wgrp Diagnostic Options 
  12076. o #pragma info 
  12077. o #pragma 
  12078. o Preprocessor Directives 
  12079.  
  12080.  
  12081. ΓòÉΓòÉΓòÉ 9.12.5. comment ΓòÉΓòÉΓòÉ
  12082.  
  12083. Emits a comment into the object file. 
  12084.  
  12085. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇcommentΓöÇΓöÇ(ΓöÇΓöÇΓö¼ΓöÇcompilerΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ)ΓöÇΓöÇ><
  12086.                Γö£ΓöÇdateΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  12087.                Γö£ΓöÇtimestampΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  12088.                ΓööΓöÇΓö¼ΓöÇcopyrightΓöÇΓö¼ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÿ
  12089.                 ΓööΓöÇuserΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ  ΓööΓöÇ,"characters"ΓöÇΓöÿ
  12090. The comment type can be: 
  12091.  
  12092. compiler       the name and version of the compiler is emitted into the end of 
  12093.                the generated object module. 
  12094. date           the date and time of compilation is emitted into the end of the 
  12095.                generated object module. 
  12096. timestamp      the last modification date and time of the source is emitted 
  12097.                into the end of the generated object module. 
  12098. copyright      the text specified by the character field is placed by the 
  12099.                compiler into the generated object module and is loaded into 
  12100.                memory when the program is run. 
  12101. user           the text specified by the character field is placed by the 
  12102.                compiler into the generated object but is not loaded into memory 
  12103.                when the program is run. 
  12104.  
  12105. Related Information 
  12106.  
  12107. o #pragma 
  12108. o Preprocessor Directives 
  12109.  
  12110.  
  12111. ΓòÉΓòÉΓòÉ 9.12.6. data_seg ΓòÉΓòÉΓòÉ
  12112.  
  12113. The #pragma data_seg directive lets you place static and external variables in 
  12114. different 32-bit data segments. 
  12115.  
  12116. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇdata_segΓöÇΓöÇ(ΓöÇΓöÇdatasegmentΓöÇΓöÇ)ΓöÇΓöÇ><
  12117.  
  12118. All static and external variables defined after the #pragma data_seg directive 
  12119. are placed in the named datasegment until another #pragma data_seg statement is 
  12120. found or the end of the compilation unit is reached. 
  12121.  
  12122. Restrictions: 
  12123.  
  12124. o Writable string literals used to initialize pointers are not placed in the 
  12125.   named datasegment, but in the default 32-bit data segment (DATA32). To place 
  12126.   a string in a particular data segment, use an array to initialize the string 
  12127.   instead of a pointer. For example: 
  12128.  
  12129.        char a[ ] = "mystring";
  12130.   instead of 
  12131.  
  12132.        char *a = "mystring";
  12133.  
  12134. o #pragma data_seg applies only to 32-bit data segments. Data placed in 16-bit 
  12135.   segments because of the /Gt option or #pragma seg16 are not affected by 
  12136.   #pragma data_seg, and are placed in 16-bit data segments. 
  12137.  
  12138. Static and external variables defined before the first #pragma data_seg 
  12139. directive are placed in the default DATA32 segment, with the exception of 
  12140. uninitialized variables and variables explicitly initialized to zero, which are 
  12141. placed in the BSS32 segment. You can also use #pragma data_seg to explicitly 
  12142. place variables in the DATA32 segment by specifying no datasegment, for 
  12143. example, #pragma data_seg(). However, you cannot use the CONST or BSS32 
  12144. segments in a #pragma data_seg directive. 
  12145.  
  12146. Note:  Because the variables in the BSS32 data segment are initialized at load 
  12147. time and loaded separately from the rest of your program, they take less space 
  12148. in your executable file. If you place these variables in a different data 
  12149. segment, this optimization does not take place, and the size of your executable 
  12150. module increases. For this reason, if the size of your executable file is 
  12151. critical to you, you should define all variables initialized to zero (either 
  12152. explicitly or by default) before the first occurrence of #pragma data_seg. 
  12153.  
  12154. Defining your own data segments allows you to group data depending on how it is 
  12155. used and to specify different attributes for different groups of data, such as 
  12156. when the data should be loaded. You specify attributes for data segments in a 
  12157. module definition (.DEF) file. 
  12158.  
  12159. For example, when you build a DLL, you might have one set of data that you want 
  12160. to make global for all processes that use the DLL, and a different set of data 
  12161. that you want to copy for each process. You could use #pragma data_seg to place 
  12162. the data in two different segments as follows: 
  12163.  
  12164.    #pragma data_seg(globdata)
  12165.  
  12166.    static int counter1 = 0;
  12167.    static int counter2 = 0;
  12168.    .
  12169.    .
  12170.    .
  12171.    #pragma data_seg(instdata)
  12172.  
  12173.    static int instcount1 = 0;
  12174.    static int instcount2 = 0;
  12175.    .
  12176.    .
  12177.    .
  12178.  
  12179. You could then place the following statements in the program's .DEF file: 
  12180.  
  12181.    SEGMENTS
  12182.       globdata CLASS 'DATA' SHARED
  12183.       instdata CLASS 'DATA' NONSHARED
  12184.  
  12185. SHARED specifies that the data in the globdata segment is global or shared by 
  12186. all processes that use the DLL. NONSHARED means that each process gets its own 
  12187. copy of the data in the instdata segment. 
  12188.  
  12189. For more information on attributes and how to specify them in a .DEF file, see 
  12190. the Toolkit documentation for the LINK386 program. 
  12191.  
  12192. Related Information 
  12193.  
  12194. o #pragma alloc_text 
  12195. o #pragma 
  12196. o Preprocessor Directives 
  12197.  
  12198.  
  12199. ΓòÉΓòÉΓòÉ 9.12.7. define ΓòÉΓòÉΓòÉ
  12200.  
  12201. The #pragma define can be used to force the definition of a template class 
  12202. without actually defining an object of the class. This directive is valid for 
  12203. C++ files only. The syntax is: 
  12204.  
  12205. >>ΓöÇΓöÇ#ΓöÇΓöÇpragmaΓöÇΓöÇdefineΓöÇΓöÇ(ΓöÇΓöÇtemplate_class_nameΓöÇΓöÇ)ΓöÇΓöÇ><
  12206.  
  12207. The pragma can appear anywhere that a declaration is allowed. 
  12208.  
  12209. The define pragma is used when organizing your program for the efficient or 
  12210. automatic generation of template functions. "Using Templates in C++ Programs" 
  12211. in the IBM C/C++ Tools: Programming Guide gives more information about using 
  12212. #pragma define. 
  12213.  
  12214. Related Information 
  12215.  
  12216. o Templates 
  12217. o #pragma 
  12218. o Preprocessor Directives 
  12219. o "Using Templates in C++ Programs" in the Programming Guide 
  12220.  
  12221.  
  12222. ΓòÉΓòÉΓòÉ 9.12.8. entry ΓòÉΓòÉΓòÉ
  12223.  
  12224. The #pragma entry directive specifies the function to be used as the entry 
  12225. point for the application being built. 
  12226.  
  12227. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇentryΓöÇΓöÇ(ΓöÇΓöÇfunc_nameΓöÇΓöÇ)ΓöÇΓöÇ><
  12228.  
  12229. The func_name function must be in the same compilation unit as the #pragma 
  12230. entry directive, and must be a defined external function. 
  12231.  
  12232. Normally when an application is started, the OS/2 system calls the C library 
  12233. entry point. When you specify a different entry point using #pragma entry, the 
  12234. system calls that entry point and does not perform any C library initialization 
  12235. or termination. If you use #pragma entry, you must ensure that your executable 
  12236. file does not require library initialization or termination, or you must 
  12237. provide your own initialization and termination functions. 
  12238.  
  12239. Related Information 
  12240.  
  12241. o #pragma 
  12242. o Preprocessor Directives 
  12243.  
  12244.  
  12245. ΓòÉΓòÉΓòÉ 9.12.9. export ΓòÉΓòÉΓòÉ
  12246.  
  12247. The #pragma export directive declares that a DLL function is to be exported and 
  12248. specifies the name of the function outside the DLL. 
  12249.  
  12250. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇpragmaΓöÇexportΓöÇΓöÇ(ΓöÇΓöÇfunction_nameΓöÇΓöÇ,ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ,ΓöÇΓöÇ>
  12251.                       ΓööΓöÇ"ΓöÇΓöÇexport_nameΓöÇΓöÇ"ΓöÇΓöÿ
  12252. >ΓöÇΓöÇordinalΓöÇΓöÇ)ΓöÇΓöÇ><
  12253.  
  12254. The function_name is the name of the function in the DLL.  The export_name is 
  12255. the name for function outside of the DLL. If no export_name is specified, 
  12256. function is used. 
  12257.  
  12258. The ordinal is the number of the function within the DLL. Another module can 
  12259. import the function using either the export_name or the ordinal number. Ordinal 
  12260. numbers are described in more detail in the Toolkit documentation. 
  12261.  
  12262. For example, the statements: 
  12263.  
  12264.    int elaine(int);
  12265.    #pragma export(elaine, catherine, 4)
  12266.  
  12267. declare that the function elaine is to be exported, and can be imported by 
  12268. another module using the name catherine or the ordinal number 4. See #pragma 
  12269. import for information on importing functions. 
  12270.  
  12271. You can also use the _Export keyword to export a function. If you use the 
  12272. keyword, you cannot specify a different name or an ordinal for the exported 
  12273. function. 
  12274.  
  12275. If you use #pragma export to export your function, you may still need to 
  12276. provide an EXPORTS entry for that function in your module definition (.DEF) 
  12277. file. If your function has any of the following default characteristics 
  12278.  
  12279. o Has shared data 
  12280. o Has no I/O privileges 
  12281. o Is not resident 
  12282.  
  12283. it does not require an EXPORTS entry. If your function has characteristics 
  12284. other than the defaults, the only way you can specify them is with an EXPORTS 
  12285. entry in your .DEF file. 
  12286.  
  12287. Note:  To create an import library for the DLL, you must either create it from 
  12288. the DLL itself or provide a .DEF file with an EXPORTS entry for every function, 
  12289. regardless of whether #pragma export is used. 
  12290.  
  12291. For more information on DLLs and .DEF files, see the Programming Guide. 
  12292.  
  12293. Related Information 
  12294.  
  12295. o #pragma import 
  12296. o _Export Qualifier 
  12297. o #pragma 
  12298. o Preprocessor Directives 
  12299.  
  12300.  
  12301. ΓòÉΓòÉΓòÉ 9.12.10. handler ΓòÉΓòÉΓòÉ
  12302.  
  12303. The #pragma handler directive registers an exception handler for a function. 
  12304.  
  12305. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇhandlerΓöÇΓöÇ(ΓöÇΓöÇfunctionΓöÇΓöÇ)ΓöÇΓöÇ><
  12306.  
  12307. The function is the name of the function for which the exception handler is to 
  12308. be registered. You should declare it before you use it in this directive. 
  12309.  
  12310. The #pragma handler directive generates the code at compile time to install the 
  12311. C/C++Tools exception handler _Exception before starting execution of the 
  12312. function. It also generates code to remove the exception handler at function 
  12313. exit. 
  12314.  
  12315. You must use this directive whenever you change library environments or enter a 
  12316. user-created DLL. 
  12317.  
  12318. Note:  If you are using the subsystem libraries, the _Exception function is not 
  12319. provided. To use the #pragma handler directive in a subsystem, you must provide 
  12320. your own exception handler named _Exception. Otherwise, you must register and 
  12321. remove your own exception handlers using the OS/2 exception handler APIs 
  12322. described in the IBM OS/2 2.0 Programming Reference. 
  12323.  
  12324. For more information on exception handling and _Exception, see the IBM 
  12325. C/C++ Tools: Programming Guide. 
  12326.  
  12327. Related Information 
  12328.  
  12329. o #pragma 
  12330. o Preprocessor Directives 
  12331.  
  12332.  
  12333. ΓòÉΓòÉΓòÉ 9.12.11. implementation ΓòÉΓòÉΓòÉ
  12334.  
  12335. The implementation pragma is used to tell the compiler the name of the file 
  12336. that contains the function template definitions corresponding to the template 
  12337. declarations in the include file containing the pragma. This directive is valid 
  12338. for C++ files only. The syntax is: 
  12339.  
  12340. >>ΓöÇΓöÇ#ΓöÇΓöÇpragmaΓöÇΓöÇimplementationΓöÇΓöÇ(ΓöÇΓöÇstring_literalΓöÇΓöÇ)ΓöÇΓöÇ><
  12341.  
  12342. The pragma can appear anywhere that a declaration is allowed. 
  12343.  
  12344. The implementation pragma is used when organizing your program for the 
  12345. efficient or automatic generation of template functions. "Using Templates in 
  12346. C++ Programs" in the IBM C/C++ Tools: Programming Guide gives more information 
  12347. about using #pragma implementation. 
  12348.  
  12349. Related Information 
  12350.  
  12351. o Templates 
  12352. o #pragma 
  12353. o Preprocessor Directives 
  12354. o "Using Templates in C++ Programs" in the Programming Guide 
  12355.  
  12356.  
  12357. ΓòÉΓòÉΓòÉ 9.12.12. import ΓòÉΓòÉΓòÉ
  12358.  
  12359. The #pragma import directive lets you import a function from a DLL using either 
  12360. an ordinal number or a function name different from the one that it has in the 
  12361. DLL. 
  12362.  
  12363. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇimportΓöÇΓöÇ(ΓöÇΓöÇfunctionΓöÇΓöÇ,ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ,ΓöÇΓöÇ>
  12364.                      ΓööΓöÇ"ΓöÇΓöÇexternal_nameΓöÇΓöÇ"ΓöÇΓöÿ
  12365. >ΓöÇΓöÇ"ΓöÇΓöÇmod_nameΓöÇΓöÇ"ΓöÇΓöÇ,ΓöÇΓöÇordinalΓöÇΓöÇ)ΓöÇΓöÇ><
  12366.  
  12367. The function is the name you use in your source to call the function.  The 
  12368. external_name is the name of the function in the DLL. For C++ files, 
  12369. external_name can also be a function prototype. If external_name is not 
  12370. specified, it is assumed to be the same as function. 
  12371.  
  12372. Note:  Both function and external_name must be defined only once in each 
  12373. compilation unit. 
  12374.  
  12375. The mod_name is the name of the DLL containing the function, and ordinal 
  12376. indicates the position of the function within the DLL. Ordinal numbers are 
  12377. described in more detail in the Toolkit documentation. 
  12378.  
  12379. The information provided by #pragma import is used at load time to locate the 
  12380. imported function. If ordinal is 0, the external_name is used to find the 
  12381. function. If ordinal is any other number, external_name is ignored and the 
  12382. function is located by number. It is usually faster to locate the function by 
  12383. number than by name. 
  12384.  
  12385. Using #pragma import decreases your link time because the linker does not 
  12386. require an import library to resolve external names. This #pragma directive is 
  12387. also useful for C++ programming because you do not have to use the fully 
  12388. qualified function name to call an imported function. 
  12389.  
  12390. Note:  You cannot use the ordinals provided in the Toolkit header files with 
  12391. #pragma import. These ordinals are provided as C macros that cannot be used in 
  12392. #pragma directives. 
  12393.  
  12394. Related Information 
  12395.  
  12396. o #pragma export 
  12397. o _Export Qualifier 
  12398. o #pragma 
  12399. o Preprocessor Directives 
  12400.  
  12401.  
  12402. ΓòÉΓòÉΓòÉ 9.12.13. info ΓòÉΓòÉΓòÉ
  12403.  
  12404. The #pragma info directive controls the diagnostic messages generated by the 
  12405. /Wgrp compiler options. 
  12406.  
  12407. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇinfoΓöÇΓöÇ(ΓöÇΓöÇΓö¼ΓöÇallΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ)ΓöÇΓöÇ><
  12408.              Γö£ΓöÇnoneΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  12409.              Γö£ΓöÇrestoreΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  12410.              Γöé ΓöîΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ Γöé
  12411.              Γöé      Γöé Γöé
  12412.              ΓööΓöÇΓöÇΓö¼ΓöÇgrpΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇΓöÿ
  12413.                ΓööΓöÇnogrpΓöÇΓöÿ
  12414.  
  12415. You can use this #pragma directive in place of the /Wgrp option to turn groups 
  12416. of diagnostics on or off. Specifying #pragma info(grp) causes all messages 
  12417. associated with that diagnostic group to be generated.  Specifying #pragma 
  12418. info(nogrp) suppresses all messages associated with that group. 
  12419.  
  12420. For example, to generate messages for missing function prototypes and 
  12421. statements with no effect, but not for uninitialized variables, specify: 
  12422.  
  12423.    #pragma info(pro, eff, nouni)
  12424.  
  12425. The #pragma directive overrides any /Wgrp options stated on the command line. 
  12426.  
  12427. Use #pragma info(all) to turn on all diagnostic checking.  You can use #pragma 
  12428. info(none) to turn off all diagnostic suboptions for specific portions of your 
  12429. program. Specifying #pragma info(restore) restores the options that were in 
  12430. effect before the previous #pragma info directive.  Because #pragma info 
  12431. operates like a stack, the options restored may not be those given on the 
  12432. command line. If no options were previously in effect, #pragma info(restore) 
  12433. does nothing. 
  12434.  
  12435. The #pragma info directive replaces the #pragma checkout directive for 
  12436. controlling diagnostics. The C/C++ Tools compiler will map #pragma 
  12437. checkout(suspend) to #pragma info(none), and #pragma checkout(resume) to 
  12438. #pragma info(restore). 
  12439.  
  12440. The following list explains the groups of diagnostic messages controlled by 
  12441. each grp option: 
  12442.  
  12443. Group   Diagnostics 
  12444. cmp     Possible redundancies in unsigned comparisons. 
  12445. cnd     Possible redundancies or problems in conditional expressions. 
  12446. cns     Operations involving constants. 
  12447. cnv     Conversions. 
  12448. dcl     Consistency of declarations. 
  12449. eff     Statements with no effect. 
  12450. enu     Consistency of enum variables. 
  12451. ext     Unused external definitions. 
  12452. gen     General diagnostics. 
  12453. got     Usage of goto statements. 
  12454. ini     Possible problems with initialization. 
  12455. lan     Effects of the language level. 
  12456. obs     Features that are obsolete. 
  12457. ord     Unspecified order of evaluation. 
  12458. par     Unused parameters. 
  12459. por     Nonportable language constructs. 
  12460. ppc     Possible problems with using the preprocessor. 
  12461. ppt     Trace of preprocessor actions. 
  12462. pro     Missing function prototypes. 
  12463. rea     Code that cannot be reached. 
  12464. ret     Consistency of return statements. 
  12465. trd     Possible truncation or loss of data or precision. 
  12466. tru     Variable names truncated by the compiler. 
  12467. uni     Uninitialized variables. 
  12468. use     Unused auto and static variables. 
  12469.  
  12470. Related Information 
  12471.  
  12472. o #pragma checkout 
  12473. o Using the /Wgrp Diagnostic Options 
  12474. o Debugging and Diagnostic Information Options 
  12475. o #pragma 
  12476. o Preprocessor Directives 
  12477.  
  12478.  
  12479. ΓòÉΓòÉΓòÉ 9.12.14. langlvl ΓòÉΓòÉΓòÉ
  12480.  
  12481. The #pragma langlvl directive lets you select elements of the C/C++ Tools 
  12482. implementation. 
  12483.  
  12484.                ΓöîΓöÇextendedΓöÇΓöÉ
  12485. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇlanglvlΓöÇΓöÇ(ΓöÇΓöÇΓö╝ΓöÇansiΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇ)ΓöÇΓöÇ><
  12486.                Γö£ΓöÇcompatΓöÇΓöÇΓöÇΓöñ
  12487.                Γö£ΓöÇsaaΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  12488.                ΓööΓöÇsaal2ΓöÇΓöÇΓöÇΓöÇΓöÿ
  12489.  
  12490. This directive can be specified only once in your source file, and must appear 
  12491. before any C code. 
  12492.  
  12493. The compiler defines preprocessor variables that are used in header files to 
  12494. define the language level. The options are: 
  12495.  
  12496. extended    Defines the preprocessor variable __EXTENDED__.  Allows ANSI and 
  12497.             SAA C constructs and all C/C++ Tools extensions. 
  12498. ansi        Defines the preprocessor variables __ANSI__ and __STDC__.  Allows 
  12499.             only language constructs that conform to ANSI standards. Note that 
  12500.             for C++,  the __STDC__ macro is set to 0, while for C it is set to 
  12501.             1. 
  12502. compat      Defines the preprocessor variable __COMPAT__. Allows constructs 
  12503.             supported by earlier versions of the C++ language, as well as ANSI 
  12504.             constructs and C/C++ Tools extensions. This language level is valid 
  12505.             for C++ programs only. 
  12506. saa         Defines the preprocessor variables __SAA__ and __SAA_L2__. Allows 
  12507.             only language constructs that conform to the most recent level of 
  12508.             SAA C standards (currently Level 2). These include ANSI C 
  12509.             constructs. This language level is valid for C programs only. 
  12510. saal2       Defines the preprocessor variable __SAA_L2__. Allows only language 
  12511.             constructs that conform to SAA Level 2 C standards. These include 
  12512.             ANSI C constructs. This language level is valid for C programs 
  12513.             only. 
  12514.  
  12515. The default language level is extended. 
  12516.  
  12517. You can also set the language level using the /Sa, /Sc, /S2, and /Se compiler 
  12518. options. These options are described in Source Code Options. 
  12519.  
  12520. Related Information 
  12521.  
  12522. o /Sa, /Sc, /S2, /Se options 
  12523. o Predefined Macros 
  12524. o #pragma 
  12525. o Preprocessor Directives 
  12526.  
  12527.  
  12528. ΓòÉΓòÉΓòÉ 9.12.15. linkage ΓòÉΓòÉΓòÉ
  12529.  
  12530. The #pragma linkage directive identifies the linkage or calling convention used 
  12531. on a function call. 
  12532.  
  12533. Note:  This #pragma directive is valid for C code only. 
  12534.  
  12535.                     ΓöîΓöÇoptlinkΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  12536. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇpragmaΓöÇlinkageΓöÇ(ΓöÇΓöÇidentifierΓöÇ,ΓöÇΓöÇΓö╝ΓöÇsystemΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇ)ΓöÇΓöÇ><
  12537.                     Γö£ΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇpascalΓöÇΓöÇΓöÇΓöÇΓöñ
  12538.                     Γöé ΓööΓöÇfar32ΓöÇΓöÿ       Γöé
  12539.                     ΓööΓöÇfar16ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÿ
  12540.                          Γö£ΓöÇcdeclΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  12541.                          Γö£ΓöÇ_cdeclΓöÇΓöÇΓöÇΓöÇΓöñ
  12542.                          Γö£ΓöÇpascalΓöÇΓöÇΓöÇΓöÇΓöñ
  12543.                          Γö£ΓöÇ_pascalΓöÇΓöÇΓöÇΓöñ
  12544.                          Γö£ΓöÇfastcallΓöÇΓöÇΓöñ
  12545.                          ΓööΓöÇ_fastcallΓöÇΓöÿ
  12546.  
  12547. The identifier identifies either the name of the function that will be given 
  12548. the particular linkage type or the name of a typedef that resolves to a 
  12549. function type. If identifier is a typedef, any function declared using 
  12550. identifier will be given the particular linkage type. 
  12551.  
  12552. The following example shows how to use a typedef to declare functions and 
  12553. pointers to functions of _System linkage: 
  12554.  
  12555.    #pragma linkage(functype, system)
  12556.  
  12557.    typedef int functype(int);
  12558.  
  12559.    functype f;     /* f is a function with _System linkage */
  12560.    functype *fp;   /* fp is a pointer to a function with _System linkage */
  12561.  
  12562. The C/C++ Tools default linkage is _Optlink, which is a convention specific to 
  12563. the C/C++ Tools product. If your program calls OS/2 APIs, you must use the 
  12564. _System calling convention, which is standard for all OS/2 applications to call 
  12565. those APIs. If you include the system header files, the OS/2 APIs are 
  12566. automatically given _System linkage. 
  12567.  
  12568. If you are developing device drivers, you should use the _Pascal convention. 
  12569. You should use the _Far32 version of _Pascal linkage if your calls will cross 
  12570. code segments. Note that _Far32 _Pascal linkage is only available when you 
  12571. specify the /Gr+ option to generate code that runs at ring zero. 
  12572.  
  12573. The _Far16 linkage conventions indicate that a function has a 16-bit linkage 
  12574. type. The cdecl and _cdecl options are equivalent. The underscore is optional, 
  12575. and is accepted for compatibility with C/2* cdecl linkage declarations. 
  12576. Similarly, pascal and _pascal are equivalent, and specify C/2 pascal linkage; 
  12577. fastcall and _fastcall specify Microsoft** _fastcall linkage. If far16 is 
  12578. specified without a parameter, _Cdecl linkage is used. 
  12579.  
  12580. You can also use linkage keywords to specify the calling convention for a 
  12581. function. Linkage keywords are easier to use than is the #pragma linkage 
  12582. directive. They let you declare both the function and its linkage type in one 
  12583. statement. See Linkage Keywords for more information on these keywords. 
  12584.  
  12585. You can use compiler options to explicitly set the calling convention to 
  12586. _Optlink (/Mp) or to change the default to _System linkage (/Ms). These options 
  12587. are described in Code Generation Options. A linkage keyword or #pragma linkage 
  12588. directive overrides the compiler option. 
  12589.  
  12590. For more information about calling conventions, see the Programming Guide. 
  12591.  
  12592. Related Information 
  12593.  
  12594. o /Mp, /Ms Options 
  12595. o Linkage Keywords 
  12596. o typedef 
  12597. o #pragma 
  12598. o Preprocessor Directives 
  12599.  
  12600.  
  12601. ΓòÉΓòÉΓòÉ 9.12.16. map ΓòÉΓòÉΓòÉ
  12602.  
  12603. The #pragma map directive associates an external name (name) with a C name 
  12604. (identifier). 
  12605.  
  12606. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇmapΓöÇΓöÇ(ΓöÇΓöÇidentifierΓöÇΓöÇ,ΓöÇΓöÇ"name"ΓöÇΓöÇ)ΓöÇΓöÇ><
  12607.  
  12608. The #pragma map directive is provided primarily for compatibility with IBM 
  12609. C/370. but can also be used with the C/C++ Tools debugger. It is also useful 
  12610. when your program maps to functions created by other compilers that precede 
  12611. identifier and function names with underscores. 
  12612.  
  12613. When you use this directive, the identifier that appears in the source file is 
  12614. not visible in the object file. The external name will be used to represent the 
  12615. object in the object file. 
  12616.  
  12617. Enclose the variable name in double quotation marks. The name will be kept as 
  12618. specified on the #pragma map directive in mixed case. Multiple identifiers can 
  12619. have the same map name. The compiler generates an error message if more than 
  12620. one map name is given to an identifier. 
  12621.  
  12622. The map name is an external name and must not be used in the source file to 
  12623. reference the object. If you try to use the map name in the source file, to 
  12624. access the corresponding object, the compiler will treat the map name as a new 
  12625. identifier. The compiler generates an error if a repeated #pragma map directive 
  12626. is encountered with the same map name and the same identifier. 
  12627.  
  12628. Note:  The C/C++ Tools compiler does not implement the optional third parameter 
  12629. to #pragma map, as defined by the SAA standard. 
  12630.  
  12631. Related Information 
  12632.  
  12633. o #pragma 
  12634. o Preprocessor Directives 
  12635.  
  12636.  
  12637. ΓòÉΓòÉΓòÉ 9.12.17. margins ΓòÉΓòÉΓòÉ
  12638.  
  12639. The #pragma margins directive specifies the columns in the input line that are 
  12640. to be scanned for input to the compiler. 
  12641.  
  12642. Note:  This #pragma directive is valid for C code only. 
  12643.  
  12644.          ΓöîΓöÇnomarginsΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  12645. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇΓö┤ΓöÇmarginsΓöÇΓöÇ(ΓöÇΓöÇlΓöÇΓöÇ,ΓöÇΓöÇrΓöÇΓöÇ)ΓöÇΓö┤ΓöÇΓöÇ><
  12646.  
  12647. Use the #pragma margins directive if you want to have characters outside 
  12648. certain columns ignored in your source file. The compiler ignores any text in 
  12649. the source input that does not fall within the range specified in the 
  12650. directive. 
  12651.  
  12652. The variable l specifies the first column of the source input that is to be 
  12653. scanned, and must be between 1 and 65535, inclusive. The variable r specifies 
  12654. the last column of the source input that is to be scanned. It must be greater 
  12655. than or equal to l and less than or equal to 65535. An asterisk (*) can be 
  12656. assigned to r to indicate the last column of input. 
  12657.  
  12658. By default, the left margin is set to 1, and the right margin is set to 
  12659. infinity. If nomargins is specified, the default values are taken. 
  12660.  
  12661. The #pragma margins directive can be used with the #pragma sequence directive 
  12662. to specify the columns that are not to be scanned for sequence numbers. If the 
  12663. #pragma sequence settings do not fall within the #pragma margins settings, the 
  12664. sequence directive has no effect. 
  12665.  
  12666. You can also set margins using the /Sg option. This option is described in 
  12667. Source Code Options. 
  12668.  
  12669. Related Information 
  12670.  
  12671. o /Sg Option 
  12672. o #pragma sequence 
  12673. o #pragma 
  12674. o Preprocessor Directives 
  12675.  
  12676.  
  12677. ΓòÉΓòÉΓòÉ 9.12.18. pack ΓòÉΓòÉΓòÉ
  12678.  
  12679. The #pragma pack directive specifies the alignment rules to use for the 
  12680. structures and unions that follow it. 
  12681.  
  12682. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇpackΓöÇΓöÇ(ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ)ΓöÇΓöÇ><
  12683.              Γö£ΓöÇ1ΓöÇΓöñ
  12684.              Γö£ΓöÇ2ΓöÇΓöñ
  12685.              ΓööΓöÇ4ΓöÇΓöÿ
  12686.  
  12687. The #pragma pack directive causes all structures and unions that follow it in 
  12688. the program to be packed along a 1-byte, 2-byte, or 4-byte (the system default) 
  12689. boundary, according to the value specified in the directive, until another 
  12690. #pragma pack directive changes the packing boundary. 
  12691.  
  12692. If no value is specified, packing is performed along the system default 
  12693. boundary unless the /Sp compiler option was used. If it is used, #pragma pack() 
  12694. causes packing to be performed along the boundary specified by /Sp. The /Sp 
  12695. option is described in Source Code Options. 
  12696.  
  12697. For example: 
  12698.  
  12699.    #pragma pack(1)
  12700.  
  12701.    struct hester{       /* this structure will be packed */
  12702.      char philip;       /*    along 1-byte boundaries    */
  12703.      int mark;
  12704.    };
  12705.    .
  12706.    .
  12707.    .
  12708.    #pragma pack(2)
  12709.  
  12710.    struct jeff{         /* this structure will be packed */
  12711.      float bill;        /*    along 2-byte boundaries    */
  12712.      int *chris;
  12713.    }
  12714.    .
  12715.    .
  12716.    .
  12717.    #pragma pack()
  12718.  
  12719.    struct dor{          /* this structure will be packed  */
  12720.      double stephen;    /* along the default boundaries   */
  12721.      long alex;
  12722.    }
  12723.  
  12724. Note:  If data types are by default packed along boundaries smaller than those 
  12725. specified by #pragma pack, they are still aligned along the smaller boundaries. 
  12726. For example, type char is always aligned along a 1-byte boundary, regardless of 
  12727. the value of #pragma pack. 
  12728.  
  12729. The following chart describes how each data type is packed for each of the 
  12730. #pragma pack options: 
  12731.  
  12732. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  12733. Γöé   DATA TYPE   Γöé    #PRAGMA PACK VALUE   Γöé
  12734. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  12735. Γöé         Γöé   1   Γöé   2   Γöé   4   Γöé
  12736. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  12737. Γöé "char"      Γöé   1   Γöé   1   Γöé   1   Γöé
  12738. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  12739. Γöé "short"     Γöé   1   Γöé   2   Γöé   2   Γöé
  12740. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  12741. Γöé "int", "long"  Γöé   1   Γöé   2   Γöé   4   Γöé
  12742. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  12743. Γöé "float",     Γöé   1   Γöé   2   Γöé   4   Γöé
  12744. Γöé "double", "long Γöé     Γöé     Γöé     Γöé
  12745. Γöé double"     Γöé     Γöé     Γöé     Γöé
  12746. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  12747. Γöé pointer     Γöé   1   Γöé   2   Γöé   4   Γöé
  12748. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  12749.  
  12750. Note:  The #pragma pack directive does not have the same effect as declaring a 
  12751.        structure as _Packed. The _Packed keyword removes all padding from 
  12752.        between structure members, while the #pragma pack directive only 
  12753.        specifies the boundaries to align the members on. 
  12754.  
  12755. Although _Packed is a SAA C construct, it is not portable to many systems. The 
  12756. C++ language does not support it. If portability and C++ support are important 
  12757. to you, avoid using the _Packed qualifier. 
  12758.  
  12759. For more information on packing structures, see _Packed Qualifier. 
  12760.  
  12761. Related Information 
  12762.  
  12763. o /Sp Option 
  12764. o _Packed Qualifier 
  12765. o Structures 
  12766. o Types 
  12767. o #pragma 
  12768. o Preprocessor Directives 
  12769.  
  12770.  
  12771. ΓòÉΓòÉΓòÉ 9.12.19. page ΓòÉΓòÉΓòÉ
  12772.  
  12773. Skips n pages of the generated source listing.  If n is not specified, the next 
  12774. page is started. 
  12775.  
  12776. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇpageΓöÇΓöÇ(ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ)ΓöÇΓöÇ><
  12777.              ΓööΓöÇnΓöÇΓöÿ
  12778.  
  12779. Related Information 
  12780.  
  12781. o #pragma 
  12782. o Preprocessor Directives 
  12783.  
  12784.  
  12785. ΓòÉΓòÉΓòÉ 9.12.20. pagesize ΓòÉΓòÉΓòÉ
  12786.  
  12787. The #pragma pagesize directive sets the number of lines per page to n for the 
  12788. generated source listing. 
  12789.  
  12790. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇpagesizeΓöÇΓöÇ(ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ)ΓöÇΓöÇ><
  12791.                ΓööΓöÇnΓöÇΓöÿ
  12792.  
  12793. The value of n must be between 16 and 32767, inclusive. The default page length 
  12794. is 66 lines. 
  12795.  
  12796. You can also use the /Lp compiler option to set the listing page size. This 
  12797. option is described in Listing File Options. 
  12798.  
  12799. Related Information 
  12800.  
  12801. o /Lp Option 
  12802. o #pragma 
  12803. o Preprocessor Directives 
  12804.  
  12805.  
  12806. ΓòÉΓòÉΓòÉ 9.12.21. priority ΓòÉΓòÉΓòÉ
  12807.  
  12808. The priority pragma specifies the order in which static objects are to be 
  12809. initialized at run time. This directive is valid for C++ files only. The syntax 
  12810. is: 
  12811.  
  12812. >>ΓöÇΓöÇ#ΓöÇΓöÇpragmaΓöÇΓöÇpriorityΓöÇΓöÇ(ΓöÇΓöÇnΓöÇΓöÇ)ΓöÇΓöÇ><
  12813.  
  12814. where n is an integer literal in the range of INT_MIN to INT_MAX. The default 
  12815. value is 0. A negative value indicates a higher priority; a positive value 
  12816. indicates a lower priority. 
  12817.  
  12818. The first 1024 priorities (INT_MIN to INT_MIN + 1023) are reserved for use by 
  12819. the compiler and its libraries. The priority value specified applies to all 
  12820. runtime static initialization in the current compilation unit. 
  12821.  
  12822. Related Information 
  12823.  
  12824. o #pragma 
  12825. o Preprocessor Directives 
  12826.  
  12827.  
  12828. ΓòÉΓòÉΓòÉ 9.12.22. seg16 ΓòÉΓòÉΓòÉ
  12829.  
  12830. The #pragma seg16 directive specifies that a data object will be shared between 
  12831. 16-bit and 32-bit processes. 
  12832.  
  12833. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇseg16ΓöÇΓöÇ(ΓöÇΓöÇidentifierΓöÇΓöÇ)ΓöÇΓöÇ><
  12834.  
  12835. It causes the compiler to lay out the identifier in memory so that it does not 
  12836. cross a 64K boundary. The identifier can then be used in a 16-bit program. 
  12837.  
  12838. The identifier can be a typedef or a data object. For example: 
  12839.  
  12840.    typedef struct foo foostr;
  12841.    #pragma seg16(foostr)
  12842.    foostr  quux;
  12843.  
  12844. uses the typedef foostr to declare quux as an object addressable by a 16-bit 
  12845. program. 
  12846.  
  12847. You can also use the /Gt compiler option to perform the equivalent of a #pragma 
  12848. seg16 for all variables in the program. The /Gt option is described in Code 
  12849. Generation Options. 
  12850.  
  12851. Note:  If #pragma seg16 is used on variables of a structure type, the pointers 
  12852. inside that structure are not automatically qualified as usable by 16-bit 
  12853. programs. If you want the pointers in the structure qualified as such, you must 
  12854. declare them using the _Seg16 type qualifier. See _Seg16 Type Qualifier for 
  12855. more information about _Seg16. 
  12856.  
  12857. For more information on calling 16-bit programs, see the Programming Guide. 
  12858.  
  12859. Related Information 
  12860.  
  12861. o /Gt Option 
  12862. o _Seg16 Type Qualifier 
  12863. o Structures 
  12864. o typedef 
  12865. o #pragma 
  12866. o Preprocessor Directives 
  12867.  
  12868.  
  12869. ΓòÉΓòÉΓòÉ 9.12.23. sequence ΓòÉΓòÉΓòÉ
  12870.  
  12871. The #pragma sequence directive defines the section of the input line that is to 
  12872. contain sequence numbers. 
  12873.  
  12874. Note:  This #pragma directive is valid for C code only. 
  12875.  
  12876.          ΓöîΓöÇnosequenceΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  12877. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇΓö┤ΓöÇsequenceΓöÇΓöÇ(ΓöÇΓöÇlΓöÇΓöÇ,ΓöÇΓöÇrΓöÇΓöÇ)ΓöÇΓö┤ΓöÇΓöÇ><
  12878.  
  12879. If you are using a source file produced on a system that uses sequence numbers, 
  12880. you can use this option to have the sequence numbers ignored. 
  12881.  
  12882. The variable l specifies the column number of the left-hand margin. The value 
  12883. of l must be between 1 and 65535 inclusive, and must also be less than or equal 
  12884. to the value of r. The variable r specifies the column number of the right-hand 
  12885. margin. The value of r must be greater than or equal to l and less than or 
  12886. equal to 65535. An asterisk (*) can be assigned to r to indicate the last 
  12887. column of the line. 
  12888.  
  12889. The default for this directive is nosequence, which specifies there are no 
  12890. sequence numbers. 
  12891.  
  12892. The #pragma sequence directive can be used with the #pragma margins directive 
  12893. to specify the columns that are not to be scanned. If the #pragma sequence 
  12894. settings do not fall within the #pragma margins settings, the sequence 
  12895. directive has no effect. 
  12896.  
  12897. You can also set sequence numbers using the /Sq option. This option is 
  12898. described in Source Code Options. 
  12899.  
  12900. Related Information 
  12901.  
  12902. o /Sq Option 
  12903. o #pragma margins 
  12904. o #pragma 
  12905. o Preprocessor Directives 
  12906.  
  12907.  
  12908. ΓòÉΓòÉΓòÉ 9.12.24. skip ΓòÉΓòÉΓòÉ
  12909.  
  12910. Skips the next n lines of the generated source listing.  The value of n must be 
  12911. a positive integer less than 255.  If n is omitted, one line is skipped. 
  12912.  
  12913. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇskipΓöÇΓöÇ(ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ)ΓöÇΓöÇ><
  12914.              ΓööΓöÇnΓöÇΓöÿ
  12915.  
  12916. Related Information 
  12917.  
  12918. o #pragma 
  12919. o Preprocessor Directives 
  12920. o Listing File Options 
  12921.  
  12922.  
  12923. ΓòÉΓòÉΓòÉ 9.12.25. sourcedir ΓòÉΓòÉΓòÉ
  12924.  
  12925. The sourcedir pragma defines a new path to the directory containing the 
  12926. original source from which the compiler generates files in the TEMPINC 
  12927. directory. 
  12928.  
  12929. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇsourcedirΓöÇΓöÇ(ΓöÇΓöÇpathΓöÇΓöÇ)ΓöÇΓöÇ><
  12930.  
  12931. Instead of searching the TEMPINC directory first for the original source of the 
  12932. include file, the pragma directs the compiler to the directory specified by the 
  12933. supplied path. The compiler automatically inserts the necessary #pragma 
  12934. sourcedir directives into the source files it generates in the TEMPINC 
  12935. directory. 
  12936.  
  12937. Note:  This directive can only be used in C++ code. 
  12938.  
  12939. Related Information 
  12940.  
  12941. o #pragma 
  12942.  
  12943.  
  12944. ΓòÉΓòÉΓòÉ 9.12.26. stack16 ΓòÉΓòÉΓòÉ
  12945.  
  12946. The #pragma stack16 directive specifies the size of the stack to be allocated 
  12947. for calls to 16-bit routines. 
  12948.  
  12949. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇstack16ΓöÇΓöÇ(ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ)ΓöÇΓöÇ><
  12950.                ΓööΓöÇsizeΓöÇΓöÿ
  12951.  
  12952. The variable size is the size of the stack in bytes, and has a value between 
  12953. 512 and 65532. The size specified applies to any 16-bit functions called from 
  12954. that point until the end of the compilation unit, or until another #pragma 
  12955. stack16 directive is given. 
  12956.  
  12957. The default value is 4096 bytes (4K). Note that the 16-bit stack is taken from 
  12958. the 32-bit stack allocated for the thread calling the 16-bit code. The 32-bit 
  12959. stack is therefore reduced by the amount you specify with #pragma stack16. Make 
  12960. sure your 32-bit stack is large enough for both your 32-bit and 16-bit code. 
  12961.  
  12962. If the sum of the size, the number of bytes for parameters, and the number of 
  12963. local bytes in the function calling the 16-bit routine is greater than 65532, 
  12964. the actual stack size will be 65532 bytes less the number of parameter and 
  12965. local bytes. If the sum of the parameter bytes and local bytes alone is greater 
  12966. than 65532, no bytes will be allocated for calls to 16-bit routines. 
  12967.  
  12968. Related Information 
  12969.  
  12970. o #pragma 
  12971. o Preprocessor Directives 
  12972.  
  12973.  
  12974. ΓòÉΓòÉΓòÉ 9.12.27. strings ΓòÉΓòÉΓòÉ
  12975.  
  12976. Specifies that the compiler may place strings into read-only memory or must 
  12977. place strings into writeable memory. Strings are writeable by default. This 
  12978. pragma must appear before any C or C++ code in a file. 
  12979.  
  12980.                ΓöîΓöÇwriteableΓöÇΓöÉ
  12981. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇstringsΓöÇΓöÇ(ΓöÇΓöÇΓö┤ΓöÇreadonlyΓöÇΓöÇΓö┤ΓöÇΓöÇ)ΓöÇΓöÇ><
  12982.  
  12983. Related Information 
  12984.  
  12985. o Strings 
  12986. o #pragma 
  12987. o Preprocessor Directives 
  12988.  
  12989.  
  12990. ΓòÉΓòÉΓòÉ 9.12.28. subtitle ΓòÉΓòÉΓòÉ
  12991.  
  12992. Places the text specified by subtitle on all subsequent pages of the generated 
  12993. source listing. 
  12994.  
  12995. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇsubtitleΓöÇΓöÇ(ΓöÇΓöÇ"subtitle"ΓöÇΓöÇ)ΓöÇΓöÇ><
  12996.  
  12997. You can also use the /Lu compiler option to specify the listing subtitle. 
  12998.  
  12999. Related Information 
  13000.  
  13001. o /Lu option 
  13002. o #pragma title 
  13003. o #pragma 
  13004. o Preprocessor Directives 
  13005.  
  13006.  
  13007. ΓòÉΓòÉΓòÉ 9.12.29. title ΓòÉΓòÉΓòÉ
  13008.  
  13009. Places the text specified by title on all subsequent pages of the generated 
  13010. source listing. 
  13011.  
  13012. >>ΓöÇΓöÇΓöÇ#ΓöÇΓöÇΓöÇpragmaΓöÇΓöÇtitleΓöÇΓöÇ(ΓöÇΓöÇ"title"ΓöÇΓöÇ)ΓöÇΓöÇ><
  13013.  
  13014. You can also use the /Lt compiler option to specify the listing title. 
  13015.  
  13016. Related Information 
  13017.  
  13018. o /Lt option 
  13019. o #pragma subtitle 
  13020. o #pragma 
  13021. o Preprocessor Directives 
  13022.  
  13023.  
  13024. ΓòÉΓòÉΓòÉ 9.12.30. undeclared ΓòÉΓòÉΓòÉ
  13025.  
  13026. This directive is used only by the compiler and only in template-include files. 
  13027. It has the syntax: 
  13028.  
  13029. >>ΓöÇΓöÇ#ΓöÇΓöÇpragmaΓöÇΓöÇundeclaredΓöÇΓöÇ><
  13030.  
  13031. In the template-include file, template functions that were explicitly declared 
  13032. in at least one compilation unit appear before this line. Template functions 
  13033. that were called, but never declared, appear after this line. 
  13034.  
  13035. For more information on template-include files, see the "Using Templates in C++ 
  13036. Programs" in the Programming Guide. 
  13037.  
  13038. Related Information 
  13039.  
  13040. o #pragma 
  13041. o Preprocessor Directives 
  13042.  
  13043.  
  13044. ΓòÉΓòÉΓòÉ <hidden> Examples of #pragma Directives ΓòÉΓòÉΓòÉ
  13045.  
  13046. The following are examples of different #pragma directives: 
  13047.  
  13048. #pragma langlvl(SAA)
  13049. #pragma title("SAA pragma example")
  13050. #pragma pagesize(55)
  13051. #pragma map(ABC, "A$$BC@")
  13052.  
  13053.  
  13054. ΓòÉΓòÉΓòÉ 10. C++ Classes ΓòÉΓòÉΓòÉ
  13055.  
  13056. C++ provides a user-defined data type called a class. 
  13057.  
  13058. The C++ class is similar to the C structure data type. In C, a structure is 
  13059. composed of a set of data members. In C++, a class type is like a C structure, 
  13060. except that a class  is composed of a set of data members and an optional set 
  13061. of operations that can be performed on the class. 
  13062.  
  13063. In C++, a class type can be declared with the keywords union, struct, or class. 
  13064. A union object can hold any one of a set of named members. Structure and class 
  13065. objects hold a complete set of members. Each class type represents a unique set 
  13066. of class members including data members, member functions, and other type 
  13067. names. The default access for members depends on the class key: 
  13068.  
  13069. o The members of a class declared with the class key class are private by 
  13070.   default. A class is inherited privately by default. 
  13071. o The members of a class declared with the class key struct are public be 
  13072.   default. A structure is inherited publicly by default. 
  13073. o The members of a union (declared with the class key union) are public by 
  13074.   default. A union cannot be used as a base class in derivation. 
  13075.  
  13076. Once you create a class type, you can declare one or more objects of that class 
  13077. type. For example: 
  13078.  
  13079. class X
  13080. { /* define class members here */ };
  13081. void main()
  13082. {
  13083.       X xobject1;       // create an object of class type X
  13084.       X xobject2;       // create another object of class type X
  13085. }
  13086.  
  13087. This chapter introduces the concept of the class data type and discusses: 
  13088.  
  13089. o Classes and Access Control 
  13090. o Declaring Class Objects 
  13091. o Scope of Class Names 
  13092.  
  13093. Classes are also used in C++ to support polymorphic functions through 
  13094. overloaded functions (static compile time binding) and virtual functions 
  13095. (dynamic binding). C++ allows you to redefine standard operators and functions 
  13096. through the concept of overloading. Operator overloading facilitates data 
  13097. abstraction by allowing you to use classes as easily as built-in types. 
  13098.  
  13099. Related Information 
  13100.  
  13101. o C++ Class Members and Friends 
  13102. o Inheritance 
  13103. o C++ Overloading 
  13104. o Virtual Functions 
  13105. o Structures 
  13106. o Unions 
  13107.  
  13108.  
  13109. ΓòÉΓòÉΓòÉ 10.1. Classes and Access Control ΓòÉΓòÉΓòÉ
  13110.  
  13111. C++ facilitates data abstraction and encapsulation by providing access control 
  13112. for class types. For example, if you declare private data members and public 
  13113. member functions, a client program can only access the private members through 
  13114. the public member functions and friends of that class. Such a class would have 
  13115. data hiding because client programs do not have access to implementation 
  13116. details and are forced to use a public interface to manipulate objects of the 
  13117. class. 
  13118.  
  13119. You can control access to class members by using access specifiers. In the 
  13120. following example, the class abc has three private data members a, b, and c, 
  13121. and three public member functions add(), mult(), and the constructor abc(). The 
  13122. main() function creates an object danforth of the abc class and then attempts 
  13123. to print the value of the member a for this object: 
  13124.  
  13125. #include <iostream.h>
  13126.  
  13127. class abc
  13128. {
  13129. private:
  13130.       int a, b, c;
  13131. public:
  13132.       abc(int p1, int p2, int p3): a(p1), b(p2), c(p3) {}
  13133.       int add() { return a + b + c ; }
  13134.       int mult() { return a * b * c; }
  13135. };
  13136.  
  13137. void main() {
  13138.       abc danforth(1,2,3);
  13139.       cout << "Here is the value of a " << danforth.a << endl;
  13140.                   // This causes an error because a is not
  13141.                   // a public member and thus cannot be accessed
  13142.                   // directly
  13143.       }
  13144.  
  13145. Because class members are private by default, you can omit the keyword private 
  13146. in the definition of abc. Because a is not a public member, the attempt to 
  13147. access its value directly causes an error. 
  13148.  
  13149. Related Information 
  13150.  
  13151. o Member Access 
  13152. o Inherited Member Access 
  13153. o C++ Classes 
  13154.  
  13155.  
  13156. ΓòÉΓòÉΓòÉ 10.1.1. Declaring Classes ΓòÉΓòÉΓòÉ
  13157.  
  13158. A class-specifier is used to declare a class. Once a class specifier has been 
  13159. seen and its members declared, a class is considered to be defined even if the 
  13160. member functions of that class are not yet defined. A class specifier has the 
  13161. following form: 
  13162.  
  13163. >>ΓöÇΓöÇΓö¼ΓöÇclassΓöÇΓöÇΓö¼ΓöÇΓöÇclass-nameΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ{ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ}ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ><
  13164.   Γö£ΓöÇstructΓöÇΓöñ        ΓööΓöÇ:base-classΓöÇΓöÿ   ΓööΓöÇmember-listΓöÇΓöÿ
  13165.   ΓööΓöÇunionΓöÇΓöÇΓöÿ
  13166.  
  13167. The member-list is optional. It specifies the class members, both data and 
  13168. functions, of the class class-name. If the member-list of a class is empty, 
  13169. objects of that class have a nonzero size. You can use a class-name within the 
  13170. member-list of the class specifier itself as long as the size of the class is 
  13171. not required. For more information, see Class Member Lists. 
  13172.  
  13173. The base-class is optional. It specifies the base class or classes from which 
  13174. the class class-name inherits members. If the base-class is not empty, the 
  13175. class class-name is called a derived class. 
  13176.  
  13177. The declarator for a class variable declared with the class, struct, or union 
  13178. keyword is an identifier. If the symbol * precedes the identifier, the 
  13179. identifier names a pointer to a class of the specified data type. If  ** 
  13180. precedes the identifier, the identifier names a pointer to a pointer to a class 
  13181. of the specified data type. 
  13182.  
  13183. If a constant expression enclosed in [ ] (brackets) follows the identifier, the 
  13184. identifier names an array of classes of the specified data type. If * precedes 
  13185. the identifier and a constant expression enclosed in [ ] follows the 
  13186. identifier, the identifier names an array of pointers to classes of the 
  13187. specified data type. 
  13188.  
  13189. You can use classes to build complicated declarators. 
  13190.  
  13191. The union type specifier can be used to declare a class declarator. 
  13192.  
  13193. Related Information 
  13194.  
  13195. o Class Names 
  13196. o Declaring Class Objects 
  13197. o Scope of Class Names 
  13198. o Class Member Lists 
  13199. o Derivation 
  13200.  
  13201.  
  13202. ΓòÉΓòÉΓòÉ 10.1.2. Class Names ΓòÉΓòÉΓòÉ
  13203.  
  13204. A class-name is a unique identifier that becomes a reserved word within its 
  13205. scope. 
  13206.  
  13207. You can qualify the names of nested classes by using the :: (scope resolution) 
  13208. operator and the name of their enclosing class. 
  13209.  
  13210. Syntax of a Nested Class Specifier 
  13211.  
  13212. A qualified-class-specifier is an alternative way of referring to a class after 
  13213. it has been declared. A qualified class specifier consists of the nested class 
  13214. name, optionally preceded by the :: operator. 
  13215.  
  13216. Once a class name is declared, it hides other declarations of the same name 
  13217. within the enclosing scope. 
  13218.  
  13219. If a class name is declared in the same scope as a function, enumerator, or 
  13220. object with the same name, that class can be referred to by using an 
  13221. elaborated-type-specifier. In the following example, the elaborated type 
  13222. specifier is used to refer to the class print that is hidden by the later 
  13223. definition of the function print(): 
  13224.  
  13225. class print
  13226. {
  13227.       /* definition of class print */
  13228. };
  13229. void print (class print*);       // redefine print as a function
  13230. //      .                        // prefix class-name by class-key
  13231. //      .                        // to refer to class print
  13232. //      .
  13233. void main ()
  13234. {
  13235.       class print* paper;        // prefix class-name by class-key
  13236.                                  // to refer to class print
  13237.       print(paper);              // call function print
  13238. }
  13239.  
  13240. You can use an elaborated type specifier with a class name to declare a class. 
  13241. For more information on elaborated type specifiers, see Incomplete Class 
  13242. Declarations. 
  13243.  
  13244. You can also qualify type names to refer to hidden type names in the current 
  13245. scope. You can reduce complex class name syntax by using a typedef to represent 
  13246. a nested class name. 
  13247.  
  13248. Example of Using a typedef for a Class Name 
  13249.  
  13250. Related Information 
  13251.  
  13252. o Declaring Classes 
  13253. o Declaring Class Objects 
  13254. o Scope of Class Names 
  13255. o Nested Classes 
  13256.  
  13257.  
  13258. ΓòÉΓòÉΓòÉ <hidden> Syntax of a Nested Class Specifier ΓòÉΓòÉΓòÉ
  13259.  
  13260. The syntax of a nested class specifier is: 
  13261.  
  13262. >>ΓöÇΓöÇclass-nameΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ><
  13263.         ΓööΓöÇ::nested-classΓöÇΓöÿ
  13264.  
  13265. where class-name specifies the name of the enclosing class and nested-class 
  13266. specifies the name of the nested class. For more information, see Nested 
  13267. Classes. 
  13268.  
  13269.  
  13270. ΓòÉΓòÉΓòÉ <hidden> Example of Using a typedef for a Class Name ΓòÉΓòÉΓòÉ
  13271.  
  13272. /************************************************************************
  13273. *
  13274.  
  13275. In the following example, a typedef is used so that the simple name nested can 
  13276. be used in place of outside::middle::inside. 
  13277.  
  13278. *
  13279. ************************************************************************/
  13280.  
  13281. #include <iostream.h>
  13282.  
  13283. class outside {
  13284. public:
  13285.       class middle {
  13286.       public:
  13287.             class inside {
  13288.                   private:
  13289.                         int a;
  13290.                   public:
  13291.                         inside(int a_init = 0): a(a_init) {}
  13292.                         void printa();
  13293.             };
  13294.       };
  13295. };
  13296.  
  13297. typedef outside::middle::inside nested;
  13298.  
  13299. void nested::printa() {
  13300.       cout << "Here is a " << this->a << endl;
  13301.       }
  13302.  
  13303. void main() {
  13304.       nested n(9);
  13305.       n.printa();
  13306. }
  13307.  
  13308.  
  13309. ΓòÉΓòÉΓòÉ 10.1.3. Classes and Structures ΓòÉΓòÉΓòÉ
  13310.  
  13311. The C++ class is an extension of the C structure. Because the only difference 
  13312. between a structure and a class is that a structure has public access by 
  13313. default and a class has private access by default, you can use the keywords 
  13314. class or struct to define equivalent classes. For example, in the following 
  13315. code fragment, the class X is equivalent to the structure Y: 
  13316.  
  13317. class X
  13318. {
  13319. int a; // private by default
  13320. public:
  13321.       int f() { return a = 5; }; // public member function
  13322. };
  13323. struct Y
  13324. {
  13325. int f() { return a = 5; };       // public by default
  13326. private:
  13327.       int a; // private data member
  13328. };
  13329.  
  13330. If you define a structure and then declare an object of that structure using 
  13331. the keyword class, the members of the object are still public by default. 
  13332.  
  13333. Example of Access for Classes and Structures 
  13334.  
  13335. An aggregate class is a class that has no constructors, no private or protected 
  13336. members, no  base classes, and no virtual functions. 
  13337.  
  13338. Initialization of aggregate classes is described in Initializers. 
  13339.  
  13340. Related Information 
  13341.  
  13342. o Structures 
  13343. o Declaring Classes 
  13344. o Declaring Class Objects 
  13345. o Scope of Class Names 
  13346.  
  13347.  
  13348. ΓòÉΓòÉΓòÉ <hidden> Example of Access for Classes and Structures ΓòÉΓòÉΓòÉ
  13349.  
  13350. /************************************************************************
  13351. *
  13352.  
  13353. In the following example, main() has access to the members of X even though X 
  13354. is declared as using the keyword class: 
  13355.  
  13356.                                                                         *
  13357. ************************************************************************/
  13358.  
  13359. #include <iostream.h>
  13360.  
  13361. struct x {
  13362.       int a;
  13363.       int b;
  13364.       } ;
  13365.  
  13366. class x X;
  13367.  
  13368. void main() {
  13369.       X.a = 0;
  13370.       X.b = 1;
  13371.       cout << "Here are e and f " << X.a << " " << X.b << endl;
  13372.       }
  13373.  
  13374.  
  13375. ΓòÉΓòÉΓòÉ 10.2. Declaring Class Objects ΓòÉΓòÉΓòÉ
  13376.  
  13377. A class declaration creates a unique type class name.  You can use a class type 
  13378. to create instances or objects of that class type. For example, you can declare 
  13379. a class, structure, and union with class names X, Y, and Z respectively: 
  13380.  
  13381. class X {       /* definition of class X */ };
  13382. struct Y {      /* definition of struct Y */ };
  13383. union Z {       /* definition of union Z */ };
  13384.  
  13385. You can then declare objects of each of these class types. Remember that 
  13386. classes, structures, and unions are all types of C++ classes. 
  13387.  
  13388. void main()
  13389. {
  13390.       X xobj;      // declare a class object of class type X
  13391.       Y yobj;      // declare a struct object of class type Y
  13392.       Z zobj;      // declare a union object of class type Z
  13393. }
  13394.  
  13395. In C++, unlike C, you do not need to precede declarations of class objects with 
  13396. the keywords union, struct, and class unless the name of the class is hidden. 
  13397. For more information on hidden names, see Scope of Class Names. 
  13398.  
  13399. When you declare more than one class object in a declaration, the declarators 
  13400. are treated as if declared individually. For example, if you declare two 
  13401. objects of class S in a single declaration: 
  13402.  
  13403. class S { /* ... */ };
  13404. void main()
  13405. {
  13406.       S S,T; // declare two objects of class type S
  13407. }
  13408.  
  13409. this declaration is equivalent to: 
  13410.  
  13411. class S { /* ... */ };
  13412. void main()
  13413. {
  13414.       S S;
  13415.       class S T;       // keyword class is required
  13416.                        // since variable S hides class type S
  13417. }
  13418.  
  13419. but is not equivalent to: 
  13420.  
  13421. class S { /* ... */ };
  13422. void main()
  13423. {
  13424.       S S;
  13425.       S T;             // error, S class type is hidden
  13426. }
  13427.  
  13428. You can also declare references to classes, pointers to classes, and arrays of 
  13429. classes. 
  13430.  
  13431. Examples of Declaring Class Objects 
  13432.  
  13433. Objects of class types that are not copy restricted can be assigned, passed as 
  13434. arguments to functions, and returned by functions. For more information, see 
  13435. Copying Class Objects. 
  13436.  
  13437. Related Information 
  13438.  
  13439. o Objects 
  13440. o Scope of Class Names 
  13441. o Initialization by Constructor 
  13442. o Copying Class Objects 
  13443.  
  13444.  
  13445. ΓòÉΓòÉΓòÉ <hidden> Examples of Declaring Class Objects ΓòÉΓòÉΓòÉ
  13446.  
  13447. /************************************************************************
  13448. *
  13449.  
  13450. In C++, unlike C, you do not need to precede declarations of class objects with 
  13451. the keywords union, struct, and class unless the name of the class is hidden. 
  13452. For example: 
  13453.  
  13454.                                                                         *
  13455. ************************************************************************/
  13456.  
  13457. struct Y { /* ... */ };
  13458. class X { /* ... */ };
  13459. void main ()
  13460. {
  13461.       int X;             // hides the class name X
  13462.       Y yobj;            // valid
  13463.       X xobj;            // error, class name X is hidden
  13464.       class X xobj;      // valid
  13465. }
  13466.  
  13467. /************************************************************************
  13468. *
  13469.  
  13470. The following example declares a reference, a pointer, and an array: 
  13471.  
  13472.                                                                         *
  13473. ************************************************************************/
  13474.  
  13475. class X { /* ... */ };
  13476. struct Y { /* ... */ };
  13477. union Z { /* ... */ };
  13478. void main()
  13479. {
  13480.       X xobj;
  13481.       X &xref = xobj;           // reference to class object of type X
  13482.       Y *yptr;                  // pointer to struct object of type Y
  13483.       Z zarray[10];             // array of 10 union objects of type Z
  13484. }
  13485.  
  13486.  
  13487. ΓòÉΓòÉΓòÉ 10.3. Scope of Class Names ΓòÉΓòÉΓòÉ
  13488.  
  13489. A class declaration introduces the class name into the scope where it is 
  13490. declared. Any class, object, function or other declaration of that name in an 
  13491. enclosing scope is hidden. If a class name is declared in a scope where an 
  13492. object, function, or enumerator of the same name is also declared, you can only 
  13493. refer to the class by using the elaborated type specifier. The class key 
  13494. (class, struct, or union) must precede the class name to identify it. For 
  13495. example: 
  13496.  
  13497. class x { int a; };            // declare a class type class-name
  13498.  
  13499. x xobject;                     // declare object of class type x
  13500.  
  13501. int x(class x*)                // redefine x to be a function
  13502. {return 0;}                    // use class-key class to define
  13503.                                // a pointer to the class type x
  13504.                                // as the function argument
  13505.  
  13506. void main()
  13507. {
  13508.       class x* xptr;           // use class-key class to define
  13509.                                // a pointer to class type x
  13510.       xptr = &xobject;         // assign pointer
  13511.       x(xptr);                 // call function x with pointer to class x
  13512. }
  13513.  
  13514. An elaborated type specifier can be used in the declaration of objects and 
  13515. functions. See Class Names for an example. An elaborated type specifier can 
  13516. also be used in the incomplete declaration of a class type to reserve the name 
  13517. for a class type within the current scope. 
  13518.  
  13519. Related Information 
  13520.  
  13521. o Incomplete Class Declarations 
  13522. o Nested Classes 
  13523. o Local Classes 
  13524. o Local Type Names 
  13525. o Class Names 
  13526. o Declaring Class Objects 
  13527. o Declaring Classes 
  13528. o Scope in C 
  13529.  
  13530.  
  13531. ΓòÉΓòÉΓòÉ 10.3.1. Incomplete Class Declarations ΓòÉΓòÉΓòÉ
  13532.  
  13533. An incomplete class declaration is a class declaration that does not define any 
  13534. class members. You cannot declare any objects of the class type or refer to the 
  13535. members of a class until the declaration is complete. However, an incomplete 
  13536. declaration allows you to make specific references to a class prior to its 
  13537. definition as long as the size of the class is not required. 
  13538.  
  13539. For example, you can define a pointer to the structure first in the definition 
  13540. of the structure second. Structure first is declared in an incomplete class 
  13541. declaration prior to the definition of second, and the definition of oneptr in 
  13542. structure second does not require the size of first: 
  13543.  
  13544. struct first;           // incomplete declaration of struct first
  13545.  
  13546. struct second           // complete declaration of struct second
  13547. {
  13548.       first* oneptr;    // pointer to struct first refers to
  13549.                         // struct first prior to its complete
  13550.                         // declaration
  13551.  
  13552.       first one;        // error, you cannot declare an object of
  13553.                         // an incompletely declared class type
  13554.       int x, y;
  13555. };
  13556.  
  13557. struct first            // complete declaration of struct first
  13558. {
  13559.       second two;       // define an object of class type second
  13560.       int z;
  13561. };
  13562.  
  13563. If you declare a class with an empty member list, it is a complete class 
  13564. declaration. For example: 
  13565.  
  13566. class X;                // incomplete class declaration
  13567. class Z {};             // empty member list
  13568. class Y
  13569. {
  13570. public:
  13571.       X yobj;           // error, cannot create an object of an
  13572.                         // incomplete class type
  13573.       Z zobj;           // valid
  13574. };
  13575.  
  13576. Related Information 
  13577.  
  13578. o Declaring Classes 
  13579. o Declaring Class Objects 
  13580. o Class Member Lists 
  13581. o Scope of Class Names 
  13582.  
  13583.  
  13584. ΓòÉΓòÉΓòÉ 10.3.2. Nested Classes ΓòÉΓòÉΓòÉ
  13585.  
  13586. A nested class is declared within the scope of another class. The name of a 
  13587. nested class is local to its enclosing class.  Unless you use explicit 
  13588. pointers, references, or object names, declarations in a nested class can only 
  13589. use visible constructs, including type names, static members, and enumerators 
  13590. from the enclosing class and global variables. 
  13591.  
  13592. Member functions of a nested class follow regular access rules and have no 
  13593. special access privileges to members of their enclosing classes. Member 
  13594. functions of the enclosing class have no special access to members of a nested 
  13595. class. 
  13596.  
  13597. You can define member functions and static data members of a nested class in 
  13598. the global scope. For example, in the following code fragment, you can access 
  13599. the static members x and y and member functions f() and g() of the nested class 
  13600. nested by using a qualified type name. Qualified type names allow you to define 
  13601. a typedef to represent a qualified class name. You can then use the typedef 
  13602. with the :: (scope resolution) operator to refer to a nested class or class 
  13603. member, as shown in the following example: 
  13604.  
  13605. class outside
  13606. {
  13607. public:
  13608.       class nested
  13609.       {
  13610.       public:
  13611.             static int x;
  13612.             static int y;
  13613.             int f();
  13614.             int g();
  13615.       };
  13616. };
  13617. int outside::nested::x = 5;
  13618. int outside::nested::f() { return 0; };
  13619.  
  13620. typedef outside::nested outnest;       // define a typedef
  13621. int outnest::y = 10;                   // use typedef with ::
  13622. int outnest::g() { return 0; };
  13623. //      . . .
  13624.  
  13625. Related Information 
  13626.  
  13627. o Class Names 
  13628. o Declaring Class Objects 
  13629. o Scope of Class Names 
  13630.  
  13631.  
  13632. ΓòÉΓòÉΓòÉ 10.3.3. Local Classes ΓòÉΓòÉΓòÉ
  13633.  
  13634. A local class is declared within a function definition. The local class is in 
  13635. the scope of the enclosing function scope. Declarations in a local class can 
  13636. only use type names, enumerations, static variables from the enclosing scope, 
  13637. as well as external variables and functions. 
  13638.  
  13639. Examples of Local Classes 
  13640.  
  13641. Member functions of a local class have to be defined within their class 
  13642. definition. Member functions of a local class must be inline functions.  Like 
  13643. all member functions, those defined within the scope of a local class do not 
  13644. need the keyword inline. 
  13645.  
  13646. A local class cannot have static data members. In the following example, an 
  13647. attempt to define a static member of a local class causes an error: 
  13648.  
  13649. void f()
  13650. {
  13651.     class local
  13652.     {
  13653.        int f();              // error, local class has noninline
  13654.                              // member function
  13655.        int g() {return 0;}   // valid, inline member function
  13656.        static int a;         // error, static is not allowed for
  13657.                              // local class
  13658.        int b;                // valid, nonstatic variable
  13659.     };
  13660. }
  13661. //      . . .
  13662.  
  13663. An enclosing function has no special access to members of the local class. 
  13664.  
  13665. Related Information 
  13666.  
  13667. o Scope of Class Names 
  13668. o Function Scope 
  13669. o Inline Member Functions 
  13670. o Inline Specifiers 
  13671. o Local Type Names 
  13672.  
  13673.  
  13674. ΓòÉΓòÉΓòÉ <hidden> Examples of Local Classes ΓòÉΓòÉΓòÉ
  13675.  
  13676. /************************************************************************
  13677. *
  13678.  
  13679. The following example uses local classes. 
  13680.  
  13681.                                                                         *
  13682. ************************************************************************/
  13683.  
  13684. int x;                         // global variable
  13685. void f()                       // function definition
  13686. {
  13687.       static int y;            // static variable y can be used by
  13688.                                // local class
  13689.       int x;                   // auto variable x cannot be used by
  13690.                                // local class
  13691.       extern int g();          // extern function g can be used by
  13692.                                // local class
  13693.  
  13694.       class local              // local class
  13695.       {
  13696.             int g() { return x; }      // error, local variable x
  13697.                                        // cannot be used by g
  13698.             int h() { return y; }      // valid,static variable y
  13699.             int k() { return ::x; }    // valid, global x
  13700.             int l() { return g(); }    // valid, extern function g
  13701.       };
  13702. }
  13703.  
  13704. void main()
  13705. {
  13706.       local* z;                // error, local is undefined
  13707. //      .
  13708. //      .
  13709. //      .
  13710. }
  13711.  
  13712.  
  13713. ΓòÉΓòÉΓòÉ 10.3.4. Local Type Names ΓòÉΓòÉΓòÉ
  13714.  
  13715. Local type names follow the same scope rules as other names. Scope rules are 
  13716. described in Scope in C++. Type names defined within a class declaration have 
  13717. local scope and cannot be used outside their class without qualification. 
  13718.  
  13719. If you use a class name, typedef name, or a constant name that is used in a 
  13720. type name, in a class declaration, you cannot redefine that name after it is 
  13721. used in the class declaration. For example: 
  13722.  
  13723. void main ()
  13724. {
  13725.       typedef double db;
  13726.       struct st
  13727.       {
  13728.             db x;
  13729.             typedef int db; // error
  13730.             db y;
  13731.       };
  13732. }
  13733.  
  13734. The following declarations are valid: 
  13735.  
  13736. typedef float T;
  13737. class s {
  13738.       typedef int T;
  13739.       void f(const T);
  13740. };
  13741.  
  13742. Here, function f() takes an argument of type s::T. However, the following 
  13743. declarations, where the order of the members of s has been reversed, cause an 
  13744. error: 
  13745.  
  13746. typedef float T;
  13747. class s {
  13748.       void f(const T);
  13749.       typedef int T;
  13750. };
  13751.  
  13752. In a class declaration, you cannot redefine a name that is not a class name, or 
  13753. a typedef name to a class name or typedef name once you have used that name in 
  13754. the class declaration. 
  13755.  
  13756. Related Information 
  13757.  
  13758. o Scope in C 
  13759. o Declaring Classes 
  13760. o Declaring Class Objects 
  13761. o Scope of Class Names 
  13762. o Local Classes 
  13763. o typedef 
  13764.  
  13765.  
  13766. ΓòÉΓòÉΓòÉ 11. C++ Class Members and Friends ΓòÉΓòÉΓòÉ
  13767.  
  13768. This chapter describes class members and friends, including the following 
  13769. topics: 
  13770.  
  13771. o Class Member Lists 
  13772. o Data Members 
  13773. o Class-Type Class Members 
  13774. o Member Bit Fields 
  13775. o Member Functions 
  13776. o Member Scope 
  13777. o Pointers to Members 
  13778. o The this Pointer 
  13779. o Static Members 
  13780. o Member Access 
  13781. o Friends 
  13782.  
  13783. Related Information 
  13784.  
  13785. o C++ Classes 
  13786. o Inheritance 
  13787. o Special Member Functions 
  13788.  
  13789.  
  13790. ΓòÉΓòÉΓòÉ 11.1. Class Member Lists ΓòÉΓòÉΓòÉ
  13791.  
  13792. An optional member list declares objects called class members.  Class members 
  13793. can be data, functions, classes, enumeration, bit fields, and type names. A 
  13794. member list is the only place you can declare class members.  Friend 
  13795. declarations are not class members but must appear in member lists. 
  13796.  
  13797. The member list follows the class name and is placed between braces. It can 
  13798. contain access specifiers, member declarations, and member definitions. 
  13799.  
  13800. You can access members by using the class access . (dot) and -> (arrow) 
  13801. operators. 
  13802.  
  13803. An access specifier is one of public, private, or protected. 
  13804.  
  13805. A member declaration declares a class member for the class containing the 
  13806. declaration. For more information on declarations, see Declarations and 
  13807. Definitions, and Declaring Class Objects. 
  13808.  
  13809. A member declaration that is a qualified name followed by a ; (semicolon) is 
  13810. used to restore access to members of base classes and is described in Access 
  13811. Declarations. 
  13812.  
  13813. A member declarator declares an object, function, or type within a declaration. 
  13814. It cannot contain an initializer. You can initialize a member by using a 
  13815. constructor or, if the member belongs to an aggregate class, by using a brace 
  13816. initializer list (a list surrounded by braces { }) in the declarator list. You 
  13817. must explicitly initialize a class containing constant or reference members 
  13818. with a brace initializer list or explicitly with a constructor. 
  13819.  
  13820. A member declarator of the form: 
  13821.  
  13822.       [identifier] : constant-expression
  13823.  
  13824. specifies a bit field. 
  13825.  
  13826. A pure specifier (= 0) indicates that a function has no definition. A pure 
  13827. specifier is only used with virtual member functions. A pure specifier replaces 
  13828. the function definition of a member function in the member list. 
  13829.  
  13830. You can use the storage-class specifier static (but not extern, auto or 
  13831. register) in a member list. 
  13832.  
  13833. The order of mapping of class members in a member list is implementation 
  13834. dependent. For the C/C++ Tools compiler, class members are allocated in the 
  13835. order they are declared. For more information, see the IBM C/C++ Tools: 
  13836. Programming Guide. 
  13837.  
  13838. Related Information 
  13839.  
  13840. o Member Access 
  13841. o Dot Operator 
  13842. o Arrow Operator 
  13843. o Declaring Class Objects 
  13844. o Initializers 
  13845. o Access Declarations 
  13846. o Initialization by Constructor 
  13847. o Virtual Functions 
  13848. o Storage Class Specifiers 
  13849.  
  13850.  
  13851. ΓòÉΓòÉΓòÉ 11.2. Data Members ΓòÉΓòÉΓòÉ
  13852.  
  13853. Data members include members that are declared with any of the fundamental 
  13854. types, as well as other types, including pointer, reference, array types, and 
  13855. user-defined types. You can declare a data member the same way as a variable, 
  13856. except that explicit initializers are not allowed inside the class definition. 
  13857.  
  13858. If an array is declared as a nonstatic class member, you must specify all of 
  13859. the dimensions of the array. 
  13860.  
  13861. Related Information 
  13862.  
  13863. o Types 
  13864. o Class Member Lists 
  13865. o Class-Type Class Members 
  13866. o Member Bit Fields 
  13867. o Static Members 
  13868. o Member Access 
  13869.  
  13870.  
  13871. ΓòÉΓòÉΓòÉ 11.3. Class-Type Class Members ΓòÉΓòÉΓòÉ
  13872.  
  13873. A class can have members that are of a class type or are pointers or references 
  13874. to a class type. Members that are of a class type must be of a class type that 
  13875. is previously declared. An incomplete class type can be used in a member 
  13876. declaration as long as the size of the class is not needed. For example, a 
  13877. member can be declared that is a pointer to an incomplete class type. 
  13878.  
  13879. A class X cannot have a member that is of type X, but it can contain pointers 
  13880. to X, references to X, and static objects of X. Member functions of X can take 
  13881. arguments of type X and have a return type of X. For example: 
  13882.  
  13883. class X
  13884. {
  13885.       X();
  13886.       X *xptr;
  13887.       X &xref;
  13888.       static X xcount;
  13889.       X xfunc(X);
  13890. };
  13891.  
  13892. The bodies of member functions are always processed after the definition of 
  13893. their class is complete. The body of a member function can use the enclosing 
  13894. class. Consider the following example: 
  13895.  
  13896. class Y
  13897. {
  13898. public:
  13899.       int a;
  13900.       Y ();
  13901. private:
  13902.       int f() {return sizeof(Y);};
  13903.       void g(Y yobj);
  13904.       Y h(int a);
  13905. };
  13906.  
  13907. In this example, the inline function f() uses the size of class Y. 
  13908.  
  13909. Related Information 
  13910.  
  13911. o Incomplete Class Declarations 
  13912. o Member Functions 
  13913. o Inline Member Functions 
  13914. o C++ Classes 
  13915. o Class Member Lists 
  13916.  
  13917.  
  13918. ΓòÉΓòÉΓòÉ 11.4. Member Bit Fields ΓòÉΓòÉΓòÉ
  13919.  
  13920. A class can contain packed data known as bit fields. You can use bit fields for 
  13921. data that requires just a few bits of storage. The syntax for a bit field is: 
  13922.  
  13923.       [identifier] : constant-expression
  13924.  
  13925. The constant expression specifies how many bits the field reserves. A bit field 
  13926. that is defined as having a length of zero causes the next field to be aligned 
  13927. on the next integer boundary. Bit fields with a length of zero must be unnamed. 
  13928.  
  13929. Unlike ANSI C, bit fields can be any integral type or enumeration type. When 
  13930. you assign a value that is out of range to a bit field, the low-order bit 
  13931. pattern is preserved and the appropriate bits are assigned. 
  13932.  
  13933. The following restrictions apply to member bit fields. You cannot: 
  13934.  
  13935. o Have a reference to a bit field 
  13936. o Define an array of bit fields 
  13937. o Take the address of a bit field 
  13938.  
  13939. The maximum bit field length is implementation dependent. For the C/C++ Tools 
  13940. compiler, it is 32 bits. For more information, see the IBM C/C++ Tools: 
  13941. Programming Guide. 
  13942.  
  13943. Related Information 
  13944.  
  13945. o Class Member Lists 
  13946.  
  13947.  
  13948. ΓòÉΓòÉΓòÉ 11.5. Member Functions ΓòÉΓòÉΓòÉ
  13949.  
  13950. Member functions are operators and functions that are declared as members of a 
  13951. class. Member functions do not include operators and functions declared with 
  13952. the friend specifier. These are called friends of a class. 
  13953.  
  13954. The definition of a member function is within the scope of its enclosing class. 
  13955. The body of a member function is analyzed after the class declaration so that 
  13956. members of that class can be used in the member function body. When the 
  13957. function add() is called in the following example, the data variables a, b, and 
  13958. c can be used in the body of add(). 
  13959.  
  13960. class x
  13961. {
  13962. public:
  13963.       int add()             // inline member function add
  13964.       {return a+b+c;};
  13965. private:
  13966.       int a,b,c;
  13967. };
  13968.  
  13969. There are a number of types of member functions: 
  13970.  
  13971. o const and volatile member functions 
  13972. o Virtual member functions 
  13973. o Special member functions 
  13974. o Inline member functions 
  13975. o Member function templates 
  13976.  
  13977. Related Information 
  13978.  
  13979. o Member Scope 
  13980. o Static Member Functions 
  13981. o Functions 
  13982. o Class Member Lists 
  13983.  
  13984.  
  13985. ΓòÉΓòÉΓòÉ <hidden> const and volatile Member Functions ΓòÉΓòÉΓòÉ
  13986.  
  13987. A member function declared with the const qualifier can be called for constant 
  13988. and nonconstant objects. A nonconstant member function can only be called for a 
  13989. nonconstant object. Similarly, a member function declared with the volatile 
  13990. qualifier can be called for volatile and nonvolatile objects. A nonvolatile 
  13991. member function can only be called for a nonvolatile object. 
  13992.  
  13993.  
  13994. ΓòÉΓòÉΓòÉ <hidden> Virtual Member Functions ΓòÉΓòÉΓòÉ
  13995.  
  13996. Virtual member functions are declared with the keyword virtual. They allow 
  13997. dynamic binding of member functions. Because all virtual functions must be 
  13998. member functions, virtual member functions are simply called virtual functions. 
  13999.  
  14000. If the definition of a virtual function is replaced by a pure specifier in the 
  14001. declaration of the function, the function is said to be declared pure. A class 
  14002. that has at least one pure virtual function is called an abstract class. 
  14003.  
  14004.  
  14005. ΓòÉΓòÉΓòÉ <hidden> Special Member Functions ΓòÉΓòÉΓòÉ
  14006.  
  14007. Special member functions are used to create, destroy, initialize, convert, and 
  14008. copy class objects. These include: 
  14009.  
  14010. o Constructors 
  14011. o Destructors 
  14012. o Conversion constructors 
  14013. o Conversion functions 
  14014. o Copy constructors 
  14015.  
  14016.  
  14017. ΓòÉΓòÉΓòÉ <hidden> Inline Member Functions ΓòÉΓòÉΓòÉ
  14018.  
  14019. A member function that is both declared and defined in the class member list is 
  14020. called an inline member function. Member functions containing a few lines of 
  14021. code are usually declared inline. 
  14022.  
  14023. An equivalent way to declare an inline member function is to declare it outside 
  14024. of the class declaration using the keyword inline and the :: (scope resolution) 
  14025. operator to identify the class the member function belongs to. For example: 
  14026.  
  14027. class Y
  14028. {
  14029.       char* a;
  14030. public:
  14031.       char* f() {return a;};
  14032. };
  14033.  
  14034. is equivalent to: 
  14035.  
  14036. class Z
  14037. {
  14038.       char* a;
  14039. public:
  14040.       char* f();
  14041. };
  14042. inline char* Z::f() {return a;}
  14043.  
  14044. When you declare an inline function without the inline keyword and do not 
  14045. define it in the class member list, you cannot call the function before you 
  14046. define it. In the above example you could not call f() until after its 
  14047. definition. 
  14048.  
  14049. Inline member functions have internal linkage. Noninline member functions have 
  14050. external linkage. 
  14051.  
  14052. For more information, see Inline Functions. 
  14053.  
  14054.  
  14055. ΓòÉΓòÉΓòÉ <hidden> Member Function Templates ΓòÉΓòÉΓòÉ
  14056.  
  14057. Any member function (inlined or noninlined) declared within a class template is 
  14058. implicitly a function template. When a template class is declared, it 
  14059. implicitly generates template functions for each function defined in the class 
  14060. template. 
  14061.  
  14062. For more information, see Member Function Templates. 
  14063.  
  14064.  
  14065. ΓòÉΓòÉΓòÉ 11.6. Member Scope ΓòÉΓòÉΓòÉ
  14066.  
  14067. Member functions and static members can be defined outside their class 
  14068. declaration if they have already been declared, but not defined, in the class 
  14069. member list. Nonstatic data members are defined when their class is 
  14070. instantiated. The declaration of a static data member is not a definition. The 
  14071. declaration of a member function is a definition if the body of the function is 
  14072. also given. 
  14073.  
  14074. Whenever the definition of a class member appears outside of the class 
  14075. declaration, the member name must be qualified by the class name using the :: 
  14076. (scope resolution) operator. 
  14077.  
  14078. Example of Defining a Member outside of the Class 
  14079.  
  14080. All member functions are in class scope even if they are defined outside their 
  14081. class declaration. 
  14082.  
  14083. The name of a class member is local to its class. Unless you use one of the 
  14084. class access operators, . (dot), or -> (arrow), or :: (scope resolution) 
  14085. operator, you can only use a class member in a member function of its class and 
  14086. in nested classes. You can only use types, enumerations and static members in a 
  14087. nested class without qualification with the :: operator. 
  14088.  
  14089. The order of search for a name in a member function body is: 
  14090.  
  14091.  1. Within the member function body itself 
  14092.  2. Within all the enclosing classes, including inherited members of those 
  14093.     classes 
  14094.  3. Within the lexical scope of the body declaration 
  14095.  
  14096. Example of Member Function Search Path 
  14097.  
  14098. Note:  When the containing classes are being searched, only the definitions of 
  14099. the containing classes and their base classes are searched. The scope 
  14100. containing the base class definitions (global scope, in this example) is not 
  14101. searched. 
  14102.  
  14103. Related Information 
  14104.  
  14105. o Scope in C++ 
  14106. o Scope Resolution Operator 
  14107. o Member Functions 
  14108. o Dot Operator 
  14109. o Arrow Operator 
  14110. o Member Access 
  14111.  
  14112.  
  14113. ΓòÉΓòÉΓòÉ <hidden> Example of Defining a Member ΓòÉΓòÉΓòÉ
  14114.  
  14115. /************************************************************************
  14116. *
  14117.  
  14118. The following example defines a member function outside of its class 
  14119. declaration. 
  14120.  
  14121.                                                                         *
  14122. ************************************************************************/
  14123.  
  14124. #include <iostream.h>
  14125. class X
  14126. {
  14127. public:
  14128.       int a, b ;      // public data members
  14129.       int add();      // member function declaration only
  14130. };
  14131. int a  = 10;          // global variable
  14132. // define member function outside its class declaration
  14133. int X::add() {return a + b;};
  14134. //      .
  14135. //      .
  14136. //      .
  14137. void main()
  14138. {
  14139.     int answer;
  14140.     X xobject;
  14141.     xobject.a = 1;
  14142.     xobject.b = 2;
  14143.     answer = xobject.add();
  14144.     cout << xobject.a << " + " << xobject.b << " = " << answer;
  14145. }
  14146.  
  14147. /************************************************************************
  14148. *
  14149.  
  14150. The output for this example is: 1 + 2 = 3 
  14151.  
  14152. Note:  All member functions are in class scope even if they are defined outside 
  14153. their class declaration. In the above example, the member function add() 
  14154. returns the data member a, not the global variable a. 
  14155.  
  14156.                                                                         *
  14157. ************************************************************************/
  14158.  
  14159.  
  14160. ΓòÉΓòÉΓòÉ <hidden> Example of Member Function Search Path ΓòÉΓòÉΓòÉ
  14161.  
  14162. /************************************************************************
  14163. *
  14164.  
  14165. The search of the enclosing classes, including inherited members, is 
  14166. demonstrated in the following example: 
  14167.  
  14168.                                                                         *
  14169. ************************************************************************/
  14170.  
  14171. class A { /* ... */ };
  14172. class B { /* ... */ };
  14173. class C { /* ... */ };
  14174. class Z : A {
  14175.       class Y : B {
  14176.             class X : C { int f(); /* ... */ };
  14177.       };
  14178. };
  14179. int Z::Y::X f()
  14180. {
  14181.    // ...
  14182.       j();
  14183.    // ...
  14184. }
  14185.  
  14186. /************************************************************************
  14187. *
  14188.  
  14189. In this example, the search for the name j in the definition of the function f 
  14190. follows this order: 
  14191.  
  14192.  1. In the body of the function f 
  14193.  2. In X and in its base class C 
  14194.  3. In Y and in its base class B 
  14195.  4. In Z and in its base class A 
  14196.  5. In the lexical scope of the body of f. In this case, this is global scope. 
  14197.  
  14198.                                                                         *
  14199. ************************************************************************/
  14200.  
  14201.  
  14202. ΓòÉΓòÉΓòÉ 11.7. Pointers to Members ΓòÉΓòÉΓòÉ
  14203.  
  14204. Pointers to members allow you to refer to nonstatic members of class objects. 
  14205. You cannot use a pointer to member to point to a static class member because 
  14206. the address of a static member is not associated with any particular object. To 
  14207. point to a static class member, you must use a normal pointer. 
  14208.  
  14209. You can use pointers to member functions in the same manner as pointers to 
  14210. functions. You can compare pointers to member functions, assign values to them, 
  14211. and use them to call member functions. Note that a member function does not 
  14212. have the same type as a nonmember function that has the same number and type of 
  14213. arguments and the same return type. 
  14214.  
  14215. Example of Pointers to Members 
  14216.  
  14217. To reduce complex syntax, you can declare a typedef to be a pointer to a 
  14218. member. A pointer to a member can be declared and used as shown in the 
  14219. following code fragment: 
  14220.  
  14221. typedef void (X::*ptfptr) (int);      // declare typedef
  14222. void main ()
  14223. {
  14224. // ...
  14225. ptfptr ptf = &X::f;                   // use typedef
  14226. X xobject;
  14227. (xobject.*ptf) (20);                  // call function
  14228. }
  14229.  
  14230. The pointer to member operators .* and ->* are used to bind a pointer to a 
  14231. member of a specific class object. Because the precedence of () (function call 
  14232. operator) is higher than .* and ->*, you must use parentheses to call the 
  14233. function pointed to by ptf. 
  14234.  
  14235. Related Information 
  14236.  
  14237. o Pointer to Member Operators  .*  ->* 
  14238. o Pointers 
  14239. o Static Members 
  14240. o The this Pointer 
  14241.  
  14242.  
  14243. ΓòÉΓòÉΓòÉ <hidden> Example of Pointers to Members ΓòÉΓòÉΓòÉ
  14244.  
  14245. /************************************************************************
  14246. *
  14247.  
  14248. Pointers to members can be declared and used as shown in the following example: 
  14249.  
  14250.                                                                         *
  14251. ************************************************************************/
  14252.  
  14253. #include <iostream.h>
  14254. class X
  14255. {
  14256. public:
  14257.       int a;
  14258.       void f(int b)
  14259.       {
  14260.              cout << "The value of b is "<< b << endl;
  14261.       }
  14262. };
  14263. //      .
  14264. //      .
  14265. //      .
  14266. void main ()
  14267. {
  14268.       // declare pointer to data member
  14269.       int X::*ptiptr = &X::a;
  14270.  
  14271.       // declare a pointer to member function
  14272.       void (X::* ptfptr) (int) = &X::f;
  14273.  
  14274.       X xobject;                  // create an object of class type X
  14275.       xobject.*ptiptr = 10;       // initialize data member
  14276.  
  14277.       cout << "The value of a is " << xobject.*ptiptr << endl;
  14278.       (xobject.*ptfptr) (20);     // call member function
  14279. }
  14280.  
  14281. /************************************************************************
  14282. *
  14283.  
  14284. The output for this example is: 
  14285.  
  14286. The value of a is 10
  14287. The value of b is 20
  14288.  
  14289.                                                                         *
  14290. ************************************************************************/
  14291.  
  14292.  
  14293. ΓòÉΓòÉΓòÉ 11.8. The this Pointer ΓòÉΓòÉΓòÉ
  14294.  
  14295. The keyword this identifies a special type of pointer. When a nonstatic member 
  14296. function is called, the this pointer identifies the class object which the 
  14297. member function is operating on. You cannot declare the this pointer or make 
  14298. assignments to it. 
  14299.  
  14300. The type of the this pointer for a member function of a class type X, is X* 
  14301. const. If the member function is declared with the constant qualifier, the type 
  14302. of the this pointer for that member function for class X, is const X* const. If 
  14303. the member function is declared with the volatile qualifier, the type of the 
  14304. this pointer for that member function for class X is volatile X* const. 
  14305.  
  14306. this is passed as a hidden argument to all nonstatic member function calls and 
  14307. is available as a local variable within the body of all nonstatic functions. 
  14308.  
  14309. For example, you can refer to the particular class object that a member 
  14310. function is called for by using the this pointer in the body of the member 
  14311. function. The following code example produces the output a =  5: 
  14312.  
  14313. #include <iostream.h>
  14314. class X
  14315. {
  14316.       int a;
  14317. public:
  14318.       // The 'this' pointer is used to retrieve 'xobj.a' hidden by
  14319.       // the automatic variable 'a'
  14320.       void Set_a(int a) { this->a = a; }
  14321.       void Print_a() { cout << "a = " << a << endl; }
  14322. };
  14323. void main()
  14324. {
  14325.       X xobj;
  14326.       int a = 5;
  14327.       xobj.Set_a(a);
  14328.       xobj.Print_a();
  14329. }
  14330.  
  14331. Unless a class member name is hidden, using the class member name is equivalent 
  14332. to using the class member name qualified with the this pointer. 
  14333.  
  14334. Example of the this Pointer 
  14335.  
  14336. Related Information 
  14337.  
  14338. o Pointers 
  14339. o Member Functions 
  14340. o Pointers to Members 
  14341. o C++ Classes 
  14342.  
  14343.  
  14344. ΓòÉΓòÉΓòÉ <hidden> Example of the this Pointer ΓòÉΓòÉΓòÉ
  14345.  
  14346. /************************************************************************
  14347. *
  14348.  
  14349. The following example shows code using class members without the this pointer. 
  14350. The comments on each line show the equivalent code with the hidden use of the 
  14351. this pointer. 
  14352.  
  14353.                                                                         *
  14354. ************************************************************************/
  14355.  
  14356. #include <string.h>
  14357. #include <iostream.h>
  14358. class X
  14359. {
  14360.       int len;
  14361.        char *ptr;
  14362. public:
  14363.       int GetLen()          // int GetLen (X* const this)
  14364.       { return len; }       // { return this->len;
  14365. }
  14366.       char * GetPtr()       // char * GetPtr (X* const this)
  14367.       { return ptr; }       // { return this->ptr;
  14368. }
  14369.       X& Set(char *);
  14370.       X& Cat(char *);
  14371.       X& Copy(X&);
  14372.       void Print();
  14373. };
  14374.  
  14375. X& X::Set(char *pc)         // X& X::Set(X* const this, char *pc)
  14376. {
  14377.       len = strlen(pc);     // this->len = strlen(pc);
  14378.       ptr = new char[len];  // this->ptr =
  14379.                             //   new char[this->len];
  14380.       strcpy(ptr, pc);      // strcpy(this->ptr, pc);
  14381.       return *this;
  14382. }
  14383.  
  14384. X& X::Cat(char *pc)         // X& X::Cat(X* const this, char *pc)
  14385. {
  14386.       len += strlen(pc);    // this->len += strlen(pc);
  14387.       strcat(ptr,pc);       // strcat(this->ptr,pc);
  14388.       return *this;
  14389. }
  14390.  
  14391. X& X::Copy(X& x)            // X& X::Copy(X* const this, X& x)
  14392. {
  14393.       Set(x.GetPtr());      // this->Set(x.GetPtr(&x));
  14394.       return *this;
  14395. }
  14396.  
  14397. void X::Print()             // void X::Print(X* const this)
  14398. {
  14399.       cout << ptr << endl;  // cout << this->ptr << endl;
  14400. }
  14401. void main()
  14402. {
  14403.       X xobj1;
  14404.       xobj1.Set("abcd").Cat("efgh");
  14405.       // xobj1.Set(&xobj1, "abcd").Cat(&xobj1, "efgh");
  14406.  
  14407.       xobj1.Print();        // xobj1.Print(&xobj1);
  14408.       X xobj2;
  14409.       xobj2.Copy(xobj1).Cat("ijkl");
  14410.       // xobj2.Copy(&xobj2, xobj1).Cat(&xobj2, "ijkl");
  14411.  
  14412.       xobj2.Print();        // xobj2.Print(&xobj2);
  14413. }
  14414.  
  14415. /************************************************************************
  14416. *
  14417.  
  14418. The above example produces the following output: 
  14419.  
  14420. abcdefgh
  14421. abcdefghijkl
  14422.  
  14423.                                                                         *
  14424. ************************************************************************/
  14425.  
  14426.  
  14427. ΓòÉΓòÉΓòÉ 11.9. Static Members ΓòÉΓòÉΓòÉ
  14428.  
  14429. Class members can be declared using the storage-class specifier static in the 
  14430. class member list. There is only one copy of the static member that is shared 
  14431. by all objects of a class in a program. When you declare an object of a class 
  14432. having a static member, the static member is not part of the class object. 
  14433.  
  14434. A typical use of static members is for recording data common to all objects of 
  14435. a class. For example, you can use a static data member as a counter to store 
  14436. the number of objects of a particular class type that are created. Each time a 
  14437. new object is created, this static data member can be incremented to keep track 
  14438. of the total number of objects. 
  14439.  
  14440. The declaration of a static member in the member list of a class is not a 
  14441. definition. The definition of a static member is equivalent to an external 
  14442. variable definition. You must define the static member outside of the class 
  14443. declaration. For example: 
  14444.  
  14445. class X
  14446. {
  14447. public:
  14448.       static int i;
  14449. }
  14450. int X::i = 0; // definition outside class declaration
  14451. //      .
  14452. //      .
  14453. //      .
  14454.  
  14455. A static member can be accessed from outside of its class only if it is 
  14456. declared with the keyword public. You can then access the static member by 
  14457. qualifying the class name using the :: (scope resolution) operator. In the 
  14458. following example: 
  14459.  
  14460. class X
  14461. {
  14462. public:
  14463.       static int f();
  14464. };
  14465. void main ()
  14466. {
  14467.       X::f();
  14468. }
  14469.  
  14470. you can refer to the static member f() of class type X as X::f(). 
  14471.  
  14472. Related Information 
  14473.  
  14474. o static Storage Class Specifier 
  14475. o Using the Class Access Operators with Static Members 
  14476. o Static Data Members 
  14477. o Static Member Functions 
  14478.  
  14479.  
  14480. ΓòÉΓòÉΓòÉ 11.9.1. Using the Class Access Operators with Static Members ΓòÉΓòÉΓòÉ
  14481.  
  14482. You can also access a static member from a class object by using the class 
  14483. access operators . (dot) and -> (arrow). When a static member is accessed 
  14484. through a class access operator, the expression on the left of the . or -> 
  14485. operator is not evaluated. 
  14486.  
  14487. Example of Accessing Static Members 
  14488.  
  14489. A static member can be referred to independently of any association with a 
  14490. class object because there is only one static member shared by all objects of a 
  14491. class. A static member can exist even if no objects of its class have been 
  14492. declared. 
  14493.  
  14494. When you access a static member, the expression that you use to access it is 
  14495. not evaluated. In the following example, the external function f() returns 
  14496. class type X. The function f() can be used to access the static member i of 
  14497. class X. The function f() itself is not called. 
  14498.  
  14499. class X
  14500. {
  14501. public:
  14502.       static int i;
  14503. };
  14504. int X::i = 10;
  14505. X f() { /* ... */ }
  14506. void main ()
  14507. {
  14508.       int a;
  14509.       a = f().i;       // f().i does not call f()
  14510. }
  14511.  
  14512. Related Information 
  14513.  
  14514. o Static Members 
  14515. o Dot Operator 
  14516. o Arrow Operator 
  14517. o Static Data Members 
  14518. o Static Member Functions 
  14519.  
  14520.  
  14521. ΓòÉΓòÉΓòÉ <hidden> Example of Accessing Static Members ΓòÉΓòÉΓòÉ
  14522.  
  14523. /************************************************************************
  14524. *
  14525.  
  14526. The following example uses the class access operators to access static members. 
  14527.  
  14528.                                                                         *
  14529. ************************************************************************/
  14530.  
  14531. #include <iostream.h>
  14532. class X
  14533. {
  14534.       static int cnt;
  14535. public:
  14536.       // The following routines all set X's static variable cnt
  14537.       // and print its value.
  14538.       void Set_Show (int i)
  14539.       {      X::cnt = i;
  14540.          cout << "X::cnt = " << X::cnt << endl; }
  14541.       void Set_Show (int i, int j )
  14542.       {       this->cnt = i+j;
  14543.          cout << "X::cnt = " << X::cnt << endl; }
  14544.       void Set_Show (X& x, int i)
  14545.       {       x.cnt = i;
  14546.          cout << "X::cnt = " << X::cnt << endl; }
  14547. };
  14548. int X::cnt;
  14549. void main()
  14550. {
  14551.       X xobj1, xobj2;
  14552.       xobj1.Set_Show(11);
  14553.       xobj1.Set_Show(11,22);
  14554.       xobj1.Set_Show(xobj2, 44);
  14555. }
  14556.  
  14557. /************************************************************************
  14558. *
  14559.  
  14560. The above example produces the following output: 
  14561.  
  14562. X::cnt = 11
  14563. X::cnt = 33
  14564. X::cnt = 44
  14565.  
  14566.                                                                         *
  14567. ************************************************************************/
  14568.  
  14569.  
  14570. ΓòÉΓòÉΓòÉ 11.9.2. Static Data Members ΓòÉΓòÉΓòÉ
  14571.  
  14572. Static data members of global classes have external linkage and can be 
  14573. initialized in file scope like other global objects. Static data members follow 
  14574. the usual class access rules, except that they can be initialized in file 
  14575. scope. Static data members and their initializers can access other static 
  14576. private and protected members of their class. The initializer for a static data 
  14577. member is in the scope of the class declaring the member. 
  14578.  
  14579. The following example shows how you can initialize static members using other 
  14580. static members, even though these members are private: 
  14581.  
  14582. class C {
  14583.       static int i;
  14584.       static int j;
  14585.       static int k;
  14586.       static int l;
  14587.       static int m;
  14588.       static int n;
  14589.       static int p;
  14590.       static int q;
  14591.       static int r;
  14592.       static int f() { return 0; }
  14593.       int a;
  14594.       C() { a = 0; }
  14595.       };
  14596. C c;
  14597. int C::i = C::f();    // initialize with static member function
  14598. int C::j = C::i;      // initialize with another static data member
  14599. int C::k = c.f();     // initialize with member function from an object
  14600. int C::l = c.j;       // initialize with data member from an object
  14601. int C::s = c.a;       // initialize with nonstatic data member
  14602. int C::r = 1;         // initialize with a constant value
  14603.  
  14604. class Y : private C {} y;
  14605.  
  14606. int C::m = Y::f();
  14607. int C::n = Y::r;
  14608. int C::p = y.r;       // error
  14609. int C::q = y.f();     // error
  14610.  
  14611. The initializations of C::p and C::q cause errors because y is an object of a 
  14612. class that is derived privately from C, and thus its members are not accessible 
  14613. to members of C. 
  14614.  
  14615. You can only have one definition of a static member in a program. If a static 
  14616. data member is not initialized, it is assigned a zero default value. Local 
  14617. classes cannot have static data members. 
  14618.  
  14619. Example of Static Data Members 
  14620.  
  14621. Related Information 
  14622.  
  14623. o Static Member Functions 
  14624. o Static Members 
  14625. o Using the Class Access Operators with Static Members 
  14626. o External Linkage 
  14627. o Member Access 
  14628. o Local Classes 
  14629.  
  14630.  
  14631. ΓòÉΓòÉΓòÉ <hidden> Example of Static Data Members ΓòÉΓòÉΓòÉ
  14632.  
  14633. /************************************************************************
  14634. *
  14635.  
  14636. The following example shows the declaration, initialization, use, and scope of 
  14637. the static data member si and static member functions Set_si(int) and 
  14638. Print_si(). 
  14639.  
  14640.                                                                         *
  14641. ************************************************************************/
  14642.  
  14643. #include <iostream.h>
  14644. class X
  14645. {
  14646.       int i;
  14647.       static int si;
  14648. public:
  14649.       void Set_i(int i) { this->i = i; }
  14650.       void Print_i() { cout << "i = " << i << endl; }
  14651.       // Equivalent to:
  14652.       // void Print_i(X* this)
  14653.       // { cout << "X::i = " << this->i << endl; }
  14654.       static void Set_si(int si) { X::si = si; }
  14655.  
  14656.       static void Print_si()
  14657.       {
  14658.             cout << "X::si = " << X::si << endl;
  14659.       }
  14660.       // Print_si doesn't have a 'this' pointer
  14661. };
  14662. int X::si = 77;       // Initialize static data member
  14663. void main()
  14664. {
  14665.       X xobj;
  14666.       // Non-static data members and functions belong to specific
  14667.       // instances (here xobj) of class X
  14668.       xobj.Set_i(11);
  14669.       xobj.Print_i();
  14670.  
  14671.       // static data members and functions belong to the class and
  14672.       // can be accessed without using an instance of class X
  14673.       X::Print_si();
  14674.       X::Set_si(22);
  14675.       X::Print_si();
  14676. }
  14677.  
  14678. /************************************************************************
  14679. *
  14680.  
  14681. The above example produces the following output: 
  14682.  
  14683. i = 11
  14684. X::si = 77
  14685. X::si = 22
  14686.  
  14687.                                                                         *
  14688. ************************************************************************/
  14689.  
  14690.  
  14691. ΓòÉΓòÉΓòÉ 11.9.3. Static Member Functions ΓòÉΓòÉΓòÉ
  14692.  
  14693. You cannot have static and nonstatic member functions with the same names and 
  14694. the same number and type of arguments. 
  14695.  
  14696. A static member function does not have a this pointer. You can call a static 
  14697. member function using the this pointer of a nonstatic member function. In the 
  14698. following example, the nonstatic member function printall() calls the static 
  14699. member function f() using the this pointer: 
  14700.  
  14701. #include <iostream.h>
  14702. class c {
  14703.             static void f() { cout << "Here is i"
  14704.                                         << i << endl;&rbr c.
  14705.             static int i;
  14706.             int j;
  14707.       public:
  14708.             c(int firstj): j(firstj) {}
  14709.             void printall();
  14710.             };
  14711. void c::printall() {
  14712.       cout << "Here is j " << this->j << endl;
  14713.       this->f();
  14714.       }
  14715. int c::i = 3;
  14716. void main() {
  14717.       class c C(0);
  14718.       C.printall();
  14719.       }
  14720.  
  14721. A static member function cannot be declared with the keyword virtual. 
  14722.  
  14723. A static member function can access only the names of static members, 
  14724. enumerators, and nested types of the class in which it is declared. 
  14725.  
  14726. Related Information 
  14727.  
  14728. o Member Functions 
  14729. o Using the Class Access Operators with Static Members 
  14730. o Static Data Members 
  14731. o Static Members 
  14732. o The this Pointer 
  14733. o Virtual Functions 
  14734.  
  14735.  
  14736. ΓòÉΓòÉΓòÉ 11.10. Member Access ΓòÉΓòÉΓòÉ
  14737.  
  14738. Member access determines if a class member is accessible in an expression or 
  14739. declaration. Note that accessibility and visibility are independent. Visibility 
  14740. is based on the scoping rules of C++. A class member can be visible and 
  14741. inaccessible at the same time. This section describes how you control the 
  14742. access to the individual nonderived class members by using access specifiers 
  14743. when you declare class members in a member list. 
  14744.  
  14745. The access specifiers are:  public, private, and protected. The three access 
  14746. specifiers have the following effect: 
  14747.  
  14748. o public class members can be accessed by any function, file or class. 
  14749.  
  14750. o private class members can be accessed only by member functions and friends of 
  14751.   the class in which the member is declared. 
  14752.  
  14753. o protected class members can be accessed only by member functions and friends 
  14754.   of the class in which they are declared and by member functions and friends 
  14755.   of classes derived from the class in which the protected members are 
  14756.   declared. The access specifier protected can be used for nonbase class 
  14757.   members, but it is equivalent to private unless it is used in a base class 
  14758.   member declaration or in a base list. 
  14759.  
  14760. The default access for an individual class member depends on the class key used 
  14761. in the class declaration. Members of classes declared with the keyword class 
  14762. are private by default. Members of classes declared with the keyword struct or 
  14763. union are public by default. 
  14764.  
  14765. The access specifier protected is meaningful only in the context of derivation. 
  14766. You can control the access to inherited members (that is, base class members) 
  14767. by including access specifiers in the base list of the derived class 
  14768. declaration. You can also restore the access to an inherited member from a 
  14769. derived class by using an access declaration. 
  14770.  
  14771. Access for inherited members is described in Inherited Member Access. 
  14772.  
  14773. Member lists can include access specifiers as labels. Members declared after 
  14774. these labels have access as specified by the label they follow. An access 
  14775. specifier determines the access for members until another access specifier is 
  14776. used or until the end of the class declaration. You can use any number of 
  14777. access specifiers in any order. 
  14778.  
  14779. Examples of Access Specifiers 
  14780.  
  14781. Related Information 
  14782.  
  14783. o Access Declarations 
  14784. o Inherited Member Access 
  14785. o Class Member Lists 
  14786. o Inherited Member Access 
  14787.  
  14788.  
  14789. ΓòÉΓòÉΓòÉ <hidden> Examples of Access Specifiers ΓòÉΓòÉΓòÉ
  14790.  
  14791. /************************************************************************
  14792. *
  14793. The following example shows access specifiers in member lists. 
  14794.  
  14795.                                                                         *
  14796. ************************************************************************/
  14797.  
  14798. class X
  14799. {
  14800.       int a;             // private data by default
  14801. public:
  14802.       void f(int);       // public function
  14803.       int b;             // public data
  14804. private:
  14805.       int c;             // private data
  14806. protected:
  14807.       void g(int);       // protected function
  14808. };
  14809. struct Y
  14810. {
  14811.       int a;             // public data by default
  14812. public:
  14813.       int b;             // public data
  14814. private:
  14815.       void g(int);       // private function
  14816.       int c;             // private data
  14817. };
  14818.  
  14819.  
  14820. ΓòÉΓòÉΓòÉ 11.11. Friends ΓòÉΓòÉΓòÉ
  14821.  
  14822. A friend of a class X is a function or class that is granted the same access to 
  14823. X as the members of X. Functions declared with the friend specifier in a class 
  14824. member list are called friend functions of that class. Classes declared with 
  14825. the friend specifier in the member list of another class are called friend 
  14826. classes of that class. 
  14827.  
  14828. A class Y must be defined before any member of Y can be declared a friend of 
  14829. another class. 
  14830.  
  14831. You can declare an entire class as a friend. If the class has not been 
  14832. previously declared, use an elaborated type specifier and a qualified type 
  14833. specifier to specify the class name. 
  14834.  
  14835. If the friend class has been previously declared, you can omit the keyword 
  14836. class, as shown in the following example: 
  14837.  
  14838. class F;
  14839. class X
  14840. {
  14841. public:
  14842.  
  14843.       X() {a=1; b=2;}
  14844. private:
  14845.       int a, b;
  14846.       friend F; // elaborated-type-specifier not required
  14847. };
  14848.  
  14849. Examples of Friends 
  14850.  
  14851. Related Information 
  14852.  
  14853. o Friend Scope 
  14854. o Friend Access 
  14855. o C++ Classes 
  14856. o Member Functions 
  14857.  
  14858.  
  14859. ΓòÉΓòÉΓòÉ <hidden> Example of a friend Function ΓòÉΓòÉΓòÉ
  14860.  
  14861. /************************************************************************
  14862. *
  14863.  
  14864. In the following example, the friend function print is a member of class Y and 
  14865. accesses the private data members a and b of class X. 
  14866.  
  14867.                                                                         *
  14868. ************************************************************************/
  14869.  
  14870. #include <iostream.h>
  14871. class X;
  14872. class Y
  14873. {
  14874. public:
  14875.       void print(X& x);
  14876. };
  14877. class X
  14878. {
  14879. public:
  14880.       X() {a=1; b=2;}
  14881. private:
  14882.       int a, b;
  14883.       friend void Y::print(X& x);
  14884. };
  14885. void Y::print(X& x)
  14886. {
  14887.       cout << "A is "<< x.a << endl;
  14888.       cout << "B is " << x.b << endl;
  14889. }
  14890. void main ()
  14891. {
  14892.       X xobj;
  14893.       Y yobj;
  14894.       yobj.print(xobj);
  14895. }
  14896.  
  14897. /************************************************************************
  14898. *
  14899. In the following example, the friend class F has a member function print that 
  14900. accesses the private data members a and b of class X and performs the same task 
  14901. as the friend function print in the above example. Any other members declared 
  14902. in class F also have access to all members of class X. In the following 
  14903. example, the friend class F has not been previously declared, so an elaborated 
  14904. type specifier and a qualified type specifier are used to specify the class 
  14905. name. 
  14906.  
  14907.                                                                         *
  14908. ************************************************************************/
  14909.  
  14910. #include <iostream.h>
  14911. class X
  14912. {
  14913. public:
  14914.  
  14915.       X() {a=1; b=2;}  // constructor
  14916. private:
  14917.       int a, b;
  14918.       friend class F;            // friend class
  14919. };
  14920. class F
  14921. {
  14922. public:
  14923.       void print(X& x)
  14924.       {
  14925.             cout << "A is " << x.a << endl;
  14926.             cout << "B is " << x.b << endl;
  14927.       }
  14928. };
  14929. void main ()
  14930. {
  14931.       X xobj;
  14932.       F fobj;
  14933.       fobj.print(xobj);
  14934. }
  14935.  
  14936. /************************************************************************
  14937. *
  14938.  
  14939. Both the above examples produce the following output: 
  14940.  
  14941. A is 1
  14942. B is 2
  14943.  
  14944.                                                                         *
  14945. ************************************************************************/
  14946.  
  14947.  
  14948. ΓòÉΓòÉΓòÉ 11.11.1. Friend Scope ΓòÉΓòÉΓòÉ
  14949.  
  14950. The name of a friend function or class first introduced in a friend declaration 
  14951. is not in the scope of the class granting friendship (also called the enclosing 
  14952. class) and is not a member of the class granting friendship. 
  14953.  
  14954. The name of a function first introduced in a friend declaration is in the scope 
  14955. of the first nonclass scope that contains the enclosing class. The body of a 
  14956. function provided in a friend declaration is handled in the same way as a 
  14957. member function defined within a class. Processing of the definition does not 
  14958. start until the end of the outermost enclosing class. In addition, unqualified 
  14959. names in the body of the function definition are searched for starting from the 
  14960. class containing the function definition. 
  14961.  
  14962. A class that is first declared in a friend declaration is equivalent to an 
  14963. extern declaration. For example: 
  14964.  
  14965. class B {};
  14966. class A
  14967. {
  14968.       friend class B; // global class B is a friend of A
  14969. };
  14970.  
  14971. If the name of a friend class has been introduced before the friend 
  14972. declaration, the compiler searches for a class name that matches the name of 
  14973. the friend class beginning at the scope of the friend declaration. If the 
  14974. declaration of a nested class is followed by the declaration of a friend class 
  14975. with the same name, the nested class is a friend of the enclosing class. 
  14976.  
  14977. The scope of a friend class name is the first nonclass enclosing scope. For 
  14978. example: 
  14979.  
  14980. class A {
  14981.    class B { // arbitrary nested class definitions
  14982.       friend class C;
  14983.    };
  14984. };
  14985. is equivalent to: 
  14986.  
  14987. class C;
  14988. class A {
  14989.    class B { // arbitrary nested class definitions
  14990.       friend class C;
  14991.    };
  14992. };
  14993.  
  14994. You need to use the class member access operators if the friend function is a 
  14995. member of another class. For example: 
  14996.  
  14997. class A
  14998. {
  14999. public:
  15000.       int f() { /* ... */ }
  15001. };
  15002. class B
  15003. {
  15004.       friend int A::f();
  15005. };
  15006.  
  15007. Friends of a base class are not inherited by any classes derived from that base 
  15008. class. 
  15009.  
  15010. Related Information 
  15011.  
  15012. o Scope of Class Names 
  15013. o Friend Access 
  15014. o Friends 
  15015. o Nested Classes 
  15016. o Derivation 
  15017.  
  15018.  
  15019. ΓòÉΓòÉΓòÉ 11.11.2. Friend Access ΓòÉΓòÉΓòÉ
  15020.  
  15021. A friend of a class can access the private and protected members of that class. 
  15022. Normally, you can only access the private members of a class through member 
  15023. functions of that class, and you can only access the protected members of a 
  15024. class through member functions of a class or classes derived from that class. 
  15025.  
  15026. Friend declarations are not affected by access specifiers. 
  15027.  
  15028. Related Information 
  15029.  
  15030. o Member Access 
  15031. o Friend Scope 
  15032. o Friends 
  15033.  
  15034.  
  15035. ΓòÉΓòÉΓòÉ 12. C++ Overloading ΓòÉΓòÉΓòÉ
  15036.  
  15037. Overloading enables you to redefine functions and most standard C++ operators. 
  15038. Typically, you overload a function or operator if you want to extend the 
  15039. operations the function or operator performs to different data types. 
  15040.  
  15041. This section discusses: 
  15042.  
  15043. o Overloading Functions 
  15044. o Argument Matching 
  15045. o Overloading Operators 
  15046. o Overloading Unary Operators 
  15047. o Overloading Binary Operators 
  15048. o Special Overloaded Operators 
  15049.  
  15050. Related Information 
  15051.  
  15052. o Functions 
  15053. o Expressions and Operators 
  15054.  
  15055.  
  15056. ΓòÉΓòÉΓòÉ 12.1. Overloading Functions ΓòÉΓòÉΓòÉ
  15057.  
  15058. You can overload a function by having multiple declarations of the same 
  15059. function name in the same scope. The declarations differ in the type and number 
  15060. of arguments in the argument list. When an overloaded function is called, the 
  15061. correct function is selected by comparing the types of the actual arguments 
  15062. with the types of the formal arguments. 
  15063.  
  15064. Consider a function print, which displays an int. You can overload the function 
  15065. print to display other types, for example, double and char*. You can have three 
  15066. functions with the same name, each performing a similar operation on a 
  15067. different data type. 
  15068.  
  15069. #include <iostream.h>
  15070. void print(int i) { cout << " Here is int " << i << endl; }
  15071. void print(double  f) { cout << " Here is float "
  15072.                                   << f << endl; }
  15073. void print(char* c) { cout << " Here is char* " << c << endl; }
  15074. void main() {
  15075.       print(10);            // calls print(int)
  15076.       print(10.10);         // calls print(double)
  15077.       print("ten");         // calls print(char*)
  15078. }
  15079.  
  15080. Two function declarations are identical if all of the following are true: 
  15081.  
  15082. o They have the same function name 
  15083. o They are declared in the same scope 
  15084. o They have identical argument lists 
  15085.  
  15086. When you declare a function name more than once in the same scope, the second 
  15087. declaration of the function name is interpreted by the compiler as follows: 
  15088.  
  15089. o If the return type, argument types, and number of arguments of the two 
  15090.   declarations are identical, the second declaration is considered a 
  15091.   declaration of the same function as the first. 
  15092. o If only the return types of the two function declarations differ, the second 
  15093.   declaration is an error. 
  15094. o If either the argument types or number of arguments of the two declarations 
  15095.   differ, the function is considered to be overloaded. 
  15096.  
  15097. Restrictions on Overloaded Functions 
  15098.  
  15099. Related Information 
  15100.  
  15101. o Functions 
  15102. o Function Declarations 
  15103. o Scope in C++ 
  15104. o Argument Matching 
  15105. o Member Functions 
  15106. o Inheritance 
  15107.  
  15108.  
  15109. ΓòÉΓòÉΓòÉ 12.1.1. Restrictions on Overloaded Functions ΓòÉΓòÉΓòÉ
  15110.  
  15111. o Functions that differ only in return type cannot have the same name. 
  15112.  
  15113. o Two member functions that differ only in that one is declared with the 
  15114.   keyword static and the other is not cannot have the same name. 
  15115.  
  15116. o A typedef is a synonym for another type, not a separate type. Thus, the 
  15117.   following two declarations of spadina() are declarations of the same 
  15118.   function: 
  15119.  
  15120.           typedef int I;
  15121.           void spadina(float, int);
  15122.           void spadina(float, I);
  15123.  
  15124. o A member function of a derived class is not in the same scope as a member 
  15125.   function in a base class with the same name. A derived class member hides a 
  15126.   base class member with the same name. 
  15127.  
  15128. o Arguments type that differ only in that one is a pointer * and the other is 
  15129.   an array [ ] are identical. The following two declarations are equivalent: 
  15130.  
  15131.           f(char*);
  15132.           f(char[10]);
  15133.  
  15134.  
  15135. ΓòÉΓòÉΓòÉ 12.2. Argument Matching ΓòÉΓòÉΓòÉ
  15136.  
  15137. When an overloaded function or overloaded operator is called, the compiler 
  15138. chooses the function declaration with the best match on all arguments from all 
  15139. the function declarations that are visible. The compiler compares the actual 
  15140. arguments of a function call with the formal arguments of all declarations of 
  15141. the function that are visible. For a best match to occur, the compiler must be 
  15142. able to distinguish a function that: 
  15143.  
  15144. o Has at least as good a match on all arguments as any other function with the 
  15145.   same name 
  15146. o Has at least one better argument match than any other function with the same 
  15147.   name 
  15148.  
  15149. If no such function exists, the call is not allowed. There are three possible 
  15150. outcomes of a call to an overloaded function. The compiler can find: 
  15151.  
  15152. o An exact match 
  15153. o No match 
  15154. o An ambiguous match 
  15155.  
  15156. An ambiguous match occurs when the actual arguments of the function call match 
  15157. more than one overloaded function. 
  15158.  
  15159. Argument matching can include performing standard and user-defined conversions 
  15160. on the arguments to match the actual arguments with the formal arguments. Only 
  15161. a single user-defined conversion is performed in a sequence of conversions on 
  15162. an actual argument. In addition, the best-matching sequence of standard 
  15163. conversions is performed on an actual argument. The best-matching sequence is 
  15164. the shortest sequence of conversions between two standard types. For example, 
  15165. the conversion: 
  15166.  
  15167. int -> float -> double
  15168.  
  15169. can be shortened to the best-matching conversion sequence: 
  15170.  
  15171. int -> double
  15172.  
  15173. because the conversion from int to double is allowed. 
  15174.  
  15175. Trivial Conversions do not affect the choice of conversion sequence. Conversion 
  15176. sequences are described in Sequences of Conversions. 
  15177.  
  15178. Related Information 
  15179.  
  15180. o Sequences of Conversions 
  15181. o Trivial Conversions 
  15182. o Overloading Functions 
  15183. o Overloading Operators 
  15184.  
  15185.  
  15186. ΓòÉΓòÉΓòÉ 12.2.1. Sequences of Conversions ΓòÉΓòÉΓòÉ
  15187.  
  15188. Argument-matching conversions occur in the following order: 
  15189.  
  15190.  1. An exact match in which the actual arguments match exactly (including a 
  15191.     match with one or more trivial conversions) with the type and number of 
  15192.     formal arguments of one declaration of the overloaded function 
  15193.  
  15194.  2. A match with promotions in which a match is found when one or more of the 
  15195.     actual arguments is promoted 
  15196.  
  15197.  3. A match with standard conversions in which a match is found when one or 
  15198.     more of the actual arguments is converted by a standard conversion 
  15199.  
  15200.  4. A match with user-defined conversions in which a match is found when one or 
  15201.     more of the actual arguments is converted by a user-defined conversion 
  15202.  
  15203.  5. A match with ellipses 
  15204.  
  15205. Match through promotions follows the rules for Type Conversions. 
  15206.  
  15207. You can override an exact match by using an explicit cast. In the following 
  15208. example, the second call to f() matches with f(void*): 
  15209.  
  15210. void f(int);
  15211. void f(void*);
  15212. void main()
  15213. {
  15214.       f(0xaabb);            // matches f(int);
  15215.       f((void*) 0xaabb);    // matches f(void*)
  15216. }
  15217.  
  15218. The implicit first argument for a nonstatic member function or operator is the 
  15219. this pointer. It refers to the class object for which the member function is 
  15220. called. When you overload a nonstatic member function, the first implicit 
  15221. argument, the this pointer, is matched with the object or pointer used in the 
  15222. call to the member function. User-defined conversions are not applied in this 
  15223. type of argument matching for overloaded functions or operators. 
  15224.  
  15225. When you call an overloaded member function of class X using the . (dot) or -> 
  15226. (arrow) operator, the this pointer has type X* const. The type of the this 
  15227. pointer for a constant object is const X* const. The type of the this pointer 
  15228. for a volatile object is volatile X* const. 
  15229.  
  15230. Related Information 
  15231.  
  15232. o Argument Matching 
  15233. o Trivial Conversions 
  15234. o Type Conversions 
  15235. o User-Defined Conversions 
  15236. o The this Pointer 
  15237. o Overloading Functions 
  15238. o Overloading Operators 
  15239. o Dot Operator 
  15240. o Arrow Operator 
  15241.  
  15242.  
  15243. ΓòÉΓòÉΓòÉ 12.2.2. Trivial Conversions ΓòÉΓòÉΓòÉ
  15244.  
  15245. Functions cannot be distinguished if they have the same name and have arguments 
  15246. that differ only in that one is declared as a reference to a type and the other 
  15247. is that type. Thus, you cannot have two functions with the same name and with 
  15248. arguments differing only in this respect. The following two declarations cannot 
  15249. be distinguished, and thus the second one causes an error: 
  15250.  
  15251. double f(double i);  // declaration
  15252.  
  15253. double f(double &i); // error
  15254.  
  15255. However, functions with the same name having arguments that differ only in that 
  15256. one is a pointer or reference and the other is a pointer to const or const 
  15257. reference can be distinguished. Functions with the same name having arguments 
  15258. that differ only in that one is a pointer or reference and the other is a 
  15259. pointer to volatile or volatile reference can also be distinguished. For the 
  15260. purpose of finding a best match of arguments, functions that have a volatile or 
  15261. const match (not requiring a trivial conversion) are better than those that 
  15262. have a volatile or const mismatch. 
  15263.  
  15264. Related Information 
  15265.  
  15266. o Argument Matching 
  15267. o Sequences of Conversions 
  15268. o Type Conversions 
  15269. o User-Defined Conversions 
  15270. o Overloading Functions 
  15271. o Overloading Operators 
  15272.  
  15273.  
  15274. ΓòÉΓòÉΓòÉ 12.3. Overloading Operators ΓòÉΓòÉΓòÉ
  15275.  
  15276. You can overload one of the standard C++ operators by redefining it to perform 
  15277. a particular operation when it is applied to an object of a particular class. 
  15278. Overloaded operators must have at least one argument that has class type. An 
  15279. overloaded operator is called an operator function and is declared with the 
  15280. keyword operator preceding the operator. Overloaded operators are distinct from 
  15281. overloaded functions, but, like overloaded functions, they are distinguished by 
  15282. the number and types of operands used with the operator. 
  15283.  
  15284. You can overload any of the following operators: 
  15285.  
  15286. +     -     *     /     %     ^     &     |     ~
  15287. !     =     <     >     +=    -=    *=    /=    %=
  15288. ^=    &=    |=    <<    >>    <<=   >>=   ==    !=
  15289. <=    >=    &&    ||    ++    --    ,     ->*   ->
  15290. ()    []    new   delete
  15291.  
  15292. where () is the function call operator and [] is the subscript operator. 
  15293.  
  15294. Consider the standard + (plus) operator. When this operator is used with 
  15295. operands of different standard types, the operators have slightly different 
  15296. meanings. For example, the addition of two integers is not implemented in the 
  15297. same way as the addition of two floating-point numbers. C++ allows you to 
  15298. define your own meanings for the standard C++ operators when they are applied 
  15299. to class types. 
  15300.  
  15301. Example of an Overloaded Operator 
  15302.  
  15303. The argument-matching conventions and rules described in Argument Matching 
  15304. apply to overloaded operators. 
  15305.  
  15306. You can overload both the unary and binary forms of: 
  15307.  
  15308.       +      -      *      &
  15309.  
  15310. When an overloaded operator is a member function, the first operand is matched 
  15311. against the class type of the overloaded operator. The second operand, if one 
  15312. exists, is matched against the argument in the overloaded operator call. 
  15313.  
  15314. When an overloaded operator is a nonmember function, at least one operand must 
  15315. have class or enumeration type. The first operand is matched against the first 
  15316. argument in the overloaded operator call. The second operand, if one exists, is 
  15317. matched against the second argument in the overloaded operator call. 
  15318.  
  15319. An overloaded operator must be either a member function, as shown in the 
  15320. following example: 
  15321.  
  15322. class X
  15323. {
  15324. public:
  15325.       X operator!();
  15326.       X& operator =(X&);
  15327.       X operator+(X&);
  15328. };
  15329. X X::operator!() { /* ... */ }
  15330. X& X::operator=(X& x) { /* ... */ }
  15331. X X::operator+(X& x) { /* ... */ }
  15332.  
  15333. or take at least one argument of class, a reference to a class, an enumeration, 
  15334. or a reference to an enumeration, as shown below: 
  15335.  
  15336. class Y;
  15337. {
  15338. //      .
  15339. };
  15340. class Z;
  15341. {
  15342. //      .
  15343. };
  15344. Y operator!(Y& y);
  15345. Z operator+(Z& z, int);
  15346.  
  15347. Usually, overloaded operators are invoked using the normal operator syntax. You 
  15348. can also call overloaded operators explicitly by qualifying the operator name. 
  15349.  
  15350. Restrictions on Overloaded Operators 
  15351.  
  15352. Related Information 
  15353.  
  15354. o Overloading Unary Operators 
  15355. o Overloading Binary Operators 
  15356. o Special Overloaded Operators 
  15357. o Argument Matching 
  15358. o Overloading Functions 
  15359. o Expressions and Operators 
  15360.  
  15361.  
  15362. ΓòÉΓòÉΓòÉ <hidden> Example of an Overloaded Operator ΓòÉΓòÉΓòÉ
  15363.  
  15364. /************************************************************************
  15365. *
  15366.  
  15367. In the following example, a class called complx is defined to model complex 
  15368. numbers, and the + (plus) operator is redefined in this class to add two 
  15369. complex numbers. 
  15370.  
  15371.                                                                         *
  15372. ************************************************************************/
  15373.  
  15374. #include <iostream.h>
  15375. class complx
  15376. {
  15377.       double real,
  15378.              imag;
  15379. public:
  15380.       complx( double real = 0., double imag = 0.); // constructor
  15381.       complx operator+(const complx&) const;       // operator+()
  15382. };
  15383. // define constructor
  15384. complx::complx( double r, double i )
  15385. {
  15386.       real = r; imag = i;
  15387. }
  15388. // define overloaded + (plus) operator
  15389. complx complx::operator+ (const complx& c) const
  15390. {
  15391.       complx result;
  15392.       result.real = (this->real + c.real);
  15393.       result.imag = (this->imag + c.imag);
  15394.       return result;
  15395. }
  15396. void main()
  15397. {
  15398.       complx x(4,4);
  15399.       complx y(6,6);
  15400.       complx z = x + y; // calls complx::operator+()
  15401. }
  15402.  
  15403. /************************************************************************
  15404. *
  15405.  
  15406. For the class complx, described above, you can call the overloaded + (plus) 
  15407. operator either implicitly or explicitly as shown below. 
  15408.  
  15409.                                                                         *
  15410. ************************************************************************/
  15411.  
  15412. class complx
  15413. {
  15414.       double real,
  15415.              imag;
  15416. public:
  15417.       complx( double real = 0., double imag = 0.);
  15418.       complx operator+(const complx&) const;
  15419. };
  15420. //      .
  15421. //      .
  15422. //      .
  15423. void main()
  15424. {
  15425.       complx x(4,4);
  15426.       complx y(6,6);
  15427.       complx u = x.operator+(y); // explicit call
  15428.       complx z = x + y;          // implicit call to complx::operator+()
  15429. }
  15430.  
  15431.  
  15432. ΓòÉΓòÉΓòÉ 12.3.1. Restrictions on Overloaded Operators ΓòÉΓòÉΓòÉ
  15433.  
  15434. o The following C++ operators cannot be overloaded: 
  15435.  
  15436.           .      .*      ::      ?:
  15437.  
  15438. o You cannot overload the preprocessing symbols # and ##. 
  15439.  
  15440. o You cannot change the precedence, grouping, or number of operands of the 
  15441.   standard C++ operators. For more information, see Operator Precedence. 
  15442.  
  15443. o An overloaded operator (except for the function call operator) cannot have 
  15444.   default arguments or an ellipsis in the argument list. 
  15445.  
  15446. o You must declare the overloaded =, [], () and -> operators as nonstatic 
  15447.   member functions to ensure that they receive lvalues as their first operands. 
  15448.  
  15449. o The operators new and delete do not follow the general rules described in 
  15450.   this section. new and delete are described on page Overloaded new and delete. 
  15451.  
  15452. o All operators except the = operator are inherited. Copy by Assignment 
  15453.   describes the behavior of the assignment operator. 
  15454.  
  15455. o Unless they are explicitly mentioned in Special Overloaded Operators, 
  15456.   overloaded unary and binary operators follow the rules outlined in 
  15457.   Overloading Unary Operators and Overloading Binary Operators. 
  15458.  
  15459. For more information on standard C++ operators, see Expressions and Operators. 
  15460.  
  15461.  
  15462. ΓòÉΓòÉΓòÉ 12.3.2. Overloading Unary Operators ΓòÉΓòÉΓòÉ
  15463.  
  15464. You can overload a prefix unary operator by declaring a nonmember function 
  15465. taking one argument or a nonstatic member function taking no arguments. 
  15466.  
  15467. When you prefix a class object with an overloaded unary operator, for example: 
  15468.  
  15469. class X
  15470. {
  15471. // ...
  15472. };
  15473. void main ()
  15474. {
  15475.       X x;
  15476.       !x;       // overloaded unary operator
  15477. }
  15478.  
  15479. the operator function call !x can be interpreted as:  x.operator!()  or 
  15480. operator!(x) . depending on the declarations of the operator function. If both 
  15481. forms of the operator function have been declared, argument matching determines 
  15482. which interpretation is used. 
  15483.  
  15484. Related Information 
  15485.  
  15486. o Overloading Binary Operators 
  15487. o Overloading Operators 
  15488. o Special Overloaded Operators 
  15489. o Restrictions on Overloaded Operators 
  15490. o Unary Expression 
  15491.  
  15492.  
  15493. ΓòÉΓòÉΓòÉ 12.3.3. Overloading Binary Operators ΓòÉΓòÉΓòÉ
  15494.  
  15495. You can overload a binary operator by declaring a nonmember function taking two 
  15496. arguments or a nonstatic member function taking one argument. 
  15497.  
  15498. When you use a class object with an overloaded binary operator, for example: 
  15499.  
  15500. class X
  15501. {
  15502. // ...
  15503. };
  15504. void main ()
  15505. {
  15506.       X x;
  15507.       int y=10;
  15508.       x*y;       // overloaded binary operator
  15509. }
  15510.  
  15511. the operator function call x*y can be interpreted as:  x.operator*(y)  or 
  15512. operator*(x,y)  depending on the declarations of the operator function. If both 
  15513. forms of the operator function have been declared, argument matching determines 
  15514. which interpretation is used. 
  15515.  
  15516. Related Information 
  15517.  
  15518. o Overloading Unary Operators 
  15519. o Overloading Operators 
  15520. o Special Overloaded Operators 
  15521. o Restrictions on Overloaded Operators 
  15522. o Binary Expression 
  15523.  
  15524.  
  15525. ΓòÉΓòÉΓòÉ 12.4. Special Overloaded Operators ΓòÉΓòÉΓòÉ
  15526.  
  15527. The following overloaded operators do not fully follow the rules for unary or 
  15528. binary overloaded operators: 
  15529.  
  15530. o Assignment 
  15531. o Function Call 
  15532. o Subscripting 
  15533. o Class Member Access 
  15534. o Increment and Decrement 
  15535. o new and delete 
  15536.  
  15537. Related Information 
  15538.  
  15539. o Overloading Unary Operators 
  15540. o Overloading Binary Operators 
  15541. o Overloading Operators 
  15542. o Restrictions on Overloaded Operators 
  15543. o Member Functions 
  15544.  
  15545.  
  15546. ΓòÉΓòÉΓòÉ 12.4.1. Overloaded Assignment ΓòÉΓòÉΓòÉ
  15547.  
  15548. You can only overload an assignment operator by declaring a nonstatic member 
  15549. function. The following example shows how you can overload the assignment 
  15550. operator for a particular class: 
  15551.  
  15552. class X
  15553. {
  15554. public:
  15555.       X();
  15556.       X& operator=(X&);
  15557.       X& operator=(int);
  15558.  
  15559. };
  15560. X& X::operator=(X& x) { /* ... */ }
  15561. X& X::operator=(int i) { /* ... */ }
  15562.  
  15563. void main()
  15564. {
  15565.       X x1, x2;
  15566.       x1 = x2;      // call x1.operator=(x2)
  15567.       x1 = 5;       // call x1.operator=(5)
  15568. }
  15569.  
  15570. You cannot declare an overloaded assignment operator that is a nonmember 
  15571. function. Overloaded assignment operators are not inherited. 
  15572.  
  15573. If a copy assignment operator function is not defined for a class, the copy 
  15574. assignment operator function is defined by default as a memberwise assignment 
  15575. of the class members. If assignment operator functions exist for base classes 
  15576. or class members, these operators are used when the compiler generates default 
  15577. copy assignment operators. See Copy by Assignment for more information. 
  15578.  
  15579. For more information on standard assignment operators, see Assignment 
  15580. Expression. 
  15581.  
  15582.  
  15583. ΓòÉΓòÉΓòÉ 12.4.2. Overloaded Function Call ΓòÉΓòÉΓòÉ
  15584.  
  15585. The function call has syntax of the form: 
  15586.  
  15587.       function-name ( [expression-list] )
  15588.  
  15589. and is considered a binary operator. The operands are function-name and an 
  15590. optional expression-list. The operator function operator() must be defined as a 
  15591. nonstatic member function. You cannot declare an overloaded function call 
  15592. operator that is a nonmember function. 
  15593.  
  15594. If you make the following call for the class object x: 
  15595.  
  15596. x (arg1, arg2, arg3)
  15597.  
  15598. it is interpreted as 
  15599.  
  15600. x.operator( )(arg1, arg2, arg3)
  15601.  
  15602. Unlike all other overloaded operators, you can provide default arguments and 
  15603. ellipses in the argument list for the function call operator. For example: 
  15604.  
  15605. class X
  15606. {
  15607. public:
  15608.       X& operator() (int = 5);
  15609. };
  15610.  
  15611. For more information on the standard function call operator, see Function Call 
  15612. ( ). 
  15613.  
  15614.  
  15615. ΓòÉΓòÉΓòÉ 12.4.3. Overloaded Subscripting ΓòÉΓòÉΓòÉ
  15616.  
  15617. An expression containing the subscripting operator has syntax of the form: 
  15618.  
  15619.       identifier [ expression ]
  15620.  
  15621. and is considered a binary operator. The operands are identifier and 
  15622. expression. The operator function operator[] must be defined as a nonstatic 
  15623. member function. You cannot declare an overloaded subscript operator that is a 
  15624. nonmember function. 
  15625.  
  15626. A subscripting expression for the class object x: 
  15627.  
  15628. x [y]
  15629.  
  15630. is interpreted as x.operator[](y). It is not interpreted as operator[](x,y) 
  15631. because it is defined as a nonstatic member function. 
  15632.  
  15633. For more information on the standard subscripting operator, see Array Subscript 
  15634. [ ]. 
  15635.  
  15636.  
  15637. ΓòÉΓòÉΓòÉ 12.4.4. Overloaded Class Member Access ΓòÉΓòÉΓòÉ
  15638.  
  15639. An expression containing the class member access -> (arrow) operator has syntax 
  15640. of the form: 
  15641.  
  15642.       identifier -> name-expression
  15643.  
  15644. and is considered a unary operator. The operator function operator->() must be 
  15645. defined as a nonstatic member function. 
  15646.  
  15647. The following restrictions apply to class member access operators: 
  15648.  
  15649. o You cannot declare an overloaded arrow operator that is a nonmember function. 
  15650. o You cannot overload the class member access . (dot) operator. 
  15651.  
  15652. Consider the following example of overloading the -> (arrow) operator: 
  15653.  
  15654. class Y
  15655. {
  15656. public:
  15657.       void f();
  15658. };
  15659. class X
  15660. {
  15661. public:
  15662.       Y* operator->();
  15663. };
  15664. X x;
  15665. x->f();
  15666.  
  15667. Here x->f() is interpreted as:  ( x.operator->() )-> f() . 
  15668.  
  15669. x.operator->() must return either a reference to a class object or a class 
  15670. object for which the overloaded operator-> function is defined or a pointer to 
  15671. any class. If the overloaded operator-> function returns a class type, the 
  15672. class type must not be the same as the class declaring the function, and the 
  15673. class type returned must contain its own definition of an overloaded -> 
  15674. operator function. 
  15675.  
  15676. For more information on the standard class member access arrow operator, see 
  15677. Arrow Operator. 
  15678.  
  15679.  
  15680. ΓòÉΓòÉΓòÉ 12.4.5. Overloaded Increment and Decrement ΓòÉΓòÉΓòÉ
  15681.  
  15682. The prefix increment operator ++ can be overloaded for a class type by 
  15683. declaring a nonmember function operator with one argument of class type or a 
  15684. reference to class type, or by declaring a member function operator with no 
  15685. arguments. In the following example, the increment operator is overloaded in 
  15686. both ways: 
  15687.  
  15688. class X
  15689. {
  15690.       int a;
  15691. public:
  15692.       operator++();      // member prefix increment operator
  15693. };
  15694. class Y { /* ... */ }
  15695. operator++(Y& y);        // nonmember prefix increment operator
  15696.  
  15697. // Definitions of prefix increment operator functions
  15698. // ...
  15699.  
  15700. void main()
  15701. {
  15702.       X x;
  15703.       Y y;
  15704.       ++x;               // x.operator++
  15705.       x.operator++();    // x.operator++
  15706.       operator++(y);     // nonmember operator++
  15707.       ++y;               // nonmember operator++
  15708. }
  15709.  
  15710. The postfix increment operator ++ can be overloaded for a class type by 
  15711. declaring a nonmember function operator operator++() with two arguments, the 
  15712. first having class type and the second having type int. Alternatively, you can 
  15713. declare a member function operator operator++() with one argument having type 
  15714. int. The compiler uses the int argument to distinguish between the prefix and 
  15715. postfix increment operators. For implicit calls, the default value is zero. For 
  15716. example: 
  15717.  
  15718. class X
  15719. {
  15720.       int a;
  15721. public:
  15722.       operator++(int);   // member postfix increment operator
  15723. };
  15724. operator++(X x, int i);  // nonmember postfix increment operator
  15725.  
  15726. // Definitions of postfix increment operator functions
  15727. // ...
  15728.  
  15729. void main()
  15730. {
  15731.       X x;
  15732.       x++;               // x.operator++
  15733.                          // default zero is supplied by compiler
  15734.       x.operator++(0);   // x.operator++
  15735.       operator++(x,0);   // nonmember operator++
  15736. }
  15737.  
  15738. The prefix and postfix decrement operators follow the same rules as their 
  15739. increment counterparts. 
  15740.  
  15741. For more information on the standard postfix and prefix increment operators, 
  15742. see Increment  ++. For more information on the standard postfix and prefix 
  15743. decrement operators, see Decrement  - -. 
  15744.  
  15745.  
  15746. ΓòÉΓòÉΓòÉ 12.4.6. Overloaded new and delete ΓòÉΓòÉΓòÉ
  15747.  
  15748. You can implement your own memory management scheme for a class by overloading 
  15749. the operators new and delete. The overloaded operator new must return a void*, 
  15750. and its first argument must have type size_t, which is defined in the standard 
  15751. header file <stddef.h>. The overloaded operator delete must return a void type, 
  15752. and its first argument must be void*. The second argument for the overloaded 
  15753. delete operator is optional and, if present, it must have type size_t. You can 
  15754. only define one delete operator function for a class. 
  15755.  
  15756. The size argument is required because a class may inherit an overloaded new 
  15757. operator. The derived class can be a different size than the base class. The 
  15758. size argument ensures that the correct amount of storage space is allocated or 
  15759. deallocated for the object. 
  15760.  
  15761. When new and delete are overloaded within a class declaration, they are static 
  15762. member functions whether they are declared with the keyword static or not. 
  15763. Thus, they cannot be virtual functions. 
  15764.  
  15765. You can access the standard, nonoverloaded versions of new and delete within a 
  15766. class scope containing the overloading new and delete operators by using the :: 
  15767. (scope resolution) operator to provide global access. 
  15768.  
  15769. For more information on the class member operators new and delete, see Free 
  15770. Store. For more information on the standard new and delete operators, see new 
  15771. Operator and delete Operator. 
  15772.  
  15773.  
  15774. ΓòÉΓòÉΓòÉ 13. Special Member Functions ΓòÉΓòÉΓòÉ
  15775.  
  15776. This chapter introduces the special member functions that are used to create, 
  15777. destroy, convert, initialize, and copy class objects. The following topics are 
  15778. discussed in this chapter: 
  15779.  
  15780. o Constructors 
  15781. o Destructors 
  15782. o Free Store 
  15783. o Temporary Objects 
  15784. o User-Defined Conversions 
  15785. o Initialization by Constructor 
  15786. o Copying Class Objects 
  15787.  
  15788. Related Information 
  15789.  
  15790. o C++ Classes 
  15791. o C++ Class Members and Friends 
  15792. o Functions 
  15793.  
  15794.  
  15795. ΓòÉΓòÉΓòÉ 13.1. Constructors and Destructors Overview ΓòÉΓòÉΓòÉ
  15796.  
  15797. Because classes have complicated internal structures, including data and 
  15798. functions, object initialization and cleanup for classes is much more 
  15799. complicated than it is for simple data structures. Constructors and destructors 
  15800. are special member functions of classes that are used to construct and destroy 
  15801. class objects. Construction may involve memory allocation and initialization 
  15802. for objects. Destruction may involve cleanup and deallocation of memory for 
  15803. objects. 
  15804.  
  15805. Like other member functions, constructors and destructors are declared within a 
  15806. class declaration. They can be defined inline or external to the class 
  15807. declaration. Constructors can have default arguments. Unlike other member 
  15808. functions, constructors can have member initialization lists. The following 
  15809. restrictions apply to constructors and destructors: 
  15810.  
  15811. o Constructors and destructors do not have return types nor can they return 
  15812.   values. 
  15813. o References and pointers cannot be used on constructors and destructors 
  15814.   because their addresses cannot be taken. 
  15815. o Constructors cannot be declared with the keyword virtual. 
  15816. o Constructors and destructors cannot be declared static, const, or volatile. 
  15817. o Unions and aggregate classes cannot contain class objects that have 
  15818.   constructors or destructors. 
  15819.  
  15820. Constructors and destructors obey the same access rules as member functions. 
  15821. For example, if a constructor is declared with the keyword protected, only 
  15822. derived classes and friends can use it to create class objects. Class member 
  15823. access is described in Member Access. 
  15824.  
  15825. The compiler automatically calls constructors when defining class objects and 
  15826. calls destructors when class objects go out of scope. A constructor does not 
  15827. allocate memory for the class object its this pointer refers to, but may 
  15828. allocate storage for more objects that its class object refers to. If memory 
  15829. allocation is required for objects, constructors can explicitly call the new 
  15830. operator. During cleanup, a destructor may release objects allocated by the 
  15831. corresponding constructor. To release objects, use the delete operator. 
  15832.  
  15833. Derived classes do not inherit constructors or destructors from their base 
  15834. classes, but they do call the constructor and destructor of base classes. 
  15835. Destructors can be declared with the keyword virtual. 
  15836.  
  15837. Constructors are also called when local or temporary class objects are created, 
  15838. and destructors are called when local or temporary objects go out of scope. 
  15839.  
  15840. You can call member functions from constructors or destructors. You can call a 
  15841. virtual function, either directly or indirectly, from a constructor or 
  15842. destructor. In this case, the function called is the one defined in the class 
  15843. or base class containing the constructor (or destructor), but not a function 
  15844. defined in any class derived from the class being constructed. This avoids the 
  15845. possibility of accessing an unconstructed object from a constructor or 
  15846. destructor. 
  15847.  
  15848. Related Information 
  15849.  
  15850. o Constructors 
  15851. o Destructors 
  15852. o Virtual Functions 
  15853. o Member Access 
  15854. o new Operator 
  15855. o delete Operator 
  15856.  
  15857.  
  15858. ΓòÉΓòÉΓòÉ 13.1.1. Constructors ΓòÉΓòÉΓòÉ
  15859.  
  15860. A constructor is a member function with the same name as its class. For 
  15861. example: 
  15862.  
  15863. class X
  15864. {
  15865. public:
  15866.       X();      // constructor for class X
  15867. };
  15868.  
  15869. Constructors are used to create, and can initialize, objects of their class 
  15870. type. Initialization of class objects using constructors is described in 
  15871. Initialization by Constructor. 
  15872.  
  15873. A default constructor is a constructor that either has no arguments, or, if it 
  15874. has arguments, all the arguments have default values. If no user-defined 
  15875. constructor exists for a class and one is needed, the compiler creates a 
  15876. default constructor, with public access, for that class. No default constructor 
  15877. is created for a class that has any constant or reference type members. 
  15878.  
  15879. Like all functions, a constructor can have default arguments. They are used to 
  15880. initialize member objects. If default values are supplied, the trailing 
  15881. arguments can be omitted in the expression list of the constructor. Note that 
  15882. if a constructor has any arguments that do not have default values, it is not a 
  15883. default constructor. 
  15884.  
  15885. A copy constructor is used to make a copy of one class object from another 
  15886. class object of the same class type. A copy constructor is called with a single 
  15887. argument that is a reference to its own class type. You cannot use a copy 
  15888. constructor with an argument of the same type as its class; you must use a 
  15889. reference. You can provide copy constructors with additional default arguments. 
  15890. If a user-defined copy constructor does not exist for a class and one is 
  15891. needed, the compiler creates a copy constructor, with public access, for that 
  15892. class. It is not created for a class if any of its members or base classes have 
  15893. an inaccessible copy constructor. 
  15894.  
  15895. If a class has a base class or members with constructors when it is 
  15896. constructed, the constructor for the base class is called, followed by any 
  15897. constructors for members. The constructor for the derived class is called last. 
  15898. Virtual base classes are constructed before nonvirtual base classes. When more 
  15899. than one base class exists, the base class constructors are called in the order 
  15900. that their classes appear in the base list. For more information, see 
  15901. Construction Order of Derived Class Objects. 
  15902.  
  15903. Examples of Constructors and Construction Order 
  15904.  
  15905. You cannot call constructors directly. You use a function style cast to 
  15906. explicitly construct an object of the specified type. 
  15907.  
  15908. Example of Explicitly Constructing an Object 
  15909.  
  15910. Related Information 
  15911.  
  15912. o Destructors 
  15913. o Constructors and Destructors Overview 
  15914. o Construction Order of Derived Class Objects 
  15915. o Default Arguments 
  15916. o References 
  15917.  
  15918.  
  15919. ΓòÉΓòÉΓòÉ <hidden> Example of Explicitly Constructing an Object ΓòÉΓòÉΓòÉ
  15920.  
  15921. /************************************************************************
  15922. *
  15923.  
  15924. In the following example, a constructor is used as an initializer to create a 
  15925. named object. 
  15926.  
  15927.                                                                         *
  15928. ************************************************************************/
  15929.  
  15930. #include <iostream.h>
  15931. class X
  15932. {
  15933. public:
  15934.  
  15935.       X (int, int , int = 0);  // constructor with default argument
  15936. private:
  15937.       int a, b, c;
  15938.       int f();
  15939. };
  15940. X::X (int i, int j, int k) { a = i; b = j; c = k; }
  15941.  
  15942. void main ()
  15943. {
  15944. X xobject = X(1,2,3);    // explicitly create and initialize
  15945.                          // named object with constructor call
  15946. }
  15947.  
  15948.  
  15949. ΓòÉΓòÉΓòÉ <hidden> Examples of Constructors and Construction Order ΓòÉΓòÉΓòÉ
  15950.  
  15951. /************************************************************************
  15952. *
  15953.  
  15954. The following code fragment shows two classes with constructors, default 
  15955. constructors, and copy constructors: 
  15956.  
  15957. class X
  15958. {
  15959. public:
  15960.       X();                     // default constructor, no arguments
  15961.       X(int, int , int = 0);   // constructor
  15962.       X(const X&);             // copy constructor
  15963.       X(X);                    // error, incorrect argument type
  15964. };
  15965. class Y
  15966. {
  15967. public:
  15968.       Y( int = 0);            // default constructor with one
  15969.                               // default argument
  15970.       Y(const Y&, int = 0);   // copy constructor
  15971. };
  15972.  
  15973. When more than one base class exists, the base class constructors are called in 
  15974. the order that their classes appear in the base list, as shown in the following 
  15975. example. Note that the construction of class D involves construction of the 
  15976. base classes B1, B2, and B3. The construction of base class B2 involves the 
  15977. construction of its class B1 member object. Thus, when class B2 is constructed, 
  15978. the constructor for class B1 is called in addition to B2's own constructor: 
  15979.  
  15980.                                                                         *
  15981. ************************************************************************/
  15982.  
  15983. class B1 { public: B1(); };
  15984. class B2
  15985. {
  15986. public:
  15987.       B2();
  15988.       B1 b1obj;
  15989. };
  15990. class B3 { public: B3(); };
  15991. // ...
  15992. class D : public B1, public B2, public B3
  15993. {
  15994. public:
  15995.       D();
  15996.       ~D();
  15997. };
  15998.  
  15999. void main ()
  16000. {
  16001.       D object;
  16002. }
  16003.  
  16004. /************************************************************************
  16005. *
  16006.  
  16007. In the above example, the constructors for object are called in the following 
  16008. order: 
  16009.  
  16010. B1();      // first base constructor declared
  16011. B1();      // member constructor for B2::b1obj
  16012. B2();      // second base constructor declared
  16013. B3();      // last base constructor declared
  16014. D();       // derived constructor called last
  16015.  
  16016. As explained above, the second call to the constructor of B1 followed by the 
  16017. call to the constructor of B2 is part of the construction of B2. 
  16018.  
  16019.                                                                         *
  16020. ************************************************************************/
  16021.  
  16022.  
  16023. ΓòÉΓòÉΓòÉ 13.1.2. Destructors ΓòÉΓòÉΓòÉ
  16024.  
  16025. A destructor is a member function with the same name as its class prefixed by a 
  16026. ~ (tilde). For example: 
  16027.  
  16028. class X
  16029. {
  16030. public:
  16031.       X();       // constructor for class X
  16032.       ~X();      // destructor for class X
  16033. };
  16034.  
  16035. A destructor takes no arguments and has no return type. Its address cannot be 
  16036. taken. Destructors cannot be declared const, volatile, or static. A destructor 
  16037. can be declared virtual or pure virtual. A union cannot have as a member an 
  16038. object of a class with a destructor. 
  16039.  
  16040. Destructors are usually used to deallocate memory and do other cleanup for a 
  16041. class object and its class members when the object is destroyed. A destructor 
  16042. is called for a class object when that object passes out of scope or is 
  16043. explicitly deleted. 
  16044.  
  16045. Class members that are class types can have their own destructors. Both base 
  16046. and derived classes can have destructors, although destructors are not 
  16047. inherited. If a base class or a member of a base class has a destructor and a 
  16048. class derived from that base class does not declare a destructor, a default 
  16049. destructor is generated. The default destructor calls the destructors of the 
  16050. base class and members of the derived class. Default destructors are generated 
  16051. with default public access. 
  16052.  
  16053. Destructors are called in the reverse order to constructors: 
  16054.  
  16055.  1. The destructor for a class object is called before destructors for members 
  16056.     and bases are called. 
  16057.  2. Destructors for nonstatic members are called before destructors for base 
  16058.     classes are called. 
  16059.  3. Destructors for nonvirtual base classes are called before destructors for 
  16060.     virtual base classes are called. 
  16061.  
  16062. When an exception is thrown for a class object with a destructor, the 
  16063. destructor for the temporary object thrown is not called until control passes 
  16064. out of the catch block. For more information, see Constructors and Destructors 
  16065. in Exception Handling. 
  16066.  
  16067. Destructors are implicitly called when an automatic or temporary object passes 
  16068. out of scope. They are implicitly called at program termination for constructed 
  16069. external and static objects. Destructors are invoked when you use the delete 
  16070. operator for objects created with the new operator. 
  16071.  
  16072. Example of Destructors 
  16073.  
  16074. You can use a destructor explicitly to destroy objects, although this practice 
  16075. is not recommended. If an object has been placed at a specific address by the 
  16076. new operator, you can call the destructor of the object explicitly to destroy 
  16077. it. An explicitly called destructor cannot delete storage. 
  16078.  
  16079. Note:  You can only call destructors for class types. You cannot call 
  16080. destructors for simple types. The call to the destructor in the following 
  16081. example causes the compiler to issue a warning: 
  16082.  
  16083.       int * ptr;
  16084.       ptr -> int::~int(); // warning
  16085.  
  16086. Related Information 
  16087.  
  16088. o Constructors and Destructors Overview 
  16089. o Constructors 
  16090. o Virtual Functions 
  16091. o Constructors and Destructors in Exception Handling 
  16092. o new Operator 
  16093. o delete Operator 
  16094.  
  16095.  
  16096. ΓòÉΓòÉΓòÉ <hidden> Example of Destructors ΓòÉΓòÉΓòÉ
  16097.  
  16098. /***********************************************************************
  16099. *
  16100.  
  16101. The following example shows the use of destructors: 
  16102.  
  16103.                                                                         *
  16104. ************************************************************************/
  16105.  
  16106. #include <string.h>
  16107. class Y
  16108. {
  16109. private:
  16110.       char * string;
  16111.       int number;
  16112. public:
  16113.       Y(const char* n,int a);   // constructor
  16114.       ~Y() { delete[] string; } // destructor
  16115. };
  16116. Y::Y(const char* n, int a)      // define class Y constructor
  16117. {
  16118.       string = strcpy(new char[strlen(n) + 1 ], n);
  16119.       number = a;
  16120. }
  16121. void main ()
  16122. {
  16123.       Y yobj = Y("somestring", 10); // create and initialize
  16124.                                     // object of class Y
  16125. // ...
  16126. // destructor ~Y is called before control returns from main()
  16127. }
  16128.  
  16129.  
  16130. ΓòÉΓòÉΓòÉ 13.2. Free Store ΓòÉΓòÉΓòÉ
  16131.  
  16132. Free store is used for dynamic allocation of memory. The new and delete 
  16133. operators are used to allocate and deallocate free store, respectively. You can 
  16134. define your own versions of new and delete for a class by overloading them. You 
  16135. can supply the new and delete operators with additional arguments. You can also 
  16136. use the /Tm option to enable the debug versions of these operators. See Debug 
  16137. Versions of new and delete for more information on these versions. When new and 
  16138. delete operate on class objects, the class member operator functions new and 
  16139. delete are called, if they have been declared. 
  16140.  
  16141. If you create a class object with the new operator, the operator function 
  16142. operator new() (if it has been declared) is called to create the object. An 
  16143. operator new() for a class is always a static class member, even if it is not 
  16144. declared with the keyword static. It has a return type void* and its first 
  16145. argument must be the size of the object type and have type size_t. It cannot be 
  16146. virtual. 
  16147.  
  16148. Type size_t is an implementation dependent unsigned integral type defined in 
  16149. <stddef.h>. For more information about size_t, see the IBM C/C++ Tools: 
  16150. Programming Guide. 
  16151.  
  16152. When you overload the new operator, you must declare it as a class member, 
  16153. returning type void*, with first argument size_t, as described above. You 
  16154. supply additional arguments in the declaration of operator new(). Use the 
  16155. placement syntax. to specify values for these arguments in an allocation 
  16156. expression 
  16157.  
  16158. The delete operator destroys an object created by the new operator. The operand 
  16159. of delete must be a pointer returned by new. If delete is called for an object 
  16160. with a destructor, the destructor is invoked before the object is deallocated. 
  16161.  
  16162. If you destroy a class object with the delete operator, the operator function 
  16163. operator delete() (if it has been declared) is called to destroy the object. An 
  16164. operator delete() for a class is always a static member, even if it is not 
  16165. declared with the keyword static. Its first argument must have type void*. 
  16166. Because operator delete() has a return type void, it cannot return a value. It 
  16167. cannot be virtual. 
  16168.  
  16169. When you overload the delete operator, you must declare it as class member, 
  16170. returning type void, with first argument having type void*, as described above. 
  16171. You can add a second argument of type size_t to the declaration. You can only 
  16172. have one operator delete() for a single class. 
  16173.  
  16174. Examples of operator new() and operator delete() 
  16175.  
  16176. The result of trying to access a deleted object is undefined because the value 
  16177. of the object can change after deletion. 
  16178.  
  16179. If new and delete are called for a class object that does not declare the 
  16180. operator functions new and delete, or they are called for a nonclass object, 
  16181. the global operators new and delete are used. The global operators new and 
  16182. delete are provided in the C++ library. 
  16183.  
  16184. Related Information 
  16185.  
  16186. o new Operator 
  16187. o delete Operator 
  16188. o Overloaded new and delete 
  16189. o Debug Versions of new and delete 
  16190.  
  16191.  
  16192. ΓòÉΓòÉΓòÉ <hidden> Examples of operators new() and delete() ΓòÉΓòÉΓòÉ
  16193.  
  16194. /************************************************************************
  16195. *
  16196.  
  16197. The following example shows two overloaded new operator functions. 
  16198.  
  16199.                                                                         *
  16200. ************************************************************************/
  16201.  
  16202. #include <stddef.h>
  16203. class X
  16204. {
  16205. public:
  16206.       void* operator new(size_t);
  16207.       void* operator new(size_t, int);
  16208. };
  16209.  
  16210. void main ()
  16211. {
  16212.       X* ptr1 = new X;        // calls X::operator new(sizeof(X))
  16213.       X* ptr2 = new(10) X;    // calls X::operator
  16214.                               // new(sizeof(X),10)
  16215. }
  16216.  
  16217. /************************************************************************
  16218. *
  16219.  
  16220. The following example shows the declaration and use of the operator functions 
  16221. operator new() and operator delete(): 
  16222.  
  16223.                                                                         *
  16224. ************************************************************************/
  16225.  
  16226. #include <stddef.h>
  16227. class X
  16228. {
  16229. public:
  16230.       void* operator new(size_t);
  16231.       void operator delete(void*);         // single argument
  16232. };
  16233. class Y
  16234. {
  16235. public:
  16236.       void operator delete(void*, size_t); // two arguments
  16237. };
  16238.  
  16239. void main ()
  16240. {
  16241.       X* ptr = new X;
  16242.       delete ptr;      // call X::operator delete(void*)
  16243.       Y* yptr;
  16244. // ...
  16245.       delete yptr;     // call Y::operator delete(void*, size_t)
  16246.                        // with size of Y as second argument
  16247. }
  16248.  
  16249.  
  16250. ΓòÉΓòÉΓòÉ 13.2.1. Debug Versions of new and delete ΓòÉΓòÉΓòÉ
  16251.  
  16252. C/C++ Tools provides special versions of new and delete to assist you in 
  16253. debugging memory management problems. These versions can help you find where 
  16254. memory is being incorrectly allocated, written to, or freed. 
  16255.  
  16256. To enable the debug memory management functions, use the /Tm option, which also 
  16257. defines the macro __DEBUG_ALLOC__. The debug versions of new and delete, as 
  16258. well as of the C library functions (malloc and so on), are automatically called 
  16259. in place of the regular functions in your code. Do not parenthesize any calls 
  16260. to these functions, because parentheses disable the definition of the function 
  16261. name to the debug function name. 
  16262.  
  16263. To each call to new, the compiler adds 2 parameters equivalent to the current 
  16264. __FILE__ and __LINE__ macros. They are inserted as the first two parameters in 
  16265. the placement syntax. As a result, the global and class-specific versions of 
  16266. operator new change from: 
  16267.  
  16268.    operator new(size_t);
  16269.    operator new(size_t , additional_parameters );
  16270. to: 
  16271.  
  16272.    operator new(size_t, const char *, size_t);
  16273.    operator new(size_t, const char *, size_t , additional_parameters );
  16274.  
  16275. The compiler adds the same parameters to each delete call, changing all global 
  16276. and class-specific versions of delete from: 
  16277.  
  16278.    operator delete(void *);
  16279.    operator delete(void * , size_t );
  16280. to: 
  16281.  
  16282.    operator delete(void *, const char *, size_t);
  16283.    operator delete(void *, const char *, size_t , size_t );
  16284.  
  16285. The debug versions also automatically call the C library function _heap_check. 
  16286. This function checks all memory blocks allocated or freed by debug memory 
  16287. management functions to make sure that no overwriting has occurred outside the 
  16288. bounds of allocated blocks or in a free memory block. You can also call 
  16289. _heap_check explicitly. 
  16290.  
  16291. You can also call the C library function _dump_allocated to print out 
  16292. information about each memory block currently allocated by the debug memory 
  16293. management functions. Both _heap_check and _dump_allocated are only available 
  16294. when the __DEBUG_ALLOC__ macro is defined, and are described in the IBM C/C++ 
  16295. Tools C Library Reference. 
  16296.  
  16297. All output from these functions is sent to the OS/2 file handle 2, which is 
  16298. usually associated with stderr. 
  16299.  
  16300. Note:  The information provided by these functions is Diagnosis, Modification, 
  16301.        and Tuning information only. It is not intended to be used as a 
  16302.        programming interface. 
  16303.  
  16304. You may need to include the <new.h> header file to include the prototypes of 
  16305. the debug malloc and free code that the debug versions of new and delete use. 
  16306.  
  16307. Important  The changes described above take place for all occurrences of new 
  16308. and delete whether global or specific to a class.  If you have provided member 
  16309. new or delete functions, you must make code changes before compiling with /Tm. 
  16310. You can use the __DEBUG_ALLOC__ macro for conditional compilation. 
  16311.  
  16312. For more information on debug memory management functions in the C library, see 
  16313. the IBM C/C++ Tools C Library Reference. 
  16314.  
  16315.  
  16316. ΓòÉΓòÉΓòÉ 13.3. Temporary Objects ΓòÉΓòÉΓòÉ
  16317.  
  16318. It is sometimes necessary for the compiler to create temporary objects. They 
  16319. are used during reference initialization and during evaluation of expressions 
  16320. including standard type conversions, argument passing, function returns, and 
  16321. evaluation of the throw expression. 
  16322.  
  16323. When a temporary object is created to initialize a reference variable, the name 
  16324. of the temporary object has the same scope as that of the reference variable. 
  16325. When a temporary object is created during the evaluation of an expression, it 
  16326. exists until there is a break in the flow of control of the program. 
  16327.  
  16328. If a temporary object is created for a class with constructors, the compiler 
  16329. calls the appropriate (matching) constructor to create the temporary object. 
  16330.  
  16331. When a temporary object is destroyed and a destructor exists, the compiler 
  16332. calls the destructor to destroy the temporary object. When you exit from the 
  16333. scope in which the temporary object was created, it is destroyed. If a 
  16334. reference is bound to a temporary object, the temporary object is destroyed 
  16335. when the reference passes out of scope unless it is destroyed earlier by a 
  16336. break in the flow of control. For example, a temporary object created by a 
  16337. constructor initializer for a reference member is destroyed on leaving the 
  16338. contructor. 
  16339.  
  16340. Examples of Temporary Objects 
  16341.  
  16342. Use the /Wgnr option to flag the points where temporary objects are generated. 
  16343.  
  16344. Related Information 
  16345.  
  16346. o Constructors 
  16347. o Destructors 
  16348. o References 
  16349. o Initializing References 
  16350. o Expressions and Operators 
  16351. o Functions 
  16352. o Using Exception Handling 
  16353.  
  16354.  
  16355. ΓòÉΓòÉΓòÉ <hidden> Examples of Temporary Objects ΓòÉΓòÉΓòÉ
  16356.  
  16357. /************************************************************************
  16358. *
  16359.  
  16360. The following example shows two expressions in which temporary objects are 
  16361. constructed: 
  16362.  
  16363.                                                                         *
  16364. ************************************************************************/
  16365.  
  16366. class Y
  16367. {
  16368. public:
  16369.       Y(int);
  16370.       Y(Y&);
  16371.       ~Y();
  16372. };
  16373. Y add(Y y) { /* ... */ }
  16374.  
  16375. void main ()
  16376. {
  16377.       Y obj1(10);
  16378.       Y obj2 = add(Y(5));       // one temporary created
  16379.       obj1 = add(obj1);         // two temporaries created
  16380. }
  16381.  
  16382. /************************************************************************
  16383. *
  16384.  
  16385. In the above example, a temporary object of class type Y is created to 
  16386. construct Y(5) before it is passed to the function add(). Because obj2 is being 
  16387. constructed, the function add() can construct its return value directly into 
  16388. obj2, so another temporary object is not created. A temporary object of class 
  16389. type Y is created when obj1 is passed to the function add(). Because obj1 has 
  16390. already been constructed, the function add() constructs its return value into a 
  16391. temporary object. This second temporary object is then assigned to obj1 using 
  16392. an assignment operator. 
  16393.  
  16394.                                                                         *
  16395. ************************************************************************/
  16396.  
  16397.  
  16398. ΓòÉΓòÉΓòÉ 13.4. User-Defined Conversions ΓòÉΓòÉΓòÉ
  16399.  
  16400. User-defined conversions allow you to specify object conversions with 
  16401. constructors or with conversion functions. User-defined conversions are 
  16402. implicitly used in addition to standard conversions for conversion of 
  16403. initializers, functions arguments, function return values, expression operands, 
  16404. expressions controlling iteration, selection statements, and explicit type 
  16405. conversions. 
  16406.  
  16407. There are two types of user-defined conversions: 
  16408.  
  16409. o Conversion by Constructor 
  16410. o Conversion Functions 
  16411.  
  16412. Related Information 
  16413.  
  16414. o Type Conversions 
  16415. o Constructors and Destructors Overview 
  16416. o Constructors 
  16417. o C++ Classes 
  16418. o Functions 
  16419.  
  16420.  
  16421. ΓòÉΓòÉΓòÉ 13.4.1. Conversion by Constructor ΓòÉΓòÉΓòÉ
  16422.  
  16423. You can call a class constructor with a single argument to convert from the 
  16424. argument type to the type of the class. 
  16425.  
  16426. At most one user-defined conversion, either a constructor or conversion 
  16427. function, is implicitly applied to a class object. When you call a constructor 
  16428. with an argument and you have not defined a constructor accepting that argument 
  16429. type, only standard conversions are used to convert the argument to another 
  16430. argument type acceptable to a constructor for that class. Other constructors or 
  16431. conversions functions are not called to convert the argument to a type 
  16432. acceptable to a constructor defined for that class. 
  16433.  
  16434. Example of Conversion by Constructor 
  16435.  
  16436. Related Information 
  16437.  
  16438. o Conversion Functions 
  16439. o Constructors and Destructors Overview 
  16440. o Constructors 
  16441. o User-Defined Conversions 
  16442. o Type Conversions 
  16443.  
  16444.  
  16445. ΓòÉΓòÉΓòÉ <hidden> Example of Conversion by Constructor ΓòÉΓòÉΓòÉ
  16446.  
  16447. /************************************************************************
  16448. *
  16449.  
  16450. The following example shows conversion by constructor: 
  16451.  
  16452.                                                                         *
  16453. ************************************************************************/
  16454.  
  16455. class Y
  16456. {
  16457.       int a,b;
  16458.       char* name;
  16459. public:
  16460.       Y(int i);
  16461.       Y(const char* n, int j = 0);
  16462. };
  16463. void add(Y);
  16464. // ...
  16465. void main ()
  16466. {
  16467.       // code                     equivalent code
  16468.       Y obj1 = 2;              // obj1 = Y(2)
  16469.       Y obj2 = "somestring";   // obj2 = Y("somestring",0)
  16470.       obj1 = 10;               // obj1 = Y(10)
  16471.       add(5);                  // add(Y(5))
  16472. }
  16473.  
  16474.  
  16475. ΓòÉΓòÉΓòÉ 13.4.2. Conversion Functions ΓòÉΓòÉΓòÉ
  16476.  
  16477. You can define a member function of a class, called a conversion function, that 
  16478. converts from the type of its class to another specified type. 
  16479.  
  16480. Syntax of a Conversion Function 
  16481.  
  16482. The conversion function specifies a conversion from the class type the 
  16483. conversion function is a member of, to the type specified by the name of the 
  16484. conversion function. Classes, enumerations, and typedef names cannot be 
  16485. declared or defined as part of the function name. 
  16486.  
  16487. Conversion functions have no arguments, and the return type is implicitly the 
  16488. conversion type. Conversion functions can be inherited. You can have virtual 
  16489. conversion functions but not static ones. 
  16490.  
  16491. Only one user-defined conversion is implicitly applied to a single value. 
  16492. User-defined conversions must be unambiguous, or they are not called. 
  16493.  
  16494. If a conversion function is declared with the keyword const, the keyword has no 
  16495. affect on the function except for acting as a tie-breaker when there is more 
  16496. than one conversion function that could be applied. Specifically, if more than 
  16497. one conversion function could be applied, all of these functions are compared. 
  16498. If any of these functions is declared with the keyword const, const is ignored 
  16499. for the purposes of this comparison. If one of these functions is a best match, 
  16500. this function is applied. If there is no best match, the functions are compared 
  16501. again, but this time const is not ignored. 
  16502.  
  16503. Example of a Conversion Function 
  16504.  
  16505. Related Information 
  16506.  
  16507. o Conversion by Constructor 
  16508. o Functions 
  16509. o Type Conversions 
  16510. o volatile and const Qualifiers 
  16511. o Virtual Functions 
  16512.  
  16513.  
  16514. ΓòÉΓòÉΓòÉ <hidden> Syntax of a Conversion Function ΓòÉΓòÉΓòÉ
  16515.  
  16516. A conversion function has the following syntax: 
  16517.  
  16518. >>ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇoperatorΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇconversion_typeΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ(ΓöÇΓöÇ)ΓöÇΓöÇ>
  16519.   ΓööΓöÇclass::ΓöÇΓöÿ       Γö£ΓöÇconstΓöÇΓöÇΓöÇΓöÇΓöñ          Γö£ΓöÇ*ΓöÇΓöñ
  16520.               ΓööΓöÇvolatileΓöÇΓöÿ          ΓööΓöÇ&ΓöÇΓöÿ
  16521. >ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ><
  16522.   ΓööΓöÇ{ΓöÇΓöÇfunction_bodyΓöÇΓöÇ}ΓöÇΓöÿ
  16523.  
  16524.  
  16525. ΓòÉΓòÉΓòÉ <hidden> Example of a Conversion Function ΓòÉΓòÉΓòÉ
  16526.  
  16527. /************************************************************************
  16528. *
  16529.  
  16530. The following code fragment shows a conversion function called operator int(): 
  16531.  
  16532.                                                                         *
  16533. ************************************************************************/
  16534.  
  16535. class Y
  16536. {
  16537.       int b;
  16538. public:
  16539.       operator int();
  16540. };
  16541. Y::operator int() {return b;}
  16542.  
  16543. void f(Y obj )
  16544. {
  16545.       // each value assigned is converted by Y::operator
  16546. int()
  16547.       int i = int(obj);
  16548.       int j = (int)obj;
  16549.       int k = i + obj;
  16550. }
  16551.  
  16552.  
  16553. ΓòÉΓòÉΓòÉ 13.5. Initialization by Constructor ΓòÉΓòÉΓòÉ
  16554.  
  16555. A class object with a constructor must be explicitly initialized or have a 
  16556. default constructor. Explicit initialization using a constructor is the only 
  16557. way, except for aggregate initialization, to initialize nonstatic constant and 
  16558. reference class members. 
  16559.  
  16560. A class object that has no constructors, no virtual functions, no private or 
  16561. protected members, and no base classes is called an aggregate. Aggregates are 
  16562. described in Structures and Unions. 
  16563.  
  16564. Class objects with constructors can be initialized with a parenthesized 
  16565. expression list. This list is used as an argument list for the call of a 
  16566. constructor that is used to initialize the class. You can also call a 
  16567. constructor with a single initialization value using the = operator. Because 
  16568. this type of expression is an initialization, not an assignment, the assignment 
  16569. operator function, if one exists, is not called. This value is used as a single 
  16570. argument for the call of a constructor. The type of the single argument must 
  16571. match the type of the first argument to the constructor. If the constructor has 
  16572. remaining arguments, these arguments must have default values. 
  16573.  
  16574. Syntax of an Explicit Initializer by Constructor 
  16575.  
  16576. Constructors can initialize their members in two different ways. A constructor 
  16577. can use the arguments passed to it to initialize member variables in the 
  16578. constructor definition: 
  16579.  
  16580. complx( double r, double i = 0.0) {re = r; im = i;}
  16581.  
  16582. Or a constructor can have an initializer list within the definition but prior 
  16583. to the function body: 
  16584.  
  16585. complx ( double r, double i = 0) : re(r), im(i) { /* ... */ }
  16586.  
  16587. Both methods assign the argument values to the appropriate data members of the 
  16588. class. The second method must be used to initialize base classes from within a 
  16589. derived class to initialize constant and reference members and members with 
  16590. constructors. 
  16591.  
  16592. Example of Explicit Initialization by Constructor 
  16593.  
  16594. Related Information 
  16595.  
  16596. o Initializing Base Classes and Members 
  16597. o Construction Order of Derived Class Objects 
  16598. o Constructors and Destructors Overview 
  16599. o Constructors 
  16600. o C++ Classes 
  16601.  
  16602.  
  16603. ΓòÉΓòÉΓòÉ <hidden> Syntax of an Explicit Initializer by Constructor ΓòÉΓòÉΓòÉ
  16604.  
  16605. The syntax for an initializer that explicitly initializes a class object with a 
  16606. constructor is: 
  16607.  
  16608. >>ΓöÇΓöÇΓö¼ΓöÇ(ΓöÇΓöÇexpressionΓöÇΓöÇ)ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ><
  16609.   ΓööΓöÇ=ΓöÇΓöÇΓö¼ΓöÇexpressionΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÿ
  16610.      Γöé   ΓöîΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ      Γöé
  16611.      Γöé          Γöé      Γöé
  16612.      ΓööΓöÇ{ΓöÇΓöÇΓöÇΓöÇexpressionΓöÇΓö┤ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ}ΓöÇΓöÿ
  16613.                ΓööΓöÇ,ΓöÇΓöÿ
  16614.  
  16615.  
  16616. ΓòÉΓòÉΓòÉ <hidden> Example of Explicit Initialization by Constructor ΓòÉΓòÉΓòÉ
  16617.  
  16618. /************************************************************************
  16619. *
  16620.  
  16621. The following example shows the declaration and use of several constructors 
  16622. that explicitly initialize class objects: 
  16623.  
  16624.                                                                         *
  16625. ************************************************************************/
  16626.  
  16627. #include <iostream.h>
  16628. class complx
  16629. {
  16630.       double re, im ;
  16631. public:
  16632.       complx();   // default constructor
  16633.       complx(const complx& c) {re = c.re; im = c.im;}
  16634.                   // copy constructor
  16635.       complx( double r, double i = 0.0) {re = r; im = i;}
  16636.                   // constructor with default trailing argument
  16637.       void display()
  16638.       {
  16639.             cout << "re = "<< re << " im = " << im << endl;
  16640.       }
  16641. };
  16642.  
  16643. void main ()
  16644. {
  16645.       complx one(1);      // initialize with complx(double, double)
  16646.       complx two = one;   // initialize with a copy of one
  16647.                           // using complx::complx(const complx&)
  16648.       complx three = complx(3,4);  // construct complx(3,4)
  16649.                                    // directly into three
  16650.       complx four;                 // initialize with default constructor
  16651.       complx five = 5;             // complx(double, double) & construct
  16652.                                    // directly into five
  16653.       one.display();
  16654.       two.display();
  16655.       three.display();
  16656.       four.display();
  16657.       five.display();
  16658. }
  16659.  
  16660. /************************************************************************
  16661. *
  16662.  
  16663. The above example produces the following output: 
  16664.  
  16665. re = 1 im = 0
  16666. re = 1 im = 0
  16667. re = 3 im = 4
  16668. re = 0 im = 0
  16669. re = 5 im = 0
  16670.  
  16671.                                                                         *
  16672. ************************************************************************/
  16673.  
  16674.  
  16675. ΓòÉΓòÉΓòÉ 13.5.1. Initializing Base Classes and Members ΓòÉΓòÉΓòÉ
  16676.  
  16677. You can initialize immediate base classes and derived class members that are 
  16678. not inherited from base classes by specifying initializers in the constructor 
  16679. definition prior to the function body. 
  16680.  
  16681. Syntax of a Constructor Initializer 
  16682.  
  16683. In a constructor that is not inline, include the initialization list as part of 
  16684. the function definition, not as part of the class declaration. For example: 
  16685.  
  16686. class B1
  16687. {
  16688.       int b;
  16689. public:
  16690.       B1();
  16691.       B1(int i) : b(i) { /* ... */ }      // inline constructor
  16692. };
  16693. class B2
  16694. {
  16695.       int b;
  16696. protected:
  16697.       B2();
  16698.       B2(int i);                        // noninline constructor
  16699. };
  16700. // B2 constructor definition including initialization list
  16701. B2::B2(int i) : b(i) { /* ...*/ }
  16702. // ...
  16703. class D : public B1, public B2
  16704. {
  16705.       int d1, d2;
  16706. public:
  16707.       D(int i, int j) : B1(i+1), B2(), d1(i) {d2 = j;}
  16708. };
  16709.  
  16710. If you do not explicitly initialize a base class or member that has 
  16711. constructors by calling a constructor, the compiler automatically initializes 
  16712. the base class or member with a default constructor. In the above example, if 
  16713. you leave out the call B2() in the constructor of class D (as shown below), a 
  16714. constructor initializer with an empty expression list is automatically created 
  16715. to initialize B2. Thus, the constructors for class D, shown above and below, 
  16716. result in the same construction of an object of class D. 
  16717.  
  16718. class D : public B1, public B2
  16719. {
  16720.       int d1, d2;
  16721. public:
  16722.       // call B2() generated by compiler
  16723.       D(int i, int j) : B1(i+1), d1(i) {d2 = j;}
  16724. };
  16725.  
  16726. Note:  You must declare base constructors with the access specifiers public or 
  16727. protected to enable a derived class to call them. 
  16728.  
  16729. Example of Base Constructors and Derivation 
  16730.  
  16731. Related Information 
  16732.  
  16733. o Construction Order of Derived Class Objects 
  16734. o Initialization by Constructor 
  16735. o Constructors and Destructors Overview 
  16736. o Constructors 
  16737. o Member Access 
  16738.  
  16739.  
  16740. ΓòÉΓòÉΓòÉ <hidden> Syntax of a Constructor Initializer ΓòÉΓòÉΓòÉ
  16741.  
  16742. The syntax for a constructor initializer is: 
  16743.  
  16744.     ΓöîΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  16745.     Γöé           ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ   Γöé
  16746.                             Γöé   Γöé
  16747. >>ΓöÇΓöÇ:ΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇidentifierΓöÇΓö¼ΓöÇΓöÇ(ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇΓöÇ)ΓöÇΓö┤ΓöÇΓöÇ><
  16748.      ΓööΓöÇclass_nameΓöÇΓöÿ    ΓööΓöÇassignment_expressionΓöÇΓöÿ
  16749.  
  16750.  
  16751. ΓòÉΓòÉΓòÉ <hidden> Example of Base Constructors and Derivation ΓòÉΓòÉΓòÉ
  16752.  
  16753. /************************************************************************
  16754. *
  16755.  
  16756. The following example shows how to call base constructors from derived classes: 
  16757.  
  16758.                                                                         *
  16759. ************************************************************************/
  16760.  
  16761. class B1
  16762. {
  16763.       int b;
  16764. public:
  16765.       B1();
  16766.       B1(int i) : b(i) { /* ... */ }
  16767. };
  16768. class B2
  16769. {
  16770.       int b;
  16771. protected:
  16772.       B2();
  16773.       B2(int i);
  16774. };
  16775. B2::B2(int i) : b(i) { /* ... */ }
  16776. class B4
  16777. {
  16778. public:
  16779.       B4();         // public constructor for B4
  16780.       int b;
  16781. private:
  16782.       B4(int);      // private constructor for B4
  16783. };
  16784. //      .
  16785. //      .
  16786. //      .
  16787.  
  16788. class D : public B1, public B2, public B4
  16789. {
  16790.       int d1, d2;
  16791. public:
  16792.       D(int i, int j) : B1(i+1), B2(i+2) ,
  16793.                         B4(i) {d1 = i; d2 = j; }
  16794.             // error, attempt to access private constructor B4()
  16795.       D(int i, int j) : B1(i+1), B2(i+2) {d1 = i; d2 = j;}
  16796.             // valid, calls public constructor for B4
  16797. };
  16798.  
  16799.  
  16800. ΓòÉΓòÉΓòÉ 13.5.2. Construction Order of Derived Class Objects ΓòÉΓòÉΓòÉ
  16801.  
  16802. When a derived class object is created using constructors, it is created in the 
  16803. following order: 
  16804.  
  16805.  1. Virtual base classes are initialized, in the order they appear in the base 
  16806.     list. 
  16807.  2. Nonvirtual base classes are initialized, in declaration order. 
  16808.  3. Class members are initialized in declaration order (regardless of their 
  16809.     order in the initialization list). 
  16810.  4. The body of the constructor is executed. 
  16811.  
  16812. In the following code fragment, the constructor for class B1 is called before 
  16813. the member d1 is initialized. Thus, the value passed to the constructor for 
  16814. class B1 is undefined. 
  16815.  
  16816. class B1
  16817. {
  16818.       int b;
  16819. public:
  16820.       B1();
  16821.       B1(int i) {b = i;}
  16822. };
  16823. class D : public B1
  16824. {
  16825.       int d1, d2;
  16826. public:
  16827.       D(int i, int j) : d1(i), B1(d1) {d2 = j;}
  16828.       // d1 is not initialized in call B1::B1(d1)
  16829. };
  16830.  
  16831. Related Information 
  16832.  
  16833. o Initializing Base Classes and Members 
  16834. o Initialization by Constructor 
  16835. o Constructors and Destructors Overview 
  16836. o Constructors 
  16837. o Derivation 
  16838.  
  16839.  
  16840. ΓòÉΓòÉΓòÉ 13.6. Copying Class Objects ΓòÉΓòÉΓòÉ
  16841.  
  16842. You can copy one class object to another object of the same type by either 
  16843. assignment or initialization. 
  16844.  
  16845. Copy by assignment is implemented with an assignment operator function. If you 
  16846. do not define the assignment operator, it is defined as memberwise assignment. 
  16847.  
  16848. Copy by initialization is implemented with a copy constructor. If you do not 
  16849. define a copy constructor, it is defined as  memberwise initialization of 
  16850. members of its class. 
  16851.  
  16852. Memberwise assignment and memberwise initialization mean that, if a class has a 
  16853. member that is a class object, the assignment operator and copy constructor of 
  16854. that class object are used to implement assignment and initialization of the 
  16855. member. 
  16856.  
  16857. Restrictions: 
  16858.  
  16859. A default assignment operator cannot be generated for a class that has: 
  16860.  
  16861. o A nonstatic constant or reference data member 
  16862. o A nonstatic data member or base class whose assignment operator is not 
  16863.   accessible 
  16864. o A nonstatic data member or base class with no assignment operator and for 
  16865.   which a default assignment operator cannot be generated 
  16866.  
  16867. A default copy constructor cannot be generated for a class that has: 
  16868.  
  16869. o A nonstatic data member or base class whose copy constructor is not 
  16870.   accessible 
  16871. o A nonstatic data member or base class with no copy constructor and for which 
  16872.   a default copy constructor cannot be generated 
  16873.  
  16874. Related Information 
  16875.  
  16876. o Copy by Assignment 
  16877. o Copy by Initialization 
  16878. o Constructors and Destructors Overview 
  16879. o Constructors 
  16880. o Overloaded Assignment 
  16881.  
  16882.  
  16883. ΓòÉΓòÉΓòÉ 13.6.1. Copy by Assignment ΓòÉΓòÉΓòÉ
  16884.  
  16885. If you do not define an assignment operator and one is required, a default 
  16886. assignment operator is defined. If you do not define an assignment operator and 
  16887. one is not required, a default assignment operator is declared but not defined. 
  16888. If an assignment operator that takes a single argument of a class type exists 
  16889. for a class, a default assignment operator is not generated. 
  16890.  
  16891. Copy by assignment is used only in assignment. 
  16892.  
  16893. You can define an assignment operator for a class with a single argument that 
  16894. is a constant reference to that class type, only if all its base classes and 
  16895. members have assignment operators that accept constant arguments. For example: 
  16896.  
  16897. class B1
  16898. {
  16899. public:
  16900.       B1& operator=(const B1&);
  16901. };
  16902. class D: public B1
  16903. {
  16904. public:
  16905.       D& operator=(const D&);
  16906. };
  16907. D& D::operator=(const D& dobj) {D dobj2 = dobj;
  16908.                                        return dobj2;}
  16909.  
  16910. Otherwise, you can define an assignment operator for a class with a single 
  16911. argument that is a reference to that class type. For example: 
  16912.  
  16913. class Z
  16914. {
  16915. public:
  16916.       Z& operator=( Z&);
  16917. };
  16918. Z& Z::operator=(Z& zobj) {Z zobj2 = zobj;
  16919.                                         return zobj2;}
  16920.  
  16921. The default assignment operator for a class is a public class member. The 
  16922. return type is a reference to the class type it is a member of. 
  16923.  
  16924. Related Information 
  16925.  
  16926. o Assignment Expression 
  16927. o Overloaded Assignment 
  16928. o Copy by Initialization 
  16929. o C++ Classes 
  16930.  
  16931.  
  16932. ΓòÉΓòÉΓòÉ 13.6.2. Copy by Initialization ΓòÉΓòÉΓòÉ
  16933.  
  16934. You can define a copy constructor for a class. If you do not define a copy 
  16935. constructor and one is required, a default copy constructor is defined. If you 
  16936. do not define a copy constructor, and one is not required, a default copy 
  16937. constructor is declared but not defined. If a class has a copy constructor 
  16938. defined, a default copy constructor is not generated. 
  16939.  
  16940. Copy by initialization is used only in initialization. 
  16941.  
  16942. You can define a copy constructor for a class with a single argument that is a 
  16943. constant reference to a class type only if all its base classes and members 
  16944. have copy constructors that accept constant arguments. For example: 
  16945.  
  16946. class B1
  16947. {
  16948. public:
  16949.       B1(const B1&) { /* ... */ }
  16950. };
  16951.  
  16952. class D: public B1
  16953. {
  16954. public:
  16955.       D(const D&);
  16956. };
  16957. D::D(const D& dobj):B1(dobj) { /* ... */ }
  16958.  
  16959. Otherwise, you can define a copy constructor with a single reference to a class 
  16960. type argument. For example: 
  16961.  
  16962. class Z
  16963. {
  16964. public:
  16965.       Z(Z&);
  16966. };
  16967. Z::Z(Z&) { /* ...*/ }
  16968.  
  16969. The default copy constructor for a class is a public class member. 
  16970.  
  16971. Related Information 
  16972.  
  16973. o Initialization by Constructor 
  16974. o Constructors 
  16975. o Copy by Assignment 
  16976. o C++ Classes 
  16977.  
  16978.  
  16979. ΓòÉΓòÉΓòÉ 14. Inheritance ΓòÉΓòÉΓòÉ
  16980.  
  16981. In C++, you can create classes from existing classes using the object-oriented 
  16982. programming technique called inheritance. Inheritance allows you to define an 
  16983. is a relationship between classes. When members are inherited, they can be used 
  16984. as if they are members of the class that inherits them. 
  16985.  
  16986. This chapter introduces inheritance and describes: 
  16987.  
  16988. o Inheritance Overview 
  16989. o Derivation 
  16990. o Inherited Member Access 
  16991. o Multiple Inheritance 
  16992. o Virtual Functions 
  16993. o Abstract Classes 
  16994.  
  16995. Related Information 
  16996.  
  16997. o C++ Classes 
  16998. o C++ Class Members and Friends 
  16999.  
  17000.  
  17001. ΓòÉΓòÉΓòÉ 14.1. Inheritance Overview ΓòÉΓòÉΓòÉ
  17002.  
  17003. C++ implements inheritance through the mechanism of derivation. Derivation 
  17004. allows you to reuse code by creating new classes, called derived classes, that 
  17005. inherit properties from one or more existing classes, called base classes. A 
  17006. derived class inherits the properties, including data and function members, of 
  17007. its base class. You can also add new data members and member functions to the 
  17008. derived class. You can modify the implementation of existing member functions 
  17009. or data by overriding base class member functions or data in the newly derived 
  17010. class. 
  17011.  
  17012. Multiple inheritance allows you to create a derived class that inherits 
  17013. properties from more than one base class. 
  17014.  
  17015. Because a derived class inherits members from all its base classes, ambiguities 
  17016. can result. For example, if two base classes have a member with the same name, 
  17017. the derived class cannot implicitly differentiate between the two members. Note 
  17018. that, when you are using multiple inheritance, the access to names of base 
  17019. classes may be ambiguous. 
  17020.  
  17021. Examples of Single and Multiple Inheritance 
  17022.  
  17023. Multiple inheritance allows you to have more than one base class for a single 
  17024. derived class. You can create an interconnected inheritance graph of inherited 
  17025. classes by using derived classes as base classes for other derived classes. You 
  17026. can build an inheritance graph through the process of specialization, in which 
  17027. derived classes are more specialized than their base classes. You can also work 
  17028. in the reverse direction and build an inheritance graph through generalization. 
  17029. If you have a number of related classes that share a group of properties, you 
  17030. can generalize and build a base class to embody them. The group of related 
  17031. classes becomes the derived classes of the new base class. 
  17032.  
  17033. A direct base class is a base class that appears directly as a base specifier 
  17034. in the declaration of its derived class. A direct base class is analogous to a 
  17035. parent in a hierarchical graph. 
  17036.  
  17037. An indirect base class is a base class that does not appear directly in the 
  17038. declaration of the derived class but is available to the derived class through 
  17039. one of its base classes. An indirect base class is analogous to a grandparent 
  17040. or great grandparent or great-great grandparent in a hierarchical graph. For a 
  17041. given class, all base classes that are not direct base classes are indirect 
  17042. base classes. 
  17043.  
  17044. Polymorphic functions are functions that can be applied to objects of more than 
  17045. one type. In C++, polymorphic functions are implemented in two ways: 
  17046.  
  17047. o Overloaded functions are statically bound at compile time, as discussed in 
  17048.   Overloading Functions. 
  17049.  
  17050. o C++ provides virtual functions. A virtual function is a function that can be 
  17051.   called for a number of different user-defined types that are related through 
  17052.   derivation. Virtual functions are bound dynamically at run time. 
  17053.  
  17054. Typically, a base class has several derived classes, each requiring its own 
  17055. customized version of a particular operation. It is difficult for a base class 
  17056. to implement member functions that are useful for all of its derived classes. A 
  17057. base class would have to determine which derived class an object belonged to 
  17058. before it could execute the applicable code for that object. When a virtual 
  17059. function is called, the compiler executes the function implementation 
  17060. associated with the object that the function is called for. The implementation 
  17061. of the base class is only a default that is used when the derived class does 
  17062. not contain its own implementation. 
  17063.  
  17064. Related Information 
  17065.  
  17066. o Derivation 
  17067. o Multiple Inheritance 
  17068. o Virtual Functions 
  17069. o C++ Classes 
  17070. o C++ Class Members and Friends 
  17071.  
  17072.  
  17073. ΓòÉΓòÉΓòÉ 14.1.1. Examples of Single and Multiple Inheritance ΓòÉΓòÉΓòÉ
  17074.  
  17075. Suppose you have defined a shape class to describe and operate on geometric 
  17076. shapes. Now suppose you want to define a circle class. Because you have 
  17077. existing code that operates on the shape class, you can use inheritance to 
  17078. create the circle class. You can redefine operations in the derived circle 
  17079. class that were originally defined in the shape base class. When you manipulate 
  17080. an object of the circle class, these redefined function implementations are 
  17081. used. For example: 
  17082.  
  17083. class shape
  17084. {
  17085.       char* name;
  17086.       int xpoint, ypoint;
  17087. public:
  17088.       virtual void rotate(int);
  17089.       virtual void draw();
  17090.       void display() const;
  17091. };
  17092.  
  17093. class circle: public shape      // derive class circle from
  17094. class shape
  17095. {
  17096.       int xorigin, yorigin;
  17097.       int radius;
  17098. public:
  17099.       void rotate(int);
  17100.       void draw();
  17101.       void display() const;
  17102. };
  17103.  
  17104. In the above example, class circle inherits the data members name, xpoint and 
  17105. ypoint, as well as the member functions display(), rotate(), and draw() from 
  17106. class shape. Because the member functions rotate() and draw() are declared in 
  17107. class shape with the keyword virtual, you can provide an alternative 
  17108. implementation for them in class circle. You can also provide an alternative 
  17109. implementation for the nonvirtual member function display() in class circle. 
  17110. When you manipulate an argument of type circle using a pointer to shape, and 
  17111. call a virtual member function, the member function defined in the derived 
  17112. class overrides the base-class member function. A similar call to a nonvirtual 
  17113. member function will call the member function defined in the base class. In 
  17114. addition to inheriting the members of class shape, class circle has declared 
  17115. its own data members, xorigin, yorigin, and radius. 
  17116.  
  17117. The key difference between virtual and nonvirtual member functions is that, 
  17118. when you treat the circle class as if it were a shape, the implementations of 
  17119. the virtual functions rotate() and draw() defined in class circle are used, 
  17120. rather than those originally defined in class shape. Because display() is a 
  17121. nonvirtual member function, the original implementation of display() defined in 
  17122. class shape is used. 
  17123.  
  17124. Multiple inheritance allows you to create a derived class that inherits 
  17125. properties from more than one base class. For example, in addition to the shape 
  17126. class, described above, you could also have a symbol class. Because a circle is 
  17127. both a shape and a symbol, you can use multiple inheritance to reflect this 
  17128. relationship. If the circle class is derived from both the shape and symbol 
  17129. classes, the circle class inherits properties from both classes. 
  17130.  
  17131. class symbol
  17132. {
  17133.       char* language;
  17134.       char letter;
  17135.       int number;
  17136. public:
  17137.       virtual void write();
  17138.       virtual void meaning();
  17139. };
  17140. class shape
  17141. {
  17142.       char* name;
  17143.       int xpoint, ypoint;
  17144. public:
  17145.       virtual void rotate(int);
  17146.       virtual void draw();
  17147.       void display() const;
  17148. };
  17149. class circle: public symbol, public shape
  17150. {
  17151.       int xorigin, yorigin;
  17152.       int radius;
  17153. public:
  17154.       void rotate(int);
  17155.       void draw ();
  17156.       void write();
  17157.       void meaning();
  17158.       void display() const;
  17159. };
  17160.  
  17161. In the above example, class circle inherits the members name, xpoint, ypoint, 
  17162. display(), rotate(), and draw() from class shape and also inherits the members 
  17163. language, letter, number, write(), and meaning() from class symbol. 
  17164.  
  17165.  
  17166. ΓòÉΓòÉΓòÉ 14.2. Derivation ΓòÉΓòÉΓòÉ
  17167.  
  17168. Inheritance is implemented in C++ through the mechanism of derivation. 
  17169. Derivation allows you to derive a class, called a derived class, from another 
  17170. class, called a base class. 
  17171.  
  17172. In the declaration of a derived class, you list the base classes of the derived 
  17173. class. The derived class inherits its members from these base classes. All 
  17174. classes that appear in the list of base classes must be previously defined 
  17175. classes. 
  17176.  
  17177. Syntax of a Derived Class 
  17178.  
  17179. Incompletely declared classes are not allowed in base lists. For example: 
  17180.  
  17181. class X; // incomplete declaration of class X
  17182. class Y: public X      // error
  17183. {
  17184. };
  17185.  
  17186. When you derive a class, the derived class inherits class members of the base 
  17187. class. You can refer to inherited members (base class members) as if they were 
  17188. members of the derived class. 
  17189.  
  17190. If you redefine base class members in the derived class, you can still refer to 
  17191. the base class members by using the :: (scope resolution) operator. 
  17192.  
  17193. You can manipulate a derived class object as if it were a base class object. 
  17194. You can use a pointer or a reference to a derived class object in place of a 
  17195. pointer or reference to its base class. For example, you can pass a pointer or 
  17196. reference to a derived class object D to a function expecting a pointer or 
  17197. reference to the base class of D. You do not need to use an explicit cast to 
  17198. achieve this; a standard conversion is performed. You can implicitly convert a 
  17199. pointer to a derived class to point to a base class. You can also implicitly 
  17200. convert a reference to a derived class to a reference to a base class. 
  17201.  
  17202. The reverse case is not allowed. You cannot implicitly convert a pointer or a 
  17203. reference to a base class object to a pointer or reference to a derived class. 
  17204.  
  17205. Examples of Derived Classes 
  17206.  
  17207. If a member of a derived class and a member of a base class have the same name, 
  17208. the base class member is hidden in the derived class. If a member of a derived 
  17209. class has the same name as a base class, the base class name is hidden in the 
  17210. derived class. In both cases, the name of the derived class member is called 
  17211. the dominant name. 
  17212.  
  17213. Related Information 
  17214.  
  17215. o Inheritance Overview 
  17216. o C++ Classes 
  17217. o Scope Resolution Operator 
  17218. o Multiple Inheritance 
  17219.  
  17220.  
  17221. ΓòÉΓòÉΓòÉ <hidden> Examples of Derived Classes ΓòÉΓòÉΓòÉ
  17222.  
  17223. /************************************************************************
  17224. *
  17225. You can refer to inherited members (base class members) as if they were members 
  17226. of the derived class: 
  17227.  
  17228.                                                                         *
  17229. ************************************************************************/
  17230.  
  17231. class base
  17232. {
  17233. public:
  17234.       int a,b;
  17235. };
  17236. class derived : public base
  17237. {
  17238. public:
  17239.       int c;
  17240. };
  17241. void main()
  17242. {
  17243.       derived d;
  17244.       d.a = 1;      // base::a
  17245.       d.b = 2;      // base::b
  17246.       d.c = 3;      // derived::c
  17247. }
  17248.  
  17249. /************************************************************************
  17250. *
  17251.  
  17252. The derived class can also add new class members and redefine existing base 
  17253. class members. In the above example, the two inherited members, a and b, of the 
  17254. derived class d, in addition to the derived class member c, are assigned 
  17255. values. For example: 
  17256.  
  17257.                                                                         *
  17258. ************************************************************************/
  17259.  
  17260. #include <iostream.h>
  17261. class base
  17262. {
  17263. public:
  17264.       char* name;
  17265.       void display(char* i) {cout << i << endl;}
  17266. };
  17267. class derived : public base
  17268. {
  17269. public:
  17270.       char* name;
  17271.       void display(char* i){cout << i << endl;}
  17272. };
  17273. void main()
  17274. {
  17275.       derived d;                    // create derived class object
  17276.       d.name = "Derived Class";     // assignment to derived::name
  17277.       d.base::name = "Base Class";  // assignment to base::name
  17278.  
  17279.       // call derived::display(derived::name)
  17280.       d.display(d.name);
  17281.  
  17282.       // call base::display(base::name)
  17283.       d.base::display(d.base::name);
  17284. }
  17285.  
  17286. /************************************************************************
  17287. *
  17288.  
  17289. In the following example, d, a pointer to a derived class object is assigned to 
  17290. bptr, a pointer to a base class object. A call is made to display() using bptr. 
  17291. Even though bptr has a type of pointer to base, in the body of display() the 
  17292. name member of derived is manipulated: 
  17293.  
  17294.                                                                         *
  17295. ************************************************************************/
  17296.  
  17297. #include <iostream.h>
  17298. class base
  17299. {
  17300. public:
  17301.       char* name;
  17302.       void display(char* i) {cout << i << endl;}
  17303. };
  17304. class derived : public base
  17305. {
  17306. public:
  17307.       char* name;
  17308.       void display(char* i){cout << i << endl;}
  17309. };
  17310. void main()
  17311. {
  17312.       derived d;
  17313.  
  17314.       // standard conversion from derived* to base*
  17315.       base* bptr = ΓöÇ"ΓöÇ;
  17316.  
  17317.       // call base::display(base::name)
  17318.       bptr->display(bptr->name);
  17319. }
  17320.  
  17321.  
  17322. ΓòÉΓòÉΓòÉ <hidden> Syntax of a Derived Class Declaration ΓòÉΓòÉΓòÉ
  17323.  
  17324. The syntax for the list of base classes is: 
  17325.  
  17326. >>ΓöÇΓöÇderived-classΓöÇΓöÇ:ΓöÇΓöÇ>
  17327.   ΓöîΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  17328.                              Γöé
  17329. >ΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇcomplete-class-nameΓöÇΓö┤ΓöÇΓöÇ><
  17330.    Γö£ΓöÇvirtualΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  17331.    Γöé      Γö£ΓöÇpublicΓöÇΓöÇΓöÇΓöÇΓöñ   Γöé
  17332.    Γöé      Γö£ΓöÇprivateΓöÇΓöÇΓöÇΓöñ   Γöé
  17333.    Γöé      ΓööΓöÇprotectedΓöÇΓöÿ   Γöé
  17334.    ΓööΓöÇΓö¼ΓöÇpublicΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÿ
  17335.     Γö£ΓöÇprivateΓöÇΓöÇΓöÇΓöñ  ΓööΓöÇvirtualΓöÇΓöÿ
  17336.     ΓööΓöÇprotectedΓöÇΓöÿ
  17337.  
  17338. The qualified-class-specifier must be a class that has been previously declared 
  17339. in a class declaration as described in Declaring Class Objects. Access 
  17340. specifiers are described in Member Access. 
  17341.  
  17342. The virtual keyword can be used to declare virtual base classes. 
  17343.  
  17344. The following example shows the declaration of the derived class D and the base 
  17345. classes V, B1, and B2. The class B1 is both a base class and a derived class 
  17346. because it is derived from class V and is a base class for D. 
  17347.  
  17348. class V { /* ... */ };
  17349. class B1 : virtual public V { /* ... */ };
  17350. class B2 { /* ... */ };
  17351. class D : public B1, private B2 { /* ... */ };
  17352.  
  17353.  
  17354. ΓòÉΓòÉΓòÉ 14.3. Inherited Member Access ΓòÉΓòÉΓòÉ
  17355.  
  17356. Access specifiers, as described in Member Access, control the level of access 
  17357. to noninherited class members. The access for an inherited member is controlled 
  17358. in three ways: 
  17359.  
  17360. o When you declare a member in a base class, you can specify a level of access 
  17361.   using the keywords public, private, and protected. 
  17362. o When you derive a class, you can specify the access level for the base class 
  17363.   in the base list. 
  17364. o You can also restore the access level of inherited members. See Derivation 
  17365.   Access of Base Classes for an example. 
  17366.  
  17367. Resolution of member names does not depend on the level of access associated 
  17368. with each class member. Consider the following example: 
  17369.  
  17370. class A {
  17371.       private:
  17372.             int a;
  17373. };
  17374. class B {
  17375.       public:
  17376.             int a;
  17377. };
  17378. class C : public A, public B {
  17379.       void f() { a = 0; }  // ambiguous - is it A::a or B::a?
  17380. };
  17381.  
  17382. In this example, class A has a private member a, and class B has a public 
  17383. member a. Class C is derived from both A and B. C does not have access to A::a, 
  17384. but a in the body of f() can still resolve to either A::a or B::a. Thus, a is 
  17385. ambiguous in the body of f(). 
  17386.  
  17387. If a class is derived publicly from a base class, a protected static base class 
  17388. member can be accessed by members and friends of any classes derived from that 
  17389. base class. A protected nonstatic base class member can be accessed by members 
  17390. and friends of any classes derived from that base class by using one of the 
  17391. following: 
  17392.  
  17393. o A pointer to a directly or indirectly derived class 
  17394. o A reference to a directly or indirectly derived class 
  17395. o An object of a directly or indirectly derived class 
  17396.  
  17397. If a class is derived privately from a base class, all protected base class 
  17398. members become private members of the derived class. 
  17399.  
  17400. Examples of Inherited Member Access Rules 
  17401.  
  17402. Related Information 
  17403.  
  17404. o Derivation Access of Base Classes 
  17405. o Access Declarations 
  17406. o Access Resolution 
  17407. o Member Access 
  17408. o Derivation 
  17409. o C++ Classes 
  17410.  
  17411.  
  17412. ΓòÉΓòÉΓòÉ 14.3.1. Derivation Access of Base Classes ΓòÉΓòÉΓòÉ
  17413.  
  17414. When you declare a derived class, an access specifier can precede each base 
  17415. class in the base list of the derived class. This does not alter the access 
  17416. attributes of the individual members of a base class as seen by the base class, 
  17417. but allows the derived class to restore the access attributes of the members of 
  17418. a base class. 
  17419.  
  17420. You can derive classes using any of the three access specifiers: 
  17421.  
  17422. o In a public base class, public and protected members of the base class remain 
  17423.   public and protected members of the derived class. 
  17424. o In a private base class, public and protected members of the base class 
  17425.   become private members of the derived class. 
  17426. o In a protected base class, public and protected members of the base class are 
  17427.   protected members of the derived class. 
  17428.  
  17429. In all cases, private members of the base class remain private. Private members 
  17430. of the base class cannot be used by the derived class unless friend 
  17431. declarations within the base class explicitly grant access to them. 
  17432.  
  17433. You can use both a structure and a class as base classes in the base list of a 
  17434. derived class declaration. If the base class is declared with the keyword 
  17435. class, its default access specifier in the base list of a derived class is 
  17436. private. If the base class is declared with the keyword struct, its default 
  17437. access specifier in the base list of a derived class is public. 
  17438.  
  17439. Examples of Public and Private Derivation 
  17440.  
  17441. Members and friends of a class can implicitly convert a pointer to an object of 
  17442. that class to a pointer to either: 
  17443.  
  17444. o A direct private base class 
  17445. o A protected base class (either direct or indirect) 
  17446.  
  17447. Related Information 
  17448.  
  17449. o Access Declarations 
  17450. o Access Resolution 
  17451. o Member Access 
  17452. o Derivation 
  17453. o C++ Classes 
  17454.  
  17455.  
  17456. ΓòÉΓòÉΓòÉ <hidden> Examples of Public and Private Derivation ΓòÉΓòÉΓòÉ
  17457.  
  17458. In the following example, class d is derived publicly from class b. Class b is 
  17459. declared a public base class by this declaration. 
  17460.  
  17461. class b
  17462. {
  17463. // ...
  17464. };
  17465. class d : public b // public derivation
  17466. {
  17467. // ...
  17468. };
  17469. In the following example, private derivation is used by default because no 
  17470. access specifier is used in the base list: 
  17471.  
  17472. struct bb
  17473. {
  17474. // ...
  17475. };
  17476. class dd : bb // private derivation
  17477. {
  17478. // ...
  17479. };
  17480.  
  17481.  
  17482. ΓòÉΓòÉΓòÉ 14.3.2. Access Declarations ΓòÉΓòÉΓòÉ
  17483.  
  17484. You can restore access to members of a base class using an access declaration. 
  17485. It allows you to change the access of a public member of a private or protected 
  17486. base class back to public. You can also change the access of a protected member 
  17487. of a private base class back to protected. Access is adjusted by using the base 
  17488. class member qualified name in the public or protected declarations of the 
  17489. derived class. 
  17490.  
  17491. You only use access declarations to restore base class access. You cannot 
  17492. change the access to a member to give it more access than it was originally 
  17493. declared with. You cannot change the access of a private member to public or to 
  17494. protected. You cannot change the access of a protected member to public. 
  17495.  
  17496. An access declaration cannot be used to restrict access to a member that is 
  17497. accessible in a base class. 
  17498.  
  17499. It is redundant to use an access declaration to change the access to a public 
  17500. member of a public base class to public, or to change the access to a protected 
  17501. member of a protected base class to protected. 
  17502.  
  17503. Examples of Access Declarations 
  17504.  
  17505. Access declarations can only be used to adjust the access of a member of a base 
  17506. class. The base class that an access declaration appears in can be directly or 
  17507. indirectly inherited by the derived class. 
  17508.  
  17509. You cannot adjust the access to a base class member if a member with the same 
  17510. name exists in a class derived from that base class. 
  17511.  
  17512. If you use an access declaration to adjust the access to an overloaded 
  17513. function, the access is adjusted for all functions with that name in the base 
  17514. class. 
  17515.  
  17516. Related Information 
  17517.  
  17518. o Derivation Access of Base Classes 
  17519. o Access Resolution 
  17520. o Member Access 
  17521. o Derivation 
  17522. o Overloading Functions 
  17523. o C++ Classes 
  17524.  
  17525.  
  17526. ΓòÉΓòÉΓòÉ <hidden> Examples of Access Declarations ΓòÉΓòÉΓòÉ
  17527.  
  17528. /************************************************************************
  17529. *
  17530.  
  17531. In the following example, the member b of the base class base is declared 
  17532. public in its base class declaration. Class derived is derived privately from 
  17533. class base. The access declaration in the public section of class derived 
  17534. restores the access level of the member b back to public. 
  17535.  
  17536.                                                                         *
  17537. ************************************************************************/
  17538.  
  17539. #include <iostream.h>
  17540. class base
  17541. {
  17542.       char a;
  17543. public:
  17544.       char c, b;
  17545.       void bprint();
  17546. };
  17547.  
  17548. class derived: private base
  17549. {
  17550.       char d;
  17551. public:
  17552.       char e;
  17553.       base::b;            // restore access to b in derived
  17554.       void dprint();
  17555.       derived(char ch) { base::b = ch; }
  17556. };
  17557.  
  17558. void print(derived& d)
  17559. {
  17560.       cout << " Here is d " << d.b << endl;
  17561. }
  17562.  
  17563. void main()
  17564. {
  17565.       derived obj('c');
  17566.       print(obj);
  17567. }
  17568.  
  17569. /************************************************************************
  17570. *
  17571.  
  17572. The external function print(derived&) can use the member b of base because the 
  17573. access of b has been restored to public. The external function print(derived&) 
  17574. can also use the members e and dprint() because they are declared with the 
  17575. keyword public in the derived class. The derived class member dprint() can use 
  17576. the members of its own class, d and e, in addition to the inherited members, b, 
  17577. c, and bprint(), that are declared with the keyword public in the base class. 
  17578. The base class member bprint() can use all the members of its own class, a, b, 
  17579. and c. 
  17580.  
  17581. You can also use an access declaration in a nested class. For example: 
  17582.  
  17583. class B
  17584. {
  17585. public:
  17586.       class N          // nested class
  17587.       {
  17588.       public:
  17589.             int i;     // public member
  17590.       };
  17591. };
  17592. class D: private B::N  // derive privately
  17593. {
  17594. public:
  17595.       B::N::i;         // restores access to public
  17596. };
  17597.  
  17598. You cannot convert a pointer to a derived class object to a pointer to a base 
  17599. class object if the base class is private or protected. For example: 
  17600.  
  17601. class B { /* ... */ };
  17602. class D : private B { /* ... */ };      // private base
  17603. class
  17604. void main ()
  17605. {
  17606.       D d;
  17607.       B* ptr;
  17608.       ptr = ΓöÇ"ΓöÇ;      // error
  17609. }
  17610.  
  17611.                                                                         *
  17612. ************************************************************************/
  17613.  
  17614.  
  17615. ΓòÉΓòÉΓòÉ 14.3.3. Access Resolution ΓòÉΓòÉΓòÉ
  17616.  
  17617. Access resolution is the process by which the accessibility of a particular 
  17618. class member is determined. Accessibility is dependent on the context. For 
  17619. example, a class member can be accessible in a member function but inaccessible 
  17620. at file scope. The following describes the access resolution procedure used by 
  17621. the compiler. 
  17622.  
  17623. In general, two scopes must be established before access resolution is applied. 
  17624. These scopes reduce an expression or declaration into a simplified construct to 
  17625. which the access rules are applied. Access rules are described in Member 
  17626. Access. These scopes are: 
  17627.  
  17628. Call scope         The scope that encloses the expression or declaration that 
  17629.                    uses the class member. 
  17630. Reference scope    The scope that identifies the class. 
  17631.  
  17632. For example, in the following code: 
  17633.  
  17634. class B { int member; };        // declaration
  17635. class A : B {}                  // declaration
  17636. void main()
  17637. {
  17638.       A aobject;                // declaration
  17639.       aobject.member = 10;      // expression
  17640. }
  17641.  
  17642. the reference scope for member is the type of aobject, that is class type  A. 
  17643.  
  17644. Reference scope is chosen by simplifying the expression (or declaration) 
  17645. containing the member. An expression can be thought of as being reduced to a 
  17646. simple expression of the form obj.member where obj is the reference scope. 
  17647. Reference scope is selected as follows: 
  17648.  
  17649. o If the member is qualified with . or ->, the reference scope is the type of 
  17650.   the object that is immediately to the left of the . or -> operator closest to 
  17651.   the member. Unqualified members are treated as if they are qualified with 
  17652.   From heading: "This this Pointer" this->. 
  17653.  
  17654. o If the member is a type member or a static member and is qualified with :: 
  17655.   (the scope resolution operator), the reference scope is the type immediately 
  17656.   to the left of the :: operator closest to the member. 
  17657.  
  17658. o Otherwise, the reference scope is the call scope. 
  17659.  
  17660. The call scope and the reference scope determine the accessibility of a class 
  17661. member. Once these scopes are resolved, the effective access of the member is 
  17662. determined. Effective access is the access of the member as it is seen from the 
  17663. reference scope. It is determined by taking the original access of the member 
  17664. in its scope as the effective access and changing it as the class hierarchy is 
  17665. traversed from the member's class to the reference scope. Effective access is 
  17666. altered as the class hierarchy is traversed for each derivation by the 
  17667. following: 
  17668.  
  17669. o The derivation access of a base class (see Derivation Access of Base Classes) 
  17670. o Access declarations that are applied to the members (see Access Declarations) 
  17671. o Friendships that are granted to the call scope (see Member Access) 
  17672.  
  17673. After effective access is determined for a member, the access rules are applied 
  17674. as if the effective access were the original access of the member. A member is 
  17675. only accessible if the access rules say that it is. 
  17676.  
  17677. Example of Access Resolution 
  17678.  
  17679. Related Information 
  17680.  
  17681. o Derivation Access of Base Classes 
  17682. o Access Declarations 
  17683. o Member Access 
  17684. o Derivation 
  17685. o Overloading Functions 
  17686. o Scope Resolution Operator 
  17687. o C++ Classes 
  17688.  
  17689.  
  17690. ΓòÉΓòÉΓòÉ <hidden> Example of Access Resolution ΓòÉΓòÉΓòÉ
  17691.  
  17692. The following example demonstrates the access resolution procedure. 
  17693.  
  17694. class A
  17695. {
  17696. public:
  17697.       int a;
  17698. };
  17699. class B : private A
  17700. {
  17701.       friend void f (B*);
  17702. };
  17703. void f(B* b)
  17704. {
  17705.       b->a = 10; // is 'a' accessible to f(B*) ?
  17706. }
  17707.  
  17708. The following steps occur to determine the accessibility of A::a in f(B*): 
  17709.  
  17710.  1. The call scope and reference scope of the expression b->a are determined: 
  17711.  
  17712.     a. The call scope is the function f(B*). 
  17713.     b. The reference scope is class B. 
  17714.  
  17715.  2. The effective access of member a is determined: 
  17716.  
  17717.     a. Because the original access of the member a is public in class A, the 
  17718.        initial effective access of a is public. 
  17719.     b. Because B inherits from A privately, the effective access of a inside 
  17720.        class B is private. 
  17721.     c. Because class B is the reference scope, the effective access procedure 
  17722.        stops here. The effective access of a is private. 
  17723.  
  17724.  3. The access rules are applied. The rules state that a private member can be 
  17725.     accessed by a friend or a member of the member's class. Because f(B*) is a 
  17726.     friend of class B, f(B*) can access the private member a. 
  17727.  
  17728.  
  17729. ΓòÉΓòÉΓòÉ <hidden> Examples of Inherited Member Access Rules ΓòÉΓòÉΓòÉ
  17730.  
  17731. /************************************************************************
  17732. *
  17733.  
  17734. The following example demonstrates inherited member access rules. 
  17735.  
  17736.                                                                         *
  17737. ************************************************************************/
  17738.  
  17739. class B
  17740. {
  17741.       int a;
  17742. public:
  17743.       int b,c;
  17744.       void f(int) {}
  17745. protected:
  17746.       int d;
  17747.       void g(int) {}
  17748. };
  17749.  
  17750. class D1 : public B
  17751. {
  17752.       int a;
  17753. public:
  17754.       int b;
  17755.       void h(int i )
  17756.       {
  17757.             g(i);              // valid, protected B::g(int)
  17758.             B::b = 10;         // valid, B::b (not local b)
  17759.             d = 5 ;            // valid, protected B::d
  17760.       }
  17761. };
  17762.  
  17763. class D2 : private B
  17764. {
  17765.       int e;
  17766. public:
  17767.       B::c;                         // modify access to B::c
  17768.       void h(int i) { d = 5; }      // valid,protected B::d
  17769. };
  17770.  
  17771. void main( )
  17772. {
  17773.  
  17774.       int i= 1;      // declare and initialize local variable
  17775.       D1 d1;         // create object of class d1
  17776.       D2 d2;         // create object of class d2
  17777.  
  17778.       d1.a = 5;      // error, D1::a is private in class D1
  17779.       d2.b = 10;     // error, B::b is inherited private to
  17780.                      // derived class D2
  17781.       d2.c = 5;      // valid, modified access from private to public
  17782.       d2.B::c = 5;   // valid, public B::c
  17783.       d1.c = 5;      // valid, B::c is inherited publicly
  17784.       d1.d = 5;      // error, B::d is protected in base class
  17785.       d2.e = 10;     // error, private D2::e
  17786.       d1.g(i);       // error, g(int) is protected in base class
  17787.       d1.h(i);       // valid
  17788.       d2.h(i);       // valid
  17789. }
  17790.  
  17791. /************************************************************************
  17792. *
  17793.  
  17794. Access rules for multiple base classes are described in Multiple Access. 
  17795.  
  17796.                                                                         *
  17797. ************************************************************************/
  17798.  
  17799.  
  17800. ΓòÉΓòÉΓòÉ 14.4. Multiple Inheritance ΓòÉΓòÉΓòÉ
  17801.  
  17802. You can derive a class from more than one base class. Deriving a class from 
  17803. more than one direct base class is called multiple inheritance. In the 
  17804. following example, classes A, B, and C are direct base classes for the derived 
  17805. class X: 
  17806.  
  17807. class A { /* ... */ };
  17808. class B { /* ... */ };
  17809. class C { /* ... */ };
  17810. class X : public A, private B, public C { /* ... */ };
  17811.  
  17812. The order of derivation is relevant only to determine the order of default 
  17813. initialization by constructors and cleanup by destructors. For more 
  17814. information, see Initialization by Constructor. 
  17815.  
  17816. A direct base class cannot appear in the base list of a derived class more than 
  17817. once: 
  17818.  
  17819. class B1 { /* ... */ };                   // direct base
  17820. class
  17821. class D : public B1, private B1 { /* ... */ }; // error
  17822.  
  17823. However, a derived class can inherit an indirect base class more than once, as 
  17824. shown in the following example: 
  17825.  
  17826. class L { /* ... */ };                  // indirect base
  17827. class
  17828. class B2 : public L { /* ... */ };
  17829. class B3 : public L { /* ... */ };
  17830. class D : public B2, public B3 { /* ... */ }; // valid
  17831.  
  17832. In the above example, class D inherits the indirect base class L once through 
  17833. class B1 and once through class B2. However, this may lead to ambiguities 
  17834. because two objects of class L exist, and both are accessible through class D. 
  17835. You can avoid this ambiguity by referring to class L using a qualified class 
  17836. name, for example,  B2::L  or  B3::L . 
  17837.  
  17838. You can also avoid this ambiguity by using the base specifier virtual to 
  17839. declare a base class. 
  17840.  
  17841. Examples of Single and Multiple Inheritance 
  17842.  
  17843. Related Information 
  17844.  
  17845. o Virtual Base Classes 
  17846. o Multiple Access 
  17847. o Inheritance Overview 
  17848. o Derivation 
  17849. o Initialization by Constructor 
  17850. o C++ Classes 
  17851.  
  17852.  
  17853. ΓòÉΓòÉΓòÉ 14.4.1. Virtual Base Classes ΓòÉΓòÉΓòÉ
  17854.  
  17855. If you have an inheritance graph in which two or more derived classes have a 
  17856. common base class, you can use a virtual base class to ensure that the two 
  17857. classes share a single instance of the base class. 
  17858.  
  17859. In the following example, an object of class D has two distinct objects of 
  17860. class L, one through class B1 and another through class B2. You can use the 
  17861. keyword virtual in front of the base class specifiers in the base lists of 
  17862. classes B1 and B2 to indicate that only one class L, shared by class B1 and 
  17863. class B2, exists. For example: 
  17864.  
  17865. class L { /* ... */ }; // indirect base class
  17866. class B1 : virtual public L { /* ... */ };
  17867. class B2 : virtual public L { /* ... */ };
  17868. class D : public B1, public B2 { /* ... */ }; // valid
  17869.  
  17870. Using the keyword virtual in this example ensures that an object of class D 
  17871. inherits only one object of class L. 
  17872.  
  17873. A derived class can have both virtual and nonvirtual base classes. For example: 
  17874.  
  17875. class V { /* ... */ };
  17876. class B1 : virtual public V { /* ... */ };
  17877. class B2 : virtual public V { /* ... */ };
  17878. class B3 : public V { /* ... */ };
  17879. class D : public B1, public B2, public B3 { /* ... */
  17880. };
  17881.  
  17882. In the above example, class D has two objects of class V, one that is shared by 
  17883. classes B1 and B2 and one through class B3. 
  17884.  
  17885. Related Information 
  17886.  
  17887. o Multiple Inheritance 
  17888. o Multiple Access 
  17889. o Inheritance Overview 
  17890. o Derivation 
  17891. o C++ Classes 
  17892.  
  17893.  
  17894. ΓòÉΓòÉΓòÉ 14.4.2. Multiple Access ΓòÉΓòÉΓòÉ
  17895.  
  17896. If you have an inheritance graph containing virtual base classes and a name can 
  17897. be reached through more than one path, the name is accessed through the path 
  17898. that gives the most access. For example: 
  17899.  
  17900. class L { public: void f(); };
  17901. class B1 : private virtual L { /* ... */ };
  17902. class B2 : public virtual L { /* ... */ };
  17903. class D : public B1, public B2
  17904. {
  17905. public:
  17906.       void f() {L::f();} // L::f() is accessed through B2
  17907.                                      // and is public
  17908. };
  17909.  
  17910. In the above example, the function f() is accessed through class B2. Because 
  17911. class B2 is inherited publicly and class B1 is inherited privately, class B2 
  17912. offers more access. 
  17913.  
  17914. An accessible base class is a publicly derived base class that is neither 
  17915. hidden nor ambiguous in the inheritance hierarchy. 
  17916.  
  17917. When you derive classes, ambiguities can result if base and derived classes 
  17918. have members with the same names. Access to a base class member is ambiguous if 
  17919. you use a name or qualified name that does not refer to a unique function, 
  17920. object, type, or enumerator. The declaration of a member with an ambiguous name 
  17921. in a derived class is not an error. The ambiguity is only flagged as an error 
  17922. if you use the ambiguous member name. 
  17923.  
  17924. For example, if two base classes have a member of the same name, an attempt to 
  17925. access the member by the derived class is ambiguous. You can resolve ambiguity 
  17926. by qualifying a member with its class name using the :: (scope resolution) 
  17927. operator. 
  17928.  
  17929. Example of Resolving Ambiguous Access 
  17930.  
  17931. The compiler checks for ambiguities at compile time. Because ambiguity checking 
  17932. occurs before access control or type checking, ambiguities may result even if 
  17933. only one of several members with the same name is accessible from the derived 
  17934. class. 
  17935.  
  17936. Conversions (either implicit or explicit) from a derived class pointer or 
  17937. reference to a base class pointer or reference must refer unambiguously to the 
  17938. same accessible base class object. For example: 
  17939.  
  17940. class W { /* ... */ };
  17941. class X : public W { /* ... */ };
  17942. class Y : public W { /* ... */ };
  17943. class Z : public X, public Y { /* ... */ };
  17944. void main ()
  17945. {
  17946.       Z z;
  17947.       X* xptr = &z;       // valid
  17948.       Y* yptr = &z;       // valid
  17949.       W* wptr = &z;       // error, ambiguous reference to class W
  17950.                           // X's W or Y's W ?
  17951. }
  17952.  
  17953. You can use virtual base classes to avoid ambiguous reference. For example: 
  17954.  
  17955. class W { /* ... */ };
  17956. class X : public virtual W { /* ... */ };
  17957. class Y : public virtual W { /* ... */ };
  17958. class Z : public X, public Y { /* ... */ };
  17959. void main ()
  17960. {
  17961.       Z z;
  17962.       X* xptr = &z;      // valid
  17963.       Y* yptr = &z;      // valid
  17964.       W* wptr = &z;      // valid, W is virtual therefore only one
  17965.                          // W subobject exists
  17966. }
  17967.  
  17968. Related Information 
  17969.  
  17970. o Virtual Base Classes 
  17971. o Multiple Inheritance 
  17972. o Scope Resolution Operator 
  17973. o Inheritance Overview 
  17974. o Derivation 
  17975. o Member Access 
  17976.  
  17977.  
  17978. ΓòÉΓòÉΓòÉ <hidden> Example of Resolving Ambiguous Access ΓòÉΓòÉΓòÉ
  17979.  
  17980. /************************************************************************
  17981. *
  17982.  
  17983. The following example uses the :: (scope resolution) operator to resolve an 
  17984. ambiguous reference. 
  17985.  
  17986.                                                                         *
  17987. ************************************************************************/
  17988.  
  17989. class B1
  17990. {
  17991. public:
  17992.       int i;
  17993.       int j;
  17994.       int g( );
  17995. };
  17996. class B2
  17997. {
  17998. public:
  17999.       int j;
  18000.       int g( );
  18001. };
  18002. class D : public B1, public B2
  18003. {
  18004. public:
  18005.       int i;
  18006. };
  18007. void main ()
  18008. {
  18009.       D dobj;
  18010.       D *dptr = &dobj;
  18011.       dptr -> i = 5;        // valid, D::i
  18012.       dptr -> j = 10;       // error, ambiguous reference to j
  18013.       dptr->B1::j = 10;     // valid, B1::j
  18014.       dobj.g( );            // error, ambiguous reference to g( )
  18015.       dobj.B2::g( );        // valid, B2::g( )
  18016. }
  18017.  
  18018.  
  18019. ΓòÉΓòÉΓòÉ 14.5. Virtual Functions ΓòÉΓòÉΓòÉ
  18020.  
  18021. In C++, dynamic binding is supported by the mechanism of virtual functions. 
  18022. Virtual functions must be members of a class. Use virtual functions when you 
  18023. expect a class to be used as a base class in a derivation and when the 
  18024. implementation of the function may be overridden in the derived class. You can 
  18025. declare a member function with the keyword virtual in its class declaration. 
  18026. For example: 
  18027.  
  18028. class B
  18029. {
  18030.       int a,b,c;
  18031. public:
  18032.       virtual int f();
  18033. };
  18034.  
  18035. You can reimplement a virtual member function, like any member function, in any 
  18036. derived class. The implementation that is executed when you make a call to a 
  18037. virtual function depends on the type of the object for which it is called. If a 
  18038. virtual member function is called for a derived class object and the function 
  18039. is redefined in the derived class, the definition in the derived class is 
  18040. executed. In this case, the redefined derived class function is said to 
  18041. override the base class function. This occurs even if the access to the 
  18042. function is through a pointer or reference to the base class. 
  18043.  
  18044. If you call a virtual function with a pointer that has base class type but 
  18045. points to a derived class object, the member function of the derived class is 
  18046. called. However, if you call a nonvirtual function with a pointer that has base 
  18047. class type, the member function of the base class is called regardless of 
  18048. whether the pointer points to a derived class object. 
  18049.  
  18050. Example of Overriding Virtual Functions 
  18051.  
  18052. If the argument types or the number of arguments of the two functions are 
  18053. different, the functions are considered different, and the function in the 
  18054. derived class does not override the function in the base class. The function in 
  18055. the derived class hides the function in the base class. 
  18056.  
  18057. The return type of an overriding virtual function can differ from the return 
  18058. type of the overridden virtual function provided that: 
  18059.  
  18060. o The overridden function returns a pointer or a reference to a class T 
  18061.  
  18062.   AND 
  18063.  
  18064. o The overriding virtual function returns a pointer or a reference to a class 
  18065.   derived from T. 
  18066. An error does result when a virtual function that returns D* overrides an 
  18067. virtual function that returns B* where B is an ambiguous base class of D. The 
  18068. reason is that two or more instances of class B will exist within class D, and 
  18069. the compiler will not know which base B to return. For more information, see 
  18070. Return Values. 
  18071.  
  18072. A virtual function cannot be global or static because, by definition, a virtual 
  18073. function is a member function of a base class and relies on a specific object 
  18074. to determine which implementation of the function is called. You can declare a 
  18075. virtual function to be a friend of another class. 
  18076.  
  18077. If a function is declared virtual in its base class, it can still be accessed 
  18078. directly using the :: (scope resolution) operator. In this case, the virtual 
  18079. function call mechanism is suppressed and the function implementation defined 
  18080. in the base class is used. In addition, if you do not redefine a virtual member 
  18081. function in a derived class, a call to that function uses the function 
  18082. implementation defined in the base class. 
  18083.  
  18084. A virtual function must be one of the following: 
  18085.  
  18086. o Defined 
  18087. o Declared pure 
  18088. o Defined and declared pure 
  18089.  
  18090. A base class containing one or more pure virtual member functions is called an 
  18091. abstract class. 
  18092.  
  18093. Related Information 
  18094.  
  18095. o Virtual Base Classes 
  18096. o Ambiguous Virtual Function Calls 
  18097. o Virtual Function Access 
  18098. o Abstract Classes 
  18099. o Return Values 
  18100. o Friends 
  18101. o Scope Resolution Operator 
  18102. o Inheritance Overview 
  18103. o Derivation 
  18104.  
  18105.  
  18106. ΓòÉΓòÉΓòÉ <hidden> Example of Overriding Virtual Functions ΓòÉΓòÉΓòÉ
  18107.  
  18108. /************************************************************************
  18109. *
  18110.  
  18111. The following example shows how virtual functions can be redefined. 
  18112.  
  18113.                                                                         *
  18114. ************************************************************************/
  18115.  
  18116. class B
  18117. {
  18118. public:
  18119.       virtual int f();
  18120.       virtual int g();
  18121.       int h();
  18122. };
  18123. class D : public B
  18124. {
  18125. public:
  18126.       int f();
  18127.       int g(char*);      // hides B::g()
  18128.       int h();
  18129. };
  18130. void main ()
  18131. {
  18132.       D d;
  18133.       B* bptr = ΓöÇ"ΓöÇ;
  18134.  
  18135.       bptr->f();         // calls D::f() because f() is virtual
  18136.       bptr->h();         // calls B::h() because h() is nonvirtual
  18137.       bptr->g();         // calls B::g()
  18138.       d.g();             // error, wrong number and type of arguments
  18139.       d.g("string");     // calls D::g(char*)
  18140. }
  18141.  
  18142.  
  18143. ΓòÉΓòÉΓòÉ 14.5.1. Ambiguous Virtual Function Calls ΓòÉΓòÉΓòÉ
  18144.  
  18145. It is an error to override one virtual function with two or more ambiguous 
  18146. virtual functions. This can happen in a derived class that inherits from two 
  18147. nonvirtual bases that are derived from a virtual base class. 
  18148.  
  18149. Example of Ambiguous Virtual Functions 
  18150.  
  18151. A special case occurs when the ambiguous overriding virtual functions come from 
  18152. separate instances of the same class type. In the following example, there are 
  18153. two objects (instances) of class L. There are two data members L::count, one in 
  18154. class A and one in class B. If the declaration of class D is allowed, 
  18155. incrementing L::count in a call to L::f() with a pointer to class V is 
  18156. ambiguous. 
  18157.  
  18158. class V
  18159. {
  18160. public:
  18161.       virtual void f();
  18162. };
  18163. class L : virtual public V
  18164. {
  18165.       int count;
  18166.       void f();
  18167. };
  18168. void L::f() {++count;}
  18169. class A : public L
  18170. { /* ... */ };
  18171. class B : public L
  18172. { /* ... */ };
  18173. class D : public A, public B { /* ... */ }; // error
  18174. void main ()
  18175. {
  18176.       D d;
  18177.       V* vptr = ΓöÇ"ΓöÇ;
  18178.       vptr->f();
  18179. }
  18180.  
  18181. In the above example, the function L::f() is expecting a pointer to an L 
  18182. object; that is, the this pointer for class L, as its first implicit argument. 
  18183. Because there are two objects of class L in a D object, there are two this 
  18184. pointers that could be passed to L::f(). Because the compiler cannot decide 
  18185. which this pointer to pass to L::f(), the declaration of class D is flagged as 
  18186. an error. 
  18187.  
  18188. Related Information 
  18189.  
  18190. o Virtual Functions 
  18191. o Virtual Function Access 
  18192. o Multiple Access 
  18193. o Scope Resolution Operator 
  18194. o Member Functions 
  18195.  
  18196.  
  18197. ΓòÉΓòÉΓòÉ <hidden> Example of Ambiguous Virtual Functions ΓòÉΓòÉΓòÉ
  18198.  
  18199. /************************************************************************
  18200. *
  18201.  
  18202. The following example shows a class that inherits from two nonvirtual bases 
  18203. that are derived from a virtual base class. 
  18204.  
  18205.                                                                         *
  18206. ************************************************************************/
  18207.  
  18208. class V
  18209. {
  18210. public:
  18211.       virtual void f() { /* ... */ };
  18212. };
  18213. class A : virtual public V
  18214. {
  18215.       void f() { /* ... */ };
  18216. };
  18217. class B : virtual public V
  18218. {
  18219.       void f() { /* ... */ };
  18220. };
  18221. class D : public B { /* ... */ }; // error
  18222. void main ()
  18223. {
  18224.       D d;
  18225.       V* vptr = ΓöÇ"ΓöÇ;
  18226.       vptr->f();            // which f(), A::f() or B::f()?
  18227. }
  18228.  
  18229. /************************************************************************
  18230. *
  18231.  
  18232. In class A, only A::f() will override V::f(). Similarly, in class B, only 
  18233. B::f() will override V::f(). However, in class D, both A::f() and B::f() will 
  18234. try to override V::f(). This attempt is not allowed because it is not possible 
  18235. to decide which function to call if a D object is referenced with a pointer to 
  18236. class V, as shown in the above example. Because only one function can override 
  18237. a virtual function, the compiler flags this situation as an error. 
  18238.  
  18239.                                                                         *
  18240. ************************************************************************/
  18241.  
  18242.  
  18243. ΓòÉΓòÉΓòÉ 14.5.2. Virtual Function Access ΓòÉΓòÉΓòÉ
  18244.  
  18245. The access for a virtual function is specified when it is declared. The access 
  18246. rules for a virtual function are not affected by the access rules for the 
  18247. function that later overrides the virtual function. In general, the access of 
  18248. the overriding member function is not known. 
  18249.  
  18250. If a virtual function is called with a pointer or reference to a class object, 
  18251. the type of the class object is not used to determine the access of the virtual 
  18252. function. Instead, the type of the pointer or reference to the class object is 
  18253. used. In the following example, when the function f() is called using a pointer 
  18254. having type B*, bptr is used to determine the access to the function f(). Even 
  18255. though the definition of f() defined in class D is executed, the access of the 
  18256. member function f() in class B is used. When the function f() is called using a 
  18257. pointer having type D*, dptr is used to determine the access to the function 
  18258. f(). This call produces an error because f() is declared private in class D. 
  18259.  
  18260. class B
  18261. {
  18262. public:
  18263.       virtual void f();
  18264. };
  18265. class D : public B
  18266. {
  18267. private:
  18268.       void f();
  18269. };
  18270. void main ()
  18271. {
  18272.       D dobj;
  18273.       B *bptr = &dobj;
  18274.       D *dptr = &dobj;
  18275.       bptr->f();   // valid, virtual B::f() is public,
  18276.                    // D::f() is called
  18277.       dptr->f();   // error, D::f() is private
  18278. }
  18279.  
  18280. Related Information 
  18281.  
  18282. o Virtual Functions 
  18283. o Ambiguous Virtual Function Calls 
  18284. o Inherited Member Access 
  18285.  
  18286.  
  18287. ΓòÉΓòÉΓòÉ 14.6. Abstract Classes ΓòÉΓòÉΓòÉ
  18288.  
  18289. An abstract class is a class that is designed to be specifically used as a base 
  18290. class. An abstract class contains at least one pure virtual function. Pure 
  18291. virtual functions are inherited. You can declare a function to be pure by using 
  18292. a pure specifier in the declaration of the member function in the class 
  18293. declaration. For example: 
  18294.  
  18295. class AB             // abstract class
  18296. {
  18297. public:
  18298.       virtual void f()= 0; // pure virtual member function
  18299. };
  18300.  
  18301. A function that is declared pure has no definition and cannot be executed. 
  18302. Because a pure virtual function has no implementation, any attempt to call that 
  18303. function is undefined. Such a call does not cause an error. No objects of an 
  18304. abstract class can be created. 
  18305.  
  18306. Note:  Because destructors are not inherited, a virtual destructor that is 
  18307. declared pure must have a definition. 
  18308.  
  18309. Virtual member functions are inherited. If a base class contains a pure virtual 
  18310. member function and a class derived from that base class does not redefine that 
  18311. pure virtual member function, the derived class itself is an abstract class. 
  18312. Any attempt to create an object of the derived class type produces an error. 
  18313.  
  18314. Examples of Errors using Abstract Classes 
  18315.  
  18316. You cannot use an abstract class as the type of an explicit conversion, as an 
  18317. argument type, or as the return type for a function. You can declare a pointer 
  18318. or reference to an abstract class. 
  18319.  
  18320. Related Information 
  18321.  
  18322. o Virtual Functions 
  18323. o Inheritance Overview 
  18324. o Derivation 
  18325. o C++ Classes 
  18326.  
  18327.  
  18328. ΓòÉΓòÉΓòÉ <hidden> Examples of Errors using Abstract Classes ΓòÉΓòÉΓòÉ
  18329.  
  18330. /************************************************************************
  18331. *
  18332.  
  18333. The following example shows an attempt to create an object of an abstract class 
  18334. type. 
  18335.  
  18336.                                                                         *
  18337. ************************************************************************/
  18338.  
  18339. class AB             // abstract class
  18340. {
  18341. public:
  18342.       virtual void f()= 0; // pure virtual member function
  18343. };
  18344. class D: public AB
  18345. {
  18346. public:
  18347.       void f();
  18348. };
  18349. void main ()
  18350. {
  18351.       D d;
  18352.       d.f() ;     // calls D::f()
  18353.       AB ab;      // error, cannot create an object of an
  18354.                   // abstract class type
  18355. }
  18356.  
  18357. /************************************************************************
  18358. *
  18359.  
  18360. The following example shows an attempt to create an object of a class derived 
  18361. from an abstract class, but that does not redefine the pure virtual function of 
  18362. that abstract class. 
  18363.  
  18364.                                                                         *
  18365. ************************************************************************/
  18366. For example: 
  18367.  
  18368. class AB // abstract class
  18369. {
  18370. public:
  18371.       virtual void f()= 0; // pure virtual member function
  18372. };
  18373. class D2: public AB
  18374. {
  18375.       int a,b,c;
  18376. public:
  18377.       void g();
  18378. };
  18379. void main ()
  18380. {
  18381.       D2 d;
  18382.       // error, cannot declare an object of abstract class D2
  18383. }
  18384.  
  18385. To avoid the error in the above example, provide a declaration of D2::f(). 
  18386.  
  18387.  
  18388. ΓòÉΓòÉΓòÉ 15. Templates ΓòÉΓòÉΓòÉ
  18389.  
  18390. This chapter describes the C++ template facility. A template specifies how an 
  18391. individual class or function can be constructed by providing a blueprint 
  18392. description of classes or functions within the template. 
  18393.  
  18394. Unlike an ordinary class or function definition, a template definition contains 
  18395. the template keyword, and uses a type argument, instead of a type, in one or 
  18396. more of the constructs used to define the class or function template. 
  18397. Individual classes or functions can then be generated simply by specifying the 
  18398. template name and by naming the type for the particular class or function as 
  18399. the type argument of the template. You can use templates to define a family of 
  18400. types or functions. 
  18401.  
  18402. The following topics are described in this chapter: 
  18403.  
  18404. o Template Syntax 
  18405. o Structuring Your Program Using Templates 
  18406. o Class Templates 
  18407. o Function Templates 
  18408. o Differences between Class and Function Templates 
  18409. o Member Function Templates 
  18410. o Friends and Templates 
  18411. o Static Data Members and Templates 
  18412.  
  18413. Important  When you link C++ object files, you must use the icc command with 
  18414. the /Tdp option to invoke the linker. If you invoke the linker in a separate 
  18415. step (with the LINK386 command), the template functions may not resolve 
  18416. correctly. 
  18417.  
  18418. Refer to the IBM C/C++ Tools: Programming Guide for programming hints on using 
  18419. templates in C++ programs. 
  18420.  
  18421. Related Information 
  18422.  
  18423. o C++ Classes 
  18424. o Functions 
  18425. o Types 
  18426.  
  18427.  
  18428. ΓòÉΓòÉΓòÉ 15.1. Template Syntax ΓòÉΓòÉΓòÉ
  18429.  
  18430. The syntax for a template is: 
  18431.  
  18432.          ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  18433. >>ΓöÇΓöÇtemplateΓöÇΓöÇΓöÉΓöÇΓöÇΓö┤Γö¼ΓöÇargument-declarationΓöÇΓö¼Γö┤ΓöÇΓöÇ>ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ><
  18434.        Γöé  Γöé            Γöé
  18435.          ΓööΓöÇtypeΓöÇΓöÇidentifierΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  18436.  
  18437. The declaration in a template declaration must define or declare one of the 
  18438. following: 
  18439.  
  18440. o A class 
  18441. o A function 
  18442. o A static member of a template class 
  18443.  
  18444. The identifier of a type is defined to be a type-name in the scope of the 
  18445. template declaration. A template declaration can appear as a global declaration 
  18446. only. The template arguments (within the < and > delimitiers) specify the types 
  18447. and the constants within the template that must be specified when the template 
  18448. is instantiated. 
  18449.  
  18450. Examples of Templates 
  18451.  
  18452. Default intializers are permitted in template arguments, under the following 
  18453. conditions: 
  18454.  
  18455. o They can only be applied to nontype template arguments. 
  18456. o Like functions, they can only be applied to trailing arguments. 
  18457. o Subsequent template declarations can add default initializers but cannot 
  18458.   redefine existing default initializers. 
  18459. o They can only be applied to class template declarations, not to function 
  18460.   template declarations. 
  18461.  
  18462. Note:  A template that defines a member function of a class template is treated 
  18463. as a function template. Such a template cannot have default intializers. 
  18464.  
  18465. Example of Default Initializers in Templates 
  18466.  
  18467. Related Information 
  18468.  
  18469. o Structuring Your Program Using Templates 
  18470. o Class Templates 
  18471. o Function Templates 
  18472. o C++ Classes 
  18473. o Functions 
  18474. o Static Members 
  18475.  
  18476.  
  18477. ΓòÉΓòÉΓòÉ <hidden> Examples of Templates ΓòÉΓòÉΓòÉ
  18478.  
  18479. Given the following template: 
  18480.  
  18481. template<class L> class Key
  18482. {
  18483.    L k;
  18484.     L* kptr;
  18485.     int length;
  18486. public:
  18487.     Key(L);
  18488.     // ...
  18489. };
  18490.  
  18491. The following table shows what the classes Key<int>, Key<char*>, and 
  18492. Key<mytype> look like: 
  18493.  
  18494. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  18495. Γöé class Key<int> i;    Γöé class Key<char*> c;    Γöé class Key<mytype> m;   Γöé
  18496. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  18497. Γöé class Key<int> {     Γöé class Key<char*> {    Γöé class Key<mytype> {   Γöé
  18498. Γöé    int k;       Γöé    char* k;      Γöé    mytype k;     Γöé
  18499. Γöé    int * kptr;    Γöé    char** kptr;    Γöé    mytype* kptr;   Γöé
  18500. Γöé    int length;    Γöé    int length;     Γöé    int length;    Γöé
  18501. Γöé public:         Γöé public:          Γöé public:         Γöé
  18502. Γöé    Key(int);     Γöé    Key(char*);     Γöé    Key(mytype);    Γöé
  18503. Γöé    // ...  };     Γöé    // ...  };     Γöé    // ...  };     Γöé
  18504. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  18505.  
  18506. The above declarations create the following objects: 
  18507.  
  18508. o i of type Key<int> 
  18509. o c of type Key<char*> 
  18510. o m of type Key<mytype> 
  18511.  
  18512. Note that the three classes above have different names. The types contained 
  18513. within the angle braces are not arguments to the class names, but part of the 
  18514. class names themselves. Key<int> and Key<char*> are class names. Within the 
  18515. context of the above example, a class called Key (with no template argument 
  18516. list) is undefined. 
  18517.  
  18518.  
  18519. ΓòÉΓòÉΓòÉ <hidden> Example of Default Initializers in Templates ΓòÉΓòÉΓòÉ
  18520.  
  18521. /************************************************************************
  18522. *
  18523.  
  18524. The following example shows a valid template declaration with default 
  18525. initializers: 
  18526.  
  18527. *
  18528. ************************************************************************/
  18529.  
  18530. #include <stdio.h>
  18531.  
  18532. template <class T, int i=1> class X
  18533. }
  18534. public:
  18535.      T s;
  18536.      X(int j=4);
  18537.      int val(T&)
  18538.      }
  18539.        return i;
  18540.      {;
  18541. {;
  18542.  
  18543. template <class T, int i> X<T,i>::X(int j):s(i)}
  18544.   printf("i=%d   j=%d\n",i,j);
  18545. {
  18546.  
  18547. void main()
  18548. }
  18549.   X<int>   myX(2);
  18550.   X<int,3> myX2(4);
  18551. {
  18552.  
  18553.  
  18554. ΓòÉΓòÉΓòÉ 15.2. Structuring Your Program Using Templates ΓòÉΓòÉΓòÉ
  18555.  
  18556. There are three ways to structure your program using templates: 
  18557.  
  18558.  1. Include the function template definition (both the .h and .c files) in all 
  18559.     files that may reference the corresponding template functions. 
  18560.  
  18561.  2. Include the function template declaration (the .h file only) in all files 
  18562.     that may reference the corresponding template functions, but include the 
  18563.     function definition (both the .h and .c files) in one file only. 
  18564.  
  18565.  3. Include the declaration of the function templates in a header file and the 
  18566.     definition in a source file that has the same name. When you include the 
  18567.     header file in your source, the compiler automatically generates the 
  18568.     template functions. Use the /Ft+ option to enable this method. 
  18569.  
  18570. The following examples illustrate all three methods using two files: stack.h 
  18571. and stackdef.h 
  18572.  
  18573. To instantiate a stack of 50 ints, you would declare the following in each 
  18574. source file that requires it: 
  18575.  
  18576. stack<int> intStack(50);
  18577.  
  18578. For method 1, each source file using the template should include both stack.h 
  18579. and stackdef.h. 
  18580.  
  18581. For method 2, every source file should include stack.h, but only one of the 
  18582. files needs to include stackdef.h. 
  18583.  
  18584. For method 3, every source file should include stack.h. The compiler 
  18585. automatically generates the template functions in the TEMPINC subdirectory that 
  18586. is created in the current directory. To use this method, copy stackdef.h to 
  18587. stack.c and use the /Ft+ option, which is the default. 
  18588.  
  18589. Important  When you link C++ object files, you must use the icc command with 
  18590. the /Tdp option to invoke the linker. If you invoke the linker in a separate 
  18591. step (with the LINK386 command), the template functions might not resolve 
  18592. correctly. 
  18593.  
  18594. Related Information 
  18595.  
  18596. o Template Syntax 
  18597. o Class Templates 
  18598. o Function Templates 
  18599. o Differences between Class and Function Templates 
  18600. o "Using Templates in C++ Programs" in the Programming Guide. 
  18601.  
  18602.  
  18603. ΓòÉΓòÉΓòÉ <hidden> stack.h and stackdef.h ΓòÉΓòÉΓòÉ
  18604.  
  18605. /************************************************************************
  18606. *
  18607.  
  18608. stack.h 
  18609.  
  18610.                                                                         *
  18611. ************************************************************************/
  18612.  
  18613. #ifndef _STACK_TPL_H
  18614.       #define _STACK_TPL_H
  18615.  
  18616.       template<class T>
  18617.       class stack
  18618.       {
  18619.       private:
  18620.              T*  v;
  18621.              T*  p;
  18622.              int sz;
  18623.  
  18624.       public:
  18625.              stack( int );
  18626.               ~stack();
  18627.               void push( T );
  18628.       };
  18629. #endif
  18630.  
  18631. /************************************************************************
  18632. *
  18633.  
  18634. stackdef.h 
  18635.  
  18636.                                                                         *
  18637. ************************************************************************/
  18638.  
  18639. #include "stack.h"
  18640.  
  18641. template<class T> stack<T>::stack( int s )
  18642. {
  18643.       v = p = new T[sz=s];
  18644. }
  18645.  
  18646. template<class T> stack<T>::~stack()
  18647. {
  18648.       delete [] v;
  18649. }
  18650.  
  18651. template<class T> void stack<T>::push( T a )
  18652. {
  18653.       *p++ = a;
  18654. }
  18655.  
  18656.  
  18657. ΓòÉΓòÉΓòÉ 15.3. Class Templates ΓòÉΓòÉΓòÉ
  18658.  
  18659. The relationship between a class template and an individual class is like the 
  18660. relationship between a class and an individual object. An individual class 
  18661. defines how a group of objects can be constructed, while a class template 
  18662. defines how a group of classes can be generated. 
  18663.  
  18664. A template definition is identical to any valid class definition that the 
  18665. template might generate, except for the following: 
  18666.  
  18667. o The class template definition is preceded by  template < 
  18668.   template-argument-list >  where template-argument-list can include zero or 
  18669.   more arguments of user-defined type and zero or more argument declarations. 
  18670.   The template-argument-list must contain at least one argument. 
  18671.  
  18672. o Types, variables, constants and objects within the class template can be 
  18673.   declared with arguments of user-defined type as well as with explicit types 
  18674.   (for example, int or char). 
  18675.  
  18676. o The template-argument-list can include argument-declarations (for example,int 
  18677.   a or char* b), which are generally used to define constant values within the 
  18678.   created class. 
  18679.  
  18680. A class template can declare a class without defining it by using an elaborated 
  18681. type specifier. For example: 
  18682.  
  18683. template  <class L,class T> class key;
  18684.  
  18685. This reserves the name as a class template name. All template declarations for 
  18686. a class template must have the same types and number of template arguments. 
  18687. Only one template declaration containing the class definition is allowed. 
  18688.  
  18689. Note the distinction between the terms class template and template class: 
  18690.  
  18691. Class template    is a template used to generate template classes. A class 
  18692.                   template can be only a declaration, or it can be a definition 
  18693.                   of the class. 
  18694. Template class    is an instance of a class template. 
  18695.  
  18696. You can instantiate the class template by declaring a template class. If the 
  18697. definitions of the member functions of the template class are not inlined, then 
  18698. you have to define them. When you instantiate a template class, its argument 
  18699. list must match the argument list in the class template declaration. 
  18700.  
  18701. Syntax of a Template Class Instantiation 
  18702.  
  18703. Note:  When you have nested template argument lists, you must have a separating 
  18704. space between the > at the end of the inner list and the one at the end of the 
  18705. outer list. Otherwise, there is an ambiguity between the output operator >> and 
  18706. two template list delimiters >. 
  18707.  
  18708. template  <class L,class T> class key
  18709. {
  18710. // ...
  18711. };
  18712. template <class L> class vector
  18713. {
  18714. // ...
  18715. };
  18716.  
  18717. void main ()
  18718. {
  18719. class key <int, vector<int> >; // instantiate template
  18720. }
  18721.  
  18722. Objects and functions of individual template classes can be accessed by any of 
  18723. the techniques used to access ordinary class member objects and functions. 
  18724.  
  18725. Examples of Accessing Class Template Members 
  18726.  
  18727. Related Information 
  18728.  
  18729. o Class Template Declarations and Definitions 
  18730. o Nontype Template Arguments 
  18731. o Explicitly Defined Template Classes 
  18732. o Function Templates 
  18733. o Template Syntax 
  18734. o Structuring Your Program Using Templates 
  18735. o C++ Classes 
  18736. o Differences between Class and Function Templates 
  18737.  
  18738.  
  18739. ΓòÉΓòÉΓòÉ <hidden> Syntax of a Template Class Instantiation ΓòÉΓòÉΓòÉ
  18740.  
  18741. The syntax for instantiation of a template class is: 
  18742.  
  18743.            ΓöîΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  18744. >>ΓöÇΓöÇtemplate-nameΓöÇΓöÇΓöÉΓöÇΓöÇΓö┤Γö¼ΓöÇtypeΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇΓöÇ>ΓöÇΓöÇ><
  18745.           Γöé  Γöé            Γöé
  18746.             ΓööΓöÇassignment-expressionΓöÇΓöÿ
  18747.  
  18748.  
  18749. ΓòÉΓòÉΓòÉ <hidden> Examples of Accessing Class Template Members ΓòÉΓòÉΓòÉ
  18750.  
  18751. Given a class template: 
  18752.  
  18753. template<class T> class vehicle
  18754. {
  18755. public:
  18756.     vehicle() { /* ... */ }    // constructor
  18757.     ~vehicle() {};             // destructor
  18758.     T kind[16];
  18759.     T* drive();
  18760.     static void roadmap();
  18761.     // ...
  18762. };
  18763.  
  18764. and the declaration: 
  18765.  
  18766. vehicle<char> bicycle; // instantiates the template
  18767.  
  18768. the constructor, the constructed object, and the member function drive() can be 
  18769. accessed with any of the following (assuming the standard header file 
  18770. <string.h> is included in the program file): 
  18771.  
  18772. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  18773. Γöé constructor          Γöé "vehicle<char> bicycle;            Γöé
  18774. Γöé                Γöé // constructor called automatically      Γöé
  18775. Γöé                Γöé // object bicycle created"          Γöé
  18776. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  18777. Γöé object "bicycle"        Γöé "strcpy (bicycle.kind, "10 speed");      Γöé
  18778. Γöé                Γöé bicycle.kind[0] = '2';"            Γöé
  18779. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  18780. Γöé function "drive()"       Γöé "char* n = bicycle.drive();"         Γöé
  18781. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  18782. Γöé function "roadmap()"      Γöé "vehicle<char>::roadmap();"          Γöé
  18783. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  18784.  
  18785.  
  18786. ΓòÉΓòÉΓòÉ 15.3.1. Class Template Declarations and Definitions ΓòÉΓòÉΓòÉ
  18787.  
  18788. A class template must be declared before any declaration of a corresponding 
  18789. template class. A class template definition can only appear once in any single 
  18790. compilation unit. A class template must be defined before any use of a template 
  18791. class that requires the size of the class or refers to members of the class. In 
  18792. the following example, the class template key is declared before it is defined. 
  18793. The declaration of the pointer keyiptr is valid because the size of the class 
  18794. is not needed. The declaration of keyi, however, causes an error. 
  18795.  
  18796. template  <class L> class key;      // class template declared,
  18797.                                     // not defined yet
  18798.                                     //
  18799. class key<int> *keyiptr;            // declaration of pointer
  18800.                                     //
  18801. class key<int> keyi;                // error, cannot declare keyi
  18802.                                     // without knowing size
  18803.                                     //
  18804. template <class L> class key;       // now class template defined
  18805. {
  18806. // ...
  18807. };
  18808.  
  18809. If a template class is used before the corresponding class template is defined, 
  18810. the compiler issues an error. A class name with the appearance of a template 
  18811. class name is considered to be a template class. In other words, angle brackets 
  18812. are valid in a class name only if that class is a template class. 
  18813.  
  18814. The definition of a class template is not compiled until the definition of a 
  18815. template class is required. At that point, the class template definition is 
  18816. compiled using the argument list of the template class to instantiate the 
  18817. template arguments. Any errors in the class definition are flagged at this 
  18818. time. If the definition of a class template is never required, it is not 
  18819. compiled. In this case, some errors in the definition might not be flagged by 
  18820. the compiler. The /Wcls option can be used to find possible errors in class 
  18821. templates that are not compiled. 
  18822.  
  18823. A class template can only be defined once within a compilation unit, and the 
  18824. class template name cannot be declared to refer to any other template, class, 
  18825. object, function, value, or type in the same scope. 
  18826.  
  18827. Related Information 
  18828.  
  18829. o Class Templates 
  18830. o Nontype Template Arguments 
  18831. o Explicitly Defined Template Classes 
  18832. o Using the /Wgrp Diagnostic Options 
  18833. o C++ Classes 
  18834. o Function Templates 
  18835. o Differences between Class and Function Templates 
  18836.  
  18837.  
  18838. ΓòÉΓòÉΓòÉ 15.3.2. Nontype Template Arguments ΓòÉΓòÉΓòÉ
  18839.  
  18840. A nontype template argument provided within a template argument list is an 
  18841. expression whose value can be determined at compile time. Such arguments must 
  18842. be constant expressions, addresses of functions or objects with external 
  18843. linkage, or addresses of static class members. Nontype template arguments are 
  18844. normally used to initialize a class or to specify the sizes of class members. 
  18845.  
  18846. For nontype integral arguments, the instance argument matches the corresponding 
  18847. template argument as long as the instance argument has a value and sign 
  18848. appropriate to the argument type. 
  18849.  
  18850. For nontype address arguments, the type of the instance argument must be of the 
  18851. form identifier or &identifier, and the type of the instance argument must 
  18852. match the template argument exactly, except that a function name is changed to 
  18853. a pointer to function type before matching. 
  18854.  
  18855. The resulting values of nontype template arguments within a template argument 
  18856. list form part of the template class's type. If two template class names have 
  18857. the same template name and if their arguments have identical values, they are 
  18858. the same class. 
  18859.  
  18860. Example of Nontype Template Arguments 
  18861.  
  18862. Note:  Arguments that contain the < symbol or the > symbol must be enclosed in 
  18863.        parentheses to prevent it from being parsed as the template argument 
  18864.        list delimiter when it is being used as a relational operator or a 
  18865.        nested template delimiter. For example, the arguments in the following 
  18866.        definition are valid: 
  18867.  
  18868.               myfilebuf<double, (20>10)> x;       // valid
  18869.  
  18870. The following definition, however, is not valid because the greater than 
  18871. operator (>) is interpreted as the closing delimiter of the template argument 
  18872. list: 
  18873.  
  18874. myfilebuf<double, 20>10> x;         // error
  18875.  
  18876. If the template arguments do not evaluate identically, the objects created are 
  18877. of different types: 
  18878.  
  18879. myfilebuf<double,200> x;            // create object x of class
  18880.                                     // myfilebuf<double,200>
  18881. myfilebuf<double,200.0> y;          // error, 200.0 is a double,
  18882.                                     // not an int
  18883.  
  18884. The instantiation of y fails because the value 200.0 is of type double, and the 
  18885. template argument is of type int. 
  18886.  
  18887. The following two objects: 
  18888.  
  18889.       myfilebuf<double, 128> x
  18890.       myfilebuf<double, 512> y
  18891.  
  18892. belong to separate template classes, and referencing either of these objects 
  18893. later with myfilebuf<double> is an error. 
  18894.  
  18895. A class template does not need to have a type argument if it has nontype 
  18896. arguments. For example, the following template is a valid class template: 
  18897.  
  18898. template<int i> class C
  18899. {
  18900.       public:
  18901.             int k;
  18902.             C() { k = i; }
  18903. };
  18904.  
  18905. This class template can be instantiated by declarations such as: 
  18906.  
  18907. class C<100>;
  18908. class C<200>;
  18909.  
  18910. Again, these two declarations refer to distinct classes because the values of 
  18911. their nontype arguments differ. 
  18912.  
  18913. Related Information 
  18914.  
  18915. o Class Templates 
  18916. o Class Template Declarations and Definitions 
  18917. o Explicitly Defined Template Classes 
  18918. o C++ Classes 
  18919. o Function Templates 
  18920. o Differences between Class and Function Templates 
  18921.  
  18922.  
  18923. ΓòÉΓòÉΓòÉ <hidden> Example of Nontype Template Arguments ΓòÉΓòÉΓòÉ
  18924.  
  18925. In the following example, a class template is defined that requires a nontype 
  18926. template int argument as well as the type argument: 
  18927.  
  18928. template<class T, int size> class myfilebuf
  18929. {
  18930.       T* filepos;
  18931.       static int array[size];
  18932. public:
  18933.       myfilebuf() { /* ... */ }
  18934.       ~myfilebuf();
  18935.       advance(); // function defined elsewhere in program
  18936. };
  18937.  
  18938. In the example above, the template argument size becomes a part of the template 
  18939. class name. An object of such a template class is created with both the type 
  18940. arguments of the class and the values of any additional template arguments. 
  18941.  
  18942. An object x, and its corresponding template class with arguments double and 
  18943. size=200, can be created from this template with a value as its second template 
  18944. argument: 
  18945.  
  18946. myfilebuf<double,200> x;
  18947.  
  18948. x can also be created using an arithmetic expression: 
  18949.  
  18950. myfilebuf<double,10*20> x;
  18951.  
  18952. The objects created by these expressions are identical because the template 
  18953. arguments evaluate identically. The value 200 in the first expression above 
  18954. could have been represented by an expression whose result at compile time is 
  18955. known to be equal to 200, as shown in the second construction. 
  18956.  
  18957.  
  18958. ΓòÉΓòÉΓòÉ 15.3.3. Explicitly Defined Template Classes ΓòÉΓòÉΓòÉ
  18959.  
  18960. You can override the definition of a class template of a particular template 
  18961. class by providing a class definition for the type of class required. For 
  18962. example, the following class template creates a class for each type for which 
  18963. it is referenced, but that class may be inappropriate for a particular type: 
  18964.  
  18965. template<class M> class portfolio
  18966. {
  18967.       double capital;
  18968.       M arr;
  18969.       // ...
  18970. } ;
  18971.  
  18972. The type for which the template class is inappropriate can be defined by using 
  18973. the applicable template class name. Assuming the inappropriately defined type 
  18974. is stocks, you can redefine the class portfolio<stocks> as follows: 
  18975.  
  18976. class portfolio<stocks>
  18977. {
  18978.       double capital;
  18979.       stocks yield;
  18980.       // ...
  18981. };
  18982.  
  18983. This explicit definition must be seen before the template class is referenced. 
  18984. In particular, a template class such as portfolio<stocks> cannot be defined 
  18985. unless its class template has also been defined. 
  18986.  
  18987. Related Information 
  18988.  
  18989. o Class Templates 
  18990. o Class Template Declarations and Definitions 
  18991. o Nontype Template Arguments 
  18992. o C++ Classes 
  18993. o Function Templates 
  18994. o Differences between Class and Function Templates 
  18995.  
  18996.  
  18997. ΓòÉΓòÉΓòÉ 15.4. Function Templates ΓòÉΓòÉΓòÉ
  18998.  
  18999. A function template allows you to define a group of functions that are the same 
  19000. except for the types of one or more of their arguments or objects. All type 
  19001. arguments in a function template must be used in the argument list or in the 
  19002. class qualifier for the function name. The type of a template function argument 
  19003. need not be explicitly specified when the template function is called. In this 
  19004. respect, a template function differs from a template class. 
  19005.  
  19006. Example of a Function Template 
  19007.  
  19008. Note the distinction between the terms function template and template function: 
  19009.  
  19010. Function template   is a template used to generate template functions. A 
  19011.                     function template can be only a declaration, or it can 
  19012.                     define the function. 
  19013. Template function   is a function generated by a function template. 
  19014.  
  19015. Because template functions can be generated in all compilation units that 
  19016. contain function template definitions, you may want to group function template 
  19017. definitions into one or two compilation units. Using templates in C++ programs 
  19018. is described completely in the IBM C/C++ Tools: Programming Guide. 
  19019.  
  19020. Related Information 
  19021.  
  19022. o Overloading Resolution for Template Functions 
  19023. o Explicitly Defined Template Functions 
  19024. o Function Template Declarations and Definitions 
  19025. o Differences between Class and Function Templates 
  19026. o Functions 
  19027. o Class Templates 
  19028.  
  19029.  
  19030. ΓòÉΓòÉΓòÉ <hidden> Example of a Function Template ΓòÉΓòÉΓòÉ
  19031.  
  19032. If you want to create a function approximate(), which determines whether two 
  19033. values are within 5% of each other, you can define the following template: 
  19034.  
  19035.       #include <math.h>
  19036.       template <class T> int approximate (T first, T second)
  19037.       {
  19038.             double aptemp=double(first)/double(second);
  19039.             return int(abs(aptemp-1.0) <= .05);
  19040.       };
  19041.  
  19042. Assuming you have two values of type float you want to compare, you can use the 
  19043. approximate function template: 
  19044.  
  19045.       float a=3.24, b=3.35;
  19046.       if (approximate(a,b))
  19047.             cout << "a and b are pretty close" << endl;
  19048.  
  19049. A template function int approximate(float,float) is generated to resolve the 
  19050. call. 
  19051.  
  19052.  
  19053. ΓòÉΓòÉΓòÉ 15.4.1. Overloading Resolution for Template Functions ΓòÉΓòÉΓòÉ
  19054.  
  19055. Resolution of overloaded template functions is done in the following order: 
  19056.  
  19057.  1. Look for a function with an exact type match. This does not include 
  19058.     template functions, unless such functions were explicitly declared using a 
  19059.     function declaration. Trivial conversions are performed if they produce an 
  19060.     exact type match. 
  19061.  
  19062.  2. Look for a function template that allows generation of a function with an 
  19063.     exact type match. Trivial conversions are performed if they produce an 
  19064.     exact type match. 
  19065.  
  19066.  3. Try ordinary overloading resolution for functions already present. This 
  19067.     does not include template functions, unless such functions were explicitly 
  19068.     declared using a function declaration. 
  19069.  
  19070. A call to a template function causes an error, and no overloading is done if 
  19071. the following conditions are true: 
  19072.  
  19073. o The only available functions for a call are template functions. 
  19074. o These functions would require nontrivial conversions for the call to succeed. 
  19075. o These functions have not been explicitly declared. 
  19076.  
  19077. Example of Overloading a Template Function 
  19078.  
  19079. Related Information 
  19080.  
  19081. o Trivial Conversions 
  19082. o Conversions 
  19083. o Function Templates 
  19084. o Explicitly Defined Template Functions 
  19085. o Function Template Declarations and Definitions 
  19086. o Functions 
  19087. o Differences between Class and Function Templates 
  19088. o Class Templates 
  19089.  
  19090.  
  19091. ΓòÉΓòÉΓòÉ <hidden> Example of Overloading a Template Function ΓòÉΓòÉΓòÉ
  19092.  
  19093. In the case of the approximate() function template: 
  19094.  
  19095.       #include <math.h>
  19096.       template <class T> int approximate (T first, T second)
  19097.       {
  19098.             double aptemp=double(first)/double(second);
  19099.             return int(abs(aptemp-1.0) <= .05);
  19100.       };
  19101.  
  19102. if the two input values are of different types, overloading resolution does not 
  19103. take place: 
  19104.  
  19105.       float a=3.24;
  19106.       double b=3.35;
  19107.       if (approximate(a,b))  // error, different types
  19108.       { /* ... */ }
  19109.  
  19110. The solution is to force a conversion to one of the available function types by 
  19111. explicitly declaring the function for the chosen type. To resolve the 
  19112. float/double example above, include the following function declaration: 
  19113.  
  19114.       int approximate(double a, double b);
  19115.       // force conversion of the float to double
  19116.  
  19117. This declaration creates a function approximate() that expects two arguments of 
  19118. type double, so that when approximate(a,b) is called, the overloading is 
  19119. resolved by converting variable a to type double. 
  19120.  
  19121.  
  19122. ΓòÉΓòÉΓòÉ 15.4.2. Explicitly Defined Template Functions ΓòÉΓòÉΓòÉ
  19123.  
  19124. In some situations, a function template can define a group of functions in 
  19125. which, for one function type, the function definition would be inappropriate. 
  19126. For instance, the function template: 
  19127.  
  19128.     template<class T> int approximate(T first, T second);
  19129.  
  19130. determines whether two values are within 5% of each other. The algorithm used 
  19131. for this function template is appropriate for numerical values, but for char* 
  19132. values, it would indicate whether the pointers to two character strings are 
  19133. within 5% of one another, not whether the strings themselves are approximately 
  19134. equal. Whether two pointers are within 5% of each other is not useful 
  19135. information. You can define an explicit template function for char* values to 
  19136. compare the two strings themselves, character by character. 
  19137.  
  19138. Example of an Explicitly Defined Template Function 
  19139.  
  19140. Explicit definition has the same effect on template overloading resolution as 
  19141. explicit declaration (See Overloading Resolution for Template Functions for 
  19142. more information.) If a template function is explicitly defined for: 
  19143.  
  19144. int approximate(double a, double b) { /* ... */ }
  19145.  
  19146. then a call of: 
  19147.  
  19148. double a=3.54;
  19149. float b=3.5;
  19150. approximate(a,b);
  19151.  
  19152. resolves in a call to  approximate(double a, double b)  and variable b is 
  19153. converted to type double. 
  19154.  
  19155. Related Information 
  19156.  
  19157. o Function Templates 
  19158. o Overloading Resolution for Template Functions 
  19159. o Function Template Declarations and Definitions 
  19160. o Functions 
  19161. o Differences between Class and Function Templates 
  19162. o Class Templates 
  19163.  
  19164.  
  19165. ΓòÉΓòÉΓòÉ <hidden> Example of an Explicitly Defined Template Function ΓòÉΓòÉΓòÉ
  19166.  
  19167. The following explicitly defined template function compares two strings and 
  19168. returns a value indicating whether more than 5% of the characters differ 
  19169. between the two strings: 
  19170.  
  19171. #include <string.h>
  19172. int approximate(char *first, char *second)
  19173. {
  19174.       if (strcmp(first,second) == 0)
  19175.             return 1; // strings are identical
  19176.  
  19177.       double difct=0;
  19178.       int maxlen=0;
  19179.  
  19180.       if (strlen(first)>strlen(second))
  19181.             maxlen=strlen(first);
  19182.  
  19183.       else maxlen=strlen(second);
  19184.       for (int i=0; i<=maxlen ; ++i)
  19185.             if ( first[i] != second[i] ) difct++;
  19186.       return int((difct / maxlen) <= .05  );
  19187. }
  19188.  
  19189. Given this definition, the function call:  approximate("String A","String B"); 
  19190. invokes the explicitly defined function above, and no template function is 
  19191. generated. 
  19192.  
  19193.  
  19194. ΓòÉΓòÉΓòÉ 15.4.3. Function Template Declarations and Definitions ΓòÉΓòÉΓòÉ
  19195.  
  19196. When a template function is defined explicitly within a compilation unit, this 
  19197. definition is used in preference to any instantiation from the function 
  19198. template. For example, if one compilation unit contains the code: 
  19199.  
  19200. #include <iostream.h>
  19201. template <class T> T f(T i) {return i+1;}
  19202. void main()
  19203. {
  19204.       cout << f(2) << endl;
  19205. }
  19206.  
  19207. and another contains: 
  19208.  
  19209. int f(int i) {return i+2;}
  19210.  
  19211. when compiled and run, the program prints the number 4 to standard output, 
  19212. indicating that the explicitly defined function was used to resolve the call to 
  19213. f(). 
  19214.  
  19215. Each template, whether of a class or of a function, must be defined at most 
  19216. once within a compilation unit. The same applies to an explicitly defined 
  19217. template class or function. Function templates and class templates can be 
  19218. declared many times. 
  19219.  
  19220. A template class is considered declared if its name is used. A template 
  19221. function is considered declared if any of the following applies: 
  19222.  
  19223. o A function whose name matches a function template's name is declared, and an 
  19224.   appropriate template function can be generated. 
  19225. o A function whose name matches a function template's name is called, and an 
  19226.   appropriate template function can be generated. 
  19227. o A function whose name matches a function template's name is called, and the 
  19228.   template function has been explicitly defined. 
  19229. o The address of a template function is taken in such a way that instantiation 
  19230.   can occur. This means the pointer to function must supply a return type and 
  19231.   argument types that can be used to instantiate the template function. 
  19232.  
  19233. A template function is instantiated or generated if the function is referenced 
  19234. in any of the following ways, provided that function is not explicitly defined 
  19235. elsewhere in the program: 
  19236.  
  19237. o The function is declared. 
  19238. o A call to the function is made. 
  19239. o The address of the function is taken. 
  19240.  
  19241. When a template function is instantiated, the body of the function template is 
  19242. compiled using the template-arg-list of the template class to instantiate the 
  19243. template arguments. Any errors in the function definition are flagged at this 
  19244. time. If a template function is never generated from a function template, it is 
  19245. not compiled. In this case, some errors in the function definition might not be 
  19246. flagged by the compiler. 
  19247.  
  19248. Related Information 
  19249.  
  19250. o Function Templates 
  19251. o Overloading Resolution for Template Functions 
  19252. o Explicitly Defined Template Functions 
  19253. o Functions 
  19254. o Differences between Class and Function Templates 
  19255. o Class Templates 
  19256.  
  19257.  
  19258. ΓòÉΓòÉΓòÉ 15.5. Differences between Class and Function Templates ΓòÉΓòÉΓòÉ
  19259.  
  19260. The name of a template class is a compound name consisting of the template name 
  19261. and the full template argument list enclosed in angle braces. Any references to 
  19262. a template class must use this complete name. For example: 
  19263.  
  19264. template <class T, int range> class ex
  19265. {
  19266.       T a;
  19267.        int r;
  19268.       // ...
  19269. };
  19270. //...
  19271. ex<double,20> obj1;     // valid
  19272. ex<double> obj2;        // error
  19273. ex obj3;                // error
  19274.  
  19275. C++ requires this explicit naming convention to ensure that the appropriate 
  19276. class can be generated. 
  19277.  
  19278. A template function, on the other hand, has the name of its function template 
  19279. and the particular function chosen to resolve a given template function call is 
  19280. determined by the type of the calling arguments. In the following example, the 
  19281. call min(a,b) is effectively a call to min(int a, int b), and the call min(af, 
  19282. bf) is effectively a call to min(float a, float b): 
  19283.  
  19284. template<class T> T min(T a, T b)
  19285. {
  19286.       if (a < b)
  19287.             return a;
  19288.       else
  19289.             return b;
  19290. }
  19291. void main()
  19292. {
  19293.       int a = 0;
  19294.       int b = 2;
  19295.       float af = 3.1;
  19296.       float bf = 2.9;
  19297.       cout << "Here is the smaller int " << min(a,b) << endl;
  19298.       cout << "Here is the smaller float " << min(af, bf) << endl;
  19299. }
  19300.  
  19301. Related Information 
  19302.  
  19303. o Class Templates 
  19304. o Function Templates 
  19305. o C++ Classes 
  19306. o Functions 
  19307.  
  19308.  
  19309. ΓòÉΓòÉΓòÉ 15.6. Member Function Templates ΓòÉΓòÉΓòÉ
  19310.  
  19311. In Function Templates, a function template was defined outside of any template 
  19312. class. However, functions in C++ are often member functions of a class. If you 
  19313. want to create a class template and a set of function templates to go with that 
  19314. class template, you do not have to create the function templates explicitly, as 
  19315. long as the function definitions are contained within the class template. Any 
  19316. member function (inlined or noninlined) declared within a class template is 
  19317. implicitly a function template. When a template class is declared, it 
  19318. implicitly generates template functions for each function defined in the class 
  19319. template. 
  19320.  
  19321. There are three ways to define template member functions: 
  19322.  
  19323.  1. Explicitly at file scope for each type used to instantiate the template 
  19324.     class. 
  19325.  2. At file scope with the template-arguments. 
  19326.  3. Inlined in the class template itself. 
  19327.  
  19328. Examples of Defining Template Member Functions 
  19329.  
  19330. Member function templates are used to instantiate any functions that are not 
  19331. explicitly generated. If you have both a member function template and an 
  19332. explicit definition, the explicit definition is used. 
  19333.  
  19334. The template argument is not used in a constructor name. For example: 
  19335.  
  19336. template<class L> class Key
  19337. {
  19338.       Key();            // default constructor
  19339.       Key( L );         // constructor taking L by value
  19340.       Key<L>( L );      // error, <L> implicit within class template
  19341. };
  19342.  
  19343. The declaration Key<L>(L) is an error because the constructor does not use the 
  19344. template argument. Assuming the above class template was corrected by removing 
  19345. the offending line, you can define a function template for the class template's 
  19346. constructor: 
  19347.  
  19348. // Constructor contained in function template:
  19349. template<class L>
  19350.       Key<L>::Key(int) { /* ... */ }
  19351.       // valid, constructor template argument assumed template<class L>
  19352.  
  19353.       Key<L>::Key<L>(int) { /* ... */ }
  19354.       /* error, constructor template argument <L> implicit
  19355.          in class template argument */
  19356.  
  19357. A template function name does not include the template argument. The template 
  19358. argument does, however, appear in the template class name if a member function 
  19359. of a template class is defined or declared outside of the class template. The 
  19360. definition:   Key<L>::Key(int) { /* ... */ }   is valid because Key<L> (with 
  19361. template argument) refers to the class, while Key(int) { /* ... */ } refers to 
  19362. the member function. 
  19363.  
  19364. Related Information 
  19365.  
  19366. o Class Templates 
  19367. o Function Templates 
  19368. o C++ Class Members and Friends 
  19369.  
  19370.  
  19371. ΓòÉΓòÉΓòÉ <hidden> Examples of Defining Template Member Functions ΓòÉΓòÉΓòÉ
  19372.  
  19373. /************************************************************************
  19374. *
  19375.  
  19376. The following three examples illustrate the three ways to define template 
  19377. member functions: 
  19378.  
  19379. Method 1 
  19380.  
  19381.                                                                         *
  19382. ************************************************************************/
  19383.  
  19384.       template <class T> class key
  19385.       {
  19386.       public:
  19387.             void f(T);
  19388.       };
  19389.       void key<char>::f(char) { /* ... */ }
  19390.       void key<int>::f(int ) { /* ... */ }
  19391.  
  19392.       void main()
  19393.       {
  19394.             int i = 9;
  19395.             key< int> keyobj;
  19396.             keyobj.f(i);
  19397.       }
  19398.  
  19399. /************************************************************************
  19400. *
  19401.  
  19402. Method 2 
  19403.  
  19404.                                                                         *
  19405. ************************************************************************/
  19406.  
  19407.       template <class T> class key
  19408.       {
  19409.       public:
  19410.             void f(T);
  19411.       };
  19412.       template <class T> void key <T>::f(T) { /* ... */ }
  19413.  
  19414.       void main()
  19415.       {
  19416.             int i = 9;
  19417.             key< int> keyobj;
  19418.             keyobj.f(i);
  19419.       }
  19420.  
  19421. /************************************************************************
  19422. *
  19423.  
  19424. Method 3 
  19425.  
  19426.                                                                         *
  19427. ************************************************************************/
  19428.  
  19429.       template <class T> class key
  19430.       {
  19431.       public:
  19432.             void f(T) { /* ... */ }
  19433.       };
  19434.  
  19435.       void main()
  19436.       {
  19437.             int i = 9;
  19438.             key< int> keyobj;
  19439.             keyobj.f(i);
  19440.       }
  19441.  
  19442.  
  19443. ΓòÉΓòÉΓòÉ 15.7. Friends and Templates ΓòÉΓòÉΓòÉ
  19444.  
  19445. A friend function can be declared in a class template either as a single 
  19446. function shared by all classes created by the template or as a template 
  19447. function that varies from class to class within the class template. For 
  19448. example: 
  19449.  
  19450. template<class T> class portfolio
  19451. {
  19452.       //...
  19453.       friend void taxes();
  19454.       friend void transact(T);
  19455.       friend portfolio<T>* invest(portfolio<T>*);
  19456.       friend portfolio* divest(portfolio*);        //error
  19457.       // ...
  19458. };
  19459.  
  19460. In this example, each declaration has the following characteristics: 
  19461.  
  19462. taxes() 
  19463.     is a single function that can access private and protected members of any 
  19464.     template class generated by the class template. Note that taxes() is not a 
  19465.     template function. 
  19466. transact(T) 
  19467.     is a function template that declares a distinct function for each class 
  19468.     generated by the class template. The only private and protected members 
  19469.     that can be accessed by functions generated from this template are the 
  19470.     private and protected members of their template class. 
  19471. invest(portfolio<T>*) 
  19472.     is a function template whose return and argument types are pointers to 
  19473.     objects of type portfolio<T>. Each class generated by the class template 
  19474.     will have a friend function of this name, and each such function will have 
  19475.     a pointer to an object of its own class as both its return type and its 
  19476.     argument type. 
  19477. divest(portfolio*) 
  19478.     is an error because portfolio* attempts to point to a class template. A 
  19479.     pointer to a class template is undefined and produces an error. This 
  19480.     statement can be corrected by using the syntax of the invest() function 
  19481.     template instead. 
  19482.  
  19483. Because all friend functions in this example are declared but not defined, you 
  19484. could create a set of function templates to define those functions that are 
  19485. implicitly template functions (that is, all the valid functions except 
  19486. taxes()). The function templates would then be used to instantiate the template 
  19487. functions as required. 
  19488.  
  19489. Related Information 
  19490.  
  19491. o Friends 
  19492. o Class Templates 
  19493. o Function Templates 
  19494. o C++ Classes 
  19495. o Functions 
  19496.  
  19497.  
  19498. ΓòÉΓòÉΓòÉ 15.8. Static Data Members and Templates ΓòÉΓòÉΓòÉ
  19499.  
  19500. A static declaration within a class template declares a static data member for 
  19501. each template class generated from the template. The static declaration can be 
  19502. of type template-argument or of any defined type. 
  19503.  
  19504. Like cplr437'.member function templates, you can explicitly define a static 
  19505. data member of a template class at file scope for each type used to instantiate 
  19506. a template class. For example: 
  19507.  
  19508. template <class T> class key
  19509. {
  19510. public:
  19511.       static T x;
  19512. };
  19513. int key<int>::x;
  19514. char key<char>::x;
  19515. void main()
  19516. {
  19517.       key<int>::x = 0;
  19518. }
  19519.  
  19520. You can also define a static data member of a template class using a template 
  19521. definition at file scope. For example: 
  19522.  
  19523. template <class T> class key
  19524. {
  19525. public:
  19526.       static T x;
  19527. };
  19528. template <class T> T key<T> ::x; // template definition
  19529. void main()
  19530. {
  19531.       key<int>::x = 0;
  19532. }
  19533.  
  19534. When you instantiate a template class, you must have either an explicit 
  19535. definition or a template definition for each static data member, but not both. 
  19536.  
  19537. Example of Static Data Members in Templates 
  19538.  
  19539. Related Information 
  19540.  
  19541. o Static Members 
  19542. o Class Templates 
  19543. o Explicitly Defined Template Classes 
  19544. o Function Templates 
  19545. o Explicitly Defined Template Functions 
  19546.  
  19547.  
  19548. ΓòÉΓòÉΓòÉ <hidden> Example of Static Data Members in Templates ΓòÉΓòÉΓòÉ
  19549.  
  19550. In the following example: 
  19551.  
  19552. template<class L> class Key
  19553. {
  19554.       static L k;
  19555.       static L* kptr;
  19556.       static int length;
  19557.       // ...
  19558. }
  19559.  
  19560. The definitions of static variables and objects must be instantiated at file 
  19561. scope. If the classes Key<int> and Key<double> are instantiated from the above 
  19562. template, and no template definitions exist, the following static data members 
  19563. must be explicitly defined at file scope, or an error occurs: 
  19564.  
  19565. int Key<int>::k, Key<int>::length, Key<double>::length;
  19566. int* Key<int>::kptr;
  19567. double Key<double>::k;
  19568. double* Key<double>::kptr = 0;
  19569.  
  19570.  
  19571. ΓòÉΓòÉΓòÉ 16. Exception Handling ΓòÉΓòÉΓòÉ
  19572.  
  19573. This chapter describes the C/C++ Tools implementation of C++ exception handling 
  19574. and discusses: 
  19575.  
  19576. o Formal and Informal Exception Handling 
  19577. o Using Exception Handling 
  19578. o Transferring Control 
  19579. o Constructors and Destructors in Exception Handling 
  19580. o Exception Specifications 
  19581. o unexpected() and terminate() Functions 
  19582.  
  19583. Note:  C++ exception handling is not the same as OS/2 exception handling. A C++ 
  19584. exception exists only within the C++ language. An OS/2 exception is generated 
  19585. by the operating system, and can be used by the C/C++ Tools library to generate 
  19586. a signal. In this section, the term exception refers to a C++ exception. OS/2 
  19587. exception handling is described in detail in the IBM C/C++ Tools: Programming 
  19588. Guide. 
  19589.  
  19590.  
  19591. ΓòÉΓòÉΓòÉ 16.1. C++ Exception Handling Overview ΓòÉΓòÉΓòÉ
  19592.  
  19593. Exception handling provides a way for a function that encounters an unusual 
  19594. situation to throw an exception and pass control to a direct or indirect caller 
  19595. of that function. The caller may or may not be able to handle the exception. 
  19596. Code that intercepts an exception is called a handler. Regardless of whether or 
  19597. not the caller can handle an exception, it may rethrow the exception so it can 
  19598. be intercepted by another handler. 
  19599.  
  19600. C++ provides three language constructs to implement exception handling: 
  19601.  
  19602. o Try blocks 
  19603. o Catch blocks 
  19604. o Throw expressions 
  19605.  
  19606. Within a function, any unusual situation can be flagged with a throw 
  19607. expression. Your program can throw an object to pass information back to the 
  19608. caller. Any object can be thrown, including the object that caused the 
  19609. exception or an object constructed when the exception occurred. 
  19610.  
  19611. A call to a function that may throw an exception should be enclosed within a 
  19612. try statement. If the called function throws an exception and an exception 
  19613. handler is defined to catch the type of the object thrown, the exception 
  19614. handler is executed. In C++, a catch block implements an exception handler. 
  19615.  
  19616. A catch block follows immediately after a try statement or immediately after 
  19617. another catch block. A catch block includes a parenthesized exception 
  19618. declaration containing optional qualifiers, a type, and an optional variable 
  19619. name. The declaration specifies the type of object that the exception handler 
  19620. may catch. Once an exception is caught, the body of the catch block is 
  19621. executed. If a function throws an exception that cannot be caught, the program 
  19622. is terminated. 
  19623.  
  19624. Exception handling is not strictly synonymous with error handling, because the 
  19625. implementation allows the passing of an exception whether or not an error 
  19626. actually occurred. You can use exception handlers for things other than 
  19627. handling errors. For example, you can transfer control back to the original 
  19628. caller of a function. You might use this if you wanted to process the Quit key 
  19629. in a program and transfer control back to the driver program when the user 
  19630. types Quit. To do this exception handlers could be used to throw an object back 
  19631. to the driver. 
  19632.  
  19633. Note:  C++ exception handling is not the same as OS/2 exception handling. A C++ 
  19634. exception exists only within the C++ language. An OS/2 exception is generated 
  19635. by the operating system, and can be used by the C/C++ Tools library to generate 
  19636. a signal. In this section, the term exception refers to a C++ exception. OS/2 
  19637. exception handling is described in detail in the IBM C/C++ Tools: Programming 
  19638. Guide. 
  19639.  
  19640. Related Information 
  19641.  
  19642. o Formal and Informal Exception Handling 
  19643. o Using Exception Handling 
  19644. o Transferring Control 
  19645.  
  19646.  
  19647. ΓòÉΓòÉΓòÉ 16.2. Formal and Informal Exception Handling ΓòÉΓòÉΓòÉ
  19648.  
  19649. While the exception handling features of C++ offer a formal mechanism for 
  19650. handling exceptions (language implemented), in many situations informal 
  19651. exception handling (logic implemented) is more appropriate. Generally speaking, 
  19652. formal exception handling should be implemented in libraries, classes, and 
  19653. functions likely to be accessed by several programs or programmers. It should 
  19654. also be used in classes and functions that are repeatedly accessed within a 
  19655. program but are not well-suited to handling their exceptions themselves. 
  19656. Because formal exception handling is designed for exceptional circumstances, it 
  19657. is not guaranteed to be efficient. Program performance is usually not affected 
  19658. when you do not invoke formal exception handling, although it can inhibit some 
  19659. optimizations. 
  19660.  
  19661. Informal exception handling, in which the user defines the appropriate action 
  19662. if an error or exception occurs, is often more suitable for handling errors. 
  19663. For example, a simple error, such as a user entering incorrect input, can more 
  19664. easily and clearly be handled by testing the input for validity and by 
  19665. requesting the input again if the original input is incorrect. 
  19666.  
  19667. Related Information 
  19668.  
  19669. o C++ Exception Handling Overview 
  19670. o Using Exception Handling 
  19671. o Transferring Control 
  19672.  
  19673.  
  19674. ΓòÉΓòÉΓòÉ 16.3. Using Exception Handling ΓòÉΓòÉΓòÉ
  19675.  
  19676. The three keywords designed for exception handling in C++ are try, catch, and 
  19677. throw. 
  19678.  
  19679. Syntax of Exception Handling Keywords 
  19680.  
  19681. The steps required to implement an exception handler are: 
  19682.  
  19683.  1. Functions that are expected to be used by many programs are coded so that, 
  19684.     when an error is detected, an exception is thrown. The throw expression 
  19685.     generally throws an object. It may be created explicitly for purposes of 
  19686.     exception handling, or it may be the object that caused the error to be 
  19687.     detected. 
  19688.  
  19689.  2. Exceptions are anticipated in a caller by means of a try statement. 
  19690.     Function calls that you anticipate might produce an exception can be 
  19691.     enclosed in braces and preceded by the keyword try. 
  19692.  
  19693.  3. Immediately following the try block, you can code one or more catch blocks. 
  19694.     Each catch block identifies what type or class of objects it can catch: 
  19695.  
  19696.     a. If the object thrown matches the type of a catch expression, control 
  19697.        passes to that catch block. 
  19698.     b. If the object thrown does not match the first catch block, subsequent 
  19699.        catch blocks are searched for a matching type. 
  19700.     c. If no match is found, the search continues in all enclosing try blocks 
  19701.        and then in the caller of the current function. 
  19702.     d. If no match is found after all try blocks are searched, a call to 
  19703.        terminate() is made, and the program is terminated normally. For 
  19704.     information on the default handlers of uncaught exceptions, see 
  19705.     unexpected() and terminate() Functions. 
  19706.  
  19707. Notes: 
  19708.  
  19709. o Any object can be thrown if it can be copied and destroyed in the function 
  19710.   from which the throw occurs. 
  19711. o Exceptions should never be thrown from a C language signal handler. The 
  19712.   result is undefined, and can cause program termination. 
  19713.  
  19714. A catch argument causes an error if it is a value argument, and a copy of it 
  19715. cannot be generated. Similarly, a throw expression causes an error if a copy of 
  19716. the value of the expression being thrown cannot be generated. 
  19717.  
  19718. Example of an Illegal catch Argument 
  19719.  
  19720. Related Information 
  19721.  
  19722. o C++ Exception Handling Overview 
  19723. o Formal and Informal Exception Handling 
  19724. o Transferring Control 
  19725. o Exception Specifications 
  19726. o unexpected() and terminate() Functions 
  19727.  
  19728.  
  19729. ΓòÉΓòÉΓòÉ <hidden> Syntax of Exception Handling Keywords ΓòÉΓòÉΓòÉ
  19730.  
  19731. The syntax for the try and catch keywords is: 
  19732.  
  19733.       ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  19734.             Γöé
  19735. >>ΓöÇΓöÇtryΓöÇΓöÇ{ΓöÇΓöÇΓöÇΓöÇstatementΓöÇΓö┤ΓöÇΓöÇ}ΓöÇΓöÇcatchΓöÇΓöÇ(ΓöÇΓöÇ>
  19736.                              ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  19737.                                    Γöé
  19738. >ΓöÇΓöÇΓö¼ΓöÇ. . .ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ)ΓöÇΓöÇ{ΓöÇΓöÇΓöÇΓöÇstatementΓöÇΓö┤ΓöÇΓöÇ}ΓöÇΓöÇ><
  19739.   Γöé ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ              Γöé
  19740.   Γöé          Γöé              Γöé
  19741.   ΓööΓöÇΓöÇΓöÇtype-specifierΓöÇΓö┤ΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÿ
  19742.              Γö£ΓöÇdeclaratorΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  19743.              ΓööΓöÇabstract-declaratorΓöÇΓöÿ
  19744.  
  19745. The syntax for the throw keyword is: 
  19746.  
  19747. >>ΓöÇΓöÇthrowΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇ><
  19748.       ΓööΓöÇassignment-expressionΓöÇΓöÿ
  19749.  
  19750.  
  19751. ΓòÉΓòÉΓòÉ <hidden> Example of an Illegal catch Argument ΓòÉΓòÉΓòÉ
  19752.  
  19753. A catch argument causes an error if it is a value argument, and a copy of it 
  19754. cannot be generated. For example: 
  19755.  
  19756. class B {
  19757. public:
  19758.       B();
  19759.       B(B&);
  19760. };
  19761.              // the following catch block will cause an error
  19762.              //
  19763. catch(const B x)
  19764. {
  19765. // ...
  19766. }
  19767.  
  19768. The catch block causes an error because the compiler does not know the type of 
  19769. the object thrown at compile time. It assumes that the type of the thrown 
  19770. object is the same as the type of the catch argument. In the above example, the 
  19771. thrown object is assumed to be of type const B. The compiler uses a copy 
  19772. constructor on the thrown argument to create the catch argument. Because there 
  19773. is no copy constructor for class B that accepts const B as an input argument, 
  19774. the compiler cannot to perform the construction and an error occurs. 
  19775.  
  19776.  
  19777. ΓòÉΓòÉΓòÉ 16.4. Transferring Control ΓòÉΓòÉΓòÉ
  19778.  
  19779. C++ implements the termination model of exception handling. In the termination 
  19780. model, when an exception is thrown, control never returns to the throw point. 
  19781. The throw point is the point in program execution where the exception occurred. 
  19782.  
  19783. C++ exception handling does not implement the resumption model of exception 
  19784. handling, which allows an exception handler to correct the exception and then 
  19785. return to the throw point. 
  19786.  
  19787. When an exception is thrown, control is passed out of the throw expression and 
  19788. out of the try block that anticipated the exception. Control is passed to the 
  19789. catch block whose exception type matches the object thrown. The catch block 
  19790. handles the exception as appropriate. If the catch block ends normally, the 
  19791. flow of control passes over all subsequent catch blocks. 
  19792.  
  19793. When an exception is not thrown from within a try block, the flow of control 
  19794. continues normally through the block, and passes over all catch blocks 
  19795. following the try block. 
  19796.  
  19797. An exception handler cannot return control to the source of the error by using 
  19798. the return statement. A return issued in this context returns from the function 
  19799. containing the catch block. 
  19800.  
  19801. If an exception is thrown and no try block is active, or if a try block is 
  19802. active and no catch block exception declaration matches the object thrown, a 
  19803. call to terminate() is issued. A call to terminate() in turn calls abort() to 
  19804. terminate the program. The abort() C library function is defined in the 
  19805. standard header file <stdlib.h>. 
  19806.  
  19807. Example of Basic Exception Handling 
  19808.  
  19809. Related Information 
  19810.  
  19811. o Catching Exceptions 
  19812. o Nested try Blocks 
  19813. o Rethrowing an Exception 
  19814. o Using a Conditional Expression in a Throw Expression 
  19815. o C++ Exception Handling Overview 
  19816. o Using Exception Handling 
  19817. o Exception Specifications 
  19818. o unexpected() and terminate() Functions 
  19819. o abort - Stop a Program 
  19820. o return 
  19821.  
  19822.  
  19823. ΓòÉΓòÉΓòÉ <hidden> Example of Basic Exception Handling ΓòÉΓòÉΓòÉ
  19824.  
  19825. /************************************************************************
  19826. *
  19827.  
  19828. The following example illustrates the basic use of try, catch, and throw. The 
  19829. program prompts for a numerical user input and determines the input's 
  19830. reciprocal. Before it attempts to print the reciprocal to standard output, it 
  19831. checks that the input value is nonzero, to avoid a division by zero. If the 
  19832. input is zero, an exception is thrown, and the catch block catches the 
  19833. exception. If the input is nonzero, the reciprocal is printed to standard 
  19834. output. 
  19835.  
  19836.                                                                         *
  19837. ************************************************************************/
  19838.  
  19839. #include <iostream.h>
  19840. #include <stdlib.h>
  19841. class IsZero { /* ... */ };
  19842. void ZeroCheck( int i )
  19843. {
  19844.          if (i==0)
  19845.                 throw IsZero();
  19846. }
  19847. void main()
  19848. {
  19849.          double a;
  19850.  
  19851.          cout << "Enter a number: ";
  19852.          cin >> a;
  19853.          try
  19854.          {
  19855.               ZeroCheck( a );
  19856.               cout << "Reciprocal is " << 1.0/a << endl;
  19857.          }
  19858.          catch ( IsZero )
  19859.          {
  19860.               cout << "Zero input is not valid" << endl;
  19861.               exit(1);
  19862.          }
  19863.          exit(0);
  19864. }
  19865.  
  19866. /************************************************************************
  19867. *
  19868.  
  19869. This example could have been coded more efficiently by using informal exception 
  19870. handling. However, it provides a simple illustration of formal exception 
  19871. handling. 
  19872.  
  19873.                                                                         *
  19874. ************************************************************************/
  19875.  
  19876.  
  19877. ΓòÉΓòÉΓòÉ 16.4.1. Catching Exceptions ΓòÉΓòÉΓòÉ
  19878.  
  19879. You can declare a handler to catch many types of exceptions. The allowable 
  19880. objects that a function can catch are declared in the parentheses following the 
  19881. catch keyword (the catch argument). You can catch objects of the fundamental 
  19882. types, base and derived class objects, references, and pointers to all of these 
  19883. types. You can also catch const and volatile types. 
  19884.  
  19885. You can also use the catch(...) form of the handler to catch all thrown 
  19886. exceptions that have not been caught by a previous catch block. The ellipsis in 
  19887. the catch argument indicates that any exception thrown can be handled by this 
  19888. handler. 
  19889.  
  19890. If an exception is caught by a catch(...) block, there is no direct way to 
  19891. access the object thrown. Information about an exception caught by catch(...) 
  19892. is very limited. You can declare an optional variable name if you want to 
  19893. access the thrown object in the catch block. 
  19894.  
  19895. A catch block can only catch accessible objects. The object caught must have an 
  19896. accessible copy constructor. For more information on access, see Member Access; 
  19897. on copy constructors, see Copy by Initialization. 
  19898.  
  19899. An argument in the catch argument of a handler will match an argument in the 
  19900. expression of the throw expression (throw argument) if any of the following 
  19901. conditions is met: 
  19902.  
  19903. o The catch argument type matches the type of the thrown object. 
  19904. o The catch argument is a public base class of the thrown class object. 
  19905. o The catch specifies a pointer type, and the thrown object is a pointer type 
  19906.   that can be converted to the pointer type of the catch argument by standard 
  19907.   pointer conversion. Pointer conversion is described on page -- Reference 
  19908.   cplr071 not found --.. 
  19909.  
  19910. Note:  If the type of the thrown object is const or volatile, the catch 
  19911. argument must also be a const or volatile for a match to occur. However, a 
  19912. const, volatile, or reference type catch argument can match a nonconstant, 
  19913. nonvolatile, or nonreference object type. A nonreference catch argument type 
  19914. will match a reference to an object of the same type. 
  19915.  
  19916. Always place a catch block that catches a derived class before a catch block 
  19917. that catches the base class of that derived class (following a try block). If a 
  19918. catch block for objects of a base class is followed by a catch block for 
  19919. objects of a derived class of that base class, the latter block is flagged as 
  19920. an error. 
  19921.  
  19922. A catch block of the form catch(...) must be the last catch block following a 
  19923. try block or an error occurs. This placement ensures that the catch(...) block 
  19924. does not prevent more specific catch blocks from catching exceptions intended 
  19925. for them. 
  19926.  
  19927. Related Information 
  19928.  
  19929. o C++ Exception Handling Overview 
  19930. o Using Exception Handling 
  19931. o Transferring Control 
  19932. o Exception Specifications 
  19933. o volatile and const Qualifiers 
  19934. o Nested try Blocks 
  19935. o Rethrowing an Exception 
  19936.  
  19937.  
  19938. ΓòÉΓòÉΓòÉ 16.4.2. Nested try Blocks ΓòÉΓòÉΓòÉ
  19939.  
  19940. When try blocks are nested and a throw occurs in a function called by an inner 
  19941. try block, control is transferred outward through the nested try blocks until 
  19942. the first catch block is found whose argument matches the argument of the throw 
  19943. expression. For example: 
  19944.  
  19945. try
  19946. {
  19947.       func1();
  19948.       try
  19949.       {
  19950.              func2();
  19951.       }
  19952.       catch (spec_err) { /* ... */ }
  19953.       func3();
  19954. }
  19955. catch (type_err) { /* ... */ }
  19956. // if no throw is issued, control resumes here.
  19957.  
  19958. In the above example, if spec_err is thrown within the inner try block (in this 
  19959. case, from func2()), the exception is caught by the inner catch block, and, 
  19960. assuming this catch block does not transfer control, func3() is called. If 
  19961. spec_err is thrown after the inner try block (for instance, by func3()), it is 
  19962. not caught and the function terminate() is called. 
  19963.  
  19964. If the exception thrown from func2() in the inner try block is type_err, the 
  19965. program will skip out of both try blocks to the second catch block without 
  19966. invoking func3(), because no appropriate catch block exists following the inner 
  19967. try block. If the entire try block in the example is in a function that has a 
  19968. throw list and does not include spec_err on its throw list, unexpected() is 
  19969. called. 
  19970.  
  19971. You can also nest a try block within a catch block. 
  19972.  
  19973. Related Information 
  19974.  
  19975. o Catching Exceptions 
  19976. o Transferring Control 
  19977. o Using Exception Handling 
  19978. o Rethrowing an Exception 
  19979. o Exception Specifications 
  19980. o unexpected() and terminate() Functions 
  19981.  
  19982.  
  19983. ΓòÉΓòÉΓòÉ 16.4.3. Rethrowing an Exception ΓòÉΓòÉΓòÉ
  19984.  
  19985. If a catch block cannot handle the particular exception it has caught, you can 
  19986. rethrow the exception. The rethrow expression (throw with no argument) causes 
  19987. the originally thrown object to be rethrown. 
  19988.  
  19989. Because the exception has already been caught at the scope in which the rethrow 
  19990. expression occurs, it is rethrown out to the next dynamically enclosing try 
  19991. block. Therefore, it cannot be handled by catch blocks at the scope in which 
  19992. the rethrow expression occurred. Any catch blocks following the dynamically 
  19993. enclosing try block have an opportunity to catch the exception. 
  19994.  
  19995. Example of Rethrowing an Exception 
  19996.  
  19997. The rethrow expression can be caught by any catch whose argument matches the 
  19998. argument of the exception originally thrown. 
  19999.  
  20000. Related Information 
  20001.  
  20002. o Catching Exceptions 
  20003. o Transferring Control 
  20004. o Using Exception Handling 
  20005. o Nested try Blocks 
  20006. o Using a Conditional Expression in a Throw Expression 
  20007. o Exception Specifications 
  20008.  
  20009.  
  20010. ΓòÉΓòÉΓòÉ <hidden> Example of Rethrowing an Exception ΓòÉΓòÉΓòÉ
  20011.  
  20012. /************************************************************************
  20013. *
  20014.  
  20015. In the following example, catch(FileIO) catches any object of type FileIO and 
  20016. any objects that are public base classes of the FileIO class. It then checks 
  20017. for those exceptions it can handle. For any exception it cannot handle, it 
  20018. issues a rethrow expression to rethrow the exception and allow another handler 
  20019. in a dynamically enclosing try block to handle the exception. 
  20020.  
  20021.                                                                         *
  20022. ************************************************************************/
  20023.  
  20024. #include <iostream.h>
  20025. class FileIO
  20026. {
  20027. public:
  20028.       int notfound;
  20029.       int endfile;
  20030.       FileIO(); // initialize data members
  20031.       // the following member functions throw an exception
  20032.       // if an input error occurs
  20033.       void advance(int x);
  20034.       void clear();
  20035.       void put(int x, int y);
  20036. };
  20037. //      .
  20038. //      .
  20039. //      .
  20040. void f()
  20041. {
  20042.       FileIO fio;
  20043.       try
  20044.       {
  20045.             // call member functions of FileIO class
  20046.             fio.advance (1);
  20047.             fio.clear();
  20048.             fio.put(1,-1);
  20049.       }
  20050.  
  20051.       catch(FileIO fexc)
  20052.       {
  20053.             if (fexc.notfound)
  20054.                   cout << "File not Found" << endl;
  20055.             else if (fexc.endfile)
  20056.                   cout << "End of File" << endl;
  20057.             else
  20058.                   throw;            // rethrow to outer handler
  20059.       }
  20060.       catch(...) { /* ... */ }      // catch other
  20061. exceptions
  20062. }
  20063. main()
  20064. {
  20065.       try
  20066.       {
  20067.             f();
  20068.       }
  20069.       catch(FileIO) { cout << "Outer Handler" << endl; }
  20070. }
  20071.  
  20072. /************************************************************************
  20073. *
  20074.  
  20075. The rethrow expression can be caught by any catch whose argument matches the 
  20076. argument of the exception originally thrown. Note that, in this example, the 
  20077. catch(...) will not catch the rethrow expression because, when the rethrow 
  20078. expression is issued, control passes out of the scope of the function f() into 
  20079. the next dynamically enclosing block. 
  20080.  
  20081.                                                                         *
  20082. ************************************************************************/
  20083.  
  20084.  
  20085. ΓòÉΓòÉΓòÉ 16.4.4. Using a Conditional Expression in a Throw Expression ΓòÉΓòÉΓòÉ
  20086.  
  20087. You can use a conditional expression as a throw expression. Consider the 
  20088. following example: 
  20089.  
  20090. #include <iostream.h>
  20091. void main() {
  20092.       int doit = 1;
  20093.       int dont = 0;
  20094.       float f = 8.9;
  20095.       int i = 7;
  20096.       int j = 6;
  20097.       try { throw doit ? i : f; }
  20098.       catch (int x)
  20099.       {
  20100.             cout << "Caught int " << x << endl;
  20101.       }
  20102.       catch (float x)
  20103.       {
  20104.             cout << "Caught float " << x << endl;
  20105.       }
  20106.       catch (double x)
  20107.       {
  20108.             cout << "Caught double " << x << endl;
  20109.       }
  20110.       catch (...)
  20111.       {
  20112.             cout << "Caught something " << endl;
  20113.       }
  20114. }
  20115.  
  20116. This example produces the following output: 
  20117.  
  20118. Caught float 7
  20119.  
  20120. At first glance, it looks as if the block that catches integer values should do 
  20121. the catch, but i is converted to a float value in the try block because it is 
  20122. in a conditional expression with the float value f. If the try block in the 
  20123. example is replaced with the following try block: 
  20124.  
  20125.       try { throw doit ? i : j; }
  20126.  
  20127. The following output is produced: 
  20128.  
  20129. Caught int 7
  20130.  
  20131. Related Information 
  20132.  
  20133. o Catching Exceptions 
  20134. o Transferring Control 
  20135. o Using Exception Handling 
  20136. o Nested try Blocks 
  20137. o Rethrowing an Exception 
  20138. o Exception Specifications 
  20139.  
  20140.  
  20141. ΓòÉΓòÉΓòÉ 16.5. Constructors and Destructors in Exception Handling ΓòÉΓòÉΓòÉ
  20142.  
  20143. When an exception is thrown and control passes to a catch block following a try 
  20144. block, destructors are called for all objects constructed since the beginning 
  20145. of the try block directly associated with that catch block. If an exception is 
  20146. thrown during construction of an object consisting of subobjects or array 
  20147. elements, destructors will only be called for those subobjects or array 
  20148. elements successfully constructed before the exception was thrown. 
  20149.  
  20150. For more information on constructors and destructors, see Constructors and 
  20151. Destructors Overview. 
  20152.  
  20153. If a destructor detects an exception and issues a throw, the exception can be 
  20154. caught if the caller of the destructor was contained within a try block and an 
  20155. appropriate catch is coded. 
  20156.  
  20157. If an exception is thrown by a function called from an inner try block, but 
  20158. caught by an outer try block (because the inner try block did not have an 
  20159. appropriate handler), all objects constructed within both the outer and all 
  20160. inner try blocks are destroyed. If the thrown object has a destructor, the 
  20161. destructor is not called until the exception is caught and handled. 
  20162.  
  20163. Because a throw expression throws an object and a catch statement can catch an 
  20164. object, the object thrown enables error-related information to be transferred 
  20165. from the point at which an exception is detected to the exception's handler. If 
  20166. you throw an object with a constructor, you can construct an object that 
  20167. contains information relevant to the catch expression. The catch block can then 
  20168. access information provided by the thrown object. 
  20169.  
  20170. Example of Using Constructors in Exception Handling 
  20171.  
  20172. Exception handling can be used in conjunction with constructors and destructors 
  20173. to provide resource management that ensures that all locked resources are 
  20174. unlocked when an exception is thrown. 
  20175.  
  20176. Example of Managing Resources with Constructors and Destructors 
  20177.  
  20178. Related Information 
  20179.  
  20180. o Constructors and Destructors Overview 
  20181. o C++ Exception Handling Overview 
  20182. o Using Exception Handling 
  20183. o Transferring Control 
  20184. o Exception Specifications 
  20185.  
  20186.  
  20187. ΓòÉΓòÉΓòÉ <hidden> Managing Resources with Constructors and Destructors ΓòÉΓòÉΓòÉ
  20188.  
  20189. /************************************************************************
  20190. *
  20191.  
  20192. Exception handling can be used in conjunction with constructors and destructors 
  20193. to provide resource management that ensures that all locked resources are 
  20194. unlocked when an exception is thrown. Consider the following example: 
  20195.  
  20196.                                                                         *
  20197. ************************************************************************/
  20198.  
  20199. class data
  20200. {
  20201.       public:
  20202.             void lock();      // prevent other users
  20203. from
  20204.                               // changing the object
  20205.             void unlock();    // allow other users to change
  20206.                               // the object
  20207. };
  20208. void q(data&), bar(data&);
  20209. // ...
  20210. main()
  20211. {
  20212.       data important;
  20213.       important.lock();
  20214.       q(important);
  20215.       bar(important);
  20216.       important.unlock();
  20217. }
  20218.  
  20219. /************************************************************************
  20220. *
  20221.  
  20222. If q() or bar() throw an exception, important.unlock() will not be called and 
  20223. the data will stay locked. This problem can be corrected by using a helper 
  20224. class to write an "exception aware" program for resource management. 
  20225.  
  20226.                                                                         *
  20227. ************************************************************************/
  20228.  
  20229. class data
  20230. {
  20231.       public:
  20232.             void lock();      // prevent other users from
  20233.                               // changing the object
  20234.             void unlock();    // allow other users to change
  20235.                               // the object
  20236. };
  20237. class locked_data             // helper class
  20238. {
  20239.       data& real_data;
  20240.       public:
  20241.             locked_data(data& d) : real_data(d)
  20242.                               {real_data.lock();}
  20243.             ~locked_data() {real_data.unlock();}
  20244. };
  20245. void q(data&), bar(data&);
  20246. // ...
  20247. main()
  20248. {
  20249.       data important;
  20250.       locked_data my_lock(important);
  20251.       q(important);
  20252.       bar(important);
  20253. }
  20254.  
  20255. /************************************************************************
  20256. *
  20257.  
  20258. In this case, if q() or bar() throws an exception, the destructor for my_lock 
  20259. will be called, and the data will be unlocked. 
  20260.  
  20261.                                                                         *
  20262. ************************************************************************/
  20263.  
  20264.  
  20265. ΓòÉΓòÉΓòÉ <hidden> Example of Using Constructors in Exception Handling ΓòÉΓòÉΓòÉ
  20266.  
  20267. /************************************************************************
  20268. *
  20269. In the following example, an object of class DivideByZero is thrown by the 
  20270. function divide(). The constructor copies the string "Division by zero" into 
  20271. the char array errname. Because DivideByZero is a derived class of class 
  20272. Matherr, the catch block for Matherr catches the thrown exception. The catch 
  20273. block can then access information provided by the thrown object, in this case 
  20274. the text of an error message. 
  20275.  
  20276.                                                                         *
  20277. ************************************************************************/
  20278.  
  20279. #include <string.h>            // needed for strcpy
  20280. #include <iostream.h>
  20281. class Matherr { public: char errname[30]; };
  20282. class DivideByZero : public Matherr
  20283. {
  20284. public:
  20285.       DivideByZero() {strcpy (errname, "Division by zero");}
  20286. };
  20287. double divide(double a, double b)
  20288. {
  20289.       if (b == 0) throw DivideByZero();
  20290.       return a/b;
  20291. }
  20292.  
  20293. void main()
  20294. {
  20295.       double a=7,b=0;
  20296.       try {divide (a,b);}
  20297.       catch (Matherr xx)
  20298.       {
  20299.             cout << xx.errname << endl;
  20300.       }
  20301. }
  20302.  
  20303.  
  20304. ΓòÉΓòÉΓòÉ 16.6. Exception Specifications ΓòÉΓòÉΓòÉ
  20305.  
  20306. C++ provides a mechanism to ensure that a given function is limited to throwing 
  20307. only a specified list of exceptions. An exception specification at the 
  20308. beginning of any function acts as a guarantee to the function's caller that the 
  20309. function will not throw any exception not contained in the exception 
  20310. specification. For example, a function: 
  20311.  
  20312. void translate() throw(unknown_word,bad_grammar) { /* ... */ }
  20313.  
  20314. explicitly states that it will not throw any exception other than unknown_word 
  20315. or bad_grammar. The function translate() must handle any exceptions thrown by 
  20316. functions it might call, unless those exceptions are specified in the exception 
  20317. specification of translate(). If an exception is thrown by a function called by 
  20318. translate() and the exception is not handled by translate() or contained in the 
  20319. exception specification of translate(), unexpected() is called. 
  20320.  
  20321. Syntax of an Exception Specification 
  20322.  
  20323. If an exception is thrown from a function that has not specified the thrown 
  20324. exception in its exception specification, the result is a call to the function 
  20325. unexpected(), which is discussed in unexpected() and terminate() Functions. 
  20326.  
  20327. A function with an empty throw() specification guarantees that the function 
  20328. will not throw any exceptions. A function without an exception specification 
  20329. allows any object to be thrown from the function. 
  20330.  
  20331. The compiler does not prevent an exception specification from defining a more 
  20332. limited set of valid exceptions than the set of exceptions the function may 
  20333. actually throw. Such an error will be detected only at run time, and only if 
  20334. the unspecified exception is thrown. 
  20335.  
  20336. Example of Throwing an Unspecified Exception 
  20337.  
  20338. If a function with an exception specification calls a subfunction with a less 
  20339. restrictive exception specification (one that contains more objects than the 
  20340. calling function's exception specification), any thrown objects from within the 
  20341. subfunction that are not handled by the subfunction, and that are not part of 
  20342. the outer function's specification list, must be handled within the outer 
  20343. function. If the outer function fails to handle an exception not in its 
  20344. exception specification, a call to unexpected() is made. 
  20345.  
  20346. Related Information 
  20347.  
  20348. o unexpected() and terminate() Functions 
  20349. o C++ Exception Handling Overview 
  20350. o Using Exception Handling 
  20351. o Transferring Control 
  20352.  
  20353.  
  20354. ΓòÉΓòÉΓòÉ <hidden> Syntax of an Exception Specification ΓòÉΓòÉΓòÉ
  20355.  
  20356. The syntax of the exception specification is: 
  20357.  
  20358.        ΓöîΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  20359.             Γöé
  20360. >>ΓöÇΓöÇthrowΓöÇΓöÇ(ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇΓöÇ)ΓöÇΓöÇ><
  20361.         ΓööΓöÇtypeΓöÇΓöÿ
  20362.  
  20363. The syntax of a function definition that includes an exception specification 
  20364. is: 
  20365.  
  20366.                   ΓöîΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ       ΓöîΓöÇ,ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  20367.                          Γöé            Γöé
  20368. >>ΓöÇΓöÇreturn-typeΓöÇΓöÇfunction-nameΓöÇΓöÇ(ΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇΓöÇ)ΓöÇΓöÇthrowΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼Γö┤ΓöÇΓöÇ)ΓöÇΓöÇ>
  20369.                   ΓööΓöÇargumentΓöÇΓöÿ        ΓööΓöÇtypeΓöÇΓöÿ
  20370. >ΓöÇΓöÇ{ΓöÇΓöÇfunction-bodyΓöÇΓöÇ}ΓöÇΓöÇ><
  20371.  
  20372.  
  20373. ΓòÉΓòÉΓòÉ <hidden> Example of Throwing an Unspecified Exception ΓòÉΓòÉΓòÉ
  20374.  
  20375. In the following example, NameTooShort is thrown from within a function that 
  20376. explicitly states that it will only throw NameTooLong. This is a valid 
  20377. function, although at run time, if NameTooShort is thrown, a call to 
  20378. unexpected() will be made. 
  20379.  
  20380. #include <string.h>            // needed for strlen
  20381. class NameTooLong {};
  20382. class NameTooShort {};
  20383.  
  20384. void check(char* fname) throw (NameTooLong)
  20385. {
  20386.        if ( strlen(fname)<4 ) throw NameTooShort();
  20387. }
  20388.  
  20389.  
  20390. ΓòÉΓòÉΓòÉ 16.7. unexpected() and terminate() Functions ΓòÉΓòÉΓòÉ
  20391.  
  20392. Not all thrown errors can be caught and successfully dealt with by a catch 
  20393. block. In some situations, the best way to handle an exception is to terminate 
  20394. the program. Two special library functions are implemented in C++ to process 
  20395. exceptions not properly handled by catch blocks or exceptions thrown outside of 
  20396. a valid try block. These functions are unexpected() and terminate(). 
  20397.  
  20398. When a function with an exception specification throws an exception that is not 
  20399. listed in its exception specification, the function unexpected() is called. 
  20400. Next, unexpected() calls a function specified by the set_unexpected() function. 
  20401. By default, unexpected() calls the function terminate(). 
  20402.  
  20403. In some cases, the exception handling mechanism will fail and a call to 
  20404. terminate() will be made. This terminate() call occurs in any of the following 
  20405. situations: 
  20406.  
  20407. o When terminate() is explicitly called 
  20408. o When no catch can be matched to a thrown object 
  20409. o When the stack becomes corrupted during the exception-handling process 
  20410. o When a system defined unexpected() is called 
  20411.  
  20412. The terminate() function calls a function specified by the set_terminate() 
  20413. function. By default, terminate calls abort(), which exits from the program. 
  20414.  
  20415. Related Information 
  20416.  
  20417. o set_unexpected() and set_terminate() 
  20418. o C++ Exception Handling Overview 
  20419. o Exception Specifications 
  20420. o Using Exception Handling 
  20421. o Transferring Control 
  20422. o abort - Stop a Program 
  20423.  
  20424.  
  20425. ΓòÉΓòÉΓòÉ 16.7.1. set_unexpected() and set_terminate() ΓòÉΓòÉΓòÉ
  20426.  
  20427. The function unexpected(), when invoked, calls the function most recently 
  20428. supplied as an argument to set_unexpected(). If set_unexpected() has not yet 
  20429. been called, unexpected() calls terminate(). 
  20430.  
  20431. The function terminate(), when invoked, calls the function most recently 
  20432. supplied as an argument to set_terminate(). If set_terminate() has not yet been 
  20433. called, terminate() calls abort(), which ends the program. 
  20434.  
  20435. You can use set_unexpected() and set_terminate() to replace terminate() and 
  20436. abort(), respectively, with your own functions. set_unexpected() and 
  20437. set_terminate() are included in the standard header files <unexpect.h>. and 
  20438. <terminat.h>. Each of these functions has as its return type and its argument 
  20439. type a pointer to function with a void return type and no arguments. The 
  20440. pointer to function you supply as the argument becomes the function called by 
  20441. the corresponding special function: the argument to set_unexpected() becomes 
  20442. the function called by unexpected(), and the argument to set_terminate() 
  20443. becomes the function called by terminate(). Both set_unexpected() and 
  20444. set_terminate() return a pointer to the function that was previously called by 
  20445. their respective special functions (unexpected() and terminate()). By saving 
  20446. the return values, you can restore the original special functions later so that 
  20447. unexpected() and terminate() will once again call terminate() and abort(). 
  20448.  
  20449. If you use set_terminate() to define your own function to replace abort(), the 
  20450. final action of that program should be to exit from the program. If you attempt 
  20451. to return from the function called by terminate(), abort() is called instead 
  20452. and the program ends. 
  20453.  
  20454. Note:  Providing a call to longjmp() inside a user-defined terminate function 
  20455. can transfer execution control to some other desired point. 
  20456.  
  20457. Example of Using the Exception Handling Functions 
  20458.  
  20459. Related Information 
  20460.  
  20461. o unexpected() and terminate() Functions 
  20462. o C++ Exception Handling Overview 
  20463. o Using Exception Handling 
  20464. o Transferring Control 
  20465. o abort - Stop a Program 
  20466. o longjmp - Restore Stack Environment 
  20467.  
  20468.  
  20469. ΓòÉΓòÉΓòÉ 16.7.2. Example of Using the Exception Handling Functions ΓòÉΓòÉΓòÉ
  20470.  
  20471. /************************************************************************
  20472. *
  20473.  
  20474. The following example shows the flow of control and special functions used in 
  20475. exception handling: 
  20476.  
  20477.                                                                         *
  20478. ************************************************************************/
  20479.  
  20480. #include <terminat.h>
  20481. #include <unexpect.h>
  20482. #include <iostream.h>
  20483. class X { /* ... */ };
  20484. class Y { /* ... */ };
  20485. class A { /* ... */ };
  20486. // pfv type is pointer to function returning void
  20487. typedef void (*pfv)();
  20488. void my_terminate()
  20489. {      cout << "Call to my terminate" << endl; }
  20490. void my_unexpected()
  20491. {      cout << "Call to my unexpected" << endl; }
  20492. void f() throw(X,Y)      // f() is permitted to throw objects of class
  20493.                          // types X and Y only
  20494. {
  20495.       A aobj;
  20496.       throw(aobj); // error, f() throws a class A object
  20497. }
  20498. main()
  20499. {
  20500.       pfv old_term = set_terminate(my_terminate);
  20501.       pfv old_unex = set_unexpected(my_unexpected);
  20502.       try{ f(); }
  20503.       catch(X)       { /* ... */ }
  20504.       catch(Y)       { /* ... */ }
  20505.       catch (...)    { /* ... */ }
  20506.  
  20507.       set_unexpected(old_unex);
  20508.       try { f();}
  20509.       catch(X)       { /* ... */ }
  20510.       catch(Y)       { /* ... */ }
  20511.       catch (...)    { /* ... */ }
  20512. }
  20513.  
  20514. /************************************************************************
  20515. *
  20516.  
  20517. At run time, this program behaves as follows: 
  20518.  
  20519.  1. The call to set_terminate() assigns to old_term the address of the function 
  20520.     last passed to set_terminate() when set_terminate() was previously called. 
  20521.  
  20522.  2. The call to set_unexpected() assigns to old_unex the address of the 
  20523.     function last passed to set_unexpected() when set_unexpected() was 
  20524.     previously called. 
  20525.  
  20526.  3. Within a try block, function f() is called. Because f() throws an 
  20527.     unexpected exception, a call to unexpected() is made. unexpected() in turn 
  20528.     calls my_unexpected(), which prints a message to standard output and 
  20529.     returns. 
  20530.  
  20531.  4. The second call to set_unexpected() replaces the user-defined function 
  20532.     my_unexpected() with the saved pointer to the original function 
  20533.     (terminate()) called by unexpected(). 
  20534.  
  20535.  5. Within a second try block, function f() is called once more. Because f() 
  20536.     throws an unexpected exception, a call to unexpected() is again made. 
  20537.     unexpected() automatically calls terminate(), which calls the function 
  20538.     my_terminate(). 
  20539.  
  20540.  6. my_terminate() displays a message. It returns, and the system calls 
  20541.     abort(), which terminates the program. 
  20542.  
  20543. At run time, the following information is displayed, and the program ends: 
  20544.  
  20545. Call to my_unexpected
  20546. Call to my_terminate
  20547.  
  20548. Note:  The catch blocks following the try block are not entered, because the 
  20549. exception was handled by my_unexpected() as an unexpected throw, not as a valid 
  20550. exception. 
  20551.  
  20552.                                                                         *
  20553. ************************************************************************/
  20554.  
  20555.  
  20556. ΓòÉΓòÉΓòÉ 17. C and C++ Compatibility ΓòÉΓòÉΓòÉ
  20557.  
  20558. The differences between ANSI C and C++ fall into two categories: 
  20559.  
  20560. o Constructs found in C++ but not in ANSI C 
  20561. o Constructs found in both C++ and ANSI C, but treated differently in the two 
  20562.   languages 
  20563.  
  20564. C++ contains many constructs that are not found in ANSI C: 
  20565.  
  20566. o Single line comments beginning with // 
  20567. o Scope operator (::) 
  20568. o Free store management using the operators new and delete 
  20569. o Linkage specification for functions 
  20570. o Reference types 
  20571. o Default arguments for functions 
  20572. o Inline functions 
  20573. o Classes 
  20574. o Anonymous unions 
  20575. o Overloaded operators and functions 
  20576. o Class templates and function templates 
  20577. o Exception handling 
  20578.  
  20579. Note:  The C/C++ Tools compiler also supports anonymous unions in C, but the 
  20580. implementation is slightly different from C++. For more information, see 
  20581. Anonymous Unions in C. 
  20582.  
  20583.  
  20584. ΓòÉΓòÉΓòÉ 17.1. Constructs Treated Differently in C and C++ ΓòÉΓòÉΓòÉ
  20585.  
  20586. Because C++ is based on ANSI C, the two languages have many constructs in 
  20587. common. The use of some of these shared constructs differs, as shown here. 
  20588.  
  20589. o Character Array Initialization 
  20590. o Character Constants 
  20591. o Class and typedef Names 
  20592. o Class and Scope Declarations 
  20593. o const Object Initialization 
  20594. o Definitions 
  20595. o Definitions within Return or Argument Types 
  20596. o Enumerator Type 
  20597. o Enumeration Type 
  20598. o Function Declarations 
  20599. o Functions with an Empty Argument List 
  20600. o Global Constant Linkage 
  20601. o Jump Statements 
  20602. o Keywords 
  20603. o main() Recursion 
  20604. o Names of Nested Classes 
  20605. o Pointers to void 
  20606. o Prototype Declarations 
  20607. o Return without Declared Value 
  20608. o __STDC__ Macro 
  20609. o typedefs in Class Declarations 
  20610.  
  20611. Related Information 
  20612.  
  20613. o C and C++ Compatibility 
  20614.  
  20615.  
  20616. ΓòÉΓòÉΓòÉ 17.1.1. Character Array Initialization ΓòÉΓòÉΓòÉ
  20617.  
  20618. In C++, when you initialize character arrays, a trailing '\0' (zero of type 
  20619. char) is appended to the string initializer. You cannot initialize a character 
  20620. array with more initializers than there are array elements. 
  20621.  
  20622. In ANSI C, space for the trailing '\0' can be omitted in this type of 
  20623. initialization. 
  20624.  
  20625. The following initialization, for instance, is not valid in C++: 
  20626.  
  20627. char v[3] = "asd"; // not valid in C++, valid in ANSI C
  20628.  
  20629. because four elements are required. This initialization produces an error 
  20630. because there is no space for the implied trailing '\0' (zero of type char). 
  20631. For more information, see Arrays. 
  20632.  
  20633.  
  20634. ΓòÉΓòÉΓòÉ 17.1.2. Character Constants ΓòÉΓòÉΓòÉ
  20635.  
  20636. A character constant has type char in C++ and int in ANSI C. See Character 
  20637. Constants for more information. 
  20638.  
  20639.  
  20640. ΓòÉΓòÉΓòÉ 17.1.3. Class and typedef Names ΓòÉΓòÉΓòÉ
  20641.  
  20642. In C++, a class and a typedef cannot both use the same name to refer to a 
  20643. different type within the same scope (unless the typedef is a synonym for the 
  20644. class name). In C, a typedef name and a struct tag name declared in the same 
  20645. scope can have the same name because they have different name spaces. For 
  20646. example: 
  20647.  
  20648. void main ()
  20649. {
  20650.      typedef double db;
  20651.      struct db; // error in C++, valid in ANSI C
  20652.  
  20653.      typedef struct st st; // valid ANSI C and C++
  20654. }
  20655.  
  20656. For more information on typedef, see typedef. For information on class types, 
  20657. see C++ Classes. For information on structures, see Structures. 
  20658.  
  20659.  
  20660. ΓòÉΓòÉΓòÉ 17.1.4. Class and Scope Declarations ΓòÉΓòÉΓòÉ
  20661.  
  20662. In C++, a class declaration introduces the class name into the scope where it 
  20663. is declared and hides any object, function, or other declaration of that name 
  20664. in an enclosing scope. In ANSI C, an inner scope declaration of a struct name 
  20665. does not hide an object or function of that name in an outer scope. For 
  20666. example: 
  20667.  
  20668. double db;
  20669. void main ()
  20670. {
  20671.      struct db               // hides double object db in C++
  20672.      { char* str; };
  20673.      int x = sizeof(db);     // size of struct in C++
  20674.                              // size of double in ANSI C
  20675. }
  20676.  
  20677. For more information, see Scope of Class Names. For general information about 
  20678. scope, see Scope in C++. 
  20679.  
  20680.  
  20681. ΓòÉΓòÉΓòÉ 17.1.5. const Object Initialization ΓòÉΓòÉΓòÉ
  20682.  
  20683. In C++, const objects must be initialized. In ANSI C, they can be left 
  20684. uninitialized. For more information, see volatile and const Qualifiers. 
  20685.  
  20686.  
  20687. ΓòÉΓòÉΓòÉ 17.1.6. Definitions ΓòÉΓòÉΓòÉ
  20688.  
  20689. An object declaration, for example: 
  20690.  
  20691. int i;
  20692.  
  20693. is a definition in C++. In ANSI C, it is a tentative definition. 
  20694.  
  20695. In C++, a global data object must be defined only once. In ANSI C, a global 
  20696. data object can be declared several times without using the extern keyword. 
  20697.  
  20698. In C++, multiple definitions for a single variable cause an error. A C 
  20699. compilation unit can contain many identical tentative definitions for a 
  20700. variable. 
  20701.  
  20702. For more information, see Declarations and Definitions. 
  20703.  
  20704.  
  20705. ΓòÉΓòÉΓòÉ 17.1.7. Definitions within Return or Argument Types ΓòÉΓòÉΓòÉ
  20706.  
  20707. In C++, types may not be defined in return or argument types. ANSI C allows 
  20708. such definitions. For example, the declarations: 
  20709.  
  20710. void print(struct X { int i;} x);      // error in C++
  20711. enum count{one, two, three} counter(); // error in C++
  20712.  
  20713. produce errors in C++, but are valid declarations in ANSI C. 
  20714.  
  20715. For more information, see Function Declarations and Calling Functions and 
  20716. Passing Arguments. 
  20717.  
  20718.  
  20719. ΓòÉΓòÉΓòÉ 17.1.8. Enumerator Type ΓòÉΓòÉΓòÉ
  20720.  
  20721. An enumerator has the same type as its enumeration in C++. In ANSI C, an 
  20722. enumeration has type int. 
  20723.  
  20724. For more information on enumerators, see Enumerations. 
  20725.  
  20726.  
  20727. ΓòÉΓòÉΓòÉ 17.1.9. Enumeration Type ΓòÉΓòÉΓòÉ
  20728.  
  20729. The assignment to an object of enumeration type with a value that is not of 
  20730. that enumeration type produces an error in C++. In ANSI C, an object of 
  20731. enumeration type can be assigned values of any integral type. 
  20732.  
  20733. For more information, see Enumerations. 
  20734.  
  20735.  
  20736. ΓòÉΓòÉΓòÉ 17.1.10. Function Declarations ΓòÉΓòÉΓòÉ
  20737.  
  20738. In C++, all declarations of a function must match the unique definition of a 
  20739. function. ANSI C has no such restriction. 
  20740.  
  20741. For more information, see Function Declarations. 
  20742.  
  20743.  
  20744. ΓòÉΓòÉΓòÉ 17.1.11. Functions with an Empty Argument List ΓòÉΓòÉΓòÉ
  20745.  
  20746. Consider the following function declaration: 
  20747.  
  20748.   int f();
  20749.  
  20750. In C++, this function declaration means that the function takes no arguments. 
  20751. In ANSI C, it could take any number of arguments, of any type. 
  20752.  
  20753. For more information, see Function Declarations. 
  20754.  
  20755.  
  20756. ΓòÉΓòÉΓòÉ 17.1.12. Global Constant Linkage ΓòÉΓòÉΓòÉ
  20757.  
  20758. In C++, an object declared const has internal linkage, unless it has previously 
  20759. been given external linkage. In ANSI C, it has external linkage. 
  20760.  
  20761. For more information, see Program Linkage. 
  20762.  
  20763.  
  20764. ΓòÉΓòÉΓòÉ 17.1.13. Jump Statements ΓòÉΓòÉΓòÉ
  20765.  
  20766. C++ does not allow you to jump over declarations containing initializations. 
  20767. ANSI C does allow you to use jump statements for this purpose. 
  20768.  
  20769. For more information, see Initializers. 
  20770.  
  20771.  
  20772. ΓòÉΓòÉΓòÉ 17.1.14. Keywords ΓòÉΓòÉΓòÉ
  20773.  
  20774. C++ contains some additional keywords not found in ANSI C. ANSI C programs that 
  20775. use these keywords as identifiers are not valid C++ programs: 
  20776.  
  20777. catch                    protected 
  20778. class                    public 
  20779. delete                   template 
  20780. friend                   this 
  20781. inline                   throw 
  20782. new                      try 
  20783. operator                 virtual 
  20784. private 
  20785.  
  20786. For more information, see Keywords. 
  20787.  
  20788.  
  20789. ΓòÉΓòÉΓòÉ 17.1.15. main() Recursion ΓòÉΓòÉΓòÉ
  20790.  
  20791. In C++, main() cannot be called recursively and cannot have its address taken. 
  20792. ANSI C allows recursive calls and allows pointers to hold the address of 
  20793. main(). 
  20794.  
  20795. For more information, see main. 
  20796.  
  20797.  
  20798. ΓòÉΓòÉΓòÉ 17.1.16. Names of Nested Classes ΓòÉΓòÉΓòÉ
  20799.  
  20800. In C++, the name of a nested class is local to its enclosing class. In ANSI C, 
  20801. the name of the nested structure belongs to the same scope as the name of the 
  20802. outermost enclosing structure. 
  20803.  
  20804. For more information, see Nested Classes. 
  20805.  
  20806.  
  20807. ΓòÉΓòÉΓòÉ 17.1.17. Pointers to void ΓòÉΓòÉΓòÉ
  20808.  
  20809. C++ allows void pointers to be assigned only to other void pointers. In ANSI C, 
  20810. a pointer to void can be assigned to a pointer of any other type without an 
  20811. explicit cast. For more information, see void Type and Pointers. 
  20812.  
  20813.  
  20814. ΓòÉΓòÉΓòÉ 17.1.18. Prototype Declarations ΓòÉΓòÉΓòÉ
  20815.  
  20816. C++ requires full prototype declarations. ANSI C allows nonprototyped 
  20817. functions. 
  20818.  
  20819. For more information, see Function Declarator. 
  20820.  
  20821.  
  20822. ΓòÉΓòÉΓòÉ 17.1.19. Return without Declared Value ΓòÉΓòÉΓòÉ
  20823.  
  20824. In C++, a return (either explicit or implicit) from main() that is declared to 
  20825. return a value results in a warning if no value is returned. A return (either 
  20826. explicit or implicit) from all other functions that is declared to return a 
  20827. value must return a value. In ANSI C, a function that is declared to return a 
  20828. value can return with no value. 
  20829.  
  20830. For more information, see Return Values. 
  20831.  
  20832.  
  20833. ΓòÉΓòÉΓòÉ 17.1.20. __STDC__ Macro ΓòÉΓòÉΓòÉ
  20834.  
  20835. The predefined macro variable __STDC__ has the integer value 0 to indicate that 
  20836. C++ does not conform to ANSI C. In ANSI C, __STDC__ has the integer value 1. 
  20837.  
  20838. For more information on macros, see Predefined Macros. 
  20839.  
  20840.  
  20841. ΓòÉΓòÉΓòÉ 17.1.21. typedefs in Class Declarations ΓòÉΓòÉΓòÉ
  20842.  
  20843. In C++, a typedef name may not be redefined in a class declaration after being 
  20844. used in the declaration. ANSI C allows such a declaration. For example: 
  20845.  
  20846. void main ()
  20847. {
  20848.      typedef double db;
  20849.      struct st
  20850.      {
  20851.           db x;
  20852.           double db; // error in C++, valid in ANSI C
  20853.      };
  20854. }
  20855.  
  20856. For more information, see typedef. 
  20857.  
  20858.  
  20859. ΓòÉΓòÉΓòÉ 18. Using Compiler Options ΓòÉΓòÉΓòÉ
  20860.  
  20861. You can use compiler options to alter the compilation and linking of your 
  20862. program. This section describes the options and tells you how to use them. 
  20863.  
  20864. The compiler options are divided into groups by function. The following list 
  20865. tells you which options are in each group. 
  20866.  
  20867. o Output File Management Options 
  20868.  
  20869.     /F
  20870.  
  20871. o #include File Search Options 
  20872.  
  20873.     /I  /X
  20874.  
  20875. o Listing File Options 
  20876.  
  20877.     /L
  20878.  
  20879. o Debugging and Diagnostic Information Options 
  20880.  
  20881.     /K  /N  /W  /Ti /Tm /Tx
  20882.  
  20883. o Source Code Options 
  20884.  
  20885.     /S  /Tc /Td /Tp
  20886.  
  20887. o Preprocessor Options 
  20888.  
  20889.     /D  /P  /U
  20890.  
  20891. o Code Generation Options 
  20892.  
  20893.     /G  /M  /Nd /Nt /O  /R
  20894.  
  20895. o Other Options 
  20896.  
  20897.     /B  /C  /H  /J  /Q  /Tl /V
  20898.  
  20899. Each group of options is described in a table in this section. In the tables, 
  20900. the Default column states the action the compiler takes if no option is 
  20901. specified; the Changing Default column shows how you can change the default. 
  20902.  
  20903. Where necessary, an option is described in greater detail in a separate panel 
  20904. that you can link to. 
  20905.  
  20906. Related Information 
  20907.  
  20908. o Specifying Compiler Options 
  20909. o Using Parameters with Compiler Options 
  20910. o Scope of Compiler Options 
  20911. o Related and Conflicting Options 
  20912. o Language-Dependent Options 
  20913. o Compiler Options for Presentation Manager Programming 
  20914.  
  20915.  
  20916. ΓòÉΓòÉΓòÉ 18.1. Specifying Compiler Options ΓòÉΓòÉΓòÉ
  20917.  
  20918. Compiler options are not case sensitive, so you can specify them in lower-, 
  20919. upper-, or mixed case. You can also substitute a dash (-) for the slash (/) 
  20920. preceding the option. For example, -Rn is equivalent to /Rn. Lower- and 
  20921. uppercase, dashes, and slashes can all be used on one command line, as in: 
  20922.  
  20923.    icc  /ls  -RN  -gD  /Li  prog.c
  20924.  
  20925. You can specify compiler options in the following ways: 
  20926.  
  20927. o On the command line 
  20928. o In the ICC environment variable 
  20929. o In the WorkFrame/2 environment 
  20930.  
  20931. Options specified on the command line override the options in the ICC variable. 
  20932.  
  20933. Related Information 
  20934.  
  20935. o Using Parameters with Compiler Options 
  20936. o Scope of Compiler Options 
  20937. o Related and Conflicting Options 
  20938. o Language-Dependent Options 
  20939. o Compiler Options for Presentation Manager Programming 
  20940. o Output File Management Options 
  20941. o #include File Search Options 
  20942. o Listing File Options 
  20943. o Debugging and Diagnostic Information Options 
  20944. o Source Code Options 
  20945. o Preprocessor Options 
  20946. o Code Generation Options 
  20947. o Other Options 
  20948.  
  20949.  
  20950. ΓòÉΓòÉΓòÉ <hidden> Specifying Options on the Command Line ΓòÉΓòÉΓòÉ
  20951.  
  20952. Compiler options specified on the command line override any previously 
  20953. specified in the ICC environment variable (as described in Specifying Options 
  20954. in ICC). 
  20955.  
  20956. For example, to compile a source file with the multithread option, enter: 
  20957.  
  20958.    icc /Gm myprog.c
  20959.  
  20960. When compiling programs with multiple source files, an option is in effect for 
  20961. all the source files that follow it. The executable module will have the same 
  20962. file name as the first source file but with the extension .EXE. 
  20963.  
  20964.  
  20965. ΓòÉΓòÉΓòÉ <hidden> Specifying Options in ICC ΓòÉΓòÉΓòÉ
  20966.  
  20967. Frequently used command-line options can be stored in the ICC environment 
  20968. variable. This method is useful if you find yourself repeating the same 
  20969. command-line options every time you compile. You can also specify source file 
  20970. names in ICC. 
  20971.  
  20972. The ICC environment variable can be set either from the command line, in a 
  20973. command (.CMD) file, or in the CONFIG.SYS file.  If it is set on the command 
  20974. line or by running a command file, the options will only be in effect for the 
  20975. current session. If it is set in the CONFIG.SYS file, the options will be in 
  20976. effect every time you use icc unless you override them using a .CMD file or by 
  20977. specifying options on the command line. 
  20978.  
  20979. For example, to specify that a source listing be generated for all compilations 
  20980. and that the macro DEBUG be defined to be 1, use the following command at the 
  20981. OS/2 prompt (or in your CONFIG.SYS file if you want these options every time 
  20982. you use the compiler): 
  20983.  
  20984.    SET ICC=/Ls+  /DDEBUG::1
  20985.  
  20986. (The double colon must be used because the "=" sign is not allowed in OS/2 
  20987. environment variables.) 
  20988.  
  20989. Now, type icc prog1.C to compile prog1.C. The macro DEBUG will be defined as 1, 
  20990. and a source listing will be produced. 
  20991.  
  20992. Options specified on the command line override the options in the ICC variable. 
  20993. For example, the following compiler invocation voids the effect of the ICC 
  20994. setting in the last example: 
  20995.  
  20996.    icc /Ls- /UDEBUG fred.c
  20997.  
  20998.  
  20999. ΓòÉΓòÉΓòÉ <hidden> Setting Options in the WorkFrame/2 Environment ΓòÉΓòÉΓòÉ
  21000.  
  21001. If you have installed the WorkFrame/2 product, you can set compiler options 
  21002. using the options dialogs.  You can use the dialogs when you create or modify a 
  21003. project. 
  21004.  
  21005. Options you select while creating or changing a project are saved with that 
  21006. project. 
  21007.  
  21008. For more information on setting options and using the WorkFrame/2, refer to its 
  21009. documentation. 
  21010.  
  21011.  
  21012. ΓòÉΓòÉΓòÉ 18.1.1. Using Parameters with Compiler Options ΓòÉΓòÉΓòÉ
  21013.  
  21014. For all compiler options that take parameters, the following rules apply: 
  21015.  
  21016. o If a parameter is required, zero or more spaces may appear between the option 
  21017.   and the parameter.  For example, both /FeMyexe.exe and /Fe  Myexe.exe are 
  21018.   valid. 
  21019. o If a parameter is optional, no space is allowed between the option and 
  21020.   parameter. For example,  /FlMylist.lst  is valid, but  /Fl Mylist.lst  is 
  21021.   not. 
  21022.  
  21023. The syntax of the compiler options varies according to the type of parameter 
  21024. that is used with the option. There are four types of parameters: 
  21025.  
  21026. o Strings 
  21027. o File names 
  21028. o Switches 
  21029. o Numbers. 
  21030.  
  21031. Related Information 
  21032.  
  21033. o Specifying Compiler Options 
  21034. o Scope of Compiler Options 
  21035. o Related and Conflicting Options 
  21036. o Language-Dependent Options 
  21037. o Compiler Options for Presentation Manager Programming 
  21038. o Output File Management Options 
  21039. o #include File Search Options 
  21040. o Listing File Options 
  21041. o Debugging and Diagnostic Information Options 
  21042. o Source Code Options 
  21043. o Preprocessor Options 
  21044. o Code Generation Options 
  21045. o Other Options 
  21046.  
  21047.  
  21048. ΓòÉΓòÉΓòÉ <hidden> Option Parameters: Strings ΓòÉΓòÉΓòÉ
  21049.  
  21050. If the option has a string parameter, the string must be enclosed by a pair of 
  21051. double quotation marks if there are spaces in the string. For example, 
  21052. /V"Version 1.0" is correct. If there are no spaces in the string, the quotation 
  21053. marks are not necessary. For example, both /VNew and /V"New" are valid. 
  21054.  
  21055. If the string contains double quotation marks, precede them with the backslash 
  21056. (\) character. For example, if the string is abc"def, specify it on the command 
  21057. line as "abc\"def". This combination is the only escape sequence allowed within 
  21058. string options. Do not end a string with a backslash, as in "abc\". 
  21059.  
  21060. Do not put a space between the option and the string. 
  21061.  
  21062.  
  21063. ΓòÉΓòÉΓòÉ <hidden> Option Parameters: File Names ΓòÉΓòÉΓòÉ
  21064.  
  21065. If you want to use a file that is in the current directory, specify only the 
  21066. file name. If the file you want to use is not in the current directory, specify 
  21067. the path and file name. For example, if your current directory is E:\, your 
  21068. source file is E:\myprog.c, and you compile using the defaults, your executable 
  21069. file will be called myprog.exe. If you want to put your executable file into 
  21070. the F:\ directory and call it newprog.exe, use the following command: 
  21071.  
  21072.    icc /FeF:\newprog.exe myprog.c
  21073.  
  21074. If you do not specify an extension for the executable file, .EXE is assumed. 
  21075.  
  21076. If your file name contains spaces (as permitted by the High Performance File 
  21077. System (HPFS)) or any elements of the HPFS extended character set, the file 
  21078. name must be enclosed in double quotation marks. In such a case, do not put a 
  21079. space between the option and a file name or directory. 
  21080.  
  21081.  
  21082. ΓòÉΓòÉΓòÉ <hidden> Option Parameters: Switches ΓòÉΓòÉΓòÉ
  21083.  
  21084. Some options are used with plus (+) or minus (-) signs. If you do not use 
  21085. either sign, the compiler processes the option as if you had used the + sign. 
  21086. When you use an option that uses switches, you can combine them. For example, 
  21087. the following two option specifications have the same result: 
  21088.  
  21089.    /La+ /Le+ /Ls+ /Lx-
  21090.    /Laesx-
  21091.  
  21092. Note that the - sign applies only to the switch immediately preceding it. 
  21093.  
  21094.  
  21095. ΓòÉΓòÉΓòÉ <hidden> Option Parameters: Numbers ΓòÉΓòÉΓòÉ
  21096.  
  21097. When an option uses a number as a parameter, do not put a space between the 
  21098. option and the number. When an option uses two numbers as parameters, separate 
  21099. the numbers with a comma.  Do not leave a space between the numbers and the 
  21100. comma. For example: 
  21101.  
  21102.    /Sg10,132
  21103.  
  21104.  
  21105. ΓòÉΓòÉΓòÉ 18.2. Scope of Compiler Options ΓòÉΓòÉΓòÉ
  21106.  
  21107. The compiler options are categorized according to how they are processed.  The 
  21108. categories are: 
  21109.  
  21110. Global 
  21111.   A global option applies to all the source files on the command line. If a 
  21112.   global option is specified more than once, the last occurrence of the option 
  21113.   is the one in effect. In the following example, all the files are compiled 
  21114.   with the /Fm- option because it follows the /Fmmap option: 
  21115.  
  21116.        icc /Fmmap module1.c module2.c /Fm- module3.c
  21117.  
  21118.   A global option can follow the last file on the command line. 
  21119.  
  21120.   The following options are global: 
  21121.  
  21122.     /B   /C   /Fe   /Fm   /Gu   /H   /Mp   /Ms   /Ol   /Q   /Sd   /Sn
  21123.  
  21124. Local 
  21125.   A local option applies only to the source files that follow the option. The 
  21126.   last, or rightmost, occurrence of these options is the one that is in effect 
  21127.   for the source file or files that follow it. 
  21128.  
  21129.   In the following example, the file module1.c is compiled with the option /Fa- 
  21130.   because this option follows /Fa+: 
  21131.  
  21132.        icc /Fa+ /Fa- module1.c
  21133.  
  21134.   In the next example, the file module1.c is compiled with the /Fa+ option, 
  21135.   while module2.c is compiled with /Fa-: 
  21136.  
  21137.        icc /Fa+ module1.c /Fa- module2.c
  21138.  
  21139.   Note:  The /D (define a preprocessor macro) is different from the other local 
  21140.   variables in that the first definition of a macro is the one that is used. 
  21141.  
  21142.   All compiler options not listed under Global are local options. 
  21143. Cumulative 
  21144.   The local option /I and the global option /B have a special characteristic. 
  21145.   Each time you specify one of them, the parameters you specify are appended to 
  21146.   the parameters previously stated. For example, the command 
  21147.  
  21148.        icc /Ia: /Ib:\cde /Ic:\fgh prog.c
  21149.  
  21150.   causes the following search path to be built: 
  21151.  
  21152.        a:;b:\cde;c:\fgh
  21153.  
  21154. Related Information 
  21155.  
  21156. o Specifying Compiler Options 
  21157. o Related and Conflicting Options 
  21158. o Language-Dependent Options 
  21159. o Compiler Options for Presentation Manager Programming 
  21160. o Output File Management Options 
  21161. o #include File Search Options 
  21162. o Listing File Options 
  21163. o Debugging and Diagnostic Information Options 
  21164. o Source Code Options 
  21165. o Preprocessor Options 
  21166. o Code Generation Options 
  21167. o Other Options 
  21168.  
  21169.  
  21170. ΓòÉΓòÉΓòÉ 18.2.1. Related and Conflicting Options ΓòÉΓòÉΓòÉ
  21171.  
  21172. Related Options 
  21173. Some options are required with other options: 
  21174.  
  21175. o If you specify the listing file option /Le (expand macros), or one of /Li or 
  21176.   /Lj (expand #include files), you must also specify the /Ls option to include 
  21177.   the source code. 
  21178. o If you specify the /Gr option to generate code to run at ring zero, you must 
  21179.   also specify the /Rn (no runtime environment) option. 
  21180.  
  21181. To use EXTRA, you must specify both the /Gh and /Ti options. 
  21182.  
  21183. Conflicting Options 
  21184. Some options are incompatible with other options. If options specified on the 
  21185. command line are in conflict, the following rules apply: 
  21186.  
  21187. o The syntax check option (/Fc) takes precedence over the output file 
  21188.   generation (/Fa, /Fb, /Fe, /Fm, /Fo, and /Ft), intermediate code linker (/Fw 
  21189.   and /Ol), and preprocessor (/P, /Pc, /Pd, and /Pe) options. 
  21190.  
  21191. o The preprocessor options (/P, /Pc, /Pd, and /Pe) take precedence over the 
  21192.   output file generation (/Fa, /Fb, /Fe, /Fl, /Fm, /Fo, and /Ft), intermediate 
  21193.   code linker (/Fw, /Gu, and /Ol) precompiled header file (/Fi and /Si), and 
  21194.   all listing file (/L) options. 
  21195.  
  21196. o The option for no runtime environment (/Rn) takes precedence over the 
  21197.   multithreading (/Gm), ddnames (/Sh), and memory file (/Sv) options. 
  21198.  
  21199. o The option to not create an object file (/Fo-) takes precedence over the 
  21200.   option to include debug information in the object (/Ti). 
  21201.  
  21202. o The compile-only option (/C) takes precedence over the name executable module 
  21203.   (/Fe) and generate linker map (/Fm) options. 
  21204.  
  21205. o The no-optimization option (/O-) takes precedence over the instruction 
  21206.   scheduler option (/Os+). 
  21207.  
  21208. o The options to expand #include files in the listing (/Li and /Lj) take 
  21209.   precedence over the precompiled header file options (/Fi and /Si). 
  21210.  
  21211. o The option to expand user and system #include files (/Lj+) takes precedence 
  21212.   over the option to expand user #include files only (/Li). 
  21213.  
  21214. Related Information 
  21215.  
  21216. o Specifying Compiler Options 
  21217. o Language-Dependent Options 
  21218. o Compiler Options for Presentation Manager Programming 
  21219. o Output File Management Options 
  21220. o #include File Search Options 
  21221. o Listing File Options 
  21222. o Debugging and Diagnostic Information Options 
  21223. o Source Code Options 
  21224. o Preprocessor Options 
  21225. o Code Generation Options 
  21226. o Other Options 
  21227.  
  21228.  
  21229. ΓòÉΓòÉΓòÉ 18.2.2. Language-Dependent Options ΓòÉΓòÉΓòÉ
  21230.  
  21231. Some C/C++ Tools options are only valid when compiling C programs, while others 
  21232. only apply to C++ programs. The following options are valid for C programs 
  21233. only: 
  21234.  
  21235. /Fd-    Store internal work files in shared memory.  C++ files must be compiled 
  21236.         with /Fd+. 
  21237. /Gv     Control handling of DS and ES registers for virtual device driver 
  21238.         development.  VDD support is provided for C only. 
  21239. /Kn     Control diagnostic messages.  The /Wgrp options replace the /Kn options 
  21240.         and provide greater control over the messages.  The /Kn options are 
  21241.         mapped to the /Wgrp options for you in C programs, but are not 
  21242.         supported for C++ programs.  The /Wgrp options are supported for both C 
  21243.         and C++. 
  21244. /Sg     Set margins for input files.  This option is provided primarily for 
  21245.         compatibility with IBM C/370.  C++ does not require any such 
  21246.         compatibility. 
  21247. /Sq     Set sequence numbers for input files. This option is provided primarily 
  21248.         for compatibility with IBM C/370.  C++ does not require any such 
  21249.         compatibility. 
  21250. /Sr     Set type conversion rules.  The C++ language only supports the new type 
  21251.         conversion rules defined by the ANSI standard. 
  21252. /Ss     Allow use of double slashes for comments.  C++ allows double slashes to 
  21253.         indicate comments as part of the language. 
  21254. /S2     Allow only SAA Level 2 C constructs.  There is no SAA definition of the 
  21255.         C++ language. 
  21256.  
  21257. The following options are valid for C++ programs only: 
  21258.  
  21259. /Fb   Control generation of browser files. 
  21260. /Ft   Control generation of files for template resolution. The C language does 
  21261.       not support templates. 
  21262. /Gx   Control inclusion of C++ exception handling information. The C language 
  21263.       does not include specific constructs for exception handling. 
  21264. /Sc   Allows constructs compatible with earlier versions of the C++ language. 
  21265.       These constructs are not allowed in C. 
  21266.  
  21267. Related Information 
  21268.  
  21269. o Specifying Compiler Options 
  21270. o Related and Conflicting Options 
  21271. o Compiler Options for Presentation Manager Programming 
  21272. o Output File Management Options 
  21273. o #include File Search Options 
  21274. o Listing File Options 
  21275. o Debugging and Diagnostic Information Options 
  21276. o Source Code Options 
  21277. o Preprocessor Options 
  21278. o Code Generation Options 
  21279. o Other Options 
  21280.  
  21281.  
  21282. ΓòÉΓòÉΓòÉ 18.2.3. Compiler Options for Presentation Manager Programming ΓòÉΓòÉΓòÉ
  21283.  
  21284. If you are using the C/C++ Tools product to develop PM applications, you may 
  21285. need the following options: 
  21286.  
  21287. Option    Description 
  21288. /Se       Allow all C/C++ Tools language extensions. (This is the default.) 
  21289. /Gm       Use the multithread libraries. 
  21290. /Gs-      Do not remove stack probes.  (This is the default.) 
  21291. /Wpro     Produce diagnostic messages about unprototyped functions. 
  21292.  
  21293. Related Information 
  21294.  
  21295. o Specifying Compiler Options 
  21296. o Source Code Options 
  21297. o Code Generation Options 
  21298. o Debugging and Diagnostic Information Options 
  21299. o Related and Conflicting Options 
  21300. o Language-Dependent Options 
  21301.  
  21302.  
  21303. ΓòÉΓòÉΓòÉ 18.3. Output File Management Options ΓòÉΓòÉΓòÉ
  21304.  
  21305. Use the options listed in this section to control the files that the compiler 
  21306. produces. 
  21307.  
  21308. Note:  You do not need the plus symbol (+) when specifying an option: the forms 
  21309. /Fa+ and /Fa are equivalent. 
  21310.  
  21311. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  21312. Γöé      Output File Management Options                    Γöé
  21313. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21314. Γöé OPTION    Γöé DESCRIPTION     Γöé DEFAULT       Γöé CHANGING THE    Γöé
  21315. Γöé        Γöé           Γöé           Γöé DEFAULT       Γöé
  21316. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21317. Γöé "/Fa[+|-]"  Γöé Produce and name  Γöé "/Fa-"        Γöé "/Fa[+]"      Γöé
  21318. Γöé        Γöé an assembler    Γöé Do not create an   Γöé Create an assem-  Γöé
  21319. Γöé "/Faname"   Γöé listing file that  Γöé assembler listing  Γöé bler listing file  Γöé
  21320. Γöé        Γöé has the source   Γöé file.        Γöé that has the same  Γöé
  21321. Γöé        Γöé code as comments.  Γöé           Γöé name as the source Γöé
  21322. Γöé        Γöé           Γöé           Γöé file, with the   Γöé
  21323. Γöé        Γöé NOTE:  This    Γöé           Γöé extension ".asm".  Γöé
  21324. Γöé        Γöé listing is not   Γöé           Γöé           Γöé
  21325. Γöé        Γöé guaranteed to    Γöé           Γöé "/Fa"name      Γöé
  21326. Γöé        Γöé compile.      Γöé           Γöé Create the listing Γöé
  21327. Γöé        Γöé           Γöé           Γöé file name".asm".  Γöé
  21328. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21329. Γöé "/Fb[+|-]"  Γöé Produce a browser  Γöé "/Fb-"        Γöé "/Fb[+]"      Γöé
  21330. Γöé        Γöé file.        Γöé Do not create a   Γöé Create a browser  Γöé
  21331. Γöé        Γöé           Γöé browser file.    Γöé file.  The file   Γöé
  21332. Γöé        Γöé NOTE:  This    Γöé           Γöé has the same name  Γöé
  21333. Γöé        Γöé option is valid   Γöé           Γöé as the source file Γöé
  21334. Γöé        Γöé for C++ files    Γöé           Γöé with the extension Γöé
  21335. Γöé        Γöé only.        Γöé           Γöé ".brs".       Γöé
  21336. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21337. Γöé "/Fc[+|-]"  Γöé Perform syntax   Γöé "/Fc-"        Γöé "/Fc[+]"      Γöé
  21338. Γöé        Γöé check only.     Γöé Compile and produce Γöé Do only a syntax  Γöé
  21339. Γöé        Γöé           Γöé output files     Γöé check.  The only  Γöé
  21340. Γöé        Γöé           Γöé according to other  Γöé output files you  Γöé
  21341. Γöé        Γöé           Γöé options.       Γöé can produce when  Γöé
  21342. Γöé        Γöé           Γöé           Γöé this option is in  Γöé
  21343. Γöé        Γöé           Γöé           Γöé effect are listing Γöé
  21344. Γöé        Γöé           Γöé           Γöé (".lst") files.   Γöé
  21345. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21346. Γöé "/Fd[+|-]"  Γöé Specify work file  Γöé "/Fd-"        Γöé "/Fd[+]"      Γöé
  21347. Γöé        Γöé storage area.    Γöé Store internal work Γöé Store internal   Γöé
  21348. Γöé        Γöé           Γöé files in shared   Γöé work files on disk Γöé
  21349. Γöé        Γöé           Γöé memory.       Γöé in the directory  Γöé
  21350. Γöé        Γöé           Γöé           Γöé specified by the  Γöé
  21351. Γöé        Γöé           Γöé NOTE:  When you   Γöé TMP variable.    Γöé
  21352. Γöé        Γöé           Γöé compile C++ code,  Γöé           Γöé
  21353. Γöé        Γöé           Γöé "/Fd+" becomes the  Γöé           Γöé
  21354. Γöé        Γöé           Γöé default.  You    Γöé           Γöé
  21355. Γöé        Γöé           Γöé cannot specify    Γöé           Γöé
  21356. Γöé        Γöé           Γöé "/Fd-" for C++    Γöé           Γöé
  21357. Γöé        Γöé           Γöé code.        Γöé           Γöé
  21358. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21359. Γöé "/Fename"   Γöé Specify name of   Γöé Give the executable Γöé "/Fename"      Γöé
  21360. Γöé        Γöé executable file or Γöé file the same name  Γöé Name the execut-  Γöé
  21361. Γöé        Γöé DLL.        Γöé as the first source Γöé able file      Γöé
  21362. Γöé        Γöé           Γöé file, with the    Γöé "name.exe" or    Γöé
  21363. Γöé        Γöé           Γöé extension ".exe" or Γöé "name.dll".     Γöé
  21364. Γöé        Γöé           Γöé ".dll".       Γöé           Γöé
  21365. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21366. Γöé "/Fi[+|-]"  Γöé Control creation  Γöé "/Fi-"        Γöé "/Fi[+]"      Γöé
  21367. Γöé        Γöé of precompiled   Γöé Do not create a   Γöé Create a precom-  Γöé
  21368. Γöé        Γöé header files.    Γöé precompiled header  Γöé piled header file  Γöé
  21369. Γöé        Γöé           Γöé file.        Γöé if none exists or  Γöé
  21370. Γöé        Γöé           Γöé           Γöé if the existing   Γöé
  21371. Γöé        Γöé           Γöé           Γöé one is out-of-   Γöé
  21372. Γöé        Γöé           Γöé           Γöé date.        Γöé
  21373. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21374. Γöé "/Fl[+|-]"  Γöé Produce and name a Γöé "/Fl-"        Γöé "/Fl[+]"      Γöé
  21375. Γöé        Γöé listing file.    Γöé Do not create a   Γöé Give the listing  Γöé
  21376. Γöé "/Flname"   Γöé           Γöé listing file.    Γöé the same file name Γöé
  21377. Γöé        Γöé           Γöé           Γöé as the source    Γöé
  21378. Γöé        Γöé           Γöé           Γöé file, with the   Γöé
  21379. Γöé        Γöé           Γöé           Γöé extension ".lst".  Γöé
  21380. Γöé        Γöé           Γöé           Γöé           Γöé
  21381. Γöé        Γöé           Γöé           Γöé "/Flname"      Γöé
  21382. Γöé        Γöé           Γöé           Γöé Name the listing  Γöé
  21383. Γöé        Γöé           Γöé           Γöé file "name.lst".  Γöé
  21384. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  21385. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  21386. Γöé      Output File Management Options                    Γöé
  21387. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21388. Γöé OPTION    Γöé DESCRIPTION     Γöé DEFAULT       Γöé CHANGING THE    Γöé
  21389. Γöé        Γöé           Γöé           Γöé DEFAULT       Γöé
  21390. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21391. Γöé "/Fm[+|-]"  Γöé Produce and name a Γöé "/Fm-"        Γöé "/Fm[+]"      Γöé
  21392. Γöé        Γöé linker map file.  Γöé Do not create a map Γöé Create a linker   Γöé
  21393. Γöé "/Fmname"   Γöé           Γöé file.        Γöé map file with the  Γöé
  21394. Γöé        Γöé           Γöé           Γöé same file name as  Γöé
  21395. Γöé        Γöé           Γöé           Γöé the source file,  Γöé
  21396. Γöé        Γöé           Γöé           Γöé with the extension Γöé
  21397. Γöé        Γöé           Γöé           Γöé ".map".       Γöé
  21398. Γöé        Γöé           Γöé           Γöé           Γöé
  21399. Γöé        Γöé           Γöé           Γöé "/Fm"name      Γöé
  21400. Γöé        Γöé           Γöé           Γöé Create map file   Γöé
  21401. Γöé        Γöé           Γöé           Γöé "name.map".     Γöé
  21402. Γöé        Γöé           Γöé           Γöé           Γöé
  21403. Γöé        Γöé           Γöé           Γöé NOTE:  Use the   Γöé
  21404. Γöé        Γöé           Γöé           Γöé "/B"/map"" option  Γöé
  21405. Γöé        Γöé           Γöé           Γöé to get a more    Γöé
  21406. Γöé        Γöé           Γöé           Γöé detailed map file. Γöé
  21407. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21408. Γöé "/Fo[+|-]"  Γöé Produce and name  Γöé "/Fo[+]"       Γöé "/Fo-"       Γöé
  21409. Γöé        Γöé an object file.   Γöé Create an object   Γöé Do not create an  Γöé
  21410. Γöé "/Fo"name   Γöé           Γöé file, and give it  Γöé object file.    Γöé
  21411. Γöé        Γöé           Γöé the same name as   Γöé           Γöé
  21412. Γöé        Γöé           Γöé the source file,   Γöé "/Foname"      Γöé
  21413. Γöé        Γöé           Γöé with the extension  Γöé Create object file Γöé
  21414. Γöé        Γöé           Γöé ".obj".       Γöé name".obj".     Γöé
  21415. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21416. Γöé "/Ft[+|-]"  Γöé Control generation Γöé "/Ft+"        Γöé "/Ft[-]"      Γöé
  21417. Γöé        Γöé of files for tem-  Γöé Generate files for  Γöé Do not generate   Γöé
  21418. Γöé "/Ftdir"   Γöé plate resolution.  Γöé template resolution Γöé files for template Γöé
  21419. Γöé        Γöé           Γöé in the TEMPINC sub- Γöé resolution.     Γöé
  21420. Γöé        Γöé NOTE:  This    Γöé directory under the Γöé           Γöé
  21421. Γöé        Γöé option is valid   Γöé current directory.  Γöé "/Ftdir"      Γöé
  21422. Γöé        Γöé for C++ files    Γöé           Γöé Generate the files Γöé
  21423. Γöé        Γöé only.  The C lan-  Γöé           Γöé and place them in  Γöé
  21424. Γöé        Γöé guage does not   Γöé           Γöé the directory dir. Γöé
  21425. Γöé        Γöé support the use of Γöé           Γöé           Γöé
  21426. Γöé        Γöé templates.     Γöé           Γöé           Γöé
  21427. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21428. Γöé "/Fw[+|-]"  Γöé Control generation Γöé "/Fw-"        Γöé "/Fw[+]"      Γöé
  21429. Γöé        Γöé and use of inter-  Γöé Perform regular   Γöé Create interme-   Γöé
  21430. Γöé "/Fwname"   Γöé mediate code    Γöé compilation; do not Γöé diate code files  Γöé
  21431. Γöé        Γöé files.       Γöé save intermediate  Γöé only; do not com-  Γöé
  21432. Γöé        Γöé           Γöé code files.     Γöé plete compilation. Γöé
  21433. Γöé        Γöé           Γöé           Γöé           Γöé
  21434. Γöé        Γöé           Γöé           Γöé "/Fwname"      Γöé
  21435. Γöé        Γöé           Γöé           Γöé Create interme-   Γöé
  21436. Γöé        Γöé           Γöé           Γöé diate code files  Γöé
  21437. Γöé        Γöé           Γöé           Γöé only and name them Γöé
  21438. Γöé        Γöé           Γöé           Γöé "name.w, name.wh", Γöé
  21439. Γöé        Γöé           Γöé           Γöé and "name.wi"; do  Γöé
  21440. Γöé        Γöé           Γöé           Γöé not complete com-  Γöé
  21441. Γöé        Γöé           Γöé           Γöé pilation.      Γöé
  21442. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  21443.  
  21444. File Names and Extensions 
  21445. If you do not specify an extension for the file management options that take a 
  21446. file name as a parameter, the default extension is used. For example, if you 
  21447. specify /Flcome, the listing file will be called come.lst. Although you can 
  21448. specify an extension of your own choosing, you should use the default 
  21449. extensions. 
  21450.  
  21451. If you use an option without using an optional name parameter, the name of the 
  21452. following source file and the default extension is used, with the exception of 
  21453. the /Fm option.  If you do not specify a name with /Fm, the name of the first 
  21454. file given on the command line is used, with the default extension .map. 
  21455.  
  21456. Note:  If you use the /Fe option, you must specify a name or a path for the 
  21457.        file.  If you specify only a path, the file will have the same name as 
  21458.        the first source file on the command line, with the path specified. 
  21459.  
  21460. Examples of File Management Options 
  21461.  
  21462. Related Information 
  21463.  
  21464. o Specifying Compiler Options 
  21465. o Listing File Options 
  21466.  
  21467.  
  21468. ΓòÉΓòÉΓòÉ <hidden> Example of File Management Options ΓòÉΓòÉΓòÉ
  21469.  
  21470. o Perform syntax check only: 
  21471.  
  21472.        icc /Fc+ myprog.c
  21473.  
  21474. o Name the object file: 
  21475.  
  21476.        icc /Fobarney.obj fred.c
  21477.  
  21478.   This names the object file barney.obj instead of the default, fred.obj. 
  21479.  
  21480. o Name the executable file: 
  21481.  
  21482.        icc /Febarney.exe fred.c
  21483.  
  21484.   This names the object file barney.exe instead of the default, fred.exe. 
  21485.  
  21486. o Name the listing file: 
  21487.  
  21488.        icc /Floutput.my /L fred.c
  21489.  
  21490.   This creates a listing output called output.my instead of fred.lst. 
  21491.  
  21492. o Name the linker map file: 
  21493.  
  21494.        icc /Fmoutput.map fred.c
  21495.  
  21496.   This creates a linker map file called output.map instead of fred.map. 
  21497.  
  21498. o Name the assembler listing file: 
  21499.  
  21500.        icc /Fabarney fred.c
  21501.  
  21502.   This names the output barney.asm. instead of fred.asm. 
  21503.  
  21504.  
  21505. ΓòÉΓòÉΓòÉ 18.4. #include File Search Options ΓòÉΓòÉΓòÉ
  21506.  
  21507. Use these options to control which paths are searched when the compiler looks 
  21508. for #include files. The paths that are searched are the result of the 
  21509. information in the INCLUDE and ICC environment variables, combined with how you 
  21510. use the following compiler options. 
  21511.  
  21512. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  21513. Γöé      #include File Search Options                     Γöé
  21514. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21515. Γöé OPTION     Γöé DESCRIPTION     Γöé DEFAULT       Γöé CHANGING DEFAULT  Γöé
  21516. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21517. Γöé "/Ipath[;path]"Γöé Specify #include  Γöé Search directory  Γöé "/Ipath[;path]"  Γöé
  21518. Γöé         Γöé search path(s).   Γöé of source file   Γöé Search       Γöé
  21519. Γöé         Γöé           Γöé (for user files   Γöé "path[;path]".   Γöé
  21520. Γöé         Γöé           Γöé only), and then   Γöé Note that for   Γöé
  21521. Γöé         Γöé           Γöé search paths given Γöé user include    Γöé
  21522. Γöé         Γöé           Γöé in the INCLUDE   Γöé files, the direc- Γöé
  21523. Γöé         Γöé           Γöé environment vari-  Γöé tory of the    Γöé
  21524. Γöé         Γöé           Γöé able.        Γöé source file is   Γöé
  21525. Γöé         Γöé           Γöé           Γöé always searched  Γöé
  21526. Γöé         Γöé           Γöé           Γöé first.       Γöé
  21527. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21528. Γöé "/Xc[+|-]"   Γöé Specify whether to Γöé "/Xc-"       Γöé "/Xc[+]"      Γöé
  21529. Γöé         Γöé search paths spec- Γöé Search paths spec- Γöé Do not search   Γöé
  21530. Γöé         Γöé ified using "/I".  Γöé ified using "/I".  Γöé paths specified  Γöé
  21531. Γöé         Γöé           Γöé           Γöé using "/I".    Γöé
  21532. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21533. Γöé "/Xi[+|-]"   Γöé Control INCLUDE   Γöé "/Xi-"       Γöé "/Xi[+]"      Γöé
  21534. Γöé         Γöé environment vari-  Γöé Search the paths  Γöé Do not search the Γöé
  21535. Γöé         Γöé able search paths. Γöé specified in the  Γöé paths specified  Γöé
  21536. Γöé         Γöé           Γöé INCLUDE environ-  Γöé by the INCLUDE   Γöé
  21537. Γöé         Γöé           Γöé ment variable.   Γöé environment vari- Γöé
  21538. Γöé         Γöé           Γöé           Γöé able.       Γöé
  21539. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  21540.  
  21541. The /I option must be followed by one or more directory names. A space may be 
  21542. included between /I and the directory name. If you specify more than one 
  21543. directory, separate the directory names with a semicolon. If you use the /I 
  21544. option more than once, the directories you specify are appended to the 
  21545. directories you previously specified. 
  21546.  
  21547. If you specify search paths using /I in both the ICC environment variable and 
  21548. on the command line, all the paths are searched. The paths specified in ICC are 
  21549. searched before those specified on the command line. 
  21550.  
  21551. Note:  Once you use the /Xc option, the paths previously specified by using /I 
  21552.        cannot be recovered. You have to use the /I option again if you want to 
  21553.        reuse the paths canceled by /Xc. 
  21554.  
  21555. The /Xi option has no effect on the /Xc and /I options. 
  21556.  
  21557. Related Information 
  21558.  
  21559. o #include 
  21560. o Include Files 
  21561. o Specifying Compiler Options 
  21562.  
  21563.  
  21564. ΓòÉΓòÉΓòÉ 18.5. Listing File Options ΓòÉΓòÉΓòÉ
  21565.  
  21566. The options listed below control whether or not a listing file is produced, the 
  21567. type of information in the listing, and the appearance of the file. 
  21568.  
  21569. Note:  The following options only modify the appearance of a listing; they do 
  21570. not cause a listing to be produced. Use them with one of the other listing file 
  21571. options, or the /Fl option, to produce a listing: 
  21572.  
  21573.    /Le /Li /Lj /Lp /Lt /Lu
  21574. If you specify any of the /Le, /Li, or /Lj options, you must also specify the 
  21575. /L, /Lf, or /Ls option. 
  21576.  
  21577. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  21578. Γöé      Listing Output Options                       Γöé
  21579. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21580. Γöé OPTION    Γöé DESCRIPTION     Γöé DEFAULT       Γöé CHANGING DEFAULT  Γöé
  21581. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21582. Γöé "/L[+|-]"   Γöé Produce a listing  Γöé "/L-"        Γöé "/L[+]"       Γöé
  21583. Γöé        Γöé file.        Γöé Do not produce a   Γöé Produce a listing  Γöé
  21584. Γöé        Γöé           Γöé listing file.    Γöé file with only a  Γöé
  21585. Γöé        Γöé           Γöé           Γöé prolog and error  Γöé
  21586. Γöé        Γöé           Γöé           Γöé messages.      Γöé
  21587. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21588. Γöé "/La[+|-]"  Γöé Include a layout  Γöé "/La-"        Γöé "/La[+]"      Γöé
  21589. Γöé        Γöé of all referenced  Γöé Do not include a   Γöé Include a layout.  Γöé
  21590. Γöé        Γöé "struct" and    Γöé layout.       Γöé           Γöé
  21591. Γöé        Γöé "union" variables, Γöé           Γöé           Γöé
  21592. Γöé        Γöé with offsets and  Γöé           Γöé           Γöé
  21593. Γöé        Γöé lengths.      Γöé           Γöé           Γöé
  21594. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21595. Γöé "/Lb[+|-]"  Γöé Include a layout  Γöé "/Lb-"        Γöé "/Lb[+]"      Γöé
  21596. Γöé        Γöé of all "struct"   Γöé Do not include a   Γöé Include a layout.  Γöé
  21597. Γöé        Γöé and "union" vari-  Γöé layout.       Γöé           Γöé
  21598. Γöé        Γöé ables.       Γöé           Γöé           Γöé
  21599. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21600. Γöé "/Le[+|-]"  Γöé Expand all macros. Γöé "/Le-"        Γöé "/Le[+]"      Γöé
  21601. Γöé        Γöé           Γöé Do not expand    Γöé Expand macros.   Γöé
  21602. Γöé        Γöé           Γöé macros.       Γöé           Γöé
  21603. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21604. Γöé "/Lf[+|-]"  Γöé Set all listing   Γöé "/Lf-"        Γöé "/Lf[+]"      Γöé
  21605. Γöé        Γöé options on or off. Γöé Set all listing   Γöé Set all listing   Γöé
  21606. Γöé        Γöé           Γöé options off.     Γöé options on.     Γöé
  21607. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21608. Γöé "/Li[+|-]"  Γöé Expand user     Γöé "/Li-"        Γöé "/Li[+]"      Γöé
  21609. Γöé        Γöé #include files.   Γöé Do not expand user  Γöé Expand user     Γöé
  21610. Γöé        Γöé           Γöé #include files.   Γöé #include files.   Γöé
  21611. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21612. Γöé "/Lj[+|-]"  Γöé Expand user and   Γöé "/Lj-"        Γöé "/Lj[+]"      Γöé
  21613. Γöé        Γöé system #include   Γöé Do not expand user  Γöé Expand user and   Γöé
  21614. Γöé        Γöé files.       Γöé and system #include Γöé system #include   Γöé
  21615. Γöé        Γöé           Γöé files.        Γöé files.       Γöé
  21616. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21617. Γöé "/Lpnum"   Γöé Set page length.  Γöé "/Lp66"       Γöé "/Lpnum"      Γöé
  21618. Γöé        Γöé           Γöé Set page length to  Γöé Specify num lines  Γöé
  21619. Γöé        Γöé           Γöé 66 lines.      Γöé per page of     Γöé
  21620. Γöé        Γöé           Γöé           Γöé listing.  num must Γöé
  21621. Γöé        Γöé           Γöé           Γöé be between 15 and  Γöé
  21622. Γöé        Γöé           Γöé           Γöé 65535 inclusive.  Γöé
  21623. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21624. Γöé "/Ls[+|-]"  Γöé Include the source Γöé "/Ls-"        Γöé "/Ls[+]"      Γöé
  21625. Γöé        Γöé code.        Γöé Do not include the  Γöé Include the source Γöé
  21626. Γöé        Γöé           Γöé source code.     Γöé code.        Γöé
  21627. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21628. Γöé "/Lt"string""Γöé Set title string.  Γöé Set title string to Γöé "/Lt"string""    Γöé
  21629. Γöé        Γöé           Γöé the name of the   Γöé Set title string  Γöé
  21630. Γöé        Γöé           Γöé source file.     Γöé to string.     Γöé
  21631. Γöé        Γöé           Γöé           Γöé Maximum string   Γöé
  21632. Γöé        Γöé           Γöé           Γöé length is 256    Γöé
  21633. Γöé        Γöé           Γöé           Γöé characters.     Γöé
  21634. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21635. Γöé "/Lu"string""Γöé Set subtitle    Γöé "/Lu"""       Γöé "/Lu"string""    Γöé
  21636. Γöé        Γöé string.       Γöé Set no subtitle   Γöé Set subtitle    Γöé
  21637. Γöé        Γöé           Γöé (null string).    Γöé string to string.  Γöé
  21638. Γöé        Γöé           Γöé           Γöé Maximum string   Γöé
  21639. Γöé        Γöé           Γöé           Γöé length is 256    Γöé
  21640. Γöé        Γöé           Γöé           Γöé characters.     Γöé
  21641. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21642. Γöé "/Lx[+|-]"  Γöé Generate a cross-  Γöé "/Lx-"        Γöé "/Lx[+]"      Γöé
  21643. Γöé        Γöé reference table   Γöé Do not generate a  Γöé Generate a cross-  Γöé
  21644. Γöé        Γöé for referenced   Γöé cross-reference   Γöé reference table.  Γöé
  21645. Γöé        Γöé variable, struc-  Γöé table.        Γöé           Γöé
  21646. Γöé        Γöé ture, and function Γöé           Γöé           Γöé
  21647. Γöé        Γöé names, that shows  Γöé           Γöé           Γöé
  21648. Γöé        Γöé line numbers where Γöé           Γöé           Γöé
  21649. Γöé        Γöé names are      Γöé           Γöé           Γöé
  21650. Γöé        Γöé declared.      Γöé           Γöé           Γöé
  21651. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21652. Γöé "/Ly[+|-]"  Γöé Generate a cross-  Γöé "/Ly-"        Γöé "/Ly[+]"      Γöé
  21653. Γöé        Γöé reference table of Γöé Do not generate a  Γöé Generate a cross-  Γöé
  21654. Γöé        Γöé all variable,    Γöé cross-reference   Γöé reference table.  Γöé
  21655. Γöé        Γöé structure, and   Γöé table.        Γöé           Γöé
  21656. Γöé        Γöé function names,   Γöé           Γöé           Γöé
  21657. Γöé        Γöé plus all local   Γöé           Γöé           Γöé
  21658. Γöé        Γöé variables refer-  Γöé           Γöé           Γöé
  21659. Γöé        Γöé enced by the user. Γöé           Γöé           Γöé
  21660. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  21661.  
  21662. Note:  You can also specify titles using the #pragma title and subtitle 
  21663. directives, but these titles do not appear on the first page of the listing 
  21664. output. 
  21665.  
  21666. Related Information 
  21667.  
  21668. o #pragma title 
  21669. o #pragma subtitle 
  21670. o Output File Management Options 
  21671. o Specifying Compiler Options 
  21672.  
  21673.  
  21674. ΓòÉΓòÉΓòÉ 18.6. Debugging and Diagnostic Information Options ΓòÉΓòÉΓòÉ
  21675.  
  21676. The options listed here are useful for debugging your programs. 
  21677.  
  21678. The /Wgrp options and /Kn options generate the same messages.  The /Wgrp 
  21679. options give you greater control over the types of messages generated.  The /Kn 
  21680. options are provided for compatibility with C Set/2 V1.0 only, and are mapped 
  21681. for you to the correct /Wgrp options. They are not supported for use in C++ 
  21682. programs, and will not be supported in future versions of the C/C++ Tools 
  21683. product. 
  21684.  
  21685. Note:  The information generated by the C/C++ Tools debugger and the /Kn and 
  21686.        /Wgrp options is provided to help you diagnose problems in your code. Do 
  21687.        not use the diagnostic information as a programming interface. 
  21688.  
  21689. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  21690. Γöé      Debugging Options                          Γöé
  21691. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21692. Γöé OPTION      Γöé DESCRIPTION    Γöé DEFAULT       Γöé CHANGING DEFAULT  Γöé
  21693. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21694. Γöé "/Ka[+|-]"    Γöé Control messages  Γöé "/Ka-"       Γöé "/Ka[+]"      Γöé
  21695. Γöé         Γöé about variable   Γöé Suppress messages  Γöé Produce messages  Γöé
  21696. Γöé         Γöé assignments that  Γöé about assignments  Γöé about inappro-   Γöé
  21697. Γöé         Γöé can result in a  Γöé that may cause a  Γöé priate assign-   Γöé
  21698. Γöé         Γöé loss of preci-   Γöé loss of precision. Γöé ments of "long"  Γöé
  21699. Γöé         Γöé sion.       Γöé           Γöé values.      Γöé
  21700. Γöé         Γöé Maps to the    Γöé           Γöé          Γöé
  21701. Γöé         Γöé "/Wtrd" option.  Γöé           Γöé          Γöé
  21702. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21703. Γöé "/Kb[+|-]"    Γöé Control messages  Γöé "/Kb-"       Γöé "/Kb[+]"      Γöé
  21704. Γöé         Γöé about basic diag- Γöé Suppress basic   Γöé Produce basic   Γöé
  21705. Γöé         Γöé nostics generated Γöé diagnostic mes-   Γöé diagnostic mes-  Γöé
  21706. Γöé         Γöé by "/K" options.  Γöé sages.       Γöé sages.       Γöé
  21707. Γöé         Γöé Maps to the    Γöé           Γöé          Γöé
  21708. Γöé         Γöé "/Wgen" option.  Γöé           Γöé          Γöé
  21709. Γöé         Γöé          Γöé           Γöé          Γöé
  21710. Γöé         Γöé NOTE:  Many of  Γöé           Γöé          Γöé
  21711. Γöé         Γöé the messages con- Γöé           Γöé          Γöé
  21712. Γöé         Γöé sidered general  Γöé           Γöé          Γöé
  21713. Γöé         Γöé diagnostics in   Γöé           Γöé          Γöé
  21714. Γöé         Γöé the C Set/2 V1.0  Γöé           Γöé          Γöé
  21715. Γöé         Γöé product are now  Γöé           Γöé          Γöé
  21716. Γöé         Γöé controlled by a  Γöé           Γöé          Γöé
  21717. Γöé         Γöé specific /W    Γöé           Γöé          Γöé
  21718. Γöé         Γöé option.      Γöé           Γöé          Γöé
  21719. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21720. Γöé "/Kc[+|-]"    Γöé Control pre-    Γöé "/Kc-"       Γöé "/Kc[+]"      Γöé
  21721. Γöé         Γöé processor warning Γöé Suppress pre-    Γöé Produce pre-    Γöé
  21722. Γöé         Γöé messages.     Γöé processor warning  Γöé processor warning Γöé
  21723. Γöé         Γöé Maps to the    Γöé messages.      Γöé messages.     Γöé
  21724. Γöé         Γöé "/Wppc" option.  Γöé           Γöé          Γöé
  21725. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21726. Γöé "/Ke[+|-]"    Γöé Control messages  Γöé "/Ke-"       Γöé "/Ke[+]"      Γöé
  21727. Γöé         Γöé about "enum"    Γöé Suppress messages  Γöé Produce messages  Γöé
  21728. Γöé         Γöé usage.       Γöé about "enum"    Γöé about "enum"    Γöé
  21729. Γöé         Γöé Maps to the    Γöé usage.       Γöé usage.       Γöé
  21730. Γöé         Γöé "/Wenu" option.  Γöé           Γöé          Γöé
  21731. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21732. Γöé "/Kf[+|-]"    Γöé Set all diag-   Γöé "/Kf-"       Γöé "/Kf[+]"      Γöé
  21733. Γöé         Γöé nostic messages  Γöé Set all diagnostic Γöé Set all diag-   Γöé
  21734. Γöé         Γöé options on or   Γöé messages options  Γöé nostic messages  Γöé
  21735. Γöé         Γöé off.        Γöé off.        Γöé options on.    Γöé
  21736. Γöé         Γöé Maps to the    Γöé           Γöé          Γöé
  21737. Γöé         Γöé "/Wall" option.  Γöé           Γöé          Γöé
  21738. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21739. Γöé "/Kg[+|-]"    Γöé Control messages  Γöé "/Kg-"       Γöé "/Kg[+]"      Γöé
  21740. Γöé         Γöé about the appear- Γöé Suppress messages  Γöé Produce messages  Γöé
  21741. Γöé         Γöé ance and usage of Γöé about "goto"    Γöé about "goto"    Γöé
  21742. Γöé         Γöé "goto" state-   Γöé statements.     Γöé statements.    Γöé
  21743. Γöé         Γöé ments.       Γöé           Γöé          Γöé
  21744. Γöé         Γöé Maps to the    Γöé           Γöé          Γöé
  21745. Γöé         Γöé "/Wgot" option.  Γöé           Γöé          Γöé
  21746. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21747. Γöé "/Ki[+|-]"    Γöé Control messages  Γöé "/Ki-"       Γöé "/Ki[+]"      Γöé
  21748. Γöé         Γöé about variables  Γöé Suppress messages  Γöé Produce messages  Γöé
  21749. Γöé         Γöé that are not    Γöé about uninitial-  Γöé about uninitial-  Γöé
  21750. Γöé         Γöé explicitly ini-  Γöé ized variables.   Γöé ized variables.  Γöé
  21751. Γöé         Γöé tialized.     Γöé           Γöé          Γöé
  21752. Γöé         Γöé Maps to the    Γöé           Γöé          Γöé
  21753. Γöé         Γöé "/Wini" and    Γöé           Γöé          Γöé
  21754. Γöé         Γöé "/Wuni" options.  Γöé           Γöé          Γöé
  21755. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21756. Γöé "/Ko[+|-]"    Γöé Control diag-   Γöé "/Ko-"       Γöé "/Ko[+]"      Γöé
  21757. Γöé         Γöé nostic messages  Γöé Suppress porta-   Γöé Produce porta-   Γöé
  21758. Γöé         Γöé about porta-    Γöé bility messages.  Γöé bility messages.  Γöé
  21759. Γöé         Γöé bility.      Γöé           Γöé          Γöé
  21760. Γöé         Γöé Maps to the    Γöé           Γöé          Γöé
  21761. Γöé         Γöé "/Wpor" option.  Γöé           Γöé          Γöé
  21762. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21763. Γöé "/Kp[+|-]"    Γöé Control messages  Γöé "/Kp-"       Γöé "/Kp[+]"      Γöé
  21764. Γöé         Γöé about function   Γöé Suppress messages  Γöé Produce messages  Γöé
  21765. Γöé         Γöé parameters that  Γöé about unused func- Γöé about unused    Γöé
  21766. Γöé         Γöé are not used.   Γöé tion parameters.  Γöé function parame-  Γöé
  21767. Γöé         Γöé Maps to the    Γöé           Γöé ters.       Γöé
  21768. Γöé         Γöé "/Wpar" option.  Γöé           Γöé          Γöé
  21769. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  21770. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  21771. Γöé      Debugging Options                          Γöé
  21772. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21773. Γöé OPTION      Γöé DESCRIPTION    Γöé DEFAULT       Γöé CHANGING DEFAULT  Γöé
  21774. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21775. Γöé "/Kr[+|-]"    Γöé Control messages  Γöé "/Kr-"       Γöé "/Kr[+]"      Γöé
  21776. Γöé         Γöé about mapping of  Γöé Suppress messages  Γöé Produce messages  Γöé
  21777. Γöé         Γöé names to the    Γöé about name     Γöé about name     Γöé
  21778. Γöé         Γöé linkage editor.  Γöé mapping.      Γöé mapping.      Γöé
  21779. Γöé         Γöé Maps to the    Γöé           Γöé          Γöé
  21780. Γöé         Γöé "/Wtru" option.  Γöé           Γöé          Γöé
  21781. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21782. Γöé "/Kt[+|-]"    Γöé Control pre-    Γöé "/Kt-"       Γöé "/Kt[+]"      Γöé
  21783. Γöé         Γöé processor trace  Γöé Suppress pre-    Γöé Produce pre-    Γöé
  21784. Γöé         Γöé messages.     Γöé processor trace   Γöé processor trace  Γöé
  21785. Γöé         Γöé Maps to the    Γöé messages.      Γöé messages.     Γöé
  21786. Γöé         Γöé "/Wppt" option.  Γöé           Γöé          Γöé
  21787. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21788. Γöé "/Kx[+|-]"    Γöé Control messages  Γöé "/Kx-"       Γöé "/Kx[+]"      Γöé
  21789. Γöé         Γöé about variables  Γöé Suppress messages  Γöé Produce messages  Γöé
  21790. Γöé         Γöé and functions   Γöé about unreferenced Γöé about unrefer-   Γöé
  21791. Γöé         Γöé that have     Γöé external variables Γöé enced external   Γöé
  21792. Γöé         Γöé external declara- Γöé and functions.   Γöé variables and   Γöé
  21793. Γöé         Γöé tions, but are   Γöé           Γöé functions.     Γöé
  21794. Γöé         Γöé never used.    Γöé           Γöé          Γöé
  21795. Γöé         Γöé Maps to the    Γöé           Γöé          Γöé
  21796. Γöé         Γöé "/Wext" and    Γöé           Γöé          Γöé
  21797. Γöé         Γöé "/Wuse" options.  Γöé           Γöé          Γöé
  21798. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21799. Γöé "/Nn"      Γöé Set maximum    Γöé Set no limit on   Γöé "/Nn"       Γöé
  21800. Γöé         Γöé number of errors  Γöé number of errors.  Γöé End compilation  Γöé
  21801. Γöé         Γöé before compila-  Γöé           Γöé when error count  Γöé
  21802. Γöé         Γöé tion aborts.    Γöé           Γöé reaches n.     Γöé
  21803. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21804. Γöé "/Ti[+|-]"    Γöé Generate      Γöé "/Ti-"       Γöé "/Ti[+]"      Γöé
  21805. Γöé         Γöé C/C++ Tools    Γöé Do not generate   Γöé Generate debugger Γöé
  21806. Γöé         Γöé debugger informa- Γöé debugger informa-  Γöé information.    Γöé
  21807. Γöé         Γöé tion.       Γöé tion.        Γöé          Γöé
  21808. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21809. Γöé "/Tm[+|-]"    Γöé Enable debug ver- Γöé "/Tm-"       Γöé "/Tm+"       Γöé
  21810. Γöé         Γöé sions of memory  Γöé Use the regular   Γöé Use the debug   Γöé
  21811. Γöé         Γöé management func-  Γöé versions of the   Γöé memory management Γöé
  21812. Γöé         Γöé tions.       Γöé memory management  Γöé functions     Γöé
  21813. Γöé         Γöé          Γöé functions      Γöé (_debug_calloc,  Γöé
  21814. Γöé         Γöé          Γöé ("calloc",     Γöé _debug_malloc,   Γöé
  21815. Γöé         Γöé          Γöé "malloc", "new",  Γöé "new", and so   Γöé
  21816. Γöé         Γöé          Γöé and so on).     Γöé on).  This option Γöé
  21817. Γöé         Γöé          Γöé           Γöé also defines the  Γöé
  21818. Γöé         Γöé          Γöé           Γöé "__DEBUG_ALLOC__" Γöé
  21819. Γöé         Γöé          Γöé           Γöé macro.  See the C Γöé
  21820. Γöé         Γöé          Γöé           Γöé Library Reference Γöé
  21821. Γöé         Γöé          Γöé           Γöé for information  Γöé
  21822. Γöé         Γöé          Γöé           Γöé on the C debug   Γöé
  21823. Γöé         Γöé          Γöé           Γöé memory management Γöé
  21824. Γöé         Γöé          Γöé           Γöé functions and the Γöé
  21825. Γöé         Γöé          Γöé           Γöé Online Language  Γöé
  21826. Γöé         Γöé          Γöé           Γöé Reference for   Γöé
  21827. Γöé         Γöé          Γöé           Γöé information on   Γöé
  21828. Γöé         Γöé          Γöé           Γöé the debug ver-   Γöé
  21829. Γöé         Γöé          Γöé           Γöé sions of "new"   Γöé
  21830. Γöé         Γöé          Γöé           Γöé and "delete".   Γöé
  21831. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21832. Γöé "/Tx[+|-]"    Γöé Control informa-  Γöé "/Tx-"       Γöé "/Tx[+|-]"     Γöé
  21833. Γöé         Γöé tion generated   Γöé Provide only the  Γöé Provide a com-   Γöé
  21834. Γöé         Γöé when an exception Γöé exception message  Γöé plete machine-   Γöé
  21835. Γöé         Γöé occurs.      Γöé and address when  Γöé state dump when  Γöé
  21836. Γöé         Γöé          Γöé an exception    Γöé an exception    Γöé
  21837. Γöé         Γöé          Γöé occurs; do not   Γöé occurs.      Γöé
  21838. Γöé         Γöé          Γöé provide a complete Γöé          Γöé
  21839. Γöé         Γöé          Γöé machine-state    Γöé          Γöé
  21840. Γöé         Γöé          Γöé dump.        Γöé          Γöé
  21841. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21842. Γöé "/W<grp>[+|-]"  Γöé Control diag-   Γöé "/Wall-"      Γöé "/Wgrp"      Γöé
  21843. Γöé         Γöé nostic messages.  Γöé Do not generate   Γöé Generate messages Γöé
  21844. Γöé         Γöé          Γöé diagnostic mes-   Γöé in the grp group. Γöé
  21845. Γöé         Γöé          Γöé sages.       Γöé More than one   Γöé
  21846. Γöé         Γöé          Γöé           Γöé group may be    Γöé
  21847. Γöé         Γöé          Γöé           Γöé specified.  See  Γöé
  21848. Γöé         Γöé          Γöé           Γöé the section which Γöé
  21849. Γöé         Γöé          Γöé           Γöé follows for    Γöé
  21850. Γöé         Γöé          Γöé           Γöé descriptions of  Γöé
  21851. Γöé         Γöé          Γöé           Γöé the different   Γöé
  21852. Γöé         Γöé          Γöé           Γöé groups of mes-   Γöé
  21853. Γöé         Γöé          Γöé           Γöé sages.       Γöé
  21854. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  21855. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  21856. Γöé      Debugging Options                          Γöé
  21857. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21858. Γöé OPTION      Γöé DESCRIPTION    Γöé DEFAULT       Γöé CHANGING DEFAULT  Γöé
  21859. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21860. Γöé "/W[0|1|2|3]"  Γöé Set the severity  Γöé "/W3"        Γöé "/W0"       Γöé
  21861. Γöé         Γöé level of message  Γöé Produce and count  Γöé Produce and count Γöé
  21862. Γöé         Γöé the compiler    Γöé all message types  Γöé only severe    Γöé
  21863. Γöé         Γöé produces and that Γöé (severe error,   Γöé errors.      Γöé
  21864. Γöé         Γöé causes the error  Γöé error, warning,   Γöé          Γöé
  21865. Γöé         Γöé count to incre-  Γöé and informa-    Γöé "/W1"       Γöé
  21866. Γöé         Γöé ment.  See the   Γöé tional).      Γöé Produce and count Γöé
  21867. Γöé         Γöé Online Language  Γöé           Γöé severe errors and Γöé
  21868. Γöé         Γöé Reference for a  Γöé           Γöé errors.      Γöé
  21869. Γöé         Γöé description of   Γöé           Γöé          Γöé
  21870. Γöé         Γöé error messages   Γöé           Γöé "/W2"       Γöé
  21871. Γöé         Γöé and severity    Γöé           Γöé Produce and count Γöé
  21872. Γöé         Γöé levels.      Γöé           Γöé severe errors,   Γöé
  21873. Γöé         Γöé          Γöé           Γöé errors, and    Γöé
  21874. Γöé         Γöé          Γöé           Γöé warnings.     Γöé
  21875. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  21876.  
  21877. Note:  If you use the /Ti option to generate debugger information, it is 
  21878.        recommended that you turn optimization off (/O-). (This recommendation 
  21879.        does not apply if you are using /Ti to generate information for EXTRA.) 
  21880.  
  21881. Using the /Wgrp Options 
  21882.  
  21883. Related Information 
  21884.  
  21885. o Specifying Compiler Options 
  21886. o Compiler Messages and Return Codes 
  21887.  
  21888.  
  21889. ΓòÉΓòÉΓòÉ 18.6.1. Using the /Wgrp Diagnostic Options ΓòÉΓòÉΓòÉ
  21890.  
  21891. The /Wgrp options control informational messages that warn of possible 
  21892. programming errors, weak programming style, and other information about the 
  21893. structure of your programs. Similar messages are in groups, or suboptions, to 
  21894. give you greater control over which types of messages you want to generate. 
  21895.  
  21896. When you specify /Wall[+], all suboptions are turned on and all possible 
  21897. diagnostic messages are reported.  Because even a simple program that contains 
  21898. no errors can produce many informational messages, you may not want to use 
  21899. /Wall very often. You can use the suboptions alone or in combination to specify 
  21900. the type of messages that you want the compiler to report. Suboptions can be 
  21901. separated by an optional + sign. To turn off a suboption, you must place a - 
  21902. sign after it. 
  21903.  
  21904. You can also combine the /W[0|1|2|3] options with the /Wgrp options. 
  21905.  
  21906. The following table lists the message groups and the message numbers that each 
  21907. controls, as well as the /Kn option that formerly controlled each message. 
  21908. Messages generated for C files begin with EDC0, while messages for C++ files 
  21909. begin with EDC3. 
  21910.  
  21911. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  21912. Γöé      /Wgrp Options                            Γöé
  21913. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21914. Γöé  GRP  Γöé   /K  Γöé CONTROLS MESSAGES ABOUT   Γöé MESSAGES          Γöé
  21915. Γöé     Γöé  OPTION Γöé               Γöé               Γöé
  21916. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21917. Γöé  "all"  Γöé  "/Kf"  Γöé All diagnostics.       Γöé All message numbers listed Γöé
  21918. Γöé     Γöé     Γöé               Γöé in this table.       Γöé
  21919. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21920. Γöé  "cls"  Γöé  (none) Γöé Use of classes        Γöé EDC3110, EDC3253, EDC3266  Γöé
  21921. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21922. Γöé  "cmp"  Γöé  (none) Γöé Possible redundancies in   Γöé EDC3138, EDC3139, EDC3140  Γöé
  21923. Γöé     Γöé     Γöé unsigned comparisons.    Γöé               Γöé
  21924. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21925. Γöé  "cnd"  Γöé  "/Kb"  Γöé Possible redundancies or   Γöé EDC0816, EDC0821, EDC0822, Γöé
  21926. Γöé     Γöé     Γöé problems in conditional   Γöé EDC3107, EDC3130      Γöé
  21927. Γöé     Γöé     Γöé expressions.         Γöé               Γöé
  21928. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21929. Γöé  "cns"  Γöé  "/Kb"  Γöé Operations involving con-  Γöé EDC0823, EDC0824, EDC0838, Γöé
  21930. Γöé     Γöé     Γöé stants.           Γöé EDC0839, EDC0865, EDC0866, Γöé
  21931. Γöé     Γöé     Γöé               Γöé EDC0867, EDC3131, EDC3219  Γöé
  21932. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21933. Γöé  "cnv"  Γöé  "/Kb"  Γöé Conversions.         Γöé EDC3313           Γöé
  21934. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21935. Γöé  "cpy"  Γöé  (none) Γöé Problems generating copy   Γöé EDC3199, EDC3200      Γöé
  21936. Γöé     Γöé     Γöé constructors.        Γöé               Γöé
  21937. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21938. Γöé  "eff"  Γöé  "/Kb"  Γöé Statements with no effect.  Γöé EDC0811, EDC0812, EDC0813, Γöé
  21939. Γöé     Γöé     Γöé               Γöé EDC0814, EDC0815, EDC3165, Γöé
  21940. Γöé     Γöé     Γöé               Γöé EDC3215           Γöé
  21941. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21942. Γöé  "enu"  Γöé  "/Ke"  Γöé Consistency of "enum" vari- Γöé EDC0830, EDC0831, EDC3137  Γöé
  21943. Γöé     Γöé     Γöé ables.            Γöé               Γöé
  21944. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21945. Γöé  "ext"  Γöé  "/Kb"  Γöé Unused external defi-    Γöé EDC0803, EDC0804, EDC0810, Γöé
  21946. Γöé     Γöé  and  Γöé nitions.           Γöé EDC3127           Γöé
  21947. Γöé     Γöé  "/Kx"  Γöé               Γöé               Γöé
  21948. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21949. Γöé  "gen"  Γöé  "/Kb"  Γöé General diagnostics.     Γöé EDC0807, EDC0809, EDC0826, Γöé
  21950. Γöé     Γöé     Γöé               Γöé EDC0835, EDC0868, EDC0869, Γöé
  21951. Γöé     Γöé     Γöé               Γöé EDC3101           Γöé
  21952. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21953. Γöé  "gnr"  Γöé  (none) Γöé Generation of temporary   Γöé EDC3151           Γöé
  21954. Γöé     Γöé     Γöé variables.          Γöé               Γöé
  21955. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21956. Γöé  "got"  Γöé  "/Kg"  Γöé Usage of "goto" statements. Γöé EDC0832, EDC0837      Γöé
  21957. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21958. Γöé  "ini"  Γöé  "/Ki"  Γöé Possible problems with    Γöé EDC0861, EDC0862, EDC0863, Γöé
  21959. Γöé     Γöé     Γöé initialization.       Γöé EDC0864           Γöé
  21960. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21961. Γöé  "lan"  Γöé  (none) Γöé Effects of the language   Γöé EDC3116           Γöé
  21962. Γöé     Γöé     Γöé level.            Γöé               Γöé
  21963. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21964. Γöé  "obs"  Γöé  "/Kb"  Γöé Features that are obsolete. Γöé EDC0827, EDC0828      Γöé
  21965. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21966. Γöé  "ord"  Γöé  "/Kb"  Γöé Unspecified order of evalu- Γöé EDC0829           Γöé
  21967. Γöé     Γöé     Γöé ation.            Γöé               Γöé
  21968. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21969. Γöé  "par"  Γöé  "/Kp"  Γöé Unused parameters.      Γöé EDC0800, EDC3126      Γöé
  21970. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21971. Γöé  "por"  Γöé  "/Ko,  Γöé Nonportable language con-  Γöé EDC0464, EDC0819, EDC0820, Γöé
  21972. Γöé     Γöé  /Kb"  Γöé structs.           Γöé EDC3132, EDC3133, EDC3135, Γöé
  21973. Γöé     Γöé     Γöé               Γöé EDC3136           Γöé
  21974. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21975. Γöé  "ppc"  Γöé  "/Kc"  Γöé Possible problems with    Γöé EDC0836, EDC0841, EDC0842, Γöé
  21976. Γöé     Γöé     Γöé using the preprocessor.   Γöé EDC0843, EDC0844, EDC0845, Γöé
  21977. Γöé     Γöé     Γöé               Γöé EDC0846, EDC0847, EDC0848  Γöé
  21978. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21979. Γöé  "ppt"  Γöé  "/Kt"  Γöé Trace of preprocessor    Γöé EDC0851, EDC0852, EDC0853, Γöé
  21980. Γöé     Γöé     Γöé actions.           Γöé EDC0854, EDC0855, EDC0856, Γöé
  21981. Γöé     Γöé     Γöé               Γöé EDC0857, EDC0858, EDC0859, Γöé
  21982. Γöé     Γöé     Γöé               Γöé EDC0860, EDC0870      Γöé
  21983. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21984. Γöé  "pro"  Γöé  "/Kb"  Γöé Missing function proto-   Γöé EDC0185           Γöé
  21985. Γöé     Γöé     Γöé types.            Γöé               Γöé
  21986. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21987. Γöé  "rea"  Γöé  "/Kb"  Γöé Code that cannot be     Γöé EDC0825, EDC3119      Γöé
  21988. Γöé     Γöé     Γöé reached.           Γöé               Γöé
  21989. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21990. Γöé  "ret"  Γöé  "/Kb"  Γöé Consistency of "return"   Γöé EDC0833, EDC0834, EDC3128  Γöé
  21991. Γöé     Γöé     Γöé statements.         Γöé               Γöé
  21992. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  21993. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  21994. Γöé      /Wgrp Options                            Γöé
  21995. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21996. Γöé  GRP  Γöé   /K  Γöé CONTROLS MESSAGES ABOUT   Γöé MESSAGES          Γöé
  21997. Γöé     Γöé  OPTION Γöé               Γöé               Γöé
  21998. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  21999. Γöé  "trd"  Γöé  "/Ka"  Γöé Possible truncation or loss Γöé EDC0817, EDC0818, EDC3108, Γöé
  22000. Γöé     Γöé     Γöé of data or precision.    Γöé EDC3135, EDC3136      Γöé
  22001. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22002. Γöé  "tru"  Γöé  "/Kr"  Γöé Variable names truncated by Γöé EDC0244           Γöé
  22003. Γöé     Γöé     Γöé the compiler.        Γöé               Γöé
  22004. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22005. Γöé  "und"  Γöé  (none) Γöé Casting of pointers to or  Γöé EDC3098           Γöé
  22006. Γöé     Γöé     Γöé from an undefined class.   Γöé               Γöé
  22007. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22008. Γöé  "uni"  Γöé  "/Ki"  Γöé Uninitialized variables.   Γöé EDC0808           Γöé
  22009. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22010. Γöé  "use"  Γöé  "/Kb,  Γöé Unused "auto" and "static"  Γöé EDC0801, EDC0802, EDC0805, Γöé
  22011. Γöé     Γöé  /Kx"  Γöé variables.          Γöé EDC0806, EDC3002, EDC3099, Γöé
  22012. Γöé     Γöé     Γöé               Γöé EDC3100           Γöé
  22013. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22014. Γöé  "vft"  Γöé  (none) Γöé Generation of virtual func- Γöé EDC3280, EDC3281, EDC3282  Γöé
  22015. Γöé     Γöé     Γöé tion tables.         Γöé               Γöé
  22016. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  22017.  
  22018. More information about the messages generated by the /Wgrp options is available 
  22019. in Compiler Messages and Return Codes. 
  22020.  
  22021. Examples of /Wgrp Options 
  22022.  
  22023. Related Information 
  22024.  
  22025. o Specifying Compiler Options 
  22026. o Compiler Messages and Return Codes 
  22027.  
  22028.  
  22029. ΓòÉΓòÉΓòÉ <hidden> Examples of /Wgrp Options ΓòÉΓòÉΓòÉ
  22030.  
  22031. o Produce all diagnostic messages: 
  22032.  
  22033.        icc /Wall blue.c
  22034.        icc /Wall+ blue.c
  22035.  
  22036. o Produce diagnostic messages about: 
  22037.  
  22038.    - Unreferenced parameters 
  22039.    - Missing function prototypes 
  22040.    - Uninitialized variables by turning on the appropriate suboptions: 
  22041.  
  22042.        icc /Wpar+pro+uni blue.c
  22043.        icc /Wparprouni blue.c
  22044.  
  22045. o Produce all diagnostic messages except: 
  22046.  
  22047.    - Warnings about assignments that can cause a loss of precision 
  22048.    - Preprocessor trace messages 
  22049.    - External variable warnings by turning on all options, and then turning off 
  22050.   the ones you do not want: 
  22051.  
  22052.        icc /Wall+trd-ppt-ext- blue.c
  22053.  
  22054. o Produce only basic diagnostics, with all other suboptions turned off: 
  22055.  
  22056.        icc /Wgen+ blue.c
  22057.  
  22058. o Produce only basic diagnostics and messages about severe errors, errors, or 
  22059.   warnings (/W2): 
  22060.  
  22061.        icc /Wgen2 blue.c
  22062.  
  22063.  
  22064. ΓòÉΓòÉΓòÉ 18.7. Source Code Options ΓòÉΓòÉΓòÉ
  22065.  
  22066. These options control how the C/C++ Tools compiler interprets your source file. 
  22067. This control is especially useful, for example, if you are migrating code or 
  22068. ensuring consistency with a particular language standard. 
  22069.  
  22070. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  22071. Γöé      Source Code Options                         Γöé
  22072. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22073. Γöé OPTION     Γöé DESCRIPTION     Γöé DEFAULT       Γöé CHANGING DEFAULT  Γöé
  22074. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22075. Γöé "/S[a|c|e|2]"  Γöé Set language    Γöé "/Se"        Γöé "/Sa"       Γöé
  22076. Γöé         Γöé level.       Γöé Allow all      Γöé Conform to ANSI  Γöé
  22077. Γöé         Γöé           Γöé C/C++ Tools lan-  Γöé standards.     Γöé
  22078. Γöé         Γöé           Γöé guage extensions.  Γöé          Γöé
  22079. Γöé         Γöé           Γöé           Γöé "/Sc"       Γöé
  22080. Γöé         Γöé           Γöé           Γöé Allow constructs  Γöé
  22081. Γöé         Γöé           Γöé           Γöé compatible with  Γöé
  22082. Γöé         Γöé           Γöé           Γöé older levels of  Γöé
  22083. Γöé         Γöé           Γöé           Γöé the C++ language. Γöé
  22084. Γöé         Γöé           Γöé           Γöé          Γöé
  22085. Γöé         Γöé           Γöé           Γöé NOTE:  This    Γöé
  22086. Γöé         Γöé           Γöé           Γöé option is valid  Γöé
  22087. Γöé         Γöé           Γöé           Γöé only for C++    Γöé
  22088. Γöé         Γöé           Γöé           Γöé files.       Γöé
  22089. Γöé         Γöé           Γöé           Γöé          Γöé
  22090. Γöé         Γöé           Γöé           Γöé "/S2"       Γöé
  22091. Γöé         Γöé           Γöé           Γöé Conform to SAA   Γöé
  22092. Γöé         Γöé           Γöé           Γöé Level 2 stand-   Γöé
  22093. Γöé         Γöé           Γöé           Γöé ards.       Γöé
  22094. Γöé         Γöé           Γöé           Γöé          Γöé
  22095. Γöé         Γöé           Γöé           Γöé NOTE:  This    Γöé
  22096. Γöé         Γöé           Γöé           Γöé option is valid  Γöé
  22097. Γöé         Γöé           Γöé           Γöé only for C files. Γöé
  22098. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22099. Γöé "/Sd[+|-]"   Γöé Set default file  Γöé "/Sd-"       Γöé "/Sd[+]"      Γöé
  22100. Γöé         Γöé extension.     Γöé Set the default   Γöé Set the default  Γöé
  22101. Γöé         Γöé           Γöé file extension as  Γöé file extension as Γöé
  22102. Γöé         Γöé           Γöé ".obj".       Γöé ".c".       Γöé
  22103. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22104. Γöé "/Sg[l][,<r|*>]Γöé Set left and right Γöé "/Sg-"       Γöé "/Sg[l][,r|*]"   Γöé
  22105. Γöé         Γöé margins of the   Γöé Do not set any   Γöé Set left margin  Γöé
  22106. Γöé "/Sg-"     Γöé input file and   Γöé margins: use the  Γöé to "l".  The    Γöé
  22107. Γöé         Γöé ignore text     Γöé entire input file. Γöé right margin can  Γöé
  22108. Γöé         Γöé outside these    Γöé           Γöé be the value r,  Γöé
  22109. Γöé         Γöé margins.  Useful  Γöé           Γöé or an asterisk   Γöé
  22110. Γöé         Γöé when using source  Γöé           Γöé can be used to   Γöé
  22111. Γöé         Γöé files that contain Γöé           Γöé denote no right  Γöé
  22112. Γöé         Γöé characters that   Γöé           Γöé margin.  "l" and  Γöé
  22113. Γöé         Γöé you want to     Γöé           Γöé r must be between Γöé
  22114. Γöé         Γöé ignore.       Γöé           Γöé 1 and 65535    Γöé
  22115. Γöé         Γöé           Γöé           Γöé inclusive, and r  Γöé
  22116. Γöé         Γöé NOTE:  This    Γöé           Γöé must be greater  Γöé
  22117. Γöé         Γöé option is only   Γöé           Γöé than or equal to  Γöé
  22118. Γöé         Γöé valid for C files. Γöé           Γöé "l".        Γöé
  22119. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22120. Γöé "/Sh[+|-]"   Γöé Control use of   Γöé "/Sh-"       Γöé "/Sh[+]"      Γöé
  22121. Γöé         Γöé ddnames.      Γöé Do not allow    Γöé Allow use of    Γöé
  22122. Γöé         Γöé           Γöé ddnames.      Γöé ddnames.      Γöé
  22123. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22124. Γöé "/Si[+|-]"   Γöé Control use of   Γöé "/Si-"       Γöé "/Si[+]"      Γöé
  22125. Γöé         Γöé precompiled header Γöé Do not use precom- Γöé Use precompiled  Γöé
  22126. Γöé         Γöé files.       Γöé piled header    Γöé header files if  Γöé
  22127. Γöé         Γöé           Γöé files.       Γöé they exist and   Γöé
  22128. Γöé         Γöé           Γöé           Γöé are current.    Γöé
  22129. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22130. Γöé "/Sm[+|-]"   Γöé Control compiler  Γöé "/Sm-"       Γöé "/Sm[+]"      Γöé
  22131. Γöé         Γöé interpretation of  Γöé Treat unsupported  Γöé Ignore unsup-   Γöé
  22132. Γöé         Γöé unsupported 16-bit Γöé 16-bit keywords   Γöé ported 16-bit   Γöé
  22133. Γöé         Γöé keywords, such as  Γöé like any other   Γöé keywords.     Γöé
  22134. Γöé         Γöé "near" and "far".  Γöé identifier.     Γöé          Γöé
  22135. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22136. Γöé "/Sn[+|-]"   Γöé Control use of   Γöé "/Sn-"       Γöé "/Sn[+]"      Γöé
  22137. Γöé         Γöé double-byte char-  Γöé Do not allow use  Γöé Allow use of    Γöé
  22138. Γöé         Γöé acter set (DBCS).  Γöé of DBCS.      Γöé DBCS.       Γöé
  22139. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22140. Γöé "/Sp[1|2|4]"  Γöé Specify alignment  Γöé "/Sp4"       Γöé "/Sp[1|2]"     Γöé
  22141. Γöé         Γöé or packing of data Γöé Align structures  Γöé Align structures  Γöé
  22142. Γöé         Γöé items within    Γöé and unions along  Γöé and unions along  Γöé
  22143. Γöé         Γöé structures and   Γöé 4-byte boundaries  Γöé 1-byte or 2-byte  Γöé
  22144. Γöé         Γöé unions.       Γöé (normal align-   Γöé boundaries.    Γöé
  22145. Γöé         Γöé           Γöé ment).       Γöé "/Sp" is equiv-  Γöé
  22146. Γöé         Γöé           Γöé           Γöé alent to "/Sp1".  Γöé
  22147. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  22148. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  22149. Γöé      Source Code Options                         Γöé
  22150. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22151. Γöé OPTION     Γöé DESCRIPTION     Γöé DEFAULT       Γöé CHANGING DEFAULT  Γöé
  22152. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22153. Γöé "/Sq[l][,<r|*>]Γöé Specify columns in Γöé "/Sq-"       Γöé "/Sq[l][,r|*]"   Γöé
  22154. Γöé         Γöé which sequence   Γöé Use no sequence   Γöé Sequence numbers  Γöé
  22155. Γöé "/Sq-"     Γöé numbers appear,   Γöé numbers.      Γöé appear between   Γöé
  22156. Γöé         Γöé and ignore text in Γöé           Γöé columns "l" and r Γöé
  22157. Γöé         Γöé those columns.   Γöé           Γöé of each line in  Γöé
  22158. Γöé         Γöé This option can be Γöé           Γöé the input source  Γöé
  22159. Γöé         Γöé used when      Γöé           Γöé code.  "l" and r  Γöé
  22160. Γöé         Γöé importing source  Γöé           Γöé must be between 1 Γöé
  22161. Γöé         Γöé files from other  Γöé           Γöé and 65535 inclu-  Γöé
  22162. Γöé         Γöé systems.      Γöé           Γöé sive, and r must  Γöé
  22163. Γöé         Γöé           Γöé           Γöé be greater than  Γöé
  22164. Γöé         Γöé NOTE:  This    Γöé           Γöé or equal to "l".  Γöé
  22165. Γöé         Γöé option is only   Γöé           Γöé If you do not   Γöé
  22166. Γöé         Γöé valid for C files. Γöé           Γöé want to specify a Γöé
  22167. Γöé         Γöé           Γöé           Γöé right column, use Γöé
  22168. Γöé         Γöé           Γöé           Γöé an asterisk for  Γöé
  22169. Γöé         Γöé           Γöé           Γöé r.         Γöé
  22170. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22171. Γöé "/Sr[+|-]"   Γöé Set type conver-  Γöé "/Sr-"       Γöé "/Sr[+]"      Γöé
  22172. Γöé         Γöé sion rules.     Γöé Use new-style    Γöé Use old-style   Γöé
  22173. Γöé         Γöé           Γöé rules for type   Γöé rules for type   Γöé
  22174. Γöé         Γöé NOTE:  This    Γöé conversion.  New-  Γöé conversion.  Old- Γöé
  22175. Γöé         Γöé option is valid   Γöé style rules pre-  Γöé style rules pre-  Γöé
  22176. Γöé         Γöé for C files only.  Γöé serve accuracy.   Γöé serve the sign.  Γöé
  22177. Γöé         Γöé           Γöé           Γöé They do not    Γöé
  22178. Γöé         Γöé           Γöé           Γöé conform to ANSI  Γöé
  22179. Γöé         Γöé           Γöé           Γöé standards.     Γöé
  22180. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22181. Γöé "/Ss[+|-]"   Γöé Allow use of    Γöé "/Ss-"       Γöé "/Ss[+]"      Γöé
  22182. Γöé         Γöé double slashes   Γöé Do not allow    Γöé Allow the double  Γöé
  22183. Γöé         Γöé ("//") for com-   Γöé double slashes to  Γöé slash format to  Γöé
  22184. Γöé         Γöé ments.       Γöé indicate comments. Γöé indicate com-   Γöé
  22185. Γöé         Γöé           Γöé           Γöé ments.  This type Γöé
  22186. Γöé         Γöé NOTE:  This    Γöé           Γöé of comment is   Γöé
  22187. Γöé         Γöé option is only   Γöé           Γöé ended by a car-  Γöé
  22188. Γöé         Γöé valid for C files. Γöé           Γöé riage return.   Γöé
  22189. Γöé         Γöé C++ allows double  Γöé           Γöé          Γöé
  22190. Γöé         Γöé slashes to indi-  Γöé           Γöé          Γöé
  22191. Γöé         Γöé cate comments as  Γöé           Γöé          Γöé
  22192. Γöé         Γöé part of the lan-  Γöé           Γöé          Γöé
  22193. Γöé         Γöé guage.       Γöé           Γöé          Γöé
  22194. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22195. Γöé "/Su[+|-|1|2|4]Γöé Control size of   Γöé "/Su-"       Γöé "/Su[+]"      Γöé
  22196. Γöé         Γöé "enum" variables.  Γöé Use the SAA rules: Γöé Make all "enum"  Γöé
  22197. Γöé         Γöé           Γöé make all "enum"   Γöé variables 4    Γöé
  22198. Γöé         Γöé           Γöé variables the size Γöé bytes.       Γöé
  22199. Γöé         Γöé           Γöé of the smallest   Γöé          Γöé
  22200. Γöé         Γöé           Γöé integral type that Γöé "/Su1"       Γöé
  22201. Γöé         Γöé           Γöé can contain all   Γöé Make all "enum"  Γöé
  22202. Γöé         Γöé           Γöé variables.     Γöé variables 1 byte. Γöé
  22203. Γöé         Γöé           Γöé           Γöé          Γöé
  22204. Γöé         Γöé           Γöé           Γöé "/Su2"       Γöé
  22205. Γöé         Γöé           Γöé           Γöé Make all "enum"  Γöé
  22206. Γöé         Γöé           Γöé           Γöé variables 2    Γöé
  22207. Γöé         Γöé           Γöé           Γöé bytes.       Γöé
  22208. Γöé         Γöé           Γöé           Γöé          Γöé
  22209. Γöé         Γöé           Γöé           Γöé "/Su4"       Γöé
  22210. Γöé         Γöé           Γöé           Γöé Make all "enum"  Γöé
  22211. Γöé         Γöé           Γöé           Γöé variables 4    Γöé
  22212. Γöé         Γöé           Γöé           Γöé bytes.       Γöé
  22213. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22214. Γöé "/Sv[+|-]"   Γöé Allow use of    Γöé "/Sv-"       Γöé "/Sv[+]"      Γöé
  22215. Γöé         Γöé memory files.    Γöé Do not allow    Γöé Allow use of    Γöé
  22216. Γöé         Γöé           Γöé memory files.    Γöé memory files.   Γöé
  22217. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22218. Γöé "/Tc"      Γöé Specify that the  Γöé Compile ".cpp" and Γöé "/Tc"       Γöé
  22219. Γöé         Γöé following file is  Γöé ".cxx" files as   Γöé Compile the fol-  Γöé
  22220. Γöé         Γöé a C file.      Γöé C++ files, and   Γöé lowing file as a  Γöé
  22221. Γöé         Γöé           Γöé ".c" and all other Γöé C source file,   Γöé
  22222. Γöé         Γöé IMPORTANT:  The   Γöé unrecognized files Γöé regardless of its Γöé
  22223. Γöé         Γöé "/Tc" option MUST  Γöé as C files.     Γöé extension.     Γöé
  22224. Γöé         Γöé be immediately   Γöé           Γöé          Γöé
  22225. Γöé         Γöé followed by a file Γöé           Γöé          Γöé
  22226. Γöé         Γöé name, and applies  Γöé           Γöé          Γöé
  22227. Γöé         Γöé only to that file. Γöé           Γöé          Γöé
  22228. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  22229. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  22230. Γöé      Source Code Options                         Γöé
  22231. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22232. Γöé OPTION     Γöé DESCRIPTION     Γöé DEFAULT       Γöé CHANGING DEFAULT  Γöé
  22233. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22234. Γöé "/Td[c|p]"   Γöé Specify default   Γöé "/Td"        Γöé "/Tdc"       Γöé
  22235. Γöé         Γöé language (C or   Γöé Compile ".cpp" and Γöé Compile all    Γöé
  22236. Γöé         Γöé C++) for files.   Γöé ".cxx" files as   Γöé source and unrec- Γöé
  22237. Γöé         Γöé           Γöé C++ files, and   Γöé ognized files   Γöé
  22238. Γöé         Γöé           Γöé ".c" and all other Γöé that follow on   Γöé
  22239. Γöé         Γöé           Γöé unrecognized files Γöé the command line  Γöé
  22240. Γöé         Γöé           Γöé as C files.     Γöé as C files.    Γöé
  22241. Γöé         Γöé           Γöé           Γöé          Γöé
  22242. Γöé         Γöé           Γöé           Γöé "/Tdp"       Γöé
  22243. Γöé         Γöé           Γöé           Γöé Compile all    Γöé
  22244. Γöé         Γöé           Γöé           Γöé source and unrec- Γöé
  22245. Γöé         Γöé           Γöé           Γöé ognized files   Γöé
  22246. Γöé         Γöé           Γöé           Γöé that follow on   Γöé
  22247. Γöé         Γöé           Γöé           Γöé the command line  Γöé
  22248. Γöé         Γöé           Γöé           Γöé as C++ files, and Γöé
  22249. Γöé         Γöé           Γöé           Γöé ensure that tem-  Γöé
  22250. Γöé         Γöé           Γöé           Γöé plate functions  Γöé
  22251. Γöé         Γöé           Γöé           Γöé are resolved cor- Γöé
  22252. Γöé         Γöé           Γöé           Γöé rectly.      Γöé
  22253. Γöé         Γöé           Γöé           Γöé          Γöé
  22254. Γöé         Γöé           Γöé           Γöé NOTE:  You can   Γöé
  22255. Γöé         Γöé           Γöé           Γöé specify "/Td"   Γöé
  22256. Γöé         Γöé           Γöé           Γöé anywhere on the  Γöé
  22257. Γöé         Γöé           Γöé           Γöé command line to  Γöé
  22258. Γöé         Γöé           Γöé           Γöé return to the   Γöé
  22259. Γöé         Γöé           Γöé           Γöé default rules for Γöé
  22260. Γöé         Γöé           Γöé           Γöé the files that   Γöé
  22261. Γöé         Γöé           Γöé           Γöé follow it.     Γöé
  22262. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22263. Γöé "/Tp"      Γöé Specify that the  Γöé Compile ".cpp" and Γöé "/Tp"       Γöé
  22264. Γöé         Γöé following file is  Γöé ".cxx" files as   Γöé Compile the fol-  Γöé
  22265. Γöé         Γöé a C++ file.     Γöé C++ files, and   Γöé lowing file as a  Γöé
  22266. Γöé         Γöé           Γöé ".c" and all other Γöé C++ source file,  Γöé
  22267. Γöé         Γöé IMPORTANT:  The   Γöé unrecognized files Γöé regardless of its Γöé
  22268. Γöé         Γöé "/Tp" option MUST  Γöé as C files.     Γöé extension.     Γöé
  22269. Γöé         Γöé be immediately   Γöé           Γöé          Γöé
  22270. Γöé         Γöé followed by a file Γöé           Γöé          Γöé
  22271. Γöé         Γöé name, and applies  Γöé           Γöé          Γöé
  22272. Γöé         Γöé only to that file. Γöé           Γöé          Γöé
  22273. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  22274.  
  22275. Additional information is available on: 
  22276.  
  22277. o Using the /Sd Option 
  22278. o Using the /Tdp Option for Template Resolution 
  22279.  
  22280. Related Information 
  22281.  
  22282. o #pragma langlvl 
  22283. o #pragma pack 
  22284. o _Packed Qualifier 
  22285. o #pragma margins 
  22286. o #pragma sequence 
  22287. o Comments 
  22288. o Specifying Compiler Options 
  22289.  
  22290.  
  22291. ΓòÉΓòÉΓòÉ 18.7.1. Using the /Sd Option ΓòÉΓòÉΓòÉ
  22292.  
  22293. This option specifies whether a file without an extension should be considered 
  22294. a C source file or an object file, and whether it should be compiled and linked 
  22295. or just linked. When using the default (/Sd-), you must specify the extension 
  22296. when using a source file: 
  22297.  
  22298.    icc anthony.c
  22299.    icc efrem.cpp
  22300.  
  22301. If you omit the extension, the C/C++ Tools compiler assumes that the file is an 
  22302. object file (.obj) and does not compile it, but only invokes the linker. The 
  22303. following commands are equivalent (assuming that /Sd+ has not been specified 
  22304. elsewhere, such as in ICC). 
  22305.  
  22306.    icc dale
  22307.    icc dale.obj
  22308.    icc /Sd- dale
  22309.  
  22310. If you want the default file extension to be the default source file extension, 
  22311. use the /Sd+ option.  For example, the following two commands are equivalent: 
  22312.  
  22313.    icc alistair.c
  22314.    icc /Sd+ alistair
  22315.  
  22316. Note:  The /Tc and /Tp options override the setting of /Sd.  If you specify 
  22317.        either /Tc or /Tp followed by a file name without an extension, the 
  22318.        compiler looks for the name specified, without an extension, and treats 
  22319.        the file as a C file (if /Tc was specified) or a C++ file (if /Tp was 
  22320.        specified). For example, given the following command: 
  22321.  
  22322.                  icc /Tp xiaohu
  22323.  
  22324. the compiler searches for the file xiaohu and compiles it as a C++ file. 
  22325.  
  22326.  
  22327. ΓòÉΓòÉΓòÉ 18.7.2. Using the /Tdp Option for Template Resolution ΓòÉΓòÉΓòÉ
  22328.  
  22329. When you link C++ object or intermediate code files, you must use icc to invoke 
  22330. the linker and you must specify the /Tdp option. For example: 
  22331.  
  22332.    icc /Tdp /Ol tammy.w trish.w
  22333.    icc /Tdp wang.obj
  22334.  
  22335. This ensures that any template functions you use are resolved correctly, among 
  22336. other things. You can use the /B option to pass options to the linker. 
  22337.  
  22338.  
  22339. ΓòÉΓòÉΓòÉ 18.8. Preprocessor Options ΓòÉΓòÉΓòÉ
  22340.  
  22341. The options listed here control the use of the preprocessor. 
  22342.  
  22343. Note that the /Pc, /Pd, and /Pe options are actually suboptions of /P. 
  22344. Specifying /Pc- is the same as specifying /P+c- and causes only the 
  22345. preprocessor to be run. 
  22346.  
  22347. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  22348. Γöé      Preprocessor Options                        Γöé
  22349. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22350. Γöé OPTION    Γöé DESCRIPTION     Γöé DEFAULT       Γöé CHANGING DEFAULT  Γöé
  22351. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22352. Γöé  /Dname[::n]Γöé Define pre-     Γöé Define no macros on Γöé  /Dname[::n]    Γöé
  22353. Γöé  or     Γöé processor macros  Γöé command line.    Γöé  or        Γöé
  22354. Γöé  /Dname[=n] Γöé to specified    Γöé           Γöé  /Dname[=n]    Γöé
  22355. Γöé        Γöé values.       Γöé           Γöé           Γöé
  22356. Γöé        Γöé           Γöé           Γöé Define pre-     Γöé
  22357. Γöé        Γöé           Γöé           Γöé processor macro   Γöé
  22358. Γöé        Γöé           Γöé           Γöé name to the value  Γöé
  22359. Γöé        Γöé           Γöé           Γöé n.  If n is     Γöé
  22360. Γöé        Γöé           Γöé           Γöé omitted, the macro Γöé
  22361. Γöé        Γöé           Γöé           Γöé is set to a null  Γöé
  22362. Γöé        Γöé           Γöé           Γöé string.  Macros   Γöé
  22363. Γöé        Γöé           Γöé           Γöé defined on the   Γöé
  22364. Γöé        Γöé           Γöé           Γöé command line over- Γöé
  22365. Γöé        Γöé           Γöé           Γöé ride macros     Γöé
  22366. Γöé        Γöé           Γöé           Γöé defined in the   Γöé
  22367. Γöé        Γöé           Γöé           Γöé source code.    Γöé
  22368. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22369. Γöé "/P[+|-]"   Γöé Control the pre-  Γöé "/P-"        Γöé "/P[+]"       Γöé
  22370. Γöé        Γöé processor.     Γöé Run the pre-     Γöé Run the pre-    Γöé
  22371. Γöé        Γöé           Γöé processor and com-  Γöé processor only.   Γöé
  22372. Γöé        Γöé           Γöé piler.  Do not    Γöé Create a pre-    Γöé
  22373. Γöé        Γöé           Γöé generate pre-    Γöé processor output  Γöé
  22374. Γöé        Γöé           Γöé processor output.  Γöé file that has the  Γöé
  22375. Γöé        Γöé           Γöé           Γöé same name as the  Γöé
  22376. Γöé        Γöé           Γöé           Γöé source file, with  Γöé
  22377. Γöé        Γöé           Γöé           Γöé the extension    Γöé
  22378. Γöé        Γöé           Γöé           Γöé ".i".        Γöé
  22379. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22380. Γöé "/Pc[+|-]"  Γöé Preserve source   Γöé "/P-"        Γöé "/Pc-"       Γöé
  22381. Γöé        Γöé code comments in  Γöé Run the pre-     Γöé Run the pre-    Γöé
  22382. Γöé        Γöé preprocessor    Γöé processor and com-  Γöé processor only.   Γöé
  22383. Γöé        Γöé output.       Γöé piler.  Do not    Γöé Create a pre-    Γöé
  22384. Γöé        Γöé           Γöé generate pre-    Γöé processor output  Γöé
  22385. Γöé        Γöé           Γöé processor output.  Γöé file and strip out Γöé
  22386. Γöé        Γöé           Γöé           Γöé any comments.  The Γöé
  22387. Γöé        Γöé           Γöé           Γöé output file has   Γöé
  22388. Γöé        Γöé           Γöé           Γöé the same name as  Γöé
  22389. Γöé        Γöé           Γöé           Γöé the source file,  Γöé
  22390. Γöé        Γöé           Γöé           Γöé with the extension Γöé
  22391. Γöé        Γöé           Γöé           Γöé ".i".        Γöé
  22392. Γöé        Γöé           Γöé           Γöé           Γöé
  22393. Γöé        Γöé           Γöé           Γöé "/Pc[+]"      Γöé
  22394. Γöé        Γöé           Γöé           Γöé Run the pre-    Γöé
  22395. Γöé        Γöé           Γöé           Γöé processor only.   Γöé
  22396. Γöé        Γöé           Γöé           Γöé Create a pre-    Γöé
  22397. Γöé        Γöé           Γöé           Γöé processor output  Γöé
  22398. Γöé        Γöé           Γöé           Γöé file that includes Γöé
  22399. Γöé        Γöé           Γöé           Γöé the comments from  Γöé
  22400. Γöé        Γöé           Γöé           Γöé the source code.  Γöé
  22401. Γöé        Γöé           Γöé           Γöé The output file   Γöé
  22402. Γöé        Γöé           Γöé           Γöé has the same name  Γöé
  22403. Γöé        Γöé           Γöé           Γöé as the source    Γöé
  22404. Γöé        Γöé           Γöé           Γöé file, with the   Γöé
  22405. Γöé        Γöé           Γöé           Γöé extension ".i".   Γöé
  22406. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22407. Γöé "/Pd[+|-]"  Γöé Redirect pre-    Γöé "/P-"        Γöé "/Pd-"       Γöé
  22408. Γöé        Γöé processor output.  Γöé Run the pre-     Γöé Run the pre-    Γöé
  22409. Γöé        Γöé           Γöé processor and com-  Γöé processor only.   Γöé
  22410. Γöé        Γöé           Γöé piler.  Do not    Γöé Do not redirect   Γöé
  22411. Γöé        Γöé           Γöé generate pre-    Γöé preprocessor    Γöé
  22412. Γöé        Γöé           Γöé processor output.  Γöé output.  Write   Γöé
  22413. Γöé        Γöé           Γöé           Γöé preprocessor    Γöé
  22414. Γöé        Γöé           Γöé           Γöé output to a file  Γöé
  22415. Γöé        Γöé           Γöé           Γöé that has the same  Γöé
  22416. Γöé        Γöé           Γöé           Γöé name as the source Γöé
  22417. Γöé        Γöé           Γöé           Γöé file, with the   Γöé
  22418. Γöé        Γöé           Γöé           Γöé extension ".I".   Γöé
  22419. Γöé        Γöé           Γöé           Γöé           Γöé
  22420. Γöé        Γöé           Γöé           Γöé "/Pd[+]"      Γöé
  22421. Γöé        Γöé           Γöé           Γöé Run the pre-    Γöé
  22422. Γöé        Γöé           Γöé           Γöé processor only.   Γöé
  22423. Γöé        Γöé           Γöé           Γöé Send the pre-    Γöé
  22424. Γöé        Γöé           Γöé           Γöé processor output  Γöé
  22425. Γöé        Γöé           Γöé           Γöé to "stdout".    Γöé
  22426. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  22427. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  22428. Γöé      Preprocessor Options                        Γöé
  22429. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22430. Γöé OPTION    Γöé DESCRIPTION     Γöé DEFAULT       Γöé CHANGING DEFAULT  Γöé
  22431. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22432. Γöé "/Pe[+|-]"  Γöé Suppress "#line"  Γöé "/P-"        Γöé "/Pe-"       Γöé
  22433. Γöé        Γöé directives in pre- Γöé Run the pre-     Γöé Run the pre-    Γöé
  22434. Γöé        Γöé processor output.  Γöé processor and com-  Γöé processor only.   Γöé
  22435. Γöé        Γöé           Γöé piler.  Do not    Γöé Generate "#line"  Γöé
  22436. Γöé        Γöé           Γöé generate pre-    Γöé directives in the  Γöé
  22437. Γöé        Γöé           Γöé processor output.  Γöé preprocessor    Γöé
  22438. Γöé        Γöé           Γöé           Γöé output.  The    Γöé
  22439. Γöé        Γöé           Γöé           Γöé output file has   Γöé
  22440. Γöé        Γöé           Γöé           Γöé the same name as  Γöé
  22441. Γöé        Γöé           Γöé           Γöé the source file,  Γöé
  22442. Γöé        Γöé           Γöé           Γöé with the extension Γöé
  22443. Γöé        Γöé           Γöé           Γöé ".i".        Γöé
  22444. Γöé        Γöé           Γöé           Γöé           Γöé
  22445. Γöé        Γöé           Γöé           Γöé "/Pe[+]"      Γöé
  22446. Γöé        Γöé           Γöé           Γöé Run the pre-    Γöé
  22447. Γöé        Γöé           Γöé           Γöé processor only.   Γöé
  22448. Γöé        Γöé           Γöé           Γöé Suppress creation  Γöé
  22449. Γöé        Γöé           Γöé           Γöé of "#line" direc-  Γöé
  22450. Γöé        Γöé           Γöé           Γöé tives in pre-    Γöé
  22451. Γöé        Γöé           Γöé           Γöé processor output.  Γöé
  22452. Γöé        Γöé           Γöé           Γöé The output file   Γöé
  22453. Γöé        Γöé           Γöé           Γöé has the same name  Γöé
  22454. Γöé        Γöé           Γöé           Γöé as the source    Γöé
  22455. Γöé        Γöé           Γöé           Γöé file, with the   Γöé
  22456. Γöé        Γöé           Γöé           Γöé extension ".i".   Γöé
  22457. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22458. Γöé "/U<name|*>" Γöé Undefine macros.  Γöé Retain macros.    Γöé "/Uname"      Γöé
  22459. Γöé        Γöé           Γöé           Γöé Undefine macro   Γöé
  22460. Γöé        Γöé           Γöé           Γöé name.        Γöé
  22461. Γöé        Γöé           Γöé           Γöé           Γöé
  22462. Γöé        Γöé           Γöé           Γöé "/U*"        Γöé
  22463. Γöé        Γöé           Γöé           Γöé Undefine all    Γöé
  22464. Γöé        Γöé           Γöé           Γöé macros.       Γöé
  22465. Γöé        Γöé           Γöé           Γöé           Γöé
  22466. Γöé        Γöé           Γöé           Γöé NOTE:  "/U" does  Γöé
  22467. Γöé        Γöé           Γöé           Γöé not affect the   Γöé
  22468. Γöé        Γöé           Γöé           Γöé macros "__DATE__,  Γöé
  22469. Γöé        Γöé           Γöé           Γöé __TIME__,      Γöé
  22470. Γöé        Γöé           Γöé           Γöé __TIMESTAMP__,   Γöé
  22471. Γöé        Γöé           Γöé           Γöé __FILE__", and   Γöé
  22472. Γöé        Γöé           Γöé           Γöé "__FUNCTION", nor  Γöé
  22473. Γöé        Γöé           Γöé           Γöé does it undefine  Γöé
  22474. Γöé        Γöé           Γöé           Γöé macros defined in  Γöé
  22475. Γöé        Γöé           Γöé           Γöé source code.    Γöé
  22476. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  22477.  
  22478. Additional information is available on Using the Preprocessor. 
  22479.  
  22480. Related Information 
  22481.  
  22482. o Preprocessor Directives 
  22483. o Predefined Macros 
  22484. o Specifying Compiler Options 
  22485.  
  22486.  
  22487. ΓòÉΓòÉΓòÉ 18.8.1. Using the Preprocessor ΓòÉΓòÉΓòÉ
  22488.  
  22489. Preprocessor directives, such as #include, allow you to include C or C++ code 
  22490. from another source file into yours, to define macros, and to expand macros. 
  22491. See Preprocessor Directives for a list of preprocessor directives and 
  22492. information on how to use them. 
  22493.  
  22494. If you run only the preprocessor, you can use the preprocessor output (which 
  22495. has all the preprocessor directives executed, but no code compiled) to debug 
  22496. your program. For example, all macros are expanded, and the code for all files 
  22497. included by #include directives appears in your program. 
  22498.  
  22499. By default, comments in the source code are not included in the preprocessor 
  22500. output.  To preserve the comments, use the /Pc option. For C programs, if you 
  22501. use // to begin your comments, you must also specify the /Ss option to include 
  22502. those comments in the preprocessor output. 
  22503.  
  22504. The /P, /Pc, /Pd, and /Pe options can be used in combination with each other. 
  22505. For example, to preserve comments, suppress #line directives, and redirect the 
  22506. preprocessor output to stdout, specify /Pcde. 
  22507.  
  22508.  
  22509. ΓòÉΓòÉΓòÉ 18.9. Code Generation Options ΓòÉΓòÉΓòÉ
  22510.  
  22511. These options specify the type of code that the compiler will produce. 
  22512.  
  22513. Notes: 
  22514.  
  22515. o The /Oi[+] option is more effective when /O[+] is also specified. 
  22516. o Using optimization (/O[+]) limits your use of the C/C++ Tools debugger to 
  22517.   debug your code. The /Ti option is not recommended for use with optimization. 
  22518.  
  22519. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  22520. Γöé      Code Generation Options                       Γöé
  22521. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22522. Γöé OPTION    Γöé DESCRIPTION     Γöé DEFAULT       Γöé CHANGING DEFAULT  Γöé
  22523. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22524. Γöé "/Gd[+|-]"  Γöé Specify static or  Γöé "/Gd-"        Γöé "/Gd[+]"      Γöé
  22525. Γöé       Γöé dynamic linking of  Γöé Statically link the Γöé Dynamically link  Γöé
  22526. Γöé       Γöé the runtime     Γöé runtime library.   Γöé to the runtime   Γöé
  22527. Γöé       Γöé library.       Γöé All external names  Γöé library.      Γöé
  22528. Γöé       Γöé           Γöé beginning with the  Γöé           Γöé
  22529. Γöé       Γöé           Γöé letters "Dos",    Γöé           Γöé
  22530. Γöé       Γöé           Γöé "Kbd", and "Vio"   Γöé           Γöé
  22531. Γöé       Γöé           Γöé are reserved.  This Γöé           Γöé
  22532. Γöé       Γöé           Γöé restriction does   Γöé           Γöé
  22533. Γöé       Γöé           Γöé not apply when com- Γöé           Γöé
  22534. Γöé       Γöé           Γöé piling with "/Gd+". Γöé           Γöé
  22535. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22536. Γöé "/Ge[+|-]"  Γöé Specify creation of Γöé "/Ge[+]"       Γöé "/Ge-"       Γöé
  22537. Γöé       Γöé an ".EXE" or a    Γöé Build an ".EXE"   Γöé Build a ".DLL"   Γöé
  22538. Γöé       Γöé ".DLL" file.     Γöé file.        Γöé file.        Γöé
  22539. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22540. Γöé "/Gf[+|-]"  Γöé Specify fast     Γöé "/Gf-"        Γöé "/Gf[+]"      Γöé
  22541. Γöé       Γöé floating-point exe- Γöé Do not use fast   Γöé Use fast floating- Γöé
  22542. Γöé       Γöé cution.       Γöé floating-point exe- Γöé point execution.  Γöé
  22543. Γöé       Γöé           Γöé cution.       Γöé           Γöé
  22544. Γöé       Γöé If your program   Γöé           Γöé           Γöé
  22545. Γöé       Γöé does not need to   Γöé           Γöé           Γöé
  22546. Γöé       Γöé abide by ANSI rules Γöé           Γöé           Γöé
  22547. Γöé       Γöé regarding the proc- Γöé           Γöé           Γöé
  22548. Γöé       Γöé essing of "double"  Γöé           Γöé           Γöé
  22549. Γöé       Γöé and "float" types,  Γöé           Γöé           Γöé
  22550. Γöé       Γöé you can use this   Γöé           Γöé           Γöé
  22551. Γöé       Γöé option to increase  Γöé           Γöé           Γöé
  22552. Γöé       Γöé your program's per- Γöé           Γöé           Γöé
  22553. Γöé       Γöé formance.  Because  Γöé           Γöé           Γöé
  22554. Γöé       Γöé the fast floating-  Γöé           Γöé           Γöé
  22555. Γöé       Γöé point method does  Γöé           Γöé           Γöé
  22556. Γöé       Γöé not perform all the Γöé           Γöé           Γöé
  22557. Γöé       Γöé conversions speci-  Γöé           Γöé           Γöé
  22558. Γöé       Γöé fied by the ANSI   Γöé           Γöé           Γöé
  22559. Γöé       Γöé standards, the    Γöé           Γöé           Γöé
  22560. Γöé       Γöé results obtained   Γöé           Γöé           Γöé
  22561. Γöé       Γöé may differ from   Γöé           Γöé           Γöé
  22562. Γöé       Γöé results obtained   Γöé           Γöé           Γöé
  22563. Γöé       Γöé using ANSI methods, Γöé           Γöé           Γöé
  22564. Γöé       Γöé but are often more  Γöé           Γöé           Γöé
  22565. Γöé       Γöé precise.       Γöé           Γöé           Γöé
  22566. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22567. Γöé "/Gh[+|-]"  Γöé Generate code    Γöé "/Gh-"        Γöé "/Gh[+]"      Γöé
  22568. Γöé       Γöé enabled for EXTRA  Γöé Do not enable code  Γöé Enable code to be  Γöé
  22569. Γöé       Γöé and other profiling Γöé for EXTRA.      Γöé run by EXTRA and  Γöé
  22570. Γöé       Γöé tools.        Γöé           Γöé other profiling   Γöé
  22571. Γöé       Γöé           Γöé           Γöé tools by generated Γöé
  22572. Γöé       Γöé           Γöé           Γöé profiler hooks in  Γöé
  22573. Γöé       Γöé           Γöé           Γöé function prologs.  Γöé
  22574. Γöé       Γöé           Γöé           Γöé           Γöé
  22575. Γöé       Γöé           Γöé           Γöé NOTE:  To enable  Γöé
  22576. Γöé       Γöé           Γöé           Γöé code for EXTRA,   Γöé
  22577. Γöé       Γöé           Γöé           Γöé you must also    Γöé
  22578. Γöé       Γöé           Γöé           Γöé specify "/Ti".   Γöé
  22579. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  22580. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  22581. Γöé      Code Generation Options                       Γöé
  22582. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22583. Γöé OPTION    Γöé DESCRIPTION     Γöé DEFAULT       Γöé CHANGING DEFAULT  Γöé
  22584. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22585. Γöé "/Gi[+|-]"  Γöé Specify fast     Γöé "/Gi-"        Γöé "/Gi[+]"      Γöé
  22586. Γöé       Γöé integer execution.  Γöé Do not use fast   Γöé Use fast integer  Γöé
  22587. Γöé       Γöé           Γöé integer execution.  Γöé execution.     Γöé
  22588. Γöé       Γöé If you are shifting Γöé           Γöé           Γöé
  22589. Γöé       Γöé bits by a variable  Γöé           Γöé           Γöé
  22590. Γöé       Γöé amount, you can use Γöé           Γöé           Γöé
  22591. Γöé       Γöé fast integer exe-  Γöé           Γöé           Γöé
  22592. Γöé       Γöé cution to ensure   Γöé           Γöé           Γöé
  22593. Γöé       Γöé that for values   Γöé           Γöé           Γöé
  22594. Γöé       Γöé greater than 31,   Γöé           Γöé           Γöé
  22595. Γöé       Γöé the bits are     Γöé           Γöé           Γöé
  22596. Γöé       Γöé shifted by the    Γöé           Γöé           Γöé
  22597. Γöé       Γöé result of a modulo  Γöé           Γöé           Γöé
  22598. Γöé       Γöé 32 of the value.   Γöé           Γöé           Γöé
  22599. Γöé       Γöé Otherwise, the    Γöé           Γöé           Γöé
  22600. Γöé       Γöé result of the shift Γöé           Γöé           Γöé
  22601. Γöé       Γöé is 0.        Γöé           Γöé           Γöé
  22602. Γöé       Γöé           Γöé           Γöé           Γöé
  22603. Γöé       Γöé NOTE:  If your    Γöé           Γöé           Γöé
  22604. Γöé       Γöé shift value is a   Γöé           Γöé           Γöé
  22605. Γöé       Γöé constant greater   Γöé           Γöé           Γöé
  22606. Γöé       Γöé than 32, the result Γöé           Γöé           Γöé
  22607. Γöé       Γöé will always be 0.  Γöé           Γöé           Γöé
  22608. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22609. Γöé "/Gm[+|-]"  Γöé Choose single or   Γöé "/Gm-"        Γöé "/Gm[+]"      Γöé
  22610. Γöé       Γöé multithread     Γöé Link with the    Γöé Link with the    Γöé
  22611. Γöé       Γöé libraries.      Γöé single-thread    Γöé multithread     Γöé
  22612. Γöé       Γöé           Γöé version of the    Γöé version of the   Γöé
  22613. Γöé       Γöé           Γöé library (no multi-  Γöé library.      Γöé
  22614. Γöé       Γöé           Γöé thread capabili-   Γöé           Γöé
  22615. Γöé       Γöé           Γöé ties).        Γöé           Γöé
  22616. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22617. Γöé "/Gn[+|-]"  Γöé Control generation  Γöé "/Gn-"        Γöé "/Gn[+]"      Γöé
  22618. Γöé       Γöé of default library  Γöé Provide linker    Γöé Do not provide   Γöé
  22619. Γöé       Γöé information in    Γöé information about  Γöé linker information Γöé
  22620. Γöé       Γöé object.       Γöé the default     Γöé about default    Γöé
  22621. Γöé       Γöé           Γöé libraries according Γöé libraries.  All   Γöé
  22622. Γöé       Γöé           Γöé to other "/G"    Γöé libraries must be  Γöé
  22623. Γöé       Γöé           Γöé options.       Γöé explicitly speci-  Γöé
  22624. Γöé       Γöé           Γöé           Γöé fied at link time. Γöé
  22625. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22626. Γöé "/Gr[+|-]"  Γöé Generate object   Γöé "/Gr-"        Γöé "/Gr[+]"      Γöé
  22627. Γöé       Γöé code that runs at  Γöé Do not allow object Γöé Allow object code  Γöé
  22628. Γöé       Γöé ring 0.  Use this  Γöé code to run at ring Γöé to run at ring 0.  Γöé
  22629. Γöé       Γöé option if you are  Γöé 0.          Γöé           Γöé
  22630. Γöé       Γöé writing code, such  Γöé           Γöé           Γöé
  22631. Γöé       Γöé as device drivers  Γöé           Γöé           Γöé
  22632. Γöé       Γöé or operating     Γöé           Γöé           Γöé
  22633. Γöé       Γöé systems, that will  Γöé           Γöé           Γöé
  22634. Γöé       Γöé run at ring 0    Γöé           Γöé           Γöé
  22635. Γöé       Γöé instead of ring 3.  Γöé           Γöé           Γöé
  22636. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22637. Γöé "/Gs[+|-]"  Γöé Remove stack probes Γöé "/Gs-"        Γöé "/Gs[+]"      Γöé
  22638. Γöé       Γöé from the generated  Γöé Do not remove stack Γöé Remove stack    Γöé
  22639. Γöé       Γöé code.        Γöé probes.       Γöé probes.       Γöé
  22640. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22641. Γöé "/Gt[+|-]"  Γöé Enable tiled memory Γöé "/Gt-"        Γöé "/Gt[+]"      Γöé
  22642. Γöé       Γöé and store variables Γöé Do not enable vari- Γöé Enable all vari-  Γöé
  22643. Γöé       Γöé such that they may  Γöé ables to be passed  Γöé ables to be passed Γöé
  22644. Γöé       Γöé be passed to 16-bit Γöé to 16-bit func-   Γöé to 16-bit func-   Γöé
  22645. Γöé       Γöé functions.      Γöé tions.        Γöé tions.  Static and Γöé
  22646. Γöé       Γöé           Γöé           Γöé external variables Γöé
  22647. Γöé       Γöé           Γöé           Γöé are mapped into   Γöé
  22648. Γöé       Γöé           Γöé           Γöé 16-bit segments.  Γöé
  22649. Γöé       Γöé           Γöé           Γöé Variables larger  Γöé
  22650. Γöé       Γöé           Γöé           Γöé than 64K will be  Γöé
  22651. Γöé       Γöé           Γöé           Γöé aligned on, but   Γöé
  22652. Γöé       Γöé           Γöé           Γöé will still cross,  Γöé
  22653. Γöé       Γöé           Γöé           Γöé 64K boundaries.   Γöé
  22654. Γöé       Γöé           Γöé           Γöé When this option  Γöé
  22655. Γöé       Γöé           Γöé           Γöé is specified, the  Γöé
  22656. Γöé       Γöé           Γöé           Γöé memory management  Γöé
  22657. Γöé       Γöé           Γöé           Γöé functions "calloc, Γöé
  22658. Γöé       Γöé           Γöé           Γöé free, malloc," and Γöé
  22659. Γöé       Γöé           Γöé           Γöé "realloc" are    Γöé
  22660. Γöé       Γöé           Γöé           Γöé mapped to the    Γöé
  22661. Γöé       Γöé           Γöé           Γöé tiled versions   Γöé
  22662. Γöé       Γöé           Γöé           Γöé "_tcalloc, _tfree, Γöé
  22663. Γöé       Γöé           Γöé           Γöé _tmalloc", and   Γöé
  22664. Γöé       Γöé           Γöé           Γöé "_trealloc".    Γöé
  22665. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  22666. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  22667. Γöé      Code Generation Options                       Γöé
  22668. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22669. Γöé OPTION    Γöé DESCRIPTION     Γöé DEFAULT       Γöé CHANGING DEFAULT  Γöé
  22670. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22671. Γöé "/Gu[+|-]"  Γöé Tell intermediate  Γöé "/Gu-"        Γöé "/Gu[+]"      Γöé
  22672. Γöé       Γöé linker whether    Γöé External functions  Γöé The data is used  Γöé
  22673. Γöé       Γöé external functions  Γöé may use data     Γöé only within the   Γöé
  22674. Γöé       Γöé use data defined in Γöé defined in the    Γöé intermediate files Γöé
  22675. Γöé       Γöé the intermediate   Γöé intermediate files  Γöé being linked, with Γöé
  22676. Γöé       Γöé link.        Γöé being linked.    Γöé the exception of  Γöé
  22677. Γöé       Γöé           Γöé           Γöé data that is    Γöé
  22678. Γöé       Γöé           Γöé           Γöé exported using   Γöé
  22679. Γöé       Γöé           Γöé           Γöé "_Export",     Γöé
  22680. Γöé       Γöé           Γöé           Γöé "#pragma export",  Γöé
  22681. Γöé       Γöé           Γöé           Γöé or a ".DEF" file.  Γöé
  22682. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22683. Γöé "/Gv[+|-]"  Γöé Control handling of Γöé "/Gv-"        Γöé "/Gv[+]"      Γöé
  22684. Γöé       Γöé DS and ES registers Γöé Do not perform any  Γöé Save the DS and ES Γöé
  22685. Γöé       Γöé for virtual device  Γöé special handling of Γöé registers on entry Γöé
  22686. Γöé       Γöé driver development. Γöé the DS and ES reg-  Γöé to an external   Γöé
  22687. Γöé       Γöé           Γöé isters.       Γöé function, set them Γöé
  22688. Γöé       Γöé NOTE:  This option Γöé           Γöé to the selector   Γöé
  22689. Γöé       Γöé is valid for C    Γöé           Γöé for DGROUP, then  Γöé
  22690. Γöé       Γöé files only.     Γöé           Γöé restore them on   Γöé
  22691. Γöé       Γöé Virtual device    Γöé           Γöé exit from the    Γöé
  22692. Γöé       Γöé driver development  Γöé           Γöé function.      Γöé
  22693. Γöé       Γöé is not supported   Γöé           Γöé           Γöé
  22694. Γöé       Γöé for C++ programs.  Γöé           Γöé           Γöé
  22695. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22696. Γöé "/Gw[+|-]"  Γöé Control generation  Γöé "/Gw-"        Γöé "/Gw[+]"      Γöé
  22697. Γöé       Γöé of "FWAIT" instruc- Γöé Do not generate   Γöé Generate "FWAIT"  Γöé
  22698. Γöé       Γöé tion after each   Γöé "FWAIT" instruction Γöé instruction after  Γöé
  22699. Γöé       Γöé floating-point load Γöé after each      Γöé each floating-   Γöé
  22700. Γöé       Γöé instruction.     Γöé floating-point load Γöé point load     Γöé
  22701. Γöé       Γöé           Γöé instruction.     Γöé instruction.  This Γöé
  22702. Γöé       Γöé           Γöé           Γöé allows the program Γöé
  22703. Γöé       Γöé           Γöé           Γöé to take a      Γöé
  22704. Γöé       Γöé           Γöé           Γöé floating-point   Γöé
  22705. Γöé       Γöé           Γöé           Γöé stack overflow   Γöé
  22706. Γöé       Γöé           Γöé           Γöé exception imme-   Γöé
  22707. Γöé       Γöé           Γöé           Γöé diately after the  Γöé
  22708. Γöé       Γöé           Γöé           Γöé load instruction  Γöé
  22709. Γöé       Γöé           Γöé           Γöé that caused it.   Γöé
  22710. Γöé       Γöé           Γöé           Γöé           Γöé
  22711. Γöé       Γöé           Γöé           Γöé NOTE:  This    Γöé
  22712. Γöé       Γöé           Γöé           Γöé option is not    Γöé
  22713. Γöé       Γöé           Γöé           Γöé recommended     Γöé
  22714. Γöé       Γöé           Γöé           Γöé because it     Γöé
  22715. Γöé       Γöé           Γöé           Γöé increases the size Γöé
  22716. Γöé       Γöé           Γöé           Γöé of your executable Γöé
  22717. Γöé       Γöé           Γöé           Γöé file and greatly  Γöé
  22718. Γöé       Γöé           Γöé           Γöé decreases its per- Γöé
  22719. Γöé       Γöé           Γöé           Γöé formance.  You do  Γöé
  22720. Γöé       Γöé           Γöé           Γöé not need this    Γöé
  22721. Γöé       Γöé           Γöé           Γöé option unless you  Γöé
  22722. Γöé       Γöé           Γöé           Γöé call assembler   Γöé
  22723. Γöé       Γöé           Γöé           Γöé code that leaves a Γöé
  22724. Γöé       Γöé           Γöé           Γöé different number  Γöé
  22725. Γöé       Γöé           Γöé           Γöé of values on the  Γöé
  22726. Γöé       Γöé           Γöé           Γöé floating point   Γöé
  22727. Γöé       Γöé           Γöé           Γöé stack.       Γöé
  22728. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22729. Γöé "/Gx[+|-]"  Γöé Controls removal of Γöé "/Gx-"        Γöé "/Gx[+]"      Γöé
  22730. Γöé       Γöé C++ exception han-  Γöé Do not remove C++  Γöé Remove C++ excep-  Γöé
  22731. Γöé       Γöé dling information.  Γöé exception handling  Γöé tion handling    Γöé
  22732. Γöé       Γöé           Γöé information.     Γöé information.    Γöé
  22733. Γöé       Γöé NOTE:  This option  Γöé           Γöé           Γöé
  22734. Γöé       Γöé is valid for C++   Γöé           Γöé           Γöé
  22735. Γöé       Γöé files only.     Γöé           Γöé           Γöé
  22736. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  22737. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  22738. Γöé      Code Generation Options                       Γöé
  22739. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22740. Γöé OPTION    Γöé DESCRIPTION     Γöé DEFAULT       Γöé CHANGING DEFAULT  Γöé
  22741. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22742. Γöé "/G[3|4|5]" Γöé Specify type of   Γöé "/G3"        Γöé "/G4"        Γöé
  22743. Γöé       Γöé processor.      Γöé Optimize code for  Γöé Optimize code for  Γöé
  22744. Γöé       Γöé           Γöé use with a 386    Γöé use with a 486   Γöé
  22745. Γöé       Γöé           Γöé processor.  The   Γöé processor.  The   Γöé
  22746. Γöé       Γöé           Γöé code will run on a  Γöé code will run on a Γöé
  22747. Γöé       Γöé           Γöé 486 or Pentium    Γöé 386 or Pentium   Γöé
  22748. Γöé       Γöé           Γöé microprocessor.   Γöé microprocessor.   Γöé
  22749. Γöé       Γöé           Γöé The compiler     Γöé The compiler    Γöé
  22750. Γöé       Γöé           Γöé includes any 486 or Γöé includes any    Γöé
  22751. Γöé       Γöé           Γöé Pentium micro-    Γöé Pentium micro-   Γöé
  22752. Γöé       Γöé           Γöé processor optimiza- Γöé processor opti-   Γöé
  22753. Γöé       Γöé           Γöé tions that do not  Γöé mizations that do  Γöé
  22754. Γöé       Γöé           Γöé detract from the   Γöé not detract from  Γöé
  22755. Γöé       Γöé           Γöé performance on the  Γöé the performance on Γöé
  22756. Γöé       Γöé           Γöé 386 processor.  If  Γöé the 486 processor. Γöé
  22757. Γöé       Γöé           Γöé you do not know   Γöé           Γöé
  22758. Γöé       Γöé           Γöé what processor your Γöé "/G5"        Γöé
  22759. Γöé       Γöé           Γöé application will be Γöé Optimize code for  Γöé
  22760. Γöé       Γöé           Γöé run on, use this   Γöé use with a Pentium Γöé
  22761. Γöé       Γöé           Γöé option.       Γöé Microprocessor.   Γöé
  22762. Γöé       Γöé           Γöé           Γöé The code will run  Γöé
  22763. Γöé       Γöé           Γöé           Γöé on a 386 or 486   Γöé
  22764. Γöé       Γöé           Γöé           Γöé processor.     Γöé
  22765. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22766. Γöé "/M[p|s]"  Γöé Set calling conven- Γöé "/Mp"        Γöé "/Ms"        Γöé
  22767. Γöé       Γöé tion.        Γöé Use _Optlink     Γöé Use _System     Γöé
  22768. Γöé       Γöé           Γöé linkage for func-  Γöé linkage for func-  Γöé
  22769. Γöé       Γöé           Γöé tions.  You must   Γöé tions.  You must  Γöé
  22770. Γöé       Γöé           Γöé include the Toolkit Γöé include the     Γöé
  22771. Γöé       Γöé           Γöé header files to   Γöé C/C++ Tools     Γöé
  22772. Γöé       Γöé           Γöé call OS/2 APIs.   Γöé library header   Γöé
  22773. Γöé       Γöé           Γöé           Γöé files to call    Γöé
  22774. Γöé       Γöé           Γöé           Γöé C/C++ Tools func-  Γöé
  22775. Γöé       Γöé           Γöé           Γöé tions.       Γöé
  22776. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22777. Γöé "/Ndname"  Γöé Specify names of   Γöé Use the default   Γöé "/Ndname"      Γöé
  22778. Γöé       Γöé default data and   Γöé names DATA32 and   Γöé Use the names    Γöé
  22779. Γöé       Γöé constant segments.  Γöé CONST32.       Γöé nameDATA32 and   Γöé
  22780. Γöé       Γöé           Γöé           Γöé nameCONST32.  You  Γöé
  22781. Γöé       Γöé           Γöé           Γöé can then give the  Γöé
  22782. Γöé       Γöé           Γöé           Γöé segments special  Γöé
  22783. Γöé       Γöé           Γöé           Γöé attributes.  The  Γöé
  22784. Γöé       Γöé           Γöé           Γöé renamed segments  Γöé
  22785. Γöé       Γöé           Γöé           Γöé are not placed in  Γöé
  22786. Γöé       Γöé           Γöé           Γöé the default data  Γöé
  22787. Γöé       Γöé           Γöé           Γöé group.       Γöé
  22788. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22789. Γöé "/Ntname"  Γöé Specify name of   Γöé Use the default   Γöé "/Ntname"      Γöé
  22790. Γöé       Γöé default code or   Γöé name CODE32.     Γöé Use the name    Γöé
  22791. Γöé       Γöé text segment.    Γöé           Γöé nameCODE32.  You  Γöé
  22792. Γöé       Γöé           Γöé           Γöé can then give the  Γöé
  22793. Γöé       Γöé           Γöé           Γöé segment special   Γöé
  22794. Γöé       Γöé           Γöé           Γöé attributes.     Γöé
  22795. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22796. Γöé "/O[+|-]"  Γöé Control optimiza-  Γöé "/O-"        Γöé "/O[+]"       Γöé
  22797. Γöé       Γöé tion.        Γöé Do not optimize   Γöé Optimize code.   Γöé
  22798. Γöé       Γöé           Γöé code.        Γöé           Γöé
  22799. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22800. Γöé "/Oi[+|-|]" Γöé Control inlining of Γöé "/Oi-"        Γöé "/Oi[+]"      Γöé
  22801. Γöé       Γöé user code.      Γöé Do not inline any  Γöé Inline all user   Γöé
  22802. Γöé "/Oivalue"  Γöé           Γöé user code.      Γöé functions quali-  Γöé
  22803. Γöé       Γöé           Γöé           Γöé fied with the    Γöé
  22804. Γöé       Γöé           Γöé NOTE:  When "/O+"  Γöé "_Inline" or    Γöé
  22805. Γöé       Γöé           Γöé is specified,    Γöé "inline" keyword.  Γöé
  22806. Γöé       Γöé           Γöé "/Oi+" becomes the  Γöé           Γöé
  22807. Γöé       Γöé           Γöé default.       Γöé "/Oivalue"     Γöé
  22808. Γöé       Γöé           Γöé           Γöé Inline all user   Γöé
  22809. Γöé       Γöé           Γöé           Γöé functions quali-  Γöé
  22810. Γöé       Γöé           Γöé           Γöé fied with the    Γöé
  22811. Γöé       Γöé           Γöé           Γöé "_Inline" or    Γöé
  22812. Γöé       Γöé           Γöé           Γöé "inline" keyword  Γöé
  22813. Γöé       Γöé           Γöé           Γöé or that are     Γöé
  22814. Γöé       Γöé           Γöé           Γöé smaller than value Γöé
  22815. Γöé       Γöé           Γöé           Γöé in abstract code  Γöé
  22816. Γöé       Γöé           Γöé           Γöé units.       Γöé
  22817. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22818. Γöé "/Ol[+|-]"  Γöé Control use of    Γöé "/Ol-"        Γöé "/Ol[+]"      Γöé
  22819. Γöé       Γöé intermediate code  Γöé Do not pass code   Γöé Pass code through  Γöé
  22820. Γöé       Γöé linker.       Γöé through the inter-  Γöé the intermediate  Γöé
  22821. Γöé       Γöé           Γöé mediate linker.   Γöé linker before gen- Γöé
  22822. Γöé       Γöé           Γöé           Γöé erating an object  Γöé
  22823. Γöé       Γöé           Γöé           Γöé file.        Γöé
  22824. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  22825. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  22826. Γöé      Code Generation Options                       Γöé
  22827. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22828. Γöé OPTION    Γöé DESCRIPTION     Γöé DEFAULT       Γöé CHANGING DEFAULT  Γöé
  22829. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22830. Γöé "/Om[+|-]"  Γöé Control size of   Γöé "/Om-"        Γöé "/Om[+]"      Γöé
  22831. Γöé       Γöé working set for   Γöé Do not limit     Γöé Limit working set  Γöé
  22832. Γöé       Γöé compiler.  The com- Γöé working set size.  Γöé size to approxi-  Γöé
  22833. Γöé       Γöé piler may use a   Γöé           Γöé mately 35M.     Γöé
  22834. Γöé       Γöé large amount of   Γöé           Γöé           Γöé
  22835. Γöé       Γöé memory when     Γöé           Γöé NOTE:  Because   Γöé
  22836. Γöé       Γöé inlining user code, Γöé           Γöé this option may   Γöé
  22837. Γöé       Γöé especially when   Γöé           Γöé cause the compiler Γöé
  22838. Γöé       Γöé performing auto-   Γöé           Γöé to disregard some  Γöé
  22839. Γöé       Γöé matic inlining at  Γöé           Γöé inlining opportu-  Γöé
  22840. Γöé       Γöé large thresholds   Γöé           Γöé nities, code gen-  Γöé
  22841. Γöé       Γöé ("/Oi50" and     Γöé           Γöé erated with "/Om-" Γöé
  22842. Γöé       Γöé higher).       Γöé           Γöé may be more effi-  Γöé
  22843. Γöé       Γöé           Γöé           Γöé cient.       Γöé
  22844. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22845. Γöé "/Op[+|-]"  Γöé Control disabling  Γöé "/Op+"        Γöé "/Op-"       Γöé
  22846. Γöé       Γöé of optimizations   Γöé Perform optimiza-  Γöé Do not perform   Γöé
  22847. Γöé       Γöé involving the stack Γöé tions involving the Γöé optimizations that Γöé
  22848. Γöé       Γöé pointer.       Γöé stack pointer.    Γöé involve the stack  Γöé
  22849. Γöé       Γöé           Γöé           Γöé pointer.  Code   Γöé
  22850. Γöé       Γöé           Γöé           Γöé that directly    Γöé
  22851. Γöé       Γöé           Γöé           Γöé manipulates the   Γöé
  22852. Γöé       Γöé           Γöé           Γöé stack pointer    Γöé
  22853. Γöé       Γöé           Γöé           Γöé should be compiled Γöé
  22854. Γöé       Γöé           Γöé           Γöé with this option.  Γöé
  22855. Γöé       Γöé           Γöé           Γöé This option is not Γöé
  22856. Γöé       Γöé           Γöé           Γöé recommended     Γöé
  22857. Γöé       Γöé           Γöé           Γöé because it     Γöé
  22858. Γöé       Γöé           Γöé           Γöé decreases the per- Γöé
  22859. Γöé       Γöé           Γöé           Γöé formance of your  Γöé
  22860. Γöé       Γöé           Γöé           Γöé executable file.  Γöé
  22861. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22862. Γöé "/Os[+|-]"  Γöé Control use of    Γöé "/Os-"        Γöé "/Os+"       Γöé
  22863. Γöé       Γöé instruction sched-  Γöé Do not invoke the  Γöé Invoke the     Γöé
  22864. Γöé       Γöé uler.        Γöé instruction sched-  Γöé instruction sched- Γöé
  22865. Γöé       Γöé           Γöé uler.        Γöé uler.        Γöé
  22866. Γöé       Γöé           Γöé           Γöé           Γöé
  22867. Γöé       Γöé           Γöé NOTE:  When "/O+"  Γöé NOTE:  You cannot  Γöé
  22868. Γöé       Γöé           Γöé is specified,    Γöé specify "/Os+" and Γöé
  22869. Γöé       Γöé           Γöé "/Os+" becomes the  Γöé "/O-".       Γöé
  22870. Γöé       Γöé           Γöé default.       Γöé           Γöé
  22871. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22872. Γöé "/R[e|n]"  Γöé Control executable  Γöé "/Re"        Γöé "/Rn"        Γöé
  22873. Γöé       Γöé runtime environ-   Γöé Generate executable Γöé Generate execut-  Γöé
  22874. Γöé       Γöé ment.        Γöé code that runs in a Γöé able code that can Γöé
  22875. Γöé       Γöé           Γöé C/C++ Tools runtime Γöé be used as a sub-  Γöé
  22876. Γöé       Γöé           Γöé environment.     Γöé system without a  Γöé
  22877. Γöé       Γöé           Γöé           Γöé runtime environ-  Γöé
  22878. Γöé       Γöé           Γöé           Γöé ment.        Γöé
  22879. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  22880.  
  22881. Additional information is available on Using the /Ge Option. 
  22882.  
  22883. Related Information 
  22884.  
  22885. o Linkage Keywords 
  22886. o #pragma linkage 
  22887. o Specifying Compiler Options 
  22888.  
  22889.  
  22890. ΓòÉΓòÉΓòÉ 18.9.1. Using the /Ge Option ΓòÉΓòÉΓòÉ
  22891.  
  22892. The C/C++ Tools libraries provide two initialization routines, one for 
  22893. executable modules and one for DLLs. For each object file, the compiler must 
  22894. include a reference to the appropriate initialization routine. The name of this 
  22895. routine is then passed to the linker when the file is linked. Use the /Ge 
  22896. option at compile time to tell the compiler which routine to reference. 
  22897.  
  22898. The /Ge- option causes the compiler to generate a reference to _dllentry for 
  22899. every module compiled. The /Ge+ option generates a reference to _exeentry only 
  22900. if a main function is found in the source.  If no main function is included, no 
  22901. linking reference is generated. 
  22902.  
  22903. If you want to create a library of objects that can be linked into either an 
  22904. executable file or a DLL, use the /Ge+ option when you compile.  Typically, 
  22905. none of these objects would contain a reference to main. 
  22906.  
  22907. If one of the objects did contain a reference to main, you can override the /Ge 
  22908. option when you link your files.  Create a source file that defines the routine 
  22909. already referenced in your object file. In the same file, add a dummy statement 
  22910. that references the correct initialization routine. Then compile this file and 
  22911. link it with your other object files. For example, if you compiled kim.obj 
  22912. using the /Ge+ option, but want to link it to create a DLL, your extra source 
  22913. file would contain statements like the following: 
  22914.  
  22915. int _exeentry = 1;
  22916. extern int _dllentry;
  22917.  
  22918. int main(void)
  22919. {
  22920.    int x;
  22921.  
  22922.    .
  22923.    .
  22924.    .
  22925.    x = _dllentry;
  22926.  
  22927.    .
  22928.    .
  22929.    .
  22930. }
  22931.  
  22932. The reference to _exeentry in kim.obj is resolved by this file, and this file's 
  22933. reference to _dllentry causes the linker to link in the correct initialization 
  22934. routine. 
  22935.  
  22936.  
  22937. ΓòÉΓòÉΓòÉ 18.10. Other Options ΓòÉΓòÉΓòÉ
  22938.  
  22939. Use these options to control linker parameters, logo display, default char 
  22940. type, and other C/C++ Tools options. 
  22941.  
  22942. ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  22943. Γöé      Other Options                            Γöé
  22944. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22945. Γöé OPTION    Γöé DESCRIPTION     Γöé DEFAULT       Γöé CHANGING DEFAULT  Γöé
  22946. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22947. Γöé "/B"options""Γöé Specify parameters Γöé "/B"""        Γöé "/B"options""    Γöé
  22948. Γöé        Γöé to be passed to   Γöé Pass only the icc  Γöé Pass options    Γöé
  22949. Γöé        Γöé linker.       Γöé default parameters  Γöé string to the    Γöé
  22950. Γöé        Γöé           Γöé to the linker.  See Γöé linker as parame-  Γöé
  22951. Γöé        Γöé See the Toolkit   Γöé "Finishing Your   Γöé ters.  The icc   Γöé
  22952. Γöé        Γöé Tools Reference   Γöé Program" in the   Γöé default parameters Γöé
  22953. Γöé        Γöé for information   Γöé Programming Guide  Γöé are also passed.  Γöé
  22954. Γöé        Γöé about the options  Γöé for a description  Γöé           Γöé
  22955. Γöé        Γöé you can pass to   Γöé of the options    Γöé           Γöé
  22956. Γöé        Γöé the LINK386     Γöé passed to the    Γöé           Γöé
  22957. Γöé        Γöé linker.       Γöé linker by default.  Γöé           Γöé
  22958. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22959. Γöé "/C[+|-]"   Γöé Perform compile   Γöé "/C-"        Γöé "/C[+]"       Γöé
  22960. Γöé        Γöé only, or perform  Γöé Perform compile and Γöé Perform compile   Γöé
  22961. Γöé        Γöé compile and link.  Γöé invoke linker.    Γöé only, no link.   Γöé
  22962. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22963. Γöé "/Hnum"    Γöé Set significant   Γöé "/H255"       Γöé "/H"num       Γöé
  22964. Γöé        Γöé length of external Γöé Set the first 255  Γöé Set the first num  Γöé
  22965. Γöé        Γöé names.       Γöé characters of    Γöé characters of    Γöé
  22966. Γöé        Γöé           Γöé external names to  Γöé external names to  Γöé
  22967. Γöé        Γöé           Γöé be significant.   Γöé be significant.   Γöé
  22968. Γöé        Γöé           Γöé           Γöé The value of num  Γöé
  22969. Γöé        Γöé           Γöé           Γöé must be between 6  Γöé
  22970. Γöé        Γöé           Γöé           Γöé and 255 inclusive. Γöé
  22971. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22972. Γöé "/J[+|-]"   Γöé Set default "char" Γöé "/J[+]"       Γöé "/J-"        Γöé
  22973. Γöé        Γöé type.        Γöé Set unspecified   Γöé Set unspecified   Γöé
  22974. Γöé        Γöé           Γöé "char" variables to Γöé "char" variables  Γöé
  22975. Γöé        Γöé           Γöé "unsigned char".   Γöé to "signed char".  Γöé
  22976. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22977. Γöé "/Q[+|-]"   Γöé Display compiler  Γöé "/Q-"        Γöé "/Q[+]"       Γöé
  22978. Γöé        Γöé logo when invoking Γöé Display logo on   Γöé Do not display   Γöé
  22979. Γöé        Γöé compiler.      Γöé "stderr".      Γöé logo.        Γöé
  22980. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  22981. Γöé "/Tl[+|-|valuΓöé]Control preloading Γöé "/Tl[+]"       Γöé "/Tlvalue"     Γöé
  22982. Γöé        Γöé of the compiler.  Γöé Preload the com-   Γöé Preload the com-  Γöé
  22983. Γöé        Γöé           Γöé piler components as Γöé piler components  Γöé
  22984. Γöé        Γöé           Γöé required.  A compo- Γöé as required and   Γöé
  22985. Γöé        Γöé           Γöé nent remains in   Γöé keep the files in  Γöé
  22986. Γöé        Γöé           Γöé memory for 10    Γöé memory for value  Γöé
  22987. Γöé        Γöé           Γöé minutes.  If it is  Γöé minutes.      Γöé
  22988. Γöé        Γöé           Γöé referenced in that  Γöé           Γöé
  22989. Γöé        Γöé           Γöé time, the timer   Γöé "/Tl-"       Γöé
  22990. Γöé        Γöé           Γöé starts again.  Each Γöé Do not preload the Γöé
  22991. Γöé        Γöé           Γöé compiler component  Γöé compiler.  You can Γöé
  22992. Γöé        Γöé           Γöé has its own timer.  Γöé specify this    Γöé
  22993. Γöé        Γöé           Γöé           Γöé option without a  Γöé
  22994. Γöé        Γöé           Γöé NOTE:  This option Γöé file name to    Γöé
  22995. Γöé        Γöé           Γöé is not available if Γöé unload any compo-  Γöé
  22996. Γöé        Γöé           Γöé you are using the  Γöé nents that are   Γöé
  22997. Γöé        Γöé           Γöé OS/2 2.0 operating  Γöé loaded.       Γöé
  22998. Γöé        Γöé           Γöé system without the  Γöé           Γöé
  22999. Γöé        Γöé           Γöé Service Pack.    Γöé           Γöé
  23000. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  23001. Γöé "/V"string"" Γöé Include a version  Γöé "/V"""        Γöé "/V"string""    Γöé
  23002. Γöé        Γöé string in the    Γöé Set no version    Γöé Set version string Γöé
  23003. Γöé        Γöé object and execut- Γöé string.       Γöé to string.  The   Γöé
  23004. Γöé        Γöé able files.     Γöé           Γöé length of the    Γöé
  23005. Γöé        Γöé           Γöé           Γöé string can be up  Γöé
  23006. Γöé        Γöé           Γöé           Γöé to 256 characters. Γöé
  23007. Γö£ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö╝ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöñ
  23008. Γöé "?"      Γöé Display list of   Γöé (none)        Γöé "?"         Γöé
  23009. Γöé        Γöé compiler options  Γöé           Γöé Display list of   Γöé
  23010. Γöé        Γöé with descriptions. Γöé           Γöé compiler options  Γöé
  23011. Γöé        Γöé           Γöé           Γöé with descriptions. Γöé
  23012. ΓööΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÿ
  23013.  
  23014. Examples of Other Options 
  23015.  
  23016. Related Information 
  23017.  
  23018. o #pragma chars 
  23019. o Specifying Compiler Options 
  23020.  
  23021.  
  23022. ΓòÉΓòÉΓòÉ <hidden> Examples of Other Options ΓòÉΓòÉΓòÉ
  23023.  
  23024. o Passing a parameter to the linker: 
  23025.  
  23026.        icc /B"/NOI" fred.c
  23027.  
  23028.   The /NOI option tells the linker to preserve the case of external names in 
  23029.   fred.obj. 
  23030.  
  23031. o Imbedding a version string or copyright: 
  23032.  
  23033.        icc /V"Version 1.0" fred.c
  23034.  
  23035.   This imbeds the version notice in fred.obj. 
  23036.  
  23037.  
  23038. ΓòÉΓòÉΓòÉ 19. Compiler Messages and Return Codes ΓòÉΓòÉΓòÉ
  23039.  
  23040. These panels contain information about the compile-time messages and should not 
  23041. be used as programming interface information. 
  23042.  
  23043. For every compilation job or job step, the compiler generates a return code 
  23044. that indicates to the operating system the degree of success or failure it 
  23045. achieved. The meanings of the return codes are: 
  23046.  
  23047. Code    Meaning 
  23048. 0       No error detected; compilation completed; successful execution 
  23049.         anticipated. 
  23050.  
  23051.                   OR
  23052.  
  23053.         Possible error (warning) detected; compilation completed; successful 
  23054.         execution probable. 
  23055. 12      Error detected; compilation may have been completed; successful 
  23056.         execution impossible. 
  23057. 16      Severe error detected; compilation terminated abnormally; successful 
  23058.         execution impossible. 
  23059. 20      Fatal error detected; compilation terminated abnormally and abruptly; 
  23060.         successful execution impossible. 
  23061.  
  23062. The compiler message format is: 
  23063.  
  23064.   filename.ext(line:col): ss EDCnnnn: text
  23065.  
  23066. where: 
  23067.  
  23068.   filename.ext - file name (with extension) where the error occurred
  23069.   line - line where the error occurred
  23070.   col - column where the error occurred
  23071.   ss - error severity:
  23072.         00 - informational
  23073.         10 - warning
  23074.         30 - error
  23075.         40 - severe error
  23076.         50 - fatal error
  23077.   nnnn - error message number
  23078.   text - message text, which may contain substitution
  23079.        text indicated by &n
  23080.  
  23081. The message text is prefixed with the severity string (for example, warning), 
  23082. not with the severity number. 
  23083.  
  23084. Message numbers in the range of 0001 to 2999 are generated for C code. Message 
  23085. numbers in the range of 3000 to 3999 are generated for C++ code.  Message 
  23086. numbers in the 4000 range are generated for both C and C++ code. 
  23087.  
  23088. Messages other than those in the 4000 range are prefixed with the name of the 
  23089. file and the line and column number where the message was generated. 
  23090.  
  23091. For messages in the 4000 range, the file name and line number where the error 
  23092. occurred follow the message text. The severity of errors for these messages is 
  23093. determined dynamically as the error occurs. If the error is unrecognized by the 
  23094. compiler, it is prefaced by unknown error. If one of these messages is 
  23095. generated, contact your IBM Service representative. 
  23096.  
  23097. There are four messages that are generated if the message files cannot be 
  23098. accessed.  They are: 
  23099.  
  23100. o Cannot find the message. 
  23101. o Cannot access the message file. 
  23102. o The message file format is not valid. 
  23103. o Cannot find the message file. 
  23104.  
  23105. If one of these messages is generated, ensure that 
  23106.  
  23107. o The DPATH variable is set in your CONFIG.SYS file 
  23108. o The message files are in a directory in the DPATH 
  23109. o The DPATH allows read access to the directories specified 
  23110. o The file system is functioning properly 
  23111. o The message files are not corrupted. 
  23112.  
  23113. Reinstall the message files if any have been corrupted. Reboot the system. 
  23114.  
  23115. If the problem persists, contact your IBM Service Representative. 
  23116.  
  23117.  
  23118. ΓòÉΓòÉΓòÉ 19.1. EDC0001 ΓòÉΓòÉΓòÉ
  23119.  
  23120. Internal compiler error at procedure &1. 
  23121.  
  23122. An error occurred during compilation. 
  23123.  
  23124. Recovery: Contact your IBM Service Representative. 
  23125.  
  23126.  
  23127. ΓòÉΓòÉΓòÉ 19.2. EDC0002 ΓòÉΓòÉΓòÉ
  23128.  
  23129. Unexpected compiler error #&1&2 occurred. 
  23130.  
  23131. An error occurred which the compiler was not able to recover from. 
  23132.  
  23133. Recovery: Contact your IBM Service Representative. 
  23134.  
  23135.  
  23136. ΓòÉΓòÉΓòÉ 19.3. EDC0003 ΓòÉΓòÉΓòÉ
  23137.  
  23138. Compilation aborted by user. 
  23139.  
  23140. Ctrl-Break or Ctrl-C was pressed to stop the compiler. 
  23141.  
  23142. Recovery: None. 
  23143.  
  23144.  
  23145. ΓòÉΓòÉΓòÉ 19.4. EDC0041 ΓòÉΓòÉΓòÉ
  23146.  
  23147. Identifier &1 must be declared before it is used. 
  23148.  
  23149. A C identifier must be declared before it is used in an expression. 
  23150.  
  23151. Recovery: Declare an identifier of that name in the current scope or in a 
  23152. higher scope. 
  23153.  
  23154.  
  23155. ΓòÉΓòÉΓòÉ 19.5. EDC0042 ΓòÉΓòÉΓòÉ
  23156.  
  23157. A declaration must declare a variable, a tag, or enum members. 
  23158.  
  23159. A data type cannot be followed by a semicolon or an enum tag without the list 
  23160. of enum constants. 
  23161.  
  23162. Recovery: Add a variable name to the data type or provide the list of enum 
  23163. constants to complete the declaration. 
  23164.  
  23165.  
  23166. ΓòÉΓòÉΓòÉ 19.6. EDC0043 ΓòÉΓòÉΓòÉ
  23167.  
  23168. A type must be specified in the declaration of the object &1. 
  23169.  
  23170. A declaration must always specify the type of the object declared or the return 
  23171. type of the function declared.  A missing type (an object name followed by a 
  23172. semicolon) does not default to int. 
  23173.  
  23174. Recovery: Declare the object or function with a type. 
  23175.  
  23176.  
  23177. ΓòÉΓòÉΓòÉ 19.7. EDC0044 ΓòÉΓòÉΓòÉ
  23178.  
  23179. An incomplete struct or union tag cannot be used in a declaration. 
  23180.  
  23181. Only pointer declarations can include incomplete types.  A struct or union tag 
  23182. is undefined if the list describing the name and type of its members has not 
  23183. been specified. 
  23184.  
  23185. Recovery: Define the tag before it is used in the declaration of an identifier 
  23186. or complete the declaration. 
  23187.  
  23188.  
  23189. ΓòÉΓòÉΓòÉ 19.8. EDC0045 ΓòÉΓòÉΓòÉ
  23190.  
  23191. The enum constants must be specified when the enum tag is declared. 
  23192.  
  23193. When an enumeration tag is declared, the list of the enumeration constants must 
  23194. be included in the declaration. 
  23195.  
  23196. Recovery: Add the list of enumeration constants in the enum tag declaration. 
  23197.  
  23198.  
  23199. ΓòÉΓòÉΓòÉ 19.9. EDC0047 ΓòÉΓòÉΓòÉ
  23200.  
  23201. External objects cannot be initialized in a block. 
  23202.  
  23203. A variable has been declared at block scope with storage class extern, and has 
  23204. been given an explicit initializer.  This is not permitted. 
  23205.  
  23206. Recovery: Initialize the external object in the external declaration. 
  23207.  
  23208.  
  23209. ΓòÉΓòÉΓòÉ 19.10. EDC0049 ΓòÉΓòÉΓòÉ
  23210.  
  23211. The pragma &1 directive has already been specified for function &2. 
  23212.  
  23213. Only one of pragma inline and pragma noinline can be specified for a single 
  23214. function.  The second pragma specified will be ignored. 
  23215.  
  23216. Recovery: Remove one of the conflicting pragmas. 
  23217.  
  23218.  
  23219. ΓòÉΓòÉΓòÉ 19.11. EDC0050 ΓòÉΓòÉΓòÉ
  23220.  
  23221. A C reserved word cannot appear in a #pragma directive. 
  23222.  
  23223. A reserved word, such as int or break, has been used in a #pragma directive. 
  23224. This can cause unexpected results, so it is not permitted. 
  23225.  
  23226. Recovery: Replace the reserved word by the name of a function or variable. 
  23227.  
  23228.  
  23229. ΓòÉΓòÉΓòÉ 19.12. EDC0060 ΓòÉΓòÉΓòÉ
  23230.  
  23231. Length of bit-field &1 must be less than or equal to 32 bits. 
  23232.  
  23233. The bit-field length must not exceed the maximum bit size of the bit-field 
  23234. type. 
  23235.  
  23236. Recovery: Define the bit-field length to be less than or equal to 32 bits. 
  23237.  
  23238.  
  23239. ΓòÉΓòÉΓòÉ 19.13. EDC0061 ΓòÉΓòÉΓòÉ
  23240.  
  23241. Bit-field &1 must have type signed int or unsigned int. 
  23242.  
  23243. Recovery: Define the bit-field with a type signed int or unsigned int. 
  23244.  
  23245.  
  23246. ΓòÉΓòÉΓòÉ 19.14. EDC0062 ΓòÉΓòÉΓòÉ
  23247.  
  23248. A bit-field with a zero length must be unnamed. 
  23249.  
  23250. A named bit-field must have a positive length; a zero length bit-field is used 
  23251. for alignment only, and must not be named. 
  23252.  
  23253. Recovery: Redefine the bit-field with a length greater than zero or remove the 
  23254. name of the bit-field. 
  23255.  
  23256.  
  23257. ΓòÉΓòÉΓòÉ 19.15. EDC0063 ΓòÉΓòÉΓòÉ
  23258.  
  23259. Length of bit-field &1 must be a constant expression. 
  23260.  
  23261. Recovery: Replace the expression that specifies the length of the bit-field 
  23262. with a constant expression. 
  23263.  
  23264.  
  23265. ΓòÉΓòÉΓòÉ 19.16. EDC0064 ΓòÉΓòÉΓòÉ
  23266.  
  23267. Length of bit-field &1 must be positive. 
  23268.  
  23269. Recovery: Replace the constant expression that specifies the length of the 
  23270. bit-field with a positive value. 
  23271.  
  23272.  
  23273. ΓòÉΓòÉΓòÉ 19.17. EDC0065 ΓòÉΓòÉΓòÉ
  23274.  
  23275. Length of bit-field &1 must be a constant integral expression. 
  23276.  
  23277. Recovery: Replace the constant expression that specifies the length of the 
  23278. bit-field with a constant integral expression. 
  23279.  
  23280.  
  23281. ΓòÉΓòÉΓòÉ 19.18. EDC0067 ΓòÉΓòÉΓòÉ
  23282.  
  23283. A struct or union member cannot be declared with a storage class. 
  23284.  
  23285. A storage class specifier was found in the declaration of a struct or union 
  23286. member.  Members automatically take on the same storage class as their parent 
  23287. structure or union. 
  23288.  
  23289. Recovery: Remove the storage class specifier from the member of the struct or 
  23290. union. 
  23291.  
  23292.  
  23293. ΓòÉΓòÉΓòÉ 19.19. EDC0068 ΓòÉΓòÉΓòÉ
  23294.  
  23295. The &1 definition must specify a member list. 
  23296.  
  23297. The declaration of a struct or a union that includes an empty member list 
  23298. enclosed between braces is not a valid struct or union definition. 
  23299.  
  23300. Recovery: Specify the members of the struct or union in the definition or 
  23301. remove the empty braces to make it a simple struct or union tag declaration. 
  23302.  
  23303.  
  23304. ΓòÉΓòÉΓòÉ 19.20. EDC0069 ΓòÉΓòÉΓòÉ
  23305.  
  23306. A member declaration must specify a name. 
  23307.  
  23308. A struct or union member declaration must specify a name.  A type cannot be 
  23309. followed by a semicolon. 
  23310.  
  23311. Recovery: Declare the member with a name. 
  23312.  
  23313.  
  23314. ΓòÉΓòÉΓòÉ 19.21. EDC0080 ΓòÉΓòÉΓòÉ
  23315.  
  23316. An object cannot be cast to an struct, union or function type. 
  23317.  
  23318. An attempt was made to cast an operand to an aggregate, union or function type. 
  23319.  
  23320. Recovery: Use pointers instead of struct, union or function objects. Cast the 
  23321. pointer operand to a pointer to the struct, union or function type. 
  23322.  
  23323.  
  23324. ΓòÉΓòÉΓòÉ 19.22. EDC0081 ΓòÉΓòÉΓòÉ
  23325.  
  23326. A struct or union cannot be cast to another data type. 
  23327.  
  23328. Recovery: Use a pointer to the struct or union as the operand. 
  23329.  
  23330.  
  23331. ΓòÉΓòÉΓòÉ 19.23. EDC0082 ΓòÉΓòÉΓòÉ
  23332.  
  23333. The data conversion is not valid. 
  23334.  
  23335. The statement contains an expression that converts data to a type that is not 
  23336. valid.  See Type Conversions for the table of correct data conversions. 
  23337.  
  23338. Recovery: Check the type declaration of the indicated operand and the type of 
  23339. the conversion.  Ensure the conversion is correct. 
  23340.  
  23341.  
  23342. ΓòÉΓòÉΓòÉ 19.24. EDC0083 ΓòÉΓòÉΓòÉ
  23343.  
  23344. Only casts to arithmetic types are allowed in an arithmetic constant 
  23345. expression. 
  23346.  
  23347. In an arithmetic constant expression, casts must be to arithmetic types. Valid 
  23348. arithmetic types include: char, signed and unsigned int, enum, float, double, 
  23349. and long double. 
  23350.  
  23351. Recovery: Remove the cast operator or change the cast to an arithmetic one. 
  23352.  
  23353.  
  23354. ΓòÉΓòÉΓòÉ 19.25. EDC0096 ΓòÉΓòÉΓòÉ
  23355.  
  23356. The subscript must be a constant integral expression. 
  23357.  
  23358. Recovery: Replace the expression that specifies the array subscript by a 
  23359. constant integral expression. 
  23360.  
  23361.  
  23362. ΓòÉΓòÉΓòÉ 19.26. EDC0097 ΓòÉΓòÉΓòÉ
  23363.  
  23364. Pointers to void and pointers to function are not assignment compatible. 
  23365.  
  23366. Recovery: Ensure that your function declarations are correct. 
  23367.  
  23368.  
  23369. ΓòÉΓòÉΓòÉ 19.27. EDC0098 ΓòÉΓòÉΓòÉ
  23370.  
  23371. Pointers to void and pointers to function cannot be compared. 
  23372.  
  23373. Recovery: Check the logic of the comparison. 
  23374.  
  23375.  
  23376. ΓòÉΓòÉΓòÉ 19.28. EDC0099 ΓòÉΓòÉΓòÉ
  23377.  
  23378. A pointer to an incomplete type cannot be subscripted. 
  23379.  
  23380. Recovery: Define the type before you reference it. 
  23381.  
  23382.  
  23383. ΓòÉΓòÉΓòÉ 19.29. EDC0100 ΓòÉΓòÉΓòÉ
  23384.  
  23385. Operand of bitwise complement must have integral type. 
  23386.  
  23387. The operand of the bitwise complement operator does not have an integral type. 
  23388. Valid integral types include: signed and unsigned char; signed and unsigned 
  23389. short, long, and int; and enum. 
  23390.  
  23391. Recovery: Change the type of the operand, or use a different operand. 
  23392.  
  23393.  
  23394. ΓòÉΓòÉΓòÉ 19.30. EDC0101 ΓòÉΓòÉΓòÉ
  23395.  
  23396. Operand of unary minus operator must have arithmetic type. 
  23397.  
  23398. The operand of the unary minus operator (-) does not have an arithmetic type. 
  23399. Valid arithmetic types include: signed and unsigned char; signed and unsigned 
  23400. short, long, and int; enum, float, double, and long double. 
  23401.  
  23402. Recovery: Change the type of the operand, or use a different operand. 
  23403.  
  23404.  
  23405. ΓòÉΓòÉΓòÉ 19.31. EDC0102 ΓòÉΓòÉΓòÉ
  23406.  
  23407. Operand of logical negation must have scalar type. 
  23408.  
  23409. The operand of the logical negation operator (!) does not have a scalar type. 
  23410. Valid scalar types include: signed and unsigned char; signed and unsigned 
  23411. short, long, and int; enum, float, double, long double, and pointers. 
  23412.  
  23413. Recovery: Change the type of the operand, or use a different operand. 
  23414.  
  23415.  
  23416. ΓòÉΓòÉΓòÉ 19.32. EDC0103 ΓòÉΓòÉΓòÉ
  23417.  
  23418. This size of this type is zero. 
  23419.  
  23420. The sizeof operator cannot be used on a void type.  If it is, the compiler 
  23421. returns zero for the size of the expression. 
  23422.  
  23423. Recovery: Ensure that sizeof() is used on a valid type. 
  23424.  
  23425.  
  23426. ΓòÉΓòÉΓòÉ 19.33. EDC0104 ΓòÉΓòÉΓòÉ
  23427.  
  23428. Only pointers to compatible types can be subtracted. 
  23429.  
  23430. The expression must contain pointers to compatible data types. See Pointer 
  23431. Arithmetic for the rules on compatible types. 
  23432.  
  23433. Recovery: Ensure that the pointers point to compatible data types. 
  23434.  
  23435.  
  23436. ΓòÉΓòÉΓòÉ 19.34. EDC0105 ΓòÉΓòÉΓòÉ
  23437.  
  23438. Operand of address operator must be a function or an lvalue. 
  23439.  
  23440. The operand of the address operator (unary &) is not valid. The operand must be 
  23441. either a function designator or an lvalue that designates an object that is not 
  23442. a bit-field and is not declared with register storage class. 
  23443.  
  23444. Recovery: Change the operand. 
  23445.  
  23446.  
  23447. ΓòÉΓòÉΓòÉ 19.35. EDC0106 ΓòÉΓòÉΓòÉ
  23448.  
  23449. The sizeof operator cannot be used with a function, void or bit-field. 
  23450.  
  23451. The operand of the sizeof operator is not valid.  The sizeof operator cannot be 
  23452. applied to an expression that has a function type or an incomplete type, to the 
  23453. parenthesized name of such a type, or to an lvalue that designates a bit-field 
  23454. object. 
  23455.  
  23456. Recovery: Change the operand. 
  23457.  
  23458.  
  23459. ΓòÉΓòÉΓòÉ 19.36. EDC0107 ΓòÉΓòÉΓòÉ
  23460.  
  23461. Operand of indirection operator must be a pointer. 
  23462.  
  23463. The operand of the indirection operator (unary *) is not a pointer. 
  23464.  
  23465. Recovery: Change the operand. 
  23466.  
  23467.  
  23468. ΓòÉΓòÉΓòÉ 19.37. EDC0108 ΓòÉΓòÉΓòÉ
  23469.  
  23470. Operand of arrow operator must be a pointer to a struct or union. 
  23471.  
  23472. The left hand operand of the arrow operator (->) must have type "pointer to 
  23473. structure" or "pointer to union". 
  23474.  
  23475. Recovery: Change the operand. 
  23476.  
  23477.  
  23478. ΓòÉΓòÉΓòÉ 19.38. EDC0109 ΓòÉΓòÉΓòÉ
  23479.  
  23480. The subscript must be an integral expression. 
  23481.  
  23482. The subscript expression must have integral type. Valid integral types include: 
  23483. char, signed and unsigned int, and enum. 
  23484.  
  23485. Recovery: Change the subscript expression to have an integral type. 
  23486.  
  23487.  
  23488. ΓòÉΓòÉΓòÉ 19.39. EDC0110 ΓòÉΓòÉΓòÉ
  23489.  
  23490. Operand of dot operator must be a struct or a union. 
  23491.  
  23492. The left hand operand of the dot (.) operator is not of type struct or union. 
  23493.  
  23494. Recovery: Change the operand. 
  23495.  
  23496.  
  23497. ΓòÉΓòÉΓòÉ 19.40. EDC0111 ΓòÉΓòÉΓòÉ
  23498.  
  23499. Identifier &1 must be a member of the struct or union. 
  23500.  
  23501. The specified member does not belong to the structure or union given. One of 
  23502. the following has occurred: 
  23503.  
  23504. o The right hand operand of the dot (.) operator is not a member of the 
  23505.   structure or union specified on the left hand side of the operator. 
  23506.  
  23507. o The right hand operand of the arrow (->) operator is not a member of the 
  23508.   structure or union pointed to by the pointer on the left hand side of the 
  23509.   operator. 
  23510.  
  23511. Recovery: Change the identifier. 
  23512.  
  23513.  
  23514. ΓòÉΓòÉΓòÉ 19.41. EDC0112 ΓòÉΓòÉΓòÉ
  23515.  
  23516. The expression must be a function designator. 
  23517.  
  23518. The expression is followed by an argument list but does not evaluate to a 
  23519. function designator. 
  23520.  
  23521. Recovery: Change the expression to be a function or a pointer to a function. 
  23522.  
  23523.  
  23524. ΓòÉΓòÉΓòÉ 19.42. EDC0113 ΓòÉΓòÉΓòÉ
  23525.  
  23526. Operand must have integral type. 
  23527.  
  23528. The operand of the bitwise operators or modulus (%) operator must have integral 
  23529. type.  Valid integral types include: char, signed and unsigned int, and enum. 
  23530.  
  23531. Recovery: Change the operand. 
  23532.  
  23533.  
  23534. ΓòÉΓòÉΓòÉ 19.43. EDC0114 ΓòÉΓòÉΓòÉ
  23535.  
  23536. Operand must be a modifiable lvalue. 
  23537.  
  23538. See Lvalue for a description of lvalue. 
  23539.  
  23540. Recovery: Change the operand. 
  23541.  
  23542.  
  23543. ΓòÉΓòÉΓòÉ 19.44. EDC0115 ΓòÉΓòÉΓòÉ
  23544.  
  23545. A struct or union can be assigned only to a compatible type. 
  23546.  
  23547. Two structures have compatible types if both have been declared with the same 
  23548. structure tag.  Two unions have compatible types if both have been declared 
  23549. with the same union tag.  However, tags are scope sensitive.  Even if two tag 
  23550. names and their member lists are identical, if their definitions are located in 
  23551. different scopes, the types associated with these tags are different. 
  23552.  
  23553. Recovery: Ensure that the structures or unions used in the assignment have been 
  23554. declared with the same tag in the same scope. 
  23555.  
  23556.  
  23557. ΓòÉΓòÉΓòÉ 19.45. EDC0116 ΓòÉΓòÉΓòÉ
  23558.  
  23559. Identifier &1 cannot be redeclared as an enum tag. 
  23560.  
  23561. In the declaration, the object is declared to be an enum tag. The object was 
  23562. previously declared to the tag of a struct or union type. 
  23563.  
  23564. Recovery: Change the name of the tag. 
  23565.  
  23566.  
  23567. ΓòÉΓòÉΓòÉ 19.46. EDC0117 ΓòÉΓòÉΓòÉ
  23568.  
  23569. The operation between these types is not valid. 
  23570.  
  23571. The identifiers on the left hand side and the right hand side of the operator 
  23572. have types that do not conform to the restrictions of the operator.  The 
  23573. operation specified in the expression cannot be performed.  See Expressions and 
  23574. Operators for the list of operator restrictions. 
  23575.  
  23576. Recovery: Change the operands. 
  23577.  
  23578.  
  23579. ΓòÉΓòÉΓòÉ 19.47. EDC0118 ΓòÉΓòÉΓòÉ
  23580.  
  23581. The divisor for the modulus or division operator cannot be zero. 
  23582.  
  23583. The value of the divisor expression cannot be zero. 
  23584.  
  23585. Recovery: Change the expression used as the divisor. 
  23586.  
  23587.  
  23588. ΓòÉΓòÉΓòÉ 19.48. EDC0119 ΓòÉΓòÉΓòÉ
  23589.  
  23590. The void pointer must be cast prior to this operation. 
  23591.  
  23592. A void pointer must be cast to a data type before it is used in this operation. 
  23593.  
  23594. Recovery: Cast the pointer to a type other than void prior to this operation. 
  23595.  
  23596.  
  23597. ΓòÉΓòÉΓòÉ 19.49. EDC0120 ΓòÉΓòÉΓòÉ
  23598.  
  23599. Operand of unary plus operator must have arithmetic type. 
  23600.  
  23601. The operand of the unary plus operator (+) does not have an arithmetic type. 
  23602. Valid arithmetic types include: signed and unsigned char; signed and unsigned 
  23603. short, long, and int; enum, float, double, and long double. 
  23604.  
  23605. Recovery: Change the operand. 
  23606.  
  23607.  
  23608. ΓòÉΓòÉΓòÉ 19.50. EDC0121 ΓòÉΓòÉΓòÉ
  23609.  
  23610. Operand must have scalar type. 
  23611.  
  23612. The operand for this operation does not have scalar type.  Valid scalar types 
  23613. include: signed and unsigned char; signed and unsigned short, long, and int; 
  23614. enum, float, double, long double, and pointers. 
  23615.  
  23616. Recovery: Change the type of the operand, or use a different operand. 
  23617.  
  23618.  
  23619. ΓòÉΓòÉΓòÉ 19.51. EDC0122 ΓòÉΓòÉΓòÉ
  23620.  
  23621. Operand must have arithmetic type. 
  23622.  
  23623. The operand of this operation does not have arithmetic type. Valid arithmetic 
  23624. types include: signed and unsigned char; signed and unsigned short, long, and 
  23625. int; enum, float, double, and long double. 
  23626.  
  23627. Recovery: Change the operand. 
  23628.  
  23629.  
  23630. ΓòÉΓòÉΓòÉ 19.52. EDC0123 ΓòÉΓòÉΓòÉ
  23631.  
  23632. If one operand is void, the other must be void. 
  23633.  
  23634. If one operand in the conditional expression has type void, the other operand 
  23635. must also have type void. 
  23636.  
  23637. Recovery: Make the operands compatible. 
  23638.  
  23639.  
  23640. ΓòÉΓòÉΓòÉ 19.53. EDC0125 ΓòÉΓòÉΓòÉ
  23641.  
  23642. Operands of the conditional operator must have compatible types. 
  23643.  
  23644. If one operand of the conditional expression has type struct or union, the 
  23645. other operand must be a struct or union declared using the same tag in the same 
  23646. scope.  Two structures have compatible types if both have been declared with 
  23647. the same structure tag. Two unions have compatible types if both have been 
  23648. declared with the same union tag.  However, tags are scope sensitive.  Even if 
  23649. two tag names and their member lists are identical, if their definitions are 
  23650. located in different scopes, the types associated with these tags are 
  23651. different. 
  23652.  
  23653. Recovery: Ensure that the structures or unions used in the conditional 
  23654. expression have been declared/defined with the same tag (in the same scope). 
  23655.  
  23656.  
  23657. ΓòÉΓòÉΓòÉ 19.54. EDC0126 ΓòÉΓòÉΓòÉ
  23658.  
  23659. If one operand is a pointer, the other must also be a pointer. 
  23660.  
  23661. If one of the result operands of a conditional expression is a pointer, the 
  23662. other result operand must be either a pointer to the same qualified or 
  23663. unqualified type, a NULL pointer, or a pointer to void. 
  23664.  
  23665. Recovery: Change the operands. 
  23666.  
  23667.  
  23668. ΓòÉΓòÉΓòÉ 19.55. EDC0127 ΓòÉΓòÉΓòÉ
  23669.  
  23670. If the operands are pointers, they must point to compatible types. 
  23671.  
  23672. If one operand of either the relational or the equality operator is a pointer, 
  23673. the other operand must be either a pointer to the same qualified or unqualified 
  23674. type, a NULL pointer, or a pointer to void. 
  23675.  
  23676. Recovery: Change the operands. 
  23677.  
  23678.  
  23679. ΓòÉΓòÉΓòÉ 19.56. EDC0128 ΓòÉΓòÉΓòÉ
  23680.  
  23681. Two pointers cannot be added. 
  23682.  
  23683. The addition operator requires that either both operands have arithmetic type 
  23684. or, if one of the operands is a pointer, the other one must have integral type. 
  23685. Valid integral types include: char, signed and unsigned int, and enum.  Valid 
  23686. arithmetic types include: the integral types plus float, double, long double, 
  23687. and bit fields. 
  23688.  
  23689. Recovery: Change the operands. 
  23690.  
  23691.  
  23692. ΓòÉΓòÉΓòÉ 19.57. EDC0130 ΓòÉΓòÉΓòÉ
  23693.  
  23694. The operation cannot be performed on an incomplete struct or union. 
  23695.  
  23696. The definition of the operand must be completed prior to this operation.  A 
  23697. structure or union type is completed when the definition of its tag is 
  23698. specified.  A struct or union tag is defined when the list describing the name 
  23699. and type of its members is specified. 
  23700.  
  23701. Recovery: Define the tag before using it in an expression. 
  23702.  
  23703.  
  23704. ΓòÉΓòÉΓòÉ 19.58. EDC0131 ΓòÉΓòÉΓòÉ
  23705.  
  23706. Subtraction between void pointers is not allowed. 
  23707.  
  23708. Recovery: Cast the pointers to a type other than void or do not subtract them. 
  23709.  
  23710.  
  23711. ΓòÉΓòÉΓòÉ 19.59. EDC0132 ΓòÉΓòÉΓòÉ
  23712.  
  23713. A pointer to void cannot be subscripted. 
  23714.  
  23715. The subscript operator requires a pointer to a valid address. 
  23716.  
  23717. Recovery: Cast the pointer to a type other than void before using it with the 
  23718. subscript operator. 
  23719.  
  23720.  
  23721. ΓòÉΓòÉΓòÉ 19.60. EDC0133 ΓòÉΓòÉΓòÉ
  23722.  
  23723. An identifier cannot be declared in a cast or sizeof expression. 
  23724.  
  23725. Only abstract declarators can appear in cast or sizeof expressions. 
  23726.  
  23727. Recovery: Remove the identifier from the cast or sizeof expression and replace 
  23728. it with an abstract declarator. 
  23729.  
  23730.  
  23731. ΓòÉΓòÉΓòÉ 19.61. EDC0136 ΓòÉΓòÉΓòÉ
  23732.  
  23733. The sizeof operator cannot be used with arrays of unknown size. 
  23734.  
  23735. Recovery: Ensure the array and its size have been declared before using it with 
  23736. the sizeof operator. 
  23737.  
  23738.  
  23739. ΓòÉΓòÉΓòÉ 19.62. EDC0137 ΓòÉΓòÉΓòÉ
  23740.  
  23741. The indirection operator cannot be applied to a pointer to an incomplete struct 
  23742. or union. 
  23743.  
  23744. Except for pointers, it is not valid to declare an object of incomplete 
  23745. structure or union type.  A structure or union is incomplete when the 
  23746. definition of its tag has not been specified. A struct or union tag is 
  23747. undefined when the list describing the name and type of its members has not 
  23748. been specified. 
  23749.  
  23750. Recovery: Define the tag before using it in the declaration of an identifier. 
  23751.  
  23752.  
  23753. ΓòÉΓòÉΓòÉ 19.63. EDC0138 ΓòÉΓòÉΓòÉ
  23754.  
  23755. The indirection operator cannot be applied to a void pointer. 
  23756.  
  23757. The indirection operator requires a pointer to a valid address. 
  23758.  
  23759. Recovery: Cast the pointer to a type other than void before using it with the 
  23760. indirection operator. 
  23761.  
  23762.  
  23763. ΓòÉΓòÉΓòÉ 19.64. EDC0139 ΓòÉΓòÉΓòÉ
  23764.  
  23765. A translation unit must contain at least one external declaration. 
  23766.  
  23767. A translation unit that does not contain any external declaration will not be 
  23768. linked to. Normally it will not affect the execution of the executable program. 
  23769.  
  23770. Recovery: Ensure this is what was intended or change the appropriate 
  23771. declarations to the external ones. 
  23772.  
  23773.  
  23774. ΓòÉΓòÉΓòÉ 19.65. EDC0140 ΓòÉΓòÉΓòÉ
  23775.  
  23776. Operand has type &1. 
  23777.  
  23778. An error has occurred due to conflicting operands.  This message states the 
  23779. type of the operand used in the expression. 
  23780.  
  23781. Recovery: No recovery is necessary if this result was intended. Change the type 
  23782. of the operand if necessary. 
  23783.  
  23784.  
  23785. ΓòÉΓòÉΓòÉ 19.66. EDC0141 ΓòÉΓòÉΓòÉ
  23786.  
  23787. Prototype has type &1. 
  23788.  
  23789. An error has occurred due to conflicting function declarations. This message 
  23790. states the type of the prototype declaration. 
  23791.  
  23792. Recovery: No recovery is necessary if this result was intended. Change the type 
  23793. of the prototype if necessary. 
  23794.  
  23795.  
  23796. ΓòÉΓòÉΓòÉ 19.67. EDC0142 ΓòÉΓòÉΓòÉ
  23797.  
  23798. Previous declaration has type &1. 
  23799.  
  23800. An error has occurred due to conflicting identifier declarations. This message 
  23801. states the type of the identifier in the current declaration. 
  23802.  
  23803. Recovery: No recovery is necessary if this result was intended. Change the 
  23804. declarations to the same type if necessary. 
  23805.  
  23806.  
  23807. ΓòÉΓòÉΓòÉ 19.68. EDC0143 ΓòÉΓòÉΓòÉ
  23808.  
  23809. The pre- and post- increment and decrement operators cannot be applied to void 
  23810. pointers. 
  23811.  
  23812. Pointers to void cannot be incremented or decremented. 
  23813.  
  23814. Recovery: Cast the pointer to a type other than void before using it with any 
  23815. of the increment or decrement operators. 
  23816.  
  23817.  
  23818. ΓòÉΓòÉΓòÉ 19.69. EDC0145 ΓòÉΓòÉΓòÉ
  23819.  
  23820. Redeclaration has type &1. 
  23821.  
  23822. An error has occurred because of conflicting declarations. This message states 
  23823. the type of the identifier in the redeclarations. 
  23824.  
  23825. Recovery: No recovery is necessary if this result was intended. Change the 
  23826. types in the declarations to be compatible, if necessary. 
  23827.  
  23828.  
  23829. ΓòÉΓòÉΓòÉ 19.70. EDC0146 ΓòÉΓòÉΓòÉ
  23830.  
  23831. Function has return type &1. 
  23832.  
  23833. Recovery: No recovery is necessary if this result was intended. Change the 
  23834. return type if necessary. 
  23835.  
  23836.  
  23837. ΓòÉΓòÉΓòÉ 19.71. EDC0147 ΓòÉΓòÉΓòÉ
  23838.  
  23839. Argument has type &1. 
  23840.  
  23841. The argument type in the function call conflicts with the parameter in the 
  23842. function prototype.  This message states the type of the argument. 
  23843.  
  23844. Recovery: No recovery is necessary if this result was intended. Change the 
  23845. argument types to be compatible, if necessary. 
  23846.  
  23847.  
  23848. ΓòÉΓòÉΓòÉ 19.72. EDC0148 ΓòÉΓòÉΓòÉ
  23849.  
  23850. Expression has type &1. 
  23851.  
  23852. Recovery: Informational message.  No recovery is necessary if this result was 
  23853. intended. 
  23854.  
  23855.  
  23856. ΓòÉΓòÉΓòÉ 19.73. EDC0149 ΓòÉΓòÉΓòÉ
  23857.  
  23858. Operation not allowed with enum that is not defined. 
  23859.  
  23860. The sizeof or cast operator cannot be used with an enum that is not defined. 
  23861.  
  23862. Recovery: Define the enum. 
  23863.  
  23864.  
  23865. ΓòÉΓòÉΓòÉ 19.74. EDC0150 ΓòÉΓòÉΓòÉ
  23866.  
  23867. The number of initializers cannot be greater than the number of elements. 
  23868.  
  23869. Too many initializers were found in the initializer list for the indicated 
  23870. declaration. 
  23871.  
  23872. Recovery: Check the number of initializers.  Check the closing brace at the end 
  23873. of the initializer list to ensure that it has been positioned correctly. 
  23874.  
  23875.  
  23876. ΓòÉΓòÉΓòÉ 19.75. EDC0151 ΓòÉΓòÉΓòÉ
  23877.  
  23878. The initializer must be a constant expression. 
  23879.  
  23880. The initializers for identifiers of static storage duration, or for identifiers 
  23881. of an array, structure, or union type must be constant expressions. 
  23882.  
  23883. Recovery: Remove the initialization or change the indicated initializer to a 
  23884. constant expression. 
  23885.  
  23886.  
  23887. ΓòÉΓòÉΓòÉ 19.76. EDC0152 ΓòÉΓòÉΓòÉ
  23888.  
  23889. A register array may only be used as the operand to sizeof. 
  23890.  
  23891. The only operator that may be applied to a register array is sizeof. 
  23892.  
  23893. Recovery: Remove the register keyword from the declaration. 
  23894.  
  23895.  
  23896. ΓòÉΓòÉΓòÉ 19.77. EDC0153 ΓòÉΓòÉΓòÉ
  23897.  
  23898. An initializer for a static identifier cannot have the automatic storage class. 
  23899.  
  23900. The initializer cannot have an automatic storage class if the identifier being 
  23901. initialized has a static storage class. 
  23902.  
  23903. Recovery: Either change the storage class in the identifier declaration or 
  23904. change the initializer. 
  23905.  
  23906.  
  23907. ΓòÉΓòÉΓòÉ 19.78. EDC0158 ΓòÉΓòÉΓòÉ
  23908.  
  23909. After widening, previous declaration has type &1. 
  23910.  
  23911. An error has occurred due to conflicting identifier declarations. This message 
  23912. states the type of the identifier in the current declaration, after the 
  23913. identifier's type has been widened. 
  23914.  
  23915. Recovery: No recovery is necessary if this result was intended. Change the 
  23916. declarations to the same type if necessary. 
  23917.  
  23918.  
  23919. ΓòÉΓòÉΓòÉ 19.79. EDC0159 ΓòÉΓòÉΓòÉ
  23920.  
  23921. After widening, redeclaration has type &1. 
  23922.  
  23923. An error has occurred because of conflicting declarations. This message states 
  23924. the type of the identifier in the redeclarations, after the identifier's type 
  23925. has been widened 
  23926.  
  23927. Recovery: No recovery is necessary if this result was intended. Change the 
  23928. types in the declarations to be compatible, if necessary. 
  23929.  
  23930.  
  23931. ΓòÉΓòÉΓòÉ 19.80. EDC0166 ΓòÉΓòÉΓòÉ
  23932.  
  23933. A non-lvalue array cannot be subscripted. 
  23934.  
  23935. Subscript operator cannot be used with a non-lvalue array. 
  23936.  
  23937. Recovery: Change the array to an lvalue one. 
  23938.  
  23939.  
  23940. ΓòÉΓòÉΓòÉ 19.81. EDC0167 ΓòÉΓòÉΓòÉ
  23941.  
  23942. A non-lvalue array cannot be used in this context. 
  23943.  
  23944. The location of a non-lvalue array may not be referenced. 
  23945.  
  23946. Recovery: Change the array to an lvalue one. 
  23947.  
  23948.  
  23949. ΓòÉΓòÉΓòÉ 19.82. EDC0168 ΓòÉΓòÉΓòÉ
  23950.  
  23951. Operation not valid on a function pointer. 
  23952.  
  23953. Subscript operator, additive operator, and prefix and postfix increment and 
  23954. decrement operators cannot be used with an operand of type pointer to function. 
  23955.  
  23956. Recovery: Change the operator or the operand. 
  23957.  
  23958.  
  23959. ΓòÉΓòÉΓòÉ 19.83. EDC0170 ΓòÉΓòÉΓòÉ
  23960.  
  23961. A function cannot be initialized. 
  23962.  
  23963. An attempt was made to assign an initial value to a function identifier. 
  23964.  
  23965. Recovery: Remove the assignment operator and the initializer. 
  23966.  
  23967.  
  23968. ΓòÉΓòÉΓòÉ 19.84. EDC0171 ΓòÉΓòÉΓòÉ
  23969.  
  23970. A function cannot return a function. 
  23971.  
  23972. A function cannot have a return type of function. 
  23973.  
  23974. Recovery: Return a pointer to the function or specify a different return type. 
  23975.  
  23976.  
  23977. ΓòÉΓòÉΓòÉ 19.85. EDC0172 ΓòÉΓòÉΓòÉ
  23978.  
  23979. Function &1 cannot have a storage class of auto or register. 
  23980.  
  23981. Recovery: Remove the storage class specifier for the function identifier, or 
  23982. change it to either extern or static. 
  23983.  
  23984.  
  23985. ΓòÉΓòÉΓòÉ 19.86. EDC0173 ΓòÉΓòÉΓòÉ
  23986.  
  23987. A function cannot be a member of a struct or union. 
  23988.  
  23989. Recovery: Use a pointer to the function or remove the function from the member 
  23990. list. 
  23991.  
  23992.  
  23993. ΓòÉΓòÉΓòÉ 19.87. EDC0174 ΓòÉΓòÉΓòÉ
  23994.  
  23995. A function cannot be an element of an array. 
  23996.  
  23997. Recovery: Use a pointer to the function, or change the type of the element. 
  23998.  
  23999.  
  24000. ΓòÉΓòÉΓòÉ 19.88. EDC0175 ΓòÉΓòÉΓòÉ
  24001.  
  24002. A function cannot return a &1 qualified type. 
  24003.  
  24004. The const or volatile qualifier cannot be used to qualify a function's return 
  24005. type. 
  24006.  
  24007. Recovery: Remove the qualifier or return a pointer to the qualified type. 
  24008.  
  24009.  
  24010. ΓòÉΓòÉΓòÉ 19.89. EDC0176 ΓòÉΓòÉΓòÉ
  24011.  
  24012. Return type must be compatible with the declaration of function &1. 
  24013.  
  24014. The return statement of the function tries to return a structure or a union 
  24015. type that is not compatible with the return type specified in the function 
  24016. declaration/definition. The type of a structure or union is represented by its 
  24017. tag. Two structures have compatible types if both have been declared with the 
  24018. same structure tag.  Two unions have compatible types if both have been 
  24019. declared with the same union tag.  However, tags are scope sensitive.  Even if 
  24020. two tag names and their member lists are identical, if their definitions are 
  24021. located in different scopes, the types associated with these tags are 
  24022. different. 
  24023.  
  24024. Recovery: Ensure that the same tag (in the same scope) is used in the function 
  24025. declaration/definition, as well as in the declaration/definition of the value 
  24026. specified on the return statement, 
  24027.  
  24028.  
  24029. ΓòÉΓòÉΓòÉ 19.90. EDC0177 ΓòÉΓòÉΓòÉ
  24030.  
  24031. A function declared to return void cannot return a value. 
  24032.  
  24033. When a function is declared to have a void return type, the return statement of 
  24034. the function cannot return any value.  An attempt was made to return a value in 
  24035. a function that was declared/defined with a void return type. 
  24036.  
  24037. Recovery: Change the declaration to specify the return type or do not return a 
  24038. value. 
  24039.  
  24040.  
  24041. ΓòÉΓòÉΓòÉ 19.91. EDC0178 ΓòÉΓòÉΓòÉ
  24042.  
  24043. A function cannot return an array. 
  24044.  
  24045. Recovery: Return a pointer to the array or specify a different return type. 
  24046.  
  24047.  
  24048. ΓòÉΓòÉΓòÉ 19.92. EDC0179 ΓòÉΓòÉΓòÉ
  24049.  
  24050. The function &1 cannot be redefined. 
  24051.  
  24052. It is not valid to define a function more than once.  Do not confuse function 
  24053. definitions and function declarations.  A declaration describes the return type 
  24054. of the function.  A definition is a declaration followed by the code that is to 
  24055. be executed when the function is called (the code portion is called the 
  24056. function body). Only one definition per function is allowed. 
  24057.  
  24058. Recovery: Remove all extra definitions or change the name of the function. 
  24059.  
  24060.  
  24061. ΓòÉΓòÉΓòÉ 19.93. EDC0180 ΓòÉΓòÉΓòÉ
  24062.  
  24063. The static function &1 is referenced but is not defined in this file. 
  24064.  
  24065. A static function was declared and referenced in this file. The definition of 
  24066. the function was not found before the end of the file.  When a function is 
  24067. declared to be static, the function definition must appear in the same file. 
  24068.  
  24069. Recovery: Define the function or remove the static storage class. 
  24070.  
  24071.  
  24072. ΓòÉΓòÉΓòÉ 19.94. EDC0181 ΓòÉΓòÉΓòÉ
  24073.  
  24074. The struct, union, or enum tag &1 cannot be redefined. 
  24075.  
  24076. A struct or union tag is defined when it is declared with the list describing 
  24077. the name and type of its members.  An enum tag is defined when it is declared 
  24078. with the list of its enumeration constants. It is not valid to define a struct, 
  24079. union, or enum tag more than once in the same scope. 
  24080.  
  24081. Recovery: Remove all extra definitions or rename the tag. 
  24082.  
  24083.  
  24084. ΓòÉΓòÉΓòÉ 19.95. EDC0183 ΓòÉΓòÉΓòÉ
  24085.  
  24086. An argument cannot be an incomplete struct or union. 
  24087.  
  24088. The argument has an incomplete struct or union type. A structure or union is 
  24089. incomplete when the definition of the tag (i.e. when the number and the type of 
  24090. its members) has not been specified. It is not valid to pass arguments of 
  24091. incomplete type to a function. 
  24092.  
  24093. Recovery: Use a pointer to the incomplete type or define the type before using 
  24094. it. 
  24095.  
  24096.  
  24097. ΓòÉΓòÉΓòÉ 19.96. EDC0184 ΓòÉΓòÉΓòÉ
  24098.  
  24099. An argument cannot have type void. 
  24100.  
  24101. The indicated parameter has type void.  A parameter of type void cannot be 
  24102. passed on a function call. 
  24103.  
  24104. Recovery: Use a pointer to void or cast the type of the argument. 
  24105.  
  24106.  
  24107. ΓòÉΓòÉΓòÉ 19.97. EDC0185 ΓòÉΓòÉΓòÉ
  24108.  
  24109. Function &1 has not been prototyped prior to use. 
  24110.  
  24111. A prototype declaration of the function specifying the number and type of the 
  24112. parameters was not found before the function was used. Errors may occur if the 
  24113. function call does not respect the function definition. 
  24114.  
  24115. Option: /Wpro 
  24116.  
  24117. Recovery: Include a prototype declaration of the function before calling it. 
  24118.  
  24119.  
  24120. ΓòÉΓòÉΓòÉ 19.98. EDC0187 ΓòÉΓòÉΓòÉ
  24121.  
  24122. The declaration or definition of the function is not valid. 
  24123.  
  24124. The compiler cannot read the declaration. It assumes that the function 
  24125. declaration was not valid. The return type or the parameters may have been 
  24126. specified incorrectly. 
  24127.  
  24128. Recovery: Check for incorrect spelling or missing parentheses. 
  24129.  
  24130.  
  24131. ΓòÉΓòÉΓòÉ 19.99. EDC0189 ΓòÉΓòÉΓòÉ
  24132.  
  24133. The return type of the function main must have type int. 
  24134.  
  24135. Recovery: Change the return type of function main to int. 
  24136.  
  24137.  
  24138. ΓòÉΓòÉΓòÉ 19.100. EDC0190 ΓòÉΓòÉΓòÉ
  24139.  
  24140. A switch expression must have integral type. 
  24141.  
  24142. The controlling expression in a switch statement must have integral type. 
  24143. Valid integral types include: char, signed and unsigned int, and enum. 
  24144.  
  24145. Recovery: Change the expression. 
  24146.  
  24147.  
  24148. ΓòÉΓòÉΓòÉ 19.101. EDC0191 ΓòÉΓòÉΓòÉ
  24149.  
  24150. A case label must be a constant integral expression. 
  24151.  
  24152. The expression in the case statement must be a constant integral expression. 
  24153. Valid integral expressions are: char, signed and unsigned int, and enum. 
  24154.  
  24155. Recovery: Change the expression. 
  24156.  
  24157.  
  24158. ΓòÉΓòÉΓòÉ 19.102. EDC0192 ΓòÉΓòÉΓòÉ
  24159.  
  24160. The case label cannot be a duplicate of the case label on line &1. 
  24161.  
  24162. Two case labels in the same switch statement cannot evaluate to the same 
  24163. integer value. 
  24164.  
  24165. Recovery: Change one of the labels. 
  24166.  
  24167.  
  24168. ΓòÉΓòÉΓòÉ 19.103. EDC0193 ΓòÉΓòÉΓòÉ
  24169.  
  24170. A default case label cannot be placed outside a switch statement. 
  24171.  
  24172. Recovery: Remove the default case label, or place it inside a switch statement. 
  24173. Check for misplaced braces on a previous switch statement. 
  24174.  
  24175.  
  24176. ΓòÉΓòÉΓòÉ 19.104. EDC0194 ΓòÉΓòÉΓòÉ
  24177.  
  24178. A switch statement cannot contain more than one default statement. 
  24179.  
  24180. Recovery: Remove one of the default statements. 
  24181.  
  24182.  
  24183. ΓòÉΓòÉΓòÉ 19.105. EDC0195 ΓòÉΓòÉΓòÉ
  24184.  
  24185. A case statement cannot be placed outside a switch statement. 
  24186.  
  24187. Recovery: Remove the case statement, or place it within a switch statement 
  24188. group.  Check for misplaced braces on the previous switch statement. 
  24189.  
  24190.  
  24191. ΓòÉΓòÉΓòÉ 19.106. EDC0196 ΓòÉΓòÉΓòÉ
  24192.  
  24193. The case label evaluates to integer value &1. 
  24194.  
  24195. An error occurred due to conflicting case labels. This message states the value 
  24196. of the case labels. 
  24197.  
  24198. Recovery: Change the case label if necessary. 
  24199.  
  24200.  
  24201. ΓòÉΓòÉΓòÉ 19.107. EDC0197 ΓòÉΓòÉΓòÉ
  24202.  
  24203. The linkage of main must be either _System or _Optlink. 
  24204.  
  24205. Recovery: Change the linkage of function main to _System or _Optlink. 
  24206.  
  24207.  
  24208. ΓòÉΓòÉΓòÉ 19.108. EDC0198 ΓòÉΓòÉΓòÉ
  24209.  
  24210. If the operands are pointers they must point to compatible object or incomplete 
  24211. types. 
  24212.  
  24213. If both operands of a relational operator are pointers, they must point to 
  24214. qualified or unqualified versions of compatible object or incomplete types. 
  24215. Pointers to functions are not allowed. 
  24216.  
  24217. Recovery: Change the operands. 
  24218.  
  24219.  
  24220. ΓòÉΓòÉΓòÉ 19.109. EDC0200 ΓòÉΓòÉΓòÉ
  24221.  
  24222. A break statement cannot be placed outside a while, do, for or switch 
  24223. statement. 
  24224.  
  24225. Recovery: Remove the break statement or place it inside a while, do, for or 
  24226. switch statement.  Check for misplaced braces on a previous statement. 
  24227.  
  24228.  
  24229. ΓòÉΓòÉΓòÉ 19.110. EDC0201 ΓòÉΓòÉΓòÉ
  24230.  
  24231. A continue statement cannot be placed outside a while, do or for loop. 
  24232.  
  24233. Recovery: Remove the continue statement or place it inside a while, do or for 
  24234. loop.  Check for misplaced braces on a previous loop. 
  24235.  
  24236.  
  24237. ΓòÉΓòÉΓòÉ 19.111. EDC0220 ΓòÉΓòÉΓòÉ
  24238.  
  24239. Only arrays and pointers to object types can be subscripted. 
  24240.  
  24241. An attempt was made to subscript an identifier that was not an array or a 
  24242. pointer to an object type. 
  24243.  
  24244. Recovery: Remove the subscripts or change the identifier. 
  24245.  
  24246.  
  24247. ΓòÉΓòÉΓòÉ 19.112. EDC0221 ΓòÉΓòÉΓòÉ
  24248.  
  24249. Array size must be a positive constant integral expression. 
  24250.  
  24251. The array size declared is not valid.  If compilation continues, the compiler 
  24252. will assume that the array has size 1. 
  24253.  
  24254. Recovery: Make the array size a positive constant integral expression. 
  24255.  
  24256.  
  24257. ΓòÉΓòÉΓòÉ 19.113. EDC0222 ΓòÉΓòÉΓòÉ
  24258.  
  24259. Arrays cannot be redeclared with a different size. 
  24260.  
  24261. Recovery: Make the size consistent with the previous declaration or remove one 
  24262. of the array declarations. 
  24263.  
  24264.  
  24265. ΓòÉΓòÉΓòÉ 19.114. EDC0223 ΓòÉΓòÉΓòÉ
  24266.  
  24267. All array dimensions except the first must be specified. 
  24268.  
  24269. Only the first dimension of an initialized array may be unspecified. All the 
  24270. other dimensions must be specified on the declaration. 
  24271.  
  24272. Recovery: Specify all the other dimensions in the array declaration. 
  24273.  
  24274.  
  24275. ΓòÉΓòÉΓòÉ 19.115. EDC0224 ΓòÉΓòÉΓòÉ
  24276.  
  24277. All dimensions must be specified for array definitions. 
  24278.  
  24279. All the dimensions of arrays of automatic or static storage class must be 
  24280. specified on the declaration.  If the declaration of the automatic or static 
  24281. array provides an initialization, the first dimension may be unspecified 
  24282. because the initialization will determine the size needed. 
  24283.  
  24284. Recovery: Specify all of the dimensions in the array declaration. 
  24285.  
  24286.  
  24287. ΓòÉΓòÉΓòÉ 19.116. EDC0225 ΓòÉΓòÉΓòÉ
  24288.  
  24289. Arrays that are members must have all dimensions specified. 
  24290.  
  24291. Arrays that are struct or union members must have all dimensions specified in 
  24292. the array declaration. 
  24293.  
  24294. Recovery: Specify all of the dimensions in the array declaration. 
  24295.  
  24296.  
  24297. ΓòÉΓòÉΓòÉ 19.117. EDC0226 ΓòÉΓòÉΓòÉ
  24298.  
  24299. The parameter lists of the function pointers are not compatible. 
  24300.  
  24301. In assignment or initialization of function pointer, the parameter lists of the 
  24302. function pointers must have compatible type. 
  24303.  
  24304. Recovery: Ensure that the parameter lists of the function pointers are 
  24305. compatible. 
  24306.  
  24307.  
  24308. ΓòÉΓòÉΓòÉ 19.118. EDC0227 ΓòÉΓòÉΓòÉ
  24309.  
  24310. The return types of the function pointers are not compatible. 
  24311.  
  24312. In assignment or initialization of function pointer, the return types of the 
  24313. function pointers must have compatible type. 
  24314.  
  24315. Recovery: Ensure that the return types of the function pointers are compatible. 
  24316.  
  24317.  
  24318. ΓòÉΓòÉΓòÉ 19.119. EDC0228 ΓòÉΓòÉΓòÉ
  24319.  
  24320. The linkage types of the function pointers are not compatible. 
  24321.  
  24322. In assignment or initialization of function pointers, the linkage types of the 
  24323. function pointers must be compatible. 
  24324.  
  24325. Recovery: Ensure that the linkage types of the function pointers are 
  24326. compatible. 
  24327.  
  24328.  
  24329. ΓòÉΓòÉΓòÉ 19.120. EDC0240 ΓòÉΓòÉΓòÉ
  24330.  
  24331. Escape sequence is out of range for character representation. 
  24332.  
  24333. Character constants specified in an escape sequence exceeded the decimal value 
  24334. of 255, or the octal equivalent of 377, or the hexadecimal equivalent of FF. 
  24335.  
  24336. Recovery: Change the escape sequence so that the value does not exceed the 
  24337. maximum value. 
  24338.  
  24339.  
  24340. ΓòÉΓòÉΓòÉ 19.121. EDC0242 ΓòÉΓòÉΓòÉ
  24341.  
  24342. Nesting cannot exceed the maximum limit &1. 
  24343.  
  24344. The internal compiler limit of &1 nested #include files was exceeded. 
  24345.  
  24346. Recovery: Remove the nesting by putting all of the #include files at the same 
  24347. level, or reduce the number of nesting levels. 
  24348.  
  24349.  
  24350. ΓòÉΓòÉΓòÉ 19.122. EDC0244 ΓòÉΓòÉΓòÉ
  24351.  
  24352. External name &1 has been truncated to &2. 
  24353.  
  24354. The external object has a name &1 which exceeds the limit and has been 
  24355. truncated to the name &2. 
  24356.  
  24357. Option: /Wtru 
  24358.  
  24359. Recovery: Change the name if necessary. 
  24360.  
  24361.  
  24362. ΓòÉΓòÉΓòÉ 19.123. EDC0246 ΓòÉΓòÉΓòÉ
  24363.  
  24364. Floating point constant is out of range. 
  24365.  
  24366. The compiler detected a floating-point overflow either in scanning a 
  24367. floating-point constant, or in performing constant arithmetic folding. 
  24368.  
  24369. Recovery: Change the floating-point constant so that it does not exceed the 
  24370. maximum value. 
  24371.  
  24372.  
  24373. ΓòÉΓòÉΓòÉ 19.124. EDC0247 ΓòÉΓòÉΓòÉ
  24374.  
  24375. Virtual storage exceeded. 
  24376.  
  24377. The compiler ran out of memory trying to compile the file.  This sometimes 
  24378. happens with large files or programs with large functions. Note that very large 
  24379. programs limit the amount of optimization that can be done. 
  24380.  
  24381. Recovery: Shut down any large processes that are running, ensure your swap path 
  24382. is large enough, turn off optimization, and redefine your virtual storage to a 
  24383. larger size.  You can also divide the file into several small sections or 
  24384. shorten the function. 
  24385.  
  24386.  
  24387. ΓòÉΓòÉΓòÉ 19.125. EDC0248 ΓòÉΓòÉΓòÉ
  24388.  
  24389. External name &1 cannot be redefined. 
  24390.  
  24391. An external name cannot be redefined.  External names can have up to 255 
  24392. significant characters, and can be upper or lowercase. Because the number of 
  24393. significant characters can be limited using the /H option, the compiler may 
  24394. recognize two names as identical although they are not.  For example, when /H3 
  24395. is specified, the identifiers ABCD and ABCE are considered identical because 
  24396. only the first three letters are significant. 
  24397.  
  24398. Recovery: Remove one of the definitions, change one of the names, or change the 
  24399. number specified on the /H option. 
  24400.  
  24401.  
  24402. ΓòÉΓòÉΓòÉ 19.126. EDC0249 ΓòÉΓòÉΓòÉ
  24403.  
  24404. The number of errors exceeds the limit. 
  24405.  
  24406. The number of errors has exceeded the number specified on the /N option. 
  24407.  
  24408. Recovery: Fix the errors or increase the error limit on the /N option. 
  24409.  
  24410.  
  24411. ΓòÉΓòÉΓòÉ 19.127. EDC0250 ΓòÉΓòÉΓòÉ
  24412.  
  24413. The maximum number of errors for one line has been exceeded. 
  24414.  
  24415. The compiler is unable to specify the location of each error in the listing 
  24416. because there are too many errors on one line. 
  24417.  
  24418. Recovery: Correct the errors or split the source line into multiple lines. 
  24419.  
  24420.  
  24421. ΓòÉΓòÉΓòÉ 19.128. EDC0251 ΓòÉΓòÉΓòÉ
  24422.  
  24423. The physical size of an array is too large. 
  24424.  
  24425. The compiler cannot handle any size which is too large to be represented 
  24426. internally. 
  24427.  
  24428. Recovery: Reduce the size of the array. 
  24429.  
  24430.  
  24431. ΓòÉΓòÉΓòÉ 19.129. EDC0252 ΓòÉΓòÉΓòÉ
  24432.  
  24433. The physical size of a struct or union is too large. 
  24434.  
  24435. The compiler cannot handle any size which is too large to be represented 
  24436. internally. 
  24437.  
  24438. Recovery: Reduce the sizes of the struct or union members. 
  24439.  
  24440.  
  24441. ΓòÉΓòÉΓòÉ 19.130. EDC0260 ΓòÉΓòÉΓòÉ
  24442.  
  24443. Declaration cannot specify multiple sign type specifiers. 
  24444.  
  24445. A declaration can specify a signed or unsigned type, but not both. 
  24446.  
  24447. Recovery: Keep only one sign type specifier. 
  24448.  
  24449.  
  24450. ΓòÉΓòÉΓòÉ 19.131. EDC0261 ΓòÉΓòÉΓòÉ
  24451.  
  24452. Declaration cannot specify multiple length type specifiers. 
  24453.  
  24454. A declaration can specify a long or short type, but not both. 
  24455.  
  24456. Recovery: Keep only one length type specifier. 
  24457.  
  24458.  
  24459. ΓòÉΓòÉΓòÉ 19.132. EDC0262 ΓòÉΓòÉΓòÉ
  24460.  
  24461. Declaration cannot specify multiple type specifiers. 
  24462.  
  24463. A declaration can specify only one data type specifier.  Valid specifiers 
  24464. include: char, int, float and double. 
  24465.  
  24466. Recovery: Keep only one type specifier. 
  24467.  
  24468.  
  24469. ΓòÉΓòÉΓòÉ 19.133. EDC0263 ΓòÉΓòÉΓòÉ
  24470.  
  24471. Declaration cannot specify multiple linkage specifiers. 
  24472.  
  24473. A declaration can specify only one linkage type.  Valid linkage types include: 
  24474. _System, _Optlink, _Far16, _Cdecl, _Pascal, and _Fastcall. 
  24475.  
  24476. Recovery: Use only one linkage type, or _Far16 with one of _Cdecl, _Pascal or 
  24477. _Fastcall. 
  24478.  
  24479.  
  24480. ΓòÉΓòÉΓòÉ 19.134. EDC0265 ΓòÉΓòÉΓòÉ
  24481.  
  24482. Declaration cannot specify multiple storage class specifiers. 
  24483.  
  24484. A declaration can specify only one storage class.  Valid storage classes 
  24485. include: auto, static, extern, register and typedef. 
  24486.  
  24487. Recovery: Use only one storage class specifier. 
  24488.  
  24489.  
  24490. ΓòÉΓòÉΓòÉ 19.135. EDC0266 ΓòÉΓòÉΓòÉ
  24491.  
  24492. The &1 type specifier cannot be used with float or double. 
  24493.  
  24494. The type specifiers signed, unsigned and short cannot be used with type float 
  24495. or double. 
  24496.  
  24497. Recovery: Ensure that the appropriate type is used, and remove the incorrect 
  24498. type specifier from the declaration.  Use type long double if a larger 
  24499. identifier is required. 
  24500.  
  24501.  
  24502. ΓòÉΓòÉΓòÉ 19.136. EDC0268 ΓòÉΓòÉΓòÉ
  24503.  
  24504. The long type specifier cannot be used with float. 
  24505.  
  24506. Recovery: Remove the long type specifier or use double instead of float. 
  24507.  
  24508.  
  24509. ΓòÉΓòÉΓòÉ 19.137. EDC0269 ΓòÉΓòÉΓòÉ
  24510.  
  24511. The long or short type specifier cannot be used with char. 
  24512.  
  24513. Recovery: Remove the length type specifier.  Use type int or short int if a 
  24514. larger identifier is required. 
  24515.  
  24516.  
  24517. ΓòÉΓòÉΓòÉ 19.138. EDC0270 ΓòÉΓòÉΓòÉ
  24518.  
  24519. The &1 type specifier cannot be used with void. 
  24520.  
  24521. No other type specifier can be used with type void. 
  24522.  
  24523. Recovery: Remove the type specifier or the void. 
  24524.  
  24525.  
  24526. ΓòÉΓòÉΓòÉ 19.139. EDC0272 ΓòÉΓòÉΓòÉ
  24527.  
  24528. The &1 type specifier cannot be used with struct, union or enum. 
  24529.  
  24530. No other type specifiers can be used with struct, union or enum. 
  24531.  
  24532. Recovery: Remove the type specifier. 
  24533.  
  24534.  
  24535. ΓòÉΓòÉΓòÉ 19.140. EDC0274 ΓòÉΓòÉΓòÉ
  24536.  
  24537. The &1 type specifier cannot be used for variables declared with a typedef. 
  24538.  
  24539. No other type specifiers can be used for variables declared with a typedef. 
  24540.  
  24541. Recovery: Remove the type specifier or the typedef. 
  24542.  
  24543.  
  24544. ΓòÉΓòÉΓòÉ 19.141. EDC0275 ΓòÉΓòÉΓòÉ
  24545.  
  24546. The predefined macro &1 is being redefined. 
  24547.  
  24548. The macro &1 is predefined.  Predefined macros should not be redefined. 
  24549.  
  24550. Recovery: Ensure that you really do want to redefine the macro. 
  24551.  
  24552.  
  24553. ΓòÉΓòÉΓòÉ 19.142. EDC0276 ΓòÉΓòÉΓòÉ
  24554.  
  24555. The predefined macro &1 is being undefined. 
  24556.  
  24557. The macro &1 is predefined.  Predefined macros should not be undefined. 
  24558.  
  24559. Recovery: Ensure that you really do want to undefine the macro. 
  24560.  
  24561.  
  24562. ΓòÉΓòÉΓòÉ 19.143. EDC0277 ΓòÉΓòÉΓòÉ
  24563.  
  24564. _Packed can only qualify a struct or union. 
  24565.  
  24566. Recovery: Remove the _Packed specifier from the declaration/definition, or 
  24567. ensure it qualifies a struct or union. 
  24568.  
  24569.  
  24570. ΓòÉΓòÉΓòÉ 19.144. EDC0278 ΓòÉΓòÉΓòÉ
  24571.  
  24572. Declaration cannot specify multiple &1 specifiers. 
  24573.  
  24574. Recovery: Ensure that only one &1 specifier is used. 
  24575.  
  24576.  
  24577. ΓòÉΓòÉΓòÉ 19.145. EDC0279 ΓòÉΓòÉΓòÉ
  24578.  
  24579. _Seg16 can only qualify a pointer type. 
  24580.  
  24581. Recovery: Remove the _Seg16 specifier from the declaration/definition, or 
  24582. ensure it qualifies a pointer. 
  24583.  
  24584.  
  24585. ΓòÉΓòÉΓòÉ 19.146. EDC0280 ΓòÉΓòÉΓòÉ
  24586.  
  24587. The predefined macro &1 cannot be redefined. 
  24588.  
  24589. An attempt to redefine a predefined macro by using either #define in your code 
  24590. or /D on the command line was encountered.  Certain predifined macros cannot be 
  24591. redefined. 
  24592.  
  24593. Recovery: Remove the #define or /D. 
  24594.  
  24595.  
  24596. ΓòÉΓòÉΓòÉ 19.147. EDC0281 ΓòÉΓòÉΓòÉ
  24597.  
  24598. The identifier &1 cannot be redeclared. 
  24599.  
  24600. Only external objects can be redeclared. 
  24601.  
  24602. Recovery: Delete or change the name of the extra declaration. 
  24603.  
  24604.  
  24605. ΓòÉΓòÉΓòÉ 19.148. EDC0282 ΓòÉΓòÉΓòÉ
  24606.  
  24607. The struct member &1 cannot be redeclared. 
  24608.  
  24609. The same struct member cannot be redeclared.  To redeclare the structure 
  24610. itself, the same tag must be used. 
  24611.  
  24612. Recovery: Delete or change the name of the extra declaration. 
  24613.  
  24614.  
  24615. ΓòÉΓòÉΓòÉ 19.149. EDC0283 ΓòÉΓòÉΓòÉ
  24616.  
  24617. The tag &1 cannot be redefined as a tag of another type. 
  24618.  
  24619. The tag is already associated with another struct, union or enum type. 
  24620.  
  24621. Recovery: Delete or rename the tag. 
  24622.  
  24623.  
  24624. ΓòÉΓòÉΓòÉ 19.150. EDC0284 ΓòÉΓòÉΓòÉ
  24625.  
  24626. The label &1 cannot be redefined. 
  24627.  
  24628. The label has already been defined in the function (a label of the same name 
  24629. followed by a colon and a section of code already appeared in the same 
  24630. function).  It is not valid to redefine a label. 
  24631.  
  24632. Recovery: Change the name of one label. 
  24633.  
  24634.  
  24635. ΓòÉΓòÉΓòÉ 19.151. EDC0285 ΓòÉΓòÉΓòÉ
  24636.  
  24637. The predefined macro &1 cannot be undefined. 
  24638.  
  24639. You tried to undefine a predefined macro by using either #undef in your code or 
  24640. /U on the command line.  You are not allowed to undefine certain predefined 
  24641. macros. 
  24642.  
  24643. Recovery: Remove the #undef or /U. 
  24644.  
  24645.  
  24646. ΓòÉΓòÉΓòÉ 19.152. EDC0286 ΓòÉΓòÉΓòÉ
  24647.  
  24648. The redeclaration cannot specify a different storage class. 
  24649.  
  24650. The redeclaration, including type qualifiers (const, volatile), must be 
  24651. identical to the first declaration. Redeclaring basic types: The type (which 
  24652. includes the type specifiers and the length and sign adjectives) and the type 
  24653. qualifiers (const, volatile) must be the same. Redeclaring functions: The 
  24654. return type with its type qualifiers has to be the same.  If the function has 
  24655. been prototyped, the prototyped redeclarations must have an identical parameter 
  24656. list (the number and type of the parameters must be the same). Redeclaring 
  24657. pointers: They have to point at the same type (including the type qualifiers). 
  24658. Redeclaring arrays: Their members must be of the same type (including the type 
  24659. qualifiers).  The array size must be the same. Redeclaring enumerations, 
  24660. structures, and unions: They must have the same tag. 
  24661.  
  24662. Recovery: Ensure that the storage class of the subsequent declarations matches 
  24663. the original declaration or remove one of the declarations. 
  24664.  
  24665.  
  24666. ΓòÉΓòÉΓòÉ 19.153. EDC0287 ΓòÉΓòÉΓòÉ
  24667.  
  24668. The goto label is not defined in function &1. 
  24669.  
  24670. The goto label is referenced but not defined in the function. The label 
  24671. definition (label followed by a colon and a section of code) must appear in the 
  24672. same function that references the label. 
  24673.  
  24674. Recovery: Define the goto label in the function or remove the reference. 
  24675.  
  24676.  
  24677. ΓòÉΓòÉΓòÉ 19.154. EDC0288 ΓòÉΓòÉΓòÉ
  24678.  
  24679. The void type can only be used with functions and pointers. 
  24680.  
  24681. The type void can only be used as the return type or parameter list of a 
  24682. function, or with a pointer indicating the type to which it is pointed.  No 
  24683. other object can be of type void. 
  24684.  
  24685. Recovery: Ensure that the declaration uses type void correctly. 
  24686.  
  24687.  
  24688. ΓòÉΓòÉΓòÉ 19.155. EDC0289 ΓòÉΓòÉΓòÉ
  24689.  
  24690. The typedef name &1 cannot be redefined. 
  24691.  
  24692. Redefinitions of typedef names are not allowed even if the definitions occur at 
  24693. file scope with identical type specifiers. 
  24694.  
  24695. Recovery: Remove identical definitions or, for a new definition, rename the 
  24696. typedef. 
  24697.  
  24698.  
  24699. ΓòÉΓòÉΓòÉ 19.156. EDC0291 ΓòÉΓòÉΓòÉ
  24700.  
  24701. The &1 storage class cannot be used with external identifier &2. 
  24702.  
  24703. Identifiers may only be declared with auto or register storage class if they 
  24704. are declared inside a block. 
  24705.  
  24706. Recovery: Remove the storage class specifier or change the scope of the 
  24707. identifier so that it is no longer at file scope. 
  24708.  
  24709.  
  24710. ΓòÉΓòÉΓòÉ 19.157. EDC0292 ΓòÉΓòÉΓòÉ
  24711.  
  24712. The block scope declaration of object &1 must be compatible with its external 
  24713. declaration. 
  24714.  
  24715. This block scope redeclaration of the external object is incompatible with the 
  24716. previous external declaration. 
  24717.  
  24718. Recovery: Ensure that the block scope declaration is identical with the file 
  24719. scope declaration, or remove one of the declarations. 
  24720.  
  24721.  
  24722. ΓòÉΓòÉΓòÉ 19.158. EDC0293 ΓòÉΓòÉΓòÉ
  24723.  
  24724. The static storage class cannot be used with functions declared at block scope. 
  24725.  
  24726. Recovery: Place the declaration of the static function at file scope, or remove 
  24727. the storage class specifier. 
  24728.  
  24729.  
  24730. ΓòÉΓòÉΓòÉ 19.159. EDC0294 ΓòÉΓòÉΓòÉ
  24731.  
  24732. The typedef storage class cannot be used on function definitions. 
  24733.  
  24734. The typedef storage class can only be used with function declarations to 
  24735. declare a function type.  A typedef name cannot carry the information of a 
  24736. function definition; it cannot specify the part of code to be executed when a 
  24737. function is called. 
  24738.  
  24739. Recovery: Remove the typedef storage class. 
  24740.  
  24741.  
  24742. ΓòÉΓòÉΓòÉ 19.160. EDC0297 ΓòÉΓòÉΓòÉ
  24743.  
  24744. Only functions or typedefs of functions can be given a linkage type. 
  24745.  
  24746. Either a #pragma linkage or a linkage keyword has been applied to an identifier 
  24747. which does not correspond to a function type or a typedef to a function type. 
  24748.  
  24749. Recovery: If the error applies to an identifier used on a #pragma linkage 
  24750. directive, then change the name specified on the #pragma linkage directive or 
  24751. remove the directive.  If the error applies to an identifier used with a 
  24752. linkage keyword, then remove the keyword. 
  24753.  
  24754.  
  24755. ΓòÉΓòÉΓòÉ 19.161. EDC0298 ΓòÉΓòÉΓòÉ
  24756.  
  24757. A #pragma &1 directive was previously specified for the object &2. 
  24758.  
  24759. More than one #pragma linkage directive was specified for the same object. 
  24760.  
  24761. Recovery: Remove the extra #pragma linkage directives. 
  24762.  
  24763.  
  24764. ΓòÉΓòÉΓòÉ 19.162. EDC0299 ΓòÉΓòÉΓòÉ
  24765.  
  24766. A map name was previously given to the object &1. 
  24767.  
  24768. An object can map to only one name. 
  24769.  
  24770. Option: See map for more information on #pragma map. 
  24771.  
  24772. Recovery: Remove the extra #pragma map directives. 
  24773.  
  24774.  
  24775. ΓòÉΓòÉΓòÉ 19.163. EDC0300 ΓòÉΓòÉΓòÉ
  24776.  
  24777. The floating point constant is not valid. 
  24778.  
  24779. See Floating-Point Constants for a description of a floating-point constant. 
  24780.  
  24781. Recovery: Ensure that the floating-point constant does not contain any 
  24782. characters that are not valid. 
  24783.  
  24784.  
  24785. ΓòÉΓòÉΓòÉ 19.164. EDC0301 ΓòÉΓòÉΓòÉ
  24786.  
  24787. A const qualified object cannot be modified. 
  24788.  
  24789. The value of a const cannot be changed.  Increment/decrement can only be 
  24790. performed on objects that are not constants. 
  24791.  
  24792. Recovery: Either do not declare the object with the const type qualifier, or do 
  24793. not use the object in an increment/decrement operation. 
  24794.  
  24795.  
  24796. ΓòÉΓòÉΓòÉ 19.165. EDC0303 ΓòÉΓòÉΓòÉ
  24797.  
  24798. Only function names can be specified in a #pragma &1 directive. 
  24799.  
  24800. Recovery: Ensure that the spelling of the function name is correct and that the 
  24801. function name has been declared before you use it in this directive. 
  24802.  
  24803.  
  24804. ΓòÉΓòÉΓòÉ 19.166. EDC0306 ΓòÉΓòÉΓòÉ
  24805.  
  24806. Only #pragma pit(*, ...) is allowed with the /Tp- option. 
  24807.  
  24808.  
  24809. ΓòÉΓòÉΓòÉ 19.167. EDC0307 ΓòÉΓòÉΓòÉ
  24810.  
  24811. The floating-point constant is too large and is converted to an infinity. 
  24812.  
  24813. The magnitude of the floating-point constant specified is too large. The number 
  24814. is converted into positive or negative infinity, depending on the sign of the 
  24815. number. 
  24816.  
  24817. Recovery: Ensure this is what was intended. 
  24818.  
  24819.  
  24820. ΓòÉΓòÉΓòÉ 19.168. EDC0308 ΓòÉΓòÉΓòÉ
  24821.  
  24822. An enum constant must be an integral constant expression that has a value 
  24823. representable as an int. 
  24824.  
  24825. If an enum constant is initialized in the definition of an enum tag, the value 
  24826. that the constant is initialized to must be an integral expression that has a 
  24827. value representable as an int. 
  24828.  
  24829. Recovery: Remove the initial value, or ensure that the initial value is an 
  24830. integral constant expression that has a value representable as an int. 
  24831.  
  24832.  
  24833. ΓòÉΓòÉΓòÉ 19.169. EDC0309 ΓòÉΓòÉΓòÉ
  24834.  
  24835. A linkage type must appear to the left of the identifier to which it applies. 
  24836.  
  24837. A declaration has been discovered which resembles int foo _System ();  The 
  24838. keyword _System must appear immediately to the left of the identifier foo. 
  24839.  
  24840. Recovery: Move the linkage descriptors to the left of the identifier. 
  24841.  
  24842.  
  24843. ΓòÉΓòÉΓòÉ 19.170. EDC0310 ΓòÉΓòÉΓòÉ
  24844.  
  24845. The typedef name &1 has already been given the same definition. 
  24846.  
  24847. The typedef name has already been declared with the same type as this 
  24848. declaration gives it.  Redeclaring a typedef at the same scope is not portable 
  24849. and might not be supported by other compilers. 
  24850.  
  24851. Option: /Wpor 
  24852.  
  24853. Recovery: Remove identical definitions or, for a new definition, rename the 
  24854. typedef. 
  24855.  
  24856.  
  24857. ΓòÉΓòÉΓòÉ 19.171. EDC0311 ΓòÉΓòÉΓòÉ
  24858.  
  24859. #pragma &1 overrides command line option &2. 
  24860.  
  24861. The option set in the #pragma statement conflicts with the option set in the 
  24862. command line. 
  24863.  
  24864. Recovery: Remove or change the #pragma statement or the command line option. 
  24865.  
  24866.  
  24867. ΓòÉΓòÉΓòÉ 19.172. EDC0312 ΓòÉΓòÉΓòÉ
  24868.  
  24869. Value &1 specified in #pragma &2 is out of range. 
  24870.  
  24871. In #pragma margins and #pragma sequence, the value specified for the right 
  24872. margin or sequence column must be greater than or equal to the value specified 
  24873. for the left margin or sequence column.  The values specified for the left and 
  24874. right margins or sequence columns must lie in the range 
  24875.  
  24876. Option: 1 to 65535. 
  24877.  
  24878. Recovery: Change the value specified for the left or right margin or sequence 
  24879. column. 
  24880.  
  24881.  
  24882. ΓòÉΓòÉΓòÉ 19.173. EDC0321 ΓòÉΓòÉΓòÉ
  24883.  
  24884. Redeclaration has different number of parameters from the previous declaration. 
  24885.  
  24886. The prototyped redeclaration of the function is not correct. The redeclaration 
  24887. must specify the same number of parameters as the previous declaration. 
  24888.  
  24889. Recovery: Make the redeclaration consistent with the original declaration. 
  24890.  
  24891.  
  24892. ΓòÉΓòÉΓòÉ 19.174. EDC0322 ΓòÉΓòÉΓòÉ
  24893.  
  24894. Type of the parameter &1 cannot conflict with previous declaration of function 
  24895. &2. 
  24896.  
  24897. The type of this parameter is incompatible with the type of the corresponding 
  24898. parameter in the previous declaration of the function. 
  24899.  
  24900. Recovery: Ensure that the subsequent declaration or function call matches the 
  24901. prototype in both the number and type of parameters.  If the parameter in the 
  24902. prototype is an incomplete struct or union tag, declare the incomplete tag at 
  24903. file scope before the function is prototyped. 
  24904.  
  24905.  
  24906. ΓòÉΓòÉΓòÉ 19.175. EDC0323 ΓòÉΓòÉΓòÉ
  24907.  
  24908. Redeclaration cannot specify fewer parameters before ellipsis than the previous 
  24909. declaration. 
  24910.  
  24911. The prototyped redeclaration of the function is not correct. Fewer parameters 
  24912. appear before the ellipsis in this function redeclaration than the previous 
  24913. declaration. 
  24914.  
  24915. Recovery: Ensure that the redeclaration is consistent with the previous 
  24916. declaration. 
  24917.  
  24918.  
  24919. ΓòÉΓòÉΓòÉ 19.176. EDC0324 ΓòÉΓòÉΓòÉ
  24920.  
  24921. The void type specifier cannot be used with other type specifiers. 
  24922.  
  24923. When void is used in the parameter list of a prototyped function declaration, 
  24924. it indicates that the function does not expect any parameters.  Therefore, if 
  24925. void is used in a prototyped declaration, it must be the only type descriptor 
  24926. in the parameter list and must not appear more than once in the list. 
  24927.  
  24928. Recovery: If the function does not require any parameters, use void only once 
  24929. in the parameter list.  If the function requires parameters, remove void from 
  24930. the parameter prototype list. 
  24931.  
  24932.  
  24933. ΓòÉΓòÉΓòÉ 19.177. EDC0325 ΓòÉΓòÉΓòÉ
  24934.  
  24935. The type of the parameters must be specified in a prototype. 
  24936.  
  24937. A prototype specifies the number and the type of the parameters that a function 
  24938. requires.  A prototype that does not specify the type of the parameters is not 
  24939. correct, for example, 
  24940.  
  24941. Option: 
  24942.  
  24943.   fred(a,b);
  24944.  
  24945. Recovery: Specify the type of the parameters in the function prototype. 
  24946.  
  24947.  
  24948. ΓòÉΓòÉΓòÉ 19.178. EDC0326 ΓòÉΓòÉΓòÉ
  24949.  
  24950. The only storage class that can be used with parameters is register. 
  24951.  
  24952. Recovery: Remove the storage class specified in the parameter declaration or 
  24953. use the register storage class. 
  24954.  
  24955.  
  24956. ΓòÉΓòÉΓòÉ 19.179. EDC0327 ΓòÉΓòÉΓòÉ
  24957.  
  24958. Redeclarations and function calls must be compatible with prototype. 
  24959.  
  24960. The number or the type of the parameters (or both) on the call does not agree 
  24961. with the specification given in the function prototype declaration. 
  24962.  
  24963. Recovery: Make the call consistent with the declaration. 
  24964.  
  24965.  
  24966. ΓòÉΓòÉΓòÉ 19.180. EDC0328 ΓòÉΓòÉΓòÉ
  24967.  
  24968. The function call cannot have more arguments than the prototype specifies. 
  24969.  
  24970. The function call is not valid.  There are more arguments in this function call 
  24971. than there were parameters specified in the function declaration. 
  24972.  
  24973. Recovery: Make the call consistent with the declaration. 
  24974.  
  24975.  
  24976. ΓòÉΓòÉΓòÉ 19.181. EDC0329 ΓòÉΓòÉΓòÉ
  24977.  
  24978. Object &1 must be specified in the parameter list for function &2. 
  24979.  
  24980. For function definitions that do not use the prototype style, a list of 
  24981. parameter names usually appears between the parentheses following the function 
  24982. name.  A list of declarations that indicates the type of the parameters 
  24983. follows.  In this case, the declaration of an object that was not listed 
  24984. between the parentheses was found in the parameter declaration list. 
  24985.  
  24986. Recovery: Ensure that the declaration list only specified parameters that 
  24987. appear between the parentheses of the function. 
  24988.  
  24989.  
  24990. ΓòÉΓòÉΓòÉ 19.182. EDC0330 ΓòÉΓòÉΓòÉ
  24991.  
  24992. A parameter cannot be declared when function &1 parentheses are empty. 
  24993.  
  24994. For function definitions that do not use the prototype style, a list of 
  24995. parameter names usually appears between parentheses following the function 
  24996. name.  A list of declarations that indicates the type of the parameters 
  24997. follows.  In this case, objects are declared in the parameter declaration list 
  24998. but no parameter appeared between the function parentheses. 
  24999.  
  25000. Recovery: Ensure that the declaration list only specifies parameters that were 
  25001. listed between the function parentheses. 
  25002.  
  25003.  
  25004. ΓòÉΓòÉΓòÉ 19.183. EDC0331 ΓòÉΓòÉΓòÉ
  25005.  
  25006. Parentheses must appear in the declaration of function &1. 
  25007.  
  25008. The syntax of the declaration is not correct.  The compiler assumes it is the 
  25009. declaration of a function in which the parentheses surrounding the parameters 
  25010. are missing. 
  25011.  
  25012. Recovery: Check the syntax of the declaration.  Ensure the object name and type 
  25013. are properly specified.  Check for incorrect spelling or missing parentheses. 
  25014.  
  25015.  
  25016. ΓòÉΓòÉΓòÉ 19.184. EDC0333 ΓòÉΓòÉΓòÉ
  25017.  
  25018. The parameters in the definition of the function &1 must be named. 
  25019.  
  25020. For function definitions, all the parameters in the parameter list must be 
  25021. named.  It is not valid to specify only the parameter's type in a function 
  25022. definition head. 
  25023.  
  25024. Recovery: Name the parameters in the parameter list. 
  25025.  
  25026.  
  25027. ΓòÉΓòÉΓòÉ 19.185. EDC0334 ΓòÉΓòÉΓòÉ
  25028.  
  25029. External identifier &1 cannot be initialized more than once. 
  25030.  
  25031. Recovery: Check the previous declarations of the object.  Ensure that only one 
  25032. declaration specifies an initializer. 
  25033.  
  25034.  
  25035. ΓòÉΓòÉΓòÉ 19.186. EDC0335 ΓòÉΓòÉΓòÉ
  25036.  
  25037. The declarations of the function &1 must be consistent in their use of the 
  25038. ellipsis. 
  25039.  
  25040. If an ellipsis is used in a function declaration, the ellipsis must be present 
  25041. in all the function redeclarations.  If no ellipsis is used in a function 
  25042. declaration, the following redeclarations cannot specify an ellipsis.  Any 
  25043. redeclaration that does not use the ellipsis consistently is not correct. 
  25044.  
  25045. Recovery: Make the redeclaration consistent with the previous declaration. 
  25046.  
  25047.  
  25048. ΓòÉΓòÉΓòÉ 19.187. EDC0337 ΓòÉΓòÉΓòÉ
  25049.  
  25050. Declaration list cannot appear when parameters in parentheses are prototyped. 
  25051.  
  25052. For function definitions that do not use the prototype style, a list of 
  25053. parameter names usually appears between parentheses following the function 
  25054. name.  A list of declarations that indicates the type of parameters follows. 
  25055. In this case, the parameters between the parentheses are prototyped.  These two 
  25056. styles of declaration cannot be mixed. 
  25057.  
  25058. Recovery: Remove either the function declaration list or the type given to the 
  25059. parameters in the function parentheses. 
  25060.  
  25061.  
  25062. ΓòÉΓòÉΓòÉ 19.188. EDC0338 ΓòÉΓòÉΓòÉ
  25063.  
  25064. Prototype &1 must contain widened types if prototype and nonprototype 
  25065. declarations are mixed. 
  25066.  
  25067. Nonprototype function declarations, popularly known as K&R prototypes, only 
  25068. specify the function return type.  The function parentheses are empty; no 
  25069. information about the parameters is given. 
  25070.  
  25071. Nonprototype function definitions specify a list of parameter names appearing 
  25072. between the function parentheses followed by a list of declarations (located 
  25073. between the parentheses and the opening left brace of the function) that 
  25074. indicates the type of the parameters.  A nonprototype function definition is 
  25075. also known as a K&R function definition. 
  25076.  
  25077. A prototype function declaration or definition specifies the type and the 
  25078. number of the parameters in the parameter declaration list that appears inside 
  25079. the function parenthesis.  A prototype function declaration is better known as 
  25080. an ANSI prototype, and a prototype function definition is better known as an 
  25081. ANSI function definition. 
  25082.  
  25083. When the nonprototype function declarations/definitions are mixed with 
  25084. prototype declarations, the type of each prototype parameter must be compatible 
  25085. with the type that results from the application of the default argument 
  25086. promotions. 
  25087.  
  25088. Most types are already compatible with their default argument promotions.  The 
  25089. only ones that aren't are char, short, and float.  Their promoted versions are, 
  25090. respectively, int, int, and double. 
  25091.  
  25092. This message can occur in several situations.  The most common is when mixing 
  25093. ANSI prototypes with K&R function definitions.  If a function is defined using 
  25094. a K&R-style header, then its prototype, if present, must specify widened 
  25095. versions of the parameter types.  Here is an example. 
  25096.  
  25097.   int function( short );
  25098.   int function( x )
  25099.     short x;
  25100.   {  }
  25101.  
  25102. This is not valid because the function has a K&R-style definition and the 
  25103. prototype does not specify the widened version of the parameter. To be correct, 
  25104. the prototype should be 
  25105.  
  25106.   int function( int );
  25107.  
  25108. becuase int is the widened version of short. 
  25109.  
  25110. Another possible solution is to change the function definition to use ANSI 
  25111. syntax.  This particular example would be changed to 
  25112.  
  25113.   int function( short );
  25114.   int function( short x )
  25115.   {  }
  25116.  
  25117. This second solution is preferable, but either solution is equally valid. 
  25118.  
  25119. Recovery: Give a promoted type to the parameter in the prototype function 
  25120. declaration. 
  25121.  
  25122.  
  25123. ΓòÉΓòÉΓòÉ 19.189. EDC0339 ΓòÉΓòÉΓòÉ
  25124.  
  25125. The function cannot be redeclared with a different linkage type. 
  25126.  
  25127. The redeclaration of this function cannot have a different linkage type than 
  25128. the previous declaration.  The function could have been given a linkage type 
  25129. through a #pragma linkage directive, a typedef, or via a previous declaration. 
  25130.  
  25131. Recovery: Ensure that the linkage type of the subsequent declarations matches 
  25132. the original declaration or remove one of the declarations. 
  25133.  
  25134.  
  25135. ΓòÉΓòÉΓòÉ 19.190. EDC0340 ΓòÉΓòÉΓòÉ
  25136.  
  25137. The enum cannot be packed to the requested size of &1. 
  25138.  
  25139. /Su1 or /Su2 was specified, but the largest member of the enum will not fit 
  25140. within a one or two byte integer.  It will be packed into the smallest integral 
  25141. type that can contain all members. 
  25142.  
  25143. Recovery: Ignore warning, or specify a larger size via the /Su option. 
  25144.  
  25145.  
  25146. ΓòÉΓòÉΓòÉ 19.191. EDC0347 ΓòÉΓòÉΓòÉ
  25147.  
  25148. Syntax error: possible missing &1 or &2. 
  25149.  
  25150. A syntax error has occurred. This message lists the tokens that the parser 
  25151. expected and did not find. 
  25152.  
  25153. Recovery: Correct the syntax error and compile again. 
  25154.  
  25155.  
  25156. ΓòÉΓòÉΓòÉ 19.192. EDC0348 ΓòÉΓòÉΓòÉ
  25157.  
  25158. Syntax error: possible missing &1. 
  25159.  
  25160. A syntax error has occurred. This message lists the tokens that the parser 
  25161. expected and did not find. 
  25162.  
  25163. Recovery: Correct the syntax error and compile again. 
  25164.  
  25165.  
  25166. ΓòÉΓòÉΓòÉ 19.193. EDC0349 ΓòÉΓòÉΓòÉ
  25167.  
  25168. Unexpected text &1 ignored. 
  25169.  
  25170. A syntax error has occurred. This message lists the tokens that were discarded 
  25171. by the parser when it tried to recover from the syntax error. 
  25172.  
  25173. Recovery: Correct the syntax error and compile again. 
  25174.  
  25175.  
  25176. ΓòÉΓòÉΓòÉ 19.194. EDC0350 ΓòÉΓòÉΓòÉ
  25177.  
  25178. Syntax error. 
  25179.  
  25180. See the other sections in this document for a complete description of C syntax 
  25181. rules. 
  25182.  
  25183. Recovery: Correct the syntax error and compile again. 
  25184.  
  25185.  
  25186. ΓòÉΓòÉΓòÉ 19.195. EDC0351 ΓòÉΓòÉΓòÉ
  25187.  
  25188. &1. 
  25189.  
  25190. General error message. 
  25191.  
  25192. Recovery: General error message. 
  25193.  
  25194.  
  25195. ΓòÉΓòÉΓòÉ 19.196. EDC0354 ΓòÉΓòÉΓòÉ
  25196.  
  25197. &1. 
  25198.  
  25199. General warning message. 
  25200.  
  25201. Recovery: General warning message. 
  25202.  
  25203.  
  25204. ΓòÉΓòÉΓòÉ 19.197. EDC0355 ΓòÉΓòÉΓòÉ
  25205.  
  25206. &1. 
  25207.  
  25208. General informational message. 
  25209.  
  25210. Recovery: General informational message. 
  25211.  
  25212.  
  25213. ΓòÉΓòÉΓòÉ 19.198. EDC0356 ΓòÉΓòÉΓòÉ
  25214.  
  25215. A constant expression cannot contain a comma operator. 
  25216.  
  25217. Recovery: Modify the constant expression to remove the comma operator. 
  25218.  
  25219.  
  25220. ΓòÉΓòÉΓòÉ 19.199. EDC0370 ΓòÉΓòÉΓòÉ
  25221.  
  25222. Operand of offsetof macro must be a struct or a union. 
  25223.  
  25224. The first operand of the offsetof macro must be a structure or union type. 
  25225.  
  25226. Recovery: Change the operand. 
  25227.  
  25228.  
  25229. ΓòÉΓòÉΓòÉ 19.200. EDC0371 ΓòÉΓòÉΓòÉ
  25230.  
  25231. The dot operator cannot be applied to an incomplete struct or union. 
  25232.  
  25233. A structure or union is incomplete when the definition of its tag has not been 
  25234. specified.  A struct or union tag is undefined when the list describing the 
  25235. name and type of its members has not been specified. 
  25236.  
  25237. Recovery: Give a definition of the tag before the operator is applied to the 
  25238. structure. 
  25239.  
  25240.  
  25241. ΓòÉΓòÉΓòÉ 19.201. EDC0372 ΓòÉΓòÉΓòÉ
  25242.  
  25243. The arrow operator cannot be applied to an incomplete struct or union. 
  25244.  
  25245. A structure or union is incomplete when the definition of its tag has not been 
  25246. specified.  A struct or union tag is undefined when the list describing the 
  25247. name and type of its members has not been specified. 
  25248.  
  25249. Recovery: Give a definition of the tag before the operator is applied to the 
  25250. structure. 
  25251.  
  25252.  
  25253. ΓòÉΓòÉΓòÉ 19.202. EDC0397 ΓòÉΓòÉΓòÉ
  25254.  
  25255. Macro argument list is not complete. 
  25256.  
  25257. Either the arguments are not fully specified or a comma or closing parenthesis 
  25258. is missing. 
  25259.  
  25260. Recovery: Complete the specification of the macro argument list. 
  25261.  
  25262.  
  25263. ΓòÉΓòÉΓòÉ 19.203. EDC0398 ΓòÉΓòÉΓòÉ
  25264.  
  25265. The pragma &1 directive for function &2 is not valid. 
  25266.  
  25267. The pragma inline and noinline directives must be issued at file scope in order 
  25268. to take effect. 
  25269.  
  25270. Recovery: Issue the pragma directive at file scope. 
  25271.  
  25272.  
  25273. ΓòÉΓòÉΓòÉ 19.204. EDC0399 ΓòÉΓòÉΓòÉ
  25274.  
  25275. A character constant must contain at least one character. 
  25276.  
  25277. Recovery: Put at least one character inside the pair of single quotation marks. 
  25278.  
  25279.  
  25280. ΓòÉΓòÉΓòÉ 19.205. EDC0400 ΓòÉΓòÉΓòÉ
  25281.  
  25282. String literals must end before the source line unless the continuation symbol 
  25283. is used. 
  25284.  
  25285. String literals must end before the end of the source line. String literals can 
  25286. be constructed which are longer than one line by using the line continuation 
  25287. sequence (backslash (\) at the end of the line) or by using the concatenation 
  25288. of adjacent string literals. 
  25289.  
  25290. Recovery: Either end the string with a quotation mark or use the continuation 
  25291. sequence. 
  25292.  
  25293.  
  25294. ΓòÉΓòÉΓòÉ 19.206. EDC0401 ΓòÉΓòÉΓòÉ
  25295.  
  25296. The character is not valid. 
  25297.  
  25298. A character not in the C source character set has been encountered. 
  25299.  
  25300. Recovery: Remove the character.  Check the syntax. 
  25301.  
  25302.  
  25303. ΓòÉΓòÉΓòÉ 19.207. EDC0403 ΓòÉΓòÉΓòÉ
  25304.  
  25305. The #line directive must specify a string literal or a new-line character. 
  25306.  
  25307. The integer value in the #line directive must be followed by a string literal 
  25308. or the end of the line. 
  25309.  
  25310. Recovery: Correct the #line directive. 
  25311.  
  25312.  
  25313. ΓòÉΓòÉΓòÉ 19.208. EDC0404 ΓòÉΓòÉΓòÉ
  25314.  
  25315. End of file was reached before end of comment that started on line &1. 
  25316.  
  25317. A comment that was not terminated has been detected.  The beginning of the 
  25318. comment was on the specified line. 
  25319.  
  25320. Recovery: End the comment before the file ends. 
  25321.  
  25322.  
  25323. ΓòÉΓòÉΓòÉ 19.209. EDC0405 ΓòÉΓòÉΓòÉ
  25324.  
  25325. A new-line character is required. 
  25326.  
  25327. A character sequence was encountered when the preprocessor required a new-line 
  25328. character. 
  25329.  
  25330.  
  25331. ΓòÉΓòÉΓòÉ 19.210. EDC0406 ΓòÉΓòÉΓòÉ
  25332.  
  25333. Preprocessing token # must be followed by a parameter. 
  25334.  
  25335. The # preprocessor operator may only be applied to a macro parameter. 
  25336.  
  25337. Recovery: Place a parameter after the # token, or remove the token. 
  25338.  
  25339.  
  25340. ΓòÉΓòÉΓòÉ 19.211. EDC0407 ΓòÉΓòÉΓòÉ
  25341.  
  25342. The #include directive is not valid. 
  25343.  
  25344. The #include file specifier is missing or not valid. 
  25345.  
  25346. Recovery: Check the spelling and syntax of the #include file path. 
  25347.  
  25348.  
  25349. ΓòÉΓòÉΓòÉ 19.212. EDC0408 ΓòÉΓòÉΓòÉ
  25350.  
  25351. A #if, #elif, #ifdef or #ifndef block must end with a #endif. 
  25352.  
  25353. Recovery: End the conditional preprocessor statements with a #endif. 
  25354.  
  25355.  
  25356. ΓòÉΓòÉΓòÉ 19.213. EDC0409 ΓòÉΓòÉΓòÉ
  25357.  
  25358. A macro name on #&1 directive is expected. 
  25359.  
  25360. Recovery: Ensure that a macro name follows the #define, #undef, #ifdef, or 
  25361. #ifndef preprocessor directive. 
  25362.  
  25363.  
  25364. ΓòÉΓòÉΓòÉ 19.214. EDC0410 ΓòÉΓòÉΓòÉ
  25365.  
  25366. A #&1 can only appear within a #if, #elif, #ifdef or #ifndef block. 
  25367.  
  25368. Recovery: Delete the #elif or #else statement, or place it within a conditional 
  25369. preprocessor block.  Check for misplaced braces. 
  25370.  
  25371.  
  25372. ΓòÉΓòÉΓòÉ 19.215. EDC0412 ΓòÉΓòÉΓòÉ
  25373.  
  25374. A #endif must follow a #if, #elif, #ifdef or #ifndef block. 
  25375.  
  25376. Recovery: Delete the #endif statement, or place it after a conditional 
  25377. preprocessor block. 
  25378.  
  25379.  
  25380. ΓòÉΓòÉΓòÉ 19.216. EDC0413 ΓòÉΓòÉΓòÉ
  25381.  
  25382. #elif cannot follow #else. 
  25383.  
  25384. The #elif directive may not follow a #else directive within a #if, #elif, 
  25385. #ifdef or #ifndef block. 
  25386.  
  25387. Recovery: Remove the #elif or the #else. 
  25388.  
  25389.  
  25390. ΓòÉΓòÉΓòÉ 19.217. EDC0414 ΓòÉΓòÉΓòÉ
  25391.  
  25392. End of file is not expected. 
  25393.  
  25394. The end of the source file has been encountered prematurely. 
  25395.  
  25396. Recovery: Check for misplaced braces. 
  25397.  
  25398.  
  25399. ΓòÉΓòÉΓòÉ 19.218. EDC0415 ΓòÉΓòÉΓòÉ
  25400.  
  25401. Text is too long. 
  25402.  
  25403. The specified token is too long to be processed.  This condition arises when a 
  25404. numeric literal with many leading zeros or a floating point literal with many 
  25405. trailing digits in the fraction is coded. 
  25406.  
  25407. Recovery: Create a shorter token. 
  25408.  
  25409.  
  25410. ΓòÉΓòÉΓòÉ 19.219. EDC0416 ΓòÉΓòÉΓòÉ
  25411.  
  25412. The integer constant suffix is not valid. 
  25413.  
  25414. The integer constant has a suffix letter that is not recognized as a valid 
  25415. suffix. 
  25416.  
  25417.  
  25418. ΓòÉΓòÉΓòÉ 19.220. EDC0417 ΓòÉΓòÉΓòÉ
  25419.  
  25420. Integer constant is out of range. 
  25421.  
  25422. The specified constant is too large to be represented by an unsigned long int. 
  25423.  
  25424. Recovery: The constant integer must have a value less than 4294967296. 
  25425.  
  25426.  
  25427. ΓòÉΓòÉΓòÉ 19.221. EDC0418 ΓòÉΓòÉΓòÉ
  25428.  
  25429. Escape character &1 is not valid and is ignored. 
  25430.  
  25431. An escape sequence that is not valid has been encountered in a string literal 
  25432. or a character literal.  It is replaced by the character following the 
  25433. backslash (\). 
  25434.  
  25435. Recovery: Change or remove the escape sequence. 
  25436.  
  25437.  
  25438. ΓòÉΓòÉΓòÉ 19.222. EDC0419 ΓòÉΓòÉΓòÉ
  25439.  
  25440. A character literal must end before the end of a line. 
  25441.  
  25442. Character literals must be terminated before the end of the source line. 
  25443.  
  25444. Recovery: End the character literal before the end of the line.  Check for 
  25445. misplaced quotation marks. 
  25446.  
  25447.  
  25448. ΓòÉΓòÉΓòÉ 19.223. EDC0420 ΓòÉΓòÉΓòÉ
  25449.  
  25450. The ## operator cannot appear first or last in the macro replacement list. 
  25451.  
  25452. The ## operator must be preceded and followed by valid tokens in the macro 
  25453. replacement list. 
  25454.  
  25455.  
  25456. ΓòÉΓòÉΓòÉ 19.224. EDC0421 ΓòÉΓòÉΓòÉ
  25457.  
  25458. The macro parameter list is incorrect. 
  25459.  
  25460. The macro parameter list must be empty, contain a single identifier, or contain 
  25461. a list of identifiers separated by commas. 
  25462.  
  25463. Recovery: Correct the parameter list. 
  25464.  
  25465.  
  25466. ΓòÉΓòÉΓòÉ 19.225. EDC0422 ΓòÉΓòÉΓòÉ
  25467.  
  25468. Parameter &1 cannot be redefined in the macro parameter list. 
  25469.  
  25470. The identifiers in the macro parameter list must be distinct. 
  25471.  
  25472. Recovery: Change the identifier name in the parameter list. 
  25473.  
  25474.  
  25475. ΓòÉΓòÉΓòÉ 19.226. EDC0423 ΓòÉΓòÉΓòÉ
  25476.  
  25477. Macro name &1 cannot be redefined. 
  25478.  
  25479. A macro may be defined multiple times only if the definitions are identical 
  25480. except for white space. 
  25481.  
  25482. Recovery: Change the macro definition to be identical to the preceding one, or 
  25483. remove it. 
  25484.  
  25485.  
  25486. ΓòÉΓòÉΓòÉ 19.227. EDC0424 ΓòÉΓòÉΓòÉ
  25487.  
  25488. The expression on the #if or #elif directive is not a valid constant 
  25489. expression. 
  25490.  
  25491. Recovery: Replace the expression that controls #if or #elif by a constant 
  25492. integral expression. 
  25493.  
  25494.  
  25495. ΓòÉΓòÉΓòÉ 19.228. EDC0425 ΓòÉΓòÉΓòÉ
  25496.  
  25497. Parameter list must specify same number of parameters as required by macro 
  25498. definition. 
  25499.  
  25500. The number of arguments specified on a macro invocation is different from the 
  25501. number of parameters required for the macro. 
  25502.  
  25503. Recovery: Make the number of arguments consistent with the macro definition. 
  25504.  
  25505.  
  25506. ΓòÉΓòÉΓòÉ 19.229. EDC0426 ΓòÉΓòÉΓòÉ
  25507.  
  25508. The #error text is too long. 
  25509.  
  25510. The text specified for the #error directive is too long to be processed.  The 
  25511. maximum length allowed for #error text is 4096 characters. 
  25512.  
  25513. Recovery: Specify a shorter message. 
  25514.  
  25515.  
  25516. ΓòÉΓòÉΓòÉ 19.230. EDC0427 ΓòÉΓòÉΓòÉ
  25517.  
  25518. #error &1 
  25519.  
  25520. This is the message issued by the #error directive. 
  25521.  
  25522. Recovery: Because this is a user-created message, the recovery depends on the 
  25523. nature of the error. 
  25524.  
  25525.  
  25526. ΓòÉΓòÉΓòÉ 19.231. EDC0428 ΓòÉΓòÉΓòÉ
  25527.  
  25528. A preprocessing directive must end before the end of a line. 
  25529.  
  25530. The end of line has been encountered while scanning a preprocessing directive. 
  25531.  
  25532.  
  25533. ΓòÉΓòÉΓòÉ 19.232. EDC0429 ΓòÉΓòÉΓòÉ
  25534.  
  25535. String literal cannot exceed maximum length of 4096. 
  25536.  
  25537. A string constant of length greater than 4096 characters was encountered. 
  25538.  
  25539. Recovery: Specify a shorter string literal. 
  25540.  
  25541.  
  25542. ΓòÉΓòÉΓòÉ 19.233. EDC0430 ΓòÉΓòÉΓòÉ
  25543.  
  25544. The preprocessing directive &1 is not valid. 
  25545.  
  25546. An unrecognized preprocessing directive has been encountered. 
  25547.  
  25548. Recovery: Check the spelling and syntax or remove the directive that is not 
  25549. valid. 
  25550.  
  25551.  
  25552. ΓòÉΓòÉΓòÉ 19.234. EDC0431 ΓòÉΓòÉΓòÉ
  25553.  
  25554. The end of a #include file was encountered before the end of the comment. 
  25555.  
  25556. Recovery: End the comment before ending the #include file.  Check for misplaced 
  25557. or missing punctuation. 
  25558.  
  25559.  
  25560. ΓòÉΓòÉΓòÉ 19.235. EDC0432 ΓòÉΓòÉΓòÉ
  25561.  
  25562. The end of file was encountered immediately after a continuation line. 
  25563.  
  25564. Recovery: Remove the continuation character from the last line of the file, or 
  25565. add code after the continuation character. 
  25566.  
  25567.  
  25568. ΓòÉΓòÉΓòÉ 19.236. EDC0433 ΓòÉΓòÉΓòÉ
  25569.  
  25570. #line value too large. 
  25571.  
  25572. Recovery: Ensure that the #line value does not exceed the maximum value (32767) 
  25573. for short integers. 
  25574.  
  25575.  
  25576. ΓòÉΓòÉΓòÉ 19.237. EDC0434 ΓòÉΓòÉΓòÉ
  25577.  
  25578. &1 value must contain only decimal digits. 
  25579.  
  25580. A non-numeric character was encountered in the &1 value. 
  25581.  
  25582. Recovery: Check the syntax of the value given. 
  25583.  
  25584.  
  25585. ΓòÉΓòÉΓòÉ 19.238. EDC0435 ΓòÉΓòÉΓòÉ
  25586.  
  25587. A valid wide character must not have 0x00 as its second byte. 
  25588.  
  25589. Recovery: Change the value of the second byte of the wide character. 
  25590.  
  25591.  
  25592. ΓòÉΓòÉΓòÉ 19.239. EDC0437 ΓòÉΓòÉΓòÉ
  25593.  
  25594. A character string literal cannot be concatenated with a wide string literal. 
  25595.  
  25596. A string that has a prefix L cannot be concatenated with a string that is not 
  25597. prefixed. 
  25598.  
  25599. Recovery: Check the syntax of the value given. 
  25600.  
  25601.  
  25602. ΓòÉΓòÉΓòÉ 19.240. EDC0438 ΓòÉΓòÉΓòÉ
  25603.  
  25604. An error was detected in #pragma &1. 
  25605.  
  25606. For a description of the syntax for #pragma directives, see #pragma of this 
  25607. book. 
  25608.  
  25609. Recovery: Check the syntax of the #pragma directive. 
  25610.  
  25611.  
  25612. ΓòÉΓòÉΓòÉ 19.241. EDC0439 ΓòÉΓòÉΓòÉ
  25613.  
  25614. Option &1 on #pragma &2 is not supported. 
  25615.  
  25616. For a list of all valid options for #pragma directives, see #pragma of this 
  25617. book. 
  25618.  
  25619. Recovery: Ensure the #pragma syntax and options are correct. 
  25620.  
  25621.  
  25622. ΓòÉΓòÉΓòÉ 19.242. EDC0441 ΓòÉΓòÉΓòÉ
  25623.  
  25624. #pragma &1 is unrecognized and is ignored. 
  25625.  
  25626. An unrecognized #pragma directive was encountered.  See #pragma for the list of 
  25627. valid #pragmas available. 
  25628.  
  25629. Recovery: Change or remove the #pragma directive. 
  25630.  
  25631.  
  25632. ΓòÉΓòÉΓòÉ 19.243. EDC0442 ΓòÉΓòÉΓòÉ
  25633.  
  25634. Option on #pragma &1 is out of range. 
  25635.  
  25636. The specified #pragma option is not within the range of the valid values. See 
  25637. #pragma for more information on the #pragma directives. 
  25638.  
  25639. Recovery: Change the option or remove the #pragma directive. 
  25640.  
  25641.  
  25642. ΓòÉΓòÉΓòÉ 19.244. EDC0443 ΓòÉΓòÉΓòÉ
  25643.  
  25644. #pragma &1 must appear on the first directive before any C code. 
  25645.  
  25646. Recovery: Ensure the indicated #pragma appears on the first directive and 
  25647. before any C code. 
  25648.  
  25649.  
  25650. ΓòÉΓòÉΓòÉ 19.245. EDC0444 ΓòÉΓòÉΓòÉ
  25651.  
  25652. The #pragma &1 must appear only once and before any C code. 
  25653.  
  25654. Recovery: Remove all but one of the specified #pragma directives and place the 
  25655. #pragma directive before any C code. 
  25656.  
  25657.  
  25658. ΓòÉΓòÉΓòÉ 19.246. EDC0445 ΓòÉΓòÉΓòÉ
  25659.  
  25660. Only one facility ID can appear on all #pragma pit directives in a compilation 
  25661. unit. 
  25662.  
  25663.  
  25664. ΓòÉΓòÉΓòÉ 19.247. EDC0449 ΓòÉΓòÉΓòÉ
  25665.  
  25666. A new-line is not expected before the end of the preprocessing directive. 
  25667.  
  25668. A new-line was encountered before the preprocessor directive was complete. 
  25669.  
  25670. Recovery: Ensure the preprocessor directive ends before the end of the line. 
  25671.  
  25672.  
  25673. ΓòÉΓòÉΓòÉ 19.248. EDC0450 ΓòÉΓòÉΓòÉ
  25674.  
  25675. Option &1 ignored because option &2 specified. 
  25676.  
  25677. The use of the second option indicated means the first has no effect.  For 
  25678. example, the /P option causes the /O option to be ignored because no code will 
  25679. be generated. 
  25680.  
  25681. Recovery: Remove one of the options. 
  25682.  
  25683.  
  25684. ΓòÉΓòÉΓòÉ 19.249. EDC0451 ΓòÉΓòÉΓòÉ
  25685.  
  25686. The &1 option has not been completely specified. 
  25687.  
  25688. Refer to Specifying Compiler Options for information on specifying compiler 
  25689. options. 
  25690.  
  25691. Recovery: Complete or remove the option. 
  25692.  
  25693.  
  25694. ΓòÉΓòÉΓòÉ 19.250. EDC0452 ΓòÉΓòÉΓòÉ
  25695.  
  25696. Suboption &2 of &1 is not valid. 
  25697.  
  25698. An incorrect suboption of the specified compiler option has been given.  See 
  25699. Specifying Compiler Options for more information on compiler options. 
  25700.  
  25701. Recovery: Change or remove the incorrect suboption. 
  25702.  
  25703.  
  25704. ΓòÉΓòÉΓòÉ 19.251. EDC0455 ΓòÉΓòÉΓòÉ
  25705.  
  25706. Suboption &2 of &1 is out of range. 
  25707.  
  25708. A suboption of the specified compiler option is not within the range of valid 
  25709. values. 
  25710.  
  25711. See Specifying Compiler Options for more information on compiler options. 
  25712.  
  25713. Recovery: Change or remove the suboption. 
  25714.  
  25715.  
  25716. ΓòÉΓòÉΓòÉ 19.252. EDC0456 ΓòÉΓòÉΓòÉ
  25717.  
  25718. Suboptions &2 and &3 of option &1 conflict. 
  25719.  
  25720. Conflicting suboptions of the indicated compiler option have been specified. 
  25721.  
  25722. Recovery: Remove one of the conflicting suboptions. 
  25723.  
  25724.  
  25725. ΓòÉΓòÉΓòÉ 19.253. EDC0460 ΓòÉΓòÉΓòÉ
  25726.  
  25727. Macro name &1 must not begin with a numeric character on &2 option. 
  25728.  
  25729. Macro names must begin with an alphabetic character or an underscore. 
  25730.  
  25731. Recovery: Change the macro name. 
  25732.  
  25733.  
  25734. ΓòÉΓòÉΓòÉ 19.254. EDC0461 ΓòÉΓòÉΓòÉ
  25735.  
  25736. &1 cannot be defined as a macro on the &2 option. 
  25737.  
  25738. Recovery: Remove the macro definition. 
  25739.  
  25740.  
  25741. ΓòÉΓòÉΓòÉ 19.255. EDC0462 ΓòÉΓòÉΓòÉ
  25742.  
  25743. Macro definition on the &1 option is not valid. 
  25744.  
  25745. Recovery: Remove the macro definition or change the macro name. 
  25746.  
  25747.  
  25748. ΓòÉΓòÉΓòÉ 19.256. EDC0463 ΓòÉΓòÉΓòÉ
  25749.  
  25750. Option &1 is not valid. 
  25751.  
  25752. An incorrect compiler option has been encountered.  See Specifying Compiler 
  25753. Options for valid compiler options. 
  25754.  
  25755. Recovery: Change or remove the option. 
  25756.  
  25757.  
  25758. ΓòÉΓòÉΓòÉ 19.257. EDC0464 ΓòÉΓòÉΓòÉ
  25759.  
  25760. Character constant has more than four bytes. 
  25761.  
  25762. A character constant can only have up to four bytes. 
  25763.  
  25764. Option: /Wpor 
  25765.  
  25766. Recovery: Change the character constant to contain four bytes or less. 
  25767.  
  25768.  
  25769. ΓòÉΓòÉΓòÉ 19.258. EDC0465 ΓòÉΓòÉΓòÉ
  25770.  
  25771. Unable to open the default file for &1 output. 
  25772.  
  25773. The intermediate file (with a .I extension) could not be opened when the /P 
  25774. option was specified.  The directory may be full. 
  25775.  
  25776. Recovery: Delete some files from the directory to free some space. 
  25777.  
  25778.  
  25779. ΓòÉΓòÉΓòÉ 19.259. EDC0468 ΓòÉΓòÉΓòÉ
  25780.  
  25781. Macro name &1 on &2 option is already defined. 
  25782.  
  25783. On the /D option a macro may be defined multiple times only if the definitions 
  25784. are identical except for white space. 
  25785.  
  25786. Recovery: Remove all but one of the indicated macro definitions, make them all 
  25787. identical, or change the name of the macro. 
  25788.  
  25789.  
  25790. ΓòÉΓòÉΓòÉ 19.260. EDC0469 ΓòÉΓòÉΓòÉ
  25791.  
  25792. Macro name &1 has been truncated to &2 on the &3 option. 
  25793.  
  25794. The length of the macro name on the /D option is greater than the maximum 
  25795. allowed.  The name has been truncated. 
  25796.  
  25797. Recovery: Change the macro name if necessary. 
  25798.  
  25799.  
  25800. ΓòÉΓòÉΓòÉ 19.261. EDC0470 ΓòÉΓòÉΓòÉ
  25801.  
  25802. Macro name &1 contains characters not valid on the &2 option. 
  25803.  
  25804. Macro names can contain only alphanumeric characters and the underscore 
  25805. character. 
  25806.  
  25807. Recovery: Change the macro name. 
  25808.  
  25809.  
  25810. ΓòÉΓòÉΓòÉ 19.262. EDC0472 ΓòÉΓòÉΓòÉ
  25811.  
  25812. Local options following file name have been ignored. 
  25813.  
  25814. Recovery: Remove local options following file name. 
  25815.  
  25816.  
  25817. ΓòÉΓòÉΓòÉ 19.263. EDC0473 ΓòÉΓòÉΓòÉ
  25818.  
  25819. Missing source or object file. 
  25820.  
  25821. Recovery: Specify a source or object file. 
  25822.  
  25823.  
  25824. ΓòÉΓòÉΓòÉ 19.264. EDC0475 ΓòÉΓòÉΓòÉ
  25825.  
  25826. Option &1 ignored because option &2 is not specified. 
  25827.  
  25828. The second option must be specified for the first to have an effect. For 
  25829. example, to use the /Le option, the /Lf option must also be specified. 
  25830.  
  25831. Recovery: Specify the second option, or remove the first. 
  25832.  
  25833.  
  25834. ΓòÉΓòÉΓòÉ 19.265. EDC0479 ΓòÉΓòÉΓòÉ
  25835.  
  25836. A module definition (.DEF) file must be specified to create a DLL. 
  25837.  
  25838. Recovery: Provide a module definition (.DEF) file. 
  25839.  
  25840.  
  25841. ΓòÉΓòÉΓòÉ 19.266. EDC0480 ΓòÉΓòÉΓòÉ
  25842.  
  25843. Option &1 requires that &2 be specified. 
  25844.  
  25845. Recovery: Specify option &2 on the command line. 
  25846.  
  25847.  
  25848. ΓòÉΓòÉΓòÉ 19.267. EDC0481 ΓòÉΓòÉΓòÉ
  25849.  
  25850. Option &1 is ignored in &2 mode. 
  25851.  
  25852. This compiler option is not supported by &2 mode.  See Specifying Compiler 
  25853. Options for all &2 options. 
  25854.  
  25855. Recovery: Change or remove the options. 
  25856.  
  25857.  
  25858. ΓòÉΓòÉΓòÉ 19.268. EDC0482 ΓòÉΓòÉΓòÉ
  25859.  
  25860. Option /Ol specified, but no source or intermediate file provided. 
  25861.  
  25862. Recovery: Specify a source or intermedicate file. 
  25863.  
  25864.  
  25865. ΓòÉΓòÉΓòÉ 19.269. EDC0483 ΓòÉΓòÉΓòÉ
  25866.  
  25867. Unable to find a complete set of intermediate files, .w, .wh and .wi, for &1. 
  25868.  
  25869. Recovery: Ensure that a complete set of intermediate files (.w, .wh, and wi) is 
  25870. existed corresponding to the intermediate file specified on the command (when 
  25871. the compile command is issued). 
  25872.  
  25873.  
  25874. ΓòÉΓòÉΓòÉ 19.270. EDC0484 ΓòÉΓòÉΓòÉ
  25875.  
  25876. To specify an intermediate file, use &1.w instead of &1&2. 
  25877.  
  25878. Recovery: Specify the intermediate file with .w extension only. 
  25879.  
  25880.  
  25881. ΓòÉΓòÉΓòÉ 19.271. EDC0485 ΓòÉΓòÉΓòÉ
  25882.  
  25883. Cannot declare a pointer to a function with builtin linkage. 
  25884.  
  25885. Recovery: Remove the #pragma linkage or builtin keyword from the declaration of 
  25886. the function. 
  25887.  
  25888.  
  25889. ΓòÉΓòÉΓòÉ 19.272. EDC0486 ΓòÉΓòÉΓòÉ
  25890.  
  25891. Cannot expliticly or implicitly take the address of a function with builtin 
  25892. linkage. 
  25893.  
  25894. The address of a builtin function cannot be determined.  The compiler does not 
  25895. allow for the declaration of a pointer to a builtin function. 
  25896.  
  25897. Recovery: Remove the #pragma linkage or builtin keyword from the declaration of 
  25898. the function. 
  25899.  
  25900.  
  25901. ΓòÉΓòÉΓòÉ 19.273. EDC0487 ΓòÉΓòÉΓòÉ
  25902.  
  25903. Unable to open icc response file &1. 
  25904.  
  25905. Recovery: Ensure file exists. 
  25906.  
  25907.  
  25908. ΓòÉΓòÉΓòÉ 19.274. EDC0488 ΓòÉΓòÉΓòÉ
  25909.  
  25910. Nested response files are not supported. 
  25911.  
  25912. Recovery: Remove all the nesting in the response file. 
  25913.  
  25914.  
  25915. ΓòÉΓòÉΓòÉ 19.275. EDC0489 ΓòÉΓòÉΓòÉ
  25916.  
  25917. The icc command line specification is not valid. 
  25918.  
  25919. When using a response file on the icc command line, no other parameters are 
  25920. allowed and there must be no space between the '@' sign and the response file 
  25921. name. 
  25922.  
  25923. Recovery: Remove all parameters other than the response file on the command 
  25924. line or remove the space between the '@' sign and the response file name. 
  25925.  
  25926.  
  25927. ΓòÉΓòÉΓòÉ 19.276. EDC0490 ΓòÉΓòÉΓòÉ
  25928.  
  25929. Option &1 needs additional listing option to generate a listing. 
  25930.  
  25931. This option only modifies the appearance of a listing; it does not cause a 
  25932. listing to be produced. 
  25933.  
  25934. Recovery: Use this option with one of the other listing file options or the /Fl 
  25935. option to produce a listing. 
  25936.  
  25937.  
  25938. ΓòÉΓòÉΓòÉ 19.277. EDC0491 ΓòÉΓòÉΓòÉ
  25939.  
  25940. The compilation cannot continue because Ctrl-Z (0x1A) was encountered in the 
  25941. response file. 
  25942.  
  25943. The Ctrl-Z (0x1A) is interpreted as end-of-file indicator.  Any characters 
  25944. following will be lost. 
  25945.  
  25946. Recovery: Remove the Ctrl-Z character (0x1A) from the response file. 
  25947.  
  25948.  
  25949. ΓòÉΓòÉΓòÉ 19.278. EDC0501 ΓòÉΓòÉΓòÉ
  25950.  
  25951. Unable to open file for intermediate code. 
  25952.  
  25953. Not able to open intermediate listing file. 
  25954.  
  25955.  
  25956. ΓòÉΓòÉΓòÉ 19.279. EDC0503 ΓòÉΓòÉΓòÉ
  25957.  
  25958. Unable to open listing file &1. 
  25959.  
  25960. The source listing file could not be opened. 
  25961.  
  25962. Recovery: Ensure enough disk space is available. 
  25963.  
  25964.  
  25965. ΓòÉΓòÉΓòÉ 19.280. EDC0504 ΓòÉΓòÉΓòÉ
  25966.  
  25967. Unable to find #include file &1. 
  25968.  
  25969. The file specified on the #include directive could not be found. 
  25970.  
  25971. Recovery: Ensure the #include file name and the search path are correct. 
  25972.  
  25973.  
  25974. ΓòÉΓòÉΓòÉ 19.281. EDC0506 ΓòÉΓòÉΓòÉ
  25975.  
  25976. Unable to find source file &1. 
  25977.  
  25978. Ensure that the name of the file specified on the command line (when the 
  25979. compile command is issued) corresponds to an existing C source file. 
  25980.  
  25981.  
  25982. ΓòÉΓòÉΓòÉ 19.282. EDC0517 ΓòÉΓòÉΓòÉ
  25983.  
  25984. &1 value must be an integer constant. 
  25985.  
  25986. Recovery: Change the value to an integer constant. 
  25987.  
  25988.  
  25989. ΓòÉΓòÉΓòÉ 19.283. EDC0518 ΓòÉΓòÉΓòÉ
  25990.  
  25991. A line number must be specified on a #line directive. 
  25992.  
  25993. Recovery: Specify a line number on the #line directive. 
  25994.  
  25995.  
  25996. ΓòÉΓòÉΓòÉ 19.284. EDC0519 ΓòÉΓòÉΓòÉ
  25997.  
  25998. #line value may not be zero. 
  25999.  
  26000. Recovery: Ensure that the #line value is not zero. 
  26001.  
  26002.  
  26003. ΓòÉΓòÉΓòÉ 19.285. EDC0550 ΓòÉΓòÉΓòÉ
  26004.  
  26005. Macro parameter list must end before the end of the line. 
  26006.  
  26007. The list of parameters for a macro on a #define directive did not end before 
  26008. the end of the line. 
  26009.  
  26010. Recovery: End the parameter list before the end of the line.  Check that all 
  26011. required continuation lines have been coded. 
  26012.  
  26013.  
  26014. ΓòÉΓòÉΓòÉ 19.286. EDC0551 ΓòÉΓòÉΓòÉ
  26015.  
  26016. The #include file header cannot be empty. 
  26017.  
  26018. The #include file header specified is empty. 
  26019.  
  26020. Recovery: Remove the #include directive or ensure that the header is not empty. 
  26021.  
  26022.  
  26023. ΓòÉΓòÉΓòÉ 19.287. EDC0553 ΓòÉΓòÉΓòÉ
  26024.  
  26025. Builtin function &1 is unrecognized. 
  26026.  
  26027.  
  26028. ΓòÉΓòÉΓòÉ 19.288. EDC0630 ΓòÉΓòÉΓòÉ
  26029.  
  26030. Error in allocating memory for intermediate files. 
  26031.  
  26032. Recovery: Ensure enough memory is available. 
  26033.  
  26034.  
  26035. ΓòÉΓòÉΓòÉ 19.289. EDC0631 ΓòÉΓòÉΓòÉ
  26036.  
  26037. Error in allocating disk space for intermediate files. 
  26038.  
  26039. Recovery: Ensure there is enough disk space in the TMP directory. Delete some 
  26040. files from the TMP directory and compile again. 
  26041.  
  26042.  
  26043. ΓòÉΓòÉΓòÉ 19.290. EDC0632 ΓòÉΓòÉΓòÉ
  26044.  
  26045. Error in opening intermediate files. 
  26046.  
  26047. Recovery: Ensure there is enough disk space and memory available. 
  26048.  
  26049.  
  26050. ΓòÉΓòÉΓòÉ 19.291. EDC0633 ΓòÉΓòÉΓòÉ
  26051.  
  26052. Error in closing intermediate files. 
  26053.  
  26054. Recovery: Restart the system, and compile again.  If this problem persists, 
  26055. contact your IBM Service representative. 
  26056.  
  26057.  
  26058. ΓòÉΓòÉΓòÉ 19.292. EDC0634 ΓòÉΓòÉΓòÉ
  26059.  
  26060. Error in creating name for intermediate files. 
  26061.  
  26062. Recovery: Restart the system and compile again.  If the problem persists, 
  26063. contact your IBM Service Representative. 
  26064.  
  26065.  
  26066. ΓòÉΓòÉΓòÉ 19.293. EDC0635 ΓòÉΓòÉΓòÉ
  26067.  
  26068. Error in writing to intermediate files. 
  26069.  
  26070. Recovery: Ensure there is enough disk space and memory available in the TMP 
  26071. directory. 
  26072.  
  26073.  
  26074. ΓòÉΓòÉΓòÉ 19.294. EDC0636 ΓòÉΓòÉΓòÉ
  26075.  
  26076. Unable to execute &1. 
  26077.  
  26078. Recovery: Ensure the executable file is in the current directory or is 
  26079. specified in your PATH, and that there is enough memory available. 
  26080.  
  26081.  
  26082. ΓòÉΓòÉΓòÉ 19.295. EDC0637 ΓòÉΓòÉΓòÉ
  26083.  
  26084. Unable to open linker response file &1. 
  26085.  
  26086. Recovery: Ensure there is enough disk space available in the TMP directory. 
  26087.  
  26088.  
  26089. ΓòÉΓòÉΓòÉ 19.296. EDC0638 ΓòÉΓòÉΓòÉ
  26090.  
  26091. Error in reading from intermediate files. 
  26092.  
  26093. Recovery: Restart the system and compile again.  If the problem persists, 
  26094. contact your IBM Service Representative. 
  26095.  
  26096.  
  26097. ΓòÉΓòÉΓòÉ 19.297. EDC0639 ΓòÉΓòÉΓòÉ
  26098.  
  26099. Unidentified error in using intermediate files. 
  26100.  
  26101. Recovery: Restart the system and compile again.  If the problem persists, 
  26102. contact your IBM Service Representative. 
  26103.  
  26104.  
  26105. ΓòÉΓòÉΓòÉ 19.298. EDC0640 ΓòÉΓòÉΓòÉ
  26106.  
  26107. Excess text &1 ignored on &2 option. 
  26108.  
  26109. Extraneous text not used by the option, has been ignored. 
  26110.  
  26111. Recovery: Remove extraneous text. 
  26112.  
  26113.  
  26114. ΓòÉΓòÉΓòÉ 19.299. EDC0641 ΓòÉΓòÉΓòÉ
  26115.  
  26116. An object declared as compatible with 16-bit applications is larger than 64K. 
  26117.  
  26118. The /Gt compiler option or #pragma seg16 directive was used with a data object 
  26119. declared as larger than 64K. 
  26120.  
  26121. Recovery: Change the data object so that it is less than 64K in size or remove 
  26122. the /Gt option and/or the #pragma seg16 directive. 
  26123.  
  26124.  
  26125. ΓòÉΓòÉΓòÉ 19.300. EDC0642 ΓòÉΓòÉΓòÉ
  26126.  
  26127. #pragma data_seg is ignored for object &1 because #pragma seg16 specified. 
  26128.  
  26129. Recovery: Remove the conflicting #pragma data_seg for the object. 
  26130.  
  26131.  
  26132. ΓòÉΓòÉΓòÉ 19.301. EDC0643 ΓòÉΓòÉΓòÉ
  26133.  
  26134. Obsolete C/2 #pragma &1 is no longer supported. 
  26135.  
  26136. A C/2 #pragma directive that is no longer supported was specified. 
  26137.  
  26138. Recovery: Remove the C/2 #pragma directive and use a valid #pragma directive or 
  26139. compiler option in its place. 
  26140.  
  26141.  
  26142. ΓòÉΓòÉΓòÉ 19.302. EDC0644 ΓòÉΓòÉΓòÉ
  26143.  
  26144. A _fastcall function cannot be defined in a 32-bit program. 
  26145.  
  26146. A function declared with the _fastcall linkage type, for example, int _Far16 
  26147. _Fastcall foo(); is defined in this compilation unit.  &Theprod. compiles 
  26148. programs to be run in 32-bit mode plus functions which support _cdecl and 
  26149. _pascal calling conventions. 
  26150.  
  26151. Recovery: Do not use _fastcall linkage for the function, or move the function 
  26152. to a different file and compile it with a 16-bit compiler. 
  26153.  
  26154.  
  26155. ΓòÉΓòÉΓòÉ 19.303. EDC0645 ΓòÉΓòÉΓòÉ
  26156.  
  26157. The operation between these types is not valid. 
  26158.  
  26159. The identifiers on the left hand side and the right hand side of the operator 
  26160. have types that do not respect the restrictions of the operator.  The operation 
  26161. specified in the expression cannot be performed.  See Expressions and Operators 
  26162. for the list of operator restrictions. 
  26163.  
  26164. Recovery: Change the operands. 
  26165.  
  26166.  
  26167. ΓòÉΓòÉΓòÉ 19.304. EDC0646 ΓòÉΓòÉΓòÉ
  26168.  
  26169. Return type must be compatible with declaration of function &1. 
  26170.  
  26171. The return statement of the function is trying to return a type which is not 
  26172. compatible with the function's declaration. 
  26173.  
  26174. Recovery: Ensure that the value you are returning from the function is correct, 
  26175. or cast the value to the appropriate type before returning it. 
  26176.  
  26177.  
  26178. ΓòÉΓòÉΓòÉ 19.305. EDC0647 ΓòÉΓòÉΓòÉ
  26179.  
  26180. Type of the parameter &1 cannot conflict with previous declaration of function 
  26181. &2. 
  26182.  
  26183. The type of this parameter is incompatible with the type of the corresponding 
  26184. parameter in the previous declaration of the function. 
  26185.  
  26186. Recovery: Ensure that the subsequent declaration or function call matches the 
  26187. prototype in both the number and type of parameters. 
  26188.  
  26189.  
  26190. ΓòÉΓòÉΓòÉ 19.306. EDC0648 ΓòÉΓòÉΓòÉ
  26191.  
  26192. If the operands are pointers, they must point to compatible types. 
  26193.  
  26194. If one operand of either the relational or the equality operator is a pointer, 
  26195. the other operand must be either a pointer to the same qualified or unqualified 
  26196. type, a NULL pointer, or a pointer to void. 
  26197.  
  26198. Recovery: Change the operands. 
  26199.  
  26200.  
  26201. ΓòÉΓòÉΓòÉ 19.307. EDC0649 ΓòÉΓòÉΓòÉ
  26202.  
  26203. User segment &1 has already been declared. 
  26204.  
  26205. The user segment has already been specified as being another type of segment. 
  26206. Data segments and text segments must have distinct names. 
  26207.  
  26208. Recovery: Change the name of the segment. 
  26209.  
  26210.  
  26211. ΓòÉΓòÉΓòÉ 19.308. EDC0650 ΓòÉΓòÉΓòÉ
  26212.  
  26213. The maximum number of user defined segments has been exceeded. 
  26214.  
  26215. Recovery: Reduce the number of text and data segments in the program. 
  26216.  
  26217.  
  26218. ΓòÉΓòÉΓòÉ 19.309. EDC0651 ΓòÉΓòÉΓòÉ
  26219.  
  26220. A 16-bit function may not have a structure or union as a parameter. 
  26221.  
  26222. Passing a structure or union by value to a 16-bit function is not allowed. 
  26223.  
  26224. Recovery: Change the parameter to a pointer to a structure or union. 
  26225.  
  26226.  
  26227. ΓòÉΓòÉΓòÉ 19.310. EDC0652 ΓòÉΓòÉΓòÉ
  26228.  
  26229. The facid was truncated to 3 characters. 
  26230.  
  26231. A facility id can be up to three characters long.  The id specified on a 
  26232. #pragma facid() directive was longer than this.  The id was truncated to three 
  26233. characters. 
  26234.  
  26235. Recovery: Ensure that the trunctated name is correct. 
  26236.  
  26237.  
  26238. ΓòÉΓòÉΓòÉ 19.311. EDC0653 ΓòÉΓòÉΓòÉ
  26239.  
  26240. The value of the flags field on #pragma pit() is bogus. 
  26241.  
  26242. The flags field on a #pragma pit directive contained some bits set which should 
  26243. not be set in a user program. 
  26244.  
  26245. Recovery: Adjust the flags value to make it legal. 
  26246.  
  26247.  
  26248. ΓòÉΓòÉΓòÉ 19.312. EDC0654 ΓòÉΓòÉΓòÉ
  26249.  
  26250. The type of the handler function '&1' on the #pragma &2 directive is illegal. 
  26251.  
  26252. The function either has the wrong linkage type, the wrong type for its return 
  26253. value, or an improper parameter list. 
  26254.  
  26255. Recovery: Check the user's guide for the correct function prototype, and fix 
  26256. the declaration as appropriate. 
  26257.  
  26258.  
  26259. ΓòÉΓòÉΓòÉ 19.313. EDC0655 ΓòÉΓòÉΓòÉ
  26260.  
  26261. #pragma &1 must appear only once in any C file. 
  26262.  
  26263. Recovery: Remove all but one of the specified #pragma directives. 
  26264.  
  26265.  
  26266. ΓòÉΓòÉΓòÉ 19.314. EDC0656 ΓòÉΓòÉΓòÉ
  26267.  
  26268. Only external function name that is defined in the file can be specified in a 
  26269. #pragma &1 directive. 
  26270.  
  26271. Recovery: Ensure that the spelling of the function name is correct, the 
  26272. function name is declared as an external identifier, and the function is 
  26273. defined in the file. 
  26274.  
  26275.  
  26276. ΓòÉΓòÉΓòÉ 19.315. EDC0657 ΓòÉΓòÉΓòÉ
  26277.  
  26278. Address of automatic variable taken when DS may not be equal to SS. 
  26279.  
  26280. The address of an auto was taken when the current data segment may may not be 
  26281. the same as the stack segment 
  26282.  
  26283. Recovery: Ensure that this will produce correct results. 
  26284.  
  26285.  
  26286. ΓòÉΓòÉΓòÉ 19.316. EDC0658 ΓòÉΓòÉΓòÉ
  26287.  
  26288. Illegal conversion between functions with 16 and 48 bit linkage. 
  26289.  
  26290. A 16 bit function or function pointer cannot be cast to a 48 bit function 
  26291. pointer, and vice-versa. 
  26292.  
  26293. Recovery: Remove the conversion. 
  26294.  
  26295.  
  26296. ΓòÉΓòÉΓòÉ 19.317. EDC0659 ΓòÉΓòÉΓòÉ
  26297.  
  26298. The /Gr option must be specified to use _Far32 _Pascal linkage. 
  26299.  
  26300. Recovery: Specify the /Gr compile option, or remove the _Far32 _Pascal linkage. 
  26301.  
  26302.  
  26303. ΓòÉΓòÉΓòÉ 19.318. EDC0660 ΓòÉΓòÉΓòÉ
  26304.  
  26305. Cannot use the _Seg16 qualifier with pointers to _Far32 _Pascal functions. 
  26306.  
  26307. Recovery: Remove the _Seg16 type qualifier. 
  26308.  
  26309.  
  26310. ΓòÉΓòÉΓòÉ 19.319. EDC0661 ΓòÉΓòÉΓòÉ
  26311.  
  26312. Functions taking a variable number of parameters cannot have _Pascal linkage. 
  26313.  
  26314. Recovery: Change the linkage of the function to be something other than 
  26315. _Pascal. 
  26316.  
  26317.  
  26318. ΓòÉΓòÉΓòÉ 19.320. EDC0800 ΓòÉΓòÉΓòÉ
  26319.  
  26320. Parameter &1 is not referenced. 
  26321.  
  26322. The identified variable has been declared in a function parameter list, but 
  26323. never referenced within the function body. 
  26324.  
  26325. Option: /Wpar 
  26326.  
  26327. Recovery: Remove the parameter declaration if it is not needed. 
  26328.  
  26329.  
  26330. ΓòÉΓòÉΓòÉ 19.321. EDC0801 ΓòÉΓòÉΓòÉ
  26331.  
  26332. Automatic variable &1 is not referenced. 
  26333.  
  26334. The identified variable has been declared at block scope, but never referenced. 
  26335.  
  26336. Option: /Wuse 
  26337.  
  26338. Recovery: Remove the variable declaration if it is not needed. 
  26339.  
  26340.  
  26341. ΓòÉΓòÉΓòÉ 19.322. EDC0802 ΓòÉΓòÉΓòÉ
  26342.  
  26343. Static variable &1 is not referenced. 
  26344.  
  26345. The identified static variable has been declared, but never referenced. 
  26346.  
  26347. Option: /Wuse 
  26348.  
  26349. Recovery: Remove the variable declaration if it is not needed. 
  26350.  
  26351.  
  26352. ΓòÉΓòÉΓòÉ 19.323. EDC0803 ΓòÉΓòÉΓòÉ
  26353.  
  26354. External variable &1 is not referenced. 
  26355.  
  26356. The identified variable has been declared either at file scope or extern at 
  26357. block scope, and was never referenced. 
  26358.  
  26359. Option: /Wuse 
  26360.  
  26361. Recovery: Remove the variable declaration if it is not needed. 
  26362.  
  26363.  
  26364. ΓòÉΓòÉΓòÉ 19.324. EDC0804 ΓòÉΓòÉΓòÉ
  26365.  
  26366. Function &1 is not referenced. 
  26367.  
  26368. The identified function has been declared, but never referenced. 
  26369.  
  26370. Option: /Wuse 
  26371.  
  26372. Recovery: Remove the function declaration if the function is not needed. 
  26373.  
  26374.  
  26375. ΓòÉΓòÉΓòÉ 19.325. EDC0805 ΓòÉΓòÉΓòÉ
  26376.  
  26377. Automatic variable &1 is set but not referenced. 
  26378.  
  26379. The identified variable has been declared and initialized, but never 
  26380. referenced.  Variables of type array, struct or union are not checked for this 
  26381. condition. 
  26382.  
  26383. Option: /Wuse 
  26384.  
  26385. Recovery: Remove the variable declaration and initialization if they are not 
  26386. needed. 
  26387.  
  26388.  
  26389. ΓòÉΓòÉΓòÉ 19.326. EDC0806 ΓòÉΓòÉΓòÉ
  26390.  
  26391. Static variable &1 is set but not referenced. 
  26392.  
  26393. The identified variable has been declared and initialized, but never 
  26394. referenced.  Variables of type array, struct or union are not checked for this 
  26395. condition. 
  26396.  
  26397. Option: /Wuse 
  26398.  
  26399. Recovery: Remove the variable declaration and initialization if they are not 
  26400. needed. 
  26401.  
  26402.  
  26403. ΓòÉΓòÉΓòÉ 19.327. EDC0807 ΓòÉΓòÉΓòÉ
  26404.  
  26405. Variable &1 may not have been set before the first reference. 
  26406.  
  26407. The compiler encountered an attempt to access the value of the identified 
  26408. variable before the variable was explicitly initialized. 
  26409.  
  26410. Option: /Wgen 
  26411.  
  26412. Recovery: Ensure the variable is explicitly initialized before its value is 
  26413. accessed. 
  26414.  
  26415.  
  26416. ΓòÉΓòÉΓòÉ 19.328. EDC0808 ΓòÉΓòÉΓòÉ
  26417.  
  26418. Variable &1 was not explicitly initialized. 
  26419.  
  26420. If not explicitly initialized, variables with storage class auto or register 
  26421. contain indeterminate values. 
  26422.  
  26423. Option: /Wuni 
  26424.  
  26425. Recovery: Initialize the variable. 
  26426.  
  26427.  
  26428. ΓòÉΓòÉΓòÉ 19.329. EDC0809 ΓòÉΓòÉΓòÉ
  26429.  
  26430. &1 redefinition hides earlier one. 
  26431.  
  26432. A typedef was defined at an inner scope with the same name as a previous 
  26433. typedef definition made at an outer scope.  The inner scope definition 
  26434. overrides the previous one. 
  26435.  
  26436. Option: /Wgen 
  26437.  
  26438. Recovery: Ensure this is what was intended or use different names for the two 
  26439. typedefs. 
  26440.  
  26441.  
  26442. ΓòÉΓòÉΓòÉ 19.330. EDC0810 ΓòÉΓòÉΓòÉ
  26443.  
  26444. External variable &1 is set but not referenced. 
  26445.  
  26446. The identified variable has been declared and initialized, but never 
  26447. referenced.  Variables of type array, struct or union are not checked for this 
  26448. condition. 
  26449.  
  26450. Option: /Wext 
  26451.  
  26452. Recovery: Remove the variable declaration and initialization if they are not 
  26453. needed. 
  26454.  
  26455.  
  26456. ΓòÉΓòÉΓòÉ 19.331. EDC0811 ΓòÉΓòÉΓòÉ
  26457.  
  26458. Statement has no effect. 
  26459.  
  26460. The statement does not cause any storage to be changed or functions to be 
  26461. called. 
  26462.  
  26463. Option: /Weff 
  26464.  
  26465. Recovery: Change or delete the statement. 
  26466.  
  26467.  
  26468. ΓòÉΓòÉΓòÉ 19.332. EDC0812 ΓòÉΓòÉΓòÉ
  26469.  
  26470. Expression has no effect. 
  26471.  
  26472. An expression with no effect has been discovered where expressions with side 
  26473. effects are usually expected. 
  26474.  
  26475. Option: /Weff 
  26476.  
  26477. Recovery: Change or delete the expression. 
  26478.  
  26479.  
  26480. ΓòÉΓòÉΓòÉ 19.333. EDC0813 ΓòÉΓòÉΓòÉ
  26481.  
  26482. if-statement is empty. 
  26483.  
  26484. The statement body for an if statement contains no executable code. 
  26485.  
  26486. Option: /Weff 
  26487.  
  26488. Recovery: Change the statement body to contain executable code or delete the if 
  26489. statement. 
  26490.  
  26491.  
  26492. ΓòÉΓòÉΓòÉ 19.334. EDC0814 ΓòÉΓòÉΓòÉ
  26493.  
  26494. else-statement is empty. 
  26495.  
  26496. The statement body for an else statement contains no executable code. 
  26497.  
  26498. Option: /Weff 
  26499.  
  26500. Recovery: Change the statement body to contain executable code or delete the 
  26501. else statement. 
  26502.  
  26503.  
  26504. ΓòÉΓòÉΓòÉ 19.335. EDC0815 ΓòÉΓòÉΓòÉ
  26505.  
  26506. Loop body is empty. 
  26507.  
  26508. The statement body for a loop statement contains no executable code. 
  26509.  
  26510. Option: /Weff 
  26511.  
  26512. Recovery: Change the statement body to contain executable code or remove the 
  26513. loop statement. 
  26514.  
  26515.  
  26516. ΓòÉΓòÉΓòÉ 19.336. EDC0816 ΓòÉΓòÉΓòÉ
  26517.  
  26518. Assignment found in a control expression. 
  26519.  
  26520. The control expression for a switch, if, for, or while statement contains an 
  26521. unparenthesized assignment statement.  A common programming problem is the 
  26522. substitution of an assignment statement (i = 3) for what should be a comparison 
  26523. statement (i == 3). 
  26524.  
  26525. Option: /Wcnd 
  26526.  
  26527. Recovery: Verify whether the statement should be an assignment or a comparison. 
  26528.  
  26529.  
  26530. ΓòÉΓòÉΓòÉ 19.337. EDC0817 ΓòÉΓòÉΓòÉ
  26531.  
  26532. Type conversion may result in lost precision. 
  26533.  
  26534. The required type conversion may cause lost precision.  See -- Reference typcn 
  26535. not found -- for more information on type conversions. for more information on 
  26536. type conversions. 
  26537.  
  26538. Option: /Wtrd 
  26539.  
  26540. Recovery: If precision is important in the operation, eliminate the type 
  26541. conversion. 
  26542.  
  26543.  
  26544. ΓòÉΓòÉΓòÉ 19.338. EDC0818 ΓòÉΓòÉΓòÉ
  26545.  
  26546. Pointer type conversion found. 
  26547.  
  26548. Conversion of pointer types may change the pointer values. 
  26549.  
  26550. Option: /Wtrd 
  26551.  
  26552. Recovery: None, if the conversion was intended.  Otherwise, declare the pointer 
  26553. to void instead of to another type, and then cast it. 
  26554.  
  26555.  
  26556. ΓòÉΓòÉΓòÉ 19.339. EDC0819 ΓòÉΓòÉΓòÉ
  26557.  
  26558. Bitwise operator applied to a signed type. 
  26559.  
  26560. Bitwise operators may change the value of a signed type by shifting the bit 
  26561. used to indicate the sign of the value. 
  26562.  
  26563. Option: /Wpor 
  26564.  
  26565. Recovery: Change the operand to an unsigned type or remove the bitwise 
  26566. operation. 
  26567.  
  26568.  
  26569. ΓòÉΓòÉΓòÉ 19.340. EDC0820 ΓòÉΓòÉΓòÉ
  26570.  
  26571. Right shift operator applied to a signed type. 
  26572.  
  26573. A right shift operator may change the value of a signed type by shifting the 
  26574. bit used to indicate the sign of the value. 
  26575.  
  26576. Option: /Wpor 
  26577.  
  26578. Recovery: Change the operand to an unsigned type or remove the shift operation. 
  26579.  
  26580.  
  26581. ΓòÉΓòÉΓòÉ 19.341. EDC0821 ΓòÉΓòÉΓòÉ
  26582.  
  26583. Relational expression is always true. 
  26584.  
  26585. The control expression of a switch, if, for, or while statement has a constant 
  26586. value, and the result is always true.  This may not be effective code. 
  26587.  
  26588. Option: /Wcnd 
  26589.  
  26590. Recovery: Verify if this result was intended.  Change the control expression if 
  26591. necessary. 
  26592.  
  26593.  
  26594. ΓòÉΓòÉΓòÉ 19.342. EDC0822 ΓòÉΓòÉΓòÉ
  26595.  
  26596. Relational expression is always false. 
  26597.  
  26598. The control expression of a switch, if, for, or while statement has a constant 
  26599. value, and the result is always false.  This may not be effective code. 
  26600.  
  26601. Option: /Wcnd 
  26602.  
  26603. Recovery: Verify if this result was intended.  Change the control expression if 
  26604. necessary. 
  26605.  
  26606.  
  26607. ΓòÉΓòÉΓòÉ 19.343. EDC0823 ΓòÉΓòÉΓòÉ
  26608.  
  26609. Expression contains division by zero. 
  26610.  
  26611. An expression containing division by zero was found. 
  26612.  
  26613. Option: /Wcns 
  26614.  
  26615. Recovery: Eliminate the division by zero if it was not intended. 
  26616.  
  26617.  
  26618. ΓòÉΓòÉΓòÉ 19.344. EDC0824 ΓòÉΓòÉΓòÉ
  26619.  
  26620. Expression contains modulus by zero. 
  26621.  
  26622. An expression containing modulus by zero was found. 
  26623.  
  26624. Option: /Wcns 
  26625.  
  26626. Recovery: Eliminate the modulus by zero if it was not intended. 
  26627.  
  26628.  
  26629. ΓòÉΓòÉΓòÉ 19.345. EDC0825 ΓòÉΓòÉΓòÉ
  26630.  
  26631. Code cannot be reached. 
  26632.  
  26633. A statement without a label has been found after an unconditional transfer of 
  26634. control, such as a goto. 
  26635.  
  26636. Option: /Wrea 
  26637.  
  26638. Recovery: If the statement should be executed, make the transfer of control 
  26639. conditional, or label the statement.  If not, remove the statement. 
  26640.  
  26641.  
  26642. ΓòÉΓòÉΓòÉ 19.346. EDC0826 ΓòÉΓòÉΓòÉ
  26643.  
  26644. Execution fall-through within a switch statement. 
  26645.  
  26646. A case label has been encountered that was not preceded by either a break or 
  26647. return statement. 
  26648.  
  26649. Option: /Wgen 
  26650.  
  26651. Recovery: Precede the case label with a break or return statement. 
  26652.  
  26653.  
  26654. ΓòÉΓòÉΓòÉ 19.347. EDC0827 ΓòÉΓòÉΓòÉ
  26655.  
  26656. Nonprototype function declaration encountered. 
  26657.  
  26658. A nonprototype function declaration was found. For example, 
  26659.  
  26660.    int addnum();
  26661.  
  26662. Function declarations should include the return type of the function and the 
  26663. types of its parameters. Calls to nonprototype functions get no type checking 
  26664. or type conversions on parameters. 
  26665.  
  26666. Option: /Wobs 
  26667.  
  26668. Recovery: Change the nonprototype declarations to prototype declarations such 
  26669. as the following: 
  26670.  
  26671.    int addnum(int, int);
  26672.  
  26673.  
  26674. ΓòÉΓòÉΓòÉ 19.348. EDC0828 ΓòÉΓòÉΓòÉ
  26675.  
  26676. The return type of the function main should have type int, not void. 
  26677.  
  26678. If main is declared to return void, the exit code from the program will be 
  26679. indeterminate. 
  26680.  
  26681. Option: /Wobs 
  26682.  
  26683.  
  26684. ΓòÉΓòÉΓòÉ 19.349. EDC0829 ΓòÉΓòÉΓòÉ
  26685.  
  26686. Possibly ambiguous operator usage encountered. 
  26687.  
  26688. Expressions consisting of traditional mathematical symbols sometimes have bugs 
  26689. created by misunderstanding of operator precedence. Nonparenthesized 
  26690. expressions containing shift operators, relationals, and bitwise operators may 
  26691. have precedence that is counterintuitive.  The identified operator has at least 
  26692. one operand that may have this property. 
  26693.  
  26694. Option: /Word 
  26695.  
  26696. Recovery: Use the appropriate parentheses to eliminate the ambiguity. 
  26697.  
  26698.  
  26699. ΓòÉΓòÉΓòÉ 19.350. EDC0830 ΓòÉΓòÉΓòÉ
  26700.  
  26701. Value is not a member of the enumeration. 
  26702.  
  26703. Variables of type enum are not expected to be used in situations other than 
  26704. assignment and comparison, and can only be assigned proper members of their 
  26705. enumeration, either directly, from function return values, or from another 
  26706. variable of the same type. 
  26707.  
  26708. Option: /Wenu 
  26709.  
  26710. Recovery: Ensure operations involving variables of type enum are valid. 
  26711.  
  26712.  
  26713. ΓòÉΓòÉΓòÉ 19.351. EDC0831 ΓòÉΓòÉΓòÉ
  26714.  
  26715. Case label is not a member of the enumeration. 
  26716.  
  26717. In a switch statement where the switch control expression is an enum, the case 
  26718. label values must be members of the enumeration. 
  26719.  
  26720. Option: /Wenu 
  26721.  
  26722. Recovery: Ensure the case label is a member of the enumeration. 
  26723.  
  26724.  
  26725. ΓòÉΓòÉΓòÉ 19.352. EDC0832 ΓòÉΓòÉΓòÉ
  26726.  
  26727. Unstructured goto statement encountered. 
  26728.  
  26729. The target label of a goto statement should not be located in an inner block 
  26730. such as a loop. 
  26731.  
  26732. Option: /Wgot 
  26733.  
  26734. Recovery: Ensure the target label of the goto statement is not located in an 
  26735. inner block. 
  26736.  
  26737.  
  26738. ΓòÉΓòÉΓòÉ 19.353. EDC0833 ΓòÉΓòÉΓòÉ
  26739.  
  26740. Implicit return statement encountered. 
  26741.  
  26742. C allows returns from a function call without specifying a return statement. 
  26743. However, if a function is to return a value, a return statement must be 
  26744. included. 
  26745.  
  26746. Option: /Wret 
  26747.  
  26748. Recovery: Add a return statement to the called function if you want it to 
  26749. return a value. 
  26750.  
  26751.  
  26752. ΓòÉΓòÉΓòÉ 19.354. EDC0834 ΓòÉΓòÉΓòÉ
  26753.  
  26754. Missing function return value. 
  26755.  
  26756. The function was declared to return a value, and a return statement with no 
  26757. value has been encountered.  If return statement is not included in the 
  26758. function, it will return an indeterminate value to the caller. 
  26759.  
  26760. Option: /Wret 
  26761.  
  26762. Recovery: Add a return value to the return statement. 
  26763.  
  26764.  
  26765. ΓòÉΓòÉΓòÉ 19.355. EDC0835 ΓòÉΓòÉΓòÉ
  26766.  
  26767. Structure or union remapping will be performed for this copy operation. 
  26768.  
  26769. A struct or union assignment has been encountered which requires an implicit 
  26770. pack or unpack operation. This form of assignment is often less efficient that 
  26771. those assignments that have identical pack characteristics. 
  26772.  
  26773. Option: /Wgen 
  26774.  
  26775. Recovery: Revise the statements to avoid unnecessary pack and unpack 
  26776. operations. 
  26777.  
  26778.  
  26779. ΓòÉΓòÉΓòÉ 19.356. EDC0836 ΓòÉΓòÉΓòÉ
  26780.  
  26781. The same #pragma &1 directive was previously specified for the object &2. 
  26782.  
  26783. The function was already declared using the same #pragma linkage directive. 
  26784.  
  26785. Option: /Wppc 
  26786.  
  26787. Recovery: Remove one of the #pragma linkage directives. 
  26788.  
  26789.  
  26790. ΓòÉΓòÉΓòÉ 19.357. EDC0837 ΓòÉΓòÉΓòÉ
  26791.  
  26792. goto statement encountered. 
  26793.  
  26794. A goto statement was found. 
  26795.  
  26796. Option: /Wgot 
  26797.  
  26798. Recovery: No recovery necessary. 
  26799.  
  26800.  
  26801. ΓòÉΓòÉΓòÉ 19.358. EDC0838 ΓòÉΓòÉΓòÉ
  26802.  
  26803. Comparison is not valid because the numeric constant is out of range. 
  26804.  
  26805. A comparison between a variable and a constant that is not in the variable's 
  26806. range of possible values has been detected. 
  26807.  
  26808. Option: /Wcns 
  26809.  
  26810. Recovery: Delete the comparison, or use a constant that is in the variable's 
  26811. range of possible values. 
  26812.  
  26813.  
  26814. ΓòÉΓòÉΓòÉ 19.359. EDC0839 ΓòÉΓòÉΓòÉ
  26815.  
  26816. Unary minus applied to an unsigned type. 
  26817.  
  26818. An unsigned type cannot have a sign. 
  26819.  
  26820. Option: /Wcns 
  26821.  
  26822. Recovery: Remove the unary minus or change the type to be signed. 
  26823.  
  26824.  
  26825. ΓòÉΓòÉΓòÉ 19.360. EDC0841 ΓòÉΓòÉΓòÉ
  26826.  
  26827. File &1 has already #included. 
  26828.  
  26829. The file specified was included by a previous #include directive. 
  26830.  
  26831. Option: /Wppc 
  26832.  
  26833. Recovery: Remove one of the #include directives. 
  26834.  
  26835.  
  26836. ΓòÉΓòÉΓòÉ 19.361. EDC0842 ΓòÉΓòÉΓòÉ
  26837.  
  26838. Macro name &1 on #undef not defined. 
  26839.  
  26840. The specified macro name has never been defined or has already been removed by 
  26841. a previous #undef directive. 
  26842.  
  26843. Option: /Wppc 
  26844.  
  26845. Recovery: Define the macro name, or remove the #undef directive. 
  26846.  
  26847.  
  26848. ΓòÉΓòÉΓòÉ 19.362. EDC0843 ΓòÉΓòÉΓòÉ
  26849.  
  26850. Macro name &1 on #define is also an identifier. 
  26851.  
  26852. The specified macro definition will override an existing identifier definition. 
  26853.  
  26854. Option: /Wppc 
  26855.  
  26856. Recovery: Rename or remove the macro or the identifier. 
  26857.  
  26858.  
  26859. ΓòÉΓòÉΓòÉ 19.363. EDC0844 ΓòÉΓòÉΓòÉ
  26860.  
  26861. Macro name &1 on #define is also a keyword. 
  26862.  
  26863. The specified macro definition will override an existing keyword definition. 
  26864.  
  26865. Option: /Wppc 
  26866.  
  26867. Recovery: Rename the macro or remove the definition. 
  26868.  
  26869.  
  26870. ΓòÉΓòÉΓòÉ 19.364. EDC0845 ΓòÉΓòÉΓòÉ
  26871.  
  26872. Identifier &1 assigned default value of 0. 
  26873.  
  26874. The indicated identifier in a #if or #elif expression was assigned the default 
  26875. value of zero.  The identifier may have been intended to be expanded as a 
  26876. macro. 
  26877.  
  26878. Option: /Wppc 
  26879.  
  26880. Recovery: Assign the identifier a value if necessary. 
  26881.  
  26882.  
  26883. ΓòÉΓòÉΓòÉ 19.365. EDC0846 ΓòÉΓòÉΓòÉ
  26884.  
  26885. Expanding trigraph &1 in string literal. 
  26886.  
  26887. A trigraph has been expanded in a string literal.  This may not be the intended 
  26888. behavior. 
  26889.  
  26890. Option: /Wppc 
  26891.  
  26892. Recovery: Ensure this is the intended behavior.  If not, use escape sequences 
  26893. to represent characters, for example '\?' for the character '?'. 
  26894.  
  26895.  
  26896. ΓòÉΓòÉΓòÉ 19.366. EDC0847 ΓòÉΓòÉΓòÉ
  26897.  
  26898. Expanding trigraph &1 in character literal. 
  26899.  
  26900. A trigraph has been expanded in a character literal.  This may not be the 
  26901. intended behavior. 
  26902.  
  26903. Option: /Wppc 
  26904.  
  26905. Recovery: Ensure this is the intended behavior.  If not, use escape sequences 
  26906. to represent characters, for example '\?' for the character '?'. 
  26907.  
  26908.  
  26909. ΓòÉΓòÉΓòÉ 19.367. EDC0848 ΓòÉΓòÉΓòÉ
  26910.  
  26911. Some program text not scanned due to &1 option. 
  26912.  
  26913. The setting of the margins and/or sequence options has resulted in some program 
  26914. text not being scanned. 
  26915.  
  26916. Option: /Wppc 
  26917.  
  26918. Recovery: Reset the margins and/or sequence options if necessary. 
  26919.  
  26920.  
  26921. ΓòÉΓòÉΓòÉ 19.368. EDC0851 ΓòÉΓòÉΓòÉ
  26922.  
  26923. #include found file &1. 
  26924.  
  26925. The message indicates the actual file found for the #include directive. 
  26926.  
  26927. Option: /Wppt 
  26928.  
  26929. Recovery: No recovery necessary if the result is what was intended. 
  26930.  
  26931.  
  26932. ΓòÉΓòÉΓòÉ 19.369. EDC0852 ΓòÉΓòÉΓòÉ
  26933.  
  26934. #undef undefining macro name &1. 
  26935.  
  26936. This message traces the execution of the #undef directive. 
  26937.  
  26938. Option: /Wppt 
  26939.  
  26940. Recovery: No recovery necessary if the result is what was intended. 
  26941.  
  26942.  
  26943. ΓòÉΓòÉΓòÉ 19.370. EDC0853 ΓòÉΓòÉΓòÉ
  26944.  
  26945. Macro name &1 on #define has a previous identical definition. 
  26946.  
  26947. The macro has already been identically defined.  This may indicate that a file 
  26948. has been #included more than once. 
  26949.  
  26950. Option: /Wppt 
  26951.  
  26952. Recovery: Remove one of the definitions or rename one of the macros. 
  26953.  
  26954.  
  26955. ΓòÉΓòÉΓòÉ 19.371. EDC0854 ΓòÉΓòÉΓòÉ
  26956.  
  26957. #line directive changing line to &1 and file to &2. 
  26958.  
  26959. This message traces the execution of the #line directive. 
  26960.  
  26961. Option: /Wppt 
  26962.  
  26963. Recovery: No recovery necessary if the result is what was intended. 
  26964.  
  26965.  
  26966. ΓòÉΓòÉΓòÉ 19.372. EDC0855 ΓòÉΓòÉΓòÉ
  26967.  
  26968. #&1 condition evaluates to &2. 
  26969.  
  26970. This message traces the evaluation of the test condition of a #if, #ifdef, or 
  26971. #elif directive. 
  26972.  
  26973. Option: /Wppt 
  26974.  
  26975. Recovery: No recovery necessary if the result is what was intended. 
  26976.  
  26977.  
  26978. ΓòÉΓòÉΓòÉ 19.373. EDC0856 ΓòÉΓòÉΓòÉ
  26979.  
  26980. defined(&1) evaluates to &2. 
  26981.  
  26982. This message traces the evaluation of the defined(&1) construct on a #if or 
  26983. #elif expression. 
  26984.  
  26985. Option: /Wppt 
  26986.  
  26987. Recovery: No recovery necessary if the result is what was intended. 
  26988.  
  26989.  
  26990. ΓòÉΓòÉΓòÉ 19.374. EDC0857 ΓòÉΓòÉΓòÉ
  26991.  
  26992. Begin skipping tokens. 
  26993.  
  26994. This message traces the execution of conditional compilation directives, for 
  26995. example indicating that code is skipped after a #if with a condition that 
  26996. evaluates to false. 
  26997.  
  26998. Option: /Wppt 
  26999.  
  27000. Recovery: Ensure the appropriate tokens were skipped. 
  27001.  
  27002.  
  27003. ΓòÉΓòÉΓòÉ 19.375. EDC0858 ΓòÉΓòÉΓòÉ
  27004.  
  27005. Stop skipping tokens. 
  27006.  
  27007. This message traces the execution of conditional compilation directives, for 
  27008. example, indicating that a #endif marked the end of a block of skipped code. 
  27009.  
  27010. Option: /Wppt 
  27011.  
  27012. Recovery: Ensure the appropriate tokens were skipped. 
  27013.  
  27014.  
  27015. ΓòÉΓòÉΓòÉ 19.376. EDC0859 ΓòÉΓòÉΓòÉ
  27016.  
  27017. #&1 nesting level is &2. 
  27018.  
  27019. This message traces the nesting level of conditional compilation directives. 
  27020.  
  27021. Option: /Wppt 
  27022.  
  27023. Recovery: No recovery necessary if the result is what was intended. 
  27024.  
  27025.  
  27026. ΓòÉΓòÉΓòÉ 19.377. EDC0860 ΓòÉΓòÉΓòÉ
  27027.  
  27028. String literals concatenated. 
  27029.  
  27030. This message traces the concatenation of two string literals. 
  27031.  
  27032. Option: /Wppt 
  27033.  
  27034. Recovery: Ensure the concatenation is what was intended. 
  27035.  
  27036.  
  27037. ΓòÉΓòÉΓòÉ 19.378. EDC0861 ΓòÉΓòÉΓòÉ
  27038.  
  27039. Optional brace encountered. 
  27040.  
  27041. A optional brace was found. 
  27042.  
  27043. Option: /Wini 
  27044.  
  27045. Recovery: No recovery necessary. 
  27046.  
  27047.  
  27048. ΓòÉΓòÉΓòÉ 19.379. EDC0862 ΓòÉΓòÉΓòÉ
  27049.  
  27050. Matching optional brace encountered. 
  27051.  
  27052. A matching optional brace was found. 
  27053.  
  27054. Option: /Wini 
  27055.  
  27056. Recovery: No recovery necessary. 
  27057.  
  27058.  
  27059. ΓòÉΓòÉΓòÉ 19.380. EDC0863 ΓòÉΓòÉΓòÉ
  27060.  
  27061. Incompletely bracketed initializer encountered, &1 left brace(s) assumed. 
  27062.  
  27063. An initializer for an aggregate type was missing a left brace or braces.  The 
  27064. compiler assumes the brace is meant to be there. 
  27065.  
  27066. Option: /Wini 
  27067.  
  27068. Recovery: Ensure this is what was intended. 
  27069.  
  27070.  
  27071. ΓòÉΓòÉΓòÉ 19.381. EDC0864 ΓòÉΓòÉΓòÉ
  27072.  
  27073. Incompletely bracketed initializer encountered, &1 right brace(s) assumed. 
  27074.  
  27075. An initializer for an aggregate type was missing a right brace or braces.  The 
  27076. compiler assumes the brace is meant to be there. 
  27077.  
  27078. Option: /Wini 
  27079.  
  27080. Recovery: Ensure this is what was intended. 
  27081.  
  27082.  
  27083. ΓòÉΓòÉΓòÉ 19.382. EDC0865 ΓòÉΓòÉΓòÉ
  27084.  
  27085. Floating-point constant is out of range. 
  27086.  
  27087. Refer to the <.float.h>. header file for the valid range for floating-point 
  27088. constants. 
  27089.  
  27090. Option: /Wcns 
  27091.  
  27092. Recovery: Ensure the floating-point constant is within the valid range. 
  27093.  
  27094.  
  27095. ΓòÉΓòÉΓòÉ 19.383. EDC0866 ΓòÉΓòÉΓòÉ
  27096.  
  27097. Constant arithmetic folding results in an infinity. 
  27098.  
  27099. Floating-point constant arithmetic folding results in an infinity. 
  27100.  
  27101. Option&colon. /Kb 
  27102.  
  27103. Recovery: Ensure this is what was intended. 
  27104.  
  27105.  
  27106. ΓòÉΓòÉΓòÉ 19.384. EDC0867 ΓòÉΓòÉΓòÉ
  27107.  
  27108. Constant arithmetic folding results in a NaN. 
  27109.  
  27110. Floating-point constant arithmetic folding results in a NaN. 
  27111.  
  27112. Option: /Wcns 
  27113.  
  27114. Recovery: Ensure this is what was intended. 
  27115.  
  27116.  
  27117. ΓòÉΓòÉΓòÉ 19.385. EDC0868 ΓòÉΓòÉΓòÉ
  27118.  
  27119. The incomplete struct or union tag &1 was introduced in a parameter list. 
  27120.  
  27121. The incomplete struct or union tag introduced in the parameter list will not be 
  27122. compatible with subsequent uses of the tag. 
  27123.  
  27124. Option: /Wgen 
  27125.  
  27126. Recovery: Declare the incomplete struct or union tag at file scope before the 
  27127. function declaration. 
  27128.  
  27129.  
  27130. ΓòÉΓòÉΓòÉ 19.386. EDC0869 ΓòÉΓòÉΓòÉ
  27131.  
  27132. The incomplete struct or union tag &1 was not completed before going out of 
  27133. scope. 
  27134.  
  27135. An incomplete struct or union tag introduced at block scope was not completed 
  27136. before the end of the scope. 
  27137.  
  27138. Option: /Wgen 
  27139.  
  27140. Recovery: Provide a complete declaration for the struct or union tag. 
  27141.  
  27142.  
  27143. ΓòÉΓòÉΓòÉ 19.387. EDC0870 ΓòÉΓòÉΓòÉ
  27144.  
  27145. #line directive changing line to &1. 
  27146.  
  27147. This message traces the execution of the #line directive. 
  27148.  
  27149. Option: /Wppt 
  27150.  
  27151.  
  27152. ΓòÉΓòÉΓòÉ 19.388. EDC0871 ΓòÉΓòÉΓòÉ
  27153.  
  27154. Ordinal value on #pragma &1 is out of range. 
  27155.  
  27156. The specified ordinal number should be between 0 and 65535, inclusive. 
  27157.  
  27158. Recovery: Change the value accordingly. 
  27159.  
  27160.  
  27161. ΓòÉΓòÉΓòÉ 19.389. EDC0872 ΓòÉΓòÉΓòÉ
  27162.  
  27163. A DLL module name must be specified in #pragma import. 
  27164.  
  27165. Module name is the name of the DLL where the entry point of the import function 
  27166. exists.  It must be specified in the parameter list of #pragma import. 
  27167.  
  27168. Recovery: Name the DLL in the parameter list. 
  27169.  
  27170.  
  27171. ΓòÉΓòÉΓòÉ 19.390. EDC0873 ΓòÉΓòÉΓòÉ
  27172.  
  27173. Undefined function &1 cannot have a #pragma export or _Export. 
  27174.  
  27175. Recovery: Define the function. 
  27176.  
  27177.  
  27178. ΓòÉΓòÉΓòÉ 19.391. EDC0874 ΓòÉΓòÉΓòÉ
  27179.  
  27180. Static function &1 cannot have a #pragma export or _Export. 
  27181.  
  27182. Recovery: Remove the static storage class of the function in order to get it 
  27183. exported. 
  27184.  
  27185.  
  27186. ΓòÉΓòÉΓòÉ 19.392. EDC0875 ΓòÉΓòÉΓòÉ
  27187.  
  27188. Definition of function &1 declared as an import encountered. 
  27189.  
  27190. The function was previously declared with the #pragma import directive. 
  27191. Functions declared as import should not be defined in the compilation unit. 
  27192.  
  27193. Recovery: Either remove the #pragma import directive for the function or or 
  27194. remove the definition. 
  27195.  
  27196.  
  27197. ΓòÉΓòÉΓòÉ 19.393. EDC0876 ΓòÉΓòÉΓòÉ
  27198.  
  27199. Function &1 was previously specified in #pragma export or _Export. 
  27200.  
  27201. More than one #pragma export directive or _Export was specified for the same 
  27202. object. 
  27203.  
  27204. Recovery: Remove the extra #pragma export directives or _Export. 
  27205.  
  27206.  
  27207. ΓòÉΓòÉΓòÉ 19.394. EDC0877 ΓòÉΓòÉΓòÉ
  27208.  
  27209. Function &1 was previously defined and should not be redeclared as an import 
  27210. encountered. 
  27211.  
  27212. Recovery: Rename the function. 
  27213.  
  27214.  
  27215. ΓòÉΓòÉΓòÉ 19.395. EDC0884 ΓòÉΓòÉΓòÉ
  27216.  
  27217. Unable to open precompiled output file &1. Reason: &2. 
  27218.  
  27219. Recovery: Ensure that the compiler has write access for the precompiled output 
  27220. file. 
  27221.  
  27222.  
  27223. ΓòÉΓòÉΓòÉ 19.396. EDC0885 ΓòÉΓòÉΓòÉ
  27224.  
  27225. Unable to write precompiled output file &1. Reason: &2. 
  27226.  
  27227. Recovery: Ensure that the compiler has write access for the precompiled output 
  27228. file and that there is enough disk space for writing the file. 
  27229.  
  27230.  
  27231. ΓòÉΓòÉΓòÉ 19.397. EDC0886 ΓòÉΓòÉΓòÉ
  27232.  
  27233. Unable to open precompiled input file &1. Reason: &2. 
  27234.  
  27235. Recovery: Ensure that the compiler has read access for the precompiled output 
  27236. file. 
  27237.  
  27238.  
  27239. ΓòÉΓòÉΓòÉ 19.398. EDC0887 ΓòÉΓòÉΓòÉ
  27240.  
  27241. Precompiled data in the file &1 does not have the correct format.  The original 
  27242. header file will be used. 
  27243.  
  27244. Recovery: Remove the corrupt precompiled version of the header file and 
  27245. re-generate it with the /Fi+ option. 
  27246.  
  27247.  
  27248. ΓòÉΓòÉΓòÉ 19.399. EDC0888 ΓòÉΓòÉΓòÉ
  27249.  
  27250. Precompiled data in the file &1 cannot be used because it was produced by a 
  27251. later version of the compiler. The original header will be used. 
  27252.  
  27253. Recovery: Erase the precompiled version of the header file and re-generate it 
  27254. with the current version of the compiler. 
  27255.  
  27256.  
  27257. ΓòÉΓòÉΓòÉ 19.400. EDC0889 ΓòÉΓòÉΓòÉ
  27258.  
  27259. Precompiled header file &1 found but not used because it is not up to date. 
  27260.  
  27261. Recovery: Use /Fi+ option to generate an up to date version of the precompiled 
  27262. header file. 
  27263.  
  27264.  
  27265. ΓòÉΓòÉΓòÉ 19.401. EDC0890 ΓòÉΓòÉΓòÉ
  27266.  
  27267. Using precompiled header file &1. 
  27268.  
  27269.  
  27270. ΓòÉΓòÉΓòÉ 19.402. EDC0891 ΓòÉΓòÉΓòÉ
  27271.  
  27272. Generated precompiled header file &1. 
  27273.  
  27274.  
  27275. ΓòÉΓòÉΓòÉ 19.403. EDC0900 ΓòÉΓòÉΓòÉ
  27276.  
  27277. Unable to open &1. 
  27278.  
  27279. Recovery: Ensure file exists. 
  27280.  
  27281.  
  27282. ΓòÉΓòÉΓòÉ 19.404. EDC0902 ΓòÉΓòÉΓòÉ
  27283.  
  27284. Unable to write to &1. 
  27285.  
  27286. Recovery: Ensure that the disk drive is not in an error mode and that there is 
  27287. enough disk space left. 
  27288.  
  27289.  
  27290. ΓòÉΓòÉΓòÉ 19.405. EDC3000 ΓòÉΓòÉΓòÉ
  27291.  
  27292. Version 1.120. warning : The message file DDE45.MSG is out of date. 
  27293.  
  27294. The message file found is not the correct version for the compiler being 
  27295. invoked.  The compiler requires a specific version of the message file 
  27296. DDE45.MSG in the help directory to display messages. 
  27297.  
  27298. Recovery: Check the DPATH environment variable and/or update the message file. 
  27299. If you have copied over the files in the the \ibmcpp\help or the \ibmcpp\bin 
  27300. directories, then the message files may be out of date. 
  27301.  
  27302.  
  27303. ΓòÉΓòÉΓòÉ 19.406. EDC3001 ΓòÉΓòÉΓòÉ
  27304.  
  27305. "private" assumed for base class "&1". 
  27306.  
  27307. No access specifier has been provided for a base class.  A base class can be 
  27308. declared with the access specifier "public" or "private".  The C++ language 
  27309. specification requires that "private" becomes the default when no access 
  27310. specifier is present.  It is good coding practice to explicitly provide the 
  27311. access specifier for the base class. 
  27312.  
  27313. Recovery: Provide an access specifier or accept the default. 
  27314.  
  27315.  
  27316. ΓòÉΓòÉΓòÉ 19.407. EDC3002 ΓòÉΓòÉΓòÉ
  27317.  
  27318. "&1" is not used in function "&2". 
  27319.  
  27320. The specified symbol has been declared within a function but it has not been 
  27321. set or used.  This is only an informational message since it is permitted to 
  27322. have declared yet unused symbols, but it is probably undesirable. 
  27323.  
  27324. Recovery: Ignore the message, use the symbol, or remove the symbol. 
  27325.  
  27326.  
  27327. ΓòÉΓòÉΓòÉ 19.408. EDC3003 ΓòÉΓòÉΓòÉ
  27328.  
  27329. Ambiguous conversion between "&1" and "&2". 
  27330.  
  27331. The compiler was not able to find a single type common to the two specified 
  27332. types. 
  27333.  
  27334. Recovery: Check the types. 
  27335.  
  27336.  
  27337. ΓòÉΓòÉΓòÉ 19.409. EDC3004 ΓòÉΓòÉΓòÉ
  27338.  
  27339. "&1" statement is not allowed in this scope. 
  27340.  
  27341. The specified statement was found outside the valid scope for such a statement. 
  27342. This typically means that it is outside any function. 
  27343.  
  27344. Recovery: Place the statement in the correct scope or remove it. 
  27345.  
  27346.  
  27347. ΓòÉΓòÉΓòÉ 19.410. EDC3005 ΓòÉΓòÉΓòÉ
  27348.  
  27349. Duplicate "default" statement in switch. 
  27350.  
  27351. Only one "default" label is allowed in a "switch" statement. This "default" 
  27352. label is not the first in the switch. 
  27353.  
  27354. Recovery: If you have nested switch statements, check that the braces match 
  27355. correctly.  If not, remove one of the "default" labels. 
  27356.  
  27357.  
  27358. ΓòÉΓòÉΓòÉ 19.411. EDC3006 ΓòÉΓòÉΓòÉ
  27359.  
  27360. Duplicate definition of label "&1". 
  27361.  
  27362. The specified label has already been defined in the current function.  A label 
  27363. can only be declared once within a function. 
  27364.  
  27365. Recovery: Remove or rename one of the label definitions. 
  27366.  
  27367.  
  27368. ΓòÉΓòÉΓòÉ 19.412. EDC3007 ΓòÉΓòÉΓòÉ
  27369.  
  27370. The "#line" macro directive may cause information for the browser to be 
  27371. corrupted. 
  27372.  
  27373. The compiler generates information for the class browser.  Using the "#line" 
  27374. preprocessor directive may cause that information to be corrupted. 
  27375.  
  27376. Recovery: Remove the "#line" macro directive or note the possible corruption. 
  27377.  
  27378.  
  27379. ΓòÉΓòÉΓòÉ 19.413. EDC3008 ΓòÉΓòÉΓòÉ
  27380.  
  27381. Source file &1 cannot be opened. 
  27382.  
  27383. The compiler could not open the specified source file. 
  27384.  
  27385. Recovery: Ensure the source file name is correct.  Ensure that the correct file 
  27386. is being read and has not been corrupted.  If the file is located on a LAN 
  27387. drive, ensure the LAN is working properly.  Also, the file may be locked by 
  27388. another process or access may be denied because of insufficient permission. 
  27389.  
  27390.  
  27391. ΓòÉΓòÉΓòÉ 19.414. EDC3009 ΓòÉΓòÉΓòÉ
  27392.  
  27393. An error occurred while reading file "&1". 
  27394.  
  27395. The compiler detected an error while reading from the specified file. 
  27396.  
  27397. Recovery: Ensure the correct file is being read.  If the file resides on a LAN 
  27398. drive, ensure that the LAN is working properly. 
  27399.  
  27400.  
  27401. ΓòÉΓòÉΓòÉ 19.415. EDC3010 ΓòÉΓòÉΓòÉ
  27402.  
  27403. Source file name is missing. 
  27404.  
  27405. The name of the source file to be compiled was missing from the compiler 
  27406. invocation.  Ensure the compile options are specified correctly; the compiler 
  27407. may misinterpret the command line if the options are specified incorrectly. 
  27408.  
  27409. Recovery: Ensure that you specify the source file name. 
  27410.  
  27411.  
  27412. ΓòÉΓòÉΓòÉ 19.416. EDC3011 ΓòÉΓòÉΓòÉ
  27413.  
  27414. "&1" is unmatched at end of file. 
  27415.  
  27416. The end of the source file was reached and the comment or block was not closed. 
  27417. It is also possible that there was a typographical error made earlier in the 
  27418. source file 
  27419.  
  27420. Recovery: Check the source file for typographical errors.  End the comment or 
  27421. block before the end of the file. 
  27422.  
  27423.  
  27424. ΓòÉΓòÉΓòÉ 19.417. EDC3012 ΓòÉΓòÉΓòÉ
  27425.  
  27426. A return value is not allowed for this function. 
  27427.  
  27428. A "return" statement with a return expression is not allowed when the enclosing 
  27429. function has a return type of "void". 
  27430.  
  27431. Recovery: Either specify "return" without a value or expression, or remove the 
  27432. "return" statement from the function. 
  27433.  
  27434.  
  27435. ΓòÉΓòÉΓòÉ 19.418. EDC3013 ΓòÉΓòÉΓòÉ
  27436.  
  27437. "&1" is undefined. 
  27438.  
  27439. The specified identifier is being used but has not yet been defined. 
  27440.  
  27441. Recovery: Define the identifier before using it.  Check its spelling.  If the 
  27442. identifier has been defined in a header file, check that any required macros 
  27443. have been defined. 
  27444.  
  27445.  
  27446. ΓòÉΓòÉΓòÉ 19.419. EDC3014 ΓòÉΓòÉΓòÉ
  27447.  
  27448. Wrong number of arguments for macro "&1". 
  27449.  
  27450. The specified macro was defined with a different number of arguments than are 
  27451. used in this macro call. 
  27452.  
  27453. Recovery: Ensure that the macro call corresponds to the macro definition. Check 
  27454. the number and levels of corresponding braces in the macro. 
  27455.  
  27456.  
  27457. ΓòÉΓòÉΓòÉ 19.420. EDC3015 ΓòÉΓòÉΓòÉ
  27458.  
  27459. The compiler could not open the output file "&1". 
  27460.  
  27461. Recovery: Ensure the output file name is correct.  Also, ensure that the 
  27462. location of the output file has sufficient storage available.  If using a LAN 
  27463. drive, ensure that the LAN is working properly and you have permission to write 
  27464. to the disk. 
  27465.  
  27466.  
  27467. ΓòÉΓòÉΓòÉ 19.421. EDC3016 ΓòÉΓòÉΓòÉ
  27468.  
  27469. &1 member "&2" cannot be accessed. 
  27470.  
  27471. The specified member is private, protected or is a member of a private base 
  27472. class and cannot be accessed from the current scope. 
  27473.  
  27474. Recovery: Check the access specification rules for the member function and 
  27475. change the access specifier if necessary.  If the member function belongs to a 
  27476. base class, check the access specifier of the base class where the current 
  27477. class is defined. 
  27478.  
  27479.  
  27480. ΓòÉΓòÉΓòÉ 19.422. EDC3017 ΓòÉΓòÉΓòÉ
  27481.  
  27482. Return value of type "&1" is expected. 
  27483.  
  27484. No return value is being returned from the current function but the function is 
  27485. expecting a non-void return value.  The function was declared with a return 
  27486. type but the compiler did not detect a return statement.  A return statement 
  27487. without an expression, or no return statement at all, can only be used in 
  27488. functions with the return value type "void". 
  27489.  
  27490. Recovery: Return a value to the function or change the return type to void. 
  27491.  
  27492.  
  27493. ΓòÉΓòÉΓòÉ 19.423. EDC3018 ΓòÉΓòÉΓòÉ
  27494.  
  27495. "&1" cannot be made a &2 member. 
  27496.  
  27497. An attempt is being made to give private access to a base class member or to 
  27498. give access that is different from the access it was declared with.  A derived 
  27499. class can only change the access of a base class member function to public or 
  27500. protected. 
  27501.  
  27502. Recovery: Remove the invalid access statement or change the access specifier in 
  27503. the base class. 
  27504.  
  27505.  
  27506. ΓòÉΓòÉΓòÉ 19.424. EDC3019 ΓòÉΓòÉΓòÉ
  27507.  
  27508. Case expression is not an integral constant expression. 
  27509.  
  27510. The expression in a "case" statement must be an integral constant expression 
  27511. followed by a colon. 
  27512.  
  27513. Recovery: Use an integral constant expression.  A constant expression has a 
  27514. value that can be determined during compilation and does not change during 
  27515. execution. 
  27516.  
  27517.  
  27518. ΓòÉΓòÉΓòÉ 19.425. EDC3020 ΓòÉΓòÉΓòÉ
  27519.  
  27520. "asm" keyword declaration is not supported. 
  27521.  
  27522. The compiler does not support "asm" declarations.  The declaration is ignored. 
  27523.  
  27524. Recovery: Remove the "asm" keyword. 
  27525.  
  27526.  
  27527. ΓòÉΓòÉΓòÉ 19.426. EDC3021 ΓòÉΓòÉΓòÉ
  27528.  
  27529. Expected "end of line" and found "&1" in preprocessor directive. 
  27530.  
  27531. The compiler detected a preprocessor directive at the beginning of this line 
  27532. and then detected an error in the rest of the directive. The rest of the line 
  27533. in the preprocessor directive is ignored. 
  27534.  
  27535. Recovery: Remove the unexpected token so that only the preprocessor directive 
  27536. appears on the line. 
  27537.  
  27538.  
  27539. ΓòÉΓòÉΓòÉ 19.427. EDC3022 ΓòÉΓòÉΓòÉ
  27540.  
  27541. "&1" was previously declared as "&2". 
  27542.  
  27543. The declaration conflicts with a previous declaration of the same name. 
  27544.  
  27545. Recovery: Change one of the names or eliminate one of the declarations. 
  27546.  
  27547.  
  27548. ΓòÉΓòÉΓòÉ 19.428. EDC3023 ΓòÉΓòÉΓòÉ
  27549.  
  27550. "&1" has already been defined. 
  27551.  
  27552. An attempt is being made to define a name that has already been defined. 
  27553.  
  27554. Recovery: Change one of the names or remove one of the definitions.  Check the 
  27555. spelling or the scope of the two variables. 
  27556.  
  27557.  
  27558. ΓòÉΓòÉΓòÉ 19.429. EDC3024 ΓòÉΓòÉΓòÉ
  27559.  
  27560. Declaration of "&1" must be a function definition. 
  27561.  
  27562. A declaration of a member function outside its member list must be a function 
  27563. definition.  A method of a class that has already been declared inside a class 
  27564. declaration cannot be redeclared outside the class. 
  27565.  
  27566. Recovery: Either remove the member function declaration outside the member list 
  27567. or change it to a definition. 
  27568.  
  27569.  
  27570. ΓòÉΓòÉΓòÉ 19.430. EDC3025 ΓòÉΓòÉΓòÉ
  27571.  
  27572. "&1" conflicts with "&2". 
  27573.  
  27574. Both the specified attributes are part of a declaration but they cannot both be 
  27575. specified in the same declaration. 
  27576.  
  27577. Recovery: Remove one of the specified attributes. 
  27578.  
  27579.  
  27580. ΓòÉΓòÉΓòÉ 19.431. EDC3026 ΓòÉΓòÉΓòÉ
  27581.  
  27582. Keyword "&1" is not allowed. 
  27583.  
  27584. The specified keyword is not allowed in this context. 
  27585.  
  27586. Recovery: Remove the keyword. 
  27587.  
  27588.  
  27589. ΓòÉΓòÉΓòÉ 19.432. EDC3027 ΓòÉΓòÉΓòÉ
  27590.  
  27591. Preprocessor directive "#&1" is not recognized. 
  27592.  
  27593. The compiler identified a # character at the start of a line and could not 
  27594. recognize the preprocessor directive following it. 
  27595.  
  27596. Recovery: Check the spelling of the preprocessor directive. 
  27597.  
  27598.  
  27599. ΓòÉΓòÉΓòÉ 19.433. EDC3028 ΓòÉΓòÉΓòÉ
  27600.  
  27601. The syntax of the file name in the "#include" directive is not valid. 
  27602.  
  27603. The compiler detected an #include preprocessor directive but could not parse 
  27604. the file name.  The file name must be surrounded by a " or < after the #include 
  27605. directive. 
  27606.  
  27607. Recovery: Correct the syntax of the file name. 
  27608.  
  27609.  
  27610. ΓòÉΓòÉΓòÉ 19.434. EDC3029 ΓòÉΓòÉΓòÉ
  27611.  
  27612. Expected integer line number and found "&1". 
  27613.  
  27614. The operand of the "#line" directive must be an integer line number. 
  27615.  
  27616. Recovery: Ensure that the "#line" directive contains an integer line number 
  27617. operand. 
  27618.  
  27619.  
  27620. ΓòÉΓòÉΓòÉ 19.435. EDC3030 ΓòÉΓòÉΓòÉ
  27621.  
  27622. The macro "&1" has already been defined. 
  27623.  
  27624. An active definition already exists for the macro name being defined.  The 
  27625. second definition will be ignored. 
  27626.  
  27627. Recovery: Remove or rename one of the macro definitions. 
  27628.  
  27629.  
  27630. ΓòÉΓòÉΓòÉ 19.436. EDC3032 ΓòÉΓòÉΓòÉ
  27631.  
  27632. Unexpected preprocessor directive "#&1". 
  27633.  
  27634. An "#else", "#elif" or "#endif" preprocessor directive was found out of 
  27635. context. 
  27636.  
  27637. Recovery: Remove or move the preprocessor directive. 
  27638.  
  27639.  
  27640. ΓòÉΓòÉΓòÉ 19.437. EDC3033 ΓòÉΓòÉΓòÉ
  27641.  
  27642. The for-init-statement must be a declaration or expression. 
  27643.  
  27644. The initializer statement within a "for" statement must be a declaration or 
  27645. expression statement. 
  27646.  
  27647. Recovery: Change the for-init-statement to a declaration or an expression. 
  27648.  
  27649.  
  27650. ΓòÉΓòÉΓòÉ 19.438. EDC3034 ΓòÉΓòÉΓòÉ
  27651.  
  27652. "&1" has a function body but is not a function. 
  27653.  
  27654. The name is not declared as a function; there may be parentheses missing from 
  27655. the declaration. 
  27656.  
  27657. Recovery: Correct the declaration. 
  27658.  
  27659.  
  27660. ΓòÉΓòÉΓòÉ 19.439. EDC3035 ΓòÉΓòÉΓòÉ
  27661.  
  27662. The array bound in "&1" is missing. 
  27663.  
  27664. An array must be defined with at least one element.  Use a pointer is you want 
  27665. to dynamically allocate memory for the array. 
  27666.  
  27667. Recovery: Add an array bound. 
  27668.  
  27669.  
  27670. ΓòÉΓòÉΓòÉ 19.440. EDC3036 ΓòÉΓòÉΓòÉ
  27671.  
  27672. The bit-field length must be an integral constant expression. 
  27673.  
  27674. The bit-field width, which is the value to the right of the colon, must be an 
  27675. integer. 
  27676.  
  27677. Recovery: Change the bit-field length to an integral constant expression.  A 
  27678. constant expression has a value that can be determined during compilation and 
  27679. does not change during execution. 
  27680.  
  27681.  
  27682. ΓòÉΓòÉΓòÉ 19.441. EDC3037 ΓòÉΓòÉΓòÉ
  27683.  
  27684. "&1" is not a base class of "&2". 
  27685.  
  27686. A derived class can only access elements of its base class or base classes. 
  27687.  
  27688. Recovery: Ensure the class names are correct and the classes are derived 
  27689. properly. 
  27690.  
  27691.  
  27692. ΓòÉΓòÉΓòÉ 19.442. EDC3038 ΓòÉΓòÉΓòÉ
  27693.  
  27694. The array bound must be a positive integral constant expression. 
  27695.  
  27696. The compiler detected an array declaration that did not have a constant that is 
  27697. greater than 0 for the array bounds.  Use pointers if you want to dynamically 
  27698. allocate storage for arrays. 
  27699.  
  27700. Recovery: Change the array bound to an integral constant expression or change 
  27701. it to a pointer.  A constant expression has a value that can be determined 
  27702. during compilation and does not change during execution. 
  27703.  
  27704.  
  27705. ΓòÉΓòÉΓòÉ 19.443. EDC3039 ΓòÉΓòÉΓòÉ
  27706.  
  27707. "&1" has the same name as its containing class. 
  27708.  
  27709. The compiler has detected conflicting names for objects within a class 
  27710. declaration.  Note that nested class declarations must have different names. 
  27711.  
  27712. Recovery: Change the name of the conflicting class. 
  27713.  
  27714.  
  27715. ΓòÉΓòÉΓòÉ 19.444. EDC3040 ΓòÉΓòÉΓòÉ
  27716.  
  27717. A destructor can only be used in a function declaration or in a function call. 
  27718.  
  27719. The compiler has detected an incorrect destructor call. 
  27720.  
  27721. Recovery: Check the call to the destructor to ensure no braces are missing. If 
  27722. the braces are correct, remove the destructor call. 
  27723.  
  27724.  
  27725. ΓòÉΓòÉΓòÉ 19.445. EDC3041 ΓòÉΓòÉΓòÉ
  27726.  
  27727. An initializer is not allowed for "&1". 
  27728.  
  27729. Recovery: Remove the initializer. 
  27730.  
  27731.  
  27732. ΓòÉΓòÉΓòÉ 19.446. EDC3042 ΓòÉΓòÉΓòÉ
  27733.  
  27734. Function "&1" is nested within another function. 
  27735.  
  27736. Functions must not be nested in C++. 
  27737.  
  27738. Recovery: Ensure that a "}" is not missing before the start of the function. 
  27739.  
  27740.  
  27741. ΓòÉΓòÉΓòÉ 19.447. EDC3043 ΓòÉΓòÉΓòÉ
  27742.  
  27743. The string must be terminated before the end of the line. 
  27744.  
  27745. The compiler detected a string that was not terminated before an end-of-line 
  27746. character was found. 
  27747.  
  27748. Recovery: End the string or use "\" to continue the string on the next line. 
  27749. The "\" must be the last character on the line. 
  27750.  
  27751.  
  27752. ΓòÉΓòÉΓòÉ 19.448. EDC3044 ΓòÉΓòÉΓòÉ
  27753.  
  27754. extern "&1" is not a recognized linkage; extern "C" is assumed. 
  27755.  
  27756. The linkage string in a linkage declaration is not one of the linkages 
  27757. supported by this compiler. 
  27758.  
  27759. Recovery: Change the linkage string to a valid value or make it "C". 
  27760.  
  27761.  
  27762. ΓòÉΓòÉΓòÉ 19.449. EDC3045 ΓòÉΓòÉΓòÉ
  27763.  
  27764. Syntax error in directive - expected "&1" and found "&2". 
  27765.  
  27766. A syntax error was found during preprocessing.  The message identifies what the 
  27767. compiler expected and what it actually found. 
  27768.  
  27769. Recovery: Correct the syntax. 
  27770.  
  27771.  
  27772. ΓòÉΓòÉΓòÉ 19.450. EDC3046 ΓòÉΓòÉΓòÉ
  27773.  
  27774. "&1" is not a variable. 
  27775.  
  27776. The compiler detected a non-variable type where one was required. 
  27777.  
  27778. Recovery: Change the usage of the name. 
  27779.  
  27780.  
  27781. ΓòÉΓòÉΓòÉ 19.451. EDC3047 ΓòÉΓòÉΓòÉ
  27782.  
  27783. An expression of type "&1" cannot be followed by the function call operator (). 
  27784.  
  27785. The compiler detected an expression followed by the function call operator. 
  27786. The expression must be of type function, pointer to function or reference to 
  27787. function. 
  27788.  
  27789. Recovery: Change the type of expression or remove the function call operator. 
  27790.  
  27791.  
  27792. ΓòÉΓòÉΓòÉ 19.452. EDC3048 ΓòÉΓòÉΓòÉ
  27793.  
  27794. The "this" keyword is only valid in class scope. 
  27795.  
  27796. An attempt to use the C++ keyword "this" was detected outside class scope.  The 
  27797. keyword "this" cannot be used outside a class member function body. 
  27798.  
  27799. Recovery: Remove or move the "this" keyword. 
  27800.  
  27801.  
  27802. ΓòÉΓòÉΓòÉ 19.453. EDC3049 ΓòÉΓòÉΓòÉ
  27803.  
  27804. The option "&1" is not supported. 
  27805.  
  27806. The command line contained an option that is not supported.  Note that some 
  27807. option parameters must not have spaces between the option and the parameter. 
  27808.  
  27809. Recovery: Remove the option.  Check the syntax of the options. 
  27810.  
  27811.  
  27812. ΓòÉΓòÉΓòÉ 19.454. EDC3050 ΓòÉΓòÉΓòÉ
  27813.  
  27814. A destructor cannot have arguments. 
  27815.  
  27816. Recovery: Remove the arguments from the destructor. 
  27817.  
  27818.  
  27819. ΓòÉΓòÉΓòÉ 19.455. EDC3051 ΓòÉΓòÉΓòÉ
  27820.  
  27821. A declaration has been made without a type specification. 
  27822.  
  27823. The compiler detected a typedef specification that did not have a type 
  27824. associated with it. 
  27825.  
  27826. Recovery: Add a type specification to the declaration. 
  27827.  
  27828.  
  27829. ΓòÉΓòÉΓòÉ 19.456. EDC3052 ΓòÉΓòÉΓòÉ
  27830.  
  27831. Return type cannot be specified for "&1". 
  27832.  
  27833. The compiler detected a return type where one is not permitted. For example, 
  27834. putting a return type on a constructor is not permitted. 
  27835.  
  27836. Recovery: Remove the return type specification for the function. 
  27837.  
  27838.  
  27839. ΓòÉΓòÉΓòÉ 19.457. EDC3053 ΓòÉΓòÉΓòÉ
  27840.  
  27841. Class qualification for "&1" is not allowed. 
  27842.  
  27843. Explicit class qualification is not allowed in this context. 
  27844.  
  27845. Recovery: Remove the class qualification. 
  27846.  
  27847.  
  27848. ΓòÉΓòÉΓòÉ 19.458. EDC3054 ΓòÉΓòÉΓòÉ
  27849.  
  27850. The "&1" operator is not allowed between "&2" and "&3". 
  27851.  
  27852. The compiler detected an illegal operator between two operands. For 
  27853. user-defined types, the operator needs to be overloaded to accept the 
  27854. user-defined types. 
  27855.  
  27856. Recovery: Change the operator or change the operands. 
  27857.  
  27858.  
  27859. ΓòÉΓòÉΓòÉ 19.459. EDC3055 ΓòÉΓòÉΓòÉ
  27860.  
  27861. "&1" cannot be converted to "&2". 
  27862.  
  27863. The type conversion cannot be performed.  This can occur in an initialization, 
  27864. assignment, or expression statement. 
  27865.  
  27866. Recovery: Change one of the types or overload the operator. 
  27867.  
  27868.  
  27869. ΓòÉΓòÉΓòÉ 19.460. EDC3056 ΓòÉΓòÉΓòÉ
  27870.  
  27871. Operand for "&1" must be a pointer or an array. 
  27872.  
  27873. Recovery: Change the operand to either a pointer or an array. 
  27874.  
  27875.  
  27876. ΓòÉΓòÉΓòÉ 19.461. EDC3057 ΓòÉΓòÉΓòÉ
  27877.  
  27878. Syntax error - "&1" is not a class name. 
  27879.  
  27880. A class name must be specified in this context. 
  27881.  
  27882. Recovery: Specify a class name.  Check the spelling. 
  27883.  
  27884.  
  27885. ΓòÉΓòÉΓòÉ 19.462. EDC3058 ΓòÉΓòÉΓòÉ
  27886.  
  27887. Operand of "&1" operator must be an lvalue. 
  27888.  
  27889. The compiler detected an operand that is not an lvalue. For example, the left 
  27890. hand side of an assignment statement must be an lvalue.  An lvalue is an 
  27891. expression that represents an object. 
  27892.  
  27893. Recovery: Change the operand to an lvalue. 
  27894.  
  27895.  
  27896. ΓòÉΓòÉΓòÉ 19.463. EDC3059 ΓòÉΓòÉΓòÉ
  27897.  
  27898. const expression cannot be modified. 
  27899.  
  27900. A const object may be initialized but its value cannot change afterwards. 
  27901.  
  27902. Recovery: Eliminate the const type qualifier from the expression or remove it 
  27903. from increment/decrement operators. 
  27904.  
  27905.  
  27906. ΓòÉΓòÉΓòÉ 19.464. EDC3060 ΓòÉΓòÉΓòÉ
  27907.  
  27908. An expression of type "&1" is not allowed on the left side of "&2". 
  27909.  
  27910. The compiler detected a mismatch between the operands of an operator. 
  27911.  
  27912. Recovery: Change the type or operator. 
  27913.  
  27914.  
  27915. ΓòÉΓòÉΓòÉ 19.465. EDC3061 ΓòÉΓòÉΓòÉ
  27916.  
  27917. "&1" is neither a base class nor a non-static member of class "&2". 
  27918.  
  27919. The compiler has detected an element of the initializer list that is not an 
  27920. element of the member list. Only immediate base classes and members not 
  27921. inherited from a base class may be initialized using the constructor 
  27922. initializer list. 
  27923.  
  27924. Recovery: Change the constructor initializer list. 
  27925.  
  27926.  
  27927. ΓòÉΓòÉΓòÉ 19.466. EDC3062 ΓòÉΓòÉΓòÉ
  27928.  
  27929. Constructor init list is not allowed for non-constructor function. 
  27930.  
  27931. Recovery: Remove the constructor initializer list. 
  27932.  
  27933.  
  27934. ΓòÉΓòÉΓòÉ 19.467. EDC3063 ΓòÉΓòÉΓòÉ
  27935.  
  27936. Variable "&1" is not allowed in an argument initializer. 
  27937.  
  27938. The compiler has detected an illegal variable in an argument initializer. 
  27939.  
  27940. Recovery: Remove the variable from the argument initializer. 
  27941.  
  27942.  
  27943. ΓòÉΓòÉΓòÉ 19.468. EDC3064 ΓòÉΓòÉΓòÉ
  27944.  
  27945. There are too many initializers in the initializer list. 
  27946.  
  27947. The compiler detected more initializers than were present in the declaration. 
  27948.  
  27949. Recovery: Remove one or more initializers from the initializer list. 
  27950.  
  27951.  
  27952. ΓòÉΓòÉΓòÉ 19.469. EDC3065 ΓòÉΓòÉΓòÉ
  27953.  
  27954. An initializer is not allowed for an array allocated by "new". 
  27955.  
  27956. Recovery: Remove the initializer or the "new" allocation. 
  27957.  
  27958.  
  27959. ΓòÉΓòÉΓòÉ 19.470. EDC3066 ΓòÉΓòÉΓòÉ
  27960.  
  27961. The bit-field length must not be more than &1. 
  27962.  
  27963. The bit-field length must not exceed the maximum bit size of the bit-field 
  27964. type. 
  27965.  
  27966. Recovery: Reduce the bit-field length. 
  27967.  
  27968.  
  27969. ΓòÉΓòÉΓòÉ 19.471. EDC3067 ΓòÉΓòÉΓòÉ
  27970.  
  27971. The type of "&1" cannot be "&2". 
  27972.  
  27973. The compiler detected a conflict in a type declaration. 
  27974.  
  27975. Recovery: Change the type. 
  27976.  
  27977.  
  27978. ΓòÉΓòÉΓòÉ 19.472. EDC3068 ΓòÉΓòÉΓòÉ
  27979.  
  27980. Function overloading conflict between "&1" and "&2". 
  27981.  
  27982. The compiler detected function argument types that it could not resolve to be 
  27983. unique. 
  27984.  
  27985. Recovery: Check the declarations of the functions. 
  27986.  
  27987.  
  27988. ΓòÉΓòÉΓòÉ 19.473. EDC3069 ΓòÉΓòÉΓòÉ
  27989.  
  27990. Declarations of the same &1 must not specify default initializers for the same 
  27991. argument. 
  27992.  
  27993. The compiler has detected an overloaded function or template that was declared 
  27994. with the same argument having default initializers. 
  27995.  
  27996. Recovery: Ensure that you wanted to declare the same function or template. If 
  27997. that is the case, remove one of the default initializers. Otherwise, remove one 
  27998. of the declarations or overload the function. 
  27999.  
  28000.  
  28001. ΓòÉΓòÉΓòÉ 19.474. EDC3070 ΓòÉΓòÉΓòÉ
  28002.  
  28003. Call does not match any argument list for "&1". 
  28004.  
  28005. No variant of the overloaded function matches the argument list on the call any 
  28006. better than all other variants.  The argument mismatch could be by type or 
  28007. number of arguments. 
  28008.  
  28009. Recovery: Change the argument list on the call to the overloaded function or 
  28010. change the argument list on one of the overloaded function variants so that a 
  28011. match is found. 
  28012.  
  28013.  
  28014. ΓòÉΓòÉΓòÉ 19.475. EDC3071 ΓòÉΓòÉΓòÉ
  28015.  
  28016. Call to "&1" matches more than one function. 
  28017.  
  28018. More than one variant of the overloaded function matches equally well with the 
  28019. argument list specified on the call. 
  28020.  
  28021. Recovery: Change the argument list on the call to the overloaded function or 
  28022. change the argument list on one of the overloaded function variants so that one 
  28023. match is found. 
  28024.  
  28025.  
  28026. ΓòÉΓòÉΓòÉ 19.476. EDC3072 ΓòÉΓòÉΓòÉ
  28027.  
  28028. Linkage for "&1" cannot be redefined. 
  28029.  
  28030. The specified name has already been declared with a different linkage than the 
  28031. current declaration. 
  28032.  
  28033. Recovery: Remove the redefinition or change one of the names. 
  28034.  
  28035.  
  28036. ΓòÉΓòÉΓòÉ 19.477. EDC3073 ΓòÉΓòÉΓòÉ
  28037.  
  28038. The "operator" declaration must declare a function. 
  28039.  
  28040. The keyword "operator" can only be used to declare an operator function. 
  28041.  
  28042. Recovery: Check the declaration of the operator and make sure the function 
  28043. declarator () appears after it.  Use the "operator" keyword to declare an 
  28044. operator function or remove it. 
  28045.  
  28046.  
  28047. ΓòÉΓòÉΓòÉ 19.478. EDC3074 ΓòÉΓòÉΓòÉ
  28048.  
  28049. Operand for "&1" is of type "&2" which is not a member pointer type. 
  28050.  
  28051. The specified operator must have an operand which is of type pointer to member. 
  28052.  
  28053. Recovery: Change the operand to type pointer to member. 
  28054.  
  28055.  
  28056. ΓòÉΓòÉΓòÉ 19.479. EDC3075 ΓòÉΓòÉΓòÉ
  28057.  
  28058. "&1" is not allowed as a function return type. 
  28059.  
  28060. A function cannot be declared with a function or an array as its return type. 
  28061.  
  28062. Recovery: Declare the function as returning a pointer to the function or the 
  28063. array element type. 
  28064.  
  28065.  
  28066. ΓòÉΓòÉΓòÉ 19.480. EDC3076 ΓòÉΓòÉΓòÉ
  28067.  
  28068. "&1" is not allowed as an array element type. 
  28069.  
  28070. The C++ language does not allow the declaration of an array of functions, 
  28071. references or void. 
  28072.  
  28073. Recovery: Remove the declaration or change the declaration so that it is an 
  28074. array of pointer to functions, references, or void. 
  28075.  
  28076.  
  28077. ΓòÉΓòÉΓòÉ 19.481. EDC3077 ΓòÉΓòÉΓòÉ
  28078.  
  28079. const variable "&1" does not have an initializer. 
  28080.  
  28081. A const variable can only be assigned a value is with an initializer.  This 
  28082. variable has no initializer, so it can never be given a value. 
  28083.  
  28084. Recovery: Initialize the variable or remove the "const" keyword. 
  28085.  
  28086.  
  28087. ΓòÉΓòÉΓòÉ 19.482. EDC3078 ΓòÉΓòÉΓòÉ
  28088.  
  28089. Non-static member "&1" must be associated with an object or a pointer to an 
  28090. object. 
  28091.  
  28092. The compiler detected a non-static member that makes reference to a specific 
  28093. object that has not been instantiated. Only static members can be referenced 
  28094. without associating them with an instance of the containing class. 
  28095.  
  28096. Recovery: Check the spelling and the class definition.  Change the name of the 
  28097. class or function, or define the function as static in that class. 
  28098.  
  28099.  
  28100. ΓòÉΓòÉΓòÉ 19.483. EDC3079 ΓòÉΓòÉΓòÉ
  28101.  
  28102. "&1" is not a member of "&2". 
  28103.  
  28104. The name has been explicitly given the specified class as a scope qualifier but 
  28105. the class does not contain a member of that name. 
  28106.  
  28107. Recovery: Check the spelling of the scope qualifier. 
  28108.  
  28109.  
  28110. ΓòÉΓòÉΓòÉ 19.484. EDC3080 ΓòÉΓòÉΓòÉ
  28111.  
  28112. Wrong number of arguments for "&1". 
  28113.  
  28114. Either a function or an explicit cast has been specified with the wrong number 
  28115. of arguments. 
  28116.  
  28117. Recovery: Use the correct number of arguments.  Ensure that overloaded 
  28118. functions have the correct number and type of arguments. 
  28119.  
  28120.  
  28121. ΓòÉΓòÉΓòÉ 19.485. EDC3081 ΓòÉΓòÉΓòÉ
  28122.  
  28123. "&1" must be a class member. 
  28124.  
  28125. Conversion functions and certain operator functions must be class members. 
  28126. They cannot be defined globally. 
  28127.  
  28128. Recovery: Remove the global definition or make "&1" a class member. 
  28129.  
  28130.  
  28131. ΓòÉΓòÉΓòÉ 19.486. EDC3082 ΓòÉΓòÉΓòÉ
  28132.  
  28133. An argument type of "&1" is not allowed for "&2". 
  28134.  
  28135. This is a declaration of a function that has restrictions on what types its 
  28136. arguments can have.  The specified type is not allowed for this argument. 
  28137.  
  28138. Recovery: Change the argument type. 
  28139.  
  28140.  
  28141. ΓòÉΓòÉΓòÉ 19.487. EDC3083 ΓòÉΓòÉΓòÉ
  28142.  
  28143. "&2" cannot have a return type of "&1". 
  28144.  
  28145. The specified operator function has the wrong return type. 
  28146.  
  28147. Recovery: Change the return type. 
  28148.  
  28149.  
  28150. ΓòÉΓòÉΓòÉ 19.488. EDC3084 ΓòÉΓòÉΓòÉ
  28151.  
  28152. One of the operands for the array operator must be of pointer type and the 
  28153. other operand must be of integral type. 
  28154.  
  28155. This error may result from the improper use of the array operator. 
  28156.  
  28157. Recovery: Change the operands of the array operator. 
  28158.  
  28159.  
  28160. ΓòÉΓòÉΓòÉ 19.489. EDC3085 ΓòÉΓòÉΓòÉ
  28161.  
  28162. Wrong number of arguments specified in the function call. 
  28163.  
  28164. The number of arguments in the function call does not match the number of 
  28165. arguments in the function declaration. 
  28166.  
  28167. Recovery: Specify the correct number of arguments. 
  28168.  
  28169.  
  28170. ΓòÉΓòÉΓòÉ 19.490. EDC3086 ΓòÉΓòÉΓòÉ
  28171.  
  28172. &1 
  28173.  
  28174. This message has been generated by the "#error" preprocessor directive, which 
  28175. is a user-defined error message placed in the source code. 
  28176.  
  28177.  
  28178. ΓòÉΓòÉΓòÉ 19.491. EDC3087 ΓòÉΓòÉΓòÉ
  28179.  
  28180. "&1" operator is not allowed for type "&2". 
  28181.  
  28182. The specified operator cannot be used with operands of this type. 
  28183.  
  28184. Recovery: Change either the operator or the operands. 
  28185.  
  28186.  
  28187. ΓòÉΓòÉΓòÉ 19.492. EDC3088 ΓòÉΓòÉΓòÉ
  28188.  
  28189. Insufficient memory. 
  28190.  
  28191. The compiler ran out of memory during compilation. 
  28192.  
  28193. Recovery: End unnecessary processes and recompile. 
  28194.  
  28195.  
  28196. ΓòÉΓòÉΓòÉ 19.493. EDC3089 ΓòÉΓòÉΓòÉ
  28197.  
  28198. More than one function "&1" has non-C++ linkage. 
  28199.  
  28200. If a function is overloaded, at most one of its variants can have non-C++ 
  28201. linkage. 
  28202.  
  28203. Recovery: Remove one of the non-C++ linkages or do not overload the function. 
  28204.  
  28205.  
  28206. ΓòÉΓòÉΓòÉ 19.494. EDC3090 ΓòÉΓòÉΓòÉ
  28207.  
  28208. Syntax error - expected "&1" and found "&2". 
  28209.  
  28210. A syntax error was found while parsing the program.  The message identifies 
  28211. what the compiler expected and what it actually found. Often the source of the 
  28212. error is an unmatched parenthesis or a missing semicolon. 
  28213.  
  28214. Recovery: Correct the syntax. 
  28215.  
  28216.  
  28217. ΓòÉΓòÉΓòÉ 19.495. EDC3091 ΓòÉΓòÉΓòÉ
  28218.  
  28219. "&1" is not allowed for &2. 
  28220.  
  28221. The attribute or name cannot be specified in the given context. The compiler 
  28222. detected incompatible names that conflicts with the language definition. 
  28223.  
  28224. Recovery: Remove the attribute or name. 
  28225.  
  28226.  
  28227. ΓòÉΓòÉΓòÉ 19.496. EDC3092 ΓòÉΓòÉΓòÉ
  28228.  
  28229. "&1" conflicts with previous "&2" declaration. 
  28230.  
  28231. The declaration conflicts with a previous declaration of the same symbol. 
  28232.  
  28233. Recovery: Remove one of the declarations. 
  28234.  
  28235.  
  28236. ΓòÉΓòÉΓòÉ 19.497. EDC3093 ΓòÉΓòÉΓòÉ
  28237.  
  28238. Initializer is too long. 
  28239.  
  28240. The string initializer for a character or wide-character array has more 
  28241. characters than the array.  Note that the trailing null character is treated as 
  28242. part of the initializer. 
  28243.  
  28244. Recovery: Increase the array or reduce the initializer. 
  28245.  
  28246.  
  28247. ΓòÉΓòÉΓòÉ 19.498. EDC3094 ΓòÉΓòÉΓòÉ
  28248.  
  28249. The "operator->" function must return either a class type, a reference to a 
  28250. class type or a pointer to class type and the class type must itself have an 
  28251. "operator->" function. 
  28252.  
  28253. Recovery: Change the return value of the "operator" function. 
  28254.  
  28255.  
  28256. ΓòÉΓòÉΓòÉ 19.499. EDC3095 ΓòÉΓòÉΓòÉ
  28257.  
  28258. Unused "&1" definition. 
  28259.  
  28260. This is an unnamed class or struct definition that has no object associated 
  28261. with it.  The definition can never be referenced. A class can be unnamed, but 
  28262. it cannot be passed as an argument or returned as a value.  An unnamed class 
  28263. cannot have any constructors or destructors. 
  28264.  
  28265. Recovery: Create an object for the class or struct, or remove the definition. 
  28266.  
  28267.  
  28268. ΓòÉΓòÉΓòÉ 19.500. EDC3096 ΓòÉΓòÉΓòÉ
  28269.  
  28270. Internal compiler error at line &1 in module "&2": &3. 
  28271.  
  28272. The compiler detected an error that it is not able to recover from. The error 
  28273. was found within the compiler itself. 
  28274.  
  28275. Recovery: Note the line and module references in this message.  Contact your 
  28276. IBM Representative. 
  28277.  
  28278.  
  28279. ΓòÉΓòÉΓòÉ 19.501. EDC3097 ΓòÉΓòÉΓòÉ
  28280.  
  28281. Reference to member "&1" of undefined class "&2". 
  28282.  
  28283. The member has been explicitly given the specified class as a scope qualifier 
  28284. but the class (and hence the member) has not been defined. 
  28285.  
  28286. Recovery: Check for a missing #include file.  Define the class and member. 
  28287.  
  28288.  
  28289. ΓòÉΓòÉΓòÉ 19.502. EDC3098 ΓòÉΓòÉΓòÉ
  28290.  
  28291. Pointer conversion may be wrong if the classes are related in a multiple 
  28292. inheritance hierarchy. 
  28293.  
  28294. The relationship between the classes in a pointer conversion is not known.  If 
  28295. the target class is later defined as a base class of the source class in a 
  28296. multiple inheritance, this conversion will be wrong if the value of the pointer 
  28297. should have been modified by the conversion. 
  28298.  
  28299. Recovery: Change the ambiguous reference in the conversion. 
  28300.  
  28301.  
  28302. ΓòÉΓòÉΓòÉ 19.503. EDC3099 ΓòÉΓòÉΓòÉ
  28303.  
  28304. "&1" is used but not set in function "&2". 
  28305.  
  28306. The specified symbol is being used but has not been assigned a valid value. 
  28307. Its value will be undefined. 
  28308.  
  28309. Recovery: Define or initialize the symbol before using it. 
  28310.  
  28311.  
  28312. ΓòÉΓòÉΓòÉ 19.504. EDC3100 ΓòÉΓòÉΓòÉ
  28313.  
  28314. "&1" is set but not used in function "&2". 
  28315.  
  28316. The specified symbol has been given a value but the symbol has not been used. 
  28317.  
  28318. Recovery: Use the symbol or remove it. 
  28319.  
  28320.  
  28321. ΓòÉΓòÉΓòÉ 19.505. EDC3101 ΓòÉΓòÉΓòÉ
  28322.  
  28323. "&1" may be used before being set. 
  28324.  
  28325. The specified symbol is being used before it has been assigned a value.  The 
  28326. value of the symbol is undefined. 
  28327.  
  28328. Recovery: Define or initialize the symbol before using it. 
  28329.  
  28330.  
  28331. ΓòÉΓòÉΓòÉ 19.506. EDC3102 ΓòÉΓòÉΓòÉ
  28332.  
  28333. The reference variable "&1" is uninitialized. 
  28334.  
  28335. Reference variables must be initialized. 
  28336.  
  28337. Recovery: Initialize the reference variable or remove it. 
  28338.  
  28339.  
  28340. ΓòÉΓòÉΓòÉ 19.507. EDC3103 ΓòÉΓòÉΓòÉ
  28341.  
  28342. "&1" must already be declared. 
  28343.  
  28344. The specified class or enum name must have been declared before this use of the 
  28345. name. 
  28346.  
  28347. Recovery: Rename or remove the declaration. 
  28348.  
  28349.  
  28350. ΓòÉΓòÉΓòÉ 19.508. EDC3104 ΓòÉΓòÉΓòÉ
  28351.  
  28352. Unrecognized source character "&1", code point &2. 
  28353.  
  28354. The specified character is not a valid character in a C++ program. The code 
  28355. point represents the ASCII value of the character displayed in hexadecimal 
  28356. format. 
  28357.  
  28358. Recovery: Remove the character. 
  28359.  
  28360.  
  28361. ΓòÉΓòÉΓòÉ 19.509. EDC3105 ΓòÉΓòÉΓòÉ
  28362.  
  28363. A local class cannot have a non-inline member function "&1". 
  28364.  
  28365. A class declared within a function must have all of its member functions 
  28366. defined inline, since the class will go out of scope before non-inline 
  28367. functions can be defined. 
  28368.  
  28369. Recovery: Define the functions inline, or move the class definition out of the 
  28370. scope of the function. 
  28371.  
  28372.  
  28373. ΓòÉΓòÉΓòÉ 19.510. EDC3106 ΓòÉΓòÉΓòÉ
  28374.  
  28375. The size of "&1" is unknown. 
  28376.  
  28377. The operation cannot be performed because the size of the specified type is not 
  28378. known. 
  28379.  
  28380. Recovery: Specify the size of the type. 
  28381.  
  28382.  
  28383. ΓòÉΓòÉΓòÉ 19.511. EDC3107 ΓòÉΓòÉΓòÉ
  28384.  
  28385. Assignment in logical expression. 
  28386.  
  28387. The logical expression contains an assignment (=).  An equality equality 
  28388. comparison (==) may have been intended. 
  28389.  
  28390. Recovery: Change the operator or the expression. 
  28391.  
  28392.  
  28393. ΓòÉΓòÉΓòÉ 19.512. EDC3108 ΓòÉΓòÉΓòÉ
  28394.  
  28395. Conversion from "&1" to "&2" may cause truncation. 
  28396.  
  28397. The specified conversion from a wider to a narrower type may cause the loss of 
  28398. significant data. 
  28399.  
  28400. Recovery: Remove the conversion from a wider to a narrower type. 
  28401.  
  28402.  
  28403. ΓòÉΓòÉΓòÉ 19.513. EDC3109 ΓòÉΓòÉΓòÉ
  28404.  
  28405. "goto &1" bypasses initialization of "&2". 
  28406.  
  28407. Jumping past a declaration with an explicit or implicit initializer is not 
  28408. valid unless the declaration is in an inner block or unless the jump is from a 
  28409. point where the variable has already been initialized. 
  28410.  
  28411. Recovery: Enclose the initialization in a block statement. 
  28412.  
  28413.  
  28414. ΓòÉΓòÉΓòÉ 19.514. EDC3110 ΓòÉΓòÉΓòÉ
  28415.  
  28416. References to "&1" may be ambiguous. The name is declared in base classes "&2" 
  28417. and "&3". 
  28418.  
  28419. Recovery: Change one of the names, or always fully qualify the name. 
  28420.  
  28421.  
  28422. ΓòÉΓòÉΓòÉ 19.515. EDC3111 ΓòÉΓòÉΓòÉ
  28423.  
  28424. Ambiguous reference to "&1", declared in base classes "&2" and "&3". 
  28425.  
  28426. The name is a member of more than one base class and the compiler cannot 
  28427. determine which one to choose. 
  28428.  
  28429. Recovery: Change one of the names, or always fully qualify the name. 
  28430.  
  28431.  
  28432. ΓòÉΓòÉΓòÉ 19.516. EDC3112 ΓòÉΓòÉΓòÉ
  28433.  
  28434. Conversion from "&1" to "&2" is ambiguous. 
  28435.  
  28436. There is more than one way to perform the specified conversion. This may be 
  28437. caused by an overloaded function. 
  28438.  
  28439. Recovery: Change or remove the conversion. 
  28440.  
  28441.  
  28442. ΓòÉΓòÉΓòÉ 19.517. EDC3113 ΓòÉΓòÉΓòÉ
  28443.  
  28444. "&1" is only valid for non-static member functions. 
  28445.  
  28446. const and volatile are only significant for non-static member functions, since 
  28447. they are applied to the "this" pointer. 
  28448.  
  28449. Recovery: Remove const and volatile from all static members. 
  28450.  
  28451.  
  28452. ΓòÉΓòÉΓòÉ 19.518. EDC3114 ΓòÉΓòÉΓòÉ
  28453.  
  28454. Duplicate case value. 
  28455.  
  28456. Case values must be unique within each "switch" statement. 
  28457.  
  28458. Recovery: Change or remove one of the duplicate case values.  Check the braces 
  28459. if you have nested case statements. 
  28460.  
  28461.  
  28462. ΓòÉΓòÉΓòÉ 19.519. EDC3115 ΓòÉΓòÉΓòÉ
  28463.  
  28464. Character literal is null. 
  28465.  
  28466. An empty character literal has been specified.  A string literal may have been 
  28467. intended. 
  28468.  
  28469. Recovery: Remove the character literal, change it to a string literal, or give 
  28470. it a value. 
  28471.  
  28472.  
  28473. ΓòÉΓòÉΓòÉ 19.520. EDC3116 ΓòÉΓòÉΓòÉ
  28474.  
  28475. "&1" is given wider scope for compatibility reasons. 
  28476.  
  28477. A type defined in class scope has been given the scope of the enclosing 
  28478. function or file because of a compiler option. 
  28479.  
  28480. Recovery: Ensure this is the desired response. 
  28481.  
  28482.  
  28483. ΓòÉΓòÉΓòÉ 19.521. EDC3117 ΓòÉΓòÉΓòÉ
  28484.  
  28485. "&1" has more than one base class "&2". 
  28486.  
  28487. A derived class has inherited the same base class in more than one path and the 
  28488. compiler cannot determine which one to choose. 
  28489.  
  28490. Recovery: Remove one of the inheritances. 
  28491.  
  28492.  
  28493. ΓòÉΓòÉΓòÉ 19.522. EDC3118 ΓòÉΓòÉΓòÉ
  28494.  
  28495. "&1" is a &2 base class of "&3". 
  28496.  
  28497. An attempt is being made to convert a pointer to a derived class into a pointer 
  28498. to a private or protected base class. 
  28499.  
  28500. Recovery: Remove the pointer conversion. 
  28501.  
  28502.  
  28503. ΓòÉΓòÉΓòÉ 19.523. EDC3119 ΓòÉΓòÉΓòÉ
  28504.  
  28505. The statement is unreachable. 
  28506.  
  28507. Flow of control in the program is never allows the statement to be be reached. 
  28508.  
  28509. Recovery: Ensure that the statement is accessible to the flow of control, or 
  28510. remove the statement. 
  28511.  
  28512.  
  28513. ΓòÉΓòÉΓòÉ 19.524. EDC3120 ΓòÉΓòÉΓòÉ
  28514.  
  28515. &1 "&2" is not allowed in a union. 
  28516.  
  28517. Unions must not be declared with base classes, virtual functions, static data 
  28518. members, members with constructors, members with destructors or members with 
  28519. class copying assignment operators. 
  28520.  
  28521. Recovery: Remove any such members from the union declaration. 
  28522.  
  28523.  
  28524. ΓòÉΓòÉΓòÉ 19.525. EDC3121 ΓòÉΓòÉΓòÉ
  28525.  
  28526. union "&1" cannot be used as a base class. 
  28527.  
  28528. Unions cannot be used as base classes for other class declarations. 
  28529.  
  28530. Recovery: Remove the union as a base class for other class declarations. 
  28531.  
  28532.  
  28533. ΓòÉΓòÉΓòÉ 19.526. EDC3122 ΓòÉΓòÉΓòÉ
  28534.  
  28535. Local variable "&1" is inaccessible from "&2". 
  28536.  
  28537. An automatic variable within a function is not accessible from local classes 
  28538. declared within the function. 
  28539.  
  28540. Recovery: Remove the reference to the local variable. 
  28541.  
  28542.  
  28543. ΓòÉΓòÉΓòÉ 19.527. EDC3123 ΓòÉΓòÉΓòÉ
  28544.  
  28545. Value of enumerator "&1" is too large. 
  28546.  
  28547. The value of an enumerator must be a constant expression that is promotable to 
  28548. a signed int value. 
  28549.  
  28550. Recovery: Reduce the value of the enumerator. 
  28551.  
  28552.  
  28553. ΓòÉΓòÉΓòÉ 19.528. EDC3124 ΓòÉΓòÉΓòÉ
  28554.  
  28555. Missing path name in include directive. 
  28556.  
  28557. Recovery: Add path name to the #include directive. 
  28558.  
  28559.  
  28560. ΓòÉΓòÉΓòÉ 19.529. EDC3125 ΓòÉΓòÉΓòÉ
  28561.  
  28562. Missing "#define" or "#undef". 
  28563.  
  28564. Recovery: Add "#define" or "#undef". 
  28565.  
  28566.  
  28567. ΓòÉΓòÉΓòÉ 19.530. EDC3126 ΓòÉΓòÉΓòÉ
  28568.  
  28569. Argument "&1" is not used in function "&2". 
  28570.  
  28571. The specified symbol has been declared as an argument to a function but has not 
  28572. been set or used. 
  28573.  
  28574. Recovery: Use the symbol or remove it. 
  28575.  
  28576.  
  28577. ΓòÉΓòÉΓòÉ 19.531. EDC3127 ΓòÉΓòÉΓòÉ
  28578.  
  28579. Global symbol "&1" is not used. 
  28580.  
  28581. The specified symbol has been declared as a global symbol but has not been set 
  28582. or used. 
  28583.  
  28584. Recovery: Remove the symbol or remove it. 
  28585.  
  28586.  
  28587. ΓòÉΓòÉΓòÉ 19.532. EDC3128 ΓòÉΓòÉΓòÉ
  28588.  
  28589. "main" returns an uninitialized value to the invocation environment. 
  28590.  
  28591. No return value is being returned from main() but main() has a non-void return 
  28592. value. 
  28593.  
  28594. Recovery: Return a value from "main" or declare it as "void". 
  28595.  
  28596.  
  28597. ΓòÉΓòÉΓòÉ 19.533. EDC3129 ΓòÉΓòÉΓòÉ
  28598.  
  28599. Default initializers are not allowed in local friend functions. 
  28600.  
  28601. Recovery: Remove the default initializers from the local friend function. 
  28602.  
  28603.  
  28604. ΓòÉΓòÉΓòÉ 19.534. EDC3130 ΓòÉΓòÉΓòÉ
  28605.  
  28606. A constant is being used as a conditional expression. 
  28607.  
  28608. The condition to an if, for, or switch is constant. 
  28609.  
  28610. Recovery: Remove the constant from the conditional expression or ignore this 
  28611. message. 
  28612.  
  28613.  
  28614. ΓòÉΓòÉΓòÉ 19.535. EDC3131 ΓòÉΓòÉΓòÉ
  28615.  
  28616. The argument to a not (!) operator is constant. 
  28617.  
  28618. The compiler has detected a constant after the ! operator which may be a coding 
  28619. error. 
  28620.  
  28621. Recovery: Remove the constant or ignore this message. 
  28622.  
  28623.  
  28624. ΓòÉΓòÉΓòÉ 19.536. EDC3132 ΓòÉΓòÉΓòÉ
  28625.  
  28626. There is more than one character in a character constant. 
  28627.  
  28628. Using more than one character in a character constant (for example, 'ab') may 
  28629. not be portable across machines. 
  28630.  
  28631. Recovery: Remove the extra character(s) or change the character constant to a 
  28632. string constant. 
  28633.  
  28634.  
  28635. ΓòÉΓòÉΓòÉ 19.537. EDC3133 ΓòÉΓòÉΓòÉ
  28636.  
  28637. Possible pointer alignment problem with the "&1" operator. 
  28638.  
  28639. A pointer that points to an object of loose alignment is being assigned, cast, 
  28640. returned or passed as a parameter to a pointer of stricter alignment. 
  28641.  
  28642. Recovery: Remove the pointer reference or change the alignment. 
  28643.  
  28644.  
  28645. ΓòÉΓòÉΓòÉ 19.538. EDC3134 ΓòÉΓòÉΓòÉ
  28646.  
  28647. A constant expression is being cast to a pointer. 
  28648.  
  28649. A constant value is being cast to a pointer.  This is nonportable. 
  28650.  
  28651. Recovery: Remove the constant expression from the cast expression. 
  28652.  
  28653.  
  28654. ΓòÉΓòÉΓòÉ 19.539. EDC3135 ΓòÉΓòÉΓòÉ
  28655.  
  28656. Precision was lost in assignment to a (possibly sign-extended) field. 
  28657.  
  28658. Recovery: Change the assignment expression. 
  28659.  
  28660.  
  28661. ΓòÉΓòÉΓòÉ 19.540. EDC3136 ΓòÉΓòÉΓòÉ
  28662.  
  28663. Precision was lost in field assignment. 
  28664.  
  28665. Recovery: Change the assignment expression. 
  28666.  
  28667.  
  28668. ΓòÉΓòÉΓòÉ 19.541. EDC3137 ΓòÉΓòÉΓòÉ
  28669.  
  28670. Enumeration type clash with the "&1" operator. 
  28671.  
  28672. Operands from two different enumerations are used in an operation. 
  28673.  
  28674. Recovery: Ensure both operands are from the same enumeration. 
  28675.  
  28676.  
  28677. ΓòÉΓòÉΓòÉ 19.542. EDC3138 ΓòÉΓòÉΓòÉ
  28678.  
  28679. Comparison of an unsigned value with a negative constant. 
  28680.  
  28681. An unsigned value is being compared to a negative number. 
  28682.  
  28683. Recovery: Remove the comparison or change the type. 
  28684.  
  28685.  
  28686. ΓòÉΓòÉΓòÉ 19.543. EDC3139 ΓòÉΓòÉΓòÉ
  28687.  
  28688. Unsigned comparision is always true or always false. 
  28689.  
  28690. The comparison is either unsigned >= 0 which is always true or unsigned < 0 
  28691. which is always false. 
  28692.  
  28693. Recovery: Remove or change the comparison. 
  28694.  
  28695.  
  28696. ΓòÉΓòÉΓòÉ 19.544. EDC3140 ΓòÉΓòÉΓòÉ
  28697.  
  28698. Comparison is equivalent to "unsigned value &1 0". 
  28699.  
  28700. The comparison is either "unsigned > 0" or "unsigned <= 0", and could be 
  28701. written as "unsigned != 0" or "unsigned == 0". 
  28702.  
  28703. Recovery: Change the comparison. 
  28704.  
  28705.  
  28706. ΓòÉΓòÉΓòÉ 19.545. EDC3141 ΓòÉΓòÉΓòÉ
  28707.  
  28708. Argument &1 for "&2" must be of type "&3". 
  28709.  
  28710. For this type of function, the specified argument must be of a particular type 
  28711. but the specified type is of a particular type that is different from the type 
  28712. specified. 
  28713.  
  28714. Recovery: Ensure that the argument is of the correct type. 
  28715.  
  28716.  
  28717. ΓòÉΓòÉΓòÉ 19.546. EDC3142 ΓòÉΓòÉΓòÉ
  28718.  
  28719. The operand for the "#line" directive must be an integer in the range 1 to 
  28720. 32767. 
  28721.  
  28722. The operand of the "#line" directive must be an integer in the specified range. 
  28723.  
  28724. Recovery: Ensure that the operand is in the specified range. 
  28725.  
  28726.  
  28727. ΓòÉΓòÉΓòÉ 19.547. EDC3143 ΓòÉΓòÉΓòÉ
  28728.  
  28729. Definition of "&1" is not allowed. 
  28730.  
  28731. The specified type is being defined in a place where it is not valid to do so; 
  28732. that is, in a type cast or a conversion function declaration. 
  28733.  
  28734. Recovery: Move the definition to a new location, or remove it. 
  28735.  
  28736.  
  28737. ΓòÉΓòÉΓòÉ 19.548. EDC3144 ΓòÉΓòÉΓòÉ
  28738.  
  28739. Reference to "&1" is not allowed. 
  28740.  
  28741. The name has a special meaning in a C++ program and cannot be referenced in 
  28742. this way. 
  28743.  
  28744. Recovery: Remove the reference. 
  28745.  
  28746.  
  28747. ΓòÉΓòÉΓòÉ 19.549. EDC3145 ΓòÉΓòÉΓòÉ
  28748.  
  28749. An octal constant is too large for character representation.  Only the 
  28750. rightmost eight bits are used for the character. 
  28751.  
  28752. Recovery: Make the octal constant smaller. 
  28753.  
  28754.  
  28755. ΓòÉΓòÉΓòÉ 19.550. EDC3146 ΓòÉΓòÉΓòÉ
  28756.  
  28757. A hexadecimal constant is larger than two digits.  Only the rightmost two 
  28758. digits are used for the character. 
  28759.  
  28760. Recovery: Make the hexadecimal constant smaller. 
  28761.  
  28762.  
  28763. ΓòÉΓòÉΓòÉ 19.551. EDC3147 ΓòÉΓòÉΓòÉ
  28764.  
  28765. A character constant is larger than the size of an "int".  Only the rightmost 
  28766. &1 characters are used. 
  28767.  
  28768. Recovery: Make the character constant smaller. 
  28769.  
  28770.  
  28771. ΓòÉΓòÉΓòÉ 19.552. EDC3148 ΓòÉΓòÉΓòÉ
  28772.  
  28773. Linkage specification must be at file scope. 
  28774.  
  28775. A linkage specification may only be defined at file scope, that is, outside all 
  28776. functions and classes. 
  28777.  
  28778. Recovery: Move the linkage specification or remove it. 
  28779.  
  28780.  
  28781. ΓòÉΓòÉΓòÉ 19.553. EDC3149 ΓòÉΓòÉΓòÉ
  28782.  
  28783. Default initializers cannot be followed by uninitialized arguments. 
  28784.  
  28785. If default initializers are specified in an argument list, there must be 
  28786. default initializers for all later arguments. 
  28787.  
  28788. Recovery: Remove the default initializers, or provide them for all later 
  28789. arguments, or move the arguments to the end of the list. 
  28790.  
  28791.  
  28792. ΓòÉΓòÉΓòÉ 19.554. EDC3150 ΓòÉΓòÉΓòÉ
  28793.  
  28794. The address of "&1" cannot be taken. 
  28795.  
  28796. The address of a constructor or destructor cannot be taken. 
  28797.  
  28798. Recovery: Remove the address operator (&) from the expression or remove the 
  28799. expression. 
  28800.  
  28801.  
  28802. ΓòÉΓòÉΓòÉ 19.555. EDC3151 ΓòÉΓòÉΓòÉ
  28803.  
  28804. &1 compiler temporary of type "&2" has been generated. 
  28805.  
  28806. The compiler has generated a temporary variable whose lifetime may be limited. 
  28807.  
  28808. Recovery: Ensure that the code does not depend on the value of a temporary 
  28809. which will be automatically destroyed when it goes out of scope. 
  28810.  
  28811.  
  28812. ΓòÉΓòÉΓòÉ 19.556. EDC3152 ΓòÉΓòÉΓòÉ
  28813.  
  28814. An error was detectect while writing to file "&1". 
  28815.  
  28816. Recovery: Ensure the file name is correct and that the disk is ready to be 
  28817. written to. 
  28818.  
  28819.  
  28820. ΓòÉΓòÉΓòÉ 19.557. EDC3153 ΓòÉΓòÉΓòÉ
  28821.  
  28822. Duplicate qualifier "&1" ignored. 
  28823.  
  28824. The keyword has been specified more than once.  Extra occurrences are ignored. 
  28825.  
  28826. Recovery: Remove one of the duplicate qualifiers. 
  28827.  
  28828.  
  28829. ΓòÉΓòÉΓòÉ 19.558. EDC3154 ΓòÉΓòÉΓòÉ
  28830.  
  28831. "&1" operator cannot be overloaded. 
  28832.  
  28833. The specified operator cannot be overloaded using an operator function.  The 
  28834. following operators cannot be overloaded: 
  28835.  
  28836. Recovery: Remove the overloading declaration or definition. 
  28837.  
  28838.  
  28839. ΓòÉΓòÉΓòÉ 19.559. EDC3155 ΓòÉΓòÉΓòÉ
  28840.  
  28841. At least one argument of "&1" must be of class type. 
  28842.  
  28843. The operator function must be a member of a class, so it must have at least one 
  28844. argument which is of class type. 
  28845.  
  28846. Recovery: Add an argument of class type. 
  28847.  
  28848.  
  28849. ΓòÉΓòÉΓòÉ 19.560. EDC3156 ΓòÉΓòÉΓòÉ
  28850.  
  28851. Call matches builtin operator. 
  28852.  
  28853. Recovery: Ensure this is the desired match. 
  28854.  
  28855.  
  28856. ΓòÉΓòÉΓòÉ 19.561. EDC3157 ΓòÉΓòÉΓòÉ
  28857.  
  28858. The divisor for the modulus or division operator cannot be zero. 
  28859.  
  28860. Recovery: Change the expression used in the divisor. 
  28861.  
  28862.  
  28863. ΓòÉΓòÉΓòÉ 19.562. EDC3158 ΓòÉΓòÉΓòÉ
  28864.  
  28865. The address of the bit-field "&1" cannot be taken. 
  28866.  
  28867. An attempt is being made to take the address of a bit-field or to use the 
  28868. bit-field to initialize a reference variable or argument. 
  28869.  
  28870. Recovery: Remove the expression that either takes the address of the bit-field 
  28871. or uses the bit-field to initialize a reference variable or argument. 
  28872.  
  28873.  
  28874. ΓòÉΓòÉΓòÉ 19.563. EDC3159 ΓòÉΓòÉΓòÉ
  28875.  
  28876. "&1" must not have default initializers. 
  28877.  
  28878. Default initializers are not allowed within the declaration of an operator 
  28879. function or a template function. 
  28880.  
  28881. Recovery: Remove the default initializers. 
  28882.  
  28883.  
  28884. ΓòÉΓòÉΓòÉ 19.564. EDC3160 ΓòÉΓòÉΓòÉ
  28885.  
  28886. The &1 "&2" needs a constructor initializer. 
  28887.  
  28888. Base classes, and class members with constructors and no default constructor, 
  28889. need to have an initializer specified in the constructor initializer list. 
  28890.  
  28891. Recovery: Specify a constructor initializer. 
  28892.  
  28893.  
  28894. ΓòÉΓòÉΓòÉ 19.565. EDC3161 ΓòÉΓòÉΓòÉ
  28895.  
  28896. Line is too long for proper generation of test coverage information. 
  28897.  
  28898. No statement may start to the right of the 2**16 column (65536) when test 
  28899. coverage information is to be generated. 
  28900.  
  28901. Recovery: Shorten the line. 
  28902.  
  28903.  
  28904. ΓòÉΓòÉΓòÉ 19.566. EDC3162 ΓòÉΓòÉΓòÉ
  28905.  
  28906. There are too many statements for proper generation of test coverage 
  28907. information. 
  28908.  
  28909. There can be no more than 2**16 (65536) statements (not source lines) in a 
  28910. module when test coverage information is to be generated. 
  28911.  
  28912. Recovery: Reduce the number of statements. 
  28913.  
  28914.  
  28915. ΓòÉΓòÉΓòÉ 19.567. EDC3163 ΓòÉΓòÉΓòÉ
  28916.  
  28917. Template class "&1" has the wrong number of arguments. 
  28918.  
  28919. A template class instantiation has a different number of template arguments 
  28920. than the template declaration. 
  28921.  
  28922. Recovery: Ensure that the template class has the same number of declarations as 
  28923. the template declaration. 
  28924.  
  28925.  
  28926. ΓòÉΓòÉΓòÉ 19.568. EDC3164 ΓòÉΓòÉΓòÉ
  28927.  
  28928. Non-&1 member function "&2" cannot be called for a &1 object. 
  28929.  
  28930. The member function is being called for a const or volatile object but it has 
  28931. not been declared with the corresponding const or volatile attribute. 
  28932.  
  28933. Recovery: Ensure that either both the function call and function declarations 
  28934. have the "const" or "volatile" keyword, or neither have. 
  28935.  
  28936.  
  28937. ΓòÉΓòÉΓòÉ 19.569. EDC3165 ΓòÉΓòÉΓòÉ
  28938.  
  28939. Null statement. 
  28940.  
  28941. Possible extraneous semi-colon. 
  28942.  
  28943. Recovery: Check for extra semi-colons in statement. 
  28944.  
  28945.  
  28946. ΓòÉΓòÉΓòÉ 19.570. EDC3166 ΓòÉΓòÉΓòÉ
  28947.  
  28948. Bit-field "&1" cannot be used in a conditional expression that is to be 
  28949. modified. 
  28950.  
  28951. The bit-field is part of a conditional expression that is to be modified. Only 
  28952. objects that can have their address taken are allowed as part of such an 
  28953. expression. 
  28954.  
  28955. Recovery: Remove the bit-field from the conditional expression. 
  28956.  
  28957.  
  28958. ΓòÉΓòÉΓòÉ 19.571. EDC3167 ΓòÉΓòÉΓòÉ
  28959.  
  28960. The "&1" qualifier cannot be applied to "&2". 
  28961.  
  28962. The qualifier is being applied to a name or a type for which it is not valid. 
  28963.  
  28964. Recovery: Remove the qualifier. 
  28965.  
  28966.  
  28967. ΓòÉΓòÉΓòÉ 19.572. EDC3168 ΓòÉΓòÉΓòÉ
  28968.  
  28969. Local type "&1" cannot be used as a &2 argument. 
  28970.  
  28971. The type is declared within the scope of a function, and is being used as a 
  28972. function argument or as a type in the instantiation of a template. 
  28973.  
  28974. Recovery: Remove the local type from the instantiation. 
  28975.  
  28976.  
  28977. ΓòÉΓòÉΓòÉ 19.573. EDC3169 ΓòÉΓòÉΓòÉ
  28978.  
  28979. Exception specification for function "&1" does not match previous declaration. 
  28980.  
  28981. If an exception specification is given in more than one declaration of a 
  28982. function, it must be the same in all such declarations. 
  28983.  
  28984. Recovery: Ensure that all exception specifications match. 
  28985.  
  28986.  
  28987. ΓòÉΓòÉΓòÉ 19.574. EDC3170 ΓòÉΓòÉΓòÉ
  28988.  
  28989. Default initializers for non-type template arguments are only allowed for class 
  28990. templates. 
  28991.  
  28992. Default initializers have been given for non-type template arguments but the 
  28993. template is not declaring a class. 
  28994.  
  28995. Recovery: Remove the default initializers. 
  28996.  
  28997.  
  28998. ΓòÉΓòÉΓòÉ 19.575. EDC3171 ΓòÉΓòÉΓòÉ
  28999.  
  29000. A function argument must not have type "void". 
  29001.  
  29002. A function argument may be an expression of any object type. "void" is an 
  29003. incomplete type that cannot be completed. Object types and incomplete types are 
  29004. disjoint sets. 
  29005.  
  29006. Recovery: Change the return type of the function argument. 
  29007.  
  29008.  
  29009. ΓòÉΓòÉΓòÉ 19.576. EDC3172 ΓòÉΓòÉΓòÉ
  29010.  
  29011. Insufficient memory in line &1 of file "&2". 
  29012.  
  29013. The compiler ran out of memory during compilation. 
  29014.  
  29015. Recovery: End unnecessary processes and recompile. 
  29016.  
  29017.  
  29018. ΓòÉΓòÉΓòÉ 19.577. EDC3173 ΓòÉΓòÉΓòÉ
  29019.  
  29020. SIGDANGER received:  page space low, compilation stopping. 
  29021.  
  29022. The operating system is about to run out of memory.  The compiler will exit to 
  29023. return memory to the system. 
  29024.  
  29025. Recovery: End unnecessary processes and recompile. 
  29026.  
  29027.  
  29028. ΓòÉΓòÉΓòÉ 19.578. EDC3174 ΓòÉΓòÉΓòÉ
  29029.  
  29030. An object of abstract class "&1" cannot be created. 
  29031.  
  29032. Objects of an abstract class cannot be created except as objects representing a 
  29033. base class of a class derived from it. A class is abstract if it has at least 
  29034. one pure virtual function. 
  29035.  
  29036. Recovery: Derive another object from the abstract class. 
  29037.  
  29038.  
  29039. ΓòÉΓòÉΓòÉ 19.579. EDC3175 ΓòÉΓòÉΓòÉ
  29040.  
  29041. Invalid use of an abstract class. 
  29042.  
  29043. An abstract class must not be used as an argument type, as a function return 
  29044. type, or as the type of an explicit conversion. 
  29045.  
  29046. Recovery: Derive another class from the abstract, instantiate it so it becomes 
  29047. a concrete object, and then use it instead. 
  29048.  
  29049.  
  29050. ΓòÉΓòÉΓòÉ 19.580. EDC3176 ΓòÉΓòÉΓòÉ
  29051.  
  29052. "&1" has been used more than once in the same base class list. 
  29053.  
  29054. A base class may only be specified once in the base class list for a derived 
  29055. class. 
  29056.  
  29057. Recovery: Remove one of the specifications. 
  29058.  
  29059.  
  29060. ΓòÉΓòÉΓòÉ 19.581. EDC3177 ΓòÉΓòÉΓòÉ
  29061.  
  29062. Template argument &1 of type "&2" does not match declared type "&3". 
  29063.  
  29064. A non-type template argument must have a type that exactly matches the type of 
  29065. the corresponding argument in the template declaration. 
  29066.  
  29067. Recovery: Ensure that the types match. 
  29068.  
  29069.  
  29070. ΓòÉΓòÉΓòÉ 19.582. EDC3178 ΓòÉΓòÉΓòÉ
  29071.  
  29072. Template argument &1 of type "&2" is not an allowable constant value or 
  29073. address. 
  29074.  
  29075. A non-type template argument must be a constant value or the address of a 
  29076. global object, function or static data member. 
  29077.  
  29078. Recovery: Change the template argument. 
  29079.  
  29080.  
  29081. ΓòÉΓòÉΓòÉ 19.583. EDC3179 ΓòÉΓòÉΓòÉ
  29082.  
  29083. Template argument list is empty. 
  29084.  
  29085. At least one template argument must be specified in a template declaration. 
  29086.  
  29087. Recovery: Specify a template argument in the declaration. 
  29088.  
  29089.  
  29090. ΓòÉΓòÉΓòÉ 19.584. EDC3180 ΓòÉΓòÉΓòÉ
  29091.  
  29092. Template argument &1 is of type "&2" which is not an integral or pointer type. 
  29093.  
  29094. A non-type template argument must be of integral or pointer type, so that it 
  29095. can be matched with a constant integral value. 
  29096.  
  29097. Recovery: Change the template argument. 
  29098.  
  29099.  
  29100. ΓòÉΓòÉΓòÉ 19.585. EDC3181 ΓòÉΓòÉΓòÉ
  29101.  
  29102. "&1" is defined in a template declaration but it is not a static member. 
  29103.  
  29104. A member of a template class defined in a template declaration must be a static 
  29105. member. 
  29106.  
  29107. Recovery: Make the member static or remove it from the template declaration. 
  29108.  
  29109.  
  29110. ΓòÉΓòÉΓòÉ 19.586. EDC3182 ΓòÉΓòÉΓòÉ
  29111.  
  29112. Template argument "&1" is not used in the declaration of "&2". 
  29113.  
  29114. All template arguments for a non-class template must be used in the declaration 
  29115. of the name or the function argument list. 
  29116.  
  29117. Recovery: Ensure all template arguments are used in the declaration of the name 
  29118. or the function argument list. 
  29119.  
  29120.  
  29121. ΓòÉΓòÉΓòÉ 19.587. EDC3183 ΓòÉΓòÉΓòÉ
  29122.  
  29123. Template declaration does not declare a class, a function, or a template class 
  29124. member. 
  29125.  
  29126. A template declaration must declare a class, a function, or a static data 
  29127. member of a template class, following the template arguments. 
  29128.  
  29129. Recovery: Change the template declaration to declare a class, a function, or a 
  29130. template class member. 
  29131.  
  29132.  
  29133. ΓòÉΓòÉΓòÉ 19.588. EDC3184 ΓòÉΓòÉΓòÉ
  29134.  
  29135. Return type "&1" for function "&2" differs from previous return type of "&3". 
  29136.  
  29137. The declaration of the function differs from a previous declaration in only the 
  29138. return type. 
  29139.  
  29140. Recovery: Change the return type so that it matches the previous return type. 
  29141.  
  29142.  
  29143. ΓòÉΓòÉΓòÉ 19.589. EDC3185 ΓòÉΓòÉΓòÉ
  29144.  
  29145. "&1" is a member of "&2" and cannot be used without qualification. 
  29146.  
  29147. The specified name is a class member, but no class qualification has been used 
  29148. to reference it. 
  29149.  
  29150. Recovery: Add a class qualification to the class member. 
  29151.  
  29152.  
  29153. ΓòÉΓòÉΓòÉ 19.590. EDC3186 ΓòÉΓòÉΓòÉ
  29154.  
  29155. The expression is not a valid preprocessor constant expression. 
  29156.  
  29157. The expression in an "#if" or "#elif" preprocessor directive is either not a 
  29158. valid expression or not a constant expression. No keywords are recognized in 
  29159. such an expression and non-macro identifiers are replaced by the constant 0. 
  29160.  
  29161. Recovery: Change the expression for the preprocessor directive. 
  29162.  
  29163.  
  29164. ΓòÉΓòÉΓòÉ 19.591. EDC3187 ΓòÉΓòÉΓòÉ
  29165.  
  29166. "&1" cannot be initialized multiple times. 
  29167.  
  29168. An initializer was already specified in the constructor definition. 
  29169.  
  29170. Recovery: Remove the additional initializer. 
  29171.  
  29172.  
  29173. ΓòÉΓòÉΓòÉ 19.592. EDC3188 ΓòÉΓòÉΓòÉ
  29174.  
  29175. A macro parameter is expected after the "#" operator. 
  29176.  
  29177. The "#" operator in a macro replacement list must be followed by a macro 
  29178. parameter. 
  29179.  
  29180. Recovery: Add a macro parameter after the "#" operator. 
  29181.  
  29182.  
  29183. ΓòÉΓòÉΓòÉ 19.593. EDC3189 ΓòÉΓòÉΓòÉ
  29184.  
  29185. "##" operator is at the start or end of the replacement list. 
  29186.  
  29187. The "##" operator must be preceded and followed by valid tokens in the macro 
  29188. replacement list. 
  29189.  
  29190. Recovery: Move the "##" operator in the replacement list. 
  29191.  
  29192.  
  29193. ΓòÉΓòÉΓòÉ 19.594. EDC3190 ΓòÉΓòÉΓòÉ
  29194.  
  29195. One or more "#endif" statements are missing at end of file. 
  29196.  
  29197. The end of file has been reached and there are still "#if", "#ifdef" or 
  29198. "#ifndef" statements without a matching "#endif" statement. 
  29199.  
  29200. Recovery: Ensure that all "#if", "#ifdef", and "#ifndef" statements have 
  29201. matching "#endif" statements. 
  29202.  
  29203.  
  29204. ΓòÉΓòÉΓòÉ 19.595. EDC3191 ΓòÉΓòÉΓòÉ
  29205.  
  29206. No suitable copy assignment operator exists to perform the assignment. 
  29207.  
  29208. A copy assignment operator exists but it does not accept the type of the given 
  29209. parameter. 
  29210.  
  29211. Recovery: Change the copy assignment operator. 
  29212.  
  29213.  
  29214. ΓòÉΓòÉΓòÉ 19.596. EDC3192 ΓòÉΓòÉΓòÉ
  29215.  
  29216. Identifier "&1" in preprocessor expression is assigned 0. 
  29217.  
  29218. Identifiers are not recognized in a preprocessor expression.  The specified 
  29219. identifier has been treated as a non-macro identifier and assigned the constant 
  29220. 0. 
  29221.  
  29222.  
  29223. ΓòÉΓòÉΓòÉ 19.597. EDC3193 ΓòÉΓòÉΓòÉ
  29224.  
  29225. Explicit call to constructor "&1" is not allowed. 
  29226.  
  29227. A constructor cannot be called explicitly.  It is called implicitly when an 
  29228. object of the class is created. 
  29229.  
  29230. Recovery: Remove the call to the constructor. 
  29231.  
  29232.  
  29233. ΓòÉΓòÉΓòÉ 19.598. EDC3194 ΓòÉΓòÉΓòÉ
  29234.  
  29235. "catch(&1)" will never be reached because of previous "catch(&2)". 
  29236.  
  29237. The catch clause can never be reached since any exception type that matches it 
  29238. will also be matched by the specified previous catch clause. 
  29239.  
  29240. Recovery: Change or remove one of the catch clauses. 
  29241.  
  29242.  
  29243. ΓòÉΓòÉΓòÉ 19.599. EDC3195 ΓòÉΓòÉΓòÉ
  29244.  
  29245. No default constructor exists for "&1". 
  29246.  
  29247. An array of class objects must be initialized by calling the default 
  29248. constructor but one has not been declared. 
  29249.  
  29250. Recovery: Declare a default constructor for the array. 
  29251.  
  29252.  
  29253. ΓòÉΓòÉΓòÉ 19.600. EDC3196 ΓòÉΓòÉΓòÉ
  29254.  
  29255. More than one default constructor exists for "&1". 
  29256.  
  29257. An array of class objects must be initialized by calling the default 
  29258. constructor but the call is ambiguous. 
  29259.  
  29260. Recovery: Ensure that only one default constructor exists. 
  29261.  
  29262.  
  29263. ΓòÉΓòÉΓòÉ 19.601. EDC3197 ΓòÉΓòÉΓòÉ
  29264.  
  29265. It is invalid to have a throw expression with type "&1". 
  29266.  
  29267. Recovery: Change the type or remove the throw expression. 
  29268.  
  29269.  
  29270. ΓòÉΓòÉΓòÉ 19.602. EDC3198 ΓòÉΓòÉΓòÉ
  29271.  
  29272. The exception specification is ignored in this declaration. 
  29273.  
  29274. The declaration contains a function declarator with an exception specification 
  29275. but is not the declaration of a function.  The exception specification is 
  29276. ignored. 
  29277.  
  29278. Recovery: Change the function declarator so that it is the declaration of a 
  29279. function. 
  29280.  
  29281.  
  29282. ΓòÉΓòÉΓòÉ 19.603. EDC3199 ΓòÉΓòÉΓòÉ
  29283.  
  29284. The compiler cannot generate a default copy constructor for "&1". 
  29285.  
  29286. The default copy constructor cannot be generated for this class because there 
  29287. exists a member or base class that has a private copy constructor, or there are 
  29288. ambiguous base classes, or this class has no name. 
  29289.  
  29290. Recovery: Ensure that a member or base class does not have a private copy 
  29291. constructor.  If not then ensure the class is named and there are no ambiguous 
  29292. references to base classes. 
  29293.  
  29294.  
  29295. ΓòÉΓòÉΓòÉ 19.604. EDC3200 ΓòÉΓòÉΓòÉ
  29296.  
  29297. The compiler cannot generate a default copy assignment operator for "&1". 
  29298.  
  29299. The default copy assignment operator cannot be generated for this class because 
  29300. it has a const member or a reference member or a member (or base class) with a 
  29301. private copy assignment operator. 
  29302.  
  29303. Recovery: Ensure there are no const members, reference members or members with 
  29304. a private copy assignment operator. 
  29305.  
  29306.  
  29307. ΓòÉΓòÉΓòÉ 19.605. EDC3201 ΓòÉΓòÉΓòÉ
  29308.  
  29309. &1 too few non-option arguments. 
  29310.  
  29311. Recovery: Add non-option arguments. 
  29312.  
  29313.  
  29314. ΓòÉΓòÉΓòÉ 19.606. EDC3202 ΓòÉΓòÉΓòÉ
  29315.  
  29316. "main" must not be declared inline or static. 
  29317.  
  29318. Although "main" is not a keyword, it is a special function that cannot be 
  29319. inlined or declared static. 
  29320.  
  29321. Recovery: Remove the inline or static specifier from the declaration of main. 
  29322.  
  29323.  
  29324. ΓòÉΓòÉΓòÉ 19.607. EDC3203 ΓòÉΓòÉΓòÉ
  29325.  
  29326. Pure virtual function called. 
  29327.  
  29328. A call has been made to a pure virtual function from a constructor or 
  29329. destructor.  In such functions, the pure virtual function would not have been 
  29330. overridden by a derived class and a run-time error would occur. 
  29331.  
  29332. Recovery: Remove the call to the pure virtual function. 
  29333.  
  29334.  
  29335. ΓòÉΓòÉΓòÉ 19.608. EDC3204 ΓòÉΓòÉΓòÉ
  29336.  
  29337. "&1" is not allowed as a conversion function type. 
  29338.  
  29339. A conversion function cannot be declared with a function or an array as its 
  29340. conversion type, since the type cannot be returned from the function. 
  29341.  
  29342. Recovery: Declare the function as converting to a pointer to the function or 
  29343. the array element type. 
  29344.  
  29345.  
  29346. ΓòÉΓòÉΓòÉ 19.609. EDC3205 ΓòÉΓòÉΓòÉ
  29347.  
  29348. Syntax error - "&1" is followed by "&3" but is not the name of a &2. 
  29349.  
  29350. The name is not a class or template name but the context implies that it should 
  29351. be. 
  29352.  
  29353. Recovery: Change the name to a class or template name. 
  29354.  
  29355.  
  29356. ΓòÉΓòÉΓòÉ 19.610. EDC3206 ΓòÉΓòÉΓòÉ
  29357.  
  29358. The previous &1 messages apply to the definition of template "&2". 
  29359.  
  29360. The instantiation of the specified template caused the messages, even though 
  29361. the line numbers in the messages refer to the original template declaration. 
  29362.  
  29363. Recovery: Ensure this is the desired response. 
  29364.  
  29365.  
  29366. ΓòÉΓòÉΓòÉ 19.611. EDC3207 ΓòÉΓòÉΓòÉ
  29367.  
  29368. The previous message applies to the definition of template "&1". 
  29369.  
  29370. The instantiation of the specified template caused the message, even though the 
  29371. line number in the message refers to the original template declaration. 
  29372.  
  29373. Recovery: Ensure this is the desired response. 
  29374.  
  29375.  
  29376. ΓòÉΓòÉΓòÉ 19.612. EDC3208 ΓòÉΓòÉΓòÉ
  29377.  
  29378. No suitable constructor exists for conversion from "&1" to "&2". 
  29379.  
  29380. A constructor is required for the class but no user-defined constructor exists 
  29381. and the compiler could not generate one. 
  29382.  
  29383. Recovery: Create a suitable constructor for conversion. 
  29384.  
  29385.  
  29386. ΓòÉΓòÉΓòÉ 19.613. EDC3209 ΓòÉΓòÉΓòÉ
  29387.  
  29388. class "&1" does not have a copy assignment operator. 
  29389.  
  29390. A copy assignment operator is required for the class but no user-defined copy 
  29391. assignment operator exists and the compiler could not generate one. 
  29392.  
  29393. Recovery: Create a copy assignment operator. 
  29394.  
  29395.  
  29396. ΓòÉΓòÉΓòÉ 19.614. EDC3210 ΓòÉΓòÉΓòÉ
  29397.  
  29398. "&1" cannot be used as a template name since it is already known in this scope. 
  29399.  
  29400. A template name must not match the name of an existing template, class, 
  29401. function, object, value or type. 
  29402.  
  29403. Recovery: Change one of the template names. 
  29404.  
  29405.  
  29406. ΓòÉΓòÉΓòÉ 19.615. EDC3211 ΓòÉΓòÉΓòÉ
  29407.  
  29408. "&1" is expected for template argument &2. 
  29409.  
  29410. Either the argument is a type and the template has a non-type argument or the 
  29411. argument is an expression and the template has a type argument. 
  29412.  
  29413. Recovery: Ensure the argument matches the template. 
  29414.  
  29415.  
  29416. ΓòÉΓòÉΓòÉ 19.616. EDC3212 ΓòÉΓòÉΓòÉ
  29417.  
  29418. "&1" cannot be defined before the template definition of which it is an 
  29419. instance. 
  29420.  
  29421. An explicit definition of a template class cannot be given before the 
  29422. corresponding template definition. 
  29423.  
  29424. Recovery: Move the template definition so that it occurs before any template 
  29425. class definitions. 
  29426.  
  29427.  
  29428. ΓòÉΓòÉΓòÉ 19.617. EDC3213 ΓòÉΓòÉΓòÉ
  29429.  
  29430. An ellipsis (...) cannot be used in the argument list of a template function. 
  29431.  
  29432. Since an exact match is needed for template functions, an ellipsis cannot be 
  29433. used in the function argument list. 
  29434.  
  29435. Recovery: Remove the ellipsis from the argument list. 
  29436.  
  29437.  
  29438. ΓòÉΓòÉΓòÉ 19.618. EDC3214 ΓòÉΓòÉΓòÉ
  29439.  
  29440. The suffix for the floating point constant is not valid. 
  29441.  
  29442. Recovery: Change the suffix for the floating point constant. 
  29443.  
  29444.  
  29445. ΓòÉΓòÉΓòÉ 19.619. EDC3215 ΓòÉΓòÉΓòÉ
  29446.  
  29447. Statement has no effect. 
  29448.  
  29449. The expression has no side effects and produces a result that is not used. 
  29450.  
  29451. Recovery: Remove the statement or use its result. 
  29452.  
  29453.  
  29454. ΓòÉΓòÉΓòÉ 19.620. EDC3216 ΓòÉΓòÉΓòÉ
  29455.  
  29456. "/*" detected in comment. 
  29457.  
  29458. "/*" has been detected within a "/*" type comment. Nested comments are not 
  29459. allowed. 
  29460.  
  29461. Recovery: Remove the imbedded "/*". 
  29462.  
  29463.  
  29464. ΓòÉΓòÉΓòÉ 19.621. EDC3217 ΓòÉΓòÉΓòÉ
  29465.  
  29466. Predefined macro name "&1" cannot be redefined or undefined. 
  29467.  
  29468. The specified macro name is predefined by the compiler and cannot be redefined 
  29469. with #define or undefined with #undef. 
  29470.  
  29471. Recovery: Remove the definition expression. 
  29472.  
  29473.  
  29474. ΓòÉΓòÉΓòÉ 19.622. EDC3218 ΓòÉΓòÉΓòÉ
  29475.  
  29476. The suffix for the integer constant is not valid. 
  29477.  
  29478. The integer constant is a suffix letter that is not recognized as a valid 
  29479. suffix. 
  29480.  
  29481. Recovery: Change the suffix to either "u" or "l". 
  29482.  
  29483.  
  29484. ΓòÉΓòÉΓòÉ 19.623. EDC3219 ΓòÉΓòÉΓòÉ
  29485.  
  29486. The expression contains a division by zero. 
  29487.  
  29488. Recovery: Remove the division by zero from the expression. 
  29489.  
  29490.  
  29491. ΓòÉΓòÉΓòÉ 19.624. EDC3220 ΓòÉΓòÉΓòÉ
  29492.  
  29493. The expression contains a modulus by zero. 
  29494.  
  29495. Recovery: Remove the modulus by zero from the expression. 
  29496.  
  29497.  
  29498. ΓòÉΓòÉΓòÉ 19.625. EDC3221 ΓòÉΓòÉΓòÉ
  29499.  
  29500. Static member "&1" can only be defined at file scope. 
  29501.  
  29502. Recovery: Move the static member so that it is defined at file scope. 
  29503.  
  29504.  
  29505. ΓòÉΓòÉΓòÉ 19.626. EDC3222 ΓòÉΓòÉΓòÉ
  29506.  
  29507. "&1" needs a constructor because &2 "&3" needs a constructor initializer. 
  29508.  
  29509. Recovery: Add a constructor. 
  29510.  
  29511.  
  29512. ΓòÉΓòÉΓòÉ 19.627. EDC3223 ΓòÉΓòÉΓòÉ
  29513.  
  29514. "&1" cannot be redeclared since it has already been used in this scope. 
  29515.  
  29516. The name is being declared in a member list but was previously declared outside 
  29517. the member list and then used in the member list. 
  29518.  
  29519. Recovery: Change or remove one of the occurrences. 
  29520.  
  29521.  
  29522. ΓòÉΓòÉΓòÉ 19.628. EDC3224 ΓòÉΓòÉΓòÉ
  29523.  
  29524. Conversion from "&1" to a reference to a non-const type "&2" requires a 
  29525. temporary. 
  29526.  
  29527. A temporary may only be used for conversion to a reference type when the 
  29528. reference is to a const type. 
  29529.  
  29530. Recovery: Change to a const type. 
  29531.  
  29532.  
  29533. ΓòÉΓòÉΓòÉ 19.629. EDC3225 ΓòÉΓòÉΓòÉ
  29534.  
  29535. "&2" is too small to hold a value of type "&1". 
  29536.  
  29537. A conversion from a pointer type to an integral type is only valid if the 
  29538. integral type is large enough to hold the pointer value. 
  29539.  
  29540. Recovery: Remove the conversion from a pointer type to an integral type. 
  29541.  
  29542.  
  29543. ΓòÉΓòÉΓòÉ 19.630. EDC3226 ΓòÉΓòÉΓòÉ
  29544.  
  29545. Object of type "&1" cannot be constructed from "&2" expression. 
  29546.  
  29547. There is no constructor taking a single argument that can be called using the 
  29548. given expression. 
  29549.  
  29550. Recovery: Change the expression. 
  29551.  
  29552.  
  29553. ΓòÉΓòÉΓòÉ 19.631. EDC3227 ΓòÉΓòÉΓòÉ
  29554.  
  29555. The compiler cannot generate a copy constructor for conversion to "&1". 
  29556.  
  29557. A copy constructor is required for the conversion.  No suitable user-defined 
  29558. copy constructor exists and the compiler could not generate one. 
  29559.  
  29560. Recovery: Create a copy constructor for the conversion. 
  29561.  
  29562.  
  29563. ΓòÉΓòÉΓòÉ 19.632. EDC3228 ΓòÉΓòÉΓòÉ
  29564.  
  29565. No suitable constructor or conversion function exists for conversion from "&1" 
  29566. to "&2". 
  29567.  
  29568. A constructor or conversion function is required for the conversion but no such 
  29569. constructor or function exists. 
  29570.  
  29571. Recovery: Create a constructor or conversion function for the conversion. 
  29572.  
  29573.  
  29574. ΓòÉΓòÉΓòÉ 19.633. EDC3229 ΓòÉΓòÉΓòÉ
  29575.  
  29576. The file is empty. 
  29577.  
  29578. Recovery: Check the file name. 
  29579.  
  29580.  
  29581. ΓòÉΓòÉΓòÉ 19.634. EDC3230 ΓòÉΓòÉΓòÉ
  29582.  
  29583. Syntax error - "&1" has been inserted before "&2". 
  29584.  
  29585. A syntax error was found while parsing the program.  The message identifies 
  29586. what the compiler expected and what it actually found. The compiler inserts the 
  29587. expected value and compilation continues. 
  29588.  
  29589. Recovery: Correct the syntax. 
  29590.  
  29591.  
  29592. ΓòÉΓòÉΓòÉ 19.635. EDC3231 ΓòÉΓòÉΓòÉ
  29593.  
  29594. Call to "&1" matches some functions best in some arguments, but no function is 
  29595. a best match for all arguments. 
  29596.  
  29597. No function matches each call argument as well as or better than all other 
  29598. functions. 
  29599.  
  29600. Recovery: Change the function call so that it matches only one function. 
  29601.  
  29602.  
  29603. ΓòÉΓòÉΓòÉ 19.636. EDC3232 ΓòÉΓòÉΓòÉ
  29604.  
  29605. Call matches "&1". 
  29606.  
  29607. The compiler detected an overloaded function or operator that is similar to 
  29608. another and is providing additional information. 
  29609.  
  29610. Recovery: Ensure this is the desired match. 
  29611.  
  29612.  
  29613. ΓòÉΓòÉΓòÉ 19.637. EDC3233 ΓòÉΓòÉΓòÉ
  29614.  
  29615. Cannot adjust access of "&1::&2" because a member in "&3" hides it. 
  29616.  
  29617. The specified member cannot have its access modified because a member of the 
  29618. same name in the specified class hides it. 
  29619.  
  29620. Recovery: Remove the access adjustment expression or unhide the member. 
  29621.  
  29622.  
  29623. ΓòÉΓòÉΓòÉ 19.638. EDC3234 ΓòÉΓòÉΓòÉ
  29624.  
  29625. "&1" cannot be redeclared. 
  29626.  
  29627. The specified name cannot be redeclared because it has already been used. 
  29628.  
  29629. Recovery: Change or remove one of the declarations. 
  29630.  
  29631.  
  29632. ΓòÉΓòÉΓòÉ 19.639. EDC3235 ΓòÉΓòÉΓòÉ
  29633.  
  29634. Syntax error - "&1" is not allowed; "&2" has already been specified. 
  29635.  
  29636. The specified attributes are both part of a declaration and are not allowed to 
  29637. be specified in the same declaration. 
  29638.  
  29639. Recovery: Remove the attributes. 
  29640.  
  29641.  
  29642. ΓòÉΓòÉΓòÉ 19.640. EDC3236 ΓòÉΓòÉΓòÉ
  29643.  
  29644. Missing option to "#pragma &1";  the directive is ignored. 
  29645.  
  29646. Recovery: Ensure all options for the "#pragma" are present. 
  29647.  
  29648.  
  29649. ΓòÉΓòÉΓòÉ 19.641. EDC3237 ΓòÉΓòÉΓòÉ
  29650.  
  29651. Invalid option "&1" specified for "#pragma options";  the option is ignored. 
  29652.  
  29653. Recovery: Remove the invalid option. 
  29654.  
  29655.  
  29656. ΓòÉΓòÉΓòÉ 19.642. EDC3238 ΓòÉΓòÉΓòÉ
  29657.  
  29658. Invalid or out of range pragma parameter;  parameter is ignored. 
  29659.  
  29660. Recovery: Remove the parameter or replace it with one within the range. 
  29661.  
  29662.  
  29663. ΓòÉΓòÉΓòÉ 19.643. EDC3239 ΓòÉΓòÉΓòÉ
  29664.  
  29665. Function "&1" has internal linkage but is undefined. 
  29666.  
  29667. If a static function or inline member function is referenced in this 
  29668. compilation unit it must be defined in the same compilation unit. 
  29669.  
  29670. Recovery: Define the function in the same compilation unit it is referenced in. 
  29671.  
  29672.  
  29673. ΓòÉΓòÉΓòÉ 19.644. EDC3240 ΓòÉΓòÉΓòÉ
  29674.  
  29675. Call to "&1" matches more than one template function. 
  29676.  
  29677. More than one template for the function matches equally well with the argument 
  29678. list specified on the call. 
  29679.  
  29680. Recovery: Change the call so that it only matches one template function. 
  29681.  
  29682.  
  29683. ΓòÉΓòÉΓòÉ 19.645. EDC3241 ΓòÉΓòÉΓòÉ
  29684.  
  29685. "&1" was declared with external linkage and called before it is defined as 
  29686. inline. 
  29687.  
  29688. When no inline specifier is used, linkage will be external unless an inline 
  29689. definition appears before the first call. 
  29690.  
  29691. Recovery: Define the function before the first call to it. 
  29692.  
  29693.  
  29694. ΓòÉΓòÉΓòÉ 19.646. EDC3242 ΓòÉΓòÉΓòÉ
  29695.  
  29696. Non-&1 member function called for a &1 object via pointer of type "&2". 
  29697.  
  29698. The member function is being called for a const or volatile object but it has 
  29699. not been declared with the corresponding const or volatile attribute. 
  29700.  
  29701. Recovery: Ensure that the function call and the function declaration match. 
  29702.  
  29703.  
  29704. ΓòÉΓòÉΓòÉ 19.647. EDC3243 ΓòÉΓòÉΓòÉ
  29705.  
  29706. "&1" cannot be a base of "&2" because "&3" contains the type name "&2". 
  29707.  
  29708. A class cannot inherit a type name that is the same as the class name. 
  29709.  
  29710. Recovery: Change the name of either the derived class or the inherited class. 
  29711.  
  29712.  
  29713. ΓòÉΓòÉΓòÉ 19.648. EDC3244 ΓòÉΓòÉΓòÉ
  29714.  
  29715. "&1" cannot be a base of "&2" because "&3" contains the enumerator "&2". 
  29716.  
  29717. A class cannot inherit an enumerator with the same name as the class name. 
  29718.  
  29719. Recovery: Change the name of either the derived class or the inherited 
  29720. enumerator name. 
  29721.  
  29722.  
  29723. ΓòÉΓòÉΓòÉ 19.649. EDC3245 ΓòÉΓòÉΓòÉ
  29724.  
  29725. "&1" cannot be a base of "&2" because "&3" contains an anonymous union member 
  29726. "&2". 
  29727.  
  29728. A class cannot inherit an anonymous union member with the same name as the 
  29729. class name. 
  29730.  
  29731. Recovery: Change either the name of the derived class or the inherited 
  29732. anonymous union member. 
  29733.  
  29734.  
  29735. ΓòÉΓòÉΓòÉ 19.650. EDC3246 ΓòÉΓòÉΓòÉ
  29736.  
  29737. Symbol length of &1 exceeds limit of &2 bytes. 
  29738.  
  29739. Recovery: Shorten the symbol length. 
  29740.  
  29741.  
  29742. ΓòÉΓòÉΓòÉ 19.651. EDC3247 ΓòÉΓòÉΓòÉ
  29743.  
  29744. The result of this pointer to member operator can be used only as the operand 
  29745. of the function call operator (). 
  29746.  
  29747. If the result of the .* or ->* is a function, then that result can be used only 
  29748. as the operand for the function call operator (). 
  29749.  
  29750. Recovery: Make the result of the pointer to member operator the operand of the 
  29751. function call operator (). 
  29752.  
  29753.  
  29754. ΓòÉΓòÉΓòÉ 19.652. EDC3248 ΓòÉΓòÉΓòÉ
  29755.  
  29756. When "&1" is used as an operand to the arrow or dot operator the result must be 
  29757. used with the function call operator (). 
  29758.  
  29759. If the result of the dot or arrow operator is a function, then that result can 
  29760. be used only as the operand for the function call operator (). 
  29761.  
  29762. Recovery: Make the result the operand of the function call operator (). 
  29763.  
  29764.  
  29765. ΓòÉΓòÉΓòÉ 19.653. EDC3249 ΓòÉΓòÉΓòÉ
  29766.  
  29767. A class with a reference or const member needs a constructor. 
  29768.  
  29769. const and reference members must be initialized in a constructor initializer 
  29770. list. 
  29771.  
  29772. Recovery: Add a constructor to the class. 
  29773.  
  29774.  
  29775. ΓòÉΓòÉΓòÉ 19.654. EDC3250 ΓòÉΓòÉΓòÉ
  29776.  
  29777. Base class initializers cannot contain virtual function calls. 
  29778.  
  29779. The virtual function table pointers are not set up until after the base classes 
  29780. are initialized. 
  29781.  
  29782. Recovery: Remove the call to a virtual function in the base class initializer. 
  29783.  
  29784.  
  29785. ΓòÉΓòÉΓòÉ 19.655. EDC3251 ΓòÉΓòÉΓòÉ
  29786.  
  29787. The previous declaration of "&1" did not have a linkage specification. 
  29788.  
  29789. A function declaration without a linkage specification must not precede the 
  29790. first linkage specification for that function. 
  29791.  
  29792. Recovery: Add a linkage specification to the first declaration of the function 
  29793.  
  29794.  
  29795. ΓòÉΓòÉΓòÉ 19.656. EDC3252 ΓòÉΓòÉΓòÉ
  29796.  
  29797. The destructor for "&1" does not exist. The call is ignored. 
  29798.  
  29799. The destructor call is for a type that does not have a destructor. The call is 
  29800. ignored. 
  29801.  
  29802. Recovery: Add a destructor to the type. 
  29803.  
  29804.  
  29805. ΓòÉΓòÉΓòÉ 19.657. EDC3253 ΓòÉΓòÉΓòÉ
  29806.  
  29807. "&1" has been added to the scope of "&2". 
  29808.  
  29809. Because the friend class has not been declared yet, its name has been added to 
  29810. the scope of the class containing the friend declaration. 
  29811.  
  29812. Recovery: If this is not intended, move the declaration of the friend class so 
  29813. that it appears before it is declared as a friend. 
  29814.  
  29815.  
  29816. ΓòÉΓòÉΓòÉ 19.658. EDC3254 ΓòÉΓòÉΓòÉ
  29817.  
  29818. The body of friend member function "&1" cannot be defined in the member list of 
  29819. "&2". 
  29820.  
  29821. A friend function that is a member of another class cannot be defined inline in 
  29822. the member list. 
  29823.  
  29824. Recovery: Define the body of the friend function at file scope. 
  29825.  
  29826.  
  29827. ΓòÉΓòÉΓòÉ 19.659. EDC3255 ΓòÉΓòÉΓòÉ
  29828.  
  29829. The initializer list must be complete because "&1" does not have a default 
  29830. constructor. 
  29831.  
  29832. Recovery: Complete the initializer list or add a default constructor to the 
  29833. class. 
  29834.  
  29835.  
  29836. ΓòÉΓòÉΓòÉ 19.660. EDC3256 ΓòÉΓòÉΓòÉ
  29837.  
  29838. "&1" cannot be opened.  The nested include file limit of &2 has been exceeded. 
  29839.  
  29840. Recovery: Remove the nesting of one or more of the include files. 
  29841.  
  29842.  
  29843. ΓòÉΓòÉΓòÉ 19.661. EDC3257 ΓòÉΓòÉΓòÉ
  29844.  
  29845. An anonymous union at file scope must have a storage class of static. 
  29846.  
  29847. Recovery: Change the storage class of the anonymous union to static. 
  29848.  
  29849.  
  29850. ΓòÉΓòÉΓòÉ 19.662. EDC3258 ΓòÉΓòÉΓòÉ
  29851.  
  29852. A pure virtual destructor needs an out-of-line definition in order for the 
  29853. corresponding class to be a base of another class. 
  29854.  
  29855. Recovery: Move the definition of the pure virtual destructor so that it is out 
  29856. of line. 
  29857.  
  29858.  
  29859. ΓòÉΓòÉΓòÉ 19.663. EDC3259 ΓòÉΓòÉΓòÉ
  29860.  
  29861. The initializer is improperly braced. 
  29862.  
  29863. Recovery: Correct the braces on the initializer. 
  29864.  
  29865.  
  29866. ΓòÉΓòÉΓòÉ 19.664. EDC3260 ΓòÉΓòÉΓòÉ
  29867.  
  29868. Invalid octal integer constant. 
  29869.  
  29870. The octal integer constant contains an '8' or a '9'. 
  29871.  
  29872. Recovery: Ensure that the octal integer constant is valid. 
  29873.  
  29874.  
  29875. ΓòÉΓòÉΓòÉ 19.665. EDC3261 ΓòÉΓòÉΓòÉ
  29876.  
  29877. All the arguments must be specified for "&1" because its default arguments have 
  29878. not been checked yet. 
  29879.  
  29880. For member functions, names in default argument expressions are bound at the 
  29881. end of the class declaration.  Calling a member function as part of a second 
  29882. member function's default argument is an error if the first member function's 
  29883. default arguments have not been checked and the call does not specify all of 
  29884. the arguments. 
  29885.  
  29886. Recovery: Specify all the arguments for the function. 
  29887.  
  29888.  
  29889. ΓòÉΓòÉΓòÉ 19.666. EDC3262 ΓòÉΓòÉΓòÉ
  29890.  
  29891. Ellipsis (...) cannot be used for "&1". 
  29892.  
  29893. Recovery: Remove the ellipsis. 
  29894.  
  29895.  
  29896. ΓòÉΓòÉΓòÉ 19.667. EDC3263 ΓòÉΓòÉΓòÉ
  29897.  
  29898. Syntax error - expected "&1" or "&2" and found "&3". 
  29899.  
  29900. A syntax error was found while parsing the program.  The message identifies 
  29901. what the compiler expected and what it actually found. 
  29902.  
  29903. Recovery: Correct the syntax error. 
  29904.  
  29905.  
  29906. ΓòÉΓòÉΓòÉ 19.668. EDC3264 ΓòÉΓòÉΓòÉ
  29907.  
  29908. A character constant must end before the end of the line. 
  29909.  
  29910. Recovery: End the character constant before the end of the line or use the 
  29911. continuation "/" symbol. 
  29912.  
  29913.  
  29914. ΓòÉΓòÉΓòÉ 19.669. EDC3265 ΓòÉΓòÉΓòÉ
  29915.  
  29916. A virtual function initializer must be 0. 
  29917.  
  29918. Recovery: Set the virtual function initializer to 0. 
  29919.  
  29920.  
  29921. ΓòÉΓòÉΓòÉ 19.670. EDC3266 ΓòÉΓòÉΓòÉ
  29922.  
  29923. "&1" is given "&2" access. 
  29924.  
  29925. Recovery: Ensure this change is intended. 
  29926.  
  29927.  
  29928. ΓòÉΓòÉΓòÉ 19.671. EDC3267 ΓòÉΓòÉΓòÉ
  29929.  
  29930. "&1" has been qualified with the "this" pointer. 
  29931.  
  29932. Recovery: Ensure this qualification is intended. 
  29933.  
  29934.  
  29935. ΓòÉΓòÉΓòÉ 19.672. EDC3268 ΓòÉΓòÉΓòÉ
  29936.  
  29937. Invalid escape sequence;  the backslash is ignored. 
  29938.  
  29939. Recovery: Ensure the escape sequence is valid. 
  29940.  
  29941.  
  29942. ΓòÉΓòÉΓòÉ 19.673. EDC3269 ΓòÉΓòÉΓòÉ
  29943.  
  29944. The result of an address expression is being deleted. 
  29945.  
  29946. Recovery: Ensure this action is intended. 
  29947.  
  29948.  
  29949. ΓòÉΓòÉΓòÉ 19.674. EDC3270 ΓòÉΓòÉΓòÉ
  29950.  
  29951. Conversion from "&1" to "&2" matches more than one conversion function. 
  29952.  
  29953. More than one conversion function could be used to perform the specified 
  29954. conversion. 
  29955.  
  29956. Recovery: Create a new conversion function for this conversion or change one of 
  29957. the types. 
  29958.  
  29959.  
  29960. ΓòÉΓòÉΓòÉ 19.675. EDC3271 ΓòÉΓòÉΓòÉ
  29961.  
  29962. Conversion matches "&1". 
  29963.  
  29964. Recovery: Ensure this is the intended match. 
  29965.  
  29966.  
  29967. ΓòÉΓòÉΓòÉ 19.676. EDC3272 ΓòÉΓòÉΓòÉ
  29968.  
  29969. "&1" cannot be initialized with an initializer list. 
  29970.  
  29971. Only an object of a class with no constructors, no private or protected 
  29972. members, no virtual functions and no base classes can be initialized with an 
  29973. initializer list. 
  29974.  
  29975. Recovery: Remove the class from the initializer list. 
  29976.  
  29977.  
  29978. ΓòÉΓòÉΓòÉ 19.677. EDC3273 ΓòÉΓòÉΓòÉ
  29979.  
  29980. A pointer to a virtual base "&1" cannot be converted to a pointer to a derived 
  29981. class "&2". 
  29982.  
  29983. A pointer to a class B may be explicitly converted to a pointer to a class D 
  29984. that has B as a direct or indirect base class if an unambiguous conversion from 
  29985. D to B exists and if B is not a virtual base class. 
  29986.  
  29987. Recovery: Remove the conversion of the pointer. 
  29988.  
  29989.  
  29990. ΓòÉΓòÉΓòÉ 19.678. EDC3274 ΓòÉΓòÉΓòÉ
  29991.  
  29992. The arguments passed using the ellipsis may not be accessible. 
  29993.  
  29994. Arguments passed using an ellipsis are only accessible if there is an argument 
  29995. preceding the ellipsis and the preceding argument is not passed by reference. 
  29996.  
  29997. Recovery: Ensure that there is an argument preceding the ellipsis and that the 
  29998. preceding argument is not passed by reference. 
  29999.  
  30000.  
  30001. ΓòÉΓòÉΓòÉ 19.679. EDC3275 ΓòÉΓòÉΓòÉ
  30002.  
  30003. Member function "&1" has already been declared. 
  30004.  
  30005. A member function cannot be redeclared in the class definition. 
  30006.  
  30007. Recovery: Remove one of the declarations. 
  30008.  
  30009.  
  30010. ΓòÉΓòÉΓòÉ 19.680. EDC3276 ΓòÉΓòÉΓòÉ
  30011.  
  30012. Assignment to a constant expression is not allowed. 
  30013.  
  30014. Recovery: Remove the assignment. 
  30015.  
  30016.  
  30017. ΓòÉΓòÉΓòÉ 19.681. EDC3277 ΓòÉΓòÉΓòÉ
  30018.  
  30019. Assignment to const variable "&1" is not allowed. 
  30020.  
  30021. Recovery: Remove the assignment to the const variable. 
  30022.  
  30023.  
  30024. ΓòÉΓòÉΓòÉ 19.682. EDC3278 ΓòÉΓòÉΓòÉ
  30025.  
  30026. Syntax error found while parsing the bit-field declarator. 
  30027.  
  30028. Recovery: Correct the syntax error. 
  30029.  
  30030.  
  30031. ΓòÉΓòÉΓòÉ 19.683. EDC3279 ΓòÉΓòÉΓòÉ
  30032.  
  30033. The return type for the "operator->" cannot be the containing class. 
  30034.  
  30035. Recovery: Change the return type for the "operator->". 
  30036.  
  30037.  
  30038. ΓòÉΓòÉΓòÉ 19.684. EDC3280 ΓòÉΓòÉΓòÉ
  30039.  
  30040. The virtual function table for "&1" is defined with "&2" linkage. 
  30041.  
  30042. Recovery: Ensure this is the desired result. 
  30043.  
  30044.  
  30045. ΓòÉΓòÉΓòÉ 19.685. EDC3281 ΓòÉΓòÉΓòÉ
  30046.  
  30047. The virtual function table for "&1" will be defined where "&2" is defined. 
  30048.  
  30049. Recovery: Ensure this is the desired result. 
  30050.  
  30051.  
  30052. ΓòÉΓòÉΓòÉ 19.686. EDC3282 ΓòÉΓòÉΓòÉ
  30053.  
  30054. The virtual function table for "&1" will be defined in a file specified by the 
  30055. user. 
  30056.  
  30057. Recovery: Ensure this is the desired result. 
  30058.  
  30059.  
  30060. ΓòÉΓòÉΓòÉ 19.687. EDC3283 ΓòÉΓòÉΓòÉ
  30061.  
  30062. The previous message applies to function argument &1. 
  30063.  
  30064. The previous message applies to the specified argument number. 
  30065.  
  30066.  
  30067. ΓòÉΓòÉΓòÉ 19.688. EDC3284 ΓòÉΓòÉΓòÉ
  30068.  
  30069. Conversion from "&1" to a reference to a non-const type "&2" requires a 
  30070. temporary. 
  30071.  
  30072. Recovery: Change the reference so that it is to a const type. 
  30073.  
  30074.  
  30075. ΓòÉΓòÉΓòÉ 19.689. EDC3285 ΓòÉΓòÉΓòÉ
  30076.  
  30077. The address of a local variable or compiler temporary is being used in a return 
  30078. expression. 
  30079.  
  30080. The address of a local variable may not be valid once control is passed out of 
  30081. the function. 
  30082.  
  30083. Recovery: Declare the variable in the calling function or as a global variable. 
  30084.  
  30085.  
  30086. ΓòÉΓòÉΓòÉ 19.690. EDC3286 ΓòÉΓòÉΓòÉ
  30087.  
  30088. Keyword "&1" cannot be used with a function definition. 
  30089.  
  30090. Recovery: Remove the keyword. 
  30091.  
  30092.  
  30093. ΓòÉΓòÉΓòÉ 19.691. EDC3287 ΓòÉΓòÉΓòÉ
  30094.  
  30095. The directive must occur before the first C++ statement in program;  "#pragma" 
  30096. is ignored. 
  30097.  
  30098. Recovery: Remove the directive or place it before the first C++ statement in 
  30099. the program. 
  30100.  
  30101.  
  30102. ΓòÉΓòÉΓòÉ 19.692. EDC3288 ΓòÉΓòÉΓòÉ
  30103.  
  30104. The pointer to member function must be bound to an object or a pointer to an 
  30105. object when it used with the function call operator (). 
  30106.  
  30107. Recovery: Remove the pointer. 
  30108.  
  30109.  
  30110. ΓòÉΓòÉΓòÉ 19.693. EDC3289 ΓòÉΓòÉΓòÉ
  30111.  
  30112. The static data member "&1" has already been declared. 
  30113.  
  30114. Recovery: Remove or change one of the declarations. 
  30115.  
  30116.  
  30117. ΓòÉΓòÉΓòÉ 19.694. EDC3290 ΓòÉΓòÉΓòÉ
  30118.  
  30119. Option "&1" must be specified on the command line or before the first C++ 
  30120. statement in the program. 
  30121.  
  30122. Recovery: Remove the option or place it before the first statement in the C++ 
  30123. program. 
  30124.  
  30125.  
  30126. ΓòÉΓòÉΓòÉ 19.695. EDC3291 ΓòÉΓòÉΓòÉ
  30127.  
  30128. The direct base "&1" of class "&2" is ignored because "&1" is also an indirect 
  30129. base of "&2". 
  30130.  
  30131. A reference to a member of "&1" will be ambiguous. 
  30132.  
  30133. Recovery: Remove the indirect inheritance. 
  30134.  
  30135.  
  30136. ΓòÉΓòÉΓòÉ 19.696. EDC3292 ΓòÉΓòÉΓòÉ
  30137.  
  30138. The "&1" operator cannot be applied to undefined class "&2". 
  30139.  
  30140. A class is undefined until the definition of its tag has been completed.  A 
  30141. class tag is undefined when the list describing the name and type of its 
  30142. members has not been specified.  The definition of the tag must be given before 
  30143. the operator is applied to the class. 
  30144.  
  30145. Recovery: Complete the definition of the class before applying an operator to 
  30146. it. 
  30147.  
  30148.  
  30149. ΓòÉΓòÉΓòÉ 19.697. EDC3293 ΓòÉΓòÉΓòÉ
  30150.  
  30151. "&1" hides the &2 "&3". 
  30152.  
  30153. A member in the derived class hides a virtual function member in a base class. 
  30154.  
  30155. Recovery: Ensure the hiding of the virtual function member is intended. 
  30156.  
  30157.  
  30158. ΓòÉΓòÉΓòÉ 19.698. EDC3294 ΓòÉΓòÉΓòÉ
  30159.  
  30160. "&1" is not the name of a function. 
  30161.  
  30162. A function name is required in this context.  The specified name has been 
  30163. declared but it is not the name of a function. 
  30164.  
  30165. Recovery: Check the spelling.  If necessary, change to a function name. 
  30166.  
  30167.  
  30168. ΓòÉΓòÉΓòÉ 19.699. EDC3295 ΓòÉΓòÉΓòÉ
  30169.  
  30170. "&1" is not the name of a variable that may be used in a "#pragma disjoint" 
  30171. directive. 
  30172.  
  30173. The variable must not be a class member or an enumeration constant. 
  30174.  
  30175. Recovery: Ensure that the variable is not a class member or an enumeration 
  30176. constant. 
  30177.  
  30178.  
  30179. ΓòÉΓòÉΓòÉ 19.700. EDC3296 ΓòÉΓòÉΓòÉ
  30180.  
  30181. The virtual functions "&1" and "&2" are ambiguous since they override the same 
  30182. function in virtual base class "&3". 
  30183.  
  30184. The two functions are ambiguous and the virtual function call mechanism will 
  30185. not be able to choose at run-time. 
  30186.  
  30187. Recovery: Remove one of the virtual functions. 
  30188.  
  30189.  
  30190. ΓòÉΓòÉΓòÉ 19.701. EDC3297 ΓòÉΓòÉΓòÉ
  30191.  
  30192. The "this" address for "&1" is ambiguous because there are multiple instances 
  30193. of "&2". 
  30194.  
  30195. Two or more "this" addresses are possible for this virtual function. The 
  30196. virtual function call mechanism will not be able to determine the correct 
  30197. address at run-time. 
  30198.  
  30199. Recovery: Remove the "this" expression or change the function name. 
  30200.  
  30201.  
  30202. ΓòÉΓòÉΓòÉ 19.702. EDC3298 ΓòÉΓòÉΓòÉ
  30203.  
  30204. Conversion from "&1" matches more than one conversion function. 
  30205.  
  30206. More than one conversion function could be applied to perform the conversion 
  30207. from the specified type. 
  30208.  
  30209. Recovery: Create a new conversion function or remove the conversion. 
  30210.  
  30211.  
  30212. ΓòÉΓòÉΓòÉ 19.703. EDC3299 ΓòÉΓòÉΓòÉ
  30213.  
  30214. Function "&1" must not be declared as "&2". 
  30215.  
  30216. The specified function has a storage class that is not allowed in the context 
  30217. that the function is declared in. 
  30218.  
  30219. Recovery: Remove the declaration or change the storage class of the function. 
  30220.  
  30221.  
  30222. ΓòÉΓòÉΓòÉ 19.704. EDC3300 ΓòÉΓòÉΓòÉ
  30223.  
  30224. The declaration of "&1" must initialize the const member "&2". 
  30225.  
  30226. Recovery: Initialize the member in the declaration. 
  30227.  
  30228.  
  30229. ΓòÉΓòÉΓòÉ 19.705. EDC3301 ΓòÉΓòÉΓòÉ
  30230.  
  30231. The declaration of "&1" must initialize the reference member "&2". 
  30232.  
  30233. Recovery: Initialize the member in the declaration. 
  30234.  
  30235.  
  30236. ΓòÉΓòÉΓòÉ 19.706. EDC3302 ΓòÉΓòÉΓòÉ
  30237.  
  30238. "&1" is not allowed as a function return type.  There may be a ";" missing 
  30239. after a "}". 
  30240.  
  30241. A class or enum definition must not be specified as a function return type.  A 
  30242. semicolon may be missing after the definition. 
  30243.  
  30244. Recovery: Ensure that a semicolon is not missing after the definition or change 
  30245. the return type. 
  30246.  
  30247.  
  30248. ΓòÉΓòÉΓòÉ 19.707. EDC3303 ΓòÉΓòÉΓòÉ
  30249.  
  30250. "&1" cannot be a base of "&2" because "&3" contains a member function called 
  30251. "&2". 
  30252.  
  30253. A class cannot inherit a function that has the same as the class. 
  30254.  
  30255. Recovery: Change the name of either the base class or the inherited function. 
  30256.  
  30257.  
  30258. ΓòÉΓòÉΓòÉ 19.708. EDC3304 ΓòÉΓòÉΓòÉ
  30259.  
  30260. Forward declaration of the enumeration "&1" is not allowed. 
  30261.  
  30262. Recovery: Fully declare the enumeration. 
  30263.  
  30264.  
  30265. ΓòÉΓòÉΓòÉ 19.709. EDC3305 ΓòÉΓòÉΓòÉ
  30266.  
  30267. Unrecognized value "&1" specified with option "&2". 
  30268.  
  30269. Recovery: Remove the unrecognized value. 
  30270.  
  30271.  
  30272. ΓòÉΓòÉΓòÉ 19.710. EDC3306 ΓòÉΓòÉΓòÉ
  30273.  
  30274. The previous message applies to argument &1 of function "&2". 
  30275.  
  30276. The previous message applies to the specified argument number. 
  30277.  
  30278.  
  30279. ΓòÉΓòÉΓòÉ 19.711. EDC3307 ΓòÉΓòÉΓòÉ
  30280.  
  30281. Unrecognized pragma "&1". 
  30282.  
  30283. The pragma is not supported by this compiler. 
  30284.  
  30285. Recovery: Change or remove the #pragma directive. 
  30286.  
  30287.  
  30288. ΓòÉΓòÉΓòÉ 19.712. EDC3308 ΓòÉΓòÉΓòÉ
  30289.  
  30290. The nested class object "&1" needs a constructor so that its &2 members can be 
  30291. initialized. 
  30292.  
  30293. Recovery: Create a constructor for the nested class object. 
  30294.  
  30295.  
  30296. ΓòÉΓòÉΓòÉ 19.713. EDC3309 ΓòÉΓòÉΓòÉ
  30297.  
  30298. The integer constant is out of range. 
  30299.  
  30300. Recovery: Ensure the integer constant is in range. 
  30301.  
  30302.  
  30303. ΓòÉΓòÉΓòÉ 19.714. EDC3310 ΓòÉΓòÉΓòÉ
  30304.  
  30305. The floating point constant is out of range. 
  30306.  
  30307. Recovery: Ensure the floating point constant is in range. 
  30308.  
  30309.  
  30310. ΓòÉΓòÉΓòÉ 19.715. EDC3311 ΓòÉΓòÉΓòÉ
  30311.  
  30312. The &1 member "&2" must be initialized in the constructor's initializer list. 
  30313.  
  30314. Using the constructor's member initializer list is the only way to initialize 
  30315. nonstatic const and reference members. 
  30316.  
  30317. Recovery: Initialize the member in the constructor's initializer list. 
  30318.  
  30319.  
  30320. ΓòÉΓòÉΓòÉ 19.716. EDC3312 ΓòÉΓòÉΓòÉ
  30321.  
  30322. Unexpected end of file: newline expected. 
  30323.  
  30324. The file did not end with a newline character. 
  30325.  
  30326. Recovery: Ensure the file ends with a newline character. 
  30327.  
  30328.  
  30329. ΓòÉΓòÉΓòÉ 19.717. EDC3313 ΓòÉΓòÉΓòÉ
  30330.  
  30331. Constructors and conversion functions are not considered when resolving an 
  30332. explicit cast to a reference type. 
  30333.  
  30334.  
  30335. ΓòÉΓòÉΓòÉ 19.718. EDC3314 ΓòÉΓòÉΓòÉ
  30336.  
  30337. A character string literal cannot be concatenated with a wide string literal. 
  30338.  
  30339. A string that has a prefix L cannot be concatenated with a string that is not 
  30340. prefixed. 
  30341.  
  30342. Recovery: Ensure both strings have the same prefix, or no prefix at all. 
  30343.  
  30344.  
  30345. ΓòÉΓòÉΓòÉ 19.719. EDC3315 ΓòÉΓòÉΓòÉ
  30346.  
  30347. All members of type "&1" must be explicitly initialized with all default 
  30348. arguments specified because the default arguments for "&2" have not been 
  30349. checked yet. 
  30350.  
  30351. Default arguments for member functions are not checked until the end of the 
  30352. class definition.  Default arguments for member functions of nested classes are 
  30353. not semantic checked until the containing class is defined.  A call to a member 
  30354. function before its default arguments have been checked must specify all 
  30355. arguments. 
  30356.  
  30357. Recovery: Specify all default arguments with all members of the type. 
  30358.  
  30359.  
  30360. ΓòÉΓòÉΓòÉ 19.720. EDC3316 ΓòÉΓòÉΓòÉ
  30361.  
  30362. The nested class "&1" is undefined and cannot be defined later. 
  30363.  
  30364. A class must be defined in the scope that it was introduced. 
  30365.  
  30366. Recovery: Define the class in the scope that it was introduced in. 
  30367.  
  30368.  
  30369. ΓòÉΓòÉΓòÉ 19.721. EDC3317 ΓòÉΓòÉΓòÉ
  30370.  
  30371. The address of an overloaded function can be taken only in an initialization or 
  30372. an assignment. 
  30373.  
  30374. Recovery: Ensure the address of an overloaded function is used on an 
  30375. initialization or an assignment. 
  30376.  
  30377.  
  30378. ΓòÉΓòÉΓòÉ 19.722. EDC3318 ΓòÉΓòÉΓòÉ
  30379.  
  30380. The compiler cannot recover from the previous errors. 
  30381.  
  30382. Recovery: Fix the errors and try the compile again. 
  30383.  
  30384.  
  30385. ΓòÉΓòÉΓòÉ 19.723. EDC3319 ΓòÉΓòÉΓòÉ
  30386.  
  30387. The mangled name for "&1" contains a compiler generated name.  The mangled name 
  30388. will not be visible from other compilation units. 
  30389.  
  30390.  
  30391. ΓòÉΓòÉΓòÉ 19.724. EDC3320 ΓòÉΓòÉΓòÉ
  30392.  
  30393. Syntax error - found "&1 &2" : "&1" is not a type name. 
  30394.  
  30395. Recovery: Change to a type name or remove the expression. 
  30396.  
  30397.  
  30398. ΓòÉΓòÉΓòÉ 19.725. EDC3321 ΓòÉΓòÉΓòÉ
  30399.  
  30400. A temporary of type "&1" is needed: "&2" is an abstract class. 
  30401.  
  30402. Recovery: Ensure this is the desired result. 
  30403.  
  30404.  
  30405. ΓòÉΓòÉΓòÉ 19.726. EDC3322 ΓòÉΓòÉΓòÉ
  30406.  
  30407. Nesting level of template class definitions may cause the compiler to fail. 
  30408.  
  30409. Template class definitions are nested in such a way that the compiler may not 
  30410. be able to continue. 
  30411.  
  30412. Recovery: Reduce the number of nesting levels of template class definitions. 
  30413.  
  30414.  
  30415. ΓòÉΓòÉΓòÉ 19.727. EDC3323 ΓòÉΓòÉΓòÉ
  30416.  
  30417. "&1" hides pure virtual function "&2" in the nonvirtual base "&3". 
  30418.  
  30419. The pure virtual function in a nonvirtual base cannot be overridden once it has 
  30420. been hidden. 
  30421.  
  30422. Recovery: Ensure this is the desired result.  If this is not intended, unhide 
  30423. the pure virtual function. 
  30424.  
  30425.  
  30426. ΓòÉΓòÉΓòÉ 19.728. EDC3324 ΓòÉΓòÉΓòÉ
  30427.  
  30428. The class qualifier "&1" for "&2" must be a template class that uses the 
  30429. template arguments. 
  30430.  
  30431. A non-class template can only declare a global function or a member of a 
  30432. template class.  If it declares a member of a template class, the template 
  30433. class arguments must include at least one of the non-class template arguments. 
  30434.  
  30435. Recovery: Change the template declaration so that it either declares a global 
  30436. function or a member of a template class that uses the non-class template 
  30437. arguments. 
  30438.  
  30439.  
  30440. ΓòÉΓòÉΓòÉ 19.729. EDC3325 ΓòÉΓòÉΓòÉ
  30441.  
  30442. The class "&1" cannot be passed by value because it does not have a copy 
  30443. constructor. 
  30444.  
  30445. Recovery: Create a copy constructor for the class or change the argument to 
  30446. pass by variable. 
  30447.  
  30448.  
  30449. ΓòÉΓòÉΓòÉ 19.730. EDC3326 ΓòÉΓòÉΓòÉ
  30450.  
  30451. The previous &1 messages show situations that could arise if the corresponding 
  30452. template definitions were instantiated. 
  30453.  
  30454. During the processing of a class template, possible errors were found in the 
  30455. class declaration.  These errors may occur when the template is instantiated. 
  30456.  
  30457. Recovery: Ensure that the errors will not occur when the template is 
  30458. instantiated. 
  30459.  
  30460.  
  30461. ΓòÉΓòÉΓòÉ 19.731. EDC3327 ΓòÉΓòÉΓòÉ
  30462.  
  30463. The previous message shows a situation that could arise if the corresponding 
  30464. template definition was instantiated. 
  30465.  
  30466. During the processing of a class template, a possible error was found in the 
  30467. class declaration.  This error may occur when the template is instantiated. 
  30468.  
  30469. Recovery: Ensure that the error will not occur when the template is 
  30470. instantiated. 
  30471.  
  30472.  
  30473. ΓòÉΓòÉΓòÉ 19.732. EDC3328 ΓòÉΓòÉΓòÉ
  30474.  
  30475. The output file name "&1" cannot be the same as the input file name. 
  30476.  
  30477. Recovery: Change either the input file name or the output file name. 
  30478.  
  30479.  
  30480. ΓòÉΓòÉΓòÉ 19.733. EDC3329 ΓòÉΓòÉΓòÉ
  30481.  
  30482. The external variable "&1" cannot be defined at block scope. 
  30483.  
  30484. Recovery: Move the external variable definition. 
  30485.  
  30486.  
  30487. ΓòÉΓòÉΓòÉ 19.734. EDC3330 ΓòÉΓòÉΓòÉ
  30488.  
  30489. "&1" cannot have an initializer list. 
  30490.  
  30491. Recovery: Remove the initializer list. 
  30492.  
  30493.  
  30494. ΓòÉΓòÉΓòÉ 19.735. EDC3331 ΓòÉΓòÉΓòÉ
  30495.  
  30496. Return value of type "&1" is expected. 
  30497.  
  30498. No return value is being returned from the current function but the function is 
  30499. expecting a non-void return value. 
  30500.  
  30501. Recovery: Ensure a return value will be returned or change the return value of 
  30502. the function. 
  30503.  
  30504.  
  30505. ΓòÉΓòÉΓòÉ 19.736. EDC3332 ΓòÉΓòÉΓòÉ
  30506.  
  30507. "&1" bypasses initialization of "&2". 
  30508.  
  30509. It is invalid to jump past a declaration with an explicit or implicit 
  30510. initializer unless the declaration is in an inner block that is also jumped 
  30511. past. 
  30512.  
  30513. Recovery: Enclose the initialization in a block statement. 
  30514.  
  30515.  
  30516. ΓòÉΓòÉΓòÉ 19.737. EDC3333 ΓòÉΓòÉΓòÉ
  30517.  
  30518. "&1" is being redeclared as a member function. It was originally declared as a 
  30519. data member. 
  30520.  
  30521. The template redeclares a data member of a class template as a member function. 
  30522.  
  30523. Recovery: Change the original declaration to a member function or change the 
  30524. redeclaration to a data member. 
  30525.  
  30526.  
  30527. ΓòÉΓòÉΓòÉ 19.738. EDC3334 ΓòÉΓòÉΓòÉ
  30528.  
  30529. "&1" is being redeclared as a non-function member or has syntax errors in its 
  30530. argument list. 
  30531.  
  30532. The template redeclares a member function of a class template as a data member. 
  30533. There may be syntax errors in the declaration. 
  30534.  
  30535.  
  30536. ΓòÉΓòÉΓòÉ 19.739. EDC3335 ΓòÉΓòÉΓòÉ
  30537.  
  30538. A string literal cannot be longer than &1 characters. 
  30539.  
  30540. Recovery: Specify a shorter string literal. 
  30541.  
  30542.  
  30543. ΓòÉΓòÉΓòÉ 19.740. EDC3336 ΓòÉΓòÉΓòÉ
  30544.  
  30545. A wide string literal cannot be longer than &1 characters. 
  30546.  
  30547. Recovery: Specify a shorter string literal. 
  30548.  
  30549.  
  30550. ΓòÉΓòÉΓòÉ 19.741. EDC3337 ΓòÉΓòÉΓòÉ
  30551.  
  30552. The definition of "&1" is not contained in an include file, but it may be 
  30553. needed for automatic generation of template functions. 
  30554.  
  30555. The definition of the class can only be used during automatic generation of 
  30556. template functions if it is contained in an include file. 
  30557.  
  30558. Recovery: Add the definition to an include file. 
  30559.  
  30560.  
  30561. ΓòÉΓòÉΓòÉ 19.742. EDC3338 ΓòÉΓòÉΓòÉ
  30562.  
  30563. Invalid MBCS character. 
  30564.  
  30565. Recovery: Replace the MBCS character. 
  30566.  
  30567.  
  30568. ΓòÉΓòÉΓòÉ 19.743. EDC3339 ΓòÉΓòÉΓòÉ
  30569.  
  30570. "&1" is an undefined pure virtual function. 
  30571.  
  30572. Recovery: Remove or define as a pure virtual function. 
  30573.  
  30574.  
  30575. ΓòÉΓòÉΓòÉ 19.744. EDC3340 ΓòÉΓòÉΓòÉ
  30576.  
  30577. The presence of the "#line" directive in source files compiled with "-a" or 
  30578. "-ae" may result in the "tcov" program behaving unpredictably. 
  30579.  
  30580. Recovery: Remove the "#line" directive or recompile without the "-a" or "-ae" 
  30581. option. 
  30582.  
  30583.  
  30584. ΓòÉΓòÉΓòÉ 19.745. EDC3341 ΓòÉΓòÉΓòÉ
  30585.  
  30586. Missing value for option "&1". 
  30587.  
  30588. Recovery: Add a value for the option. 
  30589.  
  30590.  
  30591. ΓòÉΓòÉΓòÉ 19.746. EDC3342 ΓòÉΓòÉΓòÉ
  30592.  
  30593. Template "&1" cannot be instantiated because the actual argument for formal 
  30594. argument "&2" has more than one variant. 
  30595.  
  30596. The argument is a function template or an overloaded function with two or more 
  30597. variants.  The compiler cannot decide which variant to choose to bind to the 
  30598. argument type. 
  30599.  
  30600. Recovery: Change the formal template argument or remove the extra variants. 
  30601.  
  30602.  
  30603. ΓòÉΓòÉΓòÉ 19.747. EDC3343 ΓòÉΓòÉΓòÉ
  30604.  
  30605. More than 32760 files in a compilation unit. 
  30606.  
  30607. Recovery: Reduce the number of files. 
  30608.  
  30609.  
  30610. ΓòÉΓòÉΓòÉ 19.748. EDC3345 ΓòÉΓòÉΓòÉ
  30611.  
  30612. Pointer to a builtin function not allowed. 
  30613.  
  30614. The address of a builtin function cannot be taken therefore the compiler does 
  30615. not allow for the declaration of a pointer to a builtin function. 
  30616.  
  30617. Recovery: Remove the pointer. 
  30618.  
  30619.  
  30620. ΓòÉΓòÉΓòÉ 19.749. EDC3346 ΓòÉΓòÉΓòÉ
  30621.  
  30622. Builtin function "&1" not recognized. 
  30623.  
  30624. The function declared as a builtin is not recognized by the compiler as being a 
  30625. builtin function. 
  30626.  
  30627. Recovery: Ensure the function is a builtin function or remove the builtin 
  30628. keyword from the declaration. 
  30629.  
  30630.  
  30631. ΓòÉΓòÉΓòÉ 19.750. EDC3347 ΓòÉΓòÉΓòÉ
  30632.  
  30633. "&1" is not supported. 
  30634.  
  30635. Recovery: Remove the operator from the expression. 
  30636.  
  30637.  
  30638. ΓòÉΓòÉΓòÉ 19.751. EDC3348 ΓòÉΓòÉΓòÉ
  30639.  
  30640. Function calls are not supported. 
  30641.  
  30642. Recovery: Remove function calls from the expression. 
  30643.  
  30644.  
  30645. ΓòÉΓòÉΓòÉ 19.752. EDC3349 ΓòÉΓòÉΓòÉ
  30646.  
  30647. The expression is too complicated. 
  30648.  
  30649. Recovery: Simplify the expression. 
  30650.  
  30651.  
  30652. ΓòÉΓòÉΓòÉ 19.753. EDC3350 ΓòÉΓòÉΓòÉ
  30653.  
  30654. Evaluation of the expression requires a temporary. 
  30655.  
  30656. Recovery: Change the expression so that a temporary is not required. 
  30657.  
  30658.  
  30659. ΓòÉΓòÉΓòÉ 19.754. EDC3351 ΓòÉΓòÉΓòÉ
  30660.  
  30661. "&1" is an overloaded function. 
  30662.  
  30663. The identifier refers to an overloaded function with two or more variants. The 
  30664. compiler requires a prototype argument list to decide which variant to process. 
  30665.  
  30666. Recovery: Specify a prototype argument list or remove variants of the 
  30667. overloaded function. 
  30668.  
  30669.  
  30670. ΓòÉΓòÉΓòÉ 19.755. EDC3352 ΓòÉΓòÉΓòÉ
  30671.  
  30672. Identifier or function prototype expected. 
  30673.  
  30674. The symbol must be the name of a data object, the name of a function with no 
  30675. variants, or a function or operator name followed by a parenthesized argument 
  30676. list. 
  30677.  
  30678. Recovery: Ensure the symbol is either the name of a data object, the name of a 
  30679. function with no variants, or a function or operator name followed by a 
  30680. parenthised argument list. 
  30681.  
  30682.  
  30683. ΓòÉΓòÉΓòÉ 19.756. EDC3353 ΓòÉΓòÉΓòÉ
  30684.  
  30685. "&1" does not have external linkage. 
  30686.  
  30687. The pragmas map, import, and export can only be applied to objects or functions 
  30688. that are external. 
  30689.  
  30690. Recovery: Give the identifier external linkage. 
  30691.  
  30692.  
  30693. ΓòÉΓòÉΓòÉ 19.757. EDC3354 ΓòÉΓòÉΓòÉ
  30694.  
  30695. "&1" has already been mapped. 
  30696.  
  30697. Only one map name may be given to any object or function. 
  30698.  
  30699. Recovery: Change one of the map names. 
  30700.  
  30701.  
  30702. ΓòÉΓòÉΓòÉ 19.758. EDC3355 ΓòÉΓòÉΓòÉ
  30703.  
  30704. BII file name cannot be found in the BII table for function &1. 
  30705.  
  30706. The BII file name cannot be found in the BII table. 
  30707.  
  30708. Recovery: Check the spelling of the file name. 
  30709.  
  30710.  
  30711. ΓòÉΓòÉΓòÉ 19.759. EDC3356 ΓòÉΓòÉΓòÉ
  30712.  
  30713. Invalid option with #pragma. 
  30714.  
  30715. The option given with #pragma is invalid. 
  30716.  
  30717. Recovery: Remove the #pragma option. 
  30718.  
  30719.  
  30720. ΓòÉΓòÉΓòÉ 19.760. EDC3357 ΓòÉΓòÉΓòÉ
  30721.  
  30722. BII function name already exists in the BII table for function &1. 
  30723.  
  30724. The BII function name already exists in the BII table. 
  30725.  
  30726. Recovery: Change the file name. 
  30727.  
  30728.  
  30729. ΓòÉΓòÉΓòÉ 19.761. EDC3358 ΓòÉΓòÉΓòÉ
  30730.  
  30731. The "&1" option is not allowed with the "&2" option. 
  30732.  
  30733. The specified options cannot be specified together. The first is ignored. 
  30734.  
  30735. Recovery: Remove one of the options. 
  30736.  
  30737.  
  30738. ΓòÉΓòÉΓòÉ 19.762. EDC3359 ΓòÉΓòÉΓòÉ
  30739.  
  30740. The result of string concatenation is a non-Pascal string. 
  30741.  
  30742. A pascal string was concatenated to a non-Pascal string. The result of the 
  30743. concatenation is a non-Pascal string. 
  30744.  
  30745. Recovery: Ensure both strings are either Pascal or non-Pascal. 
  30746.  
  30747.  
  30748. ΓòÉΓòÉΓòÉ 19.763. EDC3360 ΓòÉΓòÉΓòÉ
  30749.  
  30750. The result of string concatenation is a Pascal string. 
  30751.  
  30752. A non-Pascal string was concatenated to a Pascal string. The result of the 
  30753. concatenation is a Pascal string. 
  30754.  
  30755. Recovery: Ensure both strings are either Pascal or non-Pascal. 
  30756.  
  30757.  
  30758. ΓòÉΓòÉΓòÉ 19.764. EDC3361 ΓòÉΓòÉΓòÉ
  30759.  
  30760. A Pascal string is too long; the length has been set to 255. 
  30761.  
  30762. A Pascal string is longer than 255 bytes. The length byte has been set to 255, 
  30763. but the rest of the string is left intact. 
  30764.  
  30765. Recovery: Shorten the Pascal string. 
  30766.  
  30767.  
  30768. ΓòÉΓòÉΓòÉ 19.765. EDC3362 ΓòÉΓòÉΓòÉ
  30769.  
  30770. The bit-field length must not be negative. 
  30771.  
  30772. The bit-field length must be a non-negative integer value. 
  30773.  
  30774. Recovery: Change the bit-field length to a non-negative integer value. 
  30775.  
  30776.  
  30777. ΓòÉΓòÉΓòÉ 19.766. EDC3363 ΓòÉΓòÉΓòÉ
  30778.  
  30779. The bit-field length must not be negative. 
  30780.  
  30781. The bit-field length must be a non-negative integer value. 
  30782.  
  30783. Recovery: Change the bit-field length to a non-negative integer value. 
  30784.  
  30785.  
  30786. ΓòÉΓòÉΓòÉ 19.767. EDC3364 ΓòÉΓòÉΓòÉ
  30787.  
  30788. A zero-length bit-field must not have a name. 
  30789.  
  30790. A named bit-field must have a positive length; a zero-length bit-field is used 
  30791. for alignment only, and must not be named. 
  30792.  
  30793. Recovery: Remove the name from the zero-length bit-field. 
  30794.  
  30795.  
  30796. ΓòÉΓòÉΓòÉ 19.768. EDC3365 ΓòÉΓòÉΓòÉ
  30797.  
  30798. The bit-field is too small; &1 bits are needed for "&2". 
  30799.  
  30800. The bit-field length is smaller than the number of bits needed to hold all 
  30801. values of the enum. 
  30802.  
  30803. Recovery: Increase the bit-field length. 
  30804.  
  30805.  
  30806. ΓòÉΓòÉΓòÉ 19.769. EDC3366 ΓòÉΓòÉΓòÉ
  30807.  
  30808. The bit-field is larger than necessary; only &1 bits are needed for "&2". 
  30809.  
  30810. The bit-field length is larger than the number of bits needed to hold all 
  30811. values of the enum. 
  30812.  
  30813. Recovery: Decrease the bit-field length. 
  30814.  
  30815.  
  30816. ΓòÉΓòÉΓòÉ 19.770. EDC3367 ΓòÉΓòÉΓòÉ
  30817.  
  30818. An object declared as compatible with 16-bit applications is larger than 64K. 
  30819.  
  30820. The name of the object, or a typedef name used to declare it, appeared in a 
  30821. #pragma seg16 directive. 
  30822.  
  30823. Recovery: Remove the name of an object in the #pragma seg16 directive. 
  30824.  
  30825.  
  30826. ΓòÉΓòÉΓòÉ 19.771. EDC3370 ΓòÉΓòÉΓòÉ
  30827.  
  30828. A template friend declaration may only declare, not define, a class or 
  30829. function. 
  30830.  
  30831. The class or function declared in the template friend declaration must be 
  30832. defined at file scope. 
  30833.  
  30834. Recovery: Remove the definition from the template friend declaration. 
  30835.  
  30836.  
  30837. ΓòÉΓòÉΓòÉ 19.772. EDC3371 ΓòÉΓòÉΓòÉ
  30838.  
  30839. The function "&1" must not be declared "&2" at block scope. 
  30840.  
  30841. There can be no static or inline function declarations at block scope. 
  30842.  
  30843. Recovery: Move the function so that it is not defined at block scope. 
  30844.  
  30845.  
  30846. ΓòÉΓòÉΓòÉ 19.773. EDC3372 ΓòÉΓòÉΓòÉ
  30847.  
  30848. The previous &1 messages apply to function argument &2. 
  30849.  
  30850. The previous messages apply to the specified argument number. 
  30851.  
  30852.  
  30853. ΓòÉΓòÉΓòÉ 19.774. EDC3373 ΓòÉΓòÉΓòÉ
  30854.  
  30855. The previous &1 messages apply to argument &2 of function "&3". 
  30856.  
  30857. The previous messages apply to the specified argument number. 
  30858.  
  30859.  
  30860. ΓòÉΓòÉΓòÉ 19.775. EDC3374 ΓòÉΓòÉΓòÉ
  30861.  
  30862. "&1" is not a static member of "&2". 
  30863.  
  30864. Non-static data members cannot be defined outside the class definition. 
  30865.  
  30866. Recovery: Make the member a static member or move it into the class definition. 
  30867.  
  30868.  
  30869. ΓòÉΓòÉΓòÉ 19.776. EDC3375 ΓòÉΓòÉΓòÉ
  30870.  
  30871. The initializer must be enclosed in braces. 
  30872.  
  30873. Array element initializers must be enclosed in braces. 
  30874.  
  30875. Recovery: Ensure braces enclose the initializer. 
  30876.  
  30877.  
  30878. ΓòÉΓòÉΓòÉ 19.777. EDC3376 ΓòÉΓòÉΓòÉ
  30879.  
  30880. union "&1" has multiple initializers associated with its constructor "&2". 
  30881.  
  30882. At most one of the union's member objects can be stored in at any time. 
  30883.  
  30884. Recovery: Remove all but one of the initializers. 
  30885.  
  30886.  
  30887. ΓòÉΓòÉΓòÉ 19.778. EDC3377 ΓòÉΓòÉΓòÉ
  30888.  
  30889. "&1" is declared on line &2 of "&3". 
  30890.  
  30891.  
  30892. ΓòÉΓòÉΓòÉ 19.779. EDC3378 ΓòÉΓòÉΓòÉ
  30893.  
  30894. "&1" is defined on line &2 of "&3". 
  30895.  
  30896.  
  30897. ΓòÉΓòÉΓòÉ 19.780. EDC3379 ΓòÉΓòÉΓòÉ
  30898.  
  30899. Maximum number of error messages exceeded. 
  30900.  
  30901. Recovery: Begin correcting the errors. 
  30902.  
  30903.  
  30904. ΓòÉΓòÉΓòÉ 19.781. EDC3380 ΓòÉΓòÉΓòÉ
  30905.  
  30906. Virtual function "&1" is not a valid override because "&3" is an ambiguous base 
  30907. class of "&2". 
  30908.  
  30909. The compiler must generate code to convert the actual return type into the type 
  30910. that the overridden function returns (so that calls to the original overridden 
  30911. function is supported).  Unfortunately, the conversion is ambiguous. 
  30912.  
  30913. Recovery: Clarify the base class. 
  30914.  
  30915.  
  30916. ΓòÉΓòÉΓòÉ 19.782. EDC3381 ΓòÉΓòÉΓòÉ
  30917.  
  30918. The operands have type "&1" and "&2". 
  30919.  
  30920.  
  30921. ΓòÉΓòÉΓòÉ 19.783. EDC3382 ΓòÉΓòÉΓòÉ
  30922.  
  30923. "&1" is defined in this compilation and cannot be imported. 
  30924.  
  30925. Only externally defined functions can be imported. 
  30926.  
  30927. Recovery: Remove the directive that imports the function. 
  30928.  
  30929.  
  30930. ΓòÉΓòÉΓòÉ 19.784. EDC3383 ΓòÉΓòÉΓòÉ
  30931.  
  30932. "&1" is not defined in this compilation and cannot be exported. 
  30933.  
  30934. Only functions defined in this compilation can be exported. 
  30935.  
  30936. Recovery: Remove the directive that exports the function. 
  30937.  
  30938.  
  30939. ΓòÉΓòÉΓòÉ 19.785. EDC3384 ΓòÉΓòÉΓòÉ
  30940.  
  30941. "&1" is already imported or exported.  Duplicate directive ignored. 
  30942.  
  30943. A function may be imported or exported at most once. 
  30944.  
  30945. Recovery: Remove one of the directives. 
  30946.  
  30947.  
  30948. ΓòÉΓòÉΓòÉ 19.786. EDC3385 ΓòÉΓòÉΓòÉ
  30949.  
  30950. Macro "&1" has been invoked with an incomplete argument for parameter "&2". 
  30951.  
  30952. The terminating "," or ")" for the argument was not found. 
  30953.  
  30954. Recovery: Ensure the terminating "," or ")" is in the argument. 
  30955.  
  30956.  
  30957. ΓòÉΓòÉΓòÉ 19.787. EDC3386 ΓòÉΓòÉΓòÉ
  30958.  
  30959. The enum cannot be packed to the requested size of &1. 
  30960.  
  30961. The enum type is too large to fit in the storage requested with the /Su option. 
  30962.  
  30963. Recovery: Redefine the storage to a larger size. 
  30964.  
  30965.  
  30966. ΓòÉΓòÉΓòÉ 19.788. EDC3387 ΓòÉΓòÉΓòÉ
  30967.  
  30968. "&1" is not initialized until after the base class is initialized. 
  30969.  
  30970. First, the base classes are initialized in declaration order, then the members 
  30971. are initialized in declaration order, then the body of the constructor is 
  30972. executed. 
  30973.  
  30974.  
  30975. ΓòÉΓòÉΓòÉ 19.789. EDC3388 ΓòÉΓòÉΓòÉ
  30976.  
  30977. The left hand side expression of the "&1" operator is a relational expression 
  30978. ("&2").  The "&3" operator may have been intended. 
  30979.  
  30980. Recovery: Ensure the proper operator is being used. 
  30981.  
  30982.  
  30983. ΓòÉΓòÉΓòÉ 19.790. EDC3389 ΓòÉΓòÉΓòÉ
  30984.  
  30985. The left hand side expression of the "&1" operator is a logical expression 
  30986. ("&2").  The "&3" operator may have been intended. 
  30987.  
  30988. Recovery: Ensure the proper operator is being used. 
  30989.  
  30990.  
  30991. ΓòÉΓòÉΓòÉ 19.791. EDC3390 ΓòÉΓòÉΓòÉ
  30992.  
  30993. The left hand side expression of the "&1" operator is an equality expression 
  30994. ("&2").  The "&3" operator may have been intended. 
  30995.  
  30996. Recovery: Ensure the proper operator is being used. 
  30997.  
  30998.  
  30999. ΓòÉΓòÉΓòÉ 19.792. EDC3391 ΓòÉΓòÉΓòÉ
  31000.  
  31001. The right hand side expression of the "&1" operator is a relational expression 
  31002. ("&2").  The "&3" operator may have been intended. 
  31003.  
  31004. Recovery: Ensure the proper operator is being used. 
  31005.  
  31006.  
  31007. ΓòÉΓòÉΓòÉ 19.793. EDC3392 ΓòÉΓòÉΓòÉ
  31008.  
  31009. The right hand side expression of the "&1" operator is a logical expression 
  31010. ("&2").  The "&3" operator may have been intended. 
  31011.  
  31012. Recovery: Ensure the proper operator is being used. 
  31013.  
  31014.  
  31015. ΓòÉΓòÉΓòÉ 19.794. EDC3393 ΓòÉΓòÉΓòÉ
  31016.  
  31017. The right hand side expression of the "&1" operator is an equality expression 
  31018. ("&2").  The "&3" operator may have been intended. 
  31019.  
  31020. Recovery: Ensure the proper operator is being used. 
  31021.  
  31022.  
  31023. ΓòÉΓòÉΓòÉ 19.795. EDC3394 ΓòÉΓòÉΓòÉ
  31024.  
  31025. Assignment to the "this" pointer is not allowed. 
  31026.  
  31027. The "this" pointer is a const pointer. 
  31028.  
  31029. Recovery: Remove the assignment to the "this" pointer. 
  31030.  
  31031.  
  31032. ΓòÉΓòÉΓòÉ 19.796. EDC3395 ΓòÉΓòÉΓòÉ
  31033.  
  31034. "&1" must not have any arguments. 
  31035.  
  31036. Recovery: Remove all arguments from the special member function. 
  31037.  
  31038.  
  31039. ΓòÉΓòÉΓòÉ 19.797. EDC3396 ΓòÉΓòÉΓòÉ
  31040.  
  31041. The second operand to the "offsetof" operator is not valid. 
  31042.  
  31043. The second operand to the "offsetof" operator must consist only of "." 
  31044. operators and "[]" operators with constant bounds. 
  31045.  
  31046. Recovery: Remove or change the second operand. 
  31047.  
  31048.  
  31049. ΓòÉΓòÉΓòÉ 19.798. EDC3397 ΓòÉΓòÉΓòÉ
  31050.  
  31051. "&1" is a member of "&2" and cannot be used without qualification. 
  31052.  
  31053. The specified name is a class member, but no class qualification has been used 
  31054. to reference it. 
  31055.  
  31056. Recovery: Use the scope operator (::) to qualify the name. 
  31057.  
  31058.  
  31059. ΓòÉΓòÉΓòÉ 19.799. EDC3398 ΓòÉΓòÉΓòÉ
  31060.  
  31061. "&1" is undefined.  Every variable of type "&2" will assume "&1" has no virtual 
  31062. bases and does not use multiple inheritance. 
  31063.  
  31064. The definition of the class is not given but the compiler must implement the 
  31065. pointer to member.  It will do so by assuming the class has at most one 
  31066. nonvirtual base class. 
  31067.  
  31068. Recovery: If this assumption is incorrect, define the class before declaring 
  31069. the member pointer. 
  31070.  
  31071.  
  31072. ΓòÉΓòÉΓòÉ 19.800. EDC3399 ΓòÉΓòÉΓòÉ
  31073.  
  31074. "&1" is undefined.  The delete operator will not call a destructor. 
  31075.  
  31076. The definition of the class is not given so the compiler does not know whether 
  31077. the class has a destructor.  No destructor call will be made. 
  31078.  
  31079. Recovery: Define the class. 
  31080.  
  31081.  
  31082. ΓòÉΓòÉΓòÉ 19.801. EDC3400 ΓòÉΓòÉΓòÉ
  31083.  
  31084. Label "&1" is undefined. 
  31085.  
  31086. The specified label is being used but is not defined. 
  31087.  
  31088. Recovery: Define the label before using it. 
  31089.  
  31090.  
  31091. ΓòÉΓòÉΓòÉ 19.802. EDC3401 ΓòÉΓòÉΓòÉ
  31092.  
  31093. The initializer for enumerator "&1" must be an integral constant expression. 
  31094.  
  31095. The value of an enumerator must be a constant expression that is promotable to 
  31096. a signed int value. 
  31097.  
  31098. Recovery: Change the initializer to an integral constant expression.  A 
  31099. constant expression has a value that can be determined during compilation and 
  31100. does not change during program execution. 
  31101.  
  31102.  
  31103. ΓòÉΓòÉΓòÉ 19.803. EDC3402 ΓòÉΓòÉΓòÉ
  31104.  
  31105. Static member template encountered - see Programming Guide for restrictions 
  31106.  
  31107. Templates for static data members are only partially supported, and may cause 
  31108. linker errors if they are overridden by explicit definitions, or if they occur 
  31109. in library objects. For more details, see the chapter on "Using Templates in 
  31110. C++ Programs" in the Programming Guide. 
  31111.  
  31112. Recovery: Ensure that you observe the restrictions listed in the Programming 
  31113. Guide. 
  31114.  
  31115.  
  31116. ΓòÉΓòÉΓòÉ 19.804. EDC3403 ΓòÉΓòÉΓòÉ
  31117.  
  31118. Overriding virtual function "&1" may not return "&2" because class &3 has 
  31119. multiple base classes or a virtual base class. 
  31120.  
  31121. Contravariant virtual functions are supported only for classes with single 
  31122. inheritance and no virtual bases. 
  31123.  
  31124. Recovery: Ensure the class has single inheritance and no virtual bases. 
  31125.  
  31126.  
  31127. ΓòÉΓòÉΓòÉ 19.805. EDC3404 ΓòÉΓòÉΓòÉ
  31128.  
  31129. Virtual function "&1" is not a valid override because "&3" is an inaccessible 
  31130. base class of "&2". 
  31131.  
  31132. The compiler must generate code to convert the actual return type into the type 
  31133. that the overridden function returns (so that calls to the original overridden 
  31134. function is supported).  Unfortunately, the target type is inaccessible to the 
  31135. overriding function. 
  31136.  
  31137. Recovery: Make the base class accessible. 
  31138.  
  31139.  
  31140. ΓòÉΓòÉΓòÉ 19.806. EDC3405 ΓòÉΓòÉΓòÉ
  31141.  
  31142. "&1" is a member of &2 classes.  To reference one of these members the member 
  31143. must be qualified. 
  31144.  
  31145. Recovery: Use the scope operator (::) to qualify the name. 
  31146.  
  31147.  
  31148. ΓòÉΓòÉΓòÉ 19.807. EDC3406 ΓòÉΓòÉΓòÉ
  31149.  
  31150. "&1" is a member of "&2". 
  31151.  
  31152.  
  31153. ΓòÉΓòÉΓòÉ 19.808. EDC3407 ΓòÉΓòÉΓòÉ
  31154.  
  31155. "&1" is not the name of a function. 
  31156.  
  31157. A function name is required in this context.  The specified name has been 
  31158. declared but it is not the name of a function. 
  31159.  
  31160. Recovery: Ensure the name is the correctly-spelled name of a function. 
  31161.  
  31162.  
  31163. ΓòÉΓòÉΓòÉ 19.809. EDC3408 ΓòÉΓòÉΓòÉ
  31164.  
  31165. Priority value in "#pragma priority" is in system reserved range. 
  31166.  
  31167. #pragma priority values less than -2147482624 are reserved for system purposes. 
  31168.  
  31169. Recovery: Change the #pragma priority value so that it is greater than 
  31170. -2147482624. 
  31171.  
  31172.  
  31173. ΓòÉΓòÉΓòÉ 19.810. EDC3409 ΓòÉΓòÉΓòÉ
  31174.  
  31175. Priority values in successive "#pragma priority" statements must increase. 
  31176.  
  31177. Recovery: Ensure priority values in successive "#pragma priority" statements 
  31178. increase. 
  31179.  
  31180.  
  31181. ΓòÉΓòÉΓòÉ 19.811. EDC3410 ΓòÉΓòÉΓòÉ
  31182.  
  31183. Initialization or termination done before first "#pragma priority" statement. 
  31184.  
  31185. Recovery: Ensure initialization or termination follows the first "#pragma 
  31186. priority" statement. 
  31187.  
  31188.  
  31189. ΓòÉΓòÉΓòÉ 19.812. EDC3417 ΓòÉΓòÉΓòÉ
  31190.  
  31191. Enum type "&1" cannot contain both negative and unsigned values. 
  31192.  
  31193. Recovery: Remove the negative or unsigned values. 
  31194.  
  31195.  
  31196. ΓòÉΓòÉΓòÉ 19.813. EDC3418 ΓòÉΓòÉΓòÉ
  31197.  
  31198. A conflicting #pragma alloc_text was previously supplied for function &1. 
  31199.  
  31200.  
  31201. ΓòÉΓòÉΓòÉ 19.814. EDC3419 ΓòÉΓòÉΓòÉ
  31202.  
  31203. Syntax error in directive - expected "&1" and found "&2". 
  31204.  
  31205. A syntax error was found during preprocessing.  The message identifies what the 
  31206. compiler expected and what it actually found. 
  31207.  
  31208. Recovery: Correct the syntax error. 
  31209.  
  31210.  
  31211. ΓòÉΓòÉΓòÉ 19.815. EDC3420 ΓòÉΓòÉΓòÉ
  31212.  
  31213. Ordinal value on #pragma import or export must be in range 0 to 65535. 
  31214.  
  31215. Recovery: Change the ordinal value so that it is within the range. 
  31216.  
  31217.  
  31218. ΓòÉΓòÉΓòÉ 19.816. EDC3422 ΓòÉΓòÉΓòÉ
  31219.  
  31220. Functions callable from 16-bit code may not have by-value aggregate parameters. 
  31221.  
  31222. Recovery: Remove the by-value aggregate parameters. 
  31223.  
  31224.  
  31225. ΓòÉΓòÉΓòÉ 19.817. EDC3423 ΓòÉΓòÉΓòÉ
  31226.  
  31227. Functions callable from 16-bit code may not return an aggregate by value. 
  31228.  
  31229. Recovery: Remove the return of an aggregate by value. 
  31230.  
  31231.  
  31232. ΓòÉΓòÉΓòÉ 19.818. EDC3427 ΓòÉΓòÉΓòÉ
  31233.  
  31234. Address of the machine coded function "&1" can not be taken. 
  31235.  
  31236.  
  31237. ΓòÉΓòÉΓòÉ 19.819. EDC3431 ΓòÉΓòÉΓòÉ
  31238.  
  31239. Invalid pragma name "&1" ignored. 
  31240.  
  31241. Recovery: Remove the invalid pragma name. 
  31242.  
  31243.  
  31244. ΓòÉΓòÉΓòÉ 19.820. EDC3432 ΓòÉΓòÉΓòÉ
  31245.  
  31246. Illegal character "&1" found in macro name "&2". 
  31247.  
  31248. An illegal character is found in the macro specified 
  31249.  
  31250. Recovery: Remove the illegal character from the macro. 
  31251.  
  31252.  
  31253. ΓòÉΓòÉΓòÉ 19.821. EDC3433 ΓòÉΓòÉΓòÉ
  31254.  
  31255. An initializer is not allowed for the nonvirtual function "&1". 
  31256.  
  31257. The declaration of a pure virtual function must include the keyword virtual. 
  31258.  
  31259. Recovery: Remove the initializer. 
  31260.  
  31261.  
  31262. ΓòÉΓòÉΓòÉ 19.822. EDC3458 ΓòÉΓòÉΓòÉ
  31263.  
  31264. Template class matches more than one #pragma pack. 
  31265.  
  31266. Recovery: Ensure the template class matches only one #pragma pack. 
  31267.  
  31268.  
  31269. ΓòÉΓòÉΓòÉ 19.823. EDC3474 ΓòÉΓòÉΓòÉ
  31270.  
  31271. Argument to va_start must be a parameter name. 
  31272.  
  31273. Recovery: Ensure argument to va_start is a parameter name. 
  31274.  
  31275.  
  31276. ΓòÉΓòÉΓòÉ 19.824. EDC3475 ΓòÉΓòÉΓòÉ
  31277.  
  31278. A local variable or compiler temporary is being used to initialize reference 
  31279. member "&1". 
  31280.  
  31281. The local variable is only alive until the end of the function, but it is being 
  31282. used to initialize a member reference variable. 
  31283.  
  31284. Recovery: Ensure that no part of your program depends on the variable or 
  31285. temporary. 
  31286.  
  31287.  
  31288. ΓòÉΓòÉΓòÉ 19.825. EDC3476 ΓòÉΓòÉΓòÉ
  31289.  
  31290. Compilation aborted by user or by the operating system. 
  31291.  
  31292. The user pressed Ctrl-C or the operating system killed the process. Possible 
  31293. cause: swap space is exhausted 
  31294.  
  31295.  
  31296. ΓòÉΓòÉΓòÉ 19.826. EDC4004 ΓòÉΓòÉΓòÉ
  31297.  
  31298. Not enough memory is available. 
  31299.  
  31300. The compiler can not obtain the necessary virtual storage or memory. 
  31301.  
  31302. Recovery: Any of the following may help: 
  31303.  
  31304. o Shut down large processes. 
  31305. o Ensure your swap path is large enough. 
  31306. o Redefine your virtual disk, if you are using one. 
  31307. o Reboot. 
  31308. o Obtain more RAM and/or disk space. 
  31309.  
  31310.  
  31311. ΓòÉΓòÉΓòÉ 19.827. EDC4005 ΓòÉΓòÉΓòÉ
  31312.  
  31313. Error occurred in an intermediate file. 
  31314.  
  31315. An internal compiler error has occurred. 
  31316.  
  31317. Recovery: Contact your IBM Service Representative. 
  31318.  
  31319.  
  31320. ΓòÉΓòÉΓòÉ 19.828. EDC4006 ΓòÉΓòÉΓòÉ
  31321.  
  31322. An addressing mode combination is not valid. 
  31323.  
  31324. An internal compiler error has occurred. 
  31325.  
  31326. Recovery: Contact your IBM Service Representative. 
  31327.  
  31328.  
  31329. ΓòÉΓòÉΓòÉ 19.829. EDC4008 ΓòÉΓòÉΓòÉ
  31330.  
  31331. An unsupported data type was encountered. 
  31332.  
  31333. An internal compiler error has occurred. 
  31334.  
  31335. Recovery: Contact your IBM Service Representative. 
  31336.  
  31337.  
  31338. ΓòÉΓòÉΓòÉ 19.830. EDC4010 ΓòÉΓòÉΓòÉ
  31339.  
  31340. An unexpected dependent register was encountered. 
  31341.  
  31342. An internal compiler error has occurred. 
  31343.  
  31344. Recovery: Contact your IBM Service Representative. 
  31345.  
  31346.  
  31347. ΓòÉΓòÉΓòÉ 19.831. EDC4011 ΓòÉΓòÉΓòÉ
  31348.  
  31349. Error occurred while opening assembly file. 
  31350.  
  31351. An operating system or compiler error has occurred. 
  31352.  
  31353. Recovery: Ensure that: 
  31354.  
  31355. o The TMP directory is set to a writable disk 
  31356. o The target directory of the assembler or object file is writable 
  31357. o These directories exist and have enough available space 
  31358. o No other processes are modifying the directory or file 
  31359. o The file system is functioning properly 
  31360. o The virtual disk for the directory, if you are using one, is large enough. 
  31361. Try rebooting.  If the problem persists, contact your IBM Service 
  31362. Representative. 
  31363.  
  31364.  
  31365. ΓòÉΓòÉΓòÉ 19.832. EDC4012 ΓòÉΓòÉΓòÉ
  31366.  
  31367. Error occurred while writing assembly file. 
  31368.  
  31369. An operating system or compiler error has occurred. 
  31370.  
  31371. Recovery: Ensure that: 
  31372.  
  31373. o The TMP directory is set to a writable disk 
  31374. o The target directory of the assembler or object file is writable 
  31375. o These directories exist and have enough available space 
  31376. o No other processes are modifying the directory or file 
  31377. o The file system is functioning properly 
  31378. o The virtual disk for the directory, if you are using one, is large enough. 
  31379. Try rebooting.  If the problem persists, contact your IBM Service 
  31380. Representative. 
  31381.  
  31382.  
  31383. ΓòÉΓòÉΓòÉ 19.833. EDC4013 ΓòÉΓòÉΓòÉ
  31384.  
  31385. Error occurred while closing assembly file. 
  31386.  
  31387. An operating system or compiler error has occurred. 
  31388.  
  31389. Recovery: Ensure that: 
  31390.  
  31391. o The TMP directory is set to a writable disk 
  31392. o The target directory of the assembler or object file is writable 
  31393. o These directories exist and have enough available space 
  31394. o No other processes are modifying the directory or file 
  31395. o The file system is functioning properly 
  31396. o The virtual disk for the directory, if you are using one, is large enough. 
  31397. Try rebooting.  If the problem persists, contact your IBM Service 
  31398. Representative. 
  31399.  
  31400.  
  31401. ΓòÉΓòÉΓòÉ 19.834. EDC4014 ΓòÉΓòÉΓòÉ
  31402.  
  31403. Error occurred while opening object file. 
  31404.  
  31405. An operating system or compiler error has occurred. 
  31406.  
  31407. Recovery: Ensure that: 
  31408.  
  31409. o The TMP directory is set to a writable disk 
  31410. o The target directory of the assembler or object file is writable 
  31411. o These directories exist and have enough available space 
  31412. o No other processes are modifying the directory or file 
  31413. o The file system is functioning properly 
  31414. o The virtual disk for the directory, if you are using one, is large enough. 
  31415. Try rebooting.  If the problem persists, contact your IBM Service 
  31416. Representative. 
  31417.  
  31418.  
  31419. ΓòÉΓòÉΓòÉ 19.835. EDC4015 ΓòÉΓòÉΓòÉ
  31420.  
  31421. Error occurred while in writing object file. 
  31422.  
  31423. An operating system or compiler error has occurred. 
  31424.  
  31425. Recovery: Ensure that: 
  31426.  
  31427. o The TMP directory is set to a writable disk 
  31428. o The target directory of the assembler or object file is writable 
  31429. o These directories exist and have enough available space 
  31430. o No other processes are modifying the directory or file 
  31431. o The file system is functioning properly 
  31432. o The virtual disk for the directory, if you are using one, is large enough. 
  31433. Try rebooting.  If the problem persists, contact your IBM Service 
  31434. Representative. 
  31435.  
  31436.  
  31437. ΓòÉΓòÉΓòÉ 19.836. EDC4016 ΓòÉΓòÉΓòÉ
  31438.  
  31439. Error occurred while closing object file. 
  31440.  
  31441. An operating system or compiler error has occurred. 
  31442.  
  31443. Recovery: Ensure that: 
  31444.  
  31445. o The TMP directory is set to a writable disk 
  31446. o The target directory of the assembler or object file is writable 
  31447. o These directories exist and have enough available space 
  31448. o No other processes are modifying the directory or file 
  31449. o The file system is functioning properly 
  31450. o The virtual disk for the directory, if you are using one, is large enough. 
  31451. Try rebooting.  If the problem persists, contact your IBM Service 
  31452. Representative. 
  31453.  
  31454.  
  31455. ΓòÉΓòÉΓòÉ 19.837. EDC4017 ΓòÉΓòÉΓòÉ
  31456.  
  31457. Expression contains division by zero. 
  31458.  
  31459. The optimizer identified an expression containing division by zero. 
  31460.  
  31461. Recovery: Eliminate the division by zero if it was not intended. 
  31462.  
  31463.  
  31464. ΓòÉΓòÉΓòÉ 19.838. EDC4018 ΓòÉΓòÉΓòÉ
  31465.  
  31466. Too many debug options were specified. 
  31467.  
  31468. An internal compiler error has occurred. 
  31469.  
  31470. Recovery: Contact your IBM Service Representative. 
  31471.  
  31472.  
  31473. ΓòÉΓòÉΓòÉ 19.839. EDC4019 ΓòÉΓòÉΓòÉ
  31474.  
  31475. Error occurred while opening intermediate file. 
  31476.  
  31477. An operating system or compiler error has occurred. 
  31478.  
  31479. Recovery: Ensure that: 
  31480.  
  31481. o The TMP directory is set to a writable disk 
  31482. o The directory exists and has enough available space 
  31483. o No other processes are modifying the directory or file 
  31484. o The file system is functioning properly 
  31485. o The virtual disk for the directory, if you are using one, is large enough. 
  31486. Try rebooting.  If the problem persists, contact your IBM Service 
  31487. Representative. 
  31488.  
  31489.  
  31490. ΓòÉΓòÉΓòÉ 19.840. EDC4020 ΓòÉΓòÉΓòÉ
  31491.  
  31492. Error occurred while writing to intermediate file. 
  31493.  
  31494. An operating system or compiler error has occurred. 
  31495.  
  31496. Recovery: Ensure that: 
  31497.  
  31498. o The TMP directory is set to a writable disk 
  31499. o The directory exists and has enough available space 
  31500. o No other processes are modifying the directory or file 
  31501. o The file system is functioning properly 
  31502. o The virtual disk for the directory, if you are using one, is large enough. 
  31503. Try rebooting.  If the problem persists, contact your IBM Service 
  31504. Representative. 
  31505.  
  31506.  
  31507. ΓòÉΓòÉΓòÉ 19.841. EDC4021 ΓòÉΓòÉΓòÉ
  31508.  
  31509. Error occurred while reading from intermediate file. 
  31510.  
  31511. An operating system or compiler error has occurred. 
  31512.  
  31513. Recovery: Ensure that: 
  31514.  
  31515. o The TMP directory is set to a writable disk 
  31516. o The directory exists and has enough available space 
  31517. o No other processes are modifying the directory or file 
  31518. o The file system is functioning properly 
  31519. o The virtual disk for the directory, if you are using one, is large enough. 
  31520. Try rebooting.  If the problem persists, contact your IBM Service 
  31521. Representative. 
  31522.  
  31523.  
  31524. ΓòÉΓòÉΓòÉ 19.842. EDC4022 ΓòÉΓòÉΓòÉ
  31525.  
  31526. Error occurred while closing intermediate file. 
  31527.  
  31528. An operating system or compiler error has occurred. 
  31529.  
  31530. Recovery: Ensure that: 
  31531.  
  31532. o The TMP directory is set to a writable disk 
  31533. o The directory exists and has enough available space 
  31534. o No other processes are modifying the directory or file 
  31535. o The file system is functioning properly 
  31536. o The virtual disk for the directory, if you are using one, is large enough. 
  31537. Try rebooting.  If the problem persists, contact your IBM Service 
  31538. Representative. 
  31539.  
  31540.  
  31541. ΓòÉΓòÉΓòÉ 19.843. EDC4023 ΓòÉΓòÉΓòÉ
  31542.  
  31543. Error occurred while creating name. 
  31544.  
  31545. An internal compiler error has occurred. 
  31546.  
  31547. Recovery: Contact your IBM Service Representative. 
  31548.  
  31549.  
  31550. ΓòÉΓòÉΓòÉ 19.844. EDC4024 ΓòÉΓòÉΓòÉ
  31551.  
  31552. Expression contains modulo by zero. 
  31553.  
  31554. The optimizer identified an expression containing modulo by zero. 
  31555.  
  31556. Recovery: Eliminate the modulo by zero if it was not intended. 
  31557.  
  31558.  
  31559. ΓòÉΓòÉΓòÉ 19.845. EDC4026 ΓòÉΓòÉΓòÉ
  31560.  
  31561. Data definitions require more 16-bit segments than are allowed. 
  31562.  
  31563. The data declared requires more 16-bit segments than the maximum 242 available. 
  31564.  
  31565. Recovery: Break the program down into several smaller programs, or use less 
  31566. data. 
  31567.  
  31568.  
  31569. ΓòÉΓòÉΓòÉ 19.846. EDC4027 ΓòÉΓòÉΓòÉ
  31570.  
  31571. The text associated with a #pragma comment user is too long. 
  31572.  
  31573. The text of the #pragma comment user directive exceeds the limit of 255 
  31574. characters. 
  31575.  
  31576. Recovery: Shorten the text of the comment, or use multiple #pragma comment user 
  31577. directives. 
  31578.  
  31579.  
  31580. ΓòÉΓòÉΓòÉ 19.847. EDC4028 ΓòÉΓòÉΓòÉ
  31581.  
  31582. The path or file name for output file &2 is not valid. 
  31583.  
  31584. The path or file name given has not been specified correctly. 
  31585.  
  31586. Recovery: Check the spelling and syntax of the path or file name and change the 
  31587. name accordingly. 
  31588.  
  31589.  
  31590. ΓòÉΓòÉΓòÉ 19.848. EDC4029 ΓòÉΓòÉΓòÉ
  31591.  
  31592. Open access denied for output file &2. 
  31593.  
  31594. The file system will not allow the specified file to be opened. You may be 
  31595. trying to write to a readonly disk. 
  31596.  
  31597. Recovery: Direct output to a writable disk. 
  31598.  
  31599.  
  31600. ΓòÉΓòÉΓòÉ 19.849. EDC4030 ΓòÉΓòÉΓòÉ
  31601.  
  31602. Cannot open output file &2. 
  31603.  
  31604. An operating system or compiler error has occurred. 
  31605.  
  31606. Recovery: See the Recovery for message EDC4014. 
  31607.  
  31608.  
  31609. ΓòÉΓòÉΓòÉ 19.850. EDC4031 ΓòÉΓòÉΓòÉ
  31610.  
  31611. Cannot open output file &2. The file is already open. 
  31612.  
  31613. Another process has already opened the file. 
  31614.  
  31615. Recovery: Close the file and compile again. 
  31616.  
  31617.  
  31618. ΓòÉΓòÉΓòÉ 19.851. EDC4032 ΓòÉΓòÉΓòÉ
  31619.  
  31620. Cannot write to the output file. The disk is full. 
  31621.  
  31622. Recovery: Delete some files to make some space on the disk. 
  31623.  
  31624.  
  31625. ΓòÉΓòÉΓòÉ 19.852. EDC4033 ΓòÉΓòÉΓòÉ
  31626.  
  31627. Precondition violated. 
  31628.  
  31629. An internal compiler error has occurred. 
  31630.  
  31631. Recovery: See your IBM Service Representative. 
  31632.  
  31633.  
  31634. ΓòÉΓòÉΓòÉ 19.853. EDC4034 ΓòÉΓòÉΓòÉ
  31635.  
  31636. The command line passed to the Back End is not correct. 
  31637.  
  31638. An internal compiler error has occurred. 
  31639.  
  31640. Recovery: Contact your IBM Service Representative. 
  31641.  
  31642.  
  31643. ΓòÉΓòÉΓòÉ 19.854. EDC4035 ΓòÉΓòÉΓòÉ
  31644.  
  31645. Error occurred while opening source file. 
  31646.  
  31647. An operating system or compiler error has occurred. 
  31648.  
  31649. Recovery: Ensure that: 
  31650.  
  31651. o No other processes are modifying the directory or file 
  31652. o The virtual disk for the directory, if you are using one, is large enough. 
  31653. Try rebooting.  If the problem persists, contact your IBM Service 
  31654. Representative. 
  31655.  
  31656.  
  31657. ΓòÉΓòÉΓòÉ 19.855. EDC4036 ΓòÉΓòÉΓòÉ
  31658.  
  31659. The path or file name for source file &2 is not valid. 
  31660.  
  31661. The path or file name given has not been specified correctly. 
  31662.  
  31663. Recovery: Check the spelling and syntax of the path or file name and change the 
  31664. name accordingly. 
  31665.  
  31666.  
  31667. ΓòÉΓòÉΓòÉ 19.856. EDC4037 ΓòÉΓòÉΓòÉ
  31668.  
  31669. Open access denied for source file &2. 
  31670.  
  31671. The file system will not allow the specified file to be opened. because of an 
  31672. OS/2 file system error. Recovery: Try rebooting.  If the problem persists, 
  31673. contact your IBM Service Representative. 
  31674.  
  31675.  
  31676. ΓòÉΓòÉΓòÉ 19.857. EDC4038 ΓòÉΓòÉΓòÉ
  31677.  
  31678. Cannot open source file &2. 
  31679.  
  31680. An operating system or compiler error has occurred. 
  31681.  
  31682. Recovery: See the Recovery for message EDC4035. 
  31683.  
  31684.  
  31685. ΓòÉΓòÉΓòÉ 19.858. EDC4039 ΓòÉΓòÉΓòÉ
  31686.  
  31687. Cannot open source file &2. The file is already open. 
  31688.  
  31689. Another process has already opened the file. 
  31690.  
  31691. Recovery: Close the file and compile again. 
  31692.  
  31693.  
  31694. ΓòÉΓòÉΓòÉ 19.859. EDC4040 ΓòÉΓòÉΓòÉ
  31695.  
  31696. Assembler listing line is too long for successful assembly. 
  31697.  
  31698. The line in the assembler listing is too long to be assembled. 
  31699.  
  31700. Recovery: Try using shorter variable and function names. 
  31701.  
  31702.  
  31703. ΓòÉΓòÉΓòÉ 19.860. EDC4041 ΓòÉΓòÉΓòÉ
  31704.  
  31705. Error occurred while closing source file. 
  31706.  
  31707. An operating system or compiler error has occurred. 
  31708.  
  31709. Recovery: See the Recovery for message EDC4035. 
  31710.  
  31711.  
  31712. ΓòÉΓòÉΓòÉ 19.861. EDC4042 ΓòÉΓòÉΓòÉ
  31713.  
  31714. Cannot use __parmdwords in a non SYSTEM linkage function. 
  31715.  
  31716. The __parmdwords function can only be called from a function that uses _System 
  31717. linkage. 
  31718.  
  31719. Recovery: Change the linkage type of the function using the /Ms compiler option 
  31720. or the _System keyword, or remove the call to __parmdwords. 
  31721.  
  31722.  
  31723. ΓòÉΓòÉΓòÉ 19.862. EDC4043 ΓòÉΓòÉΓòÉ
  31724.  
  31725. Automatic function inliner will inline function &2. 
  31726.  
  31727. The /Oi+ option controls the inlining of user functions. When selected, all 
  31728. functions qualified by _Inline or inline become the default. 
  31729.  
  31730. Recovery: Informative message only. 
  31731.  
  31732.  
  31733. ΓòÉΓòÉΓòÉ 19.863. EDC6004 ΓòÉΓòÉΓòÉ
  31734.  
  31735. Not enough memory available. 
  31736.  
  31737. The compiler can not obtain the necessary virtual storage or memory. 
  31738.  
  31739. Recovery: Any of the following may help: 
  31740.  
  31741. o Shut down large processes. 
  31742. o Ensure your swap path is large enough. 
  31743. o Redefine your virtual disk, if you are using one. 
  31744. o Reboot. 
  31745. o Obtain more RAM and/or disk space. 
  31746.  
  31747.  
  31748. ΓòÉΓòÉΓòÉ 19.864. EDC6005 ΓòÉΓòÉΓòÉ
  31749.  
  31750. Error occurred in intermediate file. 
  31751.  
  31752. An internal compiler error has occurred. 
  31753.  
  31754. Recovery: Contact your IBM Service Representative. 
  31755.  
  31756.  
  31757. ΓòÉΓòÉΓòÉ 19.865. EDC6006 ΓòÉΓòÉΓòÉ
  31758.  
  31759. A type mismatch was found between declarations of symbol &2 in files &3 and &4. 
  31760.  
  31761. At least one different symbol was found in the source files for a common 
  31762. identifier.  All symbols for identifiers must match. 
  31763.  
  31764. Recovery: Change the code so that all common identifiers have matching symbols, 
  31765. and recompile. 
  31766.  
  31767.  
  31768. ΓòÉΓòÉΓòÉ 19.866. EDC6007 ΓòÉΓòÉΓòÉ
  31769.  
  31770. An illegal redefinition of symbol &2 defined in file &3 occurred in file &4. 
  31771.  
  31772. At least one different symbol definition was found in the source files.  All 
  31773. common symbol definitions must match. 
  31774.  
  31775. Recovery: Remove the redefinition so that all symbols have identical 
  31776. definitions, and recompile. 
  31777.  
  31778.  
  31779. ΓòÉΓòÉΓòÉ 19.867. EDC6008 ΓòÉΓòÉΓòÉ
  31780.  
  31781. The value of the /R option must be consistent across source files. 
  31782.  
  31783. Some source files were compiled with different /R options.  Only one option 
  31784. must be specified, either the /Re (runtime library) option or the /Rn 
  31785. (subsystem library). 
  31786.  
  31787. Recovery: Change the code so all files have the same /R option, and recompile. 
  31788.  
  31789.  
  31790. ΓòÉΓòÉΓòÉ 19.868. EDC6009 ΓòÉΓòÉΓòÉ
  31791.  
  31792. The value of the /G3, /G4, /G5 options must be consistent across source files. 
  31793.  
  31794. The source files were compiled for different target processors.  All source 
  31795. files specified at one time must point to the same processor. 
  31796.  
  31797. Recovery: Change the code so all files point to the same processor, and 
  31798. recompile. 
  31799.  
  31800.  
  31801. ΓòÉΓòÉΓòÉ 19.869. EDC6010 ΓòÉΓòÉΓòÉ
  31802.  
  31803. The value of the &2 option must be consistent across source files. 
  31804.  
  31805. The source files were compiled with different versions of the option specified. 
  31806. They must all use the same version of the option. 
  31807.  
  31808. Recovery: Change the code so all the files specify the same version of the 
  31809. option, and recompile. 
  31810.  
  31811.  
  31812. ΓòÉΓòÉΓòÉ 19.870. EDC6011 ΓòÉΓòÉΓòÉ
  31813.  
  31814. The value of the /O option must be consistent across source files. 
  31815.  
  31816. Some source files were compiled with different /O options.  Only one option 
  31817. must be specified in all source files. 
  31818.  
  31819. Recovery: Change the code so that the source files have the same option, and 
  31820. recompile. 
  31821.  
  31822.  
  31823. ΓòÉΓòÉΓòÉ 19.871. EDC6012 ΓòÉΓòÉΓòÉ
  31824.  
  31825. A second #pragma entry was detected in file &2. 
  31826.  
  31827. #pragma entry sets the entry point for the application, and there can never be 
  31828. more than one entry point to an application. 
  31829.  
  31830. Recovery: Remove the second #pragma entry from the file, and recompile. 
  31831.  
  31832.  
  31833. ΓòÉΓòÉΓòÉ 19.872. EDC6013 ΓòÉΓòÉΓòÉ
  31834.  
  31835. The declarations of functions &2 in file &3 and file &4 have inconsistent 
  31836. linkages. 
  31837.  
  31838. The function declarations are not consistent from file to file. 
  31839.  
  31840. Recovery: Change the code so that all the source files have the exact same 
  31841. function declarations, and recompile. 
  31842.  
  31843.  
  31844. ΓòÉΓòÉΓòÉ 19.873. EDC6014 ΓòÉΓòÉΓòÉ
  31845.  
  31846. The declarations of functions &2 in file &3 and file &4 have inconsistent 
  31847. numbers of parameters. 
  31848.  
  31849. The function declarations are not consistent from file to file. 
  31850.  
  31851. Recovery: Change the code so that all the source files have the exact same 
  31852. function declarations, and recompile. 
  31853.  
  31854.  
  31855. ΓòÉΓòÉΓòÉ 19.874. EDC6015 ΓòÉΓòÉΓòÉ
  31856.  
  31857. The declarations of functions &2 in file &3 and file &4 have inconsistent 
  31858. variable argument properties. 
  31859.  
  31860. The function declarations are not consistent from file to file. 
  31861.  
  31862. Recovery: Change the code so that all the source files have the exact same 
  31863. function declarations, and recompile. 
  31864.  
  31865.  
  31866. ΓòÉΓòÉΓòÉ 19.875. EDC6016 ΓòÉΓòÉΓòÉ
  31867.  
  31868. The command line passed to the Intermediate Code Linker is not correct. 
  31869.  
  31870. An internal compiler error has occurred. 
  31871.  
  31872. Recovery: Contact your local IBM Service Representative. 
  31873.  
  31874.  
  31875. ΓòÉΓòÉΓòÉ 19.876. EDC6017 ΓòÉΓòÉΓòÉ
  31876.  
  31877. Unknown error. 
  31878.  
  31879. An error has occurred which is beyond the recognition of the compiler. 
  31880.  
  31881. Recovery: Contact your local IBM Service Representative. 
  31882.  
  31883.  
  31884. ΓòÉΓòÉΓòÉ 19.877. EDC6018 ΓòÉΓòÉΓòÉ
  31885.  
  31886. Error in .def file &1. 
  31887.  
  31888. While the intermediate linker was parsing the .def file an error was found. 
  31889.  
  31890. Recovery: Check the .def file and correct the error. 
  31891.  
  31892.  
  31893. ΓòÉΓòÉΓòÉ 19.878. EDC6019 ΓòÉΓòÉΓòÉ
  31894.  
  31895. Error occurred while opening intermediate file. 
  31896.  
  31897. An operating system or compiler error has occurred. 
  31898.  
  31899. Recovery: Ensure that: 
  31900.  
  31901. o The TMP directory is set to a writable disk 
  31902. o The directory exists and has enough available space 
  31903. o No other processes are modifying the directory or file 
  31904. o The file system is functioning properly 
  31905. o The virtual disk for the directory, if you are using one, is large enough. 
  31906. Try rebooting.  If the problem persists, contact your IBM Service 
  31907. Representative. 
  31908.  
  31909.  
  31910. ΓòÉΓòÉΓòÉ 19.879. EDC6020 ΓòÉΓòÉΓòÉ
  31911.  
  31912. Error occurred while writing to the intermediate file. 
  31913.  
  31914. An operating system or compiler error has occurred. 
  31915.  
  31916. Recovery: See the Recovery for message EDC6019. 
  31917.  
  31918.  
  31919. ΓòÉΓòÉΓòÉ 19.880. EDC6021 ΓòÉΓòÉΓòÉ
  31920.  
  31921. Error occurred while reading from the intermediate file. 
  31922.  
  31923. An operating system or compiler error has occurred. 
  31924.  
  31925. Recovery: See the Recovery for message EDC6019. 
  31926.  
  31927.  
  31928. ΓòÉΓòÉΓòÉ 19.881. EDC6022 ΓòÉΓòÉΓòÉ
  31929.  
  31930. An operating system or compiler error has occurred. 
  31931.  
  31932. Recovery: See the Recovery for message EDC6019. 
  31933.  
  31934.  
  31935. ΓòÉΓòÉΓòÉ 19.882. EDC6023 ΓòÉΓòÉΓòÉ
  31936.  
  31937. Error occurred while creating name. 
  31938.  
  31939. An internal compiler error has occurred. 
  31940.  
  31941. Recovery: Contact your local IBM Service Representative. 
  31942.  
  31943.  
  31944. ΓòÉΓòÉΓòÉ 19.883. EDC6024 ΓòÉΓòÉΓòÉ
  31945.  
  31946. Source files containing conflicting debug language indicators were linked, 
  31947. debugging may be restricted. 
  31948.  
  31949. The debug language environment was set to handle the language of the last file 
  31950. processed.  If that language was not C++, then debugging of the program will be 
  31951. restricted. p.Recovery: 
  31952.  
  31953.  
  31954. ΓòÉΓòÉΓòÉ 20. Runtime Messages and Return Codes ΓòÉΓòÉΓòÉ
  31955.  
  31956. This section contains information about the runtime messages and should not be 
  31957. used as programming interface information. 
  31958.  
  31959. The value of the return code from a runtime error is set in one of the 
  31960. following ways: 
  31961.  
  31962. o By the initialization or termination routines of the C/C++ Tools runtime 
  31963.   library or by the program management routines 
  31964. o By the return statement in your main program 
  31965. o By calling the exit, _exit, or abort functions from your C program. 
  31966. o By calling the DosExit API. 
  31967.  
  31968. It is possible to pass a return code from a C or C++ program to the program 
  31969. that invoked it.  For example, if the program is invoked by the operating 
  31970. system, a return code can be passed either for examination in a subsequent 
  31971. program, if running of that program is conditional upon the value of the code 
  31972. returned, or merely to indicate conditions that were encountered during 
  31973. running. 
  31974.  
  31975. The return code generated by a C/C++ Tools program can be expected to be within 
  31976. the valid range of the int type. The range of values may be smaller if the 
  31977. return code is checked inside a batch .CMD file. See the OS/2 2.0 documentation 
  31978. for the acceptable range of return codes. 
  31979.  
  31980. Unless an error is detected that prevents the program management functions of 
  31981. the C/C++ Tools from operating correctly, the return code is always returned to 
  31982. the caller of the program. 
  31983.  
  31984. If your program did not specify a value for the return code either by an 
  31985. explicit return statement or by an exit statement, the return value is 
  31986. undefined. 
  31987.  
  31988. Related Information 
  31989.  
  31990. o Runtime Messages 
  31991. o return 
  31992. o abort - Stop a Program 
  31993. o exit - End Program 
  31994. o _exit - End Program 
  31995.  
  31996.  
  31997. ΓòÉΓòÉΓòÉ 20.1. Runtime Messages ΓòÉΓòÉΓòÉ
  31998.  
  31999. These are messages you see while your C/C++ Tools program is running. Runtime 
  32000. messages are produced in one of three ways: 
  32001.  
  32002. o Through a call to the perror or strerror function 
  32003. o In a machine-state dump when the exception handler terminates a program 
  32004. o Through a call to a debug memory management function. 
  32005.  
  32006. In extreme circumstances, when a runtime library function fails, an INTERNAL 
  32007. LIBRARY ERROR message is displayed along with the name of the library function 
  32008. that has failed. Make sure you have correctly installed the compiler. If the 
  32009. problem persists, contact your IBM service representative. 
  32010.  
  32011. The panels following this one list the error messages associated with errno 
  32012. values, in the format shown below. You can use the perror and strerror library 
  32013. functions to print these messages.  The errno value does not prefix the 
  32014. message. Not all error messages are associated with an errno value. 
  32015.  
  32016. Note:  While the integer value of errno is not to be used as programming 
  32017. interface information, you can use the macro values defined in <errno.h> as a 
  32018. programming interface. 
  32019.  
  32020. Message Format:     EDCnnnn : text 
  32021.  
  32022.   where:
  32023.  
  32024.            nnnn - error message number
  32025.            text - message text, which may contain substitution
  32026.               text indicated by &n
  32027.  
  32028. Related Information 
  32029.  
  32030. o perror - Print Error Message 
  32031. o strerror - Set Pointer to Runtime Error Message 
  32032. o errno.h 
  32033. o Runtime Messages and Return Codes 
  32034.  
  32035.  
  32036. ΓòÉΓòÉΓòÉ 20.2. EDC5000 ΓòÉΓòÉΓòÉ
  32037.  
  32038. Errno is 0. 
  32039.  
  32040. No error occurred. 
  32041.  
  32042.  
  32043. ΓòÉΓòÉΓòÉ 20.3. EDC5001 ΓòÉΓòÉΓòÉ
  32044.  
  32045. Domain error. 
  32046.  
  32047. errno Value: EDOM 
  32048.  
  32049. A parameter used is beyond the allowable domain of the function. 
  32050.  
  32051. Recovery: Check the domain of the function and change the parameter. 
  32052.  
  32053.  
  32054. ΓòÉΓòÉΓòÉ 20.4. EDC5002 ΓòÉΓòÉΓòÉ
  32055.  
  32056. Range error. 
  32057.  
  32058. errno Value: ERANGE 
  32059.  
  32060. The value computed is outside the allowable range of the function. 
  32061.  
  32062. Recovery: Check the range of the function and ensure your values work within 
  32063. it. 
  32064.  
  32065.  
  32066. ΓòÉΓòÉΓòÉ 20.5. EDC5003 ΓòÉΓòÉΓòÉ
  32067.  
  32068. The mode type parameter is not correct. 
  32069.  
  32070. errno Value: EBADMODE 
  32071.  
  32072. Recovery: Change the parameter to a valid mode type. 
  32073.  
  32074.  
  32075. ΓòÉΓòÉΓòÉ 20.6. EDC5004 ΓòÉΓòÉΓòÉ
  32076.  
  32077. The file name is "", a null pointer, or an invalid DDNAME. 
  32078.  
  32079. errno Value: EBADNAME 
  32080.  
  32081. The file name or DDNAME was not specified correctly. 
  32082.  
  32083. Recovery: Use the correct file name or DDNAME. 
  32084.  
  32085.  
  32086. ΓòÉΓòÉΓòÉ 20.7. EDC5005 ΓòÉΓòÉΓòÉ
  32087.  
  32088. Temporary memory files cannot be reopened. 
  32089.  
  32090. errno Value: EISTEMPMEM 
  32091.  
  32092. Recovery: Use a normal memory file or a temporary disk file. 
  32093.  
  32094.  
  32095. ΓòÉΓòÉΓòÉ 20.8. EDC5006 ΓòÉΓòÉΓòÉ
  32096.  
  32097. The file sharing mode specified is not correct. 
  32098.  
  32099. errno Value: EBADSHARE 
  32100.  
  32101. Valid sharing modes are NONE, ALL, and READ. 
  32102.  
  32103. Recovery: Specify a valid sharing mode. 
  32104.  
  32105.  
  32106. ΓòÉΓòÉΓòÉ 20.9. EDC5007 ΓòÉΓòÉΓòÉ
  32107.  
  32108. The buffering mode specified is not correct. 
  32109.  
  32110. errno Value: EBUFMODE 
  32111.  
  32112. The buffer mode was not correct.  Valid buffering modes are IOLBF, IOFBF, and 
  32113. IONBF. 
  32114.  
  32115. Recovery: Specify a valid buffering mode. 
  32116.  
  32117.  
  32118. ΓòÉΓòÉΓòÉ 20.10. EDC5008 ΓòÉΓòÉΓòÉ
  32119.  
  32120. A previous error occurred on the stream. 
  32121.  
  32122. errno Value: EERRSET 
  32123.  
  32124. A previous fatal error occurred on the stream and this is the first opportunity 
  32125. to report it. 
  32126.  
  32127. Recovery: Close the stream and retry the operation. 
  32128.  
  32129.  
  32130. ΓòÉΓòÉΓòÉ 20.11. EDC5009 ΓòÉΓòÉΓòÉ
  32131.  
  32132. The file is open. 
  32133.  
  32134. errno Value: EISOPEN 
  32135.  
  32136. The operation is not permitted on the file because a process has the file open 
  32137. in an incorrect sharing mode. 
  32138.  
  32139. Recovery: Close the file and retry the operation, or ensure the sharing modes 
  32140. are consistent. 
  32141.  
  32142.  
  32143. ΓòÉΓòÉΓòÉ 20.12. EDC5010 ΓòÉΓòÉΓòÉ
  32144.  
  32145. The file cannot be found. 
  32146.  
  32147. errno Value: ENOTEXIST 
  32148.  
  32149. The file specified cannot be found. Either the file name was not correctly 
  32150. specified, or the file has not been created. 
  32151.  
  32152. Recovery: Ensure the file name is correctly specified or create the file. 
  32153.  
  32154.  
  32155. ΓòÉΓòÉΓòÉ 20.13. EDC5011 ΓòÉΓòÉΓòÉ
  32156.  
  32157. This operation must be done before any reads, writes or repositions. 
  32158.  
  32159. errno Value: ENOTINIT 
  32160.  
  32161. Recovery: Correct the program logic. 
  32162.  
  32163.  
  32164. ΓòÉΓòÉΓòÉ 20.14. EDC5012 ΓòÉΓòÉΓòÉ
  32165.  
  32166. The stream pointer is NULL. 
  32167.  
  32168. errno Value: ENULLFCB 
  32169.  
  32170. The stream pointer must point to a valid stream. 
  32171.  
  32172. Recovery: Ensure the stream pointer points to a valid stream, and reopen the 
  32173. stream. 
  32174.  
  32175.  
  32176. ΓòÉΓòÉΓòÉ 20.15. EDC5013 ΓòÉΓòÉΓòÉ
  32177.  
  32178. Not enough memory is available to complete the operation. 
  32179.  
  32180. errno Value: EOUTOFMEM 
  32181.  
  32182. Recovery: Ensure that memory is being freed when it is no longer used, and that 
  32183. memory swapping is allowed. Use the _heapmin function to release unused memory 
  32184. from the heap. Stop large programs from running while the current application 
  32185. is being run. 
  32186.  
  32187.  
  32188. ΓòÉΓòÉΓòÉ 20.16. EDC5014 ΓòÉΓòÉΓòÉ
  32189.  
  32190. The specified buffer size is too small. 
  32191.  
  32192. errno Value: ESMALLBF 
  32193.  
  32194. Recovery: Specify a larger buffer for the file. 
  32195.  
  32196.  
  32197. ΓòÉΓòÉΓòÉ 20.17. EDC5016 ΓòÉΓòÉΓòÉ
  32198.  
  32199. The file already exists. 
  32200.  
  32201. errno Value: EEXIST 
  32202.  
  32203. An attempt was made to rename a file to an already existing file name. 
  32204.  
  32205. Recovery: Change the name of the existing file or of the new file. 
  32206.  
  32207.  
  32208. ΓòÉΓòÉΓòÉ 20.18. EDC5017 ΓòÉΓòÉΓòÉ
  32209.  
  32210. A unique file name cannot be generated. 
  32211.  
  32212. errno Value: ENOGEN 
  32213.  
  32214. A call to tmpnam or _tempnam failed because all unique file names have been 
  32215. used. 
  32216.  
  32217. Recovery: Close at least one temporary file. 
  32218.  
  32219.  
  32220. ΓòÉΓòÉΓòÉ 20.19. EDC5019 ΓòÉΓòÉΓòÉ
  32221.  
  32222. The seek operation is not valid for this stream. 
  32223.  
  32224. errno Value: ENOSEEK 
  32225.  
  32226. The stream is connected to a device that does not permit the seek operation. 
  32227.  
  32228. Recovery: Remove the seek operation or point the stream to a different device. 
  32229.  
  32230.  
  32231. ΓòÉΓòÉΓòÉ 20.20. EDC5020 ΓòÉΓòÉΓòÉ
  32232.  
  32233. The file position for the file is not valid. 
  32234.  
  32235. errno Value: EBADPOS 
  32236.  
  32237. The file position is not valid for a file positioning function. 
  32238.  
  32239. Recovery: Rewind the file or call fflush to clear any characters. Put the file 
  32240. back in the stream, and retry the operation. 
  32241.  
  32242.  
  32243. ΓòÉΓòÉΓòÉ 20.21. EDC5022 ΓòÉΓòÉΓòÉ
  32244.  
  32245. Attempted to seek to an invalid file position. 
  32246.  
  32247. errno Value: EBADSEEK 
  32248.  
  32249. The combination of starting point and offset values specified for the fseek 
  32250. function is not valid for the file, or an attempt was made to seek beyond the 
  32251. beginning of a binary or text file. 
  32252.  
  32253. Recovery: Ensure the values specified for fseek are valid. 
  32254.  
  32255.  
  32256. ΓòÉΓòÉΓòÉ 20.22. EDC5023 ΓòÉΓòÉΓòÉ
  32257.  
  32258. The file or directory specified cannot be found. 
  32259.  
  32260. errno Value: ENOENT 
  32261.  
  32262. Recovery: Ensure the path name and file name are specified correctly. Create 
  32263. the file or directory if necessary. 
  32264.  
  32265.  
  32266. ΓòÉΓòÉΓòÉ 20.23. EDC5024 ΓòÉΓòÉΓòÉ
  32267.  
  32268. The file or directory specified is read-only. 
  32269.  
  32270. errno Value: EACCESS 
  32271.  
  32272. The path name specifies a file or directory that cannot be written to. 
  32273.  
  32274. Recovery: Change the file name if necessary or remove the read-only attribute 
  32275. from the file or directory. 
  32276.  
  32277.  
  32278. ΓòÉΓòÉΓòÉ 20.24. EDC5025 ΓòÉΓòÉΓòÉ
  32279.  
  32280. Too many open files. 
  32281.  
  32282. errno Value: EMFILE 
  32283.  
  32284. Because too many files are open, the specified file cannot be opened to change 
  32285. its modification time. 
  32286.  
  32287. Recovery: Close some files. 
  32288.  
  32289.  
  32290. ΓòÉΓòÉΓòÉ 20.25. EDC5026 ΓòÉΓòÉΓòÉ
  32291.  
  32292. A command processor could not be found. 
  32293.  
  32294. errno Value: ENOCMD 
  32295.  
  32296. The command processor specified by the COMSPEC environment variable cannot be 
  32297. found, and CMD.EXE cannot be found in any of the directories specified by the 
  32298. PATH environment variable. 
  32299.  
  32300. Recovery: Ensure that the COMSPEC variable specifies a valid path and file name 
  32301. for the command processor, and/or that CMD.EXE exists in one of the directories 
  32302. specified by PATH. 
  32303.  
  32304.  
  32305. ΓòÉΓòÉΓòÉ 20.26. EDC5028 ΓòÉΓòÉΓòÉ
  32306.  
  32307. A read operation cannot immediately follow a write operation. 
  32308.  
  32309. errno Value: EGETANDPUT 
  32310.  
  32311. Recovery: Flush the stream or use one of the repositioning functions before 
  32312. doing a read operation. 
  32313.  
  32314.  
  32315. ΓòÉΓòÉΓòÉ 20.27. EDC5029 ΓòÉΓòÉΓòÉ
  32316.  
  32317. Attempted to read past end-of-file. 
  32318.  
  32319. errno Value: EPASTEOF 
  32320.  
  32321. Recovery: Reposition the file before reading. 
  32322.  
  32323.  
  32324. ΓòÉΓòÉΓòÉ 20.28. EDC5030 ΓòÉΓòÉΓòÉ
  32325.  
  32326. The file is not open for reading. 
  32327.  
  32328. errno Value: ENOTREAD 
  32329.  
  32330. Recovery: Close the file and reopen it in a mode that permits reading. 
  32331.  
  32332.  
  32333. ΓòÉΓòÉΓòÉ 20.29. EDC5031 ΓòÉΓòÉΓòÉ
  32334.  
  32335. Too many consecutive calls to ungetc. 
  32336.  
  32337. errno Value: ETOOMANYUNGETC 
  32338.  
  32339. The ungetc function is not guaranteed to work for consecutive calls. 
  32340.  
  32341. Recovery: Read the last ungetc character, or use one of the repositioning 
  32342. functions to clear the buffer. 
  32343.  
  32344.  
  32345. ΓòÉΓòÉΓòÉ 20.30. EDC5032 ΓòÉΓòÉΓòÉ
  32346.  
  32347. Cannot put EOF back to the stream. 
  32348.  
  32349. errno Value: EUNGETEOF 
  32350.  
  32351. The EOF character is not a valid parameter to ungetc or ungetch 
  32352.  
  32353. Recovery: Eliminate the ungetc or ungetch operation. 
  32354.  
  32355.  
  32356. ΓòÉΓòÉΓòÉ 20.31. EDC5033 ΓòÉΓòÉΓòÉ
  32357.  
  32358. Cannot put a character back to the stream immediately following a write 
  32359. operation on the stream. 
  32360.  
  32361. errno Value: EPUTUNGET 
  32362.  
  32363. The ungetc or ungetch function cannot be used immediately following a write 
  32364. operation. 
  32365.  
  32366. Recovery: Flush the stream or use one of the repositioning functions before 
  32367. using the unget operation. 
  32368.  
  32369.  
  32370. ΓòÉΓòÉΓòÉ 20.32. EDC5034 ΓòÉΓòÉΓòÉ
  32371.  
  32372. The process identifier specified for the child process is not valid. 
  32373.  
  32374. errno Value: ECHILD 
  32375.  
  32376. The child process does not exist, or the process identifier is not correct. 
  32377.  
  32378. Recovery: Make sure that the process identifier for the child process to be 
  32379. waited on is correct. 
  32380.  
  32381.  
  32382. ΓòÉΓòÉΓòÉ 20.33. EDC5035 ΓòÉΓòÉΓòÉ
  32383.  
  32384. The child process ended abnormally. 
  32385.  
  32386. errno Value: EINTR 
  32387.  
  32388. A trap, an unintercepted DosKill call or exception, or a hardware error 
  32389. occurred. 
  32390.  
  32391. Recovery: Check the code in the child process. 
  32392.  
  32393.  
  32394. ΓòÉΓòÉΓòÉ 20.34. EDC5036 ΓòÉΓòÉΓòÉ
  32395.  
  32396. The action code specified is not correct. 
  32397.  
  32398. errno Value: EINVAL 
  32399.  
  32400. Valid action codes for _cwait are WAIT_CHILD and WAIT_GRANDCHILD. 
  32401.  
  32402. Recovery: Specify a valid action code. 
  32403.  
  32404.  
  32405. ΓòÉΓòÉΓòÉ 20.35. EDC5037 ΓòÉΓòÉΓòÉ
  32406.  
  32407. Cannot run the specified file. 
  32408.  
  32409. errno Value: ENOEXEC 
  32410.  
  32411. The executable format of the file is not valid, or the file is not an 
  32412. executable file. 
  32413.  
  32414. Recovery: Ensure the file specified is a valid excutable file. 
  32415.  
  32416.  
  32417. ΓòÉΓòÉΓòÉ 20.36. EDC5038 ΓòÉΓòÉΓòÉ
  32418.  
  32419. Cannot start another process. 
  32420.  
  32421. errno Value: EAGAIN 
  32422.  
  32423. Another process cannot be created because it will exceed the maximum number of 
  32424. processes allowed by OS/2. 
  32425.  
  32426. Recovery: Close some of the other processes running. 
  32427.  
  32428.  
  32429. ΓòÉΓòÉΓòÉ 20.37. EDC5039 ΓòÉΓòÉΓòÉ
  32430.  
  32431. The stream specified is the wrong type for the operation. 
  32432.  
  32433. errno Value: EBADTYPE 
  32434.  
  32435. Recovery: Use the correct type of stream for the operation required. 
  32436.  
  32437.  
  32438. ΓòÉΓòÉΓòÉ 20.38. EDC5040 ΓòÉΓòÉΓòÉ
  32439.  
  32440. The file is not opened for writing. 
  32441.  
  32442. errno Value: ENOTWRITE 
  32443.  
  32444. The file may be opened in read mode. 
  32445.  
  32446. Recovery: Reopen the file with a file mode that allows the write operation. 
  32447.  
  32448.  
  32449. ΓòÉΓòÉΓòÉ 20.39. EDC5041 ΓòÉΓòÉΓòÉ
  32450.  
  32451. A write operation must not immediately follow a read operation. 
  32452.  
  32453. errno Value: EPUTANDGET 
  32454.  
  32455. Recovery: Flush the stream or use one of the repositioning functions before 
  32456. doing the write operation. 
  32457.  
  32458.  
  32459. ΓòÉΓòÉΓòÉ 20.40. EDC5042 ΓòÉΓòÉΓòÉ
  32460.  
  32461. The specified buffer length is too large. 
  32462.  
  32463. errno Value: ELARGEBF 
  32464.  
  32465. The size of the buffer must be in the range of a long int. 
  32466.  
  32467. Recovery: Specify a smaller buffer size. 
  32468.  
  32469.  
  32470. ΓòÉΓòÉΓòÉ 20.41. EDC5043 ΓòÉΓòÉΓòÉ
  32471.  
  32472. The file handle is not valid. 
  32473.  
  32474. errno Value: EBADF 
  32475.  
  32476. The file handle passed to _fstat must be recognized by the OS/2 system. 
  32477.  
  32478. Recovery: Specify a valid file handle. 
  32479.  
  32480.  
  32481. ΓòÉΓòÉΓòÉ 20.42. EDC5044 ΓòÉΓòÉΓòÉ
  32482.  
  32483. Cannot rename a file to a different device. 
  32484.  
  32485. errno Value: EXDEV 
  32486.  
  32487. A file cannot be renamed to a different drive or device. 
  32488.  
  32489. Recovery:Rename the file to a different name or copy the file to the new device 
  32490. and then rename it. 
  32491.  
  32492.  
  32493. ΓòÉΓòÉΓòÉ 20.43. EDC5045 ΓòÉΓòÉΓòÉ
  32494.  
  32495. There is no space left on the device. 
  32496.  
  32497. errno Value: ENOSPC 
  32498.  
  32499. There is not enough free space on the device to complete the requested 
  32500. operation. 
  32501.  
  32502. Recovery: Remove any files that are not needed from the device and try the 
  32503. operation again. 
  32504.  
  32505.  
  32506. ΓòÉΓòÉΓòÉ 20.44. EDC5046 ΓòÉΓòÉΓòÉ
  32507.  
  32508. An unrecognized exception occurred in a math routine. The control word has 
  32509. probably been changed. 
  32510.  
  32511. errno Value: EMATH 
  32512.  
  32513.  
  32514. ΓòÉΓòÉΓòÉ 20.45. EDC5047 ΓòÉΓòÉΓòÉ
  32515.  
  32516. The DLL specified cannot be found. 
  32517.  
  32518. errno Value: EMODNAME 
  32519.  
  32520. The DLL may not exist, or may not be specified in the LIBPATH environment 
  32521. variable. 
  32522.  
  32523. Recovery: Ensure the name is correct and is specified in the LIBPATH variable. 
  32524.  
  32525.  
  32526. ΓòÉΓòÉΓòÉ 20.46. EDC5049 ΓòÉΓòÉΓòÉ
  32527.  
  32528. The value specified for blksize or lrecl is too large. 
  32529.  
  32530. errno Value: EMAXATTR 
  32531.  
  32532. See fopen for the range of valid values for blksize and lrecl. 
  32533.  
  32534. Recovery: Specify valid values for blksize and lrecl. 
  32535.  
  32536.  
  32537. ΓòÉΓòÉΓòÉ 20.47. EDC5050 ΓòÉΓòÉΓòÉ
  32538.  
  32539. Error in reading the C Locale Description (CLD) file. 
  32540.  
  32541. errno Value: EREADERROR 
  32542.  
  32543. The CLD file specified in your DPATH variable may be damaged or have an 
  32544. incorrect format. 
  32545.  
  32546. Recovery: Ensure the DPATH variable points to a valid .CLD file. If the file is 
  32547. damaged, reinstall it. 
  32548.  
  32549.  
  32550. ΓòÉΓòÉΓòÉ 20.48. EDC5051 ΓòÉΓòÉΓòÉ
  32551.  
  32552. The value specified for blksize or lrecl conflicts with a previously set value. 
  32553.  
  32554. errno Value: EBADATTR 
  32555.  
  32556. The values for blksize and lrecl may have been set by both a ddname and by 
  32557. fopen. 
  32558.  
  32559. Recovery: Ensure the values for blksize and lrecl are consistent. 
  32560.  
  32561.  
  32562. ΓòÉΓòÉΓòÉ 20.49. EDC5060 ΓòÉΓòÉΓòÉ
  32563.  
  32564. OS/2 returned error code &1. 
  32565.  
  32566. errno Value: EOS2ERR 
  32567.  
  32568. An operating system call returned the error code given. 
  32569.  
  32570. Recovery: Refer to the OS/2 documentation under the error code given. 
  32571.  
  32572.  
  32573. ΓòÉΓòÉΓòÉ 20.50. EDC5090 ΓòÉΓòÉΓòÉ
  32574.  
  32575. Complex: log: singularity: log((0,0)). 
  32576.  
  32577. An attempt was made to use the complex 0 in the log function, which is 
  32578. undefined. 
  32579.  
  32580. Recovery: Do not try to use the complex 0 with the log function. 
  32581.  
  32582.  
  32583. ΓòÉΓòÉΓòÉ 20.51. EDC5091 ΓòÉΓòÉΓòÉ
  32584.  
  32585. Iostream: Error in form(): too many characters. 
  32586.  
  32587. The form function is used only for compatibility with earlier versions of the 
  32588. I/O Stream Library. It is not intended for use with new C++ code. As a result 
  32589. internal conversion buffer has been overwritten. 
  32590.  
  32591. Recovery: Reduce the number of conversion specifiers to be passed on to form. 
  32592.  
  32593.  
  32594. ΓòÉΓòÉΓòÉ 20.52. EDC5098 ΓòÉΓòÉΓòÉ
  32595.  
  32596. The floating-point conversion code is not linked in. 
  32597.  
  32598. An attempt was made to print a non-floating-point variable using a 
  32599. floating-point format specifier. 
  32600.  
  32601. Recovery: Ensure the correct format specifier is used for the type of variable 
  32602. to be printed. 
  32603.  
  32604.  
  32605. ΓòÉΓòÉΓòÉ 20.53. EDC5099 ΓòÉΓòÉΓòÉ
  32606.  
  32607. Internal library error in function: &1, line: &2. 
  32608.  
  32609. An internal library error has occurred. 
  32610.  
  32611. Recovery: Contact your IBM Service Representative. 
  32612.  
  32613.  
  32614. ΓòÉΓòÉΓòÉ 20.54. EDC5100 ΓòÉΓòÉΓòÉ
  32615.  
  32616. Not enough storage is available to complete initialization. 
  32617.  
  32618. Recovery: Stop large programs from running while the current application is 
  32619. being run. 
  32620.  
  32621.  
  32622. ΓòÉΓòÉΓòÉ 20.55. EDC5101 ΓòÉΓòÉΓòÉ
  32623.  
  32624. Assertion failed: &1, file: &2, line: &3. 
  32625.  
  32626. This is the message generated by the assert macro. 
  32627.  
  32628. Recovery: Correct the error that caused the assertion to fail. 
  32629.  
  32630.  
  32631. ΓòÉΓòÉΓòÉ 20.56. Exception Messages ΓòÉΓòÉΓòÉ
  32632.  
  32633. EDC5101 to EDC5145 are generated when an unhandled or incorrectly handled 
  32634. exception occurs, and are displayed in the resulting machine-state dump. 
  32635. Exceptions are explained in more detail in the OS/2 documentation. For more 
  32636. information on these messages, see the section on exception handling in the 
  32637. Programming Guide. 
  32638.  
  32639.  
  32640. ΓòÉΓòÉΓòÉ 20.57. EDC5102 ΓòÉΓòÉΓòÉ
  32641.  
  32642. Integer Division by Zero exception occurred at EIP = &1 on thread &2. 
  32643.  
  32644. An Integer Division by Zero exception occurred at the location indicated. 
  32645.  
  32646. Recovery: Correct the code and recompile. 
  32647.  
  32648.  
  32649. ΓòÉΓòÉΓòÉ 20.58. EDC5103 ΓòÉΓòÉΓòÉ
  32650.  
  32651. Invalid Opcode exception occurred at EIP = &1 on thread &2. 
  32652.  
  32653. An Invalid Opcode exception occurred at the location indicated. 
  32654.  
  32655. Recovery: Correct the code and recompile. 
  32656.  
  32657.  
  32658. ΓòÉΓòÉΓòÉ 20.59. EDC5104 ΓòÉΓòÉΓòÉ
  32659.  
  32660. General Protection Fault exception occurred at EIP = &1 on thread &2. 
  32661.  
  32662. A General Protection Fault exception occurred at the location indicated. 
  32663.  
  32664. Recovery: Correct the code and recompile. 
  32665.  
  32666.  
  32667. ΓòÉΓòÉΓòÉ 20.60. EDC5106 ΓòÉΓòÉΓòÉ
  32668.  
  32669. Guard Page Allocation Failure exception occurred at EIP = &1 on thread &2. 
  32670.  
  32671. The compiler has run out of stack space. 
  32672.  
  32673. Recovery: Allocate more stack space and recompile. 
  32674.  
  32675.  
  32676. ΓòÉΓòÉΓòÉ 20.61. EDC5110 ΓòÉΓòÉΓòÉ
  32677.  
  32678. Overflow exception occurred at EIP = &1 on thread &2. 
  32679.  
  32680. An Overflow exception occurred at the location indicated. 
  32681.  
  32682. Recovery: Correct the code and recompile. 
  32683.  
  32684.  
  32685. ΓòÉΓòÉΓòÉ 20.62. EDC5111 ΓòÉΓòÉΓòÉ
  32686.  
  32687. Bound exception occurred at EIP = &1 on thread &2. 
  32688.  
  32689. A Bound exception occurred at the location indicated. 
  32690.  
  32691. Recovery: Correct the code and recompile. 
  32692.  
  32693.  
  32694. ΓòÉΓòÉΓòÉ 20.63. EDC5112 ΓòÉΓòÉΓòÉ
  32695.  
  32696. Exception number 0x&2 occurred at EIP = &1 on thread &2. 
  32697.  
  32698. The exception identified by the number given occurred at the location 
  32699. indicated. 
  32700.  
  32701. Recovery: Correct the code and recompile. 
  32702.  
  32703.  
  32704. ΓòÉΓòÉΓòÉ 20.64. EDC5113 ΓòÉΓòÉΓòÉ
  32705.  
  32706. Exception was marked as non-continuable. 
  32707.  
  32708. The operating system will not allow the exception to be continued. This is an 
  32709. informational message that may accompany an initial exception message. 
  32710.  
  32711.  
  32712. ΓòÉΓòÉΓòÉ 20.65. EDC5114 ΓòÉΓòÉΓòÉ
  32713.  
  32714. Exception occurred handling a prior exception. 
  32715.  
  32716. The exception occurred inside the exception handler. This is an informational 
  32717. message that may accompany an initial exception message. 
  32718.  
  32719.  
  32720. ΓòÉΓòÉΓòÉ 20.66. EDC5115 ΓòÉΓòÉΓòÉ
  32721.  
  32722. Process terminating. 
  32723.  
  32724. Confirmational message generated by the exception handler. This is an 
  32725. informational message that may accompany an initial exception message. 
  32726.  
  32727.  
  32728. ΓòÉΓòÉΓòÉ 20.67. EDC5116 ΓòÉΓòÉΓòÉ
  32729.  
  32730. Register dump at point of exception: 
  32731.  
  32732. This message indicates a machine-dump was performed. The machine state follows 
  32733. and may consist of any combination of the messages EDC5117-EDC0121 and 
  32734. EDC5124-EDC0130. 
  32735.  
  32736.  
  32737. ΓòÉΓòÉΓòÉ 20.68. EDC5117 ΓòÉΓòÉΓòÉ
  32738.  
  32739. EAX = &1   EBX = &2  ECX = &3   EDX = &4 
  32740.  
  32741. These are the values of the registers at the time of the exception. 
  32742.  
  32743.  
  32744. ΓòÉΓòÉΓòÉ 20.69. EDC5118 ΓòÉΓòÉΓòÉ
  32745.  
  32746. EBP = &1   EDI = &2  ESI = &3   ESP = &4 
  32747.  
  32748. These are the values of the registers at the time of the exception. 
  32749.  
  32750.  
  32751. ΓòÉΓòÉΓòÉ 20.70. EDC5119 ΓòÉΓòÉΓòÉ
  32752.  
  32753. CS =   &1  CSLIM = &2  DS =   &3  DSLIM = &4 
  32754.  
  32755. These are the values of the registers at the time of the exception. 
  32756.  
  32757.  
  32758. ΓòÉΓòÉΓòÉ 20.71. EDC5120 ΓòÉΓòÉΓòÉ
  32759.  
  32760. ES =   &1  ESLIM = &2  FS =   &3  FSLIM = &4 
  32761.  
  32762. These are the values of the registers at the time of the exception. 
  32763.  
  32764.  
  32765. ΓòÉΓòÉΓòÉ 20.72. EDC5121 ΓòÉΓòÉΓòÉ
  32766.  
  32767. GS =   &1  GSLIM = &2  SS =   &3  SSLIM = &4 
  32768.  
  32769. These are the values of the registers at the time of the exception. 
  32770.  
  32771.  
  32772. ΓòÉΓòÉΓòÉ 20.73. EDC5122 ΓòÉΓòÉΓòÉ
  32773.  
  32774. Failed to register exception handler. 
  32775.  
  32776. A severe operating system error has occurred. 
  32777.  
  32778. Recovery: Contact your IBM Service Representative 
  32779.  
  32780.  
  32781. ΓòÉΓòÉΓòÉ 20.74. EDC5123 ΓòÉΓòÉΓòÉ
  32782.  
  32783. Invalid buffer passed to longjmp(). 
  32784.  
  32785. The buffer passed to the longjmp function is not valid. 
  32786.  
  32787. Recovery: Correct the code and recompile. 
  32788.  
  32789.  
  32790. ΓòÉΓòÉΓòÉ 20.75. EDC5124 ΓòÉΓòÉΓòÉ
  32791.  
  32792. NPX Environment: 
  32793.  
  32794. This is the state of the NPX at the time the exception occurred.  It may be 
  32795. accompanied by any combination of the messages EDC5125-EDC0130. 
  32796.  
  32797.  
  32798. ΓòÉΓòÉΓòÉ 20.76. EDC5125 ΓòÉΓòÉΓòÉ
  32799.  
  32800. CW = &1    TW = &2  IP = &4:&3 
  32801.  
  32802. These are the values of the control word, tag word, and instruction pointer in 
  32803. the NPX at the time the exception occurred. 
  32804.  
  32805.  
  32806. ΓòÉΓòÉΓòÉ 20.77. EDC5126 ΓòÉΓòÉΓòÉ
  32807.  
  32808. SW = &1  OPCODE = &2  OP = &4:&3 
  32809.  
  32810. These are the values of the status word, opcode, and the operand address in the 
  32811. NPX at the time the exception occurred. 
  32812.  
  32813.  
  32814. ΓòÉΓòÉΓòÉ 20.78. EDC5127 ΓòÉΓòÉΓòÉ
  32815.  
  32816. NPX Stack: 
  32817.  
  32818. This is the state of the NPX stack at the time the exception occurred. 
  32819.  
  32820.  
  32821. ΓòÉΓòÉΓòÉ 20.79. EDC5128 ΓòÉΓòÉΓòÉ
  32822.  
  32823. ST(&1): exponent = &3 significand = &2 &4 &5 
  32824.  
  32825. One copy of this message appears for each valid stack entry in the NPX. 
  32826.  
  32827.  
  32828. ΓòÉΓòÉΓòÉ 20.80. EDC5129 ΓòÉΓòÉΓòÉ
  32829.  
  32830. Exception occurred in C library routine called from EIP = &1. 
  32831.  
  32832. The exception occurred within a C library function. In this case, the EIP given 
  32833. is the instruction pointer in the user program where the call to the function 
  32834. occurred. This is an informational message that may accompany an initial 
  32835. exception message. 
  32836.  
  32837.  
  32838. ΓòÉΓòÉΓòÉ 20.81. EDC5130 ΓòÉΓòÉΓòÉ
  32839.  
  32840. No valid stack entries. 
  32841.  
  32842. There is no valid data in the NPX stack. 
  32843.  
  32844.  
  32845. ΓòÉΓòÉΓòÉ 20.82. EDC5131 ΓòÉΓòÉΓòÉ
  32846.  
  32847. Privileged Opcode exception occurred at EIP = &1 on thread &2. 
  32848.  
  32849. A Privileged Opcode exception occurred at the location indicated. 
  32850.  
  32851. Recovery: Correct the code and recompile. 
  32852.  
  32853.  
  32854. ΓòÉΓòÉΓòÉ 20.83. EDC5132 ΓòÉΓòÉΓòÉ
  32855.  
  32856. Data Misalignment Exception occurred at EIP = &1 on thread &2. 
  32857.  
  32858. A Data Misalignment Exception occurred at the location indicated. 
  32859.  
  32860. Recovery: Correct the code and recompile. 
  32861.  
  32862.  
  32863. ΓòÉΓòÉΓòÉ 20.84. EDC5133 ΓòÉΓòÉΓòÉ
  32864.  
  32865. Floating Point Denormal Operand exception occurred at EIP = &1 on thread &2. 
  32866.  
  32867. A Floating Point Denormal Operand exception occurred at the location indicated. 
  32868.  
  32869. Recovery: Correct the code and recompile. 
  32870.  
  32871.  
  32872. ΓòÉΓòÉΓòÉ 20.85. EDC5134 ΓòÉΓòÉΓòÉ
  32873.  
  32874. Floating Point Divide by Zero exception occurred at EIP = &1 on thread &2. 
  32875.  
  32876. A Floating Point Division by Zero exception occurred at the location indicated. 
  32877.  
  32878. Recovery: Correct the code and recompile. 
  32879.  
  32880.  
  32881. ΓòÉΓòÉΓòÉ 20.86. EDC5135 ΓòÉΓòÉΓòÉ
  32882.  
  32883. Floating Point Precision exception occurred at EIP = &1 on thread &2. 
  32884.  
  32885. A Floating Point Precision exception occurred at the location indicated. 
  32886.  
  32887. Recovery: Correct the code and recompile. 
  32888.  
  32889.  
  32890. ΓòÉΓòÉΓòÉ 20.87. EDC5136 ΓòÉΓòÉΓòÉ
  32891.  
  32892. Floating Point Invalid Operation exception occurred at EIP = &1 on thread &2. 
  32893.  
  32894. A Floating Point Invalid Operation exception occurred at the location 
  32895. indicated. 
  32896.  
  32897. Recovery: Correct the code and recompile. 
  32898.  
  32899.  
  32900. ΓòÉΓòÉΓòÉ 20.88. EDC5137 ΓòÉΓòÉΓòÉ
  32901.  
  32902. Floating Point Overflow exception occurred at EIP = &1 on thread &2. 
  32903.  
  32904. A Floating Point Overflow exception occurred at the location indicated. 
  32905.  
  32906. Recovery: Correct the code and recompile. 
  32907.  
  32908.  
  32909. ΓòÉΓòÉΓòÉ 20.89. EDC5138 ΓòÉΓòÉΓòÉ
  32910.  
  32911. Floating Point Stack Check exception occurred at EIP = &1 on thread &2. 
  32912.  
  32913. A Floating Point Stack Check exception occurred at the location indicated. 
  32914.  
  32915. Recovery: Correct the code and recompile. 
  32916.  
  32917.  
  32918. ΓòÉΓòÉΓòÉ 20.90. EDC5139 ΓòÉΓòÉΓòÉ
  32919.  
  32920. Floating Point Underflow exception occurred at EIP = &1 on thread &2. 
  32921.  
  32922. A Floating Point Underflow exception occurred at the location indicated. 
  32923.  
  32924. Recovery: Correct the code and recompile. 
  32925.  
  32926.  
  32927. ΓòÉΓòÉΓòÉ 20.91. EDC5140 ΓòÉΓòÉΓòÉ
  32928.  
  32929. In Page exception occurred at EIP = &1 on thread &2. 
  32930.  
  32931. An In Page exception occurred at the location indicated. 
  32932.  
  32933. Recovery: Correct the code and recompile. 
  32934.  
  32935.  
  32936. ΓòÉΓòÉΓòÉ 20.92. EDC5141 ΓòÉΓòÉΓòÉ
  32937.  
  32938. Attempt to continue unrecoverable exception occurred at EIP = &1 on thread &2. 
  32939.  
  32940. The exception handler tried to continue an exception that the operating system 
  32941. considered noncontinuable at the location indicated. 
  32942.  
  32943. Recovery: Correct the code and recompile. 
  32944.  
  32945.  
  32946. ΓòÉΓòÉΓòÉ 20.93. EDC5142 ΓòÉΓòÉΓòÉ
  32947.  
  32948. Invalid Disposition exception occurred at EIP = &1 on thread &2. 
  32949.  
  32950. An Invalid Disposition exception occurred at the location indicated. 
  32951.  
  32952. Recovery: Correct the code and recompile. 
  32953.  
  32954.  
  32955. ΓòÉΓòÉΓòÉ 20.94. EDC5143 ΓòÉΓòÉΓòÉ
  32956.  
  32957. Invalid Lock Sequence exception occurred at EIP = &1 on thread &2. 
  32958.  
  32959. An Invalid Lock Sequence exception occurred at the location indicated. 
  32960.  
  32961. Recovery: Correct the code and recompile. 
  32962.  
  32963.  
  32964. ΓòÉΓòÉΓòÉ 20.95. EDC5144 ΓòÉΓòÉΓòÉ
  32965.  
  32966. Bad Stack exception occurred at EIP = &1 on thread &2. 
  32967.  
  32968. A Bad Stack exception occurred at the location indicated. 
  32969.  
  32970. Recovery: Correct the code and recompile. 
  32971.  
  32972.  
  32973. ΓòÉΓòÉΓòÉ 20.96. EDC5145 ΓòÉΓòÉΓòÉ
  32974.  
  32975. Invalid Unwind Target exception occurred at EIP = &1 on thread &2. 
  32976.  
  32977. An Invalid Unwind Target exception occurred at the location indicated.  A 
  32978. possible cause is that the jmp_buf buffer supplied to the longjmp function was 
  32979. not valid. 
  32980.  
  32981. Recovery: Correct the code and recompile. 
  32982.  
  32983.  
  32984. ΓòÉΓòÉΓòÉ 20.97. EDC5146 ΓòÉΓòÉΓòÉ
  32985.  
  32986. Invalid attempt to access storage location &1. 
  32987.  
  32988. This message accompanies an exception message and gives the address of the 
  32989. storage location that caused the exception to occur. 
  32990.  
  32991.  
  32992. ΓòÉΓòÉΓòÉ 20.98. EDC5147 ΓòÉΓòÉΓòÉ
  32993.  
  32994. Exception = &1 occurred at EIP = &2. 
  32995.  
  32996. The exception identified by the number given occured at the location indicated. 
  32997.  
  32998. Recovery: Correct the code and recompile. 
  32999.  
  33000.  
  33001. ΓòÉΓòÉΓòÉ 20.99. EDC5150 ΓòÉΓòÉΓòÉ
  33002.  
  33003. An internal data structure starting at address &1 was overwritten. 
  33004.  
  33005. An internal data structure that is allocated from a separate page of memory has 
  33006. been overwritten. 
  33007.  
  33008. Recovery: Correct the code so you do not overwrite the structure and recompile. 
  33009.  
  33010.  
  33011. ΓòÉΓòÉΓòÉ 20.100. EDC5151 ΓòÉΓòÉΓòÉ
  33012.  
  33013. The invalid memory block address &1 was passed in at line &3 of &2. 
  33014.  
  33015. The free or realloc function was passed a pointer that did not point to a 
  33016. memory block allocated by malloc, calloc, or realloc. 
  33017.  
  33018. Recovery: Allocate the memory block with malloc, calloc, or realloc before 
  33019. passing the pointer to free or realloc. 
  33020.  
  33021.  
  33022. ΓòÉΓòÉΓòÉ 20.101. EDC5152 ΓòÉΓòÉΓòÉ
  33023.  
  33024. Memory was overwritten before the allocated memory block which starts at 
  33025. address &1. 
  33026.  
  33027. Memory immediately before an allocated memory block has been overwritten.  This 
  33028. message is accompanied by the first eight bytes of the memory block and the 
  33029. file name and line number where the memory block was allocated, if available. 
  33030.  
  33031. Recovery: Correct the code and recompile. 
  33032.  
  33033.  
  33034. ΓòÉΓòÉΓòÉ 20.102. EDC5153 ΓòÉΓòÉΓòÉ
  33035.  
  33036. The file name and line number are not available. 
  33037.  
  33038. The file name and line number where the memory block was allocated or freed are 
  33039. not available because too much memory was overwritten.  This message 
  33040. accompanies other debug memory management messages. 
  33041.  
  33042.  
  33043. ΓòÉΓòÉΓòÉ 20.103. EDC5154 ΓòÉΓòÉΓòÉ
  33044.  
  33045. Memory was overwitten after the allocated memory block which starts at address 
  33046. &1. 
  33047.  
  33048. Memory immediately after an allocated memory block has been overwritten.  This 
  33049. message is accompanied by the first eight bytes of the memory block and the 
  33050. file name and line number where the memory block was allocated, if available. 
  33051.  
  33052. Recovery: Correct the code and recompile. 
  33053.  
  33054.  
  33055. ΓòÉΓòÉΓòÉ 20.104. EDC5155 ΓòÉΓòÉΓòÉ
  33056.  
  33057. This memory block was freed at line number &1 in &2. 
  33058.  
  33059. This message accompanies messages about overwriting a free memory block.  It 
  33060. indicates the file name and line number where the block was freed. 
  33061.  
  33062.  
  33063. ΓòÉΓòÉΓòÉ 20.105. EDC5156 ΓòÉΓòÉΓòÉ
  33064.  
  33065. The first eight bytes of the memory block (in hex) are: &1. 
  33066.  
  33067. The first eight bytes of the memory block are given to help you determine what 
  33068. the block is or was used for. This message accompanies other debug memory 
  33069. management messages. 
  33070.  
  33071.  
  33072. ΓòÉΓòÉΓòÉ 20.106. EDC5157 ΓòÉΓòÉΓòÉ
  33073.  
  33074. The free memory block which starts at address &1 has been accessed. 
  33075.  
  33076. An attempt was made to access the memory block at the address given, when the 
  33077. block had already been freed. 
  33078.  
  33079. Recovery: Correct the code to allocate the memory location, or do not free the 
  33080. memory block before you access it. 
  33081.  
  33082.  
  33083. ΓòÉΓòÉΓòÉ 20.107. EDC5158 ΓòÉΓòÉΓòÉ
  33084.  
  33085. Memory was overwritten before the free memory block which starts at address &1. 
  33086.  
  33087. Memory immediately before a freed memory block has been overwritten.  This 
  33088. message is accompanied by the first eight bytes of the memory block, and the 
  33089. file name and line number where the memory block was freed, if available. 
  33090.  
  33091. Recovery: Correct the code and recompile. 
  33092.  
  33093.  
  33094. ΓòÉΓòÉΓòÉ 20.108. EDC5159 ΓòÉΓòÉΓòÉ
  33095.  
  33096. Memory was overwritten at the end of the free memory block which starts at 
  33097. address &1. 
  33098.  
  33099. Memory immediately after a freed memory block has been overwritten.  This 
  33100. message is accompanied by the first eight bytes of the memory block, and the 
  33101. file name and line number where the memory block was freed, if available. 
  33102.  
  33103. Recovery: Correct the code and recompile. 
  33104.  
  33105.  
  33106. ΓòÉΓòÉΓòÉ 20.109. EDC5160 ΓòÉΓòÉΓòÉ
  33107.  
  33108. Could not allocate memory for internal data structures. 
  33109.  
  33110. There is not enough memory available. 
  33111.  
  33112. Recovery: Ensure that memory is being freed when it is no longer used, and that 
  33113. memory swapping is allowed. Use the _heapmin function to release unused memory 
  33114. from the heap. Stop large programs from running while the current application 
  33115. is being run. 
  33116.  
  33117.  
  33118. ΓòÉΓòÉΓòÉ 20.110. EDC5161 ΓòÉΓòÉΓòÉ
  33119.  
  33120. Could not register exception handler for memory access violations. 
  33121.  
  33122. A severe operating system error has occurred. 
  33123.  
  33124. Recovery: Contact your IBM Service Representative. 
  33125.  
  33126.  
  33127. ΓòÉΓòÉΓòÉ 20.111. EDC5163 ΓòÉΓòÉΓòÉ
  33128.  
  33129. START OF DUMP OF ALLOCATED MEMORY BLOCKS 
  33130.  
  33131. This message indicates the start of the information produced by the 
  33132. _dump_allocated function. 
  33133.  
  33134.  
  33135. ΓòÉΓòÉΓòÉ 20.112. EDC5164 ΓòÉΓòÉΓòÉ
  33136.  
  33137. END OF DUMP OF ALLOCATED MEMORY BLOCKS 
  33138.  
  33139. This message indicates the start of the information produced by the 
  33140. _dump_allocated function. 
  33141.  
  33142.  
  33143. ΓòÉΓòÉΓòÉ 20.113. EDC5165 ΓòÉΓòÉΓòÉ
  33144.  
  33145. Address: &1    Size: &2 (&3) 
  33146.  
  33147. This message is produced by the _dump_allocated function. It gives the address 
  33148. and size of the allocated memory blocks. 
  33149.  
  33150. Recovery: 
  33151.  
  33152.  
  33153. ΓòÉΓòÉΓòÉ 20.114. EDC5166 ΓòÉΓòÉΓòÉ
  33154.  
  33155. This memory block was (re)allocated at line number &1 in &2. 
  33156.  
  33157. This message accompanies messages about overwriting memory immediately before 
  33158. or after an allocated memory block.  It indicates the file name and line number 
  33159. where the memory block was allocated or reallocated. 
  33160.  
  33161.  
  33162. ΓòÉΓòÉΓòÉ 20.115. EDC5167 ΓòÉΓòÉΓòÉ
  33163.  
  33164. Memory contents: 
  33165.  
  33166. This message is produced by the _dump_allocated function. It gives the contents 
  33167. of the allocated memory blocks.